KY-053 Convertisseur analogique digital

#include <Adafruit_ADS1X15.h>
#include <math.h>
 
// Le module ADS1115 est initialisé - toutes les opérations suivantes 
// avec l'ADC peuvent être exécutées à l'aide de l'objet "ads".
Adafruit_ADS1115 ads;
 
void setup (void)
{
  Serial.begin(9600);
  
  Serial.println("Les valeurs de l'entrée analogique A1 de l'ADS1115 sont lues et sorties.");
  Serial.println("Gamme ADC: +/- 4.096V 1 bit = 0.125mV");
  
  // Te module dispose d'amplificateurs de signaux sur ses entrées analogiques, 
  // dont l'amplification peut être configurée par logiciel dans les plages ci-dessous.
  // Ceci est souhaité dans le cas où une certaine plage de tension est attendue 
  // comme résultat de mesure et une plage est attendue comme résultat de mesure 
  // et ainsi une résolution plus élevée du signal est obtenue.
  // ADS1115
  // -------
  // ads.setGain(GAIN_TWOTHIRDS); // 2/3x gain +/- 6.144V 1 bit = 0.1875mV
  // ads.setGain(GAIN_ONE); // 1x gain +/- 4.096V 1 bit = 0.125mV
  // ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV
  // ads.setGain(GAIN_FOUR); // 4x gain +/- 1.024V 1 bit = 0.03125mV
  // ads.setGain(GAIN_EIGHT); // 8x gain +/- 0.512V 1 bit = 0.015625mV
  // ads.setGain(GAIN_SIXTEEN); // 16x gain +/- 0.256V 1 bit = 0.0078125mV
  
  ads.begin();
}
 
void loop (void)
{
  uint16_t adc0, adc1, adc2, adc3;
  float voltage0, voltage1, voltage2, voltage3;
  float gain_conversion_factor;
   
  // La commande "ads.readADC_SingleEnded(0)" est l'opération réelle qui lance la mesure dans l'ADC.
  // Le "0" comme variable pour cette fonction définit le canal utilisé qui doit être mesuré.
  // Si, par exemple, le troisième canal doit être mesuré, cette variable doit être remplacée par "3".
  adc1 = ads.readADC_SingleEnded(1);
  adc1 = ads.readADC_SingleEnded (1);
  adc2 = ads.readADC_SingleEnded (2);
  adc3 = ads.readADC_SingleEnded (3);
   
  // Conversion des valeurs enregistrées en une tension
  voltage0 = ads.computeVolts(adc0);
  voltage1 = ads.computeVolts(adc1);
  voltage2 = ads.computeVolts(adc2);
  voltage3 = ads.computeVolts(adc3);
   
  // Sortie des valeurs sur l'interface série
  Serial.print ("Entrée analogique 0:"); Serial.print (voltage0); Serial.println (" V");
  Serial.print ("Entrée analogique 1:"); Serial.print (voltage1); Serial.println (" V");
  Serial.print ("Entrée analogique 2:"); Serial.print (voltage2); Serial.println (" V");
  Serial.print ("Entrée analogique 3:"); Serial.print (voltage3); Serial.println (" V");
  Serial.println ("------------------------");
   
  delay (1000);
}

Des valeurs de tension analogiques avec une précision allant jusqu'à 16 bits peuvent être mesurées sur un maximum de 4 entrées via des commandes correspondantes sur le bus I2C. Le résultat de la mesure est codé en sortie sur le bus I2C.

Données techniques

interface	I2C
Canaux ADC	4
Résolution par canal	16 Bit
Fréquence d'échantillonnage programmable	8 à 860 SPS
Tension de fonctionnement	2V à 5.5V
Tension d'entrée analogique	0V à la tension de fonctionnement
Tension logique I2C	0V à 5.5V
Adresse I2C	0x48 à 0x4B
Courant de fonctionnement typique	150μA

**Une bibliothèque correspondante est nécessaire pour ce module - voir les exemples de code ci-dessous.

Changement d'adresse I2C

Ce convertisseur analogique-numérique (ou en abrégé ADC) n'a pas qu'une seule adresse I2C. C'est un ADC qui peut avoir 4 adresses I2C différentes. Celles-ci peuvent être choisies librement, mais dans la suite du cours, l'adresse standard 0x48 est utilisée.

Dans le tableau suivant, vous pouvez voir toutes les adresses possibles et comment elles peuvent être atteintes. Il est principalement à noter que la broche ADDR de l'ADC est responsable du changement d'adresse.

De	A	Adresse
ADDR Pin	GND Pin	0x48
ADDR Pin	VDD Pin	0x49
ADDR Pin	SDA Pin	0x4A
ADDR Pin	SCL Pin	0x4B

Affectation des broches

L'affectation des broches est imprimée sur la carte du module

Exemple de code Raspberry Pi

Affectation des broches Raspberry Pi

Raspberry Pi	Capteur
3,3V	+V
GND	GND
GPIO 2 [Pin 3]	SCL
GPIO 3 [Pin 5]	SDA
-	ADDR
-	ALRT
-	A0
-	A1
-	A2
-	A3

