Modulo DAC MCP4725, I2C, 12 bit, con EEPROM, HW-315

Il modulo MCP4725 è un convertitore digitale-analogico con interfaccia I2C, che genera una tensione analogica reale sul pin OUT, partendo da un valore digitale inviato da una scheda di sviluppo. Questo tutorial mostra come collegare e programmare il modulo con una scheda Arduino Uno, per ottenere una tensione regolabile tra 0 V e la tensione di alimentazione.

Come funziona:

MCP4725 è un DAC con risoluzione di 12 bit, il che significa che accetta valori digitali tra 0 e 4095. La tensione di uscita si calcola approssimativamente con la formula Vout = codice x VCC / 4096, dove VCC è la tensione di alimentazione del modulo. Con un'alimentazione di 5 V, il codice 0 produce circa 0 V, il codice 2048 produce circa 2,5 V, mentre il codice 4095 produce circa 5 V. Il modulo mantiene l'ultimo valore scritto nella memoria EEPROM interna, così può riavviarsi con la stessa uscita anche senza che il microcontrollore abbia trasmesso ancora nulla dopo l'alimentazione.

Di cosa hai bisogno:

• 1 x MCP4725 I2C DAC Breakout Module
• 1 x Scheda di sviluppo Uno R3 con Wifi ESP8266, compatibile Arduino
• 1 x Cavo MiniUSB, 30 cm
• 1 x 40 fili Dupont 10 cm, Femmina-Femmina

Collegamento:

Il modulo si alimenta direttamente dal pin da 5 V della scheda Arduino Uno, mentre le linee I2C si collegano ai pin dedicati A4 e A5.

Arduino Uno funziona a 5 V logici, lo stesso livello accettato dal modulo, quindi non è necessario un convertitore di livello su SDA e SCL. I pin A4 e A5 hanno pull-up interno attivato automaticamente dalla libreria Wire, sufficiente per un singolo modulo sul bus.

Scheda e librerie:

Da Arduino IDE selezionate la scheda Arduino Uno, disponibile implicitamente nel pacchetto Arduino AVR Boards. Non è necessario nessun indirizzo aggiuntivo in File Preferences per questa scheda. Installate da Library Manager la libreria Adafruit MCP4725 da Adafruit, che ha bisogno anche della libreria Wire, già inclusa in Arduino IDE.

Il codice:

Il codice inizializza il modulo all'indirizzo I2C 0x60, invia in sequenza alcuni valori noti e poi genera un ciclo di onda sinusoidale sull'uscita.

/*
  Board: Arduino Uno (Arduino AVR Boards package)
  Library: Adafruit MCP4725 by Adafruit (requires Wire, included with Arduino IDE)
  Wiring:
    Arduino 5V  -> MCP4725 VCC
    Arduino GND -> MCP4725 GND
    Arduino A4 (SDA) -> MCP4725 SDA
    Arduino A5 (SCL) -> MCP4725 SCL
*/
#include <Wire.h>
#include <Adafruit_MCP4725.h>
Adafruit_MCP4725 dac;
const uint8_t MCP4725_I2C_ADDRESS = 0x60; // default address, ADDR pad tied to GND
const float VCC = 5.0; // Arduino 5V rail used as the DAC reference
void setup() {
  Serial.begin(9600);
  while (!Serial) {
    // wait for the serial port on boards that need it
  }
  Wire.begin(); // join the I2C bus as master on A4 (SDA) and A5 (SCL)
  if (!dac.begin(MCP4725_I2C_ADDRESS)) {
    Serial.println("MCP4725 not found, check wiring and I2C address");
    while (1) {
      // halt here, nothing useful can be done without the DAC
    }
  }
  Serial.println("MCP4725 ready");
}
void loop() {
  // Step through a few known DAC codes and print the expected output voltage
  uint16_t steps[] = {0, 1024, 2048, 3072, 4095};
  for (uint8_t i = 0; i < 5; i++) {
    uint16_t code = steps[i];
    dac.setVoltage(code, false); // write the code to the DAC register only, not to EEPROM
    float voltage = code * VCC / 4095.0;
    Serial.print("DAC code: ");
    Serial.print(code);
    Serial.print(" -> approx output: ");
    Serial.print(voltage, 2);
    Serial.println(" V");
    delay(1000);
  }
  // Generate one slow sine wave cycle to show a continuously changing analog output
  Serial.println("Generating sine wave cycle...");
  for (uint16_t angleDeg = 0; angleDeg < 360; angleDeg += 5) {
    float angleRad = angleDeg * PI / 180.0;
    float normalized = (sin(angleRad) + 1.0) * 0.5; // normalize sine to 0..1
    uint16_t code = (uint16_t)(normalized * 4095);
    dac.setVoltage(code, false);
    delay(20);
  }
}

