MZ_Addon_Si1133.c

Go to the documentation of this file.

/*
 * MZ_Addon_Si1133.c
 *
 *  Created on: Aug 26, 2021
 *      Author: SKM
 */
 
/*
 * This is a sample implementation of the Si1133 driver as per data sheet.
 * Please refer Si1133 data sheet for details
 */
 
#include "MZ_Addon_Si1133.h"
#include "MZ_error_handler.h"
#include "stm32l4xx_hal.h"
#include "MZ_Addon_board_Si1133_i2c.h"
 
#define X_ORDER_MASK            0x0070
#define Y_ORDER_MASK            0x0007
#define SIGN_MASK               0x0080
#define GET_X_ORDER(m)          ( ((m) & X_ORDER_MASK) >> 4)
#define GET_Y_ORDER(m)          ( ((m) & Y_ORDER_MASK) )
#define GET_SIGN(m)             ( ((m) & SIGN_MASK) >> 7)
 
#define UV_INPUT_FRACTION       15
#define UV_OUTPUT_FRACTION      12
#define UV_NUMCOEFF             2
 
#define ADC_THRESHOLD           16000
#define INPUT_FRACTION_HIGH     7
#define INPUT_FRACTION_LOW      15
#define LUX_OUTPUT_FRACTION     12
#define NUMCOEFF_LOW            9
#define NUMCOEFF_HIGH           4
 
/* I2C transmit and Receive API has been integrated here */
#define UV_I2C_SEND(ADDRESS,LEN,TIME)   MZ_I2C_Master_Transmit(MZ_ADDONUV_I2C_INSTANCE,SLAVE_ADD,(uint8_t *) ADDRESS,LEN,TIME)
#define UV_I2C_GET(ADDRESS,LEN,TIME)    MZ_I2C_Master_Receive(MZ_ADDONUV_I2C_INSTANCE,SLAVE_ADD,(uint8_t *) ADDRESS,LEN,TIME)
#define SI1133_CONFIRM_COUNT            (5)
 
/*
 * @brief
 *    Coefficients for lux calculation
 */
const Si1133_LuxCoeff Si1133_lk =
{
    {   {     0, 209 },           
        {  1665, 93  },           
        {  2064, 65  },           
        { -2671, 234 } },         
    {   {     0, 0   },           
        {  1921, 29053 },         
        { -1022, 36363 },         
        {  2320, 20789 },         
        {  -367, 57909 },         
        { -1774, 38240 },         
        {  -608, 46775 },         
        { -1503, 51831 },         
        { -1886, 58928 } }        
};
 
/*
 * @brief
 *    Coefficients for UV index calculation
 */
 
const Si1133_coeff Si1133_uk[2] =
{
    { 1281, 30902 },            
    { -638, 46301 }             
};
 
static Si1133_error SI1133_Write_Reg(Si1133_register w_addr, uint8_t data)
{
    uint8_t _Buff[2];
    _Buff[0] = (uint8_t)w_addr;
    _Buff[1] = data;
 
    // Write the write register address and value in the slave memory
    if(MZ_OK == UV_I2C_SEND(_Buff,2,1000))
    {
        return SI_OK;
    }
    return SI_FAIL;
}
 
static Si1133_error SI1133_Write_Reg_block(Si1133_register w_addr, uint8_t len, uint8_t *data)
{
    uint8_t _Buff[2];
 
    if (len > 2) {
        return SI_FAIL;
    }
 
    _Buff[0] = (uint8_t)w_addr;
    memcpy(&_Buff[1], data, len);
 
    // Write the write register address and value in the slave memory
    if(MZ_OK == UV_I2C_SEND(_Buff,len+1,1000))
    {
        return SI_OK;
    }
    return SI_FAIL;
}
 
