Tasmota/tasmota/xsns_62_esp32_mi_ble.ino

/*
  xsns_62_esp32_mi_ble.ino - MI-BLE-sensors via ESP32 support for Tasmota
  enabled by ESP32 && USE_BLE_ESP32
  if (ESP32 && !USE_BLE_ESP32) then xsns_62_esp32_mi.ino is used - the older driver


  Copyright (C) 2020  Christian Baars and Theo Arends
  Also Simon Hailes and Robert Klauco 

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.


  --------------------------------------------------------------------------------------------
  Version yyyymmdd  Action    Description
  --------------------------------------------------------------------------------------------
  0.9.2.1 20210217  changed - make features alos depend on received data - i.e. 'unknown' devices will show what they send.
                              Add MI32Option6 1 to switch to tele/tasmota_ble/<somename> style MQTT independent of HASS discovery.
  -------
  0.9.2.0 20210127  changed - Officially includes as the mi driver when using USE_BLE_ESP32.
  -------
  0.9.1.9 20201226  changed - All change now.
  -------
  0.9.1.7 20201116  changed - small bugfixes, add BLOCK and OPTION command, send BLE scan via MQTT
  -------
  0.9.1.6 20201022  changed - Beacon support, RSSI at TELEPERIOD, refactoring
  -------
  0.9.1.5 20201021  changed - HASS related ('null', hold back discovery), number of found sensors for RULES
  -------
  0.9.1.4 20201020  changed - use BearSSL for decryption, revert to old TELEPERIOD-cycle as default
  -------
  0.9.1.3 20200926  changed - Improve HA discovery, make key+MAC case insensitive
  -------
  0.9.1.3 20200916  changed - add ATC (custom FW for LYWSD03MMC), API adaption for NimBLE-Arduino 1.0.2
  -------
  0.9.1.2 20200802  changed - add MHO-C303
  -------
  0.9.1.1 20200715  changed - add MHO-C401, refactoring
  -------
  0.9.1.0 20200712  changed - add lights and yeerc, add pure passive mode with decryption,
                              lots of refactoring
  -------
  0.9.0.1 20200706  changed - adapt to new NimBLE-API, tweak scan process
  -------
  0.9.0.0 20200413  started - initial development by Christian Baars
                    forked  - from arendst/tasmota            - https://github.com/arendst/Tasmota

*/
//#define VSCODE_DEV

/*
#ifdef VSCODE_DEV
#define ESP32
#define USE_BLE_ESP32
#define USE_MI_ESP32
#endif
*/
//#undef USE_MI_ESP32

// for testing of BLE_ESP32, we remove xsns_62_MI_ESP32.ino completely, and instead add this modified xsns_52_ibeacon_BLE_ESP32.ino
#ifdef USE_BLE_ESP32

#ifdef ESP32                       // ESP32 only. Use define USE_HM10 for ESP8266 support
#if CONFIG_IDF_TARGET_ESP32

#ifdef USE_MI_ESP32

#define XSNS_62                    62
#define USE_MI_DECRYPTION

#include <vector>
#ifdef USE_MI_DECRYPTION
#include <t_bearssl.h>
#endif //USE_MI_DECRYPTION

void MI32scanEndedCB(NimBLEScanResults results);
void MI32notifyCB(NimBLERemoteCharacteristic* pRemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify);

struct {
  uint16_t perPage = 4;
  uint8_t mqttCurrentSlot = 0;
  uint8_t mqttCurrentSingleSlot = 0;
  uint32_t period;             // set manually in addition to TELE-period, is set to TELE-period after start
  int secondsCounter = 0;   // counts up in MI32EverySecond to period
  int secondsCounter2 = 0;  // counts up in MI32EverySecond to period
  union {
    struct {
      uint32_t init:1;
      uint32_t shallClearResults:1;   // BLE scan results
      uint32_t shallShowStatusInfo:1; // react to amount of found sensors via RULES
      uint32_t firstAutodiscoveryDone:1;
      uint32_t shallTriggerTele:1;
      uint32_t triggeredTele:1;
    };
    uint32_t all = 0;
  } mode;

  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;
  } 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;
  } sensorreader;

  struct {
    uint32_t allwaysAggregate:1; // always show all known values of one sensor in brdigemode
    uint32_t noSummary:1;        // no sensor values at TELE-period
    uint32_t directBridgeMode:1; // send every received BLE-packet as a MQTT-message in real-time
    uint32_t holdBackFirstAutodiscovery:1; // allows to trigger it later
    uint32_t showRSSI:1;
    uint32_t ignoreBogusBattery:1;
    uint32_t minimalSummary:1;   // DEPRECATED!!
    uint32_t onlyAliased:1;      // only include sensors that are aliased
    uint32_t MQTTType:1;
  } option;
} MI32;

#pragma pack(1)  // byte-aligned structures to read the sensor data

  struct {
    int16_t temp;
    uint8_t hum;
    uint16_t volt; // LYWSD03 only
  } LYWSD0x_HT;
  struct {
    uint8_t spare;
    int16_t temp;
    uint16_t hum;
  } CGD1_HT;
  struct {
    int16_t temp;
    uint8_t spare;
    uint32_t lux;
    uint8_t moist;
    uint16_t fert;
  } Flora_TLMF; // temperature, lux, moisture, fertility


////////////////////////////////////////////////////////////
// from https://github.com/Magalex2x14/LYWSD03MMC-info
struct mi_beacon_frame_data_t{
  // data from byte 0 - e.g. 30
  uint8_t meshflag;             //Byte 0: x.......
  uint8_t dataflag;             //Byte 0: .x......
  uint8_t compatibilityflag;    //Byte 0: ..x..... - indicates compatibility data present
  uint8_t MACFlag;              //Byte 0: ...x....
  uint8_t isencrypted;          //Byte 0: ....x...
  uint8_t reserved;             //Byte 0: .....xxx

  // data from byte 1 - e.g. 58
  uint8_t version;              //Byte 0: xxxx....
  uint8_t authMode;             //Byte 0: ....xx.. // e.g. 2
  uint8_t bindingvalidreq;      //Byte 0: ......x.
  uint8_t registeredflag;       //Byte 0: .......x
};

struct mi_beacon_compatibility_data_t{ // e.g. 28/08
  uint8_t reserved;             //Byte 0: xx......
  uint8_t IOcap;                //Byte 0: ..x.....
  uint8_t bondability;          //Byte 0: ...xx...
  uint8_t unused;               //Byte 0: .....xxx
  uint16_t IOCapability;        // bytes 1-2, e.g. 01 00 -> 0001
};
struct mi_beacon_mac_data_t{ // e.g. 28/08
  uint8_t mac[6];
};
struct mi_beacon_payload_data_t{ //
  uint8_t type;
  uint8_t ten;
  uint8_t size;
  uint8_t data[16];
};

struct mi_beacon_data_t { //
  mi_beacon_frame_data_t framedata;
  uint16_t devicetype;
  uint8_t framecnt;
  mi_beacon_mac_data_t macdata;
  mi_beacon_compatibility_data_t compatibility;
  uint8_t payloadpresent;
  uint8_t needkey; // we need a (new) encryption key?

  mi_beacon_payload_data_t payload;
};

struct mi_beacon_data_payload_data_t { //
  union {
    struct{ //01
      uint16_t num;
      uint8_t longPress;
    } Btn;

    int16_t temp; //04
    uint16_t hum; //06
    uint32_t lux; //07
    uint8_t moist; //08
    uint16_t fert; //09
    uint8_t bat; //0a
    struct{ //0d
      int16_t temp;
      uint16_t hum;
    } HT;
    uint32_t NMT; //17
  };
};



///////////////////////////////////////////////////////////



union mi_bindKey_t{
  struct{
    uint8_t key[16];
    uint8_t MAC[6];
    };
  uint8_t buf[22];
};

struct ATCPacket_t{
	//uint8_t		size;	// = 16?
	//uint8_t		uid;	// = 0x16, 16-bit UUID
	//uint16_t	UUID;	// = 0x181A, GATT Service 0x181A Environmental Sensing
  uint8_t MAC[6]; // [0] - hi, .. [6] - lo digits
  uint16_t temp; //sadly this is in wrong endianess
  uint8_t hum;
  uint8_t batPer;
  uint16_t batMV;
  uint8_t frameCnt;
};

// GATT Service 0x181A Environmental Sensing
// All data little-endian
struct PVVXPacket_t {
	//uint8_t		size;	// = 19
	//uint8_t		uid;	// = 0x16, 16-bit UUID
	//uint16_t	UUID;	// = 0x181A, GATT Service 0x181A Environmental Sensing
	uint8_t		MAC[6]; // [0] - lo, .. [6] - hi digits
	int16_t		temperature; // x 0.1 degree
	uint16_t	humidity; // x 0.01 %
	uint16_t	battery_mv; // mV
	uint8_t		battery_level; // 0..100 %
	uint8_t		counter; // measurement count
	uint8_t		flags;
};

#pragma pack(0)

struct mi_sensor_t{
  uint8_t type; //MI_Flora = 1; MI_MI-HT_V1=2; MI_LYWSD02=3; MI_LYWSD03=4; MI_CGG1=5; MI_CGD1=6
  uint8_t needkey; // tells http to display needkey message with link
  uint8_t lastCnt; //device generated counter of the packet
  uint8_t nextDiscoveryData; // used to lkimit discovery to one MQTT per sec

  uint8_t shallSendMQTT;
  uint8_t MAC[6];
  union {
    struct {
      uint32_t temp:1;
      uint32_t hum:1;
      uint32_t tempHum:1; //every hum sensor has temp too, easier to use Tasmota dew point functions
      uint32_t lux:1;
      uint32_t moist:1;
      uint32_t fert:1;
      uint32_t bat:1;
      uint32_t NMT:1;
      uint32_t PIR:1;
      uint32_t Btn:1;
      uint32_t events:1;
      uint32_t pairing:1;
    };
    uint32_t raw;
  } feature;
  union {
    struct {
      uint32_t temp:1;
      uint32_t hum:1;
      uint32_t tempHum:1; //can be combined from the sensor
      uint32_t lux:1;
      uint32_t moist:1;
      uint32_t fert:1;
      uint32_t bat:1;
      uint32_t NMT:1;
      uint32_t motion:1;
      uint32_t noMotion:1;
      uint32_t Btn:1;
      uint32_t PairBtn:1;
    };
    uint32_t raw;
  } eventType;

  int RSSI;
  uint8_t pairing;
  uint32_t lastTime;
  uint32_t lux;
  float temp; //Flora, MJ_HT_V1, LYWSD0x, CGx
  union {
    struct {
      uint8_t moisture;
      uint16_t fertility;
      char firmware[6]; // actually only for FLORA but hopefully we can add for more devices
    }; // Flora
    struct {
      float hum;
    }; // MJ_HT_V1, LYWSD0x
    struct {
      uint16_t events; //"alarms" since boot
      uint32_t NMT;    // no motion time in seconds for the MJYD2S
    };
    uint16_t Btn;
  };
  union {
      uint8_t bat; // many values seem to be hard-coded garbage (LYWSD0x, GCD1)
  };
};

struct MAC_t {
  uint8_t buf[6];
};

std::vector<mi_sensor_t> MIBLEsensors;
std::vector<mi_bindKey_t> MIBLEbindKeys;
std::vector<MAC_t> MIBLEBlockList;

void *slotmutex = nullptr;

/*********************************************************************************************\
 * constants
\*********************************************************************************************/

#define D_CMND_MI32 "MI32"

const char kMI32_Commands[] PROGMEM = D_CMND_MI32 "|"
#ifdef USE_MI_DECRYPTION
  "Key|"
  "Keys|"
#endif  // USE_MI_DECRYPTION
  "Period|Time|Page|Battery|Unit|Block|Option";

void (*const MI32_Commands[])(void) PROGMEM = {
#ifdef USE_MI_DECRYPTION
  &CmndMi32Key,
  &CmndMi32Keys,
#endif  // USE_MI_DECRYPTION
  &CmndMi32Period, &CmndMi32Time, &CmndMi32Page, &CmndMi32Battery, &CmndMi32Unit, &CmndMi32Block, &CmndMi32Option };


#define MI_UNKOWN      1
#define MI_FLORA       2
#define MI_MJ_HT_V1    3
#define MI_LYWSD02     4
#define MI_LYWSD03MMC  5
#define MI_CGG1        6
#define MI_CGD1        7
#define MI_NLIGHT      8
#define MI_MJYD2S      9
#define MI_YEERC       10
#define MI_MHOC401     11
#define MI_MHOC303     12
#define MI_ATC         13
#define MI_DOOR        14

#define MI_MI32_TYPES    14 //count this manually

