[ ماژول MP1584EN ]
                ┌─────────────────┐
 EN ┤o                o├ VIN  (4.5-28V)
                │                  │
            FB ┤o                o├ GND
                │                  │
                │     MP1584EN     │
                │                  │
 GND ┤o                o├ VOUT (0.8-20V)
                └─────────────────┘

اتصالات:
• EN (Enable): فعال/غیرفعال (می‌توان به VIN وصل شود)
• FB (Feedback): فیدبک برای تنظیم ولتاژ (به VOUT متصل است)
• VIN: ورودی مثبت (4.5-28V)
• GND: زمین مشترک
• VOUT: خروجی مثبت (0.8-20V)

فرمول محاسبه ولتاژ خروجی:
Vout = 0.8V × (1 + R1/R2)

مقاومت‌های پیشنهادی:
• R2 = 10kΩ (بین FB و GND)
• R1 = مقاومت متغیر (بین VOUT و FB)

مثال: برای 5V خروجی:
5 = 0.8 × (1 + R1/10000)
R1 = 52.5kΩ

I_max = 3A (با هیت‌سینک)
I_max = 2A (بدون هیت‌سینک)

V_dropout ≈ 0.8V (حداقل اختلاف مورد نیاز)

// حداقل مقادیر پیشنهادی:
// ورودی: 47μF الکتولیتی + 0.1μF سرامیکی
// خروجی: 100μF الکتولیتی + 10μF تانتالیوم

/**
 * سیستم مانیتورینگ ولتاژ ورودی و خروجی ماژول MP1584EN
 * با هشدارهای امنیتی و محاسبه راندمان
 */

const int VIN_PIN = A0;    // اندازه‌گیری ولتاژ ورودی
const int VOUT_PIN = A1;   // اندازه‌گیری ولتاژ خروجی
const int CURRENT_PIN = A2; // سنسور جریان (اختیاری)
const int FAN_PIN = 9;     // کنترل فن خنک‌کننده (PWM)
const int ALARM_LED = 13;  // LED هشدار
const int BUZZER = 8;      // بازر هشدار

// کالیبراسیون تقسیم‌کننده ولتاژ
const float R1 = 30000.0; // مقاومت 30K
const float R2 = 7500.0;  // مقاومت 7.5K (تقسیم‌کننده 5:1)
const float VREF = 5.0;   // ولتاژ مرجع آردوینو

// محدودیت‌های ایمنی
const float VIN_MAX = 28.0;   // حداکثر ورودی مجاز
const float VIN_MIN = 4.5;    // حداقل ورودی مجاز
const float VOUT_MAX = 20.0;  // حداکثر خروجی مجاز
const float CURRENT_MAX = 3.0; // حداکثر جریان مجاز (آمپر)
const float TEMP_MAX = 85.0;  // حداکثر دمای مجاز (°C)

// متغیرهای اندازه‌گیری
float vin_voltage = 0.0;
float vout_voltage = 0.0;
float current = 0.0;
float temperature = 25.0;
float efficiency = 0.0;
float power_in = 0.0;
float power_out = 0.0;

// برای محاسبه میانگین‌گیری
const int SAMPLE_COUNT = 10;
float vin_samples[SAMPLE_COUNT];
float vout_samples[SAMPLE_COUNT];
int sample_index = 0;

void setup() {
  Serial.begin(115200);
  
  pinMode(FAN_PIN, OUTPUT);
  pinMode(ALARM_LED, OUTPUT);
  pinMode(BUZZER, OUTPUT);
  
  // غیرفعال کردن هشدارها در ابتدا
  digitalWrite(ALARM_LED, LOW);
  digitalWrite(BUZZER, LOW);
  analogWrite(FAN_PIN, 0);
  
  // مقداردهی اولیه آرایه نمونه‌ها
  for (int i = 0; i < SAMPLE_COUNT; i++) {
    vin_samples[i] = 0.0;
    vout_samples[i] = 0.0;
  }
  
  Serial.println("\n\n========================================");
  Serial.println("   MP1584EN Buck Converter Monitor");
  Serial.println("========================================");
  Serial.println("Monitoring input/output parameters...");
  Serial.println("----------------------------------------");
  Serial.println("Parameter  | Value  | Unit  | Status");
  Serial.println("-----------|--------|-------|--------");
}

void loop() {
  // خواندن ولتاژها
  readVoltages();
  
  // خواندن جریان (اگر سنسور متصل باشد)
  readCurrent();
  
  // محاسبه توان و راندمان
  calculatePowerAndEfficiency();
  
  // کنترل سیستم خنک‌کننده
  controlCoolingSystem();
  
  // بررسی شرایط ایمنی
  checkSafetyConditions();
  
  // نمایش اطلاعات
  displayStatus();
  
  // ارسال داده برای پلاتتر سریال
  sendToSerialPlotter();
  
  delay(500); // هر نیم ثانیه به‌روزرسانی
}

void readVoltages() {
  // خواندن ولتاژ ورودی
  int vin_raw = analogRead(VIN_PIN);
  float vin_at_adc = (vin_raw * VREF) / 1023.0;
  vin_voltage = vin_at_adc * (R1 + R2) / R2;
  
  // خواندن ولتاژ خروجی
  int vout_raw = analogRead(VOUT_PIN);
  float vout_at_adc = (vout_raw * VREF) / 1023.0;
  vout_voltage = vout_at_adc * (R1 + R2) / R2;
  
  // ذخیره در آرایه برای میانگین‌گیری
  vin_samples[sample_index] = vin_voltage;
  vout_samples[sample_index] = vout_voltage;
  sample_index = (sample_index + 1) % SAMPLE_COUNT;
  
  // محاسبه میانگین
  float vin_sum = 0.0, vout_sum = 0.0;
  for (int i = 0; i < SAMPLE_COUNT; i++) {
    vin_sum += vin_samples[i];
    vout_sum += vout_samples[i];
  }
  
  vin_voltage = vin_sum / SAMPLE_COUNT;
  vout_voltage = vout_sum / SAMPLE_COUNT;
}

void readCurrent() {
  // با فرض استفاده از سنسور جریان ACS712 5A
  int current_raw = analogRead(CURRENT_PIN);
  float voltage = (current_raw / 1023.0) * VREF;
  current = (voltage - 2.5) / 0.185; // حساسیت 185mV/A
  current = abs(current); // مقدار مطلق
}

void calculatePowerAndEfficiency() {
  power_in = vin_voltage * (current + 0.01); // +10mA برای مصرف خود ماژول
  power_out = vout_voltage * current;
  
  if (power_in > 0.001) { // جلوگیری از تقسیم بر صفر
    efficiency = (power_out / power_in) * 100.0;
    efficiency = constrain(efficiency, 0.0, 100.0);
  } else {
    efficiency = 0.0;
  }
}

void controlCoolingSystem() {
  // کنترل فن بر اساس جریان و ولتاژ
  int fan_speed = 0;
  
  if (current > 1.0) {
    fan_speed = map(current, 1.0, CURRENT_MAX, 100, 255);
  }
  
  // اگر دمای تخمینی بالا باشد، فن را سریع‌تر بچرخان
  float estimated_temp = 25.0 + (current * 15.0); // تخمین دما
  if (estimated_temp > 50.0) {
    fan_speed = max(fan_speed, 200);
  }
  
  analogWrite(FAN_PIN, fan_speed);
}

