2017年5月21日 星期日

第四章：BLE程式設計

在BLE方面，我們選用TI的CC254x，由於網路上的資源多，修改起來也快!
安裝完TI BLE-Stack 1.4.0後，會發現裡面有很多Sample Code
這樣的話，我們就可以拿網路上的SimpleBLECentral_SerialControl的Sample Code來改吧! 咦!?

BLE流程是這樣
1、先送出這個BLE的UID
2、掃瞄特定的BLE ID(為什麼要特定的呢?因為只想知道某人是不是在這區域)
3、記錄所有BLE ID的RSSI
4、上傳所有資料，資料格式會長這樣
/本機的UID/特定的UID/特定UID的RSSI值

即然有流程，就著手Coding吧…

首先只要Scan到這五個就會由MQTT上傳Cloud
char *searchID[5] = {"0x9C207BC69992","0x6D5F27560864","0x7CEC7945C8E7","0x60A1784F1FD1","0xD03972A6B3D4"};

這時讀者會想，那我要再增加怎麼辦?
一開始用Android + Socket送資料給ESP8266不就成了!

然後在uint16 SimpleBLECentral_ProcessEvent( uint8 task_id, uint16 events )內
我增加了Init_Dev與Auto_Scan的EVENT

一開始先Init_Dev，把自己的UID傳到MCU上，之後再Auto_Scan把特定BLE的數據傳到MCU
語法如下

if ( events & START_DISCOVERY_EVT )
  {
    simpleBLECentralStartDiscovery( );
   
    return ( events ^ START_DISCOVERY_EVT );
  }
 
    if ( events & Init_Dev )
  {
    GAPCentralRole_GetParameter(GAPCENTRALROLE_BD_ADDR, ownAddress);
    SerialPrintString("/");
    SerialPrintString(bdAddr2Str(ownAddress));
    SerialPrintString("/");
   
    LCD_WRITE_STRING( "Send to STM", HAL_LCD_LINE_6 );
    osal_start_timerEx( simpleBLETaskId, Auto_Scan, 5000 );
    return ( events ^ Init_Dev );
  }
 
  if ( events & Auto_Scan)
    {
     
          // Start or stop discovery
 //   SerialPrintString("  [KEY UP pressed!]\r\n");
    if ( simpleBLEState != BLE_STATE_CONNECTED )
    {
      if ( !simpleBLEScanning )
      {
        simpleBLEScanning = TRUE;
        simpleBLEScanRes = 0;
       
        LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 );
      //  SerialPrintString("Discovering...\r\n");
        LCD_WRITE_STRING( "", HAL_LCD_LINE_2 );
       
        GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE,
                                       DEFAULT_DISCOVERY_ACTIVE_SCAN,
                                       DEFAULT_DISCOVERY_WHITE_LIST );     
      }
      else
      {
        GAPCentralRole_CancelDiscovery();
      }
    }

      osal_start_timerEx( simpleBLETaskId, Auto_Scan, 5000 );
      return (events ^ Auto_Scan);

}
 
  // Discard unknown events
  return 0;
}

然後在simpleBLEAddDeviceInfo內修改寫法
static void simpleBLEAddDeviceInfo( uint8 *pAddr, uint8 *addrType )
{
  uint8 i;
 
  // If result count not at max
  if ( simpleBLEScanRes < DEFAULT_MAX_SCAN_RES )
  {
    // Check if device is already in scan results
    for ( i = 0; i < simpleBLEScanRes; i++ )
    {
      if ( osal_memcmp( pAddr, simpleBLEDevList[i].addr , B_ADDR_LEN ) )
      {
        return;
      }
    }
   // if(strcmp(args->args[0].val, "MASTER") == 0)
    for (i =0; i < 5; i++){//比對id searchID這個
    if(strcmp((uint8*)bdAddr2Str(pAddr), searchID[i]) == 0){//比較使用者設定的id，是這個id才往上傳
     // SerialPrintValue("i:", i,10);
    GAPCentralRole_GetParameter(GAPCENTRALROLE_BD_ADDR, ownAddress);
    SerialPrintString("/");
    SerialPrintString(bdAddr2Str(ownAddress));
    SerialPrintString("/");
    SerialPrintString((uint8*) bdAddr2Str(pAddr));
    SerialPrintString("/");

    SerialPrintString("-");
    SerialPrintString((uint8*)str_format(addrType));
   
    SerialPrintString("/");
    double a = calculateAccuracy( -55, -(str_format(addrType)) );
     sprintf(str, "%s", a);
    SerialPrintString((uint8*)str);
    SerialPrintString("\"");
    SerialPrintString("\r\n");

    osal_memcpy( simpleBLEDevList[simpleBLEScanRes].addr, pAddr, B_ADDR_LEN );
   
    // Increment scan result count
    simpleBLEScanRes++;
    }
  }
  }
}

接著寫被掃瞄到的從機，把RSSI換成距離的寫法
/*********************************************************************
 * @fn      calculateAccuracy
 *
 * @brief   calculateRSSI to distance
 *
 * @return  none
 */
double calculateAccuracy( double txPower, double rssi )
{
       if (rssi == 0) {
           return -1.0; // if we cannot determine accuracy, return -1.
       }
       double ratio = rssi * 1.0 / txPower;
       if (ratio < 1.0) {
           return pow(ratio, 10);
       } else {
           double accuracy = (0.42093) * pow(ratio, 6.9476) + 0.54992;
           return accuracy;
       }
}

最後在void CommondHandle(uint8 *pBuffer, uint16 length)增加以下語句
意思是說，當MCU的UART TX送AT+GO這個字串，2秒後，跳到Init_Dev
  if(length>=5 && str_cmp(pBuffer+3,"GO",2)==0){
    osal_start_timerEx( simpleBLETaskId, Init_Dev, 2000 );
    return ;
  }
完整BLE程式碼如下

#include "bcomdef.h"
#include "OSAL.h"
#include "OSAL_PwrMgr.h"
#include "OnBoard.h"
#include "hal_led.h"
#include "hal_key.h"
#include "hal_lcd.h"
#include "gatt.h"
#include "ll.h"
#include "hci.h"
#include "gapgattserver.h"
#include "gattservapp.h"
#include "central.h"
#include "gapbondmgr.h"
#include "simpleGATTprofile.h"
#include "simpleBLECentral.h"
#include "string.h"
#include "math.h"
#include "SerialApp.h"

/*********************************************************************
 * MACROS
 */

// Length of bd addr as a string
#define B_ADDR_STR_LEN                        15

/*********************************************************************
 * CONSTANTS
 */

// Maximum number of scan responses
#define DEFAULT_MAX_SCAN_RES                  8

// Scan duration in ms
#define DEFAULT_SCAN_DURATION                 4000

// Discovey mode (limited, general, all)
#define DEFAULT_DISCOVERY_MODE                DEVDISC_MODE_ALL

// TRUE to use active scan
#define DEFAULT_DISCOVERY_ACTIVE_SCAN         TRUE

// TRUE to use white list during discovery
#define DEFAULT_DISCOVERY_WHITE_LIST          FALSE

// TRUE to use high scan duty cycle when creating link
#define DEFAULT_LINK_HIGH_DUTY_CYCLE          FALSE

// TRUE to use white list when creating link
#define DEFAULT_LINK_WHITE_LIST               FALSE

// Default RSSI polling period in ms
#define DEFAULT_RSSI_PERIOD                   1000

// Whether to enable automatic parameter update request when a connection is formed
#define DEFAULT_ENABLE_UPDATE_REQUEST         FALSE

// Minimum connection interval (units of 1.25ms) if automatic parameter update request is enabled
#define DEFAULT_UPDATE_MIN_CONN_INTERVAL      400

// Maximum connection interval (units of 1.25ms) if automatic parameter update request is enabled
#define DEFAULT_UPDATE_MAX_CONN_INTERVAL      800

// Slave latency to use if automatic parameter update request is enabled
#define DEFAULT_UPDATE_SLAVE_LATENCY          0

// Supervision timeout value (units of 10ms) if automatic parameter update request is enabled
#define DEFAULT_UPDATE_CONN_TIMEOUT           600

// Default passcode
#define DEFAULT_PASSCODE                      19655

// Default GAP pairing mode
#define DEFAULT_PAIRING_MODE                  GAPBOND_PAIRING_MODE_WAIT_FOR_REQ

// Default MITM mode (TRUE to require passcode or OOB when pairing)
#define DEFAULT_MITM_MODE                     FALSE

// Default bonding mode, TRUE to bond
#define DEFAULT_BONDING_MODE                  TRUE

// Default GAP bonding I/O capabilities
#define DEFAULT_IO_CAPABILITIES               GAPBOND_IO_CAP_DISPLAY_ONLY

// Default service discovery timer delay in ms
#define DEFAULT_SVC_DISCOVERY_DELAY           1000

// TRUE to filter discovery results on desired service UUID
#define DEFAULT_DEV_DISC_BY_SVC_UUID          FALSE

// Application states
enum
{
  BLE_STATE_IDLE,
  BLE_STATE_CONNECTING,
  BLE_STATE_CONNECTED,
  BLE_STATE_DISCONNECTING
};

// Discovery states
enum
{
  BLE_DISC_STATE_IDLE,                // Idle
  BLE_DISC_STATE_SVC,                 // Service discovery
  BLE_DISC_STATE_CHAR                 // Characteristic discovery
};

/*********************************************************************
 * TYPEDEFS
 */

/*********************************************************************
 * GLOBAL VARIABLES
 */

/*********************************************************************
 * EXTERNAL VARIABLES
 */

/*********************************************************************
 * EXTERNAL FUNCTIONS
 */

/*********************************************************************
 * LOCAL VARIABLES
 */

// Task ID for internal task/event processing
static uint8 simpleBLETaskId;

// GAP GATT Attributes
static const uint8 simpleBLEDeviceName[GAP_DEVICE_NAME_LEN] = "Simple BLE Central";

// Number of scan results and scan result index
static uint8 simpleBLEScanRes;
static uint8 simpleBLEScanIdx;

// Scan result list
static gapDevRec_t simpleBLEDevList[DEFAULT_MAX_SCAN_RES];

// Scanning state
static uint8 simpleBLEScanning = FALSE;

// RSSI polling state
static uint8 simpleBLERssi = FALSE;

// Connection handle of current connection
static uint16 simpleBLEConnHandle = GAP_CONNHANDLE_INIT;

// Application state
static uint8 simpleBLEState = BLE_STATE_IDLE;

// Discovery state
static uint8 simpleBLEDiscState = BLE_DISC_STATE_IDLE;

// Discovered service start and end handle
static uint16 simpleBLESvcStartHdl = 0;
static uint16 simpleBLESvcEndHdl = 0;

// Discovered characteristic handle
static uint16 simpleBLECharHdl = 0;

