1
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: 0395 304 802
2
MỤC LỤC
A. GIỚI THIỆU VỀ ARDUINO .................................................................................. 30
I.
ARDUINO LÀ GÌ? ................................................................................................... 32
II. ARDUINO LÀM ĐƢỢC NHỮNG GÌ? .................................................................. 33
III. SƠ LƢỢC VỀ ARDUINO UNO R3 ........................................................................ 36
1. Một số thông số kỹ thuật nhƣ sau : ...................................................................... 37
2. Sơ đồ chân của Arduino Uno................................................................................ 38
IV. SƠ LƢỢC BỘ KIT TỰ HỌC ARDUINO .............................................................. 40
1. Giới thiệu sơ lƣợc về KIT TỰ HỌC: ................................................................... 40
2. Những lợi ích của Kit Tự Học Arduino: ............................................................. 40
3. Mục đích của bộ KIT TỰ HỌC: .......................................................................... 41
4. Một số bộ KIT TỰ HỌC ARDUINO: ................................................................ 42
V. CÀI ĐẶT PHẦN MỀM IDE VÀ DRIVER ............................................................ 42
1. Cài đặt phần mềm Arduino IDE: ........................................................................ 42
a.
Cài Java Runtime Environment (JRE). ....................................................................................... 42
b.
Cài đặt Arduino IDE: .................................................................................................................. 43
2. Cài đặt Driver đối với Arduino Uno, mê ga,…: ................................................. 45
a.
Cài đặt Driver:............................................................................................................................. 45
b.
Nạp chƣơng trình cho Arduino Uno (mega tƣơng tự): ............................................................... 47
3. Cài đặt Driver đối với Nano: ................................................................................ 49
a.
Giới thiệu board arduino Nano. .................................................................................................. 49
b.
Cài đặt driver cho Arduino Nano ................................................................................................ 49
c.
Thông số kỹ thuật Arduino Nano:............................................................................................... 50
d.
Nạp chƣơng trình cho Arduino Nano:......................................................................................... 51
VI. GIỚI THIỆU PHẦN MỀM ( FRITZING) HỔ TRỢ VIỆC VẼ MẠCH NGUYÊN
LÝ 52
1. Giới thiệu phần mềm Fritzing:............................................................................. 52
2. Dowload phần mềm Fritzing ( miễn phí): ........................................................... 53
3. Hƣớng dẫn sử dụng phần mềm: .......................................................................... 54
B. NGÔN NGỮ LẬP TRÌNH ARDUINO ..................................................................... 55
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: 0395 304 802
3
I.
HÀM CHỨC NĂNG (FUNCTION): ...................................................................... 55
1. Hàm nhập xuất Digital I/O: .................................................................................. 56
a.
digitalWrite(): ............................................................................................................................. 56
b.
digitalRead(): .............................................................................................................................. 57
c.
pinMode(): .................................................................................................................................. 58
2. Hàm nhập xuất Analog I/O: ................................................................................. 60
a.
analogRead() ............................................................................................................................... 60
b.
analogReference () ...................................................................................................................... 61
c.
analogWrite() .............................................................................................................................. 63
d.
analogReadResolution (): ............................................................................................................ 64
e.
analogWriteResolution () ............................................................................................................ 66
3. Hàm nhập xuất nâng cao I/O: ........................................................................... 68
a.
noTone();..................................................................................................................................... 68
b.
pulseIn () ..................................................................................................................................... 68
c.
shiftIn(); ...................................................................................................................................... 69
d.
shiftOut(); .................................................................................................................................... 70
e.
tone(); .......................................................................................................................................... 73
4. Hàm thời gian: ....................................................................................................... 74
a.
delay() ......................................................................................................................................... 74
b.
delayMicroseconds () .................................................................................................................. 75
c.
micros() ....................................................................................................................................... 76
d.
millis(); ........................................................................................................................................ 77
5. Hàm toán học: ........................................................................................................ 79
a.
abs()............................................................................................................................................. 79
b.
constrain() ................................................................................................................................... 79
c.
map() ........................................................................................................................................... 80
d.
max() ........................................................................................................................................... 81
e.
min()............................................................................................................................................ 81
f.
sq() .............................................................................................................................................. 82
g.
sqrt() ............................................................................................................................................ 82
6. Hàm lƣợng giác: .................................................................................................... 83
a.
cos()............................................................................................................................................. 83
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: 0395 304 802
4
b.
sin() ............................................................................................................................................. 83
c.
tan() ............................................................................................................................................. 84
7. Hàm số ngẫu nhiên: ............................................................................................... 84
a.
random()...................................................................................................................................... 84
b.
randomSeed() .............................................................................................................................. 85
8. Bits và Bytes: .......................................................................................................... 87
a.
Bit() ............................................................................................................................................. 87
b.
bitClear() ..................................................................................................................................... 88
c.
bitRead() ..................................................................................................................................... 88
d.
bitWrite()..................................................................................................................................... 89
e.
bitSet()......................................................................................................................................... 90
f.
lowByte() .................................................................................................................................... 90
g.
highByte() ................................................................................................................................... 91
9. Hàm Ngắt (interrupt) ............................................................................................ 92
a.
interrupts()................................................................................................................................... 92
b.
noInterrupts() .............................................................................................................................. 93
10. Hàm Ngắt Ngoài: ................................................................................................... 94
a.
attachInterrupt() .......................................................................................................................... 94
b.
detachInterrupt() ......................................................................................................................... 96
11. Hàm Giao tiếp ........................................................................................................ 98
a.
Serial()......................................................................................................................................... 98
12. Xử lý chuỗi: ............................................................................................................ 99
a.
Hàm isAlpha() ............................................................................................................................. 99
b.
Hàm isAscii() ............................................................................................................................ 100
c.
Hàm isWhitespace() .................................................................................................................. 101
d.
Hàm isPrintable(): ..................................................................................................................... 102
e. Hàm isUpperCase(): ..................................................................................................................... 103
f. Hàm isHexadecimalDigit() .......................................................................................................... 104
g. tolower: ....................................................................................................................................... 105
h. Hàm toupper() .............................................................................................................................. 105
i. Hàm isLowerCase() ....................................................................................................................... 106
II. GIÁ TRỊ : ................................................................................................................ 107
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: 0395 304 802
5
1. Hằng số ................................................................................................................. 108
a.
Hằng số thực: ............................................................................................................................ 108
b.
Hằng số nguyên......................................................................................................................... 108
c.
HIGH......................................................................................................................................... 111
d.
LOW ......................................................................................................................................... 112
e.
INPUT:...................................................................................................................................... 113
f.
INPUT_PULLUP ...................................................................................................................... 113
g.
OUTPUT ................................................................................................................................... 114
h.
LED_BUILTIN ......................................................................................................................... 114
i.
true ............................................................................................................................................ 114
j.
false ........................................................................................................................................... 115
2. Kiểu dữ liệu: ......................................................................................................... 115
a.
void ........................................................................................................................................... 115
b.
boolean ...................................................................................................................................... 116
c.
int: ............................................................................................................................................. 117
d.
unsigned int ............................................................................................................................... 118
e.
char............................................................................................................................................ 119
f.
unsigned char ............................................................................................................................ 119
g.
byte............................................................................................................................................ 119
h.
word .......................................................................................................................................... 120
i.
long ........................................................................................................................................... 120
j.
unsigned long ............................................................................................................................ 120
k.
short........................................................................................................................................... 121
l.
float ........................................................................................................................................... 121
m.
double.................................................................................................................................... 122
n.
array .......................................................................................................................................... 122
o.
string ......................................................................................................................................... 124
3. Chuyển đổi kiểu dữ liệu ...................................................................................... 126
a.
char() ......................................................................................................................................... 126
b.
byte() ......................................................................................................................................... 126
c.
int()............................................................................................................................................ 127
d.
word()........................................................................................................................................ 127
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: 0395 304 802
6
e.
long() ......................................................................................................................................... 128
f.
float()......................................................................................................................................... 128
4. Biến hằng, biến tĩnh: ......................................................................................... 129
a.
const - biến hằng ....................................................................................................................... 129
b.
static - biến tĩnh ......................................................................................................................... 129
III. CẤU TRÚC ( STRUCTURE): ............................................................................... 131
1. Cấu trúc tổng thể:................................................................................................ 131
a.
setup() và loop() ........................................................................................................................ 131
2. Toán tử logic: ....................................................................................................... 132
3. Các toán tử so sánh. ............................................................................................ 132
4. Cấu trúc điều khiển:............................................................................................ 133
a.
Câu lệnh if…..else..................................................................................................................... 133
b.
switch / case .............................................................................................................................. 134
c.
for .............................................................................................................................................. 135
d.
while.......................................................................................................................................... 137
e.
break.......................................................................................................................................... 137
f.
continue ..................................................................................................................................... 138
g.
return ......................................................................................................................................... 139
h.
goto ........................................................................................................................................... 139
5. Toán tử số học:..................................................................................................... 140
a.
Phép gán(=) ............................................................................................................................... 140
b.
Các phép cộng, trừ, nhân, chia trong Arduino .......................................................................... 140
c.
Phép chia lấy dƣ%..................................................................................................................... 141
6. Cú pháp mở rộng ................................................................................................. 142
a.
dấu chấm phẩy ( ; ).................................................................................................................... 142
b.
{} dấu ngoặc nhọn .................................................................................................................... 142
c.
Comments - Viết ghi chú trong khi viết code Arduino ............................................................. 144
d.
#define....................................................................................................................................... 145
e.
#include ..................................................................................................................................... 145
7. Phép toán hợp nhất ............................................................................................. 146
a.
Cộng một 1 đơn vị (++) / trừ một 1 đơn vị (--) ......................................................................... 146
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: 0395 304 802
7
b.
Các phép toán rút gọn += , -= , *= , /=...................................................................................... 147
C. CẤU TRÚC CHƢƠNG VÀ BÀI HỌC LẬP TRÌNH TỪ CƠ BẢN ĐẾN NÂNG
CAO ................................................................................................................................ 148
I. CẤU TRÚC CHƢƠNG TRÌNH ARDUINO VÀ CÁCH THÊM THƢ VIỆN
VÀO IDE. ....................................................................................................................... 148
1. Cấu trúc chƣơng trình Arduino: ....................................................................... 148
2. Hƣớng dẫn add thƣ viện cho Arduino IDE: ..................................................... 149
II. BÀI HỌC LẬP TRÌNH ARDUINO TỪ CƠ BẢN ĐẾN NÂNG CAO. ............. 154
1. Điều khiển LED đơn sáng nhấp nháy................................................................ 154
Nội dung chính. ................................................................................................................................. 154
Phần cứng ( Trên kit đã tích hợp sẵn chỉ cần nối dây là đƣợc) ......................................................... 154
Lắp mạch ........................................................................................................................................... 154
Hình ảnh thực tế: ............................................................................................................................... 155
Code lập trình và giải thích ............................................................................................................... 155
2. Thay đổi độ sáng của LED đơn. ......................................................................... 157
Nội dung chính:................................................................................................................................. 157
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ị: ......................................... 157
Lắp mạch ........................................................................................................................................... 157
Hình ảnh thực tế: ............................................................................................................................... 158
Chƣơng trình: .................................................................................................................................... 158
3. Điều khiển đèn giao thông. ................................................................................. 159
Phần cứng cần chuẩn bị ( nếu sử dụng kit thì đƣợc tích hợp sẵn)..................................................... 159
Lắp mạch:.......................................................................................................................................... 159
Hình ảnh thực tế: ............................................................................................................................... 160
Code lập trình:................................................................................................................................... 160
4. Điều khiển Rơ le 5Vdc 1, 2 kênh mức cao. ........................................................ 162
Giới thiệu thiệu chung:...................................................................................................................... 162
Thông số kỹ thuật: ............................................................................................................................ 162
Phần cứng chuẩn bị: .......................................................................................................................... 162
Lắp mạch:.......................................................................................................................................... 163
Code chƣơng trình: ........................................................................................................................... 163
Hình ảnh thực tế: ............................................................................................................................... 164
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: 0395 304 802
8
5. Điều khiển Công tắc tơ 3 pha: ............................................................................ 164
Giới thiệu công tắc tơ 3 pha: ............................................................................................................. 164
Phần cứng chuẩn bị: .......................................................................................................................... 166
Lắp mạch:.......................................................................................................................................... 167
Code chƣơng trình: ........................................................................................................................... 167
6. Đọc tín hiệu nút nhấn hiển thị lên serial monitor............................................. 168
Giới thiệu về nút nhấn:...................................................................................................................... 168
Phần cứng chuẩn bị: .......................................................................................................................... 170
Sơ đồ nguyên lí: ................................................................................................................................ 171
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn nút nhấn): ......................................................... 171
Hình ảnh thực tế: ............................................................................................................................... 172
Lập trình:........................................................................................................................................... 172
7. Lƣu giá trị nút nhấn. ........................................................................................... 174
Phần cứng chuẩn bị: .......................................................................................................................... 174
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn nút nhấn): ......................................................... 174
Hình ảnh thực tế: ............................................................................................................................... 175
Lập trình:........................................................................................................................................... 175
8. Bật tắt LED khi nhấn nút nhấn. ........................................................................ 177
Phần cứng chuẩn bị: .......................................................................................................................... 177
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn nút nhấn): ......................................................... 177
Hình ảnh thực tế: ............................................................................................................................... 178
Lập trình:........................................................................................................................................... 178
9. Bật tắt rơ le khi nhấn nút nhấn. ......................................................................... 180
Phần cứng chuẩn bị: .......................................................................................................................... 180
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn nút nhấn): ......................................................... 180
Hình ảnh thực tế: ............................................................................................................................... 181
Lập trình:........................................................................................................................................... 181
10. Lập trình hiển thị led 7 đoạn đơn: .................................................................... 183
Giới thiệu led 7 đoạn đơn:................................................................................................................ 183
Phần cứng chuẩn bị: .......................................................................................................................... 184
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn nút nhấn): ......................................................... 185
Lập trình:........................................................................................................................................... 185
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: 0395 304 802
9
Hình ảnh thực tế: ............................................................................................................................... 187
11. Hiển thị chữ cái, số ra module 4 led 7 đoạn. ..................................................... 188
Giới thiệu module 4 led 7 đoạn:........................................................................................................ 188
Phần cứng chuẩn bị: .......................................................................................................................... 189
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn): ....................................................................... 189
Hình ảnh thực tế: ............................................................................................................................... 190
Lập trình:........................................................................................................................................... 190
12. Lập trình hiển thị module led ma trận 8x8. ...................................................... 192
Giới thiệu module ma trận 8x8: ........................................................................................................ 192
Phần cứng chuẩn bị: ( tất cả đƣợc tích hợp trên Kit Tự Học) ........................................................... 192
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn): ....................................................................... 193
Hình ảnh thực tế: ............................................................................................................................... 193
Lập trình:........................................................................................................................................... 193
13. Hiển thị chữ lên màn hình LCD16x02. .............................................................. 198
Giới thiệu module LCD 16X02: ....................................................................................................... 198
Phần cứng chuẩn bị: ( tất cả đƣợc tích hợp trên Kit Tự Học) ........................................................... 198
Lắp mạch( nếu các bạn đã có kit học thì chỉ việc nối dây): .............................................................. 199
Hình ảnh thực tế: ............................................................................................................................... 200
Lập trình:........................................................................................................................................... 200
14. Kết hợp Module I2C với LCD16x02. ................................................................. 200
Giới thiệu module I2C cho LCD:...................................................................................................... 200
Phần cứng chuẩn bị: ( tất cả đƣợc tích hợp trên Kit Tự Học) ........................................................... 201
Lắp mạch( nếu các bạn đã có kit học thì chỉ việc nối dây): .............................................................. 201
Lập trình:........................................................................................................................................... 202
Hình ảnh thực tế: ............................................................................................................................... 202
15. Đọc giá trị cảm biến quang trở hiển thị lên serial monitor. ............................ 203
Giới thiệu cảm biến quang trở: ......................................................................................................... 203
Phần cứng chuẩn bị: (đƣợc tích hợp trên Kit Tự Học)...................................................................... 204
Lắp mạch( nếu các bạn đã có kit học thì chỉ việc nối dây): .............................................................. 204
Hình ảnh thực tế: ............................................................................................................................... 204
Lập trình:........................................................................................................................................... 205
16. Đọc gái trị CB nhiệt độ LM35 hiển thị lên serial monitor. .............................. 206
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: 0395 304 802
10
Giới thiệu cảm biến nhiệt độ LM35: ................................................................................................. 206
Phần cứng chuẩn bị: .......................................................................................................................... 207
Lắp mạch:.......................................................................................................................................... 207
Hình ảnh thực tế: ............................................................................................................................... 207
Lập trình:........................................................................................................................................... 207
17. Đọc giá trị CB nhiệt độ DS18B20 hiển thị lên serial monitor. ........................ 208
Giới thiệu cảm biến nhiệt độ DS 18B20: .......................................................................................... 208
Phần cứng chuẩn bị: .......................................................................................................................... 209
Lắp mạch:.......................................................................................................................................... 210
Lập trình:........................................................................................................................................... 210
18. Hiển thị giá trị CB nhiệt độ LM35 lên mà hình LCD. ..................................... 212
Phần cứng chuẩn bị: .......................................................................................................................... 212
Lắp mạch :......................................................................................................................................... 212
Lập trình :.......................................................................................................................................... 212
Hình ảnh thực tế: ............................................................................................................................... 213
19. Đọc giá trị cảm biến mƣa hiển thị lên serial monitor. ..................................... 214
Giới thiệu cảm biến mƣa: .................................................................................................................. 214
Phần cứng chuẩn bị: .......................................................................................................................... 215
Lắp mạch :......................................................................................................................................... 215
Lập trình :.......................................................................................................................................... 215
Hình ảnh thực tế: ............................................................................................................................... 216
20. Đọc giá trị CB siêu âm SRF 05 hiển thị lên serial monitor. ............................ 217
Giới thiệu cảm biến siêu âm SRF05: ................................................................................................ 217
Phần cứng chuẩn bị: .......................................................................................................................... 218
Lắp mạch :......................................................................................................................................... 218
Hình ảnh thực tế: ............................................................................................................................... 219
Lập trình :.......................................................................................................................................... 220
Kết quả hiển thị lên Serial monitor : ................................................................................................. 221
21. Đọc giá trị cảm biến độ ẩm đất hiển thị lên LCD16x02. .................................. 221
Giới thiệu cảm biến độ ẩm đất: ......................................................................................................... 221
Thông số kỹ thuật: ............................................................................................................................ 222
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn) ................................................................................... 222
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: 0395 304 802
11
Lắp mạch :......................................................................................................................................... 222
Hình ảnh thực tế: ............................................................................................................................... 223
Lập trình :.......................................................................................................................................... 223
Kết quả hiển thị lên Serial monitor : ................................................................................................. 224
22. Đọc giá trị CB dò line hiển thị lên serial monitor và LCD. ............................. 224
Giới thiệu cảm biến dò line: .............................................................................................................. 224
Thông số kỹ thuật: ............................................................................................................................ 225
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn) ................................................................................... 225
Lắp mạch :......................................................................................................................................... 226
Lập trình :.......................................................................................................................................... 226
Hình ảnh thực tế: ............................................................................................................................... 228
Kết quả hiển thị lên Serial monitor : ................................................................................................. 228
23. Đọc giá trị điện áp khi điều chỉnh biến trở hiển thị lên serial ......................... 229
Giới thiệu về biến trở: ....................................................................................................................... 229
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn biến trở 10K) .............................................................. 229
Lắp mạch :......................................................................................................................................... 229
Lập trình :.......................................................................................................................................... 230
Hình ảnh thực tế: ............................................................................................................................... 231
Kết quả hiển thị lên Serial monitor : ................................................................................................. 231
24. Hiển thị thời gian thực (DS1307) lên LCD và serial monitor.......................... 232
Giới thiệu về module DS1307: ......................................................................................................... 232
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn biến trở 10K) .............................................................. 233
Lắp mạch :......................................................................................................................................... 233
Lập trình :.......................................................................................................................................... 234
Hình ảnh thực tế: ............................................................................................................................... 236
Kết quả hiển thị lên Serial monitor : ................................................................................................. 236
25. Hiển thị tốc độ đo bằng Encoder quay lên LCD............................................... 237
Giới thiệu về module Encoder quay: ................................................................................................ 237
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn ) .................................................................................. 237
Thông số kỹ thuật: ............................................................................................................................ 237
Lắp mạch:.......................................................................................................................................... 240
Lập trình :.......................................................................................................................................... 240
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: 0395 304 802
12
Hình ảnh thực tế: ............................................................................................................................... 243
26. Cài đặt và hiển thị nhiệt độ, độ ẩm (DTH11).................................................... 243
Giới thiệu về giao tiếp I2C: ............................................................................................................... 243
Thông số kỹ thuật DHT11: ............................................................................................................... 244
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn ). ................................................................................. 244
Lập trình :.......................................................................................................................................... 246
Hình ảnh thực tế: ............................................................................................................................... 248
27. Điều khiển động cơ servo SG90: ........................................................................ 249
Giới thiệu về động cơ servo SG90: ................................................................................................... 249
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn ). ................................................................................. 249
Lắp mạch:.......................................................................................................................................... 250
Lập trình :.......................................................................................................................................... 250
Hình ảnh thực tế: ............................................................................................................................... 251
28. Điều khiển động cơ bƣớc stepper 28BYJ-48: .................................................. 252
Giới thiệu về động cơ bƣớc stepper 28BYJ-48: ............................................................................... 252
Thông số kỹ thuật: ............................................................................................................................ 252
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn ). ................................................................................. 252
Lắp mạch:.......................................................................................................................................... 253
Lập trình :.......................................................................................................................................... 253
Hình ảnh thực tế: ............................................................................................................................... 255
29. Bật tắt LED bằng Remote hồng ngoại: ............................................................. 256
Giới thiệu về Remote hồng ngoại: .................................................................................................... 256
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn ). ................................................................................. 257
Mắt thu hồng ngoại: .......................................................................................................................... 257
Lắp mạch:.......................................................................................................................................... 258
Lập trình:........................................................................................................................................... 258
Hình ảnh thực tế: ............................................................................................................................... 261
30. Điều khiển động cơ bằng module L298n:.......................................................... 261
Giới thiệu về Module L298:.............................................................................................................. 261
Thông số kỹ thuật: ............................................................................................................................ 262
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn ). ................................................................................. 262
Lắp mạch. .......................................................................................................................................... 262
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: 0395 304 802
13
Lập trình:........................................................................................................................................... 263
31. Lập trình module Wifi ESP8266 V1 bằng Uno R3: ......................................... 265
Giới thiệu về module Wifi ESP8266 V1: ......................................................................................... 265
Thông số kỹ thuật: ............................................................................................................................ 265
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn ). ................................................................................. 266
Lắp mạch:.......................................................................................................................................... 266
Lập trình :.......................................................................................................................................... 267
Hình ảnh thực tế: ............................................................................................................................... 269
32. Giao tiếp giữa 2 board Arduino với nhau. ........................................................ 270
Giới thiệu: ......................................................................................................................................... 270
Thƣ viện hổ trợ việc giao tiếp giữa 2 Arduino:................................................................................ 270
Phần cứng chuẩn bị: .......................................................................................................................... 270
Lắp mạch:.......................................................................................................................................... 270
Lập trình:........................................................................................................................................... 271
33. Điều khiển LED RGB ( LED 3 màu). ................................................................ 272
Giới thiệu: ......................................................................................................................................... 272
Để 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. ............................................................ 273
Lắp mạch:.......................................................................................................................................... 273
Lập trình:........................................................................................................................................... 273
Hình ảnh thực tế: ............................................................................................................................... 274
34. Hiển thị giá trị điện áp khi điều chỉnh biến trở. ............................................... 275
Giới thiệu: ......................................................................................................................................... 275
Phần cứng chuẩn bị: .......................................................................................................................... 276
Lắp mạch:.......................................................................................................................................... 276
Lập trình:........................................................................................................................................... 277
35. Đọc giá trị cảm biến báo cháy hiển thị serial monitor. .................................... 277
Giới thiệu: ......................................................................................................................................... 277
Thông số kĩ thuật: ............................................................................................................................. 277
Phần cứng chuẩn bị: .......................................................................................................................... 278
Lắp mạch:.......................................................................................................................................... 278
Lập trình:........................................................................................................................................... 279
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: 0395 304 802
14
36. Đọc giá trị CB màu (TCS3200) hiển thị serial monitor. .................................. 280
Giới thiệu: ......................................................................................................................................... 280
Thông số kĩ thuật: ............................................................................................................................. 280
Phần cứng chuẩn bị: .......................................................................................................................... 281
Lắp mạch:.......................................................................................................................................... 282
Lập trình:........................................................................................................................................... 282
37. Đọc giá trị CB chuyển động PIR hiển thị serial monitor. ................................ 283
Giới thiệu: ......................................................................................................................................... 283
Nguyên lý làm việc của loại đầu dò PIR nhƣ hình sau: .................................................................... 284
Thông số kĩ thuật: ............................................................................................................................. 285
Phần cứng chuẩn bị: .......................................................................................................................... 285
Lắp mạch:.......................................................................................................................................... 286
Lập trình:........................................................................................................................................... 286
38. Đọc giá trị CB khí gas (MQ2) hiển thị serial monitor..................................... 287
Giới thiệu: ......................................................................................................................................... 287
Thông số kĩ thuật: ............................................................................................................................. 288
Phần cứng chuẩn bị: .......................................................................................................................... 288
Lắp mạch:.......................................................................................................................................... 288
Lập trình:........................................................................................................................................... 288
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). ................................................................................................... 289
Giới thiệu: ......................................................................................................................................... 289
Thông số kĩ thuật: ............................................................................................................................. 289
Phần cứng chuẩn bị: .......................................................................................................................... 290
Lắp mạch:.......................................................................................................................................... 290
Lập trình cho Arduino:...................................................................................................................... 291
Viết app điều khiển thiết bị điện bằng Bluetooth trên điện thoại Andriod: ...................................... 292
Hình ảnh thực tế: ............................................................................................................................... 294
40. Sử dụng IC Max7219 để điều khiển led ma trận 8x8. ...................................... 294
Giới thiệu: ......................................................................................................................................... 294
Thông số kĩ thuật: ............................................................................................................................. 295
Phần cứng chuẩn bị: .......................................................................................................................... 295
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: 0395 304 802
15
Lắp mạch:.......................................................................................................................................... 295
Lập trình:........................................................................................................................................... 295
Hình ảnh thực tế: ............................................................................................................................... 296
41. Đo Tốc Độ Động Cơ Bằng Cảm Biến IR FC03. ................................................ 297
Giới thiệu: ......................................................................................................................................... 297
Phần cứng chuẩn bị: .......................................................................................................................... 297
CB tốc độ IR FC03: .......................................................................................................................... 297
Thông số kĩ thuật: ............................................................................................................................. 298
Nguyên lý hoạt động: ........................................................................................................................ 298
Lắp mạch:.......................................................................................................................................... 299
Lập trình:........................................................................................................................................... 299
42. Điều khiển RGB LED sử dụng Module Bluetooth HC05 . ............................. 300
Giới thiệu: ......................................................................................................................................... 300
Phần cứng chuẩn bị: .......................................................................................................................... 300
Lắp mạch:.......................................................................................................................................... 300
Lập trình cho arduino: ....................................................................................................................... 301
Lập trình app cho điện thoại Android: .............................................................................................. 302
43. Làm game với led ma trận 8x8 Max7219 . ........................................................ 303
Phần cứng chuẩn bị: .......................................................................................................................... 303
Lắp mạch:.......................................................................................................................................... 303
Lập trình:........................................................................................................................................... 305
Hình ảnh thực tế: ............................................................................................................................... 306
44. Lập trình với keypad 4x4 . .................................................................................. 307
Giới thiệu: ......................................................................................................................................... 307
Lắp mạch:.......................................................................................................................................... 308
Lập trình:........................................................................................................................................... 308
Hình ảnh thực tế: ............................................................................................................................... 309
45. Điều khiển thiết bị bằng module enthernet shiled . ........................................ 310
Giới thiệu về enthernet shiled: .......................................................................................................... 310
Phần cứng chuẩn bị: .......................................................................................................................... 310
Lắp mạch:.......................................................................................................................................... 311
Lập trình:........................................................................................................................................... 311
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: 0395 304 802
16
46. Đọc giá trị cảm biến áp suất BM180 . ................................................................ 313
Giới thiệu về BM180: ....................................................................................................................... 313
Phần cứng chuẩn bị: .......................................................................................................................... 314
Lắp mạch:.......................................................................................................................................... 314
Lập trình:........................................................................................................................................... 314
Hình ảnh thực tế: ............................................................................................................................... 316
47. Chạy chữ trên led ma trận 8x8 sử dụng Bluetooth HC05. .............................. 317
Phần cứng chuẩn bị: .......................................................................................................................... 317
Lắp mạch:.......................................................................................................................................... 317
Lập trình cho arduino: ....................................................................................................................... 317
Lập trình app Inventor cho điện thoại android. ................................................................................. 319
48. Điều khiển hiệu ứng RGB LED WS2812b. ....................................................... 319
Phần cứng chuẩn bị: .......................................................................................................................... 319
Giới thiệu led WS2812B: .................................................................................................................. 320
Lắp mạch:.......................................................................................................................................... 320
Lập trình cho arduino: ....................................................................................................................... 321
49. Mô phỏng hệ thống radar bằng cảm biến siêu âm SRF05. ............................ 322
Phần cứng chuẩn bị: .......................................................................................................................... 322
Lắp mạch:.......................................................................................................................................... 322
Lập trình cho arduino: ....................................................................................................................... 322
Lập trình code cho processing: ......................................................................................................... 323
Hình ảnh thực tế: ............................................................................................................................... 324
50. Lập trình điều khiển module rơ le bán dẫn SSR . ............................................ 325
Giới thiệu rơ le bán dẫn SSR: ........................................................................................................... 325
Thông số kĩ thuật: ............................................................................................................................. 325
Lắp mạch:.......................................................................................................................................... 326
Lập trình cho arduino: ....................................................................................................................... 326
D. IOT ( Internet Of Things ) ...................................................................................... 328
I.
Khái niệm Internet Of Things ( IOT) là gì?. ........................................................ 328
1. Khái niệm IOT ..................................................................................................... 328
2. Những ứng dụng thực tế trong cuộc sống ......................................................... 328
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: 0395 304 802
17
3. ESP8266 dòng chip đƣợc sử dụng phổ biến nhất hiện nay trong IOT. .......... 329
4. Module và Board phát triển của ESP8266. ....................................................... 330
5. Giới thiệu về module ESP 12E( NodeMCU V1). ............................................. 331
6. Lập trình ESP 12E bằng Arduino IDE. ............................................................ 332
Giới thiệu về ESP826612E: .............................................................................................................. 332
Chuẩn bị phần cứng: ......................................................................................................................... 332
Cài đặt phần mềm arduino IDE và thƣ viện cho esp8266. ................................................................ 332
Hƣớng dẫn nạp chƣơng trình cho ESP8266 12E: ............................................................................. 335
Hình ảnh thực tế: ............................................................................................................................... 336
II. Bài học mẫu cơ bản lập trình cho ESP12E........................................................... 337
1. Bật tắt led theo ý muốn bằng esp8266 12E. ...................................................... 337
Chuẩn bị phần cứng: ......................................................................................................................... 337
Lắp mạch:.......................................................................................................................................... 337
Lập trình:........................................................................................................................................... 337
Hình ảnh thực tế: ............................................................................................................................... 338
2. Bật tắt led bằng nút nhấn ( không lƣu trạng thái). .......................................... 338
Chuẩn bị phần cứng: ......................................................................................................................... 338
Lắp mạch:.......................................................................................................................................... 338
Lập trình:........................................................................................................................................... 339
Hình ảnh thực tế: ............................................................................................................................... 339
3. Bật tắt led bằng nút nhấn (lƣu trạng thái). ....................................................... 340
Chuẩn bị phần cứng: ......................................................................................................................... 340
Lắp mạch:.......................................................................................................................................... 340
Lập trình:........................................................................................................................................... 341
Hình ảnh thực tế: ............................................................................................................................... 342
4. Điều khiển relay bằng Esp8266 V_12E. ............................................................ 342
Chuẩn bị phần cứng: ......................................................................................................................... 342
Lắp mạch:.......................................................................................................................................... 342
Lập trình:........................................................................................................................................... 343
Hình ảnh thực tế: ............................................................................................................................... 343
5. Hiển thị lên màn hình LCD bằng ESP8266 12E. .............................................. 343
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: 0395 304 802
18
Chuẩn bị phần cứng: ......................................................................................................................... 343
Lắp mạch:.......................................................................................................................................... 344
Lập trình:........................................................................................................................................... 344
Hình ảnh thực tế: ............................................................................................................................... 344
6. Đọc giá trị cảm biến nhiệt độ LM35 và gửi lên thingspeak. ............................ 345
Chuẩn bị phần cứng: ......................................................................................................................... 346
Phần mềm : ....................................................................................................................................... 346
Cài đặt trên thingspeak:..................................................................................................................... 346
Lắp mạch:.......................................................................................................................................... 348
Lập trình:........................................................................................................................................... 348
Sau khi upload code ta mở cổng serial monitor và thingspeak: ........................................................ 350
7. Điều khiển thiết bị điện bằng webserver. .......................................................... 350
Chuẩn bị phần cứng: ......................................................................................................................... 350
Phần mềm : ....................................................................................................................................... 351
Lắp mạch:.......................................................................................................................................... 351
Lập trình:........................................................................................................................................... 351
Hình ảnh thực tế: ............................................................................................................................... 357
8. Điều khiển thiết bị điện bằng wifi và app MIT invertor. ................................ 358
Phần mền cần chuẩn bị...................................................................................................................... 358
Phần cứng cần chuẩn bị: ................................................................................................................... 358
Lắp mạch:.......................................................................................................................................... 358
Code chƣơng trình: ........................................................................................................................... 359
Cài đặt app cho điện thoại ( Andriod): .............................................................................................. 363
Hình ảnh thực tế: ............................................................................................................................... 364
9. Điều khiển thiết bị điện bằng Nodemcu ( esp 12e) và app Blynk. .................. 365
Phần mền cần chuẩn bị...................................................................................................................... 365
Phần cứng cần chuẩn bị: ................................................................................................................... 365
Lắp mạch:.......................................................................................................................................... 365
Code chƣơng trình: ........................................................................................................................... 365
Các bƣớc thực hiện nhƣ sau: ............................................................................................................. 367
Hình ảnh thực tế: ............................................................................................................................... 370
D. HỌC LẬP TRÌNH ARDUINO THÔNG QUA DỰ ÁN ....................................... 371
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: 0395 304 802
19
1. Ðo và hiển thị điện áp DC ( 0 – 30Vdc). ............................................................ 371
Phần mền cần chuẩn bị...................................................................................................................... 371
Phần cứng cần chuẩn bị: ................................................................................................................... 371
Lắp mạch:.......................................................................................................................................... 371
Code chƣơng trình: ........................................................................................................................... 372
Hình ảnh thực tế: ............................................................................................................................... 373
2. Thiết kế xe robot 4 bánh điều khiển bằng điện thoại ( bluethooth) ............... 373
Mục tiêu: ........................................................................................................................................... 373
Phần mền cần chuẩn bị...................................................................................................................... 373
Phần cứng cần chuẩn bị: ................................................................................................................... 373
Lắp mạch nguyên lý: ......................................................................................................................... 374
Lắp mô hình: ..................................................................................................................................... 375
3. Thiết kế mô hình bật tắt đèn AC 220v khi trời tối, sử dụng cảm biến quang
trở 384
Mục tiêu: ........................................................................................................................................... 384
Phần mền cần chuẩn bị...................................................................................................................... 384
Phần cứng cần chuẩn bị: ................................................................................................................... 384
Lắp mạch nguyên lý: ......................................................................................................................... 384
Code chƣơng trình: ........................................................................................................................... 385
Hình ảnh thực tế: ............................................................................................................................... 386
4. Thiết kế mô hình tƣới cây tự động. .................................................................... 387
Mục tiêu: ........................................................................................................................................... 387
Phần mền cần chuẩn bị...................................................................................................................... 387
Phần cứng cần chuẩn bị: ................................................................................................................... 387
Lắp mạch nguyên lý: ......................................................................................................................... 387
Code chƣơng trình............................................................................................................................. 387
Hình ảnh thực tế: ............................................................................................................................... 388
5. Thiết kế mô hình đếm số học sinh trong phòng học.. ....................................... 389
Mục tiêu: ........................................................................................................................................... 389
Phần mền cần chuẩn bị...................................................................................................................... 389
Phần cứng cần chuẩn bị: ................................................................................................................... 389
Lắp mạch nguyên lý: ......................................................................................................................... 389
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: 0395 304 802
20
Code chƣơng trình: ........................................................................................................................... 390
Hình ảnh thực tế: ............................................................................................................................... 392
6. Thiết kế mô hình bật tắt thiết bị bằng sóng rf 433Mhz. .................................. 393
Mục tiêu: ........................................................................................................................................... 393
Phần mền cần chuẩn bị...................................................................................................................... 393
Phần cứng cần chuẩn bị: ................................................................................................................... 393
Bảng mã ASCII: ................................................................................................................................ 393
Lắp mạch nguyên lý: ......................................................................................................................... 394
Code chƣơng trình: ........................................................................................................................... 395
Hình ảnh thực tế: ............................................................................................................................... 400
7. Thiết kế xe robot 4 bánh điều khiển bằng sóng Wifi ( nodemcu ). ................. 400
Mục tiêu: ........................................................................................................................................... 400
Phần mền cần chuẩn bị...................................................................................................................... 400
Phần cứng cần chuẩn bị: ................................................................................................................... 401
Lắp mạch nguyên lý: ......................................................................................................................... 401
Lắp mô hình: ..................................................................................................................................... 402
8. Thiết kế mô hình diều khiển bật tắt relay bằng cảm biến TOUCH ( cảm biến
điện dung ). ................................................................................................................. 411
Mục tiêu: ........................................................................................................................................... 411
Phần mền cần chuẩn bị...................................................................................................................... 411
Phần cứng cần chuẩn bị: ................................................................................................................... 411
Lắp mạch nguyên lý: ......................................................................................................................... 411
Code chƣơng trình: ........................................................................................................................... 411
Hình ảnh thực tế: ............................................................................................................................... 412
9 Gửi thông báo về điện thoại khi có trộm bằng cảm biến chuyển động sử dụng
board NodeMCU và app BLYNK. ........................................................................... 412
Mục tiêu: ........................................................................................................................................... 412
Phần mền cần chuẩn bị...................................................................................................................... 413
Phần cứng cần chuẩn bị: ................................................................................................................... 413
Lắp mạch nguyên lý: ......................................................................................................................... 413
Code chƣơng trình: ........................................................................................................................... 413
Cài app blynk cho điện thoại: ........................................................................................................... 415
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: 0395 304 802
21
Hình ảnh thực tế: ............................................................................................................................... 419
10. Điều khiển LED ma trận Max7219 với module WIFI NodeMCU................. 419
Mục tiêu: ........................................................................................................................................... 419
Phần mền cần chuẩn bị...................................................................................................................... 419
Phần cứng cần chuẩn bị: ................................................................................................................... 419
Lắp mạch nguyên lý: ......................................................................................................................... 420
Code chƣơng trình: ........................................................................................................................... 420
Hình ảnh thực tế: ............................................................................................................................... 423
11. Ðiều khiển tốc độ động cơ bƣớc bằng biến trở sử dụng board ....................... 423
Mục tiêu: ........................................................................................................................................... 423
Phần mền cần chuẩn bị...................................................................................................................... 423
Phần cứng cần chuẩn bị: ................................................................................................................... 423
Lắp mạch nguyên lý: ......................................................................................................................... 423
Code chƣơng trình: ........................................................................................................................... 424
Hình ảnh thực tế: ............................................................................................................................... 425
12 Đọc giá trị nhiệt độ, độ ẩm hiển thị lên màn hình oled 0.96” và blynk sử dụng
board NodeMCU. ....................................................................................................... 426
Mục tiêu: ........................................................................................................................................... 426
Phần mền cần chuẩn bị...................................................................................................................... 426
Phần cứng cần chuẩn bị: ................................................................................................................... 426
Lắp mạch nguyên lý: ......................................................................................................................... 426
Code chƣơng trình: ........................................................................................................................... 427
Cài đặt app Blynk: ............................................................................................................................ 429
Hình ảnh thực tế: ............................................................................................................................... 433
13. Thiết kế xe 2 bánh tự cân bằng sử dụng board ardunio. ................................. 433
Mục tiêu: ........................................................................................................................................... 433
Phần mền cần chuẩn bị...................................................................................................................... 433
Phần cứng cần chuẩn bị: ................................................................................................................... 433
Lắp mạch nguyên lý: ......................................................................................................................... 436
Code chƣơng trình: (code hoàn chỉnh link kèm theo) ...................................................................... 436
Hình ảnh thực tế: ( bánh xe đƣợc thay loại có ma sát tốt hơn ) ........................................................ 438
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: 0395 304 802
22
14. Thiết kế mô hình hẹn giờ bật tắt thiết bị sử dụng module DS1307 và arduino.
439
Mục tiêu: ........................................................................................................................................... 439
Phần mền cần chuẩn bị...................................................................................................................... 439
Phần cứng cần chuẩn bị: ................................................................................................................... 439
Lắp mạch nguyên lý: ......................................................................................................................... 439
Hình ảnh thực tế: ............................................................................................................................... 445
15. Thiết kế mô hình xe 4 bánh diều khiển bằng sóng Wifi sử board NodeMCU và
app Blynk ( công cụ Joystick ). ................................................................................. 445
Mục tiêu: ........................................................................................................................................... 445
Phần mền cần chuẩn bị...................................................................................................................... 445
Phần cứng cần chuẩn bị: ................................................................................................................... 445
Lắp mạch nguyên lý: ......................................................................................................................... 445
Code chƣơng trình: ........................................................................................................................... 446
16. Thiết kế mô hình xe robot 3 bánh tự hành sử dụng board ardunio. .............. 452
Mục tiêu: ........................................................................................................................................... 452
Phần mền cần chuẩn bị...................................................................................................................... 452
Phần cứng cần chuẩn bị: ................................................................................................................... 452
Lắp mạch nguyên lý: ......................................................................................................................... 453
Code chƣơng trình: ........................................................................................................................... 455
17. Ðiều khiển góc quay động cơ buớc bằng nút nhấn sử dụng board arduino. . 459
Mục tiêu: ........................................................................................................................................... 459
Phần mền cần chuẩn bị...................................................................................................................... 459
Phần cứng cần chuẩn bị: ................................................................................................................... 459
Lắp mạch nguyên lý: ......................................................................................................................... 459
Code chƣơng trình: ........................................................................................................................... 460
Hình ảnh thực tế: ............................................................................................................................... 462
18. Thiết kế xe robot 4 bánh điều khiển bằng giọng nói sử dụng board arduino.
463
Mục tiêu: ........................................................................................................................................... 463
Phần mền cần chuẩn bị...................................................................................................................... 463
Phần cứng cần chuẩn bị: ( Tuong tự với xe cấp dộ 1 )...................................................................... 463
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: 0395 304 802
23
Lắp mạch nguyên lý: ......................................................................................................................... 463
Lắp mô hình: tƣơng tự nhƣ xe robot 4 bánh ở trên ........................................................................... 465
19. Thiết kế mô hình mở cửa tự dộng sử dụng module RC522 và board arduino (
nhà thông minh). ........................................................................................................ 468
Mục tiêu: ........................................................................................................................................... 468
Phần mền cần chuẩn bị...................................................................................................................... 468
Phần cứng cần chuẩn bị: ................................................................................................................... 468
Lắp mạch nguyên lý: ......................................................................................................................... 468
Code chƣơng trình: ........................................................................................................................... 469
20. Thiết kế mô hình hiển thị giờ, nhiệt dộ và dộ ẩm lên module led matrix 32x8
sử dụng board arduino. ............................................................................................. 474
Mục tiêu: ........................................................................................................................................... 474
Phần mền cần chuẩn bị...................................................................................................................... 474
Phần cứng cần chuẩn bị: ................................................................................................................... 474
Lắp mạch nguyên lý: ......................................................................................................................... 474
Code chƣơng trình: ........................................................................................................................... 475
Hình ảnh thực tế: ............................................................................................................................... 480
21. Thiết kế mô hình hẹn giờ bật tắt thiết bị điện sử dụng module DS3231 và
arduino. ....................................................................................................................... 481
Mục tiêu: ........................................................................................................................................... 481
Phần mền cần chuẩn bị...................................................................................................................... 481
Phần cứng cần chuẩn bị: ................................................................................................................... 481
Lắp mạch nguyên lý: ......................................................................................................................... 481
Code chƣơng trình: ........................................................................................................................... 482
Hình ảnh thực tế: ............................................................................................................................... 486
22. Thiết kế mô hình cài đặt và hiển thị nhiệt độ sử dụng cảm biến PT100 và
board arduino. ............................................................................................................ 486
Mục tiêu: ........................................................................................................................................... 486
Phần mền cần chuẩn bị...................................................................................................................... 486
Phần cứng cần chuẩn bị: ................................................................................................................... 487
Lắp mạch nguyên lý: ......................................................................................................................... 487
Code chƣơng trình: ........................................................................................................................... 488
Hình ảnh thực tế: ............................................................................................................................... 491
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: 0395 304 802
24
23. Thiết kế mô hình hiển thị giờ lên màn hình LCD 16X02 chữ lớn không sử
module thời gian thực. ............................................................................................... 491
Mục tiêu: ........................................................................................................................................... 491
Phần mền cần chuẩn bị...................................................................................................................... 491
Phần cứng cần chuẩn bị: ................................................................................................................... 491
Lắp mạch nguyên lý: ......................................................................................................................... 492
Code chƣơng trình: ........................................................................................................................... 492
Hình ảnh thực tế: ............................................................................................................................... 497
24. Thiết kế mô hình bật tắt thiết bị điện bằng máy tính thông qua phần mền
processing và arduino. ............................................................................................... 497
Mục tiêu: ........................................................................................................................................... 497
Phần mền cần chuẩn bị...................................................................................................................... 497
Phần cứng cần chuẩn bị: ................................................................................................................... 498
Lắp mạch nguyên lý: ......................................................................................................................... 498
Code cho arduino: ............................................................................................................................. 498
Code cho processing: ........................................................................................................................ 499
Hình ảnh thực tế: ............................................................................................................................... 501
25. Thiết kế mô hình xe robot 4 bánh điều khiển bằng sóng RF thông qua module
RF24L01 và board arduino. ...................................................................................... 502
Mục tiêu: ........................................................................................................................................... 502
Phần mền cần chuẩn bị...................................................................................................................... 502
Phần cứng cần chuẩn bị: ................................................................................................................... 502
Lắp mạch nguyên lý phần phát: ........................................................................................................ 502
Lắp mạch nguyên lý phần thu: .......................................................................................................... 503
Code cho phần phát:.......................................................................................................................... 504
Code cho phần thu: ........................................................................................................................... 504
Hình ảnh thực tế: ............................................................................................................................... 507
26. Thiết kế mô hình xe robot 3 bánh dò line và tránh vật cản sử dụng board
arduino. ....................................................................................................................... 507
Mục tiêu: ........................................................................................................................................... 507
Phần mền cần chuẩn bị...................................................................................................................... 507
Phần cứng cần chuẩn bị: ................................................................................................................... 507
Lắp mạch nguyên lý: ......................................................................................................................... 508
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: 0395 304 802
25
Code chƣơng trình: ........................................................................................................................... 509
Hình ảnh thực tế: ............................................................................................................................... 512
27. Thiết kế mô hình truyền dữ liệu cảm biến qua máy tính thông qua giao tiếp
MODBUS RTU . ......................................................................................................... 513
Mục tiêu: ........................................................................................................................................... 513
Phần mền cần chuẩn bị...................................................................................................................... 513
Phần cứng cần chuẩn bị: ................................................................................................................... 513
Lắp mạch nguyên lý: ......................................................................................................................... 513
Code chƣơng trình: ........................................................................................................................... 514
Hình ảnh thực tế: ............................................................................................................................... 516
28. Thiết kế mô hình đo dòng điện AC/DC sử dụng module ACS712 và board
arduino . ...................................................................................................................... 517
Mục tiêu: ........................................................................................................................................... 517
Phần mền cần chuẩn bị...................................................................................................................... 517
Phần cứng cần chuẩn bị: ................................................................................................................... 517
Lắp mạch nguyên lý: ......................................................................................................................... 517
Code chƣơng trình: ........................................................................................................................... 518
Hình ảnh thực tế: ............................................................................................................................... 521
29. Thiết kế mô hình điều khiển độ sáng của đèn led ứng dụng giải thuật PID và
sử dụng board arduino . ............................................................................................ 521
Mục tiêu: ........................................................................................................................................... 521
Phần mền cần chuẩn bị...................................................................................................................... 521
Phần cứng cần chuẩn bị: ................................................................................................................... 521
Lắp mạch nguyên lý: ......................................................................................................................... 522
Code chƣơng trình: ........................................................................................................................... 522
Hình ảnh thực tế: ............................................................................................................................... 523
30. Thiết kế mô hình điều khiển thiết bị điện thông qua giao thức (MQTT) và
board NodeMCU. ....................................................................................................... 523
Mục tiêu: ........................................................................................................................................... 523
Phần mền cần chuẩn bị...................................................................................................................... 523
Phần cứng cần chuẩn bị: ................................................................................................................... 523
Lắp mạch nguyên lý: ......................................................................................................................... 524
Code chƣơng trình: ........................................................................................................................... 524
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: 0395 304 802
26
Cài đặt app trên Ubidots: .................................................................................................................. 525
Hình ảnh thực tế: ............................................................................................................................... 527
31. Thiết kế mô hình hiển thị vị trí lên màn hình LCD sử dụng board arduino và
GPS neo6. .................................................................................................................... 527
Mục tiêu: ........................................................................................................................................... 527
Phần mền cần chuẩn bị...................................................................................................................... 527
Phần cứng cần chuẩn bị: ................................................................................................................... 527
Lắp mạch nguyên lý: ......................................................................................................................... 527
Code chƣơng trình: ........................................................................................................................... 528
Hình ảnh thực tế: ............................................................................................................................... 529
32. Thiết kế mô hình lọc nhiễu cho cảm biến trong các dự án liên qua đến
arduino. ....................................................................................................................... 530
Mục tiêu: ........................................................................................................................................... 530
Phần mền cần chuẩn bị...................................................................................................................... 530
Phần cứng cần chuẩn bị: ................................................................................................................... 530
Lắp mạch nguyên lý: ......................................................................................................................... 530
Code chƣơng trình: ........................................................................................................................... 530
Hình ảnh thực tế: ............................................................................................................................... 532
33. Thiết kế mô hình điều khiển thiết bị điện và hiển thị giá trị cảm biến lên
internet thông qua giao thức (MQTT) và board NodeMCU. ................................ 533
Mục tiêu: ........................................................................................................................................... 533
Phần mền cần chuẩn bị...................................................................................................................... 533
Phần cứng cần chuẩn bị: ................................................................................................................... 533
Lắp mạch nguyên lý: ......................................................................................................................... 533
Code chƣơng trình: ........................................................................................................................... 534
Cài đặt app trên Ubidots: .................................................................................................................. 535
Hình ảnh thực tế: ............................................................................................................................... 538
34. Thiết kế mô hình điều khiển đóng ngắt relay bằng SMS thông qua module
sim800l và arduino. .................................................................................................... 538
Mục tiêu: ........................................................................................................................................... 538
Phần mền cần chuẩn bị...................................................................................................................... 538
Phần cứng cần chuẩn bị: ................................................................................................................... 538
Lắp mạch nguyên lý: ......................................................................................................................... 538
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: 0395 304 802
27
Code chƣơng trình: ........................................................................................................................... 539
Hình ảnh thực tế: ............................................................................................................................... 540
35. Thiết kế mô hình điều khiển đóng ngắt relay thông qua Webserver sử dụng
board ESP32. .............................................................................................................. 541
Mục tiêu: ........................................................................................................................................... 541
Phần mền cần chuẩn bị...................................................................................................................... 541
Phần cứng cần chuẩn bị: ................................................................................................................... 541
Lắp mạch nguyên lý: ......................................................................................................................... 541
Code chƣơng trình: ........................................................................................................................... 542
Hình ảnh thực tế: ............................................................................................................................... 545
36. Thiết kế mô hình hiển thị vị trí tọa độ lên màn hình LCD sử dụng module
GPS NEO6 và arduino. .............................................................................................. 545
Mục tiêu: ........................................................................................................................................... 545
Phần mền cần chuẩn bị...................................................................................................................... 545
Phần cứng cần chuẩn bị: ................................................................................................................... 545
Lắp mạch nguyên lý: ......................................................................................................................... 545
Code chƣơng trình: ........................................................................................................................... 546
Hình ảnh thực tế: ............................................................................................................................... 547
37. Thiết kế mô hình điều khiển thiết bị điện bằng SMS sử dụng module sim 800l
và arduino. .................................................................................................................. 548
Mục tiêu: ........................................................................................................................................... 548
Phần mền cần chuẩn bị...................................................................................................................... 548
Phần cứng cần chuẩn bị: ................................................................................................................... 548
Lắp mạch nguyên lý: ......................................................................................................................... 548
Code chƣơng trình: ........................................................................................................................... 549
Hình ảnh thực tế: ............................................................................................................................... 550
38. Thiết kế mô hình điều khiển đảo chiều động cơ bƣớc stepper 0.8/step sử dụng
nút nhấn và arduino. .................................................................................................. 550
Mục tiêu: ........................................................................................................................................... 550
Phần mền cần chuẩn bị...................................................................................................................... 551
Phần cứng cần chuẩn bị: ................................................................................................................... 551
Lắp mạch nguyên lý: ......................................................................................................................... 551
Code chƣơng trình: ........................................................................................................................... 552
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: 0395 304 802
28
Hình ảnh thực tế: ............................................................................................................................... 554
39. Thiết kế mô hình điều khiển tốc độ động cơ sử dụng module driver BTS7960
và arduino. .................................................................................................................. 554
Mục tiêu: ........................................................................................................................................... 554
Phần mền cần chuẩn bị...................................................................................................................... 554
Phần cứng cần chuẩn bị: ................................................................................................................... 554
Lắp mạch nguyên lý: ......................................................................................................................... 555
Code chƣơng trình: ........................................................................................................................... 555
Hình ảnh thực tế: ............................................................................................................................... 556
40. Thiết kế mô hình điều khiển động cơ bƣớc 1.8/step sử dụng module driver
TB6600 và arduino. .................................................................................................... 557
Mục tiêu: ........................................................................................................................................... 557
Phần mền cần chuẩn bị...................................................................................................................... 557
Phần cứng cần chuẩn bị: ................................................................................................................... 557
Lắp mạch nguyên lý: ......................................................................................................................... 557
Code chƣơng trình: ........................................................................................................................... 558
Hình ảnh thực tế: ............................................................................................................................... 559
41. Thiết kế mô hình điều khiển thiết bị điện dựa vào giá trị cảm biến ánh sáng và
đồng thời gửi tin nhắn về điện thoại. ........................................................................ 559
Mục tiêu: ........................................................................................................................................... 559
Phần mền cần chuẩn bị : ................................................................................................................... 559
Phần cứng cần chuẩn bị: ................................................................................................................... 560
Lắp mạch nguyên lý: ......................................................................................................................... 560
Code chƣơng trình: ........................................................................................................................... 560
Hình ảnh thực tế: ............................................................................................................................... 562
42. Thiết kế mô hình điều khiển góc quay động cơ bƣớc bằng cảm biến ánh sáng
khi trời tối hoặc trời sáng. ......................................................................................... 562
Mục tiêu: ........................................................................................................................................... 562
Phần mền cần chuẩn bị...................................................................................................................... 563
Phần cứng cần chuẩn bị: ................................................................................................................... 563
Lắp mạch nguyên lý: ......................................................................................................................... 563
Code chƣơng trình: ........................................................................................................................... 563
Hình ảnh thực tế: ............................................................................................................................... 564
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: 0395 304 802
29
43. Thiết kế mô hình đo tốc độ động cơ hiển thị lên màn hình LCD sử dụng
encorder quay và board arduino. ............................................................................. 565
Mục tiêu: ........................................................................................................................................... 565
Phần mền cần chuẩn bị...................................................................................................................... 565
Phần cứng cần chuẩn bị: ................................................................................................................... 565
Lắp mạch nguyên lý: ......................................................................................................................... 566
Code chƣơng trình: ........................................................................................................................... 566
Hình ảnh thực tế: ............................................................................................................................... 569
44. Thiết kế mô hình bật tắt thiết bị điện sử dụng cảm biến vân tay và board
arduino. ....................................................................................................................... 570
Mục tiêu: ........................................................................................................................................... 570
Phần mền cần chuẩn bị...................................................................................................................... 570
Phần cứng cần chuẩn bị: ................................................................................................................... 570
Lắp mạch nguyên lý: ......................................................................................................................... 570
Code chƣơng trình: ........................................................................................................................... 571
Hình ảnh thực tế: ............................................................................................................................... 572
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: 0395 304 802
30
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:
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: 0395 304 802
31
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
Kỹ Năng
• 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,…
• 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 ).
Đối Tƣợng
• Chỉ dành cho những giới • Dành cho giới chuyên ngành,
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
• Thời gian hoàn thành rất • Thời gian hoàn thành rất
nhanh.
lâu 1 tuần, có thể từ 1 đến
2 tháng.
• Thời gian chủ yếu tập trung
• 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
tạp hơn.
để phát triển quy mô hệ
thống.
Phát Triển
• Phát triển đƣợc kỹ năng • Phát triển đƣợc tƣ duy lập
trình hệ thống.
thiết kế mạch, in mạch,
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.
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: 0395 304 802
32
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.
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: 0395 304 802
33
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:
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: 0395 304 802
34
Mô hình máy bay 4 cánh:
Máy in 3D:
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: 0395 304 802
35
Nhà thông minh:
Hệ thống tƣới cây thông minh.
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: 0395 304 802
36
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.
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: 0395 304 802
37
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
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: 0395 304 802
38
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.
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: 0395 304 802
39
• 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
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: 0395 304 802
40
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.
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: 0395 304 802
41
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.
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: 0395 304 802
42
4. Một số bộ KIT TỰ HỌC ARDUINO:
• Kit Tự Học Arduino Uno R3 Cơ Bản các bạn có thể xem chi tết TẠI
ĐÂY.
• Kit Tự Học Arduino Uno R3 Nâng Cao các bạn có thể xem chi tết TẠI
ĐÂY.
• Kit Tự Học Arduino Mega 2560 Cơ Bản các bạn có thể xem chi tết TẠI
ĐÂY.
• Kit Tự Học Arduino Mega 2560 Nâng Cao 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 Uno và Mega khác nhau ở chổ ( Bộ Uno sử dụng
board Arduino Uno R3 Còn Bộ Mega sử dụng board Arduino 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/jre8downloads-2133155.html
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: 0395 304 802
43
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-arduinoide-cap-nhat-phien-ban-moi-nhat
Hoặc: https://www.arduino.cc/en/Main/Software
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: 0395 304 802
44
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
động Arduino IDE.
trong
thƣ
mục arduino-1.8.5\ để
khởi
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: 0395 304 802
45
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 dpinstamd64.exe (Windows x64) trong thƣ mục driver của file phần mềm IDE mình tải
về.
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: 0395 304 802
46
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‖
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: 0395 304 802
47
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:
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: 0395 304 802
48
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.
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: 0395 304 802
49
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
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: 0395 304 802
50

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
CH340
IC nạp và giao tiếp UART
5V - DC
Điện áp hoạt động
Điện áp đầu vào khuyên dùng 7-12V - DC
6-20V - DC
Điện áp đầu vào giới hạn
14 (trong đó có 6 chân PWM)
Số chân Digital I/O
8 (độ phân giải 10bit, nhiều hơn Arduino Uno 2 chân)
Số chân Analog
Dòng tối đa trên mỗi chân I/O 40mA
32KB với 2KB dùng bởi bootloader
Bộ nhớ flash
2KB
SRAM
1KB
EEPROM
16MHz
Xung nhịp
0.73" x 1.70"
Kích thƣớc
45mm
Chiều dài
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: 0395 304 802
51
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)
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: 0395 304 802
52
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
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: 0395 304 802
53
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é
https://drive.google.com/open?id=1fijv7fv4aFuKBmK6pkBk9QXZQJHdsCVs
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: 0395 304 802
54
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ý:
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: 0395 304 802
55
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.
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: 0395 304 802
56
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()
{
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: 0395 304 802
57
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.
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: 0395 304 802
58
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).
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: 0395 304 802
59
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);
}
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: 0395 304 802
60
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ó.
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: 0395 304 802
61
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.)
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: 0395 304 802
62

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_INTERNAL1V65: Đặt lại mức điện áp tối đa 1.65V