void checkSafetyConditions() {
  bool alarm_triggered = false;
  String alarm_message = "";
  
  // بررسی ولتاژ ورودی
  if (vin_voltage > VIN_MAX) {
    alarm_triggered = true;
    alarm_message = "INPUT OVERVOLTAGE!";
  } else if (vin_voltage < VIN_MIN) {
    alarm_triggered = true;
    alarm_message = "INPUT UNDERVOLTAGE!";
  }
  
  // بررسی ولتاژ خروجی
  if (vout_voltage > VOUT_MAX) {
    alarm_triggered = true;
    alarm_message = "OUTPUT OVERVOLTAGE!";
  }
  
  // بررسی جریان
  if (current > CURRENT_MAX) {
    alarm_triggered = true;
    alarm_message = "OVER CURRENT!";
  }
  
  // بررسی راندمان (اگر خیلی پایین باشد)
  if (efficiency < 70.0 && current > 0.5) {
    alarm_triggered = true;
    alarm_message = "LOW EFFICIENCY!";
  }
  
  // فعال کردن هشدارها
  if (alarm_triggered) {
    digitalWrite(ALARM_LED, HIGH);
    tone(BUZZER, 1000, 500);
    Serial.print("!!! ALARM: ");
    Serial.println(alarm_message);
  } else {
    digitalWrite(ALARM_LED, LOW);
    noTone(BUZZER);
  }
}

void displayStatus() {
  static unsigned long last_display = 0;
  
  if (millis() - last_display > 2000) { // هر 2 ثانیه نمایش
    Serial.print("V_in       | ");
    Serial.print(vin_voltage, 2);
    Serial.print("  | V     | ");
    Serial.println(checkVoltageStatus(vin_voltage, VIN_MIN, VIN_MAX));
    
    Serial.print("V_out      | ");
    Serial.print(vout_voltage, 2);
    Serial.print("  | V     | ");
    Serial.println(checkVoltageStatus(vout_voltage, 0.8, VOUT_MAX));
    
    Serial.print("Current    | ");
    Serial.print(current, 2);
    Serial.print("  | A     | ");
    Serial.println(checkCurrentStatus(current));
    
    Serial.print("Power In   | ");
    Serial.print(power_in, 2);
    Serial.println(" | W     |");
    
    Serial.print("Power Out  | ");
    Serial.print(power_out, 2);
    Serial.println(" | W     |");
    
    Serial.print("Efficiency | ");
    Serial.print(efficiency, 1);
    Serial.print("  | %     | ");
    Serial.println(checkEfficiencyStatus(efficiency));
    
    Serial.println("----------------------------------------");
    
    last_display = millis();
  }
}

String checkVoltageStatus(float voltage, float min, float max) {
  if (voltage < min * 1.1) return "LOW";
  if (voltage > max * 0.9) return "HIGH";
  return "OK";
}

String checkCurrentStatus(float current) {
  if (current > CURRENT_MAX * 0.8) return "HIGH";
  if (current < 0.1) return "LOW";
  return "OK";
}

String checkEfficiencyStatus(float eff) {
  if (eff > 90.0) return "EXCELLENT";
  if (eff > 80.0) return "GOOD";
  if (eff > 70.0) return "FAIR";
  return "POOR";
}

void sendToSerialPlotter() {
  // ارسال داده برای Serial Plotter آردوینو
  Serial.print("VIN:");
  Serial.print(vin_voltage);
  Serial.print(",VOUT:");
  Serial.print(vout_voltage);
  Serial.print(",CURRENT:");
  Serial.print(current);
  Serial.print(",EFFICIENCY:");
  Serial.println(efficiency);
}

/**
 * کنترل دیجیتال ولتاژ خروجی MP1584EN با DAC MCP4725
 * امکان تنظیم ولتاژ از طریق سریال یا اینترفیس گرافیکی
 */

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

Adafruit_MCP4725 dac;
const int DAC_ADDRESS = 0x60; // آدرس پیش‌فرض MCP4725

// پین‌های کنترل
const int VOUT_MONITOR = A0;  // مانیتورینگ ولتاژ خروجی
const int ENABLE_PIN = 7;     // کنترل پین Enable ماژول
const int FAN_PIN = 9;        // کنترل فن

