Cours:TPS 2103 tp3

De troyesGEII
Aller à : navigation, rechercher

Retour à la liste des Tps

Éléments de correction

ArduinoPinout.png

Vous allez développer un système de digicode architecturé autour d'un atmega328p (le µcontrôleur présent sur les cartes arduino).

Pour ce TP, nous utilisons une carte arduino sans le shieldinfo

Matériel

Nous utiliserons :

  • 1 carte arduino UNO
  • 1 plaque à essais
  • 2 leds Rouge
  • 2 leds verte
  • 4 résistances 330Ω
  • 1 clavier matriciel
  • 1 buzzer (à insérer directement sur les connecteurs arduino)
  • 5 fils M-M
  • 7 fils M-F

Informations lumineuses

Le digicode sera équipé de 2 voyants lumineux (rouge et vert).

On utilisera des résistances de 330Ω, et vous êtes libre de choisir un montage à anodes ou cathodes communes.

Todo.jpg Câbler sur une plaque à essais les leds sur les pin PC0 (Rouge) et PC1 (Verte)

Question.jpg Vérifier le fonctionnement des leds :

#include <avr/io.h>
#include <util/delay.h>

int main()
{
    // config des sorties

    while(1)
    {
        //allumer R + attendre
        
        //allumer V + attendre
        
        //eteindre V + attendre
        
        //eteindre R + attendre
        
    }
}
Bluebg.png
Aidesmall.png
À propos de cette image

Astuce


Vous pourrez vous inspirer du programme suivant permettant de faire clignoter la led "13" de la carte Arduino Uno.

#define led PB5

int main()
{
  DDRB |= 1 << led;
  while(1)
  {
  PORTB |= 1 << led;
  delay(100);
  PORTB &= ~(1 << led);
  delay(100);
  }
}

Decodage d'un clavier

Câblage

Le tableau suivant résume la disposition physique du clavier avec la position physique sur le connecteur des lignes (L1 à L4) et colonnes (C1 à C3) en vue de dessus :

B0 B1 B2 B3 D4 D5 D6
L1 L2 L3 L4 C1 C2 C3

ArduinoClavier.png

L/C C1 C2 C3
L1 1 2 3
L2 4 5 6
L3 7 8 9
L4 * 0 #

ClavierMatriciel.png

Todo.jpg Câbler sur une plaque à essais le clavier 12 touches que l'on vous donne. Les colonnes seront reliées sur le port D et les lignes sur le port B (cf indications ci dessus)

Remarque : On ne câblera aucune résistance de tirage, on utilisera les résistances internes au µcontrôleur.

Bluebg.png
Aidesmall.png
À propos de cette image

pullUp


2 étapes sont nécessaires pour activer une résistance de pullUp sur une broche :

  • Configurer la broche en entrée
    • pour une seule broche : DDRB &=~ (1<<PB1);
    • pour un groupe  : DDRB &=~ ((1<<PB1)|(1<<PB2)|(1<<PB3) ...);
  • Activer ensuite la/les résistance(s) de pullUp
    • pour une seule broche : PORTB |= (1<<PB1);
    • pour un groupe  : PORTB |= (1<<PB1)|(1<<PB2)|(1<<PB3) ...;

Principe de décodage

En utilisant un clavier matriciel, chaque touche n'est pas associé à une broche du µcontrôleur. Dans le cas présent, on passe de :

  • 12 entrées nécessaires si chaque touche était connectée directement
  • 7 broches nécessaires avec le clavier matriciel

L'intérêt évident est donc une réduction du nombre de broches nécessaires à l'utilisation du clavier.

L'inconvénient qui en résulte est la complexité relative du code pour trouver quelle touche est appuyée.

