HDC2080.c

Go to the documentation of this file.

/**
 * \file HDC2080.c
 * \brief Description: This library facilitates communication with, and configuration of,
 * the HDC2080 Temperature and Humidity Sensor. It makes extensive use of the
 * Wire.H library, and should be useable with both Arduino and Energia.
 *
 * \note code is release AS-IS into the public domain, no guarantee or warranty is given.
 *
 * \author HDC2010.cpp originally created by: Brandon Fisher, August 1st 2017
 */
#include "jfet_files/HDC2080.h"
#include "jfet_files/jfet_common.h"
#include <stdint.h>
#include <stdio.h>
#include <zephyr/drivers/i2c.h>
 
/**
 * \fn float readTemp(void)
 *
 * \brief Reads the temperature data from the HDC2080 sensor.
 *
 * \return Temperature in degrees Celsius.
 */
float readTemp(void) {
  uint8_t byte[2];
  int err;
  uint16_t temp;
  float f;
 
  /* Read two bytes starting from the TEMP_LOW register */
  err = readReg(TEMP_LOW, byte, 2);
  /* Combine high and low bytes into a 16-bit value */
  temp = (byte[1] << 8) | byte[0];
  /* Convert raw digital value to Celsius using datasheet formula */
  f = ((temp * 165.0f) / 65536.0f) - 40.0f;
  return f;
}
 
/**
 * \fn uint8_t readTempOffsetAdjust(void)
 *
 * \brief Reads the temperature offset adjustment value.
 *
 * \return The 8-bit offset value from the register.
 */
uint8_t readTempOffsetAdjust(void) {
  uint8_t byte[2];
 
  /* Read the offset register */
  readReg(TEMP_OFFSET_ADJUST, byte, 1);
  return byte[0];
}
 
/**
 * \fn uint8_t setTempOffsetAdjust(uint8_t value)
 *
 * \brief Sets the temperature offset adjustment value.
 *
 * \param value The 8-bit offset value to write (see datasheet page 22).
 *
 * \return The value read back from the register after writing.
 */
uint8_t setTempOffsetAdjust(uint8_t value) {
  uint8_t byte[2];
 
  byte[0] = value;
  /* Write the new offset to the sensor */
  writeReg(TEMP_OFFSET_ADJUST, byte, 1);
  return readTempOffsetAdjust();
}
 
/**
 * \fn float readHumidity(void)
 *
 * \brief Reads the relative humidity from the HDC2080 sensor.
 *
 * \return Relative humidity as a percentage (0.0 to 100.0).
 */
float readHumidity(void) {
  uint8_t byte[2];
  int err;
  uint16_t humidity;
  float f;
 
  /* Read two bytes starting from the HUMID_LOW register */
  err = readReg(HUMID_LOW, byte, 2);
  /* Combine high and low bytes */
  humidity = (byte[1] << 8) | byte[0];
  /* Convert raw value to percentage relative humidity */
  f = (humidity / 65536.0f) * 100.0f;
  return f;
}
 
/**
 * \fn uint8_t readHumidityOffsetAdjust(void)
 *
 * \brief Reads the humidity offset adjustment value from the sensor.
 *
 * \return The 8-bit offset value from the HUM_OFFSET_ADJUST register.
 */
uint8_t readHumidityOffsetAdjust(void) {
  uint8_t byte[2];
 
  /* Read the humidity offset register */
  readReg(HUM_OFFSET_ADJUST, byte, 1);
  return byte[0];
}
 
// Página 23 do datasheet
/**
 * \fn uint8_t setHumidityOffsetAdjust(uint8_t value)
 *
 * \brief Sets the humidity offset adjustment value.
 *
 * \param value The 8-bit offset value to write.
 *
 * \return The value read back from the register after writing.
 */
uint8_t setHumidityOffsetAdjust(uint8_t value) {
  uint8_t byte[2];
 
  byte[0] = value;
  /* Write the new offset to the sensor */
  writeReg(HUM_OFFSET_ADJUST, byte, 1);
  return readHumidityOffsetAdjust();
}
 
