Contents

I. Dự án:..................................................................................................................................................2
1. Giới thiệu:........................................................................................................................................2
2. Yêu cầu:...........................................................................................................................................3
3. Nhiệm vụ:........................................................................................................................................3
3.1. Tổng quan:...............................................................................................................................3
3.2. Phát triển hệ thống nhúng:.......................................................................................................4
3.3. Mô hình học máy:....................................................................................................................5
3.4. Giao diện back-end:.................................................................................................................6
3.5. Phát triển ứng dụng di động:....................................................................................................7
II. Nội dung công việc:.............................................................................................................................7
1. Thiết lập board Bo mạch DISCO-L475VG-IOT01A:......................................................................7
2. Nền tảng Arm Pelion:......................................................................................................................7
3. Lựa chọn, tìm hiểu và triển khai mô hình machine learning:...........................................................8
4. Thiết kế back-end:...........................................................................................................................8
5. Phát triển ứng dụng di động:............................................................................................................8
III. Kiến trúc IoT của dự án:..................................................................................................................8
1. Thiết bị Cảm biến và Thiết bị Kết nối:............................................................................................8
2. Mạng IoT:........................................................................................................................................8
3. Nền tảng quản lý thiết bị:.................................................................................................................9
4. Cloud Computing:...........................................................................................................................9
5. Mô hình machine learning:..............................................................................................................9
6. Giao diện back- end:........................................................................................................................9
7. Ứng dụng và Giao diện Người dùng:...............................................................................................9
Đề Thi cuối kì
Môn học: HTN & iOT
Internet of Things Course
Final Project
Wearable Activity Tracker

I. Dự án:
1. Giới thiệu:
Trong bài thực hành cuối cùng này, bạn sẽ thiết kế một hệ thống Internet of Things
(IoT) đầy đủ để phân loại theo thời gian thực của các hoạt động của người dùng. Bạn
sẽ sử dụng bảng IoT với cảm biến gia tốc và con quay hồi chuyển, đám mây nền tảng
nơi bạn có thể khởi tạo máy ảo (ví dụ: Google Cloud Platform) và Android điện thoại
di động. Dự án bao gồm một loạt các nhiệm vụ độc lập trên nhiều nền tảng, bao gồm:
 Phát triển firmware cho hệ thống nhúng.
 Thu thập kết quả đo cho các hoạt động khác nhau (đi bộ, chạy, v.v.).
 Đào tạo và triển khai các thuật toán học máy phù hợp để phát hiện chuyển
động.
 Phát triển giao diện web back-end và cơ sở dữ liệu liên quan.
  Thiết kế các chương trình truyền thông mạng mạnh mẽ.
 Phát triển ứng dụng di động.
Khi kết thúc bài thực hành này, bạn sẽ có một nguyên mẫu hoạt động của một hệ
thống có thể phân loại các loại hoạt động khác nhau với độ trễ không đáng kể và
hiển thị kết quả trên giao diện người dùng di động.
2. Yêu cầu:
Trong phần thực hành này, bạn sẽ sử dụng phần cứng và nền tảng sau:
• Bo mạch DISCO-L475VG-IOT01A có con quay hồi chuyển, gia tốc kế và Wi-Fi
tích hợp máy thu phát
• Nền tảng quản lý thiết bị Arm Pelion
• Nền tảng đám mây (ví dụ: Google Cloud Platform - GCP)
• Điện thoại thông minh Android (ví dụ: Motorola Moto G7)
Không có hạn chế cụ thể nào về phần mềm (máy chủ web, cơ sở dữ liệu, máy móc
khuôn khổ và kế hoạch truyền thông) bạn nên sử dụng để có đủ sự linh hoạt trong
thiết kế dự án, cũng như không gian cho sự sáng tạo. Tuy nhiên, chúng tôi liệt kê dưới
đây một số tùy chọn phổ biến bạn có thể muốn xem xét:
• Máy chủ web: Django, Flask, Node.js, PHP
• Cơ sở dữ liệu: MySQL, SQLite, SQL server, Firebase
• Thư viện mã nguồn : TensorFlow, PyTorch, MXNet
Xin lưu ý rằng bạn có thể tự do lựa chọn các giải pháp phần mềm khác miễn là chúng
có thể giúp ích cho bạn đạt được các nhiệm vụ được mô tả dưới đây.
3. Nhiệm vụ:
3.1. Tổng quan:
Hình 1 bên dưới minh họa cấp cao về hệ thống IoT mà bạn sẽ phát triển. Bo mạch
DISCOL475VG-IOT01A hoạt động như một thiết bị đeo được, có thể thu được số
đọc cảm biến và định kỳ gửi chúng đến nền tảng Arm Pelion thông qua kết nối Wi-Fi.
Dịch vụ đám mây có được việc đọc sẽ cập nhật và suy đoán hoạt động hiện tại của
người dùng dựa trên thư viện mã nguồn được lấy mẫu từ trước. Cuối cùng, người
dùng có thể xem số liệu thống kê tương ứng trong ứng dụng di động bằng cách truy
vấn API web.
Nhiệm vụ được chia thành nhiều nhiệm vụ như sau:
1. Phát triển hệ thống nhúng và giao tiếp với Arm Pelion
2. Lựa chọn, tìm hiểu và triển khai mô hình machine learning
3. Thiết kế back-end
4. Phát triển ứng dụng di động
Bốn nhiệm vụ được mô tả chi tiết trong phần còn lại của phần này.
3.2. Phát triển hệ thống nhúng:
Trong bài tập này, chúng tôi sẽ sử dụng lại bo mạch DISCO-L475VG-IOT01A, tương
thích với
Hệ điều hành Mbed. Bắt đầu bằng cách làm theo hướng dẫn tại
https://os.mbed.com/guides/connect-device-to-pelion/. Sau khi hoàn thành phần
hướng dẫn, bạn sẽ có một dự án mẫu trong trình biên dịch trực tuyến của mình, bao
gồm thư viện Wi-Fi cho phép bo mạch IoT của bạn kết nối với điểm phát sóng Wi-Fi
cá nhân. Tuy nhiên, để có được số đọc từ các cảm biến, bạn cần xác định mô-đun chip
trên bo mạch của mình và nhập các thư viện liên quan vào trình biên dịch của bạn.
Bạn có thể tìm thấy các thư viện liên quan đến cảm biến tại
https://os.mbed.com/code/. Tương tự, dự án ví dụ cho thấy cách kết nối và gửi dữ liệu
từ bảng đến Pelion hệ thống quản lý:
M2MObjectList m2m_obj_list;
// GET resource 3000/0/5701
m2m_get_res = M2MInterfaceFactory::create_resource(m2m_obj_list, 3000, 0,
5701, M2MResourceInstance::INTEGER, M2MBase::GET_ALLOWED);
cloud_client->add_objects(m2m_obj_list);
m2m_get_res->set_value();
Đoạn mã này liên kết một tài nguyên (bất kỳ giá trị nào) với đường dẫn web
/3000/0/5701. Con đường có thể được được chỉ định ngẫu nhiên. Mọi cập nhật tài
nguyên đều có thể được đẩy lên nền tảng Pelion thông qua các giao thức M2M, bằng
 cách gọi hàm set_value() và bạn có thể xem các bản cập nhật đồng thời tại
