ARLOK: il Robot per tutti

La robotica educativa è una tematica sempre più presente nella didattica e raccoglie sempre più adesioni da parte di giovani e meno giovani; in questo contesto si colloca ARLOK, un semplice robot educativo su ruote ideato per gli studenti e gli sperimentatori alle prime armi.
Il telaio è molto semplice da realizzare con la stampa in 3D: non sono necessari costosi macchinari di precisione. Il telaio di ARLOK è fatto da pezzi abbastanza grandi per poter essere maneggiati e assemblati con successo anche da chi ha poca manualità.
Il cuore di ARLOK è un’elettronica di controllo basata sulla scheda Arduino-like Maker UNO, per la quale rendiamo disponibili i codici sorgente di esempio e relative istruzioni.

Fig. 1

In questo articolo introdurremo il robot, spiegandovi quali sono le sue potenzialità e cosa ci si può fare, guidandovi nella costruzione e nei primi esperimenti.
ARLOK ha una storia molto particolare: nasce dalla continua sperimentazione che ha portato l’autore a mettere insieme vari componenti, fino a far nascere un robot; il primo nome assegnato ad esso doveva essere Arlecchino, perché il suo “vestito” cioè la sua scocca, era stata realizzata con avanzi di stampa 3D e risultava di vari colori.
Arlecchino è stato trasformato in AR.L.O., che è poi diventato l’acronimo inverso di ARduino Loaded with O-rings (non ha quindi nulla a che vedere col dinosauro della Disney/Pixar) perché le ruote hanno per “gomme” degli O-ring. AR.L.O. è stato il capostipite della generazione da cui poi è nato il robot descritto in questo articolo: ARLOK, che sostanzialmente è AR.L.O. in versione basata sulle schede CYTRON MakerUNO e Maker Line. ARLOK è un robottino a 2 ruote a guida differenziale, ovvero munito di due ruote entrambe collegate ad un proprio motore, nel quale la sterzata si ottiene facendo girare le ruote in senso opposto alla stessa velocità (il baricentro rimane fermo) oppure facendo girare le ruote nella stessa direzione ma a velocità differenti (virata). L’equilibrio è mantenuto tramite un terzo punto di appoggio fornito da un ball-caster (una sferetta montata in un supporto, libera di rotolare). Il firmware base di ARLOK è uno sketch Arduino che fa muovere il robot sempre dritto fino a che non trova un ostacolo, rilevato da un sonar, allorché provvede a cambiare direzione. A completamento dell’hardware, ma come accessori, sono previsti un piccolo display OLED e un modulo Bluetooth. Il robottino può essere espanso a piacere man mano che si acquisisce confidenza con la programmazione e con le dinamiche di movimento.
Di seguito analizziamo la struttura del robot.

Telaio

Il telaio è realizzato mediante la stampa 3D e le parti da stampare sono state create con Tinkercad; i relativi file STL, insieme ai programmi di esempi ed altro, sono disponibili sul repository Github di ARLOK. I file vanno stampati in modo che i pezzi risultino abbastanza solidi, quindi impostando un riempimento (fill-rate) del 25-30% e scegliendo magari come filamento il PLA+, che rispetto al PLA presenta delle caratteristiche migliori. Il telaio si compone di 8 parti (6 file singoli) che sono quelle mostrate nella Fig. 2.

Fig. 2

Abbiamo un pianale, rotondo, dello spessore di 5mm, che è il pezzo in alto a sinistra della Fig. 2; il pianale (file arlok_plate_bottom.stl) ha i fori per il fissaggio delle staffe dei servo, le scanalature per accogliere i servo, le forature sia avanti che indietro per il modello di ball-caster scelto e due fori centrali per accogliere un portabatterie standard per 3AA posto verso il basso, nonché delle gole e dei fori più grandi utili per raccogliere i cavi. Le scanalature per accogliere i servo sono profonde 2.5mm. Considerando che un servo standard (coricato sul lato più lungo col perno di uscita parallelo al piano) ha un’altezza di circa 20mm e che il perno si trova al centro (a 10mm), la distanza tra punto centrale del perno e terra (considero il servo incastrato nella base, con la base appoggiata a terra) è pari a 12,5mm: useremo dopo questo valore per alcune considerazioni.
Ci sono quindi le due staffe per bloccare i servo (arlok_servo_bracket.stl, da stampare 2 volte) e un pianale superiore (arlok_plate_top.stl) con le forature per accogliere una scheda Arduino e con delle alette per trattenereil portabatterie da 4 stilo che andrà appoggiato sulle staffe dei servo, usato per alimentare i servocomandi. Sono presenti due montanti per il pianale superiore: uno anteriore con i fori per incastrare il sensore ultrasuoni (arlok_pillar_sonar.stl presente anche nella versione rounded con le parti laterali arrotondate anziché squadrate) e uno posteriore presente in tre versioni: con foro da 6 mm (arlok_pillar_hole_06.stl) con foro da 10 mm (arlok_pillar_hole_10.stl) e con foro da 12 mm (arlok_pillar_hole_12.stl). In questo foro va l’interruttore per scollegare il pacco da 4 batterie stilo. Ci sono tre versioni con foro di diverso diametro perché il foro da 6 mm può essere utilizzato per i classici interruttori a levetta, mentre quelli da 10 e 12 mm sono destinati a ospitare i pulsanti autobloccanti.
Per l’assemblaggio del telaio andranno usate 12 viti M3 con la parte filettata lunga 12mm, consiglio il tipo TCEI (Testa Cilindrica con Esagono Incassato) dato che in alcuni punti meno accessibili è facile stringerle con una chiave esagonale a 90°. Il ball-caster andrà montato con le viti in dotazione nel relativo kit: basta mettere solo le due viti posteriori. La scheda MakerUNO, essendo piatta nella parte inferiore (non ci sono saldature o pin che sporgono), può essere fissata al pianale usando del biadesivo o, meglio, del velcro per poterla rimuovere agevolmente, oppure ancora, per ottenere un ancoraggio più stabile, dei distanziali F/F da almeno 10mm con 8 viti da 5 mm.

