RaspberryItaly Community Italiana
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.
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 |
# Demo di controllo MeArm con il controller PCA9685 PWM servo # By zzed@raspberryitaly.com - 2018 # importiamo le librerie import pygame import Adafruit_PCA9685 # De-commenta per abilitare l'output di debug #import logging #logging.basicConfig(level=logging.DEBUG) # Inizializza il PCA9685 con l'indirizzo di default (0x40). pwm = Adafruit_PCA9685.PCA9685() # In alternativa puoi specificare un diverso indirizzo/bus #pwm = Adafruit_PCA9685.PCA9685(address=0x41, busnum=2) # Setta la frequenza a 60hz, per i servomotori. pwm.set_pwm_freq(60) print('Esempio uso MeArm con tasti') print('..:inizializzazione:..') print('Rotazione: A ... D') print(' Gomito: W ... S') print(' Spalla: I ... K') print(' Pinza: N ... M') pygame.init() screen = pygame.display.set_mode((270, 40)) font = pygame.font.SysFont("arial", 32) text = font.render("Test MeArm", True, (255,255,255), (0, 0, 0)) screen.blit(text, (0,0)) pygame.display.update() Esci = False # valori iniziali base = 375 gomito = 305 spalla = 470 pinza = 630 var = [0]*4 p_min = [140,250,350,430] # angoli minimi per i servo 0-3 p_max = [660,560,600,700] # angoli massimi per i servo 0-3 posizione = [base, gomito, spalla, pinza] for n in range(4): set = posizione[n] pwm.set_pwm(n, 0, set) clock = pygame.time.Clock() passo = 5 # alla pressione del tasto, aumenta o diminuisci di.. while not Esci: for event in pygame.event.get(): if event.type == pygame.QUIT: Esci = True if event.type == pygame.KEYDOWN: # quando premi i tasti.. if event.key == pygame.K_a: var[0] = passo elif event.key == pygame.K_d: var[0] = -passo elif event.key == pygame.K_w: var[1] = passo elif event.key == pygame.K_s: var[1] = -passo elif event.key == pygame.K_i: var[2] = passo elif event.key == pygame.K_k: var[2] = -passo elif event.key == pygame.K_n: var[3] = passo elif event.key == pygame.K_m: var[3] = -passo if event.type == pygame.KEYUP: # quando rilasciati ferma i servo.. if event.key == pygame.K_a or event.key == pygame.K_d: var[0] = 0 elif event.key == pygame.K_w or event.key == pygame.K_s: var[1] = 0 elif event.key == pygame.K_i or event.key == pygame.K_k: var[2] = 0 elif event.key == pygame.K_n or event.key == pygame.K_m: var[3] = 0 for n in range(4): # muovi il braccio ciclando i servo posizione[n] = posizione[n] + var[n] if posizione[n] < p_min[n]: posizione[n] = p_min[n] elif posizione[n] > p_max[n]: posizione[n] = p_max[n] pwm.set_pwm(n, 0, posizione[n])) clock.tick(30) # il clock serve a evitare che si muova troppo veloce pygame.quit() pwm = Adafruit_PCA9685.PCA9685() # ferma i servo ! quit() |
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ù:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 |
# Demo di controllo MeArm con il controller PCA9685 PWM servo e joystick ## By zzed@raspberryitaly.com - 2018 # importiamo le librerie import pygame import Adafruit_PCA9685 # Uncomment to enable debug output. #import logging #logging.basicConfig(level=logging.DEBUG) # Inizializza il PCA9685 con l'indirizzo di default (0x40). pwm = Adafruit_PCA9685.PCA9685() # In alternativa puoi specificare un diverso indirizzo/bus #pwm = Adafruit_PCA9685.PCA9685(address=0x41, busnum=2) # Setta la frequenza a 60hz, per i servomotori. pwm.set_pwm_freq(60) print('Esempio uso MeArm con tasti o joystick/joypad') print print('..:inizializzazione:..') print print('Input da tastiera') print('Rotazione: A ... D') print(' Gomito: W ... S') print(' Spalla: I ... K') print(' Pinza: N ... M') print pygame.init() screen = pygame.display.set_mode((270, 40)) font = pygame.font.SysFont("arial", 32) text = font.render("Test MeArm", True, (255,255,255), (0, 0, 0)) screen.blit(text, (0,0)) pygame.display.update() pygame.joystick.init() # inizializza il joysitck try: j = pygame.joystick.Joystick(0) # crea una istanza joystick j.init() # inizializza istanza print 'Joystick abilitato: ' + j.get_name() joy = True except pygame.error: print 'nessun joystick trovato.' joy = False Esci = False base = 375 gomito = 305 spalla = 470 pinza = 630 var = [0]*4 p_min = [140,250,350,430] # angoli minimi per i servo 0-3 p_max = [660,560,600,700] # angoli massimi per i servo 0-3 posizione = [base, gomito, spalla, pinza] for n in range(4): set = posizione[n] pwm.set_pwm(n, 0, set) clock = pygame.time.Clock() passo = 5 while not Esci: for event in pygame.event.get(): if event.type == pygame.QUIT: Esci = True if joy: # input joystick if j.get_axis(0) <= -1: var[0] = passo elif j.get_axis(0) >= 0.5: var[0] = -passo else: var[0] = 0 if j.get_axis(1) <= -1: var[1] = passo elif j.get_axis(1) >= 0.5: var[1] = -passo else: var[1] = 0 if j.get_button(0) >= 0.5: var[2] = passo elif j.get_button(2) >= 0.5: var[2] = -passo else: var[2] = 0 if j.get_button(4) >= 0.5: var[3] = passo elif j.get_button(5) >= 0.5: var[3] = -passo else: var[3] = 0 if j.get_button(8) >= 0.5: Esci = True # premendo select esce if event.type == pygame.KEYDOWN: #quando premi i tasti.. if event.key == pygame.K_a: var[0] = passo elif event.key == pygame.K_d: var[0] = -passo elif event.key == pygame.K_w: var[1] = passo elif event.key == pygame.K_s: var[1] = -passo elif event.key == pygame.K_i: var[2] = passo elif event.key == pygame.K_k: var[2] = -passo elif event.key == pygame.K_n: var[3] = passo elif event.key == pygame.K_m: var[3] = -passo if event.type == pygame.KEYUP: # quando rilascio i tasti.. if event.key == pygame.K_a or event.key == pygame.K_d: var[0] = 0 elif event.key == pygame.K_w or event.key == pygame.K_s: var[1] = 0 elif event.key == pygame.K_i or event.key == pygame.K_k: var[2] = 0 elif event.key == pygame.K_n or event.key == pygame.K_m: var[3] = 0 for n in range(4): #muovi il braccio ciclando i servo posizione[n] = posizione[n] + var[n] if posizione[n] < p_min[n]: posizione[n] = p_min[n] elif posizione[n] > p_max[n]: posizione[n] = p_max[n] pwm.set_pwm(n, 0, posizione[n]) clock.tick(30) pygame.joystick.quit() pygame.quit() pwm = Adafruit_PCA9685.PCA9685() ### ferma i servo quit() |
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: 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.
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. 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. 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. Sviluppate ulteriormente il concetto, partecipate alla relativa discussione sul forum. Se vuoi restare aggiornato, seguici anche sui nostri social: Facebook , Twitter, YouTube, Google+, Telegram
git clone https://github.com/RorschachUK/meArmPi.git
Perché funzioni, le dipendenze sono che le librerie siano raggiungibili dal programma, quindi o nella stessa directory, o presenti nella path Python.
Perlomeno questo avviene sul Raspberry Pi Zero. Il Pi 3B+, ad esempio, è più di dieci volte più veloce, e potrebbe non essere un problema.
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
Io vi ho dato le basi e degli spunti di idee.. Ora tocca a voi!
Vi aspetto là!
