Ce module a pour but de vous proposer une introduction au monde des microcontrôleurs programmables, à l’aide de la solution proposée par la marque Arduino.

Cette solution se compose de trois parties :

• Le microcontrôleur, placé sur une carte Arduino UNO se présentant comme un
  périphérique USB externe.
• L’environnement de programmation, créé également par Arduino.
• Un langage de programmation basé sur C++ avec l’ajout de fonctions dédiées

ATTENTION : Veuillez respecter ces consignes afin d’éviter d’altérer ou d’endommager les composants :

• Touchez toujours les composants avec des mains propres et sèches : l’humidité, la graisse et les impuretés peuvent nuire au passage du courant ;
• Dans la mesure du possible, ne tordez jamais les pattes métalliques des composants électroniques. Cela étant impossible avec les résistances, ne pliez pas les pattes, mais coudez-les de la manière la moins abrupte possible : risque de les casser ;
• Bien que la tension soit basse et que vous ne risquez pas de blessures dues au courant, ne touchez pas les pattes des composants sur un circuit sous tension, les courts-circuits peuvent endommager le matériel ;
• Si vous n’êtes pas familier avec les notions d’électronique, prenez le temps de bien lire entièrement les énoncés avant de commencer à réaliser les montages électroniques.

C’est dans l’Interaction Design Institute Ivrea, une école située dans la ville italienne d’Ivrea, à mi-chemin entre Aoste et Turin qu’un étudiant colombien nommé Hernando Barragan a créé en 2004 une plateforme de développement nommée Wiring comme projet de thèse de master.

Ce projet consistait à créer un moyen de rendre possible la création de projets numériques pour des non-ingénieurs.
Le principe de base s’appuyait sur deux axes :

• La création d’un circuit imprimé facile d’utilisation basé sur un microcontrôleur Atmel ATMega168
• L’ajout à un langage de programmation préexistant, appelé Processing, de fonctions spécifiques au pilotage de ce microcontrôleur.

L’année suivante, Massimo Banzi, un de ses directeurs de thèse, avec l’aide de David Mellis, un autre étudiant de cet institut et de David Cuartielles, universitaire suédois d’origine espagnole, ont décidé de faire évoluer le projet en utilisant un contrôleur ATMega8, moins onéreux, et ont créé un projet dérivé, open-source, appelé Arduino.

Voici un des premiers prototypes d’Arduino:

Le nom Arduino est celui d’un bar à Ivrea, nommé en l’honneur d’un roi d’Italie du XIème siècle originaire de la ville, où certains des fondateurs du projet aimaient à se rencontrer. L’attrait de ce projet a suscité a poussé les créateurs à produire une première série de cartes utilisables, qui ont tout de suite rencontré un vif intérêt auprès d’instituts de formations, puis le grand public a commencé à s’y intéresser.

Voilà à quoi ressemblaient les premières cartes Arduino commercialisées. Au début, ces cartes ne communiquaient pas via l’USB, mais avec un protocole appelé RS-232 ou Série:

Actuellement, la gamme de produits Arduino comporte de nombreuses cartes aux spécifications différentes, un environnement de programmation multi-plateforme tournant sous Java, ainsi que de nombreuses extensions matérielles (appelées « shields ») pouvant se connecter aux cartes de bases.

Voici par exemple une carte permettant la communication Ethernet à une carte Arduino Uno:

Pour le pilotage de ce genre de composants, il existe des ensembles de fonction du langage supplémentaires dédiées, appelés bibliothèques, crées pour faciliter la programmation.

Présentation de la carte Arduino UNO

Voici une illustration de la carte que nous allons utiliser pour ce module avec ses principaux composants, vous pourrez vous y référer quand il sera fait mention d’un composant. (Source : site officiel) :

1) Présentation de l’interface

Voici une image de l’interface du logiciel Arduino. Elle est minimaliste, tout en étant
conviviale et complète :

2) Paramétrer le dossier de travail

On peut, dans le logiciel Arduino, définir l’emplacement par défaut où sont enregistrés les projets. Nous allons en créer un :

• Créez un dossier pour vos projets dans votre dossier personnel sur le réseau.
• Dans le logiciel Arduino, allez dans le menu Fichier -> Préférences
• Entrez le chemin d’accès au dossier préalablement créé dans le champ « Emplacement du carnet de croquis »

Ceci sera votre dossier de travail pour le module. Tout nouveau programme sera enregistré par défaut dans ce répertoire.

3) Vérifier les paramètres de matériel dans le logiciel

La dernière étape du processus d’installation consiste à vérifier que le logiciel sera capable de communiques avec la carte Arduino. Il faut pour cela définir le type de carte utilisée et le numéro de port de communication utilisé par la carte et les renseigner dans le logiciel.

• Dans le menu « Outils -> type de carte », vérifiez que « Arduino/Genuino Uno » est bien sélectionné
• Dans le menu « Outils -> Ports », le port sur lequel est branchée la carte est clairement explicité : le nom de la carte est marqué à côté

Vous pouvez à tout moment vérifier ces informations dans le champ correspondant.

4) Afficher des aides supplémentaires

Nous allons activer quelques options supplémentaires du logiciel pour obtenir nous aider lors de l’édition et de la vérification des programmes

• Dans le menu « Fichier -> Préférences », cochez les options:
  – compilation
  – téléversement
  – afficher les numéros de ligne
  – activer le repli de code

1) Introduction succincte au langage de programmation

Le langage de programmation utilisé est basé sur le langage C++. C’est un langage beaucoup plus évolué que le BASIC. Il est utilisé actuellement pour la programmation d’applications complexes, par exemple les jeux vidéo. Ce langage a sa propre syntaxe (c’est-à-dire ses propres règles d’écriture).

2) Structure d’un programme et commandes obligatoires

Nous allons commencer par voir les éléments indispensables à l’exécution d’un programme sur Arduino. Pour ce faire, il faut ouvrir le programme d’exemple avec le code minimal.

• Cliquez sur le bouton « Ouvrir »
• Dans le menu, allez dans « 01.Basics », puis cliquez sur « BareMinimum »

Voici ce qu’on obtient:

Un programme pour Arduino contient obligatoirement deux parties, appelées fonctions :

• La fonction « setup » qui permet d’exécuter une fois des instructions au démarrage (Par analogie au monde aéronautique, c’est la check-list de pré-décollage)
• La fonction « loop« , qui est une boucle, et qui contiendra le programme proprement dit. (Toujours par analogie au monde de l’aviation, pendant le vol, gagner de l’altitude, tourner, atterrir, etc…)
• Le contenu d’une fonction (c’est-à-dire le code exécuté par celle-ci) se situe obligatoirement entre les accolades ouvrantes et fermantes ( ‘’{‘’ et ’’ } ’’ )
• Le double slash ( // ) est l’équivalent de l’apostrophe du BASIC et sert à insérer un commentaire

L’utilisation et la façon de créer des fonctions seront expliquées un peu plus tard dans le module.

3) Vérifier le code

