Arduino 1 :
premiers programmes en C/C++.

• Écrire, compiler et téléverser un programme Arduino.
• Traduire votre Python en C : types, boucles, fonctions, tableaux.
• Faire plusieurs choses « en même temps » sans delay.
• Dialoguer avec le PC via le moniteur série et votre liaison.py.

Matériel : Arduino Uno + câble USB, breadboard, 2 LED, 2 résistances 220 Ω, 1 bouton. IDE Arduino 2.x installé.

Le code C++ est compilé en instructions machine AVR (séance 01 : ici pas d’interpréteur, pas de bytecode, le CPU exécute directement votre programme). Le fichier binaire (quelques Ko) est envoyé par USB au chargeur d’amorçage (bootloader) de la carte qui l’écrit en mémoire flash. Au reset, le CPU commence à l’adresse 0 : votre setup(), puis loop() indéfiniment. Il n’y a rien d’autre qui tourne. C’est pourquoi la gigue (séance 20) est de quelques microsecondes.

Python vérifie tout à l’exécution et vous protège. Le C fait exactement ce que vous écrivez, sans filet : écrire t[5] dans un tableau de 3 éléments écrase une autre variable sans message. En échange, le programme compilé est minuscule et rapide, et tient dans 2 Ko de RAM. Les réflexes de la séance 08 (tester, borner, valider) deviennent vitaux.

Temps en unsigned long, toujours. Broches et petits entiers en byte ou int. Calculs intermédiaires qui dépassent 32 767 : caster en long ((long)a * b). Éviter float dans une boucle rapide sur Uno (pas d’unité de calcul flottant : 100 fois plus lent). Sur ESP32 (32 bits, FPU), int fait 32 bits et le float est rapide : le C n’a pas de tailles fixes, d’où les types explicites int16_t, uint32_t qu’on préfère en code sérieux.

Une fonction doit être déclarée avant d’être utilisée (l’IDE Arduino génère les déclarations pour vous, mais pas un compilateur C standard). Pas de valeur par défaut classique (C++ en a, l’IDE les accepte). Un tableau ne connaît pas sa taille : on la calcule avec sizeof ou on la garde dans une constante. #define LED 13 est l’ancienne façon de faire des constantes (remplacement textuel) ; const est typé et préférable.

Front : on ne réagit pas à « le bouton est pressé » (vrai pendant 200 ms = des milliers de tours de boucle) mais à « il vient de passer de relâché à pressé » : comparer avec l’état précédent. Anti-rebond : ignorer tout changement survenant moins de 30 ms après le précédent (séance 21). millis() : millisecondes écoulées depuis le démarrage, en unsigned long ; la soustraction millis() − dernier reste correcte même après le débordement à 49,7 jours grâce à l’arithmétique modulaire (séance 13). Ce motif « état précédent + horodatage » est à retenir : il sert pour tout capteur tout-ou-rien.

delay() est acceptable dans un exemple, jamais dans un robot. La boucle doit tourner vite et chaque « tâche » vérifie si c’est son heure. C’est exactement la boucle à cadence fixe de la séance 20 et le style « demander / vérifier ». Avec ce schéma, on gère dix tâches à des cadences différentes dans un seul loop(), et le programme reste réactif. La bibliothèque standard propose une classe pour ça ; vous saurez l’écrire vous-même en séance 23.

Même structure, sans classe (ou avec, en C++) : un tableau de structures {période, prochain, fonction}. Sur Uno, la boucle tourne des dizaines de milliers de fois par seconde ; ici, Python en fait quelques centaines de milliers aussi. Le compteur montre combien de fois la boucle « passe » entre deux clignotements : c’est tout ce temps disponible pour lire les capteurs.

Lecture non bloquante : Serial.available() dit combien d’octets attendent ; on les consomme sans jamais attendre une ligne complète. Envoi de mesures à cadence fixe. Testez avec le moniteur série (tapez LED 1 + Entrée, réglé sur « Nouvelle ligne »), puis avec votre liaison.py : tout doit fonctionner sans le modifier. La classe String d’Arduino est pratique mais fragmente la RAM : en code sérieux, on utilise un tableau de char de taille fixe.