static Si1133_error SI1133_Read_Reg(Si1133_register r_addr, uint8_t *buf)
{
    uint8_t _Buf = (uint8_t)r_addr;
 
    // Write the read register address in the slave memory
    if(MZ_OK == UV_I2C_SEND(&_Buf,1,1000))
    {
        // Read the value on that register
        if(MZ_OK == UV_I2C_GET(&_Buf,1,1000))
        {
            *buf = _Buf;
            return SI_OK;
        }
    }
    return SI_FAIL;
}
 
static Si1133_error SI1133_Read_Reg_block(Si1133_register r_addr, uint8_t len, uint8_t *buf)
{
    uint8_t _Buf = (uint8_t)r_addr;
 
    // Write the read register address in the slave memory
    if(MZ_OK == UV_I2C_SEND(&_Buf,1,1000))
    {
        // Read the value on that register
        if(MZ_OK == UV_I2C_GET(buf,len,1000))
        {
            return SI_OK;
        }
    }
    return SI_FAIL;
}
 
static Si1133_error SI1133_reset(void)
{
    Si1133_error _ret;
 
    /* Delay 30 ms for sensor power-up time */
    HAL_Delay(30);
 
    /* Perform the Reset Command */
    _ret = SI1133_Write_Reg(SI1133_REG_COMMAND, (uint8_t)SI1133_CMD_RESET);
 
    /*
     * Delay for 10 ms. This delay is needed to allow the Si1133 to perform
     * internal reset sequence.
     */
    HAL_Delay(10);
 
    return _ret;
}
 
static Si1133_error SI1133_wait_until_sleep(void)
{
    Si1133_error _ret;
    uint8_t response;
 
    /*
    * This loops until the Si1133 is known to be in its sleep state
    * or if an i2c error occurs
    */
    for(uint8_t count = 0; count < SI1133_CONFIRM_COUNT; count++)
    {
        _ret = SI1133_Read_Reg(SI1133_REG_RESPONSE0, &response);
        /* If read fail or any error stop and return */
        if (SI_OK != _ret) { return _ret; }
 
        /* If sleep complete return */
        if((response & (uint8_t)SI1133_RSP0_CHIPSTAT_MASK) == (uint8_t)SI1133_RSP0_SLEEP )
        {
            return SI_OK;
        }
    }
 
    /* If not sleep in time then return fail */
    return SI_FAIL;
}
 
static Si1133_error SI1133_send_cmd(Si1133_command command)
{
    uint8_t response;
    uint8_t response_initial;
 
    Si1133_error _ret;
 
    /* Get the response register contents */
    _ret = SI1133_Read_Reg(SI1133_REG_RESPONSE0, &response_initial);
    if (SI_OK != _ret) { return _ret; }
 
    response_initial = response_initial & (uint8_t)SI1133_RSP0_COUNTER_MASK;
 
    /* Make sure the response register is consistent */
    for(uint8_t count = 0; count < SI1133_CONFIRM_COUNT; count++)
    {
        _ret = SI1133_wait_until_sleep();
        /* If the sensor is not going to sleep or any error stop and return */
        if (SI_OK != _ret) { return _ret; }
 
        /* Skip if the command is RESET COMMAND COUNTER */
        if (command == (uint8_t)SI1133_CMD_RESET_CMD_CTR) { break; }
 
        /* Read the response register again */
        _ret = SI1133_Read_Reg(SI1133_REG_RESPONSE0, &response);
        /* If read fail or any error stop and return */
        if (SI_OK != _ret) { return _ret; }
 
        /* Check if the value is same as previous value once */
        if ((response & (uint8_t)SI1133_RSP0_COUNTER_MASK) == response_initial)
        {
            break;
        }
        else
        {
            /* store the new value to check */
            response_initial = response & (uint8_t)SI1133_RSP0_COUNTER_MASK;
        }
    }
 
    /* Send the command */
    _ret = SI1133_Write_Reg(SI1133_REG_COMMAND, command);
    /* If write fail or any error stop and return */
    if (SI_OK != _ret) { return _ret; }
 
    /* Expect a change in the response register */
    uint8_t count = 0;
    for(uint8_t count = 0; count < SI1133_CONFIRM_COUNT; count++)
    {
        /* Skip if the command is RESET COMMAND COUNTER */
        if ( command == (uint8_t)SI1133_CMD_RESET_CMD_CTR ) { break; }
 
        _ret = SI1133_Read_Reg(SI1133_REG_RESPONSE0, &response);
        /* If read fail or any error stop and return */
        if (SI_OK != _ret) { return _ret; }
 
        /* Check if response change once to confirm writing */
        if ((response & (uint8_t)SI1133_RSP0_COUNTER_MASK) != response_initial)
        {
            break;
        }
    }
 
    if (count >= SI1133_CONFIRM_COUNT)
    {
        return SI_FAIL;
    }
 
    return SI_OK;
}
 