Une fois que le code est tapé, il faut vérifier qu’il est conforme (c’est-à-dire que le logiciel Arduino le comprend), pour cela, le logiciel traduit le programme en langage « machine », mais ne l’envoie pas à la carte. Si des erreurs sont trouvées, des messages d’erreur apparaîtront en rouge dans la zone d’information, sinon, un résumé sera affiché dans cette même zone.

• Cliquez sur le bouton « Vérifier »

Dans les dernières lignes de message affichées, le texte est un résumé de l’espace que va prendre le programme dans la mémoire de la carte. il est affiché en blanc, ce qui indique que la vérification n’a rencontré aucun problème.

4) Test d’un code erroné: introduction à la notion de débogage

Nous allons faire un petit test : rendre le code incorrect et voir comment le logiciel nous indique les erreurs.

• Enlevez la dernière accolade du programme, située à la ligne 9
• Cliquez sur le bouton Vérifier

Cette fois-ci, le message affiché par le logiciel est tout autre, voici ce qui est affiché:

Regardons les parties entourées :

–  » in function ‘void loop()’  » : L’erreur se situe au sein de la fonction Loop
–  » BareMinimum :6 : error : expected ‘}’ at end of input  » indique le nom du
programme (BareMinimum), le numéro de ligne du programme où se situe l’erreur
(6), l’importance de l’erreur (error, le degré le plus élevé) et ce qui a provoqué l’erreur (expected ‘}’ at end of input, c’est-à-dire :  » }  » attendu à la fin )

Remarque importante : Nous sommes dès le début confrontés à une des limitations du débogage : l’erreur se situe à la fin de la fonction (ligne 9) mais l’erreur indique que l’erreur se situe dans la fonction (ligne 6).
Nous pouvons en déduire que le message indique l’endroit du programme où l’erreur entraîne des conséquences, et non pas forcément l’endroit où elle se situe, ce qui peut rendre difficile sa résolution et entraîne un travail d’enquête parfois laborieux.
Dans le cas de programmes plus complexes, une erreur se situant sur une ligne donnée aura potentiellement des conséquences sur le programme des dizaines de lignes plus tard, voire, dans le cas d’une accolade ouvrante manquante, dans une autre fonction du programme.

Remettons les choses en ordre :

• Réinsérez l’accolade fermante à la ligne 9
• Relancez une vérification
• Vérifiez que l’erreur est bien réparée

Et voilà ! Votre premier débogage sur Arduino !

5) Envoyer le programme à la carte : que se passe-t-il

Maintenant, envoyons ce programme sur la carte Arduino pour voir ce qui se passe:

• Cliquez sur le bouton  » Téléverser « 
• Immédiatement après, observez le comportement des témoins d’activité sur la carte (Les LED situées tout de suite à gauche du logo Arduino), jusqu’à ce plus aucun d’entre eux ne clignote
• Vous pouvez répéter l’opération pour revoir l’activité des LED de la carte

Commençons par analyser ce qui vient de se passer sur la carte :

Le témoin « ON » est allumé en vert : la carte est alimentée, le plus intéressant s’est produit au niveau des témoins d’état (Les trois diodes oranges notées « L », « TX » et « RX ») :

– La diode L est allumée, ce qui indique par défaut qu’un programme est en cours
d’exécution sur la carte.
– Les diodes TX et RX ont brièvement clignoté, avant de s’éteindre. Cela a indiqué que des données ont été échangées entre la carte et l’ordinateur :
    – La diode TX indique que la carte envoie des données.
    – La diode RX indique que la carte reçoit des données.

Au niveau du logiciel, ce qui a été affiché dans la zone de messages est plus long. Sans entrer dans les détails, il y a deux parties :

– Le texte blanc correspond, comme avant, à la compilation du programme, sa
traduction en langage machine.

– Le texte orange correspond à des messages commentant le processus de transfert du programme vers la carte. Il peut être partagé en trois parties :

    – Vérification de l’état matériel de la carte,
    – Ecriture du programme dans la mémoire de la carte et
    – Comparaison entre le programme sur la carte et la version sur le disque dur,
       pour vérifier le transfert sans erreur.

6) Eteindre la LED sur la carte

Par défaut, la LED d’état « L » est allumée lors de l’exécution d’un programme.
On appelle un composant situé sur un appareil un composant « embarqué », « built-in » en anglais.

La LED « L » est donc une LED embarquée et c’est sous ce nom que nous la désignerons au programme.
Il faut maintenant donner deux instructions à la carte, en entrant des commandes dans le programme :

– Définir la LED comme un dispositif de sortie (Le microcontrôleur enverra du courant vers la LED), dans la fonction « setup » (Exécution au démarrage de la carte)
– Dire au microcontrôleur d’arrêter d’envoyer du courant vers la LED

Nous utiliserons les commandes :
–  » pinMode  » : fonction définissant le mode de fonctionnement d’un Pin,
–  » digitalWrite  » : fonction envoyant des informations sur un Pin.
Et des paramètres prédéfinis (Ce sont des variables que le logiciel connaît déjà) :
–  » LED_BUILTIN  » : variable désignant la LED embarquée
–  » OUTPUT  » : paramètre définissant un mode de sortie
–  » LOW  » : paramètre définissant une absence de courant

Voici le code à taper :

Comme dans le langage de programmation C++, il est IMPERATIF de mettre un point-virgule à la fin de chaque commande. Tout oubli entraînera systématiquement une erreur à la vérification.

Et on envoie à la carte :

• Cliquez sur le bouton « Vérifier »
• Corrigez les éventuelles erreurs
• Cliquez sur le bouton « Téléverser »

Et voilà !

7) Enregistrer le programme

Il est temps de sauvegarder les modifications.

• Cliquez sur le bouton « Enregistrer »
• Un message d’erreur s’affiche, ce qui est normal car les exemples sont protégés contre la modification.
• Cliquez sur OK
• Donnez à votre projet un nom cohérent avec la convention de nommage en vigueur, mais qui contiendra au minimum « EteindreLEDEmbarquee »

Quand l’utilisateur enregistre un projet, le logiciel crée deux éléments dans le répertoire de travail :

– Un dossier portant le nom du projet,
– Dans ce dossier, un fichier de même nom, avec l’extension .ino, qui est le programme proprement dit.

8) Rallumer la LED sur la carte : que se passe-t-il ?

Pour allumer la LED après l’avoir éteinte, la commande reste la même, seul le paramètre de fin change. Voici le code (Le paramètre « HIGH » signifie : « envoyer du courant ») :

