453 lines
16 KiB
Arduino
453 lines
16 KiB
Arduino
/*
|
|
OpenMQTTGateway - ESP8266 or Arduino program for home automation
|
|
|
|
Act as a wifi or ethernet gateway between your 433mhz/infrared IR signal/BLE and a MQTT broker
|
|
Send and receiving command by MQTT
|
|
|
|
This gateway enables to:
|
|
- publish MQTT data to a different topic related to BLE devices rssi signal
|
|
- publish MQTT data related to mi flora temperature, moisture, fertility and lux
|
|
- publish MQTT data related to mi jia indoor temperature & humidity sensor
|
|
|
|
Copyright: (c)Florian ROBERT
|
|
|
|
This file is part of OpenMQTTGateway.
|
|
|
|
OpenMQTTGateway 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.
|
|
|
|
OpenMQTTGateway 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/>.
|
|
|
|
Thanks to wolass https://github.com/wolass for suggesting me HM 10 and dinosd https://github.com/dinosd/BLE_PROXIMITY for inspiring me how to implement the gateway
|
|
*/
|
|
#ifdef ZgatewayBT
|
|
|
|
#ifdef ESP32
|
|
/*
|
|
Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
|
|
Ported to Arduino ESP32 by Evandro Copercini
|
|
*/
|
|
// core task implementation thanks to https://techtutorialsx.com/2017/05/09/esp32-running-code-on-a-specific-core/
|
|
|
|
#include <BLEDevice.h>
|
|
#include <BLEUtils.h>
|
|
#include <BLEScan.h>
|
|
#include <BLEAdvertisedDevice.h>
|
|
|
|
//Time used to wait for an interval before resending BLE infos
|
|
unsigned long timeBLE= 0;
|
|
|
|
//core on which the BLE detection task will run
|
|
static int taskCore = 0;
|
|
|
|
class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
|
|
void onResult(BLEAdvertisedDevice advertisedDevice) {
|
|
trc(F("Creating BLE buffer"));
|
|
StaticJsonBuffer<JSON_MSG_BUFFER> jsonBuffer;
|
|
JsonObject& BLEdata = jsonBuffer.createObject();
|
|
String mac_adress = advertisedDevice.getAddress().toString().c_str();
|
|
BLEdata.set("id", mac_adress);
|
|
mac_adress.replace(":","");
|
|
mac_adress.toUpperCase();
|
|
String mactopic = subjectBTtoMQTT + mac_adress;
|
|
if (advertisedDevice.haveName()){
|
|
BLEdata.set("name", (char *)advertisedDevice.getName().c_str());
|
|
}
|
|
if (advertisedDevice.haveManufacturerData()){
|
|
BLEdata.set("manufacturerdata", (char *)advertisedDevice.getManufacturerData().c_str());
|
|
}
|
|
if (advertisedDevice.haveRSSI()){
|
|
BLEdata.set("rssi", (int) advertisedDevice.getRSSI());
|
|
#ifdef subjectHomePresence
|
|
haRoomPresence(BLEdata);// this device has an rssi in consequence we can use it for home assistant room presence component
|
|
#endif
|
|
}
|
|
if (advertisedDevice.haveTXPower()){
|
|
BLEdata.set("txpower", (int8_t) advertisedDevice.getTXPower());
|
|
}
|
|
if (advertisedDevice.haveServiceData()){
|
|
|
|
char mac[mac_adress.length()+1];
|
|
mac_adress.toCharArray(mac,mac_adress.length()+1);
|
|
|
|
trc(F("Get service data "));
|
|
std::string serviceData = advertisedDevice.getServiceData();
|
|
int serviceDataLength = serviceData.length();
|
|
String returnedString = "";
|
|
for (int i=0; i<serviceDataLength; i++)
|
|
{
|
|
int a = serviceData[i];
|
|
if (a < 16) {
|
|
returnedString = returnedString + "0";
|
|
}
|
|
returnedString = returnedString + String(a,HEX);
|
|
}
|
|
|
|
char service_data[returnedString.length()+1];
|
|
returnedString.toCharArray(service_data,returnedString.length()+1);
|
|
service_data[returnedString.length()] = '\0';
|
|
BLEdata.set("servicedata", service_data);
|
|
|
|
BLEdata.set("servicedatauuid", (char *)advertisedDevice.getServiceDataUUID().toString().c_str());
|
|
|
|
char topic[] = subjectBTtoMQTT;
|
|
strcat(topic, mac);
|
|
pub(topic,BLEdata);
|
|
|
|
if (strstr(BLEdata["servicedatauuid"].as<char*>(),"fe95") != NULL){
|
|
trc("Processing BLE device data");
|
|
int pos = -1;
|
|
pos = strpos(service_data,"209800");
|
|
if (pos != -1){
|
|
trc("mi flora data reading");
|
|
boolean result = process_data(pos - 24,service_data,mac);
|
|
}
|
|
pos = -1;
|
|
pos = strpos(service_data,"20aa01");
|
|
if (pos != -1){
|
|
trc("mi jia data reading");
|
|
boolean result = process_data(pos - 26,service_data,mac);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
void setupBT(){
|
|
#ifdef multiCore
|
|
// we setup a task with priority one to avoid conflict with other gateways
|
|
xTaskCreatePinnedToCore(
|
|
coreTask, /* Function to implement the task */
|
|
"coreTask", /* Name of the task */
|
|
10000, /* Stack size in words */
|
|
NULL, /* Task input parameter */
|
|
0, /* Priority of the task */
|
|
NULL, /* Task handle. */
|
|
taskCore); /* Core where the task should run */
|
|
trc(F("ZgatewayBT multicore ESP32 setup done "));
|
|
#else
|
|
trc(F("ZgatewayBT singlecore ESP32 setup done "));
|
|
#endif
|
|
}
|
|
|
|
#ifdef multiCore
|
|
void coreTask( void * pvParameters ){
|
|
|
|
String taskMessage = "BT Task running on core ";
|
|
taskMessage = taskMessage + xPortGetCoreID();
|
|
|
|
while(true){
|
|
trc(taskMessage);
|
|
delay(TimeBtw_Read);
|
|
BLEDevice::init("");
|
|
BLEScan* pBLEScan = BLEDevice::getScan(); //create new scan
|
|
MyAdvertisedDeviceCallbacks myCallbacks;
|
|
pBLEScan->setAdvertisedDeviceCallbacks(&myCallbacks);
|
|
pBLEScan->setActiveScan(true); //active scan uses more power, but get results faster
|
|
BLEScanResults foundDevices = pBLEScan->start(Scan_duration);
|
|
}
|
|
}
|
|
#else
|
|
boolean BTtoMQTT(){
|
|
unsigned long now = millis();
|
|
if (now > (timeBLE + TimeBtw_Read)) {
|
|
timeBLE = now;
|
|
BLEDevice::init("");
|
|
BLEScan* pBLEScan = BLEDevice::getScan(); //create new scan
|
|
MyAdvertisedDeviceCallbacks myCallbacks;
|
|
pBLEScan->setAdvertisedDeviceCallbacks(&myCallbacks);
|
|
pBLEScan->setActiveScan(true); //active scan uses more power, but get results faster
|
|
BLEScanResults foundDevices = pBLEScan->start(Scan_duration);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
#else // arduino or ESP8266 working with HM10/11
|
|
|
|
#include <SoftwareSerial.h>
|
|
|
|
#define STRING_MSG "OK+DISC:"
|
|
#define RESPONSE_MSG "OK+DISIS"
|
|
#define RESP_END_MSG "OK+DISCE"
|
|
#define SETUP_MSG "OK+RESET"
|
|
|
|
SoftwareSerial softserial(BT_RX, BT_TX);
|
|
|
|
String returnedString = "";
|
|
unsigned long timebt = 0;
|
|
|
|
// this struct define which parts of the hexadecimal chain we extract and what to do with these parts
|
|
struct decompose d[6] = {{"mac",16,12,true},{"typ",28,2,false},{"rsi",30,2,false},{"rdl",32,2,false},{"sty",44,4,true},{"rda",34,60,false}};
|
|
|
|
void setupBT() {
|
|
softserial.begin(9600);
|
|
softserial.print(F("AT+ROLE1"));
|
|
delay(100);
|
|
softserial.print(F("AT+IMME1"));
|
|
delay(100);
|
|
softserial.print(F("AT+RESET"));
|
|
delay(100);
|
|
trc(F("ZgatewayBT HM1X setup done "));
|
|
}
|
|
|
|
#ifdef ZgatewayBT_v6xx
|
|
#define QUESTION_MSG "AT+DISA?"
|
|
boolean BTtoMQTT() {
|
|
|
|
//extract serial data from module in hexa format
|
|
while (softserial.available() > 0) {
|
|
int a = softserial.read();
|
|
if (a < 16) {
|
|
returnedString = returnedString + "0";
|
|
}
|
|
returnedString = returnedString + String(a,HEX);
|
|
}
|
|
|
|
if (millis() > (timebt + TimeBtw_Read)) {//retriving data
|
|
timebt = millis();
|
|
#if defined(ESP8266)
|
|
yield();
|
|
#endif
|
|
if (returnedString != "") {
|
|
size_t pos = 0;
|
|
while ((pos = returnedString.lastIndexOf(delimiter)) != -1) {
|
|
#if defined(ESP8266)
|
|
yield();
|
|
#endif
|
|
String token = returnedString.substring(pos);
|
|
returnedString.remove(pos,returnedString.length() );
|
|
char token_char[token.length()+1];
|
|
token.toCharArray(token_char, token.length()+1);
|
|
trc(token);
|
|
if ( token.length() > 60){// we extract data only if we have detailled infos
|
|
for(int i =0; i<6;i++)
|
|
{
|
|
extract_char(token_char,d[i].extract,d[i].start, d[i].len ,d[i].reverse, false);
|
|
if (i == 3) d[5].len = (int)strtol(d[i].extract, NULL, 16) * 2; // extracting the length of the rest data
|
|
}
|
|
|
|
if((strlen(d[0].extract)) == 12) // if a mac adress is detected we publish it
|
|
{
|
|
trc(F("Creating BLE buffer"));
|
|
StaticJsonBuffer<JSON_MSG_BUFFER> jsonBuffer;
|
|
JsonObject& BLEdata = jsonBuffer.createObject();
|
|
#ifdef subjectHomePresence
|
|
String HomePresenceId;
|
|
for (int i = 0; i++; i<13){
|
|
String HomePresenceId = HomePresenceId + String(d[0].extract[i]);
|
|
if(i % 2 == 0) HomePresenceId += ":";
|
|
}
|
|
trc(F("HomePresenceId"));
|
|
trc(HomePresenceId);
|
|
BLEdata.set("id", HomePresenceId);
|
|
#endif
|
|
strupp(d[0].extract);
|
|
String topic = subjectBTtoMQTT + String(d[0].extract);
|
|
int rssi = (int)strtol(d[2].extract, NULL, 16) - 256;
|
|
BLEdata.set("rssi", (int)rssi);
|
|
#ifdef subjectHomePresence
|
|
haRoomPresence(BLEdata);// this device has an rssi in consequence we can use it for home assistant room presence component
|
|
#endif
|
|
String Service_data(d[5].extract);
|
|
Service_data = Service_data.substring(14);
|
|
BLEdata.set("servicedata", (char *)Service_data.c_str());
|
|
pub((char *)topic.c_str(),BLEdata);
|
|
if (strcmp(d[4].extract, "fe95") == 0) {
|
|
int pos = -1;
|
|
pos = strpos(d[5].extract,"209800");
|
|
if (pos != -1) {
|
|
trc("mi flora data reading");
|
|
boolean result = process_data(pos - 38,(char *)Service_data.c_str(),d[0].extract);
|
|
}
|
|
pos = -1;
|
|
pos = strpos(d[5].extract,"20aa01");
|
|
if (pos != -1){
|
|
trc("mi jia data reading");
|
|
boolean result = process_data(pos - 40,(char *)Service_data.c_str(),d[0].extract);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
returnedString = ""; //init data string
|
|
return false;
|
|
}
|
|
softserial.print(F(QUESTION_MSG));
|
|
return false;
|
|
}else{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void strupp(char* beg)
|
|
{
|
|
while (*beg = toupper(*beg))
|
|
++beg;
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifndef ZgatewayBT_v6xx
|
|
#define QUESTION_MSG "AT+DISI?"
|
|
boolean BTtoMQTT() {
|
|
while (softserial.available() > 0) {
|
|
#if defined(ESP8266)
|
|
yield();
|
|
#endif
|
|
String discResult = softserial.readString();
|
|
if (discResult.indexOf(STRING_MSG)>=0){
|
|
discResult.replace(RESPONSE_MSG,"");
|
|
discResult.replace(RESP_END_MSG,"");
|
|
float device_number = discResult.length()/78.0;
|
|
if (device_number == (int)device_number){ // to avoid publishing partial values we detect if the serial data has been fully read = a multiple of 78
|
|
trc(F("Sending BT data to MQTT HM1X Version<v6xx"));
|
|
#if defined(ESP8266)
|
|
yield();
|
|
#endif
|
|
for (int i=0;i<(int)device_number;i++){
|
|
String onedevice = discResult.substring(0,78);
|
|
onedevice.replace(STRING_MSG,"");
|
|
String mac = onedevice.substring(53,65);
|
|
trc(mactopic + " " + rssi);
|
|
pub(subjectBTtoMQTT + mac + subjectBTtoMQTTrssi,onedevice.substring(66,70));
|
|
discResult = discResult.substring(78);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
if (discResult.indexOf(SETUP_MSG)>=0)
|
|
{
|
|
trc(F("Connection OK to HM-10"));
|
|
}
|
|
}
|
|
if (millis() > (timebt + TimeBtw_Read)) {//retriving value of adresses and rssi
|
|
timebt = millis();
|
|
#if defined(ESP8266)
|
|
yield();
|
|
#endif
|
|
softserial.print(F(QUESTION_MSG));
|
|
|
|
}
|
|
return false;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
boolean process_data(int offset, char * rest_data, char * mac_adress){
|
|
trc(F("Creating BLE buffer"));
|
|
StaticJsonBuffer<JSON_MSG_BUFFER> jsonBuffer;
|
|
JsonObject& BLEdata = jsonBuffer.createObject();
|
|
trc("rest_data");
|
|
trc(rest_data);
|
|
int data_length = 0;
|
|
switch (rest_data[51 + offset]) {
|
|
case '1' :
|
|
case '2' :
|
|
case '3' :
|
|
case '4' :
|
|
data_length = ((rest_data[51 + offset] - '0') * 2)+1;
|
|
trc("data_length");
|
|
trc(data_length);
|
|
break;
|
|
default:
|
|
trc("can't read data_length");
|
|
return false;
|
|
}
|
|
|
|
char rev_data[data_length];
|
|
char data[data_length];
|
|
memcpy( rev_data, &rest_data[52 + offset], data_length );
|
|
rev_data[data_length] = '\0';
|
|
|
|
// reverse data order
|
|
revert_hex_data(rev_data, data, data_length);
|
|
double value = strtol(data, NULL, 16);
|
|
trc(value);
|
|
char val[12];
|
|
String mactopic(mac_adress);
|
|
mactopic = subjectBTtoMQTT + mactopic;
|
|
|
|
// second value
|
|
char val2[12];
|
|
trc("rest_data");
|
|
trc(rest_data);
|
|
// Mi flora provides tem(perature), (earth) moi(sture), fer(tility) and lux (illuminance)
|
|
// Mi Jia provides tem(perature), batt(erry) and hum(idity)
|
|
// following the value of digit 47 we determine the type of data we get from the sensor
|
|
switch (rest_data[47 + offset]) {
|
|
case '9' :
|
|
dtostrf(value,0,0,val);
|
|
BLEdata.set("fer", val);
|
|
break;
|
|
case '4' :
|
|
if (value > 65000) value = value - 65535;
|
|
dtostrf(value/10,3,1,val); // temp has to be divided by 10
|
|
BLEdata.set("tem", val);
|
|
break;
|
|
case '6' :
|
|
if (value > 65000) value = value - 65535;
|
|
dtostrf(value/10,3,1,val); // hum has to be divided by 10
|
|
BLEdata.set("hum", val);
|
|
break;
|
|
case '7' :
|
|
dtostrf(value,0,0,val);
|
|
BLEdata.set("lux", val);
|
|
break;
|
|
case '8' :
|
|
dtostrf(value,0,0,val);
|
|
BLEdata.set("moi", val);
|
|
break;
|
|
|
|
case 'a' : // batteryLevel
|
|
dtostrf(value,0,0,val);
|
|
BLEdata.set("batt", val);
|
|
break;
|
|
|
|
case 'd' : // temp+hum
|
|
char tempAr[8];
|
|
// humidity
|
|
memcpy(tempAr, data, 4);
|
|
tempAr[4] = '\0';
|
|
value = strtol(tempAr, NULL, 16);
|
|
if (value > 65000) value = value - 65535;
|
|
dtostrf(value/10,3,1,val); // hum has to be divided by 10
|
|
BLEdata.set("hum", val);
|
|
// temperature
|
|
memcpy(tempAr, &data[4], 4);
|
|
tempAr[4] = '\0';
|
|
value = strtol(tempAr, NULL, 16);
|
|
if (value > 65000) value = value - 65535;
|
|
dtostrf(value/10,3,1,val2); // hum has to be divided by 10
|
|
BLEdata.set("tem", val2);
|
|
break;
|
|
default:
|
|
trc("can't read values");
|
|
return false;
|
|
}
|
|
pub((char *)mactopic.c_str(),BLEdata);
|
|
return true;
|
|
}
|
|
|
|
void haRoomPresence(JsonObject& HomePresence){
|
|
trc("BLE DISTANCE :");
|
|
double BLErssi = HomePresence["rssi"];
|
|
double ratio = BLErssi/-59;
|
|
double distance = (0.89)* pow(ratio,7.7095) + 0.11;
|
|
HomePresence["distance"] = distance;
|
|
trc(distance);
|
|
pub(subjectHomePresence,HomePresence);
|
|
}
|
|
|
|
#endif
|