دید از پشت (سمت اتصالات):
    
    ┌─────────────────────┐
    │                     │
    │  ○   ○   ○   ○   ○  │
    │                     │
    │  VCC DIN CS  CLK GND│
    │                     │
    └─────────────────────┘
    
    یا در برخی مدل‌ها:
    
    ┌─────────────────────┐
    │                     │
    │  ○   ○   ○   ○   ○  │
    │                     │
    │  GND DIN CS  CLK VCC│
    │                     │
    └─────────────────────┘

آردوینو ← [ماژول ۱] ← [ماژول ۲] ← [ماژول ۳] ← ...
           DIN→DOUT   DIN→DOUT   DIN→DOUT
           
نحوه اتصال:
آردوینو.MOSI → ماژول۱.DIN
آردوینو.SCK  → ماژول۱.CLK
آردوینو.SS   → ماژول۱.CS
ماژول۱.DOUT → ماژول۲.DIN (و ادامه...)

ثبات‌های آدرس‌دهی:
0x0X: رقم ۱-۸ (X=1 تا 8)
0x09: رمزگشایی
0x0A: روشنایی
0x0B: اسکن لیمیت
0x0C: حالت شات‌داون
0x0F: تست نمایشگر

// ۱۶ سطح روشنایی:
// 0xX0 تا 0xXF (X=0 تا F)
// 0 = کمترین، F = بیشترین روشنایی

void setBrightness(int level) {
    level = constrain(level, 0, 15);
    writeRegister(0x0A, level);
}

// ۱. کتابخانه LedControl
#include <LedControl.h>
LedControl lc = LedControl(12, 11, 10, 1);

// ۲. کتابخانه MaxMatrix
#include <MaxMatrix.h>
MaxMatrix m(12, 11, 10, 1);

// ۳. کتابخانه MD_MAX72xx (پیشرفته)
#include <MD_MAX72xx.h>
MD_MAX72xx mx = MD_MAX72xx(HARDWARE_TYPE, 12, 11, 10, 1);

# کتابخانه luma.led_matrix
from luma.led_matrix.device import max7219
from luma.core.interface.serial import spi, noop
from luma.core.render import canvas

# کتابخانه Adafruit_CircuitPython_MAX7219
import board
import digitalio
import adafruit_max7219

from max7219 import Matrix8x8
from machine import Pin, SPI

spi = SPI(1, baudrate=10000000, polarity=0, phase=0)
display = Matrix8x8(spi, Pin(15), 1)

#include <LedControl.h>

// پین‌ها: DIN, CLK, CS, تعداد ماژول‌ها
LedControl lc = LedControl(12, 11, 10, 1);

void setup() {
    // روشن کردن نمایشگر
    lc.shutdown(0, false);
    
    // تنظیم روشنایی متوسط
    lc.setIntensity(0, 8);
    
    // پاک کردن نمایشگر
    lc.clearDisplay(0);
}

void setPixel(int x, int y, bool state) {
    // محدودیت‌های x و y بین ۰ تا ۷
    x = constrain(x, 0, 7);
    y = constrain(y, 0, 7);
    
    // ستون‌ها از ۰ تا ۷، سطرها از ۰ تا ۷
    lc.setLed(0, x, y, state);
}

// آرایه بیت‌مپ برای کاراکترها
byte charA[8] = {
    B00111100,
    B01100110,
    B01100110,
    B01111110,
    B01100110,
    B01100110,
    B01100110,
    B00000000
};

void displayChar(byte bitmap[8]) {
    for(int row = 0; row < 8; row++) {
        lc.setRow(0, row, bitmap[row]);
    }
}

void scrollText(String text, int delayTime) {
    int length = text.length();
    
    for(int i = 0; i < length * 8; i++) {
        lc.clearDisplay(0);
        
        // محاسبه موقعیت نمایش
        int position = i;
        
        // نمایش بخشی از متن
        displayTextSegment(text, position);
        
        delay(delayTime);
    }
}

class TemperatureDisplay {
private:
    float temperature;
    LedControl* display;
    
public:
    TemperatureDisplay(LedControl* lc) {
        display = lc;
    }
    
    void updateTemperature(float temp) {
        temperature = temp;
        displayTemperature();
    }
    
    void displayTemperature() {
        display->clearDisplay(0);
        
        // نمایش عدد
        String tempStr = String(int(temperature));
        for(int i = 0; i < tempStr.length(); i++) {
            displayChar(tempStr[i], i);
        }
        
        // نمایش درجه سانتیگراد
        displayDegreeSymbol();
        
        // نمایش گراف دمایی
        displayTemperatureGraph();
    }
    
    void displayTemperatureGraph() {
        // نمایش نوار دمایی
        int level = map(temperature, 0, 50, 0, 8);
        for(int y = 0; y < level; y++) {
            display->setLed(0, 7, y, true);
        }
    }
};

class MatrixClock {
private:
    int hours;
    int minutes;
    int seconds;
    LedControl* display;
    
public:
    MatrixClock(LedControl* lc) {
        display = lc;
    }
    
    void updateTime(int h, int m, int s) {
        hours = h;
        minutes = m;
        seconds = s;
        displayTime();
    }
    
    void displayTime() {
        display->clearDisplay(0);
        
        // نمایش ساعت
        displayNumber(hours / 10, 0);
        displayNumber(hours % 10, 2);
        
        // نمایش دونقطه چشمک‌زن
        static bool colonState = false;
        if(seconds % 2 == 0) {
            displayColon(colonState);
            colonState = !colonState;
        }
        
        // نمایش دقیقه
        displayNumber(minutes / 10, 4);
        displayNumber(minutes % 10, 6);
    }
    
    void displayNumber(int num, int position) {
        byte numbers[10][8] = {
            // تعریف بیت‌مپ اعداد ۰-۹
        };
        
        for(int row = 0; row < 8; row++) {
            display->setRow(0, position, numbers[num][row]);
        }
    }
};

class SnakeGame {
private:
    struct Point {
        int x;
        int y;
    };
    
    Point snake[64];
    int length;
    Point food;
    int direction; // 0=up, 1=right, 2=down, 3=left
    
public:
    void init() {
        length = 3;
        snake[0] = {4, 4};
        snake[1] = {4, 5};
        snake[2] = {4, 6};
        direction = 0;
        generateFood();
    }
    
    void update() {
        // حرکت مار
        Point newHead = snake[0];
        
        switch(direction) {
            case 0: newHead.y--; break;
            case 1: newHead.x++; break;
            case 2: newHead.y++; break;
            case 3: newHead.x--; break;
        }
        
        // بررسی برخورد با دیوار
        if(newHead.x < 0 || newHead.x > 7 ||
           newHead.y < 0 || newHead.y > 7) {
            gameOver();
            return;
        }
        
        // بررسی برخورد با خود
        for(int i = 0; i < length; i++) {
            if(snake[i].x == newHead.x && 
               snake[i].y == newHead.y) {
                gameOver();
                return;
            }
        }
        
        // جابه‌جایی مار
        for(int i = length; i > 0; i--) {
            snake[i] = snake[i-1];
        }
        snake[0] = newHead;
        
        // بررسی غذا خوردن
        if(newHead.x == food.x && newHead.y == food.y) {
            length++;
            generateFood();
        }
    }
    
    void render(LedControl& lc) {
        lc.clearDisplay(0);
        
        // نمایش مار
        for(int i = 0; i < length; i++) {
            lc.setLed(0, snake[i].x, snake[i].y, true);
        }
        
        // نمایش غذا
        lc.setLed(0, food.x, food.y, true);
    }
};

#include <LedControl.h>

// اتصال ۴ ماژول به صورت سری
LedControl lc = LedControl(12, 11, 10, 4);

void setup() {
    for(int i = 0; i < 4; i++) {
        lc.shutdown(i, false);
        lc.setIntensity(i, 8);
        lc.clearDisplay(i);
    }
}

void displayAcrossModules(String text) {
    // نمایش متن در عرض ۴ ماژول
    int charWidth = 6; // عرض هر کاراکتر
    
    for(int pos = 0; pos < text.length() * charWidth; pos++) {
        for(int module = 0; module < 4; module++) {
            int moduleOffset = module * 8;
            displayTextSegment(text, pos - moduleOffset, module);
        }
        delay(100);
    }
}

class Matrix16x16 {
private:
    LedControl* lc;
    
public:
    Matrix16x16(LedControl* display) {
        lc = display;
    }
    
