nwk.c

Go to the documentation of this file.

/*
 * nwk.c
 *
 *  Date: 19/06/2014
 *  Author: Fernando Biazi Nascimento
 *  Copyright © 2014 Fernando Biazi Nascimento. All rights reserved.
 *
 *  License of use and copy on file license.txt
 *
 */

/*
 * From "CC2480 Target Board Schematics_1_4.pdf":
 *
 * Reference connections:
 * MSP430 in master mode
 *
 * (MSP430 pin number; pin name; config) <-> BUS name <-> (CC2480 pin number; pin name)
 *
 * (MSP430 26 P3.7: GPIO  )  -> RESET_N -> (CC2480 10 RESETn)
 *
 * (MSP430 15 P4.0: GPIO  )  -> CFG0    -> (CC2480 11 CFG0) - 1=32KHz crystal installed; 0=not
 * (MSP430 16 P4.1: GPIO  )  -> CFG1    -> (CC2480 12 CFG1) - 1=SPI; 0=UART
 *
 * (MSP430 03 P2.6: GPIO  ) <-  SRDY   <-  (CC2480 05 SRDY)
 * (MSP430 25 P3.6: GPIO  )  -> MRDY    -> (CC2480 06 MRDY)
 *
 * (MSP430 09 P3.0: UCB0STE )  -> SS/CT   -> (CC2480 15 SS/CT) - disabled in 3-pin SPI
 * UCxSTE chooses between master active/inactive
 *
 * (MSP430 10 P3.1: UCB0SIMO)  -> SI      -> (CC2480 14 SI/TX)
 * (MSP430 11 P3.2: UCB0SOMI) <-  SO     <-  (CC2480 13 SO/RX)
 * (MSP430 12 P3.3: UCB0CLK )  -> C/RT    -> (CC2480 16 C/RT)
 *
 * (MSP430 17 P4.2: GPIO  )  -> P_4.2   -> (CC2480 45 NC)
 * (MSP430 18 P4.3: GPIO  )  -> P_4.3   -> (CC2480 46 NC)
 *
 *
 * From "swra175a.pdf":
 *
 * Frame format:
 *             ---------+------------------
 *       Bytes |   1    |    2    | 0-253 |
 *             +--------+---------+-------+
 * Information | Length | Command |  Data |
 *             ---------+------------------
 *
 *             -------------------+-------
 *        Byte |       Cmd0       | Cmd1 |
 *             -------+-----------+------+
 *        Bits | 7-5  |    4-0    | 7-0  |
 *             +------+-----------+------+
 * Information | Type | Subsystem |  ID  |
 *             -------+-------------------
 *
 * Type
 *  0: 0x00 POLL. Used to retrieve data, length, subsystem and id are set to 0;
 *  1: 0x20 SREQ. Synchronous request;
 *  2: 0x40 AREQ. Asynchronous request;
 *  3: 0x60 SRSP. Synchronous response;
 *  4-7: Reserved.
 *
 * Subsystem
 *  0: Reserved
 *  1: SYS interface
 *  2: Reserved
 *  3: Reserved
 *  4: AF interface
 *  5: ZDO interface
 *  6: Simple API interface
 *  7-32: Reserved
 *
 * ID
 *  Command ID, maps to a particular interface message. 0-255
 *
 */

/*
 * ======== Standard MSP430 includes ========
 */
#include <msp430.h>

/*
 * ======== Includes ========
 */
#include "nwk.h"
#include "cc2480ai.h"
#include "led.h"
#if DEBUG!=1
#include "uart.h"
#endif

/*
 * ======== Constants ========
 */

/*
 * ======== Macros ========
 */

#define NWK_NEIGHBORHEARTBEATTIMEOUT 9

#define NWK_START_TIMEOUT 10

#define NWK_FLAGIDX_SINK 0x01
#define NWK_FLAGIDX_NSINK 0xFE
#define NWK_FLAGIDX_BOUND 0x02
#define NWK_FLAGIDX_NBOUND 0xFD
#define NWK_FLAGIDX_SENDFAIL 0x04
#define NWK_FLAGIDX_NSENDFAIL 0xFB
#define NWK_FLAGIDX_FAILJOIN 0x08
#define NWK_FLAGIDX_NFAILJOIN 0xF7

/*
 * ======== Types ========
 */

// network state
typedef enum nwk_state {
  NWK_S_INIT,
  NWK_S_SUSPENDED,
  NWK_S_CONFIGSTART,
  NWK_S_CONFIGSTARTWAIT,
  NWK_S_SETDEVICETYPE,
  NWK_S_RESETWAIT,
  NWK_S_CONFIGURE,
  NWK_S_REGISTER,
  NWK_S_START,
  NWK_S_STARTWAIT,
  NWK_S_POSTSTARTCONFIGURE,
  NWK_S_GETINFO,
  NWK_S_CHECKFORBIND,
  NWK_S_RUNNING
} nwk_state;

/*
 * ======== Global Variables ========
 */

nwk_neighbor nwk_neighbors[NWK_NEIGHBORMAX];

/*
 * ======== Local Variables ========
 */

nwk_state nwk_currentState;

nwk_state nwk_returnState;

UInt8 nwk_lastParam;

UInt8 nwk_lastParamSuccess;

nwk_devType nwk_currentDevType;

UInt16 nwk_address;

uint64_t nwk_ieeeAddress;

UInt8 nwk_dataHandle;

UInt8 nwk_freezeDetect;

UInt8 nwk_runCounter;

// 0 - allow bind
// 1 - bound to another device
UInt8 nwk_flags;

/*
 * ======== Local Functions ========
 */

UInt8 nwk_sendHeartBeat();

/*
 * ================
 */

void nwk_init() {
  UInt8 portIndex;

  nwk_currentDevType = NWK_DEVTYPE_DEFALUT;
  nwk_currentState = NWK_S_INIT;
  nwk_returnState = NWK_S_INIT;
  nwk_lastParam = 0;
  nwk_lastParamSuccess = 0;
  nwk_currentDevType = NWK_DEVTYPE_NONE;
  nwk_address = 0xFFFF;
  nwk_ieeeAddress = 0;
  nwk_dataHandle = 0;
  nwk_freezeDetect = 255;
  nwk_runCounter = 0;
  nwk_flags = 0;

  portIndex = NWK_NEIGHBORMAX;
  while (portIndex) {
    portIndex--;
    nwk_neighbors[portIndex].foreignAddress = 0xFFFF;
    nwk_neighbors[portIndex].foreignPort = 0;
    nwk_neighbors[portIndex].timeOut = 0;
  };
}

UInt16 nwk_process() {
  UInt8 portIndex;

  switch (nwk_currentState) {
  case NWK_S_INIT:
    // Reset bind state
    nwk_flags &= NWK_FLAGIDX_NBOUND & NWK_FLAGIDX_NSINK;
    return 1000;
  case NWK_S_SUSPENDED:
    break;
  case NWK_S_CONFIGSTART:
    if (nwk_configureWrite()) {
      // configure finished, nwk_configureWriteRsp will set next state on success.
      return 10;
    }
    // Configuration not finished, execute again in 10ms
    return 10;
  case NWK_S_CONFIGSTARTWAIT:
    // nwk_resetResume sets next state
    return 50;
  case NWK_S_SETDEVICETYPE:
    // Reset bind state
    nwk_flags &= NWK_FLAGIDX_NBOUND;
    if (nwk_configureWrite()) {
      // configure finished, nwk_configureWriteRsp will set next state on success.
      return 50;
    }
    // Configuration not finished, execute again in 10ms
    return 10;
  case NWK_S_RESETWAIT:
    // nwk_resetResume sets next state
    return 50;
  case NWK_S_CONFIGURE:
    if (nwk_configureWrite()) {
      // configure finished, nwk_configureWriteRsp will set next state on success.
      return 10;
    }
    // Configuration not finished, execute again in 10ms
    return 10;
  case NWK_S_REGISTER:
    // Registering application
    if (nwk_register()) {
      // nwk_registerRsp sets next state.
      // if nwk_registerRsp is not called in 10ms, nwk_register will be called again.
      return 10;
    }
    // Failed to send command, try again in 10ms
    return 10;
  case NWK_S_START:
    // Reset bind state
    nwk_flags &= NWK_FLAGIDX_NBOUND;
    if (nwk_start()) {
      // Set led indicator to starting network
      led_redConfigure(1, 300);
      // nwk_startRsp sets next state
      nwk_freezeDetect = NWK_START_TIMEOUT; // give ~5s to network start, see NWK_S_STARTWAIT block.
      return 500;
    }
    // Failed to send command, try again in 10ms
    return 10;
  case NWK_S_STARTWAIT:
    nwk_freezeDetect--;
    if (!nwk_freezeDetect) {
      nwk_freezeDetect = NWK_START_TIMEOUT;
      nwk_flags ^= NWK_FLAGIDX_FAILJOIN;
      if (nwk_flags & NWK_FLAGIDX_FAILJOIN) {
        // try again, next time, if not EndDevice, try as router
        nwk_setDeviceType(nwk_currentDevType);
      } else {
        if (nwk_currentDevType != NWK_DEVTYPE_ENDDEVICE) {
          nwk_setDeviceType(NWK_DEVTYPE_COORDINATOR);
        } else
          nwk_setDeviceType(nwk_currentDevType);
      }
    }
    return 500;
  case NWK_S_POSTSTARTCONFIGURE:
    if (nwk_configureWrite()) {
      // configure finished, nwk_configureWriteRsp will set next state on success.
      return 10;
    }
    // Configuration not finished, execute again in 10ms
    return 10;
  case NWK_S_GETINFO:
    if (nwk_getDeviceInfo()) {
      // nwk_getDeviceInfoRsp sets next state
      return 10;
    }
    // request next info in 5ms.
    return 5;
  case NWK_S_CHECKFORBIND:
    // Check if device was a sink before CC2480 reset
    if (nwk_flags & NWK_FLAGIDX_SINK)
      if (!nwk_allow_bind(0xFF))
        return 10;

    nwk_freezeDetect = 6 + ((((char *) &nwk_ieeeAddress)[0] & 0x0F) << 1);
    nwk_currentState = NWK_S_RUNNING;
    return 10;
  case NWK_S_RUNNING:

    if (nwk_freezeDetect) {
      switch (nwk_runCounter & 0x03) { // each of these tasks runs once per 4s (alternate):
      case 0x00:
        if (!nwk_sendHeartBeat())
          return 5;
        break;
      case 0x01:
        if (!(nwk_flags & (NWK_FLAGIDX_SINK | NWK_FLAGIDX_BOUND))) // not sink nor bound
          if (!nwk_bind_device(1, NWK_CMDIDRPT, 0))
            return 5;
        break;
      default:
        break;
      }

      portIndex = NWK_NEIGHBORMAX;
      while (portIndex) {
        portIndex--;
        if (nwk_neighbors[portIndex].foreignAddress != 0xFFFF)
          if (nwk_neighbors[portIndex].timeOut)
            nwk_neighbors[portIndex].timeOut--;
          else {
            nwk_neighbors[portIndex].foreignAddress = 0xFFFF;
            nwk_neighbors[portIndex].foreignPort = 0;
          }
      }
      nwk_freezeDetect--;
    } else {
      ccai_resetFull();
    }

    nwk_runCounter++;
    return 1000;
  default:
    nwk_currentState = NWK_S_INIT;
    return 1;
  }
  return 500;
}

void nwk_suspend() {
  nwk_returnState = nwk_currentState;
  // states that must be set to an earlier one
  nwk_lastParam = 0;
  nwk_lastParamSuccess = 0;
  nwk_currentState = NWK_S_SUSPENDED;
}

UInt8 nwk_wakeUp() {
  switch (nwk_currentState) {
  case NWK_S_CONFIGSTARTWAIT:
  case NWK_S_RESETWAIT:
    // device is in normal reset, it is not a simple wake-up
    return 0;
  case NWK_S_SUSPENDED: // Network is suspended, return to previous state.
    nwk_lastParamSuccess = 0;
    nwk_lastParam = 0;
    nwk_currentState = nwk_returnState;
  default: // If default, CC2480 was reset by its watch-dog
    // check the need of an earlier state
    switch (nwk_currentState) {
    case NWK_S_REGISTER:
    case NWK_S_START:
    case NWK_S_POSTSTARTCONFIGURE:
      nwk_lastParamSuccess = 0;
      nwk_lastParam = 0;
      nwk_currentState = NWK_S_CONFIGURE;
      break;
    case NWK_S_STARTWAIT:
    default:
      nwk_currentState = NWK_S_START; // This is to call nwk_start again
      break;
    }
    // Set led indicator to no network
    led_redConfigure(5, 300);
    break;
  }
  return 1;
}

void nwk_setDeviceType(nwk_devType newType) {
  nwk_currentDevType = newType;
  nwk_lastParam = 0;
  nwk_lastParamSuccess = 0;
  nwk_currentState = NWK_S_CONFIGSTART;
  // Set led indicator to no network
  led_redConfigure(5, 0);
}

nwk_devType nwk_getDeviceType() {
  if (nwk_currentState == NWK_S_RUNNING)
    return nwk_currentDevType;
  else
    return NWK_DEVTYPE_NONE;
}

void nwk_resetResume() {
  nwk_lastParam = 0;
  nwk_lastParamSuccess = 0;
  if (nwk_currentState == NWK_S_CONFIGSTARTWAIT)
    nwk_currentState = NWK_S_SETDEVICETYPE;
  else
    nwk_currentState = NWK_S_CONFIGURE;
  // Set led indicator to no network
  led_redConfigure(5, 300);
}

UInt8 nwk_configureWrite() {
  UInt8 v8;

  // Only write one configuration each time after the last one had success.
  // On fail, nwk_lastParam is set to last one successful and written again.
  switch (nwk_currentState) {
  case NWK_S_CONFIGSTART:
    switch (nwk_lastParamSuccess) {
    case 0:
      v8 = CCAI_CFGD_BIT_STARTOPT_CLEAR_CONFIG
          | CCAI_CFGD_BIT_STARTOPT_CLEAR_STATE;
      if (ccai_s_zb_write_configuration(CCAI_CFGD_ZCD_NV_STARTUP_OPTION,
          1, &v8))
        nwk_lastParam = 1;
      break;
    case 1:
      // configure finished, nwk_configureWriteRsp sets next state
      return 1;
    default: // If can't find last successful written configuration, restarting configuring
      nwk_lastParam = 0;
      nwk_lastParamSuccess = 0;
      break;
    }
  case NWK_S_SETDEVICETYPE:
    switch (nwk_lastParamSuccess) {
    case 0:
      switch (nwk_currentDevType) {
      case NWK_DEVTYPE_COORDINATOR:
        v8 = CCAI_CFGD_LOGICAL_TYPE_COORDINATOR;
        break;
      case NWK_DEVTYPE_ROUTER:
        v8 = CCAI_CFGD_LOGICAL_TYPE_ROUTER;
        break;
      case NWK_DEVTYPE_ENDDEVICE:
        v8 = CCAI_CFGD_LOGICAL_TYPE_ENDDEVICE;
        break;
      default:
        v8 = CCAI_CFGD_LOGICAL_TYPE_ROUTER;
        break;
      }
      if (ccai_s_zb_write_configuration(CCAI_CFGD_ZCD_NV_LOGICAL_TYPE, 1,
          &v8))
        nwk_lastParam = 1;
      break;
    case 1:
      // configure finished, nwk_configureWriteRsp sets next state
      return 1;
    default: // If can't find last successful written configuration, restarting configuring
      nwk_lastParam = 0;
      nwk_lastParamSuccess = 0;
      break;
    }
    break;
  case NWK_S_CONFIGURE:
    if (nwk_lastParam == nwk_lastParamSuccess)
      switch (nwk_lastParamSuccess) {
      case 0:
        // swra175a.pdf - 6.2.3.1 ZCD_NV_STARTUP_OPTION and ZASA cc2480.h
        if (nwk_currentDevType == NWK_DEVTYPE_COORDINATOR) {
          v8 = CCAI_CFGD_BIT_STARTOPT_CLEAR_STATE;
        } else {
          // CCAI_CFGD_BIT_STARTOPT_AUTO_START: undocumented on swra175a.pdf
          // got from ZASA cc2480.h file. See declaration at cc2480.h
          v8 = CCAI_CFGD_BIT_STARTOPT_CLEAR_STATE;
          //& CCAI_CFGD_BIT_STARTOPT_AUTO_START;
        }
        if (ccai_s_zb_write_configuration(
            CCAI_CFGD_ZCD_NV_STARTUP_OPTION, 1, &v8))
          nwk_lastParam = 1;
        break;
      case 1:
        // swra175a.pdf - 6.2.4.1 ZCD_NV_PANID
        if (ccai_s_zb_write_configuration(CCAI_CFGN_ZCD_NV_PANID, 2,
            NWK_CFG_PANID))
          nwk_lastParam = 2;
        break;
      case 2:
        // swra175a.pdf - 6.2.4.2 ZCD_NV_CHANLIST
        if (ccai_s_zb_write_configuration(CCAI_CFGN_ZCD_NV_CHANLIST, 4,
            NWK_CFG_CHANLIST))
          nwk_lastParam = 3;
        break;
      case 3:
        // swra175a.pdf - 6.2.4.3 ZCD_NV_PRECFGKEY
        if (ccai_s_zb_write_configuration(CCAI_CFGN_ZCD_NV_PRECFGKEY,
            16, NWK_CFG_PRECFGKEY))
          nwk_lastParam = 4;
        break;
      case 4:
        // swra175a.pdf - 6.2.4.4 ZCD_NV_PRECFGKEYS_ENABLE
        if (ccai_s_zb_write_configuration(
            CCAI_CFGN_ZCD_NV_PRECFGKEYS_ENABLE, 1,
            NWK_CFG_PRECFGKEYS_ENABLE))
          nwk_lastParam = 5;
        break;
      case 5:
        // swra175a.pdf - 6.2.4.5 ZCD_NV_SECURITY_MODE
        if (ccai_s_zb_write_configuration(
            CCAI_CFGN_ZCD_NV_SECURITY_MODE, 1,
            NWK_CFG_SECURITY_MODE))
          nwk_lastParam = 6;
        break;
      case 6:
        // swra175a.pdf - 6.2.4.6 ZCD_NV_BCAST_RETRIES
        if (ccai_s_zb_write_configuration(
            CCAI_CFGN_ZCD_NV_BCAST_RETRIES, 1,
            NWK_CFG_BCAST_RETRIES))
          nwk_lastParam = 7;
        break;
      case 7:
        // swra175a.pdf - 6.2.4.7 ZCD_NV_PASSIVE_ACK_TIMEOUT
        if (ccai_s_zb_write_configuration(
            CCAI_CFGN_ZCD_NV_PASSIVE_ACK_TIMEOUT, 1,
            NWK_CFG_PASSIVE_ACK_TIMEOUT))
          nwk_lastParam = 8;
        break;
      case 8:
        // swra175a.pdf - 6.2.4.8 ZCD_NV_BCAST_DELIVERY_TIME
        if (ccai_s_zb_write_configuration(
            CCAI_CFGN_ZCD_NV_BCAST_DELIVERY_TIME, 1,
            NWK_CFG_BCAST_DELIVERY_TIME))
          nwk_lastParam = 9;
        break;
      case 9:
        // swra175a.pdf - 6.2.4.9 ZCD_NV_ROUTE_EXPIRY_TIME
        if (ccai_s_zb_write_configuration(
            CCAI_CFGN_ZCD_NV_ROUTE_EXPIRY_TIME, 1,
            NWK_CFG_ROUTE_EXPIRY_TIME))
          nwk_lastParam = 10;
        break;
      case 10:
        // configure finished, nwk_configureWriteRsp sets next state
        return 1;
      default: // If can't find last successful written configuration, restarting configuring
        nwk_lastParam = 0;
        nwk_lastParamSuccess = 0;
        break;
      }
    break;
  case NWK_S_POSTSTARTCONFIGURE:
    if (nwk_lastParam == nwk_lastParamSuccess)
      switch (nwk_lastParamSuccess) {
      case 0:
        // swra175a.pdf - 6.2.3.1 ZCD_NV_STARTUP_OPTION
        if (nwk_currentDevType == NWK_DEVTYPE_COORDINATOR) {
          v8 = 0;
        } else {
          v8 = CCAI_CFGD_BIT_STARTOPT_AUTO_START;
        }
        if (ccai_s_zb_write_configuration(
            CCAI_CFGD_ZCD_NV_STARTUP_OPTION, 1, &v8))
          nwk_lastParam = 1;
        break;
      case 1:
        // configure finished, nwk_configureWriteRsp sets next state
        return 1;
      default: // If can't find last successful written configuration, restarting configuring
        nwk_lastParam = 0;
        nwk_lastParamSuccess = 0;
        break;
      }
    break;
  default:
    break;
  }
  return 0;
}

void nwk_configureWriteRsp(UInt8 status) {
  switch (status) {
  case CCAI_STA_ZSUCCESS:
    nwk_lastParamSuccess = nwk_lastParam;
    break;
  default:
    // Device failed to configure
    // In this program, the configuration will be sent again.
    // This could result in an infinite loop if the state that prevents the configuration do
    // not change, if it is the case, additional processing may be needed.
    nwk_lastParam = nwk_lastParamSuccess;
    break;
  }
  // Test for end of each configuration group:
  switch (nwk_currentState) {
  case NWK_S_CONFIGSTART:
    if (nwk_lastParamSuccess == 1) {
      nwk_lastParam = 0;
      nwk_lastParamSuccess = 0;
      nwk_currentState = NWK_S_CONFIGSTARTWAIT;
      ccai_resetLight();
    }
  case NWK_S_SETDEVICETYPE:
    if (nwk_lastParamSuccess == 1) {
      nwk_lastParam = 0;
      nwk_lastParamSuccess = 0;
      nwk_currentState = NWK_S_RESETWAIT;
      ccai_resetLight();
    }
  case NWK_S_CONFIGURE:
    if (nwk_lastParamSuccess == 10) {
      nwk_lastParam = 0;
      nwk_lastParamSuccess = 0;
      nwk_currentState = NWK_S_REGISTER;
    }
    break;
  case NWK_S_POSTSTARTCONFIGURE:
    if (nwk_lastParamSuccess == 1) {
      nwk_lastParam = 0;
      nwk_lastParamSuccess = 0;
      nwk_currentState = NWK_S_GETINFO;
    }
    break;
  default:
    break;
  }
}

UInt8 nwk_register() {
  return ccai_s_zb_app_register_request(NWK_CFG_APPENDPOINT,
      NWK_CFG_APPPROFILEID, NWK_CFG_DEVICEID, NWK_CFG_DEVICEVERSION,
      NWK_CFG_INPUTCMDCOUNT, NWK_CFG_INPUTCMDLIST, NWK_CFG_OUTPUTCMDCOUNT,
      NWK_CFG_OUTPUTCMDLIST);
}

void nwk_registerRsp(UInt8 status) {
  if (status == CCAI_STA_ZSUCCESS) {
    // Application is registered, start network
    nwk_currentState = NWK_S_START;
  }
}

UInt8 nwk_start() {
  return ccai_s_zb_start_request();
}

void nwk_startRsp() {
  // CC2480 is sending 0x66 0x00 instead of 0x66 0x03 after 0x26 0x03 and
  // instead of 0x66 0x02 after 0x26 0x02
  // so ignore the response if network state is NWK_S_RUNNING or NWK_S_CHECKFORBIND.
  if ((nwk_currentState != NWK_S_RUNNING)
      && (nwk_currentState != NWK_S_CHECKFORBIND))
    nwk_currentState = NWK_S_STARTWAIT;
}

void nwk_startConfirm(UInt8 status) {
  if (status == CCAI_STA_ZSUCCESS) {
    // Network is up
    nwk_currentState = NWK_S_POSTSTARTCONFIGURE;
  }
}

UInt8 nwk_allow_bind(UInt8 timeout) {
  return ccai_s_zb_allow_bind(timeout);
}

void nwk_allow_bindRsp() {
  // CC2480 is sending 6600, not 6602, so this code will not run.
}

void nwk_allow_bindConfirm(char *pBuf) {
  // another device bound to this one
#if DEBUG!=1
  // If debug, all received data is forward to serial by SPI, else forward here.
  uart_forwardCmd(pBuf);
#endif
}

UInt8 nwk_bind_device(UInt8 create, UInt16 commandId, uint64_t destination) {
  return ccai_s_zb_bind_device(create, commandId, destination);
}

void nwk_bind_deviceRsp() {

}

void nwk_bind_deviceConfirm(char *pBuf) {
  if ((pBuf[3] == NWK_CMDIDRPT) && (pBuf[4] == 0)) { // (UInt16) pBuf[3] == NWK_CMDIDRPT
#if DEBUG!=1
      // If debug, all received data is forward to serial by SPI, else forward here.
      uart_forwardCmd(pBuf);
#endif
    if (pBuf[5] == CCAI_STA_ZSUCCESS)
      nwk_flags |= NWK_FLAGIDX_BOUND;
    else
      nwk_flags &= NWK_FLAGIDX_NBOUND;
  }
}

UInt8 nwk_getDeviceInfo() {
  // swra175a.pdf - 6.3.12 ZB_GET_DEVICE_INFO
  // read one information each time after last value read have success
  if (nwk_lastParam == nwk_lastParamSuccess) {
    // The nwk_lastParam and nwk_lastParamSuccess used to be set to CCAI_INFO_XXX, but this
    // relies on no configuration Id being 0 (zero), but CCAI_INFO_STATE = 0, so
    // nwk_lastParamSuccessit was changed to sequential numbers.

    switch (nwk_lastParamSuccess) {
    case 0:
      if (ccai_s_zb_get_device_info(CCAI_INFO_STATE))
        nwk_lastParam = 1;
      break;
    case 1:
      if (ccai_s_zb_get_device_info(CCAI_INFO_IEEEADDRESS))
        nwk_lastParam = 2;
      break;
    case 2:
      if (ccai_s_zb_get_device_info(CCAI_INFO_SHORTADDRESS))
        nwk_lastParam = 3;
      break;
    case 3:
      if (ccai_s_zb_get_device_info(CCAI_INFO_PARENTSHORTADDRESS))
        nwk_lastParam = 4;
      break;
    case 4:
      if (ccai_s_zb_get_device_info(CCAI_INFO_PARENTIEEEADDRESS))
        nwk_lastParam = 5;
      break;
    case 5:
      if (ccai_s_zb_get_device_info(CCAI_INFO_ZBCHANNEL))
        nwk_lastParam = 6;
      break;
    case 6:
      if (ccai_s_zb_get_device_info(CCAI_INFO_ZBPANID))
        nwk_lastParam = 7;
      break;
    case 7:
      if (ccai_s_zb_get_device_info(CCAI_INFO_ZBEXTENDEDPANID))
        nwk_lastParam = 8;
      break;
    case 8:
      // all parameters have been requested
      return 1;
    default: // If can't find last successful information, restart reading
      nwk_lastParam = 0;
      nwk_lastParamSuccess = 0;
      break;
    }
  }
  return 0;
}

void nwk_getDeviceInfoRsp(UInt8 param, void *pValue) {
  // Not all information is useful, and there isn't a lot of gratuitous RAM, so only needed
  // information is stored.
  switch (param) {
  case CCAI_INFO_STATE:
    break;
  case CCAI_INFO_IEEEADDRESS:
    nwk_ieeeAddress = *((uint64_t *) pValue);
    break;
  case CCAI_INFO_SHORTADDRESS:
    nwk_address = *((UInt16 *) pValue);
    break;
  case CCAI_INFO_PARENTSHORTADDRESS:
    break;
  case CCAI_INFO_PARENTIEEEADDRESS:
    break;
  case CCAI_INFO_ZBCHANNEL:
    break;
  case CCAI_INFO_ZBPANID:
    break;
  case CCAI_INFO_ZBEXTENDEDPANID:
    // Last parameter, pass network to next state
    // Configure led indicator
    switch (nwk_currentDevType) {
    case NWK_DEVTYPE_COORDINATOR:
      led_redConfigure(2, 600);
      break;
    case NWK_DEVTYPE_ROUTER:
      led_redConfigure(1, 800);
      break;
    case NWK_DEVTYPE_ENDDEVICE:
      led_redConfigure(1, 2800);
      break;
    default:
      // Error, no valid device type selected, reset MSP430
      WDTCTL = 0;
      break;
    }
    break;
  default:
    break;
  }
  nwk_lastParamSuccess = nwk_lastParam;
  if (nwk_lastParamSuccess == 8) {
    nwk_lastParam = 0;
    nwk_lastParamSuccess = 0;
    nwk_currentState = NWK_S_CHECKFORBIND;
  }

}

UInt8 nwk_setPermitJoin(UInt8 timeout) {
  if (nwk_currentState != NWK_S_RUNNING) {
    return 0;
  }
  return ccai_s_zb_permit_joining_request(0xFFFC, timeout);
}

void nwk_setPermitJoinRsp() {
  // no action needed
}

UInt8 nwk_allowJoin() {
  return nwk_setPermitJoin(0xFF);
}

UInt8 nwk_disallowJoin() {
  return nwk_setPermitJoin(0x00);
}

UInt8 nwk_isClient() {
  return ((nwk_currentDevType == NWK_DEVTYPE_ROUTER)
      || (nwk_currentDevType == NWK_DEVTYPE_ENDDEVICE))
      && (nwk_currentState == NWK_S_RUNNING);
}

UInt8 nwk_isSink() {
  return nwk_flags & NWK_FLAGIDX_SINK;
}

UInt8 nwk_isBound() {
  return nwk_flags & NWK_FLAGIDX_BOUND;
}


void nwk_setSink(UInt8 sink) {
  if (sink) {
    if (nwk_allow_bind(0xFF))
      nwk_flags |= NWK_FLAGIDX_SINK;
  } else {
    if (nwk_allow_bind(0))
      nwk_flags &= NWK_FLAGIDX_NSINK;
  }
}

UInt16 nwk_getShortAddress() {
  return nwk_address;
}

uint64_t nwk_getIeeeAddress() {
  return nwk_ieeeAddress;
}

uint64_t * nwk_getPIeeeAddress() {
  return &nwk_ieeeAddress;
}

UInt8 nwk_startFrame(UInt16 destination, UInt16 cmdId, UInt8 radius, UInt8 len) {
  if (nwk_currentState != NWK_S_RUNNING) {
    return 0;
  }
  return ccai_s_zb_send_data_request_begin(destination, cmdId, nwk_dataHandle,
      NWK_DEFACK, radius, len);
}

UInt8 nwk_snd(UInt8 len, void *pBuf) {
  return ccai_s_zb_send_data_request_payload(len, pBuf);
}

void nwk_endFrame(UInt8 forwardToSerial) {
  ccai_s_zb_send_data_request_end(forwardToSerial);
  nwk_dataHandle++;
}

UInt8 nwk_sndUInt8(UInt8 v) {
  return nwk_snd(1, &v);
}

UInt8 nwk_sndUInt16(UInt16 v) {
  return nwk_snd(2, &v);
}

UInt8 nwk_sndUInt32(UInt32 *p) {
  return nwk_snd(4, p);
}

UInt8 nwk_sndUInt48(uint64_t *p) {
  return nwk_snd(6, p);
}

UInt8 nwk_sndUInt64(uint64_t *p) {
  return nwk_snd(8, p);
}

UInt8 nwk_sndInt64(int64_t *p) {
  return nwk_snd(8, p);
}

void nwk_send_dataConfirm(UInt8 dataHandle, UInt8 status) {
  if (status == CCAI_STA_ZAPSNOBOUNDDEVICE) // ZApsNoBoundDevice
    nwk_flags &= NWK_FLAGIDX_NBOUND;
  if (status == CCAI_STA_ZFAILURE) {
    if (nwk_flags & NWK_FLAGIDX_SENDFAIL) {
      nwk_flags &= NWK_FLAGIDX_NSENDFAIL & NWK_FLAGIDX_NBOUND;
    } else {
      nwk_flags |= NWK_FLAGIDX_SENDFAIL;
    }
  } else {
    if (nwk_flags & NWK_FLAGIDX_BOUND) {
      nwk_flags &= NWK_FLAGIDX_NSENDFAIL;
    }
  }
}

void nwk_rcv(char *pBuf) {
  UInt16 src;
  UInt16 cmd;
  UInt16 len;
  UInt8 portNumber;
  UInt8 i;

  nwk_freezeDetect = 4 + ((char *) &nwk_ieeeAddress)[0];

  src = pBuf[3] | (pBuf[4] << 8);
  cmd = pBuf[5] | (pBuf[6] << 8);
  len = pBuf[7] | (pBuf[8] << 8);

  switch (cmd) {
  case NWK_CMDIDHEARTBEAT:
    // heart beat
    portNumber = nwk_getNeighborPort(src);
    if (portNumber) {
      nwk_neighbors[portNumber - 1u].timeOut =
          NWK_NEIGHBORHEARTBEATTIMEOUT;
    } else {
      portNumber = nwk_registerNeighbor(src);
    }
    if (portNumber) {
      // verify if neighbor know this device, if so, register the port reported by the neighbor
      pBuf += 9;
      i = 0;
      while (i < len) {
        if (nwk_address == (pBuf[i] | (pBuf[i + 1u] << 8))) {
          nwk_neighbors[portNumber - 1u].foreignPort = pBuf[i + 2u];
          // no need to continue scan, device was found:
          i = len;
        } else
          i += 3;
      }
    } else {
      // neighbor is unknown and not enough resources to record a new one.
    }
  case NWK_CMDIDRPT:
    // report
#if DEBUG!=1
    // If debug, all received data is forward to serial by SPI, else forward here if device is in sink mode.
    if (nwk_isSink())
    uart_forwardCmd(pBuf);
#endif
    break;
  default:
    break;
  }
}

UInt8 nwk_sendHeartBeat() {
  UInt8 size;
  UInt8 portIndex;

  size = 0;
  portIndex = NWK_NEIGHBORMAX;
  while (portIndex) {
    portIndex--;
    if (nwk_neighbors[portIndex].foreignAddress != 0xFFFF) {
      size += 3;
    }
  };

  if (nwk_startFrame(0xFFFF, NWK_CMDIDHEARTBEAT, 1, size)) {
    portIndex = NWK_NEIGHBORMAX;
    while (portIndex) {
      portIndex--;
      if (nwk_neighbors[portIndex].foreignAddress != 0xFFFF) {
        nwk_sndUInt16(nwk_neighbors[portIndex].foreignAddress);
        nwk_sndUInt8(portIndex + 1);
      }
    };
    nwk_endFrame(FALSE);
    return 1;
  }
  return 0;
}

UInt8 nwk_getNeighborPort(UInt16 a) {
  UInt8 portIndex;

  portIndex = NWK_NEIGHBORMAX;
  while (portIndex) {
    portIndex--;
    if (nwk_neighbors[portIndex].foreignAddress == a) {
      return portIndex + 1;
    }
  };
  return 0;
}

UInt8 nwk_getNeighborForeignPort(UInt8 portNumber) {
  if ((!portNumber) || (portNumber > NWK_NEIGHBORMAX))
    return 0;
  portNumber--; // portIndex from here
  return nwk_neighbors[portNumber].foreignPort;
}

UInt16 nwk_getNeighborAddress(UInt8 portNumber) {
  if ((!portNumber) || (portNumber > NWK_NEIGHBORMAX))
    return 0xFFFF;
  portNumber--; // portIndex from here
  return nwk_neighbors[portNumber].foreignAddress;

}

UInt8 nwk_registerNeighbor(UInt16 a) {
  UInt8 portIndex;

  portIndex = NWK_NEIGHBORMAX;
  while (portIndex) {
    portIndex--;
    if (nwk_neighbors[portIndex].foreignAddress == 0xFFFF) {
      nwk_neighbors[portIndex].foreignAddress = a;
      nwk_neighbors[portIndex].foreignPort = 0;
      nwk_neighbors[portIndex].timeOut = NWK_NEIGHBORHEARTBEATTIMEOUT;
      return portIndex + 1;
    }
  };
  return 0;
}