AR_INTERNAL2V23: Đặt lại mức điện áp tối đa 2.23V

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ó
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: 0395 304 802
63
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() {
}
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: 0395 304 802
64
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.
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: 0395 304 802
65
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));
analogReadResolution(12);
Serial.print(", 12-bit : ");
Serial.print(analogRead(A0));
analogReadResolution(16);
Serial.print(", 16-bit : ");
Serial.print(analogRead(A0));
/
analogReadResolution(8);
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: 0395 304 802
66
Serial.print(", 8-bit : ");
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.
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: 0395 304 802
67
 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);
pinMode(12, OUTPUT);
pinMode(13, 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
analogWriteResolution(12);
analogWrite(12, map(sensorVal, 0, 1023, 0, 4095));
Serial.print(" , 12-bit PWM value : ");
Serial.print(map(sensorVal, 0, 1023, 0, 4095));
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: 0395 304 802
68
analogWriteResolution(4);
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.
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: 0395 304 802
69
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)
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: 0395 304 802
70
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)
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: 0395 304 802
71
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
*/
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: 0395 304 802
72
//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
}
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: 0395 304 802
73
//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.
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: 0395 304 802
74
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ó
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: 0395 304 802
75
Ví dụ
int ledPin = 13; // LED pin 13
void setup()
{
pinMode(ledPin, OUTPUT);
}
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()
{
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: 0395 304 802
76
pinMode(outPin, OUTPUT);
}
void loop()
{
digitalWrite(outPin, HIGH);
delayMicroseconds(50);
digitalWrite(outPin, LOW);
delayMicroseconds(50);
}
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);
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: 0395 304 802
77
}
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(){
Serial.print("Time: ");
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
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: 0395 304 802
78
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();
pinMode(ledPin, OUTPUT);
digitalWrite(ledPin, LOW);
}
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)
{
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
// cập nhật lại biến time
time = millis();
}
}
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: 0395 304 802
79
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)
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: 0395 304 802
80
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
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: 0395 304 802
81
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
đó).
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: 0395 304 802
82
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
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: 0395 304 802
83
//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)
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: 0395 304 802
84
Tham số
rad: góc ở đơn vị radian (kiểu float)
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ố
rad: góc ở đơn vị radian (kiểu float)
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.
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: 0395 304 802
85
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.
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: 0395 304 802
86
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, ...
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: 0395 304 802
87
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
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: 0395 304 802
88
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ố
x: một số nguyên thuộc bất cứ kiểu số nguyên nào
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)
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: 0395 304 802
89
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ố
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.
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
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: 0395 304 802
90
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ố
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ụ
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 ý:
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: 0395 304 802
91
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
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: 0395 304 802
92
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
}
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: 0395 304 802
93
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
}
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: 0395 304 802
94
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);
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: 0395 304 802
95
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ụ
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: 0395 304 802
96
int ledPin = 12;
void tatled()
{
// tắt đèn led khi nhấn nút, nhả ra led nhấp nháy trở lại
digitalWrite(ledPin, LOW);
}
void setup()
{
pinMode(ledPin, OUTPUT);
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
digitalWrite(ledPin, HIGH);
delay(500);
digitalWrite(ledPin, LOW);
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);
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: 0395 304 802
97
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
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: 0395 304 802
98
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!
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: 0395 304 802
99
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)
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: 0395 304 802
100
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)
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: 0395 304 802
101
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;
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: 0395 304 802
102
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)
Kiểu tham trị 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);
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: 0395 304 802
103
//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 )
Kiểu tham trị 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);
//Serial.println(c2);
}
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: 0395 304 802
104
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)
Kiểu tham trị 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() { ; }
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: 0395 304 802
105
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)
Kiểu tham trị 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.
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: 0395 304 802
106
Cú pháp
int toupper(int c)
Kiểu tham trị 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)
Kiểu tham trị c:
int
Kiểu trả về:
bool (true/ false)
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: 0395 304 802
107
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);
//Serial.println(c2);
}
void loop() { ; }
II.
GIÁ TRỊ :
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: 0395 304 802
108
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
10.0
10
2.34E5
2.34 * 105
234000
67e-12
67.0 * 10-12
0.000000000067
Giá trị
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;
}
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: 0395 304 802
109
Ở đâ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ụ
10 (thập phân)
159
2 (nhị phân)
B1111011
bắt đầu bằng 'B'
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
bắt đầu bằng '0x'
biểu thị bằng các chữ số từ 0-9 và kí tự
từ A-F (hoặc a-f)
16 (thập lục phân) 0x7B
Định dạng
Ghi chú
biểu thị bằng các chữ số từ 0 đến 9
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
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: 0395 304 802
110
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
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: 0395 304 802
111
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.
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: 0395 304 802
112
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() {
pinMode(led, OUTPUT);
}
void loop() {
digitalWrite(led, HIGH);
delay(1000);
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: 0395 304 802
113
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
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().
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: 0395 304 802
114
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
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().
Để 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.
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: 0395 304 802
115
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() {
pinMode(led, OUTPUT);
}
void loop() {
blink();
}
void blink() {
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: 0395 304 802
116
digitalWrite(led, LOW);
delay(3000);
digitalWrite(led, HIGH);
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() {
pinMode(led, OUTPUT);
led_status = true; // led ở trạng thái bật
}
void loop() {
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: 0395 304 802
117
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
Arduino. Kiểu int chiếm 2 byte bộ nhớ !
đƣợc
dùng
trong
chƣơng
trì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ớ)
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: 0395 304 802
118
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 (2 32 - 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)
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: 0395 304 802
119
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
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: 0395 304 802
120
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);
}
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: 0395 304 802
121
void loop()
{
Serial.print("Time: ");
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 .)
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: 0395 304 802
122
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.
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: 0395 304 802
123
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
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: 0395 304 802
124
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)
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: 0395 304 802
125
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);
}
}
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: 0395 304 802
126
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ố
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 byte
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: 0395 304 802
127
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ố
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 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ố
x: là một giá trị thuộc bất kỳ kiểu dữ liệu nào
8bitDauTien, 8bitSauCung: là giá trị kiểu byte
Trả về
Giá trị thuộc kiểu word
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: 0395 304 802
128
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ố
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 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ố
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 float
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: 0395 304 802
129
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;
nó
pi = 7;
// bạn có thể dụng hằng số pi trong tính toán - vì đơn giản bạn chỉ đọc
// 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ộ:
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: 0395 304 802
130


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ộ!
}
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: 0395 304 802
131
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() {
pinMode(led, OUTPUT);
}
void loop() {
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
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:
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
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: 0395 304 802
132
digitalWrite(led, HIGH);
delay(1000);
……
2. Toán tử logic:
Toán tử
and
(&&)
Ý nghĩa
Và
or ( || )
Hoặc
not ( ! )
Phủ định
xor (^)
Loại trừ
Ví dụ
(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
(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
nếu a mang giá trị TRUE thì (!a) là FALSE và
ngƣợc lại
(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.
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: 0395 304 802
133
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]) {
[câu lệnh 1]
} else {
[câu lệnh 2]
}
//biểu thức điều kiện
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
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: 0395 304 802
134
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
}
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: 0395 304 802
135
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
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: 0395 304 802
136
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>) {
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: 0395 304 802
137
<đ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;
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: 0395 304 802
138
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
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: 0395 304 802
139
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 đó
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: 0395 304 802
140
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.
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: 0395 304 802
141
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 = 9 % 5;
x = 5 % 5;
x = 4 % 5;
// x bây giờ là 2
// x bây giờ là 4
// x bây giờ là 0
// 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() {}
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: 0395 304 802
142
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,...)
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: 0395 304 802
143
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>
}
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: 0395 304 802
144
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);
}
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: 0395 304 802
145
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]>
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: 0395 304 802
146
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;
y = x--;
// x bây giờ có giá trị là 3, và y cũng có giá trị là 3
// x bây giờ đã trở lại với giá trị 2, nhƣng y không đổi vẫn là 3
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: 0395 304 802
147
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
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: 0395 304 802
148
C. CẤU TRÚC CHƢƠNG 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
CÁCH THÊM THƢ VIỆN VÀO IDE.
VÀ
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.
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: 0395 304 802
149
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.
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: 0395 304 802
150

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,...
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: 0395 304 802
151

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.)
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: 0395 304 802
152
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:
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: 0395 304 802
153
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
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: 0395 304 802
154
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.
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: 0395 304 802
155
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()
pinMode(12, OUTPUT);
Để 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);
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: 0395 304 802
156
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() {
pinMode(12, OUTPUT);
}
// 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);
delay(2000);
// tắt đèn led
// dừng chƣơng trình trong 2 giây => thấy đèn tối đƣợc 2 giây
}
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: 0395 304 802
157
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
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: 0395 304 802
158
Hình ảnh thực tế:
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:
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.
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
pinMode(led, OUTPUT);
}
void loop() {
//xuất giá trị độ sáng đèn LED
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: 0395 304 802
159
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:
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: 0395 304 802
160
Hình ảnh thực tế:
Code 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
bên dƣới chỉ dƣới dạng giải thích.
// chƣơng trình điều khiển đèn giao thông
int red = 8;
int yellow = 9;
int green = 10;
void setup(){
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: 0395 304 802
161
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
}
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: 0395 304 802
162
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.
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: 0395 304 802
163
Lắp mạch:
Code chương 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
bên dƣới chỉ dƣới dạng giải thích.
// 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() {
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: 0395 304 802
164
digitalWrite(role, HIGH); // bật role trong 10 giay
delay(10000);
digitalWrite(role, LOW);
// tắt role trong 4 giây
delay(4000);
}
Hình ảnh thực tế:
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ơ
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: 0395 304 802
165
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.
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: 0395 304 802
166
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.
Phần cứng chuẩn bị:
 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.
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: 0395 304 802
167
Lắp mạch:
Code chương 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
bên dƣới chỉ dƣới dạng giải thí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
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: 0395 304 802
168
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
tt n 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 l ại
tt n:
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).
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: 0395 304 802
169
utton (thường ( mm ho 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ƣ!
utton 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.
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: 0395 304 802
170
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).
Phần cứng chuẩn bị:




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).
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: 0395 304 802
171
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 :
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: 0395 304 802
172
Hình ảnh thực tế:
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
bên dƣới chỉ dƣới dạng giải thích.
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
}
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: 0395 304 802
173
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.
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: 0395 304 802
174
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.
Phần cứng chuẩn bị:




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).
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn nút nhấn :
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: 0395 304 802
175
Hình ảnh thực tế:
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
bên dƣới chỉ dƣới dạng giải thích.
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()
{
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: 0395 304 802
176
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.
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: 0395 304 802
177
8. Bật tắt LED khi nhấn nút nhấn.
Phần cứng chuẩn bị:






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).
1 trở 220 Ohm hoặc 470 Ohm.
1 led đơn.
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn nút nhấn :
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: 0395 304 802
178
Hình ảnh thực tế:
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
bên dƣới chỉ dƣới dạng giải thích.
int nutnhan = 8;
// định nghĩa chân số 0 là button
int led = 9, t=0;
// khai báo led và 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()
{
Serial.begin(9600);
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: 0395 304 802
179
pinMode(nutnhan,INPUT);
pinMode(led,OUTPUT);
}
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();}
}
if(t==1)
{
digitalWrite(led,HIGH);
}
else
{
digitalWrite(led,LOW);
}
}
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: 0395 304 802
180
9. Bật tắt rơ le khi nhấn nút nhấn.
Phần cứng chuẩn bị:





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).
1 rơ le kích mức cao.
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn nút nhấn :
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: 0395 304 802
181
Hình ảnh thực tế:
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
bên dƣới chỉ dƣới dạng giải thích.
int nutnhan = 8;
// định nghĩa chân số 0 là button
int role = 9, t=0;
// khai báo led và 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
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: 0395 304 802
182
}
// khởi tạo
void setup()
{
Serial.begin(9600);
pinMode(nutnhan,INPUT);
pinMode(led,OUTPUT);
}
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();}
}
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.
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: 0395 304 802
183
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).
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: 0395 304 802
184
Để 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.
Phần cứng chuẩn bị:





Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
Dây test board.
Điện trở 220 Ω.
1 led 7 đoạn đơn.
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: 0395 304 802
185
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn nút nhấn :
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
bên dƣới chỉ dƣới dạng giải thích.
// 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
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: 0395 304 802
186
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);
}
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: 0395 304 802
187
Hình ảnh thực tế:
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: 0395 304 802
188
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.
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: 0395 304 802
189
Phần cứng chuẩn bị:





Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard
1 biến tở 10k.
1 module 4 led 7 đoạn loại dƣơng chung.
Dây cắm test board.
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.
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: 0395 304 802
190
Hình ảnh thực tế:
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
bên dƣới chỉ dƣới dạng giải thích.
#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;
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: 0395 304 802
191
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
}
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: 0395 304 802
192
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




Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard
1 module led ma trận 8x8 loại dƣơng chung.
Dây cắm test board.
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: 0395 304 802
193
Lắp mạch( nếu các bạn đã có kit học thì đã lắp sẵn :
Hình ảnh thực tế:
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
bên dƣới chỉ dƣới dạng giải thích.
const int row[8] = {
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: 0395 304 802
194
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},
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: 0395 304 802
195
{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}
};
const charMapType heart1 = {
{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}
};
const charMapType heart2 = {
……………………………………………………………………………..
digitalWrite(col[thisPin], HIGH);
}
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: 0395 304 802
196
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;
}
}
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: 0395 304 802
197
}
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);
}
}
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: 0395 304 802
198
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 đề đó.
Phần cứng chuẩn bị: ( tất cả được tích hợp trên Kit Tự Học





Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard
1 module LCD 16x02.
Dây cắm test board.
1 biến trở 10K.
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: 0395 304 802
199
Lắp mạch( nếu các bạn đã có kit học thì chỉ việc nối dây):
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: 0395 304 802
200
Hình ảnh thực tế:
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
bên dƣới chỉ dƣới dạng giải thích.
#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ở
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: 0395 304 802
201
gắn trên module.
Đây chính là Module chuyển giao tiếp I2C
Phần cứng chuẩn bị: ( tất cả được tích hợp trên Kit Tự Học





Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard
1 module LCD 16x02.
1 module I2C cho LCD.
Dây cắm test board.
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
Lắp mạch( nếu các bạn đã có kit học thì chỉ việc nối dây):
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: 0395 304 802
202
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:
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.
// 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()
{
}
Hình ảnh thực tế:
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: 0395 304 802
203
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.
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: 0395 304 802
204
Phần cứng chuẩn bị: (được tích hợp trên Kit Tự Học





Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
1 quang trở.
1 điện trở 10K.
Dây cắm test board.
Lắp mạch( nếu các bạn đã có kit học thì chỉ việc nối dây):
Hình ảnh thực tế:
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: 0395 304 802
205
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
}
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: 0395 304 802
206
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...
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: 0395 304 802
207
Phần cứng chuẩn bị:




Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
1 cảm biến nhiệt độ LM35.
Dây cắm test board.
Lắp mạch:
Hình ảnh thực tế:
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
bên dƣới chỉ dƣới dạng giải thích.
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: 0395 304 802
208
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.
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: 0395 304 802
209
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
Phần cứng chuẩn bị:





Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
1 cảm biến nhiệt độ DS18b20.
1 điện trở 4.7K.
Dây cắm test board.
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: 0395 304 802
210
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
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: 0395 304 802
211
Ta bắt tay vào lập trình sau khi add xong 2 thƣ viện trên.
Code chƣơng 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
bên dƣới chỉ dƣới dạng giải thích.
#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é.
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: 0395 304 802
212
18.
Hiển thị giá trị CB nhiệt độ LM35 lên mà hình LCD.
Phần cứng chuẩn bị:






Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
1 cảm biến nhiệt độ LM35.
Dây cắm test board.
1 Module I2C cho LCD.
1 LCD 16x02.
Lắp mạch :
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
bên dƣới chỉ dƣới dạng giải thích.
#include <Wire.h>
#include <LiquidCrystal_I2C.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();
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: 0395 304 802
213
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.setCursor(5, 1);
lcd.print(temp);
delay(1000); //đợi 1 giây cho lần đọc tiếp theo
}
Hình ảnh thực tế:
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: 0395 304 802
214
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.
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: 0395 304 802
215
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).
Phần cứng chuẩn bị:


Mạch Arduino (ở đây mình sử dụng Arduino UNO).
1 cảm biến mƣa.
Lắp mạch :
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
bên dƣới chỉ dƣới dạng giải thích.
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
}
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: 0395 304 802
216
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.
}
Hình ảnh thực tế:
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: 0395 304 802
217
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.
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: 0395 304 802
218
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
Phần cứng chuẩn bị:




Mạch Arduino (ở đây mình sử dụng Arduino UNO).
1 cảm biến SRF05.
Breadboard còn gọi testboard.
Dây cắm test board.
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.
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: 0395 304 802
219
• Echo: nối với PIN 7.
Hình ảnh thực tế:
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: 0395 304 802
220
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
bên dƣới chỉ dƣới dạng giải thích.
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
delayMicroseconds(2);
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.
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: 0395 304 802
221
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.
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: 0395 304 802
222
Thông số kỹ thuật:




Đ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





Mạch Arduino (ở đây mình sử dụng Arduino UNO).
1 cảm biến độ ẩm đất.
Breadboard còn gọi testboard.
Dây cắm test board.
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.
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: 0395 304 802
223
Hình ảnh thực tế:
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,…
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: 0395 304 802
224
Serial.println("Tuoi cay");
}
//Ngƣng bơm khi đất ƣớt
else
{
digitalWrite(role,LOW);
Serial.println("Cay du nuoc");
}
delay(1000);
}
Kết quả hiển thị lên Serial monitor :
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.
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: 0395 304 802
225
Thông số kỹ thuật:
• 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



Mạch Arduino (ở đây mình sử dụng Arduino UNO).
1 cảm biến dò line.
Breadboard còn gọi testboard.
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: 0395 304 802
226





Dây cắm test board.
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>
#include <LiquidCrystal_I2C.h>
#define den 8
// Sử dụng chân 8 để điều khiển đèn led
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: 0395 304 802
227
#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.setCursor(0, 1);
lcd.print("x =");
lcd.setCursor(5, 1);
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
}
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: 0395 304 802
228
Hình ảnh thực tế:
Kết quả hiển thị lên Serial monitor :
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: 0395 304 802
229
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




Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
Dây cắm test board.
1 biến trở xoay 10K.
Lắp mạch :
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: 0395 304 802
230
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();
delay(200);
//xuống hàng
//đợi 0.2 giây
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: 0395 304 802
231
}
Hình ảnh thực tế:
Kết quả hiển thị lên Serial monitor :
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: 0395 304 802
232
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/tonghop-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".
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: 0395 304 802
233
• 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






Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
Dây cắm test board.
1 module DS1307.
1 LCD 16x02.
1 I2C cho LCD.
Lắp mạch :
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: 0395 304 802
234
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.
#include <Wire.h>
#include "RTClib.h"
#include <LiquidCrystal_I2C.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.setCursor(0, 0);
lcd.print("H:");
lcd.setCursor(0, 1);
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.setCursor(4, 0);
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(" ");
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: 0395 304 802
235
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.setCursor(4, 1);
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);
}
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: 0395 304 802
236
Hình ảnh thực tế:
Kết quả hiển thị lên Serial monitor :
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: 0395 304 802
237
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






Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
Dây cắm test board.
1 module encoder quay.
1 LCD 16x02.
1 I2C cho LCD.
Thông số kỹ thuật:
 Đ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
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: 0395 304 802
238
Để đ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
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: 0395 304 802
239
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
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: 0395 304 802
240
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 :
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.
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:
http://tdhshop.com.vn/tong-hop-cac-thu-vien-cho-arduino
Cách add thƣ viện cho Arduino IDE : http://tdhshop.com.vn/huong-dan-caithu-vien-vao-arduino-ide-ho-tro-cho-viec-lap-trinh
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: 0395 304 802
241
#include <Wire.h>
#include <LiquidCrystal_I2C.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;
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: 0395 304 802
242
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;
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: 0395 304 802
243
rotating = false;
}
}
Hình ảnh thực tế:
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
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: 0395 304 802
244
(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 .




Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
Dây cắm test board.
1 module DHT11.
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: 0395 304 802
245





1 LCD 16x02.
1 I2C cho LCD.
2 nút nhấn.
2 điện trở 10K.
Dây cắm test board.
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).
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: 0395 304 802
246
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
bên dƣới chỉ dƣới dạng giải thích.
#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();
}
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: 0395 304 802
247
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;
}
}
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: 0395 304 802
248
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");
}
}
Hình ảnh thực tế:
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: 0395 304 802
249
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
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn .



Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
Dây cắm test board.
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: 0395 304 802
250

1 module servo SG90.
Lắp mạch:
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
bên dƣới chỉ dƣới dạng giải thích.
#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);
delay(1000);
gServo.write(90);
delay(1000);
// điều chỉnh góc xoay của servo.
// điều chỉnh góc xoay của servo.
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: 0395 304 802
251
gServo.write(180); // điều chỉnh góc xoay của servo.
delay(1000);
}
Hình ảnh thực tế:
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: 0395 304 802
252
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.
Thông số kỹ thuật:
Điện thế hoạt động
Số pha
Tỉ lệ bánh răng
Một bƣớc tƣơng đƣơng
Tần số
Điện trở trong
5V
4
*64
5.625° (64 bƣớc)
100Hz
50Ω±7%(25℃)
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn .



Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
Dây cắm test board.
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: 0395 304 802
253



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 :
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.
Độ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 IN2 9 // IN2 nối với chân D9 của arduino
#define IN3 10 // IN3 nối với chân D10 của arduino
#define IN4 11 // IN4 nối với chân D11của arduino
int Steps = 4096;
int cstep = 0;
void setup()
{
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: 0395 304 802
254
Serial.begin(9600);
pinMode(IN1, OUTPUT); // các chân IN quy định là các chân ra
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
void loop()
{
for(int x=0;x<Steps;x++)
{
step1();
//delay(1);
delayMicroseconds(2500);
}
delay(1000);
}
void step1()
{
//stepp
switch(cstep)
{
case 0:
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
break;
case 1:
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, HIGH);
break;
case 2:
………………………………
digitalWrite(IN4, LOW);
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: 0395 304 802
255
break;
}
cstep=cstep+1;
if(cstep==8)
{cstep=0;}
}
Hình ảnh thực tế:
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: 0395 304 802
256
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.
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: 0395 304 802
257
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é!
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn .







Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
Dây cắm test board.
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é!!!
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: 0395 304 802
258
Lắp mạch:
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
bên dƣới chỉ dƣới dạng giải thích.
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
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: 0395 304 802
259
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()
{
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: 0395 304 802
260
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.
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: 0395 304 802
261
Hình ảnh thực tế:
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
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: 0395 304 802
262
đ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.
Thông số kỹ thuật:
Đ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.
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn ).





Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
Dây cắm test board.
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.
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: 0395 304 802
263
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
bên dƣới chỉ dƣới dạng giải thích.
#define ENA 8 //enable A on pin 8
#define ENB 3 //enable B on pin 3
#define IN1 7 //IN1 on pin 7
#define IN2 6 //IN2 on pin 6
#define IN3 5 //IN3 on pin 5
#define IN4 4 //IN4 on pin 4
void setup()
{
pinMode(ENA, OUTPUT);
pinMode(ENB, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, 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 độ.
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: 0395 304 802
264
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:
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
analogWrite(ENB, duty);
break;
case 3:
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
analogWrite(ENB, duty);
break;
}
}
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: 0395 304 802
265
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.
Thông số kỹ thuật:









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
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: 0395 304 802
266








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
Phần cứng chuẩn bị: (bộ kit đã tích hợp sẵn .




Mạch Arduino (ở đây mình sử dụng Arduino UNO).
Breadboard còn gọi testboard.
Dây cắm test board.
1 Module wifi 8266V1.
Lắp mạch:
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: 0395 304 802
267
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
bên dƣới chỉ dƣới dạng giải thích.
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.
b.
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.
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
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: 0395 304 802
268
#define TDHshop_STRING_EMPTY ""
#define TDHshop_DELAY_SEED 1000
#define TDHshop_DELAY_1X (1*TDHshop_DELAY_SEED)
#define TDHshop_DELAY_2X (2*TDHshop_DELAY_SEED)
#define TDHshop_DELAY_3X (3*TDHshop_DELAY_SEED)
#define TDHshop_DELAY_4X (4*TDHshop_DELAY_SEED)
#define TDHshop_DELAY_0X (5*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);
}
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: 0395 304 802
269
Hình ảnh thực tế:
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:
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: 0395 304 802
270
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.
Phần cứng chuẩn bị:






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).
Breadboard còn gọi testboard.
Dây cắm test board.
1 led đơn.
1 trở 220Ohm.
Lắp mạch:
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: 0395 304 802
271
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
bên dƣới chỉ dƣới dạng giải thích.
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ả
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: 0395 304 802
272
}
// 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.
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: 0395 304 802
273
Để 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:
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.
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()
{
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: 0395 304 802
274
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);
}
Hình ảnh thực tế:
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: 0395 304 802
275
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ở.
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: 0395 304 802
276
Phần cứng chuẩn bị:
 Arduino Uno, nano,…
 Breadboard.
 Dây cắm test breadboard.
 1 biến trở 10K .
Lắp mạch:
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: 0395 304 802
277
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
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 | tham khảo //Serial
}
void loop() {
//(value luôn nằm trong khoảng 0-1023)
//xuất ra giá trị vừa đọc
Serial.println(value);
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
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: 0395 304 802
278
Phần cứng chuẩn bị:
 Arduino Uno, nano,…
 Breadboard.
 Dây cắm test breadboard.
 1 cảm biến báo cháy (CB lửa) .
Lắp mạch:
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: 0395 304 802
279
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
bên dƣới chỉ dƣới dạng giải thích.
//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
}
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: 0395 304 802
280
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.
Thông số kĩ thuật:
 Đ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).
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: 0395 304 802
281
 Hỗ trợ đèn LED bổ sung và kiểm soát ánh sáng.
Phần cứng chuẩn bị:
 Arduino Uno, nano,…
 Breadboard.
 Dây cắm test 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.
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: 0395 304 802
282
Cách thiết lập tần số cho TCS3200:
Lắp mạch:
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
bên dƣới chỉ dƣới dạng giải thích.
#define S0 4
#define S1 5
#define S2 6
#define S3 7
#define sensorOut 8
int frequency = 0;
void setup() {
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
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: 0395 304 802
283
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
// thiet lap tan so 20%
digitalWrite(S0,HIGH);
digitalWrite(S1,LOW);
Serial.begin(9600);
}
void loop() {
digitalWrite(S2,LOW);
digitalWrite(S3,LOW);
frequency = pulseIn(sensorOut, LOW);
…………………………………………………
digitalWrite(S2,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.
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: 0395 304 802
284
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.
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: 0395 304 802
285
Thông số kĩ thuật:
 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
Phần cứng chuẩn bị:
 Arduino Uno, nano,…
 Breadboard.
 Dây cắm test breadboard.
 1 cảm biến chuyển động PIR .
 1 Loa hoặc 1 LED đơn.
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: 0395 304 802
286
Lắp mạch:
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
bên dƣới chỉ dƣới dạng giải thích.
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()
{
pinMode(ledPin, OUTPUT);
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: 0395 304 802
287
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
{
digitalWrite(ledPin, LOW);
}
}
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.
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: 0395 304 802
288
Thông số kĩ thuật:
 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
Phần cứng chuẩn bị:
 Arduino Uno, nano,…
 Breadboard.
 Dây cắm test breadboard.
 1 cảm biến khí gas MQ2 .
Lắp mạch:
Arduino
MQ2
A0
VCC
GND
Aout
5V
GND
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
bên dƣới chỉ dƣới dạng giải thích.
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: 0395 304 802
289
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
//(value luôn nằm trong khoảng 0-1023)
Serial.println(value); //xuất ra giá trị vừa đọc
//----------------------------------------------------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,…
Thông số kĩ thuậ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
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: 0395 304 802
290
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
Phần cứng chuẩn bị:
 Arduino Uno, nano,…
 Breadboard.
 Dây cắm test breadboard.
 1 module Bluetooth HC05 Hoặc HC06 loại slave.
Lắp mạch:
Arduino
HC06
Tx
Rx
GND
5V
Rx
Tx
GND
VCC
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: 0395 304 802
291
Lập trình cho Arduino:
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.
int LED1 = 5;
int LED2 = 6;
int LED3 = 7;
int chucai = 'g';
void setup() {
Serial.begin(9600);
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(LED3, 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);
}
………………………………………
}
}
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: 0395 304 802
292
Viết app điều khiển thiết bị điện bằng luetooth 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)
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: 0395 304 802
293
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: 0395 304 802
294
Hình ảnh thực tế:
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.
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: 0395 304 802
295
Thông số kĩ thuật:
 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.
Phần cứng chuẩn bị:
 Arduino Uno, nano,…
 Dây cắm test breadboard.
 1 module led 8x8 sử dụng IC MAX7219.
Lắp mạch:
Arduino
Module led 8x8
10
11
13
5V
GND
CS
DIN
CLK
VCC
GND
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
bên dƣới chỉ dƣới dạng giải thích.
#include <SPI.h>
#include <Adafruit_GFX.h>
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: 0395 304 802
296
#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);
}
}
Hình ảnh thực tế:
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: 0395 304 802
297
41.
Đo Tốc Độ Động Cơ ằ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.
Phần cứng chuẩn bị:




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:
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: 0395 304 802
298
Thông số kĩ thuật:






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.
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: 0395 304 802
299
Lắp mạch:
Arduino
Module IR FC03
5VDC
GND
2
VCC
GND
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); //
}
}
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: 0395 304 802
300
42.
Điều khiển RGB LED sử dụng Module Bluetooth HC05 .
Giới thiệu:
Phần cứng chuẩn bị:





Mạch Arduino Uno, Nano,…
Breadboard .
Dây cắm test board.
1 led 3 màu dƣơng chung ( anode).
3 điện trở 220Ohm.
Lắp mạch:
Arduino
RGB LED
Bluetooth HC05
5VDC
GND
2
Tx
Rx
VCC
GND
D0
VCC
GND
Rx
Tx
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: 0395 304 802
301
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);
}
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: 0395 304 802
302
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
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: 0395 304 802
303
43.
Làm game với led ma trận 8x8 Max7219 .
Phần cứng chuẩn bị:





Mạch Arduino Uno, Nano,…
Breadboard .
Dây cắm test board.
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
10
12
11
5V
GND
A0
CS
DIN
CLK
VCC
GND
Biến trở
1
3
2(chân giữa)
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: 0395 304 802
304
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
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: 0395 304 802
305
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
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() {
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: 0395 304 802
306
timer.update();
setPad();
debug("LOOSE");
gameOver();
newGame();
}
delay(GAME_DELAY);
}
Hình ảnh thực tế:
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: 0395 304 802
307
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)).
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: 0395 304 802
308
Lắp mạch:
Arduino
Module keypad 4x4
5
6
7
8
9
10
11
12
R1
R2
R3
R4
C1
C2
C3
C4
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
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
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: 0395 304 802
309
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);
}
Hình ảnh thực tế:
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: 0395 304 802
310
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.
Phần cứng chuẩn bị:


Mạch Arduino Uno, Nano,…
1 module enthernet shiled. ( phải có cáp mạng LAN RJ45 nối từ Router wifi
đến module enthernet shiled ).
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: 0395 304 802
311




Breadboard .
Dây cắm test board.
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:
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, thƣ viện Ethernet đã có sẵn trong ide.
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: 0395 304 802
312
#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);
void setup() {
// giá trị port là 80
Serial.begin(9600);
while (!Serial) {
;
}
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, 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.
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: 0395 304 802
313
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.
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: 0395 304 802
314
Phần cứng chuẩn bị:



Mạch Arduino Uno, Nano,…
1 module cảm biến áp suất BM180.
Dây cắm test board.
Lắp mạch:
Arduino
Module BM180
3.3V
GND
A4
A5
Vin
GND
SDA
SCL
Lập trình:
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: 0395 304 802
315
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:
http://tdhshop.com.vn/tong-hop-cac-thu-vien-cho-arduino
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.
#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);
}
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: 0395 304 802
316
Hình ảnh thực tế:
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é.
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: 0395 304 802
317
47.
Chạy chữ trên led ma trận 8x8 sử dụng Bluetooth HC05.
Phần cứng chuẩn bị:





Mạch Arduino Uno, Nano,…
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
GND
5
6
7
8
9
VCC
GND
CS
CLK
DIN
VCC
GND
TX
RX
Lập trình cho arduino:
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. 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, // #
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: 0395 304 802
318
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;
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: 0395 304 802
319
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.
Phần cứng chuẩn bị:




Mạch Arduino Uno, Nano,…
Dây cắm Breadboard .
Breadboard.
1 dãy led WS2812b gồm 10 led.
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: 0395 304 802
320
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
GND
D7
VCC
GND
Din
(5 VDC)
GND
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: 0395 304 802
321
Lập trình cho arduino:
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 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);
}
}
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: 0395 304 802
322
49.
Mô phỏng hệ thống radar bằng cảm biến siêu âm SRF05.
Phần cứng chuẩn bị:





Mạch Arduino Uno, Nano,…
Dây cắm Breadboard .
Breadboard.
1 động cơ servo SG90.
1 cảm biến siêu âm srf05.
Lắp mạch:
Arduino
SRF05
SERVO
5VDC
GND
12
10
11
VCC
GND
VCC
GND
S
TRIG
ECHO
Lập trình cho arduino:
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.
#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(".");
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: 0395 304 802
323
}
}
// Hàm tính khoảng cách bằng siêu âm
int calculateDistance(){
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
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:
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: 0395 304 802
324
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.
Hình ảnh thực tế:
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: 0395 304 802
325
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ơ.
Thông số kĩ thuật:
 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.
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: 0395 304 802
326
Lắp mạch:
Arduino
Module role SSR
5VDC
GND
6
VCC
GND
CH1
Lập trình cho arduino:
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.
// 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() {
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: 0395 304 802
327
digitalWrite(6, HIGH); // TAT ROLE
delay(4000);
// DOI 4 GIAY
digitalWrite(6, LOW); // BAT ROLE
delay(2000);
// DOI 2 GIAY
}
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: 0395 304 802
328
D. IOT ( Internet Of Things )
I.
Khái niệm Internet Of Things ( IOT) là gì?.
1. Khái niệm IOT
Internet of Things (IoT) - Mạng lƣới vạn vật kết nối Internet là một kịch bản
của thế giới, khi mà mỗi đồ vật, con ngƣời đƣợc cung cấp một định danh của riêng
mình, và tất cả có khả năng truyền tải, trao đổi thông tin, dữ liệu qua một mạng
duy nhất mà không cần đến sự tƣơng tác trực tiếp giữa ngƣời với ngƣời, hay ngƣời
với máy tính. IoT đã phát triển từ sự hội tụ của công nghệ không dây, công nghệ vi
cơ điện tử và Internet. Nói đơn giản là một tập hợp các thiết bị có khả năng kết nối
với nhau, với Internet và với thế giới bên ngoài để thực hiện một công việc nào
đó. ( Wikipedia).
Hiểu đơn giản, IoT có thể khiến mọi vật giờ đây có thể giao tiếp với nhau dễ dàng
hơn và ƣu điểm lớn nhất của ―Thông minh‖ là khả năng phòng ngừa và cảnh báo tại
bất kì đâu.
2. Những ứng dụng thực tế trong cuộc sống
Những ứng dụng của IoT vào các lĩnh vực trong đời sống là vô cùng phong phú và
đa dạng. Chúng ta sẽ cùng điểm qua một số ứng dụng điển hình của IoT:

Smart Home - Theo thống kê, smart home là ứng dụng liên quan đến IoT đƣợc
tìm kiếm nhiều nhất trên Google. Smart Home là 1 ngôi nhà với rất nhiều tính
năng tự động nhƣ bật máy điều không khí khi bạn sắp về tới nhà, tắt đèn ngay khi
bạn rời khỏi nhà, mở khóa khi ngƣời thân trong gia đình đang ở cửa nhà, mở
garage khi bạn lái xe đi làm về … còn rất nhiều những tính năng giúp nâng cao
chất lƣợng cuộc sống khi sử dụng smart home.
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: 0395 304 802
329

Vật dụng mang theo trên ngƣời - Có thể kể đến một số thiết bị nhƣ Dashbon
Mask, đây là 1 chiếc smart headphone giúp bạn vừa có thể nghe nhạc với âm
thanh có độ trung thực cao vừa có thể xem phim HD với máy chiếu ảo ,
hoặc AMPL SmartBag ba lô có pin dự phòng có thể sạc điện cho các thiết bị di
động, kể cả máy tính.
3. ESP8266 dòng chip đƣợc sử dụng phổ biến nhất hiện nay trong IOT.
ESP8266 là dòng chip tích hợp Wi-Fi 2.4Ghz có thể lập trình đƣợc, rẻ tiền đƣợc
sản xuất bởi một công ty bán dẫn Trung Quốc: Espressif Systems. Đƣợc phát hành
đầu tiên vào tháng 8 năm 2014, đóng gói đƣa ra thị trƣờng dạng
Mô dun ESP-01, đƣợc sản xuất bởi bên thứ 3: AI-Thinker. Có khả năng kết nối
Internet qua mạng Wi-Fi một cách nhanh chóng và sử dụng rất ít linh kiện đi kèm.
Với giá cả có thể nói là rất rẻ so với tính năng và khả năng ESP8266 có thể làm
đƣợc. ESP8266 có một cộng đồng các nhà phát triển trên thế giới rất lớn, cung cấp
nhiều Module lập trình mã nguồn mở giúp nhiều ngƣời có thể tiếp cận và xây dựng
ứng dụng rất nhanh. Hiện nay tất cả các dòng chip ESP8266 trên thị trƣờng đều
mang nhãn ESP8266EX, là phiên bản nâng cấp của ESP8266
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: 0395 304 802
330
4. Module và Board phát triển của ESP8266.
ESP8266 cần một số linh kiện nữa mới có thể hoạt động, trong đó phần khó nhất
là Anten. Đòi hỏi phải đƣợc sản xuất, kiểm tra với các thiết bị hiện đại. Do đó, trên
thị trƣờng xuất hiện nhiều Module và Board mạch phát triển đảm đƣơng hết để ngƣời
dùng đơn giản nhất trong việc phát triển ứng dụng. Một số Module và Board phát
triển phổ biến:
Hiện nay phiên bản sử dụng phổ biến nhất là ESP8266 12E.
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: 0395 304 802
331
5. Giới thiệu về module ESP 12E( NodeMCU V1).
NodeMCU v1.0 Lua - ESP8266 ESP12E
Sơ đồ chân của ESP12E
NodeMCU V1.0 đƣợc phát triển dựa trên Chip WiFi ESP8266EX bên trong
Module ESP-12E dễ dàng kết nối WiFi với một vài thao tác. Board còn tích hợp IC
CP2102, giúp dễ dàng giao tiếp với máy tính thông qua Micro USB để thao tác với
board. Và có sẳn nút nhấn, led để tiện qua quá trình học, nghiên cứu.
Với kích thƣớc nhỏ gọn, linh hoạt board dễ dàng liên kết với các thiết bị ngoại vi
để tạo thành project, sản phẩm mẫu một cách nhanh chóng.
Thông số kỹ thuật:

Chip: ESP8266EX

WiFi: 2.4 GHz hỗ trợ chuẩn 802.11 b/g/n

Điện áp hoạt động: 3.3V

Điện áp vào: 5V thông qua cổng USB

Số chân I/O: 11 (tất cả các chân I/O đều có Interrupt/PWM/I2C/One-wire,
trừ chân D0)

Số chân Analog Input: 1 (điện áp vào tối đa 3.3V)

Bộ nhớ Flash: 4MB

Giao tiếp: Cable Micro USB

Hỗ trợ bảo mật: WPA/WPA2
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: 0395 304 802
332

Tích hợp giao thức TCP/IP
Lập trình trên các ngôn ngữ: C/C++, Micropython, NodeMCU - Lua

6. Lập trình ESP 12E bằng Arduino IDE.
Giới thiệu về ESP826612E:
Để bắt đầu với những dự án Wifi các bạn cần ESP8266 với giá thành rẻ, và dễ dàng sử
dụng. Đặc biệt ESP8266 12E có thể đƣợc lập trình bằng Arduino IDE. Trƣớc khi bắt đầu
những chuỗi dự án với ESP8266, ở bài viết này, mình sẽ chia sẻ cách cài đặt Arduino
IDE để nạp code cho ESP8266.
Chuẩn bị phần cứng:

1 x ESP8266 V12 hoặc V12E đã tích hợp sẵn mạch nạp.
Cài đặt phần mềm arduino IDE và thƣ viện cho esp8266.
Sau khi tải phần mềm Arduino IDE, các bạn tiến hành cài đặt nhƣ bình thƣờng và
mở chƣơng trình lên. Và các bạn nhớ cài driver cho nó nhé.( file driver có sẵn
trong file cài).
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: 0395 304 802
333
Để tiến hành cài đặt thƣ viện và chức năng nạp code cho IDE các bạn làm nhƣ sau:
Vào File→ Preferences, vào textbox Additional Board Manager URLs thêm đƣờng
link sau vào
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Click OK để chấp nhận.
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: 0395 304 802
334
Tiếp theo vào Tool→Board→Boards Manager
Đợi một lát để chƣơng trình tìm kiếm. Ta kéo xuống và click vào ESP8266 by
ESP8266 Community, click vào Install. Chờ phần mềm tự động download và cài
đặt.
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: 0395 304 802
335
Hướng dẫn nạp chương trình cho ESP8266 12E:
Kết nối mudule ESP8266 -12E vào máy tính. Vào Tool→Board→NodeMCU 1.0, chọn
cổng COM tƣơng ứng với module tƣơng ứng.
Chọn chế độ nạp Arduino as ISP và chọn cổng COM cho đúng nhé.Vậy là ta đã có môi
trƣờng lập trình cho esp8266 rất thân thiện.
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: 0395 304 802
336
Sau khi kết nối ESP8266 với máy tính, các bạn có thể test code ESP8266 ở đây:
Code ở dƣới test led trên board esp8266 12E ở chân 13 (D7 ) sáng tắt trong vòng 1 giây.
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH); // bật led sáng 1 giây
delay(1000);
// wait for a second
digitalWrite(LED_BUILTIN, LOW); // tắt led 1 giây
delay(1000);
// wait for a second
}
Hình ảnh thực tế:
Từ ví dụ đơn giản ở trên ta có thể bắt tay vào học lập trình cho ESP để làm những
dự dán IOT có ứng dụng cao.
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: 0395 304 802
337
II. Bài học mẫu cơ bản lập trình cho ESP12E.
1. Bật tắt led theo ý muốn bằng esp8266 12E.
Chuẩn bị phần cứng:
 1 x ESP8266 V12 hoặc V12E đã tích hợp sẵn mạch nạp ( Trong ví bài viết
này tôi sử dụng ESP8266-V12E)
 1 breadboard.
 1 led.
 1 điện trở 220 Ohm.
Lắp mạch:
 Chân ( + ) của led đƣợc nối chân D3 ( tƣơng ứng với chân số GPIO0 )
 Chân ( -- ) của led đƣợc nối chân GND của ESP.
Lập trình:
void setup() {
// initialize digital pin 0 ( D3 ) as an output.
pinMode(0, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(0, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000);
// wait for a second
digitalWrite(0, LOW); // turn the LED off by making the voltage LOW
delay(1000);
// wait for a second
}
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: 0395 304 802
338
Hình ảnh thực tế:
2. Bật tắt led bằng nút nhấn ( không lƣu trạng thái).
Chuẩn bị phần cứng:
 1 x ESP8266 V12 hoặc V12E đã tích hợp sẵn mạch nạp .
 1 breadboard.
 1 led.
 1 điện trở 220 Ohm.
 1 nút nhấn 4 chân.
Lắp mạch:
 Chân ( + ) của led đƣợc nối chân D0 ( tƣơng ứng với chân số GPIO16 )
 Chân ( -- ) của led đƣợc nối chân GND của ESP.
 Chân D3 ( chân GPIO0 ) đƣợc nối với nút nhấn nhƣ hình dƣới.
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: 0395 304 802
339
Lập trình:
int ledPin = 16;
int btnPin = 0;
//int ledState = LOW;
// LED connected to digital pin 16 ( D0)
// BUTTON connected to digital pin 0 ( D3)
void setup()
{
pinMode(ledPin, OUTPUT); // sets the digital pin as output
pinMode(btnPin, INPUT);
// sets the digital pin as input
digitalWrite(btnPin, HIGH);
Serial.begin(115200);
}
void loop()
{
if(digitalRead(btnPin)==LOW)
{
digitalWrite ( ledPin, HIGH);
}
else { digitalWrite ( ledPin, LOW);}
}
Hình ảnh thực tế:
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: 0395 304 802
340
3. Bật tắt led bằng nút nhấn (lưu trạng thái).
Chuẩn bị phần cứng:
 1 x ESP8266 V12 hoặc V12E đã tích hợp sẵn mạch nạp ( Trong ví bài viết
này tôi sử dụng ESP8266-V12E)
 1 breadboard.
 1 led.
 1 điện trở 220 Ohm.
 1 nút nhấn 4 chân.
Lắp mạch:
 Chân ( + ) của led đƣợc nối chân D0 ( tƣơng ứng với chân số GPIO16 )
 Chân ( -- ) của led đƣợc nối chân GND của ESP.
 Chân D3 ( chân GPIO0 ) đƣợc nối với nút nhấn nhƣ hình dƣới.
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: 0395 304 802
341
Lập trình:
//khai báo biến
int nutnhan = 0; // định nghĩa chân số GIPO0 là button ( D3 )
int led = 16,t=0; // khai báo led và biến, 16 ( GIPO16) (tuong ung D0)
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 char float ngoại trừ void
{
int sta =!digitalRead(nutnhan); // đọc trạng thái nút nhấn
return sta;// khi co nhan nut la true
}
// khởi tạo
void setup()
{
Serial.begin(9600);
pinMode(nutnhan,INPUT);
digitalWrite(nutnhan, HIGH);
pinMode(led,OUTPUT);
}
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();}
}
if(t==1)
{
digitalWrite(led,HIGH);
}
else
{
digitalWrite(led,LOW);
}
Serial.println(t);
}
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: 0395 304 802
342
Hình ảnh thực tế:
4. Điều khiển relay bằng Esp8266 V_12E.
Chuẩn bị phần cứng:
 1 x ESP8266 V12 hoặc V12E đã tích hợp sẵn mạch nạp ( Trong ví bài viết
này tôi sử dụng ESP8266-V12E)
 1 breadboard.
 1 relay 5vd (1 hoặc 2) kênh mức cao.
