Temporisateur numérique avec microcontrôleur PIC16F887

Objectifs

• Comprendre le principe de fonctionnement d’un temporisateur
• Savoir utiliser LCD dans son projet
• Savoir utiliser un clavier 4×4 avec µC
• Savoir utiliser un relais de puissance dans son montage électronique
• Savoir utiliser la librairie Keypad  du MikroC
• Savoir créer une nouvelle fonction
• Et autres astuces pratiques

Exemples d’applications

• Relais électroniques temporisés
• Programmation de la mise en marche d’une machine
• Ouverture d’une porte, portail programmable
• Déclanchement temporisé d’un contacteur
• La minuterie de sécurité
• Etc.

Principe de fonctionnement

A travers le présent projet on va tenter de montrer comment utilise un clavier 4×4 avec un afficheur LCD. Le projet consiste à la réalisation d’une temporisation numérique. Les touches « 0 » à « 9 » du clavier permettent de saisir la valeur de minuterie en milliseconde, la validation de la saisie  et le déclenchement du temporisateur sont assurer par la touche ON/C du clavier.  L’afficheur permet d’observer la valeur acquise par le clavier (Exemple : 1023) ainsi le début du cycle « Start ».

Après l’appui sur la touche ON/C, une temporisation logicielle est lancée et on allume en parallèle la LED rouge D1. La LED reste allumée pour une durée égale à la durée de la temporisation. La LED deviendra éteinte à la fin du tempo, et le cycle recommence.

Tout savoir sur la librairie Keypad

Keypad_Init()

Initialisation du clavier. La fonction nécessite la définition du port pour lequel le clavier est connecté avant son utilisation. La fonction ne dispose d’aucun argument en entrée et en sortie (void).

Syntaxe : void Keypad_Init(void);

// Exemple 
// Affectation du port
char keypadPort at PORTD;
…
// Initialisation 
Keypad_Init();

Keypad_Key_Press()

La fonction retourne une valeur en format char allant de 1 à 16 (16 touches du clavier) dans le cas d’utilisation d’un clavier 4×4 et 1 à 12 pour le clavier 3×4. Elle renvoie la valeur « 0 » lorsqu’aucune touche n’est actionnée. Il est indispensable d’initialiser le clavier avant l’utilisation de la fonction.

Syntaxe : char Keypad_Key_Press(void);

// Exemple 

// Initialisation 
char keypadPort at PORTD;
char kp; 
…
Keypad_Init();

// Lecture du clavier 
kp = Keypad_Key_Press();

Keypad_Key_Click()

La fonction renvoie une valeur comprise entre 1 et 16 en fonction de la touche actionnée, elle renvoie 0 dans le cas échéant. La fonction nécessite aussi l’initialisation du clavier.

Syntaxe: char Keypad_Key_Click(void);

// Exemple
char kp;
...
kp = Keypad_Key_Click();

C’est quoi la différence entre Keypad_Key_Press() et Keypad_Key_Click()

• Keypad_Key_Press: La fonction renvoie en boucle la valeur de la touche actionnée tant que la touche est actionnée. D’une autre façon, il faut actionnée la touche rapidement pour un renvoi simple ou bien ajouter un délai après la fonction. La fonction est peu pratique, car on cherche à avoir une seule valeur au moment de l’appui sur une touche. Dans le cas d’un appui simultané, la fonction renvoie en boucle rapide les valeurs des touches actionnées.

• Keypad_Key_Click: La fonction renvoie une valeur unique au moment de l’appui, elle bloc l’envoie tant que la touche est actionnée. Lorsque plusieurs touches sont actionnées, la fonction ne renvoie aucune valeur, il faut relâcher l’ensemble des touches avant de réactiver la fonction. La fonction est plus pratique et efficace. Elle sera utilisée dans notre programme. Voir un exemple ICI.

Nouvelles fonctions

