自学教程：C++ BUILD_UINT16函数代码示例

/********************************************************************* * @fn          proxReporter_ReadAttrCB * * @brief       Read an attribute. * * @param        * * @return      Success or Failure */static uint8 proxReporter_ReadAttrCB( uint16 connHandle, gattAttribute_t *pAttr,                                     uint8 *pValue, uint8 *pLen, uint16 offset, uint8 maxLen ){  uint16 uuid;  bStatus_t status = SUCCESS;  // Make sure it's not a blob operation  if ( offset > 0 )  {    return ( ATT_ERR_ATTR_NOT_LONG );  }    if ( pAttr->type.len == ATT_BT_UUID_SIZE )  {    // 16-bit UUID    uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);        switch ( uuid )    {      // No need for "GATT_SERVICE_UUID" or "GATT_CLIENT_CHAR_CFG_UUID" cases;      // gattserverapp handles those types for reads         case PROXIMITY_ALERT_LEVEL_UUID:      case PROXIMITY_TX_PWR_LEVEL_UUID:        *pLen = 1;        pValue[0] = *pAttr->pValue;        break;            default:        // Should never get here!        *pLen = 0;        status = ATT_ERR_ATTR_NOT_FOUND;        break;    }  }  else  {    //128-bit UUID    *pLen = 0;    status = ATT_ERR_INVALID_HANDLE;  }  return ( status );}

/********************************************************************* * @fn      zclPartition_ConvertOtaToNative_TransferPartitionedFrame * * @brief   Helper function used to process an incoming TransferPartionFrame *          command. * * @param   pCmd   - (output) the converted command * @param   buf    - pointer to incoming frame (just after ZCL header) * @param   buflen - length of buffer (ZCL payload) * * @return  ZStatus_t */ZStatus_t zclPartition_ConvertOtaToNative_TransferPartitionedFrame( zclCmdTransferPartitionedFrame_t *pCmd, uint8 *buf, uint8 buflen ){  uint8 offset;  pCmd->fragmentationOptions = buf[0];  if ( pCmd->fragmentationOptions & ZCL_PARTITION_OPTIONS_INDICATOR_16BIT )  {    pCmd->partitionIndicator = BUILD_UINT16( buf[1], buf[2] );    offset = 3;  }  else  {    pCmd->partitionIndicator = buf[1];    offset = 2;  }  pCmd->frameLen = buf[offset++];  pCmd->pFrame = &buf[offset];  return ( ZSuccess );}

/********************************************************************* * @fn      temp_WriteAttrCB * * @brief   Validate attribute data prior to a write operation * * @param   connHandle - connection message was received on * @param   pAttr - pointer to attribute * @param   pValue - pointer to data to be written * @param   len - length of data * @param   offset - offset of the first octet to be written * @param   complete - whether this is the last packet * @param   oper - whether to validate and/or write attribute value   * * @return  Success or Failure */static bStatus_t temp_WriteAttrCB( uint16 connHandle, gattAttribute_t *pAttr,        uint8 *pValue, uint8 len, uint16 offset ){  bStatus_t status = ATT_ERR_ATTR_NOT_FOUND;  if ( pAttr->type.len == ATT_BT_UUID_SIZE )  {    uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);    switch ( uuid )    {      case GATT_CLIENT_CHAR_CFG_UUID:        status = GATTServApp_ProcessCCCWriteReq( connHandle, pAttr, pValue, len,                                                 offset, GATT_CLIENT_CFG_NOTIFY );        if (GATTServApp_ReadCharCfg(connHandle, valueConfigCoordinates) & GATT_CLIENT_CFG_NOTIFY) {          iDoTurnOnTemp();        } else {          iDoTurnOffTemp();        }        break;                    case TEMP_UUID:        if (len != sizeof(struct temp_ts)) {          return ATT_ERR_INVALID_VALUE_SIZE;        }        recorder_set_read_base_ts((struct calendar *)(pValue + sizeof(struct temp)));        status = SUCCESS;        break;              case TEMP_TIME_UUID:        if (len != sizeof(struct calendar)) {          return ATT_ERR_INVALID_VALUE_SIZE;        }        recorder_set_calendar_time((struct calendar *)pValue);        status = SUCCESS;        break;      default:        status = ATT_ERR_ATTR_NOT_FOUND;    }  }  return ( status );}

