Cours:TPS 2103 tp3

Fiche résumé

Retour à la liste des Tps

Éléments de correction

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 NANO
• 1 plaque à essais
• 8 leds pour afficher une valeur
• 2 leds verte/rouge pour le fonctionnement du digicode
• 1 résistance de 330Ω par led
• 1 clavier matriciel
• fils M-M
• fils M-F

Informations lumineuses

Câblage

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

On utilisera des résistances de 330Ω, les leds seront connectées en cathodes communes.

Câbler sur une plaque à essais les leds :

• les 2 leds pour le digicode
  • verte sur PC0
  • rouge sur PC1
• 8 leds pour afficher une valeur
  • PD0 à PD7
  • mettre les leds dans "l'ordre" des broches

Utilisation des 8 leds

Nous utiliserons dans nos programmes les types de variable dont la taille est explicitement donnée

Le débogage d'un programme est fondamental, il existe différentes façons de le faire. Ici nous nous contenterons d'utiliser des leds pour afficher des informations sur l'exécution du programme.

Principe :

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

void clignote()
{
    PORTD=0;
    for (uint8_t i=0;i<5;i++)
    {
         PORTD ^= 0xFF;
         _delay_ms(50);
    }
}

int main()
{
    // config des sorties
    DDRD = 0xFF; // les 8  broches des leds en sortie

    // qques variables
    uint8_t val1 = 0;
    int8_t val2 = -1;
    uint8_t val3 = 255;
    uint16_t val4 = 256;

    while(1)
    {
        PORTD = val1;
        _delay_ms(2000);
        clignote();
        PORTD = val2;
        _delay_ms(2000);
        clignote();
        PORTD = val3;
        _delay_ms(2000);
        clignote();
        PORTD = val4;
        _delay_ms(2000);
        for (int i=0;i<10;i++) clignote();
    }
}

Indiquer l'affichage réalisé par chacune des lignes PORTD=valx

Les nombres négatifs sont représentés pas la méthodes des compléments à deux : https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_deux ]

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 (L0 à L3) et colonnes (C0 à C2) en vue de dessus :

PC2 PC3 PC4 PC5 PB0 PB1 PB2 L0 L1 L2 L3 C0 C1 C2

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

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

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

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 ligne0 (key 1/2/3), alors l'entrée ligne PC2 passe à l'état 0.
  • la valeur change suivant la ligne sur laquelle un bouton est appuyé
• il suffit donc d'observer les 4 bits PC5..PC2 (que l'on note ici etat), et ainsi :
  • si PC5..PC2 = 1111 , pas de touche
  • si PC5..PC2 = 1110 , au moins une touche parmi 1/2/3
  • si PC5..PC2 = 1101 , au moins une touche parmi 4/5/6
  • ...

Indice de ligne

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 utilisera les 8 leds du PORTD pour afficher le résultat
  • par ex : PORTC = lecture_ligne();

int8_t lecture_ligne()
{
  int8_t etatEntrees;
  DDRB ?= .... ;    // commençons par lister les sorties sur le port B
  DDRC ?= .... ;    // puis les entrées sur le port C
  PORTB?=..... ;    // on place les sortie à l'état 0
  PORTC?= .... ;    // on active les résistances de pull-up sur les entrées

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

  etatEntrees = PINC & ??; // on récupère ensuite l'état des entrées en cachant les bits non utiles
  switch (etatEntrees)
  {
     case  : return 0; // L0 (appui sur l'une des touches 0/1/2 )
     case  : return 1; // L1
     case  : return 2; // L2
     case  : return 3; // L3
     // si autre cas, pas de touches deux touches ou autre
     default : return -1;
  }
}

Indice de colonne

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,2,3}, {4,5,6}, {7,..}, {,,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' *

É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()
{
   ....
}