venerdì 21 settembre 2018
Home / Corsi / Corso Python / MeArm: Comandiamo il braccio robot con Python

MeArm: Comandiamo il braccio robot con Python

Avete acquistato un MeArm e avete seguito le indicazioni della prima parte di questa guida per assemblarlo e calibrare i servomotori?
Bene! Allora non vedete l’ora di far muovere il vostro nuovo braccio robotico! Magari con Python!

Abilitiamo I2C

La scheda di controllo, utilizzerà il protocollo I2C per comunicare con Raspberry Pi, quindi dobbiamo innanzitutto abilitare quest’ultimo.
Ecco la procedura per Raspbian, per altre distribuzioni che sono prive di raspi-config, la procedura sarà differente, comunque non è difficile trovare come fare, in rete.

Passo 1 – abilitare interfaccia I2C – primo metodo

Dal Terminale, digitare: sudo raspi-config
Dal menù di raspi-config, scegliete “5 – Interfacing Options”:

Poi, Selezionate l’opzione “I2C” e attivate “Select”.

Selezionate e attivate “Yes”

Ora “OK”

Vi verrà po chiesto di riavviare. Anche qui “Yes”

Passo 1 – abilitare interfaccia I2C – secondo metodo

Oppure, usando lo strumento grafico in Raspbian “Raspberry Pi Configuration”. Lo trovate in Menu-Preferences-Raspberry Pi Configuration. Selezionare la scheda interfaces e abilitare da lì I2C:

Passo 2 – utilities per Python

Siccome andremo a usare I2C con Python, è bene installare quanto segue:
sudo apt-get update
sudo apt-get install -y python-smbus i2c-tools

Passo 3- spegnimento

Spegnere ora il Raspberry Pi con
sudo shutdown now Alla riaccensione l’hardware I2C sarà riconosciuto e gestibile da Python.

Collegamento

Prima di passare al codice, c’è ancora qualcosa di “fisico” da fare: il collegamento del Raspberry Pi ai servomotori. Anche se un solo servomotore per volta è possibile alimentarlo con i +5V del GPIO, qui parliamo di 4 servomotori in contemporanea, quindi è necessaria una alimentazione esterna per fornire tutta la corrente necessaria (un alimentatore da 6V DC che fornisca almeno 2A).

Ne esistono principalmente di due tipi, molto simili: la versione “HAT”, cioè da innestare sul GPIO, e una versione più compatta ed economica, da cablare manualmente, che ho preferito utilizzare sullo Zero che ho usato per questa prova. Il funzionamento è comunque identico.


I2CPWMAdafruit

Queste schede, collegare tramite il bus I2C, aggiungono delle uscite PWM e hanno un ingresso per un alimentatore dedicato separato.
Non vi sono dubbi su come si colleghi quella con zoccolo per il GPIO (basta innestarla), mentre la versione più compatta, va collegata come segue:

Raspberry Pi Scheda PCA9685
GND GND
DE
BCM3 – Pin 5 – SCL SCL
BCM2 – Pin 3 – SDA SDA
3V3 – Pin 1 VCC
V+

V+ è l’alimentazione per i servomotori, non collegatela, perché useremo un alimentatore esterno (sopratutto se userete, come me, un alimentatore da 6V). E’ invece importante che alimentatore e Raspberry condividano la massa, quindi colleghiamo il GND.

I servomotori andranno collegati alla scheda aggiuntiva, in questo ordine (con la scheda orientata come in foto, l’uscita PWM 0 è costituita dai primi 3 pin in verticale a sinistra, poi 1, 2, 3..):

  • Uscita PWM 0 = servo di rotazione della base
  • Uscita PWM 1 = servo del “gomito” del braccio
  • Uscita PWM 2 = servo della “spalla” del braccio
  • Uscita PWM 3 = servo della pinza

Installiamo la libreria di supporto

Sempre dal Terminale:
sudo apt-get install git build-essential python-dev
cd ~
git clone https://github.com/adafruit/Adafruit_Python_PCA9685.git
cd Adafruit_Python_PCA9685
sudo python setup.py install

o se volete usare Python 3, l’ultima riga diventa
sudo python3 setup.py install

