/*********************************************************************
* @fn controlBLECentralProcessGATTMsg
*
* @brief Process GATT messages
*
* @return none
*/
static void controlBLECentralProcessGATTMsg( gattMsgEvent_t *pMsg )
{
if ( simpleBLEState != BLE_STATE_CONNECTED )
{
// In case a GATT message came after a connection has dropped,
// ignore the message
return;
}
if ( ( pMsg->method == ATT_READ_RSP ) ||
( ( pMsg->method == ATT_ERROR_RSP ) &&
( pMsg->msg.errorRsp.reqOpcode == ATT_READ_REQ ) ) )
{
if ( pMsg->method == ATT_ERROR_RSP )
{
uint8 status = pMsg->msg.errorRsp.errCode;
app_write_string("ATT_READ_RSP Read Error");
//LCD_WRITE_STRING_VALUE( "Read Error", status, 10, HAL_LCD_LINE_1 );
}
else
{
// After a successful read, display the read value
uint8 valueRead = pMsg->msg.readRsp.value[0];
app_write_string(" Read value is:");
app_write_string(uint8_to_string(valueRead));
//LCD_WRITE_STRING_VALUE( "Read rsp:", valueRead, 10, HAL_LCD_LINE_1 );
}
simpleBLEProcedureInProgress = FALSE;
}
else if ( ( pMsg->method == ATT_WRITE_RSP ) ||
( ( pMsg->method == ATT_ERROR_RSP ) &&
( pMsg->msg.errorRsp.reqOpcode == ATT_WRITE_REQ ) ) )
{
if ( pMsg->method == ATT_ERROR_RSP == ATT_ERROR_RSP )
{
uint8 status = pMsg->msg.errorRsp.errCode;
app_write_string("ATT_WRITE_RSP write Error");
LCD_WRITE_STRING_VALUE( "Write Error", status, 10, HAL_LCD_LINE_1 );
}
else
{
app_write_string("write value is:");
app_write_string(uint8_to_string(simpleBLECharVal++));
// After a succesful write, display the value that was written and increment value
//LCD_WRITE_STRING_VALUE( "Write sent:", simpleBLECharVal++, 10, HAL_LCD_LINE_1 );
}
simpleBLEProcedureInProgress = FALSE;
}
else if ( simpleBLEDiscState != BLE_DISC_STATE_IDLE )
{
simpleBLEGATTDiscoveryEvent( pMsg );
}
}
static void write_buf(uint8_t* buf, uint16_t size)
{
uint16_t i;
for (i = 0; i != size; ++i, ++buf)
{
if (i && (((uint8_t)i & (16 - 1)) == 0)) write_eol();
uart_write(uint8_to_string(*buf), 2);
}
write_eol();
}
__attribute__((unused)) static void sel_test(void)
{
while (1)
{
const uint8_t x = sel_read();
uart_write(uint8_to_string(x), 2);
uart_write_rn();
_delay_ms(250);
_delay_ms(250);
_delay_ms(250);
_delay_ms(250);
}
}
//call back func
static void net_socket_recv_callback(uint16 ptr_recv_len)
{
uint8 *ptr;
uint16 next=0;
ptr=ptr_net_buff;
app_write_string("\r\n执行net socket接收回调函数!");
#if NET_DEBUG > 0
for(uint16 i=0;i<ptr_recv_len;i++)
{
app_write_string(uint8_to_string(*ptr++));
while(next++<1000);
next=0;
}
#endif
app_write_string("\r\nnet完成数据接收!");
app_write_string("\r\nnet进入协议解析程序!");
ptr=ptr_net_buff;
ble_control_net_protocol_parse(ptr,ptr_recv_len);
}
/*********************************************************************
* @fn controlBLECentralEventCB
*
* @brief Central event callback function.
*
* @param pEvent - pointer to event structure
*
* @return none
*/
static void controlBLECentralEventCB( gapCentralRoleEvent_t *pEvent )
{
switch ( pEvent->gap.opcode )
{
case GAP_DEVICE_INIT_DONE_EVENT:
{
//LCD_WRITE_STRING( "BLE Central", HAL_LCD_LINE_1 );
// LCD_WRITE_STRING( bdAddr2Str( pEvent->initDone.devAddr ), HAL_LCD_LINE_2 );
}
/***wkxboot***/
app_write_string("hello wkxboot&ble4.0!\r\n");
app_write_string("central role init done. own addr is:");
app_write_string(bdAddr2Str(pEvent->initDone.devAddr));
wkxboot_start_discover();
break;
case GAP_DEVICE_INFO_EVENT:
{
app_write_string("\r\nfind device addr is:");
app_write_string(bdAddr2Str( pEvent->deviceInfo.addr ));
// if filtering device discovery results based on service UUID
if ( DEFAULT_DEV_DISC_BY_SVC_UUID == TRUE )
{
if ( simpleBLEFindSvcUuid( PARAM_BLE_CAR_IN_PROFILE_SERV_UUID,
pEvent->deviceInfo.pEvtData,
pEvent->deviceInfo.dataLen ) )
{
simpleBLEAddDeviceInfo( pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType );
}
}
/****wkxboot***/
// simpleBLEAddDeviceInfo( pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType );
}
break;
case GAP_DEVICE_DISCOVERY_EVENT:
{
// discovery complete
simpleBLEScanning = FALSE;
// if not filtering device discovery results based on service UUID
if ( DEFAULT_DEV_DISC_BY_SVC_UUID == FALSE )
{
// Copy results
simpleBLEScanRes = pEvent->discCmpl.numDevs;
osal_memcpy( simpleBLEDevList, pEvent->discCmpl.pDevList,
(sizeof( gapDevRec_t ) * pEvent->discCmpl.numDevs) );
}
//LCD_WRITE_STRING_VALUE( "Devices Found", simpleBLEScanRes,
// 10, HAL_LCD_LINE_1 );
if ( simpleBLEScanRes > 0 )
{
LCD_WRITE_STRING( "<- To Select", HAL_LCD_LINE_2 );
}
// initialize scan index to last device
simpleBLEScanIdx = simpleBLEScanRes;
/****wkxboot***/
app_write_string("scan completed!!\r\n");
app_write_string("scan num is:");
app_write_string(uint8_to_string(simpleBLEScanRes));
if(simpleBLEScanIdx--)
{
wkxboot_start_connect();
}
else
{
wkxboot_start_discover();
}
}
break;
case GAP_LINK_ESTABLISHED_EVENT:
{
if ( pEvent->gap.hdr.status == SUCCESS )
{
simpleBLEState = BLE_STATE_CONNECTED;
simpleBLEConnHandle = pEvent->linkCmpl.connectionHandle;
simpleBLEProcedureInProgress = TRUE;
// If service discovery not performed initiate service discovery
if ( simpleBLECharHdl == 0 )
{
osal_start_timerEx( simpleBLETaskId, START_DISCOVERY_EVT, DEFAULT_SVC_DISCOVERY_DELAY );
}
//LCD_WRITE_STRING( "Connected", HAL_LCD_LINE_1 );
// LCD_WRITE_STRING( bdAddr2Str( pEvent->linkCmpl.devAddr ), HAL_LCD_LINE_2 );
app_write_string("connected peeraddr is:");
app_write_string(bdAddr2Str(pEvent->linkCmpl.devAddr));
app_write_string("connected connhandle is:");
app_write_string(uint16_to_string(simpleBLEConnHandle));
app_write_string("start to read RSSI!\r\n");
GAPCentralRole_StartRssi( simpleBLEConnHandle, DEFAULT_RSSI_PERIOD );
app_write_string("start to find services.....\r\n");
}
else
{
simpleBLEState = BLE_STATE_IDLE;
simpleBLEConnHandle = GAP_CONNHANDLE_INIT;
simpleBLERssi = FALSE;
simpleBLEDiscState = BLE_DISC_STATE_IDLE;
//LCD_WRITE_STRING( "Connect Failed", HAL_LCD_LINE_1 );
//LCD_WRITE_STRING_VALUE( "Reason:", pEvent->gap.hdr.status, 10, HAL_LCD_LINE_2 );
app_write_string("connect failed!reason is:");
app_write_string(uint8_to_string(pEvent->gap.hdr.status));
}
}
break;
case GAP_LINK_TERMINATED_EVENT:
{
simpleBLEState = BLE_STATE_IDLE;
simpleBLEConnHandle = GAP_CONNHANDLE_INIT;
simpleBLERssi = FALSE;
simpleBLEDiscState = BLE_DISC_STATE_IDLE;
simpleBLECharHdl = 0;
simpleBLEProcedureInProgress = FALSE;
// LCD_WRITE_STRING( "Disconnected", HAL_LCD_LINE_1 );
// LCD_WRITE_STRING_VALUE( "Reason:", pEvent->linkTerminate.reason,
// 10, HAL_LCD_LINE_2 );
app_write_string("disconnected !reason is:");
app_write_string(uint8_to_string(pEvent->gap.hdr.status));
app_write_string("scan again!!\r\n");
wkxboot_start_discover();
}
break;
case GAP_LINK_PARAM_UPDATE_EVENT:
{
// LCD_WRITE_STRING( "Param Update", HAL_LCD_LINE_1 );
app_write_string("link param update!\r\n");
}
break;
default:
break;
}
}
/*********************************************************************
* @fn controlBLECentralRssiCB
*
* @brief RSSI callback.
*
* @param connHandle - connection handle
* @param rssi - RSSI
*
* @return none
*/
static void controlBLECentralRssiCB( uint16 connHandle, int8 rssi )
{
// LCD_WRITE_STRING_VALUE( "RSSI -dB:", (uint8) (-rssi), 10, HAL_LCD_LINE_1 );
app_write_string("RSSI -dB:");
app_write_string(uint8_to_string((uint8)(-rssi)));
}
static void controlBLECentral_HandleKeys( uint8 shift, uint8 keys )
{
(void)shift; // Intentionally unreferenced parameter
uint8 adc;
if(keys & KEY_FUN1)
{
app_write_string("\r\ngot the KEY_FUN1 V:");
adc=halGetVoltageMonitorInput();
app_write_string( uint8_to_string(adc));
HalLedSet( HAL_LED_1 , HAL_LED_MODE_FLASH );
}
if(keys & KEY_FUN2)
{
app_write_string("\r\ngot the KEY_FUN2");
HalLedSet(HAL_LED_2, HAL_LED_MODE_BLINK);
}
if ( keys & HAL_KEY_UP )
{
// Start or stop discovery
if ( simpleBLEState != BLE_STATE_CONNECTED )
{
if ( !simpleBLEScanning )
{
simpleBLEScanning = TRUE;
simpleBLEScanRes = 0;
LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 );
LCD_WRITE_STRING( "", HAL_LCD_LINE_2 );
GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE,
DEFAULT_DISCOVERY_ACTIVE_SCAN,
DEFAULT_DISCOVERY_WHITE_LIST );
}
else
{
GAPCentralRole_CancelDiscovery();
}
}
else if ( simpleBLEState == BLE_STATE_CONNECTED &&
simpleBLECharHdl != 0 &&
simpleBLEProcedureInProgress == FALSE )
{
uint8 status;
// Do a read or write as long as no other read or write is in progress
if ( simpleBLEDoWrite )
{
// Do a write
attWriteReq_t req;
req.handle = simpleBLECharHdl;
req.len = 1;
req.value[0] = simpleBLECharVal;
req.sig = 0;
req.cmd = 0;
status = GATT_WriteCharValue( simpleBLEConnHandle, &req, simpleBLETaskId );
}
else
{
// Do a read
attReadReq_t req;
req.handle = simpleBLECharHdl;
status = GATT_ReadCharValue( simpleBLEConnHandle, &req, simpleBLETaskId );
}
if ( status == SUCCESS )
{
simpleBLEProcedureInProgress = TRUE;
simpleBLEDoWrite = !simpleBLEDoWrite;
}
}
}
if ( keys & HAL_KEY_LEFT )
{
// Display discovery results
if ( !simpleBLEScanning && simpleBLEScanRes > 0 )
{
// Increment index of current result (with wraparound)
simpleBLEScanIdx++;
if ( simpleBLEScanIdx >= simpleBLEScanRes )
{
simpleBLEScanIdx = 0;
}
LCD_WRITE_STRING_VALUE( "Device", simpleBLEScanIdx + 1,
10, HAL_LCD_LINE_1 );
LCD_WRITE_STRING( bdAddr2Str( simpleBLEDevList[simpleBLEScanIdx].addr ),
HAL_LCD_LINE_2 );
}
}
if ( keys & HAL_KEY_RIGHT )
{
// Connection update
if ( simpleBLEState == BLE_STATE_CONNECTED )
{
GAPCentralRole_UpdateLink( simpleBLEConnHandle,
DEFAULT_UPDATE_MIN_CONN_INTERVAL,
DEFAULT_UPDATE_MAX_CONN_INTERVAL,
DEFAULT_UPDATE_SLAVE_LATENCY,
DEFAULT_UPDATE_CONN_TIMEOUT );
}
}
if ( keys & HAL_KEY_CENTER )
{
uint8 addrType;
uint8 *peerAddr;
// Connect or disconnect
if ( simpleBLEState == BLE_STATE_IDLE )
{
// if there is a scan result
if ( simpleBLEScanRes > 0 )
{
// connect to current device in scan result
peerAddr = simpleBLEDevList[simpleBLEScanIdx].addr;
addrType = simpleBLEDevList[simpleBLEScanIdx].addrType;
simpleBLEState = BLE_STATE_CONNECTING;
GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE,
DEFAULT_LINK_WHITE_LIST,
addrType, peerAddr );
LCD_WRITE_STRING( "Connecting", HAL_LCD_LINE_1 );
LCD_WRITE_STRING( bdAddr2Str( peerAddr ), HAL_LCD_LINE_2 );
}
}
else if ( simpleBLEState == BLE_STATE_CONNECTING ||
simpleBLEState == BLE_STATE_CONNECTED )
{
// disconnect
simpleBLEState = BLE_STATE_DISCONNECTING;
gStatus = GAPCentralRole_TerminateLink( simpleBLEConnHandle );
LCD_WRITE_STRING( "Disconnecting", HAL_LCD_LINE_1 );
}
}
if ( keys & HAL_KEY_DOWN )
{
// Start or cancel RSSI polling
if ( simpleBLEState == BLE_STATE_CONNECTED )
{
if ( !simpleBLERssi )
{
simpleBLERssi = TRUE;
GAPCentralRole_StartRssi( simpleBLEConnHandle, DEFAULT_RSSI_PERIOD );
}
else
{
simpleBLERssi = FALSE;
GAPCentralRole_CancelRssi( simpleBLEConnHandle );
LCD_WRITE_STRING( "RSSI Cancelled", HAL_LCD_LINE_1 );
}
}
}
}
