Example #1
0
/**
 * @brief Function to send the vendor specific data request.
 *
 * @param PairingRef   The pairing reference of the device.
 * @param ProfileId    Profile-Id (ZRC or ZID)
 * @param VendorId     Vendor-id
 * @param nsduLength   length of the data
 * @param nsdu         The data pointer.
 * @param TxOptions    To fill in the control field
 */
bool vendor_data_request(uint8_t PairingRef, profile_id_t ProfileId,
                       uint16_t VendorId, uint8_t nsduLength, uint8_t *nsdu,
                       uint8_t TxOptions)
{
    /* Keep compiler happy */
    UNUSED(ProfileId);

    return nlde_data_request(PairingRef, PROFILE_ID_VENDOR_DATA, VendorId,
                             nsduLength, nsdu, TxOptions);
}
Example #2
0
bool vendor_data_request(uint8_t PairingRef, profile_id_t ProfileId,
                         uint16_t VendorId, uint8_t nsduLength, uint8_t *nsdu,
                         uint8_t TxOptions)
{
    /* Keep compiler happy */
    ProfileId = ProfileId;

    return nlde_data_request(PairingRef, PROFILE_ID_ZRC, VendorId,
                             nsduLength, nsdu, TxOptions,
                             1,
                             (FUNC_PTR)vendor_data_confirm
                            );
}
Example #3
0
void vendor_data_ind(uint8_t PairingRef, uint16_t VendorId,
                     uint8_t nsduLength, uint8_t *nsdu, uint8_t RxLinkQuality,
                     uint8_t RxFlags)
{
    /* Check if vendor id matches.
     * Handle here only vendor data from same vendor */
    uint16_t v_id = PGM_READ_WORD(&VendorIdentifier);
    uint8_t nsduHandle = 1;
    if ((VendorId == v_id) && (RxFlags & RX_FLAG_WITH_SEC)) {
        switch (nsdu[0]) { /* vendor-specific command id */
        case BATTERY_STATUS_REQ:
        {
            uint16_t voltage = get_batmon_voltage();
            nsdu[0] = BATTERY_STATUS_RESP;
            nsdu[1] = (uint8_t)voltage; /* LSB */
            nsdu[2] = (uint8_t)(voltage >> 8); /* MSB */
            nsduLength = 3;
        }
        break;

        case ALIVE_REQ: /* Alive request */
            vendor_app_alive_req();
            /* Send alive response */
            nsdu[0] = ALIVE_RESP;
            nsduLength = 1;
            break;

        case FW_VERSION_REQ:
        {
            /* Send alive response */
            nsdu[0] = FW_VERSION_RESP;
            nsdu[1] = FW_VERSION_MAJOR; /* major version number */
            nsdu[2] = FW_VERSION_MINOR; /* minor version number */
            nsdu[3] = FW_VERSION_REV; /* revision version number */
            nsduLength = 4;
        }
        break;

        case RX_ON_REQ:
        {
            uint32_t duration = 0;

            memcpy(&duration, &nsdu[1], 3);
            if (!nlme_rx_enable_request(duration,
                                        (FUNC_PTR)nlme_rx_enable_confirm
                                       )) {
                /*
                 * RX enable could not been added to the queue.
                 * Therefore do not send response message.
                 */
                return;
            }

            /* Send response */
            nsdu[0] = RX_ON_RESP;
            nsduLength = 1;
        }
        break;

        default:
        {
            /* Send response */
            nsdu[0] = FW_DATA_RESP;
            nsdu[1] = VD_NOT_SUPPORTED_ATTRIBUTE;
            nsduLength = 2;
        }
        break;
        }

        /* Transmit response message */

        nlde_data_request(PairingRef, PROFILE_ID_ZRC, VendorId,
                          nsduLength, nsdu,
                          TXO_UNICAST | TXO_DST_ADDR_NET | TXO_ACK_REQ | TXO_SEC_REQ | TXO_MULTI_CH | TXO_CH_NOT_SPEC | TXO_VEND_SPEC,
                          nsduHandle,
                          (FUNC_PTR)vendor_data_confirm
                         );
        /* Keep compiler happy */
        RxLinkQuality = RxLinkQuality;
        RxFlags = RxFlags;
    }
}
Example #4
0
void vendor_data_ind(uint8_t PairingRef, profile_id_t ProfileId, uint16_t VendorId,
                          uint8_t nsduLength, uint8_t *nsdu, uint8_t RxLinkQuality,
                          uint8_t RxFlags)
{
    /* Check if vendor id matches.
       Handle here only vendor data from same vendor */
    uint16_t v_id = PGM_READ_WORD(&VendorIdentifier);
    if ((VendorId == v_id) && (RxFlags & RX_FLAG_WITH_SEC))
    {
	switch (nsdu[0])    // vendor-specific command id
        {
          
#ifdef _DEBUG_INTERFACE_
        case 0x1B:  
          {
              int i;
              for (i = 0; i < nsduLength;) 
              {
                  RxHandler(nsdu[i++]); 
              }
             
               RX_index = 4;	// Next GetChar() will get the command id
          
              /* Call QDebug_Process */
              QDebug_ProcessCommands();
              return;
          }
          break;
          
#endif
          
#ifdef TFA_BAT_MON
            case BATTERY_STATUS_REQ:
                {
                    uint16_t voltage = tfa_get_batmon_voltage();
                    nsdu[0] = BATTERY_STATUS_RESP;
                    nsdu[1] = (uint8_t)voltage;    // LSB
                    nsdu[2] = (uint8_t)(voltage >> 8);    // MSB
                    nsduLength = 3;
                }
                break;
#endif
            case ALIVE_REQ:  /* Alive request */
                vendor_app_alive_req();
                /* Send alive response */
                nsdu[0] = ALIVE_RESP;
                nsduLength = 1;
                break;

            case FW_VERSION_REQ:
                {
                    /* Send alive response */
                    nsdu[0] = FW_VERSION_RESP;
                    nsdu[1] = FW_VERSION_MAJOR;    // major version number
                    nsdu[2] = FW_VERSION_MINOR;    // minor version number
                    nsdu[3] = FW_VERSION_REV;    // revision version number
                    nsduLength = 4;
                }
                break;

            case RX_ON_REQ:
                {
                    uint32_t duration = 0;

                    memcpy(&duration, &nsdu[1], 3);
                    if (!nlme_rx_enable_request(duration))
                    {
                        /*
                         * RX enable could not been added to the queue.
                         * Therefore do not send response message.
                         */
                        return;
                    }
                    /* Send response */
                    nsdu[0] = RX_ON_RESP;
                    nsduLength = 1;
                }
                break;

#ifdef FLASH_SUPPORT
            case FW_DATA_REQ:
                {
                    fw_data_frame_t *fw_frame;
                    vendor_status_t status = VD_SUCCESS;

                    fw_frame = (fw_data_frame_t *)nsdu;

                    /* Verify data chunk size */
                    uint8_t fw_data_size = nsduLength - 5;  // 5 = header len
                    if (fw_data_size > 64)
                    {
                        status = VD_UNSUPPORTED_SIZE;
                    }
                    else
                    {
                        /* Fill temporary page buffer */
                        uint16_t start_addr = (fw_frame->frame_cnt - 1) % 4;
                        flash_fill_page_buffer(start_addr * (SPM_PAGESIZE / 4), fw_data_size, &fw_frame->fw_data[0]);
                        /* Write flash page */
                        if ((fw_frame->frame_cnt % 4) == 0)
                        {
                            uint32_t page_start_addr;
                            page_start_addr = IMAGE_START_ADDR + ((uint32_t)SPM_PAGESIZE * ((fw_frame->frame_cnt / 4) - 1));
                            flash_program_page(page_start_addr);
                        }
                        else if (fw_frame->frame_cnt == fw_frame->total_num_frames)
                        {
                            uint32_t page_start_addr;
                            page_start_addr = IMAGE_START_ADDR + ((uint32_t)SPM_PAGESIZE * (fw_frame->frame_cnt / 4));
                            flash_program_page(page_start_addr);
                        }
                    }
                    /* Send response */
                    nsdu[0] = FW_DATA_RESP;
                    nsdu[1] = status;
                    nsduLength = 2;
                }
                break;
#endif  /* #ifdef FLASH_SUPPORT */

#ifdef FLASH_SUPPORT
            case FW_SWAP_REQ:
                flash_swap(IMAGE_START_ADDR, IMAGE_SIZE);
                /* Do not send response message */
                return;
#endif  /* #ifdef FLASH_SUPPORT */

            default:
                {
                    /* Send response */
                    nsdu[0] = FW_DATA_RESP;
                    nsdu[1] = VD_NOT_SUPPORTED_ATTRIBUTE;
                    nsduLength = 2;
                }
                break;
        }

        /* Transmit response message */
        nlde_data_request(PairingRef, PROFILE_ID_VENDOR_DATA, VendorId,
                        nsduLength, nsdu,
                        TXO_UNICAST | TXO_DST_ADDR_NET | TXO_ACK_REQ | TXO_SEC_REQ | TXO_MULTI_CH | TXO_CH_NOT_SPEC | TXO_VEND_SPEC);

        /* Keep compiler happy */
        UNUSED(ProfileId);
        UNUSED(RxLinkQuality);
        UNUSED(RxFlags);
    }
}
Example #5
0
static inline void handle_incoming_msg(void)
{
	bool ret_val;

	switch (sio_rx_buf[1]) { /* message type */
	case NLDE_DATA_REQUEST:

		/* Attention: The TxOption field is moved before the nsduLength
		 * field! */
		ret_val = nlde_data_request(sio_rx_buf[2],
				(profile_id_t)sio_rx_buf[3],
				((uint16_t)sio_rx_buf[4] |
				((uint16_t)sio_rx_buf[5] << 8)),                                       /*
		                                                                                        *
		                                                                                        *
		                                                                                        *VendorId
		                                                                                        **/
				sio_rx_buf[7],             /* nsduLength */
				&sio_rx_buf[8],
				sio_rx_buf[6],            /* TxOptions */
				1,
				(FUNC_PTR)nlde_data_confirm
				);
		break;

#if (defined RF4CE_TARGET) || (defined RF4CE_PLATFORM)
	case NLME_AUTO_DISCOVERY_REQUEST:
	{
		dev_type_t RecDevTypeList[DEVICE_TYPE_LIST_SIZE];
		profile_id_t RecProfileIdList[PROFILE_ID_LIST_SIZE];
		uint32_t AutoDiscDuration;

		for (uint8_t i = 0; i < DEVICE_TYPE_LIST_SIZE; i++) {
			RecDevTypeList[i] = (dev_type_t)sio_rx_buf[3 + i];
		}
		for (uint8_t i = 0; i < PROFILE_ID_LIST_SIZE; i++) {
			RecProfileIdList[i] = (profile_id_t)sio_rx_buf[6 + i];
		}
		MEMCPY_ENDIAN(&AutoDiscDuration, &sio_rx_buf[13],
				sizeof(uint32_t));

		ret_val = nlme_auto_discovery_request(sio_rx_buf[2], /*
			                                              *
			                                              *
			                                              *RecAppCapabilities
			                                              **/
				RecDevTypeList,                      /*
			                                              *
			                                              *(dev_type_t
			                                              *
			                                              ***)&sio_rx_buf[3],
			                                              **/
				RecProfileIdList,                      /*
			                                                *
			                                                *(profile_id_t
			                                                *
			                                                ***)&sio_rx_buf[3
			                                                * + 3],
			                                                **/
				AutoDiscDuration,                     /*
			                                               *
			                                               **(uint32_t
			                                               *
			                                               ***)&sio_rx_buf[3
			                                               * + 3 +
			                                               * 7]); */
				(FUNC_PTR)nlme_auto_discovery_confirm
				);
	}
	break;
#endif
	case NLME_DISCOVERY_REQUEST:

	{
#if (UC3)
		uint16_t PANId
			= ((uint16_t)sio_rx_buf[2] <<
				8) | (uint16_t)sio_rx_buf[3];
		uint16_t NwkAddr
			= ((uint16_t)sio_rx_buf[4] <<
				8) | (uint16_t)sio_rx_buf[5];
#else
		uint16_t PANId = (uint16_t)sio_rx_buf[2] |
				((uint16_t)sio_rx_buf[3] << 8);
		uint16_t NwkAddr = (uint16_t)sio_rx_buf[4] |
				((uint16_t)sio_rx_buf[5] << 8);
#endif
		dev_type_t dev_type_list[DEVICE_TYPE_LIST_SIZE];
		for (uint8_t i = 0; i < DEVICE_TYPE_LIST_SIZE; i++) {
			dev_type_list[i] = (dev_type_t)sio_rx_buf[7 + i];
		}
		profile_id_t org_profile_id_list[PROFILE_ID_LIST_SIZE];
		for (uint8_t i = 0; i < PROFILE_ID_LIST_SIZE; i++) {
			org_profile_id_list[i]
				= (profile_id_t)sio_rx_buf[10 +
					i];
		}
		profile_id_t disc_profile_id_list[PROFILE_ID_LIST_SIZE];
		for (uint8_t i = 0; i < PROFILE_ID_LIST_SIZE; i++) {
			disc_profile_id_list[i]
				= (profile_id_t)sio_rx_buf[19 +
					i];
		}
		uint32_t disc_duration;
		MEMCPY_ENDIAN(&disc_duration, &sio_rx_buf[26],
				sizeof(uint32_t));

		ret_val = nlme_discovery_request(PANId, NwkAddr,
				sio_rx_buf[6],                    /* uint8_t
			                                           *
			                                           *
			                                           *OrgAppCapabilities,
			                                           **/
				dev_type_list,                   /* uint8_t
			                                          *
			                                          *
			                                          *OrgDevTypeList[DEVICE_TYPE_LIST_SIZE],
			                                          **/
				org_profile_id_list,                   /*
			                                                *
			                                                *uint8_t
			                                                *
			                                                *
			                                                *OrgProfileIdList[DEVICE_TYPE_LIST_SIZE],
			                                                **/
				(dev_type_t)sio_rx_buf[7 + 3 /*num_dev_types*/ +
				7 /*num_profiles*/],                                                                    /*
			                                                                                                 *
			                                                                                                 *uint8_t
			                                                                                                 *
			                                                                                                 *
			                                                                                                 *SearchDevType,
			                                                                                                 **/
				sio_rx_buf[8 + 3 + 7],                     /*
			                                                    *
			                                                    *uint8_t
			                                                    *
			                                                    *
			                                                    *DiscProfileIdListSize,
			                                                    **/
				disc_profile_id_list,                    /*
			                                                  *
			                                                  *uint8_t
			                                                  *
			                                                  *
			                                                  *DiscProfileIdList[PROFILE_ID_LIST_SIZE],
			                                                  **/
				disc_duration,                       /* uint32_t
			                                              *
			                                              *
			                                              *DiscDuration);
			                                              **/
				(FUNC_PTR)nlme_discovery_confirm
				);
	}

	break;

#if (defined RF4CE_TARGET) || (defined RF4CE_PLATFORM)
	case NLME_DISCOVERY_RESPONSE:
	{
		nwk_enum_t Status = (nwk_enum_t)sio_rx_buf[2];
		uint64_t DstIEEEAddr;
		memcpy(&DstIEEEAddr, &sio_rx_buf[3], 8);
		dev_type_t dev_type_list[DEVICE_TYPE_LIST_SIZE];
		for (uint8_t i = 0; i < DEVICE_TYPE_LIST_SIZE; i++) {
			dev_type_list[i] = (dev_type_t)sio_rx_buf[12 + i];
		}
		profile_id_t profile_id_list[PROFILE_ID_LIST_SIZE];
		for (uint8_t i = 0; i < PROFILE_ID_LIST_SIZE; i++) {
			profile_id_list[i] = (profile_id_t)sio_rx_buf[15 + i];
		}
		ret_val = nlme_discovery_response(Status,    /* nwk_enum_t
			                                      * Status, */
				DstIEEEAddr,                    /* uint64_t
			                                         * DstIEEEAddr,
			                                         **/
				sio_rx_buf[11],                         /*
			                                                 *
			                                                 *uint8_t
			                                                 *
			                                                 *
			                                                 *RecAppCapabilities,
			                                                 **/
				dev_type_list,                    /* uint8_t
			                                           *
			                                           *
			                                           *RecDevTypeList[DEVICE_TYPE_LIST_SIZE],
			                                           **/
				profile_id_list,                    /* uint8_t
			                                             *
			                                             *
			                                             *RecProfileIdList[PROFILE_ID_LIST_SIZE],
			                                             **/
				sio_rx_buf[12 + 3 + 7]);                         /*
			                                                          *
			                                                          *uint8_t
			                                                          *
			                                                          *
			                                                          *DiscReqLQI);
			                                                          **/
	}

	break;
#endif
#if (defined RF4CE_TARGET) || (defined RF4CE_PLATFORM)
	case NLME_PAIR_RESPONSE:
	{
		nwk_enum_t Status = (nwk_enum_t)sio_rx_buf[2];
#if (UC3)
		uint16_t DstPANId
			= ((uint16_t)sio_rx_buf[3] <<
				8) | (uint16_t)sio_rx_buf[4];
#else
		uint16_t DstPANId = (uint16_t)sio_rx_buf[3] |
				((uint16_t)sio_rx_buf[4] << 8);
#endif
		uint64_t DstIEEEAddr;
		memcpy(&DstIEEEAddr, &sio_rx_buf[5], 8);
		dev_type_t dev_type_list[DEVICE_TYPE_LIST_SIZE];
		for (uint8_t i = 0; i < DEVICE_TYPE_LIST_SIZE; i++) {
			dev_type_list[i] = (dev_type_t)sio_rx_buf[14 + i];
		}
		profile_id_t profile_id_list[PROFILE_ID_LIST_SIZE];
		for (uint8_t i = 0; i < PROFILE_ID_LIST_SIZE; i++) {
			profile_id_list[i] = (profile_id_t)sio_rx_buf[17 + i];
		}
		ret_val = nlme_pair_response(Status, /* nwk_enum_t Status, */
				DstPANId,                /* uint16_t DstPANId,
			                                 **/
				DstIEEEAddr,                /* uint64_t
			                                     * DstIEEEAddr, */
				sio_rx_buf[13],                         /*
			                                                 *
			                                                 *uint8_t
			                                                 *
			                                                 *
			                                                 *RecAppCapabilities,
			                                                 **/
				dev_type_list,                /* uint8_t
			                                       *
			                                       *
			                                       *RecDevTypeList[DEVICE_TYPE_LIST_SIZE],
			                                       **/
				profile_id_list,                /* uint8_t
			                                         *
			                                         *
			                                         *RecProfileIdList[PROFILE_ID_LIST_SIZE],
			                                         **/
				sio_rx_buf[14 + 3 + 7]);                 /*
			                                                  *
			                                                  *uint8_t
			                                                  *
			                                                  *
			                                                  *ProvPairingRef);
			                                                  **/
	}
	break;
#endif

	case NLME_RESET_REQUEST:
		ret_val = nlme_reset_request(sio_rx_buf[2],
				(FUNC_PTR)nlme_reset_confirm
				);
		break;

	case NLME_PAIR_REQUEST:
	{
#if (UC3)
		uint16_t DstPANId
			= ((uint16_t)sio_rx_buf[3] <<
				8) | (uint16_t)sio_rx_buf[4];
#else
		uint16_t DstPANId = (uint16_t)sio_rx_buf[3]  |
				((uint16_t)sio_rx_buf[4] << 8);
#endif
		uint64_t DstIEEEAddr;
		memcpy(&DstIEEEAddr, &sio_rx_buf[5], 8);
		dev_type_t dev_type_list[DEVICE_TYPE_LIST_SIZE];
		for (uint8_t i = 0; i < DEVICE_TYPE_LIST_SIZE; i++) {
			dev_type_list[i] = (dev_type_t)sio_rx_buf[14 + i];
		}
		profile_id_t profile_id_list[PROFILE_ID_LIST_SIZE];
		for (uint8_t i = 0; i < PROFILE_ID_LIST_SIZE; i++) {
			profile_id_list[i] = (profile_id_t)sio_rx_buf[17 + i];
		}
		ret_val = nlme_pair_request(sio_rx_buf[2],  /* uint8_t
			                                     * LogicalChannel,
			                                     **/
				DstPANId,                /* uint16_t DstPANId,
			                                 **/
				DstIEEEAddr,                /* uint64_t
			                                     * DstIEEEAddr, */
				sio_rx_buf[13],             /* uint8_t
			                                     *
			                                     *
			                                     *OrgAppCapabilities,
			                                     **/
				dev_type_list,                /* uint8_t
			                                       *
			                                       *
			                                       *OrgDevTypeList[DEVICE_TYPE_LIST_SIZE],
			                                       **/
				profile_id_list,                /* uint8_t
			                                         *
			                                         *
			                                         *OrgProfileIdList[PROFILE_ID_LIST_SIZE],
			                                         **/
				sio_rx_buf[14 + 3 + 7],            /* uint8_t
			                                            *
			                                            *
			                                            *KeyExTransferCount);
			                                            **/
				(FUNC_PTR)nlme_pair_confirm
				);
	}

	break;

#if (NWK_GET == 1)
	case NLME_GET_REQUEST:
		ret_val = nlme_get_request((nib_attribute_t)sio_rx_buf[2],
				sio_rx_buf[3],
				(FUNC_PTR)nlme_get_confirm
				);
		break;
#endif

	case NLME_RX_ENABLE_REQUEST:
	{
		uint32_t rx_on_duration;
		MEMCPY_ENDIAN(&rx_on_duration, &sio_rx_buf[2],
				sizeof(uint32_t));
		ret_val = nlme_rx_enable_request(rx_on_duration,
				(FUNC_PTR)nlme_rx_enable_confirm
				);
	}
	break;

#if (NWK_SET == 1)
	case NLME_SET_REQUEST:
		ret_val = nlme_set_request((nib_attribute_t)sio_rx_buf[2],
				sio_rx_buf[3], &sio_rx_buf[5],
				(FUNC_PTR)nlme_set_confirm
				);
		break;
#endif
	case NLME_START_REQUEST:
		ret_val = nlme_start_request(
				(FUNC_PTR)nlme_start_confirm
				);
		break;

#if (NWK_UNPAIR_REQ_CONF == 1)
	case NLME_UNPAIR_REQUEST:
		ret_val = nlme_unpair_request(sio_rx_buf[2],
				(FUNC_PTR)nlme_unpair_confirm
				);
		break;
#endif
#if (NWK_UNPAIR_IND_RESP == 1)
	case NLME_UNPAIR_RESPONSE:
		ret_val = nlme_unpair_response(sio_rx_buf[2]);
		break;
#endif
#if ((NWK_UPDATE_KEY == 1) && (defined RF4CE_SECURITY)) || \
		(defined RF4CE_PLATFORM)
	case NLME_UPDATE_KEY_REQUEST:
		ret_val = nlme_update_key_request(sio_rx_buf[2], &sio_rx_buf[3],
				(FUNC_PTR)nlme_update_key_confirm
				);
		break;
#endif
#if (defined CHANNEL_AGILITY) || (defined RF4CE_PLATFORM)
	case NWK_CH_AGILITY_REQUEST:
		ret_val
			= nwk_ch_agility_request(
				(nwk_agility_mode_t)sio_rx_buf[2],
				(FUNC_PTR)nwk_ch_agility_confirm
				);
		break;
#endif

#ifdef PBP_ORG
	case PBP_ORG_PAIR_REQUEST:
	{
		dev_type_t OrgDevTypeList[DEVICE_TYPE_LIST_SIZE];
		profile_id_t OrgProfileIdList[PROFILE_ID_LIST_SIZE];
		profile_id_t DiscProfileIdList[PROFILE_ID_LIST_SIZE];

		for (uint8_t i = 0; i < DEVICE_TYPE_LIST_SIZE; i++) {
			OrgDevTypeList[i] = (dev_type_t)sio_rx_buf[3 + i];
		}
		for (uint8_t i = 0; i < PROFILE_ID_LIST_SIZE; i++) {
			OrgProfileIdList[i] = (profile_id_t)sio_rx_buf[6 + i];
		}
		for (uint8_t i = 0; i < PROFILE_ID_LIST_SIZE; i++) {
			DiscProfileIdList[i]
				= (profile_id_t)sio_rx_buf[13 + 2 +
					i];
		}

		ret_val = pbp_org_pair_request(sio_rx_buf[2], /*
			                                       *
			                                       *
			                                       *OrgAppCapabilities
			                                       **/
				OrgDevTypeList,                    /*
			                                            *
			                                            *OrgDevTypeList
			                                            **/
				OrgProfileIdList,                  /*
			                                            *
			                                            *OrgProfileIdList
			                                            **/
				(dev_type_t)sio_rx_buf[13],                    /*
			                                                        *
			                                                        *
			                                                        *SearchDevType
			                                                        **/
				sio_rx_buf[14],                    /*
			                                            *
			                                            *DiscProfileIdListSize
			                                            **/
				DiscProfileIdList,              /*
			                                         *
			                                         *DiscProfileIdList,
			                                         **/
				(FUNC_PTR)pbp_org_pair_confirm
				);
	}
	break;
#endif

#ifdef PBP_REC
	case PBP_REC_PAIR_REQUEST:
	{
		dev_type_t RecDevTypeList[DEVICE_TYPE_LIST_SIZE];
		profile_id_t RecProfileIdList[PROFILE_ID_LIST_SIZE];

		for (uint8_t i = 0; i < DEVICE_TYPE_LIST_SIZE; i++) {
			RecDevTypeList[i] = (dev_type_t)sio_rx_buf[3 + i];
		}
		for (uint8_t i = 0; i < PROFILE_ID_LIST_SIZE; i++) {
			RecProfileIdList[i] = (profile_id_t)sio_rx_buf[6 + i];
		}
		ret_val = pbp_rec_pair_request(sio_rx_buf[2], /*
			                                       *
			                                       *
			                                       *RecAppCapabilities
			                                       **/
				RecDevTypeList,               /* (dev_type_t
			                                       *
			                                       ***)&sio_rx_buf[3],
			                                       **/
				RecProfileIdList,              /* (profile_id_t
			                                        *
			                                        ***)&sio_rx_buf[3
			                                        * + 3], */
				(FUNC_PTR)pbp_rec_pair_confirm
				);
	}
	break;
#endif

#ifdef ZRC_PROFILE
#if ((!defined RF4CE_TARGET) || (defined RF4CE_PLATFORM))
	case ZRC_CMD_REQUEST:
		ret_val = zrc_cmd_request(sio_rx_buf[2], /* pair_ref */
				(uint16_t)sio_rx_buf[3] |
				((uint16_t)sio_rx_buf[4] << 8),                                 /*uint16_t
		                                                                                 *
		                                                                                 *
		                                                                                 *VendorId,*/
				(zrc_cmd_code_t)sio_rx_buf[5],        /*
		                                                       *
		                                                       *
		                                                       *zrc_cmd_code_t
		                                                       *
		                                                       *
		                                                       *cerc_cmd_code,
		                                                       **/
				sio_rx_buf[7],       /* uint8_t cmd_length,*/
				&sio_rx_buf[8],       /*uint8_t *cmd_payload, */
				sio_rx_buf[6],      /* uint8_t tx_options */
				(FUNC_PTR)zrc_cmd_confirm
				);
		break;
#endif
#endif  /* #ifdef ZRC_PROFILE */

#ifdef ZRC_CMD_DISCOVERY
	case ZRC_CMD_DISCOVERY_REQUEST:
		ret_val = zrc_cmd_disc_request(sio_rx_buf[2], /* PairingRef */
				(FUNC_PTR)zrc_cmd_disc_confirm
				);
		break;
#endif

#ifdef ZRC_CMD_DISCOVERY
	case ZRC_CMD_DISCOVERY_RESPONSE:
		ret_val = zrc_cmd_disc_response(sio_rx_buf[2], &sio_rx_buf[3]);
		break;
#endif

#ifdef VENDOR_DATA
	case VENDOR_DATA_REQUEST:
		ret_val = nlde_data_request(sio_rx_buf[2], /*uint8_t
		                                            * PairingRef,*/
				PROFILE_ID_ZRC,
				(uint16_t)sio_rx_buf[4] |
				((uint16_t)sio_rx_buf[5] << 8),                                   /*uint16_t
		                                                                                   *
		                                                                                   *
		                                                                                   *VendorId,*/
				sio_rx_buf[7],         /*uint8_t nsduLength,*/
				&sio_rx_buf[8],         /*uint8_t *nsdu,*/
				sio_rx_buf[6],        /*uint8_t TxOptions*/
				1,
				(FUNC_PTR)vendor_data_confirm
				);
		break;
#endif
	default:
	{
	}
		Assert("???" == 0);
		break;
	}

	if (ret_val == false) {
		Assert("Buffer is not available (Test harness)" == 0);
	}
}