• Rajoutez la ligne entourée au bon endroit
• Cliquez sur le bouton « Vérifier »
• Corrigez les éventuelles erreurs
• Cliquez sur le bouton « Téléverser »
• Observez la LED embarquée

La LED semble allumée mais très faiblement. La carte fonctionnant correctement, pourquoi ce comportement ?

Comme vous l’avez peut-être déduit, les commandes pour éteindre et rallumer la LED se situent dans la fonction « Loop », qui, comme l’indique son nom, s’exécute en boucle et, l’exécution du programme étant très rapide, le clignotement à haute fréquence donne l’impression d’une tension réduite du courant traversant la LED. Nous reviendrons plus tard dans ce cours sur l’exploitation de ce phénomène dans des cas particuliers.

9) Rajouter un délai d’attente

Il existe une commande pour indiquer à la carte d’ajouter un délai entre l’exécution de deux commandes. C’est la fonction « delay », qui s’écrit comme suit :

Delay (nombre) ;

Où le paramètre « nombre » indique à la carte le nombre de millisecondes du délai. par exemple :

Delay (1000) ;

indiquera un délai d’une seconde. Essayons de rajouter cela à notre programme :

• Ajoutez une demi-seconde après l’allumage et après l’extinction de la LED, comme indiqué dans le code ci-dessus
• Cliquez sur le bouton « Vérifier »
• Corrigez les éventuelles erreurs
• Cliquez sur le bouton « Téléverser »
• Observez la LED embarquée

Et voici votre premier programme avec Arduino, félicitations ! Essayez de changer les valeurs des délais et regardez ce qui se passe.

1) Introduction

Le langage Arduino, comme son prédécesseur Processing, sont des langages créées par adjonction de fonctions spécifiques à un langage de base : le C++.
Pour les projets plus aboutis (par exemple, gestion d’une imprimante 3D), la majorité des programmes sont écrits en C++ pur, sauf les interactions directes avec la carte.
Les fonctions spécifiques au langage Arduino feront l’objet de chapitres dédies plus tard dans ce module, mais pour les commandes de base (variables, boucles, conditions, etc…), il faut les étudier dans leur langage d’origine, le C++.

2) Un code compréhensible et facilement modifiable (les variables)

Reprenons le code de clignotement de LED que nous avons fait au chapitre précédent. La LED sur laquelle nous avons travaillé est câblée avec le pin 13, ainsi nous aurions pu écrire :

Vous pouvez tester ce code, si vous le désirez.

Supposons que vous décidiez de faire clignoter une LED située sur le pin 12 ; vous devriez modifier cette valeur dans tout votre code.
Dans notre cas, c’est relativement facile, cette valeur n’a que trois occurrences, mais dans le cas d’un programme plus complexe, il faudrait changer la valeur un nombre de fois beaucoup plus grand, dans un code de plusieurs dizaines, voire centaines de lignes.

Nous avons vu dans le cours BASIC que les variables, en plus de stocker des valeurs en vue de leur traitement, permettent de rendre le code plus facilement compréhensible si on leur donne un nom explicite.

Voici un exemple de code rendu compréhensible par l’utilisation d’une variable au nom explicite :

La partie la plus importante de situe sur la première ligne, sur laquelle on indique au programme qu’il aura à traiter une nouvelle variable. Cela s’appelle la déclaration de variable

La déclaration d‘une variable utilisée dans tout le programme (appelée aussi variable globale) se fera toujours au début du programme. Si on la déclarait par exemple dans la fonction setup, elle serait dite locale à cette fonction et ne serait pas reconnue dans les autres fonctions (par exemple, dans le code précédent, si
vous déclariez la variable LedClignotante dans la fonction setup, vous auriez une erreur de vérification dans la fonction loop, disant que la variable n’est pas déclarée.).

La déclaration des variables est impérative dans ce langage de programmation. Si, vous utilisez une nouvelle variable au milieu de votre programme sans l’avoir déclarée auparavant, la vérification échouera.

Si on étudie la ligne en question, la déclaration se compose de trois parties distinctes. Voici l’explication :

TypeVariable NomVariable = Valeur ;

TypeVariable correspond au type de la variable déclarée. Nous verrons plus tard les différents types de variables possibles.
NomVariable est le nom de la variable,
= Valeur (facultatif dans la déclaration) nous permet d’attribuer une valeur à la variable.

Si dans ce cas on décide de faire clignoter une LED située sur le pin 12, il suffit de changer la déclaration en :

int LedClignotante = 12 ;

Et le tour est joué.

3) Les types de variables

Comme on l’a vu au chapitre précédent, il existe différents types de variables. Voici une liste des types les plus utilisés :

Comme vous le voyez, le type char, qui permet de travailler le texte, stocke des valeurs numériques. Nous nous en servirons d’ailleurs pour cela. Pour travailler sur du texte, il existe des conventions de syntaxe et des commandes spécifiques que nous ne verrons pas dans ce module.

Nous pouvons aussi rajouter dans la déclaration, juste avant le type de variable l’un ou l’autre des deux paramètres supplémentaires suivants, ou même les deux :

Les variables de type unsigned pourront stocker des valeurs comme suit :

Faisons un petit exercice de raisonnement logique pour la variable LedClignotante utilisée précédemment:
– Le microcontrôleur de la carte ne peut stocker que 32 Ko pour le programme et 2 Ko pour les valeurs de variables, il convient de l’utiliser avec parcimonie pour éviter de trop en consommer.
– La valeur étant de 13, nous n’avons pas besoin de variable pouvant stocker de grands nombres, ni de nombres négatifs.
– La valeur ne change pas durant l’exécution, nous pouvons la déclarer constante.
Donc, en regardant les types de variables et les paramètres, la déclaration idéale ne serait plus :

int LedClignotante = 13 ;

mais

const unsigned char LedClignotante = 13 ;

Vous pouvez faire l’expérience, mais pour mon compte, en faisant une vérification du programme avec les deux types de variables, on obtient :

Ce qui, si on utilise un grand nombre de variables, peut faire une différence notable. Cependant, les exemples de ce module ne nécessitant pas ce genre d’optimisation, on peut continuer à utiliser le type int sans problème.

4) Les opérateurs de calcul et de comparaison

Par rapport au BASIC, il n’y a que peu de changements. Toutefois, voici un tableau complet des opérateurs avec les différences entre les langages BASIC et Arduino :

La principale différence se situe au niveau du test d’égalité. Il faudra s’en souvenir lorsqu’on programmera des conditions.

5) Les boucles

La boucle For … next … existe toujours mais sa forme est différente. Voici côte-à-côte deux versions du même code, la démo d’une boucle :

Puisque vous comprenez déjà ce que le code BASIC veut dire, voyons en détail l’anatomie de la fonction correspondante en langage Arduino :

