Activations E/S (Numériques)

Dernière mise à jour le 19/01/2014

---------------------------------------------------------------------------------------------------------------------------------------------------------------

Présentation 

Nous allons voir en détails comment fonctionnent les entrées et sorties, si elles reçoivent un signal sur leur pattes du type (tout ou rien ou « 0 » ou « 1 »), tous simplement un signal binaire. Puis nous allons voir en détails les différents registres que comporte le PIC 12F675.

---------------------------------------------------------------------------------------------------------------------------------------------------------------

Registres du PIC 12F675

OPTION_REG : 

Ce registre permet  d’activer  « pull-up » (tirage vers le haut) résistance câblée ente l’entrée et le (+) de l’alimentation, et dans le cas contraire de désactiver  « pull_down » (tirage vers le bas) résistance câblée entre l’entrée et la masse. Voir EasyPIC V7.

Option reg 1

TRISIO : 

Vous connaissez sans doute TRISA/ TRISIB / TRISC/ …, valable pour le pic 16F628A par exemple, et bien la c’est pareil, sauf que ce PIC 12F675 lui fonction soit en (A/N=Analogique/Numérique). Nous allons seulement parler du numérique.TRISIO permet de configurer l’état des pattes de notre PIC 12F675, soit ont utilisent les pattes comme une entrée chiffre (1) dans ce cas l’entrée est configurée (analogique ou numérique), ou  soit ont utilisent les pattes comme une sortie (0 « zéro ») dans ce cas la sortie  est configurée (analogique ou numérique).

Il est possible bien entendu de désigner  chaque pattes (si on veut qu’une soit une sortie l’autre une entrée ou l’inverse), mais il faut  préciser qui fait quoi. 

TRISIO.0:=1; //GP0 configuré en entrée (analogique ou numérique)
TRISIO.1:=0; //GP1 configuré en sortie (analogique ou numérique) 
TRISIO.2:=0; //GP2 configuré en sortie (analogique ou numérique)
TRISIO.3:=1; //GP3 configuré en entrée (analogique ou numérique)
TRISIO.4:=1; //GP4 configuré en entrée (analogique ou numérique)
TRISIO.5:=1; //GP5 configuré en entrée (analogique ou numérique)
 

ANSEL : 

Ansel 

Ce registre à une grande importance tous de même pour la configuration des entrée soit en analogique soit en numérique. 

Le datasheet nous explique que le PIC 12F675 comporte 4 pattes qui peuvent être utilisés en analogique respectivement (AN0 /AN1 /AN2/AN3) qui peut s’écrire aussi ANSEL<3 :0> ou ANS3 :ANS0 (même chose) voir ci-dessus . 

Ce qu’il faut comprendre c’est que le registre ANSEL comporte en lui des autres « sorte de sous-programme » ( ANS0/ANS1/ANS2/ANS3), qui permettent de dire si ces pattes vont fonctionnées en numérique ou analogique. 

Dans ce cas si on utilise ces pattes en numérique alors il faut attribuer un (0 »zéro) et en analogique un (1) ce qui nous donne :

TRISIO.0:=1; //GP0 configuré en entrée (analogique ou numérique)
TRISIO.1:=0; //GP1 configuré en sortie (analogique ou numérique) 
TRISIO.2:=0; //GP2 configuré en sortie (analogique ou numérique)
TRISIO.3:=1; //GP3 configuré en entrée (analogique ou numérique)
TRISIO.4:=1; //GP4 configuré en entrée (analogique ou numérique)
TRISIO.5:=1; //GP5 configuré en entrée (analogique ou numérique)
ANSEL.ANS0:=1; //utilisation de l'entrée GPIO.0 comme entrée analogique (AN0)
ANSEL.ANS1:=0; //utilisation de l'entrée GPIO.1 comme sortie numérique (GP1)
ANSEL.ANS2:=0; //utilisation de l'entrée GPIO.2 comme sortie numériquee (GP2)
ANSEL.ANS3:=1; //utilisation de l'entrée GPIO.4 comme entrée analogique (AN3)
ANSEL.ANS4:=1; //utilisation de l'entrée GPIO.5 comme entrée analogique (AN?) impossible!!!
ANSEL.ANS5:=1; //utilisation de l'entrée GPIO.? comme entrée analogique (AN?) impossible!!!  

Excusez moi d'anticiper mais je prèfère, voyez vous j'ai fais une erreur d'ailleur elle est indiqué avec le mots "impossible!!!", oui comme je l'es dis à la deuxième ligne, seulement  4 pattes peuvent être utilisé en analogique plus précisement les 4 bits AN0/AN1/AN2/AN3 (AN=analogique)  en aucun cas AN4 et AN5 existe et c'est pas la peine d'inventé ;-). et il suffit de regardé ce qui est indiqué sur le PIC c'est mieux quand c'est visible.

