MZ_i2c_example.c

Go to the documentation of this file.

 
#include "MZ_sys_cmsis_os2.h"
#include "MZ_i2c_example.h"
#include "MZ_timer.h"
#include "MZ_print.h"
#include "MZ_i2c1_instance.h"
#include "MZ_error_handler.h"
#include "MZ_i2c.h"
#include <stdio.h>
#include <math.h>
#include<stdlib.h>
#include "stm32l4xx_hal_i2c.h"
 
#define I2C_APP_STACK_SIZE          (1024)
#define I2C_TX_TIME             (pdMS_TO_TICKS(60000))
#define I2C_TX_SIZE             (10)
#define RESP_BUF_LEN    10
#define SI_SENSOR_BUF_LEN   50
 
static mz_thread_t      i2c_thread_id = NULL;
static StaticTask_t     i2c_cb_mem;
static StackType_t      i2c_stack[I2C_APP_STACK_SIZE];
static mz_semaphore_t   i2c_sema_id = NULL;
static mzUint8 loc_buf[RESP_BUF_LEN];
static mzUint8 resp_buf[RESP_BUF_LEN];
static mzUint8 err_code;
static mzUint8 write_sucess;
static mzUint8 localBuf1[SI_SENSOR_BUF_LEN];
static mzUint8 i2cLocBuf[SI_SENSOR_BUF_LEN];
static mzUint8  locstr1[50];
static mzUint8 send_data[I2C_TX_SIZE];
mzUint8 buf[10];
mzUint32 uv_val,als_val1,als_val2,als_val3;
SISER_RCVD SI_resp_rcvd = SISER_NONE_RCVD;
mzUint8 cnt=0;
 
static void timer_cb(TimerHandle_t xTimer)
{
    mz_puts("Timer expires\r\n");
    MZ_I2C_Master_Transmit_IT(MZ_I2C_INSTANCE,SLAVE_ADD,(uint8_t *)&send_data, sizeof(send_data));
}
 
static void i2c_app(void * arg)
{
    (void)arg;
 
    // create the timer and start when the starts if main RTOS scheduler started
    if(MZ_OK != mz_tm_create_start_recursive("I2c Read timer",I2C_TX_TIME,timer_cb))
    {
        __NOP(); // Timer create and start failed.
    }
    mz_puts("SENSOR Initialization...\r\n");
    SENSOR_Init();
    HAL_Delay(100);
 
    while(1)
    {
        // process the read data from I2C
        //[TODO] condition pending for sensor data read
        SI_Read_UV();
 
    }
 
}
 
/*
 * @fn mz_error_t i2c_app_init(void)
 * @brief creates the App thread and semaphore
 * @return MZ_OK/MZ_FAIL
 */
mz_error_t i2c_app_init(void)
{
    mz_error_t _ret = MZ_OK;
 
    // Initialize I2C 1
    if(MZ_OK != I2C1_init())
        return MZ_FAIL;
 
    // Create the I2c application threads
    if(!mz_thread_create(   &i2c_thread_id,
                            "I2c Scheduler",
                            i2c_app,
                            NULL,
                            osPriorityNormal,
                            i2c_stack,
                            I2C_APP_STACK_SIZE,
                            &i2c_cb_mem,
                            sizeof(i2c_cb_mem)))
    {
        _ret = MZ_THREAD_CREATE_FAIL;
    }
 
    // Create lock with already locked
    if(!mz_sem_create(&i2c_sema_id,1U,1U))
    {
        _ret = MZ_SEMA_CREATE_FAIL;
    }
 
    return _ret;
}
 
