物联网实验报告

更新时间：2023-10-10 12:52:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

物联网课程设计

实验成员：

指导教师：日期：

2014/7/3

实验一 LED组件

一、实验内容

LED组件：绿灯一直处于熄灭的状态，红灯不停闪烁

二、实验步骤

1) 将基站同电脑用烧录线连接好，打开基站的开关，同时将基站的烧录开关拨上去。

2) 打开 Cygwin 开发环境。 3) 在 Cygwin 界面中执行 cd apps/Demos/Basic/Led，进入到 LED 实验目录下。

4) 在 LED 实验目录下执行 make antc5 install 进行编译和烧录。 5) 可以看到实验现象为基站上的绿灯一直处于熄灭的状态，红灯不停闪烁。

三、实验代码

/**

LED 示例程序的实现模块，简单的点亮3个LED灯 @date 2010-1 */

module LedM {

uses interface Boot; }

implementation {

/** LED灯演示 */

task void DemoLed() {

/** 目前节点上提供两个LED灯 LED_BLUE -> 蓝灯 LED_YELLOW -> 黄灯 */

int i,j; while(1) {

LED_YELLOW_ON; //熄灭黄色LED灯

for(i=0;i<1000;i++) for(j=0;j<500;j++);

LED_BLUE_OFF; //点亮蓝色LED灯

}

for(i=0;i<1000;i++) for(j=0;j<500;j++);

LED_BLUE_ON; //熄灭蓝色LED灯 }

/** 启动事件处理函数，在LED.nc已经关联到MainC.Boot接口系统启动后会调用此函数 */

event void Boot.booted() {

post DemoLed(); }

实验二定时器组件

一、实验内容

通过定时器让绿色灯闪烁，并且闪烁三次后停止闪烁。

二、实验步骤

1) 将基站同电脑用烧录线连接好，打开基站的开关，同时将基站的烧录开关拨

上去。

2) 打开 Cygwin 开发环境。

3) 在Cygwin 界面中执行 cd apps/Demos/Basic/ Timer，进入到定时器实验目录下。

4) 在定时器代码目录下执行 make antc5 install，进行编译和烧录。

5) 实验现象为基站上绿色灯闪烁，并且闪烁三次后停止闪烁。

三、实验代码

#define DBG_LEV 5 module TimerLedM {

uses interface Boot;

/* Timer为系统接口TMilli指明了定时器的精度为毫秒 */

uses interface Timer as Timer1; /* as关键字为接口别名 */

uses interface Timer as Timer2; }

implementation {

/** 任务: 切换黄色LED灯 */ task void ToggleLedYellow() {

LED_YELLOW_TOGGLE; }

/** 启动事件处理函数，在TimerLed.nc已经关联到MainC.Boot接口

系统启动后会调用此函数 */

event void Boot.booted() {

}

LED_BLUE_ON;

call Timer2.startPeriodic(1000);

/** 定时器1: 持续工作，每隔1s触发一次 */ call Timer1.startPeriodic(6000);

/** 定时器2: 持续工作，每隔3s触发一次*/ //call Timer2.startPeriodic(5000);

/** 定时器1的事件处理函数 */ event void Timer1.fired() {

/** 事件处理中直接切换蓝色LED灯 */ ADBG(5, \ //LED_BLUE_TOGGLE; LED_YELLOW_ON;

call Timer2.stop();/**停止定时器触发*/ call Timer1.stop(); }

/** 定时器2的事件处理函数 */ event void Timer2.fired() {

ADBG(5, \ post ToggleLedYellow(); }

实验三串口调试

一、实验内容

通过级别控制，使得某些调试语句没有被输出到串口。

二、实验步骤

1) 将基站同电脑用烧录线连接好，打开基站的开关，同时将基站的烧录开关拨上去。

2) 用串口线将基站和 PC 机器连接起来。 3) 打开串口助手。

4) 打开 Cygwin 开发环境。

5) 在 Cygwin 界面中执行 cd apps/Demos/Basic/ SerialDebug，进入到串口调试实验目录下。

6) 在串口调试代码目录下执行 make antc5 install，进行编译和烧录。 7) 烧录成功后，实验现象为串口有内容输出，输出内容如下： DEMO of Serial Debug 1. This is a string, and this is char x 2. NUM1: HEX=0x39, DEC=57 4.FLOAT:0x123.1234

三、实验代码

