J'ai codé une librairie (en m'inspirant d'un code déjà existant) pour utilisé un lcd5510
et je voulais savoir si c’était bien codé et ou je pourrais m'améliorer.

Le .c : https://pastebin.com/AiknJRxL
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
/** Private function ################################################################ */
 
/* Envoi une commande ou un octet de donnée à l'écran */
static void LCD_SendData(const uint8_t cmd, const uint8_t data)
{
    uint8_t bit  = 0;
    uint8_t byte = 0;
 
    /* Place DC suivant le mode voulu (COMMAND ou DATA) */
    if(cmd == LCD_COMMAND) PORTD &= ~(1 << PIN_DC);
    if(cmd == LCD_DATA)    PORTD |=  (1 << PIN_DC);
 
    /* Synchronisation des données */
    PORTD &= ~(1 << PIN_CE);
 
    /* Envoi la commande / donnée */
	for(byte = 0; byte < 8; byte++)
    {
        bit = data & (1 << (7 - byte));
 
        if(bit)
            PORTD |= (1 << PIN_DIN);
        else
            PORTD &= ~(1 << PIN_DIN);
 
        PORTD |=  (1 << PIN_CLK);
        PORTD &= ~(1 << PIN_CLK);
    }
 
    PORTD |= (1 << PIN_CE);
}
 
/** Extern function ################################################################ */
 
/* Initialise l'écran en envoyant la séquence d'initialisation */
void LCD_InitLCD(void)
{
    /* Place les broches de contrôle en sorties */
    DDRD |= 0xFC;
 
    /* Reset l'écran pour être sur de son état initial */
    PORTD &= ~(1 << PIN_RESET);
    PORTD |=  (1 << PIN_RESET);
 
    /* Séquence d'initialisation */
    LCD_SendData(LCD_COMMAND, PCD8544_EXTENDEDINSTRUCTION); // Extended Commands
    LCD_SendData(LCD_COMMAND, PCD8544_SETVOP); // LCD VOP (contrast) - 0xB1 @ 3v3 ou 0xBF @ 5v
    LCD_SendData(LCD_COMMAND, PCD8544_SETTEMP); // Temp coefficent
    LCD_SendData(LCD_COMMAND, PCD8544_SETBIAS); // LCD bias mode = 1:48
    LCD_SendData(LCD_COMMAND, PCD8544_FUNCTIONSET); // Function set
    LCD_SendData(LCD_COMMAND, PCD8544_DISPLAYCONTROL); // Display control = normal mode(0x0C) (0x0D pour mode négatif)
}
 
/* Actualise l'écran */
void LCD_Udapte(void)
{
    uint16_t i = 0;
 
    /* Initialise x et y aux coordonnées 0,0 */
    LCD_SendData(LCD_COMMAND, PCD8544_SETXADDR);
    LCD_SendData(LCD_COMMAND, PCD8544_SETYADDR);
 
    for(i = 0; i < LCD_BUFFER; i++)
        LCD_SendData(LCD_DATA, lcdBuf[i]);
}
 
/* Réinitialise tout les pixels de l'écran */
void LCD_Clear(void)
{
    uint16_t i = 0;
 
    for(i = 0; i < LCD_BUFFER; i++)
        lcdBuf[i] = 0x00;
}
 
/* Allume ou éteint un pixel à une position donnée */
uint8_t LCD_SetPixel(Coordonnees *coord, const uint8_t pixel)
{
    uint16_t pos   = 0;
    uint8_t bShift = 0;
 
    if((coord->x >= 0 && coord->x < 84)
    || (coord->y >= 0 && coord->y < 48))
    {
        pos  = ((coord->y / 8) * 84) + coord->x;
        bShift = coord->y % 8;
 
        if(pixel == HIGH)
            lcdBuf[pos] |= (1 << bShift);
        else
            lcdBuf[pos] &= ~(1 << bShift);
 
        return EXIT_SUCCESS;
    }
 
    return EXIT_FAILURE;
}
 
/* Récupère l'état d'un pixel (allumé ou éteint) à une position donnée */
uint8_t LCD_GetPixel(Coordonnees *coord)
{
    uint16_t pos = 0;
    uint8_t bShift = 0;
 
    if((coord->x >= 0 && coord->x < 84)
    || (coord->y >= 0 && coord->y < 48))
    {
        pos = ( (coord->y / 8) * 84) + coord->x;
        bShift = coord->y % 8;
 
        if(lcdBuf[pos] & (1 << bShift))
            return HIGH;
        else
            return LOW;
    }
 
    return EXIT_FAILURE;
}
 
/* Déssine un caractère a l'écran */
void LCD_DrawChar(const char *chr, Coordonnees *coord)
{
    uint8_t w, h  = 0;
    uint8_t bit   = 0;
    uint8_t cbyte = 0;
    const uint16_t val = (*chr - 0x20) * 5;
    Coordonnees row = {0, 0};
 
    /* Si on dépasse l'écran on sort */
    if(coord->x > 83 || coord->y > 47)
        return;
 
    /* Déssine le caractère */
    for(w = 0; w < WIDTH_FONT; w++)
    {
        cbyte = pgm_read_byte_near(asciiTable + val + w);
 
        for(h = 0; h < HEIGH_FONT; h++)
        {
            bit = cbyte & (1 << h);
 
            row.x = coord->x + w;
            row.y = coord->y + h;
 
            if(bit != LOW)
                LCD_SetPixel(&row, HIGH);
            else
                LCD_SetPixel(&row, LOW);
        }
    }
}
 
/* Déssine une chaine de caractères a l'écran */
void LCD_Print(const char *str, Coordonnees *coord)
{
    while(*str != '\0')
    {
        /* Si on dépasse l'écran on arrête */
        if(coord->x > LCD_WIDTH - WIDTH_FONT)
            return;
 
        LCD_DrawChar(str++, coord);
        coord->x += WIDTH_FONT;
    }
}
 
void LCD_DrawBitmap(const uint8_t *bitmap, Coordonnees *coord,
                                            Dimensions *dim)
{
    uint8_t bit      = 0;
    uint8_t cbyte    = 0;
    uint8_t w, h, b  = 0;
    uint16_t iBitmap = 0;
    Coordonnees row  = {0, 0};
 
    for(h = 0; h <= (dim->h / 8); h++)
    {
        for(w = 0; w < dim->w; w++)
        {
            cbyte = pgm_read_byte_near(bitmap + iBitmap);
            iBitmap++;
 
            for(b = 0; b <= 8; b++)
            {
                bit = cbyte & (1 << b);
 
                row.x = coord->x + w;
                row.y = coord->y + b;
 
                if(bit != LOW)
                    LCD_SetPixel(&row, HIGH);
            }
        }
        coord->y += 8;
    }
}
 
void LCD_DrawVLine(Coordonnees *coord, Dimensions *dim)
{
    uint8_t l = 0;
    Coordonnees row  = {0, 0};
 
    for(l = 0; l <= dim->w; l++)
    {
        row.x = coord->x + l;
        row.y = coord->y;
 
        if(row.x >= LCD_WIDTH)
            return;
 
        LCD_SetPixel(&row, HIGH);
    }
}
 
void LCD_DrawHLine(Coordonnees *coord, Dimensions *dim)
{
    uint8_t h = 0;
    Coordonnees row  = {0, 0};
 
    for(h = 0; h <= dim->h; h++)
    {
        row.x = coord->x;
        row.y = coord->y + h;
 
        if(row.y >= LCD_WIDTH)
            return;
 
        LCD_SetPixel(&row, HIGH);
    }
}
 
void setup(void)
{
    LCD_InitLCD();
 
    Coordonnees coord;
    coord.x = 0;
    coord.y = 0;
 
    LCD_Print("Hello world !", &coord);
    LCD_Udapte();
}
 
void loop(void)
{
 
}