/**
 * \fn void enableHeater(void)
 *
 * \brief Enables the internal heating element of the HDC2080.
 */
void enableHeater(void) {
  int err;
  uint8_t configContents; // Stores current contents of config register
 
  err = readReg(HDC_CONFIG, &configContents, 1);
 
  // set bit 3 to 1 to enable heater
  configContents = (configContents | 0x08);
 
  writeReg(HDC_CONFIG, &configContents, 1);
}
 
/**
 * \fn void disableHeater(void)
 *
 * \brief Disables the internal heating element of the HDC2080.
 */
void disableHeater(void) {
  int err;
  uint8_t configContents; // Stores current contents of config register
 
  err = readReg(HDC_CONFIG, &configContents, 1);
 
  // set bit 3 to 0 to disable heater (all other bits 1)
  configContents = (configContents & 0xF7);
  writeReg(HDC_CONFIG, &configContents, 1);
}
 
/**
 * \fn uint8_t readReg(uint8_t reg, uint8_t *data, uint8_t count)
 *
 * \brief Reads a specified number of bytes from a sensor register over I2C.
 *
 * \param reg The register address to read from.
 * \param data Pointer to the buffer where received data will be stored.
 * \param count Number of bytes to read.
 *
 * \return Returns TRUE (1) upon completion.
 */
uint8_t readReg(uint8_t reg, uint8_t *data, uint8_t count) {
  uint8_t dataOut[6];
 
  dataOut[0] = reg;
  //    if (i2c_write(i2c_dev, dataOut, 1, HDC_ADDRESS))
  i2c_write(i2c_dev, dataOut, 1, HDC_ADDRESS);
  //    {
  //        myPrintkE("Fail to write to I2C\n");
  //        return FALSE;
  //    }
  //    if (i2c_read(i2c_dev, data, count, HDC_ADDRESS))
  i2c_read(i2c_dev, data, count, HDC_ADDRESS);
  //    {
  //        myPrintkE("Fail to read to I2C\n");
  //        return FALSE;
  //    }
  // printf("HDC2080 read reg: 0x%02X count: %d\r\n",reg,count);
  // for(int i=0; i<count; i++)
  // printf("i:%d 0x%02X\r\n",i, data[i]);
  return TRUE;
}
 
/**
 * \fn uint8_t writeReg(uint8_t reg, uint8_t *data, uint8_t count)
 *
 * \brief Writes a specified number of bytes to a sensor register over I2C.
 *
 * \param reg The register address to write to.
 *
 * \param data Pointer to the buffer containing data to be written.
 * \param count Number of bytes to write.
 *
 * \return Returns TRUE (1) upon completion.
 */
uint8_t writeReg(uint8_t reg, uint8_t *data, uint8_t count) {
  uint8_t datas[10];
  int i;
  // printf("HDC2080 write reg: 0x%02X count: %d\r\n",reg,count);
  // for(int i=0; i<count; i++)
  // printf("i:%d 0x%02X\r\n",i, data[i]);
 
  /* load array with register and data */
  datas[0] = reg;
  for (i = 0; i < count; i++)
    datas[i + 1] = data[i];
 
  /* write data to HDC2080 */
  //    if (i2c_write(i2c_dev, datas, count + 1, HDC_ADDRESS))
  i2c_write(i2c_dev, datas, count + 1, HDC_ADDRESS);
  //    {
  //        myPrintkE("Fail to write to I2C\n");
  //        return FALSE;
  //    }
  return TRUE;
}
 
/**
 * \fn void setLowTemp(float temp)
 *
 * \brief Sets the low temperature threshold for the interrupt pin.
 *
 * \param temp Temperature threshold in degrees Celsius (-40 to 125).
 */