// Value to write
static uint8 simpleBLECharVal = 0;

// Value read/write toggle
static bool simpleBLEDoWrite = FALSE;

// GATT read/write procedure state
static bool simpleBLEProcedureInProgress = FALSE;
int str,flag1=0,flag2=0;
uint8 ownAddress[B_ADDR_LEN];
char *searchID[5]={"0x9C207BC69992","0x6D5F27560864","0x7CEC7945C8E7","0x60A1784F1FD1","0xD03972A6B3D4"};
int searchID_flag=0;

/*********************************************************************
 * LOCAL FUNCTIONS
 */
static void simpleBLECentralProcessGATTMsg( gattMsgEvent_t *pMsg );
static void simpleBLECentralRssiCB( uint16 connHandle, int8  rssi );
static void simpleBLECentralEventCB( gapCentralRoleEvent_t *pEvent );
static void simpleBLECentralPasscodeCB( uint8 *deviceAddr, uint16 connectionHandle,
                                        uint8 uiInputs, uint8 uiOutputs );
static void simpleBLECentralPairStateCB( uint16 connHandle, uint8 state, uint8 status );
static void simpleBLECentral_HandleKeys( uint8 shift, uint8 keys );
static void simpleBLECentral_ProcessOSALMsg( osal_event_hdr_t *pMsg );
static void simpleBLEGATTDiscoveryEvent( gattMsgEvent_t *pMsg );
static void simpleBLECentralStartDiscovery( void );
static bool simpleBLEFindSvcUuid( uint16 uuid, uint8 *pData, uint8 dataLen );
static void simpleBLEAddDeviceInfo( uint8 *pAddr, uint8 *addrType );
char *bdAddr2Str ( uint8 *pAddr );

/*********************************************************************
 * PROFILE CALLBACKS
 */

// GAP Role Callbacks
static const gapCentralRoleCB_t simpleBLERoleCB =
{
  simpleBLECentralRssiCB,       // RSSI callback
  simpleBLECentralEventCB       // Event callback
};

// Bond Manager Callbacks
static const gapBondCBs_t simpleBLEBondCB =
{
  simpleBLECentralPasscodeCB,
  simpleBLECentralPairStateCB
};

/*********************************************************************
 * PUBLIC FUNCTIONS
 */

/*********************************************************************
 * @fn      SimpleBLECentral_Init
 *
 * @brief   Initialization function for the Simple BLE Central App Task.
 *          This is called during initialization and should contain
 *          any application specific initialization (ie. hardware
 *          initialization/setup, table initialization, power up
 *          notification).
 *
 * @param   task_id - the ID assigned by OSAL.  This ID should be
 *                    used to send messages and set timers.
 *
 * @return  none
 */
void SimpleBLECentral_Init( uint8 task_id )
{
  simpleBLETaskId = task_id;
  SerialApp_Init(simpleBLETaskId);

 // SerialPrintString("SimpleBLECentral_SerialPrint Start init.\r\n");
  // Setup Central Profile
  {
    uint8 scanRes = DEFAULT_MAX_SCAN_RES;
    GAPCentralRole_SetParameter ( GAPCENTRALROLE_MAX_SCAN_RES, sizeof( uint8 ), &scanRes );
  }
 
  // Setup GAP
  GAP_SetParamValue( TGAP_GEN_DISC_SCAN, DEFAULT_SCAN_DURATION );
  GAP_SetParamValue( TGAP_LIM_DISC_SCAN, DEFAULT_SCAN_DURATION );
  GGS_SetParameter( GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, (uint8 *) simpleBLEDeviceName );



  // Setup the GAP Bond Manager
  {
    uint32 passkey = DEFAULT_PASSCODE;
    uint8 pairMode = DEFAULT_PAIRING_MODE;
    uint8 mitm = DEFAULT_MITM_MODE;
    uint8 ioCap = DEFAULT_IO_CAPABILITIES;
    uint8 bonding = DEFAULT_BONDING_MODE;
    GAPBondMgr_SetParameter( GAPBOND_DEFAULT_PASSCODE, sizeof( uint32 ), &passkey );
    GAPBondMgr_SetParameter( GAPBOND_PAIRING_MODE, sizeof( uint8 ), &pairMode );
    GAPBondMgr_SetParameter( GAPBOND_MITM_PROTECTION, sizeof( uint8 ), &mitm );
    GAPBondMgr_SetParameter( GAPBOND_IO_CAPABILITIES, sizeof( uint8 ), &ioCap );
    GAPBondMgr_SetParameter( GAPBOND_BONDING_ENABLED, sizeof( uint8 ), &bonding );
  } 

  // Initialize GATT Client
  VOID GATT_InitClient();

  // Register to receive incoming ATT Indications/Notifications
    GATT_RegisterForInd( simpleBLETaskId );

  // Initialize GATT attributes
  GGS_AddService( GATT_ALL_SERVICES );         // GAP
  GATTServApp_AddService( GATT_ALL_SERVICES ); // GATT attributes

  // Register for all key events - This app will handle all key events
  RegisterForKeys( simpleBLETaskId );
 
  // makes sure LEDs are off
  HalLedSet( (HAL_LED_1 | HAL_LED_2), HAL_LED_MODE_OFF );
 
  // Setup a delayed profile startup
  osal_set_event( simpleBLETaskId, START_DEVICE_EVT );
 
 // SerialPrintString("Ready to Starting\r\n");
}

