preface

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:

    1. 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.

      chaineFonctionnelle
    2. Thermostat communicant.

      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.

chaineFonctionnelle2

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 :

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:

  1. Connectez votre Arduino à votre ordinateur.

  2. Sélectionnez dans l’IDE Arduino le bon type de carte et le bon port USB.

  3. Pour sélectionner la carte, allez dans “Outils” et dans “Type de carte”.

    serie1

    Pour sélectionner le port, allez dans “Outils” puis dans “Port”

    serie2
    • Etape 3: Identifier les bornes de la LED.

Une led ressemble à ceci :

led

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 :

led1
  • 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 :

led2

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.

  1. 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.

      led3

      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.

  2. É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.

  3. Ajouter une commande delay

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

    led4

    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.

    led5
    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

  1. Indiquer pour quelle tension sur la broche D2, la LED va s’allumer?

  2. 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:

3.2.2. Mise en oeuvre.

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

une breadboard

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

  1. Réaliser le montage sur votre breadbord en vous aidant des schémas ci-dessous.

    realisation montage schema de la carte montage avec une led et sans breadboard montage une led sur breadboard

  2. Modifier votre programme précédent pour faire clignoter la led.

4. initiation par la simulation.

Nous allons utiliser un simulateur en ligne: tinkerCad

  1. Commencer par vous créer un compte sur le site:https://www.tinkercad.com

  2. 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 :

var

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

var1

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:

  1. Une carte arduino: Platine d’essai.

  2. Cliquer sur le bouton : Code.

  3. 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.:

conditions

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.

log

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 :

  1. la création et l’assignation de la variable à une valeur de départ

  2. suivit de la définition de la condition à tester.

  3. 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 ?

    1. 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 !

    2. 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 :

tableau

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:

  1. 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é .

  2. 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.

inter

6.1. Mise en oeuvre d’un bonton poussoir.

quelques boutons poussoirs
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.

Les contraintes:
  1. 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 !

    resistance pull up
  2. 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 :

chronogramme avec rebond

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 :

filtre anti rebond

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 :

un bouton resistance pullup schema
un bouton resistance pullup montage

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 :
un bouton et une led schema
un bouton et une led montage
2 Ecrire le code pour declarer le bouton pour la fonction setup() avec les informations suivantes:
  1. On déclare une variable globale nommée "bouton" et ayant la valeur 2.

  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.

  1. Quelle sera la tension sur la broche 2 si l'on appui sur le bouton poussoir.
    1. U2 = 5V
    2. U2 = 0V


  2. Quelle sera le niveau logique si l'on appui sur le bouton poussoir.
    1. HIGH
    2. 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.

7. La chaîne d’information.

La miniaturisation et la réduction des coûts des circuits électroniques ont permis l’intégration des microprocesseurs dans la plupart des produits qui nous entourent. Ces produits doivent traiter un nombre croissant d’informations parfois très différentes.

7.1. Le flux d’information.

Le flux d’information d’un système est constitué par une chaîne d’information qui permet:

  1. D’acquérir (mesurer) une grandeur physiqueou d’acquérir les consignes (ordres) d’un opérateur.

  2. De transmettre cette information à l’unité de traitement.

  3. De traiter l’information pour contrôler l’action réalisée sur la matière d’œuvre.

  4. De stocker l’information ou le résultat du traitement.

  5. De communiquer l’état du système à l’utilisateur à travers une IHM1 ou à un autre système de communiquer une consigne (ordre) à la chaîne d’énergie.

info1

Souvent, les informations de la fonction ACQUERIR sont transmises à la fonction TRAITER par desimples fils ou connecteurs électriques. Ces informations et les résultats du traitement ne sont généralement pas stockés.La chaîne d’information se compose alors de 3 blocs fonctionnels:

info2

Nous retrouvons bien avec cette chaine d’information les élèments des activités précédentes, à savoir le bouton poussoir pour la fonction acquerir, l’arduino pour la fonction traiter et la led pour la fonction communiquer.

Il faut bien comprendre que cette représentation sera utilisable pour représenter la pluspart des systèmes.

