配置TIM3 TRIG输出

时间: 2025-09-05 14:12:55 AIGC 浏览: 3
由于没有直接与配置TIM3 TRIG输出方法相关的引用内容,下面提供一个通用的基于STM32系列单片机使用HAL库配置TIM3 TRIG输出的示例代码及步骤说明。 ### 配置步骤及代码示例 #### 1. 开启TIM3时钟 在使用TIM3之前,需要先开启其时钟。在STM32 HAL库中,可以使用以下代码开启TIM3时钟: ```c __HAL_RCC_TIM3_CLK_ENABLE(); ``` #### 2. 配置TIM3基本参数 配置TIM3的基本参数,如计数模式、预分频器、自动重载值等。以下是一个示例代码: ```c TIM_HandleTypeDef htim3; void TIM3_Init(void) { TIM_MasterConfigTypeDef sMasterConfig = {0}; htim3.Instance = TIM3; htim3.Init.Prescaler = 0; htim3.Init.CounterMode = TIM_COUNTERMODE_UP; htim3.Init.Period = 65535; htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; if (HAL_TIM_Base_Init(&htim3) != HAL_OK) { Error_Handler(); } sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE; sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK) { Error_Handler(); } } ``` #### 3. 启动TIM3 配置完成后,需要启动TIM3: ```c HAL_TIM_Base_Start(&htim3); ``` ### 完整示例代码 ```c #include "stm32xxxx_hal.h" TIM_HandleTypeDef htim3; void TIM3_Init(void) { TIM_MasterConfigTypeDef sMasterConfig = {0}; htim3.Instance = TIM3; htim3.Init.Prescaler = 0; htim3.Init.CounterMode = TIM_COUNTERMODE_UP; htim3.Init.Period = 65535; htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; if (HAL_TIM_Base_Init(&htim3) != HAL_OK) { Error_Handler(); } sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE; sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK) { Error_Handler(); } } int main(void) { HAL_Init(); __HAL_RCC_TIM3_CLK_ENABLE(); TIM3_Init(); HAL_TIM_Base_Start(&htim3); while (1) { // 主循环 } } void Error_Handler(void) { // 错误处理函数 while(1) { } } ``` ### 注意事项 - 上述代码是基于STM32 HAL库的示例,不同的STM32型号可能会有细微的差异。 - 在实际应用中,需要根据具体需求调整预分频器和自动重载值等参数。
阅读全文

相关推荐

以下是我的超声波测距代码#include "stm32f10x.h" #include "tim.h" #include "delay.h" #include "sr04.h" #include "stm32f10x.h" // 全局变量定义 volatile uint32_t capture_start = 0; // 上升沿捕获时间 volatile uint32_t overflow_count = 0; // 定时器溢出次数 volatile uint32_t pulse_width_us = 0; // 脉冲宽度(微秒) volatile uint8_t capture_state = 0; // 0:等待上升沿 1:已捕获上升沿 // 发送触发信号 void HC_SR04_Trigger(void) { GPIO_SetBits(GPIOB, GPIO_Pin_6); // PB6高电平 delay_us(10); // 持续10us GPIO_ResetBits(GPIOB, GPIO_Pin_6); // PB6拉低 } // TIM4初始化 void TIM4_Init(void) { TIM_TimeBaseInitTypeDef TIM_BaseStruct; TIM_ICInitTypeDef TIM_ICStruct; NVIC_InitTypeDef NVIC_Struct; // 时钟使能 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); // 时基配置 TIM_BaseStruct.TIM_Prescaler = 72 - 1; // 72MHz/72 = 1MHz (1us) TIM_BaseStruct.TIM_CounterMode = TIM_CounterMode_Up; TIM_BaseStruct.TIM_Period = 0xFFFF; // 最大计数值 TIM_BaseStruct.TIM_ClockDivision = TIM_CKD_DIV1; TIM_BaseStruct.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM4, &TIM_BaseStruct); // 输入捕获配置 TIM_ICStruct.TIM_Channel = TIM_Channel_2; // PB7对应TIM4_CH2 TIM_ICStruct.TIM_ICPolarity = TIM_ICPolarity_Rising; // 初始上升沿触发 TIM_ICStruct.TIM_ICSelection = TIM_ICSelection_DirectTI; TIM_ICStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1; TIM_ICStruct.TIM_ICFilter = 0x0F; // 增加滤波减少噪声 TIM_ICInit(TIM4, &TIM_ICStruct); // 中断配置 TIM_ITConfig(TIM4, TIM_IT_CC2 | TIM_IT_Update, ENABLE); // 捕获+溢出中断 NVIC_Struct.NVIC_IRQChannel = TIM4_IRQn; NVIC_Struct.NVIC_IRQChannelPreemptionPriority = 0; NVIC_Struct.NVIC_IRQChannelSubPriority = 1; NVIC_Struct.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_Struct); TIM_Cmd(TIM4, ENABLE); } // GPIO初始化 void sr04_GPIO_Init(void) { GPIO_InitTypeDef GPIO_InitStruct; // 使能GPIOB时钟 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); // PB6(Trig)配置为推挽输出 GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6; GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOB, &GPIO_InitStruct); // PB7(Echo)配置为浮空输入 GPIO_InitStruct.GPIO_Pin = GPIO_Pin_7; GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOB, &GPIO_InitStruct); } // TIM4中断服务函数 void TIM4_IRQHandler(void) { // 处理溢出中断 if(TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET) { if(capture_state == 1) { // 只在等待下降沿时计数溢出 overflow_count++; } TIM_ClearITPendingBit(TIM4, TIM_IT_Update); } // 处理捕获中断 if(TIM_GetITStatus(TIM4, TIM_IT_CC2) != RESET) { if(capture_state == 0) { // 上升沿捕获 capture_start = TIM_GetCapture2(TIM4); overflow_count = 0; capture_state = 1; // 切换为下降沿捕获 TIM_OC2PolarityConfig(TIM4, TIM_ICPolarity_Falling); } else { // 下降沿捕获 uint32_t capture_end = TIM_GetCapture2(TIM4); pulse_width_us = (overflow_count * 65536) + capture_end - capture_start; capture_state = 0; // 切换回上升沿捕获 TIM_OC2PolarityConfig(TIM4, TIM_ICPolarity_Rising); } TIM_ClearITPendingBit(TIM4, TIM_IT_CC2); } } // 获取距离 float Get_Distance(void) { // 重置测量状态 capture_state = 0; pulse_width_us = 0; overflow_count = 0; // 发送触发信号 HC_SR04_Trigger(); // 等待测量完成(带超时) uint32_t timeout = 0; while(capture_state || pulse_width_us == 0) { delay_us(10); timeout++; if(timeout > 6000) { // 60ms超时(约10米) return -1.0; // 超时错误 } } // 计算距离(单位:厘米) return (pulse_width_us * 0.034) / 2.0; }

/* USER CODE BEGIN Header */ /** ****************************************************************************** * @file : main.c * @brief : Main program body ****************************************************************************** * @attention * * Copyright (c) 2025 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 "adc.h" #include "tim.h" #include "gpio.h" /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ /* USER CODE END Includes */ /* Private typedef -----------------------------------------------------------*/ /* USER CODE BEGIN PTD */ /* USER CODE END PTD */ /* Private define ------------------------------------------------------------*/ /* USER CODE BEGIN PD */ #define TRIG_PULSE_WIDTH 10 // 10us触发脉冲 #define MEASURE_TIMEOUT 30 // 30ms测量超时 /* USER CODE END PD */ /* Private macro -------------------------------------------------------------*/ /* USER CODE BEGIN PM */ /* USER CODE END PM */ /* Private variables ---------------------------------------------------------*/ /* USER CODE BEGIN PV */ volatile uint32_t icVal1 = 0, icVal2 = 0; volatile uint8_t isFirstCaptured = 0; volatile float distance_cm = 0; int Turn_Pwm = 0; uint8_t stop_flag = 0; // 停止标志位 uint8_t void_flag = 0; // 停止标志位 float feature_time = 0; // 特征区域经过时间 int baoguang_count=10; float dis = 0; // 存放测距距离 int main_count=5; /* USER CODE BEGIN PV */ typedef enum { US_IDLE, US_TRIGGER_START, US_WAIT_ECHO } US_State_t; volatile US_State_t us_state = US_IDLE; volatile uint32_t us_trigger_time = 0; /* USER CODE END PV */ /* Private function prototypes -----------------------------------------------*/ void SystemClock_Config(void); /* USER CODE BEGIN PFP */ /* USER CODE END PFP */ /* Private user code ---------------------------------------------------------*/ /* USER CODE BEGIN 0 */ void trigger_ultrasonic_non_blocking() { if (us_state == US_IDLE) { HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4); // 启动TIM2 PWM触发脉冲 us_state = US_WAIT_ECHO; us_trigger_time = HAL_GetTick(); }} void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim); float calibration(float raw_cm); float median_filter(float new_val); void trigger_ultrasonic(); void delay_us(uint16_t us); void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim); /* 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_ADC1_Init(); MX_TIM3_Init(); MX_TIM4_Init(); MX_TIM1_Init(); MX_TIM2_Init(); /* USER CODE BEGIN 2 */ HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_4); HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_2); HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4); // 启动TIM2 PWM HAL_TIM_IC_Start_IT(&htim1, TIM_CHANNEL_1); // 启动TIM1输入捕获中断 // HAL_Delay(3000); /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { if (us_state == US_WAIT_ECHO) { // 超时检测(30ms未收到回波) if (HAL_GetTick() - us_trigger_time > MEASURE_TIMEOUT) { us_state = US_IDLE; } } static uint32_t last_measure = 0; if (HAL_GetTick() - last_measure >= 100 && us_state == US_IDLE) { trigger_ultrasonic_non_blocking(); last_measure = HAL_GetTick(); } /* 距离数据处理 --------------------------------------- */ static float filtered_distance = 0; filtered_distance = median_filter(distance_cm); filtered_distance = calibration(filtered_distance); if(filtered_distance < 10.0f) {HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_RESET); } // if (main_count>5){ // // // dis = get_distance(); // if(dis < 20.0) { // 距离小于20cm亮灯 // void_flag = 1;} // main_count=0; // } int pwmVal_R = 200; int pwmVal_L = 200; RD_TSL(baoguang_count); Find_CCD_Zhongzhi(); // 计算特征区域经过时间(假设采样频率为100Hz) if (main_count>5){ feature_time = ccd_data_process(ADV, 50.0f); // 检查是否达到积分阈值 if (feature_time >= INTEGRATION_THRESHOLD) { stop_flag = 1; }} if (main_count>50000){ main_count=50000; } if (!stop_flag) { Turn_Pwm = turn(CCD_Zhongzhi, 0); // 右侧电机控制 if (pwmVal_R - Turn_Pwm > 0) { HAL_GPIO_WritePin(GPIOA, R1_Pin, 1); HAL_GPIO_WritePin(GPIOA, R2_Pin, 0); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_2, pwmVal_R - Turn_Pwm); } else if (pwmVal_R - Turn_Pwm < 0) { HAL_GPIO_WritePin(GPIOA, R1_Pin, 0); HAL_GPIO_WritePin(GPIOA, R2_Pin, 1); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_2, -pwmVal_R + Turn_Pwm); } else { HAL_GPIO_WritePin(GPIOA, R1_Pin, 0); HAL_GPIO_WritePin(GPIOA, R2_Pin, 0); } // 左侧电机控制 if (pwmVal_L + Turn_Pwm > 0) { HAL_GPIO_WritePin(GPIOA, L1_Pin, 1); HAL_GPIO_WritePin(GPIOA, L2_Pin, 0); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_4, pwmVal_L + Turn_Pwm); } else if (pwmVal_L + Turn_Pwm < 0) { HAL_GPIO_WritePin(GPIOA, L1_Pin, 0); HAL_GPIO_WritePin(GPIOA, L2_Pin, 1); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_4, -pwmVal_L - Turn_Pwm); } else { HAL_GPIO_WritePin(GPIOA, L1_Pin, 0); HAL_GPIO_WritePin(GPIOA, L2_Pin, 0); } } else if(void_flag==1){ HAL_GPIO_WritePin(GPIOA, R1_Pin, 1); HAL_GPIO_WritePin(GPIOA, R2_Pin, 0); HAL_GPIO_WritePin(GPIOA, L1_Pin, 1); HAL_GPIO_WritePin(GPIOA, L2_Pin, 0); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_4, 350); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_2,100);//右边 HAL_Delay(300); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_2, 350);//右边 __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_4,100); HAL_Delay(300); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_2, 220);//右边 __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_4,200); HAL_Delay(100); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_2, 350);//右边 __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_4,100); HAL_Delay(300); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_4, 350); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_2,100);//右边 HAL_Delay(290); stop_flag = 0; // __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_2, -pwmVal_R); // __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_4, pwmVal_L); } else { static uint8_t is_first_run = 1; // 首次运行标志 if (is_first_run) { HAL_GPIO_WritePin(GPIOA, R1_Pin, 1); HAL_GPIO_WritePin(GPIOA, R2_Pin, 0); HAL_GPIO_WritePin(GPIOA, L1_Pin, 1); HAL_GPIO_WritePin(GPIOA, L2_Pin, 0); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_2, 210);//右边 __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_4,200); HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_RESET); HAL_Delay(400); is_first_run = 0; // 清除首次标志 } // 停止小车 HAL_GPIO_WritePin(GPIOA, R1_Pin, 1); HAL_GPIO_WritePin(GPIOA, R2_Pin, 1); HAL_GPIO_WritePin(GPIOA, L1_Pin, 1); HAL_GPIO_WritePin(GPIOA, L2_Pin, 1); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_4, 0); __HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_2, 0); } Dly_us(); /* 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}; RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; /** 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.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_MUL4; 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_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4; RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2; if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK) { Error_Handler(); } PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC; PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV2; if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) { Error_Handler(); } } /* USER CODE BEGIN 4 */ void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) { if (htim->Instance == TIM1 && htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) { if (us_state == US_WAIT_ECHO) { // 仅处理等待回波状态 if (!isFirstCaptured) { icVal1 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1); isFirstCaptured = 1; __HAL_TIM_SET_CAPTUREPOLARITY(htim, TIM_CHANNEL_1, TIM_INPUTCHANNELPOLARITY_FALLING); } else { icVal2 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1); uint32_t diff = (icVal2 > icVal1) ? (icVal2 - icVal1) : (0xFFFF - icVal1 + icVal2); distance_cm = diff * 0.034f / 2; isFirstCaptured = 0; __HAL_TIM_SET_CAPTUREPOLARITY(htim, TIM_CHANNEL_1, TIM_INPUTCHANNELPOLARITY_RISING); us_state = US_IDLE; // 测量完成,回到空闲状态 } } } } /* 精准延时函数 */ void delay_us(uint16_t us) { __HAL_TIM_SET_COUNTER(&htim4, 0); while (__HAL_TIM_GET_COUNTER(&htim4) < us); } /* 中值滤波函数 */ #define FILTER_SIZE 5 float median_filter(float new_val) { static float buffer[FILTER_SIZE] = {0}; static uint8_t index = 0; float temp[FILTER_SIZE]; buffer[index] = new_val; index = (index + 1) % FILTER_SIZE; memcpy(temp, buffer, sizeof(temp)); // 冒泡排序 for(int i=0; i<FILTER_SIZE-1; i++){ for(int j=0; j<FILTER_SIZE-i-1; j++){ if(temp[j] > temp[j+1]){ float swap = temp[j]; temp[j] = temp[j+1]; temp[j+1] = swap; } } } return temp[FILTER_SIZE/2]; } /* 校准函数 */ float calibration(float raw_cm) { // 校准点配置(根据实测数据修改) const float calib_table[2][2] = {{15.0, 15.3}, {50.0, 49.7}}; if(raw_cm <= calib_table[0][0]) return raw_cm + (calib_table[0][1] - calib_table[0][0]); if(raw_cm >= calib_table[1][0]) return raw_cm + (calib_table[1][1] - calib_table[1][0]); float k = (calib_table[1][1]-calib_table[0][1]) / (calib_table[1][0]-calib_table[0][0]); return k * (raw_cm - calib_table[0][0]) + calib_table[0][1]; } /* USER CODE END 4 */ /** * @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 */ /* USER CODE BEGIN Header */ /** ****************************************************************************** * @file tim.c * @brief This file provides code for the configuration * of the TIM instances. ****************************************************************************** * @attention * * Copyright (c) 2025 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 htim1; TIM_HandleTypeDef htim2; TIM_HandleTypeDef htim3; TIM_HandleTypeDef htim4; /* TIM1 init function */ void MX_TIM1_Init(void) { /* USER CODE BEGIN TIM1_Init 0 */ /* USER CODE END TIM1_Init 0 */ TIM_MasterConfigTypeDef sMasterConfig = {0}; TIM_IC_InitTypeDef sConfigIC = {0}; /* USER CODE BEGIN TIM1_Init 1 */ /* USER CODE END TIM1_Init 1 */ htim1.Instance = TIM1; htim1.Init.Prescaler = 39; htim1.Init.CounterMode = TIM_COUNTERMODE_UP; htim1.Init.Period = 65535; htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; htim1.Init.RepetitionCounter = 0; htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; if (HAL_TIM_IC_Init(&htim1) != HAL_OK) { Error_Handler(); } sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK) { Error_Handler(); } sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING; sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI; sConfigIC.ICPrescaler = TIM_ICPSC_DIV1; sConfigIC.ICFilter = 0; if (HAL_TIM_IC_ConfigChannel(&htim1, &sConfigIC, TIM_CHANNEL_1) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN TIM1_Init 2 */ /* USER CODE END TIM1_Init 2 */ } /* TIM2 init function */ 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 = 19; htim2.Init.CounterMode = TIM_COUNTERMODE_UP; htim2.Init.Period = 9; 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_DISABLE; if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK) { Error_Handler(); } sConfigOC.OCMode = TIM_OCMODE_PWM1; sConfigOC.Pulse = 10; sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_4) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN TIM2_Init 2 */ /* USER CODE END TIM2_Init 2 */ HAL_TIM_MspPostInit(&htim2); } /* 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}; TIM_OC_InitTypeDef sConfigOC = {0}; /* USER CODE BEGIN TIM3_Init 1 */ /* USER CODE END TIM3_Init 1 */ htim3.Instance = TIM3; htim3.Init.Prescaler = 0; htim3.Init.CounterMode = TIM_COUNTERMODE_UP; htim3.Init.Period = 499; htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; 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(); } if (HAL_TIM_PWM_Init(&htim3) != HAL_OK) { Error_Handler(); } sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &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(&htim3, &sConfigOC, TIM_CHANNEL_2) != HAL_OK) { Error_Handler(); } if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_4) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN TIM3_Init 2 */ /* USER CODE END TIM3_Init 2 */ HAL_TIM_MspPostInit(&htim3); } /* TIM4 init function */ 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}; /* USER CODE BEGIN TIM4_Init 1 */ /* USER CODE END TIM4_Init 1 */ htim4.Instance = TIM4; htim4.Init.Prescaler = 19; htim4.Init.CounterMode = TIM_COUNTERMODE_UP; htim4.Init.Period = 65535; htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; 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(); } sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN TIM4_Init 2 */ /* USER CODE END TIM4_Init 2 */ } void HAL_TIM_IC_MspInit(TIM_HandleTypeDef* tim_icHandle) { GPIO_InitTypeDef GPIO_InitStruct = {0}; if(tim_icHandle->Instance==TIM1) { /* USER CODE BEGIN TIM1_MspInit 0 */ /* USER CODE END TIM1_MspInit 0 */ /* TIM1 clock enable */ __HAL_RCC_TIM1_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); /**TIM1 GPIO Configuration PA8 ------> TIM1_CH1 */ GPIO_InitStruct.Pin = ECHO_Pin; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(ECHO_GPIO_Port, &GPIO_InitStruct); /* TIM1 interrupt Init */ HAL_NVIC_SetPriority(TIM1_CC_IRQn, 3, 0); HAL_NVIC_EnableIRQ(TIM1_CC_IRQn); /* USER CODE BEGIN TIM1_MspInit 1 */ /* USER CODE END TIM1_MspInit 1 */ } } void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle) { if(tim_baseHandle->Instance==TIM2) { /* USER CODE BEGIN TIM2_MspInit 0 */ /* USER CODE END TIM2_MspInit 0 */ /* TIM2 clock enable */ __HAL_RCC_TIM2_CLK_ENABLE(); /* TIM2 interrupt Init */ HAL_NVIC_SetPriority(TIM2_IRQn, 0, 0); HAL_NVIC_EnableIRQ(TIM2_IRQn); /* USER CODE BEGIN TIM2_MspInit 1 */ /* USER CODE END TIM2_MspInit 1 */ } else 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 */ } else if(tim_baseHandle->Instance==TIM4) { /* USER CODE BEGIN TIM4_MspInit 0 */ /* USER CODE END TIM4_MspInit 0 */ /* TIM4 clock enable */ __HAL_RCC_TIM4_CLK_ENABLE(); /* TIM4 interrupt Init */ HAL_NVIC_SetPriority(TIM4_IRQn, 0, 0); HAL_NVIC_EnableIRQ(TIM4_IRQn); /* USER CODE BEGIN TIM4_MspInit 1 */ /* USER CODE END TIM4_MspInit 1 */ } } void HAL_TIM_MspPostInit(TIM_HandleTypeDef* timHandle) { GPIO_InitTypeDef GPIO_InitStruct = {0}; if(timHandle->Instance==TIM2) { /* USER CODE BEGIN TIM2_MspPostInit 0 */ /* USER CODE END TIM2_MspPostInit 0 */ __HAL_RCC_GPIOA_CLK_ENABLE(); /**TIM2 GPIO Configuration PA3 ------> TIM2_CH4 */ GPIO_InitStruct.Pin = TRIG_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(TRIG_GPIO_Port, &GPIO_InitStruct); /* USER CODE BEGIN TIM2_MspPostInit 1 */ /* USER CODE END TIM2_MspPostInit 1 */ } else if(timHandle->Instance==TIM3) { /* USER CODE BEGIN TIM3_MspPostInit 0 */ /* USER CODE END TIM3_MspPostInit 0 */ __HAL_RCC_GPIOB_CLK_ENABLE(); /**TIM3 GPIO Configuration PB1 ------> TIM3_CH4 PB5 ------> TIM3_CH2 */ GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_5; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); __HAL_AFIO_REMAP_TIM3_PARTIAL(); /* USER CODE BEGIN TIM3_MspPostInit 1 */ /* USER CODE END TIM3_MspPostInit 1 */ } } void HAL_TIM_IC_MspDeInit(TIM_HandleTypeDef* tim_icHandle) { if(tim_icHandle->Instance==TIM1) { /* USER CODE BEGIN TIM1_MspDeInit 0 */ /* USER CODE END TIM1_MspDeInit 0 */ /* Peripheral clock disable */ __HAL_RCC_TIM1_CLK_DISABLE(); /**TIM1 GPIO Configuration PA8 ------> TIM1_CH1 */ HAL_GPIO_DeInit(ECHO_GPIO_Port, ECHO_Pin); /* TIM1 interrupt Deinit */ HAL_NVIC_DisableIRQ(TIM1_CC_IRQn); /* USER CODE BEGIN TIM1_MspDeInit 1 */ /* USER CODE END TIM1_MspDeInit 1 */ } } void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle) { if(tim_baseHandle->Instance==TIM2) { /* USER CODE BEGIN TIM2_MspDeInit 0 */ /* USER CODE END TIM2_MspDeInit 0 */ /* Peripheral clock disable */ __HAL_RCC_TIM2_CLK_DISABLE(); /* TIM2 interrupt Deinit */ HAL_NVIC_DisableIRQ(TIM2_IRQn); /* USER CODE BEGIN TIM2_MspDeInit 1 */ /* USER CODE END TIM2_MspDeInit 1 */ } else 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 */ } else if(tim_baseHandle->Instance==TIM4) { /* USER CODE BEGIN TIM4_MspDeInit 0 */ /* USER CODE END TIM4_MspDeInit 0 */ /* Peripheral clock disable */ __HAL_RCC_TIM4_CLK_DISABLE(); /* TIM4 interrupt Deinit */ HAL_NVIC_DisableIRQ(TIM4_IRQn); /* USER CODE BEGIN TIM4_MspDeInit 1 */ /* USER CODE END TIM4_MspDeInit 1 */ } } /* USER CODE BEGIN 1 */ /* USER CODE END 1 */ 有什么问题吗

