Tài Liệu Lab Iot

HỌC VIỆN CÔNG NGHỆ BƯU CHÍNH VIỄN THÔNG
KHOA VIỄN THÔNG 1
------------------------
TÀI LIỆU LAB IoT
Hà Nội, 2022
1
MỤC LỤC
MỤC LỤC…………………………………………………………………………1
DANH MỤC HÌNH VẼ…………………………………………………………...8
I. GIỚI THIỆU LAB IoT………………………………………………………..10
1. Giới thiệu hệ thống thiết bị phòng lab IoT ………………………………….10
1.1 Sơ đồ khối hệ thống thiết bị phòng lab IoT.…………………………..........10
1.2 Danh mục thiết bị phần cứng phòng lab IoT....…………………………….11
2. Giới thiệu các thiết bị Kit IoT ………………………………………….……13
2.1 Giới thiệu Kit IoT STM32............................................................................13
2.2 Giới thiệu Kit IoT Zigbee.............................................................................27
2.3 Giới thiệu mạch nạp Kit IoT………………………………………………40
3. Giới thiệu thiết bị phần mềm IoT……………………………….……..........41
3.1 Phần mềm lập trình vi điều khiển STM32………………………………...41
3.2 Phần mềm lập trình vi điều khiển Kit IoT Zigbee…………………………54
3.3 Phần mềm nạp code vào Kit IoT STM32.....................................................66
3.4 Phần mềm nạp code vào Kit IoT Zigbee......................................................69
3.5 Giới thiệu giao thức truyền thông không dây Zigbee……………………...76
4. Quy trình kiểm tra thiết bị Kit IoT …………………………………………87
4.1 Quy trình kiểm tra phần cứng ……………………………………………...87
4.2 Quy trình kiểm tra phần mềm …………………………………………….88
5. Quy định về quản lý & bảo dưỡng thiết bị phòng lab……………………….94
5.1 Quy định về quản lý thiết bị ……………………………………………….94
5.2 Quy định về bảo dưỡng thiết bị....................................................................94
2
II. GIỚI THIỆU CÁC NỘI DUNG THỰC HÀNH LAB IoT…………………95
1.Thực hành lập trình nhúng với STM32………………………………………95
Bài 1: Thực hành tạo project bằng phần mềm STM32CubeIDE…………...............95
Bài 2: Thực hành nạp code vào Kit bằng phần mềm STM32CubeIDE...................110
Bài 3: Thực hành nạp code vào Kit bằng phần mềm Stlink Utility…………..........114
Bài 4: Thực hành giao tiếp hiển thị LCD: “Welcome to IoT LAB!”................…...121
Bài 5: Thực hành cấu hình các nguồn cấp xung nhịp của hệ thống HSI …..............126
Bài 6: Thực hành cấu hình các nguồn cấp xung nhịp của hệ thống HSE …............129
Bài 7: Thực hành cấu hình vào ra trạng thái trên các chân GPIO Led…................133
Bài 8: Thực hành cấu hình vào ra trạng thái trên các chân GPIO Buzzer...............138
Bài 9: Thực hành cấu hình vào ra trạng thái trên các chân GPIO Led_Red.............143
Bài 10: Thực hành lập trình xây dựng header file cho thư viện GPIO……………148
Bài 11: Thực hành lập trình xây dựng source file cho thư viện GPIO……………157
Bài 12: Thực hành lập trình xây dựng header file của MCU STM32......................168
Bài 13: Thực hành cài đặt và cấu hình GIT.............................................................188
Bài 14: Thực hành lập trình thư viện GIT..............................................................202
Bài 15: Thực hành debug chương trình cấu hình GPIO..........................................213
Bài 16: Thực hành cấu hình ngắt ngoài cho nút nhấn trên Board STM32F4..........222
Bài 17: Thực hành cấu hình ngắt ngoài cho nút nhấn trên Kit mở rộng…..............228
Bài 18: Thực hành truyền và nhận dữ liệu với ngoại vi SPI..................................234
Bài 19: Thực hành lập trình thư viện cho ngoại vi SPI: tạo file
stm32f041re_spi.h.................................................................................................248
stm32f041re_spi.c..................................................................................................257
3
Bài 21: Thực hành truyền và nhận dữ liệu với ngoại vi I2C...................................272
Bài 22: Thực hành lập trình thư viện cho ngoại vi I2C: tạo file
stm32f041re_i2c.h.................................................................................................284
stm32f041re_i2c.c.................................................................................................293
Bài 24: Thực hành truyền và nhận dữ liệu với ngoại vi USART............................306
Bài 25: Thực hành lập trình thư viện cho ngoại vi USART: tạo file
stm32f041re_usart.h..............................................................................................319
stm32f041re_usart.c..............................................................................................327
Bài 27: Thực hành cấu hình ngoại vi TIMER ở chế độ Basic.................................340
Bài 28: Thực hành cấu hình ngoại vi TIMER ở chế độ Capture.............................344
Bài 29: Thực hành cấu hình ngoại vi TIMER ở chế độ PWM................................353
Bài 30: Thực hành lập trình thư viện cho ngoại vi TIMER: tạo file
stm32f041re_tim.h.................................................................................................358
stm32f401re_tim.c.................................................................................................369
Bài 32: Thực hành cấu hình ngoại vi ADC ở chế độ quét liên tục...........................386
Bài 33: Thực hành cấu hình ngoại vi ADC ở chế độ DMA.....................................393
Bài 34: Thực hành lập trình thư viện cho ngoại vi ADC: tạo file
stm32f401re_adc.h................................................................................................401
stm32f401re_adc.c………………………………….............................................408
4
2.Thực hành lập trình mạng không dây Zigbee……………………………...431
Bài 1: Thực hành tạo project bằng phần mềm Simplicity Studio…………............431
Bài 2: Thực hành lập trình tạo folder áp dụng phân tầng cho thư viện Simplicity
Studio …………....................................................................................................442
Bài 3: Thực hành nạp firmware vào Kit IoT Zigbee thông qua phần mềm
Commander ………………………………...........................................................447
Bài 4: Thực hành xử lý các sự kiện của nút nhấn trên Kit IoT Zigbee và sử dụng giao
thức UART để hiển thị ra màn hình………………………………........................451
Bài 5: Thực hành xử lý Leds trên Kit IoT Zigbee …………………......................458
Bài 6: Thực hành giao tiếp với các cảm biến môi trường trên Kit IoT Zigbee và hiển
thị các thông số lên màn hình PC qua phần mềm Hercules
…………………...................................................................................................466
Bài 7: Thực hành tạo thiết bị Z3Coordinator và Zigbee Router để khởi tạo mạng
………………………...........................................................................................469
Bài 8: Thực hành quá trình khởi tạo mạng và gia nhập mạng IoT Zigbee...............472
Bài 9: Thực hành sử dụng CLI xử lý bài toán giao tiếp giữa các Kit IoT
Zigbee ……………………...................................................................................477
Bài 10: Thực hành xây dựng thiết bị Sleepy End
Device....................................................................................................................482
Bài 11: Thực hành xử lý bài toán Binding trong
Zigbee....................................................................................................................489
Bài 12: Thực hành xử lý bài toán Groups trong Zigbee........................................495
3.Các dự án & sản phẩm thực tế tại lab
Project 1: Dự án mô phỏng thiết bị công tắc cảm ứng điều khiển đóng/mở rèm cửa
của Lab IoT
5
Project 2: Dự án giao tiếp với cảm biến nhiệt độ-độ ẩm và hiển thị các thông số lên
màn hình LCD
Project 3: Dự án giao tiếp vi điều khiển STM32F4 với phần mềm mô phỏng
PC_Simulator_KIT
Project 4: Dự án mô phỏng tính năng điều chỉnh độ sáng màn hình tự động trên điện
thoại
Project 5: Dự án giao tiếp với các cảm biến môi trường và hiển thị các thông số lên
màn hình PC
Project 6: Dự án kết hợp và sử dụng Command Line Interface để xử lý bài toán
Binding trong Zigbee
Project 7: Dự án kết hợp và sử dụng Command Line Interface để xử lý bài toán

Groups trong Zigbee
Project 8: Dự án xây dựng thiết bị công tắc 2 nút hoạt động với tính năng hoàn
chỉnh, tích hợp vào hệ thống Lumi Life
Project 9: Dự án xây dựng và điều khiển các thiết bị nhà thông minh tích hợp vào
hệ thống Lumi Life
6
TÀI LIỆU THAM KHẢO
PHỤ LỤC
1. Bố cục bài thực hành
2. Phiếu bàn giao thiết bị thực hành (Sinh viên)
3. Phiếu báo cáo kết quả thực hành (Sinh viên)
4. Phiếu đánh giá kết quả thực hành (Giảng viên)
7
DANH MỤC HÌNH VẼ
Hình 1.1: Sơ đồ khối hệ thống thiết bị phòng lab IoT ……………………………..6
Hình 1.2: 3D mặt trước Kit IOT STM……………………………….………..........8
Hình 1.3: 3D mặt sau kit IOT STM…………………………………………...........8
Hình 1.4: Layout mặt trước Kit IOT STM...…………………………….…………8
Hình 1.5: Layout mặt sau Kit IOT STM …………………………….……….........8
Hình 1.6: Sơ đồ khối Kit IOT STM 32 ………………………….…………............9
Hình 1.7: Sơ đồ nguyên lý Kit IOT STM 32 ………………………………..........10
Hình 1.8: Kit Nucleo STM32F401RE ……..………………………………..........12
Hình 1.9: Vi điều khiển STM32 trên Kit Nucleo STM32F401RE ……..…….......13
Hình 1.10: Chức năng vi điều khiển STM32 trên Kit Nucleo STM32F401RE ….13
Hình 1.11: Cấu trúc vi điều khiển STM32 ………………………….……..…......14
Hình 1.12: Cảm biến nhiệt độ - độ ẩm Si7020 …………………………….……..15
Hình 1.13: Sơ đồ nguyên lý cảm biến nhiệt độ, độ ẩm …………………………..15
Hình 1.14: Quang trở GL5537………………………….………….......................16
Hình 1.15: Sơ đồ nguyên lý quang trở…………………………….…………........16
Hình 1.17: Loa - Buzzer…………………………….………….............................17
Hình 1.17: Sơ đồ nguyên lý module loa…………………………….………….....17
Hình 1.18: Màn hình LCD…………………………….…………..........................18
Hình 1.19: Nguyên lý màn hình LCD……………………………….………........19
Hình 1.20: Sơ đồ nguyên lý chân kết nối…………………………….……….......19
Hình 1.21: LED RGB……………………………….…………….…………........19
Hình 1.22: Sơ đồ nguyên lý LED RGB…………………………….…………......20
Hình 1.23: 3D mặt trước Kit IOT ZIgbee…………………………….……….......20
Hình 1.24: 3D mặt sau Kit IOT Zigbee…………………………….…………......21
Hình 1.25: Layout mặt trước Kit IOT Zigbee…………………………….………21
Hình 1.26: Layout mặt sau Kit IOT Zigbee…………………………….…………22
8
Hình 1.27: Sơ đồ khối Kit IOT Zigbee…………………………….………….......23
Hình 1.28: Sơ đồ nguyên lý Kit IOT Zigbee …………………………….……….23
Hình 1.29: Sơ đồ nguyên lý khối cấp nguồn …………………………….……….26
Hình 1.30: Vi điều khiển EFR32MG21….………………………….………….....27
Hình 1.31: Sơ đồ nguyên lý vi điều khiển EFR32MG21…………………………27
Hình 1.32: Cảm biến nhiệt độ - độ ẩm Si7020…………………………….……...28
Hình 1.33: Sơ đồ nguyên lý cảm biến nhiệt độ, độ ẩm Si7020…………………...28
Hình 1.34: Cảm biến từ SI7210…………………………….…………..................29
Hình 1.35: Sơ đồ nguyên lý cảm biến từ SI7210…………………………….…...29
Hình 1.36: Nguyên lý hoạt động PIR…………………………….………….........30
Hình 1.37: Cảm biến chuyển động PIR…………………………….…………......30
Hình 1.38: Sơ đồ nguyên lý cảm biến PIR…………………………….……….....31
Hình 1.39: LED RGB…………………………….………….................................32
Hình 1.40: Sơ đồ nguyên lý LED RGB………………………….…………..........32
Hình 1.41: Sơ đồ nguyên lý USB to COM…………………………….………….42
Hình 1.42: Quang trở GL5537…………………………….…………....................42
Bảng 1.1 Danh mục thiết bị phần cứng phòng lab IoT …….....................................6
Bảng 1.2 Danh mục thiết bị trên KIT IOT STM32…………….…………............11
Bảng 1.3 Danh mục thiết bị phần cứng phòng KIT IOT ZIGBEE ……………….25
9
I. GIỚI THIỆU LAB IoT
1. Giới thiệu hệ thống thiết bị phòng lab IoT
1.1. Sơ đồ khối hệ thống thiết bị phòng lab IoT
Sơ đồ khối hệ thống thiết bị phòng lab IoT được minh họa tronh hình 1.1, bao
gồm khối nguồn, khối cảm biến, khối điều khiển, khối chấp hành và nền tảng điện
toán đám mây.
a) Khối nguồn: cấp nguồn điện cho hệ thống máy tính và các thiết bị khác như
điều hòa, đèn, máy chiếu, tivi, rèm cửa…
+ nguồn 220v
+ nguồn 5v cho vi điều khiển, IC, led…
b) Khối cảm biến: thu thập dữ liệu về môi trường, con người, sự kiệ để truyền
tới khối điều khiển, bao gồm các thiết bị:
+ cảm biến nhiệt độ, cảm biến độ ẩm, cảm biến ánh sáng, cảm biến hồng
ngoại, cảm biến chuyển động…
+ camera
+ micro
c) Khối điều khiển: thu nhận dữ liệu từ khối cảm biến, tính toán và đưa ra các
quyết định điều khiển tới khối chấp hành, bao gồm các thiết bị:
+ vi điều khiển, IC…
+ IoT gateway
+ AI camera hub
d) Khối chấp hành: thu nhận quyết định điều khiển từ khối điều khiển và chấp
hành, bao gồm các thiết bị:
+ hệ thống đèn chiếu sáng
+ tivi, điều hòa, máy chiếu, rèm cửa
+ hệ thống máy tính
10
e) IoT Cloud: lưu trữ dữ liệu hệ thống
Wifi
IoT App
Wifi
Khối thiết bị thu Zigbee

Khối chấp hành
Zigbee Khối điều khiển (khóa cửa thông minh,
thập dữ liệu Màn hình
(AI camera hub, rèm thông minh, đèn,
(hệ thống cảm biến, hệ giám sát
IoT gateway) điều hòa, máy chiếu,
thống camera) tivi, báo cháy...)
Khối nguồn
Hình 1.1 Sơ đồ khối hệ thống thiết bị phòng lab IoT

1.2. Danh mục thiết bị phần cứng phòng lab IoT
Danh mục thiết bị phần cứng phòng lab IoT được liệt kê trong Bảng 1.1, bao
gồm tên thiết bị, số lượng, thông số kỹ thuật, và vai trò của từng loại thiết bị.
Bảng 1.1 Danh mục thiết bị phần cứng phòng lab IoT
Số Thông số
Stt Tên thiết bị Vai trò
lượng kỹ thuật
- 11th Gen Intel(R) Core(TM)
i5-11400 @ 2.60GHz 2.59
GHz
- 8.00 GB (7.79 GB usable) -Tính toán, viết chương
1 Máy tính để bàn 21
- 64-bit operating system, x64- trình, nạp code vào Kit
based processor
-SSD 120G Gb chuẩn SATA 3
- 6Gb/s Ổ SSD
-Vi điều khiển STM32 -Thực hiện chức năng
Bộ Kit thực hành -Màn hình LCD thu thập, xử lý dữ liệu,
2 20
IoT -Còi (Loa) điều khiển và kết nối
-Nút nhấn thiết bị
11
-LED RGB -Tính toán & hiển thị
-Cảm biến nhiệt độ, độ ẩm các tham số
-Cảm biến ánh sáng - Báo hiệu led
-Ngoại vi & cổng kết nối -Nạp code vào Kit
-Mạch nạp Kit -Đấu nối thiết bị Kit
- Bộ cáp nối chuyên dụng - IoT-máy tính
Type C, D, USB -Đấu nối thiết bị Kit
IoT-ngoại vi
Trung tâm điều khiển
4 AI camera hub 01 06 cổng IP camera
phòng lab
Thu thập dữ liệu, giám
5 Camera 02 IP Camera
sát điều khiển phòng lab
Hiển thị giám sát hệ
6 Tivi 01
thống lab tầng 8
7 Máy chiếu 01 Hiển thị
8 Điều hòa 01 Làm mát
9 Cục phát wifi 01 Viettel Cục phát wifi
10 Switch Tp-Link 01 32 cổng Viettel Chia cổng mạng
11 Hộp kỹ thuật 01 Bảo vệ các thiết bị

Khóa cửa thông
12 01 Khóa cửa thông minh
minh
Rèm cửa thông
13 01 Rèm thông minh
minh
Panel đèn thông
14 08 Chiếu sáng thông minh
minh
12
2. Giới thiệu các thiết bị Kit IoT
2.1. Giới thiệu Kit IoT STM32
a) Khái niệm
+ IoT STM32 Board Kit là bộ board NUCLEO-F401RE của hãng
STMicroelectronics đi kèm với kit mở rộng (shield) do công ty
Lumi thiết kế giúp học viên dễ dàng học tập, phát triển ứng
dụng của mình trên board NUCLEO-F401RE
+ Kit mở rộng tương thích với các jumper header ST Morpho
của board NUCLEO-F401RE. Kit đã tích hợp đa dạng các
ngoại vi như màn hình LCD, led RGB, nút ấn, còi, cảm biến
nhiệt độ - độ ẩm, cảm biến ánh sáng …
Hình 1.2 3D mặt trước Kit IOT STM32
Hình 1.3 3D mặt sau Kit IOT STM32
13
Hình 1.4 Layout mặt trước Kit IOT STM32
Hình 1.5 Layout mặt sau Kit IOT STM32
14
b) Cấu tạo Kit IOT STM32
Hình 1.6 Sơ đồ khối Kit IOT STM 32
Hình 1.7 Sơ đồ nguyên lý của thiết bị KIT IOT STM32
15
Bảng 1.2 Danh mục thiết bị trên KIT IOT STM32
Số Thông số
- Hỗ trợ kết nối
Arduino, đầu nối ST
- STMicroelectronics morpho giúp dễ dàng
- STM32F4 Serial mở
Board NUCLEO-
1 01 -STM32F401RE rộng chức năng của nền
F401RE
MCU tảng phát triển mở
NUCLEO với
nhiều lựa chọn shield
chuyên dụng
-Vi xử lý (Processor)
-Bộ nhớ(Memory)
-Thực hiện chức năng
-Input/output pins
vi điều khiển điều khiển và kết nối
2 01 -Ngoại vi (Peripheral)
STM32 thiết bị
-Clock (xung Clock)
-Bus interfaces
- Dải đo độ ẩm: 0 - 80% RH,

dung sai 土 4%RH.
+ Dải đo nhiệt độ: -10 - 85℃,

cảm biến nhiệt độ, dung sai 土 0.4℃.
3 01 - Đo nhiệt độ, độ ẩm
độ ẩm Si7020 + Điện áp hoạt động: 1.9 -
3.6V.
+ Địa chỉ I2C được thiết kế là
0x40.
- Trở kháng tối: 2MΩ.
Quang trở
4 01 - Trở kháng sáng (10 Lux): 20 - - Đo cường độ ánh sáng
GL5537
30KΩ.
16
Điện áp hoạt động: 3.5V - 5.5V.
+ Dòng điện hoạt động: <
5 Còi – Buzzer 01 25mA. -Báo hiệu âm thanh
+ Tần số âm thanh: 2500 Hz.
- Kích thước: 1.44 inches.

+ Loại màn hình: TFT (Thin
Film Transistor), sử dụng bóng
bán dẫn loại film mỏng, đèn
nền phát sáng thông qua các
điểm ảnh.
6 Màn hình LCD 01 + Dải nhiệt độ hoạt động: -20 - - Hiển thị
70℃.
+ Điện áp hoạt động: 3V.
+ IC điều khiển: ST7735S.
+ Độ phân giải: 128*128 pixels.
+ Chuẩn giao tiếp: SPI gồm 4
chân MISO, MOSI, SS, SCK.
Tương ứng với các jump
7 Connector 01 ST Morpho của Kit
NUCLEO-F401RE
8 Led RGB 01 -Báo hiệu
-Đấu nối thiết bị Kit
Bộ cáp nối chuyên IoT-máy tính
9 01 -Type C, D, USB
dụng -Đấu nối thiết bị Kit
IoT-ngoại vi
17
Board NUCLEO - F401RE:
+ Board NUCLEO-F401RE do hãng STMicroelectronics phát triển dành cho dòng
STM32F4 Serial với STM32F401RE
MCU
+ Bo mạch NUCLEO STM32 mang lại sự linh hoạt, tiện lợi cho
người dùng tiếp cận các khái niệm mới, lập trình với vi điều
khiển STM32.
+ Hỗ trợ kết nối Arduino, đầu nối ST morpho giúp dễ dàng mở
rộng chức năng của nền tảng phát triển mở NUCLEO với
nhiều lựa chọn shield chuyên dụng.
+ Datasheet Kit NUCLEO-F401RE:
https://www.st.com/en/evaluation-tools/nucleo-f401re.html
Hình 1.8 Kit Nucleo STM32F401RE
18
Vi điều khiển STM32:
+ Khái niệm: Là một mạch tích hợp trên một bộ chip có thể lập trình được dùng để
điều khiển hoạt động của hệ thống, đóng vai trò như là “bộ não” điều hành tất cả các
hành vi của board mạch (thiết bị). Sinh viên có thể tham khảo chi tiết tại Datasheet
STM32
Hình 1.9 Vi điều khiển STM32 trên kit IoT
Hình 1.10 Chức năng vi điều khiển STM32
19
+ Cấu trúc vi điều khiển STM32
⚫ Vi xử lý (Processor)
⚫ Bộ nhớ(Memory)
⚫ Input/output pins
⚫ Ngoại vi (Peripheral)
⚫ Clock (xung Clock)
⚫ Bus interfaces
⚫ Rom: chứa chương trình, các dữ liệu ược fix hoặc những constant data. gày
nay, EEPROM hoặc FLASH để hay thế cho ROM vì chúng có chức ăng update
chương trình mới, có hả năng ghi xóa.
⚫ RAM: Đây là thành phần hỗ trợ lưu hương trình thực thi và các biến tạm.
⚫ MCU: Là bộ xử lý hỗ trợ tính toán trung âm.
⚫ Ngoài ra, còn một vài thiết bị ngoại vi hác như: ADC, DAC, I2C, UART,...
Hình 1.11 Cấu trúc vi điều khiển STM32
20
Cảm biến nhiệt độ - độ ẩm Si7020:
+ Cảm biến nhiệt độ, độ ẩm Si7020 là IC tích hợp đo nhiệt độ, độ ẩm với độ chính
xác cao, chuyển tín hiệu từ tương tự sang tín hiệu số, giao tiếp với vi điều khiển qua
chuẩn giao tiếp I2C gồm 2 chân SCL và SDA.
+ Dải đo độ ẩm: 0 - 80% RH, dung sai 土 4%RH.
+ Dải đo nhiệt độ: -10 - 85℃, dung sai 土 0.4℃.

