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 graphique MK3

Introduction

Les plate-formes de développement MK3 mySmartControl et myAVRBoard contiennent un écran graphique 64x128 pixcels. Afin de vous aider dans vos développements, nous avons écrit une librairie simple de gestion du LCD graphique myAVR.

Cette librairie reprend toutes les fonctions basiques permettant de piloter l'écran LCD mais également des fonctions plus sophistiquées pour dessiner des droites, rectangles, cercles mais aussi afficher n'importe quel caractères ASCII et 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).

Vous pouvez bien sur vous inspirer de cette librairie pour la compléter et crée vos propres fonctions graphiques. 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 24/05/10

//--------------------------------------------------------------------------
// Titre         :  Header Librairie de gestion LCD graphique 
//					de myAVR Board MK3 et mySmartControl MK3
//--------------------------------------------------------------------------
// Fonction      : Fonctions de gestion du LCD graphique
//--------------------------------------------------------------------------
// Processeur    : atmega640/atmega2560
// Langage       : C
// Date          : 16/05/2010
// Version       : 1.0
// Auteur        : Devtronic SARL - Laser&Co
//--------------------------------------------------------------------------
//en: defines for a better abridgement which port what do 
#define PortLcdData PORTC
#define PortLcdDataPIN PINC
#define PortLcdDataDDR DDRC
#define PortLcdCtrl PORTA
#define PortLcdCtrlDDR DDRA
#define PortLed PORTL
#define PortLedDDR DDRL
#define true 1
#define ASCIItableWIDTH 6

#include	<global.h>
#include 	<avr/io.h>

//----------------------------------------------------------------------
// LCD-Funktionen - Implementation
//----------------------------------------------------------------------
//en: counts a value from 0 to x
//en:    PE: x = highest index   
void MYAVRGRAPHIC_wait(uint16_t x);
//en: send data to the LCD, ist used by lcdSendData()
//en:    PE: data = data to send
void MYAVRGRAPHIC_lcdSend(uint8_t data);
//en: to initialise the LCD
void MYAVRGRAPHIC_lcdInit(void);
//en: send a control command to the LCD
//en:    PE: data = control command
void MYAVRGRAPHIC_lcdSendCmd(uint8_t data);
//en: writes a byte on the actual position at the LCD (actual position is increase by one)
//en:    PE: data = the byte
void MYAVRGRAPHIC_lcdSendData(uint8_t data);
//en: reads a byte from the actual postion at the LCD (actual position is not changed)
//en:    PA: the byte
uint8_t MYAVRGRAPHIC_lcdReadData(void);
//en: Set the position for the next output, for text e. g.
//en: the y-value is round down to a 8like value (0,8,16,24...56)
//en:    PE: x = x-coordinate 0...127; y = y-coordinate 0...63  
void MYAVRGRAPHIC_lcdSetPos(uint8_t x, uint8_t y);
//en: move to the inputline to the actual line on the LCD (srcolleffect)
//en:    PE: Line = number of the line to goto
void MYAVRGRAPHIC_lcdGotoLine(uint8_t line);
//en: clears all data on the LCD
void MYAVRGRAPHIC_lcdClear(void);
//en: inverse display (dark at bright backround/ bright at dark backround)
//en:    PE: on = off/on 0/1; 0 = normal (dark at blight backround); 1 = inverse (blight at dark backround)
void MYAVRGRAPHIC_lcdSendCmdReverse(uint8_t jn);
//en: turn the display on/off
//en:    PE: on = on/off 0/1; 0 = display on; 1 = display off (complete dark) 
void MYAVRGRAPHIC_lcdSendCmdOn(uint8_t on);
//en: set a Pixel on position x,y at the LCD
//en:    PE: x = x-coordinate 0...127; y = y-coordinate 0...63
void MYAVRGRAPHIC_lcdSetPixel(uint8_t x, uint8_t y);

