ردیف پایین (پین‌های 1-18):
پین 1:  Digit 1 Common Anode (رقم 1 - سمت چپ)
پین 2:  Digit 2 Common Anode (رقم 2)
پین 3:  Digit 3 Common Anode (رقم 3)
پین 4:  Digit 4 Common Anode (رقم 4 - سمت راست)
پین 5:  Segment E برای تمام ارقام
پین 6:  Segment D برای تمام ارقام
پین 7:  Segment C برای تمام ارقام
پین 8:  Segment G برای تمام ارقام
پین 9:  Decimal Point 4 (DP رقم 4)
پین 10: Segment B برای تمام ارقام
پین 11: Decimal Point 3 (DP رقم 3)
پین 12: Segment F برای تمام ارقام
پین 13: Segment A برای تمام ارقام
پین 14: Decimal Point 2 (DP رقم 2)
پین 15: Decimal Point 1 (DP رقم 1)
پین 16: زمین (GND) برای مدار داخلی
پین 17: VCC (5V) برای مدار داخلی

هر رقم شامل:
- 7 سگمنت اصلی (A-G)
- 1 نقطه اعشار (DP)
- آند مشترک مستقل

اتصالات:
سگمنت‌ها: موازی در همه ارقام
آند ارقام: جداگانه
نقاط اعشار: جداگانه برای هر رقم

// تعریف پایه‌های کنترل ارقام
#define DIGIT1 2  // رقم 1 (سمت چپ)
#define DIGIT2 3  // رقم 2
#define DIGIT3 4  // رقم 3
#define DIGIT4 5  // رقم 4 (سمت راست)

// تعریف پایه‌های سگمنت‌ها
#define SEG_A 6
#define SEG_B 7
#define SEG_C 8
#define SEG_D 9
#define SEG_E 10
#define SEG_F 11
#define SEG_G 12
#define SEG_DP 13 // نقطه اعشار مشترک

// مقاومت‌ها: 220Ω روی هر پایه سگمنت

void setup() {
  // تنظیم پایه‌های ارقام به عنوان خروجی
  for(int i=2; i<=5; i++) {
    pinMode(i, OUTPUT);
    digitalWrite(i, HIGH); // آند مشترک: HIGH = خاموش
  }
  
  // تنظیم پایه‌های سگمنت به عنوان خروجی
  for(int i=6; i<=13; i++) {
    pinMode(i, OUTPUT);
    digitalWrite(i, HIGH); // آند مشترک: HIGH = خاموش
  }
}

// تابع نمایش یک رقم خاص
void showDigit(int digit, int number, bool decimalPoint = false) {
  // خاموش کردن تمام ارقام
  for(int i=2; i<=5; i++) {
    digitalWrite(i, HIGH);
  }
  
  // انتخاب رقم مورد نظر
  digitalWrite(2 + (digit-1), LOW); // LOW = روشن (آند فعال)
  
  // نمایش عدد
  displayNumber(number, decimalPoint);
  
  // تأخیر برای مولتی‌پلکس
  delay(5); // برای 4 رقم، فرکانس رفرش ~50Hz
}

// تابع نمایش عدد روی سگمنت‌ها
void displayNumber(int num, bool dp) {
  // الگوهای سگمنت برای آند مشترک
  byte patterns[10] = {
    0b00000011, // 0: A,B,C,D,E,F
    0b10011111, // 1: B,C
    0b00100101, // 2: A,B,D,E,G
    0b00001101, // 3: A,B,C,D,G
    0b10011001, // 4: B,C,F,G
    0b01001001, // 5: A,C,D,F,G
    0b01000001, // 6: A,C,D,E,F,G
    0b00011111, // 7: A,B,C
    0b00000001, // 8: همه سگمنت‌ها
    0b00001001  // 9: A,B,C,D,F,G
  };
  
  byte pattern = patterns[num];
  
  // فعال کردن سگمنت‌ها
  digitalWrite(SEG_A, (pattern & 0b00000001) ? HIGH : LOW);
  digitalWrite(SEG_B, (pattern & 0b00000010) ? HIGH : LOW);
  digitalWrite(SEG_C, (pattern & 0b00000100) ? HIGH : LOW);
  digitalWrite(SEG_D, (pattern & 0b00001000) ? HIGH : LOW);
  digitalWrite(SEG_E, (pattern & 0b00010000) ? HIGH : LOW);
  digitalWrite(SEG_F, (pattern & 0b00100000) ? HIGH : LOW);
  digitalWrite(SEG_G, (pattern & 0b01000000) ? HIGH : LOW);
  digitalWrite(SEG_DP, dp ? LOW : HIGH);
}

