Revision 1.

3
Contents
Préface – “Rendre la vie plus facile” ....................................................................................................... 8
1. Introduction .................................................................................................................................... 9
1.1. La technologie actuelle ........................................................................................................... 9
1.2. Termes et technologies ......................................................................................................... 10
1.2.1. Algorigramme ............................................................................................................... 10
1.2.2. Code “C” ........................................................................................................................ 11
1.2.3. Microcontrôleur ............................................................................................................ 11
1.2.4. Arduino.......................................................................................................................... 12
1.2.5. Le schéma...................................................................................................................... 13
1.2.6. Proteus .......................................................................................................................... 13
1.3. Que contient ce livre ? .......................................................................................................... 13
2. Créer votre premier projet ........................................................................................................... 14
2.1. Prérequis ............................................................................................................................... 14
2.2. Créer un nouveau projet ....................................................................................................... 14
2.3. Se familiariser avec l’environnement Proteus ...................................................................... 18
2.3.1. Onglet de saisie du schéma........................................................................................... 18
2.3.2. Onglet Visual Designer .................................................................................................. 19
2.3.3. Les feuilles de l’algorigramme ...................................................................................... 19
2.3.4. Périphériques ................................................................................................................ 19
2.3.5. Naviguer dans le projet ................................................................................................. 20
2.4. Notions essentielles de la programmation par algorigramme ............................................. 21
2.4.1. Types de bloc d’algorigramme ...................................................................................... 21
2.4.2. Lignes de flux d’algorigramme ...................................................................................... 22
2.4.3. Routines Setup et Loop ................................................................................................. 23
2.5. Concevoir un algorigramme pour faire clignoter une LED.................................................... 23
2.5.1. Dessiner l’algorigramme ............................................................................................... 24
2.6. Lancer la simulation .............................................................................................................. 30
2.7. Informations complémentaires ............................................................................................ 32
2.7.1. Quelle LED faisons-nous clignoter ? .............................................................................. 32
2.7.2. Fenêtres “popups actives” ............................................................................................ 33
2.7.3. Edition de l’algorigramme ............................................................................................. 33
2.7.4. Téléverser le programme sur un hardware physique (Optionnel) ............................... 34
2.7.5. Ressources supplémentaires ........................................................................................ 36

2
 2.8. Challenges ............................................................................................................................. 36
3. Lire des entrées et prendre des décisions .................................................................................... 37
3.1. Introduction aux blocs de décisions...................................................................................... 37
3.2. Résumé du projet.................................................................................................................. 37
3.3. Débuter le projet................................................................................................................... 38
3.4. Ajouter des périphériques au projet..................................................................................... 38
3.5. Dessiner l’algorigramme ....................................................................................................... 40
3.6. Lancer la simulation .............................................................................................................. 42
3.7. Inverser la logique ................................................................................................................. 43
3.8. Informations complémentaires ............................................................................................ 44
3.8.1. Le système “Grove”....................................................................................................... 44
3.8.2. Modifier le numéro de connecteurs Grove dans Proteus ............................................ 45
4. Variables........................................................................................................................................ 47
4.1. Afficher du texte sur un LCD ................................................................................................. 47
4.2. Ajouter une variable dans le projet ...................................................................................... 52
4.3. Types des variables ............................................................................................................... 54
4.3.1. Opérations licites entre différents types de variables .................................................. 55
4.3.2. Sauvegarde d’une variable dans un ordinateur ............................................................ 55
4.4. Utiliser des variables dans un projet..................................................................................... 56
4.4.1. Opérations mathématiques sur une variable ............................................................... 57
4.4.2. Afficher la valeur d’une variable sur un LCD ................................................................. 58
4.4.3. Compléter l’algorigramme pour afficher une variable sur le LCD ................................ 58
4.5. Utiliser du texte dans les arguments .................................................................................... 59
4.6. Opérations mathématiques sur des variables ...................................................................... 59
4.7. Utiliser des variables dans des conditions ............................................................................ 60
4.8. Opérateurs relationnels ........................................................................................................ 62
4.9. Opérateurs logiques.............................................................................................................. 62
4.10. Etape finale du projet ....................................................................................................... 62
4.11. Le bouton Reset ................................................................................................................ 64
4.12. Prenez votre temps ........................................................................................................... 64
5. Théorie des circuits électriques basiques et simulation ............................................................... 65
5.1. L’environnement de saisie de schéma .................................................................................. 65
5.2. Circuit électrique simple ....................................................................................................... 67
5.3. Loi d’Ohm (tension, courant et résistance) .......................................................................... 68

3
 5.4. Mesures électriques.............................................................................................................. 71
5.5. Autres circuits ....................................................................................................................... 71
6. Dessiner et simuler des circuits .................................................................................................... 72
6.1. Pour les curieux, un résumé du processus de la conception en électronique ..................... 72
6.2. Généralités sur l’environnement de capture du schéma ..................................................... 73
6.3. Prendre, placer et connecter les composants ...................................................................... 74
6.3.1. Prendre les composants ................................................................................................ 74
6.3.2. Placer les composants ................................................................................................... 75
6.3.3. “Référence”, “Valeur” et “Corps” du composant ......................................................... 76
6.3.4. Déplacement, rotation ou réflexion des composants .................................................. 76
6.3.5. Editer la référence et la valeur d’un composant .......................................................... 77
6.3.6. Créer des connexions électriques entre les composants (“Wiring Up”) ...................... 78
6.4. Dessiner et simuler un schéma personnel ............................................................................ 81
7. Dessiner vos périphériques ........................................................................................................... 84
7.1. Présentation du projet de séquencement des LEDs ............................................................. 85
7.2. Dessiner le circuit .................................................................................................................. 85
7.2.1. Possibilités de copier et coller ...................................................................................... 86
7.3. Les circuits LEDs .................................................................................................................... 87
7.4. Electronique analogique et numérique ................................................................................ 87
7.4.1. Convertisseurs analogique-numérique ......................................................................... 88
7.4.2. Utiliser un potentiomètre pour générer une tension analogique en entrée ............... 88
7.5. Entrées et Sorties (Inputs / Outputs) .................................................................................... 90
7.6. L’algorigramme ..................................................................................................................... 91
7.7. Fenêtres popup actives ......................................................................................................... 94
7.8. Tester le projet ...................................................................................................................... 95
7.9. Résumé du chapitre .............................................................................................................. 95
8. Sous-programmes et boucles conditionnelles .............................................................................. 96
8.1. Débuter et configurer le projet ............................................................................................. 97
8.2. Contrôler les couleurs ........................................................................................................... 98
8.3. Configurer un pixel................................................................................................................ 98
8.4. Configurer 3 pixels .............................................................................................................. 100
8.5. Configurer 40 pixels ............................................................................................................ 101
8.6. Boucle “For” conditionnelle ................................................................................................ 102
8.7. Types de boucles conditionnelles ....................................................................................... 104

4
 8.7.1. Boucles TANT-QUE (“While”) ...................................................................................... 104
8.7.2. Boucle REPETER (“Repeat”) ........................................................................................ 104
8.7.3. Boucle FOR (“For”) ...................................................................................................... 105
8.7.4. Boucle COMPTEUR (“Count”) ..................................................................................... 105
8.8. Ajouter d’autres couleurs ................................................................................................... 105
8.9. Sous-programmes (Sub-Routines) ...................................................................................... 106
8.10. Un projet plus raffiné ...................................................................................................... 109
9. Introduction au langage C ........................................................................................................... 112
9.1. Le C comparé aux algorigrammes ....................................................................................... 113
9.2. Introduction à la syntaxe du langage C ............................................................................... 115
9.2.1. Commentaires ............................................................................................................. 117
9.2.2. Directives pour préprocesseur .................................................................................... 117
9.2.3. Indentation.................................................................................................................. 118
9.2.4. Point-virgule ................................................................................................................ 118
9.2.5. Déclaration de variable ............................................................................................... 118
9.2.6. Sous-programme (sub-routine) .................................................................................. 119
9.2.7. Expressions.................................................................................................................. 120
9.3. Expressions C....................................................................................................................... 121
9.3.1. “If” ............................................................................................................................... 122
9.3.2. “While” ........................................................................................................................ 122
9.3.3. “Do”............................................................................................................................. 122
9.3.4. “For” ............................................................................................................................ 123
9.3.5. “Switch” ...................................................................................................................... 123
9.4. Etapes complémentaires pour poursuivre l’apprentissage ................................................ 124
9.5. Opérateurs du langage C..................................................................................................... 125
9.6. Type de variable C (Arduino)............................................................................................... 126
9.7. Pointeurs C .......................................................................................................................... 126
Déclaration de pointeur .............................................................................................................. 126
“Valeur” à l’adresse pointée ....................................................................................................... 126
“Adresse” d’une variable ............................................................................................................ 126
9.8. Convertir un algorigramme en code C/C++ ........................................................................ 126
9.8.1. Directives de préprocesseur "include" ....................................................................... 128
9.8.2. Déclaration "Class"...................................................................................................... 128
10. Résumé.................................................................................................................................... 129

5
11. Chapitre bonus : Robotique .................................................................................................... 130
11.1. Théorie du suivi de ligne ................................................................................................. 133
11.2. Construire le programme : Le plan ................................................................................. 135
11.2.1. Méthode “drive” ......................................................................................................... 135
11.2.2. Méthode “readLinePos”.............................................................................................. 136
11.2.3. Le plan ......................................................................................................................... 136
11.3. Construire le programme : Mettre le plan en action ...................................................... 137
11.3.1. Construire l’algorigramme .......................................................................................... 138
11.3.2. Spécifier la carte.......................................................................................................... 139
11.4. Le moment de vérité ....................................................................................................... 142
11.5. Résumé............................................................................................................................ 142
12. Notes de l’auteur .................................................................................................................... 143
12.1. Sujets non présentés ....................................................................................................... 143
Appendix A : Challenges...................................................................................................................... 144
Procédure générale pour les challenges ......................................................................................... 144
Chapitre 2 (Créer votre premier projet) ......................................................................................... 144
Battements de cœur avec une LED ............................................................................................. 144
Chapitre 3 (Lire des entrées et prendre des décisions) .................................................................. 145
Clignotements à la demande ...................................................................................................... 145
Modification de la fréquence de clignotement .......................................................................... 145
Chapitre 4 (Variables) ..................................................................................................................... 146
Veilleuse ...................................................................................................................................... 146
Décompte avant décollage ......................................................................................................... 147
Chapitre 6 (Dessiner et simuler des circuits) .................................................................................. 148
Loi d’Ohm .................................................................................................................................... 148
Chapitre 8 (Sous-programmes et boucles conditionnelles) ............................................................ 149
Deux tons .................................................................................................................................... 149
Damier......................................................................................................................................... 149
Eclats lumineux pulsés ................................................................................................................ 150
Appendix B : Solutions des challenges ................................................................................................ 151
Chapitre 2 (Créer votre premier projet) ......................................................................................... 151
Battements de cœur avec une LED ............................................................................................. 151
Chapitre 3 (Lire des entrées et prendre des décisions) .................................................................. 152
Clignotements à la demande ...................................................................................................... 152

6
 Modification de la fréquence de clignotement .......................................................................... 152
Chapitre 4 (Variables) ..................................................................................................................... 153
Veilleuse ...................................................................................................................................... 153
Décompte avant décollage ......................................................................................................... 153
Chapitre 6 (Dessiner et simuler des circuits) .................................................................................. 154
Loi d’Ohm .................................................................................................................................... 154
Chapitre 8 (Sous-programmes et boucles conditionnelles) ............................................................ 154
Deux tons .................................................................................................................................... 154
Damier......................................................................................................................................... 155
Eclats lumineux pulsés ................................................................................................................ 155

7
 Préface – “Rendre la vie plus facile”

Il semble que, depuis la nuit des temps, l’homme a constamment recherché des moyens de se faciliter
la vie. De la cuillère la plus rudimentaire jusqu’aux smartphones modernes, l’invention d’outils et de
mécanismes lui a permis d’automatiser, de faciliter et d’accélérer ses tâches quotidiennes – ce qui a
réduit la quantité de travail à accomplir pour améliorer son niveau de vie. Combien de fois par jour
allumons-nous la lumière, utilisons-nous un moyen de transport (vélo/voiture/train) ou actionnons-
nous une chasse d’eau ? Les temps modernes ont, sans doute, débuté avec la révolution industrielle
du 18ème siècle qui, entre autres, a permis de mécaniser la production de textiles. Le fait de passer
moins de temps sur une activité, telle la fabrication de vêtements, en laisse plus pour d’autres, telle
qu’inventer d’autres machines qui font également gagner du temps. Cette tendance s’est
naturellement poursuivie, amplifiée. Après toutes les innovations mécaniques de pignons-engrenages
du 18ème – roues à eau et moteurs à vapeur – notre actualité consiste à développer des machines qui
deviennent "smart" (intelligentes) – smartphones, montres intelligentes, maisons intelligentes. Les
voitures autonomes, l’apprentissage automatique et l’intelligence artificielle (IA) ne sont plus de la
science-fiction mais s’insinuent dans notre réalité. L’objet de ce livre est de montrer qu’il est très facile
de construire des machines intelligentes simples ! En commençant par un projet élémentaire de
contrôle de lumière jusqu’à des projets qui utilisent des machines-dans-des-machines (sous-
programmes), nous vous apprenons pas à pas comment développer vos propres machines
intelligentes – pour simplifier votre quotidien.

Copyright © 2018 Dane du Plooy t/a Dizzy Enterprises. www.dizzy.co.za. 8

Traduction française André Mininno www.multipower.fr - Toute reproduction, même partielle, interdite sans l'autorisation de l'auteur
1. Introduction
1.1. La technologie actuelle
Dans notre monde actuel, nous constatons un développement rapide des technologies qui nous
entourent et qui façonnent la vie ainsi que notre travail au quotidien. Les moteurs de cette technologie
moderne sont l’électronique et le logiciel. Les composants électroniques appelés microprocesseurs
exécutent une liste de commandes contenues dans des instructions logicielles. De cette façon, le
logiciel indique aux machines électroniques modernes ce qu’il faut faire. L’écriture de code logiciel,
appelé programmation, est donc une compétence utile et nécessaire. Pour bien percevoir dans quels
domaines le logiciel transforme notre monde, pensez aux composants qui interviennent dans notre
environnement au quotidien : smartphone, voiture, ordinateurs, consoles de jeux, micro-ondes,
machines à laver, etc.

Un entrepreneur, homme d’affaires fameux, a dit un jour “Apprendre à écrire des programmes étend
votre esprit et vous aide à mieux penser; cela crée une façon de penser les choses qui, je crois, est
utile dans tous les domaines1” – cela signifie que cet apprentissage de la programmation, non
seulement, nous apprend à écrire du code pour ordinateurs, mais nous permet peut-être de
développer une méthode de penser logique qui nous aide à trouver des solutions innovantes aux
problèmes quotidiens auxquels nous sommes confrontés.

L’objet de ce livre est d’initier le lecteur à la programmation ainsi qu’à l’électronique en partant de la
base, puis en progressant pas à pas. Aucune expérience préliminaire avec ces deux domaines n’est
requise. Pour les lecteurs qui possèdent déjà une expérience, ils pourront clairement identifier et
passer les thèmes qu’ils connaissent déjà. Pour commencer, nous allons présenter les termes et les
éléments de technologie utilisés dans ce livre.

1
Bill Gates, fondateur de Microsoft. https://code.org/quotes.

9
1.2. Termes et technologies

1.2.1. Algorigramme
Un algorigramme est un diagramme visuel, facile à comprendre, qui illustre la séquence des décisions
et des actions requises pour réaliser une tâche. Par exemple, regardons le programme qui décrit
comment faire une tasse de thé :

Demander le nombre de sucres. Se souvenir de la réponse (mettre dans Nb_sucres)

Demander si du lait doit-être ajouté. Se souvenir de la réponse (mettre dans Ajouter_lait)

Bouilloire a bouilli et toujours Y-a-t-il de l eau dans la Remplir la bouilloire

Non Non
chaude ? bouilloire ? avec de l eau

Oui
Oui

Remplir la tasse
avec de l eau Faire bouillir l eau
chaude

Ajouter un sachet
de thé

Soustraire 1 à
Nb_sucres

Nb_sucres est-il Ajouter un sucre

Oui
supérieur à 0? dans la tasse

Non

Doit-on Ajouter lait dans la

Oui
Ajouter_lait? tasse

Non

Oter le sachet de
Remuer Servir le thé!
thé

Notez la structure procédurale (qui progresse en “pas à pas”) de l’algorigramme, ainsi que le processus
de décision binaire (deux états “Oui” ou “Non”) – un ordinateur fonctionne de cette façon.

10
1.2.2. Code “C”
Le “C” est un langage de programmation standard, dit de ‘haut-niveau’, couramment utilisé dans
l’industrie pour écrire des programmes. Le terme ‘haut-niveau’ signifie que les actions qu’exécutera
l’ordinateur sont exprimées avec des mots usuels d’une langue naturelle (habituellement en anglais)
et des symboles mathématiques familiers (tels que +, -, *, /). Ensuite, un outil appelé "compilateur"
vérifie les erreurs éventuelles contenues dans le code avant de convertir ce code de haut-niveau en un
code de bas-niveau, compréhensible par le microcontrôleur. Pour les débutants, le langage C peut
sembler complexe et difficile à manier.
Ce document se concentre sur la programmation par algorigramme, plus simple à comprendre et
moins sujet à erreurs, telles que les erreurs de frappes. En fin d’ouvrage, le langage C est présenté.
Notez que même les programmeurs professionnels en langage C utilisent des algorigrammes visuels
de temps en temps ; que ce soit sur un document papier ou pour résumer la logique de leur
programme dans un rapport.
Pour information, le langage C++, de plus haut niveau que le langage C, ajoute des concepts appelés
"objets" au langage C. Les algorigrammes présentés dans ce document peuvent être convertis en code
C/C++ en quelques clics (la procédure est décrite en fin de document, section 9.8).

1.2.3. Microcontrôleur

Un microcontrôleur est un composant électronique capable d’exécuter des instructions (exécuter un

programme). Il possède également des connexions d’entrées/sorties, c’est-à-dire que certaines de ses
broches peuvent être utilisées comme des entrées ou des sorties vis à vis du monde extérieur, ce qui
autorise des interactions. Un microcontrôleur inclut généralement des fonctionnalités additionnelles
(appelées "périphériques"), tel qu’un "timer" (minuteur), qui l’aide à accomplir d’autres actions. Vous

11
avez certainement entendu parler de microprocesseur ou "CPU" (Central Processing Unit), qui est le
"cerveau" du composant.
Quelle est la différence entre un microcontrôleur et un microprocesseur ?
Un microcontrôleur est un microprocesseur qui possède des fonctionnalités internes supplémentaires
(périphériques).

1.2.4. Arduino

Arduino est un terme générique qui référence une série de cartes électroniques populaires peu chères,
développées dans une logique open-source (les schémas de conception sont disponibles
gratuitement).
Ces cartes permettent de concevoir des systèmes facilement et rapidement – Ce sont des plateformes
prêtes à l’emploi. Elles rendent accessibles toutes les possibilités offertes par un microcontrôleur ainsi
que ses broches d’entrées-sorties.
Le terme “Arduino” sert pour les cartes électroniques ainsi que l’Environnement de Développement
Intégré (Arduino EDI - IDE en anglais) qui permet de les programmer en C/C++. Comme nous nous
intéressons principalement aux algorigrammes, nous n’avons pas à nous soucier de l’EDI, du code
C/C++ ou du compilateur, bien que ces sujets soient tout de même introduits au chapitre 9.

12
1.2.5. Le schéma
Un schéma est une représentation graphique des connexions entre des éléments électroniques – il
montre, de façon claire, les liaisons électriques entre les éléments. Bien que la façon dont les liens
réels se propagent puisse être complexe, le schéma représente simplement ce qui est connecté et à
quoi – une simple flèche peut suffire à définir une connexion, alors qu’un câblage physique réel peut
être long et suivre un cheminement tortueux.

1.2.6. Proteus
Proteus est un outil populaire de conception de circuits électroniques ainsi qu’un logiciel de
simulation, y compris du code du microcontrôleur ! Être capable de simuler de l’électronique présente
de nombreux avantages :
- Il est plus facile et rapide de dessiner des circuits sur un ordinateur que de les fabriquer. Le
risque de faire des erreurs est également moindre, comme celui d’oublier une connexion
(rechercher et trouver une erreur peut prendre des heures sur un circuit réel).
- Les circuits peuvent être conçus en utilisant des composants sans devoir les acheter
préalablement. Cela permet de gagner du temps et de l’argent.
- Vous ne risquez pas de casser ou de détériorer quoi que ce soit. Avec la simulation, pas besoin
d’attendre que de la fumée s’échappe de l’électronique pour constater que quelque chose ne
fonctionne pas.
- Les tests peuvent s’effectuer avec des instruments visuels, disponibles dans l’environnement
de simulation, sans devoir acheter des outils de mesures coûteux.
- Il est également possible de mettre la simulation en pause afin de faire des mesures (c’est
l’opération dite de “débogage“), ce qui n’est pas toujours possible dans le monde réel.
En outre, Proteus possède un module logiciel appelé “Visual Designer pour Arduino”, qui autorise la
conception d’algorigrammes pour Arduino, et qui sera utilisé dans cet ouvrage.
Notez que tout ce qui est décrit dans ce livre peut être testé avec Proteus, sans avoir besoin d’acheter
un circuit électronique physique. Cependant, si vous possédez du matériel électronique, il peut être
aisément programmé depuis Proteus (ceci est décrit dans la section 2.7.4).

1.3. Que contient ce livre ?

Ce livre débute avec les notions de base et des explications pas à pas ; il commence avec des projets
simples pour aborder progressivement des notions avancées. Le cœur du document concerne la
programmation par algorigrammes, avec une introduction au langage C à la fin. Comme nous l’avons
déjà indiqué, tous les algorigrammes peuvent être convertis en code C/C++ en quelques clics et tous
les projets de ce livre peuvent être réalisés et simulés sans devoir acheter de "hardware".
A présent, il est temps de se lancer !

13
2. Créer votre premier projet
Pour commencer, nous allons montrer la simplicité de création d’un premier projet fonctionnel !

2.1. Prérequis
- Ce chapitre suppose que vous possédiez déjà des notions et une expérience de base sur les
ordinateurs (vous savez utiliser un ordinateur).
- Assurez-vous d’avoir installé Proteus avant de poursuivre.

2.2. Créer un nouveau projet

Etape 1 : Lancez Proteus (normalement, par un double-clic sur l’icône Proteus du bureau Windows).
Lorsque Proteus démarre, il ouvre la page d’accueil, présentée ci-dessous.

Bouton « Accueil »

Onglet « Page d accueil » Démarrer un nouveau

projet
Ouvrir un projet exemple
Ouvrir un projet existant

Tutoriels
Lancer un nouvel
Algorigramme (raccourci)

Rubriques d aide

Informations sur la licence

Figure 2-1: “Page d’accueil" Proteus

Etape 2 : Afin de démarrer un nouveau projet algorigramme, il faut valider l’option “Nouvel
algorigramme” du bureau Proteus (voir Figure 2-1). Ceci lance l’assistant de projet de création d’un
algorigramme.

(Astuce : Le choix “Nouvel algorigramme” est similaire au choix “Nouveau projet”, mais plus immédiat
car il utilise des valeurs par défaut pour les étapes qui ne concernent pas les algorigrammes)

Le premier écran de l’assistant demande de nommer le projet et d’indiquer dans quel dossier il sera
créé.

14
 Figure 2-2: Assistant de nouveau projet algorigramme

Par défaut, le projet est appelé “Nouveau projet” (notez que l’extension de fichier ".pdsprj" ne doit
pas être modifiée); nous nommons notre projet “BlinkLED” (“BlinkLED.pdsprj”) qui signifie, faire
clignoter une LED.

Le chemin de sauvegarde peut être choisi en utilisant le bouton "Parcourir". Sélectionnez un dossier
qui a du sens pour vous, tel que le dossier "Proteus" relatif au dossier "Documents".

Après avoir validé le nom de projet et le chemin, cliquez sur le bouton "Suivant" de la partie inférieure
de la fenêtre, ce qui fera apparaître la fenêtre suivante de l’assistant.

(Astuce : Le bouton “Retour” permet de revenir à l’étape précédente et le bouton “Annuler” est à
utiliser pour quitter l’assistant de création de nouveau projet)

Etape 3 : Etape de définition du "Firmware" ; c’est le programme qui sera exécuté par le
microcontrôleur.

“Firmware” est le nom du programme – ce sont les instructions (qu’il reste à écrire) qui dit au
microcontrôleur ce qu’il doit faire. Cette étape permet également d’indiquer quel microcontrôleur
sera utilisé dans notre projet.

(Astuce : Le terme “Software” ou “Logiciel” est utilisé pour du code qui s’exécute sur un ordinateur,
tandis que le terme “Firmware” se réfère à du code pour microcontrôleur. Une petite explication à
cela : Il est plus difficile de modifier ou de remplacer le code d’un microcontrôleur que celui présent
en mémoire d’un ordinateur. Ainsi le code d’un microcontrôleur devrait être considéré comme plus
“ferme”/“firm” (moins modifiable). Dans notre cas, cependant, nous considérerons que les termes
Firmware et Software sont équivalents)

15
 Définition du firmware

La “Famille” est relative à une marque de microcontrôleurs, de manière comparable aux marques ou
aux fabricants de voitures (tel que Renault / Peugeot / Citroën / BMW / Audi / Mercedes Benz / Toyota
/ etc). Techniquement, Arduino n’est pas une marque de microcontrôleurs, mais utilise des
microcontrôleurs AVR ; le nom Arduino est cependant un identifiant de groupe très pratique, c’est
pourquoi nous l’utilisons dans ce sens.

“Contrôleur” référence le microcontrôleur (par analogie aux voitures, ce pourrait être quelque chose
tel que BMW 328i ou Renault Clio Rs). A nouveau, Arduino Uno n’est pas techniquement un
microcontrôleur, mais plutôt un produit qui utilise un microcontrôleur ATmega328P ; mais ici encore
cela facilite la description et l’identification.

“Compilateur” indique un outil qui lit les instructions compréhensibles par une personne (diagrammes
ou mots, tels qu’un algorigramme ou un code C) pour les convertir en quelque chose de
compréhensible par un microprocesseur (les instructions qui sont représentées uniquement par des
nombres). Un compilateur est une forme de “traducteur”, qui transforme des instructions
compréhensibles par un humain en instructions lisibles par un microprocesseur.

Lorsque vous êtes prêt, cliquez sur le bouton “Suivant”.

16
Etape 4 : La dernière étape de l’assistant affiche un résumé des informations liées au projet que nous
venons de créer.

Nouveau projet algorigramme

17
2.3. Se familiariser avec l’environnement Proteus
A l’issue de la création du nouveau projet avec l’assistant, Proteus ouvrira deux onglets – celui du
"Visual Designer" et celui de la "Saisie de schéma". L’onglet Visual Designer est sélectionné par défaut.

Ces boutons
Boutons projet permettent d ouvrir à
Nouveau Ouvrir nouveau les onglets
Enregistrer et s ils ont été fermés
Fermer
Onglets

Figure 2-3: Onglets “Saisie de schéma ” et “Visual Designer”

2.3.1. Onglet de saisie du schéma

L’onglet de l’éditeur de schéma contient le circuit électronique du projet. Nous pouvons ignorer cet
onglet pour l’instant, car l’assistant a automatiquement placé le circuit du projet dans le schéma. Si
vous êtes curieux, vous pouvez y jeter un coup d’œil.

Cliquez ici pour

commuter sur l onglet
de saisie de schéma

Le schéma du
circuit
électronique est
automatiquement
ajouté par
l assistant de
nouveau projet

Figure 2-4: Onglet de saisie de schéma

(Conseil : Pour un rappel sur ce qu’est un schéma, revenez à la section 1.2.5 de l’introduction)

Maintenant, commutez sur l’onglet Visual Designer.

18
2.3.2. Onglet Visual Designer
L’onglet Visual Designer est l’emplacement où est conçu l’algorigramme.

Boutons projet Nouveau Ouvrir Enregistrer et Fermer

Déplier pour voir les Feuille algorigramme

méthodes des
périphériques

Zone de conception
de l algorigramme

Glissez / déposez les

blocs génériques

Glissez / déposez les

méthodes des périphériques
(blocs d algorigramme)

Figure 2-5: Onglet Visual Designer

Après avoir créé un nouveau projet algorigramme, la zone de conception contient, par défaut, une
routine “Setup” et une routine “Loop” (nous expliquerons cela en détail plus loin). La zone “Projets”
placée à gauche, liste toutes les feuilles du projet, ainsi que les "périphériques" utilisés dans le projet.

2.3.3. Les feuilles de l’algorigramme

Une feuille d’algorigramme est une “page” sur laquelle vous concevez un algorigramme. De nombreux
projets ne contiendront qu’une seule feuille mais, pour des projets plus ambitieux, vous pourrez
ajouter des feuilles afin de mieux organiser les actions et clarifier la répartition des tâches.

2.3.4. Périphériques
Pour être simple, dans le Visual Designer, les périphériques sont des objets avec lesquels vous pouvez
interagir – par exemple un bouton ou un afficheur. Les périphériques regroupent des “méthodes” (des
instructions), telles que “Effacer écran” ou “Afficher le texte sur l’écran”.

A présent nous allons donner des explications plus détaillées :

Comme indiqué dans l’introduction (section 1.2.3), un microcontrôleur est un microprocesseur qui
possède des fonctionnalités internes supplémentaires (“périphériques”). Un timer (minuteur) est un

