Votre avis sur mon code

**stybreak** · 10/01/2020, 17h56

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

**Jay M** · 10/01/2020, 22h59

J’ai lu en diagonal mais Si ça fonctionne c’est un bon

byte est redéfini dans les macros Arduino, évitez de l’utiliser en nom de variable

Mettez des parenthèses autour des define composé, par exemple au lieu de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 #define LCD_BUFFER  LCD_WIDTH * LCD_HEIGH / 8

faites

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 #define LCD_BUFFER  (LCD_WIDTH * LCD_HEIGH / 8)

et dans l’absolu si vous utilisiez une constante typée le compilateur pourrait faire des optimisations et/ou vérifications de conformité sémantique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const uint16_t LCD_BUFFER  =  (LCD_WIDTH * LCD_HEIGH) / 8;

(et vous pourriez l’appeler LCD_BUFFER_SIZE plutôt)

Éventuellement groupez dans des variables locales les /8 et %8 pour que le compilateur optimise (un modulo coûte cher à calculer mais il est facilement dispo si vous avez fait la division juste avant, parfois le compilateur optimisé cela et fait d’une pierre deux coups).

Faites des if/else quand les conditions sont mutuellement exclusives. Ici cmd ne peut pas être à la fois LCD_COMMAND et LCD_DATA

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 if (cmd == LCD_COMMAND) PORTD &= ~(1 << PIN_DC);
if (cmd == LCD_DATA)    PORTD |=  (1 << PIN_DC);

La boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 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);
    }

gagnerait en efficacité (pas de soustraction supplémentaire à effectuer pour le masque) si vous alliez de 7 à 0 plutôt que de 0 à 7 (attention à utiliser un char et pas un uint8_t)

Pour faire un toggle sur une pin d’un port vous pouvez écrire dans PIND. Au lieu de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 PORTD |=  (1 << PIN_CLK);
PORTD &= ~(1 << PIN_CLK);

vous pouvez faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
PIND  = (1 << PIN_CLK);
PIND  = (1 << PIN_CLK);

En anglais on écrit height pour la hauteur et on dirait plutôt FONT_HEIGHT et FONT_WIDTH

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 #define HEIGH_FONT  8

Pourquoi mettre le prefix LCD_ à vos méthodes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 /* 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*);

et soyez cohérent, soit vous mettez LCD à la fin (LCD_InitLCD) soit vous ne le mettez pas...

je penche pour ne pas le mettre car j’imagine que l’appel se fait sur une instance de la classe et donc on fera

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

lcd.init();

ce qui sera compréhensible alors que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

lcd.LCD_InitLCD();

ça fait vraiment très lourd

Appuyez sur ctrl-T dans l’IDE pour inventer correctement

**stybreak** · 11/01/2020, 12h05

Merci beaucoup d'avoir pris le temps de lire mon code et de répondre.

J'ai ajusté les petits détails et les fautes, pour le double if je trouvais que ça rendait le code plus lisible

Pour PIND il me semblait que c’était pour lire un pin, pas pour le modifier.

Pour le préfixe LCD_ c'est très simple c'est parce que c'est du C et non du C++ j'ai laissé un petit exemple de la librairie à la fin au cas où

c'est vrai que le LCD_InitLCD est un peu lourd je m'en suis pas rendu compte

**Jay M** · 11/01/2020, 15h20

Envoyé par stybreak

pour le double if je trouvais que ça rendait le code plus lisible

Pour PIND il me semblait que c’était pour lire un pin, pas pour le modifier.

Pour le préfixe LCD_ c'est très simple c'est parce que c'est du C et non du C++ j'ai laissé un petit exemple de la librairie à la fin au cas où

c'est vrai que le LCD_InitLCD est un peu lourd je m'en suis pas rendu compte

pour les if vous pourriez quand même mettre un else, ça éviterait de faire un second test pour rien tout en gardant la lisibilité

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
if (cmd == LCD_COMMAND)   PORTD &= ~(1 << PIN_DC);
else if (cmd == LCD_DATA) PORTD |=  (1 << PIN_DC);

PIND a une propriété magique, si vous écrivez dedans en mettant un bit à 1, ça inverse en fait ce bit. par exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

PIND = 0b11000000; // inverse la valeur des pins 6 et 7

OK, je n'avais pas vu que c'était pour un usage en C.

**stybreak** · 11/01/2020, 16h20

Oui j'ai modifié les if, c'est plus correct.
Merci pour l'astuce avec PIND je savais pas

Encore merci d'avoir pris le temps de m'aidé

Votre avis sur mon code

Arduino

Discussions similaires

Partager

Partager