Come funziona il codice:

All'inizio del programma sono incluse le librerie Wire e Adafruit_MCP4725, è creato l'oggetto dac di tipo Adafruit_MCP4725 ed è definita la costante MCP4725_I2C_ADDRESS con il valore 0x60, indirizzo predefinito del modulo con il pin ADDR legato a massa.

Nella funzione setup viene inizializzata la comunicazione seriale, viene avviato il bus I2C con Wire.begin, quindi viene chiamato dac.begin con l'indirizzo del modulo. Se il modulo non risponde, il messaggio di errore è visualizzato sul monitor seriale e il programma rimane bloccato in un ciclo di attesa.

Nella funzione loop, il vettore steps contiene cinque codici digitali rappresentativi tra 0 e 4095. Per ogni valore, dac.setVoltage invia il codice al modulo, mentre il programma calcola e visualizza sul monitor seriale la tensione approssimativa attesa all'uscita, usando la formula codice x VCC / 4095.

Dopo aver esaminato i cinque valori, il codice genera un ciclo completo di onda sinusoidale, calcolando per ogni angolo tra 0 e 360 gradi un valore normalizzato tra 0 e 1 con la funzione sin, che trasforma in un codice digitale tra 0 e 4095 inviato al modulo con dac.setVoltage.

Risultato:

Aprite il monitor seriale a 9600 baud. Vedrete il messaggio di conferma dell'inizializzazione del modulo, quindi i cinque codici digitali insieme alla tensione approssimativa calcolata per ciascuno, seguiti dal messaggio che annuncia la generazione del ciclo di onda sinusoidale. Se misurate i pin OUT e GND con un multimetro durante ogni pausa di un secondo, leggerete una tensione vicina a quella visualizzata sul monitor.

MCP4725 ready
DAC code: 0 -> approx output: 0.00 V
DAC code: 1024 -> approx output: 1.25 V
DAC code: 2048 -> approx output: 2.50 V
DAC code: 3072 -> approx output: 3.75 V
DAC code: 4095 -> approx output: 5.00 V
Generating sine wave cycle...
DAC code: 0 -> approx output: 0.00 V
DAC code: 1024 -> approx output: 1.25 V
DAC code: 2048 -> approx output: 2.50 V
DAC code: 3072 -> approx output: 3.75 V
DAC code: 4095 -> approx output: 5.00 V

Problemi frequenti:

Se il monitor seriale visualizza il messaggio che il modulo non è stato trovato, verificate che SDA e SCL non siano invertiti tra loro e che la massa del modulo sia collegata alla massa della scheda Arduino.

Se la tensione misurata su OUT è sempre 0 V, verificate se il modulo è alimentato correttamente su VCC e se avete scritto nel codice un valore diverso da 0 verso la funzione setVoltage.

Se il modulo non risponde all'indirizzo I2C 0x60, verificate il jumper ADDR, perché un ponte accidentale verso VCC sposta l'indirizzo del modulo a 0x61.

Se i valori letti su OUT sembrano instabili o rumorosi, verificate che i fili utilizzati per l'alimentazione e per l'I2C siano corti e ben fissi, e che il modulo non sia alimentato contemporaneamente da due sorgenti diverse.

Se utilizzate due moduli MCP4725 sullo stesso bus e uno di loro non risponde correttamente, verificate che abbiate disattivato le resistenze di pull-up su tutti i moduli tranne uno.

Limitazioni e suggerimenti:

La tensione di uscita del modulo è limitata tra 0 V e la tensione di alimentazione VCC, non può generare tensioni negative o superiori all'alimentazione. La risoluzione di 12 bit offre passi di circa 1,2 mV a un'alimentazione di 5 V, sufficienti per la maggior parte delle applicazioni di controllo e generazione di segnale, ma insufficienti per misurazioni di precisione molto elevata. La velocità di aggiornamento dell'uscita è limitata dalla velocità del bus I2C e dal tempo di stabilizzazione di 6 us del convertitore, il che rende il modulo adatto per segnali lenti o di controllo, non per segnali audio ad alta frequenza. Partendo da questo circuito, potete costruire un generatore di segnale con forme d'onda variate, una sorgente di tensione di riferimento regolabile per altri circuiti o un anello di controllo analogico per un amplificatore o un driver di motore.