/*********************************************************************
 * @fn      SimpleBLECentral_ProcessEvent
 *
 * @brief   Simple BLE Central Application Task event processor.  This function
 *          is called to process all events for the task.  Events
 *          include timers, messages and any other user defined events.
 *
 * @param   task_id  - The OSAL assigned task ID.
 * @param   events - events to process.  This is a bit map and can
 *                   contain more than one event.
 *
 * @return  events not processed
 */
uint16 SimpleBLECentral_ProcessEvent( uint8 task_id, uint16 events )
{
 
  VOID task_id; // OSAL required parameter that isn't used in this function
 
  if ( events & SYS_EVENT_MSG )
  {
    uint8 *pMsg;

    if ( (pMsg = osal_msg_receive( simpleBLETaskId )) != NULL )
    {
      simpleBLECentral_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );

      // Release the OSAL message
      VOID osal_msg_deallocate( pMsg );
    }

    // return unprocessed events
    return (events ^ SYS_EVENT_MSG);
  }

  if ( events & START_DEVICE_EVT )
  {
    // Start the Device
    VOID GAPCentralRole_StartDevice( (gapCentralRoleCB_t *) &simpleBLERoleCB );

    // Register with bond manager after starting device
    GAPBondMgr_Register( (gapBondCBs_t *) &simpleBLEBondCB );
   
  //  SerialPrintString("BLE Stack is running\r\n");
   // osal_start_timerEx( simpleBLETaskId, Init_Dev, 15000 );
    return ( events ^ START_DEVICE_EVT );
  }

  if ( events & START_DISCOVERY_EVT )
  {
    simpleBLECentralStartDiscovery( );
   
    return ( events ^ START_DISCOVERY_EVT );
  }
 
    if ( events & Init_Dev )
  {
    GAPCentralRole_GetParameter(GAPCENTRALROLE_BD_ADDR, ownAddress);
    SerialPrintString("/");
    SerialPrintString(bdAddr2Str(ownAddress));
    SerialPrintString("/");
    SerialPrintString("\r\n");
   
    LCD_WRITE_STRING( "Send to STM", HAL_LCD_LINE_6 );
    osal_start_timerEx( simpleBLETaskId, Auto_Scan, 5000 );
    return ( events ^ Init_Dev );
  }
 
  if ( events & Auto_Scan)
    {
     
          // Start or stop discovery
 //   SerialPrintString("  [KEY UP pressed!]\r\n");
    if ( simpleBLEState != BLE_STATE_CONNECTED )
    {
      if ( !simpleBLEScanning )
      {
        simpleBLEScanning = TRUE;
        simpleBLEScanRes = 0;
       
        LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 );
      //  SerialPrintString("Discovering...\r\n");
        LCD_WRITE_STRING( "", HAL_LCD_LINE_2 );
       
        GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE,
                                       DEFAULT_DISCOVERY_ACTIVE_SCAN,
                                       DEFAULT_DISCOVERY_WHITE_LIST );     
      }
      else
      {
        GAPCentralRole_CancelDiscovery();
      }
    }

      osal_start_timerEx( simpleBLETaskId, Auto_Scan, 5000 );
      return (events ^ Auto_Scan);

}
 
  // Discard unknown events
  return 0;

}


/*********************************************************************
 * @fn      simpleBLECentral_ProcessOSALMsg
 *
 * @brief   Process an incoming task message.
 *
 * @param   pMsg - message to process
 *
 * @return  none
 */
static void simpleBLECentral_ProcessOSALMsg( osal_event_hdr_t *pMsg )
{
  switch ( pMsg->event )
  {
    case KEY_CHANGE:
      simpleBLECentral_HandleKeys( ((keyChange_t *)pMsg)->state, ((keyChange_t *)pMsg)->keys );
      break;

    case GATT_MSG_EVENT:
      simpleBLECentralProcessGATTMsg( (gattMsgEvent_t *) pMsg );
      break;
  }
}

/*********************************************************************
 * @fn      simpleBLECentral_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
 */
uint8 gStatus;
static void simpleBLECentral_HandleKeys( uint8 shift, uint8 keys )
{
  (void)shift;  // Intentionally unreferenced parameter

  if ( keys & HAL_KEY_UP )
  {
    // Start or stop discovery
    SerialPrintString("  [KEY UP pressed!]\r\n");
    if ( simpleBLEState != BLE_STATE_CONNECTED )
    {
      if ( !simpleBLEScanning )
      {
        simpleBLEScanning = TRUE;
        simpleBLEScanRes = 0;
       
        LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 );
        SerialPrintString("Discovering...\r\n");
        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 )
  {
    SerialPrintString("  [KEY LEFT pressed!]\r\n");
    // 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 );
        SerialPrintValue( "Device", simpleBLEScanIdx + 1, 10);
        LCD_WRITE_STRING( bdAddr2Str( simpleBLEDevList[simpleBLEScanIdx].addr ),
                          HAL_LCD_LINE_2 );
        SerialPrintString((uint8*) bdAddr2Str( simpleBLEDevList[simpleBLEScanIdx].addr ));SerialPrintString("\r\n");
    }
  }

  if ( keys & HAL_KEY_RIGHT )
  {
    SerialPrintString("  [KEY RIGHT pressed!]\r\n");
    // 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;
    SerialPrintString("  [KEY CENTER pressed!]\r\n");
    // 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 );
        SerialPrintString("Connecting:");
        LCD_WRITE_STRING( bdAddr2Str( peerAddr ), HAL_LCD_LINE_2 );
        SerialPrintString((uint8*)bdAddr2Str( peerAddr));SerialPrintString("\r\n");
      }
    }
    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 );
      SerialPrintString("Disconnecting\r\n");
    }
  }
 
  if ( keys & HAL_KEY_DOWN )
  {
    SerialPrintString("  [KEY DOWN pressed!]\r\n");
    // 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 );
        SerialPrintString("RSSI Cancelled\r\n");
      }
    }
  }
}
  
