peer2peer.c

Back to Peer-to-peer sample application.

/******************************************************************************
                    Includes section
******************************************************************************/
#include <types.h>
#include <configServer.h>
#include <appTimer.h>
#include <zdo.h>
#include <peer2peer.h>
#include <serialInterface.h>

/******************************************************************************
                    Define(s) section
******************************************************************************/

/******************************************************************************
                    Variables section
******************************************************************************/
// Network related variables
static uint16_t nwkAddr;                        // Own NWK address
static AppMessageBuffer_t appMessageBuffer;     // Application message buffer
static uint8_t messageIdTx = 0;                 // Application transmitted message ID
static uint8_t messageIdRx = 0;                 // Application received message ID
static bool messageIdRxValid = false;           // Application received message ID valid flag
static uint8_t actualDataLength = 0;            // Actual data length to be transmitted via network   

// Temporary data received via network buffer
static uint8_t tmpDataBuffer[APP_TMP_DATA_BUFFER_SIZE];
static uint8_t tmpDataBufferActualLength = 0;   

// UART related variables
static HAL_UartDescriptor_t appUartDescriptor;          // UART descriptor (required by stack)
static bool uartTxBusyFlag = false;                     // UART transmission transaction status
static uint8_t uartTxBuffer[APP_UART_TX_BUFFER_SIZE];   // UART Tx buffer
static uint8_t uartRxBuffer[APP_UART_RX_BUFFER_SIZE];   // UART Rx buffer
static uint8_t uartRxPending = 0;

static AppState_t appState = APP_INITIAL_STATE;  // application state
static AppDataTransmission_t appDataTransmissionState = APP_DATA_TRANSMISSION_IDLE_STATE; //application data transmission feature state
static ZDO_StartNetworkReq_t networkParams; // request params for ZDO_StartNetworkReq
static APS_DataReq_t apsDataReq;

// endpoint parameters
static SimpleDescriptor_t simpleDescriptor = { APP_ENDPOINT, APP_PROFILE_ID, 1, 1, 0, 0 , NULL, 0, NULL };
static APS_RegisterEndpointReq_t endpointParams;

// Timer indicating starting network during network joining.
// Also used as delay timer between APS_DataConf and APS_DataReq.
static HAL_AppTimer_t delayTimer;

/***********************************************************************************
                    Static functions declarations section
***********************************************************************************/
static void APS_DataIndication(APS_DataInd_t* dataInd);
static void APS_DataConf(APS_DataConf_t* confInfo);
static void ZDO_StartNetworkConf(ZDO_StartNetworkConf_t* confirmInfo);
static void initNetwork(void);
static void startNetwork(void);
static void networkSendData(bool newTransmission);
static void startBlinkTimer(void);
static void initSerialInterface(void);
static void sendDataToUart(uint8_t*, uint8_t);
static void startingNetworkTimerFired(void);
static void delayTimerFired(void);
static void uartBytesReceived(uint8_t readBytesLen);
static void uartWriteConf(void);
static void buttonReleased(uint8_t buttons);

/***********************************************************************************
                    Implementation section
***********************************************************************************/
/**************************************************************************/
void APL_TaskHandler(void)
{
  switch (appState)
  { 
    case APP_INITIAL_STATE:                 // Node has initial state
      initSerialInterface();                // Open UART
      appOpenButtons(NULL, buttonReleased); // Open buttons
      appOpenLeds();                        // Enable LEDs   
      initNetwork();
      SYS_PostTask(APL_TASK_ID);            // Execute next step
      break;

    case APP_NETWORK_JOINING_STATE:
      startBlinkTimer();
      startNetwork();
      break;

    case APP_NETWORK_JOINED_STATE:
    default:
      break;
  }
}

/**************************************************************************/
static void initNetwork(void)
{
  DeviceType_t  deviceType  = DEVICE_TYPE_ROUTER;
  ExtAddr_t     extAddr     = APP_COORD_UID;

#ifndef _SLIDERS_
  // NWK preconfigured address reading for Config Server
  CS_ReadParameter(CS_NWK_ADDR_ID, &nwkAddr);
#else  //#ifndef _SLIDERS_
  // NWK address reading from sliders 
  nwkAddr = BSP_ReadSliders();
  // Set the NWK address value to Config Server
  CS_WriteParameter(CS_NWK_ADDR_ID, &nwkAddr);
#endif //#ifndef _SLIDERS_

  //NWK address value check
  if (APP_MAX_NWK_ADDR < nwkAddr)
  {
    appState = APP_ERROR_STATE;
  }
  else
  {
    // Node role detection. If nwkAddr == 0 then node is coordinator. 
    // In othe case the node role is router.
    if (0 == nwkAddr)   
    {
      deviceType = DEVICE_TYPE_COORDINATOR;
      // Set the extended address value to Config Server for coordinator only
      CS_WriteParameter(CS_UID_ID, &extAddr);
    }
    // Set the deviceType value to Config Server
    CS_WriteParameter(CS_DEVICE_TYPE_ID, &deviceType);

    // Application state changing
    appState = APP_NETWORK_JOINING_STATE;
  }
}

