Panier

article (vide)

Aucun produit

Expédition 0,00 €
Total 0,00 €

Commander

Boutique

Notre équipe à votre service

Question pré-achat ? Besoin de support ?
> Visitez notre forum <

Vous avez besoin d'un devis ?
> Contactez-nous <

Vous souhaitez commander par courrier ?
> Téléchargez un bon de commande <

Renvoyez le complèté avec votre paiement à :
Devtronic SARL
21 rue Jean-Jacques Rousseau
92150 SURESNES

Modes de paiement

Librairies : Gestion écran LCD 16x2

Introduction

La mise en oeuvre d'un écran LCD n'est jamais triviale. Afin de vous aider dans vos développements, nous avons concocté une librairie simple de gestion du LCD myAVR en vente dans notre boutique.

Cette librairie reprend toutes les fonctions basiques permettant de piloter l'écran LCD mais également des fonctions plus sophistiquées pour afficher des chaînes de caractères, des nombres entiers ou des nombres décimaux. Vous trouverez un exemple de mise en oeuvre de cette librairie ici.

N'hésitez pas à nous poser des questions sur la mise en oeuvre de cette librairie sur le forum.

La librairie est compilable avec gcc (fournit avec Winavr).

Téléchargez les fichiers

Téléchargement Header (.h)
Source (.c)
* Clic droit -> Enregistrer la cible du lien sous
Mis à jour le 18/03/09

//------------------------------------------------------------------------------
// Titre         : Header librairie LCD pour myAVR LCD Addon
//------------------------------------------------------------------------------
// Fonction      : Librairie LCD pour myAVR LCD Addon
//------------------------------------------------------------------------------
// Langage       : C
// Date          : 16/09/2008
// Version       : 1.2
// Auteur        : Devtronic SARL
//------------------------------------------------------------------------------
#ifndef MYAVR_LCD
#define MYAVR_LCD

#define BIT_LCD_RS	2 		// bit du port sur lequel est connectée la pin RS du LCD
#define BIT_LCD_E	3		// bit du port sur lequel est connectée la pin E du LCD
#define BIT_LCD_D4	4		// bit du port sur lequel est connectée la pin D4 du LCD
#define BIT_LCD_D5	5		// bit du port sur lequel est connectée la pin D5 du LCD
#define BIT_LCD_D6	6		// bit du port sur lequel est connectée la pin D6 du LCD
#define BIT_LCD_D7	7		// bit du port sur lequel est connectée la pin D7 du LCD
#define PORT_LCD	PORTD	// port sur lequel sont connectées les pins du LCD (sauf R/W)
#define DPORT_LCD	DDRD	// registre de direction du port sur lequel sont connectées les pins du LCD (sauf R/W)

#define LCD_CMD_EFF			0x01	// Commande d'effacement LCD
#define LCD_CMD_HOME		0x02	// Commande de renvoi du curseur à la position initiale
#define LCD_CMD_ENTRY_MODE	0x04	// Commande de sélection du mode d'insertion
#define LCD_BIT_ENTRY_SHIFT	0		// Position bit de sélection inversion/non inversion
#define LCD_BIT_ENTRY_INC	1		// Position bit de sélection incrémentation/décrementation curseur
#define LCD_CMD_DISPLAY		0x08	// Commande de gestion de l'affichage LCD
#define LCD_BIT_DISP_DISP	2		// Position bit d'activation/désactivation de l'affichage
#define LCD_BIT_DISP_CURS	1		// Position bit d'activation/désactivation curseur
#define LCD_BIT_DISP_BLINK	0		// Position bit d'activation/désactivation clignotement curseur
#define LCD_CMD_SHIFT		0x10	// Commande de déplacement affichage/curseur
#define LCD_BIT_SHIFT_TYPE	3		// Position bit de type de déplacement
#define LCD_BIT_SHIFT_SENS	2		// Position bit de sens de déplacement
#define LCD_CMD_SET_DDRAM	0x80	// Commande d'affectation de l'adresse DDRAM
#define LCD_LIGNE_1			0x00	// Adresse ligne 1
#define LCD_LIGNE_2			0x40	// Adresse ligne 2
#define LCD_CMD_SET_CGRAM	0x40	// Commande d'affectation de l'adresse CGRAM

