4 nov. 18

Mise en œuvre d’un écran OLED de chez HESAI avec un arduino nano

Catégorie : Arduino
Étiquettes :

J’ai acheté un petit écran OLED pas cher chez aliexpress pour voir ce que ça donne. L’écran fait 1.3 pouces de diagonale (3.3cm). L’affichage est en blanc uniquement, et la résolution est de 128×64. Pas de quoi faire une interface graphique avancée, mais largement suffisant pour afficher quelques informations basiques. Au niveau du protocole de communication, c’est de l’I2C, donc deux fils seulement en plus de ceux pour alimenter le module.

Le hic, c’est que les librairies Adafruit ne fonctionnent pas avec ce module chinois, et qu’il a fallu gratter un peu avant de pouvoir le faire fonctionner. Ceci dit, la bibliothèque ssd1306 écrite par Alexey Dynda est utilisable avec ce matériel, pour peu que l’on utilise le pilote pour la puce sh1106 au lieu de celui pour ssd1306 habituellement.

Dans cet article, je vais détailler la procédure pour faire fonctionner ce petit écran oled, en utilisant l’IDE arduino, puis avec PlatformIO. C’est parti !

Le montage

Pour ces petits tests, j’ai utilisé un arduino nano (un funduino pour être exact). Ce sera largement suffisant.

Pour repérer les broches SDA (Serial Data Line ou ligne de données bidirectionnelle) et SCL (Serial Clock Line ou ligne d’horloge de synchronisation bidirectionnelle), il suffit de regarder le brochage d’un arduino nano :

Brochage d'un arduino nano

On repère rapidement que la ligne de données (SDA) se trouve sur la broche A4, et la ligne d’horloge (SCL) sur la broche A5. Le câblage est donc très simple ici :

Montage pour tester l'écran OLED

Avec l’IDE Arduino

Il faut d’abord installer la librairie ssd1306. Dans l’IDE Arduino, allez dans le menu Outils > Gérer les bibliothèques. Dans la zone de saisie Filtrez votre recherche, saisissez ssd1306. Repérez la bibliothèque nommée ssd1306 by Alexey Dynda, et cliquez sur Installer. Vous pouvez ensuite fermer la boîte de dialogue.

C’est prêt ! Nous allons tester la bibliothèque en écrivant un petit programme qui affiche un compteur à l’écran. Allez dans Fichier > Nouveau, et saisissez le code suivant :

    
    #include "ssd1306.h"

    // compteur pour les secondes
    int i = 0;
    // texte pour l'affichage du temps
    char nombre[32];

    void setup()
    {
        // initialisation de l'écran oled
        // on utilise le pilote de la puce SH1106 au lieu de SSD1306
        sh1106_128x64_i2c_init();

        // sélection de la police
        ssd1306_setFixedFont(ssd1306xled_font6x8);

        // on efface l'écran
        ssd1306_clearScreen();

        // affichage de « compteur » en haut de l'écran
        ssd1306_printFixed(40,  16, "Compteur", STYLE_NORMAL);
    }

    void loop()
    {
        // affichage du temps sous la forme xx:xx
        sprintf(nombre,"%02d:%02d", i/60,i%60);
        ssd1306_printFixedN(35,40,nombre, STYLE_NORMAL, FONT_SIZE_2X);

        delay(1000);
        i++;
    }
    

Après avoir compilé et téléversé ce croquis dans l’arduino nano, vous devriez voir quelque chose de la sorte :

Montage pour tester l'écran OLED

Avec PlatformIO

Nous allons utiliser PlatformIO Core (CLI) plutôt que sa version intégrée aux éditeurs atom ou Visual Studio Code. Je suppose que PlatformIO est déjà installé sur l’ordinateur. Les lignes de commande sont celles d’un système GNU/Linux (debian testing), mais doivent pouvoir être utilisées sur d’autres systèmes d’exploitation.

Tout d’abord, on crée un dossier vide pour le projet et on s’y place :

# création du dossier
> mkdir test_oled 
# et on s'y rend
> cd test_oled

puis on active l’environnement virtuel Python utilisé par PlatformIO :

> source ~/.platformio/penv/bin/activate

Ensuite, on doit repérer l’identifiant de la carte utilisée, ici un clone d’un Arduino nano un peu ancien :

> pio boards nano

ce qui donne à l’exécution :

Platform: atmelavr
----------------------------------------------------------------------------------------------
ID                    MCU            Frequency  Flash   RAM    Name
----------------------------------------------------------------------------------------------
nanoatmega168         ATMEGA168      16MHz     14KB    1KB    Arduino Nano ATmega168
nanoatmega328         ATMEGA328P     16MHz     30KB    2KB    Arduino Nano ATmega328
nanoatmega328new      ATMEGA328P     16MHz     30KB    2KB    Arduino Nano ATmega328 
                                                              (New Bootloader)

