Aumentar la precisión de salida de un DAC mediante el método de calibración de dos puntos

Calibración de dos puntos para salidas DAC

Corrige el desfase estático y el error de ganancia para que el voltaje configurado de tu DAC sea el voltaje que realmente entrega

La curva de voltaje (o corriente) de salida de un convertidor digital-analógico es lineal en teoría, pero el hardware real no es ideal y siempre presenta errores, por lo que la salida del DAC no será perfecta. Existen diversos factores que contribuyen a los errores en un circuito DAC y abordarlos todos está fuera del alcance de este tutorial, pero el objetivo de la calibración de dos puntos es ayudar a eliminar los errores de desfase estático y de ganancia. Estos errores son desviaciones de la curva de salida lineal ideal del DAC. Una sencilla calibración de dos puntos mide la línea real de tu DAC y luego utiliza su inversa para calcular el código que produce el voltaje solicitado. La recompensa es considerable: tras la calibración de dos puntos, el error estará dominado por la linealidad residual y la deriva térmica en lugar del desfase o la ganancia estática.

Qué corrige la calibración de dos puntos

La transferencia ideal es una línea recta. Los dispositivos reales pueden estar desplazados (desfase) e inclinados (ganancia). El gráfico siguiente muestra:

  • La línea ideal (continua).
  • La escalera de cuantificación de un DAC de 4 bits, con escalones alineados con la curva ideal (comportamiento de peldaño medio).
  • Ejemplos de error de desfase y error de ganancia (exagerados para mayor claridad).

El objetivo del enfoque de calibración de dos puntos es medir la curva de error de desfase y ganancia para poder corregir los valores de salida en el firmware y que coincidan con la curva ideal del DAC.

Paso a paso: calibración de dos puntos rápida y precisa

1) Calentamiento y estabilización

  • Alimenta tu diseño DAC y déjalo estabilizarse térmicamente (normalmente de 5 a 10 minutos).
  • Para las líneas de alimentación, comunicación y medición de salida conectadas al diseño DAC, mantén el cableado lo más corto posible. Si es posible, utiliza cable blindado para medir el voltaje de salida del DAC
  • Intenta utilizar una fuente de alimentación de bajo ruido (basada en un regulador lineal) para alimentar tu diseño DAC y reducir el ruido del circuito 

2) Elige tus dos códigos de calibración

Elige dos puntos de configuración de salida bien dentro del rango del DAC para evitar artefactos en los extremos.

  • Unipolar (0…FS): utiliza los códigos 10 % FS y 90 % FS.
  • Bipolar (±FS, binario con desfase): elige puntos simétricos respecto del código medio (p. ej., medio − 40 % FS y medio + 40 % FS).

Ejemplo (14 bits): FS = 16383, medio = 8192.
Unipolar: C1≈1638, C2≈14745.
Bipolar: C1≈8192−6554, C2≈8192+6554.

3) Mide cuidadosamente en cada punto

  1. Programa la salida del DAC en el punto C1.
  2. Espera a que se estabilice: al menos 10–20 veces el tiempo de estabilización de la salida del circuito DAC
  3. Promedia varias lecturas de tu DMM, voltímetro o un ADC de alta precisión: de 64 a 256 muestras es un buen comienzo.
    1. Nota: si utilizas un circuito ADC para la medición de calibración, asegúrate de que sus especificaciones de precisión sean al menos 4 veces mejores que las del circuito DAC que estás calibrando
  4. Registra (C1, V1), donde V1 es el promedio medido en voltios.
  5. Repite para (C2, V2).

Consejos para promedios precisos

  • Descarta las primeras muestras después de cada cambio de código.
  • Si dos mediciones repetidas difieren en más de unos pocos LSB, aumenta el tiempo de estabilización o el número de muestras.

4) Calcula la línea real de tu DAC

Esto utiliza un conjunto bien conocido de ecuaciones que permiten calcular líneas rectas o lineales, puntos y pendientes en un espacio bidimensional. En concreto, la fórmula de la pendiente y la intersección de la pendiente. Sigue el enlace de abajo para obtener más información sobre estas fórmulas matemáticas.

Para obtener más información sobre estas fórmulas, consulta esta página de Wikipedia

Modela el comportamiento medido como:

a = (V2 - V1) / (C2 - C1)
b = V1 - a * C1

donde: a = pendiente (voltios por código) y b = desfase (voltios)

5) Utiliza la inversa para comandar voltajes

Dado un voltaje solicitado VreqV_\text{req}, calcula el código de comando:

C_cmd = round( (V_req - b) / a )

donde: V_req = el voltaje que quieres que el DAC entregue y C_cmd = el código calibrado para enviar al DAC

Asegúrate de que el resultado esté limitado al rango de códigos permitido (0…FS para unipolar; 0…FS para binario con desfase/bipolar).

6) Guarda y reutiliza

Almacena aa y bb (o, en su defecto, ganancia y desfase) en la EEPROM/memoria flash para poder aplicar la corrección en cada arranque. Vuelve a ejecutar la calibración rápida si el entorno cambia significativamente.


