Utiliser les PIC 16F et 18F/Exercices/Interruption timer0 en langage C

Exercice 1 (Hitech C et Mikro C)

Si vous voulez savoir comment est réalisé pratiquement ce qui est décrit dans cet exercice, visitez le chapitre Embarquer un PIC 16F84 d'un autre livre.

Un PIC16F84 est enfoui dans un FPGA. Sa seule particularité est de fonctionner à 50 Mhz contre 10 (respectivement 20 Mhz) de fréquence maximale d'horloge pour les PIC 16F84 (respectivement 16F84A). Il exécute le programme suivant (écrit avec le compilateur Hitech C) :

//#include <pic1684.h>
#include <htc.h> //A changer si autre compilateur
void interrupt decalage(void); //A changer si autre compilateur
unsigned char nb; 
main(void) { 
  TRISA = 0xF9; // 6 entrees, 2 sorties pour A 
  TRISB = 0x00; // 8 sorties pour B 
  OPTION = 0x07; // prescaler 256 , entree sur quartz (A changer si autre compilateur : OPTION_REG)
  INTCON = 0xA0;  // autorise l'interruption timer 
  PORTB = 0x01; // une seule diode allumee		 
  TMR0 = 0x00 ; 
  nb=0; 
  while(1) { 
   // on ne fait rien que recopier sur 2 segments la valeur de SW1 
      if ((PORTA & 0x01) == 1) PORTA = 0x06; 
    } 
} 

void interrupt decalage(void) { //A changer si autre compilateur
  nb++; 
  //TMR0 = 0x00; //c'est fait car ici par overflow
  if (!(nb % 16)) 
  PORTB = (PORTB << 1) ; 
  if (PORTB == 0x00)   PORTB = 0x01; 
  T0IF = 0;  // acquittement interruption 
}

Remarquez comment est écrit une interruption avec ce compilateur.

1°) Repérer et modifier les lignes de ce programmes pour qu’il fonctionne avec le compilateur MikroC.

2°) Calculer si le chenillard réalisé par ce programme est visible à l'œil humain (fréquence de changement de position des LEDs inférieure à 20 Hz).

3°) Comment peut-on écrire l'instruction "if (!(nb % 16))" pour plus d'efficacité.

4°) Quelle est la suite des états (LEDs allumées) réalisée par ce programme.

Les deux questions suivantes sont issues du Devoir Surveillé de juin 2010.

5°) Le programme suivant est donné comme exemple du compilateur MikroC et tourne dans un PIC 16F84 qui a un quartz de 4 Mhz.

unsigned cnt; 
void interrupt() { 
  if (TMR0IF_bit) { 
    cnt++;                 // increment counter 
    TMR0IF_bit = 0;        // clear TMR0IF 
    TMR0   = 96; 
  } 
} 

void main() { 
  OPTION_REG = 0x84;       // Assign prescaler to TMR0 
  ANSEL  = 0;              // Configure AN pins as digital 
  ANSELH = 0; 
  C1ON_bit = 0;            // Disable comparators 
  C2ON_bit = 0; 
  TRISB = 0;               // PORTB is output 
  PORTB = 0xFF;            // Initialize PORTB 
  TMR0  = 96;              // Timer0 initial value 
  INTCON = 0xA0;           // Enable TMRO interrupt 
  cnt = 0;                 // Initialize cnt 

  do { 
    if (cnt >= 400) { 
      PORTB = ~PORTB;      // Toggle PORTB LEDs 
      cnt = 0;             // Reset cnt 
    } 
  } while(1); 
}

Quelle est la fréquence de clignotement des LEDs reliées au PORTB ?

6°) Modifier l'interruption (du programme de départ) pour qu'elle réalise un chenillard d'une LED se déplaçant vers les poids faibles.

Solution

1°) Pas grand chose de changé :

