Tài liệu Arduino starter kit 2021

DANH SÁCH SẢN PHẨM

1. Arduino UNO R3 DIP (chip cắm)
2. Arduino Proto Shield Uno
3. Cable nạp A-B 4. LCD 1602
4. Động cơ servo SG90 180 độ + phụ kiện
5. Mạch điều khiển ULN2003 + Động Cơ bước 5V
6. Remote hồng ngoại 21 phím
7. IC cảm biến nhiệt độ LM35 9. IC 74HC595
8. Cảm biến rung Lò Xo SW520D x2
9. Cảm biến lửa (Flame Sensor)
10. Còi buzz chủ động
11. Còi buzz thụ động
12. Mắt thu Hồng ngoại 3 chân vỏ sắt IR 1838 TSOP1838
13. Breadboard 165x54mm 830 lỗ
14. Breadboard Mini
15. Dây cắm Breadboard đực- cái 20cm (10 sợi )
16. Dây cắm Breadboard đực- đực (khoảng 60 pcs)
17. Jack pin 9v
18. LED 7 đoạn (1 led)
19. LED 7 đoạn (4 led)
20. Led đục xanh lá x4
21. Led đục đỏ x4
22. Led đục vàng x4
23. Trở 220Ω + 1kΩ + 10kΩ mỗi loại 10c
24. Biến trở (chiết áp) 10Ω
25. Quang trở x2
26. Nút nhấn 12×12 + kèm đệm nút x 4
27. Hộp đựng linh kiện xanh lá
28. Hộp đựng UNO R3 Starter Kit

Hướng dẫn tải và cài đặt Arduino 1.8.13

Bước 1: Truy cập vào địa chỉ:

https://www.arduino.cc/en/software

Các bạn có thể tải Win 7 and newer hoặc ZIP file. Mình tải Win 7 and newer về cài vào máy luôn.

Bước 2: Sau khi tải về, ta cho chạy file mới tải

Viết và nạp một chương trình cho Arduino Uno

Giao diện Arduino khi mới khởi động

Chức năng các nút lệnh trên Arduino:

Soạn một chương trình đơn giản: Hiển thị chữ “Hello Word” ra Serial:

void setup()
{
   Serial.begin(9600);
}
   void loop()
{
   Serial.println("Hello world");
   delay(1000);
}

Nhấn Upload để nạp code, màn hình báo Done uploading là hoàn thành:

Mở serial chỉnh về baudrate 9600 và xem kết quả:

Giới thiệu cơ bản về Arduino Uno

Arduino Uno là một vi điều khiển dựa trên ATmega328P. Nó có 14 chân đầu vào/đầu ra kỹ thuật số (trong đó 6 chân có thể được sử dụng làm đầu ra PWM), 6 đầu vào tương tự, tinh thể thạch anh 16 MHz, kết nối USB, giắc cắm nguồn, header ICSP và nút reset. Mạch chứa mọi thứ cần thiết để hỗ trợ vi điều khiển, chỉ cần kết nối với máy tính bằng cáp USB hoặc cấp nguồn bằng bộ chuyển đổi AC-to-DC hoặc qua chân nguồn để bắt đầu .

Sơ đồ chân Arduino Uno:

Power:

• LED: Chân D13 của Arduino được kết nối với 1 led. Khi chân có giá trị mức cao (HIGH) thì LED sẽ sáng và mức thấp LED sẽ tắt
• VIN: dùng để cung cấp nguồn khi không dùng USB hoặc các nguồn khác, điện áp 7-12VDC
• 5V: Chân này xuất ra nguồn 5V
• 3V3: Nguồn cung cấp 3.3V (dòng điện trên chân này tối đa là 50mA).
• GND: Là chân mang điện cực âm trên board.
• IOREF: chân này dùng để cung cấp tham chiếu điện áp mà bộ vi điều khiển hoạt động.
• Reset: dùng để kết nối với nút reset ra bên ngoài.

Chức năng các chân đặc biệt:

Trên Board Arduino Uno có 14 chân Digital được sử dụng để làm chân đầu vào và đầu ra, chúng sử dụng các hàm pinMode(), digitalWrite(), digitalRead(). Điện áp trên mỗi chân là 5V, dòng trên mỗi chân là 20mA và bên trong có điện trở kéo lên là 20-50 ohm. Dòng tối đa trên mỗi chân I/O không vượt quá 40mA để tránh trường hợp gây hỏng board mạch. Uno có 6 chân đầu vào Analog từ A0 đến A5, mỗi chân cung cấp 10 bit độ phân giải (tức là 1024 giá trị khác nhau).

Ngoài ra, một số chân có chức năng đặt biệt:

• Serial: chân 0 (RX) và 1 (TX): Được sử dụng để nhận dữ liệu (RX) và truyền dữ liệu (TX) TTL.
• Ngắt ngoài: chân 2 và 3
• PWM (điều chế độ rộng xung): chân 3, 5, 6, 9 và 11 cung cấp đầu ra xung PWM với độ phân giải 8 bit bằng
  hàm analogWrite ().
• SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Các chân này hỗ trợ giao tiếp SPI bằng thư viện SPI.
• TWI/I2C: A4 (SDA) và A5 (SCL) hỗ trợ giao tiếp I2C/TWI với các thiết bị khác.
• AREF: điện áp tham chiếu cho các đầu vào tương tự.

ĐÈN LED

Đèn led hay còn gọi là điốt phát quang, là một biến thể của diode cơ bản, nó xác định độ chênh lệch điện áp nhỏ nhất giữa Anode (+ ) và Cathode (-), led khác diode ở chỗ là tạo ra ánh sáng khi dòng điện đi qua. Đèn led cần được kết nối đúng âm dương của nguồn điện để hoạt động. Đèn led có rất nhiều màu sắc khác nhau: đỏ, vàng, xanh lá, xanh dường, trắng…

Điện áp: Mỗi đèn led đều có một mức điện áp đầu vào nhất định (led 5mm dao động 1.9 – 3.2 Vol), nếu cung cấp không đủ đèn sẽ không phát sáng hoặc cung cấp nguồn lớn hơn thì cần phải sử dụng trở để giảm điện thế vào led. Nếu bạn mắc nhiều đèn led nối tiếp, song song thì cần phải tính toán mức điện áp, dòng điện cung cấp cho tất cả các led.

Dòng điện: Nếu bạn cung cấp dòng điện vượt qua ngưỡng cho phép, tương đương với việc làm gia tăng nhiệt độ và làm giảm tuổi thọ của led. Dòng điện phù hợp với led 5mm thường ở mức 20mA, tối đa có thể là 30mA, chúng ta kiểm soát dòng điện bằng cách mắc một điện trở nối tiếp với đèn led,nó giúp dòng điện của led luôn ở mức cho phép.

Thực hành: Điều khiển đèn LED qua Arduino