Le principe de décodage est symétrique entre lignes et colonnes. Détaillons donc le fonctionnement pour trouver sur quelle ligne une touche est appuyée :

  • On configure les broches colonnes en sortie.
  • On configure ces sorties à l'état 0
  • Les broches lignes sont en entrée
  • l'état des lignes dépend de l'appui sur un bouton :
    • si aucun bouton appuyé, les résistances de tirage donnent un état 1 sur les lignes
    • si on appui sur un bouton de la ligne1 (key 1/2/3), alors l'entrée ligne PB0 passe à l'état 0.
    • la valeur change suivant la ligne sur laquelle un bouton est appuyé
  • il suffit donc d'observer les 4 bits PB3..PB0 (que l'on note ici etat), et ainsi :
    • si etat = 1111 , pas de touche
    • si etat = 1110 , au moins une touche parmi 1/2/3
    • si etat = 1101 , au moins une touche parmi 4/5/6
    • ...


Indice de ligne

Question.jpg Ecrire et tester le programme lecture_ligne() qui renvoie le numéro de ligne sur laquelle un bouton est appuyé

  • La validation se fera en utilisant des leds connectées sur le port C :
    • On mettra 4 leds sur les broches PC3 à PC0
    • On visualisera un nombre n sur 4 bits en écrivant PORTC = n;
int8_t lecture_ligne()
{
  int8_t ch;
  DDRD ?= .... ;    // commençons par lister les sorties sur le port D
  DDRB ?= .... ;    // puis les entrées sur le port B
  PORTD?=..... ;    // on place les sortie à l'état 0
  PORTB?= .... ;    // on active les résistances de pull-up sur les entrées

  _delay_ms(1);        // un délais est nécessaire pour l'activation des pull-ups

  ch = PINB & ??; // on récupère ensuite l'état des entrées
  switch (ch)
  {
     case  : return 0; // aucune touche
     case  : return 1; // L1
     case  : return 2; // L2
     case  : return 3; // L3
     case  : return 4; // L4
     // si autre cas, deux touches ou autre
     default : return -1;
  }
}

Indice de colonne

Question.jpg De la même façon, écrire et tester la fonction lecture_colonne() qui permettra d'obtenir le numéro de colonne sur laquelle un bouton est appuyé.


Touche appuyée

Nous souhaitons maintenant écrire une fonction qui renverra une valeur tel que décrit ci dessous :

int8_t touches[4][3] = { // tableau de char à 2 dimensions
  {1,,},
  {...},
  {...},
  {,,11}
};

int8_t getTouche();
La valeur retournée sera :
  • -1 si pas de touches (ou plusieurs) appuyées
  • la valeur correspondant à la touche pour les chiffres
  • 11 pour le #
  • 10 pour l' *

Question.jpg Écrire cette fonction en vous servant bien évidemment des 2 fonctions précédentes et pourquoi pas du tableau "touches" complété.

int8_t getTouche()
{
   ....
}

Assemblons le tout

Nous allons utiliser les 2 fonctions getTouche() et setEtatLed() pour réaliser un programme de digicode.

Cahier des charges

Commençons pour définir les contraintes :

  • On appuie sur la touche ON (touche '*') => la led rouge s'allume
  • L'utilisateur doit alors saisir le code sur 4 chiffres
  • On valide le code par la touche OK (touche '#')
  • Si le code est bon la led verte s'allume pendant 10s, sinon la led rouge clignote pendant 10s

Codez !!

Nous commençons par décrire le programme grâce à l'algorigramme suivant :

  • initialiser i
  • éteindre les leds
  • si la touche apuyé est '*'
    • allumer led rouge
    • répéter
      • attendre plus de touches appuyées ( à l'aide d'un while(getTouche....); )
      • répéter
        • lire clavier => touche ( touche = getTouche(); !!! )
        • tant que touche<0
      • si touche '*'
        • réinitialiser i
      • sinon
        • sauvegarder touche dans un tableau
        • incrémenter i
      • tant que i<4
    • attendre plus de touches appuyés
    • attendre appui sur touche
    • si touche '#'
      • vérifier le code
      • si code valide
        • allumer led verte pendant 10s
      • sinon
        • faire clignoter led rouge pendant 10s


Remarque : Utiliser un tableau pour mémoriser le code, ex :

 const int8_t code[4]={1,2,3,4};

Question.jpg Écrire le programme correspondant

Améliorations

Todo.jpg Il serait intéressant de proposer une procédure de changement du code.


Todo.jpg Il est également intéressant de régler une durée maximum (4s) de saisie du code, en utilisant un timer.

