Allumer puis éteindre une une Led a l'infini

Bonjour,

Je dois réaliser une fonction appelé dans une boucle infinie. Cette fonction à pour but d'allumer une led pendant 5 seconde et l’éteindre.

J'ai essayé divers solutions mais je tombe sur une led qui clignote et ce n'est pas mon objectif !

Auriez vous des idées? Merci.

Bonjour,

Je n'ai pas tout compris. Pourquoi une boucle infinie?
Il suffit d'allumer la led dans setup(), d'attendre 5s et de l'éteindre

Tu veux peut-être dire :

A l'intérieur de la fonction loop() qui boucle de manière infinie, appeler une fonction dont le rôle serait :

Sous une certaine condition, allumer une led, puis l'éteindre au bout de 5 secondes, sans utiliser d'instruction delay pour compter le temps, car celle-ci bloque l'exécution du programme alors qu'il y a besoin de faire autre chose pendant ces 5 secondes ?

Oui c'est exactement ça.

Non en fait, ce n'est pas ça.

Je vais être plus clair:

Dans loop(), j'appelle une fonction. Cette fonction doit allumer une led pendant 5 secondes puis l'éteindre.

#include <arduino.h>
char une_fois = true;
void setup() {
}

void loop() {
if(une_fois) {
//— Appeler la fonction qui allume et éteind la LED
une_fois = false;
}
}

Pas assez clair :smiley:

Admettons que loop() s'exécute 300.000 fois par seconde.
Tu veux appeler ta fonction 300.000 fois par seconde ?

Quelle est la condition = l'événement déclencheur de l'allumage de la led ?

Cette condition est-elle testée dans loop(), ou bien dans la fonction ?

Une fois éteinte, qu'est-ce qui pourrait conduire à réallumer la led ?

Je pense que tu n'as pas compris ce qu'est la fonction loop().

ETAPE 1
Il faudrait pour commencer te documenter sur le programme type en C/C++
Dans un programme C/C++ la fonction main() est OBLIGATOIRE. C'est elle qui est lancée automatiquement au démarrage.

//inclusion de fichier

// Déclaration de variable

//Déclaration des fonctions autre que main()

int main(void)
{
   // code et appel des autres fonctions
}

void machin()
{
// ??????????????????
}

void truc()
{
// ???????????????????,
}

Ça c'est le cas général.

ETAPE 2 CAS PARTICULIER DU MICROCONTROLEUR ET DE L'IDE Arduino

L'IDE Arduino te dispense d'écrire la fonction main et elle déclare les autres fonctions pour toi.
L'IDE arduino demande seulement au minimum 2 fonctions setup() et loop().
Bien sur tu peut en écrire d'autres qui pourront être appelées soit de setup() soit de lopp().

Si on ne fait pas ce qu'il faut un micro-contrôleur parcoure la mémoire du début jusqu'à la fin et S'ARRETE.
Il est totalement inutilisable puisque pour le relancer il faut appuyer sur RESET.

L'IDE construit pour toi une fonction main() qui a cette structure :

int main()
{
  init();
  setup();  
  while (1)
  {
    loop();
  }
}

Comme tu peux le voir la fonction main qui est lancée automatiquement fait les actions suivantes :

  1. la fonction init() est exécutée --> configuration du micro
  2. appelle la fonction setup() qui ne sera exécutée qu'une seule fois.
  3. passe ensuite dans un while. Comme la condition dans le while est toujours vraie il n'est pas possible d'en sortir et la fonction loop() tourne en boucle.
    Au passage la traduction en français de "loop" est le mot boucle.

A l'intérieur du while la fonction loop() est exécutée indéfiniment et c'est grâce à cela que le microcontrôleur peut continuer à tourner.

Si tu veux qu'une opération ne soit exécutée qu'une seule fois dans la fonction loop() malgré le fait qu'elle tourne en boucle il faut utiliser des condition if dans lesquelles tu testera l'état de variable dont tu pourra changer la valeur par exemple par des actions extérieures (boutons) comme cela t'est indiqué par d'autres.

Pour être plus précis

On a un capteur de Co2 qui a une grande inertie( environ 10 min). cela veux dire que le capteur sera supérieur a la cst pendant 10 min.

loop()
{
Si de Co2.mesuré >= Cst
Ouvre une vanne pendant 5 sec. (symbolisé ici par une led a 1)

}

Je pensais utiliser millis().

Il te faut d'abord poser ton raisonnement logique précisément.
Là il en manque encore un bout.

Donc je suppose qu'une fois ouverte pendant 5 secondes, tu veux attendre 10 minutes, et si au bout de ce délai le CO2 est toujours supérieur à ta constante, tu ouvres à nouveau la vanne pendant 5 secondes, et ainsi de suite ?

Si la logique de fonctionnement est bien exprimée en langage naturel, alors sa déclinaison en lignes de code est souvent simple.

Il suffit de se doter de variables persistantes (soit variables globales, soit variables locales déclarées en static) associées aux états logiques de fonctionnement.

Et pour être propre, utiliser des constantes contenant les paramètres, facilement identifiables en début de code.

Par exemple :

const uint32_t duree_ouverture_vanne = 5000UL; //5 secondes
const uint32_t intervalle_mini = 600000UL; //10 minutes

bool vanne_ouverte = false; //état de la vanne
uint32_t millis_ouverture_vanne = 0; //mémorisation de la valeur de millis() pour le calcul des durées écoulées

void loop()
{

  if (co2 >= seuil && vanne_ouverte == false)
  {
    //à toi de jouer : ouvrir la vanne si plus de 10 minutes écoulées depuis la dernière ouverture
    ...
  }

  if (vanne_ouverte)
  {
     //à toi de jouer : fermer la vanne si plus de 5 secondes écoulées depuis l'ouverture
     ...
  }
}