/**

串口调试程序的实现模块 @date */

/* 定义调试级别，参加Makefile的ADBG_LEVEL定义，设置大于等于ADBG_LEVEL */

#define DBG_LEV 3000 #define DBG_LEV2 2000

module SerialDebugM {

uses interface Boot; }

implementation {

/** 任务: 通过串口打印信息来调试 */ task void DebugSerial()

{

uint8_t num1 = 0x39; uint32_t num2 = 0x12345678; float float1 = 123.1234;

/** ADBG，格式类似于printf,

第一个参数为调试等级，可以参见tos/lib/common/antdebug.h

/** 打印字符和字符串 */

ADBG(DBG_LEV, \ ADBG(DBG_LEV, \This is a string, and this is char '%c'\\r\\n\

/** 打印8位的数字 */

ADBG(DBG_LEV, \NUM1: HEX=0x%x, DEC=%d\\r\\n\(int)(num1), (int)(num1));

/** 打印32位数字 */

ADBG(DBG_LEV2, \NUM2: HEX=0x%lx, DEC=%ld\\r\\n\(uint32_t)(num2), (uint32_t)(num2));

/** 打印浮点数*/

ADBG(DBG_LEV, \ }

/** 启动事件处理函数，在SerialDebug.nc已经关联到MainC.Boot接口

系统启动后会调用此函数 */

event void Boot.booted() {

post DebugSerial(); } }

实验四串口通信

一、实验内容

实现一个串口实验，在串口助手中实现回显的功能。

二、实验步骤

1) 将基站同电脑用烧录线连接好，打开基站的开关。 2) 用串口线将基站和 PC 机器连接起来。 3) 打开串口助手。

4) 打开 Cygwin 开发环境。

5) 在 Cygwin 界面中执行 cd apps/Demos/Basic/ SerialIO，进入到串口通讯实验目

录下。

6) 在串口通讯代码目录下执行 make antc5 install，进行编译和烧录。 7) 根据串口输出的提示进行操作，在串口助手的字符输入框输入 1，红灯会一直亮着，直到再一次输入 1 才熄灭；在串口助手的字符输入框输入 2，绿灯会一直亮着，直到再一次输入 1 才熄灭，输入其他数字串口会提示“Error key”，并且会显示你输入的数字，结果如下：

Demo of Serio I/O [1]Toggle BLUE LED [2]Toggle YELLOW LED You choose to input 1 You choose to Toggle BLUE LED 三、实验代码

/**

串口输入输出程序的实现模块 @author @date */

#include

/** 定义此宏，将演示UartStream.receive函数，允许一次指定数量的数据 */

//#define SERIALIO_RECEIVE

#define DBG_LEV 3000

module SerialIoM

{

uses interface Boot;

uses interface StdControl as UartStdControl; uses interface UartStream; }

implementation {

uint8_t m_receive_len; uint8_t m_echo_buf;

uint8_t m_send_buf[100];

/* 显示一个菜单提示用户 */ void showMenu() {

strcpy(m_send_buf, \of Serio I/O\\r\\n[1] Toggle BLUE LED\\r\\n[2] Toggle YELLOW LED\\r\\n\

/* 通过UartStream.send可以发送字节数据 */

call UartStream.send(m_send_buf, strlen(m_send_buf)); }

/** 启动事件处理函数，在SerialIo.nc已经关联到MainC.Boot接口

系统启动后会调用此函数 */

event void Boot.booted() {

LED_BLUE_ON; LED_YELLOW_ON;

call UartStdControl.start();

showMenu(); }

async event void UartStream.sendDone(uint8_t *buf, uint16_t len, error_t error)

{ }

/** 重新发送刚才接收的字符进行回显 */ task void showMenuTask() {

showMenu();

}

task void lightLED() {

if(m_echo_buf=='1') {

LED_BLUE_TOGGLE; /* 切换蓝色LED灯 */

ADBG(DBG_LEV, \ ADBG(DBG_LEV, \ post showMenuTask(); }

else if (m_echo_buf == '2') {

LED_YELLOW_TOGGLE; /* 切换黄色LED灯 */

ADBG(DBG_LEV, \ ADBG(DBG_LEV, \ post showMenuTask(); } else {

ADBG(DBG_LEV, \ post showMenuTask(); } }

/** 如果没有调用receive接收，则每接收到一个数据就会触发此事件 */

async event void UartStream.receivedByte(uint8_t byte) {

m_echo_buf = byte; post lightLED(); }

/** 在接收完receive命令欲接收的长度后会调用此事件 */

async event void UartStream.receiveDone(uint8_t *buf, uint16_t len, error_t error)

{

} }

实验五 Flash读写

一、实验内容

Flash读写：自己定义一个结构体，并且将结构体的内容写入到 0x1fff8，并且在写完后将结构体的数据读取出来和原始数据进行比较。

二、实验步骤

1) 将基站同电脑用烧录线连接好，打开基站的开关。 2) 用串口线将基站和 PC 机器连接起来。 3) 打开串口助手。

4) 打开 Cygwin 开发环境。

5) 在 Cygwin 开发环境中执行 cd apps/Demos/Basic/Flash。

6) 在 Flash 目录下执行 make antc5 install，进行软件的编译和烧录。 7) 烧录成功后，串口有内容输出，具体如下：