Lắp mạch:
ESP8266_12E
Module Relay 5VDC
Vin
5Vdc ( + )
GND
GND (--)
GIPO16 ( D0)
1 (S) or ( IN1)
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: 0395 304 802
343
Lập trình:
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin 13 as an output.
pinMode(13, OUTPUT);// chân điều khiển relay là chân GIPO13 ( D7)
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(13, HIGH); // turn the RELAY on
delay(5000);
// wait for 5 second
digitalWrite(13, LOW); // turn the RELAY off
delay(2000);
// wait for 2 second
}
Hình ảnh thực tế:
Lƣu ý: khi ra làm mô hình thực tế nên có nguồn cấp riêng cho module relay.
5. Hiển thị lên màn hình LCD bằng ESP8266 12E.
Chuẩn bị phần cứng:
 1 x ESP8266 V12 hoặc V12E đã tích hợp sẵn mạch nạp ( Trong ví bài viết
này tôi sử dụng ESP8266-V12E)
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: 0395 304 802
344
 1 LCD + I2C
Lắp mạch:
ESP8266_12E
Module LCD + I2C
Vin
5Vdc ( + )
GND
GND (--)
D1
SCL
D2
SDA
Lập trình:
#include "ESP8266WiFi.h"
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,20,4); // set the LCD address to 0x20 for a 16 chars and 2
line display
void setup()
{
lcd.init();
// initialize the lcd
// Print a message to the LCD.
lcd.backlight();
lcd.print("Hello, world!");
}
void loop()
{
}
Hình ảnh thực tế:
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: 0395 304 802
345
6. Đọc giá trị cảm biến nhiệt độ LM35 và gửi lên thingspeak.
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 độ.
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: 0395 304 802
346
Chuẩn bị phần cứng:
 1 x ESP8266 V12 hoặc V12E đã tích hợp sẵn mạch nạp ( Trong ví bài viết
này tôi sử dụng ESP8266-V12E)
 1 breadboard.
 1 cảm biến nhiệt độ LM35.
Phần mềm :
 Phần mềm Arduino IDE.
 Đăng kí 1 tài thoản miễn phí trên thingspeak.
Cài đặt trên thingspeak:
sau khi đăng kí một tài khoản miễn phí ta đƣợc giao diện nhƣ sau và ta chọn New
Channel
Sau đó ta thực hiện các thao tác sau:
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: 0395 304 802
347
Và ta đƣợc giao diện nhƣ hình sau:
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: 0395 304 802
348
Và mã Writekey ta lấy từ đây:
Lắp mạch:
ESP8266_12E
LM35
3.3
VCC ( 5V)
GND
GND (--)
A0
OUT
Lập trình:
#include <ESP8266WiFi.h>
String apiWritekey = "VXMLHG2R6DDPUCNT"; // mã Writekey ta thay vào đây
const char* ssid = "coffee "; // tên wifi nhà bạn
const char* password = "coffee" ;// wifi pasword
const char* server = "api.thingspeak.com";
float resolution=3.3/1023; // 3.3 is the supply volt & 1023 is max analog read value
WiFiClient client;
void setup() {
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: 0395 304 802
349
Serial.begin(115200);
WiFi.disconnect();
delay(10);
WiFi.begin(ssid, password);
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("NodeMcu connected to wifi...");
Serial.println(ssid);
Serial.println();
}
void loop() {
float temp = (analogRead(A0) * resolution) * 100;
if (client.connect(server,80))
{
String tsData = apiWritekey;
tsData +="&field1=";
tsData += String(temp);
tsData += "\r\n\r\n";
client.print("POST /update HTTP/1.1\n");
client.print("Host: api.thingspeak.com\n");
client.print("Connection: close\n");
client.print("X-THINGSPEAKAPIKEY: "+apiWritekey+"\n");
client.print("Content-Type: application/x-www-form-urlencoded\n");
client.print("Content-Length: ");
client.print(tsData.length());
client.print("\n\n"); // the 2 carriage returns indicate closing of Header fields &
starting of data
client.print(tsData);
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: 0395 304 802
350
Serial.print("Temperature: ");
Serial.print(temp);
Serial.println("uploaded to Thingspeak server....");
}
client.stop();
Serial.println("Waiting to upload next reading...");
Serial.println();
// thingspeak needs minimum 15 sec delay between updates
delay(15000);
}
Sau khi upload code ta mở cổng serial monitor và thingspeak:
và đƣợc kết quả nhƣ sau
7. Điều khiển thiết bị điện bằng webserver.
Chuẩn bị phần cứng:
 1 x ESP8266 V12 hoặc V12E đã tích hợp sẵn mạch nạp ( Trong ví bài viết
này tôi sử dụng ESP8266-V12E)
 1 breadboard.
 4 Led.
 4 điện trở 220 Ohm.
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: 0395 304 802
351
Phần mềm :
 Phần mềm Arduino IDE.
Lắp mạch:
ESP8266_12E
Led
GND
GND (--)
GIPO0 (D3)
LED1 ( + )
GIPO4 (D2)
LED2 ( + )
GIPO5 (D1)
LED3 ( + )
GIPO16 (D0)
LED4 ( + )
Lập trình:
#include <ESP8266WiFi.h>
const char* ssid = "Truong Phi";
const char* password = "01695304802";
WiFiServer server(80);
void setup() {
Serial.begin(115200);
delay(10);
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: 0395 304 802
352
pinMode(5, OUTPUT);
pinMode(4, OUTPUT);
pinMode(0, OUTPUT);
pinMode(16, OUTPUT);
digitalWrite(5, LOW);
digitalWrite(4, LOW);
digitalWrite(0, LOW);
digitalWrite(16, LOW);
// Connect to WiFi network
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
// Start the server
server.begin();
Serial.println("Server started");
// Print the IP address
Serial.print("Use this URL to connect: ");
Serial.print("http://");
Serial.print(WiFi.localIP());
Serial.println("/");
}
void loop() {
// Check if a client has connected
WiFiClient client = server.available();
if (!client) {
return;
}
// Wait until the client sends some data
Serial.println("new client");
while(!client.available()){
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: 0395 304 802
353
delay(1);
}
// Read the first line of the request
String request = client.readStringUntil('\r');
Serial.println(request);
client.flush();
// Match the request
if (request.indexOf("/light1on") > 0) {
digitalWrite(5, HIGH);
}
if (request.indexOf("/light1off") >0) {
digitalWrite(5, LOW);
}
if (request.indexOf("/light2on") > 0) {
digitalWrite(4, HIGH);
}
if (request.indexOf("/light2off") >0) {
digitalWrite(4, LOW);
}
if (request.indexOf("/light3on") >0) {
digitalWrite(0, HIGH);
}
if (request.indexOf("/light3off") > 0) {
digitalWrite(0, LOW);
}
if (request.indexOf("/light4on") > 0) {
digitalWrite(16, HIGH);
}
if (request.indexOf("/light4off") > 0) {
digitalWrite(16, LOW);
}
// Set ledPin according to the request
//digitalWrite(ledPin, value);
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: 0395 304 802
354
// Return the response
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println(""); // do not forget this one
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<head>");
client.println("<meta name='apple-mobile-web-app-capable' content='yes' />");
client.println("<meta name='apple-mobile-web-app-status-bar-style' content='blacktranslucent' />");
client.println("</head>");
client.println("<body bgcolor = \"#f7e6ec\">");
client.println("<hr/><hr>");
client.println("<h4><center> ĐIỀU KHIỂN THIẾT BỊ ĐIỆN BẰNG ESP8266 12E
</center></h4>");
client.println("<hr/><hr>");
client.println("<br><br>");
client.println("<br><br>");
client.println("<center>");
client.println("Device 1");
client.println("<a href=\"/light1on\"\"><button>Turn On </button></a>");
client.println("<a href=\"/light1off\"\"><button>Turn Off </button></a><br />");
client.println("</center>");
client.println("<br><br>");
client.println("<center>");
client.println("Device 2");
client.println("<a href=\"/light2on\"\"><button>Turn On </button></a>");
client.println("<a href=\"/light2off\"\"><button>Turn Off </button></a><br />");
client.println("</center>");
client.println("<br><br>");
client.println("<center>");
client.println("Device 3");
client.println("<a href=\"/light3on\"\"><button>Turn On </button></a>");
client.println("<a href=\"/light3off\"\"><button>Turn Off </button></a><br />");
client.println("</center>");
client.println("<br><br>");
client.println("<center>");
client.println("Device 4");
client.println("<a href=\"/light4on\"\"><button>Turn On </button></a>");
client.println("<a href=\"/light4off\"\"><button>Turn Off </button></a><br />");
client.println("</center>");
client.println("<br><br>");
client.println("<center>");
client.println("<table border=\"5\">");
client.println("<tr>");
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: 0395 304 802
355
if (digitalRead(5))
{
client.print("<td>Light 1 is ON</td>");
}
else
{
client.print("<td>Light 1 is OFF</td>");
}
client.println("<br />");
if (digitalRead(4))
{
client.print("<td>Light 2 is ON</td>");
}
else
{
client.print("<td>Light 2 is OFF</td>");
}
client.println("</tr>");
client.println("<tr>");
if (digitalRead(0))
{
client.print("<td>Light 3 is ON</td>");
}
else
{
client.print("<td>Light 3 is OFF</td>");
}
if (digitalRead(16))
{
client.print("<td>Light 4 is ON</td>");
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: 0395 304 802
356
}
else
{
client.print("<td>Light 4 is OFF</td>");
}
client.println("</tr>");
client.println("</table>");
client.println("</center>");
client.println("</html>");
delay(1);
Serial.println("Client disonnected");
Serial.println("");
}
Sau khi upload chƣơng trình thành công ta mở cổng serial monitor lên:
Từ hình trên ta đƣợc địa chỉ ip để truy cập webserver để điều khiển thiết bị điện là :
192.168.100.11 địa chỉ sẽ khác đi tùy vào router wifi nữa nhé.
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: 0395 304 802
357
Hình ảnh thực tế:
Ta nhập địa chỉ ip vào trình duyệt và cho ra giao diện giống hình dƣới.
Hình điều khiển thực tế
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: 0395 304 802
358
8.
Điều khiển thiết bị điện bằng wifi và app MIT invertor.
Phần mền cần chuẩn bị
 Phần mềm IDE.
 App inverter (đƣợc đính kèm trong file code)
Phần cứng cần chuẩn bị:
 1 ESP8266 12 HOẶC ESP8266 12E.
 1 Breadboard.
 1 Điện thoại sử dụng hệ điều hành android.
 Dây test board.
 4 Led ( các bạn có thể thay thế bằng relay để đóng ngắt thiết bị điện)
 4 Trở 220 Ohm.
Lắp mạch:
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: 0395 304 802
359
Code chƣơng trình:
#include <ESP8266WiFi.h>
const char* ssid = "Truong Phi"; //tên wifi
const char* password = "xxxxxxxxx"; // password
int R1=D1;
int R2=D2;
int R3=D3;
int R4=D4;
WiFiServer server(80); //port is 80.
void setup() {
Serial.begin(115200);
delay(10);
pinMode(R1, OUTPUT);
pinMode(R2, OUTPUT);
pinMode(R3, OUTPUT);
pinMode(R4, OUTPUT);
digitalWrite(R1,HIGH);
digitalWrite(R2,HIGH);
digitalWrite(R3,HIGH);
digitalWrite(R4,HIGH);
// Connect to WiFi network
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
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: 0395 304 802
360
// Start the server
server.begin();
Serial.println("Server started");
// Print the IP address
Serial.print("Use this URL to connect: ");
Serial.print("http://");
Serial.print(WiFi.localIP()); //Gets the WiFi shield's IP address and Print the IP
address of serial monitor
Serial.println("/");
}
void loop() {
WiFiClient client = server.available();
if (!client) {
return;
}
Serial.println("new client");
while(!client.available()){
delay(1);
}
String request = client.readStringUntil('\r');
Serial.println(request);
client.flush();
if (request.indexOf("/Relay1On") != -1) {
digitalWrite(R1,LOW);
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("");
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("Relay 1 is ON");
client.println("</html>");
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: 0395 304 802
361
client.stop();
delay(1);
}
if (request.indexOf("/Relay1Off") != -1) {
digitalWrite(R1, HIGH);
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("");
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("Relay 1 is OFF");
client.println("</html>");
client.stop();
delay(1);
}
if (request.indexOf("/Relay2On") != -1) {
digitalWrite(R2,LOW);
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("");
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("Relay 2 is ON");
client.println("</html>");
client.stop();
delay(1);
}
if (request.indexOf("/Relay2Off") != -1) {
digitalWrite(R2, HIGH);
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("");
client.println("<!DOCTYPE HTML>");
client.println("<html>");
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: 0395 304 802
362
client.println("Relay 2 is OFF");
client.println("</html>");
client.stop();
delay(1);
}
if (request.indexOf("/Relay3On") != -1) {
digitalWrite(R3,LOW);
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("");
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("Relay 3 is ON");
client.println("</html>");
client.stop();
delay(1);
}
if (request.indexOf("/Relay3Off") != -1) {
digitalWrite(R3, HIGH);
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("");
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("Relay 3 is OFF");
client.println("</html>");
client.stop();
delay(1);
}
if (request.indexOf("/Relay4On") != -1) {
digitalWrite(R4,LOW);
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("");
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: 0395 304 802
363
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("Relay 4 is ON");
client.println("</html>");
client.stop();
delay(1);
}
if (request.indexOf("/Relay4Off") != -1) {
digitalWrite(R4, HIGH);
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("");
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("Relay 4 is OFF");
client.println("</html>");
client.stop();
delay(1);
}
}
Cài đặt app cho điện thoại ( Andriod):
Viết app mit inverter (có file kèm theo), các bạn nên đăng kí một tài khoản trên web app
mit invetor.
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: 0395 304 802
364
Hình ảnh thực tế:
Ta mở màn hình serial monitor nên và ta có đƣợc kết quả giống nhƣ dƣới sau mỗi
lần ta bật tắt.
Hình thực tế:
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: 0395 304 802
365
9. Điều khiển thiết bị điện bằng Nodemcu ( esp 12e) và app Blynk.
Phần mền cần chuẩn bị
 Phần mềm IDE.
 App Blynk các bạn tải trên App Store hoặc CH play đều đƣợc.
Phần cứng cần chuẩn bị:
 1 ESP8266 12 HOẶC ESP8266 12E.
 1 Breadboard.
 1 Điện thoại sử dụng hệ điều hành android hoặc ISO.
 Dây test board.
 1 Led ( các bạn có thể thay thế bằng relay để đóng ngắt thiết bị điện)
 1 Trở 220 Ohm.
Lắp mạch:
 Chân ( + ) của led đƣợc nối chân D3 ( tƣơng ứng với chân số GPIO0 )
 Chân ( -- ) của led đƣợc nối chân GND của ESP.
Code chương trình:
Trƣớc hết chúng ta phải tải về cài thƣ viện Blynk cho Arduino IDE, thƣ viện đƣợc
kèm theo trong file code.
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: 0395 304 802
366
Tiếp đến sau khi đã add thƣ viện blynk cho IDE ta mở code mẫu có sẵn trong thƣ
viện nhƣ hình sau:
Và ta đƣợc code nhƣ sau:
#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
char auth[] = "YourAuthToken"; // token sau khi đăng kí email trên blynk và lập project
thì mã token này sẽ đƣợc gửi vào email đăng kí.
char ssid[] = "YourNetworkName"; // tên wifi
char pass[] = "YourPassword"; // nhập mật khẩu của wifi cần kết nối
void setup()
{
// Debug console
Serial.begin(9600);
Blynk.begin(auth, ssid, pass);
}
void loop()
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: 0395 304 802
367
{
Blynk.run();
}
Các bước thực hiện như sau:
a) Tải app Blynk
b) Đăng kí tài khoản trên blynk khi đăng nhập.
Sau khi cài app xong và đăng kí 1 tài khoản email và blynk sẽ báo về bạn đã đăng kí
thành công. Tiếp đến ta lập 1 project bật tắt led.
c) Lập project:
Ta chọn New Project
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: 0395 304 802
368
Ta thực hiện theo thứ tự nhƣ hình dƣới:
Hình số 2 khi ta chọn OK thì blynk sẽ gửi về email đăng kí 1 mã token và ta lấy mã đó
cho vào code IDE:
Tới hình số 6 là ta hoàn thành việc lập app trên Blynk.
d) Chỉnh sửa code:
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: 0395 304 802
369
Ta vào email đã đăng kí lấy mã token.
#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
char auth[] = "8b77ceab91c5406e99624623d2af0e3c";
char ssid[] = "Truong Phi";
char pass[] = "xxxxxxxx";
void setup()
{
// Debug console
Serial.begin(9600);
Blynk.begin(auth, ssid, pass);
}
void loop()
{
Blynk.run();
}
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: 0395 304 802
370
Hình ảnh thực tế:
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: 0395 304 802
371
D. HỌC LẬP TRÌNH ARDUINO
THÔNG QUA DỰ ÁN
1. Ðo và hiển thị điện áp DC ( 0 – 30Vdc).
Phần mền cần chuẩn bị
 Phần mềm IDE.
Phần cứng cần chuẩn bị:




1 board arduino.
1 Breadboard.
Dây test board.
1 trở 100k Ohm
 1 Trở 10k Ohm.
Lắp mạch:
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: 0395 304 802
372
Code chương trình:
https://drive.google.com/file/d/1Gruu-UErrMnrlVpTR03U-JiLoevJfmQX/view
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);
int analogInput = 0;
float vout = 0.0;
float vin = 0.0;
float R1 = 100000.0; // resistance of R1 (100K)
float R2 = 10000.0; // resistance of R2 (10K)
int value = 0;
int a[5] = {};
void setup() {
Serial.begin(9600);
pinMode(analogInput, INPUT);
lcd.init();
lcd.backlight();
lcd.setCursor(2, 0);
lcd.print("DC VOLTMETER");
delay(3000);
lcd.clear();
}
void loop() {
lcd.print("DC Voltmeter");
// read the value at analog input
value = analogRead(analogInput);
vout = (value * 5) / 1024.0;
vin = vout / (R2 / (R1 + R2));
Serial.println(vin);
if (vin < 0.09)
{
vin = 0.0;
}
lcd.setCursor(0, 1);
lcd.print("Voltage V :");
lcd.print(vin);
delay(3000);
lcd.clear();}
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: 0395 304 802
373
Hình ảnh thực tế:
https://www.youtube.com/watch?v=OYrT0qpt8hI&list=PLHPjOX8mt4YHDi1CKfCdajzDtOJfGwZx&index=2&t=0s
2. Thiết kế xe robot 4 bánh điều khiển bằng điện thoại (
bluethooth)
Mục tiêu:
 Làm xe robot điều khiển bằng điện thoại.
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
 Đăng kí 1 tài khoản miễn phí trên MIT App Inventor 2 .
Phần cứng cần chuẩn bị:












1 board arduino uno hoặc nano,...
1 điện thoại sử dụng hệ điều hành andriod.
1 mạch điều khiển động cơ L298N.
Dây test board.
1 module bluetooth HC05 hoặc HC06.
4 dộng cơ giảm tốc V1 màu vàng.
4 bánh xe robot.
1m dây điện nhỏ.
1 công tắc on/off.
1 đế 3 pin nối tiếp cho pin 3.7 VDC.
3 pin 3.7VDC. ( Loại pin sạc : 18650 ).
2 cây keo nến.
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: 0395 304 802
374
 1 tấm mica 3mm hoặc gỗ (rộng: 11cm, dài : 17cm).
Lắp mạch nguyên lý:
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: 0395 304 802
375
Arduino
L298
HC05
GND
GND (--)
GND
5V
+5VDC
VCC
5
ENB
6
IN4
7
11
12
13
2
3
IN3
ENA
IN1
IN2
Tx
Rx
Lắp mô hình:
Bƣớc 1: Gắn bánh xe vào động cơ.
Bƣớc 2: Dùng keo nến đính động cơ và bánh xe vào khung mica hoặc gỗ.
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: 0395 304 802
376
Hai động cơ cùng 1 phía ta nối dây chung với nhau ( chạy song song ). Như
mạch nguyên lý vẽ ở trên.
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: 0395 304 802
377
Bước 4: Ta nối công tắc với cực âm của nguồn.
Ðính đế nguồn pin lên thân xe bằng keo nến:
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: 0395 304 802
378
Bước 5: Ðính module L298N lên thân xe và kết nối ( GND  GND nguồn ), (
+12V  + của nguồn ).
Nối dây động cơ vào chân điều khiển động cơ của mạch L298N như sơ đồ
nguyên lý ở trên
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: 0395 304 802
379
Bước 6: Ðính board arduino lên thân xe bằng keo nến và cấp nguồn +5V và
gnd từ module L298N như sơ đồ nguyên lý ở trên.
Kết nối các chân điều khiển từ board arduino tới module L298N.
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: 0395 304 802
380
Bước 7: Kết module bluetooth hc05 với board arduino.
Bước 8: Tải file add điều khiển về điện thoại theo link kèm theo
Link tải app duợc luu trong file code
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: 0395 304 802
381
Sau khi tải về và cài đặt ta đƣợc app như hình dưới.
Bước 9: Tải file code chương trình tại link dưới và upload cho board arduino
Uno.
https://drive.google.com/open?id=1XsbXSouQ2iS1hnTrLrbWpnpy2NImnSaA
Bước 10: Lắp 3 pin 3.7V vào đế pin và bật công tắc ON/OFF lên.
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: 0395 304 802
382
Bước 11: Mở bluetooth điện thoại lên và chọn vào nút DÒ để tìm mã thiết bị
bluetooth của HC05.
Bước 12: Sau khi dò đƣợc mã HC05 ( lưu ý: mỗi bluetooth sẽ có mã khác
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: 0395 304 802
383
nhau ) ta chọn vào và nhập pass là 1234.
Bước 13: Mở app ROBOT_CAR từ điện thoại lên và chọn vào nút Kết nối
bluetooth.
Sau khi chọn nút kết nối bluetooth sẽ hiện ra cửa sổ như hình dưới và chúng ta
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: 0395 304 802
384
chọn đúng vào mã của module bluetooth HC05 ( Lưu ý: mỗi bluetooth sẽ có mã
khác nhau )
Như vậy là hoàn thành quá trình cài đặt, và có thể điều khiển đƣợc xe robot.
3. Thiết kế mô hình bật tắt đèn AC 220v khi trời tối, sử dụng
cảm biến quang trở
Mục tiêu:

Bật tắt thiết bị đèn AC 220V khi trời tối.
Phần mền cần chuẩn bị

Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:




1 board arduino uno hoặc nano,...
Dây test board.
1 module cảm biến quang trở.
1 relay 5Vdc.
 1 bóng đèn AC 220V.
Lắp mạch nguyên lý:
Trường hợp này không cần kết nối với LCD cũng được.
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: 0395 304 802
385
Arduino
CB ánh sáng
Module relay
I2C for LCD
GND
GND (--)
GND
GND
5V
+5VDC
VCC
VCC
2
D0
9
IN
A4
SDA
A5
SCL
Code chương trình:
#include <Wire.h> // thư viện hổ trợ I2C
#include <LiquidCrystal_I2C.h> // thư viện i2c cho LCD
LiquidCrystal_I2C lcd(0x27,16,2); // Ðịa chỉ cho i2c cho LCD :0x27
int quangtro = 2; //Thiết đặt chân analog đọc quang trở
int relay = 9;
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: 0395 304 802
386
void setup() {
lcd.init();
lcd.backlight();
pinMode(quangtro, INPUT);
pinMode(relay, OUTPUT);
}
void loop() {
lcd.clear();
int gt = digitalRead(quangtro); // đọc giá trị quang trở
lcd.setCursor(0,0);
lcd.print("GT Quang Tro:");
lcd.setCursor(15,0);
lcd.print(gt);
if ( gt == 1) // nếu trời tối thì bật dèn
{
digitalWrite(relay, HIGH);
}
else {digitalWrite(relay,LOW);} // trời sáng khi trời sáng
delay(500);
}
Hình ảnh thực tế:
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: 0395 304 802
387
4. Thiết kế mô hình tưới cây tự động.
Mục tiêu:
 Bật tắt bơm tưới cây khi đất khô.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:






Mạch Arduino (hoặc Nano).
Breadboard còn gọi testboard
1 module LCD 16x02 + I2C
Dây cắm test board.
1 Cảm biến độ ẩm dất.
1 Relay 5Vdc.
 1 Bom 12Vdc
Lắp mạch nguyên lý:
Code chương trình:
//Chưong trình ÐỌC DỮ LIÊU TỪ CẢM BIẾN ÐO ÐỘ ẨM ÐẤT
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16, 2);
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: 0395 304 802
388
int CBDoAm = A1; //Nối chân ra của cảm biến do dộ ẩm với chân A1
#define role 12
//Chân nối với role 12
float doamdat;
//Biến dộ ẩm dất
void setup()
{
Serial.begin(9600);
lcd.init();
lcd.backlight();
//Khai báo các chân
pinMode(role,OUTPUT);
}
void loop()
{
doamdat=analogRead(CBDoAm);
lcd.setCursor(0,0);
lcd.print("Do am la:");
lcd.setCursor(10,0);
lcd.print(doamdat); //In ra dộ ẩm dất (serial monitor)
//Bom nƣớc khi dất khô( thông qua role)
if(doamdat > 800)
{
digitalWrite(role,HIGH); //Bat role de tuoi cay,…
delay(2000);
}
else
{
digitalWrite(role,LOW);
}
delay(1000);
}
Hình ảnh thực tế:
Sau khi upload chƣơng trình ta đƣợc:
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: 0395 304 802
389
5. Thiết kế mô hình đếm số học sinh trong phòng học..
Mục tiêu:
 Ðếm số học sinh tự động trong phòng học .
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:






Mạch Arduino (hoặc Nano).
Breadboard còn gọi testboard.
1 module LCD 16x02 + I2C.
Dây cắm test board.
2 module cảm biến hồng ngoại ( dò line )
1 led 5mm.
 1 điện trở 220 Ohm.
Lắp mạch nguyên lý:
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: 0395 304 802
390
Arduino
CB IR 1
CB IR 2
I2C for LCD
LED
GND
GND (--)
GND
GND
Chân
Gnd ( - )
5V
+5VDC
VCC
VCC
6
out
7
out
A4
SDA
A5
SCL
3
Chân ( +)
Code chương trình:
https://drive.google.com/open?id=11sZXBW4QHBffT-LyULQgI1fYuXiUVoIo
#include <Wire.h> // thư viện i2c
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2); //địa chị của i2c 0x27
int IRin =6; //chân out của cb vào nối chân số 6 của arduino
int IRout=7; //chân out của cb ra nối chân số 7của arduino
int led = 3;
int dem=0;
void IRIN()
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: 0395 304 802
391
{
dem++; // tăng biến đếm lên 1 đơn vị
lcd.clear();
lcd.setCursor(0,0);
lcd.print("So hoc sinh:");
lcd.setCursor(0,1);
lcd.print(dem);
delay(1000);
}
void IROUT()
{
dem--;
if (dem < 0 ){dem=0;}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("So hoc sinh:");
lcd.setCursor(0,1);
lcd.print(dem);
delay(1000);
}
void setup(){
lcd.init();
lcd.backlight();
delay(2000);
pinMode(IRin, INPUT);
pinMode(IRout, INPUT);
pinMode(led, OUTPUT);
lcd.clear(); // xóa màn hình LCD
lcd.setCursor(0,0);
lcd.print("So hoc sinh:");
lcd.setCursor(13,0);
lcd.print(dem);
}
void loop()
{
int gtin = digitalRead(IRin); // đọc giá trị cảm biến hồng ngoại vào.
int gtout = digitalRead(IRout); // đọc giá trị cảm biến hồng ngoại ra.
if(gtin==0){
IRIN();}
if(gtout==0){
IROUT();}
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: 0395 304 802
392
if(dem<=0)
{
lcd.clear();
digitalWrite(led, LOW);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Khong co HS");
lcd.setCursor(0,1);
lcd.print("Tat den");
delay(200);
}
else
digitalWrite(led, HIGH);
}
Hình ảnh thực tế:
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: 0395 304 802
393
6. Thiết kế mô hình bật tắt thiết bị bằng sóng rf 433Mhz.
Mục tiêu:
 Bật tắt thiết bị diện bằng sóng rf 433Mhz sử dụng arduino .
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:






2 Mạch Arduino (hoặc Nano).
Breadboard còn gọi testboard
Dây cắm test board.
1 module relay 4 kênh.
1 module phát rf 433Mhz.
1 module thu rf 433Mhz.
 4 nút nhấn loại 4 chân.
Bảng mã ASCII:
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: 0395 304 802
394
Lắp mạch nguyên lý:
Lắp mạch cho phần phát ( tranmitter ):
Lắp mạch cho phần thu ( receiver):
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: 0395 304 802
395
Code chương trình:
https://drive.google.com/file/d/1Oj9pRl-1et3a7tAiS6oeOPnex1XMRVYL/view
Code phần thu ( tranmitter): code điều khiển 8 thiết bị
Lưu ý : chúng ta cần cài thư viên VirtualWire.h cho IDE trước nhé., thư viện sẽ
đƣợc kèm theo trong file code.
#include <VirtualWire.h> // thư vien
const int buttonPin1 = 2;
const int buttonPin2 = 3;
const int buttonPin3 = 5;
const int buttonPin4 = 6;
const int buttonPin5 = 7;
const int buttonPin6 = 8;
const int buttonPin7 = 9;
const int buttonPin8 = 10;
void setup()
{
Serial.begin(9600);
Serial.println("setup");
pinMode(buttonPin1, INPUT_PULLUP); // khai báo nút nhấn là input
pinMode(buttonPin2, INPUT_PULLUP);
pinMode(buttonPin3, INPUT_PULLUP);
pinMode(buttonPin4, INPUT_PULLUP);
pinMode(buttonPin5, INPUT_PULLUP);
pinMode(buttonPin6, INPUT_PULLUP);
pinMode(buttonPin7, INPUT_PULLUP);
pinMode(buttonPin8, INPUT_PULLUP);
vw_set_tx_pin(4);
// chân phát tín hiệu là chân số 4
vw_set_ptt_inverted(true);
vw_setup(4000);
}
void loop()
{
int buttonState1 = 1; // ban dầu gán nút nhấn 1 ở mức cao
buttonState1 = digitalRead(buttonPin1);
if (buttonState1 == LOW) // nếu nút nhấn 1 ở mức thấp
{
const char *msg = "A"; // Gán kí tự A
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: 0395 304 802
396
digitalWrite(13, true);
// Flash a light to show transmitting
vw_send((uint8_t *)msg, strlen(msg)); //gửi kí tự
vw_wait_tx();
Serial.println(*msg);
digitalWrite(13, false);
delay(1000);
}
{
int buttonState2 = 1;
buttonState2 = digitalRead(buttonPin2);
if (buttonState2 == LOW) {
const char *msg = "B";
digitalWrite(13, true);
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx();
Serial.println(*msg);
digitalWrite(13, false);
delay(1000);
}
{
int buttonState3 = 1;
buttonState3 = digitalRead(buttonPin3);
if (buttonState3 == LOW) {
const char *msg = "C";
digitalWrite(13, true);
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx();
Serial.println(*msg);
digitalWrite(13, false);
delay(1000);
}
{
int buttonState4 = 1;
buttonState4 = digitalRead(buttonPin4);
if (buttonState4 == LOW) {
const char *msg = "D";
digitalWrite(13, true);
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx();
Serial.println(*msg);
digitalWrite(13, false);
delay(1000);
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: 0395 304 802
397
}
{
int buttonState5 = 1;
buttonState5 = digitalRead(buttonPin5);
if (buttonState5 == LOW) {
const char *msg = "E";
digitalWrite(13, true);
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx();
Serial.println(*msg);
digitalWrite(13, false);
delay(1000);
}
{
int buttonState6 = 1;
buttonState6 = digitalRead(buttonPin6);
if (buttonState6 == LOW) {
const char *msg = "F";
digitalWrite(13, true);
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx();
Serial.println(*msg);
digitalWrite(13, false);
delay(1000);
}
{
int buttonState7 = 1;
buttonState7 = digitalRead(buttonPin7);
if (buttonState7 == LOW) {
const char *msg = "G";
digitalWrite(13, true);
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx();
Serial.println(*msg);
digitalWrite(13, false);
delay(1000);
}
{
int buttonState8 = 1;
buttonState8 = digitalRead(buttonPin8);
if (buttonState8 == LOW) {
const char *msg = "H";
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: 0395 304 802
398
digitalWrite(13, true);
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx();
Serial.println(*msg);
digitalWrite(13, false);
delay(1000);
}
delay(100);
}
}
}
}
}
}
}
}
Code phần thu ( receiver ):
#include <VirtualWire.h>
int count;
void setup()
{
Serial.begin(9600);
Serial.println("setup");
vw_set_rx_pin(4);
//chân thu tín hiệu là chân số 4
vw_set_ptt_inverted(true);
vw_setup(4000);
vw_rx_start();
pinMode(2, OUTPUT); //Relay 1
pinMode(3, OUTPUT); //Relay 2
pinMode(5, OUTPUT); //Relay 3
pinMode(6, OUTPUT); //Relay 4
pinMode(7, OUTPUT); //Relay 5
pinMode(8, OUTPUT); //Relay 6
pinMode(9, OUTPUT); //Relay 7
pinMode(10, OUTPUT); //Relay 8
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
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: 0395 304 802
399
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
digitalWrite(10, HIGH);
}
void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen))
{
int i;
digitalWrite(13, true);
Serial.print("Got: ");
for (i = 0; i < buflen; i++)
{
int c = (buf[i]);
Serial.print(c);
Serial.print(" ");
if (c==65 ) { // KÍ TỰ A
digitalWrite(2, !digitalRead(2));
}
if (c==66 ) { // KÍ TỰ B
digitalWrite(3, !digitalRead(3));
}
if (c==67 ) {
digitalWrite(5, !digitalRead(5));
}
if (c==68 ) {
digitalWrite(6, !digitalRead(6));
}
if (c==69 ) {
digitalWrite(7, !digitalRead(7));
}
if (c==70 ) {
digitalWrite(8, !digitalRead(8));
}
if (c==71 ) {
digitalWrite(9, !digitalRead(9));
}
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: 0395 304 802
400
if (c==72 ) {
digitalWrite(10, !digitalRead(10));
}
}
count++;
// Serial.print(count);
Serial.println("");
digitalWrite(13, false);
}
}
Hình ảnh thực tế:
7. Thiết kế xe robot 4 bánh điều khiển bằng sóng Wifi (
nodemcu ).
Mục tiêu:
 Điều khiển xe robot 4 bánh bằng sóng wifi sử dụng NodeMCU .
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
 Đăng kí 1 tài khoản miễn phí trên MIT App Inventor 2 .
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: 0395 304 802
401
Phần cứng cần chuẩn bị:
 1 Mạch Arduino (hoặc Nano).
 Breadboard còn gọi testboard nhỏ.
 Dây cắm test board.
 1 module L298N.
 1 module ESP8266 12E ( NodeMCU ).
 1 đế pin 3 loại 3.7 V.
 3 pin 3.7V.
 1 Công tắc ON/OFF.
 4 động cơ giảm tốc v1 màu vàng.
 4 bánh xe.
 1 tấm mica 5mm ( 11cmx17cm).
