Bibliothèque LCD pour PIC32

[DangerousMic]

Bonjour ! Je voudrais savoir si vous connaissiez une bibliothèque qui me permettrais de contrôler mon écran LCD.

Le problème est que je n'ai pas relié les broches de LCD sur le même port du PIC -_- et comme j'ai peu de temps ça m'aiderais

Les bibliothèques que j'ai me permette de contrôler LCD si tout est sur le même port et donc faut que je revoie tout le code

Merci pour votre soutient
-----

[gabuzo]

Salut,

En Cpascalbasic++ de chez pignouf ?

[futhier9178]

Salut,

Ton écran LCD est-il sur la même carte que ton pic?
Tu peux essayer la carte de développement explorer 16 qui dispose d'un écran LCD. Mais c'est un PIC24.

[DangerousMic]

En C sur MPLAB

Mon ecran est intégré à un boîtier qui est relié à des borniers ensuite sur ma carte.

[A voir en vidéo sur Futura]

[futhier9178]

ça m'a l'air compliqué.
Il vaut mieux que tu prennes un kit de développement complet c'est plus simple tu gagneras du temps.

[DangerousMic]

Justement je peux pas, je suis en stage et tout un projet m'a été donné, or en cours on nous fait travailler sur du Flowcode avec carte de développement toute faite. Donc je n'ai pas pris en compte cette contrainte.

Du coup ma carte est routé et en fabrication --' Tant pis je vais refaire le protocole à ma sauce...

[futhier9178]

Il y a le site de microchip très riche en bibliothèque tu pourras peut être ton bonheur.

[gabuzo]

Dans ce cas c'est le hard qui va déterminer le soft, voir dans un premier temps comment est câblé le LCD (mode 4 ou 8 bits) et sur quelles pins et écrire le prg en conséquence.

[DangerousMic]

Ok je te remercie je vais y faire un tour

[futhier9178]

Je regarde aussi. Dès que j'ai quelque chose je te fais savoir.

[DangerousMic]

Bonjour ! J'ai mis du temps à revenir mais j'exploitais justement une bibliothèque que j'ai trouvé...

Je vous publie mon header si cela peut servir à quelqu'un :

#ifndef TESTLCD_H
#define	TESTLCD_H

/*************************************************************************************/
typedef unsigned char byte; 		  //facultatif.
typedef unsigned int word;       	//facultatif.
typedef unsigned long dword;     	//facultatif.

/*************************************************************************************/
/**************************************************************************************
Afficheur LCD 2x16 caractères

On présente dans ce qui suit une bibliothèque de fonctions et routines gérant un
afficheur LCD alphanumérique opérant en mode 4 bits. Les broches de commandes et de
données sont initialisées à l'intérieur de la fonction init_lcd.

Grace à l'utilisation de la technique dite "champ de bits" le choix de brochage des
bits de données et de commandes entre le LCD et le micro est libre. Ceci permet de
rendre les broches, spécifiques à d'autres applications, disponibles.

**************************************************************************************/
/* Déclaration d'un champ de bits */

union {  			  //une union de nom mon_octet constituée par une structure de 8 bits
				        //et un byte à la même adresse mémoire.
	struct { 		  //une structure 8 bits (champ de bits).
		byte bit0:1,
		bit1:1,
		bit2:1,
		bit3:1,
		bit4:1,
		bit5:1,
		bit6:1,
		bit7:1;
	}bits;
	byte octet; 		  //un byte (octet).
} mon_octet ; 			//accès à l'octet complet par  mon_octet.octet  et
				            //accès aux bits par mon_octet.bits.bitx .

/*************************************************************************************/
/* Définition des broches utilisées */

//Le brochage adopté est sur un seul port (PORTB du HC08) du HC08:

#include "HardwareProfile.h"
#include "fonctions.h"

/* Déclaration des fonctions élaborées */

void ecr_ctrl(byte ctrl);
void ecr_data(byte data);
void init_lcd(byte curseur);
void xy_lcd(byte x, byte y);
void aff_car(byte c);
void aff_txt(byte *message);
void efface_lcd(void);
void defini_cars(const byte *c, byte char_code);
void onoff_lcd(byte onoff);

