Arduino Tu Hoc A Den Z Cho Nguoi Moi Bat Dau

1
EBOOKS TỰ HỌC
LẬP TRÌNH
ARDUINO DÀNH
CHO NGƯỜI MỚI
BẮT ĐẦU TỪ
A ĐẾN Z
Tài liệu biên soạn bởi Phi Nguyen và một số tài liệu được tham khảo từ arduino.cc và cộng đồng arduino
Web: tdhshop.com.vn Email: tdhshop1991@gmail.com hotline: 01695 304 802
2
MỤC LỤC
A. GIỚI THIỆU VỀ ARDUINO .................................................................................. 15
I. ARDUINO LÀ GÌ? ................................................................................................... 17
II. SƠ LƯỢC VỀ ARDUINO UNO R3 ........................................................................ 21
1. Một số thông số kỹ thuật như sau : ...................................................................... 22
2. Sơ đồ chân của Arduino Uno................................................................................ 23
III. SƠ LƯỢC BỘ KIT TỰ HỌC ARDUINO .............................................................. 25
1. Giới thiệu sơ lược về KIT TỰ HỌC: ................................................................... 25
2. Những lợi ích của Kit Tự Học Arduino: ............................................................. 25
3. Mục đích của bộ KIT TỰ HỌC: .......................................................................... 26
4. Một số bộ KIT TỰ HỌC ARDUINO: ................................................................ 27
IV. CÀI ĐẶT PHẦN MỀN IDE VÀ DRIVER ............................................................. 27
1. Cài đặt phần mền Arduino IDE: ......................................................................... 27
a. Cài Java Runtime Environment (JRE). ................................................................ 27
b. Cài đặt Arduino IDE: ........................................................................................... 28
2. Cài đặt Driver đối với Arduino Uno, mê ga,…: ................................................. 30
a. Cài đặt Driver: ...................................................................................................... 30
b. Nạp chương trình cho Arduino Uno (mega tương tự): ........................................ 32
3. Cài đặt Driver đối với Nano: ................................................................................ 34
a. Giới thiệu board arduino Nano. ........................................................................... 34
b. Cài đặt driver cho Arduino Nano ......................................................................... 34
c. Thông số kỹ thuật Arduino Nano: ....................................................................... 35
d. Nạp chương trình cho Arduino Nano: ................................................................. 36
B. NGÔN NGỮ LẬP TRÌNH ARDUINO ..................................................................... 40
I. HÀM CHỨC NĂNG (FUNCTION): ...................................................................... 40
1. Hàm nhập xuất Digital I/O: .................................................................................. 41
a. digitalWrite():....................................................................................................... 41
b. digitalRead(): ....................................................................................................... 42
c. pinMode(): ........................................................................................................... 43
3
2. Hàm nhập xuất Analog I/O: ................................................................................. 45

a. analogRead() ........................................................................................................ 45
b. analogReference () ............................................................................................... 46
c. analogWrite() ....................................................................................................... 48
d. analogReadResolution ():..................................................................................... 49
e. analogWriteResolution () ..................................................................................... 51
3. Hàm nhập xuất nâng cao I/O: ........................................................................... 53
a. noTone(); .............................................................................................................. 53
b. pulseIn () .............................................................................................................. 53
c. shiftIn(); ............................................................................................................... 54
d. shiftOut(); ............................................................................................................. 55
e. tone(); ................................................................................................................... 58
4. Hàm thời gian: ....................................................................................................... 59
a. delay() .................................................................................................................. 59
b. delayMicroseconds () ........................................................................................... 60
c. micros() ................................................................................................................ 61
d. millis(); ................................................................................................................. 62
5. Hàm toán học: ........................................................................................................ 64
a. abs() ...................................................................................................................... 64
b. constrain() ............................................................................................................ 64
c. map() .................................................................................................................... 65
d. max() .................................................................................................................... 66
e. min() ..................................................................................................................... 66
f. sq() ....................................................................................................................... 67
g. sqrt() ..................................................................................................................... 67
6. Hàm lượng giác: .................................................................................................... 68
a. cos() ...................................................................................................................... 68
b. sin() ...................................................................................................................... 68
c. tan() ...................................................................................................................... 69
4
7. Hàm số ngẫu nhiên: ............................................................................................... 69

a. random() ............................................................................................................... 69
b. randomSeed() ....................................................................................................... 70
8. Bits và Bytes: .......................................................................................................... 72
a. Bit() ...................................................................................................................... 72
b. bitClear() .............................................................................................................. 73
c. bitRead()............................................................................................................... 73
d. bitWrite() .............................................................................................................. 74
e. bitSet() .................................................................................................................. 75
f. lowByte() ............................................................................................................. 75
g. highByte() ............................................................................................................ 76
9. Hàm Ngắt (interrupt) ............................................................................................ 77
a. interrupts() ............................................................................................................ 77
b. noInterrupts() ....................................................................................................... 78
10. Hàm Ngắt Ngoài: ................................................................................................... 79
a. attachInterrupt() ................................................................................................... 79
b. detachInterrupt()................................................................................................... 81
11. Hàm Giao tiếp ........................................................................................................ 83
a. Serial() .................................................................................................................. 83
12. Xử lý chuỗi: ............................................................................................................ 84
a. Hàm isAlpha() ...................................................................................................... 84
b. Hàm isAscii() ....................................................................................................... 85
c. Hàm isWhitespace() ............................................................................................. 86
d. Hàm isPrintable(): ................................................................................................ 87
e. Hàm isUpperCase(): ............................................................................................... 88
f. Hàm isHexadecimalDigit().................................................................................... 89
g. tolower: ................................................................................................................. 90
h. Hàm toupper() ........................................................................................................ 90
i. Hàm isLowerCase() ................................................................................................. 91
5
II. GIÁ TRỊ : .................................................................................................................. 92

1. Hằng số ................................................................................................................... 93
a. Hằng số thực: ....................................................................................................... 93
b. Hằng số nguyên .................................................................................................... 93
c. HIGH .................................................................................................................... 96
d. LOW..................................................................................................................... 97
e. INPUT: ................................................................................................................. 98
f. INPUT_PULLUP ................................................................................................. 98
g. OUTPUT .............................................................................................................. 99
h. LED_BUILTIN .................................................................................................... 99
i. true ....................................................................................................................... 99
j. false .................................................................................................................... 100
2. Kiểu dữ liệu: ......................................................................................................... 100
a. void..................................................................................................................... 100
b. boolean ............................................................................................................... 101
c. int: ...................................................................................................................... 102
d. unsigned int ........................................................................................................ 103
e. char ..................................................................................................................... 104
f. unsigned char ..................................................................................................... 104
g. byte ..................................................................................................................... 104
h. word ................................................................................................................... 105
i. long..................................................................................................................... 105
j. unsigned long ..................................................................................................... 105
k. short .................................................................................................................... 106
l. float .................................................................................................................... 106
m. double ............................................................................................................. 107
n. array ................................................................................................................... 107
o. string................................................................................................................... 109
3. Chuyển đổi kiểu dữ liệu ...................................................................................... 111
6
a. char() .................................................................................................................. 111

b. byte() .................................................................................................................. 111
c. int() ..................................................................................................................... 112
d. word() ................................................................................................................. 112
e. long() .................................................................................................................. 113
f. float() .................................................................................................................. 113
4. Biến hằng, biến tĩnh: ......................................................................................... 114
a. const - biến hằng ................................................................................................ 114
b. static - biến tĩnh .................................................................................................. 114
III. CẤU TRÚC ( STRUCTURE): ............................................................................... 116
1. Cấu trúc tổng thể:................................................................................................ 116
a. setup() và loop() ................................................................................................. 116
2. Toán tử logic: ....................................................................................................... 117
3. Các toán tử so sánh. ............................................................................................ 117
4. Cấu trúc điều khiển:............................................................................................ 118
a. Câu lệnh if…..else .............................................................................................. 118
b. switch / case ....................................................................................................... 119
c. for ....................................................................................................................... 120
d. while ................................................................................................................... 122
e. break ................................................................................................................... 122
f. continue .............................................................................................................. 123
g. return .................................................................................................................. 124
h. goto..................................................................................................................... 124
5. Toán tử số học:..................................................................................................... 125
a. Phép gán(=) ........................................................................................................ 125
b. Các phép cộng, trừ, nhân, chia trong Arduino ................................................... 125
c. Phép chia lấy dư%.............................................................................................. 126
6. Cú pháp mở rộng ................................................................................................. 127
a. dấu chấm phẩy ( ; ) ............................................................................................. 127
7
b. {} dấu ngoặc nhọn ............................................................................................. 127

c. Comments - Viết ghi chú trong khi viết code Arduino...................................... 129
d. #define ................................................................................................................ 130
e. #include .............................................................................................................. 130
7. Phép toán hợp nhất ............................................................................................. 131
a. Cộng một 1 đơn vị (++) / trừ một 1 đơn vị (--) .................................................. 131
b. Các phép toán rút gọn += , -= , *= , /= .............................................................. 132
C. CẤU TRÚC CHƯƠNG TRÌNH ARDUINO VÀ BÀI HỌC LẬP TRÌNH TỪ CƠ
BẢN ĐẾN NÂNG CAO.................................................................................................. 133
I. CẤU TRÚC CHƯƠNG TRÌNH ARDUINO VÀ CÁCH THÊM THƯ VIỆN
VÀO IDE. ....................................................................................................................... 133
1. Cấu trúc chương trình Arduino: ....................................................................... 133
2. Hướng dẫn add thư viện cho Arduino IDE: ..................................................... 134
II. BÀI HỌC LẬP TRÌNH ARDUINO TỪ CƠ BẢN ĐẾN NÂNG CAO. ............. 139
1. Điều khiển LED đơn sáng nhấp nháy................................................................ 139
Nội dung chính.......................................................................................................... 139
Phần cứng ( Trên kit đã tích hợp sẵn chỉ cần nối dây là được) ................................ 139
Lắp mạch................................................................................................................... 139
Hình ảnh thực tế:....................................................................................................... 140
Code lập trình và giải thích ....................................................................................... 140
2. Thay đổi độ sáng của LED đơn. ......................................................................... 142
Nội dung chính: ........................................................................................................ 142
Phần cứng ( được tích hợp sẵn trên kit) nếu không có các bạn chuẩn bị: ................ 142
Lắp mạch................................................................................................................... 142
Hình ảnh thực tế:....................................................................................................... 143
Chương trình: ............................................................................................................ 143
3. Điều khiển đèn giao thông. ................................................................................. 144
Phần cứng cần chuẩn bị ( nếu sử dụng kit thì được tích hợp sẵn) ............................ 144
Lắp mạch: ................................................................................................................. 144
8
Hình ảnh thực tế:....................................................................................................... 145

Code lập trình: .......................................................................................................... 145
4. Điều khiển Rơ le 5Vdc 1, 2 kênh mức cao. ........................................................ 147
Giới thiệu thiệu chung: ............................................................................................. 147
Thông số kỹ thuật: .................................................................................................... 147
Phần cứng chuẩn bị: .................................................................................................. 147
Lắp mạch: ................................................................................................................. 148
Code chương trình: ................................................................................................... 148
Hình ảnh thực tế:....................................................................................................... 149
5. Điều khiển Công tắc tơ 3 pha: ............................................................................ 149
Giới thiệu công tắc tơ 3 pha: ..................................................................................... 149
Lắp mạch: ................................................................................................................. 152
Code chương trình: ................................................................................................... 152
6. Đọc tín hiệu nút nhấn hiển thị lên serial monitor............................................. 153
Giới thiệu về nút nhấn: ............................................................................................. 153
Sơ đồ nguyên lí: ........................................................................................................ 156
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn nút nhấn): ................................ 156
Hình ảnh thực tế:....................................................................................................... 157
Lập trình:................................................................................................................... 157
7. Lưu giá trị nút nhấn. ........................................................................................... 159
Hình ảnh thực tế:....................................................................................................... 160
Lập trình:................................................................................................................... 160
8. Bật tắt LED khi nhấn nút nhấn. ........................................................................ 162
9
Hình ảnh thực tế:....................................................................................................... 163

Lập trình:................................................................................................................... 163
9. Bật tắt rơ le khi nhấn nút nhấn. ......................................................................... 165
Hình ảnh thực tế:....................................................................................................... 166
Lập trình:................................................................................................................... 166
10. Lập trình hiển thị led 7 đoạn đơn: .................................................................... 168
Giới thiệu led 7 đoạn đơn: ....................................................................................... 168
Lập trình:................................................................................................................... 170
Hình ảnh thực tế:....................................................................................................... 172
11. Hiển thị chữ cái, số ra module 4 led 7 đoạn. ..................................................... 173
Giới thiệu module 4 led 7 đoạn: ............................................................................... 173
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn): ............................................... 174
Hình ảnh thực tế:....................................................................................................... 175
Lập trình:................................................................................................................... 175
12. Lập trình hiển thị module led ma trận 8x8. ...................................................... 177
Giới thiệu module ma trận 8x8: ................................................................................ 177
Phần cứng chuẩn bị: ( tất cả được tích hợp trên Kit Tự Học)................................... 177
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn): ............................................... 178
Hình ảnh thực tế:....................................................................................................... 178
Lập trình:................................................................................................................... 178
13. Hiển thị chữ lên màn hình LCD16x02. .............................................................. 183
Giới thiệu module LCD 16X02: ............................................................................... 183
Lắp mạch( nếu các bạn đã có kit học thì chỉ việc nối dây): ..................................... 184
10
Hình ảnh thực tế:....................................................................................................... 185

Lập trình:................................................................................................................... 185
14. Kết hợp Module I2C với LCD16x02. ................................................................. 185
Giới thiệu module I2C cho LCD: ............................................................................. 185
Lập trình:................................................................................................................... 187
Hình ảnh thực tế:....................................................................................................... 187
15. Đọc giá trị cảm biến quang trở hiển thị lên serial monitor. ............................ 188
Giới thiệu cảm biến quang trở: ................................................................................. 188
Phần cứng chuẩn bị: (được tích hợp trên Kit Tự Học) ............................................. 189
Hình ảnh thực tế:....................................................................................................... 189
Lập trình:................................................................................................................... 190
16. Đọc gái trị CB nhiệt độ LM35 hiển thị lên serial monitor. .............................. 191
Giới thiệu cảm biến nhiệt độ LM35: ........................................................................ 191
Lắp mạch: ................................................................................................................. 192
Hình ảnh thực tế:....................................................................................................... 192
Lập trình:................................................................................................................... 192
17. Đọc giá trị CB nhiệt độ DS18B20 hiển thị lên serial monitor. ........................ 193
Giới thiệu cảm biến nhiệt độ DS 18B20: .................................................................. 193
Lắp mạch: ................................................................................................................. 195
Lập trình:................................................................................................................... 195
18. Hiển thị giá trị CB nhiệt độ LM35 lên mà hình LCD. ..................................... 197
Lắp mạch : ................................................................................................................ 197
Lập trình :.................................................................................................................. 197
11
Hình ảnh thực tế:....................................................................................................... 198

19. Đọc giá trị cảm biến mưa hiển thị lên serial monitor. ..................................... 199
Giới thiệu cảm biến mưa: ......................................................................................... 199
Lắp mạch : ................................................................................................................ 200
Lập trình :.................................................................................................................. 200
Hình ảnh thực tế:....................................................................................................... 201
20. Đọc giá trị CB siêu âm SRF 05 hiển thị lên serial monitor. ............................ 202
Giới thiệu cảm biến siêu âm SRF05: ........................................................................ 202
Lắp mạch : ................................................................................................................ 203
Hình ảnh thực tế:....................................................................................................... 204
Lập trình :.................................................................................................................. 205
Kết quả hiển thị lên Serial monitor : ......................................................................... 206
21. Đọc giá trị cảm biến độ ẩm đất hiển thị lên LCD16x02. .................................. 206
Giới thiệu cảm biến độ ẩm đất: ................................................................................. 206
Thông số kỹ thuật: .................................................................................................... 207
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn) .......................................................... 207
Lắp mạch : ................................................................................................................ 207
Hình ảnh thực tế:....................................................................................................... 208
Lập trình :.................................................................................................................. 208
22. Đọc giá trị CB dò line hiển thị lên serial monitor và LCD. ............................. 209
Giới thiệu cảm biến dò line: ..................................................................................... 209
Thông số kỹ thuật: .................................................................................................... 210
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn) .......................................................... 210
Lắp mạch : ................................................................................................................ 211
Lập trình :.................................................................................................................. 211
Hình ảnh thực tế:....................................................................................................... 213
12

23. Đọc giá trị điện áp khi điều chỉnh biến trở hiển thị lên serial ......................... 214
Giới thiệu về biến trở: ............................................................................................... 214
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn biến trở 10K) ..................................... 214
Lắp mạch : ................................................................................................................ 214
Lập trình :.................................................................................................................. 215
Hình ảnh thực tế:....................................................................................................... 216
24. Hiển thị thời gian thực (DS1307) lên LCD và serial monitor.......................... 217
Giới thiệu về module DS1307: ................................................................................. 217
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn biến trở 10K) ..................................... 218
Lắp mạch : ................................................................................................................ 218
Lập trình :.................................................................................................................. 219
Hình ảnh thực tế:....................................................................................................... 221
25. Hiển thị tốc độ đo bằng Encoder quay lên LCD............................................... 222
Giới thiệu về module Encoder quay: ........................................................................ 222
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn ) ......................................................... 222
Thông số kỹ thuật: .................................................................................................... 222
Lắp mạch: ................................................................................................................. 225
Lập trình :.................................................................................................................. 225
Hình ảnh thực tế:....................................................................................................... 228
26. Cài đặt và hiển thị nhiệt độ, độ ẩm (DTH11).................................................... 228
Giới thiệu về giao tiếp I2C: ...................................................................................... 228
Thông số kỹ thuật DHT11: ....................................................................................... 229
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn ). ........................................................ 229
Lập trình :.................................................................................................................. 231
Hình ảnh thực tế:....................................................................................................... 233
27. Điều khiển động cơ servo SG90: ........................................................................ 234
13
Giới thiệu về động cơ servo SG90:........................................................................... 234

Lắp mạch: ................................................................................................................. 235
Lập trình :.................................................................................................................. 235
Hình ảnh thực tế:....................................................................................................... 236
28. Điều khiển động cơ bước stepper 28BYJ-48: .................................................. 237
Giới thiệu về động cơ bước stepper 28BYJ-48: ...................................................... 237
Thông số kỹ thuật: .................................................................................................... 237
Lắp mạch: ................................................................................................................. 238
Lập trình :.................................................................................................................. 238
Hình ảnh thực tế:....................................................................................................... 240
29. Bật tắt LED bằng Remote hồng ngoại: ............................................................. 241
Giới thiệu về Remote hồng ngoại: ............................................................................ 241
Mắt thu hồng ngoại: .................................................................................................. 242
Lắp mạch: ................................................................................................................. 243
Lập trình:................................................................................................................... 243
Hình ảnh thực tế:....................................................................................................... 246
30. Điều khiển động cơ bằng module L298n:.......................................................... 246
Giới thiệu về Module L298: ..................................................................................... 246
Thông số kỹ thuật: .................................................................................................... 247
Lắp mạch................................................................................................................... 247
Lập trình:................................................................................................................... 248
31. Lập trình module Wifi ESP8266 V1 bằng Uno R3: ......................................... 250
Giới thiệu về module Wifi ESP8266 V1: ................................................................. 250
Thông số kỹ thuật: .................................................................................................... 250
14
Lắp mạch: ................................................................................................................. 251

Lập trình :.................................................................................................................. 252
Hình ảnh thực tế:....................................................................................................... 254
15
A. GIỚI THIỆU VỀ ARDUINO

Điều khiển thứ gì đó một cách tự động, ngoài việc phải hoàn chỉnh kết cấu
“phần cứng”, ta cần phải có mạch điện điều khiển và phải lập trình để mạch điện
đó hoạt động theo ý mình. Lập trình thì không khó học, chỉ khó ở giai đoạn thiết kế
mạch điều khiển là khó khăn nhất đối với những ai chưa biết về làm mạch thì càng
khó hơn ( còn được gọi thiết kế truyền thống). Và phải trải qua rất nhiều công đoạn
như sau:
Tuy nhiên có một thứ làm cho mọi chuyện trở nên rất dễ dàng, có tên gọi là
“Arduino”. Và trải qua các công đoạn ngắn gọn như sau:
16
So sánh các mô hình điều khiển được sử dụng bằng phương pháp thiết kế
“truyền thống” và từ thiết kế bằng “Arduino”.
Phương pháp Truyền Thống Phương pháp dùng Arduino
• Hiểu biết chuyên sâu về • Chủ yếu tập trung tìm hiểu
linh kiện điện tử. kết nối hệ thống, không cần
quan tâm đến việc vẽ mạch,
• Biết vẽ mạch, rửa mạch, in
làm mạch in,…
mạch,…
Kỹ Năng
• Biết lập trình ( việc lập trình
• Biết lập trình ( việc lập
dễ dàng do thư viện có sẵn
trình khó khăn do module
của các module được chuẩn
tự thiết kế không có chuẩn
hóa).
hóa ).
• Chỉ dành cho những giới • Dành cho giới chuyên ngành,
Đối Tượng chuyên ngành điện - điện không chuyên, thậm chí là
tử. học sinh cấp 1, 2,..
• Thời gian hoàn thành rất • Thời gian hoàn thành rất
lâu 1 tuần, có thể từ 1 đến nhanh.
2 tháng.
• Thời gian chủ yếu tập trung
Thời Gian • Thời gian tập trung chủ yếu vào hệ thống nên có thể làm
vào làm mạch, ít thời gian được những hệ thống phức
để phát triển quy mô hệ tạp hơn.
thống.
• Phát triển được kỹ năng • Phát triển được tư duy lập
Phát Triển thiết kế mạch, in mạch, trình hệ thống.
hàn,…
Chính vì sự tiện lợi như vậy, Arduino đã trở thành một hiện tượng trên toàn thế
giới, nếu bạn lên mạng tìm kiếm và gõ vào Arduino, bạn sẽ thấy hàng ngàn ứng
dụng khác nhau từ khắp mọi nơi trên thế giới sử dụng Arduino. Từ đó ta có thể
thấy được tầm ảnh hưởng của Arduino đến nhường nào.
17
I. ARDUINO LÀ GÌ?
Arduino không phải là cái gì cao siêu hết, chỉ là sử dụng chip AVR với những thứ
mà bạn sẽ cần đến như mạch giao tiếp (USB sang UART), mạch nguồn, có sẵn các
chân vào/ra để giao tiếp với cảm biến và các thiết bị ngoại vi.
Arduino rất đơn giản, dễ sử dụng, dễ code (ngôn ngữ tương tự như C/C++). Một
trong những cái hay nhất của Arduino là nó hỗ trợ rất nhiều thư viện, rất tiện lợi.
Nếu bạn muốn điều khiển động cơ, sẽ có các mạch công suất tương thích hoàn toàn
với Arduino. Nếu bạn muốn điều khiển qua mạng Internet, cũng có một mạch
Ethernet/Wifi tương thích hoàn toàn với Arduino. Và còn rất nhiều thứ khác nữa.
18
Arduino cũng có rất nhiều kích thước khác nhau, phù hợp cho nhiều mục đích sử
dụng. Thông dụng nhất hiện nay là Arduino Uno nhỏ gọn dành cho những ai đang
bắt đầu học về arduino.
II. ARDUINO LÀM ĐƯỢC NHỮNG GÌ?

Một số các dự án thú vị đã được thực hiện bằng Arduino.
Xe điều khiển:
19
Mô hình máy bay 4 cánh:
Máy in 3D:
20
Nhà thông minh:
Hệ thống tưới cây thông minh.
21
Hiệu ứng LED:
III. SƠ LƯỢC VỀ ARDUINO UNO R3

Board Arduino Uno nhỏ gọn và đầy đủ tính năng phù hợp cho những ai mới bắt
đầu học, Arduino Uno sử dụng chip Atmega328. Nó có 14 chân digital I/O, 6 chân
đầu vào (input) analog, thạch anh dao động 16Mhz.
22
1. Một số thông số kỹ thuật như sau :

Chip ATmega328
Điện áp cấp nguồn 5V
Điện áp đầu vào (input) (kiến 7-12V

nghị )
Điện áp đầu vào(giới hạn) 6-20V
Số chân Digital I/O 14 (có 6 chân điều chế độ rộng xung PWM)
Số chân Analog (Input ) 6
DC Current per I/O Pin 40 mA
DC Current for 3.3V Pin 50 mA
Flash Memory 32KB (ATmega328) với 0.5KB sử dụng

bootloader
SRAM 2 KB (ATmega328)
EEPROM 1 KB (ATmega328)
Xung nhịp 16 MHz
23
2. Sơ đồ chân của Arduino Uno.
• USB (1).
Arduino sử dụng cáp USB để giao tiếp với máy tính. Thông qua cáp USB chúng ta
có thể Upload chương trình cho Arduino hoạt động, ngoài ra USB còn là nguồn
cho Arduino.
• Nguồn ( 2 và 3 ).
Khi không sử dụng USB làm nguồn thì chúng ta có thể sử dụng nguồn ngoài
thông qua jack cắm 2.1mm ( cực dương ở giửa ) hoặc có thể sử dụng 2 chân Vin và
GND để cấp nguồn cho Arduino.
Bo mạch hoạt động với nguồn ngoài ở điện áp từ 5 – 20 volt. Chúng ta có thể
cấp một áp lớn hơn tuy nhiên chân 5V sẽ có mực điện áp lớn hơn 5 volt. Và nếu sử
dụng nguồn lớn hơn 12 volt thì sẽ có hiện tượng nóng và làm hỏng bo mạch.
Khuyết cáo các bạn nên dùng nguồn ổn định là 5 đến dưới 12 vol.
Chân 5V và chân 3.3V (Output voltage) : các chân này dùng để lấy nguồn ra từ
nguồn mà chúng ta đã cung cấp cho Arduino. Lưu ý : không được cấp nguồn vào
các chân này vì sẽ làm hỏng Arduino.
GND: chân mass.
24
• Chip Atmega328.
Chip Atmega328 Có 32K bộ nhớ flash trong đó 0.5k sử dụng cho bootloader.
Ngoài ra còn có 2K SRAM, 1K EEPROM.
• Input và Output ( 4 và 5 ).
Arduino Uno có các chân với chức năng input và output sử dụng các hàm
pinMode(), digitalWrite() và digitalRead() để điều khiển các chân này (Analog :
A0 đến A5) (digital : chân số 0 đến chân số 13).
Cũng trên 14 chân này chúng ta còn một số chân chức năng đó là:
Serial : chân 0 (Rx ), chân 1 ( Tx). Hai chân này dùng để truyền (Tx) và nhận (Rx)
dữ liêu nối tiếp TTL.
Chúng ta có thể sử dụng nó để giao tiếp với cổng COM của một số thiết bị hoặc
các linh kiện có chuẩn giao tiếp nối tiếp.
PWM (pulse width modulation): các chân 3, 5, 6, 9, 10, 11 trên bo mạch có
dấu “~” là các chân PWM chúng ta có thể sử dụng nó để điều khiển tốc độ động
cơ, độ sáng của
đèn…
SPI : 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK), các chân này hỗ trợ giao tiếp
theo chuẩn SPI.
I2C: Arduino hỗ trợ giao tiếp theo chuẩn I2C. Các chân A4 (SDA) và A5
(SCL) cho phép chúng tao giao tiếp giửa Arduino với các linh kiện có chuẩn giao
tiếp là I2C
• Reset (6): dùng để reset Arduino.
Nhưng đối với những ai mới bắt đầu tìm hiểu về arduino thì rất khó khăn chưa
kể đến là chưa biết gì về lập trình C, tuy thông tin tài liệu về arduino trên internet
là rất nhiều nhưng thiếu gắn kết thì bộ Ebook này là một một giải pháp tuyệt vời nó
ra đời để giúp những ai đang cảm giác thấy khó khăn trong lập trình arduino, nếu
ai đang muốn học lập trình arduino nên một lần đọc qua.
Nếu có sách không thì cũng chưa đủ chúng ta cần phải có thực hành, ứng dụng
những cái mình học từ lý thuyết thì BỘ KIT TỰ HỌC ARDUINO ra đời và kết
25
hợp với EBOOKS này giúp bạn thấy việc học lập trình arduino không còn khó
như ta nghĩ.
IV. SƠ LƯỢC BỘ KIT TỰ HỌC ARDUINO

1. Giới thiệu sơ lược về KIT TỰ HỌC:
Để giúp các bạn tiếp cận Arduino một cách dễ dàng nhất, dễ hiểu nhất đặc biệt có
thể giúp các bạn làm được những dự án, đề tài,…Thì sự ra đời của Kit Tự Học
Arduino ( là bộ cơ bản nhất từ dễ đến khó và Có tài liệu hướng dẫn chi tiết kèm
theo + CODE + Ebook lập trình điều khiển arduino ) cho người mới bắt đầu để
giúp các bạn học sinh, sinh viên và những ai mới bắt đầu học lập trình điều khiển
arduino thoát khỏi cảnh phải lay hoay đi tìm tài liệu để học.
2. Những lợi ích của Kit Tự Học Arduino:
a. Tất cả các linh kiện trong bộ tự học này shop đã tạo điều kiện tốt nhất
cho người thực hành ( ví dụ như led ma trận 8x8 đã được gắn vào board
đồng,…).
b. Trên board test mẫu ở hình trên 8 led đơn đã được kết nối với 8 điện trở
1k và đã đưa ra chân sẵn, cũng nhưbiến trở 10k đã đưa ra 3 chân.
c. Có 3 nút nhấn nhỏ đã được gắn trên một module đã đi mạch sẵn và đã
cho ra chân giúp việc kết nối dễ dàng.
26
d. Dây cắm test có nhiều kích cỡ khác nhau.

e. Kết nối giữa arduino và các module khác trong bộ tự học rất dễ dàng.
f. Khi bạn mua bộ Kit Tự Học này thì được tặng kèm file hướng dẫn sử
dụng Kit + CODE đối với từng module liên quan, các bạn không cần
phải đi tìm tài liệu học.
g. Trong file hướng dẫn sử dụng kit có tất cả hơn 25 bài học cơ bản liên
quan, mỗi bài học điều có code mẫu kèm theo.
h. Tất cả khách hàng mua kit tự học từ tdhshop đều được miễn phí dạy 1
buổi online.
i. Được tặng kèm theo 18 ebook tài liệu học arduino bằng tiếng anh.
j. Được tặng kèm theo 2 sổ tay Arduino ( LẬP TRÌNH ĐIỀU KHIỂN
ARDUINO V1, V2 và 2 cuốn ebook này được tổng hợp lại và điều chỉnh
cho phù hợp nhất), tổng hợp các lệnh, hàm,…cơ bản trong quá trình lập
trình arduino.
3. Mục đích của bộ KIT TỰ HỌC:
a. Điều khiển đèn led đơn ( nhấp nháy theo yêu cầu hay chạy theo hiệu
ứng).
b. Lập trình hiển thị số trên 1 led 7 đoạn.
c. Biết lập trình module 4 led 7 đoạn hiển thị thời gian, chữ cái, số,…
d. Biết lập trình led mat trận 8x8 hiển thị chữ cái, số, hiệu ứng,…
e. Biết cách lấy tín hiệu Analog (tín hiệu tương tự) và tín hiệu Digital (tín
hiệu số) từ cảm biến nhiệt độ, cảm biến ánh sáng,…
f. Biết cách nối dây và điều khiển role ( để đóng ngắt thiết bị điện).
g. Hiển thị được thông tin trên màn hình LCD.
h. Đọc giá trị nhiệt độ hiển thị lên LCD 16X02 thông qua cảm biến nhiệt độ
LM35.
i. Điều khiển đóng ngắt thiết bị điện dựa vào cài đặt giá trị nhiệt độ.
j. Lập trình điều khiển được động cơ chạy thuận nghịch và tăng giảm tốc
độ cho động cơ.
k. Lập trình điều khiển được động cơ sevor.
l. Sử dụng remote hồng ngoại điều khiển tắt mở thiết bị điện thông qua
role.
m. Biết đọc về giá trị cảm biến độ ẩm đất để thực hiện yêu cầu gì đó mà ta
cần phải làm.
n. Và có nhiều ứng dụng khác trong quá trình thực hành cùng Kit Tự Học
Arduino.
27
4. Một số bộ KIT TỰ HỌC ARDUINO:

• Kit Tự Học Arduino V1 các bạn có thể xem chi tết TẠI ĐÂY.
• Kit Tự Học Arduino M1 các bạn có thể xem chi tết TẠI ĐÂY.
Sự khác biệt giữa các KIT TỰ HỌC ARDUINO là số lượng bài học và số lượng
Module.
Giữa BỘ KIT loại V và M khác nhau ở chổ ( Bộ V sử dụng board Arduino Uno
R3 Còn Bộ M sử dụng boardArduino Mê ga 2560).
V. CÀI ĐẶT PHẦN MỀM IDE VÀ DRIVER

1. Cài đặt phần mềm Arduino IDE:
a. Cài Java Runtime Environment (JRE).
Vì Arduino IDE được viết trên Java nên bạn cần phải cài đặt JRE trước Arduino
IDE. Link: http://www.oracle.com/technetwork/java/javase/downloads/jre8-
downloads-2133155.html
28
Bản JRE phổ biến nhất là bản dành cho Windows 32bit (x86) và Windows 64bit
(x64) mình đã đánh dấu trong hình. Nhớ chọn "Accept License Agreement".
Việc cài đặt diễn ra rất đơn giản và nhanh chóng.
b. Cài đặt Arduino IDE:
• Bước 1: Truy cập địa chỉ: http://tdhshop.com.vn/tai-phan-men-arduino-

