Dans ce guide, vous apprendrez à utiliser l’écran OLED SSD1306 de 0,96 pouce avec un ESP32 ou ESP8266 à l’aide du micrologiciel MicroPython. À titre d’exemple, nous allons vous montrer comment afficher un simple « Hello, World ! » message. Plus tard, nous vous montrerons également comment utiliser d’autres fonctions utiles pour interagir avec l’écran OLED.

Vous aimerez peut-être également lire nos guides dédiés à l’ESP avec écran OLED à l’aide d’Arduino IDE :
Conditions préalables
Pour suivre ce tutoriel, vous avez besoin du firmware MicroPython installé dans vos cartes ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre carte. Nous vous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :
En savoir plus sur MicroPython : eBook sur la programmation MicroPython avec ESP32 et ESP8266
Présentation de l’écran OLED
Dans ce guide, nous utiliserons le Écran OLED SSD1306 de 0,96 pouce c’est 128 × 64 pixels et utilise le protocole de communication I2C.

Communication I2C
Pour l’écran I2C OLED, voici les connexions que vous devez effectuer :
OLED | ESP32 | ESP8266 |
Vin | 3.3V | 3.3V |
GND | GND | GND |
SCL | GPIO 22 | GPIO 5 (D1) |
SDA | GPIO 21 | GPIO 4 (D2) |
Pièces requises
Voici une liste des pièces dont vous avez besoin pour ce projet :
Vous pouvez utiliser les liens précédents ou aller directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !
Schéma – ESP32
Suivez le schéma suivant si vous utilisez une carte ESP32 :

Lecture recommandée: Guide de référence du brochage ESP32
Schéma – ESP8266
Suivez le schéma suivant si vous utilisez une carte ESP8266 :