#if 0
static Si1133_error SI1133_reset_cmd_counter(void)
{
    return SI1133_send_cmd(SI1133_CMD_RESET_CMD_CTR);
}
#endif
static Si1133_error SI1133_force_measurement(void)
{
    return SI1133_send_cmd(SI1133_CMD_FORCE_CH);
}
#if 0
static Si1133_error SI1133_start_measurement(void)
{
    return SI1133_send_cmd(SI1133_CMD_START);
}
#endif
static Si1133_error SI1133_pause_measurement(void)
{
  return SI1133_send_cmd(SI1133_CMD_PAUSE_CH);
}
 
static Si1133_error SI1133_set_parameter(Si1133_parameter address, uint8_t value)
{
    Si1133_error _ret;
    uint8_t param_Buff[2];
    uint8_t response_initial;
    uint8_t response;
 
    _ret = SI1133_wait_until_sleep();
    /* If the sensor is not going to sleep or any error stop and return */
    if (SI_OK != _ret) { return _ret; }
 
    /* Get the response register contents */
    _ret = SI1133_Read_Reg(SI1133_REG_RESPONSE0, &response_initial);
    if (SI_OK != _ret) { return _ret; }
 
    response_initial = response_initial & (uint8_t)SI1133_RSP0_COUNTER_MASK;
 
    param_Buff[0] = value;
    param_Buff[1] = 0x80 + ((uint8_t)address & 0x3F);
 
    _ret = SI1133_Write_Reg_block(SI1133_REG_HOSTIN0, 2, param_Buff);
    if (SI_OK != _ret) { return _ret; }
 
    /* Wait for command to finish */
    uint8_t count = 0;
    for(; count < SI1133_CONFIRM_COUNT; count++)
    {
        _ret = SI1133_Read_Reg(SI1133_REG_RESPONSE0, &response);
        /* If read fail or any error stop and return */
        if (SI_OK != _ret) { return _ret; }
 
        /* Check if response change once to confirm writing */
        if ((response & (uint8_t)SI1133_RSP0_COUNTER_MASK) != response_initial)
        {
            break;
        }
    }
 
    if (count >= SI1133_CONFIRM_COUNT)
    {
        return SI_FAIL;
    }
 
    return SI_OK;
}
 
static int32_t SI1133_calculate_polynomial_helper (int32_t input,
                                                    int8_t fraction,
                                                    uint16_t mag,
                                                    int8_t shift)
{
    int32_t value;
 
    if ( shift < 0 ) {
        value = ( (input << fraction) / mag) >> -shift;
    } else {
        value = ( (input << fraction) / mag) << shift;
    }
 
    return value;
}
 
