Fonction pour affichage sur LCD en I2C

[Jérémy]

Bonsoir à tous,

Je suis assez satisfait, de ma première fonction disons "opérationnelle" et surtout de moi ( pas recopiée et modifiée).

Si quelqu'un à le temps d'y jeter un œil de corriger et/ou d’améliorer avec des commentaires, ce serait sympa.

Ne prêtez pas attention aux fonctions qui "efface l'écran" et celle qui "initialise l'écran" .

Le principe :
Quand on souhaite écrire du texte , on lance la fonction qui va bien , en envoyant les paramètres de ligne ( 1 ou 2) de colonne ( qui correspond au début du texte de 0 à 15) , et le texte .

Ensuite ça fais le reste .

Code : Tout sélectionner

/*##################################################################################
##############################     Variable / Constante    ##########################
###################################################################################*/
unsigned int i,j;               // Variable
char LCD_ADR = 0x74;            // Adresse de l'esclave I2C
char ligne,colonne, position;   // Déclaration variable

sbit LED_RA4 at LATA4_bit ;     // Déclaration de la led sur RA4

char *text;                     // Création d'un pointeur nommé text


void efface_ecran();            // Déclaration de la fonction pour effacer l'écran
void Display_init();            // Déclaration de la fonction pour initialiser l'écran

/*##################################################################################
###########################    AFFICHAGE DU TEXTE    ###############################
##################################################################################*/
void  affiche_txt (char ligne, char colonne, char *text)   // Fonction avec paramètres d'entrées
    {
        if (ligne==1) position = 0x80 + colonne;  // On détermine la position sur la ligne 1
        if (ligne==2) position = 0xC0 + colonne;  // On détermine la position sur la ligne 2

        I2C1_Start();                // Ouverture d'une Com I2C
        I2C1_Wr(LCD_ADR);            // Envoi de l'adresse esclave
        I2C1_Wr(0x00);               // Byte de contrôle pour envoyer une instruction
        I2C1_Wr(position);           // INSTRUC : position de l'ADDR du curseur 
        I2C1_Repeated_Start();       // Répétition de l'ouverture de la com I2C
        I2C1_Wr(LCD_ADR);            // Envoi de l'adresse esclave
        I2C1_Wr(0x40);               // Byte de contrôle pour envoyer une DATA

         i=0;                        // Raz de i
         while (  text[i] != '\0' )  // Temps qu'on est pas la fin du texte on continue
          {
            I2C1_Wr( 0x80 + text[i++] );    // Écriture de la lettre ou pointe le pointeur
          }

         Delay_ms(10);                      // Pause de 10ms
        I2C1_Stop();                        // Fin de l'I2C
      }