main.c #include “stm32f10x.h” #include “Delay.h” #include “TIM3_PWM.h” #include “MOTOR.h” #include “OLED.h” #include “MotorRun.h” #include “LightSensor.h” #include “Buzzer.h” #include “Key.h” #include “Timer.h” #include “Encoder.h” #include “PWM.h” #include “Servo.h” #include “Ultrasonic.h” /** @brief 主函数:初始化系统并控制电机和舵机 @return 无返回值 */ //变量声明distance float distance; int main(void) { NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);// 配置系统中断优先级分组 TIM3_PWM_Init(7199, 0); // 初始化TIM3的PWM输出,频率为10KHz ARR=7199, PSC=0 // 计算公式:PWM频率=72e6/(7199+1)/(0+1)=10kHz MOTOR_GPIO_Init(); // 初始化TB6612电机驱动控制引脚 Key_Init(); OLED_Init(); Timer_Init(); Motor_Init(); Encoder_Init_TIM2();// 初始化编码器 Encoder_Init_TIM4(); Servo_Init(); Ultrasonic_Init(); // 初始化超声波模块 OLED_ShowString(1, 1, "Distance:"); OLED_ShowString(1, 3, "Speed:"); while (1) { // 读取编码器计数值 int encoder_value = Read_Encoder(2); // 舵机控制 Servo_SetAngle(0); // 舵机转到0度 Delay_ms(1000); Servo_SetAngle(90); // 舵机转到90度 Delay_ms(1000); Servo_SetAngle(180); // 舵机转到180度 Delay_ms(1000); // 获取滤波后的距离值 distance = Get_Filtered_Distance(); // 在OLED上显示距离 OLED_ShowNum(1, 11, (uint16_t)distance, 3); OLED_ShowString(1, 14, "cm"); // 简单避障逻辑 if(distance > 0 && distance < 30) { // 距离小于30cm Motor_Stop(); // 停止 Delay_ms(500); Motor_Back(30); // 后退 Delay_ms(1000); Motor_TurnRight(50); // 右转 Delay_ms(800); } else { Motor_Forward(50); // 前进 } Delay_ms(100); // 循环延时 Set_Car_Speed(-7200, -7200);// 前进(左右电机反转,全速) Delay_ms(2000); // 延时2秒 Set_Car_Speed(7200, 7200);// 后退(左右电机正转,全速) Delay_ms(2000); // 延时2秒 Set_Car_Speed(3600, 7200); // 左转(左电机减速,右电机全速) Delay_ms(1000); // 延时1秒 Set_Car_Speed(7200, 3600);// 右转(左电机全速,右电机减速) Delay_ms(1000); // 延时1秒 Set_Car_Speed(0, 0);// 停止(左右电机速度为0) Delay_ms(1000); // 延时1秒 } } motor.c #include “stm32f10x.h” #include “Delay.h” #include “TIM3_PWM.h” #include “Motor_Common.h” // 初始化TB6612相关GPIO引脚 void MOTOR_GPIO_Init(void) { RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // 初始化AIN1、AIN2、BIN1、BIN2和STBY引脚 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOB, &GPIO_InitStructure); // 使能TB6612 GPIO_SetBits(GPIOB, GPIO_Pin_9); } /* 函数功能:设置左右电机的转速和转动方向 参数说明: * 范围:-7200~7200 注意:“负号”表示与正转相反的方向 * 参数1:Left_speed 左电机的转速和方向 * 参数2:Right_speed 右电机的转速和方向 */ void Set_Car_Speed(int Left_speed ,int Right_speed) { // 左电机 if(Left_speed > 0) { TIM_SetCompare2(TIM3, Left_speed); // PA7 GPIO_SetBits(GPIOB, GPIO_Pin_13); // BIN1 = 1 GPIO_ResetBits(GPIOB, GPIO_Pin_8); // BIN2 = 0 } else if(Left_speed < 0) { TIM_SetCompare2(TIM3, -Left_speed); // PA7 GPIO_ResetBits(GPIOB, GPIO_Pin_13); // BIN1 = 0 GPIO_SetBits(GPIOB, GPIO_Pin_8); // BIN2 = 1 } else { TIM_SetCompare2(TIM3, 0); // PA7 GPIO_ResetBits(GPIOB, GPIO_Pin_7); // BIN1 = 0 GPIO_ResetBits(GPIOB, GPIO_Pin_8); // BIN2 = 0 } // 右电机 if(Right_speed > 0) { TIM_SetCompare1(TIM3, Right_speed); // PA6 GPIO_SetBits(GPIOB, GPIO_Pin_5); // AIN1 = 1 GPIO_ResetBits(GPIOB, GPIO_Pin_12); // AIN2 = 0 } else if(Right_speed < 0) { TIM_SetCompare1(TIM3, -Right_speed); // PA6 GPIO_ResetBits(GPIOB, GPIO_Pin_5); // AIN1 = 0 GPIO_SetBits(GPIOB, GPIO_Pin_12); // AIN2 = 1 } else { TIM_SetCompare1(TIM3, 0); // PA6 GPIO_ResetBits(GPIOB, GPIO_Pin_5); // AIN1 = 0 GPIO_ResetBits(GPIOB, GPIO_Pin_12); // AIN2 = 0 } } motor-common.c #include "stm32f10x.h" #include "PWM.h" // ×óÓÒµç»ú³õʼ»¯ void Motor_Common_Init(void) { RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &GPIO_InitStructure); PWM_Init(); } ultrasonic.c #include "Ultrasonic.h" #include "Delay.h" #include <stdlib.h> // ³¬Éù²¨³õʼ»¯ void Ultrasonic_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure; // ʹÄÜGPIOºÍTIMʱÖÓ RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); // ÅäÖÃTRIGÒý½ÅÎªÍÆÍìÊä³ö GPIO_InitStructure.GPIO_Pin = TRIG_PIN; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(TRIG_PORT, &GPIO_InitStructure); // ÅäÖÃECHOÒý½ÅΪ¸¡¿ÕÊäÈë GPIO_InitStructure.GPIO_Pin = ECHO_PIN; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(ECHO_PORT, &GPIO_InitStructure); // ÅäÖÃTIM2ÓÃÓÚ²âÁ¿Âö³å¿í¶È TIM_TimeBaseStructure.TIM_Period = 0xFFFF; TIM_TimeBaseStructure.TIM_Prescaler = 72 - 1; // 1us·Ö±æÂÊ TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); } // »ñȡԭʼ¾àÀëÖµ float Get_Distance(void) { uint16_t high_time; float distance; // ·¢ËÍ10us´¥·¢Âö³åÐźŠGPIO_SetBits(TRIG_PORT, TRIG_PIN); Delay_us(10); GPIO_ResetBits(TRIG_PORT, TRIG_PIN); // µÈ´ýECHO±ä¸ß while(!GPIO_ReadInputDataBit(ECHO_PORT, ECHO_PIN)); // Æô¶¯¶¨Ê±Æ÷ ¿ªÊ¼¼ÆÊ± TIM_SetCounter(TIM2, 0); TIM_Cmd(TIM2, ENABLE); //µÈ´ýECHO±äµÍ while(GPIO_ReadInputDataBit(ECHO_PORT, ECHO_PIN)); // Í£Ö¹¶¨Ê±Æ÷²¢»ñÈ¡¼ÆÊýÖµ TIM_Cmd(TIM2, DISABLE); high_time = TIM_GetCounter(TIM2); // ¼ÆËã¾àÀë (cm) // ÉùËÙ340m/s,ת»»Îªcm/us,¼´340 * 100 / 1000000 = 0.034,ÓÉÓÚÊÇÍù·µÊ±¼ä£¬ËùÒÔ³ýÒÔ2µÃµ½0.017 distance = (float)high_time * 0.017; // ¾àÀë¹ýÂË(2cm~400cm) if(distance < 2 || distance > 400) { return 0; // ÎÞЧ¾àÀë } return distance; } // ÖÐÖµÂ˲¨»ñÈ¡¾àÀëÖµ #define FILTER_SIZE 5 float distances[FILTER_SIZE]; uint8_t filter_index = 0; float Get_Filtered_Distance(void) { float sorted[FILTER_SIZE]; float temp; uint8_t i, j; // ¸üоàÀëÊý×é distances[filter_index++] = Get_Distance(); if(filter_index >= FILTER_SIZE) { filter_index = 0; } // ¸´ÖÆÊý×éÓÃÓÚÅÅÐò for(i = 0; i < FILTER_SIZE; i++) { sorted[i] = distances[i]; } // ðÅÝÅÅÐò for(i = 0; i < FILTER_SIZE - 1; i++) { for(j = 0; j < FILTER_SIZE - i - 1; j++) { if(sorted[j] > sorted[j + 1]) { temp = sorted[j]; sorted[j] = sorted[j + 1]; sorted[j + 1] = temp; } } } // ·µ»ØÖÐÖµ return sorted[FILTER_SIZE / 2]; } servo.c #include "stm32f10x.h" #include "PWM.h" // ¶æ»ú³õʼ»¯ void Servo_Init(void) { // ³õʼ»¯¶æ»úPWM PWM_Generic_Init(TIM3, 20000 - 1, 72 - 1, 2, GPIOA, GPIO_Pin_3); } //ÉèÖöæ»ú½Ç¶Èº¯Êý void Servo_SetAngle(uint16_t angle) { //if (angle < 0) angle = 0; if (angle > 180) angle = 180; uint16_t pulse = (angle * 2000 / 180) + 500; // ½«½Ç¶Èת»»ÎªÂö³å¿í¶È TIM_SetCompare3(TIM3, pulse); } PWM.C #include "stm32f10x.h" // 通用PWM初始化函数 void PWM_Generic_Init(TIM_TypeDef* TIMx, uint16_t arr, uint16_t psc, uint16_t channel, GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) { if (TIMx == TIM3) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); } if (GPIOx == GPIOA) { RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); } else if (GPIOx == GPIOB) { RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); } else if (GPIOx == GPIOC) { RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); } GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_InitStructure.GPIO_Pin = GPIO_Pin; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOx, &GPIO_InitStructure); TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure; TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInitStructure.TIM_Period = arr; TIM_TimeBaseInitStructure.TIM_Prescaler = psc; TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIMx, &TIM_TimeBaseInitStructure); TIM_OCInitTypeDef TIM_OCInitStructure; TIM_OCStructInit(&TIM_OCInitStructure); TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; TIM_OCInitStructure.TIM_Pulse = 0; switch (channel) { case 1: TIM_OC1Init(TIMx, &TIM_OCInitStructure); TIM_OC1PreloadConfig(TIMx, TIM_OCPreload_Enable); break; case 2: TIM_OC2Init(TIMx, &TIM_OCInitStructure); TIM_OC2PreloadConfig(TIMx, TIM_OCPreload_Enable); break; // 可根据需要添加更多通道的初始化 } TIM_Cmd(TIMx, ENABLE); } //定时器3->PWM调速 周期20MS 计一个数->1US void PWM_Init(void) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //电动机PWM输出 PA6 GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &GPIO_InitStructure); TIM_InternalClockConfig(TIM3); TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure; TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInitStructure.TIM_Period = 20000 - 1; //ARR TIM_TimeBaseInitStructure.TIM_Prescaler = 72 - 1; //PSC TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStructure); TIM_OCInitTypeDef TIM_OCInitStructure; TIM_OCStructInit(&TIM_OCInitStructure); TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; TIM_OCInitStructure.TIM_Pulse = 0; //CCR TIM_OC1Init(TIM3, &TIM_OCInitStructure); //PWM输出引脚 TIM_Cmd(TIM3, ENABLE); } //电机输出比较 void PWM_SetCompare1(uint16_t Compare) { TIM_SetCompare1(TIM3, Compare); } timer.c #include "stm32f10x.h" // Device header //定时中断->1s void Timer_Init(void) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); TIM_InternalClockConfig(TIM2); TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure; TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInitStructure.TIM_Period = 10000 - 1; TIM_TimeBaseInitStructure.TIM_Prescaler = 7200 - 1; TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure); TIM_ClearFlag(TIM2, TIM_FLAG_Update); TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); NVIC_InitTypeDef NVIC_InitStructure; NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; NVIC_Init(&NVIC_InitStructure); TIM_Cmd(TIM2, ENABLE); } 代码下载进单片机以后电机不转什么原因 pwm波还是其他原因

