ماژول پتانسیومتر  آنالوگ

پتانسیومتر → آردوینو
-------------------
پایه 1 (چپ) → GND
پایه 2 (وسط) → A0 (ورودی آنالوگ)
پایه 3 (راست) → 5V

ماژول پتانسیومتر → آردوینو
-------------------------
VCC → 5V یا 3.3V
GND → GND
SIG → A0 (آنالوگ)
PWM → D3 (دیجیتال PWM - اختیاری)

/*
 * خواندن مقدار پتانسیومتر و نمایش در سریال مانیتور
 * اتصال: پایه وسط پتانسیومتر به A0
 */

const int potPin = A0;          // پایه اتصال پتانسیومتر
int potValue = 0;               // مقدار خام خوانده شده (0-1023)
float voltage = 0.0;           // ولتاژ محاسبه‌شده
int percentage = 0;            // درصد چرخش

// برای نمایش گرافیکی
const int graphWidth = 40;     // عرض نمودار در سریال مانیتور

void setup() {
  Serial.begin(9600);
  Serial.println("==================================");
  Serial.println("   Potentiometer Basic Read");
  Serial.println("==================================");
  Serial.println("Position | Value | Voltage | %");
  Serial.println("---------|-------|---------|---");
}

void loop() {
  // خواندن مقدار آنالوگ
  potValue = analogRead(potPin);
  
  // محاسبه ولتاژ (با فرض VCC = 5V)
  voltage = potValue * (5.0 / 1023.0);
  
  // محاسبه درصد
  percentage = map(potValue, 0, 1023, 0, 100);
  
  // نمایش مقادیر
  Serial.print("   ");
  Serial.print(percentage);
  Serial.print("%   | ");
  Serial.print(potValue);
  Serial.print("   | ");
  Serial.print(voltage, 2);
  Serial.print("V  | ");
  
  // نمایش گرافیکی
  int barLength = map(potValue, 0, 1023, 0, graphWidth);
  for (int i = 0; i < graphWidth; i++) {
    if (i < barLength) {
      Serial.print("█");
    } else {
      Serial.print(" ");
    }
  }
  Serial.println("|");
  
  delay(100); // تأخیر 100ms بین خواندن‌ها
}

/*
 * کنترل موقعیت سروو موتور با پتانسیومتر
 * اتصال: پتانسیومتر به A0، سروو به D9
 */

#include <Servo.h>

const int potPin = A0;          // پایه پتانسیومتر
const int servoPin = 9;         // پایه سروو موتور

Servo myServo;                  // ایجاد شیء سروو
int potValue;                   // مقدار پتانسیومتر
int servoAngle;                 // زاویه سروو (0-180 درجه)
int lastServoAngle = -1;        // زاویه قبلی برای جلوگیری از ارسال تکراری

void setup() {
  Serial.begin(9600);
  myServo.attach(servoPin);     // اتصال سروو به پایه
  
  Serial.println("==================================");
  Serial.println("   Servo Motor Control with Pot");
  Serial.println("==================================");
  Serial.println("Pot Value | Servo Angle");
  Serial.println("----------|------------");
}

void loop() {
  // خواندن پتانسیومتر
  potValue = analogRead(potPin);
  
  // تبدیل به زاویه سروو (0-180 درجه)
  servoAngle = map(potValue, 0, 1023, 0, 180);
  
  // فقط اگر زاویه تغییر کرده باشد، سروو را حرکت ده
  if (abs(servoAngle - lastServoAngle) > 1) { // آستانه 1 درجه
    myServo.write(servoAngle);
    lastServoAngle = servoAngle;
    
    // نمایش اطلاعات
    Serial.print("   ");
    Serial.print(potValue);
    Serial.print("     |    ");
    Serial.print(servoAngle);
    Serial.println("°");
  }
  
  delay(15); // تأخیر مناسب برای سروو
}

/*
 * کنترل رنگ LED RGB با سه پتانسیومتر
 * هر پتانسیومتر کنترل یک رنگ: قرمز، سبز، آبی
 */

const int potRed = A0;      // پتانسیومتر رنگ قرمز
const int potGreen = A1;    // پتانسیومتر رنگ سبز
const int potBlue = A2;     // پتانسیومتر رنگ آبی