mz_error_t I2C_Write_Reg(uint8_t addr, uint8_t data)
{
    mz_error_t _ret = MZ_OK;
    uint16_t tlen;
    tlen = 2;
    uint8_t I2CLocBuf[5] = { 0x00, 0x00, 0x00, 0x00, 0x00 };
    I2CLocBuf[0] = SI_REG_RA(addr);
    I2CLocBuf[1] = data;
 
    if(MZ_I2C_Master_Transmit(MZ_I2C_INSTANCE,SI_SL_ADD,(uint8_t *) I2CLocBuf,tlen,1000)==MZ_OK)
    {
        _ret = 0xFF;
    }
    return _ret;
}
 
 
mz_error_t I2C_Read_Reg(uint8_t addr, uint32_t *buf)
{
    mz_error_t _ret = MZ_OK;
    uint16_t tlen;
    uint16_t dlen;
    tlen = 1;
    dlen = 2;
    uint8_t I2CLocBuf[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
    I2CLocBuf[0] = SI_REG_RA(addr);
 
    if(MZ_I2C_Master_Transmit(MZ_I2C_INSTANCE,SI_SL_ADD,(uint8_t *) I2CLocBuf,tlen,1000)!=MZ_OK)
    {
        _ret = 0XFF;
    }
    if(MZ_I2C_Master_Receive(MZ_I2C_INSTANCE,SI_SL_ADD,(uint8_t *) buf,dlen,1000)!=MZ_OK)
    {
        _ret= 0XFE;
    }
    return _ret;
}
 
void reset_resp_counter(){
    if(MZ_OK != I2C_Write_Reg(SENSOR_REG_COMMAND, RESET_CMD_CTR))
    {
        mz_puts("Initialization of SENSOR FAILED\r\n");
    }
    osDelay(10);
}
 
mz_error_t param_table_write(uint8_t addr, uint8_t data)
{
    uint8_t i=0,reg_val;
    mz_error_t _ret;
    uint8_t pre_resp;
 
    err_code=0;
    write_sucess=0;
    I2C_Read_Reg(SENSOR_REG_RESPONSE0,loc_buf);
    pre_resp=loc_buf[0];//20
    resp_buf[0]=pre_resp;
    pre_resp = pre_resp & 0x1F;
    do{
        I2C_Read_Reg(SENSOR_REG_RESPONSE0,loc_buf);
        reg_val=loc_buf[0];
    }while((reg_val & 0x20) != 0x20);
    //Do Write
    I2C_Write_Reg(SENSOR_REG_HOSTIN0, data);
    addr = addr | 0x80;
    I2C_Write_Reg(SENSOR_REG_COMMAND, addr);
    osDelay(10);
    do{
 
        I2C_Read_Reg(SENSOR_REG_RESPONSE0,loc_buf);
        reg_val=loc_buf[0];
        resp_buf[1]=reg_val;
        if((reg_val & 0x1F) != pre_resp){
            break;
        }else{
            //Response is NOT received
            i++;
            osDelay(10);
        }
    }while(i<5);
    //Check for error code
    if(reg_val & 0x10 != 0){
        //Error received
        _ret = MZ_FAIL;
        err_code = reg_val & 0xF;
    }else{
        //Successful
        //Read the resonse reg
        I2C_Read_Reg(SENSOR_REG_RESPONSE1,loc_buf);
        reg_val=loc_buf[0];
        resp_buf[2]=reg_val;
        if(reg_val == data){
            write_sucess=1;
            _ret = MZ_OK;
        }else{
            _ret = MZ_FAIL;
        }
    }
    return _ret;
}
 
mz_error_t SENSOR_Config()
{
    mz_error_t _ret = MZ_OK;
    osDelay(3000);
    mz_puts("UV Sensor configuration started\r\n");
    reset_resp_counter();
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_CH_LIST,0x0f))
    {
        mz_puts("SENSOR_PARAM_CH_LIST CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCCONFIG0,0x78))
    {
        mz_puts("SENSOR_PARAM_ADCCONFIG0 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCSENS0,0x71))
    {
        mz_puts("SENSOR_PARAM_ADCSENS0 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCPOST0,0x40))
    {
        mz_puts("SENSOR_PARAM_ADCPOST0 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCCONFIG1,0x4D))
    {
        mz_puts("SENSOR_PARAM_ADCCONFIG1 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCSENS1,0xE1))
    {
        mz_puts("SENSOR_PARAM_ADCSENS1 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCPOST1,0x40))
    {
        mz_puts("SENSOR_PARAM_ADCPOST1 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCCONFIG2,0x41))
    {
        mz_puts("SENSOR_PARAM_ADCCONFIG2 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCSENS2,0xe1))
    {
        mz_puts("SENSOR_PARAM_ADCSENS2 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCPOST2,0x50))
    {
        mz_puts("SENSOR_PARAM_ADCPOST2 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCCONFIG3,0x4d))
    {
        mz_puts("SENSOR_PARAM_ADCCONFIG3 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCSENS3,0x87))
    {
        mz_puts("SENSOR_PARAM_ADCSENS3 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
 
    if(MZ_OK != Sensor_cmd_data_conf(SENSOR_PARAM_ADCPOST3,0x40))
    {
        mz_puts("SENSOR_PARAM_ADCPOST3 CONFIG FAILED\r\n");
        return MZ_FAIL;
    }
    mz_puts("UV Sensor configuration done\r\n");
 
    return _ret;
}
mz_error_t Sensor_cmd_data_conf(uint8_t addr, uint8_t data)
{
    mz_error_t ret;
    for(int i=0;i<2;i++){
        ret=param_table_write(addr, data);
        if(MZ_OK == ret){
            break;
        }
    }
}
 
void SENSOR_Init()
{
    Sensor_ReadID(buf);
    if(buf[0]==0x33){
         SENSOR_Config();
    }else{
        mz_puts("WRONG CHIP ID FOR SENSOR. SKIPPING CONFIGURATION\r\n");
    }
 
}
 
mz_error_t Sensor_ReadID(uint8_t *buf)
{
    mz_error_t _ret = MZ_OK;
    uint16_t tlen;
    uint16_t dlen;
    tlen = 1;
    dlen = 2;
    uint8_t I2CLocBuf[4] = { 0x00, 0x00, 0x00, 0x00 };
    I2CLocBuf[0]= SI_ID_REG_PART_ID;
    if(MZ_OK!= MZ_I2C_Master_Transmit(MZ_I2C_INSTANCE,SI_SL_ADD,(uint8_t *) I2CLocBuf,tlen,1000))
    {
        _ret = 0XFF;
    }
    if(MZ_OK != MZ_I2C_Master_Receive(MZ_I2C_INSTANCE,SI_SL_ADD,(uint8_t *) buf,dlen,1000))
    {
        _ret = 0XFE;
    }
    return _ret;
}
 
SISER_RCVD SI_Read_UV()
{
    uint32_t  uv_index_val;
    float uvi;
    uint16_t len;
    uint8_t ch1_msb,ch1_lsb,ch1_middle_byte;
    //single-shot measurement
    mz_puts("UV Sensor single-shot measurement\r\n");
    I2C_Write_Reg(SENSOR_REG_COMMAND, FORCE_CMD);
 
    I2C_Read_Reg(SENSOR_REG_HOSTOUT0,i2cLocBuf);
    ch1_msb = i2cLocBuf[0];
    I2C_Read_Reg(SENSOR_REG_HOSTOUT1,i2cLocBuf);
    ch1_middle_byte = i2cLocBuf[0];
    I2C_Read_Reg(SENSOR_REG_HOSTOUT2,i2cLocBuf);
    ch1_lsb = i2cLocBuf[0];
    uv_val = ch1_msb << 16;
    uv_val = uv_val | ch1_middle_byte << 8;
    uv_val = uv_val | ch1_lsb;
 
    if(uv_val<0){
        return SISER_INVALID_RESP_RCVD;
    }
    else if(uv_val>=0){
//      mz_puts("UV Index:\r\n");
        mz_puts("UV Sensor cali\r\n");
        /* Convert the readings to UV index */
        uvi = (float) SENSOR_getUv(uv_val, uk );
        uvi = uvi / ( 1 << UV_OUTPUT_FRACTION );
        calib_uv_index(uvi);
        if(uvi<10 && uvi>=0){
            string_copy(locstr1,"0");
            string_append(locstr1,localBuf1);
 
        }else if(uvi<100 && uvi>10){
            string_copy(locstr1,localBuf1);
        }
        len=Get_String_len(locstr1);
        int8buf_to_asciibuf(SENSOR_payload.UV_Data,locstr1,len);
        mz_puts("UV Sensor data got\r\n");
        return SISER_VALID_RESP_RCVD;
    }
 
}
 
int32_t SENSOR_getUv( int32_t uv, SENSOR_Coeff_TypeDef *uk ){
 int32_t uvi;
 uvi = SENSOR_calcEvalPoly( 0, uv, UV_INPUT_FRACTION, UV_OUTPUT_FRACTION, UV_NUMCOEFF, uk );
 return uvi;
}
 
int32_t SENSOR_calcPolyInner( 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;
 
  }
 
int32_t SENSOR_calcEvalPoly( int32_t x, int32_t y, uint8_t input_fraction, uint8_t output_fraction, uint8_t num_coeff, SENSOR_Coeff_TypeDef *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 = SENSOR_calcPolyInner( x, input_fraction, mag, shift );
               if( x_order > 1 ) {
                  x2 = SENSOR_calcPolyInner( x, input_fraction, mag, shift );
               }
               else {
                  x2 = 1;
               }
           }
            else {
               x1 = 1;
               x2 = 1;
            }
 
            if( y_order > 0 ) {
              y1 = SENSOR_calcPolyInner( y, input_fraction, mag, shift );
               if( y_order > 1 ) {
                  y2 = SENSOR_calcPolyInner( 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;
 }
 
void calib_uv_index(float uv_raw_data){
 
    uint16_t i,j;
    gcvt(uv_raw_data,10,locstr1);
    i=0;
    j=0;
    while(locstr1[i] != '.' && locstr1[i] != '\0')
    {
        localBuf1[j] = locstr1[i];
        i++;
        j++;
    }
    localBuf1[j] = '\0';
}
uint16_t string_copy(uint8_t *dststr,uint8_t *srcstr){
 
    uint16_t i=0;
    while(srcstr[i]!='\0' && srcstr[i]!='\r'){
        dststr[i]=srcstr[i];
        i++;
    }
    dststr[i]='\0';
    return i;
}
uint8_t string_append(uint8_t *srcstr,uint8_t *apstr){
 
    uint16_t i=0;
    uint16_t j=0;
    while(srcstr[i]!='\0' && srcstr[i]!='\r'){
        i++;
    }
    while(apstr[j]!='\0' && apstr[j]!='\r'){
        srcstr[i]=apstr[j];
        i++;
        j++;
    }
    srcstr[i]='\0';
    return i;
}
 
uint16_t Get_String_len(uint8_t *buf)
{
    uint16_t i=0,len;
    while(buf[i]!='\r' && buf[i]!='\0'){
            i++;
    }
    len=i;
    return len;
}
void int8buf_to_asciibuf(uint8_t *destbuf,uint8_t *srcbuf,uint16_t len){
    uint16_t i=0;
    uint16_t j=0;
    uint8_t dat=0;
    uint8_t val=0;
     for(i=0;i<len;i++){
         dat = srcbuf[i];
         dat=dat>>4;
         val=dat & 0x0F; //dat%16;
         if(val<0xA){
             destbuf[j] = val + 48;
         }else{
             destbuf[j] = val + 55; //65-10;
        }
 
        j++;
        dat = srcbuf[i];
        val=dat & 0x0F; //dat%16;
         if(val<0xA){
             destbuf[j] = val + 48;
         }else{
             destbuf[j] = val + 55; //65-10;
        }
        j++;
     }
     destbuf[j]='\r';
     j++;
     destbuf[j]='\n';
}