sht1x: Initial implementation
This driver was developed with a DFRobot SHT10 Temperature and Humidity sensor. This driver should work on all SHT1X devices. It requires a 10K pull-up resistor connected to the data pin. The sensor can be run at differing voltages from 2.5v to 5v. Signed-off-by: Jon Trulson <jtrulson@ics.com>
This commit is contained in:
Jon Trulson
401
src/sht1x/sht1x.c
Normal file
401
src/sht1x/sht1x.c
Normal file
@@ -0,0 +1,401 @@
|
||||
/*
|
||||
* Author: Jon Trulson <jtrulson@ics.com>
|
||||
* Copyright (c) 2016 Intel Corporation.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be
|
||||
* included in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "upm_utilities.h"
|
||||
#include "sht1x.h"
|
||||
|
||||
sht1x_context sht1x_init(unsigned int clk_pin, unsigned int data_pin)
|
||||
{
|
||||
sht1x_context dev =
|
||||
(sht1x_context)malloc(sizeof(struct _sht1x_context));
|
||||
|
||||
if (!dev)
|
||||
return NULL;
|
||||
|
||||
// zero out context
|
||||
memset((void *)dev, 0, sizeof(struct _sht1x_context));
|
||||
|
||||
dev->gpio_clk = NULL;
|
||||
dev->gpio_data = NULL;
|
||||
|
||||
// initialize the MRAA contexts
|
||||
|
||||
// clock
|
||||
if (!(dev->gpio_clk = mraa_gpio_init(clk_pin)))
|
||||
{
|
||||
printf("%s: mraa_gpio_init(clk) failed.\n", __FUNCTION__);
|
||||
sht1x_close(dev);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
mraa_gpio_dir(dev->gpio_clk, MRAA_GPIO_OUT);
|
||||
|
||||
if (mraa_gpio_use_mmaped(dev->gpio_clk, 1))
|
||||
{
|
||||
// not fatal, just slower
|
||||
printf("%s: warning, mraa_gpio_use_mmaped(clk) failed.\n",
|
||||
__FUNCTION__);
|
||||
}
|
||||
|
||||
// data
|
||||
if (!(dev->gpio_data = mraa_gpio_init(data_pin)))
|
||||
{
|
||||
printf("%s: mraa_gpio_init(data) failed.\n", __FUNCTION__);
|
||||
sht1x_close(dev);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
mraa_gpio_dir(dev->gpio_data, MRAA_GPIO_OUT);
|
||||
mraa_gpio_mode(dev->gpio_data, MRAA_GPIO_PULLUP);
|
||||
|
||||
if (mraa_gpio_use_mmaped(dev->gpio_data, 1))
|
||||
{
|
||||
// not fatal, just slower
|
||||
printf("%s: warning, mraa_gpio_use_mmaped(data) failed.\n",
|
||||
__FUNCTION__);
|
||||
}
|
||||
|
||||
// max init time
|
||||
upm_delay_ms(15);
|
||||
|
||||
// now read the status register to see if we are highres (14b) or not
|
||||
uint8_t status;
|
||||
if (sht1x_read_status(dev, &status))
|
||||
{
|
||||
printf("%s: sht1x_read_status() failed.\n", __FUNCTION__);
|
||||
sht1x_close(dev);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (status & SHT1X_STATUS_RESOLUTION_LOW)
|
||||
dev->hires = false;
|
||||
else
|
||||
dev->hires = true;
|
||||
|
||||
// setup our coefficients (see the datasheet). We always assume 5v
|
||||
// here. We also only deal with Celcius.
|
||||
|
||||
// this will set coeff_d1
|
||||
sht1x_set_volts(dev, SHT1X_VOLTS_5);
|
||||
|
||||
dev->coeff_c1 = -2.0468;
|
||||
dev->coeff_t1 = 0.01;
|
||||
if (dev->hires)
|
||||
{
|
||||
dev->coeff_d2 = 0.01;
|
||||
dev->coeff_c2 = 0.0367;
|
||||
dev->coeff_c3 = -1.5955e-6;
|
||||
dev->coeff_t2 = 0.00008;
|
||||
}
|
||||
else
|
||||
{
|
||||
dev->coeff_d2 = 0.04;
|
||||
dev->coeff_c2 = 0.5872;
|
||||
dev->coeff_c3 = -4.0845e-4;
|
||||
dev->coeff_t2 = 0.00128;
|
||||
}
|
||||
|
||||
return dev;
|
||||
}
|
||||
|
||||
void sht1x_close(sht1x_context dev)
|
||||
{
|
||||
assert(dev != NULL);
|
||||
|
||||
if (dev->gpio_clk)
|
||||
mraa_gpio_close(dev->gpio_clk);
|
||||
if (dev->gpio_data)
|
||||
mraa_gpio_close(dev->gpio_data);
|
||||
|
||||
free(dev);
|
||||
}
|
||||
|
||||
upm_result_t sht1x_update(const sht1x_context dev)
|
||||
{
|
||||
assert(dev != NULL);
|
||||
|
||||
// byte 3 is the checksum which we currently ignore
|
||||
uint8_t byte1, byte2, byte3;
|
||||
|
||||
// first read the temperature
|
||||
sht1x_send_command(dev, SHT1X_CMD_MEAS_TEMPERATURE);
|
||||
if (sht1x_wait_for_response(dev))
|
||||
{
|
||||
printf("%s: wait_for_response(temp) failed.\n", __FUNCTION__);
|
||||
return UPM_ERROR_OPERATION_FAILED;
|
||||
}
|
||||
|
||||
sht1x_read_8bits(dev, &byte1);
|
||||
sht1x_read_8bits(dev, &byte2);
|
||||
sht1x_read_8bits(dev, &byte3);
|
||||
|
||||
int temp = (byte1 << 8) | byte2;
|
||||
// printf("temp %d (0x%04x)\n", temp, temp);
|
||||
|
||||
// compute temperature
|
||||
dev->temperature = dev->coeff_d1 + dev->coeff_d2 * (float)temp;
|
||||
|
||||
// now get humidity
|
||||
sht1x_send_command(dev, SHT1X_CMD_MEAS_HUMIDITY);
|
||||
if (sht1x_wait_for_response(dev))
|
||||
{
|
||||
printf("%s: wait_for_response(hum) failed.\n", __FUNCTION__);
|
||||
return UPM_ERROR_OPERATION_FAILED;
|
||||
}
|
||||
|
||||
sht1x_read_8bits(dev, &byte1);
|
||||
sht1x_read_8bits(dev, &byte2);
|
||||
sht1x_read_8bits(dev, &byte3);
|
||||
|
||||
temp = (byte1 << 8) | byte2;
|
||||
|
||||
// first we compute a linear humidity reading, then apply temperature
|
||||
// compensation
|
||||
float linHumidity = dev->coeff_c1 + dev->coeff_c2 * (float)temp
|
||||
+ dev->coeff_c3 * (float)temp * (float)temp;
|
||||
|
||||
// convert to "true" RH (temperature compensated)
|
||||
dev->humidity = (dev->temperature - 25.0) * (dev->coeff_t1 + dev->coeff_t2)
|
||||
+ linHumidity;
|
||||
|
||||
if (dev->humidity > 99.0)
|
||||
dev->humidity = 100.0;
|
||||
|
||||
return UPM_SUCCESS;
|
||||
}
|
||||
|
||||
void sht1x_start_xmit(const sht1x_context dev)
|
||||
{
|
||||
mraa_gpio_dir(dev->gpio_data, MRAA_GPIO_OUT);
|
||||
|
||||
// start sequence
|
||||
mraa_gpio_write(dev->gpio_data, 1);
|
||||
mraa_gpio_write(dev->gpio_clk, 1);
|
||||
|
||||
mraa_gpio_write(dev->gpio_data, 0);
|
||||
mraa_gpio_write(dev->gpio_clk, 0);
|
||||
|
||||
mraa_gpio_write(dev->gpio_clk, 1);
|
||||
mraa_gpio_write(dev->gpio_data, 1);
|
||||
|
||||
mraa_gpio_write(dev->gpio_clk, 0);
|
||||
}
|
||||
|
||||
upm_result_t sht1x_write_8bits(const sht1x_context dev, uint8_t byte)
|
||||
{
|
||||
// send the byte
|
||||
mraa_gpio_dir(dev->gpio_data, MRAA_GPIO_OUT);
|
||||
|
||||
int i;
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
if (byte & 0x80)
|
||||
mraa_gpio_write(dev->gpio_data, 1);
|
||||
else
|
||||
mraa_gpio_write(dev->gpio_data, 0);
|
||||
|
||||
mraa_gpio_write(dev->gpio_clk, 1);
|
||||
mraa_gpio_write(dev->gpio_clk, 0);
|
||||
|
||||
byte <<= 1;
|
||||
}
|
||||
|
||||
// now wait for the ack response. After the falling edge of the 8th
|
||||
// clock (above), the data line should be pulled low. Then, after
|
||||
// the falling edge of the ninth clock pulse, the data line should
|
||||
// go high. We check the data line after the rising edge of the
|
||||
// ninth clock to make sure it went low.
|
||||
bool ackError = false;
|
||||
|
||||
mraa_gpio_dir(dev->gpio_data, MRAA_GPIO_IN);
|
||||
|
||||
// start 9th clock
|
||||
mraa_gpio_write(dev->gpio_clk, 1);
|
||||
|
||||
// should be low. If it's high, there is a problem.
|
||||
if (mraa_gpio_read(dev->gpio_data))
|
||||
ackError = true;
|
||||
|
||||
// finish 9th clock
|
||||
mraa_gpio_write(dev->gpio_clk, 0);
|
||||
|
||||
if (ackError)
|
||||
{
|
||||
printf("%s: didn't receive proper ACK from SHT1X.\n", __FUNCTION__);
|
||||
return UPM_ERROR_OPERATION_FAILED;
|
||||
}
|
||||
|
||||
return UPM_SUCCESS;
|
||||
}
|
||||
|
||||
upm_result_t sht1x_send_command(const sht1x_context dev, SHT1X_CMD_T cmd)
|
||||
{
|
||||
assert(dev != NULL);
|
||||
|
||||
sht1x_start_xmit(dev);
|
||||
|
||||
// send the command
|
||||
return sht1x_write_8bits(dev, (uint8_t)cmd);
|
||||
}
|
||||
|
||||
upm_result_t sht1x_wait_for_response(const sht1x_context dev)
|
||||
{
|
||||
assert(dev != NULL);
|
||||
|
||||
const int maxRetries = 500;
|
||||
int r = 0;
|
||||
|
||||
mraa_gpio_dir(dev->gpio_data, MRAA_GPIO_IN);
|
||||
|
||||
// we wait for some time (about .5 seconds, more than enough time)
|
||||
// for the data line to be pulled low.
|
||||
while (r++ < maxRetries)
|
||||
{
|
||||
if (!mraa_gpio_read(dev->gpio_data))
|
||||
break;
|
||||
|
||||
upm_delay_ms(1);
|
||||
}
|
||||
|
||||
if (r >= maxRetries)
|
||||
{
|
||||
printf("%s: no response to measurement request.\n", __FUNCTION__);
|
||||
return UPM_ERROR_OPERATION_FAILED;
|
||||
}
|
||||
|
||||
// printf("%s: retries: %d\n", __FUNCTION__, r);
|
||||
|
||||
return UPM_SUCCESS;
|
||||
}
|
||||
|
||||
void sht1x_read_8bits(const sht1x_context dev, uint8_t *value)
|
||||
{
|
||||
assert(dev != NULL);
|
||||
|
||||
// we need to read a byte, and acknowlege it
|
||||
|
||||
uint8_t byte = 0;
|
||||
|
||||
mraa_gpio_dir(dev->gpio_data, MRAA_GPIO_IN);
|
||||
|
||||
int i;
|
||||
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
mraa_gpio_write(dev->gpio_clk, 1);
|
||||
|
||||
if (mraa_gpio_read(dev->gpio_data))
|
||||
byte |= 1;
|
||||
|
||||
// don't shift on the last bit!
|
||||
if (i != 7)
|
||||
byte <<= 1;
|
||||
|
||||
mraa_gpio_write(dev->gpio_clk, 0);
|
||||
}
|
||||
|
||||
*value = byte;
|
||||
|
||||
// send the ack
|
||||
|
||||
mraa_gpio_dir(dev->gpio_data, MRAA_GPIO_OUT);
|
||||
|
||||
// pull data line low
|
||||
mraa_gpio_write(dev->gpio_data, 0);
|
||||
// cycle the clock
|
||||
mraa_gpio_write(dev->gpio_clk, 1);
|
||||
mraa_gpio_write(dev->gpio_clk, 0);
|
||||
// release data line
|
||||
mraa_gpio_write(dev->gpio_data, 1);
|
||||
}
|
||||
|
||||
float sht1x_get_temperature(const sht1x_context dev)
|
||||
{
|
||||
assert(dev != NULL);
|
||||
|
||||
return dev->temperature;
|
||||
}
|
||||
|
||||
float sht1x_get_humidity(const sht1x_context dev)
|
||||
{
|
||||
assert(dev != NULL);
|
||||
|
||||
return dev->humidity;
|
||||
}
|
||||
|
||||
void sht1x_reset(const sht1x_context dev)
|
||||
{
|
||||
assert(dev != NULL);
|
||||
|
||||
sht1x_send_command(dev, SHT1X_CMD_SOFT_RESET);
|
||||
upm_delay_ms(20);
|
||||
}
|
||||
|
||||
upm_result_t sht1x_read_status(const sht1x_context dev, uint8_t *status)
|
||||
{
|
||||
assert(dev != NULL);
|
||||
|
||||
upm_result_t rv;
|
||||
|
||||
if ((rv = sht1x_send_command(dev, SHT1X_CMD_READ_STATUS)))
|
||||
{
|
||||
printf("%s: send_command() failed.\n", __FUNCTION__);
|
||||
return rv;
|
||||
}
|
||||
|
||||
sht1x_read_8bits(dev, status);
|
||||
return UPM_SUCCESS;
|
||||
}
|
||||
|
||||
upm_result_t sht1x_write_status(const sht1x_context dev, uint8_t status)
|
||||
{
|
||||
assert(dev != NULL);
|
||||
|
||||
upm_result_t rv;
|
||||
|
||||
if ((rv = sht1x_send_command(dev, SHT1X_CMD_WRITE_STATUS)))
|
||||
{
|
||||
printf("%s: send_command() failed.\n", __FUNCTION__);
|
||||
return rv;
|
||||
}
|
||||
|
||||
return sht1x_write_8bits(dev, status);
|
||||
}
|
||||
|
||||
void sht1x_set_volts(const sht1x_context dev, SHT1X_VOLTS_T volts)
|
||||
{
|
||||
assert(dev != NULL);
|
||||
|
||||
switch (volts)
|
||||
{
|
||||
case SHT1X_VOLTS_5: dev->coeff_d1 = -40.1; break;
|
||||
case SHT1X_VOLTS_4: dev->coeff_d1 = -39.8; break;
|
||||
case SHT1X_VOLTS_3_5: dev->coeff_d1 = -39.7; break;
|
||||
case SHT1X_VOLTS_3: dev->coeff_d1 = -39.6; break;
|
||||
case SHT1X_VOLTS_2_5: dev->coeff_d1 = -39.4; break;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user