void setLowTemp(float temp) {
  uint8_t temp_thresh_low;
 
  // Verify user is not trying to set value outside bounds
  if (temp < -40.0f) {
    temp = -40.0f;
  } else if (temp > 125.0f) {
    temp = 125.0f;
  }
 
  // Calculate value to load into register
  temp_thresh_low = (uint8_t)(256.0f * (temp + 40.0f) / 165.0f);
 
  writeReg(TEMP_THR_L, &temp_thresh_low, 1);
}
 
/**
 * \fn void setHighTemp(float temp)
 *
 * \brief Sets the high temperature threshold for the interrupt pin.
 *
 * \param temp Temperature threshold in degrees Celsius (-40 to 125).
 */
void setHighTemp(float temp) {
  uint8_t temp_thresh_high;
 
  // Verify user is not trying to set value outside bounds
  if (temp < -40.0f) {
    temp = -40.0f;
  } else if (temp > 125.0f) {
    temp = 125.0f;
  }
 
  // Calculate value to load into register
  temp_thresh_high = (uint8_t)(256.0f * (temp + 40.0f) / 165.0f);
 
  writeReg(TEMP_THR_H, &temp_thresh_high, 1);
}
 
/**
 * \fn void setHighHumidity(float humid)
 *
 * \brief Sets the high humidity threshold for the interrupt pin.
 *
 * \param humid Humidity threshold in percentage (0 to 100).
 */
void setHighHumidity(float humid) {
  uint8_t humid_thresh;
 
  // Verify user is not trying to set value outside bounds
  if (humid < 0.0f) {
    humid = 0.0f;
  } else if (humid > 100.0f) {
    humid = 100.0f;
  }
 
  // Calculate value to load into register
  humid_thresh = (uint8_t)(256.0f * humid / 100.0f);
 
  writeReg(HUMID_THR_H, &humid_thresh, 1);
}
 
/**
 * \fn void setLowHumidity(float humid)
 *
 * \brief Sets the low humidity threshold for the interrupt pin.
 *
 * \param humid Humidity threshold in percentage (0 to 100).
 */
void setLowHumidity(float humid) {
  uint8_t humid_thresh;
 
  // Verify user is not trying to set value outside bounds
  if (humid < 0.0f) {
    humid = 0.0f;
  } else if (humid > 100.0f) {
    humid = 100.0f;
  }
 
  // Calculate value to load into register
  humid_thresh = (uint8_t)(256.0f * humid / 100.0f);
 
  writeReg(HUMID_THR_L, &humid_thresh, 1);
}
 
/**
 * \fn float readLowHumidityThreshold(void)
 *
 * \brief Reads the low humidity threshold currently set in the sensor.
 *
 * \return Humidity threshold as a percentage.
 */
float readLowHumidityThreshold(void) {
  int err;
  uint8_t regContents;
 
  err = readReg(HUMID_THR_L, &regContents, 1);
  float f = regContents;
  f = f * 100.0f / 256.0f;
  return f;
}
 
/**
 * \fn float readHighHumidityThreshold(void)
 *
 * \brief Reads the high humidity threshold currently set in the sensor.
 *
 * \return Humidity threshold as a percentage.
 */
float readHighHumidityThreshold(void) {
  int err;
  uint8_t regContents;
 
  err = readReg(HUMID_THR_H, &regContents, 1);
  float f = regContents;
  f = f * 100.0f / 256.0f;
  return f;
}
 
/**
 * \fn float readLowTempThreshold(void)
 *
 * \brief Reads the low temperature threshold currently set in the sensor.
 *
 * \return Temperature threshold in degrees Celsius.
 */
float readLowTempThreshold(void) {
  int err;
  uint8_t regContents;
 
  err = readReg(TEMP_THR_L, &regContents, 1);
  float f = regContents;
  f = (f * 165.0f / 256.0f) - 40.0f;
  return f;
}
 
/**
 * \fn float readHighTempThreshold(void)
 *
 * \brief Reads the high temperature threshold currently set in the sensor.
 *
 * \return Temperature threshold in degrees Celsius.
 */
float readHighTempThreshold(void) {
  int err;
  uint8_t regContents;
 
  err = readReg(TEMP_THR_H, &regContents, 1);
  float f = regContents;
  f = (f * 165.0f / 256.0f) - 40.0f;
 
  return f;
}
 
