Photorésistance (ou LDR) : symbole, caractéristiques, fonctionnement, et schéma de montage arduino

Par définition, une photorésistance est un composant électronique dont la résistance varie en fonction de la luminosité auquel il est soumis. Oui, mais : quelle est la valeur de cette résistance en fonction de l’intensité lumineuse reçue ? Comment la raccorder au reste du circuit électronique ? Peut-on tirer du courant sur celle-ci comme on veut ? Eh bien, voila certaines des questions que je vous propose de découvrir aujourd’hui, au travers de cet article !

Comme toujours, nous verrons tout d’abord les notions de base se rattachant à ce composant, puis passerons aux caractéristiques techniques, pour enfin aborder son utilisation pratique (bien plus sympa !). À ce stade, je vous proposerai de découvrir des schémas de branchement typiques de photorésistances, notamment avec Arduino.

Ceci n’est pas un cours d’électronique à proprement parler, mais simplement une introduction-découverte à un composant électronique « de base ». C’est pourquoi certaines notions ne seront pas approfondies ici, afin de rester concentré sur « l’essentiel », tant d’un point de vue théorique, que pratique. Du reste, rappelez-vous que je ne suis pas un expert en ce domaine, et qu’il peut donc y avoir des imprécisions ou erreurs qui se sont glissées. D’ailleurs, n’hésitez pas à m’en faire part en commentaire, si c’est le cas ! Merci 😉

Module	Description	Lien
	Ensemble de photorésistances courantes (GL5506, GL5516, GL5528, GL5537, GL5539, et GL5549)	Voir le prix

Photorésistance (aussi appelée LDR) : définition, symbole, fonctionnement, et utilité en pratique

Comme vu en intro, une photorésistance (aussi appelée LDR, pour « Light Dependent Resistor », ou encore « Photoresistor ») est un composant électronique dont la valeur ohmique varie en fonction de la luminosité auquel il est soumis. Au passage, il ne faut pas la confondre avec une photodiode ou un phototransistor, qui sont des composants électroniques différents.

Au niveau d’un schéma électronique, voici comment on le symbolise (et aussi, à quoi il ressemble !) :

Comme vous pouvez le voir, il s’agit d’un composant comportant seulement 2 broches, sans polarité aucune (comme une résistance « classique », en somme).

Basiquement :

• la valeur de cette résistance diminue lorsque la luminosité augmente
• la valeur de cette résistance augmente lorsque la luminosité diminue

Sa valeur ohmique (résistivité) est donc faible en plein soleil, et élevée dans le noir (obscurité).

Sachant cela, il est donc tout naturel d’utiliser une photorésistance dans les cas suivants, qui sont des applications typiques de ce composant, en pratique :

• détecteur jour/nuit
• tracker solaire (pour panneaux photovoltaïques, par exemple)

Par contre, si vous souhaitez « précisément » mesurer la luminosité ambiante, mieux vaut alors vous tourner vers un circuit spécialisé (comme le BH1750, par exemple), plutôt que d’utiliser une « simple » photorésistance. Car cette dernière est vraiment peu précise, et donc vraiment pas fiable dans ce cas !

Caractéristiques principales et secondaires

La principale caractéristique d’une photorésistance est sa relation résistivité / luminosité. En fait, ceci donne la valeur ohmique de la photorésistance, en fonction de l’intensité lumineuse auquel elle est soumise.

D’ailleurs, voici un exemple de courbe caractéristique (résistivité / luminosité) :

Comme vous pouvez le constater, la relation entre valeur ohmique et luminosité n’est pas linéaire. En clair, par exemple : si la luminosité est divisée par 2, alors la valeur ohmique ne sera pas multipliée par 2.

À noter que, à ma connaissance, les constructeurs ne communiquent généralement pas d’équation mathématique permettant de déterminer par calcul la valeur ohmique d’une photorésistance (qui d’ailleurs, dépend de nombreux facteurs). C’est pourquoi nous devons nous fier aux courbes caractéristiques, qu’ils veulent bien nous communiquer (avec toutes les imprécisions que cela peut comporter !).

Maintenant, pour bien visualiser à quoi correspondent les valeurs d’éclairement ci-dessus, exprimées en lux, voici un tableau indicatif, qui devrait vous aider :

