Afficher du texte sur un écran OLED SSD1306 avec ESP8266 NodeMCU

ESP8266 17-11-25

16 0

Plan du tutoriel

1- Objectif du tutoriel

2- Présenter l'écran OLED SSD1306

2- Les composants nécessaires

3- Montage du système

4- Programme MicroPython

Objectif du tutoriel

L’objectif de ce tutoriel est de guider l’utilisateur dans la mise en œuvre complète de l’affichage de texte sur un écran OLED SSD1306 en utilisant la carte ESP8266 NodeMCU.

Le tutoriel expliquera étape par étape comment réaliser le câblage de l’écran via l’interface I2C, installer et importer les bibliothèques nécessaires, puis écrire un programme permettant d’afficher différents types de textes (messages simples, textes multi-lignes, tailles de police, etc.).

À travers ce projet, l’utilisateur apprendra également à initialiser l’écran OLED, à comprendre son adressage I2C, à gérer le rafraîchissement de l’affichage et à intégrer cet écran dans ses futurs projets ESP8266.

Présenter l'écran OLED SSD1306

L’écran OLED SSD1306 est un module d’affichage très populaire dans les projets électroniques et IoT grâce à sa taille compacte, sa faible consommation d’énergie et sa grande lisibilité.

Il utilise une technologie OLED (Organic Light-Emitting Diode), ce qui signifie que chaque pixel émet sa propre lumière, offrant un contraste très élevé et une excellente visibilité même dans l’obscurité.

Avantages :

1- L'écran SSD1306 fonctionne très bien avec des microcontrôleurs comme ESP8266, ESP32, Arduino, Raspberry Pi, etc.

2- Il nécessite peu de fils pour fonctionner (I2C)

3- Il est supporté par de nombreuses bibliothèques (MicroPython, Arduino, CircuitPython…)

4- Son mise en œuvre est simple pour afficher du texte, des images ou des graphiques simples

5- Il est très économique et largement disponible

Les composants nécessaires

1. Carte ESP8266 NodeMCU

La carte ESP8266 NodeMCU sert de microcontrôleur principal du projet.

Elle envoie les instructions à l’écran OLED via le protocole I2C.

Elle exécute le programme (MicroPython ou Arduino) qui génère le texte à afficher.

Elle fournit l’alimentation (3,3 V) nécessaire à certains modules SSD1306.

2. Écran OLED SSD1306 (I2C)

L'écran OLED SSD1306 Affiche le texte, les chiffres ou les petits graphiques envoyés par l’ESP8266.

Il utilise la technologie OLED, ce qui permet une faible consommation et un excellent contraste.

Il Communique avec l’ESP8266 par deux lignes de données : SDA et SCL.

3. Câbles de connexion (Jumpers)

Fils de connexion

Les câbles de connexion assurent les connexions électriques entre l’ESP8266 et l’écran OLED et transportent l’alimentation (VCC et GND) et les signaux I2C (SDA et SCL).

4. Breadboard (plaque d’essai)

plaque d'essai

La plaque d'essai permet de connecter les composants sans soudures.

Elle organise les connexions pour un montage propre et stable et facilite les tests et modifications du montage.

Montage du système

1- Connecter la broche GND de l'afficheur SSD1306 à la broche GND de la carte ESP8266

2- Connecter la broche VCC de l'afficheur SSD1306 à la broche VIN de la carte ESP8266

3- Connecter la broche SDA de l'afficheur SSD1306 à la broche D2 (GPIO4) de la carte ESP8266

4- Connecter la broche SCL de l'afficheur SSD1306 à la broche D1 (GPIO5) de la carte ESP8266

Programme MicroPython

Voici un programme complet en MicroPython qui permet de faire défiler (scroller) un texte sur un écran SSD1306 à l’aide de la carte ESP8266 NodeMCU.

Assurez-vous d'avoir la bibliothèque MicroPython ssd1306.py installée sur votre ESP8266. Si vous ne l'avez pas déjà, vous devrez l'installer avant de pouvoir l'utiliser.

# Complete project details at https://RandomNerdTutorials.com/micropython-ssd1306-oled-scroll-shapes-esp32-esp8266/

from machine import Pin, SoftI2C
import ssd1306
from time import sleep

# ESP32 Pin assignment
i2c = SoftI2C(scl=Pin(5), sda=Pin(4))

# ESP8266 Pin assignment
#i2c = SoftI2C(scl=Pin(5), sda=Pin(4))

oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

screen1_row1 = "Screen 1, row 1"
screen1_row2 = "Screen 1, row 2"
screen1_row3 = "Screen 1, row 3"

screen2_row1 = "Screen 2, row 1"
screen2_row2 = "Screen 2, row 2"

