Ficha de revisão: Automatisation et Programmation de Systèmes

📋 Plan du Cours

1. Définitions fondamentales : algorithme, algorigramme et programme
2. Symboles normalisés pour la conception d'un logigramme
3. Catégories de langages de programmation et compilation en langage machine
4. Méthodologie pour résoudre un problème d'automatisme par programmation
5. Exemples d'algorithmes, logigrammes et programmes appliqués à des systèmes automatisés
6. Utilisation d'algorithmes et programmes pour la gestion d'obstacles et d'éclairage automatique
7. Concepts de séquence d'instructions, boucles et instructions conditionnelles en programmation
8. Définition et utilisation des variables en programmation automatisée
9. Exemples pratiques de boucles et instructions conditionnelles avec le logiciel Picaxe Editor
10. Programmation de déplacements et comportements du robot Picaxe avec séquences, boucles et conditions
11. Instructions conditionnelles en cascade et variables de comptage en programmation

📖 1. Définitions fondamentales : algorithme, algorigramme et programme

🔑 Notions clés & Définitions

• Algorithme : Une suite logique d'actions ou d'instructions à réaliser qui permet de décrire la manière dont un problème sera résolu, souvent rédigée en langage naturel sous forme de phrases avec des mots clés tels que si, alors, tant que, sinon, ou, et, jusqu'à.
• Page : Terme non défini dans le contenu source.

📝 Points essentiels

• Un algorigramme ou logigramme est une représentation graphique normalisée d'un algorithme utilisant des symboles spécifiques : un ovale pour le début et la fin, un losange pour les décisions avec des flèches indiquant les réponses oui ou non, et un rectangle pour les actions.
• Un programme est la traduction d'un algorithme ou d'un logigramme en langage de programmation, qui doit ensuite être compilé en langage machine (code binaire) pour être transféré et exécuté par le microprocesseur du système informatique ou automatique.
• Il est la plupart du temps rédigé en langage naturel (sous forme de phrases) et en utilisant des mots clés comme : si, alors, tant que, sinon, ou, et, jusqu'à, etc. Un algorigramme ou un logigramme est un outil qui permet de représenter de manière graphique (et donc de manière plus lisible) un algorithme.
• Une fois le programme écrit, celui-ci devra être converti/compilé en langage machine (code binaire) afin d'être transféré puis exécuté par le microprocesseur du système informatique ou du système automatique.

💡 À retenir

La résolution d'un problème progresse de la description textuelle d'un algorithme à sa représentation graphique par un algorigramme, puis à sa traduction informatique sous forme de programme exécutable.

📖 2. Symboles normalisés pour la conception d'un logigramme

🔑 Notions clés & Définitions

• Symbole Début/Fin : forme ovale qui indique le début ou la fin d’un logigramme.
• Symbole Décision : forme losange utilisée pour représenter une étape de décision ou un évènement conditionnel, avec deux sorties possibles : Oui ou Non.
• Symbole Action : forme rectangle qui désigne une action ou une instruction à exécuter dans le processus représenté.

📝 Points essentiels

• Le symbole ovale sert à marquer le début ou la fin d’un logigramme, permettant ainsi de délimiter clairement l’ensemble du processus.
• Le losange est réservé aux décisions ou évènements conditionnels, où une question ou une condition doit être évaluée. Il possède deux sorties conditionnelles : une pour la réponse Oui, une pour la réponse Non.
• Le rectangle représente une étape d’action ou d’instruction, correspondant à une opération à réaliser dans le déroulement du processus. Il doit contenir une description claire de l’action effectuée.

💡 À retenir

Maîtriser l’utilisation des symboles normalisés (ovale, losange, rectangle) est essentiel pour concevoir un logigramme clair, lisible et efficace.

📖 3. Catégories de langages de programmation et compilation en langage machine

🔑 Notions clés & Définitions

• La programmation par lignes de codes : Une catégorie de langages de programmation utilisant du texte écrit ligne par ligne, tels que Delphi, Python, C, Basic.
• Langage machine : Le code binaire exécutable par un microprocesseur, obtenu après compilation d'un programme écrit dans un langage de haut niveau.

📝 Points essentiels

• Les langages de programmation se divisent en programmation par blocs (ex : Scratch, Blockly) et par lignes de code (ex : Python, C, Basic).
• La compilation est généralement automatique et invisible lors du transfert du programme vers le microprocesseur.

💡 À retenir

Les langages de programmation se divisent en programmation par blocs (ex : Scratch, Blockly) et par lignes de code (ex : Python, C, Basic).

📖 4. Méthodologie pour résoudre un problème d'automatisme par programmation

🔑 Notions clés & Définitions

• Voyant vert : Un dispositif lumineux utilisé pour indiquer que la barrière automatique est ouverte et que le système fonctionne correctement.

📝 Points essentiels

• Adopter une démarche structurée et progressive pour transformer un problème d'automatisme en programme exécutable.
• | Un algorithme (alarme anti-intrusion) | Un logigramme (barrière automatique) | Un programme Scratch (jeu de multiplication) | Un programme en langage machine | |---------------------------------------|-------------------------------------|----------------------------------------------|---------------------------------| | Texte :
  Si quelqu’un franchit la porte ou une fenêtre de la maison, et si l’alarme est active alors une alarme sonore se déclenche.
  L’alarme s’arrête si l’utilisateur désactive le système d’alarme. | [Logigramme avec décisions "Code valide ?", "Voiture passée ?", actions "Allumer voyant rouge 3 secondes", "Ouvrir barrière et allumer voyant vert", "Fermer barrière et éteindre voyant vert"] | [Bloc Scratch avec instructions de multiplication aléatoire, demande de résultat, condition si réponse correcte ou non, dire "Gagné !" ou "Perdu, la réponse était :"] | [Code hexadécimal en colonnes avec adresses et valeurs] |

💡 À retenir

Une démarche structurée et progressive est nécessaire pour transformer un problème d'automatisme en un programme exécutable.

📖 5. Exemples d'algorithmes, logigrammes et programmes appliqués à des systèmes automatisés

🔑 Notions clés & Définitions

• Programme en langage machine : Ensemble d'instructions codées en hexadécimal, organisées par adresses et valeurs, qui sont directement exécutables par un ordinateur.
• Logigramme avec décisions : Diagramme illustrant un algorithme où des symboles spécifiques représentent des points de décision conditionnelle permettant de choisir différentes actions selon les cas.

📝 Points essentiels

• Un algorithme d'alarme anti-intrusion déclenche une alarme sonore si une porte ou une fenêtre est franchie et si l'alarme est active.
• Le logigramme d'une barrière automatique utilise des décisions pour ouvrir ou fermer la barrière selon la présence d'un véhicule.
• Un programme Scratch peut implémenter un jeu de multiplication avec des conditions de réussite ou d'échec, en demandant un résultat et en affichant un message.
• Un programme en langage machine est représenté par du code hexadécimal organisé en colonnes d'adresses et de valeurs.

💡 À retenir

Ces exemples illustrent comment un problème réel peut être traduit en algorithme, logigramme et programme informatique pour automatiser des systèmes.

📖 6. Utilisation d'algorithmes et programmes pour la gestion d'obstacles et d'éclairage automatique

🔑 Notions clés & Définitions

• Allumer l’éclairage : Action consistant à mettre en marche le système lumineux d'une pièce ou d'un espace, déclenchée automatiquement ou manuellement selon des conditions définies.
• Algorithme | Le logigramme | Le programme : Suite ordonnée d'instructions permettant de résoudre un problème ou d'accomplir une tâche spécifique, souvent traduite en logigramme ou programme.