#include "hcsr04.h" #include "delay.h" #include "usart.h" #include "lcd.h" float Distance; //距离 cm void HCSR04_Init(void) { GPIO_InitTypeDef GPIO_InitSture; EXTI_InitTypeDef EXTI_InitSture; NVIC_InitTypeDef NVIC_InitSture; //如果外部中断的话则一定使能AFIO复用功能 RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOE,ENABLE); //配置IO端口 GPIO_InitSture.GPIO_Mode = GPIO_Mode_Out_PP; //推挽输出模式 GPIO_InitSture.GPIO_Pin = HCSR04_Trig; //将PE4于Trig相连 GPIO_InitSture.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOE, &GPIO_InitSture); GPIO_InitSture.GPIO_Mode = GPIO_Mode_IPD; //下拉输入模式 GPIO_InitSture.GPIO_Pin = HCSR04_Echo; //将PE6于Echo相连 GPIO_InitSture.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOE, &GPIO_InitSture); //中断和6端口映射一起 GPIO_EXTILineConfig(GPIO_PortSourceGPIOE,GPIO_PinSource6); //外部中断配置 EXTI_InitSture.EXTI_Line=EXTI_Line6; EXTI_InitSture.EXTI_LineCmd=ENABLE; EXTI_InitSture.EXTI_Mode=EXTI_Mode_Interrupt; EXTI_InitSture.EXTI_Trigger=EXTI_Trigger_Rising; EXTI_Init(&EXTI_InitSture); //中断优先级管理 NVIC_InitSture.NVIC_IRQChannel=EXTI9_5_IRQn; NVIC_InitSture.NVIC_IRQChannelCmd=ENABLE; NVIC_InitSture.NVIC_IRQChannelPreemptionPriority=2; NVIC_InitSture.NVIC_IRQChannelSubPriority=2; NVIC_Init(&NVIC_InitSture); } void EXTI9_5_IRQHandler(void) { delay_us(10); if(EXTI_GetITStatus(EXTI_Line6)!=RESET) { TIM_SetCounter(TIM3,0); //开始计数 TIM_Cmd(TIM3,ENABLE); //使能 while(ECHO_DQ_IN); //等待低电平GPIO_ReadInputDataBit(GPIOE, HCSR04_Echo) TIM_Cmd(TIM3,DISABLE); //关闭 Distance=TIM_GetCounter(TIM3)*340/200.0; if(Distance>0) { //printf("Distance:%f cm\r\n",Distance); LCD_ShowNum(30+40,120,Distance,3,16); } EXTI_ClearITPendingBit(EXTI_Line6); } } void HCSR04_Strat(void) { GPIO_SetBits(GPIOE, HCSR04_Trig); //将Trig设置为高电平 delay_us(20); //持续大于10us触发,触发超声波模块工作 GPIO_ResetBits(GPIOE, HCSR04_Trig); }