Chuẩn bị phần cứng:

• ArduinoUno
• 8 đèn led (màu nào cũng được)
• Testboard cắm
• Dây cắm
• 8 điện trở 220 Ohm

Kết nối theo sơ đồ sau:

Code điều khiển bật tắt lần lượt 8 đèn LED

CÁCH 1 : ĐƠN GIẢN NHƯNG . . . DÀI DÒNG & TỐN THỜI GIAN

void setup()
{
    pinMode(2,OUTPUT); //Cấu hình chân số 2 là OUTPUT
    pinMode(3,OUTPUT); //Cấu hình chân số 3 là OUTPUT
    pinMode(4,OUTPUT); //Cấu hình chân số 4 là OUTPUT
    pinMode(5,OUTPUT); //Cấu hình chân số 5 là OUTPUT
    pinMode(6,OUTPUT); //Cấu hình chân số 6 là OUTPUT
    pinMode(7,OUTPUT); //Cấu hình chân số 7 là OUTPUT
    pinMode(8,OUTPUT); //Cấu hình chân số 8 là OUTPUT
    pinMode(9,OUTPUT); //Cấu hình chân số 9 là OUTPUT
}
void setup()
{
    pinMode(2,OUTPUT); //Cấu hình chân số 2 là OUTPUT
    pinMode(3,OUTPUT); //Cấu hình chân số 3 là OUTPUT
    pinMode(4,OUTPUT); //Cấu hình chân số 4 là OUTPUT
    pinMode(5,OUTPUT); //Cấu hình chân số 5 là OUTPUT
    pinMode(6,OUTPUT); //Cấu hình chân số 6 là OUTPUT
    pinMode(7,OUTPUT); //Cấu hình chân số 7 là OUTPUT
    pinMode(8,OUTPUT); //Cấu hình chân số 8 là OUTPUT
    pinMode(9,OUTPUT); //Cấu hình chân số 9 là OUTPUT
}
void setup()
{
    pinMode(2,OUTPUT); //Cấu hình chân số 2 là OUTPUT
    pinMode(3,OUTPUT); //Cấu hình chân số 3 là OUTPUT
    pinMode(4,OUTPUT); //Cấu hình chân số 4 là OUTPUT
    pinMode(5,OUTPUT); //Cấu hình chân số 5 là OUTPUT
    pinMode(6,OUTPUT); //Cấu hình chân số 6 là OUTPUT
    pinMode(7,OUTPUT); //Cấu hình chân số 7 là OUTPUT
    pinMode(8,OUTPUT); //Cấu hình chân số 8 là OUTPUT
    pinMode(9,OUTPUT); //Cấu hình chân số 9 là OUTPUT
}

CÁCH 2 : SỬ DỤNG VÒNG LẶP FOR

byte led[ ] = {2,3,4,5,6,7,8,9}; // Mảng lưu vị trí các chân Digital mà các đèn LED sử dụng theo thứ tự từ 1->8
byte TongLed; // Khai báo biến TongLed cho việc lưu tổng số chân LED
void setup()
{
    TongLed = sizeof(led); //Kiểm tra độ dài của mảng led
    for (int i=0;i<TongLed;i++) {
        pinMode(led[i],OUTPUT); //Cấu hình các chân led là OUTPUT
        digitalWrite(led[i],LOW); //Mặc định các đèn LED sẽ tắt
    }
}
    void loop()
{
    //Bật lần lượt các đèn LED
    for (int i=0; i < TongLed; i++) {
        digitalWrite(led[i],HIGH); //Bật đèn led
        delay(500); // Thời gian trễ giữa các lần là 500ms
    }
    //Tắt lần lượt các đèn LED
    for (int i = 0;i < TongLed; i += 1) {
        digitalWrite(led[i],LOW); // Tắt đèn led
        delay(500); // Thời gian trễ giữa các lần là 500ms
    }
}

BIẾN TRỞ

Biến trở là một dạng điện trở có thể thay đổi giá trị, ví dụ điện trở 10kΩ thì giá trị của nó chỉ là 10kΩ, còn biến trở 10kΩ là có thể thay đổi từ 0 ~ 10kΩ. Cấu tạo của biến trở rất đơn giản bao gồm: con chạy, cuộn dây được làm bằng hợp kim có điện trở công suất lớn, chân ngõ ra 3 chân. Biến trở được ứng dụng rộng rãi trong các mạch điện tử, được dùng để điều chỉnh sai số, điều chỉnh phân áp, phân dòng trong mạch… Ví dụ dùng để tăng giảm âm lượng trong các mạch âm thanh, tăng giảm độ sáng của đèn…

Thực hành: Đọc giá trị biến trở

Chuẩn bị phần cứng:

• ArduinoUno
• Biến trở 10K
• Testboard cắm
• Đèn LED
• Điện trở 220 Ohm
• Dây cắm

Kết nối theo sơ đồ sau:

Code đọc giá trị điện áp qua biến trở

void setup ()
{
   Serial.begin(9600); //Mở cổng Serial ở baudrate 9600
}
void loop()
{
   int giatri = analogRead(A2); // đọc giá trị điện áp ở chân A2
   Serial.println(giatri); // xuất giá trị đo được
   int dienap;
   dienap = map(giatri,0,1023,0,5000);
   // chuyển thang đo của giatri từ 0-1023 sang 0-5000mV
   Serial.println(dienap); // xuất giá trị điện áp đơn vị mV
   delay(500); // thời gian trễ mỗi lần đọc là 500ms
}

Kết nối theo sơ đồ sau:

Điều chỉnh độ sáng của đèn led bằng biến trở với Arduino

int led_pin = 6; // led được kết nối với chân số 6 Arduino
int pot_pin = A0; // chân giữa của biến trở kết nối với chân A0 Arduino
int output; // khai báo ouput là kiểu dữ liệu int
intled_value; // khai báo led_value là kiểu dữ liệu int
void setup ()
{
   pinMode(led_pin, OUTPUT); // Khai báo chân nối led là chân ngõ ra
}
void loop ()
{
   output = analogRead(pot_pin); // đọc giá trị từ biến trở
   led_value = map(output, 0, 1023, 0, 255); //chuyển từ 0-1023 sang 0-255
   analogWrite(led_pin, led_value); // cài giá trị độ sáng của led
   delay(10); // Thời gian trễ 10ms
}

NÚT NHẤN

Nút nhấn là một dạng công tắc đơn giản để đóng ngắt các thiết bị hoặc điều khiển một số hoạt động, quá trình của các thiết bị điện tử, máy móc. Hầu hết, các nút nhấn được làm bằng nhựa hoặc kim loại. Nút nhấn có 2 loại là nút nhấn thường đóng và thường mở.

Cấu tạo :