📝 Points essentiels

• Pour éviter un obstacle, l'algorithme fait tourner le robot à droite de 90°, avancer de 10 cm, puis tourner à gauche de 90° si un obstacle est détecté, sinon avancer indéfiniment.
• La gestion automatique d'éclairage allume la lumière si le bouton marche/arrêt est activé, ou si la luminosité est faible et une présence est détectée, avec une temporisation de 30 secondes avant extinction.

💡 À retenir

Des algorithmes simples, traduits en logigrammes et programmes, permettent de piloter des comportements automatisés complexes tels que l'évitement d'obstacles et la gestion automatique de l'éclairage.

📖 7. Concepts de séquence d'instructions, boucles et instructions conditionnelles en programmation

🔑 Notions clés & Définitions

• Séquence d'instructions : Une suite de commandes ou d'actions exécutées les unes à la suite des autres sans conditions préalables, généralement une seule fois.
• Instruction conditionnelle : Une instruction dont l'exécution dépend de la vérification d'une condition ou de l'apparition d'un événement extérieur, pouvant inclure des alternatives et être enchaînée en cascade.
• Instructions conditionnelles : Des instructions qui exécutent une action uniquement si une condition est vraie, avec la possibilité d'alternatives (sinon) et d'enchaînements successifs.
• Boucle : Remarque* : Il est possible d'imbriquer plusieurs boucles les unes dans les autres.

📝 Points essentiels

• Une séquence d'instructions s'exécute sans condition, généralement une seule fois.
• Une séquence d'instructions est une suite de commandes ou d'actions qui seront exécutées les unes à la suite des autres sans conditions préalables et en général une seule fois.

💡 À retenir

Une séquence d'instructions s'exécute sans condition, généralement une seule fois.

📖 8. Définition et utilisation des variables en programmation automatisée

🔑 Notions clés & Définitions

• Variable : Une case mémoire permettant de stocker une donnée modifiable pendant l'exécution du programme, pouvant contenir une valeur numérique ou une chaîne de caractères.

📝 Points essentiels

• Les variables peuvent contenir des valeurs numériques ou des chaînes de caractères.
• Les variables peuvent être utilisées dans des séquences, boucles ou instructions conditionnelles pour gérer des données dynamiques.

💡 À retenir

Les variables jouent un rôle central en tant que supports de données modifiables dans les programmes automatisés, permettant de gérer des informations dynamiques.

📖 9. Exemples pratiques de boucles et instructions conditionnelles avec le logiciel Picaxe Editor

🔑 Notions clés & Définitions

• Boucle répéter indéfiniment : Une structure de programmation qui exécute en boucle une séquence d'instructions sans condition d'arrêt, répétant continuellement tant que le programme est actif.
• Boucle répéter jusqu'à : Une structure de programmation qui répète une séquence d'instructions jusqu'à ce qu'une condition spécifique soit remplie, comme l'activation d'une entrée ou la valeur d'une variable dépassant un seuil.
• Logiciel Picaxe Editor : Un environnement de programmation visuel dédié au robot Picaxe, offrant des blocs pour créer des programmes incluant des boucles et des instructions conditionnelles.

📝 Points essentiels

• Le logiciel Picaxe Editor propose des blocs pour répéter indéfiniment ou jusqu'à une condition spécifique.
• Les instructions conditionnelles peuvent être simples (si... alors) ou avec alternative (si... alors... sinon).

💡 À retenir

Le logiciel Picaxe Editor permet d'appliquer concrètement les boucles et instructions conditionnelles dans un environnement visuel, facilitant la programmation précise du robot Picaxe.

📖 10. Programmation de déplacements et comportements du robot Picaxe avec séquences, boucles et conditions

🔑 Notions clés & Définitions

• Faire avancer le robot Picaxe : Une opération de programmation permettant de faire déplacer le robot en ligne droite, en utilisant des instructions spécifiques pour avancer, tourner ou arrêter selon une séquence ou une condition.

📝 Points essentiels

• Le robot Picaxe peut être programmé pour avancer, faire demi-tour et avancer à nouveau selon une séquence d'instructions.
• Les boucles permettent de répéter des actions comme avancer en continu ou jusqu'à une condition d'arrêt.
• Les conditions détectent des événements (ex : ligne noire) et modifient le comportement du robot (arrêt, demi-tour).

💡 À retenir

Visualiser comment combiner séquences, boucles et conditions pour piloter un robot autonome.

📖 11. Instructions conditionnelles en cascade et variables de comptage en programmation

🔑 Notions clés & Définitions

• Instructions conditionnelles en cascade : Une structure de contrôle permettant d'enchaîner plusieurs tests conditionnels avec des alternatives, utilisant des blocs successifs de type si... alors... sinon..., pour gérer différents cas de manière ordonnée.
• Variable de comptage : Une variable utilisée pour compter le nombre d'occurrences d'un événement, initialisée à zéro et incrémentée à chaque occurrence dans une boucle.
• Conditionnelles en cascade Si… alors : Une suite de tests conditionnels successifs sans bloc sinon, où chaque condition est évaluée et, si vraie, exécute un bloc d'instructions spécifique.
• Cascade "Si… alors… sinon : Une structure conditionnelle en cascade qui inclut des alternatives sinon, permettant de couvrir plusieurs cas possibles dans un ordre hiérarchisé.

📝 Points essentiels

• Les instructions conditionnelles en cascade permettent d'enchaîner plusieurs tests avec alternatives, comme si... alors... sinon... si... alors..., pour gérer différents cas successifs.
• Une variable de comptage sert à compter des occurrences, elle est initialisée à zéro et incrémentée dans une boucle.
• L'utilisation combinée des instructions conditionnelles en cascade et des variables de comptage permet de contrôler des arrêts ou actions après un nombre défini d'événements, par exemple arrêter un robot après la détection de 5 lignes noires.

💡 À retenir

Maîtriser les techniques avancées de contrôle de flux avec conditions multiples et comptage dynamique permet de gérer efficacement des situations complexes en programmation.

🧩 Compléments de couverture