19
exemple de périphérique. Les périphériques fonctionnent indépendamment du microprocesseur et
ne ralentissent pas le traitement des instructions. Ce fonctionnement est comparable à un GPS dans
votre voiture – vous pouvez vous concentrer sur la conduite pendant que le périphérique GPS s’occupe
de la navigation. En plus des périphériques internes au microcontrôleur, il est possible d’ajouter des
périphériques externes.

Proteus Visual Designer intègre une galerie de périphériques qui contient une douzaine de modules,
tels que des capteurs de température et des afficheurs. Les périphériques possèdent des méthodes,
qui sont des blocs d’algorigrammes spécifiques à chaque périphérique – telles que les commandes
“on” et “off” d’une lumière, pour l’allumer ou l’éteindre.

Par défaut, les périphériques présents dans un nouveau projet Arduino sont la “cpu” et “timer1”:

- Le périphérique “CPU” n’est pas un périphérique au sens strict du mot, parce qu’il se réfère
plutôt au microprocesseur lui-même. Cependant, il est pratique de l’ajouter à la liste des
périphériques afin d’avoir accès à ses méthodes.
- Le périphérique timer2 peut être utilisé, comme son nom l’indique, pour des mesures
temporelles.

Dans notre premier projet, nous n’utiliserons pas de périphérique supplémentaire (ces aspects seront
abordés dans les sections suivantes).

2.3.5. Naviguer dans le projet

La navigation dans le projet indique la possibilité de zoomer ou d’effectuer un panoramique dans
n’importe quelle direction (haut, bas, gauche, droite). On utilise les mêmes outils pour une navigation
dans l’algorigramme ou le schéma.

2.3.5.1. Les zooms

La méthode habituelle pour zoomer est :

- Pointez la souris à l’endroit où vous souhaitez zoomer et utilisez la molette centrale de la

souris (roulez vers l’avant pour un zoom avant et réciproquement pour un zoom arrière).

Selon vos préférences, vous pouvez également utiliser une des méthodes indiquées ci-dessous :

- Pointez la souris à l’endroit où vous souhaitez zoomer et utilisez les touche F6 ou F7 pour
zoomer avant ou arrière respectivement.
- Sur le clavier, maintenez la touche SHIFT enfoncée et étirez un rectangle avec le bouton
gauche de la souris autour de la zone à zoomer.
- Utilisez les icônes Zoom avant, Zoom arrière, Zoom tout ou Zoom zone de la barre d’outils.

Notez que la touche F8 sert, à tout moment, pour revenir à l’affichage de la totalité du projet.

2
L’utilisation du périphérique timer est un sujet avancé qui sort du cadre de ce document. Des suggestions
sont indiquées en section 12.1.

20
2.3.5.2. Panoramique
Le panoramique indique la possibilité de se déplacer dans une direction gauche/droite/haut/bas.
Habituellement, on utilise la molette de la souris pour faire un panoramique (zoom arrière pour une
vision globale puis zoom avant pour agrandir la portion désirée). Le panoramique peut également être
réalisé explicitement de la façon suivante :

- Cliquez sur le bouton du milieu de la souris pour “préempter” le projet. Utilisez la souris pour
déplacer le projet, puis cliquez avec le bouton du milieu de la souris pour “relâcher” la feuille.

D’autres options sont disponibles, plus spécifiques à l’onglet de saisie du schéma :

- Pointez la souris à l’endroit désiré et appuyez sur la touche F5 du clavier. Le recentrage de

l’affichage se fera par rapport à ce point.
- Maintenez la touche SHIFT enfoncée et venez cogner le bord de la fenêtre dans la direction
souhaitée du panoramique.
- Utilisez l’icône Panoramique de la barre d’outils.

Prenez un peu de temps pour découvrir et maîtriser ces manipulations qui vous feront gagner du
temps par la suite.

2.4. Notions essentielles de la programmation par algorigramme

Un algorigramme contient une séquence d’actions et de décisions requises pour effectuer une tâche,
dessinée sous forme graphique. L’algorigramme de la section 1.2.1 est un bon exemple introductif. Un
algorigramme est généralement plus simple à comprendre que du code écrit sous forme de texte dans
un langage spécifique, tel que le langage C. L’utilisation d’un algorigramme pour programmer permet
de se concentrer sur l’obtention des résultats attendus, sans avoir à apprendre une syntaxe plus ou
moins complexe à maîtriser - code C ou C++.

2.4.1. Types de bloc d’algorigramme

Les algorigrammes sont construits avec des “blocs”. Traditionnellement, les algorigrammes utilisent
uniquement des blocs ‘action’ ou ‘décision’ :

Bloc Nom Description

Action Bloc action Représente une action à faire, tel qu’allumer une
lumière.

Bloc décision Représente une décision à prendre, avec

Oui
Décision plusieurs sorties possibles.

Non

Cependant, Proteus admet d’autres blocs qui offrent des possibilités supplémentaires. Ne vous
souciez pas de comprendre ou de mémoriser tous les blocs à ce stade – nous y reviendrons dans les
sections suivantes. Ils sont listés ici pour être complets.

21
 Bloc fonctionnel Nom Description
Bloc événement Le bloc ‘événement’, associé au bloc ‘fin’, permet
de créer un sous-programme (sub-routine)
(présenté au chapitre 8). Le bloc ‘événement’
peut être utilisé pour gérer des événements tel
qu’une interruption - ce sujet sort du cadre de ce
livre3.
Bloc fin Le bloc ‘fin’ (end) est utilisé pour mettre fin à un
sous-programme ou un événement.
Bloc affectation Le bloc ‘affectation’ est utilisé pour affecter une
valeur à une variable dans le programme. Les
variables mémorisent quelque chose. Dans
l’exemple d’introduction “Faire une tasse de
thé”, “Nb_sucres” et “Ajouter_lait” sont des
variables.
Bloc appel de sous- Dans le Visual Designer, un “sous-programme”
programme est un groupe de blocs d’algorigrammes qui sont
placés en-dehors de l’algorigramme principal.
Regrouper certaines tâches en sous-programmes
peut aider à rendre l’algorigramme plus organisé,
simple à comprendre, et peut également éviter
la duplication de “code”. Les sous-programmes
sont abordés au chapitre 8.
Bloc de données Le bloc de données sauvegardées est utilisé pour
mémorisées réaliser des actions (t.q. lecture, écriture) sur les
objets stockés (t.q. cartes SD).
Bloc opération I/O4 Ce bloc est utilisé pour représenter une méthode
(périphérique) de périphérique (voir section 2.3.4), tel que
commuter une lumière en "on" ou "off" ou écrire
du texte sur un afficheur.

2.4.2. Lignes de flux d’algorigramme

Les blocs d’algorigramme sont reliés par des lignes de flux qui représentent les liens et le sens de
déroulement des actions/décisions (voir Figure 2-6).

Les lignes de flux sont

représentées en rouge

“Flowlines” highlighted in red

Figure 2-6: Les lignes de flux relient les blocs d’algorigramme

3
Des suggestions de lecture supplémentaires sur ce sujet sont données en section 12.1.
4
“I/O” signifie “Input / Output”, c’est à dire “Entrée / Sortie”. Par exemple, lire la température d’un
thermomètre est un exemple d’entrée et jouer un son sur un haut-parleur est un exemple de sortie.

22
2.4.3. Routines Setup et Loop
Lorsqu’un projet Proteus Visual Designer est créé, deux routines sont incluses par défaut dans
l’algorigramme : “SETUP” et “LOOP”.

Une routine est une suite d’instructions/d’actions regroupées dans un bloc commun – c’est un ‘bout’
de programme.

La routine Setup
s’exécute une Une fois terminée
fois et une seule l’exécution de la routine
au lancement. Setup, la routine Loop
est lancée pour
s’exécuter sans cesse.

After the Setup routine

has completed, the Loop
routine runs repeatedly.

Lignes de flux

Figure 2-7: Le programme algorigramme par défaut avec les routines setup et loop

La routine Setup est exécutée (“run”) une seule fois au lancement initial du microcontrôleur.

Après la routine Setup, la routine principale Loop est exécutée (“run”) sans cesse, c’est-à-dire que
lorsque le mot END (FIN) est rencontré, le programme recommence au niveau du mot LOOP.
Normalement, la majeure partie du programme se trouve dans la routine Loop.

2.5. Concevoir un algorigramme pour faire clignoter une LED

A présent, nous allons concevoir l’algorigramme qui allume et éteint une “LED” (LED : “Light Emitting
Diode” ou “Diode émettrice de lumière”). Les LEDs sont extrêmement courantes et se retrouvent dans
un grand nombre de montages ou systèmes électroniques.

Pour ce projet, nous commuterons la LED entre les états “on” et “off”, avec une attente d’une seconde
entre chaque état. C’est un programme classique lorsqu’on prend en main un nouveau système. C’est
un programme rapide à développer, qui sert à démontrer que tout fonctionne correctement (le
microcontrôleur, l’électronique ainsi que l’environnement de développement).

Le détail, concernant la LED qui va clignoter, est présenté en section 2.7.1 mais, sans attendre, nous
allons passer à la conception de l’algorigramme (vous pouvez lire la section 2.7.1 avant de continuer,
si vous êtes curieux).

23
2.5.1. Dessiner l’algorigramme
L’algorigramme, qui contient les blocs de construction, est représenté dans la figure qui suit :

Figure 2-8: Algorigramme pour faire clignoter une LED

Pour construire cet algorigramme, suivez les étapes décrites plus bas :

24
Etape 1 : Glissez la méthode “setBuiltInLED” depuis le périphérique CPU dans la routine Loop de
l’algorigramme (Figure 2-9). Le nom de la méthode “setBuiltInLED” (qui valide une LED interne à la
carte Arduino, ce qui nous évite de devoir en connecter une à la carte) indique qu’elle peut être utilisée
pour commuter une LED de la carte Arduino Uno, en “on” ou “off” (voir une présentation dans la
section 2.7.1 – si vous êtes curieux, rendez-vous à cette section puis revenez ici).

Figure 2-9: Ajout de la méthode "setBuiltInLED" dans l’algorigramme

Si la méthode est correctement alignée lors de l’insertion, des points noirs apparaîtront à l’endroit où
les lignes de flux rencontrent les blocs (Figure 2-10).

Les points indiquent un

alignement correct

Figure 2-10: Insérer un bloc d’algorigramme

Après insertion, vous ne devriez observer que des lignes de flux en entrée et en sortie du bloc. Les
points ont disparu (Figure 2-11) et seules des flèches sont visibles en fin des lignes de flux.

25
 Ligne entrante
Flèche à l’extrémité

Ligne sortante

Figure 2-11: Insérer un bloc d’algorigramme

Par défaut, la méthode “setBuiltInLED” allumera la LED (“state := ON”). Cette opération correspond à
ce que nous souhaitons, donc nous ne changerons rien. La façon de modifier le bloc “setBuildInLED”
afin d’éteindre la LED sera présenté dans les étapes 4 et 5.

Etape 2 : L’étape suivante consiste à ajouter une attente, avant d’éteindre la LED. Pour faire cela, nous
utilisons un bloc attente (delay) ; donc nous glissons-déposons ce bloc dans l’algorigramme, l’insertion
se fait après le bloc “setBuiltInLED“ (Figure 2-12).

Figure 2-12: Insérer un bloc attente

26
Etape 3 : Ensuite, nous voulons configurer le temps d’attente à 1 seconde car, par défaut, il est de 100
millisecondes. Cliquez droit sur le bloc d’attente que vous venez d’insérer dans l’algorigramme et
choisissez “Editer” dans le menu qui apparaît (Figure 2-13). Une autre possibilité est de cliquer gauche
deux fois dans le bloc.

Commande "Editer"

Figure 2-13: Menu popup du bloc attente

Indiquez “1 seconde” ou "1000 ms" (Figure 2-14), et cliquez sur “OK” lorsque c’est fait.

Configuré pour 1 seconde

Figure 2-14: Spécifier le temps d’attente

Le bloc d’attente devrait ressembler à la Figure 2-15.

Figure 2-15: Bloc attente validé pour 1 seconde

27
Etape 4 : Après cette attente de 1 seconde, pendant laquelle la LED est allumée (ON), nous voulons
l’éteindre (OFF) pendant 1 seconde. Pour éteindre la LED, nous avons à nouveau besoin d’un bloc
“setBuiltInLED“. Comme dans l’étape 1, glissez-déposez une méthode setBuiltInLED depuis le
périphérique cpu dans l’algorigramme, après l’attente de 1s.

Par défaut, la méthode “setBuiltInLED“ commute la LED sur “on”. Afin que l’action éteigne la LED,
cliquez droit et sélectionnez “Editer” dans le menu qui apparaît.

Commande éditer

Figure 2-16: Menu popup du bloc setBuiltInLED

La boite de dialogue “d’édition du bloc I/O” est affichée.

La zone des “Arguments”

Figure 2-17: Edition des entrées-sorties (I/O) du bloc

28
Etape 5 : Dans le bloc I/O, entrez “OFF” comme état (State) de l’argument.

Une coche verte indique que

l’argument est valide

Figure 2-18: Spécifier l’argument "State" (état)

En programmation, un argument représente une information transmise à une méthode (le terme
“paramètre” est également utilisé). Cet argument précise ce qu’il faut faire. Dans notre cas, pour la
méthode “setBuiltInLED“ qui peut allumer (ON) ou éteindre (OFF) la LED, nous devons indiquer
l’option souhaitée.

Un fois terminé, cliquez sur "OK". Le bloc “setBuiltInLED“ de l’algorigramme devrait ressembler à la
figure suivante :

Figure 2-19: Routine setBuiltInLED à l’état "OFF"

(Information : Pour les lecteurs qui ont une expérience préalable en programmation, sachez que “ON”
de Proteus Visual Designer est un alias de “TRUE” et “OFF” est un synonyme de “FALSE”)

Etape 6 : A présent que la LED a été éteinte, nous allons attendre 1 seconde avant de recommencer
la boucle qui allume à nouveau la LED. Pour cela, nous ajoutons une attente de 1s après le second
appel à la routine “setBuiltInLED“ (de manière identique aux étapes 2 et 3).

En définitive, la routine Loop de l’algorigramme devrait ressembler à la figure qui suit.

Figure 2-20: Algorigramme qui fait clignoter une LED

Contrôlez votre algorigramme afin qu’il soit identique à la Figure 2-20: Algorigramme qui fait clignoter
une LED (si ce n’est pas le cas, parcourez à nouveau les étapes de ce tutorial pour vérifier que rien n’a
été oublié). La routine Setup routine doit être vide.

Félicitations ! Le programme algorigramme pour faire clignoter une LED est terminé.

29
2.6. Lancer la simulation
Pour voir l’algorigramme en action, nous devons lancer la simulation. Pour cela, cliquez sur le bouton
bleu “Play”, situé en bas et à gauche de la fenêtre Proteus (Figure 2-21).

Lancer la simulation

Arrêter la simulation

Figure 2-21: Lancer la simulation

Lorsque le bouton triangulaire bleu est actionné, Proteus commence par compiler l’algorigramme afin
qu’il puisse être simulé (Voir l’étape 3 de la section 2.2 pour un rappel sur la compilation).

Sortie du compilateur. Les messages

d’erreurs, s’ils existent, seront
affichés ici

Figure 2-22: Sortie compilation

Tout problème rencontré dans l’algorigramme génèrera des messages d’erreurs affichées dans la
fenêtre de sortie de VSM Studio. Dans le cas contraire, un message vert “Compilation réussie” sera
affiché.

(Astuce : La compilation peut également être déclenchée manuellement par l’appel de la commande
“Construire projet” du menu “Construire”)

Lorsque le projet a été compilé avec succès, la simulation sera lancée (Figure 2-23).

30
 Les fenêtres “popup actives”
peuvent être redimensionnées,
déplacées ou détachées dans une
fenêtre séparée, ou fermées

Si vous fermez accidentellement une “fenêtre

popup active”, elle peut être ouverte à nouveau
depuis le menu “Débogage”

La LED de notre programme

s’allume et s’éteint toutes les
secondes

Arrêtez la simulation lorsque c’est terminé

Figure 2-23: Simulation en cours d’exécution

Vous devriez voir une LED jaune passer de l’état ON à l’état OFF avec une attente de 1 seconde entre
chaque commutation, comme indiqué dans l’algorigramme.

LED On: LED Off:

Après avoir vérifié le bon fonctionnement, cliquez sur le bouton rectangulaire bleu “Stop” (voir Figure
2-23) pour mettre fin à la simulation.

Félicitations ! Vous avez construit et simulé un programme fonctionnel.

(Astuce : Si vous souhaitez sauvegarder votre travail, utilisez indifféremment la commande

“Enregistrer le projet’ du menu Fichier, un clic sur le bouton ( ) de la barre d’outils, ou la
combinaison Ctrl + S du clavier).

Vous pouvez aller plus loin en modifiant la durée de l’attente entre chaque état de la LED, puis tester
à nouveau le programme.

Si vous souhaitez transférer votre programme sur un hardware réel, notez que ce point est abordé en
section 2.7.4.

31
2.7. Informations complémentaires
2.7.1. Quelle LED faisons-nous clignoter ?
La carte Arduino Uno que nous avons sélectionné pour notre projet, via l’assistant de création d’un
nouveau projet, est une carte de développement peu couteuse ; elle contient essentiellement un
microcontrôleur, une circuiterie électronique dédiée (telle que le circuit de gestion de l’alimentation),
et une LED montée sur la carte. Les connecteurs d’extension (“headers” ou “sockets”) sont placés sur
les bords de la carte, et peuvent être utilisés pour ajouter des périphériques externes au
microcontrôleur (voir Figure 2-24).

LED interne au circuit

Bouton Reset
(“relancer”) Connecteurs
Microcontrôleur
(“headers” ou
“sockets”)

Figure 2-24: Carte Arduino Uno5

Dans Proteus, le schéma de la Arduino Uno est contenu dans l’onglet de saisie de schéma. Comme
indiqué dans la section 2.3.1, il n’est pas nécessaire de comprendre le fonctionnement de l’éditeur
de schéma pour l’instant. Cependant, pour les curieux, le schéma ressemble à ce qui suit :

Connexions

Connexions

Microcontrôleur

Bouton Reset (“relancer”)

LED sur circuit

Figure 2-25: Schéma de la carte Arduino Uno

5
Image depuis https://store.arduino.cc/usa/arduino-uno-rev3

32
2.7.2. Fenêtres “popups actives”
Lorsque vous cliquez sur le bouton "Play", Proteus simule le circuit qui existe dans l’onglet de saisie
du schéma. Des zones supplémentaires existent, appelées “popup actives“, placées dans la saisie de
schéma. Ces zones peuvent être utilisées pour visualiser des portions spécifiques du schéma dans
l’onglet du Visual Designer pendant la simulation. Il est donc possible d’observer la simulation soit
dans l’onglet “Saisie de schéma“, soit dans l’onglet “Visual Designer“. Les “ popup actives“ sont
présentées en détail en section 7.7. A nouveau, cette information s’adresse aux curieux, et, dans
l’immédiat, il n’est pas nécessaire de comprendre le fonctionnement de l’éditeur de schéma ou le
circuit.

Note : Les fenêtres popup actives (voir Figure 2-23) peuvent être redimensionnées, déplacées,
détachées dans des fenêtres séparées et/ou fermées. Si vous fermez accidentellement une fenêtre
popup, elle peut être ouverte à nouveau via le menu "Débogage".

2.7.3. Edition de l’algorigramme

L’édition de l’algorigramme dans le Visual Designer est prévue pour être intuitive. Nous présentons ici
quelques points de détail, pour être certain de ne rien omettre.

- Les blocs déjà présents sur la feuille peuvent être déplacés par glisser-déposer.
- Les blocs peuvent être supprimés en les sélectionnant puis en appuyant sur le bouton
“Supprimer” du clavier, ou par un clic droit dessus, suivi de la sélection de la commande
“Supprimer” du menu contextuel.
- Plusieurs blocs peuvent être sélectionnés en étirant un rectangle autour d’eux avec la souris.
- Les blocs peuvent être coupés, copiés et collés en utilisant les commandes correspondantes
du menu ‘Editer’, et/ou les raccourcis clavier :
o Couper: Ctrl + X
o Copier: Ctrl + C
o Coller : Ctrl + V
- Les lignes de flux peuvent être ajustées et supprimées, en utilisant des méthodes identiques
à celles qui nous venons de lister.

Une opération, qui peut sembler moins intuitive consiste à détacher des blocs afin de les repositionner
dans l’algorigramme. Pour détacher un bloc, cliquez droit sur lui et sélectionnez la commande
“Détacher” du menu popup (comme illustré dans la figure qui suit) :

33
 Détacher le bloc de
l’algorigramme, afin de
le repositionner

Figure 2-26: Détacher un bloc de l’algorigramme

La commande “Détacher” est également disponible dans le menu principal “Editer”. Les blocs peuvent
aussi être détachés en maintenant enfoncée la touche Ctrl du clavier, puis en cliquant sur les blocs et
en les glissant hors de l’algorigramme.

Nous vous conseillons de tester ces techniques afin de vous habituer à les utiliser.

2.7.4. Téléverser le programme sur un hardware physique (Optionnel)

Si vous disposez d’un hardware physique (dans notre cas, une carte Arduino Uno), alors votre
programme peut être transféré (uploader) dans ce hardware, très simplement, depuis Proteus. Les
commandes pour effectuer ce transfert sont disponibles dans le menu Construire (lorsque l’onglet
Visual Designer est ouvert).

Figure 2-27: Menu Construire

En premier, il convient d’effectuer les bons réglages pour le transfert. Pour cela il faut ouvrir la boite
de dialogue “Options projet”, via la commande “Configurer le projet”. Voici à quoi ressemble la boite
de dialogue (Figure 2-28) :

34
 Le port dépend du port COM
auquel la carte Arduino Uno est
connectée.

Figure 2-28: Boite de dialogue des options du projet

1. Sélectionnez “AVRDUDE” comme programmateur.

2. Sélectionnez “Arduino Uno” comme interface.
3. Sélectionnez le port COM auquel la carte physique Arduino Uno est connectée.
Habituellement cela correspondra au label “USB Serial Device”, qui sera COM3 ou supérieur.
La méthode suivante peut être utilisée pour déterminer le numéro du port COM :
a. Assurez-vous que la boite de dialogue des options du projet est fermée.
b. Débranchez la carte Arduino Uno de l’ordinateur, ouvrez la boite de dialogue des
options du projet et notez les ports COM qui sont listés.
c. Connectez la carte Arduino à l’ordinateur.
d. Fermez et ouvrez à nouveau la boite de dialogue des options du projet. Un nouveau
port COM devrait apparaître dans la liste. C’est le port auquel la carte est connectée.
Si aucun nouveau port COM apparaît, c’est probablement parce que les pilotes
(drivers) USB ne sont pas installés, ou qu’il y a un souci avec le hardware (carte
défectueuse / câble défectueux / ordinateur défectueux). Le chapitre “Programmer le
hardware physique” de l’aide relative au Visual Designer (disponible dans le menu
Aide, lorsque l’onglet Visual Designer est ouvert), peut également vous aider.
4. La vitesse du port devrait être de 115200.

Lorsque les réglages sont effectués, il faut s’assurer que le projet a été compilé. Pour cela, sélectionnez
la commande “Construire Projet” dans le menu Construire du Visual Designer.

35
Si les réglages sont bons et que le projet est compilé, alors le téléversement est possible via la
commande “Téléverser” ou en utilisant le bouton dédié de la barre d’outils (voir Figure 2-29).

Construire (compiler) Téléverser Réglages projet

Figure 2-29: Boutons construire, téléverser et réglages projet

2.7.5. Ressources supplémentaires

Des explications et des tutoriels pas à pas sont également inclus dans l’aide relative au Visual Designer,
accessible depuis le menu Aide lorsque l’onglet Visual Designer est ouvert et sélectionné.

2.8. Challenges
Des défis optionnels, appelés challenges, (regroupés par chapitre) sont listés en Appendice A. Ces défis
peuvent être utilisés pour pratiquer les notions apprises, mais il est possible de continuer la lecture
de ce livre sans les faire. Des solutions possibles à ces défis sont décrites en Appendice B.

Le challenge de ce chapitre est de faire clignoter une LED afin qu’elle corresponde visuellement au
battement d’un cœur. Si vous êtes intéressé par ce défi, jetez un coup d’œil à l’appendice A, dans le
cas contraire vous pouvez passer au chapitre suivant.

36
3. Lire des entrées et prendre des décisions
3.1. Introduction aux blocs de décisions
Dans le monde de la programmation il existe deux types d’opérations fondamentales :

Décision Non
Action

Oui

Actions (“Dire”) Décisions (“Demander”)

Alors que notre premier projet introduisait les actions (en “disant” à la lumière de s’allumer ou de
s’éteindre), ce chapitre introduit les décisions (“demander”). Contrairement aux actions qui sont
reliées à une ligne de flux entrante et une ligne sortante, les décisions possèdent une ligne de flux
entrante et deux lignes sortantes. En fonction de la réponse à la question posée par le bloc de décision,
le programme choisira une des deux lignes sortantes.

Question :
Chemin à suivre si la réponse est “NO”
“La température est-
elle supérieure à 30 ?”

Chemin à suivre si la réponse est “YES”

3.2. Résumé du projet

Dans le projet suivant, nous allons demander à un bouton s’il est enfoncé ou non, puis dire à une
lumière de s’allumer ou de s’éteindre en fonction de la réponse.

a) Si le bouton est enfoncé, alors la lumière s’allume (on).

b) Si le bouton est relâché, alors la lumière est éteinte (off).

L’algorigramme de ce projet est présenté dans la figure ci-dessous.

Bloc de décision,
qui demande à un bouton de
nom “B1” s’il est enfoncé

Figure 3-1: Algorigramme Bouton-LED

Lorsque la boucle démarre, le programme demande au bouton (B1) s’il est enfoncé ou pas (bloc de
décision). Si la réponse est “Yes”, alors le programme se poursuit en allumant la LED, et si la réponse

37
est “No”, alors le programme passe par le chemin qui éteint la LED. Comme les blocs de l‘algorigramme
sont placés dans la routine “Loop” (voir section 2.4.3), ce processus se répète indéfiniment.

3.3. Débuter le projet

Pour commencer la construction de l’algorigramme, veuillez terminer les étapes suivantes :

1. Sauvegardez ( ) tout projet existant qui pourrait être ouvert (si vous ne voulez pas le
perdre). Pour cela, utilisez la commande “Enregistrer projet” du menu “Fichier”.
2. Fermez ( ) tout projet existant qui pourrait être ouvert. Pour cela, utilisez la commande
“Fermer projet” du menu Fichier. A ce stade, vous devriez voir l’onglet d’accueil Proteus ,
comme illustré dans la Figure 2-1.
3. Démarrez un nouveau projet algorigramme, de nom “Button-LED” (revoir la section 2.2 si
nécessaire).

3.4. Ajouter des périphériques au projet

Comme indiqué en section 2.3.4, les périphériques sont des objets qui peuvent être ajoutés au projet,
tels que des boutons / des afficheurs / des capteurs / etc. Pour ce projet, nous devrons ajouter un
bouton et une LED externe (différente de la LED interne à la carte qui nous avons déjà utilisé dans le
chapitre précèdent).

Les périphériques sont ajoutés au projet en utilisant la “galerie de périphériques”, accessible depuis
le menu “Ajouter périphérique” du menu Projet. Il est également possible d’y accéder par un clic droit
dans la section des périphériques du résumé du projet, puis en sélectionnant le choix “Ajouter
périphérique” du menu popup (voir Figure 3-2).

Figure 3-2: Commande ajouter périphérique

Lorsque la galerie des périphériques est ouverte, sélectionnez la catégorie “Grove”, puis ajoutez
“Momentary Action Push Button” et “Grove LED (Green)” au projet. Les périphériques peuvent être
ajoutés par un double-clic sur eux, ou par sélection puis un seul clic sur le bouton “Ajouter”.

38
 Catégorie “Grove”

Prévisualisation du
schéma du circuit
Bouton périphérique (à ignorer
Périphériques du projet pour l’instant)
(après ajout)

Lumière
(LED)

Cliquez pour ajouter le

périphérique au projet

Figure 3-3: Périphériques du projet Bouton-LED

La section des périphériques du résumé du projet devrait, à présent, contenir “BTN1 (bouton Grove)”
et “LED1 (LED Grove)” (comme illustré dans la figure qui suit). Fermez la fenêtre après l’ajout.

Figure 3-4: Périphériques ajoutés au projet

Si vous avez accidentellement ajouté plus de périphériques que nécessaire, ceux-ci peuvent être
supprimés du projet par un clic droit sur eux, puis par sélection du choix “Supprimer périphérique” du
menu popup.

Un complément d’information sur les périphériques “Grove” est inclus à la fin de ce chapitre (sections
3.8.1 et 3.8.2).

39
3.5. Dessiner l’algorigramme
Après avoir ajouté les périphériques à votre projet, il faut inclure le bloc de décision, qui demande si
le bouton est appuyé ou pas. Pour cela, il suffit de cliquer sur le périphérique bouton puis de le glisser-
déposer dans la routine Loop (comme indiqué dans la figure qui suit).

Figure 3-5: Insertion du bloc de décision associé au bouton

A la suite de l’insertion du bloc de décision, nous ajoutons les actions à déclencher en relation avec
les sorties possibles de la décision. Nous allumons la LED si la sortie du bloc de décision est OUI (Yes),
donc il suffit de glisser-déposer la méthode "On" dans l’algorigramme (voir figure qui suit).

Cliquez ici pour voir

les méthodes de
LED1, si elles ne sont
pas déjà visibles

Figure 3-6: Insertion de la méthode "on" de la LED

40
Le dernier bloc à ajouter, pour terminer l’algorigramme, est de placer la méthode “off” de LED1.
Procédez comme indiqué dans la figure suivante.

Figure 3-7: Insertion de la méthode "off" de la LED

Bien que le bloc “off” ait été ajouté à l’algorigramme, il n’est toujours pas connecté au bouton du bloc
de décision.