/*********************************************************************
 * @fn      simpleBLECentralProcessGATTMsg
 *
 * @brief   Process GATT messages
 *
 * @return  none
 */
static void simpleBLECentralProcessGATTMsg( 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;
     
      LCD_WRITE_STRING_VALUE( "Read Error", status, 10, HAL_LCD_LINE_1 );
      SerialPrintValue("Read Error", status, 10);SerialPrintString("\r\n");
    }
    else
    {
      // After a successful read, display the read value
      uint8 valueRead = pMsg->msg.readRsp.value[0];

      LCD_WRITE_STRING_VALUE( "Read rsp:", valueRead, 10, HAL_LCD_LINE_1 );
      SerialPrintValue("Read rsp:", valueRead, 10);SerialPrintString("\r\n");
    }
   
    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;
     
      LCD_WRITE_STRING_VALUE( "Write Error", status, 10, HAL_LCD_LINE_1 );
      SerialPrintValue( "Write Error", status, 10);SerialPrintString("\r\n");
    }
    else
    {
      // After a succesful write, display the value that was written and increment value
      uint8 temp=simpleBLECharVal;
      LCD_WRITE_STRING_VALUE( "Write sent:", simpleBLECharVal, 10, HAL_LCD_LINE_1 );    
      SerialPrintValue( "Write sent:", temp, 10);SerialPrintString("\r\n");
    }
   
    simpleBLEProcedureInProgress = FALSE;   

  }
  else if ( simpleBLEDiscState != BLE_DISC_STATE_IDLE )
  {
    simpleBLEGATTDiscoveryEvent( pMsg );
  }
 
}



/*********************************************************************
 * @fn      simpleBLECentralRssiCB
 *
 * @brief   RSSI callback.
 *
 * @param   connHandle - connection handle
 * @param   rssi - RSSI
 *
 * @return  none
 */
static void simpleBLECentralRssiCB( uint16 connHandle, int8 rssi )
{
    LCD_WRITE_STRING_VALUE( "RSSI -dB:", (uint8) (-rssi), 10, HAL_LCD_LINE_1 );
    SerialPrintValue("RSSI -dB:", (uint8) (-rssi), 10);SerialPrintString("\r\n");
}

/*********************************************************************
 * @fn      simpleBLECentralEventCB
 *
 * @brief   Central event callback function.
 *
 * @param   pEvent - pointer to event structure
 *
 * @return  none
 */
static void simpleBLECentralEventCB( gapCentralRoleEvent_t *pEvent )
{
  switch ( pEvent->gap.opcode )
  {
    case GAP_DEVICE_INIT_DONE_EVENT: 
      {
        LCD_WRITE_STRING( "BLE Central", HAL_LCD_LINE_1 );
      //  SerialPrintString("BLE Central: ");
        LCD_WRITE_STRING( bdAddr2Str( pEvent->initDone.devAddr ),  HAL_LCD_LINE_2 );
    //    SerialPrintString((uint8*)bdAddr2Str( pEvent->initDone.devAddr ));SerialPrintString("\r\n");
      }
      break;

    case GAP_DEVICE_INFO_EVENT:
      {
        // if filtering device discovery results based on service UUID
        if ( DEFAULT_DEV_DISC_BY_SVC_UUID == FALSE )
        {

            simpleBLEAddDeviceInfo( (uint8*) (pEvent->deviceInfo.addr), (uint8*)(-(pEvent->deviceInfo.rssi)) );
          }
      }
      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 );
       // SerialPrintValue("Devices Found", simpleBLEScanRes,10);
        //SerialPrintString("\r\n");
       
        if ( simpleBLEScanRes > 0 )
        {
          LCD_WRITE_STRING( "<- To Select", HAL_LCD_LINE_2 );
          //SerialPrintString("<- To Select\r\n");
        }

        // initialize scan index to last device
        simpleBLEScanIdx = simpleBLEScanRes;

      }
      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 );
          SerialPrintString("Connected: ");
          LCD_WRITE_STRING( bdAddr2Str( pEvent->linkCmpl.devAddr ), HAL_LCD_LINE_2 );  
          SerialPrintString((uint8*) bdAddr2Str( pEvent->linkCmpl.devAddr ));SerialPrintString("\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 );
          SerialPrintString("Connect Failed: ");
          LCD_WRITE_STRING_VALUE( "Reason:", pEvent->gap.hdr.status, 10, HAL_LCD_LINE_2 );
          SerialPrintValue("Reason:",  pEvent->gap.hdr.status,10);
        }
      }
      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 );
        SerialPrintString("Disconnected: ");
        LCD_WRITE_STRING_VALUE( "Reason:", pEvent->linkTerminate.reason,
                                10, HAL_LCD_LINE_2 );
        SerialPrintValue("Reason:",  pEvent->linkTerminate.reason,10);
      }
      break;

    case GAP_LINK_PARAM_UPDATE_EVENT:
      {
        LCD_WRITE_STRING( "Param Update", HAL_LCD_LINE_1 );
        SerialPrintString("Param Update\r\n");
      }
      break;
     
    default:
      break;
  }
}