/*##################################################################################
############################   PROGRAMME PRINCIPAL    ##############################
##################################################################################*/
void main ()
{
  TRISA = 0b11101111 ;    // RA4 en sortie  pour la led
  ANSELA=0;               // Configure en digital
  LED_RA4 = 0 ;           // On éteint la LED

  TRISC = 0b10111101 ;    // RC1 output ,RC3,RC4 as input
  ANSELC=0;

  I2C1_Init(100000);      // Initialisation de l'I2C
  Delay_ms(100);          // Pause de 100 ms

  Display_init();        // Initialise et configure l'écran

  efface_ecran();        // Efface l'écran ( remplis l'écran avec des blanks)

  //##########################   BOUCLE INFINIE   ##################################
  while(1)
  {
    affiche_txt (1,0,"Hello");      // Sur la 1 ligne, colonne 0 on écrit le texte
    affiche_txt (2,7,"World !!!");  // Sur la 2 ligne, colonne 7 on écrit le texte
  }
}


 /*##################################################################################
#########################     INITIALISATION DE L'ECRAN    #########################
##################################################################################*/
void Display_init()
    {
        Delay_ms(500);

        I2C1_Start();

        I2C1_Wr(LCD_ADR);     // Adresse de l'esclave

        // CONTROL_Mode       // bit7 -> 0=last control byte, 1=another control byte
                              // bit6 -> 0=registre inst , 1=registre Data
        I2C1_Wr(0x00);        // bit5à0 -> 0
                              // 0b00000000 = 0x00

        // function_set       // bit7 à 5 valeurs fixes : 001
                              // bit4: 0:2x4bit, 1:8 bits
        I2C1_Wr(0x34);        // bit3: 0 Non utilisé
                              // bit2: 0: 1ligne/32char, 1: 2lignes/16char
                              // bit1: 0: 1/18 multiplex, 1: 1/9 multiplex
                              // bit0: 0: standard instr., 1: extended instr.
                              // 0b00110100 = 0x34

        // display_ctl        // bit7 à  valeur fixe : 00001
                              // bit2: 0:display off, 1:display On
        I2C1_Wr(0x0C);        // bit1: 0:cursor off, 1:cursor On
                              // bit0: 0:clignotement off, 1:On
                              // 0b00001100 = 0x0C

        // Entry_mode_set     // bit7à 2: valeur fixe : 000001
                              // bit1: 0:Decremente l'adresse , 1:Incremente (curseur vers la droite)
        I2C1_Wr(0x06);        // bit0: 0:No shift , 1: Shift display
                              // 0b00000110 = 0x06

        // Extended instructions
        I2C1_Wr(0x35);        // DL: 8 bits, M: 16 by two line, SL: 1:18, H: extended instruction set

        // Disp_config        // bit7à 2: valeur fixe : 000001
        I2C1_Wr(0x05);        // bit1 : 0=left to right, 1=Right to left
                              // bit0 : 0=top to bottom  1=bottom to t

        // VLCD_SET           // Réglage du contraste  ##### OBLIGATOIRE #######
                              // bit7 : valeur fixe : 1
        I2C1_Wr(0x98);        // bit6: 0=registre VA ; 1=registre VB
                              // bit5à 0: 000000 jusqu’à 111111 pour le contraste

        // Normal instruction
        I2C1_Wr(0x34);        // DL: 8 bits, M: two line, SL: 1:18, H: normal instruction set

        I2C1_Wr(0x80);        // DDRAM Address set to 00hex

        I2C1_Wr(0x02);        // return home

        I2C1_Stop();
    }
/*##################################################################################
##############################    EFFACE L'ECRAN    ################################
##################################################################################*/
void efface_ecran()
  {
      char i = 0 ;          // Variable temporaire dans la fonction

      I2C1_Start();         // Ouverture d'une Com I2C
      I2C1_Wr(LCD_ADR);     // Envoi de l'adresse esclave
      I2C1_Wr(0x00);        // Byte de contrôle pour envoyer une instruction
      I2C1_Wr(0x80);        // INSTRUC : position de l'ADDR du curseur 1ere ligne de 80 à 8F
      I2C1_Repeated_Start();// Répétition de l'ouverture de la com I2C
      I2C1_Wr(LCD_ADR);     // Envoi de l'adresse esclave
      I2C1_Wr(0x40);        // Byte de contrôle pour envoyer une DATA
        for ( i=0;i<=15;i++)// Boucle pour répéter 16 fois l'action sur la première ligne
       {
        I2C1_Wr(0xA0);      // Envoie d'un caractère "vide"
       }

      I2C1_Repeated_Start();// Répétition de l'ouverture de la com I2C
      I2C1_Wr(LCD_ADR);     // Envoi de l'adresse esclave
      I2C1_Wr(0x00);        // Byte de contrôle pour envoyer une instruction
      I2C1_Wr(0xC0);        // INSTRUC : position de l'ADDR du curseur 2ieme ligne de C0 à CF
      I2C1_Repeated_Start();// Répétition de l'ouverture de la com I2C
      I2C1_Wr(LCD_ADR);     // Envoi de l'adresse esclave
      I2C1_Wr(0x40);        // Byte de contrôle pour envoyer une DATA
        for ( i=0;i<=15;i++)// Boucle pour répéter 16 fois l'action sur la deuxième ligne
       {
        I2C1_Wr(0xA0);      // Envoie d'un caractère "vide"
       }
    I2C1_Stop();            // Fin de l'I2C
   }

 

PS: j'avoue ne pas trop saisir la ligne suivante :

Code : Tout sélectionner

char *text; 

Je sais donc qu'on créer un pointeur qui se nomme text. Mais ensuite j'utilise text, pour ecrire mon texte . Mais un pointeur c'est l'adresse d'une variable pas une variable ? et encore moins un "char" avec une suite de lettre ça devrait être un string non ?
J'avoue avoir eu un peu de chance en voyant que ça marchait comme ça. J'aimerais bien comprendre en profondeur .