Cela étant dit, la caractéristique résistivité/luminosité n’est pas la seule chose à prendre en compte, lorsque vous cherchez un modèle de photorésistance adaptée à vos besoins. En effet, il faut également prendre en compte, quand bien même cela pourrait paraître secondaire :

• la tension maximum supportable par cette LDR
• la puissance dissipable par la LDR en elle-même (dont nous reparlerons un plus loin, car à ne surtout pas négliger)
• la température supportable par le capteur (température de service)
• le temps de réponse du capteur, lorsque la luminosité varie

Quelle photorésistance choisir ? (avec extrait datasheet des LDR série GL)

Comme vu précédemment, la caractéristique principale d’une LDR est celle qui donne sa résistance en fonction de l’éclairement. C’est donc tout naturellement que cela détermine principalement le choix d’un modèle de résistance plutôt qu’un autre (mais sans occulter pour autant les caractéristiques « secondaires » que nous venons de voir, au paragraphe précédent).

Pour vous illustrer tout cela, prenons le datasheet des photorésistances série GL (lien vers le datasheet LDR série GL), on remarque que le fabricant propose 6 déclinaisons, en fonction des besoins. C’est ainsi qu’on retrouve différentes références disponibles, selon la valeur ohmique souhaitée :

À noter qu’ici, à l’aide du coefficient noté ɣ, on peut déterminer la valeur ohmique de cette photorésistance à 100 lux de lumière, à partir de la valeur donnée à 10 lux, dans le tableau. En effet :

→ comme ɣ = log(R₁₀/R₁₀₀), avec R₁₀ la valeur ohmique de la photorésistance à 10 lux, et R₁₀₀ sa valeur à 100 lux
→ alors 10^ɣ = R₁₀ / R₁₀₀
→ d’où R₁₀₀ = R₁₀ / 10^ɣ

Application numérique :

• si on prend par exemple un modèle GL-5528, on note que R₁₀ sera égale à 10k (si on prend la valeur basse), et que le coefficient ɣ sera égal à 0,6
• alors la valeur ohmique sous 100 lux de lumière sera dans ce cas égale à :
  • R₁₀₀ = R₁₀ / 10^ɣ
  • R₁₀₀ = 10000 / 10^0,6
  • d’où R₁₀₀ = 2512 Ω

Cela permet donc d’avoir une indication supplémentaire, quant à la valeur ohmique de ces photorésistances, à 100 lux d’éclairement.

Ainsi, cela nous permettra d’orienter notre choix vers tel ou tel modèle de photorésistance, sans oublier, encore une fois, les caractéristiques que l’on pourrait qualifier de secondaires, mais qui ont toutes leur importance (puissance max dissipable, plage de température d’utilisation, temps de réponse aux variations de luminosité, …).

Cela étant dit, ce choix se fera aussi en fonction des composants qui viendront aux alentours de cette photorésistance. Car effectivement, une LDR ne s’utilise pas seule, mais le plus souvent de paire avec une résistance fixe. C’est ce que je vous propose de découvrir à présent 😉

Comment brancher un capteur LDR, au sein d’un montage électronique ? (schéma)

Comme nous venons de le voir, une photorésistance est un composant électronique à 2 broches, dont la valeur ohmique varie avec la luminosité ambiante. Et un simple ohmmètre permet de mesurer cette valeur, lorsque cette LDR n’est reliée à rien d’autre.

Bien entendu, au sein d’un montage électronique, nulle question d’utiliser un ohmmètre. En fait, il va donc falloir trouver un moyen détourné, pour retrouver la valeur de cette photorésistance. Et c’est chose particulièrement facile, avec la loi d’ohm. En effet, comme celle-ci dit que « U = R * i », alors U peut être la tension de notre photorésistance, R sa valeur ohmique, et i le courant qui la traverse. Donc si on connaît U et i, alors on peut déterminer la valeur résistive de la LDR. Mais là, il faudra un voltmètre ET un ampèremètre, pour retrouver cette valeur.

Du coup, on préfère plutôt cette solution : créer un pont diviseur de tension. Ici, il s’agit simplement de mettre la LDR en série avec une résistance de valeur fixe, afin d’avoir une tension en point milieu qui varie en fonction de la résistivité de la photorésistance. Ainsi, comme nous connaissons la valeur de cette résistance fixe et de la tension qui les alimente, nous n’avons qu’à mesurer la tension du pont diviseur de tension pour déterminer la résistance de la LDR. Simple, non ?

En pratique, voila comment cela se traduit :

