Este documento describe la construcción de una carga electrónica casera con Arduino, una pantalla LCD, un codificador rotatorio y un MOSFET de potencia. Explica los componentes necesarios, cómo conectar el circuito, codificar el software de control y construir el chasis, incluida la montura de la PCB, la colocación de los componentes y la finalización de la caja. También discute la calibración del código para adaptarse a los valores reales de las resistencias utilizadas en el circuito.

1. CARGA ELECTRÓNICA ARDUINO
En este tutorial les muestro cómo he construido una carga electrónica casera con Arduino,
una pantalla LCD, un codificador rotatorio para el menú y un MOSFET de potencia para el
control de carga. También tiene un buen sistema de enfriamiento para que pueda manejar
cargas elevadas. Ver cómo hacer el circuito, la carcasa, conectar todo, ver el código que
he usado y qué módulos y hacer el mismo proyecto. Espero que te guste. Si este tutorial
le ayuda, considere apoyar mi trabajo.
Parte 1 - ¿Qué necesitamos?
Esta es toda la electrónica que necesitamos para este proyecto. También tiene una lista
con algunas otras partes que necesitamos, como la madera contrachapada, el enfriador,
las cubiertas y los tornillos impresos en 3DF del ventilador. La electrónica es fácil de usar.
Todos los módulos utilizan comunicación i2c. Para el disipador de calor, he usado un
enfriador de PC y funciona muy bien. Necesitará un cable delgado para las conexiones de
5 V pero un cable grueso para el MOSFET y las líneas eléctricas.
Para el dron necesitamos:
1 x Arduino NANO: ENLACE eBay
1 x pantalla LCD i2c: LINK eBay
1 x ADS1115 ADC: ENLACE eBay
1 x MCP4725 DAC: ENLACE eBay

2. Parte 2 - Esquema
• Hablemos del esquema. Es importante y es posible que deba adaptarlo a sus
necesidades. En primer lugar, 12V del adaptador de CC está conectado a un interruptor
de palanca y luego al pin Arduin o Vin y al ventilador, por lo que cuando cambiamos el
interruptor, todo está encendido. El NANO tiene un regulador de 5V y ese será nuestro
Vcc. Suministre todos los módulos a Vcc y GND y conecte los pines SDA y SCL del
Arduino a todos los módulos i2c (ADC, DAC y LCD).
• Conecte el codificador a Vcc, GND y los 3 pines a los pines digitales D8, D9 y D10 del
Arduino. Conecte los pulsadores a los pines D11 y D12. También conecte el zumbador a
D3 para la señal PWM para tonos.
• Sobre el divisor de voltaje. Lea el código y las siguientes partes de los tutoriales. He
usado 10K y 100K, pero esos no son exactamente estos valores, por lo que debemos
adaptar el multiplicador en el código. Lee el código.
• Para leer la corriente utilizo una derivación de 1ohm. Leemos el voltaje en esta carga en
modo diferencial con el ADC. Nuevamente, esta resistencia no es exactamente de 1
ohmio, por lo que el multiplicador se adaptará en el código. Lea esa parte más tarde.
Conecte la salida DAC a la puerta del MOSFET. Load +, Load-, S + y S- son los
conectores banana que tenemos en el panel frontal. Eso es.
Si desea que el controlador supere los 2.1A, necesitará más voltaje en la puerta MOSFET
que 5V que el DAC podría dar. Para eso, use este segundo esquema con un OPAMP
entre el DAC y la puerta MOSFET.

3. Parte 3.1 - Prepare el MOSFET
Ok, obtenga el MOSFET y suelde cables gruesos al drenaje, la compuerta y la fuente.
Agregue tubos retráctiles para aislamiento. Luego mida la posición y haga un agujero en el
disipador de calor. Agregue un poco de pasta térmica y atornille en su lugar el MOSFET.
Ahora debería tener todo el bloque de alimentación con 3 cables.

4. Parte 3.2 - Monte la PCB
En una PCB de creación de prototipos, suelde todos los componentes. Utilizo cables
delgados para las conexiones de baja potencia como 5V para los módulos, conexiones i2c
y pulsadores. Para la ruta desde la entrada a través de la carga y hasta el MOSFET, use
conexiones de cables gruesos. Además, haga muy corta la conexión desde el ADC0 y
ADC1 del ADS1115 a los terminales de la resistencia de 1ohm. Cuanto más largas sean
estas conexiones, más caída de voltaje habrá en la carga, y necesitamos leer la caída
exactamente en la CARGA. Para los pulsadores, LCD y codificador, agregamos cables
largos y delgados para una futura conexión a la PCB con algunos pines macho-hembra.
Para las conexiones de alimentación, agregue algunos terminales de tornillo si los tiene.

5. Parte 3.3 - Monte la PCB
A continuación puede ver las conexiones en la parte inferior de la PCB. Como puede ver,
he usado un cable grueso para la ruta de alimentación para que pueda manejar alta
corriente. También he llenado de soldadura algunas conexiones por la misma razón.
Coloqué pines hembra para luego poder conectar la pantalla LCD, el codificador y esos 2
botones. Ahora incluso podemos hacer una prueba y luego exponer el caso.

6. Parte 4.1 - El caso
He usado madera contrachapada e hice un estuche simple. Empiezo con 4 paredes, la
superior, los laterales y la trasera. Mido dónde encajar el ventilador del refrigerador en el
panel posterior. Luego corté un agujero en el panel trasero para el ventilador y otro en el
lado derecho para el flujo de aire. Luego cubro el estuche enirte con vinilo de textura de
fibra de carbono para que se vea mejor. Luego imprimo en 3D las cubiertas del ventilador.
Descarga los de aquí. Usando superpegamento pego las cubiertas en su lugar.
Parte 4.2 - Más caso
Luego pego 4 bloques de madera en la parte inferior y agrego una tuerca M3. Estos se
usarán para cerrar la caja cuando termine de usar tornillos M3. Luego hago el panel
frontal y lo envuelvo en vinilo de fibra de carbono. Imprimo el soporte LCD y lo coloco
dentro. Luego decido dónde colocar cada componente. Hago agujeros y agrego todos los
botones, LCD, codificador y conectores. Luego pego el panel frontal a la carcasa y hago
las conexiones a la PCB. Asegure el interior del PCB con pegamento.

7. Parte 4.3 - Finalización del caso
El ventilador está pegado en su lugar en el panel trasero. Hago un agujero en el costado y
me aseguro de que el conector USB Arduino esté frente a ese agujero para poder
programar el chip con un cable USB. El conector principal de 12V DC tiene un orificio en
la parte posterior para que podamos conectar la alimentación aquí. Eso es. Cierra la caja
con tornillos y podemos subir el código.

8. Parte 5.1 - Código del controlador
Vaya a continuación y descargue el código. Necesitará las bibliotecas para los módulos
LCD, ADS1115 y MCP4725 y también puede descargar esas bibliotecas desde el
siguiente enlace. También necesitará la biblioteca BusIO, así que instálela con el
administrador de biblioteca de Arduino IDE. Lea el código para obtener más detalles,
especialmente la parte del multiplicador. Compile y cargue y luego pruebe el controlador.
Parte 5.2 - Explicación del multiplicador
Esta parte es importante. Verá, cuando demanda al ADS1115, para pasar de valores de
bits (0 a 65000), usamos un multiplicador. De forma predeterminada, es "0.185mv" o
"0.000185V". En el código, para medir la corriente, hacemos una medición diferencial del
voltaje en la carga "1ohm". Dado que la carga es de 1ohm, eso nos dará
DIRECTAMENTE el valor actual ya que "I = V / R" y R es 1. ¡¡¡PERO !!! La resistencia no
es exactamente de 1ohm, por lo que en mi caso he adaptado el multiplicador a
0.0001827. Es posible que deba ajustar esta variable a otros valores hasta que obtenga
buenas lecturas, por lo que mientras mide el valor con un multímetro externo al mismo
tiempo, ajuste esta variable hasta obtener buenos resultados.
Lo mismo ocurre aquí. Pero en este caso, la lectura de voltaje proviene de un divisor de
voltaje. Verá, el ADS1115 solo puede medir hasta 5V. Si la entrada es más alta, se
dañará. Entonces, para eso, entre el ADS1115 y la entrada principal, he usado un divisor
de 10K y 100K y eso será igual a un divisor de 0.0909090. Entonces, ahora el
multiplicador es 0.000185 / 0.0909090 = 0.002035. Ahora, estos valores de resistencia no
son perfectos más cercanos, por lo que no tenemos exactamente 10K y 100K, por eso mi
multiplicador para la lectura de voltaje es 0.0020645. Simplemente haga lo mismo, mida el
voltaje en la pantalla LCD y también con un multimitador externo y ajuste este valor hasta
obtener buenos resultados. He medido las resistencias pero eso no es suficiente.
Necesitamos valores precisos.

9. const float multiplier = 0.0001827; //Multiplier used for "current" read
between ADC0 and ADC1 of the ADS1115
/////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
const float multiplier_A2 = 0.0020645; //Multiplier for voltage read from
the 10K/100K divider
Parte 7 - Más información
• Algo a tener en cuenta. En esta versión, no estoy usando las sondas sensoriales. El código
era demasiado lento si leo el voltaje de entrada y el voltaje de detección al mismo tiempo,
pero intentaré agregar esta función en una versión futura.
• Además, el control de la corriente se realiza cambiando el voltaje en la puerta MOSFET.
Este control debería ser PID para obtener muy buenos resultados, pero la lectura de ADC
y la escritura de DAC están ralentizando tanto el código, que un buen PID no estaba
funcionando. Entonces, en lugar de PID, hice un "control manual" y decido el valor
proporcional dependiendo del rango de error. A continuación puede ver un ejemplo. Si el
error es muy grande, mayor al 80% del punto de ajuste, entonces la salida DAC cambiará
en los pasos io 300 de un total de 4069. Si el error es el 60% del punto de ajuste en pasos
de 170 y así sucesivamente. Si el error es pequeño, los pasos son solo 1 de un toral de
4069, por lo que tenemos un buen control. Esto funciona pero no es perfecto.
if (error > (mW_setpoint*0.8))
{
if(mW_setpoint > power_read){
dac_value = dac_value + 300;
}
if(mW_setpoint < power_read){
dac_value = dac_value - 300;
}
}
else if (error > (mW_setpoint*0.6))
{
if(mW_setpoint > power_read){
dac_value = dac_value + 170;
}
if(mW_setpoint < power_read){
dac_value = dac_value - 170;

10. }
}
else if (error > (mW_setpoint*0.4))
{
if(mW_setpoint > power_read){
dac_value = dac_value + 120;
}
if(mW_setpoint < power_read){
dac_value = dac_value - 120;
}
}
...