const int ledRed = 9;       // پایه PWM برای LED قرمز
const int ledGreen = 10;    // پایه PWM برای LED سبز
const int ledBlue = 11;     // پایه PWM برای LED آبی

int redValue, greenValue, blueValue;      // مقادیر PWM (0-255)
int redPot, greenPot, bluePot;            // مقادیر پتانسیومترها (0-1023)

void setup() {
  Serial.begin(9600);
  
  // تنظیم پایه‌های LED به عنوان خروجی PWM
  pinMode(ledRed, OUTPUT);
  pinMode(ledGreen, OUTPUT);
  pinMode(ledBlue, OUTPUT);
  
  Serial.println("=========================================");
  Serial.println("   RGB Color Mixer with 3 Potentiometers");
  Serial.println("=========================================");
  Serial.println("R   G   B   | Color Preview");
  Serial.println("--- --- --- | -----------------");
}

void loop() {
  // خواندن مقادیر پتانسیومترها
  redPot = analogRead(potRed);
  greenPot = analogRead(potGreen);
  bluePot = analogRead(potBlue);
  
  // تبدیل به مقادیر PWM
  redValue = map(redPot, 0, 1023, 0, 255);
  greenValue = map(greenPot, 0, 1023, 0, 255);
  blueValue = map(bluePot, 0, 1023, 0, 255);
  
  // اعمال رنگ به LED RGB
  analogWrite(ledRed, redValue);
  analogWrite(ledGreen, greenValue);
  analogWrite(ledBlue, blueValue);
  
  // نمایش مقادیر و پیش‌نمایش رنگ
  displayColorInfo();
  
  delay(100);
}

void displayColorInfo() {
  // نمایش مقادیر RGB
  Serial.print(redValue);
  if (redValue < 100) Serial.print(" ");
  if (redValue < 10) Serial.print(" ");
  
  Serial.print(" ");
  Serial.print(greenValue);
  if (greenValue < 100) Serial.print(" ");
  if (greenValue < 10) Serial.print(" ");
  
  Serial.print(" ");
  Serial.print(blueValue);
  if (blueValue < 100) Serial.print(" ");
  if (blueValue < 10) Serial.print(" ");
  
  Serial.print(" | ");
  
  // پیش‌نمایش متنی رنگ
  if (redValue > 200 && greenValue < 50 && blueValue < 50) {
    Serial.print("RED        ");
  } else if (redValue < 50 && greenValue > 200 && blueValue < 50) {
    Serial.print("GREEN      ");
  } else if (redValue < 50 && greenValue < 50 && blueValue > 200) {
    Serial.print("BLUE       ");
  } else if (redValue > 200 && greenValue > 200 && blueValue < 50) {
    Serial.print("YELLOW     ");
  } else if (redValue > 200 && greenValue < 50 && blueValue > 200) {
    Serial.print("MAGENTA    ");
  } else if (redValue < 50 && greenValue > 200 && blueValue > 200) {
    Serial.print("CYAN       ");
  } else if (redValue > 200 && greenValue > 200 && blueValue > 200) {
    Serial.print("WHITE      ");
  } else if (redValue < 50 && greenValue < 50 && blueValue < 50) {
    Serial.print("BLACK      ");
  } else {
    Serial.print("CUSTOM     ");
  }
  
  // نمایش کد هگز رنگ
  Serial.print(" #");
  printHex(redValue);
  printHex(greenValue);
  printHex(blueValue);
  
  Serial.println();
}

void printHex(int value) {
  if (value < 16) Serial.print("0");
  Serial.print(value, HEX);
}

/*
 * سیستم تنظیم پارامترهای PID با 3 پتانسیومتر
 * هر پتانسیومتر کنترل یکی از پارامترهای Kp, Ki, Kd
 */

#include <PID_v1.h>

// پایه‌های پتانسیومترها
const int potKp = A0;    // پتانسیومتر تنظیم Kp
const int potKi = A1;    // پتانسیومتر تنظیم Ki
const int potKd = A2;    // پتانسیومتر تنظیم Kd
const int potSetpoint = A3; // پتانسیومتر تنظیم Setpoint

// پایه‌های نمایشگر LCD (اختیاری)
const int displayUpdateButton = 2; // دکمه به‌روزرسانی نمایش

// متغیرهای PID
double Setpoint, Input, Output;
double Kp, Ki, Kd;
PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);

