Projet de prototypage rapide basé sur une architecture numérique.

Lycée Alphonse Benoit 84800 Isle-sur-la-Sorgue

1. Introduction

Dans les parcours de formation précédent nous avons découvert toutes les architectures disponibles pour permettre à un ingénieur de développer un projet numérique.

Nous allons nous concentrer sur l’architecture à base de microcontrôleur comme celle d’arduino. Cet environnement va nous permettre de découvrir la notion de prototypage rapide.

En effet, de nos jours les ingénieurs doivent pouvoir proposer une solution technique rapidement à leurs clients. Le système arduino répond pour une grande partie à cette contrainte.

Deux exemples de projets:

Sécurité pour entreprise manipulant des objets radioactifs.

Une entreprise doit pouvoir mesurer en temps réel le rayonnement β et γ des objets qu’elle manipule. Dans le cas ou un seuil est dépassé une alarme doit être envoyée par liaison série à un serveur centrale.

Thermostat communicant.

Produit final	Objectifs commerciaux
	- La produit doit pouvoir s’installer facilement dans n’importe quelles pièces de la maison - Mesure d’une température à 0.5°C prés. - Afficher la température localement - Communiquer la température à distance

Produit final

Objectifs commerciaux

thermo

- La produit doit pouvoir s’installer facilement dans n’importe quelles pièces de la maison

- Mesure d’une température à 0.5°C prés.
- Afficher la température localement
- Communiquer la température à distance

Ce thermostat communicant est la version commercialisée. Mais avant d’arriver à cette version aboutie, un prototype a dû être réalisé.

Un prototypage à base d’arduino comme le projet précédent peut répondre aux objectifs techniques.

Dans la chaine d’information, il suffira de changer le capteur dans le module acquerir et d’ajouter un module afficheur et Wifi dans la fonction communiquer.

Evidement le logiciel doit être modifié pour cette nouvelle application.

Vous l’aurez compris en adaptant les élèments autour de la carte Arduino nous pouvons réaliser un grand nombre de prototype pouvant répondre à tout ou partie d’un cahier des charges demandé par le client.

En résumé:

Un prototypage électronique est donc une première version d’un objet avec des composants électroniques.

Un prototype est la première étape de la réalisation d’un projet. Il peut être incomplet mais souvent il possède déjà les qualités techniques et les caractéristiques de fonctionnement du nouvel objet.

On le construit souvent pour démontrer ou infirmer le bien-fondé d’un ou plusieurs concepts, et ce avant sa commercialisation.

2. La carte Arduino, c’est quoi?

Arduino c’est tout simplement une petite carte électronique programmable et un logiciel multiplateforme (c’est à dire qui fonctionne sur tous les systèmes d’exploitation) qui permettent à tout le monde de créer facilement un système électronique.

nous allons utiliser la version Uno de l’Arduino, qui est le modèle de carte le plus utilisé.

Voici un schéma qui vous explique la composition d’une carte Arduino Uno :

Nous allons découvrir les différents éléments de cette carte à travers plusieurs manipulations.

3. Initiation par la manipulation.

3.1. Allumer une LED.

Notre premier projet sera de réaliser un programme pour allumer une led, puis la faire clignoter.

Etape1: Lancer IDE d’arduino.

IDE est l’abréviation en anglais Integrated Development Environment. En français on dit EDI pour Environnement de Développement Intégré.

C’est un ensemble d’outils (éditeur de texte pour la programmation, des fonctions pré-écrites, etc) pour augmenter la productivité des programmeurs qui développent des logiciels.

Certains environnements sont dédiés à un langage de programmation en particulier (ici le langage Arduino).

Etape2: Configurer la liaison série.

Nous allons configurer la communication entre la carte arduino et l’ordinateur(liaison USB ou série)

Une fois le logiciel arduino ouvert vous devez:

Connectez votre Arduino à votre ordinateur.
Sélectionnez dans l’IDE Arduino le bon type de carte et le bon port USB.
Pour sélectionner la carte, allez dans “Outils” et dans “Type de carte”.

Pour sélectionner le port, allez dans “Outils” puis dans “Port”
- Etape 3: Identifier les bornes de la LED.

Une led ressemble à ceci :

Notre LED dispose de deux pattes et vous l’aurez constaté l’un est plus courte que l’autre. La patte la plus petite s’appelle “cathode”, elle doit être connectée au pôle négatif. La patte la plus longue s’appelle “l’anode” et elle doit être connectée au pôle positif.

Nous allons utiliser les pins digitales.

Pas besoin de fil de connexion pour ce premier exercice. Nous allons mettre la led dans la pin n°13 (qui sera mon pôle positif, comme le + sur une pile) et la deuxième patte à la pin GND (“Ground”, qui sera mon pôle négatif cette fois-ci, comme le - sur une pile).

Notre branchement ressemble globalement à ceci :

Etape 4: Création du programme.

Lorsque vous ouvrez votre IDE Arduino, vous avez deux blocs de code vides. Nous allons nous intéresser au premier de ces blocs, le bloc “setup”.

Celui-ci sert à initialiser votre carte et votre programme et il ne sera interprété qu’une seule fois.

Vous avez branché votre led à la pin n°13. Vous allez donc indiquer à votre carte dans quel mode vous allez utiliser votre pin n°13. Il existe deux modes :

Le mode OUTPUT (sortie, en français) permet de contrôler l’ouverture et la fermeture du courant. Vous êtes “acteurs” et vous contrôlez l’action de la pin.

Le mode INPUT (entrée, en français) permet de vérifier l’ouverture ou la fermeture du courant.  C’est à dire que vous êtes  “à l’écoute”, vous ne faites que recevoir l’information sans pouvoir interagir avec elle.

Pour indiquer dans quel mode vous allez utiliser la pin, rien de plus simple : il vous suffit d’écrire le code suivant :

Vous annoncez donc que vous allez utiliser la pin n°13 en mode OUTPUT. Autrement dit, que vous voulez contrôler l’état de la led.

Nous allons maintenant passer à notre programme principal, celui qui va faire clignoter notre petite led.

Nous allons donc compléter le deuxième bloc de code vide, le bloc “loop”.

En anglais “loop” veut dire “boucle”. Le programme que nous allons donc écrire ici sera exécuté en boucle une fois que nous l’aurons lancé.

nous allons rédiger un programme qui va allumer la led, l’éteindre et répéter l’action en boucle pour la faire clignoter.

Allumer la led.

Notre première commande va donc être d’allumer la led. Puisque nous utilisons une pin digitale, nous allons commencer notre commande par “digitalWrite”.

Cette commande permet de laisser passer le courant ou de couper le courant. Pour cela, elle a besoin de deux informations, le numéro de la pin et l’état de celle-ci. Il existe deux états pour une pin digitale :
- HIGH pour faire passer du courant
- LOW pour fermer le courant.
  
  Téléversez votre programme pour le tester et si tout va bien passez à la suite.
  
  Téléverser en informatique signifie transférer des informations, un programme, d’un ordinateur à un autre. Ici, de l’ordinateur à l’Arduino.
Éteindre la led.

Rajouter une ligne d’instruction pour éteindre la led maintenant.

Alors???

Elle devrait rester allumer, mais pourquoi?

Pensez à votre programme qui s’exécute en boucle, des milliers de fois à la seconde. Le clignotement à lieu mais il est tellement rapide que la persistance rétinienne de votre oeil ne voit pas le clignotement mais seulement une led allumée.

