Zstack with external antena X2401c

/******************************************************************************
  Filename:       Project.c
  Revised:        $Date: 23/04/2015
  Revision:       

  Description:    Project redefine and designed by tuanna78


  Copyright 2004-2014 Texas Instruments Incorporated. All rights reserved.

  IMPORTANT: Your use of this Software is limited to those specific rights
  granted under the terms of a software license agreement between the user
  who downloaded the software, his/her employer (which must be your employer)
  and Texas Instruments Incorporated (the "License"). You may not use this
  Software unless you agree to abide by the terms of the License. The License
  limits your use, and you acknowledge, that the Software may not be modified,
  copied or distributed unless embedded on a Texas Instruments microcontroller
  or used solely and exclusively in conjunction with a Texas Instruments radio
  frequency transceiver, which is integrated into your product. Other than for
  the foregoing purpose, you may not use, reproduce, copy, prepare derivative
  works of, modify, distribute, perform, display or sell this Software and/or
  its documentation for any purpose.

  YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE
  PROVIDED �AS IS� WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
  INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE,
  NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL
  TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,
  NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER
  LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
  INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE
  OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT
  OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
  (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.

  Should you have any questions regarding your right to use this Software,
  contact Texas Instruments Incorporated at www.TI.com.
******************************************************************************/

/*********************************************************************
 * INCLUDES
 */
#include "ZComDef.h"
#include "OSAL.h"
#include "AF.h"
#include "ZDApp.h"
#include "ZDObject.h"
#include "ZDProfile.h"

#include "zcl.h"
#include "zcl_general.h"
#include "zcl_ha.h"
#include "zcl_ezmode.h"
#include "zcl_diagnostic.h"

#include "zcl_samplesw.h"

#include "onboard.h"

/* HAL */
#include "hal_lcd.h"
#include "hal_led.h"
#include "hal_key.h"
#include "hal_uart.h"

#if (defined HAL_BOARD_ZLIGHT) || (defined HAL_PWM)
#include "math.h"
#include "hal_timer.h"
#endif
#include "NLMEDE.h"
#include <stdio.h>
#include <string.h>
#include <ctype.h>



/*********************************************************************
 * TYPEDEFS
 */

/*********************************************************************
 * GLOBAL VARIABLES
 */
// This list should be filled with Application specific Cluster IDs.
const cId_t Project_ClusterList[PROJECT_MAX_CLUSTERS] =
{
  PROJECT_CLUSTERID
};

const SimpleDescriptionFormat_t Project_SimpleDesc =
{
  PROJECT_ENDPOINT,              //  int Endpoint;
  PROJECT_PROFID,                //  uint16 AppProfId[2];
  PROJECT_DEVICEID,              //  uint16 AppDeviceId[2];
  PROJECT_DEVICE_VERSION,        //  int   AppDevVer:4;
  PROJECT_FLAGS,                 //  int   AppFlags:4;
  PROJECT_MAX_CLUSTERS,          //  byte  AppNumInClusters;
  (cId_t *)Project_ClusterList,  //  byte *pAppInClusterList;
  PROJECT_MAX_CLUSTERS,          //  byte  AppNumInClusters;
  (cId_t *)Project_ClusterList   //  byte *pAppInClusterList;
};

// This is the Endpoint/Interface description.  It is defined here, but
// filled-in in Project_Init().  Another way to go would be to fill
// in the structure here and make it a "const" (in code space).  The
// way it's defined in this sample app it is define in RAM.
endPointDesc_t Project_epDesc;

/*********************************************************************
 * EXTERNAL VARIABLES
 */

/*********************************************************************
 * EXTERNAL FUNCTIONS
 */

/*********************************************************************
 * LOCAL VARIABLES
 */
byte Project_TaskID;   // Task ID for internal task/event processing
                          // This variable will be received when
                          // Project_Init() is called.

devStates_t Project_NwkState;

byte Project_TransID;  // This is the unique message ID (counter)

afAddrType_t Project_DstAddr;