void interrupt decalage(void) { 
  nb++; 
  if (!(nb % 16)) 
  PORTB = (PORTB << 1) ; 
  if (PORTB == 0x00)   PORTB = 0x01; 
  TMR0IF_bit = 0; // acquittement interruption (** changé ici **) 
}
unsigned char nb; 
main(void) { 
  TRISA = 0xF9; // 6 entrees, 2 sorties pour A 
  TRISB = 0x00; // 8 sorties pour B 
  OPTION_REG = 0x07; // prescaler 256 , entree sur quartz (** changé ici **) 
  INTCON = 0xA0;  // autorise l'interruption timer 
  PORTB = 0x01; // une seule diode allumee		 
  TMR0 = 0x00 ; 
  nb=0; 
  while(1) { 
   // on ne fait rien que recopier sur 2 segments la valeur de SW1 
      if ((PORTA & 0x01) == 1) PORTA = 0x06; 
    } 
}

2°) Je l'ai réalisé dans un FPGA et à vue de nez la fréquence est entre 5 et 10 Hz.

N'oubliez pas la division par 16 qui est réalisée avec le if (!(nb % 16)) dans l'interruption.

Calcul précis : 50 Mhz / 4*(256*256*16) = 11,92 Hz (la division par 4 a toujours lieu).

3°) "if (!(nb % 16))" est une façon pas très efficace de calculer le reste de la division par 16. J'ignore la technique utilisé par le compilateur, mais ce calcul est forcément long puisqu’il n'y a pas d'instruction de division sur le 16F84.

Comme la division se fait par 16 qui est une puissance de deux, on peut utiliser un masque pour faire ce calcul bien plus rapidement :

// langage C
if (!(nb & 0x0F)) // idem à if (!(nb % 16)) mais plus rapide

4°) Décalage tout simple d'une LED vers les poids forts.

5°) OPTION_REG = 0x84; = 1000 0100 => poids faible = 4 => division par 2 puissance 5 = 32

4 000 000 / 4*32*(256-96)*400 = 0,488 28 Hz Soit pratiquement 0,5 Hz

Un meilleur calcul serait :

4 000 000 / 4*32*(256-94)*400 = 0,482 253 086 Hz (à cause des temps de latence) Cette connaissance n’est pas demandée aux étudiants.

6°)

#include <pic1684.h>
//#include <htc.h> serait-il mieux ? 
void interrupt decalage(void);
unsigned char nb; 
main(void) { 
  TRISA = 0xF9; // 6 entrees, 2 sorties pour A 
  TRISB = 0x00; // 8 sorties pour B 
  OPTION = 0x07; // prescaler 256 , entree sur quartz 
  INTCON = 0xA0;  // autorise l'interruption timer 
  PORTB = 0x01; // une seule diode allumee		 
  TMR0 = 0x00 ; 
  nb=0; 
  while(1) { 
   // on ne fait rien que recopier sur 2 segments la valeur de SW1 
      if ((PORTA & 0x01) == 1) PORTA = 0x06; 
    } 
} 

void interrupt decalage(void) { 
  nb++; 
  //TMR0 = 0x00; //c'est fait car ici par overflow
  if (!(nb % 16)) 
  PORTB = (PORTB >> 1) ; // *** changé ici ****
  if (PORTB == 0x00)   PORTB = 0x80; // *** changé ici ****
  T0IF = 0;  // acquittement interruption 
}

 

Exercice 2

Une partie matérielle est constituée de deux afficheurs sept segments multiplexés. Les sept segments sont commandés par le PORTC, tandis que les commandes d'affichages sont réalisée par les bits b0 et b1 du PORTB. Un schéma de principe est donné ci-après.

Comment utiliser deux afficheurs multiplexés

1°) A l'aide de la documentation calculer les valeurs dans un tableau "unsigned char SEGMENT[] = {0x3F,...};" pour un affichage des chiffres de 0 à 9.

2°) réaliser une fonction responsable du transcodage :