Pour la voir clignoter, il faut donc instaurer un temps de latence entre les deux actions d’allumer et d’éteindre la led.
Ajouter une commande delay

Utilisons la commande “delay” et indiquons 500 millisecondes comme paramètre.

Hum, encore un souci … ah mais oui ! Nous avons mis un temps de latence entre l’action d’allumer (HIGH) et d’éteindre (LOW) mais pas à la fin de notre boucle.

Le programme tournant en boucle, nous nous retrouvons avec le même problème. Il ne faut donc pas oublier de mettre un “delay” (temps de latence) à la fin du programme. Nous l’avons mis à 500 millisecondes mais vous pouvez le régler comme vous le souhaitez.
En résumé:

Les commandes importantes à retenir sont :
1. Le mode OUTPUT (sortie, en français) permet de contrôler l’ouverture et la fermeture du courant. Nous sommes “acteurs” et nous contrôlons l’action de la pin.
2. Le mode INPUT (entrée, en français) permet de vérifier l’ouverture ou la fermeture du courant. C’est à dire que nous sommes “à l’écoute”, nous ne faisons que recevoir l’information sans pouvoir interagir avec elle.
3. Fonction SETUP : (qui veut dire installation en français). Celle-ci sert à initia‌liser notre carte et notre programme et elle ne sera interprétée qu’une seule fois.
4. Fonction LOOP : en anglais “loop” veut dire “boucle”. Le programme que nous allons donc écrire ici sera exécuté en boucle une fois que nous l’aurons lancé.
5. HIGH pour faire passer du courant.
6. LOW pour fermer le courant.
7. DELAY : temps de latence entre deux actions (ici allumer et éteindre une led).
8. pinMode : pour définir quelle pin on veut utiliser et dans quelle mode on veut qu’elle soit.
9. digitalWrite : commande à utiliser lorsqu’on se sert d’une pin digitale.

3.2. Allumer une led correctement!

Dans la manipulation précédente nous avons utilisé un montage simple pour éviter des connexions. Mais une LED ne doit pas être utilisée de cette manière. Elle doit être polarisée en direct avec une resistance de limitation du courant la traversant.

pour rappel:

Polarisation directe

polarisation inverse

poladirect

polainv

Lorsque l’on utilise un composant, on doit prendre l’habitude d’utiliser la "datasheet" ("documentation technique" en anglais) qui nous donne toutes les caractéristiques sur le composant.

Dans cette datasheet, on retrouvera quelque chose appelé "Forward Voltage", pour la diode. Cette indication représente la chute de tension aux bornes de la diode lorsque du courant la traverse en sens direct. Pour une LED , on considérera une tension de 1,2 à 1,6V.

3.2.1. Limiter le courant de passage.

Le courant qui traverse une LED a son importance. Si l’on branche directement la LED sur une pile, elle va s’allumer, puis tôt ou tard finira par s’éteindre… définitivement.

Pour limiter le courant, on place une résistance avant (ou après) la LED.

Mais comment on calcule cette résistance ?

Dans le schéma ci-dessous:

La led est connectée sur la broche D2 en passant par une résistance de limitation.

schema

Indiquer pour quelle tension sur la broche D2, la LED va s’allumer?
En utilisant la documentation de la LED TLHR5400, calculer la valeur de R en utilisant les lois de base de l’électricité vues précédement. Datasheet LED TLHR5400 .

élèment de réponse 150 ohms.

Si vous avez besoin de plus de details:

Dimentionnement de la résistance de la LED

3.2.2. Mise en oeuvre.

Pour réaliser ce montage nous allons utiliser une plaque d’essai: la breadboard

une breadboard

Regarder cette vidéo pour comprendre la breadboard.

Pour la suite de l’activité, la résistance de polarisation de la led sera prise égale à 220Ω

Réaliser le montage sur votre breadbord en vous aidant des schémas ci-dessous.
Modifier votre programme précédent pour faire clignoter la led.

Besoin d’aide?

La fonction pinMode.

Activer une sortie numérique.

4. initiation par la simulation.

Nous allons utiliser un simulateur en ligne: tinkerCad

Commencer par vous créer un compte sur le site:https://www.tinkercad.com
Aller ensuite dans Circuit et cliquer sur le bouton Créer un circuit.

Pour la suite, nous voulons faire clignoter un groupe de LED.

Ce groupe de LED sera composé de six LED, nommées L1, L2, L3, L4, L5 et L6. Vous aurez par conséquent besoin d’un nombre identique de résistances. Le schéma de la réalisation :

schema avec 6 leds

Vous allez réaliser le montage dans le simulateur TinkerCad. Votre schéma devrait ressembler à celui ci-dessous:

montage avec 6 leds

Vous pouvez utiliser ce "tutoriel" pour vous aider dans la conception et la simulation de votre montage.

4.1. Programmation d’un chenillard.

Le but du programme que vous devez créer va consister à réaliser un chenillard. Pour ceux qui ne savent pas ce qu’est un chenillard, voici une petite image animée :

chenillard

Proposer un programme permettant cette animation.

5. Structures algorithmiques.

Dans l’exemple du chenillard précédent, vous avez peut être trouver plusieurs manières de le coder. On trouve souvent plusieurs méthodes ou algorithmes pour répondre à un cahier des charges cependant leur efficacité sont souvent bien différentes.

L’objet de cette partie est de vous donner les bases du langage algorithmique adaptées avec le langage Arduino.

5.1. Les variables.

Une variable est un nombre . Ce nombre est stocké dans un espace de la mémoire vive (RAM) du microcontrôleur.

il existe une multitude de nombres : les nombres entiers, les nombres décimaux, … C’est pour cela qu’il faut assigner une variable à un type. Voilà les types de variables les plus répandus :

Si à présent notre variable ne prend jamais une valeur négative (-20, -78, …), alors on utilisera un type non-signé .

5.2. Les variables booléennes.

Les variables booléennes sont des variables qui ne peuvent prendre que deux valeurs : ou VRAI ou FAUX.

Elles sont utilisées notamment dans les boucles et les conditions. Nous verrons pourquoi. Une variable booléenne peut être définie de plusieurs manières :

// variable est fausse car elle vaut FALSE, du terme anglais "faux"
boolean variable = FALSE;
// variable est vraie car elle vaut TRUE, du terme anglais "vrai"
boolean variable = TRUE;

Quand une variable vaut "0", on peut considérer cette variable comme une variable booléenne, elle est donc fausse. En revanche, lorsqu’elle vaut "1" ou n’importe quelle valeurs différente de zéro, on peut aussi la considérer comme une variable booléenne, elle est donc vraie. Voilà un exemple :

// variable est fausse car elle vaut 0
int variable = 0;
// variable est vraie car elle vaut 1
int variable = 1;
// variable est vraie car sa valeur est différente de 0
int variable = 42;

Le langage Arduino accepte aussi une troisième forme d’écriture (qui lui sert pour utiliser les broches de sorties du microcontrôleur) :

// variable est à l'état logique bas (= traduction de "low"), donc 0
int variable = LOW;
// variable est à l'état logique haut (= traduction de "high"), donc 1
int variable = HIGH;

Nous nous servirons de cette troisième écriture pour allumer et éteindre des lumières…

5.3. Les opérations simples.

Pour cette partie, vous pouvez travailler sur la carte arduino ou tinkerCad.

Avec le simulateur choisir:

Une carte arduino: Platine d’essai.
Cliquer sur le bouton : Code.
Sélectionner : texte.

