Afficheur LCD 2X16 caractères en mode 4 bits

[invitebecbfa50]

Bonjour à tous, je suis très content de poster sur ce forum pour la première fois

J'ai pour le lycée un projet qui nécessite un afficheur LCD, contrôlé par un microcontroleur PIC.

Je n'ai pas le matériel chez moi pendant ces vacances mais je commence à réaliser le programme du PIC sur mon ordinateur.

Je souhaite commander l'afficheur avec 4 bits de données afin de gagner 4 broches sur mon PIC.

Il faut donc lors de l'initialisation de l'afficheur que je lui dise de travailler en 4 bits, mais je ne sais pas trop comment procéder :

• Je sais que le signal R/W doit être positionné à 0 pour indiquer qu'on est en écriture
• Je sais que le signal RS doit être positionné à 0 pour indiquer qu'on envoie des commandes et pas des caractères à afficher.
• Je sais que la fonction à réaliser est celle de paramétrage de l'afficheur : 001hij**

Avec h = 0 pour un fonctionnement en 4 bits
et avec h = 1 pour un fonctionnement en 8 bits

Mais comme cette instruction est codée sur 8 bits ( ou plutôt 6 je ne sais pas à quoi corresponde les deux astérisques ** ), je ne sais pas comment l'envoyer à l'afficheur...


Je vous remercie de m'avoir lu jusqu'au bout j'espère m'être bien expliqué...

Merci d'avance pour vos futures réponses !
-----

Publicité

[invite0e5af214]

Salut

Je te conseille de consulter cette page
tu devrais y trouver ton bonheur.

[invite1feace2e]

Salut,
le site de cherwam07 m'a l'air assez complet, jette un oeuil

après pour ce qui est d'envoyer 8 bits en travaillant avec des donnée de 8, c'est facile, il s'uffit de faire un décalage (t'en envois 4, puis les 4 autres après.)

Le pic doit etre un 16f84 ou un truc du genre non?

j'ai une source pour commander un afficheur 1 ligne 16 caractères en 4 bits.