/* Upper two bits of the MEASUREMENT_CONFIG register controls
   the temperature resolution*/
/**
 * \fn void setTempRes(int resolution)
 *
 * \brief Sets the temperature measurement resolution.
 *
 * \param resolution 0 for 14-bit, 1 for 11-bit, 2 for 9-bit.
 */
void setTempRes(int resolution) {
  int err;
  uint8_t configContents;
 
  /* Read current measurement configuration */
  err = readReg(MEASUREMENT_CONFIG, &configContents, 1);
 
  switch (resolution) {
  case FOURTEEN_BIT:
    configContents = (configContents & 0x3F);
    break;
 
  case ELEVEN_BIT:
    configContents = (configContents & 0x7F);
    configContents = (configContents | 0x40);
    break;
 
  case NINE_BIT:
    configContents = (configContents & 0xBF);
    configContents = (configContents | 0x80);
    break;
 
  default:
    configContents = (configContents & 0x3F);
  }
 
  /* Write updated resolution bits back to sensor */
  writeReg(MEASUREMENT_CONFIG, &configContents, 1);
}
 
/*  Bits 5 and 6 of the MEASUREMENT_CONFIG register controls
        the humidity resolution*/
/**
 * \fn void setHumidRes(int resolution)
 *
 * \brief Sets the humidity measurement resolution.
 *
 * \param resolution 0 for 14-bit, 1 for 11-bit, 2 for 9-bit.
 */
void setHumidRes(int resolution) {
  int err;
  uint8_t configContents;
 
  err = readReg(MEASUREMENT_CONFIG, &configContents, 1);
 
  switch (resolution) {
  case FOURTEEN_BIT:
    configContents = (configContents & 0xCF);
    break;
 
  case ELEVEN_BIT:
    configContents = (configContents & 0xDF);
    configContents = (configContents | 0x10);
    break;
 
  case NINE_BIT:
    configContents = (configContents & 0xEF);
    configContents = (configContents | 0x20);
    break;
 
  default:
    configContents = (configContents & 0xCF);
  }
 
  /* Write updated resolution bits back to sensor */
  writeReg(MEASUREMENT_CONFIG, &configContents, 1);
}
 
/*  Bits 2 and 1 of the MEASUREMENT_CONFIG register controls
        the measurement mode  */
/**
 * \fn void setMeasurementMode(int mode)
 *
 * \brief Configures whether the sensor measures Temp, Humidity, or both.
 *
 * \param mode 0: Temp & Humid, 1: Temp only, 2: Humid only.
 */
void setMeasurementMode(int mode) {
  int err;
  uint8_t configContents;
 
  err = readReg(MEASUREMENT_CONFIG, &configContents, 1);
 
  switch (mode) {
  case TEMP_AND_HUMID:
    configContents = (configContents & 0xF9);
    break;
 
  case TEMP_ONLY:
    configContents = (configContents & 0xFC);
    configContents = (configContents | 0x02);
    break;
 
  case HUMID_ONLY:
    configContents = (configContents & 0xFD);
    configContents = (configContents | 0x04);
    break;
 
  default:
    configContents = (configContents & 0xF9);
  }
 
  /* Apply the measurement mode to the configuration register */
  writeReg(MEASUREMENT_CONFIG, &configContents, 1);
}
 
/*  Bit 0 of the MEASUREMENT_CONFIG register can be used
        to trigger measurements  */
/**
 * \fn void triggerMeasurement(void)
 *
 * \brief Manually triggers a single measurement cycle.
 */
void triggerMeasurement(void) {
  int err;
  uint8_t configContents;
 
  err = readReg(MEASUREMENT_CONFIG, &configContents, 1);
 
  /* Set the trigger bit */
  configContents = (configContents | 0x01);
  writeReg(MEASUREMENT_CONFIG, &configContents, 1);
}
 
/*  Bit 7 of the CONFIG register can be used to trigger a
        soft reset  */
