Programmer un analyseur d'ensoleillement
publication: 4 novembre 2022 / mis à jour 5 novembre 2022
Appel à collaboration
Vous développez des montages, simples ou complexes avec ESP32 et ESP32forth.
Partagez-les ici sur ce site.
ESP32forth ne pourra se développer qu'avec la collaboration active de toutes les bonnes volontés.
Vos montages peuvent aider d'autres développeurs.
Les montages des autres développeurs peuvent vous aider.
Pour proposer un article ou un montage, cliquez ici
Préambule
Dans le cadre d'un projet solaire utilisant plusieurs panneaux solaires et leur micro-onduleur, il apparait
quelques soucis de gestion de l'énergie électrique produite. Lien vers le projet solaire:
Montage de mon kit en autoconsommation 600W pas à pas
Le principal souci est d'activer des appareils gros consommateurs seulement si les panneaux solaires produisent par plein soleil. Un appareil en particulier est concerné, le cumulus eau chaude:
- activer l'appareil quand les panneaux sont en plein soleil;
- désactiver l'appareil quand passent des nuages.
Les micro-onduleurs injectent du courant dans le réseau électrique général. Si un appareil gros consommateur d'électricité est actif quand passent des nuages, cet appareil sera alimenté en priorité par le réseau général.
Dans cet article, nous présentons une solution permettant la détection des nuages grâce à un panneau solaire miniature et une carte ESP32.
Code complet disponible ici:
ESP32forth/blob/main/ADC/solarLightAnalyzer.txt
Le panneau solaire miniature
Pour réaliser notre détecteur de nuages, on va utiliser un panneau solaire de très petite taille, ici un panneau de 25mm x 25mm.
Récupération d'un panneau solaire miniature
Ce panneau solaire miniature est récupéré sur une lampe de jardin qui est hors d'usage:
Voici notre mini panneau solaire sorti de cette lampe de jardin:
On sacrifie deux connecteurs dupont pour permettre d'effectuer diverses mesures sur notre plaque de prototype. Ces connecteurs sont soudés sur les deux fils rouge et bleu sortant du mini panneau solaire.
Mesure de la tension du panneau solaire
On commence par relever la tension à vide de notre mini panneau solaire, ici avec un oscilloscope. Cette mesure de tension peut aussi s'effectuer avec un voltmètre:
En pleine lumière, la tension mesurée s'élève à 14,2 Volts!
Sous une lumière diffuse, la tension descend à 5,8 Volts.
En couvrant de la main le mini panneau solaire, la tension chute à quasiment 0 Volt.
Mesure du courant du panneau solaire
Le courant, c'est à dire l'intensité, doit être relevée à l'aide d'un ampèremètre. La fonction ampèremètre d'un contrôleur universel conviendra. La mise en court-circuit du mini panneau solaire en pleine lumière permet de mesurer un courant de 10 mA.
Notre mini panneau solaire a donc une puissance approximative de 0,2 Watt.
Avant de connecter notre mini panneau solaire à la carte ESP32, il faut impérativement procéder à un abaissement de la tension de sortie. Il est hors de question d'injecter cette tension de 14,2 Volts dans une entrée de la carte ESP32. Une telle tension détruirait les circuits internes de la carte ESP32.
Abaissement de la tension du panneau solaire
L'idée est d'abaisser la tension aux bornes de notre mini panneau solaire. Après quelques tests, on choisit deux résistances, une de 220 Ohms, l'autre de 1K Ohms. Montage de ces résistances:
La mesure de tension est relevée entre les deux résistances et la borne positive du panneau solaire.
Le voltmètre indique maintenant une tension maximale de 3,2V en pleine lumière, une tension de 0,35V en lumière diffuse.
Programmation de l'analyseur solaire
La carte ESP32 dispose de 18 canaux 12 bits permettant la conversion analogique numérique (ADC). Pour analyser la tension de notre mini panneau solaire, un seul canal ADC est nécessaire et suffisant.
Seuls 15 canaux ADC sont disponibles:
Nous allons en utiliser un, le canal ADC1_CH6 qui est rattaché au pin G34:
34 constant SOLAR_CELL
: init-solar-cell ( -- )
SOLAR_CELL input pinMode
;
init-solar-cell
Pour lire la tension au point situé entre les deux résistances, il suffit d'exécuter SOLAR_CELL analogRead.
Cette séquence dépose une valeur comprise entre 0 et 4095. La valeur la plus basse correspond à une tension nulle. La
valeur la plus élevée correspond à une tension de 3,3 Volts.
Voici la définition solar-cell-read pour récupérer cette tension:
: solar-cell-read ( -- n )
SOLAR_CELL analogRead
;
Testons cette définition dans une boucle:
: solar-cell-loop ( --)
init-solar-cell
begin
solar-cell-read cr .
200 ms
key? until
;
A l'exécution de solar-cell-loop, toutes les 200 millisecondes, la valeur de la conversion de tension
ADC est affichée:
... 322 331 290 172 39 0 0 0 0 19 79 86 ...
Ici les valeurs ont été obtenues en éclairant le mini panneau solaire avec une lampe de forte puissance. Les valeurs nulles correspondent à l'absence d'éclairage.
Des essais avec le vrai soleil font remonter des mesures dépassant 300.
Gestion activation et désactivation d'un appareil
Pour commencer, nous allons définir deux pins, un pin réservé à la gestion d'un signal d'activation, l'autre à un signal de désactivation:
- pin G17 connecté à une LED verte. Ce pin sert à activer un appareil.
- pin G16 connecté à une LED rouge. Ce pin sert à désactiver un appareil.
17 constant DEVICE_ON \ green LED 16 constant DEVICE_OFF \ red LED : init-device-state ( -- ) DEVICE_ON output pinMode DEVICE_OFF output pinMode ;
On aurait pu utiliser un seul pin pour gérer l'appareil distant. Mais certains appareils, comme les relais bistables ont deux bobines:
- on alimente la première bobine pour que les contacts commutent. L'état ne change pas quand la bobine n'est plus excitée;
- pour revenir à l'état initial, on alimente la deuxième bobine.
Pour cette raison, notre programmation va tenir compte de ce type d'appareil.
\ define trigger high state delay 500 value DEVICE_DELAY \ set HIGH level of trigger : device-activation { trigger -- } trigger HIGH digitalWrite DEVICE_DELAY ?dup if ms trigger LOW digitalWrite then ;
Ici, la pseudo-constante DEVICE_DELAY sert à indiquer le délai pendant lequel le signal de commande
doit être conservé à l'état haut. Passé ce délai, le signal de commande repasse à l'état bas.
Si la valeur de DEVICE_DELAY est nulle, le signal de commande reste à l'état haut.
trigger-activation qui gère l'activation du pin correspondant:
TRIGGER_ON trigger-activationmet à l'état haut de manière permanente ou transitoire le pin attaché à la LED verte;TRIGGER_OFF trigger-activationmet à l'état haut de manière permanente ou transitoire le pin attaché à la LED rouge;
On définit maintenant deux mots, device-ON et device-OFF, respectivement chargés d'activer et désactiver
l'appareil destiné à être commandé par les pins G16 et G17:
\ define device state: 0=LOW, -1=HIGH 0 value DEVICE_STATE : enable-device ( -- ) DEVICE_STATE invert if DEVICE_OFF LOW digitalWrite DEVICE_ON device-activation -1 to DEVICE_STATE then ; : disable-device ( -- ) DEVICE_STATE if DEVICE_ON LOW digitalWrite DEVICE_OFF device-activation 0 to DEVICE_STATE then ;
L'état de l'appareil est mémorisé dans DEVICE_STATE. Cet état est testé avant une tentative de
changement d'état. Si l'appareil est actif, il ne sera pas réactivé de manière répétée. Idem si l'appareil est inactif.
\ define trigger value for sunny or cloudy sky 300 value SOLAR_TRIGGER \ if solar light > SOLAR_TRIGGER, activate action : action-light-level ( -- ) solar-cell-read SOLAR_TRIGGER >= if enable-device else disable-device then ;
Déclenchement par interruption timer
La manière la plus élégante consiste à exploiter une interruption par timer. On va utiliser le timer 0:
0 to DEVICE_DELAY
200 to SOLAR_TRIGGER
init-solar-cell
init-device-state
timers
: action ( -- )
action-light-level
0 rerun
;
' action 1000000 0 interval
A partir de maintenant, le timer va analyser le flux lumineux chaque seconde et agir en conséquence:
Pour cette vidéo, on agit sur deux paramètres:
0 to DEVICE_DELAYallume les LEDs de manière permanente. La LED rouge indique que l'appareil est désactivé. La LED verte indique l'activation de l'appareil;200 to SOLAR_TRIGGERdétermine le seuil de déclenchement de l'état d'ensoleillement. Ce paramètre est ajustable pour s'adapter aux caractéristiques du mini panneau solaire.
Le mot action fonctionne par interruption timer. Il n'est donc pas nécessaire d'avoir une boucle générale pour que le détecteur
fonctionne.
Les appareils pouvant être commandés par le capteur d'ensoleillement
En résumé, nous disposons de deux fils de commande, un fil correspondant à la LED verte sur la vidéo, l'autre fil correspondant à la LED rouge. Le programme est conçu pour que les deux fils de commande ne peuvent être actifs en même temps.
Pour avoir un signal continu sur l'un ou l'autre fil de commande, il suffit que la valeur DEVICE_DELAY soit
nulle. Voici comment initialiser ce scénario:
\ start with Constant Command Signal : start-CCS ( -- ) 0 to DEVICE_DELAY 200 to SOLAR_TRIGGER init-solar-cell init-device-state disable-device [ timers ] ['] action 1000000 0 interval ;
Et pour avoir des commandes temporisées, on affectera à DEVICE_DELAY qui indique le délai
du niveau de la commande d'activation ou de désactivation de l'appareil.
\ start with Temporized Command Signal : start-TCS ( -- ) 300 to DEVICE_DELAY 200 to SOLAR_TRIGGER init-solar-cell init-device-state disable-device [ timers ] ['] action 1000000 0 interval ;
Le scénario start-TCS est typique d'une commande de relais bistable à commande par impulsion. Le relais s'active s'il reçoit une
commande d'activation. Même si le signal d'activation retombe, le relais bistable reste actif. Pour désactiver le relais
bistable, il faut lui transmettre une commande de déasctivation sur la ligne de désactivation.
En conclusion, notre analyseur de lumière solaire peut commander une grande variété d'appareils. Il suffit d'adapter les interfaces de commande de ces appareils aux caractéristiques des ports GPIO de la carte ESP32.
Legal: site web personnel sans commerce / personal site without seling