Correction:

TRISIO.0:=1; //GP0 configuré en entrée (analogique ou numérique)                        
TRISIO.1:=0; //GP1 configuré en sortie (analogique ou numérique)                        
TRISIO.2:=0; //GP2 configuré en sortie (analogique ou numérique)                        
TRISIO.3:=1; //GP3 configuré en entrée (analogique ou numérique)                        
TRISIO.4:=1; //GP4 configuré en entrée (analogique ou numérique)                       
TRISIO.5:=1; //GP5 configuré en entrée (analogique ou numérique)                       
ANSEL.ANS0:=1; //utilisation de l'entrée GPIO.0 comme entrée analogique (AN0) 
ANSEL.ANS1:=0; //utilisation de l'entrée GPIO.1 comme sortie numérique (GP1)   
ANSEL.ANS2:=0; //utilisation de l'entrée GPIO.2 comme sortie numériquee (GP2) 
ANSEL.ANS3:=1; //utilisation de l'entrée GPIO.4 comme entrée analogique (AN3)  

Seulement les pattes 7/6/5/3 peuvent lire un signal analogique, les autres non. 

---------------------------------------------------------------------------------------------------------------------------------------------------------------

Allumer toutes les leds quand BP enfoncé

Allumer

Bon maintenant écrivons un programme en utilisant un PIC 12F675 le but et d'allumer toutes les leds en sortie du pic en appuyant sur le bouton poussoir

essayons de comprendre le programme:


procedure init; // procédure inital on configure notre PIC                                   
begin  //début                                                                               
OPTION_REG:=000000;//les résistances pull_up désactivé                                       
CMCON:=000111; //on désactve le comparateur sinon sa ne fonctionne pas                       
TRISIO.0:=1; // GP0 configuré en entrée (analogique ou numérique?)                           
TRISIO.1:=0; // GP1 configuré en sortie (analogique ou numérique?)                           
TRISIO.2:=0; // GP2 configuré en sortie (analogique ou numérique?)                           
TRISIO.3:=1; // GP3 configuré en entrée obligatoirement                                      
TRISIO.4:=0; // GP4 configuré en entrée (analogique ou numérique?)                           
TRISIO.5:=0; // GP5 configuré en sortie                                                      
ANSEL.ANS0:=0; // GPO est une sortie numérique  je comprend mieux                            
ANSEL.ANS1:=0;  // GP1 est une sortie numérique je comprend mieux                            
ANSEL.ANS2:=0; // GP2 est une sortie numérique je comprend mieux                             
ANSEL.ANS3:=0; // GP4 est une sortie numérique je comprend mieux                             
GPIO.0:=0; // l'entrée GP0 est au "0" logique et prête à RECEVOIR un NIVEAU HAUT (1 logique) 
GPIO.1:=0; // la sortie GP1 est au "0" logique et prête à DONNER un NIVEAU HAUT (1 logique)  
GPIO.2:=0; // la sortie GP2 est au "0" logique et prête à DONNER un NIVEAU HAUT (1 logique)  
GPIO.3:=0; // l'entrée  GP3 est au "0" logique et prête à RECEVOIR un NIVEAU HAUT (1 logique)
GPIO.4:=0; // la sortie GP4 est au "0" logique et prête à DONNER un NIVEAU HAUT (1 logique)  
GPIO.5:=0; // la sortie GP5 est au "0" logique et prête à DONNER un NIVEAU HAUT (1 logique)  
end;                                                                                         
procedure articulation; //notre programme                                                    
begin                                                                                        
If GPIO.0=1 then  // si GP0 est à l'état haut alors                                          
begin // début d'une indication                                                              
GPIO.0:=1;                                                                                   
GPIO.1:=1;                                                                                   
GPIO.2:=1;       // activer toutes les sorties                                               
GPIO.4:=1;                                                                                   
GPIO.5:=1;                                                                                   
end;                                                                                         
end;                                                                                         
begin // début                                                                               
init;  // le MCU vérifie le programme init (ses configurztions)                              
while true do // tant que vrai alors                                                         
articulation;  // j'exécute en boucle                                                        
end.  //fini                                                                                 

Prg1.txt Programme en format texte sans commentaire; il suffit de le copier et de le coller pour ensuite le flashé dans le PIC12F675

