Dernière mise à jour le 09/10/16
Présentation
Transmettre plusieurs bytes sur les mêmes broches ?! c’est tout à fait possible bien sûr!! pour les exemples qui vont suivres je vais utiliser le PIC 12F675 sinon vous pouvez utiliser à la place le PIC 12F629.
Nous allons étudier le fonctionnement d’un un tableau nommé plus précisément sous le nom de array. Ce tableau aura plusieurs façon de travailler avec soit la:
- Lecture d’une valeur du tableau
- Lecture de deux valeurs du tableau
- Lecture en série de plusieurs valeurs du tableau
Un tableau est désigné par son nom exemple :
Tableau[0], ou bien si je voulais je pouvais lui donner un autre nom comme Bonjour[0]. Ensuite chaque éléments d’un tableau est numérotés de l’index départ et de l’index fin. Bonjour[0..1] ce tableau comporte donc 2 éléments soit:
Bonjour[0], et Bonjour[1].
La déclaration de cette variable puisque le tableau comporte 2 éléments sera en MikroPascal :
Bonjour : Array[2] of byte;
Lecture d’une valeur du tableau
Lorsque la déclaration de notre tableau est effectuée ainsi que la déclaration du nombre d’éléments, nous allons voir dans ce premier exemple comment lire uniquement la valeur logique situé dans le tableau[0] qui est la valeur « 1 » logique. Cette valeur sera ensuite affichée en valeur logique sur les broches du PIC 12F675.
Programme du PIC
program Valeur_Tableau;;
var Tableau : Array[2] of byte; procedure Init(); begin CMCON:=%00000111; // comparateurs OFF; TRISIO:=%00000000; // GPIO.1 config en entrée GPIO:=%00000000; ANSEL:=$00; //On désactive toutes les entrées analogiques end; procedure LectureTableau; begin Tableau[0]:=1; // lecture d’une seule valeur GPIO:= Tableau[0]; // on écrit la valeur lue dans le tableau sur toutes les broches du PIC end; Begin Init; While true do begin LectureTableau; end; end. |
La broche GP0 du PIC affiche la valeur lue interne à l’élement du tableau[0] qui correspond bien à 1 soit 1 logique.
Lecture de deux valeurs du tableau
Essayons maintenant d’afficher la valeur 2 qui correspond à « 10 » en valeur logique le programme ci-desous :
Programme du PIC
program Valeur_Tableau;;
var Tableau : Array[2] of byte; procedure Init(); begin CMCON:=%00000111; // comparateurs OFF; TRISIO:=%00000000; // GPIO.1 config en entrée GPIO:=%00000000; ANSEL:=$00; //On désactive toutes les entrées analogiques end; procedure LectureTableau; begin Tableau[0]:=10; // lecture d’une seule valeur GPIO:= Tableau[0]; // on écrit la valeur lue dans le tableau sur toutes les broches du PIC end; Begin Init; While true do begin LectureTableau; end; end. |
Il s’agit bien de la valeur numéro 2 en logique mais !!! pour 3 cela donne « 11 » en logique soit :
Programme du PIC
program Valeur_Tableau;;
var Tableau : Array[2] of byte; procedure Init(); begin CMCON:=%00000111; // comparateurs OFF; TRISIO:=%00000000; // GPIO.1 config en entrée GPIO:=%00000000; ANSEL:=$00; //On désactive toutes les entrées analogiques end; procedure LectureTableau; begin Tableau[0]:=11; // lecture de 2 valeurs qui correspond au chiffre 3 en décimal GPIO:= Tableau[0]; // on écrit la valeur lue dans le tableau sur toutes les broches du PIC end; Begin Init; While true do begin LectureTableau; end; end. |
Lecture à la chaine de plusieurs valeurs du tableau
Nous avons vu qu’il était possible de lire une ou plusieurs valeur dans le tableau en même temps. Maintenant nous allons voir comment lire les valeurs dans le tableau mais les unes après les autres ou plus précisément en série.
Le but est le suivant, plutôt que d’afficher les valeurs lues sur l’ensemble des broches du PIC, nous allons envoyer par paquet ces séries uniquement sur une seule broche du PIC 12F675, alors comment faire ? C’est ce que nous allons voir tout de suite.
Prenons l’exemple pour afficher le chiffre 2 qui s’écrit en logique « 10 ».
Afin d’accéder à un champ du tableau le point (.) permet donc d’accéder aux bits individuels du registre Tableau[0]
Programme du PIC
|
program Valeur_Tableau;
var Tableau : Array[2] of byte; iInc: byte; procedure Init();
begin CMCON:=%00000111; // comparateurs OFF TRISIO:=%00000000; // GPIO.1 config en entrée GPIO:=%00000000; ANSEL:=$00; //On désactive toutes les entrées analogiques end;
procedure LectureByte;
begin
Tableau[0]:=10; // correspond au chiffre 2 en décimal //Tableau[0]:=11; // correspond au chiffre 3 en décimal begin
for iInc := 0 to 1 do // lecture en boucle du1er bit( 0=1er bit) , lecture en boucle du 2ème bits (1=2ème bits), begin
GPIO.0:= Tableau[0].iInc; // lecture des bits les un après les autres et de les reproduire sur la broche GPIO.0 du PIC end; end;
end;
begin
Init; while true do begin LectureByte; end; end. |
Il est ainsi possible de mettre plusieurs bits dans le tableau et de lire ces bits les uns après les autres afin de pouvoir envoyer ces informations seulement sur une broche du PIC. Prenons l’exemple au nous voulons coder le chiffre 228 en binaire, il suffit de 8 bit pour pouvoir écrire 228 soit en binaire cela donne 11100100.La programmation correspond à 8 bits mais dans le programme la boucle est sur 7 bits !!! bien évidement sur 7 bits !!! puisque le zéro est compris dans la boucle (de 0 à 7 = 8 valeurs)
Programme du PIC
|
program Valeur_Tableau;
var Tableau : Array[2] of byte; iInc: byte; procedure Init();
begin CMCON:=%00000111; // comparateurs OFF TRISIO:=%00000000; // GPIO.1 config en entrée GPIO:=%00000000; ANSEL:=$00; //On désactive toutes les entrées analogiques end;
procedure LectureByte;
begin Tableau[0]:=%11100100; // chiffre 228 ecrit en binaire begin for iInc := 0 to 7 do // on scrute un à un les bits à l’aide d’une boucle begin GPIO.0:=Tableau[0].iInc; // la boucle permet de lire les bits un après l’autre end; end; end;
begin
Init; while true do begin LectureByte; end; end. |
Afin d’enfoncer plus loin le clou un petit montage électronique qui permet d’allumer les leds d’un afficheur 7 segments en utilisant un CD4094 qui est situé à cette article Afficheur 7 segments – CD4094 avec PIC 12F675