//fr: liste des fonctions évolué permettant l'affichage de lettres et formes de base
void MYAVRGRAPHIC_printChar(char xchar);
void MYAVRGRAPHIC_printChain(char *chain, int nb_char);
void MYAVRGRAPHIC_PrintCircle(uint8_t x1,uint8_t y1,uint8_t r);
void MYAVRGRAPHIC_PrintLine(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2);
void MYAVRGRAPHIC_PrintFullSquare(uint8_t x1,uint8_t y1,uint8_t w);
void MYAVRGRAPHIC_PrintRectangle(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2);
void MYAVRGRAPHIC_afficherEntier(int entier);
void MYAVRGRAPHIC_afficherDouble(double vdouble, int nb_decimales);

//--------------------------------------------------------------------------
// Titre         : Librairie de gestion LCD graphique 
//					de myAVR Board MK3 et mySmartControl MK3
//--------------------------------------------------------------------------
// Fonction      : Fonctions de gestion du LCD graphique
//--------------------------------------------------------------------------
// Processeur    : ATmega8/48/88/168/atmega640/atmega2560
// Langage       : C
// Date          : 16/05/2010
// Version       : 1.0
// Auteur        : Devtronic SARL - Laser&Co
//--------------------------------------------------------------------------
#include "myavr_graphic.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
#include <math.h>			//fonction mathematiques pour sqrt()
//--------------------------------------------------------------------------

