Fix QMP6988

arendst · arendst · commit 7bde0b89d12c · 2024-06-12T10:50:29.000+02:00
diff --git a/tasmota/tasmota_support/support_a_i2c.ino b/tasmota/tasmota_support/support_a_i2c.ino
@@ -58,6 +58,10 @@ TwoWire& I2cGetWire(uint8_t bus = 0) {
   }
 }
 
+/*-------------------------------------------------------------------------------------------*\
+ * Return code: 0 = Error, 1 = OK
+\*-------------------------------------------------------------------------------------------*/
+
 bool I2cValidRead(uint8_t addr, uint8_t reg, uint8_t size, uint8_t bus = 0) {
   i2c_buffer = 0;
 
@@ -75,51 +79,51 @@ bool I2cValidRead(uint8_t addr, uint8_t reg, uint8_t size, uint8_t bus = 0) {
         for (uint32_t i = 0; i < size; i++) {
           i2c_buffer = i2c_buffer << 8 | myWire.read();   // receive DATA
         }
-        status = true;
+        status = true;                                    // 1 = OK
       }
     }
     retry--;
   }
   if (!retry) myWire.endTransmission();
-  return status;
+  return status;                                          // 0 = Error, 1 = OK
 }
 
 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;
+  return status;                                          // 0 = Error, 1 = OK
 }
 
 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;
+  return status;                                          // 0 = Error, 1 = OK
 }
 
 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;
+  return status;                                          // 0 = Error, 1 = OK
 }
 
 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;
+  return status;                                          // 0 = Error, 1 = OK
 }
 
 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;
+  return status;                                          // 0 = Error, 1 = OK
 }
 
 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;
+  return status;                                          // 0 = Error, 1 = OK
 }
 
 uint8_t I2cRead8(uint8_t addr, uint8_t reg, uint8_t bus = 0) {
@@ -166,37 +170,41 @@ bool I2cWrite(uint8_t addr, uint8_t reg, uint32_t val, uint8_t size, uint8_t bus
     }
     x--;
   } while (myWire.endTransmission(true) != 0 && x != 0);  // end transmission
-  return (x);
+  return (x);                                             // 0 = Error, 1 = OK
 }
 
 bool I2cWrite8(uint8_t addr, uint8_t reg, uint32_t val, uint8_t bus = 0) {
-   return I2cWrite(addr, reg, val, 1, bus);
+   return I2cWrite(addr, reg, val, 1, bus);               // 0 = Error, 1 = OK
 }
 
 bool I2cWrite16(uint8_t addr, uint8_t reg, uint32_t val, uint8_t bus = 0) {
-   return I2cWrite(addr, reg, val, 2, bus);
+   return I2cWrite(addr, reg, val, 2, bus);               // 0 = Error, 1 = OK
 }
 
+/*-------------------------------------------------------------------------------------------*\
+ * Return code: 0 = OK, 1 = Error
+\*-------------------------------------------------------------------------------------------*/
+
 bool I2cReadBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len, uint8_t bus = 0) {
   TwoWire& myWire = I2cGetWire(bus);
-  if (&myWire == nullptr) { return true; }               // No valid I2c bus
+  if (&myWire == nullptr) { return true; }                // No valid I2c bus
 
   myWire.beginTransmission((uint8_t)addr);
   myWire.write((uint8_t)reg);
   myWire.endTransmission();
   if (len != myWire.requestFrom((uint8_t)addr, (uint8_t)len)) {
-    return true;  // Error
+    return true;                                          // 1 = Error
   }
   while (len--) {
     *reg_data = (uint8_t)myWire.read();
     reg_data++;
   }
-  return false;  // OK
+  return false;                                           // 0 = OK
 }
 
 int8_t I2cWriteBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len, uint8_t bus = 0) {
   TwoWire& myWire = I2cGetWire(bus);
-  if (&myWire == nullptr) { return 1; }                   // No valid I2c bus
+  if (&myWire == nullptr) { return 1; }                   // 1 = Error, No valid I2c bus
 
   myWire.beginTransmission((uint8_t)addr);
   myWire.write((uint8_t)reg);
@@ -205,9 +213,11 @@ int8_t I2cWriteBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len
     reg_data++;
   }
   myWire.endTransmission();
-  return 0;  // OK
+  return 0;                                               // 0 = OK
 }
 
