LA PROGRAMMATION EN MIKROPASCAL

Mon cours a été introduit dans le manuel de cours pour les élèves du BAC technologie pour plus d'informations contactez moi sur le forum. Les schémas et les programmes sont téléchargeables sur le site sous la page téléchargement.

ABIDI Hatem

I-         La programmation en langage évolué :

Que ce soit par la méthode graphique ou en langage évolué, l'écriture du programme ainsi que sa mise au point doivent suivre le diagramme suivant :

Il faut  traduire le cahier des charges en une suite ordonnée d'actions que doit réaliser le processus de commande, cette suite d'opérations sera décomposée en actions élémentaires ou instructions c'est l'Algorithme. Par la suite il suffit de transformer cet algorithme en un langage évolué tel que le langage  PASCAL ou le langage C.

Dans la suite du cours on s'intéressera au langage PASCAL. (Compilateur Mikropascal de Mikroelektronika.) Animation Flash sur Mikropascal

I-1-  Structure d'un programme :

Un programme est un texte que le compilateur va traduire en fichier hexadécimal. Alors il doit avoir une structure particulière.

Le texte d'un programme contient au moins trois parties.

• L'entête

Ne contient qu'une ligne; commence par le mot réservé « Program » et donne un nom au programme.

• Les déclarations

Elles permettent de définir les éléments utilisés dans le programme.
En effet on devra déclarer les variables utilisées pour permettre au compilateur d'effectuer les réservations de mémoire ainsi que les sous-programmes (Procédures et fonctions).

• Le corps du programme

Commence par le mot réservé « Begin » et se termine par le mot réservé "End " suivi d'un point final. Ce qui suit ce "End" n'est pas pris en compte par le compilateur.
Entre "Begin" et "End" se trouvent les instructions à effectuer par le programme.

I-2- Les Règles de bases :

·        Toutes instructions ou actions se terminent par un point virgule ;

·        Une ligne de commentaires doit commencer par "{" et se terminer par "}"  ou commence par "//".

·        Un bloc d'instructions commence par "Begin" et se termine par "End".

I-3- Les types de variables utilisées  en Mikropascal :

I-4- Les bases du compilateur Mikropascal :

Le décimal :             A=10 ;
L'hexadécimal            A=$0F ; ou A=0x0F ;
Le binaire               A=%11010100 ;

I-5-    les opérateurs arithmétiques et logiques :

I-5-  Les structures usuelles :

a)    L'affectation :

C'est l'action d'attribuer une valeur à une variable.

b)    Les structures alternatives :

c)    Les structures itératives ou répétitives :

I : entier ;
........;
POUR  I <Valeur initiale> 
             JUSQU'A <valeur finale> 
    FAIRE
      DEBUT
      Traitement ;
      ............;
      FINFAIRE ;

I: integer;
..........
FOR I:= <valeur initiale>  
                 TO <Valeur finale>
  DO
    BEGIN
    Traitement ;
    ........;
    END;

TANQUE condition FAIRE
      DEBUT
      Traitement ;
      ............;
      FINTANQUE ;

WHILE condition DO
     BEGIN
     Traitement ;
      ........;
     END;

d)    Les procédures et les fonctions

Une suite d'instructions peut être rassemblée en un bloc qui peut être appelé depuis plusieurs endroits d'un programme. Ceci donne lieu aux notions de sous programme appelé aussi  procédures ou fonctions.

Procédures

Ce sont des groupes d'instructions qui vont former une nouvelle instruction simple utilisable dans un programme. En Pascal il faut les définir avant de les utiliser. Ceci se fait en utilisant une structure similaire à celle d'un programme.

Entête

 Procedure Identificateur (Param1:Type1, Param2:Type2,...);

Identificateur est le nom de la procédure; Param1, Param2 ... sont des paramètres que le programme fournit à la procédure sous forme de constantes, de variables ou d'expressions; Type1, Type2 ... sont les types de ces paramètres.

Déclarations

Déclarations de constantes, types, variables utilisés à l'intérieur de la procédure

Corps de la procédure

 Begin
  Instruction1; Instruction2;......
 End;

Il s'agit des instructions exécutées par le programme à l'appel de la procédure. Une procédure peut appeler d'autres procédures définies avant elle. L'appel d'une procédure se fait en écrivant son nom suivi des paramètres nécessaires entre parenthèses.

Fonctions

Une fonction est une procédure qui devra fournir un résultat de type numérique ou chaîne de caractères. La définition se fait en utilisant une structure similaire à celle de la procédure.

Entête

Function Identificateur (Param1:Type1, Param2:Type2,...):Type_R;

Identificateur est le nom de la procédure; Param1, Param2 ... sont des paramètres que le programme fournit à la fonction sous forme de constantes, de variables ou d'expressions; Type1, Type2 ... sont les types de ces paramètres; Type_R est le type du résultat fourni par la fonction.

Déclarations

Déclarations de constantes, types, variables utilisés à l'intérieur de la fonction.

Corps de la fonction

 Begin
  Instruction1;  
  Instruction2;......
  Identificateur:=résultat;
 End;

Il s'agit des instructions exécutées par le programme à l'appel de la fonction. L'une de ces instructions doit fournir le résultat de la fonction en l'affectant au nom de la fonction. L'appel d'une fonction se fait en écrivant son nom suivi des paramètres nécessaires entre parenthèses. Elle représente une expression du type du résultat fourni.

I-6-  Les fonctions adaptées aux  microcontrôleurs PIC :