+ Điện áp hoạt động: 1.9 - 3.6V.
+ Địa chỉ I2C được thiết kế là 0x40.
+ Datasheet Si7020:
https://www.silabs.com/sensors/humidity/si7006-13-20-21-34/
device.si7020-a20-im
- Tham khảo source code: Si7020
Hình 1.12 Cảm biến nhiệt độ - độ ẩm SI7020
21
Hình 1.13 Sơ đồ nguyên lý cảm biến nhiệt độ, độ ẩm
Quang trở GL5537:

+ Quang trở là một loại điện trở có điện trở thay đổi theo cường độ ánh sáng chiếu
vào. Nếu đặt ở môi trường ít có ánh sáng, có bóng râm hoặc tối thì điện trở của
quang trở tăng cao. Ngược lại, khi đặt ngoài ánh sáng thì điện trở giảm.
+ Trở kháng tối: 2MΩ.
+ Trở kháng sáng (10 Lux): 20 - 30KΩ.
+ Datasheet GL5537:
https://www.electrokit.com/uploads/productfile/40850/408500 01.pdf
+ Tham khảo source code: GL5537
Hình 1.14 Quang trở GL5537
22
Hình 1.15 Sơ đồ nguyên lý quang trở
Còi – Buzzer:
+ Còi là thiết bị phát ra âm thanh thường được sử dụng trong các mạch điện tử.
+ Điện áp hoạt động: 3.5V - 5.5V.
+ Dòng điện hoạt động: < 25mA.
+ Datasheet: http://www.farnell.com/datasheets/2171929.pdf
+ Tham khảo source code: Buzzer
Hình 1.16 Loa – Buzzer
23
Hình 1.17 Sơ đồ nguyên lý module còi
Màn hình LCD:
+ Kích thước: 1.44 inches.
+ Loại màn hình: TFT (Thin Film Transistor), sử dụng bóng bán dẫn loại film
mỏng, đèn nền phát sáng thông qua các điểm ảnh.
+ Dải nhiệt độ hoạt động: -20 - 70℃.
+ Chuẩn giao tiếp: SPI gồm 4 chân MISO, MOSI, SS, SCK.
+ Tham khảo source code: LCD
24
Hình 1.18 Màn hình LCD
Hình 1.19 Nguyên lý màn hình LCD
Connector:
+ Connector tương ứng với các jump ST Morpho của Kit NUCLEO-F401RE
Hình 1.20 Sơ đồ nguyên lý chân kết nối
25
Led RGB:
+ Led RGB gồm 3 led đỏ (RED), xanh lá (GREEN), xanh dương (BLUE). Để thay
đổi độ sáng, màu sắc của RGB, ta thay đổi độ sáng của từng led trong led RGB qua
việc xuất xung PWM từ vi điều khiển để điều chỉnh điện áp. Dựa trên hiện tượng
lưu ảnh của mắt, từ ba màu cơ bản của LED RGB, có thể tạo ra các màu theo ý
muốn.
+ Datasheet LED RGB: https://www.neumueller.com/en/artikel/spf0af0a
+ Source code: LED_RGB
Hình 1.21 LED RGB
26
Hình 1.22 Sơ đồ nguyên lý LED RGB
2.2. Giới thiệu Kit IoT Zigbee
a) Giới thiệu chung
+ IoT Zigbee board Kit với kích thước nhỏ gọn, tính năng phong phú được công ty
Lumi phát triển dựa trên dòng chip EFR32 Serial 2. Kit IOT Zigbee tích hợp sẵn
nhiều ngoại vi như: LED RGB, cảm biến nhiệt độ, độ ẩm, cảm biến từ, quang trở
đồng thời có khả năng truyền thông không dây qua mạng Zigbee.
Hình 1.23 3D mặt trước Kit IOT Zigbee
27
Hình 1.24 3D mặt sau Kit IOT Zigbee
Hình 1.25 Layout mặt trước Kit IOT Zigbee
28
Hình 1.26 Layout mặt sau Kit IOT Zigbee
b) Cấu tạo phần cứng
Hình 1.27 Sơ đồ khối Kit IOT Zigbee
29
Hình 1.28 Sơ đồ nguyên lý của thiết bị KIT IOT ZIGBEE
30
Bảng 1.3 Danh mục thiết bị phần cứng phòng KIT IOT ZIGBEE
Số Thông số
- Hỗ trợ kết nối
Arduino, đầu nối ST
- STMicroelectronics morpho giúp dễ dàng
- STM32F4 Serial mở
Board NUCLEO-
1 01 -STM32F401RE rộng chức năng của nền
F401RE
MCU tảng phát triển mở
NUCLEO với
nhiều lựa chọn shield
chuyên dụng
-Vi xử lý (Processor)
-Bộ nhớ(Memory)
-Thực hiện chức năng
-Input/output pins
Vi điều khiển điều khiển và kết nối
2 01 -Ngoại vi (Peripheral)
EFR32MG21 thiết bị
-Clock (xung Clock)
-Bus interfaces
- Dải đo độ ẩm: 0 - 80% RH,

dung sai 土 4%RH.
+ Dải đo nhiệt độ: -10 - 85℃,

cảm biến nhiệt độ, dung sai 土 0.4℃.
3 01 - Đo nhiệt độ, độ ẩm
độ ẩm Si7020 + Điện áp hoạt động: 1.9 -
3.6V.
+ Địa chỉ I2C được thiết kế là
0x40.
- Trở kháng tối: 2MΩ.
Quang trở
4 01 - Trở kháng sáng (10 Lux): 20 - - Đo cường độ ánh sáng
GL5537
30KΩ.
31
Điện áp hoạt động: 3.5V - 5.5V.
+ Dòng điện hoạt động: <
5 Còi – Buzzer 01 25mA. -Báo hiệu âm thanh
- Kích thước: 1.44 inches.

+ Loại màn hình: TFT (Thin
Film Transistor), sử dụng bóng
bán dẫn loại film mỏng, đèn
nền phát sáng thông qua các
điểm ảnh.
6 Màn hình LCD 01 + Dải nhiệt độ hoạt động: -20 - - Hiển thị
70℃.
+ Chuẩn giao tiếp: SPI gồm 4
chân MISO, MOSI, SS, SCK.
Tương ứng với các jump
7 Connector 01 ST Morpho của Kit
NUCLEO-F401RE
8 Led RGB 01 -Báo hiệu
-Đấu nối thiết bị Kit
Bộ cáp nối chuyên IoT-máy tính
9 01 -Type C, D, USB
dụng -Đấu nối thiết bị Kit
IoT-ngoại vi
Khối cấp nguồn:

+ Để cấp nguồn cho kit IoT Zigbee, ta có thể dùng ba cách sau: cổng Micro USB
5V, 2 pin AA 1.5V mắc nối tiếp hoặc cung cấp điện áp ngoài 3.3-5V trên connector.
32
+ Cổng Micro USB cung cấp điện áp 5V và hạ áp xuống 3.3V nhờ IC ổn áp
TLV70233. Ở chế độ bình thường, kit được cấp nguồn từ pin gồm 2 pin AA 1.5V
mắc nối tiếp. Khi cắm dây vào cổng Micro USB trên kit, mạch tự chuyển
khối cấp nguồn từ pin sang Micro USB.
+ Datasheet TLV70233:
https://www.ti.com/lit/ds/symlink/tlv702.pdf
Hình 1.29 Sơ đồ nguyên lý khối cấp nguồn

Vi điều khiển EFR32MG Serial 2:
+ EFR32MG21 là sản phẩm đầu tiên trong dòng SoC (System on chip) không dây
Series 2 dựa trên ARM Cortex M33 MCU. Các thiết bị Series 2 là sự phát triển tiếp
theo của các dòng Wireless Gecko Series 1 (EFR32xG1, xG12, xG13 và xG14)
được thiết kế để tăng khả năng xử lý, cải thiện hiệu suất RF lên đến 20dBm, dòng
hoạt động thấp hơn và cung cấp mức độ bảo mật cao hơn.
+ EFR32MG21 hỗ trợ Zigbee, Thread Radio, Bluetooth 5.1.
33
+ Datasheet EFR32MG21:
https://www.silabs.com/wireless/zigbee/efr32mg21-series-2 -socs#
Hình 1.30 Vi điều khiển EFR32MG21
Hình 1.31 Sơ đồ nguyên lý vi điều khiển EFR32MG21
34
Khối cảm biến:
Cảm biến nhiệt độ - độ ẩm Si7020:
+ Cảm biến nhiệt độ, độ ẩm Si7020 là IC tích hợp đo nhiệt
độ, độ ẩm với độ chính xác cao, chuyển tín hiệu từ tương
tự sang tín hiệu số, giao tiếp với vi điều khiển qua chuẩn
giao tiếp I2C.
+ Dải đo độ ẩm: 0-80%RH, dung sai 土 4% RH.
+ Dải đo độ ẩm: -10-85℃, dung sai 土 0.4℃.

+ Điện áp hoạt động: 1.9-3.6V.
+ Địa chỉ I2C được thiết kế là 0x40.
+ Datasheet Si7020: https://www.silabs.com/sensors/humidity/si7006-13-20-21-
34/device.si7020-a20-im
Hình 1.32 Cảm biến nhiệt độ - độ ẩm Si7020
Hình 1.33 Sơ đồ nguyên lý cảm biến nhiệt độ, độ ẩm Si7020
35
Cảm biến từ SI7210:
+ Cảm biến từ Si7210 dựa trên nguyên lý của hiệu ứng Hall, với độ chính xác cao,
chuyển tín hiệu từ tương tự sang tín hiệu số, giao tiếp với vi điều khiển qua chuẩn
giao tiếp I2C.
+ Địa chỉ I2C: 0x33.
+ Điện áp hoạt động: 1.7-5.5V.
+ Datasheet Si7210: https://www.silabs.com/sensors/magnetic/si7210
Hình 1.34 Cảm biến từ Si7210
Hình 1.35 Sơ đồ nguyên lý cảm biến từ Si7210

Cảm biến chuyển động PIR:
+ Cảm biến chuyển động PIR BS312 là cảm biến thụ động dùng nguồn kích thích là
tia hồng ngoại phát ra từ các vật thể nóng như con người, con vật,...
+ Các nguồn nhiệt phát ra tia hồng ngoại, qua lens và kính lọc lấy tia hồng ngoại, nó
được tiêu tụ trên 2 cảm biến hồng ngoại và tạo ra điện áp được khuếch đại. Khi có
nguồn nhiệt đi qua, từ 2 cảm biến này sẽ xuất hiện 2 tín hiệu và 2 tín hiệu này sẽ
được khuếch đại để có biên độ đủ cao và đưa vào mạch so sánh điện áp để tác động
thiết bị điều khiển hay báo động.
36
+ Điện áp hoạt động: 2-3.6V.
+ Datasheet BS312:
https://www.senbasensor.com/products/ldr-switch-3pins-intelligent-pir-big-
windows.html
Hình 1.36 Nguyên lý hoạt động PIR
Hình 1.37 Cảm biến chuyển động PIR
Hình 1.38 Sơ đồ nguyên lý cảm biến PIR
37
LED RGB:
+ LED RGB gồm 3 led đỏ (RED), xanh lá (GREEN), xanh dương (BLUE). Để thay
đổi độ sáng led RGB, ta thay đổi độ sáng của từng led trong led RGB qua việc xuất
xung PWM từ vi điều khiển để điều chỉnh điện áp. Dựa trên hiện tượng lưu ảnh của
mắt, từ 3 màu cơ bản của LED RGB, có thể tạo ra các màu theo ý muốn.
+ Datasheet led RGB: https://www.neumueller.com/en/artikel/spf0af0a
Hình 1.39 LED RGB
Hình 1.40 Sơ đồ nguyên lý LED RGB
38
USB to COM:
+ USB to COM CP2102 là khối trung gian giao tiếp vi điều khiển EFR32MG21
với máy tính truyền và nhận dữ liệu thông qua chuẩn giao tiếp UART.
+ Datasheet CP2102: https://www.silabs.com/interface/usb-bridges/classic/device
.cp2102
Hình 1.41 Sơ đồ nguyên lý USB to COM

Quang trở GL5537:
+ Quang trở là một loại điện trở có điện trở thay đổi theo cường độ ánh sáng chiếu
vào. Nếu đặt ở môi trường ít có ánh sáng, có bóng râm hoặc tối thì điện trở của
quang trở tăng cao. Ngược lại, khi đặt ngoài ánh sáng thì điện trở giảm.
+ Trở kháng tối: 2MΩ.
+ Trở kháng sáng: 20-30KΩ.
+ Datasheet GL5537: https://www.electrokit.com/uploads/productfile/40850/4085
Hình 1.42 Quang trở GL5537
39
2.3. Giới thiệu mạch nạp Kit IoT
+ Kết nối thiết bị KIT IOT ZIGBEE với nguồn USB trên máy tính thông qua dây
nạp J-Link V9. Pinout trên mạch nạp J-Link V9 (chỉ cần quan tâm tới chân SWDIO,
SWDCLK)
Hình 1.43 Sơ đồ chân của mạch nạp J-Link V9
Hình 1.44 Sơ đồ chân nạp của Kit
40
3. Giới thiệu thiết bị phần mềm IoT
3.1 Phần mềm lập trình vi điều khiển STM32
+ STM32CubeIDE là một phần mềm chứa tất cả các công cụ cần thiết để lập trình
cho kit STM32:
⚫ Chọn vi điều khiển hoặc board mạch phát triển để khởi tạo project
⚫ Khởi tạo và cấu hình ngoại vi thông qua giao diện đồ họa
⚫ Tạo ra mã nguồn từ chương trình C từ các cấu hình
⚫ Phát triển firmware
+ Hỗ trợ nhiều hệ điều hành gồm: Windows, Linux, MacOS

+ Yêu cầu về cấu hình máy tính:
• 4Gbytes RAM
• 6Gbytes ổ cứng
41
Hướng dẫn cài đặt và sử dụng phần mềm STM32CubeIDE
Bước1: Tải STM32CubeIDE cho Windows: https://www.st.com/en/development-
tools/stm32cubeide.html
Bước 2: Giải nén chúng ta sẽ nhận được file cài đặt
Bước 3: Nhấn Next, I agree
Bước 4: Chọn đường dẫn lưu phần mềm
42
Bước 5: Click Install để tiến hành cài đặt
Bước 6: Finish
43
Bước 7: File New-> STM32 Project
Bước 8: Next-> Finish
44
Bước 9: Thêm thư viện SDK_1.0.3_NUCLEO-F401RE vừa tải về vào project:
Chọn Properties
9.1. Chọn C/C++ General → Path and Symbols → Source Location → Link Folder
45
9.2. Chọn tích Link to folder in the system
9.3. Chọn Browse để chọn đến file SDK_1.0.3_NUCLEO-F401RE/Select Folder
46
9.4. Nhấn OK
9.5. Nhấn Apply
Bước 10: Sau khi đã thêm thư viện SDK_1.0.3_NUCLEO-F401RE, các bạn cần phải
tạo đường dẫn đến thư mục: Chuột phải Project/Properties
47
10.1. Chọn C/C++ Build → Setting → Tool Setting → Include paths trong
MCU GCC Compiler → chọn Add → chọn Workspace
48
10.2. Chọn các đường dẫn sau:
+ SDK_1.0.3_NUCLEO-F401RE/shared/Drivers/CMSIS/Include
+ SDK_1.0.3_NUCLEO-F401RE/shared/Drivers/STM32F401RE_St
dPeriph_Driver/inc
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/button
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/rtos
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/serial
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/buzzer
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/led
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/sensor
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/ucglib
+ SDK_1.0.3_NUCLEO-F401RE/shared/Utilities
49
10.3. Trong C/C++ Build → Setting → Tool Setting → Libraries trong MCU
GCC Linker→ chọn Add → Workspace
50
10.4. Trong Library search paths (-L) thêm đường dẫn sau:
SDK_1.0.3_NUCLEO-F401RE\lib_stm.
10.5. Tiếp tục trong Libraries(-l) → viết Libraries và Add
51
Bước 11: Coding trong main.c file
Bước 12: Build project
Bước 13: Xem các thao tác báo lỗi và cảnh báo
52
Bước 14: Xem các thông tin về quá trình biên dịch
Bước 15: Thao tác tìm đến khai báo định nghĩa: Ctrl + click vào một hàm
53
Bước 16: Đi đến vị trí chỉnh sửa gần nhất: Ctrl + Q, Ctrl + Alt + Right
Bước 17: Chạy kết quả & Kết thúc
3.2. Phần mềm cho Kit IoT Zigbee

Giới thiệu phần mềm Simplicity Studio cho Kit IoT Zigbee và cách thức tạo
project
Bước1: Trong giao diện của Simplicity Studio IDE, lựa chọn File => New =>
Project
Bước 2: Trên cửa sổ New Project, lựa chọn Silicon Labs AppBuilder
Project => Next
54
Bước 3: Lựa chọn Silicon Labs Zigbee (chỉ lựa chọn được khi đã tải SDK) -->
Next
Bước 4: Lựa chọn EmberZNet x.x.x.x GA SoC x.x.x.x (với x là số phiên

bản SDK sử dụng) => Next
55
Bước 5: Lựa chọn Project mẫu mà bạn muốn khởi tạo, đối với mỗi project,
SDK đều cung cấp cho chúng ta các đoạn mô tả để biết được project đó
được sử dụng để làm gì.
Lưu ý: Đối với SDK 6.7, IDE sẽ gặp lỗi khi tạo blank project (blank application) vì
vậy không được tích vào phần Start with a blank application
Bước 6: Đặt tên và lựa chọn đường dẫn lưu trữ project
56
Bước 7:
- Nếu sử dụng Development Board được phát triển từ Silicon Labs, lựa chọn vào
mục Board - nhập tên board
- Nếu sử dụng module được phát triển từ Silicon Labs, lựa chọn vào Part –nhập tên
module (VD: EFR32MG21A010F512IM32)
- Lựa chọn Compiler cho chương trình (VD: GNU, IAR,…). Finish
Bước 8: Mở file Z3LightSoc.isc để cấu hình. Trong Tab ZCL Cluster xóa
endpoint 2 và 3 đi vì không sử dụng
57
Kết quả
58
Bước 9: Trong mục ZCL device type => ZigBee Custom
Bước 10: Chọn HA devices => Chọn HA On/Off Light
59
Bước 11: Trong Tab HAL chọn None cho mục Bootloader vì chưa sử dụng
Bước 12: Trong Tab Plugin search green và bỏ chọn Green Power, Green
Power Library, provides API:
Bước 13: Search ZLL và bỏ chọn ZigBee Light Link
60
Bước 14: Search color và bỏ tích
Bước 15: Bỏ tích Level Control Server Cluster vì không sử dụng
61
Bước 16: Sử dụng Callback Hal Button Isr để dùng hàm xử lý nút nhấn với tham
số là
button: xác định xem nút nào được nhấn
state: xác định trạng thái của nút nhấn là nhấn hay nhả. Sử dụng Main Init để biết
khi nào thiết bị được khởi động lại
Bước 17: Chọn Generate để Simplicity Studio tạo ra các file cần thiết sau khi đã
cấu hình xong
62
Bước 18: Cấu hình chân trong file Hardware configurator
18.1. Trong mục PA => Chọn PA Voltage 1000

PA Selection Medium Power Vì MCU là dòng EFR32MG21 Series 2
63
18.2. Trong mục UART0 =>Chân TX-PA5, Chân RX-PA6
18.3. Chọn Flow control mode => No flow control TX Pin: PA5
RX Pin: PA6
18.4. Trong mục Button, cấu hình chân cho nút nhấn
SW1-PD4, SW2-PD3
Bỏ tích LED vì chưa sử dụng
64
Bước 19: Sau đó tiến hành build chương trình bằng biểu tượng cây búa
Xuất hiện một số lỗi về thư viện. Kích đúp chuột vào lỗi để di chuyển
đến dòng bị lỗi
Những thư viện này không được dùng vì vậy hãy xóa nó đi hoặc sử
dụng // để comment chúng lại
Sau đó sử dụng cây búa để build lại chương trình
Nếu tiếp tục lỗi thì hãy comment lại những dòng đó
65
Đã hết lỗi => Hoàn tất quá trình cấu hình
3.3. Phần mềm nạp code vào Kit IoT STM32
File .bin và file .hex được sử dụng để nạp vào vi điều khiển
Cách thức nạp code vào Kit IoT bằng phần mềm STM32CubeIDE
Bước 1: Kết nối Kit mở rộng với máy tính
66
Bước 2: Trên phần mềm STM32CubeIDE, chọn click phải chuột vào project
muốn nạp vào Kit, chọn Run As, sau đó chọn STM32 Cortex-M C/C++
Application
Bước 3: Lần đầu tiên nạp project sẽ xuất hiện bảng Configuration
67
Bước 4: Run As
Hoặc click chuột vào biểu tượng trên thanh công cụ
Bước 6: Kết quả code đã được nạp vào Kit
68
3.4 Phần mềm nạp code vào vi điều khiển Kit IoT Zigbee
Cách thức nạp code vào Kit IoT Zigbee
Bước 1: Chọn Generate để Simplicity Studio tạo ra các file.isc cần thiết
Bước 2: Trong file.isc được sinh ra trong project, lựa chọn Generate để
sinh ra các file thư viện, phục vụ cho quá trình nạp firmware vào Kit
Bước 3: Có thể sử dụng một trong 3 file để tiến hành nạp firmware vào Kit
Bước 4: Cắm mạch nạp
69
Bước 5: Mở phần mềm Commander:
C:\SiliconLabs\SimplicityStudio\v4\developer\adapter_packs\commander
Bước 6: Sau khi cắm Jlink được kết nối với Kit IoT Zigbee
70
Bước 7: Nạp firmware: Lựa chọn J-Link Device sau đó nhấn Connect để kết nối
với Jlink
Kết quả:
71
Bước 8: Nhấn Connect để kết nối với Kit IoT Zigbee
Kết quả:
72
Bước 9: Lựa chọn mục Tab Flash => Chọn Browse để chọn đường dẫn đến file
firmware
Bước 10: Lựa chọn đường dẫn đến project cần nạp firmware
Ví dụ
C:\Users\TrungNT\SimplicityStudio\v4_workspace\SW_ZB_V1_0_0\GNU
ARM v7.2.1 – Default
Lưu ý: Thư mục GNU ARM v7.2.1 - Default là nơi lưu trữ firmware để nạp
vào Kit
73
Bước 11: Nhấn Erase chip để xóa dữ liệu trong Flash
74
Bước 12: Nhấn Flash để nạp firmware
Bước 13: Kết thúc
75
3.5. Giới thiệu giao thức truyền thông không dây Zigbee
a) Cấu trúc Zigbee

+ Zigbee là một tiêu chuẩn mở toàn cầu
• Tốc độ truyền dữ liệu thấp, tối ưu năng lượng.
• Tốc độ tối đa: 250kbps
• Cấu trúc mạng Star, Mesh
• Gồm 3 phiên bản: Zigbee 2004; Zigbee 2006; Zigbee PRO
+ Zigbee được xây dựng trên nền tảng của IEEE 802.15.4.
• Sử dụng 4 tầng OSI
• 2 tầng MAC và PHY tuân theo tiêu
chuẩn IEEE 802.15.4
• 2 tầng APP và NWK được phát triển
bởi nhà phát hành Zigbee
+ Tần số sử dụng phụ thuộc vào dải băng tần ở quốc gia, chuẩn này xây
dựng trên ba băng tần, có tất cả 27 kênh:
• 868.0 – 868.6Mhz: Châu âu – 1 kênh, sử dụng kênh số 0
76
• 902.0 – 928.0Mhz: Mỹ - 10 kênh – từ kênh 1 – 10
• 2.40 – 2.48Ghz: Toàn thế giới – 16 kênh – từ 11 – 26.
+ IEEE 802.15.4 được chia thành 2 kiểu loại thiết bị

• Full-Function Devices (FFDs)
• Reduced-Function Devices (RFDs)
b)Các mô hình Zigbee

• Zigbee Home Automation 1.2 (Zigbee HA 1.2)
• Zigbee Light Link (ZLL)
77
• Zigbee Green Power
• Zigbee 3.0
+ Zigbee 3.0 là sự tổng hợp của cả 03 loại mô hình: Zigbee HA 1.2; Zigbee
Light Link; Zigbee Green Power.
d)Thành phần và vai trò thiết bị Zigbee 3.0
+ Zigbee Coordinator (ZC):

• Giữ vai trò quản lý toàn mạng, là bộ điều khiển chính
• Chỉ tồn tại duy nhất một ZC trong một mạng Zigbee
• Có chức năng giống ZR khi duy trì mạng
78
Router đặc biệt:
• Tìm kênh lựa chọn kênh tần phù hợp.
• Tạo mạng Centralized Network
• Địa chỉ mạng cố định: 0x0000
• Quy định thông tin mạng: PAN-ID, Extended PanID, Network Key
• Quản lý các hoạt động mạng: gia nhập, trao đổi thông tin
• Duy trì tổng thể bảo mật của mạng
+ Zigbee Router (ZR)
Có đầy đủ các chức năng như:
• Truyền bản tin
• Nhận bản tin
• Chuyển tiếp bản tin
• Cung cấp dịch vụ định tuyến cho hạ tầng mạng
• Chịu trách nghiệm về lưu thông trong mạng (routing traffic)
• Là thiết bị được thiết kế luôn thức
+ Zigbee End Device (ZED)
• KHÔNG tham gia giao thông mạng
• Giao tiếp với duy nhất với một thiết bị: ZR hoặc ZC
• Muốn truyền bản tin đến ZED, phải thông qua Parent
79
e) Các phương thức giao tiếp trong Zigbee
Beacon:
+ Là loại giao thức giao tiếp đồng bộ
● Sử dụng cấu trúc superframe:
○ Chia là 16 khe
○ Gồm 2 giai đoạn:
■ CAP – Giai đoạn tranh chấp truy cập
■ CFP - Giai đoạn tranh chấp tự do
Lưu ý: Trong giai đoạn tranh chấp truy cập, tất cả các thiết bị muốn truyền dữ liệu
trên kênh tần số cần phải sử dụng giao thức CSMA-CA.
80
● Giai đoạn tranh chấp tự do:
Zigbee Coordinator sẽ cung cấp những khe thời gian cụ thể đến cho từng thiết bị,
những khe này được gọi là Guaranteed time slot (GTS)
Lưu ý: Thiết bị được cung cấp GTS sẽ thoải mái thực hiện quá trình truyền – nhận
bản tin trong khoảng thời gian GTS mà KHÔNG CẦN phải sử dụng cơ chế CSMA-
CA.
+ Để thiết bị được cung cấp được GTS:

Zigbee Coordinator phải chắc chắn rằng toàn bộ các nút mạng của mình đều
phải được đồng bộ với nhau. Và beacon là một bản tin để thực hiện việc đồng bộ
xung thời gian của tất cả các nút trong mạng.
+ Nhược điểm:
● Tất cả các thiết bị mạng đều cùng
phải thức dậy thường xuyên để lắng
81
nghe bản tin beacon, đồng bộ lại
xung thời gian.
● Làm ảnh hưởng tới những thiết bị như sleepy end device, khi chúng phải
thức dậy chỉ để phục vụ cho việc đồng bộ mà không thực hiện các bất kỳ
một tác vụ nào khác.
Non-Beacon:
● Là giao thức giao tiếp không đồng bộ
● Không được cấp GTS và CFP
● Các thiết bị luôn tồn tại trong giai
đoạn CAP (tranh chấp truy cập)
● LUÔN phải sử dụng thuật toán CSMA/CA để thực hiện truyền nhận bản tin.
● Các thiết bị Sleepy End Device sẽ không bị ảnh hưởng
+ Có 3 hình thức truyền dữ liệu chính trong Zigbee:

● Dữ liệu được truyền từ thiết bị => Coordinator
● Dữ liệu được truyền từ Coordinator => thiết bị
● Dữ liệu được truyền thiết bị => thiết bị khác
Cả 3 kiểu hình thức này đều sử dụng phương thức giao tiếp Peer to Peer. Các loại
thiết bị sẽ giao tiếp trực tiếp đến nhau.
82
+ Truyền từ thiết bị => ZC.
● Thiết bị phải đồng bộ xung thời gian
thường xuyên. Để gửi bản tin đến cho ZC
83
+ Truyền từ Coordinator => thiết bị.
84
85
+ Truyền từ thiết bị => thiết bị:
86
4. Quy trình kiểm tra thiết bị Kit IoT
4.1. Quy trình kiểm tra thiết bị phần cứng
Bảng 4.1 Quy trình kiểm tra thiết bị phần cứng Kit IoT STM32
87
Bảng 4.2 Quy trình kiểm tra thiết bị phần cứng Kit IoT Zigbee
4.2. Quy trình kiểm tra thiết bị phần mềm

a) Kit IoT STM32
Để nạp phần mềm cho thiết bị KIT IOT STM, các bạn cần thực hiện
theo các bước sau:
Bước 1: Download và cài đặt phần mềm STM32 ST-LINK Utility tại
đây. Sau khi cài đặt xong, phần mềm có giao diện như hình sau:
88
Hình 3.1 Giao diện phần mềm STM32 ST-LINK Utility
Bước 2: Kết nối thiết bị KIT IOT STM (bao gồm BOARD STM và Kit
mở rộng) với nguồn USB trên máy tính thông qua dây cáp mini USB.
Bước 3: Mở phần mềm STM32 ST-LINK Utility, trên thanh công cụ
hãy click vào Target và chọn Connect để kết nối máy tính với BOARD
STM32. Kết nối thành công, phần mềm sẽ hiển thị như hình sau.
Hình 3.2 Phần mềm kết nối thành công với thiết bị
89
Bước 4: Click vào Binary File để lựa chọn file.bin cần nạp cho BOARD STM32.
Hình 3.3 Chọn file .bin cần nạp

Bước 5: Xóa full bộ nhớ chip
Hình 3.4 Xóa full bộ nhớ chip
90
Bước 6: Hoàn tất quá trình nạp phần mềm.
Hình 3.5 Nạp phần mềm vào bộ nhớ thiết bị

b) Kit IoT Zigbee
Để nạp phần mềm cho thiết bị KIT IOT ZIGBEE, các bạn cần thực hiện theo các
bước sau:
Bước 1: Download và cài đặt phần mềm J-Flash Lite tại đây. Sau khi cài đặt xong,
phần mềm có giao diện như hình sau:
Hình 3.6 Giao diện phần mềm J-Flash Lite
91
Bước 2: Kết nối thiết bị KIT IOT ZIGBEE với nguồn USB trên máy tính thông qua
dây nạp J-Link V9.
● Pinout trên mạch nạp J-Link V9 (chỉ cần quan tâm tới chân SWDIO, SWDCLK)
Hình 3.7 Sơ đồ chân của mạch nạp J-Link V9

● Pinout trên KIT
Hình 3.8 Sơ đồ chân nạp của Kit
92
Bước 3: Xóa và nạp phần mềm
Hình 3.9 Xóa và nạp phần mềm cho thiết bị

● Bật phần mềm J-Flash Lite: Chọn chip EFR32MG21AxxxF512.
● Lựa chọn firmware cần nạp.
● Nhấn Erase chip để xóa full bộ nhớ của chip.
● Nhấn Program Device để hoàn tất quá trình nạp phần mềm.
Lưu ý: Quá trình xóa và nạp chip bằng J-Flash Lite không quá khác biệt so với các
thiết bị khác, nên chú ý về việc các đoạn text thông báo xem đã thành công hay
chưa
93
5. Quy định về quản lý & bảo dưỡng thiết bị phòng lab
5.1. Quy định về quản lý thiết bị
+ Thời gian mỗi buổi thực hành là từ 3-4 giờ, chia làm 10-12 nhóm nhỏ, mỗi nhóm
2 sinh viên/1 bộ kit/1 máy tính, 8 bộ kit dự phòng.
+ Trước mỗi buổi thực hành, mỗi nhóm sinh viên được cung cấp: 1 phiếu bàn giao
thiết bị thực hành bao gồm danh mục các thiết bị thực hành, cuối buổi thực hành
sinh viên kiểm tra và nộp lại phiếu bàn giao + thiết bị thực hành
5.2. Quy định về bảo dưỡng thiết bị
+ Sau khi sử dụng xong thiết bị, các bạn cần phải thực hiện các bước sau để bảo
dưỡng thiết bị:
Bước 1: Kiểm tra phần mềm trên máy tính có đang nạp phần mềm hay không, nếu
có thì dừng quá trình nạp và đóng phần mềm lại.
Bước 2: Tháo dây USB kết nối giữa thiết bị và máy tính. Riêng đối với thiết bị KIT
IOT ZIGBEE, các bạn phải tháo pin ra để đảm bảo pin vẫn còn năng lượng cho
quá trình thí nghiệm tiếp theo.
Bước 3: Thu gọn thiết bị và dây kết nối cho vào hộp đựng để nơi khô thoáng, dễ
tìm và quản lý.
94
II. GIỚI THIỆU CÁC NỘI DUNG THỰC HÀNH IoT
1.Thực hành lập trình nhúng với STM32
Bài 1: Thực hành tạo project bằng phần mềm STM32CubeIDE
Nội dung thực hành:
Viết chương trình tạo project bằng phần mềm STM32CubeIDE
Yêu cầu thực hành:
+ Sinh viên tra cứu tài liệu sử dụng phần mềm STM32CubeIDE,
+ Sinh viên tra cứu tài liệu nguyên lý mạch Schematic của board
Nucleo F401RE tại đây để biết được sơ đồ chân của led và nút nhấn trên mạch.
Thiết bị thực hành: Máy tính, Board Nucleo F401RE, dây cáp đấu nối
Thời gian thực hành: 45 phút
Số lượng sinh viên thực hành: 2-3 người/nhóm
Kết quả thực hành:
+ Sinh viên nắm rõ cách thức tạo một project, thêm các thư viện, định nghĩa
các macro, xây dựng các hàm chức năng trên phần mềm STM32CubeIDE.
+ Sinh viên nắm rõ sơ đồ đấu nối chân của led và nút nhấn trên mạch Nucleo
F401RE
Các bước thực hành:
Bước1: Tải STM32CubeIDE cho Windows:

https://www.st.com/en/development-tools/stm32cubeide.html
95
Bước 2: Giải nén chúng ta sẽ nhận được file cài đặt
Bước 3: Nhấn Next, I agree
Bước 4: Chọn đường dẫn lưu phần mềm
96
Bước 5: Click Install để tiến hành cài đặt
Bước 6: Finish
97
Bước 7: File New-> STM32 Project
Bước 8: Next-> Finish
98
Bước 9: Thêm thư viện SDK_1.0.3_NUCLEO-F401RE vừa tải về vào project:
Chọn Properties
99
9.1. Chọn C/C++ General → Path and Symbols → Source
Location → Link Folder
9.2. Chọn tích Link to folder in the system
9.3. Chọn Browse để chọn đến file SDK_1.0.3_NUCLEO-F401RE/Select Folder
100
9.4. Nhấn OK
9.5. Nhấn Apply
101
Bước 10: Sau khi đã thêm thư viện SDK_1.0.3_NUCLEO-F401RE, các bạn cần
phải tạo đường dẫn đến thư mục: Chuột phải Project/Properties
10.1. Chọn C/C++ Build → Setting → Tool Setting → Include paths trong
MCU GCC Compiler → chọn Add → chọn Workspace
102
10.2. Chọn các đường dẫn sau:
+ SDK_1.0.3_NUCLEO-F401RE/shared/Drivers/CMSIS/Include
+ SDK_1.0.3_NUCLEO-F401RE/shared/Drivers/STM32F401RE_St
dPeriph_Driver/inc
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/button
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/rtos
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/serial
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/buzzer
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/led
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/sensor
103
+ SDK_1.0.3_NUCLEO-F401RE/shared/Middle/ucglib
+ SDK_1.0.3_NUCLEO-F401RE/shared/Utilities
104
10.3. Trong C/C++ Build → Setting → Tool Setting → Libraries trong MCU
GCC Linker→ chọn Add → Workspace
10.4. Trong Library search paths (-L) thêm đường dẫn sau:
SDK_1.0.3_NUCLEO-F401RE\lib_stm.
105
10.5. Tiếp tục trong Libraries(-l) → viết Libraries và Add
Bước 11: Coding trong main.c file
Bước 12: Build project
106
107
Bước 13: Xem các thao tác báo lỗi và cảnh báo
Bước 14: Xem các thông tin về quá trình biên dịch
Bước 15: Thao tác tìm đến khai báo định nghĩa: Ctrl + click vào một hàm
108
Bước 16: Đi đến vị trí chỉnh sửa gần nhất: Ctrl + Q, Ctrl + Alt + Right
109
Bài 2: Thực hành nạp code vào Kit bằng phần mềm STM32CubeIDE
Thực hành tạo và nạp code vào Kit bằng phần mềm STM32CubeIDE
+ Sinh viên tra cứu tài liệu sử dụng phần mềm STM32CubeIDE
+ Sinh viên nắm rõ thao tác tạo một project, thêm các thư viện, định nghĩa các
macro trên phần mềm STM32CubeIDE như nội dung Bài 1
+ Sinh viên nắm rõ cách thức tạo và nạp code vào Kit bằng phần mềm
STM32CubeIDE
Bước1: Tạo một project như nội dung Bài 1.
Bước2: Kết nối Kit mở rộng với máy tính
110
Bước 3: Trên phần mềm STM32CubeIDE, chọn click phải chuột vào project
muốn nạp vào Kit, chọn Run As, sau đó chọn STM32 Cortex-M C/C++
Application
Bước 4: Lần đầu tiên nạp project sẽ xuất hiện bảng Configuration
111
Bước 5: Run As
Hoặc click chuột vào biểu tượng trên thanh công cụ
112
113
Bài 3: Thực hành nạp code vào Kit bằng phần mềm Stlink Utility
Thực hành tạo và nạp code vào Kit bằng phần mềm Stlink Utility
+ Sinh viên tra cứu tài liệu sử dụng phần mềm Stlink Utility
+ Sinh viên nắm rõ cách thức tạo và nạp code code vào Kit bằng phần mềm
Stlink Utility
Bước1: Tạo một project như nội dung Bài 1.
Bước2: Kết nối Kit mở rộng với máy tính
114
Bước 3: Trên phần mềm Stlink Utility, chọn Target/Connect
Bước 4: Mở file cần nạp vào Kit (file .bin hoặc .hex)
115
Bước 5: Chọn file Bai2.bin/Open
Bước 6: Xóa các tham số của phiên chạy lần trước: chọn Target/Erase Sectors
(CTRL+ E)
116
Bước 7: Select all/Apply
117
Bước 8: Bắt đầu nạp code vào Kit: Target/Program&Verify (CTRL+P)
118
Bước 9: Chọn đúng file path/Start
119
120
Bài 4: Thực hành giao tiếp hiển thị LCD: “Welcome to IoT LAB!”
Viết chương trình hiển thị dòng text " WELCOME TO IoT LAB " ra màn
hình LCD sử dụng Kit mở rộng.
Nucleo F401RE để biết được sơ đồ chân của LCD và nút nhấn trên mạch.
+ Sinh viên nắm rõ cách thức giao tiếp hiển thị LCD trên Kit mở rộng.
+ Sinh viên nắm rõ nắm rõ cách thức tạo một project, thêm các thư viện, định
nghĩa các macro, xây dựng hàm để cấp clock, hàm để khởi tạo chức năng timer, hàm
để hiển thị chữ lên LCD trên phần mềm STM32CubeIDE.
Bước 1: Tạo một project như nội dung Bài 1.
Bước 2: Thêm các thư viện “system_stm32f4xx.h” "timer.h", "Ucglib.h"

bằng câu lệnh #include
121
Bước 3: Khai báo biến thuộc kiểu cấu trúc struct của LCD.
static ucg_t ucg;
Bước 4: Sử dụng các hàm
+ Sử dụng hàm SystemCoreClockUpdate() để cấp clock.

+ Sử dụng hàm TimerInit để khởi tạo chức năng timer.
+ Để sử dụng LCD cần sử dụng các hàm sau trong hàm main và trước
hàm while(1).
+ Sử dụng hàm ucg_DrawString để hiển thị chữ lên LCD.

Ví dụ: để hiển thị dòng text "WELCOME TO IoT LAB" có vị trí hàng
ngang LCD là 0, hàng dọc LCD là 12, có chiều hiển thị 0 nằm ngang màn
hình.
ucg_DrawString (&ucg, 0, 12, 0," WELCOME TO IoT LAB ").:
Bước 5: Trong while(1) gọi hàm processTimerScheduler để sử dụng timer:
122
Hãy thử sử dụng hàm ucg_SetFont để thay đổi font chữ và cỡ chữ
Lựa chọn một một font chữ và cỡ chữ để sử dụng/Thay thế font chữ vào hàm
và thử nghiệm kết quả.
123
124
125
Bài 5: Thực hành cấu hình các nguồn cấp xung nhịp của hệ thống HSI
Viết một chương trình cấu hình đầu ra output trên một chân của MCU là một
xung nhịp HSI
+ Sinh viên nắm rõ nắm rõ viết một chương trình cấu hình đầu ra output trên
chân của MCU
nghĩa các macro, xây dựng hàm điều khiển led, hàm đọc giá trị nút ấn, hàm Delay
để chống rung nút ấn trên phần mềm STM32CubeIDE.
Bước 2: Định nghĩa địa chỉ cơ bản cho ngoại vi clock RCC, địa chỉ offset của
thanh ghi cấu hình RCC và địa chỉ cơ bản của ngoại vi GPIOA như sau:
126
#define RCC_BASE_ADDR 0x40023800UL
#define RCC_CFGR_REG_OFFSET 0x08UL
#define RCC_CFGR_REG_ADDR (RCC_BASE_ADDR +

RCC_CFGR_REG_OFFSET)
#define GPIOA_BASE_ADDR 0x40020000UL
Bước 3: Khai báo biến con trỏ kiểu dữ liệu uint32_t trỏ đến địa chỉ thanh ghi
cấu hình RCC như sau:
uint32_t *pRccCfgrReg = (uint32_t*) RCC_CFGR_REG_ADDR;
Bước 4: Cấu hình trường bit MCO1 của thanh ghi RCC_CFGR để lựa chọn
HSI làm nguồn clock.
*pRccCfgrReg &= ~(0x3 << 21); // Clear 21 and 22 bit positions
Bước 5: Cài đặt hệ số chia prescaler cho đầu ra MCO1 là 4
*pRccCfgrReg |= (1 << 25);
*pRccCfgrReg |= (1 << 26);
Bước 6: Cài đặt chân PA8 ở chế độ alternate function để hoạt động như tín hiệu
MCO1
+ Cấp xung clock hoạt động cho PORT A như sau:

uint32_t *pRCCAhb1Enr = (uint32_t*)(RCC_BASE_ADDR + 0x30);
*pRCCAhb1Enr |= ( 1 << 0); // Enable GPIOA peripheral clock
+ Cài đặt chế độ của chân PA8 làm chức năng alternate function.
uint32_t *pGPIOAModeReg = (uint32_t*)(GPIOA_BASE_ADDR + 00);
127
*pGPIOAModeReg &= ~( 0x3 << 16); //clear
*pGPIOAModeReg |= ( 0x2 << 16); //set
+ Cài đặt thanh ghi alternation function ở chế độ 0 tương ứng với chân PA8.
uint32_t *pGPIOAAltFunHighReg = (uint32_t*)(GPIOA_BASE_ADDR + 0x24);
*pGPIOAAltFunHighReg &= ~( 0x0f << 0);
128
Bài 6: Thực hành cấu hình các nguồn cấp xung nhịp của hệ thống HSE
Viết một chương trình cấu hình đầu ra output trên một chân của MCU là một
xung nhịp HSE
+ Sinh viên nắm rõ nắm rõ viết một chương trình cấu hình đầu ra output trên
chân của MCU
129
Bước 2: Định nghĩa địa chỉ cơ bản cho ngoại vi clock RCC, địa chỉ offset của
thanh ghi cấu hình, điều khiển RCC và địa chỉ cơ bản của ngoại vi GPIOA
như sau:
#define
RCC_BASE_ADDR
#define
0x40023800UL
RCC_CFGR_REG_OFFSE
0x08UL
T
0x00UL
#define
(RCC_BASE_ADDR +
RCC_CR_REG_OFFSET
RCC_CFGR_REG_OFFSET)
#define
(RCC_BASE_ADDR +
RCC_CFGR_REG_ADDR
RCC_CR_REG_OFFSET )
#define
0x40020000UL
RCC_CR_REG_ADDR
#define
GPIOA_BASE_ADDR
Bước 3: Khai báo biến con trỏ kiểu dữ liệu uint32_t trỏ đến địa chỉ thanh ghi
cấu hình CFGR và thanh ghi điều khiển CR như sau:
+ uint32_t *pRccCrReg = (uint32_t*)RCC_CR_REG_ADDR;
+ uint32_t *pRccCfgrReg = (uint32_t*) RCC_CFGR_REG_ADDR;
Bước 4: Cho phép xung clock HSE hoạt động bằng cách sử dụng bit HSEON
của thanh ghi điều khiển CR
*pRccCrReg |= ( 1 << 16);
130
Bước 5: Đợi cho đến khi xung clock HSE từ bộ động thạch anh ổn định (chỉ khi
bộ dao động thạch anh được kết nối)
while( ! (*pRccCrReg & ( 1 << 17) ) )
Bước 6: Chuyển xung nhịp của hệ thống System Clock sang nguồn cấp HSE
*pRccCfgrReg |= ( 1 << 0)
Bước 7: Cấu hình các trường bit RCC_CFGR MCO1 để chọn HSE làm nguồn
cấp xung clock
*pRccCfgrReg |= ( 1 << 22); //clear 21 and SET 22
Bước 8: Cài đặt hệ số chia prescaler cho đầu ra MCO1 là 4
*pRccCfgrReg |= ( 1 << 25);

*pRccCfgrReg |= ( 1 << 26);
Bước 9: Cài đặt chân PA8 ở chế độ alternate function để hoạt động như tín
hiệu MCO1.
+ Cấp xung clock hoạt động cho PORT A như sau:
uint32_t *pRCCAhb1Enr = (uint32_t*)(RCC_BASE_ADDR + 0x30);

*pRCCAhb1Enr |= ( 1 << 0); // Enable GPIOA peripheral clock
+ Cài đặt chế độ của chân PA8 làm chức năng alternate function.
uint32_t *pGPIOAModeReg = (uint32_t*)(GPIOA_BASE_ADDR + 00);
*pGPIOAModeReg &= ~( 0x3 << 16); //clear
*pGPIOAModeReg |= ( 0x2 << 16); //set
+ Cài đặt thanh ghi alternation function ở chế độ 0 tương ứng với chân
PA8
131
uint32_t *pGPIOAAltFunHighReg = (uint32_t*)(GPIOA_BASE_ADDR +
0x24);
*pGPIOAAltFunHighReg &= ~( 0x0f << 0);
132
Bài 7: Thực hành cấu hình vào ra trạng thái trên các chân GPIO Led
Viết chương trình đảo trạng thái đầu ra của Led trên Board STM32F4 khi nút ấn
trên Board được nhấn.
+ Sinh viên nắm rõ cách thức cấu hình vào ra trạng thái trên các chân GPIO
Led, truyền nhận dữ liệu giữa GPIO và MCU trên Kit mở rộng
Bước 2: Thêm các thư viện "stm32f401re gpio.h", "stm32f401re_rcc.h"