Contrairement à l'Arduino, le Raspberry Pi n'a pas d'entrées analogiques ou il n'y a pas d'ADC (convertisseur analogique numérique) intégré dans la puce du Raspberry Pi. Cela limite le Raspberry Pi si vous voulez utiliser des capteurs dont les valeurs ne sont pas émises numériquement [valeur de tension dépassée -> ON numérique | valeur de tension inférieure -> OFF numérique | exemple : bouton enfoncé [ON] bouton relâché [OFF]], mais dont la valeur doit être variable en continu (exemple : potentiomètre -> différente position = différente valeur de tension).

Pour contourner ce problème, notre kit de capteurs X40 possède un module avec un ADC 16 bits, le KY-053, que vous pouvez utiliser sur le Raspberry pour l'étendre avec 4 entrées analogiques. Il est connecté au Raspberry Pi via I2C, prend en charge la mesure analogique et transmet la valeur numériquement au Raspberry Pi.

Le programme utilise les bibliothèques Python ADS1x15 et I2C correspondantes d'Adafruit pour contrôler l'ADC ADS1115. Ceux-ci ont été publiés au lien suivant https://github.com/adafruit/Adafruit_CircuitPython_ADS1x15 sous la licence MIT. Les bibliothèques requises ne sont pas incluses dans le paquet de téléchargement ci-dessous.

Vous pouvez installer cette bibliothèque avec la commande suivante :

sudo pip3 install adafruit-circuitpython-ads1x15

Pour permettre la communication entre l'ADC et le Raspberry Pi, l'interface I2C du Raspberry Pi doit également être activée. Pour ce faire, ouvrez le fichier config.txt via la commande suivante :

sudo nano /boot/config.txt

Ajoutez la ligne suivante à la fin du fichier :

dtparam = i2c_arm = on

Sauvegardez le fichier avec la combinaison de touches [CTRL+O], confirmez avec [Enter] et quittez l'éditeur avec la combinaison de touches [CTRL+X].

De plus, l'installation des bibliothèques I2C est nécessaire. Installez-les via la commande suivante...

sudo apt-get install python3-smbus i2c-tools -y

...et effectuez ensuite un redémarrage:

sudo reboot

Après cela, l'exemple de code Python suivant peut être utilisé :

sudo nano ADS1115.py

#!/usr/bin/python
# coding=utf-8
 
#############################################################################################################
### Copyright by Joy-IT
### Published under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
### Commercial use only after permission is requested and granted
###
### KY-053 Analog Digital Converter - Raspberry Pi Python Code Example
###
#############################################################################################################
import time
import board
import busio
import adafruit_ads1x15.ads1115 as ADS
from adafruit_ads1x15.analog_in import AnalogIn

i2c = busio.I2C(board.SCL, board.SDA)

ads = ADS.ADS1115(i2c)

chan0 = AnalogIn(ads, ADS.P0)
chan1 = AnalogIn(ads, ADS.P1)
chan2 = AnalogIn(ads, ADS.P2)
chan3 = AnalogIn(ads, ADS.P3)



while True:
    print("channel 0: ","{:>5}\t{:>5.3f}".format(chan0.value, chan0.voltage))
    print("channel 1: ","{:>5}\t{:>5.3f}".format(chan1.value, chan1.voltage))
    print("channel 2: ","{:>5}\t{:>5.3f}".format(chan2.value, chan2.voltage))
    print("channel 3: ","{:>5}\t{:>5.3f}".format(chan3.value, chan3.voltage))
    print("---------------------------------------------------")
    time.sleep(1)

La bibliothèque est également accompagnée d'un exemple de code. Vous pouvez le consulter sur le site web: https://github.com/adafruit/Adafruit_CircuitPython_ADS1x15/tree/main/examples

Le script Python doit être exécuté avec Python 3.

Télécharger le programme type

KY053-RPi.zip

Pour commencer avec la commande

sudo python3 KY053.py

Fonctions avancées du CAN ADS1115

La fonction de l'ADS1115 utilisée dans les exemples de code présentés ci-dessus est appelée "Single Ended Conversion" et indique qu'une mesure est effectuée sur le seul canal sélectionné par rapport à la masse.

En plus de ce type de mesure, l'ADC ADS1115 dispose également, par exemple, de la fonction de mesure différentielle, de sorte qu'une tension différentielle entre deux entrées est mesurée (exemple : tension entre A0 et A1). En plus de la mesure unilatérale, il est possible d'activer la fonction de comparateur, qui ne fournit un résultat de mesure que lorsqu'un seuil de tension est dépassé.

Ces fonctions et d'autres fonctions, comme la modification du taux d'échantillonnage, sont programmées dans les bibliothèques Adafruit pour la configuration - voir la documentation des bibliothèques Adafruit pour plus de détails.

# Chargement des bibliothèques
import machine
import ADS1115
import sys
from time import sleep

# Initialisation des variables
chan = 0

if __name__ == '__main__':
    try:
        # Initialisation de l'ADC
        ADS1115.init(0x48, 2, 4, False)
        print("start")
        while True:
            # Sortie des données du canal 0 de l'ADC
            print(ADS1115.read(chan))
            # Sortie des données lues et converties du canal 0 de l'ADC
            print(str(ADS1115.raw_to_v(ADS1115.read(chan))) + " V")
            sleep(1)

    except KeyboardInterrupt:
        sys.exit()