From 4085ae3ddfbbf10c8ccbd3dccd43452c40a1fe40 Mon Sep 17 00:00:00 2001 From: Yuval Adam Date: Fri, 13 Mar 2015 12:24:52 +0200 Subject: Add bootloader, nfclib and sensorlib --- sensorlib/sht21.c | 564 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 564 insertions(+) create mode 100644 sensorlib/sht21.c (limited to 'sensorlib/sht21.c') diff --git a/sensorlib/sht21.c b/sensorlib/sht21.c new file mode 100644 index 0000000..0698593 --- /dev/null +++ b/sensorlib/sht21.c @@ -0,0 +1,564 @@ +//***************************************************************************** +// +// sht21.c - Driver for the SHT21 accelerometer. +// +// Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved. +// Software License Agreement +// +// Texas Instruments (TI) is supplying this software for use solely and +// exclusively on TI's microcontroller products. The software is owned by +// TI and/or its suppliers, and is protected under applicable copyright +// laws. You may not combine this software with "viral" open-source +// software in order to form a larger program. +// +// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS. +// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT +// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY +// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL +// DAMAGES, FOR ANY REASON WHATSOEVER. +// +// This is part of revision 2.1.0.12573 of the Tiva Firmware Development Package. +// +//***************************************************************************** + +#include +#include "sensorlib/hw_sht21.h" +#include "sensorlib/i2cm_drv.h" +#include "sensorlib/sht21.h" + +//***************************************************************************** +// +//! \addtogroup sht21_api +//! @{ +// +//***************************************************************************** + +//***************************************************************************** +// +// The states of the SHT21 state machine. +// +//***************************************************************************** +#define SHT21_STATE_IDLE 0 // State machine is idle +#define SHT21_STATE_INIT 1 // Waiting for initialization +#define SHT21_STATE_READ 2 // Waiting for register read +#define SHT21_STATE_WRITE 3 // Waiting for register write +#define SHT21_STATE_RMW 4 +#define SHT21_STATE_READ_DATA 5 // Waiting for temperature or + // humidity data + +//***************************************************************************** +// +// The callback function that is called when I2C transactions to/from the +// SHT21 have completed. +// +//***************************************************************************** +static void +SHT21Callback(void *pvCallbackData, uint_fast8_t ui8Status) +{ + tSHT21 *psInst; + + // + // Convert the instance data into a pointer to a tSHT221 structure. + // + psInst = (tSHT21 *)pvCallbackData; + + // + // If the I2C master driver encountered a failure, force the state machine + // to the idle state (which will also result in a callback to propagate the + // error). + // + if(ui8Status != I2CM_STATUS_SUCCESS) + { + psInst->ui8State = SHT21_STATE_IDLE; + } + + // + // Determine the current state of the SHT21 state machine. + // + switch(psInst->ui8State) + { + // + // All states that trivially transition to IDLE, and all unknown + // states. + // + case SHT21_STATE_INIT: + case SHT21_STATE_READ: + case SHT21_STATE_WRITE: + case SHT21_STATE_READ_DATA: + case SHT21_STATE_RMW: + default: + { + // + // The state machine is now idle. + // + psInst->ui8State = SHT21_STATE_IDLE; + + // + // Done. + // + break; + } + } + + // + // See if the state machine is now idle and there is a callback function. + // + if((psInst->ui8State == SHT21_STATE_IDLE) && psInst->pfnCallback) + { + // + // Call the application-supplied callback function. + // + psInst->pfnCallback(psInst->pvCallbackData, ui8Status); + } +} + +//***************************************************************************** +// +//! Initializes the SHT21 driver. +//! +//! \param psInst is a pointer to the SHT21 instance data. +//! \param psI2CInst is a pointer to the I2C driver instance data. +//! \param ui8I2CAddr is the I2C address of the SHT21 device. +//! \param pfnCallback is the function to be called when the initialization has +//! completed (can be \b NULL if a callback is not required). +//! \param pvCallbackData is a pointer that is passed to the callback function. +//! +//! This function initializes the SHT21 driver, preparing it for operation, and +//! initiates a reset of the SHT21 device, clearing any previous configuration +//! data. +//! +//! \return Returns 1 if the SHT21 driver was successfully initialized and 0 if +//! it was not. +// +//***************************************************************************** +uint_fast8_t +SHT21Init(tSHT21 *psInst, tI2CMInstance *psI2CInst, uint_fast8_t ui8I2CAddr, + tSensorCallback *pfnCallback, void *pvCallbackData) +{ + // + // Initialize the SHT21 instance structure. + // + psInst->psI2CInst = psI2CInst; + psInst->ui8Addr = ui8I2CAddr; + psInst->ui8State = SHT21_STATE_INIT; + + // + // Save the callback information. + // + psInst->pfnCallback = pfnCallback; + psInst->pvCallbackData = pvCallbackData; + + // + // Perform a soft reset of the SHT21. + // + psInst->pui8Data[0] = SHT21_CMD_SOFT_RESET; + if(I2CMWrite(psInst->psI2CInst, ui8I2CAddr, psInst->pui8Data, 1, + SHT21Callback, psInst) == 0) + { + // + // The I2C write failed, so move to the idle state and return a + // failure. + // + psInst->ui8State = SHT21_STATE_IDLE; + return(0); + } + + // + // Success + // + return(1); +} + +//***************************************************************************** +// +//! Reads data from SHT21 registers. +//! +//! \param psInst is a pointer to the SHT21 instance data. +//! \param ui8Reg is the first register to read. +//! \param pui8Data is a pointer to the location to store the data that is +//! read. +//! \param ui16Count the number of data bytes to read. +//! \param pfnCallback is the function to be called when the data has been read +//! (can be \b NULL if a callback is not required). +//! \param pvCallbackData pointer that is passed to the callback function. +//! +//! This function reads a sequence of data values from consecutive registers in +//! the SHT21. +//! +//! \return Returns 1 if the read was successfully started and 0 if it was not. +// +//***************************************************************************** +uint_fast8_t +SHT21Read(tSHT21 *psInst, uint_fast8_t ui8Reg, uint8_t *pui8Data, + uint_fast16_t ui16Count, tSensorCallback *pfnCallback, + void *pvCallbackData) +{ + // + // Return a failure if the SHT21 driver is not idle (in other words, there + // is already an outstanding request to the SHT21). + // + if(psInst->ui8State != SHT21_STATE_IDLE) + { + return(0); + } + + // + // Save the callback information. + // + psInst->pfnCallback = pfnCallback; + psInst->pvCallbackData = pvCallbackData; + + // + // Move the state machine to the wait for read state. + // + psInst->ui8State = SHT21_STATE_READ; + + // + // Read the requested registers from the SHT21. + // + psInst->uCommand.pui8Buffer[0] = ui8Reg; + if(I2CMRead(psInst->psI2CInst, psInst->ui8Addr, + psInst->uCommand.pui8Buffer, 1, pui8Data, ui16Count, + SHT21Callback, (void *)psInst) == 0) + { + // + // The I2C write failed, so move to the idle state and return a + // failure. + // + psInst->ui8State = SHT21_STATE_IDLE; + return(0); + } + + // + // Success. + // + return(1); +} + +//***************************************************************************** +// +//! Writes data to SHT21 registers. +//! +//! \param psInst is a pointer to the SHT21 instance data. +//! \param ui8Reg is the register offset to be written. +//! \param pui8Data is the data buffer bytes to write. +//! \param ui16Count is the number of bytes to write. +//! \param pfnCallback is the function to be called when the data has been +//! written (can be \b NULL if a callback is not required). +//! \param pvCallbackData is a pointer that is passed to the callback function. +//! +//! This function writes a sequence of data values to consecutive registers in +//! the SHT21. The first byte of the \e pui8Data buffer contains the value to +//! be written into the \e ui8Reg register, the second value contains the data +//! to be written into the next register, and so on. +//! +//! \return Returns 1 if the write was successfully started and 0 if it was +//! not. +// +//***************************************************************************** +uint_fast8_t +SHT21Write(tSHT21 *psInst, uint_fast8_t ui8Reg, const uint8_t *pui8Data, + uint_fast16_t ui16Count, tSensorCallback *pfnCallback, + void *pvCallbackData) +{ + // + // Return a failure if the SHT21 driver is not idle (in other words, there + // is already an outstanding request to the SHT21). + // + if(psInst->ui8State != SHT21_STATE_IDLE) + { + return(0); + } + + // + // Save the callback information. + // + psInst->pfnCallback = pfnCallback; + psInst->pvCallbackData = pvCallbackData; + + // + // Move the state machine to the wait for write state. + // + psInst->ui8State = SHT21_STATE_WRITE; + + // + // Write the requested registers to the SHT21. + // + if(I2CMWrite8(&(psInst->uCommand.sWriteState), psInst->psI2CInst, + psInst->ui8Addr, ui8Reg, pui8Data, ui16Count, SHT21Callback, + psInst) == 0) + { + // + // The I2C write failed, so move to the idle state and return a + // failure. + // + psInst->ui8State = SHT21_STATE_IDLE; + return(0); + } + + // + // Success. + // + return(1); +} + +//***************************************************************************** +// +//! Performs a read-modify-write of a SHT21 register. +//! +//! \param psInst is a pointer to the SHT21 instance data. +//! \param ui8Reg is the register to modify. +//! \param ui8Mask is the bit mask that is ANDed with the current register +//! value. +//! \param ui8Value is the bit mask that is ORed with the result of the AND +//! operation. +//! \param pfnCallback is the function to be called when the data has been +//! changed (can be \b NULL if a callback is not required). +//! \param pvCallbackData is a pointer that is passed to the callback function. +//! +//! This function changes the value of a register in the SHT21 via a +//! read-modify-write operation, allowing one of the fields to be changed +//! without disturbing the other fields. The \e ui8Reg register is read, ANDed +//! with \e ui8Mask, ORed with \e ui8Value, and then written back to the SHT21. +//! +//! \return Returns 1 if the read-modify-write was successfully started and 0 +//! if it was not. +// +//***************************************************************************** +uint_fast8_t +SHT21ReadModifyWrite(tSHT21 *psInst, uint_fast8_t ui8Reg, uint_fast8_t ui8Mask, + uint_fast8_t ui8Value, tSensorCallback *pfnCallback, + void *pvCallbackData) +{ + // + // Return a failure if the SHT21 driver is not idle (in other words, there + // is already an outstanding request to the SHT21). + // + if(psInst->ui8State != SHT21_STATE_IDLE) + { + return(0); + } + + // + // Save the callback information. + // + psInst->pfnCallback = pfnCallback; + psInst->pvCallbackData = pvCallbackData; + + // + // Move the state machine to the wait for read-modify-write state. + // + psInst->ui8State = SHT21_STATE_RMW; + + // + // Submit the read-modify-write request to the TMP006. + // + if(I2CMReadModifyWrite8(&(psInst->uCommand.sReadModifyWriteState), + psInst->psI2CInst, psInst->ui8Addr, ui8Reg, + ui8Mask, ui8Value, SHT21Callback, psInst) == 0) + { + // + // The I2C read-modify-write failed, so move to the idle state and + // return a failure. + // + psInst->ui8State = SHT21_STATE_IDLE; + return(0); + } + + // + // Success. + // + return(1); +} + +//***************************************************************************** +// +//! Reads the temperature and humidity data from the SHT21. +//! +//! \param psInst is a pointer to the SHT21 instance data +//! \param pfnCallback is the function to be called when the data has been read +//! (can be \b NULL if a callback is not required). +//! \param pvCallbackData is a pointer that is passed to the callback function. +//! +//! This function initiates a read of the SHT21 data registers. The user must +//! first initiate a measurement by using the SHT21Write() function configured +//! to write the command for a humidity or temperature measurement. In the +//! case of a measurement with I2C bus hold, this function is not needed. When +//! the read has completed (as indicated by callback function), the new +//! readings can be obtained via: +//! +//! - SHT21DataTemperatureGetRaw() +//! - SHT21DataTemperatureGetFloat() +//! - SHT21DataHumidityGetRaw() +//! - SHT21DataHumidityGetFloat() +//! +//! \return Returns 1 if the read was successfully started and 0 if it was not. +// +//***************************************************************************** +uint_fast8_t +SHT21DataRead(tSHT21 *psInst, tSensorCallback *pfnCallback, + void *pvCallbackData) +{ + // + // Return a failure if the SHT21 driver is not idle (in other words, there + // is already an outstanding request to the SHT21). + // + if(psInst->ui8State != SHT21_STATE_IDLE) + { + return(0); + } + + // + // Save the callback information. + // + psInst->pfnCallback = pfnCallback; + psInst->pvCallbackData = pvCallbackData; + + // + // Move the state machine to the wait for data read state. + // + psInst->ui8State = SHT21_STATE_READ_DATA; + + // + // Read the data registers from the SHT21. + // + if(I2CMRead(psInst->psI2CInst, psInst->ui8Addr, 0, 0, psInst->pui8Data, 2, + SHT21Callback, psInst) == 0) + { + psInst->ui8State = SHT21_STATE_IDLE; + return(0); + } + + // + // Success. + // + return(1); +} + +//***************************************************************************** +// +//! Returns the raw temperature measurement as received from the SHT21. +//! +//! \param psInst is a pointer to the SHT21 instance data. +//! \param pui16Temperature is a pointer to the value into which the raw +//! temperature data is stored. +//! +//! This function returns the raw temperature data from the most recent data +//! read. The data is not manipulated in any way by the driver. +//! +//! \return None. +// +//***************************************************************************** +void +SHT21DataTemperatureGetRaw(tSHT21 *psInst, uint16_t *pui16Temperature) +{ + // + // Return the raw temperature value. + // + *pui16Temperature = ((((uint16_t)psInst->pui8Data[0]) << 8) | + (uint16_t)psInst->pui8Data[1]); +} + +//***************************************************************************** +// +//! Returns the most recent temperature measurement in floating point degrees +//! Celsius. +//! +//! \param psInst is a pointer to the SHT21 instance data. +//! \param pfTemperature is a pointer to the value into which the temperature +//! data is stored. +//! +//! This function converts the raw temperature measurement data into floating +//! point degrees Celsius and returns the result. See the SHT21 datasheet +//! section 6.2 for more information about the conversion formula used. +//! +//! \return None. +// +//***************************************************************************** +void +SHT21DataTemperatureGetFloat(tSHT21 *psInst, float *pfTemperature) +{ + uint16_t ui16TemperatureRaw; + + // + // Get the raw temperature into a floating point variable + // + SHT21DataTemperatureGetRaw(psInst, &ui16TemperatureRaw); + *pfTemperature = (float)(ui16TemperatureRaw & 0xFFFC); + + // + // Equation from SHT21 datasheet for raw to Celsius conversion. + // + *pfTemperature = -46.85 + 175.72 * (*pfTemperature / 65536.0); +} + +//***************************************************************************** +// +//! Returns the raw humidity measurement from the SHT21. +//! +//! \param psInst is a pointer to the SHT21 instance data. +//! \param pui16Humidity is a pointer to the value into which the raw humidity +//! data is stored. +//! +//! This function returns the raw humidity data from the most recent data read. +//! The data is not manipulated in any way by the driver. +//! +//! \return None. +// +//***************************************************************************** +void +SHT21DataHumidityGetRaw(tSHT21 *psInst, uint16_t *pui16Humidity) +{ + // + // Return the raw humidity value. + // + *pui16Humidity = ((((uint16_t)psInst->pui8Data[0]) << 8) | + (uint16_t)psInst->pui8Data[1]); +} + +//***************************************************************************** +// +//! Returns the relative humidity measurement as a floating point percentage. +//! +//! \param psInst pointer to the SHT21 instance data. +//! \param pfHumidity is a pointer to the value into which the humidity data +//! is stored. +//! +//! This function converts the raw humidity measurement to +//! floating-point-percentage relative humidity over water. For more +//! information on the conversion algorithm see the SHT21 datasheet section +//! 6.1. +//! +//! \return None. +// +//***************************************************************************** +void +SHT21DataHumidityGetFloat(tSHT21 *psInst, float *pfHumidity) +{ + uint16_t ui16HumidityRaw; + + // + // Convert the raw measure to float for later math. + // + SHT21DataHumidityGetRaw(psInst, &ui16HumidityRaw); + *pfHumidity = (float)(ui16HumidityRaw & 0xFFFC); + + // + // Convert from raw measurement to percent relative humidity over water + // per the datasheet formula. + // + *pfHumidity = -6.0 + 125.0 * (*pfHumidity / 65536.0); + + // + // Convert to a number from 0 to 1.0 instead of 0 to 100%. + // + *pfHumidity /= 100.0; +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** -- cgit v1.3.1