Boot.booted Read now Read ok. array1.num[0]=7 array1.num[1]=2 array1.num[2]=4 array1.num[3]=11 array1.num[4]=21 array1.num[5]=3 array1.num[6]=92 array1.num[6]=1 三、实验代码

/* 定义调试级别，参加Makefile的ADBG_LEVEL定义，设置大于等于ADBG_LEVEL */

#define DBG_LEV 3000

module TestFlashC { uses interface Boot; uses interface HalFlash; }

implementation { struct array { uint8_t num[8];

}; uint8_t ieee[8] = {0}; uint8_t ieee2[8] = {7,2,4,11,21,3,92,1}; task void initTask() { uint8_t i; struct array array1; for(i=0;i<8;i++) { array1.num[i]=ieee2[i]; } ADBG(DBG_LEV, \ call HalFlash.erase((uint8_t*)0x1fff8); for (i=0;i < 8;i+=4) { call HalFlash.write((uint8_t*)(0x1FFF8+i), (&array1.num+i), 4); } call HalFlash.read(ieee, (uint8_t *)0x1FFF8, 8); ADBG(DBG_LEV, \ for (i=0; i < sizeof(ieee); ++i) { ADBG(DBG_LEV, \ } } event void Boot.booted() { ADBG(DBG_LEV, \ post initTask(); } }

实验六点对点通信

一、实验内容

完成一个点对点的传输，让基站给单独节点发送一个命令，节点在接收到命令后将自己的蓝灯状态改变。

二、实验步骤

1) 将基站同电脑用烧录线连接好，打开基站的开关，将基站的烧录开关拨上去。

2) 用串口线将基站和 PC 机器连接起来。 3) 打开串口助手。

4) 打开 Cygwin 开发环境。

5) 在 Cygwin 开发环境中执行/opt/atos/apps/Demos/RFDemos/1_P2P。 6) 在点对点通讯目录下执行 make antc5 install GRP=BB NID=01，进行软件的编译和烧录,(GRP= BB NID=01 将当前的点烧录为第BB组，第一号)。

7) 烧录成功后，将基站的烧录开关拨下去，将节点对应的烧录开关拨上去，然后打开其中一个节点的开关。

8) 执行 make antc5 reinstall GRP= BB NID=02。 9) 重启基站，在串口助手中有如下的内容：

############################################### [P2PDEMO] My Address = 0x1, Group = 0xBB ############################################### * MY NodeId = 0x1, Group=0xBB, destination ? 2 *To Send: BLUE *Sending … from[1],to[4],len=[5] *SentOK! 现象为节点在接收到命令后将自己的蓝灯状态改变

三、实验内容

#define DBG_LEV 1000

module P2PM {

uses {

interface Boot;

interface AtosControl;

interface StdControl as UartStdControl; interface UartStream; interface AMSend; interface Receive;

interface AMPacket; interface Packet; } }