/*********************************************************************
 * @fn      pairStateCB
 *
 * @brief   Pairing state callback.
 *
 * @return  none
 */
static void simpleBLECentralPairStateCB( uint16 connHandle, uint8 state, uint8 status )
{
  if ( state == GAPBOND_PAIRING_STATE_STARTED )
  {
    LCD_WRITE_STRING( "Pairing started", HAL_LCD_LINE_1 );
  }
  else if ( state == GAPBOND_PAIRING_STATE_COMPLETE )
  {
    if ( status == SUCCESS )
    {
      LCD_WRITE_STRING( "Pairing success", HAL_LCD_LINE_1 );
    }
    else
    {
      LCD_WRITE_STRING_VALUE( "Pairing fail", status, 10, HAL_LCD_LINE_1 );
    }
  }
  else if ( state == GAPBOND_PAIRING_STATE_BONDED )
  {
    if ( status == SUCCESS )
    {
      LCD_WRITE_STRING( "Bonding success", HAL_LCD_LINE_1 );
    }
  }
}

/*********************************************************************
 * @fn      simpleBLECentralPasscodeCB
 *
 * @brief   Passcode callback.
 *
 * @return  none
 */
static void simpleBLECentralPasscodeCB( uint8 *deviceAddr, uint16 connectionHandle,
                                        uint8 uiInputs, uint8 uiOutputs )
{
#if (HAL_LCD == TRUE)

  uint32  passcode;
  uint8   str[7];

  // Create random passcode
  LL_Rand( ((uint8 *) &passcode), sizeof( uint32 ));
  passcode %= 1000000;
 
  // Display passcode to user
  if ( uiOutputs != 0 )
  {
    LCD_WRITE_STRING( "Passcode:",  HAL_LCD_LINE_1 );
    LCD_WRITE_STRING( (char *) _ltoa(passcode, str, 10),  HAL_LCD_LINE_2 );
  }
 
  // Send passcode response
  GAPBondMgr_PasscodeRsp( connectionHandle, SUCCESS, passcode );
#endif
}

/*********************************************************************
 * @fn      simpleBLECentralStartDiscovery
 *
 * @brief   Start service discovery.
 *
 * @return  none
 */
static void simpleBLECentralStartDiscovery( void )
{
  uint8 uuid[ATT_BT_UUID_SIZE] = { LO_UINT16(SIMPLEPROFILE_SERV_UUID),
                                   HI_UINT16(SIMPLEPROFILE_SERV_UUID) };
 
  // Initialize cached handles
  simpleBLESvcStartHdl = simpleBLESvcEndHdl = simpleBLECharHdl = 0;

  simpleBLEDiscState = BLE_DISC_STATE_SVC;
 
  // Discovery simple BLE service
  GATT_DiscPrimaryServiceByUUID( simpleBLEConnHandle,
                                 uuid,
                                 ATT_BT_UUID_SIZE,
                                 simpleBLETaskId );
}

/*********************************************************************
 * @fn      simpleBLEGATTDiscoveryEvent
 *
 * @brief   Process GATT discovery event
 *
 * @return  none
 */
static void simpleBLEGATTDiscoveryEvent( gattMsgEvent_t *pMsg )
{
  attReadByTypeReq_t req;
 
  if ( simpleBLEDiscState == BLE_DISC_STATE_SVC )
  {
    // Service found, store handles
    if ( pMsg->method == ATT_FIND_BY_TYPE_VALUE_RSP &&
         pMsg->msg.findByTypeValueRsp.numInfo > 0 )
    {
      simpleBLESvcStartHdl = pMsg->msg.findByTypeValueRsp.handlesInfo[0].handle;
      simpleBLESvcEndHdl = pMsg->msg.findByTypeValueRsp.handlesInfo[0].grpEndHandle;
    }
   
    // If procedure complete
    if ( ( pMsg->method == ATT_FIND_BY_TYPE_VALUE_RSP  &&
           pMsg->hdr.status == bleProcedureComplete ) ||
         ( pMsg->method == ATT_ERROR_RSP ) )
    {
      if ( simpleBLESvcStartHdl != 0 )
      {
        // Discover characteristic
        simpleBLEDiscState = BLE_DISC_STATE_CHAR;
       
        req.startHandle = simpleBLESvcStartHdl;
        req.endHandle = simpleBLESvcEndHdl;
        req.type.len = ATT_BT_UUID_SIZE;
        req.type.uuid[0] = LO_UINT16(SIMPLEPROFILE_CHAR1_UUID);
        req.type.uuid[1] = HI_UINT16(SIMPLEPROFILE_CHAR1_UUID);

        GATT_ReadUsingCharUUID( simpleBLEConnHandle, &req, simpleBLETaskId );
      }
    }
  }
  else if ( simpleBLEDiscState == BLE_DISC_STATE_CHAR )
  {
    // Characteristic found, store handle
    if ( pMsg->method == ATT_READ_BY_TYPE_RSP &&
         pMsg->msg.readByTypeRsp.numPairs > 0 )
    {
      simpleBLECharHdl = BUILD_UINT16( pMsg->msg.readByTypeRsp.dataList[0],
                                       pMsg->msg.readByTypeRsp.dataList[1] );
     
      LCD_WRITE_STRING( "Simple Svc Found", HAL_LCD_LINE_1 );
      SerialPrintString("Simple Svc Found\r\n");
      simpleBLEProcedureInProgress = FALSE;
    }
   
    simpleBLEDiscState = BLE_DISC_STATE_IDLE;
  }   
}
  
