//==============================================================================
//    S E N S I R I O N   AG,  Laubisruetistr. 50, CH-8712 Staefa, Switzerland
//==============================================================================
// Project   :  SHT2x Sample Code (V1.2)
// File      :  SHT2x.c
// Author    :  MST
// Controller:  NEC V850/SG3 (uPD70F3740)
// Compiler  :  IAR compiler for V850 (3.50A)
// Brief     :  Sensor layer. Functions for sensor access
//==============================================================================

//---------- Includes ----------------------------------------------------------
#include "SHT2x.h"

#include "iot_i2c_api.h"
#include "iot_io_api.h"


extern void delay_sometime(void);
extern int g_port;

//==============================================================================
u8t SHT2x_CheckCrc(u8t data[], u8t nbrOfBytes, u8t checksum)
//==============================================================================
{
  u8t crc = 0;
  u8t byteCtr;
  //calculates 8-Bit checksum with given polynomial
  for (byteCtr = 0; byteCtr < nbrOfBytes; ++byteCtr)
  { crc ^= (data[byteCtr]);
    for (u8t bit = 8; bit > 0; --bit)
    { if (crc & 0x80) crc = (crc << 1) ^ POLYNOMIAL;
      else crc = (crc << 1);
    }
  }
  if (crc != checksum) return CHECKSUM_ERROR;
  else return 0;
}


//===========================================================================
u8t SHT2x_ReadUserRegister(u8t *pRegisterValue)
//===========================================================================
{
    u8t checksum;   //variable for checksum byte
    u8t error=0;    //variable for error code

    int ret ;
    char send_buf[6];

    send_buf[0] = USER_REG_R;

    //Read from memory location 1
    ret = iot_i2c_write(g_port,SHT2X_ADDR,(char *)send_buf, 1);
    if ( ret ) {
        iot_printf("write failed ret = %d.\n", ret);
    }

    if (iot_i2c_read(g_port, SHT2X_ADDR, send_buf, 2)) {
        iot_printf("read failed.\n");
    } else {
        for (int i = 0; i < 4; i++) {
            iot_printf("read[%d]=%02x\r\n", i, send_buf[i] & 0xff);
        }
    }

    *pRegisterValue = send_buf[0];
    checksum = send_buf[1];
    error |= SHT2x_CheckCrc (pRegisterValue, 1, checksum);
    if (error) {
        iot_printf("read user crc err\r\n");
    }

    return error;
}

//===========================================================================
u8t SHT2x_WriteUserRegister(u8t *pRegisterValue)
//===========================================================================
{
  u8t error=0;   //variable for error code

  int ret ;
  char send_buf[6];

  send_buf[0] = USER_REG_W;

  ret = iot_i2c_write(g_port,SHT2X_ADDR,(char *)send_buf, 1);
  if ( ret ) {
      iot_printf("write failed ret = %d.\n", ret);
  }
  return error;
}
#if 0


//===========================================================================
u8t SHT2x_MeasureHM(etSHT2xMeasureType eSHT2xMeasureType, nt16 *pMeasurand)
//===========================================================================
{

  u8t  checksum;   //checksum
  u8t  data[2];    //data array for checksum verification
  u8t  error=0;    //error variable
  u16t i;          //counting variable

  //-- write I2C sensor address and command --
  I2c_StartCondition();
  error |= I2c_WriteByte (I2C_ADR_W); // I2C Adr
  switch(eSHT2xMeasureType)
  { case HUMIDITY: error |= I2c_WriteByte (TRIG_RH_MEASUREMENT_HM); break;
    case TEMP    : error |= I2c_WriteByte (TRIG_T_MEASUREMENT_HM);  break;
    default: break;
  }
  //-- wait until hold master is released --
  I2c_StartCondition();
  error |= I2c_WriteByte (I2C_ADR_R);
  SCL=HIGH;                     // set SCL I/O port as input
  for(i=0; i<1000; i++)         // wait until master hold is released or
  { DelayMicroSeconds(1000);    // a timeout (~1s) is reached
    if (SCL_CONF==1) break;
  }
  //-- check for timeout --
  if(SCL_CONF==0) error |= TIME_OUT_ERROR;

  //-- read two data bytes and one checksum byte --
  pMeasurand->s16.u8H = data[0] = I2c_ReadByte(ACK);
  pMeasurand->s16.u8L = data[1] = I2c_ReadByte(ACK);
  checksum=I2c_ReadByte(NO_ACK);

  //-- verify checksum --
  error |= SHT2x_CheckCrc (data,2,checksum);
  I2c_StopCondition();
  return error;

}
#endif

