Coppia LED IR emettitore e ricevitore, 5mm, 940nm, corpo trasparente e nero

In questo tutorial mettiamo in funzione la coppia di LED IR da 5 mm, formata da un emettitore infrarosso con corpo trasparente e da un ricevitore con corpo nero. I componenti non hanno un controller proprio, quindi li usiamo insieme a un microcontrollore. Lavoriamo con Arduino Uno R3, alimentato tramite il cavo USB del computer, perché la scheda ha tutto ciò che ci serve: uscita digitale, ingresso analogico e 5 V.

La coppia si usa per sensori di oggetti a riflessione, barriere ottiche, conteggio di pezzi, rilevatori di linea per robot e semplici sensori di prossimità. Il ricevitore misura solo l'intensità della luce IR e non decodifica codici di telecomando.

Come funziona:

L'emettitore è un diodo che produce luce infrarossa con lunghezza d'onda di 940 nm. La luce non si vede a occhio nudo, ma la fotocamera di un telefono può mostrarla come una debole luce violetta. Il ricevitore è un fotodiodo per la stessa lunghezza d'onda. Si collega in polarizzazione inversa, cioè con il catodo a 5 V. Più luce IR riceve, più corrente passa attraverso di esso.

La corrente del ricevitore passa attraverso una resistenza da 10 kohm verso GND, e la caduta di tensione sulla resistenza viene letta dall'ingresso analogico A0. La relazione è U = I x R. Per esempio, una corrente di 10 uA produce 0.1 V su 10 kohm. Il convertitore analogico-digitale della scheda Arduino Uno ha 10 bit, quindi divide 5 V in 1024 gradini di circa 4.88 mV. Senza luce IR la lettura resta vicina a 0, mentre con luce forte sale verso 1023.

L'emettitore ha una tensione diretta tipica di 1.3 - 1.5 V e una corrente di lavoro tipica di 20 mA. Senza resistenza, la corrente crescerebbe senza controllo e distruggerebbe il diodo e il pin della scheda. Con la resistenza da 220 ohm calcoliamo: (5 V - 1.3 V) / 220 ohm, cioè circa 17 mA. Il valore resta sotto 20 mA, quindi sia il diodo sia il pin D3 della scheda sono al sicuro.

Anche la luce ambientale contiene infrarosso, proveniente dal sole e dalle lampadine a incandescenza. Per questo motivo il programma legge A0 due volte, una volta con l'emettitore spento e una volta con l'emettitore acceso, e usa la differenza. Così la luce della stanza viene sottratta e resta solo la luce emessa dal LED e riflessa dall'oggetto.

Collegamento:

Alimentate la scheda Arduino Uno solo tramite il cavo USB. Il circuito usa 5 V e logica a 5 V, quindi non serve un convertitore di livello. Due resistenze completano il circuito: R1 da 220 ohm per l'emettitore e R2 da 10 kohm per il ricevitore. In entrambi i diodi il piedino lungo è l'anodo, mentre quello corto è il catodo. Sul corpo, il lato piatto del bordo indica il catodo.

Non collegate mai l'emettitore direttamente a 5 V o a D3 senza la resistenza R1. Se sulla breadboard c'è un solo pin GND libero, le due resistenze possono usare la stessa linea di massa.

Orientate l'emettitore e il ricevitore nella stessa direzione, affiancati, a una distanza di 5 - 10 mm tra loro. In questa posizione il ricevitore vede la luce riflessa da un oggetto davanti a loro. Per una barriera ottica posizionate i due diodi uno di fronte all'altro: un oggetto che passa tra loro farà diminuire la lettura.

Scheda e librerie:

Nell'Arduino IDE selezionate Tools > Board > Arduino AVR Boards > Arduino Uno. Il pacchetto Arduino AVR Boards viene installato insieme all'Arduino IDE, quindi non va aggiunto nessun indirizzo in File > Preferences.

Il programma usa solo le funzioni di base di Arduino (pinMode, digitalWrite, analogRead, delay e Serial), quindi non serve installare nessuna libreria.

Il codice:

Il programma misura la luce IR con l'emettitore spento e acceso, calcola la differenza, decide se un oggetto riflette la luce e mostra il risultato sul monitor seriale.

/*
  IR emitter and receiver pair, reflection and light barrier test
  Board: Arduino Uno (Tools > Board > Arduino AVR Boards > Arduino Uno)
  Board package: Arduino AVR Boards (comes with the Arduino IDE)
  Libraries: none, the program uses only the core Arduino functions
  Wiring:
    D3  -> IR emitter anode (long leg)
    IR emitter cathode (short leg) -> R1 220 ohm -> GND
    5V  -> IR receiver cathode (short leg)
    A0  -> IR receiver anode (long leg) and R2 10 kohm
    R2 10 kohm other end -> GND
*/
const int EMITTER_PIN = 3;         // Digital pin that drives the IR emitter
const int RECEIVER_PIN = A0;       // Analog pin that reads the IR receiver
const int SAMPLES = 8;             // Number of readings averaged per measurement
const int DETECT_THRESHOLD = 30;   // Minimum difference (ADC counts) to report an object
// Read the receiver several times and return the average value
int readAverage() {
  long sum = 0;
  for (int i = 0; i < SAMPLES; i++) {
    sum += analogRead(RECEIVER_PIN);  // One ADC reading, 0 to 1023
    delayMicroseconds(200);           // Short pause between readings
  }
  return (int)(sum / SAMPLES);
}
void setup() {
  Serial.begin(9600);                 // Start the serial monitor at 9600 baud
  pinMode(EMITTER_PIN, OUTPUT);       // The emitter pin is an output
  digitalWrite(EMITTER_PIN, LOW);     // Start with the emitter off
  Serial.println("IR pair test started");
}
void loop() {
  // Measure the ambient infrared light with the emitter off
  digitalWrite(EMITTER_PIN, LOW);
  delay(2);                           // Let the signal settle
  int ambient = readAverage();
  // Measure again with the emitter on
  digitalWrite(EMITTER_PIN, HIGH);
  delay(2);                           // Let the signal settle
  int lit = readAverage();
  // Turn the emitter off between measurements
  digitalWrite(EMITTER_PIN, LOW);
  // The difference removes the ambient light
  int difference = lit - ambient;
  if (difference < 0) {
    difference = 0;                   // Ignore negative noise
  }
  Serial.print("Emitter off: ");
  Serial.print(ambient);
  Serial.print("  Emitter on: ");
  Serial.print(lit);
  Serial.print("  Difference: ");
  Serial.print(difference);
  Serial.print("  Object: ");
  if (difference >= DETECT_THRESHOLD) {
    Serial.println("YES");
  } else {
    Serial.println("NO");
  }
  delay(300);                         // Wait between measurements
}