7.2. Acquérir.

La fonction ACQUERIR convertit et adapte une grandeur physique (position, vitesse, pression, intensité lumineuse…​) ou une information émise par l’utilisateur.L’information est ensuite transmise à l’aide d’un signal électrique qui peut être une tension électrique(en général) ou un courant électrique. Elle peut être de nature:

7.2.1. Logique.

l’information qui ne peut prendre que deux états (0 ou 1, état bas ou état haut), on parle égalementd’information Tout Ou Rien (TOR).Cette information sera transmise par un signal logique.

logique

7.2.2. Analogique.

l’information dont l’état varie de manière continue au cours du temps en prenant une infinité de valeurs. Cette information sera transmise par un signal analogique.

anal

7.2.3. Numérique.

l’information prend un nombre limité de valeurs.Cette information sera transmise par plusieurs signaux logiques.

num

7.3. Les capteurs.

L’image de la grandeur physique est obtenue par une famille de constituants appelée CAPTEUR.

  • Un capteur qui fournit un signal logique est appelé un détecteur.

  • Un capteur qui fournit un signal numérique est appelé un codeur.

  • Un capteur qui fournit un signal analogique est appelé un capteur.

  • L’information émise par l’utilisateur est obtenue par une interface HOMME/MACHINE ou IHM.

Dans le cas du bouton poussoir on peut parler de detecteur mais également d’une IHM.

7.4. Exemple de chaine d’information: La serrure codée.

serrure

QCM.


Cocher la ou les bonnes réponses.

  1. Quelles fonctions font partie de la chaîne d'information.
    1. Communiquer
    2. Numériser
    3. Convertir
    4. Traiter


  2. Une information logique.
    1. varie de façon continue
    2. ne peut prendre que 2 états
    3. prend un nombre limité de valeurs


  3. Un microprocesseur est constitué :
    1. d'un CPU
    2. d'un capteur IR
    3. d'une horloge
    4. d'un écran LCD


  4. Quelles fonctions font partie de la chaîne d'information.
    1. Communiquer
    2. Numériser
    3. Convertir
    4. Traiter


  5. Un microprocesseur fait partie de la fonction:
    1. Communiquer
    2. Numériser
    3. Convertir
    4. Traiter


  6. Une liaison wi-fi fait partie de la fonction:
    1. Communiquer
    2. Numériser
    3. Convertir
    4. Traiter


  7. Une information numérique:
    1. varie de façon continue
    2. ne peut prendre que 2 états
    3. prend un nombre limité de valeurs


  8. La fonction «communiquer»:
    1. est la première fonction de la chaîne d'information
    2. a besoin d'une interface de communication
    3. rend compte à la fonction traiter
    4. Traiter


  9. Un interrupteur fait partie de la fonction:
    1. Communiquer
    2. Numériser
    3. Acquérir
    4. Traiter


  10. IHM signifie:
    1. Interface Homme Machine
    2. Interactive Human Mainstream
    3. Intervention Hyper Maintenance
    4. Traiter

7.5. Caractérisations des signaux analogiques.

Les signaux analogiques sont les plus courant dans le nature comme par exemple l’évolution d’une température ou de la luminosité entre le jour et la nuit.

Ces grandeurs physiques(température, humidité, luminosité…​) varient de façon continue dans le temps et les capteurs convertissent le plus souvent ces grandeurs physiques en grandeurs éléctriques variant de façon continue également donc ceux sont des signaux électriques analogiques.

voici un signal analogique d’un courant à la sortie d’un microphone.

Le microphone convertit une grandeur physique (onde mécanique) en une grandeur analogique électrique.

courant

En régime variable, les courants et les différences de potentiels sont des grandeurs variant avec le temps.

