La programmation avancée et les capteurs

En 3ème, vous avez déjà abordé les fondamentaux de la programmation. Il est essentiel de maîtriser ces concepts pour progresser.

• Variables et types de données : Une variable est comme une boîte qui stocke une information. Cette information a un type (nombre entier, nombre décimal, texte, vrai/faux). Par exemple, age = 14 (nombre entier), temperature = 20.5 (nombre décimal), nom = "Alice" (texte), estMajeur = faux (booléen).
• Structures conditionnelles (si, sinon) : Elles permettent de prendre des décisions dans un programme. Si une condition est vraie, un bloc d'instructions est exécuté ; sinon (sinon), un autre bloc peut l'être.

  SI (age >= 18) ALORS
      AFFICHER "Vous êtes majeur."
  SINON
      AFFICHER "Vous êtes mineur."
  FIN SI
  

• Boucles (répéter, tant que) : Elles servent à répéter des instructions.
  • RÉPÉTER N FOIS : exécute un bloc N fois. Utile quand on sait combien de répétitions sont nécessaires.
  • TANT QUE (condition est vraie) : exécute un bloc tant qu'une condition reste vraie. Utile quand le nombre de répétitions est inconnu à l'avance.

    TANT QUE (compteur < 5) FAIRE
        AFFICHER compteur
        compteur = compteur + 1
    FIN TANT QUE
    

    Les boucles et les conditions sont les piliers de la logique de tout programme.

Un programme informatique est la traduction d'un algorithme.

• Définition d'un algorithme : C'est une suite finie et non ambiguë d'instructions ou d'opérations permettant de résoudre un problème donné. Imaginez une recette de cuisine : c'est un algorithme pour préparer un plat.
• Étapes de résolution de problèmes :
  1. Comprendre le problème : Qu'est-ce que je dois faire ?
  2. Décomposer le problème : Le diviser en sous-problèmes plus petits.
  3. Concevoir l'algorithme : Écrire les étapes logique pour résoudre chaque sous-problème.
  4. Tester et valider l'algorithme : S'assurer qu'il fonctionne comme prévu.
• Traduction en pseudocode : Le pseudocode est une description de l'algorithme qui utilise un langage proche du langage naturel, mais structuré comme un code informatique. Il n'est pas exécutable par une machine, mais permet de concevoir la logique avant de passer à un langage de programmation spécifique. Le pseudocode permet de se concentrer sur la logique sans se soucier des détails syntaxiques d'un langage.

Un IDE (Environnement de Développement Intégré) est un logiciel qui regroupe tous les outils nécessaires à la programmation.

• Présentation des IDE courants :
  • Scratch : IDE visuel, idéal pour les débutants, basé sur des blocs.
  • Arduino IDE : Pour programmer les cartes Arduino, utilise un langage proche du C/C++.
  • Python IDLE, Visual Studio Code : Pour des langages comme Python.
• Fonctionnalités principales :
  • Édition : Écrire le code.
  • Compilation : Traduire le code écrit par l'humain en un langage que la machine peut comprendre (code binaire). Pour Scratch, cette étape est transparente.
  • Débogage : Trouver et corriger les erreurs dans le code.
  • Téléchargement : Envoyer le programme sur la carte (ex: Arduino).
• Installation et configuration : La plupart des IDE sont simples à installer. Pour Arduino IDE, il faut parfois installer des bibliothèques (collections de fonctions) spécifiques pour certains capteurs ou cartes.

Les capteurs sont des éléments clés pour rendre nos systèmes interactifs avec le monde réel.

• Définition et rôle d'un capteur : Un capteur est un dispositif qui détecte et mesure une grandeur physique (lumière, température, distance, mouvement, etc.) et la convertit en un signal électrique interprétable par un système électronique (comme une carte programmable). Son rôle est de "percevoir" l'environnement.
• Différence entre capteur et actionneur :
  • Capteur : Perçoit (ex: thermomètre, détecteur de mouvement). Il fournit une information.
  • Actionneur : Agit sur l'environnement (ex: moteur, LED, buzzer). Il réalise une action physique ou lumineuse.
  • Un capteur collecte des données, un actionneur exécute une action en réponse à ces données.
• Exemples de capteurs courants :
  • Capteur de lumière (LDR)
  • Capteur de température (DHT11, LM35)
  • Capteur de distance (ultrason, infrarouge)
  • Bouton poussoir (un type simple de capteur)
  • Détecteur de mouvement (PIR)

Les capteurs ne renvoient pas tous le même type d'information.

