MCP4725 DAC module, I2C, 12-bit, with EEPROM, HW-315

The MCP4725 module is a digital-to-analog converter with I2C interface that generates a real analog voltage on the OUT pin, starting from a digital value sent from a development board. This tutorial shows how to connect and program the module with an Arduino Uno board, to obtain an adjustable voltage between 0 V and the supply voltage.

How it works:

MCP4725 is a 12-bit DAC, which means it accepts digital values between 0 and 4095. The output voltage is calculated approximately with the formula Vout = code x VCC / 4096, where VCC is the module's supply voltage. At a 5 V supply, code 0 produces approximately 0 V, code 2048 produces approximately 2.5 V, and code 4095 produces approximately 5 V. The module retains the last value written in the internal EEPROM memory, so it can restart with the same output without the microcontroller having sent anything yet after power up.

What you need:

• 1 x MCP4725 I2C DAC Breakout Module
• 1 x Arduino Uno R3 Development Board with Wifi ESP8266, Arduino compatible
• 1 x Mini USB Cable, 30cm
• 1 x 40 Dupont wires 10cm, Female-Female

Connection:

The module is powered directly from the 5 V pin of the Arduino Uno board, and the I2C lines are connected to the dedicated pins A4 and A5.

Arduino Uno operates at 5 V logic, the same level accepted by the module, so no level converter is needed on SDA and SCL. Pins A4 and A5 have internal pull-up automatically enabled by the Wire library, sufficient for a single module on the bus.

Board and libraries:

From Arduino IDE select the Arduino Uno board, available by default in the Arduino AVR Boards package. No additional address is needed in File Preferences for this board. Install from Library Manager the Adafruit MCP4725 library from Adafruit, which also requires the Wire library, already included in Arduino IDE.

Code:

The code initializes the module at I2C address 0x60, sends a few known values in turn and then generates a sine wave cycle on the output.

/*
  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);
  }
}

How the code works:

At the beginning of the program the Wire and Adafruit_MCP4725 libraries are included, the dac object of type Adafruit_MCP4725 is created and the MCP4725_I2C_ADDRESS constant is defined with the value 0x60, the default address of the module with the ADDR pin tied to ground.

In the setup function the serial communication is initialized, the I2C bus is started with Wire.begin, and then dac.begin is called with the module address. If the module does not respond, the error message is displayed on the serial monitor and the program remains stuck in a wait loop.

In the loop function, the steps array contains five representative digital codes between 0 and 4095. For each value, dac.setVoltage sends the code to the module, and the program calculates and displays on the serial monitor the approximate expected voltage at the output, using the formula code x VCC / 4095.

After going through the five values, the code generates a complete sine wave cycle, calculating for each angle between 0 and 360 degrees a normalized value between 0 and 1 with the sin function, which it transforms into a digital code between 0 and 4095 sent to the module with dac.setVoltage.

Result:

Open the serial monitor at 9600 baud. You will see the module initialization confirmation message, then the five digital codes together with the approximate voltage calculated for each, followed by the message announcing the generation of the sine wave cycle. If you measure the OUT and GND pins with a multimeter during each one-second pause, you will read a voltage close to that displayed on the 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

Common issues:

If the serial monitor displays a message that the module was not found, check that SDA and SCL are not reversed with each other and that the module ground is connected to the Arduino board ground.

If the voltage measured on OUT is always 0 V, check if the module is powered correctly on VCC and if you have written a value different from 0 in the code to the setVoltage function.

If the module does not respond at I2C address 0x60, check the ADDR jumper, because an accidental bridge to VCC moves the module address to 0x61.

If the values read on OUT seem unstable or noisy, check that the wires used for power and I2C are short and well secured, and the module is not powered simultaneously from two different sources.

If you use two MCP4725 modules on the same bus and one of them does not respond correctly, check that you have disabled the pull-up resistors on all modules except one.

Limitations and tips:

The module's output voltage is limited between 0 V and the supply voltage VCC, it cannot generate negative voltages or voltages greater than the supply. The 12-bit resolution offers steps of approximately 1.2 mV at a 5 V supply, sufficient for most control and signal generation applications, but insufficient for very high precision measurements. The output update speed is limited by the I2C bus speed and the 6 us settling time of the converter, which makes the module suitable for slow signals or control, not for high-frequency audio signals. Starting from this setup, you can build a signal generator with various waveforms, an adjustable reference voltage source for other circuits, or an analog control loop for an amplifier or motor driver.