Passer d'une programmation faite avec "Delay" vers "Millis"

Version imprimable

Bonjour,

Je suis débutant en programmation.
J'ai une tempo random faite avec "DELAY" (voir programme ci-dessous) comprenant un réglage séparé du temps : aléatoire ON et aléatoire OFF.
J'aimerai remplacer ce programme fait avec "DELAY" par le même programme fait avec "MILLIS" en gardant les mêmes propriétés (temps aléatoire ON et aléatoire OFF réglage séparé).
Pouvez-vous me conseiller, merci
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 int relais1 = 13; long randOn = 0; long randOff = 0; void setup() { pinMode(relais1, OUTPUT); } void loop() { randOn = random (150, 3000); randOff = random (10, 1100); digitalWrite(relais1, HIGH); delay(randOn); digitalWrite(relais1, LOW); delay(randOff); }

Bonjour Genisium

Voilà comment je vois la chose:

Code:

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
 int relais1 = 13;
 unsigned long randOn = 0;
 unsigned long randOnStart = 0;
 unsigned long randOff = 0;
 unsigned long randOffStart = 0;
 
 void setup() {
	 Serial.begin(115200);
 
	 pinMode(relais1, OUTPUT);
 }
 
 void loop() {
 
	 if (randOn == 0 && randOff == 0)                                          // Si le cycle On/Off est termine
	 {
		randOn = random (150, 3000);
		randOff = random (10, 1100);
 
		digitalWrite(relais1, HIGH);                                           // Le relais est On
		randOnStart = millis();                                                // Debut temporisation On
	 }
 
	 if (randOn !=0 && (millis() - randOnStart >= randOn))                     // Si temporisation On terminee
	 {
		 randOn = 0;
 
		 digitalWrite(relais1, LOW);                                           // Le relais est Off
		 randOffStart = millis();                                              // Debut temporisation Off
	 }
 
	 if (randOn ==0 && (millis() - randOffStart >= randOff))                   // Si temporisation Off terminee
	 {
		 randOff = 0;
	 }
 }

C'est claire que ça parait plus compliqué que 2 delay(randOn) et delay(randOff), mais, le gros avantage c'est que la loop() "tourne" toujours la fonction delay() étant dite bloquante.
J'espère que j'ai mis assez de commentaires pour ta compréhension sinon...

A+
Cordialement
jpbbricole

Une autre façon de coder (proche du programme de @JP) en explicitant la "machine à états finis"

Si je comprends bien:
- On a deux états ON et OFF
- On passe d'un état à l'autre quand un temps (aléatoire) a fini de s'écouler.
- On commence par une transition ETAT_ON

Code:

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
enum {ETAT_ON, ETAT_OFF} etatCourant;
const byte pinRelais = 13;
unsigned long dureeAttente;
unsigned long derniereBascule;
 
void allumer()
{
  digitalWrite(pinRelais, HIGH);
  etatCourant = ETAT_ON;
  dureeAttente = random (150, 3000); // on calcule le temps d'attente dans cet état
  derniereBascule = millis(); // on note quand on a allumé
}
 
void eteindre()
{
  digitalWrite(pinRelais, LOW);
  etatCourant = ETAT_OFF;
  dureeAttente = random (10, 1100); // on calcule le temps d'attente dans cet état
  derniereBascule = millis(); // on note quand on a éteint
}
 
void gestionDesEtats() {
  switch (etatCourant) {
    case ETAT_ON: // on est allumé, on verifie si c'est l'heure d'éteindre
      if (millis() - derniereBascule >= dureeAttente) eteindre();
      break;
 
    case ETAT_OFF: // on est éteint, on verifie si c'est l'heure d'allumer
      if (millis() - derniereBascule >= dureeAttente) allumer();
      break;
  }
}
 
void setup() {
  pinMode(pinRelais, OUTPUT);
  allumer(); // on met l'état initial
}
 
void loop() {
  gestionDesEtats(); // gestion de la machine à états finis
}

j'ai créé trois petites fonctions pour simplifier la lecture du code et comme cela la loop() est vraiment toute bête, on appelle la machine à états

NB:
une fois cette approche bien comprise, ce code est simplifiable assez fortement car on voit que allumer et éteindre font sensiblement la même chose ainsi que les différents case dans le switch. donc on pourrait simplifier comme cela

Code:

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
const byte pinRelais = 13;
byte etatCourant; // HIGH ou LOW (1 ou 0)
unsigned long dureeAttente;
unsigned long derniereBascule;
 
void relais(byte valeur)
{
  digitalWrite(pinRelais, valeur);
  etatCourant = valeur;
  dureeAttente = etatCourant ? random (150, 3000) : random (10, 1100); // on calcule le temps d'attente dans cet état
  derniereBascule = millis(); // on note quand on a changé d'état
}
 
void gestionDesEtats() {
  if (millis() - derniereBascule >= dureeAttente) relais(!etatCourant); // inverser le relais si c'est le moment
}
 
void setup() {
  pinMode(pinRelais, OUTPUT);
  relais(HIGH); // on met l'état initial
}
 
void loop() {
  gestionDesEtats(); // gestion de la machine à états finis
}

13/07/2020, 08h40
Genisium

Bonjour,

Un très grand merci pour vos réponses, rapidité et efficacité, ça fonctionne parfaitement.