Allumage à temporisations multiples

A - Exposition du problème

On a un éclairage extérieur, normalement utilisé brièvement, mais qu’on oublie souvent d’éteindre. On veut automatiser l’extinction au bout d’un temps donné si on ne la fait pas manuellement. Toutefois, si ce temps est normalement très court, on veut se garder la possibilité d’un allumage nettement plus long.
La difficulté réside dans le fait qu’on ne dispose pour passer les ordres que du bouton d’allumage qui sera le bouton marche/arrêt du dispositif.

We have an outdoor lighting, normally used briefly, but which we often forget to turn off. We want to automate the extinction after a given time if we do not do it manually. However, if this time is normally very short, we want to keep the possibility of a much longer lighting time.
The difficulty lies in the fact that only the on/off button of the device, is available for issuing commands.

B - Le principe

Les ordres sont donnés par des commutations marche/arrêt. L’alimentation étant interrompu entre deux ordres, il faut que le système garde temporairement la mémoire de ce qui a été fait précédemment sans consommation de courant. Une mémoire flash ne convient pas car la valeur enregistrée doit retomber à 0 d’elle même au bout d’un certain temps. Ceci est obtenu par la charge d’un condensateur. La tension aux bornes du condensateur, au redémarrage, donne une indication de ce qui a été fait précédemment.
Dans le cas général, le circuit n’a pas été utilisé depuis suffisament  longtemps pour que le condensateur soit entièrement déchargé. Le microcontrôleur mesure, dès la mise en marche, la tension Vc aux bornes du condensateur. Celle-ci étant inférieure à un seuil (1,4V) le microcontrôleur « décide » d’allumer la lampe pendant 5mn.
Toutefois, le condensateur est chargé à Vc = 2V immédiatement , puis au bout de 5s sa tension monte brusquement à 3V et 5s plus tard à 4V.
Si on coupe le circuit immédiatement après l’allumage, la tension Vc sera donc de 2V. Au ré-allumage, le microcontrôleur constatant cette tension décidera d’allumer pendant 30mn.
Si on attend entre 5s et 10s avant de couper puis rallumer la tension Vc sera de 3V et l’éclairage fonctionnera pendant 1h.
Si on attend au-delà de 10s, avant de couper puis rallumer la tension Vc sera de 4V. L’allumage pourra se prolonger pendant 2h.

C - Le circuit

On utilise une carte Arduino Uno couplée à un petit circuit réalisé avec une plaque à trous.
Trois sorties digitales sont utilisées pour la charge du condensateur aux trois tensions prévues (2V, 3V et 4V). R1 et R3 constituent un pont diviseur. Compte tenu des chutes de tension dans D1 et D4 il reste environ 2V pour charger le condensateur lorsque la sortie S2 est au niveau haut. Avec D2, R2, R3 et D4 la sortie S3 délivre un peu plus de 3V tandis qu’avec D3 et D4, S4 fourni 4V. Les diodes D1, D2, D3 empêchent les sorties de débiter les unes dans les autres.
La charge du condensateur se fait à travers La diode D4 et la résistance R5. La diode D4 empêche le condensateur de se décharger rapidement quand on coupe l’alimentation.
Une entrée analogique reçoit la tension du condensateur pour mesure. Lorsque la carte Arduino n’est plus alimentée, l’entrée analogique présente une impédance quasi nulle qui déchargerait rapidement le condensateur. La constante de temps de décharge est maintenue à 22s grâce à la résistance R4 (220kOhm) interposée entre le condensateur et l’entrée analogique.
Une quatrième sortie digitale fourni le signal commandant l’allumage. Sa tension est appliquée sur la base d’un transistor à travers une résistance de 1KOhm. Le transistor commande un relais électromagnétique classique qui permet d’appliquer le 230V aux lampes quand il est excité.

D - Le programme

D.I - Organigramme

Pour plus de simplicité, l’organigramme ci-dessous n’inclut pas les clignotements de la led 13 ajoutés pour faciliter le contrôle.

D.II - Le programme