// en: definition of the complete table of characters, size per char is 6x8 pixcel (char on 5x7 + border)
// fr: definition de la table des caractères, la taille d'un caracatère est 6x8 pixcels (graphique sur 5x7 + bordure cotés droit et haut)
uint8_t ASCIItable[]={
	0b11111110,0b11111110,0b11111110,0b11111110,0b11111110,0,	/*  */
	0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0,	/*space*/
	0b00000000,0b00000000,0b10111110,0b00000000,0b00000000,0,	/* ! */
	0b00000000,0b00000110,0b00000000,0b00000110,0b00000000,0,	/* " */
	0b00101000,0b11111110,0b00101000,0b11111110,0b00101000,0,	/* # */
	0b10001100,0b10010010,0b11111110,0b10010010,0b01100010,0,	/* $ */		
	0b01000110,0b00100110,0b00010000,0b11001000,0b11000100,0,	/* % */
	0b01101100,0b10011100,0b10100000,0b01000000,0b10100000,0,	/* & */
	0b00000000,0b00000000,0b00000110,0b00000000,0b00000000,0,	/* ' */
	0b00111000,0b01000100,0b10000010,0b10000010,0b00000000,0,	/* ( */
	0b00000000,0b10000010,0b10000010,0b01000100,0b00111000,0,	/* ) */
	0b01000110,0b00100110,0b00010000,0b11001000,0b11000100,0,	/* * */
	0b00000000,0b00010000,0b00111000,0b00010000,0b00000000,0,	/* + */
	0b00000000,0b00000000,0b10000000,0b01000000,0b00000000,0,	/* , */
	0b00000000,0b00010000,0b00010000,0b00010000,0b00000000,0,	/* - */
	0b00000000,0b00000000,0b10000000,0b00000000,0b00000000,0,	/* . */
	0b01000000,0b00100000,0b00010000,0b00001000,0b00000100,0,	/* / */
	0b01111100,0b10000010,0b10000010,0b10000010,0b01111100,0,	/* 0 */
	0b10001000,0b10000100,0b11111110,0b10000000,0b10000000,0,	/* 1 */
	0b10000100,0b11000010,0b10100010,0b10010010,0b10001100,0,	/* 2 */
	0b01000100,0b10010010,0b10010010,0b10010010,0b01101100,0,	/* 3 */
	0b01100000,0b01011000,0b01000100,0b11111110,0b01000000,0,	/* 4 */
	0b01001110,0b10001010,0b10001010,0b10001010,0b01110010,0,	/* 5 */
	0b01111100,0b10010010,0b10010010,0b10010010,0b01100100,0,	/* 6 */
	0b00000010,0b11000010,0b00110010,0b00001110,0b00000010,0,	/* 7 */
	0b01101100,0b10010010,0b10010010,0b10010010,0b01101100,0,	/* 8 */
	0b01001100,0b10010010,0b10010010,0b10010010,0b01111100,0,	/* 9 */
	0b11111000,0b00010100,0b00010010,0b00010100,0b11111000,0,	/* A */
	0b11111110,0b10010010,0b10010010,0b10010010,0b01101100,0,	/* B */
	0b00111000,0b01000100,0b10000010,0b10000010,0b10000010,0,	/* C */
	0b11111110,0b10000010,0b10000010,0b01000100,0b00111000,0,  /* D */
	0b11111110,0b10010010,0b10010010,0b10010010,0b10000010,0,  /* E */
	0b11111110,0b00010010,0b00010010,0b00010010,0b00000010,0,  /* F */
	0b00111000,0b01000100,0b10000010,0b10100010,0b11100010,0,  /* G */
	0b11111110,0b00010000,0b00010000,0b00010000,0b11111110,0,	/* H */
	0b00000000,0b10000010,0b11111110,0b10000010,0b00000000,0,	/* I */
	0b10000000,0b10000010,0b10000010,0b01111110,0b00000000,0,	/* J */
	0b11111110,0b00010000,0b00101000,0b01000100,0b10000010,0,	/* K */
	0b11111110,0b10000000,0b10000000,0b10000000,0b10000000,0,	/* L */
	0b11111110,0b00001100,0b00010000,0b00001100,0b11111110,0,	/* M */
	0b11111110,0b00001100,0b00010000,0b01100000,0b11111110,0,	/* N */
	0b00111000,0b01000100,0b10000010,0b01000100,0b00111000,0,	/* 0 */
	0b11111110,0b00010010,0b00010010,0b00010010,0b00001100,0,	/* P */
	0b00111000,0b01000100,0b10100010,0b01000100,0b10111000,0,	/* Q */
	0b11111110,0b00010010,0b00110010,0b01010010,0b10001100,0,	/* R */	
	0b10001100,0b10010010,0b10010010,0b10010010,0b01100010,0,	/* S */		
	0b00000010,0b00000010,0b11111110,0b00000010,0b00000010,0,	/* T */		
	0b01111110,0b10000000,0b10000000,0b10000000,0b01111110,0,	/* U */
	0b00111110,0b01000000,0b10000000,0b01000000,0b00111110,0,	/* V */
	0b01111110,0b10000000,0b01110000,0b10000000,0b01111110,0,	/* W */
	0b10000010,0b01101100,0b00010000,0b01101100,0b10000010,0,	/* X */
	0b00000110,0b00001000,0b11110000,0b00001000,0b00000110,0,	/* Y */
	0b10000010,0b11100010,0b10010010,0b10001110,0b10000010,0,	/* Z */
	0b00000000,0b11111110,0b10000010,0b10000010,0b00000000,0,	/* [ */
	0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0,	/* \ */
	0b00000000,0b10000010,0b10000010,0b11111110,0b00000000,0,	/* ] */
	0b00000000,0b00000100,0b00000010,0b00000100,0b00000000,0,	/* ^ */
	0b10000000,0b10000000,0b10000000,0b10000000,0b10000000,0,	/* _ */
	0b00000000,0b00000000,0b00000010,0b00000100,0b00000000,0,	/* ` */
	0b01100000,0b10010100,0b10010100,0b11111000,0b10000000,0,	/* a */
	0b11111110,0b01010000,0b10001000,0b10001000,0b01110000,0,	/* b */
	0b01110000,0b10001000,0b10001000,0b10001000,0b00000000,0,	/* c */
	0b01110000,0b10001000,0b10001000,0b01010000,0b11111100,0,	/* d */
	0b01110000,0b10011000,0b10011000,0b10010000,0b00000000,0,	/* e */
	0b00010000,0b11111000,0b00010100,0b00010100,0b00000000,0,	/* f */	
	0b00011000,0b10100100,0b10100100,0b10101000,0b01111100,0,	/* g */	
	0b11111110,0b00010000,0b00001000,0b00001000,0b11110000,0,	/* h */	
	0b00000000,0b00001000,0b11111010,0b00000000,0b00000000,0,	/* i */
	0b00000000,0b10000000,0b10001000,0b01111010,0b00000000,0,	/* j */
	0b00000000,0b11111110,0b00100000,0b01010000,0b10001000,0,	/* k */	
	0b00000000,0b00000010,0b11111110,0b00000000,0b00000000,0,	/* l */
	0b11110000,0b00001000,0b11110000,0b00001000,0b11110000,0,	/* m */
	0b11111000,0b00010000,0b00001000,0b00001000,0b11110000,0,	/* n */
	0b01110000,0b10001000,0b10001000,0b10001000,0b01110000,0,	/* o */
	0b11111100,0b00101000,0b00100100,0b00100100,0b00011000,0,	/* p */
	0b00011000,0b00100100,0b00100100,0b00101000,0b11111100,0,	/* q */
	0b11111000,0b00010000,0b00001000,0b00001000,0b00010000,0,	/* r */
	0b10010000,0b10101000,0b10101000,0b10101000,0b01001000,0,	/* s */
	0b00010000,0b01111100,0b10010000,0b10010000,0b00000000,0,	/* t */
	0b01111000,0b10000000,0b10000000,0b01000000,0b11111000,0,	/* u */
	0b00011000,0b01100000,0b10000000,0b01100000,0b00011000,0,	/* v */
	0b01111000,0b10000000,0b01110000,0b10000000,0b01111000,0,	/* w */
	0b10001000,0b01010000,0b00100000,0b01010000,0b10001000,0,	/* x */
	0b10001000,0b10010000,0b01100000,0b00010000,0b00001000,0,	/* y */
	0b10001000,0b11001000,0b10101000,0b10011000,0b10001000,0,	/* z */
	0b00000000,0b00010000,0b01101100,0b10000010,0b00000000,0,	/* { */
	0b00000000,0b00000000,0b11111110,0b00000000,0b00000000,0,	/* | */
	0b00000000,0b10000010,0b01101100,0b00010000,0b00000000,0,	/* } */
	0b00100000,0b00010000,0b00010000,0b00100000,0b00010000,0,	/* ~ */
	0
};

