Photodiode, Phototransistor et Capteur IR avec Arduino
Table des Matières
Description:
Photodiode, phototransistor et capteur IR avec Arduino – Une photodiode est un dispositif qui, lorsqu’elle est excitée par la lumière, produit dans le circuit un flux de courant proportionnel (et mesurable). De cette manière, on peut les faire servir de capteurs de lumière, même si, s’il est vrai qu’il existe des photodiodes particulièrement sensibles à la lumière visible, la grande majorité le sont surtout en lumière infrarouge.
Il faut tenir compte du fait que, malgré un comportement d’apparence similaire aux LDR, une différence très importante par rapport à ceux-ci (en plus de la sensibilité aux autres longueurs d’onde) est le temps de réponse aux changements de l’obscurité à l’éclairage, et vice versa, qui dans les photodiodes est beaucoup plus faible.
Comme les diodes standard, les photodiodes ont une anode et une cathode, Mais attention, pour que cela fonctionne comme nous le souhaitons, une photodiode doit toujours être connectée au circuit en polarité inverse. Bien sûr, comme pour les diodes communes, l’anode est normalement plus longue que la cathode (si elles sont de longueur égale, la cathode doit être marquée d’une manière ou d’une autre).
Son fonctionnement interne est le suivant : lorsque la photodiode est polarisée en direct, la lumière qui lui tombe dessus n’a pas d’effet appréciable et donc l’appareil se comporte comme une diode commune. Lorsqu’il est polarisé en sens inverse et qu’aucun rayonnement lumineux ne l’atteint, il se comporte également comme une diode normale car les électrons circulant dans le circuit n’ont pas assez d’énergie pour le traverser, de sorte que le circuit reste ouvert. Mais au moment où la photodiode reçoit un rayonnement lumineux dans une plage de longueur d’onde, les électrons reçoivent suffisamment d’énergie pour pouvoir “sauter” la barrière de photodiode inverse et continuer votre chemin.
Exemple 1: comment vérifier le comportement de la photodiode
Pour tester son comportement, nous pouvons utiliser le circuit ci-dessous. Ce circuit est identique à celui que nous avons vu avec les LDR, en les remplaçant par une photodiode (qui est identifiée par un nouveau symbole que nous n’avions pas vu jusqu’à présent). La valeur de votre diviseur de tension dépendra de la quantité de lumière (infrarouge) présente dans l’environnement: des résistances plus élevées améliorent la sensibilité lorsqu’il n’y a qu’une seule source de lumière et des résistances plus faibles l’améliorent lorsqu’il y en a beaucoup (le soleil lui-même ou les lampes sont des sources d’infrarouge); une valeur de 100 KΩ peut convenir pour commencer. Notons également que c’est la cathode de la photodiode (la borne la plus courte, rappelez-vous) qui se connecte à l’alimentation.
Le fonctionnement de ce circuit est le suivant: tant que la photodiode ne détecte pas la lumière infrarouge, à travers l’entrée analogique de la carte Arduino (dans ce cas le nombre 0), une tension de 0V sera mesurée car le circuit agira comme un circuit ouvert. À mesure que l’intensité lumineuse sur la photodiode augmente, le nombre d’électrons la traversant (c’est-à-dire l’intensité du courant) augmentera. Cela implique que, comme la résistance “pull-down” est fixée, par la loi d’Ohm, la tension mesurée au niveau de la broche d’entrée analogique augmentera également, jusqu’à un moment où, lorsqu’elle reçoit beaucoup de lumière, la photodiode ne provoque pratiquement aucune résistance au passage des électrons et donc la carte Arduino lit une tension maximale de 5V.
Nous avons ajouté une LED connectée à la broche de sortie PWM # 5 comme nous l’avons fait lorsque nous avons vu les LDR pour avoir un moyen visible (jeu de mots) de détecter l’incidence de la lumière infrarouge sur la photodiode. Comme vous pouvez l’observer dans le code utilisé (illustré ci-dessous), nous avons fait l’intensité de luminosité de la LED de la quantité de lumière infrarouge détectée par la photodiode: plus le rayonnement infrarouge reçu est élevé, plus la LED sera lumineuse.
Programmation:
1
2
3
4
5
6
7
8
9
10
11
12
|
int photodiode_value;
int bright_LED;
configuration void(void) {
Série.commencer(9600);
}
boucle vide (vide) {
photodiode_value = analogRead(0);
Série.println(valeur de photodiode);
bright_LED= map(valeur de photodiode), 0, 1023, 0, 255);
analogWrite(5, bright_LED); délai
(100);
}
|
Explication de programmation:
Tout d’abord Pour recevoir la valeur de la photodiode, je définis une variable de type entier
1
|
valeur de la photodiode int;
|
Ensuite, je définis une variable de type entier pour la valeur de la led “Valeur envoyée à la LED”
1
|
int bright_LED;
|
Dans la fonction de boucle vide, je reçois d’abord la valeur en utilisant la fonction analogRead et stocke ces valeurs dans la variable photodiode_value, puis utilise serial.println pour imprimer des valeurs sur un moniteur série
1
2
3
|
photodiode_value = Lecture analogique(0);
Série.println (valeur de photodiode);
|
La luminosité de la LED est proportionnelle à la quantité de lumière infrarouge reçue
1
2
3
|
bright_LED = carte(valeur de photodiode, 0, 1023, 0, 255);
analogWrite (5, bright_LED);
|
phototransistor:
Un autre type de capteurs de lumière en plus des photodiodes sont appelés phototransistors, c’est-à-dire des transistors sensibles à la lumière (également normalement infrarouges). Son fonctionnement est le suivant: lorsque la lumière tombe sur sa base, elle génère un courant qui amène le transistor à un état conducteur. Par conséquent, un phototransistor est égal à un transistor commun à la seule différence que le courant de base Ib dépend de la lumière reçue. En effet, il existe des phototransistors qui peuvent fonctionner dans les deux sens : soit en tant que phototransistors, soit en tant que transistors communs avec un courant de base spécifique Ib donné.
Le phototransistor est beaucoup plus sensible que la photodiode (du fait de l’effet de gain du transistor lui-même), car les courants pouvant être obtenus avec une photodiode sont vraiment limités. En fait, vous pouvez comprendre un phototransistor comme une combinaison de photodiode et d’amplificateur, donc en fait si nous voulons construire un phototransistor maison, il suffirait d’ajouter à un transistor commun une photodiode, reliant la cathode de la photodiode au collecteur du transistor et l’anode à la base. Dans cette configuration, le courant délivré par la photodiode (qui circulerait vers la base du transistor) serait amplifié β fois.
Dans de nombreux circuits, nous pouvons trouver un phototransistor à une courte distance d’une LED émettrice infrarouge d’une longueur d’onde compatible. Ce couple de composants est utile pour détecter l’interposition d’un obstacle entre eux (du fait de l’interruption du faisceau lumineux) et sert donc d’interrupteurs opticiens. Ils peuvent être utilisés dans une multitude d’applications, comme dans les détecteurs du passage d’une carte de crédit (à un guichet automatique) ou de l’introduction du papier (dans une imprimante) ou comme tachymètres, parmi beaucoup d’autres. Un tachymètre est un dispositif qui compte les tours par minute effectués par un obstacle soumis à une roue ou une lame qui tourne (généralement en raison du fonctionnement d’un moteur); c’est-à-dire qu’il est utilisé pour mesurer la vitesse de rotation d’un objet.Le phototransistor
est constitué de deux bornes correspondant à l’anode et à la cathode de la LED, et de deux bornes correspondant au collecteur et à l’émetteur d’un phototransistor NPN. En général, on voudra connecter les bornes de la LED à un circuit fermé alimenté en continu (anode à la source, cathode à la masse), la borne collectrice du commutateur photo à une source d’alimentation et la borne émettrice du commutateur photo à une entrée numérique de notre carte Arduino, pour pouvoir détecter ainsi l’apparition de courant lors de la réception de l’éclairage. D’autre part, cette entrée de carte Arduino en tant qu’émetteur doit être mise à la terre à travers la même résistance déroulante, pour obtenir des lectures plus stables (une valeur typique de 10 KΩ peut fonctionner, mais selon le circuit, il peut être nécessaire de valeurs plus élevées).
On retrouve également la paire de phototransistors LED infrarouge plus dans certains composants appelés “optocoupleurs” ou “optoisolateur”. La représentation schématique est généralement la suivante:
D’une manière générale, un optocoupleur agit comme un circuit fermé lorsque la lumière provient de la LED à la base du transistor et s’ouvre lorsque la LED est éteinte. Sa fonction principale est de contrôler et en même temps d’isoler deux parties d’un circuit qu’elles fonctionnent normalement à des tensions différentes (comme le ferait un transistor commun, mais de manière un peu plus sûre). Physiquement, ce sont généralement des puces qui offrent au moins quatre broches (identiques aux commutateurs photo): deux correspondent aux bornes de la LED et deux correspondent au collecteur et à l’émetteur du phototransistor (bien qu’ils puissent avoir une broche de plus correspondant à la base si on le permet, contrôlent également l’intensité qui la traverse en standard). Des exemples d’optocoupleurs sont le 4N35 ou le CNY75, fabriqués par diverses sociétés.
La paire LED-phototransistor est également utile pour détecter des objets situés à de petites distances de celui-ci. Nous étudierons cela dans la section correspondant aux capteurs de distance.
Comment faire une télécommande à l’aide d’un capteur IR:
Une utilité pratique immédiate d’une paire émetteur-récepteur infrarouge (telle qu’une LED et une photodiode / phototransistor) située à une certaine distance est l’envoi de “messages” entre eux. C’est-à-dire que la lumière infrarouge n’étant pas visible (et donc qu’elle ne “gêne” pas), des impulsions d’une certaine durée peuvent être émises et / ou de fréquence pouvant être reçues et traitées à plusieurs mètres sans qu’elles soient remarquées.”L’appareil qui les reçoit doit alors être programmé pour effectuer différentes actions en fonction du type d’impulsion lue.
En fait, tout appareil qui fonctionne avec une “télécommande” Il fonctionne de la même manière car dans sa partie avant je dois avoir un capteur capteurs infrarouges (également appelés capteurs “IR”, de l’anglais “infra-rouge”) qui reçoivent les signaux infrarouges émis par la télécommande. Et ce qu’il y a à l’intérieur, c’est essentiellement une LED qui émet des impulsions de lumière infrarouge suivant un certain motif qui signale à l’appareil l’ordre à exécuter: il y a un code clignotant pour allumer le téléviseur, un autre pour changer de chaîne, etc.
ci-dessus, nous avons parlé de “capteurs IR” et non de photodiodes / phototransistors car les premiers sont un peu plus sophistiqués. Plus précisément, les capteurs IR ne détectent aucune lumière infrarouge, mais seulement celle qui (grâce à l’incorporation d’un filtre passe-bande interne et d’un démodulateur) est modulée par une onde porteuse d’une fréquence de 38 kHz + 3 kHz. Cela signifie essentiellement que seuls les signaux dont les informations sont portées par une forme d’onde de 38 kHz seront lus. Ceci afin d’éviter que les capteurs IR ne deviennent “fous” lorsqu’ils reçoivent la lumière infrarouge qui existe venant de tous les côtés (soleil, lumière électrique they de cette façon ils ne répondent qu’à du très concret déjà normalisé.
Une autre différence avec les photodiodes / phototransistors est que les capteurs IR offrent une réponse binaire: s’ils détectent un signal IR de 38 kHz, la valeur que vous pouvez leur lire est dans la plupart des cas FAIBLE (0 V), et s’ils ne détectent rien, votre lecture donne une valeur ÉLEVÉE (5 V). Ce comportement est généralement appelé “Faible actif ou “faible actif”.
Des exemples de capteurs IR peuvent être TSOP32838 ou le GP1UX311QS. En tant que caractéristiques, les plus importantes ont que leur plage de sensibilité se situe entre des longueurs d’onde de 800 nm à 1100 nm avec une réponse maximale à 940 nm et nécessitant environ 5V et 3 mA pour fonctionner.
La puce TSOP32838 offre trois broches: face à son arrière hémisphérique, la broche la plus à gauche est la sortie numérique fournie par le capteur, la broche du milieu doit être mise à la terre et la broche la plus à droite doit être mise à la terre. connectez-vous à l’alimentation (entre 2,5 V et 5,5 V).
Exemple2:
comment allumer la led avec la télécommande en utilisant Arduino et, capteur IR TSOP32838:
Pour tester son fonctionnement, nous pourrions concevoir un circuit comme celui qui suit. Le diviseur de tension pour la LED peut être compris entre 200 et 1000 ohms.
L’idée est d’allumer brièvement la LED lorsque le capteur IR détecte un signal infrarouge. Mais attention, pas n’importe quel signal infrarouge n’est valide, mais seulement celui modulé à 38 kHz. Par conséquent, pour tester ce circuit, ne pouvons-nous utiliser aucune LED infrarouge: nous devons utiliser un bouton de commande à distance que nous avons sous la main (à partir d’un téléviseur, d’un lecteur DVD, d’un ordinateur, etc.). Une fois chargé sur la carte Arduino le croquis présenté à Next, si nous pointons cette télécommande sur le capteur IR et appuyons sur certains de ses boutons, nous devrions voir la LED s’allumer. De cette façon, nous utiliserons le capteur IR comme s’il s’agissait d’un interrupteur, qui éclaire la LED tout en détectant ce signal et l’éteint lorsqu’il n’est plus détecté.
la sortie du capteur est connectée à l’entrée numérique pin2 de la carte Arduino et la LED est connectée à sa sortie numérique pin12):
Programmation:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
int irPin = 2;
int ledPin = 12;
void setup() {
pinMode(irPin, ENTRÉE);
pinMode(ledPin, SORTIE);
}
boucle vide() {
if(pulseIn(irPin, BAS) > 0) {
retard (100);
Écriture numérique (ledPin, HAUTE);
délai(200);
digitalWrite (ledPin, FAIBLE);
}
}
|
Explication de programmation:
Je définis d’abord une variable de type entier pour le capteur IR et la led
1
2
3
|
int irPin = 2;
int ledPin = 12;
|
dans la fonction de configuration, j’ai réglé le capteur IR comme entrée et la led comme sortie
1
2
3
|
Code PIN (irPin, ENTRÉE);
Code PIN (ledPin, SORTIE);
|
Comme le signal émis par le capteur est normalement ÉLEVÉ, lorsque le bouton d’une télécommande est enfoncé, il passe à BAS. Ce que la fonction pulseIn() est de mettre en pause l’esquisse jusqu’à ce qu’un signal soit détecté BAS, dont la durée ne nous intéresse pas vraiment mais logiquement il sera toujours supérieur à zéro. Par conséquent, si l’état de la fi signifie qu’un bouton sur une télécommande a été enfoncé
1
|
if(pulseIn (irPin, FAIBLE) > 0) {
|
Il est nécessaire d’attendre un certain temps (qui dépendra du modèle de télécommande spécifique) après la détection du premier signal BAS car chaque pression sur un bouton produit de multiples oscillations entre les valeurs HAUTES et BASSES. Bien que physiquement il n’ait rien à voir, on peut comprendre cette attente comme si c’était un moyen d’éviter un “rebond” (phénomène étudié lorsque l’on traite les boutons poussoirs). Une fois ce temps d’attente écoulé, le signal du capteur devrait être revenu à son état de repos (valeur ÉLEVÉE).
1
|
retard(100);
|
Nous gardons la LED allumée pendant quelques millisecondes. Pendant ce temps, l’esquisse ne sera pas en mesure de détecter d’autres frappes provenant de la télécommande. Nous aurions également pu envoyer un message au “moniteur série” notifiant la pulsation.
1
2
3
4
5
6
7
8
9
|
Écriture numérique (ledPin, HAUTE); délai
(200);
digitalWrite (ledPin, FAIBLE);
}
}
|
Exemple3:
comment recevoir la commande de commande à distance sur le moniteur série à l’aide du capteur IR TSOP32838 avec Arduino:
Tout d’abord télécharger la bibliothèque requise pour le capteur IR
Bibliothèque Arduino IRrémote
Schéma de circuit:
Programmation:
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() {
Série.commencer(9600);
irrecev.énabeiRINe();
}
void loop() {
if(irrecv.décoder (& résultats) !=0) {
si (résultats.decode_type ==NEC) {
Série.imprimer (“NEC: “);
} sinon si (résultats.decode_type ==SONY) {
Série.imprimer (“SONY: “);
} sinon si (résultats.decode_type == RC5) {
Série.imprimer (“RC5: “);
} sinon si (résultats.decode_type == RC6) {
Série.imprimer (“RC6: “);
} sinon si (résultats.decode_type == INCONNU) {
Série.imprimer (“Inconnu: “);
}
Série.println (résultats.valeur, HEX);
irrecv.cv();
}
}
|
Explication de programmation:
Tout d’abord, j’importe la bibliothèque requise
1
|
# inclure < IRrémote.d>
|
Ensuite, je définis la broche d’entrée numérique pour le récepteur
1
|
récepteur int = 11;
|
Ensuite, je crée un objet appelé “irrecv” de type IRrecv
1
|
IRrecv irrecv (récepteur);
|
Ensuite, je déclare une variable d’un type spécial, “decode_results”.
1
|
decode_résultats résultats;
|
Ensuite, je démarre le récepteur en fonction d’étape nulle
1
|
irrecev.enableIRIn ();
|
Ensuite, dans la boucle vide, je cherche à voir si un motif IR modulé a été détecté. Si c’est le cas, je le lis et je le garde entièrement dans la variable spéciale “résultats”, sous forme de nombres hexadécimaux
1
|
si (irrecv.décoder (& résultats) !=0) {
|
Ensuite, je regarde de quel type de modèle de négociation il s’agit, s’il s’agit d’un modèle reconnu par la bibliothèque
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
si (résultats.decode_type ==NEC) {
Série.imprimer (“NEC:”);
} sinon si (résultats.decode_type ==SONY) {
Série.imprimer (“SONY: “);
} sinon si (résultats.decode_type == RC5) {
Série.imprimer (“RC5: “);
} sinon si (résultats.decode_type == RC6) {
Série.imprimer (“RC6: “);
} sinon si (résultats.decode_type == INCONNU) {
Série.print (“Inconnu:”);
}
|
Et puis je montre le motif reçu (au format hexadécimal) sur le canal série
1
|
Série.println (résultats.valeur, HEX);
|
Une fois le motif décodé, réactivez les écoutes pour détecter le prochain motif possible
1
2
3
|
irrecev.cv();
}
|
Example4:
comment faire une télécommande à l’aide du capteur IR TSOP32838 avec Arduino:
Tout d’abord télécharger la bibliothèque requise pour le capteur IR
Bibliothèque Arduino IRrémote
Utilisez le même circuit que celui que j’ai utilisé dans le projet précédent
Schéma de circuit:
Programmation:
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
|
# inclure < IRrémote.h >
int receiverPin = 11;
IRrecv irrecv(receiverPin);
résultats decode_results;
void setup() {
Série.commencer(9600);
irrecev.énabeiRINe();
}
void loop() {
int i;
if(irrecv.décoder (& résultats) !=0) {
j’ai essayé de le faire, mais j’ai essayé de le faire.cv();
}
}
}
void action() {
commutateur (résultats.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