LCD et PIC 16F84 (je suis perdu)

[Fred-ql]

Bonjour,

J'essai de programmer un LCD à l'aide d'un PIC 16F84.

Pour cela, j'utilise MPLAB IDE et IC-Prog. Ils fonctionnent tres bien lors de l'essai pour faire clignoter une LED par contre et malgrés les aides trouvées sur internet, je suis perdu pour arriver à afficher qq chose sur mon LCD.

Le fonctionnement retenu est en 4 bits sur un LCD 2 x 16 caractéres et j'ai retenu, pour l'instant :
RA2 = RS (sera apres RB2)
RA3 = E (sera apres RB3)
RB4 ... RB7 = DB4 ... DB7

Lors de mes essais, j'ai l'ecran du haut qui est "tout noir" et rien d'autres.

Mon code est :

// ****************************** **************
//
// programme de gestion Affichage LCD
//
// ****************************** **************

#define entree PORTA
#define sortie PORTB
#define rs RA2
#define en RA3


// délai en ms ------------------------------
void delay_ms(char millisec)
{
char TMR;
OPTION = 2;
do
{
TMR = 0; clrwdt();
while (TMR0 < 125); // limité à 255
}
while (-- millisec >0);
}

// validation envoie sur LCD ----------------
void lcd_valid()
{
delay_ms(1); en=0; delay_ms(1); en = 1;
}

// ecrit sur le LCD en mode 4 bits -----------
void lcd_write(unsigned char c, bit d)
{
rs = d; // choix entre donnée (d=1) et instruction (d=0)
sortie &=0b00001111;
W=c & 0b11110000;
sortie |=W;
lcd_valid();
sortie &=0b00001111;
c=swap(c);
W=c & 0b00001111;
sortie |=W;
lcd_valid();
}


// *******************
// programme principal
// *******************
void main(void)
{
entree = 0; sortie = 0;
TRISA = 0B0000000; // tout le port A en sortie
TRISB = 0B0000000; // tout le port B en sortie

// initialisation LCD
lcd_write (0x28, 0); // mode 4 bits
lcd_write (0x06, 0); // pas de scrolling
lcd_write (0x0C, 0); // affichage sans curseur
lcd_write (0x01, 0); // efface ecran

// affichage valeur essai
lcd_write(0b10000000, 0); // positionnement premier caractére
lcd_write(0b00110000, 1); // affiche "0"

}

J'ai essayé de le faire sous différentes manières avec toujours les codes indiqués ci-dessus, mais rien à faire.


Merci de m'indiquer ou je me suis trompé

le "lcd_write" n'est pas de moi (thank)
-----

[f6bes]

Bjr Fred,
Si tu n'obtiens pas de réponse à ton probléme,
j'ai un copain qui maitrise cela les yeux fermés.
Tu fais savoir et t'envoie son @mail via MP.
Cordialement

[invite66a6315c]

Bjr Fred,
Si tu n'obtiens pas de réponse à ton probléme,
j'ai un copain qui maitrise cela les yeux fermés.
Tu fais savoir et t'envoie son @mail via MP.
Cordialement

Bonjour,

SVP j'ai besoin d'aide pour afficher un comptage d'impultion sur un ecran LCD. et j'arrive pas a trouver sous langage C, j'en ai trouvé que sous assembleur, pour info j'ai le meme PIC 16F84.
au moment j'ai ecri le programme qui me servira de compter, Mais j'arrive pas a afficher en numerique sur un ecran LCD.

SVP aidez moi.

Merci

[invitef86a6203]

Met une tempo au reset d'au moins 15 ms, le LCD est lent à démarrer.
La séquence d'init risque d'arriver avant qu'il soit ready.

[A voir en vidéo sur Futura]

[invitef86a6203]

c=swap(c);
W=c & 0b00001111;
sortie |=W;
lcd_valid();