#include "stm32f10x.h" #include "delay.h" #include "HCSR04.h" #include "sys.h" #include <stdio.h> // 全局变量 static u32 cnt = 0; // 定时器溢出计数 // 定时器2初始化 static void TIM2_Int_Init(u16 arr, u16 psc) { TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure; NVIC_InitTypeDef NVIC_InitStructure; RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); // 使能TIM2时钟 // 定时器TIM2初始化 TIM_TimeBaseStructure.TIM_Period = arr; // 自动重装载值 TIM_TimeBaseStructure.TIM_Prescaler = psc; // 预分频值 TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); // 允许更新中断 // 中断优先级配置 NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); TIM_Cmd(TIM2, DISABLE); // 先关闭定时器 } // HCSR04初始化 void HCSR04_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; // 使能GPIO时钟 RCC_APB2PeriphClockCmd(TRIG_RCC | ECHO_RCC | RCC_APB2Periph_AFIO, ENABLE); // 配置TRIG引脚(PC13)为推挽输出 GPIO_InitStructure.GPIO_Pin = TRIG_PIN; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(TRIG_PORT, &GPIO_InitStructure); Trig_Low(); // 初始为低电平 // 配置ECHO引脚(PB0)为浮空输入 GPIO_InitStructure.GPIO_Pin = ECHO_PIN; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(ECHO_PORT, &GPIO_InitStructure); // 初始化定时器(72分频,1MHz计数频率,溢出值11) TIM2_Int_Init(11, 72); } // 发送触发信号 static void HCSR04_Start(void) { Trig_High(); delay_us(HCSR04_TRIG_PULSE_US); // 发送触发脉冲 Trig_Low(); } // 获取距离测量值(单次测量) _Bool HCSR04_GetDistance(unsigned int *distance) { u32 time = 0; unsigned char Err = 0; unsigned int S = 0; const u32 min_time = (HCSR04_MIN_DISTANCE_CM * 10000) / 173; // 计算最小时间 // 确保参数有效 if(distance == NULL) return 1; HCSR04_Start(); // 发送触发信号 cnt = 0; // 重置溢出计数 TIM_SetCounter(TIM2, 0); // 重置定时器计数 // 等待ECHO变为高电平(超时判断) u32 wait_high = 0; while(Echo_State() == 0) { wait_high++; delay_us(1); if(wait_high > HCSR04_WAIT_HIGH_US) // 等待高电平超时 { return 1; } } // 开始计时 TIM_Cmd(TIM2, ENABLE); // 等待ECHO变为低电平(超时判断) while(Echo_State() == 1) { time = cnt * 12 + TIM2->CNT; // 计算时间(12us为溢出周期) if(time > HCSR04_TIMEOUT_US) // 超时 { TIM_Cmd(TIM2, DISABLE); return 1; } } // 停止计时 TIM_Cmd(TIM2, DISABLE); time = cnt * 12 + TIM2->CNT; // 最终时间计算 // 距离计算与校验 if(time < min_time) // 小于最小距离 { Err = 1; } else { S = (time * 173) / 10000; // 计算距离(cm),173=346/2 if(S > HCSR04_MAX_DISTANCE_CM) // 超过最大测量范围 { Err = 1; } else { *distance = S; } } return Err; } // 带重试机制的距离测量(提高可靠性) _Bool HCSR04_GetDistanceWithRetry(unsigned int *distance, uint8_t retry_count) { uint8_t retries = 0; // 多次尝试测量,直到成功或重试次数用尽 while(retries < retry_count) { if(HCSR04_GetDistance(distance) == 0) { return 0; // 测量成功 } retries++; delay_ms(10); // 重试前短暂延时 } return 1; // 多次重试后仍失败 } // 定时器2中断服务函数(用于计数溢出) void TIM2_IRQHandler(void) { if(TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET) { TIM_ClearITPendingBit(TIM2, TIM_IT_Update); cnt++; // 溢出次数加1 } } #ifndef __HCSR04_H #define __HCSR04_H #include "stm32f10x.h" // 引脚定义(TRIG=PC13,ECHO=PB0) #define TRIG_PORT GPIOC #define TRIG_PIN GPIO_Pin_13 #define TRIG_RCC RCC_APB2Periph_GPIOC #define ECHO_PORT GPIOB #define ECHO_PIN GPIO_Pin_0 #define ECHO_RCC RCC_APB2Periph_GPIOB // 传感器参数配置(可根据需要调整) #define HCSR04_TRIG_PULSE_US 20 // 触发脉冲宽度(us) #define HCSR04_MAX_DISTANCE_CM 450 // 最大测量距离(cm) #define HCSR04_MIN_DISTANCE_CM 2 // 最小测量距离(cm) #define HCSR04_TIMEOUT_US 40000 // 超时时间(us) #define HCSR04_WAIT_HIGH_US 10000 // 等待高电平超时(us) // 简化引脚操作的宏 #define Trig_High() GPIO_SetBits(TRIG_PORT, TRIG_PIN) #define Trig_Low() GPIO_ResetBits(TRIG_PORT, TRIG_PIN) #define Echo_State() GPIO_ReadInputDataBit(ECHO_PORT, ECHO_PIN) // 函数声明 void HCSR04_Init(void); _Bool HCSR04_GetDistance(unsigned int *distance); _Bool HCSR04_GetDistanceWithRetry(unsigned int *distance, uint8_t retry_count); #endif 测量失败

