Pour en finir avec mon problème LCD/C18

[invite7a536414]

Bonjour,
Après quelques semaines de recherche et détours, j'aimerai sérieusement en finir avec mon problème de lcd...

(J'utilise une PICDEM2 PLUS board de microchip avec un PIC 18f4520 avec C18)

J'ai déjà essayé la quasi totalité des librairies conçus pour l'occasion et trainant sur le web... et celle qui m'a donné le plus de satisfaction est celle ci :
Librairie en C18 pour LCD
www.aqra.ca

La chose qui me satisfait le plus :
J'arrive à "foncer" la première ligne... et a faire clignoter le curseur...
Et encore, il faut que je bidouille... Je dois appeller line (2) puis line (1)
un simple lcdconfig (cursorON) ne fonctionne pas...

Voici le bout de code que j'utilise pour compiler.

#include <p18f4520.h> // for ports declarations
#include <delays.h> // for delay routines
#include <timers.h> //for interrupts

#define LCDdata          PORTD			// J'ai modifié les pin de sorties
#define TRIS_LCDdata     TRISD
#define LCDenable        PORTAbits.RA1
#define TRIS_LCDenable   TRISAbits.TRISA1
#define LCDrs            PORTAbits.RA3
#define TRIS_LCDrs       TRISAbits.TRISA3
#define LCDrw            PORTAbits.RA2
#define TRIS_LCDrw       TRISAbits.TRISA2
//Defines pour config du lcd
#define clear 1
#define home 2
#define cursorON 3
#define cursorOFF 4
#define shift 5
//Délais
#define wait Delay10KTCYx(1)
#define longwait Delay10KTCYx(15)
#define shortwait Delay1KTCYx(1)
#define Delay_05ms Delay10TCYx(250)

//variables utilisées ds les routines
int t;
int o;

//fonction d'initialisation de l'écran
void initlcd (void)
{
LCDdata = 0b00000000; //toutes les pins de données à 0
LCDrw = 0;
LCDenable = 0; //enable à 0
LCDrs = 0; //Register Select à 0 (configuration)
longwait;
//display ON
LCDdata = 0b00001111;
wait;
LCDenable = 1;
wait;
LCDenable = 0;
wait;
// mode 8 bit
LCDdata = 0b00000001;
wait;
LCDenable = 1;
wait;
LCDenable = 0;
wait;
// effacer l'écran
LCDdata = 0b00111000;
wait;
LCDenable = 1;
wait;
LCDenable = 0;
wait;
}

//fonction pour choisir entre quelle ligne d'écran
void line (int x)
{
if (x == 1)
{
//set display adress au début de l'écran (ligne 1)
LCDrs = 0;
LCDrw = 0;
LCDdata = 0x80;
wait;



LCDenable = 1;
wait;
LCDenable = 0;
wait;
}
if (x == 2)
{
//set display adress au 9e charactère (ligne 2)
LCDrs = 0;
LCDrw = 0;
LCDdata = 0xC0;
wait;
LCDenable = 1;
wait;
LCDenable = 0;
wait;
}
}
//configuration de l'écran (efface, home, etc)

void configlcd (int config)
{

if (config == clear)
   {
//efface l'écran
LCDrs = 0;
LCDdata = 0b00000001;
shortwait;
LCDenable = 1;
shortwait;
LCDenable = 0;
wait;
   }

if (config == home)
   {
//curseur et écran home
LCDrs = 0;
LCDdata = 0b00000011;
wait;
LCDenable = 1;
wait;
LCDenable = 0;
wait;
   }

if (config == cursorON)
   {
//curseur ON
LCDrs = 0;
LCDdata = 0b00001111;

wait;
LCDenable = 1;
wait;
LCDenable = 0;
wait;
   }

if (config == cursorOFF)
  {
//curseur OFF
LCDrs = 0;
LCDdata = 0b00001100;
wait;
LCDenable = 1;
wait;
LCDenable = 0;
wait;
  }
if (config == shift)
  {
//shift display
LCDrs = 0;
LCDdata = 0b00011000;
wait;
LCDenable = 1;
wait;
LCDenable = 0;
wait;
  }


}
//affichage d'un charactère sur l'écran
void printlcd (char text)
{
LCDrs = 1;
shortwait;
LCDdata = text; // print text
shortwait;
LCDenable = 1;
shortwait;
LCDenable = 0;
LCDdata = 0b00000000; //remet toutes les sorties à 0
LCDrs = 0;
}



char bonjour[] = " Bonjour ! ";
//fonction principale du programme
void main ()
{
//On désactive l'acquisition analogique
ADCON1=6;
//définitions des I/O
TRIS_LCDdata = 0;
TRIS_LCDenable = 0;
TRIS_LCDrw = 0;
TRIS_LCDrs = 0;
initlcd();		//A CE STADE la ligne est foncée
line (2);					
line (1);		//A CE STADE le curseur apparait


printlcd ("z");	//A CE STADE tout l'écran est blanc (comme éteind=
// Au fait c'est : "z" ou 'z' ? A chaque fois je test les deux...

while(1)
{
}
}

Oscillator : EC-Port on RA6
Fail-Safe Clock Monitor : Enable
Internal External Switch Over Mode : Disabled
...

S'il vous plait je galère avec cette librairie depuis pas mal de semaine (même si je n'ai pas travailler sur ce sujet a temps plein). J'aimerai mettre à profits les vacances pour avancer sérieusement sur le projet...

