Programmation en SI : Python, Arduino et Objets Connectés au Lycée

Programmer un système en sciences de l'ingénieur, c'est écrire une boucle qui lit les capteurs, décide, puis commande les actionneurs, sans fin. Sur une carte Arduino, cette boucle s'écrit dans la fonction loop() : une veilleuse lit la lumière sur l'entrée A0 et allume sa LED dès que la valeur lue passe sous 300. Python, le langage proposé par le programme de SI, sert à écrire tes algorithmes et à traiter les mesures.

La boucle lire, décider, agir

Un capteur transforme une grandeur physique (lumière, température) en signal électrique. Un actionneur, comme un moteur, transforme un ordre en action. Entre les deux, le micro-contrôleur exécute ton programme : un petit ordinateur sur une seule puce, avec ses broches d'entrée et de sortie, au cœur de la carte Arduino.

Avant de coder, écris l'algorithme, en pseudo-code ou en algorigramme (des rectangles pour les actions, des losanges pour les tests). Pour la veilleuse :

répéter sans fin :
    lire la lumière
    si lumière < 300 : allumer la LED
    sinon : éteindre la LED

Un système à plusieurs modes (veille, marche, alarme) se décrit plutôt par un diagramme d'états-transitions : chaque mode est un état, et un événement (un appui sur un bouton) fait passer de l'un à l'autre.

Python et Arduino, deux écritures

Le programme de sciences de l'ingénieur propose Python et permet de présenter d'autres langages. Une carte Arduino en utilise un autre : le logiciel Arduino transforme ton programme, appelé croquis, en C++, puis le compile, c'est-à-dire le traduit en instructions pour le micro-contrôleur. Variables, tests et boucles existent des deux côtés ; seule l'écriture change.

En Arduino, chaque instruction finit par un point-virgule, et chaque variable a un type : int pour un entier, float pour un nombre à virgule.

Programmer une carte Arduino

setup() s'exécute une seule fois, à la mise sous tension : on y règle les broches. loop() tourne ensuite sans fin. Voici la veilleuse : LED sur la broche 8, capteur de lumière sur A0, monté pour que la valeur lue baisse quand il fait sombre.

const int LED = 8;
const int SEUIL = 300;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  int lumiere = analogRead(A0);  // entre 0 et 1023
  if (lumiere < SEUIL) {
    digitalWrite(LED, HIGH);     // sombre : on allume
  } else {
    digitalWrite(LED, LOW);      // clair : on éteint
  }
  delay(100);                    // attendre 100 ms
}

pinMode déclare une broche en entrée ou en sortie. Sur une Uno, digitalWrite met une sortie à 5 V (HIGH) ou à 0 V (LOW) ; digitalRead lit une entrée tout ou rien, comme un bouton.

Pour une grandeur qui varie, analogRead passe par le convertisseur analogique-numérique (CAN), qui change une tension en nombre entier. Sur une Uno, il code par défaut de 0 à 5 V sur 10 bits : 2¹⁰ = 1024 valeurs, de 0 à 1023. Une unité vaut 5 / 1024 V, environ 4,9 mV. C'est la résolution : le plus petit écart de tension que la carte distingue.

Faire varier une vitesse avec la PWM

Une broche numérique ne connaît que 0 V et 5 V. Pour régler la vitesse d'un moteur ou l'éclat d'une LED, la carte utilise la PWM (modulation de largeur d'impulsion, ou MLI) : la broche bascule très vite entre 0 V et 5 V, et tu règles la part du temps passée à 5 V, appelée rapport cyclique et notée α.

analogWrite(broche, valeur) prend une valeur de 0 (toujours 0 V) à 255 (toujours 5 V). Sur une Uno, seules les broches 3, 5, 6, 9, 10 et 11 le permettent.

Pourquoi ça marche : sur une période T, la tension vaut 5 V pendant α × T et 0 V le reste du temps. Sa valeur moyenne vaut donc 5 × α × T / T = α × 5 V. Le moteur, freiné par son inertie, et ton œil, trop lent pour suivre ces éclats, ne réagissent qu'à cette moyenne.

Traiter les mesures avec Python

Une mesure brute fluctue d'une lecture à l'autre. Pour la stabiliser, on calcule une moyenne glissante : à chaque nouvelle mesure, la moyenne des k dernières, que mesures[-k:] sélectionne en Python.

def tension(n):
    return n * 5 / 1024        # valeur lue -> volts

mesures = [480, 512, 498, 530, 505, 515]
k = 4
moyenne = sum(mesures[-k:]) / k
print(moyenne, tension(moyenne))   # affiche 512.0 2.5

Plus k est grand, plus la courbe est lisse, mais plus elle réagit tard : avec 10 mesures par seconde et k = 10, un saut met une seconde à apparaître en entier.

Faire communiquer des objets

Pour envoyer ses mesures à l'ordinateur, la carte ouvre une liaison série avec Serial.begin(9600) : 9600 bauds, c'est-à-dire ici 9600 bits par seconde. Serial.println(valeur) envoie la valeur en texte, suivie de deux caractères de fin de ligne ; le moniteur série du logiciel Arduino l'affiche.

Les deux côtés suivent un protocole, des règles communes : vitesse, format des trames (les données entourées d'informations de service). Par défaut, une Arduino règle sa liaison en 8N1 : 8 bits de données, sans bit de parité, encadrés par un bit de départ et un bit de stop. Un octet coûte donc 10 bits.

Un objet connecté remplace le fil par la radio : Wi-Fi, Bluetooth ou LoRa. Dans un réseau, chaque couche ajoute ses informations (adresses, contrôle d'erreurs) autour des données, comme une lettre glissée dans une enveloppe puis dans un colis : c'est l'encapsulation.

Exercices corrigés

Toujours avec une Arduino Uno.

int n = analogRead(A0);
float u = n * 5 / 1024;
Serial.println(u);

À retenir

Sources

• Programme de sciences de l'ingénieur de première et terminale générales (Bulletin officiel) : texte sur eduscol.
• Référence du langage Arduino : documentation officielle Arduino.