#include "ultrasonic.h" #include "timer.h" /*****************辰哥单片机设计****************** STM32 * 文件 : HC-SR04超声波传感器c文件 * 版本 : V1.0 * 日期 : 2024.8.27 * MCU : STM32F103C8T6 * 接口 : 见代码 * BILIBILI : 辰哥单片机设计 * CSDN : 辰哥单片机设计 * 作者 : 辰哥 **********************BEGIN***********************/ //超声波计数 u16 msHcCount; void Ultrasonic_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; RCC_APB2PeriphClockCmd (ULTRASONIC_GPIO_CLK, ENABLE ); // 打开连接 超声波传感器 的单片机引脚端口时钟 GPIO_InitStructure.GPIO_Pin = ULTRASONIC_TRIG_GPIO_PIN; // 配置连接 传感器TRIG 的单片机引脚模式 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // 设置为推挽输出 GPIO_Init(ULTRASONIC_GPIO_PORT, &GPIO_InitStructure); // 初始化 GPIO_InitStructure.GPIO_Pin = ULTRASONIC_ECHO_GPIO_PIN; // 配置连接 传感器ECHO 的单片机引脚模式 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; // 设置为浮空输入输入 GPIO_Init(ULTRASONIC_GPIO_PORT, &GPIO_InitStructure); // 初始化 TIM4_Int_Init(1000-1,72-1); } //打开定时器4 static void OpenTimerForHc() { TIM_SetCounter(TIM4,0); msHcCount = 0; TIM_Cmd(TIM4, ENABLE); } //关闭定时器4 static void CloseTimerForHc() { TIM_Cmd(TIM4, DISABLE); } //获取定时器4计数器值 u32 GetEchoTimer(void) { u32 t = 0; t = msHcCount*1000; t += TIM_GetCounter(TIM4); TIM4->CNT = 0; delay_ms(50); return t; } //通过定时器4计数器值推算距离 float UltrasonicGetLength(void) { u32 t = 0; int i = 0; float lengthTemp = 0; float sum = 0; while(i!=5) { TRIG_Send = 1; delay_us(20); TRIG_Send = 0; while(ECHO_Reci == 0); OpenTimerForHc(); i = i + 1; while(ECHO_Reci == 1); CloseTimerForHc(); t = GetEchoTimer(); lengthTemp = ((float)t/58.0);//cm sum = lengthTemp + sum ; } lengthTemp = sum/5.0; return lengthTemp; }优化这个代码

最新推荐

recommend-type

aggregator_2.13-0.0.72-sources.jar

aggregator_2.13-0.0.72-sources.jar
recommend-type

arc-graphql-spring-boot-starter-0.81.0.jar

arc-graphql-spring-boot-starter-0.81.0.jar
recommend-type

Odoo与WooCommerce双向数据同步解决方案