Nút nhấn gồm hệ thống lò xo, hệ thống các tiếp điểm thường hở – thường đóng và vỏ bảo vệ. Khi tác động vào nút nhấn, các tiếp điểm chuyển trạng thái, khi không còn tác động, các tiếp điểm trở về trạng thái ban đầu.

Nguyên lí hoạt động :

Nút nhấn có ba phần: Bộ truyền động, các tiếp điểm cố định và các rãnh. Bộ truyền động sẽ đi qua toàn bộ công tắc và vào một xy lanh mỏng ở phía dưới. Bên trong là một tiếp điểm động và lò xo. Khi nhấn nút, nó chạm vào các tiếp điểm tĩnh làm thay đổi trạng thái của tiếp điểm. Trong một số trường hợp, người dùng cần giữ nút hoặc nhấn liên tục để thiết bị hoạt động. Với các nút nhấn tự giữ, chốt sẽ giữ nút bật cho đến khi người dùng nhấn nút lần nữa.

Thực hành: Nút nhấn và LED

Chuẩn bị phần cứng:

• ArduinoUno
• Điện trở 10K
• Điện trở 220 Ohm
• Dây cắm
• Testboard cắm
• Nút nhấn
• Đèn LED

Kết nối theo sơ đồ sau:

Code đọc trạng thái nút nhấn báo qua LED

int button =11; // Nút nhấn được kết nối với chân 11 của Arduino
int led = 2; // Led được kết nối với chân 2 của Arduino
void setup()
{
    Serial.begin(9600); // Mở cổng Serial ở baudrate 9600
    pinMode(button, INPUT); // Khai báo chân D11 ở trạng thái đọc dữ liệu
    pinMode(led,OUTPUT); // Khai báo chân nối led là ngõ ra
}
void loop()
{
    int buttonStatus = digitalRead(button); //Đọc trạng thái button
    if (buttonStatus == HIGH) // Nếu mà button bị nhấn
        {
            Serial.println("Nut dang duoc nhan");
            digitalWrite(led,HIGH); // Đèn led sáng
        }
    else
        {
            digitalWrite(led,LOW); // ngược lại button không bị nhấn
            Serial.println ("Nut chua duoc nhan");
        }
}

CÒI BUZZ THỤ ĐỘNG

Còi buzz thụ động khác với cói buzz chủ động có sẵn mạch dao động bên trong nên chỉ cần cấp nguồn là phát ra âm thanh, còn còi buzz thụ động không có bộ dao động bên trong nên khi cấp một tần số từ 2Khz – 5Khz còi sẽ phát âm thanh tùy theo tần số và thời gian, còi thụ động giúp chúng ta kiểm soát được nhiều hiệu ứng âm thanh.

Thực hành: Còi buzz thụ động với Arduino

Chuẩn bị phần cứng:

• Arduino Uno
• Testboard cắm
• Còi buzz thụ động
• Dây cắm
• Điện trở 1K

Kết nối theo sơ đồ sau:

Code: Một vài nốt nhạc tìm hiểu các câu lệnh

void setup(){
    pinMode(3,OUTPUT); // Chân số 3 là ngõ ra
}
void loop(){
    // tone(pin, frequency)
    // tone(pin, frequency, duration)
    // pin: chân kết nối, frequency: tần số sóng vuông,
    //duration: thời gian phát nhạc (đơn vị mili giây)
    tone(3,31);
    delay(400);
    tone(3,587);
    delay(200);
    tone(3,220,400);
    delay(1000);
    tone(3,1047,250);
    delay(500);
    tone(3,87,125);
    delay(125);
    noTone(3); // ngừng phát nhạc
    delay(2000); // trễ 2s
}

QUANG TRỞ

Quang trở hay điện trở quang, photoresistor, photocell, LDR ( Light-dephendent resistor), là linh kiện điện tử được làm bằng chất đặc biệt có điện trở thay đổi giảm theo mức ánh sáng chiếu vào. Ở nơi có ít ánh sáng thì giá trị điện trở tăng cao có thể lên đến vài MΩ, còn nơi có ánh sáng mạnh thì giảm còn vài trăm Ω. Vật liệu quang trở gồm nhiều loại, ở đây ta sử dụng loại CDS (làm từ Sunfua Cadm).

Quang trở hoạt động dựa trên hiệu ứng quang điện trong khối vật chất. Khi photon có năng lượng đủ lớn đập vào, sẽ làm bật electron khỏi phân tử, trở thành tự do trong khối chất và làm chất bán dẫn thành dẫn điện. Mức độ dẫn điện tùy thuộc vào số photon được hấp thụ. Tùy thuộc chất bán dẫn mà quang trở phản ứng khác nhau với bước sóng photon khác nhau. Quang trở phản ứng trễ hơn điốt quang, cỡ 10ms, nên nó tránh được thay đổi nhanh của nguồn sáng.

Thực hành: Sử dụng cầu chia áp để đọc giá trị thay đổi của quang trở với Arduino.

Ở đây mình sử dụng R1 là 10K, R2 là quang trở.

Chuẩn bị phần cứng:

• Arduino Uno
• Testboard cắm
• Quang trở
• Đèn led
• Điện trở 10k
• Điện trở 220 Ohm

Kết nối theo sơ đồ sau:

Code bật tắt LED theo giá trị quang trở

int LED = 13; // Chân led được kết nối với chân 13 của Arduino
int val = A0; // Quang trở được nối với chân A0
void setup ( )
{
    pinMode(LED,OUTPUT); // Khai báo chân led là ngõ ra
    Serial.begin(9600); //Mở cổng Serial ở baudrate 9600
}
void loop ( )
{
    val = analogRead(A0); // Đọc giá trị analog tại chân A0
    Serial.println(val); // Xuất giá trị đọc được ra serial
    if(val<800) // Trời sáng
        {
        digitalWrite (LED,LOW); // Led tắt
        }
    else // Trời tối
        {
            digitalWrite (LED,HIGH); // Led bật
        }
    delay(10); // Thời gian trễ 10ms
}

Ứ NG D Ụ NG Q U ANG TRỞ NÀY ĐỂ LÀ M ĐÈN T Ự ĐỘNG L I Ệ U CÓ ỔN?

CẢM BIẾN PHÁT HIỆN LỬA

Khi lửa cháy sẽ phát ra ánh sáng hồng ngoại (thường là ở dải 760-1100 nanomet), cảm biến sẽ nhận được tia hồng ngoại từ đó để phát hiện lửa. Nguyên lý hoạt động là điện trở của cảm biến phát hiện lửa sẽ tăng khi có lửa, nó chuyển tín hiệu hồng ngoại thu được thành tín hiệu điện để báo động.

Thực hành: Cảm biến phát hiện lửa với Arduino

Chuẩn bị phần cứng:

• Arduino Uno
• Cảm biến phát hiện lửa
• Điện trở 10K
• Tụ gốm 104
• Testboard cắm
• Dây kết nối