tu swap et fait un mask de la partie basse , elle est en haut maintenant , il n'ya que les bits forts de câblés

c=swap(c);
W=c & 0b11110000;
sortie |=W;
lcd_valid();

[invitef86a6203]

Le mask peut même être suprimé

W=swap(c);
sortie |=W;
lcd_valid();



a tester !

// ecrit sur le LCD en mode 4 bits -----------
void lcd_write(unsigned char c, bit d)
{
rs = d; // choix entre donnée (d=1) et instruction (d=0)
sortie=c & 0b11110000;
lcd_valid();
sortie=swap(c);
lcd_valid();
}

[invite66a6315c]

Bonjour,

Je te remercie beaucoup pour tes reponses, mais j'ai toujours des questions!
j'utilise le port RB0 comme entrée du signal (tout ou rien logique TTL) vers mon PIC . et mon ecran est lié a mon PIC sur les ports RB4 RB5 RB6 et RB7 .
est ce que ça a un effet sur mon programme d'affichage sur l'ecran ou pas ?

Merci .

[invite66a6315c]

Le mask peut même être suprimé

W=swap(c);
sortie |=W;
lcd_valid();



a tester !

// ecrit sur le LCD en mode 4 bits -----------
void lcd_write(unsigned char c, bit d)
{
rs = d; // choix entre donnée (d=1) et instruction (d=0)
sortie=c & 0b11110000;
lcd_valid();
sortie=swap(c);
lcd_valid();
}

Bonsoir,

je peux demander pour faire un programme, sur Le Pic, qui sert a compter des impulsions et les afficher sur un ecran LCD 8x2 chaque 10secondes ?

je vous remercie BCP

[invite66a6315c]

SVP aidez moi c'est URGENT je trouve pas un programme en C, tout les programmes sont en assembleur !!!!

Aidez moi c urgent pour ce soir !!!

Merci

[invitef86a6203]

est ce que ça affiche maintenant ?

[invitef86a6203]

TRISB = 0B0000000; // tout le port B en sortie

Si RB0 est en entrée il faut le mettre en entrée
Si 0B signifie binaire il faut 8 bits pas 7 !


TRISB = 1; // tout le port B en sortie sauf Rb0 rn entrée

[invitef86a6203]

Exemple Non testé pour pollé le port rb0 si 1 apparait on compte +1 dans count puis l'affiche en décimale

int count;
char digit[3];

count=0;

while (1)
{
 if ((PORTA & 1) == 1) // test si un pulse positif
    {
	count++;

	//converti les centaines
	digit[2]=0;
    while ( count>99)
		{
		digit[2]++;
		count = count - 100;
		}
	
	digit[2]+= 0x30; met le digit en ASCII


	//converti les dizaines
	digit[1]=0;
    while ( count>9)
		{
		digit[1]++;
		count = count - 10;
		}
	digit[1]+= 0x30; met le digit en ASCII

        ' les unités sont dans count maintenant
	digit[0]= count + 0x30; met le digit en ASCII


    while (((PORTA & 1) == 1)) ; // Attend la fin du pluse positif

    lcd_write(0b10000000, 0); // positionnement premier caractére
    lcd_write(digit[2], 1); // affiche centaines
    lcd_write(digit[1], 1); // affiche dizaines
    lcd_write(digit[0], 1); // affiche unités
    }


}

[invitef86a6203]

je considère le "int count" comme un octet dans cet exemple , peut être fallait il le déclarer comme "unsigned char".
si le int est sur 16 bits il faudra ajouter les milliers et dizaines de milliers dans la conversion , il suffit d'agrandir le buffer "digit[5]" et ajouter les 2 boucles en mettant les bons paramètres.

[invitef86a6203]

Si "unsigned int" est un 16 bits

unsigned int count;
char digit[5];

count=0;

while (1)
{
 if ((PORTA & 1) == 1) // test si un pulse positif
    {
    count++;

   //converti les dizaines de milliers
    digit[4]=0;
    while ( count>9999)
		{
		digit[4]++;
		count = count - 10000;
		}
	
	digit[4]+= 0x30; // met le digit en ASCII


    //converti les millierss
    digit[3]=0;
    while ( count>999)
		{
		digit[3]++;
		count = count - 1000;
		}
	
	digit[3]+= 0x30; // met le digit en ASCII



    //converti les centaines
    digit[2]=0;
    while ( count>99)
		{
		digit[2]++;
		count = count - 100;
		}
	
	digit[2]+= 0x30; // met le digit en ASCII


    //converti les dizaines
    digit[1]=0;
    while ( count>9)
		{
		digit[1]++;
		count = count - 10;
		}
	digit[1]+= 0x30; // met le digit en ASCII

        // les unités sont dans count maintenant
	digit[0]= count + 0x30; // met le digit en ASCII

 
    lcd_write(0b10000000, 0); // positionnement premier caractére
    lcd_write(digit[4], 1); // affiche dizaines de milliers
    lcd_write(digit[3], 1); // affiche milliers
    lcd_write(digit[2], 1); // affiche centaines
    lcd_write(digit[1], 1); // affiche dizaines
    lcd_write(digit[0], 1); // affiche unités
 
   while (((PORTA & 1) == 1)) ; // Attend la fin du pulse positif

   }


}

[invitef86a6203]

if ((PORTA & 1) == 1) // test si un pulse positif

Erreur, On a dit portB pas le portA;

if ((PORTB & 1) == 1) // test si un pulse positif

[invite66a6315c]

Bonsoir,

Merci Beaucoup, mais serieusement a force que je suis nul, je trouve des difficulté a comprendre ton programme ! c'est comme meme compliquer pour un debutant (Moi).

mais j'ai un probleme c'est que j'ai l'entrée et aussi les sorties sur les ports B (RB0 : entrée :et/; et RB5 ; RB6 , 7 , 8 en sorties)

Merci beaucoup.

[invite66a6315c]

Bonsoir,

Merci Beaucoup, mais serieusement a force que je suis nul, je trouve des difficulté a comprendre ton programme ! c'est comme meme compliquer pour un debutant (Moi).

aufait on aura besoin que des centaines donc pas besoin d'aller jusqu'a digit[5] surtout que j'ai qu un ecran de 8x2 !! donc pa trop d place !!! merci

mais j'ai un probleme c'est que j'ai l'entrée et aussi les sorties sur les ports B (RB0 : entrée :et/; et RB5 ; RB6 , 7 , 8 en sorties)

Merci beaucoup.

[invitef86a6203]

TRISA = 0B00000001; // tout le port A en sortie
TRISB = 0B00000001; // tout le port B en sortie

je met RA0 et RB0 en entrée le (1)

Le principe est simple, on test l'entrée si la tension monte ( 1 logique) alors on incrémente le compteur "count". (qui repassera à 0 une fois son maximum atteind)
a la fin du traitement on attend que le 1 de l'entrée ai disparu , afin de ne pas compter plusieurs fois un seul pulse.

Dans un même temps on convertit la valeur binaire en décimale , pour cela on divise par une puissance de 10.
un octet donne de 0 à 255 donc il y a des centaines, des dizaines et des unités.
Une fois soustrait n fois , le n donne le chiffre , mais pour l'afficher il doit être en ASCII.
En ASCII le 0 c'est 0X30 , 1 c'est 0X31 , etc...
Il suffit alors d'ajouter 0X30 au chiffre pour avoir un caractère ASCII et pouvoir l'afficher.
Il ne reste plus qu'a envoyer les 3 caractères pour un octets ou les 5 pour un int de 16 bits.

[invitef86a6203]

aufait on aura besoin que des centaines donc pas besoin d'aller jusqu'a digit[5] surtout que j'ai qu un ecran de 8x2 !! donc pa trop d place !!! merci