// Envoi au LCD du caractère entré en paramètre
void MYAVRLCD_envoiCaractere(char caractere);	
	
// Envoi au LCD de la commande entrée en paramètre
void MYAVRLCD_envoiCommande(char commande);

// Initialisation du LCD
void MYAVRLCD_initialisation(void);

// Effacement du LCD
void MYAVRLCD_effacement(void);

// Renvoi du curseur à la position initiale
void MYAVRLCD_home(void);

// Sélection du mode d'insertion pour le LCD
// direction_curseur : 1 = incrémentation - 0 = décrémentation
// inversion_affichage : 1 = inversion - 0 = non inversion
void MYAVRLCD_modeInsertion(int direction_curseur,int inversion_affichage);

// Configuration affichage LCD
// affichage_actif : 1 = actif - 0 = inactif
// curseur_actif : 1 = actif - 0 = inactif
// clignotement_actif : 1 = actif - 0 = inactif
void MYAVRLCD_confAffichage(int affichage_actif,int curseur_actif,int clignotement_actif);

// Déplacement affichage ou curseur
// type : 1 = affichage - 0 = curseur
// sens : 1 = droite - 0 = gauche
void MYAVRLCD_deplacement(int type,int sens);

// Déplacement du curseur de n caractères vers la droite
// nombre_caracteres : nombre de caracteres de déplacement vers la droite
void MYAVRLCD_deplacerCurseurDroite(int nombre_caracteres);

// Déplacement du curseur de n caractères vers la gauche
// nombre_caracteres : nombre de caracteres de déplacement vers la gauche
void MYAVRLCD_deplacerCurseurGauche(int nombre_caracteres);

// Déplacement de n caractères vers la droite des données à partir du curseur
// nombre_caracteres : nombre de caracteres de déplacement vers la droite
void MYAVRLCD_deplacerAffichageDroite(int nombre_caracteres);

// Déplacement de n caractères vers la gauche des données à partir du curseur
// nombre_caracteres : nombre de caracteres de déplacement vers la gauche
void MYAVRLCD_deplacerAffichageGauche(int nombre_caracteres);

// Ecriture d'une chaîne de caractère sur le LCD
// chaine : le pointeur sur la chaîne de caractères à envoyer
// nb_caracteres : le nombre de caractères de la chaîne
void MYAVRLCD_ecrireChaine(char *chaine, int nb_caracteres);

// Déplacement du curseur
// y : numéro de la ligne (1 ou 2)
// x : numéro du caractère (1 à 16)
void MYAVRLCD_deplacerCurseur(int y,int x);

// Ajout d'un caractère en mémoire CGRAM (8 emplacements possibles)
// caractere : pointeur sur le caractère à ajouter (en mémoire programme)
// code : code du caractère
void MYAVRLCD_ajouterCaractere(const char *caractere,int code);

// Affiche une variale de type entier sur l'écran LCD
// entier : l'entier à afficher sur l'écran
void MYAVRLCD_afficherEntier(int entier);

// Affiche une variable de type double à l'écran avec un nombre de décimales définit
// vdouble : la valeur décimale à afficher
// nb_decimales : le nombre de décimales à afficher après la virgule
void MYAVRLCD_afficherDouble(double vdouble, int nb_decimales);

#endif
//--------------------------------------------------------------------------