Le Ruote

Le ruote di ARLOK si ottengono per stampa 3D da un progetto presente su Thingiverse, chiamato Servo Wheel 4.0 (by Obijuan). Questo progetto è costituito da un file OpenScad che permette di realizzare delle ruote personalizzate adatte ad essere montate sulle squadrette dei servo. OpenScad è un tool molto interessante perché permette di parametrizzare i vari aspetti dei pezzi da stampare. Le ruote generate con questo script sono piene, hanno una scanalatura sul bordo che serve ad accogliere un O-Ring di gomma per dare grip e un incavo circolare (o a stella a 4 o 6 braccia) per accogliere la squadretta da montare sul servo, con quattro minuscoli fori intorno per il fissaggio della ruota alla squadretta. Tutti questi aspetti della ruota sono parametrizzati.
Il file STL della ruota si trova anch’esso nel repository Github con il nome arlok.wheel.stl; la ruota ha uno spessore di 4mm, un diametro adatto ad accogliere un O-Ring di 7 cm di diametro e un incavo circolare del diametro di 21mm per le squadrette dei servo.

Fig. 3

Il diametro finale delle ruote è influenzato dal diametro interno dell’O-Ring e va scelto insieme all’altezza del ball-caster per fare in modo che il robot si mantenga dritto, o meglio, leggermente inclinato verso la parte posteriore per fare più peso sul ball-caster e mantenere meglio l’equilibrio. Il ball-caster scelto, della Tamiya, può essere montato in diversi modi, così da ottenere diverse altezze. Riprenderemo il discorso tra breve.
Il diametro della ruota finita sarà quindi uguale al diametro interno dell’O-Ring + due volte lo spessore (la sezione) dello stesso: avendo utilizzato un o-ring che ha una sezione di 2,5 mm e un diametro interno di 70 mm, la mia ruota ha un diametro esterno finito di 75 mm. Tenete conto che poi il diametro finale aumenta leggermente quando andrete ad installare l’O-Ring.
Vediamo come si può personalizzare la ruota; per prima cosa apriamo il file in OpenScad:

//– Wheel parameters
wheel_or_idiam = 50; //– O-ring inner diameter
wheel_or_diam = 3; //– O-ring section diameter
wheel_height = 2*wheel_or_diam+0; //– Wheel height: change the 0 for

Le dimensioni sono espresse tutte in mm. Il primo parametro (wheel_or_idiam) imposta il diametro interno dell’o-ring. Il secondo imposta lo spessore (il diametro della sezione circolare) dell’o-ring e l’ultimo indica lo spessore della ruota: normalmente viene spessa il doppio dell’o-ring con l’o-ring al centro. Se vogliamo la ruota più spessa cambiamo lo zero con un numero maggiore, ma senza esagerare. Seguono quindi i parametri usati per tutti i tipi di squadretta (horn):

//– Parameters common to all horns
horn_drill_diam = 1.5;
horn_height = 6; //– Total height: shaft + plate
horn_plate_height = 2; //– plate height

Il primo parametro indica il diametro dei fori di fissaggio squadretta (default 1,5 mm). Il secondo parametro indica lo spessore totale della squadretta (parte piana+imbocco perno servo) e l’ultimo il solo spessore della parte piana (senza tener conto, quindi, dell’imbocco del perno): questi due parametri serviranno a “scavare” la parte centrale della ruota per fare in modo che la squadretta entri dentro la ruota ad incastro.
Subito dopo ci sono parametri relativi ad una squadretta di tipo circolare. I valori predefiniti sono quelli relativi alle squadrette forniti con i servo della Futaba:

//– Futaba 3003 servo rounded horn parameters
rh_diam1 = 8.5; //– Rounded horn small diameter
rh_diam2 = 21.5; //– Rounded horn big diameter
rounded_horn_drill_distance = 7.3;

Il primo parametro indica il diametro esterno dell’imbocco del perno del servo (small diameter) e il secondo il diametro esterno (big diameter) della squadretta. Il terzo infine indica la distanza dei fori di fissaggio della squadretta dal centro. Seguono quindi parametri relativi ad altri tipi di squadrette, che non prendo in considerazione perchè è già difficile mettere d’accordo le tolleranze della stampante 3D con le misure prese a mano della squadretta circolare, figuriamoci con le squadrette a forma di stella.
La generazione delle ruote si trova alla fine dello script:

//– Test!
Servo_wheel_rounded_horn();
translate([wheel_or_idiam+10,0,0]) Servo_wheel_4_arm_horn();
translate([-wheel_or_idiam-10,0,0]) Servo_wheel_6_arm_horn();

La ruota per la squadretta tonda è generata dalla funzione Servo_wheel_rounded_horn(); per cui le altre due funzioni, che generano le ruote per le squadrette a 4 e 6 braccia, le potete commentare con un doppio slash. Per avere le ruote piene al 50%, ci vogliono 37 grammi di filamento (circa 12,4 metri). In totale, quindi, telaio+ruote necessitano di circa 123 grammi di filamento (41,4 metri). Questi dati sono approssimativi e dipendono da tanti fattori quali percentuale di riempimento e spessore delle pareti.

Ball caster

Dato che ci sono due ruote mosse ciascuna da un proprio motore, poste più o meno al centro, e che non si tratta di un balancing-robot, ARLOK per non ribaltarsi ha bisogno almeno di un terzo punto di appoggio sul quale deve cadere gran parte del peso. Il ball-caster impiegato in ARLOK è abbastanza comune e ingegnerizzato meglio rispetto alla media; si tratta del Tamiya 70144, acquistabile tra i prodotti mostrati sulla destra. In questo modello di Ball Caster la sfera d’acciaio non poggia sulla plastica della struttura ma rotola su 3 piccole sbarrette metalliche e questo consente di avere un attrito e un’usura minori rispetto ad altri modelli. Questo ball-caster si può montare in 4 differenti modi che portano a 4 diverse altezze: 11mm, 16 mm, 27mm e 37mm. Le ultime 2 altezze, 27 e 37mm, in realtà vengono raggiunte montando tra le due parti principali della struttura delle rondelle di plastica (indicate come H1 nello schema di montaggio) che sono alte circa 2 mm: togliendole si arriva quindi a 25 e 35mm di altezza. Dunque, il gruppo di locomozione di ARLOK si basa su:
• due ruote diametro 75mm (o-ring sezione 2,5 mm e diametro interno 70 mm);
• Ball-Caster Tamiya 70144 nella versione da 27 mm ma senza le rondelle H1 (altezza ball-caster: 25 mm).

Esistono comunque tanti modelli di ball-caster stampabili in 3D. Cambiando Ball-Caster bisogna poi valutare l’altezza da terra e cambiare il diametro delle ruote (e di conseguenza trovare altri due O-Ring) e capire se possono essere montate le batterie al piano inferiore eventualmente vogliate utilizzarle (vedremo tra poco se sono necessarie). Oltre ai ball-caster esistono anche i ruotini pivotanti, tipo di quelli usati per i mobili, ma sono sconsigliati perché a volte, ruotando di 90° rimangono incastrati; per contro vanno meglio su pavimenti con piastrelle “in fuga”.

Alimentazione

