mirrors
/
Tasmota
mirror of https://github.com/arendst/Tasmota.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add correct log info

This commit is contained in:
Theo Arends 2021-01-19 16:23:16 +01:00
parent f5f6c6e5a1
commit c16fb465fb
2 changed files with 274 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

230
tasmota/xdrv_52_BLE_ESP32.ino
View File

@ -599,7 +599,7 @@ int addSeenDevice(const uint8_t *mac, uint8_t addrtype, const char *name, int8_t
int total = seenDevices.size(); int total = seenDevices.size();
if (total < MAX_BLE_DEVICES_LOGGED){ if (total < MAX_BLE_DEVICES_LOGGED){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("new seendev slot %d"), total); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: New seendev slot %d"), total);
#endif #endif
BLE_ESP32::BLE_simple_device_t* dev = new BLE_ESP32::BLE_simple_device_t; BLE_ESP32::BLE_simple_device_t* dev = new BLE_ESP32::BLE_simple_device_t;
freeDevices.push_back(dev); freeDevices.push_back(dev);
@ -667,10 +667,10 @@ int deleteSeenDevices(int ageS = 0){
dump(addr, 20, dev->mac, 6); dump(addr, 20, dev->mac, 6);
const char *alias = getAlias(dev->mac); const char *alias = getAlias(dev->mac);
if (!filter){ if (!filter){
AddLog_P(LOG_LEVEL_INFO,PSTR("delete device %s(%s) by age lastseen %u + maxage %u < now %u."), AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: Delete device %s(%s) by age lastseen %u + maxage %u < now %u."),
addr, alias, lastseenS, ageS, nowS); addr, alias, lastseenS, ageS, nowS);
} else { } else {
AddLog_P(LOG_LEVEL_INFO,PSTR("delete device %s(%s) by addrtype filter %d > %d."), AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: Delete device %s(%s) by addrtype filter %d > %d."),
addr, alias, dev->addrtype, BLEAddressFilter); addr, alias, dev->addrtype, BLEAddressFilter);
} }
#endif #endif
@ -682,7 +682,7 @@ int deleteSeenDevices(int ageS = 0){
} }
if (res){ if (res){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_INFO,PSTR("BLE deleted %d devices"), res); AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: Deleted %d devices"), res);
#endif #endif
} }
return res; return res;
@ -820,7 +820,7 @@ int getSeenDevicesToJson(char *dest, int maxlen){
} }
// deliberate test of SafeAddLog_P from main thread... // deliberate test of SafeAddLog_P from main thread...
//AddLog_P(LOG_LEVEL_INFO,PSTR("getSeen %d"), seenDevices.size()); //AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: getSeen %d"), seenDevices.size());
int len; int len;
@ -1184,17 +1184,17 @@ void postAdvertismentDetails(){
class BLESensorCallback : public NimBLEClientCallbacks { class BLESensorCallback : public NimBLEClientCallbacks {
void onConnect(NimBLEClient* pClient) { void onConnect(NimBLEClient* pClient) {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("onConnect %s"), ((std::string)pClient->getPeerAddress()).c_str()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: onConnect %s"), ((std::string)pClient->getPeerAddress()).c_str());
#endif #endif
} }
void onDisconnect(NimBLEClient* pClient) { void onDisconnect(NimBLEClient* pClient) {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("onDisconnect %s"), ((std::string)pClient->getPeerAddress()).c_str()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: onDisconnect %s"), ((std::string)pClient->getPeerAddress()).c_str());
#endif #endif
} }
bool onConnParamsUpdateRequest(NimBLEClient* pClient, const ble_gap_upd_params* params) { bool onConnParamsUpdateRequest(NimBLEClient* pClient, const ble_gap_upd_params* params) {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("onConnParamsUpdateRequest %s"), ((std::string)pClient->getPeerAddress()).c_str()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: onConnParamsUpdateRequest %s"), ((std::string)pClient->getPeerAddress()).c_str());
#endif #endif
// if(params->itvl_min < 24) { /** 1.25ms units */ // if(params->itvl_min < 24) { /** 1.25ms units */
@ -1315,7 +1315,7 @@ class BLEAdvCallbacks: public NimBLEAdvertisedDeviceCallbacks {
} }
} catch(const std::exception& e){ } catch(const std::exception& e){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("exception in advertismentCallbacks")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: exception in advertismentCallbacks"));
#endif #endif
} }
} }
@ -1334,18 +1334,18 @@ static BLESensorCallback BLESensorCB;
static void BLEscanEndedCB(NimBLEScanResults results){ static void BLEscanEndedCB(NimBLEScanResults results){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("Scan ended")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: Scan ended"));
#endif #endif
for (int i = 0; i < scancompleteCallbacks.size(); i++){ for (int i = 0; i < scancompleteCallbacks.size(); i++){
try { try {
SCANCOMPLETE_CALLBACK *pFn = scancompleteCallbacks[i]; SCANCOMPLETE_CALLBACK *pFn = scancompleteCallbacks[i];
int callbackres = pFn(results); int callbackres = pFn(results);
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("scancompleteCallbacks %d %d"), i, callbackres); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: scancompleteCallbacks %d %d"), i, callbackres);
#endif #endif
} catch(const std::exception& e){ } catch(const std::exception& e){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("exception in operationsCallbacks")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: exception in operationsCallbacks"));
#endif #endif
} }
} }
@ -1367,21 +1367,21 @@ static void BLEGenNotifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, ui
if (!pRemoteCharacteristic){ if (!pRemoteCharacteristic){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("Notify: no remote char!!??")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: Notify: no remote char!!??"));
#endif #endif
return; return;
} }
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("Notified length: %u"),length); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: Notified length: %u"),length);
#endif #endif
// find the operation this is associated with // find the operation this is associated with
NimBLERemoteService *pSvc = pRemoteCharacteristic->getRemoteService(); NimBLERemoteService *pSvc = pRemoteCharacteristic->getRemoteService();
if (!pSvc){ if (!pSvc){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("Notify: no remote service found")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Notify: no remote service found"));
#endif #endif
return; return;
} }
@ -1389,7 +1389,7 @@ static void BLEGenNotifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, ui
pRClient = pSvc->getClient(); pRClient = pSvc->getClient();
if (!pRClient){ if (!pRClient){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("Notify: no remote client!!??")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Notify: no remote client!!??"));
#endif #endif
return; return;
} }
@ -1404,7 +1404,7 @@ static void BLEGenNotifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, ui
generic_sensor_t *op = currentOperations[i]; generic_sensor_t *op = currentOperations[i];
if (!op){ if (!op){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("Notify: null op in currentOperations!!??")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Notify: null op in currentOperations!!??"));
#endif #endif
} else { } else {
if (devaddr == op->addr){ if (devaddr == op->addr){
@ -1420,7 +1420,7 @@ static void BLEGenNotifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, ui
if (!thisop){ if (!thisop){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("no op for notify")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: no op for notify"));
#endif #endif
return; return;
} }
@ -1524,7 +1524,7 @@ static void BLEOperationTask(void *pvParameters);
static void BLEStartOperationTask(){ static void BLEStartOperationTask(){
if (BLERunning == false){ if (BLERunning == false){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("%s: Start operations"),D_CMND_BLE); AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: %s: Start operations"),D_CMND_BLE);
#endif #endif
BLERunning = true; BLERunning = true;
@ -1547,25 +1547,25 @@ static void BLEStartOperationTask(){
static void BLETaskStopStartNimBLE(NimBLEClient **ppClient, bool start = true){ static void BLETaskStopStartNimBLE(NimBLEClient **ppClient, bool start = true){
if (*ppClient){ if (*ppClient){
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLETask:Stopping NimBLE")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Task:Stopping NimBLE"));
(*ppClient)->setClientCallbacks(nullptr, false); (*ppClient)->setClientCallbacks(nullptr, false);
try { try {
if ((*ppClient)->isConnected()){ if ((*ppClient)->isConnected()){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_INFO,PSTR("disconnecting connected client")); AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: disconnecting connected client"));
#endif #endif
(*ppClient)->disconnect(); (*ppClient)->disconnect();
} }
NimBLEDevice::deleteClient((*ppClient)); NimBLEDevice::deleteClient((*ppClient));
(*ppClient) = nullptr; (*ppClient) = nullptr;
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_INFO,PSTR("deleted client")); AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: deleted client"));
#endif #endif
} catch(const std::exception& e){ } catch(const std::exception& e){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("Stopping NimBLE:exception in delete client")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Stopping NimBLE:exception in delete client"));
#endif #endif
} }
@ -1582,7 +1582,7 @@ static void BLETaskStopStartNimBLE(NimBLEClient **ppClient, bool start = true){
BLERunningScan = 0; BLERunningScan = 0;
if (start){ if (start){
AddLog_P(LOG_LEVEL_INFO,PSTR("BLETask:Starting NimBLE")); AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: BLETask:Starting NimBLE"));
NimBLEDevice::init("BLE_ESP32"); NimBLEDevice::init("BLE_ESP32");
*ppClient = NimBLEDevice::createClient(); *ppClient = NimBLEDevice::createClient();
@ -1623,7 +1623,7 @@ int BLETaskStartScan(int time){
} }
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLETask: Startscan")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: BLETask: Startscan"));
#endif #endif
//vTaskDelay(500/ portTICK_PERIOD_MS); //vTaskDelay(500/ portTICK_PERIOD_MS);
ble32Scan->setActiveScan(BLEScanActiveMode ? 1: 0); ble32Scan->setActiveScan(BLEScanActiveMode ? 1: 0);
@ -1652,7 +1652,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
*pCurrentOperation = nextOperation(&queuedOperations); *pCurrentOperation = nextOperation(&queuedOperations);
if (*pCurrentOperation){ if (*pCurrentOperation){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLETask: new currentOperation")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: BLETask: new currentOperation"));
#endif #endif
BLEOpCount++; BLEOpCount++;
generic_sensor_t* temp = *pCurrentOperation; generic_sensor_t* temp = *pCurrentOperation;
@ -1673,7 +1673,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
diff = diff/1000; diff = diff/1000;
if (diff > 20000){ // 20s if (diff > 20000){ // 20s
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLETask: notify timeout")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: BLETask: notify timeout"));
#endif #endif
(*pCurrentOperation)->state = GEN_STATE_FAILED_NOTIFYTIMEOUT; (*pCurrentOperation)->state = GEN_STATE_FAILED_NOTIFYTIMEOUT;
(*pCurrentOperation)->notifytimer = 0; (*pCurrentOperation)->notifytimer = 0;
@ -1690,7 +1690,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
(*pCurrentOperation)->state = GEN_STATE_NOTIFIED; (*pCurrentOperation)->state = GEN_STATE_NOTIFIED;
// just stay here until this is removed by the main thread // just stay here until this is removed by the main thread
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLETask: notify operation complete")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: BLETask: notify operation complete"));
#endif #endif
BLE_ESP32::BLETaskRunTaskDoneOperation(pCurrentOperation, ppClient); BLE_ESP32::BLETaskRunTaskDoneOperation(pCurrentOperation, ppClient);
pClient = *ppClient; pClient = *ppClient;
@ -1701,7 +1701,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
case GEN_STATE_NOTIFIED: // - may have completed DURING our read/write to get here case GEN_STATE_NOTIFIED: // - may have completed DURING our read/write to get here
// just stay here until this is removed by the main thread // just stay here until this is removed by the main thread
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLETask: operation complete")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: BLETask: operation complete"));
#endif #endif
BLE_ESP32::BLETaskRunTaskDoneOperation(pCurrentOperation, ppClient); BLE_ESP32::BLETaskRunTaskDoneOperation(pCurrentOperation, ppClient);
pClient = *ppClient; pClient = *ppClient;
@ -1721,7 +1721,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if ((*pCurrentOperation)->state <= GEN_STATE_FAILED){ if ((*pCurrentOperation)->state <= GEN_STATE_FAILED){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLETask: op failed %d"), (*pCurrentOperation)->state); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: BLETask: op failed %d"), (*pCurrentOperation)->state);
#endif #endif
BLE_ESP32::BLETaskRunTaskDoneOperation(pCurrentOperation, ppClient); BLE_ESP32::BLETaskRunTaskDoneOperation(pCurrentOperation, ppClient);
pClient = *ppClient; pClient = *ppClient;
@ -1735,7 +1735,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if (pClient->isConnected()){ if (pClient->isConnected()){
// don't do anything if we are still connected // don't do anything if we are still connected
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLETask: still connected")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: BLETask: still connected"));
#endif #endif
return; return;
} }
@ -1755,7 +1755,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
op->state = GEN_STATE_STARTED; op->state = GEN_STATE_STARTED;
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLETask: attempt connect %s"), ((std::string)op->addr).c_str()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: BLETask: attempt connect %s"), ((std::string)op->addr).c_str());
#endif #endif
if (!op->serviceUUID.bitSize()){ if (!op->serviceUUID.bitSize()){
@ -1766,7 +1766,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if (pClient->connect(op->addr, true)) { if (pClient->connect(op->addr, true)) {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("connected %s -> getservice"), ((std::string)op->addr).c_str()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: connected %s -> getservice"), ((std::string)op->addr).c_str());
#endif #endif
NimBLERemoteService *pService = pClient->getService(op->serviceUUID); NimBLERemoteService *pService = pClient->getService(op->serviceUUID);
int waitNotify = false; int waitNotify = false;
@ -1775,7 +1775,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if (pService != nullptr) { if (pService != nullptr) {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("got service")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: got service"));
#endif #endif
// pre-set to fail if no operations requested // pre-set to fail if no operations requested
//newstate = GEN_STATE_FAILED_NOREADWRITE; //newstate = GEN_STATE_FAILED_NOREADWRITE;
@ -1792,13 +1792,13 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
pService->getCharacteristic(op->notificationCharacteristicUUID); pService->getCharacteristic(op->notificationCharacteristicUUID);
if (pNCharacteristic != nullptr) { if (pNCharacteristic != nullptr) {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("got notify characteristic")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: got notify characteristic"));
#endif #endif
op->notifylen = 0; op->notifylen = 0;
if(pNCharacteristic->canNotify()) { if(pNCharacteristic->canNotify()) {
if(pNCharacteristic->subscribe(true, BLE_ESP32::BLEGenNotifyCB)) { if(pNCharacteristic->subscribe(true, BLE_ESP32::BLEGenNotifyCB)) {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("subscribe for notify")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: subscribe for notify"));
#endif #endif
uint64_t now = esp_timer_get_time(); uint64_t now = esp_timer_get_time();
op->notifytimer = now; op->notifytimer = now;
@ -1808,7 +1808,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
waitNotify = true; waitNotify = true;
} else { } else {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("failed subscribe for notify")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: failed subscribe for notify"));
#endif #endif
newstate = GEN_STATE_FAILED_NOTIFY; newstate = GEN_STATE_FAILED_NOTIFY;
} }
@ -1816,7 +1816,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if(pNCharacteristic->canIndicate()) { if(pNCharacteristic->canIndicate()) {
if(pNCharacteristic->subscribe(false, BLE_ESP32::BLEGenNotifyCB)) { if(pNCharacteristic->subscribe(false, BLE_ESP32::BLEGenNotifyCB)) {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("subscribe for indicate")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: subscribe for indicate"));
#endif #endif
notifystate = GEN_STATE_WAITINDICATE; notifystate = GEN_STATE_WAITINDICATE;
uint64_t now = esp_timer_get_time(); uint64_t now = esp_timer_get_time();
@ -1824,21 +1824,21 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
waitNotify = true; waitNotify = true;
} else { } else {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("failed subscribe for indicate")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: failed subscribe for indicate"));
#endif #endif
newstate = GEN_STATE_FAILED_INDICATE; newstate = GEN_STATE_FAILED_INDICATE;
} }
} else { } else {
newstate = GEN_STATE_FAILED_CANTNOTIFYORINDICATE; newstate = GEN_STATE_FAILED_CANTNOTIFYORINDICATE;
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("characteristic can't notify")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: characteristic can't notify"));
#endif #endif
} }
} }
} else { } else {
newstate = GEN_STATE_FAILED_NONOTIFYCHAR; newstate = GEN_STATE_FAILED_NONOTIFYCHAR;
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("notify characteristic not found")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: notify characteristic not found"));
#endif #endif
} }
@ -1855,7 +1855,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
pCharacteristic = pService->getCharacteristic(op->characteristicUUID); pCharacteristic = pService->getCharacteristic(op->characteristicUUID);
if (pCharacteristic != nullptr) { if (pCharacteristic != nullptr) {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("got read/write characteristic")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: got read/write characteristic"));
#endif #endif
newstate = GEN_STATE_FAILED_NOREADWRITE; // overwritten on failure newstate = GEN_STATE_FAILED_NOREADWRITE; // overwritten on failure
@ -1875,12 +1875,12 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if (op->readmodifywritecallback){ if (op->readmodifywritecallback){
READ_CALLBACK *pFn = (READ_CALLBACK *)op->readmodifywritecallback; READ_CALLBACK *pFn = (READ_CALLBACK *)op->readmodifywritecallback;
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("read characteristic with readmodifywritecallback")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: read characteristic with readmodifywritecallback"));
#endif #endif
pFn(op); pFn(op);
} else { } else {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("read characteristic")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: read characteristic"));
#endif #endif
} }
@ -1896,12 +1896,12 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if (!pCharacteristic->writeValue(op->dataToWrite, op->writelen, true)){ if (!pCharacteristic->writeValue(op->dataToWrite, op->writelen, true)){
newstate = GEN_STATE_FAILED_WRITE; newstate = GEN_STATE_FAILED_WRITE;
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("characteristic write fail")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: characteristic write fail"));
#endif #endif
} else { } else {
if (!waitNotify) newstate = GEN_STATE_WRITEDONE; if (!waitNotify) newstate = GEN_STATE_WRITEDONE;
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("write characteristic")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: write characteristic"));
#endif #endif
} }
} else { } else {
@ -1913,7 +1913,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
} else { } else {
newstate = GEN_STATE_FAILED_NO_RW_CHAR; newstate = GEN_STATE_FAILED_NO_RW_CHAR;
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("r/w characteristic not found")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: r/w characteristic not found"));
#endif #endif
} }
} }
@ -1934,7 +1934,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
newstate = GEN_STATE_FAILED_NOSERVICE; newstate = GEN_STATE_FAILED_NOSERVICE;
// failed to get a service // failed to get a service
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("failed - svc not on device?")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: failed - svc not on device?"));
#endif #endif
} }
@ -1946,14 +1946,14 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
switch (rc){ switch (rc){
case (0x0200+BLE_ERR_CONN_LIMIT ): case (0x0200+BLE_ERR_CONN_LIMIT ):
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("Hit connection limit? - restarting NimBLE")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Hit connection limit? - restarting NimBLE"));
#endif #endif
BLERestartNimBLE = 1; BLERestartNimBLE = 1;
BLERestartBLEReason = BLE_RESTART_BLE_REASON_CONN_LIMIT; BLERestartBLEReason = BLE_RESTART_BLE_REASON_CONN_LIMIT;
break; break;
case (0x0200+BLE_ERR_ACL_CONN_EXISTS): case (0x0200+BLE_ERR_ACL_CONN_EXISTS):
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("Connection exists? - restarting NimBLE")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Connection exists? - restarting NimBLE"));
#endif #endif
BLERestartNimBLE = 1; BLERestartNimBLE = 1;
BLERestartBLEReason = BLE_RESTART_BLE_REASON_CONN_EXISTS; BLERestartBLEReason = BLE_RESTART_BLE_REASON_CONN_EXISTS;
@ -1963,7 +1963,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
// failed to connect // failed to connect
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("failed to connect to device %d"), rc); AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: failed to connect to device %d"), rc);
#endif #endif
} }
op->state = newstate; op->state = newstate;
@ -1979,7 +1979,7 @@ static void BLETaskRunTaskDoneOperation(BLE_ESP32::generic_sensor_t** op, NimBLE
try { try {
if ((*ppClient)->isConnected()){ if ((*ppClient)->isConnected()){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("runTaskDoneOperation: disconnecting connected client")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: runTaskDoneOperation: disconnecting connected client"));
#endif #endif
(*ppClient)->disconnect(); (*ppClient)->disconnect();
// wait for 1/2 second after disconnect // wait for 1/2 second after disconnect
@ -1990,7 +1990,7 @@ static void BLETaskRunTaskDoneOperation(BLE_ESP32::generic_sensor_t** op, NimBLE
//(*ppClient)->disconnect(); //(*ppClient)->disconnect();
// we will stall here forever!!! - as testing // we will stall here forever!!! - as testing
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE wait discon%d"), waits); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: wait discon%d"), waits);
#endif #endif
vTaskDelay(500/ portTICK_PERIOD_MS); vTaskDelay(500/ portTICK_PERIOD_MS);
} }
@ -1999,11 +1999,11 @@ static void BLETaskRunTaskDoneOperation(BLE_ESP32::generic_sensor_t** op, NimBLE
int conn_id = (*ppClient)->getConnId(); int conn_id = (*ppClient)->getConnId();
ble_gap_conn_broken(conn_id, -1); ble_gap_conn_broken(conn_id, -1);
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE wait discon%d - kill connection"), waits); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: wait discon%d - kill connection"), waits);
#endif #endif
} }
if (waits == 60){ if (waits == 60){
AddLog_P(LOG_LEVEL_ERROR,PSTR(">60s waiting -> BLE Failed, restart Tasmota %d"), waits); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: >60s waiting -> BLE Failed, restart Tasmota %d"), waits);
BLEStop = 1; BLEStop = 1;
BLEStopAt = esp_timer_get_time(); BLEStopAt = esp_timer_get_time();
@ -2015,7 +2015,7 @@ static void BLETaskRunTaskDoneOperation(BLE_ESP32::generic_sensor_t** op, NimBLE
} }
} catch(const std::exception& e){ } catch(const std::exception& e){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("runTaskDoneOperation: exception in disconnect")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: runTaskDoneOperation: exception in disconnect"));
#endif #endif
} }
@ -2035,7 +2035,7 @@ static void BLETaskRunTaskDoneOperation(BLE_ESP32::generic_sensor_t** op, NimBLE
// by adding it to this list, this will cause it to be sent to MQTT // by adding it to this list, this will cause it to be sent to MQTT
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("runTaskDoneOperation: add to completedOperations")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: runTaskDoneOperation: add to completedOperations"));
#endif #endif
addOperation(&completedOperations, op); addOperation(&completedOperations, op);
return; return;
@ -2096,7 +2096,7 @@ static void BLEOperationTask(void *pvParameters){
BLERestartNimBLE = 0; BLERestartNimBLE = 0;
BLERestartTasmota = 10; BLERestartTasmota = 10;
BLERestartTasmotaReason = BLE_RESTART_TEAMOTA_REASON_RESTARTING_BLE_TIMEOUT; BLERestartTasmotaReason = BLE_RESTART_TEAMOTA_REASON_RESTARTING_BLE_TIMEOUT;
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLETask: Restart NimBLE - restart Tasmota in 10 if not complt")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: BLETask: Restart NimBLE - restart Tasmota in 10 if not complt"));
BLE_ESP32::BLETaskStopStartNimBLE(&pClient); BLE_ESP32::BLETaskStopStartNimBLE(&pClient);
BLERestartTasmotaReason = BLE_RESTART_TEAMOTA_REASON_UNKNOWN; BLERestartTasmotaReason = BLE_RESTART_TEAMOTA_REASON_UNKNOWN;
BLERestartTasmota = 0; BLERestartTasmota = 0;
@ -2110,7 +2110,7 @@ static void BLEOperationTask(void *pvParameters){
vTaskDelay(100/ portTICK_PERIOD_MS); vTaskDelay(100/ portTICK_PERIOD_MS);
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLEOperationTask: Left task")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: BLEOperationTask: Left task"));
#endif #endif
deleteSeenDevices(); deleteSeenDevices();
@ -2192,11 +2192,11 @@ static void BLEEverySecond(bool restart){
if (!BLERestartTasmotaReason) BLERestartTasmotaReason = BLE_RESTART_TEAMOTA_REASON_UNKNOWN; if (!BLERestartTasmotaReason) BLERestartTasmotaReason = BLE_RESTART_TEAMOTA_REASON_UNKNOWN;
snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("{\"reboot\":\"%s\"}"), BLERestartTasmotaReason); snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("{\"reboot\":\"%s\"}"), BLERestartTasmotaReason);
MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain); MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain);
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE Failure! Restarting Tasmota in %d seconds because %s"), BLERestartTasmota, BLERestartTasmotaReason); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Failure! Restarting Tasmota in %d seconds because %s"), BLERestartTasmota, BLERestartTasmotaReason);
} }
if (!BLERestartTasmota){ if (!BLERestartTasmota){
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE Failure! Restarting Tasmota because %s"), BLERestartTasmotaReason); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Failure! Restarting Tasmota because %s"), BLERestartTasmotaReason);
// just a normal restart // just a normal restart
TasmotaGlobal.restart_flag = 1; TasmotaGlobal.restart_flag = 1;
} }
@ -2205,7 +2205,7 @@ static void BLEEverySecond(bool restart){
if (BLERestartBLEReason){ // just use the ptr as the trigger to send MQTT if (BLERestartBLEReason){ // just use the ptr as the trigger to send MQTT
snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("{\"blerestart\":\"%s\"}"), BLERestartBLEReason); snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("{\"blerestart\":\"%s\"}"), BLERestartBLEReason);
MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain); MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain);
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE Failure! Restarting BLE Stack because %s"), BLERestartBLEReason); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Failure! Restarting BLE Stack because %s"), BLERestartBLEReason);
BLERestartBLEReason = nullptr; BLERestartBLEReason = nullptr;
} }
@ -2250,9 +2250,9 @@ int addOperation(std::deque<generic_sensor_t*> *ops, generic_sensor_t** op){
} }
} }
if (res){ if (res){
//AddLog_P(LOG_LEVEL_DEBUG,PSTR("added operation")); //AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: added operation"));
} else { } else {
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE op - no room")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: op - no room"));
} }
return res; return res;
} }
@ -2260,7 +2260,7 @@ int addOperation(std::deque<generic_sensor_t*> *ops, generic_sensor_t** op){
int newOperation(BLE_ESP32::generic_sensor_t** op){ int newOperation(BLE_ESP32::generic_sensor_t** op){
if (!op) { if (!op) {
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE op inv in newOperation")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: op inv in newOperation"));
return 0; return 0;
} }
@ -2307,7 +2307,7 @@ int extQueueOperation(BLE_ESP32::generic_sensor_t** op){
int res = addOperation(&queuedOperations, op); int res = addOperation(&queuedOperations, op);
if (!res){ if (!res){
AddLog_P(LOG_LEVEL_ERROR,PSTR("extQueueOperation: op added id %d failed"), (lastopid-1)); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: extQueueOperation: op added id %d failed"), (lastopid-1));
} }
return res; return res;
} }
@ -2427,7 +2427,7 @@ static int StartBLE(void) {
BLE_ESP32::BLEStartOperationTask(); BLE_ESP32::BLEStartOperationTask();
return 1; return 1;
} }
AddLog_P(LOG_LEVEL_ERROR,PSTR("StartBLE - wait as BLEStop==1")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: StartBLE - wait as BLEStop==1"));
return 0; return 0;
} }
@ -2436,16 +2436,16 @@ static int StopBLE(void){
if (BLERunning){ if (BLERunning){
if (BLEStop != 1){ if (BLEStop != 1){
BLEStop = 1; BLEStop = 1;
AddLog_P(LOG_LEVEL_INFO,PSTR("StopBLE - BLEStop->1")); AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: StopBLE - BLEStop->1"));
BLEStopAt = esp_timer_get_time(); BLEStopAt = esp_timer_get_time();
// give a little time for it to stop. // give a little time for it to stop.
vTaskDelay(1000/ portTICK_PERIOD_MS); vTaskDelay(1000/ portTICK_PERIOD_MS);
return 1; return 1;
} }
AddLog_P(LOG_LEVEL_ERROR,PSTR("StopBLE - wait as BLEStop==1")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: StopBLE - wait as BLEStop==1"));
return 0; return 0;
} else { } else {
AddLog_P(LOG_LEVEL_ERROR,PSTR("StopBLE - was not running")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: StopBLE - was not running"));
return 1; return 1;
} }
} }
@ -2686,7 +2686,7 @@ void CmndBLEDetails(void){
void CmndBLEAlias(void){ void CmndBLEAlias(void){
#ifdef BLE_ESP32_ALIASES #ifdef BLE_ESP32_ALIASES
int op = XdrvMailbox.index; int op = XdrvMailbox.index;
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("Alias %d %s"), op, XdrvMailbox.data); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: Alias %d %s"), op, XdrvMailbox.data);
int res = -1; int res = -1;
switch(op){ switch(op){
@ -2705,7 +2705,7 @@ void CmndBLEAlias(void){
char *mac = p; char *mac = p;
int len = fromHex(addr, p, sizeof(addr)); int len = fromHex(addr, p, sizeof(addr));
if (len != 6){ if (len != 6){
AddLog_P(LOG_LEVEL_ERROR,PSTR("Alias invalid mac %s"), p); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Alias invalid mac %s"), p);
ResponseCmndChar("invalidmac"); ResponseCmndChar("invalidmac");
return; return;
} }
@ -2726,7 +2726,7 @@ void CmndBLEAlias(void){
return; return;
} }
AddLog_P(LOG_LEVEL_ERROR,PSTR("Add Alias mac %s = name %s"), mac, p); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Add Alias mac %s = name %s"), mac, p);
if (addAlias( addr, name )){ if (addAlias( addr, name )){
added++; added++;
} }
@ -2734,7 +2734,7 @@ void CmndBLEAlias(void){
} while (p); } while (p);
if (added){ if (added){
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("Added %d Aliases"), added); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: Added %d Aliases"), added);
BLEAliasListResp(); BLEAliasListResp();
} else { } else {
BLEAliasListResp(); BLEAliasListResp();
@ -2742,7 +2742,7 @@ void CmndBLEAlias(void){
return; return;
} break; } break;
case 2:{ // clear case 2:{ // clear
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLEAlias clearing %d"), aliases.size()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: Alias clearing %d"), aliases.size());
for (int i = aliases.size()-1; i >= 0; i--){ for (int i = aliases.size()-1; i >= 0; i--){
BLE_ESP32::ble_alias_t *alias = aliases[i]; BLE_ESP32::ble_alias_t *alias = aliases[i];
aliases.pop_back(); aliases.pop_back();
@ -2773,14 +2773,14 @@ void CmndBLEName(void) {
if (addrres){ if (addrres){
if (addrres == 2){ if (addrres == 2){
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE addr used alias: %s"), p); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: addr used alias: %s"), p);
} }
//#ifdef EQ3_DEBUG //#ifdef EQ3_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE cmd addr: %s -> %s"), p, addr.toString().c_str()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: cmd addr: %s -> %s"), p, addr.toString().c_str());
//#endif //#endif
} else { } else {
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE addr invalid: %s"), p); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: addr invalid: %s"), p);
ResponseCmndIdxChar(PSTR("invalidaddr")); ResponseCmndIdxChar(PSTR("invalidaddr"));
return; return;
} }
@ -2789,11 +2789,11 @@ void CmndBLEName(void) {
// ALWAYS use this function to create a new one. // ALWAYS use this function to create a new one.
int res = BLE_ESP32::newOperation(&op); int res = BLE_ESP32::newOperation(&op);
if (!res){ if (!res){
AddLog_P(LOG_LEVEL_ERROR,PSTR("Can't get a newOperation")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Can't get a newOperation"));
ResponseCmndChar(PSTR("FAIL")); ResponseCmndChar(PSTR("FAIL"));
return; return;
} else { } else {
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("got a newOperation from BLE")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: got a newOperation from BLE"));
} }
op->addr = addr; op->addr = addr;
@ -2804,21 +2804,21 @@ void CmndBLEName(void) {
char *name = strtok(nullptr, " "); char *name = strtok(nullptr, " ");
bool write = false; bool write = false;
if (name && *name){ if (name && *name){
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("write name %s"), name); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: write name %s"), name);
op->writelen = strlen(name); op->writelen = strlen(name);
memcpy(op->dataToWrite, name, op->writelen); memcpy(op->dataToWrite, name, op->writelen);
write = true; write = true;
} else { } else {
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("read name")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: read name"));
op->readlen = 1; op->readlen = 1;
} }
res = BLE_ESP32::extQueueOperation(&op); res = BLE_ESP32::extQueueOperation(&op);
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("queue res %d"), res); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: queue res %d"), res);
if (!res){ if (!res){
// if it fails to add to the queue, do please delete it // if it fails to add to the queue, do please delete it
BLE_ESP32::freeOperation(&op); BLE_ESP32::freeOperation(&op);
AddLog_P(LOG_LEVEL_ERROR,PSTR("Failed to queue new operation - deleted")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Failed to queue new operation - deleted"));
ResponseCmndChar(PSTR("QUEUEFAIL")); ResponseCmndChar(PSTR("QUEUEFAIL"));
return; return;
} }
@ -2856,7 +2856,7 @@ void CmndBLEOperation(void){
int op = XdrvMailbox.index; int op = XdrvMailbox.index;
//AddLog_P(LOG_LEVEL_INFO,PSTR("op %d"), op); //AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: op %d"), op);
int res = -1; int res = -1;
@ -2864,7 +2864,7 @@ void CmndBLEOperation(void){
switch(op) { switch(op) {
case 0: case 0:
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("preview")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: preview"));
#endif #endif
BLEPostMQTTTrigger = 1; BLEPostMQTTTrigger = 1;
break; break;
@ -2875,7 +2875,7 @@ void CmndBLEOperation(void){
int opres = BLE_ESP32::newOperation(&prepOperation); int opres = BLE_ESP32::newOperation(&prepOperation);
if (!opres){ if (!opres){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("Could not create new operation")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Could not create new operation"));
#endif #endif
ResponseCmndChar("FailCreate"); ResponseCmndChar("FailCreate");
return; return;
@ -2933,14 +2933,14 @@ void CmndBLEOperation(void){
// this means you could retry with another BLEOp10. // this means you could retry with another BLEOp10.
// it WOULD be deleted if you sent another BELOP1 <MAC> // it WOULD be deleted if you sent another BELOP1 <MAC>
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("Could not queue new operation")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Could not queue new operation"));
#endif #endif
ResponseCmndChar("FailQueue"); ResponseCmndChar("FailQueue");
return; return;
} else { } else {
// NOTE: prepOperation has been set to null if we queued sucessfully. // NOTE: prepOperation has been set to null if we queued sucessfully.
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("Operations queued:%d"), queuedOperations.size()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: Operations queued:%d"), queuedOperations.size());
#endif #endif
char temp[40]; char temp[40];
sprintf(temp, "{\"opid\":%d,\"u\":%d}", lastopid-1, u); sprintf(temp, "{\"opid\":%d,\"u\":%d}", lastopid-1, u);
@ -2969,13 +2969,13 @@ void CmndBLEOperation(void){
// this means you could retry with another BLEOp10. // this means you could retry with another BLEOp10.
// it WOULD be deleted if you sent another BELOP1 <MAC> // it WOULD be deleted if you sent another BELOP1 <MAC>
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("Could not queue new operation")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Could not queue new operation"));
#endif #endif
ResponseCmndChar("FailQueue"); ResponseCmndChar("FailQueue");
} else { } else {
// NOTE: prepOperation has been set to null if we queued sucessfully. // NOTE: prepOperation has been set to null if we queued sucessfully.
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("Operations queued:%d"), queuedOperations.size()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: Operations queued:%d"), queuedOperations.size());
#endif #endif
char temp[40]; char temp[40];
sprintf(temp, "{\"opid\":%d,\"u\":%d}", lastopid-1, u); sprintf(temp, "{\"opid\":%d,\"u\":%d}", lastopid-1, u);
@ -3026,20 +3026,20 @@ static void BLEPostMQTT(bool onlycompleted) {
if (prepOperation || completedOperations.size() || queuedOperations.size() || currentOperations.size()){ if (prepOperation || completedOperations.size() || queuedOperations.size() || currentOperations.size()){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("some to show")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: some to show"));
#endif #endif
if (prepOperation && !onlycompleted){ if (prepOperation && !onlycompleted){
std::string out = BLETriggerResponse(prepOperation); std::string out = BLETriggerResponse(prepOperation);
snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("%s"), out.c_str()); snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("%s"), out.c_str());
MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain); MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain);
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("prep sent %s"), out.c_str()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: prep sent %s"), out.c_str());
#endif #endif
} }
if (queuedOperations.size() && !onlycompleted){ if (queuedOperations.size() && !onlycompleted){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("queued %d"), queuedOperations.size()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: queued %d"), queuedOperations.size());
#endif #endif
for (int i = 0; i < queuedOperations.size(); i++){ for (int i = 0; i < queuedOperations.size(); i++){
TasAutoMutex localmutex(&BLEOperationsRecursiveMutex, "BLEPost1"); TasAutoMutex localmutex(&BLEOperationsRecursiveMutex, "BLEPost1");
@ -3053,7 +3053,7 @@ static void BLEPostMQTT(bool onlycompleted) {
snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("%s"), out.c_str()); snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("%s"), out.c_str());
MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain); MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain);
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("queued %d sent %s"), i, out.c_str()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: queued %d sent %s"), i, out.c_str());
#endif #endif
//break; //break;
} }
@ -3062,7 +3062,7 @@ static void BLEPostMQTT(bool onlycompleted) {
if (currentOperations.size() && !onlycompleted){ if (currentOperations.size() && !onlycompleted){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("current %d"), currentOperations.size()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: current %d"), currentOperations.size());
#endif #endif
for (int i = 0; i < currentOperations.size(); i++){ for (int i = 0; i < currentOperations.size(); i++){
TasAutoMutex localmutex(&BLEOperationsRecursiveMutex, "BLEPost2"); TasAutoMutex localmutex(&BLEOperationsRecursiveMutex, "BLEPost2");
@ -3075,7 +3075,7 @@ static void BLEPostMQTT(bool onlycompleted) {
snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("%s"), out.c_str()); snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("%s"), out.c_str());
MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain); MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain);
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("curr %d sent %s"), i, out.c_str()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: curr %d sent %s"), i, out.c_str());
#endif #endif
//break; //break;
} }
@ -3084,7 +3084,7 @@ static void BLEPostMQTT(bool onlycompleted) {
if (completedOperations.size()){ if (completedOperations.size()){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("completed %d"), completedOperations.size()); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: completed %d"), completedOperations.size());
#endif #endif
do { do {
generic_sensor_t *toSend = nextOperation(&completedOperations); generic_sensor_t *toSend = nextOperation(&completedOperations);
@ -3154,7 +3154,7 @@ static void mainThreadBLETimeouts() {
static void mainThreadOpCallbacks() { static void mainThreadOpCallbacks() {
if (completedOperations.size()){ if (completedOperations.size()){
//AddLog_P(LOG_LEVEL_INFO,PSTR("completed %d"), completedOperations.size()); //AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: completed %d"), completedOperations.size());
TasAutoMutex localmutex(&BLEOperationsRecursiveMutex, "BLEMainCB"); TasAutoMutex localmutex(&BLEOperationsRecursiveMutex, "BLEMainCB");
// find this operation in currentOperations, and remove it. // find this operation in currentOperations, and remove it.
@ -3169,11 +3169,11 @@ static void mainThreadOpCallbacks() {
OPCOMPLETE_CALLBACK *pFn = (OPCOMPLETE_CALLBACK *)(op->completecallback); OPCOMPLETE_CALLBACK *pFn = (OPCOMPLETE_CALLBACK *)(op->completecallback);
callbackres = pFn(op); callbackres = pFn(op);
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("op->completecallback %d"), callbackres); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: op->completecallback %d"), callbackres);
#endif #endif
} catch(const std::exception& e){ } catch(const std::exception& e){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("exception in op->completecallback")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: exception in op->completecallback"));
#endif #endif
} }
} }
@ -3184,14 +3184,14 @@ static void mainThreadOpCallbacks() {
OPCOMPLETE_CALLBACK *pFn = operationsCallbacks[i]; OPCOMPLETE_CALLBACK *pFn = operationsCallbacks[i];
callbackres = pFn(op); callbackres = pFn(op);
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("operationsCallbacks %d %d"), i, callbackres); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: operationsCallbacks %d %d"), i, callbackres);
#endif #endif
if (callbackres){ if (callbackres){
break; // this callback ate the op. break; // this callback ate the op.
} }
} catch(const std::exception& e){ } catch(const std::exception& e){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("exception in operationsCallbacks")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: exception in operationsCallbacks"));
#endif #endif
} }
} }
@ -3200,7 +3200,7 @@ static void mainThreadOpCallbacks() {
// if some callback told us not to send on MQTT, then remove from completed and delete the data // if some callback told us not to send on MQTT, then remove from completed and delete the data
if (callbackres){ if (callbackres){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("callbackres true -> delete op")); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: callbackres true -> delete op"));
#endif #endif
completedOperations.erase(completedOperations.begin() + i); completedOperations.erase(completedOperations.begin() + i);
delete op; delete op;
@ -3214,7 +3214,7 @@ static void BLEShow(bool json)
{ {
if (json){ if (json){
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("show json %d"),json); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: show json %d"),json);
#endif #endif
uint32_t totalCount = BLEAdvertisment.totalCount; uint32_t totalCount = BLEAdvertisment.totalCount;
uint32_t deviceCount = seenDevices.size(); uint32_t deviceCount = seenDevices.size();
@ -3372,12 +3372,12 @@ void HandleBleConfiguration(void)
{ {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG, PSTR("HandleBleConfiguration")); AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE: HandleBleConfiguration"));
#endif #endif
if (!HttpCheckPriviledgedAccess()) { if (!HttpCheckPriviledgedAccess()) {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG, PSTR("!HttpCheckPriviledgedAccess()")); AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE: !HttpCheckPriviledgedAccess()"));
#endif #endif
return; return;
} }
@ -3390,12 +3390,12 @@ void HandleBleConfiguration(void)
WebGetArg("en", tmp, sizeof(tmp)); WebGetArg("en", tmp, sizeof(tmp));
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("arg en is %s"), tmp); if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE: arg en is %s"), tmp);
#endif #endif
if (Webserver->hasArg("save")) { if (Webserver->hasArg("save")) {
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE SETTINGS SAVE")); AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE: SETTINGS SAVE"));
#endif #endif
Settings.flag5.mi32_enable = Webserver->hasArg("e0"); // Settings.flag5.mi32_enable = Webserver->hasArg("e0"); //
BLEScanActiveMode = (Webserver->hasArg("e1")?1:0); // BLEScanActiveMode = (Webserver->hasArg("e1")?1:0); //
@ -3405,7 +3405,7 @@ void HandleBleConfiguration(void)
return; return;
} }
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG, PSTR("!SAVE")); AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE: !SAVE"));
#endif #endif
char str[TOPSZ]; char str[TOPSZ];
@ -3460,7 +3460,7 @@ void HandleBleConfiguration(void)
\*********************************************************************************************/ \*********************************************************************************************/
int ExtStopBLE(){ int ExtStopBLE(){
AddLog_P(LOG_LEVEL_INFO, PSTR("Stopping BLE if active - upgrade starting?")); AddLog_P(LOG_LEVEL_INFO, PSTR("BLE: Stopping if active"));
BLE_ESP32::BLEMode = BLE_ESP32::BLEModeDisabled; BLE_ESP32::BLEMode = BLE_ESP32::BLEModeDisabled;
BLE_ESP32::StopBLE(); BLE_ESP32::StopBLE();
return 0; return 0;
@ -3548,13 +3548,13 @@ int myAdvertCallback(BLE_ESP32::ble_advertisment_t *pStruct) {
// this one is used to demonstrate processing ALL operations // this one is used to demonstrate processing ALL operations
int myOpCallback(BLE_ESP32::generic_sensor_t *pStruct){ int myOpCallback(BLE_ESP32::generic_sensor_t *pStruct){
AddLog_P(LOG_LEVEL_INFO,PSTR("myOpCallback")); AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: myOpCallback"));
return 0; // return true to block MQTT broadcast return 0; // return true to block MQTT broadcast
} }
// this one is used to demonstrate processing of ONE specific operation // this one is used to demonstrate processing of ONE specific operation
int myOpCallback2(BLE_ESP32::generic_sensor_t *pStruct){ int myOpCallback2(BLE_ESP32::generic_sensor_t *pStruct){
AddLog_P(LOG_LEVEL_INFO,PSTR("myOpCallback2")); AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: myOpCallback2"));
return 1; // return true to block MQTT broadcast return 1; // return true to block MQTT broadcast
} }
#endif #endif
@ -3577,7 +3577,7 @@ void sendExample(){
BLE_ESP32::generic_sensor_t *op = nullptr; BLE_ESP32::generic_sensor_t *op = nullptr;
int res = BLE_ESP32::newOperation(&op); int res = BLE_ESP32::newOperation(&op);
if (!res){ if (!res){
AddLog_P(LOG_LEVEL_ERROR,PSTR("Could not create new operation")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Could not create new operation"));
return; return;
} }
strncpy(op->MAC, "001A22092EE0", sizeof(op->MAC)); strncpy(op->MAC, "001A22092EE0", sizeof(op->MAC));
@ -3592,7 +3592,7 @@ void sendExample(){
if (!res){ if (!res){
// if it fails to add to the queue, do please delete it // if it fails to add to the queue, do please delete it
BLE_ESP32::freeOperation(&op); BLE_ESP32::freeOperation(&op);
AddLog_P(LOG_LEVEL_ERROR,PSTR("Failed to queue new operation - deleted")); AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: Failed to queue new operation - deleted"));
return; return;
} }

234
tasmota/xsns_62_MI_ESP32_BLE_ESP32.ino
View File

@ -490,7 +490,7 @@ int toggleUnit(BLE_ESP32::generic_sensor_t *op){
bool MI32Operation(int slot, int optype, const char *svc, const char *charactistic, const char *notifychar = nullptr, const uint8_t *data = nullptr, int datalen = 0, uint8_t *addr = nullptr ) { bool MI32Operation(int slot, int optype, const char *svc, const char *charactistic, const char *notifychar = nullptr, const uint8_t *data = nullptr, int datalen = 0, uint8_t *addr = nullptr ) {
if (!svc || !svc[0]){ if (!svc || !svc[0]){
AddLog_P(LOG_LEVEL_ERROR,PSTR("MI32Op: inv svc")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: Op inv svc"));
return 0; return 0;
} }
@ -499,17 +499,17 @@ bool MI32Operation(int slot, int optype, const char *svc, const char *charactist
// ALWAYS use this function to create a new one. // ALWAYS use this function to create a new one.
int res = BLE_ESP32::newOperation(&op); int res = BLE_ESP32::newOperation(&op);
if (!res){ if (!res){
AddLog_P(LOG_LEVEL_ERROR,PSTR("Can't get a newOperation from BLE")); AddLog_P(LOG_LEVEL_ERROR,PSTR("M32: Can't get a newOperation"));
return 0; return 0;
} else { } else {
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("got a newOperation from BLE")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: Got a newOperation"));
} }
if (slot >= 0){ if (slot >= 0){
op->addr = NimBLEAddress(MIBLEsensors[slot].MAC); op->addr = NimBLEAddress(MIBLEsensors[slot].MAC);
} else { } else {
if (!addr){ if (!addr){
AddLog_P(LOG_LEVEL_ERROR,PSTR("no addr")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: No addr"));
BLE_ESP32::freeOperation(&op); BLE_ESP32::freeOperation(&op);
return 0; return 0;
} }
@ -521,7 +521,7 @@ bool MI32Operation(int slot, int optype, const char *svc, const char *charactist
if (!op->serviceUUID.bitSize()){ if (!op->serviceUUID.bitSize()){
BLE_ESP32::freeOperation(&op); BLE_ESP32::freeOperation(&op);
AddLog_P(LOG_LEVEL_ERROR,PSTR("MI: Bad service string %s"), svc); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: MI Bad service string %s"), svc);
return 0; return 0;
} }
@ -531,7 +531,7 @@ bool MI32Operation(int slot, int optype, const char *svc, const char *charactist
op->characteristicUUID = NimBLEUUID(charactistic); op->characteristicUUID = NimBLEUUID(charactistic);
if (!op->characteristicUUID.bitSize()){ if (!op->characteristicUUID.bitSize()){
BLE_ESP32::freeOperation(&op); BLE_ESP32::freeOperation(&op);
AddLog_P(LOG_LEVEL_ERROR,PSTR("MI: Bad characteristic string %s"), charactistic); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: MI Bad characteristic string %s"), charactistic);
return 0; return 0;
} }
} }
@ -539,7 +539,7 @@ bool MI32Operation(int slot, int optype, const char *svc, const char *charactist
op->notificationCharacteristicUUID = NimBLEUUID(notifychar); op->notificationCharacteristicUUID = NimBLEUUID(notifychar);
if (!op->notificationCharacteristicUUID.bitSize()){ if (!op->notificationCharacteristicUUID.bitSize()){
BLE_ESP32::freeOperation(&op); BLE_ESP32::freeOperation(&op);
AddLog_P(LOG_LEVEL_ERROR,PSTR("MI: Bad notifycharacteristic string %s"), notifychar); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: MI Bad notifycharacteristic string %s"), notifychar);
return 0; return 0;
} }
} }
@ -564,13 +564,13 @@ bool MI32Operation(int slot, int optype, const char *svc, const char *charactist
uint32_t context = (optype << 24) | (MIBLEsensors[slot].type << 16) | slot; uint32_t context = (optype << 24) | (MIBLEsensors[slot].type << 16) | slot;
op->context = (void *)context; op->context = (void *)context;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI s:%d op:%s"), slot, BLE_ESP32::BLETriggerResponse(op).c_str()); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: MI s:%d op:%s"), slot, BLE_ESP32::BLETriggerResponse(op).c_str());
res = BLE_ESP32::extQueueOperation(&op); res = BLE_ESP32::extQueueOperation(&op);
if (!res){ if (!res){
// if it fails to add to the queue, do please delete it // if it fails to add to the queue, do please delete it
BLE_ESP32::freeOperation(&op); BLE_ESP32::freeOperation(&op);
AddLog_P(LOG_LEVEL_ERROR,PSTR("Failed to queue new operation - deleted")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: Failed to queue new operation - deleted"));
} }
return res; return res;
@ -611,9 +611,9 @@ int genericBatReadFn(int slot){
break; break;
} }
if (res > 0){ if (res > 0){
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("Req batt read slot %d type %d queued"), slot, MIBLEsensors[slot].type); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO, PSTR("M32: Req batt read slot %d type %d queued"), slot, MIBLEsensors[slot].type);
} else { } else {
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("Req batt read slot %d type %d non-queued res %d"), slot, MIBLEsensors[slot].type, res); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO, PSTR("M32: Req batt read slot %d type %d non-queued res %d"), slot, MIBLEsensors[slot].type, res);
} }
return res; return res;
} }
@ -653,7 +653,7 @@ int genericSensorReadFn(int slot, int force){
// called once per second // called once per second
int readOneSensor(){ int readOneSensor(){
if (MI32.sensorreader.active){ if (MI32.sensorreader.active){
AddLog_P(LOG_LEVEL_DEBUG,PSTR("readOneSensor - already active reading %d"), MI32.sensorreader.slot-1); AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: readOneSensor - already active reading %d"), MI32.sensorreader.slot-1);
return 0; return 0;
} }
@ -663,12 +663,12 @@ int readOneSensor(){
do { do {
// MI32.sensorreader.slot is reset to zero to trigger a read sequence // MI32.sensorreader.slot is reset to zero to trigger a read sequence
if (MI32.sensorreader.slot >= MIBLEsensors.size()){ if (MI32.sensorreader.slot >= MIBLEsensors.size()){
//AddLog_P(LOG_LEVEL_DEBUG,PSTR("readOneSensor past end of slots - %d > %d"), MI32.sensorreader.slot, MIBLEsensors.size()); //AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE: readOneSensor past end of slots - %d > %d"), MI32.sensorreader.slot, MIBLEsensors.size());
return 0; return 0;
} }
res = genericSensorReadFn(MI32.sensorreader.slot, 0); res = genericSensorReadFn(MI32.sensorreader.slot, 0);
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("genericSensorReadFn slot %d res %d"), MI32.sensorreader.slot, res); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: genericSensorReadFn slot %d res %d"), MI32.sensorreader.slot, res);
// if this sensor in this slot does not need to be read via notify, just move on top the next one // if this sensor in this slot does not need to be read via notify, just move on top the next one
if (res < 0){ if (res < 0){
@ -680,7 +680,7 @@ int readOneSensor(){
if (res == 0){ if (res == 0){
// can't read at the moment (no operations available?) // can't read at the moment (no operations available?)
AddLog_P(LOG_LEVEL_DEBUG,PSTR("readOneSensor no ops available slot %d res %d"), MI32.sensorreader.slot, res); AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: readOneSensor no ops available slot %d res %d"), MI32.sensorreader.slot, res);
return 0; return 0;
} }
@ -689,7 +689,7 @@ int readOneSensor(){
// and make it wait until the read/notify is complete // and make it wait until the read/notify is complete
// this is cleared in the response callback. // this is cleared in the response callback.
MI32.sensorreader.active = 1; MI32.sensorreader.active = 1;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("readOneSensor reading for slot %d res %d"), MI32.sensorreader.slot-1, res); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: readOneSensor reading for slot %d res %d"), MI32.sensorreader.slot-1, res);
// started one // started one
return 1; return 1;
@ -714,7 +714,7 @@ int readOneBat(){
if (res < 0){ if (res < 0){
MI32.batteryreader.slot++; MI32.batteryreader.slot++;
if (MI32.batteryreader.slot >= MIBLEsensors.size()){ if (MI32.batteryreader.slot >= MIBLEsensors.size()){
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("Batt loop complete at %d"), MI32.batteryreader.slot); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO, PSTR("M32: Batt loop complete at %d"), MI32.batteryreader.slot);
} }
return 0; return 0;
} }
@ -730,7 +730,7 @@ int readOneBat(){
// this is cleared in the response callback. // this is cleared in the response callback.
MI32.batteryreader.active = 1; MI32.batteryreader.active = 1;
if (MI32.batteryreader.slot >= MIBLEsensors.size()){ if (MI32.batteryreader.slot >= MIBLEsensors.size()){
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("Batt loop will complete at %d"), MI32.batteryreader.slot); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO, PSTR("M32: Batt loop will complete at %d"), MI32.batteryreader.slot);
} }
// started one // started one
return 1; return 1;
@ -816,7 +816,7 @@ int genericTimeWriteFn(int slot){
int genericOpCompleteFn(BLE_ESP32::generic_sensor_t *op){ int genericOpCompleteFn(BLE_ESP32::generic_sensor_t *op){
uint32_t context = (uint32_t) op->context; uint32_t context = (uint32_t) op->context;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI op complete context %x"), context); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: MI op complete context %x"), context);
int opType = context >> 24; int opType = context >> 24;
int devType = (context >> 16) & 0xff; int devType = (context >> 16) & 0xff;
@ -832,12 +832,12 @@ int genericOpCompleteFn(BLE_ESP32::generic_sensor_t *op){
bool fail = false; bool fail = false;
if (op->addr != addr){ if (op->addr != addr){
// slot changed during operation? // slot changed during operation?
AddLog_P(LOG_LEVEL_ERROR,PSTR("Slot mac changed during an operation")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: Slot mac changed during an operation"));
fail = true; fail = true;
} }
if (op->state <= GEN_STATE_FAILED){ if (op->state <= GEN_STATE_FAILED){
AddLog_P(LOG_LEVEL_ERROR,PSTR("operation failed %d for %s"), op->state, slotMAC); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: Operation failed %d for %s"), op->state, slotMAC);
fail = true; fail = true;
} }
@ -857,7 +857,7 @@ int genericOpCompleteFn(BLE_ESP32::generic_sensor_t *op){
switch(opType){ switch(opType){
case OP_TIME_WRITE: case OP_TIME_WRITE:
AddLog_P(LOG_LEVEL_DEBUG,PSTR("Time write for %s complete"), slotMAC); AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: Time write for %s complete"), slotMAC);
return 0; // nothing to do return 0; // nothing to do
case OP_BATT_READ:{ case OP_BATT_READ:{
uint8_t *data = nullptr; uint8_t *data = nullptr;
@ -876,33 +876,33 @@ int genericOpCompleteFn(BLE_ESP32::generic_sensor_t *op){
// allow another... // allow another...
MI32.batteryreader.active = 0; MI32.batteryreader.active = 0;
AddLog_P(LOG_LEVEL_INFO,PSTR("batt read slot %d done state %x"), slot, op->state); AddLog_P(LOG_LEVEL_INFO, PSTR("M32: Batt read slot %d done state %x"), slot, op->state);
} return 0; } return 0;
case OP_UNIT_WRITE: // nothing more to do? case OP_UNIT_WRITE: // nothing more to do?
AddLog_P(LOG_LEVEL_DEBUG,PSTR("Unit write for %s complete"), slotMAC); AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: Unit write for %s complete"), slotMAC);
return 0; return 0;
case OP_UNIT_READ: { case OP_UNIT_READ: {
uint8_t currUnit = op->dataRead[0]; uint8_t currUnit = op->dataRead[0];
AddLog_P(LOG_LEVEL_DEBUG,PSTR("Unit read for %s complete %d"), slotMAC, currUnit); AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: Unit read for %s complete %d"), slotMAC, currUnit);
} return 0; } return 0;
case OP_UNIT_TOGGLE: { case OP_UNIT_TOGGLE: {
uint8_t currUnit = op->dataToWrite[0]; uint8_t currUnit = op->dataToWrite[0];
AddLog_P(LOG_LEVEL_DEBUG,PSTR("Unit toggle for %s complete %d->%d; datasize was %d"), slotMAC, op->dataRead[0], op->dataToWrite[0], op->readlen); AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: Unit toggle for %s complete %d->%d; datasize was %d"), slotMAC, op->dataRead[0], op->dataToWrite[0], op->readlen);
} return 0; } return 0;
case OP_READ_HT_LY: { case OP_READ_HT_LY: {
// allow another... // allow another...
MI32.sensorreader.active = 0; MI32.sensorreader.active = 0;
MI32notifyHT_LY(slot, (char*)op->dataNotify, op->notifylen); MI32notifyHT_LY(slot, (char*)op->dataNotify, op->notifylen);
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("HT_LY notify for %s complete"), slotMAC); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: HT_LY notify for %s complete"), slotMAC);
} return 0; } return 0;
default: default:
AddLog_P(LOG_LEVEL_ERROR,PSTR("OpType %d not recognised?"), opType); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: OpType %d not recognised?"), opType);
return 0; return 0;
} }
@ -914,7 +914,7 @@ int MI32advertismentCallback(BLE_ESP32::ble_advertisment_t *pStruct)
// we will try not to use this... // we will try not to use this...
BLEAdvertisedDevice *advertisedDevice = pStruct->advertisedDevice; BLEAdvertisedDevice *advertisedDevice = pStruct->advertisedDevice;
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Advertised Device: %s Buffer: %u"),advertisedDevice->getAddress().toString().c_str(),advertisedDevice->getServiceData(0).length()); // AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: Advertised Device: %s Buffer: %u"),advertisedDevice->getAddress().toString().c_str(),advertisedDevice->getServiceData(0).length());
int RSSI = pStruct->RSSI; int RSSI = pStruct->RSSI;
const uint8_t *addr = pStruct->addr; const uint8_t *addr = pStruct->addr;
if(MI32isInBlockList(addr) == true) return 0; if(MI32isInBlockList(addr) == true) return 0;
@ -937,13 +937,13 @@ int MI32advertismentCallback(BLE_ESP32::ble_advertisment_t *pStruct)
char temp[60]; char temp[60];
BLE_ESP32::dump(temp, 13, addr, 6); BLE_ESP32::dump(temp, 13, addr, 6);
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("MI:%s svc[0] UUID (%x)"), temp, UUID); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("M32: MI:%s svc[0] UUID (%x)"), temp, UUID);
std::string ServiceDataStr = advertisedDevice->getServiceData(0); std::string ServiceDataStr = advertisedDevice->getServiceData(0);
uint32_t ServiceDataLength = ServiceDataStr.length(); uint32_t ServiceDataLength = ServiceDataStr.length();
const uint8_t *ServiceData = (const uint8_t *)ServiceDataStr.data(); const uint8_t *ServiceData = (const uint8_t *)ServiceDataStr.data();
BLE_ESP32::dump(temp, 60, ServiceData, ServiceDataLength); BLE_ESP32::dump(temp, 60, ServiceData, ServiceDataLength);
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("MI:%s"), temp); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("M32: MI:%s"), temp);
if (UUID){ if (UUID){
@ -1041,14 +1041,14 @@ int MI32AddKey(char* payload, char* key = nullptr){
bool unknownKey = true; bool unknownKey = true;
for(uint32_t i=0; i<MIBLEbindKeys.size(); i++){ for(uint32_t i=0; i<MIBLEbindKeys.size(); i++){
if(memcmp(keyMAC.MAC,MIBLEbindKeys[i].MAC,sizeof(keyMAC.MAC))==0){ if(memcmp(keyMAC.MAC,MIBLEbindKeys[i].MAC,sizeof(keyMAC.MAC))==0){
AddLog_P(LOG_LEVEL_DEBUG,PSTR("known key")); AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: Known key"));
memcpy(MIBLEbindKeys[i].key, keyMAC.key, 16); memcpy(MIBLEbindKeys[i].key, keyMAC.key, 16);
unknownKey=false; unknownKey=false;
return 1; return 1;
} }
} }
if(unknownKey){ if(unknownKey){
AddLog_P(LOG_LEVEL_DEBUG,PSTR("New key")); AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: New key"));
MIBLEbindKeys.push_back(keyMAC); MIBLEbindKeys.push_back(keyMAC);
return 1; return 1;
} }
@ -1066,17 +1066,17 @@ int MIDecryptPayload(const uint8_t *macin, const uint8_t *nonce, uint32_t tag, u
uint8_t _bindkey[32] = {0x0}; uint8_t _bindkey[32] = {0x0};
const unsigned char authData[16] = {0x11}; const unsigned char authData[16] = {0x11};
bool foundNoKey = true; bool foundNoKey = true;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI32: search key for MAC: %02x%02x%02x%02x%02x%02x"), mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: Search key for MAC: %02x%02x%02x%02x%02x%02x"), mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
for(uint32_t i=0; i<MIBLEbindKeys.size(); i++){ for(uint32_t i=0; i<MIBLEbindKeys.size(); i++){
if(memcmp(mac, MIBLEbindKeys[i].MAC, 6)==0){ if(memcmp(mac, MIBLEbindKeys[i].MAC, 6)==0){
memcpy(_bindkey, MIBLEbindKeys[i].key, 16); memcpy(_bindkey, MIBLEbindKeys[i].key, 16);
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI32: decryption Key found")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Decryption Key found"));
foundNoKey = false; foundNoKey = false;
break; break;
} }
} }
if(foundNoKey){ if(foundNoKey){
AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI32: no Key found !!")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: No Key found"));
return -2; // indicates needs key return -2; // indicates needs key
} }
@ -1098,7 +1098,7 @@ int MIDecryptPayload(const uint8_t *macin, const uint8_t *nonce, uint32_t tag, u
// returns 1 if matched, else 0 // returns 1 if matched, else 0
int ret = br_ccm_check_tag(&ctx, &tag); int ret = br_ccm_check_tag(&ctx, &tag);
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI32: Err:%i, Decrypted : %02x %02x %02x %02x %02x"), ret, payload[1],payload[2],payload[3],payload[4],payload[5]); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Err:%i, Decrypted : %02x %02x %02x %02x %02x"), ret, payload[1],payload[2],payload[3],payload[4],payload[5]);
return ret-1; // -> -1=fail, 0=success return ret-1; // -> -1=fail, 0=success
} }
@ -1168,7 +1168,7 @@ int MIParsePacket(const uint8_t* slotmac, struct mi_beacon_data_t *parsed, const
parsed->devicetype = *((uint16_t *)(data + byteindex)); parsed->devicetype = *((uint16_t *)(data + byteindex));
byteindex += 2; byteindex += 2;
parsed->framecnt = data[byteindex]; parsed->framecnt = data[byteindex];
//if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI frame %d"), parsed->framecnt); //if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: MI frame %d"), parsed->framecnt);
byteindex++; byteindex++;
@ -1217,17 +1217,17 @@ int MIParsePacket(const uint8_t* slotmac, struct mi_beacon_data_t *parsed, const
break; break;
case 0: // suceeded case 0: // suceeded
parsed->needkey = KEY_REQUIRED_AND_FOUND; parsed->needkey = KEY_REQUIRED_AND_FOUND;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI payload decrypted")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Payload decrypted"));
break; break;
case -1: // key failed to work case -1: // key failed to work
parsed->needkey = KEY_REQUIRED_AND_INVALID; parsed->needkey = KEY_REQUIRED_AND_INVALID;
AddLog_P(LOG_LEVEL_ERROR,PSTR("MI payload decrypt failed")); AddLog_P(LOG_LEVEL_ERROR,PSTR("M32: Payload decrypt failed"));
parsed->payloadpresent = 0; parsed->payloadpresent = 0;
return 0; return 0;
break; break;
case -2: // key not present case -2: // key not present
parsed->needkey = KEY_REQUIRED_BUT_NOT_FOUND; parsed->needkey = KEY_REQUIRED_BUT_NOT_FOUND;
AddLog_P(LOG_LEVEL_ERROR,PSTR("MI payload encrypted but no key")); AddLog_P(LOG_LEVEL_ERROR,PSTR("M32: Payload encrypted but no key"));
parsed->payloadpresent = 0; parsed->payloadpresent = 0;
return 0; return 0;
break; break;
@ -1262,7 +1262,7 @@ int MIParsePacket(const uint8_t* slotmac, struct mi_beacon_data_t *parsed, const
} }
if ((len - byteindex) == 0){ if ((len - byteindex) == 0){
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI no payload")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: No payload"));
parsed->payload.size = 0; parsed->payload.size = 0;
parsed->payloadpresent = 0; parsed->payloadpresent = 0;
return 0; return 0;
@ -1271,14 +1271,14 @@ int MIParsePacket(const uint8_t* slotmac, struct mi_beacon_data_t *parsed, const
// we have payload which did not need decrypt. // we have payload which did not need decrypt.
if (decres == 1){ if (decres == 1){
parsed->needkey = KEY_NOT_REQUIRED; parsed->needkey = KEY_NOT_REQUIRED;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI payload unencrypted")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Payload unencrypted"));
} }
// already decrypted if required // already decrypted if required
parsed->payloadpresent = 1; parsed->payloadpresent = 1;
memcpy(&parsed->payload, (data + byteindex), (len - byteindex)); memcpy(&parsed->payload, (data + byteindex), (len - byteindex));
if (parsed->payload.size != (len - byteindex) - 3){ if (parsed->payload.size != (len - byteindex) - 3){
AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI payload length mismatch")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Payload length mismatch"));
} }
return 1; return 1;
@ -1319,7 +1319,7 @@ void MI32nullifyEndOfMQTT_DATA(){
*/ */
uint32_t MIBLEgetSensorSlot(const uint8_t *mac, uint16_t _type, uint8_t counter){ uint32_t MIBLEgetSensorSlot(const uint8_t *mac, uint16_t _type, uint8_t counter){
//AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("%s: will test ID-type: %x"),D_CMND_MI32, _type); //AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: will test ID-type: %x"),D_CMND_MI32, _type);
bool _success = false; bool _success = false;
for (uint32_t i=0; i < MI_MI32_TYPES; i++){ // i < sizeof(kMI32DeviceID) gives compiler warning for (uint32_t i=0; i < MI_MI32_TYPES; i++){ // i < sizeof(kMI32DeviceID) gives compiler warning
if(_type == kMI32DeviceID[i]){ if(_type == kMI32DeviceID[i]){
@ -1328,40 +1328,40 @@ uint32_t MIBLEgetSensorSlot(const uint8_t *mac, uint16_t _type, uint8_t counter)
break; break;
} }
else { else {
//AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("%s: ID-type is not: %x"),D_CMND_MI32,kMI32DeviceID[i]); //AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: ID-type is not: %x"),D_CMND_MI32,kMI32DeviceID[i]);
} }
} }
if(!_success) { if(!_success) {
_type = 1; // unknown _type = 1; // unknown
} }
//AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("%s: vector size %u"),D_CMND_MI32, MIBLEsensors.size()); //AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: vector size %u"),D_CMND_MI32, MIBLEsensors.size());
for(uint32_t i=0; i<MIBLEsensors.size(); i++){ for(uint32_t i=0; i<MIBLEsensors.size(); i++){
if(memcmp(mac, MIBLEsensors[i].MAC, 6)==0){ if(memcmp(mac, MIBLEsensors[i].MAC, 6)==0){
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Counters: %x %x"),MIBLEsensors[i].lastCnt, counter); // AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Counters: %x %x"),MIBLEsensors[i].lastCnt, counter);
if(MIBLEsensors[i].lastCnt==counter) { if(MIBLEsensors[i].lastCnt==counter) {
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Old packet")); // AddLog_P(LOG_LEVEL_DEBUG,PSTR("Old packet"));
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("%s: slot: %u/%u - ign repeat"),D_CMND_MI32, i, MIBLEsensors.size()); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: slot: %u/%u - ign repeat"),D_CMND_MI32, i, MIBLEsensors.size());
//return 0xff; // packet received before, stop here //return 0xff; // packet received before, stop here
} }
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI frame %d, last %d"), counter, MIBLEsensors[i].lastCnt); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Frame %d, last %d"), counter, MIBLEsensors[i].lastCnt);
MIBLEsensors[i].lastCnt = counter; MIBLEsensors[i].lastCnt = counter;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("%s: slot: %u/%u"),D_CMND_MI32, i, MIBLEsensors.size()); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: slot: %u/%u"),D_CMND_MI32, i, MIBLEsensors.size());
if (MIBLEsensors[i].type != _type){ if (MIBLEsensors[i].type != _type){
// this happens on incorrectly configured pvvx ATC firmware // this happens on incorrectly configured pvvx ATC firmware
AddLog_P(LOG_LEVEL_ERROR,PSTR("%s: slot: %u - device type 0x%04x(%s) -> 0x%04x(%s) - check device is only sending one type of advert."),D_CMND_MI32, i, AddLog_P(LOG_LEVEL_ERROR,PSTR("M32: %s: slot: %u - device type 0x%04x(%s) -> 0x%04x(%s) - check device is only sending one type of advert."),D_CMND_MI32, i,
kMI32DeviceID[MIBLEsensors[i].type-1], kMI32DeviceType[MIBLEsensors[i].type-1], kMI32DeviceID[_type-1], kMI32DeviceType[_type-1]); kMI32DeviceID[MIBLEsensors[i].type-1], kMI32DeviceType[MIBLEsensors[i].type-1], kMI32DeviceID[_type-1], kMI32DeviceType[_type-1]);
MIBLEsensors[i].type = _type; MIBLEsensors[i].type = _type;
} }
return i; return i;
} }
//AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("%s: i: %x %x %x %x %x %x"),D_CMND_MI32, MIBLEsensors[i].MAC[5], MIBLEsensors[i].MAC[4],MIBLEsensors[i].MAC[3],MIBLEsensors[i].MAC[2],MIBLEsensors[i].MAC[1],MIBLEsensors[i].MAC[0]); //AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: i: %x %x %x %x %x %x"),D_CMND_MI32, MIBLEsensors[i].MAC[5], MIBLEsensors[i].MAC[4],MIBLEsensors[i].MAC[3],MIBLEsensors[i].MAC[2],MIBLEsensors[i].MAC[1],MIBLEsensors[i].MAC[0]);
//AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("%s: n: %x %x %x %x %x %x"),D_CMND_MI32, mac[5], mac[4], mac[3],mac[2],mac[1],mac[0]); //AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: n: %x %x %x %x %x %x"),D_CMND_MI32, mac[5], mac[4], mac[3],mac[2],mac[1],mac[0]);
} }
//AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("%s: new sensor -> slot: %u"),D_CMND_MI32, MIBLEsensors.size()); //AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: new sensor -> slot: %u"),D_CMND_MI32, MIBLEsensors.size());
//AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("%s: found new sensor"),D_CMND_MI32); //AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: found new sensor"),D_CMND_MI32);
mi_sensor_t _newSensor; mi_sensor_t _newSensor;
memset(&_newSensor, 0 , sizeof(_newSensor)); memset(&_newSensor, 0 , sizeof(_newSensor));
memcpy(_newSensor.MAC, mac, 6); memcpy(_newSensor.MAC, mac, 6);
@ -1411,7 +1411,7 @@ uint32_t MIBLEgetSensorSlot(const uint8_t *mac, uint16_t _type, uint8_t counter)
break; break;
} }
MIBLEsensors.push_back(_newSensor); MIBLEsensors.push_back(_newSensor);
AddLog_P(LOG_LEVEL_DEBUG,PSTR("%s: new %s at slot: %u"),D_CMND_MI32, kMI32DeviceType[_type-1],MIBLEsensors.size()-1); AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: %s: new %s at slot: %u"),D_CMND_MI32, kMI32DeviceType[_type-1],MIBLEsensors.size()-1);
MI32.mode.shallShowStatusInfo = 1; MI32.mode.shallShowStatusInfo = 1;
return MIBLEsensors.size()-1; return MIBLEsensors.size()-1;
}; };
@ -1444,7 +1444,7 @@ void MI32StatusInfo() {
int MI32scanCompleteCallback(NimBLEScanResults results){ int MI32scanCompleteCallback(NimBLEScanResults results){
// we actually don't need to do anything here.... // we actually don't need to do anything here....
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI32: scancomplete")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Scan complete"));
return 0; return 0;
} }
@ -1473,7 +1473,7 @@ void MI32Init(void) {
// note: for operations, we will set individual callbacks in the operations we request // note: for operations, we will set individual callbacks in the operations we request
//void registerForOpCallbacks(const char *tag, BLE_ESP32::OPCOMPLETE_CALLBACK* pFn); //void registerForOpCallbacks(const char *tag, BLE_ESP32::OPCOMPLETE_CALLBACK* pFn);
AddLog_P(LOG_LEVEL_INFO,PSTR("MI32: init: request callbacks")); AddLog_P(LOG_LEVEL_INFO,PSTR("M32: init: request callbacks"));
MI32.period = Settings.tele_period; MI32.period = Settings.tele_period;
MI32.mode.init = 1; MI32.mode.init = 1;
return; return;
@ -1496,19 +1496,19 @@ int MIParseBatt(int slot, uint8_t *data, int len){
MIBLEsensors[slot].bat = value; MIBLEsensors[slot].bat = value;
if(MIBLEsensors[slot].type==MI_FLORA){ if(MIBLEsensors[slot].type==MI_FLORA){
if (len < 7){ if (len < 7){
AddLog_P(LOG_LEVEL_ERROR,PSTR("FLORA: not enough bytes read for firmware?")); AddLog_P(LOG_LEVEL_ERROR,PSTR("M32: FLORA: not enough bytes read for firmware?"));
} else { } else {
memcpy(MIBLEsensors[slot].firmware, data+2, 5); memcpy(MIBLEsensors[slot].firmware, data+2, 5);
MIBLEsensors[slot].firmware[5] = '\0'; MIBLEsensors[slot].firmware[5] = '\0';
AddLog_P(LOG_LEVEL_DEBUG,PSTR("%s: FLORA Firmware: %s"),D_CMND_MI32,MIBLEsensors[slot].firmware); AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: %s: FLORA Firmware: %s"),D_CMND_MI32,MIBLEsensors[slot].firmware);
} }
} }
MIBLEsensors[slot].eventType.bat = 1; MIBLEsensors[slot].eventType.bat = 1;
MIBLEsensors[slot].shallSendMQTT = 1; MIBLEsensors[slot].shallSendMQTT = 1;
MI32.mode.shallTriggerTele = 1; MI32.mode.shallTriggerTele = 1;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("Batt read for %s complete %d"), slotMAC, value); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Batt read for %s complete %d"), slotMAC, value);
} else { } else {
AddLog_P(LOG_LEVEL_ERROR,PSTR("Batt read for %s complete but out of range 1-101 (%d)"), slotMAC, value); AddLog_P(LOG_LEVEL_ERROR,PSTR("M32: Batt read for %s complete but out of range 1-101 (%d)"), slotMAC, value);
} }
return 0; return 0;
@ -1540,7 +1540,7 @@ void MI32ParseATCPacket(const uint8_t * _buf, uint32_t length, const uint8_t *ad
if(_slot==0xff) return; if(_slot==0xff) return;
if ((_slot >= 0) && (_slot < MIBLEsensors.size())){ if ((_slot >= 0) && (_slot < MIBLEsensors.size())){
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("%s:pvvx at slot %u"), kMI32DeviceType[MIBLEsensors[_slot].type-1],_slot); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: %s:pvvx at slot %u"), kMI32DeviceType[MIBLEsensors[_slot].type-1],_slot);
MIBLEsensors[_slot].RSSI=RSSI; MIBLEsensors[_slot].RSSI=RSSI;
MIBLEsensors[_slot].needkey=KEY_NOT_REQUIRED; MIBLEsensors[_slot].needkey=KEY_NOT_REQUIRED;
@ -1557,7 +1557,7 @@ void MI32ParseATCPacket(const uint8_t * _buf, uint32_t length, const uint8_t *ad
} }
return; return;
} else { } else {
AddLog_P(LOG_LEVEL_ERROR, PSTR("PVVX packet mac mismatch - ignored?")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: PVVX packet mac mismatch - ignored?"));
return; return;
} }
} }
@ -1571,9 +1571,9 @@ void MI32ParseATCPacket(const uint8_t * _buf, uint32_t length, const uint8_t *ad
if (memcmp(addrrev, _packet->MAC, 6)){ if (memcmp(addrrev, _packet->MAC, 6)){
MI32_ReverseMAC(_packet->MAC); MI32_ReverseMAC(_packet->MAC);
if (!memcmp(addrrev, _packet->MAC, 6)){ if (!memcmp(addrrev, _packet->MAC, 6)){
AddLog_P(LOG_LEVEL_ERROR, PSTR("ATC packet with reversed MAC addr?")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: ATC packet with reversed MAC addr?"));
} else { } else {
AddLog_P(LOG_LEVEL_ERROR, PSTR("ATC packet with MAC addr mismatch - is this mesh?")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: ATC packet with MAC addr mismatch - is this mesh?"));
memcpy(addrrev, _packet->MAC, 6); memcpy(addrrev, _packet->MAC, 6);
} }
addr = addrrev; addr = addrrev;
@ -1584,7 +1584,7 @@ void MI32ParseATCPacket(const uint8_t * _buf, uint32_t length, const uint8_t *ad
if(_slot==0xff) return; if(_slot==0xff) return;
if ((_slot >= 0) && (_slot < MIBLEsensors.size())){ if ((_slot >= 0) && (_slot < MIBLEsensors.size())){
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("%s at slot %u"), kMI32DeviceType[MIBLEsensors[_slot].type-1],_slot); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: %s at slot %u"), kMI32DeviceType[MIBLEsensors[_slot].type-1],_slot);
MIBLEsensors[_slot].RSSI=RSSI; MIBLEsensors[_slot].RSSI=RSSI;
MIBLEsensors[_slot].needkey=KEY_NOT_REQUIRED; MIBLEsensors[_slot].needkey=KEY_NOT_REQUIRED;
@ -1616,7 +1616,7 @@ int MI32parseMiPayload(int _slot, struct mi_beacon_data_t *parsed){
char tmp[20]; char tmp[20];
BLE_ESP32::dump(tmp, 20, (uint8_t*)&(parsed->payload), parsed->payload.size+3); BLE_ESP32::dump(tmp, 20, (uint8_t*)&(parsed->payload), parsed->payload.size+3);
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("MI%d payload %s"), _slot, tmp); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: MI%d payload %s"), _slot, tmp);
switch(parsed->payload.type){ switch(parsed->payload.type){
case 0x01: // button press case 0x01: // button press
@ -1636,22 +1636,22 @@ int MI32parseMiPayload(int _slot, struct mi_beacon_data_t *parsed){
if(_tempFloat<60){ if(_tempFloat<60){
MIBLEsensors[_slot].temp=_tempFloat; MIBLEsensors[_slot].temp=_tempFloat;
MIBLEsensors[_slot].eventType.temp = 1; MIBLEsensors[_slot].eventType.temp = 1;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode 4: temp updated")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 4: temp updated"));
} else { } else {
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode 4: temp ignored > 60 (%f)"), _tempFloat); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 4: temp ignored > 60 (%f)"), _tempFloat);
} }
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Mode 4: U16: %u Temp"), _beacon.temp ); // AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Mode 4: U16: %u Temp"), _beacon.temp );
} break; } break;
case 0x06: { case 0x06: {
float _tempFloat=(float)(pld->hum)/10.0f; float _tempFloat=(float)(pld->hum)/10.0f;
if(_tempFloat<101){ if(_tempFloat<101){
MIBLEsensors[_slot].hum=_tempFloat; MIBLEsensors[_slot].hum=_tempFloat;
MIBLEsensors[_slot].eventType.hum = 1; MIBLEsensors[_slot].eventType.hum = 1;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode 6: hum updated")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 6: hum updated"));
} else { } else {
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode 6: hum ignored > 101 (%f)"), _tempFloat); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 6: hum ignored > 101 (%f)"), _tempFloat);
} }
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Mode 6: U16: %u Hum"), _beacon.hum); // AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Mode 6: U16: %u Hum"), _beacon.hum);
} break; } break;
case 0x07: case 0x07:
MIBLEsensors[_slot].lux=pld->lux & 0x00ffffff; MIBLEsensors[_slot].lux=pld->lux & 0x00ffffff;
@ -1659,19 +1659,19 @@ int MI32parseMiPayload(int _slot, struct mi_beacon_data_t *parsed){
MIBLEsensors[_slot].eventType.noMotion = 1; MIBLEsensors[_slot].eventType.noMotion = 1;
} }
MIBLEsensors[_slot].eventType.lux = 1; MIBLEsensors[_slot].eventType.lux = 1;
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Mode 7: U24: %u Lux"), _beacon.lux & 0x00ffffff); // AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Mode 7: U24: %u Lux"), _beacon.lux & 0x00ffffff);
break; break;
case 0x08: case 0x08:
MIBLEsensors[_slot].moisture=pld->moist; MIBLEsensors[_slot].moisture=pld->moist;
MIBLEsensors[_slot].eventType.moist = 1; MIBLEsensors[_slot].eventType.moist = 1;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode 8: moisture updated")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 8: moisture updated"));
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Mode 8: U8: %u Moisture"), _beacon.moist); // AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Mode 8: U8: %u Moisture"), _beacon.moist);
break; break;
case 0x09: // 'conductivity' case 0x09: // 'conductivity'
MIBLEsensors[_slot].fertility=pld->fert; MIBLEsensors[_slot].fertility=pld->fert;
MIBLEsensors[_slot].eventType.fert = 1; MIBLEsensors[_slot].eventType.fert = 1;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode 9: fertility updated")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 9: fertility updated"));
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Mode 9: U16: %u Fertility"), _beacon.fert); // AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Mode 9: U16: %u Fertility"), _beacon.fert);
break; break;
case 0x0a: case 0x0a:
if(MI32.option.ignoreBogusBattery){ if(MI32.option.ignoreBogusBattery){
@ -1683,31 +1683,31 @@ int MI32parseMiPayload(int _slot, struct mi_beacon_data_t *parsed){
if(pld->bat<101){ if(pld->bat<101){
MIBLEsensors[_slot].bat = pld->bat; MIBLEsensors[_slot].bat = pld->bat;
MIBLEsensors[_slot].eventType.bat = 1; MIBLEsensors[_slot].eventType.bat = 1;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode a: bat updated")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode a: bat updated"));
} else { } else {
MIBLEsensors[_slot].bat = 100; MIBLEsensors[_slot].bat = 100;
MIBLEsensors[_slot].eventType.bat = 1; MIBLEsensors[_slot].eventType.bat = 1;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode a: bat > 100 (%d)"), pld->bat); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode a: bat > 100 (%d)"), pld->bat);
} }
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Mode a: U8: %u %%"), _beacon.bat); // AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Mode a: U8: %u %%"), _beacon.bat);
break; break;
case 0x0d:{ case 0x0d:{
float _tempFloat=(float)(pld->HT.temp)/10.0f; float _tempFloat=(float)(pld->HT.temp)/10.0f;
if(_tempFloat < 60){ if(_tempFloat < 60){
MIBLEsensors[_slot].temp = _tempFloat; MIBLEsensors[_slot].temp = _tempFloat;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode d: temp updated")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode d: temp updated"));
} else { } else {
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode d: temp ignored > 60 (%f)"), _tempFloat); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode d: temp ignored > 60 (%f)"), _tempFloat);
} }
_tempFloat=(float)(pld->HT.hum)/10.0f; _tempFloat=(float)(pld->HT.hum)/10.0f;
if(_tempFloat < 100){ if(_tempFloat < 100){
MIBLEsensors[_slot].hum = _tempFloat; MIBLEsensors[_slot].hum = _tempFloat;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode d: hum updated")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode d: hum updated"));
} else { } else {
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode d: hum ignored > 100 (%f)"), _tempFloat); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode d: hum ignored > 100 (%f)"), _tempFloat);
} }
MIBLEsensors[_slot].eventType.tempHum = 1; MIBLEsensors[_slot].eventType.tempHum = 1;
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Mode d: U16: %x Temp U16: %x Hum"), _beacon.HT.temp, _beacon.HT.hum); // AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Mode d: U16: %x Temp U16: %x Hum"), _beacon.HT.temp, _beacon.HT.hum);
} break; } break;
case 0x0f: case 0x0f:
if (parsed->payload.ten != 0) break; if (parsed->payload.ten != 0) break;
@ -1718,7 +1718,7 @@ int MI32parseMiPayload(int _slot, struct mi_beacon_data_t *parsed){
MIBLEsensors[_slot].eventType.lux = 1; MIBLEsensors[_slot].eventType.lux = 1;
MIBLEsensors[_slot].NMT = 0; MIBLEsensors[_slot].NMT = 0;
MI32.mode.shallTriggerTele = 1; MI32.mode.shallTriggerTele = 1;
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("PIR: primary"),MIBLEsensors[_slot].lux ); // AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: PIR: primary"),MIBLEsensors[_slot].lux );
break; break;
case 0x10:{ // 'formaldehide' case 0x10:{ // 'formaldehide'
const uint16_t f = uint16_t(parsed->payload.data[0]) | (uint16_t(parsed->payload.data[1]) << 8); const uint16_t f = uint16_t(parsed->payload.data[0]) | (uint16_t(parsed->payload.data[1]) << 8);
@ -1742,11 +1742,11 @@ int MI32parseMiPayload(int _slot, struct mi_beacon_data_t *parsed){
MIBLEsensors[_slot].NMT = pld->NMT; MIBLEsensors[_slot].NMT = pld->NMT;
MIBLEsensors[_slot].eventType.NMT = 1; MIBLEsensors[_slot].eventType.NMT = 1;
MI32.mode.shallTriggerTele = 1; MI32.mode.shallTriggerTele = 1;
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Mode 17: NMT: %u seconds"), _beacon.NMT); // AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Mode 17: NMT: %u seconds"), _beacon.NMT);
} break; } break;
default: { default: {
AddLog_P(LOG_LEVEL_DEBUG,PSTR("Unknown MI pld")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Unknown MI pld"));
res = 0; res = 0;
} break; } break;
} }
@ -1771,7 +1771,7 @@ void MI32ParseResponse(const uint8_t *buf, uint16_t bufsize, const uint8_t* addr
MI32_ReverseMAC(addrrev); MI32_ReverseMAC(addrrev);
if (memcmp(addrrev, parsed.macdata.mac, 6)){ if (memcmp(addrrev, parsed.macdata.mac, 6)){
AddLog_P(LOG_LEVEL_ERROR, PSTR("MI packet with MAC addr mismatch - is this mesh?")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: MI packet with MAC addr mismatch - is this mesh?"));
memcpy(addrrev, parsed.macdata.mac, 6); memcpy(addrrev, parsed.macdata.mac, 6);
MI32_ReverseMAC(addrrev); MI32_ReverseMAC(addrrev);
addr = addrrev; addr = addrrev;
@ -1785,7 +1785,7 @@ void MI32ParseResponse(const uint8_t *buf, uint16_t bufsize, const uint8_t* addr
} }
MIBLEsensors[_slot].RSSI=RSSI; MIBLEsensors[_slot].RSSI=RSSI;
if (!res){ // - if the payload is not valid if (!res){ // - if the payload is not valid
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("MIParsePacket returned %d"), res); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: MIParsePacket returned %d"), res);
return; return;
} else { } else {
} }
@ -1814,14 +1814,14 @@ void MI32removeMIBLEsensor(uint8_t* MAC){
\***********************************************************************/ \***********************************************************************/
void MI32notifyHT_LY(int slot, char *_buf, int len){ void MI32notifyHT_LY(int slot, char *_buf, int len){
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("%s: raw data: %x%x%x%x%x%x%x"),D_CMND_MI32,_buf[0],_buf[1],_buf[2],_buf[3],_buf[4],_buf[5],_buf[6]); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: raw data: %x%x%x%x%x%x%x"),D_CMND_MI32,_buf[0],_buf[1],_buf[2],_buf[3],_buf[4],_buf[5],_buf[6]);
// the value 0b00 is 28.16 C? // the value 0b00 is 28.16 C?
if(_buf[0] != 0 || _buf[1] != 0){ if(_buf[0] != 0 || _buf[1] != 0){
memcpy(&LYWSD0x_HT,(void *)_buf,sizeof(LYWSD0x_HT)); memcpy(&LYWSD0x_HT,(void *)_buf,sizeof(LYWSD0x_HT));
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("%s: T * 100: %u, H: %u, V: %u"),D_CMND_MI32,LYWSD0x_HT.temp,LYWSD0x_HT.hum, LYWSD0x_HT.volt); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: %s: T * 100: %u, H: %u, V: %u"),D_CMND_MI32,LYWSD0x_HT.temp,LYWSD0x_HT.hum, LYWSD0x_HT.volt);
uint32_t _slot = slot; uint32_t _slot = slot;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("MIBLE: Sensor slot: %u"), _slot); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: MIBLE: Sensor slot: %u"), _slot);
static float _tempFloat; static float _tempFloat;
_tempFloat=(float)(LYWSD0x_HT.temp)/100.0f; _tempFloat=(float)(LYWSD0x_HT.temp)/100.0f;
if(_tempFloat<60){ if(_tempFloat<60){
@ -1831,7 +1831,7 @@ void MI32notifyHT_LY(int slot, char *_buf, int len){
_tempFloat=(float)LYWSD0x_HT.hum; _tempFloat=(float)LYWSD0x_HT.hum;
if(_tempFloat<100){ if(_tempFloat<100){
MIBLEsensors[_slot].hum = _tempFloat; MIBLEsensors[_slot].hum = _tempFloat;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("LYWSD0x: hum updated")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: LYWSD0x: hum updated"));
} }
MIBLEsensors[_slot].eventType.tempHum = 1; MIBLEsensors[_slot].eventType.tempHum = 1;
if (MIBLEsensors[_slot].type == MI_LYWSD03MMC || MIBLEsensors[_slot].type == MI_MHOC401){ if (MIBLEsensors[_slot].type == MI_LYWSD03MMC || MIBLEsensors[_slot].type == MI_MHOC401){
@ -1875,7 +1875,7 @@ void MI32Every50mSecond(){
void MI32EverySecond(bool restart){ void MI32EverySecond(bool restart){
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("MI32: onesec")); // AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("M32: onesec"));
MI32TimeoutSensors(); MI32TimeoutSensors();
MI32ShowSomeSensors(); MI32ShowSomeSensors();
@ -1893,7 +1893,7 @@ void MI32EverySecond(bool restart){
if (MI32.secondsCounter >= MI32.period){ if (MI32.secondsCounter >= MI32.period){
// only if we finished the last read // only if we finished the last read
if (MI32.sensorreader.slot >= MIBLEsensors.size()){ if (MI32.sensorreader.slot >= MIBLEsensors.size()){
AddLog_P(LOG_LEVEL_DEBUG,PSTR("kick off readOneSensor")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Kick off readOneSensor"));
// kick off notification sensor reading every period. // kick off notification sensor reading every period.
MI32.sensorreader.slot = 0; MI32.sensorreader.slot = 0;
MI32.secondsCounter = 0; MI32.secondsCounter = 0;
@ -1903,11 +1903,11 @@ void MI32EverySecond(bool restart){
if (MI32.secondsCounter2 >= MI32.period){ if (MI32.secondsCounter2 >= MI32.period){
if (MI32.mqttCurrentSlot >= MIBLEsensors.size()){ if (MI32.mqttCurrentSlot >= MIBLEsensors.size()){
AddLog_P(LOG_LEVEL_DEBUG,PSTR("kick off tele sending")); AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Kick off tele sending"));
MI32.mqttCurrentSlot = 0; MI32.mqttCurrentSlot = 0;
MI32.secondsCounter2 = 0; MI32.secondsCounter2 = 0;
} else { } else {
AddLog_P(LOG_LEVEL_DEBUG,PSTR("hit tele time, restarted but not finished last - lost from slot %d")+MI32.mqttCurrentSlot); AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Hit tele time, restarted but not finished last - lost from slot %d")+MI32.mqttCurrentSlot);
MI32.mqttCurrentSlot = 0; MI32.mqttCurrentSlot = 0;
MI32.secondsCounter2 = 0; MI32.secondsCounter2 = 0;
} }
@ -1968,15 +1968,15 @@ void CmndMi32Time(void) {
if (MIBLEsensors.size() > slot) { if (MIBLEsensors.size() > slot) {
int res = genericTimeWriteFn(slot); int res = genericTimeWriteFn(slot);
if (res > 0){ if (res > 0){
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("MI32: will set Time")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: will set Time"));
ResponseCmndNumber(slot); ResponseCmndNumber(slot);
return; return;
} }
if (res < 0) { if (res < 0) {
AddLog_P(LOG_LEVEL_ERROR, PSTR("MI32: cannot set Time on sensor type")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: cannot set Time on sensor type"));
} }
if (res == 0) { if (res == 0) {
AddLog_P(LOG_LEVEL_ERROR, PSTR("MI32: cannot set Time right now")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: cannot set Time right now"));
} }
} }
} }
@ -2009,15 +2009,15 @@ void CmndMi32Unit(void) {
// TOGGLE unit? // TOGGLE unit?
int res = genericUnitWriteFn(slot, -1); int res = genericUnitWriteFn(slot, -1);
if (res > 0){ if (res > 0){
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("MI32: will toggle Unit")); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: will toggle Unit"));
ResponseCmndNumber(slot); ResponseCmndNumber(slot);
return; return;
} }
if (res < 0) { if (res < 0) {
AddLog_P(LOG_LEVEL_ERROR, PSTR("MI32: cannot toggle Unit on sensor type")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: cannot toggle Unit on sensor type"));
} }
if (res == 0) { if (res == 0) {
AddLog_P(LOG_LEVEL_ERROR, PSTR("MI32: cannot toggle Unit right now")); AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: cannot toggle Unit right now"));
} }
} }
} }
@ -2091,7 +2091,7 @@ void CmndMi32Block(void){
MIBLEBlockList.push_back(_MACasBytes); MIBLEBlockList.push_back(_MACasBytes);
MI32removeMIBLEsensor(_MACasBytes.buf); MI32removeMIBLEsensor(_MACasBytes.buf);
} }
// AddLog_P(LOG_LEVEL_INFO,PSTR("MI32: size of ilist: %u"), MIBLEBlockList.size()); // AddLog_P(LOG_LEVEL_INFO,PSTR("M32: size of ilist: %u"), MIBLEBlockList.size());
} break; } break;
} }
MI32BlockListResp(); MI32BlockListResp();
@ -2136,7 +2136,7 @@ void MI32KeyListResp(){
void CmndMi32Keys(void){ void CmndMi32Keys(void){
#ifdef BLE_ESP32_ALIASES #ifdef BLE_ESP32_ALIASES
int op = XdrvMailbox.index; int op = XdrvMailbox.index;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("key %d %s"), op, XdrvMailbox.data); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Key %d %s"), op, XdrvMailbox.data);
int res = -1; int res = -1;
switch(op){ switch(op){
@ -2175,7 +2175,7 @@ void CmndMi32Keys(void){
return; return;
} }
AddLog_P(LOG_LEVEL_ERROR,PSTR("Add key mac %s = key %s"), mac, key); AddLog_P(LOG_LEVEL_ERROR,PSTR("M32: Add key mac %s = key %s"), mac, key);
char tmp[20]; char tmp[20];
// convert mac back to string // convert mac back to string
ToHex_P(addr,6,tmp,20,0); ToHex_P(addr,6,tmp,20,0);
@ -2186,7 +2186,7 @@ void CmndMi32Keys(void){
} while (p); } while (p);
if (added){ if (added){
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("Added %d Keys"), added); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Added %d Keys"), added);
MI32KeyListResp(); MI32KeyListResp();
} else { } else {
MI32KeyListResp(); MI32KeyListResp();
@ -2194,7 +2194,7 @@ void CmndMi32Keys(void){
return; return;
} break; } break;
case 2:{ // clear case 2:{ // clear
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI32Keys clearing %d"), MIBLEbindKeys.size()); if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Keys clearing %d"), MIBLEbindKeys.size());
for (int i = MIBLEbindKeys.size()-1; i >= 0; i--){ for (int i = MIBLEbindKeys.size()-1; i >= 0; i--){
MIBLEbindKeys.pop_back(); MIBLEbindKeys.pop_back();
} }
@ -2246,9 +2246,9 @@ const char HTTP_MI_KEY_STYLE[] PROGMEM = "";
#define D_MI32_KEY "MI32 Set Key" #define D_MI32_KEY "MI32 Set Key"
void HandleMI32Key(){ void HandleMI32Key(){
AddLog_P(LOG_LEVEL_DEBUG, PSTR("HandleMI32Key hit")); AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: HandleMI32Key hit"));
if (!HttpCheckPriviledgedAccess()) { if (!HttpCheckPriviledgedAccess()) {
AddLog_P(LOG_LEVEL_DEBUG, PSTR("!HttpCheckPriviledgedAccess()")); AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: !HttpCheckPriviledgedAccess()"));
return; return;
} }
WSContentStart_P(PSTR(D_MI32_KEY)); WSContentStart_P(PSTR(D_MI32_KEY));
@ -2292,7 +2292,7 @@ void MI32TimeoutSensors(){
//if (MIBLEsensors[i].MAC[2] || MIBLEsensors[i].MAC[3] || MIBLEsensors[i].MAC[4] || MIBLEsensors[i].MAC[5]){ //if (MIBLEsensors[i].MAC[2] || MIBLEsensors[i].MAC[3] || MIBLEsensors[i].MAC[4] || MIBLEsensors[i].MAC[5]){
if (!BLE_ESP32::devicePresent(MIBLEsensors[i].MAC)){ if (!BLE_ESP32::devicePresent(MIBLEsensors[i].MAC)){
uint8_t *mac = MIBLEsensors[i].MAC; uint8_t *mac = MIBLEsensors[i].MAC;
AddLog_P(LOG_LEVEL_DEBUG,PSTR("MI32: dev no longer present MAC: %02x%02x%02x%02x%02x%02x"), mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Dev no longer present MAC: %02x%02x%02x%02x%02x%02x"), mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
TasAutoMutex localmutex(&slotmutex, "Mi32Timeout"); TasAutoMutex localmutex(&slotmutex, "Mi32Timeout");
MIBLEsensors.erase(MIBLEsensors.begin() + i); MIBLEsensors.erase(MIBLEsensors.begin() + i);
} }
@ -2497,7 +2497,7 @@ void MI32ShowSomeSensors(){
} }
ResponseAppend_P(PSTR("}")); ResponseAppend_P(PSTR("}"));
MqttPublishPrefixTopic_P(TELE, PSTR(D_RSLT_SENSOR), Settings.flag.mqtt_sensor_retain); MqttPublishPrefixTopic_P(TELE, PSTR(D_RSLT_SENSOR), Settings.flag.mqtt_sensor_retain);
//AddLog_P(LOG_LEVEL_DEBUG,PSTR("%s: show some %d %s"),D_CMND_MI32, MI32.mqttCurrentSlot, TasmotaGlobal.mqtt_data); //AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: %s: show some %d %s"),D_CMND_MI32, MI32.mqttCurrentSlot, TasmotaGlobal.mqtt_data);
#ifdef USE_RULES #ifdef USE_RULES
RulesTeleperiod(); // Allow rule based HA messages RulesTeleperiod(); // Allow rule based HA messages
@ -2547,7 +2547,7 @@ void MI32ShowTriggeredSensors(){
if (cnt){ // if we got one, then publish if (cnt){ // if we got one, then publish
ResponseAppend_P(PSTR("}")); ResponseAppend_P(PSTR("}"));
MqttPublishPrefixTopic_P(STAT, PSTR(D_RSLT_SENSOR), Settings.flag.mqtt_sensor_retain); MqttPublishPrefixTopic_P(STAT, PSTR(D_RSLT_SENSOR), Settings.flag.mqtt_sensor_retain);
AddLog_P(LOG_LEVEL_DEBUG,PSTR("%s: triggered %d %s"),D_CMND_MI32, sensor, TasmotaGlobal.mqtt_data); AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: %s: triggered %d %s"),D_CMND_MI32, sensor, TasmotaGlobal.mqtt_data);
#ifdef USE_RULES #ifdef USE_RULES
RulesTeleperiod(); // Allow rule based HA messages RulesTeleperiod(); // Allow rule based HA messages