encodeur clavier, pic16F877 et code en C !!

[Voltron]

salut,

je désire commander le PIC 16F877 avec un clavier 20 touches en utilisant l'encodeur 74C923 ,pour cela j'ai branché les pins de l'encodeur avec les colonnes et lignes du clavier et avec les pins du PIC , aussi les 2 pin OSC et KBM que j'ai relié à deux capa (1uF et 100nF)comme sur le datasheet du constructeur, mais il me reste une pin DA (data available) que j'ai branché sur l'Intérruption RB0, d'après un schéma que j'ai trouvé sur le net !mais j'ai pas trop compris son utilité dans mon cas ??

je veux que à chaque appui sur une touche, un code BCD (sortie de l'encodeur) sera envoyé au PIC qu'il interprétera en une commande et l'executera à travers ses autres pin !

pour commencer la partie programmation du PIC concernant l'encodeur j'ai défini mes entrées (PIC-ENCODEUR) comme suit :

#define A_ENC PIN_B7
#define B_ENC PIN_B6
#define C_ENC PIN_B5
#define D_ENC PIN_B4
#define E_ENC PIN_B3

et puis je veux comparer le code BCD (correspondant à une touche) avec une commande que je veux que le pic exécute)

par exemple: le code 00101 ===> activer pin RA1


est ce que je dois dans ce cas mettre les sorties binaires de l'encodeurs dans un tableau puis le comparer case par case avec les codes binaires des commandes (eux aussi mises dans un tableau ? )!!?

ou bien il existe d'autres solutions ?



ci-joint: le schéma


-----

[Voltron]

schéma
---

[Voltron]

alors, vous en dites quoi ?

[umfred]

Le signal Data Available passe à 1 quand le circuit détecte l'appui d'une touche.
Connecter ce signal sur RB0 permet d'utiliser la fonction d'interruption sur RB0 ce qui permet d'interrompre l'exécution du code en cours pour traiter l'appui de touche sur le clavier.
A priori dans ton cas, ce n'est pas indispensable (tout dépend des commandes que tu veux exécuter).

Ensuite, tu peux définir une variable de type unsigned char pour lire en une fois le portB
par exemple:

unsigned char encodeur;
...
...
encodeur=portb >> 3; // encodeur = portb décalé de 3 bits sur la gauche pour avoir directement le code avec E en bit de poids faible

Pour finir, tu peux utiliser un SWITCH pour traiter chaque valeur de l'encodeur:

switch encodeur
case 0
//instruction pour le code 0
case 1
//instruction pour le code 1
....

ou alors une succession de IF (moins élégant à mon goût).

[A voir en vidéo sur Futura]

[Voltron]

salut umfred,

Le signal Data Available passe à 1 quand le circuit détecte l'appui d'une touche.
Connecter ce signal sur RB0 permet d'utiliser la fonction d'interruption sur RB0 ce qui permet d'interrompre l'exécution du code en cours pour traiter l'appui de touche sur le clavier.
A priori dans ton cas, ce n'est pas indispensable (tout dépend des commandes que tu veux exécuter).

merci pour l'explication

Ensuite, tu peux définir une variable de type unsigned char pour lire en une fois le portB
par exemple:

unsigned char encodeur;
...
...
encodeur=portb >> 3; // encodeur = portb décalé de 3 bits sur la gauche pour avoir directement le code avec E en bit de poids faible

comment ca va corresspondre exactement aux 5 PIN RB 3,4,5,6 et 7 ??, autre chose, en code C je n'écrirais pas plutot les noms des variables que j'ai défini cad ENC_A,ENC_B,...? j'ai pas trop compris ce code !


Pour finir, tu peux utiliser un SWITCH pour traiter chaque valeur de l'encodeur:

switch encodeur
case 0
//instruction pour le code 0
case 1
//instruction pour le code 1
....

ou alors une succession de IF (moins élégant à mon goût).[/QUOTE]

c vrai c moins élégant


merci pour tes réponses !!

[umfred]

