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

Flux RSS des posts récents dans ce topic ( Flux Atom)


Photo de profil de skywodd

skywodd

Membre

Membre du staff

#74 | 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 par skywodd


Pas de photo de profil

LeBear

Membre

#183 | 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é":

  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
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
/*
* 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);
//  }
//}

Photo de profil de skywodd

skywodd

Membre

Membre du staff

#187 | 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 ;)


Pas de photo de profil

LeBear

Membre

#188 | Signaler ce message


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