[Jérémy]

Bonjour,

Toujours en guise d'entrainement , je voulais afficher une variable, par exemple une valeur qu'on incrémenterai pour faire un compteur ( pas précis du tout).

Je n'ai pas réussis du premier coup, car dans ma routine il me faut une chaine de caractères pour être interpréter correctement.
Ceci ne fonctionne pas

Code : Tout sélectionner

   affiche_txt (2,11,j );  

Il m'a fallu donc, transformer un word ( mon compteur "j") en un string avec la fonction WordToStr . je stocke cette valeur dans une variable et la ça fonctionne. Il y as peut être plus simple mais j'ai pas trouvé .
Voila ce qui fonctionne

Code : Tout sélectionner

  //##########################   BOUCLE INFINIE   ##################################
  while(1)
  {
   WordToStr(j, variable);
   affiche_txt (2,11,variable );  // Sur la 2 ligne, colonne 12
   j = j++;
   delay_ms(1000);
  }
} 

Le texte envoyé est de forme word, donc sur 5 caractères ( 65535)

[tontonchristoba]

Bonjour jérémy,

C'est pas mal ! Juste une remarque, en langage C par convention les constantes s'écrivent en MAJUSCULE et les variables en minuscules. Mais ça ne change rien à la performance du code.

[Jérémy]

Bonsoir tontonchristoba ,

Bienvenue sur le Forum .

Je te remercie car ton pseudo montre un petit bug de l'icone pour voir si tu es ligne ou non ! . je me le note a corrigé !
Et je te re-remercie pour ce conseil fort judicieux, dont je prends note ( j'espere m'en souvenir), c'est le genre de petits détails qui sont appréciables quand on s'initie ! .
Par contre je n'ai pas déclaré de constante ? ( enfin je crois pas ) Pourrais tu précisé ?

[Guest]

Bonjour

Je voudrais aussi faire une remarque sur tes fonctions. A faire une fonction autant quelle soit la plus universelle possible c'est le but des fonctions, sinon dans le main .Exemple celle effacement écran .il doit bien avoir, une commande du contrôleur LCD, pour faire cela . s'il n'y pas cette commande ( j'ai un doute ) ,passé 2 paramètres à la fonction efface, en fonction du nb de caractères a effacer et position début mem .
Si jute un effacement ciblé il faut utiliser les fonctions positionnent et écriture;

c'est mon coté ASM le plus court ,le plus rapide


A+

[Jérémy]

Bonjour ,

Il y a bien une commande pour effacer le LCD, mais soit je n'ai pas réussis à la faire fonctionner( largement possible), soit l'effacement écrit des petits flèches ( comme si le code du caractère était décalé) : voila le lien qui en parle : lien

Concernant tes remarques elles sont très judicieuses ; Je pourrait écrire du texte ( des espaces) sur les deux lignes, ça simplifierait encore plus

[tontonchristoba]

Bonsoir Jeremy

Code : Tout sélectionner

char LCD_ADR = 0x74;            // Adresse de l'esclave I2C


C'est cette déclaration qui a attirée mon attention, je pense que ton compilateur traduit LCD_ADR en variable.
Une constante ou directive serait plus économique en terme de mémoire, tu devrais tester ça:

Code : Tout sélectionner

#define LCD_ADR 0x74            // Adresse de l'esclave I2C


A+

[Jérémy]

Tu as raison tontonchrostobal, en effet c'est interprété comme une variable, mais cela ne gêne pas pour le programme.

Je l'avais écris lors de mes nombreux tests, ou à un moment , je changeais l'adresse de l'esclave pour voir et vérifier cette fameuse adresse . J'ai donc oublié de remettre en #define.

Un œil neuf fait toujours du bien ! je vais corriger ceci dans le tutoriel, car en effet c'est plus propre de définir une constante plutôt qu'en variable.

[Guest]

bonjour

jeremy un petit lien sur la ds du lcd merci

A+

[Jérémy]

Bonjour ,

Ce post est une suite de celui ci ou bien évidemment j'avais mis la DS .
LCD en I²C avec driver PCF2119