Fotodiodo, Phototransistor e Sensore IR con Arduino
Sommario
Descrizione:
Fotodiodo, phototransistor, e Sensore IR con Arduino– Un fotodiodo è un dispositivo che, quando è eccitato dalla luce, produce nel circuito una corrente proporzionale alla portata (e misurabili). In questo modo, possono essere fatti servire come sensori di luce, anche se, mentre è vero che ci sono fotodiodi particolarmente sensibili alla luce visibile, la stragrande maggioranza sono soprattutto nella luce infrarossa.
Va tenuto presente che, pur avendo un comportamento in aspetto simile agli LDR, una differenza molto importante da questi (oltre alla sensibilità ad altre lunghezze d’onda) è il tempo di risposta ai cambiamenti dall’oscurità all’illuminazione, e viceversa, che nei fotodiodi è molto più basso.
Come i diodi standard, i fotodiodi hanno un anodo e un catodo, ma attenzione, affinché funzioni come desideriamo, un fotodiodo deve sempre essere collegato al circuito in polarità inversa. Naturalmente, come con i diodi comuni, normalmente l’anodo è più lungo del catodo (se sono di uguale lunghezza, il catodo dovrebbe essere contrassegnato in qualche modo).
Il suo funzionamento interno è il seguente: quando il fotodiodo è polarizzato in diretta, la luce che cade su di esso non ha un effetto apprezzabile e quindi sia il dispositivo si comporta come un comune diodo. Quando polarizzato in senso inverso e nessuna radiazione luminosa lo raggiunge, si comporta anche come un diodo normale poiché gli elettroni che fluiscono attraverso il circuito non hanno abbastanza energia per attraversarlo, quindi il circuito rimane aperto. Ma nel momento in cui il fotodiodo riceve radiazione luminosa all’interno di un intervallo di lunghezza della forma d’onda, gli elettroni ricevono energia sufficiente per essere in grado di “saltare” la barriera del fotodiodo inverso e continuare sulla strada.
Example1: come controllare il comportamento del fotodiodo
Per testare il suo comportamento, possiamo usare il circuito sottostante. Questo circuito è identico a quello che abbiamo visto con i LDRS, sostituendo questi con un fotodiodo (che è identificato da un nuovo simbolo che non avevamo visto fino ad ora). Il valore del divisore di tensione dipenderà dalla quantità di luce (infrarossa) presente nell’ambiente: resistenze più elevate migliorano la sensibilità quando c’è una sola sorgente luminosa e resistenze più basse la migliorano quando ce ne sono molte (il sole stesso o le lampade sono fonti di infrarossi); un valore 100 KΩ può andare bene per iniziare. Notiamo anche che è il catodo del fotodiodo (il terminale più corto, ricorda) quello che si collega all’alimentazione.
Il funzionamento di questo circuito è il seguente: finché il fotodiodo non rileva la luce infrarossa, attraverso l’ingresso analogico della scheda Arduino (in questo caso il numero 0) verrà misurata una tensione di 0V perché il circuito agirà come un circuito aperto. All’aumentare dell’intensità luminosa sul fotodiodo aumenterà il numero di elettroni che lo attraversano (cioè l’intensità della corrente). Questo implica che, come il “pull-down” la resistenza è fissata, con la Legge di Ohm la tensione misurata al pin di input analogico sarà anche aumentare, fino ad un momento in cui quando si riceve un sacco di luce, il fotodiodo non causa praticamente alcuna resistenza al passaggio di elettroni e quindi l’Arduino legge una tensione massima di 5V.
Abbiamo aggiunto un LED collegato al PWM output pin # 5 come abbiamo fatto quando abbiamo visto la LDRs di avere un modo visibile (pun intended) di rilevare l’incidenza di luce infrarossa sul fotodiodo. Come si può osservare nel codice utilizzato (mostrato sotto), abbiamo fatto l’intensità della luminosità del LED della quantità di luce infrarossa rilevata dal fotodiodo: più radiazione infrarossa ricevuta, più luminoso sarà il LED.
Programmazione:
1
2
3
4
5
6
7
8
9
10
11
12
|
int photodiode_value;
int bright_LED;
void setup(void) {
Seriale.inizia(9600);
}
void loop (void) {
photodiode_value = analogRead(0);
Seriale.println(photodiode_value);
bright_LED = map(photodiode_value, 0, 1023, 0, 255);
analogWrite(5, bright_LED);
ritardo(100);
}
|
Programmazione spiegazione:
Prima di tutto Per la ricezione fotodiodo valore posso definire la variabile di tipo integer
1
|
int photodiode_value;
|
Quindi posso definire la variabile di tipo integer per led valore “Valore inviato al LED”
1
|
int bright_LED;
|
Nella funzione void loop prima ricevo il valore usando la funzione analogRead e memorizzo questi valori nella variabile photodiode_value e quindi uso seriale.println per stampare i valori sul monitor seriale
1
2
3
|
photodiode_value = analogRead(0);
di Serie.println (fotodiode_valore);
|
La luminosità del LED è proporzionale alla quantità di luce infrarossa ricevuto
1
2
3
|
bright_LED = map(photodiode_value, 0, 1023, 0, 255);
analogWrite(5, bright_LED);
|
phototransistor:
Un altro tipo di sensori di luce oltre ai fotodiodi sono chiamati fototransistori, cioè transistor sensibili alla luce (anche normalmente infrarossi). Il suo funzionamento è il seguente: quando la luce cade sulla sua base, è genera una corrente che porta il transistor ad uno stato di conduzione. Pertanto, un fototransistor è uguale a un transistor comune con l’unica differenza che la corrente di base Ib dipende dalla luce ricevuta. In effetti, ci sono fototransistori che possono funzionare in entrambi i modi: come fototransistori o come transistor comuni con una data corrente di base specifica Ib.
Il fototransistor è molto più sensibile del fotodiodo (a causa dell’effetto del guadagno del transistor stesso), poiché le correnti che possono essere ottenute con un fotodiodo sono davvero limitate. In effetti, puoi capire un fototransistor come una combinazione di fotodiodo e amplificatore, quindi in realtà se vorremmo costruire un fototransistor fatto in casa, sarebbe sufficiente aggiungere a un transistor comune un fotodiodo, collegando il catodo del fotodiodo al collettore del transistor e l’anodo alla base. In questa configurazione, la corrente erogata dal fotodiodo (che circolerebbe verso la base del transistor) sarebbe amplificata β volte.
In molti circuiti possiamo trovare un fototransistor a breve distanza da un LED che emette infrarossi di una lunghezza d’onda compatibile. Questa coppia di componenti è utile per rilevare l’interposizione di un ostacolo tra di loro (a causa dell’interruzione del fascio di luce) e quindi fungere da interruttori ottici. Possono essere utilizzati in una moltitudine di applicazioni, come nei rivelatori del passaggio di una carta di credito (presso un bancomat) o l’introduzione della carta (in una stampante) o come tachimetri, tra molti altri. Un tachimetro è un dispositivo che conta i giri al minuto fatti da un ostacolo soggetto a una ruota o una lama che ruota (di solito a causa del funzionamento di un motore); è cioè, viene utilizzato per misurare la velocità di rotazione di un oggetto.
fototransistor è costituito da due terminali corrispondenti all’anodo e al catodo del LED e due terminali corrispondenti al collettore e all’emettitore di un fototransistor NPN. In generale, vorremo collegare i terminali del LED ad un circuito chiuso alimentato continuamente (anodo alla sorgente, catodo alla massa), il terminale collettore della foto passa ad una fonte di alimentazione e il terminale emettitore della foto passa ad un ingresso digitale della nostra scheda Arduino, per poter rilevare così la comparsa di corrente quando viene ricevuta l’illuminazione. D’altra parte, sia questo ingresso scheda Arduino come l’emettitore dovrebbe essere messa a terra attraverso lo stesso resistore pull-down, per ottenere letture più stabili (un valore tipico di 10 KΩ può funzionare, ma a seconda del circuito può essere bisogno di valori più alti).
Possiamo anche trovare la coppia di fototransistori a LED infrarossi plus in alcuni componenti chiamati “optoisolator” o “optoisolator”. La rappresentazione schematica è di solito così:
In linea generale, un accoppiatore ottico agisce come un circuito chiuso quando la luce proviene dal LED alla base del transistor e aperto quando il LED è spento. La sua funzione principale è quella di controllare e allo stesso tempo isolare due parti di un circuito che normalmente funzionano a tensioni diverse (proprio come farebbe un transistor comune, ma in un modo un po ‘ più sicuro). Fisicamente di solito sono chip che offrono almeno quattro pin (come gli interruttori foto): due corrispondenti ai terminali del LED e due corrispondenti al collettore ed emettitore del fototransistor (anche se possono avere un altro pin corrispondente alla base se consentito controllare l’intensità che scorre attraverso di essa anche come standard). Esempi di accoppiatori ottici sono il 4N35 o il CNY75, prodotto da varie aziende.
La coppia LED-fototransistor è utile anche per rilevare oggetti situati a piccole distanze da esso. Lo studieremo nella sezione corrispondente ai sensori di distanza.
Come effettuare il controllo remoto utilizzando il sensore IR:
Un’utilità pratica immediata di una coppia emettitore-ricevitore a infrarossi (come un LED e un fotodiodo / fototransistor) situata a una certa distanza è l’invio di “messaggi” tra di loro. Cioè, poiché la luce infrarossa non è visibile (e quindi non “infastidisce”), possono essere emessi impulsi di una certa durata e / o frequenza che possono essere ricevuti ed elaborati a diversi metri di distanza senza che “sia notato.”Il dispositivo che li riceve deve quindi essere programmato per eseguire azioni diverse a seconda del tipo di impulso letto.
Infatti, qualsiasi dispositivo che funzioni con un “telecomando” funziona in modo simile perché nella sua parte anteriore devo avere un sensore sensori infrarossi (chiamati anche sensori “IR”, dall’inglese “infra-red”) che ricevono i segnali infrarossi emessi dal telecomando. E quello che c’è dentro è fondamentalmente un LED che emette impulsi di luce infrarossa seguendo un certo schema che segnala al dispositivo l’ordine da eseguire: c’è un codice lampeggiante per accendere la TV, un altro per cambiare canale, ecc.
sopra abbiamo parlato di “sensori IR” e non di fotodiodi / fototransistori perché i primi sono un po ‘ più sofisticati. Nello specifico, i sensori IR non rilevano alcuna luce infrarossa, ma solo quella che (grazie all’incorporazione di un filtro passa-banda interno e di un demodulatore) è modulata da un’onda portante con una frequenza di 38 kHz + 3 kHz. Ciò significa fondamentalmente che verranno letti solo i segnali le cui informazioni sono trasportate da una forma d’onda a 38 kHz. Questo per evitare che i sensori IR vadano “pazzi” quando ricevono la luce infrarossa che esiste proveniente da tutti i lati (sole, luce elettrica … in questo modo rispondono solo a molto concreti già standardizzati.
Un’altra differenza con i fotodiodi / fototransistori è che i sensori IR offrono una risposta binaria: se rilevano un segnale IR di 38 kHz il valore che puoi leggere da loro nella maggior parte dei casi è BASSO (0 V), e se non rilevano nulla, la tua lettura dà un valore ELEVATO (5 V). Questo comportamento è quello che viene solitamente chiamato “Attivo basso o “basso attivo”.
Esempi di sensori IR possono essere TSOP32838 o GP1UX311QS. Come caratteristiche quelle più importanti hanno che la loro gamma di sensibilità è tra lunghezze d’onda di 800nm a 1100nm con una risposta massima a 940nm e che necessitano di circa 5V e 3 mA per funzionare.
Il chip TSOP32838 offre tre pin: rivolto verso la parte posteriore emisferica, il pin più a sinistra è l’uscita digitale fornita dal sensore, il pin centrale deve essere collegato a terra e il pin più a destra deve essere collegato a terra. collegare alla rete di alimentazione (tra 2.5 V e 5.5 V).
Example2:
come accendere led con telecomando utilizzando Arduino e, TSOP32838 Sensore IR:
Per testare il suo funzionamento, potremmo progettare un circuito come quello seguente. Il divisore di tensione per il LED può essere compreso tra 200 e 1000 ohm.
L’idea è di accendere brevemente il LED quando il sensore IR rileva un segnale a infrarossi. Ma attenzione, non solo qualsiasi segnale infrarosso è valido, ma solo quello modulato a 38 kHz. Pertanto, per testare questo circuito, non possiamo utilizzare alcun LED a infrarossi: dobbiamo usare una manopola di controllo remoto che abbiamo a portata di mano (da un televisore, un lettore DVD, un computer, ecc.). Una volta caricato sulla scheda Arduino lo schizzo presentato a Next, se puntiamo quel telecomando al sensore IR e premiamo alcuni dei suoi pulsanti, dovremmo vedere il LED accendersi. In questo modo, useremo il sensore IR come se fosse un interruttore, che illumina il LED mentre rileva quel segnale e lo spegne quando non viene più rilevato.
l’uscita del sensore è collegata all’ingresso digitale pin2 della scheda Arduino e il LED è collegato alla sua uscita digitale pin12):
Programmazione:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
int irPin=2;
int ledPin=12;
void setup() {
pinMode(irPin,INPUT);
pinMode(ledPin,OUTPUT);
}
void loop() {
se(pulseIn(irPin,BASSO) > 0) {
delay(100);
digitalWrite(ledPin,HIGH);
ritardo(200);
digitalWrite(ledPin,LOW);
}
}
|
Programmazione spiegazione:
Prima posso definire la variabile di tipo integer per sensore IR e led
1
2
3
|
int irPin=2;
int ledPin=12;
|
in funzione di setup ho impostato il sensore IR come input e led di uscita
1
2
3
|
pinMode(irPin,INPUT);
pinMode(ledPin,OUTPUT);
|
Dal momento che il segnale emesso dal sensore è normalmente ALTO, quando il pulsante di un telecomando viene premuto, cambia BASSA. Ciò che la funzione pulseIn () è di mettere in pausa lo schizzo fino a quando viene rilevato un segnale BASSO, la cui durata non ci interessa davvero ma logicamente sarà sempre maggiore di zero. Pertanto, se la condizione dell’if significa che un pulsante su un telecomando è stato premuto
1
|
se(pulseIn(irPin,BASSO) > 0) {
|
è necessario attendere un certo periodo di tempo (che variano a seconda del modello telecomando) dopo il rilevamento del primo segnale BASSO perché ogni tasto produce molteplici oscillazioni tra valori ALTI e BASSI. Anche se fisicamente non ha niente da vedere, possiamo capire questa attesa come se fosse un modo per evitare un “rimbalzo” (fenomeno studiato quando trattiamo i pulsanti). Trascorso questo tempo di attesa, il segnale proveniente dal sensore dovrebbe essere tornato al suo stato di riposo (valore ELEVATO).
1
|
ritardo(100);
|
continuiamo il LED per pochi millisecondi. Durante questo periodo lo schizzo non sarà in grado di rilevare altre sequenze di tasti provenienti dal telecomando. Potremmo anche aver inviato un messaggio al “monitor seriale” che notifica la pulsazione.
1
2
3
4
5
6
7
8
9
|
digitalWrite(ledPin,HIGH);
ritardo(200);
digitalWrite(ledPin,LOW);
}
}
|
Esempio3:
come ricevere il comando di controllo remoto sul monitor seriale utilizzando TSOP32838 Sensore IR con Arduino:
Prima di tutto scaricare la libreria necessaria per sensore IR
Arduino libreria IRremote
schema del Circuito:
Programmazione:
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
|
#include <IRremote.h>
int receiverPin = 11;
IRrecv irrecv(receiverPin);
decode_results results;
void setup () {
Seriale.inizia(9600);
irrecv.Enableirina();
}
void loop() {
if (irrecv.decodifica (& risultati)!=0) {
se (risultati.decode_type = = NEC) {
Seriale.stampa (“NEC: “);
} altrimenti se (risultati.decode_type = = SONY) {
Seriale.stampa (“SONY: “);
} altrimenti se (risultati.decode_type = = RC5) {
Seriale.stampa (“RC5: “);
} altrimenti se (risultati.decode_type = = RC6) {
Seriale.stampa (“RC6: “);
} altrimenti se (risultati.decode_type = = SCONOSCIUTO) {
Seriale.stampa (“Sconosciuto: “);
}
Seriale.println (risultati.valore, ESADECIMALE);
irrecv.riprendere();
}
}
|
Programmazione spiegazione:
in Primo luogo, l’importazione della libreria necessaria
1
|
#include <IRremote.h>
|
Quindi posso definire la digital pin di ingresso del ricevitore
1
|
int receiverPin = 11;
|
Poi ho creato un oggetto chiamato “irrecv” di tipo IRrecv
1
|
IRrecv irrecv(receiverPin);
|
Quindi dichiaro una variabile di un tipo speciale, “decode_results”.
1
|
decode_results risultati;
|
Poi Avviare il ricevitore annullare la funzione di passaggio
1
|
irrecv.Enableirina();
|
Quindi nel ciclo vuoto guardo per vedere se è stato rilevato un pattern IR modulato. Se è così, l’ho letto e lo tengo interamente nella variabile speciale “risultati”, in forma di numero esadecimale
1
|
se (irrecv.decodifica (& risultati)!=0) {
|
Poi guardo che tipo di modello di negoziazione è, se è da quella riconosciuta dalla biblioteca
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
se (i risultati.decode_type = = NEC) {
Seriale.stampa(“NEC: “);
} else if (risultati.decode_type = = SONY) {
Seriale.stampa (“SONY: “);
} altrimenti se (risultati.decode_type = = RC5) {
Seriale.stampa (“RC5: “);
} altrimenti se (risultati.decode_type = = RC6) {
Seriale.stampa (“RC6: “);
} altrimenti se (risultati.decode_type = = SCONOSCIUTO) {
Seriale.stampa(“Sconosciuto: “);
}
|
E poi vi mostro la ricevuta modello (in formato esadecimale) sul canale seriale
1
|
di Serie.println (risultati.valore ESADECIMALE);
|
una Volta che il modello è stato decodificato, riattivare l’ascolto per rilevare il prossimo modello
1
2
3
|
irrecv.riprendere();
}
|
Example4:
come fare il controllo a distanza tramite TSOP32838 Sensore IR con Arduino:
Prima di tutto scaricare la libreria necessaria per sensore IR
Arduino libreria IRremote
Utilizzare lo stesso circuito che ho usato nel precedente progetto
schema del Circuito:
Programmazione:
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
|
#includere < IRremote.h >
int receiverPin = 11;
IRrecv irrecv(receiverPin);
decode_results risultati;
void setup () {
Seriale.inizia(9600);
irrecv.Enableirina();
}
void loop(){
int i;
if (irrecv.decodifica (& risultati)!=0) {
azione ();
per (i=0; i < 2; i++) {
irrecv.riprendi();
}
}
}
void action () {
interruttore (risultati.value) {
case 0x37EE: Serial.println(“Favorites”); break;
case 0xA90: Serial.println(“On/off”); break;
case 0x290: Serial.println(“Mute”); break;
case 0x10: Serial.println(“1”); break;
case 0x810: Serial.println(“2”); break;
case 0x410: Serial.println(“3”); break;
case 0xC10: Serial.println(“4”); break;
case 0x210: Serial.println(“5”); break;
case 0xA10: Serial.println(“6”); break;
case 0x610: Serial.println(“7”); break;
case 0xE10: Serial.println(“8”); break;
case 0x110: Serial.println(“9”); break;
case 0x910: Serial.println(“0”); break;
case 0x490: Serial.println(“Increase volume”); break;
case 0xC90: Serial.println(“Decrease volume”); break;
case 0x90: Serial.println(“Increase channel”); break;
case 0x890: Serial.println(“Decrease channel”); break;
default: Serial.println(“Other button”);
}
delay(500);
}
|
Leave a Reply