Delta
This CLI (Command Line Interface) is based mbed-os. Both NNN50 and NQ620 are supported.
Embed:
(wiki syntax)
Show/hide line numbers
ble_cli.cpp
00001 /** 00002 * File: ble-cli.c 00003 * Description: BLE CLI commands used by all applications BLE of profile. 00004 * 00005 * Copyright 2014 by CYNTEC Corporation. All rights reserved. 00006 */ 00007 00008 #include "ble_cli.h" // All #include define in ble_cli.h 00009 00010 // Genral configuration parameters 00011 #define BLE_DEBUG 0 00012 #define MAX_DEVNAME_LEN 32 00013 #define CLI_FWVERION "DELTA_CLI_V1.18" 00014 00015 //0920 Silvia modify 00016 #if defined(TARGET_DELTA_DFBM_NQ620) 00017 #define MODULE_NAME "DFBM-NQ620" 00018 #else if defined(TARGET_DELTA_DFCM_NNN50) 00019 #define MODULE_NAME "DFCM-NNN50" 00020 #endif 00021 //0920 Silvia modify 00022 00023 // Advertising configuration parameters 00024 #define APP_ADV_INTERVAL 40 /**< The advertising interval (in units of ms). */ 00025 #define APP_ADV_TIMEOUT_IN_SECONDS 180 /**< The advertising timeout (in units of seconds). */ 00026 #define APP_ADV_INTERVAL_MAX 10240 // correspond to 10.24s 00027 #define APP_ADV_INTERVAL_MIN 20 // correspond to 20ms 00028 #define APP_ADV_TIMEOUT_LIMITED_MAX 16383 //1102 Silvia add 00029 #define APP_ADV_TIMEOUT_LIMITED_MIN 1 //1102 Silvia add 00030 #define APP_ADV_DATA_OFFSET 2 // Offset for Advertising Data. 00031 //#define ADVERTISING_LED_PIN_NO LED1 00032 00033 //1102 Silvia add 00034 //Scanning configuration parameters 00035 #define BLE_SCAN_INTERVAL_LIMITED_MAX 10240 00036 #define BLE_SCAN_INTERVAL_LIMITED_MIN 3 00037 #define BLE_SCAN_WINDOW_LIMITED_MAX 10240 00038 #define BLE_SCAN_WINDOW_LIMITED_MIN 3 00039 #define BLE_SCAN_TIMEOUT_LIMITED_MAX 16383 00040 #define BLE_SCAN_TIMEOUT_LIMITED_MIN 1 00041 00042 // Peripheral mode operation parameters 00043 #define CLI_SERVICE_MAX_NUM 10 00044 #define CLI_CHAR_MAX_NUM 10 00045 #define MAX_VALUE_LENGTH 20 00046 // Central mode operation parameters 00047 #define DEFAULT_SCAN_INTERVAL 500 00048 #define DEFAULT_SCAN_WINDOW 400 00049 #define DEFAULT_SCAN_TIMEOUT 0x0005 00050 #define BLE_MAX_ADDRESS_NUMBER 10 00051 #define TARGET_DEVNAME_LEN 30 00052 00053 typedef struct bufferGattChar { 00054 uint8_t props; 00055 UUID char_uuid; 00056 uint8_t value[MAX_VALUE_LENGTH]; 00057 uint16_t char_value_handle; 00058 uint16_t valueLength; 00059 } bufferGattChar_t; 00060 00061 typedef struct bufferGattService { 00062 UUID ser_uuid; 00063 bufferGattChar_t bufferGattChar[CLI_CHAR_MAX_NUM]; 00064 //uint16_t service_handle; 00065 } bufferGattService_t; 00066 00067 // gill 20150916 for scan 00068 typedef struct { 00069 const uint8_t * p_data; /**< Pointer to data. */ 00070 uint8_t data_len; /**< Length of data. */ 00071 } data_t; 00072 00073 /*************** General parameters**********************************/ 00074 bufferGattService_t bufferService[CLI_SERVICE_MAX_NUM]; /* save entry services */ 00075 static GattCharacteristic *charAry[CLI_SERVICE_MAX_NUM][CLI_CHAR_MAX_NUM]; 00076 DiscoveredService discoverServiceArr[CLI_SERVICE_MAX_NUM]; //Silvia add 00077 DiscoveredCharacteristic discoverCharArr[CLI_SERVICE_MAX_NUM][CLI_CHAR_MAX_NUM]; //Silvia add 00078 extern Serial console; 00079 BLE deltaBLE; //gill 0904 00080 extern const char* cyntecCommandErrorNames[]; 00081 00082 /*************** GATT Configuration parameters************************/ 00083 static bool connState = false; // gill 0904, define currently connecting state 00084 static uint8_t service_count=0; 00085 static uint8_t char_count=0; 00086 static uint8_t discoverService_count=0; //Silvia add 00087 static uint8_t discoverChar_count=0; //Silvia add 00088 static uint16_t test_conn_handle; //Connection handle, assign after trigger onConnectionCallback 00089 //extern bool advState; // currently no use 00090 static Gap::Address_t saveAddr[BLE_MAX_ADDRESS_NUMBER]; // check in advertisementCallback 00091 static uint8_t bleDevInd; 00092 //static const unsigned ADDR_LEN = BLEProtocol::ADDR_LEN; //Silvia add, Length (in octets) of the BLE MAC address 00093 static BLEProtocol::AddressBytes_t targetAddr; //Silvia add, For connect target device 00094 static char targetDevName[TARGET_DEVNAME_LEN]; // For connect target device 00095 //static char DEVICE_NAME[] = "nRF5x"; // default device name, same as defined in Gap.h 00096 static bool conn_action = false; // Gill add 20151015 00097 static ble_gap_addr_t m_peer_addr; 00098 //DigitalOut led1(p7); 00099 //DigitalOut led2(p13); 00100 DigitalOut BLEWriteInt(p13); // used in OnDataWritten() 00101 00102 /****************************************************** 00103 * Function Definitions 00104 ******************************************************/ 00105 00106 //DiscoveredCharacteristic ledCharacteristic; 00107 00108 void serviceDiscoveryCallback(const DiscoveredService *service) 00109 { 00110 console.printf("serviceDiscoveryCallback\r\n"); 00111 if (service->getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) { 00112 console.printf("S UUID-%x attrs[%u %u]\r\n", service->getUUID().getShortUUID(), service->getStartHandle(), service->getEndHandle()); 00113 } else { 00114 console.printf("S UUID-"); 00115 const uint8_t *longUUIDBytes = service->getUUID().getBaseUUID(); 00116 for (unsigned i = 0; i < UUID::LENGTH_OF_LONG_UUID; i++) { 00117 console.printf("%02x", longUUIDBytes[i]); 00118 } 00119 console.printf(" attrs[%u %u]\r\n", service->getStartHandle(), service->getEndHandle()); 00120 } 00121 00122 discoverServiceArr[discoverService_count] = *service; 00123 discoverService_count++; 00124 discoverChar_count = 0; 00125 } 00126 00127 void characteristicDiscoveryCallback(const DiscoveredCharacteristic *characteristicP) 00128 { 00129 //Silvia modify 00130 if (characteristicP->getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) { 00131 console.printf(" C UUID-%x valueAttr[%u] props[%x]\r\n", characteristicP->getUUID().getShortUUID(), characteristicP->getValueHandle(), (uint8_t)characteristicP->getProperties().broadcast()); 00132 } 00133 else { 00134 console.printf(" C UUID-"); 00135 const uint8_t *longUUIDBytes = characteristicP->getUUID().getBaseUUID(); 00136 for (unsigned i = (UUID::LENGTH_OF_LONG_UUID) - 1; i < UUID::LENGTH_OF_LONG_UUID; i--) { 00137 console.printf("%02x ", longUUIDBytes[i]); 00138 } 00139 console.printf(" valueAttr[%u] props[%x]\r\n", characteristicP->getValueHandle(), (uint8_t)characteristicP->getProperties().broadcast()); 00140 // uvCharacteristic = *characteristicP; 00141 } 00142 00143 discoverCharArr[discoverService_count - 1][discoverChar_count] = *characteristicP; 00144 discoverChar_count++; 00145 } 00146 void discoveryTerminationCallback(Gap::Handle_t connectionHandle) 00147 { 00148 console.printf("terminated SD for handle %u\r\n", connectionHandle); 00149 } 00150 00151 void onConnectionCallback(const Gap::ConnectionCallbackParams_t *params) 00152 { 00153 test_conn_handle = params->handle; 00154 connState = true; 00155 #if BLE_DEBUG 00156 console.printf("Connect: connState write to %d\r\n",connState); 00157 #endif 00158 //Silvia modify 00159 if (params->role == Gap::CENTRAL) { 00160 deltaBLE.gattClient().onServiceDiscoveryTermination(discoveryTerminationCallback); 00161 deltaBLE.gattClient().launchServiceDiscovery(test_conn_handle, serviceDiscoveryCallback, characteristicDiscoveryCallback); 00162 } 00163 //Silvia modify 00164 } 00165 00166 void onTimeoutCallback(Gap::TimeoutSource_t source) 00167 { 00168 //led1 = !led1; 00169 00170 //Silvia add 00171 switch (source) { 00172 case Gap::TIMEOUT_SRC_ADVERTISING: 00173 console.printf("Advertising timeout\r\n"); 00174 break; 00175 case Gap::TIMEOUT_SRC_SECURITY_REQUEST: 00176 console.printf("Security request timeout\r\n"); 00177 break; 00178 case Gap::TIMEOUT_SRC_SCAN: 00179 console.printf("Scanning timeout\r\n"); 00180 break; 00181 case Gap::TIMEOUT_SRC_CONN: 00182 console.printf("Connection timeout\r\n"); 00183 break; 00184 } 00185 //Silvia add 00186 } 00187 00188 void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params) 00189 { 00190 console.printf("Disconnected\r\n"); //Silvia add 00191 //console.printf("connState:%d\r\n",connState); 00192 //Gap::GapState_t->connected = 0; 00193 connState = false; 00194 } 00195 00196 void onDataWrittenCallback(const GattWriteCallbackParams *params) 00197 { 00198 #if BLE_DEBUG 00199 console.printf("onDataWritten\r\n"); 00200 #endif 00201 // trigger Host GPIO interrupt 00202 BLEWriteInt = !BLEWriteInt; 00203 BLEWriteInt = !BLEWriteInt; 00204 #if BLE_DEBUG 00205 console.printf("handle:%04X\r\n",params->handle); 00206 console.printf("conn_handle:%04X,writeOp:%d,offset:%04X\r\n",params->connHandle,params->writeOp,params->offset); 00207 #endif 00208 console.printf("w%d,",params->writeOp); 00209 const uint8_t* cpSerBaseUUID; 00210 const uint8_t* cpCharBaseUUID; 00211 00212 // Find specific handle Characteristic 00213 for ( int i = 0 ; i < service_count ; i++ ) { 00214 for (int j = 0 ; j < CLI_CHAR_MAX_NUM ; j++ ) { 00215 GattAttribute& tempValueAttr = charAry[i][j]->getValueAttribute(); 00216 if (tempValueAttr.getHandle()==params->handle) { 00217 #if BLE_DEBUG 00218 console.printf("ser_count,char_count:%d,%d\r\n",i,j); 00219 #endif 00220 if (bufferService[i].ser_uuid.shortOrLong()==0) 00221 console.printf("%04X",bufferService[i].ser_uuid.getShortUUID()); 00222 else { 00223 cpSerBaseUUID = bufferService[i].ser_uuid.getBaseUUID(); 00224 for (int i=15; i>=0; i--) { 00225 console.printf("%02X",cpSerBaseUUID[i]); 00226 } 00227 } 00228 console.printf(","); 00229 //console.printf("char_uuid:"); 00230 if (bufferService[i].bufferGattChar[j].char_uuid.shortOrLong()==0) // Short UUID 00231 console.printf("%04X",bufferService[i].bufferGattChar[j].char_uuid.getShortUUID()); 00232 else { // Long UUID 00233 cpCharBaseUUID = bufferService[i].bufferGattChar[j].char_uuid.getBaseUUID(); 00234 for (int i=15; i>=0; i--) { 00235 console.printf("%02X",cpCharBaseUUID[i]); 00236 } 00237 } 00238 console.printf(","); 00239 // update char value length 00240 bufferService[i].bufferGattChar[j].valueLength = params->len; 00241 break; 00242 } 00243 } 00244 } 00245 console.printf("%d,",params->len); 00246 for(int i=0; i<params->len; i++) { 00247 console.printf("%02X",params->data[i]); 00248 } 00249 console.printf(";\r\n"); 00250 } 00251 00252 static void cyntecPrintOk(void) 00253 { 00254 console.printf("\r\nOK\r\n\r\n"); 00255 } 00256 00257 static void cyntecPrintError(uint8_t errIdx) 00258 { 00259 console.printf("\r\nERROR;"); 00260 console.printf(cyntecCommandErrorNames[errIdx]); 00261 console.printf("\r\n\r\n"); 00262 } 00263 00264 static void cynAdvertiseStartCommand(void) 00265 { 00266 uint8_t argLen = 0; 00267 uint8_t *arg; 00268 uint16_t advInterval; 00269 uint16_t advTimeout; 00270 00271 switch (cyntecGetCommandTokenCnt()) { 00272 case 2: 00273 advInterval = APP_ADV_INTERVAL; 00274 advTimeout = APP_ADV_TIMEOUT_IN_SECONDS; 00275 break; 00276 case 3: 00277 /* arg1 is adv interval parameter */ 00278 arg = cyntecGetCommandArgument(0,&argLen); 00279 advInterval = cyntecAtoiUint16( arg, argLen ); 00280 advTimeout = APP_ADV_TIMEOUT_IN_SECONDS; 00281 break; 00282 case 4: 00283 arg = cyntecGetCommandArgument(0,&argLen); 00284 advInterval = cyntecAtoiUint16( arg, argLen ); 00285 arg = cyntecGetCommandArgument(1,&argLen); 00286 advTimeout = cyntecAtoiUint16( arg, argLen ); 00287 break; 00288 default: 00289 advInterval = APP_ADV_INTERVAL; 00290 advTimeout = APP_ADV_TIMEOUT_IN_SECONDS; 00291 break; 00292 } 00293 00294 if ( advInterval< APP_ADV_INTERVAL_MIN | advInterval> APP_ADV_INTERVAL_MAX | advTimeout < APP_ADV_TIMEOUT_LIMITED_MIN | advTimeout > APP_ADV_TIMEOUT_LIMITED_MAX ) { 00295 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_OUT_OF_RANGE); 00296 return; 00297 } 00298 #if BLE_DEBUG 00299 console.printf("advInterval:%d,advTimeout:%d",advInterval,advTimeout); 00300 #endif 00301 uint8_t bleName[BLE_GAP_DEVNAME_MAX_LEN] = {"\0"}; 00302 uint16_t bleLen = BLE_GAP_DEVNAME_MAX_LEN - APP_ADV_DATA_OFFSET; 00303 uint32_t err_code; 00304 00305 err_code = sd_ble_gap_device_name_get(&bleName[APP_ADV_DATA_OFFSET], &bleLen); 00306 #if BLE_DEBUG 00307 console.printf("%08X,%s\r\n",err_code,bleName+APP_ADV_DATA_OFFSET); 00308 #endif 00309 deltaBLE.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE); 00310 //deltaBLE.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)uuid16_list, sizeof(uuid16_list)); 00311 deltaBLE.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, bleName+APP_ADV_DATA_OFFSET, bleLen); 00312 deltaBLE.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED); 00313 deltaBLE.gap().setAdvertisingInterval(advInterval); /* minisecond. */ 00314 deltaBLE.gap().setAdvertisingTimeout(advTimeout); /* second. */ 00315 deltaBLE.gap().startAdvertising(); 00316 cyntecPrintOk(); 00317 //nrf_gpio_pin_set(ADVERTISING_LED_PIN_NO); 00318 } 00319 00320 /**@brief Function for stop advertising. 00321 */ 00322 static void cynAdvertiseStopCommand(void) 00323 { 00324 deltaBLE.gap().stopAdvertising(); 00325 cyntecPrintOk(); 00326 //nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO); 00327 } 00328 00329 //Silvia modify 00330 static void cynBLENameCommand(void) 00331 { 00332 uint8_t nameLen = 0; // Name char number, max is TARGET_DEVNAME_LEN 00333 uint8_t nameLenCharNum = 0; // Name length number is 1 or 2 00334 uint8_t *nameLeng = cyntecGetCommandArgument(0,&nameLenCharNum); 00335 nameLen = cyntecAtoi(nameLeng,nameLenCharNum); 00336 #ifdef BLE_DEUG 00337 console.printf("nameLenCharNum:%i\r\nOK;",nameLenCharNum); 00338 console.printf("nameLen:%i\r\nOK;",nameLen); 00339 #endif 00340 uint8_t bleName[BLE_GAP_DEVNAME_MAX_LEN] = {"\0"}; 00341 uint16_t bleLen = BLE_GAP_DEVNAME_MAX_LEN - APP_ADV_DATA_OFFSET; 00342 ble_gap_conn_sec_mode_t sec_mode; 00343 uint32_t err_code; 00344 uint8_t * argName2 = cyntecGetCommandTotalBuffer(); 00345 00346 // Get name string 00347 if (cyntecGetCommandTokenCnt() == 2) { 00348 err_code = sd_ble_gap_device_name_get(&bleName[APP_ADV_DATA_OFFSET], &bleLen); 00349 console.printf("\r\nOK;"); 00350 console.printf("%s",bleName+APP_ADV_DATA_OFFSET); 00351 console.printf(";\r\n"); 00352 } 00353 // Set name 00354 if (cyntecGetCommandTokenCnt() >= 3) { 00355 if (nameLen>TARGET_DEVNAME_LEN || nameLen <=0) 00356 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_OUT_OF_RANGE); 00357 BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode); 00358 err_code = sd_ble_gap_device_name_set(&sec_mode, 00359 (const uint8_t *) &argName2[11+nameLenCharNum], 00360 (uint16_t) nameLen);//(uint16_t) (cyntecGetTotalIndex()-11-nameLenCharNum)); 00361 if (err_code == NRF_SUCCESS) 00362 cyntecPrintOk(); 00363 else 00364 cyntecPrintError(CYNTEC_CMD_ERR_CALL_FAIL); 00365 #ifdef BLE_DEUG 00366 console.printf("LengNum:%i,string:%s,index:%i\r\n",nameLenCharNum,(const uint8_t *) &argName2[11+nameLenCharNum],cyntecGetTotalIndex()); 00367 #endif 00368 } 00369 } 00370 00371 static void cynBLEInfoCommand(void) 00372 { 00373 console.printf("\r\nOK;%s;%s\r\n\r\n", CLI_FWVERION, MODULE_NAME); 00374 } 00375 //Silvia modify 00376 00377 /**@brief Set the radio's transmit power. 00378 * 00379 * @param[in] tx_power Radio transmit power in dBm (accepted values are -40, -30, -20, -16, -12, -8, -4, 0, and 4 dBm). 00380 * 00381 * @note -40 dBm will not actually give -40 dBm, but will instead be remapped to -30 dBm. 00382 */ 00383 static void cynBLESetTxPowerCommand (void) 00384 { 00385 if (cyntecGetCommandTokenCnt() != 3) { 00386 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 00387 return; 00388 } 00389 uint32_t err_code; 00390 uint8_t txLen=0; 00391 uint8_t *arg = cyntecGetCommandArgument(0,&txLen); 00392 00393 bool inputSwitch = false; // if find matched case in TxPow, assign true 00394 00395 #if defined(TARGET_DELTA_DFBM_NQ620) 00396 const uint8_t NUM_TXPOW = 7; 00397 int8_t validTxPow[NUM_TXPOW] = {-20, -16, -12, -8, -4, 0, 4}; 00398 #else if defined(TARGET_DELTA_DFCM_NNN50) 00399 const uint8_t NUM_TXPOW = 9; 00400 int8_t validTxPow[NUM_TXPOW] = {-40, -30, -20, -16, -12, -8, -4, 0, 4}; 00401 #endif 00402 uint8_t i; 00403 int8_t setValue; 00404 00405 if ( arg != NULL ) { 00406 #if defined(TARGET_DELTA_DFBM_NQ620) 00407 setValue = atoi((const char *)arg); 00408 #else if defined(TARGET_DELTA_DFCM_NNN50) 00409 setValue = cyntecAtoInt(arg);//work around for NNN50 since somehow atoi doesn't work properly 00410 #endif 00411 for (i = 0; i < NUM_TXPOW; i++) { 00412 if (setValue == validTxPow[i]) { 00413 err_code = sd_ble_gap_tx_power_set(setValue); 00414 //APP_ERROR_CHECK(err_code); 00415 inputSwitch = true; 00416 break; 00417 } 00418 } 00419 00420 if ( inputSwitch ) 00421 cyntecPrintOk(); 00422 else 00423 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_OUT_OF_RANGE); 00424 00425 } 00426 clearBuffer(); // clear the commandState.buffer 00427 return; 00428 } 00429 00430 static void cynBLEAddressCommand(void) 00431 { 00432 if (cyntecGetCommandTokenCnt() == 3) { 00433 uint8_t argLen = 0; 00434 uint8_t *arg = cyntecGetCommandArgument(0, &argLen); 00435 uint32_t err_code; 00436 uint8_t addr,i; 00437 00438 /* should with "0x" + 12 len addr */ 00439 if (argLen == 14) { 00440 if (arg[0] != '0' || arg[1] != 'x') { 00441 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_SYNTAX_ERROR); 00442 return; 00443 } 00444 00445 m_peer_addr.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC; 00446 00447 for ( i = 1 ; i < 7 ; i++) { 00448 addr = cyntecArgToUint8(arg+2*i, 2); 00449 /* 5 - (i-1) */ 00450 m_peer_addr.addr[6-i] = addr; 00451 } 00452 00453 err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &m_peer_addr); 00454 //APP_ERROR_CHECK(err_code); 00455 00456 } else { //argLen != 14 00457 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_SYNTAX_ERROR); 00458 return; 00459 } 00460 00461 //#if BLE_DEBUG 00462 // uint8_t buf2[20]; 00463 // console.printf("\r\nSet BLE Address: "); 00464 // sprintf((char *)&buf2[0],(const char *)"[%02X %02X %02X %02X %02X %02X]", 00465 // m_peer_addr.addr[0], m_peer_addr.addr[1], m_peer_addr.addr[2], 00466 // m_peer_addr.addr[3], m_peer_addr.addr[4], m_peer_addr.addr[5]); 00467 // console.printf(buf2); 00468 //#endif 00469 00470 cyntecPrintOk(); 00471 } else if (cyntecGetCommandTokenCnt() == 2) { 00472 00473 uint32_t err_code; 00474 err_code = sd_ble_gap_address_get(&m_peer_addr); 00475 //APP_ERROR_CHECK(err_code); 00476 00477 // cyntecPrintOk(); 00478 00479 console.printf("OK;[%02X %02X %02X %02X %02X %02X];\r\n", 00480 m_peer_addr.addr[5], m_peer_addr.addr[4], m_peer_addr.addr[3], 00481 m_peer_addr.addr[2], m_peer_addr.addr[1], m_peer_addr.addr[0]); 00482 } else { //cyntecGetCommandTokenCnt() not equal to 2 or 3 00483 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 00484 } 00485 return; 00486 } 00487 00488 static uint32_t adv_report_parse(uint8_t type, data_t * p_advdata, data_t * p_typedata) 00489 { 00490 uint32_t index = 0; 00491 const uint8_t * p_data; 00492 00493 p_data = p_advdata->p_data; 00494 00495 while (index < p_advdata->data_len) { 00496 uint8_t field_length = p_data[index]; 00497 uint8_t field_type = p_data[index+1]; 00498 00499 if (field_type == type) { 00500 p_typedata->p_data = &p_data[index+2]; 00501 p_typedata->data_len = field_length-1; 00502 return NRF_SUCCESS; 00503 } 00504 index += field_length+1; 00505 } 00506 return NRF_ERROR_NOT_FOUND; 00507 } 00508 00509 void advertisementCallback(const Gap::AdvertisementCallbackParams_t *params) 00510 { 00511 //Silvia modify 00512 Gap::Address_t newAddr[6]; 00513 memcpy(newAddr,params->peerAddr,6); 00514 00515 if (conn_action == true) { 00516 conn_action = false; 00517 00518 if (memcmp(targetAddr,newAddr,6)==0) { 00519 deltaBLE.gap().connect(params->peerAddr, Gap::ADDR_TYPE_PUBLIC, NULL, NULL); //0920 Silvia change address type 00520 return; 00521 } 00522 } else { 00523 bool flagRepeat=false; 00524 00525 for(int i=0; i<BLE_MAX_ADDRESS_NUMBER; i++) { 00526 if (memcmp(newAddr,saveAddr[i],6)==0) { 00527 #if BLE_DEBUG 00528 console.printf("Repeated\r\n"); 00529 #endif 00530 flagRepeat = true; 00531 //return; 00532 } 00533 } 00534 00535 #if BLE_DEBUG 00536 console.printf("addr cmp result :%i\r\n",memcmp(newAddr,params->peerAddr,6)); 00537 console.printf("ADV data:%X,%i\r\n",&(params->advertisingData),params->advertisingDataLen); 00538 #endif 00539 data_t adv_data; 00540 data_t type_data; 00541 //Initialize advertisement report for parsing. 00542 adv_data.p_data = params->advertisingData; 00543 adv_data.data_len = params->advertisingDataLen; 00544 // Parsing Device Name 00545 uint32_t err_code = adv_report_parse(BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME, 00546 &adv_data, 00547 &type_data); 00548 #if BLE_DEBUG 00549 console.printf("error code:%X\r\n",err_code); 00550 console.printf("type_data.data_len:%i\r\n",type_data.data_len); 00551 #endif 00552 if (flagRepeat == false) { 00553 if (err_code == 0) { 00554 for (int i=0; i<type_data.data_len; i++) { 00555 console.printf("%c",type_data.p_data[i]); 00556 } 00557 //console.printf("\r\n"); 00558 } 00559 console.printf(",ADV,[%02X %02X %02X %02X %02X %02X],%d,%u\r\n",params->peerAddr[5], params->peerAddr[4], params->peerAddr[3], 00560 params->peerAddr[2], params->peerAddr[1], params->peerAddr[0],params->rssi,params->type); 00561 memcpy(saveAddr[bleDevInd],params->peerAddr,6); 00562 bleDevInd++; 00563 } 00564 } 00565 00566 /* 00567 Check short name, not implemented 00568 */ 00569 //else 00570 // { 00571 // uint32_t err_code_2 = adv_report_parse(BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME, 00572 // &adv_data, 00573 // &type_data); 00574 // console.printf("error code:%X\r\n",err_code_2); 00575 // console.printf("%i\r\n",type_data.data_len); 00576 // console.printf("%s\r\n",type_data.p_data); 00577 // 00578 // } 00579 } 00580 00581 00582 /**@brief Function to start scanning. 00583 */ 00584 static void scan_start(void) 00585 { 00586 memset(saveAddr,0,sizeof(saveAddr)); //Silvia add, Clear saving address set 00587 deltaBLE.gap().startScan(advertisementCallback); 00588 //APP_ERROR_CHECK(err_code); 00589 } 00590 00591 static void scan_stop(void) 00592 { 00593 deltaBLE.stopScan(); 00594 //APP_ERROR_CHECK(err_code); 00595 } 00596 00597 // gill 20150916 modify 00598 static void cynBLEScanCommand(void) 00599 { 00600 uint16_t setInterval = DEFAULT_SCAN_INTERVAL; 00601 uint16_t setWindow = DEFAULT_SCAN_WINDOW; 00602 uint16_t setTimeout = DEFAULT_SCAN_TIMEOUT; 00603 if (cyntecGetCommandTokenCnt()!= 2 & cyntecGetCommandTokenCnt()!= 5) { 00604 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 00605 return; 00606 } 00607 // If user input scan parameters, overwrite the default value 00608 if (cyntecGetCommandTokenCnt()== 5) { 00609 uint8_t argLen = 0; 00610 uint8_t *arg = cyntecGetCommandArgument(0,&argLen); 00611 setInterval = cyntecAtoiUint16( arg, argLen ); 00612 arg = cyntecGetCommandArgument(1,&argLen); 00613 setWindow = cyntecAtoiUint16( arg, argLen ); 00614 arg = cyntecGetCommandArgument(2,&argLen); 00615 setTimeout = cyntecAtoiUint16( arg, argLen ); 00616 } 00617 00618 //1102 Silvia modify 00619 if ( setInterval < BLE_SCAN_INTERVAL_LIMITED_MIN | setInterval > BLE_SCAN_INTERVAL_LIMITED_MAX | setWindow < BLE_SCAN_WINDOW_LIMITED_MIN | setWindow > BLE_SCAN_WINDOW_LIMITED_MAX | setTimeout > BLE_SCAN_TIMEOUT_LIMITED_MAX | (setTimeout < BLE_SCAN_TIMEOUT_LIMITED_MIN && setTimeout != 0 ) | (setInterval < setWindow)) { 00620 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_OUT_OF_RANGE); 00621 return; 00622 } 00623 00624 #if BLE_DEBUG 00625 console.printf("Interval:%d,Window:%d,timeout:%d\r\n",setInterval,setWindow,setTimeout); 00626 #endif 00627 // memset(saveAddr,0,sizeof(saveAddr)); // Clear saving address set 00628 //deltaBLE.gap().setScanParams(setInterval,setWindow,setTimeout,false); 00629 deltaBLE.gap().setScanInterval(setInterval); 00630 deltaBLE.gap().setScanWindow(setWindow); 00631 deltaBLE.gap().setScanTimeout(setTimeout); 00632 console.printf("Start Scan\r\n"); 00633 scan_start(); 00634 00635 } 00636 00637 static void cynBLEScanStopCommand(void) 00638 { 00639 console.printf("\r\nStop Scanning\r\n"); 00640 scan_stop(); 00641 } 00642 00643 static void cynBLEConnectCommand(void) 00644 { 00645 //Silvia modify for specific address 00646 if (cyntecGetCommandTokenCnt() != 3) { 00647 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 00648 return; 00649 } 00650 uint8_t argLen = 0; 00651 uint8_t *arg = cyntecGetCommandArgument(0, &argLen); 00652 ble_error_t err_code; 00653 uint8_t addr,i; 00654 00655 /* should with "0x" + 12 len addr */ 00656 if (argLen == 14) { 00657 if (arg[0] != '0' || arg[1] != 'x') { 00658 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_SYNTAX_ERROR); 00659 return; 00660 } 00661 memset(targetAddr,0,sizeof(targetAddr)); 00662 00663 for ( i = 1 ; i < 7 ; i++) { 00664 addr = cyntecArgToUint8(arg+2*i, 2); 00665 /* 5 - (i-1) */ 00666 targetAddr[6-i] = addr; 00667 } 00668 00669 for(int i=0; i<BLE_MAX_ADDRESS_NUMBER; i++) { 00670 if (memcmp(targetAddr,saveAddr[i],6)==0) { 00671 err_code = deltaBLE.gap().connect(targetAddr, Gap::ADDR_TYPE_PUBLIC, NULL, NULL); //0920 Silvia change address type 00672 00673 if (err_code != 0) { 00674 console.printf("Error:%d\r\n",err_code); 00675 } else { 00676 cyntecPrintOk(); 00677 } 00678 00679 return; 00680 } 00681 } 00682 00683 conn_action = true; 00684 scan_start(); 00685 } else { //argLen != 14 00686 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_SYNTAX_ERROR); 00687 return; 00688 } 00689 00690 //if (cyntecGetCommandTokenCnt() != 3) { 00691 // cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 00692 // return; 00693 // } 00694 // 00695 // uint8_t devNameLen = 0; 00696 // uint8_t *argDevName = cyntecGetCommandArgument(0, &devNameLen); 00697 // 00698 // //if ( argDevName != NULL ) { 00699 //// uint8_t i; 00700 //// for (i = 0; i < devNameLen; i++) { 00701 //// targetDevName[i] = argDevName[i]; 00702 //// } 00703 //// if (i < devNameLen) 00704 //// targetDevName[i] = '\0'; 00705 //// } 00706 // 00707 // memset( targetDevName , 0, TARGET_DEVNAME_LEN); 00708 // memcpy( targetDevName, argDevName, devNameLen); 00709 //#if BLE_DEBUG 00710 // console.printf("Search for device name:%s\r\n",argDevName); 00711 // console.printf("Target:%s\r\n",targetDevName); 00712 //#endif 00713 // conn_action = true; 00714 // scan_start(); 00715 00716 } 00717 00718 00719 static void cynBLEDisconnectCommand(void) 00720 { 00721 ble_error_t err_code; 00722 err_code = deltaBLE.gap().disconnect(Gap::REMOTE_USER_TERMINATED_CONNECTION); 00723 //err_code = sd_ble_gap_disconnect(test_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); 00724 //err_code = sd_ble_gap_connect_cancel(); // No function defined currently 00725 #if BLE_DEBUG 00726 console.printf("Error:%d\r\n",err_code); 00727 #endif 00728 cyntecPrintOk(); 00729 } 00730 00731 static void cynBLESystemOffCommand(void) 00732 { 00733 if (cyntecGetCommandTokenCnt() == 3) { 00734 uint8_t argLen = 0; 00735 uint8_t *arg = cyntecGetCommandArgument(0,&argLen); 00736 uint8_t gpioNum = cyntecAtoi( arg, argLen ); 00737 00738 if (gpioNum < 1 || gpioNum > 4) { 00739 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_OUT_OF_RANGE); 00740 return; 00741 } 00742 if (gpioNum == 1) 00743 nrf_gpio_cfg_sense_input(BUTTON1, NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_SENSE_LOW); 00744 #if defined(TARGET_DELTA_DFBM_NQ620)//Tsungta, temp use only, will be fix in NNN50 00745 else if (gpioNum == 2) 00746 nrf_gpio_cfg_sense_input(BUTTON2, NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_SENSE_LOW); 00747 else if (gpioNum == 3) 00748 nrf_gpio_cfg_sense_input(BUTTON3, NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_SENSE_LOW); 00749 else if (gpioNum == 4) 00750 nrf_gpio_cfg_sense_input(BUTTON4, NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_SENSE_LOW); 00751 #endif 00752 else { 00753 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_OUT_OF_RANGE); 00754 return; 00755 } 00756 cyntecPrintOk(); 00757 } else if (cyntecGetCommandTokenCnt() == 2) { 00758 /* default wake up pin is uart Rx pin */ 00759 nrf_gpio_cfg_sense_input(RX_PIN_NUMBER, 00760 NRF_GPIO_PIN_PULLUP, 00761 NRF_GPIO_PIN_SENSE_LOW); 00762 cyntecPrintOk(); 00763 } else { 00764 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 00765 return; 00766 } 00767 sd_power_system_off(); 00768 } 00769 00770 static void cynBLEGPIOCommand(void) 00771 { 00772 00773 if (cyntecGetCommandTokenCnt() == 4) { 00774 uint8_t argLen = 0; 00775 uint8_t *arg = cyntecGetCommandArgument(0,&argLen); 00776 uint8_t gpioNum = cyntecAtoi( arg, argLen ); 00777 00778 if (gpioNum < 1 || gpioNum > 4) { 00779 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_OUT_OF_RANGE); 00780 return; 00781 } 00782 00783 /* arg2 is set or clear */ 00784 uint8_t *action = cyntecGetCommandArgument(1,&argLen); 00785 00786 if ( cyntecStrCmp(action,(unsigned char *)"set",argLen) == 1 ) { 00787 if (gpioNum == 1) { DigitalOut CLI_LED(LED1); CLI_LED = 1; } 00788 else if (gpioNum == 2) { DigitalOut CLI_LED(LED2); CLI_LED = 1; } 00789 else if (gpioNum == 3) { DigitalOut CLI_LED(LED3); CLI_LED = 1; } 00790 else if (gpioNum == 4) { DigitalOut CLI_LED(LED4); CLI_LED = 1; } 00791 cyntecPrintOk(); 00792 } else if ( cyntecStrCmp(action,(unsigned char *)"clear",argLen) == 1 ) { 00793 if (gpioNum == 1) { DigitalOut CLI_LED(LED1); CLI_LED = 0; } 00794 else if (gpioNum == 2) { DigitalOut CLI_LED(LED2); CLI_LED = 0; } 00795 else if (gpioNum == 3) { DigitalOut CLI_LED(LED3); CLI_LED = 0; } 00796 else if (gpioNum == 4) { DigitalOut CLI_LED(LED4); CLI_LED = 0; } 00797 cyntecPrintOk(); 00798 } else { 00799 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_SYNTAX_ERROR); 00800 } 00801 } else { 00802 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 00803 } 00804 } 00805 00806 static void cynResetCommand(void) 00807 { 00808 cyntecPrintOk(); 00809 // On assert, the system can only recover with a reset. 00810 NVIC_SystemReset(); 00811 } 00812 00813 void triggerRead(const GattReadCallbackParams *response) 00814 { 00815 //if (response->handle == ledCharacteristic.getValueHandle()) { 00816 #if DUMP_READ_DATA 00817 printf("triggerToggledWrite: handle %u, offset %u, len %u\r\n", response->handle, response->offset, response->len); 00818 for (unsigned index = 0; index < response->len; index++) { 00819 printf("%c[%02x]", response->data[index], response->data[index]); 00820 } 00821 printf("\r\n"); 00822 #endif 00823 // 00824 // uint8_t toggledValue = response->data[0] ^ 0x1; 00825 // ledCharacteristic.write(1, &toggledValue); 00826 // } 00827 } 00828 00829 //Silvia modify 00830 void centralReadCallback(const GattReadCallbackParams *response) { 00831 // printf("centralReadCallback Handle: %d\r\n", response->handle); 00832 00833 for (unsigned index = 0; index < response->len; index++) { 00834 console.printf("[%02x]", response->data[index]); 00835 } 00836 console.printf("\r\n"); 00837 } 00838 00839 void centralWriteCallback(const GattWriteCallbackParams *response) { 00840 // printf("centralWriteCallback: %d\r\n", response->len); 00841 00842 for (unsigned index = 0; index < response->len; index++) { 00843 console.printf("[%02x]", response->data[index]); 00844 } 00845 console.printf("\r\n"); 00846 } 00847 00848 void centralHvxCallback(const GattHVXCallbackParams *response) { 00849 // printf("centralHvxCallback handle %u, type %02x, len %u\r\n", response->handle, response->type, response->len); 00850 for (unsigned index = 0; index < response->len; index++) { 00851 console.printf("[%02x]", response->data[index]); 00852 } 00853 console.printf("\r\n"); 00854 } 00855 //Silvia modify 00856 00857 static void cynBLEUpdateDataCommand(void) 00858 { 00859 if (cyntecGetCommandTokenCnt() != 6) { 00860 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 00861 return; 00862 } 00863 UUID buf_ser_uuid ; 00864 uint8_t bufferUuidVs[16]; 00865 UUID buf_char_uuid; 00866 uint8_t bufVal[MAX_VALUE_LENGTH] = {0}; 00867 uint16_t valueLen = 0; 00868 bool readmatchFlag = false; 00869 uint8_t argLen = 0; 00870 uint8_t *arg = cyntecGetCommandArgument(0,&argLen); 00871 00872 // Handle input parameter - Service UUID 00873 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 00874 buf_ser_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 00875 } 00876 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 00877 for (uint8_t i=0; i<16; i++) { 00878 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 00879 } 00880 buf_ser_uuid.setupLong(bufferUuidVs); 00881 } 00882 00883 // Handle input parameter - Characteristic UUID 00884 argLen = 0; 00885 arg = cyntecGetCommandArgument(1,&argLen); 00886 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 00887 buf_char_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 00888 } 00889 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 00890 for (uint8_t i=0; i<16; i++) { 00891 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 00892 } 00893 buf_char_uuid.setupLong(bufferUuidVs); 00894 } 00895 // Input Value Type 00896 arg = cyntecGetCommandArgument(2,&argLen); 00897 uint8_t type = *arg; 00898 //type = cyntecArgToUint8(arg,2); 00899 //printf("type:%d\r\n",type); 00900 if(type != '0' && type != '1') // Original Data 00901 { 00902 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_OUT_OF_RANGE); 00903 } 00904 00905 // Input value 00906 arg = cyntecGetCommandArgument(3,&argLen); 00907 if(type == '0') // Original Data 00908 { 00909 valueLen = argLen; 00910 memcpy(bufVal,arg,argLen); 00911 } 00912 if(type == '1') // Char Data 00913 { 00914 valueLen = (argLen-2)/2; // uint8_t to uint16_t transform 00915 for (int i=0 ; i < valueLen; i++) { 00916 bufVal[i] = cyntecArgToUint8(arg+2+2*i,2); 00917 } 00918 } 00919 #if BLE_DEBUG 00920 printf("type:%i,bufVal:",type); 00921 printf("valueLength:%i\r\n",valueLen); 00922 for (int i=0 ; i < valueLen; i++) { 00923 printf("%02X ",bufVal[i]); 00924 } 00925 printf("\r\n"); 00926 #endif 00927 00928 for ( int i = 0 ; i < service_count ; i++ ) { 00929 if ( (bufferService[i].ser_uuid == buf_ser_uuid) & (readmatchFlag == false)) { 00930 for (int j = 0 ; j < CLI_CHAR_MAX_NUM ; j++ ) { 00931 if (( bufferService[i].bufferGattChar[j].char_uuid == buf_char_uuid)& (readmatchFlag == false)) { 00932 GattAttribute& valueAttr = charAry[i][j]->getValueAttribute(); 00933 ble_error_t err; 00934 if (!connState) 00935 err = deltaBLE.gattServer().write(valueAttr.getHandle(),bufVal,valueLen,true); 00936 else 00937 err = deltaBLE.gattServer().write(test_conn_handle,valueAttr.getHandle(),bufVal,valueLen,false); 00938 00939 // update valueLength 00940 bufferService[i].bufferGattChar[j].valueLength = valueLen; 00941 00942 #if BLE_DEBUG 00943 console.printf("Write ERR:%i\r\n",err); 00944 printf("valueLen:%i\r\n",valueLen); 00945 #endif 00946 console.printf("\r\nOK;"); 00947 for (uint16_t n=0; n<valueLen; n++) { 00948 console.printf("%02X",bufVal[n]); 00949 } 00950 console.printf("\r\n"); 00951 readmatchFlag = true; 00952 return; 00953 } 00954 } 00955 } 00956 } 00957 // no matched case, can not read 00958 if (readmatchFlag == false) { 00959 cyntecPrintError(CYNTEC_CMD_ERR_NO_MATCHED_ARGUMENT); 00960 } 00961 } 00962 00963 static void cynBLEReadDataCommand(void) 00964 { 00965 //#if BLE_DEBUG 00966 // printf("Saved Char:\r\n"); 00967 // for (int i=0; i<service_count; i++) { 00968 // console.printf("ser_uuid:%04X",bufferService[service_count-1].ser_uuid.getShortUUID()); 00969 // for (int j=0; j<CLI_CHAR_MAX_NUM; j++) { 00970 // printf(" %i,char_uuid%04X,",j,bufferService[service_count-1].bufferGattChar[char_count-1].char_uuid.getShortUUID()); 00971 // printf("len%d,",bufferService[service_count-1].bufferGattChar[char_count-1].valueLength); 00972 // printf("val%02X;",bufferService[service_count-1].bufferGattChar[char_count-1].value[0]); 00973 // } 00974 // } 00975 // printf("\r\n"); 00976 //#endif 00977 if (cyntecGetCommandTokenCnt() != 4) { 00978 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 00979 return; 00980 } 00981 UUID buf_ser_uuid ; 00982 uint8_t bufferUuidVs[16]; 00983 UUID buf_char_uuid; 00984 uint8_t bufVal[MAX_VALUE_LENGTH] = {0}; 00985 uint16_t valueLen=0; 00986 //uint16_t * valueLenPtr; 00987 bool readmatchFlag = false; 00988 uint8_t argLen = 0; 00989 uint8_t *arg = cyntecGetCommandArgument(0,&argLen); 00990 00991 // Handle input parameter - Service UUID 00992 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 00993 buf_ser_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 00994 } 00995 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 00996 for (uint8_t i=0; i<16; i++) { 00997 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 00998 } 00999 buf_ser_uuid.setupLong(bufferUuidVs); 01000 } 01001 01002 // Handle input parameter - Characteristic UUID 01003 argLen = 0; 01004 arg = cyntecGetCommandArgument(1,&argLen); 01005 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 01006 buf_char_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01007 } 01008 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 01009 for (uint8_t i=0; i<16; i++) { 01010 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 01011 } 01012 buf_char_uuid.setupLong(bufferUuidVs); 01013 } 01014 01015 for ( int i = 0 ; i < service_count ; i++ ) { 01016 if ( (bufferService[i].ser_uuid == buf_ser_uuid) & (readmatchFlag == false)) { 01017 for (int j = 0 ; j < CLI_CHAR_MAX_NUM ; j++ ) { 01018 if (( bufferService[i].bufferGattChar[j].char_uuid == buf_char_uuid)& (readmatchFlag == false)) { 01019 GattAttribute& valueAttr = charAry[i][j]->getValueAttribute(); 01020 // valueLenPtr = valueAttr.getLengthPtr(); 01021 valueLen = bufferService[i].bufferGattChar[j].valueLength; 01022 uint16_t * valueLenPtr = &bufferService[i].bufferGattChar[j].valueLength; 01023 ble_error_t err = deltaBLE.gattServer().read(valueAttr.getHandle(),bufVal,valueLenPtr); 01024 #if BLE_DEBUG 01025 console.printf("Read ERR:%i\r\n",err); 01026 printf("valueLen:%i\r\n",valueLen); 01027 #endif 01028 console.printf("\r\nOK;"); 01029 console.printf("0x"); 01030 for (uint16_t n=0; n<valueLen; n++) { 01031 console.printf("%02X",bufVal[n]); 01032 } 01033 console.printf("\r\n"); 01034 readmatchFlag = true; 01035 return; 01036 } 01037 } 01038 } 01039 01040 } 01041 // no matched case, can not read 01042 if (readmatchFlag == false) { 01043 cyntecPrintError(CYNTEC_CMD_ERR_NO_MATCHED_ARGUMENT); 01044 } 01045 } 01046 01047 static void cynGattCharCommand(void) 01048 { 01049 uint8_t i; 01050 uint8_t valueLengthBuffer; 01051 01052 if (cyntecGetCommandTokenCnt() != 5) { 01053 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 01054 return; 01055 } 01056 01057 //Silvia add 01058 if (service_count == 0) { 01059 cyntecPrintError(CYNTEC_CMD_ERR_INVALID_STATE_TO_PERFORM_OPERATION); 01060 return; 01061 } 01062 //Silvia add 01063 01064 if (char_count >= CLI_CHAR_MAX_NUM) { 01065 cyntecPrintError(CYNTEC_CMD_ERR_CALL_FAIL); 01066 #if BLE_DEBUG 01067 console.printf("Error: char_count>CLI_CHAR_MAX_NUM\r\n"); 01068 #endif 01069 return; 01070 } 01071 01072 /* handle parameter - UUID */ 01073 /* Only support 16-bit or 128-bit UUID type */ 01074 uint8_t argLen = 0; 01075 uint8_t *arg = cyntecGetCommandArgument(0,&argLen); 01076 if (arg[0] != '0' || arg[1] != 'x' || (argLen != 6 && argLen != 34)) { 01077 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_SYNTAX_ERROR); 01078 return; 01079 } 01080 /* len: 6 => 0xXXXX */ 01081 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 01082 UUID::ShortUUIDBytes_t buffer_uuid_short; 01083 buffer_uuid_short = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01084 UUID uuid_short(buffer_uuid_short); 01085 bufferService[service_count-1].bufferGattChar[char_count].char_uuid = uuid_short; 01086 } 01087 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 01088 // Initialize LongUUIDBytes_t, then use default constructor to setupLong(longUUID) 01089 UUID::LongUUIDBytes_t buffer_uuid_vs; 01090 for (uint8_t i=0; i<16; i++) { 01091 buffer_uuid_vs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 01092 } 01093 bufferService[service_count-1].bufferGattChar[char_count].char_uuid.setupLong(buffer_uuid_vs); 01094 } 01095 01096 /* handle 3rd parameter - attribute mode */ 01097 argLen = 0; 01098 arg = cyntecGetCommandArgument(1,&argLen); 01099 if (arg[0] != '0' || arg[1] != 'x' ) { 01100 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_SYNTAX_ERROR); 01101 return; 01102 } 01103 uint8_t prop = cyntecArgToUint8(arg+2,2); 01104 01105 /* handle 4th parameter - attribute value */ 01106 argLen = 0; 01107 arg = cyntecGetCommandArgument(2,&argLen); 01108 if (arg[0] != '0' || arg[1] != 'x' | argLen%2 != 0) { 01109 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_SYNTAX_ERROR); 01110 return; 01111 } 01112 valueLengthBuffer = (argLen-2)/2; 01113 memset(bufferService[service_count-1].bufferGattChar[char_count].value,0,MAX_VALUE_LENGTH); 01114 for (i=0 ; i < (argLen-2)/2; i++) { 01115 bufferService[service_count-1].bufferGattChar[char_count].value[i] = cyntecArgToUint8(arg+2*(i+1), 2); 01116 //console.printf("%02X ",bufferService[service_count-1].bufferGattChar[char_count].value[i]); 01117 } 01118 #if BLE_DEBUG 01119 printf("prop:%02X\r\n",prop); 01120 console.printf("valueLengthBuffer:%d\r\n",valueLengthBuffer); 01121 console.printf("value:"); 01122 for (i=0 ; i < valueLengthBuffer; i++) { 01123 console.printf("%02X",bufferService[service_count-1].bufferGattChar[char_count].value[i]); 01124 } 01125 #endif 01126 bufferService[service_count-1].bufferGattChar[char_count].valueLength = valueLengthBuffer; 01127 bufferService[service_count-1].bufferGattChar[char_count].props = prop; 01128 //bufferService[service_count-1].bufferGattChar[char_count].char_value_handle = testHandle; 01129 01130 cyntecPrintOk(); 01131 char_count++; 01132 } 01133 01134 static void cynRegServiceCommand(void) 01135 { 01136 //GattCharacteristic *charAry[char_count]; 01137 //GattCharacteristic **charAry; 01138 //charAry = new GattCharacteristic *[char_count]; 01139 #if BLE_DEBUG 01140 console.printf("Current char_count:%d\r\n",char_count); 01141 console.printf("Current service_count:%d\r\n",service_count); 01142 #endif 01143 for (uint8_t i=0; i<char_count; i++) { 01144 charAry[service_count-1][i] = new GattCharacteristic ( 01145 bufferService[service_count-1].bufferGattChar[i].char_uuid, 01146 bufferService[service_count-1].bufferGattChar[i].value, 01147 bufferService[service_count-1].bufferGattChar[i].valueLength, 01148 MAX_VALUE_LENGTH, 01149 bufferService[service_count-1].bufferGattChar[i].props 01150 ); 01151 } 01152 GattService newService(bufferService[service_count-1].ser_uuid, charAry[service_count-1], char_count ); 01153 ble_error_t err_code; 01154 err_code = deltaBLE.addService(newService); 01155 if (err_code != 0) { 01156 #if BLE_DEBUG 01157 console.printf("addService error:%d\r\n",err_code); 01158 #endif 01159 cyntecPrintError(CYNTEC_CMD_ERR_CALL_FAIL); 01160 } else 01161 cyntecPrintOk(); 01162 //char_count = 0; // already did in gattService 01163 } 01164 01165 static void cynGattServiceCommand(void) 01166 { 01167 if (cyntecGetCommandTokenCnt() != 3) { 01168 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 01169 return; 01170 } 01171 /* handle first parameter - Service UUID */ 01172 uint8_t argLen = 0; 01173 uint8_t *arg = cyntecGetCommandArgument(0,&argLen); 01174 01175 /* Service uuid is 16 bits */ 01176 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 01177 UUID::ShortUUIDBytes_t buffer_uuid_short; 01178 buffer_uuid_short = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01179 #if BLE_DEBUG 01180 console.printf("%4X",buffer_uuid_short); 01181 #endif 01182 UUID uuid_short(buffer_uuid_short); 01183 bufferService[service_count].ser_uuid = uuid_short; 01184 //buffer_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01185 } 01186 01187 /* Service uuid is 128 bits */ 01188 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 01189 // Initialize LongUUIDBytes_t, then use default constructor to setupLong(longUUID) 01190 UUID::LongUUIDBytes_t buffer_uuid_vs; 01191 for (uint8_t i=0; i<16; i++) { 01192 buffer_uuid_vs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 01193 #if BLE_DEBUG 01194 console.printf("%2X ",buffer_uuid_vs[i]); 01195 #endif 01196 } 01197 UUID uuid_long(buffer_uuid_vs); 01198 bufferService[service_count].ser_uuid = uuid_long; 01199 } 01200 cyntecPrintOk(); 01201 service_count++; 01202 char_count = 0; 01203 } 01204 01205 /*Tsungta, @0913 modify to compatiable with mbed os 5.0*/ 01206 //#include <mbed-events/events.h> 01207 void onBleInitError(BLE &ble, ble_error_t error) 01208 { 01209 (void)ble; 01210 (void)error; 01211 /* Initialization error handling should go here */ 01212 } 01213 01214 void bleInitComplete(BLE::InitializationCompleteCallbackContext *params) 01215 { 01216 01217 } 01218 01219 static EventQueue eventQueue( 01220 /* event count */ 16 * /* event size */ 32 01221 ); 01222 01223 void scheduleBleEventsProcessing(BLE::OnEventsToProcessCallbackContext* context) { 01224 BLE &deltaBLE = BLE::Instance(); 01225 eventQueue.call(Callback<void()>(&deltaBLE, &BLE::processEvents)); 01226 } 01227 01228 void cynBLEInitCommand(void) 01229 { 01230 BLE &deltaBLE = BLE::Instance(); 01231 01232 deltaBLE.onEventsToProcess(scheduleBleEventsProcessing); 01233 deltaBLE.init(bleInitComplete); 01234 deltaBLE.onDisconnection(disconnectionCallback); 01235 deltaBLE.onConnection(onConnectionCallback); 01236 deltaBLE.onTimeout(onTimeoutCallback); 01237 deltaBLE.gattServer().onDataRead(triggerRead); 01238 01239 console.printf("\r\nOK;%s;%s\r\n\r\n", CLI_FWVERION, MODULE_NAME); //0920 Silvia add 01240 while (true) { 01241 eventQueue.dispatch(); 01242 } 01243 } 01244 /*Tsungta, end of @0913 modification*/ 01245 01246 //Silvia modify 01247 static void cynBLECenInitCommand(void) 01248 { 01249 deltaBLE.init(); 01250 deltaBLE.onDisconnection(disconnectionCallback); 01251 deltaBLE.onConnection(onConnectionCallback); 01252 deltaBLE.onTimeout(onTimeoutCallback); 01253 deltaBLE.gattClient().onDataRead(centralReadCallback); 01254 deltaBLE.gattClient().onDataWrite(centralWriteCallback); 01255 deltaBLE.gattClient().onHVX(centralHvxCallback); 01256 01257 cyntecPrintOk(); 01258 } 01259 01260 static void cynBLECenReadDataCommand(void) 01261 { 01262 if (cyntecGetCommandTokenCnt() != 4) { 01263 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 01264 return; 01265 } 01266 UUID buf_ser_uuid ; 01267 uint8_t bufferUuidVs[16]; 01268 UUID buf_char_uuid; 01269 bool readmatchFlag = false; 01270 uint8_t argLen = 0; 01271 uint8_t *arg = cyntecGetCommandArgument(0,&argLen); 01272 01273 // Handle input parameter - Service UUID 01274 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 01275 buf_ser_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01276 } 01277 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 01278 for (uint8_t i=0; i<16; i++) { 01279 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 01280 } 01281 buf_ser_uuid.setupLong(bufferUuidVs); 01282 } 01283 01284 // Handle input parameter - Characteristic UUID 01285 argLen = 0; 01286 arg = cyntecGetCommandArgument(1,&argLen); 01287 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 01288 buf_char_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01289 } 01290 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 01291 for (uint8_t i=0; i<16; i++) { 01292 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 01293 } 01294 buf_char_uuid.setupLong(bufferUuidVs); 01295 } 01296 01297 for ( int i = 0 ; i < discoverService_count ; i++ ) { 01298 UUID sUUID, cUUID; 01299 if (discoverServiceArr[i].getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) { 01300 sUUID = UUID(discoverServiceArr[i].getUUID().getShortUUID()); 01301 } else { 01302 const uint8_t *longUUIDBytes = discoverServiceArr[i].getUUID().getBaseUUID(); 01303 sUUID = UUID(longUUIDBytes); 01304 } 01305 if ((sUUID == buf_ser_uuid) & (readmatchFlag == false)) { 01306 for (int j = 0 ; j < CLI_CHAR_MAX_NUM ; j++ ) { 01307 if (discoverCharArr[i][j].getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) { 01308 cUUID = UUID(discoverCharArr[i][j].getUUID().getShortUUID()); 01309 } else { 01310 const uint8_t *longUUIDBytes = discoverCharArr[i][j].getUUID().getBaseUUID(); 01311 cUUID = UUID(longUUIDBytes); 01312 } 01313 if ((cUUID == buf_char_uuid) & (readmatchFlag == false)) { 01314 cyntecPrintOk(); 01315 discoverCharArr[i][j].read(); 01316 01317 readmatchFlag = true; 01318 return; 01319 } 01320 } 01321 } 01322 } 01323 01324 // no matched case, can not read 01325 if (readmatchFlag == false) { 01326 cyntecPrintError(CYNTEC_CMD_ERR_NO_MATCHED_ARGUMENT); 01327 } 01328 } 01329 01330 static void cynBLECenWriteDataCommand(void) { 01331 if (cyntecGetCommandTokenCnt() != 6) { 01332 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 01333 return; 01334 } 01335 UUID buf_ser_uuid ; 01336 uint8_t bufferUuidVs[16]; 01337 UUID buf_char_uuid; 01338 bool readmatchFlag = false; 01339 uint16_t valueLen = 0; 01340 uint8_t argLen = 0; 01341 uint8_t *arg = cyntecGetCommandArgument(0,&argLen); 01342 uint8_t bufVal[MAX_VALUE_LENGTH] = {0}; 01343 01344 // Handle input parameter - Service UUID 01345 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 01346 buf_ser_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01347 } 01348 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 01349 for (uint8_t i=0; i<16; i++) { 01350 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 01351 } 01352 buf_ser_uuid.setupLong(bufferUuidVs); 01353 } 01354 01355 // Handle input parameter - Characteristic UUID 01356 argLen = 0; 01357 arg = cyntecGetCommandArgument(1,&argLen); 01358 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 01359 buf_char_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01360 } 01361 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 01362 for (uint8_t i=0; i<16; i++) { 01363 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 01364 } 01365 buf_char_uuid.setupLong(bufferUuidVs); 01366 } 01367 01368 //// Input Value Type 01369 arg = cyntecGetCommandArgument(2,&argLen); 01370 uint8_t type = *arg; 01371 //type = cyntecArgToUint8(arg,2); 01372 // printf("type:%d\r\n",type); 01373 if(type != '0' && type != '1') { 01374 cyntecPrintError(CYNTEC_CMD_ERR_ARGUMENT_OUT_OF_RANGE); 01375 } 01376 01377 // Input value 01378 arg = cyntecGetCommandArgument(3,&argLen); 01379 if(type == '0') { 01380 valueLen = argLen; 01381 memcpy(bufVal,arg,argLen); 01382 } 01383 if(type == '1') { 01384 valueLen = (argLen-2)/2; // uint8_t to uint16_t transform 01385 for (int i=0 ; i < valueLen; i++) { 01386 bufVal[i] = cyntecArgToUint8(arg+2+2*i,2); 01387 } 01388 } 01389 #if BLE_DEBUG 01390 printf("type:%i,bufVal:",type); 01391 printf("valueLength:%i\r\n",valueLen); 01392 for (int i=0 ; i < valueLen; i++) { 01393 printf("%02X ",bufVal[i]); 01394 } 01395 printf("\r\n"); 01396 #endif 01397 01398 for ( int i = 0 ; i < discoverService_count ; i++ ) { 01399 UUID sUUID, cUUID; 01400 if (discoverServiceArr[i].getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) { 01401 sUUID = UUID(discoverServiceArr[i].getUUID().getShortUUID()); 01402 } else { 01403 const uint8_t *longUUIDBytes = discoverServiceArr[i].getUUID().getBaseUUID(); 01404 sUUID = UUID(longUUIDBytes); 01405 } 01406 if ((sUUID == buf_ser_uuid) & (readmatchFlag == false)) { 01407 for (int j = 0 ; j < CLI_CHAR_MAX_NUM ; j++ ) { 01408 if (discoverCharArr[i][j].getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) { 01409 cUUID = UUID(discoverCharArr[i][j].getUUID().getShortUUID()); 01410 } else { 01411 const uint8_t *longUUIDBytes = discoverCharArr[i][j].getUUID().getBaseUUID(); 01412 cUUID = UUID(longUUIDBytes); 01413 } 01414 if ((cUUID == buf_char_uuid) & (readmatchFlag == false)) { 01415 console.printf("OK;"); 01416 for (int i=0 ; i < valueLen; i++) { 01417 console.printf("%02X",bufVal[i]); 01418 } 01419 console.printf("\r\n"); 01420 deltaBLE.gattClient().write(GattClient::GATT_OP_WRITE_REQ, discoverCharArr[i][j].getConnectionHandle(), discoverCharArr[i][j].getValueHandle(), valueLen, bufVal); 01421 readmatchFlag = true; 01422 return; 01423 } 01424 } 01425 } 01426 } 01427 01428 // no matched case, can not read 01429 if (readmatchFlag == false) { 01430 cyntecPrintError(CYNTEC_CMD_ERR_NO_MATCHED_ARGUMENT); 01431 } 01432 } 01433 01434 static void cynBLECenEnNotifyCommand(void) 01435 { 01436 if (cyntecGetCommandTokenCnt() != 4) { 01437 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 01438 return; 01439 } 01440 UUID buf_ser_uuid ; 01441 uint8_t bufferUuidVs[16]; 01442 UUID buf_char_uuid; 01443 bool readmatchFlag = false; 01444 uint8_t argLen = 0; 01445 uint8_t *arg = cyntecGetCommandArgument(0,&argLen); 01446 01447 // Handle input parameter - Service UUID 01448 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 01449 buf_ser_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01450 } 01451 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 01452 for (uint8_t i=0; i<16; i++) { 01453 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 01454 } 01455 buf_ser_uuid.setupLong(bufferUuidVs); 01456 } 01457 01458 // Handle input parameter - Characteristic UUID 01459 argLen = 0; 01460 arg = cyntecGetCommandArgument(1,&argLen); 01461 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 01462 buf_char_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01463 } 01464 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 01465 for (uint8_t i=0; i<16; i++) { 01466 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 01467 } 01468 buf_char_uuid.setupLong(bufferUuidVs); 01469 } 01470 01471 for ( int i = 0 ; i < discoverService_count ; i++ ) { 01472 UUID sUUID, cUUID; 01473 if (discoverServiceArr[i].getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) { 01474 sUUID = UUID(discoverServiceArr[i].getUUID().getShortUUID()); 01475 } else { 01476 const uint8_t *longUUIDBytes = discoverServiceArr[i].getUUID().getBaseUUID(); 01477 sUUID = UUID(longUUIDBytes); 01478 } 01479 if ((sUUID == buf_ser_uuid) & (readmatchFlag == false)) { 01480 for (int j = 0 ; j < CLI_CHAR_MAX_NUM ; j++ ) { 01481 if (discoverCharArr[i][j].getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) { 01482 cUUID = UUID(discoverCharArr[i][j].getUUID().getShortUUID()); 01483 } else { 01484 const uint8_t *longUUIDBytes = discoverCharArr[i][j].getUUID().getBaseUUID(); 01485 cUUID = UUID(longUUIDBytes); 01486 } 01487 if ((cUUID == buf_char_uuid) & (readmatchFlag == false)) { 01488 cyntecPrintOk(); 01489 uint16_t value = BLE_HVX_NOTIFICATION; 01490 deltaBLE.gattClient().write(GattClient::GATT_OP_WRITE_REQ, discoverCharArr[i][j].getConnectionHandle(), discoverCharArr[i][j].getValueHandle() + 1, 2, (uint8_t *)&value); 01491 readmatchFlag = true; 01492 return; 01493 } 01494 } 01495 } 01496 } 01497 01498 // no matched case, can not read 01499 if (readmatchFlag == false) { 01500 cyntecPrintError(CYNTEC_CMD_ERR_NO_MATCHED_ARGUMENT); 01501 } 01502 } 01503 01504 static void cynBLECenDisNotifyCommand(void) { 01505 if (cyntecGetCommandTokenCnt() != 4) { 01506 cyntecPrintError(CYNTEC_CMD_ERR_WRONG_NUMBER_OF_ARGUMENTS); 01507 return; 01508 } 01509 UUID buf_ser_uuid ; 01510 uint8_t bufferUuidVs[16]; 01511 UUID buf_char_uuid; 01512 bool readmatchFlag = false; 01513 uint8_t argLen = 0; 01514 uint8_t *arg = cyntecGetCommandArgument(0,&argLen); 01515 01516 // Handle input parameter - Service UUID 01517 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 01518 buf_ser_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01519 } 01520 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 01521 for (uint8_t i=0; i<16; i++) { 01522 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 01523 } 01524 buf_ser_uuid.setupLong(bufferUuidVs); 01525 } 01526 01527 // Handle input parameter - Characteristic UUID 01528 argLen = 0; 01529 arg = cyntecGetCommandArgument(1,&argLen); 01530 if ( argLen == 6 && arg[0] == '0' && arg[1] == 'x') { 01531 buf_char_uuid = cyntecArgToUint16( (arg + 2), (argLen - 2)); 01532 } 01533 if ( argLen == 34 && arg[0] == '0' && arg[1] == 'x' ) { 01534 for (uint8_t i=0; i<16; i++) { 01535 bufferUuidVs[i] = cyntecArgToUint8( (arg + 2+2*i), 2); 01536 } 01537 buf_char_uuid.setupLong(bufferUuidVs); 01538 } 01539 01540 for ( int i = 0 ; i < discoverService_count ; i++ ) { 01541 UUID sUUID, cUUID; 01542 if (discoverServiceArr[i].getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) { 01543 sUUID = UUID(discoverServiceArr[i].getUUID().getShortUUID()); 01544 } else { 01545 const uint8_t *longUUIDBytes = discoverServiceArr[i].getUUID().getBaseUUID(); 01546 sUUID = UUID(longUUIDBytes); 01547 } 01548 if ((sUUID == buf_ser_uuid) & (readmatchFlag == false)) { 01549 for (int j = 0 ; j < CLI_CHAR_MAX_NUM ; j++ ) { 01550 if (discoverCharArr[i][j].getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) { 01551 cUUID = UUID(discoverCharArr[i][j].getUUID().getShortUUID()); 01552 } else { 01553 const uint8_t *longUUIDBytes = discoverCharArr[i][j].getUUID().getBaseUUID(); 01554 cUUID = UUID(longUUIDBytes); 01555 } 01556 if ((cUUID == buf_char_uuid) & (readmatchFlag == false)) { 01557 cyntecPrintOk(); 01558 uint16_t value = 0x00; 01559 deltaBLE.gattClient().write(GattClient::GATT_OP_WRITE_REQ, discoverCharArr[i][j].getConnectionHandle(), discoverCharArr[i][j].getValueHandle() + 1, 2, (uint8_t *)&value); 01560 readmatchFlag = true; 01561 return; 01562 } 01563 } 01564 } 01565 } 01566 01567 // no matched case, can not read 01568 if (readmatchFlag == false) { 01569 cyntecPrintError(CYNTEC_CMD_ERR_NO_MATCHED_ARGUMENT); 01570 } 01571 } 01572 //Silvia modify 01573 01574 static void cynBLEDataIntCommand(void) 01575 { 01576 cyntecPrintOk(); 01577 deltaBLE.gattServer().onDataWritten().add(onDataWrittenCallback); 01578 } 01579 static void cynBLEDisDataIntCommand(void) 01580 { 01581 cyntecPrintOk(); 01582 deltaBLE.gattServer().onDataWritten().detach(onDataWrittenCallback); 01583 } 01584 01585 #if BLE_DEBUG 01586 static void cynBLETestCommand(void) 01587 { 01588 // gill test 1021 01589 uint8_t bufVal[20] = {0}; 01590 //uint8_t valWrite[2] = {0x22,0x33}; 01591 //uint16_t bufhandle = 0x0001; 01592 //uint8_t valRead[2] = {0,0}; 01593 01594 // uint16_t handle = charAry[0][0]->getValueHandle(); // No used? 01595 GattAttribute& valueAttr = charAry[0][0]->getValueAttribute(); 01596 //valueAttr.setHandle(bufhandle); 01597 console.printf("Handle:%04X ",valueAttr.getHandle()); 01598 console.printf("UUID:%04X ",valueAttr.getUUID().getShortUUID()); 01599 01600 uint16_t* valueLenPtr = valueAttr.getLengthPtr(); 01601 deltaBLE.gattServer().read(valueAttr.getHandle(),bufVal,valueLenPtr); 01602 console.printf("gatt val[0][1]:%02X %02X\r\n",bufVal[0],bufVal[1]); 01603 } 01604 #endif 01605 01606 CyntecCommandEntry bleCommandSets[] = { 01607 // General 01608 #if BLE_DEBUG 01609 {"TEST", cynBLETestCommand, NULL, "test"}, 01610 #endif 01611 // 01612 #if SIMPLE_CMD_NAME 01613 //{"INT", cynBLEInitCommand, NULL, "Init BLE stack"},//Tsungta, INT is called in main.cpp 01614 {"GIO", cynBLEGPIOCommand, NULL, "Config gpio, Usage: <GPIO NO> <set|clear>"}, 01615 {"SLP", cynBLESystemOffCommand, NULL, "System off mode, Usage: <GPIO NO>"}, 01616 {"RST", cynResetCommand, NULL, "Soft reset"}, 01617 {"INF", cynBLEInfoCommand, NULL, "Get module information"}, 01618 {"POW", cynBLESetTxPowerCommand, NULL, "Set BLE tx power, Usage: <TX POWER>"}, 01619 {"NAM", cynBLENameCommand, NULL, "Set/Get friendly for BLE module, Usage: <LENGTH> <NAME>"}, 01620 // GATT 01621 {"GRS", cynRegServiceCommand, NULL, "Register standby service"}, 01622 {"GAC", cynGattCharCommand, NULL, "Set SIG defined characteristic or Create your own,Usage: <CHAR UUID> <PROPS> <VALUE>"}, 01623 {"GAS", cynGattServiceCommand, NULL, "Set SIG defined service or Create your own,Usage: <SERVICE UUID>"}, 01624 {"ADS", cynAdvertiseStartCommand, NULL, "Start broadcast advertise packet,Usage: <INTERVAL> <WINDOW>"}, 01625 {"ADP", cynAdvertiseStopCommand, NULL, "Stop broadcast advertise packet"}, 01626 {"SCS", cynBLEScanCommand, NULL, "Start to scan BLE device, Usage: <INTERVAL> <WINDOW> <TIMEOUT>"}, 01627 {"SCP", cynBLEScanStopCommand, NULL, "Stop to scan BLE device"}, 01628 {"CON", cynBLEConnectCommand, NULL, "Connect to specific BLE device by Device Address, Usage: <ADDR>"}, 01629 {"DCN", cynBLEDisconnectCommand, NULL, "Disconnection"}, 01630 {"ADR", cynBLEAddressCommand, NULL, "Set/Get Bluetooth address, Usage: <ADDR>"}, 01631 {"WRT", cynBLEUpdateDataCommand, NULL, "Update value of specific characteristics, Usage: <SERVICE UUID> <CHAR UUID> <TYPE> <VALUE>"}, 01632 {"RED", cynBLEReadDataCommand, NULL, "Read value of specific characteristics, Usage: <SERVICE UUID> <CHAR UUID>"}, 01633 {"EDI", cynBLEDataIntCommand, NULL, "Trigger remote write detection, give interrupt to Host."}, 01634 {"DDI", cynBLEDisDataIntCommand, NULL, "Disable remote write detection."}, 01635 //Silvia add BLE central commands 01636 {"CIN", cynBLECenInitCommand, NULL, "Init BLE Central stack"}, 01637 {"CRD", cynBLECenReadDataCommand, NULL, "BLE Central read value of specific characteristics, Usage: <SERVICE UUID> <CHAR UUID>"}, 01638 {"CWD", cynBLECenWriteDataCommand, NULL, "BLE Central write value to specific characteristics, Usage: <SERVICE UUID> <CHAR UUID> <TYPE> <VALUE>"}, 01639 {"CEN", cynBLECenEnNotifyCommand, NULL, "BLE Central enable notification of specific characteristics, Usage: <SERVICE UUID> <CHAR UUID>"}, 01640 {"CDN", cynBLECenDisNotifyCommand, NULL, "BLE Central disable notification of specific characteristics, Usage: <SERVICE UUID> <CHAR UUID>"}, 01641 {NULL, NULL, NULL, NULL}, 01642 #else 01643 //{"init", cynBLEInitCommand, NULL, "Init BLE stack"},//Tsungta, init is called in main.cpp 01644 {"gpio", cynBLEGPIOCommand, NULL, "Config gpio, Usage: <GPIO NO> <set|clear>"}, 01645 {"sleep", cynBLESystemOffCommand, NULL, "System off mode, Usage: <GPIO NO>"}, 01646 {"reset", cynResetCommand, NULL, "Soft reset"}, 01647 {"info", cynBLEInfoCommand, NULL, "Get module information"}, 01648 {"txPow", cynBLESetTxPowerCommand, NULL, "Set BLE tx power, Usage: <TX POWER>"}, 01649 {"name", cynBLENameCommand, NULL, "Set/Get friendly for BLE module, Usage: <LENGTH> <NAME>"}, 01650 // GATT 01651 {"regService", cynRegServiceCommand, NULL, "Register standby service"}, 01652 {"gattChar", cynGattCharCommand, NULL, "Set SIG defined characteristic or Create your own,Usage: <CHAR UUID> <PROPS> <VALUE>"}, 01653 {"gattService", cynGattServiceCommand, NULL, "Set SIG defined service or Create your own,Usage: <SERVICE UUID>"}, 01654 {"advStart", cynAdvertiseStartCommand, NULL, "Start broadcast advertise packet,Usage: <INTERVAL> <WINDOW>"}, 01655 {"advStop", cynAdvertiseStopCommand, NULL, "Stop broadcast advertise packet"}, 01656 {"scanStart", cynBLEScanCommand, NULL, "Start to scan BLE device, Usage: <INTERVAL> <WINDOW> <TIMEOUT>"}, //BLE central 01657 {"scanStop", cynBLEScanStopCommand, NULL, "Stop to scan BLE device"}, //BLE central 01658 {"connect", cynBLEConnectCommand, NULL, "Connect to specific BLE device by Device Address, Usage: <ADDR>"}, //Silvia modify, BLE central 01659 {"disconn", cynBLEDisconnectCommand, NULL, "Disconnection, Usage: cynb disconn"}, 01660 {"bleAddr", cynBLEAddressCommand, NULL, "Set/Get Bluetooth address, Usage: <ADDR>"}, 01661 {"update", cynBLEUpdateDataCommand, NULL, "Update value of specific characteristics, Usage: <SERVICE UUID> <CHAR UUID> <TYPE> <VALUE>"}, 01662 {"readData", cynBLEReadDataCommand, NULL, "Read value of specific characteristics, Usage: <SERVICE UUID> <CHAR UUID>"}, 01663 {"enInt", cynBLEDataIntCommand, NULL, "Trigger remote write detection, give interrupt to Host."}, 01664 {"disInt", cynBLEDisDataIntCommand, NULL, "Disable remote write detection."}, 01665 //Silvia add BLE central commands 01666 {"initBleCen", cynBLECenInitCommand, NULL, "Init BLE Central stack"}, 01667 {"cenReadData", cynBLECenReadDataCommand, NULL, "BLE Central read value of specific characteristics, Usage: <SERVICE UUID> <CHAR UUID>"}, 01668 {"cenWriteData", cynBLECenWriteDataCommand, NULL, "BLE Central write value to specific characteristics, Usage: <SERVICE UUID> <CHAR UUID> <TYPE> <VALUE>"}, 01669 {"cenEnNotify", cynBLECenEnNotifyCommand, NULL, "BLE Central enable notification of specific characteristics, Usage: <SERVICE UUID> <CHAR UUID>"}, 01670 {"cenDisNotify", cynBLECenDisNotifyCommand, NULL, "BLE Central disable notification of specific characteristics, Usage: <SERVICE UUID> <CHAR UUID>"}, 01671 {NULL, NULL, NULL, NULL}, 01672 #endif 01673 };
Generated on Tue Jul 12 2022 21:48:15 by
1.7.2