7.5.1. Classification des signaux :

  1. Les signaux variables peuvent être classés selon leur sens de circulation :

    • Les signaux unidirectionnels circulent toujours dans le même sens. Les intensités et les différence de potentiel(ddp) qui leur correspondent sont toujours de même signe.

      unipos
      Figure 2. Signal unidirectionel positif.
    • Les signaux bidirectionnels ne circulent pas toujours dans le même sens. Les intensités et les ddp qui leur correspondent sont tantôt négatives, tantôt positives.

      bi
      Figure 3. Signal bidirectionel.
  2. Grandeurs caractéristiques des signaux variables.

    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.
  3. Les signaux variables périodiques.

    periode
    Figure 4. Signal périodique.

    La représentation d’un signal électrique périodique est une répétition de figures identiques.

    Definition de période.

    La période d’un signal électrique périodique est l’intervalle de temps T qui sépare deux instants consécutifs où le signal électrique se reproduit identiquement à lui même.

    \$ T = 1 / F\$

    T en seconde (s).

    F en Hertz (Hz).

    La fréquence F représente le nombre de périodes T en une seconde.

7.5.2. Etude du signal sinusoidal.

L’expression mathématique d’un courant alternatif sinusoïdal est :

\$ i(t) = I_max . sin(omega . t + phi)\$

t : Temps en secondes (s).

omega ω: Pulsation en radians par seconde (rad/s).

Phi Φ: Phase à l’origine en radians (rad).

phi
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.\$

Applications.


Cocher la ou les bonnes réponses.

  1. Quelles est la valeur maximale de i(t) = 5 sin ( 6284 t + Π ).
    1. 5A
    2. - 5A
    3. 0 A
    4. 3.53A


  2. Quelles est la valeur minimale de i(t) = 5 sin ( 6284 t + Π ).
    1. 5A
    2. - 5A
    3. 0 A
    4. 3.53A


  3. Quelles est la valeur moyenne de i(t) = 5 sin ( 6284 t + Π ).
    1. 5A
    2. - 5A
    3. 0 A
    4. 3.53A


  4. Quelles est la valeur efficace de i(t) = 5 sin ( 6284 t + Π ).
    1. 5A
    2. - 5A
    3. 0 A
    4. 3.53A


  5. Quelles est la fréquence i(t) = 5 sin ( 6284 t + Π ).
    1. 10KHz
    2. 1KHz
    3. 0 Hz
    4. 1000Hz


  6. Quelles est la période de i(t) = 5 sin ( 6284 t + Π ).
      1. 0.1ms
      2. 1ms
      3. 0ms
      4. 0.001s


    ex1
  7. Pour le signal ci-dessus indiquer la période.
    1. 0.1ms
    2. 1ms
    3. 0ms
    4. 0.001s


  8. Pour le signal ci-dessus indiquer la fréquence.
    1. 10KHz
    2. 1KHz
    3. 0 Hz
    4. 1000Hz


  9. Pour le signal ci-dessus indiquer la pulsation.
    1. 628,4 rad/s
    2. 62,84 rad/s
    3. 3140 rad/s
    4. 6284 rad/s


  10. Pour le signal ci-dessus indiquer la valeur moyenne.
    1. 2 A
    2. 0 A
    3. 1 A
    4. 3 A


  11. Pour le signal ci-dessus indiquer la valeur efficace.
    1. 4 A
    2. 2.82 A
    3. 1.414 A
    4. 0.707 A

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 :

un signal analogique periodique

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" :

positions des entrees analogiques

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 :

symbole du potentiometre

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 :

pot

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

1 Réaliser le montage suivant sur tinkerCad.
potentiometre schema
potentiometre montage
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

chaineTel

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:

  1. 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.

    analog
  2. 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)

    num2
  3. 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).

log2

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.2. La numérisation.

Un signal est la représentation physique d’une information qui est transportée avec ou sans transformation, de la source jusqu’au destinataire. Il en existe deux catégories :

  1. les signaux analogiques, qui varient de façon continue dans le temps (intensité sonore, intensité lumineuse, pression, tension), c’est-a-dire qu’ils peuvent prendre une infinité de valeurs différentes.

  2. les signaux numériques qui transportent une information sous la forme de nombres.

Le signal analogique à convertir est une tension électrique variable issue d’un capteur (microphone par exemple) ou d’un circuit électrique.On obtient alors la courbe suivante représentant le signal analogique :

num3