// تابع اصلی برای نمایش 4 رقم
void display4DigitNumber(int number) {
  int digits[4];
  
  // تجزیه عدد به ارقام
  digits[3] = number % 10;           // رقم واحد
  digits[2] = (number / 10) % 10;    // رقم دهگان
  digits[1] = (number / 100) % 10;   // رقم صدگان
  digits[0] = (number / 1000) % 10;  // رقم هزارگان
  
  // نمایش به صورت مولتی‌پلکس
  showDigit(1, digits[0]);
  showDigit(2, digits[1]);
  showDigit(3, digits[2]);
  showDigit(4, digits[3]);
}

void loop() {
  // نمایش شمارش از 0 تا 9999
  for(int i=0; i<10000; i++) {
    // باید در حلقه اصلی، نمایش مداوم باشد
    for(int j=0; j<100; j++) { // نمایش هر عدد برای 100 چرخه
      display4DigitNumber(i);
    }
  }
}

class FourDigitDisplay {
  private:
    // پین‌های کنترل ارقام
    int digitPins[4];
    
    // پین‌های سگمنت‌ها
    int segmentPins[8]; // A,B,C,D,E,F,G,DP
    
    // بافر نمایش
    byte digitBuffer[4];
    bool dpBuffer[4];
    
    // متغیرهای زمان‌بندی
    unsigned long lastRefresh;
    int refreshRate; // Hz
    int currentDigit;
    
  public:
    // سازنده
    FourDigitDisplay(int d1, int d2, int d3, int d4,
                    int a, int b, int c, int d, int e, int f, int g, int dp) {
      // ذخیره پین‌های ارقام
      digitPins[0] = d1;
      digitPins[1] = d2;
      digitPins[2] = d3;
      digitPins[3] = d4;
      
      // ذخیره پین‌های سگمنت
      segmentPins[0] = a;
      segmentPins[1] = b;
      segmentPins[2] = c;
      segmentPins[3] = d;
      segmentPins[4] = e;
      segmentPins[5] = f;
      segmentPins[6] = g;
      segmentPins[7] = dp;
      
      // راه‌اندازی پین‌ها
      for(int i=0; i<4; i++) {
        pinMode(digitPins[i], OUTPUT);
        digitalWrite(digitPins[i], HIGH); // خاموش
      }
      
      for(int i=0; i<8; i++) {
        pinMode(segmentPins[i], OUTPUT);
        digitalWrite(segmentPins[i], HIGH); // خاموش
      }
      
      // مقداردهی اولیه بافر
      clear();
      
      // تنظیمات زمان‌بندی
      refreshRate = 200; // 200Hz = 5ms per digit
      currentDigit = 0;
      lastRefresh = 0;
    }
    
    // پاک کردن نمایشگر
    void clear() {
      for(int i=0; i<4; i++) {
        digitBuffer[i] = 10; // 10 = خاموش
        dpBuffer[i] = false;
      }
    }
    
    // نمایش عدد
    void displayNumber(int number, bool leadingZeros = false) {
      // محدود کردن به 4 رقم
      if(number > 9999) number = 9999;
      if(number < -999) number = -999;
      
      // تجزیه عدد به ارقام
      bool negative = (number < 0);
      number = abs(number);
      
      for(int i=3; i>=0; i--) {
        if(number > 0 || i == 3 || leadingZeros) {
          digitBuffer[i] = number % 10;
          number /= 10;
        } else {
          digitBuffer[i] = 10; // خاموش
        }
      }
      
      // نمایش علامت منفی
      if(negative) {
        // پیدا کردن اولین جای خالی
        for(int i=0; i<4; i++) {
          if(digitBuffer[i] == 10) {
            digitBuffer[i] = 11; // کد برای خط تیره (منفی)
            break;
          }
        }
      }
    }
    
    // نمایش زمان (HH:MM)
    void displayTime(int hours, int minutes) {
      digitBuffer[0] = hours / 10;
      digitBuffer[1] = hours % 10;
      digitBuffer[2] = minutes / 10;
      digitBuffer[3] = minutes % 10;
      
      // نقطه اعشار برای جداکننده ساعت و دقیقه
      dpBuffer[1] = true;
    }
    
    // نمایش عدد اعشاری
    void displayFloat(float number, int decimalPlaces = 1) {
      int multiplier = 1;
      for(int i=0; i<decimalPlaces; i++) {
        multiplier *= 10;
      }
      
      int integerNumber = number * multiplier;
      displayNumber(integerNumber, true);
      
      // تنظیم نقطه اعشار
      for(int i=0; i<4; i++) {
        dpBuffer[i] = false;
      }
      if(decimalPlaces > 0 && decimalPlaces < 4) {
        dpBuffer[3 - decimalPlaces] = true;
      }
    }
    