Un grand merci par avance...

Cordialement

Hoffmann
-----

[invite5637435c]

Bonjour,

bizarre ce code, l'instruction 'wait' en C je ne connais pas, surement une tempo mais... sans doute wait(x) avec x en ms.
Il faut voir dans delay.h comment c'est défini.

Il me semble que justement tu dois avoir des problèmes de tempo, puisque pour initialiser correctement un LCD il y a des temps minimum à respecter.

Tu es obligé d'utiliser ce compilo?
@+

[invite5637435c]

Je n'avais pas vu qu'il est défini dans un #define.

Donc c'est là au moins une partie du problème car je doute que cette valeur prédéfinie soit bien utilisé dans l'init.
@+

[invite7a536414]

Bonjour,


Tu es obligé d'utiliser ce compilo?
@+

Je pensais que C18 fournis par Microchip était le meilleur...

CC5 est bon pour les 16F uniquement ?
Que me conseilles tu ?

Donc toi tu chercherais plus du cotés des tempos..?

Merci d'avance

[A voir en vidéo sur Futura]

[invite5637435c]

Ce n'est pas parcequ'il est fournit par microchip qu'il est forcément le meilleur.
CCS n'est pas ma tasse de thé personnellement, il s'éloigne trop du C ANSI, mais en faisant une 'recherche' sur le forum tu trouveras des discussions sur ce sujet qui a été pas mal abordé.

Pour en revenir à ton problème il y a différentes tempos qui ont été créées pour initialiser l'afficheur, longwait, shortwait, etc.
Il faut donc vérifier que le quartz que tu as mis permet à ces tempos de générer les bonnes valeurs sinon ça ne fonctionnera pas.
@+

[invite7a536414]

Ok je vais essayer de les vérifier....
Merci pour le conseil...
je vous tient au courant...

[invitee9dcae4d]

Bonjour,

Il y a juste un truc que je ne comprends pas, à quoi bon le programmer en C si c'est pour tout réécrire comme en assembleur ?

Je n'ai pas encore essayé de le faire avec C18 (juste fait avec mikroC et MPLAB donc en ASM) mais tes routines d'initialisation me paraissent bien "compliquées" dans l'optique d'utiliser un langage de plus haut niveau.

Pourquoi ne pas utiliser les librairies de C18 par exemple et faire par exemple OpenXLCD (...) pour l'initialiser à la place de ta routine qui joue avec le Enable et RS ?

Je dis pas que c'est une mauvaise chose, ça m'intrigue juste ; ).

[invite7a536414]

