Topic "Faire plusieurs choses à la fois avec une carte Arduino"

Membre

Membre du staff

#74 | Feb. 22, 2016 at 10:57 a.m. Signaler ce message

Dans ce tutoriel, nous allons voir ensemble comment faire plusieurs choses "en même temps" avec une carte Arduino. Pour être précis, nous verrons comment construire un code non bloquant, capable de gérer plusieurs tâches simples en parallèle sans que ces tâches se bloquent mutuellement.

Lire la suite de l'article sur le site

Derniére modification le Feb. 22, 2016 at 10:57 a.m. par skywodd

LeBear

Membre

#183 | June 20, 2016 at 12:01 p.m. Signaler ce message

Bonjour Skywodd,

Le sujet est intéressant, mais lorsque l'on programme, dès que l'on commence à duplique et répéter du code, il faut se demander si l'on est pas en train de passer à coté de quelque chose, où de partir dans une fausse direction. Il est rare qu'il y ait une raison vraiment valable de dupliquer son code.

Voici en exemple le code en question "refactorisé":

/*
* Code d'exemple "Blink Without delay" avec trois LEDs.
* Refactorisé pour éviter la duplication de code
*/


class Task_Led
{
    int brocheLed;
    long intervalOn;
    long intervalOff;
    int etatLed;
    unsigned long previousMillis;


// Constructeur - Crée la classe et initialise les variables et l'état
public:
    Task_Led(int broche, long on, long off)
    {
        brocheLed = broche;
        pinMode(brocheLed, OUTPUT);
        intervalOn = on;
        intervalOff = off;

        etatLed = LOW;
        previousMillis = 0;
    }

    void MetsaJour(unsigned long currentMillis)
    {
        if ((etatLed == HIGH) && (currentMillis - previousMillis >= intervalOn)) // Si la led est on et que le delai On est écoulé
        {
            etatLed = LOW; // tourne la Led off
            previousMillis = currentMillis; // memorise le temps
            digitalWrite(brocheLed, etatLed); //mets à jour la led en cours
        }
        else if ((etatLed == LOW) && (currentMillis - previousMillis >= intervalOff)) // Si la led est éteinte et que le délai extinction est atteint où dépassé
        {
            etatLed = HIGH; // allumes la
            previousMillis = currentMillis;
            digitalWrite(brocheLed, etatLed);           
        }
    }
};


// Déclare les broches sur lesquelles sont câblées les LEDs
const int BROCHE_LED_1 = 13;
const int BROCHE_LED_2 = 12;
const int BROCHE_LED_3 = 11;

// Nombre de millisecondes entre deux changements d'état des LED
const unsigned long BLINK_INTERVAL_1 = 1000;
const unsigned long BLINK_INTERVAL_2 = 500;
const unsigned long BLINK_INTERVAL_3 = 2000;

Task_Led _led1(BROCHE_LED_1, BLINK_INTERVAL_1, BLINK_INTERVAL_2);
Task_Led _led2(BROCHE_LED_2, BLINK_INTERVAL_2, BLINK_INTERVAL_3);
Task_Led _led3(BROCHE_LED_3, BLINK_INTERVAL_2, BLINK_INTERVAL_2);


// Fonction setup(), appelée au démarrage de la carte Arduino
void setup() {

    //// Configure les broches des LEDs en sortie
    //pinMode(BROCHE_LED_1, OUTPUT);
    //pinMode(BROCHE_LED_2, OUTPUT);
    //pinMode(BROCHE_LED_3, OUTPUT);

    //// Configure l'état initial des LEDs
    //digitalWrite(BROCHE_LED_1, LOW);
    //digitalWrite(BROCHE_LED_2, LOW);
    //digitalWrite(BROCHE_LED_3, LOW);
}

// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
void loop() {
    unsigned long currentMillis = millis();
    // Sous traite les différentes tâches
    _led1.MetsaJour(currentMillis);
    _led2.MetsaJour(currentMillis);
    _led3.MetsaJour(currentMillis);
}