Lorsque nous appuyons sur le bouton poussoir toutes les leds s'allument comme prévue, lorsque nous relachons le BP elle restent toutes allumées, oui c'est normal,

---------------------------------------------------------------------------------------------------------------------------------------------------------------

Comment ça marche?

dessus et vous avez compris ce qu'il fallais faire, et bien la c'est pareil, le MCU à lu ligne par ligne (l'avantage qu'il as c'est qu'il à une vitesse de lecture très supérieur à vous lorsque vous commencer le 1er mots lui il a déja lu 10 000 fois le programme vous voyez un peu...), parenthèse fermé le MCU une fois qu'il a lu toute la procédure init il voit une autre procédure articulation (nous verrons ceci un peu plus loin) , puislorsque le MCU a lu la procédure articulation il arrice encore à un autre programme, je sais pas si vous avez remarquer mais on a changer déja 3 fois de sujet,:

1er sujet => procédure int;

2ème sujet => procédure articulation

3ème sujet=> que nous allons étudier de suite, mais avant d'attaquer ce sujet il faut voir qu'un sujet commence par un début et ce temine par une fin, c'est comme l'écriture on commence par une majuscule et onfini par un point, et bien lui voit un début avec le terme "Begin" et la fin "end;" et "end." (avec un point final quand le programme et VRAIMENT terminé).

Je disais donc qu'arriver au 3ème sujet il y'a un boucle (while true do =>tant que vrai), le MCU va lire sans cesse entre "while true doe et le "end;" et si on regarde le programme entre cette boucle nous avons "articulation", le MCU devra donc lire en boucle la procédure articulation sans cesse... Il faut admettre que lui peut faire plusieurs choses à la fois en plus de la lecture.

Concernant la procédure articulation, c'est les ordres qu'on lu donne de faire en l'occurence lorsque GPIO.0 est à l'état haut alors il faut allumer toutes les leds.

---------------------------------------------------------------------------------------------------------------------------------------------------------------

Est-tu intelligent?

Procédure init;

Je récapitule, au début il commence à lire la procédure init, en gros cette procédure lui dis ce qu'il doit faire avec ses "membres" (et vous ,vous faites quoi en ce moment avec avec vos yeux?), il faut savoir qu'un microcontroleur pour qu'il fonctionne il faut tous lui dire, c'est comment vous pour rentrez chez vous vous faites comment? vous allez me dire, :

"j'ouvre la porte"

c'est tellement simple de faire ça!! alors que non c'est pas comme ça que le PIC va comprendre, vous allez dans un premier temps mettre la mains dans votre poche, prendre la clée la mettre dans la serrure tourner la clée dans la serrure puis ensuite avec votre mains droite (ou gauche) d'ouvrir la porte, (c'est peu être idot comme exemple,mais c'est la véritée le PIC est très binaire il faut tous lui dire ;-)).

Procédure articulation;

Ensuite une fois qu'il sais comment fonctionnent tous ses "membres" il faut les articulés, c'est la procédure articulation qui va être traiter, (comme expliquer précédement) le MCU va lire et traiter ce qu'on lui demande de faire, et il interpête de la façon suivante:

Si son membre GPIO.0 reçoit un niveau haut (1) logique alors il faut activer toutes les sorties, il va donc mettre un état haut (1) logique dans GPIO.0 / GPIO.1 / GPIO.2 / GPIO.4 / GPIO.5.

La dernière ligne, begin jusqu'à la fin du programme "end." (on remarque le point final).

Begin

//ce que doit exécuter le MCU

end;

end.

