ماژول درایور MOSFET (IRF520)

آردوینو → ماژول MOSFET → بار
D9 (PWM) → SIG     بار مثبت → OUT+
5V → VCC          بار منفی → OUT-
GND → GND         منبع بار → V+ و V-

/*
 * کنترل ساده روشن/خاموش بار با MOSFET IRF520
 * اتصال: پایه SIG ماژول به D9 آردوینو
 */

const int mosfetPin = 9;      // پایه کنترل MOSFET
const int buttonPin = 2;      // پایه دکمه (اختیاری)
const int ledPin = 13;        // LED داخلی آردوینو

bool loadState = false;       // وضعیت فعلی بار
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50;

void setup() {
  Serial.begin(9600);
  pinMode(mosfetPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);
  
  // ابتدا بار خاموش است
  digitalWrite(mosfetPin, LOW);
  digitalWrite(ledPin, LOW);
  
  Serial.println("==================================");
  Serial.println("   MOSFET Driver Basic Control");
  Serial.println("==================================");
  Serial.println("Press button to toggle load");
  Serial.println();
}

void loop() {
  // خواندن وضعیت دکمه
  int buttonState = digitalRead(buttonPin);
  
  // تشخیص فشرده شدن دکمه با Debouncing
  if (buttonState == LOW) {
    if ((millis() - lastDebounceTime) > debounceDelay) {
      // تغییر وضعیت بار
      loadState = !loadState;
      digitalWrite(mosfetPin, loadState ? HIGH : LOW);
      digitalWrite(ledPin, loadState ? HIGH : LOW);
      
      Serial.print("Load turned ");
      Serial.println(loadState ? "ON" : "OFF");
      
      lastDebounceTime = millis();
    }
  }
  
  // ایمنی: خاموش کردن خودکار پس از 10 ثانیه
  if (loadState && (millis() - lastDebounceTime > 10000)) {
    loadState = false;
    digitalWrite(mosfetPin, LOW);
    digitalWrite(ledPin, LOW);
    Serial.println("Auto shutdown after 10 seconds");
  }
  
  delay(10);
}

/*
 * کنترل سرعت موتور DC با PWM با استفاده از MOSFET IRF520
 * اتصال: پایه SIG ماژول به پایه PWM آردوینو (D3, D5, D6, D9, D10, D11)
 */

const int mosfetPwmPin = 9;    // پایه PWM برای کنترل MOSFET
const int potPin = A0;         // پتانسیومتر برای تنظیم سرعت
const int currentPin = A1;     // سنسور جریان (اختیاری)
const int enablePin = 2;       // دکمه Enable/Disable
const int directionPin = 3;    // تغییر جهت موتور (با H-Bridge)

int pwmValue = 0;              // مقدار PWM (0-255)
int potValue = 0;              // مقدار پتانسیومتر
int motorSpeed = 0;            // سرعت موتور بر حسب درصد
bool motorEnabled = true;      // وضعیت فعال بودن موتور
float current = 0.0;           // جریان مصرفی

// محدودیت‌های ایمنی
const int MAX_CURRENT = 5000;  // حداکثر جریان مجاز (mA)
const int MAX_PWM = 230;       // حداکثر PWM برای جلوگیری از اضافه بار

void setup() {
  Serial.begin(115200);
  pinMode(mosfetPwmPin, OUTPUT);
  pinMode(enablePin, INPUT_PULLUP);
  pinMode(directionPin, INPUT_PULLUP);
  
  // PWM با فرکانس بالاتر برای موتورها (31.25kHz)
  // فقط روی پایه‌های 9 و 10 آردوینو Uno کار می‌کند
  TCCR1B = (TCCR1B & 0b11111000) | 0x01;
  
  Serial.println("==================================");
  Serial.println("   DC Motor Speed Controller");
  Serial.println("   Using MOSFET IRF520 Module");
  Serial.println("==================================");
  Serial.println("Commands:");
  Serial.println("  + : Increase speed by 10%");
  Serial.println("  - : Decrease speed by 10%");
  Serial.println("  s : Stop motor");
  Serial.println("  f : Full speed");
  Serial.println();
}