/* Fonctions additionnelles permettant de gérer les différentes conversions HEXA/ASCII,
FLOAT/ASCII..., et affichage direct dans la RAM du LCD : */

void aff_base(dword hexa, byte base);
void aff_float(float data, byte decimale);
void aff_CAN(byte CAN, byte decimal);
void aff_heure(byte heures, byte minutes, byte secondes);

/* Temporisation logicielle: */

void tempo_ms(word temps);

//*************************************************************************************
/* Constante utile pour la conversion HEXA/ASCII. Elle contient les codes ascii des
caractères de 0 à F. ex: h[12]=code ascii (0x43) du caractère C. */

const byte *h="0123456789ABCDEF";

//*************************************************************************************
//#include "car_spec.h"				//table définissant quelques caractères spéciaux.

/**************************************************************************************
void ecr_ctrl(byte ctrl)

Envoie un octet ctrl de contrôle pour modifier la configuration du LCD. L'envoi au LCD
de cet octet se fait en mode deux fois 4 bits.

**************************************************************************************/
void ecr_ctrl(byte ctrl){

	//utilise la variable mon_octet.octet pour avoir accès aux bits de ctrl :
	mon_octet.octet=ctrl;

	//met d'abord les 4 bits de poids forts de ctrl sur les 4 lignes DATA 7-4 utilisées du LCD
  //(mode 4 bits)

	DB4 = mon_octet.bits.bit4;
	DB5 = mon_octet.bits.bit5;
	DB6 = mon_octet.bits.bit6;
	DB7 = mon_octet.bits.bit7;

	RS_LCD=0; 				//envoie un octet de commande.
	Enable_LCD=1; 				  //validation par l'impulsion E.
        delay_us(1);
	Enable_LCD=0;

	//met par la suite les 4 bits de poids faible de ctrl sur les 4 lignes DATA 7-4
	//utilisées du LCD (mode 4 bits)
	DB4 = mon_octet.bits.bit0;
	DB5 = mon_octet.bits.bit1;
	DB6 = mon_octet.bits.bit2;
	DB7 = mon_octet.bits.bit3;

	Enable_LCD=1; 				  //validation par l'impulsion E.
        delay_us(1);
	Enable_LCD=0;

	//test du bit Busy ou attente de #2ms pour que le LCD soit prêt.

}

/**************************************************************************************
void ecr_data(byte data)

Envoie un octet de donnée data dans la RAM du LCD.
 **************************************************************************************/
void ecr_data(byte data){

	//utilise la variable  mon_octet.octet  pour avoir accès aux bits de data.
	mon_octet.octet=data;

	//met d'abord les 4 bits de poids forts de data sur les 4 lignes DATA 7-4 utilisées du
	//LCD (mode 4 bits)
	DB4 = mon_octet.bits.bit4;
	DB5 = mon_octet.bits.bit5;
	DB6 = mon_octet.bits.bit6;
	DB7 = mon_octet.bits.bit7;

	RS_LCD=0; 				//envoie un octet de commande.				//écriture dans la RAM du LCD.
	Enable_LCD=1; 				  //validation par l'impulsion E.
        delay_us(1);
	Enable_LCD=0;

	//met par la suite les 4 bits de poids faible de ctrl sur les 4 lignes DATA 7-4
	//utilisées du LCD (mode 4 bits)
	DB4 = mon_octet.bits.bit0;
	DB5 = mon_octet.bits.bit1;
	DB6 = mon_octet.bits.bit2;
	DB7 = mon_octet.bits.bit3;

	Enable_LCD=1; 				  //validation par l'impulsion E.
        delay_us(1);
	Enable_LCD=0;

}