implementation {

enum {

MAX_ADDRESS_LEN = 5, INPUT_ADDRESS = 0, INPUT_DATA = 1, };

message_t m_msg; uint8_t m_len = 0;

char m_address_str[MAX_ADDRESS_LEN] = {0}; uint8_t m_address_index = 0; uint8_t m_input_type = 0;

/* 显示菜单*/

task void showMenu() {

if( m_input_type == INPUT_DATA) {/*等待输入欲发送的数据*/

ADBG_APP( \ } else

{/*等待输入欲发送的地址*/ ADBG_APP( \

\\n###################################################\\r\\n* NodeId = 0x%x,

Group=0x%x, destination ?\\r\\n\

ADBG_N(call AMPacket.address()), ADBG_N(TOS_IEEE_PANID) );

m_input_type = INPUT_ADDRESS; m_address_index = 0; } }

/*将从串口输入的地址字符串转化为真实地址*/

MY uint16_t getDestAddress() {

uint16_t address = 0; uint8_t i = 0;

if(m_address_index > MAX_ADDRESS_LEN) {

m_address_index = MAX_ADDRESS_LEN -1; }

for ( i=0; i < m_address_index; ++i) {

uint8_t digital = m_address_str[i]; if(digital >= 'A' && digital <= 'F') {

digital = digital - 'A' + 10; }

else if(digital >= 'a' && digital <= 'f') {

digital = digital - 'a' + 10; }

else if(digital >= '0' && digital <= '9') {

digital = digital - '0'; }

address = address*16 +digital; }

return address; }

/* 发送数据*/

task void sendData() {

uint8_t i;

uint8_t* payload = call Packet.getPayload(&m_msg, NULL); uint16_t address = call AMPacket.address(); uint16_t dest_address = getDestAddress();

ADBG_APP( \Sending ... from [%d], to [%d], len=[%d]\\r\\n\

ADBG_N(address),

ADBG_N(dest_address), ADBG_N(m_len) );

call AMSend.send(dest_address, &m_msg, m_len);

//LED_BLUE_TOGGLE; }

/*发送完处理*/

event void AMSend.sendDone(message_t* msg, error_t result) {

//ADBG_APP( \

ADBG_APP( \\

if (result == SUCCESS) {

LED_BLUE_TOGGLE; } else {

LED_YELLOW_TOGGLE; }

m_len = 0;

m_input_type = INPUT_ADDRESS;

post showMenu(); }

/* 节点启动完毕*/

event void Boot.booted() {

/*开启射频*/

call AtosControl.start();

/*开启串口通信*/

call UartStdControl.start();

LED_YELLOW_OFF; LED_BLUE_OFF; ADBG_APP( \n\

ADBG_APP( \ [P2PDEMO] My Address = 0x%x, Group = 0x%x\\r\\n\

ADBG_N(call AMPacket.address()), ADBG_N(TOS_IEEE_PANID)); ADBG_APP( \

m_input_type = INPUT_ADDRESS; post showMenu(); }

/*从串口接收数据*/

async event void UartStream.receivedByte(uint8_t c) {

if(c != '\\r') {

if (m_input_type == INPUT_DATA) {/*输入数据*/ uint8_t* payload = (uint8_t*)call Packet.getPayload(&m_msg, NULL);

if(m_len >= call Packet.maxPayloadLength()) {

return; }

payload[m_len++] = c; ADBG_APP( \

if(m_len < call Packet.maxPayloadLength()) {

return; } } else

{/*输入地址*/

if(m_address_index < MAX_ADDRESS_LEN) {

m_address_str[m_address_index++] = c; ADBG_APP( \ }

if(m_address_index < MAX_ADDRESS_LEN) {

return; } } }

/*按下回车键或者到达最大长度，则处理*/ if(m_input_type == INPUT_DATA) {

post sendData(); } else {

/*地址处理完毕，准备输入数据*/ m_input_type = INPUT_DATA; post showMenu(); } }

/** 实现接口UartStream 接口中的事件*/

async event void UartStream.sendDone(uint8_t* buf, uint16_t len, error_t error)

{ }

async event void UartStream.receiveDone(uint8_t* buf, uint16_t len, error_t error)

{ }

/*射频接收数据*/

event message_t* Receive.receive(message_t* msg, void* payload, uint8_t len)

{

uint8_t i;

ADBG_APP( \len = [%d], DATA:\\r\\n\ADBG_N(len));

for(i=0; i < len; i++) {

ADBG_APP( \ }

/*如果输入命令BLUE，蓝灯状态改变*/ if(len==4) {

if(((uint8_t*)payload)[0]=='B'&&((uint8_t*)payload)[1]=='L'&&(

(uint8_t*)payload)[2]=='U'&&((uint8_t*)payload)[3]=='E')

{

LED_BLUE_TOGGLE; } }

ADBG_APP( \

LED_YELLOW_TOGGLE;

m_input_type = INPUT_ADDRESS; post showMenu();

} }

实验七射频广播

一、实验内容

写一个射频广播实验，包括基站和节点的程序。使得节点在接收到三个基站的广播信号停止接收广播数据。

二、实验步骤

1) 将基站同电脑用烧录线连接好，打开基站的开关。 2) 用串口线将基站和 PC 机器连接起来。 3) 打开串口助手。

4) 打开 Cygwin 开发环境。

5) 在 Cygwin 开发环境中执行/opt/atos/apps/Demos/RFDemos/ 6_Broadcast。

6) 在当前目录下执行 make antc5 install GRP=BB NID=01，进行软件的编译和烧录。

7) 烧录成功后，将基站的烧录开关拨下去，将节点对应的烧录开关拨上去，然后打开节点的开关。

8) 执行 make antc5 reinstall GRP=BB NID=02。 9) 再烧录一个节点，节点号 NID=03。