//===========================================================================
u8t SHT2x_MeasurePoll(etSHT2xMeasureType eSHT2xMeasureType, nt16 *pMeasurand)
//===========================================================================
{
  u8t  checksum;   //checksum
  u8t  error=0;    //error variable

  //-- write I2C sensor address and command --

    int ret ;
    char send_buf[6];

    switch(eSHT2xMeasureType)
    { case HUMIDITY: send_buf[0] = TRIG_RH_MEASUREMENT_POLL; break;
    case TEMP    : send_buf[0] = TRIG_T_MEASUREMENT_POLL; break;
    default: break;
    }

    ret = iot_i2c_write(g_port,SHT2X_ADDR,(char *)send_buf, 1);
    if ( ret ) {
      iot_printf("write failed ret = %d.\n", ret);
    }

    delay_sometime();
    delay_sometime();
    delay_sometime();

    //-- read two data bytes and one checksum byte --
    if (iot_i2c_read(g_port, SHT2X_ADDR, send_buf, 3)) {
        iot_printf("read failed.\n");
    } else {
        //for (int i = 0; i < 3; i++) {
            //iot_printf("read[%d]=%02x\r\n", i, send_buf[i] & 0xff);
        //}
    }


    pMeasurand->s16.u8H = send_buf[0];
    pMeasurand->s16.u8L = send_buf[1];
    checksum = (u8t)send_buf[2];

    //-- verify checksum --
    error |= SHT2x_CheckCrc ((u8t *)send_buf, 2, checksum);

    if (error) {
        iot_printf("MeasurePoll crc err\r\n");
    }

    return error;

}


//===========================================================================
u8t SHT2x_SoftReset()
//===========================================================================
{
    u8t  error=0;           //error variable
    int ret;

    char send_buf[1];
    send_buf[0] = SOFT_RESET;
    ret = iot_i2c_write(g_port,SHT2X_ADDR,(char *)send_buf, sizeof(send_buf));
    if ( ret ) {
        iot_printf("write failed ret = %d.\n", ret);
    }

    delay_sometime();
  return error;
}

//==============================================================================
float SHT2x_CalcRH(u16t u16sRH)
//==============================================================================
{
  ft humidityRH;              // variable for result

  u16sRH &= ~0x0003;          // clear bits [1..0] (status bits)
  //-- calculate relative humidity [%RH] --

  humidityRH = -6.0 + 125.0/65536 * (ft)u16sRH; // RH= -6 + 125 * SRH/2^16
  return humidityRH;
}

//==============================================================================
float SHT2x_CalcTemperatureC(u16t u16sT)
//==============================================================================
{
  ft temperatureC;            // variable for result

  u16sT &= ~0x0003;           // clear bits [1..0] (status bits)

  //-- calculate temperature [°C] --
  temperatureC= -46.85 + 175.72/65536 *(ft)u16sT; //T= -46.85 + 175.72 * ST/2^16
  return temperatureC;
}

//==============================================================================
u8t SHT2x_GetSerialNumber(u8t u8SerialNumber[])
//==============================================================================
{
    u8t  error=0;                          //error variable

    int ret ;
    char send_buf[6];

    send_buf[0] = 0xFA;
    send_buf[1] = 0x0F;

    //Read from memory location 1
    ret = iot_i2c_write(g_port,SHT2X_ADDR,(char *)send_buf, 2);
    if ( ret ) {
        iot_printf("write failed ret = %d.\n", ret);
    }


    if (iot_i2c_read(g_port, SHT2X_ADDR, send_buf, 4)) {
        iot_printf("read failed.\n");
    } else {
        for (int i = 0; i < 4; i++) {
            iot_printf("read[%d]=%02x\r\n", i, send_buf[i] & 0xff);
        }
    }

    //Read from memory location 2

    send_buf[0] = 0xFC;
    send_buf[1] = 0xC9;

    //Read from memory location 1
    ret = iot_i2c_write(g_port,SHT2X_ADDR,(char *)send_buf, 2);
    if ( ret ) {
        iot_printf("write failed ret = %d.\n", ret);
    }


    if (iot_i2c_read(g_port, SHT2X_ADDR, send_buf, 6)) {
        iot_printf("read failed.\n");
    } else {
        for (int i = 0; i < 6; i++) {
            iot_printf("read[%d]=%02x\r\n", i, send_buf[i] & 0xff);
        }
    }

  return error;
}


void SHT2x_test_loop(void)
{
    u8t  error = 0;              //variable for error code. For codes see system.h
    u8t  userRegister;           //variable for user register
    u8t serial_num[6] ;
    nt16 sT;
    nt16 sRH;
    ft   temperatureC;
    ft   humidityRH;

    SHT2x_SoftReset();
    SHT2x_GetSerialNumber(serial_num);


    // --- Set Resolution e.g. RH 10bit, Temp 13bit ---
    error |= SHT2x_ReadUserRegister(&userRegister);  //get actual user reg
    userRegister = (userRegister & ~SHT2x_RES_MASK) | SHT2x_RES_10_13BIT;
    error |= SHT2x_WriteUserRegister(&userRegister); //write changed user reg

    while(1)
    {
        SHT2x_MeasurePoll(TEMP, &sT);
        //-- calculate humidity and temperature --
        temperatureC = SHT2x_CalcTemperatureC(sT.u16);
        delay_sometime();
        SHT2x_MeasurePoll(HUMIDITY, &sRH);
        humidityRH   = SHT2x_CalcRH(sRH.u16);

        iot_printf("temp=%f, humidityRH=%f\r\n", temperatureC, humidityRH);

        delay_sometime();
        delay_sometime();
        delay_sometime();
    }
}