const uint16_t kMI32DeviceID[MI_MI32_TYPES]={
  0x0000, // Unkown
  0x0098, // Flora
  0x01aa, // MJ_HT_V1
  0x045b, // LYWSD02
  0x055b, // LYWSD03
  0x0347, // CGG1
  0x0576, // CGD1
  0x03dd, // NLIGHT
  0x07f6, // MJYD2S
  0x0153, // yee-rc
  0x0387, // MHO-C401
  0x06d3, // MHO-C303
  0x0a1c,  // ATC -> this is a fake ID
  0x098b  // door/window sensor
};

const char kMI32DeviceType0[] PROGMEM = "Unknown";
const char kMI32DeviceType1[] PROGMEM = "Flora";
const char kMI32DeviceType2[] PROGMEM = "MJ_HT_V1";
const char kMI32DeviceType3[] PROGMEM = "LYWSD02";
const char kMI32DeviceType4[] PROGMEM = "LYWSD03";
const char kMI32DeviceType5[] PROGMEM = "CGG1";
const char kMI32DeviceType6[] PROGMEM = "CGD1";
const char kMI32DeviceType7[] PROGMEM = "NLIGHT";
const char kMI32DeviceType8[] PROGMEM = "MJYD2S";
const char kMI32DeviceType9[] PROGMEM = "YEERC";
const char kMI32DeviceType10[] PROGMEM ="MHOC401";
const char kMI32DeviceType11[] PROGMEM ="MHOC303";
const char kMI32DeviceType12[] PROGMEM ="ATC";
const char kMI32DeviceType13[] PROGMEM ="DOOR";
const char * kMI32DeviceType[] PROGMEM = {kMI32DeviceType0,kMI32DeviceType1,kMI32DeviceType2,kMI32DeviceType3,kMI32DeviceType4,kMI32DeviceType5,kMI32DeviceType6,kMI32DeviceType7,kMI32DeviceType8,kMI32DeviceType9,kMI32DeviceType10,kMI32DeviceType11,kMI32DeviceType12,kMI32DeviceType13};

typedef int BATREAD_FUNCTION(int slot);
typedef int UNITWRITE_FUNCTION(int slot, int unit);
typedef int TIMEWRITE_FUNCTION(int slot);

int genericOpCompleteFn(BLE_ESP32::generic_sensor_t *pStruct);
int genericBatReadFn(int slot);
int genericUnitWriteFn(int slot, int unit);
int genericTimeWriteFn(int slot);
int MI32scanCompleteCallback(NimBLEScanResults results);

const char LYWSD02_Svc[] PROGMEM =              "EBE0CCB0-7A0A-4B0C-8A1A-6FF2997DA3A6";
const char LYWSD02_BattChar[] PROGMEM =         "EBE0CCC4-7A0A-4B0C-8A1A-6FF2997DA3A6";
const char LYWSD02_UnitChar[] PROGMEM =         "EBE0CCBE-7A0A-4B0C-8A1A-6FF2997DA3A6";
const char LYWSD02_TimeChar[] PROGMEM =         "EBE0CCB7-7A0A-4B0C-8A1A-6FF2997DA3A6";
const char LYWSD02_BattNotifyChar[] PROGMEM =   "EBE0CCC1-7A0A-4B0C-8A1A-6FF2997DA3A6";

const char *LYWSD03_Svc = LYWSD02_Svc;
const char *LYWSD03_BattNotifyChar = LYWSD02_BattNotifyChar;

const char *MHOC303_Svc = LYWSD02_Svc;
const char *MHOC303_UnitChar = LYWSD02_UnitChar;
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 FLORA_Svc[] PROGMEM =                "00001204-0000-1000-8000-00805F9B34FB";
const char FLORA_BattChar[] PROGMEM =           "00001A02-0000-1000-8000-00805F9B34FB";



/*********************************************************************************************\
 * enumerations
\*********************************************************************************************/

// types of operation performed, included in context
enum MI32_MI_OP_TYPES {
  OP_TIME_WRITE = 0,
  OP_BATT_READ = 1,
  OP_UNIT_WRITE = 2,
  OP_UNIT_READ = 3,
  OP_UNIT_TOGGLE = 4,
  OP_READ_HT_LY = 5,
};


enum MI32_MI_KEY_REQ {
  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
  KEY_REQUIRED_AND_INVALID = 4, // we got an encrypted packet, and could not decrypt
};

/*********************************************************************************************\
 * Classes
\*********************************************************************************************/


// fn type READ_CALLBACK
// NOTE!!!: this callback is called DIRECTLY from the operation task, so be careful about cross-thread access of data
// if is called after read, so that you can do a read/modify/write operation on a characteristic.
int toggleUnit(BLE_ESP32::generic_sensor_t *op){
  uint32_t context = (uint32_t) op->context;
  int opType = context >> 24;
  // we only need to op type
  int devType = (context >> 16) & 0xff;
  int slot = (context) & 0xff;
  switch (opType){
    case OP_UNIT_TOGGLE:{
      uint8_t curUnit = 0;
      if( op->dataRead[0] != 0 && op->dataRead[0] < 101 ){
          curUnit = op->dataRead[0];
      }

      curUnit = curUnit == 0x01?0xFF:0x01;  // C/F
      // copy in ALL of the data, because we don't know how long this is from the existing src code.
      memcpy(op->dataToWrite, op->dataRead, op->readlen);
      op->writelen = op->readlen;
      op->dataToWrite[0] = curUnit;
    } break;
    case OP_UNIT_WRITE:{
      uint8_t curUnit = op->dataToWrite[0];
      // copy in ALL of the data, because we don't know how long this is from the existing src code.
      memcpy(op->dataToWrite, op->dataRead, op->readlen);
      op->writelen = op->readlen;
      op->dataToWrite[0] = curUnit;
    } break;
  }
  return 0;
}

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(LOG_LEVEL_ERROR, PSTR("M32: Op inv svc"));
    return 0;
  }

  BLE_ESP32::generic_sensor_t *op = nullptr;

  // ALWAYS use this function to create a new one.
  int res = BLE_ESP32::newOperation(&op);
  if (!res){
    AddLog(LOG_LEVEL_ERROR,PSTR("M32: Can't get a newOperation"));
    return 0;
  } else {
    if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG, PSTR("M32: Got a newOperation"));
  }

  if (slot >= 0){
    op->addr = NimBLEAddress(MIBLEsensors[slot].MAC);
  } else {
    if (!addr){
      AddLog(LOG_LEVEL_ERROR, PSTR("M32: No addr"));
      BLE_ESP32::freeOperation(&op);
      return 0;
    }
    op->addr = NimBLEAddress(addr);
  }

  bool havechar = false;
  op->serviceUUID = NimBLEUUID(svc);

  if (!op->serviceUUID.bitSize()){
    BLE_ESP32::freeOperation(&op);
    AddLog(LOG_LEVEL_ERROR, PSTR("M32: MI Bad service string %s"), svc);
    return 0;
  }


  if (charactistic && charactistic[0]){
    havechar = true;
    op->characteristicUUID = NimBLEUUID(charactistic);
    if (!op->characteristicUUID.bitSize()){
      BLE_ESP32::freeOperation(&op);
      AddLog(LOG_LEVEL_ERROR, PSTR("M32: MI Bad characteristic string %s"), charactistic);
      return 0;
    }
  }
  if (notifychar && notifychar[0]){
    op->notificationCharacteristicUUID = NimBLEUUID(notifychar);
    if (!op->notificationCharacteristicUUID.bitSize()){
      BLE_ESP32::freeOperation(&op);
      AddLog(LOG_LEVEL_ERROR, PSTR("M32: MI Bad notifycharacteristic string %s"), notifychar);
      return 0;
    }
  }

  if (data && datalen) {
    op->writelen = datalen;
    memcpy(op->dataToWrite, data, datalen);
  } else {
    if (!datalen && havechar){
      op->readlen = 1; // if we don't set readlen, then it won't read
    }
  }

  // the only times we intercept between read abnd write
  if ((optype == OP_UNIT_WRITE) || (optype == OP_UNIT_TOGGLE)){
    op->readlen = 1; // if we don't set readlen, then it won't read
    op->readmodifywritecallback = (void *)toggleUnit;
  }

  // this op will call us back on complete or failure.
  op->completecallback = (void *)genericOpCompleteFn;
  uint32_t context = (optype << 24) | (MIBLEsensors[slot].type << 16) | slot;
  op->context = (void *)context;

  if (BLE_ESP32::BLEDebugMode > 0) AddLog(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(LOG_LEVEL_ERROR, PSTR("M32: Failed to queue new operation - deleted"));
  }

  return res;
}



int genericBatReadFn(int slot){
  int res = 0;

  switch(MIBLEsensors[slot].type) {
    // these use notify for battery read, and it comes in the temp packet
    case MI_LYWSD03MMC:
      res = MI32Operation(slot, OP_BATT_READ, LYWSD03_Svc, nullptr, LYWSD03_BattNotifyChar);
      break;
    case MI_MHOC401:
      res = MI32Operation(slot, OP_BATT_READ, MHOC401_Svc, nullptr, MHOC401_BattNotifyChar);
      break;

    // these read a characteristic
    case MI_FLORA:
      res = MI32Operation(slot, OP_BATT_READ, FLORA_Svc, FLORA_BattChar);
      break;
    case MI_LYWSD02:
      res = MI32Operation(slot, OP_BATT_READ, LYWSD02_Svc, LYWSD02_BattChar);
      break;
    case MI_CGD1:
      res = MI32Operation(slot, OP_BATT_READ, CGD1_Svc, CGD1_BattChar);
      break;

// this was for testing only - it does work, but no need to read as we get good bat in advert
//    case MI_MJ_HT_V1:
//      res = MI32Operation(slot, OP_BATT_READ, CGD1_Svc, CGD1_BattChar);
//      break;

    default:
      res = -10; // no need to read
      break;
  }
  if (res > 0){
    if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_INFO, PSTR("M32: Req batt read slot %d type %d queued"), slot, MIBLEsensors[slot].type);
  } else {
    if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_INFO, PSTR("M32: Req batt read slot %d type %d non-queued res %d"), slot, MIBLEsensors[slot].type, res);
  }
  return res;
}