// تنظیمات سیستم
float target_voltage = 5.0;   // ولتاژ هدف (ولت)
float current_voltage = 0.0;  // ولتاژ فعلی خوانده شده
float vout_min = 0.8;         // حداقل ولتاژ خروجی
float vout_max = 12.0;        // حداکثر ولتاژ (با توجه به ورودی)
bool output_enabled = true;   // وضعیت خروجی

// پارامترهای PID برای تنظیم دقیق
float Kp = 2.0, Ki = 0.5, Kd = 0.1;
float error = 0, last_error = 0, integral = 0, derivative = 0;
const float SAMPLE_TIME = 0.1; // زمان نمونه‌برداری (ثانیه)

// مقاومت‌های تقسیم‌کننده فیدبک
const float R_FB = 10000.0;   // مقاومت 10K از FB به GND
float R_top = 52500.0;        // مقاومت متغیر از VOUT به FB (برای 5V)

void setup() {
  Serial.begin(115200);
  Wire.begin();
  
  if (!dac.begin(DAC_ADDRESS)) {
    Serial.println("DAC MCP4725 not found!");
    while (1);
  }
  
  pinMode(ENABLE_PIN, OUTPUT);
  pinMode(FAN_PIN, OUTPUT);
  
  digitalWrite(ENABLE_PIN, HIGH); // فعال کردن ماژول
  digitalWrite(FAN_PIN, LOW);
  
  // محاسبه مقاومت مورد نیاز برای ولتاژ هدف
  calculateFeedbackResistor(target_voltage);
  
  Serial.println("\n\n========================================");
  Serial.println("   Digital Voltage Controller");
  Serial.println("   for MP1584EN Buck Converter");
  Serial.println("========================================");
  Serial.println("Commands:");
  Serial.println("  SET V[voltage] - Set output voltage");
  Serial.println("  GET            - Get current status");
  Serial.println("  ENABLE         - Enable output");
  Serial.println("  DISABLE        - Disable output");
  Serial.println("  PID P[value]   - Set P parameter");
  Serial.println("  PID I[value]   - Set I parameter");
  Serial.println("  PID D[value]   - Set D parameter");
  Serial.println("  CALIBRATE      - Calibrate system");
  Serial.println("  ?              - Show help");
  Serial.println("----------------------------------------");
  
  // تنظیم ولتاژ اولیه
  setOutputVoltage(target_voltage);
}

void loop() {
  // خواندن دستورات سریال
  checkSerialCommands();
  
  // خواندن ولتاژ خروجی واقعی
  readActualVoltage();
  
  // کنترل PID برای تنظیم دقیق
  if (output_enabled) {
    pidControl();
  }
  
  // کنترل فن خنک‌کننده
  controlFan();
  
  // نمایش وضعیت دوره‌ای
  static unsigned long last_display = 0;
  if (millis() - last_display > 1000) {
    displayStatus();
    last_display = millis();
  }
  
  delay(100);
}

void checkSerialCommands() {
  if (Serial.available()) {
    String command = Serial.readStringUntil('\n');
    command.trim();
    command.toUpperCase();
    
    if (command.startsWith("SET V")) {
      // تنظیم ولتاژ جدید
      float new_voltage = command.substring(5).toFloat();
      if (new_voltage >= vout_min && new_voltage <= vout_max) {
        target_voltage = new_voltage;
        calculateFeedbackResistor(target_voltage);
        setOutputVoltage(target_voltage);
        Serial.print("Voltage set to: ");
        Serial.print(target_voltage);
        Serial.println("V");
      } else {
        Serial.println("Error: Voltage out of range!");
      }
    }
    else if (command == "GET") {
      displayDetailedStatus();
    }
    else if (command == "ENABLE") {
      output_enabled = true;
      digitalWrite(ENABLE_PIN, HIGH);
      Serial.println("Output ENABLED");
    }
    else if (command == "DISABLE") {
      output_enabled = false;
      digitalWrite(ENABLE_PIN, LOW);
      Serial.println("Output DISABLED");
    }
    else if (command.startsWith("PID P")) {
      Kp = command.substring(5).toFloat();
      Serial.print("P parameter set to: ");
      Serial.println(Kp, 2);
    }
    else if (command.startsWith("PID I")) {
      Ki = command.substring(5).toFloat();
      Serial.print("I parameter set to: ");
      Serial.println(Ki, 2);
    }
    else if (command.startsWith("PID D")) {
      Kd = command.substring(5).toFloat();
      Serial.print("D parameter set to: ");
      Serial.println(Kd, 2);
    }
    else if (command == "CALIBRATE") {
      calibrateSystem();
    }
    else if (command == "?") {
      showHelp();
    }
  }
}