Questa libreria consentirà di utilizzare, dentro il vostro script Python, le uscite PWM della scheda aggiuntiva con PCA9685. Perché funzioni, quindi, la libreria deve essere presente nella stessa directory dello script .py, o in alternativa, essere messa in una delle cartelle del path dove Python va a cercarsi le librerie.

Lo script Python

Utilizzeremo Python, per comandare i servomotori e dare vita al nostro braccio robotizzato. Purtroppo, utilizzando una scheda aggiuntiva, non ho potuto utilizzare la mia amata libreria gpiozero, e mi sono arrangiato con altro..
Per rilevare la pressione dei tasti, ho scelto infatti di usare Pygame, la grande libreria Pyhton, dedicata alla realizzazione di giochi e eventi interattivi.
Ecco lo script di base:

Descrizione

Lanciando il programma, verrà impostata una finestra PyGame, serve che sia attiva per fare in modo che il programma accetti l’input da tastiera, quindi potrebbe essere necessario cliccarla.
Ora avrete la possibilità di muovere e afferrare piccoli oggetti con il vostro braccio, tramite la pressione dei tasti A, D, W, S, I, K, N, M, comandando direttamente i servomotori.

Divertente, vero? Se qualcosa non funziona come vi aspettate, analizziamo il programma, in modo che sapete dove, eventualmente, modificare.

Dopo aver importato le librerie necessarie e impostato i servomotori, viene stampata una piccola legenda dei tasti.
Viene poi impostata l’istanza PyGame, e settate le posizioni iniziali per i servomotori. la lista var indica la variazione della posizione dei vari servomotori (da var[0] a var[3]), con impostazione iniziale a zero).
Vengono poi settati gli angoli minimi e massimi entro cui i servomotori devono lavorare (fine corsa).
Il primo ciclo for, muove i servomotori nella posizione iniziale.
Viene settato poi il “passo”, cioè la misura dell’ incremento per ogni pressione di tasto.
Il ciclo While si occupa di recepire gli input da tastiera, e associarci la variazione di posizione relativa. Occorre controllare sia quando il tasto viene premuto, che quando viene rilasciato (per fermare, di conseguenza, il servomotore relativo).

Il ciclo for, come prima, si occupa di muovere, effettivamente, i servomotori, a seconda delle variazioni “collezionate” poco sopra, dipendenti dalla pressione dei tasti.
Le ultime 3 righe, servono a chiudere l’istanza PyGame e fermare i servomotori (che altrimenti restano sempre alimentati, e con le micro-variazioni dovute alle spurie, si possono surriscaldare).

Supporto Joyistick

Aggiungiamo ora il supporto per joystick e joypad USB, visto che già stiamo utilizzando PyGame, e non costa molto sforzo in più:

Descrizione

Noterete le righe in più necessarie per creare l’istanza joystick, e gestirne gli input. E’ più semplice dei tasti: direzioni e tasti sul joystick/joypad vengono viste come variazioni numeriche di alcuni registri, che, a differenza dei tasti della tastiera, vengono aggiornati in tempo reale per pressione e rilascio.
La variabile joy tiene nota se il joystick USB è collegato o meno, e di conseguenza abilita o meno la parte di codice preposta alla sua “lettura”.

Il codice è scritto per permettere l’uso contemporaneo di tastiera e joystick.
Come “plus” ho aggiunto che alla pressione del tasto 8 del joystick (nel mio caso, un joypad in stile NES, corrisponde al tasto “select”) il programma venga terminato.

Miglioramenti

Fino a ora abbiamo comandato il nostro braccio robotico azionando direttamente i vari servomotori. Nel senso che ogni tasto o direzione è invariabilmente collegato a quel servomotore. In realtà, quando noi allunghiamo un braccio per prendere un oggetto, non pensiamo quali singoli muscoli dobbiamo azionare e in che direzione: guardiamo l’oggetto, e stendiamo il braccio verso di lui. Il nostro cervello traduce quella volontà in una serie di comandi ai muscoli (almeno 4 o più) che muovendosi coordinati, permettono alla mano di percorrere in aria il percorso più breve verso l’oggetto, il tutto con un movimento coordinato che appare fluido.
Non sarebbe figo ottenere più o meno lo stesso, anche con un braccio robotico, con Raspberry che faccia il cervello che traduce una direzione in angoli da dare ai vari servomotori? Si può, e il processo che ci consente di farlo si chiama cinematica inversa.