/*********************************************************************
 * @fn      simpleBLEFindSvcUuid
 *
 * @brief   Find a given UUID in an advertiser's service UUID list.
 *
 * @return  TRUE if service UUID found
 */
static bool simpleBLEFindSvcUuid( uint16 uuid, uint8 *pData, uint8 dataLen )
{
  uint8 adLen;
  uint8 adType;
  uint8 *pEnd;
 
  pEnd = pData + dataLen - 1;
 
  // While end of data not reached
  while ( pData < pEnd )
  {
    // Get length of next AD item
    adLen = *pData++;
    if ( adLen > 0 )
    {
      adType = *pData;
     
      // If AD type is for 16-bit service UUID
      if ( adType == GAP_ADTYPE_16BIT_MORE || adType == GAP_ADTYPE_16BIT_COMPLETE )
      {
        pData++;
        adLen--;
       
        // For each UUID in list
        while ( adLen >= 2 && pData < pEnd )
        {
          // Check for match
          if ( pData[0] == LO_UINT16(uuid) && pData[1] == HI_UINT16(uuid) )
          {
            // Match found
            return TRUE;
          }
         
          // Go to next
          pData += 2;
          adLen -= 2;
        }
       
        // Handle possible erroneous extra byte in UUID list
        if ( adLen == 1 )
        {
          pData++;
        }
      }
      else
      {
        // Go to next item
        pData += adLen;
      }
    }
  }
 
  // Match not found
  return FALSE;
}

//////////////這裡是因為在simpleBLEAddDeviceInfo寫sprintf(str, "%d", addrType);會有解不出來的bug，只好寫個str_format來做
int str_format( uint8 *addrType )
{

  int str;
   sprintf(str, "%d", addrType);
 
  return str;
}
////////////


/*********************************************************************
 * @fn      calculateAccuracy
 *
 * @brief   calculateRSSI to distance
 *
 * @return  none
 */
double calculateAccuracy( double txPower, double rssi )
{
       if (rssi == 0) {
           return -1.0; // if we cannot determine accuracy, return -1.
       }
       double ratio = rssi * 1.0 / txPower;
       if (ratio < 1.0) {
           return pow(ratio, 10);
       } else {
           double accuracy = (0.42093) * pow(ratio, 6.9476) + 0.54992;
           return accuracy;
       }

}

/*********************************************************************
 * @fn      simpleBLEAddDeviceInfo
 *
 * @brief   Add a device to the device discovery result list
 *
 * @return  none
 */
static void simpleBLEAddDeviceInfo( uint8 *pAddr, uint8 *addrType )
{
  uint8 i;
 
  // If result count not at max
  if ( simpleBLEScanRes < DEFAULT_MAX_SCAN_RES )
  {
    // Check if device is already in scan results
    for ( i = 0; i < simpleBLEScanRes; i++ )
    {
      if ( osal_memcmp( pAddr, simpleBLEDevList[i].addr , B_ADDR_LEN ) )
      {
        return;
      }
    }
   // if(strcmp(args->args[0].val, "MASTER") == 0)
    for (i =0; i < 5; i++){//比對id searchID這個
    if(strcmp((uint8*)bdAddr2Str(pAddr), searchID[i]) == 0){//比較使用者設定的id，是這個id才往上傳
     // SerialPrintValue("i:", i,10);
    GAPCentralRole_GetParameter(GAPCENTRALROLE_BD_ADDR, ownAddress);
    SerialPrintString("/");
    SerialPrintString(bdAddr2Str(ownAddress));
    SerialPrintString("/");
    SerialPrintString((uint8*) bdAddr2Str(pAddr));
    SerialPrintString("/");



    //sprintf(str, "%d", addrType);
    SerialPrintString("-");
    SerialPrintString((uint8*)str_format(addrType));
   
  //  SerialPrintString((uint8*) (str));
  //  SerialPrintValue("rssi:-", str,10);
    SerialPrintString("/");
    double a = calculateAccuracy( -55, -(str_format(addrType)) );
     sprintf(str, "%s", a);
   // SerialPrintString(a);
    SerialPrintString((uint8*)str);
    SerialPrintString("\"");
    SerialPrintString("\r\n");

    // Add addr to scan result list
    osal_memcpy( simpleBLEDevList[simpleBLEScanRes].addr, pAddr, B_ADDR_LEN );
  //  simpleBLEDevList[simpleBLEScanRes].addrType = addrType;
   
    // Increment scan result count
    simpleBLEScanRes++;
    }
  }
  //  SerialPrintString(searchID[0]);
  //  SerialPrintString("\r\n");
  }
}

  
/*********************************************************************
 * @fn      bdAddr2Str
 *
 * @brief   Convert Bluetooth address to string
 *
 * @return  none
 */
char *bdAddr2Str( uint8 *pAddr )
{
  uint8       i;
  char        hex[] = "0123456789ABCDEF";
  static char str[B_ADDR_STR_LEN];
  char        *pStr = str;
 
  *pStr++ = '0';
  *pStr++ = 'x';
 
  // Start from end of addr
  pAddr += B_ADDR_LEN;
 
  for ( i = B_ADDR_LEN; i > 0; i-- )
  {
    *pStr++ = hex[*--pAddr >> 4];
    *pStr++ = hex[*pAddr & 0x0F];
  }
 
  *pStr = 0;
 
  return str;
}

