功能要求：

              协调器获取pc机通过串口发来的数据，并广播给终端，终端收到数据后打印到串口调试助手

             终端获取pc机通过串口发来的数据，并单播给协调器，协调器收到数据后打印到串口调试器上

// SampleApp.c

/* 添加头文件 */
#include "mt_uart.h"    // 串口
#include "string.h"    // 字符
#include "MT.h"    // 串口轮流事件

void SampleApp_Init(uint8 task_id)
{
    SampleApp_TaskID = task_id;
    SampleApp_NwkState = DEV_INIT;
    SampleApp_TransID = 0;
    
    MT_UartInit();
    MT_UartRegisterTaskID(task_id);    // 串口任务注册
    HalUARTWrite(0, "uart is ok \n", strlen("uart is ok \n"));    //打印

    // 协调器    
    SampleApp_Periodic_DstAddr.addrMode = (afAddrMode_t)AddrBroadcast;    //广播
    SampleApp_Periodic_DstAddr.endPoint = SAMPLEAPP_ENDPOINT;
    SampleApp_Periodic_DstAddr.addr.shortAddr = 0xFFFF;
    // 终端
    SampleApp_Flash_DstAddr.addrMode = (afAddrMode_t)Addr16Bit;  //单播
    SampleApp_Flash_DstAddr.endPoint = SAMPLEAPP_ENDPOINT;
    SampleApp_Flash_DstAddr.addr.shortAddr = 0x0000;    //协调器地址

    /* 组播不要
    SamppleApp_Group.ID = 0x0001;
    osal_memcpy(SampleApp_Group.name, "Group 1", 7);
    aps_AddGroup(SAMPLEAPP_ENDPOINT, &SampleApp_Group);
    */

}


// MT_UART.c
void MT_UartInit()
{
    halUARTCfg_t uartConfig;

    /* Initialize App ID 初始化 ID*/
    App_TaskID = 0;

    uartConfig.baudRate        = MT_UART_DEFAULT_BAUDRATE;    // 波特率
    uartConfig.flowControl     = MT_UAET_DEFAULT_OVERFLOW;    // 流控制

    #if defined(ZTOOL_P1) || defined (ZTOOL_P2)
        uartConfig.callBackFunc    = MT_UartProcessZToolData;    // 回调函数
    #elif defined(ZAPP_P1) || defined(ZAPP_P2)
        uartConfig.callBackFunc    = MT_UartProcessZAppData;
    #else
        uartConfig.callBackFunc    = NULL;
    #endif
}

void MT_UartProcessZToolData(uint8 port, uint8 event )    //触发事件
{
    uint8 ch, len = 0;
    uint8 uartData[128];    // 定义一个数组暂存数据
    uint8 i;
    
    (void)event;

    while(Hal_UART_RxBufLen(port))    //检查到串口缓存区有数据
    {
        HalUARTRead(port, &ch, 1);    // 把数据一个一个传递给 ch 变量
        uartData[len +1] = ch;        // 把 ch 的数据传输给数组
        len ++;
    }

    if(len)
    {
        uartData[0] = len;    // 第一个元素设为数据长度
        pMsg = (mtOSALSerialData_t *)osal_msg_allocate(sizeof(mtOSALSerialData_t)+
                                                       len + 1);//为串口数据包分配内存
        if(pMsg)
        {
            pMsg->hdr.event = CMD_SERIAL_MSG;    //设置串口数据到达事件
            pMsg->msg = (uint8 *)(pMsg + 1);    // 把数据定位到结构体数据部分
            for(i = 0;i <= len; i++)
            {
                pMsg->msg[i] = uartData[i];    // 把暂存数据放入串口数据包中
            }
            osal_msg_send(App_TaskID,(byte *)pMsg);    //将数据包发送消息队列
        }

        osal_msg_deallocate((uint8 *)pMsg);    //分配的内存用完后删除，以免内存泄漏
    }
}