/**
 * \fn void reset(void)
 *
 * \brief Performs a software reset on the HDC2080.
 */
void reset(void) {
  int err;
  uint8_t configContents;
 
  err = readReg(HDC_CONFIG, &configContents, 1);
 
  /* Set the soft reset bit */
  configContents = (configContents | 0x80);
  writeReg(HDC_CONFIG, &configContents, 1);
  /* Wait for the device to reboot */
  k_sleep(K_MSEC(50));
}
 
/*  Bit 2 of the CONFIG register can be used to enable/disable
        the interrupt pin  */
/**
 * \fn void enableInterrupt(void)
 *
 * \brief Enables the physical interrupt/DRDY pin.
 */
void enableInterrupt(void) {
  int err;
  uint8_t configContents;
 
  err = readReg(HDC_CONFIG, &configContents, 1);
 
  /* Set the interrupt enable bit */
  configContents = (configContents | 0x04);
  writeReg(HDC_CONFIG, &configContents, 1);
}
 
/*  Bit 2 of the CONFIG register can be used to enable/disable
        the interrupt pin  */
/**
 * \fn void disableInterrupt(void)
 *
 * \brief Disables the physical interrupt/DRDY pin (sets to High-Z).
 */
void disableInterrupt(void) {
  int err;
  uint8_t configContents;
 
  err = readReg(HDC_CONFIG, &configContents, 1);
 
  /* Clear the interrupt enable bit */
  configContents = (configContents & 0xFB);
  writeReg(HDC_CONFIG, &configContents, 1);
}
 
/**
 * \fn void setRate(int rate)
 *
 * \brief Sets the automatic measurement frequency.
 *
 * \param rate Constant representing the frequency (e.g., ONE_HZ, FIVE_SECONDS).
 */
void setRate(int rate) {
  int err;
  uint8_t configContents;
 
  err = readReg(HDC_CONFIG, &configContents, 1);
 
  switch (rate) {
  case MANUAL:
    configContents = (configContents & 0x8F);
    break;
 
  case TWO_MINS:
    configContents = (configContents & 0x9F);
    configContents = (configContents | 0x10);
    break;
 
  case ONE_MINS:
    configContents = (configContents & 0xAF);
    configContents = (configContents | 0x20);
    break;
 
  case TEN_SECONDS:
    configContents = (configContents & 0xBF);
    configContents = (configContents | 0x30);
    break;
 
  case FIVE_SECONDS:
    configContents = (configContents & 0xCF);
    configContents = (configContents | 0x40);
    break;
 
  case ONE_HZ:
    configContents = (configContents & 0xDF);
    configContents = (configContents | 0x50);
    break;
 
  case TWO_HZ:
    configContents = (configContents & 0xEF);
    configContents = (configContents | 0x60);
    break;
 
  case FIVE_HZ:
    configContents = (configContents | 0x70);
    break;
 
  default:
    configContents = (configContents & 0x8F);
  }
 
  writeReg(HDC_CONFIG, &configContents, 1);
}
 
/**
 * \fn void setInterruptPolarity(int polarity)
 *
 * \brief Configures the electrical behavior of the INT pin when active.
 *
 * \param polarity 0 for ACTIVE_LOW, 1 for ACTIVE_HIGH.
 */
void setInterruptPolarity(int polarity) {
  int err;
  uint8_t configContents;
 
  err = readReg(HDC_CONFIG, &configContents, 1);
 
  switch (polarity) {
  case ACTIVE_LOW:
    configContents = (configContents & 0xFD);
    break;
 
  case ACTIVE_HIGH:
    configContents = (configContents | 0x02);
    break;
 
  default:
    configContents = (configContents & 0xFD);
  }
 
  writeReg(HDC_CONFIG, &configContents, 1);
}
 
/**
 * \fn void setInterruptMode(int mode)
 *
 * \brief Sets the interrupt pin to either level-sensitive or comparator mode.
 *
 * \param mode 0 for LEVEL_MODE, 1 for COMPARATOR_MODE.
 */
