TP 11 — Une tâche pour l’écran SPI

Objectifs

confier l’écran à une seule tâche, qui affiche les mesures des autres ;
envoyer l’image par DMA, sans bloquer le processeur pendant le transfert ;
dessiner pendant que l’image précédente part : le double tampon.

Durée indicative : deux séances de 3 h. Prérequis : TP 10 — Des tâches pour les capteurs I²C (on en reprend le projet), TP 6 — Le DMA et TP 8 — Le bus SPI : l’écran OLED.

Ce qu’il faut savoir

Une tâche d’affichage

L’écran est une ressource : si deux tâches y écrivent, les images se mélangent. Plutôt qu’un mutex, on confie l’écran à une tâche d’affichage, la seule à l’utiliser. Elle lit l’état partagé (les mesures du TP 10), dessine l’image en mémoire, et l’envoie, à un rythme fixe : 5 images par seconde suffisent pour des chiffres.

Le temps d’une image

Une image de l’écran fait 128 × 64 pixels, soit 1 024 octets. À 4 MHz, leur envoi dure environ 2 ms, pendant lesquels HAL_SPI_Transmit occupe le processeur. Par DMA, l’envoi se fait seul ; la tâche attend la fin du transfert sur un sémaphore, comme au TP 6.

Le double tampon

Pendant que le DMA lit une image, il ne faut pas la modifier : le haut de l’écran montrerait l’ancienne, le bas la nouvelle. Avec deux tampons, on dessine dans l’un pendant que le DMA envoie l’autre, puis on échange leurs rôles.

Étape 1 — L’écran dans sa tâche

Reprenez le projet du TP 10. Ajoutez l’écran comme au TP 8 de la partie 1 : SPI3 en Transmit Only Master (PC10, PC12), prescaler 16, SCREEN_CS (PD14, niveau de départ haut), SCREEN_DC (PD15), SCREEN_RST (PC8).
Reprenez les fonctions d’affichage du TP 8 (screen_init, flush, fill, number).
Créez displayTask (priorité basse) : elle initialise l’écran, puis toutes les 200 ms copie g_sensors sous le mutex, dessine la température et le cap, et envoie l’image.

Important

screen_init utilise HAL_Delay. Dans une tâche, remplacez-le par osDelay (TP 1).

Questions

Pourquoi displayTask est-elle en priorité basse ? Que risquerait imuTask si elle était au-dessus ?
Mesurez avec DWT->CYCCNT la durée de flush. Quelle part du temps processeur l’affichage prend-il à 5 images par seconde ?

Étape 2 — L’envoi par DMA

Dans CubeMX, DMA Settings de SPI3 : SPI3_TX, Memory To Peripheral, mode Normal, octets. Activez SPI3 global interrupt (priorité 5 ou plus).
Placez le tampon de l’image en SRAM D2 (section .dma_buffer, TP 6), aligné sur 32 octets.
Dans flush, envoyez les commandes de fenêtre en mode bloquant (6 octets), puis l’image avec HAL_SPI_Transmit_DMA, et attendez un sémaphore spiDoneSem levé par HAL_SPI_TxCpltCallback.
SCREEN_CS doit rester à 0 pendant tout le transfert : remontez-le après le sémaphore, pas après l’appel.

Questions

Que vaut maintenant le temps processeur de flush ?
Que se passe-t-il si l’on remonte SCREEN_CS juste après HAL_SPI_Transmit_DMA ?
Si le cache de données est actif, que faut-il ajouter avant l’envoi ?

Étape 3 — Une boussole et un double tampon

Écrivez line(x0, y0, x1, y1) (algorithme de Bresenham), et dessinez une aiguille : un cercle de rayon 20 pixels, et un trait du centre vers le cap.
Mettez en place deux tampons : displayTask dessine dans le tampon libre, lance son envoi, puis, sans attendre la fin, commence à dessiner l’image suivante dans l’autre. Elle n’attend le sémaphore qu’au moment de relancer un envoi.
Montez la cadence à 25 images par seconde et tournez la carte.

Questions