//--------------------------------------------------------------------------
// Titre         : Librairie de gestion LCD myAVR add-on
//--------------------------------------------------------------------------
// Fonction      : Fonctions de gestion du LCD
//--------------------------------------------------------------------------
// Processeur    : ATmega8/48/88/168
// Langage       : C
// Date          :  29/09/2008
// Version       : 1.2
// Auteur        : Devtronic SARL
//--------------------------------------------------------------------------
#include "myavr_lcd.h"		// Fichier header myAVR LCD
#include <avr/io.h>			// Registres AVR et définition des constantes
#include <avr/pgmspace.h>	// Gestion mémoire programme
#include <util/delay.h>		// Fonction de délai
//--------------------------------------------------------------------------

void MYAVRLCD_ecrire4msb(char);
void MYAVRLCD_gestionEnable(void);
void MYAVRLCD_ecrire(char,int);

// Envoi commande
void MYAVRLCD_envoiCommande(char commande)
{
	MYAVRLCD_ecrire(commande,0);

}

// Envoi caractere
void MYAVRLCD_envoiCaractere(char caractere)
{
	MYAVRLCD_ecrire(caractere,1);
}

/// Gère l'écriture d'un octet vers le LCD
void MYAVRLCD_ecrire(char donnee,int type)
{
	// Activation de RS si type = 1 (donnee)
	PORT_LCD |= (type << BIT_LCD_RS);
	
	// Ecriture des 4 MSB
	MYAVRLCD_ecrire4msb(donnee);
	
	// Ecriture des 4 LSB
	MYAVRLCD_ecrire4msb(donnee << 4);
	
	// Desactivation RS
	PORT_LCD  &= ~(1<<BIT_LCD_RS);
	
	// Attente execution
	_delay_ms(6);
}

// Gère l'enable du LCD
void MYAVRLCD_gestionEnable(void)
{
   PORT_LCD |= (1 << BIT_LCD_E);		// E à 1
   __asm__("NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;NOP;");
   PORT_LCD &= ~(1 << BIT_LCD_E); 		// E à 0
}

// Gère l'écriture des 4 MSB vesr le LCD
void MYAVRLCD_ecrire4msb(char donnee)
{
	// Reset bit de données
	PORT_LCD &= ~((1 << BIT_LCD_D4) | (1 << BIT_LCD_D5) | (1 << BIT_LCD_D6) | (1 << BIT_LCD_D7)); 
	
	// Ecriture des 4 MSB
	if (donnee & (1 << 4))
	{
		PORT_LCD |= (1 << BIT_LCD_D4); // Bit D4 à 1
	}
	
	if (donnee & (1 << 5))
	{
		PORT_LCD |= (1 << BIT_LCD_D5); // Bit D5 à 1
	}
	
	if (donnee & (1 << 6))
	{
		PORT_LCD |= (1 << BIT_LCD_D6); // Bit D6 à 1
	}
	
	if (donnee & (1 << 7))
	{
		PORT_LCD |= (1 << BIT_LCD_D7); // Bit D7 à 1
	}	
	
	// Validation donnee par basculement de l'enable
	MYAVRLCD_gestionEnable();
}

// Initialisation du LCD
void MYAVRLCD_initialisation(void)
{
	// Port D en sortie
	DPORT_LCD = 0xFF;
	
	// Attente de l'initialisation interne du circuit LCD
	_delay_ms(20);
	PORT_LCD &= ~((1 << BIT_LCD_D4) | (1 << BIT_LCD_D5) | (1 << BIT_LCD_D6) | (1 << BIT_LCD_D7));

// RS à 0
	PORT_LCD &= ~(1 << BIT_LCD_RS);
	_delay_ms(10);
	
	// Configuration initiale : etape 1
	MYAVRLCD_ecrire4msb(0x30);
	_delay_ms(5);
	
	// Configuration initiale : etape 2
	MYAVRLCD_ecrire4msb(0x30);
	_delay_us(160);

// Configuration initiale : etape 3
	MYAVRLCD_ecrire4msb(0x30);
	_delay_us(160);

// Passage en mode 4 bits
	MYAVRLCD_ecrire4msb(0x20);
	_delay_ms(5);		
	
	// Envoi des commandes de paramètrage
	MYAVRLCD_envoiCommande(0x28);	// 4 bits - 2 lignes - Police 5x7
	MYAVRLCD_confAffichage(0,0,0);	// Display off - Cursor off - Blinking off
	MYAVRLCD_effacement();
	MYAVRLCD_modeInsertion(1,0);	// Cursor increase - Display not shifted
	MYAVRLCD_confAffichage(1,0,0);	//  Display on - Cursor off - Blinking off
}