1 // allumage de lampes à durées programmées (4 durées possibles)
2 const int s2V = 2;
3 const int s3V = 3;
4 const int s4V = 4;
5 const int cmdTransistor = 5;
6 const int led13 = 13;
7 int eAna = A5;
8 int vCondo = 0;
9 const int LED13 = 13;
10 void setup() {
11 // put your setup code here, to run once:
12 pinMode(s2V, OUTPUT);
13 pinMode(s3V, OUTPUT);
14 pinMode(s4V, OUTPUT);
15 pinMode(LED13, OUTPUT);
16 pinMode(cmdTransistor, OUTPUT);
17 // tout à 0
18 digitalWrite(s2V, 0);
19 digitalWrite(s3V, 0);
20 digitalWrite(s4V, 0);
21 digitalWrite(LED13, 0);
22 }
23
24 void loop() { // début loop """""""""""""""""""""""""""""""""""""""""""""
25 //allumer la lampe
26 digitalWrite(cmdTransistor, 1);
27 //Mesurer V condo
28 vCondo = analogRead(eAna);
29 //si vCondo < 1,4V (5V => 1024 ;1V => 205) ON PART POUR 5MN
30 if (vCondo < 287)
31 {
32 digitalWrite(s2V, 1); // Condo à 2V pendant les 5 premières secondes
33 digitalWrite(LED13, 1);
34 delay(1000);
35 digitalWrite(LED13, 0); // clignotement led 13 1s
36 delay(4000);
37 digitalWrite(s2V, 0);
38 digitalWrite(s3V, 1); // Condo à 3V de la 5e à la 10e seconde
39 digitalWrite(LED13, 1);
40 delay(1000);
41 digitalWrite(LED13, 0); // clignotement led 13 1s
42 delay(4000);
43 digitalWrite(s3V, 0);
44 digitalWrite(s4V, 1); // Condo à 4V après le 10e seconde
45 digitalWrite(LED13, 1);
46 delay(5000); // allumage led 5s
47 digitalWrite(LED13, 0);
48 // debut du temps imparti #########
49 for (int i=1; i< 30 ; i++) // le temps sera 5mn
50 {
51 digitalWrite(LED13, 1);
52 delay(200);
53 digitalWrite(LED13, 0);//simples clignot. brefs toutes les 10s ==
54 delay(9800);
55 }
56 }
57
58 else if (vCondo < 470) //sinon si vCondo < 2,3V ON PART POUR 30mn
59 {
60 delay(5000);
61 digitalWrite(s3V, 1); // Condo à 3V
62 digitalWrite(LED13, 1);
63 delay(1000);
64 digitalWrite(LED13, 0); // clignotement led 13 1seconde
65 delay(4000);
66 digitalWrite(s4V, 1); // Condo à 4V
67 digitalWrite(LED13, 1);
68 delay(5000);
69 digitalWrite(LED13, 0); // clignotement led 13 5secondes
70
71 // compter 30mn début du temps imparti ####################
72 for (int i=1; i< 181 ; i++) // le temps sera 30mn (180 tours de 10 secondes)
73 {
74 for (int j=1; j<3 ; j++)
75 {
76 digitalWrite(LED13, 1);
77 delay(100);
78 digitalWrite(LED13, 0); // doubles clignotements brefs led 13===
79 delay(500);
80 }
81
82 delay(8800); // 10 000 - 2(500 + 100)
83 }
84 }
85 else if (vCondo < 635) // sinon si vCondo < 3.1 V ON PART POUR 1h
86 {
87 delay(10000);
88 digitalWrite(s4V, 1); // Condo à 4V
89 digitalWrite(LED13, 1);
90 delay(5000);
91 digitalWrite(LED13, 0); // clignotement led 13 5secondes
92 // compter 1h début du délais imparti ##########################
93 for (int i=1; i< 361 ; i++) // le temps sera 1h (360 tours de 10secondes)
94 {
95 for (int j=1; j<4 ; j++)
96 {
97 digitalWrite(LED13, 1);
98 delay(100);
99 digitalWrite(LED13, 0); // triples clignotements brefs led 13 =====
100 delay(500);
101 }
102 delay(8200); // 10 000 - 3(500 + 100)
103 }
104 }
105 else
106 {
107 // compter 2h début du délais imparti #####################
108 for (int i=1; i< 721 ; i++) // le temps sera 2h (720 tours de 10secondes)
109 {
110 for (int j=1; j<5 ; j++)
111 {
112 digitalWrite(LED13, 1);
113 delay(100);
114 digitalWrite(LED13, 0);// quadruples clignot. chaque 10 secondes =====
115 delay(500);
116 }
117 delay(7600); // 10 000 - 4(500 + 100)
118 }
119 } // fin des "if / else" --------------------------------------------
120 //éteindre la lampe
121 digitalWrite(cmdTransistor, 0);
122 int i = 0;
123 while ( i == 0) // boucle infinie la led clignote 5 fois chaque 10 secondes
124 {
125 delay(7600);
126 for (int j=1; j<6 ; j++)
127 {
128 digitalWrite(LED13, 1);
129 delay(100);
130 digitalWrite(LED13, 0);// quintuples clignot. toutes les 10s =====
131 delay(500);
132 }
133 }
134 } // fin de loop """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
135

****© M Guignard ******

Si cet article vous a plu je vous invite à faire un petit geste pour me soutenir

{marcobuymeabeer}