void calculateFeedbackResistor(float vout) {
  // محاسبه مقاومت مورد نیاز برای ولتاژ خروجی مشخص
  // فرمول: Vout = 0.8 * (1 + R_top / R_FB)
  R_top = ((vout / 0.8) - 1) * R_FB;
  
  Serial.print("Calculated R_top for ");
  Serial.print(vout);
  Serial.print("V: ");
  Serial.print(R_top / 1000.0, 2);
  Serial.println("KΩ");
}

void setOutputVoltage(float voltage) {
  // اینجا باید مدار DAC به تقسیم‌کننده فیدبک متصل باشد
  // در عمل، DAC ولتاژ مرجع برای مدار فیدبک را تأمین می‌کند
  
  // محاسبه مقدار DAC (0-4095 برای 0-5V)
  uint16_t dac_value = (voltage / 5.0) * 4095;
  dac_value = constrain(dac_value, 0, 4095);
  
  dac.setVoltage(dac_value, false);
  
  Serial.print("DAC set to: ");
  Serial.println(dac_value);
}

void readActualVoltage() {
  // خواندن ولتاژ واقعی خروجی
  int raw = analogRead(VOUT_MONITOR);
  current_voltage = (raw * 5.0 / 1023.0) * 5.0; // با تقسیم‌کننده 5:1
}

void pidControl() {
  // محاسبه خطا
  error = target_voltage - current_voltage;
  
  // محاسبه انتگرال
  integral += error * SAMPLE_TIME;
  integral = constrain(integral, -10.0, 10.0); // ضد Wind-up
  
  // محاسبه مشتق
  derivative = (error - last_error) / SAMPLE_TIME;
  
  // محاسبه خروجی PID
  float pid_output = (Kp * error) + (Ki * integral) + (Kd * derivative);
  
  // اعمال تصحیح به DAC
  uint16_t current_dac = dac.getVoltage();
  uint16_t new_dac = current_dac + (pid_output * 100);
  new_dac = constrain(new_dac, 0, 4095);
  
  dac.setVoltage(new_dac, false);
  
  last_error = error;
}

void controlFan() {
  // کنترل فن بر اساس ولتاژ و جریان تخمینی
  int fan_speed = 0;
  
  if (target_voltage > 5.0 || current_voltage > 5.0) {
    fan_speed = 150; // سرعت متوسط برای ولتاژهای بالا
  }
  
  // اگر خطای PID زیاد باشد (بار سنگین)، فن را سریع‌تر کن
  if (abs(error) > 0.5) {
    fan_speed = 200;
  }
  
  analogWrite(FAN_PIN, fan_speed);
}

void displayStatus() {
  Serial.print("Target: ");
  Serial.print(target_voltage, 2);
  Serial.print("V | Actual: ");
  Serial.print(current_voltage, 2);
  Serial.print("V | Error: ");
  Serial.print(error, 3);
  Serial.print("V | DAC: ");
  Serial.println(dac.getVoltage());
}

