La programmation de systèmes automatisés

Un système automatisé est un ensemble d'éléments qui réalisent des tâches sans intervention humaine directe, ou avec une intervention minimale. Il fonctionne de manière autonome selon un programme préétabli. L'objectif principal est de faciliter la vie, d'améliorer la productivité ou la sécurité.

• Le portail électrique de la maison qui s'ouvre et se ferme seul.
• Le lave-linge qui suit un cycle de lavage sans que vous ayez à tourner chaque bouton manuellement.
• Le distributeur de boissons qui vous donne votre soda après avoir inséré une pièce.
• Les feux de circulation qui régulent le trafic.

La différence avec un système manuel est simple : un système manuel nécessite une action humaine constante pour fonctionner (ex: un interrupteur manuel pour allumer une lumière). Un système automatisé, une fois programmé, exécute ses tâches seul.

La programmation est l'art de donner des ordres à une machine. C'est comme écrire une recette très détaillée que la machine va suivre à la lettre. On programme un système pour lui permettre d'être autonome. Sans programmation, un système automatisé n'est qu'un ensemble de pièces inertes.

Rôle de la programmation :

• Donner des ordres précis et logiques à la machine.
• Définir la séquence des actions à réaliser.
• Permettre au système de réagir à son environnement (grâce aux capteurs).
• Assurer l'autonomie du système pour qu'il fonctionne sans intervention humaine constante.

Par exemple, le programme d'un lave-linge lui dit : "remplir d'eau", "chauffer à 40°C", "faire tourner le tambour pendant 30 minutes", "vidanger", etc.

Un système automatisé est généralement composé de deux grandes parties qui travaillent ensemble :

1. La partie commande (le cerveau) : C'est le cœur intelligent du système. Elle interprète les informations reçues des capteurs et prend des décisions selon le programme enregistré. Elle envoie ensuite des ordres à la partie opérative.

   • Exemples : microcontrôleur, carte électronique (comme un Arduino ou un Raspberry Pi), ordinateur.

2. La partie opérative (les muscles) : C'est la partie qui réalise les actions physiques. Elle exécute les ordres donnés par la partie commande.

   • Exemples : moteurs, vérins, lampes, résistances chauffantes.

Ces deux parties communiquent grâce à des éléments spécifiques :

• Les capteurs : Ce sont les "sens" du système. Ils mesurent des grandeurs physiques (température, lumière, présence, distance) et envoient ces informations à la partie commande.
  • Exemples : capteur de lumière, capteur de température, interrupteur de fin de course, capteur de présence.
• Les actionneurs : Ce sont les "organes" qui exécutent les ordres de la partie commande en transformant une énergie (électrique, pneumatique) en une action physique.
  • Exemples : moteur électrique (pour ouvrir un portail), lampe (pour signaler), résistance chauffante (pour un four), haut-parleur (pour émettre un son).

Un système automatisé est une boucle : Capteurs → Partie commande → Partie opérative → Environnement → Capteurs.

Un algorithme est une suite finie et ordonnée d'instructions claires et précises, qui permet de résoudre un problème ou d'accomplir une tâche. C'est une méthode de résolution, un mode d'emploi.

• Une recette de cuisine est un algorithme : "Prendre 3 œufs", "Mélanger avec 100g de farine", "Faire cuire 20 minutes à 180°C". Chaque étape est précise et doit être suivie dans l'ordre.
• Les instructions pour monter un meuble.
• Le mode d'emploi pour utiliser un appareil.

L'algorithme est la logique derrière le programme. Avant de programmer, on réfléchit à l'algorithme. Un ordinateur ne fait qu'exécuter des algorithmes.

Créer un algorithme, c'est comme résoudre une énigme en plusieurs étapes :

1. Analyse du besoin : Comprendre clairement ce que l'on veut que le système fasse. Quel est le problème à résoudre ? Quel est le résultat attendu ?

   • Exemple : "Je veux que ma lampe s'allume quand il fait nuit."

2. Décomposition en tâches simples : Diviser le problème complexe en petites étapes plus faciles à gérer. Chaque étape doit être une action élémentaire.

   • Exemple pour la lampe : 1. Mesurer la luminosité. 2. Décider s'il fait nuit. 3. Allumer ou éteindre la lampe.

3. Ordre des instructions : Déterminer la séquence logique dans laquelle ces tâches doivent être exécutées. L'ordre est crucial !

   • On ne peut pas allumer la lampe AVANT de savoir s'il fait nuit.

Pour visualiser et comprendre un algorithme, on peut utiliser différentes méthodes :

1. Langage naturel : Écrire les étapes avec des phrases simples, comme une liste d'instructions. C'est facile à lire mais peut manquer de précision.

   • Exemple : "Si la luminosité est faible, allumer la lampe. Sinon, l'éteindre."

2. Organigramme : C'est une représentation graphique de l'algorithme, utilisant des symboles géométriques standards pour les différentes actions et décisions. Les flèches indiquent l'ordre d'exécution.

   • Symboles courants :
     • Ovale : Début/Fin
     • Rectangle : Action/Traitement
     • Parallélogramme : Entrée/Sortie de données
     • Losange : Décision/Condition (oui/non)

3. Pseudo-code : C'est un langage intermédiaire entre le langage naturel et un langage de programmation. Il utilise une syntaxe structurée mais n'est pas exécutable par une machine. Il permet de se concentrer sur la logique sans se soucier des détails techniques d'un langage de programmation spécifique.

   • Exemple :

     DEBUT
         LIRE luminosité
         SI luminosité < seuil_nuit ALORS
             ALLUMER lampe
         SINON
             ETEINDRE lampe
         FIN SI
     FIN
     

Pour les débutants, la programmation visuelle par blocs est un excellent moyen d'apprendre. Des logiciels comme Scratch (développé par le MIT) permettent de créer des programmes en assemblant des blocs graphiques, comme des pièces de LEGO.

Interface utilisateur de Scratch (ou équivalent) :

• Zone de scène : Là où votre programme s'exécute, on y voit les personnages (sprites) et l'arrière-plan.
• Sprites et arrière-plans : Listes des éléments graphiques.
• Palette de blocs : C'est là que vous trouvez tous les types d'instructions (mouvement, apparence, événements, etc.), classées par couleur.
• Zone de script : C'est l'espace où vous assemblez les blocs pour créer votre programme.

L'avantage est que l'on n'a pas à se soucier de la syntaxe (les règles d'écriture du code), ce qui réduit les erreurs et facilite l'apprentissage de la logique de programmation.

Chaque bloc représente une instruction spécifique. Voici quelques catégories de blocs fondamentaux :

• Mouvement : Pour déplacer un sprite.
  • avancer de 10 pas
  • tourner de 15 degrés
  • aller à x: (0) y: (0) (pour positionner le sprite)
• Apparence : Pour modifier l'aspect du sprite ou afficher du texte.
  • dire "Bonjour !" pendant 2 secondes
  • changer de costume par (costume2)
  • afficher / cacher
• Événements : Ces blocs déclenchent le début d'un script.
  • quand le drapeau vert est cliqué (démarre le programme)
  • quand la touche espace est pressée
  • quand ce sprite est cliqué

Ces blocs sont les briques élémentaires pour construire n'importe quel programme.

Une séquence d'instructions est simplement une série de blocs placés les uns sous les autres dans la zone de script. L'ordinateur exécutera ces blocs dans l'ordre, du haut vers le bas.

Création de petits programmes :

1. Prenez un bloc "quand le drapeau vert est cliqué" (pour démarrer).
2. Ajoutez des blocs de mouvement et d'apparence en dessous.
   • Exemple : quand le drapeau vert est cliqué → dire "Je commence !" pendant 1 seconde → avancer de 50 pas → tourner de 90 degrés → dire "J'ai tourné !" pendant 1 seconde.

Le débogage simple consiste à tester son programme et à corriger les erreurs (appelées "bugs"). Si votre sprite ne fait pas ce que vous voulez, vérifiez l'ordre de vos blocs ou les valeurs que vous avez entrées. Le débogage est une étape essentielle et normale en programmation.

Les boucles permettent de répéter une ou plusieurs instructions plusieurs fois sans avoir à les écrire manuellement. Cela rend le code plus court et plus efficace.

• Répéter indéfiniment : Le bloc répéter indéfiniment exécute les instructions qu'il contient sans jamais s'arrêter, tant que le programme est en cours.
  • Utile pour un personnage qui marche en continu ou un fond sonore.
• Répéter N fois : Le bloc répéter (10) fois exécute les instructions un nombre de fois défini.
  • Exemple : Pour dessiner un carré, on peut faire répéter 4 fois { avancer de 100 pas, tourner de 90 degrés }. C'est plus court que d'écrire "avancer, tourner, avancer, tourner..." quatre fois.

Les boucles sont essentielles pour l'optimisation du code : elles évitent la répétition et rendent le programme plus facile à lire et à modifier.

Les conditions permettent au programme de prendre des décisions et d'exécuter différentes actions en fonction de si une certaine situation est vraie ou fausse.

• Si... alors... : Le bloc si (condition) alors { ... } exécute les instructions entre les accolades UNIQUEMENT si la condition est vraie.
  • Exemple : si (touche espace pressée) alors { sauter }.
• Si... alors... sinon... : Le bloc si (condition) alors { ... } sinon { ... } exécute un ensemble d'instructions si la condition est vraie, et un autre ensemble si elle est fausse.
  • Exemple : si (il pleut) alors { prendre parapluie } sinon { prendre lunettes de soleil }.
• Opérateurs logiques : Pour construire des conditions plus complexes, on utilise des opérateurs logiques :
  • et : La condition est vraie si TOUTES les sous-conditions sont vraies.
  • ou : La condition est vraie si AU MOINS UNE des sous-conditions est vraie.
  • non : Inverse la valeur de vérité d'une condition (vrai devient faux, faux devient vrai).
  • Exemple : si (il pleut ET j'ai faim) alors { commander pizza }.

En combinant boucles et conditions, on peut créer des programmes beaucoup plus complexes et interactifs.

• Un jeu simple : répéter indéfiniment { si (touche flèche droite pressée) alors { avancer } si (touche flèche gauche pressée) alors { reculer } }.
• Un système d'alarme : répéter indéfiniment { si (capteur de mouvement détecte) alors { sonner alarme } }.

Cela permet au système de réagir à des événements et de s'adapter à son environnement, rendant l'automatisation vraiment utile.

Une variable est comme une petite boîte dans la mémoire de l'ordinateur où l'on peut stocker des informations (des données). Ces informations peuvent changer pendant l'exécution du programme.

• Qu'est-ce qu'une variable ? C'est un nom qui représente une valeur qui peut varier.
  • Exemples : score, nom_joueur, nombre_vies, température.
• Stocker des informations :
  • mettre [ma_variable] à (0) : initialise la variable.
  • ajouter (1) à [score] : incrémente le score.
• Utilisation dans les programmes : Les variables sont utilisées pour suivre l'état du jeu, les préférences de l'utilisateur, les calculs, etc.
  • Si score atteint 100, alors le joueur gagne.

Un système automatisé ou un programme est souvent plus intéressant s'il peut interagir avec l'utilisateur.

• Demander et attendre : Le bloc demander [Quel est ton nom ?] et attendre permet au programme de poser une question à l'utilisateur et d'attendre sa réponse. La réponse est stockée dans une variable spéciale appelée réponse.
• Répondre à l'utilisateur : Ensuite, on peut utiliser cette réponse pour personnaliser le programme.
  • Exemple : dire [Bonjour ] + [réponse].
• Capteurs (souris, clavier) : Les capteurs intégrés à l'environnement de programmation permettent de réagir aux actions de l'utilisateur.
  • souris x / souris y : position de la souris.
  • souris pressée ? : si le bouton de la souris est enfoncé.
  • touche (espace) pressée ? : si une touche du clavier est enfoncée.

Pour appliquer toutes ces connaissances, le meilleur moyen est de créer un mini-projet.

• Exemple de projet : Un jeu de type "attrape-moi si tu peux".
  • Un personnage se déplace aléatoirement (boucle).
  • Quand l'utilisateur clique dessus (événement, capteur souris), le score augmente (variable) et le personnage se téléporte (mouvement).
  • Un temps limité (variable, condition).

Les étapes clés sont :

1. Conception : Réfléchir à ce que le jeu doit faire (l'algorithme).
2. Programmation : Assembler les blocs.
3. Test et amélioration : Jouer au jeu, identifier les bugs, et ajouter de nouvelles fonctionnalités. C'est le débogage et l'amélioration continue. Ce processus permet de consolider les acquis et de comprendre comment les différentes notions s'articulent.