Per gli assi delle ruote sono state utilizzate delle barre filettate da 16 mm di diametro, lunghe 63 cm, fatte passare attraverso dei supporti in alluminio e qui bloccate, facendo in modo che da ogni lato del telaio escano in misura uguale. I supporti sono fissati alla base inferiore del telaio del robot.

Per bloccare le ruote alla giusta distanza (lato verso il supporto) si può optare per due soluzioni; dado e controdado, oppure, come nel nostro caso, saldare un dado direttamente sulla barra filettata (Fig. 5). Per la prima soluzione, una volta fatto ciò bisogna inserire un dado 16 MA nella barra filettata, avvitarlo fino a farlo arrivare a circa 7 cm dal supporto della barra (Fig. 6), verificare più volte la misura e quindi saldarlo. Lo stesso vale per l’altro lato e l’altra barra.

 

Fig. 5

 

Fig. 6

Per montare la corona su ogni ruota, bisogna togliere i quattro bulloni originali e ricavare altri quattro fori, di pari diametro, che combacino con quelli della rispettiva ruota; per posizionare i fori con precisione, conviene creare una dima in cartoncino ricavando l’interasse dei fori delle ruote. Forate le corone, bisogna inserire i quattro da 8MA lunghi 100 mm e avvitare un dado autobloccante in modo da fissare il bullone al cerchio della ruota (Fig. 7); poi si inserisce un altro dado autobloccante (o dado e controdado) ad una distanza di circa 72 mm dal dado avvitato nel lato interno del cerchio.

Ora si può applicare la corona, centrandone i fori rispetto ai quattro retrostanti e avvitate con quattro dadi ben stretti. Fatto ciò, si monta la ruota: se tutto è corretto avrete i dadi della corona ad una distanza massima di 10 mm dal telaio. Su ogni asse si devono inserire i dadi autobloccanti 16 MA.

Esternamente, le due ruote sono distanziate e tenute in tensione tramite una barra angolare di allumino da 30×30 mm, spessa 2 mm (Fig. 8) e vanno fissate tramite un bullone al centro della barra filettata.

Quando abbiamo abbassato la pala per spalare ci siamo accorti che era necessario aumentare l’aderenza utilizzando dei cingoli (o delle ruote adatte, tipo quelle dei trattorini), ma abbiamo deciso di trovare una soluzione alternativa.

Prendendo spunto dalle varie soluzioni trovate in Internet, e adattandole alla nostre esigenze, abbiamo realizzato dei cingoli “casalinghi” utilizzando quattro confezioni di catene per bicicletta da 1/2”x1/8” con 114 maglie ciascuna (due per lato, per un totale di 120 maglie, corrispondenti a una lunghezza di circa 166 cm), 40 angolari in alluminio (mm) 12×12 lunghi 120 con spessore 2 e 80 bulloni 5MA lunghi 50 mm e relativi dadi autobloccanti (Fig. 9).

Gli angolari in alluminio, distanziati dal centro di un bullone al centro dell’altro di 8 cm, oltre che a tenere insieme e parallele le catene di ciascuna coppia costituente un cingolo (avvolte intorno alla relativa coppia di ruote) permettono di avere la giusta aderenza al manto nevoso. Su ogni angolare vanno praticati due fori, nei quali bisogna inserire due bulloni 5MA x 50 mm, necessari a fissarli alla catena ed evitando che le catene scivolino da un lato o dall’altro.

Fig. 7

 

Fig. 8

 

Fig. 9

 

Per abbinare le ruote al pignone del motore MY1016, è stato necessario procurarsi due catene a passo corto (tipo quelle dei monopattini elettrici o delle minimoto), montare sulle due ruote motrici due corone di diametro 155 mm a 76 denti e distanziarle di circa 35 mm dalla ruota (lato interno del pneumatico) tramite 4 bulloni 8MA x 100 mm.

Per fissare i motori abbiamo utilizzato dei supporti, ricavati da due barre rettangolari di ferro (mm) 30×20 lunghe 375 e forate.

Partendo dall’esterno, il primo foro si trova a circa 14 mm, mentre il secondo a 42 mm dal primo; questa distanza corrisponde ai fori del motore (parte più stretta della staffa del motore).

Sulla barra sono stati praticati due fori, a 110 mm dall’esterno e da entrambi i lati, necessari per il fissaggio alle due barre verticali da 190 mm.

La stessa foratura è stata fatta per la seconda barra.

Le due barre verticali da 19 mm, una volta saldate alla base del telaio, sono state forate a una distanza (partendo dalla base del telaio) di circa 44 mm per il primo foro (a forma di asola) e 139 mm per il secondo foro (sempre a forma di asola), come mostrato in Fig. 10.

A questo punto non rimane che fissare i motori, orientando il pignone verso l’esterno e verificando che sia in linea con la corona della ruota.

Fig. 10

La pala
La parte meccanica, un po’ più complessa, è quella del supporto della pala e del suo movimento.

Per realizzare la pala abbiamo utilizzato una lastra di acciaio rettangolare da 650×250 mm, spessa 2 mm (Fig. 11), che poi abbiamo leggermente curvato (sopra e sotto, lato lungo) per agevolare la spalatura della neve.

Per la struttura meccanica che supporta la pala e permette di muoverla (Fig. 12), abbiamo utilizzato uno scatolare di ferro da 30×20 mm lungo 265 mm, tagliato all’estremità con la richiesta angolazione, uno scatolare di ferro 40×20 mm lungo 13 cm, un profilato rettangolare da 30×20 mm lungo 46 mm, una traversa ad incastro lunga 600 mm (utilizzata per i ripiani/scaffali e reperibile presso i centri del fai da te), un supporto con cuscinetto da 16 mm e due scatolari da 40×30 mm lungo 26,5 cm tagliato all’estremità la richiesta angolazione.

Abbiamo quindi realizzato un perno in alluminio lungo 11 cm (f 12 mm tranne che nei primi 5 mm, dove ha f 14 mm) da inserire nel cuscinetto da 12 mm, nella parte superiore del quale è stato praticato un foro da 5 mm, poi filettato, per fissare, mediante un bullone 5MA, la staffa per l’attuatore lineare che permette di alzare e abbassare la benna.

La seconda staffa dell’attuatore è stata fissata al centro della barra con lunghezza 265 mm. Per ruotare a destra e sinistra la pala, abbiamo utilizzato per ogni lato due staffe a L in alluminio da 50×50 mm, larghe 40 e spesse 5, forate e avvitate inserendo tra le due una rondella, come si vede in Fig. 13.

Una coppia di L è stata fissata, tramite due bulloni, nella parte inferiore (lato sinistro) del telaio e l’altra a quello destro.

A una staffa della coppia di L è stata fissata la relativa staffa per l’attuatore lineare. La seconda staffa dell’attuatore destro e sinistro è stata fissata sulla struttura a triangolo della pala (Fig. 14).

Fig. 11

 

Fig. 12

 

Fig. 13

Fig. 14

 

Prima di forare e fissare i tre attuatori lineari sul triangolo della pala, bisogna prendere i due attuatori lineari che servono per ruotare a destra e sinistra la pala, applicare 12 Vcc a uno dei due in modo da avere l’estensione massima, mentre l’altro deve risultare completamente contratto.

Ora vanno collegati i fili di alimentazione dei due attuatori in modo da avere il positivo del 1° attuatore collegato con il negativo del 2° e il negativo del 1° sul positivo del 2°.

Bisogna quindi alimentare la coppia di fili degli attuatori e togliere tensione appena hanno raggiunto la stessa estensione. Adesso si possono fissare le staffe dell’attuatore lineare ai due attuatori laterali (sulla parte posteriore).

La staffa dell’attuatore deve essere fissata alla coppia di “L” in alluminio (quella con interposta la rondella), precedentemente fissate sulla parte frontale bassa del telaio (Fig. 15). Ora si può posizionare la parte del braccio dell’attuatore vicino al triangolo della pala, fissare una piccola “L” (servirà come ancoraggio) e prendere bene le misure prima di forare definitivamente.

Non rimane che posizionare anche l’attuatore centrale, fissando la staffa sul perno centrale del cuscinetto e fissando poi la staffa (dopo aver inserito la staffa specifica anche sulla parte del pistone) sulla zona centrale del triangolo della pala (Fig. 16).

La traversa a incastro va fissata sulla barra orizzontale del triangolo della pala (Fig. 17), forata e fissata. La pala in acciaio, opportunamente piegata, va posizionata sulla traversa in modo da segnare i punti da forare mostrati in Fig. 11.

Fig. 15

 

Fig. 16

 

Fig. 17

Cablaggio

L’elettronica del robot spazzaneve

La parte elettrica ed elettronica dello spazzaneve è basata su Arduino Uno, che ospita tre shield e si interfaccia con queste schede:
• il driver per motori MDDS30;
• il circuito a relé RELAY1CH;
• il DC/DC converter elevatore STEPUP30V.

Gli shield montati su Arduino sono il motor shield (cod. VMA03) per controllare i tre motori lineari che gestiscono il movimento della pala, e il PS2SHIELD, che permette di interfacciarsi con la console della PlayStation 2 (PS2); quest’ultimo richiede che vi sia montato, inserendolo nell’apposito connettore, l’RX-PS2, che è un ricevitore radio a 2,4 GHz specifico per ricevere i comandi dalla predetta console.

Tutte le schede e gli elementi utilizzati nel circuito si possono acquistare da Futura Elettronica.

Lo schema di cablaggio della macchina è quello che trovate in queste pagine; la fonte di alimentazione è costituita da una serie di due accumulatori a piombo gel da 7,2 Ah: nel punto intermedio dei due preleviamo 12 V, mentre tra il negativo e il positivo della serie prendiamo i 24 volt. Le due linee di alimentazione sono sezionate da un interruttore da 125V, 2×15 ampere.

Con i 12 volt facciamo funzionare Arduino, il quale alimenterà la logica degli shield attraverso i propri pin-strip; il LED (dotato internamente della resistenza di limitazione) indicherà quando Arduino è sotto tensione.

Con i 12 volt si alimenta anche la sezione di potenza del motor shield (cod. VMA03); infatti, visto l’assorbimento dei tre attuatori lineari (cod. LINACT12V50), è sconsigliabile prendere i 12 V da Arduino: bisogna optare per l’alimentazione esterna, da fornire all’apposita morsettiera PWR.

Per prendere l’alimentazione esterna, bisogna spostare il jumper dello shield vicino alla morsettiera, tra il centrale e l’EXT. La gestione dello shield richiede un’apposita libreria per Arduino, fornita a corredo.

Ciascun attuatore lineare è composto da un motoriduttore a 12 Vcc che utilizza una vite senza fine per spostare un albero avanti e indietro lungo la sua lunghezza (escursione massima di 5 cm).

L’attuatore ha un coefficiente di carico dinamico di 50 kg e una velocità massima di 1,3 cm/s. È in grado di sostenere fino a circa 250 kg, quando non si muove, e la coppia a vite assicura il mantenimento della posizione dell’albero anche in assenza di alimentazione.

Due interruttori di limitazione garantiscono l’arresto del motore quando arriva alla massima estensione e contrazione, mentre i diodi permettono di invertire la direzione dopo aver raggiunto il punto limite. L’attuatore è in metallo ed è sigillato per proteggerlo dalla polvere e dall’acqua (IP63 nominale).

Passiamo adesso alla linea di alimentazione a 24 volt, con cui viene fatta funzionare la parte di potenza dello spazzaneve, vale a dire la trazione e la sezione del proiettore (opzionale): la prima si basa sul driver per motori di potenza (cod. MDDS30 o DRI0018), da collegare con quattro fili ad altrettante linee digitali di Arduino.

Il MDDS30 è un doppio driver di potenza a ponte in grado di gestire due motori brushed in continua con una tensione di alimentazione max. di 35 Vcc e una corrente di 15 A (ciascuno). Interfacciandolo ad Arduino e utilizzando solo 4 I/O digitali (2 PWM), è possibile scegliere il verso e la velocità di rotazione dei motori.

Il circuito dispone di quattro pin di controllo, quattro LED che indicano la direzione di rotazione dei motori, due pin per l’alimentazione della scheda (5 Vdc) e due dissipatori di calore in alluminio situati nella parte posteriore del circuito stampato, necessari a smaltire il calore sviluppato nel funzionamento alla massima potenza.

Per la gestione del driver da parte di Arduino, il costruttore fornisce a corredo un’apposita libreria. Le morsettiere di uscita permettono di collegare i due motori, da connettere secondo l’indicazione dello schema (non scambiate la polarità, altrimenti i cingoli gireranno al contrario!) utilizzando cavi di diametro pari almeno a 1,5 mmq.

Quanto agli ingressi di comando, va rispettata la connessione tra Arduino e il connettore a passo 2,54 – 2 file del controller indicata nella Tabella 1; la corrispondenza vale a patto di usare la libreria fornita dal costruttore e il nostro firmware: se li modificate, dovete rivedere di conseguenza le connessioni. Ricordate che i DIR sono i livelli logici che impongono la direzione di rotazione dei motori e i PWM i segnali PWM da fornire ai driver di potenza.

 

Tabella 1

Per identificare i contatti del connettore del controller è sufficiente riferirsi alla serigrafia visibile accanto ad esso sul lato componenti dello stampato.

Oltre al controller dei motori, i 24 volt vanno ad alimentare la sezione del proiettore a LED, che potete montare o meno; se la montate, rispettate il cablaggio indicato e ricordate di far passare il positivo dei 24 V dalla scheda a relè (cod. RELAY1CH). Quest’ultima ospita un relé e il rispettivo transistor di comando, controllato da Arduino mediante il Digital I/O 13; Arduino fornisce anche l’alimentazione alla scheda, mediante il 5V e la massa (GND).

La scheda a relé permette di accendere e spegnere il proiettore, intervenendo sull’alimentazione del circuito corrispondente.

Il proiettore è progettato per funzionare a 220 Vac, tuttavia siccome questa tensione non è disponibile a bordo del robot, per evitare di usare un inverter abbiamo modificato il proiettore aprendolo, rimuovendo l’alimentatore AC/DC e portando i due fili del LED di potenza all’uscita del converter DC/DC (cod. STEPUP30V); quest’ultimo è uno switching a tensione d’uscita regolabile, che va registrato in modo da fornire al corpo a LED del proiettore una corrente tale da farlo lavorare a circa 10 watt.

Di solito ciò si ottiene a circa 30 volt. Comunque ricordate che la potenza è data dal prodotto VxI, quindi corrente per tensione (si ottiene in watt se V è espressa in volt e I in ampere), quindi a 30 V, la corrente assorbita dev’essere poco sotto i 340 mA.

Sebbene il gruppo di LED sia internamente protetto da sovracorrente, considerato che lo STEPUP30V ha una limitazione della corrente di uscita a 2A, può essere utile sostituirlo con un DC/DC elevatore dotato di regolazione della corrente di uscita; un valido esempio è reperibile sul sito www.futurashop.it ed è codificato come STEPUP30VADJ.

Della ricezione dei dati provenienti dal telecomando si occupa lo shield PS2SHIELD, per il quale il costruttore rende disponibile la specifica libreria; nel Listato 1 potete vedere un esempio di sketch per implementare la ricezione sulla seriale di Arduino dei comandi trasmessi dai pulsanti della console PS2.

Lo shield effettua la ricezione e la decodifica dei comandi; la parte radio è staccata e corrisponde all’RX_PS2, che va inserito nell’apposito connettore.

Listato 1

#include <Shield_PS2.h>

//declare class objects
PS2 ps2 = PS2(); //PS2 class object: ps2

#define LEDPIN 13

void setup() {
  Serial.begin(9600);
  ps2.init(9600, 2, 3); //initialize the main board to use desired (baudrate, rx, tx)
  //for Arduino Mega use RX:10, TX: 11 for software serial
  //for Arduino Leonardo use pin 8, 9, 10, 11 as RX and TX for software serial

  pinMode(LEDPIN, OUTPUT);
  digitalWrite(LEDPIN, LOW);

}
void loop() {
  if (ps2.getval(p_up) == 0) {
    Serial.println(“UP”);
  }
  if (ps2.getval(p_down) == 0) {
    Serial.println(“DOWN”);
  }
  if (ps2.getval(p_right) == 0) {
    Serial.println(“RIGHT”);
  }
  if (ps2.getval(p_left) == 0) {
    Serial.println(“LEFT”);
  }
  if (ps2.getval(p_triangle) == 0) {
    Serial.println(“TRIANGOLO”);
  }
  if (ps2.getval(p_cross) == 0) {
    Serial.println(“X”);
  }
  if (ps2.getval(p_circle) == 0) {
    Serial.println(“CERCHIO”);
  }
  if (ps2.getval(p_square) == 0) {
    Serial.println(“QUADRATO”);
  }
  if (ps2.getval(p_l1) == 0) {
    Serial.println(“L1”);
  }
  if (ps2.getval(p_l2) == 0) {
    Serial.println(“L2”);
  }
  if (ps2.getval(p_r1) == 0) {
    Serial.println(“R1”);
  }
  if (ps2.getval(p_r2) == 0) {
    Serial.println(“R2”);
  }
  if (ps2.getval(p_start) == 0) {
    Serial.println(“START”);
  }
  if (ps2.getval(p_select) == 0) {
    Serial.println(“SELECT”);
  }
}

L’ultima cosa da notare è la fotoresistenza, impiegata per far rilevare ad Arduino l’illuminazione dell’ambiente e comandare la scheda RELAY1CH in modo che il proiettore a LED venga acceso; il componente è alimentato a partitore di tensione da un resistore da 10 kohm (1/4 di watt) e viene letto dall’input analogico A0 di Arduino. I 5 volt vengono prelevati dal 5V di Arduino.

Il funzionamento dell’insieme è semplice: in condizioni di buona illuminazione, la resistenza del fotoresistore è bassa e la tensione letta dall’ADC del microcontrollore di Arduino è bassa e non fa scattare il comando della scheda relé; al buio la resistenza incrementa molto e l’ADC legge una tensione prossima ai 5 volt, che causa l’accensione del proiettore.

Il Firmware del robot spazzaneve con Arduino

Il firmware di gestione del robot è relativamente semplice; per comprenderne la struttura è opportuno, prima, spendere qualche parola sugli shield che deve controllare e, in particolare, su quello PS2.

Infatti del Motor Shield VMA03 abbiamo già parlato diffusamente in altri articoli perché l’abbiamo impiegato in vari progetti, quindi ci limitiamo a dire che della sua gestione si occupa l’apposita libreria che abbiamo già previsto di includere nello sketch e che richiede un segnale PWM ed un livello logico di enable.

Spieghiamo un po’ le caratteristiche salienti dello Shield PS2 e le principali funzioni della libreria ad esso dedicata.

Lo shield permette di utilizzare il controller wireless (o quello via cavo) della Playstation 2, consentendo di comandare a distanza robot o altri dispositivi; per come è stato progettato, può essere utilizzato con Arduino Uno Rev. 3, Duemilanove, Mega e Leonardo.

È dotato di pulsante di reset per ripetere quello di Arduino, di jumper per impostare vari Baud Rate (9.600, 57.600, 115.200 bps), nonché di LED di stato e di jumper per selezionare i pin utilizzati per il TX e l’RX dei dati, alternativi a quelli predefiniti dell’UART.

A tale riguardo diciamo che sulla scheda Arduino Uno i pin D0 e D1 corrispondono alla seriale hardware e che il loro significato è, rispettivamente, TX e RX. È comunque possibile riallocare le linee TX e RX via software, assegnandole ad altri pin (TX: pin 1, 3, 9, 11 – RX: 0, 2, 8, 10) caricando l’apposita libreria New Software Serial, che permette di emulare la porta seriale su coppie di I/O digitali purché non già utilizzati da altre risorse hardware (ovvero altri shield).

Notate che se utilizzate i pin della seriale hardware (D0, D1), bisogna ricordarsi di staccare il connettore PS2 dallo Shield prima di iniziare a programmare Arduino Uno.

Lo shield PS2 è in grado, tramite l’apposita libreria, di riconoscere e gestire tutti i pulsanti e i joystick analogici del controller della PS2. Ogni joystick analogico (destro e sinistro) ha due assi (X e Y) e due formati di output: analogico 1 e 2. Nel formato di output analogico 1 ci sono 2 variabili per ogni joystick, assi X e Y. In base a come spostiamo la leva del joystick, si ottiene in uscita un valore da 0 a 255 (guardate la Fig. 18), corrispondente alla posizione della levetta.

Fig. 18

Fig. 19

Asse Y:
• Posizione centrale (neutro), il valore è 128.
• Spingendo in up, il valore cambia da 128 a 0
• Spingendo in down, il valore cambia da 128 a 255.

Asse X:
• Posizione centrale (neutro), il valore è 128.
• Spingendo verso sinistra, il valore cambia da 128 a 0.
• Spingendo verso destra, il valore cambia da 128 a 255.

Nel formato di output analogico 2 ci sono quattro variabili per ogni joystick (up, down, left e right). Quando l’utente muove il joystick in una direzione, il valore delle 4 variabili cambia da 0 a 100. I joystick di destra e di sinistra avranno quindi assegnate ciascuno quattro variabili indipendenti.

Possiamo perciò decidere tra i seguenti due formati di output:

Le variabili del formato 1 sono:
• j_lx – Left joystick, X axis
• j_ly – Left joystick, Y axis
• j_rx – Right joystick, X axis
• j_ry – Right joystick, Y axis

Quelle del formato 2 sono:
• j_lu – Left joystick, up axis
• j_ld – Left joystick, down axis
• j_ll – Left joystick, left axis
• j_lr – Left joystick, right axis
• j_ru – Right joystick, up axis
• j_rd – Right joystick, down axis
• j_rl – Right joystick, left axis
• j_rr – Right joystick, right axis

Per quanto riguarda la gestione dei pulsanti del controller della PS2, basta semplicemente verificare lo stato del pulsante che ci interessa e andare a leggere il valore restituito, che può essere:
• 0 se il pulsante è premuto;
• 1 se il pulsante non è premuto.

Ad esempio, se vogliamo sapere se è stato premuto il pulsante “UP”, dovremo scrivere la seguente istruzione:

ps2.getval(p_up)==0

È anche possibile sostituire “p_up” con il valore decimale corrispondente, che in questo caso è “4 “. Per il resto delle corrispondenze fate riferimento al manuale fornito con lo shield.

Lo shield PS2 è in anche in grado di gestire i due piccoli motori interni al controller della PS2 che determinano la vibrazione (sinistra e destra): i relativi comandi richiedono due byte di dati, il primo dei quali indica quale motore deve vibrare, mentre il byte successivo (secondo byte) indica lo stato del motore o la velocità (come mostrato nella Tabella 3).

Per utilizzare lo shield che gestisce i comandi provenienti dal controller della PS2 abbiamo utilizzato la libreria Shield_PS2.h realizzata dal produttore, la Malese Cytron. All’inizio del nostro sketch includiamo, con l’istruzione “ #include <Shield_PS2.h> “, la libreria necessaria alla corretta gestione dello shield per il controller della PS2.

 

Tabella 2

Tabella 3

 

Andiamo avanti e vediamo il controllo del proiettore a LED, che viene operato tramite il pin analogico A0 di Arduino Uno Rev3, cui è collegata la fotoresistenza che rileva la luminosità ambientale; quando la luce si abbassa oltre la soglia prevista, lo sketch attiva il proiettore, o meglio, fornisce lo stato logico alto alla scheda RELAY1CH, la quale che contiene un relé -di cui è reso disponibile l’intero scambio- attivato da livelli logici.

Nel progetto, di questa scheda utilizziamo lo scambio tra C ed N.A. e con esso commutiamo l’alimentazione diretta al DC/DC converter che alimenta il proiettore, perciò quando Arduino Uno fornisce lo stato logico 1 (tramite il proprio pin digitale 13) il relé scatta e chiude i predetti contatti, facendo accendere il proiettore a LED.

Proseguiamo con la descrizione e andiamo alla gestione dei tre attuatori lineari che permettono di alzare/abbassare e ruotare a destra/sinistra la pala: visto che richiedono una certa corrente, non potendo pilotarli direttamente con le linee di Arduino ci siamo affidati a un’interfaccia driver di potenza, che nello specifico è il Motor Shield della Futura Elettronica.

Dato che questa scheda richiede di essere pilotata con segnali PWM, il firmware che abbiamo progettato invia ai pin digitali 2 e 11 segnali PWM e ai pin 3 e 12 i segnali di enable diretti al Motor Shield.

Quanto ai motori di trazione MY016, anche in questo caso Arduino Uno non può pilotarli direttamente ma li gestisce attraverso due pin digitali che forniscono i segnali di controllo al driver di potenza corrispondente; i pin utilizzati allo scopo sono 5 e 6, anch’essi impostati per fornire dei segnali PWM con i quali i driver forniscono impulsi di larghezza variabile in modo da modulare la potenza fornita ai motori.

Nello sketch, il controllo PWM dei motori corrisponde alle variabile “E1” ed “E2”, corrispondenti rispettivamente ai pin digitali 5 e 6. Quanto ai pin digitali 4 e 7, corrispondono alle variabili, rispettivamente, “M1” e “M2”.

Riassumento, per la gestione da parte di Arduino Uno abbiamo creato le seguenti variabili: “FOTORES” per la fotoresistenza, “RELAY” per l’attivazione del relé che accende il proiettore, “sensorValue” dove viene memorizzato il valore della fotoresistenza; le variabili che gestiscono il movimenzo alza/abbassa della pala sono “ALZAPALA“ e “ONALZAPALA”, mentre quelle che che gestiscono il movimento destra/sinistra della pala sono “RUOTAPALA“ e “ONRUOTAPALA”.

Le varibili dei motori sono, come già detto, “E1”,”E2” e ”M1”, ”M2”. La variabile “velo” è quella dove viene salvato il valore della velocità dei motori, mentre la “motori” è quella dove viene salvato lo stato dei motori e permette di fermare i motori una volta che i pulsanti di direzione o il joystick di direzione vengono rilasciati. La variabile “stato” riguarda la gestione del proiettore a LED: se vale 0, l’accensione è subordinata alla condizione di illuminazione della fotoresistenza, mentre se vale 1 si comanda il proiettore con il relativo pulsante del controller PS2.

Listato 2

