path: root/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c

/*
 * TemperatureSensor.c
 *
 *  Created on: 15 ���� 2018
 *      Author: shlomo
 */

#include "include.h"
#include "heater.h"
#include "TemperatureSensor.h"
#include "PMR/Hardware/HardwarePidControlType.pb-c.h"
#include "Drivers/Heater/ADS1220.h"
#include "Drivers/Heater/TemperatureSensor.h"
#include "drivers/FPGA/FPGA_SPI_Comm.h"
#include "modules/control/millisecTask.h"
#include "PT100RTD.h"

uint32_t TemperatureSensorReadFromFPGA_Res(TEMPERATURE_SENSOR_ID_ENUM SensorId,uint32_t Data);

typedef enum
{
    SENSOR_CONFIG_REG0,
    SENSOR_CONFIG_REG1,
    SENSOR_CONFIG_REG2,
    SENSOR_CONFIG_REG3,
    SENSOR_CONFIG_RESTART_CONVERSIONS,
    SENSOR_CONFIG_END

}SENSOR_CONFIG_STAGES_ENUM;

SENSOR_CONFIG_STAGES_ENUM SensConfigStages[MAX_TEMPERATURE_SENSOR_ID] = {SENSOR_CONFIG_REG0};

uint8_t FPGA_SensorInitConfigReg()
{
     #define Rref 1650  //ohm
     //#define Rref 825 //ohm

    uint8_t i;

    for(i=0;i<MAX_TEMPERATURE_SENSOR_ID;i++) // for noe we are using the same configuration to all of them
    {
        TempSensConfig[i].Reg0.bits.PGA_BYPASS     = 0x00 ;//Bit 0   PGA enabled (default)

        if(Rref==1650)
            TempSensConfig[i].Reg0.bits.GAIN       = 0x04;//Bits 1-3  Gain = 16
        else if(Rref == 825)
            TempSensConfig[i].Reg0.bits.GAIN       = 0x03;//Bits 1-3  Gain = 8

        TempSensConfig[i].Reg0.bits.MUX            = 0x06;//Bits 5-7  AINP = AIN1, AINN = AIN0

        TempSensConfig[i].Reg1.bits.BCS            = 0x00;//Bit 0     Current sources off (default)
        TempSensConfig[i].Reg1.bits.TS             = 0x00;//Bit 1     Disables temperature sensor (default)
        TempSensConfig[i].Reg1.bits.CM             = 0x01;//Bit 2     Continuous conversion mode
        TempSensConfig[i].Reg1.bits.MODE           = 0x00;//Bits 3-4  Normal mode (256-kHz modulator clock, default)
        //TempSensConfig[i].Reg1.bits.DR             = 0x06;//Bits 5-7  Data rate 1000 SPS (Sample every 1 mSec)
        TempSensConfig[i].Reg1.bits.DR             = 0x00;//Bits 5-7  Data rate 20 SPS (Sample every 50 mSec)

        if(Rref==1650)
            TempSensConfig[i].Reg2.bits.IDAC       = 0x03;//Bits 0-2  IDAC current setting 100 uA
        else if(Rref == 825)
            TempSensConfig[i].Reg2.bits.IDAC       = 0x06;//Bits 0-2  IDAC current setting 1000 uA

        TempSensConfig[i].Reg2.bits.PSW            = 0x00;//Bit  3    Switch is always open (default)
        TempSensConfig[i].Reg2.bits.HZ50_60        = 0x01;//Bits 4-5  No 50-Hz or 60-Hz rejection (default)
        TempSensConfig[i].Reg2.bits.VREF           = 0x01;//Bits 6-7  Internal 2.048-V reference selected (default)

        TempSensConfig[i].Reg3.bits.Always_write_0 = 0x00;//Bit  0;
        TempSensConfig[i].Reg3.bits.DRDYM          = 0x00;//Bit  1    Only the dedicated DRDY pin is used to indicate when data are ready (default)
        TempSensConfig[i].Reg3.bits.I2MUX          = 0x04;//Bits 2-4  IDAC2 connected to AIN3/REFN1
        TempSensConfig[i].Reg3.bits.I1MUX          = 0x03;//Bits 5-7  IDAC1 connected to AIN2

    }

    return OK;
}

uint32_t TemperatureSensorsInit(void)
{
    #ifndef EVALUATION_BOARD
    TEMPERATURE_SENSOR_ID_ENUM i;

        for(i=0;i<MAX_TEMPERATURE_SENSOR_ID; i++)
        {
            //Reset the device
            SPISendFPGARequest(i,ADS1220_CMD_RESET, 1);
            //Wait at least (50 us + 32 � t(CLK)) after the RESET command is sent before sending any other command.
        }
    #endif

   FPGA_SensorInitConfigReg();

    return OK;
}

uint32_t FPGA_SensorConfig_callback(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint32_t ReadValue)
{
    #ifndef EVALUATION_BOARD

    uint32_t temp = 0;
    if (SensorId > MAX_TEMPERATURE_SENSOR_ID)
        return ERROR;

    switch(SensConfigStages[SensorId])
    {
        case SENSOR_CONFIG_REG0:
                SensConfigStages[SensorId]++;
                temp = ADS1220_CMD_WREG | ((ADS1220_0_REGISTER<<2) & 0x0c);
                temp = temp << 8;
                temp |= TempSensConfig[SensorId].Reg0.Byte;

                MillisecWriteToTempSensor(SensorId, temp, 2, NULL);
            break;

         case SENSOR_CONFIG_REG1:
                 SensConfigStages[SensorId]++;
                 temp = ADS1220_CMD_WREG | ((ADS1220_1_REGISTER<<2) & 0x0c);
                 temp = temp << 8;
                 temp |= TempSensConfig[SensorId].Reg1.Byte;

                 MillisecWriteToTempSensor(SensorId, temp, 2, NULL);
            break;

         case SENSOR_CONFIG_REG2:
                 SensConfigStages[SensorId]++;
                 temp = ADS1220_CMD_WREG | ((ADS1220_2_REGISTER<<2) & 0x0c);
                 temp = temp << 8;
                 temp |= TempSensConfig[SensorId].Reg2.Byte;

                 MillisecWriteToTempSensor(SensorId, temp, 2, NULL);
            break;

         case SENSOR_CONFIG_REG3:
                 SensConfigStages[SensorId]++;
                 temp = ADS1220_CMD_WREG | ((ADS1220_3_REGISTER<<2) & 0x0c);
                 temp = temp << 8;
                 temp |= TempSensConfig[SensorId].Reg3.Byte;

                 MillisecWriteToTempSensor(SensorId, temp, 2, NULL);
            break;

         case SENSOR_CONFIG_RESTART_CONVERSIONS:
                 SensConfigStages[SensorId]++;
                 //Start or restart conversions
                 //The START/SYNC command is used to start a single conversion, or (when sent during an
                 //ongoing conversion) to reset the digital filter, and then restarts a single new conversion
                 MillisecWriteToTempSensor(SensorId, ADS1220_CMD_SYNC, 1, NULL);
            break;
         case SENSOR_CONFIG_END:
             break;
         default:
             return ERROR;
    }

    #endif

    return OK;
}

uint32_t TemperatureSensorRead(TEMPERATURE_SENSOR_ID_ENUM SensorId)
{
#ifdef DEBUG_TEST_FUNCTIONS
    //stubs mock temperature read
    static float temperature[MAX_TEMPERATURE_SENSOR_ID] = {0};
    if (GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w) == true) temperature[SensorId] += 0.5;
    else if (GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1) == true) temperature[SensorId] += 0.2;
    else temperature[SensorId] -= 0.3;
    return  (int)temperature[SensorId];
#else
    return TempSensorResponse[SensorId].Temparature;
#endif
}