unsigned char Display(unsigned char no) { 
    unsigned char Pattern; 
    unsigned char SEGMENT[] = {0x3F,....

3°) Réaliser le programme main() responsable de l'initialisation de l'interruption qui doit avoir lieu toutes les 10ms (avec un quartz de 4 Mhz) et qui compte de 00 à 99 toutes les secondes environ (avec un "Delay_ms(1000);")

4°) Réaliser enfin l'interruption qui affichera tantôt les dizaines, tantôt les unités.

Solution

1°) 0x3F est 0011 1111 sur un affichage xgfe dcba ce qui allume les segments fedcba affiche donc un 0 et nous donne en même temps la marche à suivre.

• 1 <-> xgfe dcba = 0000 0110 = 0x06
• 2 <-> xgfe dcba = 0101 1011 = 0x5B
• etc etc

Soit en final :

    unsigned char SEGMENT[] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};

2°)

unsigned char Display(unsigned char no) { 
    unsigned char Pattern; 
    unsigned char SEGMENT[] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
    Pattern = SEGMENT[no];
    return Pattern;
}

ou encore

unsigned char Display(unsigned char no) { 
    //unsigned char Pattern; 
    unsigned char SEGMENT[] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
    return SEGMENT[no];
}

3°) Pour bien faire, le comptage doit se faire en BCD. Cela peut se faire avec :

nb++;
// gérer le problème des unités
if ((nb &0x0F) > 9) then nb+=6;
// gérer le problème des dizaines
if ((((nb &0xF0) > 0x90) nb = 0;

Les compilateurs C compilent cela certainement de manière peu optimisée. Il faut savoir qu’il existe un bit "half carry" dans le registre Status qui permet certainement d'optimiser, mais nous laissons tomber ce genre de détail.

Pour la période de l'interruption, on part de la fréquence quartz divisée par 4 soit : 1 Mhz qu’il faut diviser par 10 000 pour avoir une période d'overflow de 10 ms. Le timer gère une division par 256 qu'on peut ramener à 250 en l'initialisant à 6 mais il nous reste à réaliser une division par 40 qui n’est pas une puissance de 2. On va prendre une division par 64 et 10000 / 64 = 156,25 donc notre timer0 sera initialisé à 256-156 = 100.

//****** Mikro C ********
unsigned char nb,mux; 
main(void) { 
  TRISB = 0xFC; // 6 entrees, 2 sorties pour B
  TRISC = 0x00; // 8 sorties pour B 
  OPTION_REG = 0x05; // prescaler 64, entree sur quartz 
  INTCON = 0xA0;  // autorise l'interruption timer 	 
  TMR0 = 100 ; 
  nb=0;
  mux = 1; 
  while(1) {
// boucle principale compte en BCD 
    nb++;
  // gérer le problème des unités
    if ((nb &0x0F) > 9) then nb+=6;
  // gérer le problème des dizaines
    if ((((nb &0xF0) > 0x90) nb = 0;
    Delay_ms(1000);
   } 
}

4°)

void interrupt(void) {
    TMR0 = 100;
    mux = ~ (mux) & 0x03; // alterne le mux
    PORTB = mux; 
  // poids faible
    if (mux == 1) PORTC = Display(nb / 10); // dizaines d’après le dessin
  // poids fort
    if (mux == 2) PORTC = Display(nb % 10); // unités
    INTCON.T0IF = 0;        // clear TMR0IF 
}

Cette façon de faire (division par 10 et reste de la division par 10) est utile si nb n’est pas en BCD, or nous avons présenté dans le main une incrémentation qui veille à laisser nb en BCD ! On peut donc renplacer cette interruption par :

void interrupt(void) {
    TMR0 = 100;
    mux = ~(mux) & 0x03; // alterne le mux
    PORTB = mux; 
  // poids faible
    if (mux == 1) PORTC = Display(nb &0x0F);
  // poids fort
    if (mux == 2) PORTC = Display((nb & 0xF0)>>4);
    INTCON.T0IF = 0;        // clear TMR0IF 
} 
ce qui est bien plus efficace pour un code d'interruption.