//en: counts a value from 0 to x
//en:    PE: x = highest index
//fr:  fonction delai, simple compteur jusqu'à x 
//fr: Param: x = valeur à décompter  
void MYAVRGRAPHIC_wait(uint16_t x)
{
	//de:  Zählschleife
	//en: loop
	while (x>0)
		//de:  x um eins erhöhen
		//en: incraese x by one
		x--;
}
//en: send data to the LCD, ist used by MYAVRGRAPHIC_lcdSendData()
//en:    PE: data = data to send
//fr: envoi une donnée au LCD (sous fonction de MYAVRGRAPHIC_lcdSendData et MYAVRGRAPHIC_lcdSendCmd)
//fr: Param: data = donnée à transmettre au LCD, peut être une commande ou une data
void MYAVRGRAPHIC_lcdSend(uint8_t data)
{
	//en: bit 3 on port-A clear (write on LCD)
	cbi(PortLcdCtrl,3);
	//en: data on port-C
	PortLcdData=data;
	//en: config port-C as output
	PortLcdDataDDR=0xFF;
	//en: bit 0 on port-A clear (chipselect = on)
	cbi(PortLcdCtrl,0);
	//en: set bit 4 on port-A; E = 1 (Write with highpuls on E)
	sbi(PortLcdCtrl,4);
	//en: inlineassembler: wait
	__asm volatile ("nop \n nop \n nop \n");
	//en: bit 4 on port-A clear; E = 0
	cbi(PortLcdCtrl,4);				
	//en: set bit 0 on port-A (chipselect = off)
	sbi(PortLcdCtrl,0);
}
//----------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------
// LCD-Funktionen - Implementation
//----------------------------------------------------------------------
//en: to initialise the LCD
//fr: initialisation du LCD
void MYAVRGRAPHIC_lcdInit(void)
{
	//en: wait
	MYAVRGRAPHIC_wait(60000);	
	//en:  light off
	PortLcdCtrl&=~0b00100000;
	//en: set bit 0 on port-A (chipselect = off)
	sbi(PortLcdCtrl,0);
	//en: set bit 7 on port-A (parallel on)
	sbi(PortLcdCtrl,7);
	//en: set bit 6 on port-A (6800 mode)
	sbi(PortLcdCtrl,6);

//en: reset the LCD
	PortLcdCtrl&=~0b00000010;
	MYAVRGRAPHIC_wait(10000);	
	PortLcdCtrl|=0b00000010;
	MYAVRGRAPHIC_wait(10000);

//en: send different controlcommand to the LCD (datasheet for details)
	
	// internal Reset 
	MYAVRGRAPHIC_lcdSendCmd(0xE2);
	// ADC select	
	MYAVRGRAPHIC_lcdSendCmd(0xA0);
	// COM output scan direction = revers 	
	MYAVRGRAPHIC_lcdSendCmd(0xC8);
	// LCD drive voltage bias ratio 	
	MYAVRGRAPHIC_lcdSendCmd(0xA2);
	// no idea 
	MYAVRGRAPHIC_lcdSendCmd(0x2F);
	// no idea
	MYAVRGRAPHIC_lcdSendCmd(0x26);
	// select booster ratio	
	MYAVRGRAPHIC_lcdSendCmd(0xF8);
	// no idea	
	MYAVRGRAPHIC_lcdSendCmd(0x00);
	// set output voltage	
	MYAVRGRAPHIC_lcdSendCmd(0x81);
	// no idea	
	MYAVRGRAPHIC_lcdSendCmd(0x09);
	// read-modify-write	
	MYAVRGRAPHIC_lcdSendCmd(0xE0);	
	// display on
	MYAVRGRAPHIC_lcdSendCmd(0xAF);	
}
//--------------------
//en: send a control command to the LCD
//en:    PE: data = control command
void MYAVRGRAPHIC_lcdSendCmd(uint8_t data)
{
	//en: bit 2 on port-A clear (datakind = controlcomand)
	cbi(PortLcdCtrl,2);
	//en: send 
	MYAVRGRAPHIC_lcdSend(data);
}
//--------------------
//en: writes a byte on the actual position at the LCD (actual position is increase by one)
//en:    PE: data = the byte
void MYAVRGRAPHIC_lcdSendData(uint8_t data)
{
	
	//en: set bit 2 on port-A (datakind = data)
	sbi(PortLcdCtrl,2);
	//en: send 
	MYAVRGRAPHIC_lcdSend(data);
}
//--------------------
//en: reads a byte from the actual postion at the LCD (actual position is not changed)
//en:    PA: the byte
uint8_t lcdReadData(void)
{
	uint8_t data;

//en: config port-C as input (for read)
	PortLcdDataDDR=0x00;
	//en: set bit 2 on port-A (datakind = data)
	sbi(PortLcdCtrl,2);
	//en: set bit 3 on port-A (read)
	sbi(PortLcdCtrl,3);
	//en: bit 0 on port-A clear (chipselect = on)
	cbi(PortLcdCtrl,0);

//en: a DUMMY-read after adress-change (MUSTBE!)

//en: set bit 4 on port-A (create a edge)
	sbi(PortLcdCtrl,4);
	//en: inlineassembler: wait
	__asm volatile ("nop \n nop \n nop \n");
	//en: bit 4 on port-A clear 
	cbi(PortLcdCtrl,4);

//en: end DUMMY-read

//en: set bit 4 on port-A (create a edge)
	sbi(PortLcdCtrl,4);
	//en: inlineassembler: wait
	__asm volatile ("nop \n nop \n nop \n");
	//en: get data on PIN-C
	data=PortLcdDataPIN;
	//en: bit 4 on port-A clear 
	cbi(PortLcdCtrl,4);

//en: set bit 0 on port-A (chipselect = off)
	sbi(PortLcdCtrl,0);
	//en: config port-C as output
	PortLcdDataDDR=0xFF;

return data;
}
//--------------------
//en: Set the position for the next output, for text e. g.
//en: the y-value is round down to a 8like value (0,8,16,24...56)
//en:    PE: x = x-coordinate 0...127; y = y-coordinate 0...63  
//fr:  set la position de la prochaine donnée à afficher
//fr: Param: x abscisse [0..127]
//fr: Param: y ordonnée [0..63]
void MYAVRGRAPHIC_lcdSetPos(uint8_t x, uint8_t y)
{
	//en: x-coordinate
	MYAVRGRAPHIC_lcdSendCmd(0b00010000+(x>>4));
	MYAVRGRAPHIC_lcdSendCmd(0b00000000+(x&0x0f));
	//en: y-coordinate
	MYAVRGRAPHIC_lcdSendCmd(0b10110000+(y>>3));
}
//--------------------
//en: move to the inputline to the actual line on the LCD (srcolleffect)
//en:    PE: Line = number of the line to goto
//fr: se déplace à un numéro de ligne (effet de scroll)
//fr: Param: line = num de la ligne en destination 
void MYAVRGRAPHIC_lcdGotoLine(uint8_t line)
{
	//en: initial display line
	MYAVRGRAPHIC_lcdSendCmd(0b01000000+(line&0b00111111));
}
//--------------------
//en: clears all data on the LCD
//fr: efface l'ecran du LCD
void MYAVRGRAPHIC_lcdClear(void)
{
	//en: the Display consists of 128 * 8 Bytes, which are placed vertical
	//en: in each byte are bit0 up and bit7 down 
	
	//en: y-loop (vertical); 8 times, 64 pixels are 8 bytes * 8 bits   
	uint8_t y;
	uint16_t x;
	
	for(y=0;y<64;y+=8)
	{
	    //en: goto linebegin
		MYAVRGRAPHIC_lcdSetPos(0,y);
		for(x=0;x<128;x++)
			//en: set byte to 0
			MYAVRGRAPHIC_lcdSendData(0);
	}
	//en:  set actual position to leftupper corner (0,0)
	MYAVRGRAPHIC_lcdSetPos(0,0);
}
//--------------------
//en: inverse display (dark at bright backround/ bright at dark backround)
//en:    PE: on = off/on 0/1; 0 = normal (dark at blight backround); 1 = inverse (blight at dark backround)
//fr: selection de la couleur du background noir ou blanc, les pixcel actifs sont aussi inversés.
//fr: Param: jn = 0 (pixcel noir sur fond blanc), jn = 1 (pixcel blanc sur fond noir) 
void MYAVRGRAPHIC_lcdSendCmdReverse(uint8_t jn)
{
	//en: display normal/reverse
	MYAVRGRAPHIC_lcdSendCmd(0b10100110+jn);
}
//--------------------
//en: turn the display on/off
//en:    PE: on = on/off 0/1; 0 = display on; 1 = display off (complete dark)
//fr: activation du rétroéclairage
//fr: Param: on = 0 (rétyroéclairage allumé), on = 1 (rétroéclairage éteint) 
void MYAVRGRAPHIC_lcdSendCmdOn(uint8_t on)
{
	//en: all pixels on /off 
	MYAVRGRAPHIC_lcdSendCmd(0b10100100+on);
}
//--------------------
//en: set a Pixel on position x,y at the LCD
//en:    PE: x = x-coordinate 0...127; y = y-coordinate 0...63
//fr:  set un pixcel aux coordonnées en paramètres
//fr:  Param: x = abcisse du pixcel [0..127], y = ordonnée du pixcel [0..64] 
void MYAVRGRAPHIC_lcdSetPixel(uint8_t x, uint8_t y)
{
	//en: goto position
	MYAVRGRAPHIC_lcdSetPos(x,y);
	uint8_t data;
	//en: bitmask for the bit (pixel) in the byte
	data=1<<(y&0b00000111);
	//en: read the byte, set the bit, write the byte
	MYAVRGRAPHIC_lcdSendData( lcdReadData()|data );
}
//--------------------

