Développer en Python avec la carte IDEASPARK esp32

La carte IDEASPARK ESP 32 comprend un esp32 vroom intégré avec un écran oled :

Ses caractéristiques principales sont:

microcontrôleur: 32-bits Xtensa@dual-core @ 240 Mhz
Tension d’utilisation: 3.3 Volts
Wifi, Bluetooth
Mémoire Flash de 4 Méga-octets
RAM de 520 Kilo-octets
Écran OLED de 128×64 pixels monochrome. Les 16 premières lignes sont de couleur jaune, les suivantes sont de couleur bleue. Intergace I2C, driver SSD1306

Cette carte peut être achetée en février 2024 aux alentours de 10 euros (frais de port inclus).

Les descriptions trouvées sur les sites vendeurs proposent le développement d’applications en langage C avec l’interface de programmation Arduino IDE. Nous proposons dans cet article de montrer comment développer sur cette carte en micropython.

Installation de MicroPython

Nous utilisons la démarche proposée dans l’excellent article Getting Started with Thonny MicroPython (Python) IDE for ESP32 and ESP8266 : il suffit de suivre les instructions proposées dans l’éditeur Thonny pour flasher micropython. Pour cela aller dans le menu « Exécuter » -> « Configurer l’interpréteur » et cliquer sur « Installer ou mettre à jour MicroPython… »

Gestion de l’écran

La bibliothèque nécessaire pour gérer l’écran OLED ne fait pas partie des bibliothèques standards de MicroPython. L’article MicroPython: OLED Display with ESP32 and ESP8266 décrit en détail les différentes façons de faire. Thonny Ide permet d’importer très facilement la bibliothèque ssd1306 dont voici le source:

ssd1306.py

Python

#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()

Il suffit d’enregistrer directement ce fichier sur l’esp32.

Pour vérifier le bon fonctionnement, il suffit de tester le programme décrit dans l’article cité précédemment:

Python

# Complete project details at https://RandomNerdTutorials.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()

Module ideaSparkScreen de gestion de l’écran

La bibliothèque précédente est très rudimentaire, nous pouvons l’améliorer en définissant un module ideaSparkScreen comportant une classe Screen ayant comme fonctions:

dans tout ce qui suit le paramètre color est optionnel, Il peut valoir 0 ou 1 (valeur par défaut)

drawLine(x1, y1, x2, y2, color) : trace un segment de droite de (x1,y1) à (x2,y2)
drawRect(x, y, x, h, color) : dessine un rectangle creux
fillRect(x, y, w, h, color) : dessine un rectangle plein
drawString(str,ing x, y, color) : affiche une chaine de caractères

Ces primitives peuvent être facilement étendues

Exemple de programme de test:

Python

from ideaSparkScreen import *
import time

ecran=ideaSparkScreen()
ecran.drawString('Hello, World 1!', 0, 0)
ecran.drawString('Hello, World 2!', 0, 8)
ecran.drawString('Hello, World 2!', 0, 16)
ecran.drawString("AAAA",0,0,color=1)
ecran.drawLine(0,0,128,63)
time.sleep(5)
ecran.fillRect(0,0,128,64,color=0)
ecran.drawRect(0,0,128,64)

Source ideaSparlScreen.py (à copier sur l’esp 32):

Python

from machine import Pin, SoftI2C
import ssd1306

