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

Merge pull request #10837 from btsimonh/BLE_ESP32iBeacon 

Ble esp32 iBeacon cleanup & update
This commit is contained in:
Theo Arends 2021-02-05 09:58:56 +01:00 committed by GitHub
parent 607654297b 136ede92bd
commit 14a2c912ee
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 229 additions and 595 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
tasmota/xdrv_79_esp32_ble.ino
View File

@ -1078,6 +1078,10 @@ void setDetails(ble_advertisment_t *ad){
maxlen -= len; maxlen -= len;
*(p++) = '\"'; maxlen--; *(p++) = '\"'; maxlen--;
sprintf(p, ",\"RSSI\":%d", ad->RSSI);
len = strlen(p);
p += len;
if (BLEAdvertismentDetailsJsonLost){ if (BLEAdvertismentDetailsJsonLost){
BLEAdvertismentDetailsJsonLost = 0; BLEAdvertismentDetailsJsonLost = 0;
strcpy(p, ",\"lost\":true"); strcpy(p, ",\"lost\":true");
@ -1598,17 +1602,19 @@ int BLETaskStartScan(int time){
if (BLEMode == BLEModeDisabled) return -4; if (BLEMode == BLEModeDisabled) return -4;
// don't scan whilst OTA in progress // don't scan whilst OTA in progress
if (BLEOtaStallBLE) return -5; if (BLEOtaStallBLE) return -5;
if (currentOperations.size()) return -3; //if (currentOperations.size()) return -3;
if (BLERunningScan) { if (BLERunningScan) {
// if we hit 2, wait one more time before starting // if we hit 2, wait one more time before starting
if (BLERunningScan == 2){ if (BLERunningScan == 2){
// wait 100ms // wait 10ms
vTaskDelay(100/ portTICK_PERIOD_MS); vTaskDelay(10/ portTICK_PERIOD_MS);
BLERunningScan = 0; BLERunningScan = 0;
} } else {
return -2; return -2;
} }
}
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG,PSTR("BLE: BLETask: Startscan")); if (BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG,PSTR("BLE: BLETask: Startscan"));
@ -1753,6 +1759,9 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
if (pClient->connect(op->addr, true)) { if (pClient->connect(op->addr, true)) {
// as soon as connected, start another scan if possible
BLE_ESP32::BLETaskStartScan(20);
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
if (BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG,PSTR("BLE: connected %s -> getservice"), ((std::string)op->addr).c_str()); if (BLEDebugMode > 0) AddLog(LOG_LEVEL_DEBUG,PSTR("BLE: connected %s -> getservice"), ((std::string)op->addr).c_str());
#endif #endif
@ -1951,7 +1960,7 @@ static void BLETaskRunCurrentOperation(BLE_ESP32::generic_sensor_t** pCurrentOpe
// failed to connect // failed to connect
#ifdef BLE_ESP32_DEBUG #ifdef BLE_ESP32_DEBUG
AddLog(LOG_LEVEL_DEBUG,PSTR("BLE: failed to connect to device %d"), rc); AddLog(LOG_LEVEL_DEBUG,PSTR("BLE: failed to connect to device"));
#endif #endif
} }
op->state = newstate; op->state = newstate;

735
tasmota/xsns_52_esp32_ibeacon_ble.ino
View File

@ -1,11 +1,8 @@
/* /*
xsns_52_esp32_ibeacon_ble.ino xsns_52_esp32_ibeacon_ble.ino
if (!USE_IBEACON_ESP32 && USE_BLE_ESP32)
- Support for HM17 BLE Module + ibeacon reader on Tasmota (untested?)
if (USE_IBEACON_ESP32 && USE_BLE_ESP32)
- Support for BLE_ESP32 ibeacon reader on Tasmota - Support for BLE_ESP32 ibeacon reader on Tasmota
Copyright (C) 2020 Gerhard Mutz and Theo Arends Copyright (C) 2020 Gerhard Mutz and Theo Arends and Simon Hailes
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
@ -21,14 +18,38 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
////////////////////////////////////////
// Commands:
// iBeacon 0/1 - Enable
// iBeaconOnlyAliased 0/1/2 -
// 0 = all BLE devices,
// 1 = only devices with any BLEAlias
// 2 = only devices which have BLEAlias starting "iB"
// iBeaconClear - clear list NOW
// iBeaconPeriod (sec) - update period - default 10s
// iBeaconTimeout (sec) - timeout period - default 30s
//
// posts MQTT about each beacon every iBeaconPeriod (default 10s)
// MQTT like
// tele/tasmota_E89E98/SENSOR = {"Time":"2021-02-04T23:20:22","IBEACON":{"MAC":"FFFFA0003B19","NAME":"iB1","RSSI":-81,"STATE":"ON","PERSEC":10}}
// Always present:
// Time: time of MQTT send
// IBEACON.MAC
// IBEACON.RSSI
// IBEACON.STATE - ON - present, OFF - last MQTT you will get for now (device removed)
// Optional:
// IBEACON.NAME - name if in scan, or BLEAlias if set - only present if NAME present
// IBEACON.PERSEC - count of adverts per sec. USeful for detecting button press?
// IBEACON.MAJOR - some iBeacon related term? - only present for some
// IBEACON.MINOR - some iBeacon related term? - only present for some
////////////////////////////////////////
// for testing of BLE_ESP32, we remove xsns_52_ibeacon.ino completely, and instead add this modified xsns_52_ibeacon_BLE_ESP32.ino // for testing of BLE_ESP32, we remove xsns_52_ibeacon.ino completely, and instead add this modified xsns_52_ibeacon_BLE_ESP32.ino
// in the future this may be more fine-grained, e.g. to allow hm17 for this, and BLE-ESP32 for other // in the future this may be more fine-grained, e.g. to allow hm17 for this, and BLE-ESP32 for other
#if CONFIG_IDF_TARGET_ESP32
#ifdef USE_BLE_ESP32 #ifdef USE_BLE_ESP32
#ifdef USE_IBEACON_ESP32
#ifdef USE_IBEACON
#define XSNS_52 52 #define XSNS_52 52
// keyfob expires after N seconds // keyfob expires after N seconds
@ -37,65 +58,21 @@
#define IB_UPDATE_TIME_INTERVAL 10 #define IB_UPDATE_TIME_INTERVAL 10
// should be in Settings // should be in Settings
#if 1 //#if 1
uint8_t ib_upd_interval,ib_tout_interval; uint8_t ib_upd_interval,ib_tout_interval;
//#undef IB_UPDATE_TIME
//#undef IB_TIMEOUT_TIME
#define IB_UPDATE_TIME ib_upd_interval #define IB_UPDATE_TIME ib_upd_interval
#define IB_TIMEOUT_TIME ib_tout_interval #define IB_TIMEOUT_TIME ib_tout_interval
#else //#else
#undef IB_UPDATE_TIME //#undef IB_UPDATE_TIME
#undef IB_TIMEOUT_TIME //#undef IB_TIMEOUT_TIME
#define IB_UPDATE_TIME Settings.ib_upd_interval //#define IB_UPDATE_TIME Settings.ib_upd_interval
#define IB_TIMEOUT_TIME Settings.ib_tout_interval //#define IB_TIMEOUT_TIME Settings.ib_tout_interval
#endif //#endif
char ib_mac[14];
struct {
union {
struct {
uint32_t init:1;
};
uint32_t all = 0;
} mode;
} ESP32BLE;
void *beaconmutex = nullptr;
#define ENDIAN_CHANGE_U16(x) ((((x)&0xFF00) >> 8) + (((x)&0xFF) << 8)) #define ENDIAN_CHANGE_U16(x) ((((x)&0xFF00) >> 8) + (((x)&0xFF) << 8))
#else
#include <TasmotaSerial.h>
#define TMSBSIZ52 512
#define HM17_BAUDRATE 9600
#define IBEACON_DEBUG
// use this for Version 110
#define HM17_V110
TasmotaSerial *IBEACON_Serial = nullptr;
uint8_t hm17_found,hm17_cmd,hm17_flag;
#ifdef IBEACON_DEBUG
uint8_t hm17_debug=0;
#endif
// 78 is max serial response
#define HM17_BSIZ 128
char hm17_sbuffer[HM17_BSIZ];
uint8_t hm17_sindex,hm17_result,hm17_scanning,hm17_connecting;
uint32_t hm17_lastms;
enum {HM17_TEST,HM17_ROLE,HM17_IMME,HM17_DISI,HM17_IBEA,HM17_SCAN,HM17_DISC,HM17_RESET,HM17_RENEW,HM17_CON};
#define HM17_SUCESS 99
#endif
struct IBEACON { struct IBEACON {
char FACID[8]; char FACID[8];
char UID[32]; char UID[32];
@ -104,16 +81,10 @@ struct IBEACON {
char PWR[2]; char PWR[2];
char MAC[12]; char MAC[12];
char RSSI[4]; char RSSI[4];
#ifdef USE_IBEACON_ESP32
char NAME[16]; char NAME[16];
#endif
}; };
#ifdef USE_IBEACON_ESP32
#define MAX_IBEACONS 32 #define MAX_IBEACONS 32
#else
#define MAX_IBEACONS 16
#endif
struct IBEACON_UID { struct IBEACON_UID {
char MAC[12]; char MAC[12];
@ -123,14 +94,78 @@ struct IBEACON_UID {
char MINOR[4]; char MINOR[4];
uint8_t FLAGS; uint8_t FLAGS;
uint8_t TIME; uint8_t TIME;
#ifdef USE_IBEACON_ESP32
uint8_t REPORTED; uint8_t REPORTED;
uint8_t REPTIME; uint8_t REPTIME;
uint8_t count; // count of adverts in REPTIME (reptime default = 10s)
uint32_t lastmqtt; // last time we sent something
char NAME[16]; char NAME[16];
#endif
} ibeacons[MAX_IBEACONS]; } ibeacons[MAX_IBEACONS];
#ifdef USE_IBEACON_ESP32
void CmndiBeacon(void);
void CmndiBeaconOnlyAliased(void);
void CmndiBeaconClear(void);
void CmndiBeaconPeriod(void);
void CmndiBeaconTimeout(void);
#define D_CMND_IBEACON "IBEACON"
const char kiBeacon_Commands[] PROGMEM = D_CMND_IBEACON "|"
"|"
"onlyaliased|"
"clear|"
"period|"
"timeout";
void (*const iBeacon_Commands[])(void) PROGMEM = {
&CmndiBeacon,
&CmndiBeaconOnlyAliased,
&CmndiBeaconClear,
&CmndiBeaconPeriod,
&CmndiBeaconTimeout
};
uint8_t iBeaconOnlyAliased = 0;
uint8_t iBeaconEnable = 0;
void CmndiBeacon(void){
if (XdrvMailbox.data_len > 0) {
iBeaconEnable = XdrvMailbox.payload;
}
ResponseCmndNumber(iBeaconEnable);
}
void CmndiBeaconOnlyAliased(void){
if (XdrvMailbox.data_len > 0) {
iBeaconOnlyAliased = XdrvMailbox.payload;
}
ResponseCmndNumber(iBeaconOnlyAliased);
}
void CmndiBeaconClear(void){
uint32_t count = 0;
for (uint32_t cnt=0; cnt<MAX_IBEACONS; cnt++) {
if (ibeacons[cnt].FLAGS) count++;
ibeacons[cnt].FLAGS=0;
}
ResponseCmndNumber(count);
}
void CmndiBeaconPeriod(void){
if (XdrvMailbox.data_len > 0) {
IB_UPDATE_TIME = XdrvMailbox.payload;
}
ResponseCmndNumber(IB_UPDATE_TIME);
}
void CmndiBeaconTimeout(void){
if (XdrvMailbox.data_len > 0) {
IB_TIMEOUT_TIME = XdrvMailbox.payload;
}
ResponseCmndNumber(IB_TIMEOUT_TIME);
}
uint32_t ibeacon_add(struct IBEACON *ib); uint32_t ibeacon_add(struct IBEACON *ib);
@ -156,12 +191,29 @@ void DumpHex(const unsigned char * in, size_t insz, char * out)
int advertismentCallback(BLE_ESP32::ble_advertisment_t *pStruct) int advertismentCallback(BLE_ESP32::ble_advertisment_t *pStruct)
{ {
struct IBEACON ib; struct IBEACON ib;
if (!iBeaconEnable) return 0;
BLEAdvertisedDevice *advertisedDevice = pStruct->advertisedDevice; BLEAdvertisedDevice *advertisedDevice = pStruct->advertisedDevice;
char sRSSI[6]; char sRSSI[6];
itoa(pStruct->RSSI,sRSSI,10); itoa(pStruct->RSSI,sRSSI,10);
const uint8_t *MAC = pStruct->addr; const uint8_t *MAC = pStruct->addr;
const char *alias = BLE_ESP32::getAlias(MAC);
if (iBeaconOnlyAliased){
// ignore unless we have an alias.
if (!alias || !(*alias)){
return 0;
}
}
if (!alias) alias = "";
if (iBeaconOnlyAliased == 2){
if (strncmp(alias, "iB", 2)){
return 0;
}
}
int manufacturerDataLen = 0; int manufacturerDataLen = 0;
std::string data; std::string data;
if (advertisedDevice->haveManufacturerData()){ if (advertisedDevice->haveManufacturerData()){
@ -192,6 +244,9 @@ int advertismentCallback(BLE_ESP32::ble_advertisment_t *pStruct)
DumpHex((const unsigned char*)MAC,6,ib.MAC); DumpHex((const unsigned char*)MAC,6,ib.MAC);
memcpy(ib.RSSI,sRSSI,4); memcpy(ib.RSSI,sRSSI,4);
memset(ib.NAME,0x0,16); memset(ib.NAME,0x0,16);
if (*alias){
strncpy(ib.NAME, alias, 16);
}
// if we added it // if we added it
if (ibeacon_add(&ib) == 1){ if (ibeacon_add(&ib) == 1){
@ -221,51 +276,21 @@ int advertismentCallback(BLE_ESP32::ble_advertisment_t *pStruct)
memset(ib.NAME,0x0,16); memset(ib.NAME,0x0,16);
} }
if (*alias){
strncpy(ib.NAME, alias,16);
}
ibeacon_add(&ib); ibeacon_add(&ib);
return 0; return 0;
} }
void ESP32Init() {
if (!ESP32BLE.mode.init) {
ESP32BLE.mode.init = 1;
IB_UPDATE_TIME=IB_UPDATE_TIME_INTERVAL;
IB_TIMEOUT_TIME=IB_TIMEOUT_INTERVAL;
}
}
#endif
void IBEACON_Init() { void IBEACON_Init() {
AddLog(LOG_LEVEL_INFO, PSTR("iBeacon register for advert callbacks"));
#ifdef USE_IBEACON_ESP32
BLE_ESP32::registerForAdvertismentCallbacks((const char *)"iBeacon", advertismentCallback); BLE_ESP32::registerForAdvertismentCallbacks((const char *)"iBeacon", advertismentCallback);
#else
hm17_found=0;
// actually doesnt work reliably with software serial
if (PinUsed(GPIO_IBEACON_RX) && PinUsed(GPIO_IBEACON_TX)) {
IBEACON_Serial = new TasmotaSerial(Pin(GPIO_IBEACON_RX), Pin(GPIO_IBEACON_TX),1,0,TMSBSIZ52);
if (IBEACON_Serial->begin(HM17_BAUDRATE)) {
if (IBEACON_Serial->hardwareSerial()) {
ClaimSerial();
}
hm17_sendcmd(HM17_TEST);
hm17_lastms=millis();
// in case of using Settings this has to be moved
IB_UPDATE_TIME=IB_UPDATE_TIME_INTERVAL; IB_UPDATE_TIME=IB_UPDATE_TIME_INTERVAL;
IB_TIMEOUT_TIME=IB_TIMEOUT_INTERVAL; IB_TIMEOUT_TIME=IB_TIMEOUT_INTERVAL;
} }
}
#endif
}
#ifdef USE_IBEACON_ESP32
void esp32_every_second(void) { void esp32_every_second(void) {
for (uint32_t cnt=0; cnt < MAX_IBEACONS; cnt++) { for (uint32_t cnt=0; cnt < MAX_IBEACONS; cnt++) {
@ -279,11 +304,16 @@ void esp32_every_second(void) {
uint32_t ageS = BLE_ESP32::devicePresent(mac); uint32_t ageS = BLE_ESP32::devicePresent(mac);
// if device not present at all. // if device not present at all or past local timeout.
if (!ageS){ if (!ageS || (ageS > IB_TIMEOUT_TIME)){
//AddLog(LOG_LEVEL_INFO, PSTR("iBeacon no device %s %02x%02x%02x%02x%02x%02x"),tmp, mac[0],mac[1], mac[2],mac[3], mac[4],mac[5]); //AddLog(LOG_LEVEL_INFO, PSTR("iBeacon no device %s %02x%02x%02x%02x%02x%02x"),tmp, mac[0],mac[1], mac[2],mac[3], mac[4],mac[5]);
ibeacons[cnt].FLAGS=0; ibeacons[cnt].FLAGS=0;
ibeacon_mqtt(ibeacons[cnt].MAC,"0000",ibeacons[cnt].UID,ibeacons[cnt].MAJOR,ibeacons[cnt].MINOR,ibeacons[cnt].NAME); uint64_t now = esp_timer_get_time();
uint32_t nowms = now/1000;
float countspermssec = ((float)ibeacons[cnt].count)/(((float)(nowms - ibeacons[cnt].lastmqtt))/1000.0);
ibeacon_mqtt(ibeacons[cnt].MAC,"0000",ibeacons[cnt].UID,ibeacons[cnt].MAJOR,ibeacons[cnt].MINOR,ibeacons[cnt].NAME, (int)(countspermssec));
ibeacons[cnt].count = 0;
ibeacons[cnt].lastmqtt = nowms;
} else { } else {
//AddLog(LOG_LEVEL_INFO, PSTR("iBeacon device %s %02x%02x%02x%02x%02x%02x"),tmp, mac[0],mac[1], mac[2],mac[3], mac[4],mac[5]); //AddLog(LOG_LEVEL_INFO, PSTR("iBeacon device %s %02x%02x%02x%02x%02x%02x"),tmp, mac[0],mac[1], mac[2],mac[3], mac[4],mac[5]);
} }
@ -293,90 +323,6 @@ void esp32_every_second(void) {
} }
} }
#else
void hm17_every_second(void) {
if (!IBEACON_Serial) return;
if (hm17_found) {
if (IB_UPDATE_TIME && (TasmotaGlobal.uptime%IB_UPDATE_TIME==0)) {
if (hm17_cmd!=99) {
if (hm17_flag&2) {
ib_sendbeep();
} else {
if (!hm17_connecting) {
hm17_sendcmd(HM17_DISI);
}
}
}
}
for (uint32_t cnt=0;cnt<MAX_IBEACONS;cnt++) {
if (ibeacons[cnt].FLAGS) {
ibeacons[cnt].TIME++;
if (ibeacons[cnt].TIME>IB_TIMEOUT_TIME) {
ibeacons[cnt].FLAGS=0;
ibeacon_mqtt(ibeacons[cnt].MAC,"0000",ibeacons[cnt].UID,ibeacons[cnt].MAJOR,ibeacons[cnt].MINOR);
}
}
}
} else {
if (TasmotaGlobal.uptime%20==0) {
hm17_sendcmd(HM17_TEST);
}
}
}
void hm17_sbclr(void) {
memset(hm17_sbuffer,0,HM17_BSIZ);
hm17_sindex=0;
//IBEACON_Serial->flush();
}
void hm17_sendcmd(uint8_t cmd) {
hm17_sbclr();
hm17_cmd=cmd;
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("hm17cmd %d"),cmd);
#endif
switch (cmd) {
case HM17_TEST:
IBEACON_Serial->write("AT");
break;
case HM17_ROLE:
IBEACON_Serial->write("AT+ROLE1");
break;
case HM17_IMME:
IBEACON_Serial->write("AT+IMME1");
break;
case HM17_DISI:
IBEACON_Serial->write("AT+DISI?");
hm17_scanning=1;
break;
case HM17_IBEA:
IBEACON_Serial->write("AT+IBEA1");
break;
case HM17_RESET:
IBEACON_Serial->write("AT+RESET");
break;
case HM17_RENEW:
IBEACON_Serial->write("AT+RENEW");
break;
case HM17_SCAN:
IBEACON_Serial->write("AT+SCAN5");
break;
case HM17_DISC:
IBEACON_Serial->write("AT+DISC?");
hm17_scanning=1;
break;
case HM17_CON:
IBEACON_Serial->write((const uint8_t*)"AT+CON",6);
IBEACON_Serial->write((const uint8_t*)ib_mac,12);
hm17_connecting=1;
break;
}
}
#endif
uint32_t ibeacon_add(struct IBEACON *ib) { uint32_t ibeacon_add(struct IBEACON *ib) {
/* if (!strncmp(ib->MAJOR,"4B1C",4)) { /* if (!strncmp(ib->MAJOR,"4B1C",4)) {
@ -387,9 +333,6 @@ uint32_t ibeacon_add(struct IBEACON *ib) {
return 0; return 0;
} }
// don't bother protecting this.
//TasAutoMutex localmutex(&beaconmutex, "iBeacAdd");
// keyfob starts with ffff, ibeacon has valid facid // keyfob starts with ffff, ibeacon has valid facid
if (!strncmp(ib->MAC,"FFFF",4) || strncmp(ib->FACID,"00000000",8)) { if (!strncmp(ib->MAC,"FFFF",4) || strncmp(ib->FACID,"00000000",8)) {
for (uint32_t cnt=0;cnt<MAX_IBEACONS;cnt++) { for (uint32_t cnt=0;cnt<MAX_IBEACONS;cnt++) {
@ -397,27 +340,27 @@ uint32_t ibeacon_add(struct IBEACON *ib) {
if (!strncmp_P(ib->UID,PSTR("00000000000000000000000000000000"),32)) { if (!strncmp_P(ib->UID,PSTR("00000000000000000000000000000000"),32)) {
if (!strncmp(ibeacons[cnt].MAC,ib->MAC,12)) { if (!strncmp(ibeacons[cnt].MAC,ib->MAC,12)) {
// exists // exists
strncpy(ibeacons[cnt].NAME,ib->NAME,sizeof(ibeacons[cnt].NAME));
memcpy(ibeacons[cnt].RSSI,ib->RSSI,4); memcpy(ibeacons[cnt].RSSI,ib->RSSI,4);
ibeacons[cnt].TIME=0; ibeacons[cnt].TIME=0;
#ifdef USE_IBEACON_ESP32
if (ibeacons[cnt].REPTIME >= IB_UPDATE_TIME) { if (ibeacons[cnt].REPTIME >= IB_UPDATE_TIME) {
ibeacons[cnt].REPTIME = 0; ibeacons[cnt].REPTIME = 0;
ibeacons[cnt].REPORTED = 0; ibeacons[cnt].REPORTED = 0;
} }
#endif ibeacons[cnt].count++;
return 2; return 2;
} }
} else { } else {
if (!strncmp(ibeacons[cnt].UID,ib->UID,32)) { if (!strncmp(ibeacons[cnt].UID,ib->UID,32)) {
// exists // exists
strncpy(ibeacons[cnt].NAME,ib->NAME,sizeof(ibeacons[cnt].NAME));
memcpy(ibeacons[cnt].RSSI,ib->RSSI,4); memcpy(ibeacons[cnt].RSSI,ib->RSSI,4);
ibeacons[cnt].TIME=0; ibeacons[cnt].TIME=0;
#ifdef USE_IBEACON_ESP32
if (ibeacons[cnt].REPTIME >= IB_UPDATE_TIME) { if (ibeacons[cnt].REPTIME >= IB_UPDATE_TIME) {
ibeacons[cnt].REPTIME = 0; ibeacons[cnt].REPTIME = 0;
ibeacons[cnt].REPORTED = 0; ibeacons[cnt].REPORTED = 0;
} }
#endif ibeacons[cnt].count++;
return 2; return 2;
} }
} }
@ -425,6 +368,7 @@ uint32_t ibeacon_add(struct IBEACON *ib) {
} }
for (uint32_t cnt=0;cnt<MAX_IBEACONS;cnt++) { for (uint32_t cnt=0;cnt<MAX_IBEACONS;cnt++) {
if (!ibeacons[cnt].FLAGS) { if (!ibeacons[cnt].FLAGS) {
strncpy(ibeacons[cnt].NAME,ib->NAME,sizeof(ibeacons[cnt].NAME));
memcpy(ibeacons[cnt].MAC,ib->MAC,12); memcpy(ibeacons[cnt].MAC,ib->MAC,12);
memcpy(ibeacons[cnt].RSSI,ib->RSSI,4); memcpy(ibeacons[cnt].RSSI,ib->RSSI,4);
memcpy(ibeacons[cnt].UID,ib->UID,32); memcpy(ibeacons[cnt].UID,ib->UID,32);
@ -432,11 +376,13 @@ uint32_t ibeacon_add(struct IBEACON *ib) {
memcpy(ibeacons[cnt].MINOR,ib->MINOR,4); memcpy(ibeacons[cnt].MINOR,ib->MINOR,4);
ibeacons[cnt].FLAGS=1; ibeacons[cnt].FLAGS=1;
ibeacons[cnt].TIME=0; ibeacons[cnt].TIME=0;
#ifdef USE_IBEACON_ESP32
memcpy(ibeacons[cnt].NAME,ib->NAME,16); memcpy(ibeacons[cnt].NAME,ib->NAME,16);
ibeacons[cnt].REPTIME = 0; ibeacons[cnt].REPTIME = 0;
ibeacons[cnt].REPORTED = 0; ibeacons[cnt].REPORTED = 0;
#endif ibeacons[cnt].count = 0;
uint64_t now = esp_timer_get_time();
uint32_t nowms = now/1000;
ibeacons[cnt].lastmqtt = nowms;
return 1; return 1;
} }
} }
@ -444,245 +390,23 @@ uint32_t ibeacon_add(struct IBEACON *ib) {
return 0; return 0;
} }
#ifndef USE_IBEACON_ESP32
void hm17_decode(void) {
struct IBEACON ib;
switch (hm17_cmd) {
case HM17_TEST:
if (!strncmp(hm17_sbuffer,"OK",2)) {
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("AT OK"));
#endif
hm17_sbclr();
hm17_result=HM17_SUCESS;
hm17_found=1;
}
break;
case HM17_ROLE:
if (!strncmp(hm17_sbuffer,"OK+Set:1",8)) {
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("ROLE OK"));
#endif
hm17_sbclr();
hm17_result=HM17_SUCESS;
}
break;
case HM17_IMME:
if (!strncmp(hm17_sbuffer,"OK+Set:1",8)) {
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("IMME OK"));
#endif
hm17_sbclr();
hm17_result=HM17_SUCESS;
}
break;
case HM17_IBEA:
if (!strncmp(hm17_sbuffer,"OK+Set:1",8)) {
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("IBEA OK"));
#endif
hm17_sbclr();
hm17_result=HM17_SUCESS;
}
break;
case HM17_SCAN:
if (!strncmp(hm17_sbuffer,"OK+Set:5",8)) {
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("SCAN OK"));
#endif
hm17_sbclr();
hm17_result=HM17_SUCESS;
}
break;
case HM17_RESET:
if (!strncmp(hm17_sbuffer,"OK+RESET",8)) {
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("RESET OK"));
#endif
hm17_sbclr();
hm17_result=HM17_SUCESS;
}
break;
case HM17_RENEW:
if (!strncmp(hm17_sbuffer,"OK+RENEW",8)) {
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("RENEW OK"));
#endif
hm17_sbclr();
hm17_result=HM17_SUCESS;
}
break;
case HM17_CON:
if (!strncmp(hm17_sbuffer,"OK+CONNA",8)) {
hm17_sbclr();
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("CONNA OK"));
#endif
hm17_connecting=2;
break;
}
if (!strncmp(hm17_sbuffer,"OK+CONNE",8)) {
hm17_sbclr();
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("CONNE ERROR"));
#endif
break;
}
if (!strncmp(hm17_sbuffer,"OK+CONNF",8)) {
hm17_sbclr();
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("CONNF ERROR"));
#endif
break;
}
if (hm17_connecting==2 && !strncmp(hm17_sbuffer,"OK+CONN",7)) {
hm17_sbclr();
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("CONN OK"));
#endif
hm17_connecting=3;
hm17_sendcmd(HM17_TEST);
hm17_connecting=0;
break;
}
break;
case HM17_DISI:
case HM17_DISC:
if (!strncmp(hm17_sbuffer,"OK+DISCS",8)) {
hm17_sbclr();
hm17_result=1;
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("DISCS OK"));
#endif
break;
}
if (!strncmp(hm17_sbuffer,"OK+DISIS",8)) {
hm17_sbclr();
hm17_result=1;
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("DISIS OK"));
#endif
break;
}
if (!strncmp(hm17_sbuffer,"OK+DISCE",8)) {
hm17_sbclr();
hm17_result=HM17_SUCESS;
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR("DISCE OK"));
#endif
hm17_scanning=0;
break;
}
if (!strncmp(hm17_sbuffer,"OK+NAME:",8)) {
if (hm17_sbuffer[hm17_sindex-1]=='\n') {
hm17_result=HM17_SUCESS;
#ifdef IBEACON_DEBUG
if (hm17_debug) {
AddLog(LOG_LEVEL_INFO, PSTR("NAME OK"));
AddLog(LOG_LEVEL_INFO, PSTR(">>%s"),&hm17_sbuffer[8]);
}
#endif
hm17_sbclr();
}
break;
}
if (!strncmp(hm17_sbuffer,"OK+DIS0:",8)) {
if (hm17_cmd==HM17_DISI) {
#ifdef HM17_V110
goto hm17_v110;
#endif
} else {
if (hm17_sindex==20) {
hm17_result=HM17_SUCESS;
#ifdef IBEACON_DEBUG
if (hm17_debug) {
AddLog(LOG_LEVEL_INFO, PSTR("DIS0 OK"));
AddLog(LOG_LEVEL_INFO, PSTR(">>%s"),&hm17_sbuffer[8]);
}
#endif
hm17_sbclr();
}
}
break;
}
if (!strncmp(hm17_sbuffer,"OK+DISC:",8)) {
hm17_v110:
if (hm17_cmd==HM17_DISI) {
if (hm17_sindex==78) {
#ifdef IBEACON_DEBUG
if (hm17_debug) {
AddLog(LOG_LEVEL_INFO, PSTR("DISC: OK"));
//OK+DISC:4C 000C0E:003 A9144081A8 3B16849611 862EC1005: 0B1CE7485D :4DB4E940F C0E:-078
AddLog(LOG_LEVEL_INFO, PSTR(">>%s"),&hm17_sbuffer[8]);
}
#endif
memcpy(ib.FACID,&hm17_sbuffer[8],8);
memcpy(ib.UID,&hm17_sbuffer[8+8+1],32);
memcpy(ib.MAJOR,&hm17_sbuffer[8+8+1+32+1],4);
memcpy(ib.MINOR,&hm17_sbuffer[8+8+1+32+1+4],4);
memcpy(ib.PWR,&hm17_sbuffer[8+8+1+32+1+4+4],2);
memcpy(ib.MAC,&hm17_sbuffer[8+8+1+32+1+4+4+2+1],12);
memcpy(ib.RSSI,&hm17_sbuffer[8+8+1+32+1+4+4+2+1+12+1],4);
if (ibeacon_add(&ib)) {
ibeacon_mqtt(ib.MAC,ib.RSSI,ib.UID,ib.MAJOR,ib.MINOR);
}
hm17_sbclr();
hm17_result=1;
}
} else {
#ifdef IBEACON_DEBUG
if (hm17_debug) AddLog(LOG_LEVEL_INFO, PSTR(">->%s"),&hm17_sbuffer[8]);
#endif
}
break;
}
}
}
#endif
void IBEACON_loop() { void IBEACON_loop() {
#ifdef USE_IBEACON_ESP32
//TasAutoMutex localmutex(&beaconmutex, "iBeacLoop"); //TasAutoMutex localmutex(&beaconmutex, "iBeacLoop");
for (uint32_t cnt=0; cnt<MAX_IBEACONS; cnt++) { for (uint32_t cnt=0; cnt<MAX_IBEACONS; cnt++) {
if (ibeacons[cnt].FLAGS && ! ibeacons[cnt].REPORTED) { if (ibeacons[cnt].FLAGS && (!ibeacons[cnt].REPORTED || ibeacons[cnt].count > 10)) {
ibeacon_mqtt(ibeacons[cnt].MAC,ibeacons[cnt].RSSI,ibeacons[cnt].UID,ibeacons[cnt].MAJOR,ibeacons[cnt].MINOR,ibeacons[cnt].NAME); uint64_t now = esp_timer_get_time();
uint32_t nowms = now/1000;
float countspermssec = ((float)ibeacons[cnt].count)/(((float)(nowms - ibeacons[cnt].lastmqtt))/1000.0);
// squash if it only just appeared
if (ibeacons[cnt].count < 2) countspermssec = 0.0;
ibeacon_mqtt(ibeacons[cnt].MAC,ibeacons[cnt].RSSI,ibeacons[cnt].UID,ibeacons[cnt].MAJOR,ibeacons[cnt].MINOR,ibeacons[cnt].NAME, (int)(countspermssec));
ibeacons[cnt].count = 0;
ibeacons[cnt].lastmqtt = nowms;
ibeacons[cnt].REPORTED=1; ibeacons[cnt].REPORTED=1;
ibeacons[cnt].REPTIME = 0;
} }
} }
#else
if (!IBEACON_Serial) return;
uint32_t difftime=millis()-hm17_lastms;
while (IBEACON_Serial->available()) {
hm17_lastms=millis();
// shift in
if (hm17_sindex<HM17_BSIZ) {
hm17_sbuffer[hm17_sindex]=IBEACON_Serial->read();
hm17_sindex++;
hm17_decode();
} else {
hm17_sindex=0;
break;
}
}
if (hm17_cmd==99) {
if (hm17_sindex>=HM17_BSIZ-2 || (hm17_sindex && (difftime>100))) {
AddLog(LOG_LEVEL_INFO, PSTR("%s"),hm17_sbuffer);
hm17_sbclr();
}
}
#endif
} }
#ifdef USE_WEBSERVER #ifdef USE_WEBSERVER
@ -691,18 +415,14 @@ const char HTTP_IBEACON_mac[] PROGMEM =
"{s}IBEACON-MAC : %s" " {m} RSSI : %s" "{e}"; "{s}IBEACON-MAC : %s" " {m} RSSI : %s" "{e}";
const char HTTP_IBEACON_uid[] PROGMEM = const char HTTP_IBEACON_uid[] PROGMEM =
"{s}IBEACON-UID : %s" " {m} RSSI : %s" "{e}"; "{s}IBEACON-UID : %s" " {m} RSSI : %s" "{e}";
#ifdef USE_IBEACON_ESP32
const char HTTP_IBEACON_name[] PROGMEM = const char HTTP_IBEACON_name[] PROGMEM =
"{s}IBEACON-NAME : %s (%s)" " {m} RSSI : %s" "{e}"; "{s}IBEACON-NAME : %s (%s)" " {m} RSSI : %s" "{e}";
#endif
void IBEACON_Show(void) { void IBEACON_Show(void) {
char mac[14]; char mac[14];
char rssi[6]; char rssi[6];
char uid[34]; char uid[34];
#ifdef USE_IBEACON_ESP32
char name[18]; char name[18];
//TasAutoMutex localmutex(&beaconmutex, "iBeacShow"); //TasAutoMutex localmutex(&beaconmutex, "iBeacShow");
#endif
int total = 0; int total = 0;
for (uint32_t cnt=0;cnt<MAX_IBEACONS;cnt++) { for (uint32_t cnt=0;cnt<MAX_IBEACONS;cnt++) {
@ -714,20 +434,14 @@ void IBEACON_Show(void) {
rssi[4]=0; rssi[4]=0;
memcpy(uid,ibeacons[cnt].UID,32); memcpy(uid,ibeacons[cnt].UID,32);
uid[32]=0; uid[32]=0;
#ifdef USE_IBEACON_ESP32
memcpy(name,ibeacons[cnt].NAME,16); memcpy(name,ibeacons[cnt].NAME,16);
name[16]=0; name[16]=0;
#endif
if (!strncmp_P(uid,PSTR("00000000000000000000000000000000"),32)) { if (!strncmp_P(uid,PSTR("00000000000000000000000000000000"),32)) {
#ifdef USE_IBEACON_ESP32
if (name[0]) { if (name[0]) {
WSContentSend_PD(HTTP_IBEACON_name,name,mac,rssi); WSContentSend_PD(HTTP_IBEACON_name,name,mac,rssi);
} else { } else {
WSContentSend_PD(HTTP_IBEACON_mac,mac,rssi); WSContentSend_PD(HTTP_IBEACON_mac,mac,rssi);
} }
#else
WSContentSend_PD(HTTP_IBEACON_mac,mac,rssi);
#endif
} else { } else {
WSContentSend_PD(HTTP_IBEACON_uid,uid,rssi); WSContentSend_PD(HTTP_IBEACON_uid,uid,rssi);
} }
@ -751,10 +465,7 @@ tT = sets timeout interval in seconds (after T seconds if tag is not detected se
sending IBEACON_FFFF3D1B1E9D_RSSI with data 99 causes tag to beep (ID to be replaced with actual ID) sending IBEACON_FFFF3D1B1E9D_RSSI with data 99 causes tag to beep (ID to be replaced with actual ID)
*** debugging *** debugging
dx = sets debug mode to 0,1 (shows hm17 cmds + reactions in console)
c = clears sensor list c = clears sensor list
s AT+xxx = send native cmds to module
e.g. s AT+CONFFFF3D1B1E9D connects to module with ID, then send s AT to disconnect which activates the beeper in the TAG
*/ */
@ -770,91 +481,23 @@ bool xsns52_cmd(void) {
cp++; cp++;
if (*cp) IB_UPDATE_TIME=atoi(cp); if (*cp) IB_UPDATE_TIME=atoi(cp);
Response_P(S_JSON_IBEACON, XSNS_52,"uintv",IB_UPDATE_TIME); Response_P(S_JSON_IBEACON, XSNS_52,"uintv",IB_UPDATE_TIME);
} else if (*cp=='t') {
cp++;
if (*cp) IB_TIMEOUT_TIME=atoi(cp);
Response_P(S_JSON_IBEACON, XSNS_52,"lintv",IB_TIMEOUT_TIME);
} else if (*cp=='c') { } else if (*cp=='c') {
for (uint32_t cnt=0;cnt<MAX_IBEACONS;cnt++) ibeacons[cnt].FLAGS=0; for (uint32_t cnt=0;cnt<MAX_IBEACONS;cnt++) ibeacons[cnt].FLAGS=0;
Response_P(S_JSON_IBEACON1, XSNS_52,"clr list",""); Response_P(S_JSON_IBEACON1, XSNS_52,"clr list","");
} }
#ifndef USE_IBEACON_ESP32
else if (*cp>='0' && *cp<='8') {
hm17_sendcmd(*cp&7);
Response_P(S_JSON_IBEACON, XSNS_52,"hm17cmd",*cp&7);
} else if (*cp=='s') {
cp++;
len--;
while (*cp==' ') {
len--;
cp++;
}
IBEACON_Serial->write((uint8_t*)cp,len);
hm17_cmd=99;
Response_P(S_JSON_IBEACON1, XSNS_52,"hm17cmd",cp);
}
#endif
#ifdef IBEACON_DEBUG
else if (*cp=='d') {
cp++;
hm17_debug=atoi(cp);
Response_P(S_JSON_IBEACON, XSNS_52,"debug",hm17_debug);
}
#endif
} else { } else {
serviced=false; serviced=false;
} }
return serviced; return serviced;
} }
#define D_CMND_IBEACON "IBEACON" void ibeacon_mqtt(const char *mac,const char *rssi,const char *uid,const char *major,const char *minor, const char *name, int count) {
#ifndef USE_IBEACON_ESP32
//"IBEACON_FFFF3D1B1E9D_RSSI", Data "99" causes TAG to beep
bool ibeacon_cmd(void) {
ib_mac[0]=0;
int16_t rssi=0;
const char S_JSON_IBEACON[] = "{\"" D_CMND_IBEACON "_%s_RSSI\":%d}";
uint8_t cmd_len = strlen(D_CMND_IBEACON);
if (!strncasecmp_P(XdrvMailbox.topic, PSTR(D_CMND_IBEACON), cmd_len)) {
// IBEACON prefix
rssi = XdrvMailbox.payload;
if (rssi==99) {
memcpy(ib_mac,XdrvMailbox.topic+cmd_len+1,12);
ib_mac[12]=0;
if (hm17_scanning) {
// postpone sendbeep
hm17_flag|=2;
} else {
ib_sendbeep();
}
}
Response_P(S_JSON_IBEACON,ib_mac,rssi);
return true;
}
return false;
}
void ib_sendbeep(void) {
hm17_flag=0;
hm17_sendcmd(HM17_CON);
}
#endif
#ifdef USE_IBEACON_ESP32
void ibeacon_mqtt(const char *mac,const char *rssi,const char *uid,const char *major,const char *minor, const char *name) {
#else
void ibeacon_mqtt(const char *mac,const char *rssi,const char *uid,const char *major,const char *minor) {
#endif
char s_mac[14]; char s_mac[14];
char s_uid[34]; char s_uid[34];
char s_major[6]; char s_major[6];
char s_minor[6]; char s_minor[6];
char s_rssi[6]; char s_rssi[6];
#ifdef USE_IBEACON_ESP32
char *s_state; char *s_state;
#endif
char s_name[18]; char s_name[18];
memcpy(s_mac,mac,12); memcpy(s_mac,mac,12);
s_mac[12]=0; s_mac[12]=0;
@ -867,32 +510,27 @@ void ibeacon_mqtt(const char *mac,const char *rssi,const char *uid,const char *m
memcpy(s_rssi,rssi,4); memcpy(s_rssi,rssi,4);
s_rssi[4]=0; s_rssi[4]=0;
int16_t n_rssi=atoi(s_rssi); int16_t n_rssi=atoi(s_rssi);
#ifdef USE_IBEACON_ESP32
if (n_rssi) { if (n_rssi) {
s_state=(char *)"ON"; s_state=(char *)"ON";
} else { } else {
s_state=(char *)"OFF"; s_state=(char *)"OFF";
} }
#endif
// if uid == all zeros, take mac
if (!strncmp_P(s_uid,PSTR("00000000000000000000000000000000"),32)) {
#ifdef USE_IBEACON_ESP32
if (name[0]) {
memcpy(s_name,name,16); memcpy(s_name,name,16);
s_name[16]=0; s_name[16]=0;
ResponseTime_P(PSTR(",\"" D_CMND_IBEACON "\":{\"MAC\":\"%s\",\"NAME\":\"%s\",\"RSSI\":%d,\"STATE\":\"%s\"}}"),s_mac,s_name,n_rssi,s_state);
// if uid == all zeros, take mac
if (!strncmp_P(s_uid,PSTR("00000000000000000000000000000000"),32)) {
if (name[0]) {
ResponseTime_P(PSTR(",\"" D_CMND_IBEACON "\":{\"MAC\":\"%s\",\"NAME\":\"%s\",\"RSSI\":%d,\"STATE\":\"%s\",\"PERSEC\":%d}}"),s_mac,s_name,n_rssi,s_state, count);
} else { } else {
ResponseTime_P(PSTR(",\"" D_CMND_IBEACON "\":{\"MAC\":\"%s\",\"RSSI\":%d,\"STATE\":\"%s\"}}"),s_mac,n_rssi,s_state); ResponseTime_P(PSTR(",\"" D_CMND_IBEACON "\":{\"MAC\":\"%s\",\"RSSI\":%d,\"STATE\":\"%s\",\"PERSEC\":%d}}"),s_mac,n_rssi,s_state, count);
} }
#else
ResponseTime_P(PSTR(",\"" D_CMND_IBEACON "\":{\"MAC\":\"%s\",\"UID\":\"%s\",\"MAJOR\":\"%s\",\"MINOR\":\"%s\",\"RSSI\":%d}}"),s_mac,s_uid,s_major,s_minor,n_rssi);
#endif
} else { } else {
#ifdef USE_IBEACON_ESP32 if (name[0]) {
ResponseTime_P(PSTR(",\"" D_CMND_IBEACON "\":{\"UID\":\"%s\",\"MAJOR\":\"%s\",\"MINOR\":\"%s\",\"MAC\":\"%s\",\"RSSI\":%d,\"STATE\":\"%s\"}}"),s_uid,s_major,s_minor,s_mac,n_rssi,s_state); ResponseTime_P(PSTR(",\"" D_CMND_IBEACON "\":{\"MAC\":\"%s\",\"NAME\":\"%s\",\"MAJOR\":\"%s\",\"MINOR\":\"%s\",\"MAC\":\"%s\",\"RSSI\":%d,\"STATE\":\"%s\",\"PERSEC\":%d}}"),s_uid,s_name,s_major,s_minor,s_mac,n_rssi,s_state,count);
#else } else {
ResponseTime_P(PSTR(",\"" D_CMND_IBEACON "\":{\"UID\":\"%s\",\"MAJOR\":\"%s\",\"MINOR\":\"%s\",\"MAC\":\"%s\",\"RSSI\":%d}}"),s_uid,s_major,s_minor,s_mac,n_rssi); ResponseTime_P(PSTR(",\"" D_CMND_IBEACON "\":{\"UID\":\"%s\",\"MAJOR\":\"%s\",\"MINOR\":\"%s\",\"MAC\":\"%s\",\"RSSI\":%d,\"STATE\":\"%s\",\"PERSEC\":%d}}"),s_uid,s_major,s_minor,s_mac,n_rssi,s_state,count);
#endif }
} }
MqttPublishTeleSensor(); MqttPublishTeleSensor();
@ -911,46 +549,29 @@ bool Xsns52(byte function)
case FUNC_INIT: case FUNC_INIT:
IBEACON_Init(); IBEACON_Init();
break; break;
#ifdef USE_IBEACON_ESP32
case FUNC_EVERY_250_MSECOND:
if (!ESP32BLE.mode.init) {
ESP32Init();
}
break;
#endif
case FUNC_LOOP: case FUNC_LOOP:
IBEACON_loop(); if (iBeaconEnable) IBEACON_loop();
break; break;
case FUNC_EVERY_SECOND: case FUNC_EVERY_SECOND:
#ifdef USE_IBEACON_ESP32 if (iBeaconEnable) esp32_every_second();
esp32_every_second();
#else
hm17_every_second();
#endif
break; break;
case FUNC_COMMAND:
result = DecodeCommand(kiBeacon_Commands, iBeacon_Commands);
break;
case FUNC_COMMAND_SENSOR: case FUNC_COMMAND_SENSOR:
if (XSNS_52 == XdrvMailbox.index) { if (XSNS_52 == XdrvMailbox.index) {
result = xsns52_cmd(); result = xsns52_cmd();
} }
break; break;
#ifndef USE_IBEACON_ESP32
case FUNC_COMMAND:
result=ibeacon_cmd();
break;
#endif
#ifdef USE_WEBSERVER #ifdef USE_WEBSERVER
case FUNC_WEB_SENSOR: case FUNC_WEB_SENSOR:
#ifndef USE_IBEACON_ESP32 if (iBeaconEnable) IBEACON_Show();
if (hm17_found) IBEACON_Show();
#else
IBEACON_Show();
#endif
break; break;
#endif // USE_WEBSERVER #endif // USE_WEBSERVER
} }
return result; return result;
} }
#endif // USE_IBEACON #endif // USE_BLE_ESP32
#endif // CONFIG_IDF_TARGET_ESP32
#endif