Per l’alimentazione dell’insieme è stato scelto un pacco di 4 pile stilo (AA) alloggiate in un portabatterie, montato tra le staffe dei servocomandi e la base del piano superiore che ha delle ali per accoglierlo. Utilizzando un’unica fonte di alimentazione a 6V non è possibile fornire tale tensione direttamente ad Arduino, quindi senza scomodare regolatori di tensione è stato applicato un diodo al silicio in serie alla linea che dai 6V porta alla MakerUNO e alla logica.
Il diodo determina una caduta di tensione pari a circa 0,7V tale che alle logiche arrivano tra 5,3V e 5,4V.
Il microcontrollore ATMega328 a bordo della MakerUNO può funzionare fino a 5,5V, così come gli altri integrati a bordo della scheda. A bordo del robot, però, oltre ad Arduino ci sono altre logiche che devono funzionare a 5V: abbiamo il sensore ad ultrasuoni HC-SR04 ed eventualmente il display OLED e il modulo Bluetooth.
Il sensore HC-SR04 può funzionare fino a 5,5V.
Il display OLED è basato sul classico SSD1306, un controller che funziona a 3,3V grazie a un regolatore che consente di alimentare il modulo con 5 ed anche 6V. Tensione di alimentazione a parte, c’è da considerare la parte relativa al level-shifting dei segnali logici, dato che i livelli sulle linee SDA/SCL devono giungere al controller necessariamente a 3,3V. Ebbene, nei display OLED 128×32 Adafruit la conversione dei segnali su SDA/SCL da livello logico alto 5V a 3,3V è affidata a MOSFET collegati alla linea dei 3,3V, per cui non ci sono problemi ad alimentare la logica a 5 o 5,5V. Su quelli cinesi, dato il basso costo non vengono usati MOSFET, che comunque non sono necessari nel caso in cui sul bus I²C il livello di tensione venga stabilito dal display stesso: sappiamo bene che le linee dell’I²C sono open-drain (i dispositivi che comunicano tra loro tirano solo la linea verso il livello basso, mentre quando bisogna andare a livello alto, vanno in alta impedenza e il livello è fornito da resistenze di pull-up).
Tipicamente SDA e SCL sono portati a livello alto (verso i 3,3V forniti dal regolatore on-board) da due resistenze da 4,7 kΩ e in più Arduino UNO e Leonardo riportano i due pin SDA e SCL sull’header senza resistenze di pull-up, il che significa che il livello logico alto non può arrivare ai 5,3V che stiamo fornendo alla Maker UNO, ma viene determinato dall’altro dispositivo posto sul bus (che ha il pull-up verso 3,3V), quindi anche per il display non c’è problema.
Il modulo Bluetooth viene alimentato a 5V ma a bordo ha un regolatore di tensione a 3,3V che “regge” come minimo a 6V in ingresso o 5,5V nel peggiore dei casi. Nessun problema, invece, per la logica, perché questi moduli Bluetooth richiedono sempre che esternamente venga messo un partitore di tensione sulla loro linea di ricezione nel caso in cui il dispositivo con cui comunicano non lavori a 3,3V. Sul PCB della breakout board del modulo si legge chiaramente: Level: 3.3V.
Sullo shield di ARLOK è stato predisposto il partitore formato da R1 e R2 dalla linea TX di Arduino verso la linea Rx del modulo Bluetooth. Con i valori specificati nello schema (R1=15kΩ e R2=22kΩ), al modulo Bluetooth arriverà un livello logico massimo di 3,3V se l’alimentazione è 5,5V.

VOUT=VIN*(R2/R1+R2)=VIN*0.5945

Il range di tensione sul pin RX del modulo è quindi da 3,3V (massimo, alimentando con Vservo a 6V) a 2,67V (minimo, alimentando con 3 pile AA): non superiamo il massimo ammesso e rientriamo nei 2V per far considerare valido il livello. Per la linea di comunicazione opposta, da TX del modulo a RX di Arduino, non c’è bisogno di fare nessun adattamento perché i 3,3V forniti dal modulo vengono già interpretati correttamente dalle logiche a 5V. Il PCB ha comunque due ingressi: uno per la tensione dei servo (6V) e uno per la tensione logica (VDD). È quindi possibile utilizzare un portapile aggiuntivo per 3 stilo (4,5V) da mettere sotto al pianale per alimentare la sola logica; in questo modo le tensioni di alimentazione (servo e logica) sono separate e si minimizzano anche eventuali disturbi: questa è la configurazione raccomandata.
Volendo è possibile utilizzare il portabatterie per 4 stilo con batterie ricaricabili NiMH: dato che queste hanno una tensione di 1,2V, avremo un totale di 4,8V: in questo caso, però, non tutti i servo potrebbero funzionare correttamente e al posto di D1 dovremmo mettere un ponticello, perché se scaliamo la tensione arriviamo a 4,1V e le logiche potrebbero non funzionare correttamente.

Servocomandi

