- Materiale richiesto:
- Modulo ADC a 8 bit a canale singolo ADC0804:
- Schema del circuito e spiegazione:
- Programmazione del Raspberry Pi:
- Visualizzazione del valore del sensore di flessione sul display LCD utilizzando Raspberry Pi:
Raspberry Pi è una scheda basata su processore con architettura ARM progettata per ingegneri elettronici e hobbisti. Il PI è una delle piattaforme di sviluppo di progetti più affidabili attualmente disponibili. Con una maggiore velocità del processore e 1 GB di RAM, il PI può essere utilizzato per molti progetti di alto profilo come l'elaborazione delle immagini e Internet of Things. Ci sono molte cose interessanti che possono essere fatte con un PI, ma una caratteristica triste è che non ha un modulo ADC integrato.
Solo, se il Raspberry Pi potesse essere interfacciato con i sensori, potrebbe conoscere i parametri del mondo reale e interagire con esso. La maggior parte dei sensori disponibili sono sensori analogici e quindi dovremmo imparare a utilizzare un modulo IC esterno ADC con Raspberry Pi per interfacciare questi sensori. In questo progetto impareremo come interfacciare il sensore flessibile con Raspberry Pi e visualizzarne i valori sullo schermo LCD.
Materiale richiesto:
- Raspberry Pi (qualsiasi modello)
- ADC0804 IC
- Display LCD 16 * 2
- Sensore di flessione
- Resistenze e condensatori
- Breadboard o perf board.
Modulo ADC a 8 bit a canale singolo ADC0804:
Prima di procedere oltre, impariamo a conoscere questo IC ADC0804 e come usarlo con Raspberry Pi. ADC0804 è un IC a 8 bit a canale singolo, il che significa che può leggere un singolo valore ADC e mapparlo su 8 bit di dati digitali. Questi dati digitali a 8 bit possono essere letti dal Raspberry Pi, quindi il valore sarà 0-255 poiché 2 ^ 8 è 256. Come mostrato nella piedinatura dell'IC di seguito, i pin da DB0 a DB7 vengono utilizzati per leggere questi dati digitali valori.
Ora un'altra cosa importante qui è che l' ADC0804 funziona a 5V e quindi fornisce un'uscita in segnale logico a 5V. Nell'uscita a 8 pin (che rappresenta 8 bit), ogni pin fornisce un'uscita + 5V per rappresentare "1" logico. Quindi il problema è che la logica PI è di + 3,3 V, quindi non è possibile dare logica + 5 V al pin GPIO + 3,3 V di PI. Se dai + 5V a qualsiasi pin GPIO di PI, la scheda viene danneggiata.
Quindi per abbassare il livello logico da + 5V, useremo il circuito del divisore di tensione. Abbiamo discusso il circuito del divisore di tensione in precedenza esaminarlo per ulteriori chiarimenti. Quello che faremo è utilizzare due resistori per dividere la logica + 5V in logiche 2 * 2.5V. Quindi, dopo la divisione, daremo una logica + 2.5v a Raspberry Pi. Quindi, ogni volta che l'ADC0804 presenta "1" logico, vedremo + 2,5 V al pin PI GPIO, invece di + 5 V. Ulteriori informazioni su ADC qui: Introduzione ad ADC0804.
Di seguito è riportata l'immagine del modulo ADC utilizzando ADC0804 che abbiamo costruito su Perf Board:
Schema del circuito e spiegazione:
Di seguito è mostrato lo schema circuitale completo per l' interfacciamento di Flex Sensor con Raspberry Pi. La spiegazione dello stesso è la seguente.
Questo circuito del sensore flex Raspberry Pi potrebbe sembrare un po 'complesso con molti fili, ma se dai un'occhiata più da vicino la maggior parte dei fili sono collegati direttamente dall'LCD e il pin dati a 8 bit al Raspberry pi. La tabella seguente ti aiuterà durante la creazione e la verifica dei collegamenti.
|
Nome pin |
Numero pin lampone |
Nome GPIO Raspberry Pi |
|
LCD Vss |
Pin 4 |
Terra |
|
LCD Vdd |
Pin 6 |
Vcc (+ 5V) |
|
LCD Vee |
Pin 4 |
Terra |
|
LCD Rs |
Pin 38 |
GPIO 20 |
|
LCD RW |
Pin 39 |
Terra |
|
LCD E |
Pin 40 |
GPIO 21 |
|
LCD D4 |
Pin 3 |
GPIO 2 |
|
LCD D5 |
Pin 5 |
GPIO 3 |
|
LCD D6 |
Pin 7 |
GPIO 4 |
|
LCD D7 |
Pin 11 |
GPIO 17 |
|
ADC0804 Vcc |
Pin 2 |
Vcc (+ 5V) |
|
ADC0804 B0 |
Pin 19 (fino a 5.1K) |
GPIO 10 |
|
ADC0804 B1 |
Pin 21 (fino a 5.1K) |
GPIO 9 |
|
ADC0804 B2 |
Pin 23 (fino a 5.1K) |
GPIO 11 |
|
ADC0804 B3 |
Pin 29 (fino a 5.1K) |
GPIO 5 |
|
ADC0804 B4 |
Pin 31 (fino a 5.1K) |
GPIO 6 |
|
ADC0804 B5 |
Pin 33 (fino a 5.1K) |
GPIO 13 |
|
ADC0804 B6 |
Pin 35 (fino a 5.1K) |
GPIO 19 |
|
ADC0804 B7 |
Pin 37 (fino a 5.1K) |
GPIO 26 |
|
ADC0804 WR / INTR |
Pin 15 |
GPIO 22 |
È possibile utilizzare la seguente immagine per determinare i numeri dei pin su Raspberry da allora.
Come tutti i moduli ADC, l' IC ADC0804 richiede anche un segnale di clock per funzionare, fortunatamente questo IC ha una sorgente di clock interna, quindi dobbiamo solo aggiungere il circuito RC ai pin CLK in e CLK R come mostrato nel circuito. Abbiamo usato un valore di 10K e 105pf, ma possiamo usare qualsiasi valore close come 1uf, 0.1uf, 0.01uf dovrebbe funzionare.
Quindi per collegare il sensore Flex abbiamo utilizzato un potenziale circuito divisore utilizzando una resistenza da 100K. Quando il sensore Flex è piegato, la resistenza attraverso di esso varierà e così il potenziale calerà attraverso il resistore. Questo calo viene misurato dall'IC ADC0804 e i dati a 8 bit vengono generati di conseguenza.
Controlla altri progetti relativi a Flex Sensor:
- Flex Sensor interfacciato con il microcontrollore AVR
- Controller di gioco Angry Bird basato su Arduino con sensore Flex
- Controllo del servomotore tramite sensore flessibile
- Generazione di toni toccando le dita utilizzando Arduino
Programmazione del Raspberry Pi:
Una volta terminate le connessioni, dovremmo leggere lo stato di questi 8 bit utilizzando Raspberry Pi e convertirli in Decimal in modo da poterli utilizzare. Il programma per fare lo stesso e visualizzare i valori risultanti sullo schermo LCD è fornito alla fine di questa pagina. Inoltre il codice è spiegato in piccole giunche di seguito.
Abbiamo bisogno di una libreria LCD per interfacciare LCD con Pi. Per questo utilizziamo la libreria sviluppata da shubham che ci aiuterà a interfacciare un display LCD 16 * 2 con un Pi in modalità a quattro fili. Inoltre abbiamo bisogno di librerie per utilizzare il tempo e i pin Pi GPIO.
Nota : il file lcd.py dovrebbe essere scaricato da qui e posizionato nella stessa directory in cui è salvato questo programma. Solo allora il codice verrà compilato.
import lcd #Import the LCD library by [email protected] import time #Import time import RPi.GPIO as GPIO #GPIO will be reffered as GPIO only
Le definizioni dei pin LCD vengono assegnate alle variabili come mostrato di seguito. Nota che questi numeri sono i numeri pin GPIO e non i numeri pin effettivi. È possibile utilizzare la tabella sopra per confrontare i numeri GPIO con i numeri pin. Il binario dell'array includerà tutti i numeri dei pin di dati ei bit dell'array memorizzeranno il valore risultante di tutti i pin GPIO.
#Definizioni pin LCD D4 = 2 D5 = 3 D6 = 4 D7 = 17 RS = 20 EN = 21 binarys = (10,9,11,5,6,13,19,26) #Array di numeri di pin collegati a DB0- Bit DB7 = #sultanti valori di dati a 8 bit
Ora dobbiamo definire i pin di input e output. I sette pin di dati saranno il pin di ingresso e il pin di trigger (RST e INTR) sarà il pin di uscita. Possiamo leggere i valori dei dati a 8 bit dal pin di input solo se attiviamo il pin di output alto per un determinato periodo di tempo in base alla scheda tecnica. Poiché abbiamo dichiarato i perni binari in binarys matrice possiamo usare per ciclo di dichiarazione come mostrato sotto.
per binari in binarys: GPIO.setup (binary, GPIO.IN) #Tutti i pin binari sono pin di input #Pin di trigger GPIO.setup (22, GPIO.OUT) #WR e i pin INTR vengono emessi
Ora usando i comandi della libreria LCD possiamo inizializzare il modulo LCD e visualizzare un piccolo messaggio di introduzione come mostrato di seguito.
mylcd = lcd.lcd () mylcd.begin (D4, D5, D6, D7, RS, EN) #Intro Message mylcd.Print ("Flex Sensor with") mylcd.setCursor (2,1) mylcd.Print ("Raspberry Pi ") time.sleep (2) mylcd.clear ()
All'interno del ciclo while infinito, iniziamo a leggere i valori binari, li convertiamo in decimali e aggiorniamo il risultato sul display LCD. Come detto in precedenza prima di leggere i valori ADC , dovremmo fare in modo che il trigger pin sia alto per un determinato momento per attivare la conversione ADC. Questo viene fatto utilizzando le seguenti righe.
GPIO.output (22, 1) #Turn ON Trigger time.sleep (0.1) GPIO.output (22, 0) #Turn OFF Trigger
Ora, dovremmo leggere i pin a 8 dati e aggiornare il risultato nell'array di bit. Per fare questo usiamo un ciclo for per confrontare ogni pin di input con True e False. Se vero, il rispettivo array di bit sarà impostato come 1, altrimenti sarà impostato come 0. Questi erano tutti i dati a 8 bit che verranno resi 0 e 1 rispettivamente dei valori letti.
# Leggi i pin di input e aggiorna il risultato nell'array di bit per i nell'intervallo (8): if (GPIO.input (binarys) == True): bits = 1 if (GPIO.input (binarys) == False): bits = 0
Dopo aver aggiornato l'array di bit, è necessario convertire questo array in valore decimale. Questa non è altro che una conversione da binario a decimale. Per i dati binari a 8 bit, 2 ^ 8 è 256. Quindi otterremo dati decimali da 0 a 255. In python l'operatore "**" viene utilizzato per trovare la potenza di qualsiasi valore. Poiché i bit iniziano con MSB, lo moltiplichiamo per 2 ^ (7 posizioni). In questo modo possiamo convertire tutti i valori binari in dati decimali e quindi visualizzarli sul display LCD
# calcola il valore decimale utilizzando l'array di bit per i nell'intervallo (8): decimal = decimal + (bits * (2 ** (7-i)))
Una volta che conosciamo il valore decimale, è facile calcolare il valore della tensione. Dobbiamo solo moltiplicarlo per 19,63. Perché per un 5VADC a 8 bit ogni bit è un'analogia di 19,3 milli volt. Il valore di tensione risultante è il valore di tensione che è apparso sui pin Vin + e Vin- dell'IC ADC0804.
# calcola il valore della tensione Tensione = decimale * 19,63 * 0,001 #una unità è 19,3 mV
Utilizzando il valore della tensione possiamo determinare come è stato piegato il sensore di flessione e in quale direzione è stato piegato. Nelle righe seguenti ho appena confrontato i valori di tensione letti con valori di tensione predeterminati per indicare la posizione del sensore Flex sullo schermo LCD.
# confronta la tensione e lo stato di visualizzazione del sensore mylcd.setCursor (1,1) if (Voltage> 3.8): mylcd.Print ("Bent Forward") elif (Voltage <3.5): mylcd.Print ("Bent Backward") else: mylcd.Print ("Stable")
Allo stesso modo è possibile utilizzare il valore di tensione per eseguire qualsiasi attività che si desidera venga eseguita dal Raspberry Pi.
Visualizzazione del valore del sensore di flessione sul display LCD utilizzando Raspberry Pi:
Il funzionamento del progetto è molto semplice. Ma assicurati di aver scaricato il file di intestazione lcd.py e di averlo posizionato nella stessa directory in cui è presente il tuo programma corrente. Quindi fai le connessioni mostrate nello schema del circuito usando una breadboard o una scheda perf ed esegui il programma seguente sul tuo Pi e dovresti far funzionare la cosa. L'impostazione dovrebbe essere simile a questa di seguito.
Come mostrato, il display LCD visualizzerà il valore decimale, il valore di tensione e la posizione del sensore. Basta piegare il sensore in avanti o all'indietro e dovresti essere in grado di vedere la tensione e il valore decimale variare, inoltre verrà visualizzato un testo di stato. Puoi collegare qualsiasi sensore e notare che la tensione che lo attraversa varia.
Il funzionamento completo del tutorial è disponibile nel video riportato di seguito. Spero che tu abbia capito il progetto e ti sia piaciuto costruire qualcosa di simile. Se hai dei dubbi, lasciali nella sezione commenti o sui forum e farò del mio meglio per rispondere.