Arduino + IMU

In questa lezione cercheremo di utilizzare un Arduino UNO

e un IMU (giroscopi e accelerometri) per attivare dei motori
a spazzole (brushed) a seconda dell'inclinazione dei
sensori, in modo da simulare un mini multi-rotore. In
particolare useremo dei sensori MPU6050 o compatibili. Le
librerie per utilizzare questi sensori con Arduino sono
scaricabili all'indirizzo:
https://github.com/jrowberg/i2cdevlib/tree/master/Arduino
/MPU6050

Una volta installate le librerie nell'IDE Arduino,

connettiamo l'IMU MPU6050 ad Arduino UNO seguendo il
pinout che si legge sopra al sensore:
Per alcuni tipi di MPU6050 sono necessarie solo 4
connessioni ad Arduino, altre invece ne richiedono di più.
In questo caso, come da foto, nel abbiamo 6:

cavo rosso - 5V: da connettere ai 5V di Arduino UNO

cavo nero – GND: da connettere al GND (negativo)
cavo arancione – 3.3V: da connettere ai 3.3v
cavo verde – SCL: da connettere al pin A5
cavo giallo – SDA: da connettere al pin A4
cavo blu – INT: da connettere al pin 0 (non A0)

Le prime tre connessioni in elenco servono ovviamente per

alimentare l'IMU in questione, questo particolare sensore
richiede sia i 5V che i 3.3V, altri solo uno dei due. Il GND,
ovvero il negativo o massa è richiesto per tutti i sensori.
L'SDA e SCL sono le connessioni che servono per far
comunicare Arduino UNO con i sensori e viceversa. E' un
tipo di connessione che si dice “a BUS” ed in particolare
i2c. L'i2c è molto diffuso perché consente di usare solo 2
cavi per più sensori messi in serie. Il Master (in questo
caso Arduino) invia dei segnali di clock tramite il cavo SCL
e identifica un sensore (Slave) che gli risponde inviando i
dati richiesti tramite cavo SDA. Per poter riconoscere più
sensori sullo stesso cavo ovviamente è necessario un
indirizzo. Infatti ogni sensore ha il proprio che il Master
dovrà specificare nel momento della richiesta dei dati. In
questo caso, il sensore MPU6050 che troviamo online può
avere 2 indirizzi diversi: 0x68 e 0x69. Se eseguendo il
codice di esempio non riusciamo a comunicare o a ricevere
dati dal sensore molto probabilmente dovremmo cambiare
l'indirizzo i2c al momento della creazione dell'oggetto
MPU6050. Più facile a farsi che a dirsi.
Quindi dopo aver collegato tutto avremo qualcosa di simile:
Facciamo partire l'IDE Arduino ed apriamo il programma di
esempio dalla libreria MPU6050 con nome MPU6050_DMP6
tramite il menu File → Examples → MPU6050 → Examples
→ MPU6050_DMP6.
Non spaventatevi dalla quantità di codice scritto in questo
esempio. E' ricco di commenti (scritte di colore grigio) in
modo da aiutare a comprendere ed utilizzare al meglio il
sensore IMU. Nelle prime righe di codice troveremo delle
indicazioni su che tipo di OUTPUT vogliamo avere dal
sensore. Per leggere i valori di YAW, PITCH e ROLL dal
sensore dovremo de-commentare (levare le doppie slash
prima della riga) la riga:

//#define OUTPUT_READABLE_YAWPITCHROLL

in modo che diventi:

#define OUTPUT_READABLE_YAWPITCHROLL

Connettendo ora Arduino al computer e inviando il codice

così com'è, potremo leggere i valori dati dal sensore
aprendo la finestra del monitor Seriale tramite il menu
Tools e selezionando come velocità 115200 in basso a
destra. Inserendo un qualsiasi carattere da tastiera e
dando invio nella finestra monitor seriale, inizieranno a
scorrere i valori dei sensori che cambieranno al ruotare del
sensore stesso. Siccome i valori di tale sensore sono salvati
nella variabile array ypr[], possiamo semplicemente
azionare un motore connesso ad esempio al pin 10 (pin
digitale PWM) se una certa soglia di valore è superata.
Ipotizzando di voler azionare il motore ed aumentare
velocità in base all'inclinazione sull'asse Y (quindi sull'asse
del Pitch) dovremo solo mappare i valori letti dalla variabile
ypr[1] in valori da 0 a 255 ed inviarli al pin 10, sapendo
che i valori che restituisce il sensore sull'asse delle Y sono
180 e vanno da -90 a +90.
Quindi il codice che dovremo scrivere per il primo motore
sarà:

analogWrite( 10, map( ypr[1], -90, 0, 255, 0 ) );

Ovviamente questo non è che un esempio che non utilizza

il sistema PID per la stabilizzazione, diciamo che abbiamo
ridotto all'osso l'operazione che compie un flight controller,
ma questo esercizio serve per capire cosa effettivamente
succede all'interno di un flight controller.