Cliquez une première fois sur le point noir placé à droite du bloc de décision du bouton, puis une
deuxième fois sur le point noir placé au-dessus du bloc d’action “off”. La procédure est illustrée ci-
dessous.

Premier clic ici...

...puis un clic ici

Figure 3-8: Connexion des blocs d’algorigramme

Le bloc “off” est maintenant accessible depuis le bloc de décision du bouton, cependant
l’algorigramme ne sait pas où aller ensuite (lorsque le bloc “off” est atteint, l’algorigramme est
bloqué). Pour terminer la connexion, il faut ajouter une ligne de flux qui part du bloc “off” pour
rejoindre la routine loop principale, comme illustré dans la figure qui suit :

41
 Premier clic ici...

...puis un clic ici

Figure 3-9: Deuxième connexion de bloc

A présent, lorsque le programme atteint le bloc “off”, il poursuit son exécution. L’algorigramme final
doit ressembler à la figure suivante.

Figure 3-10: Algorigramme du Button-LED complet

Ne vous inquiétez pas si la position des blocs n’est pas strictement identique à la Figure 3-10. Ce qui
compte, c’est que l’ordre (“séquence”) des blocs soit la même.

3.6. Lancer la simulation

Pour lancer la simulation, cliquez sur le bouton triangulaire “Play”, en bas et à gauche de la fenêtre. Si
vous obtenez un message d’erreur, revérifiez que votre algorigramme est identique à celui de la Figure
3-10, et que c’est bien un périphérique “Grove LED (Green)” qui a été ajouté au projet (ce point sera
discuté à la fin de ce chapitre, en section 3.8.2). Lorsque la simulation est lancée, vous pouvez cliquer
sur le bouton Grove pour allumer la LED Grove (voir Figure 3-11: Fenêtres popup actives de la LED et
du bouton Grove; la LED et le bouton Grove devraient apparaître dans la partie inférieure droite de
l’écran).

42
 Cliquez sur le bouton pour
simuler “un appui”

Figure 3-11: Fenêtres popup actives de la LED et du bouton Grove

N’oubliez pas de stopper la simulation lorsque vos essais sont terminés (carré bleu “Stop” en bas et à
gauche de la fenêtre).

3.7. Inverser la logique

Maintenant, modifions la logique de la LED afin qu’elle s’éteigne (off) lorsque le bouton est appuyé et
qu’elle s’allume lorsque le bouton est relâché. Avant tout modification, assurez-vous que la simulation
est arrêtée. Puis, cliquez droit sur le bloc de décision du projet et sélectionnez “Permuter Oui/Non”
(Figure 3-12).

Figure 3-12: Permuter les sorties Yes et No d’un bloc de décision

43
A présent, l’algorigramme devrait ressembler à la figure qui suit :

Figure 3-13: Algorigramme avec la logique inversée

Lancez la simulation qui doit correspondre à la nouvelle logique – la LED s’allume lorsque le bouton
n’est pas appuyé et s’éteint lorsqu’il est enfoncé (Figure 3-14 and Figure 3-15).

Figure 3-14: Bouton NON appuyé Figure 3-15: Bouton appuyé

Ceci termine le projet de ce chapitre ! Si vous avez terminé et compris ce chapitre, vous savez utiliser
les blocs décision dans un projet !

3.8. Informations complémentaires