bằng câu lệnh #include.
133
Bước 3: Định nghĩa các macro với tên gọi dễ nhớ giúp bạn dễ dàng trong khi
bạn viết chương trình.
Bước 4: Cấu hình chân PA5 của led trên Board STM32 ở chế độ output.
+ Khai báo biến thuộc kiểu dữ liệu struct GPIO.
+ Cấp xung clock hoạt động cho Port A.
+Chọn chân sử dụng với chức năng điều khiển Led.
+ Chọn chân điều khiển led ở chế độ Output.
+ Tốc độ xử lý trên chân là 50MHz.
+ Chọn chế độ là đẩy kéo Push Pull.
+ Trạng thái ban đầu trên chân là kéo xuống GND Pull Down.
+ Khởi tạo tất cả các giá trị bên trên bằng cách sử dụng hàm GPIO_Init với
đối số truyền vào là GPIOA và GPIO_InitStructure.
134
Bước 5: Cấu hình chân PC13 của nút nhấn trên Board STM32F401 ở chế độ
input.
+ Khai báo biến thuộc kiểu dữ liệu struct GPIO.● Cấp xung clock cho Port C.
+ Chọn chân sử dụng làm chức năng nút ấn.
+ Chọn chế độ trên chân GPIO là Input.
+ Tốc độ xử lý là 50MHz
+ Trạng thái Kéo trở lên dương nguồn Pull Up.
đối số truyền vào là GPIOC và GPIO_InitStructure.
135
Bước 6: Xây dựng hàm điều khiển Led với tham số truyền vào là GPIO nào và
chân được kết nối để điều khiển led:
+ Khi muốn bật led cần ghi mức logic 1 vào bit tương ứng của thanh ghi
BSRRL.
+ Khi muốn tắt led cần ghi mức logic 1 vào bit tương ứng của thanh ghi
BSRRH.
136
Bước 7: Xây dựng hàm đọc giá trị nút ấn:
+ Muốn đọc trạng thái nút ấn cần dịch bit tương ứng với nút ấn trong thanh
ghi IDR về bit số 0.
+ Sau đó sử dụng phép toán tử (AND) nhân giá trị sau khi dịch với 0x01 để
đọc giá trị trên chân làm chức năng nút ấn
Bước 8: Trong hàm while(1), thực hiện thuật toán đảo trạng thái led khi được
ấn nút.
Chú ý: Tạo và sử dụng thêm hàm Delay để chống rung nút ấn
137
Bài 8: Thực hành cấu hình vào ra trạng thái trên các chân GPIO Buzzer
Viết chương trình đảo trạng thái đầu ra của Buzzer trên Kit mở rộng khi nút
ấn trên kit được nhấn nút B5 trên Kit mở rộng STM32F401.
+ Sinh viên nắm rõ cách thức cấu hình vào ra trạng thái trên các chân GPIO
Buzzer, truyền nhận dữ liệu giữa GPIO và CPU trên Kit mở rộng
nghĩa các macro, xây dựng hàm điều khiển Buzzer, hàm đọc giá trị nút ấn, hàm
Delay để chống rung nút ấn trên phần mềm STM32CubeIDE.

138
Bước 4: Cấu hình chân PC9 của Buzzer trên Kit mở rộng STM32 ở chế độ
output:
+ Cấp xung Clock hoạt động cho Port C.
+ Chọn chân sử dụng với chức năng điều khiển Led.
139
Bước 5: Cấu hình chân B5 (PB4) của nút nhấn trên Kit mở rộng STM32 ở chế
độ Input.
+ Cấp xung Clock hoạt động cho Port B.
+ Tốc độ xử lý là 50MHz.
+ Trạng thái kéo trở lên nguồn +3.3V (Pull Up).
đối số truyền vào là GPIOB và GPIO_InitStructure.
140
Bước 6: Xây dựng hàm điều khiển Buzzer với tham số truyền vào là GPIO nào
và chân được kết nối để điều khiển led:
BSRRL.
BSRRH.
141
ấn nút.
142
Bài 9: Thực hành cấu hình vào ra trạng thái trên các chân GPIO Led Red
Viết chương trình đảo trạng thái đầu ra của Led Red trên Kit mở rộng khi nút
ấn B2 trên Kit được nhấn.
+ Sinh viên nắm rõ thao tác tạo một project tạo một project, thêm các thư viện,
định nghĩa các macro trên phần mềm STM32CubeIDE như nội dung Bài 1
+ Sinh viên nắm rõ cách thức cấu hình vào ra trạng thái trên các chân GPIO,
truyền nhận dữ liệu giữa GPIO và CPU trên Kit mở rộng
nghĩa các macro, xây dựng hàm điều khiển Led, hàm đọc giá trị nút ấn, hàm Delay

143
Bước 4: Cấu hình chân PB13 của Led_Red trên Kit mở rộng STM32 ở chế độ
output.
+ Kết nối clock cho GPIOB.
144
Bước 5: Cấu hình chân PB3 của nút nhấn B2 trên Kit mở rộng STM32 ở chế
độ input.
+ Cấp xung Clock hoạt động cho Port B.
+ Tốc độ xử lý là 50MHz.
+ Trạng thái Kéo trở lên nguồn +3.3V (Pull Up).
145
chân được kết nối để điều khiển led:
BSRRL.
BSRRH.
146
ấn nút.
147
Bài 10: Thực hành lập trình xây dựng header file cho thư viện GPIO
Viết chương trình xây dựng header file cho thư viện GPIO
+ Sinh viên nắm rõ về lập trình driver cho ngoại vi GPIO
+ Sinh viên biết được cách tạo file device header, cách viết cơ bản cho các
phân vùng ngoại vi của MCU
+ Sinh viên biết được các địa chỉ cơ bản của đường bus AHB1, APB1,
APB2, cấu trúc GPIO handle
+ Sinh viên biết được cách xây dựng các hàm cần thiết cho ngoại vi GPIO
Bước 2: Tạo header file cho GPIO
148
149
Bước 3: Bắt đầu lập trình với file header: stm32f401re_gpio.h
#include thư viện stm32f401re.h
Bước 4: Định nghĩa cấu trúc cho GPIOx
150
Bước 5: Định nghĩa GPIO_Pin
Bước 6: Định nghĩa Config GPIO mode (Viết trên vị trí của struct GPIO Init)
151
Bước 7: Định nghĩa Config GPIO Output Type (Viết trên vị trí của struct GPIO
Init)
Bước 8: Định nghĩa Config GPIO Speed (Viết trên vị trí của struct GPIO Init)
Bước 9: Định nghĩa Config GPIO Pull-up/Pull-down (Viết trên vị trí của struct
GPIO Init)
Bước 10: Định nghĩa Config GPIO Bit Set and Reset (Viết trên vị trí của struct
GPIO Init)
152
Bước 11: Định nghĩa PinSource (Viết trên vị trí của struct GPIO Init)
Vi điều khiển STM32F401RE có 15 Pin
Pin0: 0 => 0x00 (mã Hex)
Pin1: 1 => 0x01 (mã Hex)
Pin15: 15 => 0x0F (mã Hex)
153
154
Bước 12: Kết quả
Trong file.h ta sẽ khai báo các hàm nguyên mẫu cho file source để các file
khác có thể gọi và sử dụng
155
156
Bài 11: Thực hành lập trình xây dựng source file cho thư viện GPIO
Viết chương trình xây dựng source file cho GPIO
Bước 2: Tạo source file cho GPIO
157
Bước 3: Lập trình các hàm sử dụng GPIO
158
+ GPIO_Init : khởi tạo các thông số cho GPIO
+ GPIO_PinAFConfig: cấu hình chế độ alternate function
+ GPIO_DeInit: Reset lại giá trị mặc định cho GPIO
+ GPIO_ReadInputDataBit: đọc thông số từ input port,pin
+ GPIO_ReadInputData: đọc thông số từ port
+ GPIO_ReadOutputData: đọc thông số từ output port,pin
+ GPIO_SetBits: set bit trên port và pin
+ GPIO_ResetBits: reset bit trên port và pin
+ GPIO_WriteBit: set hoặc reset trên port và pin
+ GPIO_Write: ghi dữ liệu vào port
+ GPIO_ToggleBits: toggle bit trên pin
Bước 4: Include các thư viện cần thiết
159
Bước 5: Cấu hình mode cho GPIO
Reset bit trên thanh ghi MODER, sau đó mới ghi giá trị vào thanh ghi MODER
Lưu ý: pinpos * 2 vì thanh ghi MODE sử dụng 2 bit cho 1 chân
Bước 6: Cấu hình speed mode và Output mode
160
Lưu ý: SPEED và OTYPE chỉ cấu hình cho Output mode và Alternate
function.
Bước 7: Cấu hình chế độ PU/PD
Bước 8: Alternate Function Mode
161
Với chế độ Alternate Function đã được sử dụng mảng AFR[2] để lưu trữ đã
được khai báo là thành viên của struct trong file stm32f401re.h
162
Bước 9: GPIO_DeInit
Bước 10: Reset các thông số khởi tạo tại GPIO.

Sử dụng hàm RCC_AHB1PeriphResetCmd để reset các ngoại vi trên Bus
AHB1 sử dụng thanh ghi AHB1RSTR
163
Bước 11: GPIO_ReadInputDataBit
Bước 12: GPIO_ReadInputData
164
Bước 13: GPIO_ReadOutputData
Bước 14: GPIO_SetBits/ResetBits
165
Bước 15: GPIO_WriteBit and Write Bit
166
Bước 16: GPIO_ToggleBits
167
Bài 12: Thực hành lập trình xây dựng header file của MCU STM32F401RE
Viết chương trình xây dựng header file của MCU

STM32F401RE
168
Bước 2: Tải file thư viện cơ bản do ST cung cấp
Bước 3: Thêm thư viện cơ bản của stm32 vừa tải về vào project
Bước 4: Thêm các đường dẫn tới thư viện (Chọn Include, inc, Utilities).
169
Bước 5: Thêm đường dẫn đến thư viện (lib_stm) và Libraries
170
Bước 6: Theo dõi file header do nhà sản xuất cung cấp cho stm32 trong SDK
Bước 7: Các địa chỉ của bộ nhớ: FLASH, SRAM1, SRAM2, …
171
Bước 8: Địa chỉ của các Bus: AHB1, AHB2, APB1, APB2.
172
173
Bước 9: Lấy địa chỉ cơ bản rồi cộng với địa chỉ offset
Bước 10: Lấy địa chỉ các ngoại vi GPIO
174
Bước 11: Add thêm các ngoại vi trên Bus AHB1 dựa vào bảng 1 trong Reference
manual
175
Bus AHB2
Bus APB1
176
Bus APB2
177
Bước 12: Xây dựng GPIO peripheral
Định nghĩa kiểu cấu trúc cho thanh ghi GPIO
Lưu ý: NÊN sử dụng GPIO register map để lập trình
178
179
Sử dụng Mảng AFR[2] làm việc với AFRL và AFRH
Lưu ý: Khi làm việc với thanh ghi nên khai báo thanh ghi với volatile để
tránh trường hợp các biến lưu trữ giá trị thanh ghi bị thay đổi trong quá
trình tối ưu hóa (Hãy tìm hiểu về volatile nếu bạn chưa rõ).
180
Sử dụng Địa chỉ cơ bản của các PORT để làm việc với các thanh ghi
là thành viên trong struct
Bước 13: Quản lý xung Clock
Tra cứu thông tin về các thanh ghi thông qua RCC register map
181
Thông qua RCC register map viết kiểu dữ liệu struct cho thanh ghi RCC
182
Định nghĩa kiểu cấu trúc cho RCC để có thể làm việc với các thanh ghi
Cấp xung Clock ngoại vi qua Bus AHB1ENR
183
Set các bit tương ứng trong thanh ghi lên 1.
VD: GPIOD, set bit 3 lên 1 => là 0x0000 0008
184
185
Cấp xung Clock cho ngoại vi qua Bus AHB2ENR
Cấp xung Clock cho ngoại vi qua Bus APB1ENR
Cấp xung Clock cho ngoại vi qua Bus APB2ENR
186
187
Bài 13: Thực hành cài đặt và cấu hình GIT
Viết chương trình xây dựng header file của MCU

STM32F401RE
Bước 1: Vào trang web tải Git. Bạn lựa chọn mục Downloads
188
Bước 2: Bạn chọn phiên bản dành cho Windows
Bước 3: Mở file Git bạn vừa mới tải xuống chọn Run
189
Bước 4: Một cửa sổ cài đặt hiện ra bạn chọn Next
Bước 5: Lựa chọn vị trí lưu mà bạn mong muốn sau đó chọn Next
190
Bước 6: Cửa sổ tiếp theo đã có những lựa chọn mặc định cho bạn, bạn có thể
chọn thêm các mục khác theo nhu cầu bản thân. Hoặc cài đặt như bản mặc định
của nhà phát triển. Bạn chọn Next để tiếp tục cài đặt
Bước 7: Tiếp đến là lựa chọn đặt vị trí Git vào Start Menu trong mục Browse.
Bạn có thể chọn Don't create a Start Menu folder nếu không muốn tạo ra thư
191
mục của Git trên Start Menu hoặc bạn cũng có thể để mặc định, sau đó chọn
Next
Bước 8: Tiếp đến chương trình sẽ yêu cầu bạn lựa chọn một chương trình
soạn thảo để biên tập lệnh cho Git bash. Có rất nhiều chương trình khác nhau
để bạn lựa chọn, nhưng nếu sử dụng Win 10, bạn nên để trình mặc định Vim
mà phần mềm đã chọn sẵn, sau đó bạn chọn Next để tiếp tục cài đặt
192
Bước 9: Tiếp theo, phần cài đặt Git yêu cầu bạn lựa chọn cài đặt về biến môi
trường. Khi cài trên Windows 10 bạn nên sử dụng lựa chọn mặc định Git from
the command line and also from 3rd-party software (Git từ dòng lệnh và cả
từ phần mềm của bên thứ ba). Sau đó chọn Next
+ Nếu không cần dùng biến Path để là môi trường mặc định cho Git thì bạn
có thể lựa chọn Use Git from Git Bash only (chỉ sử dụng Git từ Git
Bash)
+ Hoặc chọn Use Git and optional Unix tools from the Command
Prompt nếu muốn sử dụng Git và các công cụ Unix tùy chọn từ
Command Prompt
193
Bước 10: Tiếp theo là lựa chọn phương thức bảo mật. Bạn có thể lựa chọn
phương thức mình mong muốn nhưng tốt nhất là nên giữ lại lựa chọn mặc định
là Use the OpenSSL library (sử dụng thư viện OpenSSL) của phần mềm.
Chọn Next để tiến hành bước tiếp theo.
Bạn có thể chọn Use the native Window Secure Channel library để sử dụng
thư viện gốc Window Secure Channel làm phương thức bảo mật
Tuy nhiên để có giao diện tiếng Việt đẹp mắt và dễ dàng sử dụng, thao tác
chúng ta nên giữ nguyên mục Use MinTTY the default terminal of MSYS2
(sử dụng MinTTY thiết bị mặc định của MSYS2). Sau đó chọn Next
194
Bước 11: Tiếp đến bạn sẽ lựa chọn hành vi mặc định của git. Bạn để nguyên
lựa chọn mặc định là Default (fast- forward or merge) là chế độ mặc định của
phần mềm. Chọn Next.
Bạn cũng có thể lựa chọn các mục khác như:
+ Rebase
+ Only ever fast- forward chỉ sử dụng fast- forward
195
Bước 12: Chọn mục trợ giúp chứng chỉ, để nguyên lựa chọn mặc định là Git
credential Manager (Trình quản lý thông tin xác thực Git). Sau đó chọn Next.
Bạn cũng có thể lựa chọn các mục khác như:
+ None: Không cần
+ Git credential Manager Core: Trình quản lý thông tin xác thực Git Core
196
Bước 13 : Tiếp đến bạn sẽ lựa lựa chọn cấu hình tùy chọn bổ sung, bạn để
mặc định là Enable file system caching. Chọn Next.
+ Enable file system caching (tạo bộ nhớ đệm hệ thống tệp)
+ Enable symbolic links (bật liên kết tượng trưng)
Bước 14: Cuối cùng bạn lựa chọn Install để kết thúc quá trình cài đặt. Bạn có
thể chọn Enable experimental support for pseudo consoles (bật hỗ trợ thử
nghiệm cho bảng điều khiển giả)
197
Bước 15: Cuối cùng bạn sẽ có 2 mục để bạn lựa chọn:
+ Mục Launch Git Bash: để mở cửa sổ dòng lệnh của Git lên ngay sau đó.
+ Mục View Release Notes: để xem ghi chú về các thay đổi của phiên bản
này so với các phiên bản trước đó.
Các bạn có thể lựa chọn tùy theo nhu cầu của bản thân. Và chọn Finish để
hoàn tất cài đặt.
198
Bước 16: Mở cửa sổ Git Bash: Click phải chuột -> chọn Git Bash Here
Sử dụng câu lệnh git version để kiểm tra xem git được cài đặt chưa
199
Bước 17: Cấu hình Git
Enable experimental,built-in add-i-p
Việc đầu tiên bạn nên làm khi cấu hình Git là chỉ định tên tài khoản và địa chỉ
email. Điều này rất quan trọng vì những thông tin này sẽ được sử dụng xuyên
suốt trong tất cả quá trình sau này của bạn.
Để cài đặt tên người sử dụng, sử dụng lệnh git config --global user.name "{Tên}"
Để cài đặt email người sử dụng, sử dụng lệnh git config --global user.email "{Địa
chỉ email}"
Xem thông tin cấu hình
+ git config –list
200
+ git config X (X là tên thuộc tính cần xem giá trị cấu hình)
Xem các thông số của câu lệnh X nào đó
+ git help X
+ git X –help
+ man git-x
201
Bài 14: Thực hành lập trình thư viện GIT
Viết chương trình lập trình thư viện GIT
macro trên phần mềm GIT
+ Sinh viên nắm rõ về lập trình lập trình thư viện GIT
Bước 1: Cài đặt và cấu hình Git như nội dung Bài 13.
Bước 2: Mở git Bash trong thư mục muốn sử dụng Git
202
Bước 3: Sử dụng câu lệnh: git init để khởi tạo Local Repository
Bước 4: Sử dụng câu lệnh git status để kiểm tra trạng thái các thư mục, tệp
tin trong Repository
Bước 5: Khởi tạo một thư mục file.txt
203
Có một file.txt ở trạng thái Untracked
Bước 6: Sử dụng câu lệnh git add file.txt để đưa file.txt vào vùng Staging
Area
204
Sau đó dùng git status để kiểm tra. Chữ màu xanh => File đã vào vùng
Staging Area và đợi Commit
Lưu ý: Nếu muốn đưa tất cả các file vào vùng Staging Area thì sử dụng câu
lệnh: git add .
Bước 7: Sử dụng câu lệnh git commit -m ‘content’ để đưa các file ở vùng
Staging Area lên Local Repository
Sử dụng câu lệnh git status để kiểm tra
file.txt đã được đưa vào local repository thành công.

Lưu ý: Nếu bạn chỉnh sửa nội dung trong file.txt
205
Sử dụng câu lệnh git status thấy được file.txt đang ở trạng thái bị thay đổi
Bước 8: Xóa File ra khỏi vùng Staging
+ Tạo file report.txt
+ git status
+ git add .
+ git status
+ Sử dụng câu lệnh git reset HEAD report.txt Hoặc git rm --cached
report.txt.
+ git status
206
+ Sử dụng .gitignore để không theo dõi các tập tin được chỉ định (Từ một số
file được thêm vào vùng Staged)
+ Nếu có một số tập tin bạn không muốn Commit hay không muốn đưa vào
Staging Area thì nên sử dụng gitignore
+ Tạo file .gitignore
+ Sử dụng câu lệnh: touch .gitignore để tạo .gitignore
+Tạo 2 file content1.txt và content2 không muốn commit:

Sử dụng git status để kiểm tra
207
Thêm nội dung vào file .gitignore
Không còn 2 file content1 và content2 xuất hiện trong màn hình console
Bước 9: Tạo Repository trên Github
208
Sử dụng câu lệnh này để thêm Remote Repository
209
Bước 10: Đẩy Local Repository lên Remote Repository
Sau đó đẩy lên Remote Repository
Đã xuất hiện trên Remote Repository => Thành công
210
git branch: xem các branch và branch hiện tại
git checkout -b <name> tạo một branch mới
git checkout <branch> đổi sang branch
git branch -D <branch> (delete a branch)
211
Nếu bạn muốn có một bản sao của một kho chứa Git có sẵn, có thể là một dự
án mà bạn tham gia – thì bạn hãy thực hiện clone.
212
Bài 15: Thực hành debug chương trình cấu hình GPIO
Thực hành debug chương trình cấu hình GPIO
+ Sinh viên nắm rõ về debug chương trình cấu hình GPIO
Bước 2: Sử dụng tính năng debug thông qua STLink
213
Bước 3: Cắm kết nối kit với máy tính. Biên dịch chương trình và đảm bảo
chương trình không có lỗi
214
Bước 4: Lựa chọn Switch: Chuyển đổi sang giao diện Debug
Bước 5: Điều khiển thực thi chương trình
+ Khi mới khởi động giao diện debug thì chương trình dừng lại tại hàm
đầu tiên tiên trong hàm main.
+ Chương trình đang dừng ở câu lệnh nào thì câu lệnh đó chưa được thực
hiện
215
216
217
Bước 6: Xem giá trị các biến
Mở cửa sổ Live Expressions để theo dõi giá trị các biến trong quá trình Debug
218
+ Biến toàn cục (ví dụ biến globalVariable): Gõ tên biến toàn cục vào cửa
sổ Live Expressions trước khi thực thi các lệnh hoặc bất cứ khi nào trong quá trình
debug
+ Biến địa phương(ví dụ biến localVariable): Gõ tên biến địa phương vào
cửa sổ Live Expressions khi chương trình đã nhảy vào hàm chứa biến cục bộ đó
Lưu ý: Biến địa phương sẽ chỉ theo dõi được khi còn ở trong hàm của nó. Khi
thoát khỏi hàm thì biến địa phương sẽ được giải phóng, không thấy giá trị của
biến trong bảng Live Expressions
Bước 7: Xem các giá trị các thanh ghi
Lựa chọn Window => Show View => Register.

Mở cửa sổ Registers để xem các giá trị thanh ghi trong CPU
219
Lựa chọn Window => Show View => SFRs.
Mở cửa sổ SFRs để xem các thanh ghi ngoại vi
LED GREEN (GPIOA, Pin0) được bật lên tương ứng bởi Bit 0 trên thanh ghi ODR
được set lên 1
Lưu ý:
220
+ Giá trị thanh ghi sẽ được cập nhật mỗi khi dừng lại tại Breakpoint.
+ Nhấn vào RD (Force read selected register) để yêu cầu cập nhật
giá trị mới nhất của thanh ghi nếu không đặt Breakpoint.
Xem các thanh ghi được cập nhật tự động thông qua cửa sổ Live
Expressions
221
Bài 16: Thực hành cấu hình ngắt ngoài cho nút nhấn trên Board STM32F4
Viết chương trình cấu hình ngắt ngoài cho nút nhấn trên Board STM32F401
Nucleo. Khi có ngắt xảy ra trên chân PC13 thì led trên chân PA5 sẽ được bật và sau
đó sẽ trở lại trạng thái tắt như ban đầu.