• Capteurs numériques (tout ou rien) : Aussi appelés capteurs TOR (Tout Ou Rien). Ils ne peuvent renvoyer que deux états : HIGH (haut, actif, 1, vrai) ou LOW (bas, inactif, 0, faux).
  • Exemples : Bouton poussoir (appuyé/non appuyé), capteur de fin de course, détecteur de mouvement PIR (mouvement détecté/pas de mouvement).
• Capteurs analogiques (valeurs continues) : Ils renvoient une plage de valeurs, proportionnelle à la grandeur physique mesurée.
  • Exemples : Capteur de lumière (plus il y a de lumière, plus la valeur est élevée), capteur de température (la valeur varie avec la température), capteur de distance.
  • Les capteurs analogiques offrent une mesure plus nuancée que les capteurs numériques.
• Principes de mesure :
  • Lumière : Une LDR (résistance dépendante de la lumière) dont la résistance varie avec l'intensité lumineuse.
  • Température : Utilisation de thermistances (résistance variant avec la température) ou de circuits intégrés spécifiques.
  • Distance : Capteur ultrason émettant une onde et mesurant le temps de retour de l'écho.

Pour qu'un capteur puisse communiquer avec une carte programmable (comme une carte Arduino), il doit être correctement connecté.

• Broches d'entrée/sortie (I/O pins) : Les cartes programmables ont des "broches" sur lesquelles on peut brancher les capteurs. Certaines sont dédiées aux entrées numériques, d'autres aux entrées analogiques, et d'autres encore aux sorties.
  • digitalRead() : pour lire une broche numérique.
  • analogRead() : pour lire une broche analogique.
• Schémas de câblage simples : Il faut toujours vérifier la documentation du capteur. Généralement, les capteurs ont :
  • Une broche d'alimentation (VCC ou +5V).
  • Une broche de masse (GND).
  • Une ou plusieurs broches de signal (OUT ou SIG) à connecter à une broche d'entrée de la carte.
  • Exemple : Un bouton poussoir nécessite souvent une résistance de "pull-up" ou "pull-down" pour garantir un état stable quand il n'est pas actionné.
• Alimentation électrique des capteurs : La plupart des petits capteurs fonctionnent avec une tension de 3.3V ou 5V, fournie directement par la carte. Il est crucial de respecter la tension d'alimentation pour ne pas endommager le capteur ou la carte.

La lecture d'un capteur numérique est l'une des opérations les plus fondamentales.

• Fonction de lecture numérique (digitalRead) : Cette fonction permet de lire l'état d'une broche numérique. Elle renvoie soit HIGH (si la tension est élevée, généralement 5V ou 3.3V), soit LOW (si la tension est basse, proche de 0V).

  int etatBouton = digitalRead(brocheBouton); // Lit l'état du bouton
  

• États HIGH et LOW :
  • HIGH : Représente l'état "actif" ou "1".
  • LOW : Représente l'état "inactif" ou "0".
  • Par exemple, pour un bouton, HIGH peut signifier "appuyé" et LOW "non appuyé", ou l'inverse selon le câblage (résistance de pull-up ou pull-down).
• Exemple : bouton poussoir :

  const int brocheBouton = 2; // Le bouton est connecté à la broche numérique 2
  const int brocheLED = 13;   // Une LED est connectée à la broche numérique 13
  
  void setup() {
    pinMode(brocheBouton, INPUT_PULLUP); // Configure la broche du bouton en entrée avec résistance de pull-up interne
    pinMode(brocheLED, OUTPUT);         // Configure la broche de la LED en sortie
  }
  
  void loop() {
    int etatBouton = digitalRead(brocheBouton); // Lit l'état du bouton
  
    if (etatBouton == LOW) { // Si le bouton est appuyé (LOW si pull-up)
      digitalWrite(brocheLED, HIGH); // Allume la LED
    } else {
      digitalWrite(brocheLED, LOW);  // Éteint la LED
    }
  }
  

  Comprendre les états HIGH/LOW est crucial pour interpréter correctement le capteur numérique.

Les capteurs numériques sont souvent utilisés pour déclencher des actions spécifiques.

• Déclenchement d'actions (LED, buzzer) : L'état d'un capteur numérique peut servir de condition pour allumer une LED, faire sonner un buzzer, activer un moteur, etc.

  if (digitalRead(brocheCapteurMouvement) == HIGH) {
    // Mouvement détecté
    digitalWrite(brocheAlarme, HIGH); // Active une alarme
  } else {
    // Pas de mouvement
    digitalWrite(brocheAlarme, LOW);  // Désactive l'alarme
  }
  

