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/isl29023.c | 668 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 668 insertions(+) create mode 100644 sensorlib/isl29023.c (limited to 'sensorlib/isl29023.c') diff --git a/sensorlib/isl29023.c b/sensorlib/isl29023.c new file mode 100644 index 0000000..313ced9 --- /dev/null +++ b/sensorlib/isl29023.c @@ -0,0 +1,668 @@ +//***************************************************************************** +// +// isl29023.c - Driver for the ISL29023 Light Sensor +// +// 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 +#include "sensorlib/hw_isl29023.h" +#include "sensorlib/i2cm_drv.h" +#include "sensorlib/isl29023.h" + +//***************************************************************************** +// +//! \addtogroup isl29023_api +//! @{ +// +//***************************************************************************** + +//***************************************************************************** +// +// Range setting to floating point range value lookup table +// +//***************************************************************************** +const float g_fRangeLookup[4] = +{ + 1000.0, + 4000.0, + 16000.0, + 64000.0 +}; + +//***************************************************************************** +// +// Resolution setting to floating point resolution value lookup table +// +//***************************************************************************** +const float g_fResolutionLookup[4] = +{ + 65536.0, + 4096.0, + 256.0, + 16.0 +}; + +//***************************************************************************** +// +// Beta value lookup based on datasheet typical values for DATA_IR1, DATA_IR2, +// DATA_IR3, DATA_IR4. These should be reasonable for 16 bit conversions. +// However, Beta changes with resolution and background IR conditions. +// +//***************************************************************************** +const float g_fBetaLookup[4] = +{ + 95.238, + 23.810, + 5.952, + 1.486 +}; + +//***************************************************************************** +// +// The states of the ISL29023 state machine. +// +//***************************************************************************** +#define ISL29023_STATE_IDLE 0 +#define ISL29023_STATE_INIT 1 +#define ISL29023_STATE_READ 2 +#define ISL29023_STATE_WRITE 3 +#define ISL29023_STATE_RMW 4 +#define ISL29023_STATE_READ_DATA 5 + +//***************************************************************************** +// +// The callback function that is called when I2C transations to/from the +// ISL29023 have completed. +// +//***************************************************************************** +static void +ISL29023Callback(void *pvCallbackData, uint_fast8_t ui8Status) +{ + tISL29023 *psInst; + uint8_t *pui8Data; + + // + // Convert the instance data into a pointer to a tBMA180 structure. + // + psInst = (tISL29023 *)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 = ISL29023_STATE_IDLE; + } + + // + // Determine the current state of the ISL29023 state machine. + // + switch(psInst->ui8State) + { + // + // All states that trivially transition to IDLE, and all unknown + // states. + // + case ISL29023_STATE_INIT: + case ISL29023_STATE_READ: + case ISL29023_STATE_READ_DATA: + default: + { + // + // A register operation is complete. Return to IDLE state + // the value read from the register is in the pui8Data buffer and + // can be accessed directly by the calling application after + // receiving the callback. + // + psInst->ui8State = ISL29023_STATE_IDLE; + break; + } + + // + // A write to the ISL29023 control and config registers is complete. + // + case ISL29023_STATE_WRITE: + { + // + // Set the range and resolution to the new values. If the register + // was not modified, the values will be the same so this has no + // effect. + // + psInst->ui8Range = psInst->ui8NewRange; + psInst->ui8Resolution = psInst->ui8NewResolution; + + // + // The state machine is now idle. + // + psInst->ui8State = ISL29023_STATE_IDLE; + + // + // Done. + // + break; + } + + // + // A read modify write operation has just completed. + // + case ISL29023_STATE_RMW: + { + // + // Check if the register that was written contained the range or + // resolution data that we need to track. + // + pui8Data = psInst->uCommand.sReadModifyWriteState.pui8Buffer; + if((pui8Data[0] == ISL29023_O_CMD_II) && + (ui8Status == I2CM_STATUS_SUCCESS)) + { + // + // Store the latest range and resolution settings + // + psInst->ui8Range = ((pui8Data[1] & ISL29023_CMD_II_RANGE_M) >> + ISL29023_CMD_II_RANGE_S); + psInst->ui8Resolution = ((pui8Data[1] & + ISL29023_CMD_II_ADC_RES_M) >> + ISL29023_CMD_II_ADC_RES_S); + } + + // + // The state machine is now idle. + // + psInst->ui8State = ISL29023_STATE_IDLE; + + // + // Done. + // + break; + } + } + + // + // See if the state machine is now idle and there is a callback function. + // + if((psInst->ui8State == ISL29023_STATE_IDLE) && psInst->pfnCallback) + { + // + // Call the application-supplied callback function. + // + psInst->pfnCallback(psInst->pvCallbackData, ui8Status); + } +} + +//***************************************************************************** +// +//! Initializes the ISL29023 driver. +//! +//! \param psInst is a pointer to the ISL29023 instance data. +//! \param psI2CInst is a pointer to the I2C driver instance data. +//! \param ui8I2CAddr is the I2C address of the ISL29023 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 ISL29023 driver, preparing it for operation. +//! This function also asserts a reset signal to the ISL29023 to clear any +//! previous configuration data. +//! +//! \return Returns 1 if the ISL29023 driver was successfully initialized and 0 +//! if it was not. +// +//***************************************************************************** +uint_fast8_t +ISL29023Init(tISL29023 *psInst, tI2CMInstance *psI2CInst, + uint_fast8_t ui8I2CAddr, tSensorCallback *pfnCallback, + void *pvCallbackData) +{ + // + // Initialize the ISL29023 instance structure + // + psInst->psI2CInst = psI2CInst; + psInst->ui8Addr = ui8I2CAddr; + psInst->ui8State = ISL29023_STATE_INIT; + psInst->ui8Range = ISL29023_CMD_II_RANGE_1K >> ISL29023_CMD_II_RANGE_S; + psInst->ui8NewRange = ISL29023_CMD_II_RANGE_1K >> ISL29023_CMD_II_RANGE_S; + psInst->ui8Resolution = (ISL29023_CMD_II_ADC_RES_16 >> + ISL29023_CMD_II_ADC_RES_S); + psInst->ui8NewResolution = (ISL29023_CMD_II_ADC_RES_16 >> + ISL29023_CMD_II_ADC_RES_S); + + // + // Save the callback information. + // + psInst->pfnCallback = pfnCallback; + psInst->pvCallbackData = pvCallbackData; + + // + // Put the device into power down mode. + // + psInst->pui8Data[0] = ISL29023_O_CMD_I; + psInst->pui8Data[1] = ISL29023_CMD_I_OP_MODE_POWER_DOWN; + if(I2CMWrite(psInst->psI2CInst, psInst->ui8Addr, psInst->pui8Data, 2, + ISL29023Callback, psInst) == 0) + { + // + // The I2C write failed, so move to the idle state and return a + // failure. + // + psInst->ui8State = ISL29023_STATE_IDLE; + return(0); + } + + // + // Success + // + return(1); +} + +//***************************************************************************** +// +//! Reads data from ISL29023 registers. +//! +//! \param psInst is a pointer to the ISL29023 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 is 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 is a pointer that is passed to the callback function. +//! +//! This function reads a sequence of data values from consecutive registers in +//! the ISL29023. +//! +//! \return Returns 1 if the write was successfully started and 0 if it was +//! not. +// +//***************************************************************************** +uint_fast8_t +ISL29023Read(tISL29023 *psInst, uint_fast8_t ui8Reg, uint8_t *pui8Data, + uint_fast16_t ui16Count, tSensorCallback *pfnCallback, + void *pvCallbackData) +{ + // + // Return a failure if the ISL29023 driver is not idle (in other words, + // there is already an outstanding request to the ISL29023). + // + if(psInst->ui8State != ISL29023_STATE_IDLE) + { + return(0); + } + // + // Store the Callback information + // + psInst->pfnCallback = pfnCallback; + psInst->pvCallbackData = pvCallbackData; + + // + // set ISL29023 state + // + psInst->ui8State = ISL29023_STATE_READ; + + // + // Load the command buffer with the appropriate register information + // + psInst->uCommand.pui8Buffer[0] = ui8Reg; + + // + // Start the I2CM read and return indication. + // + if(I2CMRead(psInst->psI2CInst, psInst->ui8Addr, + psInst->uCommand.pui8Buffer, 1, pui8Data, ui16Count, + ISL29023Callback, psInst) == 0) + { + psInst->ui8State = ISL29023_STATE_IDLE; + return(0); + } + + return(1); +} + +//***************************************************************************** +// +//! Write register data to the ISL29023. +//! +//! \param psInst is a pointer to the ISL29023 instance data. +//! \param ui8Reg is the first register to write. +//! \param pui8Data is a pointer to the data to write. +//! \param ui16Count is the number of data 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 ISL29023. 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 +ISL29023Write(tISL29023 *psInst, uint_fast8_t ui8Reg, uint8_t *pui8Data, + uint_fast16_t ui16Count, tSensorCallback *pfnCallback, + void *pvCallbackData) +{ + // + // Return a failure if the ISL29023 driver is not idle (in other words, + // there is already an outstanding request to the ISL29023). + // + if(psInst->ui8State != ISL29023_STATE_IDLE) + { + return(0); + } + + // + // Save the callback information + // + psInst->pfnCallback = pfnCallback; + psInst->pvCallbackData = pvCallbackData; + + // + // See if the CMD_II register is being written. + // + if((ui8Reg <= ISL29023_O_CMD_II) && + ((ui8Reg + ui16Count) > ISL29023_O_CMD_II)) + { + // + // Extract the range and resolution from the CMD_II register value. + // + psInst->ui8NewRange = ((pui8Data[ui8Reg - ISL29023_O_CMD_II] & + ISL29023_CMD_II_RANGE_M) >> + ISL29023_CMD_II_RANGE_S); + psInst->ui8NewResolution = ((pui8Data[ui8Reg - ISL29023_O_CMD_II] & + ISL29023_CMD_II_ADC_RES_M) >> + ISL29023_CMD_II_ADC_RES_S); + } + + // + // Move state machine to the write state + // + psInst->ui8State = ISL29023_STATE_WRITE; + + // + // Add the i2c address and the register offset to the data buffer. + // + if(I2CMWrite8(&(psInst->uCommand.sWriteState), psInst->psI2CInst, + psInst->ui8Addr, ui8Reg, pui8Data, ui16Count, + ISL29023Callback, psInst) == 0) + { + // + // I2C write failed, move to idle state and return the failure. + // + psInst->ui8State = ISL29023_STATE_IDLE; + return(0); + } + + // + // Success. + // + return(1); +} + +//***************************************************************************** +// +//! Performs a read-modify-write of an ISL29023 register. +//! +//! \param psInst is a pointer to the ISL29023 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 ISL29023 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 +//! ISL29023. +//! +//! \return Returns 1 if the read-modify-write was successfully started and 0 +//! if it was not. +// +//***************************************************************************** +uint_fast8_t +ISL29023ReadModifyWrite(tISL29023 *psInst, uint_fast8_t ui8Reg, + uint8_t ui8Mask, uint8_t ui8Value, + tSensorCallback *pfnCallback, void *pvCallbackData) +{ + // + // Return a failure if the ISL29023 driver is not in the idle state. + // + if(psInst->ui8State != ISL29023_STATE_IDLE) + { + return(0); + } + + // + // Save the callback information + // + psInst->pfnCallback = pfnCallback; + psInst->pvCallbackData = pvCallbackData; + + // + // set ISL29023 state + // + psInst->ui8State = ISL29023_STATE_RMW; + + // + // Submit the read-modify-write request to the ISL29023. + // + if(I2CMReadModifyWrite8(&(psInst->uCommand.sReadModifyWriteState), + psInst->psI2CInst, psInst->ui8Addr, ui8Reg, + ui8Mask, ui8Value, ISL29023Callback, psInst) == 0) + { + // + // The I2C read-modify-write failed, so move to the idle state and + // return a failure. + // + psInst->ui8State = ISL29023_STATE_IDLE; + return(0); + } + + // + // Success. + // + return(1); +} + +//***************************************************************************** +// +//! Reads the light data from the ISL29023. +//! +//! \param psInst is a pointer to the ISL29023 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 ISL29023 data registers. When the +//! read has completed (as indicated by calling the callback function), the new +//! readings can be obtained via: +//! +//! - ISL29023DataLightVisibleGetRaw() +//! - ISL29023DataLightVisibleGetFloat() +//! - ISL29023DataLightIRGetRaw() +//! - ISL29023DataLightIRGetFloat() +//! +//! \return Returns 1 if the read was successfully started and 0 if it was not. +// +//***************************************************************************** +uint_fast8_t +ISL29023DataRead(tISL29023 *psInst, tSensorCallback *pfnCallback, + void *pvCallbackData) +{ + // + // Return a failure if the ISL29023 driver is not idle (in other words, + // there is already an outstanding request to the ISL29023). + // + if(psInst->ui8State != ISL29023_STATE_IDLE) + { + return(0); + } + + // + // Store the Callback information + // + psInst->pfnCallback = pfnCallback; + psInst->pvCallbackData = pvCallbackData; + + // + // set ISL29023 state + // + psInst->ui8State = ISL29023_STATE_READ_DATA; + + psInst->uCommand.pui8Buffer[0] = ISL29023_O_DATA_OUT_LSB; + if(I2CMRead(psInst->psI2CInst, psInst->ui8Addr, + psInst->uCommand.pui8Buffer, 1, psInst->pui8Data, 2, + ISL29023Callback, psInst) == 0) + { + // + // The I2C read failed, so move to the idle state and return a failure. + // + psInst->ui8State = ISL29023_STATE_IDLE; + return(0); + } + + // + // Success. + // + return(1); +} + +//***************************************************************************** +// +//! Gets the raw measurement data from the most recent data read. +//! +//! \param psInst is a pointer to the ISL29023 instance data. +//! \param pui16Visible is a pointer to the value into which the raw light data +//! is stored. +//! +//! This function returns the raw measurement data from the most recent data +//! read. The data is not manipulated in any way by the driver. +//! +//! \return None. +// +//***************************************************************************** +void +ISL29023DataLightVisibleGetRaw(tISL29023 *psInst, uint16_t *pui16Visible) +{ + // + // Return the raw light value. + // + *pui16Visible = (psInst->pui8Data[1] << 8) | psInst->pui8Data[0]; +} + +//***************************************************************************** +// +//! Gets the measurement data from the most recent data read. +//! +//! \param psInst is a pointer to the ISL29023 instance data. +//! \param pfVisibleLight is a pointer to the value into which the light data +//! is stored as floating point lux. +//! +//! This function returns the light data from the most recent data read, +//! converted into lux. +//! +//! \return None. +// +//***************************************************************************** +void +ISL29023DataLightVisibleGetFloat(tISL29023 *psInst, float *pfVisibleLight) +{ + uint16_t ui16Light; + float fRange, fResolution; + + // + // Get the raw light data from the instance structure + // + ISL29023DataLightVisibleGetRaw(psInst, &ui16Light); + + // + // Get the floating point values for range and resolution from the lookup. + // + fRange = g_fRangeLookup[psInst->ui8Range]; + fResolution = g_fResolutionLookup[psInst->ui8Resolution]; + + // + // Calculate light reading in lux. + // + *pfVisibleLight = ((float)ui16Light) * (fRange / fResolution); +} + +//***************************************************************************** +// +//! Gets the raw measurement data from the most recent data read. +//! +//! \param psInst is a pointer to the ISL29023 instance data. +//! \param pui16IR is a pointer to the value into which the raw IR data is +//! stored. +//! +//! This function returns the raw measurement data from the most recent data +//! read. The data is not manipulated in any way by the driver. +//! +//! \return None. +// +//***************************************************************************** +void +ISL29023DataLightIRGetRaw(tISL29023 *psInst, uint16_t *pui16IR) +{ + // + // Return the raw light value. + // + *pui16IR = (psInst->pui8Data[1] << 8) | psInst->pui8Data[0]; +} + +//***************************************************************************** +// +//! Gets the measurement data from the most recent data read. +//! +//! \param psInst is a pointer to the ISL29023 instance data. +//! \param pfIR is a pointer to the value into which the IR data is stored as +//! floating point lux. +//! +//! This function returns the IR data from the most recent data read, converted +//! into lux. +//! +//! \return None. +// +//***************************************************************************** +void +ISL29023DataLightIRGetFloat(tISL29023 *psInst, float *pfIR) +{ + uint16_t i16IR; + + ISL29023DataLightIRGetRaw(psInst, &i16IR); + + *pfIR = ((float) i16IR) / g_fBetaLookup[psInst->ui8Range]; +} + +//***************************************************************************** +// +// Close the Doxygen group. +//! @} +// +//***************************************************************************** -- cgit v1.3.1