void loop() {
  // خواندن پتانسیومتر برای کنترل دستی
  potValue = analogRead(potPin);
  pwmValue = map(potValue, 0, 1023, 0, MAX_PWM);
  
  // کنترل با کیبورد (از Serial Monitor)
  if (Serial.available()) {
    char command = Serial.read();
    handleCommand(command);
  }
  
  // خواندن دکمه Enable
  if (digitalRead(enablePin) == LOW) {
    motorEnabled = !motorEnabled;
    delay(300); // Debouncing
    Serial.print("Motor ");
    Serial.println(motorEnabled ? "ENABLED" : "DISABLED");
  }
  
  // اعمال PWM اگر موتور فعال است
  if (motorEnabled) {
    analogWrite(mosfetPwmPin, pwmValue);
  } else {
    analogWrite(mosfetPwmPin, 0);
  }
  
  // محاسبه سرعت بر حسب درصد
  motorSpeed = map(pwmValue, 0, 255, 0, 100);
  
  // خواندن جریان (اگر سنسور متصل باشد)
  current = readCurrent();
  
  // نمایش اطلاعات
  static unsigned long lastDisplay = 0;
  if (millis() - lastDisplay > 500) {
    displayStatus();
    lastDisplay = millis();
  }
  
  // حفاظت در برابر اضافه جریان
  if (current > MAX_CURRENT) {
    emergencyShutdown();
  }
  
  delay(20);
}

void handleCommand(char cmd) {
  switch (cmd) {
    case '+':
      pwmValue = constrain(pwmValue + 25, 0, MAX_PWM);
      break;
    case '-':
      pwmValue = constrain(pwmValue - 25, 0, MAX_PWM);
      break;
    case 's':
    case 'S':
      pwmValue = 0;
      break;
    case 'f':
    case 'F':
      pwmValue = MAX_PWM;
      break;
    case '?':
      displayHelp();
      break;
  }
}

float readCurrent() {
  // با فرض استفاده از سنسور جریان ACS712 5A
  int rawValue = analogRead(currentPin);
  float voltage = (rawValue / 1023.0) * 5.0;
  float current = (voltage - 2.5) / 0.185; // حساسیت 185mV/A برای ACS712 5A
  return abs(current) * 1000; // بازگشت بر حسب mA
}

void displayStatus() {
  Serial.print("PWM: ");
  Serial.print(pwmValue);
  Serial.print(" (");
  Serial.print(motorSpeed);
  Serial.print("%) | Current: ");
  Serial.print(current, 0);
  Serial.print("mA | Status: ");
  Serial.println(motorEnabled ? "RUNNING" : "STOPPED");
}

void displayHelp() {
  Serial.println();
  Serial.println("=== Help ===");
  Serial.println("Control DC motor speed using MOSFET IRF520");
  Serial.println("PWM Frequency: 31.25kHz");
  Serial.println("Max Current: 5A (with current sensor)");
  Serial.println("Max Voltage: 24V (recommended)");
  Serial.println("=============");
}

void emergencyShutdown() {
  Serial.println("!!! OVERCURRENT DETECTED !!!");
  Serial.println("EMERGENCY SHUTDOWN");
  
  analogWrite(mosfetPwmPin, 0);
  motorEnabled = false;
  
  // بوق هشدار
  for (int i = 0; i < 5; i++) {
    tone(8, 2000, 200);
    delay(300);
  }
  
  // منتظر ریست دستی
  while (true) {
    if (Serial.available()) {
      char c = Serial.read();
      if (c == 'r' || c == 'R') {
        Serial.println("System reset");
        break;
      }
    }
    delay(100);
  }
}

/*
 * کنترل دمای PID با استفاده از MOSFET IRF520
 * برای کنترل المنت گرمایی یا هیتر
 */

#include <PID_v1.h>

// پایه‌ها
const int mosfetPin = 9;          // پایه PWM کنترل MOSFET
const int tempPin = A0;           // سنسور دما (NTC یا thermocouple)
const int setpointPin = A1;       // پتانسیومتر تنظیم دما

// پارامترهای PID
double Setpoint, Input, Output;
double Kp = 2.0, Ki = 5.0, Kd = 1.0;
PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);