• Structures conditionnelles avancées : On peut combiner plusieurs conditions avec ET (&&) ou OU (||).

  // Si le bouton est appuyé ET qu'il fait sombre
  if (digitalRead(brocheBouton) == LOW && analogRead(brocheLDR) < 200) {
    digitalWrite(brocheLampe, HIGH);
  } else {
    digitalWrite(brocheLampe, LOW);
  }
  

• Exemple : capteur de fin de course : Un capteur de fin de course est un interrupteur qui détecte si un objet a atteint une position limite.
  • Utilisation : Pour arrêter un moteur, changer la direction d'un robot, etc.
  • Si le capteur de fin de course est activé (HIGH), alors le moteur s'arrête.

Mettre en pratique est la meilleure façon d'apprendre.

• Conception d'un système d'alarme simple : Utiliser un détecteur de mouvement PIR. Si un mouvement est détecté, un buzzer se déclenche et/ou une LED s'allume.
• Compteur d'objets : Utiliser un capteur de fin de course ou un capteur infrarouge pour compter le nombre de fois qu'un objet passe devant lui. Afficher le compte sur le moniteur série.
• Feu de signalisation interactif : Un bouton poussoir pour demander le passage. Quand le bouton est appuyé, le feu passe au vert après un certain délai, puis revient au rouge.

Les capteurs analogiques fournissent des informations plus détaillées que les capteurs numériques.

• Fonction de lecture analogique (analogRead) : Cette fonction lit la tension sur une broche analogique et la convertit en une valeur numérique.

  int valeurCapteurLumiere = analogRead(brocheCapteurLumiere);
  

• Plage de valeurs (0-1023) : Sur la plupart des cartes Arduino, la tension d'entrée (0V à 5V) est convertie en une valeur entière de 0 à 1023.
  • 0 correspond à 0V.
  • 1023 correspond à 5V.
  • Chaque incrément de 1 représente environ $5V / 1024 \approx 0.0049V$ (ou 4.9mV).
  • Cette plage de 1024 valeurs permet une mesure plus fine.
• Exemple : capteur de lumière (LDR) : Une LDR est une résistance dont la valeur diminue quand la lumière augmente. En la montant en diviseur de tension, on obtient une tension qui varie avec la lumière.

  const int brocheLDR = A0; // LDR connectée à la broche analogique A0
  const int brocheLED = 9;  // LED connectée à la broche numérique 9 (PWM)
  
  void setup() {
    Serial.begin(9600); // Initialise la communication série
    pinMode(brocheLED, OUTPUT);
  }
  
  void loop() {
    int valeurLumiere = analogRead(brocheLDR); // Lit la valeur du capteur de lumière
    Serial.print("Valeur LDR : ");
    Serial.println(valeurLumiere);
    delay(100);
  }
  

Les valeurs brutes des capteurs analogiques doivent souvent être traitées pour être utiles.

• Conversion de valeurs (map) : La fonction map() est très utile pour convertir une plage de valeurs en une autre. Par exemple, convertir la plage 0-1023 en une plage 0-255 (pour contrôler la luminosité d'une LED via PWM).

  int valeurLumiere = analogRead(brocheLDR); // 0-1023
  int luminositeLED = map(valeurLumiere, 0, 1023, 0, 255); // Convertit en 0-255
  analogWrite(brocheLED, luminositeLED); // Contrôle la luminosité de la LED
  

• Seuils et intervalles : On peut définir des seuils pour déclencher des actions spécifiques.

  if (valeurLumiere < 200) {
    Serial.println("Il fait très sombre.");
  } else if (valeurLumiere >= 200 && valeurLumiere < 600) {
    Serial.println("Luminosité moyenne.");
  } else {
    Serial.println("Il fait très clair.");
  }
  

• Exemple : capteur de température : Un capteur comme le LM35 renvoie une tension proportionnelle à la température (souvent 10mV par degré Celsius). Il faut convertir la valeur lue (0-1023) en tension, puis en température.

  int valeurBrute = analogRead(brocheTemp);
  float tension = valeurBrute * (5.0 / 1023.0); // Convertit en Volts
  float temperatureCelsius = tension * 100.0;   // Convertit en Celsius (pour LM35)
  Serial.print("Température : ");
  Serial.print(temperatureCelsius);
  Serial.println(" °C");
  

  La fonction map() simplifie grandement la conversion de plages de valeurs.

• Variateur de lumière automatique : La luminosité d'une LED (ou d'une ampoule via un module relai) varie en fonction de la lumière ambiante mesurée par une LDR.
• Thermomètre numérique : Afficher la température mesurée par un capteur de température sur le moniteur série, ou sur un petit écran LCD.
• Détecteur de distance : Utiliser un capteur ultrason pour mesurer la distance à un obstacle. Si l'obstacle est trop proche, déclencher une alarme ou afficher un message.