Le compilateur mikropascal apporte une large bibliothèque de procédures et fonctions adaptées aux microcontrôleurs de la famille PIC de MICROCHIP. Ces fonctions sont accessibles dans l'aide du logiciel néanmoins on va citer quelque une.

Setbit(port , bit) ;

Setbit(portB,2) ;     mettre la broche RB2 à 1

Clearbit(port , bit) ;

Clearbit(portB,5); mettre la broche RB5 à 0

Testbit(port , bit)

A :=testbit(portB,7);affecter à la variable A 
l'état de RB7 

Delay_ms(temps) ;

Delay_ms(150) ; attente de 150 ms

Button(port,bit,temps d'appui,état logique actif)

If Button(portA,2,10,1) then <Action 1> ;
On teste l'appui sur un bouton poussoir 
relié à la broche RA2 pendant 10 ms 
pour faire l'Action 1

II- Les interruptions

II-1- Qu'est-ce qu'une interruption ?

Imaginez une conversation normale. Chaque interlocuteur prend la parole quand vient son tour de parler. Survient alors un évènement extérieur dont le traitement est urgent. Par exemple une voiture s'engage dans votre direction. Vous imaginez bien que votre interlocuteur ne va pas attendre la fin de votre phrase pour vous signaler le danger. Il va donc vous interrompre durant le cours normal de votre conversation; afin de pouvoir traiter immédiatement l'événement extérieur. Les interlocuteurs reprendront leur conversation où elle en était arrivée, sitôt le danger écarté. 

II-2- Les interruptions du microcontrôleur PIC16F84:

L'exécution d'une procédure d'interruption répond à un évènement qui peut être interne ou externe au microcontrôleur. L'appel d'une procédure d'interruption ne dépend pas du programme principal, mais elle l'interrompe  pendant son exécution.Dans une procédure d'interruption on ne peut pas appeler une autre procédure. Le compilateur Mikropascal utilise une directive spéciale pour le nom de la procédure (Procedure interrupt)  pour la différencier avec les autres procédures logicielles.Syntaxe :

Procedure interrupt;
Begin
       Instruction 1; 
       ............
       Instruction n;
End;

On notera que le 16F84 possède 4 sources d'interruptions:

• Un changement d'état sur les broches RB4 à RB7; Une source externe via la broche RB0/INT ;Le débordement du timer 0 ;
• La programmation de l'EEPROM de données.

Le registre INTCON est utilisé pour le contrôle et la gestion des interruptions.

On s'intéressera uniquement à l'interruption externe via la broche RB0/INT, donc on aura à manipuler uniquement les trois bits suivants:

Le bit GIE, "Global lnterrupt Enable", mis à 1 autorise toutes les interruptions non masquées par leur bit individuel.

Le bit INTE, "Interrupt Enable", mis à 1, autorise les interruptions sur RB0/INI.

Le bit INTF, "Interrupt Flag", est un indicateur, il est mis à 1 si une interruption est générée sur RB0/INI. Il doit être remis à 0 par le logiciel dans le programme de traitement de l'interruption.

Pour activer l'interruption externe via la broche RB0/INT on doit affecter la valeur (90)_H au registre INTCON :

Pour plus d'information sur les autres sources d'interruptions consultez le document constructeur  du microcontrôleur 16F84

RÉSUMÉ :

Structure générale d'un programme en Mikropascal pour le microcontrôleur 16F84A

Program nom_programme ;
  ....>Déclarations de constantes, types, variables utilisés dans le programme. 
  ....>Déclarations des procédures et fonctions utilisées dans le programme. 
Begin
  ....>Activation des interruptions utilisées
  ....>Configuration des entrées/sorties.
  ....>Initialisation des sorties utilisées.
while (1=1) do
    begin
         Instruction1;
         Instruction2;
         ......
    end ;
end.

Déclaration des variables et des constantes :

 Var nomvariable : type ;
 Const nomconstante : type = valeur ;

Déclaration d'une procédure:

Procedure Identificateur (Param1:Type1, Param2:Type2,...);
....>Déclarations de constantes, types, variables utilisés à l'intérieur de la procédure
 Begin
     Instruction1;
     Instruction2;
     ......
 End;

Déclaration d'une fonction:

Function Identificateur (Param1:Type1, Param2:Type2,...):Type_R;
....>Déclarations de constantes, types, variables utilisés à l'intérieur de la fonction.
  Begin
      Instruction1;
      Instruction2;......
      Identificateur:=résultat;
  End;

Déclaration d'une procédure d'interruption :

Procedure interrupt;
    Begin
         Instruction 1;
         ............;
        Instruction n;
        Mise à zéro de l'indicateur correspondant à la source d'interruption utilisée.
    End;

Méthodes usuelles de programmation :

Exercice 1: télécharger les fichiers [programme et simulation sous ISIS]

Traduction d'un GRAFCET de point de vue partie commande en un programme en Mikropascal pour le microcontrôleur PIC16F84A.- Soit le GRAFCET suivant :

- On vous donne le tableau  d'affectation des entrées/sorties pour le microcontrôleur PIC16F84A.

Schéma de simulation :

Travail demandé :

1/  Traduire le GRAFCET précédent en algorithme.

2/  Transformer cet  algorithme en programme en Mikropascal.Solution :

1/ L'algorithme :

Algorithme grafcet1 ;
  Variables  X0, X1, X2, X3 : octet ;  // Déclaration des étapes du GRAFCET.
 _DEBUT
|   TrisA <== $F8 ; // RA0, RA1, RA2  sont des sorties ; 
|                   //les autres broches sont des entrées.
|   TrisB <== $FF ;   // Toutes  les broches du  port B sont des entrées.
|   PortA <== 0 ;         // état initial des sorties.
|   X0 <==1 ;             // Initialement l'étape " X0 " est active.
|   X1 <== 0 ;            // Initialement l'étape " X1 " est non active.
|   X2 <== 0 ;            // Initialement l'étape " X2 " est non active.
|   X3 <== 0 ;            // Initialement l'étape " X3 " est non active.
|   TANQUE (1=1) FAIRE    // Boucle infinie.
|       _DEBUT
|      |  SI ((X0 =1) ET (Portb.0=1)) ALORS  // Condition de franchissement de la
|      |                                 // première transition qui est :
|      |                       // étape " X0 "  active et réceptivité " Dcy " vraie.
|      |                  _ DEBUT
|      |                 |      X0<== 0 ;  // Désactivation de l'étape " X0 ".
|      |                 |      X1<== 1 ; // Activation de l'étape " X1 ".
|      |                 |_ FINSI ;
|      |   SI ((X1 =1) ET (Portb.1=1)) ALORS  // Condition de franchissement de la
|      |                             // deuxième transition qui est :
|      |                          // étape " X1 "  active et réceptivité " a " vraie.
|      |                   _ DEBUT
|      |                  |      X1<== 0 ;  // Désactivation de l'étape " X1 ".
|      |                  |      X2<== 1 ;   // Activation de l'étape  "  X0 ".
|      |                  |_ FINSI ;
|      |   SI ((X2 =1) ET (Portb.2=1)) ALORS  // Condition de franchissement de la
|      |                        // troisième transition qui est :
|      |                   // étape " X2 "  active et réceptivité  " b " vraie.
|      |                  _ DEBUT
|      |                 |         X2<== 0 ;  // Désactivation de l'étape " X2 ".
|      |                 |         X3<== 1 ;  // Activation de l'étape " X3 ".
|      |                 |_ FINSI ;
|      |   SI ((X3 =1) ET (Portb.3=1)) ALORS   // Condition de franchissement de la
|      |                             // quatrième transition qui est :
|      |                       // étape " X3 " active et réceptivité " c " vraie.
|      |                  _DEBUT
|      |                 |      X3<== 0 ; // Désactivation de l'étape " X3 ".
|      |                 |      X0<== 1 ;  // Activation de l'étape " X0 ".
|      |                 |_FINSI ;
|      |   SI (X1=1) ALORS Porta.0 <==1 SINON Porta.0 <==0 ; FINSI; // 14M1 = X1.
|      |   SI (X2=1) ALORS Porta.1 <==1 SINON Porta.1 <==0 ; FINSI; // KM2 = X2.
|      |   SI (X3=1) ALORS Porta.2 <==1 SINON Porta.2 <==0 ; FINSI; // 12M1 = X3.
|      |_FINFAIRE ;
|_  FIN.

2/ Le programme :

program GRAFCET1;
Var  X0,X1,X2,X3:byte ;    // Déclaration des étapes du GRAFCET.
begin
TrisA := $F8 ;      // RA0,RA1,RA2 sont des sorties ;
                    // les autres broches sont des entrées.
TrisB := $FF ;     // Toutes  les broches du  port B sont des entrées.
PortA:= 0 ;         // état initial des sorties.
 X0:=1;             // Initialement l'étape " X0 " est active.
 X1:=0;             // Initialement l'étape " X1 " est non active.
 X2:=0;             // Initialement l'étape " X2 " est non active.
 X3:=0;             // Initialement l'étape " X3 " est non active.
 while (1=1) do     // Boucle infinie.
  begin
  if ((X0 =1) and (Portb.0=1)) then   // Condition de franchissement de la
                     // première transition qui est :
                 // étape " X0 "  active et réceptivité " Dcy " vraie.
                     begin
                     X0:=0;         // Désactivation de l'étape " X0 ".
                     X1:=1;         // Activation de l'étape " X1 ".
                     end ;
 if ((X1 =1) and (Portb.1=1)) then      // Condition de franchissement de la
                                     // deuxième transition qui est :
                   // étape " X1 "  active et réceptivité " a " vraie.
                     begin
                     X1:=0;        // Désactivation de l'étape " X1 ".
                     X2:=1;        // Activation de l'étape  "  X0 ".
                     end ;
  if ((X2 =1) and (Portb.2=1)) then     // Condition de franchissement de la
                                      // troisième transition qui est :
                  // étape " X2 "  active et réceptivité  " b " vraie.
                      begin
                      X2:=0;       // Désactivation de l'étape " X2 ".
                      X3:=1;       // Activation de l'étape " X3 ".
                      end ;
   if ((X3 =1) and (Portb.3=1)) then    // Condition de franchissement de la
                                       // quatrième transition qui est :
                  // étape " X3 " active et réceptivité " c " vraie.
                      begin
                      X3:=0 ;       // Désactivation de l'étape " X3 ".
                      X0:=1 ;       // Activation de l'étape " X0 ".
                      end ;
   if (X1=1) then Porta.0:=1  else Porta.0:= 0 ;        // 14M1 = X1.
   if (X2=1) then Porta.1:=1  else Porta.1:= 0 ;        // KM2 = X2.
   if (X3=1) then Porta.2:=1  else Porta.2:= 0 ;        // 12M1 = X3.
 end;
end.

Cas d'un Grafcet avec une temporisation ici : [programme et simulation sous ISIS]

Exercice 2:

Traduction des équations d'un système combinatoire en un programme en Mikropascal pour le microcontrôleur PIC16F84A.Soit les équations suivantes :

Schéma de simulation :

Travail demandé :

1/  Traduire les équations précédentes en algorithme.

2/  Transformer cet  algorithme en programme en Mikropascal.

Solution :  Première méthode :

1/ Algorithme :

Algorithme  EQUATIONS1;
_DEBUT
| trisA <== $FF;    // Tout le port A est configuré en entrée .
| trisB <== $E0;    // de RB0 à RB4 sorties les autres broches : entrées .
| portb <== 0;      // initialisation des sorties
| TANQUE  (1=1)  FAIRE    // boucle infinie 
|   _DEBUT 
|   |// équation de S0 : 
|   |  SI ((portA.0=1) ET (portA.1=1) ET ( portA.2=0)) ALORS 
|   |                      portb.0<==1 SINON portb.0 <== 0; FINSI ;
|   |//équation de S1 :
|   |  SI ((portA.1=1) XOR (portA.2=1)) ALORS  
|   |                      portb.1<==1 SINON portb.1 <== 0; FINSI ;
|   |//équation de S2 :
|   |  SI  ((portA.0=1) OU ((portA.1=1) ET (portA.2=0))) ALORS 
|   |                      portb.2<==1 SINON portb.2 <== 0; FINSI ;
|   |// équation de S3
|   |  SI  ((portA.1=0) ET (portA.2=0)) ALORS 
|   |                      portb.3<==1 SINON portb.3<==0; FINSI ;
|   |// équation de S4
|   |  SI ((portA.1=0) OU (portA.2=0)) ALORS 
|   |                      portb.4<==1 SINON portb.4<==0; FINSI ;
|   | _FINFAIRE;
|_FIN.

2/ Programme :

program EQUATIONS1;
 _begin
|trisA:=$FF;       // Tout le port A est configuré en entrée .
|trisB:=$E0;            // de RB0 à RB4 sorties les autres broches : entrées .
|portb:=0;              // initialisation des sorties
|while (1=1) do         // boucle infinie     
| _begin    // équation de S0 :     
||if((portA.0=1) and (portA.1=1) and ( portA.2=0)) then 
||                portb.0:=1 else portb.0:=0;    //équation de S1 :    
||if((portA.1=1) xor (portA.2=1))then 
||                portb.1:=1 else portb.1:=0;    //équation de S2 :     
||if ((portA.0=1) or ((portA.1=1) and (portA.2=0))) then 
||                portb.2:=1 else portb.2:=0;    // équation de S3    
||if ((portA.1=0) and (portA.2=0)) then 
||                portb.3:=1 else portb.3:=0;    // équation de S4    
||if((portA.1=0) or (portA.2=0))then 
||                portb.4:=1 else portb.4:=0;    
||_end;
|_end.

Deuxième méthode

1/ Algorithme :

Algorithme  EQUATIONS;
Variables  S1, S2, S3, S4, S5 : octet;   // déclaration des variables de sortie. 
 _ DEBUT| TrisA <== $FF;   // port A : entrée
| TrisB <== $E0;           //RB0, RB1, RB2, RB3, RB4 : sorties ;  RB5 ....RB7 : entrées
| Portb <== 0;             // initialisation des sortie 
| TANQUE (1=1)  FAIRE      // boucle infinie 
|       _ DEBUT
|      |    S1<==((portA.0) ET (portA.1) ET ((not portA.2)));    // équation de S1
|      |    S2<==((portA.1) OU exclusif  (portA.2));             // équation de S2
|      |    S3<==((portA.0) OU ((portA.1) ET ((not portA.2))));  // équation de S3
|      |    S4<== non ((portA.1) OU (portA.2));                  // équation de S4
|      |    S5<== non ((portA.1) ET (portA.2));                  // équation de S5
|      |
|      |    S1<==S1 ET $01;    // S1, S2, S3, S4, S5 sont de type octet (8 bits) 
|      |    S2<==S2 ET $01;    //  or on veut travailler avec un seul bit 
|      |    S3<==S3 ET $01;    // qui est le poids le plus faible (20)
|      |    S4<==S4 ET $01;    // alors il faut masquer les autres bits.
|      |    S5<==S5 ET $01;    // exp a (ocet) ; si a=0  alors non a=(11111111)2 
|      |
|      |    SI (S1=1) ALORS portb.0<==1 SINON portb.0<==0; FINSI;    // RB0 = S1.
|      |    SI (S2=1) ALORS portb.1<==1 SINON portb.1<==0; FINSI;    // RB0 = S1.
|      |    SI (S3=1) ALORS portb.2<==1 SINON portb.2<==0; FINSI;    // RB0 = S1.
|      |    SI (S4=1) ALORS portb.3<==1 SINON portb.3<==0; FINSI;    // RB0 = S1.
|      |    SI (S5=1) ALORS portb.4<==1 SINON portb.4<==0; FINSI;    // RB0 = S1.
|      |_FINFAIRE;
|_FIN.

2/  Programme :

program EQUATIONS;
Var S1,S2,S3,S4,S5 : byte;  // déclaration des variables de sortie. 
begin
trisA:=$FF;                 // port A : entrée.
trisB:=$E0;                 //RB0, RB1, RB2, RB3, RB4 : sorties ;  RB5 ....RB7 : entrées
portb:=0;                   // initialisation des sortie 
while (1=1) do              // boucle infinie      
  begin     
  S1:=((portA.0) and (portA.1) and ((not portA.2)));   // équation de S1     
  S2:=((portA.1) xor (portA.2));                       // équation de S2    
  S3:=((portA.0) or ((portA.1) and ((not portA.2)))); // équation de S3     
  S4:= not((portA.1) or (portA.2));      // équation de S4    
  S5:= not((portA.1) and (portA.2));    // équation de S5     
  S1:=S1 and $01;           // S1, S2, S3, S4, S5 sont de type octet (8 bits)      
  S2:=S2 and $01;           //  or on veut travailler avec un seul bit      
  S3:=S3 and $01;           // qui est le poids le plus faible (20)     
  S4:=S4 and $01;           // alors il faut masquer les autres bits.     
  S5:=S5 and $01;           // exp a (ocet) ; si a=0  alors non a=(11111111)2      
  if (S1=1) then portb.0:=1 else portb.0:=0;   // RB0 = S1.     
  if (S2=1) then portb.1:=1 else portb.1:=0;   // RB1 = S2.     
  if (S3=1) then portb.2:=1 else portb.2:=0;   // RB2 = S3.     
  if (S4=1) then portb.3:=1 else portb.3:=0;   // RB3 = S4.     
  if (S5=1) then portb.4:=1 else portb.4:=0;   // RB4 = S5.     
  end;
end.

Exercice 3:

Utilisation de l'interruption externe pour le comptage de pièces sur un tapis roulant dans un processus industriel.Principe de fonctionnement :

-  Ce tapis roulant se trouve à la fin d'une chaine de fabrication de pièces mécaniques.-  Un capteur de proximité permet de compter le nombre de pièces fabriquées.-  Un bouton poussoir RZ permet de mettre le compteur à zéro.-  Le nombre de pièce comptées est affiché par un afficher LCD.Schéma de la carte de commande :

Travail demandé :

1/  Traduire le fonctionnement de ce système par algorithme.2/  Transformer cet  algorithme en programme en Mikropascal.

Solution :

1/ L'algorithme :

Algorithme COMPTEUR;
Variables       
compteur : entier;  // déclaration de la variable de comptage : entier.           
nombre : chaine de caractère [12];  // déclaration d'une chaine de 12 caractères 
                                    // pour l'affichage. 
procédure interruption;     // sous programme d'interruption. 
   _DEBUT 
  |  intcon<==$90;    // validation de l'interruption RB0 
  |                   //et mise à zéro de son drapeau le bit INTF 
  |  compteur<==compteur+1; // incrémentation du compteur. 
  |_FIN;
 _DEBUT
|     lcd_config(portb,1,3,2,7,6,5,4);  
|                          //configuration de l'LCD doit toujours être avant la
|                          //configuration des registres TRISx 
|                          // lcd_config(le port, RS, E, RW, D7, D6, D5, D4) 
|     lcd_cmd(lcd_cursor_off);  // éteindre le curseur de l'afficheur LCD
|     TrisA<==$FF;   //portA entrée
|     TrisB<==$01;   // RB0 : entrée ; les autres broches : sorties pour l'LCD
|     intcon<==$90;  // activation de l'interruption externe RB0/INT
|     compteur<==0;  // initialisation du compteur.
|      lcd_out(1,1,'N.P =');   
|                //afficher sur la 1ere ligne et la 1ere colonne de l'LCD " N.P= ". 
|     TANQUE  (1=1)  FAIRE    // boucle infinie.
|           _DEBUT
|           |    inttostr (compteur,nombre); 
|           |     // changement de la variable " compteur " 
|           |          //en une chaine de caractère qui est " nombre ".
|           |    lcd_out(1,6,nombre); //afficher sur la 1ere ligne 
|           |                     //et la 6emme  colonne de l'LCD :" nombre ".
|           |    SI (porta.0=1) ALORS 
|           |            compteur<==0;FINSI;  // l'appui sur le bouton RZ 
|           |                                 // initialise le compteur.
|           |_FINFAIRE;
|_FIN.

2/ Le programme :

program COMPTEUR;
Var 
  compteur : integer;    // déclaration de la variable de comptage : entier.
  nombre : string[12];   // déclaration d'une chaine de caractère pour l'affichage.
procedure interrupt;     // sous programme d'interruption.        
  begin        
  intcon:=$90;  // validation de l'interruption RB0 
                //et mise à zéro de son drapeau le bit INTF        
  compteur:=compteur+1;  // incrémentation du compteur.        
  end;
begin
lcd_config(portb,1,3,2,7,6,5,4); //configuration de l'LCD doit toujours être avant la 
                          //configuration des registres TRISx   
                      // lcd_config(le port, RS, E, RW, D7, D6, D5, D4) 
lcd_cmd(lcd_cursor_off); // éteindre le curseur                   
TrisA:=$FF;              //portA entrée
TrisB:=$01;              // RB0 : entrée ; les autres broches : sorties pour l'LCD
intcon:=$90;             // activation de l'interruption externe RB0/INT
compteur:=0;             // initialisation du compteur.
lcd_out(1,1,'N.P =');    //afficher sur la 1ere ligne 
                         //et la 1ere colonne de l'LCD " N.P= ". 
while (1=1) do           // boucle infinie.            
            begin
            inttostr(compteur,nombre);  // changement de la variable " compteur "
                                   //en une chaine de caractère qui est " nombre ".
            lcd_out(1,6,nombre);   //afficher sur la 1ere ligne
                                   //et la 6emme  colonne de l'LCD :" nombre ".
            if (porta.0=1) then 
                   compteur:=0; // l'appui sur le bouton RZ initialise le compteur.
            end;
end.

Exercice 4: Extension d'un port  pour le microcontrôleur PIC16F84A.

On désire réaliser un compteur  modulo 100 en utilisant le microcontrôleur 16F84A et  deux afficheurs sept segments.

A / Etude préliminaire :

On vous donne le schéma suivant :

1/ Ecrire le programme correspondant afin de réaliser un compteur modulo 10.

2/ Peut-on ajouter un deuxième afficheur sur les ports du microcontrôleur.

3/ Soit le schéma suivant :

4/ Compléter les chronogrammes suivant :

B/ Extension du port B du microcontrôleur :

1/  On vous donne le circuit 74273, qui contient 8 bascules D avec horloge et remise à zéro  communes, proposer une solution  pour réaliser un compteur modulo 100 avec le PIC16F84A.

2/  Ecrire le programme correspondant.

Solution :

A/

1/Première méthode :

program COMPTEURMOD10a;
beginTrisb:=0;
portb:=0;
while (1=1) do
begin              //segments [ g f e d c b a]
portb:=%00111111 ; // chiffre 0
delay_ms(1000);    // attente d'une seconde
portb:=%00000110;  // chiffre 1
delay_ms(1000);
portb:=%01011011;  // chiffre 2
delay_ms(1000);
portb:=%01001111;  // chiffre 3
delay_ms(1000);
portb:=%01100110;  // chiffre 4
delay_ms(1000);
portb:=%01101101;  // chiffre 5
delay_ms(1000);
portb:=%01111101;  // chiffre 6
delay_ms(1000);
portb:=%00000111;  // chiffre 7
delay_ms(1000);
portb:=%01111111;  // chiffre 8
delay_ms(1000);
portb:=%01101111;  // chiffre 9
delay_ms(1000);
end;
end.
  

Deuxième méthode :

program COMPTEURMOD10b;
var i : integer;
const chiffre : array[10] of byte =(%00111111, %00000110, %01011011,%01001111, 
                                    %01100110, %01101101, %01111101, %00000111,
                                    %01111111,%01101111);
begin
Trisb:=0;
portb:=0;
while (1=1) do     
    begin     for i := 0 to 9 do  // compteur
               begin
               portb:=chiffre[i]; // affichage du chiffre
               delay_ms(1000); // attente d'une seconde
               end;
     end;
end.

2/Pour pouvoir contrôler deux afficheurs sept segments avec  un microcontrôleur il faut avoir au minimum 14 sorties sur ce dernier or le PIC16F84A ne possède que 13 entrée/sortie (8 sur le port B et 5 sur le port A) alors que faire ?

3/

B/1/

2/

program COMPTEURMOD100;
var i,j : integer;
const chiffre : array[10] of byte =(%00111111, %00000110, %01011011,%01001111, 
                                   %01100110, %01101101, %01111101, %00000111,
                                   %01111111,%01101111);
begin
Trisa:=$FC;
porta:=0;
Trisb:=0;
portb:=0;
while (1=1) do
     begin
     for j := 0 to 9 do  // compteur des dizaines
               begin
               portb:=chiffre[j]; // affichage du chiffre des dizaines
               porta.0:=1; //
               delay_ms(1); // Génération d'un front d'horloge sur RB0
               porta.0:=0;
                for i := 0 to 9 do  // compteur des unités
                       begin
                       portb:=chiffre[i]; // affichge du chiffre des unités
                       porta.1:=1;
                       delay_ms(1);  // Génération d'un front d'horloge sur RB1
                       porta.1:=0;
                        delay_ms(1000); // attente d'une seconde
                       end;
               end;
     end;
end.

Exercice 4:

Gestion d'un clavier matriciel par le microcontrôleur PIC16F84A.Soit le schéma suivant :

Dans un premier lieu on s'intéressera au clavier.Schéma structurel d'un clavier 12 touches

Le principe de ce type de clavier est simple en effet l'appui sur une touche réalise un contact direct entre la ligne et la colonne de cette touche. Pour pouvoir lire une touche appuyée par le microcontrôleur on procède comme suit:

On fait un balayage sur les colonnes c'est-à-dire on envoie les séquences suivantes  (100, 010, 001).On lit l'état des lignes sur 4 bits (A, B, C, D)On aura le tableau de correspondance suivant :

On désire afficher le code binaire correspondant à la touche appuyée sur les diodes led.

Travail demandé :

1/  Traduire le fonctionnement de ce système par algorithme.

2/  Transformer cet  algorithme en programme en Mikropascal.

Solution :

1/  Algorithme :

Algorithme clavier ;
  Variables
             T : octet ;
 _ Début
|      T<== 0 ;  {Initialisation de la variable T }
|      TRISA <== $F0 ; { RA0, RA1, RA2, RA3 : sorties ;    }
|       PortA <== 0 ;    {Initialisation du portA }
|      TRISB <== $F8 ;  {RB0, RB1, RB2 : sorties ; RB3, RB4, RB5, RB6, RB7 : entrées}
|      TANQUE  (1=1)  FAIRE {Boucle infinie}
|            _ Début 
|          |    PortB  <==  (00000001)2 ; {Première séquence}
|          |    Attente (10ms) ;                     
|          |    T<== PortB ; 
|          |    T<== T décalé à droite de 4 positions ;{Lecture de RB4, RB5, RB6 et RB7 }
|          |    SI T=8 ALORS T<== 10; FINSI;   {codage des touches }
|          |    SI T=4 ALORS T<== 7; FINSI;  
|          |    SI T=2 ALORS T<== 4; FINSI;            
|          |    SI T<> 0 ALORS PortA<==T ;{Afficher le numéro de la touche appuyée}
|          |                       FINSI;  {   sur le portA   } 
|          |    PortB <== (00000010)2 ;   {Deuxième séquence}
|          |    Attente (10ms) ; 
|          |    T <== PortB ; 
|          |    T <== T décalé à droite de 4 positions ;{Lecture de RB4, RB5, RB6 et RB7}
|          |    SI T=8 ALORS T <== 11 ; FINSI;          {codage des touches }
|          |    SI T=4 ALORS T <== 8 ; FINSI; 
|          |    SI T=2 ALORS T <== 5 ; FINSI; 
|          |    SI T=1 ALORS T<== 2 ;  FINSI;                                         
|          |    SI T<> 0 ALORS PortA<==T ;  {Afficher le numéro de la touche appuyée}   
|          |               FINSI;      {    sur le portA   }
|          |    PortB <== (00000100)2 ;       {Troisième séquence}
|          |    Attente (10ms) ;                     
|          |    T <== PortB ; 
|          |    T<==T décalé à droite de 4 positions ; {Lecture de RB4, RB5, RB6 et RB7}
|          |    SI T=8 ALORS T <== 12 ; FINSI; 
|          |    SI T=4 ALORS T <==  9  ; FINSI; 
|          |    SI T=2 ALORS T <==  6 ; FINSI; 
|          |    SI T=1 ALORS T <==  3 ;  FINSI;        {codage des touches }
|          |    SI T<> 0 ALORS PortA<==T ; FINSI;{Afficher le numéro de la touche appuyée}  
|          |                   {                   sur le portA    }
|          |_FinFaire ;
|_Fin.

 

2/  Programme

program clavier;
  Var T : byte ;
begin
T:= 0 ; {Initialisation de la variable T  }
TRISA := $F0 ;  { RA0, RA1, RA2, RA3 : sorties ;    }
portA:=0;     {Initialisation du portA }
TRISB :=$F8 ;{RB0, RB1, RB2 : sorties ; RB3, RB4, RB5, RB6, RB7 : entrées }
while  (1=1)  do       {Boucle infinie}
    begin
            PortB  := %00000001 ; {Première séquence}
            delay_ms(10) ;
            T:= PortB ;
            T:= T shr 4  ; {Lecture de RB4, RB5, RB6 et RB7}
            if T=8 then T:= 10;   {codage des touches }
            if T=4 then T:= 7;
            if T=2 then T:= 4;
            if T<> 0 then PortA:=T ;{Afficher le numéro 
                                     de la touche appuyée sur le portA  }
            PortB :=%00000010 ;    {Deuxième séquence}
            delay_ms(10) ;
            T := PortB ;
            T := T shr 4  ;   {Lecture de RB4, RB5, RB6 et RB7}
            if T=8 then T := 11 ;       {codage des touches }
            if T=4 then T := 8 ;
            if T=2 then T := 5 ;
            if T=1 then T := 2 ;
            if T<> 0 then PortA := T ;{Afficher le numéro de la 
                                        touche appuyée sur le portA   }
            PortB := %00000100 ;   {Troisième séquence}
            delay_ms(10) ;
            T := PortB ;
            T := T shr 4  ;        {Lecture de RB4, RB5, RB6 et RB7}
            if T=8 then T := 12 ;
            if T=4 then T :=  9 ;
            if T=2 then T :=  6 ;
            if T=1 then T :=  3 ;        {codage des touches }
            if T<> 0 then PortA := T ;{Afficher le numéro de la 
                                       touche appuyée sur le portA  }
    end ;
end.

Les librairies les plus utilisées en Mikropascal sont : 

- LCD Library 

- Keypad Library 

- Delays Library    

- Util Library

1/  LCD library :

Le compilateur MikroPascal fournit une bibliothèque pour communiquer avec l'afficheur LCD utilisé généralement en mode  4-bit

a) Lcd_Config :