Numériser un signal analogique consiste à transformer les grandeurs continues dans le temps en des grandeurs discontinues qui varient par palier en prenant des valeurs à intervalle de temps régulier : période d’échantillonnage Te.

La numérisation est faites à l’aide d’un convertisseur analogique-numérique (CAN).

exNum

La numérisation d’un signal nécessite trois étapes :

  1. L’échantillonnage

  2. La quantification

  3. Le codage

1 L’échantillonnage.

On appelle période d’échantillonnage Te (en s), le temps entre deux mesures successives.La fréquence d’échantillonnage fe, correspond au nombre de mesures effectuées par seconde.

Le choix de la fréquence d’échantillonnage est crucial afin de reproduire fidèlement le signal étudié. En effet si le signal analogique varie trop vite par rapport à la fréquence d’échantillonnage, la numérisation donnera un rendu incorrect.

Théorème de Shannon

Pour un signal périodique (comme un son) la fréquence échantillonnage fe doit être au moins le double de la fréquence maximale f max du signal : fe > f max

Exemple : Les fichiers audio sont couramment échantillonnés à 44,1 kHz, car cela permet de restituer des sons dont la fréquence peut aller jusqu’à 22,05 kHz, c’est-à-dire un peu au-delà de la fréquence maximale audible par l’Homme (20 kHz).

Le signal numérisé est d’autant plus proche du signal analogique que la fréquence d’échantillonnage est grande, c’est-à-dire que la période d’échantillonnage Te est plus faible

2 La quantification:

Un signal numérique ne peut prendre que certaines valeurs : c’est la quantification.

Elle s’exprime en bits. Cette quantification est assurée par un convertisseur (CAN). Chaque valeur est arrondie à la valeur permise la plus proche par défaut. On appelle alors résolution, ou pas, ou quantum, l’écart (constant) entre deux valeurs permises successives.

Exemple: Avec un convertisseur analogique numérique 8 bits, on peut donc quantifier 28 = 256 valeurs. Plus la quantification est grande (nombre de bits du convertisseur important), plus l’amplitude du signal numérique sera proche de celle du signal analogique

qson

Le nombre d’octets qui vont être nécessaires pour numériser le signal sur un support de stockage (disque dur, clé USB, DVD,…​) n’est pas illimités, ce qui explique les quantifications choisies. De plus, en ce qui concerne la radio numérique, il faut du temps pour écrire toutes ces données. Le "flux" n’est pas aussi illimitée.

Le calibre d’un convertisseur

On appelle calibre l’intervalle des valeurs mesurables des tensions analogiques à numériser (par exemple ± 5 V).

plage d’un convertisseur

On appelle plage d’un convertisseur, la largeur de l’intervalle entre la plus petite et la plus grande valeur du calibre. (pour un calibre de ± 5 V, la plage est alors de 10 V).

Le pas p d’un convertisseur de n bits et de plage donnée, est alors défini par :

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

Exemple : Le convertisseur (CAN) d’une carte d’acquisition possède les caractéristiques suivantes :calibre ± 4,5 V sur 12 bits. Déterminer le pas du convertisseur.

Correction.

La plage est donc de 9 V. Le pas est alors de :

\$ p = 9 / 2^12 = 2,2.10^-3V=2.2mV\$

Voici un exemple de quantification. On constate que la fréquence d’échantillonage et le pas ou résolution sont insuffisant pour reproduire fidèlement le signal analogique.

quantification
3 Le codage.

On appelle codage la transformation des différentes valeurs quantifiées en langage binaire.

Avec les deux opérations précédentes nous avons obtenu N échantillons de n bits par seconde.

Exemple : Le nombre N d’octets nécessaires pour "décrire" numériquement une minute de son est :

\$ N = f. q/8 . 60 . n\$
  • f: fréquence échantillonnage en Hz ou nombre d’échantillon par seconde.

  • q : quantification en bits du convertisseur.

  • n : nombre de voies (si le son est stéréo, n = 2; en mono : n = 1)

  • La division par 8 permet de ramener le résultat en octet.

    Exercice

    Déterminer le nombre d’octet nécessaires pour une minute d’en CD audio (44,1 kHz et 16 bits, stéréo).

