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

234
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();
if (total < MAX_BLE_DEVICES_LOGGED){
#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
BLE_ESP32::BLE_simple_device_t* dev = new BLE_ESP32::BLE_simple_device_t;
freeDevices.push_back(dev);
@ -667,10 +667,10 @@ int deleteSeenDevices(int ageS = 0){
dump(addr, 20, dev->mac, 6);
const char *alias = getAlias(dev->mac);
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);
} 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);
}
#endif
@ -682,7 +682,7 @@ int deleteSeenDevices(int ageS = 0){
}
if (res){
#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
}
return res;
@ -820,7 +820,7 @@ int getSeenDevicesToJson(char *dest, int maxlen){
}
// 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;
@ -1184,17 +1184,17 @@ void postAdvertismentDetails(){
class BLESensorCallback : public NimBLEClientCallbacks {
void onConnect(NimBLEClient* pClient) {
#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
}
void onDisconnect(NimBLEClient* pClient) {
#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
}
bool onConnParamsUpdateRequest(NimBLEClient* pClient, const ble_gap_upd_params* params) {
#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
// if(params->itvl_min < 24) { /** 1.25ms units */
@ -1315,7 +1315,7 @@ class BLEAdvCallbacks: public NimBLEAdvertisedDeviceCallbacks {
}
} catch(const std::exception& e){
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("exception in advertismentCallbacks"));
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: exception in advertismentCallbacks"));
#endif
}
}
@ -1334,18 +1334,18 @@ static BLESensorCallback BLESensorCB;
static void BLEscanEndedCB(NimBLEScanResults results){
#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
for (int i = 0; i < scancompleteCallbacks.size(); i++){
try {
SCANCOMPLETE_CALLBACK *pFn = scancompleteCallbacks[i];
int callbackres = pFn(results);
#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
} catch(const std::exception& e){
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("exception in operationsCallbacks"));
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: exception in operationsCallbacks"));
#endif
}
}
@ -1367,21 +1367,21 @@ static void BLEGenNotifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, ui
if (!pRemoteCharacteristic){
#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
return;
}
#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
// find the operation this is associated with
NimBLERemoteService *pSvc = pRemoteCharacteristic->getRemoteService();
if (!pSvc){
#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
return;
}
@ -1389,7 +1389,7 @@ static void BLEGenNotifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, ui
pRClient = pSvc->getClient();
if (!pRClient){
#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
return;
}
@ -1404,7 +1404,7 @@ static void BLEGenNotifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, ui
generic_sensor_t *op = currentOperations[i];
if (!op){
#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
} else {
if (devaddr == op->addr){
@ -1420,7 +1420,7 @@ static void BLEGenNotifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, ui
if (!thisop){
#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
return;
}
@ -1524,7 +1524,7 @@ static void BLEOperationTask(void *pvParameters);
static void BLEStartOperationTask(){
if (BLERunning == false){
#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
BLERunning = true;
@ -1547,25 +1547,25 @@ static void BLEStartOperationTask(){
static void BLETaskStopStartNimBLE(NimBLEClient **ppClient, bool start = true){
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);
try {
if ((*ppClient)->isConnected()){
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_INFO,PSTR("disconnecting connected client"));
AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: disconnecting connected client"));
#endif
(*ppClient)->disconnect();
}
NimBLEDevice::deleteClient((*ppClient));
(*ppClient) = nullptr;
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_INFO,PSTR("deleted client"));
AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: deleted client"));
#endif
} catch(const std::exception& e){
#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
}
@ -1582,7 +1582,7 @@ static void BLETaskStopStartNimBLE(NimBLEClient **ppClient, bool start = true){
BLERunningScan = 0;
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");
*ppClient = NimBLEDevice::createClient();
@ -1623,7 +1623,7 @@ int BLETaskStartScan(int time){
}
#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
//vTaskDelay(500/ portTICK_PERIOD_MS);
ble32Scan->setActiveScan(BLEScanActiveMode ? 1: 0);
@ -1652,7 +1652,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
*pCurrentOperation = nextOperation(&queuedOperations);
if (*pCurrentOperation){
#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
BLEOpCount++;
generic_sensor_t* temp = *pCurrentOperation;
@ -1673,7 +1673,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
diff = diff/1000;
if (diff > 20000){ // 20s
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLETask: notify timeout"));
AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: BLETask: notify timeout"));
#endif
(*pCurrentOperation)->state = GEN_STATE_FAILED_NOTIFYTIMEOUT;
(*pCurrentOperation)->notifytimer = 0;
@ -1690,7 +1690,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
(*pCurrentOperation)->state = GEN_STATE_NOTIFIED;
// just stay here until this is removed by the main thread
#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
BLE_ESP32::BLETaskRunTaskDoneOperation(pCurrentOperation, 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
// just stay here until this is removed by the main thread
#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
BLE_ESP32::BLETaskRunTaskDoneOperation(pCurrentOperation, ppClient);
pClient = *ppClient;
@ -1721,7 +1721,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if ((*pCurrentOperation)->state <= GEN_STATE_FAILED){
#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
BLE_ESP32::BLETaskRunTaskDoneOperation(pCurrentOperation, ppClient);
pClient = *ppClient;
@ -1735,7 +1735,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if (pClient->isConnected()){
// don't do anything if we are still connected
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLETask: still connected"));
AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: BLETask: still connected"));
#endif
return;
}
@ -1755,7 +1755,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
op->state = GEN_STATE_STARTED;
#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
if (!op->serviceUUID.bitSize()){
@ -1766,7 +1766,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if (pClient->connect(op->addr, true)) {
#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
NimBLERemoteService *pService = pClient->getService(op->serviceUUID);
int waitNotify = false;
@ -1775,7 +1775,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if (pService != nullptr) {
#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
// pre-set to fail if no operations requested
//newstate = GEN_STATE_FAILED_NOREADWRITE;
@ -1792,13 +1792,13 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
pService->getCharacteristic(op->notificationCharacteristicUUID);
if (pNCharacteristic != nullptr) {
#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
op->notifylen = 0;
if(pNCharacteristic->canNotify()) {
if(pNCharacteristic->subscribe(true, BLE_ESP32::BLEGenNotifyCB)) {
#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
uint64_t now = esp_timer_get_time();
op->notifytimer = now;
@ -1808,7 +1808,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
waitNotify = true;
} else {
#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
newstate = GEN_STATE_FAILED_NOTIFY;
}
@ -1816,7 +1816,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if(pNCharacteristic->canIndicate()) {
if(pNCharacteristic->subscribe(false, BLE_ESP32::BLEGenNotifyCB)) {
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("subscribe for indicate"));
AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: subscribe for indicate"));
#endif
notifystate = GEN_STATE_WAITINDICATE;
uint64_t now = esp_timer_get_time();
@ -1824,21 +1824,21 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
waitNotify = true;
} else {
#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
newstate = GEN_STATE_FAILED_INDICATE;
}
} else {
newstate = GEN_STATE_FAILED_CANTNOTIFYORINDICATE;
#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
}
}
} else {
newstate = GEN_STATE_FAILED_NONOTIFYCHAR;
#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
}
@ -1855,7 +1855,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
pCharacteristic = pService->getCharacteristic(op->characteristicUUID);
if (pCharacteristic != nullptr) {
#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
newstate = GEN_STATE_FAILED_NOREADWRITE; // overwritten on failure
@ -1875,12 +1875,12 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if (op->readmodifywritecallback){
READ_CALLBACK *pFn = (READ_CALLBACK *)op->readmodifywritecallback;
#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
pFn(op);
} else {
#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
}
@ -1896,12 +1896,12 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if (!pCharacteristic->writeValue(op->dataToWrite, op->writelen, true)){
newstate = GEN_STATE_FAILED_WRITE;
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("characteristic write fail"));
AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: characteristic write fail"));
#endif
} else {
if (!waitNotify) newstate = GEN_STATE_WRITEDONE;
#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
}
} else {
@ -1913,7 +1913,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
} else {
newstate = GEN_STATE_FAILED_NO_RW_CHAR;
#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
}
}
@ -1934,7 +1934,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
newstate = GEN_STATE_FAILED_NOSERVICE;
// failed to get a service
#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
}
@ -1946,14 +1946,14 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
switch (rc){
case (0x0200+BLE_ERR_CONN_LIMIT ):
#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
BLERestartNimBLE = 1;
BLERestartBLEReason = BLE_RESTART_BLE_REASON_CONN_LIMIT;
break;
case (0x0200+BLE_ERR_ACL_CONN_EXISTS):
#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
BLERestartNimBLE = 1;
BLERestartBLEReason = BLE_RESTART_BLE_REASON_CONN_EXISTS;
@ -1963,7 +1963,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
// failed to connect
#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
}
op->state = newstate;
@ -1979,7 +1979,7 @@ static void BLETaskRunTaskDoneOperation(BLE_ESP32::generic_sensor_t** op, NimBLE
try {
if ((*ppClient)->isConnected()){
#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
(*ppClient)->disconnect();
// wait for 1/2 second after disconnect
@ -1990,7 +1990,7 @@ static void BLETaskRunTaskDoneOperation(BLE_ESP32::generic_sensor_t** op, NimBLE
//(*ppClient)->disconnect();
// we will stall here forever!!! - as testing
#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
vTaskDelay(500/ portTICK_PERIOD_MS);
}
@ -1999,11 +1999,11 @@ static void BLETaskRunTaskDoneOperation(BLE_ESP32::generic_sensor_t** op, NimBLE
int conn_id = (*ppClient)->getConnId();
ble_gap_conn_broken(conn_id, -1);
#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
}
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;
BLEStopAt = esp_timer_get_time();
@ -2015,7 +2015,7 @@ static void BLETaskRunTaskDoneOperation(BLE_ESP32::generic_sensor_t** op, NimBLE
}
} catch(const std::exception& e){
#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
}
@ -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
#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
addOperation(&completedOperations, op);
return;
@ -2096,7 +2096,7 @@ static void BLEOperationTask(void *pvParameters){
BLERestartNimBLE = 0;
BLERestartTasmota = 10;
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);
BLERestartTasmotaReason = BLE_RESTART_TEAMOTA_REASON_UNKNOWN;
BLERestartTasmota = 0;
@ -2110,7 +2110,7 @@ static void BLEOperationTask(void *pvParameters){
vTaskDelay(100/ portTICK_PERIOD_MS);
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLEOperationTask: Left task"));
AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: BLEOperationTask: Left task"));
#endif
deleteSeenDevices();
@ -2192,11 +2192,11 @@ static void BLEEverySecond(bool restart){
if (!BLERestartTasmotaReason) BLERestartTasmotaReason = BLE_RESTART_TEAMOTA_REASON_UNKNOWN;
snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("{\"reboot\":\"%s\"}"), BLERestartTasmotaReason);
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){
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
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
snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("{\"blerestart\":\"%s\"}"), BLERestartBLEReason);
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;
}
@ -2250,9 +2250,9 @@ int addOperation(std::deque<generic_sensor_t*> *ops, generic_sensor_t** op){
}
}
if (res){
//AddLog_P(LOG_LEVEL_DEBUG,PSTR("added operation"));
//AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: added operation"));
} else {
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE op - no room"));
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: op - no room"));
}
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){
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;
}
@ -2307,7 +2307,7 @@ int extQueueOperation(BLE_ESP32::generic_sensor_t** op){
int res = addOperation(&queuedOperations, op);
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;
}
@ -2427,7 +2427,7 @@ static int StartBLE(void) {
BLE_ESP32::BLEStartOperationTask();
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;
}
@ -2436,16 +2436,16 @@ static int StopBLE(void){
if (BLERunning){
if (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();
// give a little time for it to stop.
vTaskDelay(1000/ portTICK_PERIOD_MS);
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;
} else {
AddLog_P(LOG_LEVEL_ERROR,PSTR("StopBLE - was not running"));
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: StopBLE - was not running"));
return 1;
}
}
@ -2686,7 +2686,7 @@ void CmndBLEDetails(void){
void CmndBLEAlias(void){
#ifdef BLE_ESP32_ALIASES
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;
switch(op){
@ -2705,7 +2705,7 @@ void CmndBLEAlias(void){
char *mac = p;
int len = fromHex(addr, p, sizeof(addr));
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");
return;
}
@ -2726,7 +2726,7 @@ void CmndBLEAlias(void){
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 )){
added++;
}
@ -2734,7 +2734,7 @@ void CmndBLEAlias(void){
} while (p);
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();
} else {
BLEAliasListResp();
@ -2742,7 +2742,7 @@ void CmndBLEAlias(void){
return;
} break;
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--){
BLE_ESP32::ble_alias_t *alias = aliases[i];
aliases.pop_back();
@ -2773,14 +2773,14 @@ void CmndBLEName(void) {
if (addrres){
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
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
} 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"));
return;
}
@ -2789,11 +2789,11 @@ void CmndBLEName(void) {
// ALWAYS use this function to create a new one.
int res = BLE_ESP32::newOperation(&op);
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"));
return;
} 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;
@ -2804,21 +2804,21 @@ void CmndBLEName(void) {
char *name = strtok(nullptr, " ");
bool write = false;
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);
memcpy(op->dataToWrite, name, op->writelen);
write = true;
} 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;
}
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 it fails to add to the queue, do please delete it
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"));
return;
}
@ -2856,7 +2856,7 @@ void CmndBLEOperation(void){
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;
@ -2864,7 +2864,7 @@ void CmndBLEOperation(void){
switch(op) {
case 0:
#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
BLEPostMQTTTrigger = 1;
break;
@ -2875,7 +2875,7 @@ void CmndBLEOperation(void){
int opres = BLE_ESP32::newOperation(&prepOperation);
if (!opres){
#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
ResponseCmndChar("FailCreate");
return;
@ -2933,14 +2933,14 @@ void CmndBLEOperation(void){
// this means you could retry with another BLEOp10.
// it WOULD be deleted if you sent another BELOP1 <MAC>
#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
ResponseCmndChar("FailQueue");
return;
} else {
// NOTE: prepOperation has been set to null if we queued sucessfully.
#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
char temp[40];
sprintf(temp, "{\"opid\":%d,\"u\":%d}", lastopid-1, u);
@ -2969,13 +2969,13 @@ void CmndBLEOperation(void){
// this means you could retry with another BLEOp10.
// it WOULD be deleted if you sent another BELOP1 <MAC>
#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
ResponseCmndChar("FailQueue");
} else {
// NOTE: prepOperation has been set to null if we queued sucessfully.
#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
char temp[40];
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()){
#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
if (prepOperation && !onlycompleted){
std::string out = BLETriggerResponse(prepOperation);
snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("%s"), out.c_str());
MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain);
#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
}
if (queuedOperations.size() && !onlycompleted){
#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
for (int i = 0; i < queuedOperations.size(); i++){
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());
MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain);
#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
//break;
}
@ -3062,7 +3062,7 @@ static void BLEPostMQTT(bool onlycompleted) {
if (currentOperations.size() && !onlycompleted){
#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
for (int i = 0; i < currentOperations.size(); i++){
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());
MqttPublishPrefixTopic_P(TELE, PSTR("BLE"), Settings.flag.mqtt_sensor_retain);
#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
//break;
}
@ -3084,7 +3084,7 @@ static void BLEPostMQTT(bool onlycompleted) {
if (completedOperations.size()){
#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
do {
generic_sensor_t *toSend = nextOperation(&completedOperations);
@ -3092,7 +3092,7 @@ static void BLEPostMQTT(bool onlycompleted) {
break; // break from while loop
} else {
#ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE:completedOperation removed"));
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG,PSTR("BLE: completedOperation removed"));
#endif
std::string out = BLETriggerResponse(toSend);
snprintf_P(TasmotaGlobal.mqtt_data, sizeof(TasmotaGlobal.mqtt_data), PSTR("%s"), out.c_str());
@ -3154,7 +3154,7 @@ static void mainThreadBLETimeouts() {
static void mainThreadOpCallbacks() {
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");
// find this operation in currentOperations, and remove it.
@ -3169,11 +3169,11 @@ static void mainThreadOpCallbacks() {
OPCOMPLETE_CALLBACK *pFn = (OPCOMPLETE_CALLBACK *)(op->completecallback);
callbackres = pFn(op);
#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
} catch(const std::exception& e){
#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
}
}
@ -3184,14 +3184,14 @@ static void mainThreadOpCallbacks() {
OPCOMPLETE_CALLBACK *pFn = operationsCallbacks[i];
callbackres = pFn(op);
#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
if (callbackres){
break; // this callback ate the op.
}
} catch(const std::exception& e){
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_ERROR,PSTR("exception in operationsCallbacks"));
AddLog_P(LOG_LEVEL_ERROR,PSTR("BLE: exception in operationsCallbacks"));
#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 (callbackres){
#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
completedOperations.erase(completedOperations.begin() + i);
delete op;
@ -3214,7 +3214,7 @@ static void BLEShow(bool json)
{
if (json){
#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
uint32_t totalCount = BLEAdvertisment.totalCount;
uint32_t deviceCount = seenDevices.size();
@ -3262,7 +3262,7 @@ static void BLEDiag()
uint32_t totalCount = BLEAdvertisment.totalCount;
uint32_t deviceCount = seenDevices.size();
#ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE:scans:%u,advertisements:%u,devices:%u,resets:%u,BLEStop:%d,BLERunning:%d,BLERunningScan:%d,BLELoopCount:%u,BLEOpCount:%u"), BLEScanCount, totalCount, deviceCount, BLEResets, BLEStop, BLERunning, BLERunningScan, BLELoopCount, BLEOpCount);
if (BLEDebugMode > 0) AddLog_P(LOG_LEVEL_INFO,PSTR("BLE: scans:%u,advertisements:%u,devices:%u,resets:%u,BLEStop:%d,BLERunning:%d,BLERunningScan:%d,BLELoopCount:%u,BLEOpCount:%u"), BLEScanCount, totalCount, deviceCount, BLEResets, BLEStop, BLERunning, BLERunningScan, BLELoopCount, BLEOpCount);
#endif
}
@ -3372,12 +3372,12 @@ void HandleBleConfiguration(void)
{
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG, PSTR("HandleBleConfiguration"));
AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE: HandleBleConfiguration"));
#endif
if (!HttpCheckPriviledgedAccess()) {
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG, PSTR("!HttpCheckPriviledgedAccess()"));
AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE: !HttpCheckPriviledgedAccess()"));
#endif
return;
}
@ -3390,12 +3390,12 @@ void HandleBleConfiguration(void)
WebGetArg("en", tmp, sizeof(tmp));
#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
if (Webserver->hasArg("save")) {
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE SETTINGS SAVE"));
AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE: SETTINGS SAVE"));
#endif
Settings.flag5.mi32_enable = Webserver->hasArg("e0"); //
BLEScanActiveMode = (Webserver->hasArg("e1")?1:0); //
@ -3405,7 +3405,7 @@ void HandleBleConfiguration(void)
return;
}
#ifdef BLE_ESP32_DEBUG
AddLog_P(LOG_LEVEL_DEBUG, PSTR("!SAVE"));
AddLog_P(LOG_LEVEL_DEBUG, PSTR("BLE: !SAVE"));
#endif
char str[TOPSZ];
@ -3460,7 +3460,7 @@ void HandleBleConfiguration(void)
\*********************************************************************************************/
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::StopBLE();
return 0;
@ -3548,13 +3548,13 @@ int myAdvertCallback(BLE_ESP32::ble_advertisment_t *pStruct) {
// this one is used to demonstrate processing ALL operations
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
}
// this one is used to demonstrate processing of ONE specific operation
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
}
#endif
@ -3577,7 +3577,7 @@ void sendExample(){
BLE_ESP32::generic_sensor_t *op = nullptr;
int res = BLE_ESP32::newOperation(&op);
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;
}
strncpy(op->MAC, "001A22092EE0", sizeof(op->MAC));
@ -3592,7 +3592,7 @@ void sendExample(){
if (!res){
// if it fails to add to the queue, do please delete it
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;
}

314
tasmota/xsns_62_MI_ESP32_BLE_ESP32.ino
View File

@ -97,15 +97,15 @@ struct {
struct {
// the slot currently having it's battery read
// set to 0 to start a battery read cycle
uint8_t slot = 255;
uint8_t active = 0;
uint8_t slot = 255;
uint8_t active = 0;
} batteryreader;
struct {
// the slot currently having it's battery read
// set to 0 to start a battery read cycle
uint8_t slot = 255;
uint8_t active = 0;
uint8_t slot = 255;
uint8_t active = 0;
} sensorreader;
struct {
@ -246,7 +246,7 @@ struct PVVXPacket_t {
uint16_t battery_mv; // mV
uint8_t battery_level; // 0..100 %
uint8_t counter; // measurement count
uint8_t flags;
uint8_t flags;
};
#pragma pack(0)
@ -362,7 +362,7 @@ void (*const MI32_Commands[])(void) PROGMEM = {
#define MI_MI32_TYPES 13 //count this manually
const uint16_t kMI32DeviceID[MI_MI32_TYPES]={
const uint16_t kMI32DeviceID[MI_MI32_TYPES]={
0x0000, // Unkown
0x0098, // Flora
0x01aa, // MJ_HT_V1
@ -419,8 +419,8 @@ const char *MHOC303_TimeChar = LYWSD02_TimeChar;
const char *MHOC401_Svc = LYWSD02_Svc;
const char *MHOC401_BattNotifyChar = LYWSD02_BattNotifyChar;
const char CGD1_Svc[] PROGMEM = "180F";
const char CGD1_BattChar[] PROGMEM = "2A19";
const char CGD1_Svc[] PROGMEM = "180F";
const char CGD1_BattChar[] PROGMEM = "2A19";
const char FLORA_Svc[] PROGMEM = "00001204-0000-1000-8000-00805F9B34FB";
const char FLORA_BattChar[] PROGMEM = "00001A02-0000-1000-8000-00805F9B34FB";
@ -443,7 +443,7 @@ enum MI32_MI_OP_TYPES {
enum MI32_MI_KEY_REQ {
KEY_REQUIREMENT_UNKNOWN = 0, // we don't know if a key is needed
KEY_REQUIREMENT_UNKNOWN = 0, // we don't know if a key is needed
KEY_NOT_REQUIRED = 1, // we got an unencrypted payload
KEY_REQUIRED_BUT_NOT_FOUND = 2, // we got an encrypted packet, but had not key
KEY_REQUIRED_AND_FOUND = 3, // we got an encrypted packet, and could decrypt
@ -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 ) {
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;
}
@ -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.
int res = BLE_ESP32::newOperation(&op);
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;
} 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){
op->addr = NimBLEAddress(MIBLEsensors[slot].MAC);
} else {
if (!addr){
AddLog_P(LOG_LEVEL_ERROR,PSTR("no addr"));
AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: No addr"));
BLE_ESP32::freeOperation(&op);
return 0;
}
@ -521,7 +521,7 @@ bool MI32Operation(int slot, int optype, const char *svc, const char *charactist
if (!op->serviceUUID.bitSize()){
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;
}
@ -531,7 +531,7 @@ bool MI32Operation(int slot, int optype, const char *svc, const char *charactist
op->characteristicUUID = NimBLEUUID(charactistic);
if (!op->characteristicUUID.bitSize()){
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;
}
}
@ -539,10 +539,10 @@ bool MI32Operation(int slot, int optype, const char *svc, const char *charactist
op->notificationCharacteristicUUID = NimBLEUUID(notifychar);
if (!op->notificationCharacteristicUUID.bitSize()){
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;
}
}
}
if (data && datalen) {
op->writelen = datalen;
@ -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;
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);
if (!res){
// if it fails to add to the queue, do please delete it
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;
@ -591,10 +591,10 @@ int genericBatReadFn(int slot){
break;
// these read a characteristic
case MI_FLORA:
case MI_FLORA:
res = MI32Operation(slot, OP_BATT_READ, FLORA_Svc, FLORA_BattChar);
break;
case MI_LYWSD02:
case MI_LYWSD02:
res = MI32Operation(slot, OP_BATT_READ, LYWSD02_Svc, LYWSD02_BattChar);
break;
case MI_CGD1:
@ -611,9 +611,9 @@ int genericBatReadFn(int slot){
break;
}
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 {
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;
}
@ -627,17 +627,17 @@ int genericSensorReadFn(int slot, int force){
so although the characteristic seems to exist, it does not work?
further dev required with sensor to hand.
case MI_LYWSD02:
// don't read if key present and we've decoded at least one advert
// don't read if key present and we've decoded at least one advert
if (MIBLEsensors[slot].needkey == KEY_REQUIRED_AND_FOUND) return -2;
res = MI32Operation(slot, OP_READ_HT_LY, LYWSD02_Svc, nullptr, LYWSD02_BattNotifyChar);
break;*/
case MI_LYWSD03MMC:
// don't read if key present and we've decoded at least one advert
// don't read if key present and we've decoded at least one advert
if (MIBLEsensors[slot].needkey == KEY_REQUIRED_AND_FOUND && !force) return -2;
res = MI32Operation(slot, OP_READ_HT_LY, LYWSD03_Svc, nullptr, LYWSD03_BattNotifyChar);
break;
case MI_MHOC401:
// don't read if key present and we've decoded at least one advert
// don't read if key present and we've decoded at least one advert
if (MIBLEsensors[slot].needkey == KEY_REQUIRED_AND_FOUND && !force) return -2;
res = MI32Operation(slot, OP_READ_HT_LY, MHOC401_Svc, nullptr, MHOC401_BattNotifyChar);
break;
@ -653,22 +653,22 @@ int genericSensorReadFn(int slot, int force){
// called once per second
int readOneSensor(){
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;
}
// loop if the sensor at the slot does not need to be read
// i.e. drop out of loop when we start a read, or hit the end
int res = -1;
int res = -1;
do {
// MI32.sensorreader.slot is reset to zero to trigger a read sequence
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;
}
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 (res < 0){
@ -680,7 +680,7 @@ int readOneSensor(){
if (res == 0){
// 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;
}
@ -689,7 +689,7 @@ int readOneSensor(){
// and make it wait until the read/notify is complete
// this is cleared in the response callback.
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
return 1;
@ -714,7 +714,7 @@ int readOneBat(){
if (res < 0){
MI32.batteryreader.slot++;
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;
}
@ -730,7 +730,7 @@ int readOneBat(){
// this is cleared in the response callback.
MI32.batteryreader.active = 1;
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
return 1;
@ -816,7 +816,7 @@ int genericTimeWriteFn(int slot){
int genericOpCompleteFn(BLE_ESP32::generic_sensor_t *op){
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 devType = (context >> 16) & 0xff;
@ -832,12 +832,12 @@ int genericOpCompleteFn(BLE_ESP32::generic_sensor_t *op){
bool fail = false;
if (op->addr != addr){
// 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;
}
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;
}
@ -857,7 +857,7 @@ int genericOpCompleteFn(BLE_ESP32::generic_sensor_t *op){
switch(opType){
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
case OP_BATT_READ:{
uint8_t *data = nullptr;
@ -876,33 +876,33 @@ int genericOpCompleteFn(BLE_ESP32::generic_sensor_t *op){
// allow another...
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;
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;
case OP_UNIT_READ: {
uint8_t currUnit = op->dataRead[0];
AddLog_P(LOG_LEVEL_DEBUG,PSTR("Unit read for %s complete %d"), slotMAC, currUnit);
uint8_t currUnit = op->dataRead[0];
AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: Unit read for %s complete %d"), slotMAC, currUnit);
} return 0;
case OP_UNIT_TOGGLE: {
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);
uint8_t currUnit = op->dataToWrite[0];
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;
case OP_READ_HT_LY: {
// allow another...
MI32.sensorreader.active = 0;
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;
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;
}
@ -914,7 +914,7 @@ int MI32advertismentCallback(BLE_ESP32::ble_advertisment_t *pStruct)
// we will try not to use this...
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;
const uint8_t *addr = pStruct->addr;
if(MI32isInBlockList(addr) == true) return 0;
@ -937,14 +937,14 @@ int MI32advertismentCallback(BLE_ESP32::ble_advertisment_t *pStruct)
char temp[60];
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);
uint32_t ServiceDataLength = ServiceDataStr.length();
const uint8_t *ServiceData = (const uint8_t *)ServiceDataStr.data();
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){
// this will take and keep the mutex until the function is over
@ -1041,14 +1041,14 @@ int MI32AddKey(char* payload, char* key = nullptr){
bool unknownKey = true;
for(uint32_t i=0; i<MIBLEbindKeys.size(); i++){
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);
unknownKey=false;
return 1;
}
}
if(unknownKey){
AddLog_P(LOG_LEVEL_DEBUG,PSTR("New key"));
AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: New key"));
MIBLEbindKeys.push_back(keyMAC);
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};
const unsigned char authData[16] = {0x11};
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++){
if(memcmp(mac, MIBLEbindKeys[i].MAC, 6)==0){
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;
break;
}
}
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
}
@ -1098,7 +1098,7 @@ int MIDecryptPayload(const uint8_t *macin, const uint8_t *nonce, uint32_t tag, u
// returns 1 if matched, else 0
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
}
@ -1168,7 +1168,7 @@ int MIParsePacket(const uint8_t* slotmac, struct mi_beacon_data_t *parsed, const
parsed->devicetype = *((uint16_t *)(data + byteindex));
byteindex += 2;
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++;
@ -1184,7 +1184,7 @@ int MIParsePacket(const uint8_t* slotmac, struct mi_beacon_data_t *parsed, const
byteindex += 6;
}
int decres = 1;
int decres = 1;
// everything after MAC is encrypted if specified?
if (parsed->framedata.isencrypted){
if (len < byteindex + 3+4+1){
@ -1217,17 +1217,17 @@ int MIParsePacket(const uint8_t* slotmac, struct mi_beacon_data_t *parsed, const
break;
case 0: // suceeded
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;
case -1: // key failed to work
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;
return 0;
break;
case -2: // key not present
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;
return 0;
break;
@ -1262,7 +1262,7 @@ int MIParsePacket(const uint8_t* slotmac, struct mi_beacon_data_t *parsed, const
}
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->payloadpresent = 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.
if (decres == 1){
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
parsed->payloadpresent = 1;
memcpy(&parsed->payload, (data + byteindex), (len - byteindex));
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;
@ -1319,7 +1319,7 @@ void MI32nullifyEndOfMQTT_DATA(){
*/
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;
for (uint32_t i=0; i < MI_MI32_TYPES; i++){ // i < sizeof(kMI32DeviceID) gives compiler warning
if(_type == kMI32DeviceID[i]){
@ -1328,40 +1328,40 @@ uint32_t MIBLEgetSensorSlot(const uint8_t *mac, uint16_t _type, uint8_t counter)
break;
}
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) {
_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++){
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) {
// 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
}
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;
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){
// 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]);
MIBLEsensors[i].type = _type;
}
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("%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: 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: 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("%s: found new sensor"),D_CMND_MI32);
//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("M32: %s: found new sensor"),D_CMND_MI32);
mi_sensor_t _newSensor;
memset(&_newSensor, 0 , sizeof(_newSensor));
memcpy(_newSensor.MAC, mac, 6);
@ -1411,7 +1411,7 @@ uint32_t MIBLEgetSensorSlot(const uint8_t *mac, uint16_t _type, uint8_t counter)
break;
}
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;
return MIBLEsensors.size()-1;
};
@ -1444,7 +1444,7 @@ void MI32StatusInfo() {
int MI32scanCompleteCallback(NimBLEScanResults results){
// 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;
}
@ -1473,7 +1473,7 @@ void MI32Init(void) {
// note: for operations, we will set individual callbacks in the operations we request
//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.mode.init = 1;
return;
@ -1496,19 +1496,19 @@ int MIParseBatt(int slot, uint8_t *data, int len){
MIBLEsensors[slot].bat = value;
if(MIBLEsensors[slot].type==MI_FLORA){
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 {
memcpy(MIBLEsensors[slot].firmware, data+2, 5);
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].shallSendMQTT = 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 {
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;
@ -1534,13 +1534,13 @@ void MI32ParseATCPacket(const uint8_t * _buf, uint32_t length, const uint8_t *ad
//uint16_t battery_mv; // mV
//uint8_t battery_level; // 0..100 %
//uint8_t counter; // measurement count
//uint8_t flags;
//uint8_t flags;
uint32_t _slot = MIBLEgetSensorSlot(addr, 0x0a1c, ppv_packet->counter); // This must be a hard-coded fake ID
if(_slot==0xff) return;
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].needkey=KEY_NOT_REQUIRED;
@ -1557,7 +1557,7 @@ void MI32ParseATCPacket(const uint8_t * _buf, uint32_t length, const uint8_t *ad
}
return;
} 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;
}
}
@ -1571,9 +1571,9 @@ void MI32ParseATCPacket(const uint8_t * _buf, uint32_t length, const uint8_t *ad
if (memcmp(addrrev, _packet->MAC, 6)){
MI32_ReverseMAC(_packet->MAC);
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 {
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);
}
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 >= 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].needkey=KEY_NOT_REQUIRED;
@ -1606,17 +1606,17 @@ void MI32ParseATCPacket(const uint8_t * _buf, uint32_t length, const uint8_t *ad
////////////////////////////////////////////////////////////
// this SHOULD parse any MI payload.
int MI32parseMiPayload(int _slot, struct mi_beacon_data_t *parsed){
struct mi_beacon_data_payload_data_t *pld =
struct mi_beacon_data_payload_data_t *pld =
(struct mi_beacon_data_payload_data_t *) &parsed->payload.data;
int res = 1;
if (!parsed->payloadpresent){
return 0;
}
char tmp[20];
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){
case 0x01: // button press
@ -1624,7 +1624,7 @@ int MI32parseMiPayload(int _slot, struct mi_beacon_data_t *parsed){
MIBLEsensors[_slot].eventType.Btn = 1;
MI32.mode.shallTriggerTele = 1;
break;
case 0x02:
case 0x02:
res = 0;
break;
case 0x03: {// motion? 1 byte
@ -1636,22 +1636,22 @@ int MI32parseMiPayload(int _slot, struct mi_beacon_data_t *parsed){
if(_tempFloat<60){
MIBLEsensors[_slot].temp=_tempFloat;
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 {
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;
case 0x06: {
float _tempFloat=(float)(pld->hum)/10.0f;
if(_tempFloat<101){
MIBLEsensors[_slot].hum=_tempFloat;
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 {
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;
case 0x07:
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.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;
case 0x08:
MIBLEsensors[_slot].moisture=pld->moist;
MIBLEsensors[_slot].eventType.moist = 1;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode 8: moisture updated"));
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Mode 8: U8: %u Moisture"), _beacon.moist);
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 8: moisture updated"));
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Mode 8: U8: %u Moisture"), _beacon.moist);
break;
case 0x09: // 'conductivity'
MIBLEsensors[_slot].fertility=pld->fert;
MIBLEsensors[_slot].eventType.fert = 1;
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("Mode 9: fertility updated"));
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("Mode 9: U16: %u Fertility"), _beacon.fert);
if (BLE_ESP32::BLEDebugMode > 0) AddLog_P(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 9: fertility updated"));
// AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Mode 9: U16: %u Fertility"), _beacon.fert);
break;
case 0x0a:
if(MI32.option.ignoreBogusBattery){
@ -1683,31 +1683,31 @@ int MI32parseMiPayload(int _slot, struct mi_beacon_data_t *parsed){
if(pld->bat<101){
MIBLEsensors[_slot].bat = pld->bat;
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 {
MIBLEsensors[_slot].bat = 100;
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;
case 0x0d:{
float _tempFloat=(float)(pld->HT.temp)/10.0f;
if(_tempFloat < 60){
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 {
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;
if(_tempFloat < 100){
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 {
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;
// 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;
case 0x0f:
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].NMT = 0;
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;
case 0x10:{ // 'formaldehide'
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].eventType.NMT = 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;
default: {
AddLog_P(LOG_LEVEL_DEBUG,PSTR("Unknown MI pld"));
AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: Unknown MI pld"));
res = 0;
} break;
}
@ -1771,7 +1771,7 @@ void MI32ParseResponse(const uint8_t *buf, uint16_t bufsize, const uint8_t* addr
MI32_ReverseMAC(addrrev);
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);
MI32_ReverseMAC(addrrev);
addr = addrrev;
@ -1781,11 +1781,11 @@ void MI32ParseResponse(const uint8_t *buf, uint16_t bufsize, const uint8_t* addr
if(_slot==0xff) return;
if ((_slot >= 0) && (_slot < MIBLEsensors.size())){
if (parsed.needkey != KEY_REQUIREMENT_UNKNOWN){
MIBLEsensors[_slot].needkey = parsed.needkey;
MIBLEsensors[_slot].needkey = parsed.needkey;
}
MIBLEsensors[_slot].RSSI=RSSI;
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;
} else {
}
@ -1806,7 +1806,7 @@ void MI32removeMIBLEsensor(uint8_t* MAC){
TasAutoMutex localmutex(&slotmutex, "Mi32Rem");
MIBLEsensors.erase( std::remove_if( MIBLEsensors.begin() , MIBLEsensors.end(), [MAC]( mi_sensor_t _sensor )->bool
{ return (memcmp(_sensor.MAC,MAC,6) == 0); }
{ return (memcmp(_sensor.MAC,MAC,6) == 0); }
), end( MIBLEsensors ) );
}
/***********************************************************************\
@ -1814,14 +1814,14 @@ void MI32removeMIBLEsensor(uint8_t* MAC){
\***********************************************************************/
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?
if(_buf[0] != 0 || _buf[1] != 0){
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;
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;
_tempFloat=(float)(LYWSD0x_HT.temp)/100.0f;
if(_tempFloat<60){
@ -1831,7 +1831,7 @@ void MI32notifyHT_LY(int slot, char *_buf, int len){
_tempFloat=(float)LYWSD0x_HT.hum;
if(_tempFloat<100){
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;
if (MIBLEsensors[_slot].type == MI_LYWSD03MMC || MIBLEsensors[_slot].type == MI_MHOC401){
@ -1875,17 +1875,17 @@ void MI32Every50mSecond(){
void MI32EverySecond(bool restart){
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("MI32: onesec"));
// AddLog_P(LOG_LEVEL_DEBUG_MORE, PSTR("M32: onesec"));
MI32TimeoutSensors();
MI32ShowSomeSensors();
// read a battery if
// read a battery if
// MI32.batteryreader.slot < filled and !MI32.batteryreader.active
readOneBat();
// read a sensor if
// read a sensor if
// MI32.sensorreader.slot < filled and !MI32.sensorreader.active
// for sensors which need to get data through notify...
readOneSensor();
@ -1893,7 +1893,7 @@ void MI32EverySecond(bool restart){
if (MI32.secondsCounter >= MI32.period){
// only if we finished the last read
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.
MI32.sensorreader.slot = 0;
MI32.secondsCounter = 0;
@ -1903,11 +1903,11 @@ void MI32EverySecond(bool restart){
if (MI32.secondsCounter2 >= MI32.period){
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.secondsCounter2 = 0;
} 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.secondsCounter2 = 0;
}
@ -1968,15 +1968,15 @@ void CmndMi32Time(void) {
if (MIBLEsensors.size() > slot) {
int res = genericTimeWriteFn(slot);
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);
return;
}
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) {
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?
int res = genericUnitWriteFn(slot, -1);
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);
return;
}
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) {
AddLog_P(LOG_LEVEL_ERROR, PSTR("MI32: cannot toggle Unit right now"));
AddLog_P(LOG_LEVEL_ERROR, PSTR("M32: cannot toggle Unit right now"));
}
}
}
@ -2058,7 +2058,7 @@ void CmndMi32Block(void){
} break;
default:
case 1:
break;
break;
}
MI32BlockListResp();
return;
@ -2076,7 +2076,7 @@ void CmndMi32Block(void){
case 0: {
//TasAutoMutex localmutex(&slotmutex, "Mi32Block2");
MIBLEBlockList.erase( std::remove_if( begin( MIBLEBlockList ), end( MIBLEBlockList ), [_MACasBytes]( MAC_t& _entry )->bool
{ return (memcmp(_entry.buf,_MACasBytes.buf,6) == 0); }
{ return (memcmp(_entry.buf,_MACasBytes.buf,6) == 0); }
), end( MIBLEBlockList ) );
} break;
case 1: {
@ -2091,8 +2091,8 @@ void CmndMi32Block(void){
MIBLEBlockList.push_back(_MACasBytes);
MI32removeMIBLEsensor(_MACasBytes.buf);
}
// AddLog_P(LOG_LEVEL_INFO,PSTR("MI32: size of ilist: %u"), MIBLEBlockList.size());
} break;
// AddLog_P(LOG_LEVEL_INFO,PSTR("M32: size of ilist: %u"), MIBLEBlockList.size());
} break;
}
MI32BlockListResp();
}
@ -2126,7 +2126,7 @@ void MI32KeyListResp(){
ToHex_P(MIBLEbindKeys[i].MAC,6,tmp,20,0);
char key[16*2+1];
ToHex_P(MIBLEbindKeys[i].key,16,key,33,0);
ResponseAppend_P(PSTR("\"%s\":\"%s\""), tmp, key);
}
ResponseAppend_P(PSTR("}}"));
@ -2136,7 +2136,7 @@ void MI32KeyListResp(){
void CmndMi32Keys(void){
#ifdef BLE_ESP32_ALIASES
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;
switch(op){
@ -2175,7 +2175,7 @@ void CmndMi32Keys(void){
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];
// convert mac back to string
ToHex_P(addr,6,tmp,20,0);
@ -2186,7 +2186,7 @@ void CmndMi32Keys(void){
} while (p);
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();
} else {
MI32KeyListResp();
@ -2194,7 +2194,7 @@ void CmndMi32Keys(void){
return;
} break;
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--){
MIBLEbindKeys.pop_back();
}
@ -2232,7 +2232,7 @@ const char HTTP_MI32_HL[] PROGMEM = "{s}<hr>{m}<hr>{e}";
const char HTTP_NEEDKEY[] PROGMEM = "{s}%s <a target=\"_blank\" href=\""
"https://btsimonh.github.io/atc1441.github.io/TelinkFlasherTasmota.html?mac=%s&cb=http%%3A%%2F%%2F%s%%2Fmikey"
"\">%s</a>{m} {e}";
const char HTTP_PAIRING[] PROGMEM = "{s}%s Pair Button Pressed{m} {e}";
@ -2246,10 +2246,10 @@ const char HTTP_MI_KEY_STYLE[] PROGMEM = "";
#define D_MI32_KEY "MI32 Set Key"
void HandleMI32Key(){
AddLog_P(LOG_LEVEL_DEBUG, PSTR("HandleMI32Key hit"));
if (!HttpCheckPriviledgedAccess()) {
AddLog_P(LOG_LEVEL_DEBUG, PSTR("!HttpCheckPriviledgedAccess()"));
return;
AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: HandleMI32Key hit"));
if (!HttpCheckPriviledgedAccess()) {
AddLog_P(LOG_LEVEL_DEBUG, PSTR("M32: !HttpCheckPriviledgedAccess()"));
return;
}
WSContentStart_P(PSTR(D_MI32_KEY));
WSContentSendStyle_P(HTTP_MI_KEY_STYLE);
@ -2286,13 +2286,13 @@ void MI32TimeoutSensors(){
// so block for as long as it takes.
// PROBLEM: when we take this, it hangs the BLE loop.
// BUT, devicePresent uses the
// BUT, devicePresent uses the
// remove devices for which the adverts have timed out
for (int i = MIBLEsensors.size()-1; i >= 0 ; i--) {
//if (MIBLEsensors[i].MAC[2] || MIBLEsensors[i].MAC[3] || MIBLEsensors[i].MAC[4] || MIBLEsensors[i].MAC[5]){
if (!BLE_ESP32::devicePresent(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");
MIBLEsensors.erase(MIBLEsensors.begin() + i);
}
@ -2313,7 +2313,7 @@ void MI32GetOneSensorJson(int slot){
ResponseAppend_P(PSTR("\"MAC\":\"%02x%02x%02x%02x%02x%02x\""),
p->MAC[0], p->MAC[1], p->MAC[2],
p->MAC[3], p->MAC[4], p->MAC[5]);
if((!MI32.mode.triggeredTele && !MI32.option.minimalSummary)||MI32.mode.triggeredTele){
bool tempHumSended = false;
if(p->feature.tempHum){
@ -2497,7 +2497,7 @@ void MI32ShowSomeSensors(){
}
ResponseAppend_P(PSTR("}"));
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
RulesTeleperiod(); // Allow rule based HA messages
@ -2547,7 +2547,7 @@ void MI32ShowTriggeredSensors(){
if (cnt){ // if we got one, then publish
ResponseAppend_P(PSTR("}"));
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
RulesTeleperiod(); // Allow rule based HA messages
@ -2565,7 +2565,7 @@ void MI32Show(bool json)
// don't detect half-added ones here
int numsensors = MIBLEsensors.size();
if (json) {
if (json) {
// TELE JSON messages now do nothing here, apart from set MI32.mqttCurrentSlot
// which will trigger send next second of up to 4 sensors, then the next four in the next second, etc.
//MI32.mqttCurrentSlot = 0;
@ -2576,7 +2576,7 @@ void MI32Show(bool json)
static uint16_t _counter = 0;
int32_t i = _page * MI32.perPage;
uint32_t j = i + MI32.perPage;
if (j+1 > numsensors){
j = numsensors;
}