Led matrix / ma trận 8x8 3.75mm

Loại: Đang cập nhật
Thương hiệu: Đang cập nhật
Tình trạng: Còn hàng
Mã sản phẩm: Đang cập nhật
Giá bán:
18.000₫

Cam kết bán hàng

  • Hàng được kiểm tra trước khi bán Hàng được kiểm tra trước khi bán
  • Giá cả hợp lý Giá cả hợp lý
  • Vận chuyển nhanh chóng Vận chuyển nhanh chóng

Danh sách khuyến mãi

  • Miễn phí giao hàng cho đơn từ 500k thanh toán trước.Miễn phí giao hàng cho đơn từ 500k thanh toán trước.

LED ma trận 8x8 màu đỏ, hạt LED 3.75mm

LED ma trận 8x8 gồm 64 LED đỏ sắp xếp thành 8 hàng × 8 cột, hạt LED 3.75mm, 16 chân cắm. Dùng để hiển thị chữ chạy, số, biểu tượng, hiệu ứng cho bảng thông báo mini, đồng hồ, trò chơi, mắt robot... Ma trận không có IC driver, điều khiển bằng cách quét hàng trực tiếp từ vi điều khiển (code bên dưới), hoặc ghép với IC MAX7219 / 74HC595 để tiết kiệm chân.

Thông số kỹ thuật

Thông sốGiá trị
Số LED64 (8 hàng × 8 cột)
MàuĐỏ
Kích thước hạt LED3.75 mm
Số chân16 (2 hàng × 8 chân)
LoạiAS: hàng là cực âm (catot chung) / BS: hàng là cực dương (anot chung), xem mã in trên cạnh
Điện áp thuận mỗi LED~1.8 – 2.2 V
Dòng tối đa mỗi LED20 mA (khuyên dùng ≤ 10 mA khi quét)

Sơ đồ chân (chuẩn ma trận 8x8 16 chân)

ChânNối với
9, 14, 8, 12, 1, 7, 2, 5Hàng R1 → R8 (từ trên xuống)
13, 3, 4, 10, 6, 11, 15, 16Cột C1 → C8 (từ trái sang)
Cách tìm chân 1Hàng chân nằm cùng phía với dòng mã in trên cạnh (vd 1388AS) là chân 1 – 8, chân 1 ở bên trái khi nhìn từ mặt LED. Hàng chân còn lại là 9 – 16, chân 9 đối diện chân 8.

Code mẫu 1: Arduino Uno hiển thị chữ chạy (không cần thư viện)

Mỗi chân cột (chân 13, 3, 4, 10, 6, 11, 15, 16 của ma trận) nối qua 1 điện trở 1kΩ, chân hàng nối thẳng. Khi chạy, chương trình lần lượt sáng từng LED để kiểm tra dây, sáng toàn bộ 1 giây rồi hiện chữ chạy MSHOP ♥ LED MATRIX 8X8.

Chân ma trậnQua điện trởArduino Uno
1 (Hàng R5)Không (nối thẳng)D2
2 (Hàng R7)Không (nối thẳng)D3
3 (Cột C2)CóD4
4 (Cột C3)CóD5
5 (Hàng R8)Không (nối thẳng)D6
6 (Cột C5)CóD7
7 (Hàng R6)Không (nối thẳng)D8
8 (Hàng R3)Không (nối thẳng)D9
9 (Hàng R1)Không (nối thẳng)D10
10 (Cột C4)CóD11
11 (Cột C6)CóD12
12 (Hàng R4)Không (nối thẳng)D13
13 (Cột C1)CóA0
14 (Hàng R2)Không (nối thẳng)A1
15 (Cột C7)CóA2
16 (Cột C8)CóA3

Lưu ý: Không dùng điện trở nhỏ hơn 1kΩ với Uno: khi cả hàng sáng, 1 chân Arduino phải chịu dòng của 8 LED (giới hạn 40mA). Muốn sáng hơn, đặt MATRIX_TYPE đúng loại ma trận (1 hoặc 2).

Nạp code nhanh

Nối dây theo bảng trên, cắm board qua USB và mở bằng Chrome hoặc Edge trên máy tính. Chương trình mẫu đã được biên dịch sẵn, không cần build.

Xem code mẫu · led_matrix_8x8_uno.ino
// LED ma trận 8x8 quét trực tiếp bằng Arduino Uno, không cần IC driver
// Tự sáng đúng với cả loại AS (hàng là cực âm) và BS (hàng là cực dương)
// Mỗi chân cột (C1..C8) nối qua 1 điện trở 1kΩ

// Chân 1..16 của ma trận nối lần lượt vào các chân này của Arduino Uno
const uint8_t MATRIX_PIN[16] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, A0, A1, A2, A3};

// Sơ đồ chuẩn 16 chân: chân ma trận nối hàng R1..R8 và cột C1..C8
const uint8_t ROW_PIN_NO[8] = {9, 14, 8, 12, 1, 7, 2, 5};
const uint8_t COL_PIN_NO[8] = {13, 3, 4, 10, 6, 11, 15, 16};

// 0 = tự động (sáng với cả 2 loại), 1 = hàng là cực dương (BS), 2 = hàng là cực âm (AS)
// Khi đã biết loại, chọn 1 hoặc 2 để LED sáng gấp đôi
#define MATRIX_TYPE 0
#define ON_US 400                       // Thời gian sáng mỗi hàng (µs)

const char TEXT[] = "MSHOP * LED MATRIX 8X8 *  ";

const char FONT_CHARS[] = " !-.*0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const uint8_t FONT[][5] PROGMEM = {
  {0x00, 0x00, 0x00, 0x00, 0x00},  // ' '
  {0x00, 0x00, 0x5F, 0x00, 0x00},  // '!'
  {0x08, 0x08, 0x08, 0x08, 0x08},  // '-'
  {0x00, 0x00, 0x60, 0x60, 0x00},  // '.'
  {0x0C, 0x1E, 0x3C, 0x1E, 0x0C},  // '*'
  {0x3E, 0x51, 0x49, 0x45, 0x3E},  // '0'
  {0x00, 0x42, 0x7F, 0x40, 0x00},  // '1'
  {0x72, 0x49, 0x49, 0x49, 0x46},  // '2'
  {0x21, 0x41, 0x49, 0x4D, 0x33},  // '3'
  {0x18, 0x14, 0x12, 0x7F, 0x10},  // '4'
  {0x27, 0x45, 0x45, 0x45, 0x39},  // '5'
  {0x3C, 0x4A, 0x49, 0x49, 0x31},  // '6'
  {0x41, 0x21, 0x11, 0x09, 0x07},  // '7'
  {0x36, 0x49, 0x49, 0x49, 0x36},  // '8'
  {0x46, 0x49, 0x49, 0x29, 0x1E},  // '9'
  {0x7C, 0x12, 0x11, 0x12, 0x7C},  // 'A'
  {0x7F, 0x49, 0x49, 0x49, 0x36},  // 'B'
  {0x3E, 0x41, 0x41, 0x41, 0x22},  // 'C'
  {0x7F, 0x41, 0x41, 0x41, 0x3E},  // 'D'
  {0x7F, 0x49, 0x49, 0x49, 0x41},  // 'E'
  {0x7F, 0x09, 0x09, 0x09, 0x01},  // 'F'
  {0x3E, 0x41, 0x41, 0x51, 0x73},  // 'G'
  {0x7F, 0x08, 0x08, 0x08, 0x7F},  // 'H'
  {0x00, 0x41, 0x7F, 0x41, 0x00},  // 'I'
  {0x20, 0x40, 0x41, 0x3F, 0x01},  // 'J'
  {0x7F, 0x08, 0x14, 0x22, 0x41},  // 'K'
  {0x7F, 0x40, 0x40, 0x40, 0x40},  // 'L'
  {0x7F, 0x02, 0x1C, 0x02, 0x7F},  // 'M'
  {0x7F, 0x04, 0x08, 0x10, 0x7F},  // 'N'
  {0x3E, 0x41, 0x41, 0x41, 0x3E},  // 'O'
  {0x7F, 0x09, 0x09, 0x09, 0x06},  // 'P'
  {0x3E, 0x41, 0x51, 0x21, 0x5E},  // 'Q'
  {0x7F, 0x09, 0x19, 0x29, 0x46},  // 'R'
  {0x26, 0x49, 0x49, 0x49, 0x32},  // 'S'
  {0x03, 0x01, 0x7F, 0x01, 0x03},  // 'T'
  {0x3F, 0x40, 0x40, 0x40, 0x3F},  // 'U'
  {0x1F, 0x20, 0x40, 0x20, 0x1F},  // 'V'
  {0x3F, 0x40, 0x38, 0x40, 0x3F},  // 'W'
  {0x63, 0x14, 0x08, 0x14, 0x63},  // 'X'
  {0x03, 0x04, 0x78, 0x04, 0x03},  // 'Y'
  {0x61, 0x59, 0x49, 0x4D, 0x43},  // 'Z'
};

uint8_t rowPin[8], colPin[8];
uint8_t frame[8];                       // frame[hàng] bit c = LED ở cột c

void tatHet() {                         // Thả nổi cả 16 chân (INPUT): không LED nào có dòng
  for (uint8_t i = 0; i < 8; i++) {
    pinMode(rowPin[i], INPUT);
    pinMode(colPin[i], INPUT);
  }
}

void xuat(uint8_t pin, uint8_t muc) {
  pinMode(pin, OUTPUT);
  digitalWrite(pin, muc);
}

// Chỉ xuất mức ra hàng đang chọn và các cột cần sáng, mọi chân khác thả nổi.
// Vì vậy cùng một code chạy được cho cả loại AS và BS: pha sai cực chỉ phân cực ngược, LED không sáng.
void quetHang(uint8_t r, bool hangLaAnot) {
  uint8_t bat  = hangLaAnot ? HIGH : LOW;   // Mức của hàng đang chọn
  uint8_t sang = hangLaAnot ? LOW : HIGH;   // Mức của cột để LED sáng
  for (uint8_t c = 0; c < 8; c++) {
    if ((frame[r] >> c) & 1) xuat(colPin[c], sang);
  }
  xuat(rowPin[r], bat);
  delayMicroseconds(ON_US);
  tatHet();
}

void hienThi(unsigned long ms) {
  unsigned long t0 = millis();
  while (millis() - t0 < ms) {
    for (uint8_t r = 0; r < 8; r++) {
      if (MATRIX_TYPE != 2) quetHang(r, true);
      if (MATRIX_TYPE != 1) quetHang(r, false);
    }
  }
}

uint8_t cotChu(int idx) {               // Cột thứ idx của dòng chữ (mỗi ký tự 5 cột + 1 cột trống)
  int n = sizeof(TEXT) - 1;
  if (idx < 0 || idx >= n * 6 || idx % 6 == 5) return 0;
  const char* p = strchr(FONT_CHARS, TEXT[idx / 6]);
  if (!p) return 0;
  return pgm_read_byte(&FONT[p - FONT_CHARS][idx % 6]);
}

void setup() {
  for (uint8_t i = 0; i < 8; i++) {
    rowPin[i] = MATRIX_PIN[ROW_PIN_NO[i] - 1];
    colPin[i] = MATRIX_PIN[COL_PIN_NO[i] - 1];
  }
  tatHet();

  // Kiểm tra: lần lượt sáng từng LED, LED nào không sáng là dây chân đó lỗi
  for (uint8_t r = 0; r < 8; r++) {
    for (uint8_t c = 0; c < 8; c++) {
      memset(frame, 0, sizeof(frame));
      frame[r] = 1 << c;
      hienThi(25);
    }
  }
  memset(frame, 0xFF, sizeof(frame));     // Sáng toàn bộ 1 giây
  hienThi(1000);
}