10) 全部烧录完成后，首先将基站的开关关闭，然后打开两个节点的开关，这个时候两个节点的红、黄、蓝灯都是亮着的。

11) 当打开基站的开关的时候，首先是基站的红色灯闪烁，然后两个节点都跟着蓝灯闪烁三次，之后不再亮。说明节点在接收到三个基站的广播信号停止接收广播数据。

三、实验代码

#define DBG_LEV 1000

module BroadcastP {

uses {

interface Boot;

interface AtosControl; interface AMSend; interface Receive; interface AMPacket; interface Packet;

interface Timer as SensorTimer; } }

implementation

task void sendMsgTask() {

uint8_t i;

ADBG(3000, \

for (i=0; i < m_sensor_length; ++i) {

ADBG(3000, \ }

if (call AMSend.send(dest_address, &m_sensor_msg, m_sensor_length) != SUCCESS)

{

atomic m_sensoring = FALSE; } }

event void AMSend.sendDone(message_t* msg, error_t success) {

ADBG(DBG_LEV, \Sent%s!\\r\\n\(success == SUCCESS) ? \: \

if(j==0)

{post sensorDataTask();j++;} }

/* 节点启动完毕*/

event void Boot.booted() {

/*开启射频*/

ADBG(DBG_LEV, \ LED_BLUE_TOGGLE;

call AtosControl.start();

p_sensor_payload = call Packet.getPayload(&m_sensor_msg, NULL);

}

event void AtoSensorCollection.sensorDone(uint8_t* data, uint8_t len, error_t result)

{

ADBG(10, \(int)len, (int)result);

if(result == SUCCESS) {

m_sensor_length = len; post sendMsgTask(); } else {

atomic m_sensoring = FALSE; } }

/*射频接收数据*/

event message_t* Receive.receive(message_t* msg, void* payload, uint8_t len)

{

LED_BLUE_TOGGLE; if (len != 1) {

return NULL; } j=0;

ADBG(DBG_LEV, \len = %d payload = %c\\n\(int)len, *((char *)payload));

if (*(char *)payload == 'y' || *(char *)payload == 'Y') {

dest_address = call AMPacket.source(msg); post sensorDataTask(); } } }

实验十 RSSI

一、实验内容

通过大量测试两个点在不同距离通讯下的 RSSI 值，并以图形显示出来，横轴为距离，纵轴为RSSI值。

二、实验步骤

1) 将基站同电脑用烧录线连接好，打开基站的开关。 2) 用串口线将基站和 PC 机器连接起来。 3) 打开串口助手。

4) 打开 Cygwin 开发环境。

5) 在 Cygwin 开发环境中执行 cd /opt/atos/apps/Demos/RFDemos/ 2_RSSISample。

6) 在 RSSI 实验目录下执行 make antc5 install GRP=01 NID=01，进行软件的编译和烧录。

7) 烧录成功后，将基站的烧录开关拨下去，将节点对应的烧录开关拨上去，然后打开节点的开关。

8) 执行 make antc5 reinstall GRP=BB NID=02。 9) 重启基站.

10) 通过改变节点和基站的距离，可以观察到 RSSI 值的改变。在串口助手中有如下的内容：

################################################## [RSSISAMPLE DEMO]My Address=0x1,Group=0xBB ################################################## *Prepare to Receive: *Receive, len = [2], RSSI:[36] *Receive, len = [2], RSSI:[40] *Receive, len = [2], RSSI:[40] *Receive, len = [2], RSSI:[40] *Receive, len = [2], RSSI:[40] *Receive, len = [2], RSSI:[39] *Receive, len = [2], RSSI:[31] *Receive, len = [2], RSSI:[30] *Receive, len = [2], RSSI:[33] *Receive, len = [2], RSSI:[29] *Receive, len = [2], RSSI:[30] *Receive, len = [2], RSSI:[36] *Receive, len = [2], RSSI:[29] *Receive, len = [2], RSSI:[25] *Receive, len = [2], RSSI:[24] *Receive, len = [2], RSSI:[35] *Receive, len = [2], RSSI:[32] *Receive, len = [2], RSSI:[30]

三、实验结果

实验十一

星型拓扑：让基站的 ID 变为 2。每个基本节点都将自己的目的地址变为 2。并且最终通讯形成星形网络。

实验十二

树形拓扑：两组以上同学共同完成；

实验十三

远程控制：操作

实验十四

M2M短信收发：操作

实验十五

M2M短信控制：参考指令集操作

{

int i=0;

message_t m_msg;

/* 发送数据*/

task void sendData() {

uint16_t m_len = 0x00;

uint8_t* payload = call Packet.getPayload(&m_msg, NULL); uint16_t address = call AMPacket.address(); *payload = 0x01; m_len = 0x01;

if (address == 0x01) {

call AMSend.send(0xFFFF, &m_msg, m_len); LED_BLUE_TOGGLE; } }

/*发送完处理*/

event void AMSend.sendDone(message_t* msg, error_t success) { }

/* 节点启动完毕*/

event void Boot.booted() {

/*开启射频*/

call AtosControl.start();

LED_YELLOW_ON; LED_BLUE_ON;

call SensorTimer.startPeriodic(1000); }

event void SensorTimer.fired() {

post sendData(); }

/*射频接收数据*/

event message_t* Receive.receive(message_t* msg, void* payload, uint8_t len)

{ /**在蓝灯闪三次后停止闪烁，然后关闭射频*/ i++; if(i<6) {

LED_BLUE_TOGGLE; } else {

/*LED_BULE_OFF;*/ }

Call AtosControl.stop(); } }

实验八

AD和数字传感采集：操作

实验九传感通信

一、实验内容

每次基站发送一个采集命令，节点采集两次数据，并且分两组数据发送到基站。

二、实验步骤

1) 将基站同电脑用烧录线连接好，打开基站的开关。 2) 用串口线将基站和 PC 机器连接起来。 3) 打开串口助手。

4) 打开 Cygwin 开发环境。

5) 在 Cygwin 开发环境中执行 cd apps/Demos/sensor/CommSensor/Base。 6) 在采集通讯基站目录下执行 make antc5 install GRP=BB NID=01，进行软件的编译和烧录。

7) 执行 cd apps/Demos/sensor/CommSensor/Node。

8) 在采集通讯节点目录下面执行 make antc5 ASO=LIGHT TYPE=3 install GRP=BB NID=02。

9) 重启基站，在串口助手中有如下的内容： ############################################### My Address = 0x1, Group = 0xBB ############################################### ############################################### * MY NodeId = 0x1, Group=0xBB, destination ? 2 *To Send:(Y or N) y payload = y *Sending … from[1],to[2],len=[1] *SentOK! ############################################### * MY NodeId = 0x1, Group=0xBB, destination ? *Receive, len=[2],DATA:

3e f0 ############################################### * MY NodeId = 0x1, Group=0xBB, destination ? *Receive, len=[2],DATA: 3e f4 三、实验代码

#define DBG_LEV 9

module CommSensorNodeP {

uses {

interface Boot;

interface AtosControl; interface AMSend; interface Receive; interface AMPacket; interface Packet;

interface AtoSensorCollection; } }

implementation {

message_t m_sensor_msg; uint sensor_retry = 0; bool m_sensoring = FALSE; uint8_t m_sensor_length = 0; uint8_t m_sensor_length1 = 0; uint8_t* p_sensor_payload; uint8_t* p_sensor_payload1; uint16_t dest_address; int j=0;

task void sensorDataTask() {

int i=0;

error_t result; result =

AtoSensorCollection.startSensor(p_sensor_payload);

if(result != SUCCESS) {

if (sensor_retry++ < 3) {

post sensorDataTask(); } else {

atomic m_sensoring = FALSE; } }

}

call

本文来源：https://www.bwwdw.com/article/gr0f.html

相关文章：