Vérifier la taille du type !
s'il fait 8 bits ou 16 bits ou autre , cela dépend du compilateur.

ou alors mettre une limite haute , pour être sur , comme ceci;
if (count > 200) count=0;

la comparaison > est recommandé par rapport au == , si la logique le permet.

[invite66a6315c]

Bonjour Pat,

Merci pour vos aides, ca ma vraiment aider et merci encore pour l'explication j'en avai besoin pour etre sûr de ce que j'ai compri, Merci beaucoup
Donc mon programme final que je vais presenter est :




#include<stdio.h>
#include<stdlib.h>

List p=16F84
#include<p16F84>


main()
{
int cont;
int contsec;
char digit[3];
TRISA = 0B00000001; // tout le port A en sortie
TRISB = 0B00000001; // tout le port B en sortie
{
cont=0;
contSec=0;

void(1000);

while (1)
{
if ((PORTB & 1) == 1) // test si un pulse positif
{
cont++;
if (cont > 999) count=0 ;
else
//convertion des centaines

digit[2]=0;
while ( cont>99)
{
digit[2]++;
cont = cont - 100;
}

digit[2]+= 0x30; // met le digit en ASCII


//convertion des dizaines

digit[1]=0;
while ( cont>9)
{
digit[1]++;
cont = cont - 10;
}

digit[1]+= 0x30; // met le digit en ASCII

// les unités sont dans count maintenant

digit[0]= cont + 0x30; // met le digit en ASCII


while ((PORTB & 1) == 1)) ; // Attend la fin du pluse positif
if(contSec==10)
{
lcd_write(0b10000000, 0); // positionnement premier caractére
lcd_write(digit[2], 1); // affiche centaines
lcd_write(digit[1], 1); // affiche dizaines
lcd_write(digit[0], 1); // affiche unités
contSec=0;
}
}
}

[invite66a6315c]

Bonjour Pat,

Merci pour vos aides, ca ma vraiment aider et merci encore pour l'explication j'en avai besoin pour etre sûr de ce que j'ai compri, Merci beaucoup
Donc mon programme que je vais presenter ; sachant que le signal rentre sur le port RB0 ; est :

#include<stdio.h>
#include<stdlib.h>

List p=16F84
#include<p16F84>


main()
{
int cont;
int contsec;
char digit[3];
TRISA = 0B00000001; // tout le port A en sortie
TRISB = 0B00000001; // tout le port B en sortie
{
cont=0;
contSec=0;

void(1000);

while (1)
{
if ((PORTB & 1) == 1) // test si un pulse positif
{
cont++;
contSec++;

if (cont > 999)
{
count=0 ;
}
else

//convertion des centaines

digit[2]=0;
while ( cont>99)
{
digit[2]++;
cont = cont - 100;
}

digit[2]+= 0x30; // met le digit en ASCII


//convertion des dizaines

digit[1]=0;
while ( cont>9)
{
digit[1]++;
cont = cont - 10;
}

digit[1]+= 0x30; // met le digit en ASCII

// les unités sont dans count maintenant

digit[0]= cont + 0x30; // met le digit en ASCII


while ((PORTB & 1) == 1)) ; // Attend la fin du pluse positif
if(contSec==10) // je veux faire un compteur pour que l'ecran affiche qu'après 10 secondes
{
lcd_write(0b10000000, 0); // positionnement premier caractére
lcd_write(digit[2], 1); // affiche centaines
lcd_write(digit[1], 1); // affiche dizaines
lcd_write(digit[0], 1); // affiche unités
contSec=0;
}
}
}

[invite66a6315c]

On peut faire le comptage comme j'ai modifié sur le programme ci-dessous ou on peut pas ?
(je peux pas tester mon programme excusez-moi)

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

List p=16F84
#include<p16F84>


main()
{
int cont;

char digit[3];
TRISA = 0B00000001; // tout le port A en sortie
TRISB = 0B00000001; // tout le port B en sortie
{
cont=0;

clock_t start, end;
double elapsed;

start = clock() ; // debut de comptage


void(1000);

while (1)
{
if ((PORTB & 1) == 1) // test si un pulse positif
{
cont++;
contSec++;

if (cont > 999)
{
count=0 ;
}
else

//convertion des centaines

digit[2]=0;
while ( cont>99)
{
digit[2]++;
cont = cont - 100;
}

digit[2]+= 0x30; // met le digit en ASCII


//convertion des dizaines

digit[1]=0;
while ( cont>9)
{
digit[1]++;
cont = cont - 10;
}

digit[1]+= 0x30; // met le digit en ASCII

// les unités sont dans count maintenant

digit[0]= cont + 0x30; // met le digit en ASCII


while ((PORTB & 1) == 1)) ; // Attend la fin du pluse positif

end = clock() ; // arret du comptage
elapsed = ((double)end - start )/ CLOCKS_PER_SEC ; // conversion en secondes
if (elapsed == 10)
{
lcd_write(0b10000000, 0); // positionnement premier caractére
lcd_write(digit[2], 1); // affiche centaines
lcd_write(digit[1], 1); // affiche dizaines
lcd_write(digit[0], 1); // affiche unités
contSec=0;
}
}
}

[invitef86a6203]

if (cont > 999)
{
count=0 ;
}
else

S'il s'agit dun octet on ne peut pas depasser 255 !

le else sans accolade ne prend que la lihgne du dessous
le retirer carrément !

[invitef86a6203]

void(1000);

C'est quoi ?

void est un type qui attend un nom derrière.
void signifie pas de valeur de retour de fonction


start = clock() ; // debut de comptage
je n'ai pas d'info sur cette fonction spécifique au compilateur...
Et Attention au type 1000 c'est un type de 16bits , pas sur que la fonction attend ce type c'est peut être 8 bits soit 255 maximum.

[invite66a6315c]

le :
void(1000) ;

c'est une attente d"une seconde, car l'ecran a besoin au moins de 15ms après l'alimenter, donc j'ai pensé faire une attente d'une seconde.

et pour le compilateur clock() j'ai trouver l'exemple ici

Merci

[invite66a6315c]

Ecxusez moi c'est :

void_delay(1000);

[invitef86a6203]

Ecxusez moi c'est :

void_delay(1000);

Ok , ça c'est mieux!



reste à voir si 1000 est accepté, le lien cité ne le précise pas.
Il faudrait regarder le prototype dans le header "time.h".
vérifier aussi la taille en octets des types utilisé comme int

void_delay(int);


on fait appel a des structures comme time_t
time_t timestamp;
struct tm * t;

struct tm
{
int tm_sec; /* secondes (0,59) */
int tm_min; /* minutes (0,59) */
int tm_hour; /* heures depuis minuit (0,23) */
int tm_mday; /* jour du mois (0,31) */
int tm_mon; /* mois depuis janvier (0,11) */
int tm_year; /* années écoulées depuis 1900 */
int tm_wday; /* jour depuis dimanche (0,6) */
int tm_tm_yday; /* jour depuis le 1er janvier (0,365) */
int tm_isdst;
};

ça fait penser que le type int est de 2 octets !
car pour 365 il faut 2 octets

[invitef86a6203]

Ne pas oublier de relancer le start sinon ça fonctionnera qu'une seul fois

send = clock() ; // arret du comptage
elapsed = ((double)end - start )/ CLOCKS_PER_SEC ; // conversion en secondes
if (elapsed == 10)
{
start = clock() ; // debut de comptage

ou start = end;



perso j'aurais mis
if (elapsed > 9)
pareil que
if (elapsed == 10)

mais si pour une raison x on passe le 10 ça fonctionnera tout de suite , sinon faudra attendre le tour du compteur sur 16 bits , ça fait beaucoup ...