// Efface le contenu de l'ecran LCD
void MYAVRLCD_effacement(void)
{	
	MYAVRLCD_envoiCommande(LCD_CMD_EFF);
}

// Renvoi le curseur à la position initiale
void MYAVRLCD_home(void)
{	
	MYAVRLCD_envoiCommande(LCD_CMD_HOME);
}

// Sélection du mode d'insertion des caractères sur le LCD
void MYAVRLCD_modeInsertion(int direction_curseur,int inversion_affichage)
{	
	MYAVRLCD_envoiCommande(LCD_CMD_ENTRY_MODE | (inversion_affichage << LCD_BIT_ENTRY_SHIFT) | (direction_curseur << LCD_BIT_ENTRY_INC));
}

// Configuration affichage LCD
void MYAVRLCD_confAffichage(int affichage_actif,int curseur_actif,int clignotement_actif)
{
	MYAVRLCD_envoiCommande(
		LCD_CMD_DISPLAY
		| (affichage_actif << LCD_BIT_DISP_DISP)
		| (curseur_actif << LCD_BIT_DISP_CURS)
		| (clignotement_actif << LCD_BIT_DISP_BLINK)
	);
}

// Déplacement affichage ou curseur
void MYAVRLCD_deplacement(int type,int sens)
{
	MYAVRLCD_envoiCommande(
		LCD_CMD_SHIFT
		| (type << LCD_BIT_SHIFT_TYPE)
		| (sens << LCD_BIT_SHIFT_SENS)
	);
}

// Déplacement du curseur de n caractères vers la droite
void MYAVRLCD_deplacerCurseurDroite(int nombre_caracteres)
{
	int i;
	for(i=0;i<nombre_caracteres;i++)
	{
		MYAVRLCD_deplacement(0,1);
	}
}

// Déplacement du curseur de n caractères vers la gauche
void MYAVRLCD_deplacerCurseurGauche(int nombre_caracteres)
{
	int i;
	for(i=0;i<nombre_caracteres;i++)
	{
		MYAVRLCD_deplacement(0,0);
	}
}

// Déplacement de n caractères vers la droite des données à partir du curseur
void MYAVRLCD_deplacerAffichageDroite(int nombre_caracteres)
{
	int i;
	for(i=0;i<nombre_caracteres;i++)
	{
		MYAVRLCD_deplacement(1,1);
	}
}

// Déplacement de n caractères vers la gauche des données à partir du curseur
void MYAVRLCD_deplacerAffichageGauche(int nombre_caracteres)
{
	int i;
	for(i=0;i<nombre_caracteres;i++)
	{
		MYAVRLCD_deplacement(1,0);
	}
}

// Ecriture d'une chaîne de caractère sur le LCD
void MYAVRLCD_ecrireChaine(char *chaine, int nb_caracteres)
{
	int i;
	
	if (!chaine)
	{
		return;		// Si le pointeur passé en paramètre n'est pas valide => sortie de la fonction
	}
	
	for (i=0;i<nb_caracteres;i++)
	{
		MYAVRLCD_envoiCaractere(chaine[i]);
	}	
}

// Déplacement du curseur
void MYAVRLCD_deplacerCurseur(int y,int x)
{
	int adresse;
	
	if ((y < 1) || (y > 2) || (x < 1) || (x > 16))
	{
		return;		// Si le numéro de caractère/ligne n'est pas bon => sortie de la fonction
	}

// Ligne 1
	if (y == 1)
	{
		adresse = LCD_LIGNE_1 + (x - 1);
	}
	// Ligne 2
	else
	{
		adresse = LCD_LIGNE_2 + (x - 1);
	}
	
	MYAVRLCD_envoiCommande(LCD_CMD_SET_DDRAM | adresse);
}