Notez que la photorésistance peut être branchée aussi bien en amont (du côté du « + »), qu’en aval (du côté du « -« ). Seul change le comportement de la tension de sortie, dans ce cas.

Dans le 1er cas :

Comme Vs = Vcc * R / (R + LDR) dans ce cas, qui est la formule de base d’un pont diviseur de tension
alors Vs * (R + LDR) = Vcc * R
d’où Vs * R + Vs * LDR = Vcc * R
d’où Vs * LDR = Vcc * R – Vs * R
d’où Vs * LDR = R(Vcc – Vs)
d’où LDR = R*(Vcc – Vs) / Vs

Dans le 2ème cas :

Comme Vs = Vcc * LDR / (R + LDR) dans ce cas, qui est la formule de base d’un pont diviseur de tension
alors Vs * (R + LDR) = Vcc * LDR
d’où Vs * R + Vs * LDR = Vcc * LDR
d’où Vs * R = Vcc * LDR – Vs * LDR
d’où Vs * R = LDR (Vcc – Vs)
d’où LDR = Vs * R / (Vcc – Vs)

Comme vous pouvez le voir, on peut donc aisément déterminer la valeur ohmique d’une photorésistance, à partir de la tension mesurée en Vs, et en appliquant la formule adéquat (Vcc et R étant des constantes, fixes et connues à l’avance, seul Vs varie).

En résulte le tableau suivant :

Au final, on peut donc dire qu’un des meilleurs moyens de mesurer la valeur ohmique d’une photorésistance est de l’insérer dans un pont diviseur de tension. Ainsi, on obtient une tension qui varie en fonction de la luminosité ambiante. Par contre, côté précision de mesure, on perd forcément en qualité, du fait qu’on intègre un élément de plus (la résistance fixe notée R, qui a elle aussi sa propre tolérance, et ses propres variations, notamment en fonction de la température).

Module	Description	Lien
	Ensemble de photorésistances courantes (GL5506, GL5516, GL5528, GL5537, GL5539, et GL5549)	Voir le prix

Code arduino #1 : exemple de branchement photorésistance arduino, avec lecture de tension

Le premier exemple de montage à réaliser permet de déterminer la valeur ohmique d’une photorésistance, branchée au sein d’un pont diviseur de tension, en lisant la tension issue de ce dernier, via une entrée analogique d’Arduino. Cette valeur sera communiquée en temps réel, sur le moniteur série de l’IDE arduino.

En pratique, voici l’ensemble du montage à réaliser :

Au niveau des composants, voici ce que j’ai utilisé :

• 1 x photorésistance modèle GL 5528
• 1 x résistance fixe 10 kohms 1% (la tolérance influe sur le résultat, attention)
• 1 x Arduino Uno R3

À noter que l’ensemble du montage sera alimenté par le câble USB de programmation de l’Arduino, qui permettra par la même de lire les valeurs retournées par ce dernier, via le moniteur série de l’IDE arduino.

