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

/********************************************************************* * @fn      DualImageConcept_processStateChangeEvt * * @brief   Process a pending GAP Role state change event. * * @param   newState - new state * * @return  None. */static void DualImageConcept_processStateChangeEvt(gaprole_States_t newState){  switch ( newState )  {    case GAPROLE_STARTED:      {        uint8_t ownAddress[B_ADDR_LEN];        GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);        // Display device address        Display_print0(dispHandle, 1, 0, Util_convertBdAddr2Str(ownAddress));        Display_print0(dispHandle, 2, 0, "Initialized");      }      break;          case GAPROLE_ADVERTISING:        Display_print0(dispHandle, 2, 0, "Advertising");      break;    case GAPROLE_CONNECTED:      {        uint8_t peerAddress[B_ADDR_LEN];        GAPRole_GetParameter(GAPROLE_CONN_BD_ADDR, peerAddress);        Display_print0(dispHandle, 2, 0, "Connected");        Display_print0(dispHandle, 3, 0, Util_convertBdAddr2Str(peerAddress));      }      break;    case GAPROLE_WAITING:       Display_print0(dispHandle, 2, 0, "Disconnected");      // Clear remaining lines      Display_clearLines(dispHandle, 3, 5);      break;          case GAPROLE_WAITING_AFTER_TIMEOUT:      Display_print0(dispHandle, 2, 0, "Timed Out");            // Clear remaining lines      Display_clearLines(dispHandle, 3, 5);      break;          case GAPROLE_ERROR:      break;          default:      break;  }}

/*---------------------------------------------------------------------------* Peripheral role of a state change handler.* - newState: new state*-------------------------------------------------------------------------*/static void peripheralStateNotificationCB( gaprole_States_t newState ){  uint16 connHandle = INVALID_CONNHANDLE;  if ( pmd.gapProfileState != newState )  {    switch( newState )    {    case GAPROLE_STARTED:      {        // Set the system ID from the bd addr        uint8 systemId[8];              // from #define DEVINFO_SYSTEM_ID_LEN  8        GAPRole_GetParameter(GAPROLE_BD_ADDR, systemId);        // shift three bytes up        systemId[7] = systemId[5];        systemId[6] = systemId[4];        systemId[5] = systemId[3];        // set middle bytes to zero        systemId[4] = 0;        systemId[3] = 0;        updateNameWithAddressInfo();              }      break;          case GAPROLE_ADVERTISING:             break;    case GAPROLE_CONNECTED:      GAPRole_GetParameter( GAPROLE_CONNHANDLE, &connHandle );     #if defined ( PLUS_BROADCASTER )      osal_start_timerEx( pmd.taskId, PMD_ADV_IN_CONNECTION_EVT, ADV_IN_CONN_WAIT );#endif      break;    case GAPROLE_WAITING:      break;    case GAPROLE_WAITING_AFTER_TIMEOUT:      break;    default:      // do nothing      break;          }  }  pmd.gapProfileState = newState;}

/********************************************************************* * @fn      processGapStateChange * * @brief   Change the GAP state. *          1. Connected -> disconnect and start advertising *          2. Advertising -> stop advertising *          3. Disconnected/not advertising -> start advertising * * @param   none * * @return  none */static void processGapStateChange(void){  if (gapProfileState != GAPROLE_CONNECTED)  {    uint8_t current_adv_enabled_status;    uint8_t new_adv_enabled_status;    // Find the current GAP advertising status    GAPRole_GetParameter(GAPROLE_ADVERT_ENABLED, &current_adv_enabled_status);    if (current_adv_enabled_status == FALSE)    {      new_adv_enabled_status = TRUE;    }    else    {      new_adv_enabled_status = FALSE;    }    // Change the GAP advertisement status to opposite of current status    GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),                         &new_adv_enabled_status);  }  if (gapProfileState == GAPROLE_CONNECTED)  {    uint8_t adv_enabled = TRUE;    // Disconnect    GAPRole_TerminateConnection();    // Start advertising    GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &adv_enabled);  }}

/*---------------------------------------------------------------------------* Add the set the last part of hte device name to the final bytes of the * device address. Useful when mane demo devices are located in the same room.*-------------------------------------------------------------------------*/void updateNameWithAddressInfo(void){  //uint8 status;  uint8 numberString[4];  uint8 address[6];  uint8 value;  //status = GAPRole_GetParameter(GAPROLE_BD_ADDR, address);  GAPRole_GetParameter(GAPROLE_BD_ADDR, address);  value = (address[1] & 0xF0) >> 4;  numberString[0] = getAscii(value);  value = address[1] & 0x0F;  numberString[1] = getAscii(value);       value = (address[0] & 0xF0) >> 4;  numberString[2] = getAscii(value);  value = address[0] & 0x0F;  numberString[3] = getAscii(value);       // Replace "0000" part of "OLP425-0000"  osal_memcpy(&attDeviceName[7], numberString, 4);  osal_memcpy(&deviceName[9], numberString, 4);    osal_memcpy(&attDeviceNameNew[7], numberString, 4);  osal_memcpy(&deviceNameNew[9], numberString, 4);//  status = GAPRole_SetParameter( GAPROLE_SCAN_RSP_DATA, sizeof ( deviceName ), deviceName );//  status = GGS_SetParameter( GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN - 1, attDeviceName );     GAPRole_SetParameter( GAPROLE_SCAN_RSP_DATA, sizeof ( deviceName ), deviceName );  GGS_SetParameter( GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN - 1, attDeviceName );   }

/** *  SNP_terminateConn * */uint8_t SNP_terminateConn(snpTermConnReq_t *pReq){    uint8_t status = SNP_SUCCESS;      if(pReq->option == SNP_GAP_TERM_CONN_IMMEDIATLY)    {      uint16_t value;      GAPRole_GetParameter(GAPROLE_CONNHANDLE, &value);      if(pReq->connHandle != value)      {        return SNP_INVALID_PARAMS;      }      else      {        HCI_EXT_DisconnectImmedCmd(value);      }    }    else if(pReq->option == SNP_GAP_TERM_CONN_DEFAULT)    {      status = GAPRole_TerminateConnection();    }    else    {      return SNP_INVALID_PARAMS;    }    return status;}

/********************************************************************* * @fn      simpleBLEBroadcaster_HandleKeys * * @brief   Handles all key events for this device. * * @param   shift - true if in shift/alt. * @param   keys - bit field for key events. Valid entries: *                 HAL_KEY_SW_2 *                 HAL_KEY_SW_1 * * @return  none */static void simpleBLEBroadcaster_HandleKeys( uint8 shift, uint8 keys ){  VOID shift;  // Intentionally unreferenced parameter  if ( keys & HAL_KEY_SW_1 )  {    advertData[6]++;        GAPRole_SetParameter( GAPROLE_ADVERT_DATA, sizeof( advertData ), advertData );  }    if ( keys & HAL_KEY_SW_2 )  {    // ressing the right key should toggle advertising on and off    uint8 current_adv_enabled_status;    uint8 new_adv_enabled_status;        //Find the current GAP advertisement status    GAPRole_GetParameter( GAPROLE_ADVERT_ENABLED, &current_adv_enabled_status );        if( current_adv_enabled_status == FALSE )    {      new_adv_enabled_status = TRUE;    }    else    {      new_adv_enabled_status = FALSE;    }        //change the GAP advertisement status to opposite of current status    GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &new_adv_enabled_status );  }}

/********************************************************************* * @fn      softCmd_HandleKeys * * @brief   Handles all key events for this device. * * @param   shift - true if in shift/alt. * @param   keys - bit field for key events. Valid entries: *                 HAL_KEY_SW_2 *                 HAL_KEY_SW_1 * * @return  none */static void softCmd_HandleKeys( uint8 shift, uint8 keys ){  if ( keys & HAL_KEY_SW_1 )  {    // if in a connection send a soft key    if ( softCmdGapState == GAPROLE_CONNECTED )    {      softCmdSend( CMD_ENUM_SOFT_CMD_0 );    }  }    if ( keys & HAL_KEY_SW_2 )  {    // if not in a connection, toggle advertising on and off    if( softCmdGapState != GAPROLE_CONNECTED )    {      uint8 status;            // toggle GAP advertisement status      GAPRole_GetParameter( GAPROLE_ADVERT_ENABLED, &status );      status = !status;      GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &status );       }    // if in a connection send a soft key    else    {      softCmdSend( CMD_ENUM_SOFT_CMD_1 );    }  }}

static void wechat_get_mac_addr(uint8 *mac_address){	uint8 ownAddress[B_ADDR_LEN];	GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);	for ( uint8 i = 6; i > 0; )	{		i--;		mac_address[5-i]= ownAddress[i];	}}

/********************************************************************* * @fn      Update UI * * @brief   Update user interface LCD and LED * * @param   none * * @return  none */static void updateUI( void ){    LCD_WRITE_STRING( "Thermometer",  HAL_LCD_LINE_1 );    static uint8 ownAddress[B_ADDR_LEN];#if (defined HAL_LCD) && (HAL_LCD == TRUE)    //number of stored measuremnts    uint16 count =0;    //store index    if( thStoreIndex > thStoreStartIndex )    {        count = thStoreIndex - thStoreStartIndex;    }    if( thStoreStartIndex > thStoreIndex )    {        count = ( TH_STORE_MAX-thStoreStartIndex ) + thStoreIndex+1;    }#endif    //State    switch (gapProfileState)    {    case GAPROLE_INIT:        LCD_WRITE_STRING( "Initialized",  HAL_LCD_LINE_2 );        break;    case GAPROLE_STARTED:        LCD_WRITE_STRING( "Started",  HAL_LCD_LINE_2 );        GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);        LCD_WRITE_STRING( bdAddr2Str( ownAddress ),  HAL_LCD_LINE_3 );        break;    case GAPROLE_ADVERTISING:        LCD_WRITE_STRING( "Advertising",  HAL_LCD_LINE_2 );        LCD_WRITE_STRING( "                  ",  HAL_LCD_LINE_3 );        LCD_WRITE_STRING_VALUE("Stored", count, 10, HAL_LCD_LINE_3 );        break;    case GAPROLE_WAITING:    case GAPROLE_WAITING_AFTER_TIMEOUT:        LCD_WRITE_STRING( "Waiting    ",  HAL_LCD_LINE_2 );        LCD_WRITE_STRING_VALUE("Stored", count, 10, HAL_LCD_LINE_3 );        break;    case GAPROLE_CONNECTED:        LCD_WRITE_STRING( "Connected  ",  HAL_LCD_LINE_2 );        break;    case GAPROLE_ERROR:        LCD_WRITE_STRING( "Error      ",  HAL_LCD_LINE_2 );        break;    default:        break;    }}

/******************************************************************************* * @fn      SensorTagConnectionControl_update * * @brief   Update the Connection Control service with the current connection *          control settings * */void SensorTagConnectionControl_update(void){  uint8_t buf[CCSERVICE_CHAR1_LEN];  uint16_t connInterval;  uint16_t connSlaveLatency;  uint16_t connTimeout;     // Get the connection control data  GAPRole_GetParameter(GAPROLE_CONN_INTERVAL, &connInterval);  GAPRole_GetParameter(GAPROLE_SLAVE_LATENCY, &connSlaveLatency);  GAPRole_GetParameter(GAPROLE_CONN_TIMEOUT, &connTimeout);  buf[0] = LO_UINT16(connInterval);  buf[1] = HI_UINT16(connInterval);  buf[2] = LO_UINT16(connSlaveLatency);  buf[3] = HI_UINT16(connSlaveLatency);  buf[4] = LO_UINT16(connTimeout);  buf[5] = HI_UINT16(connTimeout);  CcService_setParameter(CCSERVICE_CHAR1,sizeof(buf),buf);}

static void FanPeripheralStateNotificationCallBack(gaprole_States_t newState){	switch (newState)	{		case GAPROLE_STARTED:			{				uint8 ownAddress[B_ADDR_LEN];				uint8 systemId[DEVINFO_SYSTEM_ID_LEN];				GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);				// use 6 bytes of device address for 8 bytes of system ID value				systemId[0] = ownAddress[0];				systemId[1] = ownAddress[1];				systemId[2] = ownAddress[2];				// set middle bytes to zero				systemId[4] = 0x00;				systemId[3] = 0x00;				// shift three bytes up				systemId[7] = ownAddress[5];				systemId[6] = ownAddress[4];				systemId[5] = ownAddress[3];				DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);			}			break;		case GAPROLE_ADVERTISING:			break;		case GAPROLE_CONNECTED:			FanConnected(fanTaskId);			break;		case GAPROLE_WAITING:			{				FanDisConnected();				uint8 advertEnabled = FALSE;				GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8), &advertEnabled); 				GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof(scanResponseData), scanResponseData);				GGS_SetParameter(GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, scanResponseData + 2);				advertEnabled = TRUE;				GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8), &advertEnabled);						}			break;		case GAPROLE_WAITING_AFTER_TIMEOUT:			break;		case GAPROLE_ERROR:			break;		default:			break;	}};

/** *  SNP_getStatus */void SNP_getStatus(snpGetStatusCmdRsp_t *pMsg){      extern snp_ATToperation_t  snp_ATTstore;  GAPRole_GetParameter(GAPROLE_STATE, &pMsg->gapRoleStatus);  GAPRole_GetParameter(GAPROLE_ADVERT_ENABLED, &pMsg->advStatus);  if(pMsg->advStatus == FALSE)   {    // Connectable Advertisement not enabled, Check of non-connectable adv     // enabled    GAPRole_GetParameter(GAPROLE_ADV_NONCONN_ENABLED, &pMsg->advStatus);  }    pMsg->ATTstatus = snp_ATTstore.validity;  if(snp_ATTstore.validity)  {    pMsg->ATTmethod = snp_ATTstore.method;  }  else  {    pMsg->ATTmethod = 0;  }}

/********************************************************************* * @fn      peripheralStateNotificationCB * * @brief   Notification from the profile of a state change. * * @param   newState - new state * * @return  none */static void peripheralStateNotificationCB( gaprole_States_t newState ){  switch ( newState )  {    case GAPROLE_STARTED:      {            uint8 ownAddress[B_ADDR_LEN];                GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);            #if (defined HAL_LCD) && (HAL_LCD == TRUE)          // Display device address           HalLcdWriteString( bdAddr2Str( ownAddress ),  HAL_LCD_LINE_2 );          HalLcdWriteString( "Initialized",  HAL_LCD_LINE_3 );        #endif // (defined HAL_LCD) && (HAL_LCD == TRUE)          }      break;          case GAPROLE_ADVERTISING:      {        #if (defined HAL_LCD) && (HAL_LCD == TRUE)          HalLcdWriteString( "Advertising",  HAL_LCD_LINE_3 );        #endif // (defined HAL_LCD) && (HAL_LCD == TRUE)                  }      break;    case GAPROLE_WAITING:      {        #if (defined HAL_LCD) && (HAL_LCD == TRUE)          HalLcdWriteString( "Waiting",  HAL_LCD_LINE_3 );        #endif // (defined HAL_LCD) && (HAL_LCD == TRUE)                  }      break;              case GAPROLE_ERROR:      {        #if (defined HAL_LCD) && (HAL_LCD == TRUE)          HalLcdWriteString( "Error",  HAL_LCD_LINE_3 );        #endif // (defined HAL_LCD) && (HAL_LCD == TRUE)                  }      break;                default:      {        #if (defined HAL_LCD) && (HAL_LCD == TRUE)          HalLcdWriteString( "",  HAL_LCD_LINE_3 );        #endif // (defined HAL_LCD) && (HAL_LCD == TRUE)           }              break;   }}

/********************************************************************** @fn      simpleBLEPeripheral_HandleKeys** @brief   Handles all key events for this device.** @param   shift - true if in shift/alt.* @param   keys - bit field for key events. Valid entries:*                 HAL_KEY_SW_2*                 HAL_KEY_SW_1** @return  none*/static void simpleBLEPeripheral_HandleKeys( uint8 shift, uint8 keys ){	uint8 SK_Keys = 0;		VOID shift;  // Intentionally unreferenced parameter		if ( keys & HAL_KEY_SW_1 )	{		SK_Keys |= SK_KEY_LEFT;	}		if ( keys & HAL_KEY_SW_2 )	{				SK_Keys |= SK_KEY_RIGHT;				// if device is not in a connection, pressing the right key should toggle		// advertising on and off		// Note:  If PLUS_BROADCASTER is define this condition is ignored and		//        Device may advertise during connections as well. #ifndef PLUS_BROADCASTER  		if( gapProfileState != GAPROLE_CONNECTED )		{#endif // PLUS_BROADCASTER			uint8 current_adv_enabled_status;			uint8 new_adv_enabled_status;						//Find the current GAP advertisement status			GAPRole_GetParameter( GAPROLE_ADVERT_ENABLED, &current_adv_enabled_status );						if( current_adv_enabled_status == FALSE )			{				new_adv_enabled_status = TRUE;			}			else			{				new_adv_enabled_status = FALSE;			}						//change the GAP advertisement status to opposite of current status			GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &new_adv_enabled_status );#ifndef PLUS_BROADCASTER		}#endif // PLUS_BROADCASTER	}		// Set the value of the keys state to the Simple Keys Profile;	// This will send out a notification of the keys state if enabled	SK_SetParameter( SK_KEY_ATTR, sizeof ( uint8 ), &SK_Keys );}

/** *  SNP_setAdvData * */uint8_t SNP_setAdvData(snpSetAdvDataReq_t *pReq, uint8_t len){  uint8_t status = 0;  uint8_t *pDataPtr;    //Device must be started, or the set adv command will failed.  VOID GAPRole_StartDevice(&SNP_gapRoleCBs);      if(pReq->type < SNP_ADV_DATA_MAX_IDX)  {    pDataPtr = advPtrTable[pReq->type].pData;    if(pDataPtr)    {      ICall_free(advPtrTable[pReq->type].pData);    }    advPtrTable[pReq->type].pData = pDataPtr = ICall_malloc(len);    if(pDataPtr)    {      advPtrTable[pReq->type].length = len;      memcpy(pDataPtr, pReq->pData, len);      if(pReq->type == SNP_ADV_DATA_SCAN_RSP_IDX)      {        status = GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, len, pDataPtr);      }      else if(pReq->type == SNP_ADV_DATA_NON_CONN_IDX)      {        status = GAPRole_SetParameter(GAPROLE_ADVERT_DATA, len, pDataPtr);      }      else if(pReq->type == SNP_ADV_DATA_CONN_IDX)      {        uint8_t value;        GAPRole_GetParameter(GAPROLE_STATE, &value);        if(value == GAPROLE_CONNECTED_ADV)        {          status = GAPRole_SetParameter(GAPROLE_ADVERT_DATA, len, pDataPtr);                }            }    }    else    {      status = SNP_OUT_OF_RESOURCES;    }        }  else  {    //Error, bad type    status = SNP_INVALID_PARAMS;  }    return status;}

/********************************************************************* * @fn      peripheralStateNotificationCB * * @brief   Notification from the profile of a state change. * * @param   newState - new state * * @return  none */static void peripheralStateNotificationCB( gaprole_States_t newState ){  switch ( newState )  {    case GAPROLE_STARTED:    {      uint8 ownAddress[B_ADDR_LEN];      uint8 systemId[DEVINFO_SYSTEM_ID_LEN];      GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);      // use 6 bytes of device address for 8 bytes of system ID value      systemId[0] = ownAddress[0];      systemId[1] = ownAddress[1];      systemId[2] = ownAddress[2];      // set middle bytes to zero      systemId[4] = 0x00;      systemId[3] = 0x00;      // shift three bytes up      systemId[7] = ownAddress[5];      systemId[6] = ownAddress[4];      systemId[5] = ownAddress[3];      DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);    }    break;    case GAPROLE_ADVERTISING:	    HalLedSet(HAL_LED_1, HAL_LED_MODE_ON );	    break;    case GAPROLE_CONNECTED:      HalLedSet(HAL_LED_1, HAL_LED_MODE_OFF );      break;    case GAPROLE_WAITING:      // Link terminated intentionally: reset all sensors      resetSensorSetup();      break;	  default:	    break;  }  gapProfileState = newState;}

/** *  @fn      SNP_paramUpdateCB * *  @brief   callback to be notify a update of the connection parameters  *           has happened. * *  @param[in]   connInterval     : interval of the connection *  @param[in]  connSlaveLatency  : slave latency of the connection *  @param[in]  connTimeout       : supervision timeout of the connection * *  @return  status of the command. */void SNP_paramUpdateCB(uint16_t connInterval,                       uint16_t connSlaveLatency,                       uint16_t connTimeout){  uint16_t param[4];  uint16_t temp;  GAPRole_GetParameter(GAPROLE_CONNHANDLE, &temp);    param[0] = BUILD_UINT16(LO_UINT16(temp), HI_UINT16(temp));   param[1] = BUILD_UINT16(LO_UINT16(connInterval), HI_UINT16(connInterval));   param[2] = BUILD_UINT16(LO_UINT16(connSlaveLatency),                           HI_UINT16(connSlaveLatency));  param[3] = BUILD_UINT16(LO_UINT16(connTimeout), HI_UINT16(connTimeout));  SNP_eventToHost_send(SNP_CONN_PARAM_UPDATED_EVT, NULL, sizeof(param),                       (uint8_t*)param);  }

/********************************************************************* * @fn      HeartRate_toggleAdvertising * * @brief   Toggle advertising state. * * @param   none * * @return  status - TRUE if advertising, FALSE otherwise. */static bool HeartRate_toggleAdvertising(void){  uint8_t advState;    // Find the current GAP advertisement status.  GAPRole_GetParameter(GAPROLE_ADVERT_ENABLED, &advState);    // Get the opposite state.  advState = !advState;    // Change the GAP advertisement status to opposite of current status.  GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),                        &advState);      return advState;}

/********************************************************************* * @fn      heartRate_HandleKeys * * @brief   Handles all key events for this device. * * @param   shift - true if in shift/alt. * @param   keys - bit field for key events. Valid entries: *                 HAL_KEY_SW_2 *                 HAL_KEY_SW_1 * * @return  none */static void heartRate_HandleKeys( uint8 shift, uint8 keys ){  if ( keys & HAL_KEY_SW_1 )  {    // set simulated measurement flag index    if (++heartRateFlagsIdx == FLAGS_IDX_MAX)    {      heartRateFlagsIdx = 0;    }  }    if ( keys & HAL_KEY_SW_2 )  {    // if not in a connection, toggle advertising on and off    if( gapProfileState != GAPROLE_CONNECTED )    {      uint8 status;            // Set fast advertising interval for user-initiated connections      GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_FAST_ADV_INTERVAL );      GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_FAST_ADV_INTERVAL );      GAP_SetParamValue( TGAP_GEN_DISC_ADV_MIN, DEFAULT_FAST_ADV_DURATION );      // toggle GAP advertisement status      GAPRole_GetParameter( GAPROLE_ADVERT_ENABLED, &status );      status = !status;      GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &status );               // Set state variable      if (status == FALSE)      {        heartRateAdvCancelled = TRUE;      }    }    // if in a connection toggle some the battery state bits for test purposes    else    {      uint8 state;            Batt_GetParameter( BATT_PARAM_STATE, &state );      state ^= BATT_FLAGS_CR_CRIT;      Batt_SetParameter( BATT_PARAM_STATE, sizeof( uint8 ), &state );    }      }}

/********************************************************************* * @fn      bloodPressure_HandleKeys * * @brief   Handles all key events for this device. * * @param   shift - true if in shift/alt. * @param   keys - bit field for key events. Valid entries: *                 HAL_KEY_SW_2 *                 HAL_KEY_SW_1 * * @return  none */static void bloodPressure_HandleKeys( uint8 shift, uint8 keys ){   if ( keys & HAL_KEY_SW_1 )  {    // set simulated measurement flag index    if (++bloodPressureFlagsIdx == FLAGS_IDX_MAX)    {      bloodPressureFlagsIdx = 0;    }  }    if ( keys & HAL_KEY_SW_2 )  {    // if device is not in a connection, pressing the right key should toggle    // advertising on and off and start a measurement    if( gapProfileState != GAPROLE_CONNECTED )    {      uint8 current_adv_enabled_status;      uint8 new_adv_enabled_status;            //Find the current GAP advertisement status      GAPRole_GetParameter( GAPROLE_ADVERT_ENABLED, &current_adv_enabled_status );            if( current_adv_enabled_status == FALSE )        new_adv_enabled_status = TRUE;      else        new_adv_enabled_status = FALSE;            //change the GAP advertisement status to opposite of current status      GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &new_adv_enabled_status );            //start simulation timer (start --> cuff -->measurement ready)      osal_start_timerEx( bloodPressureTaskId, BP_TIMER_CUFF_EVT, TIMER_CUFF_PERIOD );             //reset cuff count      cuffCount = 0;         }    else //connected mode, simulate some measurements    {      simulateMeas();    }        }}

/** *  SNP_updateConnParam * */uint8_t SNP_updateConnParam(snpUpdateConnParamReq_t *pReq){    uint8_t enableUpdateRequest = TRUE;    uint8_t status;    uint8_t value;      status = GAPRole_SetParameter(GAPROLE_PARAM_UPDATE_ENABLE, sizeof(uint8_t),                         &enableUpdateRequest);    status |= GAPRole_SetParameter(GAPROLE_MIN_CONN_INTERVAL, sizeof(uint16_t),                         &pReq->intervalMin);    status |= GAPRole_SetParameter(GAPROLE_MAX_CONN_INTERVAL, sizeof(uint16_t),                         &pReq->intervalMax);    status |= GAPRole_SetParameter(GAPROLE_SLAVE_LATENCY, sizeof(uint16_t),                         &pReq->slaveLatency);    status |= GAPRole_SetParameter(GAPROLE_TIMEOUT_MULTIPLIER, sizeof(uint16_t),                         &pReq->supervisionTimeout);      if(status == bleInvalidRange)    {      //Error management      return SNP_INVALID_PARAMS;    }    else if(status)     {      // Mix of errors      return SNP_FAILURE;    }        //check Status, only force update if in a connection.    GAPRole_GetParameter(GAPROLE_STATE, &value);    if((value == GAPROLE_CONNECTED) || (value == GAPROLE_CONNECTED_ADV))    {      if (GAPRole_SetParameter( GAPROLE_PARAM_UPDATE_REQ,                                      sizeof(uint8_t),                                      &enableUpdateRequest))      {        status = SNP_INVALID_PARAMS;      }    }    else    {      status = SNP_NOT_CONNECTED;    }    return status;}

uint8 Application_StopAdvertise(){    if( gapProfileState != GAPROLE_CONNECTED )    {        uint8 astatus;        // toggle GAP advertisement status        GAPRole_GetParameter( GAPROLE_ADVERT_ENABLED, &astatus );        if (astatus == TRUE)        {            astatus = FALSE;            GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &astatus );            return SUCCESS;        }    }    return FAILURE;}

bStatus_t char4_notify(uint8 state){  attHandleValueNoti_t Report;    GAPRole_GetParameter(GAPROLE_CONNHANDLE, &connHandle);  uint16 value = GATTServApp_ReadCharCfg( connHandle, simpleProfileChar4Config);  // If notifications enabled  if ( value & GATT_CLIENT_CFG_NOTIFY )  {    // Set the handle    Report.handle = simpleProfileAttrTbl[14].handle;    Report.len = 1;                    osal_memcpy(Report.value, &state, 1);    // Send the notification    return GATT_Notification( connHandle, &Report, FALSE );  }    return bleIncorrectMode;}

/********************************************************************* * @fn      SimpleBLEBroadcaster_processStateChangeEvt * * @brief   Notification from the profile of a state change. * * @param   newState - new state * * @return  none */static void SimpleBLEBroadcaster_processStateChangeEvt(gaprole_States_t newState){  switch (newState)  {    case GAPROLE_STARTED:      {        uint8 ownAddress[B_ADDR_LEN];                GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);                // Display device address         LCD_WRITE_STRING(Util_convertBdAddr2Str(ownAddress), LCD_PAGE1);        LCD_WRITE_STRING("Initialized", LCD_PAGE2);      }      break;          case GAPROLE_ADVERTISING:      {        LCD_WRITE_STRING("Advertising", LCD_PAGE2);              }      break;    case GAPROLE_WAITING:      {        LCD_WRITE_STRING("Waiting", LCD_PAGE2);             }      break;              case GAPROLE_ERROR:      {        LCD_WRITE_STRING("Error", LCD_PAGE2);               }      break;                default:      {        LCD_WRITE_STRING("", LCD_PAGE2);      }      break;   }}

/********************************************************************* * @fn      hidDevGapStateCB * * @brief   Notification from the profile of a state change. * * @param   newState - new state * * @return  none */static void hidDevGapStateCB( gaprole_States_t newState ){  // if connected  if ( newState == GAPROLE_CONNECTED )  {    // get connection handle    GAPRole_GetParameter( GAPROLE_CONNHANDLE, &gapConnHandle );    // connection not secure yet    hidDevConnSecure = FALSE;    // don't start advertising when connection is closed    uint8 param = FALSE;    GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &param );    // start idle timer    hidDevStartIdleTimer();  }  // if disconnected  else if ( hidDevGapState == GAPROLE_CONNECTED &&            newState != GAPROLE_CONNECTED )  {    hidDevDisconnected();    updateConnParams = TRUE;    if ( pairingStatus == SMP_PAIRING_FAILED_CONFIRM_VALUE )    {      // bonding failed due to mismatched confirm values      hidDevInitialAdvertising();      pairingStatus = SUCCESS;    }  }  // if started  else if ( newState == GAPROLE_STARTED )  {    // nothing to do for now!  }  hidDevGapState = newState;}

/********************************************************************* * @fn      thermometer_Advertise * * @brief   Start advertisemement when measurement is ready * * * @return  none */static void thermometer_Advertise( void ){    // Advertise if not connected    if( gapProfileState != GAPROLE_CONNECTED )    {        uint8 current_adv_enabled_status;        uint8 new_adv_enabled_status;        //Find the current GAP advertisement status        GAPRole_GetParameter( GAPROLE_ADVERT_ENABLED, &current_adv_enabled_status );        if( current_adv_enabled_status == FALSE )        {            new_adv_enabled_status = TRUE;        }        //change the GAP advertisement status        GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &new_adv_enabled_status );    }}

uint8 Application_StartAdvertise(uint16 duration, uint16 interval){    if( gapProfileState != GAPROLE_CONNECTED )    {        uint8 astatus;        // toggle GAP advertisement status        GAPRole_GetParameter( GAPROLE_ADVERT_ENABLED, &astatus );        if (astatus == FALSE)        {            //Set fast advertising interval for user-initiated connections            GAP_SetParamValue( TGAP_LIM_DISC_ADV_INT_MIN, interval );            GAP_SetParamValue( TGAP_LIM_DISC_ADV_INT_MAX, interval );            GAP_SetParamValue( TGAP_LIM_ADV_TIMEOUT, duration );            astatus = TRUE;            GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &astatus );            return SUCCESS;        }    }    return FAILURE;}

/********************************************************************* * @fn      Thermometer_advertise * * @brief   Start advertisement when measurement is ready. * * @param   none * * @return  none */static void Thermometer_advertise(void){  // If not connected, toggle advertising.  if (gapProfileState != GAPROLE_CONNECTED)  {    uint8_t current_adv_enabled_status;    uint8_t new_adv_enabled_status;        // Find the current GAP advertisement status.    GAPRole_GetParameter(GAPROLE_ADVERT_ENABLED, &current_adv_enabled_status);        if(current_adv_enabled_status == FALSE)    {      new_adv_enabled_status = TRUE;    }        // Change the GAP advertisement status .    GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),                          &new_adv_enabled_status);     }}

/********************************************************************* * @fn      softCmdGapStateCB * * @brief   Notification from the profile of a state change. * * @param   newState - new state * * @return  none */static void softCmdGapStateCB( gaprole_States_t newState ){  // if connected  if (newState == GAPROLE_CONNECTED)  {    linkDBItem_t  *pItem;    // Get connection handle    GAPRole_GetParameter( GAPROLE_CONNHANDLE, &softCmdConnHandle );    // Get peer bd address    if ( (pItem = linkDB_Find( softCmdConnHandle )) != NULL)    {      // If connected to device without bond do service discovery      if ( !osal_memcmp( pItem->addr, softCmdBondedAddr, B_ADDR_LEN ) )      {        softCmdDiscoveryCmpl = FALSE;      }            // Initiate service discovery if necessary      if ( softCmdDiscoveryCmpl == FALSE )      {        osal_start_timerEx( softCmdTaskId, START_DISCOVERY_EVT, DEFAULT_DISCOVERY_DELAY );      }    }        }    // if disconnected  else if (softCmdGapState == GAPROLE_CONNECTED &&            newState != GAPROLE_CONNECTED)  {    softCmdDisconnected();        // reset client characteristic configuration descriptors    uint16 param = GATT_CFG_NO_OPERATION;    Batt_SetParameter(BATT_PARAM_LVL_ST_CHAR_CFG, sizeof(uint16), (uint8 *) &param);  }        softCmdGapState = newState;}

/** * @fn      uartServ2_SetParameter * * @brief   Set a Service 2 parameter. * * @param   param - Profile parameter ID * @param   len - length of data to right * @param   value - pointer to data to write.  This is dependent on *          the parameter ID and WILL be cast to the appropriate *          data type (example: data type of uint16 will be cast to *          uint16 pointer). * * @return  bStatus_t */bStatus_t uartServ2_SetParameter(uint8 param, uint8 len, void *value){	bStatus_t	ret = SUCCESS;	switch (param) {	case UARTSERV2_CHAR:		{			attHandleValueNoti_t	noti;			uint16			notiHandle;			uint8			*pkt = (uint8 *) value;			GAPRole_GetParameter(GAPROLE_CONNHANDLE, &notiHandle);			noti.handle = uartServ2AttrTbl[2].handle;			noti.len = len;			osal_memcpy(&noti.value[0], pkt, noti.len);			GATT_Notification(notiHandle, &noti, FALSE);			//			{				uint8	i;				dmsg(("[ble->app]:"));				for (i=0; i<noti.len; i++) {					dmsg((" %02x", noti.value[i]));				}				dmsg(("/n"));			}		}		break;	default:		ret = INVALIDPARAMETER;		break;	}	return (ret);}