// mt_uart.h
#if !defined MT_UART_DEFAULT_BAUDRATE
    #define    MT_UART_DEFAULT_BAUDRATE    HAL_UART_BR_115200    // 115200
#endif

#if !defined(MT_UART_DEFAULT_OVERFLOW)
    #define    MT_DEFAULT_VOERFLOW    FALSE    // 关闭
#endif


// AF.h
typedef enum
{
    afAddrNotPresent = AddrNotPresent,
    afAddr16Bit = Addr16Bit,
    afAddr64Bit = Addr64Bit,
    afAddrGroup = AddrGroup,
    afAddrBroadcast = AddrBroadcast
}afAddrMode_t;

// SampleApp.c

//声明
void SerialData_Analysis(uint8 *msg);

//事件轮循
uint16 SampleApp_ProcessEvent(uint8 task_id, uint16 events)
{
    afIncomingMSGPacket_t *MSGpkyt;
    (void)task_id;

    if( events & SYS_EVENT_MSG)
    {
        MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive(SampleApp_TaskID);
        while(MSGpkt)
        {
            switch( MSGpkt -> har.event)
            {
                case KEY_CHANGE:
                    break;
                case AF_INCOMING_MSG_CMD:        // 无线信息
                    SampleApp_MessageMSGCB();
                    break;
                case ZDO_STATE_CHANGE:
                    SampleApp_NwkState = (devStates_t)(MSGpky->hdr.status);
                    if()
                    {
                        /* 不需要周期性发送数据 
                        osal_start_timerEx( SampleApp_TaskID,
                                            SAMPLEAPP_SEND_PERIODIC_MSG_EVT,
                                            SAMPLEAPP_SEND_PERIODIC_MSG_TIMEOUT);
                        */
                    }
                    else
                    {}
                    break;
                case CMD_SERIAL_MSG:        // 串口数据的到达
                    SerialData_Analysis(((mtOSALSerialData_t *)MSGpkt) -> msg );
                    break;

                default:
                    break;
            }
        }
    }
}

void SerialData_Analysis(uint8 *msg)
{
    if(zgDeviceLogicalType == ZG_DEVICETYPE_COORDINATOR)    //协调器
    {
        AF_DataRequest(&SampleApp_Periodic_DstAddr,    // 广播地址
                        &SampleApp_eqDesc,
                        SAMPLEAPP_PERIODIC_CLUSTERID,    //命令号
                        *msg,                          // 长度
                        msg+1
                        &SampleApp_TransID,
                        AF_DISCV_ROUTE,
                        AF_DEFAULT_RADIUS);
    }
    else if(zgDeviceLogicalType == ZG_DEVICETYPE_ENDDEVICE)
    {
         AF_DataRequest(&SampleApp_Flash_DstAddr,    // 单播地址
                        &SampleApp_eqDesc,
                        SAMPLEAPP_FLASH_CLUSTERID,    //命令号
                        *msg,                          // 长度
                        msg+1
                        &SampleApp_TransID,
                        AF_DISCV_ROUTE,
                        AF_DEFAULT_RADIUS);
    }
}

void SampleApp_MessageMSGCB()
{
    uint16 flashTime;
    
    switch(pkt -> clusterId)
    {
        case SAMPLEAPP_PERIODIC_CLUSTERID:    //终端
            HalUARTWrite(0, pkt -> cmd.Data, pkt -> cmd.DataLength);
            break;
        case SAMPLEAPP_FLASH_CLUSTERID:        // 协调器
            HalUARTWrite(0, pkt -> cmd.Data, pkt -> cmd.DataLength);
            break;
    }
}

//sapi.h
#define    ZG_DEVICETYPE_COORDINATOR    0x00     
#define    ZG_DEVICETYPE_ENDDEVICE    0x02    // 终端 

// MT.H

#define    CMD_SERIAL_MSG    0x01

//mt_uart.h

typedef struct
{
    osal_event_har_t hdr;
    uint8 *msg;    // 第一元素为数据的长度，后位数据
}mtOSALSerialData_t;