Kết nối theo sơ đồ sau:

Code: Đọc giá trị analog của cảm biến trên Serial, xem sự thay đổi khi có lửa và không có lửa

int val = A0; // Cảm biến được nối với chân A0
void setup(){
    Serial.begin(9600); //Mở cổng Serial ở baudrate 9600
}
void loop(){
    val = analogRead(A0); // Đọc giá trị analog tại chân A0
    Serial.println(val); // Xuất giá trị đọc được ra serial
    delay(10); // Thời gian trễ 10ms
}

Sau khi đọc được giá trị cảm biến, các bạn có thể chia khoảng giá trị ra có lửa và không có lửa, dùng lệnh if để so sánh kết quả, rồi kết nối thêm còi và đèn led để báo động (tương tự như với cảm biến quang trở).

CẢM BIẾN NGHIÊNG, RUNG SW520D

Các cảm biến độ nghiêng kiểu công tắc bóng này là một loại công tắc kỹ thuật số thay đổi trạng thái từ mở sang đóng dựa trên độ nghiêng của nó so với vector trường hấp dẫn của trái đất. Về mặt điện, chúng hoạt động giống như nút nhấn mà chúng ta đã sử dụng trước đây, nơi các tiếp điểm dẫn điện khi công tắc đóng và không dẫn điện khi nó mở ra. Về mặt cơ học, chúng thường bao gồm một vỏ rỗng (thường là hình trụ) và một khối tự do dẫn điện bên trong (điển hình là một đốm thủy ngân hoặc một quả cầu kim loại lăn tròn); trên một đầu của vỏ, cảm biến có hai hoặc nhiều phần tử dẫn điện bị đoản mạch khi hướng của cảm biến đến mức khối lượng tự do bên trong cuộn và tiếp xúc vật lý với chúng.

Khi cảm biến ở vị trí thẳng, viên bi trong sẽ chạm 2 chân và 2 chân đó sẽ được thông với nhau. Khi cảm biến nghiêng, viên bi lăn ra khỏi sẽ làm 2 chân đứt mạch, không thông.

Thực hành: Cảm biến rung với Arduino

Chuẩn bị phần cứng:

• Arduino Uno
• Testboard cắm
• Cảm biến nghiêng, rung SW520D
• Dây cắm
• Đèn led

Kết nối theo sơ đồ sau:

const int ledPin = 13; // led được kết nối với chân số 13 Arduino
void setup ( )
{
    pinMode(ledPin,OUTPUT); // Khai báo chân led là ngõ ra
    pinMode(2,INPUT_PULLUP); // Khai báo chân 2 là ngõ vào, có dùng
// trở treo của Arduino
}
void loop ( )
{
    int a = digitalRead(2); // Đọc trạng thái chân số 2 lưu vào biến a
    if(a == HIGH) // Nếu giá trị a = 1 tương ứng cảm biến đang nghiêng
        {
            digitalWrite(ledPin,LOW); // Tắt Led
        }
    else // Nếu giá trị a = 0 tương ứng cảm biến không nghiêng
        {
            digitalWrite(ledPin,HIGH); // Bật Led
        }
}

LED 7 ĐOẠN

Led 7 đoạn hay Led 7 thanh (Seven Segment Display) gổm 7 thanh led đơn sắp xếp theo hình chữ “8”. Hầu hết các led 7 đoạn thực sự có 8 phân đoạn, với một dấu chấm ở phía bên phải của chữ số đóng vai trò là dấu thập phân. Mỗi đoạn được đặt tên bằng chữ từ A -> G và DP cho dấu thập phân.

Mỗi phân đoạn đều có thể được điều khiển riêng lẻ, giống như một đèn LED thông thường. Có 2 loại led 7 đoạn là Anode chung và Cathode chung.

Loại Cathode chung (các chân ” – ” của led được mắc chung với nhau) Chân 3 và chân 8 là 2 chân được nối chung với GND (chân âm của led), các chân dương của led được sử dụng riêng biệt, cần thanh led nào sáng chỉ cần cho cực dương của led đó được kết nối với nguồn dương.

Loại Anode chung (các chân ” + ” của led được mắc chung với nhau) Chân 3 và chân 8 là 2 chân được nối chung với Vcc (chân dương của led), các chân âm của led được sử dụng riêng biệt, cần thanh led nào sáng chỉ cần cho cực âm của led đó được kết nối với nguồn âm.

Thực hành: Hiển thị những con số với LED 7 đoạn

Chuẩn bị phần cứng:

• Arduino Uno
• Led 7 đoạn (Cathode chung)
• Điện trở 1K hoặc 220 Ohm
• Testboard cắm
• Dây cắm

Kết nối theo sơ đồ sau:

CÁCH 1 : VIẾT TỪNG SỐ

void setup()
{
    pinMode(2, OUTPUT); // Khai báo chân số 2 là ngõ ra
    pinMode(3, OUTPUT); // Khai báo chân số 3 là ngõ ra
    pinMode(4, OUTPUT); // Khai báo chân số 4 là ngõ ra
    pinMode(5, OUTPUT); // Khai báo chân số 5 là ngõ ra
    pinMode(6, OUTPUT); // Khai báo chân số 6 là ngõ ra
    pinMode(7, OUTPUT); // Khai báo chân số 7 là ngõ ra
    pinMode(8, OUTPUT); // Khai báo chân số 8 là ngõ ra
    pinMode(9, OUTPUT); // Khai báo chân số 9 là ngõ ra
    digitalWrite(9, 0); // tắt chấm tròn "dp"
}
void loop()
{
    // Hiển thị số '0'
    digitalWrite(2, 1);
    digitalWrite(3, 1);
    digitalWrite(4, 1);
    digitalWrite(5, 1);
    digitalWrite(6, 1);
    digitalWrite(7, 1);
    digitalWrite(8, 0);
    delay(1000);
}

CÁCH 2 : SỬ DỤNG VÒNG LẶP FOR

void Display_Segment(int);
// Lưu trữ tất cả giá trị cấu hình của led 7 đoạn
int digit[10][7] = {
    {0,1,1,1,1,1,1}, // Số '0'
    {0,0,0,1,0,0,1}, // Số '1'
    {1,0,1,1,1,1,0}, // Số '2'
    {1,0,1,1,0,1,1}, // Số '3'
    {1,1,0,1,0,0,1}, // Số '4'
    {1,1,1,0,0,1,1}, // Số '5'
    {1,1,1,0,1,1,1}, // Số '6'
    {0,0,1,1,0,0,1}, // Số '7'
    {1,1,1,1,1,1,1}, // Số '8'
    {1,1,1,1,0,1,1 }}; // Số '9'
void setup ()
{
    for(int a=2; a<=8; a++){
    pinMode(a, OUTPUT);
}
}
void loop()
{
    for (int value = 0; value<=9; value++){ // Đếm từ 0 đến 9
        delay(1000);
        Display_Segment(value); //Chuyển giá trị cho hàm
    }
    delay(2000);
}
// Hàm lấy giá trị và hiển thị lên led 7 đoạn
void Display_Segment(int value)
{
    int startPin= 2;
    for (int x=6; x >= 0; x--) {
        digitalWrite(startPin, digit[value][x]);
        startPin++;
    }
} 

LED 7 ĐOẠN 4 SỐ

Led 7 đoạn 4 số là bao gồm 4 led 7 đoạn đơn ghép lại, về cấu tạo và nguyên lý hoạt động cũng tương tự như led 7 đoạn 1 số.

Thực hành: Hiển thị những con số với LED 7 đoạn 4 số

Chuẩn bị phần cứng:

• Arduino Uno
• Led 7 đoạn 4 số (Cathode chung)
• Điện trở 1K hoặc 220 Ohm
• Testboard cắm
• Dây cắm

Kết nối theo sơ đồ sau:

‘ Các chân chữ số D1, D2, D3 và D4 của led 7 đoạn cần được kết nối với các điện trở hạn chế dòng điện, vì chúng là các đầu nối chung của các led. ‘

Code hiển thị các số 1000 đến 9999 1 giây đếm lên 1 đơn vị

Tải thư viện tại: https://github.com/DeanIsMe/SevSeg

#include "SevSeg.h" // gọi thư viện
SevSeg sevseg; // Khởi tạo một đối tượng điều khiển led 7 đoạn
int num =1000; // khởi tạo biến num là kiểu dữ liệu int
void setup()
{
    byte numDigits = 4;
    byte digitPins[ ] = {0, 11, 12, 13}; // Khởi tạo các chân nối với chân âm của led
    byte segmentPins[ ] = {9, 2, 3, 5, 6, 8, 7, 4}; // Khởi tạo các chân nối với chân
    //dương của led
    bool resistorsOnSegments = false; // 'false' là điện trở nằm trên
    //các chân chữ số
    byte hardwareConfig = COMMON_CATHODE; // loại led cathode chung
    sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins,
    resistorsOnSegments); //phần này của câu lệnh trên
    sevseg.setBrightness(100); // độ sáng led
}
void loop ( )
{
    static unsigned long timer = 0; // Khởi tạo biến timer
    if (millis() - timer >= 1000) {
        timer = millis();
        sevseg.setNumber(num);
        num++; // Đếm lên 1 đơn vị
    }
}

IC 74HC595

IC 74HC595 là một IC thông dụng với khả năng dịch bit và ghi nhớ tạm thời 8 bit. Vì vậy, IC 74HC595 có khả năng mở rộng thêm chân cho các board mạch vi điều khiển như Arduino

• VCC: chân cấp nguồn dương cho IC
• GND: chân nối với cực âm
• OE Output Enable: chân có cho phép IC hoạt động hay
• không, dùng để bật/tắt IC, IC được phép chạy khi chân ở
• trạng thái LOW
• MR Master Reclear: chân reset, khi chân này ở trạng thái
• HIGH, bộ nhớ trong IC bị xóa
• DS Serial Data Input: chân nhận dữ liệu vào IC
• ST_CP Storage register clock pin: hay còn gọi là chân
• LATCH, khi chân này từ trạng thái LOW chuyển sang
• HIGH thì data trong IC sẽ được xuất ra các chân Q1 → Q7
• SH_CP Shift register clock pin: còn gọi là chân CLOCK, khi
• từ trạng thái LOW → HIGH tức là một xung, dữ liệu sẽ
• được dịch vào một bit theo trạng thái hiện tại của của
• chân DS
• Q1 → Q7 : tượng trưng cho 8 bit trong vùng nhớ IC.

Thực hành: Điều khiển nhiều LED tiết kiệm chân Arduino hơn với IC 74HC595

Chuẩn bị phần cứng:

• Arduino Uno
• IC 74HC595
• Testboard cắm
• Dây cắm
• Đèn led
• Điện trở 220 Ohm

Kết nối theo sơ đồ trang bên:

Các chân 8, 11, 12 lần lượt điều khiển các chân LATCH, CLOCK, INPUT. Các chân Q0 đến Q7 nối lần lượt vào chân dương của đèn led thông qua trở. Chân Enable nối mức thấp, chân MR nối mức cao.

Code dùng IC 74HC595 điều khiển bật tắt lần lượt 8 LED

int latchPin = 8; // Chân LATCH của IC được nối với chân số 8 của Arduino
int clockPin = 12; // Chân CLOCK của IC được nối với chân số 12 của Arduino
int dataPin = 11; // Chân INPUT của IC được nối với chân số 11 của Arduino
void setup()
{
    pinMode(latchPin, OUTPUT); // Khai báo chân số 8 Arduino là ngõ ra
    pinMode(clockPin, OUTPUT); // Khai báo chân số 12 Arduino là ngõ ra
    pinMode(dataPin, OUTPUT); // Khai bào chân số 11 Arduino là ngõ ra
}
void loop()
{
    for (int x = 1; x < 256; x = x << 1) // Dịch bit
    {
        digitalWrite(latchPin, LOW); // giữ trạng thái chân LATCH là LOW
        shiftOut(dataPin, clockPin, MSBFIRST, x); // dịch bit
        digitalWrite(latchPin, HIGH); // chuyển trạng thái chân LATCH sang HIGH
        delay(500); // delay 0.5s cho lần chạy kế tiếp
    }
}

Giải thích: Tạo vòng lặp có giá trị từ 1 đến 255, bước nhảy của vòng lặp này là
dịch qua 1 bit. Số x ban đầu là 1:
0000 0001: 2^0 = 1
0000 0010: 2^1 = 2
0000 0100: 2^2 = 4
0000 1000: 2^3 = 8
0001 0000: 2^4 =16
0010 0000: 2^5 = 32
0100 0000: 2^6= 64
1000 0000: 2^7 = 128
Do đó, giới hạn vòng lặp x khi bằng 256 thì dừng. Mỗi vòng lặp bắt đầu bằng
việc cài đặt cho chân LATCH có trạng thái là LOW. MSBFIRST, LSBFIRST trong
hàm shifOut có nghĩa là dịch bit từ bit bên phải nhất hoặc từ bit bên trái nhất.

ĐỘNG CƠ SERVO 180 ĐỘ