Côté programme, voici ce que j’ai écrit, afin d’arriver au résultat souhaité :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier :       prgPhotoresistance-1-LectureTensionLdrAvecArduino.ino
  
  Description :   Programme permettant d'afficher, sur le moniteur série de l'IDE arduino, la valeur ohmique
                  de la photorésistance branchée sur l'entrée A0 d'un Arduino Uno (via un pont diviseur de tension)
                  
  Auteur :        Jérôme TOMSKI (https://passionelectronique.fr/)
  Créé le :       09.05.2022

*/

#define valeurDeLaResistanceFixe                      9970  // Mettre ici la "vraie" valeur (mesurée) de la résistance fixe de 10 kohms que vous allez utiliser
#define brocheEntreePointMilieuPontDiviseurDeTension  A0    // L'entrée A0 de l'arduino uno sera utilisée pour lire la tension en point milieu du pont diviseur
#define tensionAlimentationMicrocontroleurArduino     5     // Ici, on utilise un Arduino Uno, donc un modèle équipé du µC ATmega328P, fonctionnant sous 5 volts

int valeurDeLentreeAnalogique;          // Contiendra la valeur lue sur l'entrée analogique ; pour rappel, il s'agit d'une valeur 10 bits (0..1023)
float tensionDeLentreeAnalogique;       // Contiendra la valeur de calcul de tension, exprimée en volt, à partir de la "valeurDeLentreeAnalogique"
long valeurOhmiqueDeLaLDR;              // Contiendra la valeur ohmique calculée de la photorésistance, à partir de la "tensionDeLentreeAnalogique"
                                        // et de la résistance fixe (constante nommée "valeurDeLaResistanceFixe", dans ce programme)

// ========================
// Initialisation programme
// ========================
void setup() {

  // Initialise la liaison série (arduino uno -> PC)
  Serial.begin(9600);
  Serial.println(F("================================================================================"));
  Serial.println(F("PHOTORESISTANCE / Programme exemple 1"));
  Serial.println(F("- Lecture de la tension en point milieu du pont diviseur"));
  Serial.println(F("- Détermination de la valeur ohmique de la LDR"));
  Serial.println(F("================================================================================"));
  Serial.println("");

}

// =================
// Boucle principale
// =================
void loop() {
  
  // Lecture de l'entrée analogique (pour rappel, cela retourne une valeur sur 10 bits, comprise entre 0 et 1023)
  valeurDeLentreeAnalogique = analogRead(brocheEntreePointMilieuPontDiviseurDeTension);

  // Détermination de la tension présente sur l'entrée analogique
  tensionDeLentreeAnalogique = float(tensionAlimentationMicrocontroleurArduino * valeurDeLentreeAnalogique) / 1023;

  // Détermination de la valeur de la LDR, en fonction de la valeur de la résistance fixe, et de la tension précédemment trouvée
      // Nota : je reprends ici la formule de calcul développée un peu plus haut dans ce tuto, à savoir :
      //   → LDR = R*(Vcc – Vs) / Vs
      //   → d'où valLDR = R * (tensionAlimArduino – tensionEntreeAnalogique) / tensionEntreeAnalogique
  valeurOhmiqueDeLaLDR = valeurDeLaResistanceFixe * (tensionAlimentationMicrocontroleurArduino - tensionDeLentreeAnalogique) / tensionDeLentreeAnalogique;

  // Puis on affiche ces valeurs sur le moniteur série de l'interface arduino
  Serial.print(F("Tension au milieu du pont diviseur : "));
  Serial.print(tensionDeLentreeAnalogique);
  Serial.println(F(" V"));

  Serial.print(F("Estimation de la valeur de la LDR (par calcul) : "));
  Serial.print(valeurOhmiqueDeLaLDR);
  Serial.println(F(" ohms"));

  Serial.println("");

  // Et on reboucle cette fonction loop, après 5 secondes de "pause"
  delay(5000);
  
}

Au niveau du moniteur série de l’interface arduino, voici ce que j’ai relevé (en faisant un « maximum d’ombre » sur la LDR, puis en la mettant en « plein jour », afin de bien montrer l’impact en sortie) :

Remarque : avec ce programme, on s’aperçoit que la précision n’est pas extraordinaire, il faut bien l’avouer ! Car :

• on passe par l’ADC 10 bits de l’Arduino (convertisseur analogique vers numérique) qui n’est pas forcément des plus précis
• la tension d’alimentation USB 5V n’est jamais exactement à cette valeur (on peut donc être plus ou moins en-dessous, par exemple)
• la résistance fixe de 10K ohms ne fait pas exactement 10k, car également en fonction de la température (entre autres choses)
• les arrondis de calculs, au sein du code arduino, vont par ailleurs induire un manque de précision (et oui !)
• et la photorésistance, elle aussi, est sensible à la chaleur (qui, par exemple en plein soleil, peut avoir par une valeur ohmique « altérée », comparé à la valeur attendue)

On le remarque d’ailleurs « dans le noir », où cette résistance était donnée à 1 Mohm par le constructeur. Or là, avec le programme qui « lit » une tension de 0,01 volt en point milieu du pont diviseur de tension, donnant une résistance de 3,3 Mohms (donc bien au-dessus de ce que spécifie le fabricant de cette photorésistance !).

Nota : pour le pont diviseur de tension, j’ai opté une résistance de 10k ohms. J’ai fait le choix d’une telle valeur :
– parce qu’elle correspond à la valeur donnée à 10 lux par le fabricant (ce qui ferait un pivot à Vcc/2 à cette éclairement donné)
– pour limiter le courant de façon suffisante (par soucis d’économie d’énergie, et vis à vis de la puissance max dissipable, dans la LDR en elle-même)

En parlant de la puissance maximum dissipable par la photorésistance, celle-ci est de (si on considère qu’en plein soleil, la LDR finit à 0 ohm) :

→ comme P = U² / R (formule de calcul de puissance, à partir de P = U * i, et de U = R * i)
→ alors P = 5² / (10000 + 0)
→ d’où P = 2,5 mW

En sachant qu’un modèle GL-5525 peut dissiper jusqu’à 100 mW, on est donc pleinement dans les clous, ici !

Bon… à présent : faisons évoluer ce montage, afin d’en faire une application plus concrète, et surtout, bien plus sympa ! Alors en route pour l’exemple suivant 😉

Module	Description	Lien
	Ensemble de photorésistances courantes (GL5506, GL5516, GL5528, GL5537, GL5539, et GL5549)	Voir le prix

Code arduino #2 : exemple de réalisation d’un interrupteur crépusculaire, avec pilotage relais arduino

Second exemple que je vous propose de découvrir ici, et qui illustre bien l’utilisation de photorésistances en pratique : l’interrupteur crépusculaire. Petite parenthèse pour ceux qui ne sauraient pas ce que c’est : un interrupteur crépusculaire est un système permettant la mise en route d’éléments électriques (un éclairage de nuit, par exemple), en fonction de la luminosité ambiante. En clair : cela permet par exemple de faire allumer un éclairage extérieur, une fois la nuit tombée, et de le couper automatiquement au lever du soleil, le lendemain.

Pour vous illustrer cela, je vous propose de voir ensemble le montage suivant, qui permet d’actionner un relais de puissance, en fonction d’un seuil de luminosité donné, qu’on aura soi-même défini à l’aide d’un potentiomètre :

Au niveau des composants utilisés ici, les voici en détail :

• 1 x photorésistance type GL 5528
• 1 x résistance fixe de 10k ohms 1%
• 1 x potentiomètre de 10k ohms (linéaire)
• 1 x Arduino Nano v3
• 1 x relais de puissance 1 voie, bobine 5 volts continus (pouvant couper du 230 volts alternatifs)

Je ne vous préciserai ici aucune valeur pour le disjoncteur de protection côté courant alternatif, car cela est à choisir en fonction de installation, et de la charge que vous prévoyez d’alimenter. Au passage, ne vous approchez jamais du 230 VAC, à moins de savoir exactement ce que vous faites, pour tout éviter tout risque électrique (pouvant aller jusqu’à l’électrocution).

À noter que le modèle de relais utilisé ici se pilote « à l’envers », si je puis dire, car il faut lui envoyer « 0 volt » sur son entrée IN pour l’activer, et « +5V » pour le mettre au repos.

Au niveau du programme arduino, voici ce que j’ai rédigé, pour donner vie à cet interrupteur crépusculaire :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier :       prgPhotoresistance-2-InterrupteurCrepusculaire.ino
  
  Description :   Programme permettant de réaliser un interrupteur crépusculaire (éclairage de nuit, j'entends ici), à partir
                  d'une photorésistance GL-5528, d'un Arduino Nano, et d'un potentiomètre de fixation de seuil de basculement.
                  Un relais de puissance permettra de simuler l'actionnement du système, en fonction de l'éclairement.

  Fonctionnement : Dès qu'il fait nuit, le relais "colle", et permet d'allumer un éclairage nocture. Dès que le jour revient, tout s'éteint !
                  
  Auteur :        Jérôme TOMSKI (https://passionelectronique.fr/)
  Créé le :       09.05.2022

*/

#define brocheDentreePointMilieuPontDiviseurDeTension   A0    // L'entrée A0 de l'arduino nano sera utilisée pour lire la tension en point milieu du pont diviseur de tension
#define brocheDentreePointMilieuPotentiometre           A1    // L'entrée A1 de l'arduino nano sera utilisée pour lire la tension en point milieu du potentiomètre de réglage de seuil
#define brocheDeSortieRelaisDePuissance                 6     // La sortie D6 de l'arduino nano permettra d'actionner le relais de puissance

#define seuilHysteresisBasculementCrepusculaire         20    // Définition d'un hystérésis, afin que le relais ne se mette pas à "osciller", à proximité du seuil de basculement

int valeurAnalogiquePontDiviseurDeTension;    // Contiendra la valeur lue au niveau du pont diviseur de tension ; pour rappel, il s'agit d'une valeur 10 bits (0..1023)
int valeurAnalogiquePotentiometre;            // Contiendra la valeur lue au niveau du potentiomètre de réglage (idem : valeur 10 bits, donc variant de 0 à 1023)

boolean etatDuRelais;           // Contiendra l'état du relais (true ou false, selon si allumé ou éteint)

#define relaisEteint  false     // Indiquera que le relais est au repos
#define relaisAllume  true      // Indiquera que le relais est en marche


// ========================
// Initialisation programme
// ========================
void setup() {

  // Initialisation de la liaison série (arduino nano -> PC), si besoin de faire du débuggage (non indispensable)
  Serial.begin(9600);
  Serial.println(F("==================================================================================="));
  Serial.println(F("PHOTORESISTANCE - Programme exemple 2 : réalisation d'un interrupteur crépusculaire"));
  Serial.println(F("==================================================================================="));
  Serial.println("");

  // Définition de la broche attaquant le relais en "sortie"
  pinMode(brocheDeSortieRelaisDePuissance, OUTPUT);

  // On met le relais au repos au démarrage du programme, on attend une demi-seconde, et on passe à la boucle loop !
  eteindreRelais();
  delay(500);
}

// =================
// Boucle principale
// =================
void loop() {
  
  // Lecture des entrées analogiques (pour rappel, celles-ci retournent des valeurs sur 10 bits, donc comprises entre 0 et 1023)
  valeurAnalogiquePontDiviseurDeTension = analogRead(brocheDentreePointMilieuPontDiviseurDeTension);
  valeurAnalogiquePotentiometre = analogRead(brocheDentreePointMilieuPotentiometre);

  // Réduction des valeurs précédentes, en fonction de l'hystérésis (on passe d'une valeur 0…1023 à 0+hystérsis…1023-hytérésis)
  valeurAnalogiquePontDiviseurDeTension = map(valeurAnalogiquePontDiviseurDeTension, 0, 1023, 0+seuilHysteresisBasculementCrepusculaire, 1023-seuilHysteresisBasculementCrepusculaire);
  valeurAnalogiquePotentiometre = map(valeurAnalogiquePotentiometre, 0, 1023, 0+seuilHysteresisBasculementCrepusculaire, 1023-seuilHysteresisBasculementCrepusculaire);

  // Pour débuggage
  Serial.print(F("Valeur lue sur l'entrée analogique du pont diviseur de tension : "));
  Serial.println(valeurAnalogiquePontDiviseurDeTension);
  Serial.print(F("Valeur lue sur l'entrée analogique du potentiomètre : "));
  Serial.println(valeurAnalogiquePotentiometre);

  // Ensuite, on agit différemment selon si le relais est déjà allumé ou non (pour mise en oeuvre de l'hystérésis, pour éviter toute instabilité)
  switch(etatDuRelais) {
    
    // ================================ 
    // Cas où le relais est déjà éteint
    // ================================
    case relaisEteint :

      // Ici, on allume le relais, si la valeur du pont diviseur de tension passe en dessous de celle du potentiomètre (-hystérésis)
      if(valeurAnalogiquePontDiviseurDeTension < (valeurAnalogiquePotentiometre - seuilHysteresisBasculementCrepusculaire)) {
        Serial.println("→ mise en marche du relais");
        allumerRelais();
      }
      break;

    // ================================ 
    // Cas où le relais est déjà allumé
    // ================================
    case relaisAllume :
    
      // Ici, on éteint le relais, si la valeur du pont diviseur de tension dépasse celle du potentiomètre (+hystérésis)
      if(valeurAnalogiquePontDiviseurDeTension > (valeurAnalogiquePotentiometre + seuilHysteresisBasculementCrepusculaire)) {
        Serial.println("→ mise au repos du relais");
        eteindreRelais();
      }
      break;
  }
  
  // Et on reboucle cette fonction loop, après une petite "pause" à chaque passage
  delay(1500);
}

void allumerRelais() {
  // On met le relais en marche
  digitalWrite(brocheDeSortieRelaisDePuissance, LOW);       // Dans mon cas, il faut envoyer un état bas (0V) pour faire coller le relais
  etatDuRelais = relaisAllume; 
}

void eteindreRelais() {
  // On met le relais au repos
  digitalWrite(brocheDeSortieRelaisDePuissance, HIGH);      // Dans mon cas, il faut envoyer un état haut (+5V) pour mettre le relais au repos
  etatDuRelais = relaisEteint; 
}

Une fois uploadé dans votre arduino, vous n’aurez plus qu’à régler le potentiomètre à la valeur de basculement souhaitée, et faire vos essais. À partir de là :

• s’il y a moins de luminosité que définit (moins un certain hystérésis), alors le relais s’enclenchera
• s’il y a plus de luminosité que définit (plus un certain hystérésis), alors le relais se mettra au repos

Remarque : au sein du code arduino ci-dessus, j’ai laissé toutes mes lignes de débuggage. Ceci vous permettra également de suivre les différentes valeurs mesurées par l’arduino, aussi bien côté photorésistance, que du côté potentiomètre. Ainsi, vous comprendrez peut-être un peu mieux comment fonctionne ce programme. À noter que ce programme gère en automatique l’ajout ou le retrait d’un hystérésis, afin d’éviter toute instabilité du montage, au moment du basculement jour-nuit.

Du coup, si jamais vous laissez votre ordi branché à votre Arduino, et que vous ouvrez le moniteur série, vous devriez voir quelque chose de semblable à ceci (issu de mes essais) :

Au final, si vous utilisez les mêmes composants que moi, vous devriez voir :

• la LED verte du relais s’allumer lorsque l’ensoleillement devient insuffisant, comparé à la consigne, cette dernière étant définie par le potentiomètre
• la LED verte du relais s’éteindre lorsque l’éclairement devient supérieur à la consigne, qui est définie par le potentiomètre

Quelques remarques, au passage :

• on aurait pu opter pour un potentiomètre logarithmique plutôt qu’un potentiomètre linéaire, afin de mieux coller à la caractéristique valeur ohmique/luminosité de la photorésistance (à voir, en pratique…)
• on aurait pu ajouter un second potentiomètre de réglage (plus « fin »), de valeur moins importante que le premier, afin d’avoir un réglage plus fin de la consigne
• l’ajout d’un détecteur de présence type PIR à ce montage, couplé à une temporisation, en ferait un « bon » système d’éclairage automatique nocturne (qui permettrait d’allumer une lumière pour un temps donné, en cas de présence, lorsqu’il fait nuit)

Et pour finir, une photo du montage que j’ai réalisé de mon côté, sur breadboard :

Avantages et inconvénients des LDR

Maintenant que nous avons vu des exemples d’application pratique, et avant de conclure, j’aimerai vous glisser quelques mots sur les avantages et inconvénients des photorésistances (LDR), en pratique.

Au niveau des avantages, je dirai que :

• c’est un composant peu cher
• très facile à mettre en œuvre
• la sensibilité est vraiment élevée

Et au niveau des inconvénients, en voici quelques uns :

• c’est un composant qui manque cruellement de précision (pouvant sans problème atteindre 40% « d’erreur », au niveau de la tolérance !), et sans parler du fait, qu’en plus, tout ceci varie également en fonction de la température …
• sa réponse ohmique n’est pas linéaire, en fonction du flux lumineux reçu
• sa « bande passante » est limitée (vis à vis du spectre lumineux, j’entends, même si c’est quelque chose que je n’ai pas détaillé ici)
• vieilli mal avec le temps (oxydation si laissé à l’air libre, détérioration par échauffements excessifs si laissé en plein soleil, …)

Module	Description	Lien
	Ensemble de photorésistances courantes (GL5506, GL5516, GL5528, GL5537, GL5539, et GL5549)	Voir le prix

Tuto photorésistance : conclusion !

Nous voici au terme de cet article introductif aux photorésistances (LDR, en anglais). J’espère que vous aurez pu découvrir suffisamment de choses ici, afin que vous puissiez à l’avenir vous servir de ce composant, dans vos futurs montages ! À noter que je ne suis volontairement pas entré dans les détails ici, afin de ne pas vous noyer d’informations, pour rester « focus » sur l’essentiel 😉

Il est temps pour moi de vous laisser, et de vous dire à bientôt !
Jérôme.

À découvrir aussi : une introduction aux amplificateurs opérationnels !

JEROME

Passionné par tout ce qui touche à l'électronique, sans toutefois en être expert, j'ai à coeur de vous partager ici, peu à peu, tout ce que j'ai appris, découvert, réalisé, et testé jusqu'à présent ! En espérant que tout cela puisse vous servir, ainsi qu'au plus grand nombre !

(*) Mis à jour le 16/01/2024