Perché usare un servocomando al posto di un motoriduttore? Innanzitutto perché i servo hanno dimensioni standard, contengono un motoriduttore, costano molto poco e sono molto facili da trovare; ma la cosa forse più importante di tutte è che hanno l’elettronica di pilotaggio del motore a bordo, il che semplifica l’elettronica richiesta da ARLOK. Chiaramente non è possibile usare i servocomandi così come sono dato che hanno una rotazione limitata. Anche se in commercio esistono già servocomandi a rotazione continua, vediamo di seguito come modificare due servocomandi standard RC per farli diventare a rotazione continua. Sul prototipo del robot sono stati usati dei servocomandi: sono molto comuni e hanno gli ingranaggi in metallo, una costruzione molto solida con cavi più spessi e invece dei cuscinetti hanno delle boccole in metallo sui perni di uscita.
Sullo shield sono previsti connettori per servo con una pin-out standard: ovvero con il terminale di alimentazione (6V) al centro.
Generalmente i servo hanno una pin-out del tipo segnale-tensione-GND (S + -) anche se possono cambiare i colori dei fili. Se utilizzate servocomandi con diversa piedinatura bisogna separare i contatti del connettore. La modifica per la rotazione continua è molto semplice e consiste in due operazioni: rimozione del notch dall’ingranaggio del perno di uscita e sostituzione del potenziometro (che funge nei servo da sensore di posizione) con due resistenze di uguale valore (consigliato 22 Kohm). In pratica il servo, leggendo sempre un valore “centrale” sull’IO del potenziometro, crederà che l’albero si trovi sempre al centro e quindi l’elettronica a bordo continua far ruotare il motore anziché fermarlo. Il notch viene messo solo per sicurezza.
Alcuni servo più sofisticati, però, rilevano la condizione di rotazione continua perché quando danno corrente al motore e questo gira (tra l’altro ne rilevano anche l’assorbimento) rilevano che la posizione restituita dal potenziometro di feedback rimane sempre al punto centrale; questo determina anomalia e l’arresto del motore. Pertanto bisogna utilizzare dei servo analogici classici.

Display OLED

Lo shield e il codice sono predisposti per l’utilizzo di un piccolo display OLED da 0,91″ con una risoluzione di 128×32 pixel (Fig. 4). Sebbene sia utile per la taratura del punto zero dei servocomandi e per mostrare altre informazioni, non è necessario perchè la taratura si può fare anche senza.

Fig. 4

Modulo Bluetooth

Per la connessione Bluetooth è stato previsto il modulo HC-05, ma va bene anche l’HC-06: l’importante è che sia quello montato su breakout board con pin-strip che porta all’esterno i pin RX/TX. A bordo è presente un regolatore di tensione a 3,3V per il chipset, i cui livelli logici sono quindi 0/3,3V; ecco perché è necessario mettere un partitore tra la linea TX di Arduino, che lavora a 5V, e la linea RX del modulo.
Quando innestate il modulo bluetooth controllate la piedinatura: il pin RX del modulo va allineato con la piazzola TX e viceversa.
Il modulo Bluetooth è un accessorio e può essere utile per sperimentare ulteriormente: avere un debug, ad esempio, sul cellulare utilizzando un software qualsiasi che fa da terminale o possiamo anche realizzare un’app, magari tramite MIT App Inventor, per poter pilotare il robottino dal cellulare o semplicemente avere una dashboard con indicazioni e letture di sensori fornite dal robot. Ancora potremmo utilizzare un’app android, Bluetooth Electronics, che è un semplice tool di comunicazione seriale over Bluetooth che ci da la possibilità di costruire interfacce con pulsanti ai quali possiamo associare comandi da inviare via seriale: sul repository GitHub è presente proprio questo esempio.
Il modulo HC-05 può anche fungere da master oltre che da slave, a differenza dell’HC-06 che funziona solo come slave; l’uno o l’altro, per il nostro ARLOK è indifferente perchè sarà sempre il cellulare a fare da master. Un’altra differenza tra i due moduli sta nella modalità di funzionamento attiva all’avvio: il modulo HC-06 si avvia in modalità AT (può accettare da subito comandi per la configurazione), mentre l’HC-05 non accetta comandi AT all’avvio e per mandarlo in questa modalità bisogna premere il pulsantino on board.
Questi moduli, oltre all’alimentazione e alle linee UART hanno altri due pin: STATE, che è il pin a cui è collegato il led on-board che lampeggia in modo diverso a seconda della modalità attiva, e un altro pin che a volte è riportato come KEY, altre volte come EN. In genere quando c’è EN si tratta di un pin per spegnere il modulo: mandando un livello basso si spegne, lasciandolo scollegato o a 3,3V il modulo si accende.
Quando è riportato come KEY potrebbe non servire a nulla (HC-06) o per attivare la modalità AT sul modulo HC-05: in questo caso dato che il pin per la modalità AT è tenuto normalmente a livello basso con una resistenza di pull-down, per entrare in questa modalità dal pin (cioè senza premere il pulsante) bisogna mandarlo a livello alto (3,3V). Il problema di questi moduli è che ogni produttore è d’accordo sul pin STATE ma ognuno fa un po’ quello che gli pare con l’altro pin: KEY o EN; per tale motivo sul PCB è stato previsto un connettore a 6 pin per il modulo ma i due pin laterali non li ho collegati a nulla. Esistono poi alcune breakout board che non hanno i pin disposti allo stesso modo: a quel punto dovete utilizzare l’area millefori e fate voi un adattatore.
Il connettore per il modulo Bluetooth lo potete utilizzare anche per collegare altri dispositivi di comunicazione, basta che stiate attenti alla tensione di alimentazione del modulo che volete usare (i moduli ESP-01 vanno alimentati a 3,3V) e al pin-out.
Non abbiamo una stretta necessità della modalità AT: questa viene utilizzata per cambiare la configurazione del modulo ovvero cambiarne il baud-rate (default 9600bps sull’HC-05), la password di accesso (default 1234 sull’HC-05, a volte 0000), il nome (default HC-05) ecc. Sul modulo HC-05, quando si entra in modalità AT il baud-rate non è più 9600 ma 38400 e durante questa modalità non è possibile collegare un dispositivo Bluetooth.
Se volete cambiare i parametri di configurazione del modulo vi è necessario un adattatore UART/USB e un programma di terminale.

