Reprise du message précédent :
Bonjour a tous
 
les exemples C de mon site sont simples pour être compris plus facilement afin de faire évoluer le code en fonction de vos besoins.
 
simple aussi, car cela prend moin de place dans le PIC  
c'est important.
 
le code ci-dessous extrait d'un de mes tutorials
fonctionne avec le compilatur HI-TECH
 
si vous essayez de placer cette fonction sur CodeVisionAvr
elle ne fonctionne pas il faut modifier le code.
 

 
très cordialement
Angeliz

Salut,
 
je suis en train d'essayer de gérer l'affichage sur un lcd 2x8 en mode 4bits avec un pic 16F73 (assez proche du 16F84). Après lecture des divers post je n'arrive pas à adapter le code fourni en c.
 
y aurait il quelqu'un pour me filer un coup de main ou mettre sur la piste ?
 
pour info voici mes brochages :  
RC0 : RS
RC1 : E
RA0 : Data7
RA1 : Data6
RA2 : Data5
RA3 : Data4

visiblement, le code du début du topic fonctionne déjà en 4 bit

Bonsoir
 
eh oui paf,comme moi a mes début et apres lecture du datasheet la lumiere fut.....
 
ton portA par defaut il est comment sur le 16F873??  
 
réponse: en mode analogique  
donc cela ne peu fonctionner
 
solution le mode digital se configure comme cela  
 
ADCON1=6;  // PORT A passe en mode digital  
 
bon test  
 
Cordialement

merci pour l'info !
 
