ساخت یک یو پی اس خانگی 1 کاوا: راهنمای جامع عملی

				
					/**
 * برنامه کامل کنترل یو پی اس 1 کاوا
 * میکروکنترلر: ATmega328P
 * کامپایلر: AVR-GCC
 * فرکانس: 16MHz
 */

#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
#include <string.h>

// ==================== تعریف پین‌ها ====================
// پورت B
#define RELAY_CHARGE    PB0    // رله شارژر
#define RELAY_INVERTER  PB1    // رله اینورتر  
#define RELAY_MAIN      PB2    // رله اصلی
#define BUZZER          PB3    // بیزر
#define FAN_PWM         PB4    // فن خنک‌کننده (PWM)

// پورت C (ADC)
#define ADC_BATTERY     PC0    // سنسور ولتاژ باتری
#define ADC_GRID        PC1    // سنسور ولتاژ برق شهر
#define ADC_CURRENT     PC2    // سنسور جریان ACS712
#define ADC_TEMP        PC3    // سنسور دما LM35

// پورت D
#define LCD_RS          PD0
#define LCD_RW          PD1
#define LCD_EN          PD2
#define LCD_D4          PD4
#define LCD_D5          PD5
#define LCD_D6          PD6
#define LCD_D7          PD7

// ==================== تعریف ثابت‌ها ====================
#define BATTERY_FULL    54.6    // ولتاژ کامل باتری (48V)
#define BATTERY_LOW     42.0    // ولتاژ پایین باتری
#define BATTERY_CRITICAL 40.0   // ولتاژ بحرانی
#define GRID_MIN        180.0   // حداقل ولتاژ برق شهر
#define TRANSFER_DELAY  50      // تاخیر انتقال (میلی‌ثانیه)
#define PWM_FREQ        5000    // فرکانس PWM فن

// ==================== متغیرهای جهانی ====================
volatile uint16_t adc_values[4];
volatile uint8_t adc_index = 0;
volatile uint32_t system_tick = 0;
volatile uint8_t fault_flags = 0;

// وضعیت سیستم
enum SystemState {
    STATE_NORMAL,      // برق شهر وصل
    STATE_BATTERY,     // کار با باتری
    STATE_CHARGING,    // در حال شارژ
    STATE_FAULT        // خطا
} system_state;

// ساختار برای ذخیره اطلاعات
struct UPSData {
    float battery_voltage;
    float grid_voltage;
    float load_current;
    float temperature;
    uint32_t backup_time;
    uint8_t battery_percent;
    uint16_t frequency;
};

struct UPSData ups_data;

// ==================== توابع راه‌اندازی ====================

/**
 * راه‌اندازی تایمر 0 برای PWM فن
 */
void init_timer0_pwm(void) {
    // حالت Fast PWM
    TCCR0A = (1 << WGM00) | (1 << WGM01) | (1 << COM0B1);
    // تقسیم‌کننده 64
    TCCR0B = (1 << CS01) | (1 << CS00);
    OCR0B = 0; // شروع با سرعت صفر
}

/**
 * راه‌اندازی تایمر 1 برای ADC و کارهای زمان‌بندی
 */
void init_timer1(void) {
    // حالت CTC
    TCCR1B = (1 << WGM12) | (1 << CS12); // تقسیم‌کننده 256
    OCR1A = 625; // 10ms @ 16MHz/256
    TIMSK1 = (1 << OCIE1A); // فعال کردن وقفه
}

/**
 * راه‌اندازی ADC
 */
void init_adc(void) {
    // ولتاژ مرجع AVcc، تراز چپ
    ADMUX = (1 << REFS0) | (1 << ADLAR);
    // فعال کردن ADC، تقسیم‌کننده 128
    ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
    // فعال کردن وقفه ADC
    ADCSRA |= (1 << ADIE);
    // شروع تبدیل اول
    ADCSRA |= (1 << ADSC);
}

/**
 * راه‌اندازی پین‌های I/O
 */
void init_gpio(void) {
    // پورت B خروجی
    DDRB = (1 << RELAY_CHARGE) | (1 << RELAY_INVERTER) | 
           (1 << RELAY_MAIN) | (1 << BUZZER) | (1 << FAN_PWM);
    
    // پورت C ورودی برای ADC
    DDRC = 0x00;
    
    // پورت D خروجی برای LCD
    DDRD = 0xFF;
    
    // خاموش کردن همه رله‌ها در ابتدا
    PORTB &= ~((1 << RELAY_CHARGE) | (1 << RELAY_INVERTER) | (1 << RELAY_MAIN));
}

// ==================== توابع LCD ====================
#ifdef USE_LCD
void lcd_command(uint8_t cmd) {
    PORTD = (PORTD & 0x0F) | (cmd & 0xF0);
    PORTD &= ~(1 << LCD_RS);
    PORTD &= ~(1 << LCD_RW);
    PORTD |= (1 << LCD_EN);
    _delay_us(1);
    PORTD &= ~(1 << LCD_EN);
    _delay_us(100);
    
    PORTD = (PORTD & 0x0F) | (cmd << 4);
    PORTD |= (1 << LCD_EN);
    _delay_us(1);
    PORTD &= ~(1 << LCD_EN);
    _delay_us(100);
}

void lcd_data(uint8_t data) {
    PORTD = (PORTD & 0x0F) | (data & 0xF0);
    PORTD |= (1 << LCD_RS);
    PORTD &= ~(1 << LCD_RW);
    PORTD |= (1 << LCD_EN);
    _delay_us(1);
    PORTD &= ~(1 << LCD_EN);
    _delay_us(100);
    
    PORTD = (PORTD & 0x0F) | (data << 4);
    PORTD |= (1 << LCD_EN);
    _delay_us(1);
    PORTD &= ~(1 << LCD_EN);
    _delay_us(100);
}

void lcd_init(void) {
    _delay_ms(50);
    lcd_command(0x33);
    lcd_command(0x32);
    lcd_command(0x28); // 4-bit, 2-line, 5x8
    lcd_command(0x0C); // Display on, cursor off
    lcd_command(0x06); // Entry mode
    lcd_command(0x01); // Clear
    _delay_ms(2);
}

void lcd_string(const char *str) {
    while(*str) {
        lcd_data(*str++);
    }
}

void lcd_update_display(void) {
    char buffer[16];
    
    // خط اول
    lcd_command(0x80);
    if(system_state == STATE_NORMAL) {
        lcd_string("GRID: ");
    } else {
        lcd_string("BATT: ");
    }
    
    dtostrf(ups_data.battery_voltage, 5, 1, buffer);
    lcd_string(buffer);
    lcd_string("V ");
    
    // درصد باتری
    itoa(ups_data.battery_percent, buffer, 10);
    lcd_string(buffer);
    lcd_string("%");
    
    // خط دوم
    lcd_command(0xC0);
    if(system_state == STATE_BATTERY) {
        lcd_string("Backup: ");
        uint32_t minutes = ups_data.backup_time / 60;
        uint32_t seconds = ups_data.backup_time % 60;
        itoa(minutes, buffer, 10);
        lcd_string(buffer);
        lcd_string(":");
        if(seconds < 10) lcd_string("0");
        itoa(seconds, buffer, 10);
        lcd_string(buffer);
    } else {
        lcd_string("Load: ");
        dtostrf(ups_data.load_current, 4, 1, buffer);
        lcd_string(buffer);
        lcd_string("A");
    }
}
#endif

// ==================== توابع محاسباتی ====================

/**
 * محاسبه ولتاژ باتری
 */
float calculate_battery_voltage(uint16_t adc_value) {
    // تقسیم‌کننده ولتاژ: 48V -> 5V -> ADC
    // نسبت تقسیم: (R1=10K, R2=2.2K) = 5.545
    float voltage = (adc_value * 5.0 / 256.0) * 5.545;
    return voltage;
}

/**
 * محاسبه ولتاژ برق شهر
 */
float calculate_grid_voltage(uint16_t adc_value) {
    // ترانس 220V به 12V + تقسیم‌کننده
    // نسبت کلی: 220V -> 2.5V -> ADC
    float voltage = (adc_value * 5.0 / 256.0) * 88.0;
    return voltage;
}

/**
 * محاسبه جریان مصرفی
 */
float calculate_load_current(uint16_t adc_value) {
    // ACS712 30A: 66mV/A
    // ولتاژ خروجی: 2.5V @ 0A
    float voltage = (adc_value * 5.0 / 256.0) - 2.5;
    float current = voltage / 0.066; // 66mV/A
    return (current > 0) ? current : 0;
}

/**
 * محاسبه دمای MOSFET‌ها
 */
float calculate_temperature(uint16_t adc_value) {
    // LM35: 10mV/°C
    float voltage = (adc_value * 5.0 / 256.0);
    float temperature = voltage * 100.0; // 10mV/°C
    return temperature;
}

/**
 * محاسبه درصد شارژ باتری
 */
uint8_t calculate_battery_percent(float voltage) {
    if(voltage >= 54.6) return 100;
    if(voltage <= 40.0) return 0;
    
    // منحنی شارژ باتری سربی-اسیدی
    float percent = ((voltage - 40.0) / (54.6 - 40.0)) * 100.0;
    return (uint8_t)percent;
}

/**
 * محاسبه زمان پشتیبانی باقی‌مانده
 */
uint32_t calculate_backup_time(float voltage, float current) {
    if(current < 0.1) return 9999; // بدون بار
    
    // ظرفیت باتری: 4×18Ah = 72Ah @ 48V
    float capacity_wh = 72.0 * 48.0; // 3456Wh
    float usable_energy = capacity_wh * 0.8; // 80% راندمان
    float load_power = current * 220.0; // فرض 220V
    
    if(load_power < 10) return 9999;
    
    float hours = usable_energy / load_power;
    uint32_t seconds = (uint32_t)(hours * 3600);
    
    return seconds;
}

// ==================== توابع کنترل ====================

/**
 * کنترل رله‌ها در حالت نرمال
 */
void control_normal_mode(void) {
    // برق شهر به خروجی
    PORTB |= (1 << RELAY_MAIN);
    _delay_ms(TRANSFER_DELAY);
    
    // اینورتر خاموش
    PORTB &= ~(1 << RELAY_INVERTER);
    
    // اگر باتری نیاز به شارژ داشت
    if(ups_data.battery_voltage < BATTERY_FULL - 0.5) {
        PORTB |= (1 << RELAY_CHARGE);
        system_state = STATE_CHARGING;
    } else {
        PORTB &= ~(1 << RELAY_CHARGE);
    }
}

/**
 * کنترل رله‌ها در حالت باتری
 */
void control_battery_mode(void) {
    // برق شهر قطع است
    PORTB &= ~(1 << RELAY_MAIN);
    _delay_ms(TRANSFER_DELAY);
    
    // اینورتر روشن
    PORTB |= (1 << RELAY_INVERTER);
    
    // شارژر خاموش
    PORTB &= ~(1 << RELAY_CHARGE);
    
    // هشدار باتری ضعیف
    if(ups_data.battery_voltage < BATTERY_LOW) {
        PORTB |= (1 << BUZZER);
        _delay_ms(500);
        PORTB &= ~(1 << BUZZER);
    }
}

/**
 * کنترل فن خنک‌کننده
 */
void control_fan_speed(void) {
    uint8_t speed = 0;
    
    // کنترل بر اساس دما
    if(ups_data.temperature > 60) {
        speed = 255; // حداکثر سرعت
    } else if(ups_data.temperature > 50) {
        speed = 200;
    } else if(ups_data.temperature > 40) {
        speed = 150;
    } else if(ups_data.load_current > 5) {
        speed = 100;
    } else {
        speed = 50; // حداقل سرعت
    }
    
    OCR0B = speed;
}

/**
 * بررسی خطاها
 */
void check_faults(void) {
    fault_flags = 0;
    
    // خطا دمای بالا
    if(ups_data.temperature > 80) {
        fault_flags |= (1 << 0);
    }
    
    // خطا جریان زیاد
    if(ups_data.load_current > 25) {
        fault_flags |= (1 << 1);
    }
    
    // خطا ولتاژ پایین باتری
    if(ups_data.battery_voltage < BATTERY_CRITICAL) {
        fault_flags |= (1 << 2);
    }
    
    // خطا ولتاژ بالای برق شهر
    if(ups_data.grid_voltage > 260 && system_state == STATE_NORMAL) {
        fault_flags |= (1 << 3);
    }
    
    // اگر خطا وجود داشت
    if(fault_flags) {
        system_state = STATE_FAULT;
        // خاموش کردن همه رله‌ها
        PORTB &= ~((1 << RELAY_CHARGE) | (1 << RELAY_INVERTER) | (1 << RELAY_MAIN));
        // فعال کردن بیزر
        PORTB |= (1 << BUZZER);
    }
}

// ==================== وقفه‌ها ====================

/**
 * وقفه تایمر 1 (هر 10ms)
 */
ISR(TIMER1_COMPA_vect) {
    system_tick++;
    
    // هر 100ms (10 بار)
    if(system_tick % 10 == 0) {
        // شروع تبدیل ADC جدید
        adc_index = (adc_index + 1) % 4;
        ADMUX = (ADMUX & 0xF8) | (adc_index & 0x07);
        ADCSRA |= (1 << ADSC);
    }
    
    // آپدیت زمان پشتیبانی
    if(system_state == STATE_BATTERY && ups_data.backup_time > 0) {
        ups_data.backup_time--;
    }
}

/**
 * وقفه ADC
 */
ISR(ADC_vect) {
    uint8_t low = ADCL;
    uint8_t high = ADCH;
    uint16_t value = (high << 8) | low;
    
    adc_values[adc_index] = value;
}

// ==================== تابع اصلی ====================

int main(void) {
    // راه‌اندازی سخت‌افزار
    init_gpio();
    init_timer0_pwm();
    init_timer1();
    init_adc();
    
    #ifdef USE_LCD
    lcd_init();
    #endif
    
    // فعال کردن وقفه‌های جهانی
    sei();
    
    // حالت اولیه
    system_state = STATE_NORMAL;
    ups_data.backup_time = 0;
    
    // حلقه اصلی
    while(1) {
        // خواندن و محاسبه مقادیر ADC
        ups_data.battery_voltage = calculate_battery_voltage(adc_values[0]);
        ups_data.grid_voltage = calculate_grid_voltage(adc_values[1]);
        ups_data.load_current = calculate_load_current(adc_values[2]);
        ups_data.temperature = calculate_temperature(adc_values[3]);
        
        // محاسبات دیگر
        ups_data.battery_percent = calculate_battery_percent(ups_data.battery_voltage);
        
        // بررسی خطاها
        check_faults();
        
        // کنترل حالت
        if(system_state != STATE_FAULT) {
            if(ups_data.grid_voltage >= GRID_MIN) {
                // برق شهر وصل است
                system_state = STATE_NORMAL;
                control_normal_mode();
            } else {
                // برق شهر قطع است
                system_state = STATE_BATTERY;
                if(ups_data.backup_time == 0) {
                    // محاسبه زمان پشتیبانی
                    ups_data.backup_time = calculate_backup_time(
                        ups_data.battery_voltage, 
                        ups_data.load_current
                    );
                }
                control_battery_mode();
            }
        }
        
        // کنترل فن
        control_fan_speed();
        
        // آپدیت نمایشگر
        #ifdef USE_LCD
        lcd_update_display();
        #endif
        
        // تاخیر
        _delay_ms(100);
    }
    
    return 0;
}

// ==================== Makefile ====================
/*
# Makefile برای کامپایل برنامه

MCU = atmega328p
F_CPU = 16000000UL
CC = avr-gcc
OBJCOPY = avr-objcopy
CFLAGS = -mmcu=$(MCU) -DF_CPU=$(F_CPU) -Os -Wall

TARGET = ups_controller
SRC = main.c

all:
	$(CC) $(CFLAGS) -o $(TARGET).elf $(SRC)
	$(OBJCOPY) -O ihex -R .eeprom $(TARGET).elf $(TARGET).hex

flash:
	avrdude -c arduino -p $(MCU) -P /dev/ttyUSB0 -b 57600 -U flash:w:$(TARGET).hex

clean:
	rm -f *.elf *.hex
*/