Shield ARLOK

Per affacciare MakerUNO a sensori e attuatori del robot è stato realizzato uno shield specifico che accoglie i componenti elettronici a bordo del robot. Trovate lo schema elettrico dello shield in queste pagine, insieme al relativo piano di montaggio.

Schema Elettrico

Su un lato dello shield ci sono le due morsettiere a vite per l’alimentazione con l’indicazione di positivo e negativo: su VServo andrà la tensione fornita dalle 4 batterie AA. Nel caso in cui volessimo utilizzare un solo pacco batterie (quello da 4 stilo), allora il jumper posto dietro i connettori a vite (JP1) va messo sulla posizione VServo (verso destra, in direzione del diodo): in questo modo, alle logiche arriverà la 6V scalata dal diodo D1 (quindi circa 5,3-5,4V). Un altro jumper (Power) può essere utilizzato per disconnettere la sola tensione logica: qui può anche essere messo un piccolo interruttore con passo 2,54.

Fig. 5

L’altro connettore a vite (VDD) va usato nel caso in cui alle logiche volessimo fornire un’alimentazione separata: in questo caso J1 va chiuso verso la dicitura VDD (verso sinistra, in direzione dei connettori dei servo).
Nella Fig. 6 viene mostrato come fare per alimentare il robot (sia servocomandi che logiche) con una sola sorgente costituita dal pacco batterie da 4 stilo.

Fig. 6

Nella Fig. 7, invece, viene illustrato come configurare la scheda per poter utilizzare due alimentazioni separate (il pacco da 3 stilo andrebbe installato sotto al pianale inferiore, tra ruote e ball-caster, sfruttando i due/tre fori centrali).

Fig. 7

Se i servo assorbono poca corrente e quindi non creano sbalzi di tensione, si può utilizzare la prima soluzione (solo le 4 batterie AA); se invece notate che il modulo Bluetooth si resetta o addirittura si resetta la Maker UNO, provate prima ad aumentare il valore dei condensatori sulla scheda e anche ad aumentare l’ampiezza della rampa di decelerazione dei servo durante uno stop o un cambio direzione (i cambi improvvisi portano a picchi di assorbimento). Se anche questo non risolve i reset, allora è necessario utilizzare la seconda soluzione con il pacco batterie aggiuntivo per alimentare la sola logica.
All’altra estremità del PCB va collegato il sensore ultrasuoni rispettando la piedinatura riportata sulla serigrafia, che combacia con quella del sensore orientato con il quarzo verso il basso. Potete collegare il sensore utilizzando 4 cavetti jumper femmina/femmina oppure rimuovere l’header dal sensore ultrasuoni e saldare 4 fili che terminano con un connettore Molex femmina passo 2,54 mm, da innestare sul maschio saldato sul PCB.
Diversamente dovrete piegare verso l’alto l’header del sensore durante il montaggio perché tocca sul vano batterie e non potete innestare i cavetti jumper. Potete utilizzare o un’accoppiata connettore femmina munito di cavi + maschio da montare sul circuito stampato oppure un cavo maschio/femmina da innestare direttamente sull’header del sensore (dopo averlo piegato). Nello schema di cablaggio in queste pagine vedete come collegare i moduli allo shield.

Schema di cablaggio

Realizzazione pratica