uint32_t Filter_Temparature_Measurement(TEMPERATURE_SENSOR_ID_ENUM SensorId, int32_t Current_Measurement_C, uint32_t NoOfAvrSamples)
{
    #define MaxAvrSamples 100 //MAX of average samples

    uint32_t Filtered_Measurement;

    static int32_t Sample_buf[MAX_TEMPERATURE_SENSOR_ID][MaxAvrSamples] = {0};

    static uint8_t SampleIndex[MAX_TEMPERATURE_SENSOR_ID] = {0};

    uint8_t i;
    uint32_t Status = OK;

    #ifdef TEMPERATURE_MEASUREMENT_HiGH_LIMIT
        if (Current_Measurement_C > MAX_TEMPERATURE_MEASUREMENT)
        {
            Current_Measurement_C  = MAX_TEMPERATURE_MEASUREMENT;
            Status =  ERROR;
        }
    #endif

    #ifdef TEMPERATURE_MEASUREMENT_LOW_LIMIT
        if (Current_Measurement_C < MIN_TEMPERATURE_MEASUREMENT)
        {

            Current_Measurement_C  = MAX_TEMPERATURE_MEASUREMENT;
            Status =  ERROR;
        }
    #endif

    Sample_buf[SensorId][SampleIndex[SensorId]] = Current_Measurement_C;

    SampleIndex[SensorId] = SampleIndex[SensorId]++;

    if(SampleIndex[SensorId] > (NoOfAvrSamples - 1))
        SampleIndex[SensorId] = 0;

    int32_t TempSum = 0;

    for(i=0; i<NoOfAvrSamples; i++)
    {
        TempSum += Sample_buf[SensorId][i];
    }

    Filtered_Measurement = TempSum / NoOfAvrSamples;

    TempSensorResponse[SensorId].Temparature_C = Filtered_Measurement;

    return Status;
}

uint32_t TemperatureSensorReadFromFPGA(TEMPERATURE_SENSOR_ID_ENUM SensorId)
{
    uint32_t Status = OK;

    // send the command byte
    //SPISendFPGARequest( SensorId,ADS1220_CMD_RDATA, 3);

    MillisecReadFromTempSensor(SensorId, ADS1220_CMD_RDATA, 3, TemperatureSensorReadFromFPGA_Res);

    return Status;
}

uint32_t Calc_Resistance(TEMPERATURE_SENSOR_ID_ENUM SensorId, unsigned int Current_Measurement)
{

    uint32_t Resistance_100;

    unsigned int Factor_2Rref_E_H;
    unsigned int Factor_2Rref_E_L;

    //Resistance = Measurement / (2^23) *2 * Rref / Gain

    Factor_2Rref_E_H = 200 * Rref; // 200 to calculate Resistance*100

    Factor_2Rref_E_L = 8388608 * (2<<(TempSensConfig[SensorId].Reg0.bits.GAIN -1));//2^23*Gain

    Resistance_100 = (float)Current_Measurement  / (float)Factor_2Rref_E_L * (float)Factor_2Rref_E_H;

    return Resistance_100;
}

int32_t RTD (uint32_t Resistance_100) //Resistance * 100
// find the temperature using  Lookup table
{
    int16_t i = 0;
    int32_t Temperature_c;

    const int PT100_TABLE_MAXIDX = ((sizeof(Pt100_table) / sizeof(Pt100_table[0])) - 1) ;

    while( (Resistance_100 < Pt100_table[i]) && (i < PT100_TABLE_MAXIDX) )
    {
        i++;
    }

    Temperature_c = i-200;

    return Temperature_c;
}




uint32_t TemperatureSensorReadFromFPGA_Res(TEMPERATURE_SENSOR_ID_ENUM SensorId,uint32_t Data)
{
    uint32_t Status = OK;

    int32_t Current_Measurement_C = 0;

    uint32_t Resistance_100;

    //uint32_t Data;

    //SPIGetFPGAResponse(SensorId, &Data);

    // sign extend data //TODO ?
    if (Data & 0x800000)
        Data |= 0xff000000;

    Resistance_100 = Calc_Resistance(SensorId, Data);

    Current_Measurement_C = RTD (Resistance_100);

    #ifdef WithTempSensorFiltrer
        uint32_t NoOfAvrSamples = 5;//TODO - how many Samples
        Status = Filter_Temparature_Measurement(SensorId, Current_Measurement_C, NoOfAvrSamples);
    #else
        TempSensorResponse[SensorId].Temparature_C = Current_Measurement_C;
    #endif

    return Status;
}