//fr:  affiche un caractère ASCII selon la table ASCIItable[] définie plus haut
//fr:  Param: caractère à imprimer
void MYAVRGRAPHIC_printChar(char xchar){
	uint16_t i,n,m,p;
	n=(uint16_t)(xchar);
	// char is space-9
	if ((n>=32) & (n<58)){
		m=n-31;
	// char is A to ~
	}else if((n>=65) & (n<127)){
		m=n-65+27;// A is located at 26th in ASCIItable table
	}
	else{//default full rectangle when char unknown in ASCIItable[]
		m=0;// position of rectangle
	}
	
	p=ASCIItableWIDTH*m;
	for (i=0;i<ASCIItableWIDTH;i++){
		MYAVRGRAPHIC_lcdSendData(ASCIItable[p+i]);
	}
}

//fr:  affiche une chaine de caractère ASCII selon la table ASCIItable[] définie plus haut
//fr:  Param: *chain = pointeur de la chaine de caractère à imprimer
//fr:  Param: nb_char = longueur de la chaine de caractère à imprimer
void MYAVRGRAPHIC_printChain(char *chain, int nb_char)
{
	int i;
	
	if (!chain)
	{
		return;		// Si le pointeur passé en paramètre n'est pas valide => sortie de la fonction
	}
	
	for (i=0;i<nb_char;i++)
	{
		MYAVRGRAPHIC_printChar(chain[i]);
	}	
}

