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

Fertirrega v6 with internal temperature (but slow)

Browse Source
This commit is contained in:
hardware
2026-07-16 16:49:58 +01:00
parent 08709213d9
commit 8d1bb4fadb
121 changed files with 35137 additions and 12048 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Fertirrega_v6/Core/Src/ad5934_driver.c
+77 -112
View File
@@ -11,19 +11,14 @@
#include "ad5934_driver.h"
const float calibrationResistance[3] = {AD5934_GAIN_FACTOR_100R, AD5934_GAIN_FACTOR_1K, AD5934_GAIN_FACTOR_10K};
int16_t temperature_dut_samples[AD5934_TEMP_AVERAGES][2]={{0},{0}};
int16_t temperature_ref_samples[AD5934_TEMP_AVERAGES][2]={{0},{0}};
float temperature_display[AD5934_TEMP_AVERAGES] = {0};
int16_t ec_dut_samples[AD5934_EC_AVERAGES][2]={{0},{0}};
int16_t ec_ref_samples_H[AD5934_EC_AVERAGES][2]={{0},{0}};
int16_t ec_ref_samples_L[AD5934_EC_AVERAGES][2]={{0},{0}};
float ec_display[AD5934_EC_AVERAGES] = {0};
/******************************************************************************
* @brief Set an AD5934 internal register value.
*
@@ -221,17 +216,25 @@ uint32_t AD5934_Sweep(void)
******************************************************************************/
float AD5934_GetTemperature(void)
{
uint8_t i, channel;
uint8_t i, ch_dut, ch_ref;
uint32_t sample;
int32_t ref_sum[2], dut_sum[2];
float real_ref,imag_ref, real_dut, imag_dut, ratio, discriminant, mag_dut, mag_ref, ratio_mag, impedance_dut, temperature_sum;
float real_ref,imag_ref, real_dut, imag_dut, ratio, discriminant, mag_dut, mag_ref, ratio_mag, impedance_dut, temperature_sum, 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
channel = AD5934_CH_PT100;
{
ch_ref = AD5934_CH_REF100R_LOW_GAIN;
ch_dut = AD5934_CH_RTD_LOW_GAIN; //PT100
gain_factor = 100.0f;
}
else
channel = AD5934_CH_PT1000;
{
ch_ref = AD5934_CH_REF1K_MID_GAIN;
ch_dut = AD5934_CH_RTD_MID_GAIN; //PT1000
gain_factor = 1000.0f;
}
ADG715_Update(channel + AD5934_CH_DELTA); // Set the Reference Resistor on board in the Analog Mux
ADG715_Update(ch_ref); // Set the Reference Resistor on board in the Analog Mux
HAL_Delay(2); //Wait a little
sample = AD5934_Sweep(); // Get Reference Resistor Values from ADC
@@ -261,7 +264,7 @@ float AD5934_GetTemperature(void)
// Calculate gain factor impedance
mag_ref = sqrtf((real_ref * real_ref) + (imag_ref * imag_ref));
ADG715_Update(channel);
ADG715_Update(ch_dut);
HAL_Delay(2);
sample = AD5934_Sweep(); // Get PT100/PT1000 Values from ADC
@@ -295,13 +298,13 @@ float AD5934_GetTemperature(void)
ratio_mag = mag_ref / mag_dut;
if(channel==AD5934_CH_PT100)
impedance_dut = AD5934_Linear_Correction((calibrationResistance[channel & 0x0F]) * ratio_mag);
if(ch_ref==AD5934_CH_REF100R_LOW_GAIN) // only for PT100
impedance_dut = AD5934_Linear_Correction(gain_factor * ratio_mag);
else
impedance_dut = (calibrationResistance[channel & 0x0F]) * ratio_mag;
impedance_dut = gain_factor * ratio_mag;
// Calculate impedance ratio with the Reference Resistor
ratio = impedance_dut / (calibrationResistance[channel & 0x0F]);
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));
@@ -330,92 +333,24 @@ float AD5934_GetTemperature(void)
******************************************************************************/
float AD5934_GetImpedance(void)
{
uint8_t i, channel;
uint32_t sample_H, sample_L, sample_dut;
int32_t ref_sum_H[2], ref_sum_L[2], dut_sum[2];
float real_number, imag_number, mag_dut, mag_ref_H, mag_ref_L, gain_factor_H, gain_factor_L, gain_factor_dut, slope, admittance;
/* STEP 1: Two points reference curve */
ADG715_Update(AD5934_CH_REF_1K); // Set the Reference for High Resistor on board in the Analog Mux
HAL_Delay(2); //Wait a little
sample_H = AD5934_Sweep(); // Get Reference Resistor 1 from ADC
ADG715_Update(AD5934_CH_REF_100R); // Set the Reference for Low Resistor on board in the Analog Mux
HAL_Delay(2); //Wait a little
sample_L = AD5934_Sweep(); // Get Reference Resistor 2 from ADC
// Move values in the vectors
for (i = (AD5934_EC_AVERAGES-1); i > 0; i--)
{
ec_ref_samples_H[i][0] = ec_ref_samples_H[i-1][0]; //real
ec_ref_samples_H[i][1] = ec_ref_samples_H[i-1][1]; //imag
ec_ref_samples_L[i][0] = ec_ref_samples_L[i-1][0]; //real
ec_ref_samples_L[i][1] = ec_ref_samples_L[i-1][1]; //imag
}
// Read real and imaginary data
ec_ref_samples_H[0][0] = (int16_t)(sample_H & 0x0000FFFF); //real
ec_ref_samples_H[0][1] = (int16_t)((sample_H & 0xFFFF0000)>>16); //imag
//ec_ref_samples_H[0][1] = (int16_t)((0xFFFF - (sample_H & 0xFFFF0000)>>16)); //imag
// Read real and imaginary data
ec_ref_samples_L[0][0] = (int16_t)(sample_L & 0x0000FFFF); //real
ec_ref_samples_L[0][1] = (int16_t)((sample_L & 0xFFFF0000)>>16); //imag
//ec_ref_samples_L[0][1] = (int16_t)((0xFFFF - (sample_L & 0xFFFF0000)>>16)); //imag
// Sum values in the vectors
for (i = 0, ref_sum_H[0]=0, ref_sum_H[1]=0, ref_sum_L[0]=0, ref_sum_L[1]=0; i < AD5934_EC_AVERAGES; i++)
{
ref_sum_H[0] += (int32_t)ec_ref_samples_H[i][0]; //real
ref_sum_H[1] += (int32_t)ec_ref_samples_H[i][1]; //imag
ref_sum_L[0] += (int32_t)ec_ref_samples_L[i][0]; //real
ref_sum_L[1] += (int32_t)ec_ref_samples_L[i][1]; //imag
}
real_number = ((float)ref_sum_H[0])/((float)AD5934_EC_AVERAGES);
imag_number = ((float)ref_sum_H[1])/((float)AD5934_EC_AVERAGES);
// Calculate gain factor impedance
mag_ref_H = sqrtf((real_number * real_number) + (imag_number * imag_number));
if(mag_ref_H > 0.0f)
gain_factor_H = 1.0f / (1000.0f * mag_ref_H);
else
gain_factor_H = 0.0f;
real_number = ((float)ref_sum_L[0])/((float)AD5934_EC_AVERAGES);
imag_number = ((float)ref_sum_L[1])/((float)AD5934_EC_AVERAGES);
// Calculate gain factor impedance
mag_ref_L = sqrtf((real_number * real_number) + (imag_number * imag_number));
if(mag_ref_L > 0.0f)
gain_factor_L = 1.0f / (100.0f * mag_ref_L);
else
gain_factor_L = 0.0f;
uint8_t i, ec_gain;
uint32_t sample_dut;
int32_t dut_sum[2];
float real_number, imag_number, mag_dut, slope;
/* STEP 2: Set the Amplification related to the maximum set value */
if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_6) == GPIO_PIN_SET) // PA6 has internal pull-up and the Switch connects to GND
channel = AD5934_CH_EC_5MS; // Switch OFF = 5 mS/cm
ec_gain = AD5934_CH_EC_HIGH_GAIN; // Switch OFF = 5 mS/cm, HIGH GAIN,
else
channel = AD5934_CH_EC_10MS; // Switch ON = 10 mS/cm
ec_gain = AD5934_CH_EC_MID_GAIN; // Switch ON = 10 mS/cm, MID GAIN,
ADG715_Update(channel);
ADG715_Update(ec_gain);
HAL_Delay(2);
sample_dut = AD5934_Sweep(); // Get PT100/PT1000 Values from ADC
for (i = (AD5934_EC_AVERAGES-1); i > 0; i--)
{
ec_dut_samples[i][0] = ec_dut_samples[i-1][0]; //real
@@ -425,7 +360,6 @@ float AD5934_GetImpedance(void)
// Read real and imaginary data
ec_dut_samples[0][0] = (int16_t)(sample_dut & 0x0000FFFF); //real
ec_dut_samples[0][1] = (int16_t)((sample_dut & 0xFFFF0000)>>16); //imag
//ec_dut_samples[0][1] = (int16_t)((0xFFFF - (sample_dut & 0xFFFF0000)>>16)); //imag
for (i = 0, dut_sum[0]=0, dut_sum[1]=0; i < AD5934_EC_AVERAGES; i++)
{
@@ -439,20 +373,19 @@ float AD5934_GetImpedance(void)
// Calculate unknown magnitude
mag_dut = sqrtf((real_number * real_number) + (imag_number * imag_number));
// Calculate gain factor for the unknown magnitude
if(mag_ref_H != mag_ref_L)
slope = ((gain_factor_H - gain_factor_L)/(mag_ref_H - mag_ref_L));
//slope = ((gain_factor_H - gain_factor_L)/(log10f(mag_ref_H) - log10f(mag_ref_L)));
if(main_state == STATE_SETUP_CALIBRATION)
return(mag_dut);
else if(flash_data.ec12880_value != flash_data.ec1413_value)
{
slope = ((AD5934_GAIN_FACTOR_12880US - AD5934_GAIN_FACTOR_1413US)/(flash_data.ec12880_value - flash_data.ec1413_value));
return(AD5934_GAIN_FACTOR_1413US + (mag_dut - flash_data.ec1413_value) * slope);
}
else
return 0.0f;
//gain_factor_dut = gain_factor_L + (log10f(mag_dut) - log10f(mag_ref_L)) * slope;
gain_factor_dut = gain_factor_L + (mag_dut - mag_ref_L) * slope;
// Calculate and return admittance in mS
return(10.0f * mag_dut * gain_factor_dut);
}
@@ -576,33 +509,65 @@ void ADG715_Update(uint8_t channel)
ADG715_ResetChannels();
// Set the pair of connections
if(channel == AD5934_CH_REF_100R)
if(channel == AD5934_CH_REF100R_LOW_GAIN)
{
ADG715_SetChannels(ADG715_SW1, ADG715_SW4); // Rf = 150R, Ch = Ref_100R
}
else if(channel == AD5934_CH_REF_1K)
else if(channel == AD5934_CH_REF100R_MID_GAIN)
{
ADG715_SetChannels(ADG715_SW2, ADG715_SW4); // Rf = 1k5, Ch = Ref_100R
}
else if(channel == AD5934_CH_REF100R_HIGH_GAIN)
{
ADG715_SetChannels(ADG715_SW3, ADG715_SW4); // Rf = 6k2, Ch = Ref_100R
}
else if(channel == AD5934_CH_REF1K_LOW_GAIN)
{
ADG715_SetChannels(ADG715_SW1, ADG715_SW5); // Rf = 150R, Ch = Ref_1k
}
else if(channel == AD5934_CH_REF1K_MID_GAIN)
{
ADG715_SetChannels(ADG715_SW2, ADG715_SW5); // Rf = 1k5, Ch = Ref_1k
}
else if(channel == AD5934_CH_REF_10K)
else if(channel == AD5934_CH_REF1K_HIGH_GAIN)
{
ADG715_SetChannels(ADG715_SW3, ADG715_SW5); // Rf = 6k2, Ch = Ref_1k
}
else if(channel == AD5934_CH_REF10K_LOW_GAIN)
{
ADG715_SetChannels(ADG715_SW1, ADG715_SW6); // Rf = 150R, Ch = Ref_10k
}
else if(channel == AD5934_CH_REF10K_MID_GAIN)
{
ADG715_SetChannels(ADG715_SW2, ADG715_SW6); // Rf = 1k5, Ch = Ref_10k
}
else if(channel == AD5934_CH_REF10K_HIGH_GAIN)
{
ADG715_SetChannels(ADG715_SW3, ADG715_SW6); // Rf = 6k2, Ch = Ref_10k
}
else if(channel == AD5934_CH_PT100)
else if(channel == AD5934_CH_RTD_LOW_GAIN)
{
ADG715_SetChannels(ADG715_SW1, ADG715_SW7); // Rf = 150R, Ch = PT100
ADG715_SetChannels(ADG715_SW1, ADG715_SW7); // Rf = 150R, Ch = RTD
}
else if(channel == AD5934_CH_PT1000)
else if(channel == AD5934_CH_RTD_MID_GAIN)
{
ADG715_SetChannels(ADG715_SW2, ADG715_SW7); // Rf = 1k5, Ch = PT1000
ADG715_SetChannels(ADG715_SW2, ADG715_SW7); // Rf = 1k5, Ch = RTD
}
else if(channel == AD5934_CH_EC_10MS)
else if(channel == AD5934_CH_RTD_HIGH_GAIN)
{
ADG715_SetChannels(ADG715_SW2, ADG715_SW8); // Rf = 1k5, Ch = EC 10 mS/cm Max
ADG715_SetChannels(ADG715_SW3, ADG715_SW7); // Rf = 6k2, Ch = RTD
}
else if(channel == AD5934_CH_EC_5MS)
else if(channel == AD5934_CH_EC_LOW_GAIN)
{
ADG715_SetChannels(ADG715_SW3, ADG715_SW8); // Rf = 6k2, Ch = EC 5 mS/cm Max
ADG715_SetChannels(ADG715_SW1, ADG715_SW8); // Rf = 150R, Ch = EC
}
else if(channel == AD5934_CH_EC_MID_GAIN)
{
ADG715_SetChannels(ADG715_SW2, ADG715_SW8); // Rf = 1k5, Ch = EC
}
else if(channel == AD5934_CH_EC_HIGH_GAIN)
{
ADG715_SetChannels(ADG715_SW3, ADG715_SW8); // Rf = 6k2, Ch = EC
}
}
Fertirrega_v6/Core/Src/adc.c
+39 -8
View File
@@ -26,6 +26,7 @@
ADC_HandleTypeDef hadc1;
ADC_HandleTypeDef hadc2;
DMA_HandleTypeDef hdma_adc1;
/* ADC1 init function */
void MX_ADC1_Init(void)
@@ -44,12 +45,12 @@ void MX_ADC1_Init(void)
/** Common config
*/
hadc1.Instance = ADC1;
hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
hadc1.Init.ContinuousConvMode = DISABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T3_TRGO;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 1;
hadc1.Init.NbrOfConversion = 2;
if (HAL_ADC_Init(&hadc1) != HAL_OK)
{
Error_Handler();
@@ -57,9 +58,18 @@ void MX_ADC1_Init(void)
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Channel = ADC_CHANNEL_VREFINT;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
sConfig.Rank = ADC_REGULAR_RANK_2;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
@@ -133,6 +143,23 @@ void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle)
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* ADC1 DMA Init */
/* ADC1 Init */
hdma_adc1.Instance = DMA1_Channel1;
hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
hdma_adc1.Init.Mode = DMA_CIRCULAR;
hdma_adc1.Init.Priority = DMA_PRIORITY_LOW;
if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)
{
Error_Handler();
}
__HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc1);
/* USER CODE BEGIN ADC1_MspInit 1 */
/* USER CODE END ADC1_MspInit 1 */
@@ -147,11 +174,12 @@ void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle)
__HAL_RCC_GPIOA_CLK_ENABLE();
/**ADC2 GPIO Configuration
PA0-WKUP ------> ADC2_IN0
PA1 ------> ADC2_IN1
*/
GPIO_InitStruct.Pin = AIN2_Pin;
GPIO_InitStruct.Pin = AIN1_Pin|AIN2_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
HAL_GPIO_Init(AIN2_GPIO_Port, &GPIO_InitStruct);
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* USER CODE BEGIN ADC2_MspInit 1 */
@@ -176,6 +204,8 @@ void HAL_ADC_MspDeInit(ADC_HandleTypeDef* adcHandle)
*/
HAL_GPIO_DeInit(GPIOA, AIN1_Pin|AIN2_Pin);
/* ADC1 DMA DeInit */
HAL_DMA_DeInit(adcHandle->DMA_Handle);
/* USER CODE BEGIN ADC1_MspDeInit 1 */
/* USER CODE END ADC1_MspDeInit 1 */
@@ -189,9 +219,10 @@ void HAL_ADC_MspDeInit(ADC_HandleTypeDef* adcHandle)
__HAL_RCC_ADC2_CLK_DISABLE();
/**ADC2 GPIO Configuration
PA0-WKUP ------> ADC2_IN0
PA1 ------> ADC2_IN1
*/
HAL_GPIO_DeInit(AIN2_GPIO_Port, AIN2_Pin);
HAL_GPIO_DeInit(GPIOA, AIN1_Pin|AIN2_Pin);
/* USER CODE BEGIN ADC2_MspDeInit 1 */
Fertirrega_v6/Core/Src/ads1015_driver.c
+20 -8
View File
@@ -8,9 +8,9 @@
*/
#include "ads1015_driver.h"
#include "main.h" // Assuming HAL is included via main.h
float temp_calib, ph_compensated, v_ph4=0, v_ph7=0;
ADS1015_I2C i2c;
float ph_dut_samples[ADS1015_PH_AVERAGES]={0};
// Write the register
static void writeRegister(ADS1015_I2C *i2c, uint8_t reg, uint16_t value) {
@@ -271,10 +271,22 @@ int16_t ADSgetLastConversionResults(ADS1015_I2C *i2c) {
}
}
float ADSCalculate_ph_Volts(int16_t adc_raw)
float ADSCalculate_ph_Volts(void)
{
// 1. Converter leitura bruta do ADC para tensão real (Volts)
return ((float)adc_raw * ADS1015_ADC_VREF) / ADS1015_ADC_MAX;
float ph_dut_sum;
uint8_t i;
for (i = (ADS1015_PH_AVERAGES-1); i > 0; i--)
ph_dut_samples[i] = ph_dut_samples[i-1];
ph_dut_samples[0] = (((float)(2048 - ADSreadADC_Differential_0_1(&i2c)) * ADS1015_ADC_VREF) / ADS1015_ADC_MAX); // 1. Converter leitura bruta do ADC para tensão real (Volts)
for (i = 0, ph_dut_sum=0; i < ADS1015_PH_AVERAGES; i++)
ph_dut_sum += ph_dut_samples[i];
ph_dut_sum /= ADS1015_PH_AVERAGES;
return (ph_dut_sum);
}
@@ -295,7 +307,7 @@ float ADSCalculate_ph_Compensated(int16_t adc_raw, float temp_dut)
// 2. Calcular o Slope original (medido na temperatura da calibração)
// Delta pH é fixo em 3.0 (de pH 7 para pH 4)
float delta_v_calib = v_ph7 - v_ph4;
float delta_v_calib = flash_data.ph7_value - flash_data.ph4_value;
if (delta_v_calib == 0.0f)
{
@@ -306,7 +318,7 @@ float ADSCalculate_ph_Compensated(int16_t adc_raw, float temp_dut)
// 3. Calcular o Fator de Correção Térmica (Equação de Nernst)
float temp_k_now = temp_dut + ADS1015_KELVIN_OFFSET;
float temp_k_ref = temp_calib + ADS1015_KELVIN_OFFSET;
float temp_k_ref = flash_data.temperature_value + ADS1015_KELVIN_OFFSET;
// Fator: (T_atual / T_referencia)
float thermal_factor = temp_k_now / temp_k_ref;
@@ -316,7 +328,7 @@ float ADSCalculate_ph_Compensated(int16_t adc_raw, float temp_dut)
* O Slope ajustado para a temperatura atual é: slope_at_calib / thermal_factor
* Fórmula: pH = pH_ref + (V_medido - V_ref_7) * Slope_ajustado
*/
float ph_result = 7.0f + ((v_measured - v_ph7) * (slope_at_calib / thermal_factor));
float ph_result = 7.0f + ((v_measured - flash_data.ph7_value) * (slope_at_calib / thermal_factor));
// 5. Clamping (Garantir limites físicos)
if (ph_result < 0.0f) ph_result = 0.0f;
Fertirrega_v6/Core/Src/dma.c
+55
View File
@@ -0,0 +1,55 @@
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file dma.c
* @brief This file provides code for the configuration
* of all the requested memory to memory DMA transfers.
******************************************************************************
* @attention
*
* Copyright (c) 2026 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "dma.h"
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
/*----------------------------------------------------------------------------*/
/* Configure DMA */
/*----------------------------------------------------------------------------*/
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/**
* Enable DMA controller clock
*/
void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__HAL_RCC_DMA1_CLK_ENABLE();
/* DMA interrupt init */
/* DMA1_Channel1_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
}
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
Fertirrega_v6/Core/Src/flash_manager.c
+3
View File
@@ -9,6 +9,9 @@
* @param pPage Ponteiro para a estrutura de 1KB na RAM.
* @return HAL_OK em caso de sucesso.
*/
FlashPage_t flash_data;
HAL_StatusTypeDef Flash_Save_Page(FlashPage_t *pPage) {
if (pPage == NULL) return HAL_ERROR;
Fertirrega_v6/Core/Src/gpio.c
+1 -2
View File
@@ -28,7 +28,6 @@
/* USER CODE END 0 */
/*----------------------------------------------------------------------------*/
/* Configure GPIO */
/*----------------------------------------------------------------------------*/
@@ -133,7 +132,7 @@ void MX_GPIO_Init(void)
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if (GPIO_Pin == Calib_PH_Pin)
if ((GPIO_Pin == Calib_PH_Pin) && (main_state == STATE_RUNNING_OK))
{
uint32_t current_time = HAL_GetTick();
GPIO_PinState pin_state = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_3);
Fertirrega_v6/Core/Src/main.c
+168 -68
View File
@@ -19,7 +19,9 @@
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "adc.h"
#include "dma.h"
#include "i2c.h"
#include "tim.h"
#include "usart.h"
#include "gpio.h"
@@ -29,6 +31,8 @@
#include "digital_outputs_driver.h"
#include "ad5934_driver.h"
#include "rs485_driver.h"
#include "flash_manager.h"
#include <string.h>
/* USER CODE END Includes */
@@ -40,8 +44,10 @@
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define AVG_SLOPE (4.3F)
#define V_AT_25C (1.43F)
#define V_REF_INT (1.2F)
#define STM32_TEMPERATURE_AVERAGES 4
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
@@ -62,20 +68,25 @@ uint8_t imag_text[6];
uint8_t rs485_text[6];
uint8_t newline[]={'\r','\n'};
uint8_t newline[]={'\n','\0'};
uint8_t doubleSpace[]={'_','_'};
uint8_t newline_ph[]={'_','p','H','\r','\n'};
uint8_t newline_admi[]={'_','m','S','\r','\n'};
uint8_t newline_real[]={'_','°','C','\r','\n'};
uint8_t newline_imag[]={'_','O','h','m','\r','\n'};
uint8_t newline_485[]={'_','a','d','\r','\n'};
uint8_t newline_ph[]={'_','p','H','\n','\0'};
uint8_t newline_admi[]={'_','u','S','\n','\0'};
uint8_t newline_temp[]={' ','°','C','\n','\0'};
uint8_t newline_real[]={'_','°','C','\n','\0'};
uint8_t newline_imag[]={'_','O','h','m','\n','\0'};
uint8_t newline_485[]={'_','a','d','\n','\0'};
uint8_t minus[]={'-',' '};
uint8_t main_state = STATE_RUNNING_OK;
uint8_t rs485_address=0;
ADS1015_I2C i2c;
uint16_t AD_RES[2];
uint8_t UpdateEvent = 0;
float Temperature, Temp_Sum, V_Sense, V_Ref;
float Temp_Samples[STM32_TEMPERATURE_AVERAGES]={0};
/* USER CODE END PV */
@@ -113,11 +124,15 @@ int main(void)
uint32_t previous_millis_red = 0;
uint32_t current_millis;
float temperature_RTD, admittance_EC;
float temperature_RTD, admittance_EC, ph_compensated;
/*! Temporary variables */
char tempString[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
long double tempValue = 0;
uint8_t tempString[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t i;
/* USER CODE END 1 */
@@ -139,13 +154,24 @@ int main(void)
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_ADC1_Init();
MX_ADC2_Init();
MX_I2C1_Init();
MX_I2C2_Init();
MX_USART1_UART_Init();
MX_TIM3_Init();
/* USER CODE BEGIN 2 */
Flash_Load_Page(&flash_data);
//TempSensor_Init(&hadc1);
HAL_TIM_Base_Start(&htim3);
HAL_ADCEx_Calibration_Start(&hadc1);
HAL_ADC_Start_DMA(&hadc1, (uint32_t*)AD_RES, 2); // Start ADC Conversion
digital_outputs_init();
// Initialize RS-485 driver
@@ -158,20 +184,59 @@ int main(void)
AD5934_Init();
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_3) == GPIO_PIN_RESET)
{
main_state = STATE_SETUP_CALIBRATION;
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, GPIO_PIN_RESET); // Red LED On
for(i=0;i<32;i++)
{
flash_data.temperature_value = temperature_RTD;
flash_data.ph4_value = ADSCalculate_ph_Volts();
flash_data.ec1413_value = AD5934_GetImpedance();
}
while(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_3) == GPIO_PIN_RESET);
HAL_Delay(500);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_RESET); // Green LED On
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, GPIO_PIN_SET);
for(i=0;i<32;i++)
{
flash_data.ph7_value = ADSCalculate_ph_Volts();
flash_data.ec12880_value = AD5934_GetImpedance();
Flash_Save_Page(&flash_data);
}
HAL_Delay(500);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_RESET); // Green LED On
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, GPIO_PIN_RESET); // Red LED On
main_state = STATE_RUNNING_OK;
}
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
current_millis = HAL_GetTick();
// Piscar LED verde em PB5 a cada 0,5 segundos
if ((current_millis - previous_millis_green) >= 800)
if ((current_millis - previous_millis_green) >= 500)
{
previous_millis_green = current_millis;
@@ -186,6 +251,10 @@ int main(void)
}*/
FloatToString(tempString, Temperature);
status0 = rs485_send_broadcast(tempString, (strlen((char*)tempString)-1));
status1 = rs485_send_broadcast(newline_temp, strlen((char*)newline_temp));
temperature_RTD = AD5934_GetTemperature();
FloatToString(tempString, temperature_RTD);
@@ -193,24 +262,8 @@ int main(void)
status1 = rs485_send_broadcast(newline_real, strlen((char*)newline_real));
if(edge_state == FALLING_EDGE)
{
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, GPIO_PIN_RESET);
temp_calib = temperature_RTD;
v_ph4 = ADSCalculate_ph_Volts(2048 - ADSreadADC_Differential_0_1(&i2c));
edge_state = NO_EDGE;
HAL_Delay(500);
}else if(edge_state == RISING_EDGE)
{
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, GPIO_PIN_SET);
v_ph7 = ADSCalculate_ph_Volts(2048 - ADSreadADC_Differential_0_1(&i2c));
edge_state = NO_EDGE;
HAL_Delay(500);
}
ph_compensated = ADSCalculate_ph_Compensated((2048 - ADSreadADC_Differential_0_1(&i2c)),temp_calib);
ph_compensated = ADSCalculate_ph_Compensated((2048 - ADSreadADC_Differential_0_1(&i2c)),flash_data.temperature_value);
FloatToString(tempString, ph_compensated);
status0 = rs485_send_broadcast(tempString, (strlen((char*)tempString)-1));
status1 = rs485_send_broadcast(newline_ph, strlen((char*)newline_ph));
@@ -222,6 +275,28 @@ int main(void)
status1 = rs485_send_broadcast(newline_admi, strlen((char*)newline_admi));
}
else if(UpdateEvent)
{
for (i = (STM32_TEMPERATURE_AVERAGES-1); i > 0; i--)
Temp_Samples[i] = Temp_Samples[i-1];
// Read real and imaginary data
if(AD_RES[0]>0.0f)
V_Ref = (float)((V_REF_INT * 4095.0)/AD_RES[0]);
else
V_Ref = 0.0f;
V_Sense = (float)(AD_RES[1] * V_Ref) / 4095.0;
Temp_Samples[0] = (((V_AT_25C - V_Sense) * 1000.0) /AVG_SLOPE) + 25.0;
for (i = 0, Temp_Sum=0; i < STM32_TEMPERATURE_AVERAGES; i++)
Temp_Sum += Temp_Samples[i];
Temperature = Temp_Sum/((float)STM32_TEMPERATURE_AVERAGES);
UpdateEvent = 0;
}
@@ -333,11 +408,7 @@ void SystemClock_Config(void)
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL2;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
@@ -347,10 +418,10 @@ void SystemClock_Config(void)
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
{
@@ -377,43 +448,68 @@ void SystemClock_Config(void)
*
* @return None.
*******************************************************************************/
void FloatToString(char * buf, double val)
void FloatToString(char *buf, double val)
{
long intPart = 0;
short fracPart = 0;
short charPos = 0;
char localBuf[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
short i = sizeof(localBuf) - 1;
char temp[20]; // Buffer auxiliar para construção segura
int i = 0;
intPart = (long)val;
fracPart = (short)((val - intPart) * 1000 + 0.5);
while(i > sizeof(localBuf) - 4)
{
localBuf[i] = (fracPart % 10) + 0x30;
fracPart /= 10;
i--;
// 1. Tratar sinal negativo
if (val < 0) {
temp[i++] = '-';
val = -val;
}
localBuf[i] = '.';
if(intPart == 0)
{
i --;
localBuf[i] = '0';
// 2. Separar parte inteira e fracionária
long intPart = (long)val;
// Multiplicamos por 1000 para obter 3 casas decimais fixas
int fracPart = (int)((val - (double)intPart) * 1000.0 + 0.5);
// 3. Converter a parte inteira para o buffer temp
// Usamos um buffer temporário de inversão para não precisar de lógica complexa de ponteiro
char intRev[12];
int j = 0;
if (intPart == 0) {
intRev[j++] = '0';
} else {
while (intPart > 0) {
intRev[j++] = (intPart % 10) + '0';
intPart /= 10;
}
}
while(intPart)
{
i --;
localBuf[i] =(intPart % 10) + 0x30;
intPart /= 10;
// Inverter a parte inteira de volta para o buffer principal
for (int k = j - 1; k >= 0; k--) {
temp[i++] = intRev[k];
}
for(charPos = i; charPos < sizeof(localBuf); charPos ++)
{
*buf = localBuf[charPos];
buf ++;
// 4. Adicionar o ponto decimal e a parte fracionária (sempre 3 casas)
temp[i++] = '.';
// Garantir que a parte fracionária tenha sempre 3 dígitos (ex: .005 em vez de .5)
int fracBuffer[3];
fracBuffer[2] = fracPart % 10; // Unidade
fracBuffer[1] = (fracPart / 10) % 10; // Dezena
fracBuffer[0] = (fracPart / 100) % 10; // Centena
for (int k = 2; k >= 0; k--) {
temp[i++] = fracBuffer[k] + '0';
}
*buf = 0;
// 5. Finalizar a string com o caractere nulo
temp[i] = '\0';
// 6. Copiar para o buffer de destino final (sem risco de lixo)
int destIdx = 0;
while (temp[destIdx] != '\0' && destIdx < 15) { // Limite de segurança
buf[destIdx] = temp[destIdx];
destIdx++;
}
buf[destIdx] = '\0';
}
void intToStr(int N, char *str) {
int i = 0;
@@ -452,6 +548,10 @@ void intToStr(int N, char *str) {
}
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
UpdateEvent = 1;
}
/* USER CODE END 4 */
Fertirrega_v6/Core/Src/stm32f1xx_it.c
+15
View File
@@ -55,6 +55,7 @@
/* USER CODE END 0 */
/* External variables --------------------------------------------------------*/
extern DMA_HandleTypeDef hdma_adc1;
extern UART_HandleTypeDef huart1;
/* USER CODE BEGIN EV */
@@ -212,6 +213,20 @@ void EXTI3_IRQHandler(void)
/* USER CODE END EXTI3_IRQn 1 */
}
/**
* @brief This function handles DMA1 channel1 global interrupt.
*/
void DMA1_Channel1_IRQHandler(void)
{
/* USER CODE BEGIN DMA1_Channel1_IRQn 0 */
/* USER CODE END DMA1_Channel1_IRQn 0 */
HAL_DMA_IRQHandler(&hdma_adc1);
/* USER CODE BEGIN DMA1_Channel1_IRQn 1 */
/* USER CODE END DMA1_Channel1_IRQn 1 */
}
/**
* @brief This function handles USART1 global interrupt.
*/
Fertirrega_v6/Core/Src/tim.c
+105
View File
@@ -0,0 +1,105 @@
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file tim.c
* @brief This file provides code for the configuration
* of the TIM instances.
******************************************************************************
* @attention
*
* Copyright (c) 2026 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "tim.h"
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
TIM_HandleTypeDef htim3;
/* TIM3 init function */
void MX_TIM3_Init(void)
{
/* USER CODE BEGIN TIM3_Init 0 */
/* USER CODE END TIM3_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
/* USER CODE BEGIN TIM3_Init 1 */
/* USER CODE END TIM3_Init 1 */
htim3.Instance = TIM3;
htim3.Init.Prescaler = 3;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 59999;
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM3_Init 2 */
/* USER CODE END TIM3_Init 2 */
}
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
{
if(tim_baseHandle->Instance==TIM3)
{
/* USER CODE BEGIN TIM3_MspInit 0 */
/* USER CODE END TIM3_MspInit 0 */
/* TIM3 clock enable */
__HAL_RCC_TIM3_CLK_ENABLE();
/* USER CODE BEGIN TIM3_MspInit 1 */
/* USER CODE END TIM3_MspInit 1 */
}
}
void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
{
if(tim_baseHandle->Instance==TIM3)
{
/* USER CODE BEGIN TIM3_MspDeInit 0 */
/* USER CODE END TIM3_MspDeInit 0 */
/* Peripheral clock disable */
__HAL_RCC_TIM3_CLK_DISABLE();
/* USER CODE BEGIN TIM3_MspDeInit 1 */
/* USER CODE END TIM3_MspDeInit 1 */
}
}
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */