Mille modi per distruggere Arduino

Arduino è veramente un dispositivo robusto, molto ben pensato e semplice.

Tuttavia non è poi così difficile distruggerlo\danneggiarlo.

Questa breve guida mette sul tavolo diverse "esperienze" su cosa NON fare con Arduino.

Power for Arduino!

Domanda da un milione di dollari, come alimento Arduino?
Classica risposta, tramite USB.

Nel caso volessimo fare di più, controllare carichi più "pesanti"?
Alimento da jack? ma brucio qualcosa? stacco o non stacco la USB?
... e Vin.... cos'è? .... dov'è?!?

Questa piccola guida vuole fare un po' di chiarezza su come Arduino, sotto la scocca, mangia e smista l'energia data da una qualunque fonte.

I mille utilizzi del 7805

Il regolatore di tensione LM7805 è uno dei regolatori più famosi ed economici presenti sul mercato.

Approfondimento sensori IR

Riassumiamo il corretto funzionamento del sensore IR nel nostro Line Follower.

Il dispositivo IR ha due componenti essenziali:

• trasmettitore, che emette un segnale ( onda ) ad infrarossi 
• ricevitore, che riceve un'onda ad infrarossi

Come si riassume nell'immagine, un oggetto "nero" assorbe tutta l'onda infrarossa spedita dal trasmettitore.
Nel caso opposto, un oggetto "bianco" assorbe parzialmente l'onda del trasmettitore, ed una porzione ritorna verso il ricevitore.

Tipicamente il sensore manda ad Arduino uno 0 per il bianco, ed un 1 per il nero.
Per verificare come ragiona il nostro modulo IR utilizziamo: https://goo.gl/cdCJNC

Il sensore, quindi:

stima la quantità di luce riflessa dall'oggetto, determinando il colore della linea.

Successivamente il programma decide come affrontare il problema.

Materiali diversi riflettono in modo diverso, quindi per avere una miglior lettura da parte del sensore, abbiamo un piccolo trimmer regolabile posto sul componente.


Distanza minima, sensore oggetto:
Le onde tendono a spegnersi, deteriorarsi, nelle lunghe distanze.
Per questo motivo è un punto, non trascurabile, la distanza del sensore rispetto alla linea.

Il modulo IR per Arduino, monta una coppia ricevitore-trasmettitore chiamata TCRT-5000.
Dal suo datasheet leggiamo che la distanza ottimale sensore-oggetto è di 0.1 - 1.5 cm.
Si riporta una distanza massima di 2.5 cm.

IMU GY-521 accelerometro - giroscopio - termometro

IMU (Inertia Measurement Unit) sensors, questo il nome tecnico del nostro sensore GY-521.

Un dispositivo con questo appellativo, appunto IMU, è un dispositivo che ingloba 2 sensori:

1. Accelerometro [ (m/s2) o G-force ]
2. Giroscopio [ RPM o gradi su secondi]

che tramite un'apposita centralina di controllo ed elaborazione ( MPU-6050 ) calcola posizione, velocità e orientamento.

Libreria Maestro Pololu per MatLab

Per poter utilizzare al meglio il nostro modulo Maestro Pololu direttamente in MatLab ho scritto qualche riga di codice. 

Per poter comunicare correttamente ci sono diversi passi preliminari da impostare:

1. Tramite il Pololu Servo Controller Software, impostare USB Dual port mode.
   
2. Nella directory del MatLab creiamo un nuovo file chiamato "java.opts" scrivendoci queste riga:  -Dgnu.io.rxtx.SerialPorts=/dev/ttyS0:/dev/ttyS1:/dev/USB0:/dev/ttyACM0
   Al prossimo riavvio del MatLab verrà caricata automaticamente.

Esempio di funzione chiamante nella console:

movePololuServo('/dev/ttyACM0', 0, 6120);

Dove:

• movePololuServo è la funzione per muovere il servo.
• /dev/ttyACM0 è la porta di comunicazione con Arduino.
• 0 è il primo servo collegato.
• 6120 la posizione.

Nel caso ci fossero problemi o modifiche da consigliare, sentitevi liberi di commentare qui sotto oppure su GIT.

DIY ATtiny Programming Shield for Arduino

Spesso per questioni di comodità si utilizza un programmatore per testare e scrivere la nostra ATtiny. Utilizzando Arduino come programmatore, sarebbe comodo avere una basetta -shield- collegabile direttamente ad Arduino per programmare la nostra ATtiny.

by Plusea

Questa guida ci aiuterà a creare DIY la nostra Shield Arduino Attiny85\45.

Make it Modena FabLab

Eccoci ci siamo quasi!

Presto sarà disponibile il sito, il forum ( che è importante più del sito, per aiutarci e scambiare informazioni ) e la wiki.

Vorrei spendere due righe per riassumere la mia esperienza e come, grazie alle persone giuste e tanta determinazione, siamo arrivati a questo punto, il FabLab.

Primo esempio ATtiny85 Arduino

Come primo esempio utilizzeremo un programma pre-predefinito per Arduino, in modo da dimostrare il completo collegamento con la maggior parte dei comandi Arduino-ATtiny.

photo by http://goo.gl/QwXkNL

Per prima cosa colleghiamo correttamente la nostra ATtiny85 ad Arduino configurato come ISP, guida.

A questo punto, nell'Arduino IDE, selezioniamo File --> Esempi --> Basics --> Blink .

Ora cambiamo il pin a cui collegheremo il led e la nostra resistenza, da 13 a 0.

Ora seguendo gli accorgimenti NECESSARI di questa guida, colleghiamo un led ed una resistenza al pin 5 (fisico) della nostra ATtiny85.

A questo punto carichiamo il programma normalmente, come se lo volessimo caricare su Arduino.
L'ISP si prenderò la briga di caricarlo correttamente sulla nostra ATtiny85.

Il risultato? la foto qui in testa! il led inizierà ad accendersi e spegnersi secondo le indicazioni del nostro programma.


Riporto tutti i comandi Arduino riconosciuti anche dalla ATtiny85:

• pinMode()
• digitalWrite()
• digitalRead()
• analogRead()
• analogWrite()
• shiftOut()
• pulseIn()
• millis()
• micros()
• delay()
• delayMicroseconds()
• SoftwareSerial (has been updated in Arduino 1.0)

PIN out / int ATtiny85

Vediamo rapidamente, tramite questa utilissima immagine, le uscite e gli ingressi della nostra ATtiny85.

Prima di tutto impariamo a leggere questa immagine.

Di necessario dobbiamo tener presente due indicazioni:

• Pin utilizzabili da Arduino, quelli che useremo nell'IDE
• Sono quelli nelle nei pallini verdi, rossi e blu.

• Pin che indicano i piedini fisici del componente
• Sono quelli all'interno del componente.

Per capire meglio come mai questa differenza sia NECESSARIA, vi riporto questo esempio.

Quando dobbiamo fisicamente collegare la nostra ATtiny85 ad Arduino impostato come ISP, dobbiamo far riferimento ai pin fisici del componente.

Questi sono quelli interni al componente, partono da 1, in alto a sinistra, scendono fino all'4, ricominciando dall'altra parte nel componente (dal basso verso l'alto).

Immaginiamo di collegare un led, i pin fisici 4 e 8 non sono utilizzabili, in quanto sono l'alimentazione.

Rimangono i pin 1,2,3,5,6,7.

Immaginiamo di collegare il led ( con la sua resistenza ) al pin fisico  2.

Quando andremo a definire, nell'Arduino IDE, quale pin è collegato al led, dovremo guardare i numeri al di fuori del componente, quelli colorati.

Il pin fisico 2 (dove c'è il led) è collegato al pin 3 dell'Arduino IDE.

Questo è il primo passo necessario per la corretta lettura di questa utilissima immagine guida.


Un ulteriore esempio degno di nota sono i pin fisici 2,3,7.
Se vogliamo utilizzarli come pin Analogici, dovremo chiamarli con i numeri rossi che iniziano per 'A' .
Mentre se vogliamo utilizzarli come pin Digitali, li chiameremo con i numeri blu.
I piedini PWM sono contrassegnati con il colore verde.

Collegamento ATtiny85 e Arduino ISP

Guida precedente, libreria necessaria: Arduino IDE e ATtiny85 .

Questa guida vi spiegherà come collegare fisicamente il nostro ISP ( Arduino in questo caso ) con l'ATtiny85.

Per prima cosa è necessario avere:

• scheda Arduino ONE o Duemilanove
• ATtiny85 oppure una ATtiny45 ( entrambe a 8 pin )
• un condensatore da 10uF, non più richiesto.
• breadboard
• svariati cavi
  

1. Passo zero, caricare sull'Arduino l'esempio "ArduinoISP".
2. Montare lo schema riportato fisicamente qui sotto:

NOTA: sull'ATtiny c'è un pallino che indica il primo pin, quello è collegato con il cavo giallo al pin 10.

Come indicato nella guida precedente, ricordiamoci d'impostare nell'Arduino IDE:

• "tools" --> "board" --> "ATtiny"
• "tools" --> "processor" --> "ATtiny85"
• "tools" --> "programmer" --> "Arduino as ISP"

Arduino IDE e ATtiny85

Come abbiamo già visto in questo articolo possiamo programmare la nostra ATtiny85 utilizzando il nostro Arduino come Programmer (ISP) oppure utilizzando un programmer esterno ( esempio ).

La guida è identica per entrambi i casi.

Per prima cosa, rendiamo il nostro Arduino IDE in grado di "scrivere" sull'ATtiny85.

Git ufficiale del progetto

Nota: per questa procedura serve una versione dell'IDE d'Arduino almeno 1.6.4 o superiore.

Aggiunta boards ATtinyXX:

Apriamo il nostro Arduino IDE ed andiamo in "File" --> "preferences" .

 Qui troviamo un'icona di due finestrelle in basso a destra. Clicchiamoci.

Copiamo ed incolliamo nella casella questa stringa:

https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

Clicchiamo su "ok" e poi di nuovo "ok" per tornare all'IDE d'Arduino.

Ora sotto il menu "tools" --> "board" --> "boards manager"  andiamo a cercare ATtiny .

Installiamo questo pacchetto.

Chiudiamo quest'ultima finestra e tornando in "tools" --> "board" leggeremo ATiny; selezioniamola.

Sempre sotto "tools" --> "processor" selezioniamo ATtiny85.

Ora la guida si dirama:

• Programmare ATtiny85 tramite Arduino ISP
• Caricare sull'Arduino l'esempio "ArduinoISP".
• Nell'Arduino IDE selezioniamo "tools" --> "programmer" --> "Arduino as ISP".
• Guida al corretto collegamento tra Arduino ISP e ATtiny85.
• Caricare il programma sull'ATtiny85.

• Programmare ATtiny85 tramite programmer esterno
• Seguiamo la guida data dal produttore del nostro programmer esterno.

Bootloader e Programmer

Come abbiamo visto nella guida precedente stiamo parlando di microcontrollori, che sia quello montato su Arduino o una ATtiny85, entrambi hanno bisogno del Bootloader o Programmer.

Andiamo per ordine, cos'è un Programmer?

Un programmer è un piccolo dispositivo che permette di far comunicare un microcontrollore con il pc.

Pensateci, un oggetto con 8,16,24 pin, come lo collegate fisicamente al computer per programmarlo?

In sostanza vi sto dicendo che per programmare un microcontrollore serve un programmer.

Per rendere meglio l'idea guardiamo questo comune programmer per ATtiny85.

Programmer per ATtiny85

Guardiamo i punti salienti:

La USB ci permette di collegarci al pc, l'ATtiny84 è un microcontrollore che fa da programmer (si nel programmer c'è un microcontrollore per programmare un microcontrollore XD ) ed il Socket dove andremo a mettere la nostra ATtiny85 da programmare.

Ma Arduino? Arduino non ha un programmer?

In effetti Arduino non ha un suo programmer, chi ha studiato e creato Arduino non voleva complicare la vita ai novizi, quindi si sono inventati il Bootloader.

Il bootloader è un software che incorpora due cose:

• il codice del vostro programma
• il programmer, per interfacciarsi con il pc

Il trucco sta tutto qui, quello che veniva fatto dal programmer ( il microcontrollore ATtiny84 ) ora viene fatto dal microcontroller d'Arduino. 

In somma, sparisce un microcontrollore per programmare Arduino.

La domanda sorge spontanea, ma perchè devo utilizzare un programmatore? sarà ben più comodo e furbo come fa Arduino?

Arduino ha molta memoria rispetto ad una ATtiny85, 32 KB contro 8 KB della ATtiny, se pensiamo d'incorporare nel codice anche il bootloader sprechiamo troppa memoria!

Ed ecco spiegato il motivo per il quale si usa un programmatore per programmare un'ATtiny.

Quindi devo comprare un programmer per utilizzare l'ATtiny85?

Fortunatamente no, possiamo istruire Arduino come un programmer!

Nella successiva guida vedremo come farlo nei dettagli, per poi crearne una versione più evoluta e comoda.

Introduzione ATtiny85 Arduino

La prima cosa che dobbiamo chiarire, prima d'addentrarci in come usare la nostra ATtiny85, è: cos'è un ATtiny?

Microcontrollori

AT è l'acronimo del produttore di queste "mini Arduino", appunto ATMEL. Questa enorme e storica casa crea microcontrollori da sempre, compreso quello che troviamo sul nostro Arduino.

ATMEL produce una vastissima gamma di microcontrollori, tra cui troviamo quello montato su Arduino (vedi immagine sotto) e diversi tipi di ATtinyXX. 

In questa guida ci concentreremo sulla ATtiny85.

Se prendete il vostro Arduino, noterete un microcontrollore ATMEL proprio sulla scheda:

Microcontrollore puntato dal cacciavite

Come potete vedere ha molti più pin, piedini, rispetto alla nostra ATtiny85, che ha solo 8 pin, piedini.

Eccola la nostra ATtiny85

Insomma, per rispondere alla domanda cos'è una ATtiny , la risposta più generica è "un altro microcontrollore", in particolare l'ATtiny85 ha la possibilità di caricare il codice Arduino.

Ed ecco perchè così tanto interesse per la versione ATtiny85.

La seconda domanda da porsi è: perchè usarla? 

ho già un Arduino, che fa più cose avendo anche più pin, piedini.

Forse è meglio vedere la soluzione di questa domanda da un'altro punto di vista.

Per tutti i progetti che avete realizzato con un Arduino, quanti pin avete utilizzato? 

Tipicamente dai 3 ai 5 pin, è raro utilizzarne di più. 

Altro punto di vista per rispondere a questa domanda è: quanto ci costa un Arduino?

Una volta creato il nostro progetto l'Arduino è giù utilizzato, e se volessi cominciare un nuovo progetto? 

E' impensabile comprare più Arduino, per diversi progetti, non costa poi così poco...

Per non parlare del fatto che, un Arduino, è veramente sprecata se la si mette in una scatola con solo 3 pin attaccati....

Molto più compatto e versatile d'un Arduino

Ora abbiamo diversi punti di vista per arrivare alla risposta: perchè usarla .

Arduino è un'ottima scheda di progetto, versatile ed utilizzabile per progettare di tutto.

Una volta progettata la nostra idea, basterà prendere una scheda compatibile con il codice Arduino, come la nostra ATtiny85, ed esportare il codice precedentemente provato su Arduino.

A questo punto, avremo un "mini Arduino" da mettere in qualsiasi scatola! 

Vi ricordo che un'ATtiny85 costa circa 3 euro!

Una nota aggiuntiva, più che utile, moltissime librerie per Arduino sono perfettamente compatibili con l'ATtiny85. Più avanti nelle guide lo metteremo meglio alla luce.

Avendo appena riposto alle domande minime per comprendere l'utilizzo e la necessità nello studiare la nostra ATtiny85, i prossimi passi saranno quelli necessari per compilare e far funzionare correttamente la nostra ATtiny85 con l'IDE d'Arduino.

3Doodler hack

3Doodler hack

Prima di tutto, cos'è la penna 3Doobler? 

Questa penna nata su kickstarter, è una semplice versione "manuale" d'una stampante 3D. 

Per non perdere troppo tempo nella descrizione della penna, non compete a questo post, vi lascio un video autoesplicativo:

Ma guardiamo più da vicino questa penna:

Sul lato di questa penna troviamo 3 forellini, partendo da destra verso sinistra:

• Pin 0 = GND
• Pin 1 = Slow
• Pin 2 = Fast

Collegando con un cavetto questi Pin, a coppie per chiudere il circuito, abbiamo queste combinazioni:

• GND + Slow = la penna estrude in Slow
• GND + Fast = la penna estrude in Fast
• GND + GND = combinazione impossibile, non ci si riesce fisicamente!
• Fast + Slow o Slow + Fast = nessun effetto, non utilizzata
• Fast + Slow + GND = modalità Reverse

Quindi, solo le combinazioni verdi hanno senso, le altre no. In totale 4.

La domanda sorge spontanea, Fast, Slow e lo STOP? Basta non chiudere il circuito. Quindi collegare GND a nessun altro Pin.

Questo articolo nasce per poter collegare ad un Arduino, o in generale ad un controllore, che controlli automaticamente, secondo un programma, la nostra penna.

Bene, in sostanza dobbiamo collegare queste coppie per avere le 4 combinazioni essenziali.

Per farlo utilizziamo un transistor. 

Il principio di funzionamento è questo, il circuito è in ON ( immagine a sinistra ) quando Arduino manda un comando HIGH , +5 V.

Questo stato equivale a collegare due Pin, appunto in coppia.

L'opposto è il circuito in OFF ( immagine di destra ), quando Arduino manda un comando LOW, 0 V.

Sfruttando questo principio ho creato questo circuito con due transistor:

Arduino manda un segnale di HIGH o LOW sui Pin 8 e 7 . Mandando l'impulso HIGH si accende il transistor collegato a quel pin, mandano l'impulso LOW si spegne quel transistor al pin collegato.

Non accendendo nessun transistor ho la condizione di STOP.

Il codice ed il circuito relativo lo troverete sul mio GIT a questo indirizzo: 

Braccio robotico controllato tramite bluetooth

Il passaggio successivo per il controllo del braccio robotico è l'utilizzo del modulo Maestro per i movimenti ed il modulo HC-06 per la gestione bluetooth.

Ovviamente è fortemente consigliato aver seguito le guide per il controllo del modulo HC-06: http://goo.gl/JY0qrp

Lo schematico riportato sopra illustra tutti i collegamenti necessari per l'utilizzo.

Per prima cosa dobbiamo cambiare la BAUD del nostro modulo bluetooth, riprendiamo la guida: http://goo.gl/SV2Rym  colleghiamo il modulo HC-06 come indicato nella guida linkata ed utilizzando il comando: AT+BAUD5 andiamo a cambiare la BAUD da 9600 a 19200 .

Abbiamo ora cambiato la frequenza alla quale il nostro modulo bluetooth risponde, ora fissata a 19200.

Ricordo che nell'esempio su GIT HC-06_AT va cambiata la frequenza di risposta alla riga 19.

Ora è tutto pronto per caricare il codice necessario, lo trovate qui: https://goo.gl/Uzz1sJ  sotto la cartella "HC-06__Me_Arm__BT" .

Il codice è commentato, quindi potrete seguire passo passo il funzionamento.

Riporto un breve riassunto d'utilizzo: 

• Alla pressione del tasto 'a' vi verrà dato un messaggio di benvenuto.
• Selezionando uno dei 4 motori disponibili, il primo a partire da 0, vi verrà comunicato il motore scelto.
• Con i tasti 'j' e 'l' rispettivamente, si incrementerà o decrementerò il valore dedicato alla posizione del servo precedentemente selezionato.

Accensione d'un led su Arduino da telefono bluetooth

Ora che abbiamo visto come collegare e configurare il nostro HC-06 con Arduino, proviamo un vero e proprio utilizzo in remoto, tramite bluetooth d'un telefono.

Facciamo fede al nostro schema solito:

Una volta collegato come da schema, scarichiamo quest'app dall'Android Store: BlueTerm .

Con quest'app possiamo impartire comandi diretti a tutti i dispositivi bluetooth con i quali ci connetteremo.

Scarichiamo e carichiamo sull'Arduino l'esempio nella cartella "HC-06_blink_led_phone" che troviamo qui: https://goo.gl/CX1fiC

Connessione ed utilizzo:

Apriamo l'app, cerchiamo il nostro dispositivo denominato "HC-06". Alla richiesta della password digitiamo: 1234 .

A questo punto la lucina rossa del nostro HC-06 sarò rossa e fissa, non più lampeggiante, sinonimo d'una avvenuta connessione.

Il dispositivo è pronto a ricevere i comandi.

Se analizziamo il codice caricato tu Arduino, l'idea di base è quella di scrivere nel terminale un carattere 'a' per avere in risposta una scritta, oppure "0" o "1" per accendere o spegnere il led 13.

Questo è un banale ma primo esempio di collegamento e lettura di dati, da parte d'Arduino, ricevuto con il modulo bluetooth.

Modulo HC-06 Bluetooth

Impariamo ad utilizzare il modulo HC-06 Bluetooth da interfacciare con il nostro Arduino.

Come ormai è a tutti noto, i moduli Bluetooth sono ormai ovunque, con la loro semplicità d'utilizzo e connessione. 

Infatti ogni qualvolta vogliamo collegarci ad un dispositivo Bluetooth ci basta cercarlo e collegarci direttamente. Al massimo verrà richiesta una password di sicurezza.

Qualunque modulo Bluetooth si occupa di gestire correttamente la trasmissione da dispositivo a dispositivo a dispositivo, dando l'impressione all'utilizzatore di non aver nulla che lo divide tra il mittente ed il destinatario. 

HC-05 o HC-06 ?

Ci sono diversi modelli di moduli HC-0x in circolazione, i più recenti e comuni sono i modelli 05 e 06. 

Questi modelli sono identici, stesso chip, ma montano una versione diversa di firmware.

In questa guida si parlerà del modello più recente, l'HC-06. 

Altre info qui: http://goo.gl/MFY6C3


Collegamento e settaggi:
Il primo passo è il corretto collegamento, in quanto una delle porte, quella di RXD, riceve segnali a 3.3V e non a 5V come Arduino genera.
Come risolvo?
Per risolvere il problema si utilizza un partitore resistivo. Il rapporto di partizione è R2=2*R1 .

Una volta collegato tutto correttamente carichiamo un programma di prova e settaggio, lo trovate a questo indirizzo, sotto "HC-06_AT" : https://goo.gl/CX1fiC

Una volta caricato, apriamo la nostra seriale d'Arduino e digitiamo "AT", senza apici e maiuscolo.
Se il dispositivo ci risponderò con "OK" il collegamento è avvenuto con successo.

Riporto qui sotto una serie di comandi compatibili con la versione HC-06:

AT	OK	Used to verify communication
AT+VERSION	OKlinvorV1.8	The firmware version (version might depend on firmware)
AT+NAMExyz	OKsetname	Sets the module name to “xyz”
AT+PIN1234	OKsetPIN	Sets the module PIN to 1234
AT+BAUD1	OK1200	Sets the baud rate to 1200
AT+BAUD2	OK2400	Sets the baud rate to 2400
AT+BAUD3	OK4800	Sets the baud rate to 4800
AT+BAUD4	OK9600	Sets the baud rate to 9600
AT+BAUD5	OK19200	Sets the baud rate to 19200
AT+BAUD6	OK38400	Sets the baud rate to 38400
AT+BAUD7	OK57600	Sets the baud rate to 57600
AT+BAUD8	OK115200	Sets the baud rate to 115200
AT+BAUD9	OK230400	Sets the baud rate to 230400
AT+BAUDA	OK460800	Sets the baud rate to 460800
AT+BAUDB	OK921600	Sets the baud rate to 921600
AT+BAUDC	OK1382400	Sets the baud rate to 1382400

Perchè dovrei voler cambiare la "baud rate" del mio dispositivo?

L'HC-06 può cambiare la sua risposta ad una frequenza ben definita, magari sulla classica 9600 abbiamo collegato un altro modulo, ed Arduino può non essere in grado di distinguere i segnali dei diversi dispositivi.

Per questo motivo possiamo regolare la risposta in una certa baud rate del nostro HC-06 .

Delay() & Get Moving State

Una volta "perso" un po' di tempo su questi esempi, risolviamo i problemi relativo alla funzione delay() nel programma.

Analizziamo questo piccolo pezzo di codice a titolo d'esempio:

maestro.setTarget(0, 6000);
delay(3000); 
maestro.setTarget(0, 4000);

Una volta impartito un comando di posizione maestro.setTarget il programma non attende il tempo effettivo necessario al braccio per arrivare fisicamente a quella posizione, ma esegue immediatamente la funzione successiva, in questo caso delay(3000) .

Questo si traduce nel fatto che il braccio non aspetterà realmente 3 secondi prima della posizione successiva.

Per poter sviare a questo non piccolo inconveniente si utilizza un'altra funzione offerta dalla Maestro library, Get Moving State.
Questa funzione attende l'effettivo completamente del movimento da parte del braccio, prima d'eseguire la funzione successiva.

Proviamo a modificare il primo esempio visto aggiungendo questa nuova funzione:

#include <PololuMaestro.h>

#ifdef SERIAL_PORT_HARDWARE_OPEN
  #define maestroSerial SERIAL_PORT_HARDWARE_OPEN
#else
  #include 
  SoftwareSerial maestroSerial(10, 11);
#endif

MicroMaestro maestro(maestroSerial);

void setup()
{
  maestroSerial.begin(9600);
}

void loop()
{
  maestro.setSpeed(0, 20); 
  maestro.setAcceleration(0, 200);

  maestro.setTarget(0, 6000);
  maestro.getMovingState();
  delay(3000); 

  maestro.setTarget(0, 4000);
  maestro.getMovingState();
  delay(3000);  
}

Riassumendo la funzione maestro.getMovingState() è sempre accoppiata alla funzione maestro.setTarget per attendere l'effettivo completamento del movimento da parte del braccio.

Primo esempio di programma per il braccio robotico

Iniziamo a vedere come utilizzare i comandi fondamentali della Maestro library per muovere correttamente i nostri Servo motori.

Per prima cosa proviamo ad utilizzare un solo motore Servo, successivamente proveremo ad utilizzarne più Servo contemporaneamente.

// L'esercizio mostra il movimento di 1 motore, con relative accelerazioni e velocità.
#include <PololuMaestro.h>

#ifdef SERIAL_PORT_HARDWARE_OPEN
  #define maestroSerial SERIAL_PORT_HARDWARE_OPEN
#else
  #include 
  SoftwareSerial maestroSerial(10, 11);
#endif

MicroMaestro maestro(maestroSerial);

void setup()
{
  maestroSerial.begin(9600);
}

void loop()
{
 //con la funzione setSpeed imposto il numero del motore, la sua velocità
  maestro.setSpeed(0, 20); 
 
 //con la funzione setAcceleration imposto il numero del motore, la sua  accelerazione . Questo numero è compreso tra 0 ( accelerazione massima ) e 255
  maestro.setAcceleration(0, 200);

 //con la funzione setTarget imposto una posizione al motore, tipicamente tra 4000 e 8000
  maestro.setTarget(0, 6000);
  delay(3000); //aspetto 3 secondi prima di passare alla prossima posizione
  
  maestro.setTarget(0, 4000);
  delay(3000); //aspetto 3 secondi prima di passare alla prossima posizione
}

Possiamo modificare diversi parametri, in questo esempio, per il singolo Servo:

1. il numero del motore da comandare
2. la sua velocità
3. la sua accelerazione 

E' molto utile ed istruttivo capire cosa cambia il movimento del braccio al variare di questi parametri da noi fissati. Il passo immediatamente successivo è proprio il controllo di più motori contemporaneamente:

/* L'esercizio mostra il movimento di 3 motori contemporanemanete, con relative accellerazioni e velocità. 
*/

#include <PololuMaestro.h>

#ifdef SERIAL_PORT_HARDWARE_OPEN
  #define maestroSerial SERIAL_PORT_HARDWARE_OPEN
#else
  #include 
  SoftwareSerial maestroSerial(10, 11);
#endif

MicroMaestro maestro(maestroSerial);

void setup()
{
  maestroSerial.begin(9600);
}

void loop()
{
 //con la funzione setSpeed imposto il numero del motore, la sua velicità
  maestro.setSpeed(0, 20); 
  maestro.setSpeed(1, 10); 
  maestro.setSpeed(2, 10); 
 //con la funzione setAcceleration imposto il numero del motore, la sua  accellerazione . Questo numero è compreso tra 0 ( accelerazione massima ) e 255
  maestro.setAcceleration(0, 200);
  maestro.setAcceleration(1, 200);
  maestro.setAcceleration(2, 200);

 //con la funzione setTarget imposto una posizione al motore, tipicamente tra 4000 e 8000
  maestro.setTarget(0, 6000);
  maestro.setTarget(1, 4000);
  maestro.setTarget(2, 4000);
  delay(3000); //aspetto 3 secondi prima di passare alla prossima posizione
  
  maestro.setTarget(0, 4000);
  maestro.setTarget(1, 6000);
  maestro.setTarget(2, 6000);
  delay(3000);
}

Anche in questo caso i parametri che possiamo impostare sono i medesimi dell'esempio precedente, solo applicabili a diversi Servo motori.

Configurazione di base & Maestro library

Per prima cosa occupiamoci delle prime connessioni che ci forniranno una configurazione "base" per i nostri test e prove durate la programmazione.

Con queste connessioni saremo in grado di alimentare correttamente ogni componente, dal Maestro fino a tutti i motori utilizzati.
Rimane da collegare la USB che alimenta e comanda Arduino.

I motori sono connessi uno sotto l'altro nell'apposita parte dedicata, per maggiori informazioni sul collegamento vi riporto l'immagine seguente:

Installazione ed uso della Maestro library

Per prima cosa procuriamoci l'ultima versione dell'IDE d'Arduino dal sito ufficiale: http://goo.gl/JuskT

Una volta scaricato, scompattiamo il file "tar.xz" e apriamo la cartella appena scompattata.

Cliccando con il destro sul file denominato "arduino" , proprietà, permessi ed abilitiamo l'opzione esegui.

Ora basterà premere due volte sul file "arduino" per avviare l'eseguibile.

Un'opzione da eseguire per abilitare le porte USB per Arduino è la seguente, aprite il terminale e digitate:

sudo usermod -aG dialout <myuser>

Ricordatevi di sostituire la scritta in rosso con il nome del vostro user.

A questo punto l'IDE sarà pronto per ogni esigenza. 

Scarichiamo la libreria apposita per il nostro Maestro in questo modo:

Eseguiamo "Arduino", Sketch->Include Library->Manage Libraries .
A questo punto si aprirà una finestra con una funzione cerca, usiamola scrivendo: "PololuMaestro" .
Installiamo il pacchetto trovato.

A questo punto avremo a disposizione non solo la libreria, ma anche alcuni utili esempi.

MeMa - Progetto braccio robotico

Il progetto braccio robotico nasce dell'idea di voler utilizzare al meglio il mio Arduino e Raspberry Pi per progetti o sviluppi futuri in diversi campi. Diciamolo, dopo poco ci si scoccia ad usare Arduino e la Raspberry Pi per accendere o spegnere led!

L'idea è quella di poter avere un modulo, un braccio in questo caso, pilotato da diversi motori per svolgere le più svariate funzioni, sempre mantenendo la compatibilità con i diversi moduli ( shell ) Arduino e Raspberry Pi.

In questa prima fase, il montaggio, reperiamo tutto il necessario per il controllo e la connessione del braccio robotico.

Per la base del braccio ho trovato molto interessante il progetto open source "MeArm", recuperabile a questo indirizzo : http://goo.gl/sxX13z

Scaricato il disegno, si può decidere di stamparlo in 3D oppure tagliarlo su d'un foglio di plexiglas con un taglio laser.
Una volta stampato/tagliato tutti i componenti , basterà utilizzare questa guida passo passo per il montaggio: http://www.instructables.com/id/Pocket-Sized-Robot-Arm-meArm-V04/

Per quanto riguarda i motori il progetto è sagomato con i motori tipo SERVO con queste dimensioni: http://goo.gl/j3gDnt
Non importa la marca del servo, la potenza o altro, conta solo la dimensione compatibile con il progetto.

Per le viti, attenersi alla guida passo passo; alcune di queste M3 non sono di comune uso, meglio trovare un rivenditore specializzato in viti vicino a casa propria .

Connessione e controllo 

Una volta assemblato il tutto , ci troviamo con 4motori da comandare in PWM, con un numero di porte da occupare su Arduino considerevolmente alto. Analizziamo un modo molto più elegante e funzionale per il controllo dei motori. 

La mia soluzione è l'utilizzo d'un controller servo chiamato Maestro Micro: https://www.pololu.com/product/1350

Questo controller è comodo per controllare servo di diversa dimensione ed in numero elevato, oltre ad averne una miglior gestione. Per comandare questo controller sono necessari solo due pin d'Arduino.
Per controllare il corretto funzionamento del controller utilizzare questa libreria completa d'ogni funzione disponibile : https://github.com/pololu/maestro-arduino

Prossimamente scriverò qualche articolo con qualche riga di codice per comprendere meglio l'interfaccia tra controller e SERVO.

Collegamento Arduino - Matlab

La guida si riferisce al metodo utilizzato prima del rilascio del pacchetto di comunicazione ufficiale da parte di Mathworks per Arduino.

Questa guida vuole unire due strumenti, apparentemente, molto diversi:

Arduino, un micro controllore collegabile a diversi sensori 

Matlab, un programma d'analisi matematica

L'idea di base è utilizzare Arduino per la corretta connessione/accoppiamento di diversi sensori, lasciando a Matlab il compito di raccogliere ed analizzare i risultati.

Di base Arduino comunica in modo seriale con il computer o altri dispositivi, quindi per il corretto collegamento Arduino & Matlab è necessario iniziare - inizializzare - un canale di comunicazione; appunto seriale.

Per prima cosa iniziamo da Arduino, apriamo l'IDE che utilizziamo sempre per scrivere e caricare i nostri programmi dal pc ad Arduino:

Copiamo il programma seguente:

 void setup(){  
   Serial.begin(9600);  
   Serial.println('a');  
   char a = 'b';  
   while (a !='a'){  
     a=Serial.read();  
   }  
 }  
 void loop(){  
 }  

Il semplice programma inizializza una seriale a 9600 baud, scrivendo la lettera 'a' sulla seriale. Il ciclo si conclude  quando dalla seriale viene letto una lettera diversa da 'a' . In questo modo il dispositivo in ascolto avrà comunicato il corretto collegamento. Ora veniamo al codice Matlab:

Per prima cosa dobbiamo comunicare - nativamente - a Matlab la porta utilizzata da Arduino per comunicare, per farlo dobbiamo aprire un nuovo documento di testo ed inserire:

-Dgnu.io.rxtx.SerialPorts=/dev/ttyS0:/dev/ttyUSB0:/dev/ttyACM0

Salviamo il file di testo con il nome "java.opts" , dove 'java' è il nome ed il '.opts'  l'estensione. Ora dobbiamo fare in modo che Matlab  carichi il file quando necessario, scriviamo nella Command Window di Matlab i seguenti comandi, tenendo nota del risultato d'ogni uno:

matlabroot

e successivamente

computer('arch') 

Il file "java.opts" andrà salvato nella locazione: $MATLABROOT/bin/$ARCH

Dove andremo a sostituire i nomi colorati con i percorsi trovati dai comandi applicati prima in Command Window.


Ora apriamo Matlab, nuova funzione e copiamo il seguente programma:

 %scrivere in console  
 %instrhwinfo ('serial')  
 %comPort = '/dev/ttyACM0';  
 %[ s,flag ] = setupSerial( comPort );  
   
 function [s,flag] = setupSerial(comPort)  
   
 flag = 1;  
     
 s=serial(comPort);  
 set(s,'DataBits',8);  
 set(s,'StopBits',1);  
 set(s,'BaudRate',9600);   
 set(s,'Parity','none');  
 fopen(s); % fopen (serial),Connect serial port object to device  
 a='b';  
 while (a~='a')  
   a=fread(s,1,'uchar'); % fread (serial),Read binary data from device  
 end  
 if(a=='a')  
   disp('serial read');   
 end  
 fprintf(s,'%c','a'); % fprintf (serial),Write text to device  
 mbox= msgbox('Serial Communication setup.'); uiwait(mbox);  
 fscanf(s,'%u'); % fscanf (serial),Read ASCII data from device, and format as text  
 end  

La funzione setupSerial si occupa, nella prima parte, del corretta inizializzazione tramite la seriale con Arduino.
La seconda parte invia una lettera diversa dalla 'a' in ingresso ad Arduino, confermando l'avvenuto collegamento.
Usiamo 'mbox' per visualizzare a schermo un messaggio d'avvenuto collegamento.


Ora basterà caricare nella Command Windows di Matlab i seguenti comandi:

- porta di collegamento con Arduino con il comando:

comPort = '/dev/ttyACM0';

- avviare la funzione con il comando:

[ s,flag ] = setupSerial( comPort );

Se tutto risponde correttamente si visualizzerà un avviso con la scritta "Serial Communication setup" .

NOTE:
Come potete vedere dall'immagine qui sopra di Matlab, la finestra "current folder" è aperta sulla cartella contenente il file della funzione. Se così non fosse, potremmo riscontrare qualche messaggio d'errore tipo: Undefined function 'setupSerial' for input arguments of type 'char'

Script python Transmission

Per questione di comodità ho deciso di scrivere due semplici script, uno per collegare rapidamente pc e Raspberry tramite il comando ssh ed uno direttamente sul Raspberry con i comandi più utili.

Raspberry connection script:

Riposto qui lo script, vi basterà copiarlo in un file di testo e cambiare l'estensione da .txt a .py  .

#!/usr/bin/python
import os
print 'Raspberry connection script'
os.system("ssh pi@IP_RASPBERRY")

Ricordate di cambiare IP_RASPBERRY con l'indirizzo del vostro raspberry.

Salvate il tutto, cambiate successivamente l'estensione da .txt a .py .

Per renderlo subito eseguibile lo script clicchiamo con il destro, proprietà, permessi, mettiamo la spunta nell'ultima riga "esecuzione".

Una volta avviato vi verrò chiesto d'inserire la vostra password, e si collegherà automaticamente.

Raspberry Transmission script:

Questo script va scritto direttamente sul nostro raspberry, colleghiamoci tramite lo script appena scritto qui sopra ed iniziamo.

Creiamo lo script con il comando:

sudo nano transmission

ora copiamo lo script riportato qui sotto:

----------

 #!/usr/bin/python  
 #code by Dave Calaway http://goo.gl/7yt8Lf  
 import os  
 print 'Transmission script'  
 while True:  
  numero = int( raw_input('1 stop\n2 edit .json\n3 load setting\n4 reload transmission\n0 exit\n') )  
  if numero == 1:  
  os.system("sudo /etc/init.d/transmission-daemon stop")  
  if numero == 2:  
  os.system("cd /etc/transmission-daemon && sudo nano settings.json")  
  if numero == 3:  
  os.system("sudo /etc/init.d/transmission-daemon reload")  
  if numero == 4:  
  os.system("sudo /etc/init.d/transmission-daemon restart")  
  if numero == 0:  
  break  
 print 'bye :D'  

Ora salviamo premendo CTRL+O, invio per confermare il nome ed in fine CTRL+X per uscire dall'editor.

Ora proviamo ad avviarlo, scriviamo:

python transmission

ora seguiamo le informazioni a monitor.
Ogni volta che ci collegheremo al Raspberry lo script sarà li e pronto per essere avviato con il comando sopra citato.