if (ps2.getval(p_circle) == 0) {
  Serial.println(“CERCHIO”);
  if (stato == 0) { // 
    stato = stato + 1;
    delay(100);
    Serial.println(stato);
    digitalWrite(RELAY, HIGH);
    ps2.vibrate(2, 255); // attiva la vibrazione sul controller

    delay(500); // pausa 500 ms
    ps2.vibrate(2, 0); // disattiva vibrazione
    delay(500);
    ps2.vibrate(2, 255);
    delay(500);
    ps2.vibrate(2, 0);
  } else {
    stato = 0;
    delay(100);
    Serial.println(stato);
    digitalWrite(RELAY, LOW);
    ps2.vibrate(2, 255); // attiva la vibrazione sul controller
    delay(500); // pausa 500 ms
    ps2.vibrate(2, 0); // disattiva vibrazione
  }

Visto che per sapere se è attiva una delle due funzioni non abbiamo alcun feedback, sul controller viene attivata la vibrazione; per l’esattezza, il controller PS2 vibra due volte e per un breve periodo per il pulsante, mentre una volta per la fotoresistenza (Listato 2):

Per i pin TX e RX abbiamo utilizzato rispettivamente il pin 9 e il pin 8, mentre come Baud Rate abbiamo selezionato 9.600. L’istruzione “ps2.getval (p_up)==0” permette di conoscere quale pulsante è stato attivato sul controller PS2: nel nostro caso abbiamo inserito “(p_up)=0” che permette di sapere se è stato premuto il pulsante “Up” del controller; se volete utilizzare un altro pulsante potete sostituire quello attuale con il pulsante che vi interessa (nel Listato 3 trovate l’elenco).

È anche possibile sostituirla con “(p_joy_lu)==100” per sapere se il joystick di sinistra è in posizione “UP” oppure sostituendola con “(p_joy_ld)==100” potete sapere se il joystick è in posizione “Down”, “(p_joy_lr)==100” se è “Right” e “(p_joy_11)==100” se è “Left”. Infine, potete utilizzare insieme le due istruzioni con “if( ps2.getval(p_up)==0 || ps2.getval(p_joy_lu)==100)” che permette di sapere se il pulsante “UP” è stato premuto o il joystick di sinistra è in posizione “UP”.

Listato 3

#########################
# Constants (LITERAL1)
#########################
p_select pulsante “select”
p_start pulsante “start”
p_up pulsante “up”
p_right pulsante “right”
p_down pulsante “down”
p_left pulsante “left”
p_triangle pulsante “triangolo”
p_circle pulsante “cerchio”
p_cross pulsante “X”
p_square pulsante “quadrato”
p_joy_lu Joystick sinistro “up”
p_joy_ld Joystick sinistro “down”
p_joy_11 Joystick sinistro “left”
p_joy_lr Joystick sinistro “right”
p_joy_ru Joystick destro “up”
p_joy_rd Joystick destro “down”
p_joy_rl Joystick destro “left”
p_joy_rr Joystick destro “right”

 

Il nostro sketch comincia con verificare il valore della variabile “motori”, impostata con un valore uguale a “0”. Se viene premuto il pulsante “Up” o il joystick sinistro viene spostato nella posizione “Up” [istruzione if( ps2.getval(p_up)==0 || ps2.getval(p_joy_lu)==100)], corrispondente nel nostro caso al movimento in avanti, verranno attivati i motori con il valore di velocità PWM “velo”, che può essere incrementato da 0 a 250 con il pulsante “triangolo” e diminuito con “X”.

Quando viene raggiunto il valore di velocità massima, corrispondente a 250, sul controller viene attivata per un breve periodo la vibrazione, come mostrato nel Listato 4.

Listato 4

if (ps2.getval(p_triangle) == 0) {
  Serial.println(“TRIANGOLO”);
  if (velo & lt; 250) {
    velo = velo + 25;
  } else {
    ps2.vibrate(2, 255); //non fa niente
    delay(500);
    ps2.vibrate(2, 0);
  }
  analogWrite(M1, velo);
  analogWrite(M2, velo);
  Serial.println(velo);
}