mirror of https://github.com/arendst/Tasmota.git
Add ESP32 support for BMPxxx sensors on two I2C busses
Add ESP32 support for BMPxxx sensors on two I2C busses (#17643)
This commit is contained in:
Theo Arends
parent
0781192c87
commit
9073fe01c1
|
|
@ -8,6 +8,7 @@ All notable changes to this project will be documented in this file.
|
|||
- Support for PCA9632 4-channel 8-bit PWM driver as light driver by Pascal Heinrich (#17557)
|
||||
- Berry `bytes()` now evaluates to `false` if empty
|
||||
- Berry ``crypto.AES_CCM`` (required by Matter protocol)
|
||||
- ESP32 support for BMPxxx sensors on two I2C busses (#17643)
|
||||
|
||||
### Breaking Changed
|
||||
|
||||
|
|
|
|||
|
|
@ -119,6 +119,7 @@ The latter links can be used for OTA upgrades too like ``OtaUrl https://ota.tasm
|
|||
- Berry crypto add ``random`` to generate series of random bytes
|
||||
- Berry crypto add ``HKDF_HMAC_SHA256``
|
||||
- Berry crypto add ``SPAKE2P_Matter`` for Matter support
|
||||
- ESP32 support for BMPxxx sensors on two I2C busses [#17643](https://github.com/arendst/Tasmota/issues/17643)
|
||||
|
||||
### Breaking Changed
|
||||
|
||||
|
|
|
|||
|
|
@ -8,15 +8,12 @@
|
|||
|
||||
#ifdef USE_I2C
|
||||
/*********************************************************************************************\
|
||||
* Basic I2C routines
|
||||
* Basic I2C routines supporting two busses
|
||||
\*********************************************************************************************/
|
||||
|
||||
const uint8_t I2C_RETRY_COUNTER = 3;
|
||||
|
||||
uint32_t i2c_active[4] = { 0 };
|
||||
#ifdef ESP32
|
||||
uint32_t i2c_active_bus2[4] = { 0 }; // ESP32 can have two I2C buses
|
||||
#endif
|
||||
uint32_t i2c_active[2][4] = { 0 };
|
||||
uint32_t i2c_buffer = 0;
|
||||
|
||||
bool I2cBegin(int sda, int scl, uint32_t frequency = 100000);
|
||||
|
|
@ -48,8 +45,7 @@ bool I2c2Begin(int sda, int scl, uint32_t frequency) {
|
|||
}
|
||||
#endif
|
||||
|
||||
bool I2cValidRead(uint8_t addr, uint8_t reg, uint8_t size, uint8_t bus = 0)
|
||||
{
|
||||
bool I2cValidRead(uint8_t addr, uint8_t reg, uint8_t size, uint8_t bus = 0) {
|
||||
uint8_t retry = I2C_RETRY_COUNTER;
|
||||
bool status = false;
|
||||
#ifdef ESP32
|
||||
|
|
@ -58,7 +54,6 @@ bool I2cValidRead(uint8_t addr, uint8_t reg, uint8_t size, uint8_t bus = 0)
|
|||
#else
|
||||
TwoWire & myWire = Wire;
|
||||
#endif
|
||||
|
||||
i2c_buffer = 0;
|
||||
while (!status && retry) {
|
||||
myWire.beginTransmission(addr); // start transmission to device
|
||||
|
|
@ -78,83 +73,81 @@ bool I2cValidRead(uint8_t addr, uint8_t reg, uint8_t size, uint8_t bus = 0)
|
|||
return status;
|
||||
}
|
||||
|
||||
bool I2cValidRead8(uint8_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
bool status = I2cValidRead(addr, reg, 1,bus);
|
||||
bool I2cValidRead8(uint8_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
bool status = I2cValidRead(addr, reg, 1, bus);
|
||||
*data = (uint8_t)i2c_buffer;
|
||||
return status;
|
||||
}
|
||||
bool I2cValidRead16(uint16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
bool status = I2cValidRead(addr, reg, 2,bus);
|
||||
|
||||
bool I2cValidRead16(uint16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
bool status = I2cValidRead(addr, reg, 2, bus);
|
||||
*data = (uint16_t)i2c_buffer;
|
||||
return status;
|
||||
}
|
||||
bool I2cValidReadS16(int16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
|
||||
bool I2cValidReadS16(int16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
bool status = I2cValidRead(addr, reg, 2, bus);
|
||||
*data = (int16_t)i2c_buffer;
|
||||
return status;
|
||||
}
|
||||
bool I2cValidRead16LE(uint16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
|
||||
bool I2cValidRead16LE(uint16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
uint16_t ldata;
|
||||
bool status = I2cValidRead16(&ldata, addr, reg, bus);
|
||||
*data = (ldata >> 8) | (ldata << 8);
|
||||
return status;
|
||||
}
|
||||
bool I2cValidReadS16_LE(int16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
|
||||
bool I2cValidReadS16_LE(int16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
uint16_t ldata;
|
||||
bool status = I2cValidRead16LE(&ldata, addr, reg, bus);
|
||||
*data = (int16_t)ldata;
|
||||
return status;
|
||||
}
|
||||
bool I2cValidRead24(int32_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
|
||||
bool I2cValidRead24(int32_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
bool status = I2cValidRead(addr, reg, 3, bus);
|
||||
*data = i2c_buffer;
|
||||
return status;
|
||||
}
|
||||
uint8_t I2cRead8(uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
|
||||
uint8_t I2cRead8(uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
I2cValidRead(addr, reg, 1, bus);
|
||||
return (uint8_t)i2c_buffer;
|
||||
}
|
||||
uint16_t I2cRead16(uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
|
||||
uint16_t I2cRead16(uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
I2cValidRead(addr, reg, 2, bus);
|
||||
return (uint16_t)i2c_buffer;
|
||||
}
|
||||
int16_t I2cReadS16(uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
|
||||
int16_t I2cReadS16(uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
I2cValidRead(addr, reg, 2, bus);
|
||||
return (int16_t)i2c_buffer;
|
||||
}
|
||||
uint16_t I2cRead16LE(uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
|
||||
uint16_t I2cRead16LE(uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
I2cValidRead(addr, reg, 2, bus);
|
||||
uint16_t temp = (uint16_t)i2c_buffer;
|
||||
return (temp >> 8) | (temp << 8);
|
||||
}
|
||||
int16_t I2cReadS16_LE(uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
|
||||
int16_t I2cReadS16_LE(uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
return (int16_t)I2cRead16LE(addr, reg, bus);
|
||||
}
|
||||
int32_t I2cRead24(uint8_t addr, uint8_t reg, uint8_t bus = 0)
|
||||
{
|
||||
|
||||
int32_t I2cRead24(uint8_t addr, uint8_t reg, uint8_t bus = 0) {
|
||||
I2cValidRead(addr, reg, 3, bus);
|
||||
return i2c_buffer;
|
||||
}
|
||||
|
||||
bool I2cWrite(uint8_t addr, uint8_t reg, uint32_t val, uint8_t size, uint8_t bus = 0)
|
||||
{
|
||||
bool I2cWrite(uint8_t addr, uint8_t reg, uint32_t val, uint8_t size, uint8_t bus = 0) {
|
||||
uint8_t x = I2C_RETRY_COUNTER;
|
||||
#ifdef ESP32
|
||||
if (!TasmotaGlobal.i2c_enabled_2) { bus = 0; }
|
||||
TwoWire & myWire = (bus == 0) ? Wire : Wire1;
|
||||
#else
|
||||
if(0!=bus) {return false;} // second I2c bus ESP32 only
|
||||
if (bus != 0) { return false; } // Second I2c bus ESP32 only
|
||||
TwoWire & myWire = Wire;
|
||||
#endif
|
||||
do {
|
||||
|
|
@ -168,23 +161,21 @@ bool I2cWrite(uint8_t addr, uint8_t reg, uint32_t val, uint8_t size, uint8_t bus
|
|||
} while (myWire.endTransmission(true) != 0 && x != 0); // end transmission
|
||||
return (x);
|
||||
}
|
||||
bool I2cWrite8(uint8_t addr, uint8_t reg, uint32_t val, uint8_t bus = 0)
|
||||
{
|
||||
return I2cWrite(addr, reg, val, 1,bus);
|
||||
|
||||
bool I2cWrite8(uint8_t addr, uint8_t reg, uint32_t val, uint8_t bus = 0) {
|
||||
return I2cWrite(addr, reg, val, 1, bus);
|
||||
}
|
||||
|
||||
bool I2cWrite16(uint8_t addr, uint8_t reg, uint32_t val, uint8_t bus = 0)
|
||||
{
|
||||
return I2cWrite(addr, reg, val, 2,bus);
|
||||
bool I2cWrite16(uint8_t addr, uint8_t reg, uint32_t val, uint8_t bus = 0) {
|
||||
return I2cWrite(addr, reg, val, 2, bus);
|
||||
}
|
||||
|
||||
bool I2cReadBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len, uint8_t bus = 0)
|
||||
{
|
||||
bool I2cReadBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len, uint8_t bus = 0) {
|
||||
#ifdef ESP32
|
||||
if (!TasmotaGlobal.i2c_enabled_2) { bus = 0; }
|
||||
TwoWire & myWire = (bus == 0) ? Wire : Wire1;
|
||||
#else
|
||||
if(0!=bus) {return false;} // second I2c bus ESP32 only
|
||||
if (bus != 0) { return false; } // Second I2c bus ESP32 only
|
||||
TwoWire & myWire = Wire;
|
||||
#endif
|
||||
myWire.beginTransmission((uint8_t)addr);
|
||||
|
|
@ -200,13 +191,12 @@ bool I2cReadBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len, u
|
|||
return 0;
|
||||
}
|
||||
|
||||
int8_t I2cWriteBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len, uint8_t bus = 0)
|
||||
{
|
||||
int8_t I2cWriteBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len, uint8_t bus = 0) {
|
||||
#ifdef ESP32
|
||||
if (!TasmotaGlobal.i2c_enabled_2) { bus = 0; }
|
||||
TwoWire & myWire = (bus == 0) ? Wire : Wire1;
|
||||
#else
|
||||
if(0!=bus) {return false;} // second I2c bus ESP32 only
|
||||
if (bus != 0) { return false; } // Second I2c bus ESP32 only
|
||||
TwoWire & myWire = Wire;
|
||||
#endif
|
||||
myWire.beginTransmission((uint8_t)addr);
|
||||
|
|
@ -219,8 +209,7 @@ int8_t I2cWriteBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len
|
|||
return 0;
|
||||
}
|
||||
|
||||
void I2cScan(uint8_t bus = 0)
|
||||
{
|
||||
void I2cScan(uint8_t bus = 0) {
|
||||
// Return error codes defined in twi.h and core_esp8266_si2c.c
|
||||
// I2C_OK 0
|
||||
// I2C_SCL_HELD_LOW 1 = SCL held low by another device, no procedure available to recover
|
||||
|
|
@ -246,7 +235,7 @@ void I2cScan(uint8_t bus = 0)
|
|||
if (!TasmotaGlobal.i2c_enabled_2) { bus = 0; }
|
||||
TwoWire & myWire = (bus == 0) ? Wire : Wire1;
|
||||
#else
|
||||
if(0!=bus) {return;} // second I2c bus ESP32 only
|
||||
if (bus != 0) { return; } // Second I2c bus ESP32 only
|
||||
TwoWire & myWire = Wire;
|
||||
#endif
|
||||
myWire.beginTransmission(address);
|
||||
|
|
@ -267,95 +256,56 @@ void I2cScan(uint8_t bus = 0)
|
|||
}
|
||||
if (any) {
|
||||
ResponseAppend_P(PSTR("\"}"));
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
Response_P(PSTR("{\"" D_CMND_I2CSCAN "\":\"" D_JSON_I2CSCAN_NO_DEVICES_FOUND "\"}"));
|
||||
}
|
||||
}
|
||||
|
||||
void I2cResetActive(uint32_t addr, uint32_t count = 1, uint8_t bus = 0)
|
||||
{
|
||||
void I2cResetActive(uint32_t addr, uint32_t count = 1, uint8_t bus = 0) {
|
||||
#ifdef ESP8266
|
||||
bus = 0;
|
||||
#endif
|
||||
addr &= 0x7F; // Max I2C address is 127
|
||||
count &= 0x7F; // Max 4 x 32 bits available
|
||||
while (count-- && (addr < 128))
|
||||
{
|
||||
#ifdef ESP32
|
||||
if(0==bus)
|
||||
{
|
||||
#endif
|
||||
i2c_active[addr / 32] &= ~(1 << (addr % 32));
|
||||
#ifdef ESP32
|
||||
}
|
||||
else
|
||||
{
|
||||
i2c_active_bus2[addr / 32] &= ~(1 << (addr % 32));
|
||||
}
|
||||
#endif
|
||||
while (count-- && (addr < 128)) {
|
||||
i2c_active[bus][addr / 32] &= ~(1 << (addr % 32));
|
||||
addr++;
|
||||
}
|
||||
// AddLog(LOG_LEVEL_DEBUG, PSTR("I2C: Active %08X,%08X,%08X,%08X"), i2c_active[0], i2c_active[1], i2c_active[2], i2c_active[3]);
|
||||
// AddLog(LOG_LEVEL_DEBUG, PSTR("I2C: Active %08X,%08X,%08X,%08X"), i2c_active[bus][0], i2c_active[bus][1], i2c_active[bus][2], i2c_active[bus][3]);
|
||||
}
|
||||
|
||||
void I2cSetActive(uint32_t addr, uint32_t count = 1, uint8_t bus = 0)
|
||||
{
|
||||
void I2cSetActive(uint32_t addr, uint32_t count = 1, uint8_t bus = 0) {
|
||||
#ifdef ESP8266
|
||||
bus = 0;
|
||||
#endif
|
||||
addr &= 0x7F; // Max I2C address is 127
|
||||
count &= 0x7F; // Max 4 x 32 bits available
|
||||
while (count-- && (addr < 128))
|
||||
{
|
||||
#ifdef ESP32
|
||||
if(0==bus)
|
||||
{
|
||||
#endif
|
||||
i2c_active[addr / 32] |= (1 << (addr % 32));
|
||||
#ifdef ESP32
|
||||
}
|
||||
else
|
||||
{
|
||||
i2c_active_bus2[addr / 32] |= (1 << (addr % 32));
|
||||
}
|
||||
#endif
|
||||
while (count-- && (addr < 128)) {
|
||||
i2c_active[bus][addr / 32] |= (1 << (addr % 32));
|
||||
addr++;
|
||||
}
|
||||
// AddLog(LOG_LEVEL_DEBUG, PSTR("I2C: Active %08X,%08X,%08X,%08X"), i2c_active[0], i2c_active[1], i2c_active[2], i2c_active[3]);
|
||||
// AddLog(LOG_LEVEL_DEBUG, PSTR("I2C: Active %08X,%08X,%08X,%08X"), i2c_active[bus][0], i2c_active[bus][1], i2c_active[bus][2], i2c_active[bus][3]);
|
||||
}
|
||||
|
||||
void I2cSetActiveFound(uint32_t addr, const char *types, uint8_t bus = 0)
|
||||
{
|
||||
I2cSetActive(addr,bus);
|
||||
void I2cSetActiveFound(uint32_t addr, const char *types, uint8_t bus = 0) {
|
||||
I2cSetActive(addr, bus);
|
||||
#ifdef ESP32
|
||||
if (0 == bus) {
|
||||
AddLog(LOG_LEVEL_INFO, S_LOG_I2C_FOUND_AT, types, addr);
|
||||
} else {
|
||||
if (1 == bus) {
|
||||
AddLog(LOG_LEVEL_INFO, S_LOG_I2C_FOUND_AT_PORT, types, addr, bus);
|
||||
}
|
||||
#else
|
||||
AddLog(LOG_LEVEL_INFO, S_LOG_I2C_FOUND_AT, types, addr);
|
||||
} else
|
||||
#endif // ESP32
|
||||
}
|
||||
bool I2cActive(uint32_t addr, uint8_t bus = 0)
|
||||
{
|
||||
#ifdef ESP32
|
||||
if(0==bus)
|
||||
{
|
||||
#endif
|
||||
addr &= 0x7F; // Max I2C address is 127
|
||||
if (i2c_active[addr / 32] & (1 << (addr % 32))) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
#ifdef ESP32
|
||||
}
|
||||
// else
|
||||
addr &= 0x7F; // Max I2C address is 127
|
||||
if (i2c_active_bus2[addr / 32] & (1 << (addr % 32))) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
#endif
|
||||
AddLog(LOG_LEVEL_INFO, S_LOG_I2C_FOUND_AT, types, addr);
|
||||
}
|
||||
|
||||
bool I2cSetDevice(uint32_t addr, uint8_t bus = 0)
|
||||
{
|
||||
bool I2cActive(uint32_t addr, uint8_t bus = 0) {
|
||||
#ifdef ESP8266
|
||||
bus = 0;
|
||||
#endif
|
||||
addr &= 0x7F; // Max I2C address is 127
|
||||
return (i2c_active[bus][addr / 32] & (1 << (addr % 32)));
|
||||
}
|
||||
|
||||
bool I2cSetDevice(uint32_t addr, uint8_t bus = 0) {
|
||||
#ifdef ESP32
|
||||
if (!TasmotaGlobal.i2c_enabled_2) { bus = 0; }
|
||||
TwoWire & myWire = (bus == 0) ? Wire : Wire1;
|
||||
|
|
@ -363,7 +313,7 @@ bool I2cSetDevice(uint32_t addr, uint8_t bus = 0)
|
|||
TwoWire & myWire = Wire;
|
||||
#endif
|
||||
addr &= 0x7F; // Max I2C address is 127
|
||||
if (I2cActive(addr,bus)) {
|
||||
if (I2cActive(addr, bus)) {
|
||||
return false; // If already active report as not present;
|
||||
}
|
||||
myWire.beginTransmission((uint8_t)addr);
|
||||
|
|
@ -371,7 +321,7 @@ bool I2cSetDevice(uint32_t addr, uint8_t bus = 0)
|
|||
uint32_t err = myWire.endTransmission();
|
||||
if (err && (err != 2)) {
|
||||
#ifdef ESP32
|
||||
AddLog(LOG_LEVEL_DEBUG, PSTR("I2C: Error %d at 0x%02x bus &d"), err, addr,bus);
|
||||
AddLog(LOG_LEVEL_DEBUG, PSTR("I2C: Error %d at 0x%02x bus %d"), err, addr, bus);
|
||||
#else
|
||||
AddLog(LOG_LEVEL_DEBUG, PSTR("I2C: Error %d at 0x%02x"), err, addr);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -44,14 +44,14 @@
|
|||
|
||||
#define BMP_REGISTER_CHIPID 0xD0
|
||||
|
||||
#define BMP_REGISTER_RESET 0xE0 // Register to reset to power on defaults (used for sleep)
|
||||
#define BMP_REGISTER_RESET 0xE0 // Register to reset to power on defaults (used for sleep)
|
||||
|
||||
#define BMP_CMND_RESET 0xB6 // I2C Parameter for RESET to put BMP into reset state
|
||||
#define BMP_CMND_RESET 0xB6 // I2C Parameter for RESET to put BMP into reset state
|
||||
|
||||
#ifdef ESP32
|
||||
#define BMP_MAX_SENSORS 4
|
||||
#define BMP_MAX_SENSORS 4 // 2 busses
|
||||
#else
|
||||
#define BMP_MAX_SENSORS 2
|
||||
#define BMP_MAX_SENSORS 2
|
||||
#endif
|
||||
|
||||
const char kBmpTypes[] PROGMEM = "BMP180|BMP280|BME280|BME680";
|
||||
|
|
@ -114,8 +114,7 @@ typedef struct {
|
|||
|
||||
bmp180_cal_data_t *bmp180_cal_data = nullptr;
|
||||
|
||||
bool Bmp180Calibration(uint8_t bmp_idx)
|
||||
{
|
||||
bool Bmp180Calibration(uint8_t bmp_idx) {
|
||||
if (!bmp180_cal_data) {
|
||||
bmp180_cal_data = (bmp180_cal_data_t*)malloc(BMP_MAX_SENSORS * sizeof(bmp180_cal_data_t));
|
||||
}
|
||||
|
|
@ -160,33 +159,21 @@ bool Bmp180Calibration(uint8_t bmp_idx)
|
|||
return true;
|
||||
}
|
||||
|
||||
void Bmp180Read(uint8_t bmp_idx)
|
||||
{
|
||||
void Bmp180Read(uint8_t bmp_idx) {
|
||||
if (!bmp180_cal_data) { return; }
|
||||
#ifdef ESP32
|
||||
uint8_t bus= (bmp_idx>=2) ? 1 : 0; // first two BMP's at bus 0, additional at bus 1
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_CONTROL, BMP180_TEMPERATURE,bus);
|
||||
|
||||
uint8_t bus = bmp_idx >>1; // First two BMP's at bus 0, additional at bus 1
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_CONTROL, BMP180_TEMPERATURE, bus);
|
||||
delay(5); // 5ms conversion time
|
||||
int ut = I2cRead16(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_RESULT,bus);
|
||||
#else
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_CONTROL, BMP180_TEMPERATURE);
|
||||
delay(5); // 5ms conversion time
|
||||
int ut = I2cRead16(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_RESULT);
|
||||
#endif
|
||||
int ut = I2cRead16(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_RESULT, bus);
|
||||
int32_t xt1 = (ut - (int32_t)bmp180_cal_data[bmp_idx].cal_ac6) * ((int32_t)bmp180_cal_data[bmp_idx].cal_ac5) >> 15;
|
||||
int32_t xt2 = ((int32_t)bmp180_cal_data[bmp_idx].cal_mc << 11) / (xt1 + (int32_t)bmp180_cal_data[bmp_idx].cal_md);
|
||||
int32_t bmp180_b5 = xt1 + xt2;
|
||||
bmp_sensors[bmp_idx].bmp_temperature = ((bmp180_b5 + 8) >> 4) / 10.0f;
|
||||
|
||||
#ifdef ESP32
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_CONTROL, BMP180_PRESSURE3,bus); // Highest resolution
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_CONTROL, BMP180_PRESSURE3, bus); // Highest resolution
|
||||
delay(2 + (4 << BMP180_OSS)); // 26ms conversion time at ultra high resolution
|
||||
uint32_t up = I2cRead24(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_RESULT,bus);
|
||||
#else
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_CONTROL, BMP180_PRESSURE3); // Highest resolution
|
||||
delay(2 + (4 << BMP180_OSS)); // 26ms conversion time at ultra high resolution
|
||||
uint32_t up = I2cRead24(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_RESULT);
|
||||
#endif
|
||||
uint32_t up = I2cRead24(bmp_sensors[bmp_idx].bmp_address, BMP180_REG_RESULT, bus);
|
||||
up >>= (8 - BMP180_OSS);
|
||||
|
||||
int32_t b6 = bmp180_b5 - 4000;
|
||||
|
|
@ -270,8 +257,7 @@ typedef struct {
|
|||
|
||||
Bme280CalibrationData_t *Bme280CalibrationData = nullptr;
|
||||
|
||||
bool Bmx280Calibrate(uint8_t bmp_idx)
|
||||
{
|
||||
bool Bmx280Calibrate(uint8_t bmp_idx) {
|
||||
// if (I2cRead8(bmp_address, BMP_REGISTER_CHIPID) != BME280_CHIPID) return false;
|
||||
|
||||
if (!Bme280CalibrationData) {
|
||||
|
|
@ -279,46 +265,42 @@ bool Bmx280Calibrate(uint8_t bmp_idx)
|
|||
}
|
||||
if (!Bme280CalibrationData) { return false; }
|
||||
|
||||
uint8_t bus= (bmp_idx>=2) ? 1 : 0; // first two BMP's at bus 0, additional at bus 1 (ESP32 32 only)
|
||||
Bme280CalibrationData[bmp_idx].dig_T1 = I2cRead16LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_T1,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_T2 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_T2,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_T3 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_T3,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P1 = I2cRead16LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P1,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P2 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P2,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P3 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P3,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P4 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P4,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P5 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P5,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P6 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P6,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P7 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P7,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P8 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P8,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P9 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P9,bus);
|
||||
uint8_t bus = bmp_idx >>1; // First two BMP's at bus 0, additional at bus 1
|
||||
Bme280CalibrationData[bmp_idx].dig_T1 = I2cRead16LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_T1, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_T2 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_T2, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_T3 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_T3, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P1 = I2cRead16LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P1, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P2 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P2, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P3 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P3, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P4 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P4, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P5 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P5, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P6 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P6, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P7 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P7, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P8 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P8, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_P9 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_P9, bus);
|
||||
if (BME280_CHIPID == bmp_sensors[bmp_idx].bmp_type) { // #1051
|
||||
Bme280CalibrationData[bmp_idx].dig_H1 = I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H1,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_H2 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H2,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_H3 = I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H3,bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_H4 = (I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H4,bus) << 4) | (I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H4 + 1,bus) & 0xF);
|
||||
Bme280CalibrationData[bmp_idx].dig_H5 = (I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H5 + 1,bus) << 4) | (I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H5,bus>>1) >> 4);
|
||||
Bme280CalibrationData[bmp_idx].dig_H6 = (int8_t)I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H6,bus);
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_CONTROL, 0x00,bus); // sleep mode since writes to config can be ignored in normal mode (Datasheet 5.4.5/6 page 27)
|
||||
Bme280CalibrationData[bmp_idx].dig_H1 = I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H1, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_H2 = I2cReadS16_LE(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H2, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_H3 = I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H3, bus);
|
||||
Bme280CalibrationData[bmp_idx].dig_H4 = (I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H4, bus) << 4) | (I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H4 + 1,bus) & 0xF);
|
||||
Bme280CalibrationData[bmp_idx].dig_H5 = (I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H5 + 1, bus) << 4) | (I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H5,bus>>1) >> 4);
|
||||
Bme280CalibrationData[bmp_idx].dig_H6 = (int8_t)I2cRead8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_DIG_H6, bus);
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_CONTROL, 0x00, bus); // sleep mode since writes to config can be ignored in normal mode (Datasheet 5.4.5/6 page 27)
|
||||
// Set before CONTROL_meas (DS 5.4.3)
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_CONTROLHUMID, 0x01,bus); // 1x oversampling
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_CONFIG, 0xA0,bus); // 1sec standby between measurements (to limit self heating), IIR filter off
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_CONTROL, 0x27,bus); // 1x oversampling, normal mode
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_CONTROLHUMID, 0x01, bus); // 1x oversampling
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_CONFIG, 0xA0, bus); // 1sec standby between measurements (to limit self heating), IIR filter off
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_CONTROL, 0x27, bus); // 1x oversampling, normal mode
|
||||
} else {
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_CONTROL, 0xB7,bus); // 16x oversampling, normal mode (Adafruit)
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_CONTROL, 0xB7, bus); // 16x oversampling, normal mode (Adafruit)
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void Bme280Read(uint8_t bmp_idx)
|
||||
{
|
||||
void Bme280Read(uint8_t bmp_idx) {
|
||||
if (!Bme280CalibrationData) { return; }
|
||||
|
||||
#ifdef ESP32
|
||||
int32_t adc_T = I2cRead24(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_TEMPDATA,bmp_idx>>1);
|
||||
#else
|
||||
int32_t adc_T = I2cRead24(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_TEMPDATA);
|
||||
#endif
|
||||
uint8_t bus = bmp_idx >>1; // First two BMP's at bus 0, additional at bus 1
|
||||
int32_t adc_T = I2cRead24(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_TEMPDATA, bus);
|
||||
adc_T >>= 4;
|
||||
|
||||
int32_t vart1 = ((((adc_T >> 3) - ((int32_t)Bme280CalibrationData[bmp_idx].dig_T1 << 1))) * ((int32_t)Bme280CalibrationData[bmp_idx].dig_T2)) >> 11;
|
||||
|
|
@ -327,11 +309,8 @@ void Bme280Read(uint8_t bmp_idx)
|
|||
int32_t t_fine = vart1 + vart2;
|
||||
float T = (t_fine * 5 + 128) >> 8;
|
||||
bmp_sensors[bmp_idx].bmp_temperature = T / 100.0f;
|
||||
#ifdef ESP32
|
||||
int32_t adc_P = I2cRead24(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_PRESSUREDATA,bmp_idx>>1);
|
||||
#else
|
||||
int32_t adc_P = I2cRead24(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_PRESSUREDATA);
|
||||
#endif
|
||||
|
||||
int32_t adc_P = I2cRead24(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_PRESSUREDATA, bus);
|
||||
adc_P >>= 4;
|
||||
|
||||
int64_t var1 = ((int64_t)t_fine) - 128000;
|
||||
|
|
@ -351,11 +330,9 @@ void Bme280Read(uint8_t bmp_idx)
|
|||
bmp_sensors[bmp_idx].bmp_pressure = (float)p / 25600.0f;
|
||||
|
||||
if (BMP280_CHIPID == bmp_sensors[bmp_idx].bmp_type) { return; }
|
||||
#ifdef ESP32
|
||||
int32_t adc_H = I2cRead16(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_HUMIDDATA,bmp_idx>>1);
|
||||
#else
|
||||
int32_t adc_H = I2cRead16(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_HUMIDDATA);
|
||||
#endif
|
||||
|
||||
int32_t adc_H = I2cRead16(bmp_sensors[bmp_idx].bmp_address, BME280_REGISTER_HUMIDDATA, bus);
|
||||
|
||||
int32_t v_x1_u32r = (t_fine - ((int32_t)76800));
|
||||
v_x1_u32r = (((((adc_H << 14) - (((int32_t)Bme280CalibrationData[bmp_idx].dig_H4) << 20) -
|
||||
(((int32_t)Bme280CalibrationData[bmp_idx].dig_H5) * v_x1_u32r)) + ((int32_t)16384)) >> 15) *
|
||||
|
|
@ -440,8 +417,7 @@ bool Bme680Init(uint8_t bmp_idx) {
|
|||
return true;
|
||||
}
|
||||
|
||||
void Bme680Read(uint8_t bmp_idx)
|
||||
{
|
||||
void Bme680Read(uint8_t bmp_idx) {
|
||||
if (!bme_dev) { return; }
|
||||
|
||||
int8_t rslt = BME68X_OK;
|
||||
|
|
@ -488,8 +464,7 @@ void Bme680Read(uint8_t bmp_idx)
|
|||
|
||||
/********************************************************************************************/
|
||||
|
||||
void BmpDetect(void)
|
||||
{
|
||||
void BmpDetect(void) {
|
||||
int bmp_sensor_size = BMP_MAX_SENSORS * sizeof(bmp_sensors_t);
|
||||
if (!bmp_sensors) {
|
||||
bmp_sensors = (bmp_sensors_t*)malloc(bmp_sensor_size);
|
||||
|
|
@ -498,19 +473,14 @@ void BmpDetect(void)
|
|||
memset(bmp_sensors, 0, bmp_sensor_size); // Init defaults to 0
|
||||
|
||||
for (uint32_t i = 0; i < BMP_MAX_SENSORS; i++) {
|
||||
uint8_t bmp_type = 0;
|
||||
#ifdef ESP32
|
||||
uint8_t bus = (i>=2) ? 1 : 0;
|
||||
uint8_t bus = i >>1;
|
||||
if (!I2cSetDevice(bmp_addresses[i], bus)) { continue; }
|
||||
bmp_type = I2cRead8(bmp_addresses[i], BMP_REGISTER_CHIPID, bus);
|
||||
#else
|
||||
if (!I2cSetDevice(bmp_addresses[i])) { continue; }
|
||||
bmp_type = I2cRead8(bmp_addresses[i], BMP_REGISTER_CHIPID);
|
||||
#endif
|
||||
uint8_t bmp_type = I2cRead8(bmp_addresses[i], BMP_REGISTER_CHIPID, bus);
|
||||
if (bmp_type) {
|
||||
bmp_sensors[bmp_count].bmp_address = bmp_addresses[i];
|
||||
bmp_sensors[bmp_count].bmp_type = bmp_type;
|
||||
bmp_sensors[bmp_count].bmp_model = 0;
|
||||
|
||||
bool success = false;
|
||||
switch (bmp_type) {
|
||||
case BMP180_CHIPID:
|
||||
|
|
@ -531,19 +501,14 @@ void BmpDetect(void)
|
|||
}
|
||||
if (success) {
|
||||
GetTextIndexed(bmp_sensors[bmp_count].bmp_name, sizeof(bmp_sensors[bmp_count].bmp_name), bmp_sensors[bmp_count].bmp_model, kBmpTypes);
|
||||
#ifdef ESP32
|
||||
I2cSetActiveFound(bmp_sensors[bmp_count].bmp_address, bmp_sensors[bmp_count].bmp_name,bus);
|
||||
#else
|
||||
I2cSetActiveFound(bmp_sensors[bmp_count].bmp_address, bmp_sensors[bmp_count].bmp_name);
|
||||
#endif
|
||||
I2cSetActiveFound(bmp_sensors[bmp_count].bmp_address, bmp_sensors[bmp_count].bmp_name, bus);
|
||||
bmp_count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void BmpRead(void)
|
||||
{
|
||||
void BmpRead(void) {
|
||||
for (uint32_t bmp_idx = 0; bmp_idx < bmp_count; bmp_idx++) {
|
||||
switch (bmp_sensors[bmp_idx].bmp_type) {
|
||||
case BMP180_CHIPID:
|
||||
|
|
@ -569,30 +534,20 @@ void BmpShow(bool json)
|
|||
float bmp_sealevel = ConvertPressureForSeaLevel(bmp_sensors[bmp_idx].bmp_pressure);
|
||||
float bmp_temperature = ConvertTemp(bmp_sensors[bmp_idx].bmp_temperature);
|
||||
float bmp_pressure = ConvertPressure(bmp_sensors[bmp_idx].bmp_pressure);
|
||||
#ifdef ESP32
|
||||
|
||||
char name[12];
|
||||
if (TasmotaGlobal.i2c_enabled_2)
|
||||
{
|
||||
strlcpy(name, bmp_sensors[bmp_idx].bmp_name, sizeof(bmp_sensors[bmp_idx].bmp_name));
|
||||
uint8_t bus= (bmp_idx>=2) ? 1 : 0;
|
||||
strlcpy(name, bmp_sensors[bmp_idx].bmp_name, sizeof(bmp_sensors[bmp_idx].bmp_name));
|
||||
#ifdef ESP32
|
||||
if (TasmotaGlobal.i2c_enabled_2) {
|
||||
uint8_t bus = bmp_idx >>1;
|
||||
if (bmp_count > 1) {
|
||||
snprintf_P(name, sizeof(name), PSTR("%s%c%02X%c%1d"), name, IndexSeparator(), bmp_sensors[bmp_idx].bmp_address,IndexSeparator(),bus); // BMXXXX-XX-X
|
||||
snprintf_P(name, sizeof(name), PSTR("%s%c%02X%c%1d"), name, IndexSeparator(), bmp_sensors[bmp_idx].bmp_address, IndexSeparator(), bus); // BMXXXX-XX-X
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
strlcpy(name, bmp_sensors[bmp_idx].bmp_name, sizeof(bmp_sensors[bmp_idx].bmp_name));
|
||||
if (bmp_count > 1) {
|
||||
snprintf_P(name, sizeof(name), PSTR("%s%c%02X"), name, IndexSeparator(), bmp_sensors[bmp_idx].bmp_address); // BMXXXX-XX
|
||||
}
|
||||
}
|
||||
#else
|
||||
char name[10];
|
||||
strlcpy(name, bmp_sensors[bmp_idx].bmp_name, sizeof(name));
|
||||
} else
|
||||
#endif
|
||||
if (bmp_count > 1) {
|
||||
snprintf_P(name, sizeof(name), PSTR("%s%c%02X"), name, IndexSeparator(), bmp_sensors[bmp_idx].bmp_address); // BMXXXX-XX
|
||||
}
|
||||
#endif
|
||||
|
||||
char pressure[33];
|
||||
dtostrfd(bmp_pressure, Settings->flag2.pressure_resolution, pressure);
|
||||
|
|
@ -672,20 +627,14 @@ void BmpShow(bool json)
|
|||
|
||||
#ifdef USE_DEEPSLEEP
|
||||
|
||||
void BMP_EnterSleep(void)
|
||||
{
|
||||
void BMP_EnterSleep(void) {
|
||||
if (DeepSleepEnabled()) {
|
||||
for (uint32_t bmp_idx = 0; bmp_idx < bmp_count; bmp_idx++) {
|
||||
switch (bmp_sensors[bmp_idx].bmp_type) {
|
||||
case BMP180_CHIPID:
|
||||
case BMP280_CHIPID:
|
||||
case BME280_CHIPID:
|
||||
#ifdef ESP32
|
||||
uint8_t bus= (bmp_idx>=2) ? 1 : 0;
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BMP_REGISTER_RESET, BMP_CMND_RESET,bus);
|
||||
#else
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BMP_REGISTER_RESET, BMP_CMND_RESET);
|
||||
#endif
|
||||
I2cWrite8(bmp_sensors[bmp_idx].bmp_address, BMP_REGISTER_RESET, BMP_CMND_RESET, bmp_idx >>1);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
|
|
|||
Loading…
Reference in New Issue