Il sensore analizzato in questo articolo utilizza un chip Tilt sensor RPI-1031 che è in grado di rilevare l’inclinazione in quattro direzioni: avanti, indietro, a sinistra, a destra.
All’interno del sensore ci sono due fototransistor, un LED e un dispositivo mobile.
Citazione dell’articolo nella sezione News, Tecnologia del Blog di Elettronica In
Indice
Come funziona il Tilt sensor RPI-1031
Il funzionamento del RPI-1031 Tilt Sensor è molto semplice. All’interno del sensore è presente un led a infrarossi , che comunica con due ricevitori fotosensibili attraverso una superficie riflettente. Tra questi componenti e la superficie riflettente c’è una sorta di “copertura” che, a seconda del movimento del componente, può coprire il sensore IR o i ricevitori.
Spostando il sensore possiamo avere 4 stati :
- LED IR bloccato
- Ricevitore 1 oscurato
- Ricevitore 2 oscurato
- nessuno dei 3 bloccati o oscurati
Questi segnali vengono inviati ai pin S1 e S2 del modulo
Questo sensore è ideale nei casi in cui bisogna soltanto rilevare la direzione del movimento e non è necessario l’utilizzo di un ben più costoso accelerometro: ad esempio, nelle cornici digitali per cambiare l’orientamento delle fotografie in base alla rotazione della cornice
Caratteristiche del modulo sensore
- Produttore chip: ROHM Semiconductor
- Modello del chip: RPI-1031 (datasheet) , ora sostituito da RPI-1035 (datasheet)
- Tensione di alimentazione: 3.3 – 5Vcc
- Dissipazione di potenza di collettore: 80mW
- Dimensioni: 20×11 mm.
Schema elettrico del modulo
Analizziamo ora lo schema elettrico del sensore Tilt RPI-1031.
Questo deriva da quello presente sui data Sheet , ed è formato dal sensore che si presenta come un piccolo parallelepipedo che misura 3,3×3,7×2,4 mm.
Sono presenti tre resistenze: una limitatrice per l’alimentazione del Led IR e due poste sul collettore dei due fototransistor.
Il fototransistor è un transistor a giunzione bipolare realizzato in modo che la luce proveniente dal diodo IR possa raggiungere la giunzione tra la base ed il collettore permettendo il passaggio di corrente.
È poi presente la pin strip su cui fanno capo i due pin dell’alimentazione che può essere compresa tra i 3,3V e i 5V, più i due pin di uscita dei due fototransistor.
Il PCB misura circa 20×11 mm, ed è presente un foro dal diametro di 3,5 m per il suo fissaggio
Schema di base per l’utilizzo del sensore
Il progetto completo può essere anche scaricato dal mio account presso OSHWLab, utilizzando questo link.
Dove trovare il sensore?
Il sensore Tilt Sensor 4 direzioni può essere acquistato presso il sito FUTURA ELETTRONICA, il codice prodotto è 2846-RPI1031. Il suo costo, al momento della pubblicazione di questo articolo è di 4,90 €.
La pin strip maschio risulta già saldata sul PCB.
Citazione dell’articolo nella sezione News, Tecnologia di Elettronica In
Altri sensori di inclinazione
Sono disponibili altri due moduli che sono sensibili alla lori inclinazione, questi appartengono alla serie 37 in 1 Sensor Module Board Set Kit For Arduino:
- KY-017 Mercury open optical module
- KY-020 Tilt switch module
Questi però sono più limitati potendo rilevare soltanto l’inclinazione in una sola direzione
|
KY-017 Mercury open optical module |
|
Collegamento di base del sensore
Vediamo prima di tutto il collegamento di base del sensore Tilt Sensor 4 direzioni; in questo caso leggeremo i valori forniti dal sensore tramite il monitor seriale dell’IDE.
Materiale occorrente
Il materiale per realizzare il nostro progetto è formato da:
 Scheda Arduino UNO |
 Sensore Tilt Sensor 4 direzioni |