void loop() {
  int tong = (sizeof(TEXT) - 1) * 6;
  for (int off = -8; off < tong; off++) {  // Chữ chạy từ phải sang trái
    for (uint8_t r = 0; r < 8; r++) {
      uint8_t hang = 0;
      for (uint8_t c = 0; c < 8; c++) {
        if ((cotChu(off + c) >> r) & 1) hang |= 1 << c;
      }
      frame[r] = hang;
    }
    hienThi(70);
  }
}

Code mẫu 2: ESP32 hiển thị chữ chạy

Giống code mẫu 1, dùng 16 chân GPIO an toàn của ESP32. Mỗi chân cột nối qua điện trở 330Ω (ESP32 chạy mức 3.3V nên dùng điện trở nhỏ hơn để đủ sáng).

Chân ma trậnQua điện trởESP32
1 (Hàng R5)Không (nối thẳng)GPIO13
2 (Hàng R7)Không (nối thẳng)GPIO14
3 (Cột C2)CóGPIO27
4 (Cột C3)CóGPIO26
5 (Hàng R8)Không (nối thẳng)GPIO25
6 (Cột C5)CóGPIO33
7 (Hàng R6)Không (nối thẳng)GPIO32
8 (Hàng R3)Không (nối thẳng)GPIO23
9 (Hàng R1)Không (nối thẳng)GPIO22
10 (Cột C4)CóGPIO21
11 (Cột C6)CóGPIO19
12 (Hàng R4)Không (nối thẳng)GPIO18
13 (Cột C1)CóGPIO17
14 (Hàng R2)Không (nối thẳng)GPIO16
15 (Cột C7)CóGPIO4
16 (Cột C8)CóGPIO5
Nạp code nhanh

Nối dây theo bảng trên, cắm board qua USB và mở bằng Chrome hoặc Edge trên máy tính. Chương trình mẫu đã được biên dịch sẵn, không cần build.

Xem code mẫu · led_matrix_8x8_esp32.ino
// LED ma trận 8x8 quét trực tiếp bằng ESP32, không cần IC driver
// Tự sáng đúng với cả loại AS (hàng là cực âm) và BS (hàng là cực dương)
// Mỗi chân cột (C1..C8) nối qua 1 điện trở 330Ω

// Chân 1..16 của ma trận nối lần lượt vào các chân này của ESP32
const uint8_t MATRIX_PIN[16] = {13, 14, 27, 26, 25, 33, 32, 23, 22, 21, 19, 18, 17, 16, 4, 5};

// Sơ đồ chuẩn 16 chân: chân ma trận nối hàng R1..R8 và cột C1..C8
const uint8_t ROW_PIN_NO[8] = {9, 14, 8, 12, 1, 7, 2, 5};
const uint8_t COL_PIN_NO[8] = {13, 3, 4, 10, 6, 11, 15, 16};

// 0 = tự động (sáng với cả 2 loại), 1 = hàng là cực dương (BS), 2 = hàng là cực âm (AS)
// Khi đã biết loại, chọn 1 hoặc 2 để LED sáng gấp đôi
#define MATRIX_TYPE 0
#define ON_US 400                       // Thời gian sáng mỗi hàng (µs)

const char TEXT[] = "MSHOP * LED MATRIX 8X8 *  ";

const char FONT_CHARS[] = " !-.*0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const uint8_t FONT[][5] PROGMEM = {
  {0x00, 0x00, 0x00, 0x00, 0x00},  // ' '
  {0x00, 0x00, 0x5F, 0x00, 0x00},  // '!'
  {0x08, 0x08, 0x08, 0x08, 0x08},  // '-'
  {0x00, 0x00, 0x60, 0x60, 0x00},  // '.'
  {0x0C, 0x1E, 0x3C, 0x1E, 0x0C},  // '*'
  {0x3E, 0x51, 0x49, 0x45, 0x3E},  // '0'
  {0x00, 0x42, 0x7F, 0x40, 0x00},  // '1'
  {0x72, 0x49, 0x49, 0x49, 0x46},  // '2'
  {0x21, 0x41, 0x49, 0x4D, 0x33},  // '3'
  {0x18, 0x14, 0x12, 0x7F, 0x10},  // '4'
  {0x27, 0x45, 0x45, 0x45, 0x39},  // '5'
  {0x3C, 0x4A, 0x49, 0x49, 0x31},  // '6'
  {0x41, 0x21, 0x11, 0x09, 0x07},  // '7'
  {0x36, 0x49, 0x49, 0x49, 0x36},  // '8'
  {0x46, 0x49, 0x49, 0x29, 0x1E},  // '9'
  {0x7C, 0x12, 0x11, 0x12, 0x7C},  // 'A'
  {0x7F, 0x49, 0x49, 0x49, 0x36},  // 'B'
  {0x3E, 0x41, 0x41, 0x41, 0x22},  // 'C'
  {0x7F, 0x41, 0x41, 0x41, 0x3E},  // 'D'
  {0x7F, 0x49, 0x49, 0x49, 0x41},  // 'E'
  {0x7F, 0x09, 0x09, 0x09, 0x01},  // 'F'
  {0x3E, 0x41, 0x41, 0x51, 0x73},  // 'G'
  {0x7F, 0x08, 0x08, 0x08, 0x7F},  // 'H'
  {0x00, 0x41, 0x7F, 0x41, 0x00},  // 'I'
  {0x20, 0x40, 0x41, 0x3F, 0x01},  // 'J'
  {0x7F, 0x08, 0x14, 0x22, 0x41},  // 'K'
  {0x7F, 0x40, 0x40, 0x40, 0x40},  // 'L'
  {0x7F, 0x02, 0x1C, 0x02, 0x7F},  // 'M'
  {0x7F, 0x04, 0x08, 0x10, 0x7F},  // 'N'
  {0x3E, 0x41, 0x41, 0x41, 0x3E},  // 'O'
  {0x7F, 0x09, 0x09, 0x09, 0x06},  // 'P'
  {0x3E, 0x41, 0x51, 0x21, 0x5E},  // 'Q'
  {0x7F, 0x09, 0x19, 0x29, 0x46},  // 'R'
  {0x26, 0x49, 0x49, 0x49, 0x32},  // 'S'
  {0x03, 0x01, 0x7F, 0x01, 0x03},  // 'T'
  {0x3F, 0x40, 0x40, 0x40, 0x3F},  // 'U'
  {0x1F, 0x20, 0x40, 0x20, 0x1F},  // 'V'
  {0x3F, 0x40, 0x38, 0x40, 0x3F},  // 'W'
  {0x63, 0x14, 0x08, 0x14, 0x63},  // 'X'
  {0x03, 0x04, 0x78, 0x04, 0x03},  // 'Y'
  {0x61, 0x59, 0x49, 0x4D, 0x43},  // 'Z'
};

uint8_t rowPin[8], colPin[8];
uint8_t frame[8];                       // frame[hàng] bit c = LED ở cột c

void tatHet() {                         // Thả nổi cả 16 chân (INPUT): không LED nào có dòng
  for (uint8_t i = 0; i < 8; i++) {
    pinMode(rowPin[i], INPUT);
    pinMode(colPin[i], INPUT);
  }
}

void xuat(uint8_t pin, uint8_t muc) {
  pinMode(pin, OUTPUT);
  digitalWrite(pin, muc);
}

// Chỉ xuất mức ra hàng đang chọn và các cột cần sáng, mọi chân khác thả nổi.
// Vì vậy cùng một code chạy được cho cả loại AS và BS: pha sai cực chỉ phân cực ngược, LED không sáng.
void quetHang(uint8_t r, bool hangLaAnot) {
  uint8_t bat  = hangLaAnot ? HIGH : LOW;   // Mức của hàng đang chọn
  uint8_t sang = hangLaAnot ? LOW : HIGH;   // Mức của cột để LED sáng
  for (uint8_t c = 0; c < 8; c++) {
    if ((frame[r] >> c) & 1) xuat(colPin[c], sang);
  }
  xuat(rowPin[r], bat);
  delayMicroseconds(ON_US);
  tatHet();
}

void hienThi(unsigned long ms) {
  unsigned long t0 = millis();
  while (millis() - t0 < ms) {
    for (uint8_t r = 0; r < 8; r++) {
      if (MATRIX_TYPE != 2) quetHang(r, true);
      if (MATRIX_TYPE != 1) quetHang(r, false);
    }
  }
}

uint8_t cotChu(int idx) {               // Cột thứ idx của dòng chữ (mỗi ký tự 5 cột + 1 cột trống)
  int n = sizeof(TEXT) - 1;
  if (idx < 0 || idx >= n * 6 || idx % 6 == 5) return 0;
  const char* p = strchr(FONT_CHARS, TEXT[idx / 6]);
  if (!p) return 0;
  return pgm_read_byte(&FONT[p - FONT_CHARS][idx % 6]);
}

void setup() {
  for (uint8_t i = 0; i < 8; i++) {
    rowPin[i] = MATRIX_PIN[ROW_PIN_NO[i] - 1];
    colPin[i] = MATRIX_PIN[COL_PIN_NO[i] - 1];
  }
  tatHet();

  // Kiểm tra: lần lượt sáng từng LED, LED nào không sáng là dây chân đó lỗi
  for (uint8_t r = 0; r < 8; r++) {
    for (uint8_t c = 0; c < 8; c++) {
      memset(frame, 0, sizeof(frame));
      frame[r] = 1 << c;
      hienThi(25);
    }
  }
  memset(frame, 0xFF, sizeof(frame));     // Sáng toàn bộ 1 giây
  hienThi(1000);
}

void loop() {
  int tong = (sizeof(TEXT) - 1) * 6;
  for (int off = -8; off < tong; off++) {  // Chữ chạy từ phải sang trái
    for (uint8_t r = 0; r < 8; r++) {
      uint8_t hang = 0;
      for (uint8_t c = 0; c < 8; c++) {
        if ((cotChu(off + c) >> r) & 1) hang |= 1 << c;
      }
      frame[r] = hang;
    }
    hienThi(70);
  }
}

Mẹo khi sử dụng

  • Chữ bị xoay ngang hoặc ngược: xoay ma trận 90°/180°, hoặc đổi chỗ 2 mảng ROW_PIN_NO và COL_PIN_NO trong code.
  • Một hàng hoặc một cột không sáng trong bước kiểm tra: kiểm tra lại dây chân ma trận tương ứng trong bảng.
  • Không sáng LED nào: kiểm tra chân 1 có cắm đúng hướng không (lật ma trận lại thử).
  • Muốn dùng ít chân hơn và sáng đều hơn: dùng module MAX7219 điều khiển ma trận (chỉ cần 3 chân).

Bước 1: Truy cập website và lựa chọn sản phẩm cần mua

Bước 2: Click và sản phẩm muốn mua, màn hình hiển thị ra pop up với các lựa chọn sau

Nếu bạn muốn tiếp tục mua hàng: Bấm vào phần tiếp tục mua hàng để lựa chọn thêm sản phẩm vào giỏ hàng

Nếu bạn muốn xem giỏ hàng để cập nhật sản phẩm: Bấm vào xem giỏ hàng

Nếu bạn muốn đặt hàng và thanh toán cho sản phẩm này vui lòng bấm vào: Đặt hàng và thanh toán

