ChTheo/RFG_stm32_ADC_STM32F429
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

implemented sync_detector logic. But it is a bit buggy: data stored in avg_ON is very similar to avg_OFF. But while sync_detector phase is inverted -- both behave the same way

Browse Source
This commit is contained in:
Theodor Chikin
2025-12-19 23:20:55 +03:00
parent eb6cb9b762
commit 186ad1939a
19 changed files with 5244 additions and 4772 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
Core/Src/main.c
View File

@ -66,11 +66,20 @@ volatile uint32_t curr_step_start_N = 0;
/* ADC1 circular DMA buffer definition */
uint16_t ADC1_buff_circular[ADC_BUFF_SIZE];
//char ADC_msg[] = "curr_step ?????? ??????????\r\nSweep_start\n\r";
char ADC_msg[] = "stp ?????? ??????????\r\nSweep_start\n\r";
#define ADC_msg_len 24
#define ADC_msg_len_Sweep_start 37
#define ADC_msg_val_pos 12
//char ADC_msg[] = "stp ?????? ?????????? ??????????\r\nSweep_start\n\r";
//#define ADC_msg_len 35
//#define ADC_msg_len_Sweep_start 48
#define ADC_msg_val_ON_pos 12
#define ADC_msg_val_OFF_pos 23
#define ADC_msg_step_pos 4
/* USER CODE END 0 */
@ -112,13 +121,17 @@ int main(void)
ADC_proc_shadow.status = 0; // ADC started
ADC_proc_shadow.N = 0;
ADC_proc_shadow.sum = 0;
ADC_proc_shadow.avg = 0;
ADC_proc_shadow.sum_ON = 0;
ADC_proc_shadow.avg_ON = 0;
ADC_proc_shadow.sum_OFF = 0;
ADC_proc_shadow.avg_OFF = 0;
ADC_proc.status = 0; // ADC started
ADC_proc.N = 0;
ADC_proc.sum = 0;
ADC_proc.avg = 0;
ADC_proc.sum_ON = 0;
ADC_proc.avg_ON = 0;
ADC_proc.sum_OFF = 0;
ADC_proc.avg_OFF = 0;
uint32_t curr_points_N_max = 100;
uint32_t curr_points_N =0;
@ -133,22 +146,39 @@ int main(void)
//HAL_Delay(100);
if (ADC_proc_shadow.status == 2) {
ADC_proc_shadow.avg = ADC_proc_shadow.sum / ADC_proc_shadow.N;
// ADC_proc_shadow.avg_ON = ADC_proc_shadow.sum_ON / ADC_proc_shadow.N;
ADC_proc_shadow.avg_OFF = ADC_proc_shadow.sum_OFF / ADC_proc_shadow.N;
ADC_proc_shadow.avg_ON = ADC_proc_shadow.sum_ON / ADC_proc_shadow.N;
ADC_proc_shadow.avg_ON = ADC_proc_shadow.avg_OFF;
// ADC_proc_shadow.avg_ON = ADC_proc_shadow.avg_ON - ADC_proc_shadow.avg_OFF;
ADC_proc_shadow.status = 1; // reset for next accumulation
ADC_proc_shadow.sum = 0;
ADC_proc_shadow.N = 0;
ADC_msg[ADC_msg_val_ON_pos + 0] = (ADC_proc_shadow.avg_ON / 1000000000) % 10 + '0';
ADC_msg[ADC_msg_val_ON_pos + 1] = (ADC_proc_shadow.avg_ON / 100000000) % 10 + '0';
ADC_msg[ADC_msg_val_ON_pos + 2] = (ADC_proc_shadow.avg_ON / 10000000) % 10 + '0';
ADC_msg[ADC_msg_val_ON_pos + 3] = (ADC_proc_shadow.avg_ON / 1000000) % 10 + '0';
ADC_msg[ADC_msg_val_ON_pos + 4] = (ADC_proc_shadow.avg_ON / 100000) % 10 + '0';
ADC_msg[ADC_msg_val_ON_pos + 5] = (ADC_proc_shadow.avg_ON / 10000) % 10 + '0';
ADC_msg[ADC_msg_val_ON_pos + 6] = (ADC_proc_shadow.avg_ON / 1000) % 10 + '0';
ADC_msg[ADC_msg_val_ON_pos + 7] = (ADC_proc_shadow.avg_ON / 100) % 10 + '0';
ADC_msg[ADC_msg_val_ON_pos + 8] = (ADC_proc_shadow.avg_ON / 10) % 10 + '0';
ADC_msg[ADC_msg_val_ON_pos + 9] = (ADC_proc_shadow.avg_ON / 1) % 10 + '0';
ADC_msg[ADC_msg_val_pos + 0] = (ADC_proc_shadow.avg / 10000000000) % 10 + '0';
ADC_msg[ADC_msg_val_pos + 1] = (ADC_proc_shadow.avg / 1000000000) % 10 + '0';
ADC_msg[ADC_msg_val_pos + 2] = (ADC_proc_shadow.avg / 10000000) % 10 + '0';
ADC_msg[ADC_msg_val_pos + 3] = (ADC_proc_shadow.avg / 1000000) % 10 + '0';
ADC_msg[ADC_msg_val_pos + 4] = (ADC_proc_shadow.avg / 100000) % 10 + '0';
ADC_msg[ADC_msg_val_pos + 5] = (ADC_proc_shadow.avg / 10000) % 10 + '0';
ADC_msg[ADC_msg_val_pos + 6] = (ADC_proc_shadow.avg / 1000) % 10 + '0';
ADC_msg[ADC_msg_val_pos + 7] = (ADC_proc_shadow.avg / 100) % 10 + '0';
ADC_msg[ADC_msg_val_pos + 8] = (ADC_proc_shadow.avg / 10) % 10 + '0';
ADC_msg[ADC_msg_val_pos + 9] = (ADC_proc_shadow.avg / 1) % 10 + '0';
/*
ADC_msg[ADC_msg_val_OFF_pos + 0] = (ADC_proc_shadow.avg_OFF / 1000000000) % 10 + '0';
ADC_msg[ADC_msg_val_OFF_pos + 1] = (ADC_proc_shadow.avg_OFF / 100000000) % 10 + '0';
ADC_msg[ADC_msg_val_OFF_pos + 2] = (ADC_proc_shadow.avg_OFF / 10000000) % 10 + '0';
ADC_msg[ADC_msg_val_OFF_pos + 3] = (ADC_proc_shadow.avg_OFF / 1000000) % 10 + '0';
ADC_msg[ADC_msg_val_OFF_pos + 4] = (ADC_proc_shadow.avg_OFF / 100000) % 10 + '0';
ADC_msg[ADC_msg_val_OFF_pos + 5] = (ADC_proc_shadow.avg_OFF / 10000) % 10 + '0';
ADC_msg[ADC_msg_val_OFF_pos + 6] = (ADC_proc_shadow.avg_OFF / 1000) % 10 + '0';
ADC_msg[ADC_msg_val_OFF_pos + 7] = (ADC_proc_shadow.avg_OFF / 100) % 10 + '0';
ADC_msg[ADC_msg_val_OFF_pos + 8] = (ADC_proc_shadow.avg_OFF / 10) % 10 + '0';
ADC_msg[ADC_msg_val_OFF_pos + 9] = (ADC_proc_shadow.avg_OFF / 1) % 10 + '0';
*/
ADC_msg[ADC_msg_step_pos + 0] = (Sweep_state.curr_step_N / 100000) % 10 + '0';
ADC_msg[ADC_msg_step_pos + 1] = (Sweep_state.curr_step_N / 10000) % 10 + '0';

143
Core/Src/stm32f4xx_it.c
View File

@ -264,6 +264,148 @@ void OTG_FS_IRQHandler(void)
/* USER CODE BEGIN 1 */
#ifdef SYNC_DET_ON
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
HAL_GPIO_WritePin(LED_BLUE_GPIO_Port, LED_BLUE_Pin, GPIO_PIN_SET);
if (Sweep_state.curr_step_started_flag == 2) {
Sweep_state.curr_step_started_flag = 0; // reset flag after processing second half
for (uint32_t i = ADC_BUFF_SIZE/2; i < Sweep_state.curr_step_start_DMA_N; i++) {
if ((i & 1) != 0){
ADC_proc.sum_ON += ADC1_buff_circular[i];
}else{
ADC_proc.sum_OFF += ADC1_buff_circular[i];
}
}
ADC_proc.N += (Sweep_state.curr_step_start_DMA_N - ADC_BUFF_SIZE/2)/2;
ADC_proc_shadow.sum_ON = ADC_proc.sum_ON;
ADC_proc_shadow.sum_OFF = ADC_proc.sum_OFF;
ADC_proc_shadow.avg_ON = ADC_proc.avg_ON;
ADC_proc_shadow.avg_OFF = ADC_proc.avg_OFF;
ADC_proc_shadow.N = ADC_proc.N;
ADC_proc_shadow.status = 2; // buffer filled
ADC_proc.sum = 0;
ADC_proc.sum_ON = 0;
ADC_proc.sum_OFF = 0;
ADC_proc.N = 0;
ADC_proc.avg_ON = 0;
ADC_proc.avg_OFF = 0;
ADC_proc.status = 1; // collecting data
for (uint32_t i = Sweep_state.curr_step_start_DMA_N; i < ADC_BUFF_SIZE; i++) {
if ((i & 1) != 0){
ADC_proc.sum_ON += ADC1_buff_circular[i];
}else{
ADC_proc.sum_OFF += ADC1_buff_circular[i];
}
}
ADC_proc.N = (ADC_BUFF_SIZE - Sweep_state.curr_step_start_DMA_N)/2;
}else{
for (uint32_t i = ADC_BUFF_SIZE/2; i < ADC_BUFF_SIZE; i++) {
if ((i & 1) != 0){
ADC_proc.sum_ON += ADC1_buff_circular[i];
}else{
ADC_proc.sum_OFF += ADC1_buff_circular[i];
}
}
ADC_proc.N += (ADC_BUFF_SIZE - ADC_BUFF_SIZE/2)/2;
}
//if (0){
if (ADC_proc.N >= ADC_BUFF_SIZE*100){
ADC_proc_shadow.sum_OFF = ADC_proc.sum_OFF;
ADC_proc_shadow.sum_ON = ADC_proc.sum_ON;
ADC_proc_shadow.avg_ON = ADC_proc.avg_ON;
ADC_proc_shadow.avg_OFF = ADC_proc.avg_OFF;
ADC_proc_shadow.N = ADC_proc.N;
ADC_proc_shadow.status = 2; // buffer filled
ADC_proc.sum_OFF = 0;
ADC_proc.sum_ON = 0;
ADC_proc.N = 0;
ADC_proc.avg_ON = 0;
ADC_proc.avg_OFF = 0;
ADC_proc.status = 1; // collecting data
}
// This function is called when the first half of the ADC buffer is filled
// You can process the first half of ADC1_buff_circular here
}
void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef* hadc)
{
//HAL_GPIO_WritePin(LED_BLUE_GPIO_Port, LED_BLUE_Pin, GPIO_PIN_RESET);
HAL_GPIO_TogglePin(LED_BLUE_GPIO_Port, LED_BLUE_Pin);
if (Sweep_state.curr_step_started_flag == 1) {
Sweep_state.curr_step_started_flag = 0;
for (uint32_t i = 0; i < Sweep_state.curr_step_start_DMA_N; i++) {
if ((i & 1) != 0){
ADC_proc.sum_ON += ADC1_buff_circular[i];
}else{
ADC_proc.sum_OFF += ADC1_buff_circular[i];
}
}
ADC_proc.N += (Sweep_state.curr_step_start_DMA_N)/2;
ADC_proc_shadow.sum_ON = ADC_proc.sum_ON;
ADC_proc_shadow.avg_ON = ADC_proc.avg_ON;
ADC_proc_shadow.sum_OFF = ADC_proc.sum_OFF;
ADC_proc_shadow.avg_OFF = ADC_proc.avg_OFF;
ADC_proc_shadow.N = ADC_proc.N;
ADC_proc_shadow.status = 2; // buffer filled
ADC_proc.sum_ON = 0;
ADC_proc.sum_OFF = 0;
ADC_proc.sum = 0;
ADC_proc.N = 0;
ADC_proc.avg_OFF = 0;
ADC_proc.avg_ON = 0;
ADC_proc.status = 1; // collecting data
for (uint32_t i = Sweep_state.curr_step_start_DMA_N; i < ADC_BUFF_SIZE/2; i++) {
if ((i & 1) != 0){
ADC_proc.sum_ON += ADC1_buff_circular[i];
}else{
ADC_proc.sum_OFF += ADC1_buff_circular[i];
}
}
ADC_proc.N = (Sweep_state.curr_step_start_DMA_N)/2;
}else{
for (uint32_t i = 0; i < ADC_BUFF_SIZE/2; i++) {
if ((i & 1) != 0){
ADC_proc.sum_ON += ADC1_buff_circular[i];
}else{
ADC_proc.sum_OFF += ADC1_buff_circular[i];
}
}
ADC_proc.N += (ADC_BUFF_SIZE/2)/2;
}
// This function is called when the first half of the ADC buffer is filled
// You can process the first half of ADC1_buff_circular here
}
#else
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
HAL_GPIO_WritePin(LED_BLUE_GPIO_Port, LED_BLUE_Pin, GPIO_PIN_SET);
@ -357,6 +499,7 @@ void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef* hadc)
// This function is called when the first half of the ADC buffer is filled
// You can process the first half of ADC1_buff_circular here
}
#endif
/*
void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef* hadc)