Controlar la carga electrónica con MOSFET con un ESP32 – Básicos

Vamos añadir a la carga electrónica con MOSFET, que construimos en un artículo anterior, un control básico mediante un microcontrolador ESP32.

De esta forma vamos a poder pasar al siguiente nivel y podremos pensar en hacer montones de cosas y proyectos más avanzados con el ESP32.

Como te imaginarás, y si no te lo imaginas ya estoy yo aquí para decírtelo, este artículo está escrito utilizando el ESP32, pero nada te impide utilizar un ESP8266, un Arduino u otro microcontrolador, como los nRF52840 o nRF69936 de Nordic Semiconductor.

¡ESTO ES SOLO EL PRIMER PASO! En el próximo artículo verás como, basándonos en lo que aquí veremos, vamos a construir un instrumento que nos permita hacer montones de pruebas, medidas y caracterizaciones.

Podrás de una forma casi automática, saber cuáles son las características de un panel solar, una batería o un alimentador. Todo desde un navegador web, con gráficas y automatizaciones.

Te recomiendo que, si aún no lo has hecho, leas primero el artículo sobre la carga electrónica con MOSFET básica, porque lo que aquí veremos se basa en él:

¿Cómo preparar la carga para controlarla mediante ESP32?

Básicamente, tenemos que pensar en controlarla con un voltaje externo (que vendrá del ESP32) en vez de controlarla mediante el voltaje que sale del divisor de tensión (el potenciómetro).

Para eso, lo primero que tenemos que hacer, si ya la teníamos construida con el potenciómetro montado, es modificar ligeramente la carga electrónica para conectarla al ESP32.

Si recuerdas, esa carga electrónica se controlaba mediante una tensión que salía de un divisor de tensión hecho con un simple potenciómetro.

Te recuerdo el esquema para explicártelo mejor:

Del terminal intermedio del potenciómetro R2 salía un voltaje que regulábamos, entre 0 y 5V según dónde ajustásemos el potenciómetro y lo metíamos en el comparador positivo (terminal «+«) del OpAmp (amplificador operacional).

Lo que vamos a hacer es generar esa tensión con un ESP32 e inyectarla directamente en el comparador positivo (terminal «+«) del OpAmp.

Lo único que necesitamos para conseguirlo es interrumpir la conexión entre el terminal intermedio del potenciómetro y el OpAmp y conectar la salida de voltaje del ESP32 directamente a la entrada «+» del OpAmp.

Para eso vamos a incluir en la placa de la carga electrónica un conector de dos pines, para el voltaje y GND (los dos cables que vendrán del ESP32).

Modificación de la carga electrónica para controlarla mediante un voltaje externo

Te presento el «método UNO, DOS«. ¡Como en el gimnasio!

Repite conmigo:

1. Corto la conexión central del potenciómetro
2. Conecto el ESP32

Sencillo, ¿verdad?

El único matiz es que en vez de conectar el ESP32 directamente, voy a poner un conector para que sea más sencillo hacer pruebas y modificaciones (si quieres, puedes conectarlo directamente).

Cómo una imagen vale más que 1000 palabras y ya llevo muchas palabras, te dejo dos imágenes (para que valgan más que 2000 palabras):

Como ves, he añadido un conector blanco de 2 pines.

El pin de la derecha (el más cercano al borde de la placa) será para conectarlo a GND del ESP32.

El pin de la izquierda (el que está delante del terminal central del potenciómetro) será para inyectar el voltaje generado por el ESP32.

Solo tienes que cortar o retirar la conexión del terminal central del potenciómetro con el pin 2 del circuito integrado LM358 (marcado en rojo).

El conector blanco de dos pines lo tienes que conectar a GND (negativo) y el pin 2 del circuito integrado LM358 (marcado en amarillo).

¡Ya está! ¡Modificado!

Una aclaración: no he quitado el potenciómetro porque pienso que quizá quiera hacer alguna prueba con él en el futuro, por lo que me he limitado a desconectar su salida (el terminal central).

Si no tienes intención de volver a utilizarlo, puedes retirarlo directamente. Incluso, puedes optar por no colocarlo en absoluto, especialmente si estás ensamblando la carga para que sea controlada por un ESP32 y no tienes pensado realizar otros experimentos sin él.

¿Cómo generamos el voltaje con el ESP32?

Tenemos, básicamente, cuatro opciones para generar el voltaje necesario con nuestro ESP32.

1. Generación de voltaje con un DAC (Conversor Digital Analógico) interno del ESP32.
2. Generación de voltaje con una señal PWM.
3. Utilizar un DAC (Conversor Digital Analógico) externo.
4. Generación de voltaje mediante modulación delta-sigma.

En mi blog, encontrarás un artículo en el que comparo los distintos sistemas de generación de voltaje. Te recomiendo que le des un vistazo, ya que te será de gran ayuda para determinar cuál es la opción más adecuada para tus necesidades.

En mi caso voy a generar la tensión con un DAC externo, el MCP4725.

Te recomiendo que sigas mi consejo y, salvo que construyas la carga solo para hacer algunas pruebas, sin más pretensiones, utilices el MCP4725.

Añadiendo un MCP4725, por un par de euros, tendrás una forma fácil de generar una tensión continua con una precisión más que suficiente para la aplicación que vamos a darle.

Refrigeración del MOSFET

Dependiendo de la intensidad a la que te interese ajustar la carga y del tiempo que la vayas a tener funcionando, necesitarás un disipador más o menos grande (o incluso ninguno, para corrientes pequeñas durante periodos breves).

Para poder hacer pruebas con mayor comodidad y con más intensidad de corriente, he decidido poner un disipador al MOSFET.

He puesto este disipador mediano porque es el que tenía. Está recuperado de una vieja fuente de alimentación de PC Corsair GS700 por lo que no tengo datos técnicos.

Te puedo decir una cosa: el disipador debe estar haciendo su trabajo muy bien porque durante las pruebas he quemado algún cablecillo de los que estoy utilizando mientras que el MOSFET seguía a una buena temperatura de unos 60ºC en ese momento.

¿Recuerdas que te he dicho que prestes atención a la sección de los cables? Pues te sugiero que hagas lo que yo diga y no lo que yo haga. 😜

Pruebas usando el DAC del ESP32

Para hacer las pruebas con el DAC del ESP32 he utilizado este pequeño programa que me permitía cambiar fácilmente el voltaje de salida a través del puerto serie (escribiendo directamente el voltaje en el terminal).

Esta fotografía es del setup que he utilizado para estas pruebas:

#include <Arduino.h>

const int dacPin = 25;
const float referenceVoltage = 3.3;
const float maxVoltage = 3.3;
float targetVoltage = 0;

void setup() {
  Serial.begin(115200);
  pinMode(dacPin, OUTPUT); // Set the pin as OUTPUT
  digitalWrite(dacPin, LOW); // Disable the pullup resistor
  dacWrite(dacPin, 0);
}

void loop() {
  // Leer el valor de targetVoltage desde el puerto serie cuando se presiona Enter
  if (Serial.available() > 0) {
    String input = Serial.readStringUntil('\n'); // Lee la entrada hasta que se presiona Enter
    if (input.length() > 0) {
      targetVoltage = input.toFloat();

      // Restringe el valor máximo de targetVoltage a la referencia
      targetVoltage = constrain(targetVoltage, 0, maxVoltage);

      Serial.print("Nuevo targetVoltage: ");
      Serial.println(targetVoltage);
    }
  }

  int dacWriteValue = (targetVoltage / referenceVoltage) * 255;
  Serial.print("dacWriteValue: ");
  Serial.println(dacWriteValue);

  dacWriteValue = constrain(dacWriteValue, 0, 255);
  dacWrite(dacPin, dacWriteValue);
  delay(1000);
}

Aunque no voy a poder utilizar esta solución para este proyecto (por el problema que ya me esperaba, el offset del DAC, que impide que baje hasta 0V), el experimento ha funcionado muy bien. Quizá sea interesante para otros proyectos donde no necesite bajar hasta 0V.

