Embedded_RD/WTZSSoftWare
15
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
fb2ca87ca2
WTZSSoftWare/Src/main.c

1943 lines
65 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2024 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 "main.h"
#include "cmsis_os.h"
#include "usb_device.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
// #include "arm_math.h"
#include "stm32h7xx_hal_pwr.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
#include "stdio.h"
#include <stdint.h>
#include <string.h>
#define ITM_PORT8(n) (*(volatile unsigned char *)(0xe0000000 + 4 * (n)))
#define ITM_PORT16(n) (*(volatile unsigned short *)(0xe0000000 + 4 * (n)))
#define ITM_PORT32(n) (*(volatile unsigned long *)(0xe0000000 + 4 * (n)))
#define DEMCR (*(volatile unsigned long *)(0xE000EDFC))
#define TRCENA 0X01000000
int fputc(int ch, FILE *f)
{
if (DEMCR & TRCENA)
{
while (ITM_PORT32(0) == 0)
;
ITM_PORT8(0) = ch;
}
return ch;
}
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc3;
DMA_HandleTypeDef hdma_adc3;
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim4;
UART_HandleTypeDef huart1;
DMA_HandleTypeDef hdma_usart1_rx;
DMA_HandleTypeDef hdma_memtomem_dma2_stream0;
/* Definitions for defaultTask */
osThreadId_t defaultTaskHandle;
/* USER CODE BEGIN PV */
const osThreadAttr_t defaultTask_attributes = {
.name = "defaultTask",
.stack_size = 4096,
.priority = (osPriority_t)osPriorityNormal,
};
const osThreadAttr_t CommunicationResponeTask_attributes = {
.name = "CommunicationResponeTask",
.stack_size = 4096,
.priority = (osPriority_t)osPriorityNormal,
};
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_BDMA_Init(void);
static void MX_DMA_Init(void);
static void MX_ADC3_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_TIM2_Init(void);
static void MX_TIM1_Init(void);
static void MX_TIM4_Init(void);
void StartDefaultTask(void *argument);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
//_Bool ADC1Finish = 1;
//_Bool ADC2Finish = 1;
_Bool ADC3Finish = 1;
// uint32_t ADC3DataBuf[1024 * 10 / 2] __attribute__((section(".ADC3DataBufAddr")));
// uint32_t ADC3DataBufTrans[4096 * 10 / 2] __attribute__((section(".ADC3DataBufTransAddr")));
#define ADC3DataBuf ((uint32_t *)(D3_SRAM_BASE + 0x1000))
#define ADC3DataBufTrans ((uint32_t *)(D1_AXISRAM_BASE + 0x50000))
void ExitRun0Mode(void) {}
_Bool StartFlag = 0;
static uint8_t HFk = 0;
static uint8_t CPk = 0;
void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef *hadc)
{
__HAL_DMA_CLEAR_FLAG(hadc3.DMA_Handle, BDMA_FLAG_HT0);
if (StartFlag)
{
if (hadc->Instance == ADC3)
{
if (HFk < 4)
{
if (HAL_DMA_Init(&hdma_memtomem_dma2_stream0) != HAL_OK)
{
Error_Handler();
}
HAL_DMA_Start(&hdma_memtomem_dma2_stream0, (uint32_t)(ADC3DataBuf),
(uint32_t)(ADC3DataBufTrans + 1024 * 10 * 2 * HFk / 4), 1024 * 10);
while (__HAL_DMA_GET_FLAG(&hdma_memtomem_dma2_stream0, DMA_FLAG_HTIF0_4) == RESET)
;
__HAL_DMA_CLEAR_FLAG(&hdma_memtomem_dma2_stream0, DMA_FLAG_HTIF0_4);
__HAL_DMA_CLEAR_FLAG(&hdma_memtomem_dma2_stream0, DMA_FLAG_TCIF0_4);
HFk++;
}
else
{
HFk = 4;
}
}
}
else
{
HFk = 0;
}
}
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
{
__HAL_DMA_CLEAR_FLAG(hadc3.DMA_Handle, BDMA_FLAG_TC0);
if (StartFlag)
{
if (hadc->Instance == ADC3)
{
if (CPk < 4)
{
if (HFk <= CPk)
return;
if (HAL_DMA_Init(&hdma_memtomem_dma2_stream0) != HAL_OK)
{
Error_Handler();
}
HAL_DMA_Start(&hdma_memtomem_dma2_stream0, (uint32_t)(ADC3DataBuf + 1024 * 10 / 4),
(uint32_t)(ADC3DataBufTrans + 1024 * 10 / 4 + 1024 * 10 * 2 * CPk / 4), 1024 * 10);
while (__HAL_DMA_GET_FLAG(&hdma_memtomem_dma2_stream0, DMA_FLAG_TCIF0_4) == RESET)
;
__HAL_DMA_CLEAR_FLAG(&hdma_memtomem_dma2_stream0, DMA_FLAG_HTIF0_4);
__HAL_DMA_CLEAR_FLAG(&hdma_memtomem_dma2_stream0, DMA_FLAG_TCIF0_4);
CPk++;
if (CPk == 4)
{
ADC3Finish = 1;
StartFlag = 0;
}
}
else
{
CPk = 4;
ADC3Finish = 1;
StartFlag = 0;
}
}
}
else
{
CPk = 0;
}
}
/* FFT相关参数，默认使用4096点FFT
* 可选范围为: 16, 64, 256, 1024, 4096
*/
#define FFT_LENGTH 4096
uint16_t fft_inputbuf[FFT_LENGTH]; /* FFT输入缓冲区 */
uint8_t Uart_ReadCache[128];
_Bool ReadFlag = 0;
uint8_t gain = 0;
void CommunicationResponse(void *P_grg);
osSemaphoreId_t Command_Semaphore;
osSemaphoreId_t CommandResponse_Semaphore;
extern uint8_t Command_Write(uint8_t *data, uint16_t length);
extern uint8_t Command_GetCommand(uint8_t *command);
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
UNUSED(huart);
//HAL_GPIO_WritePin(GPIOI, GPIO_PIN_7, GPIO_PIN_RESET);
//osDelay(10);
//HAL_GPIO_WritePin(GPIOI, GPIO_PIN_7, GPIO_PIN_SET);
// HAL_UART_DMAStop(huart); // 停止DMA接收
if (Command_Write(Uart_ReadCache, Size) >= 4)
{
// 如果写入成功，释放信号量，允许其他线程获取
osSemaphoreRelease(Command_Semaphore);
}
// 处理接收到的数据
// HAL_UARTEx_ReceiveToIdle_DMA(huart, Uart_ReadCache, 128); // 重新启动DMA接收
}
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */
/*************************************************************************************** */
/*************************************************************************************** */
/*************************************************************************************** */
/*************************************************************************************** */
/*************************************************************************************** */
/*************************************************************************************** */
/*************************************************************************************** */
/*************************************************************************************** */
/*************************************************************************************** */
/*************************************************************************************** */
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_BDMA_Init();
MX_DMA_Init();
MX_ADC3_Init();
MX_USART1_UART_Init();
MX_TIM2_Init();
MX_TIM1_Init();
MX_TIM4_Init();
/* USER CODE BEGIN 2 */
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
/* USER CODE END 2 */
/* Init scheduler */
osKernelInitialize();
/* USER CODE BEGIN RTOS_MUTEX */
/* add mutexes, ... */
/* USER CODE END RTOS_MUTEX */
/* USER CODE BEGIN RTOS_SEMAPHORES */
/* add semaphores, ... */
/* USER CODE END RTOS_SEMAPHORES */
/* USER CODE BEGIN RTOS_TIMERS */
/* start timers, add new ones, ... */
/* USER CODE END RTOS_TIMERS */
/* USER CODE BEGIN RTOS_QUEUES */
/* USER CODE END RTOS_QUEUES */
/* Create the thread(s) */
/* creation of defaultTask */
defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);
/* USER CODE BEGIN RTOS_THREADS */
/* add threads, ... */
/* USER CODE END RTOS_THREADS */
/* USER CODE BEGIN RTOS_EVENTS */
/* add events, ... */
/* USER CODE END RTOS_EVENTS */
/* Start scheduler */
osKernelStart();
/* We should never get here as control is now taken by the scheduler */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Supply configuration update enable
*/
HAL_PWREx_ConfigSupply(PWR_LDO_SUPPLY);
/** Configure the main internal regulator output voltage
*/
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE0);
while (!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY))
{
}
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 5;
RCC_OscInitStruct.PLL.PLLN = 192;
RCC_OscInitStruct.PLL.PLLP = 2;
RCC_OscInitStruct.PLL.PLLQ = 15;
RCC_OscInitStruct.PLL.PLLR = 2;
RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_2;
RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
RCC_OscInitStruct.PLL.PLLFRACN = 0;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 |
RCC_CLOCKTYPE_PCLK2 | RCC_CLOCKTYPE_D3PCLK1 | RCC_CLOCKTYPE_D1PCLK1;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief ADC3 Initialization Function
* @param None
* @retval None
*/
static void MX_ADC3_Init(void)
{
/* USER CODE BEGIN ADC3_Init 0 */
/* USER CODE END ADC3_Init 0 */
ADC_ChannelConfTypeDef sConfig = {0};
/* USER CODE BEGIN ADC3_Init 1 */
/* USER CODE END ADC3_Init 1 */
/** Common config
*/
hadc3.Instance = ADC3;
hadc3.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV4;
hadc3.Init.Resolution = ADC_RESOLUTION_16B;
hadc3.Init.ScanConvMode = ADC_SCAN_ENABLE;
hadc3.Init.EOCSelection = ADC_EOC_SEQ_CONV;
hadc3.Init.LowPowerAutoWait = DISABLE;
hadc3.Init.ContinuousConvMode = DISABLE;
hadc3.Init.NbrOfConversion = 10;
hadc3.Init.DiscontinuousConvMode = DISABLE;
hadc3.Init.ExternalTrigConv = ADC_EXTERNALTRIG_T4_TRGO;
hadc3.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
hadc3.Init.ConversionDataManagement = ADC_CONVERSIONDATA_DMA_CIRCULAR;
hadc3.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
hadc3.Init.LeftBitShift = ADC_LEFTBITSHIFT_NONE;
hadc3.Init.OversamplingMode = DISABLE;
hadc3.Init.Oversampling.Ratio = 1;
if (HAL_ADC_Init(&hadc3) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
sConfig.SingleDiff = ADC_SINGLE_ENDED;
sConfig.OffsetNumber = ADC_OFFSET_NONE;
sConfig.Offset = 0;
sConfig.OffsetSignedSaturation = DISABLE;
if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_1;
sConfig.Rank = ADC_REGULAR_RANK_2;
if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_5;
sConfig.Rank = ADC_REGULAR_RANK_3;
if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Rank = ADC_REGULAR_RANK_4;
if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_10;
sConfig.Rank = ADC_REGULAR_RANK_5;
if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_11;
sConfig.Rank = ADC_REGULAR_RANK_6;
if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_13;
sConfig.Rank = ADC_REGULAR_RANK_7;
if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_14;
sConfig.Rank = ADC_REGULAR_RANK_8;
if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_15;
sConfig.Rank = ADC_REGULAR_RANK_9;
if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_16;
sConfig.Rank = ADC_REGULAR_RANK_10;
if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN ADC3_Init 2 */
/* USER CODE END ADC3_Init 2 */
}
/**
* @brief TIM1 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM1_Init(void)
{
/* USER CODE BEGIN TIM1_Init 0 */
/* USER CODE END TIM1_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
/* USER CODE BEGIN TIM1_Init 1 */
/* USER CODE END TIM1_Init 1 */
htim1.Instance = TIM1;
htim1.Init.Prescaler = 240000000 / 1000000 - 1;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 100 - 1;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 5;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
{
Error_Handler();
}
sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
sBreakDeadTimeConfig.DeadTime = 0;
sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
sBreakDeadTimeConfig.BreakFilter = 0;
sBreakDeadTimeConfig.Break2State = TIM_BREAK2_DISABLE;
sBreakDeadTimeConfig.Break2Polarity = TIM_BREAK2POLARITY_HIGH;
sBreakDeadTimeConfig.Break2Filter = 0;
sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM1_Init 2 */
/* USER CODE END TIM1_Init 2 */
}
/**
* @brief TIM2 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM2_Init(void)
{
/* USER CODE BEGIN TIM2_Init 0 */
/* USER CODE END TIM2_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
/* USER CODE BEGIN TIM2_Init 1 */
/* USER CODE END TIM2_Init 1 */
htim2.Instance = TIM2;
htim2.Init.Prescaler = 240000000 / 1000000 - 1;
htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
htim2.Init.Period = 100 - 1;
htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM2_Init 2 */
/* USER CODE END TIM2_Init 2 */
HAL_TIM_MspPostInit(&htim2);
}
/**
* @brief TIM4 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM4_Init(void)
{
/* USER CODE BEGIN TIM4_Init 0 */
/* USER CODE END TIM4_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
/* USER CODE BEGIN TIM4_Init 1 */
/* USER CODE END TIM4_Init 1 */
htim4.Instance = TIM4;
htim4.Init.Prescaler = 240000000 / 1000000 - 1;
htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
htim4.Init.Period = 100 - 1;
htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim4) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 5;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM4_Init 2 */
/* USER CODE END TIM4_Init 2 */
}
/**
* @brief USART1 Initialization Function
* @param None
* @retval None
*/
static void MX_USART1_UART_Init(void)
{
/* USER CODE BEGIN USART1_Init 0 */
/* USER CODE END USART1_Init 0 */
/* USER CODE BEGIN USART1_Init 1 */
/* USER CODE END USART1_Init 1 */
huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART1_Init 2 */
/* USER CODE END USART1_Init 2 */
}
/**
* Enable DMA controller clock
*/
static void MX_BDMA_Init(void)
{
/* DMA controller clock enable */
__HAL_RCC_BDMA_CLK_ENABLE();
/* DMA interrupt init */
/* DMAMUX2_OVR_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMAMUX2_OVR_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMAMUX2_OVR_IRQn);
/* BDMA_Channel0_IRQn interrupt configuration */
HAL_NVIC_SetPriority(BDMA_Channel0_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(BDMA_Channel0_IRQn);
}
/**
* Enable DMA controller clock
* Configure DMA for memory to memory transfers
* hdma_memtomem_dma2_stream0
*/
static void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__HAL_RCC_DMA2_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
/* Configure DMA request hdma_memtomem_dma2_stream0 on DMA2_Stream0 */
hdma_memtomem_dma2_stream0.Instance = DMA2_Stream0;
hdma_memtomem_dma2_stream0.Init.Request = DMA_REQUEST_MEM2MEM;
hdma_memtomem_dma2_stream0.Init.Direction = DMA_MEMORY_TO_MEMORY;
hdma_memtomem_dma2_stream0.Init.PeriphInc = DMA_PINC_ENABLE;
hdma_memtomem_dma2_stream0.Init.MemInc = DMA_MINC_ENABLE;
hdma_memtomem_dma2_stream0.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_memtomem_dma2_stream0.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_memtomem_dma2_stream0.Init.Mode = DMA_NORMAL;
hdma_memtomem_dma2_stream0.Init.Priority = DMA_PRIORITY_LOW;
hdma_memtomem_dma2_stream0.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
hdma_memtomem_dma2_stream0.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
hdma_memtomem_dma2_stream0.Init.MemBurst = DMA_MBURST_SINGLE;
hdma_memtomem_dma2_stream0.Init.PeriphBurst = DMA_PBURST_SINGLE;
if (HAL_DMA_Init(&hdma_memtomem_dma2_stream0) != HAL_OK)
{
Error_Handler();
}
/* DMA interrupt init */
/* DMA1_Stream5_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
}
/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOF_CLK_ENABLE();
__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOG_CLK_ENABLE();
__HAL_RCC_GPIOI_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_11, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_7,
GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14,
GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_7, GPIO_PIN_SET);
/*Configure GPIO pin : PA8 */
GPIO_InitStruct.Pin = GPIO_PIN_8;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pin : PC11 */
GPIO_InitStruct.Pin = GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/*Configure GPIO pins : PD0 PD1 PD3 PD4
PD5 */
GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pins : PD2 PD7 */
GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pins : PG9 PG10 PG11 PG12
PG13 PG14 */
GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
/*Configure GPIO pin : PI7 */
GPIO_InitStruct.Pin = GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);
/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}
/* USER CODE BEGIN 4 */
void LOWPower()
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Supply configuration update enable
*/
HAL_PWREx_ConfigSupply(PWR_LDO_SUPPLY);
/** Configure the main internal regulator output voltage
*/
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
while (!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY))
{
}
__HAL_RCC_SYSCFG_CLK_ENABLE();
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE0);
while (!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY))
{
}
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 5;
RCC_OscInitStruct.PLL.PLLN = 32;
RCC_OscInitStruct.PLL.PLLP = 2;
RCC_OscInitStruct.PLL.PLLQ = 15;
RCC_OscInitStruct.PLL.PLLR = 2;
RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_2;
RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
RCC_OscInitStruct.PLL.PLLFRACN = 0;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 |
RCC_CLOCKTYPE_PCLK2 | RCC_CLOCKTYPE_D3PCLK1 | RCC_CLOCKTYPE_D1PCLK1;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
{
Error_Handler();
}
MX_USART1_UART_Init();
}
uint16_t CLKHZ[98] = {5000, 4000, 3000, 2500, 2000, 1500, 1300, 1200, 1100, 1000, 900, 800, 700, 520, 460, 400, 350,
300, 260, 230, 210, 190, 170, 160, 140, 130, 120, 110, 105, 90, 85, 80, 77, 75,
72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56,
55, 54, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31,
30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14,
13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; // 500mi
float BaseNiose[4];
float BaseNioseGain[4];
float OutPut1[8][4][98];
float OutPut2[8][4][98];
float OutPut3[8][4][98];
float OutPut4[8][4][98];
uint8_t CLKCount = 98;
float Datav;
void CLKHZSET(uint16_t Deep)
{
switch (Deep)
{
case 150:
{
uint16_t HZ[98] = {5000, 4500, 4000, 3500, 3000, 2500, 2200, 2000, 1800, 1600, 1400, 1300, 1200, 1100,
1000, 950, 900, 850, 800, 750, 700, 650, 600, 550, 500, 460, 400, 350,
320, 300, 260, 230, 210, 190, 180, 170, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // 500mi
memcpy(CLKHZ, HZ, sizeof(HZ));
CLKCount = 36;
break;
}
case 600:
{
uint16_t HZ[98] = {5000, 4000, 3000, 2500, 2000, 1500, 1300, 1200, 1100, 1000, 900, 800, 700, 520, 460,
400, 350, 300, 260, 230, 210, 190, 170, 160, 140, 130, 120, 110, 105, 90,
85, 80, 77, 75, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62,
61, 60, 59, 58, 57, 56, 55, 54, 45, 44, 43, 42, 41, 40, 39,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
};
CLKCount = 60;
memcpy(CLKHZ, HZ, sizeof(HZ));
break;
}
case 800:
{
uint16_t HZ[98] = {
5000, 4000, 3000, 2500, 2000, 1500, 1300, 1200, 1100, 1000, 900, 800, 700, 520, 460, 400, 350,
300, 260, 230, 210, 190, 170, 160, 140, 130, 120, 110, 105, 90, 85, 80, 77, 75,
72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56,
55, 54, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
CLKCount = 64;
memcpy(CLKHZ, HZ, sizeof(HZ));
break;
}
case 1200:
{
uint16_t HZ[98] = {
5000, 4000, 3000, 2500, 2000, 1500, 1300, 1200, 1100, 1000, 900, 800, 700, 520, 460, 400, 350,
300, 260, 230, 210, 190, 170, 160, 140, 130, 120, 110, 105, 90, 85, 80, 77, 75,
72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56,
55, 54, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
CLKCount = 68;
memcpy(CLKHZ, HZ, sizeof(HZ));
break;
}
case 1500:
{
uint16_t HZ[98] = {
5000, 4000, 3000, 2500, 2000, 1500, 1300, 1200, 1100, 1000, 900, 800, 700, 520, 460, 400, 350,
300, 260, 230, 210, 190, 170, 160, 140, 130, 120, 110, 105, 90, 85, 80, 77, 75,
72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56,
55, 54, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31,
30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
CLKCount = 78;
memcpy(CLKHZ, HZ, sizeof(HZ));
break;
}
case 2000:
{
uint16_t HZ[98] = {
5000, 4000, 3000, 2500, 2000, 1500, 1300, 1200, 1100, 1000, 900, 800, 700, 520, 460, 400, 350,
300, 260, 230, 210, 190, 170, 160, 140, 130, 120, 110, 105, 90, 85, 80, 77, 75,
72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56,
55, 54, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31,
30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14,
13, 12, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
CLKCount = 88;
memcpy(CLKHZ, HZ, sizeof(HZ));
break;
}
default:
case 3000:
{
uint16_t HZ[98] = {
5000, 4000, 3000, 2500, 2000, 1500, 1300, 1200, 1100, 1000, 900, 800, 700, 520, 460, 400, 350,
300, 260, 230, 210, 190, 170, 160, 140, 130, 120, 110, 105, 90, 85, 80, 77, 75,
72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56,
55, 54, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31,
30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14,
13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
};
CLKCount = 98;
memcpy(CLKHZ, HZ, sizeof(HZ));
break;
}
}
}
_Bool CheckMaxV(uint16_t Vmv)
{
uint8_t j, k = 0;
for (k = 0; k < 100; k++)
{
for (j = 0; j < 128; j++)
{
// for( i = 0; i < 14/2; i++)
// {
// if( ADC1DataBuf[i+j*7] /65535 *3300 > Vmv )
// return 1;
// if( ADC1DataBuf[i+j*7]>>16 /65535 *3300 > Vmv )
// return 1;
// }
// if( ADC2DataBuf[j] /65535 *3300 > Vmv )
// return 1;
// if( ADC2DataBuf[j]>>16 /65535 *3300 > Vmv )
// return 1;
// for( i = 0; i < 16/2; i++)
{
// if( ADC3DataBuf[7+j*8] /65535 *3300 > Vmv )
// return 1;
Datav = (ADC3DataBuf[7 + j * 8] >> 16) / 65535.0f * 3300;
if (Datav > Vmv + 1650)
return 1;
Datav = (ADC3DataBuf[7 + j * 8] & 0x00FF) / 65535.0f * 3300;
if (Datav > Vmv + 1650)
return 1;
Datav = (ADC3DataBuf[6 + j * 8] >> 16) / 65535.0f * 3300;
if (Datav > Vmv + 1650)
return 1;
Datav = (ADC3DataBuf[6 + j * 8] & 0x00FF) / 65535.0f * 3300;
if (Datav > Vmv + 1650)
return 1;
Datav = (ADC3DataBuf[0 + j * 8] >> 16) / 65535.0f * 3300;
if (Datav > Vmv + 1650)
return 1;
}
}
}
return 0;
}
void ChannelSelect(uint8_t Channel)
{
switch (Channel)
{
default:
case 0:
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_11, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_10, GPIO_PIN_RESET);
break;
case 1:
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_11, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_10, GPIO_PIN_RESET);
break;
case 2:
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_11, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_10, GPIO_PIN_RESET);
break;
case 3:
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_11, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_10, GPIO_PIN_RESET);
break;
case 4:
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_11, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_10, GPIO_PIN_SET);
break;
case 5:
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_11, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_10, GPIO_PIN_SET);
break;
case 6:
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_11, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_10, GPIO_PIN_SET);
break;
case 7:
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_11, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_10, GPIO_PIN_SET);
break;
}
}
void SampleRate_Set(uint32_t Rate)
{
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
/* USER CODE BEGIN TIM4_Init 1 */
/* USER CODE END TIM4_Init 1 */
htim4.Instance = TIM4;
htim4.Init.Prescaler = 240000000 / Rate / 100 - 1;
htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
htim4.Init.Period = 100 - 1;
htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim4) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 5;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
{
Error_Handler();
}
}
void Clk_Set(uint16_t Clk)
{
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
htim2.Instance = TIM2;
if (Clk == 0)
{
HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);
return;
}
if (Clk < 5)
{
htim2.Init.Prescaler = 240000000 / (Clk * 100 * 100) - 1;
htim2.Init.Period = 100 - 1;
}
else
{
htim2.Init.Prescaler = 240000000 / (Clk * 10 * 100) - 1;
htim2.Init.Period = 10 - 1;
}
htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
if (Clk < 5)
{
sConfigOC.Pulse = 50;
}
else
{
sConfigOC.Pulse = 5;
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
{
Error_Handler();
}
HAL_TIM_MspPostInit(&htim2);
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
}
void SlopeSet(uint8_t Level)
{
osDelay(100);
switch (Level)
{
default:
case 0: // 1
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_5, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_4, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_1, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_0, GPIO_PIN_RESET);
break;
case 1: // 10
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_5, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_4, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_1, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_0, GPIO_PIN_RESET);
break;
case 2: // 100
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_5, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_4, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_1, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_0, GPIO_PIN_RESET);
break;
case 3: // 1000
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_5, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_4, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_1, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_0, GPIO_PIN_RESET);
break;
case 4: // 10000
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_5, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_4, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_1, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_0, GPIO_PIN_RESET);
break;
case 5: // 100000
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_5, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_4, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_1, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_0, GPIO_PIN_SET);
break;
}
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_11, GPIO_PIN_SET);
osDelay(100);
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_11, GPIO_PIN_RESET);
}
uint16_t i, j = 0;
union floattouint16_t
{ // 32位float与16位uint16的联合体
float f;
uint32_t u32;
uint16_t u16[2];
uint8_t u8[4];
};
union floattouint16_t FtU;
// 计算一个数组的平均值
float calculateAverage(uint16_t arr[], int size)
{
double sum = 0.0;
// 累加
int i;
for (i = 0; i < size; i++)
{
sum += arr[i];
}
// 计算平均值
double average = sum / size;
return average / 65535.0f * 3300 * 2.828;
}
_Bool LineCheckResult[32];
float LineCheckF[32];
char bufx[80];
void LineCheck(void)
{
uint16_t i, j, k = 0;
float TempCheck;
CommunicationData.MeasurementPrecision = 0;
SampleRate_Set(4096 * 2);
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_7, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_9, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_RESET);
for (j = 0; j < 8; j++)
{
CommunicationData.MeasurementPrecision = 96 / 3 / 8 * j;
HAL_ADC_Stop_DMA(&hadc3);
HAL_ADC_Start_DMA(&hadc3, ADC3DataBuf, 1024 * 10);
ChannelSelect(j);
memset(ADC3DataBuf, 0, sizeof(ADC3DataBuf));
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);
osDelay(500);
HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_1);
for (k = 0; k < 1024; k++)
{
fft_inputbuf[k] = (uint16_t)(ADC3DataBuf[k * 5 + 2] >> 0); // CH1
}
LineCheckF[j + 0] = calculateAverage(fft_inputbuf, 1024);
for (k = 0; k < 1024; k++)
{
fft_inputbuf[k] = (uint16_t)(ADC3DataBuf[k * 5 + 2] >> 16); // CH2
}
LineCheckF[j + 8] = calculateAverage(fft_inputbuf, 1024);
for (k = 0; k < 1024; k++)
{
fft_inputbuf[k] = (uint16_t)(ADC3DataBuf[k * 5 + 0] >> 16); // CH3
}
LineCheckF[j + 16] = calculateAverage(fft_inputbuf, 1024);
for (k = 0; k < 1024; k++)
{
fft_inputbuf[k] = (uint16_t)(ADC3DataBuf[k * 5 + 0] >> 0); // CH4
}
LineCheckF[j + 24] = calculateAverage(fft_inputbuf, 1024);
}
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_9, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_7, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_SET);
for (j = 0; j < 8; j++)
{
CommunicationData.MeasurementPrecision = 96 / 3 / 8 * j + 30;
HAL_ADC_Stop_DMA(&hadc3);
HAL_ADC_Start_DMA(&hadc3, ADC3DataBuf, 1024 * 10);
ChannelSelect(j);
memset(ADC3DataBuf, 0, sizeof(ADC3DataBuf));
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);
for (i = 0; i < 50; i++)
{
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_RESET);
osDelay(5);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_SET);
osDelay(5);
}
HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_1);
for (k = 0; k < 1024; k++)
{
fft_inputbuf[k] = (uint16_t)(ADC3DataBuf[k * 5 + 2] >> 0); // CH1
}
TempCheck = calculateAverage(fft_inputbuf, 1024);
LineCheckF[j + 0] = (TempCheck > LineCheckF[j + 0] ? (TempCheck - LineCheckF[j + 0]) : 0);
if (LineCheckF[j + 0] > 100)
{
LineCheckResult[j + 0] = 1;
}
else
{
LineCheckResult[j + 0] = 0;
}
for (k = 0; k < 1024; k++)
{
fft_inputbuf[k] = (uint16_t)(ADC3DataBuf[k * 5 + 0] >> 16); // CH3
}
TempCheck = calculateAverage(fft_inputbuf, 1024);
LineCheckF[j + 16] = (TempCheck > LineCheckF[j + 16] ? (TempCheck - LineCheckF[j + 16]) : 0);
if (LineCheckF[j + 16] > 100)
{
LineCheckResult[j + 16] = 1;
}
else
{
LineCheckResult[j + 16] = 0;
}
}
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_9, GPIO_PIN_SET); // A1
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_7, GPIO_PIN_SET); // A0
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_RESET); // A1
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_SET); // A0
for (j = 0; j < 8; j++)
{
CommunicationData.MeasurementPrecision = 96 / 3 / 8 * j + 60;
HAL_ADC_Stop_DMA(&hadc3);
HAL_ADC_Start_DMA(&hadc3, ADC3DataBuf, 1024 * 10);
ChannelSelect(j);
memset(ADC3DataBuf, 0, sizeof(ADC3DataBuf));
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);
for (i = 0; i < 50; i++)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_7, GPIO_PIN_SET);
osDelay(5);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_7, GPIO_PIN_RESET);
osDelay(5);
}
HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_1);
for (k = 0; k < 1024; k++)
{
fft_inputbuf[k] = (uint16_t)(ADC3DataBuf[k * 5 + 2] >> 16); // CH2
}
TempCheck = calculateAverage(fft_inputbuf, 1024);
LineCheckF[j + 8] = (TempCheck > LineCheckF[j + 8] ? (TempCheck - LineCheckF[j + 8]) : 0);
if (LineCheckF[j + 8] > 100)
{
LineCheckResult[j + 8] = 1;
}
else
{
LineCheckResult[j + 8] = 0;
}
for (k = 0; k < 1024; k++)
{
fft_inputbuf[k] = (uint16_t)(ADC3DataBuf[k * 5 + 0] >> 0); // CH4
}
TempCheck = calculateAverage(fft_inputbuf, 1024);
LineCheckF[j + 24] = (TempCheck > LineCheckF[j + 24] ? (TempCheck - LineCheckF[j + 24]) : 0);
if (LineCheckF[j + 24] > 100)
{
LineCheckResult[j + 24] = 1;
}
else
{
LineCheckResult[j + 24] = 0;
}
}
HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);
// HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
// osDelay(500);
// sprintf(bufx, "%s\r\n", "\r\n\r\n\r\n----------------------接线测试----------------------\r\n");
// HAL_UART_Transmit(&huart1, (uint8_t *)bufx, strlen(bufx), 0xFFFF);
// while (HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX)
// ; // 等待UART发送完成
// osDelay(3000);
// for (i = 0; i < 32; i++)
// {
// sprintf(bufx, "通道%02d: %.1f\r\n", i + 1, LineCheckF[i]);
// HAL_UART_Transmit(&huart1, (uint8_t *)bufx, strlen(bufx), 0xFFFF);
// while (HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX)
// ; // 等待UART发送完成
// }
// for (i = 0; i < 32; i++)
// {
// sprintf(bufx, "通道%02d: %d\r\n", i + 1, LineCheckResult[i]);
// HAL_UART_Transmit(&huart1, (uint8_t *)bufx, strlen(bufx), 0xFFFF);
// while (HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX)
// ; // 等待UART发送完成
// }
ReadFlag = 1;
// HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
// HAL_UARTEx_ReceiveToIdle_IT(&huart1, (uint8_t *)&Uart_ReadCache, 100); // 锟劫匡拷锟斤拷锟斤拷锟斤拷锟叫讹拷
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_7, GPIO_PIN_RESET);
osDelay(1000);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_7, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_7, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_9, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_RESET);
CommunicationData.MeasurementPrecision = 100;
}
extern void Command_Deal(void);
float FindMaxValue(float *data, uint16_t length)
{
float maxValue = data[0];
for (uint16_t i = 1; i < length; i++)
{
if (data[i] > maxValue)
{
maxValue = data[i];
}
}
if(maxValue < 0.05)
{
maxValue = data[2];
}
return maxValue;
}
void CommunicationResponse(void *P_grg)
{
float FindmaxDatabuf[4];
for (;;)
{
osSemaphoreAcquire(CommandResponse_Semaphore, osWaitForever);
if (CommunicationData.MeasurementFlag)
{
uint8_t l, m, n = 0;
CommunicationData.MeasurementPrecision = 0;
SampleRate_Set(4096 * 2);
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_1);
HAL_ADC_Stop_DMA(&hadc3);
HAL_ADC_Start_DMA(&hadc3, ADC3DataBuf, 1024 * 10);
ChannelSelect(0);
Clk_Set(CLKHZ[0]);
osDelay(1000); // 10
SlopeSet(2);
// HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
HFk = 0;
CPk = 0;
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);
for (l = 0; l < CLKCount; l++)
{
if (!CommunicationData.MeasurementFlag)
break;
CommunicationData.MeasurementPrecision = 100.0 / CLKCount * l;
osDelay(10); // 10
for (m = 0; m < 8; m++)
{
if (!CommunicationData.MeasurementFlag)
break;
for (n = 0; n < 3; n++)
{
if (!CommunicationData.MeasurementFlag)
break;
if (l >= 90)
osDelay(2000); // 10
else
osDelay(200); // 10
ADC3Finish = 0;
StartFlag = 1;
do
{
osDelay(30);
} while (!ADC3Finish);
HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_1);
HAL_ADC_Stop_DMA(&hadc3);
HAL_ADC_Start_DMA(&hadc3, ADC3DataBuf, 1024 * 10);
if (n < 2)
{
SlopeSet(n + 3);
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);
}
else
{
if ((m == 7) && (l < 97))
{
Clk_Set(CLKHZ[l + 1]);
}
ChannelSelect(m + 1);
SlopeSet(2);
if ((m == 7) && (l < 97))
{
}
HFk = 0;
CPk = 0;
if (l >= 90)
{
SampleRate_Set(4096 / 2);
osDelay(1500); // 10
}
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);
}
int x = 0;
for (x = 0; x < FFT_LENGTH; x++)
{
fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 3] >> 0); // CH1
}
OutPut1[m][n][l] = (calculateAverage(fft_inputbuf, FFT_LENGTH)) / pow(10, n + 2);// - BaseNioseGain[0];
if (OutPut1[m][n][l] < 0)
OutPut1[m][n][l] = 0;
for (x = 0; x < FFT_LENGTH; x++)
{
fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 3] >> 16); // CH2
}
OutPut2[m][n][l] = (calculateAverage(fft_inputbuf, FFT_LENGTH) ) / pow(10, n + 2);// - BaseNioseGain[1];
if (OutPut2[m][n][l] < 0)
OutPut2[m][n][l] = 0;
for (x = 0; x < FFT_LENGTH; x++)
{
fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 4] >> 0); // CH3
}
OutPut3[m][n][l] = (calculateAverage(fft_inputbuf, FFT_LENGTH) ) / pow(10, n + 2);// - BaseNioseGain[2];
if (OutPut3[m][n][l] < 0)
OutPut3[m][n][l] = 0;
for (x = 0; x < FFT_LENGTH; x++)
{
fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 4] >> 16); // CH4
}
OutPut4[m][n][l] = (calculateAverage(fft_inputbuf, FFT_LENGTH) ) / pow(10, n + 2);// - BaseNioseGain[3];
if (OutPut4[m][n][l] < 0)
OutPut4[m][n][l] = 0;
}
}
}
for (l = 0; l < CLKCount; l++)
{
for (m = 0; m < 8; m++)
{
FindmaxDatabuf[0] = OutPut1[m][0][l];
FindmaxDatabuf[1] = OutPut1[m][1][l];
FindmaxDatabuf[2] = OutPut1[m][2][l];
// FindmaxDatabuf[3] = OutPut1[m][3][l];
OutPut1[m][0][l] = FindMaxValue(FindmaxDatabuf, 3);
FindmaxDatabuf[0] = OutPut2[m][0][l];
FindmaxDatabuf[1] = OutPut2[m][1][l];
FindmaxDatabuf[2] = OutPut2[m][2][l];
// FindmaxDatabuf[3] = OutPut2[m][3][l];
OutPut2[m][0][l] = FindMaxValue(FindmaxDatabuf, 3);
FindmaxDatabuf[0] = OutPut3[m][0][l];
FindmaxDatabuf[1] = OutPut3[m][1][l];
FindmaxDatabuf[2] = OutPut3[m][2][l];
// FindmaxDatabuf[3] = OutPut3[m][3][l];
OutPut3[m][0][l] = FindMaxValue(FindmaxDatabuf, 3);
FindmaxDatabuf[0] = OutPut4[m][0][l];
FindmaxDatabuf[1] = OutPut4[m][1][l];
FindmaxDatabuf[2] = OutPut4[m][2][l];
// FindmaxDatabuf[3] = OutPut4[m][3][l];
OutPut4[m][0][l] = FindMaxValue(FindmaxDatabuf, 3);
}
}
HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_1);
HAL_ADC_Stop_DMA(&hadc3);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_7, GPIO_PIN_RESET);
osDelay(1500);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_7, GPIO_PIN_SET);
if (!CommunicationData.MeasurementFlag)
{
CommunicationData.MeasurementPrecision = 0;
CommunicationData.MeasurementFlag = 0;
}
else
{
CommunicationData.MeasurementPrecision = 100;
CommunicationData.MeasurementFlag = 0;
}
}
if (CommunicationData.SingelStrengthMeasurementFlag)
{
LineCheck();
CommunicationData.SingelStrengthMeasurementFlag = 0;
}
}
}
/* USER CODE END 4 */
/* USER CODE BEGIN Header_StartDefaultTask */
/**
* @brief Function implementing the defaultTask thread.
* @param argument: Not used
* @retval None
*/
#include "usbd_cdc_if.h"
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void *argument)
{
/* init code for USB_DEVICE */
// MX_USB_DEVICE_Init();
/* USER CODE BEGIN 5 */
/* Infinite loop */
CommunicationData.Deep = 150; // 默认深度150
CommunicationData.ChannelNum = 8; // 默认通道数8
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_7, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_9, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_RESET);
HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);
SlopeSet(0);
Clk_Set(CLKHZ[0]);
HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);
osDelay(5000); // 10
HAL_ADCEx_Calibration_Start(&hadc3, ADC_CALIB_OFFSET, ADC_SINGLE_ENDED);
HAL_ADCEx_Calibration_Start(&hadc3, ADC_CALIB_OFFSET_LINEARITY, ADC_SINGLE_ENDED);
HAL_ADC_Start_DMA(&hadc3, ADC3DataBuf, 1024 * 10);
HAL_UARTEx_ReceiveToIdle_DMA(&huart1, Uart_ReadCache, 128); // 开启DMA串口接收
__HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE); // 开启空闲中断 /* USER CODE END RTOS_EVENTS */
__HAL_DMA_DISABLE_IT(&hdma_usart1_rx, DMA_IT_HT); // 禁止半传输完成中断
CommandResponse_Semaphore = osSemaphoreNew(1, 0, NULL); // 创建命令响应信号量，初始值为0，最大值为1
Command_Semaphore = osSemaphoreNew(1, 0, NULL); // 创建信号量，初始值为0，最大值为1
// osThreadId_t communicationTaskHandle =
osThreadNew(CommunicationResponse, NULL, &CommunicationResponeTask_attributes);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
// HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);
// osDelay(500); // 10
// {
// ADC3Finish = 0;
// StartFlag = 1;
// do
// {
// osDelay(50);
// } while (!ADC3Finish);
// HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_1);
// int x = 0;
// for (x = 0; x < FFT_LENGTH; x++)
// {
// fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 3] >> 0); // CH1
// }
// BaseNiose[0] = calculateAverage(fft_inputbuf, FFT_LENGTH);
// for (x = 0; x < FFT_LENGTH; x++)
// {
// fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 3] >> 16); // CH2
// }
// BaseNiose[1] = calculateAverage(fft_inputbuf, FFT_LENGTH);
// for (x = 0; x < FFT_LENGTH; x++)
// {
// fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 4] >> 0); // CH3
// }
// BaseNiose[2] = calculateAverage(fft_inputbuf, FFT_LENGTH);
// for (x = 0; x < FFT_LENGTH; x++)
// {
// fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 4] >> 16); // CH4
// }
// BaseNiose[3] = calculateAverage(fft_inputbuf, FFT_LENGTH);
// }
//
// SlopeSet(4);
// Clk_Set(CLKHZ[0]);
// osDelay(1000); // 10
// HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);
// osDelay(500); // 10
// {
// ADC3Finish = 0;
// StartFlag = 1;
// do
// {
// osDelay(50);
// } while (!ADC3Finish);
// HAL_TIM_PWM_Stop(&htim4, TIM_CHANNEL_1);
// int x = 0;
// for (x = 0; x < FFT_LENGTH; x++)
// {
// fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 3] >> 0); // CH1
// }
// BaseNioseGain[0] = (calculateAverage(fft_inputbuf, FFT_LENGTH) - BaseNiose[0]) / 10000.0f;
// for (x = 0; x < FFT_LENGTH; x++)
// {
// fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 3] >> 16); // CH2
// }
// BaseNioseGain[1] = (calculateAverage(fft_inputbuf, FFT_LENGTH) - BaseNiose[1]) / 10000.0f;
// for (x = 0; x < FFT_LENGTH; x++)
// {
// fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 4] >> 0); // CH3
// }
// BaseNioseGain[2] = (calculateAverage(fft_inputbuf, FFT_LENGTH) - BaseNiose[2]) / 10000.0f;
// for (x = 0; x < FFT_LENGTH; x++)
// {
// fft_inputbuf[x] = (uint16_t)(ADC3DataBufTrans[x * 5 + 4] >> 16); // CH4
// }
// BaseNioseGain[3] = (calculateAverage(fft_inputbuf, FFT_LENGTH) - BaseNiose[3]) / 10000.0f;
// }
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_7, GPIO_PIN_RESET);
osDelay(500);
HAL_GPIO_WritePin(GPIOI, GPIO_PIN_7, GPIO_PIN_SET);
// char buf[80];
// HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
// sprintf(buf, "%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,\r\n", BaseNiose[0],BaseNiose[1],BaseNiose[2],BaseNiose[3],BaseNioseGain[0],BaseNioseGain[1],BaseNioseGain[2],BaseNioseGain[3]);
// HAL_UART_Transmit(&huart1, (uint8_t *)buf, strlen(buf), HAL_MAX_DELAY);
// while (HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX);
// HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
while (1)
{
Command_Deal();
osSemaphoreRelease(CommandResponse_Semaphore);
osDelay(300); //
}
// LOWPower();
/* USER CODE END 5 */
}
/**
* @brief Period elapsed callback in non blocking mode
* @note This function is called when TIM7 interrupt took place, inside
* HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment
* a global variable "uwTick" used as application time base.
* @param htim : TIM handle
* @retval None
*/
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* USER CODE BEGIN Callback 0 */
/* USER CODE END Callback 0 */
if (htim->Instance == TIM7)
{
HAL_IncTick();
}
/* USER CODE BEGIN Callback 1 */
/* USER CODE END Callback 1 */
}
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
Reference in New Issue View Git Blame Copy Permalink