Avec un seul tampon, et sans attendre la fin du transfert avant de redessiner, que verrait-on ?
Quelle est la cadence maximale théorique de l’écran, à 4 MHz ? Comment l’augmenter ?

Solution de l’étape 3

Le tracé de ligne (algorithme de Bresenham, tous octants) :

static void line(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
{
    int32_t dx  = (x1 > x0) ? (x1 - x0) : (x0 - x1);   /* |dx| */
    int32_t dy  = (y1 > y0) ? (y0 - y1) : (y1 - y0);   /* -|dy| */
    int32_t sx  = (x0 < x1) ? 1 : -1;
    int32_t sy  = (y0 < y1) ? 1 : -1;
    int32_t err = dx + dy;

    for (;;)
    {
        pixel(x0, y0);
        if ((x0 == x1) && (y0 == y1)) { break; }
        int32_t e2 = 2 * err;
        if (e2 >= dy) { err += dy; x0 += sx; }         /* un pas en x */
        if (e2 <= dx) { err += dx; y0 += sy; }         /* un pas en y */
    }
}

L’aiguille, du centre vers le cap (0° vers le haut, le cap croît vers la gauche) :

float a = s.heading_deg * 3.1415927f / 180.0f;        /* en radians */

circle(CX, CY, RADIUS);
line(CX, CY,
     CX - (int32_t)lroundf((float)(RADIUS - 2) * sinf(a)),
     CY - (int32_t)lroundf((float)(RADIUS - 2) * cosf(a)));

Le double tampon :

static uint8_t g_fb[2][1024] __attribute__((section(".dma_buffer"), aligned(32)));
static uint8_t *fb = g_fb[0];                /* le tampon où l'on dessine */
static volatile uint8_t g_spi_busy;

static void wait_previous(void)
{
    if (g_spi_busy)
    {
        osSemaphoreAcquire(spiDoneSemHandle, osWaitForever);
        HAL_GPIO_WritePin(SCREEN_CS_GPIO_Port, SCREEN_CS_Pin, GPIO_PIN_SET);
        g_spi_busy = 0u;
    }
}

static void flush(void)
{
    wait_previous();                           /* l'image précédente est partie */
    send_commands(fenetre, (uint16_t)sizeof(fenetre));
    SCB_CleanDCache_by_Addr((uint32_t *)fb, 1024);
    HAL_GPIO_WritePin(SCREEN_DC_GPIO_Port, SCREEN_DC_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(SCREEN_CS_GPIO_Port, SCREEN_CS_Pin, GPIO_PIN_RESET);
    g_spi_busy = 1u;
    HAL_SPI_Transmit_DMA(&hspi3, fb, 1024u);
    fb = (fb == g_fb[0]) ? g_fb[1] : g_fb[0];   /* on dessinera dans l'autre */
}

Bresenham en deux mots. Pour tracer une droite sur une grille de points, il faut choisir, à chaque pas, d’avancer en x, en y, ou les deux. Bresenham tient à jour une erreur : l’écart, à un facteur près, entre la droite idéale et le dernier point tracé. Selon son signe, on avance dans un sens ou dans l’autre, et on la corrige. Uniquement des additions et des comparaisons d’entiers : c’est pour cela qu’il est utilisé depuis 1962 sur tous les écrans.

Le sens de l’aiguille. Sur l’écran, y croît vers le bas : un point « en haut » a un y plus petit, d’où les signes moins. Un cap de 90° (un quart de tour à gauche) doit mettre l’aiguille à gauche : x diminue, d’où CX − r·sin(a).

Exercices supplémentaires

Ces exercices n’ont pas de correction.

Des pages : SW1 fait défiler plusieurs pages (capteurs, charge du processeur du TP 9, marges de pile des tâches). La tâche des boutons envoie un événement à displayTask par une file.
Du texte : complétez la police avec les lettres majuscules, et écrivez text(x, page, "TEMP").
Ne rien envoyer pour rien : n’envoyez l’image que si elle a changé (comparez-la à la précédente).

Après le TP

Pour rendre la carte au robot, voir Remettre la carte en état RatBot.