Bước 3: Lựa chọn thông tin tài khoản thanh toán

Nếu bạn đã có tài khoản vui lòng nhập thông tin tên đăng nhập là email và mật khẩu vào mục đã có tài khoản trên hệ thống

Nếu bạn chưa có tài khoản và muốn đăng ký tài khoản vui lòng điền các thông tin cá nhân để tiếp tục đăng ký tài khoản. Khi có tài khoản bạn sẽ dễ dàng theo dõi được đơn hàng của mình

Nếu bạn muốn mua hàng mà không cần tài khoản vui lòng nhấp chuột vào mục đặt hàng không cần tài khoản

Bước 4: Điền các thông tin của bạn để nhận đơn hàng, lựa chọn hình thức thanh toán và vận chuyển cho đơn hàng của mình

Bước 5: Xem lại thông tin đặt hàng, điền chú thích và gửi đơn hàng

Sau khi nhận được đơn hàng bạn gửi chúng tôi sẽ liên hệ bằng cách gọi điện lại để xác nhận lại đơn hàng và địa chỉ của bạn.

Trân trọng cảm ơn.

Có thể bạn thích

Sản phẩm đã xem

Thông số kỹ thuật

LED ma trận 8x8 màu đỏ, hạt LED 3.75mm

LED ma trận 8x8 gồm 64 LED đỏ sắp xếp thành 8 hàng × 8 cột, hạt LED 3.75mm, 16 chân cắm. Dùng để hiển thị chữ chạy, số, biểu tượng, hiệu ứng cho bảng thông báo mini, đồng hồ, trò chơi, mắt robot... Ma trận không có IC driver, điều khiển bằng cách quét hàng trực tiếp từ vi điều khiển (code bên dưới), hoặc ghép với IC MAX7219 / 74HC595 để tiết kiệm chân.

Thông số kỹ thuật

Thông sốGiá trị
Số LED64 (8 hàng × 8 cột)
MàuĐỏ
Kích thước hạt LED3.75 mm
Số chân16 (2 hàng × 8 chân)
LoạiAS: hàng là cực âm (catot chung) / BS: hàng là cực dương (anot chung), xem mã in trên cạnh
Điện áp thuận mỗi LED~1.8 – 2.2 V
Dòng tối đa mỗi LED20 mA (khuyên dùng ≤ 10 mA khi quét)

Sơ đồ chân (chuẩn ma trận 8x8 16 chân)

ChânNối với
9, 14, 8, 12, 1, 7, 2, 5Hàng R1 → R8 (từ trên xuống)
13, 3, 4, 10, 6, 11, 15, 16Cột C1 → C8 (từ trái sang)
Cách tìm chân 1Hàng chân nằm cùng phía với dòng mã in trên cạnh (vd 1388AS) là chân 1 – 8, chân 1 ở bên trái khi nhìn từ mặt LED. Hàng chân còn lại là 9 – 16, chân 9 đối diện chân 8.

Code mẫu 1: Arduino Uno hiển thị chữ chạy (không cần thư viện)

Mỗi chân cột (chân 13, 3, 4, 10, 6, 11, 15, 16 của ma trận) nối qua 1 điện trở 1kΩ, chân hàng nối thẳng. Khi chạy, chương trình lần lượt sáng từng LED để kiểm tra dây, sáng toàn bộ 1 giây rồi hiện chữ chạy MSHOP ♥ LED MATRIX 8X8.

Chân ma trậnQua điện trởArduino Uno
1 (Hàng R5)Không (nối thẳng)D2
2 (Hàng R7)Không (nối thẳng)D3
3 (Cột C2)CóD4
4 (Cột C3)CóD5
5 (Hàng R8)Không (nối thẳng)D6
6 (Cột C5)CóD7
7 (Hàng R6)Không (nối thẳng)D8
8 (Hàng R3)Không (nối thẳng)D9
9 (Hàng R1)Không (nối thẳng)D10
10 (Cột C4)CóD11
11 (Cột C6)CóD12
12 (Hàng R4)Không (nối thẳng)D13
13 (Cột C1)CóA0
14 (Hàng R2)Không (nối thẳng)A1
15 (Cột C7)CóA2
16 (Cột C8)CóA3

Lưu ý: Không dùng điện trở nhỏ hơn 1kΩ với Uno: khi cả hàng sáng, 1 chân Arduino phải chịu dòng của 8 LED (giới hạn 40mA). Muốn sáng hơn, đặt MATRIX_TYPE đúng loại ma trận (1 hoặc 2).

Nạp code nhanh

Nối dây theo bảng trên, cắm board qua USB và mở bằng Chrome hoặc Edge trên máy tính. Chương trình mẫu đã được biên dịch sẵn, không cần build.

Xem code mẫu · led_matrix_8x8_uno.ino
// LED ma trận 8x8 quét trực tiếp bằng Arduino Uno, không cần IC driver
// Tự sáng đúng với cả loại AS (hàng là cực âm) và BS (hàng là cực dương)
// Mỗi chân cột (C1..C8) nối qua 1 điện trở 1kΩ

// Chân 1..16 của ma trận nối lần lượt vào các chân này của Arduino Uno
const uint8_t MATRIX_PIN[16] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, A0, A1, A2, A3};

// Sơ đồ chuẩn 16 chân: chân ma trận nối hàng R1..R8 và cột C1..C8
const uint8_t ROW_PIN_NO[8] = {9, 14, 8, 12, 1, 7, 2, 5};
const uint8_t COL_PIN_NO[8] = {13, 3, 4, 10, 6, 11, 15, 16};

// 0 = tự động (sáng với cả 2 loại), 1 = hàng là cực dương (BS), 2 = hàng là cực âm (AS)
// Khi đã biết loại, chọn 1 hoặc 2 để LED sáng gấp đôi
#define MATRIX_TYPE 0
#define ON_US 400                       // Thời gian sáng mỗi hàng (µs)

const char TEXT[] = "MSHOP * LED MATRIX 8X8 *  ";

const char FONT_CHARS[] = " !-.*0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const uint8_t FONT[][5] PROGMEM = {
  {0x00, 0x00, 0x00, 0x00, 0x00},  // ' '
  {0x00, 0x00, 0x5F, 0x00, 0x00},  // '!'
  {0x08, 0x08, 0x08, 0x08, 0x08},  // '-'
  {0x00, 0x00, 0x60, 0x60, 0x00},  // '.'
  {0x0C, 0x1E, 0x3C, 0x1E, 0x0C},  // '*'
  {0x3E, 0x51, 0x49, 0x45, 0x3E},  // '0'
  {0x00, 0x42, 0x7F, 0x40, 0x00},  // '1'
  {0x72, 0x49, 0x49, 0x49, 0x46},  // '2'
  {0x21, 0x41, 0x49, 0x4D, 0x33},  // '3'
  {0x18, 0x14, 0x12, 0x7F, 0x10},  // '4'
  {0x27, 0x45, 0x45, 0x45, 0x39},  // '5'
  {0x3C, 0x4A, 0x49, 0x49, 0x31},  // '6'
  {0x41, 0x21, 0x11, 0x09, 0x07},  // '7'
  {0x36, 0x49, 0x49, 0x49, 0x36},  // '8'
  {0x46, 0x49, 0x49, 0x29, 0x1E},  // '9'
  {0x7C, 0x12, 0x11, 0x12, 0x7C},  // 'A'
  {0x7F, 0x49, 0x49, 0x49, 0x36},  // 'B'
  {0x3E, 0x41, 0x41, 0x41, 0x22},  // 'C'
  {0x7F, 0x41, 0x41, 0x41, 0x3E},  // 'D'
  {0x7F, 0x49, 0x49, 0x49, 0x41},  // 'E'
  {0x7F, 0x09, 0x09, 0x09, 0x01},  // 'F'
  {0x3E, 0x41, 0x41, 0x51, 0x73},  // 'G'
  {0x7F, 0x08, 0x08, 0x08, 0x7F},  // 'H'
  {0x00, 0x41, 0x7F, 0x41, 0x00},  // 'I'
  {0x20, 0x40, 0x41, 0x3F, 0x01},  // 'J'
  {0x7F, 0x08, 0x14, 0x22, 0x41},  // 'K'
  {0x7F, 0x40, 0x40, 0x40, 0x40},  // 'L'
  {0x7F, 0x02, 0x1C, 0x02, 0x7F},  // 'M'
  {0x7F, 0x04, 0x08, 0x10, 0x7F},  // 'N'
  {0x3E, 0x41, 0x41, 0x41, 0x3E},  // 'O'
  {0x7F, 0x09, 0x09, 0x09, 0x06},  // 'P'
  {0x3E, 0x41, 0x51, 0x21, 0x5E},  // 'Q'
  {0x7F, 0x09, 0x19, 0x29, 0x46},  // 'R'
  {0x26, 0x49, 0x49, 0x49, 0x32},  // 'S'
  {0x03, 0x01, 0x7F, 0x01, 0x03},  // 'T'
  {0x3F, 0x40, 0x40, 0x40, 0x3F},  // 'U'
  {0x1F, 0x20, 0x40, 0x20, 0x1F},  // 'V'
  {0x3F, 0x40, 0x38, 0x40, 0x3F},  // 'W'
  {0x63, 0x14, 0x08, 0x14, 0x63},  // 'X'
  {0x03, 0x04, 0x78, 0x04, 0x03},  // 'Y'
  {0x61, 0x59, 0x49, 0x4D, 0x43},  // 'Z'
};

uint8_t rowPin[8], colPin[8];
uint8_t frame[8];                       // frame[hàng] bit c = LED ở cột c

void tatHet() {                         // Thả nổi cả 16 chân (INPUT): không LED nào có dòng
  for (uint8_t i = 0; i < 8; i++) {
    pinMode(rowPin[i], INPUT);
    pinMode(colPin[i], INPUT);
  }
}

void xuat(uint8_t pin, uint8_t muc) {
  pinMode(pin, OUTPUT);
  digitalWrite(pin, muc);
}

// Chỉ xuất mức ra hàng đang chọn và các cột cần sáng, mọi chân khác thả nổi.
// Vì vậy cùng một code chạy được cho cả loại AS và BS: pha sai cực chỉ phân cực ngược, LED không sáng.
void quetHang(uint8_t r, bool hangLaAnot) {
  uint8_t bat  = hangLaAnot ? HIGH : LOW;   // Mức của hàng đang chọn
  uint8_t sang = hangLaAnot ? LOW : HIGH;   // Mức của cột để LED sáng
  for (uint8_t c = 0; c < 8; c++) {
    if ((frame[r] >> c) & 1) xuat(colPin[c], sang);
  }
  xuat(rowPin[r], bat);
  delayMicroseconds(ON_US);
  tatHet();
}

void hienThi(unsigned long ms) {
  unsigned long t0 = millis();
  while (millis() - t0 < ms) {
    for (uint8_t r = 0; r < 8; r++) {
      if (MATRIX_TYPE != 2) quetHang(r, true);
      if (MATRIX_TYPE != 1) quetHang(r, false);
    }
  }
}

uint8_t cotChu(int idx) {               // Cột thứ idx của dòng chữ (mỗi ký tự 5 cột + 1 cột trống)
  int n = sizeof(TEXT) - 1;
  if (idx < 0 || idx >= n * 6 || idx % 6 == 5) return 0;
  const char* p = strchr(FONT_CHARS, TEXT[idx / 6]);
  if (!p) return 0;
  return pgm_read_byte(&FONT[p - FONT_CHARS][idx % 6]);
}

void setup() {
  for (uint8_t i = 0; i < 8; i++) {
    rowPin[i] = MATRIX_PIN[ROW_PIN_NO[i] - 1];
    colPin[i] = MATRIX_PIN[COL_PIN_NO[i] - 1];
  }
  tatHet();

  // Kiểm tra: lần lượt sáng từng LED, LED nào không sáng là dây chân đó lỗi
  for (uint8_t r = 0; r < 8; r++) {
    for (uint8_t c = 0; c < 8; c++) {
      memset(frame, 0, sizeof(frame));
      frame[r] = 1 << c;
      hienThi(25);
    }
  }
  memset(frame, 0xFF, sizeof(frame));     // Sáng toàn bộ 1 giây
  hienThi(1000);
}

void loop() {
  int tong = (sizeof(TEXT) - 1) * 6;
  for (int off = -8; off < tong; off++) {  // Chữ chạy từ phải sang trái
    for (uint8_t r = 0; r < 8; r++) {
      uint8_t hang = 0;
      for (uint8_t c = 0; c < 8; c++) {
        if ((cotChu(off + c) >> r) & 1) hang |= 1 << c;
      }
      frame[r] = hang;
    }
    hienThi(70);
  }
}

Code mẫu 2: ESP32 hiển thị chữ chạy

Giống code mẫu 1, dùng 16 chân GPIO an toàn của ESP32. Mỗi chân cột nối qua điện trở 330Ω (ESP32 chạy mức 3.3V nên dùng điện trở nhỏ hơn để đủ sáng).

Chân ma trậnQua điện trởESP32
1 (Hàng R5)Không (nối thẳng)GPIO13
2 (Hàng R7)Không (nối thẳng)GPIO14
3 (Cột C2)CóGPIO27
4 (Cột C3)CóGPIO26
5 (Hàng R8)Không (nối thẳng)GPIO25
6 (Cột C5)CóGPIO33
7 (Hàng R6)Không (nối thẳng)GPIO32
8 (Hàng R3)Không (nối thẳng)GPIO23
9 (Hàng R1)Không (nối thẳng)GPIO22
10 (Cột C4)CóGPIO21
11 (Cột C6)CóGPIO19
12 (Hàng R4)Không (nối thẳng)GPIO18
13 (Cột C1)CóGPIO17
14 (Hàng R2)Không (nối thẳng)GPIO16
15 (Cột C7)CóGPIO4
16 (Cột C8)CóGPIO5
Nạp code nhanh

Nối dây theo bảng trên, cắm board qua USB và mở bằng Chrome hoặc Edge trên máy tính. Chương trình mẫu đã được biên dịch sẵn, không cần build.

Xem code mẫu · led_matrix_8x8_esp32.ino
// LED ma trận 8x8 quét trực tiếp bằng ESP32, không cần IC driver
// Tự sáng đúng với cả loại AS (hàng là cực âm) và BS (hàng là cực dương)
// Mỗi chân cột (C1..C8) nối qua 1 điện trở 330Ω

// Chân 1..16 của ma trận nối lần lượt vào các chân này của ESP32
const uint8_t MATRIX_PIN[16] = {13, 14, 27, 26, 25, 33, 32, 23, 22, 21, 19, 18, 17, 16, 4, 5};

// Sơ đồ chuẩn 16 chân: chân ma trận nối hàng R1..R8 và cột C1..C8
const uint8_t ROW_PIN_NO[8] = {9, 14, 8, 12, 1, 7, 2, 5};
const uint8_t COL_PIN_NO[8] = {13, 3, 4, 10, 6, 11, 15, 16};

// 0 = tự động (sáng với cả 2 loại), 1 = hàng là cực dương (BS), 2 = hàng là cực âm (AS)
// Khi đã biết loại, chọn 1 hoặc 2 để LED sáng gấp đôi
#define MATRIX_TYPE 0
#define ON_US 400                       // Thời gian sáng mỗi hàng (µs)

const char TEXT[] = "MSHOP * LED MATRIX 8X8 *  ";