void setInterruptMode(int mode) {
  int err;
  uint8_t configContents;
 
  err = readReg(HDC_CONFIG, &configContents, 1);
 
  switch (mode) {
  case LEVEL_MODE:
    configContents = (configContents & 0xFE);
    break;
 
  case COMPARATOR_MODE:
    configContents = (configContents | 0x01);
    break;
 
  default:
    configContents = (configContents & 0xFE);
  }
 
  writeReg(HDC_CONFIG, &configContents, 1);
}
 
/**
 * \fn uint8_t readInterruptStatus(void)
 *
 * \brief Reads the interrupt status register.
 *
 * \return Bitmask of triggered interrupts (DRDY, TH, TL, HH, HL).
 */
uint8_t readInterruptStatus(void) {
  int err;
  uint8_t regContents;
 
  err = readReg(INTERRUPT_DRDY, &regContents, 1);
  return regContents;
}
 
/**
 * \fn void clearMaxTemp(void)
 *
 * \brief Resets the Maximum Temperature peak-hold register to 0.
 */
void clearMaxTemp(void) {
  uint8_t value = 0;
 
  writeReg(TEMP_MAX, &value, 1);
}
 
/**
 * \fn void clearMaxHumidity(void)
 *
 * \brief Resets the Maximum Humidity peak-hold register to 0.
 */
void clearMaxHumidity(void) {
  uint8_t value = 0;
 
  writeReg(HUMID_MAX, &value, 1);
}
 
/**
 * \fn float readMaxTemp(void)
 *
 * \brief Reads the highest temperature recorded since the last clear.
 *
 * \return Maximum temperature in degrees Celsius.
 */
float readMaxTemp(void) {
  int err;
  uint8_t regContents;
 
  err = readReg(TEMP_MAX, &regContents, 1);
  float f = regContents;
  f = (f * 165.0f / 256.0f) - 40.0f;
 
  return f;
}
 
/**
 * \fn float readMaxHumidity(void)
 *
 * \brief Reads the maximum humidity recorded since the last clear.
 *
 * \return Maximum relative humidity as a percentage.
 */
float readMaxHumidity(void) {
  int err;
  uint8_t regContents;
 
  err = readReg(HUMID_MAX, &regContents, 1);
  float f = regContents;
  f = (f / 256.0f) * 100.0f;
 
  return f;
}
 
/**
 * \fn void enableThresholdInterrupt(void)
 *
 * \brief Enables the high/low temperature and humidity threshold interrupts.
 */
void enableThresholdInterrupt(void) {
  int err;
  uint8_t regContents;
 
  err = readReg(INTERRUPT_CONFIG, &regContents, 1);
 
  regContents = (regContents | 0x78);
 
  writeReg(INTERRUPT_CONFIG, &regContents, 1);
}
 
/**
 * \fn void disableThresholdInterrupt(void)
 *
 * \brief Disables the high/low temperature and humidity threshold interrupts.
 */
void disableThresholdInterrupt(void) {
  int err;
  uint8_t regContents;
 
  err = readReg(INTERRUPT_CONFIG, &regContents, 1);
 
  regContents = (regContents & 0x87);
 
  writeReg(INTERRUPT_CONFIG, &regContents, 1);
}
 
/**
 * \fn void enableDRDYInterrupt(void)
 *
 * \brief Enables the Data Ready (DRDY) interrupt.
 */
void enableDRDYInterrupt(void) {
  int err;
  uint8_t regContents;
 
  err = readReg(INTERRUPT_CONFIG, &regContents, 1);
 
  regContents = (regContents | 0x80);
 
  writeReg(INTERRUPT_CONFIG, &regContents, 1);
}
 
/**
 * \fn void disableDRDYInterrupt(void)
 *
 * \brief Disables the Data Ready (DRDY) interrupt.
 */
void disableDRDYInterrupt(void) {
  int err;
  uint8_t regContents;
 
  err = readReg(INTERRUPT_CONFIG, &regContents, 1);
 
  regContents = (regContents & 0x7F);
 
  writeReg(INTERRUPT_CONFIG, &regContents, 1);
}
 