    // به‌روزرسانی نمایشگر (فراخوانی در loop)
    void update() {
      unsigned long currentTime = millis();
      int refreshInterval = 1000 / (refreshRate * 4); // زمان هر رقم
      
      if(currentTime - lastRefresh >= refreshInterval) {
        lastRefresh = currentTime;
        
        // خاموش کردن رقم قبلی
        digitalWrite(digitPins[currentDigit], HIGH);
        
        // رفتن به رقم بعدی
        currentDigit = (currentDigit + 1) % 4;
        
        // اگر رقم خاموش است، رد شو
        while(digitBuffer[currentDigit] == 10 && currentDigit < 3) {
          currentDigit = (currentDigit + 1) % 4;
        }
        
        // نمایش رقم جاری
        showDigit(currentDigit, digitBuffer[currentDigit], dpBuffer[currentDigit]);
      }
    }
    
  private:
    // نمایش یک رقم خاص
    void showDigit(int digit, int number, bool decimalPoint) {
      // روشن کردن رقم
      digitalWrite(digitPins[digit], LOW);
      
      // نمایش عدد
      byte pattern = getSegmentPattern(number);
      
      // فعال کردن سگمنت‌ها
      for(int i=0; i<7; i++) {
        bool segmentOn = !((pattern >> i) & 0x01); // معکوس برای آند مشترک
        digitalWrite(segmentPins[i], segmentOn ? LOW : HIGH);
      }
      
      // نقطه اعشار
      digitalWrite(segmentPins[7], decimalPoint ? LOW : HIGH);
    }
    
    // الگوی سگمنت برای هر عدد
    byte getSegmentPattern(int number) {
      switch(number) {
        case 0:  return 0b00000011; // ABCDEF
        case 1:  return 0b10011111; // BC
        case 2:  return 0b00100101; // ABDEG
        case 3:  return 0b00001101; // ABCD G
        case 4:  return 0b10011001; //  BC FG
        case 5:  return 0b01001001; // A CD FG
        case 6:  return 0b01000001; // A CDEFG
        case 7:  return 0b00011111; // ABC
        case 8:  return 0b00000001; // ABCDEFG
        case 9:  return 0b00001001; // ABCDFG
        case 11: return 0b11111101; // خط تیره (G)
        default: return 0b11111111; // خاموش
      }
    }
};

// استفاده از کلاس
FourDigitDisplay display(2,3,4,5,6,7,8,9,10,11,12,13);

void setup() {
  Serial.begin(9600);
  display.displayNumber(1234);
}

void loop() {
  display.update(); // فراخوانی مداوم در loop
  
  // تغییر عدد هر 2 ثانیه
  static unsigned long lastChange = 0;
  static int counter = 0;
  
  if(millis() - lastChange > 2000) {
    lastChange = millis();
    counter = (counter + 1) % 10000;
    display.displayNumber(counter, true); // با صفرهای پیشرو
  }
}

#include <ShiftRegister.h>

#define DATA_PIN 11
#define CLOCK_PIN 12
#define LATCH_PIN 10

// کنترل ارقام با ترانزیستور
#define DIGIT1_TRANSISTOR 2
#define DIGIT2_TRANSISTOR 3
#define DIGIT3_TRANSISTOR 4
#define DIGIT4_TRANSISTOR 5

byte digitPatterns[12] = {
  0b11000000, // 0
  0b11111001, // 1
  0b10100100, // 2
  0b10110000, // 3
  0b10011001, // 4
  0b10010010, // 5
  0b10000010, // 6
  0b11111000, // 7
  0b10000000, // 8
  0b10010000, // 9
  0b11111111, // خاموش
  0b10111111  // خط تیره
};

int currentDigit = 0;
int displayBuffer[4] = {0, 0, 0, 0};

void setup() {
  pinMode(DATA_PIN, OUTPUT);
  pinMode(CLOCK_PIN, OUTPUT);
  pinMode(LATCH_PIN, OUTPUT);
  
  for(int i=2; i<=5; i++) {
    pinMode(i, OUTPUT);
    digitalWrite(i, HIGH); // ترانزیستور خاموش
  }
}

