Tasmota/tasmota/xsns_63_aht1x.ino

/*
  xsns_63_AHT1x.ino - AHT10 I2C temperature and humidity sensor support for Tasmota

  Copyright (C) 2020  Martin Wagner

  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_AHT1x
/*********************************************************************************************\
 * AHT10/15 - Temperature and Humidity
 *
 * I2C Address: 0x38
 *
 * Attention: this Sensor is incompatible with other I2C devices on I2C bus.
 *
 * The Datasheet write:
 * "Only a single AHT10 can be connected to the I2C bus and no other I2C
 *  devices can be connected".
 *
 * after lot of search and tests, now is confirmed that works only reliable with one sensor
 * on I2C Bus
\*********************************************************************************************/

#define XSNS_63              63
#define XI2C_43              43  // See I2CDEVICES.md

#define AHT1X_ADDR1          0x38
#define AHT1X_ADDR2          0x39

#define AHT1X_MAX_SENSORS    2

#define AHT_HUMIDITY_CONST      100
#define AHT_TEMPERATURE_CONST   200
#define AHT_TEMPERATURE_OFFSET  50
#define KILOBYTE_CONST          1048576.0f

#define AHT1X_CMD_DELAY      40
#define AHT1X_RST_DELAY      30
#define AHT1X_MEAS_DELAY     80 // over 75ms in datasheet

uint8_t AHTSetCalCmd[3]    = {0xE1, 0x08, 00}; //load factory calibration coeff
uint8_t AHTSetCycleCmd[3]  = {0xE1, 0x28, 00}; //enable cycle mode
uint8_t AHTMeasureCmd[3]   = {0xAC, 0x33, 00}; //start measurment command
uint8_t AHTResetCmd        = 0xBA;             //soft reset command

const char ahtTypes[] PROGMEM = "AHT1X|AHT1X";
uint8_t aht1x_addresses[] = { AHT1X_ADDR1, AHT1X_ADDR2 };
uint8_t aht1x_count  = 0;
uint8_t aht1x_Pcount = 0;

struct AHT1XSTRUCT
{
  float   humidity = NAN;
  float   temperature = NAN;
  uint8_t address;    // bus address
  char    types[6];   // Sensor type name and address -
} aht1x_sensors[AHT1X_MAX_SENSORS];

bool AHT1XWrite(uint8_t aht1x_idx)
{
  Wire.beginTransmission(aht1x_sensors[aht1x_idx].address);
  Wire.write(AHTMeasureCmd, 3);
  if (Wire.endTransmission() != 0)
    return false;
}

bool AHT1XRead(uint8_t aht1x_idx)
{
  uint8_t data[6];
  Wire.requestFrom(aht1x_sensors[aht1x_idx].address, (uint8_t) 6);
  for(uint8_t i = 0; Wire.available() > 0; i++){
     data[i] = Wire.read();
   }
   if ((data[0] & 0x80) == 0x80) return false; //device is busy

  aht1x_sensors[aht1x_idx].humidity    = (((data[1] << 12)| (data[2] << 4) | data[3] >> 4) * AHT_HUMIDITY_CONST / KILOBYTE_CONST);
  aht1x_sensors[aht1x_idx].temperature = ((AHT_TEMPERATURE_CONST * (((data[3] & 0x0F) << 16) | (data[4] << 8) | data[5]) / KILOBYTE_CONST) - AHT_TEMPERATURE_OFFSET);

  return (!isnan(aht1x_sensors[aht1x_idx].temperature) && !isnan(aht1x_sensors[aht1x_idx].humidity) && (aht1x_sensors[aht1x_idx].humidity != 0));
}

/********************************************************************************************/

// Test for Polling the device without delays
// Incompatible with other devices on I2C bus
void AHT1XPoll(void) // We have 100ms for read. Sensor needs 80-95 ms
{
  aht1x_Pcount++;
   switch (aht1x_Pcount) {
    case 10:
      AHT1XWrite(0);
      break;
    case 11:
      if (AHT1XRead(0)){
        ConvertTemp(aht1x_sensors[0].temperature);   // Set global temperature
        ConvertHumidity(aht1x_sensors[0].humidity);  // Set global humidity
      }
      aht1x_Pcount = 0;
      break;
    }
}

unsigned char AHT1XReadStatus(uint8_t aht1x_address)
{
  uint8_t result = 0;
  Wire.requestFrom(aht1x_address, (uint8_t) 1);
  result = Wire.read();
  return result;
}

void AHT1XReset(uint8_t aht1x_address)
{
  Wire.beginTransmission(aht1x_address);
  Wire.write(AHTResetCmd);
  Wire.endTransmission();
  delay(AHT1X_RST_DELAY);
}

/********************************************************************************************/
bool AHT1XInit(uint8_t aht1x_address)
{
  Wire.beginTransmission(aht1x_address);
  Wire.write(AHTSetCalCmd, 3);
  if (Wire.endTransmission() != 0) return false;
  delay(AHT1X_CMD_DELAY);
  if((AHT1XReadStatus(aht1x_address) & 0x68) == 0x08) // Sensor calcoef aktiv
    return true;
  return false;
}

void AHT1XDetect(void)
{
  for (uint8_t i = 0; i < AHT1X_MAX_SENSORS; i++) {
    if (I2cActive(aht1x_addresses[i])) { continue; }
    if (AHT1XInit(aht1x_addresses[i]))
    {
      aht1x_sensors[aht1x_count].address = aht1x_addresses[i];
      GetTextIndexed(aht1x_sensors[aht1x_count].types, sizeof(aht1x_sensors[aht1x_count].types), i, ahtTypes);
      I2cSetActiveFound(aht1x_sensors[aht1x_count].address, aht1x_sensors[aht1x_count].types);
      aht1x_count = 1;
      break; // Only one Sensor allowed at the moment (I2C Sensor-Bug)
    }
  }
}

void AHT1XShow(bool json)
{
  for (uint32_t i = 0; i < aht1x_count; i++) {
    float tem = ConvertTemp(aht1x_sensors[i].temperature);
    float hum = ConvertHumidity(aht1x_sensors[i].humidity);
    char types[11]; // AHT1X-0x38
    snprintf_P(types, sizeof(types), PSTR("%s%c0x%02X"), aht1x_sensors[i].types, IndexSeparator(), aht1x_sensors[i].address);  // "X-0xXX"
    TempHumDewShow(json, ((0 == tele_period) && (0 == i)), types, tem, hum);
  }
}

/*********************************************************************************************\
 * Interface
\*********************************************************************************************/

bool Xsns63(uint8_t function)
{
  if (!I2cEnabled(XI2C_43)) { return false; }
  bool result = false;

  if (FUNC_INIT == function) {
    AHT1XDetect();
  }
  else if (aht1x_count){
    switch (function) {
      case FUNC_EVERY_100_MSECOND:
        AHT1XPoll();
        break;
      case FUNC_JSON_APPEND:
        AHT1XShow(1);
        break;
  #ifdef USE_WEBSERVER
      case FUNC_WEB_SENSOR:
        AHT1XShow(0);
        break;
  #endif  // USE_WEBSERVER
    }
  }
  return result;
}

#endif  // USE_AHT1X
#endif  // USE_I2C