/**
 * \fn int initHDC2080(void)
 *
 * \brief Initializes the HDC2080 sensor with default parameters.
 *
 * \return TRUE if the sensor is found and initialized, FALSE otherwise.
 */
int initHDC2080(void) {
  unsigned char datas[6] = {0};
 
  /* Verify Manufacturer and Device ID */
  ret = readReg(MID_L, datas, 4);
  manfID = (datas[1] << 8) | datas[0];
  deviceID = (datas[3] << 8) | datas[2];
  myPrintkI("HDC2080 Manf: 0x%04X Device: 0x%04X\r\n", manfID, deviceID);
  if ((manfID != MAN_ID) || (deviceID != DEV_ID) || (ret == FALSE)) {
    //      sprintf(myStr, "HDC2080 Manf: %04X Device: %04X\r\n", manfID, deviceID);
    //      myPrintkW(myStr);
    myPrintkW("HDC2080 Temp/Humidty Sensor not found\r\n");
    return FALSE;
  }
 
  /* initialize HDC2080 */
  /* interrupt status 0x04 */
  readInterruptStatus(); /* read status to clear */
 
  /* TEMP_MAX 0x05 */
  clearMaxTemp();
 
  /* HUMIDITY_MAX 0x06 */
  clearMaxHumidity();
 
  /* Interrupt Enable 0x07 */
  //    disableThresholdInterrupt();    /* disable temp/humidity low/high threshold interrupts */
  enableThresholdInterrupt(); /* enable temp/humidity low/high threshold interrupts */
                              //    disableDRDYInterrupt();
  enableDRDYInterrupt();
 
  /* TEMP_OFFSET adjust 0x08 */
  setTempOffsetAdjust(0);
 
  /* HUMIDITY_OFFSET adjust 0x09 */
  setHumidityOffsetAdjust(0);
 
  /* Temperature Threshold adjust Low 0x0A */
  setLowTemp(10.0);
 
  /* Temperature Threshold adjust High 0x0B */
  setHighTemp(30.0);
 
  /* Humidity Threshold adjust Low 0x0C */
  setLowHumidity(10.0);
 
  /* Humidity Threshold adjust High 0x0D */
  setHighHumidity(80.0);
 
  /* CONFIG 0x0E*/
  setInterruptMode(LEVEL_MODE);     /* set interrupt mode */
  setInterruptPolarity(ACTIVE_LOW); /* set interrupt polarity */
 
  /* If manual trigger is enabled, we don't need the hardware interrupt pin active */
  // if (flashParameters.manualTrigger) {
  //   myPrintkW("Manual trigger Enabled. Waiting for datetime command from gateway.\r\n");
  //   disableInterrupt();
  // } else {
  /* Otherwise, enable the INT pin to signal data ready or threshold alarms */
  myPrintkW("HDC2080 automatic trigger Enabled\r\n");
  enableInterrupt();
  // }
 
  disableHeater(); /* dusable heater */
 
  if (flashParameters.manualTrigger) {
    setRate(MANUAL); /* set auto conversion rate */
  } else {
    setRate(TEN_SECONDS); /* set auto conversion rate */
  }
 
  /* MEASUREMENT_CONFIG 0x0F*/
  //    setMeasurementMode(TEMP_ONLY);      /* set measurement mode */
  //    setMeasurementMode(HUMID_ONLY);     /* set measurement mode */
  setMeasurementMode(TEMP_AND_HUMID); /* set measurement mode */
  setHumidRes(FOURTEEN_BIT);          /* set humidity resolution */
  setTempRes(FOURTEEN_BIT);           /* set temperature resolution */
  triggerMeasurement();               /* start measurement */
 
  /* HDC2080  found */
  sensorTypePresentAll |= (1 << SENSORTYPEHDC2080);
  myPrintkI("HDC2080 Temp/Humidty Present\r\n");
  return TRUE;
}