Por lo demás, escribía el voltaje que quería en el teclado del PC, pulsaba [Enter] y a la salida tenía el voltaje solicitado (más el offset y los errores de linealidad del DAC).

Con ese offset a la salida del DAC, el mínimo de intensidad al que bajaba la carga electrónica era de 0.74mA que es muy alto para mis necesidades.

Está claro que podría bajarlo utilizando una resistencia R1 más alta (estaba usando la de 1Ω) o modificando el voltaje de alimentación de la carga electrónica (la estaba alimentando a 5V).

Pruebas usando PWM generado por el ESP32

He configurado el pin 27 como salida PWM de 1Khz con una resolución de 10 bits (lo que proporciona 1024 «escalones»).

El código utilizado para las pruebas ha sido el siguiente:

#include <Arduino.h>

// Define el canal PWM a utilizar
int pwmChannel = 0;

// Define el pin al que está conectado el PWM
const int pwmPin = 27;

// Inicializa el ciclo de trabajo del PWM al 0%
int dutyCycle = 0;

// Guarda el valor anterior del ciclo de trabajo
int oldDutyCycle = 0;

// Define la resolución del PWM (10 bits en este caso)
const int pwmResolution = 10;

// Define la frecuencia del PWM (1kHz en este caso)
const int pwmFrequency = 1000;

void setup()
{
  // Inicia la comunicación serial a 115200 baudios
  Serial.begin(115200);

  // Configura el PWM con el canal, la frecuencia y la resolución especificados
  ledcSetup(pwmChannel, pwmFrequency, pwmResolution);

  // Asocia el pin especificado con el canal PWM
  ledcAttachPin(pwmPin, pwmChannel);

  // Inicia el PWM con el ciclo de trabajo inicial
  ledcWrite(pwmChannel, map(dutyCycle, 0, 1023, 0, 1024));
}

void loop()
{
  // Si el ciclo de trabajo ha cambiado, lo muestra por el puerto serie
  if (dutyCycle != oldDutyCycle)
  {
    Serial.print(">Ciclo de trabajo:");
    Serial.print(dutyCycle);
    Serial.println(" de 1023");
    oldDutyCycle = dutyCycle;
  }

  // Si hay datos disponibles en el puerto serie, los lee
  if (Serial.available() > 0)
  {
    int key = Serial.read();
    // Si la tecla presionada es la tecla de escape y hay al menos dos caracteres más en el buffer
    if (key == 27 && Serial.available() >= 2)
    {
      Serial.read(); // Descarta el siguiente carácter ('[')
      switch (Serial.read()) // Lee el siguiente carácter
      {
      case 'A': // Si es 'A' (flecha arriba), incrementa el ciclo de trabajo
        oldDutyCycle = dutyCycle;
        dutyCycle = min(1023, dutyCycle + 5);
        break;
      case 'B': // Si es 'B' (flecha abajo), decrementa el ciclo de trabajo
        oldDutyCycle = dutyCycle;
        dutyCycle = max(0, dutyCycle - 5);
        break;
      }
    }
  }

  // Actualiza la salida PWM con el nuevo ciclo de trabajo
  ledcWrite(pwmChannel, map(dutyCycle, 0, 1023, 0, 1024));

  // Espera 100 milisegundos antes de la próxima iteración del bucle
  delay(100);
}

Este código permite, para mayor comodidad al experimentar, modificar el ciclo de trabajo de la señal PWM desde el terminal serie con las flechas arriba y abajo en incrementos de 5 pasos de los 1024 disponibles.

De las pruebas que he hecho el resultado ha sido completamente positivo, aunque pienso que es mejor utilizar el DAC MCP4725 (al fin y al cabo, para usar la señal PWM, hay que poner un filtro R-C, como te explico a continuación).

Ahora bien, para convertir la señal de pulsos PWM en una tensión continua variable he tenido que poner a la salida un filtro pasa bajo, construido con una resistencia de 4.7kΩ y un condensador electrolítico de 1uF.

El montaje del filtro paso bajo es muy fácil.