uint8 str2hex(uint8 *hex);
uint8 str2hex(uint8 *str)
{
  uint8 hex[] = "0123456789ABCDEF";
  uint8 i=0,h,l;
  for(i=0;i<16;i++){
    if(hex[i]==str[0])
      h=i;
    if(hex[i]==str[1])
      l=i;
  }
  return (h*16+l);
}
uint8 str_cmp(uint8 *p1,uint8 *p2,uint8 len);
uint8 str_cmp(uint8 *p1,uint8 *p2,uint8 len)
{
  uint8 i=0;
  while(i<len){
    if(p1[i]!=p2[i])
      return 1;
    i++;
  }
  return 0;
}
void CommondHandle(uint8 *pBuffer, uint16 length)
{
  if(length<2)
    return ;
  if(pBuffer[0]!='A' && pBuffer[1]!='T')
    return ;
  if(length <=4){
    SerialPrintString("OK\r\n");
    return ;
  }
 
  //if(pBuffer[0]=='G' && pBuffer[1]=='O')
  if(length>=5 && str_cmp(pBuffer+3,"GO",2)==0){
    //SerialPrintString("OK\r\n");
   // osal_start_timerEx( simpleBLETaskId, Auto_Scan, 2000 );
    osal_start_timerEx( simpleBLETaskId, Init_Dev, 2000 );
   
    return ;
  }
    
  if(length>=8 && str_cmp(pBuffer+3,"ROLE?",5)==0){
    SerialPrintString("Central\r\n");
    return ;
  }
  if(length>=7 && str_cmp(pBuffer+3,"SCAN",4)==0){
    simpleBLEScanning = TRUE;
    simpleBLEScanRes = 0;
   
    LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 );
    SerialPrintString("Discovering...\r\n");
    LCD_WRITE_STRING( "", HAL_LCD_LINE_2 );
   
    GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE,
                                   DEFAULT_DISCOVERY_ACTIVE_SCAN,
                                   DEFAULT_DISCOVERY_WHITE_LIST );
    return ;
  }
  if(length>=7 && str_cmp(pBuffer+3,"CON",3)==0){
    uint8 tmp=pBuffer[6]-48-1;
    if ( simpleBLEState == BLE_STATE_IDLE ){
      // if there is a scan result
      if ( simpleBLEScanRes > 0 )
      {
        uint8 addrType;
        uint8 *peerAddr;
        // connect to current device in scan result
        peerAddr = simpleBLEDevList[tmp].addr;
        addrType = simpleBLEDevList[tmp].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 );
        SerialPrintString("Connecting:");
        LCD_WRITE_STRING( bdAddr2Str( peerAddr ), HAL_LCD_LINE_2 );
        SerialPrintString((uint8*)bdAddr2Str( peerAddr));SerialPrintString("\r\n");
      }
    }
    return ;
     
  }
  if(length>=7 && str_cmp(pBuffer+3,"RSSI",4)==0){
    // 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 );
        SerialPrintString("RSSI Cancelled\r\n");
      }
    }
    return ;
  }
  if(length>=9 && str_cmp(pBuffer+3,"DISCON",6)==0){
    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 );
      SerialPrintString("Disconnecting\r\n");
    }
  }
  //AT+WRITE0xXX
  if(length>=12 && str_cmp(pBuffer+3,"WRITE",5)==0){
    //uint8 val=0;
    simpleBLECharVal=str2hex(pBuffer+10);
    if ( simpleBLEState == BLE_STATE_CONNECTED &&
              simpleBLECharHdl != 0 &&
              simpleBLEProcedureInProgress == FALSE )
    {
      uint8 status;

      // 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 );        


     
      if ( status == SUCCESS )
      {
        simpleBLEProcedureInProgress = TRUE;
      }
    }
    return ;
   
  }
}

/*********************************************************************
*********************************************************************/

好了，BLE說難不難，說簡單也不太簡單，因為要搞懂TI的協議

但我們就這樣完成了! 哈哈哈! 團結力量大!!!

本體笑而不答…




於

沒有留言:

張貼留言

訂閱： 張貼留言 (Atom)

FB設定搶先看的方式

設定搶先看的兩種方式 A1. 先到我家的日常粉絲團按下 …( 紅框處 ) A2. 按下追蹤中 ( 紅框處 ) A3. 按下搶先看 ( 紅框處 ) A4. 完成!!! 另一種方式 ...

  • 均方誤差(Mean square error，MSE)
    這次和一群好友一起挑戰百日機器學習 太久沒寫python，第一天腦袋轉不過來記錄一下 回歸常用的損失函數: 均方誤差(Mean square error，MSE) 是各測量值誤差的平方和取平均值的平方根（均方根誤差的平方） 使用sklearn from ...
  • 氫水!? 水素水!? 詐騙!? 讓72億人口驚呆了!?
    事情是這樣來的，由於長輩在我眼前表演且講解水素的神奇 這可是日本進口的舶來品 ( 撕下 貼紙，以免被吉) 水素可神奇的呢 ! Bla Bla Bla… 講了近半個小時 … 但為什麼會說是表演 !? 因為...
  • 使用Arduino Nano打造調光器
    鑒於調光器文章流量很高，可見大家對於此類產品有強烈的興趣 這次再寫一章使用 Arduini nano 實做，而且簡單的不得了，還不用怕被電到，文章是由 這篇 修正而來， 1-10V 調光技術 最後電路修正為下圖，整流器接上 LED 燈條 (LED 燈泡也同樣意...