222
Bước 2: Thêm các thư viện cần thiết như "stm32f401re_rcc.h",
"stm32f401re_gpio.h", "misc.h", "stm32f4xx_exti.h", "stm32f4xx_syscfg.h"
bằng câu lệnh #include
Bước 3: Cấu hình chân PA5 của led trên Board STM32 ở chế độ output
Khai báo biến thuộc kiểu dữ liệu struct GPIO
+ Cấp clock cho Port A.
đối số truyền vào là GPIOA và GPIO_InitStructure
Bước 4: Xây dựng hàm Interruppt_Init cấu hình cho phép ngắt khi nút ấn kết
nối với chân PC13 khi được ấn như sau
223
4.1. Khai báo các biến thuộc kiểu dữ liệu cấu trúc của GPIO, EXTI và
NVIC
4.2. Khởi tạo chân GPIO PC13
+ Cấp clock cho Port C.
+ Chọn chế độ trên chân PC13 là Input.
+ Chọn tốc tốc trên chân PC13 là 50MHz.
+ Chọn chế độ kéo trở lên dương nguồn Pull Up.
+ Chọn chân để sử dụng là PC13
+ Sử dụng hàm GPIO_Init với đối số là GPIOC, &GPIO_InitStructure
4.3. Cấu hình sử dụng Line ngắt 13
+ Cấp clock cho ngoại vi Syscfg.
+ Sử dụng hàm SYSCFG_EXTILineConfig với tham số truyền vào là ngắt.

ở GPIO nào và Line ngắt nào để kết nối Line ngắt 3 với PC13.
224
4.4. Cấu hình sử dụng ngắt
+ Khởi tạo Line13 được sử dụng chức năng ngắt.
+ Chọn chế độ ngắt.
+ Chọn sườn xuống phát hiện sự kiện ngắt Falling.
+ Cho phép ngắt được hoạt động.
+ Sử dụng hàm EXTI_Init để khởi tạo tất cả các giá trị ở trên với đối số là
&EXTI_InitStructure
4.5. Cấu hình trình phục vụ ngắt NVIC.
+ Sử dụng trình phục vụ ngắt EXTI15_10_IRQn.
+ Cấu hình ưu tiên ngắt PreemptionPriority mức 0.
+ Cấu hình ưu tiên ngắt SubPriority mức 0.
+ Cho phép sử dụng trình phục vụ ngắt.
+ Sử dụng hàm NVIC_Init để cấu hình các giá trị ở trên với đối số là
&NVIC_InitStructure
225
Bước 5: Khai báo hàm phục vụ ngắt trên chân PC13 như sau
+ EXTI_GetFlagStatus(EXTI_Line13) kiểm tra sự kiện ngắt có đúng trên

chân PC13 hay không.
+ EXTI_ClearITPendingBit(EXTI_Line13) xóa cờ ngắt sau khi thực hiện

xong chương trình ngắt.
Bước 6: Xây dựng hàm LedControl_SetStatus
Bước 7: Trước hàm while(1), sử dụng các hàm
+ SystemCoreClockUpdate
+ Led_Init
+ Interruppt_Init
Bước 8: Trong hàm while(1), sử dụng biến Status và hàm

LedControl_SetStatus để thực hiện yêu cầu đề bài
226
227
Bài 17: Thực hành cấu hình ngắt ngoài cho nút nhấn trên Kit mở rộng
Viết chương trình cấu hình ngắt ngoài cho nút nhấn trên Kit mở rộng. Khi ấn
nút B2 trên kit mở rộng thì Led Green trên kit mở rộng sẽ đảo trạng thái sau đó Led
sẽ quay về trạng thái ban đầu.

228
"stm32f401re_gpio.h", "misc.h", "stm32f401re_exti.h",
"stm32f401re_syscfg.h" bằng câu lệnh #include
Bước 3: Cấu hình chân PA0 của led trên Kit STM32 ở chế độ output
+ Cấp xung clock cho PortA.
Bước 4: Xây dựng hàm Interruppt_Init cấu hình cho phép ngắt khi nút nhấn
kết nối với chân B2 trên Kit STM32F401
229
4.1. Khai báo các biến thuộc kiểu dữ liệu cấu trúc của GPIO, EXTI và
NVIC
4.2. Khởi tạo chân GPIO PB3
+ Cấp clock cho GPIOB.
+ Chọn chế độ trên chân PB3 là Input.
+ Chọn tốc tốc trên chân PB3 là 50MHz.
+ Chọn chế độ kéo trở lên dương nguồn Pull Up.
+ Chọn chân để sử dụng là PB3
+ Sử dụng hàm GPIO_Init với đối số là GPIOB, &GPIO_InitStructure
4.3. Cấu hình sử dụng Line ngắt 3
+ Cấp clock cho ngoại vi Syscfg.
+ Sử dụng hàm SYSCFG_EXTILineConfig với tham số truyền vào là ngắt.

ở GPIO nào và Line ngắt nào để kết nối Line ngắt 3 của nút B2
230
4.4. Cấu hình sử dụng ngắt
+ Khởi tạo Line3 được sử dụng chức năng ngắt.
+ Chọn chế độ ngắt.
+ Chọn sườn xuống phát hiện sự kiện ngắt Falling.
+ Cho phép ngắt được hoạt động.
+ Sử dụng hàm EXTI_Init để khởi tạo tất cả các giá trị ở trên với đối số là
&EXTI_InitStructure.
4.5. Cấu hình trình phục vụ ngắt NVIC
+ Sử dụng trình phục vụ ngắt EXTI3_IRQn.
+ Cấu hình ưu tiên ngắt PreemptionPriority mức 0.
+ Cấu hình ưu tiên ngắt SubPriority mức 0.
+ Cho phép sử dụng trình phục vụ ngắt.
+ Sử dụng hàm NVIC_Init để cấu hình các giá trị ở trên với đối số là
&NVIC_InitStructure.
Bước 5: Khai báo hàm phục vụ ngắt trên chân PB4 như sau
231
EXTI_ClearITPendingBit(EXTI_Line3) xóa cờ ngắt sau khi thực hiện
Bước 6: Xây dựng hàm LedControl_SetStatus
Bước 7: Trước hàm while(1), sử dụng các hàm
+ Led_Init
+ Interruppt_Init
Bước 8: Trong hàm while(1),sử dụng biến Status và hàm LedControl_SetStatus

để thực hiện yêu cầu đề bài
232
233
Bài 18: Thực hành truyền và nhận dữ liệu với ngoại vi SPI
Viết chương trình truyền dữ liệu có giá trị là 0xB1 từ SPI Master sang SPI
Slave sử dụng của STM32F401RE. Nhấn nút PC13 để gửi dữ liệu từ SPI2 => SPI1.
Nếu dữ liệu nhận được từ SPI Slave trùng với dữ liệu được truyền đi từ SPI Master
thì Led Green trên Kit (PA5) sẽ bật tắt 5 lần rồi trở lại trạng thái ban đầu.
+ Sinh viên nắm rõ về lập trình driver cho ngoại vi SPI
+ Sinh viên biết được cách truyền và nhận dữ liệu với ngoại vi SPI
234
Bước 2: Kết nối phần cứng giữa ngoại vi SPI1 (Slave) và SPI2 (Master) trên
Board STM32 với nhau như sau:
+ SCK : PB3 - PB13
+ MISO : PA6 - PB14
+ MOSI : PA7 - PB15
+ NSS : PA4 - PB12
Lưu ý: Khi thực hiện bài này phải tháo kit mở rộng ra chỉ sử dụng board
Nucleo-F401RE

"stm32f401re_gpio.h", "stm32f401re_spi.h", "misc.h" bằng câu lệnh #include
235
Bước 4: Khai báo các Macro giúp quá trình lập trình dễ dàng hơn
Bước 5: Xây dựng hàm khởi tạo sử dụng SPI2 với chế độ Master:
5.1. Khai báo các kiểu dữ liệu thuộc kiểu cấu trúc GPIO, SPI.
236
5.2. Khởi tạo các chân GPIO với chức năng của các chân SS, SCK, MISO,
MOSI
+ Cho phép cấp clock cho các chân sử dụng với chức năng SPI
+ Chọn chế độ các chân GPIO là Alternate Function.
+ Chọn tốc độ trên chân GPIO là 50MHz.
+ Chọn chế độ điều khiển trên chân là đẩy kéo Push Pull.
+ Chọn các chân trên vi điều khiển làm chức năng SPI.
+ Sử dụng hàm GPIO_Init với tham số truyền vào là GPIO nào, biến dữ
liệu thuộc kiểu dữ liệu Struct GPIO để cài đặt các tham số đã được gắn ở trên.
+ Sử dụng hàm GPIO_PinAFConfig cài đặt các chân GPIO với chức năng
Alternate Function với đối số truyền vào là GPIO nào, chân được sử dụng với chức
năng Alternate Function và chân GPIO thuộc AF mấy.
+ Khởi tạo chân NSS_Master ở chế độ Output.
+ Tốc độ trên chân là 50MHz
+ Chế độ điều khiển trên GPIO là đẩy kéo Push Pull.
+ Trạng thái ban đầu là kéo trở lên Pull Up.
237
5.3. Khởi tạo sử dụng ngoại vi SPI với chế độ Master:
+ Cho phép cấp clock cho ngoại vi SPI.
+ Chọn chế độ truyền là song công.
+ Chọn chế cho SPI là Master.
+ Chọn khung truyền dữ liệu là 8 bit.
+ Chọn cực tính xung trên chân SCK là ở mức thấp (CPOL).
+ Chọn pha đồng hồ là chế độ 1 (CPHA).
+ Chọn chân SS được điều khiển bởi phần mềm.
+ Chọn hệ số chia tần sử dụng trên chân SCK là 4.
+ Chọn bit truyền đầu tiên là bit thấp.
+ Sử dụng hàm SPI_Init với tham số truyền vào là SPI nào và biến dữ liệu
kiểu struct SPI để cài đặt các giá trị đã được khởi tạo bên trên.
238
+ Sử dụng hàm SPI_Cmd với tham số truyền vào là SPI đang sử dụng và
trạng thái kết nối để sử dụng SPI.
Bước 6: Xây dựng hàm khởi tạo sử dụng SPI1 ở chế độ Slave
6.1. Khai báo các kiểu dữ liệu thuộc kiểu cấu trúc GPIO, SPI, NVIC.
6.2. Khởi tạo các chân GPIO với chức năng của các chân SS, SCK, MISO,
MOSI
+ Cho phép cấp clock cho các chân sử dụng với chức năng SPI
+ Chọn chế độ các chân GPIO là Alternate Function.
+ Chọn tốc độ trên chân GPIO là 50MHz.
239
+ Chọn chế độ điều khiển trên chân là đẩy kéo Push Pull.
+ Chọn các chân trên vi điều khiển làm chức năng SPI.
+ Sử dụng hàm GPIO_Init với tham số truyền vào là GPIO nào, biến dữ liệu
thuộc kiểu dữ liệu Struct GPIO để cài đặt các tham số đã được gắn ở trên.
+ Sử dụng hàm GPIO_PinAFConfig cài đặt các chân GPIO với chức năng
Alternate Function với đối số truyền vào là GPIO nào, chân được sử dụng
với chức năng Alternate Function và chân GPIO thuộc AF mấy.
+ Khởi tạo chân NSS_Slave ở chế độ Input.
+ Tốc độ trên chân GPIO là 50MHz.
+ Trạng thái ban đầu là kéo trở lên Pull Up.
240
6.3. Khởi tạo sử dụng ngoại vi SPI với chế độ Slave:
+ Cấp xung clock cho ngoại vi SPI.
+ Chọn chế độ truyền là song công.
+ Chọn chế cho SPI là Slave.

241
+ Chọn khung truyền dữ liệu là 8 bit.
+ Chọn cực tính xung trên chân SCK là ở mức thấp (CPOL).
+ Chọn pha đồng hồ là chế độ 1 (CPHA).
+ Chọn chân SS được điều khiển bởi phần mềm.
+ Chọn hệ số chia tần sử dụng trên chân SCK là 4.
+ Sử dụng hàm SPI_Init với tham số truyền vào là SPI nào và biến dữ liệu
kiểu struct SPI để cài đặt các giá trị đã được khởi tạo bên trên.
+ Sử dụng hàm SPI_Cmd với tham số truyền vào là SPI đang sử dụng và
trạng thái kết nối để sử dụng SPI
242
6.4. Cấu hình sử dụng ngắt khi SPI Slave nhận được dữ liệu từ SPI Master.
+ Cấu hình sử dụng trình phục vụ ngắt NVIC cho SPI Slave.
+ Chọn mức ưu tiên ngắt PreemptionPriority là 0.
+ Chọn mức ưu tiên ngắt SubPriority là 0.
+ Cho phép trình phục vụ ngắt hoạt động.
+ Sử dụng hàm NVIC_Init để cài đặt các giá trị đã được khởi tạo ở trên.
+ Sử dụng hàm SPI_ITConfig với tham số truyền vào là SPI Slave sử dụng
ngắt, trạng thái xảy ra sự kiện ngắt, trạng thái kết nối.
Bước 7: Xây dựng hàm truyền dữ liệu từ SPI Master với tham số truyền vào là
dữ liệu cần truyền
+ Kéo chân NSS xuống GND cho phép truyền dữ liệu.
+ Sử dụng hàm SPI_I2S_SendData để truyền dữ liệu.
+ Sử dụng hàm SPI_I2S_GetFlagStatus chờ cho đến khi dữ liệu truyền xong.
+ Kéo chân NSS lên mức cao khi đã truyền xong dữ liệu.
243
Bước 8: Xây dựng hàm nhận dữ liệu từ SPI Master với tham số là SPI ở chế độ
Slave
EXTI_ClearITPendingBit(EXTI_Line3) xóa cờ ngắt sau khi thực hiện

Bước 9: Sử dụng hàm SPI1_IRQHandler nhận dữ liệu khi SPI Slave nhận được
dữ liệu từ SPI Master
Trong hàm phục vụ ngắt, gán biến nhận dữ liệu với hàm Revice_Data để thực hiện
nhiệm vụ bật tắt Led.
244
Bước 10: Xây dựng hàm cấu hình chân PA0 của led trên Board STM32 ở chế
độ Output
Bước 11: Xây dựng hàm cấu hình chân PC13 của nút nhấn trên Board
STM32F401
245
Bước 12: Trong hàm main, trước hàm while (1) gọi các hàm:
+ System Core Clock Update
+ Button_Init
+ Led_Init
+ SPI_InitMaste
+ SPI_InitSlave
Bước 13: Trong hàm While(1), xây dựng thuật toán khi ấn nút truyền thì truyền
dữ liệu, nếu dữ liệu nhận đúng với dữ liệu gửi thì Led trên kit nháy 5 lần rồi
trở về trạng thái ban đầu và sử dụng các hàm sau:
246
247
248
stm32f041re_spi.h
Viết chương trình lập trình thư viện cho ngoại vi SPI: tạo file stm32f041re_spi.h
+ Sinh viên biết được cách xây dựng các hàm cần thiết cho ngoại vi SPI
+ Sinh viên biết được cách lập trình thư viện cho ngoại vi SPI: tạo file
stm32f041re_spi.h
249
Bước 2: Tạo file.h cho ngoại vi SPI:
+ stm32f041re_spi.h
Bước 3: Include Device Header file
Bước 4: Định nghĩa struct cho ngoại vi SPI
250
Bước 5: Define các thông số cho SPI
Direction
251
Mode
Data Size
CPOL
CPHA
252
BaudRate_Prescaler
Lưu ý: Khi lập trình thư viện phải sử dụng tài liệu Reference Manual để
theo dõi lấy thông tin lập trình
MSB_LSB
253
DMA
NSS Internal Software Management
CRC Transmit or Receive
Direction: Transmit or Receive
254
SPI Interrupt
SPI Flags
CRC polynomial
255
Bước 6: Khai báo các hàm nguyên mẫu
256
stm32f401re_spi.c
Viết chương trình truyền lập trình thư viện cho ngoại vi SPI: tạo file
stm32f401re_spi.c
+ Sinh viên biết được cách xây dựng các hàm cần thiết cho ngoại vi SPI
+ Sinh viên biết được cách lập trình thư viện cho ngoại vi SPI: tạo file
stm32f041re_spi.c

257
Bước 2: Tạo file.c cho ngoại vi SPI:
+ stm32f401re_spi.c
Bước 3: #include thư viện và và define
Một số hàm quan trọng sử dụng cho ngoại vi SPI
3.1. SPI_Init: Khởi tạo SPI
258
3.2. SPI_Cmd: Cho phép sử dụng SPIx
259
3.3. SPI_DataSizeConfig: Cấu hình kích thước dữ liệu
260
3.4. SPI_BiDirectionalLineConfig: Lựa chọn chế độ chỉ truyền hay
chỉ nhận
3.5. SPI_NSSInternalSoftwareConfig: Cấu hình chân NSS bằng

phần mềm cho SPI đã chọn
261
3.6. Hàm trả về dữ liệu nhận được từ ngoại vi SPIx
3.7. Hàm truyền dữ liệu qua ngoại vi SPI
262
3.8. Một số hàm sử dụng CRC kiểm tra và phát hiện lỗi
Cyclic Redundancy Check thường viết tắt là CRC, là thuật ngữ tiếng Anh
trong kỹ thuật số, là phương pháp kiểm tra và phát hiện lỗi, được sử
dụng trong các mạng số và thiết bị lưu trữ để phát hiện sự thay đổi tình cờ
đối với dữ liệu được truyền đi hay lưu trữ
263
264
3.9. SPI DMA
Direct memory access là cơ chế của hệ thống máy tính cho phép một
thành phần phần cứng truy cập đến bộ nhớ dữ liệu chính một cách độc lập
với CPU
265
Bước 4: Sử dụng ngắt với SPI
4.1. SPI_ITConfig: Cấu hình ngắt cho SPI
266
4.2. SPI_GetFlagStatus: Kiểm tra cờ của SPI
267
4.3. SPI_ClearFlag: Xóa cờ
268
4.4. SPI_GetITStatus: Kiểm tra cờ ngắt của SPI
269
4.5. SPI_ClearITPendingBit: Xóa cờ ngắt của SPI
270
271
Bài 21: Thực hành truyền và nhận dữ liệu với ngoại vi I2C
Viết chương trình giao tiếp giữa hai ngoại vi I2C1 và I2C3 trên vi điều khiển
STM32F401RE khi nhấn nút USER trên Board STM32F401 thì dữ liệu sẽ được
truyền từ I2C3 đến I2C1 và dữ liệu sẽ được kiểm tra. Nếu dữ liệu truyền và nhận là
trùng khớp thì Led LD2 trên Board sẽ nhấp nháy 5 lần rồi trở lại trạng thái ban đầu.
+ Sinh viên nắm rõ về lập trình driver cho ngoại vi I2C
+ Sinh viên biết được truyền và nhận dữ liệu với ngoại vi I2C
+ Sinh viên biết được cách xây dựng các hàm cần thiết cho ngoại vi I2C

272
Bước 2: Kết nối phần cứng giữa ngoại vi I2C1 (Slave) và I2C3 (Master) trên
Board STM32 với nhau như hình dưới đây
SCL : PB8 - PA8
SDA : PB9 - PC9
Lưu ý: Sử dụng thêm phần cứng là điện trở 10K (nếu có) và kết nối như
trong hình ảnh dưới đây. Nếu không có thì bạn có thể sử dụng điện trở nội
bên trong chip như hướng dẫn dưới đây.
"stm32f401re_gpio.h", "stm32f401re_i2c.h", "misc.h" bằng câu lệnh #include.
Bước 4: Khai báo các macro giúp quá trình lập trình dễ dàng hơn
273
Bước 5: Xây dựng hàm khởi tạo sử dụng I2C3
5.1. Khai báo dữ liệu thuộc kiểu dữ liệu cấu trúc của GPIO và I2C đã được
định nghĩa trong file thư viện header stm32f401re_gpio.h và
stm32f401re_i2c.h
5.2. Cấu hình GPIO được dùng làm chân SCL và SDA.
+ Cấp xung clock cho ngoại vi GPIOA và GPIOC.
+ Chọn chế độ trên 2 chân chọn làm SDA và SCL Alternate Function.
+ Chọn tốc độ trên 2 chân được sử dụng là 50MHz.
+ Chọn chế độ điều khiển trên 2 chân là Open drain.
+ Chọn trạng thái trở trên hai 2 chân là trạng thái trở treo lên PULL_UP.
274
+ Sử dụng chân PA8 là chân SCL và PC9 là chân SDA.
+ Sử dụng hàm GPIO_Init với tham số truyền vào là GPIO đang được sử
dụng và biến thuộc kiểu cấu trúc GPIO để cấu hình các giá trị được khởi
tạo bên trên cho 2 chân PA8 và PC9.
+ Sử dụng hàm GPIO_PinAFConfig với đối số truyền vào là GPIO đang

được sử dụng, chân GPIO có chức năng AF và vị trí chân GPIO sử dụng
với chức năng I2C ở Alternate Function nào.
5.3. Cấu hình sử dụng I2C3
+ Cấp clock cho I2C3 hoạt động.
+ Sử dụng tần số trên chân SCL là 400KHz.
+ Chọn chế độ là có thể truyền và nhận dữ liệu.
+ Chu kì xung thấp chia xung cao trên chân SCL là 2.
+ Địa chỉ của I2C là 0.
+ Cho phép sử dụng bit ACK.
275
+ Sử dụng 7 bit địa chỉ.
+ Sử dụng hàm I2C_Init với tham số truyền vào là I2C đang sử dụng và
biến thuộc kiểu cấu trúc I2C để cấu hình các giá trị đã khởi tạo bên trên
của I2C.
+ Sử dụng hàm I2C_Cmd để cho phép I2C hoạt động.
Bước 6: Xây dựng hàm khởi tạo sử dụng I2C1
6.1. Khai báo dữ liệu thuộc kiểu dữ liệu cấu trúc của GPIO và I2C, NVIC
6.2. Cấu hình GPIO được dùng làm chân SCL và SDA.
+ Cấp clock cho GPIOB.
+ Chọn chế độ trên 2 chân chọn làm SDA và SCL Alternate Function.
+ Chọn tốc độ trên 2 chân được sử dụng là 50MHz.
+ Chọn chế độ điều khiển trên 2 chân là Open drain.
+ Chọn trạng thái trở trên 2 chân là thả nổi.
+ Sử dụng chân PB9 là chân SCL và PB8 là chân SDA.
276
+ Sử dụng hàm GPIO_Init với tham số truyền vào là GPIO đang được sử
dụng và biến thuộc kiểu cấu trúc GPIO để cấu hình các giá trị được khởi
tạo bên trên cho 2 chân PB8 và PB9.
+ Sử dụng hàm GPIO_PinAFConfig với đối số truyền vào là GPIO đang

