-
Notifications
You must be signed in to change notification settings - Fork 0
/
GLCD2.h~RF1ed56069.TMP
321 lines (282 loc) · 16 KB
/
GLCD2.h~RF1ed56069.TMP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
//////////////////////////////////////////////////////////////////////////////////////////
// DÉCLARATIONS POUR LIBRAIRIE GLCD.C //
//////////////////////////////////////////////////////////////////////////////////////////
// Auteur : Steve Romaric Tchuinte //
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// DEFINES //
//////////////////////////////////////////////////////////////////////////////////////////
#include <stdint.h>
//#include "LPC17xx_Bits.h"
#include "type.h"
// Pins de contrôle
// -----------------
#define LCD_EN 0x00080000 // P0.19
#define LCD_LE 0x00100000 // P0.20
#define LCD_DIR 0x00200000 // P0.21
#define LCD_CS 0x00400000 // P0.22
#define LCD_RS 0x00800000 // P0.23
#define LCD_WR 0x01000000 // P0.24
#define LCD_RD 0x02000000 // P0.25
// Couleurs standard pour 65K
// --------------------------
#define WHITE 0xFFFF // RGB = Blanc
#define BLACK 0x0000 // Noir
#define BLUE 0x003F // Bleu (b5/b0)
#define RED 0xF800 // Rouge (b15/b11)
#define GREEN 0x07C0 // Vert (b10/b6)
#define GREENLIGHT 0x3FCF // Vert clair
#define YELLOW 0xFFC0 // Jaune = rouge + vert
#define CYAN 0x07FF // Cyan = vert + bleu
#define GREY 0xC638 // gris clair
#define GREYDARK 0x8430 // gris foncé
#define GREYDARKDARK 0x4208 // gris très foncé 00 001000
#define PINK 0xF9CF // rose
#define BLUELIGHT 0x7BFF // bleu clair
#define ORANGE 0xF4DE
#define ORANGE1 0xF4DF
#define TURQUOISE 0xFFCC
#define VGA_BLACK 0x0000
#define VGA_WHITE 0xFFFF
#define VGA_RED 0xF800
#define VGA_GREEN 0x0400
#define VGA_BLUE 0x001F
#define VGA_SILVER 0xC618
#define VGA_GRAY 0x8410
#define VGA_MAROON 0x8000
#define VGA_YELLOW 0xFFE0
#define VGA_OLIVE 0x8400
#define VGA_LIME 0x07E0
#define VGA_AQUA 0x07FF
#define VGA_TEAL 0x0410
#define VGA_NAVY 0x0010
#define VGA_FUCHSIA 0xF81F
#define VGA_PURPLE 0x8010
//#define VGA_TRANSPARENT 0xFFFFFFFF
// GLCD RGB color definitions;
#define Black 0x0000 /* 0, 0, 0 */
#define Navy 0x000F /* 0, 0, 128 */
#define DarkGreen 0x03E0 /* 0, 128, 0 */
#define DarkCyan 0x03EF /* 0, 128, 128 */
#define Maroon 0x7800 /* 128, 0, 0 */
#define Purple 0x780F /* 128, 0, 128 */
#define Olive 0x7BE0 /* 128, 128, 0 */
#define Grey 0xF7DE
#define LightGrey 0xC618 /* 192, 192, 192 */
#define DarkGrey 0x7BEF /* 128, 128, 128 */
#define Blue 0x001F /* 0, 0, 255 */
#define Blue2 0x051F
#define Green 0x07E0 /* 0, 255, 0 */
#define Cyan 0x07FF /* 0, 255, 255 */
#define Red 0xF800 /* 255, 0, 0 */
#define Magenta 0xF81F /* 255, 0, 255 */
#define Yellow 0xFFE0 /* 255, 255, 0 */
#define White 0xFFFF /* 255, 255, 255 */
// Autres
// ------
#define LCD_WIDTH 320 // Largeur écran : écran couché
#define LCD_HEIGHT 240 // hauteur écran : idem
//////////////////////////////////////////////////////////////////////////////////////////
// STRUCTURES //
////////////////////////////////////////////////////////////////////////////////////////
typedef struct
{
uint16_t X1; // coordonnées coin supérieur gauche rectangle
uint16_t Y1;
uint16_t X2; // coordonnées coin inférieur droit rectangle
uint16_t Y2;
uint16_t *Xt; // coordonnées 1er caractère de chaque ligne du texte
uint16_t *Yt;
unsigned char *Text; // texte: terminé par 0x00, passage ligne = 0x0A(\n)
uint16_t FillColor; // couleur de remplissage du bouton
uint16_t LightColor; // couleur de lumière
uint16_t ShadowColor; // couleur d'ombrage
uint16_t TextColor; // couleur du texte
}GLCD_Button;
//////////////////////////////////////////////////////////////////////////////////////////
// PROTOTYPES //
////////////////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------
// OBTIENT SI L'ÉCRAN A ÉTÉ CORRECTEMENT CONFIGURÉ
// return : true si écran configuré
//----------------------------------------------------------------------------------------
extern Boolean GLCD_GetStatus(void);
//----------------------------------------------------------------------------------------
// INITIALISE ET ALLUME L'AFFICHEUR LCD
// La méthode Timing_InitializeTimer() doit avoir été appelée, sinon le timer0 sera utilisé
// par défaut pour générer les délais
// Ne prend en charge que les afficheurs pilotés par le driver SSD1289
// return: false si échec
//----------------------------------------------------------------------------------------
extern Boolean GLCD_Initialize (void); // Initialise l'afficheur
//----------------------------------------------------------------------------------------
// ALLUME L'AFFICHEUR LCD DÉJA INITIALISÉ
//----------------------------------------------------------------------------------------
extern void GLCD_On(void);
//----------------------------------------------------------------------------------------
// ÉTEINT L'AFFICHEUR LCD
//----------------------------------------------------------------------------------------
extern void GLCD_Off(void);
//----------------------------------------------------------------------------------------
// ENTRE EN MODE SLEEP
//----------------------------------------------------------------------------------------
extern void GLCD_EnterSleep(void);
//----------------------------------------------------------------------------------------
// QUITTE LE MODE SLEEP
//----------------------------------------------------------------------------------------
extern void GLCD_ExitSleep(void);
//----------------------------------------------------------------------------------------
// EFFACE L'ÉCRAN AVEC LA COULEUR DE FOND PRÉCISÉE
// color : couleur de fond en RGB : 5 bits rouge, 6 bits vert, 5 bits bleu
//----------------------------------------------------------------------------------------
extern void GLCD_Clear (unsigned short color); // Efface l'écran avec la couleur précisée (65K)
//----------------------------------------------------------------------------------------
// CONFIGURE LES COULEURS DU TEXTE
// backColor : Couleur de fond
// foreColor : Couleur d'écriture
//----------------------------------------------------------------------------------------
extern void GLCD_SetTextColors(unsigned short backColor, unsigned short foreColor);
//----------------------------------------------------------------------------------------
// CONFIGURE LA COULEUR DU TEXTE
// foreColor : Couleur d'écriture
//----------------------------------------------------------------------------------------
extern void GLCD_SetTextColor(unsigned short foreColor);
//----------------------------------------------------------------------------------------
// FENÊTRE D'ÉCRITURE = TOUT L'ÉCRAN
//----------------------------------------------------------------------------------------
extern void GLCD_WindowScreen(void);
//----------------------------------------------------------------------------------------
// FENÊTRE D'ÉCRITURE = RECTANGLE PRÉCISÉ
// x: abcisse du coin supérieur gauche de la zone, par rapport au coin supérieur gauche LCD
// y : ordonnée du coin supérieur gauche : idem
// width : largeur de la zone
// height : hauteur de la zone
// return : true si les paramètres sont corrects
//----------------------------------------------------------------------------------------
extern Boolean GLCD_SetWindow(uint16_t x, uint16_t y, uint16_t width, uint16_t height);
//----------------------------------------------------------------------------------------
// ÉCRITURE D'UN CARACTÈRE : BAS NIVEAU - COORDONNÉES ABSOLUES
// x : abscisse de départ du coin supérieur gauche par rapport au coin supérieur gauche LCD
// y : ordonnée de départ du coin supérieur gauche : idem
// car : pointeur sur le premier mot de 16 bits composant le caractère à afficher
//----------------------------------------------------------------------------------------
extern void GLCD_WriteChar(uint16_t x, uint16_t y, uint16_t *car);
void GLCD_WriteChar1(unsigned int x, unsigned int y, unsigned char *car);
//----------------------------------------------------------------------------------------
// ÉCRITURE D'UN CARACTÈRE : HAUT NIVEAU
// x : abscisse du coin supérieur gauche du caractère
// y : ordonnée du coin supérieur gauche du caractère
// car : code ASCII du caractère
//----------------------------------------------------------------------------------------
extern void GLCD_PrintChar(uint16_t x, uint16_t y, unsigned char car);
//----------------------------------------------------------------------------------------
// ÉCRITURE D'UN TEXTE
// x : abscisse du coin supérieur gauche du premier caractère
// y : ordonnée du coin supérieur gauche du premier carac
// *str : pointeur sur la chaine de caractères terminée par un zéro
// Le caractère 0x0A provoque un saut de ligne, 0x00 indique la fin de la chaîne
// 0x0A = séquence \n
//----------------------------------------------------------------------------------------
extern void GLCD_Print(uint16_t x, uint16_t y, unsigned char *str);
//----------------------------------------------------------------------------------------
// ÉCRITURE D'UNE VALEUR NON SIGNÉE CODÉE SUR 8 BITS AVEC LE NOMBRE MINIMAL DE CHIFFRES PRÉCIS2
// x: Abscisse du coin supérieur gauche du premier chiffre
// y: Ordonnée du coin supérieur gauche du premier chiffre
// value: valeur à convertir, 8 bits non signée
// minDigits: Nombre minimal de chiffres demandés (complétion éventuelle avec des "0" à gauche)
// return: Nombre de digits réellements imprimés
//----------------------------------------------------------------------------------------
extern int GLCD_Print_Val8(uint16_t x, uint16_t y, unsigned char value, unsigned char minDigits);
extern int GLCD_Print_Val81(uint16_t x, uint16_t y, unsigned char value, unsigned char minDigits);
extern int GLCD_Print_Val4(uint16_t x, uint16_t y, unsigned char value, unsigned char minDigits);
//extern void hour_min_sec1(uint16_t x, uint16_t y,unsigned short h, unsigned short m, unsigned short s);
//extern char hour_min_sec(uint16_t x, uint16_t y,unsigned short h, unsigned short m, unsigned short s);
//----------------------------------------------------------------------------------------
// ÉCRIT UNE VALEUR NON SIGNÉE CODÉE DANS UN UINT16_T AVEC LE NOMBRE MINIMAL DE CHIFFRE PRÉCISÉ
// x: Abscisse du coin supérieur gauche du premier chiffre
// y: Ordonnée du coin supérieur gauche du premier chiffre
// value: valeur à convertir, 8 bits non signée
// minDigits: Nombre minimal de chiffres demandés (complété avec des "0" à gauche)
// return: Nombre de digits réellements imprimés
//----------------------------------------------------------------------------------------
extern int GLCD_Print_Val16(uint16_t x, uint16_t y, uint16_t value, unsigned char minDigits);
extern int GLCD_Print_Val32(uint32_t x, uint32_t y, uint32_t value, unsigned char minDigits);
//----------------------------------------------------------------------------------------
// ÉCRITURE D'UNE LIGNE DE TEXTE AVEC LA COULEUR SPÉCIFIÉE
// x : abscisse du coin supérieur gauche du premier caractère
// y : ordonnée du coin supérieur gauche du premier carac
// *str : pointeur sur la chaine de caractères terminée par un zéro
// color : couleur du texte
// Ne modifie pas la couleur de texte par défaut
//----------------------------------------------------------------------------------------
extern void GLCD_PrintColor(uint16_t x, uint16_t y, unsigned char *str, uint16_t color);
//----------------------------------------------------------------------------------------
// EFFACE LES LIGNES DE TEXTE PRÉCISÉES
// y: ordonnée du coin supérieur gauche de la ligne
// nbLines : nombre de lignes
//----------------------------------------------------------------------------------------
extern void GLCD_ClearLines(uint16_t y, unsigned char nbLines);
//----------------------------------------------------------------------------------------
// EFFACE LA LIGNE DE TEXTE PRÉCISÉE
// y: Ordonnée coin supérieur gauche de la ligne
//----------------------------------------------------------------------------------------
extern void GLCD_ClearLine(uint16_t y);
//----------------------------------------------------------------------------------------
// ALLUME UN PIXEL AVEC LA COULEUR SPÉCIFIÉE
// x : abscisse du point
// y : ordonnée du point
// color : Couleur du point
// return: true si OK, false si coordonnées incorrectes
//----------------------------------------------------------------------------------------
extern Boolean GLCD_SetPoint(uint16_t x, uint16_t y, uint16_t color);
//----------------------------------------------------------------------------------------
// TRACE UNE LIGNE DE LA COULEUR SPÉCIFIÉE
// x1 : Abscisse du point d'origine
// y1 : ordonnée du point d'origine
// x2 : abscisse du point d'extrémité
// y2 : ordonnée du point d'extrémité
// color : Couleur de la ligne
// return : false si erreurs de coordonnées, true si OK
//----------------------------------------------------------------------------------------
extern Boolean GLCD_DrawLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color);
//----------------------------------------------------------------------------------------
// TRACE UNE CROIX CENTRÉE SUR LE POINT SPÉCIFIÉ
// x : abscisse du centre
// y : ordonnée du centre
// len : Longueur des branches par rapport au centre
// color : couleur des branches
// centerColor : couleur du point central
// return: true si dessin possible
//----------------------------------------------------------------------------------------
extern Boolean GLCD_DrawCross(uint16_t x, uint16_t y, unsigned char len, uint16_t color, uint16_t centerColor);
//----------------------------------------------------------------------------------------
// TRACE UN RECTANGLE DE LA COULEUR SPéCIFIÉE
// x1 : Abscisse du coin supérieur gauche
// y1 : ordonnée du coin supérieur gauche
// x2 : abscisse du coin inférieur droit
// y2 : ordonnée du coin inférieur droit
// color : Couleur du rectangle
// return : false si erreurs de coordonnées, true si OK
//----------------------------------------------------------------------------------------
extern Boolean GLCD_DrawRect(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color);
//----------------------------------------------------------------------------------------
// REMPLI UN RECTANGLE AVEC LA COULEUR SPÉCIFIÉE
// x1 : Abscisse du coin supérieur gauche
// y1 : ordonnée du coin supérieur gauche
// x2 : abscisse du coin inférieur droit
// y2 : ordonnée du coin inférieur droit
// fillColor : Couleur de remplissage
//----------------------------------------------------------------------------------------
extern void GLCD_FillRect(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t fillColor);
//----------------------------------------------------------------------------------------
// DESSINE UN BOUTON
// button : pointeur sur la structure définissant le bouton
//----------------------------------------------------------------------------------------
extern void GLCD_DrawButton(GLCD_Button *button);
//----------------------------------------------------------------------------------------
// DESSINE UN ENSEMBLE DE BOUTONS
// buttons : pointeur sur le tableau de structures définissant les boutons
// size : nombre de boutons
//----------------------------------------------------------------------------------------
extern void GLCD_DrawButtons(GLCD_Button *buttons, unsigned char size);
extern int GLCD_Print_ValFloat(uint32_t x, uint32_t y, double v_floatNum_f32, unsigned char minDigits);