Cours:ArduinoSimulationUno : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
 
m (Bjacquot a déplacé la page Cours:ArduinoSimulation vers Cours:ArduinoSimulationUno sans laisser de redirection)
 
(18 révisions intermédiaires par 2 utilisateurs non affichées)
Ligne 4 : Ligne 4 :
  
  
−
[[Cours:Shieldinfo|La carte utilisée pour les Tps]] dispose de 2 afficheurs [http://fr.wikipedia.org/wiki/Afficheur_7_segments 7 segments].
+
Il conviendra si besoin de reprendre le TP précédent !
  
−
={{Bleu|Ex1: Un premier caractère}}=
+
Nous utiliserons une carte arduino nano ainsi que divers composants que nous relierons ensemble sur une plaque à essais.
  
−
{{Todo|Commencez par lire [[Cours:Shieldinfo#Afficheurs_7_segments|la documentation]] et '''exécutez le programme donné en exemple'''.}}
 
  
−
Ce programme très simple ne permet pas de choisir l'état des segments individuellement.
+
=Prise en main=
  
−
Nous allons modifier le programme afin d'afficher la lettre d : [[Fichier:7-segment bcdeg.svg|50px]]
+
==Branchement==
 +
[[Fichier:ArduinoNanoPinout.png|right|400px]]
  
−
L'état des segments est donné dans le tableau suivant :
+
On souhaite commander 2 leds (rouge et verte), et utiliser un bouton poussoir pour interagir avec le système.
−
{| 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 :
+
Le choix des broches pour les leds est laissé libre, le bouton sera connecté sur une interruption au choix :
−
<source lang=C>
+
*broche arduino 2 (indiqué D2 sur la carte) : interruption 0
 +
*broche arduino 3 (indiqué D3 sur la carte) : interruption 1
  
−
const char pinMux = 4;
+
{{Question|Ajouter et connecter les composants nécessaires :}}
−
const char pinAff[8]={13,12,6,7,8,10,9,11};
+
*on utilisera une résistance de tirage de 10kΩ pour le bp
−
void setup(){
+
*on utilisera des résistances de 330Ω pour les leds
−
    char i;
+
 
−
// Déclaration des 8 sorties des afficheurs
+
==Associons leds et bouton==
−
    for (i=0;i<8;i++) pinMode(pinAff[i],OUTPUT);
+
 
−
// + sortie de multiplexage (choix de l'afficheur)
+
On souhaite avoir un système dont le comportement est le suivant :
−
    pinMode(pinMux,OUTPUT);
+
*si bouton appuyé alors :
−
}
+
**led verte allumée
−
void loop(){
+
** led rouge éteinte
−
    char i,c; // Les segments s'allument
+
*sinon
−
    for (i=0;i<8;i++) digitalWrite(pinAff[i],HIGH);
+
**led verte éteinte
−
    delay(500);
+
** led rouge allumée
−
    for (i=0;i<8;i++) digitalWrite(pinAff[i],LOW);
+
 
−
    delay(500);
+
{{Question|Écrire un programme répondant à ce cahier des charges}}
−
}
+
 
−
</source>
+
==Changement d'état==
−
'''Exemple 2''' : Comprendre le programme suivant pour un affichage de la lettre d.
+
 
−
<source lang=c>
+
Le système doit maintenant changer d'état à l'appui sur le bouton :
−
const char pinMux = 4;
+
*à chaque appui la led rouge change d'état
−
const char pinAff[8]={13,12,6,7,8,10,9,11};
+
*la led verte change d'état tous les 2 appuis
−
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;
+
{{Question|Codez !}}
  
−
void affiche7sgt(unsigned char v)
+
===Indications===
−
{
+
La fonction attachInterrupt(pin,function,mode) fait tout ce qu'il faut.
−
    char i,s;
+
* pin 0 ou 1 selon la pin 2 ou 3 ( 3 ou 2 selon la carte)  
−
    unsigned char c;
+
* function le nom de la fonction appelée
−
// boucle d'affichage :
+
* mode 0,1,2,3 ou LOW, CHANGE, RISING, FALLING
−
    for (i=0;i<8;i++)
+
<u>Exemple</u>: un capteur de Hall tout-ou-rien est utilisé comme fin de course sur la pin 2. On mettra dans le setup() attachInterrupt(0,StopMoteur(),3); La fonction StopMoteur() sera appelée toutes les fois quand le signal capteur passe de 1 à 0.
−
    {
 
−
          // 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
 
−
    }
 
−
}
 
  
−
void setup()
+
={{Rouge|Afficheur 7 segments}}=
−
{
 
−
    char i;
 
  
−
    for (i=0;i<8;i++) pinMode(pinAff[i],OUTPUT);    // Déclaration des 8 sorties des afficheurs
+
=={{Bleu|Branchement}}==
−
    pinMode(pinMux,OUTPUT);                        // + sortie de multiplexage (choix de l'afficheur)
 
−
    digitalWrite(pinMux,1);                        // sur l'afficheur 1
 
−
}
 
  
−
void loop()
 
−
{
 
−
  affiche7sgt(val);
 
−
}
 
−
</source>
 
  
−
{{Aide|Pourquoi un "ET LOGIQUE" & ???}}
+
[[Fichier:ArduinoUno7sgts.jpg|right|400px]]
  
 +
[[Fichier:Afficheur7sgtsCathodesCommunes.png|right|400px]]
  
 +
Nous relions maintenant un afficheur 7 segments cathodes communes à la carte arduino.
  
 +
On veillera à mettre une résistance de 1kΩ en série pour chaque segment.
  
−
Les 8 bits de la variable val correspondent à l'état de chacun des segments.
+
Nous n'utiliserons pas le point (DP). Les segments seront connectés au choix sur les broches arduino 0 à 2  et  4 à 7 (nous n'utilisons pas la broche arduino n°3 qui servira pour un bouton poussoir).
  
−
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)] :
+
{{Question|Faire le câblage}}
  
−
{| class="wikitable"
+
=={{Bleu|Premier affichage}}==
−
|-
 
−
! Val
 
−
||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 &.
+
{{Question|En utilisant les fonctions pinMode et digitalWrite, représentez le chiffre 2 sur l'afficheur}}
  
−
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.
+
{{Question|Modifiez votre programme pour représentez le chiffre 3}}
  
−
{{finAide}}
+
{{Question|Puis affichez successivement 2 puis 3}}
  
−
={{Bleu|Ex2: 0,1,2 ... 9 !}}=
+
{{Vert|'''... ça devient vite pénible !!!'''}}
  
−
Maintenant que nous avons un code plus facilement flexible, attaquons nous aux chiffres.
+
=={{Bleu|tableau et PORT}}==
  
−
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 :
+
==={{Vert|Notion de port}}===
−
<source lang=c>
 
−
const unsigned char val[10]={B00111111,..,...};    // Vous avez ici l'état des segments pour afficher le chiffre 0.
 
−
</source>
 
  
−
{{Question|Modifiez le programme précédent en utilisant un tableau, et affichez en boucle les chiffres de 0 à 9.}}
+
[[Fichier:ArduinoNanoPinout.png ‎|right|400px]]
 +
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.
  
−
={{Bleu|Ex3: Toujours plus}}=
+
En effet, nous utilisons les pattes 0 à 7, qui correspondent pour le µcontrôleur au PORTD (PD0, PD1, PD2, ...).
  
−
Vous allez maintenant faire un compteur de 0 à 99.
+
{{Info|Ainsi, il devient possible de modifier l'état de toutes ces sorties/leds, en une seule instruction :}}
  
−
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.
+
<source lang=c>
 +
void setup()
 +
{
 +
  // déclarer toutes les pattes en sortie :
  
−
{{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
+
void loop()
−
<source lang=C>
+
{
−
void affiche2Digits(char dizaine,char unite) {
+
  //mettre toutes les sorties à '1'
−
  char c;
+
  PORTD = 0b11110111;  // nous n'utilisons pas PD3, la broche 3
−
  for (c=0;c<20;c++)    {
+
  delay(200);
−
    digitalWrite(pinMux,1);  // sur l'afficheur unité
+
  //mettre toutes les sorties à '0'
−
  // appeler affiche7sgt
+
   PORTD = 0b00000000;  // ou PORTD = 0x00; ou encore PORTD = 0;
−
    delay(10);
+
  delay(200);
−
    digitalWrite(pinMux,0);  // puis sur l'afficheur dizaine
 
−
   // appeler affiche7sgt
 
−
    delay(10);   }
 
 
}
 
}
 
</source>
 
</source>
  
 +
==={{Vert|Utilisation}}===
  
−
Le comptage de 0 à 99 devient alors une formalité, on vous demande 3 méthodes.
+
{{Question|Reprenez la question précédente, c'est à dire afficher 2 puis 3}}
  
−
{{Question|1. Utilisez 2 boucles [http://arduino.cc/en/Reference/For for] imbriquées avec 2 variables u (unité) et d (dizaine !).}}
+
{{Question|Puis complétez pour afficher en boucle tous les chiffres}}
  
−
{{Question|2. Utilisez 1 seule boucle [http://arduino.cc/en/Reference/For for] de 0 à 99 et les opérateurs modulo et division.}}
+
==={{Vert|Tableau}}===
  
−
{{Question|3. Sans utiliser de [http://arduino.cc/en/Reference/For for], en incrémentant une variable globale cpt:}}
+
Simplifions encore en utilisant un tableau dont le principe est donné si dessous :
  
 
<source lang=c>
 
<source lang=c>
−
unsigned char cpt=0;
 
−
...
 
  
−
void affiche7sgt(unsigned char v)
+
// déclaration d'un tableau de 3 cases
−
{
+
// avec des valeurs initiales dans chaque case
−
  ...
+
unsigned char tableau[3] = {0b00000000,0b11001100,0b11110000};
−
}
 
  
−
void setup()
 
−
{
 
−
  ...
 
−
}
 
  
 
void loop()
 
void loop()
 
{
 
{
−
   ...
+
   // pour modifier une case :
−
   cpt++;
+
  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] ....;
 +
  }
 
}
 
}
 
</source>
 
</source>
 +
 +
{{Question|Reprendre la question précédente en utilisant un tableau}}
 +
 +
 +
={{Rouge|Terminé ? ... ajoutons l'afficheur des dizaines !}}=
 +
 +
=={{Bleu|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 cathodes communes non plus à l'alimentation directement, mais au µcontrôleur.
 +
 +
{{Rouge|Utiliser les broches 8 et 9 pour connecter les cathodes communes.}}
 +
 +
=={{Bleu|Premier programme}}==
 +
 +
{{Question|É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 !
 +
 +
=={{Bleu|Compteur modulo 99}}==
 +
 +
{{Question|Réalisez alors un compteur modulo 99}}
 +
 +
*pour récupérer la valeur :
 +
**des unités : u = n%10;
 +
**des dizaines : d = (n/10)%10;
 +
**des centaines : c = (n/100)%10;
 +
**des mil.....
 +
*alterner rapidement (mais pas trop) entre l'affichage des unités et des dizaines
 +
*on pourra ajouter un bouton connecté sur la broche 3 (INT1) qui incrémente n à chaque appui

Version actuelle datée du 23 septembre 2021 à 13:11

Retour à la liste des Tps

Éléments de correction


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

Nous utiliserons une carte arduino nano ainsi que divers composants que nous relierons ensemble sur une plaque à essais.


Prise en main

Branchement

ArduinoNanoPinout.png

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 (indiqué D2 sur la carte) : interruption 0
  • broche arduino 3 (indiqué D3 sur la carte) : interruption 1

Question.jpg Ajouter et connecter les composants nécessaires :

  • on utilisera une résistance de tirage de 10kΩ pour le bp
  • on utilisera des résistances de 330Ω pour les leds

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 !

Indications

La fonction attachInterrupt(pin,function,mode) fait tout ce qu'il faut.

  • pin 0 ou 1 selon la pin 2 ou 3 ( 3 ou 2 selon la carte)
  • function le nom de la fonction appelée
  • mode 0,1,2,3 ou LOW, CHANGE, RISING, FALLING

Exemple: un capteur de Hall tout-ou-rien est utilisé comme fin de course sur la pin 2. On mettra dans le setup() attachInterrupt(0,StopMoteur(),3); La fonction StopMoteur() sera appelée toutes les fois quand le signal capteur passe de 1 à 0.

Afficheur 7 segments

Branchement

ArduinoUno7sgts.jpg
Afficheur7sgtsCathodesCommunes.png

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

On veillera à mettre une résistance de 1kΩ en série pour chaque segment.

Nous n'utiliserons pas le point (DP). Les segments seront connectés au choix sur les broches arduino 0 à 2 et 4 à 7 (nous n'utilisons pas la broche arduino n°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

ArduinoNanoPinout.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 PORTD (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'
   PORTD = 0b11110111;  // nous n'utilisons pas PD3, la broche 3
   delay(200);
   //mettre toutes les sorties à '0'
   PORTD = 0b00000000;  // ou PORTD = 0x00; ou encore PORTD = 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 cathodes communes non plus à l'alimentation directement, mais au µcontrôleur.

Utiliser les broches 8 et 9 pour connecter les cathodes 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

  • pour récupérer la valeur :
    • des unités : u = n%10;
    • des dizaines : d = (n/10)%10;
    • des centaines : c = (n/100)%10;
    • des mil.....
  • alterner rapidement (mais pas trop) entre l'affichage des unités et des dizaines
  • on pourra ajouter un bouton connecté sur la broche 3 (INT1) qui incrémente n à chaque appui
Récupérée de « http://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:ArduinoSimulationUno&oldid=15500 »