https://portal.mbedcloud.com/devices/list. Các API do Arm cung cấp sẽ hữu ích trong
việc triển khai truyền thông mạng
https://www.pelion.com/docs/device-management/current/mbedclient/class_m2_m_re
source.html
Trong dự án này, tài nguyên mà bạn sẽ sử dụng là các số liệu từ con quay hồi chuyển
và gia tốc kế. Bạn nên cẩn thận về số lượng tài nguyên bạn cần tạo, từ góc độ của cả
chi phí truyền thông và việc sử dụng API. Ở giai đoạn này, bạn có thể chưa quen với
API Pelion.
3.3. Mô hình học máy:
Để đạt được sự nhận dạng hoạt động, bạn sẽ tận dụng sức mạnh của máy học. Bạn có
thể sử dụng tập dữ liệu sau trên Kaggle: https://www.kaggle.com/vmalyi/run-or-walk,
trong đó có dữ liệu cảm biến được thu thập trước đó từ gia tốc kế và con quay hồi
chuyển. Tài liệu trong đó giải thích cách thu thập dữ liệu và mô hình nào được sử
dụng để đào tạo. Bạn được khuyến khích đọc qua các bài đăng, trong trường hợp bạn
có thể hy vọng thu thập thêm dữ liệu sau này mà còn nếu bạn muốn nâng cao độ tin
cậy của mô hình hoặc đa dạng hóa việc phát hiện kịch bản. Ngay cả khi bạn không
muốn làm như vậy, các bài viết gốc vẫn chứa một gợi ý quan trọng về đơn vị đo
lường được sử dụng để biểu diễn dữ liệu cảm biến, không được ghi rõ ràng trong tập
dữ liệu. Tuy nhiên, bạn không nên sử dụng mô hình tương tự như đề xuất của tác giả
tương ứng. Bạn có thể thấy rằng phương pháp của anh ấy đã/không thể sử dụng các số
đọc từ tất cả các trục. Đây là một điều quan trọng điểm: bạn nên cố gắng hết sức để
đảm bảo rằng mô hình của bạn có thể khái quát hóa tốt theo nhiều kịch bản thử
nghiệm nghiêm ngặt. Để đạt được điều này, bạn cần làm cho mô hình học tập của
mình trở nên hữu ích càng nhiều càng tốt thông tin nhất có thể. Về mặt thiết kế mô
hình, bạn có thể xem xét khía cạnh sau để đảm bảo mô hình của bạn đạt được hiệu
suất tốt:
1.Tận dụng thông tin tạm thời. Rõ ràng, phát hiện chuyển động là một nhiệm vụ nhận
dạng mẫu trên dữ liệu đa chiều theo chuỗi thời gian. Nói cách khác, nhiệm vụ này nhạy
cảm với thời gian, vì vậy bạn cần phải đảm bảo rằng mô hình có thể tìm hiểu các mối
tương quan thời gian từ tập dữ liệu. Đối với một số nhiệm vụ nhạy cảm với thời gian
(ngay cả đối với nhiệm vụ này), có thể một mô hình không nhạy cảm với thời gian có thể
thể hiện hiệu suất hợp lý. Tuy nhiên, hãy lưu ý rằng nếu mô hình của bạn không trích
xuất/tìm hiểu mối tương quan thời gian từ tập dữ liệu, bạn chỉ có thể thu được những hiểu
biết hạn chế.
2. Giữ mọi thứ nhẹ nhàng. Theo dõi hoạt động không phải là một nhiệm vụ học tập
khó khăn đòi hỏi hàng ngàn thông số và ngày đào tạo. Khi thiết kế một mô hình, bạn
nên bắt đầu từ giải pháp đơn giản nhất và dần dần thêm các khối vào đó, thay vì đi
thẳng vào mô hình học sâu phức tạp. Mặc dù tất cả các tính toán có thể đạt được trong
cloud, bạn không nên sử dụng nhiều hơn mức bạn cần. Các mô hình khác nhau theo
mặc định sẽ sử dụng các nguồn tài nguyên khác nhau. Bạn có thể nghĩ đến những câu
hỏi sau đây trước khi bắt đầu: Có tốt hơn không nếu hãy chọn một mẫu phức tạp sẽ
đạt được hiệu suất xuất sắc nhưng có nhiều tham số và yêu cầu nhiều dữ liệu để huấn
luyện hoặc chọn mô hình có ít tham số hơn có thể được đào tạo trong một đợt? Bạn
coi trọng tài nguyên tính toán hoặc bộ nhớ hơn tài nguyên? Bạn có muốn mô hình của
mình đưa ra những diễn giải xác suất hay không?

3.4. Giao diện back-end:

Ngoài nền tảng quản lý thiết bị Pelion, bạn có thể lấy số đo theo thời gian thực thông
qua
Pelion SDK, có sẵn bằng nhiều ngôn ngữ lập trình (Python, Java, Javascript và C#).
Bạn có thể tìm thấy tài liệu đầy đủ tại:
https://www.pelion.com/docs/devicemanagement/current/mbed-cloud-sdk-
references/index.html. Đối với hoạt động liên lạc giữa thiết bị và nền tảng Pelion, điều
quan trọng là phải quyết định tần số cũng như tốc độ lấy mẫu thích hợp. Cứ sau 20
giây sẽ có độ trễ lớn và bạn có thể mất thông tin quan trọng về mặt thời gian khi đọc
100 lần mỗi giây sẽ tạo ra nhiều lưu lượng truy cập và có thể tỏ ra không cần thiết. Vì
vậy, bạn sẽ cần phải thực hiện một số thí nghiệm thăm dò đầu tiên.
Khi bạn đã đào tạo mô hình học máy của mình, bạn cần phát triển một máy chủ web
1. Đưa ra dự đoán định kỳ, dựa trên kết quả đọc từ nền tảng Pelion.
2. Lưu trữ dự đoán trên Đám mây (trong cơ sở dữ liệu).
3. Tạo API web để gọi khi người dùng muốn xem dự đoán theo thời gian thực.
4. Tạo API web để gọi khi người dùng muốn xem hồ sơ hoạt động lịch sử của họ.
Tất nhiên, bạn có thể thêm nhiều chức năng hơn cho cả logic máy chủ và thiết kế di
động của mình để hoạt động tốt hơn. khả năng sử dụng. Như đã giải thích ở trên, máy
chủ web cần thực hiện đồng thời ít nhất ba tác vụ:
1. Lắng nghe và trả lời các yêu cầu HTTP;
2. Chờ đợi các bài đọc mới và đưa ra dự đoán dựa trên những bài đọc đó; Và
3. Thực hiện các thao tác với cơ sở dữ liệu.
Bạn cần thiết kế cẩn thận logic của máy chủ để tránh những lỗi không mong muốn,
chẳng hạn như dữ liệu ghi đè và bế tắc, chỉ kể tên một số.
3.5. Phát triển ứng dụng di động:
Bạn nên sử dụng điện thoại thông minh Android mà bạn nên phát triển ứng dụng di
động để hiển thị thông tin liên quan được lấy từ đám mây. Android Studio là công cụ
dễ tiếp cận nhất dành cho phát triển một ứng dụng và bạn có thể tự do chọn Java hoặc
Kotlin làm ngôn ngữ lập trình. Nếu bạn là quen thuộc hơn với JavaScript, có một số
khung công tác JS dành cho thiết bị di động mà bạn cũng có thể chọn, chẳng hạn như
Cordova và NativeScript. Nếu bạn đang sử dụng Android Studio, khuyến nghị là sử
dụng Volley, thư viện HTTP được phát triển bởi Google, để liên lạc với dịch vụ đám
mây. Thông tin thêm về Volley có thể được được tìm thấy tại
https://developer.android.com/training/volley . Android nghiêm cấm việc sử dụng
nhiều I/O các hoạt động, chẳng hạn như kết nối mạng, chạy trong luồng giao diện
người dùng (đó là luồng chính). Thông thường, Các yêu cầu HTTP được gói trong
một lớp Asyntask và cần phải xác định hàm gọi lại. ảnh hưởng rất lớn đến năng suất.
Volley cung cấp các API tiện lợi cho nhiều yêu cầu HTTP khác nhau có thể giảm
đáng kể số lượng mã.
Không có yêu cầu cụ thể nào về thiết kế của ứng dụng dành cho thiết bị di động,
nhưng nhìn chung thì nên có các chức năng sau:
1. Hiển thị các dự đoán theo thời gian thực được lấy từ đám mây;
2. Hiển thị lịch sử các bản ghi hoạt động được lưu trữ trong cơ sở dữ liệu trên đám
mây;
3. Đảm bảo người dùng có thể tương tác với ứng dụng một cách trơn tru và mã không
có lỗi.
Giao diện người dùng và hình ảnh động hấp dẫn cũng rất được khuyến khích.
II. Nội dung công việc:
1. Thiết lập board Bo mạch DISCO-L475VG-IOT01A:
 Thiết lập bo mạch để thu thập dữ liệu từ con quay hồi chuyển, gia tốc kế có
sẵn trong bo mạch.
 Thiết lập kết nối wifi trong bo mạch để gởi dữ liệu lên nền tảng Arm
Pelion.
 Gởi dữ liệu lên Pelion.
2. Nền tảng Arm Pelion:
 Đăng ký và Tạo Một Dự Án trên Pelion:
Truy cập trang Pelion Device Management Portal.
Đăng ký tài khoản và tạo một dự án mới.
 Lấy thông tin kết nối từ Pelion:
Trong dự án của bạn, lấy thông tin như Device ID, API Key, và Endpoint.
 Sửa Code để Kết Nối với Pelion:
Sử dụng thông tin kết nối lấy được để cấu hình kết nối với nền tảng Pelion
trong mã nguồn của bạn.

 Xem Dữ Liệu Từ Bo Mạch:

Sử dụng giao diện Pelion để theo dõi giá trị cảm biến từ bo mạch của bạn.
 Chạy Project và Kiểm Tra:
Biên dịch và nạp chương trình lên bo mạch.
Kiểm tra kết nối và theo dõi giá trị cảm biến trên trang Pelion Device
Management Portal.
3. Lựa chọn, tìm hiểu và triển khai mô hình machine learning:

4. Thiết kế back-end:
Nt

5. Phát triển ứng dụng di động:

III. Kiến trúc IoT của dự án:

1. Thiết bị Cảm biến và Thiết bị Kết nối:
Bộ công cụ Discovery B-L475E-IOT01A cho nút IoT cho phép người dùng
phát triển các ứng dụng có kết nối trực tiếp với máy chủ đám mây. Bộ
Discovery cho phép ứng dụng đa dạng bằng cách khai thác khả năng giao tiếp
tiêu thụ điện năng thấp, cảm biến đa đường và các tính năng STM32L4 dựa
trên lõi ARM® Cortex® -M4. Sự hỗ trợ cho kết nối Arduino Uno V3 và
PMOD cung cấp khả năng mở rộng không giới hạn với nhiều lựa chọn về bảng
bổ trợ chuyên dụng.
Thiết bị cảm biến: Gia tốc kế 3D và con quay hồi chuyển 3D (LSM6DSL)
2. Mạng IoT:
Mạng IoT (Internet of Things Network) là một hệ thống liên kết các thiết bị kết
nối trong Internet of Things (IoT). Mục tiêu của mạng IoT là kết nối và thu thập
dữ liệu từ các thiết bị cảm biến và thiết bị thông minh để chúng có thể tương tác
với nhau và với hạ tầng mạng để cung cấp các dịch vụ và ứng dụng thông minh.
Dự án sử dụng giao thức M2M của Pelion để truyền tải dữ liệu từ thiết bị đến nền
tảng quản lý thiết bị.
Xác định tần suất và tốc độ lấy mẫu phù hợp để tránh độ trễ lớn và giảm lưu lượng
truy cập không cần thiết.
3. Nền tảng quản lý thiết bị:
Sử dụng nền tảng quản lý thiết bị Arm Pelion để kết nối và quản lý các thiết bị
IoT.
4. Cloud Computing:
Sử dụng nền tảng đám mây, ví dụ như Google Cloud Platform (GCP), để lưu trữ
dữ liệu, triển khai mô hình machine learning và cung cấp các dịch vụ back-end.
5. Mô hình machine learning:
Phát triển và triển khai mô hình machine learning để phân loại các hoạt động của
người dùng dựa trên dữ liệu từ cảm biến.
6. Giao diện back- end:
Thiết kế back-end để lắng nghe và trả lời yêu cầu HTTP từ thiết bị IoT.
Lưu trữ dữ liệu dự đoán và lịch sử hoạt động trong cơ sở dữ liệu.

7. Ứng dụng và Giao diện Người dùng:

Phát triển ứng dụng di động trên nền tảng Android sử dụng Android Studio.
Sử dụng thư viện Volley để liên lạc với dịch vụ đám mây và hiển thị thông tin liên
quan từ dự đoán và lịch sử hoạt động.