Comment utiliser module convertisseur MCP4725 avec Arduino

Introduction

Les modules convertisseurs numérique-analogique (CNA) sont des composants essentiels pour les projets électroniques impliquant la génération de signaux analogiques. Dans cet article, nous allons explorer comment utiliser le module convertisseur MCP4725 avec Arduino pour générer une onde sinusoïdale de manière précise et contrôlée. Nous aborderons en détail le matériel nécessaire, les connexions, le code Arduino, et nous analyserons les résultats obtenus.

Matériel Requis

Avant de commencer, assurez-vous de disposer du matériel suivant :

• Arduino Nano (ou toute autre carte Arduino compatible)
• Module convertisseur MCP4725
• Oscilloscope portable
• Alimentations USB portables (pour alimenter l’Arduino et le MCP4725)

Présentation du convertisseur MCP4725

Le MCP4725 est un CNA 12 bits qui peut être contrôlé via une interface I2C. Il offre une résolution de 12 bits, ce qui signifie qu’il peut générer des valeurs analogiques comprises entre 0V et la tension de référence (généralement 5V) avec une précision de 1/4096 de la tension de référence par pas. Ce module est idéal pour générer des signaux analogiques, tels que des signaux sinusoïdaux, des rampes, etc.

Connexion du convertisseur MCP4725 à l’Arduino

La première étape consiste à connecter le module MCP4725 à l’Arduino. Voici les connexions requises :

• Broche SDA du MCP4725 à la broche A4 de l’Arduino
• Broche SCL du MCP4725 à la broche A5 de l’Arduino
• Broche VCC du MCP4725 à 5V de l’Arduino
• Broche GND du MCP4725 à la masse de l’Arduino (GND)
• Broche VOUT du MCP4725 au point du circuit où vous souhaitez générer le signal analogique (par exemple, la broche A0 de l’Arduino) , dans ce schéma on veut visualiser VOUT analogique à partir de l’oscilloscope.

Code Arduino pour Générer une Onde Sinusoïdale

Pour générer une onde sinusoïdale, nous allons créer un tableau d’échantillons représentant une période de la sinusoïde. Ensuite, nous utiliserons le convertisseur MCP4725 pour convertir ces échantillons en signaux analogiques. Voici un exemple de code pour générer une onde sinusoïdale :

#include <Wire.h>

// Constantes
const int adresseI2CduMCP4725             =   0x60;
const int nombreDePasDuSignalSinusoidal   =   120; 
// Variables
int ondeSinusoidale[nombreDePasDuSignalSinusoidal];       // Tableau qui contiendra toutes les valeurs représentant une onde sinusoïdale complète
int pointeurTableauOndeSinusoidal;                        // Pointeur qui permettra de parcourir ce tableau, pas à pas
int echantillonOndeSinusoidale;                           // Contiendra une fraction de l'onde sinusoïdale (un "pas")

// ========================
// Initialisation programme
// ========================
void setup() {

  // Initialise la liaison série (Arduino Nano -> PC)
  Serial.begin(9600);
  Serial.println(F("==============================================================================="));
  Serial.println(F("PRG3 - Génération d'une onde sinusoïdale en sortie du MCP4725 (amplitude 0->5V)"));
  Serial.println(F("==============================================================================="));
  Serial.println("");

  // Initialise la liaison I2C (Arduino Nano -> MCP4725)
  Wire.begin();
  Wire.setClock(400000);       
  // Remplissage de la table "ondeSinusoidale", représentant une onde sinusoïdale complète, d'amplitude 0 à 4095, décomposée en un nombre de pas défini
  for (int pointeurTableauOndeSinusoidal = 0 ; pointeurTableauOndeSinusoidal < nombreDePasDuSignalSinusoidal ; pointeurTableauOndeSinusoidal++) {
    // Pour cela, on va utiliser la fonction sin(), qui prend en argument une valeur exprimée en radian (et pour rappel : 1 "tour complet" = 2*Pi radians)
    ondeSinusoidale[pointeurTableauOndeSinusoidal] = 2047 + round(2047 * sin(2 * PI * pointeurTableauOndeSinusoidal / (nombreDePasDuSignalSinusoidal-1)));
    // Nota 1 : variera entre 0 et 4094 (en fait : initialement de -2047 à 2047, mais décalé vers le haut de 2047 pts, pour travailler en tension positive)
    // Nota 2 : ce valeur se chiffre donc sur 12 bits (que l'on devra scinder en 2 parties plus tard, pour la transmission I2C)
  }
}