Pour le contenu de la boucle, c’est-à-dire les instructions exécutées à chaque itération, en BASIC, elles sont mises entre la ligne « for » et la ligne « next », alors qu’en langage Arduino, le « next » disparait et les limites du code à exécuter sont symbolisées par des accolades ouvrante et fermante.
La ligne « for » est plus complexe en langage Arduino et s’écrit comme suit :

for (int Variable = ValeurDepartVariable ; ConditionArrivéeVariable ; « opération incrémentant la variable »)

dont les points essentiels sont :
– Tous les paramètres de la boucle sont mis entre les deux parenthèses,
– Chaque paramètre est séparé par un point-virgule ;
– Etant donné que « for » est une fonction, la variable locale utilisée doit être déclarée (dans ce cas, elle est de type int et vaut au départ ValeurMinVariable), ce qui est le premier paramètre de la boucle,
– Le deuxième paramètre de la boucle indique la condition pour laquelle la boucle recommence (Variable < 101) et
– Le troisième paramètre indique ce qui arrive à la variable entre chaque itération.

Reprenons l’exemple donné précédemment :

La signification de la ligne « for » est :

Pour chaque valeur de la variable entière Boucle, dont la valeur initiale est de 0, ré-exécute ce qui se trouve entre les accolades tant que Variable est plus petit que 101 et augmente la valeur de Variable de 1 à chaque fois

• Reprenez le code de la LED clignotante que vous avez créé précédemment
  
• Rajoutez la boucle nécessaire pour que le clignotement devienne de plus en plus rapide
• Enregistrez comme un nouveau fichier et faites la démonstration du code et de son fonctionnement sur la carte à votre formateur

Il existe un autre type de boucle, non étudiée dans le cours BASIC, la boucle « do … while ». Comme pour la boucle « for … next », je vais donner en parallèle un exemple de boucle « while » et son équivalent en BASIC, dont le problème à résoudre est de demander à l’utilisateur une variable dont la valeur est inférieure ou égale à 50 :

Remarque importante : Dans le code Arduino, la commande input n’existe pas. Je l’ai uniquement écrite pour montrer son placement au sein de la boucle do … while. Pour l’équivalent à la commande input, on en reparlera plus tard car il faudra d’abord apprendre comment faire communiquer la carte et l’ordinateur. Pour l’équivalent en « français » de la boucle do … while, on peut la décomposer comme suit :

do

{

    Commandes

} while (condition) ;

Où les commandes sont :
– Do = fais (ce qui est situé entre les accolades)
– While = tant que la condition située entre les parenthèses est vérifiée

De plus, dans le cas de cette boucle, vu que le test a lieu à la fin, le code situé entre les accolades sera de toute façon exécuté au moins une fois.

6) Les conditions et tests

Le premier test de condition est la fonction « if ». Voici un exemple de condition if qui allume une LED de couleur en fonction de la valeur d’une variable :

On remarque tout de suite que les commandes à exécuter ne sont pas limitées à une seule ligne. Ceci est aussi le cas en BASIC mais n’a pas été traité dans le cours d’introduction.

Si nous devons tester un grand nombre de conditions à la suite, réécrire les conditions « else if » de nombreuses fois se révèle vite fastidieux.
Il existe une structure de test beaucoup plus compréhensible pour de nombreux tests à la suite, et plus simple à mettre en œuvre :

7) Introduction au concept de fonction : son utilité

Dans un langage de programmation, une fonction est une de bloc du programme (une suite d’actions autonome dont le programme se servira sur demande).
Il faut impérativement les déclarer, c’est-à-dire écrire leur code, en dehors des fonctions setup et loop.

Les fonctions peuvent servir à deux choses :

– Retourner un résultat au programme (par exemple, les fonctions mathématiques
comme sinus, ou la fonction Serial.read qui écoutera si la carte transmet des informations par le câble USB)
– Automatiser des actions (par exemple, dire au microcontrôleur d’envoyer du courant dans un pin nécessite de nombreuses actions à lui faire exécuter, mais pour le programmeur, taper une seule commande, digitalWrite, sera beaucoup plus facile)

Prenant comme exemple la fonction digitalWrite, on remarque que l’on ajoute des
parenthèses après la commande, dans lesquelles on ajoute des informations. C’est ce qu’on appelle des paramètres, qui indiquent soit des valeurs que la fonction devra traiter, soit des instructions pour que la fonction travaille d’une manière particulière. Par exemple :

ValeurSinus = sin(Angle) ; , qui indique que la fonction sin() devra traiter la valeur de Angle.

8) Les fonctions en langage Arduino

Déclarer une fonction en langage Arduino se fait en tapant le code suivant :

Explications :

– Type_fonction : Cela indique au programme que la fonction renverra un résultat ou non :
      – Si la fonction doit retourner un résultat, Type_fonction sera le type de variable de la valeur retournée (p.ex : int, char…)
    – Si la fonction ne doit pas retourner de valeur et est juste une suite d’instructions, Type_fonction sera de type void. Cela explique pourquoi les fonctions setup et loop sont de type void, elles ne renvoient pas de valeurs par elle-mêmes.
– Nom_fonction sera le nom que l’on va donner à la fonction et donc de la commande que l’on va taper dans le programme pour l’appeler.
– Type_paramètre_x Nom_paramètre_x fonctionnent comme des déclarations de variables et indiquent à la fonction le type de données qu’elle recevra par le paramètre. Cela déclare également ne nouvelle variable locale à la fonction (qui ne sera pas disponible en dehors de celle-ci).
– Type_variable_x Nom_variable_x sont des déclarations de variables locales supplémentaires, à ajouter au besoin.
– Commande_x, ce sont des commandes que la fonction exécutera.
– Return est une commande spécifique aux fonctions qui doivent retourner une valeur. Elle indique à la fonction de retourner la valeur attendue et de stopper
immédiatement son exécution.

Exemple : création d’une fonction nommée puissance qui, quand on lui donne 2 nombres entiers, renverra la valeur du premier « puissance » le deuxième (en mathématiques : a puissance b), mais renverra 0 en cas d’erreur et de la façon de l’intégrer dans un programme Arduino :

Pour cet exercice, vous allez devoir faire clignoter la LED, mais en vous servant de ce que vous avez appris sur les fonctions.

Voici le cahier des charges :

1. Les variables doivent être explicites et explicitées
2. Les temps d’allumage et d’extinction doivent être faciles à changer
3. La fonction loop ne doit contenir que l’appel de la fonction ClignoterLed
4. La fonction ClignoterLed a trois paramètres :
5. La LED à allumer
6. Le temps d’allumage
7. Le temps d’extinction
8. La fonction ClignoterLed doit uniquement servir à appeler les deux fonctions AllumerLed et EteindreLed
9. Les fonctions AllumerLed et EteindreLED servent à allumer ou à éteindre une LED et à attendre un certain temps. A vous de réfléchir à leur paramètres et à leur contenu.