/********************************************************************* * @fn          battReadAttrCB * * @brief       Read an attribute. * * @param       connHandle - connection message was received on * @param       pAttr - pointer to attribute * @param       pValue - pointer to data to be read * @param       pLen - length of data to be read * @param       offset - offset of the first octet to be read * @param       method - type of read message * * @return      SUCCESS, blePending or Failure */static bStatus_t battReadAttrCB( uint16 connHandle, gattAttribute_t *pAttr,                                 uint8 *pValue, uint8 *pLen, uint16 offset,                                 uint8 maxLen, uint8 method ){  bStatus_t status = SUCCESS;  // Make sure it's not a blob operation (no attributes in the profile are long)  if ( offset > 0 )  {    return ( ATT_ERR_ATTR_NOT_LONG );  }  uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1] );  // Measure battery level if reading level  if ( uuid == BATT_LEVEL_UUID )  {    uint8 level;    level = battMeasure();    // If level has gone down    if (level < battLevel)    {      // Update level      battLevel = level;    }    *pLen = 1;    pValue[0] = battLevel;  }  else if ( uuid == GATT_REPORT_REF_UUID )  {    *pLen = HID_REPORT_REF_LEN;    osal_memcpy( pValue, pAttr->pValue, HID_REPORT_REF_LEN );  }  else  {    status = ATT_ERR_ATTR_NOT_FOUND;  }  return ( status );}

/********************************************************************* * @fn          sk_ReadAttrCB * * @brief       Read an attribute. * * @param       connHandle - connection message was received on * @param       pAttr - pointer to attribute * @param       pValue - pointer to data to be read * @param       pLen - length of data to be read * @param       offset - offset of the first octet to be read * @param       maxLen - maximum length of data to be read * * @return      Success or Failure */static uint8 sk_ReadAttrCB( uint16 connHandle, gattAttribute_t *pAttr,                             uint8 *pValue, uint8 *pLen, uint16 offset, uint8 maxLen ){  bStatus_t status = SUCCESS;   // Make sure it's not a blob operation (no attributes in the profile are long  if ( offset > 0 )  {    return ( ATT_ERR_ATTR_NOT_LONG );  }   if ( pAttr->type.len == ATT_BT_UUID_SIZE )  {    // 16-bit UUID    uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);    switch ( uuid )    {      // No need for "GATT_SERVICE_UUID" or "GATT_CLIENT_CHAR_CFG_UUID" cases;      // gattserverapp handles this type for reads      // simple keys characteristic does not have read permissions, but because it      //   can be sent as a notification, it must be included here      case SK_KEYPRESSED_UUID:        *pLen = 1;        pValue[0] = *pAttr->pValue;        break;      default:        // Should never get here!        *pLen = 0;        status = ATT_ERR_ATTR_NOT_FOUND;        break;    }  }  else  {    // 128-bit UUID    *pLen = 0;    status = ATT_ERR_INVALID_HANDLE;  }  return ( status );}

void get_dev_info( uint8 *buf ){  // 0x05 mac short_addr type  // 1 8 2 1 == 12 bytes  // 0 1 2 3 4 5 6 7 8 9 10 11  uint16 short_addr;  uint8 type;  uint8 ieeeAddr[9];  uint8 i;    type = buf[11];  short_addr = BUILD_UINT16( buf[9], buf[10]);    for(i=0;i<8;i++)  {    ieeeAddr[i] = buf[i+1];  }}

/*************************************************************************************************** * @fn          MT_UtilSrcMatchCheckSrcAddr * * @brief      Check if a short or extended address is in the source address table. * * @param      pBuf - Buffer contains the data * * @return     void ***************************************************************************************************/void MT_UtilSrcMatchCheckSrcAddr (uint8 *pBuf){  uint8 cmdId;  uint8 retArray[2];  /* Parse header */  cmdId = pBuf[MT_RPC_POS_CMD1];  pBuf += MT_RPC_FRAME_HDR_SZ;#if 0  /* Unsupported  */  uint16 panID;  zAddrType_t devAddr;  /* Address mode */  devAddr.addrMode = *pBuf++;  /* Address based on the address mode */  MT_UtilSpi2Addr( &devAddr, pBuf);  pBuf += Z_EXTADDR_LEN;  /* PanID */  panID = BUILD_UINT16( pBuf[0] , pBuf[1] );  /* Call the routine */  retArray[1] =  ZMacSrcMatchCheckSrcAddr (&devAddr, panID);    /* Return failure if the index is invalid */  if (retArray[1] == ZMacSrcMatchInvalidIndex )  {    retArray[0] = ZFailure;  }  else  {    retArray[0] = ZSuccess;  }#else  retArray[0] = ZMacUnsupported;  retArray[1] = ZMacSrcMatchInvalidIndex;#endif  /* Build and send back the response */  MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_UTIL), cmdId, 2, retArray );}

void SampleApp_MessageMSGCB( afIncomingMSGPacket_t *pkt ){  uint16 flashTime;    switch ( pkt->clusterId )  {    case SAMPLEAPP_PERIODIC_CLUSTERID:      f=pkt->cmd.Data[0];//检测其panid,记录在参数f里面。      if(State_data[f]=='0'){State_data[f]='1';}//将其状态置为在线//      HalUARTWrite(0, State_data,3);     //十六进制发给PC机  //      HalUARTWrite(0, "/n",1);      break;    case SAMPLEAPP_FLASH_CLUSTERID:      flashTime = BUILD_UINT16(pkt->cmd.Data[1], pkt->cmd.Data[2] );      HalLedBlink( HAL_LED_4, 4, 50, (flashTime / 4) );      break;  }}

/*************************************************************************************************** * @fn      MT_AfInterPanCtl * * @brief   Process the AF Inter Pan control command. * * @param   pBuf - pointer to the received buffer * * @return  none ***************************************************************************************************/static void MT_AfInterPanCtl(uint8 *pBuf){  uint8 cmd, rtrn;  uint16 panId;  endPointDesc_t *pEP;    cmd = pBuf[MT_RPC_POS_CMD1];  pBuf += MT_RPC_FRAME_HDR_SZ;  switch (*pBuf++)  // Inter-pan request parameter.  {  case InterPanClr:    rtrn = StubAPS_SetIntraPanChannel();           // Switch channel back to the NIB channel.    break;  case InterPanSet:    rtrn = StubAPS_SetInterPanChannel(*pBuf);      // Set channel for inter-pan communication.    break;  case InterPanReg:    if ((pEP = afFindEndPointDesc(*pBuf)))    {      StubAPS_RegisterApp(pEP);      rtrn = SUCCESS;    }    else    {      rtrn = FAILURE;    }    break;  case InterPanChk:    panId = BUILD_UINT16(pBuf[0], pBuf[1]);    rtrn = (StubAPS_InterPan(panId, pBuf[2])) ? ZSuccess : ZFailure;    break;  default:    rtrn = afStatus_INVALID_PARAMETER;    break;  }  MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_AF), cmd, 1, &rtrn);}

/********************************************************************* * @fn      GATTServApp_ProcessCCCWriteReq * * @brief   Process the client characteristic configuration *          write request for a given client. * * @param   connHandle - connection message was received on * @param   pAttr - pointer to attribute * @param   pValue - pointer to data to be written * @param   len - length of data * @param   offset - offset of the first octet to be written * @param   validCfg - valid configuration * * @return  Success or Failure */bStatus_t GATTServApp_ProcessCCCWriteReq( uint16 connHandle, gattAttribute_t *pAttr,                                          uint8 *pValue, uint16 len, uint16 offset,                                          uint16 validCfg ){  bStatus_t status = SUCCESS;  // Validate the value  if ( offset == 0 )  {    if ( len == 2 )    {      uint16 value = BUILD_UINT16( pValue[0], pValue[1] );      // Validate characteristic configuration bit field      if ( ( value & ~validCfg ) == 0 ) // indicate and/or notify      {        // Write the value if it's changed        if ( GATTServApp_ReadCharCfg( connHandle,                                      GATT_CCC_TBL(pAttr->pValue) ) != value )        {          status = GATTServApp_WriteCharCfg( connHandle,                                             GATT_CCC_TBL(pAttr->pValue),                                             value );        }      }      else      {        status = ATT_ERR_INVALID_VALUE;      }    }    else    {      status = ATT_ERR_INVALID_VALUE_SIZE;    }  }  else  {    status = ATT_ERR_ATTR_NOT_LONG;  }  return ( status );}

/********************************************************************* * @fn          findMeTarget_ReadAttrCB * * @brief       Read an attribute. * * @param       connHandle - connection message was received on * @param       pAttr - pointer to attribute * @param       pValue - pointer to data to be read * @param       pLen - length of data to be read * @param       offset - offset of the first octet to be read * @param       maxLen - maximum length of data to be read * @param       method - type of read message  * * @return      SUCCESS, blePending or Failure */static bStatus_t findMeTarget_ReadAttrCB( uint16 connHandle, gattAttribute_t *pAttr,                                           uint8 *pValue, uint16 *pLen, uint16 offset,                                          uint16 maxLen, uint8 method ){  bStatus_t status = SUCCESS;    // Make sure it's not a blob operation (no attributes in the profile are long)  if ( offset > 0 )  {    return ( ATT_ERR_ATTR_NOT_LONG );  }   if ( pAttr->type.len == ATT_BT_UUID_SIZE )  {    // 16-bit UUID    uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);    switch ( uuid )    {      // No need for "GATT_PRIMARY_SERVICE_UUID" or "GATT_CHARACTER_UUID" cases;      // gattserverapp handles those types for reads      case ALERT_LEVEL_UUID:        *pLen = 1;        pValue[0] = *pAttr->pValue;        break;              default:        // Should never get here! (characteristics 3 and 4 do not have read permissions)        *pLen = 0;        status = ATT_ERR_ATTR_NOT_FOUND;        break;    }  }  else  {    // 128-bit UUID    *pLen = 0;    status = ATT_ERR_INVALID_HANDLE;  }  return ( status );}

/********************************************************************* * @fn          glucose_ReadAttrCB * * @brief       Read an attribute. * * @param       connHandle - connection message was received on * @param       pAttr - pointer to attribute * @param       pValue - pointer to data to be read * @param       pLen - length of data to be read * @param       offset - offset of the first octet to be read * @param       maxLen - maximum length of data to be read * * @return      Success or Failure */static uint8 glucose_ReadAttrCB( uint16 connHandle, gattAttribute_t *pAttr,                            uint8 *pValue, uint8 *pLen, uint16 offset, uint8 maxLen ){  bStatus_t status = SUCCESS;  // Require security for all characteristics  if ( linkDB_Encrypted( connHandle ) == FALSE )  {    return ATT_ERR_INSUFFICIENT_ENCRYPT;  }  // Make sure it's not a blob operation (no attributes in the profile are long)  if ( offset > 0 )  {    return ( ATT_ERR_ATTR_NOT_LONG );  }  if ( pAttr->type.len == ATT_BT_UUID_SIZE )  {    // 16-bit UUID    uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);    switch ( uuid )    {      // No need for "GATT_SERVICE_UUID" or "GATT_CLIENT_CHAR_CFG_UUID" cases;      // gattserverapp handles those types for reads      case GLUCOSE_FEATURE_UUID:        *pLen = 2;        pValue[0] = LO_UINT16( glucoseFeature );        pValue[1] = HI_UINT16( glucoseFeature );        break;      default:        // Should never get here! (characteristics 3 and 4 do not have read permissions)        *pLen = 0;        status = ATT_ERR_ATTR_NOT_FOUND;        break;    }  }  return ( status );}

/*************************************************************************************************** * @fn      MT_NlmeJoinRequest * * @brief   Join Request * * @param   pBuf - pointer to the received buffer * * @return  void ***************************************************************************************************/void MT_NlmeJoinRequest(uint8 *pBuf){  uint8 retValue = ZFailure;  uint8 dummyExPANID[Z_EXTADDR_LEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};  uint16 panID;  uint8 cmdId;  networkDesc_t *pNwkDesc;  /* parse header */  cmdId = pBuf[MT_RPC_POS_CMD1];  pBuf += MT_RPC_FRAME_HDR_SZ;  panID = BUILD_UINT16(pBuf[0], pBuf[1]);  if((pNwkDesc = nwk_getNetworkDesc(dummyExPANID,panID, pBuf[2])) != NULL )  {    if (pNwkDesc->chosenRouter == INVALID_NODE_ADDR )    {      retValue = ZNwkNotPermitted;    }    else    {      retValue = NLME_JoinRequest( dummyExPANID, panID, pBuf[2], pBuf[3],                                   pNwkDesc->chosenRouter, pNwkDesc->chosenRouterDepth );    }  }  else  {    retValue = ZNwkNotPermitted;  }  if ( pBuf[3] & CAPINFO_RCVR_ON_IDLE )  {    /* The receiver is on, turn network layer polling off. */    NLME_SetPollRate( 0 );    NLME_SetQueuedPollRate( 0 );    NLME_SetResponseRate( 0 );  }  /* Build and send back the response */  MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_NWK), cmdId, 1, &retValue);}

/********************************************************************* * @fn          bloodPressure_ReadAttrCB * * @brief       Read an attribute. * * @param       connHandle - connection message was received on * @param       pAttr - pointer to attribute * @param       pValue - pointer to data to be read * @param       pLen - length of data to be read * @param       offset - offset of the first octet to be read * @param       maxLen - maximum length of data to be read * * @return      Success or Failure */static uint8 bloodPressure_ReadAttrCB( uint16 connHandle, gattAttribute_t *pAttr,                             uint8 *pValue, uint8 *pLen, uint16 offset, uint8 maxLen ){  bStatus_t status = SUCCESS;  // If attribute permissions require authorization to read, return error  if ( gattPermitAuthorRead( pAttr->permissions ) )  {    // Insufficient authorization    return ( ATT_ERR_INSUFFICIENT_AUTHOR );  }    // Make sure it's not a blob operation (no attributes in the profile are long)  if ( offset > 0 )  {    return ( ATT_ERR_ATTR_NOT_LONG );  }   if ( pAttr->type.len == ATT_BT_UUID_SIZE )  {    // 16-bit UUID    uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);    switch ( uuid )    {      case BLOODPRESSURE_FEATURE_UUID:        {          *pLen = 2;          pValue[0] = 0;          pValue[1] = 0;          }        break;               default:        // Should never get here! (characteristics 3 and 4 do not have read permissions)        *pLen = 0;        status = ATT_ERR_ATTR_NOT_FOUND;        break;    }  }  return ( status );}

/********************************************************************* * @fn          bat_ReadAttrCB * * @brief       Read an attribute. * * * @return      Success or Failure */static uint8 bat_ReadAttrCB( uint16 connHandle, gattAttribute_t *pAttr,                             uint8 *pValue, uint8 *pLen, uint16 offset, uint8 maxLen ){  bStatus_t status = SUCCESS;  // Make sure it's not a blob operation (no attributes in the profile are long  if ( offset > 0 )  {    return ( ATT_ERR_ATTR_NOT_LONG );  }  // 16-bit UUID  uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);    if ( pAttr->type.len == ATT_BT_UUID_SIZE )  {    switch ( uuid )    {      // No need for "GATT_SERVICE_UUID" case;      // gattserverapp handles those types for reads        case BATTERY_LEVEL_UUID:      case BATTERY_STATE_UUID:        *pLen = 1;        pValue[0] = *pAttr->pValue;        break;            default:        // Should never get here!        *pLen = 0;        status = ATT_ERR_ATTR_NOT_FOUND;        break;    }  }  else  {    //128-bit UUID    *pLen = 0;    status = ATT_ERR_INVALID_HANDLE;  }    return ( status );}

/** * @fn          battReadAttrCB * * @brief       Read an attribute. * * @param       connHandle - connection message was received on * @param       pAttr - pointer to attribute * @param       pValue - pointer to data to be read * @param       pLen - length of data to be read * @param       offset - offset of the first octet to be read * @param       maxLen - maximum length of data to be read * * @return      Success or Failure */static uint8 battReadAttrCB(uint16 connHandle, gattAttribute_t *pAttr, uint8 *pValue, uint8 *pLen, uint16 offset, uint8 maxLen){	bStatus_t	status = SUCCESS;	uint16		uuid = BUILD_UINT16(pAttr->type.uuid[0], pAttr->type.uuid[1]);	// Make sure it's not a blob operation (no attributes in the profile are long)	if (offset > 0) {		return (ATT_ERR_ATTR_NOT_LONG);	}	// Measure battery level if reading level	if (uuid == BATT_LEVEL_UUID) {		*pLen     = 1;		pValue[0] = battLevel;	} else {		status = ATT_ERR_ATTR_NOT_FOUND;	}	return (status);}

static void dev_opera(uint8*buf){  uint8 dev_cnt; //device count  uint16 dev_addr; // device 地址  uint8 opera_bit;  uint8 stop_bit;  uint8 i,j;    i = 0;  j = 0;  //0x01 0x?? ff ff xx ff ff xx ff ff xx  dev_cnt = buf[1];  for(i=0;i<dev_cnt;i++)  {    stop_bit = 2+i*3;        dev_addr = BUILD_UINT16(buf[stop_bit], buf[ stop_bit + 1]);    opera_bit = stop_bit+2;  }  }

/********************************************************************* * @fn          StubNWK_ParseMsg * * @brief       Call this function to parse an incoming Stub NWK frame. * * @param       buf - pointer incoming message buffer * @param       bufLength - length of incoming message * @param       snff  - pointer Frame Format Parameters * * @return      pointer to network packet, NULL if error */static void StubNWK_ParseMsg( uint8 *buf, uint8 bufLength, NLDE_FrameFormat_t *snff ){  uint16 fc;  osal_memset( snff, 0, sizeof(NLDE_FrameFormat_t) );  snff->bufLength = bufLength;  // get the frame control  fc = BUILD_UINT16( buf[NWK_HDR_FRAME_CTRL_LSB], buf[NWK_HDR_FRAME_CTRL_MSB] );  // parse the frame control  NLDE_ParseFrameControl( fc, snff );  snff->hdrLen = STUB_NWK_HDR_LEN;  // Stub NWK payload  snff->nsdu = buf + snff->hdrLen;  snff->nsduLength = snff->bufLength - snff->hdrLen;} /* StubNWK_ParseMsg */

/*************************************************************************************************** * @fn      MT_SysOsalNVLength * * @brief   Attempt to get the length to an NV item * * @param   uint8 pData - pointer to the data * * @return  None ***************************************************************************************************/void MT_SysOsalNVLength(uint8 *pBuf){  uint16 nvId;  uint16 nvLen;  uint8 rsp[2];  /* Skip over RPC header */  pBuf += MT_RPC_FRAME_HDR_SZ;  /* Get the ID */  nvId = BUILD_UINT16(pBuf[0], pBuf[1]);  /* Attempt to get NV item length */  nvLen = osal_nv_item_len( nvId );  rsp[0] = LO_UINT16( nvLen );  rsp[1] = HI_UINT16( nvLen );  /* Build and send back the response */  MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_SYS),                                 MT_SYS_OSAL_NV_LENGTH, 2, rsp);}

/*************************************************************************************************** * @fn      MT_NlmeRouteDiscoveryRequest * * @brief   Route Discovery Request * * @param   pBuf - pointer to the received buffer * * @return  void ***************************************************************************************************/void MT_NlmeRouteDiscoveryRequest(uint8 *pBuf){  uint8 retValue = ZFailure;  uint8 cmdId;  /* parse header */  cmdId = pBuf[MT_RPC_POS_CMD1];  pBuf += MT_RPC_FRAME_HDR_SZ;  if ( ZSTACK_ROUTER_BUILD )  {    retValue = NLME_RouteDiscoveryRequest(BUILD_UINT16(pBuf[0], pBuf[1]), pBuf[2], pBuf[3]);  }  else  {    retValue = ZUnsupportedMode;  }  /* Build and send back the response */  MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_NWK), cmdId, 1, &retValue);}

/****************************************************************************** * @fn      modbus_multi_write */void modbus_multi_write( uint8 *data_buffer, uint8 len){  uint8 address;    address = BUILD_UINT16( data_buffer[3], data_buffer[2]);    if( address == MODBUS_SECURITY_KEY_START)  {    if(data_buffer[6]>=32)    {      for(uint8 i=0; i<16; i++)      {      //  osal_memcpy(defaultKey, data_buffer[7+i*2], 1);        defaultKey[i] = data_buffer[7+i*2];        zgPreconfigKeyInit( TRUE );        // Initialize NV items for all Keys: NWK, APS, TCLK and Master        ZDSecMgrInitNVKeyTables( TRUE );      }    }  }}

/********************************************************************* * @fn      oadWriteAttrCB * * @brief   Validate and Write attribute data * * @param   connHandle - connection message was received on * @param   pAttr - pointer to attribute * @param   pValue - pointer to data to be written * @param   len - length of data * @param   offset - offset of the first octet to be written * @param   method - type of write message  * * @return  SUCCESS, blePending or Failure */static bStatus_t oadWriteAttrCB(uint16 connHandle, gattAttribute_t *pAttr,                                uint8 *pValue, uint8 len, uint16 offset,                                uint8 method){  bStatus_t status = SUCCESS;  if ( pAttr->type.len == ATT_BT_UUID_SIZE )  {    // 16-bit UUID    uint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);    if ( uuid == GATT_CLIENT_CHAR_CFG_UUID)    {      status = GATTServApp_ProcessCCCWriteReq( connHandle, pAttr, pValue, len,                                               offset, GATT_CLIENT_CFG_NOTIFY );    }    else    {      status = ATT_ERR_ATTR_NOT_FOUND; // Should never get here!    }  }  else  {    // 128-bit UUID    if (osal_memcmp(pAttr->type.uuid, oadCharUUID[OAD_CHAR_IMG_IDENTIFY], ATT_UUID_SIZE))    {      status = oadImgIdentifyWrite( connHandle, pValue );    }    else if (osal_memcmp(pAttr->type.uuid, oadCharUUID[OAD_CHAR_IMG_BLOCK], ATT_UUID_SIZE))    {      status = oadImgBlockWrite( connHandle, pValue );    }    else    {      status = ATT_ERR_ATTR_NOT_FOUND; // Should never get here!    }  }  return status;}

/********************************************************************* * @fn      zclElectricalMeasurement_ProcessInCmd_GetMeasurementProfileRsp * * @brief   Process in the received Electrical Measurement Get Measurement Profile Response cmd * * @param   pInMsg - pointer to the incoming message * @param   pCBs - pointer to the application callbacks * * @return  ZStatus_t */static ZStatus_t zclElectricalMeasurement_ProcessInCmd_GetMeasurementProfileRsp( zclIncoming_t *pInMsg,                                                                                 zclElectricalMeasurement_AppCallbacks_t *pCBs ){  uint8 i;  uint8 offset;  uint16 calculatedIntervalSize;  zclElectricalMeasurementGetMeasurementProfileRsp_t cmd;  ZStatus_t status;  if ( pCBs->pfnElectricalMeasurement_GetMeasurementProfileRsp )  {    // determine size of intervals by subtracting size of startTime, status,    // profileIntervalPeriod, numberOfIntervalsDelivered, and attributeID from message length    calculatedIntervalSize = pInMsg->pDataLen - 9;    cmd.pIntervals = zcl_mem_alloc( calculatedIntervalSize );    if ( !cmd.pIntervals )    {      return ( ZMemError );  // no memory, return failure    }    cmd.startTime = BUILD_UINT32( pInMsg->pData[0], pInMsg->pData[1], pInMsg->pData[2], pInMsg->pData[3] );    cmd.status = pInMsg->pData[4];    cmd.profileIntervalPeriod = pInMsg->pData[5];    cmd.numberOfIntervalsDelivered = pInMsg->pData[6];    cmd.attributeID = BUILD_UINT16( pInMsg->pData[7], pInMsg->pData[8] );    offset = 9;    for ( i = 0; i < calculatedIntervalSize; i++ )    {      cmd.pIntervals[i] = pInMsg->pData[offset++];    }    status = ( pCBs->pfnElectricalMeasurement_GetMeasurementProfileRsp( &cmd ) );    zcl_mem_free( cmd.pIntervals );    return status;  }  return ( ZFailure );}

/** *  SNP_getGapParam * */uint8_t SNP_getGapParam(snpGetGapParamReq_t* pReq){      uint8_t status;    //Move part of the simple peripheral init back here    if((pReq->paramId != TGAP_AUTH_TASK_ID) &&         (pReq->value < TGAP_PARAMID_MAX))    {      uint16_t value;      value = GAP_GetParamValue(pReq->paramId);      pReq->value = BUILD_UINT16( LO_UINT16(value),  HI_UINT16(value));    }    if(pReq->value != 0xFFFF)    {      status = SNP_SUCCESS;    }    else    {      status = SNP_INVALID_PARAMS;    }    return status;}

/*************************************************************************************************** * @fn      MT_UtilzclGeneral_KeyEstablish_InitiateKeyEstablishment * * @brief   Proxy the zclGeneral_KeyEstablish_InitiateKeyEstablishment() function. * * @param   pBuf - pointer to the received buffer * * @return  void ***************************************************************************************************/static void MT_UtilzclGeneral_KeyEstablish_InitiateKeyEstablishment(uint8 *pBuf){  afAddrType_t partnerAddr;  uint8 cmdId = pBuf[MT_RPC_POS_CMD1];  pBuf += MT_RPC_FRAME_HDR_SZ;  partnerAddr.panId = 0;  // Not an inter-pan message.  partnerAddr.endPoint = pBuf[2];  partnerAddr.addrMode = (afAddrMode_t)pBuf[3];  if (afAddr64Bit == partnerAddr.addrMode)  {    (void)osal_memcpy(partnerAddr.addr.extAddr, pBuf+4, Z_EXTADDR_LEN);  }  else  {    partnerAddr.addr.shortAddr = BUILD_UINT16(pBuf[4], pBuf[5]);  }  zcl_key_establish_task_id = pBuf[0];  *pBuf = zclGeneral_KeyEstablish_InitiateKeyEstablishment(MT_TaskID, &partnerAddr, pBuf[1]);  MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_UTIL), cmdId, 1, pBuf);}

/*************************************************************************************************** * @fn      MT_SysOsalNVWrite * * @brief * * @param   uint8 pData - pointer to the data * * @return  None ***************************************************************************************************/void MT_SysOsalNVWrite(uint8 *pBuf){  uint16 nvId;  uint8 nvItemLen=0, nvItemOffset=0;  uint8 rtrn;  /* Skip over RPC header */  pBuf += MT_RPC_FRAME_HDR_SZ;  /* Get the ID */  nvId = BUILD_UINT16(pBuf[0], pBuf[1]);  /* Get the offset */  nvItemOffset = pBuf[2];  /* Get the length */  nvItemLen = pBuf[3];  pBuf += 4;  /* Default to ZFailure */  rtrn = ZFailure;  /* Set the Z-Globals value of this NV item. */  zgSetItem( nvId, (uint16)nvItemLen, pBuf );  if ((osal_nv_write(nvId, (uint16)nvItemOffset, (uint16)nvItemLen, pBuf)) == ZSUCCESS)  {    if (nvId == ZCD_NV_EXTADDR)    {      rtrn = ZMacSetReq(ZMacExtAddr, pBuf);    }    else    {      rtrn = ZSuccess;    }  }  /* Build and send back the response */  MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_SYS),                                 MT_SYS_OSAL_NV_WRITE, 1, &rtrn);}

/********************************************************************* * @fn      zclElectricalMeasurement_ProcessInCmd_GetProfileInfoRsp * * @brief   Process in the received Electrical Measurement Get Profile Info Response cmd * * @param   pInMsg - pointer to the incoming message * @param   pCBs - pointer to the application callbacks * * @return  ZStatus_t */static ZStatus_t zclElectricalMeasurement_ProcessInCmd_GetProfileInfoRsp( zclIncoming_t *pInMsg,                                                                          zclElectricalMeasurement_AppCallbacks_t *pCBs ){  uint8 i;  uint8 offset;  uint16 calculatedArraySize;  zclElectricalMeasurementGetProfileInfoRsp_t cmd;  ZStatus_t status;  if ( pCBs->pfnElectricalMeasurement_GetProfileInfoRsp )  {    // calculate size of variable array    calculatedArraySize = pInMsg->pDataLen - 3;  // variable array - 3 bytes of fixed variables    cmd.pListOfAttributes = zcl_mem_alloc( calculatedArraySize );    if ( !cmd.pListOfAttributes )    {      return ( ZMemError );  // no memory, return failure    }    cmd.profileCount = pInMsg->pData[0];    cmd.profileIntervalPeriod = pInMsg->pData[1];    cmd.maxNumberOfIntervals = pInMsg->pData[2];    cmd.numberOfAttributes = calculatedArraySize / sizeof( uint16 );    offset = 3;    for ( i = 0; i < cmd.numberOfAttributes; i++ )    {      cmd.pListOfAttributes[i] = BUILD_UINT16( pInMsg->pData[offset], pInMsg->pData[offset + 1] );      offset += 2;    }    status = ( pCBs->pfnElectricalMeasurement_GetProfileInfoRsp( &cmd ) );    zcl_mem_free( cmd.pListOfAttributes );    return status;  }  return ( ZFailure );}

/********************************************************************* * @fn      glucoseConfigGattMsg()   * * @brief   Handle GATT messages for characteristic configuration. * * @param   state - Discovery state. * @param   pMsg - GATT message. * * @return  New configuration state. */uint8_t glucoseConfigGattMsg(uint8_t state, gattMsgEvent_t *pMsg){  if ((pMsg->method == ATT_READ_RSP || pMsg->method == ATT_WRITE_RSP) &&      (pMsg->hdr.status == SUCCESS))  {    // Process response    switch (glucoseConfigList[state])    {      case HDL_GLUCOSE_MEAS_CCCD:        break;              case HDL_GLUCOSE_CONTEXT_CCCD:        break;              case HDL_GLUCOSE_CTL_PNT_CCCD:        break;              case HDL_GLUCOSE_FEATURE:        glucoseFeatures = BUILD_UINT16(pMsg->msg.readRsp.pValue[0],                                        pMsg->msg.readRsp.pValue[1]);        break;              case HDL_DEVINFO_SYSTEM_ID:        break;              case HDL_DEVINFO_MANUFACTURER_NAME:        break;              case HDL_DEVINFO_MODEL_NUM:        break;              default:        break;    }  }  return glucoseConfigNext(state + 1);}

/* * @fn      uartServ1_WriteAttrCB * * @brief   Validate attribute data prior to a write operation * * @param   connHandle - connection message was received on * @param   pAttr - pointer to attribute * @param   pValue - pointer to data to be written * @param   len - length of data * @param   offset - offset of the first octet to be written * * @return  Success or Failure */static bStatus_t uartServ1_WriteAttrCB(uint16 connHandle, gattAttribute_t *pAttr, uint8 *pValue, uint8 len, uint16 offset){	bStatus_t	status = SUCCESS;	dmsg(("/033[40;31m0xFFE9 (Write)/033[0m/n"));	// If attribute permissions require authorization to write, return error	if (gattPermitAuthorWrite(pAttr->permissions)) {		// Insufficient authorization		return (ATT_ERR_INSUFFICIENT_AUTHOR);	}	if (pAttr->type.len == ATT_BT_UUID_SIZE) {		// 16-bit UUID		uint16	uuid = BUILD_UINT16(pAttr->type.uuid[0], pAttr->type.uuid[1]);		switch (uuid) {		case UARTSERV1_CHAR_UUID:			osal_memcpy(pAttr->pValue, pValue, len);			if (uartServ1_AppCBs) {				uartServ1_AppCBs(UARTSERV1_CHAR);			}			break;		default:			// should never get here! (characteristic 2 do not have write permissions)			dmsg(("err/n"));			status = ATT_ERR_ATTR_NOT_FOUND;			break;		}	} else {		// 128-bit UUID		status = ATT_ERR_INVALID_HANDLE;	}	return (status);}

/*************************************************************************************************** * @fn      MT_SysOsalStartTimer * * @brief * * @param   uint8 pData - pointer to the data * * @return  None ***************************************************************************************************/void MT_SysOsalStartTimer(uint8 *pBuf){  uint16 eventId;  uint8 retValue = ZFailure;  uint8 cmdId;  /* parse header */  cmdId = pBuf[MT_RPC_POS_CMD1];  pBuf += MT_RPC_FRAME_HDR_SZ;  if (*pBuf <= 3)  {    eventId = (uint16) MT_SysOsalEventId[*pBuf];    retValue = osal_start_timerEx(MT_TaskID, eventId, BUILD_UINT16(pBuf[1], pBuf[2]));  }  else  {    retValue = ZInvalidParameter;  }  /* Build and send back the response */  MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_SYS), cmdId, 1, &retValue);}