5.3.1. L’addition.

void setup()
{
Serial.begin(9600);
  // définition de la variable x
int x = 0;

// on change la valeur de x par une opération simple
x = 12 + 3;
// x vaut maintenant 12 + 3 = 15

  Serial.print("x=");
  Serial.println(x);
}

void loop()
{

}

Les points virgules:

Les points virgules terminent les instructions. Si par exemple je dis dans mon programme : "appelle la fonction couperDuSaucisson" je dois mettre un point virgule après l’appel de cette fonction .

Les points virgules ( ; ) sont synonymes d’erreurs car il arrive très souvent de les oublier à la fin des instructions. Par conséquent le code ne marche pas et la recherche de l’erreur peut nous prendre un temps conséquent ! Donc faites bien attention.

Les commentaires:

Ce sont des lignes de codes qui seront ignorées par le programme. Elles ne servent en rien lors de l’exécution du programme.

// cette ligne est un commentaire sur UNE SEULE ligne

/*cette ligne est un commentaire, sur PLUSIEURS lignes
qui sera ignoré par le programme, mais pas par celui qui lit le code */

L’affichage du résultat:

Pour afficher le résultat de l’opération, nous allons utiliser le moniteur série. Pour cela on initialise la communication avec l’instruction:

Serial.begin(9600);

Et on affiche le résultat avec :

Serial.print("x=");	// Pour afficher le texte x=
Serial.println(x);  // Pour afficher la valeur de la variable x.

Le code est intégré dans le fonction setup afin d’être exécuté qu’une seule fois.

5.3.2. Soustraction de deux variables.

Essayer le code suivant:

int x = 38;   // définition de la variable x et assignation à la valeur 38
int y = 10;
int z = 0;

z = x - y;    // on a donc z = 38 - 10 = 28

5.3.3. La division .

Essayer le code suivant:

float x = 0;
float y = 15;
float z = 0;

x = 12 / 2; // x vaut maintenant 12 / 2 = 6

z = y / x; // on a donc z = 15 / 6 = 2.5

Attention: nous utilisons des nombres réels, donc des variables de type float

5.3.4. L’incrémentation.

Derrière ce nom barbare se cache une simple opération d’addition.

var = 0;
var++; // c'est cette ligne de code qui nous intéresse

"var++;" revient à écrire : "var = var + 1;" En fait, on ajoute le chiffre 1 à la valeur de var . Et si on répète le code un certain nombre de fois, par exemple 30, et bien on aura var = 30.

5.4. Les conditions.

C’est un choix que l’on fait entre plusieurs propositions. En informatique, les conditions servent à tester des variables. Par exemple : *Vous faites une recherche sur un site spécialisé pour acheter une nouvelle voiture. Vous imposez le prix de la voiture qui doit être inférieur à 5000€. Le programme qui va gérer ça va faire appel à un test conditionnel . Il va éliminer tous les résultats de la recherche dont le prix est supérieur à 5000€.

Pour tester des variables, il faut connaître quelques symboles.:

En informatique, on parle de condition . "si la condition est vraie", on fait une action. En revanche "si la condition est fausse", on exécute une autre action.

5.4.1. If…else.

On veut tester la valeur d’une variable. Prenons le même exemple que tout à l’heure. Je veux tester si la voiture est inférieure à 5000€.

int prix_voiture = 4800; // variable : prix de la voiture définit à 4800€

D’abord on définit la variable "prix voiture". Sa valeur est de 4800€. Ensuite, on doit tester cette valeur. Pour tester une condition, on emploie le terme if (de l’anglais "si"). Ce terme doit être suivi de parenthèses dans lesquelles se trouveront les variables à tester. Donc entre ces parenthèses, nous devons tester la variable prix voiture afin de savoir si elle est inférieure à 5000€.

if(prix_voiture < 5000)
{
    // la condition est vraie, donc j'achète la voiture
}

On peut lire cette ligne de code comme ceci : " si la variable prix_voiture est inférieure à 5000, on exécute le code qui se trouve entre les accolades.

Les instructions qui sont entre les accolades ne seront exécutées que si la condition testée est vraie !

5.4.2. else

On a pour l’instant testé que si la condition est vraie. Maintenant, nous allons voir comment faire pour que d’autres instructions soient exécutées si la condition est fausse. Le terme else de l’anglais "sinon" implique notre deuxième choix si la condition est fausse. Par exemple, si le prix de la voiture est inférieur à 5000€, alors je l’achète. Sinon, je ne l’achète pas. Pour traduire cette phrase en ligne de code, c’est plus simple qu’avec un if, il n’y a pas de parenthèses à remplir :

int prix_voiture = 5500;

if(prix_voiture < 5000)
{
    // la condition est vraie, donc j'achète la voiture
}
else
{
    // la condition est fausse, donc je n'achète pas la voiture
}

Le else n’est pas obligatoire, on peut très bien mettre plusieurs if à la suite.

5.5. Les opérateurs logiques.

Comment faire pour savoir si la voiture vaut 5000€ *ET* si elle a l'option GPS ?

Il existe des opérateurs qui vont nous permettre de tester cette condition.

Reprenons ce que nous avons testé dans le else if : SI la voiture vaut 5500€ ET qu’elle a l’option GPS en plus, ALORS je l’achète. On va utiliser un if et un opérateur logique qui sera le ET :

int prix_voiture = 5500;
int option_GPS = TRUE;

/* l'opérateur && lie les deux conditions qui doivent être
vraies ensemble pour que la condition soit remplie */
if(prix_voiture == 5500 && option_GPS)
{
    // j'achète la voiture si la condition précédente est vraie
}

Si maintenant la condition testée dans le if est : "SI le prix de la voiture est inférieur à 5000€ OU SI le prix de la voiture est égal à 5500€ ET la voiture à l’option GPS en plus, ALORS j’achète la voiture".

On peut rassembler ces conditions:

int prix_voiture = 5500;
int option_GPS = TRUE;

if((prix_voiture < 5000) || (prix_voiture == 5500 && option_GPS))
{
    // la condition est vraie, donc j'achète la voiture
}
else
{
    // la condition est fausse, donc je n'achète pas la voiture
}

Attention aux parenthèses qui sont à bien placer dans les conditions, ici elles n’étaient nécessaires, mais elles aident à mieux lire le code.

5.6. Les boucles.

En programmation, une boucle est une instruction qui permet de répéter un bout de code. Cela va nous permettre de faire se répéter un bout de programme ou un programme entier. Il existe deux types principaux de boucles :

1	La boucle conditionnelle , qui teste une condition et qui exécute les instructions qu’elle contient tant que la condition testée est vraie.
2	La boucle de répétition , qui exécute les instructions qu’elle contient, un nombre de fois prédéterminé.

5.6.1. La boucle conditionnelle: while

Problème :

Je veux que le volet électrique de ma fenêtre se ferme automatiquement quand la nuit tombe (Nous ne nous occuperons pas de faire le système qui ferme le volet à l’arrivée de la nuit). La carte Arduino dispose d’un capteur qui indique la position du volet (ouvert ou fermé). Ce que nous cherchons à faire : c’est créer un bout de code qui fait descendre le volet tant qu’il n’est pas fermé .

Pour résoudre le problème posé, il va falloir que l’on utilise une boucle.