Ejemplo de código para Arduino (listo para usar)

Este boceto muestra cómo:

  • definir dos códigos de calibración,
  • pegar tus dos voltajes medidos,
  • calcular aa y bb, y
  • mapear cualquier voltaje de salida solicitado a un código DAC calibrado.
// SPDX-License-Identifier: MIT
#include <Arduino.h>
#include <stdint.h>
#include <math.h>

// ====== Configuraciones del usuario ======
#define DAC_BITS     14      // p. ej., 12, 14, 16
#define DAC_BIPOLAR  0       // 0=unipolar 0..FS, 1=bipolar ±FS (códigos binarios con desfase)

// Elige dos códigos bien dentro del rango:
#if DAC_BIPOLAR
  static const uint32_t FS   = (1UL << DAC_BITS) - 1UL;
  static const uint32_t MID  = (1UL << (DAC_BITS - 1));
  static const uint32_t C1   = MID - (uint32_t)(0.40f * (float)FS);
  static const uint32_t C2   = MID + (uint32_t)(0.40f * (float)FS);
#else
  static const uint32_t FS   = (1UL << DAC_BITS) - 1UL;
  static const uint32_t C1   = (uint32_t)(0.10f * (float)FS);  // ~10 % FS
  static const uint32_t C2   = (uint32_t)(0.90f * (float)FS);  // ~90 % FS
#endif

// Pega tus voltajes medidos (promediados) para esos códigos:
float V1_meas = 1.234f;   // voltios medidos en el código C1
float V2_meas = 3.210f;   // voltios medidos en el código C2

// ====== Estado de calibración ======
static float a_slope = 1.0f; // voltios por código
static float b_offs  = 0.0f; // voltios

// Calcula a y b a partir de las dos mediciones
void computeCalibration() {
  a_slope = (V2_meas - V1_meas) / (float)((int32_t)C2 - (int32_t)C1);
  b_offs  = V1_meas - a_slope * (float)C1;
}

// Convierte el voltaje solicitado a un código DAC *calibrado*
uint32_t dacVoltageToCodeCal(float vreq) {
  float c = (vreq - b_offs) / a_slope;           // inversa de V = a*C + b
  if (c < 0.0f) c = 0.0f;
  float cmax = (float)FS;
  if (c > cmax) c = cmax;
  return (uint32_t)lroundf(c);
}

// Ejemplo de promedio de N lecturas de una función ADC `readVoltsOnce()`
// (Sustituye readVoltsOnce() por tu medidor/ADC.)
float averageVolts(size_t N) {
  float sum = 0.0f;
  const size_t throwaway = min<size_t>(N/8, 8);  // descarta las primeras muestras
  for (size_t i=0; i<throwaway; ++i) { /* readVoltsOnce(); */ }
  for (size_t i=0; i<N; ++i) {
    // sum += readVoltsOnce();
  }
  return sum / (float)N;
}

void setup() {
  Serial.begin(115200);
  delay(50);

  // 1) Programa C1 en tu DAC aquí, espera a que se estabilice, mide y establece V1_meas.
  // 2) Programa C2, espera, mide y establece V2_meas.
  // Para este ejemplo de blog asumimos que V1_meas/V2_meas se han pegado arriba.

  computeCalibration();
  Serial.print("Pendiente calibrada (V/código): "); Serial.println(a_slope, 9);
  Serial.print("Desfase calibrado (V):     "); Serial.println(b_offs, 6);

  // Solicita un voltaje y obtén el código calibrado:
  float vreq = 2.500f;
  uint32_t code = dacVoltageToCodeCal(vreq);
  Serial.print("Solicita "); Serial.print(vreq, 3);
  Serial.print(" V -> código DAC "); Serial.println(code);

  // TODO: escribe 'code' en tu DAC vía SPI/I2C aquí.
}

void loop() {
  // Nada aquí — las constantes de calibración están listas para usarse
}

Preguntas frecuentes y consejos profesionales

  • ¿Unipolar o bipolar?
    El método es idéntico. Para dispositivos bipolares (binario con desfase), simplemente elige códigos simétricos respecto del código medio. Las matemáticas utilizan los códigos en bruto, por lo que no necesitas un manejo especial.
  • ¿Cuántas muestras debo promediar?
    Comienza con 128 y comprueba la desviación estándar; auméntala hasta que la media se estabilice dentro de una fracción de un LSB.
  • ¿Esto corregirá la no linealidad?
    No — dos puntos corrigen solo el desfase y la ganancia. Si la no linealidad integral predomina, utiliza una LUT multipunto.
  • ¿Necesito recalibrar?
    Si la temperatura o los cambios en la alimentación/referencia afectan a tu especificación, almacena a,ba,b por unidad y vuelve a ejecutar una calibración rápida de 2 puntos en la instalación o después de grandes cambios de temperatura.

En resumen: Dos mediciones, un poco de matemáticas y cada voltaje que comandes llega donde lo esperas — a pesar del desfase y el error de ganancia del mundo real. 

Regresar al blog