// =================
// Boucle principale
// =================
void loop() {

  // ******************************************************************************************************
  // Parcours du tableau représentant une onde sinusoïdale complète, divisée en un certain nbre de morceaux
  // ******************************************************************************************************
  for(pointeurTableauOndeSinusoidal = 0 ; pointeurTableauOndeSinusoidal < nombreDePasDuSignalSinusoidal ; pointeurTableauOndeSinusoidal++) {
 
    // Lit un échantillon de cette onde
    echantillonOndeSinusoidale = ondeSinusoidale[pointeurTableauOndeSinusoidal];
    
    // Initie la communication avec le MCP4725
    Wire.beginTransmission(adresseI2CduMCP4725);
 
    // Envoi d'une commande en "Fast Mode Write" (C2=0 et C1=0), et en "Normal Mode" (PD1=0 et PD0=0) au niveau des power-down bits, sur 2 octets
    // Remarque : quand on parle de "Fast Mode" ici, il s'agit en fait du nom d'opération spécifiée par le fabricant du MCP4725,
    // et non du "Fast Mode" I2C, qui concerne la vitesse de communication sur le bus i2c de l'arduino. C'est subtil, certes, mais pas du tout la même chose !

    // ============================================
    // Premier octet à envoyer
    // ============================================
    // Numéros de bit     |  7  |  6  |  5  |  4  |  3  |  2  |  1  |  0
    // Désignation du bit |  C2 |  C1 | PD1 | PD0 | D11 | D10 |  D9 |  D8
    // Valeur des bits    |  0  |  0  |  0  |  0  |  x  |  x  |  x  |  x    (les "x" étant à remplacer à la volée, par les 4 bits de poids fort de la valeur à envoyer
    // ============================================
    // En résumé : les 4 premiers bits vaudront "0000", et les 4 suivants seront les 4 premiers bits de la valeur 12 bits à envoyer (d'où le décalage de 12-4 = 8 bits)
    Wire.write((0b0000 << 4) | ((echantillonOndeSinusoidale & 0b111100000000) >> 8));

    // ============================================
    // Deuxième octet à envoyer
    // ============================================
    // Numéros de bit     |  7  |  6  |  5  |  4  |  3  |  2  |  1  |  0
    // Désignation du bit |  D7 |  D6 |  D5 |  D4 |  D3 |  D2 |  D1 |  D0
    // Valeur des bits    |  x  |  x  |  x  |  x  |  x  |  x  |  x  |  x    (les "x" étant à remplacer à la volée, par les 8 bits de poids faible de la valeur à envoyer
    // ============================================
    // En résumé : ces 8 bits correspondent aux 8 derniers bits de la valeur 12 bits à envoyer
    Wire.write(echantillonOndeSinusoidale & 0b000011111111);

    // Stoppe cet envoi à destination du MCP4725, concernant cet échantillon d'onde sinusoïdale
    Wire.endTransmission();

    // PAS DE PAUSE ICI. En fait, on boucle directement à la valeur suivante. Cela nous permettra de voir quelle fréquence on pourra atteindre
    // avec cet arduino, sachant que notre sinusoïde a été divisée en un certain nombre de pas (qu'on pourra réduire pour aller plus vite,
    // mais en dégradant la qualité du signal de sortie au passage).
    
  }
}

Amélioration de la Précision

Pour améliorer la précision de la génération du signal sinusoïdal, vous pouvez ajuster le tableau d’échantillons en fonction des caractéristiques de votre MCP4725 et de vos besoins spécifiques. Vous pouvez également ajuster la fréquence du signal en modifiant la durée de la pause entre chaque envoi d’échantillon. Plus la pause est courte, plus la fréquence du signal sera élevée, mais cela peut affecter la qualité du signal généré.

Contrôle de l’Amplitude

Le convertisseur MCP4725 offre la possibilité de contrôler l’amplitude du signal généré en ajustant la tension de référence (Vcc). Vous pouvez utiliser un diviseur de tension externe ou un potentiomètre pour régler la tension de référence du MCP4725 et ainsi contrôler l’amplitude du signal de sortie.

Application Pratique : Générateur de Signaux

En utilisant le convertisseur MCP4725 avec Arduino, vous pouvez créer un générateur de signaux simple et polyvalent. En combinant différentes formes d’ondes (sinusoïdales, carrées, triangulaires, etc.) et en ajustant leur fréquence et leur amplitude, vous pouvez générer des signaux adaptés à vos besoins. Cela peut être utile dans de nombreux projets, tels que la génération de signaux de test pour des circuits électroniques, le contrôle de moteurs et bien plus encore.

Nouveaux Horizons : Intégration à des Projets Plus Complexes

En utilisant le convertisseur MCP4725 avec Arduino, vous pouvez également l’intégrer dans des projets plus complexes impliquant la génération de signaux analogiques pour contrôler des circuits, des capteurs ou des actionneurs. Par exemple, vous pourriez utiliser le signal généré pour contrôler la vitesse d’un moteur, ajuster l’intensité lumineuse d’une LED, ou réguler la température d’un système de chauffage.

Conclusion

Le module convertisseur MCP4725 est un outil puissant pour générer des signaux analogiques avec précision et flexibilité à l’aide d’Arduino. Dans cet article, nous avons exploré comment utiliser ce module pour générer une onde sinusoïdale, mais les possibilités sont infinies. Vous pouvez l’utiliser pour créer des signaux adaptés à vos besoins spécifiques dans une variété de projets électroniques. N’hésitez pas à expérimenter avec différentes formes d’ondes, fréquences et amplitudes pour explorer les nombreuses possibilités qu’offre ce module. Amusez-vous à créer vos propres générateurs de signaux personnalisés et découvrez de nouvelles façons d’utiliser le convertisseur MCP4725 dans vos projets futurs. Bonnes expérimentations !

Pour plus d’articles : https://www.moussasoft.com/tutoriels-electroniques

Twitter: Moussa Lhoussaine (@Moussasoft_com) / Twitter

Arduino – Home