// محدوده تنظیم پارامترها
const double Kp_min = 0.0, Kp_max = 10.0;
const double Ki_min = 0.0, Ki_max = 5.0;
const double Kd_min = 0.0, Kd_max = 2.0;
const double Setpoint_min = 0.0, Setpoint_max = 100.0;

// متغیرهای نمایش
unsigned long lastDisplayUpdate = 0;
const unsigned long displayInterval = 500; // هر 500ms به‌روزرسانی شود

void setup() {
  Serial.begin(115200);
  pinMode(displayUpdateButton, INPUT_PULLUP);
  
  // مقداردهی اولیه PID
  Setpoint = 50.0;
  Input = 0.0;
  Kp = 2.0;
  Ki = 0.5;
  Kd = 0.1;
  
  myPID.SetMode(AUTOMATIC);
  myPID.SetOutputLimits(0, 255);
  
  Serial.println("========================================");
  Serial.println("   PID Parameter Tuning with Pots");
  Serial.println("========================================");
  Serial.println("Kp\tKi\tKd\tSetpoint");
  Serial.println("---\t---\t---\t--------");
}

void loop() {
  // خواندن مقادیر پتانسیومترها
  readPotentiometers();
  
  // به‌روزرسانی پارامترهای PID
  updatePIDParameters();
  
  // شبیه‌سازی فرآیند (در پروژه واقعی اینجا سنسور خوانده می‌شود)
  simulateProcess();
  
  // محاسبه PID
  myPID.Compute();
  
  // اعمال خروجی به فرآیند (در پروژه واقعی به actuator می‌رود)
  applyOutput();
  
  // نمایش دوره‌ای پارامترها
  updateDisplay();
  
  delay(20);
}

void readPotentiometers() {
  static int lastPotKp = -1, lastPotKi = -1, lastPotKd = -1, lastPotSp = -1;
  static unsigned long lastReadTime = 0;
  
  // کاهش نرخ خواندن برای کاهش نویز
  if (millis() - lastReadTime > 50) {
    int potKpValue = analogRead(potKp);
    int potKiValue = analogRead(potKi);
    int potKdValue = analogRead(potKd);
    int potSpValue = analogRead(potSetpoint);
    
    // میانگین‌گیری برای کاهش نویز
    potKpValue = (potKpValue + lastPotKp) / 2;
    potKiValue = (potKiValue + lastPotKi) / 2;
    potKdValue = (potKdValue + lastPotKd) / 2;
    potSpValue = (potSpValue + lastPotSp) / 2;
    
    // ذخیره برای دفعه بعد
    lastPotKp = potKpValue;
    lastPotKi = potKiValue;
    lastPotKd = potKdValue;
    lastPotSp = potSpValue;
    
    // تبدیل به مقادیر واقعی
    Kp = mapFloat(potKpValue, 0, 1023, Kp_min, Kp_max);
    Ki = mapFloat(potKiValue, 0, 1023, Ki_min, Ki_max);
    Kd = mapFloat(potKdValue, 0, 1023, Kd_min, Kd_max);
    Setpoint = mapFloat(potSpValue, 0, 1023, Setpoint_min, Setpoint_max);
    
    lastReadTime = millis();
  }
}

float mapFloat(long x, long in_min, long in_max, float out_min, float out_max) {
  return (x - in_min) * (out_max - out_min) / (float)(in_max - in_min) + out_min;
}

void updatePIDParameters() {
  myPID.SetTunings(Kp, Ki, Kd);
}

void simulateProcess() {
  // شبیه‌سازی یک فرآیند درجه اول
  // در پروژه واقعی باید از سنسور خوانده شود
  static float processValue = 0;
  const float timeConstant = 2.0; // ثابت زمانی فرآیند
  const float sampleTime = 0.02; // زمان نمونه‌برداری 20ms
  
  processValue += (Output - processValue) * sampleTime / timeConstant;
  Input = processValue;
}

void applyOutput() {
  // در پروژه واقعی: فعال‌سازی actuator
  // مثلاً: analogWrite(heaterPin, Output);
  
  // برای نمایش:
  static int lastOutput = -1;
  if (abs(Output - lastOutput) > 1) {
    lastOutput = Output;
    // می‌توانید اینجا خروجی را به پین PWM اعمال کنید
  }
}