// Ajout d'un caractère en mémoire CGRAM (8 emplacements possibles)
void MYAVRLCD_ajouterCaractere(const char *caractere,int code)
{
	char commande,ligne_caractere;
	int i;
	
	// Initialisation commande
	// Le code du caractère est décalé de 3 car les 3 LSB correspondent aux adresses des octects (8) composant le caractère
	commande = LCD_CMD_SET_CGRAM | (code << 3);
	
	for(i=0;i<8;i++)
	{
		// Récupération octet courant composant le caractère depuis la mémoire programme
		ligne_caractere = pgm_read_byte(&caractere[i]);
		// Envoi commande puis incrémentation index octet composant
		MYAVRLCD_envoiCommande(commande++);
		// Envoi octet composant le caractère
		MYAVRLCD_envoiCaractere(ligne_caractere);
	}
}

// Affiche une variale de type entier sur l'écran LCD
void MYAVRLCD_afficherEntier(int entier)
{
	int compteur = 0;
	char caracteres[10];  // Un entier comporte un maximum de 10 digits  
	
	// Si l'entier vaut 0, on l'affiche tout de suite
	if(entier == 0)
	{
		MYAVRLCD_envoiCaractere('0');
	}	
	else
	{
		// Gestion de l'affichage du signe moins dans le cas d'un nombre négatif
		if(entier < 0)
		{
			MYAVRLCD_envoiCaractere('-');
			entier = -entier;	// Repassage du nombre en positif
		}
		
		// Construction de la chaîne de caractères correspondante
		// Principe: divisions successives par 10 pour récupérer chaque digit
		//           jusqu'à arriver à 0.
		while(entier>0 && compteur <= 10)
		{
			caracteres[compteur] = entier % 10;  // Récupération du digit actuel
			entier /= 10;   // Passage au digit suivant
			compteur++;
		}
		
		// Affichage de la chaîne (on commence par les derniers digit
		// puisque la construction s'est faites dans le sens inverse)
		for(;compteur>0; compteur--)
		{
			MYAVRLCD_envoiCaractere('0' + caracteres[compteur-1]);
		}
	}
}

// Affiche une variable de type double à l'écran avec un nombre de décimales définit
void MYAVRLCD_afficherDouble(double vdouble, int nb_decimales)
{
	unsigned long fraction;
	unsigned long fraction_successives;
	unsigned long multiple = 1;
	int nb_decimales_affichees = nb_decimales - 1;

// Etape 1 : Affichage de la valeur entière
	MYAVRLCD_afficherEntier((int) vdouble);

// Etape 2 : Affichage de la partie décimale
	// Principe : Multiplication successive par 10 pour construire le nombre entier
	//            correspondant aux décimales
	
	if (nb_decimales > 0)
	{
		// Affichage de la virgule
		MYAVRLCD_envoiCaractere(',');
		
		// Récupération du premier diviseur
		while(nb_decimales--)
		{
			multiple *= 10;
		}
		
		// Toute la partie décimale est transformée en partie entière		
		// Nombre positif
		if (vdouble >= 0)
		{
			fraction = (vdouble - (int) vdouble) * multiple;
		}
		// Nombre négatif
		else
		{
			fraction = ((int) vdouble - vdouble) * multiple;		
		}
		
		fraction_successives = fraction;
		
		// Vérification si besoin de rajouter des zéros après la virgule
		// avant d'afficher la partie décimale
		while(fraction_successives /= 10)
		{
			nb_decimales_affichees--;
		}
		
		// Affichage des zéros si besoin
		while(nb_decimales_affichees--)
		{
			MYAVRLCD_envoiCaractere('0');
		}
		
		// Affichage de la partie décimale
		MYAVRLCD_afficherEntier((int) fraction);
	}
}
//--------------------------------------------------------------------------