void loop() {
  // مولتی‌پلکس ارقام
  digitalWrite(2 + currentDigit, LOW); // روشن کردن رقم جاری
  
  // ارسال الگوی سگمنت
  digitalWrite(LATCH_PIN, LOW);
  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, digitPatterns[displayBuffer[currentDigit]]);
  digitalWrite(LATCH_PIN, HIGH);
  
  delay(5); // زمان روشن ماندن
  
  digitalWrite(2 + currentDigit, HIGH); // خاموش کردن رقم جاری
  
  // رفتن به رقم بعدی
  currentDigit = (currentDigit + 1) % 4;
}

// با ماژول RTC DS3231
#include <RTClib.h>
RTC_DS3231 rtc;

void displayClock() {
  DateTime now = rtc.now();
  int hour = now.hour();
  int minute = now.minute();
  
  // نمایش به فرمت 24 ساعته
  display.displayTime(hour, minute);
}

// با ADC 16-bit
void displayVoltage(float voltage) {
  // نمایش با دقت 0.01V
  display.displayFloat(voltage, 2);
  
  // اضافه کردن واحد
  // نمایش "V" روی نقطه اعشار خاص
}

// با انکودر یا سنسور
class CounterSystem {
  private:
    long count = 0;
    long target = 0;
    
  public:
    void increment() {
      count++;
      updateDisplay();
    }
    
    void reset() {
      count = 0;
      updateDisplay();
    }
    
    void updateDisplay() {
      display.displayNumber(count, true);
    }
};

// با سنسورهای DS18B20
void displayTemperatures(float temp1, float temp2) {
  // نمایش متناوب
  static bool showFirst = true;
  
  if(showFirst) {
    display.displayFloat(temp1, 1);
    display.dpBuffer[2] = true; // T1 نشانگر
  } else {
    display.displayFloat(temp2, 1);
    display.dpBuffer[2] = false;
    display.dpBuffer[3] = true; // T2 نشانگر
  }
  
  showFirst = !showFirst;
}

برای هر سگمنت:
If = 15mA (توصیه شده)
Vf = 2.0V (متوسط)
Vcc = 5V

R = (Vcc - Vf) / If = (5 - 2) / 0.015 = 200Ω

استفاده از مقاومت 220Ω استاندارد.

جریان کل برای یک رقم:
7 سگمنت × 15mA = 105mA

جریان پیک برای ماژول (4 رقم):
4 رقم × 105mA = 420mA

نیاز به منبع تغذیه 5V/1A برای عملکرد مطمئن.

// تایمر معکوس با تنظیم زمان
class CountdownTimer {
  private:
    int minutes = 0;
    int seconds = 0;
    bool running = false;
    
  public:
    void setTime(int min, int sec) {
      minutes = min;
      seconds = sec;
    }
    
    void start() { running = true; }
    void stop() { running = false; }
    void reset() { minutes = seconds = 0; }
    
    void update() {
      if(running && (minutes > 0 || seconds > 0)) {
        if(seconds == 0) {
          minutes--;
          seconds = 59;
        } else {
          seconds--;
        }
      }
    }
    
    void display() {
      int totalSeconds = minutes * 60 + seconds;
      display.displayNumber(totalSeconds, true);
      
      // نقطه اعشار چشمک‌زن وقتی زیر 1 دقیقه
      if(totalSeconds < 60) {
        display.dpBuffer[2] = (millis() / 500) % 2; // چشمک 1Hz
      }
    }
};

// با DHT22 و این ماژول
#include <DHT.h>
DHT dht(DHTPIN, DHT22);

void displayEnvironment() {
  float temp = dht.readTemperature();
  float humidity = dht.readHumidity();
  
  static unsigned long lastSwitch = 0;
  static bool showTemp = true;
  
  if(millis() - lastSwitch > 3000) { // هر 3 ثانیه تغییر
    lastSwitch = millis();
    showTemp = !showTemp;
  }
  
  if(showTemp) {
    display.displayFloat(temp, 1);
    display.dpBuffer[1] = true; // نشانگر دما
  } else {
    display.displayFloat(humidity, 1);
    display.dpBuffer[3] = true; // نشانگر رطوبت
  }
}

// برای مسابقات
class ScoreBoard {
  private:
    int teamAScore = 0;
    int teamBScore = 0;
    int period = 1;
    
  public:
    void teamAScorePoint() { teamAScore++; }
    void teamBScorePoint() { teamBScore++; }
    void nextPeriod() { period++; }
    
    void display() {
      static int displayMode = 0;
      
      switch(displayMode) {
        case 0: // نمایش امتیازها
          display.displayNumber(teamAScore * 100 + teamBScore, true);
          display.dpBuffer[1] = true; // جداکننده
          break;
        case 1: // نمایش پریود
          display.displayNumber(period, false);
          display.dpBuffer[0] = true; // نشانگر P
          break;
      }
    }
};