3.8.1. Le système “Grove”
“Grove” est le nom d’un ensemble de cartes périphériques produites par la société Seeed Studio
(www.seeedstudio.com). Ces cartes incluent de nombreuses interfaces et des capteurs, tels que le
bouton et la LED utilisés dans ce projet. Ces cartes périphériques sont connectées à une “carte de
base” via des câbles. La carte de base ("Base Board”) enfichée sur une carte Arduino Uno.

44
 Connecteurs numérotés
(D2 et D3)

Carte périphérique “Carte de base”, insérée

LED Grove sur une Arduino Uno

Carte périphérique
bouton Grove
Peripheral Board

Figure 3-16: Système Grove6

3.8.2. Modifier le numéro de connecteurs Grove dans Proteus

Comme on peut le voir dans la Figure 3-16, les connecteurs de la carte de base Grove sont numérotés.
Lorsque nous ajoutons un périphérique bouton Grove ou une LED Grove dans notre projet (section
3.4), automatiquement, Proteus insère dans le schéma le bon circuit électronique qui correspond à
ces périphériques.

Numéro du Circuit du
connecteur de périphérique ajouté
la carte de base automatiquement
Grove

Figure 3-17: Schéma avec les circuits périphériques

6
Image issue de https://pmtechnologie.shost.ca/spip.php?article21, Creative Commons Attribution 2.5
License, non modifiée excepté pour les labels ajoutés.

45
Pour les périphériques de ce projet, par défaut, le bouton Grove est connecté à “D2” et la LED Grove
à “D3”. Les différentes LEDs Grove (bleue, rouge, jaune) sont connectées par défaut à ‘D2’ – bien
évidemment il n’est pas possible de connecter deux cartes au même connecteur. Si nous tentons
d’affecter plusieurs LEDs au même numéro de connecteur, alors Proteus signalera une erreur :

Figure 3-18: Conflit hardware (la broche IO2 est connectée à plusieurs périphériques)

Il est cependant facile de modifier le numéro de connecteur auquel le périphérique Grove est relié !
Pour faire cela, il faut valider l’onglet schéma et cliquer droit sur le numéro de connecteur, puis choisir
“Editer propriétés” dans le menu popup.

Figure 3-19: Editer les propriétés d’un connecteur Grove

Dans la boite de dialogue d’édition du composant qui apparaît, choisissez un numéro de connecteur
différent dans la liste déroulante “Connector ID", et cliquez sur “OK”.

Cliquez sur
“OK” pour
terminer
done

Numéro de connecteur
à affecter

Figure 3-20: Valider un numéro de connecteur Grove différent

Maintenant, la carte périphérique est reliée à un connecteur différent, ce qui résout le conflit matériel !

46
4. Variables
Les variables sont un moyen de mémoriser une information sur un ordinateur. Par exemple, imaginons
une personne qui souhaite conserver la trace du stock dans une boutique. Il possède un cahier avec
le nom des produits auquel il associe la quantité du produit en stock.

Melons 21
Sacs de pommes de terre 35
Laitues 39

Pour commencer, imaginons qu’initialement, il y ait 21 melons en stock et que ce nombre soit noté
sur le cahier.
Puis un client arrive et achète trois melons. Le nombre de melons doit donc être décrémenté de 3.
Une autre façon de décrire ceci, est d’indiquer que le nouveau nombre associé à melon est égal au
nombre actuel minoré de 3 :

melons = melons - 3

La nouvelle valeur de melons dans le stock est donc 21 – 3 = 17. Imaginons que la personne qui tient
le décompte du stock utilise un crayon. Il faut qu’il commence par effacer la valeur actuelle, puis qu’il
note la nouvelle valeur. Donc, il efface l’ancienne valeur de 21, et écrit 17 à la place.

Ensuite, supposons que la boutique reçoit une livraison de 9 melons. Il faut donc ajouter +9 au nombre
de melons en stock ou dire que la nouvelle valeur de melons est égale à l’ancienne valeur plus 9 :

melons = melons + 9

Le nouveau décompte de melons en stock est à présent de 17 + 9 = 26. La personne qui tient le compte
du stock efface la valeur de 17, et écrit la nouvelle valeur de 26.

Le nombre de melons dans cet exemple est une “variable”. Le nom de la variable est “melons” et la
valeur de cette variable est le nombre de melons en stock (commence à 21, puis devient 17, puis 26).

4.1. Afficher du texte sur un LCD

Pour illustrer l’utilisation de variables dans l’algorigramme, commençons par un exemple :

1. Sauvegardez ( ) le projet existant qui pourrait être ouvert (si vous ne souhaitez pas perdre
son contenu).
2. Fermez ( ) tout projet existant ouvert. Vous devriez voir l’onglet "Accueil" de Proteus affiché
( ), comme indiqué en Figure 2-1.
3. Lancez un nouveau projet algorigramme, avec le nom de projet “Variables” (revoir la section
2.2 si vous avez besoin d’une piqure de rappel).
4. Ajoutez le module périphérique "Grove RGB LCD Module" au projet depuis la galerie
(Catégorie périphérique Grove). Pour un rappel sur la façon d’ajouter un périphérique au
projet, voir la section 3.4. Après l’ajout, le périphérique devrait apparaître dans la liste comme
"LCD1 (Grove RGB LCD)".

47
"LCD" signifie "Liquid Crystal Display7". C’est un dispositif électronique d’affichage que vous devez
avoir rencontré plusieurs fois.

Afficheur LCD

Figure 4-1: Afficheur LCD sur un produit8

Le module LCD RGB dispose de deux lignes de texte, avec 16 caractères maximum sur chaque ligne.

Pour débuter la construction de notre algorigramme, glissez-déposez la méthode “print” depuis le LCD
vers la routine “Setup” de l’algorigramme.

Figure 4-2: Méthode "print" du périphérique LCD

La méthode “print” est utilisée pour afficher du texte ou des nombres sur le LCD.

Pour spécifier le texte à afficher sur le LCD, cliquez droit sur le bloc “print” de l’algorigramme, puis
validez la commande "Editer" (ou, tout simplement, double cliquez sur le bloc). La boite de dialogue
suivante apparaît :

7
Si vous êtes curieux, voir https://en.wikipedia.org/wiki/Liquid-crystal_display pour plus d’information.
8
Produit avec l’image d’un LCD image depuis https://commons.wikimedia.org/wiki/File:Ensoniq_MR-
61_(LCD).jpg, Attribution-Share Alike 2.0 Generic licence. Non modifié sauf pour les labels ajoutés.

48
 Entrez le texte à afficher ici

Figure 4-3: Boite de dialogue de la méthode "print"

Le texte à afficher sur le LCD doit être entré dans le champ situé sous “Arguments”, où il est écrit “List
of numbers or strings to print”. Entrez le texte "Bienvenue !" (avec les guillemets):

Figure 4-4: Texte "Bienvenue !"

En programmation, un texte doit toujours être entouré de guillemets (" "). L’explication à cela est
donnée en section 4.5, mais, pour l’instant il faut admettre que c’est la règle.

Lorsque c’est terminé, cliquez sur “OK”. L’algorigramme devrait ressembler à ce qui suit :

Figure 4-5: Algorigramme "Bienvenue !"

49
Lancez la simulation (bouton “Play”) ; vous devriez voir le texte "Bienvenue !" s’afficher sur le LCD.

Figure 4-6: "Bienvenue !" affiché sur le LCD

Super ! C’est simple, non ?

Dans l’étape suivante du projet, nous allons afficher le texte "Compteur" sur la ligne du bas du LCD,
ainsi qu’un nombre à côté du texte. Le nombre sera incrémenté de 1 chaque seconde.

Pour afficher du texte sur la ligne du bas (sous le message “Bienvenue !”), nous devons disposer d’un
moyen pour indiquer à quel endroit nous voulons afficher du texte. Pour cela, nous utilisons la
méthode “setCursor” (positionne curseur) du périphérique LCD RGB de Grove. Glissez-déposez la
méthode “setCursor“ dans la routine Setup de l’algorigramme, après le bloc “print”. Puis, cliquez droit
sur le bloc “setCursor“ et sélectionnez la commande "Editer" du menu popup (ou double-cliquez deux
fois sur le bloc). Modifiez la valeur “Row” (ligne) à 1.

Figure 4-7: Boite de dialogue de la méthode setCursor

50
Notez que les valeurs associées à "row" (ligne) et "column" (colonne) commencent à ZERO. Ceci
signifie que la ligne du haut est la "ligne 0" et que celle du bas est la "ligne 1» ; la colonne la plus à
gauche est la "colonne 0" et celle la plus à droite est la "colonne 15".

Colonnes
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Lignes

0 B i e n v e n u e !
1

Afin d’afficher un texte au début de la seconde ligne du LCD, nous devons indiquer "row 1" et "col 0",
(Figure 4-7). Lorsque c’est fait, cliquez sur "OK".

Vous pouvez vous demander pourquoi nous n’avons pas eu à positionner le texte "Bienvenue !» ; la
réponse est que, au lancement, le LCD est configuré pour afficher du texte en haut et à gauche, donc
à la colonne 0 de la ligne 0.

Après avoir indiqué au LCD où nous souhaitons afficher le texte (en utilisant la méthode “setCursor“),
nous devons dire ce que nous voulons afficher à cet emplacement. Glissez-déposez une autre
méthode “print” dans l’algorigramme, après le bloc “setCursor“. Editez les propriétés du bloc (double-
cliquez sur lui), et spécifiez "Compteur:" (avec les guillemets), comme texte à afficher. Votre
algorigramme devrait ressembler à la figure qui suit :

Figure 4-8: Algorigramme avec le texte "Compteur:" ajouté

Lancez la simulation ; vous devriez voir le message "Compteur:" apparaître sur la ligne du bas (en plus
du texte “Bienvenue ! ” sur la ligne du haut).

51
 Figure 4-9: LCD avec "Compteur:"

4.2. Ajouter une variable dans le projet

Maintenant, nous allons ajouter un nombre à côté du texte "Compteur:". Ce nombre sera incrémenté
de 1 chaque seconde.

Si on revient sur l’exemple donné en début de chapitre, de la personne qui tient le compte du stock
dans une boutique, nous devons dire à l’ordinateur de se souvenir d’une valeur qui sera incrémentée.
Il faut également associer un nom à cette valeur, ainsi qu’une valeur initiale (lancement). C’est
similaire au nom d’un produit inscrit sur une feuille (tel que "melons") et la valeur qui lui est associée
(21 initialement). Le terme qui permet d’identifier le nombre est une variable.

Pour ajouter une nouvelle variable à un projet, glissez-déposez un bloc affectation ( ) dans
l’algorigramme, placé après le deuxième bloc “print” (Figure 4-10).

Figure 4-10: Insertion d’un bloc affectation

Ensuite, nous éditons ce bloc (clic droit et validez "Editer", ou double-cliquez sur le bloc affectation).

52
 Nom de la nouvelle variable

Type de la variable

Liste des variables

du programme

Cliquez ci pour créer

une nouvelle variable

Figure 4-11: Ajouter une nouvelle variable

En bas et à gauche de la boite de dialogue (zone "Variables"), cliquez sur "Nouvelle" pour créer une
variable. Entrez le nom "compteur" comme nom de variable (sans les guillemets9), comme indiqué
dans la figure ci-dessus (Figure 4-11). Le type est INTEGER (entier) - le type des variables sera présenté
rapidement, et cliquez sur “OK”.

Figure 4-12: Affectation d’une valeur à une variable

9
La raison sur l’utilisation des guillemets ou non est présentée en section 4.5.

53
Félicitations ! Vous avez créé une nouvelle variable qui s’appelle compteur. Elle doit apparaître dans
la liste des variables.

Toujours dans la boite de dialogue, dans le bloc "Affectation", sélectionnez la variable compteur dans
la liste déroulante, et entrez 0 dans le champ de droite. Ceci signifie que nous allons associer la valeur
0 à la variable compteur dans le bloc d’affectation. Terminez par un clic sur “OK”. Votre algorigramme
devient :

Figure 4-13: Algorigramme avec une affectation de variable

4.3. Types des variables

Dans la section précédente, nous avons créé une nouvelle variable et vous avez noté qu’il existait une
liste déroulante pour choisir un "type" de variable.

Figure 4-14: Boite de dialogue d’une nouvelle variable

54
Le type de variable indique le “type” d’information qui peut être stocké dans cette variable. Les types
possibles de variables dans le Visual Designer sont listés ci-dessous :

Type de variable Information qui peut y être sauvegardée

Boolean “Yes” ou “No” (“True” ou “False”).
Integer Nombre (nombres négatifs compris) - 1, 2, 3, 10, 5000, -5, -123, etc.
Float Nombre avec une partie décimale (nombres négatifs compris) - 3.1, -5.6, etc.
String Texte (une chaîne de caractères) - "Bienvenue !", "pourquoi pas"
Time Une date et une heure. Par exemple, 11:07:15 05/08/1983.
Handle (Sujet avancé. Un gestionnaire de ressource, tel qu’un fichier sur carte SD)

La raison pour laquelle il existe des types de variables différents est liée à la façon dont l’ordinateur
sauvegarde les informations en interne, ainsi que les opérations qui peuvent intervenir sur ces
variables. Ces sujets sont présentés succinctement ci-dessous, cependant, considérez que vous
pouvez simplement choisir le type de variable qui correspond le mieux à l’information que vous
voulez y stocker. Posez-vous la question de ce que vous voulez sauvegarder dans la variable ? Est-ce
un nombre ? Du texte ? Un choix entre “Oui” ou “Non” (“Yes” or “No”) ?

4.3.1. Opérations licites entre différents types de variables

Vous serez certainement d’accord pour dire que l’opération mathématique 5 + 5 a un sens – le résultat
est évidemment 10. Cependant, que se passe-t-il si on vous demande de calculer 5 + "Bonjour" ? Cela
n’aurait pas de sens. De la même manière, le type d’une variable détermine les opérations qui lui sont
applicables. Les nombres peuvent être ajoutés, soustraits, multipliés, divisés, etc. Les textes peuvent
être mis bout à bout ("Bonjour " + "Madame !" = "Bonjour Madame !").

Notez qu’il est possible d’avoir un nombre placé dans un texte – par exemple "Achète 5 pommes".
Dans ce cas, l’ordinateur considère que tout est du texte et traite le "5" comme une lettre plutôt qu’un
chiffre. En résumé, si deux nombres de valeur 5 sont ajoutés, la réponse est 10. Si deux chaînes qui
contiennent le texte "5" sont mises ensemble, alors la réponse est "55".

Notez également que certains langages de programmation utilisent le symbole "+"’ pour relier du
texte. Dans ce cas, ce n’est pas une opération mathématique et aucun des autres symboles
mathématiques (multiplier, diviser, etc) ne peut être appliqué au texte (à nouveau, cela n’aurait pas
de sens- quel serait le résultat de "bonjour" multiplié par "chat" ?).

4.3.2. Sauvegarde d’une variable dans un ordinateur

Ce paragraphe a été ajouté pour les curieux. Vous pouvez passer directement à la section 4.4 si la
lecture vous semble déroutante.

Il n’est absolument pas nécessaire, pour les besoins de conception d’un algorigramme, de comprendre
comment un ordinateur sauvegarde les variables. Cependant, voici une rapide explication sur une
autre raison quant à la nécessité de disposer de différents types de variables :

Imaginons que vous deviez remplir un formulaire qui contient une case pour chaque lettre :

55
 Nom:

Date de
naissance:
Note : Insérez une lettre ou un nombre par case

Vous serez capable d’entrer votre nom dans les cases disponibles (dans la limite du nombre de cases
disponibles), ce qui n’est pas possible pour la date de naissance qui ne contient que 3 cases ! Vous
avez besoin de 10 cases :

Date de / /
naissance:

Ainsi, vous pourriez y placer une date complète, telle que 05/08/1983.

De manière similaire, un ordinateur associe un certain nombre de cases mémoire à un type de

variable. Une variable booléenne ne peut recevoir que les états 1 ou 0 (interprétés comme “Yes” ou
“No” / “True” ou “False”) – vous ne pouvez pas y sauvegarder le nombre 972, car il n’y a pas assez de
place pour cela.

Comme nous l’avons déjà indiqué, aussi longtemps que vous choisissez simplement le bon type de
variable pour le type d’information que vous voulez y stocker, vous n’avez pas à vous soucier de
l’espace mémoire que réserve un ordinateur.

4.4. Utiliser des variables dans un projet

A ce stade, nous avons ajouté une variable "compteur" dans notre projet, que nous pouvons utiliser
dans notre programme.

Nous souhaitons effectuer les actions suivantes :

1. Incrémenter la valeur du nombre sauvegardé dans la variable "compteur" (ajouter 1).

2. Dire au LCD que nous voulons afficher une information (sur la bonne ligne et colonne, grâce à
la méthode "setCursor").
3. Dire au LCD d’afficher la valeur de la variable "compteur".
4. Attendre 1 seconde.
(Répéter)

Ceci est représenté par l’algorigramme qui suit :

56
 Figure 4-15: Afficher sur une LCD un nombre qui s’incrémente

4.4.1. Opérations mathématiques sur une variable

La première étape est d’incrémenter le compteur (ajouter 1).

Les opérations mathématiques sur les variables (tel que l’incrément) sont réalisées grâce à des blocs
"affectation" qu’il convient de glissez-déposer dans la routine Loop (pour un rappel, voir Figure 4-10
– excepté que, cette fois-ci, nous glissons le bloc dans la routine Loop au lieu de la routine Setup).

Puis, éditons le bloc “affectation“ (pour un rappel, voir section 4.2). Sous "Affectations", choisissez la
variable "compteur" dans la liste et entrez le texte "compteur + 1" (sans les guillemets10) à droite (voir
la figure qui suit).

Figure 4-16: Incrémenter une variable

Cliquez sur "OK". L’expression globale est compteur := compteur + 1 . Lorsque cette instruction est
exécutée, elle prend l’ancienne valeur de "compteur", lui ajoute 1 et sauvegarde la nouvelle valeur
dans la variable "compteur". Donc, si "compteur" valait 0, l’ordinateur lui ajoute 1 ; 0 + 1 égal 1, que
l’ordinateur sauvegarde à dans la variable "compteur". La prochaine fois que l’expression est
exécutée, "compteur" vaut 1, donc le calcul donne 1 + 1, égal à 2. La fois suivante, le résultat devient
2 + 1 qui est égal à 3, et ainsi de suite.

10
L’explication sur l’utilisation ou non des guillemets est présentée en section 4.5.

57
D’autres opérations mathématiques peuvent être définies – par exemple compteur := compteur - 1,
compteur := compteur + 5 ou compteur := compteur * 3 (multiplié par 3) – un résumé des opérateurs
mathématiques reconnus est listé en section 4.6.

4.4.2. Afficher la valeur d’une variable sur un LCD

Après l’incrément du compteur, nous allons afficher la valeur de la variable sur le LCD, mais, au
préalable, il faut positionner le curseur pour que l’affichage commence à la bonne position (méthode
"setCursor"). A ce stade, le LCD affiche déjà les informations suivantes :

Colonnes
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Lignes

0 B i e n v e n u e !
1 C o m p t e u r :

L’emplacement qui nous intéresse pour afficher la valeur de la variable "compteur" est la ligne 1,
colonne 9 (encadré en rouge). Glissez-déposez la méthode “setCursor“ dans l’algorigramme, après le
bloc d’affectation ajouté dans l’étape précédente. Puis, éditez le bloc “setCursor“ pour valider la ligne
1 et la colonne 9. Si vous avez besoin d’un rappel sur l’ajout et l’adaptation des propriétés de la
méthode “setCursor“, revoyez la section 4.1.

Ensuite, glissez-déposez une méthode "print" dans l’algorigramme, après la méthode “setCursor“ qui
vient d’être ajoutée. Editez le bloc "print" et entrez "compteur" (sans guillemets) dans la zone
"Arguments", comme illustré dans la figure suivante :

Figure 4-17: Entrer le nom d’une variable comme argument

Vous pouvez vous demander pourquoi nous entrons du texte sans ou avec guillemets dans la méthode
“print“ – ce point sera discuté en section 4.5, mais une réponse rapide est que le nom des variables
doit être entré sans les guillemets.

4.4.3. Compléter l’algorigramme pour afficher une variable sur le LCD

Nous voici à l’étape finale qui consiste à attendre 1 seconde avant de répéter le processus (autrement,
l’affichage serait si rapide que nous ne pourrions rien voir). Glissez-déposez un bloc d’attente ( )
dans l’algorigramme après le bloc “print“, et validez un temps d’attente de 1000ms (en éditant le bloc
attente).

Votre algorigramme devrait ressembler à celui de la Figure 4-15. Si ce n’est pas le cas, reparcourez les
étapes une à une pour vérifier.

Une fois prêt, lancez la simulation. Un nombre devrait être affiché à droite du texte "Compteur:".
Cette valeur doit s’incrémenter chaque seconde !

58
4.5. Utiliser du texte dans les arguments
Vous avez certainement noté que, lorsque nous avons affiché du texte sur le LCD, nous avons entouré
ce texte avec des guillemets (tel que “Compteur”), mais lorsque nous souhaitons afficher la valeur
d’une variable nous entrons le nom de la variable sans les guillemets (compteur). La raison à cela peut
s’expliquer par le problème suivant :

Que se passe-t-il si nous voulons afficher le texte "compteur" sur l’afficheur, plutôt que la valeur d’une
variable de nom "compteur" ? C’est un problème auquel les concepteurs des langages de
programmation sont confrontés et la solution qui a été choisie est de placer le texte entre guillemets
(“ “). Les guillemets ne font pas partie du texte – dans ce cas ils ne sont pas affichés sur le LCD –,
simplement ils aident le compilateur à différencier une variable d’un texte.

Variable Texte

4.6. Opérations mathématiques sur des variables

Comme nous l’avons vu lorsque nous avons incrémenté la variable compteur := compteur + 1, il est
possible d’effectuer des calculs mathématiques avec des variables. Les opérations mathématiques
suivantes sont possibles :

Symbole (Opérateur) Opération

+ Addition
- Soustraction
* Multiplication
/ Division
% Modulo11 (reste après la division)

Note : des opérations mathématiques plus complexes qu’un simple incrément de variable sont
possibles et des parenthèses peuvent être utilisées dans les équations. Par exemple, pour calculer
l’aire d’un triangle, qui se sert des variables "aire", "base" et "hauteur", l’équation suivante pourrait
être utilisée : aire = (base * hauteur) / 2 (“la surface est égale à la base multipliée par la hauteur, divisé
par 2”).

11
Notez que modulo (ce qui reste après une division) n’a rien à voir avec un pourcentage, bien que l’opérateur
retenu pour le langage "C" est le symbole pourcentage. Quelques exemples de modulo sont:
7 divisé par 2 est 3½ (trois et un demi) – ainsi 7 modulo 2 vaut 1, parce que 2 intervient 3 fois dans 7, et il reste
1 pour atteindre 7. Donc, 7 % 2 = 1.
31 divisé par 4 est 7¾ (sept trois quart) – ainsi 31 modulo 4 vaut 3, car 4 intervient 7 fois dans 31, et il reste 3
pour atteindre 31. Donc, 31 % 4 = 3.
D’autres exemples de module sont:
8 % 4 = 0, 11 % 3 = 2, 12 % 3 = 0, 13 % 3 = 1, 14 % 3 = 2, 8%7=1

59
4.7. Utiliser des variables dans des conditions
Les variables peuvent également servir à poser des questions (dans des blocs de décision, par
exemple). Dans la prochaine étape de notre projet, nous allons modifier notre algorigramme afin que
le texte “Valeur > 10 !” soit affiché sur la première ligne du LCD lorsque la variable "compteur" dépasse
10. L’algorigramme correspondant est détaillé dans la figure Figure 4-18: Algorigramme qui utilise une
variable dans un bloc décision:

Blocs ajoutés

Figure 4-18: Algorigramme qui utilise une variable dans un bloc décision

Les blocs d’algorigramme suivants ont été ajoutés (mis en surbrillance dans la Figure 4-18) :

1. Un bloc décision qui contrôle si la valeur de la variable compteur est supérieure à 10.
2. La méthode "home" du LCD, qui est équivalent à l’appel de la méthode “setCursor“, avec la
ligne et la colonne égales à 0.
3. La méthode “print” du LCD qui affiche le texte “Valeur > 10 !” sur le LCD.

Afin de mettre à jour notre algorigramme afin qu’il corresponde à celui de la Figure 4-18, commencez
par ajouter d’un bloc décision, sous le bloc d’attente de 1 s :

60
 Figure 4-19: Insérer un bloc « décision »

Cliquez droit sur le bloc « décision » et choisissez "Editer" dans le menu popup (ou double-cliquez deux
fois sur le bloc décision). Dans la boite de dialogue d’édition du bloc de décision, entrez "compteur>10"
(sans guillemets) dans la section "Condition" (comme illustré dans la figure suivante).

Figure 4-20: Insertion de la condition dans la boite de dialogue

Terminez par un clic sur “OK”. Ensuite, ajoutez les méthodes “home” and “print” du LCD dans
l’algorigramme. Editez le bloc "print” du LCD et insérez "Valeur > 10 !" sous "Arguments"’ (pour un
rappel sur la façon de procéder, voir la section 4.1). Permutez “Yes” et “No” du bloc de décision afin
que “Yes” corresponde à la Figure 4-18 (clic droit sur le bloc de décision et choisissez "Permuter
Oui/Non"’ du menu popup).

Lorsque c’est fait, lancez la simulation. Lorsque le compteur atteint 11, le texte “Valeur > 10 !” est
affiché sur la première ligne du LCD. (Si la simulation ne se passe pas comme prévu, veuillez vérifier
l’algorigramme pour qu’il soit identique à la Figure 4-18)

61
4.8. Opérateurs relationnels
Les opérateurs relationnels sont utilisés dans des conditions (tel que dans un bloc de décision) pour
poser une question dont la réponse peut être soit Oui (Yes), soit Non (No). Dans notre exemple, nous
posons la question "Est-ce que la valeur de la variable compteur est supérieure à 10 ? " (compteur >
10). D’autres opérateurs relationnels sont également disponibles et sont présentés ci-dessous :

Symbole (Opérateur) Opération (Question)

= Egal à?
!= Différent de?
> Supérieur à?
< Inférieur à?
>= Supérieur ou égal à?
<= Inférieure ou égal à?

4.9. Opérateurs logiques

Les opérateurs logiques peuvent servir avec les opérateurs relationnels pour poser des questions plus
complexes - ces opérateurs sont AND, OR et NOT. Par exemple, "La bouilloire bout ET (And) il y a une
tasse sur la table, alors verser le l’eau chaude dans la tasse". Des parenthèses peuvent également être
utilisées pour créer des conditions plus complexes. Il est donc possible d’associer plusieurs blocs de
décisions, mais ne vous inquiétez pas si vous ne les comprenez pas pour l’instant. Nous n’utiliserons
pas ce type d’expressions complexes dans ce document, mais elles sont présentées pour être
complets.

Symbole (Opérateur) Opération (Question)

&& And
|| Or
! Not

Par exemple, (distance > 5 && distance < 10) || (poids > 15) (“distance supérieure à 5 et distance
inférieure à 10, ou poids supérieur à 15?”).

4.10. Etape finale du projet

Pour la dernière étape, nous allons ajouter un bouton qui met la valeur de la variable compteur à 20
lorsqu’on appuie dessus.

L’algorigramme final, après ajout de cette fonctionnalité, est détaillé dans la figure suivante.

62
 Blocs ajoutés

Figure 4-21: Algorigramme final du projet

Pour mettre à jour votre algorigramme afin qu’il corresponde à la Figure 4-21, il faut effectuer les
étapes suivantes :

1. Ajoutez un “Momentary Action Push Button” – bouton d’action temporaire, (depuis la galerie
de périphériques Grove) dans le projet. Pour un rappel sur la façon d’ajouter un périphérique
au projet, voir la section 3.4.
2. Glissez-déposez le bouton ("B1") dans l’algorigramme, pour que soit inséré un bloc de décision
(voir Figure 4-21). Voir la section 3.5 pour un rappel sur la façon de placer un bouton dans
l’algorigramme.
3. Glissez-déposez un bloc d’affectation dans l’algorigramme. Placez-le et connectez-le comme
dans la Figure 4-21.
4. Editez le bloc d’affectation avec l’instruction "compteur := 20".
5. Commuter le "Yes" et "No" du bloc de décision, comme dans la Figure 4-21.

Lorsque c’est prêt, lancez la simulation. Appuyez et maintenez enfoncé le bouton que vous venez
d’ajouter (ne pas confondre le bouton Grove avec le bouton Reset), et vous devriez voir la valeur du
compteur sauter jusqu’à 20. Il est nécessaire de maintenir le bouton enfoncé, car l’état du bouton est
uniquement testé en haut de la routine Loop, et non lors de l’attente de 1 seconde, en bas. Donc, si
vous appuyez sur le bouton ou le relâchez pendant l’attente de 1 seconde, votre programme ne verra
pas que le bouton est enfoncé. Il existe des techniques pour repérer l’état du bouton et de le
mémoriser même si l’appui est très court. Cependant, ceci sort du cadre de ce chapitre. Si la simulation
ne fonctionne pas comme attendu, vérifier attentivement l’algorigramme pour qu’il soit identique à
celui de la Figure 4-21. Assurez-vous que vous appuyez sur le bouton Grove et pas le bouton Reset
(ceci sera présenté dans la section suivante).

63
 Bouton Reset

Bouton Grove
B

Figure 4-22: Bouton Grove vs. bouton Reset

4.11. Le bouton Reset

Le bouton Reset (mis en surbrillance dans Figure 2-24, Figure 2-25 et Figure 4-22) relance le
microcontrôleur.

Si vous appuyez dessus pendant la simulation, vous noterez que le compteur recommence à compter
à partir de la valeur 1 ; c’est parce que le programme reprend au début (la routine Setup est exécutée
une fois, puis c’est au tour de la routine répétitive Loop).

Ne confondez pas le bouton Reset avec tout autre bouton qui pourrait être utilisé dans le projet.

4.12. Prenez votre temps

Les variables sont un nouveau concept important. De plus, nous avons également introduit les
afficheurs LCD dans ce chapitre.

A moins d’avoir une expérience préalable en programmation, il vous faudra un peu de temps pour
assimiler les notions présentées et vous devrez peut-être relire à nouveau ce chapitre, pour être
certain de bien l’avoir compris.

64
5. Théorie des circuits électriques basiques et simulation
Bien que l’objet principal de ce document concerne le développement logiciel, il est nécessaire d’avoir
des connaissances de principe en électricité afin d’envisager la conception de systèmes électroniques.
Notre société actuelle nous plonge naturellement dans un environnement qui manipule des objets
électriques (commutateurs, batteries, modules électroniques tel qu’un téléphone, etc.). Cette section
parcourt certains concepts de base pour s’assurer que le lecteur les connait.

A présent, vous savez que Proteus permet de concevoir et de simuler des algorigrammes logiciels pour
microcontrôleurs. Cependant, il faut savoir que Proteus autorise aussi la simulation des circuits
électriques ou des composants électroniques. De nombreux projets exemples sont fournis avec le
logiciel qui démontrent des principes électriques de base. Afin d’être certain que possédez ces
connaissances, nous allons utiliser des exemples de projets pour démontrer ces principes.

5.1. L’environnement de saisie de schéma

Après avoir travaillé dans l’espace de travail relatif à l’onglet Visual Designer (conception
d’algorigramme) de Proteus, nous allons, maintenant et pour tous les chapitres suivants, nous
concentrer sur l’onglet de saisie de schéma.

La façon la plus simple de nous familiariser avec cet onglet est d’ouvrir un fichier exemple.
Commençons pas ouvrir le projet exemple “Basic Electricity 1”:

1. Sauvegardez ( ) tout projet existant ouvert (si vous ne voulez pas le perdre) – commande
"Enregistrer projet" du menu Fichier.
2. Cliquez sur le menu Fichier et sélectionnez la commande "Ouvrir projet exemple", ou cliquez sur
le bouton "Ouvrir exemple" de la page d’accueil de Proteus ( ). La fenêtre de parcours des
projets exemples devrait s’ouvrir (voir Figure 5-1).
3. Choisissez la catégorie “Interactive Simulation”.
4. Validez le projet “Interactive Simulation: Basic Electricity 1”.
5. Cliquez sur le bouton “Ouvrir” pour lancer le projet exemple.

La figure qui suit illustre la procédure présentée ci-dessus pour ouvrir le projet “Interactive Simulation:
Basic Electricity 1”.

65
 Choisissez le projet
Choisissez la catégorie Basic Electricity 1
project
Interactive simulation
category

Cliquez sur le bouton Ouvrir

pour lancer le projet
exemplesample project

Figure 5-1: Procédure d’ouverture de la simulation interactive – Projet exemple "Basic Electricity 1"

Lorsque le projet est ouvert, vous devriez voir le projet suivant s’afficher.

Aperçu du dessin
du schéma Zoom et panoramique

Zone d’édition du schéma

Eléments utilisés
dans le schéma

Dessin du circuit
électronique
Modes outils

“Play” (lancer la simulation)

Figure 5-2: Onglet saisie de schéma du projet exemple ouvert “Basic Electricity 1”

66
L’onglet relatif à l’éditeur et la façon de dessiner votre propre schéma sont décrits plus précisément
dans le chapitre suivant. Pour l’instant, il nous suffit de savoir comment ouvrir un projet, de le
parcourir (zoom et panoramique) et de lancer la simulation. Les opérations de zoom et panoramique
sont identiques à l’environnement du Visual Designer (algorigramme) – pour vous rafraîchir les idées
vous pouvez vous rendre au chapitre “Créer votre premier projet”.

5.2. Circuit électrique simple

Cette section suppose que le projet est toujours ouvert (si ce n’est pas le cas, ouvrez-le à nouveau).

Switch

Batterie Lampe

Figure 5-3: Diagramme du schéma “Basic Electricity 1”

Le circuit est constitué d’une batterie, d’un commutateur (switch) et d’une lampe. La batterie stocke
l’énergie électrique qui est utilisée par la lampe. Le commutateur permet de commuter la lampe entre
les états ON et OFF. Le circuit est simulable dans Proteus et il est possible d’interagir avec lui pendant
la simulation – c.a.d. que le commutateur peut être fermé ou ouvert par un simple clic sur lui. Pour
lancer la simulation, cliquez sur le bouton “Play” (triangle bleu) situé en bas et à gauche de la fenêtre
de l’éditeur de schéma.

Au lancement de la simulation, on peut voir que l’état du switch est fermé (ON), ce qui permet à
l’électricité de circuler de la batterie vers la lampe. La batterie possède donc le "potentiel" de fournir
de l’électricité.

On dit que le côté positif de la batterie possède un "haut potentiel" et le côté négatif un "bas
potentiel".

67
Une analogie peut être trouvée avec un barrage élevé (côté positif de la batterie) qui permet à l’eau
de circuler jusqu’à un barrage situé plus bas (côté négatif de la batterie), via une roue à eau (c’est la
"charge" qui, dans notre cas, est la lampe). Notez que la taille des barrages n’a pas d’importance. L’eau
coule du fait de la différence de hauteur entre les barrages, mais pas parce qu’ils sont grands ou petits.

La différence de potentiel (entre le haut et le bas) est notée "DDP".

En électricité, la grandeur qui mesure la différence de potentiel est la tension, mesurée en Volts.

Comme conséquence de cette différence de potentiel ou de "pression" exercée par la batterie,

l’énergie électrique qui passe dans la lampe est convertie en lumière (lorsque le switch est sur ON).
Dans le cas du switch ouvert (OFF), la lampe reste éteinte car l’électricité ne peut pas circuler à travers
elle.

5.3. Loi d’Ohm (tension, courant et résistance)

Considérons l’expérience suivante, qui utilise un seau relié à un tuyau, et un robinet placé au bout du
tuyau.
Seau rempli
Table d’eau
Tuyau Robinet

Chaise

Figure 5-4: Seau sur le sol (basse tension)

Figure 5-5: Seau sur la chaise (moyenne tension)

Figure 5-6: Seau sur la table (haute tension)

68
Si nous ouvrons le robinet et le laissons ouvert (sur le sol, sans y toucher), et que nous déplaçons le
seau du sol sur la chaise puis la table, nous constaterons que l’eau s’écoule de plus en plus vite. Pour
un robinet sur le sol, qui reste ouvert, plus le seau s’élève, plus l’eau s’écoule rapidement.

Il est également évident que, si nous laissons le seau à une hauteur fixe (la chaise par exemple), et que
nous fermons légèrement le robinet, l’eau s’écoule moins vite et réciproquement lorsqu’on l’ouvre.

Si nous adaptons cette expérience au domaine de l’électricité, nous obtenons les correspondances
suivantes :

- La Tension est la hauteur du seau. Plus la hauteur du seau est importante, plus la différence
de potentiel est élevée (hauteur entre le seau et le robinet). Notez que ce n’est pas la
contenance du seau qui compte mais sa hauteur par rapport au sol.
- La Résistance est le robinet. Si nous fermons le robinet, il résiste davantage au flux d’eau qui
le traverse, et si nous l’ouvrons alors il présente une résistance moindre à l’eau.
- Le Courant est la quantité d’eau qui sort du robinet – combien il en sort (en millilitres par
seconde, par exemple). Le courant permettrait de déterminer le temps qu’il faut pour remplir
un verre, par exemple. Moins de courant signifie qu’il faut plus de temps pour remplir le seau
et réciproquement.

La relation mathématique entre ces trois termes peut être illustrée par le diagramme suivant.

V Courant (I) = Tension (V) / Résistance (R)

Tension (V) = Courant (I) x Résistance (R)

I R Résistance (R) = Tension (V) / Courant (I)

Si la tension de change pas et que la résistance décroit, alors le courant augmente (et vice versa).
Si la résistance ne change pas et que la tension augmente, alors le courant augmente (et vice versa).

Vous pourriez vous demander ce que représente la quantité d’eau dans le seau. En électricité, la
quantité totale d’eau dans le seau peut être mesurée en "Coulombs" ou en "Ampères-Heure".
L’ampère est l’unité de mesure du courant, et sera présentée dans la section suivante. "Ampère-
heure" indique le temps (combien d’heures) pendant lequel la source peut fournir le courant indiqué.
Si nous revenons à l’exemple de l’eau, si nous fournissons 2 litres d’eau par heure pendant 3 heures,
alors la quantité totale d’eau fournie sera de 2 x 3 = 6 litres. Pour certaines batteries, on utilise l’unité
"Milliampères-heure".

Afin de démontrer la loi d’Ohm en simulation, ouvrez le projet exemple “Interactive Simulation: Basic
Electricity 2” (utilisez la procédure d’ouverture du fichier indiqué en section 5.1).

69
Ce projet de simulation interactive présente l’influence d’une résistance variable placée dans le circuit
à lampe de la section 5.2. Alors qu’un commutateur ne peut prendre que les deux états "on" ou "off",
une résistance variable est comparable à un robinet ou une valve qui se ferme plus ou moins, ce qui
permet de contrôler le flux qui passe dans le circuit.

Résistance
variable
Le courant Le courant
diminue. augmente.

Batterie Lampe
12 V 12 V

Figure 5-7: Schéma du circuit de "Basic Electricity 2"

Ce circuit est constitué d’une batterie 12V, d’une résistance variable et d’une lampe 12V. Selon la loi
d’Ohm, la "résistance (R) est inversement proportionnelle12 au courant électrique (I) qui la traverse
(plus la résistance augmente, moins de courant passe dans la résistance), à condition que la différence
de potentiel (V) aux bornes de la résistance reste constante".

Lorsque la simulation est lancée, la résistance variable est un élément interactif qui peut être ajusté
pour observer les effets d’une modification. Le courant électrique qui passe dans la lampe est
modifiable via les boutons ‘+’ et ‘–‘ de la résistance variable. On peut observer que si le courant
augmente, la lampe brille davantage. De la même façon, la lampe brille moins lorsque le courant
diminue. La simulation nous permet de conclure que l’intensité lumineuse de la lampe est
proportionnelle au courant électrique qui la traverse. Ceci est en accord avec la loi d’Ohm décrite
précédemment.

12
‘Inversement proportionnel’ signifie que lorsqu’une valeur augmente, l’autre diminue. Dans le cas de la loi
d’Ohm, si la résistance augmente alors le courant diminue.

70
5.4. Mesures électriques
De façon comparable au poids qui se mesure en kilogrammes et la distance en kilomètres, il existe des
unités spéciales pour mesure l’électricité. Ce sont :

Quantité mesurée Unité Symbole

Tension (V) Volts V
Courant (I) Ampères (ou ‘Amps’) A
Résistance (R) Ohms R ou Ω

Comme pour d’autres unités, un préfixe peut être ajouté avec un effet multiplicateur tel que ’kilo’,
‘milli’, etc. – par exemple 100 milli-amps (100mA) ou 10 kilo-ohms (10kΩ, souvent compacté sous la
forme 10k). Les projets "Mesurer une tension, un courant et une résistance" listés ci-dessous, incluent
des appareils de mesure de la tension (voltmètre) ou de mesure du courant (ampèremètre).

5.5. Autres circuits

D’autres exemples de circuits sont disponibles, que nous vous conseillons d’explorer en fonction de
vos intérêts. Les circuits listés ci-dessous illustrent les effets de résistances placées en série ou en
parallèle, ainsi que des versions plus élaborées des principes déjà présentés.

Project exemple Principe démontré

Basic Electricity 3
Basic Electricity 4
Basic Electricity 5
Basic Electricity 6
Basic Electricity 7
Measuring Voltage, Current and Resistance 1
Measuring Voltage, Current and Resistance 2
Measuring Voltage, Current and Resistance 3
Measuring Voltage, Current and Resistance 4
Measuring Voltage, Current and Resistance 5
Measuring Voltage, Current and Resistance 6
Measuring Voltage, Current and Resistance 7
Measuring Voltage, Current and Resistance 8
Measuring Voltage, Current and Resistance 9
Résistance série.
Résistance parallèle.
Circuits avec deux commutateurs (switchs).
Contrôle de la vitesse et de la direction d’un moteur
en utilisant des commutateurs (switchs) et une
résistance variable.
Faire ‘sauter’ un fusible en y faisant passer trop de
courant.
Mesure d’une tension au bornes d’une batterie et
d’une ampoule.
Utilisation de résistances en série comme diviseurs
de tension.
Utilisation d’un ampèremètre.
Utilisation d’un ampèremètre et d’un voltmètre.
Utilisation de résistances placées en parallèle
comme diviseurs de tension.
Présentation sur la façon d’ajouter des tensions en
série.
Loi d’Ohm.
Utilisation de résistances de valeurs différentes
pour diviser le courant.
Un potentiomètre (résistance variable) est ajouté
au circuit précédent.

D’autres exemples sont également disponibles. Ils présentent des concepts et des composants
électroniques tels que condensateurs, diodes, transistors, Ampli Op, portes logiques, circuits à logique
séquentielle, oscillateurs, etc.

71
6. Dessiner et simuler des circuits
Après avoir présenté des exemples de projets qui contiennent des circuits à simuler, ce chapitre vous
apprend à dessiner des circuits (schémas). En plus d’être une compétence utile à acquérir, ceci permet
de dessiner vos circuits personnels qui pourront interagir avec des microcontrôleurs et des
algorigrammes.

6.1. Pour les curieux, un résumé du processus de la conception en

électronique
Comme mentionné dans l’introduction, un schéma est un diagramme d’une électronique connectée.
Il montre ce qui est connecté et à quoi, mais pas exactement comment.

Dans le processus de conception en électronique, après avoir défini un schéma, le circuit est
généralement converti en un circuit imprimé (PCB - Printed-Circuit-Board), qui est un circuit physique
qui implémente les connexions "théoriques" spécifiées dans le schéma. Notez qu’il est évidemment
possible de créer plusieurs PCB différents à partir d’un même schéma. Ci-dessous, voici un exemple
de schéma avec un PCB possible qui en est déduit.

Figure 6-1: Exemple de schéma Figure 6-2: Exemple de sortie PCB Figure 6-3: Exemple de PCB

Lorsque le schéma est terminé, il est converti en un agencement de circuit imprimé (sortie PCB ou PCB
layout). La sortie PCB est ensuite transmise à un fabricant qui réalise le circuit imprimé physique. A ce
stade, le PCB contient uniquement les liens (fils) du schéma, sans les composants. Pour terminer, les
composants sont soudés sur le PCB.

Proteus peut être utilisé pour concevoir aussi bien des schémas que des PCBs. Cependant,
l’agencement du PCB sort du cadre de ce livre car nous utiliserons des circuits « tout-fait », tel un
circuit Arduino Uno.

(Astuce : En plus des informations données dans ce chapitre, un tutoriel sur la saisie de schéma et une
aide en ligne sont disponibles dans le menu ‘Aide’ de Proteus, lorsque l’onglet sur la saisie de schéma
est actif).

72
6.2. Généralités sur l’environnement de capture du schéma
Pour commencer, veuillez-vous assurer que vous avez un projet ouvert qui contient un schéma (par
exemple, ouvrez le projet exemple “Blinking LED for Arduino Uno” depuis le menu Fichier, dans la
catégorie "Visual Designer for Arduino").

Vue
d’ensemble
Zone d’édition

Sélecteur
d’objet
Schéma du circuit
électronique
Modes
outils

Figure 6-4: Onglet de la saisie de schéma de Proteus

L’onglet de saisie de schéma est constitué de trois zones principales ; la vue d’ensemble, le sélecteur
d’objets et la zone d’édition.

La zone d’édition correspond à l’espace où les composants sont placés et reliés ("wired-up"), afin de
construire le circuit électrique. Lorsque le nouveau projet Visual Designer est créé, Proteus ajoute
automatiquement la carte microcontrôleur (un circuit Arduino UNO dans notre cas) dans la zone
d’édition du schéma (illustrée dans la figure ci-dessus).

La vue d’ensemble fournit (comme son nom le suggère) une représentation d’ensemble du schéma.
Cependant, lorsqu’un nouvel objet est sélectionné dans le sélecteur d’objets, la vue d’ensemble est
utilisée pour prévisualiser l’objet sélectionné (nous reviendrons plus loin sur ce point).

Le sélecteur d’objets contient une liste de composants (tels que des boutons, LEDs, etc.) qui ont été
pris dans les bibliothèques pour être utilisés dans le projet / schéma (la procédure de sélection des
objets sera rapidement décrite). Si un autre mode outil est validé (diffèrent du mode sélection ou du
mode composant), alors le contenu du sélecteur d’objets s’adaptera à l’outil actif.

73
 Bouton sauvegarde
Outils de zooms
Barre horizontale
Mode sélection
d’outils
Mode

Barre
verticale
d’outils

Figure 6-5: Barres d’outils de la capture du schéma

L’onglet de saisie de schéma contient essentiellement deux barres d’outils ; une horizontale et une
verticale. La barre d’outils horizontale contient des boutons qui sont équivalents à des commandes du
menu ‘Fichier’ (tels que : Ouvrir un nouveau projet, sauvegarder un projet) ainsi que des outils (tels
que les zooms, etc.). La barre verticale contient tous les outils qui peuvent être utilisés pour dessiner
le schéma.

6.3. Prendre, placer et connecter les composants

6.3.1. Prendre les composants
Lorsque les composants dont vous avez besoin dans le schéma ne sont pas listés dans le sélecteur
d’objets, il convient de les chercher en bibliothèques. Commencez par valider le mode sélection ( )
ou le mode composant ( ) ; cliquez ensuite sur le bouton P placé au-dessus du sélecteur d’objets
(voir la figure qui suit) ou utilisez le raccourci clavier (touche "P" du clavier).

Cliquez sur l’icône du

bouton P (“prendre”) pour
accéder aux bibliothèques

Figure 6-6: Accès aux bibliothèques de Proteus

74
Les composants (tels que les LEDs, résistances, etc.) sont ajoutés au sélecteur d’objets après les avoir
sélectionnés en bibliothèques. Ils deviennent ainsi utilisables dans le schéma.

Recherche de composant
par mots-clés

Liste des composants disponibles

selon la catégorie sélectionnée
et/ou des critères de recherche

Différentes catégories
disponibles

Figure 6-7: Aperçu des éléments en bibliothèques

Un composant peut être trouvé, soit par recherche avec un mot clé, soit par sélection dans une
catégorie. Lorsqu’il est trouvé, le composant peut être ajouté à la liste du sélecteur d’objets par un
double-clic ou par sélection, puis un clic sur “OK”.

6.3.2. Placer les composants

Quand un composant a été ajouté au sélecteur d’objets, il peut être placé sur le schéma de la façon
suivante :
Boutons de contrôle
Mode composant tourner/pivoter avant placement

Prévisualisation du
Clic pour prévisualiser
composant
le placement

Cliquez à nouveau
pour valider le
placement

Choisir le composant

Figure 6-8: Placement du composant

1. Assurez-vous que le mode sélection ou le mode composant est actif.

2. Sélectionnez dans le sélecteur d’objets, le composant à ajouter au schéma.
3. Cliquez une première dois dans la zone d’édition du schéma. Une prévisualisation en magenta
du composant doit apparaître.
4. Déplacez la prévisualisation à l’endroit qui vous convient, et cliquez à nouveau pour valider le
placement.

75
6.3.3. “Référence”, “Valeur” et “Corps” du composant
Vous avez peut-être déjà noté que les composants possèdent un label, ajouté automatiquement. C’est
un nom tel que “R1” / “D1” / etc. Ce sont des "références" (ou "IDs" - identifiants) qui permettent
d’identifier de manière unique les composants (à la fois sur le schéma et sur le PCB). Les composants
possèdent également des "valeurs". Par exemple, une résistance peut avoir une valeur de “10k” (10
kilo-ohms). Le "dessin" du composant est appelé le "corps" (body).

Référence du composant Valeur du composant Corps du composant

Figure 6-9: Référence, Valeur et Corps du composant

6.3.4. Déplacement, rotation ou réflexion des composants

Une rotation ou une réflexion des composants est possible avant placement, en utilisant les contrôles
de la barre verticale d’outils ; une prévisualisation est affichée au-dessus du sélecteur d’objets. Après
placement, une rotation/réflexion peut être effectuée par un clic droit sur le composant, puis sélection
de l’opération souhaitée dans le menu popup. Une option de déplacement du composant est
également disponible dans le même popup ("Glisser objet").

Figure 6-10: Menu popup du composant, obtenu sur clic droit

Important : Notez qu’il est possible de déplacer les labels relatifs à la référence et la valeur d’un
composant indépendamment du composant lui-même. Cette possibilité peut être une source de
grande frustration si vous tentez de déplacer la totalité du composant et pas simplement le label !
Pour déplacer la totalité du composant, assurez-vous de cliquer sur le corps du composant (

Figure 6-9).

Une autre méthode pour déplacer des composants, lorsque le mode de sélection est actif, est de
commencer par les sélectionner en cliquant sur eux ou en étirant un rectangle de sélection autour
d’eux (les objets sélectionnés seront repérés en ROUGE – voir Figure 6-11), puis par un clic et un
déplacement à la nouvelle position.

76
 Figure 6-11: L’objet sélectionné (repéré visuellement en rouge) est prêt à être déplacé

Les composants peuvent être supprimés ou retirés du projet grâce à un clic droit pour faire apparaître
le menu popup (Figure 6-10), or par un double-clic sur eux.

A présent, nous vous invitons à tester les méthodes de placement, déplacement, suppression,
rotation/miroir de quelques nouveaux composants.

(Astuce : Certains composants, tel qu’un "BOUTON", possèdent une aire d’interaction ; comme cela a
été vu dans les chapitres précédents ; c’est-à-dire que nous pouvons simuler l’action sur un bouton en
cliquant sur lui. Ceci peut rendre ces composants difficiles à sélectionner car le fait de cliquer sur eux
provoquera une interaction au lieu d’une sélection. La solution est soit de cliquer droit sur le
composant puis de choisir la bonne action dans le menu popup, soit d’étirer un rectangle de sélection
autour du composant)

6.3.5. Editer la référence et la valeur d’un composant

La référence et la valeur d’un composant peuvent être éditées par un clic droit sur le composant, puis
en choisissant "Editer propriétés" du menu popup ; ceci fera apparaître la boite de dialogue d’édition
du composant (Figure 6-12).

Référence de l’élément ou“ID”

Valeur de l’élément

Figure 6-12: Boite de dialogue d’édition du composant

Notez que vous devez cliquer sur le "dessin" ou "corps" du composant (

77
Figure 6-9), plutôt que sur le texte référence ou le texte valeur, afin de faire apparaître la boite de
dialogue d’édition du composant. Un clic sur les textes ‘référence’ ou ‘label’ fera apparaître la boite
de dialogue d’édition du texte sélectionné, limitée à l’édition du label.

Un clic gauche sur un composant déjà sélectionné (en rouge) ouvrira la boite de dialogue d’édition du
composant. Donc, un double-clic sur un composant quelconque non sélectionné, est le raccourci pour
appeler la boite de dialogue d’édition du composant.

Proteus incrémente automatiquement la référence des composants nouvellement placés pour

s’assurer qu’ils possèdent une référence unique, ce qui évite de devoir les modifier manuellement
(par exemple, R1, R2, R3, etc.).

Rien de vous empêche d’éditer la valeur, par exemple, afin de la modifier (telle que la valeur d’une
résistance ou d’un condensateur).

6.3.6. Créer des connexions électriques entre les composants (“Wiring Up”)
Lorsque les composants nécessaires ont été ajoutés (placés) sur le schéma, ils peuvent être
électriquement reliés entre eux (“wired up”).

6.3.6.1. Routage “Suivez-moi”

Le routage de fil "suivez-moi" est disponible dans tous les modes outils. Les composants possèdent
des broches ("pin"), facilement repérables mais qui peuvent être vérifiées en plaçant le pointeur souris
au-dessus d’elles.

Lorsque la souris se superpose à une broche, alors un crayon vert ( ) apparaît, qui indique qu’un fil
peut être dessiné depuis/vers ce point. Une connexion est lancée par un clic sur un point de départ,
puis par un clic sur un point d’arrivée. La figure suivante illustre la procédure :

Clic gauche sur le point

de départ– dans notre
cas, la broche inférieure Déplacez le curseur
de la résistance. souris dans la
direction de la
broche d’arrivée
Un clic gauche sur la
broche termine la
connexion – dans
notre cas, la broche
supérieure de la LED

Figure 6-13: Créer une connexion électrique– départ vers arrivée

(Astuce : Il est possible de cliquer le long du chemin qui relie le point de départ à celui d’arrivée. Cela
créera des points d’ancrage intermédiaires qui permettent de définir un parcours quelconque. Ces

78
points d’ancrage peuvent ensuite être manipulés/déplacés de façon habituelle. Un lien peut
également être supprimé via la commande correspondante du menu popup sur clic droit ou par un
double-clic sur lui)

6.3.6.2. Créer des connexions avec des terminaux

Le fait d’avoir des multiples liens de connexions sur un schéma peut contribuer à le rendre confus et
illisible. Une méthode alternative pour créer des connexions entre deux broches est d’utiliser des
objets "Terminaux".

Les terminaux sont considérés comme électriquement connectés s’ils ont le même nom. Ceci permet
d’établir un lien électrique sans avoir à dessiner une ligne entre les broches. La Figure 6-14 illustre une
connexion par terminaux entre la broche PB5/SCK/PCINT4 d’un microcontrôleur Arduino Uno, et la
résistance placée à côté de la LED (le terminal est nommé "IO13"’). La connexion permet de faire
clignoter la LED de notre premier projet.

Connexion avec
des terminaux

Terminal défaut

Terminal alimentation
Point de jonction Terminal masse

Figure 6-14: Connexions entre broches avec des terminaux

Un point terminal peut être placé sur le schéma en utilisant le mode "Terminal" ( ) disponible dans
la barre verticale d’outils (Figure 6-15).

79
 Mode Terminal

Figure 6-15: Mode Terminal

Placer des terminaux est comparable au placement des composants (sauf qu’il n’est pas nécessaire de
prendre des terminaux dans une bibliothèque, au préalable).

Divers types de terminaux sont disponibles, sachant que les trois types les plus utilisés sont Default,
Power (alimentation) et Ground (masse).

Les terminaux Power ( ) et Ground ( ) sont automatiquement reconnus pas Proteus comme
sources d’alimentation. Notez que vous n’avez pas l’obligation de dire à Proteus d’où provient
l’alimentation (d’une batterie / plug / générateur / etc. – la source exacte n’a pas d’importance pour
le projet ou les besoins de simulation). Les terminaux Power sont connectés à +5V (5 volts) par défaut,
et les terminaux Ground sont connectés à 0V (zéro volts) par défaut. L’origine du terme "Ground"
provient de la pratique de relier le cuivre à la terre, donc Ground signifie 0V (zéro volts). La tension
d’un terminal power peut être modifiée de la même façon qu’une référence ou la valeur d’un
composant – par un clic droit sur le terminal, puis sélection de "Editer propriétés" du menu popup, ou
par un double-clic sur le terminal.

Figure 6-16: Editer le label du terminal

Les terminaux se connectent de façon habituelle (section 6.3.6.1) aux broches des composants. Notez
que lorsque les broches de deux composants ou terminaux sont superposées, cela ne signifie pas
qu’elles sont connectées – un lien explicite doit les relier !

Une autre façon de placer un terminal (ainsi qu’un composant) sur le schéma est d’effectuer un clic
droit dans une zone vierge de la zone d’édition, puis d’appeler la commande Placer –> Terminal du
menu popup (Figure 6-17).

80
 Figure 6-17: Ajouter un terminal dans le schéma via le menu popup sur clic droit

6.3.6.3. Points de jonction

Un point de jonction représente un point où deux fils sont reliés. Les liens qui se coupent sans qu’un
point de jonction existe, ne sont pas considérés comme reliés.

Point de jonction – fils reliés

Les fils se croisent – fils

non reliés

Figure 6-18: Points de jonction

Les points de jonction sont créés automatiquement lors du processus du routage "Suivez-moi" (en
routant un fil sur un autre). Ils peuvent être aussi explicitement placés grâce au menu popup sur clic
droit ou par validation du mode Point de jonction ( ) de la barre verticale d’outils.

6.4. Dessiner et simuler un schéma personnel

Dessinons et simulons un circuit personnel.

81
 Figure 6-19: Le circuit du schéma à dessiner

Dessiner ce schéma permettra de mettre en pratique les concepts présentés dans ce chapitre et
donnera l’occasion de simuler les principes relatifs à loi d’Ohm, appris dans le chapitre précédent.

Pour dessiner le schéma illustré dans la Figure 6-19, veuillez suivre les étapes suivantes.

1. Sauvegardez ( ) tout travail ouvert pour ne pas le perdre, puis fermez ( ) tout projet
ouvert (Commande "Fermer projet" du menu Fichier).

2. Cliquez sur l’icône de l’éditeur de schéma ( ) pour ouvrir l’onglet de saisie de schéma (vous
pourriez également lancer un nouveau projet via l’assistant, mais notre choix est ici un
raccourci rapide).

3. Prenez les composants suivants dans la bibliothèque ‘composants’ (voir la section 6.3.1 si vous
avez besoin d’un rappel sur la façon de chercher et prendre des composants en bibliothèques
– en mode Composant ( ), cliquez sur le bouton au-dessus du sélecteur d’objets). La
méthode la plus simple pour trouver les composants est d’entrer leur nom dans le champ
"mots-clés".
a. RES (Résistance)13.
b. POT-HG (Potentiomètre).
c. SW-SPST (Switch).

4. Placez les composants et les terminaux (un terminal Power et un Ground) sur le schéma.

5. Validez le mode "Instruments virtuels" ( ) de la barre d’outils verticale, et placez un

ampèremètre DC et 2 voltmètres DC sur le schéma (ils seront listés dans le sélecteur d’objets
lorsque le mode Instruments virtuels est actif).
6. Modifiez les propriétés suivantes des composants / terminaux / instruments :
a. Définir le terminal power à +5V.
b. Définir la valeur de la résistance à 1k.

13
Vous pouvez obtenir un grand nombre de résultats lorsque vous recherchez “RES”. Si vous entrez RES (sans
les guillemets) sous "Mots-clés", seul le composant RES sera sélectionné par défaut. Un clic sur OK permet de
l’ajouter (ou appuyez deux fois sur la touche Entrer du clavier).

82
 c. Modifiez la gamme d’affichage de l’ampèremètre DC à "Milliamps" (depuis la boite de
dialogue d’édition du composant, dans la liste "Display Range").

7. Déplacez et tournez les composants comme nécessaire, puis connectez le tout afin que votre
schéma corresponde à la figure précédente.

8. Sauvegardez votre travail ! (Le nom du projet pourrait être "SimpleCircuit", s’il n’a pas déjà
été nommé)

Nous sommes prêts à simuler le circuit. Ce circuit nous permet d’expérimenter les principes de
tensions, courants et résistances décrits dans le chapitre précédent.

(Astuce : Si vous souhaitez que le circuit contienne des flèches qui indiquent le sens du courant,
procédez de la façon suivante : Lorsque la simulation est stoppée, cliquez sur le menu "Système",
sélectionnez les Options d’animation, cochez les options "Voir tension du fil en couleur ?" et "Voir sens
du courant avec des flèches ?", puis validez avec ok – lorsque la simulation sera lancée à nouveau, les
flèches apparaîtront)

83
7. Dessiner vos périphériques
Jusqu’à présent nous avons toujours utilisé des circuits prêts-à-l’emploi dans nos projets
d’algorigramme. Pour ces circuits, Proteus insère automatiquement le circuit du microcontrôleur dans
le schéma au lancement d’un nouveau projet, ainsi que le circuit des périphériques (boutons, LED,
LECD, etc.) qui sont ajoutés depuis la galerie de périphériques du Visual Designer. Ceci reproduit la
méthode de prototypage rapide des cartes (comme le cas de la connexion d’une carte Arduino Uno à
un système Grove), utilisées pour construire un projet du monde « réel ».

Cependant, il est possible de construire ses propres circuits afin qu’ils interagissent avec un
microcontrôleur

LEDs
Fils de liaisons

Microcontrôleur

Résistances

Carte Arduino Uno

Carte de connexion

Figure 7-1: Montage expérimental en fils volants (Breadboarding)14

La figure précédente semble compliquée, mais ne vous inquiétez pas – le dessin des circuits dans
Proteus est moins confus et source d’erreurs (telles que de connexions non correctes). Il est également
plus simple à déboguer si un problème est rencontré.

Une plaque d’expérimentation du montage de la figure ci-dessus (breadboard) est un circuit plastique
troué, qui est électriquement connecté selon un certain motif. Les composants et les fils de jonction
sont insérés dans les trous pour constituer le circuit. D’autres possibilités de prototypage existent,
mais ces explications sortent du cadre de ce document. Notre explication se concentre sur la

14
Image de montage en fils volants (Breadboarding) depuis http://learn.adafruit.com/adafruit-arduino-lesson-
4-eight-leds/overview, Attribution Creative Commons license, non modifiée sauf pour les labels ajoutés.

84
conception d’un schéma et sa simulation avec Proteus mais sachez que de nombreuses ressources
existent pour réaliser vos circuits.

7.1. Présentation du projet de séquencement des LEDs

Dans ce chapitre, nous allons dessiner un circuit et construire un algorigramme qui séquence des LEDs
(les LEDs s’allument les unes à la suite des autres). Nous allons également contrôler la vitesse de
séquencement grâce à un potentiomètre (résistance variable). Le circuit final est illustré dans la figure
suivante (notez que la représentation est plus claire que celle du circuit en fils volants).

Terminaux des
broches numériques

Circuit Arduino Uno (inséré

automatiquement)

Potentiomètre
pour contrôler
la vitesse de
séquencement

5 x circuits LED

Figure 7-2: Circuit de séquencement des LEDs

7.2. Dessiner le circuit

(Astuce : Si vous être bloqué lors du dessin du schéma, ou pour vous remémorer certaines notions,
revenez au chapitre 6)

1. Pour commencer, lancez un nouveau projet algorigramme Arduino Uno. Pour un rappel, voyez
les sections 2.2, 3.3 ou 4.1 (n’oubliez pas de sauvegarder ( ) tout travail en cours afin de ne
pas le perdre, de fermer ( ) tout projet ouvert, et de sélectionner "Nouvel algorigramme"
depuis l’écran d’accueil ( )). Le projet peut s’appeler “SequenceLEDs“.

2. Commutez sur l’onglet de l’éditeur de schéma ( ).

3. Prenez les éléments suivants dans la bibliothèque de composants (les autres composants dont
nous aurons besoin devraient déjà être dans le sélecteur d’objets). Petit rappel de la section
6.3.1 (en mode composant ( ), cliquez sur le bouton placé au-dessus du sélecteur
d’objets ; puis utilisez le champ Mots-clés pour chercher en bibliothèques).

a. LED-RED (LED rouge)

b. POT-HG (Potentiomètre / Résistance variable)

85
 4. Placez les composants et les terminaux comme indiqué en Figure 7-2; connectez-les, et
configurez les valeurs. Ces actions impliqueront les éléments suivants :

a. Placer 5 x LEDs rouges (LED-Red).

b. Placer 5 x résistances (RES).
c. Placer 1 x potentiomètre / résistance variable (POT-HG).
d. Placer 6 x terminaux DEFAULT.
e. Placer 1 x terminal POWER and 2 x terminaux GROUND.
f. Connectez le tout, comme décrit en Figure 7-2.
g. Nommez les 5 x terminaux DEFAULT qui sont connectés aux LEDs de IO3 à IO7 (IO3,
IO4, IO5, IO6, IO7). Notez que les noms sont constitués des lettres ‘I’ et ‘O’ (pour
input/output), puis des nombres 3 à 7. Voir la section 6.3.6.2 / Figure 6-16 pour un
rappel (clic-droit sur le terminal, puis ‘Editer les propriétés du menu popup’ – entrez
le label du terminal / nom et cliquez sur OK). Le fait de nommer ces terminaux IO3 à
IO7 les connecte aux terminaux correspondants des broches du circuit Arduino Uno.
h. Nommer le terminal DEFAULT qui est connecté au potentiomètre ‘AD0’. Notez que le
nom est constitué des lettres "a" et "d" (pour analog/digital) suivies du nombre 0
(zéro).
i. Définir le terminal POWER à +5V (voir section 6.3.6.2 / Figure 6-16 si vous avez besoin
d’un rappel).
j. Changez les valeurs (résistances) des résistances à 330R (pour 330Ω, mais il est plus
simple de taper ‘R’ car la plupart des claviers ne possèdent pas la touche ‘Ω’). Voir la
section 6.3.5 / Figure 6-12 pour un rappel sur la façon de modifier la valeur. Si vous
vous demandez s’il existe des façons plus simples de modifier la valeur des résistances
(plutôt que de la faire manuellement une par une), alors la réponse est OUI ; il suffit
de construire un premier couple LED-résistance, puis de le dupliquer (voir la section
suivante), ou d’utiliser un outil appelé "Outil d’affectation de propriété" qui permet
d’affecter des valeurs à toutes les résistances. Utiliser l’outil d’affectation de propriété
("PAT") sort du cadre de ce document, sachant que l’aide sur l’éditeur de schéma de
Proteus explique cela en détail. Pour l’instant, la solution la plus simple consiste à
éditer et modifier chaque valeur à la suite (il n’y en a que 5 à modifier).

7.2.1. Possibilités de copier et coller

Proteus intègre les possibilités traditionnelles de copier-coller, que ce soit pour les composants isolés
ou les blocs de composants. Pour utiliser le bloc "copie" ( ), disponible dans la barre d’outils
horizontale, commencez par sélectionner le circuit à copier. Pour cela, assurez-vous que le mode de
sélection est actif ( ), puis étirez un rectangle autour du circuit à copier ; celui-ci sera mis en
surbrillance de couleur rouge. Ensuite, cliquez sur le bouton de copie de bloc (ou clic-droit sur le circuit
en surbrillance et validez la commande "Copier bloc" du menu contextuel). Un aperçu en magenta de
la copie apparaîtra– déplacez-le à l’emplacement souhaité et cliquez pour finaliser son placement.

86
7.3. Les circuits LEDs
Voyons comment le circuit fonctionne et pourquoi il comporte une résistance.

Terminal connecté
à la broche 7 d’une
Arduino UNO
Terminal GROUND

Figure 7-3: Circuit LED

Le principe de base est le suivant : Lorsque la carte Arduino Uno valide une broche de sortie à l’état
haut (“on” ou “true”) dans l’algorigramme, ceci génère une tension de sortie de 5 volts sur cette
broche. Comme il existe une différence de potentiel entre la broche de sortie (5 volts) et la masse (0
volts), l’électricité passe de cette broche à travers la LED et la résistance (ce qui allume la LED). Dans
la situation contraire, lorsque la broche est mise à l’état bas (“off” or “false”), ceci génère une tension
de sortie de zéro volt sur cette broche. Aucune différence de potentiel n’existe entre le 0 et la masse
(0 volt), donc aucun courant ne passe et la LED s’éteint. Les LEDs sont des diodes auxquelles il faut
associer une résistance afin de limiter le courant qui les traverse. La résistance peut être placée avant
ou après la LED, cela n’a pas d’importance. Ceci est comparable à un tuyau dans lequel circule de l’eau.
Vous pouvez contrôler la quantité d’eau qui passe dans le tuyau en plaçant un robinet à l’une des
extrémités.

Mathématiquement, le courant qui passe dans le circuit est donné par la formule I = V / R (voir section
5.3). Comme la LED n’est pas résistive, la quantité de courant (I) qui passe dans le circuit est donnée
par la tension (5V de la broche Arduino) et la résistance du circuit (330R). Sans la résistance, le courant
serait important et provoquerait une détérioration de la LED (fumée).

7.4. Electronique analogique et numérique

Dans la section précédente nous avons connecté les LEDs à "IO3’- ‘IO7" (qui signifie input/output 3 à
7), et nous avons relié le potentiomètre (résistance variable) à "AD0" (qui signifie analogue/digital
zéro).

L’électronique numérique (digital) se réfère à un système qui se pense en termes de 0 et de 1 – "on"

ou "off" ("true" ou "false"). Dans un microprocesseur, les choses fonctionnent de la même façon. Pour
une carte Arduino, ceci correspond à 5 Volts ("on" / "true" / "high") et 0 Volt ("off" / "false" / "low").

L’électronique analogique peut prendre n’importe quelle valeur– ce pourrait être 1 volt, 2.5 volts, 3
volts, etc.

Techniquement (c’est le cas pour une Arduino Uno), tout ce qui inférieur à 1.5V sera considéré comme
"zéro", et tout ce qui est supérieur à 3V correspondra à "un" – entre ces deux tensions, la valeur est
"indéfinie" (elle peut prendre l’un quelconque des deux états), et tout ce qui est en dehors des limites
peut endommager le microcontrôleur.

87
7.4.1. Convertisseurs analogique-numérique
Comme le microprocesseur ne comprend que des uns et des zéros, il existe un périphérique interne
appelé "analogue to digital converter" (ADC) ou convertisseur analogique-numérique (CAN) en
français. Ce convertisseur accepte une tension analogique en entrée et la transforme en des uns et
des zéros que le microprocesseur peut comprendre.

Sans plus d’explications dans la représentation des nombres binaires (dans ce système de numération,
les nombres sont tous représentés par une suite de 1 et 0), il suffit de comprendre qu’un ADC convertit
la tension analogique en un nombre interne au microcontrôleur.

Ce nombre ne correspond pas exactement à la tension (c.a.d., ce n’est pas "1" pour 1 volt ou "5" pour
5 volts); mais c’est plutôt une échelle où la tension est comprise entre deux points de référence.
Comme une carte Arduino Uno fonctionne en 5 volts, le maximum de l’échelle est 5V et le minimum
est 0V.

Le plus grand nombre que peut produire notre convertisseur est 1023. Cette valeur correspond à 5
volts (c’est la résolution de l’ADC – la précision avec laquelle les tensions sont mesurées). Donc, pour
une tension analogique de 5 volts, l’ADC donnera un nombre de 1023. Pour zéro volt (0V), le nombre
sera zéro (0). Pour 1 volt ce serait 205. Pour 2.5V ce serait 512, 3V serait 614, et ainsi de suite.

Ceci peut être représenté par l’équation suivante : Sortie_ADC = (Tension_Entree / 5) x 1023.

Dans le monde électronique, différentes résolutions ADC et références de tensions existent, mais pour
notre propos relatif à une Arduino Uno, les nombres et l’équation indiquée sont applicables.

7.4.2. Utiliser un potentiomètre pour générer une tension analogique en entrée

Le potentiomètre de notre circuit est utilisé pour générer une tension analogique en entrée qui nous
servira pour valider la vitesse de séquencement des LEDs.

Dans le monde réel, un potentiomètre est habituellement un bouton rotatif.

Figure 7-4: Potentiomètre avec bouton rotatif Figure 7-5: Plusieurs boutons potentiomètres sur un
dispositif électronique15

15
https://commons.wikimedia.org/wiki/File:Audio_SwitchBoxTwo_(With_Volume_Knobs)_(2011-10-
08_by_Kevin_B_3).jpg

88
Techniquement, le potentiomètre est un circuit « diviseur de tension ». Selon la loi des résistances en
série (résistances placées les unes à la suite des autres), la tension aux bornes de chaque résistance
est divisée proportionnellement à la valeur de chacune d’elles. Ceci est illustré dans le chapitre
consacré à la "Théorie et simulation de circuits électriques de base" ainsi que dans le circuit construit
dans le chapitre "Dessiner et simuler des circuits".

Une autre façon d’exprimer cela est de dire que la tension issue du potentiomètre varie linéairement
entre la valeur maximale et la valeur minimale.

Basse pression

Moyenne pression

Haute pression
pressure

Figure 7-6: Circuit potentiomètre Figure 7-7: Expérience de pression d’eau

La Figure 7-7 décrit une expérience avec de l’eau qui peut illustrer notre propos. L’eau est placée dans
un container (tel qu’une bouteille de grande hauteur) avec des trous uniformément répartis le long
de la bouteille. La pression d’eau en bas du container est supérieure à la pression en haut du container
(car le "poids" de l’eau est supérieur). Pour tout point intermédiaire entre le point haut et le point bas,
la pression se situe entre ces deux valeurs. En termes électriques, la différence de potentiel (la
"pression" électrique) est répartie uniformément entre le haut et le bas. Notez, cependant, que la
pression d’eau est déterminée par la gravité et que la pression sera toujours plus grande en bas du
container, alors que la pression électrique est déterminée par la tension qui ne dépend que de la façon
dont nous dessinons le circuit. Dans la Figure 7-6, la pression haute (+5 volts) est en haut, tandis que
la pression basse (masse, ou 0 volts) est en bas (c’est l’opposé de l’expérience de la bouteille d’eau).
Lorsque le potentiomètre est connecté à notre circuit, il fournira une tension analogique en sortie,
comprise entre zéro et cinq volts. Cette tension sera une entrée pour le convertisseur analogique-
numérique (ADC) de notre microcontrôleur Arduino Uno.

89
7.5. Entrées et Sorties (Inputs / Outputs)
Les broches d’un microcontrôleur peuvent "écouter" (entrées) ou "parler" (sorties). Par défaut (c’est-
à-dire à la mise sous tension), les broches (pins) "écoutent". Si nous souhaitons que certaines broches
deviennent des sorties, pour contrôler nos LEDs par exemple, nous devons manuellement dire au
microcontrôleur de les configurer comme telles. Ceci est réalisé en utilisant la méthode "pinMode"
disponible dans le périphérique cpu.

Figure 7-8: Méthode "pinMode" du périphérique cpu

Lorsque la broche a été positionnée en sortie (via la méthode pinMode), nous pouvons la commuter
en ‘on’ ou ‘off’ en utilisant la méthode "digitalWrite", également disponible dans le périphérique cpu.

Figure 7-9: Méthode "digitalWrite" du périphérique cpu

Souvenez-vous que, pour un microcontrôleur, “TRUE” a la même signification que “On” (ou “High”) –
dans notre cas "sortie 5V"; et “FALSE” signifie “Off” (ou “Low”) – c’est à dire "sortie 0V".

90
7.6. L’algorigramme
Interconnexion

Bloc d’interconnexion

Figure 7-10: Algorigramme de séquencement des LEDs

La Figure 7-10 décrit l’algorigramme de notre projet. A ce stade, nous allons étudier comment il
fonctionne et il n’est pas nécessaire de le dessiner.

Les étapes du programme sont:

1. Configurer en sortie toutes les broches (pins) reliées aux LEDs. Pour cela, nous utilisons la
méthode pinMode (section 7.5) – Un bloc par broche à configurer en sortie. Les blocs sont
placés dans la routine Setup, car cette action n’intervient qu’une fois au lancement. Notez
que la broche qui reçoit la tension du potentiomètre n’a pas besoin d’être configurée en
entrée, car toutes les broches sont des entrées par défaut.
2. Dans la routine Loop, nous commençons par positionner toutes les LEDs à "off". Pour cela,
des blocs digitalWrite valident l’état de chaque broche à "FALSE" ("Off").
3. Ensuite, nous lisons la valeur analogique de la broche connectée au potentiomètre (broche
analogique 0, ou AD0), et nous la mémorisons dans la variable appelée "ain" (nom choisi

91
 comme la contraction de analog-input ou entrée analogique). Ceci est fait dans le bloc
"analogRead" (la méthode est disponible dans le périphérique cpu).
4. Après un saut via "Interconnect" (nous reviendrons sur ce point rapidement), l’étape suivante
est d’attendre. Le temps d’attente est celui de la valeur de la variable "ain", liée à la tension
du potentiomètre. Après cette attente, nous allumons la première LED (commutons sur TRUE,
avec la méthode digitalWrite). Le processus "attendre-commuter-allumer” est répété pour
chaque LED (de la broche 3 à la broche 7).
5. Enfin, le programme reprend automatiquement au début de Loop. Les LEDs sont éteintes à
nouveau– ce processus se répète indéfiniment.

Certains points doivent être notés à propos de notre algorigramme / programme :

- Des blocs commentaires ont été ajoutés pour aider le lecteur à comprendre comment le
programme est organisé. Ces blocs commentaires n’affectent pas le fonctionnement du
programme, ce sont des "notes" destinées à une personne.
- L’algorigramme contient un bloc "interconnect". Cette fonctionnalité est intéressante lorsque
l’algorigramme est trop long pour être contenu en totalité dans une page / feuille. Le bloc
d’interconnexion permet de le découper en plusieurs parties. La procédure pour faire cela est
illustrée dans la figure suivante.

Figure 7-11: Scinder un algorigramme en deux parties grâce à des blocs d’interconnexions

- Des blocs d’interconnexion de même numéro sont considérés comme reliés. Des blocs
d’interconnexions peuvent être insérés par un clic droit sur la ligne concernée, puis en
choisissant la commande "Scinder" du menu contextuel. Il est également possible de scinder
manuellement l’algorigramme en venant déposer un bloc d’interconnexion dans
l’algorigramme (le bloc est disponible dans la liste des blocs, à gauche de l’algorigramme).
- Le programme ne lit la valeur du potentiomètre, pour valider la vitesse de séquencement,
qu’au début de chaque cycle. Donc, si vous modifiez la valeur du potentiomètre pendant un
séquencement des LEDs, la nouvelle vitesse ne prendra effet qu’au début du prochain cycle
(lorsque le potentiomètre est lu une nouvelle fois). L’algorigramme pourrait être modifié pour
que le potentiomètre soit lu plus souvent (nous vous suggérons d’implémenter cette
fonctionnalité si vous le souhaitez, en insérant un bloc analogRead avant chaque attente, par
exemple).

92
Notez que, même avec des blocs d’interconnexions, il est possible de manquer de place sur une feuille,
si l’algorigramme est important. Pour vous sortir de cette situation, vous pouvez ajouter d’autres
feuilles (cliquez sur le menu Projet et sélectionnez la commande "Nouvelle feuille") – les blocs
d’interconnexions peuvent également être utilisés pour relier des feuilles. Il existe aussi d’autres
méthodes pour organiser des algorigrammes de taille importante, telles que les sous-routines que
nous aborderons dans le chapitre suivant.

Maintenant, nous allons construire notre algorigramme afin qu’il corresponde à celui de la Figure 7-10.

1. Glissez-déposez 5 x méthodes pinMode depuis le périphérique cpu dans l’algorigramme, à

l’intérieur de la routine Setup. Validez les arguments "pin" et "mode" du bloc pour que les
broches de 3 à 7 soient des sorties (voir Figure 7-10) – clic droit sur le bloc et choisissez la
commande Editer du menu contextuel.

2. Glissez-déposez 5 x méthodes digitalWrite depuis le périphérique cpu dans l’algorigramme, à

l’intérieur de la routine Loop. Validez les arguments afin qu’ils commutent toutes les broches
à "off" (FALSE : broches 3 à 7).

3. Glissez-déposez une méthode analogRead depuis le périphérique cpu dans l’algorigramme, à

l’intérieur de la routine Loop, après les blocs digitalWrite ajoutés dans l’étape précédente.

4. Editez le bloc analogRead. Validez l’argument Ain à 0 – c’est la broche analogique que nous
voulons lire (AN0). Créez une nouvelle variable appelée ‘ain’ (elle peut avoir déjà été créée
automatiquement), et sélectionnez le résultat de analogRead pour qu’il soit sauvegardé dans
cette variable (comme présenté dans la figure suivante).

Notez que la similitude entre l’argument de nom "Ain" et la variable de nom "ain" est une
pure coïncidence– nous aurions pu nommer la variable "lit_potar" par exemple.

5. Scindez l’algorigramme par un clic droit sur la ligne au-dessus de la routine analogRead, puis
en choisissant la commande Scinder du menu popup.

6. Ajoutez un bloc attente dans la routine Loop (après le bloc interconnect), et validez l’attente
à ain millisecondes.

93
 Ceci validera une attente en millisecondes, fonction de la valeur de la variable ain.

7. Ajoutez une méthode digitalWrite dans la routine Loop, afin d’allumer la première LED -
Validez la pin 3 et l’état à TRUE.

8. Ajoutez une autre attente et une méthode digitalWrite pour chacune des 4 LEDs restantes, y
compris un bloc d’attente final. Nous avons ainsi une séquence qui allume les LEDs une par
une, avec une attente entre chaque allumage (le temps d’attente dépend de la variable "ain",
dont la valeur est déterminée par la tension aux bornes du potentiomètre).

Lorsque c’est terminé, votre algorigramme doit être identique à celui de la Figure 7-10 (souvenez-vous
que les blocs commentaires n’affectent pas l’algorigramme). Ne lancez pas la simulation à ce stade.

7.7. Fenêtres popup actives

Lorsque vous lancez la simulation de l’algorigramme, vous avez remarqué qu’il est possible d’interagir
avec les composants utilisés par le programme (boutons, LEDs, etc) directement dans l’onglet Visual
Designer ou dans l’onglet de l’éditeur de schéma. Lorsque les composants sont affichés dans l’onglet
Visual Designer, Proteus les copie depuis l’onglet de saisie de schéma. Les parties qui sont copiées de
cette façon sont appelées des "popup actives". Ce sont des zones rectangulaires, repérées en couleur
bleue, comme illustré dans la figure suivante.

Région popup active

Figure 7-12: Popup active

Vous pouvez ajouter vos fenêtres actives personnelles sur le schéma en utilisant le mode "Fenêtre
active" ( ), disponible dans la barre d’outils verticale. Pour ajouter une fenêtre active, il suffit de
valider ce mode, puis de dessiner un rectangle autour de la zone qui vous convient. Vous pouvez
également nommer cette fenêtre active (lui donner un label) afin de l’identifier de façon unique (clic
droit sur elle, puis Editer les propriétés). Comme exercice, ajoutez des fenêtres actives dans votre
schéma, pour qu’elles correspondent à celles de la figure suivante.

94
 Popups actives
ajoutées.

Figure 7-13: Schéma avec deux régions de popup actives ajoutées

Lorsque des fenêtres actives ont été ajoutées au schéma, elles apparaîtront dans l’onglet Visual
Designer pendant la simulation, et vous pourrez interagir avec elles. Bien évidemment, l’interaction
sera également possible depuis l’onglet de l’éditeur de schéma.

(Astuce : Si une fenêtre active n’apparaît pas lors de la simulation, ouvrez le menu Débogage – la
fenêtre doit être listée dans ce menu et vous pouvez cliquer dessus pour la faire apparaître. Notez que
les fenêtres actives peuvent être déplacées, redimensionnées ou détachées dans des fenêtres
séparées de l’onglet Visual Designer (lorsque la simulation est lancée))

7.8. Tester le projet

Lorsque l’algorigramme est terminé, comme sur la Figure 7-10, et qu’éventuellement des fenêtres
actives ont été ajoutées, un clic sur le bouton "Play" (triangle bleu en bas et à gauche de la fenêtre)
lance la simulation. Vous devriez voir les LEDs flasher en séquence. Une modification des réglages du
potentiomètre (utilisez les flèches ou cliquez dessus) doit changer la vitesse des flashs. Si rien ne se
passe comme prévu, il faut revoir ce chapitre pour comprendre d’où vient l’erreur ou ce qui n’a pas
été correctement configuré

7.9. Résumé du chapitre

Les notions abordées dans ce chapitre doivent vous permettre de dessiner un circuit personnel et
d’interagir avec le microcontrôleur (au-delà d’une simple interaction avec les périphériques
disponibles dans la galerie des périphériques).

95
8. Sous-programmes et boucles conditionnelles
Félicitations ! Si vous avez terminé et compris les circuits des chapitres relatifs à la conception
d’algorigrammes, alors vous disposez de tous les outils pour dessiner vos projets et interagir avec eux
dans un algorigramme du Visual Designer16! Ce chapitre introduit deux nouveaux concepts : les sous-
programmes (sub-routines), et les boucles conditionnelles. Bien que ces deux nouveaux concepts ne
nous permettent pas de faire quelque chose que nous ne pouvions pas faire précédemment, ils nous
autorisent à le faire plus simplement.

Nous allons utiliser les sous-programmes et les boucles conditionnelles pour mieux organiser des
algorigrammes complexes. Ils nous permettront de définir des algorigrammes plus courts, plus
simples, plus faciles à lire et à comprendre.

Note : Les sous-programmes et les boucles sont des concepts séparés (ils ne dépendent pas l’un de
l’autre). Cependant, nous introduisons les deux dans le même chapitre, en utilisant un exemple de
projet qui y fait appel.

Figure 8-1: Shield Adafruit NeoPixel pour Arduino17

Nous utiliserons le shield "Adafruit NeoPixel pour Arduino". Un NeoPixel est une boite à LEDs, dont la
couleur peut être contrôlée. Le shield NeoPixel contient 40 LEDs, réparties en 5 lignes de 8 colonnes
(ou 8 lignes de 5 colonnes, selon la façon dont on regarde le circuit – cette organisation ligne-colonne
est également appelée un tableau ou une matrice). Le "shield" (nom utilisé pour décrire des cartes

16
Techniquement, le sujet avancé relatif aux ‘interruptions’ n’a pas encore été abordé. Nous suggérons de lire
les explications données en section 12.1.
17
https://www.adafruit.com/product/1430

96
périphériques associées à une carte Arduino) se branche directement sur la carte Arduino Uno. Nous
commencerons avec un projet simple qui allume une LED du module NeoPixels. Puis nous ferons
évoluer le projet pour allumer toutes les LEDs tout en modifiant la couleur. Au cours du processus
nous introduirons les sous-programmes et les boucles conditionnelles. Vous pourrez sauvegarder le
projet aux différentes étapes de conception, afin de conserver une copie de nom différent pour
chaque phase.

8.1. Débuter et configurer le projet

1. Lancez un nouveau projet algorigramme. Pour un rappel, voir les sections 2.2, 3.3 ou 4.1
(Sauvegardez tout projet ouvert ( ), fermez-le ( ), puis choisissez "Nouvel algorigramme"
dans l’écran d’accueil ( )). Nommez le projet "NeoPixel1".
2. Ajoutez un "Adafruit NeoPixel Shield" au projet depuis la galerie des périphériques du Visual
Designer. Pour un rappel, voir la section 3.4. (La galerie des périphériques est accessible par
un clic droit dans la section Projet, puis "Ajouter périphérique" - Le shield Adafruit NeoPixel
est présent dans la catégorie Adafruit.

Après l’ajout du shield Adafruit NeoPixel, la zone "Projets" devrait contenir toutes les méthodes
disponibles pour le NeoPixels (comme illustré ci-dessous).

Définir la couleur du pixel

par les composantes R, G, B

Définir la couleur du pixel

Méthodes du
par un triplet R, G, B 32 bits
périphérique NeoPixel
compact

Figure 8-2: Méthodes NeoPixel

97
8.2. Contrôler les couleurs
La couleur émise par chacune des 40 NeoPixels peut être contrôlée par une combinaison des trois
couleurs fondamentales ; rouge, vert, bleu. A l’intérieur de chaque NeoPixel, trois LEDS sont présentes
– une rouge, une verte et une bleue. La lumière émise par un NeoPixel est un mélange de ces 3 LEDs.
Pour commencer, nous utiliserons uniquement des couleurs fondamentales – tout en rouge, tout en
vert et tout en bleu. De façon comparable au convertisseur analogique-numérique du chapitre
précédent qui admettait une valeur maximale de 1023, la couleur maximale de chaque LED est de 255.
Donc, la valeur 0 éteint totalement la LED et la valeur de 255 correspond à une émission maximale.

8.3. Configurer un pixel

Dans cette première étape, nous allons définir la couleur d’un seul NeoPixel. Nous utiliserons la
méthode setPixelColor du périphérique NeoPixel (Figure 8-2). Notez qu’il existe deux méthodes
setPixelColor. Chacune d’elles offre un moyen différent de spécifier la couleur – nous choisissons la
méthode la plus haute dans la liste, qui valide la couleur grâce aux composantes RGB (le fait de
superposer la souris au-dessus de chaque méthode affiche une infobulle qui fournit plus
d’informations sur elle). Glissez-déposez la méthode setPixelColor dans la routine Loop (Figure 8-2) de
l’algorigramme. Déposez également la méthode "show" après "setPixelColor". Si vous avez incorporé
la bonne méthode setPixelColor, vous devriez obtenir la figure suivante.

Figure 8-3: Insertion de la méthode setPixelColor dans la routine Loop de l’algorigramme

La méthode setPixelColor valide la couleur d’un NeoPixel, mais cette couleur ne sera active qu’après
l’appel à la méthode show. Il est donc possible de préparer la couleur de plusieurs pixels, puis de les
rendre actifs tous en même temps, par un appel unique à "show". Cette technique de programmation
s’appelle "buffering" (tampon); la méthode setPixelColor tamponne les informations et la méthode
show envoie le tampon vers les NeoPixels.

Pour spécifier la couleur d’un NeoPixel, cliquez droit sur la méthode setPixelColor que nous venons
d’ajouter et choisissez Editer dans le menu popup (ou cliquez gauche deux fois sur la méthode). La
boite de dialogue du bloc setPixelColor apparaît.

98
 Figure 8-4: Edition de la boite de dialogue de la méthode setPixelColor

Quatre arguments (ou paramètres) sont disponibles : ‘N’, ‘R’, ‘G’ et ‘B’.

- "N" est le numéro du pixel, de zéro (0) à 39. Les ordinateurs utilisent souvent une
numérotation qui commence à zéro au lieu de 1. Les NeoPixels de notre shield dans Proteus
sont organisés en lignes, puis on progresse par zig-zag en commençant en haut et à gauche,
pour terminer en bas et à droite (ceci est illustré dans la figure suivante).
- R est la composante rouge de la lumière, spécifiée par un nombre compris entre 0 et 255.
- G est la composante verte de la lumière, spécifiée par un nombre compris entre 0 et 255.
- B est la composante bleue de la lumière, spécifiée par un nombre compris entre 0 et 255.

La combinaison de ces trois intensités lumineuses détermine une couleur unique. Par exemple, une
association de rouge et de vert de même intensité, produira du jaune.

NeoPixel #0 #7
(premier NeoPixel)
#14
#8
#15
#16 #9

NeoPixel #39
(dernier NeoPixel)

Figure 8-5: Schéma du composant shield NeoPixel

99
Conserver le numéro de pixel (N) à 0. Définir l’intensité du canal rouge R à 255 et laisser les intensités
verte et bleue à 0 (canaux éteints). Nous obtiendrons ainsi un NeoPixel rouge.

Lorsque c’est terminé, lancez la simulation (cliquez sur OK pour accepter les réglages de setPixelColor).
Le NeoPixel #0 devient rouge.

8.4. Configurer 3 pixels

A présent, validons également la couleur des NeoPixels #1 et #2, afin que les 3 premiers pixels soient
rouges.

Si, à ce stade, vous souhaitez sauvegarder votre projet, utilisez la commande "Enregistrez-sous" du
menu Fichier. Par exemple, utilisez le nom “NeoPixel2”.

Glissez deux méthodes setPixelMethods supplémentaires dans l’algorigramme, au-dessus de la

méthode "show". Validez les paramètres afin que les pixels 2 et 3 deviennent rouges. La figure
suivante montre l’algorigramme.

Figure 8-6: Algorigramme qui configure 3 pixels

100
8.5. Configurer 40 pixels
Que se passe-t-il si nous souhaitons coloriser 40 NeoPixels en rouge ? Devons-nous glisser-déposer 40
fois la méthode “setPixelColor“ dans l’algorigramme ? Cette façon de procéder fonctionnerait mais
nous aurions 40 blocs dans l’algorigramme ; un pour chaque NeoPixel. Fort heureusement, il existe
une méthode plus simple.

Enregistrons l’étape actuelle sous le nom “NeoPixel3”, par exemple.

Figure 8-7: Algorigramme pour configurer 40 pixels

La figure précédente présente un algorigramme qui valide 40 pixels, en utilisant 1 seul bloc
“setPixelColor“. L’algorigramme se sert d’une variable "pixel" qui contient le numéro du pixel à
configurer.

La valeur de "pixel" évolue de 0 à 39. Elle commence avec la valeur 0 pour configurer le pixel 0, puis
est incrémentée de 1. Ensuite un test est effectué pour savoir si cette valeur est inférieure ou égale à
39. Si c’est le cas, le déroulement du programme se poursuit via la sortie "YES". En définitive, tant que
la valeur de la variable est inférieure ou égale à 39, le processus se répète pour s’arrêter lorsque 39+1
= 40 ; dans cette situation la condition "pixel<=39"’ n’est plus respectée et le programme se poursuit,
via la sortie "NO", vers le bloc LED1 qui contient la méthode "show", qui affiche les 40 LEDs en rouge
en une seule opération.

Pour un rappel sur la façon d’ajouter une variable dans votre programme, voir la section 4.2.

101
8.6. Boucle “For” conditionnelle
Comme nous avons besoin d’une variable qui parcourt une séquence de valeurs, ce qui se produit
souvent en programmation, nous pouvons utiliser un appelé boucle "Pour" (FOR en anglais).

S vous souhaitez sauvegarder votre projet, utilisez la commande "Enregistrez-sous" du menu Fichier.

Figure 8-8: Configurer 40 pixels avec une boucle "For"

Le programme de la Figure 8-8 fait la même chose que celui de la section précédente (Figure 8-7),
cependant il est plus concis et plus simple à concevoir. En outre il est plus clair et facile à comprendre.

Nous allons mettre à jour notre algorigramme avec une boucle "POUR".

Figure 8-9: Bloc de construction d’une boucle

Commençons par glisser-déposer un bloc de construction d’une boucle for dans l’algorigramme.

Ensuite, cliquez droit sur le bloc "LOOP" et choisissez la commande Editer du menu popup (vous
pouvez également double-cliquer sur le bloc LOOP).

La boite de dialogue suivante s’affiche

102
 .
Figure 8-10: Edition de la boucle

Vous constaterez que cette boite de dialogue contient plusieurs onglets ; un pour chaque façon de
déclarer une boucle. Ces différents types de boucles seront présentées rapidement (elles se
ressemblent). Pour l’instant nous utiliserons la boucle "Pour-Suivant" ("For-Next"), qui correspond à
l’option par défaut.
Explicitement nous exprimons une phrase telle que : « POUR pixel qui varie de 0 à 39, faire ce qui suit,
puis incrémenter pixel de 1 avant de recommencer. Lorsque la valeur de pixel dépasse 39, sortir de la
boucle ».

La variable de boucle servira à compter (dans notre cas, ce sera le numéro du pixel).

Les valeurs DEBUT et FIN n’ont pas besoin de plus d’explications – dans notre cas, les valeurs sont 0
et 39, respectivement.

La valeur PAS détermine la façon dont la variable de boucle est ajustée à chaque itération. Dans ce
projet, nous souhaitons que le numéro de pixel augmente de 1 à chaque passage, donc la valeur sera
1. Si, par exemple, nous définissons une valeur de PAS égale à 2, la variable du numéro de pixel serait
incrémentée de 2 à chaque itération de la boucle (0, 2, 4, 6, 8, etc.).

Assurez-vous que "pixel" est sélectionné comme variable de boucle, validez la valeur DEBUT à 0 et la
valeur de FIN à 39. La valeur de PAS est 1 (ou ne mettez rien dans le champ). Cliquez sur OK pour
fermer la boite de dialogue.

L’algorigramme doit ressembler à la Figure 8-8. Souvenez-vous que vous pouvez détacher des blocs
afin de les repositionner (clic droit sur le bloc, puis "Détacher" ou maintenez la touche CTRL enfoncée,
cliquez sur le bloc et glissez-le).

En final, lancez la simulation et vérifiez que les 40 NeoPixels s’allument simultanément en rouge.

103
8.7. Types de boucles conditionnelles
8.7.1. Boucles TANT-QUE (“While”)
Les boucles "TANT-QUE" (While en anglais) s’exécutent “tant que la condition de fin n’est pas validée”.
Par exemple, “Tant que Bouton1 est enfoncé, répétez les actions” (une autre façon de s’exprimer
pourrait être “Aussi longtemps que Bouton1 est appuyé, répétez ces actions”). La figure suivante
illustre deux méthodes équivalentes pour réaliser la même tâche, en utilisant un bloc de décision ou
en utilisant une boucle "Tant-que". La tâche est, “Tant que Button1 est toujours enfoncé, ajoutez 1 à
la variable nommée count”.

Figure 8-11: Boucle « TANT-QUE / FIN TANT-QUE » (While-Wend)

8.7.2. Boucle REPETER (“Repeat”)

Les boucles "REPETER" (ou REPETER-JUSQU’A) sont comparables aux boucles "TANT-QUE", excepté
que la condition est testée après les actions à répéter, plutôt qu’avant. Par exemple, “Répétez ces
actions, jusqu’à ce que Button1 ne soit plus enfoncé ”.

Figure 8-12: Boucle Répéter-Jusqu’à

La figure précédente illustre deux méthodes équivalentes pour effectuer la même tâche ; en utilisant
un bloc de décision ou en utilisant une boucle "répéter-jusqu’à". La tâche est, “Ajouter 1 à la variable
count, jusqu’à ce que Button1 ne soit plus enfoncé”. Notez que la boucle Répéter-Jusqu’à utilise une
logique opposée à la boucle Tant-que ("REPETER-JUSQUA" teste une condition FAUSSE (FALSE), alors
que la boucle ‘TANT-QUE’ vérifie que la condition est VRAIE (TRUE)). Donc, l’expression “répétons les
actions jusqu’à ce que le bouton ne soit plus enfoncé”, est opposée à “répéter les actions tant que le
bouton est enfoncé”. L’expression “ne soit plus” inverse la logique, qui est convertie de vraie en fausse
et vice-versa (par exemple, “le thé est chaud” –> “thé chaud = VRAI”, ou “le thé n’est pas chaud” ->
“thé chaud = FAUX”)

104
8.7.3. Boucle FOR (“For”)
La boucle ‘POUR’ (ou boucle "For-Next" en anglais) a déjà été présentée dans les étapes du projet
précédent.

Une variable compte d’une valeur de début jusqu’à une valeur de fin, avec la possibilité de changer le
pas d’incrément à chaque itération de la boucle (par exemple, compter de 0 à 10 avec un pas de 1,
conduira à la séquence [0,1,2,3,4,5,6,7,8,9,10]).

A ce stade vous pourriez être intéressé de savoir qu’en interne à l’ordinateur, la boucle POUR est
convertie en une boucle TANT-QUE. Donc “Pour compteur = 0 à 10 par pas de 2” devient “Débuter
compteur à 0. Ajouter 2 à chaque fois et continuer aussi longtemps que compteur est inférieur ou égal
à 10.”

8.7.4. Boucle COMPTEUR (“Count”)

C’est le dernier type de boucle qu’autorise la boite de dialogue de Proteus, via le premier onglet.

C’est une forme simplifiée de boucle "POUR", qui suppose que le pas est de 1 et que le comptage
commence à 0. Donc “Pour compteur = 0 à 39, par pas de 1” est équivalent à “Compteur 40”.

En cas de doute, utilisez la boucle "POUR".

8.8. Ajouter d’autres couleurs

A présent nous allons ajouter des couleurs vertes et bleues à notre programme. Après avoir validé
tous les NeoPixels avec la couleur rouge, nous les ferons commuter en vert (après un court délai) puis
finalement en bleu (après un court délai également). Le processus sera répété (bien évidemment,
après un court délai).

A ce stade, vous pouvez enregistrer le projet sous le nom “NeoPixel5”, par exemple.

Figure 8-13: Algorigramme pour valider tous les NeoPixels en rouge, puis vert, puis bleu

La figure ci-dessus montre un algorigramme qui réalise la fonction souhaitée de commutation des
couleurs.

105
Par rapport à l’algorigramme précédent, nous devons réaliser deux copies du bloc d’affichage en rouge
(notez que le Visual Designer incorpore la fonctionnalité de copier-coller via le menu popup sur clic
droit ou grâce au menu ‘Editer’ lorsque le bloc a été sélectionné. Les raccourcis clavier habituels
CTRL+C et CTRL+V peuvent aussi être utilisés). Ensuite, il suffit d’ajuster les paramètres de couleur des
méthodes “setPixelColor“ et ajouter une attente. Afin que l’algorigramme soit contenu dans la page,
il est également nécessaire d’ajouter des blocs d’interconnexion.

Notez que les commentaires "Red", "Green" et "Blue" placés au-dessus des boucles "FOR" n’affectent
pas le fonctionnement du programme. Veuillez mettre à jour votre algorigramme afin qu’il ressemble
à celui de la figure précédente, lancez la simulation et contrôlez le bon fonctionnement. Les NeoPixels
devraient être tous rouges, puis après une seconde, ils devraient devenir verts, pour passer à la
couleur bleue une seconde plus tard.

Pour terminer, le processus doit se répéter après une attente d’une seconde et recommencer
indéfiniment.

8.9. Sous-programmes (Sub-Routines)

Dans la section précédente nous avons reproduit une séquence de programme grâce à un copier-
coller de blocs. Ceci est pratique, mais il existe une façon plus élégante et efficace de programmer,
par l’utilisation des sous-programmes.

Comme nous l’avons déjà indiqué, les sous-programmes (sub-routines en anglais) ainsi que les boucles
conditionnelles sont totalement optionnels ; en effet, il est possible d’écrire un programme sans
jamais les utiliser.

Par contre, il est important de comprendre qu’ils permettent de simplifier l’écriture de programmes
complexes.

La portion du programme que nous avons dupliqué précédemment est très courte (4 à 5 blocs), mais
si cette taille à reproduire devient importante (plusieurs dizaines de blocs par exemple), alors les sous-
programmes montrent leur intérêt. Dans le projet à construire, nous allons placer les sections copiées-
collées de l’algorigramme dans un sous-programme séparé (qui mettra à jour les pixels).

A ce stade, vous pouvez enregistrer le projet nouveau sous le nom “NeoPixel6”, par exemple.

106
 Sous-programme

Appels de sous-
programme

Figure 8-14: Algorigramme avec sous-programme et appels

La figure ci-dessus présente l’algorigramme de cette étape du projet. Nous sommes partis de zéro
pour écrire un algorigramme qui utilise des mots en français. Une zone, à droite, est dédiée à notre
sous-programme de nom, "ChangePixel". Dans la partie principale de l’algorigramme, nous avons
déclaré trois nouvelles variables, appelées "rouge", "vert" et "bleu". Ces variables serviront pour
indiquer, au sous-programme, la couleur à utiliser.

Commençons par déclarer le sous-programme "ChangePixel". Pour cela, il faut glisser-déposer un bloc
événement dans l’algorigramme.

Figure 8-15: Bloc événement (sub-routine)

Notez que le bloc "End" est ajouté automatiquement. Changez le nom du bloc événement en
"ChangePixel", par un clic droit puis sélectionnez ‘Editer’ dans le menu popup (ou par un double-clic
sur le bloc).

107
Ajoutez les blocs d’affectation dans le corps de LOOP, qui est actuellement vide. Editez les blocs
d’affectation et créez 3 nouvelles variables : rouge, vert, bleu. Affectez les valeurs de la Figure 8-14
aux variables (rouge:=255, vert:=0, bleu:=0). Pour un rappel sur la façon de créer les variables, vous
pouvez vous reporter à la section 4.2.

Glissez-déposez un bloc "d’appel de sous-programme" dans le corps principal de LOOP, après le bloc
d’affectation.

Figure 8-16: Bloc appel de sous-programme

Editez le bloc "sous-programme" et sélectionnez "ChangePixel” comme méthode à appeler.

Ajoutez deux blocs d’affectation de variables avec les appels au sous-programme, comme illustré en
Figure 8-14. Notez que les commentaires sont optionnels.

Mettez à jour les blocs "setPixelColor" afin qu’ils utilisent les variables que nous venons de créer pour
les valeurs “rouge”, “vert”, et “bleu” (au lieu de valeurs fixes telle que “255” pour l’argument “rouge”.
Utilisez rouge sans les guillemets).

Nous avons ainsi adapté l’algorigramme afin qu’il utilise un sous-programme pour mettre à jour la
couleur de tous les NeoPixels (et attend 1 seconde après avoir fait cela). Des variables “rouge”, “vert”
et “bleu” ont permis de configurer les couleurs des NeoPixels. Dans la boucle principale loop, nous
définissons la couleur à obtenir grâce aux variables, puis nous appelons le sous-programme
“ChangePixel”.

Une fois terminé, lancez la simulation et vérifiez que le programme fonctionne comme prévu. Si ce
n’est pas le cas, comparez avec l’algorigramme plus haut.

Les sous-programmes peuvent être difficiles à comprendre mais, pour l’instant, rappelez-vous que
lorsque vous en appelez un dans l’algorigramme, cela signifie que des blocs dédiés ont été regroupés
dans une routine particulière. Apprenez également à repérer l’appel à un sous-programme dans un
algorigramme.

Notez que la plupart des méthodes de périphériques qui ont été utilisées jusqu’à présent, y compris
la méthode "setPixelColor" sont, en fait, des appels à des sous-programmes ! La seule différence avec
des sous-programmes que vous pourriez développer vous-même est que les détails de ces méthodes
sont cachés dans Proteus.

108
D’un point de vue conceptuel, il est généralement préférable « d’oublier » comment fonctionne un
sous-programme. Un point important est de le nommer avec un nom significatif, représentatif de la
tâche qu’il exécute. Un autre avantage des sous-programmes est qu’ils permettent de décomposer un
programme en plus petites parties, qui rendent le programme plus facile à comprendre.

Par exemple, il est plus simple de dire "s’il vous plait, je souhaite commander une soupe de tomates,
du pain, une salade et un gâteau au chocolat" que d’expliquer toutes les étapes nécessaires pour faire
cela. « Veuillez prendre des tomates, découpez-les, mettez de l’eau dans une casserole, allumez le
feu, etc, etc". Plus le nombre d’opérations élémentaires augmentent, plus cela devient confus à
comprendre.

Les sous-programmes répondent à plusieurs objectifs :

1. Remplacer des parties répétitives dans un programme.

2. Découper un programme en plus petites parties, plus simples à comprendre par un humain.

3. Permettre de réutiliser des portions de programmes entre projets.

8.10. Un projet plus raffiné

Nous allons utiliser nos nouvelles compétences acquises sur les sous-programmes et les boucles
conditionnelles pour construire un programme qui fait passer notre NeoPixel par toutes les couleurs
de l’arc-en-ciel !

Enregistrez votre projet actuel et créer un nouveau projet de nom “NeoPixel7”, par exemple.

109
 Figure 8-17: Algorigramme Arc-En-ciel

La figure précédente décrit l’étape finale de notre projet. Une nouvelle routine appelée
"ChangeCouleur" a été ajoutée, qui gère la transition du rouge au vert, du vert au bleu et du bleu au
rouge. Lors de ces changements, toutes les couleurs de l’arc-en-ciel sont parcourues. Trois nouvelles
variables sont ajoutées – deux nombres entiers appelés "niveau_debut" et "niveau_fin" (aucun
d’espace et aucun accent dans le nom des variables) et une chaîne de caractère (du texte) appelée
"transition".

Le sous-programme "ChangeCouleur" contient une boucle qui fait varier niveau_debut de 255 à 0
(intensité maximale jusqu’à extinction). La variable "niveau_fin", grâce à l’équation "niveau_fin = 255
– niveau_depart", a une progression inverse de 0 à 255. Ainsi, dans la première boucle, le canal rouge
décroit jusqu’à s’éteindre alors que le canal vert augmente simultanément jusqu’à l’intensité
maximale.

Le sous-programme "ChangePixel" est appelé pour mettre à jour l’affichage avec la nouvelle couleur.
L’attente est fixée à 10ms (millisecondes) afin que la transition intervienne à une vitesse acceptable.
Si nous avions conservé la valeur d’attente du projet précédent, le programme aurait duré 255 x 1
seconde, soit 4 minutes et 15 secondes pour 1 transition. Avec la nouvelle valeur de 10ms, une
transition dure 2.55 secondes.

La boucle principale (LOOP) se contente de mettre à jour la variable “transition” avec le type de
transition souhaitée, puis appelle le sous-programme “ChangeCouleur”.

110
Mettez à jour votre algorigramme pour qu’il corresponde à celui de la figure précédente. Si vous êtes
bloqué, parcourez à nouveau les sections adéquates de ce livre. La boite de dialogue ci-dessous
montre comment définir la variable “transition” de type STRING (chaîne de caractères).

Figure 8-18: Création d’une variable "String" et affectation

Lorsque vous êtes prêt, lancez la simulation. Le NeoPixels devrait effectuer toutes les transitions de
couleurs programmées. Si quelque chose ne fonctionne pas, comparez votre algorigramme à celui de
la Figure 8-17.

Nous espérons que vous serez impressionné par le résultat obtenu grâce à cet algorigramme ! En
programmation, il existe plusieurs façons d’aboutir au même résultat. Par exemple, vous auriez pu
obtenir le même effet de transition en utilisant uniquement des blocs "setPixelColor", mais sans
l’utilisation des boucles conditionnelles et des sous-programmes, il aurait fallu 3 x 255 x 40 = 30 600
blocs pour y arriver – trente mille six cents blocs. Notre algorigramme ne contient que 19 blocs.

Le module Neopixel est un bon outil pour tester d’autres possibilités, car chaque pixel peut être piloté
individuellement. Les panneaux publicitaires à LEDs sont des écrans digitaux de plus en plus employés
de nos jours et le NeoPixel constitue une bonne introduction à leur pilotage. Laissez place à votre
imagination pour tester d’autres projets personnels qui vous permettront d’améliorer vos
compétences et votre maîtrise de la programmation par algorigrammes.

111
9. Introduction au langage C
Note : Si vous le souhaitez, vous pourriez passer directement au chapitre “Chapitre bonus : Robotique”
avant d’aborder celui-ci.

Félicitations ! Si vous avez terminé avec succès et compris les chapitres précédents, alors vous avez
acquis de nouvelles compétences : la capacité d’écrire un programme informatique évolué.

A présent, regardons de plus prêt un autre langage de programmation appelé le langage C . “C” est un
langage de programmation utilisé pour développer des logiciels, de la même façon que le Visual
Designer. La différence entre ces deux modes d’écriture intervient dans la syntaxe : par exemple, vous
pourriez expliquer à quelqu’un comment cuire un gâteau en vous exprimant en anglais ou en français
mais, quelle que soit la langue utilisée, les actions seraient les mêmes. De manière comparable, le C
est simplement un langage “diffèrent” pour écrire des programmes. Alors que le Visual Designer
assemble des blocs dans un algorigramme, les programmes C sont totalement écrits en texte (avec
des lettres, des nombres, des mots, des caractères de ponctuation, etc.). Cependant, comme vous
pourrez le constater lors de l’introduction au C, il est plus facile et moins intimidant de se lancer dans
la programmation avec des algorigrammes qu’avec le langage C !

C est un langage “standard de l’industrie”, ce qui signifie qu’il est couramment utilisé pour développer
des logiciels. L’apprentissage du C vous apporte les avantages suivants :

- Vous trouverez des compilateurs C pour la plupart des composants, au-delà du monde
Arduino.
- De très nombreuses ressources écrites en C sont disponibles, telles que des bibliothèques.
Une bibliothèque est le regroupement de sous-programmes, que quelqu’un a déjà écrit, et
qui peuvent vous aider dans votre tâche de développement (sans devoir “réinventer la roue”).
Le Visual Designer contient également des bibliothèques, sous la forme de périphériques
placés dans la galerie de périphériques (section 3.4).

En outre, C est un langage de programmation nettement plus puissant qu’un langage par
algorigramme. De façon comparable à ce qui a été décrit au chapitre 8, avec les boucles et les sous-
programmes qui facilitent la construction de programmes complexes, le C offre des possibilités pour
développer et organiser des logiciels complexes très ambitieux. Le langage C++, une version avancée
du C, regroupe d’autres concepts et encore plus de fonctionnalités/possibilités.

Vous pourriez être intéressé de savoir que Proteus, y compris le Visual Designer, sont principalement
écrits en C++. Une autre information intéressante à connaître concerne la capacité de Proteus à
convertir tous les algorigrammes du Visual Designer en code C++, durant le processus de compilation.

Ce chapitre est une introduction au langage C. Veuillez noter que ce n’est pas un cours exhaustif sur
le “C”, qui nécessiterait un livre à lui seul, mais il contient des notions de base afin de bien vous
orienter pour mieux progresser par vous-même, à l’aide de lectures complémentaires.

De plus, l’intention de ce chapitre n’est pas de “remplacer” les acquis de la programmation par
algorigramme, appris dans les chapitres précédents. Bien qu’il soit important de considérer
l’apprentissage du C, il est possible qu’il ne corresponde par à vos objectifs personnels ; dans ce cas,
continuez à développer vos programmes avec les algorigrammes.

112
9.1. Le C comparé aux algorigrammes
Pour introduire le langage C, nous allons commencer par créer un projet algorigramme, puis nous le
comparerons à un projet équivalent en C.

Déclarons un nouveau projet algorigramme (vous devriez être habitué avec ce processus, à présent –
souvenez-vous de sauvegarder tout travail ouvert que vous ne voulez pas perdre). Le nom de fichier
“C_LED_Algo” peut être utilisé pour ce projet. Ensuite, utilisez les méthodes du périphérique CPU pour
construire l’algorigramme suivant (configurez les paramètres des blocs de l’algorigramme pour qu’ils
correspondent à la figure ci-dessous).

Figure 9-1: Algorigramme pour faire clignoter une LED

Cet algorigramme commence par configurer la broche 13 du microcontrôleur en sortie (SETUP), puis
commute indéfiniment cette sortie entre les états haut (TRUE / ON) et bas (FALSE / OFF), avec une
attente de 1 seconde entre chaque état (LOOP). Comme la LED interne à la carte Arduino UNO est
connectée à la broche 13, elle va s’allumer puis s’éteindre toutes les secondes. Lancez la simulation
pour vérifier que le programme fonctionne correctement.

Passons au langage C pour obtenir la même fonctionnalité. Sauvegardez votre projet algorigramme
puis cliquez sur menu Fichier pour lancer la commande “Nouveau projet” (cette fois-ci nous ne créons
pas un algorigramme). Dans l’assistant de nouveau projet, suivez les étapes ci-dessous :

1. Nom de projet “C_LED_Code”. (Cliquez sur “Suivant”)

2. Indiquez que vous créez un schéma base sur le gabarit DEFAULT. (Cliquez sur “Suivant”)
3. Ne pas créer de PCB. (Cliquez sur “Suivant”)
4. Indiquez que vous créez un nouveau projet firmware. Choisissez la famille ARDUINO (Arduino
Uno est le contrôleur et Arduino AVR est le compilateur qui devraient être validés par défaut).
Cochez la case “Créer fichiers initiaux”, mais ne cochez pas la case “Créer périphériques”. Ceci
est illustré figure suivante. (Cliquez sur “Suivant”, puis “Terminer” pour sortir)

113
 Figure 9-2: Nouveau projet firmware

Double cliquez sur le fichier “main.ino” sur le gauche afin de l’ouvrir, s’il n’est pas déjà ouvert.

Vous obtiendrez le code comparable à celui-ci :

/* Main.ino file generated by New Project wizard

*
* Created: Sun Jan 14 2018
* Processor: Arduino Uno
* Compiler: Arduino AVR
*/
void setup () {

// TODO:put your setup code here, to run once:

}
void loop() {

// TODO: put your main code here, to run repeatedly:

}

La totalité du code de couleur verte correspond à du commentaire qui n’a aucune influence sur les
opérations du programme ; il peut donc être ignoré. Il reste “void setup”, “void loop” ainsi que des

114
parenthèses et des accolades. “Setup” et “Loop”, sont des noms identiques à ceux des routines SETUP
et LOOP de l’algorigramme "C_LED_Algo".

Le code ci-dessous montre le code C équivalent à l’algorigramme pour comparaison.

Code “C” Algorigramme

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

void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}