screen3_row1 = "Screen 3, row 1"

screen1 = [[0, 0 , screen1_row1], [0, 16, screen1_row2], [0, 32, screen1_row3]]
screen2 = [[0, 0 , screen2_row1], [0, 16, screen2_row2]]
screen3 = [[0, 40 , screen3_row1]]

# Scroll in screen horizontally from left to right
def scroll_in_screen(screen):
  for i in range (0, oled_width+1, 4):
    for line in screen:
      oled.text(line[2], -oled_width+i, line[1])
    oled.show()
    if i!= oled_width:
      oled.fill(0)

# Scroll out screen horizontally from left to right
def scroll_out_screen(speed):
  for i in range ((oled_width+1)/speed):
    for j in range (oled_height):
      oled.pixel(i, j, 0)
    oled.scroll(speed,0)
    oled.show()

# Continuous horizontal scroll
def scroll_screen_in_out(screen):
  for i in range (0, (oled_width+1)*2, 1):
    for line in screen:
      oled.text(line[2], -oled_width+i, line[1])
    oled.show()
    if i!= oled_width:
      oled.fill(0)

# Scroll in screen vertically
def scroll_in_screen_v(screen):
  for i in range (0, (oled_height+1), 1):
    for line in screen:
      oled.text(line[2], line[0], -oled_height+i+line[1])
    oled.show()
    if i!= oled_height:
      oled.fill(0)

# Scroll out screen vertically
def scroll_out_screen_v(speed):
  for i in range ((oled_height+1)/speed):
    for j in range (oled_width):
      oled.pixel(j, i, 0)
    oled.scroll(0,speed)
    oled.show()

# Continous vertical scroll
def scroll_screen_in_out_v(screen):
  for i in range (0, (oled_height*2+1), 1):
    for line in screen:
      oled.text(line[2], line[0], -oled_height+i+line[1])
    oled.show()
    if i!= oled_height:
      oled.fill(0)

while True:

  # Scroll in, stop, scroll out (horizontal)
  scroll_in_screen(screen1)
  sleep(2)
  scroll_out_screen(4)

  scroll_in_screen(screen2)
  sleep(2)
  scroll_out_screen(4)

  scroll_in_screen(screen3)
  sleep(2)
  scroll_out_screen(4)

  # Continuous horizontal scroll
  scroll_screen_in_out(screen1)
  scroll_screen_in_out(screen2)
  scroll_screen_in_out(screen3)

  # Scroll in, stop, scroll out (vertical)
  scroll_in_screen_v(screen1)
  sleep(2)
  scroll_out_screen_v(4)

  scroll_in_screen_v(screen2)
  sleep(2)
  scroll_out_screen_v(4)

  scroll_in_screen_v(screen3)
  sleep(2)
  scroll_out_screen_v(4)

  # Continuous verticall scroll
  scroll_screen_in_out_v(screen1)
  scroll_screen_in_out_v(screen2)
  scroll_screen_in_out_v(screen3)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

# Complete project details at https://RandomNerdTutorials.com/micropython-ssd1306-oled-scroll-shapes-esp32-esp8266/

from machine import Pin, SoftI2C

import ssd1306

from time import sleep

# ESP32 Pin assignment

i2c = SoftI2C(scl=Pin(5), sda=Pin(4))

# ESP8266 Pin assignment

#i2c = SoftI2C(scl=Pin(5), sda=Pin(4))

oled_width = 128

oled_height = 64

oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

screen1_row1 = "Screen 1, row 1"

screen1_row2 = "Screen 1, row 2"

screen1_row3 = "Screen 1, row 3"

screen2_row1 = "Screen 2, row 1"

screen2_row2 = "Screen 2, row 2"

screen3_row1 = "Screen 3, row 1"

screen1 = [[0, 0 , screen1_row1], [0, 16, screen1_row2], [0, 32, screen1_row3]]

screen2 = [[0, 0 , screen2_row1], [0, 16, screen2_row2]]

screen3 = [[0, 40 , screen3_row1]]

# Scroll in screen horizontally from left to right

def scroll_in_screen(screen):

for i in range (0, oled_width+1, 4):

for line in screen:

oled.text(line[2], -oled_width+i, line[1])

oled.show()

if i!= oled_width:

oled.fill(0)

# Scroll out screen horizontally from left to right

def scroll_out_screen(speed):

for i in range ((oled_width+1)/speed):

for j in range (oled_height):

oled.pixel(i, j, 0)

oled.scroll(speed,0)

oled.show()

# Continuous horizontal scroll

def scroll_screen_in_out(screen):

for i in range (0, (oled_width+1)*2, 1):

for line in screen:

oled.text(line[2], -oled_width+i, line[1])

oled.show()

if i!= oled_width:

oled.fill(0)

# Scroll in screen vertically

def scroll_in_screen_v(screen):

for i in range (0, (oled_height+1), 1):

for line in screen:

oled.text(line[2], line[0], -oled_height+i+line[1])

oled.show()

if i!= oled_height:

oled.fill(0)

# Scroll out screen vertically

def scroll_out_screen_v(speed):

for i in range ((oled_height+1)/speed):

for j in range (oled_width):

oled.pixel(j, i, 0)

oled.scroll(0,speed)

oled.show()

# Continous vertical scroll

def scroll_screen_in_out_v(screen):

for i in range (0, (oled_height*2+1), 1):

for line in screen:

oled.text(line[2], line[0], -oled_height+i+line[1])

oled.show()

if i!= oled_height:

oled.fill(0)

while True:

# Scroll in, stop, scroll out (horizontal)

scroll_in_screen(screen1)

sleep(2)

scroll_out_screen(4)

scroll_in_screen(screen2)

sleep(2)

scroll_out_screen(4)

scroll_in_screen(screen3)

sleep(2)

scroll_out_screen(4)

# Continuous horizontal scroll

scroll_screen_in_out(screen1)

scroll_screen_in_out(screen2)

scroll_screen_in_out(screen3)

# Scroll in, stop, scroll out (vertical)

scroll_in_screen_v(screen1)

sleep(2)

scroll_out_screen_v(4)

scroll_in_screen_v(screen2)

sleep(2)

scroll_out_screen_v(4)

scroll_in_screen_v(screen3)

sleep(2)

scroll_out_screen_v(4)

# Continuous verticall scroll

scroll_screen_in_out_v(screen1)

scroll_screen_in_out_v(screen2)

scroll_screen_in_out_v(screen3)

Ce programme réalise les actions suivantes :

1. Initialisation de l’écran OLED SSD1306

Configuration du bus I2C (broches SDA et SCL de l’ESP8266).

Définition de la résolution de l’afficheur (128×64 pixels).

Création d’un objet oled permettant de contrôler l’écran.

2. Création de plusieurs écrans de texte

Définition de textes répartis sur une ou plusieurs lignes : Screen 1, Screen 2, Screen 3, etc.

Chaque écran est enregistré sous forme de coordonnées (x, y) + texte.

3. Génération d’effets d’animation

Le programme propose plusieurs fonctions permettant d’appliquer des effets de défilement :

Défilement horizontal entrant : le texte apparaît en glissant de gauche à droite vers l’intérieur de l’écran.

Défilement horizontal sortant : le texte disparaît en glissant vers la droite.

Défilement horizontal continu : le texte se déplace en boucle de gauche à droite.

Défilement vertical entrant: le texte descend depuis le haut de l’écran vers sa position normale.

Défilement vertical sortant : le texte monte et disparaît progressivement.

Défilement vertical continu : le texte défile constamment de haut en bas.

4. Affichage automatique des animations en boucle

Dans la boucle while True, le programme :

- affiche successivement les différents écrans

- applique les effets de défilement horizontal puis vertical

- insère des pauses pour laisser chaque texte visible

- répète le tout indéfiniment

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Afficher du texte sur un écran OLED SSD1306 avec ESP8266 NodeMCU

ESP8266 17-11-25

Système de détection de fuite de gaz avec ESP8266 NodeMCU et capteur MQ-4

ESP8266 10-11-25

Utilisation du capteur de gaz MQ-4 avec ESP8266 NodeMCU

ESP8266 06-11-25

Système de détection de flammes avec ESP8266 NodeMCU et capteur KY-026

ESP8266 04-11-25

Utilisation du capteur de flamme KY-026 avec l’ESP8266 NodeMCU

ESP8266 24-10-25

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 9971vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 9518vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 8580vues

Allumer une LED par la carte ESP32

ESP32 8325vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino UNO 8163vues

Construction des robots

Tutoriels plus commentés

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 28 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino UNO 17 commentaires

Echange des messages entre deux cartes Micro:bit via radio

Micro:bit 14 commentaires

Présentation du module capteur de lumière à LDR

Composants 12 commentaires

Présentation du buzzer

Composants 6 commentaires

Afficher du texte sur un écran OLED SSD1306 avec ESP8266 NodeMCU

Plan du tutoriel

1- Objectif du tutoriel

2- Présenter l'écran OLED SSD1306

2- Les composants nécessaires

3- Montage du système

4- Programme MicroPython

Objectif du tutoriel

Présenter l'écran OLED SSD1306

Les composants nécessaires

Montage du système

Programme MicroPython

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles