Accueil > ESP32, Matériel > Utilisation du convertisseur analogique-numérique ADS1115 en MicroPython

Utilisation du convertisseur analogique-numérique ADS1115 en MicroPython

Suite aux problèmes de conversion analogique-numérique rencontrés avec l’ESP32, aujourd’hui nous allons voir comment utiliser un convertisseur externe à savoir l’ADS1115.

Ce convertisseur se présente comme suit :

Le brochage est le suivant :

  • VDD : 2v à 5.5v
  • GND : masse
  • SCL, SDA : bus i2c
  • ADDR : permet de définir l’adresse i2c
  • ALRT : information lorsqu’une conversion est effectuée
  • A0, A1, A2, A3 : entrées analogiques

La configuration de l’adresse i2c s’effectue avec la broche ADDR; ainsi on peut configurer 4 adresses en effectuant le branchement suivant :

  • Adresse 0x48 : ADDR –> GND
  • Adresse 0x49 : ADDR –> VDD
  • Adresse 0x4A : ADDR –> SDA
  • Adresse 0X4B : ADDR –> SCL

Les spécifications sont les suivantes :

  • Précision : 16 bits (15 bits + 1 bit signé)
  • Débit des mesures programmables :
    • 8 échantillons par seconde
    • 16 échantillons par seconde
    • 32 échantillons par seconde
    • 64 échantillons par seconde
    • 128 échantillons par seconde
    • 250 échantillons par seconde
    • 475 échantillons par seconde
    • 860 échantillons par seconde
  • 4 canaux ou 2 canaux différentiels.
  • Amplificateur de gain programmable (PGA) :
    • +/- 6.144 v : gain x2/3
    • +/- 4.096 v : gain x1
    • +/- 2.048 v : gain x2
    • +/- 1.024 v : gain x4
    • +/- 0.512 v : gain x8
    • +/- 0.256 v : gain x16

La librairie pour MicroPython peut être téléchargée à l’adresse Github suivante.

Le module ADS1115 sera branché à l’ESP32 Heltec Wifi Kit 32 comme suit :

ADS1115 broche VDD –> ESP32 broche + 3.3v

ADS1115 broche GND –> ESP32 broche GND

ADS1115 broche SCL –> ESP32 broche GPIO22

ADS1115 broche SDA –> ESP32 broche GPIO21

ADS1115 broche ADDR –> GND

ADS1115 broche ALRT –> ESP32 broche GPIO13

Le premier programme va effectuer une seule mesure de l’entrée A0, effectuer la conversion en volt et l’afficher sur l’écran OLED de l’ESP32 Wifi Kit 32, dont voici le contenu :

#
# Utilisation du convertisseur ADS1115
#
# Materiel :
#               Heltec Wifi Kit 32 (ESP32)
#               OLED SSD1306 integre
#               ADS1115
#
# Auteur : iTechnoFrance
#

import machine, time, ssd1306, ads1x15

# Activation ecran OLED integre
reset_oled = machine.Pin16, machine.Pin.OUT)  # GPIO16 --> Reset OLED
reset_oled.value(0)  # reset OLED
time.sleep(0.050)  # attente 50 ms
reset_oled.value(1)  # active OLED

# Declaration I2C pour la gestion de l'afficheur OLED SSD1306
# GPIO15 --> SCL OLED, GPIO04 --> SDA OLED
i2c_oled = machine.I2C(scl=machine.Pin(15), sda=machine.Pin(4))
oled = ssd1306.SSD1306_I2C(128, 64, i2c_oled)  # 128 x 64 pixels

# Declaration I2C pour la communication avec le module ADS1115
# GPIO21 --> SDA, GPIO22 --> SCL
i2c = machine.I2C(scl=machine.Pin(22), sda=machine.Pin(21))

# Declaration module ADS1115
adresse_ads1115 = 0x48
gain = 1
# gain 0 : 6.144V # 2/3x
# gain 1 : 4.096V # 1x
# gain 2 : 2.048V # 2x
# gain 3 : 1.024V # 4x
# gain 4 : 0.512V # 8x
# gain 5 : 0.256V # 16x
adc = ads1x15.ADS1115(i2c, adresse_ads1115, gain)
echantillons = 3
# 0 :  8   echantillons/seconde
# 1 :  16  echantillons/seconde
# 2 :  32  echantillons/seconde
# 3 :  64  echantillons/seconde
# 4 :  128 echantillons/seconde (defaut)
# 5 :  250 echantillons/seconde
# 6 :  475 echantillons/seconde
# 7 :  860 echantillons/seconde
canal = 0
# 0 : A0
# 1 : A1
# 2 : A2
# 3 : A3