• Créez le programme appelé ClignoterLEDAvecFonctions_(votre nom) en suivant le cahier des charges ci-dessus
• Faites la démonstration du code et de son fonctionnement sur la carte à votre formateur

1) La platine d’expérimentation

La platine d’expérimentation (en anglais : « breadboard », littéralement : « planche à
pain »…) est l’outil indispensable pour la conception de circuits imprimés car la mise en place de composants électroniques dessus ne nécessite aucune soudure, ce qui permet de déplacer les composants à notre guise. Ceci est rendu possible grâce à des « pinces » logées dans les trous de la platine, qui maintiennent fermement les connecteurs des composants.

Voici un schéma avec les explications :

Par convention, nous enverrons le courant dans les pins d’alimentation côté bleu, tandis que ceux côté rouge seront reliés à la masse.

Pour bien comprendre comment enficher les composants sur la platine d’expérimentation et ainsi éviter les courts-circuits, voici un schéma de cette dernière auquel est ajouté en orange le schéma de son câblage interne, c’est-à-dire quels pins sont reliés ensemble :

2) Premier circuit électronique : allumer une LED – théorie

Les LED (Light-Emitting Diodes ou diodes électroluminescentes) sont des petits composants qui émettent de la lumière lorsqu’elles sont traversées par un courant.
Comme toutes les diodes, elles sont polarisées, ce qui veut dire qu’elles ne laissent passer le courant que dans un sens, c’est pourquoi il est nécessaire de savoir différencier leurs deux pôles et dans quel sens il convient de les intégrer au circuit.

Voici la photo d’une diode rouge identique à celle disponibles dans le kit avec les explications nécessaires :

Il existe encore un point dont il faut absolument se souvenir :

Ces LED sont conçues pour n’être traversées que par un courant maximal très faible. La tension de 5V délivrée par la carte Arduino est trop forte. Si vous essayiez (ne le faites pas !) de brancher une de ces LED en circuit avec la carte Arduino sans autre élément de protection, la LED serait Immédiatement détruite par l’intensité du courant qui la traverserait !

Il faut donc rajouter quelque chose entre la carte Arduino et la LED pour abaisser la tension.

3) Comprendre la relation entre tension, courant et résistance

Pour bien comprendre ce concept à l’aide d’un exemple concret, nous allons expliquer pourquoi une LED serait détruite si elle était branchée directement en circuit. Pour ce faire, il faut connaître les phénomènes physiques qui se cachent derrière la circulation d’un courant électrique et comment ces phénomènes sont en relation les uns avec les autres.

Un courant électrique est composé d’électrons se déplaçant dans un environnement conducteur.

Les trois grandeurs de base utilisées en électronique sont :

– La tension (Notée : U). Son unité est le volt (abréviation : V). Elle exprime une différence de potentiel électrique entre deux points d’un circuit électrique (Un des points aura plus de charges que l’autre).
– L’intensité ou courant électrique (notée : I). Son unité est l’Ampère (abréviation : A). Elle exprime l’intensité d’un courant électrique. (1A = 6,241 509 629 152 65×1018 charges d’électrons par seconde).
– La résistance (notée : R). Son unité est l’ohm (abréviation : Ω). Elle sert à quantifier la résistance d’un milieu conducteur au passage du courant.

Il existe d’autres valeurs utilisées en électronique. Nous verrons l’une d’entre-elles plus tard dans ce module, mais il n’est pas nécessaire d’en parler maintenant.

Nous remarquons que si le tuyau rétrécit, le débit diminue, ce qui équivaut à dire que si la résistance augmente, l’intensité baisse. Pour revenir à un débit équivalent avec le nouveau tuyau, il faut augmenter la pression, donc la hauteur de la colonne d’eau. En électricité: Si on augmente la tension, l’intensité redeviendra la même qu’avant avec la nouvelle résistance.

Ces interactions ont été découvertes par le physicien allemand Georg Simon Ohm dans les années 1820 et sont décrites dans une loi physique qui porte son nom.

4) Exemple : Ne pas faire griller la LED

La loi d’Ohm indique que les relations entre la tension et l’intensité d’un courant pour une résistance données se calculent selon une formule simple :

U (Tension) = R (Résistance) * I (Intensité).

Voici une capture d’écran des spécifications d’une LED sur un site de distribution de matériel électronique :

On a donc la LED qui fonctionne sous 2V et a un courant nominal de 0.01A à ne pas dépasser. La résistance doit donc baisser la tension de 3V. Pour calculer la résistance qui permet de faire cela, la formule est :

U = R*I -> R = U/I -> R = 3V/0.01A = 300 Ω

Pour que notre LED ne grille pas, la résistance doit donc être de 300 Ω minimum.
La résistance dont nous disposons avec la valeur la plus proche est une de 330 Ω: ce sera donc celle-ci que nous utiliserons.

5) Les résistances : comment s’en servir ?

Une résistance, nous l’avons vu, résiste au passage du courant électrique et est calculée en Ohm. Cette information est indiquée sur toutes les résistances de la même manière, mais cependant d’une manière qui peut sembler incompréhensible, à l’aide de bandes colorées peintes dessus. Pour pouvoir décoder ce code, voici un petit schéma explicatif mettant en relation les codes couleur d’une résistance et leur valeur en Ohm :

Pour notre module, nous avons calculé la résistance à notre disposition idéale pour protéger la LED : Nous avons besoin d’une résistance de 330 Ω, sa tolérance est de ± 5%.

AVANT DE CONTINUER, trouvez le code couleur correspondant le mieux à cette résistance et vérifiez-la avec votre formateur.

6) Montage du circuit

Voici le schéma de montage du circuit électronique pour allumer la LED :

Explication :

– Le microcontrôleur applique une tension de 5 V au pin 12,
– A travers le fil rouge et le connecteur interne à la breadboard, le courant arrive à la résistance,
– En traversant la résistance, la tension est abaissée,
– A travers le connecteur interne à la platine d’expérimentation, le courant arrive à l’anode de la LED
– Le courant allume la LED,
– Le courant repart par la cathode de la LED,
– Puis via les connecteurs internes de la breadboard et les fils jaune et gris, le courant finit son trajet dans le pin de terre de la carte.

• Effectuez le montage ci-dessus
• Reprenez votre dernier programme créé
• Changez la valeur de LedClignotante de 13 pour 12
• Vérifiez, corrigez si nécessaire et téléversez le programme
• Si la LED ne s’allume pas, vérifiez son sens
• Faites la démonstration du montage et de son fonctionnement à votre formateur

