Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Arduino Discussion :

Votre avis sur mon code


Sujet :

Arduino

  1. #1
    Nouveau Candidat au Club
    Votre avis sur mon code
    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

  2. #2
    Membre expérimenté
    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

  3. #3
    Nouveau Candidat au Club
    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

  4. #4
    Membre expérimenté
    Citation Envoyé par stybreak Voir le message
    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.

  5. #5
    Nouveau Candidat au Club
    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é

###raw>template_hook.ano_emploi###