    void setPixel16(int x, int y, bool state) {
        // تعیین ماژول و موقعیت نسبی
        int moduleX = x / 8;
        int moduleY = y / 8;
        int moduleIndex = moduleY * 2 + moduleX;
        
        int localX = x % 8;
        int localY = y % 8;
        
        lc->setLed(moduleIndex, localX, localY, state);
    }
    
    void displayImage16x16(uint16_t image[16]) {
        for(int y = 0; y < 16; y++) {
            for(int x = 0; x < 16; x++) {
                bool pixel = (image[y] >> (15 - x)) & 1;
                setPixel16(x, y, pixel);
            }
        }
    }
};

class GraphicsBuffer {
private:
    byte buffer[8];
    LedControl* display;
    
public:
    GraphicsBuffer(LedControl* lc) {
        display = lc;
        clear();
    }
    
    void clear() {
        memset(buffer, 0, sizeof(buffer));
    }
    
    void setPixel(int x, int y, bool state) {
        if(x >= 0 && x < 8 && y >= 0 && y < 8) {
            if(state) {
                buffer[y] |= (1 << (7 - x));
            } else {
                buffer[y] &= ~(1 << (7 - x));
            }
        }
    }
    
    void render() {
        for(int row = 0; row < 8; row++) {
            display->setRow(0, row, buffer[row]);
        }
    }
    
    void scrollLeft() {
        for(int row = 0; row < 8; row++) {
            buffer[row] <<= 1;
        }
    }
};

class AnimationTimer {
private:
    unsigned long lastUpdate;
    unsigned long interval;
    int frame;
    int totalFrames;
    
public:
    AnimationTimer(unsigned long updateInterval) {
        interval = updateInterval;
        lastUpdate = millis();
        frame = 0;
    }
    
    bool shouldUpdate() {
        unsigned long current = millis();
        if(current - lastUpdate >= interval) {
            lastUpdate = current;
            return true;
        }
        return false;
    }
    
    int getFrame() {
        if(shouldUpdate()) {
            frame = (frame + 1) % totalFrames;
        }
        return frame;
    }
    
    void setTotalFrames(int frames) {
        totalFrames = frames;
    }
};

class PowerManager {
private:
    LedControl* display;
    bool isSleeping;
    
public:
    PowerManager(LedControl* lc) {
        display = lc;
        isSleeping = false;
    }
    
    void sleep() {
        if(!isSleeping) {
            display->shutdown(0, true);
            isSleeping = true;
        }
    }
    
    void wake() {
        if(isSleeping) {
            display->shutdown(0, false);
            isSleeping = false;
        }
    }
    
    void autoSleep(unsigned long timeout) {
        static unsigned long lastActivity = millis();
        
        if(millis() - lastActivity > timeout) {
            sleep();
        }
    }
    
    void updateActivity() {
        lastActivity = millis();
        if(isSleeping) {
            wake();
        }
    }
};

۱. بررسی اتصال VCC و GND
۲. بررسی پین‌های DIN, CLK, CS
۳. تست با تابع displayTest()
۴. بررسی جهت اتصال ماژول

مشکل: فقط برخی LEDها روشن می‌شوند
۱. بررسی تنظیمات اسکن لیمیت
۲. تست سخت‌افزار با تابع setLed()
۳. بررسی اتصال‌های لحیم‌کاری

مشکل: نمایشگر چشمک می‌زند
۱. افزایش تاخیر در به‌روزرسانی
۲. استفاده از خازن ۱۰μF روی VCC
۳. بررسی نویز منبع تغذیه

مشکل: ماتریس داغ می‌شود
۱. کاهش روشنایی با setIntensity()
۲. بررسی جریان مصرفی
۳. استفاده از منبع تغذیه با جریان کافی

    Serial.println("Starting hardware test...");
    
    // تست تمام LEDها
    lc.clearDisplay(0);
    lc.shutdown(0, false);
    lc.setIntensity(0, 15);
    
    // تست تک تک LEDها
    for(int y = 0; y < 8; y++) {
        for(int x = 0; x < 8; x++) {
            lc.setLed(0, x, y, true);
            delay(50);
            lc.setLed(0, x, y, false);
        }
    }
    
    // تست حالت تست نمایشگر
    lc.shutdown(0, true);
    delay(1000);
    lc.shutdown(0, false);
    
    Serial.println("Hardware test complete!");
}