static int32_t SI1133_calculate_polynomial(int32_t x,
                                    int32_t y,
                                    uint8_t input_fraction,
                                    uint8_t output_fraction,
                                    uint8_t num_coeff,
                                    const Si1133_coeff *kp)
{
    uint8_t info, x_order, y_order, counter;
    int8_t sign, shift;
    uint16_t mag;
    int32_t output = 0, x1, x2, y1, y2;
 
    for ( counter = 0; counter < num_coeff; counter++ ) {
        info = kp->info;
        x_order = GET_X_ORDER(info);
        y_order = GET_Y_ORDER(info);
 
        shift = ( (uint16_t) kp->info & 0xff00) >> 8;
        shift ^= 0x00ff;
        shift += 1;
        shift = -shift;
 
        mag = kp->mag;
 
        if ( GET_SIGN(info) ) {
            sign = -1;
        } else {
            sign = 1;
        }
 
        if ( (x_order == 0) && (y_order == 0) ) {
            output += sign * mag << output_fraction;
        } else {
            if ( x_order > 0 ) {
                x1 = SI1133_calculate_polynomial_helper(x, input_fraction, mag, shift);
                if ( x_order > 1 ) {
                    x2 = SI1133_calculate_polynomial_helper(x, input_fraction, mag, shift);
                } else {
                    x2 = 1;
                }
            } else {
                x1 = 1;
                x2 = 1;
            }
 
            if ( y_order > 0 ) {
                y1 = SI1133_calculate_polynomial_helper(y, input_fraction, mag, shift);
                if ( y_order > 1 ) {
                    y2 = SI1133_calculate_polynomial_helper(y, input_fraction, mag, shift);
                } else {
                    y2 = 1;
                }
            } else {
                y1 = 1;
                y2 = 1;
            }
 
            output += sign * x1 * x2 * y1 * y2;
        }
 
        kp++;
    }
 
    if ( output < 0 ) {
        output = -output;
    }
 
    return output;
}
 
static int32_t SI1133_get_uv (int32_t uv)
{
    int32_t uvi;
 
    uvi = SI1133_calculate_polynomial(0, uv, UV_INPUT_FRACTION, UV_OUTPUT_FRACTION, UV_NUMCOEFF, Si1133_uk);
 
    return uvi;
}
 
static int32_t SI1133_get_lux (int32_t vis_high, int32_t vis_low, int32_t ir)
{
    int32_t lux;
 
    if ( (vis_high > ADC_THRESHOLD) || (ir > ADC_THRESHOLD) )
    {
        lux = SI1133_calculate_polynomial(vis_high,
                                   ir,
                                   INPUT_FRACTION_HIGH,
                                   LUX_OUTPUT_FRACTION,
                                   NUMCOEFF_HIGH,
                                   &(Si1133_lk.coeff_high[0]));
    }
    else
    {
        lux = SI1133_calculate_polynomial(vis_low,
                                   ir,
                                   INPUT_FRACTION_LOW,
                                   LUX_OUTPUT_FRACTION,
                                   NUMCOEFF_LOW,
                                   &(Si1133_lk.coeff_low[0]) );
    }
 
    return lux;
}
 
/* --- PUBLIC FUNCTION --- */
Si1133_error SI1133_init (void)
{
    Si1133_error _ret;
 
    /* Allow some time for the part to power up */
    HAL_Delay(5);
 
    _ret = SI1133_reset();
 
    HAL_Delay(10);
 
    _ret += SI1133_set_parameter(SI1133_PARAM_CH_LIST, 0x0F);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCCONFIG0, 0x78);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCSENS0, 0x71);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCPOST0, 0x40);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCCONFIG1, 0x4D);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCSENS1, 0xE1);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCPOST1, 0x40);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCCONFIG2, 0x41);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCSENS2, 0xE1);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCPOST2, 0x50);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCCONFIG3, 0x4D);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCSENS3, 0x87);
    _ret += SI1133_set_parameter(SI1133_PARAM_ADCPOST3, 0x40);
 
    _ret += SI1133_Write_Reg(SI1133_REG_IRQ_ENABLE, 0x0F);
 
    return _ret;
}
 
Si1133_error SI1133_deinit (void)
{
    Si1133_error _ret;
 
    _ret = SI1133_set_parameter(SI1133_PARAM_CH_LIST, 0x3F);
    _ret += SI1133_pause_measurement();
    _ret += SI1133_wait_until_sleep();
 
    return _ret;
}
 