Syntaxe

Lcd_Config (var port : byte; const. RS, EN, WR, D7, D6, D5, D4 : byte);

Description

 Initialiser l'afficheur LCD et définir les broches du microcontrôleur à relier à l'LCD.

Exemple 

Lcd_Config (PORTD,1,2,0,3,5,4,6);b)

b) Lcd_Init :

Syntaxe

Lcd_Init (var port : byte);

Description

Initialiser l'afficheur LCD avec  le PIC en spécifiant le port uniquement, le branchement de l'LCD avec le microcontrôleur est imposé par Mikropascal (consulter l'aide du logiciel) 

Exemple

 Lcd_Init (PORTB);

c) Lcd_Out :

Syntaxe

Lcd_Out (row, col : byte; var text : array[255] of char);

Description 

Ecrire un Texte sur l'afficheur LCD en indiquant sa position (ligne et colonne).

Exemple

 Ecrire  "Hello!" sur  LCD sur la ligne  1, colonne 3:Lcd_Out(1, 3, 'Hello!');

d) Lcd_Out_Cp :

Syntaxe

Lcd_Out_Cp(var text : array[255] of char);

Description 

Ecrire  le texte sur l'afficheur LCD à la position actuelle de curseur. 

Exemple

 Afficher " salut " à la position actuelle de curseur :Lcd_Out_Cp('salut');