9.2. Introduction à la syntaxe du langage C

Dans le premier programme significatif ci-dessous, nous comparerons à nouveau un algorigramme
avec son équivalent en code C. Les deux programmes sont listés ci-dessous, sachant que nous
reviendrons ensuite sur le code C, pour expliquer les règles de syntaxes.

Nous souhaitons faire flasher une LED lorsqu’un bouton est appuyé, en incrémentant le nombre de
flashs à chaque fois. Voici l’algorigramme correspondant :

Figure 9-3: Algorigramme d’introduction à la syntaxe du langage "C"

115
Cet algorigramme utilise une variable "compte" qui comptabilise le nombre de flashs et un sous-
programme "Flash_LED" qui fait flasher la LED. Le nombre de fois que la LED passe de l’état allumé à
éteint est donné par la variable "compte". Au lancement du programme, compte vaut 1 et cette valeur
s’incrémente à chaque fois que le bouton est enfoncé.

/* Programme qui fait clignoter une LED

* lorsqu’un bouton est appuyé.
Commentaires
*
* Processeur: Arduino Uno
* Compilateur: Arduino AVR
*/
Directive pour le préprocesseur
#define BUTTON_PIN 2
Déclaration de variables
int boucle;
int compte;
Sous-programme

void FlashLED() {
for (boucle = 1; boucle <= compte; boucle = boucle + 1) {
digitalWrite(13,HIGH); // Allume la LED
delay(250); Groupe d’instructions, avec un
digitalWrite(13,LOW); // Eteint la LED début et une fin (accolades)
delay(250);
}
}

void setup() {
Sous-programme, avec un
pinMode(13,OUTPUT);
compte =1; début et une fin (accolade
} ouvrante et accolade fermante)

void loop() { Condition

if (digitalRead(BUTTON_PIN)==HIGH) { // Le bouton est-il enfoncé ?

FlashLED();
Appel de sous-programme
compte = compte + 1;
delay(1000);
}
Commentaire
}

C Code 1

Les règles de syntaxe de ce programme C sont présentées ci-dessous. Cependant, veuillez noter que
nous ne détaillons pas toutes les caractéristiques du C, mais uniquement quelques notions
fondamentales.

Note : Le langage C est "sensible à la casse“ pour tous les caractères ! Ceci signifie qu’il différencie les
majuscules et les minuscules de chaque lettre d’un mot : ainsi compte, Compte, ou cOmpte sont
considérés comme des noms différents par le compilateur – les caractères accentués sont autorisés
dans les commentaires.

116
9.2.1. Commentaires
Les commentaires représentent une information qui a été ajoutée au programme, destinée à un
lecteur humain, et qui n’affecte pas les opérations réalisées dans le programme (ils sont ignorés par
l’ordinateur). Les commentaires en C peuvent être ajoutés de deux façons.

9.2.1.1. Commentaires délimités

Les commentaires délimités sont repérés par un marqueur de début et un marqueur de fin. Le
marqueur de début est “/*” (barre oblique, étoile) et le marqueur de fin est “*/” (étoile, barre
oblique). Tout texte compris entre ces deux marqueurs est considéré comme un commentaire. Les
commentaires délimités peuvent être répartis sur plusieurs lignes, voire insérés au milieu du code sur
une seule ligne

/* Ceci est un
commentaire
multilignes */

9.2.1.2. Commentaire fin-de-ligne

Le commentaire fin de ligne commence par “//” (deux barres obliques accolées), et se poursuit jusqu’à
la fin de la ligne. Aucun marqueur de fin n’est nécessaire.

delay(1000); // Attente de 1000 millisecondes = 1 seconde

9.2.2. Directives pour préprocesseur

Les directives pour préprocesseur commencent avec un # (caractère dièse) placé en colonne 1 de la
ligne, tel que #define dans le code exemple. Elles sont principalement placées en début de
programme, sur leur propre ligne et continuent jusqu’à la fin de la ligne (il est possible de les étendre
sur plusieurs lignes, cependant elles occupent habituellement une seule ligne).

Dans l’exemple, “#define BUTTON_PIN 2” indique au compilateur que “BUTTON_PIN” et “2” sont
synonymes pour ce programme – ces suites de caractères sont interchangeables.

#define BUTTON_PIN 2 //"BUTTON_PIN" signifie la même chose que "2"

L’intérêt de cette équivalence est de pouvoir utiliser BUTTON_PIN dans le programme plutôt que 2.

Donnons un exemple simpliste, mais réaliste pour imager l’intérêt de cette déclaration. Supposons
que le programme soit développé pour un certain microcontrôleur qui se sert de la broche 2 comme
entrée d’un bouton. Si la directive existe, BUTTON_PIN est utilisé dans le programme à chaque fois
que c’est nécessaire. Sans cette directive, c’est 2 qui est utilisé dans le programme, et peut apparaître
plusieurs fois, n’importe où dans le code. Ultérieurement, supposons qu’on décide de remplacer le
microcontrôleur par un autre qui se sert de la broche 7 pour la même fonction. Sans la directive, il
faudrait rechercher tous les 2 relatifs à l’entrée "bouton" et les remplacer par 7. Ceci prend du temps,
avec des oublis ou des erreurs potentielles. Grâce à la directive, il suffira de remplacer 2 par 7 dans la
ligne de la directive, d’ajouter un commentaire approprié, puis de recompiler pour que le logiciel
devienne compatible avec le nouveau microcontrôleur.

117
9.2.3. Indentation
L’indentation correspond à la pratique d’insertion d’espaces au début de la ligne afin de faciliter la
lecture du code et de marquer des dépendances – l’indentation du code C est totalement ignorée par
l’ordinateur.

Note : D’autres langages, tel que Python, utilisent l’indentation pour structurer le programme. Les
environnements de développement favorisent également l’indentation pour clarifier les dépendances
dans le code. Pour terminer, nous dirons que la pratique de l’indentation facilite la lecture du code à
une personne qui découvre un programme ainsi qu’au concepteur lorsqu’il souhaite le modifier.

void loop() {
if (digitalRead(BUTTON_PIN)==HIGH) { // Bouton enfoncé?
FlashLED();
Compte = compte + 1;
delay(1000);
} Indentation – facilite la lecture du code
}

9.2.4. Point-virgule
Toutes les commandes et déclarations doivent être suivies d’un point-virgule (“;”). Par exemple :

int compte; // Déclaration de variable

compte = compte + 1; // Commande
delay(1000); // Commande

Dans d’autres langages de programmation, la séparation des commandes et des déclarations est
obtenue par un placement sur des lignes différentes, mais ce n’est pas le cas en C, car c’est le point-
virgule qui fait office de séparateur.

Le code suivant est totalement identique au précédent :

int compte; compte = compte + 1; delay(1000); // Tout sur une ligne

Le C ne contrôle pas les lignes, excepté pour les commentaires de fin de ligne et les directives de
préprocesseur. A la place, il utilise le point-virgule pour séparer les commandes.

9.2.5. Déclaration de variable

Avant de pouvoir utiliser une variable dans un programme, elle doit être "déclarée" en indiquant son
type (par exemple int pour entier) et son nom. Le tout se termine par un point-virgule.

int compte; // Déclaration de la variable compte de type entier