Un robot qui plante moteurs en marche est dangereux. Le watchdog timer est un compteur matériel indépendant du programme : s’il n’est pas remis à zéro à temps, il redémarre la puce. Un programme qui s’est perdu dans une boucle infinie, une corruption mémoire, un capteur qui bloque : tout cela déclenche un redémarrage propre. Toute machine industrielle en a un. Complément logiciel : au démarrage, mettre tous les moteurs à l’arrêt avant toute autre chose.

const char* MORSE[] = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--",
                       "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};
const int POINT = 200;

void signal(int duree) { digitalWrite(13, HIGH); delay(duree); digitalWrite(13, LOW); delay(POINT); }

void morse(const char* message) {
  for (int i = 0; message[i] != '\0'; i++) {        // une chaîne C se termine par '\0'
    char c = toupper(message[i]);
    if (c == ' ') { delay(POINT * 7); continue; }
    if (c < 'A' || c > 'Z') continue;
    const char* code = MORSE[c - 'A'];
    for (int j = 0; code[j] != '\0'; j++) signal(code[j] == '.' ? POINT : 3 * POINT);
    delay(POINT * 2);
  }
}

void setup() { pinMode(13, OUTPUT); }
void loop() { morse("SOS robot"); delay(3000); }

c - 'A' : les caractères sont des nombres (séance 07), A = 65 ; la soustraction donne l’indice 0–25. Une chaîne C est un tableau de char terminé par un zéro. delay est acceptable ici : le programme ne fait rien d’autre.

const byte BOUTON = 2, LED = 13;
enum Etat { ATTENTE, ALLUME, RESULTAT };
Etat etat = ATTENTE;
unsigned long t_cible, t_allumage;
unsigned long meilleur = 999999;

void setup() {
  pinMode(BOUTON, INPUT_PULLUP); pinMode(LED, OUTPUT);
  Serial.begin(115200); randomSeed(analogRead(A0));      // une broche en l'air : du bruit
  t_cible = millis() + random(1000, 5000);
}

void loop() {
  bool presse = digitalRead(BOUTON) == LOW;
  switch (etat) {
    case ATTENTE:
      if (presse) { Serial.println("TRICHE"); etat = RESULTAT; }
      else if (millis() >= t_cible) { digitalWrite(LED, HIGH); t_allumage = millis(); etat = ALLUME; }
      break;
    case ALLUME:
      if (presse) {
        unsigned long reaction = millis() - t_allumage;
        digitalWrite(LED, LOW);
        if (reaction < meilleur) meilleur = reaction;
        Serial.print("Reaction : "); Serial.print(reaction); Serial.print(" ms  (meilleur "); Serial.print(meilleur); Serial.println(")");
        etat = RESULTAT;
      }
      break;
    case RESULTAT:
      if (!presse) { delay(500); t_cible = millis() + random(1000, 5000); etat = ATTENTE; }
      break;
  }
}

Un enum nomme les états ; switch aiguille. Cette machine à états est la structure de tout programme embarqué un peu complexe : on la reverra en séance 28 pour le comportement d’un robot. randomSeed(analogRead(A0)) : une broche non connectée fournit du bruit, la seule source de hasard d’un microcontrôleur.

void setup() {
  DDRB |= (1 << 5);                     // DDR = Data Direction Register : bit 5 en sortie (= pinMode(13, OUTPUT))
  Serial.begin(115200);
}

void loop() {
  unsigned long n = 0, fin = millis() + 1000;
  while (millis() < fin) { digitalWrite(13, HIGH); digitalWrite(13, LOW); n++; }
  Serial.print("digitalWrite : "); Serial.print(n); Serial.println(" bascules/s");

  n = 0; fin = millis() + 1000;
  while (millis() < fin) { PORTB |= (1 << 5); PORTB &= ~(1 << 5); n++; }
  Serial.print("registre     : "); Serial.print(n); Serial.println(" bascules/s");
  delay(2000);
}

Typiquement ~120 000 bascules/s avec digitalWrite contre ~2 000 000 avec les registres (limitées ici par millis() et le compteur ; un PORTB ^= ... seul prend 2 cycles = 125 ns, soit 8 MHz). DDRB configure la direction, PORTB l’état des sorties, PINB lit les entrées : trois registres de 8 bits, un bit par broche. Tout ce que fait Arduino se ramène à écrire des bits dans des registres, et la fiche technique de l’ATmega328P (660 pages) les décrit tous. Ce niveau est celui des pilotes de périphériques et de l’embarqué critique ; en prépa, l’option informatique le touche via l’architecture des ordinateurs.