e) Lcd_Chr :

Syntaxe

Lcd_Chr(row, col, character : byte);

Description 

Ecrire un Caractère sur l'LCD en indiquant sa position (ligne et colonne). 

Exemple

 Ecrire  "i" sur  LCD sur la ligne  2, colonne  3:Lcd_Chr(2, 3, 'i');

f) Lcd_Chr_Cp :

Syntaxe

Lcd_Chr_Cp(character : byte);

Description 

Ecrire un caractère sur l'afficheur LCD  à la position actuelle de curseur. 

Exemple

 Ecrire  "e" à la position actuelle du curseur.Lcd_Chr_Cp('e');

g) Lcd_Cmd :

Syntaxe

Lcd_Cmd (command : byte);

Description

Envoie une commande à l'afficheur LCD. La liste complète des commandes est la suivante :

LCD_FIRST_ROW             Déplacer le curseur  à la 1ère ligne
LCD_SECOND_ROW            Déplacer le curseur  à la 2 ème ligne
LCD_THIRD_ROW             Déplacer le curseur  à la 3 ème ligne
LCD_FOURTH_ROW            Déplacer le curseur  à la 4 ème ligne
LCD_CLEAR                 Effacer le contenu de l'afficheur
LCD LCD_RETURN_HOME       Retour du  Curseur  à la position initiale
 LCD_CURSOR_OFF           Arrêter  le curseur