1) Le composant

Un bouton est un petit dispositif qui, sur appui de l’utilisateur, modifie sa façon de faire passer le courant. Les deux types principaux de boutons sont :
– Le bouton poussoir normalement ouvert (NO) : Par défaut, le courant ne passe pas. Le circuit se ferme uniquement lorsque l’utilisateur appuie dessus.
– Le bouton poussoir normalement ouvert (NF) : Par défaut, le courant passe. Le circuit s’ouvre uniquement lorsque l’utilisateur appuie dessus.
Les boutons que nous avons à disposition sont de type NO.
Voici une photo de ce composant avec les explications nécessaires :

2) Eliminer les interférences : un peu de théorie électronique

Les explications suivantes seront données de manière théorique, sans expérimentation, car les phénomènes décrits sont soit trop aléatoires et dépendants d’événements extérieurs pour être observés concrètement, soit génèrent des courts-circuits qui ont pour effet la déconnexion immédiate de la carte par mécanisme d’autoprotection.
– La première difficulté à obtenir un signal entrant clair est liée à la vulnérabilité des
circuits électroniques aux interférences électromagnétiques (un téléphone portable à proximité, de l’électricité statique, etc…) qui pourraient faire varier le signal suffisamment pour que la carte détecte un appui sur le bouton sans que ce soit réellement le cas.
– La deuxième difficulté est que l’appui sur le bouton peut faire varier la tension suffisamment rapidement pour créer un court-circuit.

Pour ces deux problèmes, la solution est de rajouter une résistance pour absorber les interférences et faire varier la tension de manière plus douce. C’est ce qu’on appelle une résistance de « pull-up », qui aura pour résultat un signal clair.

Une troisième source d’interférences a pour origine la nature mécanique du bouton: Lors de l’appui, le signal ne varie pas immédiatement de 0 à 1 mais peut sauter plusieurs fois entre 0 et 1. C’est ce qu’on appelle des « rebonds ».

Pour remédier à ceci, il faut utiliser un composant électronique appelé condensateur, qui fonctionne comme un petit réservoir de courant : les charges électriques s’accumulent sur deux plaquettes conductrices, elles-mêmes situées de part et d’autre d’une couche isolante.

Ce petit réservoir se remplira ou se videra lors de changement de potentiel, tout en
absorbant les « rebonds », ce qui donnera une transition de signal nette.

3) Schéma du circuit

Voici le schéma du circuit nécessaire à la récupération du signal optimal du bouton :

Explications :
– Le courant de 5V arrive (fils noirs), puis passe à travers la résistance de pull-up, d’où élimination des interférences.
– Une déviation (fil bleu) alimente le pin 2 de la carte en 5V quand le bouton n’est pas appuyé.
– Le bouton, quand il est appuyé, mettra en contact la partie 5V avec la mise à la terre (fils gris), ce qui fera baisser la tension sur le fil bleu à 0.
– Le condensateur, mis en parallèle avec le bouton filtrera les rebonds.

Donc, la carte récupérera un état HIGH pour le bouton relâché et un état LOW pour un état enfoncé.

4) Les fonctions Arduino pour récupérer un signal électrique

Pour récupérer la valeur du courant arrivant sur un pin, il nous faut deux commandes supplémentaires :
– Définir le pin en mode entrée (fonction pinMode, mais avec le paramètre INPUT)
– La fonction digitalRead , qui servira à stocker la valeur dans une variable

5) Feu rouge / feu vert

Voici un exemple de programmation pour la lecture d’un signal numérique :

• Effectuez le montage (remarque: le condensateur bleu du schéma est à remplacer par un condensateur où il est marqué 103 dessus) et le programme ci-dessus puis testez le bouton
• Modifiez maintenant le programme afin que le changement d’état persiste si on relâche le bouton et qu’il faille ré-appuyer dessus pour rechanger de LED, en gros, transformez ce bouton en interrupteur
• Faites la démonstration du programme, du montage et de son fonctionnement à votre formateur

1) Théorie : la communication série

La norme RS-232 est une ancienne norme définissant les protocoles, la connectique et les câblages nécessaires à la communication entre deux appareils, le plus souvent entre un ordinateur et un périphérique. Cette norme est quasiment tombée dans l’oubli, ayant été remplacée par l’USB, sauf pour certaines machines industrielles.

Pour les cartes Arduino, les communications entre celles-ci et l’ordinateur se font encore via ce protocole, un contrôleur dédié faisant interface entre les connectiques série et USB, celuici ayant été rajouté pour l’alimentation et la facilité de configuration.

On peut toutefois faire encore communiquer deux cartes Arduino entre-elles grâce à ce protocole, mais dans le cadre de ce cours, la communication série nous servira uniquement à faire transiter des informations via le câble USB.

Pour que deux appareils arrivent à communiquer via ce protocole, ils doivent pouvoir se synchroniser. Le protocole RS-232 permet beaucoup de paramétrages, mais la communication série de base pour Arduino permet uniquement de modifier le taux de transfert, qui sera exprimé en bauds, ou bits par seconde.

Pour pouvoir lire ce que la carte transmet, il nous faut une interface de communication dans laquelle nous pouvons afficher ces informations. IL existe beaucoup de programme le permettant mais Arduino a une fonctionnalité déjà prévue à cet effet : le moniteur série.

2) La communication série dans un programme Arduino

Pour pouvoir obtenir des informations de la carte, il existe trois fonctions principales dédiées à la communication série :
– Serial.begin(NombreBauds) ; : à placer dans le setup, qui sert à démarrer la connexion série, le paramètre NombreBauds indique la vitesse de transfert, une vitesse de 9600 bauds est largement suffisante pour nous.
– Serial.print(Informations) ; : permet d’envoyer des données depuis la carte vers l’ordinateur. Cela peut être du texte, le contenu d’une variable, etc.
– Serial.println(Informations) ; : identique à Serial.print, mais effectue un retour à la ligne dans le moniteur série.

La fenêtre du moniteur série s’ouvre à l’aide du bouton situé en haut à droite de l’interface de programmation (Voir l’illustration du chapitre 3.1 pour la localiser). Elle se présente comme suit :

3) Exemple de programme de communication série

Voici un petit code qui vous montrera l’affichage sur le moniteur.
Remarque:
– Pour éviter une répétition, le code sera situé dans le setup
– Le programme redémarre lorsqu’on ouvre le moniteur série

• Retapez le code ci-dessus en comprenant ce que vous faites
• Vérifiez/téléversez votre programme
• Ouvrez le moniteur série et regardez le résultat (La différence de résultats entre les fonctions Serial.print et Serial.printIn)
• Dans le moniteur série, modifiez le taux de transfert de la réception et regardez ce qui se passe
• Remettez le taux de transfert à 9600 bauds et observez ce qui se passe