le MCU sais qu'il faut commencer encore une dernière étape, et c'est celle-ci ou tous va se passer, ensuite arrive la deuxième ligne "init;" (vue précédement) et il voit "while true do"  cea veut dire que tant que la ligne "init" est vrai (elle peut qu'être vrai car rien ne change dans cette configuration) il va faire "articulation;"

si le bouton poussoir est enfoncé il va donc mettre le (1) logique dans tous les ports ce qui va allumer toutes les leds, et va vérifier en boucle entre "while true do" et "end;" tant que c'est vrai c'est à dire tant que le BP est maintenue enfoncé les leds reste allumé, si mintenant on relache le BP que ce passe t'il? est bien admettons qu'on arrive a suivre la vitesse de lecture (chose impossible mais imaginons le) il faut qu'on fasse la même chose que le MCU (lire en boucle et lire le programme de haut en bas).

Sa veut dire que lorsque le BP est relaché GPIO.0 repasse à l'état logique (0), mais comme le MCU à mis la valeur (1) dans les sorties lorsque qu'il va revenir en début de boucle il va repasser pour la nième fois sur le GPIO.0 et la il va voir la valeur à (0) logique et il s'arrête il s'arrête car pour qu'il puisse continuer de lire la suite il faut que GPIO.0=1 dans ce cas il peut continué la boucle mais le problème est que précédement la valeur était àmise à 1 et sachant qu'il s'arrête car la conditon GPIO=1 n'est pas respecté rien ne lui dis de remttre les sortie à (0) logique.

Si vous avez compris un peu ce que je suis entrain d'expliquer (c'est pas évident d'expliquer simplement les choses compliqué), il faut que le MCU comprenne que nous voulons mettre à (0) les sortie quand le BP n'est pas enfoncé.

Nous allons donc réctifier le programme....

---------------------------------------------------------------------------------------------------------------------------------------------------------------

Réctification du programme pour que les leds s'éteignent quand BP relaché

On reprend, procédure init (non rien à changer), oui il n'ya rien à changer car le montage reste t'elle qu'il est.

procédure articulation en revanche la il faut faire quelque chose, quand on appuie on allume on "articule" notre PIC et quand on relache on "articule" aussi le PIC pour éteindre les leds, il faut donc placer un condition pour que les leds s'éteignent lorsque le BP est relaché.

program allumer_toutes_les_leds;                                                             
procedure init; // procédure inital on configure notre PIC                                   
begin  //début                                                                               
OPTION_REG:=000000;//les résistances pull_up désactivé                                       
CMCON:=000111; //on désactve le comparateur sinon sa ne fonctionne pas                       
TRISIO.0:=1; // GP0 configuré en entrée (analogique ou numérique?)                           
TRISIO.1:=0; // GP1 configuré en sortie (analogique ou numérique?)                           
TRISIO.2:=0; // GP2 configuré en sortie (analogique ou numérique?)                           
TRISIO.3:=1; // GP3 configuré en entrée obligatoirement                                      
TRISIO.4:=0; // GP4 configuré en entrée (analogique ou numérique?)                           
TRISIO.5:=0; // GP5 configuré en sortie                                                      
ANSEL.ANS0:=0; // GPO est une sortie analogique je comprend mieux                            
ANSEL.ANS1:=0;  // GP1 est une sortie analogique je comprend mieux                           
ANSEL.ANS2:=0; // GP2 est une sortie analogique je comprend mieux                            
ANSEL.ANS3:=0; // GP4 est une sortie analogique je comprend mieux                            
GPIO.0:=0; // l'entrée GP0 est au "0" logique et prête à RECEVOIR un NIVEAU HAUT (1 logique) 
GPIO.1:=0; // la sortie GP1 est au "0" logique et prête à DONNER un NIVEAU HAUT (1 logique)  
GPIO.2:=0; // la sortie GP2 est au "0" logique et prête à DONNER un NIVEAU HAUT (1 logique)  
GPIO.3:=0; // l'entrée  GP3 est au "0" logique et prête à RECEVOIR un NIVEAU HAUT (1 logique)
GPIO.4:=0; // la sortie GP4 est au "0" logique et prête à DONNER un NIVEAU HAUT (1 logique)  
GPIO.5:=0; // la sortie GP5 est au "0" logique et prête à DONNER un NIVEAU HAUT (1 logique)  
end;                                                                                         
procedure articulation; //notre programme                                                    
begin                                                                                        
If GPIO.0=1 then  // si GP0 est à l'état haut alors                                          
begin // début d'une indication                                                              
GPIO.0:=1;                                                                                   
GPIO.1:=1;                                                                                   
GPIO.2:=1;       // activer toutes les sorties                                               
GPIO.4:=1;                                                                                   
GPIO.5:=1;                                                                                   
end;                                                                                         
begin                                                                                        
if GPIO.0=0 then                                                                             
begin                                                                                        
GPIO.0:=0;                                                                                   
GPIO.1:=0;                                                                                   
GPIO.2:=0;       // désactiver toutes les sorties                                            
GPIO.4:=0;                                                                                   
GPIO.5:=0;                                                                                   
end;                                                                                         
end;                                                                                         
end;                                                                                         
begin // début                                                                               
init;  // le MCU vérifie le programme init (ses configurztions)                              
while true do // tant que vrai alors                                                         
articulation;  // j'exécute                                                                  
end.  //fini                                                                                 

 Prg2.txt à vous d'essayer

Voilà un programme opérationnel

--------------------------------------------------------------------------------------------------------------------------------------------------------------- 

Historiques

 

Créer un site gratuit avec e-monsite - Signaler un contenu illicite sur ce site