void updateDisplay() {
  // به‌روزرسانی نمایش در سریال مانیتور
  if (millis() - lastDisplayUpdate > displayInterval) {
    Serial.print(Kp, 2);
    Serial.print("\t");
    Serial.print(Ki, 2);
    Serial.print("\t");
    Serial.print(Kd, 2);
    Serial.print("\t");
    Serial.print(Setpoint, 1);
    Serial.print("\t| Output: ");
    Serial.print(Output, 0);
    Serial.print(" | PV: ");
    Serial.print(Input, 1);
    Serial.println();
    
    lastDisplayUpdate = millis();
  }
  
  // اگر دکمه فشرده شد، نمایش کامل
  if (digitalRead(displayUpdateButton) == LOW) {
    displayFullInfo();
    delay(300); // Debouncing
  }
}

void displayFullInfo() {
  Serial.println();
  Serial.println("=== CURRENT PID PARAMETERS ===");
  Serial.print("Kp (Proportional): ");
  Serial.println(Kp, 3);
  Serial.print("Ki (Integral):     ");
  Serial.println(Ki, 3);
  Serial.print("Kd (Derivative):   ");
  Serial.println(Kd, 3);
  Serial.print("Setpoint:          ");
  Serial.println(Setpoint, 1);
  Serial.print("Process Value:     ");
  Serial.println(Input, 1);
  Serial.print("Control Output:    ");
  Serial.println(Output, 0);
  Serial.println("===============================");
  Serial.println();
}

/*
 * ولتمتر دیجیتال با قابلیت کالیبراسیون با پتانسیومتر
 * پتانسیومتر برای تنظیم offset و gain استفاده می‌شود
 */

const int voltagePin = A0;        // ورودی ولتاژ مورد اندازه‌گیری
const int calibOffsetPin = A1;    // پتانسیومتر کالیبراسیون offset
const int calibGainPin = A2;      // پتانسیومتر کالیبراسیون gain
const int modeButton = 2;         // دکمه تغییر حالت

// متغیرهای کالیبراسیون
float calibOffset = 0.0;          // تصحیح offset
float calibGain = 1.0;            // تصحیح gain

// حالت‌های عملکرد
enum Mode { MEASURE, CALIB_OFFSET, CALIB_GAIN };
Mode currentMode = MEASURE;

// ولتاژ مرجع داخلی آردوینو (می‌تواند 1.1V یا 5V باشد)
const float vRef = 5.0;
const int adcResolution = 1023;

// برای نمایش 7-Segment (اختیاری)
const int digitPins[] = {3, 4, 5, 6};      // پایه‌های انتخاب رقم
const int segmentPins[] = {7, 8, 9, 10, 11, 12, 13}; // پایه‌های segments

void setup() {
  Serial.begin(9600);
  pinMode(modeButton, INPUT_PULLUP);
  
  Serial.println("==================================");
  Serial.println("   Digital Voltmeter with Calibration");
  Serial.println("==================================");
  Serial.println("Modes: M=Measure, O=Offset Calib, G=Gain Calib");
  Serial.println("Press button to change mode");
  Serial.println();
}

void loop() {
  // بررسی دکمه تغییر حالت
  checkModeButton();
  
  // اجرای عملکرد بر اساس حالت فعلی
  switch (currentMode) {
    case MEASURE:
      measureVoltage();
      break;
    case CALIB_OFFSET:
      calibrateOffset();
      break;
    case CALIB_GAIN:
      calibrateGain();
      break;
  }
  
  delay(100);
}

void checkModeButton() {
  static unsigned long lastPress = 0;
  
  if (digitalRead(modeButton) == LOW && millis() - lastPress > 300) {
    // تغییر حالت چرخشی
    currentMode = static_cast<Mode>((currentMode + 1) % 3);
    lastPress = millis();
    
    Serial.print("Mode changed to: ");
    switch (currentMode) {
      case MEASURE: Serial.println("MEASUREMENT"); break;
      case CALIB_OFFSET: Serial.println("OFFSET CALIBRATION"); break;
      case CALIB_GAIN: Serial.println("GAIN CALIBRATION"); break;
    }
  }
}