// Number of recieved messages
static uint16 rxMsgCount;

// Time interval between sending messages

/*********************************************************************
 * LOCAL FUNCTIONS
 */
static void Project_ProcessZDOMsgs( zdoIncomingMsg_t *inMsg );
static void Project_HandleKeys( byte shift, byte keys );
static void Project_MessageMSGCB( afIncomingMSGPacket_t *pckt );
static void Project_SendTheMessage( void );
//define uart
#define DEBUGUA 1
#define RX_BUF_LEN 128
#ifdef HAL_UART_DMA
static void UARTInit(void);
static void cbackUART(uint8 port, uint8 event);
//static void DetectCmdFromUart(uint8 *StrCmd, uint8 len);
static void HalUARTWriteHex(int port, int variable);
#endif



/*********************************************************************
 * @fn          Write hex, debug addr
 *
 * @brief       Modify from HalUARTWrite
 *
 * @param       none
 *
 * @return      none
 */
static void HalUARTWriteHex(int port, int variable)
 {
    char str[8];
    for(int i = 0;i<sizeof(str);i++)
      str[i] = 0;
    sprintf(str,"%x\r\n",variable);
    HalUARTWrite(port,(uint8*)str,osal_strlen(str));
 }
/*********************************************************************
 * @fn          cb UA
 *
 * @brief       cb ua
 *
 * @param       none
 *
 * @return      none
 */
static void cbackUART(uint8 port, uint8 event)
{
  uint8 pBuf[RX_BUF_LEN];
  uint16 len;
  
  if(event == HAL_UART_RX_TIMEOUT)
    {
      //Read UART
      len = HalUARTRead(HAL_UART_PORT_0,pBuf,RX_BUF_LEN);
      //DetectCmdFromUart(pBuf,len);
      //Trans
    }
}
/*********************************************************************
 * @fn          UARTInit
 *
 * @brief       Initialization function for the UART, as init system complete
 *
 * @param       none
 *
 * @return      none
 */
 void UARTInit(void)
{
  halUARTCfg_t uartConfig;
  
  //Define config
  uartConfig.configured           = true;
  uartConfig.baudRate             = HAL_UART_BR_115200; //Baudrate
  uartConfig.flowControl          = FALSE;//delete flowcontrol
  uartConfig.flowControlThreshold = 64;
  uartConfig.rx.maxBufSize        = 128;
  uartConfig.tx.maxBufSize        = 128;
  uartConfig.idleTimeout          = 6;//Time out 6ms/ 1 char
  uartConfig.callBackFunc         = cbackUART; //time cback
  uartConfig.intEnable            = FALSE;//Delete interrupt
  
  HalUARTInit();
  HalUARTOpen(HAL_UART_PORT_0, &uartConfig);//Open Port 0 
#if DEBUGUA
  HalUARTWrite(HAL_UART_PORT_0,"Designed firmware: tuanna78\r\n",28);
  HalUARTWrite(HAL_UART_PORT_0,"Vertion Zstack   : Z-Stack Home 1.2.1\r\n",39);
  HalUARTWrite(HAL_UART_PORT_0,"Begin            : 1/4/2015\r\n",29);
  HalUARTWrite(HAL_UART_PORT_0,"Complete         :         \r\n",29);
#endif
}

/*********************************************************************
 * @fn      Project_Init
 *
 * @brief   Initialization function for the Generic App Task.
 *          This is called during initialization and should contain
 *          any application specific initialization (ie. hardware
 *          initialization/setup, table initialization, power up
 *          notificaiton ... ).
 *
 * @param   task_id - the ID assigned by OSAL.  This ID should be
 *                    used to send messages and set timers.
 *
 * @return  none
 */
