Dans le développement de systèmes embarqués, l'ajout d'une fonctionnalité d'affichage améliore significativement l'expérience utilisateur et l'interaction. Pour les développeurs utilisant le microcontrôleur HK32F030, un écran LCD 12864 piloté par le ST7567 représente une solution économique. Cet article explore la restructuration du code de base en une architecture modulaire, ainsi que l'application de diverses techniques d'optimisation pour améliorer les performances d'affichage.

1. Conception de l'architecture du pilote et encapsulation modulaire

Une conception de pilote efficace doit être facile à assembler et à utiliser, comme des briques Lego. Pour un contrôleur LCD garphique tel que le ST7567, il est essentiel d'établir des niveaux d'abstraction clairs :

// Définitions clés dans le fichier d'en-tête display_driver.h
typedef enum {
    DISP_RES_OK = 0,
    DISP_RES_TIMEOUT,
    DISP_RES_INVALID_ARG
} Display_Result;

typedef struct {
    void (*ms_delay)(uint32_t);
    void (*us_delay)(uint32_t);
    void (*port_write)(Port_Group*, uint16_t, uint8_t);
} Display_HalInterface;

Les points essentiels de la conception de la couche d'abstraction matérielle (HAL) incluent :

• Isolation de la configuration des broches : utilisation d'une structure pour encapsuler tous les paramètres liés au matériel.
• Mécanisme de rappel : implémentation d'opérations indépendantes de la plateforme pour les délais et les GPIO via des pointeurs de fonction.
• Gestion des états : définition explicite des codes de statut pour diverses opérations.

Exemple d'implémentation de l'interface d'initialisation :

Display_Result Display_Init(const Display_HalInterface* hal_intf)
{
    if (!hal_intf || !hal_intf->ms_delay || !hal_intf->us_delay || !hal_intf->port_write) {
        return DISP_RES_INVALID_ARG;
    }
    
    // Séquence d'initialisation matérielle
    hal_intf->port_write(SCREEN_POWER_PORT, SCREEN_POWER_PIN, 1);
    hal_intf->ms_delay(100);
    
    // Séquence de réinitialisation
    hal_intf->port_write(RESET_PORT, RESET_PIN, 0);
    hal_intf->ms_delay(20);
    hal_intf->port_write(RESET_PORT, RESET_PIN, 1);
    hal_intf->ms_delay(20);
    
    // Envoi de la séquence de commandes d'initialisation
    static const uint8_t startup_cmds[] = {
        0xE2, 0x2C, 0x2E, 0x2F, 0x25,
        0x81, 0x10, 0xA2, 0xC8, 0xA0,
        0x40, 0xAF
    };
    
    for (uint8_t index = 0; index < sizeof(startup_cmds); index++) {
        Send_Command(startup_cmds[index]);
    }
    
    return DISP_RES_OK;
}

2. Gestion de la mémoire vidéo et optimisation du rafraîchisesment partiel

Un rafraîchissement global peut provoquer un scintillement visible, en particulier dans les scénarios d'affichage dynamique. Des optimations peuvent être appliquées comme suit :

Implémentation de la technique du double tampon

// Définition de la mémoire vidéo
#define VIDEO_RAM_SIZE (128 * 8)  // Pixels 128x64, 1bit/pixel
static uint8_t front_buffer[VIDEO_RAM_SIZE];
static uint8_t back_buffer[VIDEO_RAM_SIZE];

void Refresh_DisplaySection(uint8_t initial_page, uint8_t final_page,
                            uint8_t initial_column, uint8_t final_column)
{
    for (uint8_t page_idx = initial_page; page_idx <= final_page; page_idx++) {
        Set_MemoryPointer(page_idx, initial_column);
        
        for (uint8_t col_idx = initial_column; col_idx <= final_column; col_idx++) {
            uint16_t memory_offset = page_idx * 128 + col_idx;
            if (front_buffer[memory_offset] != back_buffer[memory_offset]) {
                Write_PixelData(front_buffer[memory_offset]);
                back_buffer[memory_offset] = front_buffer[memory_offset];
            }
        }
    }
}

Données de test comparative des performances

3. Implémentation de fonctionnalités graphiques avancées

L'affichage de texte de base constitue un point de départ, mais la véritable valeur réside dans les éléments d'interface graphique :

Algorithme de dessin de ligne avec anti-crénelage

void Render_SmoothLine(int x_start, int y_start, int x_end, int y_end)
{
    int delta_x = abs(x_end - x_start), step_x = x_start < x_end ? 1 : -1;
    int delta_y = -abs(y_end - y_start), step_y = y_start < y_end ? 1 : -1;
    int error_val = delta_x + delta_y, error_double;
    uint8_t alpha_value;
    
    for (;;) {
        // Pixel principal
        Set_Point(x_start, y_start, 1);
        
        // Pixels de bord pour anti-crénelage
        error_double = 2 * error_val;
        if (error_double >= delta_y) {
            if (x_start == x_end) break;
            error_val += delta_y;
            x_start += step_x;
            alpha_value = 255 * (error_double - delta_y) / delta_x;
            Set_PointWithAlpha(x_start, y_start + step_y, alpha_value);
        }
        if (error_double <= delta_x) {
            if (y_start == y_end) break;
            error_val += delta_x;
            y_start += step_y;
            alpha_value = 255 * (delta_x - error_double) / delta_x;
            Set_PointWithAlpha(x_start + step_x, y_start, alpha_value);
        }
    }
}