Nous observons donc que si les appareils n’émettent/écoutent pas avec les même taux de transfert, la synchronisation ne peut pas avoir lieu et les données reçues sont inutilisables.

• Reprenez le programme de l’exercice 4 et modifiez-le pour qu’il affiche en texte quelle LED est allumée (Vous pouvez laisser le texte se répéter, ce n’est pas discriminant)
• Faites la démonstration du programme, du montage et de son fonctionnement à votre formateur

1) Introduction

La communication série, de par les possibilités de traiter les données reçues, est un sujet suffisamment complexe pour faire l’objet de plusieurs chapitres, voire d’un cours entier. Pour ce cours d’introduction, nous n’allons en voir que deux aspects:

La demande d’une valeur (équivalent à la commande input en BASIC) et un test simple pour détecter l’arrivée de nouvelles données en temps réel.

Grâce à celà, vous serez déjà capable de communiquer de manière satisfaisante avec votre carte Arduino.

2) Les fonctions Arduino liées à la réception de valeurs

Il existe deux types de commandes pour dire à la carte de récupérer des données envoyées depuis l’ordinateur.

La première est:
Serial.read() : qui permet de lire le flux entrant caractère par caractère

L’autre type comporte les fonctions:
Serial.readString() : qui permet de capturer une chaîne de caractères
Serial.parseInt() : pour récupérer des nombre entiers
Serial.parseFloat() :pour récupérer des nombres décimaux

Remarque: La communication série se fait toujours byte pat byte et les valeurs sont toujours traitées sous format numérique, donc la fonction Serial.readString est créée pour simplifier au maximum la gestion de plusieurs caractères en même temps, tandis que les fonctions Serial.parse sont faites pour emmagasiner plusieurs chiffres dans la même variable de nombre.

3) Interactions basiques

Pour récupérer des chaînes de caractères, il faut tout d’abord déclarer la variable adéquate:

int NombreEntier; //Déclare un entier
float NombreDecimal; //Déclare un nombre décimal
String Texte; //Déclare une chaîne de caractères

Ensuite, il faut détecter l’arrivée de nouvelles données par la ligne série. Il existe pour celà la fonction:

Serial.available()

qui vaut 0 quand rien reçu et 1 si on reçoit quelque-chose.

De plus, il faut stopper l’exécution du programme pour attendre les données.
Nous utiliserons la boucle :

while (conditions)
{
//Commandes
}

qui s’exécute tant que la condition est vérifiée.

Si on la combine avec le test de nouvelles données, on obtient :

while (Serial.available() == 0)
{
}

qui est une boucle ne s’arrêtant que si on reçoit des données.

4) Exemple : fiche d’identité

Voici un petit programme montrant l’application de ces principes :

• Recopiez et testez le programme ci-dessus
• Assurez-vous d’avoir bien compris !

• Créez un petit programme qui demande ses nom, prénom, métier et salaire brut à l’utilisateur, puis créez une petite fiche de salaire avec comme suit :

  FICHE DE SALAIRE de Prenom Nom, Metier
  ———————————-
  Salaire brut : XXXXXXX.-
  ———-
  Déductions :
  ———-
  AVS : XXX.- (4,2%)
  AI : XXX.- (0,7%)
  APG : XXX.- (0,25%)
  AC : XXX.- (1,0%)
  ANP : XXX.- (1,3%)
  LPP : XXX.- (7,0%)

  Total : XXXX.-

  Salaire net : XXXXX.-

• Faites la démonstration de votre programme à votre formateur

5) Lecture directe du flux entrant

La fonction pour récupérer une valeur arrivant par la voie série est, comme nous l’avons vu:

Serial.Read();

Cette fonction n’a pas de paramètres pour l’Arduino UNO, mais pour des cartes à plusieurs entrées séries, le paramètre serait le numéro de la connexion.

Vu que toutes les valeurs sont stockées sous formes numériques on définira la variable comme un int

Exemple : int CaractereRecu = Serial.read()

6) Exemple : capturer une entrée

Voici comment capturer un caractère entré et le réafficher :

• Recopiez le code suivant
• Assurez-vous d’avoir bien compris !

• Créez un circuit avec une LED verte et une LED rouge, puis un programme qui demande:
  – Allumer/Eteindre?
  – Led verte ou rouge?
  Et qui fait ce que demandé
• N’oubliez pas de mettre des garde-fous pour empêcher des entrées incorrectes
• Faites la démonstration de votre programme, de votre montage et de son fonctionnement à votre formateur

1) Théorie électronique

Un potentiomètre est une résistance que l’on peut faire varier. Celui que nous utiliserons est de type linéaire, c’est-à-dire que le rapport entre la tension de sortie et la tension maximale est directement proportionnelle au rapport entre la position du curseur et le chemin maximal parcourable.

Le composant à notre disposition est le suivant (le modèle peut varier mais le principe reste le même) :

2) Montage du circuit électronique

Voici la manière de mettre le potentiomètre en circuit avec votre carte Arduino (le modèle sur ce schéma est différent de celui que nous utilisons, mais le câblage reste identique) :

3) Programmation : Récupérer la valeur sur la carte et l’afficher

La fonction utilisée pour lire des données s’appelle analogRead(NomduPin) ;

Les pins utilisés pour recueillir ces informations sont les pins A0 à A5

Ces pins servant uniquement à cela, les configurer via pinMode n’est pas nécessaire.

Pour déclarer une variable adressant ce pin, il faudra utiliser une variable char, la valeur étant du texte.

Voici un petit programme qui permet de récupérer la valeur brute renvoyée par le
potentiomètre :

• Recopiez le programme ci-dessus et réalisez le montage du chapitre 10.2
• Regardez les valeurs affichées (n’oubliez pas d’ouvrir le moniteur série)

4) Une petite fonction utile pour convertir les données reçues

Vous avez remarqué que l’Arduino traduit la tension reçue en une valeur comprise entre 0 et 1023, ce qui n’est pas idéal pour connaître la valeur exacte de la tension reçue.

Voici une fonction très pratique pour retrouver la tension reçue effective à partir de cette valeur, la fonction map() ;

Elle s’écrit comme suit :

ValeurConvertie = map (ValeurAConvertir, MinValeurAConvertir, MaxValeurAConvertir, MinValeurConvertie, MaxValeurConvertie) ;

Exemple d’utilisation de cette fonction : réaliser un voltmètre.

• Recopiez le code suivant et comprenez bien le fonctionnement de la fonction map() ;

• A l’aide de ce que vous venez d’apprendre, créez un petit programme qui fera varier le délai de clignotement d’une LED entre 0,5 et 1 seconde à l’aide d’un potentiomètre
• Faites la démonstration de votre programme, de votre montage et de son fonctionnement à votre formateur