/* ICI, un bout de programme permet de faire les choses suivantes :
1. un capteur détecte la tombée de la nuit et la levée du jour
     - Si c'est la nuit, alors on doit fermer le volet
     - Sinon, si c'est le jour, on doit ouvrir le volet
2. le programme lit l'état du capteur qui indique si le volet est ouvert ou fermé
3. enregistrement de cet état dans la variable de type String : position_volet
     - Si le volet est ouvert, alors : position_volet = "ouvert";
     - Sinon, si le volet est fermé : position_volet = "ferme";
*/

while(position_volet == "ouvert")
{
    // instructions qui font descendre le volet
}

Il faut la lire : "TANT QUE la position du volet est ouvert ", on boucle/répète les instructions de la boucle (entre les accolades).

Tester ce code pour vous aider à comprendre.

Prenons un exemple simple, réalisons un compteur !

int compteur = 0;

void setup()
{
Serial.begin(9600);

while(compteur != 5)
{
    compteur++; // on incrémente la variable compteur à chaque tour de boucle
	Serial.print("compteur=");
    Serial.println(compteur);
}

}

void loop()
{

}

5.6.2. La boucle do…while.

Cette boucle est similaire à la précédente. Mais il y a une différence qui a son importance ! En effet, si on prête attention à la place la condition dans la boucle while , on s’aperçoit qu’elle est testée avant de rentrer dans la boucle. Tandis que dans une boucle do…while, la condition est testée seulement lorsque le programme est rentré dans la boucle :

do
{
    // les instructions entre ces accolades sont répétées
    // TANT QUE la condition est vrai
}while(/* condition à tester */);

Le mot do vient de l’anglais et se traduis par faire . Donc la boucle do…while signifie "faire les instructions, tant que la condition testée est fausse". Tandis que dans une boucle while on pourrait dire : "tant que la condition est fausse, fais ce qui suit".

Quelle est la différence entre ces deux boucles?

1	Tester le code ci-dessous et expliquer la différence avec le code précédent.

int compteur = 5;

void setup()
{
Serial.begin(9600);

do
{
    compteur++;  // on incrémente la variable compteur à chaque tour de boucle
	Serial.print("compteur=");
    Serial.println(compteur);
}while(compteur < 5);  // tant que compteur est inférieur à 5, on boucle

}

void loop()
{

}

5.6.3. La boucle for.

Cette boucle est exécutée X fois. Contrairement aux deux boucles précédentes, on doit lui donner trois paramètres.

for(int compteur = 0; compteur < 5; compteur++)
{
    // code à exécuter
}

Entre les parenthèses, on doit donner trois paramètres qui sont :

la création et l’assignation de la variable à une valeur de départ
suivit de la définition de la condition à tester.
suivit de l’instruction à exécuter.

la boucle est exécutée autant de fois qu’il sera nécessaire à compteur pour arriver à 5. Donc ici, le code qui se trouve à l’intérieur de la boucle sera exécuté 5 fois.

Proposer un programme permettant de faire clignoter une led 5 fois et testez-le sur tinkerCad.

5.7. Les fonctions.

Une fonction est un "conteneur" mais différent des variables. En effet, une variable ne peut contenir qu’un nombre, tandis qu’une fonction peut contenir un programme entier !

En fait, lorsque l’on va programmer notre carte Arduino, on va écrire notre programme dans des fonctions. Pour l’instant nous n’en connaissons que deux : setup() et loop() .

L’utilité d’une fonction réside dans sa capacité à simplifier le code et à le séparer en "petits bouts" que l’on assemblera ensemble pour créer le programme final Si vous voulez, c’est un peu comme les jeux de construction en plastique : chaque pièce à son propre mécanisme et réalise une fonction. Par exemple une roue permet de rouler ; un bloc permet de réunir plusieurs autres blocs entre eux ; un moteur va faire avancer l’objet créé… Et bien tous ces éléments seront assemblés entre eux pour former un objet (voiture, maison, …). Tout comme, les fonctions seront assemblées entre elles pour former un programme. On aura par exemple la fonction : "mettre au carré un nombre" ; la fonction : "additionner a + b" ; etc. Qui au final donnera le résultat souhaité.

5.8. Fabriquer une fonction.

Pour fabriquer une fonction, nous avons besoin de savoir trois choses :

Quel est le type de la fonction que je souhaite créer ?
Quel sera son nom ?

Quel(s) paramètre(s) prendra-t-elle ?

Nom de la fonction. Pour commencer, nous allons, en premier lieu, choisir le nom de la fonction. Par exemple, si votre fonction doit récupérer la température d’une pièce fournie par un capteur de température : vous appellerez la fonction lireTemperaturePiece , ou bien lire temperature piece.

Un nom de fonction explicite garantit une lecture rapide et une compréhension aisée du code. Un lecteur doit savoir ce que fait la fonction juste grâce à son nom, sans lire le contenu !

Les types et les paramètres. Ils servent à donner des informations au traitement qu’elle doit effectuer. Prenons un exemple concret. Pour changer l’état d’une sortie du microcontrôleur, Arduino nous propose la fonction suivante: digitalWrite(pin, value) . Ainsi, la référence nous explique que la fonction a les caractéristiques suivantes:
- paramètre pin : le numéro de la broche à changer.
- paramètre value : l’état dans lequel mettre la broche (HIGH, (haut, +5V) ou LOW (bas, masse))
- retour: pas de retour de résultat.

5.8.1. Le type void.

On vient de voir qu’une fonction pouvait accepter des paramètres et éventuellement renvoyer quelque chose. Mais ce n’est pas obligatoire.

Dans le cas d’une fonction faire clignoter une led, cette fonction ne renvoie aucun résultat alors que la fonction mettre au carré(par exemple) va nous indiquer le résultat de la mise au carré d’un nombre passé en paramètre à la fonction.

void nom_de_la_fonction()
{
    // instructions
}

On utilise donc le type void pour dire que la fonction n’aura pas de retour. Une fonction de type void ne peut donc pas retourner de valeur.

5.8.2. Les fonctions "typées".

Prenons un exmple que vous pouvez tester:

int calcul = 0;

void setup()
{
Serial.begin(9600);
calcul = 10 * maFonction();
Serial.print("calcul=");
Serial.println(calcul);
//ou
Serial.print("calcul=");
Serial.println(10 * maFonction());
}

void loop()
{

}

int maFonction()
{
    int resultat = 44;  // déclaration de ma variable résultat
    return resultat;
}

calcul est une variable globale car définit hors des fonctions loop() et setup().

Une variable globale sera reconnue par toutes les fonctions alors qu’une variable à l’intérieur d’une fonction (dite locale) sera reconnue uniquement dans cette fonction.

int maFonction() est notre fonction, elle est placée hors de la fonction loop()(programme principal). Cette fonction est typée car si elle est appelée elle va renvoyer un résultat de type entier(int) grâce à l’instruction return.
calcul = 10 x maFonction(); L’avantage des fonctions typées est que vous pouvez directement les appeler dans un calcul comme dans cette instruction.

5.8.3. Les fonctions avec paramètres.

Voilà un code, étudiez-le et testez-le.

int x = 64;
int y = 192;

void setup()
{
Serial.begin(9600);
maFonction(x, y);
Serial.print("f=");
Serial.println(maFonction(x, y));
}


void loop()
{

}

int maFonction(int param1, int param2)
{
    int somme = 0;
    somme = param1 + param2;
    // somme = 64 + 192 = 255

    return somme;
}

5.9. Décoder.

Voici un code, expliquez son fonctionnement.

unsigned char operation = 0;
int x = 5;
int y = 10;