Correction
\$ N = 44100 . 16 / 8 .60 .2 = 10584000 octets\$
\$ N = 10584000 / 1024 = 10 335kio = 10 335 / 1024 = 10.9 Mio\$

9.2.1. kio et ko ou Mio et Mo c’est pareil?

Non pas du tout !. En langage numérique nous travaillons en base 2, nous devrions toujours exprimer les résultats en kio ou Mio.

Cette distinction n’est malheureusement pas appliqué par le grand public ou les fabricants : on parle ainsi kilooctet à la place de kibioctet.

Cela crée des confusions : un disque de 100 gigaoctets à la même capacité qu’un disque de 93,13 gibioctets.

Voici un tableau pour s’y retrouver.

tableau2

9.3. Exercices.

Le signal analogique ci-dessous, de fréquence de 1 kHz ,est numérisé avec un CAN 4 bits.

exoQuant

Cocher la ou les bonnes réponses.

  1. Calculer la période d’échantillonnage..
    1. 8ms
    2. 4ms
    3. 1ms
    4. 16ms


  2. En déduire la fréquence d’échantillonnage..
    1. 125Hz
    2. 1KHz
    3. 0.25Khz
    4. 62.5Hz


  3. Déterminer la valeur du pas p en volts..
    1. 0.125V
    2. 0.9V
    3. 0.25V
    4. 0.5V


9.4. 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.

can

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.

modele
\$ 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.5. Retour à l’arduino.

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

    potentiometre schema
    potentiometre montage
  2. 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.

1 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.6. QCM.


Cocher la ou les bonnes réponses.

  1. Un signal analogique est un signal...
    1. Continu
    2. Discret
    3. Discontinu
    4. sans logique


  2. Codec signifie
    1. codeur/décodeur
    2. correction/détection
    3. codage décimal


    4. La fibre optique transmet...
      1. les sons
      2. les ondes électromagnétiques
      3. les ultra sons
      4. toutes les ondes ci-dessus


    5. La période représente
      1. un nombre de cycles par seconde
      2. un temps
      3. une fréquence
      4. les irrégularités d’un signal


    6. Pour numériser un signal, on a besoin
      1. d’une tension électrique
      2. de grandeurs discrètes
      3. d’une base de temps périodique


    7. Lors de la numérisation d’un signal analogique, il y a perte d’information.
      1. c’est faux
      2. c’est vrai
      3. un signal analogique n’a pas besoin d’être numérisé


    8. La numérisation d’un signal nécessite...
      1. 2 étapes
      2. 3 étapes
      3. 4 étapes
      4. 1 étape est suffisante


    9. Le byte est...
      1. un ensemble de 10 bits
      2. un signal numérique
      3. un octet
      4. aucune des réponses ci-dessus


    10. CAN signifie
      1. Correcteur Analogique Numérique
      2. Convertisseur Analogique Numérique
      3. Correction Avant Numérisation


    11. Quelle étape ne fait pas partie du procédé de numérisation
      1. le codage
      2. le chiffrement
      3. la quantification


    12. Si la fréquence maximale audible par l’Homme est de 20 kHz il faut échantillonner au moins à..
      1. 20 kHz
      2. 40 kHz
      3. 200 kHz
      4. 400 kHz


    13. Pour une fréquence d’échantillonnage élevée, il faut une période d’échantillonnage faible.
      1. vrai
      2. faux
      3. il n’y a aucune relation entre fréquence et période d’échantillonnage


    14. Plus le pas du convertisseur est faible, plus le nombre de mesures à coder seront importants.
      1. c’est faux
      2. le pas du convertisseur n’intervient pas sur le nombre de mesures à coder
      3. c’est vrai


    15. Avec un CAN de 4 bits, on peut coder...
      1. 4 valeurs différentes
      2. 16 valeurs différentes
      3. 32 valeurs différentes
      4. 255 valeurs différentes


    16. Le quantum représente...
      1. la plage du convertisseur
      2. le calibre du convertisseur
      3. la résolution du convertisseur


9.7. Applications.

9.7.1. Acquisition de la température.