void Project_Init( uint8 task_id )
{
  Project_TaskID = task_id;
  Project_NwkState = DEV_INIT;
  Project_TransID = 0;

  // Device hardware initialization can be added here or in main() (Zmain.c).
  // If the hardware is application specific - add it here.
  // If the hardware is other parts of the device add it in main().

  Project_DstAddr.addrMode = (afAddrMode_t)AddrNotPresent;
  Project_DstAddr.endPoint = 0;
  Project_DstAddr.addr.shortAddr = 0;

  // Fill out the endpoint description.
  Project_epDesc.endPoint = PROJECT_ENDPOINT;
  Project_epDesc.task_id = &Project_TaskID;
  Project_epDesc.simpleDesc
            = (SimpleDescriptionFormat_t *)&Project_SimpleDesc;
  Project_epDesc.latencyReq = noLatencyReqs;

  // Register the endpoint description with the AF
  afRegister( &Project_epDesc );

  // Register for all key events - This app will handle all key events
  RegisterForKeys( Project_TaskID );

  // This app is part of the Home Automation Profile
  //zclHA_Init( &Project_SimpleDesc );

  // Register the ZCL General Cluster Library callback functions
 // zclGeneral_RegisterCmdCallbacks( PROJECT_ENDPOINT, &Project_CmdCallbacks );
  
  //Register callback function
  ZDO_RegisterForZDOMsg( Project_TaskID, End_Device_Bind_rsp );
  ZDO_RegisterForZDOMsg( Project_TaskID, Match_Desc_rsp );
  ZDO_RegisterForZDOMsg( Project_TaskID, IEEE_addr_rsp);
  ZDO_RegisterForZDOMsg( Project_TaskID, NWK_addr_rsp);
  ZDO_RegisterForZDOMsg( Project_TaskID, Device_annce);
  
#ifdef HAL_UART_DMA
  UARTInit();
#endif
}

/*********************************************************************
 * @fn      Project_ProcessEvent
 *
 * @brief   Generic Application Task event processor.  This function
 *          is called to process all events for the task.  Events
 *          include timers, messages and any other user defined events.
 *
 * @param   task_id  - The OSAL assigned task ID.
 * @param   events - events to process.  This is a bit map and can
 *                   contain more than one event.
 *
 * @return  none
 */
uint16 Project_ProcessEvent( uint8 task_id, uint16 events )
{
  afIncomingMSGPacket_t *MSGpkt;

  (void)task_id;  // Intentionally unreferenced parameter

  if ( events & SYS_EVENT_MSG )
  {
    MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( Project_TaskID );
    while ( MSGpkt )
    {
      switch ( MSGpkt->hdr.event )
      {
        case ZDO_CB_MSG:
          Project_ProcessZDOMsgs( (zdoIncomingMsg_t *)MSGpkt );
          break;

        case KEY_CHANGE:
          Project_HandleKeys( ((keyChange_t *)MSGpkt)->state, ((keyChange_t *)MSGpkt)->keys );
          break;

        case AF_INCOMING_MSG_CMD:
          Project_MessageMSGCB( MSGpkt );
          break;

        case ZDO_STATE_CHANGE:
          Project_NwkState = (devStates_t)(MSGpkt->hdr.status);
          if ( (Project_NwkState == DEV_ZB_COORD) ||
               (Project_NwkState == DEV_ROUTER) ||
               (Project_NwkState == DEV_END_DEVICE) )
          {
            // Start sending "the" message in a regular interval.

          }
          break;

        default:
          break;
      }

      // Release the memory
      osal_msg_deallocate( (uint8 *)MSGpkt );

      // Next
      MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( Project_TaskID );
    }

    // return unprocessed events
    return (events ^ SYS_EVENT_MSG);
  }
  return 0;
}

/*********************************************************************
 * Event Generation Functions
 */

/*********************************************************************
 * @fn      Project_ProcessZDOMsgs()
 *
 * @brief   Process response messages
 *
 * @param   none
 *
 * @return  none
 */
static void Project_ProcessZDOMsgs( zdoIncomingMsg_t *inMsg )
{
  switch ( inMsg->clusterID )
  {
  case IEEE_addr_rsp:
    {
      ZDO_NwkIEEEAddrResp_t* pRspnew2;
      pRspnew2 = ZDO_ParseAddrRsp(inMsg);
      
    }
  case NWK_addr_rsp:
  {
    ZDO_NwkIEEEAddrResp_t* pRspnew;
    pRspnew = ZDO_ParseAddrRsp(inMsg);
    HalUARTWriteHex(0x00, pRspnew->nwkAddr);
    break;
  }
    case End_Device_Bind_rsp:
      if ( ZDO_ParseBindRsp( inMsg ) == ZSuccess )
      {
        // Light LED
        HalLedSet( HAL_LED_4, HAL_LED_MODE_ON );
      }
#if defined( BLINK_LEDS )
      else
      {
        // Flash LED to show failure
        HalLedSet ( HAL_LED_4, HAL_LED_MODE_FLASH );
      }
#endif
      break;

    case Match_Desc_rsp:
      {
        ZDO_ActiveEndpointRsp_t *pRsp = ZDO_ParseEPListRsp( inMsg );
        if ( pRsp )
        {
          if ( pRsp->status == ZSuccess && pRsp->cnt )
          {
            Project_DstAddr.addrMode = (afAddrMode_t)Addr16Bit;
            Project_DstAddr.addr.shortAddr = pRsp->nwkAddr;
            // Take the first endpoint, Can be changed to search through endpoints
            Project_DstAddr.endPoint = pRsp->epList[0];

            // Light LED
            HalLedSet( HAL_LED_4, HAL_LED_MODE_ON );
          }
          osal_mem_free( pRsp );
        }
      }
      break;
      //Da lay dia chi khi thiet bi join mang dau tien thanh cong
  case Device_annce:
    {
    ZDO_DeviceAnnce_t devAnnce;
    ZDO_ParseDeviceAnnce(inMsg, &devAnnce);
    HalUARTWriteHex(0x00, devAnnce.nwkAddr);
    break;
    }
  }
}

/*********************************************************************
 * @fn      Project_HandleKeys
 *
 * @brief   Handles all key events for this device.
 *
 * @param   shift - true if in shift/alt.
 * @param   keys - bit field for key events. Valid entries:
 *                 HAL_KEY_SW_4
 *                 HAL_KEY_SW_3
 *                 HAL_KEY_SW_2
 *                 HAL_KEY_SW_1
 *
 * @return  none
 */
