ESP32 MicroPython - Enregistrer des Données avec Horodatage sur Carte SD
Ce guide vous montre comment construire un enregistreur de données qui enregistre des entrées horodatées sur une carte Micro SD en utilisant l'ESP32 et MicroPython. Voici ce que nous allons couvrir :
- L'enregistrement de données horodatées dans un seul fichier journal sur la carte Micro SD.
- L'organisation des journaux dans plusieurs fichiers sur la carte Micro SD, en créant un fichier séparé pour chaque jour.
La date et l'heure sont obtenues depuis un module RTC DS3231 et écrites sur la carte Micro SD avec les lectures du capteur.
Les données enregistrées peuvent inclure tout type de mesure, par exemple :
- Des lectures de capteurs de température, d'humidité ou d'autres capteurs.
- Des événements d'accès depuis un système de contrôle d'accès.
Pour simplifier, ce guide utilise des lectures de deux broches d'entrée analogiques comme données d'exemple. Vous pouvez facilement modifier le code pour enregistrer tout autre type d'information.
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables ESP32 (ESP32 inclus) | |
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
À Propos du Module Micro SD Card et du Module RTC
Besoin d'aide pour démarrer avec le module Micro SD Card ou le module RTC ? Consultez ces tutoriels étape par étape couvrant le brochage, le câblage et la programmation :
- Tutoriel ESP32 MicroPython - Carte Micro SD.
- Tutoriel ESP32 MicroPython - Module RTC.
Schéma de Câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Le tableau de câblage ci-dessous montre comment connecter le module Micro SD Card et le module RTC DS3231 à l'ESP32 :
| Module Micro SD Card | ESP32 |
|---|---|
| VCC | 5V |
| GND | GND |
| MISO | GPIO19 |
| MOSI | GPIO23 |
| SCK | GPIO18 |
| CS | GPIO5 |
| Module RTC DS3231 | ESP32 |
|---|---|
| VCC | 3.3V |
| GND | GND |
| SDA | GPIO21 |
| SCL | GPIO22 |
※ Note:
Si votre shield (comme un shield Ethernet) dispose déjà d'un slot Micro SD Card intégré, vous pouvez ignorer le module externe et simplement insérer la carte directement dans le shield.
ESP32 MicroPython - Enregistrement de Données Horodatées sur Carte Micro SD
/*
* Ce code ESP32 MicroPython a été développé par newbiely.fr
* Ce code ESP32 MicroPython est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp32-micropython/esp32-micropython-log-data-with-timestamp-to-sd-card
*/
import machine
import os
import time
import sdcard
# Define SPI pins for the Micro SD Card module
SPI_SCK_PIN = 18 # The ESP32 pin GPIO18 connected to SCK
SPI_MOSI_PIN = 23 # The ESP32 pin GPIO23 connected to MOSI
SPI_MISO_PIN = 19 # The ESP32 pin GPIO19 connected to MISO
SPI_CS_PIN = 5 # The ESP32 pin GPIO5 connected to SS (CS)
# Define I2C pins for the RTC module
I2C_SDA_PIN = 21 # The ESP32 pin GPIO21 connected to SDA
I2C_SCL_PIN = 22 # The ESP32 pin GPIO22 connected to SCL
FILE_NAME = "/sd/log.txt"
# Initialize I2C and RTC (DS3231)
i2c = machine.I2C(0, sda=machine.Pin(I2C_SDA_PIN), scl=machine.Pin(I2C_SCL_PIN))
# DS3231 I2C address
DS3231_ADDR = 0x68
def bcd_to_dec(bcd):
return (bcd >> 4) * 10 + (bcd & 0x0F)
def get_datetime():
buf = i2c.readfrom_mem(DS3231_ADDR, 0x00, 7)
second = bcd_to_dec(buf[0])
minute = bcd_to_dec(buf[1])
hour = bcd_to_dec(buf[2])
day = bcd_to_dec(buf[4])
month = bcd_to_dec(buf[5] & 0x1F)
year = bcd_to_dec(buf[6]) + 2000
return (year, month, day, hour, minute, second)
# Initialize SD card using SoftSPI and sdcard driver
spi = machine.SoftSPI(baudrate=1000000, polarity=0, phase=0,
sck=machine.Pin(SPI_SCK_PIN),
mosi=machine.Pin(SPI_MOSI_PIN),
miso=machine.Pin(SPI_MISO_PIN))
cs = machine.Pin(SPI_CS_PIN, machine.Pin.OUT)
try:
sd = sdcard.SDCard(spi, cs)
os.mount(sd, "/sd")
print("SD CARD INITIALIZED.")
except Exception as e:
print("SD CARD FAILED, OR NOT PRESENT!", e)
raise SystemExit
print("--------------------")
# Define analog pins
analog_pin_1 = machine.ADC(machine.Pin(36)) # A0
analog_pin_2 = machine.ADC(machine.Pin(39)) # A1
analog_pin_1.atten(machine.ADC.ATTN_11DB) # set attenuation to 11 dB (up to ~3.3V input)
analog_pin_2.atten(machine.ADC.ATTN_11DB)
while True:
try:
f = open(FILE_NAME, "a")
print("Writing log to SD Card")
# Get timestamp from RTC
year, month, day, hour, minute, second = get_datetime()
timestamp = "{}-{}-{} {}:{}:{}".format(year, month, day, hour, minute, second)
# Read data
analog_1 = analog_pin_1.read()
analog_2 = analog_pin_2.read()
# Write timestamp and data
f.write("{} analog_1 = {}, analog_2 = {}\n".format(timestamp, analog_1, analog_2))
f.close()
except Exception as e:
print("SD Card: Issue encountered while attempting to open the file", FILE_NAME, e)
time.sleep(2) # delay 2 seconds
Étapes Rapides
Voici les instructions pour configurer et exécuter votre code MicroPython sur l'ESP32 avec Thonny IDE :
- Assurez-vous que Thonny IDE est installé sur votre ordinateur.
- Confirmez que le firmware MicroPython est chargé sur votre carte ESP32.
- Si c'est la première fois que vous utilisez un ESP32 avec MicroPython, consultez le guide ESP32 - Premiers pas. pour des instructions étape par étape.
- Effectuez le câblage comme indiqué sur l'image ci-dessus.
- Connectez la carte ESP32 à votre ordinateur avec un câble USB.
- Ouvrez Thonny IDE sur votre ordinateur.
- Dans Thonny IDE, allez dans Outils Options.
- Dans l'onglet Interpréteur, choisissez MicroPython (ESP32) dans le menu déroulant.
- Assurez-vous que le bon port est sélectionné. Thonny IDE le détecte généralement automatiquement, mais vous devrez peut-être le sélectionner manuellement (comme COM3 sur Windows ou /dev/ttyACM0 sur Linux).
- Naviguez vers Outils Gérer les packages dans Thonny IDE.
- Recherchez "sdcard", puis trouvez la bibliothèque sdcard fournie par micropython-lib.
- Cliquez sur sdcard, puis cliquez sur le bouton Installer pour installer la bibliothèque de carte SD.
- Assurez-vous que la carte Micro SD est formatée en FAT16 ou FAT32 (recherchez des instructions en ligne si nécessaire)
- Copiez le code MicroPython fourni et collez-le dans l'éditeur de Thonny.
- Sauvegardez le code sur votre ESP32 en :
- Cliquant sur le bouton Enregistrer ou en appuyant sur Ctrl+S.
- Dans la boîte de dialogue d'enregistrement, choisissez Appareil MicroPython.
- Nommez le fichier main.py.
- Cliquez sur le bouton vert Exécuter (ou appuyez sur F5) pour exécuter le script.
- Consultez le message dans le Shell en bas de Thonny.
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
SD CARD INITIALIZED.
--------------------
Writing log to SD Card
Writing log to SD Card
Writing log to SD Card
Writing log to SD Card
Writing log to SD Card
Writing log to SD Card
Writing log to SD Card
MicroPython (ESP32) • CP2102 USB To UART Bridge Controller @ COM12 ≡
- Retirez la carte Micro SD du module
- Insérez-la dans un lecteur de carte SD USB connecté à votre PC
- Ouvrez le fichier log.txt sur votre ordinateur — son contenu devrait ressembler à ceci :
Si vous n'avez pas de lecteur de carte SD USB, vous pouvez vérifier le contenu du fichier journal en exécutant le code MicroPython suivant sur l'ESP32.
/*
* Ce code ESP32 MicroPython a été développé par newbiely.fr
* Ce code ESP32 MicroPython est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp32-micropython/esp32-micropython-log-data-with-timestamp-to-sd-card
*/
import machine
import os
import sdcard
# Define SPI pins for the Micro SD Card module
SPI_SCK_PIN = 18 # The ESP32 pin GPIO18 connected to SCK
SPI_MOSI_PIN = 23 # The ESP32 pin GPIO23 connected to MOSI
SPI_MISO_PIN = 19 # The ESP32 pin GPIO19 connected to MISO
SPI_CS_PIN = 5 # The ESP32 pin GPIO5 connected to SS (CS)
FILE_NAME = "/sd/log.txt"
# Initialize SD card using SoftSPI and sdcard driver
spi = machine.SoftSPI(baudrate=1000000, polarity=0, phase=0,
sck=machine.Pin(SPI_SCK_PIN),
mosi=machine.Pin(SPI_MOSI_PIN),
miso=machine.Pin(SPI_MISO_PIN))
cs = machine.Pin(SPI_CS_PIN, machine.Pin.OUT)
try:
sd = sdcard.SDCard(spi, cs)
os.mount(sd, "/sd")
print("SD CARD INITIALIZED.")
except Exception as e:
print("SD CARD FAILED, OR NOT PRESENT!", e)
raise SystemExit
# Open file for reading
try:
f = open(FILE_NAME, "r")
while True:
ch = f.read(1) # read characters one by one from Micro SD Card
if not ch:
break
print(ch, end="") # print the character to the Shell
f.close()
except Exception as e:
print("SD Card: Issue encountered while attempting to open the file", FILE_NAME, e)
os.umount("/sd")
ESP32 MicroPython - Journalisation dans des Fichiers Quotidiens Séparés
Stocker tous les journaux dans un seul fichier le fait grossir avec le temps, rendant la gestion plus difficile. Le code ci-dessous divise les journaux en plusieurs fichiers :
- Un nouveau fichier est créé pour chaque jour
- Chaque nom de fichier suit le format : AAAAMMJJ.txt
/*
* Ce code ESP32 MicroPython a été développé par newbiely.fr
* Ce code ESP32 MicroPython est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp32-micropython/esp32-micropython-log-data-with-timestamp-to-sd-card
*/
import machine
import os
import time
import sdcard
# Define SPI pins for the Micro SD Card module
SPI_SCK_PIN = 18 # The ESP32 pin GPIO18 connected to SCK
SPI_MOSI_PIN = 23 # The ESP32 pin GPIO23 connected to MOSI
SPI_MISO_PIN = 19 # The ESP32 pin GPIO19 connected to MISO
SPI_CS_PIN = 5 # The ESP32 pin GPIO5 connected to SS (CS)
# Define I2C pins for the RTC module
I2C_SDA_PIN = 21 # The ESP32 pin GPIO21 connected to SDA
I2C_SCL_PIN = 22 # The ESP32 pin GPIO22 connected to SCL
# Initialize I2C and RTC (DS3231)
i2c = machine.I2C(0, sda=machine.Pin(I2C_SDA_PIN), scl=machine.Pin(I2C_SCL_PIN))
# DS3231 I2C address
DS3231_ADDR = 0x68
def bcd_to_dec(bcd):
return (bcd >> 4) * 10 + (bcd & 0x0F)
def get_datetime():
buf = i2c.readfrom_mem(DS3231_ADDR, 0x00, 7)
second = bcd_to_dec(buf[0])
minute = bcd_to_dec(buf[1])
hour = bcd_to_dec(buf[2])
day = bcd_to_dec(buf[4])
month = bcd_to_dec(buf[5] & 0x1F)
year = bcd_to_dec(buf[6]) + 2000
return (year, month, day, hour, minute, second)
# Initialize SD card using SoftSPI and sdcard driver
spi = machine.SoftSPI(baudrate=1000000, polarity=0, phase=0,
sck=machine.Pin(SPI_SCK_PIN),
mosi=machine.Pin(SPI_MOSI_PIN),
miso=machine.Pin(SPI_MISO_PIN))
cs = machine.Pin(SPI_CS_PIN, machine.Pin.OUT)
try:
sd = sdcard.SDCard(spi, cs)
os.mount(sd, "/sd")
print("SD CARD INITIALIZED.")
except Exception as e:
print("SD CARD FAILED, OR NOT PRESENT!", e)
raise SystemExit
print("--------------------")
# Define analog pins
analog_pin_1 = machine.ADC(machine.Pin(36)) # A0
analog_pin_2 = machine.ADC(machine.Pin(39)) # A1
analog_pin_1.atten(machine.ADC.ATTN_11DB) # set attenuation to 11 dB (up to ~3.3V input)
analog_pin_2.atten(machine.ADC.ATTN_11DB)
while True:
year, month, day, hour, minute, second = get_datetime()
# Generate filename: /sd/YYYYMMDD.txt
filename = "/sd/{:04d}{:02d}{:02d}.txt".format(year, month, day)
try:
f = open(filename, "a")
print("Writing log to SD Card")
# Write timestamp
timestamp = "{}-{}-{} {}:{}:{}".format(year, month, day, hour, minute, second)
# Read data
analog_1 = analog_pin_1.read()
analog_2 = analog_pin_2.read()
# Write timestamp and data
f.write("{} analog_1 = {}, analog_2 = {}\n".format(timestamp, analog_1, analog_2))
f.close()
except Exception as e:
print("SD Card: Issue encountered while attempting to open the file", filename, e)
time.sleep(2) # delay 2 seconds
Après une période d'exécution prolongée, si vous :
- Retirez la carte Micro SD du module
- L'insérez dans un lecteur de carte SD USB connecté à votre PC
- Vous trouverez plusieurs fichiers journaux comme illustré ci-dessous :
