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

317 lines
6.9 KiB
C++
Raw Blame History

/*
xsns_78_xezo.ino - EZO family I2C driver support for Tasmota
Copyright (C) 2020 Christopher Tremblay
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/>.
*/
#ifdef USE_I2C
#if defined(USE_EZOPH) || defined(USE_EZOORP) || defined(USE_EZORTD) || defined(USE_EZOHUM)
#define XSNS_78 78
#define XI2C_55 55 // See I2CDEVICES.md
#define EZO_ADDR_0 0x61 // First EZO address
#define EZO_ADDR_n 16 // Number of ports for use with EZO devices
// List of known EZO devices and their default address
enum {
EZO_DO = 0x61, // D.O.
EZO_ORP = 0x62, // ORP
EZO_PH = 0x63, // pH
EZO_EC = 0x64, // EC
EZO_RTD = 0x66, // RTD
EZO_PMP = 0x67, // PMP
EZO_FLO = 0x68, // FLO
EZO_CO2 = 0x69, // CO2
EZO_PRS = 0x6A, // PRS
EZO_O2 = 0x6C, // O2
EZO_HUM = 0x6F, // HUM
EZO_RGB = 0x70, // RGB
};
const char EZO_EMPTY[] PROGMEM = "";
//const char EZO_DO_NAME[] PROGMEM = "DO";
#ifdef USE_EZOORP
const char EZO_ORP_NAME[] PROGMEM = "ORP";
#endif
#ifdef USE_EZOPH
const char EZO_PH_NAME[] PROGMEM = "pH";
#endif
//const char EZO_EC_NAME[] PROGMEM = "EC";
#ifdef USE_EZORTD
const char EZO_RTD_NAME[] PROGMEM = "RTD";
#endif
//const char EZO_PMP_NAME[] PROGMEM = "PMP";
//const char EZO_FLO_NAME[] PROGMEM = "FLO";
//const char EZO_CO2_NAME[] PROGMEM = "CO2";
//const char EZO_PRS_NAME[] PROGMEM = "PRS";
//const char EZO_O2_NAME[] PROGMEM = "O2";
#ifdef USE_EZOHUM
const char EZO_HUM_NAME[] PROGMEM = "HUM";
#endif
//const char EZO_RGB_NAME[] PROGMEM = "RGB";
const char *const EZOSupport[EZO_ADDR_n] PROGMEM = {
EZO_EMPTY,
#ifdef USE_EZOORP
EZO_ORP_NAME,
#else
EZO_EMPTY,
#endif
#ifdef USE_EZOPH
EZO_PH_NAME,
#else
EZO_EMPTY,
#endif
EZO_EMPTY,
EZO_EMPTY,
#ifdef USE_EZORTD
EZO_RTD_NAME,
#else
EZO_EMPTY,
#endif
EZO_EMPTY,
EZO_EMPTY,
EZO_EMPTY,
EZO_EMPTY,
EZO_EMPTY,
EZO_EMPTY,
EZO_EMPTY,
EZO_EMPTY,
#ifdef USE_EZOHUM
EZO_HUM_NAME,
#else
EZO_EMPTY,
#endif
EZO_EMPTY,
};
struct EZOManager {
void Command()
{
char *at = XdrvMailbox.data;
uint32_t len = XdrvMailbox.data_len;
// Figure out if we're trying to address a specific device
// PS: This should ideally be done through the Tasmota mailbox
if (at[0] == '-') {
int32_t idx = atoi(&at[1]) - 1;
at = strchr(at, ' ');
if (!at++) {
return;
}
len -= (at - XdrvMailbox.data);
if ((idx >= 0) && (idx < count)) {
sensor[idx]->ProcessMeasurement();
sensor[idx]->HandleCommand(at, len);
}
} else {
for (uint32_t i = 0; i < count; i++) {
sensor[i]->ProcessMeasurement();
sensor[i]->HandleCommand(at, len);
}
}
}
void EverySecond()
{
// Do we have to deal with the 2 stage booting process?
if (count < 0) {
// EZO devices take 2s to boot
if (uptime >= next) {
count++;
if (count == -1) {
DetectRequest();
next = uptime + 1;
} else if (count == 0) {
ProcessDetection();
}
}
}
for (int32_t i = 0; i < count; i++) {
sensor[i]->ProcessMeasurement();
sensor[i]->MeasureRequest();
}
}
void Show(bool json)
{
for (int32_t i = 0; i < count; i++) {
if (sensor[i]->isValid()) {
char name[7];
snprintf_P(name, sizeof(name), PSTR("%s%c%X"), D_EZO_NAME, IndexSeparator(), i + 1);
if (count == 1) {
name[sizeof(D_EZO_NAME) - 1] = 0;
}
sensor[i]->Show(json, name);
}
}
}
private:
void DetectRequest(void)
{
const uint8_t EZOInfoCmd[2] = {'i', 0};
alive = 0;
// Scan the address range
uint16_t shift = 1;
for (uint8_t i = EZO_ADDR_0; shift; i++) {
if (!I2cActive(i)) {
// Request the device to identify itself
Wire.beginTransmission(i);
Wire.write(EZOInfoCmd, sizeof(EZOInfoCmd));
int c = Wire.endTransmission();
if (c == 0) {
alive |= shift;
}
}
shift <<= 1;
}
}
void ProcessDetection(void)
{
// Check every address that we sent a request to
for (uint8_t addr = EZO_ADDR_0; addr < EZO_ADDR_0 + EZO_ADDR_n; addr++) {
if (alive & 1) {
char data[D_EZO_MAX_BUF];
Wire.requestFrom(addr, sizeof(data));
char code = Wire.read();
if (code == 1) {
uint32_t i;
for (i = 0; Wire.available() > 0; i++) {
char c = Wire.read();
// Helps us strcmp
data[i] = (c == ',') ? 0 : c;
}
// Technically the response starts with "?I," but we'll skip testing it to save space
if (i >= 3) {
for (uint32_t j = 0; j < EZO_ADDR_n; j++) {
if (strcasecmp_P(&data[3], EZOSupport[j]) == 0) {
data[0] = 'E';
data[1] = 'Z';
data[2] = 'O';
I2cSetActiveFound(addr, data);
// We use switch intead of virtual function to save RAM
switch (j + EZO_ADDR_0) {
#ifdef USE_EZOORP
case EZO_ORP:
sensor[count] = new EZOORP(addr);
break;
#endif
#ifdef USE_EZOPH
case EZO_PH:
sensor[count] = new EZOpH(addr);
break;
#endif
#ifdef USE_EZORTD
case EZO_RTD:
sensor[count] = new EZORTD(addr);
break;
#endif
#ifdef USE_EZOHUM
case EZO_HUM:
sensor[count] = new EZOHUM(addr);
break;
#endif
}
count++;
}
}
}
}
}
alive >>= 1;
}
}
uint32_t next = 2;
int8_t count = -2;
// Following variables are harcoded to allow a maximum of 16 entries
uint16_t alive;
EZOStruct *sensor[EZO_ADDR_n];
} EZOManager;
// The main driver is the same for all devices.
// What changes is the implementation of the class itself
bool Xsns78(uint8_t function)
{
if (!I2cEnabled(XI2C_55)) {
return false;
}
switch (function) {
case FUNC_COMMAND_SENSOR:
EZOManager.Command();
break;
case FUNC_EVERY_SECOND:
EZOManager.EverySecond();
break;
case FUNC_JSON_APPEND:
EZOManager.Show(1);
break;
#ifdef USE_WEBSERVER
case FUNC_WEB_SENSOR:
EZOManager.Show(0);
break;
#endif
}
return false;
}
#endif // USE_EZO*
#endif // USE_I2C
Reference in New Issue View Git Blame Copy Permalink