Buzzer

Objectif

Nous souhaitons utiliser le buzzer afin d'avoir une information sonore sur la touche du clavier appuyée.

Pour ce faire, chaque touche sera associée à une note de musique tel qu'indiqué dans le tableau suivant :

Touche 0 1 2 3 4 5 6 7 8 9 * #
Note Do Do# Ré# Mi Fa Fa# Sol Sol# La La# Si
Fréquence (Hz) 261,63 277,18 293,66 311,13 329,63 349,23 369,99 392 415,3 440 466,16 493,88
Période (µs) 3822 3608 3405 3214 3037 2863 2703 2551 2408 2273 2145 2025


Programmons

Question.jpg Vous utiliserez le programme réalisé au tp précédent, et notamment la fonction playnote(note,duree) pour jouer la note associée à chaque appui d'une touche


Confinement 2020

Groupe S2d

Jamboard TP digicode

Clavier : lecture ligne (correction en C)

#include <avr/io.h>
#include <util/delay.h>

#define ledR PC0
#define ledV PC1

int8_t lecture_ligne()
{
  int8_t ch;
  DDRD |= (1<<PD4)|(1<<PD5)|(1<<PD6) ;// commençons par lister les sorties sur le port D
  DDRB &=~( (1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3) ) ;    // puis les entrées sur le port B
  PORTD &=~( (1<<PD4)|(1<<PD5)|(1<<PD6) ) ;    // on place les sortie à l'état 0
  PORTB |= (1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3) ;    // on active les résistances de pull-up sur les entrées

  _delay_ms(1);        // un délais est nécessaire pour l'activation des pull-ups

  ch = PINB & 0b00001111; // on récupère ensuite l'état des entrées
  switch (ch)
  {
     case  0b1111: return 0; // aucune touche
     case  0b1110: return 1; // L1
     case  0b1101: return 2; // L2
     case  0b1011: return 3; // L3
     case  0b0111: return 4; // L4
     // si autre cas, deux touches ou autre
     default : return -1;
  }
}
int main()
{
  int8_t ligne;
// setup
  DDRC |= (1<<ledR) | (1<<ledV);
// loop
  while(1)
  {
    ligne = lecture_ligne();
    switch(ligne) {
      case 0 :PORTC &=~ (1<<ledR);PORTC &=~ (1<<ledV);break;
      case 1 :PORTC |= (1<<ledR);PORTC &=~ (1<<ledV);break;
      case 2 :PORTC &=~ (1<<ledR);PORTC |= (1<<ledV);break;
      case 3 :PORTC |= (1<<ledR);PORTC |= (1<<ledV);break;
      default:PORTC &=~ (1<<ledR);PORTC &=~ (1<<ledV);break;
    }
    _delay_ms(100);
  }
}

Correction Arduino

#include <avr/io.h>
#include <util/delay.h>

#define ledR PC0
#define ledV PC1

void setup() {
  DDRC |= (1<<ledR) | (1<<ledV);
  Serial.begin(9600);
}

int8_t lecture_ligne()
{
  int8_t ch;
  DDRD |= (1<<PD4)|(1<<PD5)|(1<<PD6) ;// commençons par lister les sorties sur le port D
  DDRB &=~( (1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3) ) ;    // puis les entrées sur le port B
  PORTD &=~( (1<<PD4)|(1<<PD5)|(1<<PD6) ) ;    // on place les sortie à l'état 0
  PORTB |= (1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3) ;    // on active les résistances de pull-up sur les entrées

  _delay_ms(1);        // un délais est nécessaire pour l'activation des pull-ups

  ch = PINB & 0b00001111; // on récupère ensuite l'état des entrées
  switch (ch)
  {
     case  0b1111: return 0; // aucune touche
     case  0b1110: return 1; // L1
     case  0b1101: return 2; // L2
     case  0b1011: return 3; // L3
     case  0b0111: return 4; // L4
     // si autre cas, deux touches ou autre
     default : return -1;
  }
}

void loop() {
  int8_t ligne,colonne,codeClavier;
  ligne=lecture_ligne();
  Serial.println(ligne);
  _delay_ms(100);
}