/**************************************************************************/
void ZDO_StartNetworkConf(ZDO_StartNetworkConf_t* confirmInfo)
{
  if (confirmInfo->status == ZDO_SUCCESS_STATUS)
  {
    appState = APP_NETWORK_JOINED_STATE;
    actualDataLength = 0;
    messageIdRxValid = false;
    uartRxPending = 0;

    // Stop the blink timer
    HAL_StopAppTimer(&delayTimer);
    appOnLed(APP_NETWORK_STATUS_LED);

#if APP_DATA_TRANSMISSION_DELAY
    // Setup timer to be used as delay timer between APS_DataConf and APS_DataReq.
    delayTimer.interval = APP_DATA_TRANSMISSION_DELAY;
    delayTimer.mode     = TIMER_ONE_SHOT_MODE;
    delayTimer.callback = delayTimerFired;
#endif

    // Set application endpoint properties
    endpointParams.simpleDescriptor = &simpleDescriptor;
    endpointParams.APS_DataInd = APS_DataIndication;
    // Register endpoint
    APS_RegisterEndpointReq(&endpointParams);
  }
  else
  {
    SYS_PostTask(APL_TASK_ID);
  }
}

/**************************************************************************/
static void startNetwork(void)
{
  networkParams.ZDO_StartNetworkConf = ZDO_StartNetworkConf;
  // start network
  ZDO_StartNetworkReq(&networkParams);   
}

/**************************************************************************/
static void startBlinkTimer(void)
{
  delayTimer.interval = APP_JOINING_INDICATION_PERIOD;
  delayTimer.mode     = TIMER_REPEAT_MODE;
  delayTimer.callback = startingNetworkTimerFired;
  HAL_StartAppTimer(&delayTimer);
}

/**************************************************************************/
static void startingNetworkTimerFired(void)
{
  appToggleLed(APP_NETWORK_STATUS_LED);
}

/**************************************************************************/
void ZDO_MgmtNwkUpdateNotf(ZDO_MgmtNwkUpdateNotf_t *nwkParams)
{
  switch (nwkParams->status)
  {
    case ZDO_NETWORK_STARTED_STATUS:
      break;

    case ZDO_NETWORK_LOST_STATUS:
//    case ZDO_REJOIN_STARTED_STATUS:
      {
        APS_UnregisterEndpointReq_t unregEndpoint;  
        if (APP_NETWORK_JOINED_STATE == appState)
        {
          unregEndpoint.endpoint = endpointParams.simpleDescriptor->endpoint;
          APS_UnregisterEndpointReq(&unregEndpoint);    
        }
        appOffLed(APP_NETWORK_STATUS_LED);
  
        // try to rejoin the network
        appState = APP_NETWORK_JOINING_STATE;
        SYS_PostTask(APL_TASK_ID);
        break;  
      }        

    case ZDO_NWK_UPDATE_STATUS:
      break;

    default:
      break;
  }
}

/**************************************************************************/
void ZDO_WakeUpInd(void)
{
}

/**************************************************************************/
void ZDO_SleepInd(void)
{
}

/**************************************************************************/
static void networkSendData(bool newTransmission)
{
  if (APP_DATA_TRANSMISSION_IDLE_STATE == appDataTransmissionState)
  {
    appDataTransmissionState = APP_DATA_TRANSMISSION_BUSY_STATE;
    // indicate we're sending
    appOnLed(APP_SENDING_STATUS_LED);

    if (newTransmission)
    {
      // The new applicatiom message will be sent
      // messageId value 
      appMessageBuffer.message.messageId = messageIdTx++;
      // APS Data Request preparing
      apsDataReq.dstAddrMode = APS_SHORT_ADDRESS;               // Short addressing mode 
      // Destination address
      apsDataReq.dstAddress.shortAddress = (nwkAddr & 0xfffe) | ((~nwkAddr) & 0x01);
      apsDataReq.profileId = simpleDescriptor.AppProfileId;     // Profile ID
      apsDataReq.dstEndpoint = simpleDescriptor.endpoint;       // Desctination endpoint
      apsDataReq.clusterId = APP_CLUSTER_ID;                    // Desctination cluster ID
      apsDataReq.srcEndpoint = simpleDescriptor.endpoint;       // Source endpoint
      apsDataReq.asdu = (uint8_t*) &appMessageBuffer.message;   // application message pointer
      // actual application message length
      apsDataReq.asduLength = actualDataLength + sizeof(appMessageBuffer.message.messageId);
      apsDataReq.txOptions.acknowledgedTransmission = 1;        // Acknowledged transmission enabled
      apsDataReq.radius = 0;                                    // Default radius
      apsDataReq.APS_DataConf = APS_DataConf;                   // Confirm handler
    }

    // send data request
    APS_DataReq(&apsDataReq);
  }
}

/**************************************************************************/
void APS_DataConf(APS_DataConf_t* confInfo)
{
  appOffLed(APP_SENDING_STATUS_LED);

  if (APS_SUCCESS_STATUS == confInfo->status) // data delivered
  {
#if APP_DATA_TRANSMISSION_DELAY
    // Start delay timer. This timer is used to prevent collisions in duplex mode.
    HAL_StartAppTimer(&delayTimer);
#else
    // No delay needed.
    delayTimerFired();
#endif
  }
  else  // data not delivered, resend
  {
    appDataTransmissionState = APP_DATA_TRANSMISSION_IDLE_STATE;
    networkSendData(false); // Current application message retransmission
  }
}

/**************************************************************************/
static void delayTimerFired(void)
{
  appDataTransmissionState = APP_DATA_TRANSMISSION_IDLE_STATE;

  appOffLed(APP_SENDING_STATUS_LED);

  if (uartRxPending > 0)
    uartBytesReceived(uartRxPending);
}
                
/**************************************************************************/
void APS_DataIndication(APS_DataInd_t* indData)
{
  AppMessage_t *appMessage = (AppMessage_t *) indData->asdu;

  // Data received indication
  appOnLed(APP_RECEIVING_STATUS_LED);

  if ((false == messageIdRxValid) ||
      (messageIdRx != appMessage->messageId))
  {
    messageIdRxValid = true;
    messageIdRx = appMessage->messageId;
    // write received data to UART
    sendDataToUart(appMessage->data, indData->asduLength - 1);
  }
  appOffLed(APP_RECEIVING_STATUS_LED);
}

/**************************************************************************/
static void initSerialInterface(void)
{
  uartTxBusyFlag = false;
  
  appUartDescriptor.tty             = UART_CHANNEL;
  appUartDescriptor.mode            = ASYNC;
  appUartDescriptor.baudrate        = UART_BAUDRATE_38400;
  appUartDescriptor.dataLength      = UART_DATA8;
  appUartDescriptor.parity          = UART_PARITY_NONE;
  appUartDescriptor.stopbits        = UART_STOPBIT_1;
  appUartDescriptor.rxBuffer        = uartRxBuffer;
  appUartDescriptor.rxBufferLength  = sizeof(uartRxBuffer);
  appUartDescriptor.txBuffer        = NULL; // use callback mode
  appUartDescriptor.txBufferLength  = 0;
  appUartDescriptor.rxCallback      = uartBytesReceived;
  appUartDescriptor.txCallback      = uartWriteConf;
  appUartDescriptor.flowControl     = UART_FLOW_CONTROL_HARDWARE;
  OPEN_UART(&appUartDescriptor);
}

/**************************************************************************/
static void sendDataToUart(uint8_t* data, uint8_t length)
{
  if (APP_TMP_DATA_BUFFER_SIZE > tmpDataBufferActualLength + length)
  {
    memcpy(&tmpDataBuffer[tmpDataBufferActualLength], data, length);
    tmpDataBufferActualLength += length;
    // If there are no space in tmp Buffer for future messages receive
  }
   
  if (false == uartTxBusyFlag)
  {
    uartWriteConf();
  }
  
  // If there are no space in tmp Buffer for future messages receive
  if (APP_TMP_DATA_BUFFER_SIZE < tmpDataBufferActualLength + APP_MAX_DATA_SIZE) 
  {
    APS_StopEndpointIndication(APP_ENDPOINT); // Disable APS Data Indications
  }
}

/**************************************************************************/
static void uartWriteConf(void)
{
  int bytesWritten;

  if (0 < tmpDataBufferActualLength)  // data waiting to be written to UART
  {
    memcpy(uartTxBuffer, tmpDataBuffer, tmpDataBufferActualLength);
    bytesWritten = WRITE_UART(&appUartDescriptor, uartTxBuffer, tmpDataBufferActualLength);
    if (0 < bytesWritten)
    {
      tmpDataBufferActualLength -= bytesWritten;
      uartTxBusyFlag = true;
    }
  }
  else
  {
    uartTxBusyFlag = false;
    APS_ResumeEndpointIndication(APP_ENDPOINT); // Enable APS Data Indications
  }
}

/**************************************************************************/
static void uartBytesReceived(uint8_t bytesToRead)
{
  if (APP_NETWORK_JOINED_STATE == appState)
  {
    uartRxPending = bytesToRead;

    if (APP_DATA_TRANSMISSION_IDLE_STATE == appDataTransmissionState)
    {
      if (APP_MAX_DATA_SIZE < bytesToRead)
        bytesToRead = APP_MAX_DATA_SIZE;

      // Read data from UART 
      actualDataLength = (uint8_t) READ_UART(&appUartDescriptor, appMessageBuffer.message.data, bytesToRead);

      networkSendData(true);

      uartRxPending -= bytesToRead;
    }
  }
}

/**************************************************************************/
static void buttonReleased(uint8_t aButton)
{
  switch (aButton)
  {
    case BSP_KEY0:  // SW1 pressed
      if ((APP_NETWORK_JOINED_STATE == appState) &&
          (APP_DATA_TRANSMISSION_IDLE_STATE == appDataTransmissionState))
      {
        // Fill the buffer with some data and send it
        memset(&appMessageBuffer.message.data, 0xdd, APP_MAX_DATA_SIZE); 
        actualDataLength = APP_MAX_DATA_SIZE;
        networkSendData(true);
        break;
      }
      
    default:
      break;
  }
}

// eof peer2Peer.c

---