TP 8 — Le bus SPI : l’écran OLED

Objectifs

comprendre le bus SPI et ses lignes de commande ;
initialiser un écran OLED par une suite de commandes ;
dessiner dans une image en mémoire (framebuffer), puis l’envoyer à l’écran d’un seul bloc ;
afficher des chiffres, par exemple une mesure d’un TP précédent.

Durée indicative : deux séances de 3 h. Prérequis : TP 1 — Allumer une LED, lire un bouton.

Ce qu’il faut savoir

Le bus SPI

Le SPI est un bus série synchrone, plus rapide et plus simple que l’I²C :

SCK, l’horloge, imposée par le maître ;
MOSI, les données du maître vers l’esclave ;
MISO, les données de l’esclave vers le maître (inutile ici) ;
CS (chip select), une broche par esclave, à 0 pendant l’échange : il n’y a pas d’adresse, c’est CS qui désigne le composant.

Figure made with TikZ

L’envoi d’un octet en SPI : CS sélectionne l’écran, SCK cadence, MOSI porte les bits.

L’écran

Un module OLED monochrome de 128 × 64 points, piloté par un contrôleur SSD1309, relié au connecteur SCREEN_SPI1 :

Signal	Broche	Rôle
MOSI	PC12 (SPI3_MOSI)	données vers l’écran
SCK	PC10 (SPI3_SCK)	horloge
CS	PD14	sélection de l’écran, active à 0
DC	PD15	0 : l’octet envoyé est une commande ; 1 : c’est une donnée (des pixels)
RST	PC8	remise à zéro de l’écran, active à 0

Avertissement

Le module porte un interrupteur SPI / I²C : il doit être sur SPI. L’écran ne renvoie rien (pas de MISO) : le microcontrôleur ne peut pas savoir s’il est bien branché. Quand rien ne s’affiche, vérifiez d’abord le câble et cet interrupteur.

La mémoire de l’écran

Les 128 × 64 points sont rangés en 8 pages de 8 lignes. Un octet représente une colonne de 8 points d’une page, bit 0 en haut. L’écran entier tient donc en 128 × 8 = 1 024 octets.

Figure made with TikZ

La mémoire de l’écran : 8 pages de 128 octets, chaque octet est une colonne de 8 points.

On dessine dans un tableau de 1 024 octets en mémoire, puis on l’envoie à l’écran en une fois.

Étape 1 — Configurer le SPI

Créez un projet tp08_spi_ecran comme au TP 1 (STM32H750VBTx, SYS → Debug : Serial Wire, horloge par défaut).
Dans Connectivity → SPI3, choisissez Transmit Only Master. Vérifiez que SCK et MOSI sont sur PC10 et PC12.
Dans Parameter Settings du SPI3 :
- Data Size : 8 Bits. CubeMX propose parfois 4 bits par défaut sur ce microcontrôleur : vérifiez-le ;
- Prescaler : 16.
L’horloge du SPI. Dans Clock Configuration, le multiplexeur SPI123 Clock Mux propose plusieurs sources ; les PLL ne sont pas actives : choisissez PER_CK (la HSI, 64 MHz). Avec le prédiviseur 16, l’horloge du bus vaut 4 MHz, sous les quelque 10 MHz qu’accepte le SSD1309.
Configurez PD14, PD15 et PC8 en GPIO_Output, labels SCREEN_CS, SCREEN_DC et SCREEN_RST. Pour SCREEN_CS, réglez le niveau de départ (GPIO output level) sur High : l’écran n’est pas sélectionné au démarrage.
Générez le code.

Étape 2 — Initialiser l’écran

Écrivez une fonction send_commands(const uint8_t *cmds, uint16_t n) : DC à 0 (commande), CS à 0, HAL_SPI_Transmit(&hspi3, …), CS à 1.
Remise à zéro : RST à 1, 10 ms, RST à 0, 10 ms, RST à 1, 10 ms.

Envoyez la suite d’initialisation suivante, tirée de la fiche technique du SSD1309 :

