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

318 lines
9.2 KiB
C++
Raw Blame History

/*
xsns_08_htu21.ino - HTU21 temperature and humidity sensor support for Tasmota
Copyright (C) 2021 Heiko Krupp and Theo Arends
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
#ifdef USE_HTU
/*********************************************************************************************\
* HTU21 - Temperature and Humidity
*
* Source: Heiko Krupp
*
* I2C Address: 0x40
\*********************************************************************************************/
#define XSNS_08 8
#define XI2C_09 9 // See I2CDEVICES.md
#define HTU21_ADDR 0x40
#define SI7013_CHIPID 0x0D
#define SI7020_CHIPID 0x14
#define SI7021_CHIPID 0x15
#define HTU21_CHIPID 0x32
#define HTU21_READTEMP 0xE3
#define HTU21_READHUM 0xE5
#define HTU21_WRITEREG 0xE6
#define HTU21_READREG 0xE7
#define HTU21_RESET 0xFE
#define HTU21_HEATER_WRITE 0x51
#define HTU21_HEATER_READ 0x11
#define HTU21_SERIAL2_READ1 0xFC /* Read 3rd two Serial bytes */
#define HTU21_SERIAL2_READ2 0xC9 /* Read 4th two Serial bytes */
#define HTU21_HEATER_ON 0x04
#define HTU21_HEATER_OFF 0xFB
#define HTU21_RES_RH12_T14 0x00 // Default
#define HTU21_RES_RH8_T12 0x01
#define HTU21_RES_RH10_T13 0x80
#define HTU21_RES_RH11_T11 0x81
#define HTU21_CRC8_POLYNOM 0x13100
const char kHtuTypes[] PROGMEM = "HTU21|SI7013|SI7020|SI7021|T/RH?";
struct {
float temperature = 0;
float humidity = 0;
uint8_t address;
uint8_t bus;
uint8_t type = 0;
uint8_t delay_temp;
uint8_t delay_humidity = 50;
uint8_t valid = 0;
char types[7];
} Htu;
/*********************************************************************************************/
uint8_t HtuCheckCrc8(uint16_t data) {
for (uint32_t bit = 0; bit < 16; bit++) {
if (data & 0x8000) {
data = (data << 1) ^ HTU21_CRC8_POLYNOM;
} else {
data <<= 1;
}
}
return data >>= 8;
}
bool HtuReset(void) {
/*
TwoWire& myWire = I2cGetWire(Htu.bus);
if (&myWire == nullptr) { return false; } // No valid I2c bus
myWire.beginTransmission(HTU21_ADDR);
myWire.write(HTU21_RESET);
myWire.endTransmission();
*/
I2cWrite0(HTU21_ADDR, HTU21_RESET, Htu.bus);
delay(15); // Reset takes 15ms
return true;
}
uint8_t HtuReadDeviceId(void) {
if (!HtuReset()) { return 0; }; // Fixes ESP32 sensor loss at restart
/*
uint16_t deviceID = 0;
uint8_t checksum = 0;
TwoWire& myWire = I2cGetWire(Htu.bus);
myWire.beginTransmission(HTU21_ADDR);
myWire.write(HTU21_SERIAL2_READ1);
myWire.write(HTU21_SERIAL2_READ2);
myWire.endTransmission();
myWire.requestFrom(HTU21_ADDR, 3);
deviceID = myWire.read() << 8;
deviceID |= myWire.read();
checksum = myWire.read();
if (HtuCheckCrc8(deviceID) == checksum) {
deviceID = deviceID >> 8;
} else {
deviceID = 0;
}
*/
uint8_t data[3];
I2cReadBuffer(HTU21_ADDR, HTU21_SERIAL2_READ2 << 8 | HTU21_SERIAL2_READ1, data, 3, Htu.bus);
uint16_t deviceID = (data[0] << 8) | data[1];
if (HtuCheckCrc8(deviceID) == data[2]) {
deviceID = deviceID >> 8;
} else {
deviceID = 0;
}
return (uint8_t)deviceID;
}
void HtuSetResolution(uint8_t resolution) {
uint8_t current = I2cRead8(HTU21_ADDR, HTU21_READREG, Htu.bus);
current &= 0x7E; // Replace current resolution bits with 0
current |= resolution; // Add new resolution bits to register
I2cWrite8(HTU21_ADDR, HTU21_WRITEREG, current, Htu.bus);
}
void HtuHeater(uint8_t heater) {
uint8_t current = I2cRead8(HTU21_ADDR, HTU21_READREG, Htu.bus);
switch(heater) {
case HTU21_HEATER_ON : current |= heater;
break;
case HTU21_HEATER_OFF : current &= heater;
break;
default : current &= heater;
break;
}
I2cWrite8(HTU21_ADDR, HTU21_WRITEREG, current, Htu.bus);
}
void HtuInit(void) {
HtuReset();
HtuHeater(HTU21_HEATER_OFF);
HtuSetResolution(HTU21_RES_RH12_T14);
}
bool HtuI2cRead(uint8_t reg, uint8_t hdelay, uint16_t &sensorval) {
if (!I2cWrite0(HTU21_ADDR, reg, Htu.bus)) { return false; }
delay(hdelay); // Sensor time at max resolution
uint8_t data[3] = { 0 };
if (!I2cReadBuffer0(HTU21_ADDR, data, 3, Htu.bus)) {
sensorval = data[0] << 8 | data[1]; // MSB, LSB
}
if (HtuCheckCrc8(sensorval) != data[2]) { return false; } // Checksum mismatch
return true;
}
bool HtuRead(void) {
if (Htu.valid) { Htu.valid--; }
uint16_t sensorval = 0;
/*
uint8_t checksum = 0;
TwoWire& myWire = I2cGetWire(Htu.bus);
myWire.beginTransmission(HTU21_ADDR);
myWire.write(HTU21_READTEMP);
if (myWire.endTransmission() != 0) { return false; } // In case of error
delay(Htu.delay_temp); // Sensor time at max resolution
myWire.requestFrom(HTU21_ADDR, 3);
if (3 == myWire.available()) {
sensorval = myWire.read() << 8; // MSB
sensorval |= myWire.read(); // LSB
checksum = myWire.read();
}
if (HtuCheckCrc8(sensorval) != checksum) { return false; } // Checksum mismatch
Htu.temperature = ConvertTemp(0.002681f * (float)sensorval - 46.85f);
myWire.beginTransmission(HTU21_ADDR);
myWire.write(HTU21_READHUM);
if (myWire.endTransmission() != 0) { return false; } // In case of error
delay(Htu.delay_humidity); // Sensor time at max resolution
myWire.requestFrom(HTU21_ADDR, 3);
if (3 <= myWire.available()) {
sensorval = myWire.read() << 8; // MSB
sensorval |= myWire.read(); // LSB
checksum = myWire.read();
}
if (HtuCheckCrc8(sensorval) != checksum) { return false; } // Checksum mismatch
*/
if (!HtuI2cRead(HTU21_READTEMP, Htu.delay_temp, sensorval)) { return false; } // Checksum mismatch
Htu.temperature = ConvertTemp(0.002681f * (float)sensorval - 46.85f);
if (!HtuI2cRead(HTU21_READHUM, Htu.delay_humidity, sensorval)) { return false; } // Checksum mismatch
sensorval ^= 0x02; // clear status bits
Htu.humidity = 0.001907f * (float)sensorval - 6;
if (Htu.humidity > 100) { Htu.humidity = 100.0f; }
if (Htu.humidity < 0) { Htu.humidity = 0.01f; }
if ((0.00f == Htu.humidity) && (0.00f == Htu.temperature)) {
Htu.humidity = 0.0f;
}
if ((Htu.temperature > 0.00f) && (Htu.temperature < 80.00f)) {
Htu.humidity = (-0.15f) * (25 - Htu.temperature) + Htu.humidity;
}
Htu.humidity = ConvertHumidity(Htu.humidity);
Htu.valid = SENSOR_MAX_MISS;
return true;
}
/********************************************************************************************/
void HtuDetect(void) {
Htu.address = HTU21_ADDR;
for (Htu.bus = 0; Htu.bus < 2; Htu.bus++) {
if (!I2cSetDevice(Htu.address, Htu.bus)) { continue; }
Htu.type = HtuReadDeviceId();
if (Htu.type) {
uint8_t index = 0;
HtuInit();
switch (Htu.type) {
case HTU21_CHIPID:
Htu.delay_temp = 50;
Htu.delay_humidity = 16;
break;
case SI7021_CHIPID:
index++; // 3
case SI7020_CHIPID:
index++; // 2
case SI7013_CHIPID:
index++; // 1
Htu.delay_temp = 12;
Htu.delay_humidity = 23;
break;
default:
index = 4;
Htu.delay_temp = 50;
Htu.delay_humidity = 23;
}
GetTextIndexed(Htu.types, sizeof(Htu.types), index, kHtuTypes);
I2cSetActiveFound(Htu.address, Htu.types, Htu.bus);
break;
}
}
}
void HtuEverySecond(void) {
if (TasmotaGlobal.uptime &1) { // Every 2 seconds
// HTU21: 68mS, SI70xx: 37mS
if (!HtuRead()) {
AddLogMissed(Htu.types, Htu.valid);
}
}
}
void HtuShow(bool json) {
if (Htu.valid) {
TempHumDewShow(json, (0 == TasmotaGlobal.tele_period), Htu.types, Htu.temperature, Htu.humidity);
}
}
/*********************************************************************************************\
* Interface
\*********************************************************************************************/
bool Xsns08(uint32_t function)
{
if (!I2cEnabled(XI2C_09)) { return false; }
bool result = false;
if (FUNC_INIT == function) {
HtuDetect();
}
else if (Htu.type) {
switch (function) {
case FUNC_EVERY_SECOND:
HtuEverySecond();
break;
case FUNC_JSON_APPEND:
HtuShow(1);
break;
#ifdef USE_WEBSERVER
case FUNC_WEB_SENSOR:
HtuShow(0);
break;
#endif // USE_WEBSERVER
}
}
return result;
}
#endif // USE_HTU
#endif // USE_I2C
Reference in New Issue View Git Blame Copy Permalink