Passiamo ora alle note costruttive, iniziando con lo shield, il cui circuito stampato può essere ottenuto per fotoincisione partendo dalle tracce lato rame scaricabili dal repository dell’autore.
Quanto al montaggio dei componenti, andate in ordine di altezza nel caso in cui non venga utilizzata la Maker Uno ma un Arduino Uno standard, è necessario usare headers più lunghi del normale altrimenti lo shield tocca sul connettore USB.
Particolare attenzione va prestata al modulo Bluetooth: normalmente il verso di innesto è quello indicato nella foto: il pin RX del modulo deve entrare nel pad contrassegnato con TX e il pin TX in quello RX. I due pin esterni (STATE e KEY o EN) non sono collegati, quindi attenzione a non inserirlo al contrario. Dovete fare molta attenzione anche alla pin-out dei servocomandi.
Nota importante: il sensore ultrasuoni deve stare tutto fuori: se le capsule vanno a filo con la staffa, le letture sono alterate e il robot comincia a rilevare ostacoli anche se non ci sono.
Sul PCB sono riportati anche due header (EXT1 e EXT2) con i pin rimasti liberi. In particolare l’header EXT1, sotto al connettore per ultrasuoni, è per un eventuale modulo aggiuntivo line-follower per cui ci sono 3 I/O da sfruttare per il sensore di linea centrale e i due laterali: utilizzando il sensore makerline della Cytron, oltre ai PIN digitali per il rilevamento della linea è possibile, in alternativa, utilizzare un unico ingresso analogico.
Gli ingressi analogici, tranne lo zero che è occupato dal trimmer, sono riportati su 3 headers separati, ognuno dotato anche della linea 5V e GND per facilitare il momtaggio di eventuali sensori analogici. Il trimmer collegato ad A0 servirà nel firmware di esempio per la regolazione del punto zero dei servocomandi. Nella parte centrale del PCB c’è una utile area millefori che si presta a modifiche e aggiunte. Se intendete utilizzare gli ingressi analogici A4 e A5, sappiate che sono condivisi con SDA e SCL.
Per la MakerUNO bastano degli header maschio normali (quelli da 11mm): in questo caso utilizzate lo stesso header standard maschio da 40 pin indicato sopra (per i servo e JP1) e avrete cura, nella zona dell’header alimentazioni, di montare un pezzo da 6 pin anziché da 8 lasciando liberi i pin NC e Vin, che si trovano alle estremità e non servono.

Piano di montaggio

Elenco Componenti:

R1: 22 Kohm
R2: 15 Kohm
R3: 330 ohm
C1, C2, C4. C5, C6: 100nF
C3: 1000 uF 16V
LD1: led rosso 3mm
VR1 : trimmer 10Kohm MO
D1: 1N4004
P1-P2: microswitch NO
RESET: microswitch NO
Varie:
– pinheader 10pin
– pinheader 8pin
– pinheader pin
– pinheader 4pin
strip maschio 2 poli
– strip maschio 3 poli
– strip maschio 4 poli
– strip maschio 7 poli
– strip maschio 8 poli
– strip maschio 10 poli
– strip femmina 6 poli
– strip femmina 4 poli
– morsetto 2 poli p5
– jumper
– connettore grove
– Circuito stampato S1543 (69x54mm)

Il firmware

Passiamo adesso all’analisi dello sketch installato nella scheda MakerUNO per gestire ARLOK.
Prima di tutto è necessario installare su Arduino IDE alcune librerie. Basta andare in Strumenti > Gestione librerie scrivere il nome della libreria (in grassetto nella lista che segue), premere Invio per cercare e cliccare sul pulsante Installa nella casella dove compare la libreria precisa. Dato che possono esserci varie librerie con nomi simili, leggete bene quali sono gli autori, riportati in corsivo:

• Adafruit SSD1306 di Adafruit (questa ha bisogno di una libreria aggiuntiva che verrà installata automaticamente dopo un pop-up che vi richiede il permesso di farlo);
• Adafruit GFX di Adafruit
• TimerOne di Jesse Tane, Jérôme Despatis, Michael Polli, Dan Clemens, Paul Stoffregen;
Bisogna installare ancora un’altra libreria che non compare nella lista di Arduino IDE e dovremo farlo a mano: andiamo all’URL https://github.com/nabontra/ServoTimer2, clicchiamo sul pulsante Clone or download e quindi Download ZIP.
Estratto il file ZIP si genera la cartella ServoTimer2-master: rinominiamola in ServoTimer2.
Copiamo questa cartella nella cartella delle librerie Arduino in documenti (per Windows: Documenti/Arduino/libraries). Dopo averla copiata, giusto per sicurezza, controllate che all’interno di questa cartella ci sia una cartella examples.
Se l’IDE era aperto, dobbiamo chiuderlo e riavviarlo per fargli vedere questa nuova libreria.
Ora è possibile scaricare il programma di esempio per far muovere ARLOK, dal sito https://github.com/settorezero/arlok.
Copiate solo il codice e incollatelo nella finestra di Arduino IDE.
Selezionate la scheda che state utilizzando e provate solo a compilarlo senza caricare (cliccate il tasto di spunta). Se la compilazione va a buon fine, siete già a buon punto, altrimenti vuol dire che non avete installato qualche libreria o avete selezionato la scheda sbagliata.

Funzionamento del codice