mesure = adc.read(echantillons, canal)  # effectue une mesure
tension = adc.raw_to_v(mesure)  # conversion de la mesure en tension
oled.fill(0)  # efface l'ecran
oled.text("VOLTMETRE", 20, 0)
oled.text(str(tension), 50, 20)
oled.show()

La librairie permet également d’effectuer des mesures séquentielles dans une boucle ou à partir d’un Timer en modifiant le code :

adc.set_conv(echantillons, canal)  # initialise les parametres de conversion

while True:
    mesure = adc.read_rev()  # recupere la derniere conversion et relance une nouvelle conversion
    tension = adc.raw_to_v(mesure)  # conversion de la mesure en tension
    oled.fill(0)  # efface l'ecran
    oled.text("VOLTMETRE", 20, 0)
    oled.text(str(tension), 50, 20)
    oled.show()
    time.sleep(5)

La librairie permet d’effectuer une mesure différentielle entre 2 canaux d’entrée. Voici la partie du code modifié pour gérer cette fonctionnalité  :

canal0 = 0
canal1 = 1
# 0 : A0
# 1 : A1
# 2 : A2
# 3 : A3

while True:
    mesure = adc.read(echantillons, canal0, canal1)  # effectue une mesure différentielle canal0 - canal1
    tension = adc.raw_to_v(mesure)  # conversion de la mesure en tension
    oled.fill(0)  # efface l'ecran
    oled.text("VOLTMETRE", 20, 0)
    oled.text(str(tension), 50, 20)
    oled.show()
    time.sleep(5)

Il est également possible d’effectuer une conversion et quand celle-ci est effectuée, la broche ALRT change d’état (il suffit ensuite de traiter ce signal à partir d’une interruption). Voici la partie du code pour mettre en oeuvre cette fonctionnalité :

mesure = 0

def traite_interruption(rien):
    global mesure
    mesure = adc.alert_read()  # recupere la mesure

# Definition GPIO13 pour traiter l'interruption
pin_interrupt = machine.Pin(13, machine.Pin.IN, machine.Pin.PULL_UP)
# interruption sur un niveau bas
pin_interrupt.irq(trigger = machine.Pin.IRQ_FALLING, handler = traite_interruption)

# demarre la conversion en continu
adc.conversion_start(echantillons, canal)

while True:
    tension = adc.raw_to_v(mesure)  # conversion de la mesure en tension
    oled.fill(0)  # efface l'ecran
    oled.text("VOLTMETRE", 20, 0)
    oled.text(str(tension), 50, 20)
    oled.show()

La librairie permet également de changer l’état de la broche ALRT quand un seuil est défini. Dans l’exemple qui suit on traite l’interruption :

seuil_trigger = False

def traite_interruption(rien):
global seuil_trigger
seuil_trigger = True

# Definition GPIO13 pour traiter l'interruption
pin_interrupt = machine.Pin(13, machine.Pin.IN, machine.Pin.PULL_UP)
# interruption sur un niveau bas
pin_interrupt.irq(trigger = machine.Pin.IRQ_FALLING, handler = traite_interruption)

seuil = 0x800
# Mesure continue avec definition d'un seuil
adc.alert_start(echantillons, canal, None, seuil)

while True:
mesure = adc.alert_read() # recupere la mesure
# si la mesure depasse le seuil, un changement d'etat se produit sur la broche ALRT
if seuil_trigger:
    oled.fill(0) # efface l'ecran
    oled.text("SEUIL DETECTE", 0, 0)
    oled.show()
    seuil_trigger = False
else:
    oled.fill(0) # efface l'ecran
    oled.show()

Voilà nous avons effectué un tour sur l’utilisation de ce convertisseur et de la librairie.

Catégories :ESP32, Matériel Étiquettes : ,
  1. Aucun commentaire pour l’instant.
  1. No trackbacks yet.

Votre commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google

Vous commentez à l’aide de votre compte Google. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s

%d blogueurs aiment cette page :