/*********************************************************************
 * @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;
  }
}
예제 #2
0
/*---------------------------------------------------------------------------
* 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;
}
예제 #3
0
/*********************************************************************
 * @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);
  }
}
예제 #4
0
/*---------------------------------------------------------------------------
* 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 );   
}
예제 #5
0
/**
 *  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;
}
예제 #6
0
/*********************************************************************
 * @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 );
  }
}
예제 #7
0
/*********************************************************************
 * @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 );
    }
  }
}
예제 #8
0
파일: wechatapp.c 프로젝트: billy-wang/IOT
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];
	}
}
예제 #9
0
/*********************************************************************
 * @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;
    }

}
예제 #10
0
/*******************************************************************************
 * @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);
}
예제 #11
0
파일: fan.c 프로젝트: drme/ble-remote
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;
  }
}
예제 #13
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 );
}
예제 #15
0
/**
 *  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;
}
예제 #16
0
파일: SensorTag.c 프로젝트: AubrCool/BLE
/*********************************************************************
 * @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;
}
예제 #17
0
/**
 *  @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);  
}
예제 #18
0
/*********************************************************************
 * @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;
}
예제 #19
0
/*********************************************************************
 * @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 );
    }
    
  }
}
예제 #20
0
/*********************************************************************
 * @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();
    }      
  }
}
예제 #21
0
/**
 *  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;
}
예제 #22
0
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;
}
예제 #23
0
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;
}
예제 #24
0
/*********************************************************************
 * @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; 
  }
}
예제 #25
0
/*********************************************************************
 * @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;
}
예제 #26
0
/*********************************************************************
 * @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 );
    }
}
예제 #27
0
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;
}
예제 #28
0
/*********************************************************************
 * @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);   
  }
}
예제 #29
0
/*********************************************************************
 * @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;
}
예제 #30
0
파일: uartserv.c 프로젝트: wythe-lin/ZTKBLE
/**
 * @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);
}