16
tasmota/xsns_52_ibeacon.ino
View File

@ -31,16 +31,18 @@
#define IB_UPDATE_TIME_INTERVAL 10 #define IB_UPDATE_TIME_INTERVAL 10
// should be in Settings // should be in Settings
#if 1 //#if 1
uint8_t ib_upd_interval,ib_tout_interval; uint8_t ib_upd_interval,ib_tout_interval;
//#undef IB_UPDATE_TIME
//#undef IB_TIMEOUT_TIME
#define IB_UPDATE_TIME ib_upd_interval #define IB_UPDATE_TIME ib_upd_interval
#define IB_TIMEOUT_TIME ib_tout_interval #define IB_TIMEOUT_TIME ib_tout_interval
#else //#else
#undef IB_UPDATE_TIME //#undef IB_UPDATE_TIME
#undef IB_TIMEOUT_TIME //#undef IB_TIMEOUT_TIME
#define IB_UPDATE_TIME Settings.ib_upd_interval //#define IB_UPDATE_TIME Settings.ib_upd_interval
#define IB_TIMEOUT_TIME Settings.ib_tout_interval //#define IB_TIMEOUT_TIME Settings.ib_tout_interval
#endif //#endif
char ib_mac[14]; char ib_mac[14];

22
tasmota/xsns_62_esp32_mi_ble.ino
View File