ide-cap-nhat-phien-ban-moi-nhat
Hoặc: https://www.arduino.cc/en/Main/Software
29
Bước 2: Sau khi download xong, các bạn bấm chuột phải vào file vừa
download arduino-1.8.5-windows.zip và chọn “Extract here” để giải nén.
Bước 3: Chạy file arduino.exe trong thư mục arduino-1.8.5\ để khởi

động Arduino IDE.
30
Sau khi chạy file arduino.exe ta có giao diên Arduino IDE:
2. Cài đặt Driver đối với Arduino Uno, mê ga,…:

a. Cài đặt Driver:
Đầu tiên, các bạn chạy file dpinst-x86.exe (Windows x86) hoặc dpinst-
amd64.exe (Windows x64) trong thư mục driver của file phần mềm IDE mình tải
về.
31
Cửa sổ “Device Driver Installation Wizard” hiện ra, các bạn chọn Next để tiếp
tục.
Khi có yêu cầu xác nhận cài đặt driver, chọn “Install”
32
Quá trình cài đặt đã hoàn tất. Bấm “Finish” để thoát.
b. Nạp chương trình cho Arduino Uno (mega tương tự):
Bước 1: Khởi động Arduino IDE:
33
Bước 2: Mở chương trình mẫu trên Arduino IDE (Blink)
Bước 3: Vào Tools các bạn chọn đúng nhé cái này rất quan trọng.
Kết quả ta có thể thấy Led chân số 13 (tích hợp trên board, led màu cam) của
Arduino Uno sáng 1 giây và tắt 1 giây.
34
3. Cài đặt Driver đối với Nano:

a. Giới thiệu board arduino Nano.
Board Arduino Nano là một trong những phiên bản nhỏ gọn của board Arduino.
Arduino Nano có đầy đủ các chức năng và chương trình có trên Arduino Uno
do cùng sử dụng MCU ATmega328P. Nhờ việc sử dụng IC dán của ATmega328P
thay vì IC chân cắm nên Arduino Nano có thêm 2 chân Analog so với Arduino
Uno.
b. Cài đặt driver cho Arduino Nano
Arduino Nano được kết nối với máy tính qua cổng Mini - B USB và sử dụng
chip CH340 để chuyển đổi USB sang UART thay vì dùng chip ATmega16U2 để
giả lập cổng COM như trên Arduino Uno hay Arduino Mega, nhờ vậy giá thành
sản phẩm được giảm mà vẫn giữ nguyên được tính năng, giúp Arduino giao tiếp
được với máy tính, từ đó thực hiện việc lập trình.
Trước hết chúng ta phải tải driver CH340 cho arduino nano TẠI ĐÂY:
 Bước 1: Giải nén thư mục vừa tải về ⇒ mở thư mục CH341SER ⇒khởi
động file SETUP.EXE
35
 Bước 2: Nhấn chọn INSTALL
 Bước 3: Hoàn tất cài đặt
c. Thông số kỹ thuật Arduino Nano:

IC chính ATmega328P
IC nạp và giao tiếp UART CH340
Điện áp hoạt động 5V - DC
Điện áp đầu vào khuyên dùng 7-12V - DC
Điện áp đầu vào giới hạn 6-20V - DC
Số chân Digital I/O 14 (trong đó có 6 chân PWM)
Số chân Analog 8 (độ phân giải 10bit, nhiều hơn Arduino Uno 2 chân)
Dòng tối đa trên mỗi chân I/O 40mA
Bộ nhớ flash 32KB với 2KB dùng bởi bootloader
SRAM 2KB
EEPROM 1KB
Xung nhịp 16MHz
Kích thước 0.73" x 1.70"
Chiều dài 45mm
36
d. Nạp chương trình cho Arduino Nano:
Bước 1: Khởi động Arduino IDE
Bước 2: Mở chương trình mẫu trên Arduino IDE (Blink)
37
Bước 3: Vào Tools các bạn chọn đúng nhé cái này rất quan trọng.
Kết quả ta có thể thấy Led chân số 13 (tích hợp trên board, led màu đỏ) của
Arduino Nano sáng 1 giây và tắt 1 giây.
VI. GIỚI THIỆU PHẦN MỀM ( FRITZING) HỔ TRỢ

VIỆC VẼ MẠCH NGUYÊN LÝ
1. Giới thiệu phần mềm Fritzing:
Để vẽ một sơ đồ mạch điện ứng dụng hoàn chỉnh, phục vụ cho quá trình học tập
và nghiên cứu thì bạn cần có nhiều kinh nghiệm và linh kiện điện tử để thử
nghiệm. Một giải pháp hiệu quả cho tình huống này là sử dụng phần mềm
Fritzing, bạn sẽ nhanh chóng tạo ra những sơ đồ mạch nguyên lý, sơ đồ lắp đặt có
hình ảnh trực quan.
Trong quá trình học lập trình Arduino chắc ai cũng đã nhìn thấy những hình
ảnh mạch kết nối của Arduino với một số linh kiện như hình ở dưới. Đó là phần
38
mền Fritzing, hiện tại phần mềm này miễn phí và rất trực quan rất có ích cho ai
học lập trình Arduino.
2. Dowload phần mềm Fritzing ( miễn phí):
Các bạn click vào links sau nhé: http://fritzing.org/download/ tải phần mềm
miễn phí với giao diện như sau:
39
3. Hướng dẫn sử dụng phần mềm:
Kết nối mạch trên Breadboard:
Chuyển qua sơ đồ nguyên lý:
40
B. NGÔN NGỮ LẬP TRÌNH ARDUINO

Ngôn ngữ lập trình Arduino có thể được chia thành ba phần chính:
+ Hàm chức năng (function).
+ Giá trị (các biến và các hằng số).
+ Cấu trúc (structure).
I. HÀM CHỨC NĂNG (FUNCTION):
Điều khiển board Arduino và thực hiện các phép tính.
41
1. Hàm nhập xuất Digital I/O:

a. digitalWrite():
Miêu tả:
Viết một giá trị HIGH hoặc một LOW cho một chân số của arduino.
Nếu chân đã được cấu hình như một OUTPUT với pinMode(), điện áp của
nó sẽ được thiết lập với giá trị tương ứng: 5V (hoặc 3.3V trên 3.3V)
cho HIGH, 0V cho LOW.
Nếu chân được cấu hình như là một INPUT, digitalWrite()sẽ cho phép
( HIGH) hoặc vô hiệu hóa ( LOW) pullup nội bộ trên chân đầu vào. Nên thiết
lập pinMode() để INPUT_PULLUP cho phép các điện trở kéo lên bên trong.
Cú pháp:
digitalWrite(pin, value);
Thông số:
pin: Số của chân digital mà bạn muốn thiết đặt.
value: HIGH hoặc LOW.
Trả về:
Không có.
Ví dụ:
Mã làm cho pin kỹ thuật số 13 OUTPUTvà chuyển đổi nó bằng cách luân
phiên giữa HIGHvà LOWở tốc độ một giây.
int led =13;
void setup()
{
42
pinMode(led, OUTPUT); // led được nối với chân số 13.

}
void loop()
{
digitalWrite(led, HIGH); // bật led
delay(1000); // dừng chương trình 1 giây
digitalWrite(led, LOW); // tắt led
delay(1000); // dừng chương trình 1 giây
}
Ghi chú:
Các chân đầu vào tương tự có thể được sử dụng như chân kỹ thuật số, được
gọi là A0, A1, v.v ...
b. digitalRead():
Miêu tả:
Đọc giá trị từ một Chân số đã được chỉ định, hoặc là HIGH hoặc LOW.
Cú pháp
digitalRead(pin)
Thông số
pin: số chân digital bạn muốn đọc.
Trả về
HIGH hoặc là LOW
Ví dụ:
int led = 12; // LED kết nối với chân số 12.

int nutnhan = 7; // nút nhấn kết nối với chân số 7
int val = 0; // biến để lưu trữ các giá trị đọc.
43
void setup ()
{
pinMode (led, OUTPUT); // chân số 12 là đầu ra.
pinMode (nutnhan, INPUT); // thiết lập chân số 7 như đầu vào.
}
void loop ()
{
val = digitalRead (nutnhan); // đọc các pin đầu vào
digitalWrite (led, val); // thiết lập giá trị của LED là giá trị của nút nhấn.
}
Ghi chú:
Nếu chân không được kết nối với bất cứ thứ gì, digitalRead () có thể trở lại
HIGH hoặc LOW (và điều này có thể thay đổi ngẫu nhiên).
Các chân đầu vào tương tự có thể được sử dụng như chân kỹ thuật số, được
gọi là A0, A1, v.v ...
c. pinMode():
Miêu tả:
Cấu hình 1 pin quy định hoạt động như là một đầu vào (INPUT) hoặc đầu ra
(OUTPUT).
44
Cú pháp:
pinMode(pin, mode)
Thông số:
pin: số chân có chế độ bạn muốn thiết lập.
mode: INPUT, OUTPUT, Hoặc INPUT_PULLUP.
Trả về:
Không có.
Ví dụ:
void setup()
{
pinMode (12, OUTPUT); // chân số 12 là đầu ra
}
void loop ()
{
digitalWrite (12, HIGH);
delay(1000);
digitalWrite (12, LOW);
delay(1000);
}
45
Ghi chú:
Các chân đầu vào tương tự có thể được sử dụng như chân số, được gọi là A0,
A1, v.v ...
2. Hàm nhập xuất Analog I/O:

a. analogRead()
Giới thiệu
Nhiệm vụ của analogRead() là đọc giá trị điện áp từ một chân Analog (ADC).
Board Arduino Uno có 6 pin từ A0 đến A5 (8 pin trên Mini và Nano, 16 pin
trên Mega), bộ chuyển đổi tương tự 10-bit sang số.
Điều này có nghĩa là nó sẽ lập bản đồ điện áp đầu vào từ 0 đến 5 volts thành
các số nguyên từ 0 đến 1023. Điều này tạo ra độ phân giải giữa các lần đọc: 5
volts / 1024 đơn vị hoặc, 0,0049 volt (4,9 mV) trên một đơn vị. Dải đầu vào
và độ phân giải có thể được thay đổi bằng cách sử dụng
Hàm analogRead() cần 100 micro giây để thực hiện.
Khi người ta nói "đọc tín hiệu analog", bạn có thể hiểu đó chính là việc đọc giá trị
điện áp.
Cú pháp
analogRead (pin) ;
Thông số
pin: Số chân đầu vào tương tự để đọc từ (0 đến 5 trên hầu hết các bo Arduino,
0 đến 7 trên Mini và Nano, 0 đến 15 trên Mega)
Trả về
int (0 đến 1023).
Ví dụ
Ví dụ đọc giá trị điện áp trên analogPin và hiển thị nó.
46
int analogPin = 4; // chân đọc giá trị analog A4

int val = 0; // lưu giá trị analog đọc về.
void setup()
{
Serial.begin(9600); // giao tiếp serial
}
void loop()
{
val = analogRead(analogPin); // đọc giá trị analog ở chân A4
Serial.println(val); // hiển thị ra cửa sổ serial
}
Ghi chú:
Nếu pin đầu vào tương tự không kết nối với bất cứ thứ gì, giá trị trả về bởi
analogRead () sẽ dao động dựa trên một số yếu tố (ví dụ: giá trị của các đầu
vào analog khác...).
b. analogReference ()
Miêu tả:
Cấu hình điện áp tham chiếu được sử dụng cho đầu vào analog (tức là giá trị
được sử dụng làm đầu vào). Các lựa chọn là:
Board Arduino (Uno, Mega, v.v.)

47
 DEFAULT: tham chiếu tương tự mặc định 5 volts or 3.3 volts.

 INTERNAL: đặt mức điện áp với 1,1 volts trên ATmega168 hoặc
ATmega328P và 2,56 volts trên ATmega8 (không dùng trên Arduino Mega).
 INTERNAL1V1: đặt mức điện áp tối đa 1.1V (chỉ dành cho Arduino Mega)
 INTERNAL2V56: đặt mức điện áp tối đa 2.56V (Arduino Mega)
 EXTERNAL: điện áp được áp dụng cho chân AREF (chỉ từ 0 đến 5V) được
sử dụng làm tham chiếu.
Board SAMD của Arduino (Zero, v.v ...)
 AR_DEFAULT: Đặt lại mức điện áp tối đa 3.3V

 AR_INTERNAL: Đặt lại mức điện áp tối đa 2.23V
 AR_INTERNAL1V0: Đặt lại mức điện áp tối đa 1.0V
 AR_EXTERNAL: điện áp được áp dụng cho chân AREF được sử dụng làm
tham chiếu.
Board Arduino SAM (Do)
 AR_DEFAULT: tham chiếu analog mặc định là 3.3V. Đây là tùy chọn duy
nhất được hỗ trợ cho Due.
Cú pháp
analogReference(type);
Thông số
type: một trong các kiểu giá trị sau: DEFAULT, INTERNAL, INTERNAL1V1,
INTERNAL2V56, hoặc EXTERNAL (xem danh sách các tùy chọn như trong
mô tả).
Trả về
Không có
48
Ghi chú
Nếu bạn sử dụng kiểu EXTERNAL cho hàm analogReference thì bạn phải cấp nó
một nguồn nằm trong khoảng từ 0-5V, và nếu bạn đã cấp một nguồn điện thỏa mãn
điều kiện trên vào chân AREF thì bạn phải gọi dòng
lệnh analogReference(EXTERNAL) trước khi sử dụng analogRead().
c. analogWrite()
Miêu tả
analogWrite() là lệnh xuất ra từ một chân trên mạch Arduino một mức tín hiệu
analog (phát xung PWM). Người ta thường điều khiển mức sáng tối của đèn LED
hay điều chỉnh tốc độ động cơ.
Tần số của tín hiệu PWM trên hầu hết các chân khoảng 490 Hz. Trên
board Uno và các board tương tự, chân 5 và 6 có tần số khoảng 980 Hz.
Bạn không cần gọi hàm pinMode() để đặt chế độ OUTPUT cho chân sẽ
dùng để phát xung PWM trên mạch Arduino.
Cú pháp:
analogWrite([chân phát xung PWM], [giá trị xung PWM]);
Giá trị mức xung PWM nằm trong khoảng từ 0 đến 255, tương ứng với mức duty
cycle từ 0% đến 100%
Trả về
Không có.
Ví dụ:
Đoạn code dưới có chức năng làm sáng dần một đèn LED được kết nối vào chân số
2 trên mạch Arduino.
int led = 2;
void setup() {
}
49
void loop() {
for (int i = 0; i <= 255; i++) {
analogWrite(led,i);
delay(20);
}
}
Đoạn code trên có chức năng làm sáng dần một đèn LED được kết nối vào chân số
11 trên mạch Arduino.
Hay ví dụ đặt đầu ra cho LED tỷ lệ với giá trị được đọc từ Cảm biến độ
ẩm đất:
int ledPin = 9;
int analogPin = 4; // chân A0 của cảm biến độ ẩm đất được nối với chân A4 của
arduino
int val = 0;
void setup()
{
pinMode(ledPin, OUTPUT);
}
void loop()
{
val = analogRead(analogPin);
analogWrite(ledPin, val / 4); // giá trị analogRead khoảng 0 to 1023,
analogWrite giá trị khoảng 0 to 255
}
d. analogReadResolution ():
Miêu tả
analogReadResolution () là một phần mở rộng của Analog cho Arduino Due, Zero
và MKR Family.
Board Due, Zero và MKR Family có các tính năng ADC 12-bit. Điều này sẽ trả
lại các giá trị từ analogRead() 0 đến 4095.
50
Cú pháp
analogReadResolution(bits)
Thông số
bits: xác định độ phân giải (tính theo bit) của giá trị trả về bởi
hàm analogRead(). Bạn có thể đặt giá trị này từ 1 đến 32. Bạn có thể đặt độ
phân giải cao hơn 12 nhưng giá trị trả về analogRead()sẽ bị xấp xỉ.
Trả về
Không có
Mã ví dụ
Ví dụ cho thấy cách sử dụng ADC với nhiều độ phân giải khác nhau.
void setup() {
Serial.begin(9600);
}
void loop() {
analogReadResolution(10);
Serial.print("ADC 10-bit (default) : ");
Serial.print(analogRead(A0));
Serial.print(", 12-bit : ");
/
51

Serial.println(analogRead(A0));
delay(100);
}
Ghi chú :
Nếu bạn đặt giá trị analogReadResolution() cho một giá trị cao hơn khả năng
của board, Arduino sẽ chỉ báo cáo lại ở độ phân giải cao nhất của nó, đệm
thêm các bit với số không.
e. analogWriteResolution ()
Miêu tả
analogWriteResolution() là một phần mở rộng của Analog cho Arduino Due.
analogWriteResolution()đặt độ phân giải của hàm analogWrite(). Nó mặc định là 8 bit

(giá trị từ 0-255) để tương thích được với arduino.
Board Due có khả năng phần cứng như sau:
 12 chân mà mặc định là 8-bit PWM, giống như board AVR. Có thể thay đổi độ
phân giải 12-bit.
 2 chân với 12-bit DAC (Bộ chuyển đổi Số-sang-tương tự)
 Bằng cách thiết lập độ phân giải ghi là 12, bạn có thể sử dụng analogWrite()với
các giá trị từ 0 đến 4095 để khai thác độ phân giải DAC đầy đủ hoặc để thiết lập
tín hiệu PWM mà không cần lăn lên.
Zero, có khả năng phần cứng như sau:
 10 chân mà mặc định là 8-bit PWM, giống như bảng AVR. Có thể thay đổi độ
phân giải 12-bit.
 1 chân với 10-bit DAC (Bộ chuyển đổi Số-sang-Analog).

 Bằng cách đặt độ phân giải ghi là 10, bạn có thể sử dụng analogWrite()với
các giá trị từ 0 đến 1023 để khai thác độ phân giải DAC đầy đủ
Các board MKR có các khả năng phần cứng sau đây:
 4 chân mà mặc định là 8-bit PWM, giống như board AVR. Có thể thay đổi từ
8 (mặc định) sang độ phân giải 12-bit.
52
 1 chân với 10-bit DAC (Bộ chuyển đổi Số-sang-tương tự)

 Bằng cách đặt độ phân giải cho 12 bit, bạn có thể sử dụng analogWrite()với
các giá trị từ 0 đến 4095 cho các tín hiệu PWM; đặt 10 bit trên pin DAC để
khai thác độ phân giải DAC đầy đủ 1024 giá trị.
Cú pháp
analogWriteResolution(bits)
Thông số
bits: xác định độ phân giải (theo bit) của các giá trị được sử dụng trong hàm
analogWrite(). Giá trị có thể dao động từ 1 đến 32. Nếu bạn chọn độ phân giải cao hơn
hoặc thấp hơn khả năng phần cứng của bảng, giá trị được sử dụng analogWrite()sẽ bị cắt
ngắn nếu nó quá cao hoặc có đệm bằng 0 nếu nó quá thấp.
Trả về
Không có
Ví dụ:
void setup(){
Serial.begin(9600);
pinMode(11, OUTPUT);
}
void loop(){
int sensorVal = analogRead(A0);

Serial.print("Analog Read) : ");
Serial.print(sensorVal);
analogWriteResolution(8);
analogWrite(11, map(sensorVal, 0, 1023, 0 ,255));
Serial.print(" , 8-bit PWM value : ");
Serial.print(map(sensorVal, 0, 1023, 0 ,255));
// on the Due
analogWrite(12, map(sensorVal, 0, 1023, 0, 4095));
Serial.print(" , 12-bit PWM value : ");
Serial.print(map(sensorVal, 0, 1023, 0, 4095));
53
analogWrite(13, map(sensorVal, 0, 1023, 0, 15));
Serial.print(", 4-bit PWM value : ");
Serial.println(map(sensorVal, 0, 1023, 0, 15));
delay(5);
}
3. Hàm nhập xuất nâng cao I/O:
a. noTone();
Miêu tả
Ngừng tạo ra một sóng vuông kích hoạt bởi tone(). Không có hiệu lực nếu
không có tone được tạo ra.
Cú pháp
noTone(pin)
Thông số
pin: chân để dừng tone
Trả về
Không có
b. pulseIn ()
Miêu tả:
Đọc thời gian của một xung (HIGH hoặc LOW) trên pin. Ví dụ: nếu giá
trị là CAO , pulseIn()đợi cho pin đi CAO , bắt đầu tính thời gian, sau đó đợi
cho pin để LOW và dừng thời gian. Trả về thời gian của xung trong các mili
giây. Cung cấp và trả về 0 nếu không có xung bắt đầu trong một khoảng thời
gian xác định.
Hoạt động trên xung từ 10 microseconds đến 3 phút chiều dài.
54
Cú pháp
pulseIn(pin, value)
pulseIn(pin, value, timeout)
Thông số
pin: số pin mà bạn muốn đọc xung. (int)
value: loại xung để đọc: HIGH hoặc LOW . (int)
timeout(tùy chọn): số microsecond chờ xung bắt đầu; mặc định là một giây
(unsigned long)
Trả về
Thời gian của một xung (trong micro giây) hoặc 0 nếu không có xung bắt đầu
trước khoảng thời gian chờ (unsigned long)
Ví dụ:
Ví dụ tính thời gian của một xung trên pin 9.
int pin = 9;
unsigned long duration;
void setup()
{
pinMode(pin, INPUT);
}
void loop()
{
duration = pulseIn(pin, HIGH);
}
c. shiftIn();
Cú pháp
byte incoming = shiftIn(dataPin, clockPin, bitOrder)
55
Thông số
dataPin: pin để nhập mỗi bit (int)
clockPin: chân để bật / tắt tín hiệu báo đọc từ dataPin
bitOrder: để thay đổi các bit; hoặc MSBFIRST hoặc LSBFIRST . (Bit quan
trọng nhất đầu tiên, hoặc, Bit quan trọng nhất trước tiên)
Trả về
Giá trị đọc (byte)
d. shiftOut();
Miêu tả:
shiftOut() có nhiệm vụ chuyển 1 byte (gồm 8 bit) ra ngoài từng bit một. Bit được
chuyển đi có thể được bắt đầu từ bit nằm bên trái nhất (leftmost) hoặc từ bit nằm
bên phải nhất (rightmost). Các bit này được xuất ra tại chân dataPin sau khi
chân clockPin được pulsed (có mức điện thế là HIGH, sau đó bị đẩy xuống LOW).
Lưu ý: Nếu bạn đang giao tiếp với một thiết bị mà chân clock của nó có giá trị
được thay đổi từ mức điện thế LOW lên HIGH (rising edge) khi shiftOut, thì bạn
cần chắc chắn rằng chân clockPin cần được chạy lệnh
này: digitalWrite(clockPin,LOW);
Cú pháp
shiftOut(dataPin, clockPin, bitOrder, value)
Thông số:
dataPin: pin sẽ được xuất ra tín hiệu ( int)
clockPin: pin dùng để xác nhận việc gửi từng bit của dataPin (int)
bitOrder: một trong hai giá trị MSBFIRST hoặc LSBFIRST.

(Bắt đầu từ bit bên phải nhất hoặc Bắt đầu từ bit bên trái nhất)
value: dữ liệu cần được shiftOut (byte)
56
Chú ý
shiftOut() chỉ xuất được dữ liệu kiểu byte. Nếu bạn muốn xuất một kiểu dữ liệu lớn
hơn thì bạn phải shiftOut 2 lần (hoặc nhiều hơn), mỗi lần là 8 bit.
Trả về
không
Ví dụ
Đầu tiên, chúng ta cần bật IC 595 lên. Bạn hãy nối mạch như sau:
 GND (pin 8) nối đến cực âm (GND)

 Vcc (pin 16) nối đến chân 5V
 OE (pin 13) nối đến cực âm (GND)
 MR (pin 10) nối đến chân 5V
/*
shiftOut với 8 LED bằng 1 IC HC595
*/
57
//chân ST_CP của 74HC595

int latchPin = 8;
//chân SH_CP của 74HC595
int clockPin = 12;
//Chân DS của 74HC595
int dataPin = 11;
//Trạng thái của LED, hay chính là byte mà ta sẽ gửi qua shiftOut
byte ledStatus;
void setup() {
//Bạn BUỘC PHẢI pinMode các chân này là OUTPUT
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}
void loop() {
//Sáng tuần tự
ledStatus = 0;//mặc định là không có đèn nào sáng hết (0 = 0b00000000)
for (int i = 0; i < 8; i++) {
ledStatus = (ledStatus << 1) | 1;//Đẩy toàn bộ các bit qua trái 1 bit và cộng bit có giá
trị là 1 ở bit 0
/**
Bắt buộc phải có để shiftOut
**/
digitalWrite(latchPin, LOW); //các đèn LED sẽ không sáng khi bạn digital LOW
//ShiftOut ra IC
shiftOut(dataPin, clockPin, MSBFIRST, ledStatus);
digitalWrite(latchPin, HIGH);//các đèn LED sẽ sáng với trạng thái vừa được cập nhập
/**
Kết thúc bắt buộc phải có
**/
delay(500); // Dừng chương trình khoảng 500 mili giây để thấy các hiệu ứng của đèn
LED
}
58
//Tắt tuần tự
for (int i = 0;i<8;i++) {
ledStatus <<= 1; //Đẩy tất cả các bit qua bên trái 1 bit
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, ledStatus);
digitalWrite(latchPin, HIGH);
delay(500);
}
}
e. tone();
Giới thiệu
Hàm này sẽ tạo ra một sóng vuông ở tần số được định trước (chỉ nửa chu kỳ) tại
một pin digital bất kỳ (analog vẫn được). Thời hạn của quá trình tạo ra sóng âm có
thể được định trước hoặc nó sẽ phát ra âm thanh liên tục cho đến khi Arduino IDE
chạy hàm (noTone). Chân digital đó cần được kết nối tới một buzzer hoặc một
loa để có thể phát được âm thanh.
Lưu ý rằng, chỉ có thể sử dụng duy nhất mộ hàm tone() trong cùng một thời điểm.
Nếu hàm tone() đang chạy trên một pin nào đó, bây giờ bạn lại tone() thêm một lần
nữa thì hàm tone() sau sẽ không có hiệu lực. Nếu bạn tone() lên pin đang
được tone() thì hàm tone() sau sẽ thay đổi tần số sóng của pin đó.
Trên mạch Arduino Mega, sử dụng hàm tone() thì sẽ can thiệp đến đầu ra PWM tại
các chân digital 3 và digital 11.
Chú ý: Nếu bạn muốn chơi nhiều cao độ khác nhau trên nhiều pin. Thì trước khi
chơi trên một pin khác thì bạn phải noTone() trên pin đang được sử dụng.
59
Cú pháp
tone(pin, frequency)
tone(pin, frequency, duration)
Tham số
pin: cổng digial / analog mà bạn muốn chơi nhạc (nói cách khác là pin được kết nối
tới loa)
frequency: tần số của sóng vuông (sóng âm)
duration: thời gian phát nhạc, đơn vị là mili giây (tùy chọn)
Trả về
Không có
4. Hàm thời gian:

a. delay()
Sự miêu tả
Tạm dừng chương trình cho khoảng thời gian (tính bằng mili giây) được chỉ
định là tham số. (Có 1000 mili giây = 1 giây.)
Cú pháp
delay(ms)
Thông số
ms: số mili giây để tạm dừng ( unsigned long)
Trả về
Không có
60
Ví dụ
int ledPin = 13; // LED pin 13
void setup()
{
}
void loop()
{
digitalWrite(ledPin, HIGH);
delay(1000);
digitalWrite(ledPin, LOW);
delay(1000);
}
b. delayMicroseconds ()
Miêu tả
Tạm dừng chương trình cho khoảng thời gian (tính bằng mili giây) được chỉ
định là tham số. Và cứ mỗi 1000000 micro giây = 1 giây
Cú pháp
delayMicroseconds(us)
Thông số
us: số microseconds để tạm dừng ( unsigned int)
Trả về
Không có
Ví dụ
int outPin = 7; // chan so 7
void setup()
{
61
pinMode(outPin, OUTPUT);
}
void loop()
{
digitalWrite(outPin, HIGH);
delayMicroseconds(50);
digitalWrite(outPin, LOW);
}
Ghi chú:
Chức năng này hoạt động rất chính xác trong phạm vi 3 micro giây. Và không thể
đảm bảo rằng delayMicroseconds sẽ thực hiện chính xác cho thời gian trễ nhỏ hơn.
c. micros()
Miêu tả:
micros() có nhiệm vụ trả về một số - là thời gian (tính theo micro giây) kể từ lúc mạch
Arduino bắt đầu chương trình của bạn. Nó sẽ tràn số và quay số 0 (sau đó tiếp tục tăng)
sau 70 phút. Tuy nhiên, trên mạch Arduino 16MHz (ví dụ Duemilanove và Nano) thì giá
trị của hàm này tương đương 4 đơn vị micro giây.
Lưu ý: 106 micro giây = 1 giây
Tham số
Không có
Trả về
Một số nguyên kiểu unsigned long là thời gian kể từ lúc thương trình Arduino
được khởi động
Ví dụ
unsigned long time;
void setup(){
Serial.begin(9600);
62
}
void loop(){
Serial.print("Time: ");
time = micros();
// in ra thời gian kể từ lúc chương trình được bắt đầu
Serial.println(time);
// đợi 1 giây trước khi tiếp tục in
delay(1000);
}
d. millis();
Giới thiệu
millis() có nhiệm vụ trả về một số - là thời gian (tính theo mili giây) kể từ lúc mạch
Arduino bắt đầu chương trình của bạn. Nó sẽ tràn số và quay số 0 (sau đó tiếp tục tăng)
sau 50 ngày.
Thông số
Không có
Trả về
Một số nguyên kiểu unsigned long là thời gian kể từ lúc thương trình Arduino
được khởi động
Ví dụ
unsigned long time;
void setup(){
Serial.begin(9600);
}
void loop(){
time = millis();
// in ra thời gian kể từ lúc chương trình được bắt đầu
Serial.println(time);
// đợi 1 giây trước khi tiếp tục in
63
delay(1000);
}
Lưu ý :
Các hàm về thời gian trong Arduino gồm millis() và micros() sẽ bị tràn số sau 1
thời gian sử dụng. Với hàm millis() là khoảng 50 ngày. Tuy nhiên, do là kiểu số
nguyên không âm (unsigned long) nên ta dễ dàng khắc phục điều này bằng cách sử
dụng hình thức ép kiểu.
unsigned long time;

byte ledPin = 10;
void setup()
{
// khởi tạo giá trị biến time là giá trị hiện tại
// của hàm millis();
time = millis();
}
void loop()
{
// Lưu ý các dấu ngoặc khi ép kiểu
// đoạn chương trình này có nghĩa là sau mỗi 1000 mili giây
// đèn Led ở chân số 10 sẽ thay đổi trạng thái
if ( (unsigned long) (millis() - time) > 1000)
{
// Thay đổi trạng thái đèn led

if (digitalRead(ledPin) == LOW)
{
} else {
}
// cập nhật lại biến time

time = millis();
}
}
64
5. Hàm toán học:
a. abs()
Mô tả
Hàm abs có nhiệm vụ trả về giá trị tuyệt đối của một số.
Cú pháp
abs(x);
Tham số
x: một số bất kỳ
Trả về
Nếu x >= 0, thì trả về x còn ngược lại là trả về -x
Chú ý cú pháp
abs(a--); // nếu bạn nhập như thế này thì sẽ bị lỗi đấy
a--;
abs(a); // nhưng nếu nhập như thế này thì ổn! Và hãy ghi nhớ là không được để
bất cứ phép tính nào bên trong hàm này, bạn nhé
b. constrain()
Giới thiệu
Bắt buộc giá trị nằm trong một khoảng cho trước.
Cú pháp
constrain(x, a, b)
65
Tham số
x: giá trị cần xét
a: chặn dưới (a là giá trị nhỏ nhất của khoảng)
b: chặn trên (b là giá trị lớn nhất của khoảng)
Trả về
x: nếu a <= x <= b
a: nếu x < a
b: nếu x > b
Ví dụ
int sensVal = analogRead(A2);
sensVal = constrain(sensVal, 10, 150); //Giới hạn giá trị sensVal trong khoảng [10,150]
c. map()
Mô tả
map() là hàm dùng để chuyển một giá trị từ thang đo này sang một giá trị ở thang
đo khác. Gía trị trả về của hàm map() luôn là một số nguyên.
Cú pháp
map(val,A1,A2,B1,B2);
Trong đó:
 val là giá trị cần chuyển đổi

 A1, A2 là giới hạn trên và dưới của thang đo hiện tại
 B1,B2 là giới hạn trên và dưới của thang đo cần chuyển tới