On souhaite faire une acquisition de température dans une salle de classe.

Dans cette salle, la température ne dépasse jamais les 45°C et ne passe jamais en dessous de 0°C.

La solution matérielle choisie est la suivante :

  • Capteur de température : LM35

  • Convertisseur analogique/numérique : CAN 10bits tolérant une plage d’entrée comprise entre 0V et 3.3V.

lm35

Cocher la ou les bonnes réponses.

  1. A l’aide de la documentation, donner l’étendue de mesure du capteur LM35. Justifier le choix de ce capteur. LM35
    1. −55°C to +150°̊C
    2. 0°C to +150°̊C
    3. −5°C to +100°C


  2. A l’aide de la documentation et de la figure suivante, relever la sensibilité du capteur LM35. ex1
    1. + 10.0 mV/°C
    2. + 1.0 mV/°CC
    3. + 20.0 mV/°C


    4. Donner les valeurs extrêmes prises par la tension Vout.
      1. 0°C * 10mV/°C = 0V à 45°C * 10mV/°C = 0.45V
      2. 0°C * 1mV/°C = 0V à 45°C * 1mV/°C = 0.045V
      3. 0°C * 20mV/°C = 0V à 45°C * 20mV/°C = 0.9V


    5. Ce capteur a-t-il un fonctionnement linéaire ?
      1. Vrai
      2. Faux


    6. Indiquer les valeurs décimales extrêmes que peut prendre le mot binaire N pour le convertisseur 10bits.
      1. N min =(0) N max = 512
      2. N min =(0) N max = 1024
      3. N min =(0) N max = 1023


    7. Calculer quantum q (pas de quantification) du convertisseur analogique / numérique.
      1. q = 12.94mV
      2. q = 3,22mV
      3. q = 4.88mV


    8. Donner les valeurs décimales prises par le mot N sur 10bits issu du convertisseur analogique / numérique pour les températures min et max de la salle de classe.
      1. Nmin=0 et Nmax=139
      2. Nmin=0 et Nmax=1039
      3. Nmin=0 et Nmax=1023


    9. Donner les valeurs binaires prises par le mot N sur 10bits issu du convertisseur analogique / numérique pour les températures min et max de la salle de classe.
      1. Nmin=0 et Nmax=1111111111
      2. Nmin=0 et Nmax=11111111
      3. Nmin=0 et Nmax=0010001011


9.7.2. Conversion d’un signal.

exocan
  1. Sur combien de bits travaille ce convertisseur A/N (amplitude) ?

  2. Combien de valeurs différentes sont-elles possibles (amplitude) ?

  3. Déterminez la période d’échantillonnage Te utilisée par ce convertisseur.

  4. Calculez la fréquence d’échantillonnage.

  5. Sachant que les valeurs max et min du signal analogique sont 2V et -2V, calculez le pas de ce convertisseur

  6. Pour mémoriser le signal numérique correspondant à ces 4ms, combien de bits de données va-t-on avoir?

  7. Si le signal total dure maintenant 5 minutes, combien de bits de données seront nécessaires pour mémoriser numériquement le signal?

  8. Sachant qu’un kilo octet vaut 1024 octet (et oui 1ko n’est pas 1000 octets. Ceci est malheureusement une mauvaise habitude très répandue du milieu informatique et contraire au système international), donnez le résultat précédent en ko (kilo-octet).

9.7.3. Luxmétre d’une station domotique.

Un module domotique, relié à un serveur central par un module de communication XBee, est constitué d’un détecteur de luminosité linéaire 0-400 lux.

Le microcontrôleur possède un CAN 10 bits, 8kHz-5V qui lui permet de lire la tension analogique 0-4 V du luxmètre.

  1. calculer la période d’échantillonnage en ms.

  2. calculer le quantum du CAN en mV.

  3. déterminer la valeur de sortie du CAN en décimal et en binaire pour une tension d’entrée de 2,8 V.

  4. déterminer la sensibilité du capteur de luminosité.

  5. calculer la quantité minimale de flux lumineux détectable par le CAN (résolution).

9.8. 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.

10. Webographie