void loop()
{
    // le paramètre "opération" donne le type d'opération à faire
    maFonction(x, y, operation);
}

int maFonction(int param1, int param2, int param3)
{
    int resultat = 0;
    switch(param3)
    {
    case 0 : // addition, resultat = 15
        resultat = param1 + param2;
        break;
    case 1 : // soustraction, resultat = -5
        resultat = param1 - param2;
        break;
    case 2 : // multiplication, resultat = 50
        resultat = param1 * param2;
        break;
    case 3 : // division, resultat = 0 (car nombre entier)
        resultat = param1 / param2;
        break;
    default :
        resultat = 0;
        break;
    }

    return resultat;
}

l’instruction switch va tester param3 avec tous les cas que l’on aura donnés.
L’instruction break est nécessaire , car si vous ne la mettez pas, l’ordinateur, ou plutôt la carte Arduino, va exécuter toutes les instructions. Elle permet de dire qu’il faut arrêter de tester les conditions car on a trouvé la valeur correspondante.
La structure swith-case est très utile dans la construction de menus par exemple.

5.10. Les tableaux.

Un tableau est une grosse variable. Son but est de stocker des éléments de mêmes types en les mettant dans des cases. Par exemple, un professeur qui stocke les notes de ses élèves. Il utilisera un tableau de float (nombre à virgule), avec une case par élèves.

Un tableau, tout comme sous Excel, c’est un ensemble constitué de cases, lesquels vont contenir des informations. En programmation, ces informations seront des nombres . Chaque case d’un tableau contiendra une valeur. En reprenant l’exemple des notes des élèves, le tableau répertoriant les notes de chaque élève ressemblerait à ceci :

5.10.1. Déclarer un tableau.

On le déclare avec un type semblable, et une taille représentant le nombre d’éléments qu’il contiendra. Par exemple, pour une classe de 20 étudiants (de 0 à 19):

float notes[20];

Si on voulait faire un tableau de 100 étudiants dans lesquels on recense leurs nombres d’absence, on ferait le tableau suivant:

char absenteisme[100];

5.10.2. Accéder et modifier une case du tableau.

Pour accéder à une case d’un tableau, il suffit de connaître l’indice de la case à laquelle on veut accéder. L’indice c’est le numéro de la case qu’on veut lire/écrire. Par exemple, pour lire la valeur de la case 10 (donc indice 9 car on commence à 0):

float notes[20]; // notre tableau
float valeur; // une variable qui contiendra une note

// valeur contient désormais la note du dixième élève
valeur = notes[9];

Pour accéder à une valeur on fait comme avec une variable normale, il suffit d’utiliser l’opérateur ' = ' :

notes[9] = 10,5;   // on change la note du dixième élève

5.10.3. Initialiser un tableau.

Ce que l’on va faire, c’est initialiser notre tableau. On a la possibilité de remplir chaque case une par une ou bien utiliser une boucle qui remplira le tableau à notre place.

char i=0; // une variable que l'on va incrémenter
float notes[20];  // notre tableau

void setup()
{
    // boucle for qui remplira le tableau pour nous
    for(i = 0; i < 20; i++)
    {
        notes[i] = 0; // chaque case du tableau vaudra 0
    }
}

Cette exemple permet d’initialiser rapidement un tableau mais avec une même valeur.

Sinon on peut directement remplir un tableau à sa création:

float note[] = {10,10,11,15,5,8,9,12,15,18};

Un peu de codage!!

