Es un tema viejo que ya había estado dando vueltas en algún momento, y hoy por casualidad recordé que acá habían compartido un archivo (hace mas de 10 años) y encontré sus errores...
Me refiero puntualmente a este pdf mencionado en el comentario #89:
Trabajemos para conseguir un inversor DC-AC senoidal
En su momento lo edite y lo lleve a un PIC16F876, pero hace aproximadamente año y medio volví a este proyecto base y lo migre todo a un simple Arduino NANO por que la persona que lo necesitaba, no tenia grabadora de microcontroladores y era un caso particularmente necesario por que vivía en una escuela rural y no contaba con muchos recursos... O sea, lo arme con un Arduino para que cualquiera que no entienda de microcontroladores, lo único que tiene que hacer es contar con el cable usb, el Arduino NANO, abrir el ide gratuito de Arduino, copiar, pegar y compilar (grabar)…
Antes que nada, les comento a "todos" que el programa original en ASM, no coincide con el hardware y es la implementación clásica para un inversor de onda cuadrada simple, no para uno senoidal como dice. El autor quizás omitió el programa original quizás por razones comerciales, particulares, o vaya a saber uno.
Si analizan la lógica del ASM, pueden ver que solo utiliza ACALL DELAI para crear pausas y CLR/SETB (P3.0/P3.1) para alternar los drivers. Esto genera una simple onda cuadrada con un tiempo muerto rudimentario, ideal para cargas resistivas simples (como bombillas incandescentes), pero ineficiente y potencialmente dañino para motores o electrónica sensible.
Por mas filtro que vean en el diagrama, esta faltando SPWM. Para una onda senoidal pura se requiere de una odulación por ancho de pulso sinusoidal (SPWM = Sinusoidal Pulse Width Modulation).
Esto implica:
- Una tabla de valores senoidales almacenada en memoria.
- El uso de interrupciones de temporizador de alta velocidad para cambiar el ancho de pulso cientos de veces por ciclo (50 Hz).
- y sumar una seguridad para que el puente H no vuele
El ejemplo del pdf en ASM carecía de la subrutina PULSE_TRAIN que probablemente debía implementar esta lógica, pero incluso con esa subrutina, la simplicidad del resto del programa sugiere un diseño más básico y no la que presenta en el circuito del pdf. El título del diagrama (PURE SINE INVERTER) se contradice con la simplicidad del código ASM que presenta. en fin, dejemos de lado este tema, y vamos al grano... Acá te muestro una segunda versión del sketch implementando un Arduino NANO que se amolda al diseño del hardware presentado en el pdf…
En el sketch te pongo las referencias de los pines para hacer las conexiones y no armar un RatAMPS (chiste de la jerga arenera
)
CSS:
//=======================SolarDUINO_V2=======================
// ingeniería inversa y correcion al diseño del Inversor:
// DIDIK ROSTYONO 2006
// prof.martintorres@educ.ar - ETI Patagonia
//===========================================================
#include <avr/io.h>
#include <avr/interrupt.h>
#include <math.h>
// --- Mapeo de Pines (Segun Esquematico) ---
#define BTN_START_STOP_PIN 2 // P1.2
#define BAT_SENSE_PIN A0 // P1.7 (ADC input)
#define BUZZER_PIN 6 // P3.4
#define LED_PIN 7 // P3.5
#define SPWM_PIN_A 9 // P3.0 (OC1A - Driver 1)
#define SPWM_PIN_B 10 // P3.1 (OC1B - Driver 2)
// --- Constantes de Control ---
#define LOW_VOLTAGE_ADC 512 // Umbral de bateria baja (Calibrar con potenciómetro: 0=12V, 1023=0V)
#define BEEP_DUR_MS 250
// --- Constantes SPWM (50 Hz) ---
#define SINE_STEPS 200 // Muestras por ciclo completo
#define TIMER1_TOP_VALUE 1023 // TOP para 10-bit Phase Correct PWM
volatile uint16_t sine_table[SINE_STEPS];
volatile uint16_t sine_index = 0;
volatile bool inverter_on = false;
// --- Variables de Tiempo (Millis-based) ---
unsigned long previousMillis = 0;
bool ledState = false;
//===========================================================
// --- Funciones auxiliares ---
void generate_sine_table()
{
for (int i = 0; i < SINE_STEPS; i++) {
sine_table[i] = (uint16_t)(sin(i * 2 * M_PI / SINE_STEPS) * 511.5 + 511.5);
}
}
// Interrupción del Timer1 para actualizar el valor de PWM
ISR(TIMER1_OVF_vect)
{
if (inverter_on)
{
// Actualiza el valor de comparación A y B.
OCR1A = sine_table[sine_index];
OCR1B = sine_table[sine_index];
sine_index++;
if (sine_index >= SINE_STEPS)
{
sine_index = 0;
}
}
}
//===========================================================
void setup()
{
pinMode(BTN_START_STOP_PIN, INPUT_PULLUP);
pinMode(BAT_SENSE_PIN, INPUT);
pinMode(BUZZER_PIN, OUTPUT);
pinMode(LED_PIN, OUTPUT);
pinMode(SPWM_PIN_A, OUTPUT);
pinMode(SPWM_PIN_B, OUTPUT);
digitalWrite(LED_PIN, HIGH); // LED OFF (Lógica inversa)
generate_sine_table();
setup_timer1(); // Configura el hardware del Timer1
}
//===========================================================
void loop()
{
unsigned long currentMillis = millis();
// 1. Lectura de Bateria (ADC ANALOGICO)
int bat_level_adc = analogRead(BAT_SENSE_PIN);
if (bat_level_adc > LOW_VOLTAGE_ADC) // Si el ADC lee un valor alto (voltaje bajo)
{
inverter_on = false;
TCCR1A &= ~((1 << COM1A1) | (1 << COM1B1)); // Desconecta pines 9 y 10
if (currentMillis - previousMillis >= BEEP_DUR_MS)
{
previousMillis = currentMillis;
ledState = !ledState;
digitalWrite(BUZZER_PIN, ledState);
digitalWrite(LED_PIN, !ledState);
}
return;
}
else
{
digitalWrite(BUZZER_PIN, LOW); // Si la bateria esta bien, apaga el buzzer de alarma
}
if (digitalRead(BTN_START_STOP_PIN) == LOW)
{
if (!inverter_on && (currentMillis - previousMillis > 300))
{
inverter_on = true; // Reconecta los pines 9 y 10 al Timer1 (Output Compare Mode)
TCCR1A |= (1 << COM1A1) | (1 << COM1B1) | (1 << COM1B0); // Pin B invertido
previousMillis = currentMillis;
}
else if (inverter_on && (currentMillis - previousMillis > 300))
{
inverter_on = false;
TCCR1A &= ~((1 << COM1A1) | (1 << COM1B1)); // Desconecta pines 9 y 10
previousMillis = currentMillis;
}
}
if (inverter_on)
{
if (currentMillis - previousMillis >= 1000) // Parpadeo lento (1Hz)
{
previousMillis = currentMillis;
ledState = !ledState;
digitalWrite(LED_PIN, ledState ? LOW : HIGH); // Invertir estado del LED
}
}
else
{
digitalWrite(LED_PIN, HIGH); // LED apagado
}
}
//===========================================================
// Configuración del Timer1 para SPWM con Hardware Dead Time (Modo 10 Phase Correct PWM)
void setup_timer1()
{
cli();
TCCR1A = 0;
TCCR1B = 0;
TCNT1 = 0;
ICR1 = TIMER1_TOP_VALUE;
// WGM13=1, WGM12=0, WGM11=1, WGM10=0 => Mode 10: Phase Correct PWM, TOP is ICR1
TCCR1B |= (1 << WGM13);
TCCR1A |= (1 << WGM11);
// Preescalador 8: 16MHz/8 = 2MHz clock for timer
TCCR1B |= (1 << CS11);
// Habilita interrupción por Overflow del Timer1
TIMSK1 |= (1 << TOIE1);
sei();
}
//==========================================================
No hay mucha ciencia en el sketch... Para la lectura del estado de batería, las resistencias de 10K y el potenciómetro de 1K forman un divisor de tensión desde la línea de 12VDC (en realidad 13,8/14,3).
Este divisor reduce el voltaje a un nivel seguro para la base del transistor BC547, y lo usamos como comparador, actúando como un interruptor (CORTE-SATURACION).
Supongamos que la batería esta "Bien"(ej. > 11V): El voltaje en la base es suficiente para encender el transistor (SATURACION).
Esto conecta el pin P1.7 (A0 en Arduino) a tierra (GND), resultando en una lectura de voltaje baja (0V).
En el caso de tener una estado de batería baja (ej. < 11V): El voltaje en la base cae, apagando el transistor (CORTE). El pin P1.7 ya no está conectado a tierra y, gracias a la configuración, su voltaje sube (lectura de voltaje alta en el ADC)... Con el multimetro se puede ver la curva.
Para ajustar el Umbral, el potenciómetro de 1K es importante que sea de buen estado y no meta perturbaciones al tocar el chasis o la perilla, ya que permite calibrar manualmente el punto exacto de voltaje de la batería donde el transistor cambia de estado (corte-saturacion).
El sketch trate de que interactúe con este hardware mediante la entrada analógica A0 (
BAT_SENSE_PIN). En cada iteración del loop(), la función analogRead(BAT_SENSE_PIN) lee el voltaje en el pin A0.
Un valor LOW (cercano a 0) indica batería en buen estado. Un valor HIGH (cercano a 1023), si se usa la referencia de 5V del Arduino) indica batería baja.
La logica del umbral hace que la línea
if (bat_level_adc > LOW_VOLTAGE_ADC) compare la lectura. Si la lectura es mayor que el umbral (
LOW_VOLTAGE_ADC, que definimos como
512), el programa entra en el estado de alarma.
Para tener un control "No Bloqueante", implemente millis() para hacer parpadear el LED y sonar el buzzer sin bloquear el resto del programa, permitiendo asi una monitorización constante y reactiva del botón de Start/Stop. El sistema está diseñado para que, cuando el hardware detecta bajo voltaje, el software entre en modo de seguridad inmediatamente.
Algo que me dio dolor de cabeza y hasta que no cambie el potenciometro metalico por uno sellado y eje de plastico, fue la calibracion....
La calibración del umbral requiere un multímetro y ajustar el hardware físicamente. Primero definimos el "Umbral Deseado", o sea, decidimos a qué voltaje de batería queremos que el inversor se apague y active la alarma (por ejemplo, 10.5V).
Despues, conectamos la batería de 12V o una fuente variable al circuito (con un fusible en línea, por seguridad). y ajustamos la fuente en 10,5v... Ajustamos el Potenciómetro Con la tension exactamente a 10.5V, medimos con multímetro el voltaje en la base del transistor BC547 y giramos el potenciómetro hasta que el voltaje en esa base sea de aproximadamente 0.7V.En este punto, el transistor debería estar justo al borde de apagarse (CORTE).
Si bien ya no hace falta por que yo lo hice con mi instrumental y ya defini los valores en el sketch, no esta demas explicarte como podes vos darle un ajuste fino por software...
teniendo el hardware configurado y con esta tension de 10,5v, podes añadir temporalmente un
Serial.begin(9600) en setup() y
Serial.println(bat_level_adc); dentro del loop()... Con esto, veriamos por el Monitor Serial el valor exacto que lee cuando tu batería está exactamente en 10.5V.
Este será tu valor
LOW_VOLTAGE_ADC. Actualiza la constante en el programa donde dice:
Código:
define LOW_VOLTAGE_ADC 512 // Reemplaza 512 por el valor que mediste
Al hacer esto, sincronizaste el umbral físico del circuito con la lógica del programa. La lógica del
if (bat_level_adc > LOW_VOLTAGE_ADC) ahora funcionará perfectamente con tu ajuste manual.
No encuentro la carpeta de la version definitiva que tenia
ahi tenia el PCB dibujado del inversor y el regulador PWM, mas el nuevo sketch actualizado... Espero que te sea de ayuda. Saludos
ESTA SERIA LA CONEXION CON EL ARDUINO NANO
www.forosdeelectronica.com