//fr:  Affiche un cercle de centre x1,x1 et de rayon r en pixcel
//fr:  Param: x1 abcisse du centre du cercle
//fr:  Param: y1 ordonnée du centre du cercle
//fr:  Param: r rayon du cercle
void MYAVRGRAPHIC_PrintCircle(uint8_t x1,uint8_t y1,uint8_t r){
	int8_t x,y;
	int8_t a;
	
	// pour toutes les abscisses
	for(x=(x1-r);x<=(x1+r);x++){
		// utilise l'équation cartésienne du cercle en ordonnée
		a=sqrt(r*r-(x-x1)*(x-x1));
		y=y1+a;// solution a (demi cercle droit)
		MYAVRGRAPHIC_lcdSetPixel(x,y);
		y=y1-a;// solution b (demi cercle gauche)
		MYAVRGRAPHIC_lcdSetPixel(x,y);
	}
	// pour toutes les ordonnées afin de combler les espaces
	for(y=(y1-r/2);y<=(y1+r/2);y++){
		// utilise l'équation cartésienne du cercle en abscisse
		a=sqrt(r*r-(y-y1)*(y-y1));
		x=x1+a;// solution a (demi cercle supérieur)
		MYAVRGRAPHIC_lcdSetPixel(x,y);
		x=x1-a;// solution b (demi cercle inférieur)
		MYAVRGRAPHIC_lcdSetPixel(x,y);
	}
}