En navigant sur le web tout le monde on s'accorde a dire que les librairies xlcd de C18 ne fonctionnent pas. J'ai essayer (sans trop chercher) et rien...
Cette librairire a au moins le mérite de faire allumé le LCD

Je re testerai cette aprem...
Merci de vos conseils...

[invite5637435c]

Bonsoir,

l'idée de reprendre un soft tout fait n'est jamais constructif, le mieux est de se confronter à la datasheet et d'extraire le nécessaire pour écrire ta propre routine.
Tu vas peut-être y passer du temps mais au bout du compte tu vas gagner beaucoup.
Quand tu sais comment ça fonctionne tu ne te pose plus de question, tu suis les directives et ça marche, des gens ont fait en sorte de décrire ce que tu dois savoir autant profiter de leur expérience et suivre leur conseils.

Finalement tout le secret est là, lire ou écouter, puis appliquer.

@+

[invite6cd67d9b]

Hello hoffmann et les autres,

Je suis l'auteur de ce code. C'est un des premiers projets que j'ai fait en C, veuillez excusez la mauvaise qualité... mais c'est fonctionnel

Celà étant dit, j'ai retravaillé ce code avec les années et je l'utilise tjrs.

hoffmann => si tu ajoutes [**] sur MSN, j'te fournirai la version plus récente.

[invite5637435c]

Bonsoir tartopommes ça faisait un bail.

Un ancien comme toi devrait savoir que les adresses mails ou autres sont proscrites sur le forum, utilise la MP pour cela.
Si tu as une explication du problème de notre ami tu peux aussi donner ton avis, d'autres en seront ravis s'ils tombent ici.

@+

[invite6cd67d9b]

Hello!

Désolé pour l'adresse, je croyais que notée sans le formatage typique d'une adresse mail c'était correct.

Je vais vérifier dans mes archives et poster le code directement ici sous peu.

[invite6cd67d9b]

hoffmann, tu trouveras ci dessous pas mal de code.

Tout d'abord, un équivalent de ce que tu as, mais probablement un peu plus optimisé:

  //******************************************\\
//Gestion d'un afficheur LCD 16*2 en mode 4-bits\\
//**********************************************\\

//Utilisé pour l'afficheur LCD 16*2 blanc sur fond bleu
//de la carte mère Eurobot OPEN 2k7
 

//*** Variables et définitions ***\\

//Pins sur le PIC
#define LCD_D07 LATDbits.LATD5
#define TRIS_D07 TRISDbits.TRISD5
#define LCD_D06 LATDbits.LATD4
#define TRIS_D06 TRISDbits.TRISD4
#define LCD_D05 LATDbits.LATD7
#define TRIS_D05 TRISDbits.TRISD7
#define LCD_D04 LATDbits.LATD6
#define TRIS_D04 TRISDbits.TRISD6

#define LCD_enable LATDbits.LATD2
#define TRIS_LCD_enable TRISDbits.TRISD2
#define LCD_rs LATDbits.LATD1
#define TRIS_LCD_rs TRISDbits.TRISD1
#define LCD_rw LATDbits.LATD0
#define TRIS_LCD_rw TRISDbits.TRISD0

//Defines pour config du lcd
#define clear 1
#define home 2
#define cursorON 3
#define cursorOFF 4
#define shiftL 5
#define shiftR 6
#define texte 33
#define config 44


//Variables utilisées dans les routines
int t, i, mode; 
char lower, upper;


//*** Prototypes de fonctions ***\\

void pulse_enable (void);
void set_low (void);
void init_lcd2 (void);
void line_choice (int x);
void config_lcd (int configuration);
void assign_data (char data);
void print_char (char text, int mode);
void print_char_init (char text);
void print_string (int lin, const rom char *str);
void set_pins_lcd (void);


//*** Fonctions ***\\

//On valide l'info
void pulse_enable (void)
{
  	Delay10TCYx(1); //1us
  	LCD_enable = 1;
  	Delay10TCYx(1); //1us
  	LCD_enable = 0;
  	Delay10TCYx(1); //1us
}