được sử dụng, chân GPIO có chức năng AF và vị trí chân GPIO sử dụng
với chức năng I2C ở Alternate Function nào.
6.3. Cấu hình sử dụng I2C1
+ Cấp clock cho I2C1 hoạt động.
+ Sử dụng tần số trên chân SCL là 400KHz.
+ Chọn chế độ là có thể truyền và nhận dữ liệu.
+ Chu kì xung thấp chia xung cao trên chân SCL là 2.
+ Địa chỉ của I2C là SERIAL_ADR (0x02).
+ Cho phép sử dụng bit ACK.
+ Sử dụng 7 bit địa chỉ.
277
+ Sử dụng hàm I2C_Init với tham số truyền vào là I2C đang sử dụng và
biến thuộc kiểu cấu trúc I2C để cấu hình các giá trị đã khởi tạo bên trên
của I2C.
+ Sử dụng hàm I2C_Cmd để cho phép I2C hoạt động
6.4. Cấu hình trình phục vụ ngắt
+ Cho phép ngắt khi nhận các bit địa chỉ và bit Stop.
+ Cho phép ngắt khi có dữ liệu được truyền đến.
+ Sử dụng trình phục vụ ngắt I2C1_EV_IRQn.
+ Cho phép ưu tiên ngắt PreemptionPriority là 0.
+ Cho phép ưu tiên ngắt SubPriority là 0.
+ Cho phép trình phục vụ ngắt hoạt động.
+ Sử dụng hàm NVIC_Init để cấu hình các khởi tạo trên cho trình phục vụ
ngắt I2C.
278
Bước 7: Sử dụng hàm I2C1_EV_IRQHandler để thực hiện ngắt
+ Sử dụng hàm I2C_GetLastEvent(I2C1) để kiểm tra khi có sự kiện ngắt.
+ Sử dụng I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED
kiểm tra địa chỉ truyền đến đúng hay không?
+ Sử dụng I2C_EVENT_SLAVE_BYTE_RECEIVED kiểm tra có dữ liệu

truyền đến.
+ Sử dụng I2C_EVENT_SLAVE_STOP_DETECTED kiểm tra có dữ liệu

stop truyền đến
Bước 8: Xây dựng các hàm truyền bit start và địa chỉ.
+ Chờ cho đường truyền là rảnh.
+ Sử dụng hàm I2C_GenerateSTART để truyền bit Start.
+ Chờ cho bit Start truyền xong.

279
+ Sử dụng hàm I2C_Send7bitAddress để truyền các bit địa chỉ với tham số
là I2C đang sử dụng để truyền, 7 bit địa chỉ và hướng truyền địa chỉ.
+ Chờ truyền xong địa chỉ.
Bước 9: Xây dựng hàm truyền dữ liệu.
+ Sử dụng hàm I2C_TransmitData để truyền dữ liệu.
+ Chờ cho quá trình truyền xong.
Bước 10: Xây dựng hàm truyền bit Stop
Sử dụng hàm I2C_GenerateSTOP để truyền bit STOP
280
Bước 11: Xây dựng hàm cấu hình chân PA5 của led green trên Board STM32
ở chế độ Output
Bước 12: Xây dựng hàm cấu hình chân PC13 của nút nhấn trên Board
STM32F401 ở chế độ Input
Bước 13: Trong hàm main, trước hàm while(1) gọi các hàm sau
+ SystemCoreClockUpdate();
+ Button_Init();
+ Led_Init();
281
+ I2C_InitMaster();
+ I2C_InitSlave();
Bước 14: Trong hàm while(1), thực hiện thuật toán bật tắt led khi nhận đúng
dữ liệu
282
283
stm32f041re_i2c.h
Viết chương trình lập trình thư viện cho ngoại vi I2C: tạo file stm32f041re_i2c.h.
phân vùng ngoại vi của I2C
+ Sinh viên biết được lập trình thư viện cho ngoại vi I2C: tạo file
stm32f041re_i2c.h
284
Bước 1: Tạo một project như nội dung Bài 1
Bước 2: Tạo file.h cho ngoại vi I2C
+ stm32f041re_i2c.h
File stm32f401re_i2c.h
Bước 3: #include Device Header file
Bước 4: Định nghĩa struct cho ngoại vi I2C
285
Bước 5: define các thông số cho I2C
5.1. Mode
5.2. Duty cycle trong chế độ Fast mode
5.3. Cho phép/Không cho phép sử dụng bit ACK

286
5.4. Truyền hay nhận
5.5. ACK phản hồi cho địa chỉ
5.6. NACK
287
5.7. Interrupt
288
5.8. Register Flag
289
5.9. Master mode
5.10. Slave mode
290
291
292
stm32f401re_i2c.c
Viết chương trình lập trình thư viện cho ngoại vi I2C: tạo file stm32f401re_i2c.c
+ Sinh viên biết được lập trình thư viện cho ngoại vi I2C: tạo file
stm32f401re_i2c.c
293
Bước 2: Tạo file.c cho ngoại vi I2C
+ stm32f041re_i2c.c
3.1. I2C_Init: Khởi tạo I2C
294
295
3.2. I2C_Cmd: Cho phép sử dụng I2Cx
296
3.3. I2C_GenarateSTART : Đưa ra điều kiện START
3.4. I2C_GenerateSTOP: Đưa ra điều kiện STOP
297
3.5. I2C_Send7bitAddress: Gửi 7bit địa chỉ
298
3.6. Cho phép/Không cho phép sử dụng bit ACK
3.7. Hàm truyền dữ liệu qua ngoại vi I2C
3.8. Hàm đọc dữ liệu nhận được
299
Bước 4: Sử dụng ngắt với I2C
4.1. I2C_ITConfig: Cấu hình ngắt cho I2C
4.2. I2C_CheckEvent: Kiểm tra các event của I2C
300
4.3. I2C_GetLastEvent: Lấy event cuối cùng
301
4.4. I2C_GetFlagStatus: Kiểm tra cờ có được set hay không
302
4.5. I2C_ClearFlag: Xóa cờ
303
4.6. I2C_GetITStatus: Kiểm tra cờ ngắt
304
4.7. I2C_ClearITPendingBit: Xóa cờ ngắt
305
Bài 24: Thực hành truyền và nhận dữ liệu với ngoại vi USART
Viết chương trình khi nhấn nút trên Board (PC13) STM32 sẽ truyền dữ liệu từ
USART6 đến USART1 trên Board STM32. Khi dữ liệu truyền trùng khớp thì Led
màu xanh (Led - PA5 sau board) trên Kit STM32F401 sẽ nháy 5 lần sau đó trở lại
trạng thái ban đầu.
+ Sinh viên nắm rõ về lập trình driver cho ngoại vi USART
+ Sinh viên biết được truyền và nhận dữ liệu với ngoại vi USART
+ Sinh viên biết được cách xây dựng các hàm cần thiết cho ngoại vi USART

306
Bước 2: Kết nối phần cứng giữa ngoại vi USART6 và USART1 trên Board
STM32 với nhau như sau
TX : PC6 - RX: PA10
307
Lưu ý: Khi thực hiện bài này phải tháo kit mở rộng ra chỉ sử dụng board
Nucleo-F401re
Bước 3: Thêm các thư viện "stm32f401re gpio.h", "stm32f401re_rcc.h",

"stm32f401re_usart.h", "misc.h"bằng câu lệnh #include.
Bước 4: Khai báo các Macro giúp quá trình lập trình trở nên dễ dàng hơn
308
Bước 5: Xây dựng hàm để cấu hình chân PC13 của nút nhấn trên Board STM32
ở chế độ input.
+ Kết nối clock cho GPIOC.
+ Tốc độ xử lý là 100MHz
+ Trạng thái Kéo trở lên dương nguồn Pull Up.
309
Bước 6: Xây dựng hàm để cấu hình chân PA0 Làm trạng thái đầu ra để điều
khiển led Green trên Kit STM32F4
+ Kết nối clock cho GPIOA.
310
Bước 7: Cấu hình ngoại vi USART6 ở chế độ chỉ truyền dữ liệu.
7.1. Khai báo các kiểu dữ liệu thuộc các kiểu struct về GPIO, USART để cấu
hình sử dụng các ngoại vi.
7.2. Cấu hình chân GPIO sử dụng cho USART6
+ Cho phép kết nối clock đến chân GPIO sử dụng cho USART6.
+ Chọn chế trên chân GPIO sử dụng cho USART6 là Alternate Function.
+ Chọn Tốc độ trên chân là 50MHz.
+ Chọn chế độ điều khiển trên chân là Push Pull.
311
+ Chọn trạng thái trên chân ban đầu là kéo trở lên dương nguồn Pull Up.
+ Chọn chân PC6 làm chân TX của USART6.
+ Sử dụng hàm GPIO_Init với tham số truyền vào là GPIO nào được sử dụng,
Biến dữ liệu kiểu cấu trúc struct GPIO để tham chiếu đến các giá trị vừa khởi
tạo bên trên.
+ Sử dụng hàm GPIO_PinAFConfig với tham số truyền vào là GPIO đang

sử dụng, chân sử dụng với chức năng AF và chân đó thuộc AF nào.
7.3. Cấu hình sử dụng USART6 với chức năng chỉ truyền dữ liệu với các bước
sau:
+ Enable clock để sử dụng ngoại vi USART6.
+ Cấu hình tốc độ truyền là 9600.
+ Khung truyền 8 bit dữ liệu.
+ Khung truyền dữ liệu có một bit Stop.
+ Không sử dụng bit Parity.
+ Cho phép quá trình truyền bởi phần cứng.
+ Chức năng nhận dữ liệu trên chân Tx.

312
+ Sử dụng hàm USART_Init để cài đặt các giá trị đã khởi tạo ở trên.
+ Cho phép bộ USART6 hoạt động.
Bước 8: Cấu hình ngoại vi USART1 ở chế độ chỉ nhận dữ liệu
8.1. Khai báo các kiểu dữ liệu thuộc các struct của GPIO, USART, NVIC để
cấu hình sử dụng ngoại vi USART1
+ Chọn chân PA10 làm chân RX của USART1.
+ Sử dụng hàm GPIO_Init với tham số truyền vào là GPIO nào được sử dụng,
Biến dữ liệu kiểu cấu trúc struct GPIO để tham chiếu đến các giá trị vừa khởi
tạo bên trên.
313
+ Sử dụng hàm GPIO_PinAFConfig với tham số truyền vào là GPIO đang
sử dụng, chân sử dụng với chức năng AF và chân đó thuộc AF nào
8.3. Cấu hình sử dụng USART1 với chức năng chỉ nhận dữ liệu với các bước
sau:
+ Cấp clock để sử dụng ngoại vi USART1.
+ Khung truyền có một bit Stop.
+ Cho phép quá trình nhận bởi phần cứng.
+ Chức năng nhận dữ liệu trên chân Rx.
314
8.4. Cấu hình sử dụng USART1 với ngắt khi có dữ liệu truyền từ USART6 với
các bước sau:
+ Cho phép sử dụng ngắt ngoại vi USART1.
+ Sử dụng ưu tiên ngắt PreemptionPriority là 0.
+ Sử dụng ưu tiên ngắt SubPriority là 0.
+ Sử dụng trình phục vụ ngắt với USART1.
+ Sử dụng hàm NVIC_Init(&NVIC_InitStructure) với tham số truyền vào

là biến dữ liệu thuộc kiểu cấu trúc NVIC để cấu hình các giá trị đã được khai
báo ở trên.
Bước 9: Gọi hàm xử lý ngắt USART1_IRQHandler
+ Kiểm tra dữ liệu là đã được gửi đến USART1.
+ Gán giá trị nhận được với biến Data_Receive.
315
+ Gọi hàm USART_ClearITPendingBit để thoát khỏi hàm xử lý ngắt
Bước 10: Xây dựng hàm Control_led_ReceiveData xử lý khi dữ liệu nhận

được là đúng
316
10.1.Trong hàm main gọi hàm Control_led_ReceiveData
10.2. Hàm delay
317
318
stm32f041re_usart.h
Viết chương trình lập trình thư viện cho ngoại vi USART: tạo file
stm32f041re_usart.h
+ Sinh viên biết được lập trình thư viện cho ngoại vi USART
319
Bước 2: Tạo file.h cho ngoại vi UART:
+ stm32f041re_usart.h
320
Bước 4: Định nghĩa struct cho ngoại vi UART
STM32F401RE sử dụng USART bao gồm chức năng cho UART. Khởi
tạo Clock khi muốn sử dụng chức năng USART
321
Bước 5: define các thông số cho UART
5.1. Độ dài bit
5.2. Lựa chọn stop bits
5.3. Bit chẵn lẻ
322
5.4. UART mode truyền hay nhận
5.5. UART HW Flow Control
5.6. Sử dụng Clock khi muốn sử dung USART
5.7. Sử dụng CPOL và CPHA khi muốn sử dụng USART cấu hình
chức năng truyền đồng bộ sử dụng xung Clock
323
5.8. Last Bit
5.9. UART Interrupt
5.10. UART_DMA
324
5.11. UART Flag
325
326
stm32f041re_usart.c
Viết chương trình lập trình thư viện cho ngoại vi USART: tạo file
stm32f041re_usart.c
+ Sinh viên biết được lập trình thư viện cho ngoại vi USART
327
Bước 2: Tạo file.c cho ngoại vi UART:+ stm32f401re_usart.c
3.1. USART_Init: Khởi tạo UART
328
329
330
3.2. USART_Cmd: Cho phép sử dụng UART
331
3.3. USART_SendData Hàm truyền dữ liệu
3.4. USART_ReceiveData Hàm nhận dữ liệu
332
3.5. Hàm xử lý ngắt. Cho phép/ không cho phép ngắt UART
333
3.6. Hàm kiểm tra cờ ngắt xem có được set hay không
334
3.7. Xóa cờ UART
335
3.8. Hàm kiểm tra cờ ngắt
336
337
3.9. Hàm xóa cờ ngắt
338
339
Bài 27: Thực hành cấu hình ngoại vi TIMER ở chế độ Basic
Viết chương trình tạo độ trễ Delay để bật/tắt trạng thái led PA5 trên board
STM32F4 Nucleo sử dụng ngoại vi Timer 1.
+ Sinh viên nắm rõ về lập trình driver cho ngoại vi, cấu hình ngoại vi TIMER
+ Sinh viên biết được cách xây dựng các hàm cần thiết cho ngoại vi TIMER

"stm32f401re_gpio.h", "stm32f401re_tim.h" bằng câu lệnh #include.
340
Bước 3: Định nghĩa chân PA5 và mức logic 0/1 bằng các câu lệnh macro như
sau:
Bước 4: Xây dựng hàm cấu hình chân PA5 của led trên Board STM32 ở chế độ
Output
chân được kết nối để điều khiển led
Bước 6: Xây dựng hàm khởi tạo các giá trị của sử dụng timer chức năng base
341
tạo tần số 1Khz
+ Khai báo biến sử dụng kiểu dữ liệu cấu trúc của TIMER
+ RCC_APB2PeriphClockCmd: Cấp Clock cho TIMER 1 hoạt động.
+ TIM_CounterMode: Chọn chế độ đếm của TIMER là đếm lên.
+ TIM_Prescaler: Chọn hệ số chia là 83.
+ TIM_Period: Chọn giá trị tràn TIMER là 999.
+ TIM_ClockDivision: Chọn hệ số chia clock sử dụng cho timer.
+ TIM_RepetitionCounter: Chọn chế độ đếm lặp lại.
+ Sử dụng hàm TIM_TimeBaseInit với tham số là TIMER đang sử dụng và

biến dữ liệu thuộc kiểu cấu trúc TIMER để khởi tạo các giá trị bên trên.
+ Sử dụng hàm TIM_Cmd cho phép TIMER 1 hoạt động
Bước 7: Xây dựng hàm tạo delay bằng Timer
+ Khởi tạo giá trị đếm thanh ghi đếm CNT = 0.
342
+ Cho phép thanh ghi đếm bắt đầu đếm đến 999 thì giảm giá trị ms để tạo
delay
Bước 8: Trong hàm main, trước hàm while(1) gọi các hàm:
+ Led1Control_Init
+ Time_Init
Bước 9: Trong Hàm While(1), bật tắt led theo delay 500ms tạo bởi Timer
343
Bài 28: Thực hành cấu hình ngoại vi TIMER ở chế độ Capture
Viết chương trình sử dụng Timer 2 với chức năng Input Capture để đọc số
lần ấn nút B2 trên kit STM32F401 và sau 1s sẽ gửi số lần ấn nút lên PC.

"stm32f401re_gpio.h", "stm32f401re_tim.h", "misc.h" bằng câu lệnh
#include.
344
Bước 3: Xây dựng hàm cấu hình chế độ Timer với chức năng Input Capture
trên chân PB3:
3.1. Khai báo các biến thuộc kiểu dữ liệu cấu trúc GPIO, Timer, Timer Input
Capture, NVIC
3.2. Khởi tạo GPIO sử dụng chức năng Input Capture
+ Cấp clock sử dụng GPIOB.
+ Chọn chế độ Alternate function
+ Chọn tốc độ trên chân GPIO là 50MHz
+ Chọn chế độ điều khiển là Push Pull.
+ Chọn trạng thái trên chân ban đầu là thả nổi.
+ Chọn GPIO Pin 3 cho chức năng Input Capture.
+ Sử dụng hàm GPIO_PinAFConfig với đối số là GPIOB, chân PB3 làm

chức năng Alternate function và sử dụng Mode AF cho Timer 2.
+ Sử dụng hàm GPIO_Init với các tham số truyền vào là GPIO đang
được sử dụng và biến thuộc kiểu cấu trúc GPIO để cấu hình các giá trị
đã được khởi tạo ở trên.
345
3.3. Khởi tạo sử dụng Timer Base
+ Kết nối clock sử dụng Timer2.
+ Chọn hệ số chia tần là 41999 để tạo ra tần số 2KHz.
+ Chọn giá trị tràn Timer max là 0xFFFF.
+ Chọn chế độ đếm lên.
+ Không chia cấp clock cho Timer 2.
+ Sử dụng hàm TIM_TimeBaseInit với các đối số là Timer2,

&TIM_TimeBaseInitStructure để cài đặt các giá trị đã khởi tạo ở trên.
3.4. Cấu hình sử dụng chức năng Input Capture trên chân PB3
+ Chọn kênh 2 của Timer 2.
+ Chọn Sườn phát hiện sự kiện là cả sườn lên và sườn xuống.
+ Chọn chỉ định đầu vào là trực tiếp.
346
+ Chọn hệ số chia tần là 1.
+ Sử dụng hàm TIM_ICInit tham số truyền vào là Timer đang được sử

dụng và biến dữ liệu thuộc kiểu cấu trúc Input capture để cấu hình
các giá trị đã được khởi tạo ở chế độ Input capture.
+ Sử dụng hàm TIM_Cmd cho phép Timer 2 hoạt động.
3.5. Khởi tạo ngắt cho chức năng Input Capture
+ Sử dụng hàm TIM_ITConfig với tham số truyền vào là Timer đang

được sử dụng , kênh sử dụng chức năng Input capture và trạng thái
kết nối.
+ Sử dụng trình phục vụ ngắt của Timer 2.
+ Chọn mức ưu tiên ngắt PreemptionPriority là 0.
+ Chọn mức ưu tiên ngắt SubPriority là 0.
+ Sử dụng hàm NVIC_Init với tham số truyền vào là địa trị biến dữ liệu
thuộc kiểu cấu trúc NVIC để cấu hình các giá trị đã được khởi tạo ở
trên.
347
Bước 4: Sử dụng hàm TIM2_IRQHandler để thực hiện ngắt khi nút ấn trên
chân PB3 được ấn và nhả và sử dụng hàm Check_Tim_Press kiểm tra số lần
ấn nút
Bước 5: Xây dựng hàm Check_Tim_Press kiểm tra số lần ấn và lưu thời gian
trong quá trình ấn và nhả nút
+ Sử dụng biến Status1 để kiểm tra lúc ấn nút và lúc nhả nút
+ Biến Number_Press sẽ được tăng lên khi phát hiện sườn xuống
+ Biến Tim_Rising sẽ lưu thời gian khi phát hiện sườn lên để so sánh
Bước 6: Xây dựng hàm Send_NumberPress để gửi dữ liệu sau 1s lên máy tính
348
+ Kiểm tra xem nút ấn đã được ấn chưa bằng biến Status.
+ Nếu giá trị thời gian đếm trên thanh ghi CNT bị tràn và đếm lại từ đầu thì
thời gian kiểm tra xem đã đủ 1s để gửi dữ liệu được tính bằng công thức
Tim_SendData = (0xffff + Tim_Update) - Tim_Rising
+ Nếu giá trị thời gian đếm trên thanh ghi CNT lớn hơn thời gian khi nút ấn
được nhả thì thời gian kiểm tra xem đã đủ 1s để gửi dữ liệu được tính bằng công
thức:
Tim_SendData = Tim_Update - Tim_Rising
+ Nếu thời gian là lớn hơn 1s sẽ gửi số lần ấn nút lên máy tính
349
Bước 7: Xây dựng hàm cấu hình USART2 hoạt động để truyền giá trị nhiệt lên
PC
hình sử dụng các ngoại vi
+ Sử dụng hàm GPIO_Init với tham số truyền vào là GPIO nào được sử
dụng, Biến dữ liệu kiểu cấu trúc struct GPIO để tham chiếu đến các giá
trị vừa khởi tạo bên trên.
+ Sử dụng hàm GPIO_PinAFConfig với tham số truyền vào là GPIO

đang sử dụng, chân sử dụng với chức năng AF và chân đó thuộc AF nào
350
sau:
+ Cho phép bộ USART2 hoạt động
351
Bước 8: Trong hàm While(1), Sử dụng hàm Send_NumberPress để gửi số lần
ấn nút lên PC
352
Bài 29: Thực hành cấu hình ngoại vi TIMER ở chế độ PWM
Viết chương trình sử dụng Timer 1 với chức năng PWM điều khiển
độ sáng trên led ở chân PA11 với tần số là 10KHz.

"stm32f401re_gpio.h", "stm32f401re_tim.h" bằng câu lệnh #include.
353
Bước 3: Khai báo macro Period cho timer 1 để tạo tần số 10khz.
#define Tim_Period 8399
Bước 4: Xây dựng hàm TimPwm_Init cấu hình chế độ Timer với chức năng
PWM trên chân PA11.
4.1. Khai báo các kiểu dữ liệu thuộc các kiểu dữ liệu GPIO, Timer Base và
Timer Output Compare.
4.2. Cấu hình chân GPIO sử dụng cho chức năng PWM.
+ RCC_AHB1PeriphClockCmd: Cấp clock sử dụng GPIOA.
+ GPIO_Mode : Chọn chế độ trên chân GPIO là Alternate function.
+ GPIO_Speed: Chọn tốc độ trên chân GPIO là 50MHz.
+ GPIO_OType: Chọn chế độ điều khiển là đẩy kéo Push Pull.
+ GPIO_PuPd: Chọn trạng thái ban đầu trên chân GPIO là thả treo.
+ Sử dụng hàm GPIO_PinAFConfig với đối số là GPIOA, chân

PA11 làm chức năng Alternate function và sử dụng Mode AF cho
Timer1
+ GPIO_Pin: Sử dụng chân PA11 làm chức năng PWM.
+ Sử dụng hàm GPIO_Init với các đối số là GPIOA và

&GPIO_InitStructure
354
4.3. Cấu hình sử dụng Timer base tạo tần số 10khz
+ RCC_APB2PeriphClockCmd: Kết nối clock sử dụng Timer1.
+ TIM_Prescaler: Chọn hệ số chia tần là 0.
+ TIM_Period: Hệ số tràn timer là 8399 để tạo ra tần số là 10KHz.
+ TIM_CounterMode: Chọn chế độ đếm lên.
+ TIM_ClockDivision: Hệ số chia tần sử dụng Timer.
+ TIM_RepetitionCounter: Chọn bộ đến lặp lại là 0.
+ Sử dụng hàm TIM_TimeBaseInit với các đối số là Timer1,