Le .h :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
/* Table ascii, 5 pixels de large par 8 pixels de haut */
const char asciiTable[] PROGMEM =
{
   0x00, 0x00, 0x00, 0x00, 0x00 // 20
  ,0x00, 0x00, 0x5f, 0x00, 0x00 // 21 !
  ,0x00, 0x07, 0x00, 0x07, 0x00 // 22 "
  ,0x14, 0x7f, 0x14, 0x7f, 0x14 // 23 #
  ,0x24, 0x2a, 0x7f, 0x2a, 0x12 // 24 $
  ,0x23, 0x13, 0x08, 0x64, 0x62 // 25 %
  ,0x36, 0x49, 0x55, 0x22, 0x50 // 26 &
  ,0x00, 0x05, 0x03, 0x00, 0x00 // 27 '
  ,0x00, 0x1c, 0x22, 0x41, 0x00 // 28 (
  ,0x00, 0x41, 0x22, 0x1c, 0x00 // 29 )
  ,0x14, 0x08, 0x3e, 0x08, 0x14 // 2a *
  ,0x08, 0x08, 0x3e, 0x08, 0x08 // 2b +
  ,0x00, 0x50, 0x30, 0x00, 0x00 // 2c ,
  ,0x08, 0x08, 0x08, 0x08, 0x08 // 2d -
  ,0x00, 0x60, 0x60, 0x00, 0x00 // 2e .
  ,0x20, 0x10, 0x08, 0x04, 0x02 // 2f /
  ,0x3e, 0x51, 0x49, 0x45, 0x3e // 30 0
  ,0x00, 0x42, 0x7f, 0x40, 0x00 // 31 1
  ,0x42, 0x61, 0x51, 0x49, 0x46 // 32 2
  ,0x21, 0x41, 0x45, 0x4b, 0x31 // 33 3
  ,0x18, 0x14, 0x12, 0x7f, 0x10 // 34 4
  ,0x27, 0x45, 0x45, 0x45, 0x39 // 35 5
  ,0x3c, 0x4a, 0x49, 0x49, 0x30 // 36 6
  ,0x01, 0x71, 0x09, 0x05, 0x03 // 37 7
  ,0x36, 0x49, 0x49, 0x49, 0x36 // 38 8
  ,0x06, 0x49, 0x49, 0x29, 0x1e // 39 9
  ,0x00, 0x36, 0x36, 0x00, 0x00 // 3a :
  ,0x00, 0x56, 0x36, 0x00, 0x00 // 3b ;
  ,0x08, 0x14, 0x22, 0x41, 0x00 // 3c <
  ,0x14, 0x14, 0x14, 0x14, 0x14 // 3d =
  ,0x00, 0x41, 0x22, 0x14, 0x08 // 3e >
  ,0x02, 0x01, 0x51, 0x09, 0x06 // 3f ?
  ,0x32, 0x49, 0x79, 0x41, 0x3e // 40 @
  ,0x7e, 0x11, 0x11, 0x11, 0x7e // 41 A
  ,0x7f, 0x49, 0x49, 0x49, 0x36 // 42 B
  ,0x3e, 0x41, 0x41, 0x41, 0x22 // 43 C
  ,0x7f, 0x41, 0x41, 0x22, 0x1c // 44 D
  ,0x7f, 0x49, 0x49, 0x49, 0x41 // 45 E
  ,0x7f, 0x09, 0x09, 0x09, 0x01 // 46 F
  ,0x3e, 0x41, 0x49, 0x49, 0x7a // 47 G
  ,0x7f, 0x08, 0x08, 0x08, 0x7f // 48 H
  ,0x00, 0x41, 0x7f, 0x41, 0x00 // 49 I
  ,0x20, 0x40, 0x41, 0x3f, 0x01 // 4a J
  ,0x7f, 0x08, 0x14, 0x22, 0x41 // 4b K
  ,0x7f, 0x40, 0x40, 0x40, 0x40 // 4c L
  ,0x7f, 0x02, 0x0c, 0x02, 0x7f // 4d M
  ,0x7f, 0x04, 0x08, 0x10, 0x7f // 4e N
  ,0x3e, 0x41, 0x41, 0x41, 0x3e // 4f O
  ,0x7f, 0x09, 0x09, 0x09, 0x06 // 50 P
  ,0x3e, 0x41, 0x51, 0x21, 0x5e // 51 Q
  ,0x7f, 0x09, 0x19, 0x29, 0x46 // 52 R
  ,0x46, 0x49, 0x49, 0x49, 0x31 // 53 S
  ,0x01, 0x01, 0x7f, 0x01, 0x01 // 54 T
  ,0x3f, 0x40, 0x40, 0x40, 0x3f // 55 U
  ,0x1f, 0x20, 0x40, 0x20, 0x1f // 56 V
  ,0x3f, 0x40, 0x38, 0x40, 0x3f // 57 W
  ,0x63, 0x14, 0x08, 0x14, 0x63 // 58 X
  ,0x07, 0x08, 0x70, 0x08, 0x07 // 59 Y
  ,0x61, 0x51, 0x49, 0x45, 0x43 // 5a Z
  ,0x00, 0x7f, 0x41, 0x41, 0x00 // 5b [
  ,0x02, 0x04, 0x08, 0x10, 0x20 // 5c backslash
  ,0x00, 0x41, 0x41, 0x7f, 0x00 // 5d ]
  ,0x04, 0x02, 0x01, 0x02, 0x04 // 5e ^
  ,0x40, 0x40, 0x40, 0x40, 0x40 // 5f _
  ,0x00, 0x01, 0x02, 0x04, 0x00 // 60 `
  ,0x20, 0x54, 0x54, 0x54, 0x78 // 61 a
  ,0x7f, 0x48, 0x44, 0x44, 0x38 // 62 b
  ,0x38, 0x44, 0x44, 0x44, 0x20 // 63 c
  ,0x38, 0x44, 0x44, 0x48, 0x7f // 64 d
  ,0x38, 0x54, 0x54, 0x54, 0x18 // 65 e
  ,0x08, 0x7e, 0x09, 0x01, 0x02 // 66 f
  ,0x0c, 0x52, 0x52, 0x52, 0x3e // 67 g
  ,0x7f, 0x08, 0x04, 0x04, 0x78 // 68 h
  ,0x00, 0x44, 0x7d, 0x40, 0x00 // 69 i
  ,0x20, 0x40, 0x44, 0x3d, 0x00 // 6a j
  ,0x7f, 0x10, 0x28, 0x44, 0x00 // 6b k
  ,0x00, 0x41, 0x7f, 0x40, 0x00 // 6c l
  ,0x7c, 0x04, 0x18, 0x04, 0x78 // 6d m
  ,0x7c, 0x08, 0x04, 0x04, 0x78 // 6e n
  ,0x38, 0x44, 0x44, 0x44, 0x38 // 6f o
  ,0x7c, 0x14, 0x14, 0x14, 0x08 // 70 p
  ,0x08, 0x14, 0x14, 0x18, 0x7c // 71 q
  ,0x7c, 0x08, 0x04, 0x04, 0x08 // 72 r
  ,0x48, 0x54, 0x54, 0x54, 0x20 // 73 s
  ,0x04, 0x3f, 0x44, 0x40, 0x20 // 74 t
  ,0x3c, 0x40, 0x40, 0x20, 0x7c // 75 u
  ,0x1c, 0x20, 0x40, 0x20, 0x1c // 76 v
  ,0x3c, 0x40, 0x30, 0x40, 0x3c // 77 w
  ,0x44, 0x28, 0x10, 0x28, 0x44 // 78 x
  ,0x0c, 0x50, 0x50, 0x50, 0x3c // 79 y
  ,0x44, 0x64, 0x54, 0x4c, 0x44 // 7a z
  ,0x00, 0x08, 0x36, 0x41, 0x00 // 7b {
  ,0x00, 0x00, 0x7f, 0x00, 0x00 // 7c |
  ,0x00, 0x41, 0x36, 0x08, 0x00 // 7d }
  ,0x10, 0x08, 0x08, 0x10, 0x08 // 7e ~
  ,0x78, 0x46, 0x41, 0x46, 0x78 // 7f DEL
};
 
 
/** PCD8544 Commandset ################################################################ */
 