在探讨Odoo与WooCommerce连接器模块之前,需要先了解几个关键的IT概念,比如Odoo,WooCommerce,ERP系统,以及如何将它们通过一个名为“connector-woocommerce”的Python模块整合在一起。 ### Odoo与WooCommerce的连接 **Odoo** 是一个全面的企业资源规划(ERP)软件包,用于管理企业中的所有业务流程。它包含了一系列的模块,覆盖了从会计、库存管理到电子商务和客户关系管理的各个方面。Odoo强大的模块化系统使其可以高度定制化,以适应不同企业的特定需求。 **WooCommerce** 是一个开源的电子商务解决方案,主要设计用于集成WordPress,是目前使用最广泛的电子商务平台之一。它能够提供完整的在线商店功能,并且可以通过众多插件进行扩展,以满足不同的业务需求。 ### ERP系统与电子商务的整合 在现代商务环境中,ERP系统和电子商务平台需要紧密集成。ERP系统负责内部业务流程的管理,而电子商务平台则负责与客户的直接交互,包括产品展示、订单处理、支付处理等。当两者被整合在一起时,它们可以提供无缝的工作流,例如实时库存同步、自动更新订单状态、以及统一的客户数据管理。 ### WooCommerceERPconnect **WooCommerceERPconnect**,也即“connector-woocommerce”,是一款专为连接Odoo ERP系统与WooCommerce电子商务平台设计的双向连接器。这个模块能够使得Odoo中的产品信息、订单信息、库存信息以及客户信息能够实时地同步到WooCommerce中。同样,从WooCommerce平台接收到的订单也可以实时地传输并反映到Odoo系统内。这样一来,企业可以确保他们的ERP系统和在线商店始终保持信息的一致性,极大地提高了业务效率和客户满意度。 ### 连接器的兼容性和实现方式 提到该连接器与**OpenERP 8.0** 和 **WooCommerce 2.4.x** 100% 兼容,说明开发团队在设计时考虑了特定版本间的兼容性问题,确保了连接器能够在这些版本上正常工作。考虑到Odoo是由OpenERP发展而来,它强调了此连接器是为最新版本的Odoo所设计,以确保能利用Odoo提供的最新功能。 **Python** 在这里扮演了重要的角色,因为Python是Odoo的开发语言,并且在连接器模块中也广泛使用。Python的易用性、灵活性以及丰富的库支持,使得开发者能够快速开发出功能强大的模块。该连接器模块很可能使用了Python进行后端逻辑处理,借助Odoo提供的API与WooCommerce进行数据交互。 ### 文件压缩包内容 关于提供的**connector-woocommerce-8.0** 压缩包,这显然是一个专为Odoo版本8.0设计的WooCommerce连接器。文件包内可能包括了所有必要的安装文件、配置脚本、以及可能的文档说明。安装这样的模块通常需要对Odoo有一定的了解,包括如何部署新模块,以及如何配置模块以确保其能够正确与WooCommerce通信。 ### 实施电子商务与ERP整合的考虑因素 企业实施ERP与电子商务整合时,需考虑以下因素: - **数据同步**:确保产品数据、库存数据、价格、订单信息等在Odoo和WooCommerce之间实时准确地同步。 - **安全性和稳定性**:在数据传输和处理过程中保障数据安全,并确保整合后的系统稳定运行。 - **扩展性**:随着业务的扩展,连接器需要能够适应更多的用户、更多的产品和更复杂的数据交互。 - **维护和更新**:连接器需要定期维护和更新,以适应Odoo和WooCommerce的版本迭代。 在进行整合时,可能需要进行定制开发以适应特定的业务逻辑和工作流程。这往往涉及到对Odoo或WooCommerce API的深入了解,并可能需要调整连接器的源代码以满足特殊需求。 ### 总结 通过Odoo连接器WooCommerce模块的使用,企业可以有效地整合其ERP系统与电子商务平台,实现数据的一体化管理,提高工作效率,优化客户体验。而这一切的实现,都离不开对Odoo、WooCommerce以及连接器背后的技术栈(如Python)的深入理解。
recommend-type

Linux系统运维知识大揭秘

### Linux 系统运维知识大揭秘 #### 1. 标准输入、输出与错误 在 Linux 系统中,标准输入(STDIN)、标准输出(STDOUT)和标准错误(STDERR)是非常基础且重要的概念。 |名称|默认目标|重定向使用|文件描述符编号| | ---- | ---- | ---- | ---- | |STDIN|计算机键盘|< (等同于 0<)|0| |STDOUT|计算机显示器|> (等同于 1>)|1| |STDERR|计算机显示器|2>|2| 常见的 Bash 重定向器如下: |重定向器|解释| | ---- | ---- | |> (等同于 1>)|重定向 STDOUT。
recommend-type

int arr1[4] = {1,2,3,4}; int arr2[4] = { 1,2 }; int arr[4] = {0];//所有元素为0 static int arr3[3]; int arr4[4]; cout << "arr1:"<<arr1[0] << arr1[1] << arr1[2] << arr1[3] << endl; cout << "arr2:" << arr2[0] << arr2[1] << arr2[2] << arr2[3] << endl; cout << "arr3:" << arr3[0] << arr3[1] << arr3[2] << arr3[3] << endl; cout << "arr4:" << arr4[0] << arr4[1] << arr4[2] << arr4[3] << endl;

### C++ 中数组的初始化与未初始化元素的默认值行为 在 C++ 中,数组的初始化行为取决于其类型(如内置数组、`std::array` 或 `std::vector`)以及使用的初始化语法。以下是对不同情况的详细分析。 #### 内置数组的初始化与默认值 对于内置数组(如 `int arr[10];`),如果未显式初始化,则其元素的值是未定义的。这意味着这些元素可能包含任意的垃圾值,具体取决于编译器和运行环境。例如: ```cpp int arr[10]; // 未初始化,元素值未定义 ``` 如果希望所有元素初始化为零,可以使用值初始化语法: ```cpp int arr[
recommend-type

基于Lerna和Module Federation的Micro前端架构

### 知识点一:微前端架构(microfrontend) 微前端是一种架构设计风格,它将一个大型前端应用拆分成多个较小的独立前端应用,每个独立的前端应用可以被单独开发、部署和扩展。微前端架构有助于团队的独立工作,降低了大规模项目的技术债务,提高了系统的可维护性和可扩展性。 #### 关键概念: 1. **独立自治:** 每个微前端都可以独立于整体应用进行开发、测试和部署。 2. **技术多样性:** 不同的微前端可以使用不同的前端技术栈。 3. **共享基础设施:** 为了保持一致性,微前端之间可以共享工具、框架和库。 4. **通信机制:** 微前端之间需要有通信机制来协调它们的行为。 ### 知识点二:Lerna Lerna 是一个优化了多包管理的 JavaScript 库,专用于维护具有多个包的大型JavaScript项目。Lerna 可以帮助开发者在一个仓库中管理多个包,减少重复的构建步骤,并且在包之间共享依赖。 #### 核心功能: 1. **作用域包管理:** Lerna 可以帮助开发者创建和管理仓库中的本地作用域包。 2. **自动链接:** 自动链接内部依赖,减少开发中的配置复杂性。 3. **版本管理:** 方便地处理多包项目的版本发布和变更。 4. **并行构建:** 加速构建过程,因为可以并行地构建多个包。 ### 知识点三:Module Federation Module Federation 是 Webpack 5 引入的一个实验性功能,它允许运行时从多个构建中动态加载代码。这使得在不同的前端应用之间共享模块成为可能,这是实现微前端架构的关键技术。 #### 关键特性: 1. **远程和本地模块共享:** 它不仅可以在应用程序之间共享模块,还可以在应用程序内部进行模块共享。 2. **代码分割:** 可以实现更好的代码分割和懒加载。 3. **独立部署:** 允许独立部署,由于模块是动态加载的,对应用程序的更改不需要重新部署整个应用。 4. **热模块替换:** 可以在不刷新页面的情况下替换模块。 ### 知识点四:Yarn 和 npm 包管理器 Yarn 和 npm 是 JavaScript 社区中最流行的两个包管理器,它们用于安装、更新和管理项目依赖。 #### Yarn: 1. **速度:** Yarn 在安装依赖时具有更快的速度。 2. **确定性:** 通过使用 lock 文件确保依赖安装的一致性。 3. **离线缓存:** Yarn 缓存了安装的每个包,以便在离线模式下工作。 #### npm: 1. **广泛性:** npm 是 JavaScript 社区中最广泛使用的包管理器。 2. **生态系统:** npm 拥有一个庞大且活跃的生态系统,提供了大量可用的包。 ### 知识点五:monorepo Monorepo 是一种源代码管理策略,其中所有项目代码都位于同一个仓库中。与多仓库(每个项目一个仓库)相反,monorepo 管理方式可以在整个项目的上下文中共享和管理代码。 #### monorepo 的优势: 1. **代码共享:** 项目之间可以共享代码库,便于代码复用。 2. **集中管理:** 统一的依赖管理和版本控制。 3. **项目间依赖清晰:** 项目间依赖关系透明,便于维护和开发。 ### 知识点六:工作区(Workspaces) 工作区是 monorepo 的一个重要组成部分,它允许一个仓库中包含多个包或项目。每个工作区可以有自己的 `package.json` 和依赖项,并且可以互相引用,简化了复杂项目的依赖管理。 #### 工作区特点: 1. **依赖管理:** 允许工作区依赖于仓库中的其他包。 2. **扁平化依赖:** 可以确保依赖项只被安装一次,节省了空间并减少了重复。 3. **开发流程简化:** 工作区设置简化了开发流程,允许同时工作在多个项目或包上。 ### 实际操作指令解读 1. **初始化项目:** - `yarn install` 或 `npm install`:安装依赖,根据仓库设置的不同可能包括 Lerna 或其他依赖。 2. **开发模式:** - `yarn develop` 或 `npm run develop`:启动开发服务器,对于带有预览的情况,可以使用 `WITH_PREVIEWS=1 yarn develop`。 3. **构建和启动单个远程生产版本:** - `yarn clean` 清除之前的构建。 - `yarn single:build` 单独构建生产版本。 - `yarn single:start` 启动生产服务器。 4. **构建和启动多个远程生产版本:** - `yarn multi:build` 构建多个生产版本。 - `yarn multi:start` 启动多版本生产服务器。 5. **构建镜像:** - `yarn docker:build` 使用 Yarn 构建 Docker 镜像。 以上操作指令展示了如何在使用 Lerna 和 Module Federation 的微前端 monorepo 环境下进行项目的初始化、开发、构建和部署,使用 Yarn 和 npm 工作区来优化多项目依赖管理与构建流程。
recommend-type

