hardware/fertirrega_v6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed error from 0.5 to 0.1 Celsius Degree

Browse Source
This commit is contained in:
hardware
2026-08-07 17:48:48 +01:00
parent 0452925384
commit ebb76da3b0
12 changed files with 13130 additions and 11832 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Fertirrega_v6/Core/Inc/ad5934_driver.h
+59 -14
View File
@@ -87,12 +87,24 @@ extern "C" {
// Values for frequency counts = (freq*2^27)/(1MHz/16)
#define AD5934_FREQ_4K882HZ 0x009FF92F // 4.882kHz
#define AD5934_FREQ_3K761HZ 0x007B3D8E // 3.761kHZ
#define AD5934_FREQ_2K599HZ 0x005529FE // 2.599kHz
#define AD5934_FREQ_2K5HZ 0x0051EB86 // 2.5kHz
#define AD5934_FREQ_2K293HZ 0x004B2314 // 2.293kHz
#define AD5934_FREQ_2K018HZ 0x00422036 // 2.018kHz
#define AD5934_FREQ_1K953HZ 0x003FFEF3 // 1.953kHz
#define AD5934_FREQ_1K865HZ 0x003D1CC1 // 1.865kHz
#define AD5934_FREQ_1K590HZ 0x003419E3 // 1.59kHz
#define AD5934_FREQ_0HZ 0x00000000 // 0Hz
#define AD5934_STEP_FREQ_0 0x0000 // 0 passos
#define AD5934_SETTLING_TIME_23 0x0017 // 17 ciclos
#define AD5934_SETTLING_TIME_32 0x0020 // 32 ciclos
#define AD5934_SETTLING_TIME_48 0x0030 // 48 ciclos
#define AD5934_SETTLING_TIME_64 0x0040 // 64 ciclos
#define AD5934_SETTLING_TIME_90 0x0060 // 90 ciclos
#define AD5934_SETTLING_TIME_117 0x0075 // 117 ciclos
#define AD5934_SETTLING_TIME_160 0x00A0 // 160 ciclos
#define AD5934_SETTLING_TIME_191 0x00BF // 191 ciclos
/*****************************************************************************/
@@ -116,7 +128,7 @@ extern "C" {
#define ADG715_SW7 0x40 //RTD Input
#define ADG715_SW8 0x80 //CE Input
#define ADG715_SWOFF 0x00 //Dummy
/*****************************************************************************/
/**************************** General Defines ********************************/
@@ -141,6 +153,9 @@ extern "C" {
#define AD5934_GAIN_FACTOR_1413US 1413.0f
#define AD5934_GAIN_FACTOR_12880US 12880.0f
// Aproximação linear do coeficiente PT100/PT1000 (α), usada abaixo de 0°C
// R(T) ≈ R0 * (1 + ALPHA * T) → T ≈ (R/R0 - 1) / ALPHA
#define AD5934_RTD_ALPHA 0.00385f // ohms/ohm/°C, padrão IEC 60751
#define AD5934_RTD_A 3.9083e-3f
#define AD5934_RTD_B (-5.775e-7f)
@@ -150,27 +165,22 @@ extern "C" {
#define AD5934_EC_ALPHA_PER_C 0.02f
#define AD5934_EC_TEMP_REF_C 25.0f
// Values for sample timming sync
#define AD5934_SYNC_PER_SWEEP 60 // 60 ms between sweeps
#define AD5934_SYNC_MUX_SETTLING 5 // 5 ms to wait before read after change ADG715 channels
//Mux Set to Read...
#define AD5934_ID_RTD 0
#define AD5934_ID_EC 1
#define AD5934_ID_REF 2
/*****************************************************************************/
/**************************** Filtering Defines *****************************/
/*****************************************************************************/
#define AD5934_TIME_PER_SWEEP 60 // 60 ms entre o início de cada sweep
#define AD5934_TIME_MUX_SETTLING 10 // 10 ms de espera após trocar o MUX
#define AD5934_TIME_PER_SWEEP 10 // 60 ms entre o início de cada sweep
#define AD5934_SYNC_MUX_SETTLING 40 // 10 ms to wait before read after change ADG715 channels
#define AD5934_BURST_SIZE 5
#define AD5934_TRIM_COUNT 1
#define AD5934_HISTORY_SIZE 5
#define AD5934_IIR_ALPHA 0.55f
#define AD5934_BURST_SIZE 1 // Number of Repeated Sweeps on the same channel before change the Mux
#define AD5934_TRIM_COUNT 0
#define AD5934_HISTORY_SIZE 8
#define AD5934_IIR_ALPHA 0.10f
#define AD5934_REF_FLOAT_SCALE_MIN 1850.0f
#define AD5934_REF_FLOAT_SCALE_MAX 2450.0f
@@ -241,12 +251,12 @@ typedef enum {
typedef enum {
AD5934_IDLE,
AD5934_WAIT_MUX,
AD5934_START_CONVERSION,
AD5934_WAIT_CONVERSION,
AD5934_READ_DATA,
AD5934_WAIT_NEXT_SWEEP,
AD5934_SWITCH_MUX,
AD5934_WAIT_MUX
AD5934_SWITCH_MUX
} AD5934_State_t;
@@ -263,6 +273,14 @@ typedef struct {
uint8_t value_valid;
} AD5934_filter_t;
typedef struct {
float buffer[AD5934_HISTORY_SIZE];
float sum;
uint8_t index;
uint8_t count; // quantas amostras já foram inseridas (até encher o buffer)
float average;
} AD5934_AvgFilter_t;
static const uint8_t ADG715_Channel_Map[AD5934_CH_MAX] = {
[AD5934_CH_REF100R_LOW_GAIN] = (ADG715_SW1 | ADG715_SW4),
[AD5934_CH_REF100R_MID_GAIN] = (ADG715_SW2 | ADG715_SW4),
@@ -357,12 +375,14 @@ static const uint16_t AD5934_Scale_Out_Max[AD5934_CH_MAX] = {
AD5934_EC5_OUT_SCALE_MAX
};
extern I2C_HandleTypeDef hi2c2;
extern float reference_resistor, temperature_RTD, thermal_compensaded_EC;
extern volatile AD5934_State_t ad5934_state;
extern volatile uint32_t g_ms_counter; // Increment each 1ms Timer
extern volatile uint32_t state_timer;
extern uint8_t current_mux_channel;
extern uint8_t sweep_count; // Count how many sweeps done at the same channel now (0 a 7)
@@ -373,6 +393,9 @@ extern uint8_t current_ref_mux;
extern AD5934_filter_t g_rtd_filter, g_ec_filter, g_ref_filter;
extern int16_t rtd_now, ref_now, ec_now;
extern int16_t rtd_now_i, ref_now_i, ec_now_i;
/*****************************************************************************/
/************************ Functions Declarations *****************************/
/*****************************************************************************/
@@ -380,6 +403,8 @@ void AD5934_SetRegisterValue(uint8_t registerAddress, uint32_t registerValue, ui
uint32_t AD5934_GetRegisterValue(uint8_t registerAddress, uint8_t numberOfBytes);
uint32_t AD5934_ReadRegister(uint8_t regAddr, uint8_t numberOfBytes);
void AD5934_Init(void);
void AD5934_RestartSweep(void);
@@ -398,12 +423,20 @@ float AD5934_EC_Calibrate_Temperature(float temp_C);
float AD5934_GetMagnitude(void);
float AD5934_GetImpedance(float mag_ref, float mag_dut);
uint32_t AD5934_Get_Real_Imag_Numbers(void);
uint16_t AD5934_Compress_To_IntScale(float value, uint8_t scale);
float AD5934_Round_Float_Precision(float value, uint8_t number_of_decimals);
float AD5934_Linear_Correction(float raw_value);
void AD5934_MovingAvg_Init(AD5934_AvgFilter_t *filt);
void AD5934_MovingAvg_Process(AD5934_AvgFilter_t *filt, float new_sample);
void AD5934_Process_System(void);
void AD5934_Sort_Array(float *v, uint8_t n);
@@ -416,10 +449,22 @@ void AD5934_Process_Sample(AD5934_filter_t *ch, float raw);
void AD5934_RTD_NewSample(float raw);
void AD5934_RTD_Real_NewSample(float raw);
void AD5934_RTD_Imag_NewSample(float raw);
void AD5934_EC_NewSample(float raw);
void AD5934_EC_Real_NewSample(float raw);
void AD5934_EC_Imag_NewSample(float raw);
void AD5934_Reference_NewSample(float raw);
void AD5934_Reference_Real_NewSample(float raw);
void AD5934_Reference_Imag_NewSample(float raw);
void ADG715_SetRegisterValue(char value);
void ADG715_ResetChannels(void);
Fertirrega_v6/Core/Src/ad5934_driver.c
+205 -77
View File
@@ -12,13 +12,13 @@
#include "ad5934_driver.h"
volatile AD5934_State_t ad5934_state = AD5934_IDLE;
volatile uint32_t state_timer = 0;
volatile uint32_t g_ms_counter = 0; /* Incrementado a cada 1ms no Timer */
float reference_resistor = 0, temperature_RTD = 0, thermal_compensaded_EC = 0;
uint8_t current_mux_channel = AD5934_ID_RTD;
uint8_t current_hw_mux_connection = ADG715_Channel_Map[AD5934_CH_RTD_LOW_GAIN]; // PT100 Connection
uint8_t current_mux_channel = 0;
uint8_t current_hw_mux_connection = AD5934_CH_REF100R_LOW_GAIN; // Connection
uint8_t current_ec_mux = AD5934_CH_EC_MID_GAIN;
uint8_t current_rtd_mux = AD5934_CH_RTD_LOW_GAIN;
uint8_t current_ref_mux = AD5934_CH_REF100R_LOW_GAIN;
@@ -29,6 +29,9 @@ AD5934_filter_t g_rtd_filter = {0};
AD5934_filter_t g_ec_filter = {0};
AD5934_filter_t g_ref_filter = {0};
int16_t rtd_now, ref_now, ec_now;
int16_t rtd_now_i, ref_now_i, ec_now_i;
uint8_t is_new_channel = 1;
/******************************************************************************
@@ -98,6 +101,43 @@ uint32_t AD5934_GetRegisterValue(uint8_t registerAddress, uint8_t numberOfBytes)
}
/************************************************************************************
* @brief Lê um registrador do AD5934 usando a abstração Mem_Read (mais segura).
*
* @param regAddr Endereço do registrador no AD5934.
* @return uint32_t Valor lido do registrador.
***********************************************************************************/
uint32_t AD5934_ReadRegister(uint8_t regAddr, uint8_t numberOfBytes)
{
uint32_t registerValue = 0;
uint8_t readData[4] = {0,0,0,0}; // Buffer para receber 16 bits (AD5934 usa regs de 16-bit)
uint8_t writeData[2] = {AD5934_ADDR_POINTER,regAddr};
//HAL_StatusTypeDef status;
//Limit buffer size to prevent stack overflow (AD5934 regs are max 4 bytes) */
if (numberOfBytes > 4)
{
return 0xFFFFFFFF;
}
HAL_I2C_Master_Transmit(&hi2c2, AD5934_I2C_ADDRESS, writeData, 2, 5);
//HAL_Delay(1);
// Usamos Mem_Read que faz: START -> ADDR+W -> REG_ADDR -> REPEATED_START -> ADDR+R -> DATA -> STOP
HAL_I2C_Mem_Read(&hi2c2, AD5934_I2C_ADDRESS, AD5934_BLOCK_READ, I2C_MEMADD_SIZE_8BIT, readData, numberOfBytes, 5);
/* 5. Reconstruct value from Big-Endian buffer */
for (uint8_t i = 0; i < numberOfBytes; i++)
{
registerValue = (registerValue << 8) | readData[i];
}
return registerValue;
}
/******************************************************************************
* @brief Configure and Start the AD5934 frequency sweep parameters.
*
@@ -116,7 +156,7 @@ void AD5934_Init(void)
AD5934_SetRegisterValue(AD5934_CONTROL_REG_LB, (AD5934_CONTROL_FUNCTION(AD5934_RESET)), 1);
// Configure starting frequency
AD5934_SetRegisterValue(AD5934_START_FREQ_REG_LB, AD5934_FREQ_2K5HZ, 3);
AD5934_SetRegisterValue(AD5934_START_FREQ_REG_LB, AD5934_FREQ_2K293HZ, 3);
// Configure frequency increment step
AD5934_SetRegisterValue(AD5934_FREQ_INCR_REG_LB, AD5934_FREQ_0HZ, 3);
@@ -195,7 +235,7 @@ void AD5934_StopSweep(void)
float AD5934_Calculate_Temperature(float mag_ref, float mag_dut)
{
uint8_t ch_ref;
float gain_factor, impedance_dut, ratio, discriminant;
float gain_factor, impedance_dut, temperature;
if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_7) == GPIO_PIN_SET) // OFF = PT1000, ON = PT100, PA7 has internal pull-up and switch connects to GND
{
@@ -217,12 +257,23 @@ float AD5934_Calculate_Temperature(float mag_ref, float mag_dut)
impedance_dut = gain_factor * ratio_mag;
// Calculate impedance ratio with the Reference Resistor
ratio = impedance_dut / gain_factor;
float ratio = impedance_dut / gain_factor;
// Calculate impedance discriminant with the ratio
discriminant = (AD5934_RTD_A*AD5934_RTD_A)-(4.0f * AD5934_RTD_B * (1.0f - ratio));
float discriminant = (AD5934_RTD_A*AD5934_RTD_A)-(4.0f * AD5934_RTD_B * (1.0f - ratio));
return ((-AD5934_RTD_A + sqrtf(discriminant))/(2.0f * AD5934_RTD_B));
if (discriminant >= 0.0f && impedance_dut >= gain_factor)
{
// Ramo T >= 0°C: solução quadrática exata
temperature = (-AD5934_RTD_A + sqrtf(discriminant))/(2.0f * AD5934_RTD_B);
}
else
{
// Ramo T < 0°C (ou discriminante inválido por ruído): aproximação linear
temperature = (ratio - 1.0f) / AD5934_RTD_ALPHA;
}
return AD5934_Round_Float_Precision(temperature,1);
}
@@ -299,10 +350,10 @@ float AD5934_GetMagnitude(void)
{
// Get Real Data register
int16_t real_value = ((AD5934_GetRegisterValue(AD5934_REAL_REG_LB,2)));
int16_t real_value = ((AD5934_GetRegisterValue(AD5934_REAL_REG_HB,2)));
// Get Imaginary Data register
int16_t imag_value = ((AD5934_GetRegisterValue(AD5934_IMG_REG_LB,2)));
int16_t imag_value = ((AD5934_GetRegisterValue(AD5934_IMG_REG_HB,2)));
// Calculate Magnitude using float function sqrtf
float magnitude = sqrtf(((float)real_value * (float)real_value) + ((float)imag_value * (float)imag_value));
@@ -312,6 +363,55 @@ float AD5934_GetMagnitude(void)
}
/******************************************************************************
* @brief Get Real and Imaginary values and calculate Magnitude.
*
* @param: none
*
* @return Magnitude (float).
******************************************************************************/
float AD5934_GetImpedance(float mag_ref, float mag_dut)
{
uint8_t ch_ref;
float gain_factor;
if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_7) == GPIO_PIN_SET) // OFF = PT1000, ON = PT100, PA7 has internal pull-up and switch connects to GND
{
ch_ref = AD5934_CH_RTD_LOW_GAIN; //PT100
gain_factor = AD5934_GAIN_FACTOR_100R;
}
else
{
ch_ref = AD5934_CH_RTD_MID_GAIN; //PT1000
gain_factor = AD5934_GAIN_FACTOR_1K;
}
float impedance_ref = (1/(mag_ref * gain_factor));
float impedance_dut = (1/(mag_dut * impedance_ref));
return impedance_dut;
}
/******************************************************************************
* @brief Get Real and Imag values from Magnitude.
*
* @param: none
*
* @return Magnitude (int16).
******************************************************************************/
uint32_t AD5934_Get_Real_Imag_Numbers(void)
{
uint32_t real_imag_reg = AD5934_GetRegisterValue(AD5934_IMG_REG_LB, 4); //AD5934_ReadRegister(AD5934_REAL_REG_LB, 4); //
return (real_imag_reg);
}
/**
* @brief Converte um valor float em uma escala de FLOAT_MIN a FLOAT_MAX para uint16_t em escala de UINT16_MIN a UINT16_MAX
*
@@ -333,7 +433,10 @@ uint16_t AD5934_Compress_To_IntScale(float value, uint8_t scale)
return AD5934_Scale_Out_Max[scale];
// Converte o valor usando a fórmula: ((value - FLOAT_MIN) / (FLOAT_MAX - FLOAT_MIN)) * (UINT16_MAX - UINT16_MIN) + UINT16_MIN
uint16_t result = (uint16_t)(((value - AD5934_Scale_Float_Min[scale]) / (AD5934_Scale_Float_Max[scale] - AD5934_Scale_Float_Min[scale])) * ((float)AD5934_Scale_Out_Max[scale] - (float)AD5934_Scale_Out_Min[scale]) + (float)AD5934_Scale_Out_Min[scale]);
//uint16_t result = (uint16_t)(((value - AD5934_Scale_Float_Min[scale]) / (AD5934_Scale_Float_Max[scale] - AD5934_Scale_Float_Min[scale])) * ((float)AD5934_Scale_Out_Max[scale] - (float)AD5934_Scale_Out_Min[scale]) + (float)AD5934_Scale_Out_Min[scale]);
float factor = ((float)AD5934_Scale_Out_Max[scale] - (float)AD5934_Scale_Out_Min[scale]) / (AD5934_Scale_Float_Max[scale] - AD5934_Scale_Float_Min[scale]);
uint16_t result = (uint16_t)((float)AD5934_Scale_Out_Min[scale] + (value - AD5934_Scale_Float_Min[scale]) * factor);
// Garante que o resultado não exceda o limite superior
if (result > AD5934_Scale_Out_Max[scale])
@@ -418,92 +521,87 @@ float AD5934_Calibrate(float dry_probe_real, float dry_probe_imag, float standar
*/
void AD5934_Process_System(void)
{
static uint32_t state_timer = 0;
uint8_t status = 0;
switch (ad5934_state)
switch (ad5934_state)
{
case AD5934_IDLE:
ADG715_SetChannels(current_mux_channel); // Starts changing the mux channel
ADG715_SetChannels(current_hw_mux_connection); // Starts changing the mux channel
is_new_channel = 1; // Forces first channel
state_timer = g_ms_counter;
ad5934_state = AD5934_WAIT_MUX;
break;
case AD5934_WAIT_MUX:
if ((g_ms_counter - state_timer) >= AD5934_SYNC_MUX_SETTLING) // Wait until AD715 Mux switch stability
{
sweep_count = 0;
ad5934_state = AD5934_START_CONVERSION;
}
//if ((g_ms_counter - state_timer) >= AD5934_SYNC_MUX_SETTLING) // Wait until AD715 Mux switch stability
//{
HAL_Delay(15);
ad5934_state = AD5934_START_CONVERSION;
//}
break;
case AD5934_START_CONVERSION:
state_timer = g_ms_counter; // Starts to count the Burst period for the sweeps
/* DECISÃO DE COMANDO: Novo canal vs Leituras sucessivas */
if (is_new_channel) // Decision: Channel Switched or Next Sample in the Burst ?
{
AD5934_RestartSweep(); // Clean some AD5934 internal registers to Re-Start Sweep
is_new_channel = 0; // Resets the flag to read the next Sample Burst
}
else
{
AD5934_Repeat_Sweep(); // Get Sample and just repeat reading
}
//state_timer = g_ms_counter; // Starts to count the Burst period for the sweeps
/* DECISÃO DE COMANDO: Novo canal vs Leituras sucessivas */
if (is_new_channel) // Decision: Channel Switched or Next Sample in the Burst ?
{
AD5934_RestartSweep(); // Clean some AD5934 internal registers to Re-Start Sweep
is_new_channel = 0; // Resets the flag to read the next Sample Burst
}
else
{
AD5934_Repeat_Sweep(); // Get Sample and just repeat reading
}
ad5934_state = AD5934_WAIT_CONVERSION; // Next State
ad5934_state = AD5934_WAIT_CONVERSION; // Next State
break;
case AD5934_WAIT_CONVERSION:
status = (uint8_t)AD5934_GetRegisterValue(AD5934_STATUS_REG, 1); // Check if the current converion is ready in the AD5934
uint8_t status = (uint8_t)AD5934_GetRegisterValue(AD5934_STATUS_REG, 1); // Check if the current converion is ready in the AD5934
if ((status & AD5934_STATUS_DATA_VALID) != 0)
{
ad5934_state = AD5934_READ_DATA;
uint32_t magnitude_int = AD5934_Get_Real_Imag_Numbers();
int16_t mag_real = (int16_t)(magnitude_int>>16);
int16_t mag_imag = (int16_t)(magnitude_int & 0x0000FFFF);
float mag_float = sqrtf(((float)mag_real * (float)mag_real) + ((float)mag_imag * (float)mag_imag));
switch (current_mux_channel)
{
case AD5934_ID_RTD:
AD5934_RTD_NewSample(mag_float);
rtd_now = mag_float;
rtd_now_i = mag_imag;
break;
case AD5934_ID_EC:
AD5934_EC_NewSample(mag_float);
ec_now = mag_real;
ec_now_i = mag_imag;
break;
case AD5934_ID_REF:
AD5934_Reference_NewSample(mag_float);
ref_now = mag_float;
ref_now_i = mag_imag;
break;
}
if(sweep_count<(AD5934_BURST_SIZE-1))
{
sweep_count++;
ad5934_state = AD5934_START_CONVERSION;
}
else
{
sweep_count = 0;
ad5934_state = AD5934_SWITCH_MUX;
}
}
break;
case AD5934_READ_DATA:
{
float magnitude = AD5934_GetMagnitude();
switch (current_mux_channel)
{
case AD5934_ID_RTD:
AD5934_RTD_NewSample(magnitude);
break;
case AD5934_ID_EC:
AD5934_EC_NewSample(magnitude);
break;
case AD5934_ID_REF:
AD5934_Reference_NewSample(magnitude);
break;
}
sweep_count++;
if (sweep_count >= AD5934_BURST_SIZE) // Check if number of samples for the burst is complete
{
ad5934_state = AD5934_SWITCH_MUX; // Next Re-Start Sweep
}
else
{
ad5934_state = AD5934_WAIT_NEXT_SWEEP; // Next Repeat Sweep
}
}
break;
case AD5934_WAIT_NEXT_SWEEP:
if ((g_ms_counter - state_timer) >= AD5934_TIME_PER_SWEEP)
{
ad5934_state = AD5934_START_CONVERSION;
}
break;
case AD5934_SWITCH_MUX:
AD5934_StopSweep(); // Put AD5934 in Standby
AD5934_StopSweep(); // Put AD5934 in Standby
current_mux_channel = (uint8_t)((current_mux_channel + 1) % 3); // Pointer to the next channel (Circular Buffer 0 to 2)
switch (current_mux_channel)
{
@@ -529,9 +627,11 @@ void AD5934_Process_System(void)
break;
}
ADG715_SetChannels(current_hw_mux_connection); // Change the analog mux
HAL_Delay(12);
is_new_channel = 1; // Channel Switched
state_timer = g_ms_counter; // Reload timer to wait for stability
ad5934_state = AD5934_WAIT_MUX; // Next State
//state_timer = g_ms_counter; // Reload timer to wait for stability
//ad5934_state = AD5934_WAIT_MUX; // Next State
ad5934_state = AD5934_START_CONVERSION;
break;
}
}
@@ -638,10 +738,35 @@ void AD5934_Process_Sample(AD5934_filter_t *ch, float raw)
/* Final output: combines the IIR state (fast response to real drift)
* with the window average (more stable, slower response). Adjust
* the weighting per channel if needed. */
ch->filtered_value = 0.5f * ch->iir_state + 0.5f * window_average;
ch->filtered_value = 0.65f * ch->iir_state + 0.35f * window_average;
//ch->filtered_value = window_average;
ch->value_valid = 1;
}
void AD5934_MovingAvg_Init(AD5934_AvgFilter_t *filt)
{
for (uint8_t i = 0; i < AD5934_HISTORY_SIZE; i++) {
filt->buffer[i] = 0.0f;
}
filt->sum = 0.0f;
filt->index = 0;
filt->count = 0;
filt->average = 0.0f;
}
void AD5934_MovingAvg_Process(AD5934_AvgFilter_t *filt, float new_sample)
{
for (uint8_t i = (AD5934_HISTORY_SIZE-1); i > 0; i--)
filt->buffer[i] = filt->buffer[i-1];
filt->buffer[0] = new_sample;
for (uint8_t i = 0; i < AD5934_HISTORY_SIZE; i++)
filt->sum += new_sample;
filt->average = (filt->sum / (float)AD5934_HISTORY_SIZE);
}
/* ---------------------------------------------------------------------- */
/* PUBLIC FUNCTIONS - ONE PER CHANNEL */
@@ -654,6 +779,7 @@ void AD5934_RTD_NewSample(float raw)
AD5934_Process_Sample(&g_rtd_filter, raw);
}
/* Call this every time a sweep completes with the mux on the EC
* (conductivity probe) channel */
void AD5934_EC_NewSample(float raw)
@@ -661,6 +787,7 @@ void AD5934_EC_NewSample(float raw)
AD5934_Process_Sample(&g_ec_filter, raw);
}
/* Call this every time a sweep completes with the mux on the on-board
* precision reference resistor channel */
void AD5934_Reference_NewSample(float raw)
@@ -669,6 +796,7 @@ void AD5934_Reference_NewSample(float raw)
}
/*****************************************************************************
* ADG715
*****************************************************************************
Fertirrega_v6/Core/Src/main.c
+101 -32
View File
@@ -62,6 +62,7 @@ void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
void intToStr(int16_t N, uint8_t *str);
void FloatToString(uint8_t * buf, double val);
void Convert2Hex(uint32_t value, char *str);
/* USER CODE END PFP */
@@ -89,7 +90,9 @@ int main(void)
uint32_t previous_millis_red = 0;
uint32_t current_millis;
float ref_final;
float mag_reference, mag_rtd, mag_ec;
/* USER CODE END 1 */
@@ -122,6 +125,9 @@ int main(void)
HAL_TIM_Base_Start_IT(&htim3);
//AD5934_MovingAvg_Init (&g_rtd_filter);
//AD5934_MovingAvg_Init (&g_ref_filter);
//AD5934_MovingAvg_Init (&g_ec_filter);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_SET); // LED Green Off
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, GPIO_PIN_SET); // LED Red Off
@@ -129,6 +135,7 @@ int main(void)
digital_outputs_init();
rs485_init();
ADG715_ResetChannels();
ADS1015_Init(); // Initializes pH Measurement
AD5934_Init(); // Initializes CE and RTD Measurement
@@ -136,8 +143,8 @@ int main(void)
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while(averages<15)
/*
while(averages<20)
{
AD5934_Process_System();
ADS1015_Process_System();
@@ -146,16 +153,18 @@ int main(void)
if((current_millis % 20) == 0) // Send data each 20ms
{
if (g_ref_filter.value_valid) // Reference Resistor on Board: 100 Ohms or 1000 Ohms
if (g_ref_imag_filter.value_valid) // Reference Resistor on Board: 100 Ohms or 1000 Ohms
{
reference_resistor = g_ref_filter.filtered_value;
uint16_t reference_final = AD5934_REF_OUT_SCALE_MAX - AD5934_Compress_To_IntScale(g_ref_filter.filtered_value, current_ref_mux);
//reference_resistor = g_ref_filter.filtered_value;
reference_resistor = sqrtf((g_ref_real_filter.filtered_value * g_ref_real_filter.filtered_value)+(g_ref_imag_filter.filtered_value * g_ref_imag_filter.filtered_value));
//reference_resistor = ref_now;
//uint16_t reference_final = AD5934_REF_OUT_SCALE_MAX - AD5934_Compress_To_IntScale(g_ref_filter.filtered_value, current_ref_mux);
averages++;
}
}
}
*/
digital_outputs_toggle(0);
digital_outputs_toggle(1);
digital_outputs_toggle(2);
@@ -177,41 +186,78 @@ int main(void)
if((current_millis % 500) == 0) // Send data each 100ms
{
/* if (g_ref_filter.value_valid) // Reference Resistor on Board: 100 Ohms or 1000 Ohms
{
//if (g_ref_filter.value_valid) // Reference Resistor on Board: 100 Ohms or 1000 Ohms
//{
mag_reference = g_ref_filter.filtered_value;
//mag_reference = sqrtf(((float)ref_now * (float)ref_now) + ((float)ref_now_i * (float)ref_now_i));
//mag_reference = sqrtf((g_ref_real_filter.average * g_ref_real_filter.average)+(g_ref_imag_filter.average * g_ref_imag_filter.average));
//mag_reference = (float)ref_now;
//reference_resistor = g_ref_filter.filtered_value;
uint16_t reference_final = AD5934_REF_OUT_SCALE_MAX - AD5934_Compress_To_IntScale(g_ref_filter.filtered_value, current_ref_mux);
//uint16_t reference_final = AD5934_REF_OUT_SCALE_MAX - AD5934_Compress_To_IntScale(g_ref_filter.filtered_value, current_ref_mux);
intToStr(reference_final, tempString);
// float ref_final = g_ref_filter.filtered_value;
//FloatToString(tempString, ref_final);
//intToStr(reference_final, tempString);
//ref_final = g_ref_filter.filtered_value;
FloatToString(tempString, mag_reference);
//Convert2Hex(ref_now, tempString);
//intToStr(ref_now, tempString);
rs485_send_broadcast(tempString, (strlen((uint8_t*)tempString)));
//intToStr(ref_now_i, tempString);
//rs485_send_broadcast(tempString, (strlen((uint8_t*)tempString)));
rs485_send_broadcast(&newline, 1);
//}
//if (g_rtd_filter.value_valid) // PT100 or PT1000 in °C
//{
//mag_rtd = (float)rtd_now;
mag_rtd = g_rtd_filter.filtered_value;
//mag_rtd = sqrtf((g_rtd_real_filter.average * g_rtd_real_filter.average)+(g_rtd_imag_filter.average * g_rtd_imag_filter.average));
//mag_rtd = sqrtf(((float)rtd_now * (float)rtd_now) + ((float)rtd_now_i * (float)rtd_now_i));
//temperature_RTD = AD5934_Calculate_Temperature(mag_reference, mag_rtd);
temperature_RTD = AD5934_Calculate_Temperature(mag_reference,mag_rtd);// AD5934_GetImpedance(mag_reference,mag_rtd);//
//uint16_t rtd_final = AD5934_RTD_OUT_SCALE_MAX - AD5934_Compress_To_IntScale(g_rtd_filter.filtered_value, current_rtd_mux);
//uint16_t rtd_final = AD5934_Compress_To_IntScale(temperature_RTD, current_rtd_mux);
//intToStr(rtd_final, tempString);
//float rtd_final = g_rtd_filter.filtered_value; //g_rtd_filter.filtered_value;
FloatToString(tempString, temperature_RTD);
//Convert2Hex(rtd_now, tempString);
//intToStr(rtd_now, tempString);
rs485_send_broadcast(tempString, (strlen((uint8_t*)tempString)));
//Convert2Hex(rtd_now_i, tempString);
//intToStr(rtd_now_i, tempString);
//rs485_send_broadcast(tempString, (strlen((uint8_t*)tempString)));
rs485_send_broadcast(&newline, 1);
//}
/*if (g_rtd_imag_filter.value_valid) // PT100 or PT1000 in °C
{
//float mag_rtd = sqrtf((g_rtd_real_filter.filtered_value * g_rtd_real_filter.filtered_value)+(g_rtd_imag_filter.filtered_value * g_rtd_imag_filter.filtered_value));
temperature_RTD = AD5934_Calculate_Temperature(reference_resistor, mag_rtd);
//uint16_t rtd_final = AD5934_RTD_OUT_SCALE_MAX - AD5934_Compress_To_IntScale(g_rtd_filter.filtered_value, current_rtd_mux);
//uint16_t rtd_final = AD5934_Compress_To_IntScale(temperature_RTD, current_rtd_mux);
//intToStr(rtd_final, tempString);
float rtd_final = temperature_RTD; //g_rtd_filter.filtered_value;
FloatToString(tempString, rtd_final);
rs485_send_broadcast(tempString, (strlen((uint8_t*)tempString)));
rs485_send_broadcast(&newline, 1);
}*/
if (g_rtd_filter.value_valid) // PT100 or PT1000 in °C
{
temperature_RTD = AD5934_Calculate_Temperature(reference_resistor, g_rtd_filter.filtered_value);
uint16_t rtd_final = AD5934_RTD_OUT_SCALE_MAX - AD5934_Compress_To_IntScale(temperature_RTD, current_rtd_mux);
//if (g_ec_filter.value_valid) // EC
//{
//mag_ec = sqrtf((g_ec_real_filter.filtered_value * g_ec_real_filter.filtered_value)+(g_ec_imag_filter.filtered_value * g_ec_imag_filter.filtered_value));
mag_ec = sqrtf(((float)ec_now * (float)ec_now) + ((float)ec_now_i * (float)ec_now_i));
thermal_compensaded_EC = AD5934_EC_Compensate_Magnitude_To_25C(mag_ec, temperature_RTD);
//uint16_t ec_final = AD5934_Compress_To_IntScale(thermal_compensaded_EC, current_ec_mux);
intToStr(rtd_final, tempString);
//float rtd_final = g_rtd_filter.filtered_value;
//FloatToString(tempString, rtd_final);
rs485_send_broadcast(tempString, (strlen((uint8_t*)tempString)));
rs485_send_broadcast(&newline, 1);
}
if (g_ec_filter.value_valid) // EC
{
thermal_compensaded_EC = AD5934_EC_Compensate_Magnitude_To_25C(g_ec_filter.filtered_value, temperature_RTD);
uint16_t ec_final = AD5934_Compress_To_IntScale(thermal_compensaded_EC, current_ec_mux);
intToStr(ec_final, tempString);
//intToStr(ec_now, tempString);
// float ec_final = g_ec_filter.filtered_value;
// FloatToString(tempString, ec_final);
FloatToString(tempString, mag_ec);
//Convert2Hex((ec_now+0x80008000), tempString);
rs485_send_broadcast(tempString, (strlen((uint8_t*)tempString)));
//intToStr(ec_now_i, tempString);
//rs485_send_broadcast(tempString, (strlen((uint8_t*)tempString)));
rs485_send_broadcast(&newline, 1);
}
//}
if (g_ph_filter.value_valid) // pH
{
@@ -222,6 +268,7 @@ int main(void)
//FloatToString(tempString, ph_final);
rs485_send_broadcast(tempString, (strlen((uint8_t*)tempString)));
rs485_send_broadcast(&newline, 1);
rs485_send_broadcast(&newline, 1);
}
rs485_send_broadcast(&newline, 1);
@@ -359,7 +406,7 @@ void FloatToString(uint8_t *buf, double val)
fracBuffer[1] = (fracPart / 10) % 10; // Dezena
fracBuffer[0] = (fracPart / 100) % 10; // Centena
for (int k = 2; k >= 0; k--) {
for (int k = 0; k <= 2; k++) {
temp[i++] = fracBuffer[k] + '0';
}
@@ -434,6 +481,28 @@ void intToStr(int16_t N, uint8_t *str)
}
}
/**
* Converte um valor uint32_t para string hexadecimal,
* escrevendo o resultado no buffer apontado por 'str'.
*
* @param value Valor a ser convertido (ex: 4276803469)
* @param str Ponteiro para buffer de destino (mínimo 9 bytes:
* 8 dígitos hex + terminador nulo)
*/
void Convert2Hex(uint32_t value, char *str)
{
const char hexTable[] = "0123456789ABCDEF";
for (int8_t i = 7; i >= 0; i--)
{
str[i] = hexTable[value & 0xF];
value >>= 4;
}
//str[8] = '\0';
}
/* TIM3 Timer Interrupt */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{