//Mets toutes les pins de données à 0
void set_low (void)
{
 	LCD_D07 = 0;
	LCD_D06 = 0;
	LCD_D05 = 0;
	LCD_D04 = 0;
}

//Configuration de l'écran	
void init_lcd (void)
{	

	//On laisse le temps à l'écran de bien démarrer
	Delay10KTCYx(30);  //30ms
	
	//On s'assure que tout soit bien à 0
	set_low();
	LCD_rw = 0;
  	LCD_enable = 0;         
  	LCD_rs = 0;            //Register Select à 0 (configuration)

	Delay10KTCYx(30);  //30ms  

	//Display OFF
	print_char_init(0x8);

	//Display ON
	print_char_init(0xC);

	//Clear screen
	print_char_init(0x1);

	//Config 4bits
	print_char_init(0x2);


	print_char_init(0x1);

  	Delay10KTCYx(20);  //20ms

}

//Configuration de l'écran	
void init_lcd2 (void)
{	

	//On laisse le temps à l'écran de bien démarrer
	Delay10KTCYx(30);  //30ms
	
	//On s'assure que tout soit bien à 0
	set_low();
	LCD_rw = 0;
  	LCD_enable = 0;         
  	LCD_rs = 0;            //Register Select à 0 (configuration)  

	Delay10KTCYx(30);  //30ms

	//Display OFF
	print_char_init(0x8);
	print_char_init(0x8);

	//Display ON
//	print_char_init(0xC);

	//Clear screen
	print_char_init(0x0);
	print_char_init(0x1);
	print_char_init(0x0);
	print_char_init(0x0);
	print_char_init(0x1);
/*	
	//Config 8bits
	print_char_init(0x3);
	print_char_init(0x3);
	print_char_init(0x3);
*/

	//Config 4bits
	print_char_init(0x2);
	print_char_init(0x2);
	print_char_init(0x8);

	print_char_init(0x0);
	print_char_init(0xC);

	print_char_init(0x0);
	print_char_init(0x6);

	print_char_init(0x0);
	print_char_init(0x1);

  	Delay10KTCYx(2);  //2ms

}

//fonction pour choisir entre quelle ligne d'écran
void line_choice (int x)
{
	if (x == 1)
	{
	    //set display adress au début de l'écran (ligne 1)
		print_char(0x80, config);
	}

	if (x == 2)
	{
		//set display adress au 21e charactère (ligne 2)
		print_char(0xC0, config);
	}
}

//configuration de l'écran (efface, home, etc)
void config_lcd (int configuration)
{
	if (configuration == clear)
	 {
		//efface l'écran
		print_char(0b00000001, config); 
  		Delay10KTCYx(2);  //2ms
	 }

	if (configuration == home)
	 {
		//curseur et écran home
		print_char(0b00000011, config); 
  		Delay10KTCYx(2);  //2ms 
	 }

	if (configuration == cursorON)
	 {
		//curseur ON
		print_char(0b00001111, config);
		Delay10TCYx(50);  //50us
	 }

	if (configuration == cursorOFF)
	 {
		//curseur OFF
		print_char(0b00001100, config);  
		Delay10TCYx(50);  //50us
	 }

	if (configuration == shiftL)
	{
		//shift display
		print_char(0b00011000, config);  
		Delay10TCYx(50);  //50us
	 }

	if (configuration == shiftR)
	{
		//shift display
		print_char(0b00011100, config);
		Delay10TCYx(50);  //50us  
	 }
}

//Place un mot de 4-bits sur D04-D07
void assign_data (char data)
{
	Delay10TCYx(50);  //50us

	if (data & 0b00000001)
		LCD_D04 = 1;
	else
		LCD_D04 = 0;
	
	if (data & 0b00000010)
		LCD_D05 = 1;
	else
		LCD_D05 = 0;

	if (data & 0b00000100)
		LCD_D06 = 1;
	else
		LCD_D06 = 0;
	
	if (data & 0b00001000)
		LCD_D07 = 1;
	else
		LCD_D07 = 0;

	Delay10TCYx(50);  //50us
	pulse_enable();
}