Ví dụ
//Chuyển đổi 37 độ C sang độ F
int C_deg = 37;
int F_deg = map(37,0,100,32,212); //F_deg = 98
66
d. max()
Miêu tả
Hàm max có nhiệm vụ trả về giá trị lớn nhất giữa hai biến.
Cú pháp
max(x, y);
Thông số
x: số thứ nhất, mọi kiểu dữ liệu đều được chấp nhận.
y: số thứ hai, mọi kiểu dữ liệu đều được chấp nhận.
Trả về
Số lớn nhất trong 2 số.
Hàm max được dùng để lấy chặn dưới (không để giá trị tụt xuống quá một mức
quy định nào đó).
e. min()
Mô tả
Hàm min có nhiệm vụ trả về giá trị nhỏ nhất giữa hai biến.
Cú pháp
min(x, y);
Tham số
x: số thứ nhất, mọi kiểu dữ liệu đều được chấp nhận.
y: số thứ hai, mọi kiểu dữ liệu đều được chấp nhận.
Trả về
Số nhỏ nhất trong 2 số.
Hàm min được dùng để lấy chặn trên (không để giá trị vượt quá một mức quy định nào
đó).
67
f. sq()
Giới thiệu
Hàm sq() được dùng để tính bình phường của một số bất kì, số này có thể thuộc bất
kì kiểu dữ liệu biển diễn số nào. sq() trả về giá trị mà nó tính được với kiểu dữ liệu
giống như kiểu dữ liệu của tham số ta đưa vào.
Cú pháp
sq([số cần tính bình phương]);
Ví dụ
int binhphuong1 = sq(5);
int binhphuong2 = sq(-5);
float binhphuong3 = sq(9.9);
float binhphuong4 = sq(-9.9);
//binhphuong1 = 25
//binhphuong2 = 25
//binhphuong3 = 98.01
//binhphuong4 = 98.01
g. sqrt()
Giới thiệu
sqrt() là hàm dùng để tính căn bậc 2 của một số bất kì (có thể là số nguyên hoặc số
thực tùy ý) và trả về kết quả này.
Cú pháp
sqrt([số cần tính căn bậc 2]);
Ví dụ
int v1 = sqrt(9);
float v2 = sqrt(6.4);
double v3 = sqrt(6.5256);
int v4 = sqrt(-9);
float v5 = sqrt(-6.4);
//v1 = 3
//v2 = 2.53
68
//v3 = 2.55
//v4 = 0
//v5 = NaN (tham khảo hàm isnan())
Chú ý
Tham số đưa vào hàm sqrt() có thể là bất kì kiểu dữ liệu biểu diễn số nào. Kết quả
trả về của sqrt() được định nghĩa là kiểu số thực double hoặc NaN nếu tham số đưa
vào là số thực bé hơn 0.
6. Hàm lượng giác:
a. cos()
Miêu tả
Hàm này có nhiệm vụ tính cos một một góc (đơn vị radian). Giá trị chạy trong
đoạn [-1,1].
Cú pháp
cos(rad)
Thông số
rad: góc ở đơn vị radian (kiểu float)
Trả về
cos của góc rad (kiểu double)
b. sin()
Giới thiệu
Hàm này có nhiệm vụ tính sin một một góc (đơn vị radian). Giá trị chạy trong
đoạn [-1,1].
Cú pháp
sin(rad)
69
Tham số
Trả về
sin của góc rad (kiểu double)
c. tan()
Giới thiệu
Hàm này có nhiệm vụ tính tan một một góc (đơn vị radian). Giá trị chạy trong
khoảng từ âm vô cùng đến dương vô cùng.
Cú pháp
tan(rad)
Tham số
Trả về
tan của góc rad (kiểu double)
7. Hàm số ngẫu nhiên:
a. random()
Mô tả
Trả về một giá trị nguyên ngẫu nhiên trong khoảng giá trị cho trước.
70
Cú pháp
random(max+1);
random(min,max+1);
Trong đó:
min và max là giá trị đầu và cuối của khoảng giá trị mà random() trả về.
Trả về
Giá trị nguyên ngẫu nhiên nằm trong khoảng từ min đến max. Nếu giá
trị min không được đưa vào thì nó được hiểu ngầm là 0.
Ví dụ
int a = random(100); //giá trị a nằm trong khoảng từ 0 đến 99
int b = random(0,11); //giá trị b nằm trong khoảng từ 0 đến 10
b. randomSeed()
Mô tả
Hàm random() luôn trả về một số ngẫu nhiên trong phạm vi cho trước. Giả sử mình
gọi hàm này 10 lần, nó sẽ trả về 10 giá trị số nguyên ngẫu nhiên. Nếu gọi
nó n lần, random()sẽ trả về n số. Tuy nhiên những giá trị mà nó trả về luôn được
biết trước (cố định).
Bạn hãy chạy thử chương trình sau
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.println(random(100));
delay(200);
}
Tôi có thể khẳng định rằng 10 giá trị "ngẫu nhiên" đầu tiên bạn nhận được là: 7,
49, 73, 58, 30, 72, 44, 78, 23, 9,.... Điều này nghe có vẻ không được "ngẫu nhiên"
cho lắm.
71
Bạn hãy thử chạy chương trình này:
void setup(){
Serial.begin(9600);
randomSeed(10);
}
void loop(){
Serial.println(random(100));
delay(200);
}
Nhận thấy rằng: chuỗi giá trị mà hàm random() trả về đã có sự thay đổi. Tuy nhiên
chuỗi này vẫn là chuỗi cố định. Thử thay đổi tham số của
lệnh randomSeed() từ 10 sang một số khác, bạn sẽ thấy chuỗi số trả về cũng thay
đổi theo nhưng giá trị xuất ra thì vẫn cố định, dù cho bạn có bấm nút reset trên
Arduino thì chuỗi số được in ra những lẫn sau đều y hệt như lần đầu tiên chúng
được in ra. Để ý rằng tham số của hàm random() vẫn cố định, dĩ nhiên nếu bạn
thay đổi tham số này thì chuỗi ngẫu nhiên trả về sẽ thay đổi theo, nhưng chúng
cũng vẫn là một chuỗi số cố định.
Với cùng khoảng giá trị truyền vào hàm random(), hàm randomSeed() quyết định
trật tự các giá trị mà random() trả về. Trật tự này phụ thuộc vào tham số mà ta
truyền vào randomSeed().
Cú pháp
randomSeed(number);
Với number là một số nguyên bất kì.
Lưu ý: nếu bạn gọi hàm random() mà không chạy lệnh randomSeed() trước đó,
chương trình sẽ mặc định chạy sẵn lệnh randomSeed(0) (tham số là 0).
Ví dụ
Nếu chạy randomSeed(0), hàm random(100) sẽ trả về 10 giá trị đầu tiên là:
7, 49, 73, 58, 30, 72, 44, 78, 23, 9, ...
Nếu chạy randomSeed(10), hàm random(100) sẽ trả về 10 giá trị đầu tiên là: 70 ,
43, 1, 92, 65, 26, 40, 98, 48, 67, ...
72
Nếu chạy randomSeed(-46), hàm random(100) sẽ trả về 10 giá trị đầu tiên là: 15,
50, 82, 36, 36, 37, 25, 59, 93, 74, ...
Nếu chạy randomSeed(159), hàm random(100) sẽ trả về 10 giá trị đầu tiên là: 13,
51, 67, 38, 22, 50, 67, 73, 81, 75, ...
Nếu chạy randomSeed(159), hàm random(99) sẽ trả về 10 giá trị đầu tiên là: 67,
42, 70, 34, 53, 6, 42, 38, 29, 64, ...
8. Bits và Bytes:
a. Bit()
Giới thiệu
Trả về một số nguyên dạng 2n (2 mũ n).
Cú pháp
bit(n)
Thông số
n: số nguyên
Trả về
số nguyên
Ví dụ
bit(0); // 2^0 = 1
bit(1); // 2^1 = 2
bit(2); // 2^2 = 4
// cũng có thể viết như sau

1 << 0 // = 1
1 << 1 // = 2
1 << 2 // = 4
73
b. bitClear()
Giới thiệu
bitClear() sẽ thay giá trị tại một bit xác định của một số nguyên thành 0.
Cú pháp
bitClear(x, n)
Tham số
x: một số nguyên thuộc bất cứ kiểu số nguyên nào
n: vị trí bit cần ghi. Các bit sẽ được tính từ phải qua trái, và số thứ tự đầu tiên là số
0.
Trả về
Không có
Ví dụ
bitClear(B11110010,1); // B11110000
c. bitRead()
Giới thiệu
bitRead() sẽ trả về giá trị tại một bit nào đó được xác định bởi người lập trình của
một số nguyên.
Cú pháp
bitRead(x, n)
Tham số
n: bit cần đọc. Các bit sẽ được tính từ phải qua trái, và số thứ tự đầu tiên là số 0
Trả về
Giá trị của 1 bit (1 hoặc là 0)
74
Ví dụ
bitRead(B11110010,0); // trả về 0
bitRead(B11110010,1); // trả về 1
bitRead(B11110010,2); // trả về 0
//Hàm bitRead có thể viết như sau

B11110010 >> 0 & 1 // = 0
B11110010 >> 1 & 1 // = 1
B11110010 >> 2 & 1 // = 0
d. bitWrite()
Giới thiệu
bitWrite() sẽ ghi đè bit tại một vị trí xác định của số nguyên.
Cú pháp
bitWrite(x, n, b)
Tham số
0.
b: 1 hoặc 0
Trả về
Không có
Ví dụ
bitWrite(B11110010,0,1); // B11110011
bitWrite(B11110010,1,0); // B11110000
bitWrite(B11110010,2,1); // B11110110
//Hàm bitWrite có thể viết như sau

B11110010 | (1 << 0) // = B11110011
B11110010 & ~(1 << 1) // = B11110000
75
B11110010 | (1 << 2) // = B11110110

e. bitSet()
Giới thiệu
bitSet() sẽ thay giá trị tại một bit xác định của một số nguyên thành 1.
Cú pháp
bitSet(x, n)
Tham số
0.
Trả về
Không có
Ví dụ
bitSet(B11110010,0); // B11110011
bitSet(B11110010,2); // B11110110
//Hàm bitSet có thể viết như sau

B11110010 | (1 << 0) // = B11110011
B11110010 | (1 << 2) // = B11110110
f. lowByte()
Giới thiệu
lowByte() là hàm trả về byte cuối cùng (8 bit cuối cùng) của một chuỗi các bit. Một
số nguyên bất kì cũng được xem như là một chuỗi các bit, vì bất kì số nguyên nào
cũng có thể biểu diễn ở hệ nhị phân dưới dạng các bit "0" và "1".
Lưu ý:
76
lowByte() không nhận giá trị thuộc kiểu dữ liệu số thực. Bạn sẽ gặp lỗi biên dịch
nếu cố làm điều này.
Cú pháp
lowByte([giá trị cần lấy ra 8 bit cuối]);
Trả về
byte
Ví dụ
int A = lowByte(0B11110011001100); //A = 0B11001100 = 204;
int B = lowByte(511); //B = lowByte(0B111111111) = 255;
int C = lowByte(5); //C = lowByte(0B00000101) = 0B101 = 5;
g. highByte()
Giới thiệu
highByte() là hàm trả về một chuỗi 8 bit kề với 8 bit cuối cùng của một chuỗi các
bit. Như vậy, nếu dữ liệu đưa vào một chuỗi 16bit thì highByte() sẽ trả về 8 bit đầu
tiên, nếu dữ liệu đưa vào là một chuỗi 8bit hoặc nhỏ hơn, highByte() sẽ trả về giá
trị 0. Một số nguyên bất kì cũng được xem như là một chuỗi các bit, vì bất kì số
nguyên nào cũng có thể biểu diễn ở hệ nhị phân dưới dạng các bit "0" và "1".
Lưu ý:
highByte() không nhận giá trị thuộc kiểu dữ liệu số thực. Bạn sẽ gặp lỗi biên dịch
nếu cố làm điều này.
Cú pháp
highByte([giá trị đưa vào]);
Trả về
byte
Ví dụ
int A = highByte(0B1111111100000000); //A = 0B11111111 = 255;
int B = highByte(0B10101010); //B = 0
int C = highByte(0B110000000011111111) //C = 0B00000000 = 0
int D = highByte(1023); //D = highByte(0B111111111) = 0B11 = 3
77
9. Hàm Ngắt (interrupt)

a. interrupts()
Giới thiệu
Mặc định, Arduino luôn bật các ngắt nên trong phần setup(), bạn không cần gọi
hàm này để bật các ngắt. Hàm interrupts() sẽ bật toàn bộ các ngắt đã được cài đặt.
Nếu vì lý do nào đó bạn tắt các ngắt bằng hàm noInterrupts(), bạn sử dụng hàm
này để bật lại các ngắt.
Cú pháp
interrupts();
Thông số
Không có
Trả về
Không có
Ví dụ
void setup() {}
void loop()
{
noInterrupts();
// tắt các ngắt để chạy
// đoạn chương trình yêu cầu cao về thời gian
interrupts();
// bật lại các ngắt, các ngắt hoạt động
// bình thường trở lại
}
78
b. noInterrupts()
Giới thiệu
Khi cần chạy các đoạn chương trình yêu cầu chính xác về thời gian, bạn cần tắt các
ngắt để Arduino chỉ tập trung vào xử lý các tác vụ cần thiết và chỉ duy nhất các tác
vụ này. Các ngắt chạy nền sẽ không được thực thi sau khi gọi hàm noInterrupts().
Cú pháp
noInterrupts();
Thông số
không
Trả về
không
Ví dụ
void setup() {}
void loop()
{
noInterrupts();
// tắt các ngắt để chạy
// đoạn chương trình yêu cầu cao về thời gian
interrupts();
// bật lại các ngắt, các ngắt hoạt động
// bình thường trở lại
}
79
10. Hàm Ngắt Ngoài:

a. attachInterrupt()
Giới thiệu
Ngắt (interrupt) là những lời gọi hàm tự động khi hệ thống sinh ra một sự kiện.
Những sự kiện này được nhà sản xuất vi điều khiển thiết lập bằng phần cứng và
được cấu hình trong phần mềm bằng những tên gọi cố định.
Vì ngắt hoạt động độc lập và tự sinh ra khi được cấu hình nên chương trình chính
sẽ đơn giản hơn. Một ví dụ điển hình về ngắt là hàm millis(). Hàm này tự động
chạy cùng với chương trình và trả về 1 con số tăng dần theo thời gian mặc dù
chúng ta không cài đặt nó. Việc cài đặt hàm millis() sử dụng đến ngắt và được cấu
hình tự động bên trong mã chương trình Arduino.
Vì sao cần phải dùng đến ngắt?
Ngắt giúp chương trình gọn nhẹ và xử lý nhanh hơn. Chẳng hạn, khi kiểm tra 1 nút
nhấn có được nhấn hay không, thông thường bạn cần kiểm tra trạng thái nút nhấn
bằng hàm digitalRead() trong đoạn chương trình loop(). Với việc sử dụng ngắt, bạn
chỉ cần nối nút nhấn đến đúng chân có hỗ trợ ngắt, sau đó cài đặt ngắt sẽ sinh ra
khi trạng thái nút chuyển từ HIGH->LOW. Thêm 1 tên hàm sẽ gọi khi ngắt sinh ra.
Vậy là xong, biến trong đoạn chương trình ngắt sẽ cho ta biết trạng thái nút nhấn.
Số lượng các ngắt phụ thuộc vào từng dòng vi điều khiển. Với Arduino Uno bạn
chỉ có 2 ngắt, Mega 2560 có 6 ngắt và Leonardo có 5 ngắt.
Cú pháp
attachInterrupt(interrupt, ISR, mode);
80
Thông số
interrupt: Số thứ tự của ngắt. Trên Arduino Uno, bạn có 2 ngắt với số thứ tự là 0
và 1. Ngắt số 0 nối với chân digital số 2 và ngắt số 1 nối với chân digital số 3.
Muốn dùng ngắt bạn phải gắn nút nhấn hoặc cảm biến vào đúng các chân này thì
mới sinh ra sự kiện ngắt. Nếu dùng ngắt số 0 mà gắn nút nhấn ở chân digital 4 thì
không chạy được rồi.
ISR: tên hàm sẽ gọi khi có sự kiện ngắt được sinh ra.
mode: kiểu kích hoạt ngắt, bao gồm
 LOW: kích hoạt liên tục khi trạng thái chân digital có mức thấp
 HIGH: kích hoạt liên tục khi trạng thái chân digital có mức cao.
 RISING: kích hoạt khi trạng thái của chân digital chuyển từ mức điện áp
thấp sang mức điện áp cao.
 FALLING: kích hoạt khi trạng thái của chân digital chuyển từ mức điện áp
cao sang mức điện áp thấp.
Lưu ý: với mode LOW và HIGH, chương trình ngắt sẽ được gọi liên tục khi chân
digital còn giữ mức điện áp tương ứng.
Trả về
không
Ví dụ
81
int ledPin = 12;
void tatled()
{
// tắt đèn led khi nhấn nút, nhả ra led nhấp nháy trở lại
}
void setup()
{
pinMode(2, INPUT_PULLUP); // sử dụng điện trở kéo lên cho chân số 2, ngắt 0
attachInterrupt(0, tatled, LOW);
}
void loop()
{
// đoạn chương trình này nhấp nháy led sau 500ms
delay(500);
delay(500);
}
b. detachInterrupt()
Giới thiệu
Hàm detachInterrupt() sẽ tắt các ngắt đã được kích hoạt tương ứng với thông số
truyển vào. Giả sử sau khi nhấn nút bấm lần đầu tiên đèn led sẽ tắt nhưng nhấn lần
thứ 2 đèn sẽ không tắt nữa. Lúc này cần dùng đến detachInterrupt() để tắt ngắt
chúng ta đã tạo ra.
Cú pháp
detachInterrupt(interrupt);
82
Thông số
interrupt: số thứ tự ngắt (xem thêm ở attachInterrupt() )
Trả về
không
Ví dụ
Đoạn chương trình dưới đây sẽ bật sáng đèn led và chỉ tắt nó khi nhấn lần đầu tiên, thả ra
đèn sẽ sáng lại. Nếu tiếp tục nhấn nữa thì đèn vẫn sáng mà không bị tắt đi.
int ledPin = 12; // đèn LED được kết nối với chân digital 12
boolean daNhan = false; // lưu giữ giá trị cho biết đã nhấn nút hay chưa
void tatled()
{
digitalWrite(ledPin, LOW); // tắt đèn led khi còn nhấn nút
daNhan = true; // lúc này đã nhấn nút
}
void setup()
{
pinMode(ledPin, OUTPUT); // thiết đặt chân ledPin là OUTPUT
pinMode(2, INPUT_PULLUP); // sử dụng điện trở kéo lên cho chân số 2, ngắt 0
83
attachInterrupt(0, tatled, LOW); // cài đặt ngắt gọi hàm tatled

}
void loop()
{
digitalWrite(ledPin, HIGH); // bật đèn led
if (daNhan == true)
{
// Nếu đã nhấn nút thì tắt ngắt đi
detachInterrupt(0);
}
}
11. Hàm Giao tiếp

a. Serial()
Thư viện Serial được dùng trong việc giao tiếp giữa các board mạch với
nhau (hoặc board mạch với máy tính hoặc với các thiết bị khác). Tất cả các
mạch Arduino đều có ít nhất 1 cổng Serial (hay còn được gọi là UART hoặc
USART). Giao tiếp Serial được thực hiện qua 2 cổng digital 0 (RX) và 1 (TX)
hoặc qua cổng USB tới máy tính. Vì vậy, nếu bạn đang sử dụng các hàm
của thư viện Serial này, bạn không thể sử dụng các chân digital 0 và digital
1 để làm việc khác được!
84
Bạn có thể sử dụng bảng Serial monitor có sẵn trong Arduino IDE để giao
tiếp với Arduino qua giao thức Serial. Kích vào biểu tượng Serial Monitor (
) hoặc nhấn tổ hợp phím Ctrl+Shift+M để mở bảng Serial Monitor, sau
đó bạn kích chuột vào bảng chọn như hình dưới để chọn baudrate giống
với baudrate được dùng trong quá trình lập trình của bạn. Mặc định là
9600.
12. Xử lý chuỗi:
a. Hàm isAlpha()
Hàm này kiểm tra xem ký tự đã truyền có phải là chữ cái không.
Cú pháp:
bool isAlpha(int c)
Thông số
Kiểu tham trị c: int
Trả về
Kiểu trả về: bool (true/ false)

