Cours:ArduinoSimulationUno : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
Ligne 1 : Ligne 1 :
 
[[Cours:TPs_1103|{{Rouge|<big>'''Retour à la liste des Tps'''</big>}}]]
 
[[Cours:TPs_1103|{{Rouge|<big>'''Retour à la liste des Tps'''</big>}}]]
 +
 
[[Cours:ArduinoSimulationCorrection|{{Vert|<big>'''Éléments de correction'''</big>}}]]
 
[[Cours:ArduinoSimulationCorrection|{{Vert|<big>'''Éléments de correction'''</big>}}]]
 +
 +
 +
Il conviendra si besoin de reprendre le TP précédent !
 +
  
 
Nous allons explorer dans ce TP un logiciel en ligne de simulation sur le site https://circuits.io/
 
Nous allons explorer dans ce TP un logiciel en ligne de simulation sur le site https://circuits.io/
Ligne 6 : Ligne 11 :
 
={{Rouge|Prise en main}}=
 
={{Rouge|Prise en main}}=
  
 +
=={{Bleu|Branchement}}==
 +
 +
On souhaite commander 2 leds (rouge et verte), et utiliser un bouton poussoir pour interagir avec le système.
 +
 +
Le choix des broches pour les leds est laissé libre, le bouton sera connecté sur une interruption au choix :
 +
*broche arduino 2 : interruption 0
 +
*broche arduino 3 : interruption 1
 +
 +
{{Question|Ajouter et connecter les composants nécessaires, et si besoin donner leur une valeur adaptée.}}
 +
 +
=={{Bleu|Associons leds et bouton}}==
 +
 +
On souhaite avoir un système dont le comportement est le suivant :
 +
*si bouton appuyé alors :
 +
**led verte allumée
 +
** led rouge éteinte
 +
*sinon
 +
**led verte éteinte
 +
** led rouge allumée
 +
 +
{{Question|Écrire un programme répondant à ce cahier des charges}}
  
 +