//affichage d'un charactère sur l'écran
void print_char (char text, int mode)
{
	if(mode == texte)
   		LCD_rs = 1;
	if(mode == config)
		LCD_rs = 0;

	Delay10TCYx(50);  //50us

	//Divise l'octet en deux nibbles
	upper = text >> 4;
	lower = text & 0b1111;
 	
	//et les envoie à l'écran
	assign_data(upper);
	Delay10TCYx(50);  //50us
	assign_data(lower);
	Delay10TCYx(50);  //50us

   	set_low(); //remet toutes les sorties à 0
}

//permet d'envoyer les commandes d'initialisation en
//pseudo 8bits
void print_char_init (char text)
{
	LCD_rs = 0;

	Delay10TCYx(50);  //50us
 	
	//et les envoie à l'écran
	assign_data(text);
	Delay10TCYx(50);  //50us

   	set_low(); //remet toutes les sorties à 0
}

//affichage d'une chaine de charactères sur l'écran
void print_string (int lin, const rom char *str)
{
	line_choice(lin);
	for(t=0; t<=15; ++t)  //imprime les charactères
	{
  		  	print_char(str[t], texte);
	}
}

//Définie les entrées et les sorties
void set_pins_lcd (void)
{
	TRIS_D04 = 0;
	TRIS_D05 = 0;
	TRIS_D06 = 0;
	TRIS_D07 = 0;

	TRIS_LCD_enable = 0;
	TRIS_LCD_rs = 0;
	TRIS_LCD_rw = 0;
}

Message à suivre... (trop de caractères )

[invite6cd67d9b]

Ensuite, la version "vraie librairie". Elle se modifie facilement pour faire avec un autre format d'écran.

//Gestion d'un afficheur LCD 20*4 en mode 4-bits
//Utilisé pour l'afficheur LCD 20*4 blanc sur fond bleu de la carte mère Eurobot OPEN 2k8

#ifndef INC_LCD420_H
#define INC_LCD420_H 

/////////////////////////////////////////////////////////////////////////////
//                                                                         //
//                       Prototypes de fonctions                           //
//                                                                         //
/////////////////////////////////////////////////////////////////////////////

void pulse_enable (void);
void set_low (void);
void init_lcd2 (void);
void line_choice (int x);
void config_lcd (int configuration);
void assign_data (char data);
void print_char (char text, int mode);
void print_char_init (char text);
void print_string (int lin, char *str);
void set_pins_lcd (void);

/////////////////////////////////////////////////////////////////////////////
//                                                                         //
//                        Constantes et variables                          //
//                                                                         //
/////////////////////////////////////////////////////////////////////////////

//Pins sur le PIC
#define LCD_D04 LATBbits.LATB12
#define TRIS_LCD_D04 TRISBbits.TRISB12
#define LCD_D05 LATDbits.LATD0
#define TRIS_LCD_D05 TRISDbits.TRISD0
#define LCD_D06 LATDbits.LATD1
#define TRIS_LCD_D06 TRISDbits.TRISD1
#define LCD_D07 LATFbits.LATF0
#define TRIS_LCD_D07 TRISFbits.TRISF0
#define LCD_EN LATFbits.LATF1
#define TRIS_LCD_EN TRISFbits.TRISF1
#define LCD_RS LATFbits.LATF4
#define TRIS_LCD_RS TRISFbits.TRISF4

//Defines pour config du lcd
#define clear 1
#define home 2
#define cursorON 3
#define cursorOFF 4
#define shiftL 5
#define shiftR 6
#define texte 33
#define config 44


#endif

/////////////////////////////////////////////////////////////////////////////
//                                                                         //
//                           [Eurobot OPEN 2008]                           //
//                Gestion d'un afficheur LCD 20*4 en mode 4-bits           //
//                               version 1.0                               //
//                                                                         //
/////////////////////////////////////////////////////////////////////////////
//                                                                         //
//                          dsPIC30F4013, 10 MHz x4                        //
//                                 JFDuval                                 //
//                                31/03/2008                               //
//                                                                         // 
/////////////////////////////////////////////////////////////////////////////
//Utilisé pour l'afficheur LCD 20*4 de la carte mère Eurobot OPEN 2k8