// تنظیمات سیستم
const int PWM_FREQ = 5000;        // فرکانس PWM برای کنترل دمای بهتر
const int TEMP_SAMPLES = 10;      // تعداد نمونه‌ها برای میانگین‌گیری دما
const int WINDOW_SIZE = 5000;     // پنجره زمانی برای PID
unsigned long windowStartTime;

// متغیرهای نظارت
float currentTemp = 0;
float maxTemp = 0;
unsigned long heatingTime = 0;
bool systemActive = true;

void setup() {
  Serial.begin(115200);
  
  // تنظیم پایه‌ها
  pinMode(mosfetPin, OUTPUT);
  
  // تنظیم فرکانس PWM بالاتر (31.25kHz روی پایه 9)
  TCCR1B = (TCCR1B & 0b11111000) | 0x01;
  
  // مقداردهی اولیه PID
  Setpoint = 50.0; // دمای هدف اولیه (درجه سانتی‌گراد)
  myPID.SetMode(AUTOMATIC);
  myPID.SetOutputLimits(0, 255);
  myPID.SetSampleTime(1000); // زمان نمونه‌برداری 1 ثانیه
  
  windowStartTime = millis();
  
  Serial.println("==================================");
  Serial.println("   PID Temperature Controller");
  Serial.println("   Using MOSFET IRF520 Module");
  Serial.println("==================================");
  Serial.println("T: Current Temperature");
  Serial.println("S: Setpoint Temperature");
  Serial.println("P: PID Output (0-255)");
  Serial.println("C: Heater Current (%)");
  Serial.println();
}

void loop() {
  // خواندن دمای تنظیم‌شده از پتانسیومتر
  int setpointRaw = analogRead(setpointPin);
  Setpoint = map(setpointRaw, 0, 1023, 25, 150); // محدوده 25-150°C
  
  // خواندن دمای فعلی
  currentTemp = readTemperature();
  
  // به‌روزرسانی ورودی PID
  Input = currentTemp;
  
  // محاسبه خروجی PID
  myPID.Compute();
  
  // اعمال PWM با روش زمان-تناسب
  unsigned long now = millis();
  if (now - windowStartTime > WINDOW_SIZE) {
    windowStartTime += WINDOW_SIZE;
  }
  
  if (Output > (now - windowStartTime)) {
    digitalWrite(mosfetPin, HIGH);
  } else {
    digitalWrite(mosfetPin, LOW);
  }
  
  // برای تست: استفاده مستقیم از PWM
  // analogWrite(mosfetPin, Output);
  
  // نظارت و ثبت داده
  monitorSystem();
  
  // کنترل با کیبورد
  if (Serial.available()) {
    handleSerialCommands();
  }
  
  // ایمنی: بررسی دمای بیش از حد
  if (currentTemp > 200) {
    emergencyShutdown();
  }
  
  delay(100);
}

float readTemperature() {
  // با فرض استفاده از ترمیستور NTC 10K
  int rawValue = 0;
  
  // میانگین‌گیری برای کاهش نویز
  for (int i = 0; i < TEMP_SAMPLES; i++) {
    rawValue += analogRead(tempPin);
    delay(10);
  }
  rawValue /= TEMP_SAMPLES;
  
  // تبدیل آنالوگ به مقاومت
  float resistance = 10000.0 / (1023.0 / rawValue - 1);
  
  // تبدیل مقاومت به دما (معادله Steinhart-Hart)
  float steinhart;
  steinhart = resistance / 10000.0;          // (R/R0)
  steinhart = log(steinhart);                // ln(R/R0)
  steinhart /= 3950.0;                       // 1/B * ln(R/R0)
  steinhart += 1.0 / (25.0 + 273.15);        // + (1/T0)
  steinhart = 1.0 / steinhart;               // معکوس
  steinhart -= 273.15;                       // کلوین به سلسیوس
  
  return steinhart;
}

void monitorSystem() {
  static unsigned long lastReport = 0;
  
  if (millis() - lastReport > 2000) {
    float heaterPercent = (Output / 255.0) * 100.0;
    
    Serial.print("T:");
    Serial.print(currentTemp, 1);
    Serial.print("°C\tS:");
    Serial.print(Setpoint, 1);
    Serial.print("°C\tP:");
    Serial.print(Output, 0);
    Serial.print("\tC:");
    Serial.print(heaterPercent, 1);
    Serial.print("%\tState:");
    Serial.println(systemActive ? "ON" : "OFF");
    
    // به‌روزرسانی حداکثر دما
    if (currentTemp > maxTemp) {
      maxTemp = currentTemp;
    }
    
    // محاسبه زمان گرمایش
    if (heaterPercent > 10) {
      heatingTime += 2000;
    }
    
    lastReport = millis();
  }
}