Platform: espressif32
----------------------------------------------------------------------------------------------
ID                    MCU            Frequency  Flash   RAM    Name
----------------------------------------------------------------------------------------------
nano32                ESP32          240MHz    4MB     320KB  MakerAsia Nano32

Platform: nordicnrf51
----------------------------------------------------------------------------------------------
ID                    MCU            Frequency  Flash   RAM    Name
----------------------------------------------------------------------------------------------
redBearLabBLENano     NRF51822       16MHz     256KB   32KB   RedBearLab BLE Nano 1.5

Platform: nordicnrf52
----------------------------------------------------------------------------------------------
ID                    MCU            Frequency  Flash   RAM    Name
----------------------------------------------------------------------------------------------
redbear_blenano2      NRF52832       64MHz     512KB   64KB   RedBearLab BLE Nano 2

L’indentifiant qui nous intéresse ici est donc nanoatmega328. On initialise alors le projet avec la commande :

> pio init --board nanoatmega328

The current working directory /home/lgr/tmp/test_oled will be used for the project.

The next files/directories have been created in /home/lgr/tmp/test_oled
include - Put project header files here
lib - Put here project specific (private) libraries
src - Put project source files here
platformio.ini - Project Configuration File

Project has been successfully initialized! Useful commands:
`pio run` - process/build project from the current directory
`pio run --target upload` or `pio run -t upload` - upload firmware to a target
`pio run --target clean` - clean project (remove compiled files)
`pio run --help` - additional information

Les fichiers et dossiers du projet minimaliste sont alors créés. Dans le dossier src de l’arborescence du projet, il faut créer un fichier main.cpp, contenant le même code que celui donné plus haut pour d’IDE Arduino.

Ensuite, il faut compléter le fichier platformio.ini pour y inclure les dépendances aux bibliothèques. Pour cela, on se rend sur la page https://platformio.org/lib et dans la zone de recherche, on saisit ssd1306. Dans la liste des résultats, identifier la bibliothèque ssd1306 d’Alexey Dynda et on clique sur le lien pour aller sur la page de cette bibliothèque. Les lignes à ajouter dans le fichier platformio.ini dont données dans l’onglet Installation de cette page. On ajoutera donc ces lignes pour obtenir le fichier de configuration platformio.ini suivant :

[env:nanoatmega328]
platform = atmelavr
board = nanoatmega328
framework = arduino

lib_deps = 
     1904
     Wire
     SPI

Quelques remarques importantes :

  • dans lib_deps, il ne faut pas mettre le nom de la bibliothèque (ssd1306) mais seulement son identifiant 1904. En effet, avec le nom seulement, c’est une autre bibliothèque qui sera automatiquement téléchargée et installée au moment de la compilation. Je ne sais pas du tout d’où vient ce comportement étrange…
  • il faut ajouter des dépendances supplémentaires de la bibliothèque ssd1306 : Wire et SPI.

Pour compiler le code, il suffit de saisir :

pio run

Cela va donc télécharger toutes les bibliothèques manquantes (en les plaçant dans le sous-dossier caché .piolibdeps), et lancer la chaîne de compilation. Au bout de quelques secondes, la compilation est terminée et le binaire est prêt à être envoyé dans l’arduino nano :

Processing nanoatmega328 (platform: atmelavr; board: nanoatmega328; framework: arduino)
----------------------------------------------------------------------------------------------
Verbose mode can be enabled via `-v, --verbose` option
CONFIGURATION: https://docs.platformio.org/page/boards/atmelavr/nanoatmega328.html
PLATFORM: Atmel AVR > Arduino Nano ATmega328
SYSTEM: ATMEGA328P 16MHz 2KB RAM (30KB Flash)
Library Dependency Finder -> http://bit.ly/configure-pio-ldf
LDF MODES: FINDER(chain) COMPATIBILITY(soft)
Collected 25 compatible libraries
Scanning dependencies...
Dependency Graph
|-- <ssd1306> 1.7.9
|   |-- <SPI> 1.0
|   |-- <Wire> 1.0
|-- <Wire> 1.0
|-- <SPI> 1.0
Compiling .pioenvs/nanoatmega328/src/main.cpp.o

[]

Building .pioenvs/nanoatmega328/firmware.hex
Memory Usage -> http://bit.ly/pio-memory-usage
DATA:    [==        ]  15.7% (used 321 bytes from 2048 bytes)
PROGRAM: [==        ]  21.5% (used 6620 bytes from 30720 bytes)
==========================================
[SUCCESS] Took 4.71 seconds
==========================================

Il ne reste plus qu’à téléverser le binaire avec la commande :

> pio run -t upload

et le compteur doit commencer à égrainer les secondes !