voici la source des conftions que j'utilise
(désolé si ca prend de la place...
(faire un tour chez moi si jamais http://kevin.raymond.free.fr/PROJETS/ANEMO/
mais c'est pas tres bien rangé.... )

//----------------- 3 FONCTIONS PROPRE A L'AFFICHEUR ----------------- \\
/*________________________________________________________________________*/
void outcar(unsigned char oct)
{
  unsigned char val[2];
  int i;
  unsigned char flag;                                                             // Pour tester le bit BUSY (d7) de l'afficheur

    val[0] = oct & 0xf0;                                                          // Valeur sur 8 bits: d'abords les points faibles...
    val[1] = (oct <<4) & 0xf0;                                                    // ...ensuite les poids fort

    for(i=0 ;i<2 ;i++)
    {
        RS = 1;                                                                    // Mode données
        E = 0;
        RW = 0;                                                                    // Mode écriture
        PORTB = val[i];                                                            // données valides
        Pause200us(3);
        E = 1;                                                                     // Enable activé 600 us
        Pause200us(3);
        E = 0;

        TRISB = 0x81;                                                              // RB7 en entree pour tester d7
        RS = 0;                                                                    // Mode controle
        RW = 1;                                                                    // Mode lecture

        do
        {
             E = 1;
             flag = PORTB & 0x80;
             E = 0;
        }while(flag);                                                             // attente ...
        TRISB = 0x07;
    }
}



/*________________________________________________________________________*/
void out4bits(void)
{
char flag;

     E = 0;
     RS = 0;                                                                       // Mode controle
     RW = 0;
     PORTB=0x28;                                                                   // Mode 4 bits, 1 ligne
     Pause200us(3);
     E = 1;
     Pause200us(3);
     E = 0;

     TRISB = 0x81;                                                                 // RB7 en entree pour tester d7
     RS = 0;
     RW = 1;

     do
     {
        E = 1;
        flag = PORTB & 0x80;
        E = 0;
     }while(flag);                                                                 // attente ...
     TRISB = 0x07;
}

/*________________________________________________________________________*/
void outctrl(unsigned char car)
{
unsigned char val[2];
int i;
char flag;

     val[0] = car & 0xf0 ;
     val[1] = (car <<4) & 0xf0 ;

     for(i=0 ;i<2 ;i++)
     {
        E = 0;
        RS = 0;                                                                    // Mode controle
        RW = 0;
        PORTB = val[i];
        Pause200us(10);
        E = 1;
        Pause200us(10);
        E = 0;

        TRISB = 0x81;                                                              // RB7 en entree pour tester d7
        RS = 0;
        RW = 1;

        do
        {
           E = 1;
           flag = PORTB & 0x80;
           E = 0;
        }while(flag);                                                             // attente ...
        TRISB = 0x07;
     }
}

apres pour la config

 ----------------------- version fonctionnement sur 4 bits --------------------
 relier d3 du lcd a 1 et d2 du lcd a 0
 les bits d4 à d7 correspondent au bus de donnée du LCD

 -------------------------------- I/O lignes -----------------------------------
    I/O    RB7	-->	d7 lcd (Input/Output : flag fin d'écriture)
    O  	   RB6	-->	d6 lcd
    O 	   RB5	-->	d5 lcd
    O	   RB4	-->	d4 lcd

    O	   RA2	-->     E lcd
    O	   RA1	-->	r/w lcd
    O	   RA0	-->	rs lcd

 ------------------------------- Controle LCD -------------------------------
    RS	RW		OPERATION
    0	0		ecriture dans le registre d'instruction et execution commande
    0	1		lecture busy flag d7 et compteur d'adresse d0-d6
    1	0		ecriture registre de donnees
    1	1		lecture registre de donnees

 ----------------------------- INSTRUCTION LCD -----------------------------------
avec RS et RW a 0 : ( x=indifferent )

    00000001		efface l'écran
    000001ab            avance curseur : shift display b=1 , increment a=1 decrement a=0
    00001cde	        activation affichage : c=display d=curesur e=clignotement
    0001fgxx		decalage affichage ou deplacement curseur : f=1 decalage f=0 curseur g=0 a gauche g=1 a droite
    001hi0xx		h=1 => 8bits  , h=0 => 4bits ;i=1 => 2 lignes i=0 => 1 ligne
**

mes definitions pour plus de lisibilités :

#define RS         RA0
#define RW         RA1                 // lignes de controle du LCD
#define E          RA2
#define BF         RB7                 // flag fin ecriture

voila, c'est une source qui marche, mais que t'a plus qu'a adapter a ton environnement (actuellement je l'adapte pour mon 2 lignes 16 caractères.. mais 8 bits! (a moi le 16f877!!))

ca c'est la configuration "minimal" apres ca voir par exemple http://kevin.raymond.free.fr/PROJETS/ANEMO/testAff/
pour des sources avec des exemples (j'ai pas mis dés le début parce que ca doit être moins commenté...)
apres verification, mes lignes sont pas très bien commentée (bizarre... )

Attention, je travail avec les interruption timer suivant la version de mes sources...


plus d'explication? je suis par la (normalement...)
J'ai l'habitude de pas etre très claire...

si jamais, il est possible de se faire des programmateur facile et pas cher

[invitebecbfa50]

Merci beaucoup ! J'ai regardé et compris la manière dont ils nous disent d'initialiser le LCD en mode 4 bits, mais je ne comprends pas trop l'exemple ( tout en bas de la page )

Moi j'aurais tendance à faire comme ça :

3h 3h
-> Interprété comme 33h en mode 4 bits et comme 30h 30h en mode 8 bits
( le répéter plusieurs fois pour être sur )
Que le LCD recoive 33h ou 30h il s'ent configuré en mode 8 bits.

Puis on lui envoit 2h qu'il va comprendre comme 20h et il va se mettre en mode 4 bits.

Puis on peut faire ce qu'on veut on est sur d'être en mode 4 bits




Ca vous parait correct ?

[A voir en vidéo sur Futura]

[invitebecbfa50]

PS : Je viens de voir le 2eme message ^^

Je vois que tu écris en C, langage que je connais assez bien, mais je ne sais pas comment le compiler pour un 16f84... Ou pour tout 16f.. d'ailleurs, comment fais tu ?
J'ai bien testé avec SDCC mais à chaque fois à la compilation du .asm généré à partir du .c il y avait une erreur du type "Cette instruction ne peut être utilisé que pour générer des fichiers objets" ( en anglais ^^)

Comment compile tu ?

[invite1feace2e]

ouais j'ai vu que j'avais repondu juste avant

oups, j'etais persuadé que c'était en c que tu compilais
Je compile avec cc5x : rapide et simple, mais bon, limité a 2ko (ou 1ko...) néamoins suffisant pour un 16f84

tu travails en asm pour les PIC?
(dans ce cas je peux pas 'taiser, je me dis qu'il faut que je m'y mette un jour mais bon... )

[invitebecbfa50]

Ouais je programme en Assembleur mais c'est par défaut parceque je ne connaissait pas de moyen de compiler le C, je vais regarder ton compilateur, merci !

[invite1feace2e]

bah de rien! c'est tellement plus simple en C
dommage que Bigonoff n'est pas fait ses cours en C aussi

tu peux aller voir la si tu veux : http://kevin.raymond.free.fr/Exe_carte_pic/

ya cc5x et context (context c'est un editeur auquel on ajoute le compilateur et le programmateur)
normalement tu telecharges le repertoir et c'est tout configuré. (bon, pas besoin de mes sources lol, j'attend le printemps pour faire le menage )

[invite2aeb1d0b]

Bonjour à vous , je vois que vous êtes assez expert pour répondre à ma question bête ; mon programme dit "#define AFF PORTB" en 8 bit pour l'afficheur , je veux le passer en 4 bit:
#define AFF PORTB
#define RS PORTC,0
#define RW PORTC,1
#define E PORTC,2
J'ai donc ecris pour l'adapter ;
#define AFF PORTB ,4,5,6,7
#define RS PORTB,0
#define RW PORTB,1
#define E PORTB,2
#define BF PORTB,7; n'y a t il pas une contradiction avec l'instruction ci dessus " si PORTB = val[i]" et la valeur AFF ou dois le la mettre ," aff=I "???
aider moi svp