void handleSerialCommands() {
  char cmd = Serial.read();
  
  switch (cmd) {
    case '+':
      Setpoint += 5.0;
      Serial.print("Setpoint increased to: ");
      Serial.println(Setpoint, 1);
      break;
      
    case '-':
      Setpoint -= 5.0;
      Serial.print("Setpoint decreased to: ");
      Serial.println(Setpoint, 1);
      break;
      
    case 'p':
      // تنظیم پارامتر P
      Kp = Serial.parseFloat();
      myPID.SetTunings(Kp, Ki, Kd);
      Serial.print("Kp set to: ");
      Serial.println(Kp, 2);
      break;
      
    case 'i':
      // تنظیم پارامتر I
      Ki = Serial.parseFloat();
      myPID.SetTunings(Kp, Ki, Kd);
      Serial.print("Ki set to: ");
      Serial.println(Ki, 2);
      break;
      
    case 'd':
      // تنظیم پارامتر D
      Kd = Serial.parseFloat();
      myPID.SetTunings(Kp, Ki, Kd);
      Serial.print("Kd set to: ");
      Serial.println(Kd, 2);
      break;
      
    case 's':
    case 'S':
      systemActive = !systemActive;
      if (!systemActive) {
        analogWrite(mosfetPin, 0);
      }
      Serial.print("System ");
      Serial.println(systemActive ? "activated" : "deactivated");
      break;
      
    case '?':
      displayPIDStatus();
      break;
  }
}

void displayPIDStatus() {
  Serial.println();
  Serial.println("=== PID Controller Status ===");
  Serial.print("Kp: "); Serial.println(Kp, 2);
  Serial.print("Ki: "); Serial.println(Ki, 2);
  Serial.print("Kd: "); Serial.println(Kd, 2);
  Serial.print("Max Temp: "); Serial.print(maxTemp, 1); Serial.println("°C");
  Serial.print("Heating Time: "); Serial.print(heatingTime / 60000.0, 1); Serial.println(" minutes");
  Serial.print("Current PWM Freq: "); Serial.print(PWM_FREQ); Serial.println("Hz");
  Serial.println("=============================");
}

void emergencyShutdown() {
  Serial.println("!!! OVERHEAT DETECTED !!!");
  Serial.println("EMERGENCY SHUTDOWN INITIATED");
  
  analogWrite(mosfetPin, 0);
  systemActive = false;
  
  for (int i = 0; i < 10; i++) {
    Serial.println("OVERHEAT - SYSTEM SHUTDOWN");
    delay(1000);
  }
}

// فرمول محاسبه دمای Junction
T_junction = T_ambient + (P_loss × R_θJA)

// برای IRF520 با هیت‌سینک:
R_θJA = 62°C/W (بدون هیت‌سینک)
R_θJA = 5-10°C/W (با هیت‌سینک مناسب)

// مثال: جریان 5A در 12V
P_loss = 5² × 0.27 = 6.75W
T_junction = 25°C + (6.75 × 62) = 443.5°C // بسیار خطرناک!
T_junction = 25°C + (6.75 × 8) = 79°C // قابل قبول با هیت‌سینک

// کنترل موتور پله‌ای با درایور MOSFET
// نیاز به 4 کانال MOSFET برای کنترل کامل

// ساخت منبع تغذیه 5-30V با کنترل PWM

// دیم‌کردن LED‌های پرقدرت با فرکانس بالا

// کنترل پالس‌های کوتاه با جریان بالا برای سلونوئید

// کنترل جریان شارژ با MOSFET و PWM

// برای پایه 9 و 10:
TCCR1B = (TCCR1B & 0b11111000) | 0x01; // 31.25kHz
TCCR1B = (TCCR1B & 0b11111000) | 0x02; // 3.9kHz
TCCR1B = (TCCR1B & 0b11111000) | 0x03; // 976Hz