class ideaSparkScreen():
    def __init__(self):
        self.oled=ssd1306.SSD1306_I2C(128,64, SoftI2C(scl=Pin(22), sda=Pin(21)))
        
    def drawLine(self,x1,y1,x2,y2,color=1):
        dx = abs(x2 – x1)
        dy = abs(y2 – y1)
        step = dy > dx
        if step:
            x1, y1 = y1, x1
            x2, y2 = y2, x2
            dx, dy = dy, dx
        if x1 > x2:
            x1, x2 = x2, x1
            y1, y2 = y2, y1
        error = 0
        y = y1
        ystep = 1 if y1 < y2 else -1
        for x in range(x1, x2 + 1):
            if step:
                self.oled.pixel(y, x,color)  # Si drawpixel existe
            else:
                self.oled.pixel(x, y,color)  # Si drawpixel existe
            error += dy
            if 2 * error >= dx:
                y += ystep
                error -= dx
        self.oled.show()
        
    def drawRect(self,col,lig,w,h,color=1):
        self.drawLine(col,lig,col+w-1,lig,color)
        self.drawLine(col+w-1,lig,col+w-1,lig+h-1,color)
        self.drawLine(col+w-1,lig+h-1,col,lig+h-1,color)
        self.drawLine(col,lig+h-1,col,lig,color)
        
    def fillRect(self,col,lig,w,h,color=1):
        for i in range(h):
            for j in range(w):
                self.oled.pixel(col+j,lig+i,color)
        self.oled.show()

    def drawString(self,texte,col,lig,color=1):
        self.fillRect(col,lig,len(texte)*8,8,0)
        self.oled.text(texte,col,lig,color)
        self.oled.show()

Connexion wifi

Le programme suivant montre comment se connecter au wifi, puis faire une requête à un serveur ntp pour récupérer la date et l’heure, et enfin affiche l’heure courante et l’adresse ip toutes les minutes

Python

import ntptime
import utime
import network
import time
from ideaSparkScreen import *

def connectWifi(ssid,passwd,maxtry=20):
    wlan=network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        wlan.connect(ssid,passwd)
        nbtry=1
        while not wlan.isconnected():
            time.sleep_ms(500)
            nbtry+=1
            if nbtry>=maxtry:
                return "timeout"
    ip,masque,x,y=wlan.ifconfig()
    return str(ip)

def getTime(offset):
    return utime.time()+offset*3600

def timeToHHMMSS(time):
    year, month, mday, hour, minute, second, weekday, yearday = utime.localtime(time)
    #"{:04d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}".format(year, month, mday, hour, minute, second)
    return "{:02d}:{:02d}:{:02d}".format(hour, minute, second)
    
def timeToHHMM(time):
    year, month, mday, hour, minute, second, weekday, yearday = utime.localtime(time)
    #"{:04d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}".format(year, month, mday, hour, minute, second)
    return "{:02d}:{:02d}".format(hour, minute)

ecran=ideaSparkScreen()
ssid="votre ssid"
password="mot de passe du ssid"
ecran.drawString(connectWifi(ssid,password),0,8)
ntptime.settime()      
while True:
    ecran.drawString(timeToHHMM(getTime(1)),0,0)
    utime.sleep(60) # toutes les minutes

Requêtes HTTP

Pour cela, installer la bibliothèque urequests. L’exemple suivant permet d’effectuer une requête http ou https, de stocker le résultat dans le fichier http.html puis d’afficher le contenu de ce fichier. Attention, la capacité de stockage de la carte est de 4 Méga-octets au maximum (donc veuillez à ce que le résultat de la requête ne soit pas trop important)

Python

import network
import urequests
import uos

def connectWifi(ssid,passwd,maxtry=20):
    wlan=network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        wlan.connect(ssid,passwd)
        nbtry=1
        while not wlan.isconnected():
            time.sleep_ms(500)
            nbtry+=1
            if nbtry>=maxtry:
                return "timeout"
    ip,masque,x,y=wlan.ifconfig()
    return str(ip)
    
def getHttp(url):
    useragent={"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0"}
    reponse=urequests.get(url,headers=useragent)
    return reponse.text
    
def getHttpToFile(url,path):
    r=getHttp(url)
    with open(path,"w") as fout:
        fout.write(r)
    
ssid="Votre SSID"
password="Mot de passe du SSID"
url="http ou https…. url"
print(connectWifi(ssid,password))
getHttpToFile(url,"http.html")
files=uos.listdir("")
print(files)
with open("http.html","r") as finp:
    print(finp.read())

Grimeco

Développer en Python avec la carte IDEASPARK esp32

Installation de MicroPython

Gestion de l’écran

Module ideaSparkScreen de gestion de l’écran

Connexion wifi

Requêtes HTTP

A DECOUVRIR EGALEMENT

Raspberry PI5 Leds WS2812b

PEDI, Python Editeur

Explorateur de cartes

Laisser un commentaire Annuler la réponse