+/*-------------------------------------------------------------------------------------------*/
+
 void I2cScan(uint8_t bus = 0) {
   // Return error codes defined in twi.h and core_esp8266_si2c.c
   // I2C_OK                      0
diff --git a/tasmota/tasmota_xsns_sensor/xsns_28_qmp6988.ino b/tasmota/tasmota_xsns_sensor/xsns_28_qmp6988.ino
@@ -125,11 +125,18 @@ qmp6988_data_t *Qmp6988 = nullptr;
 /*********************************************************************************************/
 
 bool QMP6988I2cReadBuffer(uint8_t reg, uint8_t *reg_data, uint16_t len) {
-  return I2cReadBuffer(Qmp6988->address, reg, reg_data, len, Qmp6988->bus);
+  bool ret = !I2cReadBuffer(Qmp6988->address, reg, reg_data, len, Qmp6988->bus);
+
+//  AddLog(LOG_LEVEL_DEBUG, PSTR("QMP: Rd %02X '%*_H', Rslt %d"), reg, len, reg_data, ret);
+
+  return ret;
 }
 
-uint8_t QMP6988I2cWrite(uint8_t reg, uint32_t val) {
-  uint8_t ret = I2cWrite8(Qmp6988->address, reg, val, Qmp6988->bus);
+bool QMP6988I2cWrite(uint8_t reg, uint32_t val) {
+  bool ret = I2cWrite8(Qmp6988->address, reg, val, Qmp6988->bus);
+
+//  AddLog(LOG_LEVEL_DEBUG, PSTR("QMP: Wr %02X '%02X', Rslt %d"), reg, val, ret);
+
   delay(20);
   return ret;
 }
@@ -272,7 +279,7 @@ int QMP6988GetPressure02e(qmp6988_ik_data_t* ik, int dp, int16_t tx) {
 void QMP6988Reset(void) {
   uint8_t ret = QMP6988I2cWrite(QMP6988_RESET_REG, 0xe6);
   if (0 == ret) {
-    AddLog(LOG_LEVEL_DEBUG, PSTR("QMP: Reset fail"));
+    QMP6988_LOG("reset fail!!! \r\n");
   }
   QMP6988I2cWrite(QMP6988_RESET_REG, 0x00);
 }
@@ -322,7 +329,7 @@ bool QMP6988ValidChip(void) {
   uint8_t data;
   QMP6988I2cReadBuffer(QMP6988_CHIP_ID_REG, &data, 1);
 
-  AddLog(LOG_LEVEL_DEBUG, PSTR("QMP: Chip Id 0x%02X"), data);
+  QMP6988_LOG("chip id=0x%x \r\n", data);
 
   return (QMP6988_CHIP_ID == data);
 }
@@ -345,7 +352,7 @@ void QMP6988CalcPressureAndTemperature(void) {
   int P_int = QMP6988GetPressure02e(&(Qmp6988->ik), P_raw, T_int);
 
   Qmp6988->temperature = (float)T_int / 256.0f;
-  Qmp6988->pressure    = (float)P_int / 16.0f;
+  Qmp6988->pressure    = (float)P_int / 1600.0f;
 }
 
 void Qmp6988Detect(void) {

Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,10 @@ TwoWire& I2cGetWire(uint8_t bus = 0) {`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
	`61`	`+/-------------------------------------------------------------------------------------------\`
	`62`	`+ * Return code: 0 = Error, 1 = OK`
	`63`	`+\-------------------------------------------------------------------------------------------/`
	`64`	`+`
`61`	`65`	`bool I2cValidRead(uint8_t addr, uint8_t reg, uint8_t size, uint8_t bus = 0) {`
`62`	`66`	`i2c_buffer = 0;`
`63`	`67`
`@@ -75,51 +79,51 @@ bool I2cValidRead(uint8_t addr, uint8_t reg, uint8_t size, uint8_t bus = 0) {`
`75`	`79`	`for (uint32_t i = 0; i < size; i++) {`
`76`	`80`	`i2c_buffer = i2c_buffer << 8 \| myWire.read(); // receive DATA`
`77`	`81`	`}`
`78`		`- status = true;`
	`82`	`+ status = true; // 1 = OK`
`79`	`83`	`}`
`80`	`84`	`}`
`81`	`85`	`retry--;`
`82`	`86`	`}`
`83`	`87`	`if (!retry) myWire.endTransmission();`
`84`		`- return status;`
	`88`	`+ return status; // 0 = Error, 1 = OK`
`85`	`89`	`}`
`86`	`90`
`87`	`91`	`bool I2cValidRead8(uint8_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {`
`88`	`92`	`bool status = I2cValidRead(addr, reg, 1, bus);`
`89`	`93`	`*data = (uint8_t)i2c_buffer;`
`90`		`- return status;`
	`94`	`+ return status; // 0 = Error, 1 = OK`
`91`	`95`	`}`
`92`	`96`
`93`	`97`	`bool I2cValidRead16(uint16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {`
`94`	`98`	`bool status = I2cValidRead(addr, reg, 2, bus);`
`95`	`99`	`*data = (uint16_t)i2c_buffer;`
`96`		`- return status;`
	`100`	`+ return status; // 0 = Error, 1 = OK`
`97`	`101`	`}`
`98`	`102`
`99`	`103`	`bool I2cValidReadS16(int16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {`
`100`	`104`	`bool status = I2cValidRead(addr, reg, 2, bus);`
`101`	`105`	`*data = (int16_t)i2c_buffer;`
`102`		`- return status;`
	`106`	`+ return status; // 0 = Error, 1 = OK`
`103`	`107`	`}`
`104`	`108`
`105`	`109`	`bool I2cValidRead16LE(uint16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {`
`106`	`110`	`uint16_t ldata;`
`107`	`111`	`bool status = I2cValidRead16(&ldata, addr, reg, bus);`
`108`	`112`	`*data = (ldata >> 8) \| (ldata << 8);`
`109`		`- return status;`
	`113`	`+ return status; // 0 = Error, 1 = OK`
`110`	`114`	`}`
`111`	`115`
`112`	`116`	`bool I2cValidReadS16_LE(int16_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {`
`113`	`117`	`uint16_t ldata;`
`114`	`118`	`bool status = I2cValidRead16LE(&ldata, addr, reg, bus);`
`115`	`119`	`*data = (int16_t)ldata;`
`116`		`- return status;`
	`120`	`+ return status; // 0 = Error, 1 = OK`
`117`	`121`	`}`
`118`	`122`
`119`	`123`	`bool I2cValidRead24(int32_t *data, uint8_t addr, uint8_t reg, uint8_t bus = 0) {`
`120`	`124`	`bool status = I2cValidRead(addr, reg, 3, bus);`
`121`	`125`	`*data = i2c_buffer;`
`122`		`- return status;`
	`126`	`+ return status; // 0 = Error, 1 = OK`
`123`	`127`	`}`
`124`	`128`
`125`	`129`	`uint8_t I2cRead8(uint8_t addr, uint8_t reg, uint8_t bus = 0) {`
`@@ -166,37 +170,41 @@ bool I2cWrite(uint8_t addr, uint8_t reg, uint32_t val, uint8_t size, uint8_t bus`
`166`	`170`	`}`
`167`	`171`	`x--;`
`168`	`172`	`} while (myWire.endTransmission(true) != 0 && x != 0); // end transmission`
`169`		`- return (x);`
	`173`	`+ return (x); // 0 = Error, 1 = OK`
`170`	`174`	`}`
`171`	`175`
`172`	`176`	`bool I2cWrite8(uint8_t addr, uint8_t reg, uint32_t val, uint8_t bus = 0) {`
`173`		`- return I2cWrite(addr, reg, val, 1, bus);`
	`177`	`+ return I2cWrite(addr, reg, val, 1, bus); // 0 = Error, 1 = OK`
`174`	`178`	`}`
`175`	`179`
`176`	`180`	`bool I2cWrite16(uint8_t addr, uint8_t reg, uint32_t val, uint8_t bus = 0) {`
`177`		`- return I2cWrite(addr, reg, val, 2, bus);`
	`181`	`+ return I2cWrite(addr, reg, val, 2, bus); // 0 = Error, 1 = OK`
`178`	`182`	`}`
`179`	`183`
	`184`	`+/-------------------------------------------------------------------------------------------\`
	`185`	`+ * Return code: 0 = OK, 1 = Error`
	`186`	`+\-------------------------------------------------------------------------------------------/`
	`187`	`+`
`180`	`188`	`bool I2cReadBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len, uint8_t bus = 0) {`
`181`	`189`	`TwoWire& myWire = I2cGetWire(bus);`
`182`		`- if (&myWire == nullptr) { return true; } // No valid I2c bus`
	`190`	`+ if (&myWire == nullptr) { return true; } // No valid I2c bus`
`183`	`191`
`184`	`192`	`myWire.beginTransmission((uint8_t)addr);`
`185`	`193`	`myWire.write((uint8_t)reg);`
`186`	`194`	`myWire.endTransmission();`
`187`	`195`	`if (len != myWire.requestFrom((uint8_t)addr, (uint8_t)len)) {`
`188`		`- return true; // Error`
	`196`	`+ return true; // 1 = Error`
`189`	`197`	`}`
`190`	`198`	`while (len--) {`
`191`	`199`	`*reg_data = (uint8_t)myWire.read();`
`192`	`200`	`reg_data++;`
`193`	`201`	`}`
`194`		`- return false; // OK`
	`202`	`+ return false; // 0 = OK`
`195`	`203`	`}`
`196`	`204`
`197`	`205`	`int8_t I2cWriteBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len, uint8_t bus = 0) {`
`198`	`206`	`TwoWire& myWire = I2cGetWire(bus);`
`199`		`- if (&myWire == nullptr) { return 1; } // No valid I2c bus`
	`207`	`+ if (&myWire == nullptr) { return 1; } // 1 = Error, No valid I2c bus`
`200`	`208`
`201`	`209`	`myWire.beginTransmission((uint8_t)addr);`
`202`	`210`	`myWire.write((uint8_t)reg);`
`@@ -205,9 +213,11 @@ int8_t I2cWriteBuffer(uint8_t addr, uint8_t reg, uint8_t *reg_data, uint16_t len`
`205`	`213`	`reg_data++;`
`206`	`214`	`}`
`207`	`215`	`myWire.endTransmission();`
`208`		`- return 0; // OK`
	`216`	`+ return 0; // 0 = OK`
`209`	`217`	`}`
`210`	`218`
	`219`	`+/-------------------------------------------------------------------------------------------/`
	`220`	`+`
`211`	`221`	`void I2cScan(uint8_t bus = 0) {`
`212`	`222`	`// Return error codes defined in twi.h and core_esp8266_si2c.c`
`213`	`223`	`// I2C_OK 0`