#include <p30f4013.h>   
#include "lcd_4_20.h"
#include "delays.h"
 

//Variables utilisées dans les routines
int t, i, mode; 
char lower, upper;

/////////////////////////////////////////////////////////////////////////////
//                                                                         //
//                                Fonctions                                //
//                                                                         //
/////////////////////////////////////////////////////////////////////////////

//On valide l'info
void pulse_enable (void)
{
	Nop(); Nop(); Nop();  // 1.2us
  	LCD_EN = 1;
	Nop(); Nop(); Nop();  // 1.2us
  	LCD_EN = 0;
	Nop(); Nop(); Nop();  // 1.2us
}

//Mets toutes les pins de données à 0
void set_low (void)
{
 	LCD_D07 = 0;
	LCD_D06 = 0;
	LCD_D05 = 0;
	LCD_D04 = 0;
}

//Configuration de l'écran	
void init_lcd (void)
{	

	//On laisse le temps à l'écran de bien démarrer
	delay_ms(30);  //30ms
	
	//On s'assure que tout soit bien à 0
	set_low();
  	LCD_EN = 0;         
  	LCD_RS = 0;            //Register Select à 0 (configuration)

	delay_ms(30);  //30ms 

	//Display OFF
	print_char_init(0x8);

	//Display ON
	print_char_init(0xC);

	//Clear screen
	print_char_init(0x1);

	//Config 4bits
	print_char_init(0x2);


	print_char_init(0x1);

	delay_ms(20);  //30ms

}

//Configuration de l'écran	
void init_lcd2 (void)
{	

	//On laisse le temps à l'écran de bien démarrer
	delay_ms(30);  //30ms
	
	//On s'assure que tout soit bien à 0
	set_low();
  	LCD_EN = 0;         
  	LCD_RS = 0;            //Register Select à 0 (configuration)  

	delay_us(50);	//50us

	//Clear screen
	print_char_init(0x0);
	print_char_init(0x1);
	print_char_init(0x0);
	print_char_init(0x0);
	print_char_init(0x1);
	
	//Config 8bits
	print_char_init(0x3);
	print_char_init(0x3);
	print_char_init(0x3);

	//Config 4bits
	print_char_init(0x2);
	print_char_init(0x2);
	print_char_init(0x8);

	print_char_init(0x0);
	print_char_init(0xC);

	print_char_init(0x0);
	print_char_init(0x6);

	print_char_init(0x0);
	print_char_init(0x1);

	delay_ms(2);  

}

//fonction pour choisir entre quelle ligne d'écran
void line_choice (int x)
{
	if (x == 1)
	{
	    //set display adress au début de l'écran (ligne 1)
		print_char(0x80, config);
	}

	if (x == 2)
	{
		//set display adress au 21e charactère (ligne 2)
		print_char(0xC0, config);
	}

	if (x == 3)
	{
		//set display adress au 41e charactère (ligne 3)
		print_char(0x94, config);
	}

	if (x == 4)
	{
		//set display adress au 61e charactère (ligne 4)
		print_char(0xD4, config);
	}
}

//configuration de l'écran (efface, home, etc)
void config_lcd (int configuration)
{
	if (configuration == clear)
	 {
		//efface l'écran
		print_char(0b00000001, config); 
 		delay_ms(2);  //2ms
	 }

	if (configuration == home)
	 {
		//curseur et écran home
		print_char(0b00000011, config); 
 		delay_ms(2);  //2ms
	 }

	if (configuration == cursorON)
	 {
		//curseur ON
		print_char(0b00001111, config);
		delay_us(50);	//50us
	 }

	if (configuration == cursorOFF)
	 {
		//curseur OFF
		print_char(0b00001100, config);  
		delay_us(50);	//50us
	 }

	if (configuration == shiftL)
	{
		//shift display
		print_char(0b00011000, config);  
		delay_us(50);	//50us
	 }

	if (configuration == shiftR)
	{
		//shift display
		print_char(0b00011100, config);
		delay_us(50);	//50us
	 }
}