/* General commands */
#define PCD8544_POWERDOWN			0x04
#define PCD8544_ENTRYMODE			0x02
#define PCD8544_EXTENDEDINSTRUCTION	0x21
#define PCD8544_DISPLAYBLANK		0x00
#define PCD8544_DISPLAYNORMAL		0x04
#define PCD8544_DISPLAYALLON		0x01
#define PCD8544_DISPLAYINVERTED		0x05
 
/* Normal instruction set */
#define PCD8544_FUNCTIONSET			0x20
#define PCD8544_DISPLAYCONTROL		0x0C
#define PCD8544_SETYADDR			0x40
#define PCD8544_SETXADDR			0x80
 
/* Extended instruction set */
#define PCD8544_SETTEMP				0x04
#define PCD8544_SETBIAS				0x14
#define PCD8544_SETVOP				0x80
 
 
/** Macro setting ################################################################ */
 
/* Definition des broches du lcd */
#define PIN_CE      PORTD7  /* Broche d'activation pour synchronisé les données */
#define PIN_RESET   PORTD6  /* Broche pour réinitialisé l'écran */
#define PIN_DC      PORTD5  /* Broche pour sélectionner l'envoie d'une commande ou d'une donnée */
#define PIN_DIN     PORTD4  /* Broche Pour reçevoir la commande ou la donnée */
#define PIN_CLK     PORTD3  /* Broche pour le signal d'horloge */
 
/* La broche DC permet de dire à l'écran si on envoi une commande ou une donnée */
#define LCD_COMMAND     0
#define LCD_DATA        1
 
/* Défini ici la hauteur / largeur de l'écran en pixel */
#define LCD_WIDTH   84
#define LCD_HEIGH   48
#define LCD_BUFFER  LCD_WIDTH * LCD_HEIGH / 8
 
/* Taille des caractères de la tables ascii */
#define WIDTH_FONT  5
#define HEIGH_FONT  8
 
 
/** Structures ################################################################ */
 
typedef struct Coordonnees
{
    int8_t x;
    int8_t y;
 
}Coordonnees;
 
typedef struct Dimensions
{
    uint8_t w;
    uint8_t h;
 
}Dimensions;
 
 
/** Global variables ################################################################ */
 
uint8_t lcdBuf[LCD_BUFFER] = {0};
 
 
/** Prototype function ################################################################ */
 
/* Private */
static void LCD_SendData(const uint8_t, const uint8_t);
 
 
/* Extern */
void LCD_InitLCD(void);
void LCD_Udapte(void);
void LCD_Clear(void);
void LCD_DrawChar(const char*, Coordonnees*);
void LCD_Print(const char*, Coordonnees*);
void LCD_DrawBitmap(const uint8_t*, Coordonnees*, Dimensions*);
 
uint8_t LCD_SetPixel(Coordonnees*, const uint8_t);
uint8_t LCD_GetPixel(Coordonnees*);
Merci d'avance