• char_2_int(): Convertir un caractère en une valeur entière
• key_2_val(): Convertir la valeur acquise du clavier (1-16) à la touche correspondante en format ASCII
• str_2_int(): Convertir une chaine de caractère en une valeur entière

// Syntaxes
unsigned short char_2_int(unsigned short kpp)
unsigned short key_2_val(unsigned short kpp)
unsigned long str_2_int(unsigned short *str, unsigned short taille)

Voir le programme principal concernant la définition des nouvelles fonctions

Le clavier – Comment Ça Marche ?

Concrètement un clavier est un assemblage des boutons poussoirs sous forme d’une matrice de taille nxm, avec n le nombre de ligne et m le nombre des colonnes. Dans notre exemple, on dispose de 4×4=16 boutons poussoirs. Ci-dessous un schéma illustratif du clavier 4×4:

La lecture du clavier consiste à l’envoi d’un signal logique « 1 » dans l’une des colonnes (ou lignes) et lire l’état des colonnes. En effet, on dispose de 4 colonnes, la valeur acquise nous permettra d’obtenir la touche actionnée. La valeur acquise est nulle lorsqu’aucune touche n’est actionnée. Le microcontrôleur envoie le niveau haut ligne par ligne en boucle, puis il lit l’état des colonnes pour ensuite en déduire la touche actionnée. Ci-dessous un exemple de lecture d’un clavier 4×4  de la touche « = » :

1. Le µc active la colonne 1. Le mot envoyé par le µc vaut « 1000 »
2. Le µc lit l’état des lignes DCBA : Dans ce cas il est égal à « 0000 » car aucune touche (ON/C, 1, 4, 7) n’est actionnée
3. Le µc désactive la colonne 1 et active la colonne 2. Le mot envoyé est égal à « 0100 »
4. Le µc lit l’état des lignes DCBA : Dans ce cas il est égal à « 0000 » car aucune touche (0, 2, 5, 8) n’est actionnée
5. Le µc désactive la colonne 2 et il active la colonne 3. Le mot envoyé est égal à « 0010 »
6. Le µc lit l’état des lignes DCBA : dans ce cas il est égal à « 1000 » car la touche « = » est actionnée.
7. Etc.

Lorsque le µC détecte une valeur non nulle dans les broches BCDA, il mémorise l’état puis il en déduit la touche actionnée. En effet, les fonctions illustrées précédemment permettent d’itérer l’ensemble des étapes en boucle.

Étapes de simulation

Important: le temps effectif est relativement long suite à l’utilisation d’une boucle « for » pour exécuter la temporisation. Nous avons réduit le nombre d’itérations en utilisation une division par 16 (décalage à droite de 4 bits de la valeur) afin d’être plus précis. De plus le modèle ISIS n’exécute pas le programme en temps réel, donc plus de retard. Je vous recommande d’utiliser une valeur faible (<10 000) afin d’observer visuellement les résultats. Néomoins, le programme sera plus efficace en utilisant un kit de développement.

1. Attente de la saisie

2. Saisie de la valeur

3. Lancement du temporisateur

Programme MikroC

unsigned short kp,i=0,j=0, Taille=0;
char txt[6];
char ValKey[16], ValKey_rev[16];
char  keypadPort at PORTD;
unsigned long Tempo_int=0, ii=0;
char test[16];

unsigned short char_2_int(unsigned short kpp)
{
 unsigned short kp_int=0;
 switch (kpp)
 {
   case  2: kp_int = 1; break; // 1
   case  3: kp_int = 4; break; // 4
   case  4: kp_int = 7; break; // 7
   case  5: kp_int = 0; break; // 0
   case  6: kp_int = 2; break; // 2
   case  7: kp_int = 5; break; // 5
   case  8: kp_int = 8; break; // 8
   case 10: kp_int = 3; break; // 3
   case 11: kp_int = 6; break; // 6
 }
 return   kp_int;
}