est-ce que la syntaxe suivante est bonne (car une partie de mon port A sert aussi a d'autre choses)
 
#define pins PORT.0,PORTA.1,PORTA.2,PORTA.3 ; //DB7,DB6,DB5,DB4
#define Lcd_E RC1=1;asm("nop" );asm("nop" );RC1=0;  
#define Lcd_RS RC0;
 
 
-------------
et pendant que j'y suis j'aimerais comprendre comment marche cette fonction :
b3=cVar & 0b11110000;   // envoi 4 bit poids fort  
pins=pins & 4;    // copie du bit lcd_E  
pins=pins | b3;  
pins=pins & 4;   // envoi 4 bits poids faible  
b3=(cVar<<4);  
pins=pins | b3;

Bonsoir  
 
vous utilisez quel compilateur  
cela ressemble a du code avr#define pins PORT.0,PORTA.1,PORTA.2,PORTA.3 ; //DB7,DB6,DB5,DB4  
 
il faut configurer le portA comme cela  
O sortie les X cela depend de ta config
TRISA=0bXXXX0000;
 
connecte les broches de ton lcd comme cela
le decalage des bits sera plus simple par la suite.
RA0 : bit 4  
RA1 : bit 5  
RA2 : bit 6  
RA3 : bit 7  
 
pour la fonction ci dessous
effectivement il faut la modifier pour faire fonctionner ton lcd
 
b3=cVar & 0b11110000;   // envoi 4 bit poids fort  
pins=pins & 4;    // copie du bit lcd_E  
pins=pins | b3;    
pins=pins & 4;   // envoi 4 bits poids faible  
b3=(cVar<<4);  
pins=pins | b3;
 
mais bon j'ai pas le temps ce soir
 
bonne soirée

J'utilise cc5x
TRISA = 0b00010000;
 
justement c'est un genre struct que j'essaye de faire avec avr#define pins PORT.0,PORTA.1,PORTA.2,PORTA.3 ;
 
Pour la fonction de decoupage bits de poids fort/faible je vais me plonger dans un bouquin de c dès que j'en aurai acheté un ! Mais bon je suis preneur de tout conseil :-)
 
Pour le brochage du lcd je n'ai pas le choix car une carte de test a deja été faite.

 
Sinon c'est un 16F73 et non 16F873 pour info.
 
Encore merci pour votre aide et attention !!!

Bonsoir
 
c'est la meme chose, le pic 16f73 est en mode analogique
par defaut c'est marqué sur le datasheet
 
ce prog fontionne avec un quartz de 4mhZ  
le pas de tmr0 doit etre de 64µS
 
Ne pas oublier le trisa
(structure inutile)  
TRISA=0b00010000; // 1 entrée, 0 sortie
(pour ra5 il faudra modifier legerement le code)
 
Cordialement

euh j'ai ça comme message :
 
{  
        if(!(cVar & 128)) cNewVar  &= ~(1 << cL);                                                                       ^------
Error[1] lcd2.h 41 : Unable to generate code  (The C syntax is correct. However, CC5X is unable to generate code.
 The workaround is often to split the code into simpler statements,
 using an extra variable to store temporary results. Sometimes it is
 enough to change the sequence of operations)
 
ça peux marcher ça ? :
     for(cL=0;cL<=7;cL++)  
 {  
        masque = (1 << cL);
        cNewVar &= cVar & masque;  
 }  
PS : est-ce que je peux vous envoyer ça par mail pour eviter de "polluer" ce forum

Bonsoir
 
eh oui cette formule met CC5x KO.  
je compile cela sous picc 8.01PL3, logiciel utilisé dans l'industrie,  
et cela passe sans problême... trop bien picc de HI_TECH
il met quand meme 160µs pour faire la transformation
de l'octet.
 
ce type de posts ne pollue pas un forum
car ils sont utiles et instructifs.
 
voici l'adresse de mon site
http://angeliz.free.fr il y a un forum sur le langage C
sur PIC et AVR
 
mise à jour le 21 10
 
avec ceci CC5x ne vas pas faire d'erreur  
de plus temps de calcul de la boucle optimisé a 84µs (pic 4mhz)
simulation fait avec MPLAB 6.61
 
  unsigned char cNewVar,cVar2;  
  cVar2=cVar;  // evite de modifier cVar
  cNewVar=0;
  cL=7;
  do{
    cNewVar<<=1;
    if(cVar2 & 1) cNewVar |=1;
    cVar2 >>=1;
    }while(cL-- !=0);
   PORTA=cNewVar;  // place les 4 bits de poids fort
   .....  
 
 
Cordialement

C'est bon comme ça ?
(et pendant que j'y suis comment ça marche ce décalage Var<<=1 ?)
 
/********************************************************
| Projet : Affichage sur écran LCD 2x8 en 4bits
| Date : 22/10/2004                                    
| Auteur  : Angeliz (http://angeliz.free.fr/)            
| Modification : Charly_md                              
|                                                
| Microcontrôleur     : PIC 16F73                        
| Clock frequency     : 4,000000 MHz                    
| Specificitées Pattes lcd : D4=RA3,D5=RA2,D6=RA1,D7=RA0  
********************************************************/
 
 
//Define de ports
  bit Lcd_RS@PORTC.0 ;
 
//Variables globales
  unsigned char cL;
 
//Fonctions  
  void Lcd_E(void);
  void Efface_LCD(void);  
  void Ligne_LCD(char cLigne);  
  void Efface_LigneLCD(char cEff);  
  void wr_Lcd(unsigned char cVar,unsigned char cLcd_RS);  
  void Ini_Lcd(void);  
  void Tempo(char ti); // temporisation  
 
   
//---------initialisation LCD--------  
  void Ini_Lcd(void)  
  {  
      PORTA=0;
      Lcd_RS=0;  
      for(cL=0;cL<2;cL++) {TMR0=1; while(TMR0 != 0);} //32ms  afficheur  
         
      PORTA = 0b1100; //Mode 4 bits //0b0011
      Lcd_E();  
      Tempo(254);
      Lcd_E();  
      Tempo(254);
      Lcd_E();
      Tempo(254);    
      PORTA = 0b0100;  //0b0010
      Lcd_E();
      Tempo(254);  
 
      wr_Lcd(0b00101000,0);     // Mode 2 lignes  
      wr_Lcd(0b00000001,0);     // Efface l'affichage initialisation  DD-ram  
      wr_Lcd(0b00001100,0);     // Affichage des caractères de gauche à droite et curseur se déplace  
      wr_Lcd(0b00000110,0);     // Déplacement vers la droite  
       
  }  
 
//fonction ecriture message/commande    
  void wr_Lcd(unsigned char cVar,unsigned char cLcd_RS)      
   {    
  unsigned char cNewVar;
  cNewVar=0;  
  cL=7;  
  do{  
    cNewVar<<=1;  
    if(cVar & 1) cNewVar |=1;  
    cVar >>=1;  
    }
  while(--cL !=0);  
   PORTA=cNewVar;  // place les 4 bits de poids fort  
 
    Lcd_E();  
    if((cVar>2) && (Lcd_RS==0)) TMR0=255; // tempo 86µs  
    else TMR0=228;                         // tempo 1,7ms    
    while(TMR0 != 0);      
    }  
   
//fonction temporisation
   void Tempo(char ti)  
   {  
     TMR0=ti;  
     while(TMR0 != 0);  
   }  
   
//fonction choix d'une ligne du lcd
   void Ligne_LCD(char cLigne)  
   {  
     if(cLigne==1) wr_Lcd(0x80,0); // afficheur ligne 1  
       else if (cLigne==2) wr_Lcd(0xC0,0); // afficheur ligne 2  
     }  
     
//fonction pour effacer une ligne du lcd
   void Efface_LigneLCD(char cEff)  
   {  
     if(cEff==1)  
      {    
        wr_Lcd(0x80,0);      // set DDRAM passe 1 ere ligne  
        for(cL=0;cL<=15;cL++)wr_Lcd(0x20,1);  // affiche des espaces  
      }  
           
     if(cEff==2)  
      {    
        wr_Lcd(0xC0,0);      // set DDRAM passe 2 eme ligne  
        for(cL=0;cL<=15;cL++)wr_Lcd(0x20,1);  // affiche des espaces  
      }        
   }  
 
//fonction pour effacer tout le lcd    
  void Efface_LCD(void)  
   {  
      wr_Lcd(1,0);  
   }    
 
//Fonction Valide
 void Lcd_E(void)
 {
 PORTC.1=1;
 TMR0=255;  
     while(TMR0 != 0);  
 PORTC.1=0;  
 }

Bonjour,
 
cNewVar<<=1  est equivalent a: cNewVar= cNewVar<<1  
on fait un décalage de l'octet de 1 bit vers la gauche
ex: avant 0001 0001 decalage->  0010 0010
 
cNewVar= cNewVar<<3  décalage de trois bits vers la gauche
ex: avant 0001 0001 decalage->  1000 1000
 
 
voila la fonction complête
 
void wr_Lcd(unsigned char cVar,unsigned char cLcd_RS)      
   {    
    unsigned char cNewVar,cVar2;  
    Lcd_RS=cLcd_RS; // ligne mis a jour le 3 /11 existe mon prog du   début
    cVar2=cVar;  // evite de modifier cVar  
    cNewVar=0;  
    cL=7;  
    do{  
      cNewVar<<=1;  
      if(cVar2 & 1) cNewVar |=1;  
      cVar2 >>=1;  
      }while(cL-- !=0);  
    PORTA=cNewVar;  // place les 4 bits de poids fort  
    Tempo(255);  
    PORTA=cNewVar>>4; // place les 4 bits de poids faible  
       
    Lcd_E;  
    if((cVar>2) && (Lcd_RS==0)) TMR0=255; // tempo 86µs  
    else TMR0=228;                         // tempo 1,7ms    
    while(TMR0 != 0);      
    }
 
j'ai modifier le code cVar 2 18h46
compile test et donne le résultat
bye

 
euh, juste comme ça, théoriquement il te faut une pulse sur enable a chaque quartet que tu envois, ce qui n est pas le cas.
 
 
grosso modo ça donne
 
send2lcd(unsigned char data, unsigned char registre)
{
    unsigned char buffer = 0;
    if(registre == 0)// acces au registre de commandes
    RS = 0;
    else //acces au registre de données
    RS = 1;
    buffer = data & 0x0F; //masque le quartet de poids faible
    data = data & 0xF0 ;  // masque le quartet de poids fort
    data = data >> 4;     //on deplace le quartet en LSB
    PORTA = data;         //transfert du quartet de poids fort
    lcd_delay();          //délais de stabilisation des données
    EN = 1;
    lcd_delay();          //délais d'impulsion EN
    EN = 0;
    PORTA = buffer;       //transfert du quartet de poids faible
    lcd_delay();          //délais de stabilisation des données
    EN = 1;
    lcd_delay();          //délais d'impulsion EN
    EN = 0;
}
 
ou lcd_delay génere une tempo pour l impulsion du signal Enable

 
et mettre RS au haut niveau avant d'envoyer des données

c est dans mon code

 
 
c'est dans le tiens mais je le vois pas dans le siens

 
 
par contre, pour passer un "mode" de fonction en paramètre on peux faire ça plus classe
 
genre :

 
comme ça on est sur de n'avoir que CMD_MODE ou DATA_MODE en paramètre, et aucun risque de se retrouver avec un paramètre farfelut qui pourrait êter mal gérer

tu peux pas te retrouver avec un parametre farfelu car la variable =0 c est une commande et > 0 c est une donnée!
de plus on travaille en microcontrolleur donc au plus simple.
sinon on peux aussi faire un DEFINE DATA 1 et COMMAND 0 ou meme faire un flag enregistré dans un bit en mémoire
genre
sbit lcd_instruction = 0;
et tu le mets à 1 ou 0
car RS est un bit, pas un octet.

la logique de travailler avec soit 0 soit pas 0 est pê simple mais source d'erreur
et faut jamais compter sur le programmeur, même si c'est soit même, pour ne pas faire ces erreurs
 
faire un typedef enum évite de se tromper à d'autre endroit dans le code, et surtout permet au compilo de comprendre le sens de ce paramètre
 
faire un typedef enum ne complique pas le code que le µC aura à traiter, ça sert uniquement au programmeur et au compilo
au final, pour le µC ça revient au même
 
quand à passer par les define, les enum sont moins lourd à mettre en place, et on peux pas faire de typedef avec des valeurs de define

oki
en tout cas mon compilateur (keil et qui est deja complexe) limite l utilisation de tels parametre ainsi que l allocation dynamique de mémoire.

erf, c'est pour sa que j'aime pas les compilos de µC

Bonsoir
 
vous n'avez pas analysé correctement mon prog
le E est aussi dans la fonction Tempo.
Pour le RS j'ai oublié de le replacer , car il existe dans mon prog au début de ce chapitre.
 
Cordialement  
Angeliz

tu as édité a 20h55?

Bonsoir
 
Genesis pour le RS oui
 
Cordialement

ce n'est pas réellement sa place dans Tempo

Bonsoir
 
c'etait pour economiser des lignes de code Deadog
genesis ton code ne fonctionne pas pour le cas de charly-md
 
Cordialement
 

mon code ne fonctionne pas? comment ça? à quel endroit? car c est ce que j utilise pour un acces LCD 4 bits hd44780

Bonsoir
 
il ne suffit pas dans le cas de charly_md
de faire un decalage de bit vers la droite
faut aussi modifier le position des bits
 
exemple variable a envoyer en binaire
0001 0101
tu envois en premier 0101 puis 0001  
 
ce qui est bon si d7 (lcd) est relié au bit 3 du quartet
mais d7 du lcd est relier au bit 0 du quartet
 
la modif de mon code modifie cela.
 
pour ma part je n'ai pas eu prof pour concevoir mes progs
pas eu cette chance...
je suis autodidacte et un passionné des pic,
donc désolé si ma façon de concevoir mes progs vous  
interpelle un peu.
 
 bonne soirée a tous
 
cordialement

 
 
c'est une question de logique
on ne met pas le enable dans une fonction qui gére un temps
 
j'ai n'ai pas eu plus de prof que toi pour apprendre

Bonsoir
 
rien a voir avec la logique
regarde le post plus haut j'ai deja répondu a ta question
 
Cordialement
 

eh ben, apprend qu'on économise pas de ligne de code quand la lisibilité est en jeu ^^

Bonjour  
 
c'est ton avis pas le mien,  
mais mon code est bien lisible si on se donne la peine
de l'étudier et non de lire en diagonale.
 
Cordialement

mais on ne devrait à se donner de la peine plus qu'il n'en faut pour comprendre un code

quand on donne une valeur binaire, on donne du MSB a gauche au LSB a droite, donc D7 -> D0 là je suis d accord c est pas bon, dans ce cas pourquoi ne pas avoir optimisé les connexions?

Bonjour Genesis
 
 
dans le cas et sujet de charly_md, il nest plus possible  de modifier les connexions, car la carte est terminé.  
 
c'est pour cela que j'ai fait une mofication dans le code
de traitement des bits en direction du lcd afin d'aider charly_md.
 
bonne journée a tous
Cordialement

oki je comprends.
mais ton code fonctionne ou pas? le lcd s initialise?

bonjour Genesis
 
oui mon code fonctionne bien
il est présenté sur mon site  
 
Cordialement

 
Bonjour
 
  voila un peu d'asm pour optimiser la routine C
  afin d'adapter l'octet au portA
   
  avant:
  unsigned char cNewVar,cVar2;
  Lcd_RS=cLcd_RS;  
  cVar2=cVar;  // evite de modifier cVar  
  cNewVar=0;  
  cL=7;  
  do{  
    cNewVar<<=1;  
    if(cVar2 & 1) cNewVar |=1;  
    cVar2 >>=1;  
    }while(cL-- !=0);  
 
 
  apres modif en asm hitech:
 
  unsigned char cNewVar,cVar2;  
  Lcd_RS=cLcd_RS;  
  cVar2=cVar;  // evite de modifier cVar  
  cNewVar=0;  
 
  cL=8;
  #asm
  loop:
  rlf _cNewVar,f
  bcf _cNewVar,0
  btfsc _cVar2,0
  bsf _cNewVar,0
  rrf _cVar2,f
  decfsz _cL,f
  goto loop  
  #endasm
 
  Optimiser a 64µs c'est un peu mieux que le C
 
  au fait plus de nouvelle de charly_md ?
 
  Cordialement