int genericSensorReadFn(int slot, int force){
  int res = 0;
  switch(MIBLEsensors[slot].type) {
/*  seen notify timeout consistently with MI_LYWSD02,
    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
      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
      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
      if (MIBLEsensors[slot].needkey == KEY_REQUIRED_AND_FOUND && !force) return -2;
      res = MI32Operation(slot, OP_READ_HT_LY, MHOC401_Svc, nullptr, MHOC401_BattNotifyChar);
      break;

    default:
      res = -1;
      break;
  }
  return res;
}


// called once per second
int readOneSensor(){
  if (MI32.sensorreader.active){
    AddLog(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;
  do {
    // MI32.sensorreader.slot is reset to zero to trigger a read sequence
    if (MI32.sensorreader.slot >= MIBLEsensors.size()){
      //AddLog(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(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){
      MI32.sensorreader.slot++;
    } else {
      break;
    }
  } while (1);

  if (res == 0){
    // can't read at the moment (no operations available?)
    AddLog(LOG_LEVEL_DEBUG, PSTR("M32: readOneSensor no ops available slot %d res %d"), MI32.sensorreader.slot, res);
    return 0;
  }

  // setup next slot to read
  MI32.sensorreader.slot++;
  // 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(LOG_LEVEL_DEBUG, PSTR("M32: readOneSensor reading for slot %d res %d"), MI32.sensorreader.slot-1, res);

  // started one
  return 1;
}



// called once per second
int readOneBat(){
  if (MI32.batteryreader.active){
    return 0;
  }

  //MI32.batteryreader.slot is rest to zero to trigger a read...
  if (MI32.batteryreader.slot >= MIBLEsensors.size()){
    return 0;
  }

  int res = genericBatReadFn(MI32.batteryreader.slot);

  // if this sensor in this slot does not support battery read, just move on top the next one
  if (res < 0){
    MI32.batteryreader.slot++;
    if (MI32.batteryreader.slot >= MIBLEsensors.size()){
      if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_INFO, PSTR("M32: Batt loop complete at %d"), MI32.batteryreader.slot);
    }
    return 0;
  }

  if (res == 0){
    // can't read at the moment (no operations available?)
    return 0;
  }

  // setup next slot to read
  MI32.batteryreader.slot++;
  // and make it wait until the read/notify is complete
  // this is cleared in the response callback.
  MI32.batteryreader.active = 1;
  if (MI32.batteryreader.slot >= MIBLEsensors.size()){
    if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_INFO, PSTR("M32: Batt loop will complete at %d"), MI32.batteryreader.slot);
  }
  // started one
  return 1;
}



/////////////////////////////////////////////////////
// change the unit of measurement?
// call with unit == -1 to cause the unit to be toggled.
int genericUnitWriteFn(int slot, int unit){
  int res = 0;
  int op = OP_UNIT_WRITE;
  if (unit == -1){
    op = OP_UNIT_TOGGLE;
  }
  uint8_t writeData[1];
  writeData[0] = unit;
  switch (MIBLEsensors[slot].type){
    case MI_LYWSD02:
      res = MI32Operation(slot, op, LYWSD02_Svc, LYWSD02_UnitChar, nullptr, writeData, 1);
      break;
    case MI_MHOC303: // actually, EXACTLY the same as above, including the sevice and characteristic...
      res = MI32Operation(slot, op, MHOC303_Svc, MHOC303_UnitChar, nullptr, writeData, 1);
      break;
    default:
      res = -1;
      break;
  }
  return res;
}

/////////////////////////////////////////////////////
// read the unit of measurement.  genericOpCompleteFn
int genericUnitReadFn(int slot){
  int res = 0;
  switch (MIBLEsensors[slot].type){
    case MI_LYWSD02:
      res = MI32Operation(slot, OP_UNIT_READ, LYWSD02_Svc, LYWSD02_UnitChar);
      break;
    case MI_MHOC303: // actually, EXACTLY the same as above, including the sevice and characteristic...
      res = MI32Operation(slot, OP_UNIT_READ, MHOC303_Svc, MHOC303_UnitChar);
      break;
    default:
      res = -1;
      break;
  }
  return res;
}


/////////////////////////////////////////////////////
// write time to a device. genericOpCompleteFn
int genericTimeWriteFn(int slot){
  int res = 0;
  switch (MIBLEsensors[slot].type){
    case MI_LYWSD02: {
      union {
        uint8_t buf[5];
        uint32_t time;
      } _utc;
      _utc.time = Rtc.utc_time;
      _utc.buf[4] = Rtc.time_timezone / 60;
      res = MI32Operation(slot, OP_TIME_WRITE, LYWSD02_Svc, LYWSD02_TimeChar, nullptr, _utc.buf, sizeof(_utc.buf));
    } break;
    case MI_MHOC303: // actually, EXACTLY the same as above, including the sevice and characteristic...
      union {
        uint8_t buf[5];
        uint32_t time;
      } _utc;
      _utc.time = Rtc.utc_time;
      _utc.buf[4] = Rtc.time_timezone / 60;
      res = MI32Operation(slot, OP_TIME_WRITE, MHOC303_Svc, MHOC303_TimeChar, nullptr, _utc.buf, sizeof(_utc.buf));
      break;
    default:
      res = -1;
      break;
  }
  return res;
}


int genericOpCompleteFn(BLE_ESP32::generic_sensor_t *op){
  uint32_t context = (uint32_t) op->context;

  if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG, PSTR("M32: MI op complete context %x"), context);

  int opType = context >> 24;
  int devType = (context >> 16) & 0xff;
  int slot = (context) & 0xff;

  char slotMAC[13];
  BLE_ESP32::dump(slotMAC, sizeof(slotMAC), MIBLEsensors[slot].MAC, 6) ;
  uint8_t addrrev[6];
  memcpy(addrrev, MIBLEsensors[slot].MAC, 6);
  //BLE_ESP32::ReverseMAC(addrrev);
  NimBLEAddress addr(addrrev);

  bool fail = false;
  if (op->addr != addr){
    // slot changed during operation?
    AddLog(LOG_LEVEL_ERROR, PSTR("M32: Slot mac changed during an operation"));
    fail = true;
  }

  if (op->state <= GEN_STATE_FAILED){
    AddLog(LOG_LEVEL_ERROR, PSTR("M32: Operation failed %d for %s"), op->state, slotMAC);
    fail = true;
  }

  if (fail){
    switch(opType){
      case OP_BATT_READ:{
        // allow another...
        MI32.batteryreader.active = 0;
      } break;
      case OP_READ_HT_LY: {
        // allow another...
        MI32.sensorreader.active = 0;
      } break;
    }
    return 0;
  }

  switch(opType){
    case OP_TIME_WRITE:
      AddLog(LOG_LEVEL_DEBUG, PSTR("M32: Time write for %s complete"), slotMAC);
      return 0; // nothing to do
    case OP_BATT_READ:{
      uint8_t *data = nullptr;
      int len = 0;
      if (op->notifylen){
        data = op->dataNotify;
        len = op->notifylen;
        // note: the only thingas that have battery in notify FOR THE MOMENT read it like this.
        MI32notifyHT_LY(slot, (char*)op->dataNotify, op->notifylen);
      }
      if (op->readlen){
        data = op->dataRead;
        len = op->readlen;
        MIParseBatt(slot, data, len);
      }

      // allow another...
      MI32.batteryreader.active = 0;
      AddLog(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(LOG_LEVEL_DEBUG, PSTR("M32: Unit write for %s complete"), slotMAC);
      return 0;

    case OP_UNIT_READ: {
      uint8_t currUnit = op->dataRead[0];
      AddLog(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(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(LOG_LEVEL_DEBUG, PSTR("M32: HT_LY notify for %s complete"), slotMAC);
    } return 0;

    default:
      AddLog(LOG_LEVEL_ERROR, PSTR("M32: OpType %d not recognised?"), opType);
      return 0;
  }

  return 0;
}

int MI32advertismentCallback(BLE_ESP32::ble_advertisment_t *pStruct)
{
  // we will try not to use this...
  BLEAdvertisedDevice *advertisedDevice = pStruct->advertisedDevice;

  // AddLog(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;
  if (MI32.option.onlyAliased){
    const char *alias = BLE_ESP32::getAlias(addr);
    if (!alias || !(*alias)){
      return 0;
    }
  }

  int svcdataCount = advertisedDevice->getServiceDataCount();

  if (svcdataCount == 0) {
    return 0;
  }

  NimBLEUUID UUIDBig = advertisedDevice->getServiceDataUUID(0);//.getNative()->u16.value;

  const ble_uuid_any_t* native = UUIDBig.getNative();
  if (native->u.type != 16){
    //not interested in 128 bit;
    return 0;
  }
  uint16_t UUID = native->u16.value;

  char temp[60];
  BLE_ESP32::dump(temp, 13, addr, 6);

  if (BLE_ESP32::BLEDebugMode > 0) AddLog(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(LOG_LEVEL_DEBUG_MORE, PSTR("M32: MI:%s"), temp);


  if (UUID){
    // this will take and keep the mutex until the function is over
    TasAutoMutex localmutex(&slotmutex, "Mi32AdCB2");
    switch(UUID){
      case 0xfe95: // std MI?
      case 0xfdcd: // CGD1?
      {
        MI32ParseResponse(ServiceData, ServiceDataLength, addr, RSSI);
      } break;
      case 0x181a: { //ATC
        MI32ParseATCPacket(ServiceData, ServiceDataLength, addr, RSSI);
      } break;

      default:{
      } break;
    }
  }
  return 0;
}


/*********************************************************************************************\
 * Helper functions
\*********************************************************************************************/

/**
 * @brief Remove all colons from null terminated char array
 *
 * @param _string Typically representing a MAC-address like AA:BB:CC:DD:EE:FF
 */
void MI32stripColon(char* _string){
  uint32_t _length = strlen(_string);
  uint32_t _index = 0;
  while (_index < _length) {
    char c = _string[_index];
    if(c==':'){
      memmove(_string+_index,_string+_index+1,_length-_index);
    }
    _index++;
  }
  _string[_index] = 0;
}

/**
 * @brief Convert string that repesents a hexadecimal number to a byte array
 *
 * @param _string input string in format: AABBCCDDEEFF or AA:BB:CC:DD:EE:FF, caseinsensitive
 * @param _mac  target byte array must match the correct size (i.e. AA:BB -> uint8_t bytes[2])
 */

void MI32HexStringToBytes(char* _string, uint8_t* _byteArray) {
  MI32stripColon(_string);
  UpperCase(_string,_string);
  uint32_t index = 0;
  uint32_t _end = strlen(_string);
  memset(_byteArray,0,_end/2);
  while (index < _end) {
      char c = _string[index];
      uint8_t value = 0;
      if(c >= '0' && c <= '9')
        value = (c - '0');
      else if (c >= 'A' && c <= 'F')
        value = (10 + (c - 'A'));
      _byteArray[(index/2)] += value << (((index + 1) % 2) * 4);
      index++;
  }
}

/**
 * @brief Reverse an array of 6 bytes
 *
 * @param _mac a byte array of size 6 (typicalliy representing a MAC address)
 */
void MI32_ReverseMAC(uint8_t _mac[]){
  uint8_t _reversedMAC[6];
  for (uint8_t i=0; i<6; i++){
    _reversedMAC[5-i] = _mac[i];
  }
  memcpy(_mac,_reversedMAC, sizeof(_reversedMAC));
}

#ifdef USE_MI_DECRYPTION
int MI32AddKey(char* payload, char* key = nullptr){
  mi_bindKey_t keyMAC;

  if (!key){
    MI32HexStringToBytes(payload,keyMAC.buf);
  } else {
    MI32HexStringToBytes(payload,keyMAC.MAC);
    MI32HexStringToBytes(key,keyMAC.key);
  }

  bool unknownKey = true;
  for(uint32_t i=0; i<MIBLEbindKeys.size(); i++){
    if(memcmp(keyMAC.MAC,MIBLEbindKeys[i].MAC,sizeof(keyMAC.MAC))==0){
      AddLog(LOG_LEVEL_DEBUG, PSTR("M32: Known key"));
      memcpy(MIBLEbindKeys[i].key, keyMAC.key, 16);
      unknownKey=false;
      return 1;
    }
  }
  if(unknownKey){
    AddLog(LOG_LEVEL_DEBUG, PSTR("M32: New key"));
    MIBLEbindKeys.push_back(keyMAC);
    return 1;
  }
  return 0;
}




int MIDecryptPayload(const uint8_t *macin, const uint8_t *nonce, uint32_t tag, uint8_t *data, int len){
  uint8_t payload[32];
  uint8_t mac[6];
  memcpy(mac, macin, 6);
  MI32_ReverseMAC(mac);
  uint8_t _bindkey[32] = {0x0};
  const unsigned char authData[16] = {0x11};
  bool foundNoKey = true;
  if (BLE_ESP32::BLEDebugMode > 0) AddLog(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(LOG_LEVEL_DEBUG,PSTR("M32: Decryption Key found"));
      foundNoKey = false;
      break;
    }
  }
  if(foundNoKey){
    AddLog(LOG_LEVEL_DEBUG,PSTR("M32: No Key found"));
    return -2; // indicates needs key
  }

  br_aes_small_ctrcbc_keys keyCtx;
  br_aes_small_ctrcbc_init(&keyCtx, _bindkey, 16);

  br_ccm_context ctx;
  br_ccm_init(&ctx, &keyCtx.vtable);
  br_ccm_reset(&ctx, nonce, 12, 1, len, 4);
  br_ccm_aad_inject(&ctx, authData, 1);
  br_ccm_flip(&ctx);

  memcpy(payload, data, len); //we want to be sure about 4-byte alignement
  br_ccm_run(&ctx, 0, payload, len);
  memcpy(data, payload, len); //back to the packet


  // crashed in here - why?, so give it more space to work with?
  // returns 1 if matched, else 0
  int ret = br_ccm_check_tag(&ctx, &tag);

  if (BLE_ESP32::BLEDebugMode > 0) AddLog(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
}

#endif // USE_MI_DECRYPTION


// packet examples:
// MJ_HT_V1
// 5020 AA01 41 3AF4DAA8654C 0A100109
// 5020 AA01 43 3AF4DAA8654C 061002E901
// 5020 AA01 48 3AF4DAA8654C 041002BF00
// 5020 AA01 4A 3AF4DAA8654C 0D1004BF00E901
// 7122 AA01 15 3AF4DAA8654C 0D 0200020D10

// LYWSD03 encrypted data:
// 5858 5B05 2F B3E30838C1A4 [69A9FBDF67] ,060000 0791C39A - 23bytes
// 23-9 = 14
// -> nonce B3E30838C1A4|5B02|2F|060000
// 23-6 = 17
// -> tag 0791C39A
// datalen = 23 - 9 - 4 - 3 - 1 - 1 = 5

// CGD1 reconstructed from src: (svcdata on fdcd)
// xxyy FFEEDDCCBBAA MMMM TTTTHHHH|BB
// xxyy FFEEDDCCBBAA 0104 TTTTHHHH
// xxyy FFEEDDCCBBAA 0201 BB


int MIParsePacket(const uint8_t* slotmac, struct mi_beacon_data_t *parsed, const uint8_t *datain, int len){
  uint8_t data[32];
  memcpy(data, datain, len);
  if (!parsed){
    return 0;
  }
  if (len < 5){
    return 0;
  }

  int byteindex = 0;

  // 58 58 = 0x5858 = data|comp|mac|enc, v5|auth2
  // 30 58 = 0x5830 = comp|mac, v5|auth2
  // 30 50 = 0x5030 = comp|mac, v5|auth0
  // 48 59 = 0x5948 = data|enc, v5|auth2|registered
  // 10 59 = 0x5910 = mac, v5|auth2|registered
  // 71 22 = 0x2271 = data|comp|mac v2|bind
  // 50 20 = 0x2050 = data|mac v2 - MJ_HT_V1 data
  // 71 22 = 0x2271 = data|comp|mac|reserved1 v2|bind - MJ_HT_V1 pair

  // data from byte 0 - e.g. 30
  parsed->framedata.meshflag  = (data[byteindex] & 0x80)>>7; //Byte 0: x.......
  parsed->framedata.dataflag  = (data[byteindex] & 0x40)>>6; //Byte 0: .x......
  parsed->framedata.compatibilityflag   = (data[byteindex] & 0x20)>>5; //Byte 0: ..x..... - indicates compatibility data present
  parsed->framedata.MACFlag             = (data[byteindex] & 0x10)>>4; //Byte 0: ...x....
  parsed->framedata.isencrypted         = (data[byteindex] & 0x08)>>3; //Byte 0: ....x...
  parsed->framedata.reserved            = (data[byteindex] & 0x03)>>6; //Byte 0: .....xxx

  // data from byte 1 - e.g. 58
  byteindex++;
  parsed->framedata.version             = (data[byteindex] & 0xf0)>>4; //Byte 0: xxxx....
  parsed->framedata.authMode            = (data[byteindex] & 0x0C)>>6; //Byte 0: ....xx.. // e.g. 2
  parsed->framedata.bindingvalidreq     = (data[byteindex] & 0x02)>>1; //Byte 0: ......x.
  parsed->framedata.registeredflag      = (data[byteindex] & 0x01);    //Byte 0: .......x

  byteindex++;

  parsed->devicetype = *((uint16_t *)(data + byteindex));
  byteindex += 2;
  parsed->framecnt = data[byteindex];
  //if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG, PSTR("M32: MI frame %d"), parsed->framecnt);
  byteindex++;


  if (parsed->framedata.version <= 3){
    // e.g. MJ_HT_V1
  }

  if (parsed->framedata.MACFlag){
    if (len < byteindex + 6){
      return 0;
    }
    memcpy(parsed->macdata.mac, &data[byteindex], 6);
    byteindex += 6;
  }

  int decres = 1;
  // everything after MAC is encrypted if specified?
  if (parsed->framedata.isencrypted){
    if (len < byteindex + 3+4+1){
      return 0;
    }
    const uint8_t* mac = slotmac;
    if (parsed->framedata.MACFlag){
      mac = parsed->macdata.mac;
    }
    uint8_t nonce[12];
    uint8_t *p = nonce;
    memcpy(p, mac, 6);
    p += 6;
    memcpy(p, &parsed->devicetype, 2);
    p += 2;
    *(p++) = parsed->framecnt;
    uint8_t *extCnt = data +(len-7);
    memcpy(p, extCnt, 3);
    p += 3;
    uint32_t tag = *(uint32_t *)(data + (len-4));

    // decrypt the data in place
    decres = MIDecryptPayload(mac, nonce, tag, data + byteindex, len - byteindex - 7);
    // no longer need the nonce data.
    len -= 7;
  }

  switch(decres){
    case 1: // decrypt not requested
      break;
    case 0: // suceeded
      parsed->needkey = KEY_REQUIRED_AND_FOUND;
      if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Payload decrypted"));
      break;
    case -1: // key failed to work
      parsed->needkey = KEY_REQUIRED_AND_INVALID;
      AddLog(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(LOG_LEVEL_ERROR,PSTR("M32: Payload encrypted but no key"));
      parsed->payloadpresent = 0;
      return 0;
      break;
  }

  // if set, there could be 1 or 3 bytes here.
  if (parsed->framedata.compatibilityflag) {
    if (len < byteindex + 1){
      return 0;
    }
    // e.g. in pair: 7122 AA01 15 3AF4DAA8654C [0D] 0200020D10 -> bond|unused2
    parsed->compatibility.reserved      = (data[byteindex] & 0xc0) >> 6;             //Byte 0: xx......
    parsed->compatibility.IOcap         = (data[byteindex] & 0x20) >> 5;             //Byte 0: ..x.....
    parsed->compatibility.bondability   = (data[byteindex] & 0x18) >> 3;             //Byte 0: ...xx...
    parsed->compatibility.unused        = (data[byteindex] & 0x07) >> 0;             //Byte 0: .....xxx
    byteindex ++;

    if (parsed->compatibility.IOcap) {
      if (len < byteindex + 2){
        return 0;
      }
      parsed->compatibility.IOCapability = *((uint16_t *)(data + byteindex));           // bytes 1-2, e.g. 01 00 -> 0001
      byteindex += 2;
    }
  }

  // rest is payload
  int rem = (len - byteindex);
  if (rem > sizeof(parsed->payload)){
    rem = sizeof(parsed->payload);
    return 0;
  }

  if ((len - byteindex) == 0){
    if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG,PSTR("M32: No payload"));
    parsed->payload.size = 0;
    parsed->payloadpresent = 0;
    return 0;
  }

  // we have payload which did not need decrypt.
  if (decres == 1){
    parsed->needkey = KEY_NOT_REQUIRED;
    if (BLE_ESP32::BLEDebugMode > 0) AddLog(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(LOG_LEVEL_DEBUG,PSTR("M32: Payload length mismatch"));
  }

  return 1;
}




#ifdef USE_HOME_ASSISTANT
/**
 * @brief For HASS only, changes last entry of JSON in mqtt_data to 'null'
 */

void MI32nullifyEndOfMQTT_DATA(){
  char *p = TasmotaGlobal.mqtt_data + strlen(TasmotaGlobal.mqtt_data);
  while(true){
    *p--;
    if(p[0]==':'){
      p[1] = 0;
      break;
    }
  }
  ResponseAppend_P(PSTR("null"));
}
#endif // USE_HOME_ASSISTANT

/*********************************************************************************************\
 * common functions
\*********************************************************************************************/


/**
 * @brief Return the slot number of a known sensor or return create new sensor slot
 *
 * @param _MAC     BLE address of the sensor
 * @param _type       Type number of the sensor
 * @return uint32_t   Known or new slot in the sensors-vector
 */
uint32_t MIBLEgetSensorSlot(const uint8_t *mac, uint16_t _type, uint8_t counter){

  //AddLog(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]){
      _type = i+1;
      _success = true;
      break;
    }
    else {
      //AddLog(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: ID-type is not: %x"),D_CMND_MI32,kMI32DeviceID[i]);
    }
  }
  if(!_success) {
    _type = 1; // unknown
  }

  //AddLog(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(LOG_LEVEL_DEBUG,PSTR("M32: Counters: %x %x"),MIBLEsensors[i].lastCnt, counter);
      if(MIBLEsensors[i].lastCnt==counter) {
        // AddLog(LOG_LEVEL_DEBUG,PSTR("Old packet"));
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(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(LOG_LEVEL_DEBUG,PSTR("M32: Frame %d, last %d"), counter, MIBLEsensors[i].lastCnt);
      MIBLEsensors[i].lastCnt = counter;
      if (BLE_ESP32::BLEDebugMode > 0) AddLog(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(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(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(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(LOG_LEVEL_DEBUG_MORE,PSTR("M32: %s: new sensor -> slot: %u"),D_CMND_MI32, MIBLEsensors.size());
  //AddLog(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);
  _newSensor.type = _type;
  _newSensor.eventType.raw = 0;
  _newSensor.feature.raw = 0;
  _newSensor.temp = NAN;
  _newSensor.needkey = KEY_REQUIREMENT_UNKNOWN;
  _newSensor.bat = 0x00;
  _newSensor.RSSI = 0xffff;
  _newSensor.lux = 0x00ffffff;

  switch (_type)
    {
    case MI_FLORA:
      _newSensor.moisture =0xff;
      _newSensor.fertility =0xffff;
      _newSensor.firmware[0]='\0';
      _newSensor.feature.temp=1;
      _newSensor.feature.moist=1;
      _newSensor.feature.fert=1;
      _newSensor.feature.lux=1;
      _newSensor.feature.bat=1;
      break;
    case MI_NLIGHT:
      _newSensor.events=0x00;
      _newSensor.feature.PIR=1;
      _newSensor.feature.NMT=1;
      _newSensor.feature.events=1;
      break;
    case MI_MJYD2S:
      _newSensor.NMT=0;
      _newSensor.events=0x00;
      _newSensor.feature.PIR=1;
      _newSensor.feature.NMT=1;
      _newSensor.feature.lux=1;
      _newSensor.feature.bat=1;
      _newSensor.feature.events=1;
      break;
    case MI_YEERC:
    case MI_DOOR:
      _newSensor.feature.Btn=1;
      break;
    default:
      _newSensor.hum=NAN;
      _newSensor.feature.temp=1;
      _newSensor.feature.hum=1;
      _newSensor.feature.tempHum=1;
      _newSensor.feature.bat=1;
      break;
    }
  MIBLEsensors.push_back(_newSensor);
  AddLog(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;
};

/**
 * @brief trigger real-time message for PIR or RC
 *
 */
void MI32triggerTele(void){
  MI32.mode.triggeredTele = 1;
  MI32ShowTriggeredSensors();
  MI32.mode.triggeredTele = 0;
}

/**
 * @brief Is called after every finding of new BLE sensor
 *
 */
void MI32StatusInfo() {
  MI32.mode.shallShowStatusInfo = 0;
  Response_P(PSTR("{\"%s\":{\"found\":%u}}"), D_CMND_MI32, MIBLEsensors.size());
  XdrvRulesProcess();
}

/*********************************************************************************************\
 * BLE callbacks section
 * These are called from main thread only.
\*********************************************************************************************/


int MI32scanCompleteCallback(NimBLEScanResults results){
  // we actually don't need to do anything here....
  if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Scan complete"));
  return 0;
}


/*********************************************************************************************\
 * init BLE_32
\*********************************************************************************************/


void MI32Init(void) {
  MIBLEsensors.reserve(10);
  MIBLEbindKeys.reserve(10);
  MI32.mode.init = false;

  //test section for options
  MI32.option.allwaysAggregate = 1;
  MI32.option.noSummary = 0;
  MI32.option.minimalSummary = 0;
  MI32.option.directBridgeMode = 0;
  MI32.option.showRSSI = 1;
  MI32.option.ignoreBogusBattery = 1; // from advertisements
  MI32.option.holdBackFirstAutodiscovery = 1;

  BLE_ESP32::registerForAdvertismentCallbacks((const char *)"MI32", MI32advertismentCallback);
  BLE_ESP32::registerForScanCallbacks((const char *)"MI32", MI32scanCompleteCallback);
  // note: for operations, we will set individual callbacks in the operations we request
  //void registerForOpCallbacks(const char *tag, BLE_ESP32::OPCOMPLETE_CALLBACK* pFn);

  AddLog(LOG_LEVEL_INFO,PSTR("M32: init: request callbacks"));
  MI32.period = Settings.tele_period;
  MI32.mode.init = 1;
  return;
}


/*********************************************************************************************\
 * Task section
\*********************************************************************************************/




int MIParseBatt(int slot, uint8_t *data, int len){
  int value = data[0];
  char slotMAC[13];
  BLE_ESP32::dump(slotMAC, sizeof(slotMAC), MIBLEsensors[slot].MAC, 6) ;

  if ((value != 0) && (value < 101)){
    MIBLEsensors[slot].bat = value;
    if(MIBLEsensors[slot].type==MI_FLORA){
      if (len < 7){
        AddLog(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(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(LOG_LEVEL_DEBUG,PSTR("M32: Batt read for %s complete %d"), slotMAC, value);
  } else {
    AddLog(LOG_LEVEL_ERROR,PSTR("M32: Batt read for %s complete but out of range 1-101 (%d)"), slotMAC, value);
  }

  return 0;
}

/*********************************************************************************************\
 * parse the response from advertisements
\*********************************************************************************************/


void MI32ParseATCPacket(const uint8_t * _buf, uint32_t length, const uint8_t *addr, int RSSI){
  ATCPacket_t *_packet = (ATCPacket_t*)_buf;
  PVVXPacket_t *ppv_packet = (PVVXPacket_t*)_buf;


  if (length == 15){ // 19-1-1-2
    uint8_t addrrev[6];
    memcpy(addrrev, addr, 6);
    MI32_ReverseMAC(addrrev);
    if (!memcmp(addrrev, ppv_packet->MAC, 6)){
      //int16_t		temperature; // x 0.1 degree
      //uint16_t	humidity; // x 0.01 %
      //uint16_t	battery_mv; // mV
      //uint8_t		battery_level; // 0..100 %
      //uint8_t		counter; // measurement count
      //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(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;

        MIBLEsensors[_slot].temp = (float)(ppv_packet->temperature)/100.0f;
        MIBLEsensors[_slot].hum = (float)(ppv_packet->humidity)/100.0f;
        MIBLEsensors[_slot].eventType.tempHum  = 1;
        MIBLEsensors[_slot].bat = ppv_packet->battery_level;
        MIBLEsensors[_slot].eventType.bat  = 1;

        if(MI32.option.directBridgeMode) {
          MIBLEsensors[_slot].shallSendMQTT = 1;
          MI32.mode.shallTriggerTele = 1;
        }
      }
      return;
    } else {
      AddLog(LOG_LEVEL_ERROR, PSTR("M32: PVVX packet mac mismatch - ignored?"));
      return;
    }
  }


  uint8_t addrrev[6];
  memcpy(addrrev, addr, 6);
  //MI32_ReverseMAC(addrrev);

  // if packet tell a different address to origin, use the different address
  if (memcmp(addrrev, _packet->MAC, 6)){
    MI32_ReverseMAC(_packet->MAC);
    if (!memcmp(addrrev, _packet->MAC, 6)){
      AddLog(LOG_LEVEL_ERROR, PSTR("M32: ATC packet with reversed MAC addr?"));
    } else {
      AddLog(LOG_LEVEL_ERROR, PSTR("M32: ATC packet with MAC addr mismatch - is this mesh?"));
      memcpy(addrrev, _packet->MAC, 6);
    }
    addr = addrrev;
  }

  uint32_t _slot = MIBLEgetSensorSlot(addr, 0x0a1c, _packet->frameCnt); // This must be a hard-coded fake ID

  if(_slot==0xff) return;

  if ((_slot >= 0) && (_slot < MIBLEsensors.size())){
    if (BLE_ESP32::BLEDebugMode > 0) AddLog(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;

    MIBLEsensors[_slot].temp = (float)(int16_t(__builtin_bswap16(_packet->temp)))/10.0f;
    MIBLEsensors[_slot].hum = (float)_packet->hum;
    MIBLEsensors[_slot].eventType.tempHum  = 1;
    MIBLEsensors[_slot].bat = _packet->batPer;
    MIBLEsensors[_slot].eventType.bat  = 1;

    if(MI32.option.directBridgeMode) {
      MIBLEsensors[_slot].shallSendMQTT = 1;
      MI32.mode.shallTriggerTele = 1;
    }
  } else {

  }
}

////////////////////////////////////////////////////////////
// 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 *) &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(LOG_LEVEL_DEBUG_MORE,PSTR("M32: MI%d payload %s"), _slot, tmp);
  
  // clear this for every payload
  MIBLEsensors[_slot].pairing = 0;
  MIBLEsensors[_slot].eventType.PairBtn = 0;

  switch(parsed->payload.type){
    case 0x01: // button press
      MIBLEsensors[_slot].Btn = pld->Btn.num + (pld->Btn.longPress/2)*6;
      MIBLEsensors[_slot].feature.Btn = 1;
      MIBLEsensors[_slot].eventType.Btn = 1;
      MI32.mode.shallTriggerTele = 1;
      MIBLEsensors[_slot].shallSendMQTT = 1;
      break;
    case 0x02: // related to pair button?
      MIBLEsensors[_slot].pairing = 1;
      MIBLEsensors[_slot].eventType.PairBtn = 1;
      MIBLEsensors[_slot].feature.pairing = 1;
      MI32.mode.shallTriggerTele = 1;
      MIBLEsensors[_slot].shallSendMQTT = 1;
      break;
    case 0x03: {// motion? 1 byte
      uint8_t motion = parsed->payload.data[0];
      res = 0;
    }break;
    case 0x04:{
      float _tempFloat=(float)(pld->temp)/10.0f;
      if(_tempFloat<60){
        MIBLEsensors[_slot].temp=_tempFloat;
        MIBLEsensors[_slot].feature.temp = 1;
        MIBLEsensors[_slot].eventType.temp = 1;
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 4: temp updated"));
      } else {
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 4: temp ignored > 60 (%f)"), _tempFloat);
      }
      // AddLog(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].feature.hum = 1;
        MIBLEsensors[_slot].eventType.hum = 1;
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 6: hum updated"));
      } else {
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 6: hum ignored > 101 (%f)"), _tempFloat);
      }
      // AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Mode 6: U16:  %u Hum"), _beacon.hum);
    } break;
    case 0x07:
      MIBLEsensors[_slot].lux=pld->lux & 0x00ffffff;
      if(MIBLEsensors[_slot].type==MI_MJYD2S){
        MIBLEsensors[_slot].eventType.noMotion  = 1;
      }
      MIBLEsensors[_slot].eventType.lux  = 1;
      MIBLEsensors[_slot].feature.lux = 1;
      // AddLog(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;
      MIBLEsensors[_slot].feature.moist = 1;
      if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 8: moisture updated"));
      // AddLog(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;
      MIBLEsensors[_slot].feature.fert = 1;
      if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode 9: fertility updated"));
      // AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Mode 9: U16: %u Fertility"), _beacon.fert);
    break;
    case 0x0a:
      if(MI32.option.ignoreBogusBattery){
        if(MIBLEsensors[_slot].type==MI_LYWSD03MMC || MIBLEsensors[_slot].type==MI_MHOC401){
          res = 0;
          break;
        }
      }
      MIBLEsensors[_slot].feature.bat = 1;
      if(pld->bat<101){
        MIBLEsensors[_slot].bat = pld->bat;
        MIBLEsensors[_slot].eventType.bat  = 1;
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(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(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode a: bat > 100 (%d)"), pld->bat);
      }
      // AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Mode a: U8: %u %%"), _beacon.bat);
    break;
    case 0x0d:{
      MIBLEsensors[_slot].feature.tempHum = 1;
      float _tempFloat=(float)(pld->HT.temp)/10.0f;
      if(_tempFloat < 60){
        MIBLEsensors[_slot].temp = _tempFloat;
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode d: temp updated"));
      } else {
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(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(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode d: hum updated"));
      } else {
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG_MORE,PSTR("M32: Mode d: hum ignored > 100 (%f)"), _tempFloat);
      }
      MIBLEsensors[_slot].eventType.tempHum  = 1;
      // AddLog(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;
      MIBLEsensors[_slot].eventType.motion = 1;
      MIBLEsensors[_slot].lastTime = millis();
      MIBLEsensors[_slot].events++;
      MIBLEsensors[_slot].lux = pld->lux;
      MIBLEsensors[_slot].eventType.lux = 1;
      MIBLEsensors[_slot].NMT = 0;
      MI32.mode.shallTriggerTele = 1;
      MIBLEsensors[_slot].shallSendMQTT = 1;
      MIBLEsensors[_slot].feature.lux = 1;
      MIBLEsensors[_slot].feature.NMT = 1;
      MIBLEsensors[_slot].feature.events=1;

      // AddLog(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);
      float formaldehyde = (float)f / 100.0f;
      res = 0;
    } break;
    case 0x12:{ // 'active'
      int active = parsed->payload.data[0];
      res = 0;
    } break;
    case 0x13:{ //mosquito tablet
      int tablet = parsed->payload.data[0];
      res = 0;
    } break;
    case 0x17:{
      const uint32_t idle_time =
          uint32_t(parsed->payload.data[0]) | (uint32_t(parsed->payload.data[1]) << 8) | (uint32_t(parsed->payload.data[2]) << 16) | (uint32_t(parsed->payload.data[2]) << 24);
      float idlemins = (float)idle_time / 60.0f;
      int has_motion = (idle_time) ? 0 : 0;

      MIBLEsensors[_slot].NMT = pld->NMT;
      MIBLEsensors[_slot].eventType.NMT = 1;
      MI32.mode.shallTriggerTele = 1;
      MIBLEsensors[_slot].shallSendMQTT = 1;
      MIBLEsensors[_slot].feature.NMT = 1;

      // AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Mode 17: NMT: %u seconds"), _beacon.NMT);
    } break;

    case 0x19:{
      MIBLEsensors[_slot].Btn = uint8_t(parsed->payload.data[0]); // just an 8 bit value in a union.
      MIBLEsensors[_slot].eventType.Btn = 1;
      MI32.mode.shallTriggerTele = 1;
      MIBLEsensors[_slot].shallSendMQTT = 1;
      MIBLEsensors[_slot].feature.Btn = 1;
    } break;

    default: {
      AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Unknown MI pld"));
      res = 0;
    } break;
  }

  if(res && MI32.option.directBridgeMode) {
    MIBLEsensors[_slot].shallSendMQTT = 1;
    MI32.mode.shallTriggerTele = 1;
  }

  return res;
}

////////////////////////////////////////////////////////////
// this SHOULD parse any MI packet, including encrypted.
void MI32ParseResponse(const uint8_t *buf, uint16_t bufsize, const uint8_t* addr, int RSSI) {
  struct mi_beacon_data_t parsed;
  memset(&parsed, 0, sizeof(parsed));
  int res = MIParsePacket(addr, &parsed, buf, bufsize);

  uint8_t addrrev[6];
  memcpy(addrrev, addr, 6);
  MI32_ReverseMAC(addrrev);

  if (memcmp(addrrev, parsed.macdata.mac, 6)){
    AddLog(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;
  }

  uint16_t _slot = MIBLEgetSensorSlot( addr, parsed.devicetype, parsed.framecnt );
  if(_slot==0xff) return;
  if ((_slot >= 0) && (_slot < MIBLEsensors.size())){
    if (parsed.needkey != KEY_REQUIREMENT_UNKNOWN){
      MIBLEsensors[_slot].needkey = parsed.needkey;
    }
    MIBLEsensors[_slot].RSSI=RSSI;
    if (!res){ // - if the payload is not valid
      if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG, PSTR("M32: MIParsePacket returned %d"), res);
      return;
    } else {
    }
    MI32parseMiPayload(_slot, &parsed);
  }
}

bool MI32isInBlockList(const uint8_t* MAC){
  bool isBlocked = false;
  for(auto &_blockedMAC : MIBLEBlockList){
    if(memcmp(_blockedMAC.buf,MAC,6) == 0) isBlocked = true;
  }
  return isBlocked;
}

void MI32removeMIBLEsensor(uint8_t* MAC){
  // this will take and keep the mutex until the function is over
  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); }
  ), end( MIBLEsensors ) );
}
/***********************************************************************\
 * Read data from connections
\***********************************************************************/

void MI32notifyHT_LY(int slot, char *_buf, int len){
  if (BLE_ESP32::BLEDebugMode > 0) AddLog(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(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(LOG_LEVEL_DEBUG_MORE,PSTR("M32: MIBLE: Sensor slot: %u"), _slot);
    static float _tempFloat;
    _tempFloat=(float)(LYWSD0x_HT.temp)/100.0f;
    if(_tempFloat<60){
        MIBLEsensors[_slot].temp=_tempFloat;
        // MIBLEsensors[_slot].showedUp=255; // this sensor is real
    }
    _tempFloat=(float)LYWSD0x_HT.hum;
    if(_tempFloat<100){
      MIBLEsensors[_slot].hum = _tempFloat;
      if (BLE_ESP32::BLEDebugMode > 0) AddLog(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){
      // ok, so CR2032 is 3.0v, but drops immediately to ~2.9.
      // so we'll go with the 2.1 min, 2.95 max.
      float minVolts = 2100.0;
      //float maxVolts = 2950.0;
      //float range = maxVolts - minVolts;
      //float divisor = range/100; // = 8.5
      float percent = (((float)LYWSD0x_HT.volt) - minVolts)/ 8.5; //divisor;
      if (percent > 100) percent = 100;

      MIBLEsensors[_slot].bat = (int) percent;
      MIBLEsensors[_slot].eventType.bat  = 1;
    }
    if(MI32.option.directBridgeMode) {
      MIBLEsensors[_slot].shallSendMQTT = 1;
      MI32.mode.shallTriggerTele = 1;
    }
  }
}


/**
 * @brief Launch functions from Core 1 to make race conditions less likely
 *
 */

void MI32Every50mSecond(){

  if(MI32.mode.shallTriggerTele){
      MI32.mode.shallTriggerTele = 0;
      MI32triggerTele();
  }
}

/**
 * @brief Main loop of the driver, "high level"-loop
 *
 */

void MI32EverySecond(bool restart){

//  AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("M32: onesec"));
  MI32TimeoutSensors();

  if (MI32.option.MQTTType == 0){
    // show tas style sensor MQTT
    MI32ShowSomeSensors();
  }
  
  if (MI32.option.MQTTType == 1 
#ifdef USE_HOME_ASSISTANT
    ||
    Settings.flag.hass_discovery
#endif
  ) { 
    // these two share a counter
    // discovery only sent if hass_discovery
    MI32DiscoveryOneMISensor();
    // show independent style sensor MQTT
    // note - if !MQTTType, then this is IN ADDITION to 'normal'
    MI32ShowOneMISensor();
  }

  // read a battery if
  // MI32.batteryreader.slot < filled and !MI32.batteryreader.active
  readOneBat();


  // read a sensor if
  // MI32.sensorreader.slot < filled and !MI32.sensorreader.active
  // for sensors which need to get data through notify...
  readOneSensor();

  if (MI32.secondsCounter >= MI32.period){
    // only if we finished the last read
    if (MI32.sensorreader.slot >= MIBLEsensors.size()){
      AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Kick off readOneSensor"));
      // kick off notification sensor reading every period.
      MI32.sensorreader.slot = 0;
      MI32.secondsCounter = 0;
    }
  }
  MI32.secondsCounter ++;

  if (MI32.secondsCounter2 >= MI32.period){
    if (MI32.mqttCurrentSlot >= MIBLEsensors.size()){
      AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Kick off tele sending"));
      MI32.mqttCurrentSlot = 0;
      MI32.secondsCounter2 = 0;
      MI32.mqttCurrentSingleSlot = 0;
    } else {
      AddLog(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;
      MI32.mqttCurrentSingleSlot = 0;
    }
  }
  MI32.secondsCounter2++;

  static uint32_t _counter = MI32.period - 15;
  static uint32_t _nextSensorSlot = 0;
  uint32_t _idx = 0;

  int numsensors = MIBLEsensors.size();
  for (uint32_t i = 0; i < numsensors; i++) {
    if(MIBLEsensors[i].type==MI_NLIGHT || MIBLEsensors[i].type==MI_MJYD2S){
      MIBLEsensors[i].NMT++;
    }
  }

  if(MI32.mode.shallShowStatusInfo == 1){
    MI32StatusInfo();
  }
}

/*********************************************************************************************\
 * Commands
\*********************************************************************************************/

void CmndMi32Period(void) {
  if (XdrvMailbox.data_len > 0) {
    if (1 == XdrvMailbox.payload) {
      MI32EverySecond(true);
    } else {
      MI32.period = XdrvMailbox.payload;
    }
  }
  ResponseCmndNumber(MI32.period);
}

int findSlot(char *addrOrAlias){
  uint8_t mac[6];
  int res = BLE_ESP32::getAddr(mac, addrOrAlias);
  if (!res) return -1;

  for (int i = MIBLEsensors.size()-1; i >= 0 ; i--) {
    if (!memcmp(MIBLEsensors[i].MAC, mac, 6)){
      return i;
    }
  }
  return -1;
}


void CmndMi32Time(void) {
  if (XdrvMailbox.data_len > 0) {
    int slot = findSlot(XdrvMailbox.data);
    if (slot < 0) {
      slot = XdrvMailbox.payload;
    }
    if (MIBLEsensors.size() > slot) {
      int res = genericTimeWriteFn(slot);
      if (res > 0){
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG, PSTR("M32: will set Time"));
        ResponseCmndNumber(slot);
        return;
      }
      if (res < 0) {
        AddLog(LOG_LEVEL_ERROR, PSTR("M32: cannot set Time on sensor type"));
      }
      if (res == 0) {
        AddLog(LOG_LEVEL_ERROR, PSTR("M32: cannot set Time right now"));
      }
    }
  }
  ResponseCmndChar_P("fail");
}

void CmndMi32Page(void) {
  if (XdrvMailbox.payload > 0) {
    MI32.perPage = XdrvMailbox.payload;
  }
  ResponseCmndNumber(MI32.perPage);
}

// read ALL battery values where we can?
void CmndMi32Battery(void) {
  // trigger a read cycle
  MI32.batteryreader.slot = 0;
  ResponseCmndDone();
}


void CmndMi32Unit(void) {
  if (XdrvMailbox.data_len > 0) {
    int slot = findSlot(XdrvMailbox.data);
    if (slot < 0) {
      slot = XdrvMailbox.payload;
    }

    if (MIBLEsensors.size() > slot) {
      // TOGGLE unit?
      int res = genericUnitWriteFn(slot, -1);
      if (res > 0){
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG, PSTR("M32: will toggle Unit"));
        ResponseCmndNumber(slot);
        return;
      }
      if (res < 0) {
        AddLog(LOG_LEVEL_ERROR, PSTR("M32: cannot toggle Unit on sensor type"));
      }
      if (res == 0) {
        AddLog(LOG_LEVEL_ERROR, PSTR("M32: cannot toggle Unit right now"));
      }
    }
  }
  ResponseCmndIdxChar(PSTR("Invalid"));
}

#ifdef USE_MI_DECRYPTION
void CmndMi32Key(void) {
  if (44 == XdrvMailbox.data_len) {  // a KEY-MAC-string
    MI32AddKey(XdrvMailbox.data, nullptr);
    MI32KeyListResp();
  } else {
    ResponseCmndIdxChar(PSTR("Invalid"));
  }
}
#endif  // USE_MI_DECRYPTION

void MI32BlockListResp(){
  Response_P(PSTR("{\"MI32Block\":{"));
  for (int i = 0; i < MIBLEBlockList.size(); i++){
    if (i){
      ResponseAppend_P(PSTR(","));
    }
    char tmp[20];
    ToHex_P(MIBLEBlockList[i].buf,6,tmp,20,0);
    ResponseAppend_P(PSTR("\"%s\":1"), tmp);
  }
  ResponseAppend_P(PSTR("}}"));
}


void CmndMi32Block(void){
  if (XdrvMailbox.data_len == 0) {
    switch (XdrvMailbox.index) {
      case 0: {
        //TasAutoMutex localmutex(&slotmutex, "Mi32Block1");
        MIBLEBlockList.clear();
      } break;
      default:
      case 1:
        break;
    }
    MI32BlockListResp();
    return;
  }

  MAC_t _MACasBytes;
  int res = BLE_ESP32::getAddr(_MACasBytes.buf, XdrvMailbox.data);
  if (!res){
    ResponseCmndIdxChar(PSTR("Addr invalid"));
    return;
  }

  //MI32HexStringToBytes(XdrvMailbox.data,_MACasBytes.buf);
  switch (XdrvMailbox.index) {
    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); }
        ), end( MIBLEBlockList ) );
    } break;
    case 1: {
      //TasAutoMutex localmutex(&slotmutex, "Mi32Block3");
      bool _notYetInList = true;
      for (auto &_entry : MIBLEBlockList) {
        if (memcmp(_entry.buf,_MACasBytes.buf,6) == 0){
          _notYetInList = false;
        }
      }
      if (_notYetInList) {
        MIBLEBlockList.push_back(_MACasBytes);
        MI32removeMIBLEsensor(_MACasBytes.buf);
      }
      // AddLog(LOG_LEVEL_INFO,PSTR("M32: size of ilist: %u"), MIBLEBlockList.size());
    } break;
  }
  MI32BlockListResp();
}

void CmndMi32Option(void){
  bool onOff = atoi(XdrvMailbox.data);
  switch(XdrvMailbox.index) {
    case 0:
      MI32.option.allwaysAggregate = onOff;  
      ResponseCmndIdxNumber(onOff);
      return;
      break;
    case 1:
      MI32.option.noSummary = onOff;
      ResponseCmndIdxNumber(onOff);
      return;
      break;
    case 2:
      MI32.option.directBridgeMode = onOff;
      ResponseCmndIdxNumber(onOff);
      return;
      break;
    case 4:{
      MI32.option.ignoreBogusBattery = onOff;
      ResponseCmndIdxNumber(onOff);
      return;
    } break;
    case 5:{
      MI32.option.onlyAliased = onOff;
      if (MI32.option.onlyAliased){
        // discard all sensors for a restart
        MIBLEsensors.clear();
      }
      ResponseCmndIdxNumber(onOff);
      return;
    } break;
    case 6:{
      MI32.option.MQTTType = onOff;
      ResponseCmndIdxNumber(onOff);
      return;
    } break;
    
  }
  ResponseCmndIdxError();
}

void MI32KeyListResp(){
  Response_P(PSTR("{\"MIKeys\":{"));
  for (int i = 0; i < MIBLEbindKeys.size(); i++){
    if (i){
      ResponseAppend_P(PSTR(","));
    }
    char tmp[20];
    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("}}"));
}


void CmndMi32Keys(void){
#ifdef BLE_ESP32_ALIASES
  int op = XdrvMailbox.index;
  if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Key %d %s"), op, XdrvMailbox.data);

  int res = -1;
  switch(op){
    case 0:
    case 1:{
      char *p = strtok(XdrvMailbox.data, " ,=");
      bool trigger = false;
      int added = 0;

      do {
        if (!p || !(*p)){
          break;
        }

        uint8_t addr[6];
        char *mac = p;
        int addrres = BLE_ESP32::getAddr(addr, p);
        if (!addrres){
          ResponseCmndChar("invalidmac");
          return;
        }

        p = strtok(nullptr, " ,=");
        char *key = p;
        if (!p || !(*p)){
          int i = 0;
          for (i = 0; i < MIBLEbindKeys.size(); i++){
            mi_bindKey_t *key = &MIBLEbindKeys[i];
            if (!memcmp(key->MAC, addr, 6)){
              MIBLEbindKeys.erase(MIBLEbindKeys.begin() + i);
              MI32KeyListResp();
              return;
            }
          }
          ResponseCmndChar("invalidmac");
          return;
        }

        AddLog(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);
        if (MI32AddKey(tmp, key)){
          added++;
        }
        p = strtok(nullptr, " ,=");
      } while (p);

      if (added){
        if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Added %d Keys"), added);
        MI32KeyListResp();
      } else {
        MI32KeyListResp();
      }
      return;
    } break;
    case 2:{ // clear
      if (BLE_ESP32::BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG,PSTR("M32: Keys clearing %d"), MIBLEbindKeys.size());
      for (int i = MIBLEbindKeys.size()-1; i >= 0; i--){
        MIBLEbindKeys.pop_back();
      }
      MI32KeyListResp();
      return;
    } break;
  }
  ResponseCmndChar("invalididx");
#endif
}


/*********************************************************************************************\
 * Presentation
\*********************************************************************************************/

const char HTTP_MI32[] PROGMEM = "{s}MI ESP32 v0921{m}%u%s / %u{e}";
const char HTTP_MI32_ALIAS[] PROGMEM = "{s}%s Alias {m}%s{e}";
const char HTTP_MI32_MAC[] PROGMEM = "{s}%s %s{m}%s{e}";
const char HTTP_RSSI[] PROGMEM = "{s}%s " D_RSSI "{m}%d dBm{e}";
const char HTTP_BATTERY[] PROGMEM = "{s}%s" " Battery" "{m}%u %%{e}";
const char HTTP_LASTBUTTON[] PROGMEM = "{s}%s Last Button{m}%u {e}";
const char HTTP_EVENTS[] PROGMEM = "{s}%s Events{m}%u {e}";
const char HTTP_NMT[] PROGMEM = "{s}%s No motion{m}> %u seconds{e}";
const char HTTP_MI32_FLORA_DATA[] PROGMEM = "{s}%s" " Fertility" "{m}%u us/cm{e}";
const char HTTP_MI32_HL[] PROGMEM = "{s}<hr>{m}<hr>{e}";

//const char HTTP_NEEDKEY[] PROGMEM = "{s}%s <a target=\"_blank\" href=\""
//  "https://atc1441.github.io/TelinkFlasher.html?mac=%s&cb=http%%3A%%2F%%2F%s%%2Fmikey"
//  "\">%s</a>{m} {e}";

//const char HTTP_NEEDKEY[] PROGMEM = "{s}%s <a target=\"_blank\" href=\""
//  "http://127.0.0.1:8887/keys/TelinkFlasher.html?mac=%s&cb=http%%3A%%2F%%2F%s%%2Fmikey"
//  "\">%s</a>{m} {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}";


const char HTTP_KEY_ERROR[] PROGMEM = "Key error %s";
const char HTTP_MAC_ERROR[] PROGMEM = "MAC error %s";
const char HTTP_KEY_ADDED[] PROGMEM = "Cmnd: MI32Keys %s=%s";
const char HTTP_MI_KEY_STYLE[] PROGMEM = "";


#define D_MI32_KEY "MI32 Set Key"

void HandleMI32Key(){
  AddLog(LOG_LEVEL_DEBUG, PSTR("M32: HandleMI32Key hit"));
  if (!HttpCheckPriviledgedAccess()) {
    AddLog(LOG_LEVEL_DEBUG, PSTR("M32: !HttpCheckPriviledgedAccess()"));
    return;
  }
  WSContentStart_P(PSTR(D_MI32_KEY));
  WSContentSendStyle_P(HTTP_MI_KEY_STYLE);

  char key[64] = {0};
  WebGetArg("key", key, sizeof(key));

  if (strlen(key) != 16*2){
    WSContentSend_P(HTTP_KEY_ERROR, key);
    WSContentStop();
    return;
  }

  char mac[13] = {0};
  WebGetArg("mac", mac, sizeof(mac));
  if (strlen(mac) != 12){
    WSContentSend_P(HTTP_MAC_ERROR, mac);
    WSContentStop();
    return;
  }

  WSContentSend_P(HTTP_KEY_ADDED, mac, key);

  strncat(key, mac, sizeof(key));
  MI32AddKey(key, nullptr);

//  WSContentSpaceButton(BUTTON_CONFIGURATION);
  WSContentStop();
}


void MI32TimeoutSensors(){
  // whatever, this function access all the arrays....
  // so block for as long as it takes.

  // PROBLEM: when we take this, it hangs the BLE loop.
  // 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(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);
      }
    //}
  }
}


// this assumes that we're adding to a ResponseTime_P
void MI32GetOneSensorJson(int slot, int hidename){
  mi_sensor_t *p;
  p = &MIBLEsensors[slot];

  // remove hyphen - make it difficult to configure HASS
  if (!hidename) {
    ResponseAppend_P(PSTR("\"%s%02x%02x%02x\":{"),
          kMI32DeviceType[p->type-1],
          p->MAC[3], p->MAC[4], p->MAC[5]);
  }

  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){
      if(p->eventType.tempHum || !MI32.mode.triggeredTele || MI32.option.allwaysAggregate){
        if (!isnan(p->hum) && !isnan(p->temp)
#ifdef USE_HOME_ASSISTANT
          ||(hass_mode!=-1)
#endif //USE_HOME_ASSISTANT
        ) {
          ResponseAppend_P(PSTR(","));
          ResponseAppendTHD(p->temp, p->hum);
          tempHumSended = true;
        }
      }
    }
    if(p->feature.temp && !tempHumSended){
      if(p->eventType.temp || !MI32.mode.triggeredTele || MI32.option.allwaysAggregate) {
        if (!isnan(p->temp)
#ifdef USE_HOME_ASSISTANT
          ||(hass_mode!=-1)
#endif //USE_HOME_ASSISTANT
        ) {
          ResponseAppend_P(PSTR(",\"" D_JSON_TEMPERATURE "\":%*_f"),
            Settings.flag2.temperature_resolution, &p->temp);
        }
      }
    }
    if(p->feature.hum && !tempHumSended){
      if(p->eventType.hum || !MI32.mode.triggeredTele || MI32.option.allwaysAggregate) {
        if (!isnan(p->hum)
#ifdef USE_HOME_ASSISTANT
          ||(hass_mode!=-1)
#endif //USE_HOME_ASSISTANT
        ) {
          char hum[FLOATSZ];
          dtostrfd(p->hum, Settings.flag2.humidity_resolution, hum);
          ResponseAppend_P(PSTR(",\"" D_JSON_HUMIDITY "\":%s"), hum);
        }
      }
    }
    if (p->feature.lux){
      if(p->eventType.lux || !MI32.mode.triggeredTele || MI32.option.allwaysAggregate){
        if (p->lux!=0x0ffffff
#ifdef USE_HOME_ASSISTANT
          ||(hass_mode!=-1)
#endif //USE_HOME_ASSISTANT
        ) { // this is the error code -> no lux
          ResponseAppend_P(PSTR(",\"" D_JSON_ILLUMINANCE "\":%u"), p->lux);
#ifdef USE_HOME_ASSISTANT
          if (p->lux==0x0ffffff) MI32nullifyEndOfMQTT_DATA();
#endif //USE_HOME_ASSISTANT
        }
      }
    }
    if (p->feature.moist){
      if(p->eventType.moist || !MI32.mode.triggeredTele || MI32.option.allwaysAggregate){
        if (p->moisture!=0xff
#ifdef USE_HOME_ASSISTANT
          ||(hass_mode!=-1)
#endif //USE_HOME_ASSISTANT
        ) {
          ResponseAppend_P(PSTR(",\"" D_JSON_MOISTURE "\":%u"), p->moisture);
#ifdef USE_HOME_ASSISTANT
          if (p->moisture==0xff) MI32nullifyEndOfMQTT_DATA();
#endif //USE_HOME_ASSISTANT
        }
      }
    }
    if (p->feature.fert){
      if(p->eventType.fert || !MI32.mode.triggeredTele || MI32.option.allwaysAggregate){
        if (p->fertility!=0xffff
#ifdef USE_HOME_ASSISTANT
          ||(hass_mode!=-1)
#endif //USE_HOME_ASSISTANT
        ) {
          ResponseAppend_P(PSTR(",\"Fertility\":%u"), p->fertility);
#ifdef USE_HOME_ASSISTANT
          if (p->fertility==0xffff) MI32nullifyEndOfMQTT_DATA();
#endif //USE_HOME_ASSISTANT
        }
      }
    }
    if (p->feature.Btn){
      if(p->eventType.Btn
#ifdef USE_HOME_ASSISTANT
          ||(hass_mode==2)
#endif //USE_HOME_ASSISTANT
      ){
        ResponseAppend_P(PSTR(",\"Btn\":%u"),p->Btn);
      }
    }
    if(p->eventType.PairBtn && p->pairing){
        ResponseAppend_P(PSTR(",\"Pair\":%u"),p->pairing);
    }
  } // minimal summary


  if (p->feature.PIR){
    if(p->eventType.motion || !MI32.mode.triggeredTele){
      if(MI32.mode.triggeredTele) ResponseAppend_P(PSTR(",\"PIR\":1")); // only real-time
      ResponseAppend_P(PSTR(",\"Events\":%u"),p->events);
    }
    else if(p->eventType.noMotion && MI32.mode.triggeredTele){
      ResponseAppend_P(PSTR(",\"PIR\":0"));
    }
  }

  if (p->type == MI_FLORA && !MI32.mode.triggeredTele) {
    if (p->firmware[0] != '\0') { // this is the error code -> no firmware
      ResponseAppend_P(PSTR(",\"Firmware\":\"%s\""), p->firmware);
    }
  }

  if (p->feature.NMT || !MI32.mode.triggeredTele){
    if(p->eventType.NMT){
      ResponseAppend_P(PSTR(",\"NMT\":%u"), p->NMT);
    }
  }
  if (p->feature.bat){
    if(p->eventType.bat || !MI32.mode.triggeredTele || MI32.option.allwaysAggregate){
      if (p->bat != 0x00
#ifdef USE_HOME_ASSISTANT
          ||(hass_mode!=-1)
#endif //USE_HOME_ASSISTANT
      ) { // this is the error code -> no battery
      ResponseAppend_P(PSTR(",\"Battery\":%u"), p->bat);
#ifdef USE_HOME_ASSISTANT
          if (p->bat == 0x00) MI32nullifyEndOfMQTT_DATA();
#endif //USE_HOME_ASSISTANT
      }
    }
  }
  if (MI32.option.showRSSI) ResponseAppend_P(PSTR(",\"RSSI\":%d"), p->RSSI);

  if (!hidename) {
    ResponseAppend_P(PSTR("}"));
  }
  p->eventType.raw = 0;
  p->shallSendMQTT = 0;

}


///////////////////////////////////////////////
// starts a completely fresh MQTT message.
// sends up to 4 sensors
// triggered by setting MI32.mqttCurrentSlot = 0
void MI32ShowSomeSensors(){
  // don't detect half-added ones here
  int numsensors = MIBLEsensors.size();
  if (MI32.mqttCurrentSlot >= numsensors){
    // if we got to the end of the sensors, then don't send more
    return;
  }

#ifdef USE_HOME_ASSISTANT
  bool _noSummarySave = MI32.option.noSummary;
  bool _minimalSummarySave = MI32.option.minimalSummary;
  if(hass_mode==2){
    if(MI32.option.holdBackFirstAutodiscovery){
      if(!MI32.mode.firstAutodiscoveryDone){
        MI32.mode.firstAutodiscoveryDone = 1;
        return;
      }
    }
    MI32.option.noSummary = false;
    MI32.option.minimalSummary = false;
  }
#endif //USE_HOME_ASSISTANT

  ResponseTime_P(PSTR(""));
  int cnt = 0;
  int maxcnt = 4;
  mi_sensor_t *p;
  for (; (MI32.mqttCurrentSlot < numsensors) && (cnt < maxcnt); MI32.mqttCurrentSlot++, cnt++) {
    ResponseAppend_P(PSTR(","));
    p = &MIBLEsensors[MI32.mqttCurrentSlot];

    MI32GetOneSensorJson(MI32.mqttCurrentSlot, (maxcnt == 1));
    int mlen = strlen(TasmotaGlobal.mqtt_data);

    // if we ran out of room, leave here.
    if (sizeof(TasmotaGlobal.mqtt_data) - mlen < 100){
      MI32.mqttCurrentSlot++;
      break;
    }
    cnt++;
  }
  ResponseAppend_P(PSTR("}"));
  MqttPublishPrefixTopic_P(TELE, PSTR(D_RSLT_SENSOR), Settings.flag.mqtt_sensor_retain);
  //AddLog(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
#endif  // USE_RULES

#ifdef USE_HOME_ASSISTANT
  if(hass_mode==2){
    MI32.option.noSummary = _noSummarySave;
    MI32.option.minimalSummary = _minimalSummarySave;
  }
#endif //USE_HOME_ASSISTANT
}


///////////////////////////////////////////////
// starts a completely fresh MQTT message.
// sends ONE sensor on a dedicated topic NOT related to this TAS
// triggered by setting MI32.mqttCurrentSingleSlot = 0
void MI32ShowOneMISensor(){
  // don't detect half-added ones here
  int numsensors = MIBLEsensors.size();
  if (MI32.mqttCurrentSingleSlot >= numsensors){
    // if we got to the end of the sensors, then don't send more
    return;
  }

  if(
#ifdef USE_HOME_ASSISTANT
    Settings.flag.hass_discovery
    ||
#endif //USE_HOME_ASSISTANT
    MI32.option.MQTTType == 1
    ){

    ResponseTime_P(PSTR(","));
    MI32GetOneSensorJson(MI32.mqttCurrentSingleSlot, 1);
    mi_sensor_t *p;
    p = &MIBLEsensors[MI32.mqttCurrentSingleSlot];

    ResponseAppend_P(PSTR("}"));

    char idstr[32];
    const char *alias = BLE_ESP32::getAlias(p->MAC);
    const char *id = idstr;
    if (alias && *alias){
      id = alias;
    } else {
      sprintf(idstr, PSTR("%s%02x%02x%02x"),
            kMI32DeviceType[p->type-1],
            p->MAC[3], p->MAC[4], p->MAC[5]);
    }
    char SensorTopic[60];
    sprintf(SensorTopic, "tele/tasmota_ble/%s",
      id);

    MqttPublish(SensorTopic);
    //AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: %s: show some %d %s"),D_CMND_MI32, MI32.mqttCurrentSlot, TasmotaGlobal.mqtt_data);
  }
  MI32.mqttCurrentSingleSlot++;
}


///////////////////////////////////////////////
// starts a completely fresh MQTT message.
// sends ONE sensor's worth of HA discovery msg
const char MI_HA_DISCOVERY_TEMPLATE[] PROGMEM =
  "{\"availability\":[],\"device\":"
  "{\"identifiers\":[\"BLE%s\"],"
  "\"name\":\"%s\","
  "\"manufacturer\":\"tas\","
  "\"model\":\"%s\","
  "\"via_device\":\"%s\""
  "},"
  "\"dev_cla\":\"%s\","
  "\"expire_after\":600,"
  "\"json_attr_t\":\"%s\","
  "\"name\":\"%s_%s\","
  "\"state_topic\":\"%s\","
  "\"uniq_id\":\"%s_%s\","
  "\"unit_of_meas\":\"%s\","
  "\"val_tpl\":\"{{ value_json.%s }}\"}";

void MI32DiscoveryOneMISensor(){
  // don't detect half-added ones here
  int numsensors = MIBLEsensors.size();
  if (MI32.mqttCurrentSingleSlot >= numsensors){
    // if we got to the end of the sensors, then don't send more
    return;
  }

#ifdef USE_HOME_ASSISTANT
  if(Settings.flag.hass_discovery){
    mi_sensor_t *p;
    p = &MIBLEsensors[MI32.mqttCurrentSingleSlot];


    // careful - a missing comma causes a crash!!!!
    // because of the way we loop?
    const char *classes[] = {
      "temperature",
      "Temperature",
      "°C",
      "humidity",
      "Humidity",
      "%",
      "temperature",
      "DewPoint",
      "°C",
      "battery",
      "Battery",
      "%",
      "signal_strength",
      "RSSI",
      "dB"
    };

    int datacount = (sizeof(classes)/sizeof(*classes))/3;

    if (p->nextDiscoveryData >= datacount){
      p->nextDiscoveryData = 0;
    }

    char DiscoveryTopic[80];
    const char *host = NetworkHostname();
    const char *devtype = kMI32DeviceType[p->type-1];
    char idstr[32];
    const char *alias = BLE_ESP32::getAlias(p->MAC);
    const char *id = idstr;
    if (alias && *alias){
      id = alias;
    } else {
      sprintf(idstr, PSTR("%s%02x%02x%02x"),
            devtype,
            p->MAC[3], p->MAC[4], p->MAC[5]);
    }

    char SensorTopic[60];
    sprintf(SensorTopic, "tele/tasmota_ble/%s",
      id);


    //int i = p->nextDiscoveryData*3;
    for (int i = 0; i < datacount*3; i += 3){
      if (!classes[i] || !classes[i+1] || !classes[i+2]){
        return;
      }

      ResponseClear();

    /*
    {"availability":[],"device":{"identifiers":["TasmotaBLEa4c1387fc1e1"],"manufacturer":"simon","model":"someBLEsensor","name":"TASBLEa4c1387fc1e1","sw_version":"0.0.0"},"dev_cla":"temperature","json_attr_t":"tele/tasmota_esp32/SENSOR","name":"TASLYWSD037fc1e1Temp","state_topic":"tele/tasmota_esp32/SENSOR","uniq_id":"Tasmotaa4c1387fc1e1temp","unit_of_meas":"°C","val_tpl":"{{ value_json.LYWSD037fc1e1.Temperature }}"}
    {"availability":[],"device":{"identifiers":["TasmotaBLEa4c1387fc1e1"],
    "name":"TASBLEa4c1387fc1e1"},"dev_cla":"temperature",
    "json_attr_t":"tele/tasmota_esp32/SENSOR",
    "name":"TASLYWSD037fc1e1Temp","state_topic":  "tele/tasmota_esp32/SENSOR",
    "uniq_id":"Tasmotaa4c1387fc1e1temp","unit_of_meas":"°C",
    "val_tpl":"{{ value_json.LYWSD037fc1e1.Temperature }}"}
    */

      ResponseAppend_P(MI_HA_DISCOVERY_TEMPLATE,
      //"{\"identifiers\":[\"BLE%s\"],"
        id,
      //"\"name\":\"%s\"},"
        id,
      //\"model\":\"%s\",
        devtype,
      //\"via_device\":\"%s\"
        host,
      //"\"dev_cla\":\"%s\","
        classes[i],
      //"\"json_attr_t\":\"%s\"," - the topic the sensor publishes on
        SensorTopic,
      //"\"name\":\"%s_%s\"," - the name of this DATA
        id, classes[i+1],
      //"\"state_topic\":\"%s\","  - the topic the sensor publishes on?
        SensorTopic,
      //"\"uniq_id\":\"%s_%s\"," - unique for this data,
        id, classes[i+1],
      //"\"unit_of_meas\":\"%s\"," - the measure of this type of data
        classes[i+2],
      //"\"val_tpl\":\"{{ value_json.%s }}") // e.g. Temperature
        classes[i+1]
          //
      );

      sprintf(DiscoveryTopic, "homeassistant/sensor/%s/%s/config",
        id, classes[i+1]);

      MqttPublish(DiscoveryTopic);
      p->nextDiscoveryData++;
      //vTaskDelay(100/ portTICK_PERIOD_MS);
    }
  } // end if hass discovery
  //AddLog_P(LOG_LEVEL_DEBUG,PSTR("M32: %s: show some %d %s"),D_CMND_MI32, MI32.mqttCurrentSlot, TasmotaGlobal.mqtt_data);
#endif //USE_HOME_ASSISTANT

}

///////////////////////////////////////////////
// starts a completely fresh MQTT message.
// sends up to 4 sensors pe5r msg
// sends only those which are raw and triggered.
// triggered by setting MI32.mode.triggeredTele = 1
void MI32ShowTriggeredSensors(){
  if (!MI32.mode.triggeredTele) return; // none to show
  MI32.mode.triggeredTele = 0;

  // don't detect half-added ones here
  int numsensors = MIBLEsensors.size();

  int sensor = 0;

  int maxcnt = 4;
  if(
#ifdef USE_HOME_ASSISTANT
    Settings.flag.hass_discovery
    ||
#endif //USE_HOME_ASSISTANT
    MI32.option.MQTTType == 1
    ){
    maxcnt = 1;
  }


  do {
    ResponseTime_P(PSTR(""));
    int cnt = 0;
    mi_sensor_t *p;
    for (; (sensor < numsensors) && (cnt < maxcnt); sensor++) {
      p = &MIBLEsensors[sensor];
      if(p->eventType.raw == 0) continue;
      if(p->shallSendMQTT==0) continue;

      cnt++;
      ResponseAppend_P(PSTR(","));
      // hide sensor name if HASS or option6
      MI32GetOneSensorJson(sensor, (maxcnt == 1));
      int mlen = strlen(TasmotaGlobal.mqtt_data);

      // if we ran out of room, leave here.
      if (sizeof(TasmotaGlobal.mqtt_data) - mlen < 100){
        sensor++;
        break;
      }
    }
    if (cnt){ // if we got one, then publish
      ResponseAppend_P(PSTR("}"));
      if(
    #ifdef USE_HOME_ASSISTANT
        Settings.flag.hass_discovery
        ||
    #endif //USE_HOME_ASSISTANT
        MI32.option.MQTTType == 1
        ){
        char SensorTopic[60];
        char idstr[32];
        const char *alias = BLE_ESP32::getAlias(p->MAC);
        const char *id = idstr;
        if (alias && *alias){
          id = alias;
        } else {
          sprintf(idstr, PSTR("%s%02x%02x%02x"),
                kMI32DeviceType[p->type-1],
                p->MAC[3], p->MAC[4], p->MAC[5]);
        }
        sprintf(SensorTopic, "tele/tasmota_ble/%s",
          id);
        MqttPublish(SensorTopic);
      } else {
        MqttPublishPrefixTopic_P(STAT, PSTR(D_RSLT_SENSOR), Settings.flag.mqtt_sensor_retain);
      }
      AddLog(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
#endif  // USE_RULES

    } else { // else don't and clear
      ResponseClear();
    }
  } while (sensor < numsensors);
}


void MI32Show(bool json)
{
  // don't detect half-added ones here
  int numsensors = MIBLEsensors.size();

  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;

#ifdef USE_WEBSERVER
  } else {
    static  uint16_t _page = 0;
    static  uint16_t _counter = 0;
    int32_t i = _page * MI32.perPage;
    uint32_t j = i + MI32.perPage;

    if (j+1 > numsensors){
      j = numsensors;
    }
    char stemp[5] ={0};
    if (numsensors-(_page*MI32.perPage)>1 && MI32.perPage!=1) {
      sprintf_P(stemp,"-%u",j);
    }
    if (numsensors==0) i=-1; // only for the GUI

    WSContentSend_PD(HTTP_MI32, i+1,stemp,numsensors);
    for (i; i<j; i++) {
      WSContentSend_PD(HTTP_MI32_HL);
      mi_sensor_t *p;
      p = &MIBLEsensors[i];

      const char *typeName = kMI32DeviceType[p->type-1];
      const char *alias = BLE_ESP32::getAlias(p->MAC);
      if (alias && *alias){
        WSContentSend_PD(HTTP_MI32_ALIAS, typeName, alias);
      }
      char _MAC[18];
      ToHex_P(p->MAC,6,_MAC,18);//,':');
      WSContentSend_PD(HTTP_MI32_MAC, typeName, D_MAC_ADDRESS, _MAC);
      WSContentSend_PD(HTTP_RSSI, typeName, p->RSSI);


      // for some reason, display flora differently
      switch(p->type){
        case MI_FLORA:{
          if (!isnan(p->temp)) {
            WSContentSend_Temp(typeName, p->temp);
          }
          if (p->moisture!=0xff) {
            WSContentSend_PD(HTTP_SNS_MOISTURE, typeName, p->moisture);
          }
          if (p->fertility!=0xffff) {
            WSContentSend_PD(HTTP_MI32_FLORA_DATA, typeName, p->fertility);
          }
        } break;
        default:{
          if (!isnan(p->hum) && !isnan(p->temp)) {
            WSContentSend_THD(typeName, p->temp, p->hum);
          }
        }
      }

#ifdef USE_MI_DECRYPTION
      bool showkey = false;
      char tmp[40];
      strcpy(tmp, PSTR("KeyRqd"));
      switch(p->needkey) {
        default:{
          snprintf(tmp, 39, PSTR("?%d?"), p->needkey );
          showkey = true;
        } break;
        case KEY_REQUIREMENT_UNKNOWN: {
          strcpy(tmp, PSTR("WAIT"));
          showkey = true;
        } break;
        case KEY_NOT_REQUIRED: {
          strcpy(tmp, PSTR("NOTKEY"));
          //showkey = true;
        } break;
        case KEY_REQUIRED_BUT_NOT_FOUND: {
          strcpy(tmp, PSTR("NoKey"));
          showkey = true;
        } break;
        case KEY_REQUIRED_AND_FOUND: {
          strcpy(tmp, PSTR("KeyOk"));
          showkey = true;
        } break;
        case KEY_REQUIRED_AND_INVALID: {
          strcpy(tmp, PSTR("KeyInv"));
          showkey = true;
        } break;
      }

      // adds the link to get the key.
      // provides mac and callback address to receive the key, if we had a website which did this
      // (future work)
      if (showkey){
        BLE_ESP32::dump(_MAC, 13, p->MAC,6);
        WSContentSend_PD(HTTP_NEEDKEY, typeName, _MAC, Webserver->client().localIP().toString().c_str(), tmp );
      }

#endif //USE_MI_DECRYPTION

      if (p->feature.events){
        WSContentSend_PD(HTTP_EVENTS, typeName, p->events);
      }
      if (p->feature.NMT){
        // no motion time
        if(p->NMT>0) WSContentSend_PD(HTTP_NMT, typeName, p->NMT);
      }

      if (p->feature.lux){
        if (p->lux!=0x00ffffff) { // this is the error code -> no valid value
          WSContentSend_PD(HTTP_SNS_ILLUMINANCE, typeName, p->lux);
        }
      }
      if(p->bat!=0x00){
          WSContentSend_PD(HTTP_BATTERY, typeName, p->bat);
      }
      if (p->feature.Btn){
        WSContentSend_PD(HTTP_LASTBUTTON, typeName, p->Btn);
      }
      if (p->pairing){
        WSContentSend_PD(HTTP_PAIRING, typeName);
      }
    }
    _counter++;
    if(_counter>3) {
      _page++;
      _counter=0;
    }
    if (MIBLEsensors.size()%MI32.perPage==0 && _page==MIBLEsensors.size()/MI32.perPage) { _page = 0; }
    if (_page>MIBLEsensors.size()/MI32.perPage) { _page = 0; }
#endif  // USE_WEBSERVER
  }
}

/*********************************************************************************************\
 * Interface
\*********************************************************************************************/
#define WEB_HANDLE_MI32 "mikey"

bool Xsns62(uint8_t function)
{
//  if (!Settings.flag5.mi32_enable) { return false; }  // SetOption115 - Enable ESP32 MI32 BLE
//  return false;

  bool result = false;

  switch (function) {
    case FUNC_INIT:
      MI32Init();
      break;
    case FUNC_EVERY_50_MSECOND:
      MI32Every50mSecond();
      break;
    case FUNC_EVERY_SECOND:
      MI32EverySecond(false);
      break;
    case FUNC_COMMAND:
      result = DecodeCommand(kMI32_Commands, MI32_Commands);
      break;
    case FUNC_JSON_APPEND:
      // we are not in control of when this is called...
      //MI32Show(1);
      break;
#ifdef USE_WEBSERVER
    case FUNC_WEB_ADD_HANDLER:
      WebServer_on(PSTR("/" WEB_HANDLE_MI32), HandleMI32Key);
      break;
    case FUNC_WEB_SENSOR:
      MI32Show(0);
      break;
#endif  // USE_WEBSERVER
    }
  return result;
}
#endif  // USE_MI_ESP32
#endif  // CONFIG_IDF_TARGET_ESP32
#endif  // ESP32

#endif