Động cơ servo là một dạng động cơ chỉ quay khi được điều khiển (bằng xung PWM) với góc quay nằm trong khoảng từ 0 – 180 độ. Nó không giống các loại động cơ thường chỉ cần cấp nguồn là quay liên tục. Động cơ servo được thiết kế những hệ thống hồi tiếp vòng kín. Tín hiệu ra của động cơ được nối với một mạch điều khiển. Khi động cơ quay, vận tốc và vị trí sẽ được hồi tiếp về mạch điều khiển này. Nếu có bầt kỳ lý do nào ngăn cản chuyển động quay của động cơ, cơ cấu hồi tiếp sẽ nhận thấy tín hiệu ra chưa đạt được vị trí mong muốn. Mạch điều khiển tiếp tục chỉnh sai lệch cho động cơ đạt được điểm chính xác.

Bên trong 1 servo thường bao gồm bốn thành phần chính: động cơ DC, hộp số, biến trở và mạch điều khiển. Động cơ
DC có tốc độ cao và mô-men xoắn thấp nhưng hộp số giảm tốc độ xuống đồng thời tăng mô-men xoắn lên.

Chiết áp được gắn trên bánh răng cuối cùng hoặc trục đầu ra, do đó động cơ cũng quay chiết áp, tạo ra một điện áp liên quan đến góc tuyệt đối của trục đầu ra. Trong mạch điều khiển, điện áp chiết áp này được so sánh với điện áp đến từ đường tín hiệu. Nếu cần, bộ điều khiển kích hoạt mạch cầu H tích hợp cho phép động cơ quay theo hai hướng cho đến khi hai tín hiệu đạt mức chênh lệch bằng không.

Thực hành: Điều khiển Servo sử dụng Arduino

Chuẩn bị phần cứng:

• Arduino Uno
• Động cơ Servo SG90
• Biến trở
• Testboard cắm
• Dây cắm

Kết nối theo sơ đồ sau:

Code điều khiển góc quay của Servo dùng Arduino

Link tải thư viện: https://github.com/arduino-libraries/Servo

#include <Servo.h> // Thư viện điều khiển servo
Servo myservo; // Khai báo đối tượng myservo dùng để điều khiển servo
int bientro = A0; // Khai báo chân A0 kết nối với biến trở
int servoPin = 9; // Khai báo chân 9 Arduino kết nối với chân điều khiển servo
void setup ( )
{
    myservo.attach(servoPin); // Cài đặt chức năng điều khiển servo cho chân
    // servoPin
    Serial.begin(9600); // Mở giao tiếp Serial ở baudrate 960
}
void loop ( )
{
    int value = analogRead(bientro); // Đọc giá trị biến trở
    // dùng để điều khiển góc quay cho servo
    int servoPos = map(value, 0, 1023, 0, 180); // Chuyển giá trị analog (0-1023)
    // đọc được từ biến trở sang số đo độ (0-180 độ )
    myservo.write(servoPos); // Cho servo quay một góc là servoPos độ
    Serial.println(servoPos); // Hiển thị góc quay của servo ra serial
    delay(100); //Thời gian trễ mỗi lần là 100ms
}

CẢM BIẾN NHIỆT ĐỘ LM35

Cảm biến nhiệt độ LM35 là loại cảm biến tương tự, hoạt động bằng cách cho ra một giá trị hiệu điện thế nhất định tại chân Output tương ứng với mỗi mức nhiệt độ.

Thực hành: Đọc giá trị nhiệt độ môi trường bằng cảm biến LM35 và Arduino

Chuẩn bị phần cứng:

• Arduino Uno
• Cảm biến nhiệt độ LM35
• Testboard cắm
• Dây cắm

Kết nối theo sơ đồ sau:

Code: Đọc giá trị nhiệt độ môi trường hiển thị ra Serial bằng cảm biến LM35 và Arduino

int sensorPin = A0; // chân analog kết nối tới cảm biến LM35
void setup()
{
    Serial.begin(9600); //Khởi động Serial ở mức baudrate 9600
}
void loop()
{
    int reading = analogRead(sensorPin); //đọc giá trị từ cảm biến LM35
    //tính ra giá trị hiệu điện thế (đơn vị Volt) từ giá trị cảm biến
    float voltage = reading * 5.0 / 1024.0;
    // Cứ mỗi 10mV = 1 độ C, nên ta nhân giá trị cho 100 để ra được nhiệt đo
    float temp = voltage * 100.0;
    Serial.println(temp); // Hiển thị nhiệt độ ra Serial
    delay(1000); // 1s đọc 1 lần
}

CẢM BIẾN THU HỒNG NGOẠI IR 1838 TSOP1838 + REMOTE

Cảm biến hồng ngoại hay còn được gọi là IR Sensor, chúng là một thiết bị điện tử có khả năng đo và phát hiện bức xạ hồng ngoại trong môi trường xung quanh. Cảm biến hồng ngoại (IR Sensor) phát ra các tia vô hình đối với mắt người, vì bước sóng của nó dài hơn ánh sáng khả kiến (mặc dù nó vẫn nằm trên cùngmột phổ điện từ). Bất cứ thứ gì phát ra nhiệt (mọi thứ có nhiệt độ trên năm độ Kelvin) đều phát ra bức xạ hồng ngoại. Trên remote có 1 led hồng ngoại được sử dụng để truyền tín hiệu hồng ngoại. Tín hiệu này sẽ được nhận bởi 1 cảm biến thu hồng ngoại và chuyển thành dạng xung điện, sau đó các xung điện này sẽ được chuyển đổi thành dữ liệu được sử dụng cho các thiết bị điện tử. Remote + cảm biến thu hồng ngoại IR 1838 dùng trong các ứng dụng điều khiển các thiết bị từ xa. Module dễ dàng kết nối với vi điều khiển.

Thực hành: Sử dụng cảm biến thu hồng ngoại IR 1838 để nhận tín hiệu từ remote với Arduino

Chuẩn bị phần cứng:

• Arduino Uno
• Cảm biến thu hồng ngoại IR 1838
• Remote hồng ngoại 21 phím
• Testboard cắm
• Dây cắm

Kết nối theo sơ đồ sau:

Code: Nhận tín hiệu từ remote và hiển thị giá trị ra Serial

Link tải thư viện: https://github.com/Arduino-IRremote/Arduino-IRremote

#include <IRremote.h> // Thư viện IR remote
int RECV_PIN = 3; // Chân số 3 Arduino kết nối với chân tín hiệu của cảm biến IR
IRrecv irrecv(RECV_PIN); // Khai báo đối tượng irrecv
decode_results results; // lưu giữ kết quả giải mã tín hiệu
void setup()
{
    Serial.begin(9600); // Khởi động Serial ở baudrate 9600
    irrecv.enableIRIn(); // Bắt đầu nhận tín hiệu
}
void loop() {
    if (irrecv.decode(&results)) { // Nếu nhận được tín hiệu
        Serial.println(results.value, HEX); // Hiển thị kết quả ra Serial dưới mã Hex
        irrecv.resume(); // Nhận giá trị tiếp theo
    }
}

MÀN HÌNH LCD 1602

