Báo cáo mạng cảm biến dùng module lora SX1278 (UART) (Có code mẫu và sơ đồ chi tiết)
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (1.85 MB, 34 trang )
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Thiết kế mạng cảm biến không dây dùng module lora
1) TÓM TẮT
Đồ án thực hiện nhằm mục tiêu thiết kế được ứng dụng mạng cảm biến không dây dùng
module lora. Lợi ích của việc sử dụng module lora không dây là có thể truyền dữ liệu với
khoảng cách lên hàng km mà không cần các mạch khuếch đại công suất từ đó giúp tiết
kiệm năng lượng tiêu thụ khi truyền/nhận dữ liệu ít tốn sức người, tiết kiệm thời gian. Đồ
án sử dụng chip SX1278 của hãng Semtech (hoạt động ở tần số 410 – 441 Mhz). Thực
hiện thiết kế một hệ thống gồm 2 phần chính: Node và server. Node (arduino) thu thập
các thông số nhiệt độ từ cảm biến LM35 và gửi về server để quản lý thông qua công nghệ
lora, node và server cùng xử lý 2 tác vụ là truyền và nhận gói tin. Node thì truyền (phản
hồi) khi đã nhận được gói tin từ server. Server thì thực hiện việc gửi lệnh và nhận dữ liệu
phản hồi từ client (tại đây ta có thể làm mọi điều với dữ liệu nhận được). Cùng với sự tìm
tòi, học hỏi không ngừng của nhóm để tạo thành một khối có chức năng điều khiển và
thực hiện lệnh truyền nhận được giữa các client với server. Kết quả nghiên cứu là mô
hình có thể thực hiện lệnh từ xa truyền nhận theo ý người dùng muốn mà ở đây cụ thể là
truyền nhận giữa các client và server với nhau thông qua việc điều khiển bằng các button
(nút nhấn) và quan sát các kết quả trả về thông qua trình theo dõi serial (serial monitor)
của trình biên dịch Arduino IDE hoặc cũng có thể thực hiện gửi lệnh từ chính cửa sổ này.
Đồ án đạt yêu cầu thiết kế ứng dụng mạng cảm biến không dây dùng module LoRa để
đọc giá trị cảm biến từ xa.
Từ khóa: Module lora, mạng cảm biến không dây, iot
ABSTRACT
The project aims to design a wireless sensor network application using the module lora.
The benefit of using the wireless module lora is that it can transmit data at distances up to
kilometers without the need for power amplifiers, thereby saving energy consumption
when transmitting / receiving data, less labor-intensive, saving time. This project uses
Semtech SX1278 chip (operating at frequencies 410 - 441 Mhz).The implementation of a
system design consists of two main parts: Node and server. The node (arduino) collects
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
temperature parameters from the LM35 sensor and sends it to the server to manage
through the lora technology, the node and the server together handle the two tasks of
transmitting and receiving packets. The node transmits (responds) when the packet has
been received from the server. The server sends the command and receives response data
from clients (here we can do everything with the data received). My group has designed
a block that controls and executes commands received between clients and the server.
The research result is that the model can execute remote commands at the discretion of
the user (namely, transmitting between clients and servers together through control
buttons) and observing the returned results via the Serial Monitor of the Arduino IDE
compiler, or you can also send commands from this window. This project meets the
requirements of designing a wireless sensor network using module lora to read remote
sensor values.
Keywords: Module lora, wireless sensor network, iot
Title: Wireless sensor network design uses lora module
2) GIỚI THIỆU
LoRa là viết tắt của Long Range Radio được nghiên cứu và phát triển bởi Cycleo và sau
này được mua lại bởi công ty Semtech năm 2012. Với công nghệ này, chúng ta có thể
truyền dữ liệu với khoảng cách lên hàng km mà không cần các mạch khuếch đại công
suất; từ đó giúp tiết kiệm năng lượng tiêu thụ khi truyền/nhận dữ liệu. Do đó, LoRa có
thể được áp dụng rộng rãi trong các ứng dụng thu thập dữ liệu như sensor network trong
đó các sensor node có thể gửi giá trị đo đạc về trung tâm cách xa hàng km và có thể hoạt
động với battery trong thời gian dài trước khi cần thay pin.
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Nguyên lý hoạt động của LoRa ra sao?
LoRa sử dụng kỹ thuật điều chế gọi là Chirp Spread Spectrum. Có thể hiểu nôm na
nguyên lý này là dữ liệu sẽ được băm bằng các xung cao tần để tạo ra tín hiệu có dãy tần
số cao hơn tần số của dữ liệu gốc (cái này gọi là chipped); sau đó tín hiệu cao tần này tiếp
tục được mã hoá theo các chuỗi chirp signal (là các tín hiệu hình sin có tần số thay đổi
theo thời gian; có 2 loại chirp signal là up-chirp có tần số tăng theo thời gian và downchirp có tần số giảm theo thời gian; và việc mã hoá theo nguyên tắc bit 1 sẽ sử dụng upchirp, và bit 0 sẽ sử dụng down-chirp) trước khi truyền ra anten để gửi đi.
Theo Semtech công bố thì nguyên lý này giúp giảm độ phức tạp và độ chính xác cần thiết
của mạch nhận để có thể giải mã và điều chế lại dữ liệu; hơn nữa LoRa không cần công
suất phát lớn mà vẫn có thể truyền xa vì tín hiệu Lora có thể được nhận ở khoảng cách xa
ngay cả độ mạnh tín hiệu thấp hơn cả nhiễu môi trường xung quanh.
Băng tần làm việc của LoRa từ 430MHz đến 915MHz cho từng khu vực khác nhau trên
thế giới:
430MHz cho châu Á
780MHz cho Trung Quốc
433MHz hoặc 866MHz cho châu Âu
915MHz cho USA
Nhờ sử dụng chirp signal mà các tín hiệu LoRa với các chirp rate khác nhau có thể hoạt
động trong cùng 1 khu vực mà không gây nhiễu cho nhau. Điều này cho phép nhiều thiết
bị LoRa có thể trao đổi dữ liệu trên nhiều kênh đồng thời (mỗi kênh cho 1 chirprate)
Radio packet của LoRa như hình sau:
Các dữ liệu trong 1 radio packet của LoRa, bao gồm:
Preamble: Là chuỗi binary để bộ nhận detect được tín hiệu của LoRa packet trong
không khí
Header: chứa thông tin về size của Payload cũng như có PayloadCRC hay không.
Giá trị của Header cũng được check CRC kèm theo
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Payload: là dữ liệu ứng dụng truyền qua LoRa
Payload: giá trị CRC của Payload. Nếu có PayloadCRC, LoRa chip sẽ tự kiểm tra
dữ liệu trong Payload và báo lên nếu CRC OK hay không.
Lý do thực hiện đề tài: Nhằm làm quen với công nghệ truyền từ xa và ứng dụng được
một số các chức năng của module lora để có thể phát triển mở rộng ra các ứng dụng từ đó
áp dụng thực tế vào cuộc sống hằng ngày.
Nghiên cứu liên quan mạng cảm biến không dây dùng module: Có thể phát triển thêm
để ứng dụng vào hệ thống tưới cây thông minh, báo cháy thông minh, điều khiển tự động
từ xa, ngôi nhà thông minh, iot…
Kết quả mong muốn: Truyền nhận giữa các Node và Server thuận lợi (không có lỗi
ngoài ý muốn), phát triển thêm việc ứng dụng lora vào trong việc điều khiển xe mô hình
nhằm có thể giúp việc quản lý vị trí của các Node một cách tự động
Các bước thực hiện:
+ Tìm hiểu công nghệ Lora và các linh kiện cần thiết sử dụng trong đề tài
+ Tham khảo tài liệu (Datasheet, Internet,… )
+ Hỏi giáo viên hướng dẫn về những khó khăn gặp phải trong quá trình làm đồ án
+ Thiết kế giải thuật, phần cứng của Node và Server
+ Sau khi thực hiện truyền nhận được giữa hai Module thì tiến hành đọc cảm biến và
hoàn thành đồ án
+ Đưa ra được hướng phát triển và tài liệu tham khảo
Tài liệu tham khảo:
/> /> /> /> />
3) PHƯƠNG PHÁP THỰC HIỆN
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
3.1) Thiết kế phần cứng:
3.1.1) Kit Arduino Nano và Kit Arduino Uno R3
Giới thiệu tổng quan:
Board Arduino Nano có cấu tạo, số lượng chân vào ra là tương tự như board Arduino Uno
tuy nhiên đã được tối giản về kích thước cho tiện sử dụng hơn. Do được tối giản rất nhiều
về kích thước nên Arduino Nano chỉ được nạp code và cung cấp điện bằng duy nhất 1
cổng mini USB
Board Arduino Nano
Thông số kĩ thuật chi tiết:
+ Vi xử lý
+ Điện áp hoạt động
+ Điện áp đầu vào (khuyến nghị)
+ Điện áp đầu vào (giới hạn)
+ Chân vào/ra số
+ Chân vào tương tự
+ Dòng điện mỗi chân vào/ra
+ Bộ nhớ
ATmega328 (phiên bản v3.0)
5V
7-12 V
6-20 V
14 (6 chân có khả năng xuất ra tín hiệu PWM)
8
40 mA
16 KB (ATmega168), 32 KB (ATmega328) trong đó
+ SRAM
+ EEPROM
+ Xung nhịp
2 KB dùng để nạp bootloader
1 KB (ATmega168) hoặc 2 KB (ATmega328)
512 bytes (ATmega168) hoặc 1 KB (ATmega328)
16 MHz
3.1.2) Arduino IDE:
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Thiết kế bo mạch nhỏ gọn, trang bị nhiều tính năng thông dụng mang lại nhiều lợi thế
cho Arduino, tuy nhiên sức mạnh thực sự của Arduino nằm ở phần mềm. Môi trường lập
trình đơn giản dễ sử dụng, ngôn ngữ lập trình dễ hiểu và dựa trên nền tảng C/C++ rất
quen thuộc với người làm kỹ thuật. Và quan trọng là số lượng thư viện code được viết
sẵn và chia sẻ bởi cộng đồng nguồn mở là cực kỳ lớn.
Giao diện phần mềm Arduino IDE.
3.1.3) Module Lora SX1278 (UART):
SX1278 là module truyền thông có công suất 100mw. Nó làm việc ở dải 433MHZ và sử
dụng cổng Serial để gửi nhận dữ liệu. Khoảng cách truyền tối đa lý tưởng của Module
Lora này đạt được khoảng 3000m. Module này có cơ chế FEC truyền lại khi báo lỗi
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
truyền tin. Khi truyền tin thì dữ liệu sẽ được mã hóa và giải mã nhằm cải thiện độ tin cậy.
Module có 4 chế độ hoạt động với 4 mode truyền khác nhau. Đặc biệt có thể ứng dụng
vào các hệ thống yêu cầu điện năng tiêu thụ rất thấp. Khi ở chế độ power saving mode.
Các chế độ truyền nhận của module lora SX1728
Thông số kỹ thuật :
-Model: E32-TTL-100 RF
-IC chính: SX1278 từ SEMTECH.
-Điện áp hoạt đông: 2.5 - 5.5 VDC
-Điện áp giao tiếp: TTL
-Giao tiếp UART Data bits 8, Stop bits 1, Parity none, tốc độ từ 1200 - 115200.
-Tần số: 410 - 441Mhz
-Công suất: 20dbm (100mW)
-Khoảng cách truyền tối đa trong điều kiện lý tưởng: 3000m
-Tốc độ truyền: 0.3 - 19.2 Kbps ( mặc định 2.4 Kbps)
-512bytes bộ đệm.
-Hỗ trợ 65536 địa chỉ cấu hình có 32 kênh
-Kích thước: 21x36mm.
-Độ dài dữ liệu truyền và nhận là: 58 Byte / gói tin
Các ứng dụng:
Cảm biến đọc khoảng cách thông minh
Node cảm biến
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Nhà thông minh
Robot thông minh
Quan trắc môi trường
Hệ thống thu thập dữ liệu tự động
Module Lora SX1278
Chi tiết chức năng chân AUX:
-
Chân AUX có thể được sử dụng để hiển thị quá trình truyền nhận dữ liệu không
dây hoặc quá trình khởi động của module.
Tín hiệu AUX báo hiệu hoạt động của module
Khi có tín hiệu vào TXD thì tín hiệu AUX xuất ra là thấp báo hiệu có tín hiệu truyền
serial. Khi Serial đã gửi xong thì AUX=1 tức là trở lại mức cao như lúc chờ dữ liệu ban
đầu.
3.1.4) Cảm biến nhiệt độ LM35
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Cảm biến LM35 là bộ cảm biến nhiệt mạch tích hợp chính xác cao mà điện áp đầu ra của
nó tỉ lệ tuyến tính với nhiệt độ thang Celsius. Chúng không yêu cầu cân chỉnh ngoài vì
vốn chúng đã được cân chỉnh.
Cảm biến LM35 có 3 chân:
+ Chân nguồn VCC
+ Chân đầu ra Vout (chân tương tự)
+ Chân nối đất GND.
Hình ảnh cảm biến LM35
Đặc điểm chính của cảm biến LM35 :
- Điện áp đầu vào từ 4V đến 30V
- Độ phân giải điện áp đầu ra là 10mV/˚C
- Độ chính xác cao ở 25 ˚C là 0.5˚C
- Trở kháng đầu ra thấp 0.1 cho 1mA tải
Dải nhiệt độ đo được của LM35 là từ -55˚C đến 150˚C với các mức điện áp ra khác
nhau. Xét một số mức điện áp sau :
- Nhiệt độ 55˚C điện áp đẩu ra -550mV
- Nhiệt độ 25˚C điện áp đầu ra 250mV
- Nhiệt độ 150˚C điện áp đầu ra 1500mV.
Tùy theo cách mắc của LM35 để ta đo các giải nhiệt độ phù hợp. Đối với hệ thống này
thì đo từ 0˚C đến 150˚C
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
3.2) Giải pháp thiết kế Node con (client):
Sơ đồ khối ghép nối phần cứng:
Sơ đồ khối Node con
Khối 1: Khối nguồn
Khối nguồn có nhiệm vụ chính là cung cấp nguồn điện cho toàn bộ mạch điều khiển bao
gồm khối vi điều khiển và khối truyền thông
Khối 2: Khối vi điều khiển MCU
Khối vi điều khiển MCU ARDUINO UNO R3 sẽ nhận tín hiệu từ cảm biến và gửi bản tin
đến Server thông qua module truyền thông SX1278.
Khối 3: Khối cảm biến
Khối cảm biến sẽ nhận thay đổi của môi trường, sau đó sẽ gửi tín hiệu điện áp về vi điều
khiển
Khối 4: Khối truyền thông
Khối truyền thông có nhiệm vụ gửi các gói tin dữ liệu từ nút con đến Server
Lưu đồ thuật toán Node con
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Lưu đồ thuật toán Node con
Giải thích lưu đồ thuật toán: Sau khi cấp nguồn cho Node con, vi điều khiển sẽ thực hiện
cấu hình các tham số và cấu hình hệ thống. Sau đó thực hiện đọc giá trị các cảm biến và
đợi nhận lệnh từ Server. Qúa trình này lặp lại liên tục
Sơ đồ nguyên lí thiết kế phần cứng
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Sơ đồ nguyên lý Node con
3.3) Giải pháp thiết kế Server:
Sơ đồ khối ghép nối phần cứng:
Sơ đồ khối Server
Khối 1: Khối nguồn
Khối 2: Khối vi điều khiển MCU
Khối 3: Khối cảm biến
Khối 4: Khối truyền thông
Lưu đồ thuật toán Server:
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Lưu đồ thuật toán Server
Giải thích lưu đồ thuật toán: Sau khi cấp nguồn cho Server, vi điều khiển sẽ thực hiện cấu
hình các tham số và cấu hình hệ thống. Sau đó thực hiện đợi lệnh, khi có lệnh thì nhận và
kiểm tra lệnh để gửi cho từng Node con thực thi (Với Lệnh Auto thì gửi cho toàn Chanel)
và nhận các giá trị tương ứng với từng lệnh khác nhau từ Client và quan sát trên Serial
monitor của Arduino IDE
Sơ đồ nguyên lí thiết kế phần cứng
Sơ đồ nguyên lý Server
3.5) CÁC DẠNG GỬI GÓI TIN TRONG LORA THÔNG DỤNG:
3.5.1) Theo Kiểu Giao Thức TCP/IP:
Giao thức TCP/IP hoạt động như thế nào?
TCP/IP là sự kết hợp của hai giao thức riêng biệt: Giao thức kiểm soát truyền tin (TCP) và giao
thức Internet (IP). Giao thức Internet cho phép các gói được gửi qua mạng; Nó cho biết các
gói tin được gửi đi đâu và làm thế nào để đến đó. IP có một phương thức cho phép bất kỳ máy
tính nào trên Internet chuyển tiếp gói tin tới một máy tính khác thông qua một hoặc nhiều
khoảng (chuyển tiếp) gần với người nhận gói tin.
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Giao thức điều khiển truyền dẫn đảm bảo việc truyền dữ liệu đáng tin cậy qua các mạng kết
nối Internet. TCP kiểm tra các gói dữ liệu xem có lỗi không và gửi (ACK) yêu cầu truyền lại nếu
có lỗi được tìm thấy.
Được áp dụng trong đồ án khi gửi các lệnh đơn (Hoặc khi kiểm tra kết nối) thì sẽ đợi ACK,
nếu Server nhận được ACK thì sẽ làm tiếp việc khác. Nếu như hết Timeout mà không nhận
được ACK thì ta sẽ gửi lại (Hoặc không).
Giao thức TCP đảm bảo được việc không bị mất gói tin (Được áp dụng trong những
trường hợp muốn đảm bảo việc truyền nhận gói tin chính xác 100%)
3.5.2) Theo Kiểu Giao Thức UDP:
Giao thức UDP giống với TCP nhưng UDP chỉ gửi gói tin mà không quan tâm quá trình gửi
(nhận)
Dễ gây mất gói tin, nhưng phù hợp khi ta cần gửi nhiều lệnh, liên tục mà không muốn đợi
Timeout (Như khi gửi lệnh điều khiển)
HÌNH ẢNH MINH HỌA
_Ngoài ra ta cũng có thể sử dụng các loại giao thức khác để truyền nhận như: Polling, Cửa sổ
trượt, ….
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
4) PHẦN CODE CHƯƠNG TRÌNH:
#include <SoftwareSerial.h>
#include "E32-TTL-100.h"
#define M0_PIN 7
#define M1_PIN 8
#define AUX_PIN
A0
#define SOFT_RX
10
#define SOFT_TX 11
SoftwareSerial softSerial(SOFT_RX, SOFT_TX); // RX, TX
//=== AUX ===========================================+
bool AUX_HL;
bool ReadAUX()
{
int val = analogRead(AUX_PIN);
if(val<50)
{
AUX_HL = LOW;
}else {
AUX_HL = HIGH;
}
return AUX_HL;
}
//return default status
RET_STATUS WaitAUX_H()
{
RET_STATUS STATUS = RET_SUCCESS;
uint8_t cnt = 0;
uint8_t data_buf[100], data_len;
while((ReadAUX()==LOW) && (cnt++
Serial.print(".");
delay(100);
}
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
if(cnt==0)
{
}
else if(cnt>=TIME_OUT_CNT)
{
STATUS = RET_TIMEOUT;
Serial.println(" TimeOut");
}
else
{
Serial.println("");
}
return STATUS;
}
//=== AUX ===========================================//=== Mode Select ===================================+
bool chkModeSame(MODE_TYPE mode)
{
static MODE_TYPE pre_mode = MODE_INIT;
if(pre_mode == mode)
{
//Serial.print("SwitchMode: (no need to switch) "); Serial.println(mode, HEX);
return true;
}
else
{
Serial.print("SwitchMode: from "); Serial.print(pre_mode, HEX); Serial.print(" to ");
Serial.println(mode, HEX);
pre_mode = mode;
return false;
}
}
void SwitchMode(MODE_TYPE mode)
{
if(!chkModeSame(mode))
{
WaitAUX_H();
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
switch (mode)
{
case MODE_0_NORMAL:
// Mode 0 | normal operation
digitalWrite(M0_PIN, LOW);
digitalWrite(M1_PIN, LOW);
break;
case MODE_1_WAKE_UP:
digitalWrite(M0_PIN, HIGH);
digitalWrite(M1_PIN, LOW);
break;
case MODE_2_POWER_SAVIN:
digitalWrite(M0_PIN, LOW);
digitalWrite(M1_PIN, HIGH);
break;
case MODE_3_SLEEP:
// Mode 3 | Setting operation
digitalWrite(M0_PIN, HIGH);
digitalWrite(M1_PIN, HIGH);
break;
default:
return ;
}
WaitAUX_H();
delay(10);
}
}
//=== Mode Select ===================================//=== Basic cmd =====================================+
void cleanUARTBuf()
{
bool IsNull = true;
while (softSerial.available())
{
IsNull = false;
softSerial.read();
}
}
void triple_cmd(SLEEP_MODE_CMD_TYPE Tcmd)
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
{
uint8_t CMD[3] = {Tcmd, Tcmd, Tcmd};
softSerial.write(CMD, 3);
delay(50); //need ti check
}
RET_STATUS Module_info(uint8_t* pReadbuf, uint8_t buf_len)
{
RET_STATUS STATUS = RET_SUCCESS;
uint8_t Readcnt, idx;
Readcnt = softSerial.available();
//Serial.print("softSerial.available(): "); Serial.print(Readcnt); Serial.println(" bytes.");
if (Readcnt == buf_len)
{
for(idx=0;idx
{
*(pReadbuf+idx) = softSerial.read();
Serial.print(" 0x");
Serial.print(0xFF & *(pReadbuf+idx), HEX);
// print as an ASCII-encoded
hexadecimal
} Serial.println("");
}
else
{
STATUS = RET_DATA_SIZE_NOT_MATCH;
Serial.print("
RET_DATA_SIZE_NOT_MATCH
Serial.println(Readcnt);
cleanUARTBuf();
}
return STATUS;
}
//=== Basic cmd =====================================//=== Sleep mode cmd ================================+
RET_STATUS Write_CFG_PDS(struct CFGstruct* pCFG)
{
softSerial.write((uint8_t *)pCFG, 6);
WaitAUX_H();
delay(1200); //need ti check
-
Readcnt:
");
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
return RET_SUCCESS;
}
RET_STATUS Read_CFG(struct CFGstruct* pCFG)
{
RET_STATUS STATUS = RET_SUCCESS;
//1. read UART buffer.
cleanUARTBuf();
//2. send CMD
triple_cmd(R_CFG);
//3. Receive configure
STATUS = Module_info((uint8_t *)pCFG, sizeof(CFGstruct));
if(STATUS == RET_SUCCESS)
{
Serial.print(" HEAD: "); Serial.println(pCFG->HEAD, HEX);
Serial.print(" ADDH: "); Serial.println(pCFG->ADDH, HEX);
Serial.print(" ADDL: "); Serial.println(pCFG->ADDL, HEX);
Serial.print(" CHAN:
"); Serial.println(pCFG->CHAN, HEX);
}
return STATUS;
}
RET_STATUS Read_module_version(struct MVerstruct* MVer)
{
RET_STATUS STATUS = RET_SUCCESS;
//1. read UART buffer.
cleanUARTBuf();
//2. send CMD
triple_cmd(R_MODULE_VERSION);
//3. Receive configure
STATUS = Module_info((uint8_t *)MVer, sizeof(MVerstruct));
if(STATUS == RET_SUCCESS)
{
Serial.print(" HEAD: 0x"); Serial.println(MVer->HEAD, HEX);
Serial.print(" Model: 0x"); Serial.println(MVer->Model, HEX);
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Serial.print(" Version: 0x"); Serial.println(MVer->Version, HEX);
Serial.print(" features: 0x"); Serial.println(MVer->features, HEX);
}
return RET_SUCCESS;
}
void Reset_module()
{
triple_cmd(W_RESET_MODULE);
WaitAUX_H();
delay(1000);
}
RET_STATUS SleepModeCmd(uint8_t CMD, void* pBuff)
{
RET_STATUS STATUS = RET_SUCCESS;
Serial.print("SleepModeCmd: 0x"); Serial.println(CMD, HEX);
WaitAUX_H();
SwitchMode(MODE_3_SLEEP);
switch (CMD)
{
case W_CFG_PWR_DWN_SAVE:
STATUS = Write_CFG_PDS((struct CFGstruct* )pBuff);
break;
case R_CFG:
STATUS = Read_CFG((struct CFGstruct* )pBuff);
break;
case W_CFG_PWR_DWN_LOSE:
break;
case R_MODULE_VERSION:
Read_module_version((struct MVerstruct* )pBuff);
break;
case W_RESET_MODULE:
Reset_module();
break;
default:
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
return RET_INVALID_PARAM;
}
WaitAUX_H();
return STATUS;
}
//=== Sleep mode cmd ================================RET_STATUS SettingModule(struct CFGstruct *pCFG)
{
RET_STATUS STATUS = RET_SUCCESS;
#ifdef Device_A
pCFG->ADDH = DEVICE_A_ADDR_H;
pCFG->ADDL = DEVICE_A_ADDR_L;
#else
pCFG->ADDH = DEVICE_B_ADDR_H;
pCFG->ADDL = DEVICE_B_ADDR_L;
#endif
pCFG->OPTION_bits.trsm_mode =TRSM_FP_MODE;
pCFG->OPTION_bits.tsmt_pwr = TSMT_PWR_10DB;
STATUS = SleepModeCmd(W_CFG_PWR_DWN_SAVE, (void* )pCFG);
SleepModeCmd(W_RESET_MODULE, NULL);
STATUS = SleepModeCmd(R_CFG, (void* )pCFG);
return STATUS;
}
RET_STATUS ReceiveMsg(uint8_t *pdatabuf, uint8_t *data_len)
{
RET_STATUS STATUS = RET_SUCCESS;
uint8_t idx;
SwitchMode(MODE_0_NORMAL);
*data_len = softSerial.available();
if (*data_len > 0)
{
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
Serial.print("ReceiveMsg: "); Serial.print(*data_len); Serial.println(" bytes.");
for(idx=0;idx<*data_len;idx++)
*(pdatabuf+idx) = softSerial.read();
for(idx=0;idx<*data_len;idx++)
{
Serial.print(" 0x");
Serial.print(0xFF & *(pdatabuf+idx), HEX);
// print as an ASCII-encoded
hexadecimal
} Serial.println("");
}
else
{
STATUS = RET_NOT_IMPLEMENT;
}
return STATUS;
}
RET_STATUS SendMsg()
{
RET_STATUS STATUS = RET_SUCCESS;
SwitchMode(MODE_0_NORMAL);
if(ReadAUX()!=HIGH)
{
return RET_NOT_IMPLEMENT;
}
delay(10);
if(ReadAUX()!=HIGH)
{
return RET_NOT_IMPLEMENT;
}
//TRSM_FP_MODE
//Send format : ADDH ADDL CHAN DATA_0 DATA_1 DATA_2 ...
#ifdef Device_A
uint8_t SendBuf[4] = { DEVICE_B_ADDR_H, DEVICE_B_ADDR_L, 0x17,
random(0x00, 0x80)};
#else
//for A
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
uint8_t SendBuf[4] = { DEVICE_A_ADDR_H, DEVICE_A_ADDR_L, 0x17,
random(0x81, 0xFF)}; //for B
#endif
softSerial.write(SendBuf, 4);
return STATUS;
}
//The setup function is called once at startup of the sketch
void setup()
{
RET_STATUS STATUS = RET_SUCCESS;
struct CFGstruct CFG;
struct MVerstruct MVer;
pinMode(M0_PIN, OUTPUT);
pinMode(M1_PIN, OUTPUT);
pinMode(AUX_PIN, INPUT);
pinMode(LED_BUILTIN, OUTPUT);
softSerial.begin(9600);
Serial.begin(9600);
#ifdef Device_A
Serial.println("[10-A] ");
#else
Serial.println("[10-B] ");
#endif
STATUS = SleepModeCmd(R_CFG, (void* )&CFG);
STATUS = SettingModule(&CFG);
STATUS = SleepModeCmd(R_MODULE_VERSION, (void* )&MVer);
// Mode 0 | normal operation
SwitchMode(MODE_0_NORMAL);
//self-check initialization.
WaitAUX_H();
delay(10);
if(STATUS == RET_SUCCESS)
Serial.println("Setup init OK!!");
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
}
void blinkLED()
{
static bool LedStatus = LOW;
digitalWrite(LED_BUILTIN, LedStatus);
LedStatus = !LedStatus;
}
// The loop function is called in an endless loop
void loop()
{
uint8_t data_buf[100], data_len;
#ifdef Device_A
if(ReceiveMsg(data_buf, &data_len)==RET_SUCCESS)
{
blinkLED();
}
#else
if(SendMsg()==RET_SUCCESS)
{
blinkLED();
}
#endif
delay(random(400, 600));
}
Phần Thư Viện E32-TTL-100.h:
#ifndef E32-TTL-100_H_
#define E32-TTL-100_H_
typedef enum {
RET_SUCCESS = 0,
RET_ERROR_UNKNOWN,
/* something shouldn't happened */
RET_NOT_SUPPORT,
RET_NOT_IMPLEMENT,
RET_NOT_INITIAL,
RET_INVALID_PARAM,
RET_DATA_SIZE_NOT_MATCH,
RET_BUF_TOO_SMALL,
Đồ án kỹ thuật điện tử
ĐỒ ÁN KỸ THUẬT ĐIỆN TỬ
RET_TIMEOUT,
RET_HW_ERROR,
} RET_STATUS;
enum MODE_TYPE
{
MODE_0_NORMAL = 0,
MODE_1_WAKE_UP,
MODE_2_POWER_SAVIN,
MODE_3_SLEEP,
MODE_INIT = 0xFF
};
//SPED+
enum SLEEP_MODE_CMD_TYPE
{
W_CFG_PWR_DWN_SAVE = 0xC0,
R_CFG
= 0xC1,
W_CFG_PWR_DWN_LOSE = 0xC2,
R_MODULE_VERSION = 0xC3,
W_RESET_MODULE = 0xC4
};
enum UART_FORMAT_TYPE
{
UART_FORMAT_8N1 = 0x00, /*no parity bit one stop*/
UART_FORMAT_8O1 = 0x01, /*odd parity bit one stop*/
UART_FORMAT_8E1 = 0x02 /*even parity bitone stop*/
};
enum UART_BPS_TYPE
{
UART_BPS_1200 = 0x00,
UART_BPS_9600 = 0x03,
UART_BPS_115200 = 0x07
};
enum AIR_BPS_TYPE
{
AIR_BPS_300 = 0x00,
AIR_BPS_2400 = 0x02,
AIR_BPS_19200 = 0x05
};
