基于STM32设计的智能灌溉控制系统

#include "main.h"
 #include "stm32f1xx_hal.h"
 
 /* TIM handle structure */
 TIM_HandleTypeDef htim;
 
 /* Function prototypes */
 void PWM_Init(TIM_HandleTypeDef *htim, uint32_t channel);
 void Set_Motor_Speed(TIM_HandleTypeDef *htim, uint32_t channel, uint16_t speed);
 
 int main(void)
 {
   /* Initialize the HAL Library */
   HAL_Init();
 
   /* Initialize TIM2 PWM with a frequency of 10 kHz */
   PWM_Init(&htim2, TIM_CHANNEL_1);
 
   /* Set the motor speed to 50% */
   Set_Motor_Speed(&htim2, TIM_CHANNEL_1, 5000);
 
   while (1)
   {
     /* Infinite loop */
   }
 }
 
 /**
   * @brief  Initializes PWM output on specified TIM channel.
   * @param  htim: TIM handle structure.
   * @param  channel: TIM channel to be used for PWM output.
   * @retval None
   */
 void PWM_Init(TIM_HandleTypeDef *htim, uint32_t channel)
 {
   TIM_OC_InitTypeDef sConfigOC = {0};
 
   /* Configure PWM output on specified TIM channel */
   sConfigOC.OCMode       = TIM_OCMODE_PWM1;
   sConfigOC.Pulse        = 0;
   sConfigOC.OCPolarity   = TIM_OCPOLARITY_HIGH;
   sConfigOC.OCFastMode   = TIM_OCFAST_DISABLE;
   HAL_TIM_PWM_ConfigChannel(htim, &sConfigOC, channel);
 
   /* Start PWM output */
   HAL_TIM_PWM_Start(htim, channel);
 }
 
 /**
   * @brief  Sets the motor speed on specified TIM channel.
   * @param  htim: TIM handle structure.
   * @param  channel: TIM channel to be used for PWM output.
   * @param  speed: Motor speed in units of 1/10,000th of the maximum speed.
   *                For example, a speed of 5000 would set the motor speed to 50%.
   * @retval None
   */
 void Set_Motor_Speed(TIM_HandleTypeDef *htim, uint32_t channel, uint16_t speed)
 {
   uint16_t max_speed = htim->Init.Period;
 
   /* Ensure that speed is within range */
   if (speed > max_speed)
     speed = max_speed;
 
   /* Update PWM duty cycle */
   __HAL_TIM_SET_COMPARE(htim, channel, speed);
 }

#include "motor_control.h"
 
 void Motor_Control(TIM_HandleTypeDef *htim, uint32_t channel, uint16_t speed)
 {
   /* Initialize PWM output on specified TIM channel */
   PWM_Init(htim, channel);
 
   /* Set the motor speed */
   Set_Motor_Speed(htim, channel, speed);
 }

#ifndef __MOTOR_CONTROL_H__
 #define __MOTOR_CONTROL_H__
 
 #include "stm32f1xx_hal.h"
 
 /* Function prototypes */
 void PWM_Init(TIM_HandleTypeDef *htim, uint32_t channel);
 void Set_Motor_Speed(TIM_HandleTypeDef *htim, uint32_t channel, uint16_t speed);
 void Motor_Control(TIM_HandleTypeDef *htim, uint32_t channel, uint16_t speed);
 
 #endif /* __MOTOR_CONTROL_H__ */

电流 = AD值 / 灵敏度
 电压 = AD值 / 分压比
 功率 = 电压 * 电流
 能量 = 功率 * 时间

#include "stm32f1xx_hal.h"
 
 ADC_HandleTypeDef hadc1;
 TIM_HandleTypeDef htim2;
 
 void SystemClock_Config(void);
 static void MX_GPIO_Init(void);
 static void MX_ADC1_Init(void);
 static void MX_TIM2_Init(void);
 
 uint16_t ad_val_ch1, ad_val_ch2;
 float voltage, current, power, energy;
 
 int main(void)
 {
   HAL_Init();
   SystemClock_Config();
   MX_GPIO_Init();
   MX_ADC1_Init();
   MX_TIM2_Init();
 
   while (1)
   {
     // ADC采样电压信号
     HAL_ADC_Start(&hadc1);
     HAL_ADC_PollForConversion(&hadc1, 100);
     ad_val_ch1 = HAL_ADC_GetValue(&hadc1);
     voltage = ad_val_ch1 * 3.3 / 4096 * 10; // 假设分压比为10
 
     // ADC采样电流信号
     HAL_TIM_Base_Start(&htim2);
     HAL_ADC_Start(&hadc1);
     HAL_ADC_PollForConversion(&hadc1, 100);
     ad_val_ch2 = HAL_ADC_GetValue(&hadc1);
     current = ad_val_ch2 * 3.3 / 4096 * 50; // 假设灵敏度为50mV/A
 
     // 计算功率和能量
     power = voltage * current;
     energy += power * 0.1; // 假设定时器时间间隔为100ms
 
     // 输出测量结果
     printf("Voltage: %.2f Vrn", voltage);
     printf("Current: %.2f Arn", current);
     printf("Power: %.2f Wrn", power);
     printf("Energy: %.2f Jrn", energy);
 
     HAL_Delay(1000); // 假设数据输出间隔为1s
   }
 }
 
 void SystemClock_Config(void)
 {
   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 
   __HAL_RCC_PWR_CLK_ENABLE();
   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
 
   RCC_OscInitStruct.OscillatorType = RCCRCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
 RCC_OscInitStruct.HSIState = RCC_HSI_ON;
 RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
 if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
 {
 Error_Handler();
 }
 
 RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
 RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
 RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
 RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
 RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
 {
 Error_Handler();
 }
 }
 
 static void MX_ADC1_Init(void)
 {
 ADC_ChannelConfTypeDef sConfig = {0};
 
 __HAL_RCC_ADC1_CLK_ENABLE();
 
 hadc1.Instance = ADC1;
 hadc1.Init.ScanConvMode = DISABLE;
 hadc1.Init.ContinuousConvMode = ENABLE;
 hadc1.Init.DiscontinuousConvMode = DISABLE;
 hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
 hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
 hadc1.Init.NbrOfConversion = 1;
 if (HAL_ADC_Init(&hadc1) != HAL_OK)
 {
 Error_Handler();
 }
 
 sConfig.Channel = ADC_CHANNEL_0; // 假设测量电压的ADC通道为0
 sConfig.Rank = ADC_REGULAR_RANK_1;
 sConfig.SamplingTime = ADC_SAMPLETIME_13CYCLES_5;
 if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }
 
 sConfig.Channel = ADC_CHANNEL_1; // 假设测量电流的ADC通道为1
 if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }
 }
 
 static void MX_TIM2_Init(void)
 {
 __HAL_RCC_TIM2_CLK_ENABLE();
 
 htim2.Instance = TIM2;
 htim2.Init.Prescaler = 7200 - 1;
 htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
 htim2.Init.Period = 10000 - 1; // 假设定时器时间间隔为100ms
 if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
 {
 Error_Handler();
 }
 }
 
 void Error_Handler(void)
 {
 while (1)
 {
 }
 }
 
 #ifdef USE_FULL_ASSERT
 
 void assert_failed(char *file, uint32_t line)
 {
 }
 
 #endif