&TIM_TimeBaseInitStructure để cài đặt các giá trị đã khởi tạo ở
trên.
355
4.4. Cấu hình sử dụng chức năng PWM trên chân PA11
+ TIM_OCMode chọn Chế độ PWM là TIM_OCMode_PWM2.
+ TIM_OutputState : Cho phép hoặc không cho phép chân pwm

hoạt động
+ TIM_Pulse :Đây chính là thông số quyết định duty cycle (tỉ lệ

phần trăm xung mức cao so với period)
+ TIM_OCPolarity : Nếu polarity bit là 1 thì output sẽ ra mức cao

tại lúc bắt đầu chu kỳ và sau đó xuống mức thấp tại thời điểm kết
thúc chu kỳ
+ Sử dụng hàm TIM_OC4Init tham số truyền vào là Timer đang

được sử dụng và biến dữ liệu thuộc kiểu cấu trúc PWM cho phép
kênh 4 của Timer 1 hoạt động.
+ Cho phép Timer 1 hoạt động.
+ Cho phép Timer với Chức năng PWM hoạt động
Bước 5: Xây dựng hàm thay đổi độ sáng led bằng PWM với tham số truyền vào
là % độ sáng từ 0 đến 100
356
Bước 6: Trong hàm main, trước hàm while(1) gọi các hàm:
+ SystemCoreClockUpdate.
+ TimPwm_Init.
Bước 7: Trong hàm while(1), gọi hàm LedControl_PWM để thay đổi độ sáng
led
357
stm32f041re_tim.h
Viết chương trình lập trình thư viện cho ngoại vi TIMER: tạo file
stm32f041re_tim.h
+ Sinh viên nắm rõ về lập trình driver cho ngoại vi TIMER
+ Sinh viên biết được lập trình thư viện cho ngoại vi TIMER: tạo file
stm32f041re_tim.h

358
Bước 2: Tạo file.h cho ngoại vi timer:
+ stm32f041re_tim.h
359
Bước 4: Định nghĩa struct cho ngoại vi TIMER
4.1. Time Basic.
4.2. Timer Output Compare
360
4.3. Timer Input Capture
Bước 5: Define các thông số cho TIMER
5.1. Timer Channel
361
5.2. Clock Division
5.3. Timer Counter Mode
Bước 6: Output Compare
6.1. Output Compare Mode
362
6.2. Lựa chọn Timer Pulse Mode
6.3. Timer Output Compare Polarity (Active High or Low)
6.4. Output Compare State (Enable/Disable)
6.5. Output compare Idle state
363
6.6. Output compare Preload State
6.7. Output compare Fast State
6.8. Output compare Clear State
Bước 7: Input Capture
7.1. Capture Compare State (Enable/Disable)
7.2. Input capture Polarity
364
7.3. Input capture Selection
7.4. Input capture Prescaler
Bước 8: Interrupt
8.1. Interrupt Sources
8.2. Timer Flag
365
9.1. Timer Basic
9.2. Output Compare
366
9.3. Input Capture
9.4. Timer Flag (Interrupt, DMA)
367
368
stm32f401re_tim.c
Viết chương trình lập trình thư viện cho ngoại vi TIMER: tạo file stm32f401re_tim.c
+ Sinh viên nắm rõ về lập trình driver cho ngoại vi TIMER
+ Sinh viên biết được lập trình thư viện cho ngoại vi TIMER: tạo file
stm32f041re_tim.c
Bước 2: Tạo file.c cho ngoại vi timer:
369
+ stm32f401re_tim.c
+ Timer Basic Initialization: Khởi tạo Timer. Đầu tiên là cấp xung
clock cho ngoại vi Timer, chọn hệ số chia tần, chế độ đếm ... và cuối
cùng là cho phép ngoại vi Timer hoạt động.
+ Timer Input Capture Initialization: Khởi tạo Timer chế độ Input

Capture. Đầu tiên các bạn cần chọn kênh, tiếp theo chọn sườn phát
hiện sự kiện ... và cuối cùng là cho phép sử dụng timer ở chế độ
Input Capture.
+ Timer Output Compare Initialization: Khởi tạo Timer chế độ Output

Compare. Đầu tiên các bạn cần chọn chế độ, tiếp theo chọn độ rộng
xung ... và cuối cùng là cho phép ngoại vi timer hoạt động ở chế độ
Output Compare.
370
+ Timer Get Capture: Lấy được khoảng thời gian giữa hai lần có sườn
lên hoặc sườn xuống hoặc sườn lên và xuống.
+ Timer Set Capture: Thiết lập hệ số chia cho chế độ Input Capture
+ Timer Error Interrupt handling: Hàm sử dụng ngắt kiểm tra lỗi khi
sử dụng ngoại vi Timer.
+ Timer Event Interrupt handling: Hàm sử dụng ngắt cập nhật sự

kiện của ngoại vi Timer.
Bước 4: TIM_TimeBaseInit: Khởi tạo Timer basic
371
Bước 5: TIM_ICInit: Khởi tạo timer chế độ Input Capture
372
Bước 6: Hàm cấu hình chế độ Input Capture sử dụng cho hàm khởi tạo Input
Capture
373
374
Bước 7: Timer Output Compare
TIM_OC1Init : Kênh 1 (Tương tự với các kênh còn lại)
375
376
Bước 8: Hàm GetCapture
377
Bước 9: Hàm SetCapture Prescaler
378
379
Bước 10: Hàm cấu hình sử dụng ngắt Cho phép/ không cho phép ngắt
TIMER
380
Bước 11: Hàm kiểm tra cờ ngắt
381
Bước 12: Hàm xóa cờ ngắt
382
Bước 13: Hàm kiểm tra cờ
383
Bước 14: Hàm xóa cờ
384
385
Bài 32: Thực hành cấu hình ngoại vi ADC ở chế độ quét liên tục
Viết chương trình đọc giá trị ADC của cảm biến nhiệt độ bên trong vi điều
khiển STM32F401 sau đó hiển thị giá trị nhiệt độ lên phần mềm hercules.
+ Sinh viên nắm rõ về lập trình driver cho ngoại vi ADC
+ Sinh viên biết được cấu hình ngoại vi ADC
+ Sinh viên biết được cách xây dựng các hàm cần thiết cho ngoại vi ADC
386
"stm32f401re_gpio.h", "stm32f401re_adc.h", "stm32f401re_usart.h",
"timer.h" bằng câu lệnh #include.
Bước 3: Xây dựng hàm khởi tạo các giá trị để sử dụng ngoại vi Timer
3.1. Khai báo các biến thuộc kiểu dữ liệu cấu trúc ADC chung và ADC riêng
3.2. Cấp Clock cho bộ ADC1 hoạt động.
3.3. Sử dụng hàm ADC_DeInit() để khởi lại các giá trị của ADC về mặc định.
3.4. Khởi tạo các giá trị ADC chung
+ Chọn chế độ cho ADC là ADC_Mode_Independent.
+ Chọn hệ số chia tần số là 1.
+ Không sử dụng DMA.
+ Chọn thời gian giữa 2 lần chuyển đổi là 5Cycles
3.5. Khởi tạo các giá trị cho ADC1
+ Chọn số bit chuyển đổi là 12 bit.
+ Không cho phép sử dụng chuyển đổi không liên tục.
+ Cho phép sử dụng chuyển đổi liên tục.
387
+ Cho phép ghi dữ liệu từ bên phải.
+ Chọn số kênh sử dụng là 1
+ Sử dụng hàm ADC_Init với tham số là bộ ADC đang sử dụng và biến

dữ liệu thuộc kiểu cấu trúc ADC để cài đặt các giá trị đã khởi tạo ở
trên.
+ Sử dụng hàm ADC_RegularChannelConfig với các đối số là ADC1,

kênh được kết nối với cảm biến nhiệt độ, một kênh chuyển đổi và thời
gian lấy mẫu là 144Cycles.
+ Sử dụng hàm ADC_TempSensorVrefintCmd để sử dụng cảm biến

nhiệt độ bên trong vi điều khiển.
+ Sử dụng hàm ADC_Cmd để sử dụng bộ ADC1
Bước 4: Xây dựng hàm chuyển đổi giá trị nhiệt độ đọc từ ADC ra giá trị độ C.
+ Sử dụng hàm ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) chờ thực

hiện xong quá trình chuyển đổi ADC.
388
+ Gán biến TemperatureValue với giá trị Digital đọc được của cảm biến
nhiệt độ sau khi chuyển đổi xong.
+ Thực hiện chuyển đổi giá trị đọc được từ ADC ra giá trị nhiệt độ theo công
thức
Bước 5: Xây dựng hàm cấu hình USART2 hoạt động để truyền giá trị nhiệt
lên PC
hình sử dụng các ngoại vi
389
+ Chọn tốc độ trên chân là 100MHz.
+ Sử dụng hàm GPIO_Init với tham số truyền vào là GPIO nào được sử
dụng, Biến dữ liệu kiểu cấu trúc struct GPIO để tham chiếu đến các giá
trị vừa khởi tạo bên trên.
+ Sử dụng hàm GPIO_PinAFConfig với tham số truyền vào là GPIO

đang sử dụng, chân sử dụng với chức năng AF và chân đó thuộc AF
nào.
sau:
390
Bước 6: Xây dựng hàm đọc và truyền dữ liệu nhiệt độ sau 1s
391
392
Bài 33: Thực hành cấu hình ngoại vi ADC ở chế độ DMA
Viết chương trình đọc giá trị ADC chế độ DMA của cảm biến ánh sáng trên
kit vi STM32F401 sau đó hiển thị giá trị nhiệt độ lên PC
+ Sinh viên biết được cấu hình ngoại vi ADC
393
"stm32f401re_gpio.h", "stm32f401re_adc.h", "stm32f401re_usart.h",
"timer.h","stm32f401re_dma.h" bằng câu lệnh #include.
Bước 3: Khai báo các macro và biến sử dụng trong khi lập trình
Bước 4: Xây dựng hàm khởi tạo các giá trị để sử dụng ngoại vi Timer
4.1. Khai báo các biến thuộc kiểu dữ liệu cấu trúc GPIO, ADC chung và
ADC riêng, DMA
4.2. Cấu hình chân GPIO có chức năng ADC
+ Cấp xung clock cho PortC.
+ Sử dụng chân PA5
+ Chọn mode là Analog.
+ Chọn chế độ thả nổi.
+ Sử dụng hàm GPIO_Init cấu hình các giá trị trên
394
4.3. Sử dụng hàm ADC_DeInit() để khởi lại các giá trị của ADC về mặc định.
4.4. Khởi tạo các giá trị ADC chung
+ Chọn chế độ cho ADC là ADC_Mode_Independent.
+ Chọn hệ số chia tần số là 1.
+ Không sử dụng DMA.
+ Chọn thời gian giữa 2 lần chuyển đổi là 5Cycles
4.5. Khởi tạo các giá trị cho ADC1
+ Cấp xung Clock cho ADC1.
+ Chọn số bit chuyển đổi là 12 bit.
+ Không cho phép sử dụng chuyển đổi không liên tục.
+ Cho phép sử dụng chuyển đổi liên tục.
+ Cho phép ghi dữ liệu từ bên phải.
+ Chọn số kênh sử dụng là 1
395
+ Sử dụng hàm ADC_Init với tham số là bộ ADC đang sử dụng và biến
dữ liệu thuộc kiểu cấu trúc ADC để cài đặt các giá trị đã khởi tạo ở
trên.
4.6. Cấu hình sử dụng DMA
+ RCC_AHB1PeriphClockCmd: Cấp xung clock cho DMA.
+ DMA_DeInit: Khởi tạo mặc định cho DMA bằng hàm DMA_DeInit.
+ DMA_Channel: Cấu hình kênh DMA.
+ DMA_PeripheralBaseAddr: Cấu hình địa chỉ của thanh ghi chứa Data
trong bộ ADC.
+ DMA_Memory0BaseAddr: Cấu hình địa chỉ của biến chứa giá trị ADC
đọc về.
+ DMA_DIR: Cấu hình chiều dữ liệu được truyền là từ ngoại vi.
+ DMA_BufferSize: Số lượng data truyền là 1.
+ DMA_PeripheralInc: Không cho phép tăng địa chỉ của ngoại vi vì data
chỉ có 1.
+ DMA_MemoryInc: Không cho phép tăng địa chỉ của bộ nhớ vì data chỉ
có 1.
396
+ DMA_PeripheralDataSize:Chọn kích thước mảng dữ liệu ADCValue
gồm : Byte, Haftword và Word
+ DMA_MemoryDataSize: Chọn số bit của data bộ nhớ
+ DMA_Mode: Chọn chế độ DMA chuyển đổi liên tục.
+ DMA_Priority: Xác định độ ưu tiên của kênh DMA.
+ DMA_Init: Cấu hình các giá trị đã được khởi tạo ở trên.
+ DMA_Cmd: Cho phép DMA hoạt động.
+ ADC_DMACmd: Cho phép sử dụng ADC với chức năng DMA.
4.7. Cấu hình kênh chuyển đổi, cho phép ADC1 hoạt động và chuyển đổi
Bước 5: Xây dựng hàm đọc ADC từ cảm biến ánh sáng
Bước 6: Xây dựng hàm khởi tạo USART để truyền giá trị đọc được từ cảm biến
ánh sáng lên PC
397
Bước 7: Xây dựng hàm đọc và truyền dữ liệu nhiệt độ
398
Bước 8: Trước hàm while(1), gọi các hàm
+ TimerInit
+ LightSensor_Init1
+ USART1_Init
Bước 9: Trong hàm while(1), gọi hàm MultiSensorScan.
399
400
stm32f401re_adc.h
Viết chương trình lập trình thư viện cho ngoại vi ADC: tạo file stm32f401re_adc.h
+ Sinh viên biết được lập trình thư viện cho ngoại vi ADC: tạo file
stm32f401re_adc.h
401
Bước 2: Tạo file.h cho ngoại vi ADC:
+ stm32f041re_adc.h
Bước 4: Định nghĩa struct cho ngoại vi ADC
402
Bước 5: define các thông số cho I2C
5.1. ADC Common Mode
5.2. Cấu hình hệ số chia
5.3. Sử dụng Mode DMA hay không
403
5.4. Thời gian giữa 2 lần chuyển đổi
5.5. Cấu hình độ phân giải
5.6. ADC external trigger edge
404
5.7. Data Align
5.8. ADC channels
405
5.9. Số lần lấy mẫu
5.10. ADC flags
5.11. Interrupt
406
407
stm32f401re_adc.c
Viết chương trình lập trình thư viện cho ngoại vi ADC: tạo file stm32f401re_adc.c
+ Sinh viên biết được lập trình thư viện cho ngoại vi ADC: tạo file
stm32f401re_adc.h
408
Bước 2: Tạo file.c cho ngoại vi ADC:
+ stm32f401re_adc.c
409
Bước 4: Hàm quan trọng sử dụng cho ngoại vi ADC
410
+ DC Common Initialization: Khởi tạo ngoại vi ADC như chọn chế độ,
chọn hệ số chia tần sử dụng cho ngoại vi ADC
+ ADC Advance Initialization: Khởi tạo ngoại vi ADC riêng như cấp
xung clock cho ADCx, chọn giá trị chuyển đổi, cho phép chuyển đổi
liên tục ... và cuối cùng là cho phép ngoại vi ADCx hoạt động.
+ ADC Get Conversion Value: Hàm có chức năng đọc giá trị chuyển
đổi của ngoại vi ADC.
+ ADC DMA Initialization: Khởi tạo sử dụng DMA. Đầu tiên cấp xung
clock cho DMA, tiếp theo chọn kênh DMA ... và cuối cùng là cho
phép sử dụng DMA.
+ ADC Interrupt Configuration: Khởi tạo ngắt của ngoại vi ADC. Đầu
tiên cho phép sử dụng ngắt của ngoại vi ADC, tiếp theo cho phép
411
ngoại vi ADC sử dụng bộ quản lý ngắt NVIC ... và cuối cùng cho
phép NVIC hoạt động
+ ADC Error Interrupt handling: Hàm sử dụng ngắt kiểm tra lỗi trong quá
trình chuyển đổi ADC.
+ ADC Even Interrupt handling: Hàm sử dụng ngắt thông báo quá
trình chuyển đổi ADC đã xong.
4.1. ADC_Init: Khởi tạo ADC
412
4.2. ADC_CommonInit : Khởi tạo tham số cho ADC
413
4.3.ADC_Cmd: Cho phép sử dụng ADCx
414
4.4. ADC_RegularChannelConfig Cấu hình lựa chọn kênh
415
416
4.5. Cho phép/Không cho phép sử dụng cảm biến
417
4.6. Cho phép, Bắt đầu chuyển đổi
418
4.7. Chế độ chuyển đổi liên tục
419
4.8. Chế độ chuyển đổi không liên tục
420
421
4.9. Hàm đọc dữ liệu nhận được
4.10. ADC DMA
Direct memory access là cơ chế của hệ thống máy tính cho phép một
thành phần phần cứng truy cập đến bộ nhớ dữ liệu chính một cách độc lập
với CPU
422
423
424
Bước 5: Sử dụng ngắt với ADC
5.1. ADC_ITConfig: Cấu hình ngắt cho SPI
425
5.2. ADC_GetITStatus: Kiểm tra cờ ngắt
426
5.3. Xóa cờ ngắt
427
5.4. ADC_GetFlagStatus: Kiểm tra các cờ của ADC
428
429
5.5. ADC_ClearFlag: Xóa cờ
5.6. SPI_GetFlagStatus: Kiểm tra cờ có được set hay không
5.7. I2C_ClearFlag: Xóa cờ
430
2.Thực hành lập trình mạng không dây Zigbee
Bài 1: Thực hành viết chương trình tạo project bằng phần mềm Simplicity
Studio
Bước1: Trong giao diện của Simplicity Studio IDE, lựa chọn
File => New => Project
Bước 2: Trên cửa sổ New Project, lựa chọn Silicon Labs AppBuilder
Project => Next
Bước 3: Lựa chọn Silicon Labs Zigbee (chỉ lựa chọn được khi đã tải
SDK) --> Next
431
Bước 4: Lựa chọn EmberZNet x.x.x.x GA SoC x.x.x.x (với x là số phiên
bản SDK sử dụng) => Next
Bước 5: Lựa chọn Project mẫu mà bạn muốn khởi tạo, đối với mỗi project,
SDK đều cung cấp cho chúng ta các đoạn mô tả để biết được project đó
được sử dụng để làm gì.
Lưu ý: Đối với SDK 6.7, IDE sẽ gặp lỗi khi tạo blank project (blank
application) vì vậy không được tích vào phần Start with a blank application
Bước 6: Đặt tên và lựa chọn đường dẫn lưu trữ project
432
Bước 7:
- Nếu sử dụng Development Board được phát triển từ Silicon Labs, lựa chọn vào
mục Board - nhập tên board
- Nếu sử dụng module được phát triển từ Silicon Labs, lựa chọn vào Part –nhập tên
module (VD: EFR32MG21A010F512IM32)
- Lựa chọn Compiler cho chương trình (VD: GNU, IAR,…). Finish
433
Bước 8: Mở file Z3LightSoc.isc để cấu hình. Trong Tab ZCL Cluster xóa
endpoint 2 và 3 đi vì không sử dụng
Kết quả
Bước 9: Trong mục ZCL device type => ZigBee Custom
434
Bước 10: Chọn HA devices => Chọn HA On/Off Light
Bước 11: Trong Tab HAL chọn None cho mục Bootloader vì chưa sử dụng
435
Bước 12: Trong Tab Plugin search green và bỏ chọn Green Power, Green
Power Library, provides API: gp
Bước 13: Search ZLL và bỏ chọn ZigBee Light Link
Bước 14: Search color và bỏ tích
Bước 15: Bỏ tích Level Control Server Cluster vì không sử dụng
436
Bước 16: Sử dụng Callback Hal Button Isr để dùng hàm xử lý nút nhấn với tham
số là
button: xác định xem nút nào được nhấn
state: xác định trạng thái của nút nhấn là nhấn hay nhả. Sử dụng Main Init để biết
khi nào thiết bị được khởi động lại
Bước 16: Chọn Generate để Simplicity Studio tạo ra các file cần thiết sau khi
đã cấu hình xong
437
Bước 17: Cấu hình chân trong file Hardware configurator
438
17.1. Trong mục PA => Chọn PA Voltage 1000
PA Selection Medium Power Vì MCU là dòng EFR32MG21 Series 2
17.2. Trong mục UART0 =>Chân TX-PA5, Chân RX-PA6
17.3. Chọn Flow control mode => No flow control TX Pin: PA5
RX Pin: PA6
17.4. Trong mục Button, cấu hình chân cho nút nhấn
SW1-PD4, SW2-PD3
439
Bỏ tích LED vì chưa sử dụng
Bước 18: Sau đó tiến hành build chương trình bằng biểu tượng cây búa
Xuất hiện một số lỗi về thư viện. Kích đúp chuột vào lỗi để di chuyển đến
dòng bị lỗi
Những thư viện này không được dùng vì vậy hãy xóa nó đi hoặc sử dụng
// để comment chúng lại
440
Sau đó sử dụng cây búa để build lại chương trình
Nếu tiếp tục lỗi thì hãy comment lại những dòng đó
Đã hết lỗi => Hoàn tất quá trình cấu hình
441
Bài 2: Thực hành lập trình tạo folder áp dụng phân tầng cho thư viện Simplicity
Studio
Bước1: Tạo một project như nội dung Bài 1
Bước 2: Click phải chuột vào project => Chọn New => Folder
Bước 3: Đặt tên cho folder là Source
442
Bước 4: Tiếp tục tạo folder App, Mid, Driver trong folder Source
Bước 5: Trong folder App tạo file main.c
Bước 6: Đặt tên là main.c rồi nhấn Finish để hoàn tất tạo file.c
443
Bước 7: Tạo file header main.h
Bước 8: Tương tự như vậy hãy tạo những file còn lại với kết quả như dưới
444
Bài 3: Thực hành nạp firmware vào Kit IoT Zigbee thông qua phần mềm
Commander
Bước 2: Trong file.isc được sinh ra trong project, lựa chọn Generate để
sinh ra các file thư viện, phục vụ cho quá trình nạp firmware vào Kit
Bước 3: Có thể sử dụng một trong 3 file trên để tiến hành nạp firmware vào Kit
Bước 4: Cắm mạch nạp
445
Bước 5: Mở phần mềm Commander:
C:\SiliconLabs\SimplicityStudio\v4\developer\adapter_packs\commander
Bước 6: Sau khi cắm Jlink được kết nối với Kit IoT Zigbee
Bước 7: Nạp firmware: Lựa chọn J-Link Device sau đó nhấn Connect để kết
nối với Jlink
446
Kết quả:
Bước 8: Nhấn Connect để kết nối với Kit IoT Zigbee

447
Kết quả:
448
Bước 9: Lựa chọn mục Tab Flash => Chọn Browse để chọn đường dẫn đến file
firmware
Bước 10: Lựa chọn đường dẫn đến project cần nạp firmware
Ví dụ
C:\Users\TrungNT\SimplicityStudio\v4_workspace\SW_ZB_V1_0_0\GNU
ARM v7.2.1 – Default
Lưu ý: Thư mục GNU ARM v7.2.1 - Default là nơi lưu trữ firmware để nạp vào
Kit
Bước 11: Nhấn Erase chip để xóa dữ liệu trong Flash
449
Bước 12: Nhấn Flash để nạp firmware
Bước 13: Kết thúc