Lecture recommandée: Guide de référence du brochage ESP8266
Bibliothèque OLED SSD1306
La bibliothèque pour écrire sur l’écran OLED ne fait pas partie de la bibliothèque MicroPython standard par défaut. Vous devez donc télécharger la bibliothèque sur votre carte ESP32/ESP8266.
#MicroPython SSD1306 OLED driver, I2C and SPI interfaces created by Adafruit
import time
import framebuf
# register definitions
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xa4)
SET_NORM_INV = const(0xa6)
SET_DISP = const(0xae)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xa0)
SET_MUX_RATIO = const(0xa8)
SET_COM_OUT_DIR = const(0xc0)
SET_DISP_OFFSET = const(0xd3)
SET_COM_PIN_CFG = const(0xda)
SET_DISP_CLK_DIV = const(0xd5)
SET_PRECHARGE = const(0xd9)
SET_VCOM_DESEL = const(0xdb)
SET_CHARGE_PUMP = const(0x8d)
class SSD1306:
def __init__(self, width, height, external_vcc):
self.width = width
self.height = height
self.external_vcc = external_vcc
self.pages = self.height // 8
# Note the subclass must initialize self.framebuf to a framebuffer.
# This is necessary because the underlying data buffer is different
# between I2C and SPI implementations (I2C needs an extra byte).
self.poweron()
self.init_display()
def init_display(self):
for cmd in (
SET_DISP | 0x00, # off
# address setting
SET_MEM_ADDR, 0x00, # horizontal
# resolution and layout
SET_DISP_START_LINE | 0x00,
SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
SET_MUX_RATIO, self.height - 1,
SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
SET_DISP_OFFSET, 0x00,
SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
# timing and driving scheme
SET_DISP_CLK_DIV, 0x80,
SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
SET_VCOM_DESEL, 0x30, # 0.83*Vcc
# display
SET_CONTRAST, 0xff, # maximum
SET_ENTIRE_ON, # output follows RAM contents
SET_NORM_INV, # not inverted
# charge pump
SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
SET_DISP | 0x01): # on
self.write_cmd(cmd)
self.fill(0)
self.show()
def poweroff(self):
self.write_cmd(SET_DISP | 0x00)
def contrast(self, contrast):
self.write_cmd(SET_CONTRAST)
self.write_cmd(contrast)
def invert(self, invert):
self.write_cmd(SET_NORM_INV | (invert & 1))
def show(self):
x0 = 0
x1 = self.width - 1
if self.width == 64:
# displays with width of 64 pixels are shifted by 32
x0 += 32
x1 += 32
self.write_cmd(SET_COL_ADDR)
self.write_cmd(x0)
self.write_cmd(x1)
self.write_cmd(SET_PAGE_ADDR)
self.write_cmd(0)
self.write_cmd(self.pages - 1)
self.write_framebuf()
def fill(self, col):
self.framebuf.fill(col)
def pixel(self, x, y, col):
self.framebuf.pixel(x, y, col)
def scroll(self, dx, dy):
self.framebuf.scroll(dx, dy)
def text(self, string, x, y, col=1):
self.framebuf.text(string, x, y, col)
class SSD1306_I2C(SSD1306):
def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
self.i2c = i2c
self.addr = addr
self.temp = bytearray(2)
# Add an extra byte to the data buffer to hold an I2C data/command byte
# to use hardware-compatible I2C transactions. A memoryview of the
# buffer is used to mask this byte from the framebuffer operations
# (without a major memory hit as memoryview doesn't copy to a separate
# buffer).
self.buffer = bytearray(((height // 8) * width) + 1)
self.buffer[0] = 0x40 # Set first byte of data buffer to Co=0, D/C=1
self.framebuf = framebuf.FrameBuffer1(memoryview(self.buffer)[1:], width, height)
super().__init__(width, height, external_vcc)
def write_cmd(self, cmd):
self.temp[0] = 0x80 # Co=1, D/C#=0
self.temp[1] = cmd
self.i2c.writeto(self.addr, self.temp)
def write_framebuf(self):
# Blast out the frame buffer using a single I2C transaction to support
# hardware I2C interfaces.
self.i2c.writeto(self.addr, self.buffer)
def poweron(self):
pass
class SSD1306_SPI(SSD1306):
def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
self.rate = 10 * 1024 * 1024
dc.init(dc.OUT, value=0)
res.init(res.OUT, value=0)
cs.init(cs.OUT, value=1)
self.spi = spi
self.dc = dc
self.res = res
self.cs = cs
self.buffer = bytearray((height // 8) * width)
self.framebuf = framebuf.FrameBuffer1(self.buffer, width, height)
super().__init__(width, height, external_vcc)
def write_cmd(self, cmd):
self.spi.init(baudrate=self.rate, polarity=0, phase=0)
self.cs.high()
self.dc.low()
self.cs.low()
self.spi.write(bytearray([cmd]))
self.cs.high()
def write_framebuf(self):
self.spi.init(baudrate=self.rate, polarity=0, phase=0)
self.cs.high()
self.dc.high()
self.cs.low()
self.spi.write(self.buffer)
self.cs.high()
def poweron(self):
self.res.high()
time.sleep_ms(1)
self.res.low()
time.sleep_ms(10)
self.res.high()
Suivez les instructions suivantes pour l’IDE que vous utilisez :
- A. Téléchargez la bibliothèque OLED avec IDE uPyCraft
- B. Téléchargez la bibliothèque OLED avec Thonny IDE
A. Télécharger la bibliothèque OLED avec uPyCraft IDE
Cette section montre comment télécharger une bibliothèque à l’aide de l’IDE uPyCraft. Si vous utilisez Thonny IDE, lisez la section suivante.
1. Créez un nouveau fichier en appuyant sur le Nouveau fichier bouton.

2. Copiez le code de la bibliothèque OLED dans ce fichier. le Le code de la bibliothèque OLED peut être trouvé ici.
Noter: la bibliothèque d’affichage SSD1306 OLED a été construite par Adafruit et ne sera plus
être mis à jour. Pour le moment, ça marche bien. Cependant, nous mettrons à jour ce guide si nous
trouver une bibliothèque similaire qui fonctionne aussi bien que celle-ci.
3. Après avoir copié le code, enregistrez le fichier en appuyant sur la touche Sauvegarder bouton.

4. Appelez ce nouveau fichier « ssd1306.py » et appuyez sur d’accord.

5. Clique le Télécharger et exécuter bouton.

Le fichier doit être enregistré dans le dossier de l’appareil sous le nom « ssd1306.py » comme
mis en évidence dans la figure suivante.

Maintenant, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque.
B. Télécharger la bibliothèque OLED avec Thonny IDE
Si vous utilisez Thonny IDE, suivez les étapes suivantes :
1. Copiez le code de la bibliothèque dans un nouveau fichier. le Le code de la bibliothèque OLED peut être trouvé ici.
2. Enregistrez ce fichier sous ssd1306.py.
3. Aller à Appareil > Télécharger le script actuel avec le nom actuel

Et c’est tout. La bibliothèque a été téléchargée sur votre tableau. Pour vous assurer qu’il a été téléchargé avec succès, dans le Shell, vous pouvez taper :
%lsdevice
Il devrait renvoyer les fichiers actuellement enregistrés sur votre tableau. L’un d’eux devrait être le ssd1306.py déposer.

Après avoir téléchargé la bibliothèque sur votre tableau, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque.
Code
Après avoir téléchargé la bibliothèque sur l’ESP32 ou l’ESP8266, copiez le code suivant dans le
main.py déposer. Il imprime simplement le ‘Bonjour le monde!‘ trois fois à l’écran.
# Complete project details at https://Raspberryme.com
from machine import Pin, SoftI2C
import ssd1306
from time import sleep
# ESP32 Pin assignment
i2c = SoftI2C(scl=Pin(22), sda=Pin(21))
# 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)
oled.text('Hello, World 1!', 0, 0)
oled.text('Hello, World 2!', 0, 10)
oled.text('Hello, World 3!', 0, 20)
oled.show()
Comment fonctionne le code
Commencez par importer les modules nécessaires pour interagir avec les GPIO et envoyer des données à l’OLED via la communication I2C. Vous devez importer le Épingler et SoftI2C cours de la machine module.
from machine import Pin, SoftI2C
Vous devez également importer la bibliothèque OLED que vous avez précédemment téléchargée sur le tableau en tant que ssd1306.py déposer.
import ssd1306
Les broches I2C par défaut de l’ESP32 sont GPIO 22 (SCL) et GPIO 21 (SDA). Les broches I2C par défaut de l’ESP8266 sont GPIO 5 (SLC) et GPIO 4 (SDA).
Utilisez la ligne suivante si vous utilisez une carte ESP32 :
# ESP32 Pin assignment
i2c = SoftI2C(scl=Pin(22), sda=Pin(21))
Commentez la ligne précédente et décommentez ce qui suit si vous utilisez une carte ESP8266 :
#ESP8266 Pin assignment
i2c = SoftI2C(scl=Pin(5), sda=Pin(4))
Définissez la largeur et la hauteur OLED sur les variables suivantes :
oled_width = 128
oled_height = 64
Après cela, créez un SSD1306_I2C objet appelé vieux. Cet objet accepte la largeur, la hauteur et les broches I2C de l’OLED que vous avez définies précédemment.
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)
Après avoir initialisé l’écran OLED, il vous suffit d’utiliser le texte() fonction sur le vieux objet pour écrire du texte. Après le texte() fonction, vous devez appeler la Afficher() méthode pour mettre à jour l’OLED.
oled.text('Hello, World 1!', 0, 0)
oled.text('Hello, World 2!', 0, 10)
oled.text('Hello, World 3!', 0, 20)
oled.show()
le texte() La méthode accepte les arguments suivants (dans cet ordre) :
- Message: doit être de type String
- Position X : où commence le texte
- Position Y : où le texte est affiché verticalement
- Couleur du texte : il peut être noir ou blanc. La couleur par défaut est le blanc et ce paramètre est facultatif.
Par exemple, la ligne suivante écrit le message « Hello, World 1 ! » message de couleur blanche. Le texte commence sur x = 0 et y = 0.
oled.text('Hello, World 1!', 0, 0)
La ligne de code suivante écrit le texte sur la ligne suivante (y =10).
oled.text('Hello, World 2!', 0, 10)
Enfin, pour que les modifications prennent effet, utilisez le Afficher() méthode sur le vieux objet.
oled.show()
Manifestation
Téléchargez le code sur votre tableau. Votre écran OLED devrait ressembler à ceci :

Autres fonctions OLED
La bibliothèque fournit d’autres méthodes pour interagir avec l’écran OLED.
Remplir l’écran
Pour remplir tout l’écran de blanc, utilisez le remplir() fonctionner comme suit :
oled.fill(1)
oled.show()

Pour effacer l’écran, utilisez le remplir() méthode comme passe 0 comme argument. (Définit tous les pixels sur noir) :
oled.fill(0)
oled.show()
Dessiner un pixel
Pour dessiner un pixel, utilisez le pixel() méthode, suivie de la Afficher() méthode. le pixel() La méthode accepte les arguments suivants :
- Coordonnée X : emplacement des pixels horizontalement
- Coordonnée Y : emplacement des pixels verticalement
- Couleur des pixels : peut être noir ou blanc
Par exemple, pour dessiner un pixel blanc dans le coin supérieur gauche :
oled.pixel(0, 0, 1)
oled.show()

Inverser les couleurs
Vous pouvez également inverser les couleurs OLED : blanc avec noir et vice versa, en utilisant le inverser() méthode:
oled.invert(True)

Pour revenir aux couleurs d’origine, utilisez :
oled.invert(False)
Affichage des données des capteurs
le texte() La fonction accepte uniquement les variables de type String en tant que message. Les lectures des capteurs sont généralement stockées dans des variables int ou float.
Si vous souhaitez afficher les lectures des capteurs et qu’elles sont stockées dans des variables int ou float, elles doivent être converties en chaîne. Pour convertir les données en chaîne, vous pouvez utiliser le str() une fonction:
temperature = 12.34
temperature_string = str(temperature)
Ensuite, vous pouvez afficher le chaîne_température variable sur l’OLED à l’aide de la texte() et Afficher() méthodes :
oled.text(temperature_string, 0, 0)
oled.show()
Conclusion
Ce guide rapide vous a montré comment utiliser les fonctionnalités de base OLED : écrire du texte et dessiner des pixels avec l’ESP32 et l’ESP8266 en utilisant MicroPython. Maintenant, vous pouvez utiliser l’OLED dans vos propres projets pour afficher des messages ou des lectures de capteurs.
Nous avons d’autres tutoriels MicroPython que vous pourriez également aimer :
Si vous souhaitez en savoir plus sur la programmation des cartes ESP32 et ESP8266 avec MicroPython, consultez notre eBook : Programmation MicroPython avec ESP32 et ESP8266.
-
ESP8266 OLED ESP12F Node-MCU Carte de Développement avec écran OLED de 0,96 Pouces,Pilote CH340,Module sans Fil ESP-12E WiFi, et Micro USB,pour la Programmation Arduino IDE/MicropythonLa carte ESP8266 Display Node-MCU possède toutes les caractéristiques du module ESP8266 traditionnel, avec la même taille et les mêmes ports périphériques, et offre une intégration transparente avec un écran OLED de 0,96 pouce. L'écran présente une haute résolution de 128x64 avec un pilote 1306 et est compatible avec les interfaces I2C et SPI. Cette ESP8266 Display carte utilise l'I2C pour se connecter à un écran OLED via les broches SDA (D6 / GPIO12) et SCL (D5 / GPIO14). Avec cette carte, il est facile d'afficher une variété d'informations et de données. La carte ESP8266 Node-MCU est équipée d'un module ESP12E, qui contient le microprocesseur RISC Tensilica Xtensa 32-bit LX106 alimentant la puce ESP8266. Ce microprocesseur supporte le RTOS et fonctionne à une fréquence d'horloge réglable entre 80 MHz et 160 MHz. Pour installer la nouvelle version du pilote CH340, il suffit de rechercher les mots clés "CH340 Driver" sur Google.com ou Bing.com et de suivre les instructions d'installation fournies.Recommandé pour le système d'exploitation Win10. Cette ESP8266 Display Node-MCU carte est une option exceptionnelle pour divers projets d'Internet des objets (IoT). Elle peut être utilisée pour afficher l'état de la connexion réseau,les informations de surveillance, les niveaux de puissance et d'autres données pertinentes.
-
ESP8266 OLED ESP12F Node-MCU Carte de Développement XTVTX 2 Pièces OLED Arduino avec écran OLED de 0,96 Pouces,Pilote CH340,Module sans Fil ESP-12E WiFi, et Micro USB,pour la Programmation ArduinoLa carte ESP8266 Node-MCU possède toutes les caractéristiques du module ESP8266 traditionnel, avec la même taille et les mêmes ports périphériques, et offre une intégration transparente avec un écran OLED de 0,96 pouce. L'écran présente une haute résolution de 128x64 avec un pilote 1306 et est compatible avec les interfaces I2C et SPI. Cette ESP8266 Display carte utilise l'I2C pour se connecter à un écran OLED via les broches SDA (D6 / GPIO12) et SCL (D5 / GPIO14). Avec cette carte, il est facile d'afficher une variété d'informations et de données. Pour installer la nouvelle version du pilote CH-340, il suffit de rechercher les mots clés "CH340 Driver" sur Google.com ou Bing.com et de suivre les instructions d'installation fournies.Recommandé pour le système d'exploitation Win10. La carte ESP8266 Display Node-MCU est équipée d'un module ESP12E, qui contient le microprocesseur RISC Tensilica Xtensa 32-bit LX106 alimentant la puce ESP8266. Ce microprocesseur supporte le RTOS et fonctionne à une fréquence d'horloge réglable entre 80 MHz et 160 MHz. Cette ESP8266 Display carte est une option exceptionnelle pour divers projets d'Internet des objets (IoT). Elle peut être utilisée pour afficher l'état de la connexion réseau,les informations de surveillance, les niveaux de puissance et d'autres données pertinentes.
-
DIYmalls 0.96" OLED écran Module I2C IIC 128x64 SSD - 1306 3.3V-5V Blanc pour Arduino ESP32 ESP8266 (lot de 3)-0.96 OLED se connecte facilement en utilisant I2C sur quatre lignes (alimentation, masse, données et horloge) à l'adresse 0x3c. L'adresse est modifiable avec quelques soudures, mais à moins que vous n'en ayez vraiment besoin, ne risquez pas. -L'adresse I2C réelle (7 bits) de OLED est 0x3C, pas 3D, pas l'adresse (8 bits) imprimée à l'arrière de l'écran dit 0x78 ou 0x7A. 0x78 est 0x3C décalé vers la gauche de 1 bit, c'est ainsi que les adresses i2c sont envoyées sur le bus. Vous devez définir correctement cette adresse dans n'importe quelle esquisse, sinon vous n'obtiendrez pas de données envoyées à l'écran et vous risquez de la confondre avec un DOA. -L'une des grandes choses à propos de l'écran OLED est qu'ils sont par conception, émettant de la lumière. Vous pouvez avoir les écrans dans l'obscurité totale, et vous pouvez facilement les lire. À la lumière directe du soleil, ils peuvent toujours être lu, mais il n'est pas recommandé de les exposer au soleil pendant de longues périodes. - Ce petit écran OLED est largement utilisé dans les projets de bricolage : montres intelligentes, petite station météo, réveil, moniteur de ressources informatiques (pourcentages d'utilisation du processeur/GPU, disponibilité de la RAM, températures centrales), etc. - Il y a un film transparent amovible sur chaque surface en verre OLED pour une protection résistante aux rayures jusqu'à utilisation.