Programmer pour répondre à un besoin
Un portail qui s'ouvre quand tu appuies sur la télécommande, un store qui descend quand le soleil tape fort, une serre qui s'aère toute seule : derrière chacun de ces objets, un programme décide. Il lit les informations des capteurs, applique des règles, puis commande les actionneurs. Depuis la 5e, tu analyses et modifies des programmes ; en 4e, tu traduis un algorithme en programme ; en 3e, tu élabores toi-même l'algorithme et tu structures le programme.
Ce que tu sauras faire
Analyser un programme fourni et le tester
Analyser un programme, c'est dire ce qu'il fait, ligne par ligne, avec des valeurs précises. Tester, c'est comparer ce qu'il fait réellement avec le besoin à satisfaire. Trois mots reviennent partout : une variable garde une valeur qui peut changer ; une condition (« si… alors… sinon ») choisit entre deux actions ; une boucle (« répéter ») recommence des instructions.
Exemple
Besoin : le store descend quand il y a trop de lumière et remonte quand il y en a peu. Programme fourni :
répéter indéfiniment
si luminosité > 800 alors
descendre le store
Pour tester, tu choisis des valeurs et tu déroules le programme à la main :
- luminosité = 900 : la condition est vraie, le store descend ;
- luminosité = 300 : la condition est fausse, rien ne se passe.
Le store ne remonte jamais : le programme ne répond qu'à la moitié du besoin. Un bon test couvre tous les cas du besoin, y compris celui où la lumière diminue.
Modifier un programme ou un algorithme
Un algorithme est la suite d'étapes écrite en français, avant le programme ; le programme écrit cette suite dans le langage du logiciel. On modifie l'un ou l'autre de la même façon : tu repères l'écart avec le besoin, tu changes une valeur ou tu ajoutes une instruction, puis tu reteste.
Exemple
Pour que le store remonte, on ajoute le cas contraire :
répéter indéfiniment
si luminosité > 800 alors
descendre le store
sinon
monter le store
Tu reteste avec 900 (le store descend) puis avec 300 (il monte). Si le soleil gêne déjà à 600, tu modifies seulement le seuil : 800 devient 600. Change une seule chose à la fois : sinon tu ne sais plus laquelle a corrigé, ou cassé, le comportement.
Élaborer un algorithme
En 3e, tu pars du besoin, pas d'un programme déjà écrit. La démarche tient en quatre temps :
- Formule le besoin en une phrase, puis liste les entrées (capteurs, boutons) et les sorties (actionneurs, affichage).
- Choisis la structure : une boucle si le système surveille en permanence, une condition pour chaque choix, une variable pour garder une valeur en mémoire.
- Écris l'algorithme en français, une instruction par ligne.
- Déroule-le à la main avec des valeurs d'essai.
Exemple
Serre connectée : la lucarne doit s'ouvrir au-dessus de 28 °C et se fermer sinon. Entrée : le capteur de température. Sortie : le moteur de la lucarne.
répéter indéfiniment
mesurer la température
si température > 28 alors
ouvrir la lucarne
sinon
fermer la lucarne
Déroulé : à 31 °C, la lucarne s'ouvre ; à 22 °C, elle se ferme. La démarche complète est résumée ci-dessous : si un test échoue, tu reviens corriger l'algorithme ou le programme.
Traduire l'algorithme en programme
Traduire, c'est remplacer chaque ligne de l'algorithme par l'instruction équivalente du logiciel : « répéter indéfiniment » devient un bloc de boucle, « si… sinon » un bloc de condition, « mesurer la température » la lecture du capteur. Tu utilises les noms exacts des capteurs et des actionneurs du système réel.
Exemple
Compteur de places d'un parking de 50 places. Algorithme : au départ, il reste 50 places ; chaque fois qu'une voiture entre, on retire 1 place ; s'il ne reste aucune place, on affiche COMPLET. Programme (la flèche ← signifie « prend la valeur ») :
places ← 50
répéter indéfiniment
si une voiture entre alors
places ← places − 1
si places = 0 alors
afficher COMPLET
Après l'instruction « places ← places − 1 », la nouvelle valeur est l'ancienne moins 1 : après trois voitures, places vaut 47. Tu vérifies ta traduction en déroulant le programme et en retrouvant le résultat de l'algorithme.
Sous-programmes et fonctions : la modularité
Quand la même suite d'instructions revient, tu ne la recopies pas : tu la regroupes dans un sous-programme, un bloc d'instructions qui porte un nom. Le programme principal l'appelle par son nom, autant de fois que nécessaire. Découper un programme en blocs indépendants s'appelle la modularité.
Exemple
Un portail s'ouvre avec la télécommande ou avec le clavier à code. Dans les deux cas : allumer le clignotant, démarrer le moteur jusqu'à la fin de course, éteindre le clignotant.
sous-programme ouvrir_portail
allumer le clignotant
démarrer le moteur jusqu'à la fin de course
éteindre le clignotant
programme principal
répéter indéfiniment
si télécommande = 1 alors
ouvrir_portail
si code correct alors
ouvrir_portail
Le sous-programme est écrit une fois : le programme est plus court et plus lisible, une correction se fait en un seul endroit, et tu peux le tester seul.
Une fonction est un sous-programme qui reçoit des valeurs et renvoie un résultat, comme une fonction en mathématiques.
fonction moyenne(a, b)
renvoyer (a + b) / 2
température ← moyenne(20, 24)
Après l'appel, température vaut 22. Elle sert ici à faire la moyenne de deux mesures d'un capteur.
Structurer et commenter un programme
Un programme structuré s'organise de façon lisible, par exemple dans cet ordre : un commentaire de présentation, le départ (les variables reçoivent leur valeur de départ), le programme principal avec sa boucle, puis les sous-programmes et les fonctions. Un commentaire est une ligne que la machine ignore : il explique à celui qui relit à quoi sert un bloc et pourquoi une valeur a été choisie. Grâce à lui, un camarade peut reprendre ton programme et travailler avec toi. Le symbole qui marque un commentaire dépend du logiciel ; ici, c'est #.
Exemple
La serre, mieux structurée :
# Serre : aération automatique
seuil ← 28 # température d'ouverture, en °C
répéter indéfiniment
température ← lire le capteur
si température > seuil alors
ouvrir_lucarne
sinon
fermer_lucarne
Le nom « seuil » dit ce que représente la valeur ; pour changer la température d'ouverture, tu ne modifies qu'une ligne. Les sous-programmes ouvrir_lucarne et fermer_lucarne sont écrits plus bas.
Réaliser un système avec interaction humain-machine
Dans un système réel, une personne agit sur la machine (bouton, clavier, télécommande) et la machine lui répond (voyant, écran, mouvement) : c'est une interaction humain-machine. Le programme doit attendre l'action de la personne, puis lui répondre de façon claire.
Exemple
Barrière de parking : le conducteur appuie sur un bouton, la barrière se lève, puis redescend après son passage. La cellule vaut 1 quand une voiture est devant la barrière.
répéter indéfiniment
afficher « Appuyez sur le bouton »
attendre que bouton = 1
lever_barrière
attendre que cellule = 0
baisser_barrière
Mise au point. Au test sur le système réel, la barrière redescend tout de suite : quand elle se lève, la voiture n'est pas encore devant la cellule, donc cellule vaut déjà 0. Tu observes l'écart, tu corriges une seule chose, tu reteste : il faut attendre d'abord que la voiture arrive, puis qu'elle parte. La fin du programme devient :
lever_barrière
attendre que cellule = 1
attendre que cellule = 0
baisser_barrière
Les pièges à éviter
- Condition ou boucle. « si » teste une seule fois ; « répéter » recommence. Sans boucle, le store ne regarde la lumière qu'une fois.
- Avant et après. Dans « places ← places − 1 », le calcul utilise l'ancienne valeur ; la variable ne prend la nouvelle valeur qu'après l'instruction.
- Un seul test. Un programme qui marche pour 900 peut échouer pour 300 : teste chaque cas du besoin, y compris le « sinon ».
- Capteur ou actionneur. Le capteur envoie une information au programme (entrée) ; l'actionneur exécute l'ordre du programme (sortie).
- Définir sans appeler. Un sous-programme écrit mais jamais appelé ne s'exécute pas.
Ce qu'il faut retenir
- Analyser un programme, c'est le dérouler à la main avec des valeurs ; tester, c'est vérifier qu'il répond à tout le besoin.
- Un algorithme est écrit en français ; le programme le traduit pour la machine, ligne par ligne.
- Démarche : besoin, entrées et sorties, structure (boucle, condition, variable), algorithme, programme, test, mise au point.
- Une variable garde une valeur qui change ; une condition choisit ; une boucle recommence.
- Un sous-programme est un bloc nommé, écrit une fois et appelé autant de fois que nécessaire ; une fonction renvoie un résultat. La modularité rend le programme plus court, plus lisible, plus facile à corriger et à tester.
- Un programme structuré a un départ, un programme principal, des sous-programmes, des noms parlants et des commentaires.
- Dans une interaction humain-machine, le programme attend l'action de la personne, puis lui répond.
- Mettre au point : observer l'écart sur le système réel, corriger une seule chose, retester.
À l'épreuve
Au brevet, l'épreuve de sciences dure une heure et porte sur deux disciplines tirées au sort parmi physique-chimie, SVT et technologie : tu révises les trois. En technologie, un exercice de programmation décrit des documents (besoin, schéma, programme en blocs ou en pseudo-code), puis enchaîne des questions. Consignes possibles, du type : « Indique la valeur de la variable après l'exécution », « Déroule le programme pour une température de 31 °C », « Propose la modification qui répond au besoin », « Explique à quoi sert ce sous-programme ». Le correcteur attend des réponses précises, appuyées sur une ligne du programme ou une valeur, et une justification par le besoin visé. Une partie de programme à écrire peut être remplacée par un choix ou une valeur à donner. Écris les valeurs successives de la variable : le déroulé montre ton raisonnement.