实验九 ZStack 广播通信实验
【实验目的】
1. 了解 ZigBee 广播通信的原理
2. 掌握在 ZigBee 网络中进行广播通信的方法
【实验设备】
1. 装有 IAR 开发工具的 PC 机一台
2. 实验箱一台
3. CCDebugger（以及 USB A-B 延长线）一个
4. USB Mini 延长线一根
【实验要求】
1. 编程要求：使用协议栈提供的 API 函数编写应用程序。
2. 实现功能：送节点向加入到同一 PANID 的 ZigBee 网络的所有节点以广播形式发送消息。
3. 实验现象：带有广播信息接收功能的节点收到广播信息后连续、快速闪烁节点上的通信指示灯
LED_D8（并通过串口输出接收到的信息——字符串“Broadcast Message”）。
【实验原理】
在 ZigBee 网络中设置一个广播信息发送节点，若干个广播信息接收节点，发送节点周期性的向所有
节点广播消息，广播发送节点发送广播消息后通信指示灯会连续闪烁 3 次，允许接收广播消息的节点接收
到广播信息后，控制节点的通信指示灯 LED_D8 连续闪烁四次。通过观察各个节点的通信指示灯就可以判断是否接收到广播信息。
实验流程图
实验步骤
１.打开Tools中的f8wConfig.cfg，将里面DZAPP_CONFIG_PAN_ID=0xFFFF
的0xFFFF改成其他值；
PAN_ID改成0x0020
2. 在工程目录结构树上方的下拉列表中，选择“CoordinatorEB” ，将实验箱的一个节点指定为协调器，编译调试，将代码烧进节点里；
3. 在“SAPP_Device.h”文件中，取消“HAS_BROADCASTSEND”的注释，
4.在工程目录结构树上方的下拉列表中，选择“EndDeviceEB”, 转换实验箱节点，将此节点指定为发送节点，编译调试，将代码烧进节点里；
5. 在“SAPP_Device.h”文件中，取消“HAS_BROADCASTSEND”的注释，
转换实验箱节点，将此节点指定为接收节点，编译调试，将代码烧进节点里，重复几次第5步骤，可多设置接收节点；
实验现象：可以看到协调器节点和发送端的节点的通信灯同时闪烁，接收器节点的D8连续闪烁4次，表示接收到信息。
实验感想：
通过此次实验了解了 ZigBee 广播通信的原理，掌握在 ZigBee 网络中进行广播通信的方法，通过课上教授的知识，学以致用。
实验完整代码：
节点定义广播发送和接收
APP_Base.c
#include "APP_Base.h"
#if defined(SAPP_ZSTACK_DEMO)
#include "hal_led.h"
// 任务建立实验范例代码
// 任务处理函数
uint16 Hello_ProcessEvent(uint8 task_id, uint16 events);
uint16 Hello_ProcessEvent(uint8 task_id, uint16 events)
{
if(events & 0x0001)
{
// 控制LED闪烁
HalLedBlink(HAL_LED_1, 1, 50, 250);
// 启动定时器, 设置1秒钟后再次触发该任务
osal_start_timerEx(task_id, 0x0001, 1000);
}
// 清除定时器事件标志
return (events ^ 0x0001);
}
#endif
// 任务列表
const pTaskEventHandlerFn tasksArr[] = {
macEventLoop,
nwk_event_loop,
Hal_ProcessEvent,
#if defined( MT_TASK )
MT_ProcessEvent,
#endif
APS_event_loop,
#if defined ( ZIGBEE_FRAGMENTATION )
APSF_ProcessEvent,
#endif
ZDApp_event_loop,
#if defined ( ZIGBEE_FREQ_AGILITY ) || defined ( ZIGBEE_PANID_CONFLICT )
ZDNwkMgr_event_loop,
#endif
#if defined(SAPP_ZSTACK)
sapp_controlEpProcess,
sapp_functionEpProcess,
#endif
#if defined(SAPP_ZSTACK_DEMO)
// 任务建立实验范例代码
// 任务列表
Hello_ProcessEvent,
#endif
};
const uint8 tasksCnt = sizeof(tasksArr)/sizeof(tasksArr[0]);
// 初始化任务
void osalInitTasks( void )
{
uint8 taskID = 0;
macTaskInit( taskID++ );
nwk_init( taskID++ );
Hal_Init( taskID++ );
#if defined( MT_TASK )
MT_TaskInit( taskID++ );
#endif
APS_Init( taskID++ );
#if defined ( ZIGBEE_FRAGMENTATION )
APSF_Init( taskID++ );
#endif
ZDApp_Init( taskID++ );
#if defined ( ZIGBEE_FREQ_AGILITY ) || defined ( ZIGBEE_PANID_CONFLICT )
ZDNwkMgr_Init( taskID++ );
#endif
#if defined(SAPP_ZSTACK)
sapp_taskInitProcess();
#endif
#if defined(SAPP_ZSTACK_DEMO)
// 任务建立实验范例代码
// 启动定时器
osal_start_timerEx(taskID, 0x0001, 1000);
#endif
}
APP_Base.h
#ifndef _APP_BASE_H_
#define _APP_BASE_H_
#include "ZComDef.h"
#include "hal_drivers.h"
#include "OSAL.h"
#include "ZGlobals.h"
#include "AF.h"
#include "aps_groups.h"
#include "nwk.h"
#include "APS.h"
#if defined ( ZIGBEE_FRAGMENTATION )
#include "aps_frag.h"
#endif
#include "MT.h"
#include "MT_UART.h"
#if defined( MT_TASK )
#include "MT_TASK.h"
#endif
#if defined ( ZIGBEE_FREQ_AGILITY ) || defined ( ZIGBEE_PANID_CONFLICT )
#include "ZDNwkMgr.h"
#endif
#include "ZDApp.h"
#include "ZComDef.h"
#include "OSAL_Tasks.h"
#include "aps_groups.h"
#include "OnBoard.h"
#if defined(SAPP_ZSTACK)
#include "SAPP_FrameWork.h"
#endif
#endif//_APP_BASE_H_
SAPP_Device.c
#if defined(SAPP_ZSTACK)
#include "SAPP_Device.h"
#include "hal_io.h"
#include <string.h>
/**************************************************************/
/* 传感器列表 */
/**************************************************************/
/********************************/
/* 燃气传感器 */
/********************************/
#if defined(HAS_GAS)
#define GAS_IO_GROUP 0
#define GAS_IO_BIT 0
void sensorGasResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void sensorGasResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
{
HalIOSetInput(GAS_IO_GROUP, GAS_IO_BIT, Pull_Down);
HalIOIntSet(ep->ep, GAS_IO_GROUP, GAS_IO_BIT, IOInt_Rising, 0);
}
//IO端口中断触发，中断源检测
if(type == ResIOInt)
{
uint8 GasValue = 1;
SendData(ep->ep, &GasValue, 0x0000, TRANSFER_ENDPOINT, sizeof(GasValue));
}
}
void sensorGasTimeout(struct ep_info_t *ep);
void sensorGasTimeout(struct ep_info_t *ep)
{
uint8 value = HalIOGetLevel(GAS_IO_GROUP, GAS_IO_BIT);
SendData(ep->ep, &value, 0x0000, TRANSFER_ENDPOINT, sizeof(value));
}
#endif
/********************************/
/* 温度传感器 */
/********************************/
#if defined(HAS_TEMP) || defined(HAS_HUMM)
#include "sht10.h"
static uint16 TempValue = 0;
#endif
#if defined(HAS_TEMP)
void sensorTempResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void sensorTempResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
{
SHT10_init(0x01);
}
}
void sensorTempTimeout(struct ep_info_t *ep);
void sensorTempTimeout(struct ep_info_t *ep)
{
unsigned int value = 0;
unsigned char checksum = 0;
SHT10_Measure(&value,&checksum, TEMPERATURE);
TempValue = (value << 2) - 3960;
SendData(ep->ep, &TempValue, 0x0000, TRANSFER_ENDPOINT, sizeof(TempValue));
}
#endif
/********************************/
/* 湿度传感器 */
/********************************/
#if defined(HAS_HUMM)
void sensorHummResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void sensorHummResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
{
SHT10_init(0x01);
}
}
void sensorHummTimeout(struct ep_info_t *ep);
void sensorHummTimeout(struct ep_info_t *ep)
{
const float C1 = -4.0f; // for 8 Bit
const float C2 = +0.648f; // for 8 Bit
const float C3 = -0.0000072f; // for 8 Bit
const float T1 = 0.01f; // for 8 bit
const float T2 = 0.00128f; // for 8 bit
float rh_lin = 0.0f; // rh_lin: Humidity linear
float rh_true = 0.0f; // rh_true: Temperature compensated humidity
float t_C = 0.0f; // t_C : Temperature []
unsigned int HumiValue = 0;
unsigned char checksum = 0;
SHT10_Measure(&HumiValue,&checksum, HUMIDITY);
rh_lin=C3*HumiValue*HumiValue + C2*HumiValue + C1; //calc. humidity from ticks to [%RH]
rh_true=(t_C-25)*(T1+T2*HumiValue)+rh_lin; //calc. temperature compensated humidity [%RH]
if(rh_true>100)
rh_true=100; //cut if the value is outside of
if(rh_true<0.1)
rh_true=0.1f; //the physical possible range
HumiValue = (unsigned int)(rh_true * 100);
SendData(ep->ep, &HumiValue, 0x0000, TRANSFER_ENDPOINT, sizeof(HumiValue));
}
#endif
/********************************/
/* 雨滴传感器 */
/********************************/
#if defined(HAS_RAIN)
#define RAIN_IO_GROUP 0
#define RAIN_IO_BIT 0
void sensorRainResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void sensorRainResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
{
HalIOSetInput(RAIN_IO_GROUP, RAIN_IO_BIT, Pull_None);
HalIOIntSet(ep->ep, RAIN_IO_GROUP, RAIN_IO_BIT, IOInt_Rising, 0);
}
//IO端口中断触发，中断源检测
if(type == ResIOInt)
{
uint8 RainValue = 1;
SendData(ep->ep, &RainValue, 0x0000, TRANSFER_ENDPOINT, sizeof(RainValue));
}
}
void sensorRainTimeout(struct ep_info_t *ep);
void sensorRainTimeout(struct ep_info_t *ep)
{
uint8 value = HalIOGetLevel(RAIN_IO_GROUP, RAIN_IO_BIT);
SendData(ep->ep, &value, 0x0000, TRANSFER_ENDPOINT, sizeof(value));
}
#endif
/********************************/
/* 火焰传感器 */
/********************************/
#if defined(HAS_FIRE)
#define FIRE_IO_GROUP 0
#define FIRE_IO_BIT 0
void sensorFireResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void sensorFireResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
{
HalIOSetInput(FIRE_IO_GROUP, FIRE_IO_BIT, Pull_Down);
HalIOIntSet(ep->ep, FIRE_IO_GROUP, FIRE_IO_BIT, IOInt_Rising, 0);
}
//IO端口中断触发，中断源检测
if(type == ResIOInt)
{
uint8 FireValue = 1;
SendData(ep->ep, &FireValue, 0x0000, TRANSFER_ENDPOINT, sizeof(FireValue));
}
}
void sensorFireTimeout(struct ep_info_t *ep);
void sensorFireTimeout(struct ep_info_t *ep)
{
uint8 value = HalIOGetLevel(FIRE_IO_GROUP, FIRE_IO_BIT);
SendData(ep->ep, &value, 0x0000, TRANSFER_ENDPOINT, sizeof(value));
}
#endif
/********************************/
/* 烟雾传感器 */
/********************************/
#if defined(HAS_SMOKE)
#define SMOKE_IO_GROUP 0
#define SMOKE_IO_BIT 0
void sensorSmokeResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void sensorSmokeResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
{
HalIOSetInput(SMOKE_IO_GROUP, SMOKE_IO_BIT, Pull_Down);
HalIOIntSet(ep->ep, SMOKE_IO_GROUP, SMOKE_IO_BIT, IOInt_Rising, 0);
}
//IO端口中断触发，中断源检测
if(type == ResIOInt)
{
uint8 SmokeValue = 1;
SendData(ep->ep, &SmokeValue, 0x0000, TRANSFER_ENDPOINT, sizeof(SmokeValue));
}
}
void sensorSmokeTimeout(struct ep_info_t *ep);
void sensorSmokeTimeout(struct ep_info_t *ep)
{
uint8 value = HalIOGetLevel(SMOKE_IO_GROUP, SMOKE_IO_BIT);
SendData(ep->ep, &value, 0x0000, TRANSFER_ENDPOINT, sizeof(value));
}
#endif
/********************************/
/* 光照度传感器 */
/********************************/
#if defined(HAS_ILLUM)
#include "hal_adc.h"
void sensorILLumTimeout(struct ep_info_t *ep);
void sensorILLumTimeout(struct ep_info_t *ep)
{
uint16 LightValue = 256 - (HalAdcRead(0, HAL_ADC_RESOLUTION_14) >> 3);
// 将AD值变换为光照度的100倍
LightValue = LightValue * 39;// * 10000 / 256;
SendData(ep->ep, &LightValue, 0x0000, TRANSFER_ENDPOINT, sizeof(LightValue));
}
#endif
/********************************/
/* 安防传感器 */
/********************************/
#if defined(HAS_IRPERS)
#define SAFTY_IO_GROUP 1
#define SAFTY_IO_BIT 0
void sensorIRPersResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void sensorIRPersResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
{
HalIOSetInput(SAFTY_IO_GROUP, SAFTY_IO_BIT, Pull_Down);
HalIOIntSet(ep->ep, SAFTY_IO_GROUP, SAFTY_IO_BIT, IOInt_Rising, 0);
}
//IO端口中断触发，中断源检测
if(type == ResIOInt)
{
uint8 IRPersValue = 1;
SendData(ep->ep, &IRPersValue, 0x0000, TRANSFER_ENDPOINT, sizeof(IRPersValue));
}
}
void sensorIRPersTimeout(struct ep_info_t *ep);
void sensorIRPersTimeout(struct ep_info_t *ep)
{
uint8 value = HalIOGetLevel(SAFTY_IO_GROUP, SAFTY_IO_BIT);
SendData(ep->ep, &value, 0x0000, TRANSFER_ENDPOINT, sizeof(value));
}
#endif
/********************************/
/* 红外测距传感器 */
/********************************/
#if defined(HAS_IRDIST)
#include "hal_adc.h"
extern uint16 irDistTab[256];
void sensorIRDistTimeout(struct ep_info_t *ep);
void sensorIRDistTimeout(struct ep_info_t *ep)
{
uint8 value = HalAdcRead(0, HAL_ADC_RESOLUTION_14) >> 3;
// 计算距离值value的单位为mm
uint16 IRDistValue = irDistTab[value];
SendData(ep->ep, &IRDistValue, 0x0000, TRANSFER_ENDPOINT, sizeof(IRDistValue));
}
#endif
/********************************/
/* 语音传感器 */
/********************************/
#if defined(HAS_VOICE)
#include "hal_uart.h"
static struct ep_info_t *voiceEndPoint = NULL;
static uint8 LastVoiceData = 0;
static void sensorVoiceUartProcess( uint8 port, uint8 event );
static void sensorVoiceUartProcess( uint8 port, uint8 event )
{
(void)event; // Intentionally unreferenced parameter
while (Hal_UART_RxBufLen(port))
{
HalUARTRead(port, &LastVoiceData, 1);
if(LastVoiceData == 0xAA)
LastVoiceData = 1;
else if(LastVoiceData == 0x55)
LastVoiceData = 0;
else
LastVoiceData = -1;
if(voiceEndPoint != NULL)
SendData(voiceEndPoint->ep, &LastVoiceData, 0x0000, TRANSFER_ENDPOINT, 1);
}
}
void sensorVoiceNwkStateChange(struct ep_info_t *ep);
void sensorVoiceNwkStateChange(struct ep_info_t *ep)
{
voiceEndPoint = ep;
}
void sensorVoiceResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void sensorVoiceResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
{
halUARTCfg_t uartConfig;
voiceEndPoint = ep;
/* UART Configuration */
uartConfig.configured = TRUE;
uartConfig.baudRate = HAL_UART_BR_9600;
uartConfig.flowControl = FALSE;
uartConfig.flowControlThreshold = MT_UART_DEFAULT_THRESHOLD;
uartConfig.rx.maxBufSize = MT_UART_DEFAULT_MAX_RX_BUFF;
uartConfig.tx.maxBufSize = MT_UART_DEFAULT_MAX_TX_BUFF;
uartConfig.idleTimeout = MT_UART_DEFAULT_IDLE_TIMEOUT;
uartConfig.intEnable = TRUE;
uartConfig.callBackFunc = sensorVoiceUartProcess;
HalUARTOpen(HAL_UART_PORT_1, &uartConfig);
}
}
void sensorVoiceTimeout(struct ep_info_t *ep);
void sensorVoiceTimeout(struct ep_info_t *ep)
{
uint8 nulData = 0;
SendData(ep->ep, &nulData, 0x0000, TRANSFER_ENDPOINT, 1);
}
#endif
/********************************/
/* 二进制执行器传感器 */
/********************************/
#if defined(HAS_EXECUTEB)
#define ControlInit() do { HalIOSetOutput(1,4);HalIOSetOutput(1,5);HalIOSetOutput(1,6);HalIOSetOutput(1,7);Control(0); } while(0)
#define Control(mask) do { HalIOSetLevel(1,4,mask&0x01);HalIOSetLevel(1,5,mask&0x02);HalIOSetLevel(1,6,mask&0x04);HalIOSetLevel(1,7,mask&0x08); } while(0)
void OutputExecuteBResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void OutputExecuteBResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
ControlInit();
}
void outputExecuteB(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg);
void outputExecuteB(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg)
{
//msg->Data[], msg->DataLength, msg->TransSeqNumber
Control(msg->Data[0]);
SendData(ep->ep, &msg->Data[0], 0x0000, TRANSFER_ENDPOINT, 1);
}
void outputExecuteBTimeout(struct ep_info_t *ep);
void outputExecuteBTimeout(struct ep_info_t *ep)
{
uint8 value = P1 >> 4;
SendData(ep->ep, &value, 0x0000, TRANSFER_ENDPOINT, sizeof(value));
}
#endif
/********************************/
/* 模拟执行器传感器 */
/********************************/
#if defined(HAS_EXECUTEA)
void outputExecuteA(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg);
void outputExecuteA(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg)
{
}
#endif
/********************************/
/* 遥控器传感器 */
/********************************/
#if defined(HAS_REMOTER)
#include "IR.h"
static uint8 lastCode[32];
static uint8 lastCodeLen = 0;
void IRSendResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void IRSendResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
IRSendInit(); // 需要初始化
}
void outputRemoter(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg);
void outputRemoter(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg)
{
lastCodeLen = msg->Data[0];
memcpy(lastCode, &msg->Data[1], lastCodeLen);
GenIR(&msg->Data[1], IRGuideLen_9ms, (uint8)lastCodeLen);
SendData(ep->ep, lastCode, 0x0000, TRANSFER_ENDPOINT, lastCodeLen>>3);
}
void outputRemoterTimeout(struct ep_info_t *ep);
void outputRemoterTimeout(struct ep_info_t *ep)
{
if(lastCodeLen <= 0)
{
uint8 value = 0;
SendData(ep->ep, &value, 0x0000, TRANSFER_ENDPOINT, 1);
}
else
SendData(ep->ep, lastCode, 0x0000, TRANSFER_ENDPOINT, lastCodeLen>>3);
}
#endif
/********************************/
/* 虚拟功能 */
/********************************/
#if defined(HAS_TESTFUNCTION)
#define TEST_STRING "Z-Stack for SAPP"
static uint8 lastData[119] = TEST_STRING;
static uint8 lastLen = 0;
void testFunc_RecvData(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg);
void testFunc_RecvData(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg)
{
lastLen = msg->DataLength;
memcpy(&lastData[sizeof(TEST_STRING) - 1], msg->Data, lastLen);
SendData(ep->ep, lastData, 0x0000, TRANSFER_ENDPOINT,
lastLen + sizeof(TEST_STRING) - 1);
}
void testFunc_TimeOut(struct ep_info_t *ep);
void testFunc_TimeOut(struct ep_info_t *ep)
{
SendData(ep->ep, lastData, 0x0000, TRANSFER_ENDPOINT,
lastLen + sizeof(TEST_STRING) - 1);
}
#endif
/********************************/
/* 广播发送功能 */
/********************************/
#if defined(HAS_BROADCASTSEND)
#define BROADCAST_STRING "\r\nBroadcast Message\r\n"
void BroadcastSend_TimeOut(struct ep_info_t *ep);
void BroadcastSend_TimeOut(struct ep_info_t *ep)
{
SendData(ep->ep, BROADCAST_STRING, 0XFFFF, TRANSFER_ENDPOINT,
sizeof(BROADCAST_STRING) - 1);
//广播后指示灯 LED_D9 闪烁2次
HalLedBlink( HAL_LED_2, 2, 50, 100 );
}
#endif
/********************************/
/* 广播接收功能 */
/********************************/
#if defined(HAS_BROADCASTRECEIVE)
void BroadcastReceiveData(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg);
void BroadcastReceiveData(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg)
{
//收到广播数据后 LED_D8 连续闪烁4次!
HalLedBlink( HAL_LED_1, 4, 50, 120 );
HalUARTWrite(HAL_UART_PORT_0, msg->Data, msg->DataLength);
}
#define BROADCAST_STRING "Broadcast Message"
void BroadcastSend_TimeOut(struct ep_info_t *ep);
void BroadcastSend_TimeOut(struct ep_info_t *ep)
{
SendData(ep->ep, BROADCAST_STRING, 0X0000, TRANSFER_ENDPOINT,
sizeof(BROADCAST_STRING) - 1);
}
#endif
/********************************/
/* IC卡读卡器 */
/********************************/
#if defined(HAS_125KREADER)
#include "hal_uart.h"
#define CARDID_SIZE 5 // 卡号长度
static uint8 lastCardId[CARDID_SIZE]; // 用来保存接收到的卡号
static uint8 cardRecvIdx; // 上一次接收到的长度
static uint32 lastTick; // 上一次接收数据的系统时间
static struct ep_info_t *cardEndPoint;
static void sensor125kReaderUartProcess( uint8 port, uint8 event );
static void sensor125kReaderUartProcess( uint8 port, uint8 event )
{
(void)event; // Intentionally unreferenced parameter
if((lastTick + 100) <= osal_GetSystemClock())
{ // 如果本次接收到的时间距离上次超过了0.1秒
cardRecvIdx = 0; // 则清空计数器，重新接收卡号
}
lastTick = osal_GetSystemClock(); // 记录下当前的时间
while (Hal_UART_RxBufLen(port))
{
uint16 restLen = Hal_UART_RxBufLen(port);
if(restLen > (CARDID_SIZE - cardRecvIdx))
restLen = CARDID_SIZE - cardRecvIdx;
HalUARTRead(port, &lastCardId[cardRecvIdx], restLen);
cardRecvIdx += restLen;
if(cardRecvIdx >= CARDID_SIZE) // 如果已经接收完成一个完整的卡号
{ // 则发送给协调器
SendData(cardEndPoint->ep, lastCardId, 0x0000, TRANSFER_ENDPOINT, CARDID_SIZE);
}
}
}
void sensor125kReaderResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void sensor125kReaderResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
{
halUARTCfg_t uartConfig;
memset(lastCardId, 0, sizeof(lastCardId));
cardRecvIdx = 0;
cardEndPoint = ep;
/* UART Configuration */
uartConfig.configured = TRUE;
uartConfig.baudRate = HAL_UART_BR_19200;
uartConfig.flowControl = FALSE;
uartConfig.flowControlThreshold = MT_UART_DEFAULT_THRESHOLD;
uartConfig.rx.maxBufSize = MT_UART_DEFAULT_MAX_RX_BUFF;
uartConfig.tx.maxBufSize = MT_UART_DEFAULT_MAX_TX_BUFF;
uartConfig.idleTimeout = MT_UART_DEFAULT_IDLE_TIMEOUT;
uartConfig.intEnable = TRUE;
uartConfig.callBackFunc = sensor125kReaderUartProcess;
HalUARTOpen(HAL_UART_PORT_0, &uartConfig);
}
}
void sensor125kReaderTimeout(struct ep_info_t *ep);
void sensor125kReaderTimeout(struct ep_info_t *ep)
{
uint8 nullId[CARDID_SIZE] = { 0x00 };
SendData(cardEndPoint->ep, nullId, 0x0000, TRANSFER_ENDPOINT, CARDID_SIZE);
}
#endif
/********************************/
/* 语音播放节点 */
/********************************/
#if defined(HAS_SPEAKER)
void OutputSpeakerResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void OutputSpeakerResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
HalUART1HwInit();
}
void outputSpeaker(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg);
void outputSpeaker(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg)
{
//msg->Data[], msg->DataLength, msg->TransSeqNumber
HalUART1HwTxByte(msg->Data[0]);
// SendData(ep->ep, &msg->Data[0], 0x0000, TRANSFER_ENDPOINT, 1);
}
void outputSpeakerTimeout(struct ep_info_t *ep);
void outputSpeakerTimeout(struct ep_info_t *ep)
{
uint8 value = 0;
SendData(ep->ep, &value, 0x0000, TRANSFER_ENDPOINT, sizeof(value));
}
#endif
/********************************/
/* 红外接收解码 */
/********************************/
#if defined(HAS_IRDecode)
#include <hal_irdec.h>
void IRDecodeResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res);
void IRDecodeResAvailable(struct ep_info_t *ep, RES_TYPE type, void *res)
{
if(type == ResInit)
{
IRDecodeT1Init(ep->task_id, ep->ep);
}
//定时器1通道0一次红外解码结束,向上传送解码结果
if(type == ResTimerInt)
{
OSALIRDecData_t *irData = (OSALIRDecData_t *)res;
SendData(ep->ep, irData->irCode, 0x0000, TRANSFER_ENDPOINT, irData->irLen);
}
}
void IRDecodeTimeout(struct ep_info_t *ep);
void IRDecodeTimeout(struct ep_info_t *ep)
{
uint8 value = 0;
SendData(ep->ep, &value, 0x0000, TRANSFER_ENDPOINT, sizeof(value));
}
#endif
/***************************************************/
/* 节点功能列表 */
/***************************************************/
struct ep_info_t funcList[] = {
#if defined(HAS_GAS)
{
// 加入网络,收到数据,超时处理,资源变化
NULL, NULL, sensorGasTimeout, sensorGasResAvailable,
{ DevGas, 0, 5 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_TEMP)
{
NULL, NULL, sensorTempTimeout, sensorTempResAvailable,
{ DevTemp, 1, 5 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_HUMM)
{
NULL, NULL, sensorHummTimeout, sensorHummResAvailable,
{ DevHumm, 0, 5 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_ILLUM)
{
NULL, NULL, sensorILLumTimeout, NULL,
{ DevILLum, 0, 3 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_RAIN)
{
NULL, NULL, sensorRainTimeout, sensorRainResAvailable,
{ DevRain, 0, 5 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_IRDIST)
{
NULL, NULL, sensorIRDistTimeout, NULL,
{ DevIRDist, 0, 3 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_SMOKE)
{
NULL, NULL, sensorSmokeTimeout, sensorSmokeResAvailable,
{ DevSmoke, 0, 5 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_FIRE)
{
NULL, NULL, sensorFireTimeout, sensorFireResAvailable,
{ DevFire, 0, 3 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_IRPERS)
{
NULL, NULL, sensorIRPersTimeout, sensorIRPersResAvailable,
{ DevIRPers, 0, 2 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_VOICE)
{
sensorVoiceNwkStateChange, NULL, sensorVoiceTimeout, sensorVoiceResAvailable,
{ DevVoice, 0, 5 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_EXECUTEB)
{
NULL, outputExecuteB, outputExecuteBTimeout, OutputExecuteBResAvailable,
{ DevExecuteB, 3, 10 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_EXECUTEA)
{
NULL, outputExecuteA, NULL, NULL,
{ DevExecuteA, 0, 3 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_REMOTER)
{
NULL, outputRemoter, outputRemoterTimeout, IRSendResAvailable,
{ DevRemoter, 0, 3 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_TESTFUNCTION)
{
NULL,
testFunc_RecvData,
testFunc_TimeOut,
NULL,
{ DevTest, 0, 3 },
},
#endif
#if defined(HAS_BROADCASTSEND)
{
NULL,
NULL,
BroadcastSend_TimeOut,
NULL,
{ DevBroadcastSend, 0, 3 },
},
#endif
#if defined(HAS_BROADCASTRECEIVE)
{
NULL,
BroadcastReceiveData,
BroadcastSend_TimeOut,
NULL,
{ DevBroadcastReceive, 0, 30 },
},
#endif
#if defined(HAS_125KREADER)
{
NULL, NULL, sensor125kReaderTimeout, sensor125kReaderResAvailable,
{ Dev125kReader, 0, 10 },
},
#endif
#if defined(HAS_SPEAKER)
{
NULL, outputSpeaker, outputSpeakerTimeout, OutputSpeakerResAvailable,
{ DevSpeaker, 0, 9 }, // type, id, refresh cycle
},
#endif
#if defined(HAS_IRDecode)
{
NULL, NULL, IRDecodeTimeout, IRDecodeResAvailable,
{ DevIRDecode, 0, 5 }, // type, id, refresh cycle
},
#endif
#if defined(ZDO_COORDINATOR)
{ // 协调器
CoordinatorNwkStateChangeRoutine,
CoordinatorIncomingRoutine,
CoordinatorTimeoutRoutine,
CoordinatorResAvailableRoutine,
{ DevCoordinator, 0, 0 },
},
#elif defined(RTR_NWK)
{ // 路由器
RouterNwkStateChangeRoutine,
RouterIncomingRoutine,
RouterTimeoutRoutine,
RouterResAvailableRoutine,
{ DevRouter, 0, 30 },
},
#endif
};
// 不能修改下面的内容!!!
const uint8 funcCount = sizeof(funcList) / sizeof(funcList[0]);
#endif
SAPP_Device.h
#ifndef _SAPP_DEVICE_H_
#define _SAPP_DEVICE_H_
#include "SAPP_FrameWork.h"
#ifdef __cplusplus
extern "C"
{
#endif
// 功能类型值定义
enum {
DevTemp = 1, // 空气温度
DevHumm, // 空气湿度
DevILLum, // 光照度
DevRain, // 雨滴
DevIRDist, // 红外测距
DevGas, // 燃气
DevSmoke, // 烟雾
DevFire, // 火焰
DevIRPers, // 人体红外
DevVoice, // 语音识别
DevExecuteB, // 开关量输出执行器
DevExecuteA, // 模拟量输出执行器
DevRemoter, // 红外遥控
Dev125kReader, // 125kHz读卡器
DevSpeaker, // 语音报警
DevTest, // 功能测试
DevBroadcastSend, // 广播发送
DevBroadcastReceive, // 广播接收
DevIRDecode, // 红外遥控解码
DevMaxNum,
};
#if !defined( ZDO_COORDINATOR ) && !defined( RTR_NWK )
// 节点功能定义
//#define HAS_GAS // 瓦斯传感器
//#define HAS_TEMP // 温度传感器
//#define HAS_HUMM // 湿度传感器
//#define HAS_RAIN // 雨滴传感器
//#define HAS_FIRE // 火焰传感器
//#define HAS_SMOKE // 烟雾传感器
//#define HAS_ILLUM // 光照度传感器
//#define HAS_IRPERS // 人体红外传感器
//#define HAS_IRDIST // 红外测距传感器
//#define HAS_VOICE // 语音传感器, 修改 HAL_UART_DMA 的定义为2
//#define HAS_EXECUTEB // 执行器
//#define HAS_EXECUTEA // 模拟执行器(预留扩展)
//#define HAS_REMOTER // 红外遥控(预留扩展)
//#define HAS_TESTFUNCTION // 虚拟功能
//#define HAS_BROADCASTSEND // 广播发送
//#define HAS_BROADCASTRECEIVE // 广播接收
//#define HAS_125KREADER // 125K电子标签阅读器
//#define HAS_SPEAKER // 语音报警器
//#define HAS_IRDecode // 红外解码
#endif
#ifdef __cplusplus
}
#endif
#endif//_SAPP_DEVICE_H_
SAPP_FrameWork.h
#if defined(SAPP_ZSTACK)
#include "SAPP_FrameWork.h"
#include <string.h>
/*********************************************************************
* FUNCTIONS
*********************************************************************/
static void createEndPoint(struct ep_info_t *epInfo, uint8 *task_id, uint8 ep);
#if defined(ZDO_COORDINATOR)
static uint8 uartMsgProcesser(uint8 *msg);
#endif
/*********************************************************************
* Local Variables
*********************************************************************/
//uint8 ctrlBuffer[sizeof(TOPOINFO) + sizeof(FUNCTABLE) + FUNC_NUM * sizeof(FUNCINFO)];
static TOPOINFO topoBuffer = { 0x02 };
FUNCTABLE *funcTableBuffer;// = (FUNCTABLE *)(&ctrlBuffer[sizeof(TOPOINFO)]);
static devStates_t curNwkState;
static uint8 controlTaskId;
static uint8 functionTaskId;
static struct ep_info_t controlEndPointInfo;
static uint8 isUserTimerRunning = 0;
void sapp_taskInitProcess(void)
{
#if defined ( BUILD_ALL_DEVICES )
// The "Demo" target is setup to have BUILD_ALL_DEVICES and HOLD_AUTO_START
// We are looking at a jumper (defined in SampleAppHw.c) to be jumpered
// together - if they are - we will start up a coordinator. Otherwise,
// the device will start as a router.
if ( readCoordinatorJumper() )
zgDeviceLogicalType = ZG_DEVICETYPE_COORDINATOR;
else
zgDeviceLogicalType = ZG_DEVICETYPE_ROUTER;
#endif // BUILD_ALL_DEVICES
#if defined ( HOLD_AUTO_START )
// HOLD_AUTO_START is a compile option that will surpress ZDApp
// from starting the device and wait for the application to
// start the device.
ZDOInitDevice(0);
#endif
// 构造功能列表
funcTableBuffer = createFuncTable(funcCount);
funcTableBuffer->ft_type = 0x01;
funcTableBuffer->ft_count = funcCount;
int i;
for(i = 0; i < funcCount; i++)
{
funcTableBuffer->ft_list[i].type = funcList[i].function.type;
funcTableBuffer->ft_list[i].id = funcList[i].function.id;
funcTableBuffer->ft_list[i].cycle = funcList[i].function.cycle;
}
controlTaskId = tasksCnt - 2;
functionTaskId = tasksCnt - 1;
HalIOInit(functionTaskId);
createEndPoint(&controlEndPointInfo, &controlTaskId, CONTROL_ENDPOINT);
for(i = 0; i < funcCount; i++)
{
struct ep_info_t *ep = &funcList[i];
createEndPoint(ep, &functionTaskId, i + 1);
if(ep->res_available)
(*ep->res_available)(ep, ResInit, NULL);
}
#if defined(ZDO_COORDINATOR)// || defined(RTR_NWK)
// RegisterForKeys( SampleApp_TaskID );
MT_UartRegisterTaskID(controlTaskId);
#endif
}
/*********************************************************************
* LOCAL FUNCTIONS
*/
static void createEndPoint(struct ep_info_t *epInfo, uint8 *task_id, uint8 ep)
{
static cId_t commonClusterId = SAPP_PERIODIC_CLUSTERID;
// Fill out the endpoint description.
epInfo->task_id = *task_id;
epInfo->ep = ep;
epInfo->timerTick = epInfo->function.cycle;
epInfo->userTimer = 0;
epInfo->simpleDesc.EndPoint = ep;
epInfo->simpleDesc.AppProfId = SAPP_PROFID;
epInfo->simpleDesc.AppDeviceId = SAPP_DEVICEID;
epInfo->simpleDesc.AppDevVer = SAPP_DEVICE_VERSION;
epInfo->simpleDesc.Reserved = 0;
epInfo->simpleDesc.AppNumInClusters = 1;
epInfo->simpleDesc.pAppInClusterList = &commonClusterId;
epInfo->simpleDesc.AppNumOutClusters = 1;
epInfo->simpleDesc.pAppOutClusterList = &commonClusterId;
epInfo->SampleApp_epDesc.endPoint = ep;
epInfo->SampleApp_epDesc.task_id = task_id;
epInfo->SampleApp_epDesc.simpleDesc = &epInfo->simpleDesc;
epInfo->SampleApp_epDesc.latencyReq = noLatencyReqs;
// Register the endpoint description with the AF
afRegister(&epInfo->SampleApp_epDesc);
}
uint16 sapp_controlEpProcess(uint8 task_id, uint16 events)
{
afIncomingMSGPacket_t *MSGpkt;
if ( events & SYS_EVENT_MSG )
{
MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive(task_id);
while ( MSGpkt )
{
switch ( MSGpkt->hdr.event )
{
#if defined(ZDO_COORDINATOR)
case CMD_SERIAL_MSG:
// SampleApp_UartMessage((uint8 *)MSGpkt);
uartMsgProcesser((uint8 *)MSGpkt);
HalLedBlink( HAL_LED_1, 2, 50, 90 );
break;
#endif
// Received when a messages is received (OTA) for this endpoint
case AF_INCOMING_MSG_CMD:
{
// TODO: QueryProfile or QueryTopo
switch(MSGpkt->clusterId)
{
case SAPP_PERIODIC_CLUSTERID:
switch(MSGpkt->cmd.Data[0])
{
case 0x01:
// CtrlQueryProfile
// 获取到数据包的来源地址来当做发送数据的目标
SendData(CONTROL_ENDPOINT, funcTableBuffer->ft_data, MSGpkt->srcAddr.addr.shortAddr, MSGpkt->srcAddr.endPoint, sizeof(FUNCTABLE) + funcCount * sizeof(FUNCINFO));
break;
case 0x02:
// CtrlQueryTopo
// 获取到数据包的来源地址来当做发送数据的目标
SendData(CONTROL_ENDPOINT, (unsigned char *)&topoBuffer, MSGpkt->srcAddr.addr.shortAddr, MSGpkt->srcAddr.endPoint, sizeof(TOPOINFO));
break;
case 0x03:
// CtrlQuerySpecialFunction
// cmd.Data[0] = 3, cmd.Data[1] = funcCode, cmd.Data[2] = funcID
{
uint8 i;
for(i = 0; i < funcTableBuffer->ft_count; i++)
{
if((funcTableBuffer->ft_list[i].type == MSGpkt->cmd.Data[1])
&& (funcTableBuffer->ft_list[i].id == MSGpkt->cmd.Data[2]))
{
// 0x03, EndPoint, rCycle
uint8 specialFunc[3] = { 0x03, i + 1, funcTableBuffer->ft_list[i].cycle };
SendData(CONTROL_ENDPOINT, specialFunc, MSGpkt->srcAddr.addr.shortAddr, MSGpkt->srcAddr.endPoint, sizeof(specialFunc));
break;
}
}
}
break;
default:
{
int i;
for(i = 0; i < funcCount; i++)
{
struct ep_info_t *ep = &funcList[i];
if(ep->res_available) (*ep->res_available)(ep, ResControlPkg, MSGpkt);
}
}
break;
}
HalLedBlink( HAL_LED_2, 1, 50, 250 );
break;
}
break;
}
// Received whenever the device changes state in the network
case ZDO_STATE_CHANGE:
{
devStates_t st = (devStates_t)(MSGpkt->hdr.status);
if ( (st == DEV_ZB_COORD)
|| (st == DEV_ROUTER)
|| (st == DEV_END_DEVICE) )
{
// topoBuffer->type = 0x02;
memcpy(topoBuffer.IEEE, NLME_GetExtAddr(), 8);
#if !defined(ZDO_COORDINATOR)
topoBuffer.PAddr = NLME_GetCoordShortAddr();
#else
topoBuffer.PAddr = 0xFFFF;
#endif
osal_memcpy(&topoBuffer.panid, &_NIB.nwkPanId, sizeof(uint16));
osal_memcpy(&topoBuffer.channel, &_NIB.nwkLogicalChannel, sizeof(uint8));
//向协调器发送拓扑信息
SendData(CONTROL_ENDPOINT, (unsigned char *)&topoBuffer, 0x0000, TRANSFER_ENDPOINT, sizeof(TOPOINFO));
HalLedBlink( HAL_LED_2, 4, 50, 250 );
}
}
break;
default:
break;
}
// Release the memory
osal_msg_deallocate( (uint8 *)MSGpkt );
// Next - if one is available
MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( task_id );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
// 定时器时间到, 遍历所有端点看是否有userTimer
if(events & SAPP_SEND_PERIODIC_MSG_EVT)
{
int i;
uint8 hasUserTimer = 0;
for(i = 0; i < funcCount; i++)
{
struct ep_info_t *ep = &funcList[i];
if(ep->userTimer && ep->res_available)
{
hasUserTimer = 1;
ep->userTimer = ep->userTimer - 1;
if(ep->userTimer <= 1)
{
ep->userTimer = 0;
(*ep->res_available)(ep, ResUserTimer, NULL);
}
}
}
if(hasUserTimer)
{
// 重新启动定时器
osal_start_timerEx(task_id, SAPP_SEND_PERIODIC_MSG_EVT, 1000);
}
else
{
isUserTimerRunning = 0;
osal_stop_timerEx(task_id, SAPP_SEND_PERIODIC_MSG_EVT);
}
// return unprocessed events
return (events ^ SAPP_SEND_PERIODIC_MSG_EVT);
}
// Discard unknown events
return 0;
}
uint16 sapp_functionEpProcess(uint8 task_id, uint16 events)
{
afIncomingMSGPacket_t *MSGpkt;
if(events & SYS_EVENT_MSG)
{
MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( task_id );
while ( MSGpkt )
{
switch ( MSGpkt->hdr.event )
{
// 接收到数据包
case AF_INCOMING_MSG_CMD:
{
switch ( MSGpkt->clusterId )
{
case SAPP_PERIODIC_CLUSTERID:
if(MSGpkt->endPoint <= funcCount)
{
struct ep_info_t *ep = &funcList[MSGpkt->endPoint - 1];
if(ep->incoming_data)
(*ep->incoming_data)(ep, MSGpkt->srcAddr.addr.shortAddr, MSGpkt->srcAddr.endPoint, &MSGpkt->cmd);
}
HalLedBlink( HAL_LED_2, 1, 50, 250 );
break;
}
}
break;
case ZDO_STATE_CHANGE:
{
curNwkState = (devStates_t)(MSGpkt->hdr.status);
if ( (curNwkState == DEV_ZB_COORD)
|| (curNwkState == DEV_ROUTER)
|| (curNwkState == DEV_END_DEVICE) )
{
int i;
int hasTimeOut = 0;
for(i = 0; i < funcCount; i++)
{
struct ep_info_t *ep = &funcList[i];
if(ep->nwk_stat_change)
(*ep->nwk_stat_change)(ep);
// 重置端点计数器
if(ep->time_out && ep->function.cycle)
{
ep->timerTick = ep->function.cycle;
hasTimeOut = 1;
}
}
if(hasTimeOut)
{
// 加入网络成功,启动定时器,为各个端点提供定时
osal_start_timerEx(task_id,
SAPP_SEND_PERIODIC_MSG_EVT,
1000);
}
}
else
osal_stop_timerEx(task_id, SAPP_SEND_PERIODIC_MSG_EVT);
}
break;
case IOPORT_INT_EVENT:
{
OSALIOIntData_t* IOIntData;
IOIntData =(OSALIOIntData_t*)MSGpkt;
if(IOIntData->endPoint <= funcCount)
{
struct ep_info_t *ep = &funcList[IOIntData->endPoint - 1];
if(ep->res_available)
(*ep->res_available)(ep, ResIOInt, IOIntData->arg);
}
}
break;
#if defined(HAL_IRDEC) && (HAL_IRDEC == TRUE)
case IRDEC_INT_EVENT: //
{
OSALIRDecIntData_t* TimerIntData = (OSALIRDecIntData_t*)MSGpkt;
if(TimerIntData->endPoint <= funcCount)
{
struct ep_info_t *ep = &funcList[TimerIntData->endPoint - 1];
if(ep->res_available)
(*ep->res_available)(ep, ResTimerInt, TimerIntData->data);
}
}
break;
#endif
default:
break;
}
// Release the memory
osal_msg_deallocate( (uint8 *)MSGpkt );
// Next - if one is available
MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( task_id );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
// 定时器时间到, 遍历所有端点看是否有需要调用time_out
if(events & SAPP_SEND_PERIODIC_MSG_EVT)
{
int i;
for(i = 0; i < funcCount; i++)
{
struct ep_info_t *ep = &funcList[i];
if(ep->time_out && ep->function.cycle)
{
// 端点需要周期执行
ep->timerTick = ep->timerTick - 1;
if(ep->timerTick == 0)
{
// 定时时间到,执行time_out函数
(*ep->time_out)(ep);
ep->timerTick = ep->function.cycle;
}
}
#if 0
if(ep->userTimer && ep->res_available)
{
ep->userTimer = ep->userTimer - 1;
if(ep->userTimer <= 1)
{
(*ep->res_available)(ep, ResUserTimer, NULL);
ep->userTimer = 0;
}
}
#endif
}
// 重新启动定时器
osal_start_timerEx(task_id, SAPP_SEND_PERIODIC_MSG_EVT, 1000);
// return unprocessed events
return (events ^ SAPP_SEND_PERIODIC_MSG_EVT);
}
// Discard unknown events
return 0;
}
#if defined(ZDO_COORDINATOR)
static uint8 uartMsgProcesser(uint8 *msg)
{
mtOSALSerialData_t *pMsg = (mtOSALSerialData_t *)msg;
mtUserSerialMsg_t *pMsgBody = (mtUserSerialMsg_t *)pMsg->msg;
if ( (curNwkState != DEV_ZB_COORD)
&& (curNwkState != DEV_ROUTER)
&& (curNwkState != DEV_END_DEVICE) )
return 1;
switch(pMsgBody->cmd)
{
case 0x0018:
{
switch(pMsgBody->cmdEndPoint)
{
case 0xF1:
{
// 转发数据
SendData(TRANSFER_ENDPOINT, pMsgBody->data,
pMsgBody->addr, pMsgBody->endPoint,
pMsgBody->len - 6);
}
break;
}
}
break;
}
return 1;
}
#endif
uint8 SendData(uint8 srcEP, const void *buf, uint16 addr, uint8 dstEP, uint8 Len)
{
static uint8 transID = 0;
afAddrType_t SendDataAddr;
struct ep_info_t *epInfo;
if(srcEP <= funcCount)
epInfo = &funcList[srcEP - 1];
else
epInfo = &controlEndPointInfo;
SendDataAddr.addrMode = (afAddrMode_t)Addr16Bit; //短地址发送
SendDataAddr.endPoint = dstEP;
SendDataAddr.addr.shortAddr = addr;
if ( AF_DataRequest( &SendDataAddr, //发送的地址和模式
// TODO:
&epInfo->SampleApp_epDesc, //终端（比如操作系统中任务ID等）
SAPP_PERIODIC_CLUSTERID,//发送串ID
Len,
(uint8*)buf,
&transID, //信息ID（操作系统参数）
AF_DISCV_ROUTE,
AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )
{
HalLedBlink( HAL_LED_1, 1, 50, 250 );
return 1;
}
else
{
return 0;
}
}
void CreateUserTimer(struct ep_info_t *ep, uint8 seconds)
{
if(ep == NULL)
return;
if(ep->res_available == NULL)
return;
ep->userTimer = seconds;
if(isUserTimerRunning == 0)
{
osal_start_timerEx(controlTaskId,
SAPP_SEND_PERIODIC_MSG_EVT,
1000);
isUserTimerRunning = 1;
}
}
void DeleteUserTimer(struct ep_info_t *ep)
{
if(ep == NULL)
return;
ep->userTimer = 0;
}
void ModifyRefreshCycle(struct ep_info_t *ep, uint8 seconds)
{
if(ep == NULL)
return;
if(ep->time_out == NULL)
return;
ep->function.cycle = seconds;
if(ep->timerTick > seconds)
ep->timerTick = seconds;
}
#if ! defined(ZDO_COORDINATOR) && defined(RTR_NWK)
void RouterTimeoutRoutine(struct ep_info_t *ep)
{
SendData(ep->ep, (unsigned char *)&topoBuffer, 0x0000, TRANSFER_ENDPOINT, sizeof(TOPOINFO)); //节点向协调器发送采集数据
}
#endif
#if defined(ZDO_COORDINATOR)
void CoordinatorIncomingRoutine(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg)
{
//msg->Data[], msg->DataLength, msg->TransSeqNumber
// 转发数据到串口
if(msg->DataLength > 0)
{
mtUserSerialMsg_t *pMsg = osal_mem_alloc(sizeof(mtUserSerialMsg_t) + msg->DataLength - 1);
pMsg->sop = MT_UART_SOF;
pMsg->len = msg->DataLength + 6;
pMsg->cmd = 0x0018;
pMsg->cmdEndPoint = 0xF1;
pMsg->addr = addr;
pMsg->endPoint = endPoint;
memcpy(pMsg->data, msg->Data, msg->DataLength);
pMsg->fsc = MT_UartCalcFCS(0, &pMsg->len, 1);
pMsg->fsc = MT_UartCalcFCS(pMsg->fsc, pMsg->dataBody, pMsg->len);
HalUARTWrite(HAL_UART_PORT_0, &pMsg->sop, sizeof(mtUserSerialMsg_t) - 2 + msg->DataLength);
HalUARTWrite(HAL_UART_PORT_0, &pMsg->fsc, 1);
osal_mem_free(pMsg);
}
}
#endif
#endif//SAPP_ZSTACK
SAPP_FrameWork.h
#ifndef _SAPP_FRAMEWORK_H_
#define _SAPP_FRAMEWORK_H_
#include <hal_board.h>
#include "ZComDef.h"
#include "hal_drivers.h"
#include "OSAL.h"
#include "ZGlobals.h"
#include "AF.h"
#include "aps_groups.h"
#include "nwk.h"
#include "APS.h"
#if defined ( ZIGBEE_FRAGMENTATION )
#include "aps_frag.h"
#endif
#include "MT.h"
#include "MT_UART.h"
#if defined( MT_TASK )
#include "MT_TASK.h"
#endif
#if defined ( ZIGBEE_FREQ_AGILITY ) || defined ( ZIGBEE_PANID_CONFLICT )
#include "ZDNwkMgr.h"
#endif
#include "ZDApp.h"
#include "ZComDef.h"
#include "OSAL_Tasks.h"
#include "aps_groups.h"
#include "OnBoard.h"
/* HAL */
#include "hal_led.h"
#include "hal_io.h"
#include "hal_irdec.h"
// These constants are only for example and should be changed to the
// device's needs
#define CONTROL_ENDPOINT 0xF0
#define TRANSFER_ENDPOINT 1
#define SAPP_PROFID 0x0F08
#define SAPP_DEVICEID 0x0001
#define SAPP_DEVICE_VERSION 0
#define SAPP_PERIODIC_CLUSTERID 1
// Application Events (OSAL) - These are bit weighted definitions.
#define SAPP_SEND_PERIODIC_MSG_EVT 0x0001
enum {
DevRouter = 240,
DevCoordinator
};
typedef struct topo_info_t {
uint8 type;
uint8 IEEE[8];
uint16 PAddr;
uint16 panid;
uint8 channel;
} TOPOINFO;
typedef struct func_info_t {
uint8 type;
uint8 id;
uint8 cycle;
} FUNCINFO;
typedef union {
uint8 ft_data[2];
struct {
uint8 ft_type;
uint8 ft_count;
FUNCINFO ft_list[0];
} ft_field;
} FUNCTABLE;
#define ft_type ft_field.ft_type
#define ft_count ft_field.ft_count
#define ft_list ft_field.ft_list
#define createFuncTable(count) (FUNCTABLE *)osal_mem_alloc(sizeof(FUNCTABLE) + count * sizeof(FUNCINFO))
#define destroyFuncTable(ft) osal_mem_free(ft)
typedef enum {
ResMinType = 0,
ResInit, // 表示模块初始化
ResSerial,
ResUserTimer,
ResControlPkg,
ResIOInt,
ResTimerInt,
ResMaxType,
} RES_TYPE;
struct ep_info_t {
// 网络状态发生变化时会调用该函数
void (*nwk_stat_change)(struct ep_info_t *ep);
// 接收到数据时会调用该函数
void (*incoming_data)(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg);
// 周期性调用的函数
void (*time_out)(struct ep_info_t *ep);
// 系统资源可用时调用该函数,系统资源指的是:串口接收到数据/中断等等
void (*res_available)(struct ep_info_t *ep, RES_TYPE type, void *res);
// NOTE: cycle成员会被用来计数,并周期性调用time_out函数
struct func_info_t function;
// 当前端点号
uint8 ep;
// 与此端点绑定的任务ID
uint8 task_id;
// 递减计数,为0时调用time_out函数,并重载初值=cycle
uint8 timerTick;
uint8 userTimer;
endPointDesc_t SampleApp_epDesc;
SimpleDescriptionFormat_t simpleDesc;
};
extern struct ep_info_t funcList[];
extern const uint8 funcCount;
extern void sapp_taskInitProcess(void);
extern uint16 sapp_controlEpProcess(uint8 task_id, uint16 events);
extern UINT16 sapp_functionEpProcess( uint8 task_id, uint16 events );
extern uint8 SendData(uint8 srcEP, const void *buf, uint16 addr, uint8 dstEP, uint8 Len);
extern void CreateUserTimer(struct ep_info_t *ep, uint8 seconds);
extern void DeleteUserTimer(struct ep_info_t *ep);
extern void ModifyRefreshCycle(struct ep_info_t *ep, uint8 seconds);
#if defined(ZDO_COORDINATOR)
#define CoordinatorNwkStateChangeRoutine NULL
void CoordinatorIncomingRoutine(struct ep_info_t *ep, uint16 addr, uint8 endPoint, afMSGCommandFormat_t *msg);
#define CoordinatorTimeoutRoutine NULL
#define CoordinatorResAvailableRoutine NULL
#elif defined(RTR_NWK)
#define RouterNwkStateChangeRoutine NULL
#define RouterIncomingRoutine NULL
void RouterTimeoutRoutine(struct ep_info_t *ep);
#define RouterResAvailableRoutine NULL
#endif
#endif//_SAPP_FRAMEWORK_H_