De nombreux types sont disponibles entre lesquels il faut choisir – vous trouverez plus d’information
sur ces types dans la documentation du compilateur (pour Arduino, voir le lien
https://www.arduino.cc/en/Reference/VariableDeclaration).

118
9.2.6. Sous-programme (sub-routine)
Un sous-programme est inséré dans un programme en commençant par indiquer le type de variables
qu’il retourne – par exemple le mot “void” (vide) sert à indiquer que le sous-programme ne renvoie
rien – puis le nom suivi des parenthèses ouvrante et fermante “( )”. Les instructions qui sont exécutées
par le sous-programme sont insérées entre les accolades “{“ et “}”.

Note : nous utilisons indifféremment les termes sous-programme, sub-routine (appellation anglo-
saxonne), procédure ou fonction pour représenter une suite d’instructions particulières regroupées
dans un bloc nommé. En programmation orientée objet, on utilise le mot "méthode" pour parler d’une
fonction associée à un objet. Dans le Visual Designer, chaque périphérique est un objet pour lequel
plusieurs méthodes sont disponibles (tel que l’objet CPU avec toutes ses méthodes, dont pinmode ou
digitalwrite).

void MonSousProgramme () {
// Les instructions du sous-programme sont mises ici
}

Les “paramètres” (également appelés “arguments”), lorsqu’ils existent, peuvent être insérés entre la
parenthèse ouvrante et fermante. L’exemple, ci-dessous, d’une fonction qui accepte un paramètre et
renvoie une valeur, sera détaillé dans les sections suivantes.

int ma_var;
La fonction renvoie le type int (entier)
Un paramètre/argument (int rayon)
int CirconferenceCercle(int rayon) {
return 2 * 3.14 * rayon; // Circonférence = 2 x PI x rayon
}
Mot-clé “return”
Paramètre/argument “passé” à la fonction (100)
void loop() {
my_var = CirconferenceCercle (100); // Calcule la circonférence d’un
// cercle dont le rayon vaut 100
}
Appel de fonction

9.2.6.1. Sous-programme qui retourne une valeur (“Fonctions”)

Jusqu’à présent, nous avons construit des sous-programmes qui se comportent comme des
“procédures” – elles exécutent uniquement une suite de commandes. Cependant, les sous-
programmes peuvent devenir des fonctions car elles retournent (return) une valeur.

Le mot-clé return est un mot réservé du langage C. Il s’utilise pour renvoyer une "valeur".

Par exemple, considérons une fonction qui calcule la circonférence d’un cercle à partir de son rayon.
Nous pourrions utiliser (appeler) la fonction comme cela :

ma_var = CirconferenceCercle (100);// Nom de fonction sans accent !

Ce code copie la valeur transmise par le return de CirconferenceCercle dans la variable “ma_var”.

Si la fonction ne renvoie rien (c’est une simple procédure), alors le type "void" peut être utilisé, comme
dans notre programme exemple C, Code 1.

119
void FlashLED()

Le programme exemple C Code 1 appelle une fonction qui renvoie une valeur :

if (digitalRead(BUTTON_PIN) == HIGH)

“digitalRead” est une fonction qui retourne une valeur qui peut être “HIGH” ou “LOW”.

Il est possible de développer un programme sans jamais écrire de fonctions qui retournent une valeur,
cependant, sachez que cette possibilité de retour facilite l’écriture. Une explication exhaustive sur
l’écriture des fonctions sort du cadre de ce livre. Pour les curieux, il existe de nombreuses ressources
disponibles sur Internet, telle que https://www.arduino.cc/en/Reference/FunctionDeclaration.

9.2.6.2. Paramètres de sous-programme

Il est possible de "passer" des paramètres aux sous-programmes lors de l’appel. Reprenons l’exemple
du calcul de la circonférence d’un cercle :

int CirconferenceCercle (int rayon)

Cette fonction attend un nombre entier “int”. Ce paramètre est transmis lorsque la fonction est
appelée. A l’intérieur de la fonction, la valeur est référencée par le nom “rayon”.

Bien que le programme exemple C, Code 1, n’explique pas comment déclarer une fonction qui utilise
des paramètres, il présente l’utilisation de fonctions (appel) qui nécessitent des arguments – par
exemple :

delay(1000);

“delay” est le nom d’un sous-programme (fonction), et “1000” est la valeur passée en tant que
paramètre à cette fonction. Un autre exemple est :

digitalWrite(13,HIGH);

La fonction “digitalWrite” attend deux paramètres – un numéro de broche et un état (“HIGH” ou

“LOW). Les paramètres sont séparés par une virgule (“,”).

A nouveau, nous rappelons qu’il est possible de développer un programme sans écrire de fonctions
avec des paramètres, cependant, sachez que cette possibilité facilite l’écriture. Une explication
exhaustive sur l’écriture des fonctions sort du cadre de ce livre.

9.2.7. Expressions
Les expressions incluent des décisions “if” ainsi que des boucles “while” et “for”.

120
9.2.7.1. Conditions
Dans une expression, les conditions doivent être placées entres des parenthèses. Par exemple (les
parenthèses de l’expression sont mises en surbrillance) :

if (digitalRead(2)==HIGH) // si le port numérique numéro 2 est HIGH

Les différentes expressions sont approfondies dans la section suivante.

Notez qu’en langage C, lorsqu’une question teste une égalité, deux signes égal (==) doivent être
utilisés. Un seul signe égal (=) est utilisé dans les instructions (“dire”) alors que deux (==) sont utilisés
dans les conditions (“demander”). Il est extrêmement important de comprendre cela correctement,
car si un seul "=" est utilisé dans l’expression, elle sera toujours évaluée comme vraie (TRUE), et vous
vous gratterez la tête en essayant de comprendre pourquoi votre programme ne fonctionne pas
comme prévu ! C’est une nuance subtile du langage C à ne pas oublier.

9.2.7.2. Groupe d’expressions

Un groupe d’expressions est encadré d’accolades “{“ et “}”. Par défaut, une expression affectera
uniquement l’instruction qui la suit immédiatement. Par exemple, dans le code suivant, seul le code
“FlashLED();” est concerné par la boucle while.

while (digitalRead(2)==HIGH)
FlashLED(); // Cette instruction est incluse dans la boucle
delay(1000); // Cette instruction n’est pas incluse dans la boucle

Afin que l’attente (delay) fasse également partie de la boucle while, il faut ajouter des accolades
comme indiqué ci-dessous :

while (digitalRead(2)==HIGH) {
FlashLED(); // Dans ce cas, les deux instructions
delay(1000); // sont incluent dans la boucle
}

9.3. Expressions C
Nous redisons que les deux types fondamentaux d’expressions en C sont les “if” et les boucles “while”.
Tous les autres types d’expressions peuvent être construits à partir de ceux-ci.

Dans les syntaxes d’expressions listées ci-dessous, les crochets indiquent un code optionnel (c’est-à-
dire que le code entre les crochets droits, y compris les crochets, est optionnel et peut être omis s’il
n’a pas d’utilité pour le programme à écrire). Les accolades, qui permettent de regrouper des
expressions, ont été ajoutées pour rendre les exemples plus clairs, même lorsqu’il n’y a qu’une
instruction qui suit l’expression.

121
9.3.1. “If”

Syntaxe
if (expression) instruction1 [else instruction2]

Exemple
if (count > 5) {
digitalWrite(13, HIGH);
} else {
digitalWrite(13, LOW);
}

9.3.2. “While”

Syntaxe
while (expression) instruction

Exemple
while (count < 5) {
count=count+1;
}

9.3.3. “Do”

Syntaxe
do instruction while (expression);

Exemple
do {
count=count+1;
} while (count < 5);

Note: La boucle “Repeat”, disponible dans l’algorigramme de l’exemple, a une logique inversée
(“count >= 5” au lieu de “count < 5”, car c’est une boucle “jusqu’à” et pas “tant que”) - Il n’y a pas
d’équivalent en C.

122
9.3.4. “For”

Syntaxe
for ([init-expr]; [cond-expr]; [inc-expr]) instruction

- “init-expr” est une expression “initialisation ”, qui s’exécute avant que la boucle commence.

- “cond-expr” est une expression “condition ”, qui est évaluée au début de chaque passage dans
la boucle, pour décider si la boucle continue.

- “incr-expr” est l’expression “incrément ”, qui est une instruction exécutée après chaque
passage dans la boucle. Notez que cette instruction ne doit pas nécessairement “incrémenter”
quelque chose, et pourrait éventuellement multiplier, etc.

Si vous souhaitez revoir la façon dont les algorigrammes utilisent les blocs décision et les actions,
reportez-vous à la section 8.7.3.

Exemple
for (count=0; count<=10; count=count+2) {
analogWrite(10, count);
}

9.3.5. “Switch”
L’expression “Switch” est comparable à un bloc de décision qui possède plusieurs sorties et pas
uniquement “yes” et “no”. Il n’existe pas actuellement de bloc équivalent dans le Visual Designer
(cependant, notez qu’il est possible de réaliser la même structure de contrôle en utilisant plusieurs
blocs de décisions “if”).

Syntaxe
switch (expression) {
case constant-expression_1:
statement1;
[break;]
case constant-expression_2:
statement2;
[break;]
[default:
statement;]
}

123
Exemple
switch (count) {
case 1:
analogWrite(10, 12);
break;
case 2:
analogWrite(10, 34);
break;
case 3:
analogWrite(10, 56);
break;
default:
analogWrite(10, 0);
}

Notez que, si l’instruction “break” est omise, alors le code continuera en exécutant les différents cas
(“cases”) placés en-dessous du cas qui valide la condition de test, jusqu’à rencontrer l’instruction
break ou la fin de l’expression "switch".

Une présentation exhaustive de l’expression “switch” peut être trouvée dans les ressources internet
telle que https://www.arduino.cc/reference/en/language/structure/control-structure/switchcase/

9.4. Etapes complémentaires pour poursuivre l’apprentissage

Comme le C est un langage de programmation standard, couramment utilisé dans l’industrie, il existe
de très nombreuses ressources disponibles.

En premier lieu, nous vous conseillons de lancer une recherche internet telle que “Débuter en C”. Pour
se focaliser sur Arduino, essayez "Débuter en C avec Arduino" ou un autre choix en anglais, “Arduino
Getting Started” – les sites Arduino ou Adafruit proposent
(https://www.arduino.cc/en/Guide/HomePage), (https://learn.adafruit.com/lesson-0-getting-
started/overview).

Proteus regroupe plusieurs projets exemples, en code C, basés sur Arduino ainsi que des projets pour
d’autre microcontrôleurs. Nous vous suggérons de parcourir les projets exemples (Fichier, Ouvrir un
projet exemple). Entrez “Arduino” dans le champ mots-clés, puis choisissez la catégorie VSM for AVR.
Les projets exemples peuvent être étudiés, modifiés et simulés.

L’environnement de développement intégré officiel Arduino inclut de nombreux projets exemples qui
mettent en œuvre différents concepts (voir https://www.arduino.cc/en/Main/Software).

Notez que Proteus est capable de simuler du code pour microcontrôleur, même si ce code n’a pas été
développé dans l’environnement Proteus ! Par exemple, vous pourriez développer du code dans
l’environnement de développement Arduino (Arduino IDE), et être en mesure de le simuler dans
Proteus. Pour plus d’information sur ce sujet, voir l’aide Proteus sur la simulation “Simulation directe”
dans “Travailler avec des microprocesseurs ”. L’aide sur la simulation dans Proteus est disponible
depuis le menu Aide lorsque l’onglet de simulation est sélectionné / Actif.

124
Les concepts C qui n’ont pas été abordés (ou pas entièrement) dans ce chapitre incluent :

- Tableaux
- Pointeurs
- Expressions de saut (“break” et “continue”)
- Chaîne de caractères
- Structures
- Enumérations
- Bibliothèques

De plus, aucun des concepts spécifiques au langage C++ n’a été présenté. Notez que le compilateur
Arduino est capable de compiler du C/C++. Ceci signifie qu’il peut compiler un programme écrit en C
ainsi qu’un programme écrit en C++.

Généralement, une bonne façon pour apprendre le langage est de modifier des exemples
fonctionnels. Cela permet de se servir de quelque chose qui est déjà opérationnel afin de l’adapter à
votre problème. A chaque étape de modification, il faut tester si tout se passe comme prévu, puis
poursuivre pas à pas. Cette méthode est préférable à celle qui consiste à partir de zéro pour écrire un
programme de taille importante car, dans ce cas, la recherche d’une erreur éventuelle risque de
prendre beaucoup de temps. Notez également qu’il n’est pas nécessaire de comprendre exactement
chaque partie d’un programme fonctionnel lorsque vous devez uniquement modifier une petite partie
pour qu’il fasse ce que vous souhaitez.

Souvenez-vous que, si vous avez compris et terminé avec succès les chapitres précédents, vous savez
déjà comment pense un programmeur. L’apprentissage du C consiste principalement à comprendre
comment structurer les instructions en respectant la syntaxe propre à ce nouveau langage.

9.5. Opérateurs du langage C

Opérateurs arithmétiques Opérateurs relationnels Opérateurs affectation

+ Addition
- Soustraction
* Multiplication
/ Division
% Modulo (reste de
la division)
== Identique a = b; // Affectation
!= Différent de a += b; // a = a + b;
> Supérieur à a *= b; // etc...
< Inférieur à
>= Supérieur ou égal
<= Inférieur ou égal

Opérateurs logique Opérateurs bit à bit Opérateurs unaires

&& AND logique & AND bit à bit i++; // i = i + 1;
|| OR logique | OR bit à bit i--; // i = i – 1;
! NOT logique ^ XOR bit à bit a = ++b; // b = b + 1;
~ Complément de bits // a = b;
a = b++; // a = b;
<< Décalage de bit à
// b = b + 1;
gauche
>> Décalage de bit à
droite

125
9.6. Type de variable C (Arduino)

Type Taille en octets Etendue

byte 1 0 .. 255
[unsigned] char 1 0 .. 255
signed char 1 - 128 .. 127
[signed] short [int] 1 - 128 .. 127
[signed] int 2 -32768 .. 32767
unsigned [int] 2 0 .. 65535
[signed] long [int] 4 -2147483648 .. 2147483647
unsigned long [int] 4 0 .. 4294967295
float 4 -3.4 * 1038 .. +3.4 * 1038

9.7. Pointeurs C
Déclaration de pointeur
char* p; // Déclare “p” comme pointeur de caractère
// (pointeur vers un caractère)

“Valeur” à l’adresse pointée

v = *p; // La valeur de la variable (à l’adresse) pointée par p
// et affectée à v

“Adresse” d’une variable

p = &v; // L’adresse de la variable v est affectée à p
// (p pointe sur v)

9.8. Convertir un algorigramme en code C/C++

Un algorigramme conçu dans le Visual Designer peut être aisément converti en code C/C++. Lors de
l’apprentissage du C, vous pouvez tenter de concevoir un algorigramme puis de la convertir en C. Vous
pourriez faire de même pour les différents projets des premiers chapitres de ce livre. Pour convertir
un algorigramme en code C/C++, il suffit de cliquer droit dans le dossier projets du Visual Designer et
de sélectionner la commande "Convertir en fichier source".

Figure 9-4: Conversion en projet source

126
Comme exemple, convertissons le projet de la section 9.1 en code C/C++.

1. Recréez ou ouvrez à nouveau le projet de la section 9.1 (“C_LED_Algo”).

2. Convertissez le projet en code C/C++, en utilisant la procédure de la Figure 9-4 ci-dessus.
3. Ouvrez le fichier “main.ino” généré à l’issue de la conversion.

Le code résultant devrait ressembler à ceci :

// Généré par Proteus Visual Designer pour Arduino de Proteus

// Code de configuration du périphérique (Do Not Edit)

//---CONFIG_BEGIN---
#pragma GCC push_options
#pragma GCC optimize ("Os")
Directive préprocesseur
#include <core.h> // Requis par cpu #include pour inclure
#include <cpu.h> les bibliothèques

#pragma GCC pop_options

// Constructeurs de périphériques
Déclaration de “Class”
CPU &cpu = Cpu;

void peripheral_setup () {
}

void peripheral_loop() {
}
//---CONFIG_END---
// Variables algorigramme

// Routine algorigramme
void chart_SETUP() { “cpu.pinMode” au lieu
cpu.pinMode(13,OUTPUT); de “pinMode”
}

void chart_LOOP() { Routines “indirectes” setup et

cpu.digitalWrite(13,true); loop (appelées respectivement
delay(1000); depuis les routines principales
cpu.digitalWrite(13,false); setup et loop)

delay(1000);
}

// Points d’entrées et gestionnaires d’interruptions

void setup () { peripheral_setup(); chart_SETUP(); }
void loop () { peripheral_loop(); chart_LOOP(); }

C Code 2: Algorigramme converti en code C

127
Vous noterez que ce code est un peu plus compliqué que celui de la section 9.1 (reproduit à nouveau
en page suivante), cependant, il réalise exactement la même chose. En fait, ce code est généré à
chaque compilation d’un algorigramme (par exemple, avant une simulation).

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

void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}

C Code 3: Version simplifiée du programme “

C Code 2”

Le code qui a été généré automatiquement, lors de la demande de conversion de l’algorigramme, est
légèrement plus compliqué que celui ci-dessus, car il s’adapte à la façon dont le Visual Designer
fonctionne en interne. Cependant, grâce à cet ajout de complexité, le Visual Designer permet de
développer en C/C++ ou de concevoir des algorigrammes, ce qui le rend très attractif.

Nous répétons qu’il n’est pas absolument nécessaire de comprendre comment fonctionne chaque
partie du code généré. Il suffit de vous concentrer sur les parties qui répondent à vos besoins, voire
d’étudier des petites parties du programme pour voir comment Proteus convertit une portion
d’algorigramme en code.

Quoi qu’il en soit, nous donnons quelques explications complémentaires ci-dessous.

9.8.1. Directives de préprocesseur "include"

Le préprocesseur inclut des directives "#include" qui référencent des bibliothèques dont se sert le
programme. Les bibliothèques sont contenues dans des fichiers séparés, sachant que chacune d’elles
peut également faire appel à d’autres bibliothèques.

9.8.2. Déclaration "Class"

Les "classes” sont l’expression en C++ d’une fonctionnalité objet. C’est une façon d’encapsuler des
sections de code ensemble et de les associer à un objet – d’où le nom de “programmation orientée
objets - POO”. Par exemple, nous pourrions concevoir une classe appelée “moniteur”, qui possède des
propriétés “largeur” et “hauteur” (“moniteur.largeur” et “moniteur.hauteur ”), et des méthodes, dont
une appelée “efface” (“moniteur.efface”). Les propriétés sont des variables utilisées dans une classe,
et les méthodes sont des sous-programmes également définis dans une classe. Les propriétés et les
méthodes d’une classe sont accessibles en utilisant le nom de la classe (tel que cpu), suivi d’un point
“.” et enfin le nom de la variable ou de la méthode (tel que digitalWrite).

cpu.digitalWrite(13,true);

Chaque périphérique du Visual Designer est implémenté dans une classe.

128
10. Résumé
Après avoir fait le constat que l’électronique et le logiciel sont importants dans notre quotidien, nous
avons découvert, tout au long de ce cours, qu’il existe des solutions pour apprendre simplement ces
disciplines.

Nous avons appris comment donner des instructions à des ordinateurs en développant des
programmes logiciels adaptés. Les principes fondamentaux de l’électronique ont également été
présentés. Les premiers programmes contenaient une suite d’instructions simples, puis nous avons
poursuivi avec la prise de décisions, l’ajout des variables qui servent à mémoriser une information. Les
notions plus évoluées sont intervenues ensuite, telles que les boucles conditionnelles et les sous-
programmes.

Grâce à un seau, un tuyau et un robinet nous avons appris la loi d’Ohm ; la relation entre la tension ;
la résistance et le courant. Nous avons également appris à dessiner et simuler nos schémas
électroniques personnels.

Si vous avez terminé et compris le contenu de ce livre, vous possédez à présent les outils de base utiles
à la création de machines "intelligentes" et pouvez approfondir vos savoirs grâce aux pistes fournies.
L’industrie électronique évolue rapidement et l’apprentissage est un processus continu lié à
l’amélioration des anciennes technologie et l’apparition de nouvelles. Cependant, les principes de
base présentés dans ce livre restent les mêmes

Il vous appartient de trouver des applications pour mettre en œuvre les outils que vous avez acquis.
La prochaine fois que vous rencontrez dans votre quotidien un problème ou une tache répétitive, vous
examinerez peut-être la possibilité de construire une machine adaptée qui pourra rendre la vie plus
facile aux autres ainsi qu’à vous même

Bon développement !

129
11. Chapitre bonus : Robotique
Au cas où vous ne le saviez pas déjà, l’électricité peut faire bouger les choses !

Traditionnellement, l’électricité permet de générer un déplacement grâce à des moteurs électriques

(qui exploitent le lien entre l’électricité et le magnétisme – " électromagnétisme ”18). Les moteurs
électriques sont extrêmement courants et utilisés dans un grand nombre d’objets de notre quotidien
(climatiseur, réfrigérateur, moteur de porte, perceuse, drone, sèche-cheveux, etc.).

L’électricité peut également être utilisée pour bouger les choses d’une autre façon : comme avec
l’effet piézoélectrique où l’action d’une charge électrique peut provoquer une déformation d’un
matériau18.

En plus d’être la cause d’un déplacement, les signaux électriques interviennent dans les moteurs à
essence ou diésel, car ceux-ci sont gérés par un système de contrôle électronique (injection et
allumage électronique). Même les muscles de notre corps répondent à des stimuli électriques
transmis via nos nerfs.

Lorsque la programmation est appliquée au contrôle intelligent des machines en mouvement, on parle
habituellement de « robotique » ; ce domaine n’est pas très éloigné de ce que vous venez d’appendre,
mis à part que des pièces en mouvement sont impliquées !

Proteus intègre des possibilités de simulation en robotique. En particulier, nous utiliserons un robot
qui s’appelle le Pololu Zumo:

Figure 11-1: Robot Pololu Zumo

18
Dans ce chapitre nous nous contenterons de considérer que l’électricité peut servir à faire bouger un objet
(comme dans le cas d’un moteur électrique). Une explication plus précise sur comment l’électricité sert à créer
un déplacement, sort du cadre de ce livre. Vous pouvez lancer une recherche Internet avec les termes
“Electromagnétisme” / “Moteur DC” / “Piézoélectricité” etc.).

130
Les fonctionnalités de Pololu Zumo:

- Deux moteurs électriques (un pour chaque essieu).

- Une ligne de 6 capteurs infra-rouge qui peuvent servir à suivre des lignes ou détecter les
obstacles.
- Un buzzer piézo, pour jouer des sons (dans ce cas, l’effet piézoélectrique sert à générer une
vibration traduite en ondes sonores).
- Capteurs de navigation:
o Accéléromètre 3-axes (utilise pour détecter quel axe est actif ainsi que vitesse
d’accélération / décélération).
o Magnétomètre 3-axes (“compass”).
o Gyroscope 3-axes (pour détecter la rotation, par exemple si le robot a tourné de 90°
sur la gauche ou la droite).

Plusieurs méthodes pratiques sont incluses dans le Visual Designer pour travailler avec le robot :

Figure 11-2: Quelques méthodes du périphérique Zumo

Des informations spécifiques sur chacune de ces méthodes sont présentes dans le fichier d’aide du
Visual Designer (disponible depuis le menu Aide lorsque l’onglet Visual Designer est actif) :

Figure 11-3: Menu Aide du Visual Designer

131
 Figure 11-4: Sujets de l’aide du Visual Designer

Proteus peut simuler les robots qui naviguent autour d’obstacles / de pistes ; ceci est pratique quand
le matériel physique n’est pas disponible ou pendant les phases de développement ou de débogage
du code / algorithme de contrôle du robot.

Figure 11-5: Simulation robot dans Proteus

Vous pouvez dessiner la piste que vous voulez, en utilisant un simple éditeur graphique tel que MS
Paint (pour une explication détaillée sur la façon de procéder, veuillez-vous reporter à l’aide dont nous

132
venons de parler – sujet “Environnement virtuel / Carte d’obstacles ” – dans ce chapitre, nous
utiliserons simplement un parcours exemple prédéfini).

Nous allons développer un programme de suivi de ligne pour le robot Zumo. Vous pourrez tester le
programme en simulation et, si vous avez un robot physique, vous pourrez vérifier le fonctionnement
réel (un ruban adhésif noir scotché sur le sol permet de définir une ligne).

Figure 11-6: Zumo et piste "Real Life"

11.1. Théorie du suivi de ligne

Une ligne de 6 capteurs infra-rouge est placée sous le robot Zumo.

Figure 11-7: Ligne de capteurs

Le capteur de réflectance fonctionne par émission de lumière, puis par mesure de la quantité de
lumière réfléchie (veuillez noter que la lumière rouge visible sur l’image ci-dessus ne correspond pas
à la lumière émise/détectée par les capteurs – ceux-ci utilisent une lumière infra-rouge, invisible aux
êtres humains). Sachant que plus l’objet placé sous le capteur est sombre, moins il réfléchit de lumière,
les capteurs peuvent être utilisés pour repérer une ligne noire placée sur un fond blanc.

Comme le Zumo dispose de 6 capteurs répartis uniformément, il est possible de savoir si la ligne noire
est au milieu, sur la gauche ou la droite du robot. Afin de suivre la ligne, le robot devrait se déplacer
préférentiellement au-dessus des capteurs centraux :

133
 Position de la ligne Action requise (pour “revenir sur la piste ”)
Très à gauche Tourner fortement à gauche
Gauche Tourner légèrement à gauche
Milieu Continuer tout droit
Droite Tourner légèrement à droite
Très à droite Tourner fortement à droite

Figure 11-8: Action corrective selon la position de la ligne

Si la ligne est sous le(s) capteur(s) de gauche, et que l’action correctrice consiste à tourner à gauche,
alors le robot s’orientera afin que les capteurs centraux soient activés – et vice versa pour la droite.
Bien évidemment, tant que le robot perçoit les capteurs du milieu actifs, s’il poursuit sa route sans
changer de direction, il suivra correctement la ligne.

Nous vous invitons à bien regarder la figure ci-dessus pour comprendre la relation entre la ligne, la
position du robot et l’action correctrice à envisager.

Figure 11-9: Effet d’un virage à droite sur les capteurs de la ligne

Cette façon de contrôler un système est dit "proportionnel" ; la correction est proportionnelle à
l’éloignement par rapport aux capteurs centraux – plus l’écart est important, plus on tourne les roues
pour ramener rapidement le robot sur "les rails". Ce type de contrôle proportionnel peut provoquer
des oscillations dans le cheminement du robot (voir figure ci-dessous). Sachez qu’il existe des
méthodes plus sophistiquées de contrôle d’asservissement pour retrouver et conserver la bonne
position, tel que le PID (proportionnel-Intégral-Dérivé).

Figure 11-10: Oscillations éventuelles liées au contrôle proportionnel

Cependant, pour notre projet, l’asservissement “proportionnel” sera suffisant.

134
11.2. Construire le programme : Le plan
Dans notre programme, nous utiliserons deux méthodes du Zumo: “drive” et “readLinePos”.

Figure 11-11: Méthodes du périphérique Zumo à utiliser

11.2.1. Méthode “drive”

Paramètre Valeurs possibles Description
Wheel - Both (les deux) Spécifie quelle(s) roue(s) sont concernée(s) par la
(roue) - Left (gauche) vitesse/direction.
- Right (droite)
Dir - Forwards (avant) Spécifie le sens de rotation des roues ; en avant ou en
(direction) - Backwards (arrière) arrière.
Speed 0-255 Spécifie la vitesse de rotation des roues ; entre 0
(vitesse) (arrêt) et 255 (vitesse max).

- Pour avancer en ligne droite, choisir "Both", "forward" ainsi que la vitesse entre 1 et 255.
- Pour tourner à gauche, la roue droite doit tourner à une vitesse supérieure que celle de la
roue gauche – Inversement pour un virage à droite.
- Lors d’un virage, le robot tournera plus ou moins brusquement selon la différence de vitesse
entre les deux essieux.

Figure 11-12: Virage plus ou moins brusque selon la différence de vitesse entre essieux

Pour tourner, il est nécessaire d’utiliser deux fois la méthode “drive”– une fois pour chaque roue.

Pour aller tout droit, il est nécessaire d’utiliser la méthode “drive” une seule fois – avec le paramètre
“Wheel” positionné sur “Both”; nous pourrions aussi aller tout droit en utilisant deux fois la méthode
“drive” (une fois pour chaque roue), avec une vitesse et une direction identiques lors des deux appels.

135
11.2.2. Méthode “readLinePos”
La méthode “readLinePos” retourne une valeur comprise entre 0 et 5000, qui représente la position
de la ligne sous les capteurs – “0” signifie que la ligne est placée sous le capteur le plus à gauche et
“5000” indique que la ligne est sous le capteur le plus à droite. Pour une ligne sous les capteurs du
milieu, la lecture donnera 2500.

Figure 11-13: Example de résultat de "readLinePos" pour différentes positions de la ligne

11.2.3. Le plan
La structure de base de notre programme sera :

1. Lire la position de la ligne.

2. Calculer l’écart entre le robot et la ligne afin de déterminer s’il faut tourner et dans quelle
direction – nous appellerons cette tâche la “déviation”.
3. Ajuster la vitesse des moteurs, afin que le robot tourne dans la bonne direction afin de revenir
sur la ligne.

Une façon d’obtenir un avancement correct en ligne droite est de positionner la vitesse des deux
moteurs à 50%, puis d’ajouter ou de soustraire une vitesse à chaque moteur selon la rotation
souhaitée. Ceci signifie que nous pourrions ajouter ou soustraire jusqu’à 50% de vitesse à chaque
moteur (un moteur pourrait être à 100% de sa vitesse lorsque l’autre est à 0%). Il faut donc représenter
la "déviation" sous la forme d’une valeur qui peut varier de -50% à +50%, à ajouter ou soustraire à
chaque moteur.

- Comme la “pleine vitesse” de chaque moteur est obtenue avec une valeur de 255, une vitesse
de 50% équivaut à 127.

- La déviation sera convertie en un nombre compris entre -127 et +127 (qui représente une
variation de vitesse de -50% à +50%. Ces valeurs sont à rapprocher de la lecture des 6 capteurs
qui varie de 0 à 5000.
o Lorsque la ligne est placée sous les capteurs centraux, le nombre lu est 2500. Nous
souhaitons soustraire cette valeur afin que la déviation soit de 0 pour une ligne vue
sous les capteurs centraux.
o Après soustraction d’une lecture de 2500, nous obtenons un nombre compris entre
-2500 et +2500. Cette valeur doit être mise à l’échelle dans la gamme -127 à +127.
Une bonne approximation est obtenue en divisant ce nombre par 20 (-2500/20=-125,
et +2500/20=+125). L’écart entre 127 et 125 est acceptable.
o La formule de calcul de la déviation est donc :
deviation = ( lecture - 2500 )/20

136
 Une analyse rapide de notre formule montre que le comportement est correct :
▪ Une lecture de 2500 (ligne sous les capteurs centraux) donne une déviation
de 0.
▪ Une lecture de 0 (ligne sous le capteur à l’extrémité gauche) donne une
déviation de -125.
▪ Une lecture de 0 (ligne sous le capteur à l’extrémité droite) donne une
déviation de +125.

- A présent, nous devons utiliser la déviation calculée pour ajuster la vitesse des moteurs. Si la
ligne est sur la droite du robot, alors la déviation sera positive. Afin de tourner à droite (pour
revenir sur la "piste”, sous les capteurs centraux), nous devons augmenter la vitesse des roues
à gauche et augmenter celle des roues à droite, ce qui nous donne les formules :

VitesseRoueGauche = 127 + deviation

VitesseRoueDroite = 127 – deviation

C’est fini ! Vous auriez pu penser que le suivi de ligne du robot était compliqué à programmer, mais
avec un peu de mathématiques, nous avons fait cela en quelques étapes.

Bien sûr, l’algorithme à concevoir n’était pas extrêmement compliqué, mais il constitue une bonne
introduction. La solution trouvée est simple et devrait fonctionner correctement.

11.3. Construire le programme : Mettre le plan en action

Comme vous savez démarrer un nouveau projet et ajouter des périphériques, nous pourrons passer
directement à la phase de conception de l’algorigramme :

1. Lancez un nouveau projet algorigramme (en utilisant une Arduino Uno; le projet peut
s’appeler “SuiviLigneZumo”).

2. Ajoutez le périphérique “Arduino Zumo Robot” au projet (il est placé dans la catégorie “Motor
Control”).

3. Définissez l’algorigramme (détails ci-dessous).

4. Spécifiez la carte qui contient la ligne que notre robot doit suivre (détails ci-dessous).

137
11.3.1. Construire l’algorigramme
L’algorigramme ressemblera à ce qui suit :

Figure 11-14: Algorigramme simple de suivi de ligne

Cela correspond aux étapes de notre “Le plan”. Notez que nous avons besoin de 2 variables :

Figure 11-15: Les variables

Si vous avez des difficultés à définir l’algorigramme ou à ajouter des variables, veuillez revoir les
chapitres précédents qui parlent de ces sujets.

138
11.3.2. Spécifier la carte
Pour spécifier la carte (la piste) du robot, sur la feuille du schéma, éditer les propriétés du robot Zumo.

Figure 11-16: Accès aux propriétés du Zumo dans l’éditeur de schéma

Figure 11-17: Propriétés du Zumo

Comme mentionné précédemment, vous pouvez dessiner la piste que doit suivre le robot, en utilisant
un logiciel de dessin tel que MS Paint. Pour ce chapitre, nous allons utiliser une simple piste déjà
présente dans le dossier “Samples” de Proteus (habituellement “C:\ProgramData\Labcenter
Electronics\Proteus 8 Professional\SAMPLES\Visual Designer for Arduino\Virtual Turtle\”). Nous nous
servirons du fichier “Line Follow.png”.

139
Ce parcours peut également être téléchargé depuis le site www.dizzy.co.za/zumo-st .

Figure 11-18: Piste simple de "Suivi de ligne "

Pour charger la piste exemple dans Proteus, cliquez sur le bouton “Parcourir” lié au champ “Obstacle
Map” :

Figure 11-19: Champ "Obstacle map" et bouton "Browse"

Parcourez les dossiers jusqu’au fichier “Line Follow.png” et cliquez sur “Ouvrir”.

Figure 11-20: Parcours

140
Ensuite– comme notre programme est relativement simple et ne gère pas le robot lorsqu’il n’est pas
du tout au-dessus d’une ligne – nous devons nous assurer que le robot est placé au-dessus d’une ligne
au démarrage. Pour cela, nous entrons un angle de départ, une position horizontale et verticale du
robot sur la piste :

Angle -60
Horizontal Position 265
Vertical Position 520

Figure 11-21: Champs liés à la position de lancement du Zumo

(Ces valeurs ont été précalculées et elles fonctionnent, mais d’autres valeurs peuvent également être
utilisées et vous êtes libre de faire des essais)

Ceci positionne le robot en bas et à gauche de la piste :

Figure 11-22: Position de départ du Zumo

Lorsque vous êtes prêts, cliquez sur “OK” pour appliquer les modifications apportées au périphérique
Zumo.

141
11.4. Le moment de vérité
Cliquez sur le bouton “Play” pour lancer la simulation, et vous pourrez observer le robot suivre la ligne,
ou s’il se perd dans l’oubli !

Figure 11-23: Simulation du suivi de ligne

Si tout a été fait correctement, notre robot devrait suivre la ligne sans la perdre.

11.5. Résumé
En termes de programmation, la robotique n’est pas réellement plus complexe que ce que nous
savons déjà – seule la notion de déplacement a été ajoutée.

Comme introduction, nous avons créé un programme très simple pour aider un robot à suivre une
ligne ; vous pouvez améliorer l’algorigramme en expérimentant des algorithmes meilleurs de retour
sur la ligne, d’autres parcours, d’autres applications.

Proteus inclut plusieurs exemples de projet robotique que nous vous conseillons de regarder. Vous
pouvez aussi essayer des robots différents ; la suite vous appartient. Bonne programmation avec le
Visual Designer !

142
12. Notes de l’auteur
12.1. Sujets non présentés
Les sujets suivants n’ont pas encore été abordés dans ce livre (mais ils pourraient l’être dans une
version future). Ils sont indiqués dans l’hypothèse où vous souhaitez poursuivre l’apprentissage par
vous-même.

Sujet Ressources pour un auto-apprentissage

Débogage - “Simulation and Debug Skills” sous-catégorie de l’aide Proteus Visual
Designer19 (dans le sujet “VISUAL DESIGNER”).
Modulation par - “Tutorial 4: Motor Control (Shield)”, dans la catégorie “TUTORIALS” de
largeur l’aide de Proteus Visual Designer 19.
d’impulsion - https://learn.adafruit.com/adafruit-arduino-lesson-3-rgb-leds
Interruptions - Projet exemple “External and Timer Interrupts Demo”.
- https://learn.adafruit.com/multi-tasking-the-arduino-part-2
- https://www.sparkfun.com/tutorials/326
- https://learn.adafruit.com/multi-tasking-the-arduino-part-3
Machines - https://learn.adafruit.com/multi-tasking-the-arduino-part-1
d’états
Accès fichier - “Tutorial 3: SD Card and TFT (Shield)” dans la catégorie “TUTORIALS” de
(carte SD) l’aide de Proteus Visual Designer19.

19
Le fichier d’aide de Proteus Visual Designer s’ouvre depuis le menu ‘Aide’ lorsque l‘onglet Visual Designer est
ouvert et sélectionné, ou depuis la zone “Aide” de l’onglet d’accueil de Proteus.

143
Appendix A: Challenges
Afin que vous pratiquiez à votre tour et voir si les concepts vus sont bien compris (et pas simplement
recopiés), des challenges sont inclus. Vous devrez probablement relire certaines sections d’un chapitre
afin de terminer un challenge. Notez que les challenges ne sont pas un prérequis pour progresser dans
la lecture de ce livre (c’est pourquoi nous les avons inclus dans un appendice plutôt que dans un
chapitre), donc ne soyez pas inquiets si vous n’arrivez pas terminer un challenge – vous pourrez
toujours y revenir plus tard.

Des solutions possibles aux challenges sont listées en Appendix B. Souvenez-vous qu’il existe plusieurs
façons de résoudre un challenge, c’est pourquoi votre solution peut être légèrement différente de
celle du livre. Le plus important est que votre programme fonctionne (quoi qu’il en soit, il est
préférable de se servir de la technique présentée dans un chapitre pour y arriver).

Procédure générale pour les challenges

1. Sauvegardez ( ) tout projet ouvert afin de ne pas le perdre. Ceci est possible grâce à la
commande “Enregistrer le projet ” du menu Fichier.
2. Fermez ( ) tout projet existant qui pourrait être ouvert. Ceci est possible grâce à la
commande “Fermer projet ” du menu Fichier. Vous devriez voir l’onglet d’accueil de Proteus
( ).
3. Sauf indication contraire (la plupart des challenges sont des algorigrammes, sauf quelques-
uns), lancez un nouveau projet algorigramme (section 2.2) – le nom du challenge peut être
utilisé comme nom de projet.

Chapitre 2 (Créer votre premier projet)

Battements de cœur avec une LED

Eléments nécessaires

Qté Matériel Ajout du projet dans Proteus

1 Arduino Uno Assistant de création nouvel algorigramme

Challenge
Se servir de la LED interne à la carte Arduino Uno pour construire un algorigramme qui fait clignoter
la LED deux fois rapidement, puis attend avant de recommencer (boucle). Ceci mime visuellement les
battements d’un cœur.

Ceci est représenté graphiquement ci-dessous (les cycles de répétitions sont grisés) :

Choisissez des timings qui vous conviennent. Nous suggérons 250 millisecondes de temps ON, 500
millisecondes de temps OFF et des attentes de 2 secondes.

144
Chapitre 3 (Lire des entrées et prendre des décisions)
Clignotements à la demande

Eléments nécessaires

Qté Matériel Ajout du projet dans Proteus

1 Arduino Uno Assistant de création nouvel algorigramme
1 Grove Momentary Action Push Button Galerie de périphérique (Catégorie Grove)
1 Grove LED (Green) Galerie de périphérique (Catégorie Grove)

Challenge
Concevoir un algorigramme qui fait clignoter une LED, uniquement lorsqu’un bouton est appuyé (si ce
n’est pas le cas, la LED doit rester éteinte).

Le timing de clignotement n’est pas important. Nous suggérons 1 seconde ON et 1 seconde OFF.

Modification de la fréquence de clignotement

Eléments nécessaires

Qté Matériel Ajout du projet dans Proteus

1 Arduino Uno Assistant de création nouvel algorigramme
1 Grove Momentary Action Push Button Galerie de périphérique (Catégorie Grove)
1 Grove LED (Green) Galerie de périphérique (Catégorie Grove)

Challenge
Concevoir un algorigramme qui fait clignoter une LED lentement lorsqu’un bouton n’est pas enfoncé,
et plus rapidement lorsqu’il est enfoncé.

Nous suggérons un timing de 1 seconde ON / 1 seconde OFF pour un clignotement lent, et 250
millisecondes ON / 250 millisecondes OFF pour un clignotement rapide.

Astuce
La méthode “toggle” de la LED Grove peut être utilisée pour commuter sur l’état ON lorsqu’elle est
sur OFF et réciproquement. Il n’est pas obligatoire de se servir de cette méthode, cependant elle rend
l’algorigramme plus court et plus simple.

145
Chapitre 4 (Variables)
Veilleuse

Eléments nécessaires
Qté Matériel Ajout du projet dans Proteus
1 Arduino Uno Assistant de création nouvel algorigramme
1 Grove Luminance Sensor Galerie de périphérique (Catégorie Grove)
1 Grove LED (Green) Galerie de périphérique (Catégorie Grove)

Challenge
Concevoir une veilleuse automatique – une lampe qui s’allume automatiquement lorsque la
luminosité ambiante est faible. Le capteur "Grove Luminance" mesure la luminosité ; pour ce
challenge, une lecture de luminance inférieure à 300 sera considérée comme “nuit”, autrement ce
sera “jour”. Noter que la veilleuse sera une LED qui s’allume ou s’éteint selon la valeur de luminance
lue par le capteur.

Composant
capteur de
luminance

A-1: Capteur de luminance Grove

Astuce
La méthode “readLuminance” du capteur "Grove Luminance" sert à lire la luminance (niveau de
lumière). Par défaut, cette méthode place automatiquement le niveau dans une variable de nom
“Lux”, que vous pouvez utiliser n’importe où dans votre programme (par exemple dans un bloc de
décision).

Le capteur de luminance est représenté par une fenêtre, qui montre le soleil lorsqu’il fait ‘jour’ et des
étoiles lorsqu’il fait ‘nuit’. Pour modifier la luminosité – utilisez les boutons HAUT et BAS placés en bas
et à droite.

Changez la Changez la
luminosité luminosité

146
Décompte avant décollage

Eléments nécessaires

Qté Matériel Ajout du projet dans Proteus

1 Arduino Uno Assistant de création nouvel algorigramme
1 Module Grove RGB LCD Galerie de périphérique (Catégorie Grove)
1 Grove Momentary Action Push Button Galerie de périphérique (Catégorie Grove)
(Bonus optionnel)

Challenge
Concevoir un algorigramme qui décompte de 10 à 0 (avec une attente de 1 seconde), affiche la valeur
du décompte sur la ligne du haut d’un LCD. Lorsque 0 est atteint, il affiche le texte “Decollage!”(sans
accent) sur la ligne du bas du LCD.

Bonus optionnel : Ajouter un bouton qui ajoute 3 au compteur lorsqu’il est enfoncé.

Astuces
Lorsque vous écrivez quelque chose sur un LCD, seuls les caractères indiqués sont écrits, en laissant le
reste de l’affichage inchangé. Ceci est très pratique si vous souhaitez mettre à jour des parties du LCD,
sans modifier le reste.

Par exemple, si vous écrivez “10” (deux caractères) sur le LCD, puis souhaitez afficher “9” (un seul
caractère) à la même position, vous obtiendrez “90” ! Le caractère 9 remplace le 1 alors que le 0 du
10 n’est pas modifié. Il existe deux solutions pour tenir compte de ces cas de figures :

La première consiste à effacer la totalité du LCD avant d’écrire quoi que ce soit. Pour cela, la méthode
“clear” du LCD peut être employée (normalement, elle est placée au début de la boucle).

La seconde possibilité est d’écrire des caractères vides (tel que des espaces " ") au-dessus de tout ce
qui doit être effacé. Donc, par exemple, vous commencez par écrire deux caractères vides au-dessus
du “10” pour l’effacer, puis écrivez “9”. L’écriture des caractères qui effacent la zone et l’écriture du
“9” seront placés dans deux blocs d’algorigramme différents, avec un bloc “setCursor” ou “home”
entre les deux.

Pour le bonus optionnel, notez que le bouton doit être maintenu enfoncé pendant au moins 1 seconde
pour qu’il soit pris en compte. Il existe plusieurs façons de répondre à cette demande (tel qu’une
décomposition de l’attente en plusieurs morceaux).

147
Chapitre 6 (Dessiner et simuler des circuits)
Loi d’Ohm

Création du projet
Ce projet ne nécessite pas d’algorigramme. Pour la procédure de lancement d’un projet comme celui-
ci, voir la section 6.4.

Eléments nécessaires

Qty Matériel Ajout du projet dans Proteus

1 RES (Résistance), valeur de 5R (5 ohms)
1 Terminal POWER, valeur de +10V (10 volts)
1 Terminal GROUND
1 DC Ammeter (Ampèremètre DC)
Mode outils : Composant de schéma
(Prendre en bibliothèque)
Mode outils : Terminaux de schéma
Mode outils : Terminaux de schéma
Mode outils : Instruments virtuels

Challenge
Soit une tension de 10 volts et une résistance de 5 ohms ; calculez le courant résultant en ampère
(selon la loi d’Ohm). Dessinez un circuit dans Proteus pour vérifier le calcul par simulation.

148
Chapitre 8 (Sous-programmes et boucles conditionnelles)
Deux tons

Eléments nécessaires

Qté Matériel Ajout du projet dans Proteus

1 Arduino Uno Assistant de création nouvel algorigramme
1 Shield Adafruit NeoPixel Galerie de périphérique (Catégorie Adafruit)

Challenge
Validez la couleur rouge (“red”) pour les 20 premiers pixels, et la couleur verte (“green”) pour les 20
pixels restants.

Astuce
Les 20 premiers pixels sont numérotés de 0 à 19, et les suivants de 20 à 39.

Damier

Eléments nécessaires

Qté Matériel Ajout du projet dans Proteus

1 Arduino Uno Assistant de création nouvel algorigramme
1 Shield Adafruit NeoPixel Galerie de périphérique (Catégorie Adafruit)

Challenge
Afficher un damier (pixels alternés blancs et noirs) sur le shield NeoPixel.

Astuces
Un pixel blanc est généré lorsque les trois canaux de couleur (rouge, vert et bleu) sont à leur intensité
maximale (255). Un pixel noir est généré lorsque les trois canaux de couleur (rouge, vert et bleu) sont
à leur intensité minimale (0).

Comme pour la plupart des programmes, il existe plusieurs façons de résoudre ce challenge (une des
deux techniques présentées ci-dessous peut être utilisée) :

a) Une boucle (loop) avec la valeur “Pas” à 2 sert à compter “0, 2, 4, etc”.
b) Une équation mathématique telle que “intensity=255-intensity” peut servir à commuter
“intensity” entre 255 et 0.

149
Eclats lumineux pulsés

Eléments nécessaires

Qté Matériel Ajout du projet dans Proteus

1 Arduino Uno Assistant de création nouvel algorigramme
1 Adafruit NeoPixel Shield Galerie de périphérique (Catégorie Adafruit)

Challenge
En prenant une couleur rouge, faites varier lentement tous les pixels depuis l’intensité 0 (red=0)
jusqu’à l’intensité maximale (red=255), puis revenir à une extinction progressive (et recommencez).

Bonus optionnel : Au lieu de faire varier uniquement une couleur rouge, pulsez la couleur rouge, puis
verte et enfin bleue (et recommencez).

Astuces
Une attente de 5ms entre chaque mise à jour de l’affichage (méthode “show”) est recommandée.

Pour le bonus optionnel :

L’intensité d’un pixel peut varier grâce à l’équation suivante “r=red*intensity/255”, où

“intensity”(intensité) est une variable dont la valeur est comprise entre 0 et 255. Analysons cette
équation :

- Si l’intensité vaut 255, alors il n’y a aucun effet sur la variable “red” (255 / 255 = 1).
- Si l’intensité vaut 0, alors “r” devient 0 (0 / 255 = 0).
- Si l’intensité vaut 127, alors “r” vaut approximativement la moitié de “red” (127 / 255 = 0.5
environ).

150
Appendix B: Solutions des challenges
Cet appendice présente des solutions possibles aux challenges proposés en Appendix A. Rappelez-
vous qu’il existe plusieurs manières de résoudre un challenge en programmation. Donc, si votre
solution ne correspond pas exactement à celle listée dans ce livre, ne soyez pas inquiet ! Le plus
important est que le programme fonctionne (bien évidemment, il est recommandé de se servir de la
technique présentée dans le chapitre référencé).

Chapitre 2 (Créer votre premier projet)

Battements de cœur avec une LED

151
Chapitre 3 (Lire des entrées et prendre des décisions)
Clignotements à la demande

Modification de la fréquence de clignotement

152
Chapitre 4 (Variables)
Veilleuse

Décompte avant décollage

Bonus
optionnel
nal Bonus

153
Chapitre 6 (Dessiner et simuler des circuits)
Loi d’Ohm

Chapitre 8 (Sous-programmes et boucles conditionnelles)

Deux tons

154
Damier

Exemple de solution 1 Exemple de solution 2

Eclats lumineux pulsés

Note : Les exemples incorporent le bonus optionnel proposé dans les challenges.

155