Partiamo dalla gestione del SONAR: questo viene controllato tramite interrupt per non bloccare il programma aspettando di fornirgli il trigger e controllare la risposta: in tutto questo tempo il robot potrebbe sbattere senza accorgersi dell’ostacolo. L’idea della lettura del SONAR tramite interrupt è di Steve Garrat. Per questo motivo abbiamo installato la libreria TimerOne che consente di impostare con facilità un interrupt per overflow sul Timer1 con il quale gestiremo il triggering del sensore. Il Timer viene impostato per generare un interrupt ogni 50µS. Questo interrupt viene agganciato alla funzione timer1_ISR. Qui utilizziamo una macchina a stati ed è bene che vi ricordiate come funziona il sonar. La prima volta che scatta l’interrupt ci troviamo nello stato 1: viene mandato a livello alto il pin di trigger, si imposta un contatore trigger_time_count e ci si posiziona per lo stato 2. La seconda volta che scatta (dopo altri 50µS) ci troviamo quindi nello stato 2 e il pin di trigger viene portato a livello basso: l’impulso sul trigger è durato quindi 50µS, da datasheet deve durare almeno 10µS. Si torna allo stato zero, ovvero si fa nulla: quando trigger_time_count raggiunge lo zero si ricomincia daccapo inviando un nuovo impulso sul trigger.
Il contatore arriva a zero dopo 225mS, impostati da TICK_COUNTS (4500*50µS=225000µS). Nel frattempo l’impulso di ritorno viene monitorato da un pin al quale abbiamo agganciato un interrupt sul cambio di stato che abbiamo chiamato sonarEcho_ISR. In quest’altra funzione controlliamo se il cambio di stato del pin di echo è stato da livello basso a livello alto o viceversa; nel primo caso vuol dire che l’impulso è appena arrivato e la sua durata (cioè fino a che non ridiventa basso) sarà proporzionale alla distanza rilevata. Viene quindi memorizzato il valore del contatore micros() di Arduino.
Dopo un po’ scatterà un nuovo interrupt causato dal nuovo cambio di stato di echo da alto a basso: a questo punto dal contatore micros() attuale si sottrae il valore memorizzato prima e abbiamo quindi la durata dell’impulso di echo da cui ricaviamo la distanza. Il valore di distanza rilevato viene salvato in una variabile globale in modo che sia disponibile anche al Loop. Tutto questo deve essere eseguito nel tempo tra un trigger e il successivo. Per la gestione dei servo non abbiamo utilizzato la funzione standard di Arduino ma una modificata, ServoTimer2, che per la generazione del PWM per pilotare i servo si avvale del Timer2 piuttosto che dell’1, che, come avete visto, stiamo sfruttando per gestire il SONAR e non possiamo quindi utilizzare per altro. Per generare l’interrupt potremmo usare una libreria che sfrutta il Timer2 per generare l’interrupt e lasciar perdere la libreria alternativa per i servo. Questa libreria, diversamente da quella standard di Arduino, non accetta come parametro l’angolazione in gradi, bensì la durata in microsecondi dell’impulso di pilotaggio.
Il codice non fa altro che far andare ARLOK dritto (i due servo, dato che si trovano montati in maniera speculare, dovranno girare uno in un senso e l’altro nel senso opposto). Nel momento in cui la distanza rilevata dal SONAR è al di sotto di una certa soglia (parametro OBSTACLE), il robottino si ferma e con una funzione random sceglie di andare a destra o sinistra.
Il valore di OBSTACLE non deve essere troppo basso perchè c’è una certa lentezza di aggiornamento dovuta alla gestione del display, il valore attuale nel codice è un buon compromesso.
Lo stop del robot, però, non è immediato perché ne causerebbe il ribaltamento in avanti per inerzia ma è stata prevista una rampa di decelerazione ottenuta giocando sugli impulsi di pilotaggio dei servo. Infatti tenendo 1.500 µS come valore di servo in posizione centrale (fermo, nel nostro caso), al di sopra di tale valore il servo ruoterà in un verso e al di sotto nel verso opposto, ma più siamo vicini al valore di 1500 tanto più il servo girerà lentamente, altrimenti in condizioni normali (servo non modificato) non riuscirebbe a fermarsi in tempo per riportarsi precisamente al centro, per cui il comportamento normale è che la velocità di rotazione del servo diminuisce man mano che si avvicina al punto centrale. Il servo che abbiamo modificato crede di trovarsi sempre al punto centrale; c’è però da gestire il punto zero dei servo, dal momento che non tutti i servo si fermano precisamente al valore di 1.500 µs, specie questi che sono stati modificati. A ciò provvede la funzione di setup, per la quale avete bisogno di qualcosa su cui appoggiare il robottino in modo che le ruote siano libere di girare in aria senza toccare e di un piccolo cacciavite a taglio che entri nel cursore del trimmer VR1. Il setup è facilitato dall’utilizzo del display.

Conclusioni

Il progetto ARLOK nella sua interezza è rilasciato sotto licenza Creative Commons BY-SA-NC 4.0, ovvero siete liberi di condividerlo e farne modifiche a patto che sia indicato l’autore originale e le eventuali modifiche fatte, il progetto o qualsiasi sua parte non siano utilizzati a scopi commerciali e che la condivisione avvenga allo stesso modo di come l’ha fatta l’autore.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Menu