1) Générer une tension variable : théorie

Le microcontrôleur de la carte Arduino, bien que capable de récupérer des valeurs de tensions variables par ses entrées analogiques ne peut délivrer que des valeurs binaires (5V ou 0V) et est donc incapable de délivrer du « vrai » courant à tension variable.
La carte va devoir « tricher » un peu pour y arriver, en utilisant ce qu’on appelle la « modulation de largeur d’impulsion » (Abréviation anglaise : PWM, j’utiliserai cette abréviation désormais).

Nous avons déjà pu observer ce phénomène au début du cours : une LED qui clignote très rapidement éclaire beaucoup moins.

Le concept est le suivant :
Le contrôleur envoie des cycles (courant / pas de courant) à une haute fréquence de valeur constante. Cette alternance rapide d’état haut/bas créent une tension moyenne. Si on fait varier le rapport entre la durée du signal haut et celle du signal bas et si on rajoute un condensateur et des résistances dans le circuit, la tension moyenne résultante variera. C’est le principe de base de la PWM.

2) La commande pour les sorties analogiques

Pour dire à la carte de délivrer une tension variable en utilisant la PWM, il existe la commande

analogWrite(ValeurPWM);

ValeurPWM prendra une valeur comprise entre 0 (0V) et 255(5V)

analogWrite(Led,0);

équivaudra à digitalWrite (Led, LOW); et

analogWrite(Led, 255);

équivaudra à digitalWrite (Led, HIGH);

3) Exemple : clignotement doux

Ecrire un programme faisant varier l’intensité d’une LED

• Recopiez le code ci-dessous
• Assurez-vous d’avoir bien compris

• A l’aide de ce que vous venez d’apprendre, créez un petit programme qui commandera l’intensité d’une LED par un potentiomètre
• Faites la démonstration de votre programme, de votre montage et de son fonctionnement à votre formateur

1) Présentation du composant

Un servo est un composant muni d’un axe de rotation dont l’angle variera en fonction de la tension d’un signal de commande.

Voici un schéma de son fonctionnement:

2) Le circuit électronique

Voici la façon de réaliser un circuit comportant un servo:

Remarque: le signal de commande doit obligatoirement venir d’un PWM.

3) Introduction aux bibliothèques de fonctions

Des fonctions ont été créées pour faciliter le pilotage de ces composants, mais elles se trouvent dans des fichiers séparés, écrits en langage C++

Par exemple les fonctions liées à la commande des servos sont écrites dans deux fichiers distincts:
– CodeCPplusPlus.cpp, qui contient la déclaration et le code de ces fonctions en langage C++
– Résumé.h, qui est un résumé de ces fonctions.

Si on veut rajouter les fonctions contenues dans le fichier cpp, il faudra appeler le résumé (le fichier h) dans notre programme. On appelle cela l’inclusion.

Voici comment inclure un fichier h dans un programme:

#include <Résumé. h>

Quand la compilation du programme aura lieu, le fichier CodeCPlusPlus.cpp sera compilé aussi et le fichier Résumé.h servira à faire le lien entre les deux.

4) La bibliothèque Servo et ses fonctions

La bibliothèque Servo comprend plusieurs fonctions, qui elles-mêmes font appel à beaucoup d’autres paramètres. Pour simplifier cette gestion, la bibliothèque fait appel à une notion peut-être nouvelle pour vous: la programmation orientée objet. Le but de ce cours n’étant pas de vous y initier, les explications seront limitées au strict nécessaire.

Les fonctions de cette bibliothèque sont:

Servo NomDuServo;

ce qui équivaut à dire à votre programme: Crée un objet de type Servo et qui s’appellera NomDuServo. Dorénavant tu travailleras sur cet objet.

NomDuServo.attach(NumeroPin);

Ce qui veut dire: Prends l’objet NomDuServo et attache-le au pin NumeroPin (Ce doit être un pin capable PWM). Cette fonction permet de définir quel pin enverra le courant au servo.

NomDuServo.write(ValeurAngle);

ce qui veut dire Envoie du courant analogique vers le servo pour le faire tourner d’un angle de ValeurAngle.

Remarque: ValeurAngle est une valeur comprise entre 0 et 180.

5) Exemple : faire tourner un gouvernail

Un capitaine désire pouvoir commander à distance le gouvernail de son navire. Il désire pouvoir entrer les valeurs au clavier.

• Recopiez le code ci-dessous et branchez le servo de manière appropriée.

Le capitaine a décidé que finalement ce serait plus simple pour lui de piloter son navire avec un volant.

• Modifiez le programme du chapitre 12.5 pour que le pilotage du servo se fasse à l’aide d’un potentiomètre
• Faites la démonstration de votre programme, de votre montage et de son fonctionnement à votre formateur

Créez un circuit et le programme correspondant pour respecter le cahier des charges suivant (N’hésitez pas à faire un organigramme pour vous aider, mais ce n’est pas obligatoire.):

Le programme comportera trois modes:

• Mode automatique comportant lui-même deux modes
  – Mode feu rouge: LED rouge et barrière fermée
  – Mode feu vert: LED verte et barrière ouverte
• Mode manuel: feu rouge par défaut, ouverture minutée par appui sur le bouton
• Mode panne: barrière ouverte, les deux LED clignotent

Le fonctionnement:

• En mode panne (mode par défaut au démarrage):

  – Surveillance de la ligne série en permanence
  – Si interception du caractère « a », passage au mode automatique et information via la ligne série de l’exécution de la commande
  – Sinon, reste en mode panne et informe d’un signal invalide

• En mode automatique:

  – Mode feu rouge (par défaut):
  – programme en pause
  – Demande de commande
  – Si commande entrée est « vert », passage en mode feu vert et envoi de confirmation
  – Sinon si commande entrée est « manuel », passage en mode manuel et envoi de confirmation
  – Sinon, passage en mode panne et information de réception de données erronées

  – Mode feu vert:
  – programme en pause
  – Demande de commande
  – Si commande entrée est « rouge », passage en mode feu rouge et envoi de confirmation
  – Sinon si commande entrée est « manuel », passage en mode manuel et envoi de confirmation
  – Sinon, passage en mode panne et information de réception de données erronées

   

• Mode manuel:

  – Mode feu rouge (par défaut):
  – A l’écoute permanente d’un signal
  – Si interception d’un caractère « a », passage en mode automatique et envoi de confirmation
  – Si détection de l’appui sur le bouton
  – Passage en mode feu vert pendant 10 secondes et envoi de confirmation
  – Passage en mode feu rouge et envoi de confirmation et reprise de l’écoute du signal
  – Sinon, passage en mode panne et information de réception de données erronées
  

  Faites la démonstration de votre programme, de votre montage et de son fonctionnement à votre formateur