static const uint8_t init_cmds[] = {
    0xAE,         /* affichage éteint pendant la configuration */
    0xD5, 0x80,   /* diviseur d'horloge                        */
    0xA8, 0x3F,   /* 64 lignes                                 */
    0xD3, 0x00,   /* pas de décalage vertical                  */
    0x40,         /* ligne de départ 0                         */
    0xA1,         /* colonnes de droite à gauche               */
    0xC8,         /* lignes de bas en haut                     */
    0xDA, 0x12,   /* câblage des lignes, 128 × 64              */
    0x81, 0x7F,   /* contraste à mi-course                     */
    0xD9, 0x22,   /* pré-charge                                */
    0xDB, 0x34,   /* tension de désélection                    */
    0xA4,         /* afficher la mémoire                       */
    0xA6,         /* vidéo normale (A7 : inversée)             */
    0x20, 0x00,   /* adressage horizontal                      */
    0xAF,         /* affichage allumé                          */
};

Note

Les exemples écrits pour l’écran SSD1306, très répandus, envoient aussi 0x8D, 0x14 pour allumer une pompe de charge interne. Le SSD1309 n’en a pas : sa haute tension est fournie par le module. Ne l’envoyez pas.

Question

Remplacez 0xA6 par 0xA7. Que voit-on ? Et avec 0xA0 à la place de 0xA1 ?

Étape 3 — Envoyer une image

Déclarez l’image en mémoire : static uint8_t fb[1024];
Écrivez flush() qui l’envoie à l’écran : d’abord les commandes qui fixent la fenêtre d’écriture à l’écran entier, puis les 1 024 octets en mode donnée (DC à 1) :
```
static const uint8_t fenetre[] = {
    0x21, 0x00, 0x7F,   /* colonnes 0 à 127 */
    0x22, 0x00, 0x07,   /* pages 0 à 7      */
};
```
Testez quatre motifs, deux secondes chacun : tout allumé (0xFF partout), tout éteint (0x00), des bandes verticales, des bandes horizontales.

Questions

Quel motif d’octets donne des bandes horizontales de 8 points ? Et des bandes verticales de 8 points ?
Combien de temps dure l’envoi de l’image entière à 4 MHz ? Combien d’images par seconde peut-on envoyer au plus ?

Étape 4 — Dessiner

Écrivez pixel(x, y, allume), qui allume ou éteint un point de l’image en mémoire, à l’aide de la formule ci-dessus.
Dessinez un cadre autour de l’écran, puis une diagonale.

Pour afficher des chiffres, voici une police de 5 × 7 points : chaque caractère fait 5 colonnes, un octet par colonne, bit 0 en haut. Elle s’écrit directement dans une page de l’image.

static const uint8_t chiffres[10][5] = {
    { 0x3E, 0x51, 0x49, 0x45, 0x3E },   /* 0 */
    { 0x00, 0x42, 0x7F, 0x40, 0x00 },   /* 1 */
    { 0x42, 0x61, 0x51, 0x49, 0x46 },   /* 2 */
    { 0x21, 0x41, 0x45, 0x4B, 0x31 },   /* 3 */
    { 0x18, 0x14, 0x12, 0x7F, 0x10 },   /* 4 */
    { 0x27, 0x45, 0x45, 0x45, 0x39 },   /* 5 */
    { 0x3C, 0x4A, 0x49, 0x49, 0x30 },   /* 6 */
    { 0x01, 0x71, 0x09, 0x05, 0x03 },   /* 7 */
    { 0x36, 0x49, 0x49, 0x49, 0x36 },   /* 8 */
    { 0x06, 0x49, 0x49, 0x29, 0x1E },   /* 9 */
};

Affichez un compteur qui augmente d’une unité par seconde.

Exercices supplémentaires

Ces exercices n’ont pas de correction.

La température à l’écran : affichez la mesure du TMP102 (TP 7 — Le bus I²C : température, accéléromètre et gyroscope), en degrés avec une décimale.
La batterie à l’écran : la tension et une jauge dessinée (TP 6 — Le niveau de batterie).
Grands chiffres : doublez la taille de la police (chaque point devient un carré de 2 × 2).
Balle qui rebondit : un carré de 4 × 4 points qui se déplace et rebondit sur les bords, 25 images par seconde.
Toutes les lettres : complétez la police avec les lettres majuscules.

Après le TP

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