Aquí tienes el esquema:

Y aquí puedes ver el efecto que tiene este filtro tan simple:

El canal 1 (en amarillo) corresponde a la señal PWM tal cual es generada por el ESP32.

El canal 2 (en azul) es la salida del filtro, con esa señal PWM aplicada a la entrada.

En mi caso, he construido el filtro en una pequeña placa independiente con dos conectores para poder hacer pruebas e intercambiarlo fácilmente:

Es este diagrama puedes ver las conexiones de la pequeña plaquita con el filtro RC:

Aquí puedes ver el filtro montado en la entrada PWM de la carga electrónica durante las pruebas.

Pruebas usando el DAC MCP4725

Solo puedo decir una cosa: no lo había usado nunca y estoy encantado.

Es super fácil utilizar un MCP4725 para generar voltaje y el voltaje generado es superestable.

Creo, sinceramente, que es la solución perfecta para la carga electrónica. Salvo que sea para una prueba de concepto puntual no merece la pena utilizar una señal PWM o el DAC interno del ESP32.

Este es un código de prueba, muy sencillo, que nos permite ajustar la tensión de salida del MCP4725 desde el terminal serie.

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_MCP4725.h>

#define SDA_PIN 33
#define SCL_PIN 32

Adafruit_MCP4725 dac;

void setup() {
  Serial.begin(115200);
  Wire.begin(SDA_PIN, SCL_PIN);

  dac.begin(0x60);  // Dirección I2C predeterminada 0x60, si no funciona, intenta 0x62

  // Configura el MCP4725 según tus necesidades (puedes cambiar la referencia a 4096 para una referencia de 4.096V)
  dac.setVoltage(0, false);  // Establece el voltaje inicial a 0V
}

void loop() {
  // Muestra el valor de voltaje actual por el puerto serie
  Serial.print(">Voltaje de salida: "); Serial.print(dac.readVoltage()); Serial.println(" V");
  Serial.println("");

  // Actualiza el voltaje según las teclas de flecha
  if (Serial.available() > 0) {
    int key = Serial.read();
    if (key == 27 && Serial.available() >= 2) { // Detecta la secuencia de teclas de flecha
      Serial.read(); // Descarta '['
      switch (Serial.read()) {
        case 'A': // Flecha arriba
          dac.setVoltage(dac.readVoltage() + 0.01, false);  // Ajusta el voltaje hacia arriba (puedes cambiar el valor según tus necesidades)
          break;
        case 'B': // Flecha abajo
          dac.setVoltage(dac.readVoltage() - 0.01, false);  // Ajusta el voltaje hacia abajo (puedes cambiar el valor según tus necesidades)
          break;
      }
    }
  }

  delay(100);
}

¿Y ahora qué? ¡El siguiente nivel! 🚀

Hemos conseguido lo más importante: controlar la carga electrónica de forma digital usando un microcontrolador ESP32, y hemos confirmado que funciona con su DAC interno y con PWM.

Sin embargo, para convertir esta base en un instrumento de laboratorio capaz de hacer mediciones profesionales, necesitamos dos cosas que el ESP32 no nos da con la precisión suficiente:

1. Control de Corriente Ultra-fino: Necesitamos más de los 8 o 10 bits de resolución que nos dan el PWM o el DAC interno.
2. Medición de Alta Precisión: Necesitamos leer la corriente y el voltaje de la fuente (DUT) de forma simultánea y muy exacta.

En el próximo artículo, daremos el salto definitivo. Usaremos la misma base que ya tienes, pero le añadiremos:

• Un DAC externo (MCP4725) de 12 bits para un control de 4096 pasos.
• Un monitor de potencia INA3221 de tres canales para lecturas de corriente y tensión de altísima precisión.

Con estos dos módulos, construiremos un Analizador de Cargas y Fuentes que te permitirá obtener automáticamente las curvas V-I (Voltaje-Corriente) de cualquier fuente, panel solar, batería o cargador.

¡Prepárate! Dejaremos de ser aficionados al DIY para convertirnos en ingenieros de instrumentación en el siguiente post.