Normalement tu peux lire la valeur du port B (c'est-à-dire de RB7 (poids fort) à RB0 (poids faible) en faisant:

encodeur= portb;

car portb doit doit normalement être défini un fichier .h (qu'il faut bien sûr déclarer en entête) qui fait correspondre à une variable C "portb" la variable "portb" assembleur qui correspond aux états des pattes B7 à B0

#define "pic16f877.h" //à vérifier selon le compilateur utilisé

avec le 1er code, tu as donc l'ensemble du portb dans encodeur.
Pour n'avoir que les bits RB3 à RB7 (avec RB3 en poids faible), il faut effectuer 3 décalages vers la droite pour avoir au final une valeur comprise entre b'0000 0000' et b'0001 1111' (en valeur binaire):
Pour être plus clair:
- encodeur=portb => encodeur = [RB7 RB6 RB5 RB4 RB3 RB2 RB1 RB0]
- On décale une fois => encodeur = [0 RB7 RB6 RB5 RB4 RB3 RB2 RB1]
...
- Après 3 décalages => encodeur = [0 0 0 RB7 RB6 RB5 RB4 RB3].

J'espère que mes explications seront assez claires

PS avec ta solution, il aurait fallu faire:

encodeur=E_ENC+(D_ENC*2)+(C_ENC*4)+(B_ENC*8)+(A_ENC*16);

ce qui se traduit en assembleur par un nombre plus important de code pour arriver au même résultat.

[Voltron]

Normalement tu peux lire la valeur du port B (c'est-à-dire de RB7 (poids fort) à RB0 (poids faible) en faisant:

encodeur= portb;

car portb doit doit normalement être défini un fichier .h (qu'il faut bien sûr déclarer en entête) qui fait correspondre à une variable C "portb" la variable "portb" assembleur qui correspond aux états des pattes B7 à B0

#define "pic16f877.h" //à vérifier selon le compilateur utilisé

avec le 1er code, tu as donc l'ensemble du portb dans encodeur.
Pour n'avoir que les bits RB3 à RB7 (avec RB3 en poids faible), il faut effectuer 3 décalages vers la droite pour avoir au final une valeur comprise entre b'0000 0000' et b'0001 1111' (en valeur binaire):
Pour être plus clair:
- encodeur=portb => encodeur = [RB7 RB6 RB5 RB4 RB3 RB2 RB1 RB0]
- On décale une fois => encodeur = [0 RB7 RB6 RB5 RB4 RB3 RB2 RB1]
...
- Après 3 décalages => encodeur = [0 0 0 RB7 RB6 RB5 RB4 RB3].

J'espère que mes explications seront assez claires

PS avec ta solution, il aurait fallu faire:

encodeur=E_ENC+(D_ENC*2)+(C_ENC*4)+(B_ENC*8)+(A_ENC*16);

ce qui se traduit en assembleur par un nombre plus important de code pour arriver au même résultat.

waw génial l'explication !!


merci bcp umfred

p'tit question:

l'opérateur ">>" de décalage, c'est pas celui du C++ , ca n'a rien à voir,hein !?

car sur C++, on l'utilise pour extraire les flots des valeurs d'entrée
exple:

 cin >> n   // entrer une variable avec le clavier

je continue la programmation...

a+

[umfred]

Non rien à voir, en effet.
L'opérateur >> sert à décaler à droite (<< à gauche) les bits d'un octet (ou mot) et donc à diviser (multiplier) par 2, 4, 8, 16, 32, ...

Vérifie néanmoins que cet opérateur est bien pris en charge par ton compilateur . Dans le cas contraire, il faudra faire une division par 8 (2³) dans notre cas.

PS :
En C++, le ">>" de la ligne "cin >> n:" n'est pas un opérateur mais une affectation (comme le symbole = en fait).
Si en C++, tu fais "encodeur = encodeur >> n;" tu fera un certain nombre de décalage vers la droite (selon la valeur de n en fait).

[Voltron]

encore une petite question umfred si tu permet, je me pose une question sur le choix du type pour la variable encodeur ?
est ce une unsigned char parceque ce type défini sur 8 bits englobe les combinaisons binaires possible à la sortie de l'encodeur [xxx0 0000] à [xxx1 0011] ? ou bien plus ?
car le type short int qui est un 8 bit ferait l'affaire lui aussi, n'est ce pas ?

[umfred]

unsigned char c'est une donnée sur 8 bits et non signé quelque soit le compilateur utilisé (donc valeur de 0 à 255)

short int c'est une donnée sur 8 bits (qui peut être signé sauf si on le précède de unsigned) (donc valeur de -128 à 127 si signé , ou de 0 à 255 si non signé).

Après c'est un peu une histoire de goût et d'habitude. Rien n'empêche non plus d'utiliser un (unsigned) int qui lui peut être sur 8 ou 16 bits selon le compilateur.
En plus, en déclarant en (unsigned) char on est sûr de ne réserver qu'un octet quelque soit le compilateur utilisé.

Tu peux, si tu le veux, tester les 2 types en créant les variables unsigned short int encodeur_entier et unsigned char encodeur_car et en effectuant les mêmes opérations sur ces 2 variables (encodeur_car=portb>>3; encodeur_entier=portb>>3 .
Tu constatera sûrement peu de différences dans le code assembleur généré.

[Voltron]

unsigned char c'est une donnée sur 8 bits et non signé quelque soit le compilateur utilisé (donc valeur de 0 à 255)

short int c'est une donnée sur 8 bits (qui peut être signé sauf si on le précède de unsigned) (donc valeur de -128 à 127 si signé , ou de 0 à 255 si non signé).

Après c'est un peu une histoire de goût et d'habitude. Rien n'empêche non plus d'utiliser un (unsigned) int qui lui peut être sur 8 ou 16 bits selon le compilateur.
En plus, en déclarant en (unsigned) char on est sûr de ne réserver qu'un octet quelque soit le compilateur utilisé.

Tu peux, si tu le veux, tester les 2 types en créant les variables unsigned short int encodeur_entier et unsigned char encodeur_car et en effectuant les mêmes opérations sur ces 2 variables (encodeur_car=portb>>3; encodeur_entier=portb>>3 .
Tu constatera sûrement peu de différences dans le code assembleur généré.

mille merci pour tes éclaircissements umfred


pour l'info, le compilateur que j'utilise est le PCW de CCS !! IDE version 3.36 (2002)

[Voltron]

Ensuite, tu peux définir une variable de type unsigned char pour lire en une fois le portB
par exemple:

unsigned char encodeur;
...
...
encodeur=portb >> 3; // encodeur = portb décalé de 3 bits sur la gauche pour avoir directement le code avec E en bit de poids faible

Pour finir, tu peux utiliser un SWITCH pour traiter chaque valeur de l'encodeur:

switch encodeur
case 0
//instruction pour le code 0
case 1
//instruction pour le code 1
....

ou alors une succession de IF (moins élégant à mon goût).

j'ai utilisé le registre portb mais mon compilateur l'a ignoré !!

et même l'affectation

encodeur=E_ENC+(D_ENC*2)+(C_ENC*4)+(B_ENC*8)+(A_ENC*16);

n'a pas marché lors de la simulation sur Isis !!

voici le code que j'ai écris :

#include <16F877.h>
#use delay(clock=4000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
#include <input.c>


#define A_ENC  PIN_B3
#define B_ENC  PIN_B4
#define C_ENC  PIN_B5
#define D_ENC  PIN_B6
#define E_ENC  PIN_B7

#define A1 PIN_A1
#define A2 PIN_A2
#define A3 PIN_A3

void main ()
{

unsigned char encodeur;


//encodeur=portb >> 3 

encodeur = 00000000;

encodeur = A_ENC+(B_ENC*2)+(C_ENC*4)+(D_ENC*8)+(E_ENC*16);

printf("%u",encodeur);


switch (encodeur) {

case 00000001 :
 output_high(A1);

case 00000010 :
 output_high(A2);

case 00000011 :
 output_high(A3);
}


}

et puis je me pose une question sur mon code:
Est ce qu'il est possible de comparer (affecter) un nombre binaire de 8 bits avec (à) une variable de type unsigned char sans avoir à convertir l'un d'eux ??

encodeur = 00010001

ca s'écrit ??


si quelqu'un pourrait me corriger !?

[invite03481543]

Salut,

encodeur = 00010001 est une écriture décimale et non binaire, c'est comme si tu avais écrit encodeur = 10001 (dix mille un).

en binaire:

encodeur = 0b00010001

en Hexa:

encodeur = 0x11

[umfred]

Il semblerait que pour lire un port avec CCS, il faut utiliser l'instruction input_b() pour le port B; ce qui donnerait :

encodeur=input_b();

Autre chose, il faut définir quels bits sont en entrée ou en sortie (avec les instruction set_tris_b() et set_tris_a()) et également désactiver l'analogique sur le port A avec setup_adc_ports().

(voir dans le manuel de CCS)

pour la définition de encodeur, utilise seulement char (a priori le unsigned est ignoré par le compilateur (liste des types en page 33 du manuel )

[Voltron]

je vous remercie Hulk et umfred pour vos réponses pertinentes !
d'après la page 158 du manuel de CSS , et comme a écrit umfred, on affecte l'entrée des ports b (les 8 ) grâce à la commande input_b(), cependant j'ai pas trouvé sur le manuel comment utiliser seulement certains pins du b, en l'occurence RB3,RB4,RB5,RB6 et RB7 !!

je met quoi comme parammètre ? : input_b( ??)

[Voltron]

une idée ?