/********************************************************************************
* @file hal_sensor_stack.c
* @author Naresh Patel
* @date 03-May-2024
* @brief
*******************************************************************************/
/********************************************************************************
* INCLUDES
********************************************************************************/
//#include "ADS124S08.h"
#include "hal_sensor_stack.h"
#include "hal_display_stack.h"
#include "project_data_types.h"
//#include "math.h"
#include <math.h>
#include "sl_common.h"
#include "ustimer.h"
#include "spidrv.h"
#include "sl_spidrv_instances.h"
static void TransferComplete(SPIDRV_Handle_t handle,Ecode_t transferStatus,int itemsTransferred);
static double HAL_SensorStack_Calculate_RTD_Temperature(int32_t adcValue);
static void restoreRegisterDefaults(void);
extern SPIDRV_Init_t sl_spidrv_init_SPI_Display_TemperatureSensor;
/* Internal register map array (to recall current configuration) */
static uint8_t registerMap[NUM_REGISTERS];
//ADS124S08::ADS124S08()
//{
// pinMode(ADS124S08_DRDY_PIN, INPUT); //data ready input line
// pinMode(ADS124S08_START_PIN, OUTPUT); // start
// pinMode(ADS124S08_PWDN_PIN, OUTPUT); // Power down output
//}
/******************************************************************************************************************
* Function Name: void HAL_SensorStack_Init(void)
* Author: Naresh
* Date: 23-June-2024
* Function Parameter: void
* Return value : void
* Description: -- Initialize temperature stack
******************************************************************************************************************/
void HAL_SensorStack_Init(void)
{
// initalize the data ready and chip select pins:
// pinMode(ADS124S08_DRDY_PIN, INPUT); //data ready input line
// pinMode(ADS124S08_CS_PIN, OUTPUT); //chip enable output line
// pinMode(ADS124S08_START_PIN, OUTPUT); // start
// pinMode(ADS124S08_PWDN_PIN, OUTPUT); // Power down output
GPIO_PinModeSet(SENSOR_DRDY_PORT, SENSOR_DRDY_PIN, gpioModeInput, 1);
GPIO_PinModeSet(SENSOR_CS_PORT,SENSOR_CS_PIN,gpioModePushPull,1);
GPIO_PinModeSet(DISPLAY_CS_PORT,DISPLAY_CS_PIN,gpioModePushPull,1);
GPIO_PinModeSet(SENSOR_RESET_PORT,SENSOR_RESET_PIN,gpioModePushPull,1);
GPIO_PinModeSet(SENSOR_START_SYNCH_PORT,SENSOR_START_SYNCH_PIN,gpioModePushPull,0);
//digitalWrite(ADS124S08_CS_PIN, HIGH);
HAL_SensorStack_Sensor_ChipSelect_Set();
// SerialDEBUG.begin(9600);
// delay(1000);
// // start the SPI library:
// SPI.begin();
// SPI.setBitOrder(MSBFIRST);
// //CPOL = 0, CPHA = 1
// SPI.setDataMode(SPI_MODE1);
// // Selecting 1Mhz clock for SPI
// SPI.setClockDivider(SPI_CLOCK_DIV8); // DIV16
HAL_SensorStack_ReInitialize();
sl_spidrv_SPI_Display_TemperatureSensor_handle->userCallback = TransferComplete;
//initalize ADS1292 slave
// PC_ADS124S08.ADS124S08_Init(); // initialise ADS124S08
ADS124S08_Init();
// SerialDEBUG.println("ADS124S08 Initialised successfully....");
}
// return mV value
uint32_t ADS124S08_Read_Data(void)
{
// double value = -1;
uint8_t DataTx[3] = {0x00,0x00,0x00};
uint8_t DataRx[3] = {0xFF,0xFF,0xFF};
uint32_t iData = 0;
// if(digitalRead(ADS124S08_DRDY_PIN) == LOW) // monitor Data ready(DRDY pin)
if(GPIO_PinOutGet(SENSOR_DRDY_PORT, SENSOR_DRDY_PIN) == LOW) // monitor Data ready(DRDY pin)
{
// while(digitalRead(ADS124S08_DRDY_PIN) == LOW);
while(GPIO_PinOutGet(SENSOR_DRDY_PORT, SENSOR_DRDY_PIN) == LOW);
// digitalWrite(ADS124S08_CS_PIN, LOW);
HAL_SensorStack_Sensor_ChipSelect_Clear();
// delay(5);
USTIMER_Delay(5 * MS_MULTIPLIER);
// iData = SPI.transfer(CONFIG_SPI_MASTER_DUMMY);
// iData = (iData<<8) + SPI.transfer(CONFIG_SPI_MASTER_DUMMY);
// iData = (iData<<8) + SPI.transfer(CONFIG_SPI_MASTER_DUMMY);
HAL_SensorStack_SendReceive_SPI_Data(&DataTx, &DataRx, 3);
iData = (DataRx[0] << 16) + (DataRx[1] << 8) + (DataRx[2]);
// delay(5);
USTIMER_Delay(5 * MS_MULTIPLIER);
// digitalWrite(ADS124S08_CS_PIN, HIGH);
HAL_SensorStack_Sensor_ChipSelect_Set();
// value = (RES) * (float)iData * 1000;
// return value;
return iData;
}
else
{
return iData;
}
}
uint32_t ADS124S08_Read(void)
{
uint32_t iData = 0;
// uint8_t rxBuffer[3] = {0};
uint8_t DataTx[4] = {0x00,0x00,0x00,0x00};
uint8_t DataRx[4] = {0xFF,0xFF,0xFF,0xFF};
uint8_t dummy_read;
// digitalWrite(ADS124S08_CS_PIN,LOW);
HAL_SensorStack_Sensor_ChipSelect_Clear();
// delay(5);
USTIMER_Delay(5 * MS_MULTIPLIER);
// SPI.transfer(ADS_RDATA);
// rxBuffer[0] = SPI.transfer(0x00);
// rxBuffer[1] = SPI.transfer(0x00);
// rxBuffer[2] = SPI.transfer(0x00);
DataTx[0] = ADS_RDATA;
HAL_SensorStack_SendReceive_SPI_Data(&DataTx, &DataRx, 4);
// delay(5);
USTIMER_Delay(5 * MS_MULTIPLIER);
// digitalWrite(ADS124S08_CS_PIN,HIGH);
HAL_SensorStack_Sensor_ChipSelect_Set();
// Serial.println(rxBuffer[0]);
// Serial.println(rxBuffer[1]);
// Serial.println(rxBuffer[2]);
// iData = (rxBuffer[0] << 16) + (rxBuffer[1] << 8) + rxBuffer[2];
iData = (DataRx[2] << 16) + (DataRx[3] << 8) + (DataRx[4]);
return iData;
}
uint8_t readRegister(uint8_t address)
{
uint8_t data;
uint8_t data1;
uint8_t DataTx[3] = {0x00,0x00,0x00};
uint8_t DataRx[3] = {0xFF,0xFF,0xFF};
// digitalWrite(ADS124S08_CS_PIN,LOW);
HAL_SensorStack_Sensor_ChipSelect_Clear();
// delay(5);
USTIMER_Delay(5 * MS_MULTIPLIER);
// SPI.transfer(ADS_RREG|(address & 0x1f));
// SPI.transfer(0x00);
// data = SPI.transfer(CONFIG_SPI_MASTER_DUMMY);
DataTx[0] = (ADS_RREG|(address & 0x1F));
DataTx[1] = 0x00;
DataTx[2] = 0x00;
HAL_SensorStack_SendReceive_SPI_Data(&DataTx, &DataRx, 3);
// delay(5);
USTIMER_Delay(5 * MS_MULTIPLIER);
// digitalWrite(ADS124S08_CS_PIN,HIGH);
HAL_SensorStack_Sensor_ChipSelect_Set();
data = DataRx[2];
return data;
}
void ADS124S08_Init(void)
{
uint8_t initRegisterMap[NUM_REGISTERS] = { 0 };
uint8_t status = FALSE;
// Log.info("ADS Init");
// delay(10);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Reset();
// delay(20);
USTIMER_Delay(20 * MS_MULTIPLIER);
ADS124S08_Reset_Data_Conv_Command();
status = readRegister(REG_ADDR_STATUS);
if ( (status & ADS_nRDY_MASK) ) {
return(FALSE); // Device not ready
}
restoreRegisterDefaults();
// Configure initial device register settings here
initRegisterMap[REG_ADDR_STATUS] = 0x00; // Reset POR event
initRegisterMap[REG_ADDR_INPMUX] = RTD_FOUR_WIRE_INPUT_MUX;
initRegisterMap[REG_ADDR_PGA] = RTD_FOUR_WIRE_PGA;
initRegisterMap[REG_ADDR_DATARATE]= RTD_FOUR_WIRE_DATARATE;
initRegisterMap[REG_ADDR_REF] = RTD_FOUR_WIRE_REF_SEL;
initRegisterMap[REG_ADDR_IDACMAG] = RTD_FOUR_WIRE_IDACMAG;
initRegisterMap[REG_ADDR_IDACMUX] = RTD_FOUR_WIRE_IDACMUX;
initRegisterMap[REG_ADDR_VBIAS] = RTD_VBIAS;
// initRegisterMap[REG_ADDR_SYS] = SYS_DEFAULT;
initRegisterMap[REG_ADDR_SYS] = (SYS_DEFAULT | ADS_CALSAMPLE_16 ) ; // sample 16 times for calibration (calibration works when global chopping is off)
// delay(1000);
USTIMER_Delay(1000 * MS_MULTIPLIER);
ADS124S08_Reg_Write(REG_ADDR_ID, 0x00);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Reg_Write(REG_ADDR_STATUS, 0x00);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Reg_Write(REG_ADDR_INPMUX, RTD_FOUR_WIRE_INPUT_MUX);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Reg_Write(REG_ADDR_PGA, RTD_FOUR_WIRE_PGA);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Reg_Write(REG_ADDR_DATARATE, RTD_FOUR_WIRE_DATARATE);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Reg_Write(REG_ADDR_REF, RTD_FOUR_WIRE_REF_SEL);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Reg_Write(REG_ADDR_IDACMAG, RTD_FOUR_WIRE_IDACMAG);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Reg_Write(REG_ADDR_IDACMUX, RTD_FOUR_WIRE_IDACMUX);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Reg_Write(REG_ADDR_VBIAS, RTD_VBIAS);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Reg_Write(REG_ADDR_SYS, (SYS_DEFAULT| ADS_CALSAMPLE_16 ));
USTIMER_Delay(10 * MS_MULTIPLIER);
// Read back all registers, except for status register.
registerMap[REG_ADDR_STATUS] = readRegister(REG_ADDR_STATUS);
USTIMER_Delay(10 * MS_MULTIPLIER);
registerMap[REG_ADDR_INPMUX] = readRegister(REG_ADDR_INPMUX);
USTIMER_Delay(10 * MS_MULTIPLIER);
registerMap[REG_ADDR_PGA] = readRegister(REG_ADDR_PGA);
USTIMER_Delay(10 * MS_MULTIPLIER);
registerMap[REG_ADDR_DATARATE] = readRegister(REG_ADDR_DATARATE);
USTIMER_Delay(10 * MS_MULTIPLIER);
registerMap[REG_ADDR_REF] = readRegister(REG_ADDR_REF);
USTIMER_Delay(10 * MS_MULTIPLIER);
registerMap[REG_ADDR_IDACMAG] = readRegister(REG_ADDR_IDACMAG);
USTIMER_Delay(10 * MS_MULTIPLIER);
registerMap[REG_ADDR_IDACMUX] = readRegister(REG_ADDR_IDACMUX);
USTIMER_Delay(10 * MS_MULTIPLIER);
registerMap[REG_ADDR_VBIAS] = readRegister(REG_ADDR_VBIAS);
USTIMER_Delay(10 * MS_MULTIPLIER);
registerMap[REG_ADDR_SYS] = readRegister(REG_ADDR_SYS);
USTIMER_Delay(10 * MS_MULTIPLIER);
registerMap[REG_ADDR_FSCAL2] = readRegister(REG_ADDR_FSCAL2);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Enable_Start();
// delay(10);
USTIMER_Delay(10 * MS_MULTIPLIER);
ADS124S08_Disable_Start();
// delay(50);
USTIMER_Delay(50 * MS_MULTIPLIER);
ADS124S08_Start_Data_Conv_Command();
// delay(50);
USTIMER_Delay(50 * MS_MULTIPLIER);
}
void setChannel(uint8_t channel)
{
channel = (channel << 4) + 0x0C;
ADS124S08_Reg_Write(ADS_INPMUX, channel); //Ch 1 enabled, gain 6, connected to electrode in
// delay(10);
USTIMER_Delay(50 * MS_MULTIPLIER);
}
void ADS124S08_Reset(void)
{
// digitalWrite(ADS124S08_PWDN_PIN, HIGH);
HAL_SensorStack_Sensor_ResetPin_Set();
// delay(100); // Wait 100 mSec
USTIMER_Delay(100 * MS_MULTIPLIER);
// digitalWrite(ADS124S08_PWDN_PIN, LOW);
HAL_SensorStack_Sensor_ResetPin_Clear();
// delay(100);
USTIMER_Delay(100 * MS_MULTIPLIER);
// digitalWrite(ADS124S08_PWDN_PIN, HIGH);
HAL_SensorStack_Sensor_ResetPin_Set();
// delay(100);
USTIMER_Delay(100 * MS_MULTIPLIER);
}
void ADS124S08_Disable_Start(void)
{
// digitalWrite(ADS124S08_START_PIN, LOW);
HAL_SensorStack_Sensor_StartSynch_Clear();
// delay(20);
USTIMER_Delay(20 * MS_MULTIPLIER);
}
void ADS124S08_Enable_Start(void)
{
// digitalWrite(ADS124S08_START_PIN, HIGH);
HAL_SensorStack_Sensor_StartSynch_Set();
// delay(20);
USTIMER_Delay(20 * MS_MULTIPLIER);
}
//void ADS124S08_Hard_Stop (void)
//{
// digitalWrite(ADS124S08_START_PIN, LOW);
// delay(100);
//}
void ADS124S08_Reset_Data_Conv_Command (void)
{
ADS124S08_SPI_Command_Data(ADS_RESET); // Send 0x08 to the ADS1x9x
}
void ADS124S08_Start_Data_Conv_Command (void)
{
ADS124S08_SPI_Command_Data(ADS_START); // Send 0x08 to the ADS1x9x
}
void ADS124S08_Wakeup_Data_Conv_Command (void)
{
ADS124S08_SPI_Command_Data(ADS_WAKEUP); // Send 0x08 to the ADS1x9x
}
//void ADS124S08_Soft_Stop (void)
//{
// ADS124S08_SPI_Command_Data(ADS_STOP); // Send 0x0A to the ADS1x9x
//}
void ADS124S08_Start_Read_Data_Continuous (void)
{
}
void ADS124S08_Stop_Read_Data_Continuous (void)
{
}
void ADS124S08_SPI_Command_Data(unsigned char data_in)
{
uint8_t DataRx = 0xFF;
// digitalWrite(ADS124S08_CS_PIN, LOW);
HAL_SensorStack_Sensor_ChipSelect_Clear();
// delay(2);
USTIMER_Delay(2 * MS_MULTIPLIER);
// SPI.transfer(data_in);
HAL_SensorStack_SendReceive_SPI_Data(&data_in, &DataRx, 1);
// delay(2);
USTIMER_Delay(2 * MS_MULTIPLIER);
// digitalWrite(ADS124S08_CS_PIN, HIGH);
HAL_SensorStack_Sensor_ChipSelect_Set();
}
//Sends a write command to SCP1000
void ADS124S08_Reg_Write (unsigned char READ_WRITE_ADDRESS, unsigned char DATA)
{
uint8_t DataTx[3] = {0xFF,0xFF,0xFF};
uint8_t DataRx[3] = {0xFF,0xFF,0xFF};
// now combine the register address and the command into one byte:
// byte dataToSend = READ_WRITE_ADDRESS + ADS_WREG;
uint8_t dataToSend = READ_WRITE_ADDRESS + ADS_WREG;
// take the chip select low to select the device:
// digitalWrite(ADS124S08_CS_PIN, LOW);
HAL_SensorStack_Sensor_ChipSelect_Clear();
// delay(2);
USTIMER_Delay(2 * MS_MULTIPLIER);
// SPI.transfer(dataToSend); //Send register location
// SPI.transfer(0x00); //number of register to wr
// SPI.transfer(DATA); //Send value to record into register
DataTx[0] = dataToSend;
DataTx[1] = 0x00;
DataTx[2] = DATA;
HAL_SensorStack_SendReceive_SPI_Data(&DataTx, &DataRx, 3);
// delay(2);
USTIMER_Delay(2 * MS_MULTIPLIER);
// take the chip select high to de-select:
// digitalWrite(ADS124S08_CS_PIN, HIGH);
HAL_SensorStack_Sensor_ChipSelect_Set();
}
/******************************************************************************************************************
* Function Name: void HAL_SensorStack_Sensor_ChipSelect_Set(void)
* Author: Naresh
* Date: 23-June-2024
* Function Parameter: void
* Return value : void
* Description: -- Set GPIO for sensor chip select
******************************************************************************************************************/
void HAL_SensorStack_Sensor_ChipSelect_Set(void)
{
GPIO_PinOutSet(SENSOR_CS_PORT,SENSOR_CS_PIN);
}
/******************************************************************************************************************
* Function Name: void HAL_SensorStack_Sensor_ChipSelect_Clear(void)
* Author: Naresh
* Date: 23-June-2024
* Function Parameter: void
* Return value : void
* Description: -- Clear GPIO for sensor chip select
******************************************************************************************************************/
void HAL_SensorStack_Sensor_ChipSelect_Clear(void)
{
GPIO_PinOutClear(SENSOR_CS_PORT,SENSOR_CS_PIN);
}
/******************************************************************************************************************
* Function Name: void HAL_SensorStack_Display_ChipSelect_Set(void)
* Author: Naresh
* Date: 23-June-2024
* Function Parameter: void
* Return value : void
* Description: -- Set GPIO for display chip select
******************************************************************************************************************/
void HAL_SensorStack_Display_ChipSelect_Set(void)
{
GPIO_PinOutSet(DISPLAY_CS_PORT,DISPLAY_CS_PIN);
}
/******************************************************************************************************************
* Function Name: void HAL_SensorStack_Display_ChipSelect_Clear(void)
* Author: Naresh
* Date: 23-June-2024
* Function Parameter: void
* Return value : void
* Description: -- Clear GPIO for display chip select
******************************************************************************************************************/
void HAL_SensorStack_Display_ChipSelect_Clear(void)
{
GPIO_PinOutClear(DISPLAY_CS_PORT,DISPLAY_CS_PIN);
}
/******************************************************************************************************************
* Function Name: void HAL_SensorStack_Sensor_ResetPin_Set(void)
* Author: Naresh
* Date: 23-June-2024
* Function Parameter: void
* Return value : void
* Description: -- Set GPIO for Reset pin
******************************************************************************************************************/
void HAL_SensorStack_Sensor_ResetPin_Set(void)
{
GPIO_PinOutSet(SENSOR_RESET_PORT,SENSOR_RESET_PIN);
}
/******************************************************************************************************************
* Function Name: void HAL_SensorStack_Sensor_ResetPin_Clear(void)
* Author: Naresh
* Date: 23-June-2024
* Function Parameter: void
* Return value : void
* Description: -- Clear GPIO for Reset pin
******************************************************************************************************************/
void HAL_SensorStack_Sensor_ResetPin_Clear(void)
{
GPIO_PinOutClear(SENSOR_RESET_PORT,SENSOR_RESET_PIN);
}
/******************************************************************************************************************
* Function Name: void HAL_SensorStack_Sensor_StartSynch_Set(void)
* Author: Naresh
* Date: 23-June-2024
* Function Parameter: void
* Return value : void
* Description: -- Set Start/Synch GPIO
******************************************************************************************************************/
void HAL_SensorStack_Sensor_StartSynch_Set(void)
{
GPIO_PinOutSet(SENSOR_START_SYNCH_PORT,SENSOR_START_SYNCH_PIN);
}
/******************************************************************************************************************
* Function Name: void HAL_SensorStack_Sensor_StartSynch_Clear(void)
* Author: Naresh
* Date: 23-June-2024
* Function Parameter: void
* Return value : void
* Description: -- Clear Start/Synch GPIO
******************************************************************************************************************/
void HAL_SensorStack_Sensor_StartSynch_Clear(void)
{
GPIO_PinOutClear(SENSOR_START_SYNCH_PORT,SENSOR_START_SYNCH_PIN);
}
///******************************************************************************************************************
// * Function Name: void HAL_SensorStack_Sensor_Set_StartSynchPin(void)
// * Author: Naresh
// * Date: 23-June-2024
// * Function Parameter: state level of START pin (false = low, true = high)
// * Return value : void
// * Description: -- Sets the state of the MCU START GPIO pin
// ******************************************************************************************************************/
//void HAL_SensorStack_Sensor_Set_StartSynchPin( uint8_t state )
//{
// if(state){
// HAL_SensorStack_Sensor_StartSynch_Set();
// } else {
// HAL_SensorStack_Sensor_StartSynch_Clear();
// }
//
// USTIMER_Delay(2);
//}
///******************************************************************************************************************
// * Function Name: void HAL_SensorStack_Sensor_Send_Start_Command(void)
// * Author: Naresh
// * Date: 23-June-2024
// * Function Parameter: void
// * Return value : void
// * Description: -- Sends START Command through SPI
// ******************************************************************************************************************/
//void HAL_SensorStack_Sensor_Send_Start_Command(void)
//{
// uint16_t dataTx = OPCODE_START;
//
// SPIDRV_MTransmit(sl_spidrv_SPI_Display_TemperatureSensor_handle,&dataTx,1,TransferComplete);
//}
/************************************************************************************//**
*
* @brief HAL_SensorStack_Sensor_Send_Stop_Command()
* Sends STOP Command through SPI
*
* @param[in]
*
* @return None
*/
//void HAL_SensorStack_Sensor_Send_Stop_Command(void)
//{
// uint16_t dataTx = OPCODE_STOP;
//
// SPIDRV_MTransmit(sl_spidrv_SPI_Display_TemperatureSensor_handle,&dataTx,1,TransferComplete);
//}
void HAL_SensorStack_Send_SPI_Data(uint8_t *TxData, uint8_t length)
{
SPIDRV_MTransmit(sl_spidrv_SPI_Display_TemperatureSensor_handle,TxData,length,TransferComplete);
}
void HAL_SensorStack_Receive_SPI_Data(uint8_t *RxData, uint8_t length)
{
SPIDRV_MReceive(sl_spidrv_SPI_Display_TemperatureSensor_handle,RxData,length,TransferComplete);
}
void HAL_SensorStack_SendReceive_SPI_Data(uint8_t *TxData , uint8_t *RxData, uint8_t length)
{
SPIDRV_MTransferB(sl_spidrv_SPI_Display_TemperatureSensor_handle,TxData,RxData,length);
// SPIDRV_MTransfer(sl_spidrv_SPI_Display_TemperatureSensor_handle,TxData,RxData,length,TransferComplete);
}
/********************************************************************************
* STATIC FUNCTIONS
********************************************************************************/
/******************************************************************************************************************
* Function Name: static void TransferComplete(SPIDRV_Handle_t handle,Ecode_t transferStatus,int itemsTransferred)
* Author: Sumit
* Date: 31-May-2024
* Function Parameter: SPIDRV_Handle_t handle,Ecode_t transferStatus,int itemsTransferred
* Return value : Success
* Description: -- This is a callback function to check if the transfer is success
******************************************************************************************************************/
static void TransferComplete(SPIDRV_Handle_t handle,
Ecode_t transferStatus,
int itemsTransferred)
{
if (transferStatus == ECODE_EMDRV_SPIDRV_OK) {
// Success !
}
}
/********************************************************************************
* Function Name: int16_t HAL_TemperatureStack_Receive_Temperature_Value(uint8_t)
* Author: Naresh Patel
* Date: 03-May-2024
* Function Parameter: void
* Return value : void
* Description: --
*******************************************************************************/
int16_t HAL_TemperatureStack_Receive_Temperature_Value(uint8_t temperature_config)
{
uint16_t statusb;
uint16_t crc;
double temperature_val;
int16_t temperature_sensor_val = 0;
int32_t adc_value;
uint8_t i = 0;
//Temperature Sensor logic
// 1st : Send SPI command to read resistance value from RTD to digital converter
// 2nd : Using constants Aplha, beta and gamma and gain value ---> Degree Celcius
// 3rd : Celcius to Fahrenhit
//Method 1: To read data from saved data buffer.
adc_value = ADS124S08_Read();
//Method 2 : To read data direct from data buffer.
// if(GPIO_PinOutGet(SENSOR_DRDY_PORT, SENSOR_DRDY_PIN) == LOW)
// adc_value[i] = ADS124S08_Read_Data();
// else
// {
// while(GPIO_PinOutGet(SENSOR_DRDY_PORT, SENSOR_DRDY_PIN) == HIGH);
// adc_value[i] = ADS124S08_Read_Data();
// }
temperature_val = HAL_SensorStack_Calculate_RTD_Temperature(adc_value);
temperature_sensor_val = (int16_t)(temperature_val * 10U);
return(temperature_sensor_val);
}
/********************************************************************************
* Function Name: static float HAL_SensorStack_Calculate_RTD_Temperature(int32_t adcValue)
* Author: Naresh Patel
* Date: 03-May-2024
* Function Parameter: void
* Return value : void
* Description: --
*******************************************************************************/
static double HAL_SensorStack_Calculate_RTD_Temperature(int32_t adcValue)
{
double temperature;
// Calculate resistance of RTD
volatile double resistance = (adcValue * (RREF / 8388607)) /(16); // Adjust for gain of 16
// Calculate temperature using Callendar-Van Dusen equation
if (resistance > R0) { // Temperatures above 0 degrees C
temperature = ((-RTD_A * R0 + sqrt(pow(RTD_A * R0, 2) - 4 * RTD_B * R0 * (R0 - resistance))) / (2 * RTD_B * R0));
} else { // Temperatures above 0 degrees C
temperature = ((resistance / R0 - 1) / (RTD_A + RTD_B * (resistance / R0 - 1) + RTD_C * pow((resistance / R0 - 1), 2)));
}
return temperature;
}
/******************************************************************************************************************
* Function Name: void HAL_SensorStack_ReInitialize(void)
* Author: Naresh
* Date: 23-June-2024
* Function Parameter: void
* Return value : void
* Description: -- ReInitialize SPI interface for temperature stack
******************************************************************************************************************/
void HAL_SensorStack_ReInitialize(void)
{
sl_spidrv_init_SPI_Display_TemperatureSensor.bitRate = SL_SPIDRV_SPI_TEMPERATURESENSOR_BITRATE;
sl_spidrv_init_SPI_Display_TemperatureSensor.clockMode = spidrvClockMode1;
SPIDRV_Init(sl_spidrv_SPI_Display_TemperatureSensor_handle, &sl_spidrv_init_SPI_Display_TemperatureSensor);
}
/************************************************************************************//**
*
* @brief restoreRegisterDefaults()
* Updates the registerMap[] array to its default values
* NOTES: If the MCU keeps a copy of the ADC register settings in memory,
* then it is important to ensure that these values remain in sync with the
* actual hardware settings. In order to help facilitate this, this function
* should be called after powering up or resetting the device (either by
* hardware pin control or SPI software command).
* Reading back all of the registers after resetting the device will
* accomplish the same result.
*
* @return None
*/
static void restoreRegisterDefaults(void)
{
/* Default register settings */
registerMap[REG_ADDR_ID] = ID_DEFAULT;
registerMap[REG_ADDR_STATUS] = STATUS_DEFAULT;
registerMap[REG_ADDR_INPMUX] = INPMUX_DEFAULT;
registerMap[REG_ADDR_PGA] = PGA_DEFAULT;
registerMap[REG_ADDR_DATARATE] = DATARATE_DEFAULT;
registerMap[REG_ADDR_REF] = REF_DEFAULT;
registerMap[REG_ADDR_IDACMAG] = IDACMAG_DEFAULT;
registerMap[REG_ADDR_IDACMUX] = IDACMUX_DEFAULT;
registerMap[REG_ADDR_VBIAS] = VBIAS_DEFAULT;
registerMap[REG_ADDR_SYS] = SYS_DEFAULT;
registerMap[REG_ADDR_OFCAL0] = OFCAL0_DEFAULT;
registerMap[REG_ADDR_OFCAL1] = OFCAL1_DEFAULT;
registerMap[REG_ADDR_OFCAL2] = OFCAL2_DEFAULT;
registerMap[REG_ADDR_FSCAL0] = FSCAL0_DEFAULT;
registerMap[REG_ADDR_FSCAL1] = FSCAL1_DEFAULT;
registerMap[REG_ADDR_FSCAL2] = FSCAL2_DEFAULT;
registerMap[REG_ADDR_GPIODAT] = GPIODAT_DEFAULT;
registerMap[REG_ADDR_GPIOCON] = GPIOCON_DEFAULT;
}
Tool/software:
Hello ,
I am using ADS124S08 RTD to digital converter to read RTD sensor data. I have initialized register settings and read it back. It is giving proper value which i initialized..
In HW circuit , We use AIN0 as current source. We use 4 wire RTD sensor. We connected RTD sensor with AIN0, AIN1, AIN2, AIN3. I checked that AIN0 voltage is 1.6 V. AIN1 voltage is 1.6 V. AIN2 voltage is REFOUT voltage is 2.7. Voltage difference between AIN1(V+) and AIN2(V-) = 1.1 V.
I use "ADS124S08_Read()" function to read ADC value. After that i send read command periodically. Which always returns 0.I am using silicon lab microcontroller , for silicon lab microcontroller SPI is working fine.
I am attaching source code and schematic. Could you please guide me why i am getting zero ADC value during read "ADS124S08_Read()" ?
.