unsigned short key_2_val(unsigned short kpp)
{
 unsigned short kp_val=0;
 switch (kpp)
 {
   case  1: kp_val = 67; break; // C/ON: Arret
   case  2: kp_val = 49; break; // 1
   case  3: kp_val = 52; break; // 4
   case  4: kp_val = 55; break; // 7
   case  5: kp_val = 48; break; // 0
   case  6: kp_val = 50; break; // 2
   case  7: kp_val = 53; break; // 5
   case  8: kp_val = 56; break; // 8
   case  9: kp_val = 35; break; // =
   case 10: kp_val = 51; break; // 3
   case 11: kp_val = 54; break; // 6
   case 12: kp_val = 57; break; // 9
   case 13: kp_val = 43; break; // +
   case 14: kp_val = 45; break; // -
   case 15: kp_val = 42; break; // x
   case 16: kp_val = 47; break; // /
 }
 return   kp_val;
}

unsigned long str_2_int(unsigned short *str, unsigned short taille)
{
 unsigned short i_0=0 ;
 double somme_val=0.0,char_val=0.0, i_doub=0.0;

 for (i_0=0; i_0<taille; i_0++)
 {
     char_val=(double)char_2_int(str[i_0]);
     i_doub=(double)i_0;
     somme_val=somme_val+char_val*pow(10.0,i_doub);
 }
 somme_val=somme_val+1;
 return   (unsigned long )somme_val;
}

// LCD module connections
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D4 at RB0_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D7 at RB3_bit;

sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D7_Direction at TRISB3_bit;
// End LCD module connections

void main() {
  Keypad_Init();                           // Initialize Keypad
  ANSEL  = 0;                              // Configure AN pins as digital I/O
  ANSELH = 0;
  TRISE=0;
  PORTE=0x00;
  // Port A en entrée
  TRISA=0xFF;
  Lcd_Init();                              // Initialize LCD
  Lcd_Cmd(_LCD_CLEAR);                     // Clear display
  Lcd_Cmd(_LCD_CURSOR_OFF);                // Cursor off
  Lcd_Out(1, 1, "Tempo (ms)  :");                 // Write message text on LCD
  Lcd_Out(2, 1, "=>");

  do 
  {
    do
    {
      do
        // Lecture du clavier
        kp = Keypad_Key_Click();
        //kp = Keypad_Key_Press(); // Testé la fonction
      while (!kp);
      
      // Mémorisation de la touche actionnée
      ValKey[i]= kp;
      
      // Obtenir la valeur ASCII de la touche
      kp=  key_2_val(kp);
      
      // Affichage de la touche
      Lcd_Chr(2, i+4, kp);
      Taille=i;
      i++;
      if (i+4==16)
         break;
    }while(kp!=67);  // Condition d'Arret

    // Inverser le tableau
    ValKey[Taille]=" ";
    for (j=0;j<Taille; j++)
        ValKey_rev[j]=ValKey[Taille-1-j];

    // Conversion string ==> Int
    Tempo_int=str_2_int(ValKey_rev, Taille);
    
    // Start tempo
    PORTE=0x01;
    Lcd_Cmd(_LCD_CLEAR);
    Lcd_Out(1, 1, "Tempo (ms)  :");
    Lcd_Out(2, 1, "=> Start");

    ii= Tempo_int>>6;
    for (i=0;i<ii; i++)
        Delay_ms(64);
    
    // Arret tempo
    PORTE=0x00;
    kp = 0; i=0;
    Tempo_int=0;
    Lcd_Cmd(_LCD_CLEAR);
    Lcd_Cmd(_LCD_CURSOR_OFF);
    Lcd_Out(1, 1, "Tempo (ms)  :");
    Lcd_Out(2, 1, "=>");
  } while (1);
}

Téléchargement

• MikroC: Temporisateur numérique
• ISIS: Temporisateur numérique 

Retour à l’accueil MikroC