const char FONT_CHARS[] = " !-.*0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const uint8_t FONT[][5] PROGMEM = {
  {0x00, 0x00, 0x00, 0x00, 0x00},  // ' '
  {0x00, 0x00, 0x5F, 0x00, 0x00},  // '!'
  {0x08, 0x08, 0x08, 0x08, 0x08},  // '-'
  {0x00, 0x00, 0x60, 0x60, 0x00},  // '.'
  {0x0C, 0x1E, 0x3C, 0x1E, 0x0C},  // '*'
  {0x3E, 0x51, 0x49, 0x45, 0x3E},  // '0'
  {0x00, 0x42, 0x7F, 0x40, 0x00},  // '1'
  {0x72, 0x49, 0x49, 0x49, 0x46},  // '2'
  {0x21, 0x41, 0x49, 0x4D, 0x33},  // '3'
  {0x18, 0x14, 0x12, 0x7F, 0x10},  // '4'
  {0x27, 0x45, 0x45, 0x45, 0x39},  // '5'
  {0x3C, 0x4A, 0x49, 0x49, 0x31},  // '6'
  {0x41, 0x21, 0x11, 0x09, 0x07},  // '7'
  {0x36, 0x49, 0x49, 0x49, 0x36},  // '8'
  {0x46, 0x49, 0x49, 0x29, 0x1E},  // '9'
  {0x7C, 0x12, 0x11, 0x12, 0x7C},  // 'A'
  {0x7F, 0x49, 0x49, 0x49, 0x36},  // 'B'
  {0x3E, 0x41, 0x41, 0x41, 0x22},  // 'C'
  {0x7F, 0x41, 0x41, 0x41, 0x3E},  // 'D'
  {0x7F, 0x49, 0x49, 0x49, 0x41},  // 'E'
  {0x7F, 0x09, 0x09, 0x09, 0x01},  // 'F'
  {0x3E, 0x41, 0x41, 0x51, 0x73},  // 'G'
  {0x7F, 0x08, 0x08, 0x08, 0x7F},  // 'H'
  {0x00, 0x41, 0x7F, 0x41, 0x00},  // 'I'
  {0x20, 0x40, 0x41, 0x3F, 0x01},  // 'J'
  {0x7F, 0x08, 0x14, 0x22, 0x41},  // 'K'
  {0x7F, 0x40, 0x40, 0x40, 0x40},  // 'L'
  {0x7F, 0x02, 0x1C, 0x02, 0x7F},  // 'M'
  {0x7F, 0x04, 0x08, 0x10, 0x7F},  // 'N'
  {0x3E, 0x41, 0x41, 0x41, 0x3E},  // 'O'
  {0x7F, 0x09, 0x09, 0x09, 0x06},  // 'P'
  {0x3E, 0x41, 0x51, 0x21, 0x5E},  // 'Q'
  {0x7F, 0x09, 0x19, 0x29, 0x46},  // 'R'
  {0x26, 0x49, 0x49, 0x49, 0x32},  // 'S'
  {0x03, 0x01, 0x7F, 0x01, 0x03},  // 'T'
  {0x3F, 0x40, 0x40, 0x40, 0x3F},  // 'U'
  {0x1F, 0x20, 0x40, 0x20, 0x1F},  // 'V'
  {0x3F, 0x40, 0x38, 0x40, 0x3F},  // 'W'
  {0x63, 0x14, 0x08, 0x14, 0x63},  // 'X'
  {0x03, 0x04, 0x78, 0x04, 0x03},  // 'Y'
  {0x61, 0x59, 0x49, 0x4D, 0x43},  // 'Z'
};

uint8_t rowPin[8], colPin[8];
uint8_t frame[8];                       // frame[hàng] bit c = LED ở cột c

void tatHet() {                         // Thả nổi cả 16 chân (INPUT): không LED nào có dòng
  for (uint8_t i = 0; i < 8; i++) {
    pinMode(rowPin[i], INPUT);
    pinMode(colPin[i], INPUT);
  }
}

void xuat(uint8_t pin, uint8_t muc) {
  pinMode(pin, OUTPUT);
  digitalWrite(pin, muc);
}

// Chỉ xuất mức ra hàng đang chọn và các cột cần sáng, mọi chân khác thả nổi.
// Vì vậy cùng một code chạy được cho cả loại AS và BS: pha sai cực chỉ phân cực ngược, LED không sáng.
void quetHang(uint8_t r, bool hangLaAnot) {
  uint8_t bat  = hangLaAnot ? HIGH : LOW;   // Mức của hàng đang chọn
  uint8_t sang = hangLaAnot ? LOW : HIGH;   // Mức của cột để LED sáng
  for (uint8_t c = 0; c < 8; c++) {
    if ((frame[r] >> c) & 1) xuat(colPin[c], sang);
  }
  xuat(rowPin[r], bat);
  delayMicroseconds(ON_US);
  tatHet();
}

void hienThi(unsigned long ms) {
  unsigned long t0 = millis();
  while (millis() - t0 < ms) {
    for (uint8_t r = 0; r < 8; r++) {
      if (MATRIX_TYPE != 2) quetHang(r, true);
      if (MATRIX_TYPE != 1) quetHang(r, false);
    }
  }
}

uint8_t cotChu(int idx) {               // Cột thứ idx của dòng chữ (mỗi ký tự 5 cột + 1 cột trống)
  int n = sizeof(TEXT) - 1;
  if (idx < 0 || idx >= n * 6 || idx % 6 == 5) return 0;
  const char* p = strchr(FONT_CHARS, TEXT[idx / 6]);
  if (!p) return 0;
  return pgm_read_byte(&FONT[p - FONT_CHARS][idx % 6]);
}

void setup() {
  for (uint8_t i = 0; i < 8; i++) {
    rowPin[i] = MATRIX_PIN[ROW_PIN_NO[i] - 1];
    colPin[i] = MATRIX_PIN[COL_PIN_NO[i] - 1];
  }
  tatHet();

  // Kiểm tra: lần lượt sáng từng LED, LED nào không sáng là dây chân đó lỗi
  for (uint8_t r = 0; r < 8; r++) {
    for (uint8_t c = 0; c < 8; c++) {
      memset(frame, 0, sizeof(frame));
      frame[r] = 1 << c;
      hienThi(25);
    }
  }
  memset(frame, 0xFF, sizeof(frame));     // Sáng toàn bộ 1 giây
  hienThi(1000);
}

void loop() {
  int tong = (sizeof(TEXT) - 1) * 6;
  for (int off = -8; off < tong; off++) {  // Chữ chạy từ phải sang trái
    for (uint8_t r = 0; r < 8; r++) {
      uint8_t hang = 0;
      for (uint8_t c = 0; c < 8; c++) {
        if ((cotChu(off + c) >> r) & 1) hang |= 1 << c;
      }
      frame[r] = hang;
    }
    hienThi(70);
  }
}

Mẹo khi sử dụng

  • Chữ bị xoay ngang hoặc ngược: xoay ma trận 90°/180°, hoặc đổi chỗ 2 mảng ROW_PIN_NO và COL_PIN_NO trong code.
  • Một hàng hoặc một cột không sáng trong bước kiểm tra: kiểm tra lại dây chân ma trận tương ứng trong bảng.
  • Không sáng LED nào: kiểm tra chân 1 có cắm đúng hướng không (lật ma trận lại thử).
  • Muốn dùng ít chân hơn và sáng đều hơn: dùng module MAX7219 điều khiển ma trận (chỉ cần 3 chân).
Danh sách so sánh
Messenger