450
Bài 4: Thực hành viết chương trình xử lý các sự kiện của nút nhấn SW1 (PD04),
SW2(PD03) trong bảng sau và sử dụng giao thức UART để hiển thị text ra màn hình
qua phần mềm Hercules

Bước 2: Cấu hình chân trong file Hardware configurator: Bỏ chọn Button và
Led tự xây dựng lại module Button và Led
Bước 3: Xây dựng lại module Button và Led

3.1.Tạo module Button trong tầng Mid
3.2. Trong button.h

451
3.3. Trong file button.c: thêm thư viện
452
3.4. Trong file button.c: khai báo con trỏ hàm
Bước 4: Cấu hình chân PD04, PD03 ở chế độ Input, cho phép ngắt sườn lên và
sườn xuống
Bước 5: Xử lý tín hiệu ngắt và sử dụng Event

Một số hàm sử dụng event:
+ emberEventControlSetActive(control);
+ Active Event. Nhảy đến thực hiện hàm Handler
+ emberEventControlSetInactive(control);
+ Inactive Event. Ngừng tái kích hoạt Event hoạt động
+ emberEventControlSetDelayMS(control, delay);
+ Kích hoạt Event sau khoảng thời gian delay
5.1. Khai báo Event trong file .isc
453
5.2. Khai báo data sử dụng Event cho nút nhấn
Ví dụ: emberEventControlSetActive(buttonPressAndHoldEventControl);
Thì chương trình sẽ chạy vào hàm buttonPressAndHoldEventHandle để xử lý
Bước 6: Sau khi khai báo Event hay chỉnh sửa trong file.isc cần phải Generate
để sinh ra các file thư viện, phục vụ cho quá trình nạp firmware vào Kit
Bước 7: Nạp firmware vào Kit: thao tác như bước 2-12 của Bài 3
Bước 8: Mở phần mềm Hercules
454
Bước 9: Kết nối với Kit thông qua cổng COM
Tag Serial chọn cổng COM#Open
455
Tham khảo: Lưu đồ thuật toán tín hiệu ngắt nút nhấn
456
457
Bài 5: Viết chương trình tạo hàm xử lý Led trên Kit IoT Zigbee cho các trường
hợp nút nhấn sau:

Bước 2: Cấu hình chân trong file Hardware configurator: Bỏ chọn Button và
Led tự xây dựng lại module Button và Led
Bước 3: Xây dựng lại module Button và Led

3.1.Tạo module Led trong tầng Mid
458
3.2. Trong led.h
3.3. Trong file led.c: khai báo một mảng chứa thông tin về các led RGB
3.4. Trong file led.c: Init các chân cho led RGB
459
Bước 4: Xây dựng các hàm bật, tắt, blink led
4.1. onLed():
4.2.offLed():
4.3. toggleLed(): Tạo một timer cho mỗi led
4.4. toggleLed(): Trong hàm ledInit() thêm các câu lệnh sau
4.5. Xây dựng hàm toggleLed():
460
4.6. Xử lý timer event của toggleLed
461
Bước 5: Xây dựng chương trình
5.1. Cấu trúc phân tầng
5.2. Sơ đồ thuật toán tầng App
462
5.3. Xây dựng chương trình
463
Bước 6: Sau khi khai báo hay chỉnh sửa trong file.isc cần phải Generate để sinh
ra các file thư viện, phục vụ cho quá trình nạp firmware vào Kit
Bước 7: Nạp firmware vào Kit: thao tác như bước 2-12 của Bài 3.
464
465
Bài 6: Thực hành giao tiếp với các cảm biến môi trường trên Kit IoT Zigbee
và hiển thị các thông số lên màn hình PC qua phần mềm Hercules
Bước 2: Thêm các thư viện cần thiết vào project như sau
Bước 3: Xây dựng hàm khởi tạo ngoại vi ADC của chip EFR32MG21 để
giao tiếp với cảm biến ánh sáng
void LightSensor_AdcPollingReadHandler(void)
Bước 4: Xây dựng hàm khởi tạo ngoại vi I2C của chip EFR32MG21 để
giao tiếp với cảm biến nhiệt độ - độ ẩm
emberEventControlSetInactive(readValueSensorLightControl);
Bước 5: Xây dựng hàm đọc giá trị cường độ ánh sáng của cảm biến ánh
sáng
uint32_t lux = LightSensor_AdcPollingRead();
5.1: Cho phép ADC0 bắt đầu chuyển đổi đơn

5.2: Đợi ADC0 chuyển đổi dữ liệu xong bằng cách kiểm tra
trạng thái của cờ SINGLEFIFODV
5.3: Đọc dữ liệu chuyển đổi của ADC0
Bước 6: Xây dựng hàm đọc giá trị nhiệt độ của cảm biến Si7020
KalmanTemp = Si7020_MeasureTemp();
Bước 7: Xây dựng hàm đọc giá trị độ ẩm của cảm biến Si7020
KalmanHumi = Si7020_MeasureHumi();
Bước 8: Trước hàm emberAfMainInitCallback gọi các hàm
466
+ Si7020_Init: Khởi tạo cảm biến Si7020
+ LDRInit: Khởi tạo cảm biến ánh sáng
+ emberEventControlSetDelayMS: tạo timer với chu kỳ 5 s cập nhật
giá trị cường độ ánh sáng. Trong hàm callback sử dụng hàm debug
emberAfCorePrintln để hiển thị giá trị cường độ ánh sáng lên màn
hình PC.
+ emberEventControlSetDelayMS: tạo timer với chu kỳ 10 s cập nhật
các giá trị nhiệt độ và độ ẩm. Trong hàm callback sử dụng hàm
debug emberAfCorePrintln để hiển thị giá trị nhiệt độ và độ ẩm lên
màn hình PC.
void emberAfMainInitCallback(void)
{
emberAfCorePrintln("Main Init");
buttonInit(User_buttonPressAndHoldingEventHandler,
User_buttonPressAndHoldEventHandler);
ledInit();
LDRInit();
initI2C();
Si7020_Init();
KalmanFilterInit(2, 2, 0.001); // Initialize Kalman filter
emberEventControlSetDelayMS(readValueSensorLightControl, 1000);
emberEventControlSetDelayMS(ReadValueTempHumiControl,1000);
}
467
468
Bài 7: Thực hành tạo thiết bị Z3Coordinator và Zigbee Router để khởi tạo
mạng
Bước 1: Tạo một project với tên Z3Coordinator như nội dung Bài 1
Bước 2: Tab ZCL Clusters: lựa chọn endpoint cho Coordinator, thông thường,
ZC chỉ sử dụng 1 endpoint duy nhất với ZCL device type là “Zigbee Custom”,
và tick vào hết những clusters muốn ZC hỗ trợ
Bước 3: Tab Zigbee Stack: “Zigbee Device Type” lựa chọn “Coordinator or
Router”, “Security Type” lựa chọn “Zigbee 3.0 Security”
469
Bước 4: Tab Plugins: Tick vào những plugins để phục vụ chính cho ZC như
Lưu ý: Bỏ tích những plugin không dùng như ZLL, Zigbee Green Power
và một số khác giống như đã thực hành trong tài liệu project đầu tiên
+ Network Creator: lựa chọn những kênh tần muốn ZC hỗ trợ
+ Network Creator Security
Bước 5: Tab Bootloader nhớ để None vì chưa dùng
Bước 8: Thao tác tương tự từ Bước 1-7 để tạo thiết bị Zigbee Router
Có thể sử dụng luôn project mẫu Z3LightSoC với CLI được kích hoạt.
Mở Tab Callback
+ Enable PreCommandReceived CallBack để nhận và xử lý bản tin
cluster on/off
470
+ Gọi hàm callback này ra sử dụng phục vụ cho việc xử lý bạn tin On/Off
nhận được
+ Tham khảo lưu đồ thuật toán lập trình
471
Bài 8: Thực hành khởi tạo và gia nhập mạng Zigbee gồm Z3Coordinator và
Zigbee Router
Bước 1: Tạo thiết bị Z3Coordinator và Zigbee Router như nội dung Bài 8
Bước 2: Kết nối thiết bị Z3Coordinator và Zigbee Router với máy tính qua cổng
COM

Kết quả:
472
Bước 5: Mở phần mềm Hercules cho Zigbee Coordinator
Bước 6: trên Zigbee Coordinator: khởi tạo mạng Zigbee sử dụng CLI plugin
network-creator form
473
Bước 7: trên Zigbee Coordinator: dùng câu lệnh info để kiểm tra xem thiết bị
ZC đã tạo mạng thành công hay chưa, và những thông tin mạng
474
Bước 8: trên Zigbee Coordinator: mở gia nhập mạng Zigbee thông qua câu
lệnh: plugin network-creator-security open-network
Bước 9: trên Zigbee Router: cho thiết bị thực hiện công việc tìm kiếm mạng
Zigbee thông qua câu lệnh: plugin network-steering start 0
475
Bước 10: trên Zigbee Router: thực hiện câu lệnh info để kiểm tra thông tin
mạng của thiết bị này, có thể thấy được các thông tin mạng đã trùng với thông
tin mạng được tạo từ Z3Coordinator
Bước 11: Khởi tạo và gia nhập mạng thành công
Quá trình gia nhập mạng
476
Bài 9: Thực hành sử dụng CLI xử lý bài toán giao tiếp giữa các Kit IoT
Zigbee
Bước 3: Xây dựng thêm thiết bị thuộc type HA-Dimmer Switch-2
endpoint: xử lý on/off, level control
Bước 4: Tạo API thực hiện điều chỉnh độ sáng led

4.1. Sử dụng Timer để tạo xung PWM
477
4.2. Ngắt timer và PWM led RGB
478
Bước 5: Điều khiển led khi nhận được bản tin
479
Sơ đồ thuật toán
480
Bước 8: Kết nối thiết bị Z3Coordinator và Zigbee Router với máy tính qua cổng
COM
Bước 9: Khởi tạo mạng: thao tác như bước 5-11 của Bài 8
481
Bài 10: Thực hành xây dựng thiết bị Sleepy End Device
Bước 3: Tạo thiết bị 1 Endpoint kiểu sleepy-end-device
3.1. Cảm biến PIR
3.2. Lựa chọn thiết bị làm Zigbee End-device
482
Bước 4: Xây dựng chương trình
4.1. Xử lý cảm biến PIR
483
4.2. Xử lý timer cho phép phát hiện chuyển động sau 5s
484
4.3. Xử lý timer phát hiện hết chuyển động
485
4.4. Init PIR
4.5. Enable PIR
486
4.6. Xử lý tín hiệu ngắt từ chân cảm biến chuyển động Delay 200ms để tránh
nhiễu
4.7. Xử lý các trạng thái cảm biến chuyển động
4.8. pirHardHandle()
487
488
Bài 11: Thực hành xử lý bài toán Binding trong Zigbee: truyền dữ liệu từ
Zigbee Coordinator tới Zigbee Router – Initiator, sau đó Router – Initiator
đồng bộ tới Zigbee Router – Target.
Bước 2: Tạo 3 thiết bị như nội dung Bài 8
+ Kit thứ 1: Kit làm nhiệm vụ là Zigbee Coordinator
+ Kit thứ 2: Kit làm nhiệm vụ là Zigbee Router – Initiator
+ Kit thứ 3: Kit làm nhiệm vụ là Zigbee Router - Target
Bước 3: Sử dụng phần mềm Hercules để sử dụng CLI
Bước 4: Zigbee Coordinator tiến hành tạo mạng sử dụng câu lệnh:
plugin network-creator form 1 0xABCD 10 11
489
Bước 5: Zigbee Coordinator tiến hành mở mạng cho các thiết bị gia nhập mạng
bằng câu lệnh: plugin network-creator-sercurity open-network
Lưu ý: Nếu muốn đóng mạng không cho phép các thiết bị gia nhập thì
sử dụng câu lệnh: plugin network-creator-security close-network
Bước 6: Cho thiết bị Zigbee Router-Initiator vào mạng dùng câu lệnh:
plugin network-steering start 0
490
Bước 7: Zigbee Coordinator sử dụng câu lệnh: plugin address-table print hiển
thị thông tin các thiết bị trong mạng với node ID và địa chỉ MAC của
từng thiết bị
Ví dụ: Thiết bị 1 Node ID là 0x1C91, địa chỉ MAC: 588E81FFFE970DBE
Bước 8: Cho thiết bị Zigbee Router-target vào mạng dùng câu lệnh:
plugin find-and-bind target 1
491
Bước 9: Khởi tạo thiết bị Initiator tìm kiếm thiết bị Target bằng câu lệnh:
Bước 10: Để Initiator có thể tìm được target của mình

Đầu tiên nó sẽ phải gửi bản tin broadcast có tên là Identify Query
Request
492
Bước 11: Để Initiator có thể tìm được target của mình
Đầu tiên nó sẽ phải gửi bản tin broadcast có tên là Identify Query
Request
Sau khi Target nhận được bản tin Identify Query Request
Nó sẽ phản hồi lại Initiator bản tin Identify Query Response
Complete: 0x00 => Quá trình binding thành công
Sử dụng câu lệnh: option binding-table print
Xem thông tin về bảng binding table
Bước 12: Thực hiện gửi lệnh điều khiển

Gửi lệnh điều khiển ON/OFF từ Initiator
493
Sử dụng câu lệnh:
+ zcl on-off on
+ bsend 1: là câu lệnh sử dụng send trong binding
Bước 13: Kết quả Initiator gửi cho Target
494
Bài 12: Thực hành xử lý bài toán Groups trong Zigbee: tạo group trong mạng
bao gồm 3 thiết bị Zigbee Coordinator, Zigbee Router – Initiator và Zigbee
Router – Target, Zigbee Coordinator truyền dữ liệu từ đồng thời cho cả
Router – Initiator và Zigbee Router – Target.
Bước 2: Tạo 3 thiết bị như nội dung Bài 8
+ Kit thứ 1: Kit làm nhiệm vụ là Zigbee Coordinator
+ Kit thứ 2: Kit làm nhiệm vụ là Zigbee Router – Initiator
+ Kit thứ 3: Kit làm nhiệm vụ là Zigbee Router - Target
Bước 3: Sử dụng phần mềm Hercules để sử dụng CLI
Bước 4: Zigbee Coordinator tiến hành tạo mạng sử dụng câu lệnh:
plugin network-creator form 1 0xABCD 10 11
495
Bước 5: Zigbee Coordinator tiến hành mở mạng cho các thiết bị gia nhập mạng
bằng câu lệnh: plugin network-creator-sercurity open-network
Lưu ý: Nếu muốn đóng mạng không cho phép các thiết bị gia nhập thì
sử dụng câu lệnh: plugin network-creator-security close-network
Bước 6: Tạo group zcl groups add 1 “test” trên Zigbee Coordinator
Bước 7: Thêm các thiết bị vào Group:

7.1. Trên Zigbee Coordinator sử dụng câu lệnh: plugin address-table print
496
7.2. Lấy node ID của thiết bị để thêm vào nhóm
7.3. Sử dụng câu lệnh: send 0x1C91 1 1 Thêm thiết bị

+ nodeID: 0x1C91
+ Endpoint: 1
+ GroupID: 1
7.4. Tương tự như thiết bị 1 thêm thiết bị 2 vào group
Bước 8: Thực hiện gửi lệnh điều khiển

Gửi lệnh điều khiển ON/OFF từ Zigbee Coordinator toiws 2 thiết bị trong
group
Sử dụng Zigbee Coordinator để gửi lệnh ON/OFF đến nhóm
+ Gửi lệnh ON LED đến Group.
+ Sử dụng câu lệnh gửi bản tin ON đến thiết bị zcl on-off on
+ send_multicast 1 1
497
Bước 13: Kết quả Zigbee Coordinator để gửi lệnh cho Initiator và Target
498
TÀI LIỆU THAM KHẢO
[1] Tài liệu giới thiệu Kit IoT STM 32: https://drive.google.com/file/ Kit IoT STM32
[2] Tài liệu giới thiệu Kit IoT Zigbee: https://drive.google.com/file/ Kit IoT Zigbee
[3] Tài liệu giới thiệu vi điều khiển STM 32: https://drive.google.com/file/ STM32
[4] Tài liệu giới thiệu phần mềm STM 32: https://drive.google.com/file/ STM 32
[5] Tài liệu hướng dẫn nạp code vào Kit IoT STM32:
https://drive.google.com/file/nạp Kit IoT STM32
[6] Tài liệu giới thiệu phần mềm Simple Studio: https://drive.google.com/file/
Simple Studio
[7] Tài liệu hướng dẫn nạp code vào Kit IoT Zigbee:
https://drive.google.com/file/nạp Kit IoT Zigbee
499
PHỤ LỤC
1. Bố cục bài thực hành
- Nội dung thực hành
- Yêu cầu thực hành
- Thiết bị thực hành
- Thời gian thực hành
- Số lượng sinh viên thực hành
- Các bước thực hành
- Báo cáo kết quả thực hành
- Đánh giá
- Tài liệu thamkhảo
500
2. Phiếu bàn giao thiết bị thực hành
Tên bài: ……………………………………………………………………………...
Họ và tên sinh viên……………………………Mã sinh viên……………………...
………………………………………………………………..……………………...
Nhóm…………………..Lớp……………… ..Ngày…..tháng…..năm…………..
Giảng viên hướng dẫn…………………………Ca thực tập……………………….
Trạng thái trước lúc Trạng thái sau

Stt Tên thiết bị Số lượng
bàn giao thực hành
1
2
3
4
5
6
Sinh viên Giảng viên
(ký ghi rõ họ tên) (ký ghi rõ họ tên)
501
3. Phiếu báo cáo kết quả thực hành (Sinh viên)
Tên bài: ……………………………………………………………………………...
………………………………………………………………..……………………...
Nhóm…………………..Lớp……………… ..Ngày…..tháng…..năm…………..
Giảng viên hướng dẫn……………………… Ca thực tập……………………….
Nội dung Mức độ Thời gian Đánh giá kết quả

Stt
thực hành hoàn thành (%) hoàn thành (100)
1
2
3
Thảo luận sinh viên:
Sinh viên
(ký ghi rõ họ tên)
502
4. Phiếu đánh giá kết quả thực hành (Giảng viên)
Tên bài: ……………………………………………………………………………...
Nhóm…………………..Lớp…………………Ngày…..tháng…..năm…………..
Giảng viên hướng dẫn………………………….Ca thực tập……………………….
Thứ Điểm Ghi

Nội dung đánh giá Yêu cầu
tự chuẩn chú
- Làm quen với hệ thống nhúng
1 10 -Thành thạo
IoT
- Tìm hiểu nắm rõ nguyên lý đấu
2 nối các thiết bị trên Kit IoT 20 -Thành thạo
STM32
- Phần mềm cho hệ thống nhúng
3 10 -Thành thạo
IoT
- Cách thức nạp code vào Kit IoT
4 20 -Thành thạo
STM32 của hệ thống nhúng IoT
-Lắp ráp sơ đồ mạch đo và kết nối -Đúng sơ đồ
5 10
các thiết bị với máy tính - Gọn gàng khoa học
- Đúng sơ đồ
6 -Thiết lập thông số thiết bị 10
-Đúng trình tự nguyên tắc
- Áp dụng các công thức
7 -Đọc và phân tích kết quả đo 10
- Tính toán đúng kết quả
8 -Viết báo cáo 10 - Gọn gàng khoa học
Tổng điểm:
Nhận xét giảng viên:
Giảng viên
503

Tài Liệu Lab Iot

Uploaded by

Copyright:

Available Formats

You might also like

Tài Liệu Lab Iot

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tài Liệu Lab Iot

Uploaded by

Copyright:

Available Formats

HỌC VIỆN CÔNG NGHỆ BƯU CHÍNH VIỄN THÔNG

KHOA VIỄN THÔNG 1

TÀI LIỆU LAB IoT

Bài 1: Thực hành tạo project bằng phần mềm STM32CubeIDE…………...............95

Bài 12: Thực hành xử lý bài toán Groups trong Zigbee........................................495

3.Các dự án & sản phẩm thực tế tại lab

Project 7: Dự án kết hợp và sử dụng Command Line Interface để xử lý bài toán

2. Phiếu bàn giao thiết bị thực hành (Sinh viên)

3. Phiếu báo cáo kết quả thực hành (Sinh viên)

4. Phiếu đánh giá kết quả thực hành (Giảng viên)

Khối thiết bị thu Zigbee

Hình 1.1 Sơ đồ khối hệ thống thiết bị phòng lab IoT

10 Switch Tp-Link 01 32 cổng Viettel Chia cổng mạng

11 Hộp kỹ thuật 01 Bảo vệ các thiết bị

Hình 1.2 3D mặt trước Kit IOT STM32

Hình 1.3 3D mặt sau Kit IOT STM32

Hình 1.5 Layout mặt sau Kit IOT STM32

Hình 1.6 Sơ đồ khối Kit IOT STM 32

Hình 1.7 Sơ đồ nguyên lý của thiết bị KIT IOT STM32

- Dải đo độ ẩm: 0 - 80% RH,

+ Dải đo nhiệt độ: -10 - 85℃,

- Kích thước: 1.44 inches.

Hình 1.8 Kit Nucleo STM32F401RE

Hình 1.9 Vi điều khiển STM32 trên kit IoT

Hình 1.10 Chức năng vi điều khiển STM32

Hình 1.11 Cấu trúc vi điều khiển STM32

+ Dải đo nhiệt độ: -10 - 85℃, dung sai 土 0.4℃.

Hình 1.12 Cảm biến nhiệt độ - độ ẩm SI7020

Quang trở GL5537:

Hình 1.14 Quang trở GL5537

Hình 1.16 Loa – Buzzer

Hình 1.19 Nguyên lý màn hình LCD

Hình 1.20 Sơ đồ nguyên lý chân kết nối

Hình 1.21 LED RGB

Hình 1.23 3D mặt trước Kit IOT Zigbee

Hình 1.25 Layout mặt trước Kit IOT Zigbee

b) Cấu tạo phần cứng

Hình 1.27 Sơ đồ khối Kit IOT Zigbee

- Dải đo độ ẩm: 0 - 80% RH,

+ Dải đo nhiệt độ: -10 - 85℃,

- Kích thước: 1.44 inches.

Khối cấp nguồn:

Hình 1.29 Sơ đồ nguyên lý khối cấp nguồn

Hình 1.30 Vi điều khiển EFR32MG21

Hình 1.31 Sơ đồ nguyên lý vi điều khiển EFR32MG21

+ Dải đo độ ẩm: -10-85℃, dung sai 土 0.4℃.

Hình 1.32 Cảm biến nhiệt độ - độ ẩm Si7020

Hình 1.33 Sơ đồ nguyên lý cảm biến nhiệt độ, độ ẩm Si7020

Hình 1.34 Cảm biến từ Si7210

Hình 1.35 Sơ đồ nguyên lý cảm biến từ Si7210

Hình 1.36 Nguyên lý hoạt động PIR

Hình 1.37 Cảm biến chuyển động PIR

Hình 1.38 Sơ đồ nguyên lý cảm biến PIR

Hình 1.39 LED RGB

Hình 1.40 Sơ đồ nguyên lý LED RGB

Hình 1.41 Sơ đồ nguyên lý USB to COM

Hình 1.42 Quang trở GL5537

Hình 1.43 Sơ đồ chân của mạch nạp J-Link V9

Hình 1.44 Sơ đồ chân nạp của Kit