static void run() { ESP_LOGD(LOG_TAG, "MLE-15 sample starting"); BLEDevice::init(""); BLEClient* pClient = BLEDevice::createClient(); pClient->connect(BLEAddress("ff:ff:45:19:14:80")); BLERemoteService* pRemoteService = pClient->getService(serviceUUID); if (pRemoteService == nullptr) { ESP_LOGD(LOG_TAG, "Failed to find our service UUID: %s", serviceUUID.toString().c_str()); return; } BLERemoteCharacteristic* pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID); if (pRemoteCharacteristic == nullptr) { ESP_LOGD(LOG_TAG, "Failed to find our characteristic UUID: %s", charUUID.toString().c_str()); return; } pRemoteCharacteristic->writeValue((uint8_t)1); //BLEClient *pClient = BLE::createClient(); //pClient->setClientCallbacks(new MyClientCallbacks()); //pClient->connect(BLEAddress("00:00:00:00:00:00")); }
void run(void *data) { BLEAddress* pAddress = (BLEAddress *)data; BLEClient* pClient = BLEDevice::createClient(); pClient->connect(*pAddress); pClient->getServices(); BLERemoteService* pRemoteService = pClient->getService(serviceUUID); if (pRemoteService == nullptr) { ESP_LOGD(LOG_TAG, "Failed to find our service UUID: %s", serviceUUID.toString().c_str()); return; } pRemoteService->getCharacteristics(); BLERemoteCharacteristic* pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID); if (pRemoteCharacteristic == nullptr) { ESP_LOGD(LOG_TAG, "Failed to find our characteristic UUID: %s", charUUID.toString().c_str()); return; } pRemoteCharacteristic->readValue(); pRemoteCharacteristic->writeValue("123"); pRemoteCharacteristic->registerForNotify(notifyCallback); pClient->disconnect(); ESP_LOGD(LOG_TAG, "%s", pClient->toString().c_str()); ESP_LOGD(LOG_TAG, "-- End of task"); }
void run(void* data) { BLEAddress* pAddress = (BLEAddress*)data; BLEClient* pClient = BLEDevice::createClient(); BLEDevice::setEncryptionLevel(ESP_BLE_SEC_ENCRYPT); BLEDevice::setSecurityCallbacks(new MySecurity()); BLESecurity *pSecurity = new BLESecurity(); pSecurity->setKeySize(); pSecurity->setAuthenticationMode(ESP_LE_AUTH_REQ_SC_ONLY); pSecurity->setCapability(ESP_IO_CAP_IO); pSecurity->setRespEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK); // Connect to the remove BLE Server. pClient->connect(*pAddress); // Obtain a reference to the service we are after in the remote BLE server. BLERemoteService* pRemoteService = pClient->getService(serviceUUID); if (pRemoteService == nullptr) { ESP_LOGD(LOG_TAG, "Failed to find our service UUID: %s", serviceUUID.toString().c_str()); return; } // Obtain a reference to the characteristic in the service of the remote BLE server. BLERemoteCharacteristic* pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID); if (pRemoteCharacteristic == nullptr) { ESP_LOGD(LOG_TAG, "Failed to find our characteristic UUID: %s", charUUID.toString().c_str()); return; } // Read the value of the characteristic. std::string value = pRemoteCharacteristic->readValue(); ESP_LOGD(LOG_TAG, "The characteristic value was: %s", value.c_str()); while(1) { // Set a new value of the characteristic ESP_LOGD(LOG_TAG, "Setting the new value"); std::ostringstream stringStream; struct timeval tv; gettimeofday(&tv, nullptr); stringStream << "Time since boot: " << tv.tv_sec; pRemoteCharacteristic->writeValue(stringStream.str()); FreeRTOS::sleep(1000); } pClient->disconnect(); ESP_LOGD(LOG_TAG, "%s", pClient->toString().c_str()); ESP_LOGD(LOG_TAG, "-- End of task"); } // run
void run(void* data) { BLEAddress* pAddress = (BLEAddress*)data; BLEClient* pClient = BLEDevice::createClient(); // Connect to the remove BLE Server. pClient->connect(*pAddress); // Obtain a reference to the service we are after in the remote BLE server. BLERemoteService* pRemoteService = pClient->getService(serviceUUID); if (pRemoteService == nullptr) { ESP_LOGD(LOG_TAG, "Failed to find our service UUID: %s", serviceUUID.toString().c_str()); return; } // Obtain a reference to the characteristic in the service of the remote BLE server. BLERemoteCharacteristic* pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID); if (pRemoteCharacteristic == nullptr) { ESP_LOGD(LOG_TAG, "Failed to find our characteristic UUID: %s", charUUID.toString().c_str()); return; } // Read the value of the characteristic. std::string value = pRemoteCharacteristic->readValue(); ESP_LOGD(LOG_TAG, "The characteristic value was: %s", value.c_str()); while(1) { // Set a new value of the characteristic ESP_LOGD(LOG_TAG, "Setting the new value"); std::ostringstream stringStream; struct timeval tv; gettimeofday(&tv, nullptr); stringStream << "Time since boot: " << tv.tv_sec; pRemoteCharacteristic->writeValue(stringStream.str()); FreeRTOS::sleep(1000); } pClient->disconnect(); ESP_LOGD(LOG_TAG, "%s", pClient->toString().c_str()); ESP_LOGD(LOG_TAG, "-- End of task"); } // run
/** * @brief Set the Service UUID for this device. * @param [in] serviceUUID The discovered serviceUUID */ void BLEAdvertisedDevice::setServiceUUID(BLEUUID serviceUUID) { m_serviceUUIDs.push_back(serviceUUID); m_haveServiceUUID = true; ESP_LOGD(LOG_TAG, "- addServiceUUID(): serviceUUID: %s", serviceUUID.toString().c_str()); } // setServiceUUID
/** * @brief Set the value of a specific characteristic associated with a specific service. * @param [in] serviceUUID The service that owns the characteristic. * @param [in] characteristicUUID The characteristic whose value we wish to write. * @throws BLEUuidNotFound */ void BLEClient::setValue(BLEUUID serviceUUID, BLEUUID characteristicUUID, std::string value) { ESP_LOGD(LOG_TAG, ">> setValue: serviceUUID: %s, characteristicUUID: %s", serviceUUID.toString().c_str(), characteristicUUID.toString().c_str()); getService(serviceUUID)->getCharacteristic(characteristicUUID)->writeValue(value); ESP_LOGD(LOG_TAG, "<< setValue"); } // setValue
/** * @brief Get the value of a specific characteristic associated with a specific service. * @param [in] serviceUUID The service that owns the characteristic. * @param [in] characteristicUUID The characteristic whose value we wish to read. * @throws BLEUuidNotFound */ std::string BLEClient::getValue(BLEUUID serviceUUID, BLEUUID characteristicUUID) { ESP_LOGD(LOG_TAG, ">> getValue: serviceUUID: %s, characteristicUUID: %s", serviceUUID.toString().c_str(), characteristicUUID.toString().c_str()); std::string ret = getService(serviceUUID)->getCharacteristic(characteristicUUID)->readValue(); ESP_LOGD(LOG_TAG, "<<getValue"); return ret; } // getValue
/** * @brief Handle GATT Client events */ void BLEClient::gattClientEventHandler( esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t* evtParam) { ESP_LOGD(LOG_TAG, "gattClientEventHandler [esp_gatt_if: %d] ... %s", gattc_if, BLEUtils::gattClientEventTypeToString(event).c_str()); // Execute handler code based on the type of event received. switch(event) { case ESP_GATTC_SRVC_CHG_EVT: ESP_LOGI(LOG_TAG, "SERVICE CHANGED"); break; case ESP_GATTC_CLOSE_EVT: { // esp_ble_gattc_app_unregister(m_appId); // BLEDevice::removePeerDevice(m_gattc_if, true); break; } // // ESP_GATTC_DISCONNECT_EVT // // disconnect: // - esp_gatt_status_t status // - uint16_t conn_id // - esp_bd_addr_t remote_bda case ESP_GATTC_DISCONNECT_EVT: { // If we receive a disconnect event, set the class flag that indicates that we are // no longer connected. m_isConnected = false; if (m_pClientCallbacks != nullptr) { m_pClientCallbacks->onDisconnect(this); } BLEDevice::removePeerDevice(m_appId, true); esp_ble_gattc_app_unregister(m_gattc_if); m_semaphoreRssiCmplEvt.give(); m_semaphoreSearchCmplEvt.give(1); break; } // ESP_GATTC_DISCONNECT_EVT // // ESP_GATTC_OPEN_EVT // // open: // - esp_gatt_status_t status // - uint16_t conn_id // - esp_bd_addr_t remote_bda // case ESP_GATTC_OPEN_EVT: { m_conn_id = evtParam->open.conn_id; if (m_pClientCallbacks != nullptr) { m_pClientCallbacks->onConnect(this); } if (evtParam->open.status == ESP_GATT_OK) { m_isConnected = true; // Flag us as connected. } m_semaphoreOpenEvt.give(evtParam->open.status); break; } // ESP_GATTC_OPEN_EVT // // ESP_GATTC_REG_EVT // // reg: // esp_gatt_status_t status // uint16_t app_id // case ESP_GATTC_REG_EVT: { m_gattc_if = gattc_if; m_semaphoreRegEvt.give(); break; } // ESP_GATTC_REG_EVT case ESP_GATTC_CFG_MTU_EVT: if(evtParam->cfg_mtu.status != ESP_GATT_OK) { ESP_LOGE(LOG_TAG,"Config mtu failed"); } m_mtu = evtParam->cfg_mtu.mtu; break; case ESP_GATTC_CONNECT_EVT: { BLEDevice::updatePeerDevice(this, true, m_gattc_if); esp_err_t errRc = esp_ble_gattc_send_mtu_req(gattc_if, evtParam->connect.conn_id); if (errRc != ESP_OK) { ESP_LOGE(LOG_TAG, "esp_ble_gattc_send_mtu_req: rc=%d %s", errRc, GeneralUtils::errorToString(errRc)); } #ifdef CONFIG_BLE_SMP_ENABLE // Check that BLE SMP (security) is configured in make menuconfig if(BLEDevice::m_securityLevel){ esp_ble_set_encryption(evtParam->connect.remote_bda, BLEDevice::m_securityLevel); } #endif // CONFIG_BLE_SMP_ENABLE break; } // ESP_GATTC_CONNECT_EVT // // ESP_GATTC_SEARCH_CMPL_EVT // // search_cmpl: // - esp_gatt_status_t status // - uint16_t conn_id // case ESP_GATTC_SEARCH_CMPL_EVT: { esp_ble_gattc_cb_param_t* p_data = (esp_ble_gattc_cb_param_t*)evtParam; if (p_data->search_cmpl.status != ESP_GATT_OK){ ESP_LOGE(LOG_TAG, "search service failed, error status = %x", p_data->search_cmpl.status); break; } #ifndef ARDUINO_ARCH_ESP32 // commented out just for now to keep backward compatibility // if(p_data->search_cmpl.searched_service_source == ESP_GATT_SERVICE_FROM_REMOTE_DEVICE) { // ESP_LOGI(LOG_TAG, "Get service information from remote device"); // } else if (p_data->search_cmpl.searched_service_source == ESP_GATT_SERVICE_FROM_NVS_FLASH) { // ESP_LOGI(LOG_TAG, "Get service information from flash"); // } else { // ESP_LOGI(LOG_TAG, "unknown service source"); // } #endif m_semaphoreSearchCmplEvt.give(0); break; } // ESP_GATTC_SEARCH_CMPL_EVT // // ESP_GATTC_SEARCH_RES_EVT // // search_res: // - uint16_t conn_id // - uint16_t start_handle // - uint16_t end_handle // - esp_gatt_id_t srvc_id // case ESP_GATTC_SEARCH_RES_EVT: { BLEUUID uuid = BLEUUID(evtParam->search_res.srvc_id); BLERemoteService* pRemoteService = new BLERemoteService( evtParam->search_res.srvc_id, this, evtParam->search_res.start_handle, evtParam->search_res.end_handle ); m_servicesMap.insert(std::pair<std::string, BLERemoteService*>(uuid.toString(), pRemoteService)); m_servicesMapByInstID.insert(std::pair<BLERemoteService *, uint16_t>(pRemoteService, evtParam->search_res.srvc_id.inst_id)); break; } // ESP_GATTC_SEARCH_RES_EVT default: { break; } } // Switch // Pass the request on to all services. for (auto &myPair : m_servicesMap) { myPair.second->gattClientEventHandler(event, gattc_if, evtParam); } } // gattClientEventHandler
/** * @brief Constructor. * @param [in] handle The BLE server side handle of this characteristic. * @param [in] uuid The UUID of this characteristic. * @param [in] charProp The properties of this characteristic. * @param [in] pRemoteService A reference to the remote service to which this remote characteristic pertains. */ BLERemoteCharacteristic::BLERemoteCharacteristic( uint16_t handle, BLEUUID uuid, esp_gatt_char_prop_t charProp, BLERemoteService* pRemoteService) { ESP_LOGD(LOG_TAG, ">> BLERemoteCharacteristic: handle: %d 0x%d, uuid: %s", handle, handle, uuid.toString().c_str()); m_handle = handle; m_uuid = uuid; m_charProp = charProp; m_pRemoteService = pRemoteService; m_notifyCallback = nullptr; retrieveDescriptors(); // Get the descriptors for this characteristic ESP_LOGD(LOG_TAG, "<< BLERemoteCharacteristic"); } // BLERemoteCharacteristic
/** * @brief Set the value of a characteristic. * @param [in] characteristicUuid The characteristic to set. * @param [in] value The value to set. * @throws BLEUuidNotFound */ void BLERemoteService::setValue(BLEUUID characteristicUuid, std::string value) { ESP_LOGD(LOG_TAG, ">> setValue: uuid: %s", characteristicUuid.toString().c_str()); getCharacteristic(characteristicUuid)->writeValue(value); ESP_LOGD(LOG_TAG, "<< setValue"); } // setValue
/** * @brief Read the value of a characteristic associated with this service. */ std::string BLERemoteService::getValue(BLEUUID characteristicUuid) { ESP_LOGD(LOG_TAG, ">> readValue: uuid: %s", characteristicUuid.toString().c_str()); std::string ret = getCharacteristic(characteristicUuid)->readValue(); ESP_LOGD(LOG_TAG, "<< readValue"); return ret; } // readValue
/** * @brief Set the characteristic by UUID. * @param [in] uuid The uuid of the characteristic. * @param [in] characteristic The characteristic to cache. * @return N/A. */ void BLECharacteristicMap::setByUUID( BLECharacteristic *pCharacteristic, BLEUUID uuid) { m_uuidMap.insert(std::pair<BLECharacteristic *, std::string>(pCharacteristic, uuid.toString())); } // setByUUID
/** * @brief Set the value of a characteristic of a service on a remote device. * @param [in] bdAddress * @param [in] serviceUUID * @param [in] characteristicUUID */ /* STATIC */ void BLEDevice::setValue(BLEAddress bdAddress, BLEUUID serviceUUID, BLEUUID characteristicUUID, std::string value) { ESP_LOGD(LOG_TAG, ">> setValue: bdAddress: %s, serviceUUID: %s, characteristicUUID: %s", bdAddress.toString().c_str(), serviceUUID.toString().c_str(), characteristicUUID.toString().c_str()); BLEClient *pClient = createClient(); pClient->connect(bdAddress); pClient->setValue(serviceUUID, characteristicUUID, value); pClient->disconnect(); } // setValue
/** * @brief Get the value of a characteristic of a service on a remote device. * @param [in] bdAddress * @param [in] serviceUUID * @param [in] characteristicUUID */ /* STATIC */ std::string BLEDevice::getValue(BLEAddress bdAddress, BLEUUID serviceUUID, BLEUUID characteristicUUID) { ESP_LOGD(LOG_TAG, ">> getValue: bdAddress: %s, serviceUUID: %s, characteristicUUID: %s", bdAddress.toString().c_str(), serviceUUID.toString().c_str(), characteristicUUID.toString().c_str()); BLEClient *pClient = createClient(); pClient->connect(bdAddress); std::string ret = pClient->getValue(serviceUUID, characteristicUUID); pClient->disconnect(); ESP_LOGD(LOG_TAG, "<< getValue"); return ret; } // getValue