1	Réaliser une fonction meilleurNote(float tableau[], int nombreEleve) permettant de trouver la note maximale dans le tableau, en passant comme paramètres un tableau et le nombre d’élève. Essayer par vous-même et regarder ensuite une proposition de correction. Correction `float meilleurNote(float tableau[], int nombreEleve) { int i = 0; int max = 0; // variable contenant la future meilleure note for(i=0; i<nombreEleve; i++) { // si la note lue est meilleure que la meilleure actuelle if(tableau[i] > max) { // alors on l'enregistre max = tableau[i]; } } // on retourne la meilleure note return max; }`
2	Assembler et tester les codes(initialisation du tableau,nombre max,..) dans le simulateur tinkerCad Correction int nbrEleve = 10; float note[] = {10,10,11,19,5,8,9,12,15,18}; float noteMax; void setup() { Serial.begin(9600); noteMax = meilleurNote(note,nbrEleve); Serial.print("noteMax="); Serial.println(noteMax); } float meilleurNote(float tableau[], int nombreEleve) { int i = 0; float max = 0; // variable contenant la future meilleure note for(i=0; i<nombreEleve; i++) { // si la note lue est meilleure que la meilleure actuelle if(tableau[i]>max) { // alors on l'enregistre max = tableau[i]; } } // on retourne la meilleure note return max; } void loop() { }
3	Réaliser une fonction float moyenneNote(float tableau[], int nombreEleve) permettant de trouver la moyenne des notes dans le tableau, en passant comme paramètres un tableau et le nombre d’élève.
4	Ajouter cette fonction au programme précédent et faire valider par le professeur.

5.11. Bilan.

Ce chapitre sur les structures algorithmiques pose les bases de la programmation avec la carte arduino. Avec ces nouvelles connaissances nous allons pouvoir aborder sereinement la suite de la formation et les projets.

Il y a bien sûr beaucoup de sujets qui n’ont pas été abordés mais les grandes lignes ont cependant été exposées.

N’oubliez pas que la programmation est une activité qui nécessite énormément de pratique. N’hésitez donc surtout pas à refaire chez vous les exercices proposés et même à les compléter par vous même en proposant des alternatives ou des évolutions.

Les outils utilisés au labo d’informatique sont majoritairement gratuits. Vous n’avez donc aucune excuse pour ne pas les installer chez vous !

De plus, la programmation informatique — du moins à notre niveau — n’occasionne pas de dégâts irréversibles. Donc, osez expérimenter même si cela n’aboutit pas : échouer c’est apprendre à réussir.

Bonne programmation !

6. Acquisition d’une grandeur logique.

Dans cette partie, nous allons utiliser des boutons poussoirs (ou BP). Ces derniers sont de deux types:

Normalement ouvert(NO)
- Relâché : le courant ne passe pas, le circuit est déconnecté ; on dit que le circuit est " ouvert".
- Appuyé : le courant passe, on dit que le circuit est fermé .
Le bouton poussoir normalement fermé (NF)

Ce type de bouton est l’opposé du type précédent, c’est-à-dire que lorsque le bouton est relâché, il laisse passer le courant. Et inversement :

Relâché : le courant passe, le circuit est connecté ; on dit que le circuit est " fermé ".
Appuyé : le courant ne passe pas, on dit que le circuit est ouvert .

Nous utiliserons également des interrupteurs.

l’interrupteur agit comme une bascule. Un appui ferme le circuit et il faut un second appui pour l’ouvrir de nouveau. Il possède donc des états stables (ouvert ou fermé). On dit qu’un interrupteur est bistable . Vous en rencontrez tous les jours lorsque vous allumez la lumière.

6.1. Mise en oeuvre d’un bonton poussoir.

Figure 1. Quelques boutons poussoirs - (CC-BY-SA Scwerllguy )

Souvent ils ont quatre pattes (comme sur l’image ci-dessus). Si c’est le cas, sachez que les broches sont reliées deux à deux. Cela signifie quelles fonctionnent par paire. Il faut donc se méfier lorsque vous le brancher sinon vous obtiendrez le même comportement qu’un fil (si vous connectez deux broches reliées).

Utilisez un multimètre pour déterminer quelles broches sont distinctes. Pour ne pas se tromper, on utilise en général deux broches qui sont opposées sur la diagonale du bouton.

Comprendre le bouton poussoir

Les contraintes:

liées aux bruits électromagnétiques.

Lorsque l’on fait de l’électronique, on a toujours peur des perturbations (générées par plein de choses : des lampes à proximité, un téléphone portable, un doigt sur le circuit, l’électricité statique, …). On appelle ça des contraintes de CEM . Ces perturbations sont souvent inoffensives, mais perturbent beaucoup les montages électroniques. Il est alors nécessaire de les prendre en compte lorsque l’on fait de l’électronique de signal. Par exemple, dans certains cas on peut se retrouver avec un bit de signal qui vaut 1 à la place de 0, les données reçues sont donc fausses.

Pour contrer ces effets nuisibles, on place en série avec le bouton une résistance de pull-up. Cette résistance sert à "tirer" ("to pull" in english) le potentiel vers le haut (up) afin d’avoir un signal clair sur la broche étudiée. Sur le schéma suivant, on voit ainsi qu’en temps normal le "signal" a un potentiel de 5V. Ensuite, lorsque l’utilisateur appuiera sur le bouton une connexion sera faite avec la masse. On lira alors une valeur de 0V pour le signal. Voici donc un deuxième intérêt de la résistance de pull-up, éviter le court-circuit qui serait généré à l’appui !
Liées à la mécanique.

Les boutons ne sont pas des systèmes mécaniques parfaits. Du coup, lorsqu’un appui est fait dessus, le signal ne passe pas immédiatement et proprement de 5V à 0V. En l’espace de quelques millisecondes, le signal va "sauter" entre 5V et 0V plusieurs fois avant de se stabiliser. Il se passe le même phénomène lorsque l’utilisateur relâche le bouton.

Ce genre d’effet n’est pas désirable, car il peut engendrer des parasites au sein de votre programme (si vous voulez détecter un appui, les rebonds vont vous en générer une dizaine en quelques millisecondes, ce qui peut-être très gênant dans le cas d’un compteur par exemple). Voilà un exemple de chronogramme relevé lors du relâchement d’un bouton poussoir :

Pour atténuer ce phénomène, nous allons utiliser un condensateur en parallèle avec le bouton. Ce composant servira ici "d’amortisseur" qui absorbera les rebonds (comme sur une voiture avec les cahots de la route). Le condensateur, initialement chargé, va se décharger lors de l’appui sur le bouton. S’il y a des rebonds, ils seront encaissés par le condensateur durant cette décharge. Il se passera le phénomène inverse (charge du condensateur) lors du relâchement du bouton. Ce principe est illustré à la figure suivante :

En résumé, voilà un montage que vous pourriez obtenir avec un bouton, sa résistance de pull-up et son filtre anti-rebond sur votre carte Arduino :

Les pull-ups internes.

Comme expliqué précédemment, pour obtenir des signaux clairs et éviter les courts-circuits, on utilise des résistances de pull-up. Cependant, ces dernières existent aussi en interne du microcontrôleur de l’Arduino, ce qui évite d’avoir à les rajouter par nous-mêmes par la suite. Ces dernières ont une valeur de 20 kilo-Ohms. Elles peuvent être utilisées sans aucune contrainte technique.

Il suffira d’indiquer l’argument INPUT_PULLUP dans l’instruction pinMode.

const int unBouton = 2; // un bouton sur la broche 2

void setup()
{
    pinMode(unBouton, INPUT_PULLUP);
}

void loop()
{
    // votre programme
}

un bouton resistance pullup interne schema

6.2. Traitement logiciel de l’appui sur un bouton poussoir.

Maintenant que nous avons vu le fonctionnement de ce bouton poussoir, nous allons réaliser un programme capable de détecter cette grandeur logique et de commander l’allumage d’une led.

Nous pourrions commander n’importe quoi d’autre mais cet exemple simple pour une initiation est suffisant, de plus il permettra de reprendre vos connaissances sur la led vu précédement.

Pour rappel, nous allons lire l’état d’une entrée logique. Une entrée logique ne peut prendre que deux états, HAUT ( HIGH ) ou BAS ( LOW ). L’état haut correspond à une tension de +5V sur la broche, tandis que l’état bas est une tension de 0V. Dans notre exemple, nous allons utiliser un simple bouton. Dans la réalité, vous pourriez utiliser n’importe quel capteur qui possède une sortie logique.

Nous allons donc utiliser :

Un bouton poussoir (et une résistance de 10k de pull-up et un condensateur anti-rebond de 10nF)
Une LED (et sa résistance de limitation de courant)
La carte Arduino

1	Voici le schéma à réaliser dans tinkerCad :
2	Ecrire le code pour declarer le bouton pour la fonction setup() avec les informations suivantes: On déclare une variable globale nommée "bouton" et ayant la valeur 2. La resistance de pull-up étant externe, l’argument du type d’entrée de l’instruction pinMode est INPUT.
3	Analyse électrique: répondre à ce QCM. Cocher la ou les bonnes réponses. Quelle sera la tension sur la broche 2 si l'on appui sur le bouton poussoir. U2 = 5V U2 = 0V Quelle sera le niveau logique si l'on appui sur le bouton poussoir. HIGH LOW Pour lire l’état logique d’une entrée logique il faut utiliser la fonction digitalRead() . Cette fonction prend un paramètre qui est la broche à tester et elle retourne une variable de type int . Pour lire l’état de la broche 2 nous devons ajouter un code comme : `int etat; void loop() { etat = digitalRead(bouton); // Rappel : bouton = 2 }`
4	Réaliser un programme permettant : lorsque l’on appuie sur le bouton, la LED doit s’éteindre. Lorsque l’on relâche le bouton, la LED doit s’allumer.

Indices si necessaire…

le bouton est connecté à la broche 2 de la carte Adruino : const int bouton = 2;
la LED à la broche 13 : const int led = 13;
variable qui enregistre l’état du bouton : int etatBouton;

Vous pouvez vous aider de l’exemple bouton dans tinkerCad.

8. Traiter un signal analogique avec un système numérique.

Jusqu’à présent nous n’avons fait qu’utiliser des grandeurs numériques binaires. Autrement dit, nous n’avons utilisé que des états logiques HAUT et BAS.Ces deux niveaux correspondent respectivement aux tensions de 5V et 0V.

Cependant, une valeur analogique ne se contentera pas d’être exprimée par 0 ou 1. Elle peut prendre une infinité de valeurs dans un intervalle donné. Dans notre cas, par exemple, la grandeur analogique pourra varier aisément de 0 à 5V en passant par 1.45V, 2V, 4.99V, etc.

Voici un exemple de signal analogique, un signal sinusoïdal :

Si on essaye de mettre ce signal (ce que je vous déconseille de faire) sur une entrée numérique de l’Arduino et qu’on lit les valeurs avec digitalRead(), on ne lira que 0 ou 1. Les broches numériques de l’Arduino étant incapable de lire les valeurs d’un signal analogique.

Il faut donc ajouter une fonction permettant de convertir un signal analogique en un signal numérique.

Evidement la carte arduino intégre quelques convertisseurs analogique-numérique ou CAN

8.1. Le CAN.

C’est un dispositif qui va convertir des grandeurs analogiques en grandeurs numériques. La valeur numérique obtenue sera proportionnelle à la valeur analogique fournie en entrée.

Il existe différentes façons de convertir une grandeur analogique, plus ou moins faciles à mettre en œuvre, plus ou moins précises et plus ou moins onéreuses.

Nous ferons un chapitre complet sur les CAN mais pour l’instant nous allons simplement le mettre en oeuvre sur la carte arduino.

8.2. Lire la tension analogique sur une broche analogique.

Sur une carte Arduino Uno, on retrouve 6 CAN . Ils se trouvent tous du même côté de la carte, là où est écrit "Analog IN" :

Ces 6 entrées analogiques sont numérotées, tout comme les entrées/sorties logiques. Par exemple, pour aller lire la valeur en sortie d’un capteur branché sur le convertisseur de la broche analogique numéro 3, on fera : valeur = analogRead(3);

analogRead(pin) est une fonction qui va nous permettre de lire la valeur lue sur une entrée analogique de l’Arduino.

Elle prend un argument et retourne la valeur lue :

L’argument est le numéro de l’entrée analogique à lire (explication ci-dessous)
La valeur retournée (un int ) sera le résultat de la conversion analogique- >numérique

Voici un code pour lire une tension analogique.

// broche analogique 3 OU broche numérique 3
const int monCapteur = 3;

// la valeur lue sera comprise entre 0 et 1023
int valeurLue = 0;

// fonction setup()
{
...
}

void loop()
{
    // on mesure la tension du capteur sur la broche analogique 3
    valeurLue = analogRead(monCapteur);

    // du code et encore du code ...
}

8.2.1. Exemple d’utilisation.

Nous avons besoin d’un capteur analogique. Ce capteur doit convertir une grandeur physique en une tension électrique. Nous pourrions utiliser un capteur de température ou de luminosité mais pour simplifier la manipulation nous allons utiliser un potentiomètre.

Le potentiomètre

C’est un composant très fréquemment employé en électronique. On le retrouve aussi sous le nom de résistance variable. Il permet de convertir une position en une tension électrique exemple un bouton de volume sur amplificateur audio.

voici le symbole du potentiomètre :

On y remarque une première chose importante, le potentiomètre a trois broches.

Deux servent à borner les tensions maximum (A) et minimum (B) que l’on peut obtenir à ses bornes, et la troisième est reliée à un curseur mobile qui donne la tension variable obtenue entre les bornes précédemment fixées.

Ainsi, on peut représenter notre potentiomètre comme un "diviseur de tension réglable". En effet, lorsque vous déplacez le curseur, en interne cela équivaut à modifier le point milieu.

En termes électroniques, vous pouvez imaginer avoir deux résistances en série (R1 et R2 ). Lorsque vous déplacez votre curseur vers la borne basse, R1 augmente alors que R2 diminue et lorsque vous déplacez votre curseur vers la borne haute, R2 augmente alors que R1 diminue.

Voici un tableau montrant quelques cas de figure de manière schématique :

Vous pouvez suivre ces vidéos pour plus d’informations:

Rappel pont diviseur de tension

Comprendre le potentiomètre

1	Réaliser le montage suivant sur tinkerCad.
2	Réaliser un programme permettant la lecture et l’affichage de la valeur convertie qui dépend de la position de l’axe du potentiomètre.
3	Tester le montage et votre code avec le simulateur.
4	Pour une variation compléte de l’axe du potentiomètre comme varie la valeur numérique affichée dans le moniteur série? Vous pouvez utiliser un voltmètre entre l’entrée analogique et la masse pour mesurer la variation de tension en entrée.

Correction si nécessaire.

// le potentiomètre, branché sur la broche analogique 0
const int potar = 0;
// variable pour stocker la valeur lue après conversion
int valeurLue;
// on convertit cette valeur en une tension
float tension;

.Bilan de cette partie.
***
Nous constatons que pour une variation compléte du potentiomètre
***
void setup()
{
    // on se contente de démarrer la liaison série
    Serial.begin(9600);
}

void loop()
{
    // on convertit en nombre binaire la tension lue en sortie du potentiomètre
    valeurLue = analogRead(potar);



    // on affiche la valeur lue sur la liaison série
    Serial.print("valeurLue = ");
    Serial.println(valeurLue);


    // on saute une ligne entre deux affichages
    Serial.println();
    // on attend une demi-seconde pour que l'affichage ne soit pas trop rapide
    delay(500);
}

Bilan de la partie.

Après avoir relié un potentiomètre à une entrée analogique de l’arduino, on constate que pour une variation de la tension entre 0 et 5V, la valeur numérique fournie par la carte arduino évolue entre 0 et 1023.

Pourquoi cette plage de variation?

Pour répondre à cette question et comprendre la correspondance entre cette valeur numérique et la grandeur analogique d’entrée nous devons approfondir nos connaissances sur le CAN.

C’est ce que nous allons voir dans le prochain chapitre.

9. La conversion analogique-numérique ou numérisation de l’information.

9.1. L’information c’est quoi?

Les progrès technologiques ont dopé la communication, par la rotative et le chemin de fer au XIXe siècle, puis les ondes hertziennes, le satellite et l’Internet.

L’information est immatérielle. Elle peut être consignée directement ou pas sur un support matériel qui prend alors la valeur de document. L’information toutefois est indépendante du support : elle existe indépendamment de lui.

9.1.1. Transmission des informations.

On appelle information un ensemble de connaissances qui peuvent être codés de plusieurs façons Letransfert d’une information nécessite une chaîne de transmission.

Elle comporte un encodeur, qui code l’information, qui la transmet à un émetteur (qui éventuellement la crypte, la compresse,la module,…) qui la transmet à un récepteur (qui éventuellement la décrypte, la décompresse, la démodule,…) qui la décode et la restitue.

Exemple : Chaîne de transmission en téléphonie

La transmission peut être soit analogique ou numérique (signal discret).

La façon de transmettre l’information a évolué au niveau du milieu de transmission et de la nature des signaux.

Si on utilise l’atmosphère comme milieu, les signaux peuvent être : des sons, des ultra-sons, des ondes électromagnétiques,…
Si on utilise la fibre optique, les signaux sont alors des ondes électromagnétiques.

Exemple : Lorsqu’un usager téléphone, une ligne le relie à son correspondant.

Elle assure le transport de la voix, dans les deux sens, jusqu’à ce que la communication soit terminée. Cette liaison provisoire est créée par la compagnie de téléphone, grâce à des opérations de commutation effectuées dans les centraux téléphoniques.

Dans l’histoire du téléphone, la commutation a d’abord été réalisée de façon manuelle, puis électromécanique, puis enfin informatique.

Entre l’invention du téléphone par A.G.Bell (en 1877) et les années soixante, la voix fut transmise de manière analogique, sous forme d’un signal électrique se propageant sur des fils de cuivre. Puis les compagnies de téléphone commencèrent à utiliser la transmission numérique entre les centraux.La transformation du signal, analogique vers numérique et inversement, est assurée par des "codecs" (Codeur/DECodeur).

9.1.2. Rappel sur la nature de l’information.

Dans un système de traitement, l’information peut être:

Analogique (analog): le signal varie de manière continue au cours du temps (mesure d’une grandeur physique). Son amplitude peut prendre une infinité de valeurs dans un intervalle de temps donné.

Une grandeur analogique varie de façon continue proportionnellement à l’indication donnée par un capteur.
Numérique (digital): la représentation du signal varie de façon discrète (ie: discontinue) dans une liste de valeurs.

Une grandeur numérique varie de façon discontinue et non proportionnelle à l’indication donnée par un capteur (ie: la valeur de la tension mesurée avec un voltmètre numérique est exprimée au moyen de un ou plusieurs chiffres dont la lecture est précise)
Logique (logic): le signal est convertit dans un état binaire qui ne prend que deux valeurs, notées par convention 0 et 1 (logique Tout ou Rien, TOR).

On caractérise le signal par:

sa forme, qui peut être quelconque, sinusoïdale, triangulaire ou rectangulaire.
sa périodicité. Dans ce cas il peut être soit périodique, soit non-périodique. S’il est périodique on calcule alors sa période1 T en secondes (s) ou sa fréquence2 f en Hertz (Hz).
son amplitude. Elle représente la différence entre la valeur maximale et la valeur minimale (qui peut être négative).
sa valeur moyenne s’il est périodique.

9.3. Modélisation d’un CAN.

Pour répondre à la question du chapitre précédent sur le pourquoi d’une variation de la valeur numérique fournie par l’adruino entre 0 à 1023. Nous pouvons maintenant répondre que la carte arduino utilise un convertisseur 10 bits.

Cependant il faudrait comprendre la relation qu’il existe entre ce nombre et la grandeur analogique de l’entrée. Nous allons modéliser cette relation.

On peut trouver la caractéristique de transfert : H = f(Ue).

Le nombre N ne peut prendre que des valeurs discrèt es alors que la tension Ue accepte toutes les valeurs dans uns plage donnée : l’évolution se fera par paliers.

Nous avons vu que chaque paliers correspond à la résoltion du convertisseur, ou pas ou quantum.

\$ q = "plage" / 2^n\$

La plage pour une arduino est de 5V et le convertisseur est de 10 bits donc

\$ q = 5 / 1024\$

Si nous cherchons le modéle du graphe précédent, il s’agit d’une fonction linéaire ; y=ax donc:

N = k Ue

a ou k est un coefficient directeur de cette droite. On détermine ce coefficient par :

le rapport entre une variation des ordonnées sur une variation des abscisses.

Par exemple pour une variation de 1 sur les ordonnées, nous avons une variation d’un quantum sur les absisses.

Donc

\$ k = 1 / q =1 /(5/1024) =1024/5\$

Le modéle final est :

\$ N = k . U_e = 1 / q . U_e= 1024/5 . U_e\$

On peut vérifier que cette relation est homogène car le résultat du calcul est bien un nombre.

Cependant il faudra arrondir à la valeur entière par défaut.

Nous allons pouvoir reprendre notre programme arduino est afficher sur le moniteur série la valeur de la tension analogique affichée sur le voltmètre.

9.4. Retour à l’arduino.

Vous avez réalisé pour rappel ce montage et placé un voltmètre entre l’entrée A0 de l’arduino et la masse:
Vous avez réaliser ce code:

// le potentiomètre, branché sur la broche analogique 0
const int potar = 0;
// variable pour stocker la valeur lue après conversion
int valeurLue;
// on convertit cette valeur en une tension
float tension;

.Bilan de cette partie.
***
Nous constatons que pour une variation compléte du potentiomètre
***
void setup()
{
    // on se contente de démarrer la liaison série
    Serial.begin(9600);
}

void loop()
{
    // on convertit en nombre binaire la tension lue en sortie du potentiomètre
    valeurLue = analogRead(potar);



    // on affiche la valeur lue sur la liaison série
    Serial.print("valeurLue = ");
    Serial.println(valeurLue);


    // on saute une ligne entre deux affichages
    Serial.println();
    // on attend une demi-seconde pour que l'affichage ne soit pas trop rapide
    delay(500);
}

Nous voulons compléter ce code pour afficher la valeur de la tension analogique afin d’obtenir la même valeur que sur le voltmètre.

proposer cette modification.

Nous voulons afficher la valeur de Ue ou tension, à vous d’adapter la formule précédente.

Correction si nécessaire.

// le potentiomètre, branché sur la broche analogique 0
const int potar = 0;
// variable pour stocker la valeur lue après conversion
int valeurLue;
// on convertit cette valeur en une tension
float tension;

void setup()
{
    // on se contente de démarrer la liaison série
    Serial.begin(9600);
}

void loop()
{
    // on convertit en nombre binaire la tension lue en sortie du potentiomètre
    valeurLue = analogRead(potar);

    // on traduit la valeur brute en tension (produit en croix)
    tension = valeurLue * 5.0 / 1023;

    // on affiche la valeur lue sur la liaison série
    Serial.print("valeurLue = ");
    Serial.println(valeurLue);

    // on affiche la tension calculée
    Serial.print("Tension = ");
    Serial.print(tension,2);
    Serial.println(" V");

    // on saute une ligne entre deux affichages
    Serial.println();
    // on attend une demi-seconde pour que l'affichage ne soit pas trop rapide
    delay(500);
}

Bravo, vous avez crée votre première chaine d’acquisition de grandeur analogique. Vous pouvez maintenant mettre n’importe quel autre capteur (humidité, température, pression…) la démarche sera la même. Nous verons quelques exemples…

9.7. Un exemple dans l’ingénierie du son.

Dans ce document vous pouvez suivre toutes les étapes de l’acquisition d’un signal sonore dans un studio d’enregistrement.

Ingénierie du son.

1	Les valeurs instantanées : Elles sont variables avec le temps et sont notées : i(t), u(t), …etc. +
2	Les valeurs maximales : Elles sont indépendantes du temps et sont notées : Imax, Umax, …etc. + Remarque : Valeur maximale de l’intensité du courant i(t). C’est la valeur maximale que peut atteindre l’intensité du courant i(t) au cours d’une période. +
3	Les valeurs minimales : Elles sont indépendantes du temps et sont notées : Imin, Umin, …etc. Remarque : Valeur minimale de l’intensité du courant i(t). C’est la valeur minimale que peut atteindre l’intensité du courant i(t) au cours d’une période.
4	Les valeurs moyennes : Elles sont indépendantes du temps et sont notées : Imoy, Umoy, …etc.
5	Valeur crête à crête : C’est l’écart entre l’intensité maximale et l’intensité minimale du courant.

1	La pulsation ω: La période de la fonction sinus est 2Π. Pour un signal de forme sinusoïdale qui a une phase à l’origine nulle on peut écrire l’équation suivante : \$ omega = 2 . Pi . f\$
2	La valeur crête à crête : Ipp: La valeur crête à crête de l’intensité d’un courant sinusoïdal est donnée par : \$ I_(pp) = I_max - I_min.\$ La valeur crête à crête de l’intensité d’un courant électrique se mesure à l’aide d’un OSCILLOSCOPE.
3	La valeur efficace : Ieff La valeur efficace de l’intensité d’un courant sinusoïdal est donnée par : \$ I_(eff) = I_max / sqrt(2).\$ La valeur efficace de l’intensité d’un courant électrique se mesure à l’aide d’un ampèremètre en position « ALTERNATIF ».
4	La valeur moyenne : Imoy La valeur moyenne de l’intensité d’un courant sinusoïdal correspond à la partie continue du signal sinusoïdal. Dans le cas d’un signal sinusoïdal alternatif sa valeur moyenne est nulle. La valeur moyenne de l’intensité d’un courant électrique sinusoïdal se mesure à l’aide d’un ampèremètre en position « CONTINU ». \$ I_(moy) = (I_max + I_min) / 2.\$