Màn hình LCD với khả năng hiển thị 2 dòng với mỗi dòng 16 ký tự, có thể hiển thị các kí tự đa dạng (chữ, số, kí tự đồ họa), được ứng dụng nhiều trong các board mạch điện tử khác nhau.

Sơ đồ chân của LCD:

• VSS: cực âm nguồn cho LCD: 0V
• VDD: cực dương nguồn LCD: 5V
• Constrast Voltage (Vo): điều khiển độ sáng màn hình
• Register Select (RS): lựa chọn thanh ghi
• RS=0 chọn thanh ghi lệnh
• RS=1 chọn thanh ghi dữ liệu
• Read/Write (R/W)
• R/W=0 ghi dữ liệu
• R/W=1 đọc dữ liệu.
• Enable: Cho phép ghi vào LCD
• D0 – D7: 8 chân trao đổi dữ liệu với các vi điều khiển, với 2 chế độ sử dụng
• Chế độ 8 bit: Dữ liệu được truyền trên cả 8 đường, với bit MSB là bit DB7.
• Chế độ 4 bit : Dữ liệu được truyền trên 4 đường từ DB4 tới DB7, bit MSB là DB7.
• Backlight (Backlight Anode (+) và Backlight Cathode (-)): Tắt bật đèn màn hình LCD.
• Sơ đồ chân của LCD:

Thực hành: Lập trình hiển thị chữ ra màn hình LCD 1602 với Arduino

Chuẩn bị phần cứng:

• Arduino Uno
• LCD 1602
• Testboard cắm
• Biến trở 10K
• Dây cắm

Kết nối theo sơ đồ sau:

Code: Hiển thị chữ ra màn hình LCD

#include <LiquidCrystal.h> // Gọi thư viện hỗ trợ
LiquidCrystal lcd(4, 6, 10, 11, 12, 13); //Khởi tạo với các chân lcd
void setup() {
    lcd.begin(16, 2); // Khởi động màn hình loại 1602
    lcd.print("Hello World"); // Hiển thị chữ "Hello World" ra màn hình, mặc định sẽ hiển thị tại hàng 1, cột 1
}

void loop() {
    // Lưu ý: hàng 1 là hàng thứ 2, hàng 0 là hàng thứ 1. Nó đếm từ
    0 từ không phải từ 1
    lcd.setCursor(0, 1); // Sét vị trí tại cột 1 hàng 2
    lcd.print("Xin chao cac ban"); // Hiển thị chữ "Xin chao cac ban"
    ra màn hình
}

Sau khi nạp code xong, các bạn có thể vặn biến trở để chỉnh độ tương phản của màn hình cho phù hợp.

MẠCH ĐIỀU KHIỂN ĐỘNG CƠ BƯỚC ULN2003 + STEP 28YJ-48

Module điều khiển động cơ bước ULN2003 là một vi mạch đệm, cấu tạo từ các mảng darlington chịu được dòng điện đi qua lớn với điện áp cao. Cấu trúc bên trong bao gồm 7 cặp Transistor ghép theo phương thức darlington cực góp hở với một cực phát chung, mỗi cặp có khả năng điều khiển tải lên đến 500mA và 50V. (Transistor Darlington còn gọi là cặp Darlington, là cấu trúc hỗn hợp gồm hai transistor lưỡng cực cùng kiểu npn hoặc pnp kết nối theo cách thức để khuếch đại dòng của transistor đầu được khuếch đại thêm bởi transistor thứ hai).

Động cơ bước 28BYJ-48 là động cơ bước được sử dụng phổ biến, biến đổi xung điện thành chuyển động quay cơ học rời rạc. Đó là bởi vì khi các tín hiệu điện được áp dụng, động cơ bước sẽ quay theo các gia số góc chính xác và cố định được gọi là các bước. Động cơ gồm 4 cuộn dây tạo thành vòng bao quanh rotor. Những cuộn dây này được gọi là stator, vì chúng đứng yên và tĩnh. Mỗi cuộn dây được đánh giá ở mức + 5V, giúp dễ dàng điều khiển bằng bất kỳ bộ vi điều khiển nào, chẳng hạn như Arduino.

Sơ đồ động cơ bước:

Sơ đồ mạch driver ULN2003

Thực hành: Điều khiển động cơ bước 28YJ-48 bằng Driver ULN2003 và Arduino

Chuẩn bị phần cứng:

• Arduino Uno
• Mạch điều khiển động cơ bước ULN2003 + động cơ bước 28YJ-48
• Dây cắm

Kết nối theo sơ đồ sau:

Code: Điều khiển động cơ bước bằng ULN2003 và Arduino

int Pin1 = 8; // Khai báo chân 8 Arduino kết nối với chân IN1 của ULN2003
int Pin2 = 9; // Khai báo chân 9 Arduino kết nối với chân IN1 của ULN2003
int Pin3 = 10; // Khai báo chân 10 Arduino kết nối với chân IN1 của ULN2003
int Pin4 = 11; // Khai báo chân 11 Arduino kết nối với chân IN1 của ULN2003
int _step = 0;
int count =0;
void setup()
{
    // Khai báo các chân là ngõ ra
    pinMode(Pin1, OUTPUT);
    pinMode(Pin2, OUTPUT);
    pinMode(Pin3, OUTPUT);
    pinMode(Pin4, OUTPUT);
}
void loop()
{
    // Động cơ quay tới
    int day2 = 1;
    while (day2 < 2000) {
    day2 += 1; //
    quaytoi() ;
    }
    // Động cơ quay chiều ngược lại
    int day1 = 1;
    while (day1 <2000) {
        day1 += 1; //
        quaylui() ;
    }
}

void quaytoi()
{
    // Hàm cấp xung điều khiển động cơ quay tới
    switch(_step){
        case 0:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, HIGH);
        break;
        case 1:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, HIGH);
        digitalWrite(Pin4, HIGH);
        break;
        case 2:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, HIGH);
        digitalWrite(Pin4, LOW);
        break;
        case 3:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, HIGH);
        digitalWrite(Pin3, HIGH);
        digitalWrite(Pin4, LOW);
        break;
        case 4:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, HIGH);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, LOW);
        break;
        case 5:
        digitalWrite(Pin1, HIGH);
        digitalWrite(Pin2, HIGH);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, LOW);
        break;
        case 6:
        digitalWrite(Pin1, HIGH);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, LOW);
        break;
        case 7:
        digitalWrite(Pin1, HIGH);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, HIGH);
        break;
        default:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, LOW);
        break;
    }
    _step--;
    if(_step>7){
        _step=0;
    }
    if(_step<0){
        _step=7;
    }
    delay(1);
}