Encapsulation de composants d'interface utilisateur courants

1. Composant de barre de progression :

typedef struct {
    uint8_t pos_x;
    uint8_t pos_y;
    uint8_t bar_width;
    uint8_t bar_height;
    uint8_t border_size;
    float progress_ratio; // 0.0 à 1.0
} ProgressBar_Config;

void Draw_ProgressBar(const ProgressBar_Config* config)
{
    // Dessin du cadre
    Draw_Rectangle(config->pos_x, config->pos_y,
                   config->pos_x + config->bar_width,
                   config->pos_y + config->bar_height,
                   config->border_size);
    
    // Calcul de la largeur de remplissage
    uint8_t fill_size = (config->bar_width - 2 * config->border_size) * config->progress_ratio;
    
    // Dessin de la zone remplie
    Fill_Rectangle(config->pos_x + config->border_size,
                   config->pos_y + config->border_size,
                   config->pos_x + config->border_size + fill_size,
                   config->pos_y + config->bar_height - config->border_size,
                   1);
}

2. Conception du système de menu :

typedef struct {
    const char* label;
    void (*callback)(void);
} MenuItem_Entry;

typedef struct {
    const MenuItem_Entry* entries;
    uint8_t entry_count;
    uint8_t current_selection;
} Menu_Context;

void Render_Menu(const Menu_Context* ctx)
{
    for (uint8_t i = 0; i < ctx->entry_count; i++) {
        if (i == ctx->current_selection) {
            Highlight_Area(5, 15 + i * 10, 123, 15 + i * 10 + 8);
        }
        Display_Text(10, 15 + i * 10, ctx->entries[i].label);
    }
}

4. Stratégies d'optimisation pour une faible consommation

Dans les applications alimentées par batterie, l'optimisation de la consommation du système d'affichage est cruciale :

Technique d'ajustement dynamique du taux de rafraîchissement

typedef enum {
    PWR_MODE_ACTIVE = 0,    // Rafraîchissement à 60Hz
    PWR_MODE_IDLE,          // Rafraîchissement à 30Hz
    PWR_MODE_STANDBY        // Mise à jour uniquement des informations critiques
} Power_OperationMode;

void Configure_PowerMode(Power_OperationMode mode)
{
    static Power_OperationMode current_mode = PWR_MODE_ACTIVE;
    if (current_mode == mode) return;
    
    switch (mode) {
        case PWR_MODE_ACTIVE:
            // Restauration du mode pleine fonctionnalité
            Send_Command(0xAF); // Activation de l'affichage
            Send_Command(0xA4); // Restauration du contenu d'affichage
            break;
            
        case PWR_MODE_IDLE:
            // Réduction du taux de rafraîchissement
            Send_Command(0xAC); // Désactivation du pilote statique
            Send_Command(0xA9); // Réglage du biais 1/8
            break;
            
        case PWR_MODE_STANDBY:
            // Mode de consommation minimale
            Send_Command(0xAE); // Désactivation de l'affichage
            Send_Command(0xA5); // Allumage complet de l'écran (optionnel)
            break;
    }
    
    current_mode = mode;
}

Données mesurées de gestion de l'alimentation

5. Techniques de débogage et d'analyse des performances

Dans les projets réels, des méthodes de débogage efficaces peuvent économiser un temps de développement considérable :

Tableau de dépannage des problèmes courants

Intégration d'outils d'analyse des performances

// Ajout de code de surveillance des performances dans la couche pilote
typedef struct {
    uint32_t full_refresh_count;
    uint32_t partial_refresh_count;
    uint32_t spi_transfer_cycles;
    uint32_t command_execution_time;
} Performance_Metrics;

void Retrieve_PerformanceData(Performance_Metrics* metrics_out)
{
    if (metrics_out) {
        metrics_out->full_refresh_count = stats_log.full_refresh;
        metrics_out->partial_refresh_count = stats_log.partial_refresh;
        metrics_out->spi_transfer_cycles = stats_log.spi_ops;
        metrics_out->command_execution_time = stats_log.cmd_timing;
    }
}

// Exemple d'utilisation
void Display_PerformanceData(void)
{
    Performance_Metrics current_stats;
    Retrieve_PerformanceData(&current_stats);
    
    char text_buffer[32];
    sprintf(text_buffer, "Global:%lums", current_stats.full_refresh_count / 1000);
    Display_Text(10, 10, text_buffer);
    
    sprintf(text_buffer, "Partiel:%lums", current_stats.partial_refresh_count / 1000);
    Display_Text(10, 20, text_buffer);
}

Sur des MCU à ressources limitées comme le HK32F030, un pilote ST7567 optimisé peut occuper environ 3 Ko de Flash et 256 octets de RAM, tout en atteignant un taux de rafraîchissement partiel de 30 ips. L'essentiel est de séparer la logique métier des opérations matérielles, et d'utiliser raisonnablement les mécanismes DMA et d'interruptions pour alléger la charge du processeur.