LCD_MOVE_CURSOR_LEFT      Déplacer  le curseur à gauche
LCD_MOVE_CURSOR_RIGHT     Déplacer le curseur à droite
LCD_TURN_ON               Activer  l'affichage sur l'afficheur
LCDLCD_TURN_OFF           Arrêter l'affichage sur l'afficheur
LCDLCD_SHIFT_LEFT         Décalage de l'affichage à gauche
LCD_SHIFT_RIGHT           Décalage de l'affichage à droite

2/  Keypad Library :

Le MikroPascal fournit une bibliothèque pour travailler avec les claviers matriciels.

a) Keypad_Init :

Syntaxe

Keypad_Init(var port : word);

Description

Initialiser et préciser le port sur le quel est branché le clavier.

Exemple 

Keypad_Init(PORTB);

b) Keypad_Read :

Syntaxe

Keypad_Read : byte;

Description 

Vérifier si une touche est appuyée. La fonction renvoie 1 à 15, selon la touche appuyée, ou 0 si aucune touche n'est actionnée.

Exemple

 kp := Keypad_Read;

c) Keypad_Released :

Syntaxe

Keypad_Released :byte;

Description

L'appel de Keypad_Released génère une attente  jusqu'à ce qu'une touche soit appuyée et libérée. Une fois libérée, la fonction renvoie 1 à 15, selon la touche.