=={{Bleu|Changement d'état}}==
  
 +
Le système doit maintenant changer d'état à l'appui sur le bouton :
 +
*à chaque appui la led rouge change d'état
 +
*la led verte change d'état tous les 2 appuis
  
−
={{Rouge|Prise en main}}=
+
{{Question|Codez !}}
 +
 
 +
={{Rouge|Afficheur 7 segments}}=
 +
 
 +
=={{Bleu|Branchement}}==
 +
 
 +
Nous relions maintenant un afficheur 7 segments à la carte arduino.
 +
 
 +
Remarquons que l'afficheur ne peut pas être connecté directement sur la platine d'essais, il faut le relier par des fils volants.
 +
 
 +
Nous n'utiliserons pas le point (DP). Les segments seront connectés au choix sur les broches 0 à 2  et  4 à 7 (nous n'utilisons pas la broche 3 qui servira pour un bouton poussoir).
  
 +
{{Question|Faire le câblage}}
  
−
[[Cours:Shieldinfo|La carte utilisée pour les Tps]] dispose de 2 afficheurs [http://fr.wikipedia.org/wiki/Afficheur_7_segments 7 segments].
+
=={{Bleu|Premier affichage}}==
  
−
={{Bleu|Ex1: Un premier caractère}}=
+
{{Question|En utilisant les fonctions pinMode et digitalWrite, représentez le chiffre 2 sur l'afficheur}}
  
−
{{Todo|Commencez par lire [[Cours:Shieldinfo#Afficheurs_7_segments|la documentation]] et '''exécutez le programme donné en exemple'''.}}
+
{{Question|Modifiez votre programme pour représentez le chiffre 3}}
  
−
Ce programme très simple ne permet pas de choisir l'état des segments individuellement.
+
{{Question|Puis affichez successivement 2 puis 3}}
  
−
Nous allons modifier le programme afin d'afficher la lettre d : [[Fichier:7-segment bcdeg.svg|50px]]
+
{{Vert|'''... ça devient vite pénible !!!'''}}
  
−
L'état des segments est donné dans le tableau suivant :
+
=={{Bleu|tableau et PORT}}==
−
{| class="wikitable"
 
−
|-
 
−
! sgt
 
−
||  pt ||  g ||  f ||  e ||  d ||  c ||  b ||  a
 
−
|-
 
−
! Etat
 
−
||[[Fichier:Lede.png]]||[[Fichier:Leda.png]]||[[Fichier:Lede.png]]||[[Fichier:Leda.png]]||[[Fichier:Leda.png]]||[[Fichier:Leda.png]]||[[Fichier:Leda.png]]||[[Fichier:Lede.png]]
 
−
|-
 
−
! Val
 
−
||0||1||0||1||1||1||1||0
 
−
|}
 
−
Afficher une valeur se résume à commander l'état de 8 bits, et donc une variable V de type [http://arduino.cc/en/Reference/UnsignedChar unsigned char] de valeur V=B01011110 permet de mémoriser cette valeur.
 
  
−
'''Exemple 1 :''' Nous allons commencer par un programme qui fait clignoter toutes les LEDs de l'afficheur :
+
==={{Vert|Notion de port}}===
−
<source lang=C>
 
  
−
const char pinMux = 4;
+
[[Fichier:ArduinoPinout.png|right|400px]]
−
const char pinAff[8]={13,12,6,7,8,10,9,11};
+
En observant attentivement la figure ci-contre, on constate que les pattes utilisées pour commander les leds n'ont pas été choisies au hasard.
−
void setup(){
 
−
    char i;
 
−
// Déclaration des 8 sorties des afficheurs
 
−
    for (i=0;i<8;i++) pinMode(pinAff[i],OUTPUT);
 
−
// + sortie de multiplexage (choix de l'afficheur)
 
−
    pinMode(pinMux,OUTPUT);
 
−
}
 
−
void loop(){
 
−
    char i,c; // Les segments s'allument
 
−
    for (i=0;i<8;i++) digitalWrite(pinAff[i],HIGH);
 
−
    delay(500);
 
−
    for (i=0;i<8;i++) digitalWrite(pinAff[i],LOW);
 
−
    delay(500);
 
−
}
 
−
</source>
 
−
'''Exemple 2''' : Comprendre le programme suivant pour un affichage de la lettre d.
 
−
<source lang=c>
 
−
const char pinMux = 4;
 
−
const char pinAff[8]={13,12,6,7,8,10,9,11};
 
−
const char masques[8]={1,2,4,8,16,32,64,128};                      // Liste des masques pour obtenir l'état d'un seul segment
 
  
−
const unsigned char val = B01011110;
+
En effet, nous utilisons les pattes 0 à 7, qui correspondent pour le µcontrôleur au PORTB (PD0, PD1, PD2, ...).
  
−
void affiche7sgt(unsigned char v)
+
{{Info|Ainsi, il devient possible de modifier l'état de toutes ces sorties/leds, en une seule instruction :}}
−
{
 
−
    char i,s;
 
−
    unsigned char c;
 
−
// boucle d'affichage :
 
−
    for (i=0;i<8;i++)
 
−
    {
 
−
          // delay(300);  // A ajouter pour obtenir un "ralenti"
 
−
          c = v & masques[i];  // c dépend de val,masques et du segment qui nous intéresse (donc i)
 
−
          if (c == masques[i] ) digitalWrite(pinAff[i],1);        // Modifie successivement l'état des segments a (ou patte 13)
 
−
                else digitalWrite(pinAff[i],0);          // puis b (ou patte 12) ... selon la valeur de c
 
−
    }
 
−
}
 
  
 +
<source lang=c>
 
void setup()
 
void setup()
 
{
 
{
−
    char i;
+
  // déclarer toutes les pattes en sortie :
  
−
    for (i=0;i<8;i++) pinMode(pinAff[i],OUTPUT);    // Déclaration des 8 sorties des afficheurs
 
−
    pinMode(pinMux,OUTPUT);                        // + sortie de multiplexage (choix de l'afficheur)
 
−
    digitalWrite(pinMux,1);                        // sur l'afficheur 1
 
 
}
 
}
  
 
void loop()
 
void loop()
 
{
 
{
−
   affiche7sgt(val);
+
   //mettre toutes les sorties à '1'
 +
  PORTB = 0b11110111;  // nous n'utilisons pas PD3, la broche 3
 +
  delay(200);
 +
  //mettre toutes les sorties à '0'
 +
  PORTB = 0b00000000;  // ou PORTB = 0x00; ou encore PORTB = 0;
 +
  delay(200);
 
}
 
}
 
</source>
 
</source>
  
−
{{Aide|Pourquoi un "ET LOGIQUE" & ???}}
+
==={{Vert|Utilisation}}===
  
 +
{{Question|Reprenez la question précédente, c'est à dire afficher 2 puis 3}}
  
 +
{{Question|Puis complétez pour afficher en boucle tous les chiffres}}
  
 +
==={{Vert|Tableau}}===
  
−
Les 8 bits de la variable val correspondent à l'état de chacun des segments.
+
Simplifions encore en utilisant un tableau dont le principe est donné si dessous :
  
−
Pour obtenir l'état du segment c, correspondant au bit b2, nous devons "masquer" les autres bits à l'aide de [http://arduino.cc/en/Reference/BitwiseAnd l'opérateur & (et bit à bit)] :
+
<source lang=c>
  
−
{| class="wikitable"
+
// déclaration d'un tableau de 3 cases
−
|-
+
// avec des valeurs initiales dans chaque case
−
! Val
+
unsigned char tableau[3] = {0b00000000,0b11001100,0b11110000};
−
||0||1||0||1||1||{{rouge|1}}||1||0
 
−
|-colspan="9"
 
−
|
 
−
|-
 
−
!&
 
−
||{{Bleu|0}}||{{Bleu|0}}||{{Bleu|0}}||{{Bleu|0}}||{{Bleu|0}}||{{Rouge|1}}||{{Bleu|0}}||{{Bleu|0}}
 
−
|-
 
−
!=
 
−
||0||0||0||0||0||{{rouge|1}}||0||0
 
−
|}
 
  
−
Après masquage le résultat est soit nul soit strictement positif, selon la valeur du bit b2. Il suffit d'adapter pour compléter les autres valeurs du tableau masques, et de compléter l'affectation de c avec l'opérateur &.
 
  
−
Cet exemple explique la valeur 4<sub>(10)</sub>=00000100<sub>(2)</sub> ([http://arduino.cc/en/Reference/IntegerConstants ou encore B00000100 ou bien 0x04]) indiquée comme valeur de masques[2] dans le programme précédent.
+
void loop()
 +
{
 +
  // pour modifier une case :
 +
  tableau[0] = 0b01010101; // modification de la première case
 +
 
 +
  // utilisation d'une case :
 +
  x = tableau[2]; // dernière case du tableau de dimension 3
  
−
{{finAide}}
+
  // parcourir le tableau
−
 
+
  for (i=0;i<3;i++)
−
={{Bleu|Ex2: 0,1,2 ... 9 !}}=
+
  {
−
 
+
      .... = tableau[i] ....;
−
Maintenant que nous avons un code plus facilement flexible, attaquons nous aux chiffres.
+
  }
−
 
+
}
−
Nous avons 10 symboles différents, donc nous utiliserons un tableau de type [http://arduino.cc/en/Reference/UnsignedChar unsigned char] de dimension 10 qui remplacera la variable val de l'exemple 2 :
 
−
<source lang=c>
 
−
const unsigned char val[10]={B00111111,..,...};    // Vous avez ici l'état des segments pour afficher le chiffre 0.
 
 
</source>
 
</source>
  
−
{{Question|Modifiez le programme précédent en utilisant un tableau, et affichez en boucle les chiffres de 0 à 9.}}
+
{{Question|Reprendre la question précédente en utilisant un tableau}}
  
−
={{Bleu|Ex3: Toujours plus}}=
 
  
−
Vous allez maintenant faire un compteur de 0 à 99.
+
={{Rouge|Terminé ? ... ajoutons l'afficheur des dizaines !}}=
  
−
Pour ce faire vous allez commencer par modifier le compteur de 0 à 9, pour que la valeur s'affiche "simultanément" sur les 2 afficheurs, soit 00 puis 11, 22, 33 ... 99. Vous conserverez la même vitesse de comptage.
+
=={{Bleu|Câblage}}=
−
 
 
−
{{Question|Faire la modification demandée en vous inspirant [[Cours:Shieldinfo#Afficheurs_7_segments|du programme donné en exemple]].}}
 
−
 
 
−
'''INDICATION''' : Réaliser d'abord un sous-programme
 
−
<source lang=C>
 
−
void affiche2Digits(char dizaine,char unite) {
 
−
  char c;
 
−
  for (c=0;c<20;c++)    {
 
−
    digitalWrite(pinMux,1);  // sur l'afficheur unité
 
−
  // appeler affiche7sgt
 
−
    delay(10);
 
−
    digitalWrite(pinMux,0);  // puis sur l'afficheur dizaine
 
−
  // appeler affiche7sgt
 
−
    delay(10);    }
 
−
}
 
−
</source>
 
  
 +
Nous allons réaliser un multiplexage des afficheurs, c'est à dire que les segments des 2 afficheurs sont reliés ensemble
  
−
Le comptage de 0 à 99 devient alors une formalité, on vous demande 3 méthodes.
+
..... du coup la valeur est la même sur les 2 afficheurs !
  
−
{{Question|1. Utilisez 2 boucles [http://arduino.cc/en/Reference/For for] imbriquées avec 2 variables u (unité) et d (dizaine !).}}
+
Il faut alors modifier le schéma en reliant les anodes communes non plus à l'alimentation directement, mais au µcontrôleur.
  
−
{{Question|2. Utilisez 1 seule boucle [http://arduino.cc/en/Reference/For for] de 0 à 99 et les opérateurs modulo et division.}}
+
{{Utiliser les broches 8 et 9 pour connecter les anodes communes.}}
  
−
{{Question|3. Sans utiliser de [http://arduino.cc/en/Reference/For for], en incrémentant une variable globale cpt:}}
+
=={{Bleu|Premier programme}}==
  
−
<source lang=c>
+
{{Question|Écrire un programme qui affiche la valeur 2 sur l'afficheur des unités puis des dizaines.}}
−
unsigned char cpt=0;
 
−
...
 
  
−
void affiche7sgt(unsigned char v)
+
'''Remarque :''' si cela est fait assez rapidement (<10ms), on aura l'impression que les 2 afficheurs sont allumés simultanément !
−
{
 
−
  ...
 
−
}
 
  
−
void setup()
+
=={{Bleu|Compteur modulo 99}}==
−
{
 
−
  ...
 
−
}
 
  
−
void loop()
+
{{Question|Réalisez alors un compteur modulo 99}}
−
{
 
−
  ...
 
−
  cpt++;
 
−
  ...
 
−
}
 
−
</source>
 

Version du 6 octobre 2016 à 15:32

Retour à la liste des Tps

Éléments de correction


Il conviendra si besoin de reprendre le TP précédent !


Nous allons explorer dans ce TP un logiciel en ligne de simulation sur le site https://circuits.io/

Prise en main

Branchement

On souhaite commander 2 leds (rouge et verte), et utiliser un bouton poussoir pour interagir avec le système.

Le choix des broches pour les leds est laissé libre, le bouton sera connecté sur une interruption au choix :

  • broche arduino 2 : interruption 0
  • broche arduino 3 : interruption 1

Question.jpg Ajouter et connecter les composants nécessaires, et si besoin donner leur une valeur adaptée.

Associons leds et bouton

On souhaite avoir un système dont le comportement est le suivant :

  • si bouton appuyé alors :
    • led verte allumée
    • led rouge éteinte
  • sinon
    • led verte éteinte
    • led rouge allumée

Question.jpg Écrire un programme répondant à ce cahier des charges

Changement d'état

Le système doit maintenant changer d'état à l'appui sur le bouton :

  • à chaque appui la led rouge change d'état
  • la led verte change d'état tous les 2 appuis

Question.jpg Codez !

Afficheur 7 segments

Branchement

Nous relions maintenant un afficheur 7 segments à la carte arduino.

Remarquons que l'afficheur ne peut pas être connecté directement sur la platine d'essais, il faut le relier par des fils volants.

Nous n'utiliserons pas le point (DP). Les segments seront connectés au choix sur les broches 0 à 2 et 4 à 7 (nous n'utilisons pas la broche 3 qui servira pour un bouton poussoir).

Question.jpg Faire le câblage

Premier affichage

Question.jpg En utilisant les fonctions pinMode et digitalWrite, représentez le chiffre 2 sur l'afficheur

Question.jpg Modifiez votre programme pour représentez le chiffre 3

Question.jpg Puis affichez successivement 2 puis 3

... ça devient vite pénible !!!

tableau et PORT

Notion de port

ArduinoPinout.png

En observant attentivement la figure ci-contre, on constate que les pattes utilisées pour commander les leds n'ont pas été choisies au hasard.

En effet, nous utilisons les pattes 0 à 7, qui correspondent pour le µcontrôleur au PORTB (PD0, PD1, PD2, ...).

Info.jpg Ainsi, il devient possible de modifier l'état de toutes ces sorties/leds, en une seule instruction : 

void setup()
{
   // déclarer toutes les pattes en sortie :

}

void loop()
{
   //mettre toutes les sorties à '1'
   PORTB = 0b11110111;  // nous n'utilisons pas PD3, la broche 3
   delay(200);
   //mettre toutes les sorties à '0'
   PORTB = 0b00000000;  // ou PORTB = 0x00; ou encore PORTB = 0;
   delay(200);
}

Utilisation

Question.jpg Reprenez la question précédente, c'est à dire afficher 2 puis 3

Question.jpg Puis complétez pour afficher en boucle tous les chiffres

Tableau

Simplifions encore en utilisant un tableau dont le principe est donné si dessous : 

// déclaration d'un tableau de 3 cases
// avec des valeurs initiales dans chaque case
unsigned char tableau[3] = {0b00000000,0b11001100,0b11110000};


void loop()
{
   // pour modifier une case :
   tableau[0] = 0b01010101; // modification de la première case
   
   // utilisation d'une case :
   x = tableau[2]; // dernière case du tableau de dimension 3

   // parcourir le tableau
   for (i=0;i<3;i++)
   {
      .... = tableau[i] ....;
   }
}

Question.jpg Reprendre la question précédente en utilisant un tableau


Terminé ? ... ajoutons l'afficheur des dizaines !

=Câblage

Nous allons réaliser un multiplexage des afficheurs, c'est à dire que les segments des 2 afficheurs sont reliés ensemble

..... du coup la valeur est la même sur les 2 afficheurs !

Il faut alors modifier le schéma en reliant les anodes communes non plus à l'alimentation directement, mais au µcontrôleur.

Modèle:Utiliser les broches 8 et 9 pour connecter les anodes communes.

Premier programme

Question.jpg Écrire un programme qui affiche la valeur 2 sur l'afficheur des unités puis des dizaines.

Remarque : si cela est fait assez rapidement (<10ms), on aura l'impression que les 2 afficheurs sont allumés simultanément !

Compteur modulo 99

Question.jpg Réalisez alors un compteur modulo 99

Récupérée de « http://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:ArduinoSimulationUno&oldid=8417 »