//Place un mot de 4-bits sur D04-D07
void assign_data (char data)
{
	delay_us(50);	//50us

	if (data & 0b00000001)
		LCD_D04 = 1;
	else
		LCD_D04 = 0;
	
	if (data & 0b00000010)
		LCD_D05 = 1;
	else
		LCD_D05 = 0;

	if (data & 0b00000100)
		LCD_D06 = 1;
	else
		LCD_D06 = 0;
	
	if (data & 0b00001000)
		LCD_D07 = 1;
	else
		LCD_D07 = 0;

	delay_us(50);	//50us
	pulse_enable();
}

//affichage d'un charactère sur l'écran
void print_char (char text, int mode)
{
	if(mode == texte)
   		LCD_RS = 1;
	if(mode == config)
		LCD_RS = 0;

	delay_us(10);	//50us

	//Divise l'octet en deux nibbles
	upper = text >> 4;
	lower = text & 0b1111;
 	
	//et les envoie à l'écran
	assign_data(upper);
//	delay_us(10);	//50us
	assign_data(lower);
//	delay_us(10);	//50us

   	set_low(); //remet toutes les sorties à 0
}

//permet d'envoyer les commandes d'initialisation en
//pseudo 8bits
void print_char_init (char text)
{
	LCD_RS = 0;

	delay_us(50);	//50us
 
	//et les envoie à l'écran
	assign_data(text);
	delay_us(50);	//50us

   	set_low(); //remet toutes les sorties à 0
}

//affichage d'une chaine de charactères sur l'écran
//les choix de duos permettent une gestion plus simple
//des animations sur l'écran
void print_string (int lin, char *str)
{
	if(lin == 1 ||  2 ||  3 ||  4)
	{	
		line_choice(lin);
		for(t=0; t<=19; ++t)  //imprime les premiers charactères
		{
  		  	print_char(str[t], texte);
		}
	}

	if(lin == 14)
	{
		line_choice(1);
		for(t=0; t<=19; ++t)  //imprime les premiers charactères
		{
  		  	print_char(str[t], texte);
		}

		line_choice(4);
		for(t=0; t<=19; ++t)  //imprime les premiers charactères
		{
  		  	print_char(str[t], texte);
		}
	}
	if(lin == 23)
	{
		line_choice(2);
		for(t=0; t<=19; ++t)  //imprime les premiers charactères
		{
  		  	print_char(str[t], texte);
		}

		line_choice(3);
		for(t=0; t<=19; ++t)  //imprime les premiers charactères
		{
  		  	print_char(str[t], texte);
		}
	}
}

//Définie les entrées et les sorties
void set_pins_lcd (void)
{
	TRIS_LCD_D04 = 0;
	TRIS_LCD_D05 = 0;
	TRIS_LCD_D06 = 0;
	TRIS_LCD_D07 = 0;

	TRIS_LCD_EN = 0;
	TRIS_LCD_RS = 0;
}

Note: essaie de l'utiliser avec la 2e fonction d'init, c'est elle qui m'a donné le plus de succès. Dépendant des écrans, il faut parfois être très redondants afin de s'assurer qu'il démarre bien.

En espérant ainsi t'aider!

[invite860936ec]

bonjour a tous.
Le probléme avec la librairie de microchip vient du fait que mplab ne compile pas le lcd.h avec la deffinition des ports et e/s.
J'ai résolue le probléme en faisant un copier coler des fonctions microcip dans mon appli puis en les rennommant et ca marche trés bien . ci joint mon code en espérant que cela puisse vous servir
@+

[invite7a536414]

Je vais faire des tests dans pas longtemps.
Merci beaucoup pour toutes ces matières à réfléchir...

Bonne soirée et encore merci