void measureVoltage() {
  // خواندن ولتاژ ورودی
  int rawValue = analogRead(voltagePin);
  
  // اعمال کالیبراسیون
  float voltage = (rawValue * (vRef / adcResolution) + calibOffset) * calibGain;
  
  // نمایش نتیجه
  static unsigned long lastDisplay = 0;
  if (millis() - lastDisplay > 500) {
    Serial.print("Voltage: ");
    Serial.print(voltage, 3);
    Serial.print("V | Raw: ");
    Serial.print(rawValue);
    Serial.print(" | Offset: ");
    Serial.print(calibOffset, 3);
    Serial.print(" | Gain: ");
    Serial.print(calibGain, 3);
    Serial.println();
    
    // همچنین می‌توانید روی LCD نمایش دهید
    // displayOnLCD(voltage);
    
    lastDisplay = millis();
  }
}

void calibrateOffset() {
  // خواندن پتانسیومتر offset
  int potValue = analogRead(calibOffsetPin);
  
  // تبدیل به محدوده offset (مثلاً -1V تا +1V)
  calibOffset = map(potValue, 0, 1023, -1000, 1000) / 1000.0;
  
  // نمایش وضعیت کالیبراسیون
  static unsigned long lastDisplay = 0;
  if (millis() - lastDisplay > 300) {
    Serial.print("Offset Calibration: ");
    Serial.print(calibOffset, 3);
    Serial.print("V | Pot: ");
    Serial.print(potValue);
    
    // نمایش گرافیکی
    Serial.print(" | [");
    int barPos = map(potValue, 0, 1023, 0, 20);
    for (int i = 0; i < 20; i++) {
      if (i == 10) Serial.print("|");
      else if (i == barPos) Serial.print("█");
      else Serial.print(" ");
    }
    Serial.println("]");
    
    lastDisplay = millis();
  }
}

void calibrateGain() {
  // خواندن پتانسیومتر gain
  int potValue = analogRead(calibGainPin);
  
  // تبدیل به محدوده gain (مثلاً 0.8 تا 1.2)
  calibGain = map(potValue, 0, 1023, 800, 1200) / 1000.0;
  
  // نمایش وضعیت کالیبراسیون
  static unsigned long lastDisplay = 0;
  if (millis() - lastDisplay > 300) {
    Serial.print("Gain Calibration: ");
    Serial.print(calibGain, 3);
    Serial.print(" | Pot: ");
    Serial.print(potValue);
    
    // نمایش گرافیکی
    Serial.print(" | [");
    int barPos = map(potValue, 0, 1023, 0, 20);
    for (int i = 0; i < 20; i++) {
      if (i == 10) Serial.print("|");
      else if (i == barPos) Serial.print("█");
      else Serial.print(" ");
    }
    Serial.println("]");
    
    lastDisplay = millis();
  }
}

// تابع پیشرفته خواندن پتانسیومتر با فیلتر
int readPotentiometer(int pin, int samples = 10) {
  long total = 0;
  
  // حذف اولین نمونه (ممکن است ناپایدار باشد)
  analogRead(pin);
  delay(1);
  
  // میانگین‌گیری چند نمونه
  for (int i = 0; i < samples; i++) {
    total += analogRead(pin);
    delay(2);
  }
  
  // حذف مقادیر پرت
  int average = total / samples;
  
  // فیلتر میانگین متحرک
  static int filterBuffer[5] = {0};
  static int filterIndex = 0;
  
  filterBuffer[filterIndex] = average;
  filterIndex = (filterIndex + 1) % 5;
  
  long filteredTotal = 0;
  for (int i = 0; i < 5; i++) {
    filteredTotal += filterBuffer[i];
  }
  
  return filteredTotal / 5;
}

#include <EEPROM.h>

void saveCalibration(float offset, float gain) {
  EEPROM.put(0, offset);
  EEPROM.put(4, gain);
  Serial.println("Calibration saved to EEPROM");
}

void loadCalibration() {
  EEPROM.get(0, calibOffset);
  EEPROM.get(4, calibGain);
  Serial.println("Calibration loaded from EEPROM");
}

// کنترل 4 کانال صدا با پتانسیومترهای لگاریتمی

// تنظیم دمای day و night با دو پتانسیومتر

// تولید sine, square, triangle با فرکانس متغیر

// تنظیم ولتاژ 0-30V و جریان 0-5A

// تنظیم زمان‌های مختلف برای رله‌ها