static Si1133_error SI1133_measure (Si1133_samples *_s1)
{
    uint8_t buffer[13];
    Si1133_error _ret;
    Si1133_samples sample;
    Si1133_samples *samples = &sample;
 
    _ret = SI1133_Read_Reg_block(SI1133_REG_IRQ_STATUS, 13, buffer);
 
    samples->irq_status = buffer[0];
 
    samples->ch0 = buffer[1] << 16;
    samples->ch0 |= (buffer[2] << 8);
    samples->ch0 |= buffer[3];
    if ( samples->ch0 & 0x800000 ) {
        samples->ch0 |= 0xFF000000;
    }
 
    samples->ch1 = buffer[4] << 16;
    samples->ch1 |= buffer[5] << 8;
    samples->ch1 |= buffer[6];
    if ( samples->ch1 & 0x800000 ) {
        samples->ch1 |= 0xFF000000;
    }
 
    samples->ch2 = buffer[7] << 16;
    samples->ch2 |= buffer[8] << 8;
    samples->ch2 |= buffer[9];
    if ( samples->ch2 & 0x800000 ) {
        samples->ch2 |= 0xFF000000;
    }
 
    samples->ch3 = buffer[10] << 16;
    samples->ch3 |= buffer[11] << 8;
    samples->ch3 |= buffer[12];
    if ( samples->ch3 & 0x800000 ) {
        samples->ch3 |= 0xFF000000;
    }
 
    memcpy(_s1,&sample,sizeof(Si1133_samples));
 
    return _ret;
}
 
Si1133_error SI1133_get_hardware_id (uint8_t *hardware_id)
{
    return SI1133_Read_Reg(SI1133_REG_PART_ID, hardware_id);
}
 
Si1133_error SI1133_measure_lux_uv (float *lux, float *uvi)
{
    Si1133_samples _samples;
    Si1133_error _ret;
    uint8_t response;
 
    /* Force measurement */
    _ret = SI1133_force_measurement();
 
    /* Go to sleep while the sensor does the conversion */
    HAL_Delay(200);
 
    /* Check if the measurement finished, if not then wait */
    _ret += SI1133_Read_Reg(SI1133_REG_IRQ_STATUS, &response);
    while ( response != 0x0F ) {
        HAL_Delay(5);
        _ret += SI1133_Read_Reg(SI1133_REG_IRQ_STATUS, &response);
    }
 
    /* Get the results */
    memset(&_samples,0,sizeof(_samples));
    _ret += SI1133_measure(&_samples);
 
    /* Convert the readings to lux */
    *lux = (float) SI1133_get_lux(_samples.ch1, _samples.ch3, _samples.ch2);
    *lux = *lux / (float) (1 << LUX_OUTPUT_FRACTION);
 
    /* Convert the readings to UV index */
    *uvi = SI1133_get_uv(_samples.ch0);
    *uvi = *uvi / (float)(1 << UV_OUTPUT_FRACTION);
 
    return _ret;
}
 
 
Si1133_error SI1133_get_measurement (float *lux, float *uvi)
{
    Si1133_samples samples;
    uint32_t _ret;
 
    /* Get the results */
    _ret = SI1133_measure(&samples);
 
    /* Convert the readings to lux */
    *lux = (float)SI1133_get_lux(samples.ch1, samples.ch3, samples.ch2);
    *lux = *lux / (float)(1 << LUX_OUTPUT_FRACTION);
 
    /* Convert the readings to UV index */
    *uvi = (float)SI1133_get_uv(samples.ch0);
    *uvi = *uvi / (float)(1 << UV_OUTPUT_FRACTION);
 
    return _ret;
}
 
float SI1133_get_light_level(void)
{
    float lux, uvi;
    (void)SI1133_measure_lux_uv(&lux, &uvi);
    return lux;
}
 
float SI1133_get_uv_index(void)
{
    float lux, uvi;
    (void)SI1133_measure_lux_uv(&lux, &uvi);
    return uvi;
}