Come funziona il codice:

All'inizio definiamo i pin e i parametri. EMITTER_PIN vale 3 e comanda l'emettitore, RECEIVER_PIN è A0 e legge il ricevitore. SAMPLES stabilisce quante letture vengono mediate a ogni misurazione, mentre DETECT_THRESHOLD è la differenza minima, in gradini del convertitore, da cui segnaliamo un oggetto.

La funzione readAverage() legge A0 per SAMPLES volte, somma i valori in una variabile di tipo long e restituisce la media. La media riduce il rumore della lettura, e la breve pausa di 200 microsecondi tra le letture lascia stabilizzare il convertitore.

In setup() avviamo il monitor seriale a 9600 baud, impostiamo EMITTER_PIN come uscita e lo portiamo nello stato LOW, cioè con l'emettitore spento. Poi inviamo un messaggio di avvio.

In loop() misuriamo prima la luce ambientale con l'emettitore spento e conserviamo il valore in ambient. Poi accendiamo l'emettitore, aspettiamo 2 ms e misuriamo di nuovo, e il valore finisce in lit. Spegniamo l'emettitore e calcoliamo difference = lit - ambient. Se il risultato è negativo, lo portiamo a 0. Se difference è almeno DETECT_THRESHOLD, stampiamo che l'oggetto è rilevato. Alla fine aspettiamo 300 ms prima della misurazione successiva.

Risultato:

Aprite il monitor seriale dell'Arduino IDE alla velocità di 9600 baud. Su ogni riga vedete la lettura con l'emettitore spento, la lettura con l'emettitore acceso, la differenza e lo stato dell'oggetto. Senza oggetto davanti alla coppia, la differenza resta piccola. Quando avvicinate una mano o un foglio bianco a qualche centimetro, la differenza cresce molto e il programma segnala l'oggetto.

IR pair test started
Emitter off: 11  Emitter on: 13  Difference: 2  Object: NO
Emitter off: 11  Emitter on: 14  Difference: 3  Object: NO
Emitter off: 12  Emitter on: 96  Difference: 84  Object: YES
Emitter off: 12  Emitter on: 241  Difference: 229  Object: YES
Emitter off: 11  Emitter on: 188  Difference: 177  Object: YES
Emitter off: 11  Emitter on: 15  Difference: 4  Object: NO
Emitter off: 12  Emitter on: 14  Difference: 2  Object: NO

Problemi frequenti:

Le letture restano a 0 e la differenza non cambia. La causa tipica è il ricevitore collegato al contrario oppure il collegamento mancante tra A0 e il suo anodo. Verificate che il piedino corto del ricevitore sia a 5V e che il piedino lungo sia collegato ad A0 e alla resistenza R2 da 10 kohm verso GND.

L'emettitore non appare acceso sulla fotocamera del telefono. Verificate che l'anodo, cioè il piedino lungo, sia collegato a D3 e che R1 porti il catodo a GND. Alcuni telefoni hanno un filtro IR sulla fotocamera principale, quindi provate anche con quella frontale.

La differenza è piccola anche con un oggetto davanti. I due diodi non sono orientati nella stessa direzione, oppure l'oggetto è troppo lontano o troppo scuro. Le superfici nere assorbono la luce IR, mentre quelle bianche e lucide la riflettono bene. Avvicinate l'oggetto e verificate la distanza di 5 - 10 mm tra i diodi.

I valori sono vicini a 1023 e non variano più. Il ricevitore riceve luce IR molto forte, per esempio dal sole o da una lampadina a incandescenza. Spostate il montaggio all'ombra oppure coprite il ricevitore con un tubo corto nero che lasci libera solo la direzione verso l'oggetto.

Le letture saltano molto da una misurazione all'altra. Verificate i contatti sulla breadboard e la massa comune delle due resistenze, poi aumentate il valore di SAMPLES nel codice per ottenere una media migliore.

Limitazioni e consigli:

Con un emettitore alimentato a circa 17 mA, la distanza di rilevamento per riflessione è nell'ordine dei centimetri e dipende molto dal colore e dalla superficie dell'oggetto. Per distanze maggiori usate la barriera ottica, con i diodi uno di fronte all'altro. Il ricevitore non filtra la luce IR ambientale, per questo il metodo della differenza tra la lettura con l'emettitore acceso e quella con l'emettitore spento è importante.

La coppia non decodifica segnali di telecomando, perché non ha un demodulatore. Per una barriera ottica o un rilevatore di linea potete regolare DETECT_THRESHOLD in base alla distanza e alla superficie utilizzate. Con gli stessi componenti potete costruire un contatore di oggetti, un rilevatore di linea per un robot o un sensore di prossimità.