static void Project_HandleKeys( uint8 shift, uint8 keys )
{
  zAddrType_t dstAddr;
    if ( keys & HAL_KEY_SW_1 )
    {
      
    }

    if ( keys & HAL_KEY_SW_2 )
    {
      
    }

    if ( keys & HAL_KEY_SW_3 )
    {
      
    }

    if ( keys & HAL_KEY_SW_4 )
    {
      HalLedSet ( HAL_LED_4, HAL_LED_MODE_OFF );
      // Initiate a Match Description Request (Service Discovery)
      dstAddr.addrMode = AddrBroadcast;
      dstAddr.addr.shortAddr = NWK_BROADCAST_SHORTADDR;
      ZDP_MatchDescReq( &dstAddr, NWK_BROADCAST_SHORTADDR,
                        PROJECT_PROFID,
                        PROJECT_MAX_CLUSTERS, (cId_t *)Project_ClusterList,
                        PROJECT_MAX_CLUSTERS, (cId_t *)Project_ClusterList,
                        FALSE );
    }
    if ( keys & HAL_KEY_SW_7 )
      {
        HalLedSet ( HAL_LED_4, HAL_LED_MODE_OFF );

      // Initiate an End Device Bind Request for the mandatory endpoint
      dstAddr.addrMode = Addr16Bit;
      dstAddr.addr.shortAddr = 0x0000; // Coordinator
      ZDP_EndDeviceBindReq( &dstAddr, NLME_GetShortAddr(),
                            Project_epDesc.endPoint,
                            PROJECT_PROFID,
                            PROJECT_MAX_CLUSTERS, (cId_t *)Project_ClusterList,
                            PROJECT_MAX_CLUSTERS, (cId_t *)Project_ClusterList,
                            FALSE );
      }
    if ( keys & HAL_KEY_SW_8 )
      {
        // Initiate a Match Description Request (Service Discovery)
        Project_SendTheMessage();
        //Yeu cau cap phat dia chi nwk dua tren dia chi ieee
        uint8 b = 0;
        
        ZLongAddr_t Addr64bit[8] = {0x26,0xDE,0xEF,0x02,0x00,0x4B,0x12,0x00};
        strcpy((char*)&(Project_DstAddr.addr.extAddr),(char*)&Addr64bit);
        b = ZDP_NwkAddrReq(Project_DstAddr.addr.extAddr,ZDP_ADDR_REQTYPE_SINGLE,0,0);
        if ( b == ZSuccess)
          HalUARTWrite(0x00,"Da yeu cau thanh cong dia chi\r\n", 30);
        else 
          HalUARTWrite(0x00,"Fail\r\n",5);
        //Yeu cau cap phat dia chi nwk dua tren dia chi ieee
        ZLongAddr_t Addr64bit2[8] = {0x00,0x12,0x4B,0x00,0x02,0xEF,0xDE,0x26};
        strcpy((char*)&(Project_DstAddr.addr.extAddr),(char*)&Addr64bit2);
        b = ZDP_NwkAddrReq(Project_DstAddr.addr.extAddr,ZDP_ADDR_REQTYPE_SINGLE,0,0);
        
        if ( b == ZSuccess)
          HalUARTWrite(0x00,"Da yeu cau thanh cong dia chi\r\n", 30);
        else 
          HalUARTWrite(0x00,"Fail\r\n",5);
        strcpy((char*)&(Project_DstAddr.addr.extAddr),(char*)&aExtendedAddress);
        b = ZDP_NwkAddrReq(Project_DstAddr.addr.extAddr,ZDP_ADDR_REQTYPE_SINGLE,0,0);
        if ( b == ZSuccess)
          HalUARTWrite(0x00,"Da yeu cau thanh cong dia chi\r\n", 30);
        else 
          HalUARTWrite(0x00,"Fail\r\n",5);
        ZDP_IEEEAddrReq(Project_DstAddr.addr.shortAddr,ZDP_ADDR_REQTYPE_SINGLE,0,0);
        
      }
}

/*********************************************************************
 * LOCAL FUNCTIONS
 */
/*********************************************************************
 * @fn      Project_MessageMSGCB
 *
 * @brief   Data message processor callback.  This function processes
 *          any incoming data - probably from other devices.  So, based
 *          on cluster ID, perform the intended action.
 *
 * @param   none
 *
 * @return  none
 */
static void Project_MessageMSGCB( afIncomingMSGPacket_t *pkt )
{
  switch ( pkt->clusterId )
  {
    case PROJECT_CLUSTERID:
      rxMsgCount += 1;  // Count this message
#if DEBUG
      HalUARTWrite(0x00,"-->Da doc duoc noi dung ban tin truyen den: \r\n",45);
      HalUARTWrite(0x00,pkt->cmd.Data,pkt->cmd.DataLength - 1);
#endif
      HalLedSet ( HAL_LED_4, HAL_LED_MODE_BLINK );  // Blink an LED
      break;
  }
}

/*********************************************************************
 * @fn      Project_SendTheMessage
 *
 * @brief   Send "the" message.
 *
 * @param   none
 *
 * @return  none
 */
static void Project_SendTheMessage( void )
{
  char theMessageData[] = "Hello World";

  if ( AF_DataRequest( &Project_DstAddr, &Project_epDesc,
                       PROJECT_CLUSTERID,
                       (byte)osal_strlen( theMessageData ) + 1,
                       (byte *)&theMessageData,
                       &Project_TransID,
                       AF_DISCV_ROUTE, AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )
  {
    // Successfully requested to be sent.
  }
  else
  {
    // Error occurred in request to send.
  }
  
}


/*********************************************************************
 */