void quaylui()
{
    // Hàm cấp xung điều khiển động cơ quay
    chiều ngược lại
    switch(_step){
        case 0:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, HIGH);
        break;
        case 1:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, HIGH);
        digitalWrite(Pin4, HIGH);
        break;
        case 2:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, HIGH);
        digitalWrite(Pin4, LOW);
        break;
        case 3:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, HIGH);
        digitalWrite(Pin3, HIGH);
        digitalWrite(Pin4, LOW);
        break;
        case 4:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, HIGH);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, LOW);
        break;
        case 5:
        digitalWrite(Pin1, HIGH);
        digitalWrite(Pin2, HIGH);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, LOW);
        break;
        case 6:
        digitalWrite(Pin1, HIGH);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, LOW);
        break;
        case 7:
        digitalWrite(Pin1, HIGH);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, HIGH);
        break;
        default:
        digitalWrite(Pin1, LOW);
        digitalWrite(Pin2, LOW);
        digitalWrite(Pin3, LOW);
        digitalWrite(Pin4, LOW);
        break;
    }
    _step++;
    if(_step>7){
        _step=0;
    }
    if(_step<0){
        _step=7;
    }
    delay(1);
}

LED MA TRẬN 8×8

Led ma trận 8×8 bao gồm 64 con led được sắp xếp với nhau theo dạng ma trận, thành 8 hàng và 8 cột, tức là 16 chân. Các led đơn trong cùng một hàng được nối chung anode hoặc cathode, tương tự trong một cột các led được nối chung anode hoặc cathode, tùy mỗi loại led.

Sơ đồ led ma trận 8×8:

Thực hành: Điều khiển đèn led ma trận 8×8 với Arduino

Chuẩn bị phần cứng:

• Arduino Uno
• Led ma trận 8×8
• Dây nối
• Test board cắm
• Điện trở 220 Ohm

Kết nối theo sơ đồ sau:

Code: Hiển thị hình trái tim trên led ma trận 8×8 với arduino

int R[] = {9,4,A2,6,10,A3,11,A5}; // Khai báo các chân nối với chân hàng của led
int C[] = {5,12,13,8,A4,7,3,2}; // Khai báo các chân nối với chân cột của led
unsigned char biglove[8][8] = //tạo hình trái tim lớn
{
    1,1,1,1,1,1,1,1,
    1,0,0,1,1,0,0,1,
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,
    1,0,0,0,0,0,0,1,
    1,1,0,0,0,0,1,1,
    1,1,1,0,0,1,1,1,
};
unsigned char smalllove[8][8] = //tạo hình trái tim nhỏ
{
    1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,
    1,1,0,1,1,0,1,1,
    1,0,0,0,0,0,0,1,
    1,0,0,0,0,0,0,1,
    1,1,0,0,0,0,1,1,
    1,1,1,0,0,1,1,1,
    1,1,1,1,1,1,1,1,
};
void setup()
{
// Khai báo các chân là ngõ ra
for(int i = 0;i<8;i++)
    {
        pinMode(R[i],OUTPUT);
        pinMode(C[i],OUTPUT);
    }
}
int R[] = {9,4,A2,6,10,A3,11,A5}; // Khai báo các chân nối với chân hàng của led
int C[] = {5,12,13,8,A4,7,3,2}; // Khai báo các chân nối với chân cột của led
unsigned char biglove[8][8] = //tạo hình trái tim lớn
{
    1,1,1,1,1,1,1,1,
    1,0,0,1,1,0,0,1,
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,
    1,0,0,0,0,0,0,1,
    1,1,0,0,0,0,1,1,
    1,1,1,0,0,1,1,1,
};
unsigned char smalllove[8][8] = //tạo hình trái tim nhỏ
{
    1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,
    1,1,0,1,1,0,1,1,
    1,0,0,0,0,0,0,1,
    1,0,0,0,0,0,0,1,
    1,1,0,0,0,0,1,1,
    1,1,1,0,0,1,1,1,
    1,1,1,1,1,1,1,1,
};
void setup()
{
// Khai báo các chân là ngõ ra
for(int i = 0;i<8;i++)
    {
        pinMode(R[i],OUTPUT);
        pinMode(C[i],OUTPUT);
    }
}

Cách 2: Sử dụng led ma trận 8×8 với IC 74HC595

Chuẩn bị phần cứng:

• Arduino Uno
• Led ma trận 8×8 (cathode chung)
• IC 74HC595
• Dây nối
• Test board cắm
• Điện trở 220 Ohm

Kết nối theo sơ đồ sau:

Q0 – 9, Q1 – 14, Q2 – 8, Q3 – 12, Q4 – 1, Q5 – 7, Q6 – 2 Q7 – 5; 13 – 13, 12 – 3, 11 – 4, 10 – 10, 9 – 6, 8 – 11, 7 – 15, 6 – 16

Code: Hiển thị trái tim bằng led ma trận 8×8 bằng IC 74HC595 và Arduino

int latchPin = 4; // chân 4 Arduino kết nối với chân LATCH của IC 74HC595
int clockPin = 5; // chân 5 Arduino kết nối với chân CLOCK của IC 74HC595
int dataPin = 3; // chân 3 Arduino kết nối với chân DATA của IC 74HC595
int pins [8] = {13,12,11,10,9,8,7,6}; // khai báo các chân cột của led
byte H[8]= { 
    B11111111, // Tạo hình trái tim
    B11001001,
    B10110110,
    B10111110,
    B10111110,
    B11011101,
    B11101011,
    B11110111
};
byte h[8]= { 
    B11111111, // Tạo hình trái tim
    B11001001,
    B10000000,
    B10000000,
    B10000000,
    B11000001,
    B11100011,
    B11110111
};
void setup() {
    // Khai báo các chân là ngõ ra
    pinMode(latchPin, OUTPUT); /
    pinMode(clockPin, OUTPUT);
    pinMode(dataPin, OUTPUT);
    for (int i = 0; i < 8; i++) {
        pinMode(pins[i], OUTPUT);
        digitalWrite(pins[i], HIGH);
    }
}

void loop() {
    // Hiển thị từng hình trái tim
    for (int k = 0; k < 1000; k++) {
        display_char(H);
    }
    for (int k = 0; k < 1000; k++) {
        display_char(h);
    }
}
void display_char(byte ch[8]) {
    // Hàm hiển thị ra led
    for (int j = 0; j < 8; j++) {
        digitalWrite(latchPin, LOW);
        digitalWrite(pins[j], HIGH);
        digitalWrite(clockPin, LOW);
        shiftOut(dataPin, clockPin, MSBFIRST, ch[j]); //dịch bit
        digitalWrite(latchPin, HIGH);
        digitalWrite(latchPin, LOW);
        shiftOut(dataPin, clockPin, MSBFIRST, B11111111);
        digitalWrite(latchPin, HIGH);
        digitalWrite(pins[j], LOW);
    }
}

Các bạn có thể tải file đầy đủ với định dạng pdf tại: Tài liệu Arduino starter kit 2021