RHCSA实践考试及相关知识汇总

# RHCSA 实践考试及相关知识汇总 ## 一、实践考试说明 ### (一)通用注意事项 为确保考试在干净的环境中开始,需遵循以下提示: - 无需任何外部服务器或资源。 - 不要注册或连接任何外部存储库。 - 根据每个实践考试的说明安装新的虚拟机。 - 这些实践考试不提供示例解决方案,在实际考试中,你需要能够自行验证解决方案。 - 应能在两小时内完成每个考试。 ### (二)实践考试 C 内容 1. **安装虚拟机**:安装一个 RHEL 8 或 CentOS 8 虚拟机,要求如下: - 2GB 内存。 - 使用默认分区,20GB 磁盘空间。 - 一个额外的 20
recommend-type

'EOF' 现在,告诉我,eof左右俩边的标点

在 Bash 脚本或 Shell 编程中,`EOF` 通常用于 here document 语法结构中,表示一段多行文本的结束标记。在该结构中,`EOF` 左右两边的标点符号具有特定的语法意义。 ### `EOF` 左边的标点符号 `EOF` 左边通常使用 `<<` 这一组合符号作为重定向操作符,表示开始一个 here document。这一操作符紧接在命令之后,用于指示 Shell 接下来的输入将被视为输入流,直到遇到指定的结束标记(如 `EOF`)为止。例如: ```bash cat << EOF This is a test. EOF ``` 在上述示例中,`<<` 出现在 `E
recommend-type

构建智能银行聊天机器人:Watson Assistant与情绪分析

### 知识点 #### 概述 在给定的文件信息中,我们关注的是通过使用IBM Watson服务,如何构建一个银行行业的聊天机器人。该机器人整合了Watson Assistant、自然语言理解(NLU)、Tone Analyzer以及Watson Discovery服务,目的是提高客户互动体验,并能够应对常见问题解答和情绪检测等复杂场景。 #### 标题中的知识点 1. **Watson Assistant** Watson Assistant是IBM提供的一个以AI为基础的对话式客户服务工具,它允许开发者构建能够与用户进行自然语言交互的聊天机器人。Watson Assistant的核心优势在于其能够理解和预测用户的意图,并且可以学习并适应用户与之对话的方式。 2. **自然语言理解(NLU)** 自然语言理解是人工智能的一个分支,它专注于使计算机能够理解和处理人类语言。在这个项目中,NLU被用来识别和分析用户输入中的位置实体,这样机器人能够更精确地提供相关的服务或信息。 3. **Tone Analyzer服务** Tone Analyzer是IBM Watson的另一项服务,它运用情绪分析技术来检测文本中的情绪色彩。在聊天机器人应用中,通过Tone Analyzer可以判断用户的情绪状态,比如是否感到愤怒或沮丧,从而使得聊天机器人能够做出相应的反馈。 4. **聊天机器人** 聊天机器人是一种软件应用,旨在模拟人类对话,可以通过文本或语音识别,对用户的输入进行处理,并作出响应。在这里,聊天机器人应用于银行业务,以实现快速响应客户的查询和问题。 #### 描述中的知识点 1. **Node.js** Node.js是一个基于Chrome V8引擎的JavaScript运行时环境,它使得JavaScript能够用于服务器端开发。在构建聊天机器人时,Node.js可以用来创建Web UI界面,通过它可以实现用户与聊天机器人的互动。 2. **常见问题发现** 在聊天机器人的上下文中,常见问题发现指的是系统识别并回答客户经常提出的问题。这通常是通过预先设定的问题-答案对来实现的。 3. **愤怒检测** 愤怒检测是聊天机器人使用Tone Analyzer服务的一项功能,用于分析用户输入的语气,判断其是否含有负面情绪。这样机器人可以采取适当的行动,例如将对话转接给人工客服。 4. **FAQ文档中的段落检索** 在聊天机器人中,当客户的问题不能通过预设的答案解决时,需要从文档集合中检索相关信息。段落检索是一种高级搜索技术,用于从大量文档中快速找到最符合用户查询的部分。 #### 标签中的知识点 1. **IBM Cloud** IBM Cloud,先前称为Bluemix,是IBM提供的一套云计算服务,支持包括Watson服务在内的各种应用和服务的部署和运行。 2. **IBM Developer Technology** 这指的是IBM为开发者提供的技术和资源集合,其中包括IBM Watson服务和开发者可以利用的工具包。 3. **IBM Code** IBM Code是IBM倡导的开源项目和代码分享平台,旨在推动开发者社区通过共享代码实现创新。 4. **JavaScript** JavaScript是一种广泛用于网页开发的编程语言,也是Node.js的开发语言,它在构建聊天机器人时起到了前端逻辑处理的关键作用。 #### 压缩包子文件的文件名称列表中的知识点 1. **watson-banking-chatbot-master** 文件名称表明这是一个主项目文件夹,包含构建银行聊天机器人的所有源代码、资源文件及配置。"master"一词暗示这是项目的主分支或主版本。 综合以上信息,开发者将学习到如何利用IBM Watson平台提供的不同AI服务,结合Node.js来创建一个功能完善的银行服务聊天机器人。通过这个过程,开发者会掌握在IBM Cloud上部署和运行聊天机器人所需的知识和技能,同时了解到如何利用NLU服务进行实体识别,如何使用Tone Analyzer服务进行情绪分析,以及如何通过Watson Discovery服务检索FAQ相关的信息。
recommend-type

Linux技术术语全面解析

# Linux技术术语全面解析 ## 1. 基础概念 ### 1.1 变量与路径 - **$PATH**:一个变量,包含了用户输入命令时系统搜索可执行文件的目录列表。 - **.(当前目录)**:可使用`pwd`命令获取其值。 ### 1.2 文件与目录 - **绝对文件名**:完整的文件名,以根目录名开头,包含直至当前文件或目录的所有目录。 - **目录(Directory)**:文件系统中用于有组织地存储文件的文件夹。 ### 1.3 权限与访问控制 - **访问控制列表(ACL)**:在Linux权限管理中,该系统允许为多个用户和多个组授予权限,管理员还能为特定目录设置默认权限。