/**************************************************************************************
void init_lcd(byte curseur)

Initialise le LCD et les PORTs utilisés.

Paramètres

	curseur = 0 : curseur fixe hors service, affichage actif.
	curseur = 1 : curseur en service, affichage actif.
	curseur = 2 : curseur clignotant en service, affichage actif.

**************************************************************************************/
void init_lcd(byte curseur){


        ecr_ctrl(0x03);
        delay_ms(15);

        ecr_ctrl(0x03);
        delay_ms(15);

        ecr_ctrl(0x03);
        delay_ms(15);

        ecr_ctrl(0x02);

	ecr_ctrl(0x28);         //adressage 4 Bits, afficheur 2 lignes.

	ecr_ctrl(0x06);         //incrémente l'adresse DD-RAM (l'affichage se décale vers la droite).

	ecr_ctrl(0x01);         //effacement de l'écran et curseur positionné en haut à gauche.

	switch(curseur){

	case 0:
		ecr_ctrl(0x0C);		//curseur hors service, affichage actif.
		break;

	case 1:
		ecr_ctrl(0x0E);		//curseur en service, affichage actif.
		break;

	case 2:
		ecr_ctrl(0x0F); 	//curseur clignotant en service.
		break;

	default:
		break;
	};
}

/**************************************************************************************
void xy_lcd(byte x, byte y)

Positionne le curseur aux coordonnées (x, y) : 1 <= x <= 16 et 1 <= y <= 2.

**************************************************************************************/
void xy_lcd(byte x, byte y){

	if (y==1)
		ecr_ctrl(0x80+x-1);               //positionne la ligne 1 aux coordonnées (x, 1).

	if (y==2)
		ecr_ctrl(0xC0+x-1);               //positionne la ligne 2 aux coordonnées (x, 2).
}

/**************************************************************************************
void aff_car(byte c)

Affiche à la position du curseur le caractère dont le code ascii est c.

**************************************************************************************/
void aff_car(byte c){

	ecr_data (c);
}

/**************************************************************************************

void aff_txt(byte *message)

Affiche, à la position du curseur, le texte " message ".

*message : pointeur sur le message stocké en ROM (mémoire Flash).

Option

\r placé dans message provoque le retour au début de la ligne suivante.

**************************************************************************************/
void aff_txt(byte *message){

	while(*message!= '\0'){	        //écriture sur le LCD de toute la chaîne.

		if(*message=='\r')
			xy_lcd(1,2);
		else
			aff_car(*message);          //écriture sur le LCD d'un caractère du message.

		message++;
	};
}

/**************************************************************************************
void efface_lcd(void)

Efface l'écran et positionne le curseur en haut à gauche.

**************************************************************************************/
void efface_lcd(void){

	ecr_ctrl(0x01);
}

/**************************************************************************************
void defini_cars(const byte *c, char_code)

Définit, dans le tableau c, un caractère personnalisé de 8x8 points. Le LCD utilisé
admet au maximum 8 caractères spéciaux.

char_code : étant le code du caractère à définir. Il doit satisfaire :
0 <= char_code <= 7.

**************************************************************************************/
void defini_cars(const byte *c, byte char_code){

	byte i=0,a;
	a=(char_code<<3)|0x40;        //les caractères sont logés dans le CGRAM du LCD à partir
					                      //de l'adresse 0x40.
	for(i=0; i<8; i++){

		ecr_ctrl(a);
		ecr_data(c[i]);
		a++;
	};
}

/**************************************************************************************
void onoff_lcd(byte onoff)

Allume ou éteint l'affichage. Le contenu de La RAM du LCD n'est pas affecté.

onoff = 1: allumé ; onoff = 0: éteint.

**************************************************************************************/
void onoff_lcd(byte onoff){

	if(onoff==1)
		ecr_ctrl(0x0C);
	else
		ecr_ctrl(0x08);
}

#endif	/* TESTLCD_H */

Mais je veux bien que vous me dépanniez sur un détail... j'arrive à initialiser l'afficheur (curseur clignote) mais dès que je veux afficher un caractère ou texte il disparaît et rien se s'affiche

Le .c

#include "Main.h"
#include "HardwareProfile.h"
#include <p32xxxx.h>
#include <plib.h>
#include "testLCD.h"


/*
 *
 */

int main(int argc, char** argv) {

    SYSTEMConfig (SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);

    init_Broches();

    delay_ms(50);

    init_lcd(0);

    delay_ms(2000);
    aff_car('A');

    return (EXIT_SUCCESS);

}

Si vous avez une solution. Merci à vous.

[DangerousMic]

Désolé finalement j'ai trouvé -_-

Dans le header que j'ai donné : dans la fonction ecr_data() : changer RS = 0 en RS = 1.

Merci quand même.