La vraie puissance de la programmation réside dans la capacité à faire interagir capteurs et actionneurs pour créer des systèmes intelligents.

• Logique de contrôle : C'est le "cerveau" du programme. Il analyse les données des capteurs et décide quelles actions les actionneurs doivent effectuer.
  • Exemple : Si le capteur de température détecte 25°C et que le capteur de lumière détecte l'obscurité, alors allumer la climatisation et la lumière.
• Réponse du système : La rapidité et la pertinence de la réponse sont cruciales. Il faut s'assurer que les actions sont déclenchées au bon moment et de la bonne manière.
• Exemple : robot suiveur de ligne :
  • Capteurs : Deux capteurs infrarouges sous le robot (un à gauche, un à droite) pour détecter une ligne noire sur un fond blanc.
  • Actionneurs : Deux moteurs (un pour chaque roue).
  • Logique :
    • Si les deux capteurs sont sur la ligne : avancer tout droit.
    • Si le capteur gauche est hors de la ligne : tourner à gauche.
    • Si le capteur droit est hors de la ligne : tourner à droite.
  • La combinaison de plusieurs capteurs permet une compréhension plus complexe de l'environnement.

Le débogage est l'art de trouver et de corriger les erreurs. C'est une compétence essentielle en programmation.

• Identification des erreurs (syntaxe, logique) :
  • Erreurs de syntaxe : Fautes de frappe, points-virgules manquants, parenthèses non fermées. Le compilateur les détecte souvent et affiche des messages d'erreur.
  • Erreurs de logique : Le programme s'exécute, mais ne fait pas ce qu'on attend. C'est plus difficile à trouver, car le programme "pense" qu'il fait la bonne chose.
• Utilisation du moniteur série (Serial.print) : C'est l'outil de débogage le plus simple et le plus puissant pour les cartes comme Arduino.
  • Permet d'afficher les valeurs des variables, l'état des capteurs, ou des messages de progression à différents points du programme.

  // Dans setup()
  Serial.begin(9600);
  
  // Dans loop() pour vérifier une valeur
  int valeurCapteur = analogRead(A0);
  Serial.print("Valeur lue : ");
  Serial.println(valeurCapteur); // Affichera la valeur sur le moniteur série
  

• Stratégies de résolution de problèmes :
  1. Isoler le problème : Tester chaque partie du programme séparément.
  2. Vérifier le câblage : Une mauvaise connexion est une cause fréquente d'erreurs.
  3. Utiliser le moniteur série : Afficher des informations clés pour comprendre ce qui se passe.
  4. Simplifier le code : Retirer des parties du code pour voir si l'erreur disparaît, puis les rajouter une par une.
  5. Rechercher sur internet : Les messages d'erreur sont souvent connus et des solutions existent en ligne.

Écrire du code qui fonctionne est une chose, écrire du bon code en est une autre.

• Commentaires et lisibilité :
  • // Ceci est un commentaire sur une ligne
  • /* Ceci est un commentaire sur plusieurs lignes */
  • Les commentaires expliquent ce que fait le code, pourquoi il le fait, et comment il fonctionne. Ils sont essentiels pour que d'autres personnes (ou vous-même plus tard) puissent comprendre votre programme.
  • Utiliser des noms de variables clairs (brocheLED au lieu de b1).
• Modularité du code (fonctions) : Diviser un gros programme en petites fonctions (void allumerLED(), int lireTemperature()) rend le code plus organisé, plus facile à lire et à déboguer. Chaque fonction a une tâche spécifique.

  void setup() {
    // ...
  }
  
  void loop() {
    gererLumiere();
    gererTemperature();
    // ...
  }
  
  void gererLumiere() {
    // Code pour lire le capteur de lumière et contrôler la LED
  }
  
  void gererTemperature() {
    // Code pour lire le capteur de température
  }
  

• Gestion de l'énergie (si applicable) : Pour les systèmes alimentés par batterie, il est important de penser à la consommation d'énergie. Certaines techniques incluent :
  • Mettre le microcontrôleur en mode veille (sleep mode).
  • Éteindre les capteurs ou actionneurs quand ils ne sont pas utilisés.
  • Un code bien structuré est plus facile à maintenir et à faire évoluer.