85
Ví dụ
1. int t = 'b'; // kí tự
2. bool c1;
3. int c2;
4. void setup()
5. {
6. Serial.begin(9600);
7. c1 = isAlpha(t);
8. //hoặc c2=isalpha(t);
9. Serial.println(c1);
10. // Serial.println(c2);
11.}
12.void loop() { ; }
b. Hàm isAscii()
Kiểm tra kí tự đã truyền có thuộc bảng ASCII hay không.
Cú pháp:
bool isAscii(int c)
Kiểu tham trị c: int
Kiểu trả về:
bool (true/ false)
86
Bảng tra cứu:
c. Hàm isWhitespace()
Kiểm tra xem kí tự đã truyền có phải là kí tự cách (‘ ‘) hoặc( ‘\t’) không .
Cú pháp
bool isWhitespace(int c)
Kiểu tham trị c:
int
Kiểu trả về:
bool (true/ false)
Ví dụ
int t = ' '; // kí tự “trắng”
bool c1;
87
void setup(){
Serial.begin(9600);
c1 = isWhitespace(t);
Serial.println(c1);
void loop() { ; }
d. Hàm isPrintable():
Hàm này kiểm tra xem ký tự đã truyền có thể in được không
Cú pháp
bool isPrintable(int c)

int
Kiểu trả về:

bool (true/ false)
Ví dụ
int t = 'a'; // a là kí tự có thể in (xem lại bảng)
bool c1;
int c2;
void setup(){
Serial.begin(9600);
c1 = isPrintable(t);
//c2=isprint(t);
Serial.println(c1);
88
//Serial.println(c2);
void loop() { ; }
e. Hàm isUpperCase():
Hàm này kiểm tra xem ký tự đã truyền có phải là một chữ hoa không
Cấu trúc
bool isUpperCase(int c )

int
Kiểu trả về:

bool (true/ false)
Ví dụ
int t = 'A'; // A là một kí tự viết hoa (xem lại bảng)
bool c1;
int c2;
void setup()
{
Serial.begin(9600);
c1 = isUpperCase(t);
//c2=isupper(t);
Serial.println(c1);
}
89
void loop() { ; }
f. Hàm isHexadecimalDigit()
Hàm này kiểm tra xem ký tự đã truyền có phải là ký tự thập lục phân không
Cấu trúc
bool isHexadecimalDigit(int c)

int
Kiểu trả về:
bool (true/ false)
Ví dụ
int t = 'A'; // A là một kí tự (có giá trị ) thuộc dãy thập lục phân (số Hex)(xem
lại bảng)
bool c1;
int c2;
void setup() {
Serial.begin(9600);
c1 = isHexadecimalDigit(t);
// c2=isxdigit(t);
Serial.println(c1);
// Serial.println(c2);
void loop() { ; }
90
g. tolower:
Hàm này chuyển đổi các chữ cái hoa thành chữ thường
Cú pháp
int tolower(int c)

int
Kiểu trả về:

int
Ví dụ
int t1 = 'A'; // Đổi chữ A thành a. (xem lại bảng)
int t2;
void setup() {
t2 = tolower(t1);
// kết quả t2='a'
void loop() { ; }
h. Hàm toupper()
Hàm này chuyển đổi các chữ cái thường thành chữ hoa.
91
Cú pháp
int toupper(int c)

int
Kiểu trả về:

int
Ví dụ
int t1 = 'h'; // Đổi chữ h thành H. (xem lại bảng)
int t2;
void setup() {
t2 = toupper(t1);
// kết quả t2='H'
void loop() { ; }
i. Hàm isLowerCase()
Hàm này kiểm tra xem ký tự đã truyền có phải là một chữ thường không
Cấu trúc
bool isLowerCase(int c)

int
Kiểu trả về:

bool (true/ false)
92
Ví dụ
int t = 'a'; // a là chữ thường (không viết in hoa) (xem lại bảng)
bool c1;
int c2;
void setup()
Serial.begin(9600);
c1 = isLowerCase(t);
//c2=islower(t);
Serial.println(c1);
void loop() { ; }
II. GIÁ TRỊ :
93
1. Hằng số
a. Hằng số thực:
Giới thiệu
Hằng số thực (floating point constants) cũng có cách làm việc và sử dụng tương tự.
Khi bạn viết một biểu thức tính toán, giá trị của biểu thức này sẽ được tính ra và
trình biên dịch sẽ thay thế biểu thức này bằng một hằng số thực đã tính ra được.
Điều đó gợi ý rằng trong những chương trình lớn, để giảm thời gian biên dịch, bạn
nên tính trước giá trị của những biểu thức thay vì bắt trình biên dịch tính toán.
Ví dụ
float a = .159;
float b = 0.159; // a = b
Để biểu thị những hằng số thực có giá trị cực lớn hoặc cực nhỏ, bạn phải sử dụng 2
kí hiệu khoa học là "E" và "e".
Hằng số thực Ý nghĩa Giá trị
10.0 10
2.34E5 2.34 * 105 234000
67e-12 67.0 * 10-12 0.000000000067
b. Hằng số nguyên
Giới thiệu
Hằng số nguyên là những con số được sử dụng trực tiếp trong chương trình. Theo
mặc định, những con số này có kiểu là int (trong pascal thì kiểu int giống như kiểu
integer).
Ví dụ
if (a >= 10) {
a = 0;
}
94
Ở đây 0 và 10 được gọi là những hằng nguyên.
Thông thường, các hằng số nguyên được biểu thị dưới dạng thập phân, nhưng bạn
có thể biểu thị chúng trong các hệ cơ số khác như sau:
Hệ cơ số Ví dụ Định dạng Ghi chú
10 (thập phân) 159 biểu thị bằng các chữ số từ 0 đến 9
bắt đầu bằng 'B'

2 (nhị phân) B1111011 biểu thị bằng 2 chữ số 0 và 1
(hoặc '0B')
8 (bát phân) 0173 bắt đầu bằng '0' biểu thị bằng các chữ số từ 0-7
biểu thị bằng các chữ số từ 0-9 và kí tự

16 (thập lục phân) 0x7B bắt đầu bằng '0x'
từ A-F (hoặc a-f)
Hệ thập phân (decimal) là hệ cơ số 10, cũng là hệ cơ số được dùng phổ biến nhất.
Ví dụ:
int a = 101; // có giá trị là 101 ở hệ thập phân ((1 * 10^2) + (0 * 10^1) + 1)
Hệ nhị phân (binary) là hệ cơ số 2, chỉ được biểu thị bởi 2 chữ số "0" và "1", có
tiền tố "B" (đôi khi là "0B") đứng đầu
Ví dụ:
int a = B101; // có giá trị là 5 ở hệ thập phân ((1 * 2^2) + (0 * 2^1) + 1)
Các định dạng nhị phân chỉ hoạt động trên byte (8 bit) giữa 0 (B0) và 255
(B11111111). Nếu muốn sử dụng hệ nhị phân trên một số nguyên int (16 bít) thì
bạn phải thực hiện quy trình 2 bước như sau:
long myInt = (B11100000 * 256) + B11111111; // myInt = B1110000011111111
95
Hệ bát phân (octal) là hệ cơ số 8, chỉ dùng các chữ số từ 0-7 để biểu thị, có tiền tố
"0" đứng đầu
int a = 0101; // có giá trị là 65 ở hệ thập phân ((1 * 8^2) + (0 * 8^1) + 1)
Chú ý:
Rất khó để tìm lỗi một cách dễ dàng nếu bạn không cẩn thận hoặc không thành
thạo trong việc sử dụng hệ bát phân.
Lý do là giả sử bạn muốn khai báo một hằng số nguyên ở hệ thập phân ví dụ 161,
nhưng do chưa đọc bài này nên bạn "chơi trội" đặt thêm số 0 phía trước. =>
chương trình dịch hiểu sai hệ số bạn đang sử dụng => sinh ra lỗi logic khiến
chương trình chạy sai.
Hệ thập lục phân (hexadecimal) là hệ cơ số 16, chỉ dùng các chữ số từ 0-9 và
A-F (hoặc a-f) để biểu thị; A đại diện cho 10, B là 11, lên đến F là 15. Các chữ số
dùng ở hệ này có tiền tố "0x" đứng trước
Ví dụ:
int a = 0x101; // có giá trị là 257 trong hệ thập phân ((1 * 16^2) + (0 * 16^1) +
1)
Hậu tố U và L
Theo mặc định, một hằng số nguyên được coi là một số nguyên kiểu int với những
hạn chế trong giao tiếp giữa các giá trị. Để xác định một hằng số nguyên với một
kiểu dữ liệu khác, bạn phải tuân theo quy tắc sau:
 Dùng 'u' hoặc 'U' để biểu thị kiểu dữ liệu unsigned (không âm). Ví dụ: 33u
 Dùng 'l' hoặc 'L' để biểu thị kiểu dữ liệu long. Ví dụ: 100000L
 Dùng 'ul' hoặc 'UL' để biểu thị kiểu dữ liệu unsigned long. Ví dụ: 32767ul
96
c. HIGH
HIGH là một hằng số có giá trị nguyên là 1
Xét đoạn code ví dụ sau:
int led1 = 12;
void setup() {
pinMode(led1, OUTPUT);
digitalWrite(led1, HIGH);
}
void loop() {
}
Đoạn code này có chức năng bật sáng đèn led1 nối với chân số 12 trên mạch
Arduino (Arduino Nano, Uno R3, Mega 2560, ...). Bạn có thể tải đoạn chương
trình này lên mạch Arduino của mình để kiểm chứng. Sau đó, hãy thử tải đoạn
chương trình này lên:
int led1 = 12;
void setup() {
pinMode(led1, OUTPUT);
digitalWrite(led1, 1);
}
void loop() {
}
Sẽ xuất hiện 2 vấn đề:
 Trong đoạn code thứ 2, "HIGH" đã được sửa thành "1".

 Đèn led trên mạch Arduino vẫn sáng bình thường với 2 chương trình khác
nhau.
Điều này khẳng định "HIGH là một hằng số có giá trị nguyên là 1" đã nêu ở trên.
97
HIGH là một điện áp lớn hơn 0V
Điện áp ở mức HIGH không có giá trị cụ thể như 3.3V, 5V, 9V, ... mà trong mỗi
loại mạch điện, nó có trị số khác nhau và đã được quy ước trước. Trong các mạch
Arduino, HIGH được quy ước là mức 5V mặc dù 4V vẫn có thể được xem
là HIGH. Ví dụ như trong mạch Arduino Uno R3, theo nhà sản xuất, điện áp được
xem là ở mức HIGH nằm trong khoảng từ 3V đến 5V.
d. LOW
LOW là một hằng số có giá trị nguyên là 0
Xét đoạn code ví dụ sau:
int led = 12;
void setup() {
pinMode(led, OUTPUT);
}
void loop() {
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
}
Đoạn code này có chức năng bật sáng đèn led nối với chân số 12 trên mạch
Arduino (Arduino Nano, Uno R3, Mega 2560, ...). Sau đó, hãy thử tải đoạn chương
trình này lên:
int led = 13;
void setup() {
}
void loop() {
delay(1000);
98
digitalWrite(led, 0);
delay(1000);
}
Sẽ xuất hiện 2 vấn đề:
 Trong đoạn code thứ 2, "LOW" đã được sửa thành "0".

 Đèn led trên mạch Arduino vẫn sáng bình thường với 2 chương trình khác
nhau.
Điều này khẳng định "LOW là một hằng số có giá trị nguyên là 0" đã nêu ở trên.
LOW là một điện áp lớn hơn 0V
Điện áp ở mức LOW không có giá trị cụ thể như 3.3V, 5V, 9V, ... mà trong mỗi
loại mạch điện, nó có một trị số khác nhau nhưng thường là 0V hoặc gần bằng
0V.
Trong các mạch Arduino, LOW được quy ước là mức 0V mặc dù 0.5V vẫn có thể
được xem là LOW.
e. INPUT:
Các Chân kỹ thuật số có thể được sử dụng được giá trị này. Để thay đổi cách sử
dụng một pin, chúng ta sử dụng hàm pinMode().
Cấu hình một pin là INPUT
Các pin của Arduino ( Atmega ) được cấu hình là một INPUT với pinMode ( ) có
nghĩa là làm cho pin ấy có trở kháng cao (không cho dòng điện đi ra) . Pin được
cấu hình là INPUT làm việc tiêu thụ năng lượng điện của mạch rất nhỏ, nó tương
đương với một loạt các điện trở 100 Mega-ôm ở phía trước của pin . Điều này làm
cho chúng cực kì hữu ích cho việc đọc một cảm biến, nhưng không cung cấp năng
lượng một đèn LED.
f. INPUT_PULLUP
99
Cấu hình một pin là INPUT_PULLUP
Chip Atmega trên Arduino có nội kéo lên điện trở (điện trở kết nối với hệ thống
điện nội bộ) mà bạn có thể truy cập. Nếu bạn không thích mắc thêm một điện trở ở
mạch ngoài, bạn có thể dùng tham số INPUT_PULLUP trong pinMode().
Mặc định khi không được kết nối với một mạch ngoài hoặc được kết nối với cực
dương thì pin sẽ nhận giá trị là HIGH, khi pin được thông tới cực âm xuống đất thì
nhận giá trị là LOW.
g. OUTPUT
Để thiết đặt pin là một OUTPUT, chúng ta dùng pinMode ( ), điều này có nghĩa là làm
cho pin ấy có một trở kháng thấp (cho dòng điện đi ra). Điều này có nghĩa, pin sẽ cung
cấp một lượng điện đáng kể cho các mạch khác . Pin của vi điều khiển Atmega có thể
cung cấp một nguồn điện liên tục 5V hoặc thả chìm ( cho điện thế bên ngoài chạy vào )
lên đến 40 mA ( milliamps ). Điều này làm cho chúng hữu ích để tạo năng lượng đèn
LED nhưng vô dụng đối với các cảm biến đọc!
h. LED_BUILTIN
Hầu hết các mạch Arduino đều có một pin kết nối với một LED (led nằm trên
mạch) nối tiếp với một điện trở. LED_BUILTIN là một hằng số thay thế cho việc
tuyên bố một biến có giá trị điều khiển on-board LED. Hầu hết trên các mạch
Arduino, chúng có giá trị là 13
i. true
Giới thiệu
true là một hằng logic. Bạn cũng có thể HIỂU true là một HẰNG SỐ NGUYÊN
mang giá trị là 1. Trong các biểu thức logic, một hằng số hay giá trị của một biểu
thức khác 0 được xem như là mang giá trị true.
100
Lưu ý
 Không được viết "true" thành TRUE hay bất kì một dạng nào khác.
 Các giá trị sau là tương đương nhau: true, HIGH, 1
j. false
Giới thiệu
Trái lại với true, false là một hằng logic có giá trị là phủ định của true (và ngược
lại), tức là (!true) = false. Bạn cũng có thể HIỂU false là một hằng số nguyên
mang giá trị là 0. Trong các biểu thức logic, một hằng số hay giá trị của một biểu
thức bằng 0 được xem như là bằng false.
Lưu ý
 Không được viết "false" thành FALSE hay bất kì một dạng nào khác.
 Các giá trị sau là tương đương nhau: false, LOW, 0
2. Kiểu dữ liệu:
a. void
Miêu tả
"void" là một từ khóa chỉ dùng trong việc khai báo một function. Những function
được khai báo với "void" sẽ không trả về bất kì dữ liệu nào khi được gọi.
Ví dụ
led = 10;
void setup() {
}
void loop() {
blink();
}
void blink() {
101
delay(3000);
delay(1000);
}
Giải thích
e. "blink" là một function được định nghĩa với từ khóa "void", do đó nó

không trả về một giá trị nào. Nhiệm vụ của "blink" chỉ là làm nhấp nháy
đèn LED ở chân số 13 trên mạch Arduino.
f. Bạn có thể thấy rằng những function kiểu này không dùng lệnh "return"
để trả về giá trị của function.
b. boolean
Giới thiệu
Một biến được khai báo kiểu boolean sẽ chỉ nhận một trong hai giá
trị: true hoặc false. Và bạn sẽ mất 1 byte bộ nhớ cho điều đó.
Lưu ý
Những cặp giá trị sau là tương đương nhau. Về bản chất, chúng đều là những hằng
số nguyên với 2 giá trị 0 và 1:
 true - false
 HIGH - LOW
 1-0
Ví dụ:
int led = 10;
boolean led_status;
void setup() {
led_status = true; // led ở trạng thái bật
}
void loop() {
102
digitalWrite(led, led_status); // bật đèn, led_status = 1

delay(1000);
digitalWrite(led, !led_status); // tắt đèn, !led_status = 0
delay(1000);
}
c. int:
Giới thiệu
Kiểu int là kiểu số nguyên chính được dùng trong chương trình
Arduino. Kiểu int chiếm 2 byte bộ nhớ !
Trên mạch Arduino Uno, nó có đoạn giá trị từ -32,768 đến 32,767 (-215 đến 215-1)
(16 bit)
Trên mạch Arduino Due, nó có đoạn giá trị từ -2,147,483,648 đến 2,147,483,647 (-
231 đến 231-1) (32 bit) (lúc này nó chiếm 4 byte bộ nhớ)
103
Ví dụ
int ledPin = 10;
Cú pháp
int var = val;
var: tên biến
val: giá trị
d. unsigned int
Giới thiệu
Kiểu unsigned int là kiểu số nguyên nằm trong khoảng từ 0 đến 65535 (0 đến 216 -
1). Mỗi biến mang kiểu dữ liệu này chiếm 2 byte bộ nhớ.
Lưu ý
Trên Arduino Due, unsigned int có khoảng giá trị từ 0 đến 4,294,967,295 (232 - 1)
(lúc này nó chiếm 4 byte bộ nhớ).
Bạn có thể dễ dàng nhận ra rằng kiểu dữ liệu này không chứa các giá trị âm so với
kiểu int.
Cú pháp
unsigned int [tên biến] = [giá trị];
Ví dụ
unsigned int ledPin = 10;
Khi một biến kiểu unsigned int được gán trị vượt ngoài phạm vi giá trị (bé hơn 0
hoặc lớn hơn 65525), giá trị của biến này sẽ tự động được đẩy lên giới hạn trên
hoặc giới hạn dưới trong khoảng giá trị của nó.
unsigned int x = 0; // x nhận giá trị trong khoảng từ 0 đến 65535

x=x-1 // x = 0 - 1 = 65535 (giới hạn trên của x)
x=x+1 // x = 65535 + 1 = 0 (giới hạn dưới của x)
104
e. char
Giới thiệu
Kiểu dữ liệu này là kiểu dữ liệu biểu diễn cho 1 KÝ TỰ (nếu bạn cần biểu diễn
một chuỗi trong chương trình Arduino - bạn cần sử dụng kiểu dữ liệu String). Kiểu
dữ liệu này chiếm 1 byte bộ nhớ!
Kiểu char chỉ nhận các giá trị trong bảng mã ASCII.
Kiểu char được lưu dưới dạng 1 số nguyên byte có số âm (có các giá trị từ -127 -
128), thay vì thiết đặt một biến kiểu char có giá trị là 'A', bạn có thể đặt là 65. Để
hiểu rõ hơn bạn xem ví dụ dưới đây.
Ví dụ
char myChar = 'A';
char myChar = 65; // cả 2 cách khai báo đều hợp lệ
f. unsigned char
Giới thiệu
Giống hệt bài giới thiệu về kiểu char. Tuy nhiên kiểu unsigned char lại biểu hiệu
một số nguyên byte không âm (giá trị từ 0 - 255).
Ví dụ
unsigned char myChar = 240;
g. byte
Giới thiệu
Là một kiểu dữ liệu biểu diễn số nguyên nằm trong khoảng từ 0 đến 255. Bạn sẽ mất 1
byte bộ nhớ cho mỗi biến mang kiểu byte
Ví dụ
byte a = 123; //khai báo biến a mang kiểu byte, có giá trị là 123
105
h. word
Giới thiệu
Giống như kiểu unsigned int, kiểu dữ liệu này là kiểu số nguyên 16 bit không âm
(chứa các giá trị từ 0 đến 65535), và nó chiếm 2 byte bộ nhớ!
Ví dụ
word a = 2000;
i. long
Giới thiệu
long là một kiểu dữ liệu mở rộng của int. Những biến có kiểu long có thể mang giá
trị 32bit từ -2,147,483,648 đến -2,147,483,647. Bạn sẽ mất 4 byte bộ nhớ cho một
biến kiểu long.
Khi tính toán với số nguyên (biến kiểu int), bạn phải thêm hậu tố "L" phía sau các
số nguyên kiểu int để chuyển chúng sang kiểu long. Việc tính toán (cộng, trừ,
nhân,...) giữa 2 số thuộc 2 kiểu dữ liệu khác nhau là không được phép.
Ví dụ
long a = 10;
long b = a + 10L // b = 20.
j. unsigned long
Giới thiệu
Kiểu unsigned long là kiểu số nguyên nằm trong khoảng từ 0 đến

4,294,967,295 (0 đến 232 - 1). Mỗi biến mang kiểu dữ liệu này chiếm 4 byte bộ
nhớ.
Ví dụ
unsigned long time;
void setup()
{
Serial.begin(9600);
}
106
void loop()
{
time = millis();
Serial.println(time);//Xuất thời gian lúc chạy hết đoạn lệnh trên
delay(1000);
}
k. short
Giới thiệu
Giống hệt kiể int, tuy nhiên có điều trên mọi mạch Arduino nó đều chiếm 4 byte bộ
nhớ và biểu thị giá trị trong khoảnf -32,768 đến 32,767 (-215 đến 215-1) (16 bit).
Ví dụ
short ledPin = 13;
Cú pháp
short var = val;
var: tên biến
val: giá trị
l. float
Giới thiệu
Để định nghĩa 1 kiểu số thực, bạn có thể sử dụng kiểu dữ liệu float. Một biến dùng
kiểu dữ liệu này có thể đặt một giá trị nằm trong khoảng -3.4028235E+38 đến
3.4028235E+38. Nó chiếm 4 byte bộ nhớ.
Với kiểu dữ liệu float bạn có từ 6-7 chữ số có nghĩa nằm ở bên mỗi bên dấu
".". Điều đó có nghĩa rằng bạn có thể đặt một số thực dài đến 15 ký tự (bao gồm
dấu .)
107
Lưu ý
Để biểu diễn giá trị thực của một phép chia bạn phải 2 số thực chia cho lẫn nhau.
Ví dụ: bạn xử lý phép tính 5.0 / 2.0 thì kết quả sẽ trả về là 2.5. Nhưng nếu mà bạn
xử lý phép tính 5 / 2 thì kết quả sẽ là 2 (vì hai số nguyên chia nhau sẽ ra một số
nguyên).
Ví dụ
float myfloat;
float sensorCalbrate = 1.117;
Cú pháp
float var = val;
var: tên biến
val: giá trị
Ví dụ
int x;
int y;
float z;
x = 1;
y = x / 2; // y sẽ trả về kết quả là 0
z = (float)x / 2.0; //z sẽ có kết quả là 0.5 (bạn nhập 2.0, chứ không phải là 2)
m. double
Giống hết như kiểu float. Nhưng trên mạch Arduino Due thì kiểu double lại chiếm
đến 8 byte bộ nhớ (64 bit). Vì vậy hãy cẩn thận khi sử dụng kiểu dữ liệu này!
n. array
Giới thiệu
Array là mảng (tập hợp các giá trị có liên quan và được đánh dấu bằng những chỉ
số). Array được dùng trên Arduino chính là Array trong ngôn ngữ lập trình C.
108
Các cách khởi tạo một mảng

int myInts[6]; // tạo mảng myInts chứa tối đa 6 phần tử (được đánh dấu từ 0-5), các
phần tử này đều có kiểu là int => khai báo này chiếm 2*6 = 12 byte bộ nhớ
int myPins[] = {2, 4, 8, 3, 6}; // tạo mảng myPins chứa 5 phần tử (lần lượt là 2, 4,
8, 3, 6). Mảng này không giới hạn số lượng phần tử vì có khai báo là "[]"
int mySensVals[6] = {2, 4, -8, 3, 2}; // tạo mảng mySensVals chứa tối đa 6 phần
tử, trong đó 5 phần tử đầu tiên có giá trị lần lượt là 2, 4, -8, 3, 2
char message[6] = "hello"; // tạo mảng ký tự (dạng chuỗi) có tối đa 6 ký tự!

Truy cập các phẩn tử trong mảng
Chú ý: Phần tử đầu tiên trong mảng luôn được đánh dấu là số 0.
mySensVals[0] == 2, mySensVals[1] == 4, vâng vâng
Điều này có nghĩa rằng, việc khai báo một mảng có tối đa 10 phần tử, thì phần tử
cuối cần (thứ 10) được đánh dấu là số 9
int myArray[10]={9,3,2,4,3,2,7,8,9,11};
// myArray[9] có giá trị là 11
// myArray[10] sẽ trả về một giá trị "hên xui" nằm trong khoảng giá trị của int
Vì vậy, hãy chú ý trong việc truy cập đến giá trị trong mảng, nếu bạn muốn truy
cập đến phần tử cuối cùng thì hãy truy đến đến ô giới hạn của mảng - 1.
Hãy ghi nhớ rằng, trong trình biên dịch ngôn ngữ C, nó không kiểm tra bạn có truy
cập đến một ô có nằm trong bộ nhớ hay không! Nên nếu không cẩn thận trong việc
truy cập mảng, chương trình của bạn sẽ mắc lỗi logic và rất khó để tìm lỗi đấy!
Gán một giá trị cho một phần tử

mySensVals[0] = 10;
Đọc một giá trị của một phần tử và gán cho một biến nào đó cùng kiểu dữ liệu
x = mySensVals[0]; //10
109
Dùng mảng trong vòng lặp
Mảng rất thường được dùng trong vòng lặp (chẳng hạn như dùng để lưu các chân
digital quản lý đèn led). Trong đó, biến chạy của hàm for sẽ đi hết (hoặc một phần)
của mảng, tùy thuộc vào yêu cầu của bạn mà thôi! Ví dụ về việc in 5 phần tử đầu
của mảng myPins:
int i;
for (i = 0; i < 5; i = i + 1) {
Serial.println(myPins[i]);
}
o. string
Giới thiệu
string tiếng Anh nghĩa là chuỗi.
Cách khai báo

char Str1[15]; // khai bảo chuỗi có độ dài là 15 ký tự.
char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'}; //khai báo chuỗi có độ dài tối đa là 8 ký tự
và đặt nó giá trị ban đầu là arduino (7 ký tự). Buộc phải khai báo chuỗi nằm giữa
hai dấu nháy đơn nhé!
char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};//khai báo chuỗi có độ dài tối đa là 8 ký
tự và đặt nó giá trị ban đầu là arduino<ký tự null> (8 ký tự)
char Str4[ ] = "arduino";// Chương trình dịch sẽ tự động điều chỉnh kích thước cho
chuỗi Str4 này và ngoài ra bạn phải đặt một chuối trong dấu ngoặc kép
char Str5[8] = "arduino";// Một cách khai báo như Str3

char Str6[15] = "arduino"; // Một cách khai báo khác với độ dài tối đa lớn hơn
CHÚ Ý: mỗi chuỗi đều cần có 1 ký tự NULL, nếu bạn không khai báo ký tự
NULL (\0) ở cuối thì trình biên dịch sẽ tự động thêm vào. Đó là lý do vì sao Str2,
Str4 lại có độ dài là 8 nhưng chỉ chứa một chuỗi 7 ký tự. Ký tự NULL này để làm
gì? Nó dùng để trình biên dịch biết điểm dừng của một chuỗi! Nếu không nó sẽ
đọc tiếp những phần bộ nhớ khác (mà phần ấy không lưu chuỗi)
110
Bạn có thể khai bảo một chuỗi dài như sau:
char myString[] = "This is the first line"

" this is the second line"
" etcetera"
Mảng chuỗi
Khi cần phải thao tác với một lượng lớn chuỗi (ví dụ như trong các ứng dụng trả
lời người dùng bằng LCD) thì bạn cần sử dụng một mảng chuỗi. Mà bản chất của
chuỗi là mảng các ký tự. Vì vậy để khai báo 1 mảng chuỗi bạn cần sử dụng một
mảng 2 chiều!
Để khai báo một mảng chuỗi, rất đơn giản:
char* myStrings[] = {"I'm number 1", "I'm number 2"};
Chỉ cần thêm dấu * sau chữ char và trong dấu ngoặc vuông phía sau myStrings bạn
có thể thiết đặt số lượng phần tử tối đa của mảng chuỗi!
Ví dụ
char* myStrings[]={"This is string 1", "This is string 2", "This is string 3",
"This is string 4", "This is string 5","This is string 6"};
void setup(){
Serial.begin(9600);
}
void loop(){
for (int i = 0; i < 6; i++){
Serial.println(myStrings[i]);
delay(500);
}
}
111
3. Chuyển đổi kiểu dữ liệu

a. char()
Giới thiệu
Hàm char() có nhiệm vụ chuyển kiểu dữ liệu của một giá trị về kiểu char
Cú pháp
char(x)
Tham số
x: là một giá trị thuộc bất kỳ kiểu dữ liệu nào
Trả về
Giá trị thuộc kiểu char
b. byte()
Giới thiệu
Hàm byte() có nhiệm vụ chuyển kiểu dữ liệu của một giá trị về kiểu byte
Cú pháp
byte(x)
Tham số
Trả về
Giá trị thuộc kiểu byte
112
c. int()
Giới thiệu
Hàm int() có nhiệm vụ chuyển kiểu dữ liệu của một giá trị về kiểu int
Cú pháp
int(x)
Tham số
Trả về
Giá trị thuộc kiểu int
d. word()
Giới thiệu
Hàm word() có nhiệm vụ chuyển kiểu dữ liệu của một giá trị về kiểu word. Hoặc
ghép 2 giá trị thuộc kiểu byte thành 1 giá trị kiểu word
Cú pháp
word(x)
word(8bitDauTien,8bitSauCung)
Tham số
8bitDauTien, 8bitSauCung: là giá trị kiểu byte
Trả về
Giá trị thuộc kiểu word
113
e. long()
Giới thiệu
Hàm long() có nhiệm vụ chuyển kiểu dữ liệu của một giá trị về kiểu long
Cú pháp
long(x)
Tham số
Trả về
Giá trị thuộc kiểu long
f. float()
Giới thiệu
Hàm float() có nhiệm vụ chuyển kiểu dữ liệu của một giá trị về kiểu float
Cú pháp
float(x)
Tham số
Trả về
Giá trị thuộc kiểu float
114
4. Biến hằng, biến tĩnh:

a. const - biến hằng
Giới thiệu
Với một từ khóa "const" nằm trước một khai báo biến, bạn sẽ làm cho biến này
thành một biến chỉ có thể đọc "read-only".
Ví dụ
const float pi = 3.14;
float x;
// ....
x = pi * 2; // bạn có thể dụng hằng số pi trong tính toán - vì đơn giản bạn chỉ đọc
nó
pi = 7; // lỗi ! bạn không thể thay đổi giá trị của một hằng số
Dùng const hay dùng #define ?
Để khai báo một biến hằng số (nguyên / thực) hoặc hằng chuỗi thì bạn có thể dùng
cả 2 cách đều được. Tuy nhiên, để khai báo một biến mảng (array) là một hằng số
bạn chỉ có thể sử dụng từ khóa const. Và đây là một lý do nữa khiến const được
dùng nhiều và được ưa chuộng hơn #define!
b. static - biến tĩnh

Giới thiệu
Biến tĩnh là biến sẽ được tạo ra duy nhất một lần khi gọi hàm lần đầu tiên và nó sẽ
không bị xóa đi để tạo lại khi gọi lại hàm ấy. Đây là sự khác biệt giữa biến tĩnh và
biến cục bộ.
Biến tĩnh là loại biến lưỡng tính, vừa có tính chất của 1 biến toàn cục, vừa mang
tính chất của 1 biến cục bộ:
115
 Tính chất 1 biến toàn cục: biến không mất đi khi chương trình con kết thúc,
nó vẫn nằm trong ô nhớ của chương trình và được tự động cập nhật khi
chương trình con được gọi lại. Giống như 1 biến toàn cục vậy.
 Tính chất 1 biến cục bộ: biến chỉ có thể được sử dụng trong chương trình
con mà nó được khai báo.
Để khai báo bạn chỉ cần thêm từ khóa "static" trước khai báo biến. Xem ví dụ để rõ
hơn.
Ví dụ
void setup(){
Serial.begin(9600); // Khởi tạo cổng Serial ở baudrate 9600
}
void loop() {
testStatus();// Chạy hàm testStatus
delay(500); // dừng 500 giây để bạn thấy được sự thay đổi
}
void testStatus() {
static int a = 0;// Khi khai báo biến "a" là biến tĩnh
// thì duy nhất chỉ có 1 lần đầu tiên khi gọi hàm testStatus
// là biến "a" được tạo và lúc đó ta gán "a" có giá trị là 0
a++;
Serial.println(a);
// Biến a sẽ không bị mất đi khi chạy xog hàm testStatus
// Đó là sự khác biệt giữa biến tĩnh và biến cục bộ!
}
116
III. CẤU TRÚC ( STRUCTURE):
1. Cấu trúc tổng thể:

a. setup() và loop()
Giới thiệu
Những lệnh trong setup() sẽ được chạy khi chương trình của bạn khởi động. Bạn
có thể sử dụng nó để khai báo giá trị của biến, khai báo thư viện, thiết lập các
thông số,…
Sau khi setup() chạy xong, những lệnh trong loop() được chạy. Chúng sẽ lặp đi lặp
lại liên tục cho tới khi nào bạn ngắt nguồn của board Arduino mới thôi.
Ví dụ
int led = 10;
void setup() {
}
void loop() {
delay(1000);
delay(1000);
}
Giải thích
Khi bạn cấp nguồn cho Arduino, lệnh “pinMode(led, OUTPUT);” sẽ được chạy 1
lần để khai báo.
Sau khi chạy xong lệnh ở setup(), lệnh ở loop() sẽ được chạy và được lặp đi lặp lại
liên tục, tạo thành một chuỗi:
delay(1000);
delay(1000);
117
delay(1000);
……
2. Toán tử logic:
Toán tử Ý nghĩa Ví dụ
and Và (a && b) trả về TRUE nếu a và b đều mang giá trị
(&&) TRUE. Nếu một trong a hoặc b là FALSE thì (a
&& b) trả về FALSE
or ( || ) Hoặc (a || b) trả về TRUE nếu có ít nhất 1 trong 2 giá trị
a và b là TRUE, trả về FALSE nếu a và b đều
FALSE
not ( ! ) Phủ định nếu a mang giá trị TRUE thì (!a) là FALSE và
ngược lại
xor (^) Loại trừ (a ^ b) trả về TRUE nếu a và b mang hai giá trị
TRUE/FALSE khác nhau, các trường hợp còn lại
trả về FALSE
3. Các toán tử so sánh.
118
4. Cấu trúc điều khiển:

a. Câu lệnh if…..else
Cú pháp:
if ([biểu thức 1] [toán tử so sánh] [biểu thức 2]) { //biểu thức điều kiện
[câu lệnh 1]
} else {
[câu lệnh 2]
}
Nếu biểu thức điều kiện trả về giá trị TRUE, [câu lệnh 1] sẽ được thực hiện, ngược
lại, [câu lệnh 2] sẽ được thực hiện.
Ví dụ:
int a = 0;
if (a == 0) {
a = 10;
} else {
a = 1;
}
// a = 10
Lệnh if không bắt buộc phải có nhóm lệnh nằm sau từ khóa else
int a = 0;
if (a == 0) {
a = 10;
// a = 10
119
b. switch / case
Mô tả
Giống như if, switch / case cũng là một dạng lệnh nếu thì, nhưng nó được thiết kế
chuyên biệt để bạn xử ý giá trị trên một biến chuyên biệt..
Ví dụ, bạn có một biến là action sẽ nhận trị từ những module khác qua serial.
Nhưng action sẽ nằm trong một các giá trị nào đó thì lúc này bạn hãy sử dụng
switch / case.
Ví dụ
switch (action) {
case "0":
//bat led 1
break;
case "1":
//bat led 2
break;
default:
// mặc định là không làm gì cả
// bạn có thể có default: hoặc không
}
Cú pháp
switch (var) {
case label:
//đoạn lệnh
break;
case label:
// Đoạn lệnh
break;
/*
case ... more and more
*/
default:
// statements
}
120
Tham số
var: biến mà bạn muốn so sánh
label: sẽ đem giá trị của biến SO SÁNH BẰNG với nhãn này
c. for
Giới thiệu
Hàm for có chức năng làm một vòng lặp
Bây giờ hãy lấy một ví dụ đơn giản như sau:
Tôi muốn xuất 10 chữ số (từ 1 - 10) ra Serial.
Nếu bạn chưa đọc bài này và cũng chưa biết kiến thức về for, bạn sẽ lập trình như
sau:
void setup() {
Serial.begin(9600);
Serial.println(1);
Serial.println(2);
Serial.println(3);
Serial.println(4);
Serial.println(5);
Serial.println(6);
Serial.println(7);
Serial.println(8);
Serial.println(9);
Serial.println(10);
}
void loop() {
// không làm gì cả;
}
Đoạn code khá dài và lặp đi lặp lại câu lệnh Serial.println
121
Nhưng sau khi biết về hàm for bạn chỉ cần một đoạn code cực kì ngắn như sau:
void setup(){
Serial.begin(9600);
int i;
for (i = 1;i<=10;i=i+1) {
Serial.println(i);
}
}
void loop(){
}
Cấu trúc
Nếu bạn chưa biết về vòng lặp hoặc hàm for, để hiểu được hàm for, bạn cần nắm
được 4 phần:
1. Hàm for là một vòng lặp có giới hạn - nghĩa là chắc chắn nó sẽ kết thúc
(không sớm thi muộn).
2. Nó sẽ bắt đầu từ một vị trí xác định và đi đến một vị trí kết thúc.
3. Cứ mỗi bước xong, nó lại thực hiện một đoạn lệnh
4. Sau đó, nó lại bước đi tiếp, nó có thể bước 1 bước hoặc nhiều bước, nhưng
không được thay đổi theo thời gian.
Bây giờ tôi sẽ nói nó theo một cách khoa học qua cú pháp của hàm for (tôi sẽ chia
làm 2 loại để các bạn dễ dàng ứng dụng vào code của mình).
 For tiến (xuất phát từ một vị trí nhỏ chạy đến vị trí lớn hơn) <vị trí kết thúc>
bé hơn <vị trí kết thúc>
for (<kiểu dữ liệu nguyên> <tên thằng chạy> = <vị trí xuất phát>; <tên thằng
chạy> <= <vị trí kết thúc>; <tên thằng chạy> += <mỗi lần bước mấy bước>)
{
<đoạn câu lệnh>;
}
 For lùi (xuất phát từ một vị trí lớn chạy về vị trí nhỏ hơn) <vị trí xuất phát>
lớn hơn <vị trí kết thúc>
for (<kiểu dữ liệu nguyên> <tên thằng chạy> = <vị trí xuất phát>; <tên thằng
chạy> <= <vị trí kết thúc>; <tên thằng chạy> -= <mỗi lần lùi mấy bước>) {
122
<đoạn câu lệnh>;

}
Và khi đã hiểu được một cách sâu sắc thì đây là cú pháp chính của hàm For:
for (<biến chạy> = <start>;<điều kiện>;<bước>) {

//lệnh
}
d. while
Giới thiệu
Vòng lặp while là một dạng vòng lặp theo điều kiện, mình không thể biết trước số
lần lặp cua nó, nhưng mình quản lý lúc nào thì nó ngừng lặp!
Cú pháp
while (<điều kiện>) {
//các đoạn lệnh;
}
Ví dụ
int giay = 1;
int phut = 1;
while (giay < 60) { //Chừng nào day < 60 thì còn chạy (<=60). Khi day == 60 thì
được 1 phút
giay += 1;
}
phut+= 1;
e. break
Giới thiệu
break là một lệnh có chức năng dừng ngay lập tức một vòng lặp (do, for, while)
chứa nó trong đó. Khi dừng vòng lặp, tất cả những lệnh phía sau break và ở trong
vòng lặp chịu ảnh hưởng của nó sẽ bị bỏ qua.
Ví dụ
int a = 0;
123
while (true) {
if (a == 5) break;
a = a + 1;
}
//a = 5
while (true) {
while (true) {
a++;
if (a > 5) break;
}
a++;
if (a > 100) break;
}
//a = 101
f. continue
Giới thiệu
continue là một lệnh có chức năng bỏ qua một chu kì lặp trong một vòng lặp
(for, do, while) chứa nó trong đó. Khi gọi lệnh continue, những lệnh sau nó và ở
trong cùng vòng lặp với nó sẽ bị bỏ qua để thực hiện những chu kì lặp kế tiếp.
Ví dụ
int a = 0;
int i = 0;
while (i < 10) {
i = i + 1;
continue;
a = 1;
}
//a vẫn bằng 0
124
g. return
Giới thiệu
return có nhiệm vụ trả về một giá trị (cùng kiểu dữ liệu với hàm) mà nó được gọi!
Cú pháp
return;
return value; // cả 2 đều đúng
Thông số
value: bất kỳ giá trị hoặc một đối tượng..
Ví dụ
//Hàm kiểm tra giá trị của cảm biến có hơn một ngưỡng nào đó hay không
int checkSensor(){
if (analogRead(0) > 400) {
return 1;
else{
return 0;
}
h. goto
Giới thiệu
Nó có nhiệm vụ tạm dừng chương trình rồi chuyển đến một nhãn đã được định
trước, sau đó lại chạy tiếp chương trình!
Cú pháp
label: //Khai báo một nhãn có tên là label
goto label; //Chạy đến nhãn label rồi sau đó thực hiện tiếp những đoạn chương
trình sau nhãn đó
125
Thủ thuật
Không nên dùng lệnh goto trong chương trình Program hay bất cứ chương trình
nào sử dụng ngôn ngữ C. Nhưng nếu sử dụng một cách khôn ngoan bạn sẽ tối ưu
hóa được nhiều điều trong một chương trình!
Vậy nó hữu ích khi nào, đó là lúc bạn đang dùng nhiều vòng lặp quá và muốn thoát
khỏi nó một cách nhanh chóng!
Ví dụ
for(byte r = 0; r < 255; r++){
for(byte g = 255; g > -1; g--){
for(byte b = 0; b < 255; b++){
if (analogRead(0) > 250){ goto bailout;}
//thêm nhiều câu lệnh nữa
}
}
}
bailout:
5. Toán tử số học:
a. Phép gán(=)
Giới thiệu
Dùng để gán một giá trị cho một biến. Giá trị nằm trên phải, tên biến nằm bên trái
ngăn cách nhau bởi 1 dấu bằng.
Ví dụ
int sensor; // Khai báo kiểu dữ liệu cho biến sensor là int
sensor = analogRead(0); // đặt giá trị cho sensor là giá trị analog tại chân A0
b. Các phép cộng, trừ, nhân, chia trong Arduino
Giới thiệu
Những phép toán trên có nhiệm vụ thực hiện việc tính toán trong Arduino. Tùy
thuộc vào kiểu dữ liệu của các biến hoặc hằng số mà kết quả trả về của nó có kiểu
dữ liệu như thế nào.
126
Ví dụ
y = y + 3;
x = x - 7;
i = j * 6;
r = r / 5;
Cú pháp
result = value1 + value2;
result = value1 - value2;
result = value1 * value2;
result = value1 / value2;
Tham số
value1: là một số ở bất kỳ kiểu dữ liệu nào
value2: là một số ở bất kỳ kiểu dữ liệu nào
c. Phép chia lấy dư%

Giới thiệu
Phép chia lấy dư là phép lấy về phần dư của một phép chia các số nguyên.
Cú pháp
<phần dư> = <số bị chia> / <số chia>;
Ví dụ
x = 7 % 5; // x bây giờ là 2
x = 9 % 5; // x bây giờ là 4
x = 5 % 5; // x bây giờ là 0
x = 4 % 5; // x bây giờ là 4
Tham khảo
/* cập nhập lại giá trị trong hàm loop */
int values[10];
int i = 0;
void setup() {}
127
void loop()
{
values[i] = analogRead(0);
i = (i + 1) % 10; // giá trị của biến i sẽ không bao giờ vượt quá 9.
}
Lưu ý
Phép chia lấy dư không khả dụng với kiểu dữ liệu float
6. Cú pháp mở rộng
a. dấu chấm phẩy ( ; )
Giới thiệu
Dùng để kết thúc một dòng lệnh.
Ví dụ
int ledPin = 13;
Thủ thuật
Giả sử bạn có quên dấu ";" này thì cũng không có vấn đề to tát lắm, chương trình
dịch của Arduino sẽ tự động dò tìm lỗi này và thông báo chính xác dòng bị lỗi!
b. {} dấu ngoặc nhọn

Giới thiệu
Rất đơn giản, {} là một cặp dấu ngoặc nhọn, nên một khi bạn đã mở ngoặc thì phải
đóng ngoặc lại cho nó!
Nhiệm vụ của nó là cung cấp một cú pháp để gọi những lệnh cho những cấu trúc
đặc biệt như (if, while, for,...)
128
Cách sử dụng
Trong hàm và thủ tục
void myfunction(<kiểu dữ liệu> <tham số>){

<lệnh>;
}
Vòng lặp
while (<điều kiện>)
{
<câu lệnh>
}
do
{
<câu lệnh>
} while (<điều kiện>);
for (<khởi tạo>; <điều kiện>; <bước>)

{
<câu lệnh>
}
Lệnh rẻ nhánh
if (<điều kiện 1>)
{
<lệnh 1>
}
else if (<điều kiện 2>)

{
<lệnh 2>
}
129
c. Comments - Viết ghi chú trong khi viết code Arduino

Giới thiệu
Bạn rất khó ghi nhớ từng dòng code một trong một chương trình thật là dài, với
những thuật toán phức tạp, vì vậy Arduino đã làm cho bạn một cú pháp để giải
quyết vấn đề này, đó là Comments.
Comments sẽ giúp bạn ghi chú cho từng dòng code hoặc trình bày nhiệm vụ của nó
để bạn hoặc những người khác có thể hiểu được chương trình này làm được những
gì. Và comments sẽ không được Arduino biên dịch nên cho dù bạn viết nó dài đến
đâu thì cũng không ảnh hưởng đến bộ nhớ flash của vi điều khiển. Để comments
trong Arduino, bạn có 2 cách. ( // chú thích code ), ( /* chú thích code */ )
Ví dụ
/* chương trình trên được viết bởi Phi Nguyen */
void setup() {
pinMode(13, OUTPUT); // chân số 13 là chân OUTPUT
void loop() {
digitalWrite(13, HIGH); // bật led trong vòng 3 giây
delay(3000);
digitalWrite(13, LOW); // tắt led trong vòng 1 giây
delay(1000);
130
d. #define
Giới thiệu
#define là một đối tượng của ngôn ngữ C/C++ cho phép bạn đặt tên cho một
hằng số nguyên hay hằng số thực. Trước khi biên dịch, trình biên dịch sẽ thay
thế những tên hằng bạn đang sử dụng bằng chính giá trị của chúng. Quá trình
thay thế này được gọi là quá trình tiền biên dịch (pre-compile).
Cú pháp
#define [tên hằng] [giá trị của hằng]
Ví dụ
#define pi 3.14
Nếu bạn viết code thế này ...
#define pi 3.14
float a = pi * 2.0; // pi = 6.28
thì sau khi pre-compile trước khi biên dịch, chương trình của bạn sẽ như thế
này:
#define pi 3.14
float a = 3.14 * 2.0; // a = 6.28
e. #include
Giới thiệu
#include cho phép chương trình của bạn tải một thư viện đã được viết sẵn.
Tức là bạn có thể truy xuất được những tài nguyên trong thư viện này từ
chương trình của mình. Nếu bạn có một đoạn code và cần sử dụng nó trong
nhiều chương trình, bạn có thể dùng #include để nạp đoạn code ấy vào
chương trình của mình, thay vì phải chép đi chép lại đoạn code ấy.
Cú pháp
#include <[đường dẫn đến file chứa thư viện]>
131
Ví dụ
Giả sử bạn có thư mục cài đặt Arduino IDE tên là ArduinoIDE, thư viện của
bạn có tên là EEPROM (được lưu ở \ArduinoIDE\libraries\EEPROM\)
Một đoạn code lưu ở file code.h nằm trong thư mục function của thư
viện EEPROM thì được khai báo như sau:
7. Phép toán hợp nhất

a. Cộng một 1 đơn vị (++) / trừ một 1 đơn vị (--)
Giới thiệu
Tăng hoặc trừ một biến đi 1 đơn vị.
Cú pháp
x++; // tăng x lên 1 giá trị và trả về giá trị cũ của x
++x; // tăng x lên 1 giá trị và trả về giá trị mới của x
x-- ; // trừ x lên 1 giá trị và trả về giá trị cũ của x

--x ; // trừ x lên 1 giá trị và trả về giá trị mới của x
Tham số
x: bất kỳ kiểu số nguyên nào (int, byte, unsigned int,...)
Trả về
Giá trị cũ của biến hoặc giá trị mới đã được cộng / hoặc bị trừ của biến ấy.
Ví dụ
x = 2;
y = ++x; // x bây giờ có giá trị là 3, và y cũng có giá trị là 3
y = x--; // x bây giờ đã trở lại với giá trị 2, nhưng y không đổi vẫn là 3
132
b. Các phép toán rút gọn += , -= , *= , /=

Giới thiệu
Cung cấp một số phép toán rút gọn để bạn gõ code trong đẹp hơn.
Cú pháp
x += y; // giống như phép toán x = x + y;
x -= y; // giống như phép toán x = x - y;
x *= y; // giống như phép toán x = x * y;
x /= y; // giống như phép toán x = x / y;
Tham số
x: mọi kiểu dữ liệu
y: mọi kiểu dữ liệu hoặc hằng số
Ví dụ
x = 2;
x += 4; // x bây giờ có giá trị là 6
x -= 3; // x bây giờ có giá trị là 3
x *= 10; // x bây giờ có giá trị là 30
x /= 2; // x bây giờ có giá trị là 15
133
C. CẤU TRÚC CHƯƠNG TRÌNH

ARDUINO VÀ BÀI HỌC LẬP TRÌNH
TỪ CƠ BẢN ĐẾN NÂNG CAO
I. CẤU TRÚC CHƯƠNG TRÌNH ARDUINO VÀ
CÁCH THÊM THƯ VIỆN VÀO IDE.
1. Cấu trúc chương trình Arduino:
Trong một chương trình Arduino, bạn cần có tối thiểu 2 hàm hệ thống chính, bắt
buộc phải có. Đó là setup() và loop()
Hàm setup() và loop() hoạt động như sau:
 Những lệnh trong setup() sẽ được chạy khi chương trình của bạn khởi động.
Bạn có thể sử dụng nó để khai báo giá trị của biến, khai báo thư viện, thiết
lập các thông số,…
 Sau khi setup() chạy xong, những lệnh trong loop() được chạy. Chúng sẽ lặp
đi lặp lại liên tục cho tới khi nào bạn ngắt nguồn của board Arduino mới
thôi.
134
Quá trình của một chương trình có thể được miêu tả như sơ đồ dưới đây:
Ví dụ một chương trình điều khiển led cơ bản:
int led = 13; // khai báo chân điều khiển led là chân số 13 của arduino
void setup() { //toàn bộ đoạn code nằm trong hàm này chỉ được chạy duy nhất một
lần khi chạy chương trình
pinMode(led, OUTPUT); //sẽ được chạy 1 lần để khai báo chân ra của arduino
void loop() { // lặp lại mãi mãi sau khi chạy xong setup()
digitalWrite(led, HIGH); //bật led
delay(1000); // bật led trong vòng 1 giây
digitalWrite(led, LOW); // tắt led
delay(1000); // tắt led trong vòng 1 giây sau đó bật led và lặp lại quá trình.
2. Hướng dẫn add thư viện cho Arduino IDE:

Thư viện đóng vai trò vô cùng quan trọng trong việc lập trình điều khiển
Ardunio.
135
 Nó cung cấp cho bạn một phương thức cực kỳ đơn giản để giao tiếp giữa
các module và arduino. ( ví dụ như giúp việc giao tiếp giữa Arduino với
module thời gian thực DS1307 trở nên dễ dàng hơn rất nhiều)
 Thư viện trong Arduino chứa các mã nguồn có những đặc điểm chung,
được xây dựng thành một gói bao gồm file: examples, .h, .cpp,...Nhằm giúp
người sử dụng giải quyết được vấn đề nhanh chóng.
 Một số thư viện có sẵn trong chương trình Arduino IDE như:
Sevor, Stepper, EEPROM, Ethernet, SPI,...
136
 Nhằm giúp người sử dụng giải quyết được vấn đề nhanh chóng,
trong bài viết này tôi cài thư viện I2C làm ví dụ để cài vào thư viện cho
Arduino IDE.
 Sau khi tải thư viện I2C về với file .zip (Tải tại đây) copy thư mục
vào đường dẫn sau: ( lưu ý Arduino IDE chỉ hiểu những file .zip hoặc
dạng folder.)
137
Sau khi tải về và lưu vào đường dẫn ở trên, Ta vào Sketch  Include Library
Add sau đó chọn file I2C vừa tải về:
Chọn Open để bắt đầu add thư viện I2C vào Arduino IDE:
138
Nếu cửa sổ Arduino IDE báo dòng chữ dưới đây thì đã cài thành công.
Sau khi ài xong ta reset lại Arduino IDE và xem lại thư viện I2C đã có trong IDE
chưa. Vậy là OK
139
II. BÀI HỌC LẬP TRÌNH ARDUINO TỪ CƠ BẢN ĐẾN

NÂNG CAO.
1. Điều khiển LED đơn sáng nhấp nháy.
Nội dung chính.
Hôm nay, chúng ta sẽ tìm hiểu cách để điều khiển một con đèn led nhấp nháy.
Phần cứng ( Trên kit đã tích hợp sẵn chỉ cần nối dây là được)
 1 arduino uno, nano,…
 1 trở 220 Ohm
 1 led đơn
Lắp mạch
Ở bài này ta điều khiển led đơn sáng nhấp nháy theo yêu cầu của mình.
140
Hình ảnh thực tế:
Code lập trình và giải thích

Code lập trình sẽ được lưu trong file ( file _code) riêng để tránh việc bị lổi, code
bên dưới chỉ dưới dạng giải thích.
Trước tiên, cứ mỗi khi dùng một con LED, chúng ta phải pinMode OUTPUT chân
Digital mà ta sử dụng cho con đèn LED. Trong ví dụ, chúng ta sử dụng chân LED
là chân digital 12. Nên đoạn code sau cần nằm trong void setup()
Để bật một con đèn LED, bạn phải digitalWrite HIGH cho chân số 12 (chân Digtal
được kết nối với con LED). Đoạn code này nằm trong void loop()
digitalWrite(12,HIGH);
Dòng lệnh trên sẽ cấp một điện thế là 5V vào chân số Digital 12. Điện thế sẽ đi qua
điện trở 220ohm rồi đến đèn LED (sẽ làm nó sáng mà không bị cháy, ngoài ra bạn
có thể các loại điện trở khác <= 10kOhm). Để tắt một đèn LED, bạn sử dụng hàm:
digitalWrite(12,LOW);
141
Lúc này điện thế tại chân 12 sẽ là 0 V => đèn LED tắt. Và để thấy được trạng thái
bật và tắt của đèn LED bạn phải dừng chương trình trong một khoảng thời gian đủ
lâu để mắt cảm nhận được (nói vậy thôi, chứ bạn chỉ cần dừng chương trình trong
vài miligiây là thấy được rồi). Vì vậy, hàm delay được tạo ra để làm việc này
(Dừng hẳn chương trình bao nhiêu mili giây)!
code:
/*
Đoạn code làm nhấp nháy một đèn LED cho trước
*/
// Hàm setup chạy một lần duy nhất khi khởi động chương trình
void setup() {
// Hàm loop chạy mãi mãi sau khi kết thúc hàm setup()
void loop() {
digitalWrite(12, HIGH); // bật đèn led sáng
delay(5000); // dừng chương trình trong 5 giây => thây đèn sáng được 5 giây
digitalWrite(12, LOW); // tắt đèn led
delay(2000); // dừng chương trình trong 2 giây => thấy đèn tối được 2 giây
142
2. Thay đổi độ sáng của LED đơn.

Nội dung chính:
Hôm nay chúng sẽ tìm hiểu cách sử dụng các chân digital để xuất giá trị analog và
ứng dụng chúng trong việc làm thay đổi độ sáng của đèn (làm mờ đèn).
Phần cứng ( được tích hợp sẵn trên kit) nếu không có các bạn chuẩn bị:
 Arduino Uno, nano,…
 Breadboard.
 Dây cắm breadboard.
 1 điện trở (hoặc 220 Ohm hoặc 1kOhm).
 1 đèn LED đơn.
Lắp mạch
143
Lưu ý những chân digital có dấu ~ phía trước và những chân analog mới hỗ
trợ analogWrite,
Chương trình:
int led = 6; // cổng digital mà LED được nối vào

int giatribandau = 0; // mặc định độ sáng của đèn
int tanggiatri = 5; // mỗi lần thay đổi độ sáng thì thay đổi với giá trị là bao nhiêu
void setup() {
// pinMode đèn led là OUTPUT
}
void loop() {
//xuất giá trị độ sáng đèn LED
144
analogWrite(led, giatribandau);
// Đoạn code này có nghĩa nếu độ sáng == 0 hoặc bằng == 255 thì sẽ đổi chiều
của biến thay đổi độ sáng. Ví dụ, nếu đèn từ sáng yếu --> sáng mạnh thì
fadeAmount dương. Còn nếu đèn sáng mạnh --> sáng yếu thì fadeAmmount lúc
này sẽ có giá trị âm
if (giatribandau == 0 || giatribandau == 255) {
tanggiatri = - tanggiatri ;
}
//đợi 50 mili giây để thấy sự thay đổi của đèn
delay(50);
}
3. Điều khiển đèn giao thông.

Phần cứng cần chuẩn bị ( nếu sử dụng kit thì được tích hợp sẵn)
• Arduino Uno, Nano,…
• Breadboard.
• Dây cắm breadboard.
• 3 điện trở 220 Ohm (hoặc 560 Ohm hoặc 1kOhm).
• 3 LED đơn siêu sáng.
Lắp mạch:
145
Code lập trình:

// chương trình điều khiển đèn giao thông
int red = 8;
int yellow = 9;
int green = 10;
void setup(){
146
pinMode(red,OUTPUT);
pinMode(yellow,OUTPUT);
pinMode(green,OUTPUT);
void loop(){
delay(15000);
void dengiaothong(){
digitalWrite(yellow,LOW); // tat den vang
digitalWrite(green,LOW); // tat den xanh
digitalWrite(red,HIGH); // bat den do
delay(10000);// den đỏ sáng 10 giây.
digitalWrite(green,LOW); // tat den xanh
digitalWrite(red,LOW); // tat den do
digitalWrite(yellow,HIGH); // bat den vang
delay(2000); // đèn vàng sáng 2 giây.
digitalWrite(yellow,LOW); // tat den vang
digitalWrite(red,LOW); // tat den do
digitalWrite(green,HIGH); // bat den xanh trong vong 15 giây
147
4. Điều khiển Rơ le 5Vdc 1, 2 kênh mức cao.

Giới thiệu thiệu chung:
Module 1 Relay với opto cách ly nhỏ gọn, có opto và transistor cách ly giúp cho
việc sử dụng trở nên an toàn với board mạch chính, mạch được sử dụng để đóng
ngắt nguồn điện công suất AC ( quạt hay đèn,…) hoặc DC.
Role 1 kênh ( có 1 role) và 2 kênh ( 2 rơ le) trên thuộc loại kích mức cao.
Tiếp điểm đóng ngắt gồm 3 tiếp điểm NC (thường đóng), NO(thường mở) và
COM(chân chung) được cách ly hoàn toàn với board mạch chính.
Ở trạng thái bình thường chưa kích NC sẽ nối với COM, khi có trạng thái kích
COM sẽ chuyển sang nối với NO và mất kết nối với NC.
Thông số kỹ thuật:
 Sử dụng điện áp nuôi DC 5V.

 Relay mỗi Relay tiêu thụ dòng khoảng 80mA.
 Điện thế đóng ngắt tối đa: AC250V ~ 10A hoặc DC30V ~ 10A.
 Có đèn báo đóng ngắt trên mỗi Relay.
Phần cứng chuẩn bị:

 Arduino Uno, Nano,…
 Rơ le 1 ( hoặc 2) kênh mức cao.
 Dây cắm test board.
148
Lắp mạch:
Code chương trình:

// Code này sử dụng cho role mức cao
int role = 11; // có thể sử dụng chân khác của arduino để điều khiển rơ le
void setup() {
pinMode(role, OUTPUT); // role được khai báo là chân ra
void loop() {
149
digitalWrite(role, HIGH); // bật role trong 10 giay
delay(10000);
digitalWrite(role, LOW); // tắt role trong 4 giây
delay(4000);
5. Điều khiển Công tắc tơ 3 pha:

Giới thiệu công tắc tơ 3 pha:
Công tắc tơ là gì?:
Công tắc tơ là khí cụ điện để đóng, ngắt thường xuyên các mạch điện động lực, từ
xa, bằng tay (thông qua nút bấm) hoặc tự động có công suất lớn. Việc đóng cắt
công tắc tơ có thể được thực hiện bằng nam châm điện, thủy lực hoặc khí nén.
Thông thường sẽ sử dụng nam châm điện để đóng cắt công tắc tơ
150
Cấu tạo công tắc tơ:

Bao gồm các bộ phận chính: Cuộn cảm, nam châm điện, lò xo, lõi thép và các tiếp
điểm.
151
Nguyên lý hoạt động công tắc tơ:
-Khi cuộn hút công tắc tơ chưa được cấp điện, lò xo hồi vị đẩy lõi thép động cách
xa khỏi lõi thép tĩnh. Các cặp tiếp điểm chính ở trạng thái mở.
- Khi cấp điện vào cuộn hút của công tắc tơ, lõi thép tĩnh hút lõi thép động thắng
được lực đẩy lò xo, từ đó đóng các tiếp điểm lại, đưa điện đi từ đầu vào Công tắc
tơ tới đầu ra công tắc tơ.
- Khi ngắt điện cấp vào cuộn hút công tắc tơ, lực hút không còn nữa, lò xo lại đẩy
lõi thép động về vị trí ban đầu, các cặp tiếp điểm mở ra, ngắt điện ở đầu ra công tắc
tơ.
- Ngoài tiếp điểm chính để truyền tải điện 3 pha, công tắc tơ còn có thêm các tiếp
điểm phụ để sử dụng trong các mạch điều khiển, mạch logic trung gian.
 Mạch arduino uno, nano, mê ga,…
 Công tắc tơ LS hàn quốc ( trong bài này sử dụng loại 18A).
 Module rơ le 5Vdc ( trong bài sử dụng loại kích mức cao).
 Dây cắm test và một số dây điện dân dụng hoặc công nghiệp.
152
Lắp mạch:

// Code này sử dụng cho role mức cao
int role = 3;// sử dụng chân 3 để điều khiển rơ le đóng ngắt cuộn từ của công tắc tơ
void setup() {
pinMode(role, OUTPUT); // role được khai báo là chân ra
void loop() {
digitalWrite(role, HIGH); // bật role trong 10 giây cũng như cấp điện cho cuộn từ 10 s
delay(10000);
digitalWrite(role, LOW); // tắt role trong 10 giây cũng như ngắt điện cho cuộn từ 10 s
153
delay(10000);
} // trong phần sau chúng ta sử dụng nút nhấn để bật tắt role đóng ngắt cuộn từ của công tắc tơ
6. Đọc tín hiệu nút nhấn hiển thị lên serial monitor.
Giới thiệu về nút nhấn:
Tôi sẽ giới thiệu cho các bạn những loại button ( nút nhấn) phổ biến hiện nay.
Nút nhấn (Button) là gì?
Bạn có thể tìm thấy nó ở mọi thứ trong cuộc sống, chẳng hạn như cái nút trong bàn phím
máy tính của mình,…
Các loại button:
Button có rất nhiều loại, và mỗi loại lại có ứng dụng riêng của nó. Vì vậy, chỉ cần s dụng
hợp lý và sáng tạo các loại button - nút bấm, bạn sẽ làm nên những dự án. Nút nhấn
thường có 2 loại chính: 2 chân và 4 chân ( thực chất 4 chân giống 2 chân chỉ giúp nó cố
định và chắc chắn hơn).
154
Button (thường) (6mm hoặ c 12mm)
Đây là loại button rất phổ biến, loại button này cũng có các kính thước cạnh 6mm, 9mm
hoặc 12m. Loại 6mm hay được dùng trong các dự án nhỏ và loại còn lại dùng cho các dự
án lớn hơn.
Loại này tuy là 4 chân, nhưng thực chất cũng chỉ là 2 chân mà thôi, các bạn xem hình
dưới.
Ưu điểm của loại có 4 chân này là nó khá vững và rất khó hư!
Button dán (button smd)
Loại này khá là nhỏ, chỉ 2-3mm, vì vậy rât phù hợp cho những mạch yêu cầu về kích
thước, bạn có thể tìm thấy nó trên con nano, nó chính là nút reset cho chú Arduino nano.
155
Nút bấm công nghiệp:
Những loại nút bấm này thường được dùng để chế tạo những đồ trong công nghiệp, hoặc
những máy móc to lớn cần bấm nhiều và cần đèn trạng thái. Loại này đôi khi có đèn, đôi
khi lại không. Với loại không có đèn thì cũng có 2 chân như các loại ở trên, còn loại có
đèn thì có đến 4 chân (2 chân của button, 1 chân dương và 1 chân âm của led).
 Mạch Arduino (ở đây mình sử dụng Arduino UNO).

 Breadboard còn gọi testboard
 Điện trở 10 kΩ.
 Nút nhấn 2 chân hoặc 4 chân (hoặc công tắc tương đương).
156
Sơ đồ nguyên lí:
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn nút nhấn):
157
Lập trình:
int nutnhan = 2; // khai bao chan nut nhấn là chân D2

void setup() {
Serial.begin(9600); //Mở cổng Serial ở baudrate 9600 để giao tiếp với máy tính
pinMode(button, INPUT); //Cài đặt chân D2 ở trạng thái đọc dữ liệu
}
void loop() {
int buttonStatus = digitalRead(nutnhan); //Đọc trạng thái button
Serial.println(buttonStatus); //Xuất trạng thái button
delay(200); //Chờ 200ms
}
158
Khi bạn chưa nhấn nút, chân D2 được nối với GND qua một điện trở 10 kΩ, do đó
lệnh digitalRead(nutnhan) sẽ trả về giá trị 0 (LOW). Khi bạn nhấn nút, chân D2
sẽ được nối trực tiếp với 5V và nối với GND thông qua 1 điện trở 10kΩ,
lệnh digitalRead(nutnhan) sẽ trả về giá trị 1 (HIGH).
Khi chưa nhấn nút, nếu bạn nối chân D2 với GND qua 1 điện trở thì người ta gọi
điện trở này là điện trở pulldown. Trái lại, nếu bạn nối D2 với chân 5V qua một
điện trở thì người ta gọi nó là điện trở pullup. Cách nối ở trên hình sử dụng cách
nối điện trở pulldown.
Sau khi upload code lên mạch Arduino, bạn bấm Ctrl + Shift + M để mở cửa
sổ Serial Monitor để xem trạng thái nút nhấn được mạch Arduino gửi về máy
tính.
159
Trong câu lệnh:
pinMode(button, INPUT);
Bạn hãy sửa INPUT thành INPUT_PULLUP rồi tải lại code của bạn lên mạch
Arduino. Bạn có thể tháo điện trở 10 kΩ ra và xem kết quả ... Đó là vì trong vi
điều khiển ATmega328 của Arduino UNO đã có sẵn điện trở pullup tương tự điện
trở pulldown mà bạn đang mắc, tuy nhiên nếu bạn khai báo là INPUT như mặc
định thì nó sẽ không được sử dụng, trái lại việc khai báo INPUT_PULLUP sẽ
kích hoạt điện trở này.
7. Lưu giá trị nút nhấn.


160
Lập trình:
int nutnhan = 2; // định nghĩa chân số 0 là button

int t = 0; // khai báo biến
int status1; // biến lưu các trạng thái nút nhấn
// viết hàm chống dội
boolean chong_doi()
{
int sta =!digitalRead(nutnhan); // đọc trạng thái nút nhấn
}
// khởi tạo
void setup()
{
161
Serial.begin(9600);
pinMode(nutnhan,INPUT);
}
void loop() // vong lap
{
int buttonState = digitalRead(nutnhan);
//Serial.println(buttonState);
status1 = chong_doi();
if(status1==true)
{
{
t=!t;// đảo trạng thái
}
while(status1==true){status1=chong_doi();}
}
Serial.println(t);
}
Sau khi upload code lên mạch Arduino, bạn bấm Ctrl + Shift + M để mở cửa
sổ Serial Monitor để xem trạng thái nút nhấn được mạch Arduino gửi về máy
tính.
162
8. Bật tắt LED khi nhấn nút nhấn.


 1 trở 220 Ohm hoặc 470 Ohm.
 1 led đơn.
163
Lập trình:

int led = 9, t=0; // khai báo led và biến
boolean chong_doi()
{
}
// khởi tạo
void setup()
{
Serial.begin(9600);
164
pinMode(led,OUTPUT);
}
{
Serial.println(buttonState);
if(status1==true)
{
{
t=!t; // đảo trạng thái
}
}
if(t==1)
{
digitalWrite(led,HIGH);
}
else
{
digitalWrite(led,LOW);
}
}
165
9. Bật tắt rơ le khi nhấn nút nhấn.


 1 rơ le kích mức cao.
166
Lập trình:

int role = 9, t=0; // khai báo led và biến
boolean chong_doi()
{
167
}
// khởi tạo
void setup()
{
Serial.begin(9600);
pinMode(led,OUTPUT);
}
{
Serial.println(buttonState);
if(status1==true)
{
{
t=!t; // đảo trạng thái
}
}
if(t==1)
{
digitalWrite(role,HIGH);
}
else
{
digitalWrite(role,LOW);
}
}
TỪ BÀI HỌC NÀY CÁC BẠN CÓ THỂ ĐIỀU KHIỂN ĐƯỢC CÔNG TẮT TƠ
THEO Ý MÌNH THÔNG QUA NÚT NHẤN.
168
10. Lập trình hiển thị led 7 đoạn đơn:

Giới thiệu led 7 đoạn đơn:
Trước khi vào lập trình, chúng ta hãy cùng đi vào tìm hiểu cấu trúc của LED 7
đoạn.
Thực ra cấu trúc của LED 7 đoạn gồm 8 LED đơn, nhìn lên hình trên chắc các bạn
cũng thấy gồm có 7 đoạn và một dấu chấm nhỏ, mỗi đoạn và dấu chấm nhỏ đó là một
LED đơn.
Việc sử dụng LED 7 đoạn chúng ta có thể sử dụng để hiển thị các số, các chữ cái
anphabet và nhiều kiểu ký tự khác nhau. Như trên hình các bạn đã thấy, một LED 7
đoạn đơn gồm 10 chân đó là các chân: a, b, c, d, e, f, g, 2 chân chung và chân dấu
chấm tròn (DP).
LED 7 đoạn gồm 2 loại đó là dương chung và âm chung. Trong bài học này chúng ta
sẽ viết chương trình và tải vào Arduino để hiển thị các số từ 0-9 ( Loại âm chung).
169
Để LED hiển thị chúng ta phải làm cho 8 LED đơn như ở trên hiển thị, ví dụ ở
đây 8 LED ở đây là các led mang kí tự a, b, c, d, e, f, g và một dấu chấm ở chân
cuối.
Bây giờ chúng ta thử suy nghĩ nếu chúng ta muốn hiển thị số 0 chúng ta phải làm
thế nào?
Nhìn vào hình LED hiển thị ở đầu bài chúng ta thấy:
Để hiển thị số 0 thì chúng ta phải làm cho các LED đơn a, b, c, d, e, f phải sáng
lên, dấu chấm và g phải tắt đi. Như vậy để tạo số 0 chúng ta phải thể hiện mã code
hệ nhị phân (binary) là B111111100.
Tương tự đối với số 1 thì có những cái LED nào sáng?
Các bạn có thể viết được mã làm xuất hiện số 1 được không?
Đó là: B01100000.
Tương tự đối với các số 2. 3, 4, 5, 6, 7, 9.
Để dễ hiểu hơn tôi xin đưa ra một bảng sau để các bạn dò.
Lưu ý: sáng là 1, tắt là 0.

 Breadboard còn gọi testboard.
 Dây test board.
 Điện trở 220 Ω.
 1 led 7 đoạn đơn.
170
Lập trình:
// Khai báo chân

const int G = 8; // G= Arduino chân 8
const int F = 7; // F= Arduino chân 7
const int A = 2; // A = Arduino chân 2
const int B = 3; // B = Arduino chân 3
const int E = 6; // E = Arduino chân 6
171
const int D = 5; // D = Arduino chân 5

const int C = 4; // C = Arduino chân 4
const int dp = 9; // dp = Arduino chân 9
const int second = 1000; // thiết lập với mili giây, 1000 milliseconds = 1 second
const int digit = 10; // Số ký tự hiển thị10 digits (0 - 9)
const int segment = 7; // Số thanh hiển thị trong LED (7)
// Định nghĩa những thanh( led đơn) sáng
byte digseg[digit][segment] = {
{ 1,1,1,1,1,1,0 }, // = 0
{ 0,1,1,0,0,0,0 }, // = 1
{ 1,1,0,1,1,0,1 }, // = 2
{ 1,1,1,1,0,0,1 }, // = 3
{ 0,1,1,0,0,1,1 }, // = 4
{ 1,0,1,1,0,1,1 }, // = 5
{ 1,0,1,1,1,1,1 }, // = 6
{ 1,1,1,0,0,0,0 }, // = 7
{ 1,1,1,1,1,1,1 }, // = 8
{ 1,1,1,1,0,1,1 } // = 9
};
void setup() {
// Định nghĩa chân xuất tín hiệu OUTPUT
………………………………………………………
writeDigit(digit);
delay(second);
}
delay(4*second);
}
172
173
11. Hiển thị chữ cái, số ra module 4 led 7 đoạn.

Giới thiệu module 4 led 7 đoạn:
Đây là module tốn thời gian của bạn hơi nhiều đấy, module này nhiều chân và có
khá là mới mẻ với những bạn nào mới bắt đầu học lập trình arduino. Và tất nhiên,
bạn sẽ hiểu được cách để sử dụng chúng sau này, cho những dự án khác của bạn.
Trong bài này tôi sử dụng loại Anode chung ( dương chung).
Trước tiên bạn add thư viện SevSeg vào IDE. Các bạn tải tại link sau:
http://tdhshop.com.vn/tong-hop-cac-thu-vien-cho-arduino
Chú ý trường hợp bị chồng thư viện bạn cài bản IDE 1.0.6 để tránh trường hợp
này. Chạy song song 2 phiên bản đều được.
174

 1 biến tở 10k.
 1 module 4 led 7 đoạn loại dương chung.
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn):
Trường hợp trên ta không gắn điện trở cũng được.
Tiếp đến ta nối biến trở 10k vào để tăng giảm độ sáng của led 7 đoạn.
175
Lập trình:
#include "SevSeg.h" //Include thư viện SevSeg

SevSeg myDisplay; // Khai báo biến myDisplay là đối tượng của thư viện SegSev
int bientro = A0;
void setup() { //Hàm Setup
Serial.begin(9600); //Bật cổng Serial ở mức Baudrate là 9600
Serial.println("Ready");
int displayType = COMMON_ANODE;
int digit1 = 8; //chân số 8 của arduino nối chân 12 của led 7 đoạn
int digit2 = 12;
int digit3 = 13;
int digit4 = 2;
int segA = 9;
int segB = 11;
int segC = 4;
176
int segD = 6;
int segE = 7;
int segF = 10;
int segG = 3;
int numberOfDigits = 4; // số dấu chấm
myDisplay.Begin(displayType, numberOfDigits, digit1, digit2, digit3, digit4, segA,

segB, segC, segD, segE, segF, segG, segDP); // Bắt đầu cho phép giao tiếp
myDisplay.SetBrightness(100); //điều chỉnh độ sáng của Module LED
}
void loop(){
myDisplay.DisplayString("AbcD", 0b00001000); // Thể hiện chữ AbcD ra bảng

LED, và dãy số 0b00001000 là vị trí dấu chấm. Bạn hãy thử thay những số 0 bằng
số 1 hoặc ngược lại để kiểm nghiệm
myDisplay.SetBrightness(getBrightness()); //độ sáng
}
int getBrightness() { // Hàm đọc giá trị độ sáng từ biến trở

int value = analogRead(bientro); // Đọc giá trị biến trở và đưa vào biến value
value = map(value,0,1023,0,100); // Chuyển đổi giá trị trong thang đo 0-1023 về
thang đo 0 - 100
return value; // Trả về giá trị độ sáng
}
177
12. Lập trình hiển thị module led ma trận 8x8.

Giới thiệu module ma trận 8x8:
LED MATRIX 8x8 đơn giản chỉ là 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. Vì mỗi loại LED MATRIX có sơ đồ
chân riêng nên các bạn hãy tra cứu datasheet của nó để có thể lắp mạch chính xác .
Trong bài viết này mình sử dụng LED matrix " anode ( dương chung) ", có nghĩa
là các chân điều khiển hàng của ma trận chính là cực dương của LED.
Phần cứng chuẩn bị: ( tất cả được tích hợp trên Kit Tự Học)

 1 module led ma trận 8x8 loại dương chung.
178
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn):
Lập trình:
const int row[8] = {
179
2, 7, 19, 5, 13, 18, 12, 16
};
const int col[8] = {
6, 11, 10, 3, 17, 4, 8, 9
};
int pixels[8][8];
int count = 1000;
char str[] = "FABCDEDCBA";
int ptrChar = 0;
const charMapType charBlank = {
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0}
};
//Các bạn để ý những con số 1 nhé.
const charMapType heart0 = {
{0, 0, 0, 1, 1, 0, 0, 0},
180
{0, 0, 1, 0, 0, 1, 0, 0},
{0, 1, 0, 0, 0, 0, 1, 0},
{1, 1, 1, 1, 1, 1, 1, 1},
{1, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 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},
{0, 0, 0, 1, 1, 0, 0, 0},
{0, 0, 1, 1, 1, 1, 0, 0},
{0, 0, 1, 1, 1, 1, 0, 0},
{0, 0, 0, 1, 1, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0}
};
……………………………………………………………………………..
digitalWrite(col[thisPin], HIGH);
181
setupChar();
void loop() {
refreshScreen();
if(count-- == 0){
count = 1000;
setupChar();
void setupChar(){
char c = str[ptrChar];
int offset = c - 'A';
const charMapType *cMap = charMap[offset];
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
bool v = (*cMap)[x][y];
if(v){
pixels[x][y] = LOW;
}else{
pixels[x][y] = HIGH;
182
ptrChar++;
if(ptrChar>=strLen-1){
ptrChar = 0;
void refreshScreen() {
for (int thisRow = 0; thisRow < 8; thisRow++) {
digitalWrite(row[thisRow], HIGH);
for (int thisCol = 0; thisCol < 8; thisCol++) {
int thisPixel = pixels[thisRow][thisCol];
digitalWrite(col[thisCol], thisPixel);
if (thisPixel == LOW) {
digitalWrite(col[thisCol], HIGH);
digitalWrite(row[thisRow], LOW);
183
13. Hiển thị chữ lên màn hình LCD16x02.

Giới thiệu module LCD 16X02:
Trong bài này các bạn sẽ tìm cách điều khiển màn hình LCD bằng Arduino mà
không sử dụng module I2C LCD. Chỉ cần Arduino bạn có thể điều khiển được
LCD nhưng lại tốn khá nhiều chân của arduino, Ở phần tiếp theo chúng ta sẽ sử
dụng module I2C để giải quyết vấn đề đó.

 1 module LCD 16x02.
 1 biến trở 10K.
184
Lắp mạch( nếu các bạn đã có kit học thì chỉ việc nối dây):
185
Lập trình:
#include <LiquidCrystal.h> //Khai báo thư viện cho LCD ( Thư viện đã có sẵn)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //noi voi chan LCD LAN LUOT : Rs, E, D4, D5, D6, D7
void setup() {
//Thông báo đây là LCD 1602
lcd.print("DIEN – DIEN TU!"); //In ra màn hình lcd dòng chữ DIEN – DIEN TU
void loop() {
lcd.setCursor(0, 1); // đặt con trỏ vào cột 0, dòng 1
lcd.print(" TDHShop"); // In ra dong chu
}
14. Kết hợp Module I2C với LCD16x02.

Giới thiệu module I2C cho LCD:
Với module chuyển giao tiếp LCD sang I2C, các bạn chỉ cần 2 chân (SDA và
SCL) của Arduino kết nối với 2 chân (SDA và SCL) của module là đã có thể hiển
thị thông tin lên LCD. Ngoài ra có thể điều chỉnh được độ tương phản bởi biến trở
186
gắn trên module.
Đây chính là Module chuyển giao tiếp I2C

 1 module LCD 16x02.
 1 module I2C cho LCD.
Trước hết ta phải add thư viện I2C vào phần mền Arduino IDE. Các bạn tải thư
viện tại links sau: http://tdhshop.com.vn/tong-hop-cac-thu-vien-cho-arduino
187
Lưu ý : Với các dòng mega các bạn nối chân SCL vào SCL và SDA vào SDA.
Lập trình:
// sau khi upload chương trình các bạn nhớ chỉnh biến trở xanh trên I2C nhé.
// trường hợp sử dụng địa chỉ 0x27 không được thay bằng 0x3F.
// Trên module I2C có biến trở chúng ta hãy điều chỉnh độ sáng của LCD.
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F,16,2); // lưu ý ở đây có 2 địa chỉ ( 0x27) hoặc (0x3F)
void setup()
{
lcd.init();
lcd.backlight();
lcd.print("TDHshop.com.vn");
}
void loop()
{
}
188
15. Đọc giá trị cảm biến quang trở hiển thị lên serial
monitor.
Giới thiệu cảm biến quang trở:

Quang trở là một loại "vật liệu" điện tử rất hay gặp và được sử dụng trong những
mạch cảm biến ánh sáng. Có thể hiểu một cách dễ dàng rằng, quang trở là một loại
ĐIỆN TRỞ mà giá trị của nó thay đổi theo cường độ ánh sáng.
Nếu đặt ở môi trường có ít ánh sáng hoặc tối thì điện trở của quang trở sẽ tăng cao
còn nếu đặt ở ngoài nắng, hoặc nơi có ánh sáng thì điện trở sẽ giảm. Quang trở
không phân biệt chân.
189
Phần cứng chuẩn bị: (được tích hợp trên Kit Tự Học)

 1 quang trở.
 1 điện trở 10K.
190
Bây giờ chúng ta upload chương trình đọc giá trị cảm biến quang trở cho arduino và xem
giá trị của quang trở, nhớ là hãy thay đổi độ sáng của môi trường để xem sự thay đổi của
quang trở (chẳng hạn bạn lấy bàn tay che ánh sáng chiếu trực tiếp vào qua ng trở chẳng
hạn).
Lập trình:
int quangtro = A5; //Thiết đặt chân analog đọc quang trở
void setup() {
// Khởi tạo cộng Serial 9600
Serial.begin(9600);
}
void loop() {
int giatriQuangtro = analogRead(quangtro); // đọc giá trị quang trở
Serial.println(giatriQuangtro); // Xuất giá trị ra Serial Monitor

}
191
16. Đọc gái trị CB nhiệt độ LM35 hiển thị lên serial monitor.
Giới thiệu cảm biến nhiệt độ LM35:
Cảm biến nhiệt độ LM35 là một loại cảm biến tương tự rất hay được ứng dụng
trong các ứng dụng đo nhiệt độ thời gian thực ( nhưng vẫn còn sai số lớn) . Với
kích thước nhỏ và giá thành rẻ là một trong những ưu điểm của nó. Vì đây là cảm
biến tương tự (analog sensor) nên ta có thể dễ dàng đọc được giá trị của nó bằng
hàm analogRead().
Nhiệt độ được xác định bằng cách đo hiệu điện thế ngõ ra của LM35.
→ Đơn vị nhiệt độ: °C.
→ Nhiệt độ thay đổi tuyến tính: 10mV/°C
Độ chính xác thực tế: 1/4°C ở nhiệt độ phòng và 3/4°C ngoài khoảng 2°C tới 150°C công
suất tiêu thụ là 60uA.
Cảm biến LM35 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
Vout (chân giữa) ứng với mỗi mức nhiệt độ.
Như vậy, bằng cách đưa vào chân bên trái của cảm biến LM35 hiệu điện thế 5V, chân
phải nối đất, đo hiệu điện thế ở chân giữa bằng các pin A0 trên arduino (giống y hệt cách
đọc giá trị biến trở), bạn sẽ có được nhiệt độ (0-100ºC) bằng công thức:
float temperature = (5.0*analogRead(A0)*100.0/1024.0);
Với LM35, bạn có thể tự tạo cho mình mạch cảm biến nhiệt độ sử dụng LM35 và tự động
ngắt điện khi nhiệt độ vượt ngưỡng tối đa, đóng điện khi nhiệt độ thấp hơn ngưỡng tối
thiểu thông qua module rơ le...
192

 1 cảm biến nhiệt độ LM35.
Lắp mạch:
Lập trình:
193
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
// Bạn không cần phải pinMode cho các chân analog trước khi dùng nó
}
void loop() {
//đọc giá trị từ cảm biến LM35
int reading = analogRead(sensorPin);
//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.
// Vì vậy nếu biến voltage là biến lưu hiệu điện thế (đơn vị Volt)
// thì ta chỉ việc nhân voltage cho 100 là ra được nhiệt độ!
float temp = voltage * 100.0;
Serial.println(temp);
delay(1000); //đợi 1 giây cho lần đọc tiếp theo
}
17. Đọc giá trị CB nhiệt độ DS18B20 hiển thị lên serial monitor.
Giới thiệu cảm biến nhiệt độ DS 18B20:

Cảm biến nhiệt độ DS18B20 với dãy đo (-55°C đến +125°C) sai số ±0.5°C. Nhiệt
độ ít bị chênh lệch hơn so với cảm biến nhiệt độ LM35.
194
Về căn bản, cảm biến này cũng giống như LM35, các bạn có thể xem phần cảm
biến LM35 ở phần trước. DS18B20 dùng cơ chế truyền tín hiệu 1-Wire. Nôm na
với cái cơ chế này, chúng ta có thể đọc nhiều con DS18B20 cùng một lúc trên cùng
1 dây.
 Sử dụng một chân data với 64bit serial code cho phép chúng ta dùng nhiều
con trên cùng 1 chân digial (cơ chế 1-Wire)
 Có thể cấp nguồn từ 3 - 5.5V
 Đo từ -55°C đến +125°C sai số ±0.5°C nếu đang trong khoản -10°C đến
+85°C

 1 cảm biến nhiệt độ DS18b20.
 1 điện trở 4.7K.
195
Lắp mạch:
Đối với loại không dây:
Đối với loại có dây:
Lập trình:
Trước khi bắt tay vào lập trình ta cần phải tải hai thư viện sau và add vào thư viện
cho arduino IDE:
Thư viện thứ 1: OneWire.h
Thư viện thứ 2: DallasTemperature.h
Tải Tại Đây
Cách add thư viện vào Ardunio IDE: Xem tại đây
196
Ta bắt tay vào lập trình sau khi add xong 2 thư viện trên.
#include <OneWire.h>
#include <DallasTemperature.h>
// Chân nối với Arduino
#define ONE_WIRE_BUS 2 //Thiết đặt thư viện onewire
OneWire oneWire(ONE_WIRE_BUS);
//Mình dùng thư viện DallasTemperature để đọc
DallasTemperature sensors(&oneWire);
void setup(void)
{
Serial.begin(9600);
sensors.begin();
}
void loop(void)
{
sensors.requestTemperatures();
Serial.print("Nhiet do");
Serial.println(sensors.getTempCByIndex(0)); // Vì chỉ 1cảm biến nên dùng 0
//chờ 1 s rồi đọc giá trị cảm biến
delay(1000);
}
Sau khi upload chương trình xong các bạn mở cổng Serial port xem kết quả
nhé.
197
18. Hiển thị giá trị CB nhiệt độ LM35 lên mà hình LCD.

 1 cảm biến nhiệt độ LM35.
 1 Module I2C cho LCD.
 1 LCD 16x02.
Lắp mạch :
Lập trình :
#include <Wire.h>
int sensorPin = A0; // chân analog kết nối tới cảm biến LM35
LiquidCrystal_I2C lcd(0x3F,16,2);
void setup()
{
Serial.begin(9600); //Khởi động Serial ở mức baudrate 9600
lcd.init();
lcd.backlight();
198
lcd.print("NHIET DO");
}
void loop()
{
//đọc giá trị từ cảm biến LM35
int reading = analogRead(sensorPin);
//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.
// Vì vậy nếu biến voltage là biến lưu hiệu điện thế (đơn vị Volt)
float temp = voltage * 100.0;
Serial.println(temp);
lcd.setCursor(0, 1);
lcd.print("T =");
lcd.print(temp);
delay(1000); //đợi 1 giây cho lần đọc tiếp theo
}
199
19. Đọc giá trị cảm biến mưa hiển thị lên serial monitor.
Giới thiệu cảm biến mưa:
Chúng ta có thể dễ dàng nhận biết mưa bằng mắt thường hoặc cảm nhận ở da.
Với tư tưởng ấy, các hệ thống điện tử phát hiện mưa cũng chia ra làm hai loại: thứ
nhất là dùng camera để nhận biết và loại thứ hai là dùng cảm biến (tương tự da của
con người). Trong môi trường Arduino, bạn có thể dùng cả 2 cách trên để phát
hiện mưa. Tuy nhiên, để tiết kiệm chi phí và dễ dàng trong việc lập trình, cài đặt,
người ta thường chọn phương pháp thứ hai.
Vấn đề về phát hiện mưa thì cực kì đơn giản, nhưng để truyền dữ liệu cảm biến
mưa về trung tâm xử lý thì khó hơn đôi chút.
Mạch cảm biến mưa gồm 2 phần:
 Mạch cảm biến mưa được gắn ngoài trời.

 Mạch điều chỉnh độ nhạy cần được che chắn.
Mạch cảm biến mưa hoạt động bằng cách so sánh hiệu điện thế của mạch cảm biến
nằm ngoài trời với giá trị định trước (giá trị này thay đổi được thông qua 1 biến trở
màu xanh) từ đó phát ra tín hiệu đóng / ngắt rơ le qua chân D0(digital) hoặc
AO(analog). Vì vậy, chúng ta dùng một chân digital hoặc analog để đọc tín hiệu từ
cảm biến mưa.
200
Khi cảm biến khô ráo (trời không mưa), chân D0 của module cảm biến sẽ được
giữ ở mức cao (5V). Khi có nước trên bề mặt cảm biến (trời mưa), đèn LED màu
đỏ sẽ sáng lên, chân D0 được kéo xuống thấp (0V).

 1 cảm biến mưa.
Lắp mạch :
Lập trình :
int rainSensor = 6; // Chân tín hiệu cảm biến mưa ở chân digital 6 (arduino)
void setup() {
pinMode(rainSensor,INPUT);// Đặt chân cảm biến mưa là INPUT, vì tín hiệu sẽ
được truyền đến cho Arduino
Serial.begin(9600);// Khởi động Serial ở baudrate 9600
}
201
void loop() {
int value = digitalRead(rainSensor); //Đọc tín hiệu cảm biến mưa
if (value == HIGH) { // Cảm biến đang không mưa
Serial.println("Khong mua");
}
else
{
Serial.println("Dang mua");
}
delay(1000); // Đợi 1 giây cho lần kiểm tra tiếp theo.
}
202
20. Đọc giá trị CB siêu âm SRF 05 hiển thị lên serial
monitor.
Robot khi ở chế độ tự động, nó phải lấy thông tin của môi trường xung quanh
như: khoảng cách, nhiệt độ, ánh sáng ... Và tiến hành phân tích các dữ liệu đó, cuối
cùng ra quyết định phù hợp. Ví dụ như robot tự tìm đường đi thì nó phải tính được
xem phía trước có vật cản hay không, và tiến hành đi tới hay rẽ sang một hướng
khác. Bài viết này sẽ hướng dẫn bạn đọc hiểu và sử dụng được một trong những
cảm biến khoảng cách phổ biến - SRF05.
Giới thiệu cảm biến siêu âm SRF05:

Sóng siêu âm là một loại sóng cao tầng mà con người không thể nghe thấy
được. Tuy nhiên, ta có thể thấy được sự hiện diện của sóng siêu âm ở khắp mọi nơi
trong tự nhiên. Ta có các loài động vật như dơi, cá heo ... dùng sóng siêu âm để
liên lạc với nhau, để săn mồi hay định vị trong không gian.
Việc tính toán khoảng cách cũng còn phụ thuộc rất nhiều vào môi trường truyền
dẫn, ví dụ như sóng âm truyền trong môi trường nước hay kim loại sẽ nhanh hơn
rất nhiều so với sóng âm được truyền trong môi trường không khí. Lưu ý là sóng
âm không thể truyền được trong môi trường chân không.
Cảm biến siêu âm SRF05 cũng hoạt động theo như nguyên tắc ở trên, thiết bị
gồm có 2 loa - thu và phát - cùng với 5 chân để kết nối với Arduino, tầm hoạt động
tối đa của cảm biến này nằm trong khoảng từ 1 đến 2m.
203
Chức năng của các chân này như sau:
1. Vcc: cấp nguồn cho cảm biến.

2. Trigger: kích hoạt quá trình phát sóng âm. Quá trình kích hoạt khi một chu
kì điện cao / thấp diễn ra.
3. Echo: bình thường sẽ ở trạng thái 0V, được kích hoạt lên 5V ngay khi có tín
hiệu trả về, sau đó trở về 0V.
4. Gnd: nối với cực âm của mạch
5. OUT: không sử dụng

 1 cảm biến SRF05.
Lắp mạch :
• Vcc: nối với nguồn 5V của Adruino

• Gnd: nối với PIN GND.
• Trigger: nối với PIN 8.
204
• Echo: nối với PIN 7.
205
Lập trình :
const int trig = 8; // chân trig của HC-SR05

const int echo = 7; // chân echo của HC-SR05
void setup()
{
Serial.begin(9600); // giao tiếp Serial với baudrate 9600
pinMode(trig,OUTPUT); // chân trig sẽ phát tín hiệu
pinMode(echo,INPUT); // chân echo sẽ nhận tín hiệu
}
void loop()
{
unsigned long duration; // biến đo thời gian
int distance; // biến lưu khoảng cách
/* Phát xung từ chân trig */
digitalWrite(trig,0); // tắt chân trig
digitalWrite(trig,1); // phát xung từ chân trig
delayMicroseconds(5); // xung có độ dài 5 microSeconds
digitalWrite(trig,0); // tắt chân trig
/* Tính toán thời gian */
// Tính khoảng cách đến vật.
distance = int(duration/2/29.1);
/* In kết quả ra Serial Monitor */
Serial.print(distance);
Serial.println("cm");
delay(200);
}
Giải tích code:
Ta biết thời gian âm thanh truyền trong không khí ở 20°C là 344 m/s. Bằng quy
tắc tam suất đơn giản ta có thể dễ dàng tính được sóng âm di chuyển 1 cm trong
không khí sẽ mất 1000 / 344 * 100 ~= 29.1.
Arduino cung cấp cho ta hàm pulseIn có tác dụng trả về thời gian (tính bằng
milisec) kể từ khi hàm này được gọi cho đến khi có tín hiệu tại PIN chỉ định trước,
hay trả về 0 nếu không nhận được tín hiệu / quá thời gian timeout.
206
Kết quả hiển thị lên Serial monitor :
21. Đọc giá trị cảm biến độ ẩm đất hiển thị lên LCD16x02.
Giới thiệu cảm biến độ ẩm đất:
 Cảm biến phát hiện độ ẩm đất, bình thường đầu ra của cảm biến độ ẩm đất là
digital (D0) và analog (A0), tùy các bạn có thể lựa chọn chân số (digital) hay
chân tương tự (analog) để lập trình,
 Độ nhạy của cảm biến độ ẩm đất có thể điều chỉnh được (Bằng cách điều
chỉnh biến trở màu xanh trên board mạch) cái này chỉ có tác dụng với chân
digital (D0).
 Phần đầu dò được cắm vào đất để phát hiện độ ẩm, khi độ ầm của đất đạt
ngưỡng thiết lập, đầu ra D0 sẽ chuyển trạng thái từ mức thấp lên mức cao.
207
 Điện áp làm việc 3.3V ~ 5V.

 Có lỗ cố định để lắp đặt thuận tiện.
 PCB có kích thước nhỏ 3.2 x 1.4 cm.
 Sử dung chip LM393 để so sánh, ổn định làm việc.
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn)

 1 cảm biến độ ẩm đất.
 1 rơ le 5VDC
Lắp mạch :
Trong bài học này ta ứng dụng giá trị cảm biếm độ ẩm đất đọc về để điều khiển
đóng ngắt rơ le 5Vdc.
208
Lập trình :
//Chương trình ĐỌC DỮ LIÊU TỪ CẢM BIẾN ĐO ĐỘ ẨM ĐẤT
int CBDoAm = A1; //Nối chân ra của cảm biến đo độ ẩm với chân A1
#define role 12 //Chân nối với role 12
float doamdat; //Biến độ ẩm đất
void setup()
{
Serial.begin(9600);
//Khai báo các chân
pinMode(role,OUTPUT);
}
void loop()
{
doamdat=analogRead(CBDoAm);
Serial.print("Do am la:");
Serial.print(doamdat); //In ra độ ẩm đất (serial monitor)
//Bơm nước khi đất khô( thông qua role)
if(doamdat<200)
{
digitalWrite(role,HIGH); //Bat role de tuoi cay,…
209
Serial.println("Tuoi cay");
}
//Ngưng bơm khi đất ướt
else
{
digitalWrite(role,LOW);
Serial.println("Cay du nuoc");
}
delay(1000);
}
22. Đọc giá trị CB dò line hiển thị lên serial monitor và LCD.
Giới thiệu cảm biến dò line:
Cảm biến dò line có thể dùng để phát hiện line trắng và đen. Mạch sử dụng cảm
biến hồng ngoại với khoảng cách phát hiện từ 1~25mm. Có thể điều chỉnh độ nhạy
của cảm biến bằng cách điều chỉnh biến trở được tích hợp sẵn trên module.
210
• Nguồn cung cấp: 3.3V - 5V.
• Dòng điện tiêu thụ: <10mA.
• Dải nhiệt độ hoạt động: 0 độ C ~ 50 độ C
• Ngõ ra giao tiếp: 3 chân (VCC, GND, OUT)
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn)

 1 cảm biến dò line.
211

 1 led đơn.
 1 điện trở 220 Ohm.
 1 LCD 16x02.
 1 I2C cho LCD.
Lắp mạch :
Lập trình :
Code lập trình sẽ được để trong một file ( file_code) riêng để tránh việc bị lỗi.
// CHƯƠNG TRÌNH THỬ ĐẶC TÍNH CỦA CẢM BIẾN DÒ LINE
#include <Wire.h>
#define den 8 // Sử dụng chân 8 để điều khiển đèn led
212
#define tinhieu 2 //Chân S của cảm biến nối với chân 2 trên mạch Arduino
int x; //Tên biến chứa giá trị của cảm biến dò đường
LiquidCrystal_I2C lcd(0x3F,16,2); // dia chi của i2c lcd
void setup()
{
Serial.begin(9600); //Đưa dữ liệu lên máy tính để quan sát
pinMode(den,OUTPUT); //Định nghĩa chân ra để điều khiển đèn led
pinMode(tinhieu,INPUT); //Định nghỉa chân 2 là chân lấy tín hiệu vào của cảm
biến
lcd.init();
lcd.backlight();
lcd.print("CB DO LINE");
}
void loop()
{
Serial.println(x);
lcd.print("x =");
lcd.print(x);
if(x==HIGH) //nếu x=1 (gặp màu đen) thì đèn tắt
{
digitalWrite(den,LOW);
}
if(x==LOW) //Nếu x=0 (gặp màu trắng) thì đèn sáng
{
digitalWrite(den,HIGH);
}
delay(1000); //Chờ 1 giây để hệ thống đáp ứng
}
213
214
23. Đọc giá trị điện áp khi điều chỉnh biến trở hiển thị lên
serial
Giới thiệu về biến trở:

Biến trở chỉ đơn giản chỉ là một điện trở có thể thay đổi được trị số. Mạch
Arduino không đọc trực tiếp điện trở này mà đọc gián tiếp qua điện áp mà biến trở
gây ra.
Phần màu vàng là một lớp điện trở. Cây kim màu xanh được đè chặt xuống
phần điện trở này. Giả sử có dòng điện đi từ 1 đến 2 thì nó sẽ phải qua phần màu
vàng (được tô đỏ) và đó chính là điện trở hiện tại của biến trở. Bạn chỉ việc vặn
cây kim để tăng giảm độ dài của vùng màu đỏ, qua đó tăng giảm giá trị điện trở.
Khi vặn biến trở, ta sẽ làm thay đổi điện trở ở phần màu đỏ và màu vàng (do
điện tích của chúng thay đổi), qua đó làm thay đổi điện áp ở chân 2.
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn biến trở 10K)

 1 biến trở xoay 10K.
Lắp mạch :
215
Lập trình :
Code lập trình sẽ được lưu trong một file ( file_code) riêng để tránh việc bị lổi,
code bên dưới chỉ dưới dạng giải thích.
void setup() {
Serial.begin(9600); //Mở cổng Serial để giap tiếp
}
void loop() {
int value = analogRead(A0); //đọc giá trị điện áp ở chân A0
//(value luôn nằm trong khoảng 0-1023)
Serial.println(value); //xuất ra giá trị vừa đọc
voltage = map(value,0,1023,0,5000); //chuyển thang đo của value

//từ 0-1023 sang 0-5000 (mV)
Serial.println(voltage); //xuất ra điện áp (đơn vị là mV)
Serial.println(); //xuống hàng

delay(200); //đợi 0.2 giây
216
217
24. Hiển thị thời gian thực (DS1307) lên LCD và serial monitor.
Giới thiệu về module DS1307:

Bài viết này sẽ giới thiệu về giao tiếp I2C trên Arduino và sử dụng module
Realtime clock DS1307.
Trước tiên bạn cài 3 thư viện : Wire ( thư viện này đã có sẵn), DS1307 và I2C
cho arduino IDE. Các bạn tải thư viện tại links sau: http://tdhshop.com.vn/tong-
hop-cac-thu-vien-cho-arduino
Giới thiệu một số hàm trong thư viện Wire.h:
Wire.begin(address (optional));
• Khởi tạo thư viện Wire.h và tham gia vào I2C bus.
• address: 7-bit địa chỉ của thiết bị "Slave" (optional); nếu không có địa chỉ thì
coi như "Master".
Wire.beginTransmission(address);
• Bắt đầu truyền dữ liệu đến thiết bị "Slave" với address đã có.
Wire.endTransmission();
• Kết thúc truyền dữ liệu đến thiết bị "Slave" đã được bắt đầu
bởi Wire.beginTransmission(address).
Wire.write(value);
• Ghi dữ liệu lên thiết bị "Slave", được gọi giữa beginTransmission()
và endTransmission().
Wire.read();
• Đọc dữ liệu được truyền từ thiết bị "Slave" đến Arduino, được gọi sau
requestFrom().
Wire.requestFrom(address, quantity);
• Được sử dụng bởi thiết bị "Master" để yêu cầu dữ liệu từ thiết bị "Slave".
• address: là địa chỉ của thiết bị "Slave".
218
• quantity: số lượng bytes yêu cầu.

Đây là các Timekeeper registers của DS1307, chúng ta sẽ dựa vào bảng này để
read/write IC DS1307 qua I2C.
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn biến trở 10K)

 1 module DS1307.
 1 LCD 16x02.
 1 I2C cho LCD.
Lắp mạch :
219
Lập trình :
#include <Wire.h>
#include "RTClib.h"
LiquidCrystal_I2C lcd(0x3F,16,2); // 0x3F là địa chỉ của lcd 16x2
void setup () {
lcd.init();
lcd.backlight(); // bật đèn nền LCD
lcd.begin(16, 2);
lcd.print("H:");
lcd.print("D:");
Serial.begin(9600);
Wire.begin();
Wire.beginTransmission(0x68); // địa chỉ của ds1307
Wire.write(0x07);
Wire.write(0x10);
RTC.begin();
if (! RTC.isrunning()) {
Serial.println("RTC is NOT running!");
RTC.adjust(DateTime(__DATE__, __TIME__)); //dòng này nạp 1 lần rồi xóa rồi
nạp lại thì thời gian sẽ không bị chạy lại khi mất điện.
}
}
void loop () {
lcd.print(now.hour(), DEC); // in ra giờ lên LCD
lcd.print(":");
lcd.print(now.minute(), DEC); // in ra phút lên LCD
lcd.print(":");
lcd.print(now.second(), DEC); // in ra giây lên LCD
lcd.print(" ");
220
Serial.print(now.hour(), DEC); // in ra giờ lên SERIAL

Serial.print(":");
Serial.print(now.minute(), DEC); // in ra giờ lên SERIAL
Serial.print(":");
Serial.print(now.second(), DEC); // in ra giờ lên SERIAL
Serial.print(" ");
Serial.print(now.day(), DEC);
Serial.print("/");
Serial.print(now.month(), DEC);
Serial.print("/");
Serial.print(now.year(), DEC);
Serial.print("");
Serial.println();
lcd.print(now.day(), DEC); // in ra ngày lên LCD
lcd.print("/");
lcd.print(now.month(), DEC); // in ra tháng lên LCD
lcd.print("/");
lcd.print(now.year(), DEC); // in ra năm lên LCD
lcd.print("");
delay(1000);
}
221
222
25. Hiển thị tốc độ đo bằng Encoder quay lên LCD.

Giới thiệu về module Encoder quay:
Rotaty Encoder Module trông giống 1 module biến trở nhưng có ngõ ra dạng
xung số. Bằng việc xoay núm vặn, ngõ ra xung của 2 kênh sẽ thay đổi với 1 độ
lệch pha xác định (90độ) giúp phân biệt được chiều xoay.
Đếm số lượng xung ngõ ra sẽ cho biết vị trí góc xoay, vị trí này là không giới
hạn. Đồng thời module cũng cung cấp 1 nút nhấn có thể được lập trình để trở thành
1 nút reset giá trị đếm.
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn )

 1 module encoder quay.
 1 LCD 16x02.
 1 I2C cho LCD.
 Điện áp cung cấp: 3.3
 Độ phân giải 20 xung /vòng.
 Các chân tín hiệu:
 +: chân cấp nguồn dương.
 GND: chân cấp nguồn âm.
 CLK: phase A.
 DT: phase B.
 SW: button
223
Để điều khiển số vòng quay hay vận tốc động cơ thì chúng ta nhất thiết phải đọc
được góc quay của motor.
Encoder thường bao gồm kênh A, kênh B. Trong hình bạn thấy hãy chú ý một lỗ
nhỏ bên phía trong của đĩa quay và một cặp phát - thu dành riêng cho lỗ nhỏ này.
Cữ mỗi lần motor quay được một vòng. Bên ngoài đĩa quay được chia thành các
rãnh nhỏ và một cặp thu-phát khác dành cho các rãnh này. Đây là kênh A của
encoder. Mỗi loại encoder có độ phân giải khác nhau, có khi trên mỗi đĩa chĩ có vài
rãnh nhưng cũng có trường hợp đến hàng nghìn rãnh được chia. Để điều khiển
động cơ, bạn phải biết độ phân giải của encoder đang dùng. Độ phân giải ảnh
224
hưởng đến độ chính xác điều khiển và cả phương pháp điều khiển tuy nhiên trên
các encoder còn có một cặp thu phát khác được đặt trên cùng đường tròn với
kênh A nhưng lệch một chút (lệch M+0,5 rãnh), đây là kênh B của encoder. Tín
hiệu xung từ kênh B có cùng tần số với kênh A nhưng lệch pha 90o. Bằng cách
phối hợp kênh A và B người đọc sẽ biết chiều quay của động cơ.
Hai kênh A và B lệch pha trong encoder

Hình trên thể hiện sự bộ trí của 2 cảm biến kênh A và B lệch pha nhau. Khi
cảm biến A bắt đầu bị che thì cảm biến B hoàn toàn nhận được hồng ngoại xuyên
qua, và ngược lại. Hình thấp là dạng xung ngõ ra trên 2 kênh. Xét trường hợp
motor quay cùng chiều kim đồng hồ, tín hiệu “đi” từ trái sang phải.
Bạn hãy quan sát lúc tín hiệu A chuyển từ mức cao xuống thấp (cạnh xuống)
thì kênh B đang ở mức thấp. Ngược lại, nếu động cơ quay ngược chiều kim đồng
hồ, tín hiệu “đi” từ phải qua trái. Lúc này, tại cạnh xuống của kênh A thì kênh B
đang ở mức cao.
Như vậy, bằng cách phối hợp 2 kênh A và B chúng ta không những xác định
được góc quay (thông qua số xung) mà còn biết được chiều quay của động.
Đối với arduino chúng ta sử dụng ngắt để đọc được dữ liệu từ encoder.
Chúng ta nối kênh A của encoder với 1 ngắt ngoài ( INT2 chẳng hạn) và kênh B
với một chân nào đó bất kỳ (không phải chân ngắt). Cứ mỗi lần ngắt ngoài xảy ra,
tức có 1 xung xuất hiện trên ở kênh A thì trình phục vụ ngắt ngoài tự động được
225
gọi. Trong trình phục vụ ngắt này chúng ta kiểm tra mức của kênh B, tùy theo mức
của kênh B chúng ta sẽ tăng biến đếm xung lên 1 hoặc giảm đi 1. Tuy nhiên, bạn
cần phải tính toán rất cẩn thận khi sử dụng phương pháp này. Ví dụ trường hợp
encoder có độ phân giải 2000 xung/vòng, motor bạn quay với vận tốc 100 vòng/s
thì tần số xung trên kênh A của encode là 2000x100=200KHz, nghĩa là cứ mỗi 5 us
ngắt ngoài xảy ra một lần. Tần số ngắt như thế là quá cao cho AVR, điều này có
nghĩa là AVR chỉ tập trung cho mỗi việc “đếm xung”, không có đủ thời gian để
thực thi các việc khác.
Trong bài này, chúng ta chọn độ phân giải của encoder là 20 (20 xung trên mỗi
vòng quay, loại encoder đơn giản nhất).
Lắp mạch:
Lập trình :
Trước tiên ta phải add thêm thư viện I2C cho arduino IDE.
Tải thư viện theo link sau:

Cách add thư viện cho Arduino IDE : http://tdhshop.com.vn/huong-dan-cai-

thu-vien-vao-arduino-ide-ho-tro-cho-viec-lap-trinh
226
#include <Wire.h>
LiquidCrystal_I2C lcd(0x3F,20,4);
// Cách nối các chân trên Encoder quay
#define encoderPinA 2 // Tương ứng chân DT trên Encoder quay
#define encoderPinB 3 // Tương ứng chân CLK trên Encoder quay
// Chân + nối nguồn 5V và chân GND nối cực âm
volatile int encoderPos = 0; // Cho vị trí đầu bằng 0
int lastReportedPos = 1; // Vị trí cuối bằng 1
static boolean rotating=false; // Quản lý debounce (giống như là chống nhiễu)
// các biến cho trình phục vụ ngắt interrupt
boolean A_set = false;
boolean B_set = false;
//Đo tốc độ
int newposition;
int oldposition=0;
long newtime;
long oldtime=0;
int vantoc = 0;
int sovong = 0;
void setup() {
lcd.begin(20,4);
lcd.init();
lcd.backlight();
pinMode(encoderPinA, INPUT_PULLUP); // INPUT-PULLUP tương đương
Mode INPUT và tự động nhận trạng thái HIGH hoặc LOW
pinMode(encoderPinB, INPUT_PULLUP);
Serial.begin(9600); // chuyển dữ liệu lên cổng Serial Port
lcd.setCursor(0,1);
lcd.print("SO VONG = ");
}
// Vòng lặp chính, công việc được thực hiện bởi trình phục vụ ngắt
void loop() {
delay(1000);
rotating = true; // Khởi động bộ debounce (có thể hiểu như bộ chống nhiễu)
newtime=millis();
detachInterrupt(0);
detachInterrupt(1);
vantoc = (newposition-oldposition)*60/20;
227
Serial.print("vantoc=");
Serial.println(vantoc,DEC);
oldposition=newposition;
oldtime=newtime;
lcd.clear();
lcd.setCursor(0,0);
lcd.print("TOC DO = ");
lcd.setCursor(11,0);
lcd.print(vantoc);
lcd.print(" RPM");
lcd.setCursor(0,1);
lcd.print("SO VONG = ");
lcd.setCursor(11,1);
lcd.print(sovong,DEC);
attachInterrupt(0, doEncoderA, CHANGE);
attachInterrupt(1, doEncoderB, CHANGE);
}
// Ngắt khi chuyển trạng thái của A
void doEncoderA(){
if ( rotating ) delay (1); // Chờ 1 chút
// Kiểm tra việc chuyển đổi trạng thái, xem có thật sự thay đổi trạng thái chưa
if( digitalRead(encoderPinA) != A_set ) {
A_set = !A_set;
// Cộng 1 nếu có tín hiệu A rồi có tín hiệu B
if ( A_set && !B_set )
encoderPos += 1;
ganxung += 1;
sovong=encoderPos/20;
if (ganxung == 42){ganxung=0;}
rotating = false; // Không cần debounce nữa cho đến khi được nhấn lần nữa
}
}
// Ngắt khi thay đổi trạng thái ở B, tương tự như ở A
void doEncoderB(){
if ( rotating ) delay (1);
if( digitalRead(encoderPinB) != B_set ) {
// Trừ 1 nếu B rồi đến A
if( B_set && !A_set )
encoderPos -= 1;
228
rotating = false;
}
}
26. Cài đặt và hiển thị nhiệt độ, độ ẩm (DTH11).

Bài học này giúp chúng ta áp dụng những bài trước ta đã học, giao tiếp I2C trên
Arduino và sử dụng module DTH11, và cách cài đặt nhiệt độ, độ ẩm để đóng ngắt
thiết bị theo yêu cầu của chúng ta. Và hiển thị giá trị nhiệt độ độ ẩm lên màn hình
LCD16X02.
Trước tiên bạn cài 2 thư viện : DTH11 và I2C cho arduino IDE. Các bạn tải 2 thư
viện này tại: http://tdhshop.com.vn/tong-hop-cac-thu-vien-cho-arduino
Giới thiệu về giao tiếp I2C:
I2C là viết tắt của "Inter-Integrated Circuit", một chuẩn giao tiếp được phát
minh bởi Philips’ semiconductor division (giờ là NXP) nhằm đơn giản hóa việc
trao đổi dữ liệu giữa các ICs. Đôi khi nó cũng được gọi là Two Wire Interface
229
(TWI) vì chỉ sử dụng 2 kết nối để truyền tải dữ liệu, 2 kết nối của giao tiếp I2C
gồm: SDA (Serial Data Line) và SCL (Serial Clock Line).
Có hàng ngàn thiết bị sử dụng giao tiếp I2C, chẳng hạn như real-time clocks,
digital potentiometers, temperature sensors, digital compasses, memory chips, FM
radio circuits, I/O expanders, LCD controllers, amplifiers,...Board Arduino của
chúng ta có thể kiểm soát tất cả và số lượng tối đa trong một thời điểm lên đến 112
thiết bị I2C.
Trên board Arduino UNO, SDA là chân analog A4, SCL là chân analog A5.
Module DHT11:
Thông số kỹ thuật DHT11:

DHT11 Là cảm biến nhiệt độ, độ ẩm rất thông dụng hiện nay vì chi phí rẻ và rất
dễ lấy dữ liệu thông qua giao tiếp 1-wire ( giao tiếp digital 1-wire truyền dữ liệu
duy nhất). Cảm biến được tích hợp bộ tiền xử lý tín hiệu giúp dữ liệu nhận về được
chính xác mà không cần phải qua bất kỳ tính toán nào.
 Đặc điểm:
o Điện áp hoạt động : 3V - 5V (DC)
o Dải độ ẩm hoạt động : 20% - 90% RH, sai số ±5%RH
o Dải nhiệt độ hoạt động : 0°C ~ 50°C, sai số ±2°C
o Tần số lấy mẫu tối đa: 1 Hz
o Khoảng cách truyền tối đa: 10m
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn ).

 1 module DHT11.
230
 1 LCD 16x02.
 1 I2C cho LCD.
 2 nút nhấn.
 2 điện trở 10K.
Sơ đồ nối dây của nút nhấn như sau: ( ở trên là 3 nút nhấn ghép lại với nhau
thành 1 module do shop thiết kế (như hình ở dưới), các bạn cũng có thể làm được,
thực hiện giống như hình sau, với nhiều nút nhấn theo ý muốn của mình).
231
Lập trình :
Code lập trình sẽ được lưu trong file ( file_code) riêng để tránh việc bị lổi, code
#include "DHT.h" // khai bao thu vien dht

#include <Wire.h>
#include <LiquidCrystal_I2C.h> // thu vien i2c cho lcd
//DHT11
#define DHTPIN11 6 // chan du lieu kết nối với chân D6 của arduino
#define DHTTYPE11 DHT11
#define minTempC 0 // nhiet do thap nhat có thể thay đổi được
#define maxTempC 100 // nhiet do cao thap nhat có thể thay đổi được
#define startTempC 34 // nhiet do cai ban đầu
float setTempC;
#define buttonDN 5
#define buttonUP 4
#define role 3
LiquidCrystal_I2C lcd(0x3f,16,2);
byte degree[8] = {
0B01110,
0B01010,
0B01110,
0B00000,
0B00000,
0B00000,
0B00000,
0B00000
};
void setup()
{
Serial.begin(9600);
pinMode(buttonDN, INPUT_PULLUP);
pinMode(buttonUP, INPUT_PULLUP);
pinMode(role, OUTPUT);//KICH ROLAY
setTempC = startTempC;
setTempC1 = startTempC;
dht11.begin();
}
232
void loop()
{
setTemperature();
setHeater();
displayLCD();
}
void displayLCD(){
float t1 = dht11.readTemperature();
lcd.init();
lcd.backlight();// initialize the lcd
lcd.clear();
lcd.home ();
lcd.setCursor(0,0);
lcd.print("T1: ");
lcd.setCursor(3,0);
lcd.print(round(t1));
lcd.print("");
lcd.write(1);
lcd.print("C");
…………………………………
lcd.createChar(1, degree);
}
void setTemperature()
{
if (digitalRead(buttonDN)==HIGH){
setTempC++;
if(setTempC < minTempC) setTempC = minTempC;
}
if (digitalRead(buttonUP)==HIGH){
//setTempC += incPlus;
setTempC--;
if(setTempC > maxTempC) setTempC = maxTempC;
}
}
233
void setHeater() // chương trình con so sánh giá trị cài đặt với giá trị thực
{
if ((setTempC) > t1){
digitalWrite(role, LOW);
lcd.setCursor(8,1);
lcd.print("TAT QUAT");
}
else if (setTempC <= (t1)){
digitalWrite(role, HIGH);
lcd.setCursor(8,1);
lcd.print("MO QUAT");
}
}
234
27. Điều khiển động cơ servo SG90:

Động cơ có nhiều loại và biến thể khác nhau, một trong số các biến thể đó là
loại động cơ cho phép ta điều khiển tốc độ, góc quay .. hay nói khác đi cho phép ta
ra lệnh điều khiển và thực thi lệnh đó một cách cực kì chính xác - đó chính là động
cơ servo. Trong bài viết này, ta cùng tìm hiểu cách hoạt động của động cơ servo và
cách lập trình hoạt động thông qua Arduino.
Giới thiệu về động cơ servo SG90:
Động cơ servo cũng được chia làm nhiều loại, phụ thuộc vào góc quay tối đa
của chúng, 2 loại phổ biến hay sử dụng là:
 Động cơ servo quay 180°: Futaba S3003, MG90[S] ...

 Động cơ servo quay 360°: MG995, MG996R ...
Như đã đề cập bên trên, động cơ servo là loại động cơ cho phép ta điều khiển
một cách cực kì chính xác. Vì vậy, khác với động cơ thông thường ta chỉ cần cấp
nguồn cho động cơ là có thể vận hành được. Động cơ servo yêu cầu ta phải cấp
nguồn (2 dây) và nhận điều khiển từ mạch chính (1 dây), mỗi dây thường được
đánh màu như sau:
 Đỏ: nhận điện nguồn, tuỳ vào loại động cơ mà giá trị này có thể khác nhau
 Nâu: nối với cực âm của mạch
 Vàng: nhận tín hiệu từ mạch điều khiển

235
 1 module servo SG90.
Lắp mạch:
Lập trình :
#include <Servo.h>
#define SERVO_PIN 9 // chan tin hieu cua servo noi voi chan so 9 arduino
Servo gServo;
void setup()
{
gServo.attach(SERVO_PIN);
}
void loop()
{
gServo.write(0); // điều chỉnh góc xoay của servo.
delay(1000);

delay(1000);
236

delay(1000);
}
237
28. Điều khiển động cơ bước stepper 28BYJ-48:
Động cơ bước là một loại động cơ mà ở đó bạn sẽ có thể quy định chính xác số
góc quay và động cơ bước sẽ phải quay. Không giống như Servo, động cơ bước
có thể quay bao nhiêu độ tùy ý và mỗi lần quay nó sẽ quay được 1 step, 1 step ở
đây là bao nhiêu còn phụ thuộc vào động cơ bước của bạn. Ví dụ , động cơ bước
của bạn có 72 step thì nó sẽ cần quay 72 step để hoàn thành một vòng quay. Số
step này là hằng số, nhưng bạn có thể dùng công nghệ micro step để "cải thiện" số
vòng quay động cơ bước của bạn.
Giới thiệu về động cơ bước stepper 28BYJ-48:
Động cơ bước sử dụng trong phần này là động cơ bước 4 pha (thực ra là 2 pha
được chia ra làm 2 ở mỗi pha ngay tại vị trí giữa) (gồm 5 dây), 4 trong 5 dây này
được kết nối với 2 cuộn dây trong động cơ và 1 dây là dây nguồn chung cho cả 2
cuộn dây. Mỗi bước của động cơ quét 1 góc 5.625 độ, vậy để quay 1 vòng động cơ
phải thực hiện 64 bước.
Điện thế hoạt động 5V
Số pha 4
Tỉ lệ bánh răng *64
Một bước tương đương 5.625° (64 bước)
Tần số 100Hz
Điện trở trong 50Ω±7%(25℃)

238
 1 động cơ bước stepper 28BYJ-48.

 1 module điều khiển động cơ bước ULN2003.
 1 bộ nguồn ngoài (5V đến 12V) ( trong bài này chúng ta có thể sử dụng
nguồn 5Vdc của arduino nhưng khuyến cáo hạn chế sử dụng để tránh việc
hư board arduino).
Lắp mạch:
Lập trình :
Động cơ BYJ48 Stepper chỉ có sẵn bộ hộp số và nó cho ta đến *64 (tỉ lệ bánh răng)
=> nó có đến 64 * 64 = 4096 bước.
#define IN1 8 // IN1 nối với chân D8 của arduino

#define IN4 11 // IN4 nối với chân D11của arduino
int Steps = 4096;
int cstep = 0;
void setup()
{
239
Serial.begin(9600);
pinMode(IN1, OUTPUT); // các chân IN quy định là các chân ra
pinMode(IN2, OUTPUT);
}
void loop()
{
for(int x=0;x<Steps;x++)
{
step1();
//delay(1);
}
delay(1000);
void step1()
{
//stepp
switch(cstep)
{
case 0:
digitalWrite(IN1, LOW);
digitalWrite(IN4, HIGH);
break;
case 1:
break;
case 2:
………………………………
240
break;
}
cstep=cstep+1;
if(cstep==8)
{cstep=0;}
}
241
29. Bật tắt LED bằng Remote hồng ngoại:

Giới thiệu về Remote hồng ngoại:
Hầu hết chúng ta đã sử dụng remote hồng ngoại để điều khiển TV, quạt, máy
điều hòa,....nhưng không phải ai cũng biết remote làm việc ra sao. Tín hiệu hồng
ngoại là 1 chùm sóng ánh sáng không thể nhìn thấy bằng mắt thường, do đó, bạn
không thể thấy ánh sáng khi nhìn vào cái đèn LED nhỏ ở đầu của remote. Ta dùng
remote hồng ngoại loại nào cũng được….
Trên remote có 1 hoặc nhiều LEDs hồng ngoại (IR LED) được sử dụng để truyền
tín hiệu hồng ngoại. Nhìn bên ngoài thì IR LED giống hệt LED thường, nhưng vì
nó phát ra ánh sáng hồng ngoại nên bạn không thể thấy được ánh sáng của nó bằng
mắt thường.
242
Tín hiệu này sẽ được nhận bởi 1 bộ thu hồng ngoại đặc biệt và chuyển thành dạng
xung điện, sau đó các xung điện này được chuyển đổi thành dữ liệu được sử dụng
cho các thiết bị điện tử.
Nếu bạn tò mò muốn biết ánh sáng hồng ngoại nó như thế nào, hãy nhấn 1 nút
bất kỳ trên remote rồi nhìn vào cái đèn LED ở đầu remote thông qua 1 chiếc
camera nhé!

 1 Remote hồng ngoại hoặc remote Tivi,…
 1 mắt thu hồng ngoại ( IR receiver loại 36Khz).
 1 trở 220 Ohm.
 1 led đơn.
Mắt thu hồng ngoại:
Trong bài viết này mình sử dụng IR receiver loại 36Khz. Vì mỗi loại IR receiver
có sơ đồ chân khác nhau nên các bạn nên tham khảo datasheet của nó nhé!!!
243
Lắp mạch:
Lập trình:
Trước hết các bạn phải add thư viện IR remote vào Arduino IDE. Các bạn tải TẠI
ĐÂY.
Sau khi tải thư viện về, bạn mở cửa sổ IDE, các bạn chọn Sketch--->Import
Library...---> Add Library....sau đó chọn file .zip mà bạn vừa tải về để có thể sử
dụng thư viện. Các bạn có thể tham khảo cách add thư viện TẠI ĐÂY.
Tiếp theo ta upload đoạn code (DOCFILEHEX) sau, các bạn mở cửa sổ Serial và
bấm các nút của remote, tùy loại remote sẽ có giá trị trả về khác nhau và các bạn
nên ghi lại giá trị file HEX để ta lập trình.
Đấy là các giá trị HEX của tín hiệu được gửi từ remote, thử tất cả các nút của
remote các bạn sẽ biết được IR codes của nó.
// Chương trình (CODE) đọc giá trị HEX của từng nút nhấn của Remote hồng
ngoại.
#include <IRremote.h> // thư viện hỗ trợ IR remote

const int receiverPin = 8; // chân digital 8 dùng để đọc tín hiệu
244
decode_results results; // lưu giữ kết quả giải mã tín hiệu

void setup()
{
Serial.begin(9600); // serial baudrate 9600
irrecv.enableIRIn(); // start the IR receiver
}
void loop()
{
if (irrecv.decode(&results)) // nếu nhận được tín hiệu
{
Serial.println(results.value, HEX); // in ra Serial Monitor
delay(200);
irrecv.resume(); // nhận giá trị tiếp theo
}
}
Sau khi đọc được từng giá trị file HEX của các nút nhấn, các bạn nên ghi lại. Tiếp
theo ta nạp chương trình (dieukhienledbangremote) cho arduino sử dụng remote để
bật tắt LED với những giá trị hex ta đã đọc được ở trên.
// bật tắt led ở chân số 12
#include <IRremote.h> // thư viện hỗ trợ IR remote
const int receiverPin = 8; // chân digital 8 dùng để đọc tín hiệu

decode_results results; // lưu giữ kết quả giải mã tín hiệu
const int RED = 12; // LED đỏ

/* trạng thái của các LEDs*/
boolean stateRED = false;
void setup()
{
Serial.begin(9600); // serial
pinMode(RED, OUTPUT);
pinMode(YELLOW, OUTPUT);
pinMode(GREEN, OUTPUT);
}
void translateIR()
{
245
switch(results.value)
{
case 0xFF30CF: stateRED = !stateRED; //ví dụ nhấn số 1(0xFF30CF: g tri hex
số 1)
digitalWrite(RED, stateRED);
break;
case 0xFF6897: stateRED = stateYELLOW = stateGREEN = false;//NHAN SO 0
digitalWrite(RED, 0);
}
}
void loop()
{
if (irrecv.decode(&results)) // nếu nhận được tín hiệu
{
translateIR();
Serial.println(results.value, HEX);
delay(200);
irrecv.resume(); // nhận giá trị tiếp theo
}
}
 Các hàm và lệnh trong của thư viện IR remote như:
o IRrecv irrecv(receiverPin);: tạo đối tượng IRrecv mới có tên là irrecv sử dụng tham
số là receiverPin.
o decode_results results; : lưu kết quả giải mã được
o irrecv.enableIRIn(); : bắt đầu giải mã tín hiệu IR
o irrecv.decode(&results);: trả về true nếu có tín hiệu đến
o irrecv.resume; : đợi tín hiệu IR tiếp theo.
246
30. Điều khiển động cơ bằng module L298n:

Giới thiệu về Module L298:
Trong bài này, tôi sẽ hướng dẫn các bạn sử dụng IC L298 đã tích hợp sẵn mạch cầu H,
ứng dụng trong việc điều khiển cùng lúc 2 động cơ theo chiều quay bất kì, kết hợp với
247
điều xung PWM có thể điều chỉnh tốc độ xoay của động cơ. PWM để cân bằng độ chênh
lệch giữa 2 bánh xe.
Điện áp điều khiển: +6 V ~ +12 V.
L298 gồm các chân:
 12V power, 5V power: bên trong mạch có sử dụng IC điều hướng dòng điện, hoạt
động với điện áp 5V, khi nối nguồn 12V mạch sẽ hoạt động với nguồn 12V, tuy
nhiên mạch sẽ điều hướng dòng điện.
o Điện áp 12V điều khiển động cơ để hoạt động.
o Hạ điện áp xuống thành 5V và cấp nguồn cho IC.
 Như vậy khi cấp nguồn 9V: động cơ hoạt động với dòng 9V và IC của mạch sẽ
hoạt động với điện áp 5V. Việc thiết kế có nhằm điều hướng thành 2 điện áp khác
nhau giúp IC hoạt động ổn định và tách nguồn riêng biệt với động cơ.
 Power GND chân này là GND của nguồn cấp cho Động cơ.
 2 Jump A enable và B enable, nếu bạn dùng Board để điều khiển động cơ bước thì
giữ nguyên. Nếu điều khiển động cơ bình thường thì nối với chân PWM để điều
khiển tốc độ.
 Gồm có 4 chân Input. IN1, IN2, IN3, IN4.
 Output A: nối với động cơ giảm tốc V1. bạn chú ý chân +, -. Nếu bạn nối ngược
thì động cơ sẽ chạy ngược.

 1 động cơ bước giảm tốc V1 ( màu vàng ) có sẵn trên kit.
 1 module L298 như hình trên.
Lắp mạch.
248
Lập trình:
#define ENA 8 //enable A on pin 8
#define ENB 3 //enable B on pin 3
#define IN1 7 //IN1 on pin 7
void setup()
{
pinMode(ENA, OUTPUT);
pinMode(ENB, OUTPUT);
}
void loop()
{
motorA(1, 25); //cho motor A chạy 25% tốc độ CHẠY THUẬN
delay(5000); //chạy 25% trong 5 s
motorA(3, 100); //thắng động cơ A
motorB(1, 25); //cho motor B chạy 25% tốc độ.
249
delay(5000); //chạy 25% trong 5 s

motorA(2, 25); // cho motor A chạy 25% tốc độ CHẠY NGHỊCH
delay(5000); //let motor A and motor B run for 5 seconds
motorB(3, 50); //thắng động cơ B
motorA(0, 100); //dừng động cơ A
delay(5000); //đợi 5 s
}
//**************** Motor A control *****************
void motorA(int mode, int percent)
{
……………………………………………………………………………………
case 2:
analogWrite(ENB, duty);
break;
case 3:
analogWrite(ENB, duty);
break;
}
}
250
31. Lập trình module Wifi ESP8266 V1 bằng Uno R3:

Giới thiệu về module Wifi ESP8266 V1:
ESP8266 là một chip tích hợp cao - System on Chip (SoC), có khả năng xử lý
và lưu trữ tốt, cung cấp khả năng vượt trội để trang bị thêm tính năng wifi cho các
hệ thống khác hoặc đóng vai trò như một giải pháp độc lập.
Module wifi ESP8266 v1 cung cấp khả năng kết nối mạng wifi đầy đủ và khép
kín, bạn có thể sử dụng nó để tạo một web server đơn giản hoặc sử dụng như một
access point.
 Wifi 802.11 b/g/n

 Wifi 2.4 GHz, hỗ trợ WPA/WPA2
 Chuẩn điện áp hoạt động 3.3V
 Chuẩn giao tiếp nối tiếp UART với tốc độ Baud lên đến 115200
 Có 3 chế độ hoạt động: Client, Access Point, Both Client and Access Point
 Hỗ trợ các chuẩn bảo mật như: OPEN, WEP, WPA_PSK, WPA2_PSK,
WPA_WPA2_PSK
 Hỗ trợ cả 2 giao tiếp TCP và UDP
 Tích hợp công suất thấp 32-bit CPU có thể được sử dụng như là bộ vi xử lý
ứng dụng
 SDIO 1.1 / 2.0, SPI, UART
251
 URXD(RX) — dùng để nhận tín hiệu trong giao tiếp UART với vi điều
khiển
 VCC — đầu vào 3.3V
 GPIO 0 — kéo xuống thấp cho chế độ upload bootloader
 RST — chân reset cứng của module, kéo xuống mass để reset
 GPIO 2 — thường được dùng như một cổng TX trong giao tiếp UART để
debug lỗi
 CH_PD — kích hoạt chip, sử dụng cho Flash Boot và updating lại module,
nối với mức cao
 GND — nối với mass
 UTXD (TX) — dùng để truyền tín hiệu trong giao tiếp UART với vi điều
khiển

 1 Module wifi 8266V1.
Lắp mạch:
252
Lập trình :
Arduino Uno gửi lệnh điều khiển (tập lệnh AT) cho ESP8266 cũng bằng giao tiếp
UART. Tuy nhiên board Arduino chỉ có 1 chân RX và 1 chân TX cho phép thực
hiện giao tiếp UART. Điều đó dẫn đến 2 sự lựa chọn:
a. Sử dụng chân RX và TX có sẵn trên Arduino để nạp code sau khi nạp code
xong thì mới kết nối 2 chân đó với ESP8266. Với phương pháp này bạn phải
thêm một khoảng thời gian delay ở hàm setup() để đảm bảo là sau khi kết
nối ESP8266 với Arduino, thì ESP8266 vẫn nhận được đầy đủ các tập lệnh
AT từ Arduino. Tuy nhiên, bạn không thể debug qua cổng Serial do cổng
này đang đóng vai trò kết nối với ESP8266.
b. Sử dụng SoftwareSerial để giả lập thêm 1 cổng Serial nữa để gửi tập lệnh
AT cho ESP8266. Thư viện SoftwareSerial đã được trang bị sẵn trong
Arduino IDE nên bạn không cần phải tải thêm. Với cách này thì bạn có thể
debug thông qua Serial tuy nhiên code sẽ phức tạp hơn.
Ở ví dụ dưới đây tôi chọn phương án thứ nhất và chọn thời gian delay là 5s để kết
nối chân TX và RX của Arduino với chân RX và TX của ESP8266 ngay sau khi
nạp code thành công.
* Lưu ý : TRONG QUÁ TRÌNH NẠP CODE CÁC BẠN NÊN RÚT DÂY TX VÀ RX RA
KHỎI ARDUINO, KHI NẠP CODE XONG TA HÃY CẮM LẠI
// Code chương trình bật tắt led chân số 13 của Arduino.
#define LED_PIN 13
#define CMD_SEND_BEGIN "AT+CIPSEND=0"
#define CMD_SEND_END "AT+CIPCLOSE=0"
#define TDHshop_PROTOCOL_HTTP 80
#define TDHshop_PROTOCOL_HTTPS 443
#define TDHshop_PROTOCOL_FTP 21
#define TDHshop_PROTOCOL_CURRENT TDHshop_PROTOCOL_HTTP
#define TDHshop_CHAR_CR 0x0D
#define TDHshop_CHAR_LF 0x0A
253
#define TDHshop_STRING_EMPTY ""

#define TDHshop_DELAY_SEED 1000
#define TDHshop_DELAY_1X (1*TDHshop_DELAY_SEED)
bool hasRequest = false;
void setup()
{
delay(TDHshop_DELAY_0X);
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
initESP8266();
}
void loop()
{
while(Serial.available())
{
……………………………………………………………………………..
void deliverMessage(const String& msg, int dt)

{
Serial.println(msg);
delay(dt);
254

Sau khi nạp code xong ta nối lại dây TX và RX và mở cổng Serial Monitor để
xem arduino gửi lệnh lên ESP8266 như sau:
Tiếp đến trên máy tính hay điện thoại ta kết nối với Wifi có
tên TDHshop.com.vn và nhập pass cho nó "123456789" . Tiếp theo mở trình duyệt
Web lên và gõ địa chỉ mặc định của ESP8266 là : 192.168.4.1 hiển thị như sau:
255
32. Giao tiếp giữa 2 board Arduino với nhau.
Giới thiệu:
Trong bài này tôi sẽ hướng dẫn bạn cách giao tiếp giữa 2 mạch Arduino bất kỳ.
Trong nhiều dự án phức tạp thì 1 Arduino thì không thể thực hiện được, Vì vậy
giao tiếp giữa 2 arduino với nhau giúp chúng ta gải quyết được vấn đề trên.
Thư viện hổ trợ việc giao tiếp giữa 2 Arduino:

Chúng ta sẽ sử dụng thư viện Serial Command để xây dựng các "câu lệnh".
Các bạn tải thư viện TẠI ĐÂY thư viện thứ 13.
Cách add thư viện các bạn có thểm xem TẠI ĐÂY.
 Mạch Arduino (ở đây mình sử dụng Arduino UNO) (Truyền dữ liệu).

 Mạch Arduino hoặc Nano,… (ở đây mình sử dụng Arduino UNO) (Nhận dữ
liệu).
 1 led đơn.
 1 trở 220Ohm.
Lắp mạch:
256
Lập trình:
Chương trình ( code) upload cho Arduino Truyền lệnh:
void setup() {
Serial.begin(9600); // Bạn khởi tạo một cổng Serial tại baudrate 9600.
}
int Step = 0;
void loop() {
if (Step == 0) {
Serial.println("LED_RED 1"); // Đèn đỏ sáng. 1 == HIGH
} else if (Step == 1) {
Serial.println("LED_RED 0"); // Đèn đỏ tắt . 0 == LOW
}
Step = (Step + 1) % 2; //Step sẽ tuần tự tuần hoàn các giá trị trong khoảng từ 0 --
>1
delay(500); // Dừng 1/2 giây giữa các lần gửi
}
Chương trình ( code) upload cho Arduino nhận lệnh:
#include <SoftwareSerial.h>
#include <SerialCommand.h> // Khai báo biến sử dụng thư viện Serial Command
SerialCommand sCmd;
int red = 8;
void setup() {
Serial.begin(9600); / /Khởi tạo Serial ở baudrate 9600 .
pinMode(red,OUTPUT);
// Một số hàm trong thư viện Serial Command
sCmd.addCommand("LED_RED", led_red); // Khi có câu lệnh tên là
LED_RED sẽ chạy hàm led_red
}
void loop() {
sCmd.readSerial();
//Bạn không cần phải thêm bất kỳ dòng code nào trong hàm loop này cả
257
// hàm led_red sẽ được thực thi khi gửi hàm LED_RED

void led_red() {
//Đoạn code này dùng để đọc TỪNG tham số. Các tham số mặc định có kiểu dữ
liệu là "chuỗi"
char *arg;
arg = sCmd.next();
int value = atoi(arg); // Chuyển chuỗi thành số

digitalWrite(red,value);
}
33. Điều khiển LED RGB ( LED 3 màu).
Giới thiệu:
Trong bài này, chúng ta sẽ tìm hiểu cách sử dụng LED RGB (Red Green Blue –
Đỏ, Xanh Lá, Xanh Dương). Bạn có thể sử dụng hàm analogWrite của Arduino để
điều khiển màu sắc của LED.
LED RGB (Đỏ, Xanh lá, Xanh dương) trông giống như đèn LED thông thường,
tuy nhiên, cấu tạo bên trong của LED này thực sự gồm 3 đèn LED, một đỏ, một
xanh lá và một xanh dương. Bằng cách điều khiển độ sáng của mỗi LED riêng biệt
mà bạn có thể tạo ra màu sắc bất kì mà bạn muốn.
258
Để thay màu sắc của LED RGB, ta chỉ việc thay đổi độ sáng của từng con diode
(led) trong con led rgb. Để thay đổi độ sáng của một con LED ta chỉ việc điều
chỉnh điện áp xuất ra con LED, mà để điều chỉnh điện áp xuất ra con LED ta sẽ
dùng xung PWM.
Lắp mạch:
Lập trình:
const int RED_PIN = 9; // led đỏ

const int GREEN_PIN = 10; // led xanh lá
const int BLUE_PIN = 11; // led xanh dương
int DELAY_TIME = 500; // đơn vị là mili giây
void setup()
{
pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
}
void loop()
{
259
maucoban(); // Gọi hàm maucoban

}
void maucoban()
{
// Tắt toàn bộ các led
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);
delay(DELAY_TIME);
// Chỉ bật led đỏ
………………………………………
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);
delay(DELAY_TIME);
}
260
34. Hiển thị giá trị điện áp khi điều chỉnh biến trở.
Giới thiệu:
Bài ví dụ này sẽ giới thiệu cho các bạn cách đọc giá trị điện áp gây ra bởi một biến
trở. Biến trở chỉ đơn giản chỉ là một điện trở có thể thay đổi được trị số. Mạch
Arduino không đọc trực tiếp điện trở này mà đọc gián tiếp qua điện áp mà biến trở
gây ra.
Cấu tạo của biến trở:
Phần màu vàng là một lớp điện trở. Cây kim màu xanh được đè chặt xuống phần
điện trở này. Giả sử có dòng điện đi từ 1 đến 2 thì nó sẽ phải qua phần màu vàng
(được tô đỏ) và đó chính là điện trở hiện tại của biến trở. Bạn chỉ việc vặn cây kim
để tăng giảm độ dài của vùng màu đỏ, qua đó tăng giảm giá trị điện trở.
261

 Breadboard.
 Dây cắm test breadboard.
 1 biến trở 10K .
Lắp mạch:
262
Lập trình:
void setup() {
Serial.begin(9600); //Mở cổng Serial để giap tiếp | tham khảo //Serial
}
void loop() {
int voltage;
voltage = map(value,0,1023,0,5000); //chuyển thang đo của value
//từ 0-1023 sang 0-5000 (mV)
Serial.println(voltage); //xuất ra điện áp (đơn vị là mV)
Serial.println(); //xuống hàng
delay(200); //đợi 0.2 giây
}
35. Đọc giá trị cảm biến báo cháy hiển thị serial monitor.
Giới thiệu:
Đây là loại cảm biến chuyên dùng để phát hiện lửa , thường được sử dụng trong hệ
thông báo cháy. Tầm phát hiện trong khoảng 80cm, góc quét là 60 độ. Có thể phát
hiện lửa tốt nhất là loại có bước sóng từ 760nm - 1100nm. Mạch được tích hợp IC
LM393 so sánh để tạo mức tín hiệu => ta có thể chỉnh độ nhạy bằng biến trở.
Thông số kĩ thuật:
 Nguồn : 3.3V - 5V, 15mA
 Điên áp ra : 3.3 - 5V, đầu ra có cả analog và Digital.
 Khoảng cách : 80 cm
 Góc quét : 60 độ
 Kích thước : 3.2 x 1.4 cm
263

 Breadboard.
 1 cảm biến báo cháy (CB lửa) .
Lắp mạch:
264
Lập trình:
//Cách nối dây: chân G nối GND, chân V+ nối nguồn 5V

//Chân AO (Analog Output-tín hiệu ra Analog) nối chân A1
//Chân DO (Digital Output - tín hiệu ra on/off) nối chân 4
#define ChanAO 1//Chân A1 là chân để đọc tính hiệu Analog AO
#define ChanDO 4//Chân 4 (bên digital) là chân để đọc tín hiệu Digital DO
#define baochay 12//Chân để điều khiển đèn led báo cháy
float giatriAO;//Biến chứa giá trị Analog AO
float giatriDO;//Biến chứa giá trị Digital DO
void setup()
{
Serial.begin(9600);
pinMode(ChanDO, INPUT); //Định nghĩa chanDO (chân 4) là chân đọc tính hiệu
vào
pinMode(baochay,OUTPUT); //Định nghĩa chân báo cháy (chân 12) là chân xuất
tín hiệu ra cho đèn led
}
void loop()
{
……………………………………………………………….
Serial.print(" Gia tri chan Digital: ");//In giá trị digital ra màn hình
Serial.println(giatriDO);
if(giatriAO<900)//Điều kiện để phát tín hiệu cháy (do người dùng tự đặt)
{
Serial.println("Dang chay");//Báo cháy
digitalWrite(baochay,HIGH);//Bật đèn sáng
}
else//Ngược lại
{
digitalWrite(baochay,LOW);//Tắt đèn
}
delay(1000);//Cập nhật giá trị sau 1s
}
265
36. Đọc giá trị CB màu (TCS3200) hiển thị serial monitor.
Giới thiệu:
Module cảm biến màu TCS3200 là một module cảm biến phát hiện đầy đủ màu
sắc, bao gồm cả cảm biến màu TCS3200 với khả năng nhận biết 3 màu cơ bản
RGB và 4 đèn LED trắng. Các TCS3200 có thể phát hiện và đo lường gần như tất
cả màu sắc có thể nhìn thấy. Ứng dụng bao gồm kiểm tra đọc dải, phân loại theo
màu sắc, cảm biến ánh sáng xung quanh và hiệu chuẩn, và kết hợp màu sắc, đó chỉ
là một vài ứng dụng.
TCS3200 có các bộ tách sóng quang, có 2 bộ lọc màu sắc là bộ lọc màu đỏ,
xanh, hoặc màu xanh, hoặc không có bộ lọc ( rõ
ràng). Các bộ lọc của mỗi màu được phân bố đều khắp các mảng để loại bỏ sai lệch
vị trí giữa các điểm màu. Bên trong là một bộ dao động tạo ra đầu ra sóng vuông
có tần số là tỷ lệ thuận với cường độ của màu sắc lựa chọn.
 Điện áp cung cấp: (2.7V đến 5.5V)
 Chuyển đổi từ cường độ ánh sáng sang tần số với độ phân giải cao.
 Có khả năng lập trình để nhận biết đầy đủ các màu sắc.
 Điện năng tiêu thụ thấp.
 Giao tiếp trực tiếp với vi điều khiển.
 S0 ~ S1: Dùng để lựa chọn tỉ lệ tần số đầu ra
 S2 ~ S3: Dùng để lựa chọn kiểu photodiode
 OUT Pin: Đầu ra tần số.
 OE Pin: Tần số đầu ra cho phép hoạt động (hoạt động ở mức thấp).
266
 Hỗ trợ đèn LED bổ sung và kiểm soát ánh sáng.

 Breadboard.
 1 cảm biến MÀU (TCS3200) .
Nguyên tắc nhận biết màu:

TCS3200 có bộ lọc màu, khi lựa chọn một bộ lọc màu nó sẽ cho phép chỉ nhận
biết 1 màu và các màu khác sẽ bị chặn. Ví dụ, khi lựa chọn các bộ lọc màu đỏ, Chỉ
có ánh sáng tới màu đỏ có thể được thông qua, màu xanh và màu xanh lá cây sẽ
được ngăn chặn. Vì vậy chúng ta có thể nhận được cường độ ánh sáng màu đỏ.
Tương tự như vậy, khi lựa chọn các bộ lọc khác mà chúng ta có thể nhận được ánh
sáng màu xanh hoặc màu xanh lá cây.
Cách thiết lập màu sắc cho TCS3200:
Tần số đầu ra của TCS3200 trong khoảng 2HZ~500KHZ. Tần số đầu ra có dạng
xung vuông với tần số khác nhau khi mà màu sắc khác nhau và cường độ sáng là
khác nhau. Chúng ta có thể lựa chọn tỉ lệ giữa cừng độ sáng và màu sắc theo bảng
sau. Trên module này cũng có chân LED EN đây là chân điều khiển đèn LED để
tắt hoặc bật.
267
Cách thiết lập tần số cho TCS3200:
Lắp mạch:
Lập trình:
#define S0 4
#define S1 5
#define S2 6
#define S3 7
#define sensorOut 8
int frequency = 0;
void setup() {
pinMode(S0, OUTPUT);
268
pinMode(sensorOut, INPUT);
// thiet lap tan so 20%

digitalWrite(S0,HIGH);
digitalWrite(S1,LOW);
Serial.begin(9600);
}
void loop() {
frequency = pulseIn(sensorOut, LOW);
…………………………………………………
digitalWrite(S3,HIGH);
frequency = pulseIn(sensorOut, LOW);
Serial.print("B= ");
Serial.print(frequency);
Serial.println(" ");
delay(100);
}
37. Đọc giá trị CB chuyển động PIR hiển thị serial monitor.
Giới thiệu:
PIR là chữ viết tắt của Passive InfraRed sensor (PIR sensor), tức là bộ cảm
biến thụ động dùng nguồn kích thích là tia hồng ngoại. Tia hồng ngoại (IR) chính
là các tia nhiệt phát ra từ các vật thể nóng. Trong các cơ thể sống, trong chúng ta
luôn có thân nhiệt (thông thường là ở 37 độ C), và từ cơ thể chúng ta sẽ luôn phát
ra các tia nhiệt, hay còn gọi là các tia hồng ngoại, người ta sẽ dùng một tế bào điện
để chuyển đổi tia nhiệt ra dạng tín hiệu điện và nhờ đó mà có thể làm ra cảm biến
phát hiện các vật thể nóng đang chuyển động.
269
Cảm biến này gọi là thụ động vì nó không dùng nguồn nhiệt tự phát (làm nguồn
tích cực, hay chủ động) mà chỉ phụ thuộc vào các nguồn tha nhiệt, đó là thân nhiệt
của các thực thể khác, như con người, con vật…
Trên đây là đầu dò PIR, loại bên trong gắn 2 cảm biến tia nhiệt, nó có 3 chân ra,
một chân nối masse, một chân nối với nguồn volt DC, mức áp làm việc có thể từ 3
đến 15V. Góc dò lớn. Để tăng độ nhậy cho đầu dò, Bạn dùng kính Fresnel, nó
được thiết kế cho loại đầu có 2 cảm biến, góc dò lớn, có tác dụng ngăn tia tử ngoại.
Nguyên lý làm việc của loại đầu dò PIR như hình sau:
Các nguồn nhiệt (với người và con vật là nguồn thân nhiệt) đều phát ra tia hồng
ngoại, qua kính Fresnel, qua kích lọc lấy tia hồng ngoại, nó được cho tiêu tụ trên 2
cảm biến hồng ngoại gắn trong đầu dò, và tạo ra điện áp được khuếch đại với
transistor FET. Khi có một vật nóng đi ngang qua, từ 2 cảm biến này sẽ cho xuất
hiện 2 tín hiệu và tín hiệu này sẽ được khuếch đại để có biên độ đủ cao và đưa vào
mạch so áp để tác động vào một thiết bị điều khiển hay báo động.
270
 GND – kết nối với mặt đất

 OUT – kết nối đến một chân digital của Arduino
 5V – kết nối với 5V
 Breadboard.
 1 cảm biến chuyển động PIR .
 1 Loa hoặc 1 LED đơn.
271
Lắp mạch:
Lập trình:
int ledPin = 10; // chọn chân 10 báo hiệu LED

int inputPin = 2; // chọn ngõ tín hiệu vào cho PIR
int val = 0;
void setup()
{
272
pinMode(inputPin, INPUT);
Serial.begin(9600);
}
void loop()
{
val = digitalRead(inputPin); // đọc giá trị đầu vào.
Serial.print(frequency);
Serial.println(" ");
delay(100);
if (val == HIGH) // nếu giá trị ở mức cao.(1)
{
digitalWrite(ledPin, HIGH); // LED On
}
else
{
}
}
38. Đọc giá trị CB khí gas (MQ2) hiển thị serial monitor.
Giới thiệu:
Cảm biến khí ga MQ2 là một trong những loại cảm biến được sử dụng để nhận
biết: LPG, i-butan, Propane, Methane , Alcohol, Hydrogen, Smoke và khí ga. Được
thiết kế với độ nhạy cao, thời gian đáp ứng nhanh. Gía trị đọc được từ cảm biến sẽ
được đọc về từ chân Analog của vi điều khiển.
273
 Nguồn hoạt động: 5VDC
 Dòng: 150mA
 Tính hiệu tương tự (analog)
 Hoạt động trong thời gian dài, ổn định
 Breadboard.
 1 cảm biến khí gas MQ2 .
Lắp mạch:
Arduino MQ2
A0 Aout
VCC 5V
GND GND
Lập trình:
274
void setup() {
Serial.begin(9600); //Mở cổng Serial để giap tiếp | tham khảo Serial
}
void loop() {
int value = analogRead(A0); //đọc giá trị điện áp ở chân A0 - chân cảm biến
//-----------------------------------------------------
delay(1000); //đợi 1 giây để bạn kịp tháy serial - (optional)
}
Để test, bạn có thể dùng hộp quẹt,... và xì hơi ga vào tấm lưới của nó.
39. Điều khiển thiết bị bằng BLUETOOTH ( HC05 hoặc

HC06) ( chỉ áp dụng cho Điện thoại android).
Giới thiệu:
Kết nối Arduino với các thiết bị, module điện tử khác là 1 việc tương đối dễ
dàng, hôm nay tôi sẽ giới thiệu với các bạn cách kết nối Arduino với module
Bluetooth và điều khiển nó thông qua điện thoại Android. Các bạn có thể ứng dụng
để điều khiển các thiết bị điện trong nhà như bật tắt đèn, quạt,…
Module này gồm 4 chân GND, VCC, TX, RX Khi kết nối bạn chỉ cần nối chân
TX với chân 0 và chân RX nối với chân 1 trên Arduino sau đó bạn có thể lập trình
gửi và nhận dữ liệu như 1 cổng Serial thông thường. Module này có 3 loại
275
Master, Slave và loại chạy được cả 2 chế độ Master và Slave, ở ví dụ này tôi sử
dụng loại Slave, khi kết nối với điện thoại bạn điền mật khẩu mặc định là: 1234

 Breadboard.
 1 module Bluetooth HC05 Hoặc HC06 loại slave.
Lắp mạch:
Arduino HC06
Tx Rx
Rx Tx
GND GND
5V VCC
276
Lập trình cho Arduino:

int LED1 = 5;
int LED2 = 6;
int LED3 = 7;
int chucai = 'g';
void setup() {
Serial.begin(9600);
pinMode(LED1, OUTPUT);
}
void loop() {
if(Serial.available()>0){
chucai = Serial.read();
}
if(chucai =='a'){ // bật led 1
Serial.println(chucai);
digitalWrite(LED1, HIGH);
}
if(chucai=='b'){ // tắt led 1
Serial.println(chucai);
digitalWrite(LED1, LOW);
}
………………………………………
}
}
277
Viết app điều khiển thiết bị điện bằng Bluetooth trên điện thoại Andriod:
Trong bài viết này tôi xin giới thiệu cách viết app cho điện thoại Andriod bằng
appinventor. Giao diện rất đơn giản và dễ sử dụng.
Giao diện của Appinventor: (app cho điện thoại được lưu trong file code)
278
279
40. Sử dụng IC Max7219 để điều khiển led ma trận 8x8.
Giới thiệu:
Với việc sử dụng IC Max7219 việc điều khiển led ma trận 8x8 trở nên dễ dàng hơn
và được hổ trợ bởi những thư viện có sẵn. Ta có thể ghép nối nhiều module led 8x8
này lại với nhau.
280
 Module có thể điều khiển 8x8 điểm led chân cathode chung.
 Điện áp hoạt động: 5V
 Bên trái của module là chân ngõ vào và bên phải là chân ngõ ra.
 1 module led 8x8 sử dụng IC MAX7219.
Lắp mạch:
Arduino Module led 8x8

10 CS
11 DIN
13 CLK
5V VCC
GND GND
Lập trình:
#include <SPI.h>
#include <Adafruit_GFX.h>
281
#include <Max72xxPanel.h>
int pinCS = 10;
//ARDUINO ket noi voi MAX_MATRIX7219

//CS ----- PIN10
//DIN ----- PIN11
//CLK ----- PIN13
int numberOfHorizontalDisplays = 1; //số trong Hiển thị theo chiều ngang

int numberOfVerticalDisplays = 4; // Số trong hiển thị theo chiều dọc.
…………………………………………………
String tape = "NHOM HOC LAP TRINH ARDUINO"; // ký tự muốn truyền lên
matrix
int wait = 100; // thời gian chạy chữ.
int spacer = 1; // khoảng cách cách chữ

int width = 5 + spacer; // độ rộng của font là 5 fixel
void setup() {
matrix.setIntensity(10); // cài đặt giá trị độ tương phản từ 0 đến 15.

matrix.setRotation(3);
}
void loop() {
for ( int i = 0 ; i < width * tape.length() + matrix.width() - 1 - spacer; i++

)
{
matrix.fillScreen(LOW);
delay(wait);
}
}
282
41. Đo Tốc Độ Động Cơ Bằng Cảm Biến IR FC03.
Giới thiệu:
Bài viết hướng dẫn cách sử dụng cảm biến đo tốc độ IR FC-03 kết hợp với vòng
xoay encoder 15 lỗ, để xác định tốc độ của động cơ DC. Khi có tốc độ, ta có thể
thực hiện điều chỉnh tốc độ của động cơ để cho xe chạy thẳng, thông qua mạch
L298.
 1 x Arduino Uno R3.

 1 x Cảm biến tốc độ IR FC-03.
 1 x Đĩa encoder 15 lỗ.
 1 x động cơ.
CB tốc độ IR FC03:
283
 1 x Bộ thu phát ITR9608: Chân số 2 có chứa diode phát tia hồng ngoại, chân
số 1 chứa 1 phototransistor để thu nhận tín hiệu hồng ngoại.
 1 x IC LM393.
 VCC: cảm biến chịu được mức điện áp từ 3.3 - 5V. Chân này được nối với
pin nguồn 5V của Arduino.
 GND: nối với pin nguồn GND của arduino.
 DO: chân cho tín hiệu số đi ra của cảm biến (High / Low).
 AO: chân cho tín hiệu tương tự đi ra từ cảm biến. Chân này tôi không sử
dụng.
Nguyên lý hoạt động:
Khi motor quay thì đĩa encoder quay, lúc này, giá trị ở chân DO của FC-03 chuyển
đổi liên tục từ LOW sang HIGH và từ HIGH sang LOW. Nguyên nhân là do khi
FC-03 được cấp điện, diode ở chân số 2 của ITR9608 phát ra tia hồng ngoại, nếu
tia hồng ngoại được truyền thông qua lỗ của đĩa encoder, phototransistor nhận
được tín hiệu và chuyển output của chân DO lên mức HIGH. Ngược lại, khi tia
hồng ngoại bị cản bởi đĩa encoder, phototransistor không nhận được tín hiệu, chân
DO được chuyển về mức LOW.
Dựa vào nguyên lý ngày, để lấy được số vòng quay của động cơ trong một khoảng
thời gian, ta chỉ cần đếm số lỗ mà FC-03 bắt được trong khoảng thời gian đó. Tức
là ta sẽ đếm số lần mà pin 2 của Arduino chuyển từ HIGH sang LOW.
284
Lắp mạch:
Arduino Module IR FC03

5VDC VCC
GND GND
2 D0
Lập trình:
#define PIN_DO 2
volatile unsigned int pulses;
float rpm;
unsigned long timeOld;
#define HOLES_DISC 15 // số lổ trên đĩa encoder
void counter()
{
pulses++;
}
void setup()
{
Serial.begin(9600);
pinMode(PIN_DO, INPUT);
attachInterrupt(digitalPinToInterrupt(PIN_DO), counter, FALLING);// khởi động
interrupt
}
void loop()
{
if (millis() - timeOld >= 1000)
{
detachInterrupt(digitalPinToInterrupt(PIN_DO)); // ngưng interrupt để thực
hiện tính toán
rpm = (pulses * 60) / (HOLES_DISC);
Serial.println(rpm);
timeOld = millis();
pulses = 0;
attachInterrupt(digitalPinToInterrupt(PIN_DO), counter, FALLING); //
}
}
285
42. Điều khiển RGB LED sử dụng Module Bluetooth HC05 .
Giới thiệu:
 Mạch Arduino Uno, Nano,…

 Breadboard .
 1 led 3 màu dương chung ( anode).
 3 điện trở 220Ohm.
Lắp mạch:
Arduino RGB LED Bluetooth HC05

5VDC VCC VCC
GND GND GND
2 D0
Tx Rx
Rx Tx
286
Lập trình cho arduino:

#define max_char 12
char message[max_char];
char r_char;
byte index = 0;
int i;
int redPin = 11; // Red RGB pin -> D11

int greenPin = 10; // Green RGB pin -> D10
int bluePin = 9; // Blue RGB pin -> D9
int redValue = 255;

int greenValue = 255;
int blueValue = 255;
void setup() {
pinMode(redPin,OUTPUT);
pinMode(bluePin,OUTPUT);
pinMode(greenPin, OUTPUT);
Serial.begin(9600);
}
287
void loop() {
//while is reading the message
while(Serial.available() > 0){
flag = 0;
if(index < (max_char-1)){
r_char = Serial.read();
message[index] = r_char;
………………………………
for(i=0; i<12; i++){
message[i] = '\0';
}
index=0;
}
}
Lập trình app cho điện thoại Android:
File app được lưu trong file code kèm theo.
Lưu ý khi dùng điện thoại android kết nối với HC05 với mật khẩu 1234
288
43. Làm game với led ma trận 8x8 Max7219 .

 Breadboard .
 1 led ma trận 8x8 max7219.
 1 biến trở 1K.
Lắp mạch:
Biến trở các bạn nối như hình dưới.
Arduino Module led 8x8 Biến trở

10 CS
12 DIN
11 CLK
5V VCC 1
GND GND 3
A0 2(chân giữa)
289
Led ma trận có 8 cột và 8 hàng.
Nếu bạn muốn hiển thị một cái gì đó trong ma trận, bạn chỉ cần biết nếu trong một
hàng hoặc cột xác định, các đèn LED đang bật hoặc tắt.
Ví dụ hiển thị một khuôn mặt
290
Lập trình:
bên dưới chỉ dưới dạng giải thích. Trước hết ta phải cài thêm thư viên LedControl
và Timer có kèm theo.
#include "LedControl.h" // thư viện ledcontrol cần cài cho ide

#include "Timer.h" // thư viện Timer cần cài cho ide
#define POTPIN A0 // chân số 2( chân giữa) biến trở nối với A0 của ardunio
byte sad[] = {
B00000000,
B01000100,
B00010000,
B00010000,
B00000000,
B00111000,
B01000100,
B00000000
};
lc.setRow(0, yball, byte(1 << (xball)));
byte padmap = byte(0xFF >> (8 - PADSIZE) << xpad) ;
#ifdef DEBUG
#endif
lc.setRow(0, 7, padmap);
}
void setup() {
pinMode(POTPIN, INPUT);
…………………………………………………….
lc.clearDisplay(0);
randomSeed(analogRead(0));
#ifdef DEBUG
Serial.begin(9600);
Serial.println("Pong");
#endif
newGame();
ball_timer = timer.every(BALL_DELAY, moveBall);
}
void loop() {
291
timer.update();
setPad();
debug("LOOSE");
gameOver();
newGame();
}
delay(GAME_DELAY);
}
292
44. Lập trình với keypad 4x4 .
Giới thiệu:
Hình trên là sơ đồ nguyên lý của module bàn phím 4x4. Tuy có đến 16 nút nhấn,
nghĩa là nếu làm một cách thông thường (dùng chân digital) thì chúng ta phải cần
đến 16 chân Arduino để đọc. Nhưng với bàn phím này, chúng ta chỉ cần dùng 8
chân (4 chân hàng ngang (row), và 4 chân cột dọc (column)).
293
Lắp mạch:
Arduino Module keypad 4x4

5 R1
6 R2
7 R3
8 R4
9 C1
10 C2
11 C3
12 C4
Lập trình:
bên dưới chỉ dưới dạng giải thích. Trước hết ta cần phải cài thêm thư viện Keypad
có kèm theo.
#include Keypad.h
const byte rows = 4; //số hàng
const byte columns = 4; //số cột
int holdDelay = 700; //Thời gian trễ để xem là nhấn 1 nút nhằm tránh nhiễu
int n = 3; //
int state = 0; //nếu state =0 ko nhấn,state =1 nhấn thời gian nhỏ , state = 2 nhấn
giữ lâu
char key = 0;
char keys[rows][columns] =
{
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'},
};
byte rowPins[rows] = {5, 6, 7, 8}; //Cách nối chân với Arduino

byte columnPins[columns] = {9, 10, 11, 12};
//cài đặt thư viện keypad
294
Keypad keypad = Keypad(makeKeymap(keys), rowPins, columnPins, rows,

columns);
void setup() {
Serial.begin(9600);//bật serial, baudrate 9600
……………………………………………………………
}
if ((int)keypad.getState() == RELEASED) {
key += state;
state = 0;
//Xuat ket qua len may tinh
Serial.println(key);
}
delay(100);
}
295
45. Điều khiển thiết bị bằng module enthernet shiled .
Giới thiệu về enthernet shiled:

Ethernet shield là một module mở rộng cho arduino, giúp arduino có thể kết nối với
internet. Ứng dụng của shield này là truyền nhận thông tin giữa arduino với thiết bị bên
ngoài sử dụng internet, shield này đặc biệt hữu ích cho các ứng dụng IoT, điều khiển và
kiểm soát hệ thống vì internet luôn liên tục, dữ liệu truyền đi nhanh. Hôm nay tôi sẽ
hướng dẫn mọi người cách sử dụng nó để điều khiển thiết bị bằng đường truyền internet .

 1 module enthernet shiled. ( phải có cáp mạng LAN RJ45 nối từ Router wifi
đến module enthernet shiled ).
296
 Breadboard .
 1 điện trở 220 Ohm.
 1 led siêu sáng ( từ đó ta có thể chuyển qua bật tắt relay).
Lắp mạch:
Chụp shield ethernet lên uno hoặc mega như hình:
Ta điều khiển bật tắt đèn led ở chân số D2.
Lập trình:
bên dưới chỉ dưới dạng giải thích, thư viện Ethernet đã có sẵn trong ide.
297
#include<SPI.h> // thư viện để kết nối shield

#include<Ethernet.h> // thư viện cho dự án
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; // địa chỉ MAC( địa chỉ
phần cứng của shield ethernet), cứ để nguyên
IPAddress ip(192, 168, 1, 8); // địa chỉ IP của shield, có thể thay đổi tùy ý.
EthernetServer server = EthernetServer(80); // giá trị port là 80

void setup() {
Serial.begin(9600);
while (!Serial) {
;
}
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
digitalWrite(2, LOW);
if (readString.indexOf("button2on") > 0) {
digitalWrite(3, HIGH);
}
if (readString.indexOf("button3off") > 0) {
digitalWrite(2 , LOW);
}
readString = "";
}
}
Sau khi lắp mạch như hình trên và ta nạp code bên dưới và nhập địa chỉ ip ta sẽ
thấy giao diện điều khiển hiện ra.
298
46. Đọc giá trị cảm biến áp suất BM180 .
Giới thiệu về BM180:

Hôm nay chúng ta cùng tìm hiểu về loại cảm biến đo áp suất BM180. Chuyên dùng
trong các dự án về môi trường và nó cũng là một trong những giao tiếp I2C quen
thuộc mà trong các bài trước có đề cập đến.
Đây là board mạch cảm biến áp suất BMP185 đơn giản, độ chính xác cao, tiết
kiệm điện năng. BMP180 có khả năng đo lường áp suất trong khoảng 300 - 1100
hPa với sai số tuyệt đối dưới 0.02 hPa trong chế độ nâng cao độ phân giải.
Cảm biến này hoạt động trong khoảng điện áp 1.8 tới 3.6V và hỗ trợ I/O 5V (Nhà
sản xuất khuyên dùng nguồn 3.3V đã lọc sạch, ổn định). Nó được thiết kế để kết
nối trực tiếp với vi điều khiển thông qua cổng giao tiếp I2C.
299

 1 module cảm biến áp suất BM180.
Lắp mạch:
Arduino Module BM180

3.3V Vin
GND GND
A4 SDA
A5 SCL
Lập trình:
300
Trước khi upload code các bạn cần cài thêm thư viện BM180 cho arduino IDE
Tại link sau:
#include <Wire.h>
#include <Adafruit_BMP085.h>
Adafruit_BMP085 bmp;
void setup() {
Serial.begin(9600);
if (!bmp.begin()) {
Serial.println("Could not find a valid BMP085 sensor");
while (1) {}
}
}
void loop() {
Serial.print("Temperature = ");
Serial.print(bmp.readTemperature());
Serial.println(" *C");
……………………………………………………..
Serial.print("Real altitude = ");
Serial.print(bmp.readAltitude(101500));
Serial.println(" meters");
Serial.println();
delay(500);
}
301

Sau khi lắp mạch và nạp chương trình cho arduino ta bật cổng serial moniter để
xem kết quả như hình dưới nhé.
302
47. Chạy chữ trên led ma trận 8x8 sử dụng Bluetooth HC05.

 1 module Bluetooth hc05.
 Dây cắm Breadboard .
 1 module led 8x8 sử dụng IC max7219.
 1 điện thoại sử dụng hệ điều hành android.
Lắp mạch:
Arduino Module LED 8x8 Bluetooth

5VDC VCC VCC
GND GND GND
5 CS
6 CLK
7 DIN
8 TX
9 RX

bên dưới chỉ dưới dạng giải thích. Ta cần phải cài thêm thư viên MaxMatrix.h
được lưu trong file code.
Lưu ý trước khi nạp chương trình cho arduino ta không kết nối dây TX, RX với
chân số 8, 9 của arduino . Sau khi đã nạp xong chúng ta hãy kết nối lại.
#include <MaxMatrix.h>
#include <SoftwareSerial.h>
#include <avr/pgmspace.h>
PROGMEM const unsigned char CH[] = {
3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
303
4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $

5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
…………………………………………………………
3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};
int dIn = 7; // DIN pin of MAX7219 module
int clk = 6; // CLK pin of MAX7219 module
int cs = 5; // CS pin of MAX7219 module
int maxInUse = 1; // số module MAX7219's kết nối
MaxMatrix m(dIn, cs, clk, maxInUse);
SoftwareSerial Bluetooth(8, 9); // BluetoothTx – Pin 8, RX – Pin 9
byte buffer[10];
char incomebyte;
int scrollSpeed = 100;
char text[100] = "Hello "; // test mẫu đoạn chữ Hello
int brightness = 15;
int count = 0;
char indicator;
void setup() {
m.init();
}
while (Bluetooth.available()) {
incomebyte = Bluetooth.read();
…………………………………………………….
{
if (*s < 32) continue;
char c = *s - 32;
memcpy_P(buffer, CH + 7 * c, 7);
m.writeSprite(col, 0, buffer);
m.setColumn(col + buffer[0], 0);
col += buffer[0] + 1;
304
s++;
}
}
Lập trình app Inventor cho điện thoại android.
File app được để trong file code kèm theo.
Sau khi chúng ta đã cài đặt app cho điện thoại sử dụng hệ điều hành android và tiến
hành kết nối Bluetooth của điện thoại với HC05 ( mật khẩu mặt định 1234 ).
48. Điều khiển hiệu ứng RGB LED WS2812b.

 Breadboard.
 1 dãy led WS2812b gồm 10 led.
305
Giới thiệu led WS2812B:
LED RGB WS2812B sử dụng chip WS2812B nên có thể lập trình để điều khiển
màu sắc độ sáng. Dễ dàng điều khiển, tương thích với Arduino. Với lớp phủ
Silicon bên ngoài có thể chống nước hoàn toàn, đảm bảo an toàn khi sử dụng trong
môi trường ẩm ướt. Sử dụng điện áp 5 – 12V.
Điều tuyệt vời về những LED này là chúng ta có thể kiểm soát ngay cả dải LED
chỉ với một chân từ bo mạch Arduino.
Lắp mạch:
Arduino RGB WS2812b Nguồn riêng

VCC (5 VDC)
GND GND GND
D7 Din
306

bên dưới chỉ dưới dạng giải thích. Trước hết ta cần cài thêm thư viện FastLED, có
kèm theo file.
Lưu ý: nên cấp nguồn riêng cho led.
#include <FastLED.h>
#define LED_PIN 7
#define NUM_LEDS 11
CRGB leds[NUM_LEDS];
void setup() {
FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
}
void loop() {
for (int i = 0; i <= 10; i++) {
leds[i] = CRGB ( 0, 0, 255);
FastLED.show();
delay(40);
}
for (int i = 10; i >= 0; i--) {
leds[i] = CRGB ( 255, 0, 0);
FastLED.show();
delay(40);
}
}
307
49. Mô phỏng hệ thống radar bằng cảm biến siêu âm SRF05.

 Breadboard.
 1 động cơ servo SG90.
 1 cảm biến siêu âm srf05.
Lắp mạch:
Arduino SRF05 SERVO

5VDC VCC VCC
GND GND GND
12 S
10 TRIG
11 ECHO

#include <Servo.h>
const int trigPin = 10;
const int echoPin = 11;
long duration;
int distance;
Servo myServo; // Tạo đối tượng Servo để điều khiển Servo
void setup() {
pinMode(trigPin, OUTPUT); // Set chân trig là chân OUTPUT
pinMode(echoPin, INPUT); // Set chân echo INPUT
Serial.begin(9600);
myServo.attach(12); // Chân Servo là chân 12
}
void loop() {
delay(30);
Serial.print(".");
308
}
}
// Hàm tính khoảng cách bằng siêu âm
int calculateDistance(){
digitalWrite(trigPin, LOW);
digitalWrite(trigPin, HIGH);
return distance;
}
Lập trình code cho processing:
Trước hết chúng ta cần phải cài phần mềm PROCESSING theo link sau:
https://drive.google.com/open?id=1La369RgmlIdG21q869ZbQTJJVsdD0AjB
Sau đó ta cài đặt phần mềm Processing vào máy tính.
Một phương thức điều khiển arduino bằng máy tính sử dụng ngôn ngữ Java tuy đã
xuất hiện từ lâu nhưng nó rất hữu ích cho các dự án cần về giao diện điều khiển.
Giao diện của phần mềm:
309
Code lập trình trên processing:
Code được lưu trong file code kèm theo.
Trong quá trình chạy code processing cần phải kết nối arduino với máy tính.
310
50. Lập trình điều khiển module rơ le bán dẫn SSR .
Giới thiệu rơ le bán dẫn SSR:
- Relay SSR (Solid State Relay) hay còn gọi là Relay Rắn là loại relay sử
dụng cấu trúc bán dẫn thay vì cấu trúc cơ học nên có độ bền và tuổi thọ cao.
- Module Relay rắn SSR sử dụng nguồn DC 5V để kích Relay hoạt động đóng
ngắt điện thế AC với công suất tối đa 250V 2A, module này chỉ dùng để
đóng ngắt nguồn AC, không sử dụng được để đóng ngắt nguồn DC, trong
Relay SSR có tích hợp sẵn opto cách ly (photo triac) nên sử dụng rất an
toàn.
- Module được thiết kế nhỏ gọn, ra chân đầy đủ, có led hiển thị trạng thái
đóng ngắt, Ứng dụng đóng ngắt nguồn AC cần tần suất đóng ngắt nhiều và
tuổi thọ cao. Khắc phục được những điểm còn hạn chế của role cơ.
 Số Relay: 1
 Điện áp kích: 5VDC.
 Dòng tiêu thụ: 20mA/1 Relay SSR
 Điện áp đóng ngắt tối đa: 75 to 240VAC (50/60Hz).
 Dòng điện đóng ngắt: 0.1 - 2A.
 Có cách ly: Photo Triac
 Kích thước: 25*34*25 (L * W * H)
 Trọng lượng: 13 g.
311
Lắp mạch:
Arduino Module role SSR

5VDC VCC
GND GND
6 CH1

// CHUONG TRINH DIEU KHIEN ROLE SSR BÁN DẪN

// Thuộc loại kích mức thấp
void setup() {
pinMode(6, OUTPUT);
}
void loop() {
312
digitalWrite(6, HIGH); // TAT ROLE

delay(4000); // DOI 4 GIAY
digitalWrite(6, LOW); // BAT ROLE
delay(2000); // DOI 2 GIAY
}

Arduino Tu Hoc A Den Z Cho Nguoi Moi Bat Dau

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Arduino Tu Hoc A Den Z Cho Nguoi Moi Bat Dau

Uploaded by

Copyright:

Available Formats

1

2. Hàm nhập xuất Analog I/O: ................................................................................. 45

7. Hàm số ngẫu nhiên: ............................................................................................... 69

II. GIÁ TRỊ : .................................................................................................................. 92

a. char() .................................................................................................................. 111

b. {} dấu ngoặc nhọn ............................................................................................. 127

Hình ảnh thực tế:....................................................................................................... 145

Hình ảnh thực tế:....................................................................................................... 163

Hình ảnh thực tế:....................................................................................................... 185

Hình ảnh thực tế:....................................................................................................... 198

Kết quả hiển thị lên Serial monitor : ......................................................................... 213

Giới thiệu về động cơ servo SG90:........................................................................... 234

Lắp mạch: ................................................................................................................. 251

A. GIỚI THIỆU VỀ ARDUINO

Phương pháp Truyền Thống Phương pháp dùng Arduino

II. ARDUINO LÀM ĐƯỢC NHỮNG GÌ?

Mô hình máy bay 4 cánh:

Nhà thông minh:

Hệ thống tưới cây thông minh.

Hiệu ứng LED:

III. SƠ LƯỢC VỀ ARDUINO UNO R3

1. Một số thông số kỹ thuật như sau :

Điện áp cấp nguồn 5V

Điện áp đầu vào (input) (kiến 7-12V

Điện áp đầu vào(giới hạn) 6-20V

Số chân Analog (Input ) 6

DC Current per I/O Pin 40 mA

DC Current for 3.3V Pin 50 mA

Flash Memory 32KB (ATmega328) với 0.5KB sử dụng

Xung nhịp 16 MHz

2. Sơ đồ chân của Arduino Uno.

GND: chân mass.

IV. SƠ LƯỢC BỘ KIT TỰ HỌC ARDUINO

2. Những lợi ích của Kit Tự Học Arduino:

d. Dây cắm test có nhiều kích cỡ khác nhau.

3. Mục đích của bộ KIT TỰ HỌC:

4. Một số bộ KIT TỰ HỌC ARDUINO:

V. CÀI ĐẶT PHẦN MỀM IDE VÀ DRIVER

Việc cài đặt diễn ra rất đơn giản và nhanh chóng.

b. Cài đặt Arduino IDE:

• Bước 1: Truy cập địa chỉ: http://tdhshop.com.vn/tai-phan-men-arduino-

Bước 3: Chạy file arduino.exe trong thư mục arduino-1.8.5\ để khởi

Sau khi chạy file arduino.exe ta có giao diên Arduino IDE:

2. Cài đặt Driver đối với Arduino Uno, mê ga,…:

Quá trình cài đặt đã hoàn tất. Bấm “Finish” để thoát.

b. Nạp chương trình cho Arduino Uno (mega tương tự):

Bước 1: Khởi động Arduino IDE:

Bước 2: Mở chương trình mẫu trên Arduino IDE (Blink)

3. Cài đặt Driver đối với Nano:

b. Cài đặt driver cho Arduino Nano

 Bước 2: Nhấn chọn INSTALL

 Bước 3: Hoàn tất cài đặt

c. Thông số kỹ thuật Arduino Nano:

d. Nạp chương trình cho Arduino Nano:

Bước 1: Khởi động Arduino IDE

Bước 2: Mở chương trình mẫu trên Arduino IDE (Blink)

VI. GIỚI THIỆU PHẦN MỀM ( FRITZING) HỔ TRỢ

2. Dowload phần mềm Fritzing ( miễn phí):

3. Hướng dẫn sử dụng phần mềm:

Kết nối mạch trên Breadboard:

Chuyển qua sơ đồ nguyên lý:

B. NGÔN NGỮ LẬP TRÌNH ARDUINO

+ Hàm chức năng (function).