Exemples 

kp := Keypad_Released;

3/ Delays Library :

MikroPascal fournit une procédure pour créer des temporisations.

a) Delay_us :

Syntaxe

Delay_us(const time_in_us : word);

Description

Crée un  retard dont la durée en microsecondes est time_in_us (une constante). La gamme des constantes applicables dépend de la fréquence de l'oscillateur

Exemple

 Delay_us(10);  // Dix microsecondes

b) Delay_ms :

Syntaxe

Delay_ms(const time_in_ms : word);

Description

Crée un  retard dont la durée en millisecondes est time_in_ms (une constante). La gamme des constantes applicables dépend de la fréquence de l'oscillateur.

Exemple 

Delay_ms(1000);  //   une seconde.

c) Vdelay_ms :

Syntaxe

Vdelay_ms(time_in_ms : word);

Description

Crée un  retard  dont la durée en millisecondes est time_in_ms (une variable).

Exemple

Var Pause : integer ;

//.... 

Pause := 1000;

// ...

Vdelay_ms(pause);      //  pause d'une seconde

d) Delay_Cyc :

Syntaxe

Delay_Cyc(cycles_div_by_10 : byte);

Description

Crée un retard dont la durée est fonction de l'horloge du microcontrôleur.

Exemple 

Delay_Cyc(10); 