Lắp mạch nguyên lý:
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: 0395 304 802
402
Lắp mô hình:
Bƣớc 1: Dùng keo nến đính đông cơ và bánh xe vào khung mica hoặc gỗ.
Hai động cơ cùng 1 phía ta nối dây chung với nhau ( chạy song song ). Nhƣ mạch
nguyên lý vẽ ở trên.
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: 0395 304 802
403
Bƣớc 2: Đính module L298N lên thân xe và kết nối ( GND  GND nguồn dây
màu đen), ( +12V  + của nguồn pin dây màu đỏ).
Nối dây động cơ vào chân điều khiển động cơ của mạch L298N nhƣ sơ đồ
nguyên lý ở trên
Bƣớc 3: Đính board NodeMCU lên thân xe bằng keo nến và cấp nguồn +5V
và gnd từ module L298N nhƣ sơ đồ nguyên lý ở trên.
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: 0395 304 802
404
Bƣớc 4: Upload chƣơng trình cho board NodeMCU ( lƣu ý: cách cài đặt
board nodeMCU các bạn xem lại trang 323 nhé. )
File code:
https://drive.google.com/open?id=1RUhXB-QuqAqTa51-fleDk_PUfERC7Yfs
Trƣớc hết các bạn phải add thƣ viện ESP8266WiFi cho phần mền IDE. Thƣ viện
kèm theo code.
#define ENA 14
// Enable/speed motors Right
GPIO14(D5)
#define ENB 12
// Enable/speed motors Left
GPIO12(D6)
#define IN_1 15
// L298N in1 motors Right
GPIO15(D8)
#define IN_2 13
// L298N in2 motors Right
GPIO13(D7)
#define IN_3 2
// L298N in3 motors Left
GPIO2(D4)
#define IN_4 0
// L298N in4 motors Left
GPIO0(D3)
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
String command;
int speedCar = 800;
int speed_Coeff = 3;
// 400 - 1023.
const char* ssid = "WIFI Car";
ESP8266WebServer server(80);
void setup() {
pinMode(ENA, OUTPUT);
pinMode(ENB, OUTPUT);
pinMode(IN_1, OUTPUT);
pinMode(IN_2, OUTPUT);
pinMode(IN_3, OUTPUT);
pinMode(IN_4, OUTPUT);
Serial.begin(115200);
// Connecting WiFi
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: 0395 304 802
405
WiFi.mode(WIFI_AP);
WiFi.softAP(ssid);
IPAddress myIP = WiFi.softAPIP();
Serial.print("AP IP address: ");
Serial.println(myIP);
server.on ( "/", HTTP_handleRoot );
server.onNotFound ( HTTP_handleRoot );
server.begin();
}
void goAhead(){
digitalWrite(IN_1, LOW);
digitalWrite(IN_2, HIGH);
analogWrite(ENA, speedCar);
digitalWrite(IN_3, LOW);
digitalWrite(IN_4, HIGH);
analogWrite(ENB, speedCar);
}
void goBack(){
digitalWrite(IN_1, HIGH);
digitalWrite(IN_2, LOW);
analogWrite(ENA, speedCar);
digitalWrite(IN_3, HIGH);
digitalWrite(IN_4, LOW);
analogWrite(ENB, speedCar);
}
void goRight(){
digitalWrite(IN_1, HIGH);
digitalWrite(IN_2, LOW);
analogWrite(ENA, speedCar);
digitalWrite(IN_3, LOW);
digitalWrite(IN_4, HIGH);
analogWrite(ENB, speedCar);
}
void goLeft(){
digitalWrite(IN_1, LOW);
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: 0395 304 802
406
digitalWrite(IN_2, HIGH);
analogWrite(ENA, speedCar);
digitalWrite(IN_3, HIGH);
digitalWrite(IN_4, LOW);
analogWrite(ENB, speedCar);
}
void goAheadRight(){
digitalWrite(IN_1, LOW);
digitalWrite(IN_2, HIGH);
analogWrite(ENA, speedCar/speed_Coeff);
digitalWrite(IN_3, LOW);
digitalWrite(IN_4, HIGH);
analogWrite(ENB, speedCar);
}
void goAheadLeft(){
digitalWrite(IN_1, LOW);
digitalWrite(IN_2, HIGH);
analogWrite(ENA, speedCar);
digitalWrite(IN_3, LOW);
digitalWrite(IN_4, HIGH);
analogWrite(ENB, speedCar/speed_Coeff);
}
void goBackRight(){
digitalWrite(IN_1, HIGH);
digitalWrite(IN_2, LOW);
analogWrite(ENA, speedCar/speed_Coeff);
digitalWrite(IN_3, HIGH);
digitalWrite(IN_4, LOW);
analogWrite(ENB, speedCar);
}
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: 0395 304 802
407
void goBackLeft(){
digitalWrite(IN_1, HIGH);
digitalWrite(IN_2, LOW);
analogWrite(ENA, speedCar);
digitalWrite(IN_3, HIGH);
digitalWrite(IN_4, LOW);
analogWrite(ENB, speedCar/speed_Coeff);
}
void stopRobot(){
digitalWrite(IN_1, LOW);
digitalWrite(IN_2, LOW);
analogWrite(ENA, speedCar);
digitalWrite(IN_3, LOW);
digitalWrite(IN_4, LOW);
analogWrite(ENB, speedCar);
}
void loop() {
server.handleClient();
command = server.arg("State");
if (command == "F") goAhead();
else if (command == "B") goBack();
else if (command == "L") goLeft();
else if (command == "R") goRight();
else if (command == "I") goAheadRight();
else if (command == "G") goAheadLeft();
else if (command == "J") goBackRight();
else if (command == "H") goBackLeft();
else if (command == "0") speedCar = 400;
else if (command == "1") speedCar = 470;
else if (command == "2") speedCar = 540;
else if (command == "3") speedCar = 610;
else if (command == "4") speedCar = 680;
else if (command == "5") speedCar = 750;
else if (command == "6") speedCar = 820;
else if (command == "7") speedCar = 890;
else if (command == "8") speedCar = 960;
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: 0395 304 802
408
else if (command == "9") speedCar = 1023;
else if (command == "S") stopRobot();
}
void HTTP_handleRoot(void) {
if( server.hasArg("State") ){
Serial.println(server.arg("State"));
}
server.send ( 200, "text/html", "" );
delay(1);
}
Trƣờng hợp máy tính không nhận cổng COM ( PORT ) thì các bạn phải cài
driver CP2102 hoặc CH340 tùy vào chip nạp của NodeMCU cho máy tính
nhé.
Bƣớc 5: Tải app về cài cho điện thoại andriod.
Link tải app đƣợc lƣu trong file code các bạn nhé.
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: 0395 304 802
409
Sau khi tải về và cài đặt ta đƣợc app nhƣ hình dƣới.
Bƣớc 6: Lắp 3 pin 3.7V vào đế pin và bật công tắc ON/OFF lên.
Bƣớc 7: Dùng điện thoại kết nối với Wifi NodeMCU phát ra có tên “ WIFI
Car”
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: 0395 304 802
410
Bƣớc 8: Sau khi đã kết nối Wifi thành công ta mở app lên và nhập địa chỉ IP
mặc định của ESP8266 là: 192.168.4.1 , và ta có thể bắt đầu điều khiển xe
robot.
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: 0395 304 802
411
8. Thiết kế mô hình diều khiển bật tắt relay bằng cảm biến
TOUCH ( cảm biến điện dung ).
Mục tiêu:

Bật tắt relay bằng cảm biến diện dụng sử dụng board arduino.
Phần mền cần chuẩn bị

Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:





1 Mạch Arduino (hoặc Nano).
Breadboard còn gọi testboard nhỏ.
Dây cắm test board.
1 module relay 5Vdc.
1 module cảm biến diện dung.
Lắp mạch nguyên lý:
Code chương trình:
https://drive.google.com/file/d/1JLEig4sqvXRYWREy8VAMo5YiPCPK6OFw/view
int touchPin = 2;// chân D0 của cảm biến nối với chân số 2 của arduino.
int relay = 3; // relay kết nối với chân số 3
int val = 0;
int trangthai = 0;
int touched = 0;
void setup() {
Serial.begin(9600);
pinMode(touchPin, INPUT);
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: 0395 304 802
412
pinMode(relay, OUTPUT);
}
void loop() {
val = digitalRead(touchPin);
if(val == HIGH && trangthai == LOW){
touched = 1-touched;
delay(100);
}
trangthai = val;
if(touched == HIGH){
Serial.println("Light ON");
digitalWrite(relay, LOW);
}else{
Serial.println("Light OFF");
digitalWrite(relay, HIGH);
}
}
Hình ảnh thực tế:
9 Gửi thông báo về điện thoại khi có trộm bằng cảm biến chuyển
động sử dụng board NodeMCU và app BLYNK.
Mục tiêu:
 Gửi thông báo về điện thoại khi có trộm vào nhà.
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: 0395 304 802
413
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
 Cài đặt app blynk vào điện thoại.
Phần cứng cần chuẩn bị:
 1 Mạch Node MCU.
 1 smartphone andriod hoặc IOS.
 Dây cắm test board.
 1 module cảm biến chuyển động.
Lắp mạch nguyên lý:
Code chương trình:
https://drive.google.com/open?id=11sZXBW4QHBffT-LyULQgI1fYuXiUVoIo
#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
BlynkTimer timer;
char auth[] = "eeVwFO5uuw_9zofrSR0Rc8oELQho54"; // mã token này được gửi vào
email của bạn sau khi lập project của blynk.
char ssid[] = "Truong Phi"; //Wifi nhà bạn
char pass[] = "01695304802"; //Wifi Password
int trangthai=0;
int led =5;
void canhbao()
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: 0395 304 802
414
{
int gtcb = digitalRead(D6);
}
else if (gtcb==0)
{
trangthai=0;
digitalWrite(5, LOW);
}
}
void setup()
{
Serial.begin(9600);
Blynk.begin(auth, ssid, pass);
pinMode(12,INPUT_PULLUP);//D6
pinMode(5,INPUT_PULLUP);
timer.setInterval(1000L,canhbao);
}
void loop()
{
Blynk.run();
timer.run();
}
Upload code cho Nodemcu ( trước khi upload phải chọn giống như hình dưới)
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: 0395 304 802
415
Cài app blynk cho điện thoại:
Bƣớc 1: Tải app blynk trên CH play hoặc App Store
Bƣớc 2: Mở app lên đăng kí tài khoản miễn phí bằng email sau đó chọn NEW
PROJECT.
Bƣớc 3: Lập app nhƣ hình dƣới.
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: 0395 304 802
416
Bƣớc 4: Chọn vào nút OK sau đó dùng tay trƣợt theo dấu mũi tên .
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: 0395 304 802
417
Bƣớc 5: Chọn đến mục nhƣ hình ở dƣới.
Bƣớc 6: Chọn vào hình tam giác nhƣ hình dƣới để chuyển qua chế độ online.
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: 0395 304 802
418
Sau khi hoàn thiện app và upload chƣơng trình cho board NodeMCU chúng ta thử
test:
Tin nhắn gửi về điện thoại thông qua app blynk nhƣ sau:
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: 0395 304 802
419
Hình ảnh thực tế:
10. Điều khiển LED ma trận Max7219 với module WIFI
NodeMCU.
Mục tiêu:
 Lập trình chạy chữ led ma trận Max7219 sử dụng module Wifi
NodeMCU web server.
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 1 Mạch Node MCU.
 Dây cắm test board.
 1 module led ma trận Max7219 (32x8).
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: 0395 304 802
420
Lắp mạch nguyên lý:
Code chương trình:
https://drive.google.com/open?id=19k3z4h7CQalLODKQOUCFj8AzO_tVpC7J
#include <LEDMatrixDriver.hpp>
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
const char* ssid = "Trinh Quang Nam."; // Thay đôi tên wifi
const char* password = "bubu123789"; // Thay đổi pass wifi
// TCP server at port 80 will respond to HTTP requests
WiFiServer server(80);
const uint8_t LEDMATRIX_CS_PIN = 15;
// Define LED Matrix dimensions (0-n) - eg: 32x8 = 31x7
const int LEDMATRIX_WIDTH = 31;
const int LEDMATRIX_HEIGHT = 7;
const int LEDMATRIX_SEGMENTS = 4;
// The LEDMatrixDriver class instance
LEDMatrixDriver lmd(LEDMATRIX_SEGMENTS, LEDMATRIX_CS_PIN);
void displayText ( char * theText)
{
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: 0395 304 802
421
if ( myTime + ANIM_DELAY < millis())
{
myTime=millis();
drawString(theText, len, x, 0);
lmd.display();
// Advance to next coordinate
if( --x < len * -8 )
{
x = LEDMATRIX_WIDTH;
lmd.clear();
}
}
}
…………………..
void drawString(char* text, int len, int x, int y )
{
for( int idx = 0; idx < len; idx ++ )
{
int c = text[idx] - 32;
// stop if char is outside visible area
if( x + idx * 8 > LEDMATRIX_WIDTH )
return;
// only draw if char is visible
if( 8 + x + idx * 8 > 0 )
drawSprite( font[c], x + idx * 8, y, 8, 8 );
}
}
void drawSprite( byte* sprite, int x, int y, int width, int height )
{
// The mask is used to get the column bit from the sprite row
byte mask = B10000000;
for( int iy = 0; iy < height; iy++ )
{
for( int ix = 0; ix < width; ix++ )
{
lmd.setPixel(x + (width - ix), y + iy, (bool)(sprite[iy] & mask ));
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: 0395 304 802
422
mask = mask >> 1;
}
// reset column mask
mask = B10000000;
}
}
Sau khi nạp code chƣơng trình cho NodeMCU thì trên màn hình led sẽ xuất hiện địa
chỉ IP, ví dụ : 192.168.1.70
Khi đã có địa chỉ IP ta dùng máy tính hay điện thoại ta truy cập vào địa chỉ đó để điều
khiển dòng chữ chạy trên led ma trận.
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: 0395 304 802
423
Hình ảnh thực tế:
11.
Ðiều khiển tốc độ động cơ bước bằng biến trở sử dụng board
Mục tiêu:

Ðiều khiển tốc độ động cơ bước bằng biến trở sử dụng board arduino.
Phần mền cần chuẩn bị

Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:






1 board arduino.
Dây cắm test board.
1 breadboard.
1 driver điều khiển động cơ bước A4988.
1 động cơ bước 1.8 độ / step (0.4A).
1 bộ nguồn (8 – 35Vdc).
Lắp mạch nguyên lý:
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: 0395 304 802
424
Sơ đồ mạch nối driver A4988 và động cơ bƣớc: ( lƣu ý nếu sử dụng 2 nguồn riêng
phải nối chung chân GND của 2 nguồn với nhau )
Code chương trình:
https://drive.google.com/file/d/1PdbPYgBmvfzfp2X4cCaeMovt1ewGuxNW/view
const int stepPin = 3;
const int dirPin = 4;
int customDelay,customDelayMapped;
void setup() {
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: 0395 304 802
425
pinMode(stepPin,OUTPUT);
pinMode(dirPin,OUTPUT);
digitalWrite(dirPin,HIGH);
}
void loop() {
customDelayMapped = speedUp(); // nhận giá trị độ trễ tùy chỉnh
// làm cho các xung có độ trễ tùy chỉnh, tùy thuộc vào biến trở xoay, từ dó thay đổi tốc
độ động cơ
digitalWrite(stepPin, HIGH);
delayMicroseconds(customDelayMapped);
digitalWrite(stepPin, LOW);
delayMicroseconds(customDelayMapped);
}
int speedUp() {
int customDelay = analogRead(A0); // đọc giá trị analog từ biến trở
int newCustom = map(customDelay, 0, 1023, 300,4000);// Chuyển các giá trị đọc của
//biến trở từ 0 dến 1023 thành các giá trị dộ trễ mong muốn (300 dến 4000)
return newCustom;
}
Hình ảnh thực tế:
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: 0395 304 802
426
12 Đọc giá trị nhiệt độ, độ ẩm hiển thị lên màn hình oled 0.96”
và blynk sử dụng board NodeMCU.
Mục tiêu:
 Đọc và hiển thị giá trị nhiệt độ và độ ẩm hiển thị màn hình oled và
blynk.
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
 Cài đặt app Blynk cho điện thoại.
Phần cứng cần chuẩn bị:
 1 board NodeMCU.
 Dây cắm test board.
 1 breadboard.
 1 Module dht11.
 1 màn hình oled 0.96‖.
Lắp mạch nguyên lý:
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: 0395 304 802
427
Code chương trình:
https://drive.google.com/file/d/1oHGKSNTXN-FSvqPlGY8R3EW07s5VwO_H/view?usp=drive_open
#include <Wire.h>
#include "SSD1306.h"
#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
// You should get Auth Token in the Blynk App.
char auth[] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
// Your WiFi credentials.
char ssid[] = "Trinh Quang Nam.";
char pass[] = "bubu123789";
#include <DHT.h>
#define DHTPIN 4 // what pin we're connected to
#define DHTTYPE DHT11 // DHT 11
// OLED display i2C
// D3 -> SDA
// D5 -> SCL
// Initialize the OLED display using Wire library
SSD1306 display(0x3C, D3, D5);
DHT dht(DHTPIN, DHTTYPE);
BlynkTimer timer;
void setup(){
Serial.begin(115200);
// Initialising the UI will init the display too.
display.init();
display.flipScreenVertically();
display.setFont(ArialMT_Plain_16);
display.setTextAlignment(TEXT_ALIGN_LEFT);
dht.begin(); // initialize dht
Blynk.begin(auth, ssid, pass, "blynk-cloud.com", 8080);
timer.setInterval(1000L, sendSensor);
}
void displayWeather(){
float h = dht.readHumidity();
// Read temperature as Celsius
float t = dht.readTemperature();
// Read temperature as Fahrenheit
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: 0395 304 802
428
float f = dht.readTemperature(true);
if (isnan(h) || isnan(t) || isnan(f)){
display.clear(); // clearing the display
display.drawString(5,0, "DHT Failed!");
return;
}
display.clear();
display.drawString(30, 0, "Weather");
display.drawString(0, 20, "Humidity: " + String(h) + "%\t");
display.drawString(0, 40, "Temp: " + String(t) + "°C");
//Uncomment to get temperature in farenheit
//display.drawString(0, 40, "Temp: " + String(f) + "°F");
}
void loop(){
Blynk.run(); // Running the blynk code
displayWeather(); //Calling back the displayWeather function
display.display();
timer.run();
}
void sendSensor()
{
float h = dht.readHumidity(); //Read the humidity
float t = dht.readTemperature(); // or dht.readTemperature(true) for Fahrenheit
if (isnan(h) || isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
return;
}
// You can send any value at any time.
// Please don't send more that 10 values per second.
Blynk.virtualWrite(V5, h);
Blynk.virtualWrite(V6, t);
}
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: 0395 304 802
429
Cài đặt app Blynk:
Bƣớc 1: Tải app blynk trên CH play hoặc App Store
Bƣớc 2: Mở app lên đăng kí tài khoản miễn phí bằng email sau đó chọn NEW
PROJECT.
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: 0395 304 802
430
Bƣớc 3: Lập app nhƣ hình dƣới.
Bƣớc 4: Chọn vào nút OK mã token sẽ đƣợc gửi vào email sau đó dùng tay
trƣợt theo dấu mũi tên .
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: 0395 304 802
431
Bƣớc 5: Chọn đến mục nhƣ hình ở dƣới ( chọn 2 lần ).
Bƣớc 6: Chọn vào hình chữ nhật nhƣ hình dƣới và thay đổi thông tin giồng
hình.
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: 0395 304 802
432
Bƣớc 7: Chọn vào hình chữ nhật nhƣ hình dƣới và thay đổi thông tin giồng
hình.
Bƣớc 8: Chọn vào hình tam giác nhƣ hình dƣới để chuyển qua chế độ online
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: 0395 304 802
433
Hình ảnh thực tế:
13.
Thiết kế xe 2 bánh tự cân bằng sử dụng board ardunio.
Mục tiêu:
 Thiết kế mô hình xe 2 bánh tự cân bằng sử dụng board arduino áp
dụng luật điều khiển tối ƣu bền vững ( µ tổng hợp ).
Phần mền cần chuẩn bị

Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:







1 arduino mega2560.
Dây cắm test board.
1bộ khung xe robot 2 bánh cân bằng.
3 tấm mica 5mm ( 7cm x 12 cm ) .
1 module L298n.
1 công tắc ON/OFF.
8 trục dồng 5cm.
Khung xe robot 2 bánh:( Lưu ý: chúng ta có thể thay bánh xe loại có ma sát tốt
hơn )
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: 0395 304 802
434
Board Arduino mega 2560:
Module điều khiển động cơ L298n:
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: 0395 304 802
435
Cảm biến góc nghiêng ( mpu 6050):
Nguồn ( 3 pin 3.7V ) và đế 3 pin 3.7V mắc nối tiếp:
Một số phụ kiện khác như: tấm mica, công tắc, dây cắm test và 8 trục đồng 5 cm.
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: 0395 304 802
436
Lắp mạch nguyên lý:
Code chương trình: (code hoàn chỉnh link kèm theo)
https://drive.google.com/file/d/1bMTQRZUwvafHIAA1piCfH6gLgI15_5kj/view
#include <Wire.h>
#include "Kalman.h" // Source: https://github.com/TKJElectronics/KalmanFilter
#include <avr/io.h>
#include <avr/interrupt.h>
Kalman kalmanX;
Kalman kalmanY;
int motor1 = 9;
// pin PWM motor 1
int motor2 = 10;
// pin PWM motor 2
int dir1PinL = 4;
int dir2PinL = 5;
int dir1PinR = 6;
int dir2PinR = 7;
int EnPhaseA = 2;
// Pin encoder phase A
int EnPhaseB = 3;
// Pin encoder phase B
double Error;
double PreError = 0;
double Blance = 180.0887; // gia tri cân bằng mặcđịnh
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: 0395 304 802
437
unsigned long lastTime;
double gyroXrate; //theta dot
int TimerCount = 0;
int Button = 0;
int Run = 0;
//Run or not run
volatile long Pulse =0, PrePulse = 0, DeltaPulse =0;
float Distance =0; // m
float a = 1; //0.2;
float Velocity = 0; // (m/s)
float Diameter = 0.07; // 70cm
//các hệ số K cần tìm bằng cách chạy file matlab kèm theo.
float K1 = 40;
float K2 = -0.0030;
float K3 = 1.8764;
float K4 = 0.2;
float Output_H = 0;
int Output_H_1 =0, Output_H_2 = 0;
int16_t accX, accY, accZ;
int16_t tempRaw;
int16_t gyroX, gyroY, gyroZ;
double accXangle, accYangle;
double temp;
double gyroXangle, gyroYangle;
double compAngleX, compAngleY;
double kalAngleX, kalAngleY;
uint32_t timer;
uint8_t i2cData[14];
// Buffer for I2C data
void setup() {
pinMode(EnPhaseA, INPUT);
pinMode(EnPhaseB, INPUT);
digitalWrite(2,LOW);
digitalWrite(3,LOW);
attachInterrupt(0, UpdateRotation, RISING);
pinMode(18, INPUT_PULLUP);
//=====================Khai bao dk motor
====================================//
pinMode(motor1,OUTPUT);
pinMode(dir1PinL,OUTPUT);
pinMode(dir2PinL,OUTPUT);
pinMode(motor2,OUTPUT);
pinMode(dir1PinR,OUTPUT);
pinMode(dir2PinR,OUTPUT);
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: 0395 304 802
438
//=================== Giao tiep I2C va loc
Kalmal==============================//
Serial.begin(115200);
Wire.begin();
i2cData[0] = 7;
i2cData[1] = 0x00;
filtering, 8 KHz sampling
while(i2cRead(0x75,i2cData,1));
if(i2cData[0] != 0x68) {
Serial.print(F("Error reading sensor"));
while(1);
}
delay(100); // Wait for sensor to stabilize
while(i2cRead(0x3B,i2cData,6));
accX = ((i2cData[0] << 8) | i2cData[1]);
accY = ((i2cData[2] << 8) | i2cData[3]);
compAngleX = accXangle;
compAngleY = accYangle;
}
Hình ảnh thực tế: ( bánh xe đƣợc thay loại có ma sát tốt hơn )
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: 0395 304 802
439
14.
Thiết kế mô hình hẹn giờ bật tắt thiết bị sử dụng module
DS1307 và arduino.
Mục tiêu:

Thiết kế mô hình hẹn giờ bật tắt thiết bị sử dụng module ds1307 và arduino
hiển thị lên màn hình LCD.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:







1 arduino.
Dây cắm test board.
1 module DS1307.
1 LCD16x02.
1 module I2C cho LCD.
1 trở 220 Ohm.
1 led don 5mm.
Lắp mạch nguyên lý:
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: 0395 304 802
440
Code chương trình:
https://drive.google.com/file/d/15dgJIvK6DbXV7FInyFCdF7r4k0SQHNDO/view?usp=drive_open
#include <Wire.h> // thư viện I2C
#include<EEPROM.h> // Thư viện EEPROM
#include <RTClib.h>
#include <LiquidCrystal_I2C.h>
byte degree[8] =
{
0B01110,
0B01010,
0B01110,
0B00000,
0B00000,
0B00000,
0B00000
};
RTC_DS1307 RTC;
LiquidCrystal_I2C lcd(0x27,16,2); // dịa chỉ của I2C
int temp,inc,hours1,minut,add=11;
int next=12; // nút nhấn chuyển sang trang thái khác.
int INC=11; // nút nhấn tang giờ hoặc phút
int set_mo=10; // nút nhấn set mở thiết bị
int set_tat=9; // nút nhấn set tắt thiết bị
#define buzzer 13 // chân dều khiển thiết bị hoặc loa.
int HOUR,MINUT,SECOND;
void setup()
{
Serial.begin(9600);
Wire.begin();
RTC.begin();
lcd.backlight();
lcd.begin(16,2);
lcd.init();
lcd.createChar(1, degree);
pinMode(INC, INPUT);
pinMode(next, INPUT);
pinMode(set_mo, INPUT);
pinMode(set_tat, INPUT);
pinMode(buzzer, OUTPUT);
digitalWrite(next, HIGH);
digitalWrite(set_mo, HIGH);
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: 0395 304 802
441
digitalWrite(INC, HIGH);
digitalWrite(set_tat, HIGH);
digitalWrite(buzzer, 0);
lcd.setCursor(0,0);
lcd.print("Real Time Clock");
lcd.setCursor(0,1);
lcd.print("Circuit Digest ");
delay(2000);
if(!RTC.isrunning())
{
RTC.adjust(DateTime(__DATE__,__TIME__)); // upload code lần đầu các bạn mở dòng
code này sau dó upload code lại 1 lần nữa thì xóa dòng code này đi nhé.
}
}
void loop()
{
int temp=0,val=1,temp4;
DateTime now = RTC.now();
if(digitalRead(set_mo) == 0)
{
lcd.setCursor(0,0);
lcd.print(" Set ON ");
delay(2000);
defualt();
time();
delay(1000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Alarm time ");
lcd.setCursor(0,1);
lcd.print(" has been set ");
delay(2000);
}
if(digitalRead(set_tat) == 0)
{
lcd.setCursor(0,0);
lcd.print(" Set OFF ");
delay(2000);
defualt();
time();
delay(1000);
//cài đặt thời gian bật thiết bị
//cài đặt thời gian tắt thiết bị
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: 0395 304 802
442
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Alarm time ");
lcd.setCursor(0,1);
lcd.print(" has been set ");
delay(2000);
}
lcd.clear(); // xóa màn hình LCD
lcd.setCursor(0,0);
lcd.print("Time:"); // in dòng chữ Time ở cột 0 và hàng 0
lcd.setCursor(6,0);
lcd.print(HOUR=now.hour(),DEC); // in giờ ở cột 6 và hàng 0
lcd.print(":");
lcd.print(MINUT=now.minute(),DEC);
lcd.print(":");
lcd.print(SECOND=now.second(),DEC);
lcd.setCursor(0,1);
lcd.print("Date: ");
lcd.print(now.day(),DEC);
lcd.print("/");
lcd.print(now.month(),DEC);
lcd.print("/");
lcd.print(now.year(),DEC);
match();
match1();
delay(500);
}
void defualt()
{
lcd.setCursor(0,1);
lcd.print(HOUR);
lcd.print(":");
lcd.print(MINUT);
lcd.print(":");
lcd.print(SECOND);
}
void time()
{
int temp=1,minuts=0,hours=0,seconds=0;
while(temp==1) // trường hợp temp bằng 1
{
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: 0395 304 802
443
if(digitalRead(INC)==0) // nếu nút INC được nhấn thì tăng biến giờ lên 1 đơn vị
{
HOUR++;
if(HOUR==24)
{
HOUR=0;
}
while(digitalRead(INC)==0);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Set Alarm Time ");
//lcd.print(x);
lcd.setCursor(0,1);
lcd.print(HOUR);
lcd.print(":");
lcd.print(MINUT);
lcd.print(":");
lcd.print(SECOND);
delay(100);
if(digitalRead(next)==0)
{
hours1=HOUR;
EEPROM.write(add++,hours1);
temp=2;
while(digitalRead(next)==0);
}
}
while(temp==2) // trường hợp temp bằng 2
{
if(digitalRead(INC)==0) // nếu nút INC được nhấn thì tăng biến phút lên 1 đơn vị
{
MINUT++;
if(MINUT==60)
{MINUT=0;}
while(digitalRead(INC)==0);
}
// lcd.clear();
lcd.setCursor(0,1);
lcd.print(HOUR);
lcd.print(":");
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: 0395 304 802
444
lcd.print(MINUT);
lcd.print(":");
lcd.print(SECOND);
delay(100);
if(digitalRead(next)==0)
{
minut=MINUT;
EEPROM.write(add++, minut);
temp=0;
while(digitalRead(next)==0);
}
}
delay(1000);
}
void match()// chương trình con bật thiết bị
{
int tem[23];
for(int i=11;i<23;i++)
{
tem[i]=EEPROM.read(i);
}
if(HOUR == tem[11] && MINUT == tem[12]) // biến giờ lưu vị trí 11, phút ở 12
{
digitalWrite(buzzer, HIGH);// bật thiết bị lên khi đúng giờ cài đặt
}
}
void match1()// chương trình con tắt thiết bị
{
int tem1[23];
for(int j=11;j<23;j++)
{
tem1[j]=EEPROM.read(j);
}
if(HOUR == tem1[13] && MINUT == tem1[14])
{
digitalWrite(buzzer, LOW);
}
}
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: 0395 304 802
445
Hình ảnh thực tế:
15.
Thiết kế mô hình xe 4 bánh diều khiển bằng sóng Wifi sử
board NodeMCU và app Blynk ( công cụ Joystick ).
Mục tiêu:

Thiết kế xe 4 bánh diều khiển bằng sóng wifi sử dụng board nodeMCU và
app blynk ( công cụ joystick ).
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
 Cài dặt app blynk vào diện thoại.
Phần cứng cần chuẩn bị:
 1 Mạch Node MCU.
 1 smartphone andriod hoặc IOS.
 Dây cắm test board.
 1 module cảm biến chuyển dộng.
Lắp mạch nguyên lý:
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: 0395 304 802
446
Lắp mô hình:
Lắp mô hình hoàn toàn giống với bài số 7.
Code chương trình:
https://drive.google.com/file/d/1BQ2tpaSQP5w26wbO-0e4ETn2sQxPdnEg/view
#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
char auth[] = "xxxxxxxxxxxxxxxxxx"; // mã token này duợc gửi vào email của bạn sau
khi dang kí 1 project của blynk
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: 0395 304 802
447
// Your WiFi credentials.
char ssid[] = "Trinh Quang Nam."; //tên wifi nhà bạn
char pass[] = "bubu123789";
//mật khẩu
BlynkTimer timer;
const byte L298N_A_pin = D5; // GPI05-- ENA
const byte L298N_A_In1_pin = D8; //GPI04
const byte L298N_A_In2_pin = D7; //GPI0
const byte L298N_B_In3_pin = D4; // GPI02
const byte L298N_B_In4_pin = D3; // GPIO14
const byte L298N_B_pin = D6; //GPI12 -- ENB
byte SolSinyal = 0;
byte SagSinyal = 0;
byte ArkaLamba = 0;
void motorSpeed(int prmA, byte prmA1, byte prmA2, int prmB, byte prmB1, byte prmB2)
{
analogWrite(L298N_A_pin,prmA);
analogWrite(L298N_B_pin,prmB);
digitalWrite(L298N_A_In1_pin,prmA1);
digitalWrite(L298N_A_In2_pin,prmA2);
digitalWrite(L298N_B_In3_pin,prmB1);
digitalWrite(L298N_B_In4_pin,prmB2);
}
BLYNK_WRITE(V0) {
int x = param[0].asInt();
int y = param[1].asInt();
// x = -2 -1 0 1 2
// Y = -2 -1 0 1 2
if (y>=0)
{
ArkaLamba = 0;
// digitalWrite(Led4_pin,LOW);
}
else
{
ArkaLamba = 1;
SolSinyal = 1;
SagSinyal = 1;
}
if ((x==0) && (y==0)) /// stop
{
motorSpeed(0,LOW,LOW,0,LOW,LOW);
SolSinyal = 0;
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: 0395 304 802
448
SagSinyal = 0;
}
else if ((x==0) && (y>0))
{
if (y==1){ motorSpeed(700,HIGH,LOW,700,HIGH,LOW); } // turn right
else { motorSpeed(900,HIGH,LOW,900,HIGH,LOW); }
SolSinyal = 0;
SagSinyal = 0;
}
else if ((y==0) && (x>0))
{
motorSpeed(900,HIGH,LOW,900,LOW,HIGH); // tiến
SagSinyal = 1;
}
else if ((y>0) && (x>0))
{
motorSpeed(900,HIGH,LOW,700,LOW,LOW);
SagSinyal = 1;
}
else if ((y==0) && (x<0))
{
motorSpeed(900,LOW,HIGH,900,HIGH,LOW); // rẻ trái
SolSinyal = 1;
}
else if ((y>0) && (x<0))
{
}
void setup() {
Serial.begin(115200);
pinMode(L298N_A_In1_pin,OUTPUT);
pinMode(L298N_A_In2_pin,OUTPUT);
pinMode(L298N_B_In3_pin,OUTPUT);
pinMode(L298N_B_In4_pin,OUTPUT);
digitalWrite(L298N_A_In1_pin,LOW);
digitalWrite(L298N_A_In2_pin,LOW);
digitalWrite(L298N_B_In3_pin,LOW);
digitalWrite(L298N_B_In4_pin,LOW);
Blynk.begin(auth, ssid, pass);
timer.setInterval(1000L, sendTemps);
}
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: 0395 304 802
449
void sendTemps()
{
}
void loop() {
Blynk.run();
timer.run();
}
Upload code cho Nodemcu ( truớc khi upload phải chọn giống như hình duới)
Cài app blynk cho diện thoại:
Bước 1: Tải app blynk trên CH play hoặc App Store
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: 0395 304 802
450
Bước 2: Mở app lên đăng kí tài khoản miễn phí bằng email sau dó chọn NEW
PROJECT.
Bước 3: Chọn vào nút OK sau đó dùng tay trượt theo dấu mũi tên .
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: 0395 304 802
451
Bước 4: Chọn đến mục như hình ở dưới.
Bước 5: Click vào joystick ta chỉnh sửa giống như hình dưới. Chọn vào hình
tam giác để hoàn thành app.
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: 0395 304 802
452
Bước 6: Bật công tắc nguồn cho xe và app đã kết nối với Wifi và chúng ta có thể điều
khiển xe chạy tiến lùi ,…
16.
Thiết kế mô hình xe robot 3 bánh tự hành sử dụng board
ardunio.
Mục tiêu:

Thiết kế mô hình xe robot tự hành sử dụng board arduino.
Phần mền cần chuẩn bị

Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 1 arduino.
 Dây cắm test board.
 1 module l298n.
 1 động cơ servo 9g.
 1 module SRF05 (cảm biến khoảng cách).
 1 khung xe 3 bánh hoặc 4 bánh.
 1 dế 3 pin ( 3.7 V ).
 3 viên pin 18650 ( 3.7 V) , Có thể dùng pin 9V.
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: 0395 304 802
453

2 cây keo nến.
Lắp mạch nguyên lý:
Arduino
L298n
SRF05
Servo
GND
GND (--)
GND
Dây nâu
5V
3
+5VDC
IN1
VCC
Dây đỏ
11
5
IN2
IN3
6
A1
A5
10
IN4
Nguồn pin
Trig
Echo
Dây màu cam
gnd
12+
Gnd ( - )
(+)
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: 0395 304 802
454
Lắp mô hình:
Lắp mô hình khung xe 3 bánh như hình dưới
Lắp động cơ servo và cảm biến khoảng cách như hình sau ( dùng keo nến để
kết nối cảm biến và servo )
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: 0395 304 802
455
Lắp mô hình hoàn chỉnh sau khi kết nối dây dẫn như sơ đồ nguyên lý:
( dùng keo nến để dính các khối lên khung xe )
Code chương trình:
https://drive.google.com/file/d/1gjxq1g_s6jDvJ36MWWXu-fFIC8KrQgq9/edit
#include <Servo.h>
//thư viện điều khiển động cơ servo
#include <NewPing.h> //thư viện hổ trợ cảm biến khoang cach srf05 cần phải cài
//our L298N control pins
const int LeftMotorForward = 11;// IN2
const int LeftMotorBackward = 3;// IN1
const int RightMotorForward = 6;// IN4
const int RightMotorBackward = 5;// IN3
#define trig_pin A1
//A1
#define echo_pin A2
//A2
#define maximum_distance 200 // Khoảng cách tối đa 20 cm
boolean goesForward = false;
int distance = 100;
int vel = 150;
NewPing sonar(trig_pin, echo_pin, maximum_distance);
Servo servo_motor;
void setup(){
pinMode(RightMotorForward, OUTPUT);
pinMode(LeftMotorForward, OUTPUT);
pinMode(LeftMotorBackward, OUTPUT);
pinMode(RightMotorBackward, OUTPUT);
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: 0395 304 802
456
servo_motor.attach(10);
servo_motor.write(90);
delay(2000);
distance = readPing();
delay(100);
distance = readPing();
delay(100);
distance = readPing();
delay(100);
distance = readPing();
delay(100);
// chân diều khiển dộng co servo 10
}
void loop(){
int distanceRight = 0;
int distanceLeft = 0;
delay(50);
if (distance <= 20){
moveStop();
delay(300);
moveBackward();
delay(400);
moveStop();
delay(300);
distanceRight = lookRight();
delay(300);
distanceLeft = lookLeft();
delay(300);
if (distance >= distanceLeft){
turnRight();
moveStop();
}
else{
turnLeft();
moveStop();
}
}
else{
moveForward();
}
distance = readPing();
}
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: 0395 304 802
457
int lookRight(){
servo_motor.write(10);
delay(500);
int distance = readPing();
delay(100);
servo_motor.write(90);
return distance;
}
int lookLeft(){
servo_motor.write(170);
delay(500);
int distance = readPing();
delay(100);
servo_motor.write(90);
return distance;
delay(100);
}
int readPing(){
delay(70);
int cm = sonar.ping_cm();
if (cm==0){
cm=250;
}
return cm;
}
void moveStop(){
// xe dừng
analogWrite(RightMotorForward, LOW);
analogWrite(LeftMotorForward, LOW);
analogWrite(RightMotorBackward, LOW);
analogWrite(LeftMotorBackward, LOW);
}
void moveForward(){ // xe chạy tiến
if(!goesForward){
goesForward=true;
analogWrite(LeftMotorForward, vel);
analogWrite(RightMotorForward, vel);
analogWrite(LeftMotorBackward, LOW);
analogWrite(RightMotorBackward, LOW);
}
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: 0395 304 802
458
}
void moveBackward(){ //xe chạy lùi
goesForward=false;
analogWrite(LeftMotorBackward, vel);
analogWrite(RightMotorBackward, vel);
analogWrite(LeftMotorForward, LOW);
analogWrite(RightMotorForward, LOW);
}
void turnRight(){ // xe rẻ phải
analogWrite(LeftMotorForward, vel);
analogWrite(RightMotorBackward, vel);
digitalWrite(LeftMotorBackward, LOW);
digitalWrite(RightMotorForward, LOW);
delay(500);
analogWrite(LeftMotorForward, vel);
analogWrite(RightMotorForward, vel);
analogWrite(LeftMotorBackward, LOW);
analogWrite(RightMotorBackward, LOW);
}
void turnLeft(){ // xe rẻ trái
analogWrite(LeftMotorBackward, vel);
analogWrite(RightMotorForward, vel);
analogWrite(LeftMotorForward, LOW);
analogWrite(RightMotorBackward, LOW);
delay(500);
analogWrite(LeftMotorForward, vel);
analogWrite(RightMotorForward, vel);
analogWrite(LeftMotorBackward, LOW);
analogWrite(RightMotorBackward, LOW);
}
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: 0395 304 802
459
17.
Ðiều khiển góc quay động cơ buớc bằng nút nhấn sử dụng
board arduino.
Mục tiêu:

Ðiều khiển góc quay dộng co bƣớc bằng nút nhấn sử dụng board arduino.
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:






1 board arduino.
Dây cắm test board.
1 breadboard.
1 driver điều khiển động cơ bước A4988.
1 động cơ bước 1.8 độ / step (0.4A).
1 bộ nguồn (8 – 35Vdc).
 3 nút nhấn 4 chân.
Lắp mạch nguyên lý:
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: 0395 304 802
460
Sơ đồ mạch nối driver A4988 và động cơ bước: ( lưu ý nếu sử dụng 2 nguồn riêng phải
nối chung chân GND của 2 nguồn với nhau )
Code chương trình:
https://drive.google.com/file/d/19lBEAcOHlYqC1s7VhJEFaJjQK5p6e-JB/view
const int stepPin = 5;
const int dirPin = 2;
const int enPin = 8;
const int b1 = A1; // nút nhấn 1
const int b2 = A2; // nút nhấn 2
const int b3 = A3; // nút nhấn 3
int currentAngle = 0;
int angle = 0; // góc quay
float stepPerAngle = 1.8; // full step = 1.8
int numstep;
void setup() {
Serial.begin(9600); // tốc độ baud 9600
pinMode(stepPin,OUTPUT);
pinMode(dirPin,OUTPUT);
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: 0395 304 802
461
pinMode(enPin,OUTPUT);
digitalWrite(enPin,LOW);
digitalWrite(dirPin,HIGH);
pinMode(b1, INPUT); // khai báo chân nút nhấn là chân vào
pinMode(b2, INPUT);
pinMode(b3, INPUT);
digitalWrite(b1,HIGH);
digitalWrite(b2,HIGH);
digitalWrite(b3,HIGH);
}
void loop() {
int n;
if( digitalRead(b1) == 0){ // nếu nút nhấn b1 được nhấn thì gán góc quay là 0 độ
angle = 0;
}
else if( digitalRead(b2) == 0){ // nếu nút b2 được nhấn thì gán góc quay là 90 độ
angle = 90;
}
else if( digitalRead(b3) == 0){ // nếu nút b3 được nhấn thì gán góc quay là 270 độ
angle = 270;
}
if( currentAngle != angle ){
if( currentAngle < angle){
digitalWrite(dirPin,HIGH); // quay theo chiều thuận
n = angle - currentAngle;
numstep = n / stepPerAngle; // số step cần phải quay
}
else if( currentAngle > angle){
digitalWrite(dirPin,LOW); // quay theo chiều thuận
n = currentAngle - angle;
if( angle == 0){
n =currentAngle;
}
numstep = n / stepPerAngle; // số step cần quay của động cơ bước
}
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: 0395 304 802
462
for(int x = 0; x < numstep; x++) {
digitalWrite(stepPin,HIGH);
delayMicroseconds(1000); // ta có thể thay dòng số này để chỉnh tốc độ quay
digitalWrite(stepPin,LOW);
delayMicroseconds(1000); //// ta có thể thay dòng số này để chỉnh tốc độ quay
}
currentAngle = angle;
}
delay(500);
}
Hình ảnh thực tế:
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: 0395 304 802
463
18.
Thiết kế xe robot 4 bánh điều khiển bằng giọng nói sử dụng
board arduino.
Mục tiêu:

Thiết kế xe robot diều khiển bằng giọng nói.
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
 Ðăng kí 1 tài khoản miễn phí trên MIT App Inventor 2 .
Phần cứng cần chuẩn bị: ( Tuong tự với xe cấp dộ 1 )













1 board arduino uno hoặc nano,...
1 điện thoại sử dụng hệ điều hành andriod.
1 mạch điều khiển động cơ L298N.
Dây test board.
1 module bluetooth HC05 hoặc HC06.
4 động cơ giảm tốc V1 màu vàng.
4 bánh xe robot.
1m dây điện nhỏ.
1 công tắc on/off.
1 đế 3 pin nối tiếp cho pin 3.7 VDC.
3 pin 3.7VDC. ( Loại pin sạc : 18650 ).
2 cây keo nến.
1 tấm mica 3mm hoặc gỗ (rộng: 11cm, dài : 17cm).
Lắp mạch nguyên lý:
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: 0395 304 802
464
Arduino
L298n
HC05
GND
GND (--)
GND
5V
5
+5VDC
ENB
VCC
6
7
IN4
IN3
11
12
13
ENA
IN1
IN2
2
3
Tx
rx
12+ (nối từ pin)
GND (--)
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: 0395 304 802
465
Lắp mô hình: tương tự như xe robot 4 bánh ở trên
Bước 1: Hình dưới là xe robot hoàn thành.
Bước 2: Tải file code chương trình tại link dưới và upload code cho board
arduino uno.
https://drive.google.com/open?id=1Vr8l2zLYUlkjwy-CvCevN-MVMtpem8qf
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: 0395 304 802
466
Bước 3: Tải file add điều khiển về điện thoại theo link kèm theo
https://drive.google.com/open?id=1Pd_XTz5B63SznwV78hnHK80d3lp16jnK
Sau khi tải về và cài đặt ta đƣợc app như hình dưới.
Bước 4: Lắp pin vào xe robot và bật công tắc ON/OFF lên, trường hợp đã
gắn cảm biến dò line lên xe chúng ta không cần phải gỡ ra.
Bước 5: Kết nối bluetooth của xe robot và điện thoại, mở bluetooth của điện
thoại lên và dò tên bluetooth của xe và pass của bluetooth thường là 1234.
Sau dó mở app điều khiển xe robot lên.
Sau khi chọn nút bluetooth sẽ hiện ra cửa sổ như hình dƣới và chúng ta chọn đúng
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: 0395 304 802
467
vào mã của module bluetooth HC05 ( Lưu ý: mỗi bluetooth sẽ có mã khác nhau)
Khi màn hình app xuất hiện chữ connected có nghia việc kết nối đã thành công.
Bước 6: Chọn vào nút speak something dể điều khiển bằng giọng nói.
Chọn vào nút speak something để điều khiển bằng giọng nói. Và bạn có thể
thêm tính năng hoặc thay đổi từ trong file code.
+ Ði thẳng với : "Go"
+ Rẻ trái : "Turn left"
+ Rẻ phải: "Turn Right"
+ Rẻ phải: "stop"
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: 0395 304 802
468
19.
Thiết kế mô hình mở cửa tự dộng sử dụng module RC522 và
board arduino ( nhà thông minh).
Mục tiêu:

Thiết kế mô hình mở cửa tự động sử dụng module RC522 và board arduino.
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:









1 board arduino.
Dây cắm test board.
1 module thẻ tử RC522.
1 động cơ servo 9g.
1 loa 5Vdc.
1 led dỏ 5mm.
1 led xanh 5mm.
2 trở 220 Ohm.
1 cây keo nến.
Lắp mạch nguyên lý:
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: 0395 304 802
469
Arduino
MFRC522
SERVO
LOA
GND
GND (--)
Dây nâu
GND (-)
Dây đỏ
5V
3.3V
3.3V
11
12
MOSI
MISO
13
10
9
SCK
SDA(SS)
RST
6
5
Dây cam
Dƣơng +
Code chương trình:
Bước 1: Add thư viện MFRC522 cho phần mền IDE ( 1.6.8 trở lên).
Ta chọn Sketch  Inlude Library  Manage Libraries.
Trong quá trình cài thư viện thì máy tính phải kết nối INTERNET.
Bước 2: Sau khi cài thư viện MFRC522 cho IDE và đã kết nối mạch như hình
vẽ ở trên, ta upload code sau để đọc UID của thẻ từ.
https://drive.google.com/open?id=1iinyGb4RBwrTxz7sMFkTEDhfQF2gjAYY
#include <SPI.h>
#include <MFRC522.h>
#define RST_PIN
9
// chân Reset nối với chân số 9
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: 0395 304 802
470
#define SS_PIN
10
// chân SS nối với chân số 10
MFRC522 mfrc522(SS_PIN, RST_PIN);
void setup() {
Serial.begin(9600);
while (!Serial);
SPI.begin();
// Init SPI bus
mfrc522.PCD_Init(); // Init MFRC522
mfrc522.PCD_DumpVersionToSerial();
Reader details
Serial.println(F("Quet ma UID cua the..."));
}
void loop() {
if ( ! mfrc522.PICC_IsNewCardPresent()) {
return;
}
if ( ! mfrc522.PICC_ReadCardSerial()) {
return;
}
mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
}
Bước 3: Sau khi upload code ta mở serial monitor lên và đƣa thẻ từ vào board
MFRC522.
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: 0395 304 802
471
Ta lưu lại mã UID : DA AC F3 0B
Bước 3: Chỉnh sửa lại code sau( thay mã UID thẻ của bạn ) và upload cho
board arduino.
https://drive.google.com/open?id=1qiMmkY0g5pDIayn7mIM_OLpf3Jjfk-KH
#include <SPI.h> // THU VIEN SPI
#include <MFRC522.h> // THU VIEN RC522
#include <Servo.h> // THU VIEN DK DONG CO SERVO
#define SS_PIN 10 // DINH DỊA CHỈ CHO RC522
#define RST_PIN 9 // chan reset
int ledxanh = 2;
int leddo =3;
int loa = 5;
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
Servo myServo;
void setup()
{
Serial.begin(9600);
SPI.begin();
// khoi dong SPI
mfrc522.PCD_Init(); // Initiate MFRC522
myServo.attach(6); //servo pin CHAN NOI ARDUINO
myServo.write(0); //servo O do
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: 0395 304 802
472
Serial.println("Put your card to the reader...");
Serial.println();
pinMode(ledxanh,OUTPUT);
pinMode(leddo,OUTPUT);
pinMode(loa,OUTPUT);
}
void loop()
{
// Look for new cards
if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}
// Select one of the cards
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
Serial.print("UID tag :");
String content= "";
byte letter;
for (byte i = 0; i < mfrc522.uid.size; i++)
{
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
Serial.print(mfrc522.uid.uidByte[i], HEX);
content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
content.concat(String(mfrc522.uid.uidByte[i], HEX));
}
Serial.println();
Serial.print("Message : ");
content.toUpperCase();
if (content.substring(1) == "DA AC F3 0B")// thay mã UID thẻ của bạn ở dây
{
Serial.println("Ma hop le");
Serial.println();
delay(500);
digitalWrite(ledxanh, HIGH);
myServo.write(180);
delay(2000);
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: 0395 304 802
473
myServo.write(0);
digitalWrite(ledxanh, LOW);
}
else {
Serial.println(" khong hop le");
digitalWrite(leddo, HIGH);
digitalWrite(loa, HIGH);
delay(1000);
digitalWrite(leddo, LOW);
digitalWrite(loa, LOW);
}
}
Bước 4: Trường hợp thẻ hợp lệ động cơ servo quay mở cửa và đèn xanh sáng,
ngược lại động cơ servo không quay cửa dóng , đèn đỏ sáng và đồng thời loa
kêu.
Trường hợp này các bạn có thể cải tiến bằng then cửa từ, khi áp dụng thực tế nhé.
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: 0395 304 802
474
20.
Thiết kế mô hình hiển thị giờ, nhiệt dộ và dộ ẩm lên module led
matrix 32x8 sử dụng board arduino.
Mục tiêu:

Thiết kế mô hình hiển thị giờ, nhiệt dộ và dộ ẩm ( dht11) lên module led
matrix 32x8 sử dụng arduino.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:






1 board arduino.
Dây cắm test board.
1 module ds1307.
1 module dht11.
3 nút nhấn 4 chân.
3 trở 10K.
 1 module led ma trận 32x8 max 7219.
Lắp mạch nguyên lý:
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: 0395 304 802
475
Arduino
LED
MATRIX
GND (--)
DS1307
DHT11
GND
GND (-)
5V
2
VCC
VCC
VCC+
OUT
11
10
DIN
CS
13
A4
A5
CLK
GND
NÚT
NHẤN
SDA
SCL
3
4
5
N1
N2
N3
Code chương trình:
Các bạn lưu ý trong file download về có 4 file thư viện các bạn phải add 4 file thư
viện dó vào phần mền IDE mới sử dụng đƣợc code nhé. Link tải code:
https://drive.google.com/file/d/1G_PFGn6-oZbDLjdBD93BRXPy4q1lUllE/view
# define USE_DS1307
#include <MD_Parola.h> // thu viện duợc dính kèm trong file code
#include <MD_MAX72xx.h>
#include <SPI.h>
#include <Wire.h>
#include <MD_DS1307.h>
#include "DHT.h"
#define DHTPIN 2
// chân dọc tín hiệu của dht 11 là chân số 2
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
#include "Font.h"
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4 // với 4 là 1 module max7219
#define CLK_PIN 13
#define DATA_PIN 11
#define CS_PIN 10
MD_Parola P = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
volatile boolean buttonA = false;
volatile boolean buttonB = false;
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: 0395 304 802
476
volatile boolean buttonC = false;
int StateOfbuttonA = 0;
int StateOfbuttonB = 0;
int StateOfbuttonC = 0;
int NewStateOfbuttonA = 0;
int NewStateOfbuttonB = 0;
int NewStateOfbuttonC = 0;
int temp;
int Humi;
int Mode = 0;
int contrast = 0;
int SPEED_TIME = 75;
#define PAUSE_TIME 0
#define MAX_MESG 20
char szTime[9]; // hh:mm
char szsecond[4]; // ss
char szMesg[MAX_MESG+1] = "";
uint8_t degC[] = { 6, 3, 3, 56, 68, 68, 68 }; // Deg C
char *mon2str(uint8_t mon, char *psz, uint8_t len)
{
static const __FlashStringHelper* str[] =
{
F("Jan"), F("Feb"), F("Mar"), F("Apr"),
F("May"), F("Jun"), F("Jul"), F("Aug"),
F("Sep"), F("Oct"), F("Nov"), F("Dec")
};
strncpy_P(psz, (const char PROGMEM *)str[mon-1], len);
psz[len] = '\0';
void setup(void)
{
dht.begin();
pinMode(3, INPUT_PULLUP);
pinMode(4, INPUT_PULLUP);
pinMode(5, INPUT_PULLUP);
P.begin(3);
P.setInvert(false);
P.setZone(2, 0, 3);
P.setZone(1, 1, 3);
P.setZone(0, 4, 1);
P.setFont(1, numeric7Se);
P.setFont(0, numeric7Seg);
P.displayZoneText(1, szTime, PA_LEFT, SPEED_TIME, PAUSE_TIME, PA_PRINT,
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: 0395 304 802
477
PA_NO_EFFECT);
P.displayZoneText(0, szsecond, PA_LEFT, SPEED_TIME, 0, PA_PRINT,
PA_NO_EFFECT);
P.displayZoneText(2, szMesg, PA_CENTER, SPEED_TIME, 0, PA_PRINT,
PA_SCROLL_LEFT);
P.addChar('$', degC);
RTC.control(DS1307_CLOCK_HALT, DS1307_OFF);
RTC.control(DS1307_12H, DS1307_OFF);
getTime(szTime);
}
void loop(void)
{
P.setIntensity(contrast);
NewStateOfbuttonA = digitalRead(3);
NewStateOfbuttonB = digitalRead(4);
NewStateOfbuttonC = digitalRead(5);
buttonAisPressed();
buttonBisPressed();
buttonCisPressed();
if (buttonA) {
if (Mode == 0 ) {
buttonA = false;
contrast++;
if (contrast >= 51 ) {
contrast = 50;
}
}
else if (Mode == 1 ) {
buttonA = false;
Mode = 0;
}
else if (Mode == 2 ) {
buttonA = false;
RTC.h++;
if (RTC.h >= 24 ) {
RTC.h = 0;
}
RTC.writeTime();
}
else if (Mode == 3 ) {
buttonA = false;
RTC.m++;
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: 0395 304 802
478
if (RTC.m >= 60 ) {
RTC.m = 0;
}
RTC.writeTime();
}
else if (Mode == 4 ) {
buttonA = false;
RTC.s = 0;
RTC.writeTime();
}
else if (Mode == 5 ) {
buttonA = false;
RTC.dow++;
if (RTC.dow >= 8 ) {
RTC.dow = 1;
}
RTC.writeTime();
P.displayReset(2);
}
else if (Mode == 6 ) {
buttonA = false;
RTC.dd++;
if (RTC.dd >= 32 ) {
RTC.dd = 1;
}
RTC.writeTime();
}
else if (Mode == 7 ) {
buttonA = false;
RTC.mm++;
if (RTC.mm >= 13 ) {
RTC.mm = 1;
}
RTC.writeTime();
}
else if (Mode == 8 ) {
buttonA = false;
RTC.yyyy++;
if (RTC.yyyy >= 2035 ) {
RTC.yyyy = 2015;
}
RTC.writeTime();
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: 0395 304 802
479
}
}
else if (buttonB) {
buttonB = false;
Mode++;
P.displayReset(2);
if (Mode >= 9 ) {
Mode = 0;
}
}
if (buttonC) {
if (Mode == 0 ) {
buttonC = false;
contrast--;
if (contrast <= 0 ) {
contrast = 0;
}
}
else if (Mode == 1 ) {
buttonC = false;
Mode = 0;
}
else if (Mode == 2 ) {
buttonC = false;
RTC.h--;
if (RTC.h <= 0 ) {
RTC.h = 23;
}
RTC.writeTime();
}
else if (Mode == 3 ) {
buttonC = false;
RTC.m--;
if (RTC.m <= 0 ) {
RTC.m = 59;
}
RTC.writeTime();
}
else if (Mode == 4 ) {
buttonC = false;
RTC.s = 0;
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: 0395 304 802
480
RTC.writeTime();
}
else if (Mode == 5 ) {
buttonC = false;
RTC.dow--;
if (RTC.dow <= 0 ) {
RTC.dow = 7;
}
RTC.writeTime();
P.displayReset(2);
}
else if (Mode == 6 ) {
buttonC = false;
RTC.dd--;
if (RTC.dd <= 0 ) {
RTC.dd = 31;
}
RTC.writeTime();
}
else if (Mode == 7 ) {
buttonC = false;
}
Hình ảnh thực tế:
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: 0395 304 802
481
21.
Thiết kế mô hình hẹn giờ bật tắt thiết bị điện sử dụng module
DS3231 và arduino.
Mục tiêu:

Thiết kế mô hình hẹn giờ bật tắt thiết bị điện sử dụng module DS3231 và
arduino hiển thị lên màn hình LCD.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:






1 board arduino.
Dây cắm test board.
1 module ds3231.
1 module Relay 5Vdc.
3 nút nhấn 4 chân.
1 màn hình LCD 16X02 + I2C.
 1 bóng đèn DC12V hoặc bóng led.
Lắp mạch nguyên lý:
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: 0395 304 802
482
Arduino
I2C for LCD
DS3231
RELAY
GND
GND (--)
GND
DC (-)
5V
A4
VCC
SDA
VCC
SDA
DC+
A5
8
SCL
SCL
NÚT
NHẤN
IN(S)
10
11
12
N1
N2
N3
Code chương trình:
https://drive.google.com/open?id=1FuG1ra_OMJ-9AgYCIwovOHT23rVv-uL5
#include <Wire.h> // Thư viện I2C
#include<EEPROM.h> // Thư viện EEPROM
#include <DS3231.h> // Thư viện DS3231
#include <LiquidCrystal_I2C.h>
DS3231 clock;
RTCDateTime dt;
LiquidCrystal_I2C lcd(0x27,16,2); // Địa chỉ I2C
int temp,inc,hours1,minut,add=11;
int next=10; // Nút nhân 1
int INC=11;
// Nút nhân 2
int set_mad=12; // Nút nhân 3
#define den 8 // relay nối với chân số 8
int HOUR,MINUT,SECOND;
void setup()
{
Serial.begin(9600); // tốc độ baud 9600
Wire.begin();
clock.begin();
lcd.backlight();
lcd.begin(16,2);
lcd.init();
pinMode(INC, INPUT); // biến INC được khai báo là chân vào
pinMode(next, INPUT);
pinMode(set_mad, INPUT);
pinMode(den, OUTPUT);
digitalWrite(den, HIGH);
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: 0395 304 802
483
digitalWrite(next, HIGH);
digitalWrite(set_mad, HIGH);
digitalWrite(INC, HIGH);
lcd.setCursor(0,0);
lcd.print("CAI DAT GIO");
lcd.setCursor(0,1);
lcd.print("Circuit Digest ");
delay(2000);
clock.setDateTime(__DATE__, __TIME__);// lưu ý dòng này nạp code lần đầu như
//code này, sau đó nạp lại 1 lần nữa nhưng bỏ dòng này đi
}
void loop()
{
dt = clock.getDateTime();
int temp=0,val=1,temp4;
if(digitalRead(set_mad) == 0) // set thời gian tắt thiết bị
{
lcd.setCursor(0,0);
lcd.print(" Set Alarm ");
delay(2000);
defualt();
time();
delay(1000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" THOI GIAN NGAT ");
lcd.setCursor(0,1);
lcd.print(" DA SAN SANG ");
delay(2000);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Time:");
lcd.setCursor(6,0);
lcd.print(HOUR= dt.hour);
lcd.print(":");
lcd.print(MINUT= dt.minute);
lcd.print(":");
lcd.print(SECOND= dt.second);
lcd.setCursor(0,1);
lcd.print("Date: ");
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: 0395 304 802
484
lcd.print( dt.day);
lcd.print("/");
lcd.print( dt.month);
lcd.print("/");
lcd.print( dt.year);
match();
delay(200);
}
void defualt()
{
lcd.setCursor(0,1);
lcd.print(HOUR);
lcd.print(":");
lcd.print(MINUT);
lcd.print(":");
lcd.print(SECOND);
}
void time()
{
int temp=1,minuts=0,hours=0,seconds=0;
while(temp==1)
{
if(digitalRead(INC)==0)
{
HOUR++;
if(HOUR==24)
{
HOUR=0;
}
while(digitalRead(INC)==0);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Set Alarm Time ");
//lcd.print(x);
lcd.setCursor(0,1);
lcd.print(HOUR);
lcd.print(":");
lcd.print(MINUT);
lcd.print(":");
lcd.print(SECOND);
delay(100);
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: 0395 304 802
485
if(digitalRead(next)==0)
{
hours1=HOUR;
EEPROM.write(add++,hours1);
temp=2;
while(digitalRead(next)==0);
}
}
while(temp==2)
{
if(digitalRead(INC)==0)
{
MINUT++;
if(MINUT==60)
{MINUT=0;}
while(digitalRead(INC)==0);
}
// lcd.clear();
lcd.setCursor(0,1);
lcd.print(HOUR);
lcd.print(":");
lcd.print(MINUT);
lcd.print(":");
lcd.print(SECOND);
delay(100);
if(digitalRead(next)==0)
{
minut=MINUT;
EEPROM.write(add++, minut);
temp=0;
while(digitalRead(next)==0);
}
}
delay(1000);
}
void match()
{
int tem[23];
for(int i=11;i<23;i++)
{
tem[i]=EEPROM.read(i);
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: 0395 304 802
486
}
if(HOUR == tem[11] && MINUT == tem[12]) // Kiểm tra giờ và phút hiện tại
// có bằng giờ và phút cài chưa để tắt thiết bị điện
{
beep();
}
}
void beep()
{
digitalWrite(den, LOW);
}
Hình ảnh thực tế:
22.
Thiết kế mô hình cài đặt và hiển thị nhiệt độ sử dụng cảm biến
PT100 và board arduino.
Mục tiêu:

Thiết kế mô hình cài đặt và hiển thị nhiệt độ sử dụng cảm biến PT100 và
board arduino.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
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: 0395 304 802
487
Phần cứng cần chuẩn bị:








1 board arduino.
Dây cắm test board.
1 breadboard.
1 module PT100.
1 module Relay 5Vdc.
2 nút nhấn 4 chân.
2 điện trở 10k.
1 màn hình LCD 16X02 + I2C.
 1 bóng đèn DC12V hoặc bóng led.
Lắp mạch nguyên lý:
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: 0395 304 802
488
Arduino
I2C for LCD
PT100
RELAY
GND
GND (--)
GND
DC (-)
5V
A4
VCC
SDA
VCC
DC+
A5
A0
SCL
NÚT
NHẤN
S
8
4
5
8
N1
N2
Code chương trình:
https://drive.google.com/file/d/1JXbzdO5uGwVINNNTUjdgxtkCypM16j-z/view
#include <Wire.h>
#include <LiquidCrystal_I2C.h> // Thƣ viện i2c cho lcd
LiquidCrystal_I2C lcd(0x27,16,2); //đại chỉ i2c 0x27
unsigned long time1 = 0;
const int analogInPin = A0; // chân tín hiệu của pt100 nối với chân A0
const int SensorValueLow = 463;
const int SensorValueDiff = 36;
const int TempValueDiff = 42;
const int TempValueLow = 9;
int sensorValue = 0;
double Temp = 0;
#define minTempC 0
#define maxTempC 150
#define startTempC 29 // giá trị nhiệt độ cài ban đầu
float setTempC;
#define buttonDN 5 // chân nút nhấn 1 nối chân số 4
#define buttonUP 4 // chân nút nhấn 2 nối chân số 5
#define role 8 // chân relay nối chân số 8
#define coi 3
byte degree[8] = { // dòng này để hiển thị kí tự độ C
0B01110,
0B01010,
0B01110,
0B00000,
0B00000,
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: 0395 304 802
489
0B00000,
0B00000,
0B00000
};
void setup()
{
Serial.begin(9600);
pinMode(buttonDN, INPUT_PULLUP);
pinMode(buttonUP, INPUT_PULLUP);
pinMode(role, OUTPUT); //chân kích tắt mở relay
pinMode(coi, OUTPUT); //còi báo
digitalWrite(coi,HIGH);
setTempC = startTempC;
}
void loop()
{
sensorValue = analogRead(analogInPin);
Temp = sensorValue-SensorValueLow;
Temp = Temp/SensorValueDiff;
Temp = Temp*TempValueDiff;
Temp = Temp+TempValueLow;
Temp = Temp - 32;
setTemperature();
setHeater();
displayLCD();
}
void displayLCD(){
lcd.init(); // khởi động lcd
lcd.backlight();// bật tắt màn hình LCD
lcd.clear();
lcd.home ();
Serial.print("C = ");
Serial.println(Temp);
lcd.setCursor(0,0);
lcd.print("NHIET DO: ");
lcd.setCursor(10,0);
lcd.print(Temp);
lcd.print("");
lcd.write(1);
lcd.print("C");
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: 0395 304 802
490
lcd.setCursor(0,1);
lcd.print("CAI : ");
lcd.setCursor(5,1);
lcd.print(round(setTempC));
lcd.print("");
lcd.write(1);
lcd.print("C");
lcd.createChar(1, degree);
}
void setTemperature()
{
if (digitalRead(buttonDN)==HIGH){ // Trường hợp nút nhấn được nhấn
setTempC++; // tăng giá trị cài lên 1 đơn vị
if(setTempC < minTempC) setTempC = minTempC;
}
if (digitalRead(buttonUP)==HIGH){
setTempC--;// giảm giá trị cài lên 1 đơn vị
if(setTempC > maxTempC) setTempC = maxTempC;
}
}
void setHeater()
{
if ((setTempC) > (Temp + 0.5 ) ) {
digitalWrite(role, LOW);
lcd.setCursor(11,1);
lcd.print("DONG");
//delay(10000);
}
else if ((setTempC) <= (Temp - 0.5)){
digitalWrite(role, HIGH);
//digitalWrite(coi, LOW);
beep();
lcd.setCursor(11,1);
lcd.print("NGAT");
}
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: 0395 304 802
491
}
void beep() { // còi kêu khi nhiệt độ cài nhỏ hơn nhiệt độ hiện tại
digitalWrite(coi, LOW);
delay(800);
digitalWrite(coi, HIGH);
delay(800);
}
Hình ảnh thực tế:
23.
Thiết kế mô hình hiển thị giờ lên màn hình LCD 16X02 chữ lớn
không sử module thời gian thực.
Mục tiêu:

Thiết kế mô hình hiển thị giờ lên màn hình LCD 16x02 chữ lớn không sử
dụng module thời gian thực.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 1 board arduino.
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: 0395 304 802
492





Dây cắm test board.
1 breadboard.
3 nút nhấn 4 chân.
3 điện trở 10 K.
1 màn hình LCD 16X02 + I2C.
Lắp mạch nguyên lý:
Code chương trình:
https://drive.google.com/file/d/1tM17LmEDlNicUrqmBby5ahCli2Pf0dLs/view
#include <Wire.h>
#include <LiquidCrystal_I2C.h> // Thư viện i2c cho lcd
LiquidCrystal_I2C lcd(0x27,16,2); // địa chỉ i2c 0x27 hoặc 0x3f
int s,m,h,a,d,state,state1,state2,dg,cnt;
void setup()
{
lcd.init(); // khởi động i2c lcd
lcd.backlight(); // bat tat man hinh lcd
// gán cho mỗi phân đoạn là 1 số ghi
lcd.createChar(1,bar1);
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: 0395 304 802
493
lcd.createChar(2,bar2);
lcd.createChar(3,bar3);
lcd.createChar(4,bar4);
lcd.createChar(5,bar5);
lcd.createChar(6,bar6);
lcd.createChar(7,bar7);
lcd.createChar(8,bar8);
state=1;
state1=1;
state2=1;
pinMode(8,INPUT);
pinMode(9,INPUT);
pinMode(10,INPUT);
s=0;
m=0;
h=0;
a=0;
}
void custom0(int col)
{ //sử dụng các phân đoạn để hiên thị số 0
lcd.setCursor(col, 0);
lcd.write(2);
lcd.write(8);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(1);
}
void custom1(int col)
{
lcd.setCursor(col,0);
lcd.write(32);
lcd.write(32);
lcd.write(1);
lcd.setCursor(col,1);
lcd.write(32);
lcd.write(32);
lcd.write(1);
}
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: 0395 304 802
494
void custom2(int col)
{
lcd.setCursor(col,0);
lcd.write(5);
lcd.write(3);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(6);
}
void custom3(int col)
{
lcd.setCursor(col,0);
lcd.write(5);
lcd.write(3);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(7);
lcd.write(6);
lcd.write(1);
}
void custom4(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(6);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(32);
lcd.write(32);
lcd.write(1);
}
void custom5(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(3);
lcd.write(4);
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: 0395 304 802
495
lcd.setCursor(col, 1);
lcd.write(7);
lcd.write(6);
lcd.write(1);
}
void custom6(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(3);
lcd.write(4);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(1);
}
void custom7(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(8);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(32);
lcd.write(32);
lcd.write(1);
}
void custom8(int col)
{
lcd.setCursor(col, 0);
lcd.write(2);
lcd.write(3);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(1);
}
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: 0395 304 802
496
void loop()
{
if(digitalRead(8)&&state==1){// chuyển qua chế độ chỉnh lại giờ phút
cnt++;
state=0;
if(cnt>3){
cnt=0;
}
}else if(!digitalRead(8)&&state==0){
state=1;
}
if(digitalRead(9)&&state1==1){ // tăng giờ hoặc phút
dg=1;
state1=0;
}else if(!digitalRead(9)&&state1==0){
state1=1;
}
if(digitalRead(10)&&state2==1){// // giảm giờ hoặc phút
dg=-1;
state2=0;
}else if(!digitalRead(10)&state2==0){
state2=1;
}
d=m%10;
printNumber(d, 10);
d=m/10;
printNumber(d, 7);
lcd.setCursor(14, 0);
if(a){ // nếu a lớn hớn 0
lcd.print("AM");
}else{
lcd.print("PM");
}
if(cnt==0){
s++;
lcd.setCursor(6, 0);
lcd.print(" ");
lcd.setCursor(6, 1);
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: 0395 304 802
497
lcd.print(" ");
delay(500);
lcd.setCursor(6, 0);
lcd.print(".");
lcd.setCursor(6, 1);
lcd.print(".");
delay(500);
}
}
Hình ảnh thực tế:
24.
Thiết kế mô hình bật tắt thiết bị điện bằng máy tính thông qua
phần mền processing và arduino.
Mục tiêu:

Thiết kế mô hình bật tắt thiết bị điện bằng máy tính thông qua phần mền
processing và arduino.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
 Cài đặt phần mền processing: https://processing.org/download/
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: 0395 304 802
498
Phần cứng cần chuẩn bị:
 1 board arduino.
 Dây cắm test board.
 1 module relay 5vdc 1 kênh mức cao.
Lắp mạch nguyên lý:
Code cho arduino:
https://drive.google.com/open?id=1a-6G1jfviXPpGtS_ApRg7J4pyIu6m7wF
void setup() {
pinMode(8, OUTPUT); // den
pinMode(9, OUTPUT); // quạt
pinMode(10, OUTPUT); //tivi
Serial.begin(9600);
}
void loop(){
if(Serial.available()){ //chờ tín hiệu đƣợc gửi đến serial
char val = Serial.read();
if(val == 'd'){
//if d
digitalWrite(8, HIGH); //turn on dèn
}
if(val == 'q'){
//if q
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: 0395 304 802
499
digitalWrite(9, HIGH); //turn on quat
}
if(val == 't'){
//if t
digitalWrite(10, HIGH); //turn on tivi
}
if(val == 'f'){
//if f
digitalWrite(8, LOW); //turn off all led
digitalWrite(9, LOW);
digitalWrite(10, LOW);
}
}
}
Code cho processing:
https://www.youtube.com/watch?v=trVfFPGALwk&list=PLHPjOX8mt4YHDi1CKfCdajzDtOJfGwZx&index=28
Sau khi cài đặt phần mền processing các bạn mở file code lên.
import controlP5.*; //các bạn cần phai add thƣ viện controlP5
import processing.serial.*;
Serial port;
ControlP5 cp5;
PFont font;
void setup(){
size(300, 450); //Kích thƣớc giao diện rộng và cao
printArray(Serial.list());
port = new Serial(this, "COM23", 9600); // các bạn cần chú ý đến cổng COM thay
cho đúng nhé
cp5 = new ControlP5(this);
font = createFont("calibri light bold", 20);
cp5.addButton("QUAT") //"QUẠT" is the name of button
.setPosition(100, 50)
.setSize(120, 70)
//(width, height)
.setFont(font);
cp5.addButton("DEN") //"ĐÈN" is the name of button
.setPosition(100, 150)
.setSize(120, 70)
//(width, height)
.setFont(font) ;
cp5.addButton("TIVI") //"TIVI" is the name of button
.setPosition(100, 250)
.setSize(120, 70)
//(width, height)
.setFont(font) ;
cp5.addButton("ALLOFF") //"alloff" is the name of button
.setPosition(100, 350)
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: 0395 304 802
500
.setSize(120, 70)
.setFont(font) ;
//(width, height)
}
void draw(){ //same as loop in arduino
background(100, 0 , 0);
//lets give title to our window
fill(0, 255, 0);
//chỉnh màu text (r, g, b)
textFont(font);
text("ĐIỀU KHIỂN THIẾT BỊ ĐIỆN", 20, 30); // ("text", x coordinate, y coordinat)
}
void QUAT(){
port.write('d');
}
void DEN(){
port.write('q');
}
void TIVI(){
port.write('t');
}
void ALLOFF(){
port.write('f');
}
Trƣớc khi sử dụng code này ta phải mở phần mền processing lên và cần cài thƣ
viện controlP5 và phần mền processing.
Sketch import Library Add Library
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: 0395 304 802
501
Và chúng ta lƣu ý trƣớc khi chạy file code của processing các bạn phải chọn
cổng COM cho đúng nhé ( cổng COM mà board arduino đang kết nối với
máy tính ). Và chọn vào dấu tam giác để chạy ra giao diện điều khiển.
Hình ảnh thực tế:
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: 0395 304 802
502
25.
Thiết kế mô hình xe robot 4 bánh điều khiển bằng sóng RF thông
qua module RF24L01 và board arduino.
Mục tiêu:

Thiết kế mô hình xe robot 4 bánh điều khiển bằng sóng RF thông qua
module RF24L01 và board arduino.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:










2 board arduino uno hoặc nano,...
Dây cắm test board.
1 module JoyStick.
2 module RF24L01.
1 đế 3 pin 3.7 V mắc nối tiếp.
3 pin 3.7 V.
1 module L298N.
1 khung xe 4 bánh.
1 pin 9V.
1 Jack pin 9V.
Lắp mạch nguyên lý phần phát:
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: 0395 304 802
503
Lắp mạch nguyên lý phần thu:
Arduino
NRF24L01
L298N
GND
GND (--)
GND
3.3V
5V
VCC
9
8
CSN
CE
11
12
13
3
5
2
4
6
7
MOSI
MISO
SCK
5V+
ENA
ENB
IN1
IN2
IN3
IN4
12+ ( Pin )
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: 0395 304 802
504
Code cho phần phát:
https://drive.google.com/open?id=1a-6G1jfviXPpGtS_ApRg7J4pyIu6m7wF
Trƣớc khi upload các bạn cần add thƣ viện NRF24L01 vào phần mền IDE nhé kèm
theo trong file code.
#include <SPI.h> // thư viện chuẩn SPI
#include <nRF24L01.h>
#include <RF24.h> // Thu viện RF24L01
RF24 radio(8,9); // CE, CSN
const byte address[6] = "00001";// địa chỉ
char xyData[32] = "";
String xAxis, yAxis;
void setup() {
Serial.begin(9600);
radio.begin();
radio.openWritingPipe(address);
radio.setPALevel(RF24_PA_MIN);
radio.stopListening();
}
void loop() {
xAxis = analogRead(A1); // đọc giá trị analoag trục x của joystick
yAxis = analogRead(A0); // đọc giá trị analoag trục y của joystick
// gửi giá trị analog của trục x
xAxis.toCharArray(xyData, 5);
radio.write(&xyData, sizeof(xyData));
// gửi giá trị analog của trục y
yAxis.toCharArray(xyData, 5);
radio.write(&xyData, sizeof(xyData));
delay(20);
}
Code cho phần thu:
#include <SPI.h> // thư viện chuẩn giao tiếp SPI
#include <nRF24L01.h>
#include <RF24.h> // Thư viện nrf24l01
#define enA 3 // chân ena nối với chân số 3 của arduino
#define in1 2 // chân in1 nối với chân số 2 của arduino
#define in2 4 // chân in2 nối với chân số 4 của arduino
#define enB 5 // chân enb nối với chân số 5 của arduino
#define in3 6 // chân in3 nối với chân số 6 của arduino
#define in4 7 // chân in4 nối với chân số 7 của arduino
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: 0395 304 802
505
RF24 radio(8, 9); // CE, CSN
const byte address[6] = "00001"; // địa chỉ rf
char receivedData[32] = "";
int xAxis, yAxis;
int motorSpeedA = 0;
int motorSpeedB = 0;
void setup() {
pinMode(enA, OUTPUT);
pinMode(enB, OUTPUT);
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
pinMode(in3, OUTPUT);
pinMode(in4, OUTPUT);
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address);
radio.setPALevel(RF24_PA_MIN);
radio.startListening();
}
void loop() {
if (radio.available()) {
radio.read(&receivedData, sizeof(receivedData)); // đọc dữ liệu mà mạch phát gửi tới
xAxis = atoi(&receivedData[0]); // chuyển đổi dữ liệu sang dạng số nguyên (trục x)
delay(10);
radio.read(&receivedData, sizeof(receivedData));
yAxis = atoi(&receivedData[0]);// chuyển đổi dữ liệu sang dạng số nguyên (trục y)
delay(10);
}
if (yAxis < 460) {
// xe chạy lùi khi y < 460
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
digitalWrite(in3, HIGH);
digitalWrite(in4, LOW);
motorSpeedA = map(yAxis, 460, 0, 0, 255);// chuyển đổi giá trị analog trục y của joy
gửi về tƣơng ứng với tốc độ độ của động cơ ( 460 -- 0 ; 0---- 255)
motorSpeedB = map(yAxis, 460, 0, 0, 255);
}
else if (yAxis > 550) {
// xe chạy tiến
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
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: 0395 304 802
506
digitalWrite(in3, LOW);
digitalWrite(in4, HIGH);
motorSpeedA = map(yAxis, 550, 1023, 0, 255);
motorSpeedB = map(yAxis, 550, 1023, 0, 255);
}
else {
motorSpeedA = 0;
motorSpeedB = 0;
}
if (xAxis < 460) {
// chuyển đổi giá trị analog trục x của joy gửi về tương ứng với tốc độ độ của động cơ (
470 -- 0 ; 0---- 255)
int xMapped = map(xAxis, 460, 0, 0, 255);
// xe rẻ trái
motorSpeedA = motorSpeedA + xMapped;
motorSpeedB = motorSpeedB - xMapped;
if (motorSpeedA < 0) {
motorSpeedA = 0;
}
if (motorSpeedB > 255) {
motorSpeedB = 255;
}
}
if (xAxis > 550) {
// chuyển đổi giá trị analog trục x của joy gửi về tương ứng với tốc độ độ của động cơ
( 550-----1023 ; 0---- 255)
int xMapped = map(xAxis, 550, 1023, 0, 255);
// xe rẻ phải
motorSpeedA = motorSpeedA - xMapped;
motorSpeedB = motorSpeedB + xMapped;
if (motorSpeedA > 255) {
motorSpeedA = 255;
}
if (motorSpeedB < 0) {
motorSpeedB = 0;
}
}
if (motorSpeedA < 70) {
motorSpeedA = 0;
}
if (motorSpeedB < 70) {
motorSpeedB = 0;
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: 0395 304 802
507
}
analogWrite(enA, motorSpeedA);
analogWrite(enB, motorSpeedB);
}
Hình ảnh thực tế:
26.
Thiết kế mô hình xe robot 3 bánh dò line và tránh vật cản sử
dụng board arduino.
Mục tiêu:

Thiết kế mô hình xe robot 3 bánh dò line và tránh vật cản sử dụng board
arduino.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:







1 board arduino uno hoặc nano,...
Dây cắm test board.
1 module cảm biến khoảng cách SRF05.
3 module cảm biến dò line.
1 đế 3 pin 3.7 V mắc nối tiếp.
3 pin 3.7 V.
1 module L298N.
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: 0395 304 802
508
Lắp mạch nguyên lý:
Arduino
L298N
GND
GND (--)
5V
ENA
5+
5
ENB
IN1
6
3
IN2
IN3
IN4
11
12
4
7
8
Cảm biến khoảng
cách(SRF05)
GND
CB dò line
VCC
VCC
GND (-)
Trig
Echo
OUTL
OUTS
OUTR
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: 0395 304 802
509
Code chương trình:
https://drive.google.com/open?id=13-dbSzfZrSZNO0lV6SLxOPYJOidD5Ezn
int stop_distance = 12;// Khoảng cách phát hiện vật cản
//Kết nối SRF 05 OR 04
const int trigPin = 11; // kết nối chân trig với chân 11 arduino
const int echoPin = 12; // kết nối chân echo với chân 12 arduino
//L298 kết nối arduino
const int motorA1
= 3; // kết nối chân IN1 với chân 3 arduino
const int motorA2
= 4; // kết nối chân IN2 với chân 4 arduino
const int motorAspeed = 5; // kết nối chân ENA với chân 5 arduino
const int motorB1
= 7; // kết nối chân IN3 với chân 7 arduino
const int motorB2
= 8; // kết nối chân IN4 với chân 8 arduino
const int motorBspeed =6; // kết nối chân ENB với chân 6 arduino
//kết nối của 3 cảm biến hồng ngoại (dò line )
const int L_S =9; // cb dò line trái
const int S_S =2; // cb dò line giữa
const int R_S =10; //cb dò line phải
int left_sensor_state;// biến lƣu cảm biến hồng ngoại line trái
int s_sensor_state; // biến lƣu cảm biến hồng ngoại line giữa
int right_sensor_state;// biến lƣu cảm biến hồng ngoại line phải
long duration; //
int distance; // biến khoảng cách
void setup() {
pinMode(L_S,INPUT); // chân cảm biến khai báo là đầu vào
pinMode(R_S,INPUT);
pinMode(S_S,INPUT);
pinMode(motorA1, OUTPUT);
pinMode(motorA2, OUTPUT);
pinMode(motorB1, OUTPUT);
pinMode(motorB2, OUTPUT);
pinMode(motorAspeed, OUTPUT);
pinMode(motorBspeed, OUTPUT);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
Serial.begin(9600);
analogWrite(motorAspeed, 120); // tốc độ động cơ a ban đầu 120 ( 0 - 255)
analogWrite(motorBspeed, 120);// tốc độ động cơ b ban đầu 120 ( 0 - 255)
delay(3000);
}
void loop() {
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
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: 0395 304 802
510
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance= duration*0.034/2;
Serial.print("Distance: ");
Serial.println(distance);
left_sensor_state = digitalRead(L_S);
s_sensor_state = digitalRead(S_S);
right_sensor_state = digitalRead(R_S);
if ((digitalRead(L_S) == 0)&&(digitalRead(S_S) == 1)&&(digitalRead(R_S) ==
0)){forword();}// đi tiến
if ((digitalRead(L_S) == 1)&&(digitalRead(S_S) == 1)&&(digitalRead(R_S) ==
0)){turnLeft();} // rẻ trái
if ((digitalRead(L_S) == 1)&&(digitalRead(S_S) ==0)&&(digitalRead(R_S) == 0))
{turnLeft();} // rẻ trái
if ((digitalRead(L_S) == 0)&&(digitalRead(S_S) == 1)&&(digitalRead(R_S) ==
1)){turnRight();} // rẻ phải
if ((digitalRead(L_S) == 0)&&(digitalRead(S_S) == 0)&&(digitalRead(R_S) ==
1)){turnRight();}// rẻ phải
if ((digitalRead(L_S) == 1)&&(digitalRead(S_S) == 1)&&(digitalRead(R_S) ==
1)){Stop();} // stop
if(distance < stop_distance) // nếu khoảng cách nhỏ hơn giới hạn
{
digitalWrite (motorA1,HIGH);// cho xe robot chạy lùi 1 đoạn
digitalWrite(motorA2,LOW);
digitalWrite (motorB1,LOW);
digitalWrite(motorB2,HIGH);
delay(200);
analogWrite (motorAspeed, 0);
analogWrite (motorBspeed, 0);
delay(200);
digitalWrite (motorA1,HIGH);// cho xe robot re phai
digitalWrite(motorA2,LOW);
digitalWrite (motorB1,HIGH);
digitalWrite(motorB2,LOW);
analogWrite (motorAspeed, 90);
analogWrite (motorBspeed, 90);
delay(400);
digitalWrite (motorA1,LOW); //cho xe robot ĐI THẲNG1 1 đoạn
digitalWrite(motorA2,HIGH);
digitalWrite (motorB1,HIGH);
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: 0395 304 802
511
digitalWrite(motorB2,LOW);
analogWrite (motorAspeed, 90);
analogWrite (motorBspeed, 90);
delay(600);
digitalWrite (motorA1,LOW);// cho xe robot re trái 1 đoạn có thể thay đổi
digitalWrite(motorA2,HIGH);
digitalWrite (motorB1,LOW);
digitalWrite(motorB2,LOW);
analogWrite (motorAspeed, 110);
analogWrite (motorBspeed, 110);
delay(1000);
///////////////////
digitalWrite (motorA1,LOW); //cho xe robot ĐI THẲNG
digitalWrite(motorA2,HIGH);
digitalWrite (motorB1,HIGH);
digitalWrite(motorB2,LOW);
analogWrite (motorAspeed, 100);
analogWrite (motorBspeed, 100);
delay(300);
////////////////////////
digitalWrite (motorA1,LOW); //cho xe robot rẻ trái
digitalWrite(motorA2,HIGH);
digitalWrite (motorB1,LOW);
digitalWrite(motorB2,LOW);
analogWrite (motorAspeed, 100);
analogWrite (motorBspeed, 100);
delay(500);
digitalWrite (motorA1,LOW); //cho xe robot ĐI THẲNG
digitalWrite(motorA2,HIGH);
digitalWrite (motorB1,HIGH);
digitalWrite(motorB2,LOW);
analogWrite (motorAspeed, 90);
analogWrite (motorBspeed, 90);
while(left_sensor_state == LOW){
left_sensor_state = digitalRead(L_S);
s_sensor_state = digitalRead(S_S);
right_sensor_state = digitalRead(R_S);
Serial.println("in the first while");
}
}
}
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: 0395 304 802
512
void forword(){ // chương trình con xe robot đi tiến
digitalWrite (motorA1,LOW);
digitalWrite(motorA2,HIGH);
digitalWrite (motorB1,HIGH);
digitalWrite(motorB2,LOW);
}
void turnRight(){
digitalWrite (motorA1,LOW);
digitalWrite(motorA2,LOW);
digitalWrite (motorB1,HIGH);
digitalWrite(motorB2,LOW);
}
void turnLeft(){
digitalWrite (motorA1,LOW);
digitalWrite(motorA2,HIGH);
digitalWrite (motorB1,LOW);
digitalWrite(motorB2,LOW);
}
void Stop(){
digitalWrite (motorA1,LOW);
digitalWrite(motorA2,LOW);
digitalWrite (motorB1,LOW);
digitalWrite(motorB2,LOW);
}
Hình ảnh thực tế:
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: 0395 304 802
513
27.
Thiết kế mô hình truyền dữ liệu cảm biến qua máy tính thông
qua giao tiếp MODBUS RTU .
Mục tiêu:

Thiết kế mô hình truyền dữ liệu cảm biến qua máy tính thông qua chuẩn
MODBUS RTU sử dụng đƣờng truyền RS 485.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
 Cài đặt phần mền hổ trợ Modbus slave.
https://www.modbustools.com/download.html
Phần cứng cần chuẩn bị:







1 board arduino uno hoặc nano,...
Dây cắm test board và 1 breadboard.
1 module LCD 16x02 và 1 I2C for LCD..
1 module cảm biến dò line.
1 module cảm biến độ ẩm đất.
1 module RS 485.
1 module USB to RS – 485.
Lắp mạch nguyên lý:
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: 0395 304 802
514
Code chương trình:
https://drive.google.com/open?id=1Cc5BHu2lC05RtE73LJb7kafJuxBvf3tx
#include <ModbusMaster.h> //thư viện modbus
#include <Wire.h> // thư viện i2c để hiển thị LCD
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2); // địa chỉ i2c lcd là 0x27
#define DE 3 // chân DE được nối với chân số 3 arduino
#define RE 2 // chân RE được nối với chân số 2 arduino
ModbusMaster node;
void preTransmission()
{
digitalWrite(RE, 1); //Đưa chân RE lên mức cao
digitalWrite(DE, 1); // Đưa chân DE lên mức cao
}
void postTransmission()
{
digitalWrite(RE, 0);
digitalWrite(DE, 0);
}
void setup()
{
lcd.init();
lcd.backlight();// bật tắt màn hình LCD
lcd.print("Arduino VN");
delay(3000);
lcd.clear();
lcd.print("");
lcd.setCursor(0,1);
lcd.print("Giao tiep Modbus");
delay(3000);
lcd.clear();
pinMode(RE, OUTPUT);
pinMode(DE, OUTPUT);
pinMode(4,INPUT);// Chân cảm biến hồng ngoại được nối với chân số 4 arduino
digitalWrite(RE, 0);//Đưa chân RE xuống mức thấp
digitalWrite(DE, 0);//Đưa chân DE xuống mức thấp
Serial.begin(115200); //tốc độ baud 115200
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: 0395 304 802
515
node.begin(1, Serial); //Slave có ID là 1
node.preTransmission(preTransmission);
node.postTransmission(postTransmission);
}
void loop()
{
float value = analogRead(A0);// Gán giá trị cb độ ẩm đất cho biến value
node.writeSingleRegister(0x40000,value); // lưu giá trị cảm biến đó vào thanh ghi có
địa chỉ 0x40000
lcd.setCursor(0,0);
lcd.print("GTCBD :");
lcd.print(value);
int gtcb= digitalRead(4); // đọc giá trị cảm biến hồng ngoại lưu vào biến gtcb
if (gtcb == 1)
{
node.writeSingleRegister(0x40001,1);// lưu giá trị cảm biến đó vào thanh ghi có địa
chỉ 0x40001
lcd.setCursor(0,1);
lcd.print("CBHN: 1");
}
else
{
node.writeSingleRegister(0x40001,0); // lưu giá trị cảm biến đó vào thanh ghi có địa
chỉ 0x40001
lcd.setCursor(0,1);
lcd.print("CBHN: 0");
}
}
Sau khi các bạn upload chƣơng trình cho board arduino các bạn mở phần mền
Modbus RTU lên:
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: 0395 304 802
516
Tiếp đến ta chọn vào mục Connection  connect  Register later:
Các bạn có thể xem video hƣớng dẫn tại link dƣới nhé:
https://www.youtube.com/watch?v=RK8c6305zmU&
Hình ảnh thực tế:
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: 0395 304 802
517
28.
Thiết kế mô hình đo dòng điện AC/DC sử dụng module ACS712
và board arduino .
Mục tiêu:

Thiết kế mô hình đo dòng điện AC/DC sử dụng module ACS712 và board
arduino.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:




1 board arduino uno hoặc nano,...
Dây cắm test board và 1 breadboard.
1 module LCD 16x02 và 1 I2C for LCD..
1 module ACS 712.
Lắp mạch nguyên lý:
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: 0395 304 802
518
Code chương trình:
https://drive.google.com/open?id=1J4bzGVP3vwVRqDv1yiXqh6GktS-3Por0
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);
float hesodc= 0.063; // he so mv/A của dòng điện dc
float hesoac = 0.055; // he so mv/A của dòng điện ac
int vonglap = 100; //số vòng lặp
const int chancongtac = 7;
int gtct = 0;
void setup()
{
Serial.begin(9600);
lcd.init();
lcd.backlight();
pinMode(chancongtac, INPUT); // chan cong tac de chon che do do dong AC/DC
digitalWrite(chancongtac, HIGH); // ban dau ta gán giá trị công tắc ở mức cao
chucnang();
}
void chucnang()
{
lcd.clear();
lcd.setCursor(4,0);
lcd.print("DO DONG DIEN");
}
void loop()
{
gtct = digitalRead(chancongtac);
delay(200);
if (gtct == HIGH)
{
float volt;
float dongdct = 0;
for (int i = 0; i < vonglap; i++)
{
volt = analogRead(A0) * 5.0 / 1023.0;
dongdct += (volt - 2.4955) /hesodc;
}
float dongdc = (dongdct / vonglap);
if ( (dongdc < 0.100) && (dongdc > -0.100) )
{
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: 0395 304 802
519
lcd.clear();
lcd.setCursor(1,0);
lcd.print("DO DONG DIEN");
lcd.setCursor(6,1);
lcd.print("DC");
delay(1000);
}
else
{
lcd.clear();
lcd.setCursor(1,0);
lcd.print("DO DONG DC");
lcd.setCursor(0,1);
lcd.print("I= ");
lcd.print(dongdc,3);
Serial.println( dongdc);
lcd.print(" A");
delay(1000);
}
}
else //Pulsador
{
float volt;
float get_corriente();
float dongact=get_corriente();//dong dien ac
float dongac=dongact*0.707;
float congsuat=dongac*221.2; // cong suat dien ac
if ( (dongact < 0.100) && (dongact > -0.100) )
{
lcd.clear();
lcd.setCursor(2,0);
lcd.print("DO DONG DIEN");
lcd.setCursor(6,1);
lcd.print("AC");
delay(1000);
}
else
{
lcd.clear();
lcd.setCursor(0,0);
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: 0395 304 802
520
lcd.print("I= ");
lcd.print(dongact,3);
lcd.print(" A");
lcd.setCursor(14,0);
lcd.print("AC");
lcd.setCursor(0,1);
lcd.print("P= ");
lcd.print(congsuat,3);
lcd.print(" W");
delay(1000);
}
}
}
float get_corriente()
{
float volt;
float dongact=0;
long tiempo=millis();
float Imax=0;
float Imin=0;
while(millis()-tiempo<500)
{
volt = analogRead(A1) * (5.0 / 1023.0);// chuyen doi gia tri analog sang dien ap
dongact=0.9*dongact+0.1*((volt-2.4955)/hesoac); //dong dien ac duoc do
if(dongact>Imax)Imax=dongact;
if(dongact<Imin)Imin=dongact;
}
return((Imax-Imin)/2);
}
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: 0395 304 802
521
Hình ảnh thực tế:
Các bạn có thể xem video hƣớng dẫn tại đậy:
https://www.youtube.com/watch?v=XtYnv1l2dNo
29.
Thiết kế mô hình điều khiển độ sáng của đèn led ứng dụng giải
thuật PID và sử dụng board arduino .
Mục tiêu:

Thiết kế mô hình điều khiển độ sáng của led ứng dụng giải thuật PID và
board arduino.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:





1 board arduino uno hoặc nano,...
Dây cắm test board và 1 breadboard.
1 module cảm biến ánh sáng.
1 bóng led đơn 5 li.
1 điện trở 220 Ohm.
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: 0395 304 802
522
Lắp mạch nguyên lý:
Code chương trình:
https://drive.google.com/open?id=1oPijj0fApEB9VXa8Y7DgKwHqar8VeLz1
#include <PID_v1.h> // thư viện pid
double Setpoint ; // điểm đặt
double Input;
// giá trị đầu vào của cam biến ánh sáng
double Output ;
// giá trị đầu ra là tín hiệu điều khiển bóng đèn led
double Kp=0.5, Ki=10, Kd=0.4; // các thông số kp,ki,kd các bạn có thể thay đổi
PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);
void setup()
{
Serial.begin(9600);
Setpoint = 240; // giá trị đặt là 240 , giá trị này các bạn có thể thay đổi
myPID.SetMode(AUTOMATIC);
myPID.SetTunings(Kp, Ki, Kd);
}
void loop()
{
Input = map(analogRead(1), 0, 1024, 0, 255); // giá trị chuyển đổi từ 0--1024 tương
ứng 0---255
myPID.Compute();
analogWrite(6,Output); //chân điều khiển độ sáng của led.
Serial.print(Input);
Serial.print(" ");
Serial.println(Setpoint);
delay(500); }
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: 0395 304 802
523
Hình ảnh thực tế:
Các bạn có thể xem video hƣớng dẫn tại đậy:
https://www.youtube.com/watch?v=nQLftptT664&list=PLHPjOX8mt4YHDi1CKfCdajzDtOJfGwZx&index=34
30.
Thiết kế mô hình điều khiển thiết bị điện thông qua giao thức
(MQTT) và board NodeMCU.
Mục tiêu:
Thiết kế mô hình điều khiển thiết bị điện thông qua giao thức (MQTT) và
board NodeMCU.
 MQTT (Message Queuing Telemetry Transport) là một giao thức gởi dạng
publish/subscribe sử dụng cho các thiết bị [IoT] với băng thông thấp, độ tin
cậy cao và khả năng đƣợc sử dụng trong mạng lƣới không ổn định.

Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
 Tạo một tài khoản trên Ubidots: https://industrial.ubidots.com.
 Cần phải add thƣ viện kèm theo trong file code vào phần mền IDE.
Phần cứng cần chuẩn bị:
 1 Mạch Node MCU.
 Dây cắm test board.
 1 module Relay 5Vdc.
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: 0395 304 802
524
Lắp mạch nguyên lý:
Code chương trình:
https://drive.google.com/file/d/1bY6mSySriczP3oyHUPQHJHxjPAYLAfyy/view
/*
* MQTT (Message Queuing Telemetry Transport) là một giao thức gởi dạng
publish/subscribe sử dụng cho các thiết bị [IoT] với băng thông thấp, độ tin cậy cao và
khả năng đƣợc sử dụng trong mạng lƣới không ổn định.
*
*/
#include "UbidotsMicroESP8266.h"
#define DEVICE "control_relay" // Tên mà các bạn đặt ở mục device
#define VARIABLE "relay" // tên biến điều khiển
#define TOKEN "BBFF-PuMLmLq4yb4Bm9cMOZsCb6UGcJXK9f" // mã token trong
mục API sau khi ta đăng tài khoản ở Ubidots
#define WIFISSID "Trinh Quang Nam." // tên wifi
#define PASSWORD "bubu123789" // pass
Ubidots client(TOKEN);
float Valor_Temperatura = 0;
void setup() {
Serial.begin(115200);
client.wifiConnection(WIFISSID, PASSWORD);
pinMode(5, OUTPUT); // điều khiển relay ở chân số 5
digitalWrite(5, 0);
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: 0395 304 802
525
}
void loop()
{
float Valor_Led = client.getValueWithDevice(DEVICE, VARIABLE);
if (Valor_Led != ERROR_VALUE){
Serial.print(F(">>>>>>>>> Bien dieu khien: "));
Serial.println(Valor_Led);
}else{
Serial.println(F("Error"));
}
if (Valor_Led==0.00){digitalWrite(5, 1);}// nếu là nhận giá trị là 0 là tắt relay
if (Valor_Led==1.00){digitalWrite(5, 0);}// nếu là nhận giá trị là 1 là bật relay
client.sendAll(false);
delay(5000);
}
Cài đặt app trên Ubidots:
Sau khi các bạn đã tạo thành công 1 tài khoản trên Ubidots, Các bạn làm theo các
bƣớc sau
- Trên thanh công cụ: Devices Devices Add new devicesBlank
Devices.
- Trong mục Blank Devices:Ta đặt tên cho mục Devices name ( ví dụ:
control_relay).
- Sau khi tạo mục control_relay  Add Variable  Raw.
-
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: 0395 304 802
526
- Ta đặt tên biến là relay , các bạn có thể đặt tùy ý nhƣng phải sữa code nhé.
- Tiếp đến trên thanh công cụ ta chọn mục DATADashboards Add New
Dashboards , ta đặt tên tùy úy phần này sẽ không liên quan đến code.
- Tiếp đến trong mục Add new widget  Swtich  Add Variables 
control_relay relay chọn vào dấu tick.
- Xong bƣớc này các bạn có thể điều khiển thiết bị điện thông qua internet.
Link video hƣớng dẫn :
https://www.youtube.com/watch?v=zkIOdb8Wfpo&list=PLHPjOX8mt4YHDi1CKfCdaj
zDtOJfGwZx&index=37
Giao diện sau khi hoàn thành nhƣ trên.
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: 0395 304 802
527
Hình ảnh thực tế:
31.
Thiết kế mô hình hiển thị vị trí lên màn hình LCD sử dụng
board arduino và GPS neo6.
Mục tiêu:

Thiết kế mô hình hiển thị vị trí lên màn hình LCD sử dụng board arduino và
GPS neo6.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
 Add thƣ viện GPS vào phần mền IDE, thƣ viện kèm trong file code.
Phần cứng cần chuẩn bị:
 1 Mạch Arduino.
 Dây cắm test board.
 1 module LCD 16X02.
 1 Module I2C cho LCD.
 1 Module GPS Neo6,.
 1 Ăng ten cho GPS.
Lắp mạch nguyên lý:
Các bạn lƣu ý mạch GPS này cần để bên ngoài để bắt đƣợc sóng rồi mới đem vô
nhé.
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: 0395 304 802
528
Code chương trình:
https://drive.google.com/open?id=1Vt1bWYsTKiW3kGtJq2sWI5R6L8Z2QB4h
#include <Wire.h> // thư viện i2c
#include <LiquidCrystal_I2C.h>
#include <SoftwareSerial.h>
#include <TinyGPS++.h>// Thư viện gps
LiquidCrystal_I2C lcd(0x27,16,2);// địa chỉ I2C
float lattitude,longitude; // vi độ , kinh độ
SoftwareSerial gpsSerial(8,9);//rx-9,tx -8
TinyGPSPlus gps;
void setup(){
Serial.begin(9600); // tốc độ baud
lcd.init();
lcd.backlight();
gpsSerial.begin(9600);
lcd.print(" GPS ");
delay(2000);
lcd.clear();
}
void loop(){
while(1)
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: 0395 304 802
529
{
while (gpsSerial.available() > 0) /// chờ khi nào có tín hiệu của gps
{ gps.encode(gpsSerial.read()); }
if (gps.location.isUpdated())
{
Serial.print("LAT=");
Serial.println(gps.location.lat(), 6); // in ra màn hình máy tính Vĩ độ
Serial.print("LONG=");
Serial.println(gps.location.lng(), 6);// in ra màn hình máy tính Kinh độ
lattitude=gps.location.lat();
longitude=gps.location.lng();
break;
} }
Serial.print("LATTITUDE=");
Serial.println(lattitude,6);
Serial.print("LONGITUDE=");
Serial.println(longitude,6);
lcd.print("VD ");lcd.print(lattitude,6);// in ra màn hình LCD VĨ ĐỘ
lcd.setCursor(0, 1);
lcd.print("KD ");lcd.print(longitude,6);// in ra màn hình LCD Kinh ĐỘ
}
Hình ảnh thực tế:
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: 0395 304 802
530
32.
Thiết kế mô hình lọc nhiễu cho cảm biến trong các dự án liên
qua đến arduino.
Mục tiêu:

Thiết kế mô hình lọc nhiễu cho cảm biến trong các dự án liên quan đến
arduino.
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
 Add thƣ viện Kalman vào phần mền IDE, thƣ viện kèm trong file code.
Phần cứng cần chuẩn bị:
 1 Mạch Arduino.
 Dây cắm test board.
 1 module cảm biến độ ẩm đất.
Lắp mạch nguyên lý:
Code chương trình:
https://drive.google.com/file/d/1NW7Ub7-rVoFkkkXGxEEjQnzNLnbn7ddq/view
#include <SimpleKalmanFilter.h>
SimpleKalmanFilter bo_loc(2, 2, 0.001);
float e; // nhiễu tự tạo cho thay cho nhiễu bên ngoài tác động vào
// khi áp dụng vào thực tiễn các bạn bỏ nhiễu tự tạo này nhé.
float s; // giá trị đo được (có thêm nhiễu)
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: 0395 304 802
531
float s_kalman; // giá trị được lọc nhiễu
void setup()
{
Serial.begin(9600);
}
void loop()
{
int sensorValue = analogRead(A0); // lưu giá trị cảm biến độ ẩm đất
randomSeed(millis());
e = (float)random(-10, 10); // nhiễu tự điều chỉnh
s = sensorValue + e;
// giá trị thực tế cộng với nhiễu
Serial.print(s);
Serial.print(",");
s_kalman = bo_loc.updateEstimate(s); // giá trị cảm biến sau khi lọc bởi Kalman
Serial.print(s_kalman);
Serial.println();
}
Sau khi upload code xong chúng ta mở Serial Monitor lên:
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: 0395 304 802
532
Hình ảnh thực tế:
Đƣờng màu xanh là tín hiệu cảm biến bị nhiễu còn đƣờng màu đỏ là tín hiệu cảm
biến sau khi đƣợc lọc bởi bộ lọc Kalman.
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: 0395 304 802
533
33.
Thiết kế mô hình điều khiển thiết bị điện và hiển thị giá trị
cảm biến lên internet thông qua giao thức (MQTT) và board
NodeMCU.
Mục tiêu:

Thiết kế mô hình điều khiển thiết bị điện và hiển thị giá trị cảm biến lên
internet thông qua giao thức (MQTT) và board NodeMCU.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
 Tạo một tài khoản trên Ubidots: https://industrial.ubidots.com.
 Cần phải add thƣ viện kèm theo trong file code vào phần mền IDE. Trong
bài 30.
Phần cứng cần chuẩn bị:
 1 Mạch Node MCU.
 Dây cắm test board.
 1 module Relay 2 kênh 5Vdc.
 1 module cảm biến độ ẩm đất.
Lắp mạch nguyên lý:
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: 0395 304 802
534
Code chương trình:
https://drive.google.com/open?id=1NLmaul0gxaOGs-8bUeKNrQCviEEBK0_p
#include "UbidotsMicroESP8266.h"
#define DEVICE "control_relay" // Tên mà các bạn đặt ở mục device
#define VARIABLE "relay1" // tên biến điều khiển
#define VARIABLE1 "relay2" // tên biến điều khiển
#define ID_CB "5dca1e911d84721bcd348591" // id của biến
#define TOKEN "BBFF-5CfT7R2cxtNU9GhUP8PtOVN1Jk5S1" // mã token trong mục
API sau khi ta đăng tài khoản ở Ubidots
#define WIFISSID "Trinh Quang Nam." // tên wifi
#define PASSWORD "bubu123789" // pass
Ubidots client(TOKEN);
int cb = A0;
int gtcb = 0;
void setup() {
Serial.begin(115200);
client.wifiConnection(WIFISSID, PASSWORD);
pinMode(cb, INPUT);
pinMode(5, OUTPUT); // điều khiển relay ở chân số 5
digitalWrite(5, 0);
pinMode(16, OUTPUT); // điều khiển relay ở chân số 16
digitalWrite(16, 0);
}
void loop()
{
int gtcb = analogRead(cb);
float Valor_Led = client.getValueWithDevice(DEVICE, VARIABLE);
float Valor_Led1 = client.getValueWithDevice(DEVICE, VARIABLE1);
if (Valor_Led != ERROR_VALUE){
Serial.print(F(">>>>>>>>> Bien dieu khien: "));
Serial.println(Valor_Led);
}else{
Serial.println(F("Error"));
}
if (Valor_Led==0.00){digitalWrite(5, 1);}// nếu là nhận giá trị là 0 là tắt relay }
if (Valor_Led==1.00){digitalWrite(5, 0);}// nếu là nhận giá trị là 1 là bật relay }
if (Valor_Led1==2.00){digitalWrite(16, 1);}// nếu là nhận giá trị là 0 là tắt relay }
if (Valor_Led1==3.00){digitalWrite(16, 0);}
client.add(ID_CB, gtcb);
client.sendAll(false);
delay(2000);}
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: 0395 304 802
535
Cài đặt app trên Ubidots:
- Cài đặt giống ở bài số 30, ở bài này chúng ta thêm mục cảm biến độ ẩm đất để
hiển thị lên app. Trong mục: Devices  Add Variable  Raw
Đặt tên là CBDOAMDAT nhƣ hình dƣới
- Ta copy ID của cảm biến độ ẩm đất thay vào dòng này của file code: #define
ID_CB "5dca1e911d84721bcd348591" // id của biến
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: 0395 304 802
536
- Tiếp đến ta chọn Data Dashboards
Phần đóng ngắt relay các bạn làm giống ở bài 30, ở phần này trình bày cách
hiển thị giá trị cảm biến.
Sau khi click vào dấu + ta chọn mục Gauge
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: 0395 304 802
537
Tiếp theo ta chọn Add Variables
Tiếp theo ta chọn các mục nhƣ hình dƣới:
Nhƣ vậy chúng ta đã cài đặt xong app.
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: 0395 304 802
538
Hình ảnh thực tế:
34.
Thiết kế mô hình điều khiển đóng ngắt relay bằng SMS thông
qua module sim800l và arduino.
Mục tiêu:

Thiết kế mô hình điều khiển đóng ngắt relay bằng SMS thông qua module
sim800l và arduino.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 1 board arduino .
 Dây cắm test board.
 1 module Relay 1 kênh 5Vdc.
 1 module sim800l.
 1 module ổn áp L2596 3A.
 1bộ nguồn ( 9 – 12V ) 2A trở lên.
Lắp mạch nguyên lý:
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: 0395 304 802
539
Code chương trình:
https://drive.google.com/open?id=1gPmRFBUhnHW8LR_fzlp3aVbZF29gcz22
#include <SoftwareSerial.h>
SoftwareSerial mySerial(10,11); // tx - 10 ; rx - 11
char incomingByte;
String inputString;
int relay = 12; //chân kích relay được nối với chân 12 arduino
void setup()
{
pinMode(relay, OUTPUT); //khai báo relay là output
digitalWrite(relay, HIGH); //tắt relay
Serial.begin(9600);
mySerial.begin(9600);
while(!mySerial.available()){
mySerial.println("AT");
delay(1000);
Serial.println("Connecting..."); // kết nối
}
Serial.println("Connected!");
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: 0395 304 802
540
mySerial.println("AT+CMGF=1"); // khởi động chức năng SMS
delay(1000);
mySerial.println("AT+CNMI=1,2,0,0,0");
delay(1000);
mySerial.println("AT+CMGL=\"REC UNREAD\""); // đọc tin nhắn
}
void loop()
{
if(mySerial.available()){
delay(100);
// Serial Buffer
while(mySerial.available()){
incomingByte = mySerial.read();
inputString += incomingByte;
}
delay(10);
Serial.println(inputString);
inputString.toUpperCase();
if (inputString.indexOf("OFF") > -1){
digitalWrite(relay, HIGH);// kích mức thấp tƣơng úng HIGH
}
if (inputString.indexOf("ON") > -1){
digitalWrite(relay, LOW);// kích mức thấp tƣơng úng LOW
}
delay(50);
//Delete Messages
if (inputString.indexOf("OK") == -1){
mySerial.println("AT+CMGDA=\"DEL ALL\"");
delay(1000);}
inputString = "";
}
}
Hình ảnh thực tế:
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: 0395 304 802
541
35.
Thiết kế mô hình điều khiển đóng ngắt relay thông qua
Webserver sử dụng board ESP32.
Mục tiêu:

Thiết kế mô hình điều khiển đóng ngắt relay thông qua webserver sử dụng
board ESP32.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
 Add tool board ESP32 cho phần mền IDE:
File  Preferences  URLs , ta dán link này vào mục URLs nhé:
https://dl.espressif.com/dl/package_esp32_index.json
Tool  Board  Board manager  ta gõ từ ( ESP32 )  Chọn install
Phần cứng cần chuẩn bị:
 1 board node ESP32 .
 Dây cắm test board.
 1 Test board.
 1 module Relay 2 kênh 5Vdc.
Lắp mạch nguyên lý:
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: 0395 304 802
542
Code chương trình:
https://drive.google.com/open?id=13t6cRCHss_Mk68epZiRJEZF_7DQPLd1k
#include <WiFi.h>
#include <WebServer.h>
const char* ssid = "ESP32IOT"; // tên wifi
const char* password = "123456789"; // pass
IPAddress local_ip(192,168,1,1);
IPAddress gateway(192,168,1,1);
IPAddress subnet(255,255,255,0);
WebServer server(80);
uint8_t LED1pin = 12;
bool LED1status = LOW;
uint8_t LED2pin = 14;
bool LED2status = LOW;
void setup() {
Serial.begin(115200);
pinMode(LED1pin, OUTPUT);
pinMode(LED2pin, OUTPUT);
WiFi.softAP(ssid, password);
WiFi.softAPConfig(local_ip, gateway, subnet);
delay(100);
server.on("/", handle_OnConnect);
server.on("/led1on", handle_led1on);
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: 0395 304 802
543
server.on("/led1off", handle_led1off);
server.on("/led2on", handle_led2on);
server.on("/led2off", handle_led2off);
server.onNotFound(handle_NotFound);
server.begin();
Serial.println("HTTP server started");
}
void loop() {
server.handleClient();
if(LED1status)
{digitalWrite(LED1pin, HIGH);}
else
{digitalWrite(LED1pin, LOW);}
if(LED2status)
{digitalWrite(LED2pin, HIGH);}
else
{digitalWrite(LED2pin, LOW);}
}
void handle_OnConnect() {
LED1status = LOW;
LED2status = LOW;
Serial.println("GPIO4 Status: OFF | GPIO5 Status: OFF");
server.send(200, "text/html", SendHTML(LED1status,LED2status));
}
void handle_led1on() {
LED1status = HIGH;
Serial.println("GPIO4 Status: ON");
server.send(200, "text/html", SendHTML(true,LED2status));
}
void handle_led1off() {
LED1status = LOW;
Serial.println("GPIO4 Status: OFF");
server.send(200, "text/html", SendHTML(false,LED2status));
}
void handle_led2on() {
LED2status = HIGH;
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: 0395 304 802
544
Serial.println("GPIO5 Status: ON");
server.send(200, "text/html", SendHTML(LED1status,true));
}
void handle_led2off() {
LED2status = LOW;
Serial.println("GPIO5 Status: OFF");
server.send(200, "text/html", SendHTML(LED1status,false));
}
void handle_NotFound(){
server.send(404, "text/plain", "Not found");
}
String SendHTML(uint8_t led1stat,uint8_t led2stat){
String ptr = "<!DOCTYPE html> <html>\n";
ptr +=".button-on:active {background-color: #2980b9;}\n";
ptr +=".button-off {background-color: #34495e;}\n";
ptr +=".button-off:active {background-color: #2c3e50;}\n";
ptr +="p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";
ptr +="</style>\n";
ptr +="</head>\n";
ptr +="<body>\n";
ptr +="<h1>ESP32 Web Server</h1>\n";
ptr +="<h3>Control Relay</h3>\n";
if(led1stat)
{ptr +="<p>RELAY1 Status: ON</p><a class=\"button button-off\"
href=\"/led1off\">OFF</a>\n";}
else
{ptr +="<p>RELAY1 Status: OFF</p><a class=\"button button-on\"
href=\"/led1on\">ON</a>\n";}
if(led2stat)
{ptr +="<p>RELAY2 Status: ON</p><a class=\"button button-off\"
href=\"/led2off\">OFF</a>\n";}
else
{ptr +="<p>RELAY2 Status: OFF</p><a class=\"button button-on\"
href=\"/led2on\">ON</a>\n";}
ptr +="</body>\n";
ptr +="</html>\n";
return ptr;
}
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: 0395 304 802
545
Hình ảnh thực tế:
36.
Thiết kế mô hình hiển thị vị trí tọa độ lên màn hình LCD sử
dụng module GPS NEO6 và arduino.
Mục tiêu:

Thiết kế mô hình hiển thị vị trí tọa độ lên màn hình LCD sử dụng module
GPS NEO6 và arduino.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 Dây cắm test board.
 1 board arduino uno R3.
 1 Test board.
 1 module GPS NEO6.
 1 module LCD + I2C cho LCD.
Lắp mạch nguyên lý:
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: 0395 304 802
546
Code chương trình:
https://drive.google.com/file/d/1Vt1bWYsTKiW3kGtJq2sWI5R6L8Z2QB4h/view
#include <Wire.h> // thư viện i2c
#include <LiquidCrystal_I2C.h>
#include <SoftwareSerial.h>
#include <TinyGPS++.h>// Thư viện gps
LiquidCrystal_I2C lcd(0x27,16,2);// địa chỉ I2C
float lattitude,longitude; // vi độ , kinh độ
SoftwareSerial gpsSerial(8,9);//rx-9,tx -8
TinyGPSPlus gps;
void setup(){
Serial.begin(9600); // tốc độ baud
lcd.init();
lcd.backlight();
gpsSerial.begin(9600);
lcd.print(" GPS ");
delay(2000);
lcd.clear();
}
void loop(){
while(1)
{
while (gpsSerial.available() > 0) /// chờ khi nào có tín hiệu của gps
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: 0395 304 802
547
{ gps.encode(gpsSerial.read()); }
if (gps.location.isUpdated())
{
Serial.print("LAT=");
Serial.println(gps.location.lat(), 6); // in ra màn hình máy tính Vĩ độ
Serial.print("LONG=");
Serial.println(gps.location.lng(), 6);// in ra màn hình máy tính Kinh độ
lattitude=gps.location.lat();
longitude=gps.location.lng();
break;
}
}
Serial.print("LATTITUDE=");
Serial.println(lattitude,6);
Serial.print("LONGITUDE=");
Serial.println(longitude,6);
lcd.print("VD ");lcd.print(lattitude,6);// in ra màn hình LCD VĨ ĐỘ
lcd.setCursor(0, 1);
lcd.print("KD ");lcd.print(longitude,6);// in ra màn hình LCD Kinh ĐỘ
}
// Lưu ý GPS để bên ngoài để bắt sóng.
Hình ảnh thực tế:
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: 0395 304 802
548
37.
Thiết kế mô hình điều khiển thiết bị điện bằng SMS sử dụng
module sim 800l và arduino.
Mục tiêu:

Thiết kế mô hình điều khiển thiết bị điện bằng SMS sử dụng module sim
800l và arduino.
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 Dây cắm test board.
 1 board arduino uno R3.
 1 Test board.
 1 module sim 800l.
 1 module Relay 1 kênh 5Vdc.
 1 module L2596 ( hạ áp xuồng 4.2V dc cấp cho module sim ).
Lắp mạch nguyên lý:
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: 0395 304 802
549
Code chương trình:
https://drive.google.com/file/d/1gPmRFBUhnHW8LR_fzlp3aVbZF29gcz22/view
#include <SoftwareSerial.h>
SoftwareSerial mySerial(10,11); // tx - 10 ; rx - 11
char incomingByte;
String inputString;
int relay = 12; //chân kích relay được nối với chân 12 arduino
void setup()
{
pinMode(relay, OUTPUT); //khai báo relay là output
digitalWrite(relay, LOW); //tắt relay
Serial.begin(9600);
mySerial.begin(9600);
while(!mySerial.available()){
mySerial.println("AT");
delay(1000);
Serial.println("Connecting..."); // kết nối
}
Serial.println("Connected!");
mySerial.println("AT+CMGF=1"); // khởi động chức năng SMS
delay(1000);
mySerial.println("AT+CNMI=1,2,0,0,0");
delay(1000);
mySerial.println("AT+CMGL=\"REC UNREAD\""); // đọc tin nhắn tới
}
void loop()
{
if(mySerial.available()){
delay(100);
// Serial Buffer
while(mySerial.available()){
incomingByte = mySerial.read();
inputString += incomingByte;
}
delay(10);
Serial.println(inputString);
inputString.toUpperCase();
if (inputString.indexOf("OFF") > -1){// nếu nội dụng tin nhắn OFF thì bật relay
digitalWrite(relay, HIGH);// kích mức thấp tương úng HIGH
}
if (inputString.indexOf("ON") > -1){
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: 0395 304 802
550
digitalWrite(relay, LOW);// kích mức thấp tương úng LOW
}
delay(50);
//Delete Messages
if (inputString.indexOf("OK") == -1){
mySerial.println("AT+CMGDA=\"DEL ALL\"");
delay(1000);}
inputString = "";
}
}
Hình ảnh thực tế:
38.
Thiết kế mô hình điều khiển đảo chiều động cơ bƣớc stepper
1.8/step sử dụng nút nhấn và arduino.
Mục tiêu:

Thiết kế mô hình điều đảo chiều động cơ bƣớc sử dụng nút nhấn và arduino.
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: 0395 304 802
551
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 Dây cắm test board.
 1 board arduino uno R3.
 1 Test board.
 1 module driver A4988.
 1 biến trở 10K.
 3 nút nhấn 4 chân.
 3 điện trở 10k.
 1 động cơ bƣớc 1.8/step 1A.
 1 bộ nguồn cung cấp nguồn cho driver A4988 ( 8 – 35Vdc).
Lắp mạch nguyên lý:
Lắp mạch driver A4988, arduino và động cơ step.
3 nút nhấn lần lƣợt đƣợc nối với các chân 8, 9, 10 của arduino.
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: 0395 304 802
552
Code chương trình:
https://drive.google.com/file/d/1ITzT67yeydJrIURw5KPlj_9FQ2IyYt9E/view
const int stepPin = 3; // chân step của board a4988 nối với chân số 3 arduino
const int dirPin = 4;
int sta = 8; // nút nhấn strat / stop
int thuan = 9; // nút nhấn chạy thuận
int nghich = 10; // nút nhấn chạy nghịch
int customDelay,customDelayMapped;
int t = 0; // khai báo biến
int m = 0; // khai báo biến
int status1;// biến lưu các trạng thái nút nhấn
boolean chong_doi()// int char float ngoại trừ void
{
int sta1 =digitalRead(sta); // đọc trạng thái nút nhấn
return sta1;// khi co nhan nut la true
}
void setup() {
// Sets the two pins as Outputs
pinMode(stepPin,OUTPUT);
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: 0395 304 802
553
pinMode(dirPin,OUTPUT);
pinMode(sta,INPUT);
pinMode(thuan,INPUT);
pinMode(nghich,INPUT);
pinMode(6, OUTPUT); //Enable
digitalWrite(6,LOW);
// digitalWrite(dirPin,HIGH);
}
void loop() {
status1 = chong_doi();
if(status1==true)
{
{
t=!t;// đảo trạng thái
}
while(status1==true){status1=chong_doi();}
}
customDelayMapped = speedUp(); // nhận giá trị độ trễ tùy chỉnh
int gtthuan = digitalRead(thuan);
int gtnghich = digitalRead(nghich);
if ( gtthuan == 1) {m=1;}
if ( gtnghich == 1) {m=2;}
// làm cho các xung có độ trễ tùy chỉnh, tùy thuộc vào biến trở xoay, từ đó thay đổi
tốc độ động cơ
if (( t==1)&&(m==1)){// chạy thuận
digitalWrite(dirPin,HIGH);
digitalWrite(stepPin, HIGH);
delayMicroseconds(customDelayMapped);
digitalWrite(stepPin, LOW);
delayMicroseconds(customDelayMapped);
}
if (( t== 1)&&(m==2)) {// chạy nghich
digitalWrite(dirPin,LOW);
digitalWrite(stepPin, HIGH);
delayMicroseconds(customDelayMapped);
digitalWrite(stepPin, LOW);
delayMicroseconds(customDelayMapped);
}
if (t==0) { digitalWrite(dirPin,0);
digitalWrite(stepPin, 0);
m=0;
}
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: 0395 304 802
554
}
int speedUp() {
int customDelay = analogRead(A0); // đọc giá trị cảm biến
int newCustom = map(customDelay, 0, 1023, 300,4000);// Chuyển các giá trị đọc của
chiết áp từ 0 đến 1023 thành các giá trị độ trễ mong muốn (300 đến 4000)
return newCustom;
}
Hình ảnh thực tế:
39.
Thiết kế mô hình điều khiển tốc độ động cơ sử dụng module
driver BTS7960 và arduino.
Mục tiêu:

Thiết kế mô hình điều khiển tốc độ động cơ sử dụng module driver
BTS7960 và arduino.
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 Dây cắm test board.
 1 board arduino uno R3.
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: 0395 304 802
555
 1 Test board.
 1 module driver BTS7960.
 1 biến trở 10K.
 1 động cơ DC 2A.
 1 bộ nguồn cung cấp nguồn cho driver ( 7 – 24Vdc).
Lắp mạch nguyên lý:
Code chương trình:
https://drive.google.com/file/d/14wY-Lt2dQph6r8U6OAnX2yGqtATlxE_V/view
#define RPWM 3 // define pin 3 for RPWM pin (output)
#define R_EN 4 // define pin 2 for R_EN pin (input)
#define R_IS 5 // define pin 5 for R_IS pin (output)
#define LPWM 6 // define pin 6 for LPWM pin (output)
#define L_EN 7 // define pin 7 for L_EN pin (input)
#define L_IS 8 // define pin 8 for L_IS pin (output)
#define CW 1 // chạy nghịch
#define CCW 0 //chạy thuận
#define debug 1
int customDelay,tocdo;
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: 0395 304 802
556
#include <RobojaxBTS7960.h>
RobojaxBTS7960 motor(R_EN,RPWM,R_IS, L_EN,LPWM,L_IS,debug);
void setup() {
Serial.begin(9600);// tốc dộ baud
motor.begin();
}
void loop() {
tocdo = speedUp();
motor.rotate(tocdo,CCW);
}
int speedUp() {
int customDelay = analogRead(A0);
int newCustom = map(customDelay, 0, 1023, 0,50);// Chuyển các giá trị đọc của chiết
áp từ 0 đến 1023 thành các giá trị độ trễ mong muốn (0 đến 50)
return newCustom;
}
Hình ảnh thực tế:
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: 0395 304 802
557
40.
Thiết kế mô hình điều khiển động cơ bƣớc 1.8/step sử dụng
module driver TB6600 và arduino.
Mục tiêu:

Thiết kế mô hình điều khiển động cơ sử dụng module driver TB6600 và
arduino.
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 Dây cắm test board.
 1 board arduino uno R3.
 1 Test board.
 1 module driver TB6600.
 1 động cơ bƣớc 1.8/step.
 1 bộ nguồn cung cấp nguồn cho driver ( 9– 42Vdc).
Lắp mạch nguyên lý:
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: 0395 304 802
558
Code chương trình:
https://drive.google.com/file/d/1VXUFoaVDx18hfvd262o2eOvoK8RbOlVi/view
const int stepPin = 3; //PUL
const int dirPin = 2; // DIR
const int enPin = 8; //ena
void setup() {
pinMode(stepPin,OUTPUT);
pinMode(dirPin,OUTPUT);
pinMode(enPin,OUTPUT);
digitalWrite(enPin,LOW);
}
void loop() {
digitalWrite(dirPin,HIGH); // cho đông cơ quay theo chiều thuận
for(int x = 0; x < 200; x++) { // CHẠY 1 VÒNG 200 STEP / 1.8 ĐỘ = 360, S1 S2
ON, S3 OFF
digitalWrite(stepPin,HIGH);
delayMicroseconds(500);
digitalWrite(stepPin,LOW);
delayMicroseconds(500);
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: 0395 304 802
559
}
delay(1000);
digitalWrite(dirPin,LOW); //thay đổi chiều quay
for(int x = 0; x < 200; x++) {
digitalWrite(stepPin,HIGH);
delayMicroseconds(500);
digitalWrite(stepPin,LOW);
delayMicroseconds(500);
}
delay(1000);
}
Hình ảnh thực tế:
41.
Thiết kế mô hình điều khiển thiết bị điện dựa vào giá trị cảm
biến ánh sáng và đồng thời gửi tin nhắn về điện thoại.
Mục tiêu:

Thiết kế mô hình điều khiển thiết bị điện dựa trên giá trị cảm biến ánh sáng
và đồng thời gửi tin nhắn về điện thoại.
Phần mền cần chuẩn bị :
 Cài đặt phần mềm arduino IDE.
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: 0395 304 802
560
Phần cứng cần chuẩn bị:
 Dây cắm test board.
 1 board arduino uno R3 hoặc mê ga 2560.
 1 Test board.
 1 module sim800l.
 1 module cảm biến ánh sáng ( quang trở ).
 1 module hạ áp L2596.
 1 module relay 1 kênh 5Vdc.
Lắp mạch nguyên lý:
Code chương trình:
https://drive.google.com/file/d/1lD16u0_-8S4vjG1xf0BNnI3T1OmOL7-t/view
#include <SoftwareSerial.h>
SoftwareSerial sim(10, 11);// tx 10 -- rx 11
int _timeout;
String _buffer;
int gtcb;
int led = 8;// RELAY được bật tắt ở chân số 8 của arduino
int cbas = 4;
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: 0395 304 802
561
String number = "0815345816"; //-> các bạn thay đổi số điện thoại ở đây.
void setup() {
delay(5000); //delay for 7 seconds to make sure the modules get the signal
Serial.begin(9600);
pinMode(cbas, INPUT);
pinMode(led, OUTPUT);
_buffer.reserve(50);
Serial.println("Sistem Started...");
sim.begin(9600);
delay(1000);
}
//boolean khigas = true;
void loop() {
gtcb = digitalRead(cbas);
Serial.println(gtcb);
if (gtcb == 1)
{
delay(1000);
if (gtcb == 1){
digitalWrite(led, HIGH);
// callNumber();
SendMessage();
}
}
else {digitalWrite(led, LOW);
}
}
void SendMessage()
{
sim.println("AT+CMGF=1");
delay(1000);
//Serial.println ("Set SMS Number");
sim.println("AT+CMGS=\"" + number + "\"\r");
delay(1000);
String SMS = "troi toi";
sim.println(SMS);
delay(100);
sim.println((char)26);
delay(1000);
_buffer = _readSerial();
}
String _readSerial() {
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: 0395 304 802
562
_timeout = 0;
while (!sim.available() && _timeout < 12000 )
{
delay(13);
_timeout++;
}
if (sim.available()) {
return sim.readString();
}
}
void callNumber() {
sim.print (F("ATD"));
sim.print (number);
sim.print (F(";\r\n"));
_buffer = _readSerial();
Serial.println(_buffer);
}
Hình ảnh thực tế:
42.
Thiết kế mô hình điều khiển góc quay động cơ bƣớc bằng cảm
biến ánh sáng khi trời tối hoặc trời sáng.
Mục tiêu:

Thiết kế mô hình điều khiển góc quay động cơ bƣớc bằng cảm biến ánh sáng
khi trời tối hoặc trời sáng.
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: 0395 304 802
563
Phần mền cần chuẩn bị
 Cài dặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 Dây cắm test board.
 1 board arduino uno R3.
 1 Test board.
 1 module driver A4988.
 1 động cơ bƣớc 1.8/step.
 1 module cảm biến ánh sáng.
 1 bộ nguồn cung cấp nguồn cho driver ( 8– 35Vdc).
Lắp mạch nguyên lý:
Code chương trình:
https://drive.google.com/file/d/19Ao8sUt9mb8Lgdy3q1sVsyzRP8pnjD4O/view
const int stepPin = 11;
const int dirPin = 12;
const int enPin = 10;
int cbas = 3;
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: 0395 304 802
564
int t = 0;
void setup() {
Serial.begin(9600);
pinMode(stepPin,OUTPUT);
pinMode(dirPin,OUTPUT);
pinMode(enPin,OUTPUT);
pinMode(cbas,INPUT);
digitalWrite(enPin,LOW);
digitalWrite(dirPin,HIGH);
}
void loop() {
int gtcb = digitalRead(cbas);
Serial.println(gtcb);
if (( gtcb==1)&&(t==0)){
digitalWrite(dirPin,HIGH);
for(int x = 0; x < 1200; x++) // 1.8/ step --> 200 quay 1 vòng
{
digitalWrite(stepPin,HIGH);
delayMicroseconds(1000);
digitalWrite(stepPin,LOW);
delayMicroseconds(1000);
}
t=1;
}
if (( gtcb==0)&&(t==1)){
digitalWrite(dirPin,LOW);
for(int x = 0; x < 1200; x++)
{
digitalWrite(stepPin,HIGH);
delayMicroseconds(1000);
digitalWrite(stepPin,LOW);
delayMicroseconds(1000);
}
t=0;
}
}
Hình ảnh thực tế:
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: 0395 304 802
565
43.
Thiết kế mô hình đo tốc độ động cơ hiển thị lên màn hình LCD
sử dụng encorder quay và board arduino.
Mục tiêu:

Thiết kế mô hình đo tốc độ động cơ và hiển thị lên màn hình LCD.
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 Dây cắm test board.
 1 board arduino uno R3.
 1 Test board.
 1 module driver BTS7960.
 1 động cơ DC.
 1 biến trở 10k.
 1 module LCD và I2C cho LCD.
 1 module encorder quay.
 1 bộ nguồn cung cấp nguồn cho driver ( 7 – 24Vdc).
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: 0395 304 802
566
Lắp mạch nguyên lý:
Code chương trình:
https://drive.google.com/file/d/1_1oyWzK93MsGQGrxd2xvhp3qywYehz5S/view
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);
#define RPWM 9 // define pin 9 for RPWM pin (output)
#define R_EN 4 // define pin 2 for R_EN pin (input)
#define R_IS 5 // define pin 5 for R_IS pin (output)
#define LPWM 6 // define pin 6 for LPWM pin (output)
#define L_EN 7 // define pin 7 for L_EN pin (input)
#define L_IS 8 // define pin 8 for L_IS pin (output)
#define CW 1 //do not change
#define CCW 0 //do not change
#define debug 1 //change to 0 to hide serial monitor debugging information or set to 1
to view
int customDelay,tocdo;
#include <RobojaxBTS7960.h>
RobojaxBTS7960 motor(R_EN,RPWM,R_IS, L_EN,LPWM,L_IS,debug);
// 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
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: 0395 304 802
567
#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
unsigned long time2 = 0;
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 service routine vars
boolean A_set = false;
boolean B_set = false;
//int tocdo;
unsigned long timeold = 0;
int newposition;
int oldposition=0;
long newtime;
long oldtime=0;
int vantoc = 0;
int ganvantoc = 0;
int ganxung = 0;
int sovong = 0;
void setup() {
// Serial.begin(9600);
lcd.init();
lcd.backlight();
motor.begin();
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);
// Chân encoder trên ngắt 0 (chân 2)
attachInterrupt(0, doEncoderA, CHANGE);
// Chân encoder trên ngắt 1 (chân 3)
attachInterrupt(1, doEncoderB, CHANGE);
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() {
tocdo = speedUp();
motor.rotate(tocdo,CCW);// run motor with 100% speed
if ( (unsigned long) (millis() - time2) > 1000 )
{
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: 0395 304 802
568
rotating = true; // Khởi động bộ debounce (có thể hiểu như bộ chống nhiễu)
newtime=millis();
newposition=encoderPos;
detachInterrupt(0);
detachInterrupt(1);
vantoc = (newposition-oldposition)*60/20;
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);
time2 = millis();
}
}
// Ngắt khi chuyển trạng thái của A
void doEncoderA(){
// debounce
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 ) { // debounce một lần nữa
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
}
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: 0395 304 802
569
}
// 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 ) {
B_set = !B_set;
// Trừ 1 nếu B rồi đến A
if( B_set && !A_set )
encoderPos -= 1;
rotating = false;
}
}
int speedUp() {
int customDelay = analogRead(A0);
int newCustom = map(customDelay, 0, 1023, 2,14);// Chuyển các giá trị đọc của chiết
áp từ 0 đến 1023 thành các giá trị độ trễ mong muốn (300 đến 4000)
return newCustom;
}
Hình ảnh thực tế:
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: 0395 304 802
570
44.
Thiết kế mô hình bật tắt thiết bị điện sử dụng cảm biến vân tay
và board arduino.
Mục tiêu:

Thiết kế mô hình bật tắt thiết bị điện sử dụng cảm biến vân tay và board
arduino.
Phần mền cần chuẩn bị
 Cài đặt phần mềm arduino IDE.
Phần cứng cần chuẩn bị:
 Dây cắm test board.
 1 board arduino uno R3 hoặc nano.
 1 Test board.
 1 module cảm biến vân tay R307.
 1 module relay 1 kênh 5Vdc.
Lắp mạch nguyên lý:
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: 0395 304 802
571
Code chương trình:
https://drive.google.com/file/d/10BchIJCM3I-77F46nZhBDuIWFCrNtt6s/view
Trƣớc hết các bạn add thƣ viện sau vào IDE: thƣ viện Adafruit-Fingerprint-SensorLibrary-master kèm theo trong file code ở trên
Cách lấy dấu vân tay các bạn làm theo nhƣ video sau:
https://youtu.be/MwzgEcaqPIY
Sau đây là file code để bật tắt thiết bị sau khi lấy dấu vân tay thành công.
#include <Adafruit_Fingerprint.h>
int electronic_lock = 12;
SoftwareSerial mySerial(2, 3);// Tx, Rx
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
void setup()
{
pinMode(12, OUTPUT);
Serial.begin(9600);
while (!Serial);
delay(100);
// set the data rate for the sensor serial port
finger.begin(57600);
if (finger.verifyPassword()) {
Serial.println("Found fingerprint sensor");
} else {
Serial.println("Did not find fingerprint sensor");
while (1) { delay(1); }
}
finger.getTemplateCount();
Serial.print("Sensor contains "); Serial.print(finger.templateCount); Serial.println("
template(s)");
Serial.println("Waiting for valid finger...");
}
void loop()
{
getFingerprintIDez();
delay(50);
}
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: 0395 304 802
572
int getFingerprintIDez() {
uint8_t p = finger.getImage();
if (p != FINGERPRINT_OK) return -1;
p = finger.image2Tz();
if (p != FINGERPRINT_OK) return -1;
p = finger.fingerFastSearch();
if (p != FINGERPRINT_OK) return -1;
// found a match!
Serial.print("Found ID #"); Serial.print(finger.fingerID);
Serial.print(" with confidence of "); Serial.println(finger.confidence);
digitalWrite(electronic_lock, HIGH);// mở khóa hay thiết bị điện theo yêu cầu nếu
đúng dấu vân tay
delay(1500);
digitalWrite(electronic_lock, LOW);
Serial.println("Unlocked");
return finger.fingerID;
}
Hình ảnh thực tế:
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: 0395 304 802