cc2480ai.c

Go to the documentation of this file.

/*
 * cc2480ai.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
 *
 */

/*
 * CC2480 Application Interface
 * based on swra175a.pdf section 6
 *
 * Reference connections (as in "CC2480 Target Board Schematics_1_4.pdf"):
 * 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 "cc2480ai.h"
#include "spi.h"
#include "nwk.h"

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

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

#define CCAI_MSGP_SYS_RESET_IND_CMD          0x4180

#define CCAI_MSGR_SYS_VERION                 0x6102

#define CCAI_MSGR_SYS_OSAL_NV_READ           0x6108

#define CCAI_MSGR_SYS_OSAL_NV_WRITE          0x6109

#define CCAI_MSGR_SYS_OSAL_START_TIMER       0x610A

#define CCAI_MSGR_SYS_OSAL_STOP_TIMER        0x610B

#define CCAI_MSGP_SYS_OSAL_TIMER_EXPIRED     0x4181

#define CCAI_MSGR_SYS_RANDOM                 0x610C

#define CCAI_MSGR_SYS_ADC_READ               0x610D

#define CCAI_MSGR_SYS_GPIO                   0x610E

#define CCAI_MSGR_SYS_TEST_LOOPBACK          0x6141

#define CCAI_MSGR_ZB_READ_CONFIGURATION      0x6604

#define CCAI_MSGR_ZB_WRITE_CONFIGURATION     0x6605

#define CCAI_MSGR_ZB_APP_REGISTER_REQUEST    0x660A

#define CCAI_MSGR_ZB_START_REQUEST           0x6600

#define CCAI_MSGP_ZB_START_CONFIRM           0x4680

#define CCAI_MSGR_ZB_PERMIT_JOINING_REQUEST  0x6608

#define CCAI_MSGR_ZB_BIND_DEVICE             0x6601

#define CCAI_MSGP_ZB_BIND_CONFIRM            0x4681

#define CCAI_MSGR_ZB_ALLOW_BIND              0x6602

#define CCAI_MSGP_ZB_ALLOW_BIND_CONFIRM      0x4682

#define CCAI_MSGR_ZB_SEND_DATA_REQUEST       0x6603

#define CCAI_MSGP_ZB_SEND_DATA_CONFIRM       0x4683

#define CCAI_MSGP_ZB_RECEIVE_DATA_INDICATION 0x4687

#define CCAI_MSGR_ZB_GET_DEVICE_INFO         0x6606

#define CCAI_MSGR_ZB_FIND_DEVICE_REQUEST     0x6607

#define CCAI_MSGP_ZB_FIND_DEVICE_CONFIRM     0x4685

#define CCAI_MSGR_AF_REGISTER                0x6400

#define CCAI_MSGR_AF_DATA_REQUEST            0x6401

#define CCAI_MSGP_AF_DATA_CONFIRM            0x4480

#define CCAI_MSGP_AF_INCOMING_MSG            0x4481

#define CCAI_MSGR_ZDO_NWK_ADDR_REQ           0x6500

#define CCAI_MSGP_ZDO_NWK_ADDR_RSP           0x4580

#define CCAI_MSGR_ZDO_IEEE_ADDR_REQ          0x6501

#define CCAI_MSGP_ZDO_IEEE_ADDR_RSP          0x4581

#define CCAI_MSGR_ZDO_NODE_DESC_REQ          0x6502

#define CCAI_MSGP_ZDO_NODE_DESC_RSP          0x4582

#define CCAI_MSGR_ZDO_SIMPLE_DESC_REQ        0x6504

#define CCAI_MSGP_ZDO_SIMPLE_DESC_RSP        0x4584

#define CCAI_MSGR_ZDO_ACTIVE_EP_REQ          0x6505

#define CCAI_MSGP_ZDO_ACTIVE_EP_RSP          0x4585

#define CCAI_MSGR_ZDO_MATCH_DESC_REQ         0x6506

#define CCAI_MSGP_ZDO_MATCH_DESC_RSP         0x4586

#define CCAI_MSGP_ZDO_MATCH_DESC_RSP_SENT    0x45C2

#define CCAI_MSGR_ZDO_USER_DESC_REQ          0x6508

#define CCAI_MSGP_ZDO_USER_DESC_RSP          0x4588

#define CCAI_MSGR_ZDO_USER_DESC_SET          0x650B

#define CCAI_MSGP_ZDO_USER_DESC_CONF         0x4589

#define CCAI_MSGR_ZDO_END_DEVICE_ANNCE       0x650A

#define CCAI_MSGP_ZDO_END_DEVICE_ANNCE_IND   0x45C1

#define CCAI_MSGR_ZDO_END_DEVICE_BIND_REQ    0x6520 // Unclear sender from this line

#define CCAI_MSGP_ZDO_END_DEVICE_BIND_RSP    0x45A0

#define CCAI_MSGR_ZDO_BIND_REQ               0x6521

#define CCAI_MSGP_ZDO_BIND_RSP               0x45A1

#define CCAI_MSGR_ZDO_UNBIND_REQ             0x6522

#define CCAI_MSGP_ZDO_UNBIND_RSP             0x45A2

#define CCAI_MSGR_ZDO_MGMT_LQI_REQ           0x6531

#define CCAI_MSGP_ZDO_MGMT_LQI_RSP           0x45B1

#define CCAI_MSGR_ZDO_MGMT_LEAVE_REQ         0x6534

#define CCAI_MSGP_ZDO_MGMT_LEAVE_RSP         0x45B4

#define CCAI_MSGR_ZDO_MGMT_PERMIT_JOIN_REQ   0x6536

#define CCAI_MSGP_ZDO_MGMT_PERMIT_JOIN_RSP   0x45B6

#define CCAI_MSGP_ZDO_STATE_CHANGE_IND       0x45C0

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

typedef enum ccai_state {
  CCAI_S_INIT, 
  CCAI_S_POWERUPHOLD, 
  CCAI_S_POWERUPWAIT, 
  CCAI_S_DORESET, 
  CCAI_S_RESETHOLD, 
  CCAI_S_RESETWAIT, 
  CCAI_S_RUNNING 
} ccai_state;

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

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

ccai_state ccai_currentState;

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

// Incoming messages
// ccai_p: poll (may be response to an earlier AREQ or SREQ)
// ccai_r: response to a SREQ
// Configuration interface
void ccai_p_sys_reset_ind();
void ccai_r_sys_version();
void ccai_r_sys_osal_nv_read();
void ccai_r_sys_osal_nv_write();
void ccai_r_sys_osal_start_timer();
void ccai_r_sys_osal_stop_timer();
void ccai_p_sys_osal_timer_expired();
void ccai_r_sys_random();
void ccai_r_sys_adc_read();
void ccai_r_sys_gpio();
void ccai_r_sys_test_loopback();
// Configuration interface
void ccai_r_zb_read_configuration();
void ccai_r_zb_write_configuration();
// Simple API interface
void ccai_r_zb_app_register_request();
void ccai_r_zb_start_request();
void ccai_p_zb_start_confirm();
void ccai_r_zb_permit_joining_request();
void ccai_r_zb_bind_device();
void ccai_p_zb_bind_confirm();
void ccai_r_zb_allow_bind();
void ccai_p_zb_allow_bind_confirm();
void ccai_r_zb_send_data_request();
void ccai_p_zb_send_data_confirm();
void ccai_p_zb_receive_data_indication();
void ccai_r_zb_get_device_info();
void ccai_r_zb_find_device_request();
void ccai_p_zb_find_device_confirm();
// AF interface
void ccai_r_af_register();
void ccai_r_af_data_request();
void ccai_p_af_data_confirm();
void ccai_p_af_incoming_msg();
// ZDO interface
void ccai_r_zdo_nwk_addr_req();
void ccai_p_zdo_nwk_addr_rsp();
void ccai_r_zdo_ieee_addr_req();
void ccai_p_zdo_ieee_addr_rsp();
void ccai_r_zdo_node_desc_req();
void ccai_p_zdo_node_desc_rsp();
void ccai_r_zdo_simple_desc_req();
void ccai_p_zdo_simple_desc_rsp();
void ccai_r_zdo_active_ep_req();
void ccai_p_zdo_active_ep_rsp();
void ccai_r_zdo_match_desc_req();
void ccai_p_zdo_match_desc_rsp();
void ccai_p_zdo_match_desc_rsp_sent();
void ccai_r_zdo_user_desc_req();
void ccai_p_zdo_user_desc_rsp();
void ccai_r_zdo_user_desc_set();
void ccai_p_zdo_user_desc_conf();
void ccai_r_zdo_end_device_annce();
void ccai_p_zdo_end_device_annce_ind();
void ccai_r_zdo_end_device_bind_req(); // unclear sender from this line
void ccai_p_zdo_end_device_bind_rsp();
void ccai_r_zdo_bind_req();
void ccai_p_zdo_bind_rsp();
void ccai_r_zdo_unbind_req();
void ccai_p_zdo_unbind_rsp();
void ccai_r_zdo_mgmt_lqi_req();
void ccai_p_zdo_mgmt_lqi_rsp();
void ccai_r_zdo_mgmt_leave_req();
void ccai_p_zdo_mgmt_leave_rsp();
void ccai_r_zdo_mgmt_permit_join_req();
void ccai_p_zdo_mgmt_permit_join_rsp();
void ccai_p_zdo_state_change_ind();

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

void ccai_init() {
  ccai_currentState = CCAI_S_INIT;
  P4OUT |= BIT0 | BIT1; // cfg0 - 32KHz crystal, cfg1 - SPI
  P4DIR |= BIT0 | BIT1;
}

UInt16 ccai_proccess() {
  switch (ccai_currentState) {
  case CCAI_S_INIT:
    P3OUT &= ~BIT7;
    ccai_currentState = CCAI_S_POWERUPHOLD;
    P4OUT |= BIT0 | BIT1; // cfg0 - 32KHz crystal, cfg1 - SPI
    P4DIR |= BIT0 | BIT1;
    spi_init();
    return 10;
  case CCAI_S_POWERUPHOLD:
    P3OUT |= BIT7;
    ccai_currentState = CCAI_S_POWERUPWAIT;
    return 10;
  case CCAI_S_POWERUPWAIT:
    // Then wait for command SYS_RESET_IND_CMD, the called function will set next state
    return 10;
  case CCAI_S_DORESET:
    // reset again
    P3OUT &= ~BIT7;
    ccai_currentState = CCAI_S_RESETHOLD;
    return 10;
  case CCAI_S_RESETHOLD:
    P3OUT |= BIT7;
    ccai_currentState = CCAI_S_RESETWAIT;
    return 10;
  case CCAI_S_RESETWAIT:
    // Then wait for command SYS_RESET_IND_CMD, the called function will set next state
    return 250;
  case CCAI_S_RUNNING:
    return 1000;
  default:
    ccai_currentState = CCAI_S_RESETWAIT;
    return 1;
  }
}

void ccai_resetFull() {
  ccai_currentState = CCAI_S_INIT;
}

void ccai_resetLight() {
  ccai_currentState = CCAI_S_DORESET;
}

void ccai_process_message() {
  UInt16 cmd;
  cmd = spi_buf[1];
  cmd <<= 8;
  cmd |= spi_buf[2];
  switch (cmd) {
  case CCAI_MSGP_SYS_RESET_IND_CMD:
    ccai_p_sys_reset_ind();
    break;
  case CCAI_MSGR_SYS_VERION:
    ccai_r_sys_version();
    break;
  case CCAI_MSGR_SYS_OSAL_NV_READ:
    ccai_r_sys_osal_nv_read();
    break;
  case CCAI_MSGR_SYS_OSAL_NV_WRITE:
    ccai_r_sys_osal_nv_write();
    break;
  case CCAI_MSGR_SYS_OSAL_START_TIMER:
    ccai_r_sys_osal_start_timer();
    break;
  case CCAI_MSGR_SYS_OSAL_STOP_TIMER:
    ccai_r_sys_osal_stop_timer();
    break;
  case CCAI_MSGP_SYS_OSAL_TIMER_EXPIRED:
    ccai_p_sys_osal_timer_expired();
    break;
  case CCAI_MSGR_SYS_RANDOM:
    ccai_r_sys_random();
    break;
  case CCAI_MSGR_SYS_ADC_READ:
    ccai_r_sys_adc_read();
    break;
  case CCAI_MSGR_SYS_GPIO:
    ccai_r_sys_gpio();
    break;
  case CCAI_MSGR_SYS_TEST_LOOPBACK:
    ccai_r_sys_test_loopback();
    break;
    // Configuration interface
  case CCAI_MSGR_ZB_READ_CONFIGURATION:
    ccai_r_zb_read_configuration();
    break;
  case CCAI_MSGR_ZB_WRITE_CONFIGURATION:
    ccai_r_zb_write_configuration();
    break;
    // Simple API interface
  case CCAI_MSGR_ZB_APP_REGISTER_REQUEST:
    ccai_r_zb_app_register_request();
    break;
  case CCAI_MSGR_ZB_START_REQUEST:
    ccai_r_zb_start_request();
    break;
  case CCAI_MSGP_ZB_START_CONFIRM:
    ccai_p_zb_start_confirm();
    break;
  case CCAI_MSGR_ZB_PERMIT_JOINING_REQUEST:
    ccai_r_zb_permit_joining_request();
    break;
  case CCAI_MSGR_ZB_BIND_DEVICE:
    ccai_r_zb_bind_device();
    break;
  case CCAI_MSGP_ZB_BIND_CONFIRM:
    ccai_p_zb_bind_confirm();
    break;
  case CCAI_MSGR_ZB_ALLOW_BIND:
    ccai_r_zb_allow_bind();
    break;
  case CCAI_MSGP_ZB_ALLOW_BIND_CONFIRM:
    ccai_p_zb_allow_bind_confirm();
    break;
  case CCAI_MSGR_ZB_SEND_DATA_REQUEST:
    ccai_r_zb_send_data_request();
    break;
  case CCAI_MSGP_ZB_SEND_DATA_CONFIRM:
    ccai_p_zb_send_data_confirm();
    break;
  case CCAI_MSGP_ZB_RECEIVE_DATA_INDICATION:
    ccai_p_zb_receive_data_indication();
    break;
  case CCAI_MSGR_ZB_GET_DEVICE_INFO:
    ccai_r_zb_get_device_info();
    break;
  case CCAI_MSGR_ZB_FIND_DEVICE_REQUEST:
    ccai_r_zb_find_device_request();
    break;
  case CCAI_MSGP_ZB_FIND_DEVICE_CONFIRM:
    ccai_p_zb_find_device_confirm();
    break;
    // AF interface
  case CCAI_MSGR_AF_REGISTER:
    ccai_r_af_register();
    break;
  case CCAI_MSGR_AF_DATA_REQUEST:
    ccai_r_af_data_request();
    break;
  case CCAI_MSGP_AF_DATA_CONFIRM:
    ccai_p_af_data_confirm();
    break;
  case CCAI_MSGP_AF_INCOMING_MSG:
    ccai_p_af_incoming_msg();
    break;
    // ZDO interface
  case CCAI_MSGR_ZDO_NWK_ADDR_REQ:
    ccai_r_zdo_nwk_addr_req();
    break;
  case CCAI_MSGP_ZDO_NWK_ADDR_RSP:
    ccai_p_zdo_nwk_addr_rsp();
    break;
  case CCAI_MSGR_ZDO_IEEE_ADDR_REQ:
    ccai_r_zdo_ieee_addr_req();
    break;
  case CCAI_MSGP_ZDO_IEEE_ADDR_RSP:
    ccai_p_zdo_ieee_addr_rsp();
    break;
  case CCAI_MSGR_ZDO_NODE_DESC_REQ:
    ccai_r_zdo_node_desc_req();
    break;
  case CCAI_MSGP_ZDO_NODE_DESC_RSP:
    ccai_p_zdo_node_desc_rsp();
    break;
  case CCAI_MSGR_ZDO_SIMPLE_DESC_REQ:
    ccai_r_zdo_simple_desc_req();
    break;
  case CCAI_MSGP_ZDO_SIMPLE_DESC_RSP:
    ccai_p_zdo_simple_desc_rsp();
    break;
  case CCAI_MSGR_ZDO_ACTIVE_EP_REQ:
    ccai_r_zdo_active_ep_req();
    break;
  case CCAI_MSGP_ZDO_ACTIVE_EP_RSP:
    ccai_p_zdo_active_ep_rsp();
    break;
  case CCAI_MSGR_ZDO_MATCH_DESC_REQ:
    ccai_r_zdo_match_desc_req();
    break;
  case CCAI_MSGP_ZDO_MATCH_DESC_RSP:
    ccai_p_zdo_match_desc_rsp();
    break;
  case CCAI_MSGP_ZDO_MATCH_DESC_RSP_SENT:
    ccai_p_zdo_match_desc_rsp_sent();
    break;
  case CCAI_MSGR_ZDO_USER_DESC_REQ:
    ccai_r_zdo_user_desc_req();
    break;
  case CCAI_MSGP_ZDO_USER_DESC_RSP:
    ccai_p_zdo_user_desc_rsp();
    break;
  case CCAI_MSGR_ZDO_USER_DESC_SET:
    ccai_r_zdo_user_desc_set();
    break;
  case CCAI_MSGP_ZDO_USER_DESC_CONF:
    ccai_p_zdo_user_desc_conf();
    break;
  case CCAI_MSGR_ZDO_END_DEVICE_ANNCE:
    ccai_r_zdo_end_device_annce();
    break;
  case CCAI_MSGP_ZDO_END_DEVICE_ANNCE_IND:
    ccai_p_zdo_end_device_annce_ind();
    break;
  case CCAI_MSGR_ZDO_END_DEVICE_BIND_REQ:
    ccai_r_zdo_end_device_bind_req();
    break;
  case CCAI_MSGP_ZDO_END_DEVICE_BIND_RSP:
    ccai_p_zdo_end_device_bind_rsp();
    break;
  case CCAI_MSGR_ZDO_BIND_REQ:
    ccai_r_zdo_bind_req();
    break;
  case CCAI_MSGP_ZDO_BIND_RSP:
    ccai_p_zdo_bind_rsp();
    break;
  case CCAI_MSGR_ZDO_UNBIND_REQ:
    ccai_r_zdo_unbind_req();
    break;
  case CCAI_MSGP_ZDO_UNBIND_RSP:
    ccai_p_zdo_unbind_rsp();
    break;
  case CCAI_MSGR_ZDO_MGMT_LQI_REQ:
    ccai_r_zdo_mgmt_lqi_req();
    break;
  case CCAI_MSGP_ZDO_MGMT_LQI_RSP:
    ccai_p_zdo_mgmt_lqi_rsp();
    break;
  case CCAI_MSGR_ZDO_MGMT_LEAVE_REQ:
    ccai_r_zdo_mgmt_leave_req();
    break;
  case CCAI_MSGP_ZDO_MGMT_LEAVE_RSP:
    ccai_p_zdo_mgmt_leave_rsp();
    break;
  case CCAI_MSGR_ZDO_MGMT_PERMIT_JOIN_REQ:
    ccai_r_zdo_mgmt_permit_join_req();
    break;
  case CCAI_MSGP_ZDO_MGMT_PERMIT_JOIN_RSP:
    ccai_p_zdo_mgmt_permit_join_rsp();
    break;
  case CCAI_MSGP_ZDO_STATE_CHANGE_IND:
    ccai_p_zdo_state_change_ind();
    break;
  default:
    break;
  }
}

UInt8 ccai_a_sys_reset_req() {
  if (spi_reqBegin(1, 0x41, 0x00)) {
    spi_reqData(1, "\x00");
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_p_sys_reset_ind() {
  switch (ccai_currentState) {
  case CCAI_S_POWERUPWAIT:
    // configure initial device type
    nwk_setDeviceType(NWK_DEVTYPE_DEFALUT); // This will call ccai_resetLight()
    break;
  default:
    ccai_currentState = CCAI_S_RUNNING;
    // if nwk_state is suspended, wake up it, else configure the network.
    if (!nwk_wakeUp())
      nwk_resetResume();
    break;
  }
}

UInt8 ccai_s_sys_version() {
  if (spi_reqBegin(0, 0x21, 0x02)) {
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_sys_version() {

}

UInt8 ccai_s_sys_osal_nv_read(UInt16 id, UInt8 offset) {
  if (spi_reqBegin(3, 0x21, 0x08)) {
    spi_reqData(2, &id);
    spi_reqData(1, &offset);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_sys_osal_nv_read() {

}

UInt8 ccai_s_sys_osal_nv_write(UInt16 id, UInt8 offset, UInt8 len, char *pBuf) {
  if (len > 16) {
    return 0;
  }
  if (spi_reqBegin(4 + len, 0x21, 0x09)) {
    spi_reqData(2, &id);
    spi_reqData(1, &offset);
    spi_reqData(1, &len);
    spi_reqData(len, pBuf);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_sys_osal_nv_write() {

}

UInt8 ccai_s_sys_osal_start_timer(UInt8 id, UInt16 timeout) {
  if (spi_reqBegin(3, 0x21, 0x0A)) {
    spi_reqData(1, &id);
    spi_reqData(2, &timeout);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_sys_osal_start_timer() {

}

UInt8 ccai_s_sys_osal_stop_timer(UInt8 id) {
  if (spi_reqBegin(1, 0x21, 0x0B)) {
    spi_reqData(1, &id);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_sys_osal_stop_timer() {

}

void ccai_p_sys_osal_timer_expired() {

}

UInt8 ccai_s_sys_random() {
  if (spi_reqBegin(0, 0x21, 0x0C)) {
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_sys_random() {

}

UInt8 ccai_s_sys_adc_read(UInt8 channel, UInt8 resolution) {
  if (spi_reqBegin(2, 0x21, 0x0D)) {
    spi_reqData(1, &channel);
    spi_reqData(1, &resolution);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_sys_adc_read() {

}

UInt8 ccai_s_sys_gpio(UInt8 operation, UInt8 value) {
  if (spi_reqBegin(2, 0x21, 0x0E)) {
    spi_reqData(1, &operation);
    spi_reqData(1, &value);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_sys_gpio() {

}

UInt8 ccai_a_sys_test_rf(UInt8 testMode, UInt16 frequency, UInt8 txPower) {
  if (spi_reqBegin(4, 0x41, 0x40)) {
    spi_reqData(1, &testMode);
    spi_reqData(2, &frequency);
    spi_reqData(1, &txPower);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

UInt8 ccai_s_sys_test_loopback(UInt8 len, char *pBuf) {
  if (len > 253) {
    return 0;
  }
  if (spi_reqBegin(len, 0x21, 0x41)) {
    spi_reqData(len, pBuf);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_sys_test_loopback() {

}

UInt8 ccai_s_zb_read_configuration(UInt8 configId) {
  if (spi_reqBegin(1, 0x26, 0x04)) {
    spi_reqData(1, &configId);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_zb_read_configuration() {

}

UInt8 ccai_s_zb_write_configuration(UInt8 configId, UInt8 len, void *pBuf) {
  if ((len == 0) || (len > 128)) {
    return 0;
  }
  if (spi_reqBegin(2 + len, 0x26, 0x05)) {
    spi_reqData(1, &configId);
    spi_reqData(1, &len);
    spi_reqData(len, pBuf);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_zb_write_configuration() {
  nwk_configureWriteRsp(spi_buf[3]);
}

UInt8 ccai_s_zb_app_register_request(UInt8 appEndPoint, UInt16 appProfileId,
    UInt16 DeviceId, UInt8 DeviceVersion, UInt8 inputCommandsNum,
    char *InputCommandsList, UInt8 OutputCommandsNum,
    char *OutputCommandsList) {
  if (spi_reqBegin(9 + (inputCommandsNum << 1) + (OutputCommandsNum << 1),
      0x26, 0x0A)) {
    spi_reqData(1, &appEndPoint);
    spi_reqData(2, &appProfileId);
    spi_reqData(2, &DeviceId);
    spi_reqData(1, &DeviceVersion);
    spi_reqData(1, "\x00");
    spi_reqData(1, &inputCommandsNum);
    spi_reqData(inputCommandsNum << 1, InputCommandsList);
    spi_reqData(1, &OutputCommandsNum);
    spi_reqData(OutputCommandsNum << 1, OutputCommandsList);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_zb_app_register_request() {
  nwk_registerRsp(spi_buf[3]);
}

UInt8 ccai_s_zb_start_request() {
  if (spi_reqBegin(0, 0x26, 0x00)) {
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_zb_start_request() {
  nwk_startRsp();
}

void ccai_p_zb_start_confirm() {
  nwk_startConfirm(spi_buf[3]);
}

UInt8 ccai_s_zb_permit_joining_request(UInt16 destination, UInt8 timeOut) {
  if (spi_reqBegin(3, 0x26, 0x08)) {
    spi_reqData(2, &destination);
    spi_reqData(1, &timeOut);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_zb_permit_joining_request() {
  nwk_setPermitJoinRsp();
}

UInt8 ccai_s_zb_bind_device(UInt8 create, UInt16 commandId,
    uint64_t destination) {
  if (spi_reqBegin(11, 0x26, 0x01)) {
    spi_reqData(1, &create);
    spi_reqData(2, &commandId);
    spi_reqData(8, &destination);
    spi_reqEnd(TRUE);
    return 1;
  }
  return 0;
}

void ccai_r_zb_bind_device() {
  nwk_bind_deviceRsp();
}

void ccai_p_zb_bind_confirm() {
  nwk_bind_deviceConfirm(spi_buf);
}

UInt8 ccai_s_zb_allow_bind(UInt8 timeout) {
  if (spi_reqBegin(1, 0x26, 0x02)) {
    spi_reqData(1, &timeout);
    spi_reqEnd(TRUE);
    return 1;
  }
  return 0;
}

void ccai_r_zb_allow_bind() {
  nwk_allow_bindRsp();
}

void ccai_p_zb_allow_bind_confirm() {
  nwk_allow_bindConfirm(spi_buf);
}

UInt8 ccai_s_zb_send_data_request(UInt16 destination, UInt16 commandId,
    UInt8 handle, UInt8 ack, UInt8 radius, UInt8 len, void *pBuf) {
  if (len > 84) {
    return 0;
  }
  if (spi_reqBegin(8 + len, 0x26, 0x03)) {
    spi_reqData(2, &destination);
    spi_reqData(2, &commandId);
    spi_reqData(1, &handle);
    spi_reqData(1, &ack);
    spi_reqData(1, &radius);
    spi_reqData(1, &len);
    spi_reqData(len, pBuf);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

UInt8 ccai_s_zb_send_data_request_begin(UInt16 destination, UInt16 commandId,
    UInt8 handle, UInt8 ack, UInt8 radius, UInt8 len) {
  if (len > 84) {
    return 0;
  }
  if (spi_reqBegin(8 + len, 0x26, 0x03)) {
    spi_reqData(2, &destination);
    spi_reqData(2, &commandId);
    spi_reqData(1, &handle);
    spi_reqData(1, &ack);
    spi_reqData(1, &radius);
    spi_reqData(1, &len);
    return 1;
  }
  return 0;
}

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

void ccai_s_zb_send_data_request_end(UInt8 forwardToSerial) {
  spi_reqEnd(forwardToSerial);
}

void ccai_r_zb_send_data_request() {

}

void ccai_p_zb_send_data_confirm() {
  nwk_send_dataConfirm(spi_buf[3], spi_buf[4]);
}

void ccai_p_zb_receive_data_indication() {
  // Data received from remote device
  nwk_rcv(spi_buf);
}

UInt8 ccai_s_zb_get_device_info(UInt8 param) {
  if (spi_reqBegin(1, 0x26, 0x06)) {
    spi_reqData(1, &param);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_zb_get_device_info() {
  nwk_getDeviceInfoRsp(spi_buf[3], &spi_buf[4]);
}

UInt8 ccai_s_zb_find_device_request(uint64_t searchKey) {
  if (spi_reqBegin(8, 0x26, 0x07)) {
    spi_reqData(8, &searchKey);
    spi_reqEnd(FALSE);
    return 1;
  }
  return 0;
}

void ccai_r_zb_find_device_request() {

}

void ccai_p_zb_find_device_confirm() {

}

UInt8 ccai_s_af_register() {
  return 0;
}

void ccai_r_af_register() {

}

UInt8 ccai_s_af_data_request() {
  return 0;
}

void ccai_r_af_data_request() {

}

void ccai_p_af_data_confirm() {

}

void ccai_p_af_incoming_msg() {

}

UInt8 ccai_s_zdo_nwk_addr_req() {
  return 0;
}

void ccai_r_zdo_nwk_addr_req() {

}

void ccai_p_zdo_nwk_addr_rsp() {

}

UInt8 ccai_s_zdo_ieee_addr_req() {
  return 0;
}

void ccai_r_zdo_ieee_addr_req() {

}

void ccai_p_zdo_ieee_addr_rsp() {

}

UInt8 ccai_s_zdo_node_desc_req() {
  return 0;
}

void ccai_r_zdo_node_desc_req() {

}

void ccai_p_zdo_node_desc_rsp() {

}

UInt8 ccai_s_zdo_simple_desc_req() {
  return 0;
}

void ccai_r_zdo_simple_desc_req() {

}

void ccai_p_zdo_simple_desc_rsp() {

}

UInt8 ccai_s_zdo_active_ep_req() {
  return 0;
}

void ccai_r_zdo_active_ep_req() {

}

void ccai_p_zdo_active_ep_rsp() {

}

UInt8 ccai_s_zdo_match_desc_req() {
  return 0;
}

void ccai_r_zdo_match_desc_req() {

}

void ccai_p_zdo_match_desc_rsp() {

}

void ccai_p_zdo_match_desc_rsp_sent() {

}

UInt8 ccai_s_zdo_user_desc_req() {
  return 0;
}

void ccai_r_zdo_user_desc_req() {

}

void ccai_p_zdo_user_desc_rsp() {

}

UInt8 ccai_s_zdo_user_desc_set() {
  return 0;
}

void ccai_r_zdo_user_desc_set() {

}

void ccai_p_zdo_user_desc_conf() {

}

UInt8 ccai_s_zdo_end_device_annce() {
  return 0;
}

void ccai_r_zdo_end_device_annce() {

}

void ccai_p_zdo_end_device_annce_ind() {

}

UInt8 ccai_s_zdo_end_device_bind_req() {
  return 0;
}

void ccai_r_zdo_end_device_bind_req() {

}

void ccai_p_zdo_end_device_bind_rsp() {

}

UInt8 ccai_s_zdo_bind_req() {
  return 0;
}

void ccai_r_zdo_bind_req() {

}

void ccai_p_zdo_bind_rsp() {

}

UInt8 ccai_s_zdo_unbind_req() {
  return 0;
}

void ccai_r_zdo_unbind_req() {

}

void ccai_p_zdo_unbind_rsp() {

}

UInt8 ccai_s_zdo_mgmt_lqi_req() {
  return 0;
}

void ccai_r_zdo_mgmt_lqi_req() {

}

void ccai_p_zdo_mgmt_lqi_rsp() {

}

UInt8 ccai_s_zdo_mgmt_leave_req() {
  return 0;
}

void ccai_r_zdo_mgmt_leave_req() {

}

void ccai_p_zdo_mgmt_leave_rsp() {

}

UInt8 ccai_s_zdo_mgmt_permit_join_req() {
  return 0;
}

void ccai_r_zdo_mgmt_permit_join_req() {

}

void ccai_p_zdo_mgmt_permit_join_rsp() {

}

void ccai_p_zdo_state_change_ind() {

}