4/  Util Library

La bibliothèque 'util library'  contient des diverses routines utiles pour le développement de programmes.

Button

Syntaxe

Button (var port : byte; pin, time, active_state : byte) : byte;

Description

Les Paramètres (port)  et (pin)  indiquent l'endroit du bouton ; le paramètre temps d'appui nécessaire pour rendre le bouton actif ; le  paramètre active_state, peut être 0 ou 1,  il détermine si le bouton est ouvert au repos ou fermé au repos.

Exemple

while true do
begin 
   if Button(PORTB, 0, 1, 1) then oldstate := 255; 
   if oldstate and Button(PORTB, 0, 1, 0) then 
   begin   
      PORTD := not(PORTD);
      oldstate := 0; 
   end;
end;

5/ Autres fonctions intégrés:

Le compilateur mikroPascal fournit un ensemble de fonctions de service intégrées utiles. Les fonctions intégrées n'ont aucune condition spéciale ; vous pouvez les employer dans n'importe quelle partie de votre programme.

a)SetBit :

Syntaxe

SetBit(var register : byte; bit : byte);

Description

  Le Paramètre bit doit être une variable 

Exemple

 SetBit(PORTB, 2);  // RB2  =1 ;

b) ClearBit :

Syntaxe 

ClearBit(var register : byte; bit : byte);

Description

Le Paramètre bit doit être variable.

Exemple

ClearBit(PORTC, 7);  // RC7 =0 ;c)

c) TestBit :

Syntaxe

TestBit(var register : byte; bit : byte) : byte;

Description

Cette Fonction teste si le paramètre  bit est égal à 1. Si oui, la  fonction renvoie 1, si non elle  renvoie 0. Le  Paramètre bit doit être  variable. 

Exemple

flag := TestBit(PORTB, 2);   // flag =1 si RB2 =1