//en: print a full square from x1,y1 corner with width w.
//fr:  Affiche un carré rempli de coin supérieur gauche x1,x1 et de coté w (en pixcel)
//fr:  Param: x1 abcisse du coin supérieur gauche du carré
//fr:  Param: y1 ordonnée du coin supérieur gauche du carré
//fr:  Param: w coté du carré en nb de pixcels
void MYAVRGRAPHIC_PrintFullSquare(uint8_t x1,uint8_t y1,uint8_t w){
	int8_t x,y;
	// parcours toutes les abscisses du carré
	for(x=x1;x<(x1+w);x++){
		// parcours toutes les ordonnées du carré
		for(y=y1;y<(y1+w);y++){
			// set chaque pixcel
			MYAVRGRAPHIC_lcdSetPixel(x,y);
		}
	}
}

//fr:  Affiche une ligne entre 2 points 
//fr:  Param: x1 abcisse du point 1 
//fr:  Param: y1 ordonnée du point 1
//fr:  Param: x2 abcisse du point 1 
//fr:  Param: y2 ordonnée du point 1
void MYAVRGRAPHIC_PrintLine(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2){
	int8_t x,y;
	int8_t signx= 1;
	int8_t signy= 1;
	int8_t a;
	int8_t deltax,deltay;
	// calcule la distance en pixcel entre les 2 points
	deltax=(int8_t)(x2-x1);
	deltay=(int8_t)(y2-y1);
	
	//détermine si la pente est positive ou négative en abscisse 
	if (x2<x1){
		signx=-1;
		deltax=-deltax;
	}
	//détermine si la pente est positive ou négative en ordonnée
	if (y2<y1){
		signy=-1;
		deltay=-deltay;
	}
	// parcours toutes les abscisses si la |pente| est < 1 (écrasé en abscisse)
	if (deltax > deltay){
		for(a=0;a<=deltax;a++){
			// calcule les coordonnées de chaque pixcel de la droite
			x=(uint8_t)(x1+a*signx);
			y=(uint8_t)((y1+signy*((a*deltay)/deltax)));
			MYAVRGRAPHIC_lcdSetPixel(x,y);
		}
	// parcours toutes les ordonnées si la |pente| est > 1 (écrasé en ordonée)
	}else{
		for(a=0;a<=deltay;a++){
			// calcule les coordonnées de chaque pixcel de la droite
			y=(uint8_t)(y1+a*signy);
			x=(uint8_t)((x1+signx*((a*deltax)/deltay)));
			MYAVRGRAPHIC_lcdSetPixel(x,y);
		}
	}
}