@ -2649,12 +2649,9 @@ void MI32DiscoveryOneMISensor(){
p->nextDiscoveryData = 0; p->nextDiscoveryData = 0;
} }
//int i = p->nextDiscoveryData*3; char DiscoveryTopic[80];
for (int i = 0; i < datacount*3; i += 3){ const char *host = NetworkHostname();
if (!classes[i] || !classes[i+1] || !classes[i+2]){ const char *devtype = kMI32DeviceType[p->type-1];
return;
}
char idstr[32]; char idstr[32];
const char *alias = BLE_ESP32::getAlias(p->MAC); const char *alias = BLE_ESP32::getAlias(p->MAC);
const char *id = idstr; const char *id = idstr;
@ -2662,7 +2659,7 @@ void MI32DiscoveryOneMISensor(){
id = alias; id = alias;
} else { } else {
sprintf(idstr, PSTR("%s%02x%02x%02x"), sprintf(idstr, PSTR("%s%02x%02x%02x"),
kMI32DeviceType[p->type-1], devtype,
p->MAC[3], p->MAC[4], p->MAC[5]); p->MAC[3], p->MAC[4], p->MAC[5]);
} }
@ -2671,6 +2668,12 @@ void MI32DiscoveryOneMISensor(){
id); 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(); ResponseClear();
/* /*
@ -2689,9 +2692,9 @@ void MI32DiscoveryOneMISensor(){
//"\"name\":\"%s\"}," //"\"name\":\"%s\"},"
id, id,
//\"model\":\"%s\", //\"model\":\"%s\",
kMI32DeviceType[p->type-1], devtype,
//\"via_device\":\"%s\" //\"via_device\":\"%s\"
NetworkHostname(), host,
//"\"dev_cla\":\"%s\"," //"\"dev_cla\":\"%s\","
classes[i], classes[i],
//"\"json_attr_t\":\"%s\"," - the topic the sensor publishes on //"\"json_attr_t\":\"%s\"," - the topic the sensor publishes on
@ -2709,7 +2712,6 @@ void MI32DiscoveryOneMISensor(){
// //
); );
char DiscoveryTopic[80];
sprintf(DiscoveryTopic, "homeassistant/sensor/%s/%s/config", sprintf(DiscoveryTopic, "homeassistant/sensor/%s/%s/config",
id, classes[i+1]); id, classes[i+1]);