void displayDetailedStatus() {
  Serial.println("\n=== SYSTEM STATUS ===");
  Serial.print("Target Voltage: ");
  Serial.print(target_voltage, 3);
  Serial.println("V");
  
  Serial.print("Actual Voltage: ");
  Serial.print(current_voltage, 3);
  Serial.println("V");
  
  Serial.print("Voltage Error: ");
  Serial.print(error, 3);
  Serial.println("V");
  
  Serial.print("PID Parameters: P=");
  Serial.print(Kp, 2);
  Serial.print(", I=");
  Serial.print(Ki, 2);
  Serial.print(", D=");
  Serial.println(Kd, 2);
  
  Serial.print("R_top calculated: ");
  Serial.print(R_top / 1000.0, 2);
  Serial.println("KΩ");
  
  Serial.print("Output: ");
  Serial.println(output_enabled ? "ENABLED" : "DISABLED");
  
  Serial.println("====================\n");
}

void calibrateSystem() {
  Serial.println("\n=== CALIBRATION MODE ===");
  Serial.println("Connect precision voltmeter to output");
  Serial.println("Calibration steps will run automatically");
  
  float test_voltages[] = {1.0, 3.3, 5.0, 9.0, 12.0};
  int num_tests = sizeof(test_voltages) / sizeof(test_voltages[0]);
  
  digitalWrite(ENABLE_PIN, HIGH);
  delay(1000);
  
  for (int i = 0; i < num_tests; i++) {
    Serial.print("\nStep ");
    Serial.print(i + 1);
    Serial.print(": Setting ");
    Serial.print(test_voltages[i]);
    Serial.println("V");
    
    target_voltage = test_voltages[i];
    setOutputVoltage(target_voltage);
    
    Serial.println("Wait 5 seconds for stabilization...");
    delay(5000);
    
    // خواندن چند نمونه
    float sum = 0;
    for (int j = 0; j < 10; j++) {
      readActualVoltage();
      sum += current_voltage;
      delay(100);
    }
    
    float avg_voltage = sum / 10.0;
    float error_percent = ((avg_voltage - target_voltage) / target_voltage) * 100;
    
    Serial.print("Measured: ");
    Serial.print(avg_voltage, 3);
    Serial.print("V | Error: ");
    Serial.print(error_percent, 2);
    Serial.println("%");
    
    // ذخیره فاکتور تصحیح
    saveCalibrationFactor(test_voltages[i], avg_voltage);
  }
  
  Serial.println("\nCalibration complete!");
  Serial.println("=======================\n");
}

void saveCalibrationFactor(float target, float actual) {
  // ذخیره فاکتورهای کالیبراسیون در EEPROM
  // اینجا فقط نمایش داده می‌شود
  float correction_factor = target / actual;
  
  Serial.print("Correction factor for ");
  Serial.print(target, 1);
  Serial.print("V: ");
  Serial.println(correction_factor, 4);
}

void showHelp() {
  Serial.println("\n=== DIGITAL VOLTAGE CONTROLLER ===");
  Serial.println("This system allows precise digital control");
  Serial.println("of MP1584EN buck converter output voltage.");
  Serial.println();
  Serial.println("Hardware Setup:");
  Serial.println("1. Connect DAC MCP4725 to Arduino I2C");
  Serial.println("2. DAC output to feedback circuit");
  Serial.println("3. Voltage divider for monitoring");
  Serial.println("4. Fan for cooling");
  Serial.println();
  Serial.println("Operation:");
  Serial.println("- PID controller maintains precise output");
  Serial.println("- Auto-calibration for accuracy");
  Serial.println("- Over-voltage/current protection");
  Serial.println("- Thermal management");
  Serial.println("==============================\n");
}

// حداقل خنک‌کاری مورد نیاز:
if (I_out > 1A) {
  // هیت‌سینک 20×20mm روی تراشه
}

if (I_out > 2A) {
  // هیت‌سینک + فن 5V
}

if (I_out > 2.5A) {
  // هیت‌سینک + فن 12V + خمیر حرارتی
}

// کنترل از طریق اپ موبایل + ذخیره پروفایل‌ها

// CC/CV charging با مانیتورینگ دما

// کنترل جریان ثابت برای LEDهای 10W+

// چند خروجی با سنکرون‌سازی

// MPPT کنترلر با راندمان بالا