|
|
Schema dei collegamenti
Sketch test di base
Sotto è riportato lo sketch di base per la lettura del sensore, sarà visibile la posizione risultante dalla combinazione dei valori in uscita dai due pin S1 e S2.
Per la lettura occorre attivare il monitor seriale dell’IDE premendo l’apposito tasto
Il risultato sarà simile a questo
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
//Definizione pin int tilt_s1 = 3; int tilt_s2 = 4; int valore_s1, valore_s2; void setup() { Serial.begin(9600); //Impostazione pin come input pinMode(tilt_s1, INPUT); pinMode(tilt_s2, INPUT); Serial.println("Test del sensore tilt RPI-1031"); } void loop() { int position = getTiltPosition(); Serial.print("Poszione: "); Serial.print(position); Serial.print("\tUscita S1: "); Serial.print(valore_s1); Serial.print("\tUscita S2: "); Serial.println(valore_s2); //Ritardo nuova lettura delay(200); } int getTiltPosition() { valore_s1 = digitalRead(tilt_s1); valore_s2 = digitalRead(tilt_s2); return (valore_s1 << 1) | valore_s2; //bitwise math to combine the values } |
Visualizzazione su matrice di led
Per rendere più accattivante l’utilizzo del sensore utilizzeremo un Modulo matrice di led 8×8 pilotata dal driver MAX7219, questo ci permetterà di mostrare da quale lato è inclinato il modulo.
Per la sua gestione si utilizza l’interfaccia SPI, per cui sono sufficienti solamente tre pin più quelli di alimentazione.
Altre informazioni sulla matrice di led vedere l’articolo Matrice LED 8×8 pilotata da driver MAX7219
Video del test del sensore
Materiale necessario
| Scheda Arduino UNO |
Sensore Tilt Sensor 4 direzioni |
|
Modulo matrice LED 8×8 con MAX7219 |
 Bread board |
Cavi di collegamento colorati |
Schema dei collegamenti
Librerie di gestione della matrice led
Per facilitare l’uso del modulo sono disponibili varie librerie. Per il caricamento occorre aprire sotto il menù Sketch, #include libreria, “Gestione Librerie..”
Nel campo ricerca si inserirà “LedControl” , trovata la libreria , premendo su “More info..” apparirà il tasto “Installa” cliccare il tasto, la libreria verrà installata.
Per approfondire la problematica dell’istallazione delle librerie vedere l’articolo Arduino – Tutorial, come installare una libreria
Creazione degli Sprite
Per preparare gli Sprite da visualizzare sulla matrice si è utilizzata un’applicazione online creata da Miro Bozik, che permette di avere i codici numerici da utilizzare nello sketch
Il suo utilizzo è molto semplice, basterà cliccare nelle varie caselle per formare, nel nostro caso, delle frecce orientate nelle quatto direzioni.
Nella casella sottostate si formerà la stringa numerica da inserire poi nel programma
|
1 2 3 4 5 |
// Definizione caratteri byte alto[8] = {B00011000, B00111100, B01111110, B11111111, B00011000, B00011000, B00011000, B00011000}; byte basso[8] = {B00011000, B00011000, B00011000, B00011000, B11111111, B01111110, B00111100, B00011000}; byte dx[8] = {B00001000, B00001100, B00001110, B11111111, B11111111, B00001110, B00001100, B00001000}; byte sx[8] = {B00010000, B00110000, B01110000, B11111111, B11111111, B01110000, B00110000, B00010000}; |
Sketch test con display OLED
Sotto è riportato lo sketch utilizzato. Una volta attivato, rileverà l’inclinazione del sensore, e procederà all’attivazione. Sulla matrice dei led si accenderanno in modo da far apparire di volta in volta delle frecce orientate nel senso di inclinazione del sensore.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
#include "LedControl.h" #define DATA_PIN 11 #define CLK_PIN 13 #define CS_PIN 10 #define tilt_s1 3 #define tilt_s2 4 LedControl lc = LedControl(DATA_PIN, CLK_PIN, CS_PIN, 2); void setup() { //ACCENSIONE DISPLAY lc.shutdown(0, false); // luminosità media lc.setIntensity(0, 8); //Cancella display lc.clearDisplay(0); pinMode(tilt_s1, INPUT); pinMode(tilt_s2, INPUT); } // Definizione caratteri byte alto[8] = {B00011000, B00111100, B01111110, B11111111, B00011000, B00011000, B00011000, B00011000}; byte basso[8] = {B00011000, B00011000, B00011000, B00011000, B11111111, B01111110, B00111100, B00011000}; byte dx[8] = {B00001000, B00001100, B00001110, B11111111, B11111111, B00001110, B00001100, B00001000}; byte sx[8] = {B00010000, B00110000, B01110000, B11111111, B11111111, B01110000, B00110000, B00010000}; void loop() { int position = getTiltPos(); //top if (position == 0) { for (int row = 0; row < 8; row++) { lc.setRow(0, row, alto[row]); } } //right else if (position == 2) { for (int row = 0; row < 8; row++) { lc.setRow(0, row, dx[row]); } } //left else if (position == 1) { for (int row = 0; row < 8; row++) { lc.setRow(0, row, sx[row]); } } //bottom else if (position == 3) { for (int row = 0; row < 8; row++) { lc.setRow(0, row, basso[row]); } } } int getTiltPos() { int s1 = digitalRead(tilt_s1); int s2 = digitalRead(tilt_s2); return (s1 << 1) | s2; //bitwise math to combine the values } |