//fr:  Affiche un rectangle à partir de 2 points
//fr:  le point 1 est le coin supérieur gauche, le point 2 est le coin inférieur droit 
//fr:  Param: x1 abcisse du point 1 
//fr:  Param: y1 ordonnée du point 1
//fr:  Param: x2 abcisse du point 2 
//fr:  Param: y2 ordonnée du point 2
void MYAVRGRAPHIC_PrintRectangle(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2){
	MYAVRGRAPHIC_PrintLine(x1,y1,x1,y2);
	MYAVRGRAPHIC_PrintLine(x1,y1,x2,y1);
	MYAVRGRAPHIC_PrintLine(x1,y2,x2,y2);
	MYAVRGRAPHIC_PrintLine(x2,y1,x2,y2);
}

//fr:  Affiche un entier 
//fr:  Param: entier à afficher
void MYAVRGRAPHIC_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)
	{
		MYAVRGRAPHIC_printChar('0');
	}	
	else
	{
		// Gestion de l'affichage du signe moins dans le cas d'un nombre négatif
		if(entier < 0)
		{
			MYAVRGRAPHIC_printChar('-');
			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--)
		{
			MYAVRGRAPHIC_printChar('0' + caracteres[compteur-1]);
		}
	}
}

//fr: Affiche une variable de type double à l'écran avec un nombre de décimales définit
//fr:  Param: vdouble= valeur à afficher
//fr:  Param: nb_decimales= nb de décimales après la virgule
void MYAVRGRAPHIC_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
	MYAVRGRAPHIC_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
		MYAVRGRAPHIC_printChar(',');
		
		// 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--)
		{
			MYAVRGRAPHIC_printChar('0');
		}
		
		// Affichage de la partie décimale
		MYAVRGRAPHIC_afficherEntier((int) fraction);
	}
}