Impostando gli angoli e tenendo conto della lunghezza dei vario spezzoni del braccio, infatti, è possibile calcolare gli angoli necessari per ottenere una certa posizione tridimensionale della pinza alla punta del braccio.
Una cosa non ho mai digerito, fin dai tempi della scuola: la trigonometria. Bè, anche i logaritmi e i sistemi, a dire il vero, giusto per restare nello stesso campo d’azione, ma la trigonometria è quella che più di tutto, in barba al famoso tormentone “ma quando lo userò mai nella vita reale?”, è tornata di prepotenza nella mia vita e con cui ho dovuto fare i conti molto più spesso di quanto mi piaccia ammettere, che sia stato per l’elettrotecnica o per la programmazione, persino nel lavoro!.

Dopo un numero indecente di notti insonni senza quasi alcun risultato utile, mi pongo finalmente la domanda che bisognerebbe porsi prima di imbarcarsi in qualsiasi progetto: “possibile che qualcuno non lo abbia già fatto?”
E infatti sì, eccola lì. Una libreria bella e pronta per utilizzare la cinematica inversa con il MeArm, e dargli in pasto delle coordinate tridimensionali come obbiettivo da raggiungere.

La si trova su Github, qui:
git clone https://github.com/RorschachUK/meArmPi.git

Per questo motivo, io sono andato a modificare i valori iniziali indicati nella libreria (file meArm.py), prima di utilizzarla. Può essere che per voi vadano bene senza modifiche, o che dobbiate inserire valori diversi sia da quelli di default che dai miei.

Quindi, in questo campo, lascerò che sperimentiate. Ecco il mio listato, altra variante del precedente, a titolo di esempio da cui partire.
Perché funzioni, le dipendenze sono che le librerie siano raggiungibili dal programma, quindi o nella stessa directory, o presenti nella path Python.

In realtà per il comando tramite tasti o joystick/joypad, la cinematica inversa non sembra la scelta migliore: ogni piccolo step va calcolato a ogni pressione del tasto, e questo si traduce in un movimento di scattini consecutivi, considerando il tempo necessario a eseguire il calcolo, piuttosto che un unico movimento fluido.
Perlomeno questo avviene sul Raspberry Pi Zero. Il Pi 3B+, ad esempio, è più di dieci volte più veloce, e potrebbe non essere un problema.

Però porta con sé altri vantaggi: come il potersi muovere tra diversi punti di cui abbiamo le coordinate spaziali tridimensionali, cosa essenziale per interagire, con precisione, con l’ambiente reale.
MeArm è un progetto didattico, che non possiede una precisione millimetrica, e sempre per didattica ho appena scalfito il mondo della cinematica inversa, che, visto il numero esiguo di articolazioni del braccio (due, più una rotazione), in questo caso non fa certo la differenza.
Ma nel mondo reale, nelle applicazioni industriali, è indispensabile comandare i robot o bracci robotici indicando loro le coordinate spaziali tridimensionali, in modo da agire con precisione sulle parti che vanno a lavorare.

Spunti di sviluppo

Si può anche fare un misto dei due sistemi: a comando diretto dei servomotori per spostare il braccio “manualmente” e usando le coordinate tridimensionali per riprodurre un movimento tra punti tridimensionali di un percorso, o memorizzare delle posizioni (magari solo premendo un tasto) e poi ripeterle, impostando una specie di “macro” ma che lavora nel mondo fisico reale.

Qui potete acquistarlo.
Io vi ho dato le basi e degli spunti di idee.. Ora tocca a voi!

Sviluppate ulteriormente il concetto, partecipate alla relativa discussione sul forum.
Vi aspetto là!

Se vuoi restare aggiornato, seguici anche sui nostri social: Facebook , TwitterYouTubeGoogle+Telegram

A proposito di Zzed

Zzed
Appassionato di informatica alternativa, ma perenne novellino di Linux..

Vedi Anche

Musica con Raspberry e DAC: Spotify connect

Se c’è una cosa che mi piace fare quando torno a casa dal lavoro stanco …

Powered by themekiller.com