//void task_led1() {
//  static unsigned long previousMillisLed1 = 0;
//  static byte etatBrocheLed1 = LOW;
//
//  unsigned long currentMillis = millis();
//
//  // Si BLINK_INTERVAL_1 ou plus millisecondes se sont écoulés
//  if (currentMillis - previousMillisLed1 >= BLINK_INTERVAL_1) {
//
//      // Garde en mémoire la valeur actuelle de millis()
//      previousMillisLed1 = currentMillis;
//
//      // Inverse l'état de la LED 1
//      etatBrocheLed1 = !etatBrocheLed1;
//      digitalWrite(BROCHE_LED_1, etatBrocheLed1);
//  }
//}
//
//void task_led2() {
//  static unsigned long previousMillisLed2 = 0;
//  static byte etatBrocheLed2 = LOW;
//
//  unsigned long currentMillis = millis();
//
//  // Si BLINK_INTERVAL_2 ou plus millisecondes se sont écoulés
//  if (currentMillis - previousMillisLed2 >= BLINK_INTERVAL_2) {
//
//      // Garde en mémoire la valeur actuelle de millis()
//      previousMillisLed2 = currentMillis;
//
//      // Inverse l'état de la LED 2
//      etatBrocheLed2 = !etatBrocheLed2;
//      digitalWrite(BROCHE_LED_2, etatBrocheLed2);
//  }
//}
//
//void task_led3() {
//  static unsigned long previousMillisLed3 = 0;
//  static byte etatBrocheLed3 = LOW;
//
//  unsigned long currentMillis = millis();
//
//  // Si BLINK_INTERVAL_3 ou plus millisecondes se sont écoulés
//  if (currentMillis - previousMillisLed3 >= BLINK_INTERVAL_3) {
//
//      // Garde en mémoire la valeur actuelle de millis()
//      previousMillisLed3 = currentMillis;
//
//      // Inverse l'état de la LED 3
//      etatBrocheLed3 = !etatBrocheLed3;
//      digitalWrite(BROCHE_LED_3, etatBrocheLed3);
//  }
//}

skywodd

Membre

Membre du staff

#187 | June 20, 2016 at 4:47 p.m. Signaler ce message

Le sujet est intéressant, mais lorsque l'on programme, dès que l'on commence à duplique et répéter du code, il faut se demander si l'on est pas en train de passer à coté de quelque chose, où de partir dans une fausse direction. Il est rare qu'il y ait une raison vraiment valable de dupliquer son code.
par LeBear

La duplication de code est en générale une mauvaise chose, je suis tout à fait d'accord.

Cependant, ceci est un article pour débutant, et non un article traitant de l'implémentation d'un système événementiel ou d'un mini RTOS / gestionnaire de tâches. Le but ici n'est pas de faire du "beau code" mais de faire comprendre une logique algorithmique

Le code dupliqué dans l'article l'est volontairement, c'est un code d'exemple, chaque morceau est en plusieurs exemplaires pour montrer l’exécution parallèle. Si j'avais sorti un RTOS / Scheduler, ou même simplement une classe C++, j'aurai perdu la totalité des débutants avant la fin de l'introduction

LeBear

Membre

#188 | June 20, 2016 at 5:19 p.m. Signaler ce message

Oui, bien sur, tu dois avoir raison, puisque tu le dis, même si ça ne rime à rien.

harryweb

Membre

#813 | Feb. 6, 2018 at 7:42 p.m. Signaler ce message

Bonjour, Je me posais la question de savoir comment faire avec ce type de code pour avoir par exemple quelque chose de non cyclique. Je m'explique: La led 1 tourne toutes les secondes = OK on voit que le l'arduino (Feather M0 dans mon cas) est alimenté la led 2 (plutôt un relais pour mon cas) change d'état de manière cyclique toutes les 10 minutes = High dès le démarrage. la led 3 (Un autre relais ;-) ) se mettra en fonctionnement (high) à la 55iéme minute mais juste 2 minutes. Surtout pas pendant que la led 2 est HIGH elle aussi.