1. Détail source à réviser : Page 1 --- I. Les définitions à savoir Un algorithme est une suite logique d'actions ou d'instructions à réaliser qui permet de décrire la manière dont un problème sera résolu. Il est la plupart du temps rédigé en la (Source: "Page 1 --- I. Les définitions à savoir Un algorithme est une suite logique d'actions ou d'instructions à réaliser qui permet de décrire la manière dont un problème sera résolu. Il est la plupart du temps rédigé en langage naturel (sous forme de phrases) et en utilisant des mots clés comme : si, alors, tant que, sinon, ou, et, jusqu'à, etc. Un")
2. Détail source à réviser : logique d'actions ou d'instructions à réaliser qui permet de décrire la manière dont un problème sera résolu. Il est la plupart du temps rédigé en langage naturel (sous forme de phrases) et en utilisant des mots clés c (Source: "logique d'actions ou d'instructions à réaliser qui permet de décrire la manière dont un problème sera résolu. Il est la plupart du temps rédigé en langage naturel (sous forme de phrases) et en utilisant des mots clés comme : si, alors, tant que, sinon, ou, et, jusqu'à, etc. Un algorigramme ou un logigramme est un outil qui permet de")
3. Détail source à réviser : (sous forme de phrases) et en utilisant des mots clés comme : si, alors, tant que, sinon, ou, et, jusqu'à, etc. Un algorigramme ou un logigramme est un outil qui permet de représenter de manière graphique ( (Source: "(sous forme de phrases) et en utilisant des mots clés comme : si, alors, tant que, sinon, ou, et, jusqu'à, etc. Un algorigramme ou un logigramme est un outil qui permet de représenter de manière graphique (et donc de manière plus lisible) un algorithme. Pour concevoir un logigramme, il faut impérativement utilisé les symboles")
4. Détail source à réviser : est un outil qui permet de représenter de manière graphique (et donc de manière plus lisible) un algorithme. Pour concevoir un logigramme, il faut impérativement utilisé les symboles normalisés suivants : [Schéma symbo (Source: "est un outil qui permet de représenter de manière graphique (et donc de manière plus lisible) un algorithme. Pour concevoir un logigramme, il faut impérativement utilisé les symboles normalisés suivants : [Schéma symboles logigramme : Début (ovale) Evènement ? (losange) avec flèches OUI et NON Action (rectangle)] Un programme est la traduction")
5. Détail source à réviser : utilisé les symboles normalisés suivants : [Schéma symboles logigramme : Début (ovale) Evènement ? (losange) avec flèches OUI et NON Action (rectangle)] Un programme est la traduction d'un algorithme ou d'un logigram (Source: "utilisé les symboles normalisés suivants : [Schéma symboles logigramme : Début (ovale) Evènement ? (losange) avec flèches OUI et NON Action (rectangle)] Un programme est la traduction d'un algorithme ou d'un logigramme à l'aide d'un langage de programmation. Une fois le programme écrit, celui-ci devra être converti/compilé en langage machine")
6. Détail source à réviser : Un programme est la traduction d'un algorithme ou d'un logigramme à l'aide d'un langage de programmation. Une fois le programme écrit, celui-ci devra être converti/compilé en langage machine (code binaire) afin d'ê (Source: "Un programme est la traduction d'un algorithme ou d'un logigramme à l'aide d'un langage de programmation. Une fois le programme écrit, celui-ci devra être converti/compilé en langage machine (code binaire) afin d'être transféré puis exécuté par le microprocesseur du système informatique ou du système automatique. Les langages de programmation se")
7. Détail source à réviser : converti/compilé en langage machine (code binaire) afin d'être transféré puis exécuté par le microprocesseur du système informatique ou du système automatique. Les langages de programmation se décomposent en 2 catégori (Source: "converti/compilé en langage machine (code binaire) afin d'être transféré puis exécuté par le microprocesseur du système informatique ou du système automatique. Les langages de programmation se décomposent en 2 catégories : - la programmation par blocs (ou briques) : Scratch, Blockly, Ardublock, Mblock, Millenium … ; - la programmation par lignes de")
8. Détail source à réviser : Les langages de programmation se décomposent en 2 catégories : - la programmation par blocs (ou briques) : Scratch, Blockly, Ardublock, Mblock, Millenium … ; - la programmation par lignes de codes : Delphi, Python, C, (Source: "Les langages de programmation se décomposent en 2 catégories : - la programmation par blocs (ou briques) : Scratch, Blockly, Ardublock, Mblock, Millenium … ; - la programmation par lignes de codes : Delphi, Python, C, Basic …. II. La méthodologie à suivre Pour résoudre un problème d'automatisme, il est nécessaire de : Etape N°1 : Ecrire")
9. Détail source à réviser : ; - la programmation par lignes de codes : Delphi, Python, C, Basic …. II. La méthodologie à suivre Pour résoudre un problème d'automatisme, il est nécessaire de : Etape N°1 : Ecrire l'algorithme (*sur une feuille de (Source: "; - la programmation par lignes de codes : Delphi, Python, C, Basic …. II. La méthodologie à suivre Pour résoudre un problème d'automatisme, il est nécessaire de : Etape N°1 : Ecrire l'algorithme (sur une feuille de papier libre). Etape N°2 : Représenter manuellement ou numériquement cet algorithme en logigramme. Etape N°3 : Choisir le")
10. Détail source à réviser : : Etape N°1 : Ecrire l'algorithme (sur une feuille de papier libre). Etape N°2 : Représenter manuellement ou numériquement cet algorithme en logigramme. Etape N°3 : Choisir le langage/logiciel de programmat (Source: ": Etape N°1 : Ecrire l'algorithme (sur une feuille de papier libre). Etape N°2 : Représenter manuellement ou numériquement cet algorithme en logigramme. Etape N°3 : Choisir le langage/logiciel de programmation le plus approprié (*en fonction du niveau de compatibilité avec le système ou le microprocesseur et de son propre niveau de")
11. Détail source à réviser : Etape N°3 : Choisir le langage/logiciel de programmation le plus approprié (en fonction du niveau de compatibilité avec le système ou le microprocesseur et de son propre niveau de pratique/maîtrise). Etape N°4 (Source: "Etape N°3 : Choisir le langage/logiciel de programmation le plus approprié (en fonction du niveau de compatibilité avec le système ou le microprocesseur et de son propre niveau de pratique/maîtrise). Etape N°4 : Traduire le logigramme en programme à l'aide du langage/logiciel de programmation choisi. Etape N°5 : Compiler/convertir en")
12. Détail source à réviser : et de son propre niveau de pratique/maîtrise*). Etape N°4 : Traduire le logigramme en programme à l'aide du langage/logiciel de programmation choisi. Etape N°5 : Compiler/convertir en langage machine le programme (Source: "et de son propre niveau de pratique/maîtrise*). Etape N°4 : Traduire le logigramme en programme à l'aide du langage/logiciel de programmation choisi. Etape N°5 : Compiler/convertir en langage machine le programme (*opération qui s'effectue la plupart du temps automatiquement et de manière totalement "invisible" lors du transfert dans le")
13. Détail source à réviser : N°5** : Compiler/convertir en langage machine le programme (opération qui s'effectue la plupart du temps automatiquement et de manière totalement "invisible" lors du transfert dans le microprocesseur). III. Des exemple (Source: "N°5** : Compiler/convertir en langage machine le programme (opération qui s'effectue la plupart du temps automatiquement et de manière totalement "invisible" lors du transfert dans le microprocesseur). III. Des exemples concrets | Un algorithme (alarme anti-intrusion) | Un logigramme (barrière automatique) | Un programme Scratch (jeu de")
14. Détail source à réviser : lors du transfert dans le microprocesseur*). III. Des exemples concrets | Un algorithme (alarme anti-intrusion) | Un logigramme (barrière automatique) | Un programme Scratch (jeu de multiplication) | Un programme en lang (Source: "lors du transfert dans le microprocesseur*). III. Des exemples concrets | Un algorithme (alarme anti-intrusion) | Un logigramme (barrière automatique) | Un programme Scratch (jeu de multiplication) | Un programme en langage machine |")
15. Détail source à réviser : Scratch avec instructions de multiplication aléatoire, demande de résultat, condition si réponse correcte ou non, dire "Gagné !" ou "Perdu, la réponse était :"] | [Code hexadécimal en colonnes avec adresses et valeurs] | (Source: "Scratch avec instructions de multiplication aléatoire, demande de résultat, condition si réponse correcte ou non, dire "Gagné !" ou "Perdu, la réponse était :"] | [Code hexadécimal en colonnes avec adresses et valeurs] | --- Page 2 --- Problème N°2 : Permettre à un système mobile d'éviter/contourner un obstacle | Le système mobile | L'algorithme |")
16. Détail source à réviser : :"] | [Code hexadécimal en colonnes avec adresses et valeurs] | --- Page 2 --- Problème N°2 : Permettre à un système mobile d'éviter/contourner un obstacle | Le système mobile | L'algorithme | Le logigramme | Le prog (Source: ":"] | [Code hexadécimal en colonnes avec adresses et valeurs] | --- Page 2 --- Problème N°2 : Permettre à un système mobile d'éviter/contourner un obstacle | Le système mobile | L'algorithme | Le logigramme | Le programme (Scratch) | |-------------------|--------------|---------------|-----------------------| | [Photo d'un robot sur un passage piéton]")
17. Détail source à réviser : | Le système mobile | L'algorithme | Le logigramme | Le programme (Scratch) | |-------------------|--------------|---------------|-----------------------| | [Photo d'un robot sur un passage piéton] | Si le robot détecte (Source: "| Le système mobile | L'algorithme | Le logigramme | Le programme (Scratch) | |-------------------|--------------|---------------|-----------------------| | [Photo d'un robot sur un passage piéton] | Si le robot détecte un obstacle, alors tourner à droite de 90°, avancer de 10 cm puis tourner à gauche de 90°. Sinon avancer indéfiniment. | [Logigramme")
18. Détail source à réviser : d'un robot sur un passage piéton] | Si le robot détecte un obstacle, alors tourner à droite de 90°, avancer de 10 cm puis tourner à gauche de 90°. Sinon avancer indéfiniment. | [Logigramme avec décisions "Présence d' (Source: "d'un robot sur un passage piéton] | Si le robot détecte un obstacle, alors tourner à droite de 90°, avancer de 10 cm puis tourner à gauche de 90°. Sinon avancer indéfiniment. | [Logigramme avec décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch")
19. Détail source à réviser : avancer indéfiniment. | [Logigramme avec décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "atten (Source: "avancer indéfiniment. | [Logigramme avec décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesurée par le capteur", conditions sur distance, commandes avancer,")
20. Détail source à réviser : "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesurée par le capteur", conditions sur distance, commandes avancer, tourner, etc.] | **Problèm (Source: ""Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesurée par le capteur", conditions sur distance, commandes avancer, tourner, etc.] | Problème N°3 : Gérer automatiquement l'éclairage d'une pièce | L'algorithme | Le logigramme | Le programme (Millenium) |")
21. Détail source à réviser : sur distance, commandes avancer, tourner, etc.] | Problème N°3 : Gérer automatiquement l'éclairage d'une pièce | L'algorithme | Le logigramme | Le programme (Millenium) | |--------------|---------------|------------- (Source: "sur distance, commandes avancer, tourner, etc.] | Problème N°3 : Gérer automatiquement l'éclairage d'une pièce | L'algorithme | Le logigramme | Le programme (Millenium) | |--------------|---------------|-------------------------| | Si le bouton marche/arrêt est enclenché alors allumer l’éclairage. Sinon si le capteur de luminosité détecte qu’il fait")
22. Détail source à réviser : (Millenium) | |--------------|---------------|-------------------------| | Si le bouton marche/arrêt est enclenché alors allumer l’éclairage. Sinon si le capteur de luminosité détecte qu’il fait nuit et le capteu (Source: "(Millenium) | |--------------|---------------|-------------------------| | Si le bouton marche/arrêt est enclenché alors allumer l’éclairage. Sinon si le capteur de luminosité détecte qu’il fait nuit et le capteur de présence est activé alors allumer l’éclairage, attendre 30 s. puis éteindre l’éclairage. Sinon éteindre l’éclairage. |")
23. Détail source à réviser : de luminosité détecte qu’il fait nuit et le capteur de présence est activé alors allumer l’éclairage, attendre 30 s. puis éteindre l’éclairage. Sinon éteindre l’éclairage. | [Logigramme avec décisions "Ma (Source: "de luminosité détecte qu’il fait nuit et le capteur de présence est activé alors allumer l’éclairage, attendre 30 s. puis éteindre l’éclairage. Sinon éteindre l’éclairage. | [Logigramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre")
24. Détail source à réviser : Sinon éteindre l’éclairage. | [Logigramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique (Source: "Sinon éteindre l’éclairage. | [Logigramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, et sortie éclairage] | --- Page 3 --- I. Les définitions à savoir Une séquence d'instructions")
25. Détail source à réviser : 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, et sortie éclairage] | --- Page 3 --- I. Les définitions à savoir Une séquence d'instructions est une suite de command (Source: "30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, et sortie éclairage] | --- Page 3 --- I. Les définitions à savoir Une séquence d'instructions est une suite de commandes ou d'actions qui seront exécutées les unes à la suite des autres sans conditions préalables et en général une seule fois. Une")
26. Détail source à réviser : savoir Une séquence d'instructions est une suite de commandes ou d'actions qui seront exécutées les unes à la suite des autres sans conditions préalables et en général une seule fois. Une boucle permet de répéter (Source: "savoir Une séquence d'instructions est une suite de commandes ou d'actions qui seront exécutées les unes à la suite des autres sans conditions préalables et en général une seule fois. Une boucle permet de répéter une instruction ou une séquence d'instruction indéfiniment, un certain nombre de fois ou en fonction d'une condition (*Répéter…")
27. Détail source à réviser : en général une seule fois. Une boucle permet de répéter une instruction ou une séquence d'instruction indéfiniment, un certain nombre de fois ou en fonction d'une condition (*Répéter… indéfiniment / Répéter… jusqu’à… (Source: "en général une seule fois. Une boucle permet de répéter une instruction ou une séquence d'instruction indéfiniment, un certain nombre de fois ou en fonction d'une condition (Répéter… indéfiniment / Répéter… jusqu’à… / Répéter… tant que…). Remarque : Il est possible d'imbriquer plusieurs boucles les unes dans les autres. Une **instruction")
28. Détail source à réviser : d'une condition (Répéter… indéfiniment / Répéter… jusqu’à… / Répéter… tant que…). Remarque : Il est possible d'imbriquer plusieurs boucles les unes dans les autres. Une instruction conditionnelle est une instruct (Source: "d'une condition (Répéter… indéfiniment / Répéter… jusqu’à… / Répéter… tant que…). Remarque : Il est possible d'imbriquer plusieurs boucles les unes dans les autres. Une instruction conditionnelle est une instruction dont l'exécution est soumise à une condition ou à l'apparition d'un évènement extérieur (Si… alors… / Si… alors… sinon…).")
29. Détail source à réviser : autres. Une instruction conditionnelle est une instruction dont l'exécution est soumise à une condition ou à l'apparition d'un évènement extérieur (Si… alors… / Si… alors… sinon…). Remarque : Il est possible de m (Source: "autres. Une instruction conditionnelle est une instruction dont l'exécution est soumise à une condition ou à l'apparition d'un évènement extérieur (Si… alors… / Si… alors… sinon…). Remarque : Il est possible de mettre plusieurs instructions conditionnelles les unes derrière les autres (en cascade). Une variable est une case mémoire qui permet")
30. Détail source à réviser : / Si… alors… sinon…). Remarque : Il est possible de mettre plusieurs instructions conditionnelles les unes derrière les autres (en cascade). Une variable est une case mémoire qui permet de stocker une donnée. Elle _(Source: "/ Si… alors… sinon…). Remarque : Il est possible de mettre plusieurs instructions conditionnelles les unes derrière les autres (en cascade). Une variable est une case mémoire qui permet de stocker une donnée. Elle peut contenir une valeur numérique (nombre) ou une chaîne de caractères (texte). Elle peut être fixe ou varier dans le temps")_
31. Détail source à réviser : est une case mémoire qui permet de stocker une donnée. Elle peut contenir une valeur numérique (nombre) ou une chaîne de caractères (texte). Elle peut être fixe ou varier dans le temps lors de l'exécution du programm (Source: "est une case mémoire qui permet de stocker une donnée. Elle peut contenir une valeur numérique (nombre) ou une chaîne de caractères (texte). Elle peut être fixe ou varier dans le temps lors de l'exécution du programme. Remarque : Il est possible d'utiliser des variables aussi bien dans une séquence d'instructions, dans une boucle ou dans une")
32. Détail source à réviser : être fixe ou varier dans le temps lors de l'exécution du programme. Remarque : Il est possible d'utiliser des variables aussi bien dans une séquence d'instructions, dans une boucle ou dans une instruction conditionnell (Source: "être fixe ou varier dans le temps lors de l'exécution du programme. Remarque : Il est possible d'utiliser des variables aussi bien dans une séquence d'instructions, dans une boucle ou dans une instruction conditionnelle. II. Des exemples concrets (sur le logiciel Picaxe Editor) | Les différentes boucles | |------------------------| | [Bloc "répéter")
33. Détail source à réviser : dans une boucle ou dans une instruction conditionnelle. II. Des exemples concrets (sur le logiciel Picaxe Editor) | Les différentes boucles | |------------------------| | [Bloc "répéter indéfiniment faire"] [Bloc "répé (Source: "dans une boucle ou dans une instruction conditionnelle. II. Des exemples concrets (sur le logiciel Picaxe Editor) | Les différentes boucles | |------------------------| | [Bloc "répéter indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C.1 est activée"] | | [Bloc "répéter jusqu'à varA > 10"] [Bloc "tant que l'entrée C.1 est activée")
34. Détail source à réviser : | [Bloc "répéter indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C.1 est activée"] | | [Bloc "répéter jusqu'à varA > 10"] [Bloc "tant que l'entrée C.1 est activée faire"] | | Les variables | |--------------| (Source: "| [Bloc "répéter indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C.1 est activée"] | | [Bloc "répéter jusqu'à varA > 10"] [Bloc "tant que l'entrée C.1 est activée faire"] | | Les variables | |--------------| | [Bloc varA] [Bloc varA , varB] | | Les différentes instructions conditionnelles | |--------------------------------| |")
35. Détail source à réviser : que l'entrée C.1 est activée faire"] | | Les variables | |--------------| | [Bloc varA] [Bloc varA , varB] | | Les différentes instructions conditionnelles | |--------------------------------| | [Bloc "si l'entrée C.1 es (Source: "que l'entrée C.1 est activée faire"] | | Les variables | |--------------| | [Bloc varA] [Bloc varA , varB] | | Les différentes instructions conditionnelles | |--------------------------------| | [Bloc "si l'entrée C.1 est activée faire"] [Bloc "si l'entrée C.1 est activée faire sinon"] | --- Page 4 --- | Avancer en ligne droite pendant 3 secondes,")
36. Détail source à réviser : | |--------------------------------| | [Bloc "si l'entrée C.1 est activée faire"] [Bloc "si l'entrée C.1 est activée faire sinon"] | --- Page 4 --- | Avancer en ligne droite pendant 3 secondes, demi-tour sur lui-même pui (Source: "| |--------------------------------| | [Bloc "si l'entrée C.1 est activée faire"] [Bloc "si l'entrée C.1 est activée faire sinon"] | --- Page 4 --- | Avancer en ligne droite pendant 3 secondes, demi-tour sur lui-même puis avancer de nouveau en ligne droite pendant 3 secondes. | Avancer en ligne droite en non-stop. | Faire avancer le robot Picaxe en")
37. Détail source à réviser : ligne droite pendant 3 secondes, demi-tour sur lui-même puis avancer de nouveau en ligne droite pendant 3 secondes. | Avancer en ligne droite en non-stop. | Faire avancer le robot Picaxe en aller-retour avec demi-tour lo (Source: "ligne droite pendant 3 secondes, demi-tour sur lui-même puis avancer de nouveau en ligne droite pendant 3 secondes. | Avancer en ligne droite en non-stop. | Faire avancer le robot Picaxe en aller-retour avec demi-tour lors de la détection d'une ligne noire |")
38. Détail source à réviser : avancer le robot Picaxe en aller-retour avec demi-tour lors de la détection d'une ligne noire | |---------------------------------|-------------------------------|--------------------------------------------------------- (Source: "avancer le robot Picaxe en aller-retour avec demi-tour lors de la détection d'une ligne noire | |---------------------------------|-------------------------------|-------------------------------------------------------------| | [Image bloc code Picaxe avec temporisations et sorties activées/désactivées] | [Bloc "répéter indéfiniment faire sortie C.1")
39. Détail source à réviser : -------|-------------------------------------------------------------| | [Image bloc code Picaxe avec temporisations et sorties activées/désactivées] | [Bloc "répéter indéfiniment faire sortie C.1 activée sortie C.2 acti (Source: "-------|-------------------------------------------------------------| | [Image bloc code Picaxe avec temporisations et sorties activées/désactivées] | [Bloc "répéter indéfiniment faire sortie C.1 activée sortie C.2 activée"] | [Bloc "répéter sortie C.1 activée sortie C.2 activée jusqu'à ce que l'entrée C.3 est désactivée"] | | Séquence d'instructions |")
40. Détail source à réviser : indéfiniment faire sortie C.1 activée sortie C.2 activée"] | [Bloc "répéter sortie C.1 activée sortie C.2 activée jusqu'à ce que l'entrée C.3 est désactivée"] | | Séquence d'instructions | Boucle Répéter… indéfiniment | (Source: "indéfiniment faire sortie C.1 activée sortie C.2 activée"] | [Bloc "répéter sortie C.1 activée sortie C.2 activée jusqu'à ce que l'entrée C.3 est désactivée"] | | Séquence d'instructions | Boucle Répéter… indéfiniment | Boucle Répéter… jusqu'à… | |-------------------------|------------------------------|---------------------------| Faire avancer le")
41. Détail source à réviser : | | Séquence d'instructions | Boucle Répéter… indéfiniment | Boucle Répéter… jusqu'à… | |-------------------------|------------------------------|---------------------------| Faire avancer le robot Picaxe en suivi de lig (Source: "| | Séquence d'instructions | Boucle Répéter… indéfiniment | Boucle Répéter… jusqu'à… | |-------------------------|------------------------------|---------------------------| Faire avancer le robot Picaxe en suivi de ligne noire avec arrêt en cas de rupture de ligne. | Faire avancer le robot Picaxe en ligne droite avec arrêt après détection de 5 lignes")
42. Détail source à réviser : Faire avancer le robot Picaxe en suivi de ligne noire avec arrêt en cas de rupture de ligne. | Faire avancer le robot Picaxe en ligne droite avec arrêt après détection de 5 lignes noires. | |----------------------------- (Source: "Faire avancer le robot Picaxe en suivi de ligne noire avec arrêt en cas de rupture de ligne. | Faire avancer le robot Picaxe en ligne droite avec arrêt après détection de 5 lignes noires. | |---------------------------------|---------------------------------------------| | [Bloc code Picaxe avec conditions en cascade "Si… alors… sinon…"]")
43. Détail source à réviser : avec arrêt après détection de 5 lignes noires. | |---------------------------------|---------------------------------------------| | [Bloc code Picaxe avec conditions en cascade "Si… alors… sinon…"] | [Bloc code Picaxe a (Source: "avec arrêt après détection de 5 lignes noires. | |---------------------------------|---------------------------------------------| | [Bloc code Picaxe avec conditions en cascade "Si… alors… sinon…"] | [Bloc code Picaxe avec variable de comptage varA initialisée à 0, boucle répétée, incrémentation varA, arrêt à varA = 5] | | Instructions conditionnelles en")
44. Détail source à réviser : ---------------------------------|---------------------------------------------| | [Bloc code Picaxe avec conditions en cascade "Si… alors… sinon…"] | [Bloc code Picaxe avec variable de comptage varA initialisée à 0, bou (Source: "---------------------------------|---------------------------------------------| | [Bloc code Picaxe avec conditions en cascade "Si… alors… sinon…"] | [Bloc code Picaxe avec variable de comptage varA initialisée à 0, boucle répétée, incrémentation varA, arrêt à varA = 5] | | Instructions conditionnelles en cascade Si… alors… sinon… | Variable (de comptage)")
45. Détail source à réviser : I. Les définitions à savoir Un algorithme est une suite logique d'actions ou d'instructions à réaliser qui permet de décrire la manière dont un problème sera résolu (Source: "I. Les définitions à savoir Un algorithme est une suite logique d'actions ou d'instructions à réaliser qui permet de décrire la manière dont un problème sera résolu")
46. Détail source à réviser : Pour concevoir un logigramme, il faut impérativement utilisé les symboles normalisés suivants : [Schéma symboles logigramme : Début (ovale) Evènement ? (losange) avec flèches OUI et NON Action (rectangle)] Un **programme (Source: "Pour concevoir un logigramme, il faut impérativement utilisé les symboles normalisés suivants : [Schéma symboles logigramme : Début (ovale) Evènement ? (losange) avec flèches OUI et NON Action (rectangle)] Un programme est la traduction d'un algorithme ou d'un logigramme à l'")
47. Détail source à réviser : ogramme** est la traduction d'un algorithme ou d'un logigramme à l'aide d'un langage de programmation. (Source: "ogramme** est la traduction d'un algorithme ou d'un logigramme à l'aide d'un langage de programmation.")
48. Détail source à réviser : II. La méthodologie à suivre Pour résoudre un problème d'automatisme, il est nécessaire de : Etape N°1 : Ecrire l'algorithme (sur une feuille de papier libre) (Source: "II. La méthodologie à suivre Pour résoudre un problème d'automatisme, il est nécessaire de : Etape N°1 : Ecrire l'algorithme (sur une feuille de papier libre)")
49. Détail source à réviser : Etape N°2 : Représenter manuellement ou numériquement cet algorithme en logigramme (Source: "Etape N°2 : Représenter manuellement ou numériquement cet algorithme en logigramme")
50. Détail source à réviser : Etape N°4 : Traduire le logigramme en programme à l'aide du langage/logiciel de programmation choisi (Source: "Etape N°4 : Traduire le logigramme en programme à l'aide du langage/logiciel de programmation choisi")
51. Détail source à réviser : III. Des exemples concrets | Un algorithme (alarme anti-intrusion) | Un logigramme (barrière automatique) | Un programme Scratch (jeu de multiplication) | Un programme en langage machine | |------------------------------ (Source: "III. Des exemples concrets | Un algorithme (alarme anti-intrusion) | Un logigramme (barrière automatique) | Un programme Scratch (jeu de multiplication) | Un programme en langage machine | |---------------------------------------|-------------------------------------|----------------------------------------------|---------------------------------| | *Text...")
52. Détail source à réviser : n si réponse correcte ou non, dire "Gagné !" ou "Perdu, la réponse était :"] | [Code hexadécimal en colonnes avec adresses et valeurs] | --- Page 2 --- Problème N°2 : Permettre à un système mobile (Source: "n si réponse correcte ou non, dire "Gagné !" ou "Perdu, la réponse était :"] | [Code hexadécimal en colonnes avec adresses et valeurs] | --- Page 2 --- Problème N°2 : Permettre à un système mobile")
53. Détail source à réviser : n aléatoire, demande de résultat, condition si réponse correcte ou non, dire "Gagné !" ou "Perdu, la réponse était :"] | [Code hexadécimal en colonnes avec adresses et valeurs] | --- Page 2 --- Problème N°2 : Permett (Source: "n aléatoire, demande de résultat, condition si réponse correcte ou non, dire "Gagné !" ou "Perdu, la réponse était :"] | [Code hexadécimal en colonnes avec adresses et valeurs] | --- Page 2 --- Problème N°2 : Permettre à un système mobile d'éviter/contourner un obstacle |")
54. Détail source à réviser : cm puis tourner à gauche de 90°. Sinon avancer indéfiniment. | [Logigramme avec décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | (Source: "cm puis tourner à gauche de 90°. Sinon avancer indéfiniment. | [Logigramme avec décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le")
55. Détail source à réviser : 0 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesurée par le capteur", conditions sur distance, commandes a (Source: "0 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesurée par le capteur", conditions sur distance, commandes avancer, tourner, etc.] | Problème N°3 : Gérer automatiquement l'é")
56. Détail source à réviser : t l'éclairage d'une pièce | L'algorithme | Le logigramme | Le programme (Millenium) | |--------------|---------------|-------------------------| | Si le bouton marche/arrêt est enclenché alors allumer l’éclairage. (Source: "t l'éclairage d'une pièce | L'algorithme | Le logigramme | Le programme (Millenium) | |--------------|---------------|-------------------------| | Si le bouton marche/arrêt est enclenché alors allumer l’éclairage.")
57. Détail source à réviser : igramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, (Source: "igramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, et sortie éclairage] | --- Page 3 --- I. Les défin")
58. Détail source à réviser : I. Les définitions à savoir Une séquence d'instructions est une suite de commandes ou d'actions qui seront exécutées les unes à la suite des autres sans conditions préalables et en général une seule fois (Source: "I. Les définitions à savoir Une séquence d'instructions est une suite de commandes ou d'actions qui seront exécutées les unes à la suite des autres sans conditions préalables et en général une seule fois")
59. Détail source à réviser : . Une instruction conditionnelle est une instruction dont l'exécution est soumise à une condition ou à l'apparition d'un évènement extérieur (Si… alors… / Si… alors… sinon…). Remarque : Il est possible de (Source: ". Une instruction conditionnelle est une instruction dont l'exécution est soumise à une condition ou à l'apparition d'un évènement extérieur (Si… alors… / Si… alors… sinon…). Remarque : Il est possible de")
60. Détail source à réviser : Remarque : Il est possible de mettre plusieurs instructions conditionnelles les unes derrière les autres (en cascade) (Source: "Remarque : Il est possible de mettre plusieurs instructions conditionnelles les unes derrière les autres (en cascade)")
61. Détail source à réviser : II. Des exemples concrets (sur le logiciel Picaxe Editor) | Les différentes boucles | |------------------------| | [Bloc "répéter indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C (Source: "II. Des exemples concrets (sur le logiciel Picaxe Editor) | Les différentes boucles | |------------------------| | [Bloc "répéter indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C")
62. Détail source à réviser : e logiciel Picaxe Editor*) | Les différentes boucles | |------------------------| | [Bloc "répéter indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C.1 est activée"] | | [Bloc "répéter jusqu'à varA > 10"] [Blo (Source: "e logiciel Picaxe Editor*) | Les différentes boucles | |------------------------| | [Bloc "répéter indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C.1 est activée"] | | [Bloc "répéter jusqu'à varA > 10"] [Bloc "tant que l'entrée C.1 est activée faire"] | | Les varia")
63. Détail source à réviser : Les différentes instructions conditionnelles | |--------------------------------| | [Bloc "si l'entrée C.1 est activée faire"] [Bloc "si l'entrée C.1 est activée faire sinon"] | --- Page 4 --- | Avancer en ligne droite p (Source: "Les différentes instructions conditionnelles | |--------------------------------| | [Bloc "si l'entrée C.1 est activée faire"] [Bloc "si l'entrée C.1 est activée faire sinon"] | --- Page 4 --- | Avancer en ligne droite pendant 3 secondes, demi-tour sur lui-même puis avancer de nouveau")
64. Détail source à réviser : | Faire avancer le robot Picaxe en aller-retour avec demi-tour lors de la détection d'une ligne noire | |---------------------------------|-------------------------------|------------------------------------------------- (Source: "| Faire avancer le robot Picaxe en aller-retour avec demi-tour lors de la détection d'une ligne noire | |---------------------------------|-------------------------------|-------------------------------------------------------------| | [Image bloc code Picaxe avec temporisations et sorties activées/désactivées] | [Bloc "répéter indéfiniment faire sortie C")
65. Détail source à réviser : -| | [Image bloc code Picaxe avec temporisations et sorties activées/désactivées] | [Bloc "répéter indéfiniment faire sortie C.1 activée sortie C.2 activée"] | [Bloc "répéter sortie C.1 activée sortie C.2 activée jusqu'à (Source: "-| | [Image bloc code Picaxe avec temporisations et sorties activées/désactivées] | [Bloc "répéter indéfiniment faire sortie C.1 activée sortie C.2 activée"] | [Bloc "répéter sortie C.1 activée sortie C.2 activée jusqu'à ce que l'entrée C.3 est désactivée"] | | Séquence d'instructions | Boucle Répéter… indéfiniment")
66. Détail source à réviser : | |---------------------------------|---------------------------------------------| | [Bloc code Picaxe avec conditions en cascade "Si… alors… sinon…"] | [Bloc code Picaxe avec variable de comptage varA initialisée à 0, (Source: "| |---------------------------------|---------------------------------------------| | [Bloc code Picaxe avec conditions en cascade "Si… alors… sinon…"] | [Bloc code Picaxe avec variable de comptage varA initialisée à 0, boucle répétée, incrémentation varA, arrêt à varA = 5] | | Instructions conditionnelles en cascade Si… alors… sinon… | Variable (de compt...")
67. Détail source à réviser : -----------------------------------------| | [Bloc code Picaxe avec conditions en cascade "Si… alors… sinon…"] | [Bloc code Picaxe avec variable de comptage varA initialisée à 0, boucle répétée, incrémentation varA, arrê (Source: "-----------------------------------------| | [Bloc code Picaxe avec conditions en cascade "Si… alors… sinon…"] | [Bloc code Picaxe avec variable de comptage varA initialisée à 0, boucle répétée, incrémentation varA, arrêt à varA = 5] | | Instructions conditionnelles en")
68. Détail source à réviser : "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, et sortie éclairage] | (Source: ""Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, et sortie éclairage] | --- Page 3 --- I. Les définitions à savoir Une **sé")
69. Détail source à réviser : "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, et sortie éclairage] | --- Page 3 --- I. Les dé (Source: ""Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, et sortie éclairage] | --- Page 3 --- I. Les définitions à savoir Une séquence d'instructions")
70. Détail source à réviser : vées] | [Bloc "répéter indéfiniment faire sortie C.1 activée sortie C.2 activée"] | [Bloc "répéter sortie C.1 activée sortie C.2 activée jusqu'à ce que l'entrée C.3 est désactivée"] | | Séquence d'instructions | Boucle R (Source: "vées] | [Bloc "répéter indéfiniment faire sortie C.1 activée sortie C.2 activée"] | [Bloc "répéter sortie C.1 activée sortie C.2 activée jusqu'à ce que l'entrée C.3 est désactivée"] | | Séquence d'instructions | Boucle Répéter… indéfiniment | Boucle Répéter… jusqu'à… | |-------------------------|------------------------------|------------")
71. Détail source à réviser : Logigramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, rela (Source: "Logigramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, et sortie éclairage] | --- Page 3 --- I. Les définitions")
72. Détail source à réviser : e (opération qui s'effectue la plupart du temps automatiquement et de manière totalement "invisible" lors du transfert dans le microprocesseur). III. Des exemples concrets | Un algorithme (alarme anti-intrusion) | Un l (Source: "e (opération qui s'effectue la plupart du temps automatiquement et de manière totalement "invisible" lors du transfert dans le microprocesseur). III. Des exemples concrets | Un algorithme (alarme anti-intrusion) | Un logigramme (barrière automatique) | Un pro")
73. Détail source à réviser : r en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesurée par le capteur", conditions sur distance, commandes avancer, tourner, etc.] | Problème N°3 (Source: "r en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesurée par le capteur", conditions sur distance, commandes avancer, tourner, etc.] | Problème N°3 : Gérer automatiquement l'éclairage d'une pièce | L'algorithme | Le logigramme |")
74. Détail source à réviser : férentes boucles | |------------------------| | [Bloc "répéter indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C.1 est activée"] | | [Bloc "répéter jusqu'à varA > 10"] [Bloc "tant que l'entrée C.1 est activée (Source: "férentes boucles | |------------------------| | [Bloc "répéter indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C.1 est activée"] | | [Bloc "répéter jusqu'à varA > 10"] [Bloc "tant que l'entrée C.1 est activée faire"] | | Les variables | |--------------| | [Bloc varA] [Bloc varA , varB]")
75. Détail source à réviser : r indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C.1 est activée"] | | [Bloc "répéter jusqu'à varA > 10"] [Bloc "tant que l'entrée C.1 est activée faire"] | | Les variables | |--------------| | [Bloc varA] [ (Source: "r indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C.1 est activée"] | | [Bloc "répéter jusqu'à varA > 10"] [Bloc "tant que l'entrée C.1 est activée faire"] | | Les variables | |--------------| | [Bloc varA] [Bloc varA , varB] | | Les différentes instructions condit")
76. Détail source à réviser : er jusqu'à ce que l'entrée C.1 est activée"] | | [Bloc "répéter jusqu'à varA > 10"] [Bloc "tant que l'entrée C.1 est activée faire"] | | Les variables | |--------------| | [Bloc varA] [Bloc varA , varB] | | Les différent (Source: "er jusqu'à ce que l'entrée C.1 est activée"] | | [Bloc "répéter jusqu'à varA > 10"] [Bloc "tant que l'entrée C.1 est activée faire"] | | Les variables | |--------------| | [Bloc varA] [Bloc varA , varB] | | Les différentes instructions conditionnelles | |--------------------------------| |")
77. Détail source à réviser : s | |--------------------------------| | [Bloc "si l'entrée C.1 est activée faire"] [Bloc "si l'entrée C.1 est activée faire sinon"] | --- Page 4 --- | Avancer en ligne droite pendant 3 secondes, demi-tour sur lui-même p (Source: "s | |--------------------------------| | [Bloc "si l'entrée C.1 est activée faire"] [Bloc "si l'entrée C.1 est activée faire sinon"] | --- Page 4 --- | Avancer en ligne droite pendant 3 secondes, demi-tour sur lui-même puis avancer de nouveau en ligne droite pendant 3 secondes. | Avancer en")
78. Détail source à réviser : Sinon avancer indéfiniment. | [Logigramme avec décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions (Source: "Sinon avancer indéfiniment. | [Logigramme avec décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distan")
79. Détail source à réviser : | [Logigramme avec décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton (Source: "| [Logigramme avec décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesuré")
80. Détail source à réviser : décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettr (Source: "décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesurée par le capteur", conditio")
81. Détail source à réviser : cle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesur (Source: "cle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesurée par le capteur", conditions sur distance, comma")
82. Détail source à réviser : is éteindre l’éclairage. Sinon éteindre l’éclairage. | [Logigramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’écla (Source: "is éteindre l’éclairage. Sinon éteindre l’éclairage. | [Logigramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisa")
83. Détail source à réviser : ge. Sinon éteindre l’éclairage. | [Logigramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électri (Source: "ge. Sinon éteindre l’éclairage. | [Logigramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, et so")
84. Détail source à réviser : ** l’éclairage. | [Logigramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, t (Source: "** l’éclairage. | [Logigramme avec décisions "Marche/arrêt activé ?", "Lumière faible ?", "Présence ?", actions "Allumer l’éclairage", "Attendre 30 secondes", "Eteindre l’éclairage"] | [Schéma électrique avec capteurs, temporisateurs, relais, et sortie éclairage")
85. Détail source à réviser : La méthodologie à suivre Pour résoudre un problème d'automatisme, il est nécessaire de : Etape N°1 : Ecrire l'algorithme (sur une feuille de papier libre) (Source: "La méthodologie à suivre Pour résoudre un problème d'automatisme, il est nécessaire de : Etape N°1 : Ecrire l'algorithme (sur une feuille de papier libre)")
86. Détail source à réviser : Etape N°5 : Compiler/convertir en langage machine le programme (opération qui s'effectue la plupart du temps automatiquement et de manière totalement "invisible" lors du transfert dans le microprocesseur) (Source: "Etape N°5 : Compiler/convertir en langage machine le programme (opération qui s'effectue la plupart du temps automatiquement et de manière totalement "invisible" lors du transfert dans le microprocesseur)")
87. Détail source à réviser : Remarque : Il est possible d'utiliser des variables aussi bien dans une séquence d'instructions, dans une boucle ou dans une instruction conditionnelle (Source: "Remarque : Il est possible d'utiliser des variables aussi bien dans une séquence d'instructions, dans une boucle ou dans une instruction conditionnelle")
88. Détail source à réviser : Des exemples concrets (sur le logiciel Picaxe Editor) | Les différentes boucles | |------------------------| | [Bloc "répéter indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C (Source: "Des exemples concrets (sur le logiciel Picaxe Editor) | Les différentes boucles | |------------------------| | [Bloc "répéter indéfiniment faire"] [Bloc "répéter jusqu'à ce que l'entrée C")
89. Détail source à réviser : Pour concevoir un logigramme, il faut impérativement utilisé les symboles normalisés suivants : [Schéma symboles logigramme : Début (ovale) Evènement (Source: "Pour concevoir un logigramme, il faut impérativement utilisé les symboles normalisés suivants : [Schéma symboles logigramme : Début (ovale) Evènement")
90. Détail source à réviser : Logigramme avec décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est (Source: "Logigramme avec décisions "Présence d'obstacle ?", actions "Tourner à droite de 90°", "Avancer de 10 cm", "Tourner à gauche de 90°", "Avancer en continu"] | [Bloc Scratch avec instructions "attendre jusqu'à le bouton est pressé", "mettre distance à distance mesurée par le capteur")
91. Détail source à réviser : Des exemples concrets | Un algorithme (alarme anti-intrusion) | Un logigramme (barrière automatique) | Un programme Scratch (jeu de multiplication) | Un programme en langage machine | |----------------------------------- (Source: "Des exemples concrets | Un algorithme (alarme anti-intrusion) | Un logigramme (barrière automatique) | Un programme Scratch (jeu de multiplication) | Un programme en langage machine | |---------------------------------------|-------------------------------------|----------------------------------------------|---------------------------------| | *Tex")
92. Détail source à réviser : us lisible*) un algorithme. Pour concevoir un logigramme, il faut impérativement utilisé les symboles normalisés suivants : [Schéma symboles logigramme : Début (ovale) Evènement ? (losange) avec flèches OUI et NON (Source: "us lisible*) un algorithme. Pour concevoir un logigramme, il faut impérativement utilisé les symboles normalisés suivants : [Schéma symboles logigramme : Début (ovale) Evènement ? (losange) avec flèches OUI et NON")
93. Détail source à réviser : er le robot Picaxe en aller-retour avec demi-tour lors de la détection d'une ligne noire | (Source: "er le robot Picaxe en aller-retour avec demi-tour lors de la détection d'une ligne noire |")
94. Détail source à réviser : Séquence d'instructions | Boucle Répéter… indéfiniment | Boucle Répéter… jusqu'à… | |-------------------------|------------------------------|---------------------------| Faire avancer le robot Picaxe en suivi de ligne (Source: "Séquence d'instructions | Boucle Répéter… indéfiniment | Boucle Répéter… jusqu'à… | |-------------------------|------------------------------|---------------------------| Faire avancer le robot Picaxe en suivi de ligne")
95. Détail source à réviser : cascade "Si… alors… sinon…"] | [Bloc code Picaxe avec variable de comptage varA initialisée à 0, boucle répétée, incrémentation varA, arrêt à varA = 5] | | Instructions conditionnelles en cascade Si… alors… sinon… | (Source: "cascade "Si… alors… sinon…"] | [Bloc code Picaxe avec variable de comptage varA initialisée à 0, boucle répétée, incrémentation varA, arrêt à varA = 5] | | Instructions conditionnelles en cascade Si… alors… sinon… |")
96. Détail source à réviser : s de rupture de ligne. | Faire avancer le robot Picaxe en ligne droite avec arrêt après détection de 5 lignes noires. | |---------------------------------|---------------------------------------------| | [Bloc code (Source: "s de rupture de ligne. | Faire avancer le robot Picaxe en ligne droite avec arrêt après détection de 5 lignes noires. | |---------------------------------|---------------------------------------------| | [Bloc code")

📊 Tableaux de Synthèse

Comparatif des langages de programmation

Langage	Utilisation principale	Niveau de difficulté
Python	Automatisation, scripts	Facile
C	Systèmes embarqués, logiciels	Moyen
Basic	Initiation	Facile
Delphi	Applications Windows	Moyen

⚠️ Pièges & Confusions Fréquentes

1. Confusion entre algorithme et programme.
2. Mélanger symboles logigramme ou logigramme avec diagrammes non normalisés.
3. Oublier de compiler ou convertir le programme en langage machine.
4. Utiliser des instructions conditionnelles sans gestion des cas alternatifs.
5. Confondre boucle infinie et boucle conditionnelle.
6. Ne pas respecter la normalisation des symboles pour le logigramme.
7. Mauvaise traduction de l'algorithme en logigramme ou programme.

✅ Checklist Examen

1. Savoir rédiger un algorithme en langage naturel.
2. Représenter un algorithme sous forme de logigramme normalisé.
3. Choisir le langage ou logiciel de programmation adapté.
4. Traduire un logigramme en programme informatique.
5. Compiler ou convertir le programme en langage machine.
6. Utiliser correctement les symboles normalisés du logigramme.
7. Programmer des boucles et conditions en environnement graphique.
8. Gérer des variables de comptage dans un programme.
9. Programmer un robot Picaxe avec séquences, boucles et conditions.
10. Utiliser des instructions conditionnelles en cascade.
11. Programmer la détection et le suivi de ligne pour un robot.