voilà, je ne peux pas utiliser le code tel quel puisque ma led 3 fonctionnerait en blink toute les 55 minutes… J'ai bien pensé à un 2éme µC qui, lorsqu'il reçoit l'état HIGH de la led 3 commute mon relais pour 2 minutes et attends le prochain passage…. Mais je suppose que vous avez plus simple comme idée ?

Merci de vos tuyaux éventuels. PS: C'est mon 1er essai avec le langage ARDUINO. merci

Derniére modification le Feb. 6, 2018 at 7:44 p.m. par harryweb

skywodd

Membre

Membre du staff

#820 | Feb. 15, 2018 at 5:36 p.m. Signaler ce message

En ce basant sur l'exemple "blink without delay", il doit être possible d’obtenir un résultat proche de ce que tu décris.

Un truc dans ce genre :

const byte PIN_LED_A = 2;
const byte PIN_LED_B = 3;
const byte PIN_LED_C = 4;

unsigned long previousMillis_A = 0;
unsigned long previousMillis_B = 0;
unsigned long previousMillis_C = 0;
unsigned long previousMillis_C2 = 0;

bool led_A = LOW, led_B = LOW;

void setup() {

  pinMode(PIN_LED_A, OUTPUT);
  pinMode(PIN_LED_B, OUTPUT);
  pinMode(PIN_LED_C, OUTPUT);
}

void loop() {
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis_A >= 1000UL) { // 1 seconde
    previousMillis_A = currentMillis;
     
    led_A = !led_A;
    digitalWrite(PIN_LED_A, led_A);
  }
  
  if (currentMillis - previousMillis_B >= 10 * 60 * 1000UL) { // 10 minutes
    previousMillis_B = currentMillis;

    led_B = !led_B;
    digitalWrite(PIN_LED_B, led_B);
  }
  
  if (currentMillis - previousMillis_C >= 55 * 60 * 1000UL) { // 55 minutes
    previousMillis_C = currentMillis;

    if (led_B == LOW) {
      digitalWrite(PIN_LED_C, HIGH);
    }
  }
  
  if (currentMillis - previousMillis_C2 >= 57 * 60 * 1000UL) { // 55 + 2 minutes
    previousMillis_C2 = currentMillis;

    digitalWrite(PIN_LED_C, LOW);
  }
}

harryweb

Membre

#822 | Feb. 15, 2018 at 6:24 p.m. Signaler ce message

Bonjour Skywood,

OK, j'ai pigé ta façon de vouloir faire la chose. Merci ! Entretemps, j'ai bossé dessus et je suis arrivé à faire ce que j'en désirais en introduisant des variables. Et c'est un peu l'usine à gaz. (Je m'en sert pour ma caisse de bouturage d'agrumes et les relais 'pilotent' des brumisateurs 24V) Ton code étant bien plus simple que le mien, je vais travailler dessus, j'ai le temps car mes boutures ont toutes foirées ! ;-) C'est mon 1er prog dans ce langage et même si j'ai eu une formation d'une semaine sur le C il y a trois ans, je cherche les meilleures sources et dois trouver des repères pour ne pas réinventer la poudre…

Bien amicalement

skywodd

Membre

Membre du staff

#853 | March 20, 2018 at 10:53 a.m. Signaler ce message

j'ai le temps car mes boutures ont toutes foirées !
par harryweb

Les prochaines seront parfaites grace à ton prog

C'est mon 1er prog dans ce langage et même si j'ai eu une formation d'une semaine sur le C il y a trois ans, je cherche les meilleures sources et dois trouver des repères pour ne pas réinventer la poudre…
par harryweb

Je te conseille de regarder un peu sur internet des tutoriels sur les langages C et C++. Fondamentalement, le logiciel Arduino, ce n'est qu'une collection de fonctions toutes prêtes en C/C++.

Gros probléme d'emails avec Yahoo