帮我写一段程序，stm32单片机，当按下按键B2超过2秒时，实现串口通信功能，向串口发送“无信号输出”

### 回答1：
下面是一个简单的程序，实现了按下B2超过2秒后通过串口发送“无信号输出”的功能。需要注意的是，这里使用了HAL库中的时间延时函数`HAL_Delay()`，因此需要在程序中开启HAL库的支持。

#include "stm32f1xx_hal.h"
#include "stdio.h"

UART_HandleTypeDef huart1;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);

int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_USART1_UART_Init();

  while (1)
  {
    if (HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_RESET)
    {
      HAL_Delay(2000);
      if (HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_RESET)
      {
        char str[] = "无信号输出";
        HAL_UART_Transmit(&huart1, (uint8_t*)str, strlen(str), HAL_MAX_DELAY);
      }
    }
  }
}

void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage 
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_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();
  }
  /** 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_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_USART1_UART_Init(void)
{
  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;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  __HAL_RCC_GPIOC_CLK_ENABLE();

  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);

  GPIO_InitStruct.Pin = GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
}

void Error_Handler(void)
{
  while(1) {}
}

在这个程序中，我们首先初始化了GPIO和串口。然后进入了一个无限循环，一直检测按键B2是否被按下。如果B2被按下，程序会延时2秒钟，然后再次检测B2是否被按下。如果B2被按下超过2秒钟，则通过串口发送“无信号输出”这个字符串。

### 回答2：
你好！
下面是一个使用STM32单片机的程序来实现你的需求。在这个程序中，我们使用了一个定时器来测量按键B2的按下时间，并在超过2秒时触发串口通信功能。我们将使用的串口通信模块为USART1，波特率设置为115200。

#include "stm32f10x.h"

void delay_ms(uint32_t ms)
{
// 使用系统滴答定时器延迟ms毫秒
ms *= 1000;
ms /= (SystemCoreClock / 1000);
SysTick_Config(SystemCoreClock / 1000);
while (ms--) {
while (!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk));
}
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
}

int main()
{
// 初始化GPIO和串口
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO | RCC_APB2Periph_USART1, ENABLE);
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0; // B2按键连接到GPIOA的Pin 0
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOA, &GPIO_InitStruct);

USART_InitTypeDef USART_InitStruct;
USART_InitStruct.USART_BaudRate = 115200;
USART_InitStruct.USART_WordLength = USART_WordLength_8b;
USART_InitStruct.USART_StopBits = USART_StopBits_1;
USART_InitStruct.USART_Parity = USART_Parity_No;
USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStruct.USART_Mode = USART_Mode_Tx;
USART_Init(USART1, &USART_InitStruct);
USART_Cmd(USART1, ENABLE);

while (1) {
// 检测按键B2是否按下
if (!GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0)) {
// 延迟2秒进行按键按下时间的测量
delay_ms(2000);

// 如果按键B2仍然按下，则触发串口通信功能
if (!GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0)) {
USART_SendData(USART1, '无');
delay_ms(10);
USART_SendData(USART1, '信');
delay_ms(10);
USART_SendData(USART1, '号');
delay_ms(10);
USART_SendData(USART1, '出');
delay_ms(10);
USART_SendData(USART1, '力');
delay_ms(10);
USART_SendData(USART1, '输');
delay_ms(10);
USART_SendData(USART1, '。');
delay_ms(10);
}
}
}
}

以上就是程序的基本框架，它可以实现当按下按键B2超过2秒时，通过串口向外发送"无信号输出"。你可以根据自己的需求对程序进行修改和优化。希望对你有所帮助，祝你成功！

### 回答3：
您好！以下是一个使用STM32单片机的程序，当按下按键B2超过2秒时，实现串口通信功能，向串口发送"无信号输出"的程序代码：

#include "stm32f1xx_hal.h"

/* 定义串口号和波特率 */
#define UART_HANDLER huart1
#define BAUDRATE    9600

/* 定义按键和LED的引脚 */
#define BUTTON_PIN GPIO_PIN_0
#define BUTTON_PORT GPIOA
#define LED_PIN GPIO_PIN_5
#define LED_PORT GPIOA

/* 定义计时器的参数 */
#define TIMER_PERIOD 2000  // 2秒
#define TIMER_PRESCALER ((SystemCoreClock / 10000) - 1)  // 根据系统时钟设置分频系数

/* 定义全局变量 */
UART_HandleTypeDef UART_HANDLER;
uint8_t button_pressed = 0;  // 按键是否按下标志
uint32_t timer_counter = 0;  // 计时器计数值

/* 按键B2的中断处理函数 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if(GPIO_Pin == BUTTON_PIN)
  {
    button_pressed = 1;
  }
}

/* 系统时钟初始化 */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct;
  RCC_ClkInitTypeDef RCC_ClkInitStruct;

  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI_DIV2;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL16;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  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_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* 调试UART初始化 */
void UART_Init(void)
{
  UART_HANDLER.Instance = USART1;
  UART_HANDLER.Init.BaudRate = BAUDRATE;
  UART_HANDLER.Init.WordLength = UART_WORDLENGTH_8B;
  UART_HANDLER.Init.StopBits = UART_STOPBITS_1;
  UART_HANDLER.Init.Parity = UART_PARITY_NONE;
  UART_HANDLER.Init.Mode = UART_MODE_TX;
  UART_HANDLER.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  UART_HANDLER.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&UART_HANDLER) != HAL_OK)
  {
    Error_Handler();
  }

  if (HAL_UART_Transmit(&UART_HANDLER, (uint8_t *)"UART Initialized...\r\n", 22, HAL_MAX_DELAY) != HAL_OK)
  {
    Error_Handler();
  }
}

/* 初始化GPIO */
void GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct;

  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_AFIO_CLK_ENABLE();

  /* 配置按键B2的GPIO为输入，上拉 */
  GPIO_InitStruct.Pin = BUTTON_PIN;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(BUTTON_PORT, &GPIO_InitStruct);

  HAL_NVIC_SetPriority(EXTI0_IRQn, 1, 0);
  HAL_NVIC_EnableIRQ(EXTI0_IRQn);

  /* 配置LED引脚的GPIO为输出推挽 */
  GPIO_InitStruct.Pin = LED_PIN;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LED_PORT, &GPIO_InitStruct);

  /* 配置USART1 TX引脚的GPIO为复用推挽 */
  GPIO_InitStruct.Pin = GPIO_PIN_9;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

/* 初始化定时器 */
void Timer_Init(void)
{
  TIM_HandleTypeDef TIM_Handler;
  TIM_Base_InitTypeDef TIM_BaseInitStruct;

  __HAL_RCC_TIM4_CLK_ENABLE();

  TIM_Handler.Instance = TIM4;
  TIM_Handler.Init.Prescaler = TIMER_PRESCALER;
  TIM_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;
  TIM_Handler.Init.Period = TIMER_PERIOD;
  TIM_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  if (HAL_TIM_Base_Init(&TIM_Handler) != HAL_OK)
  {
    Error_Handler();
  }

  HAL_NVIC_SetPriority(TIM4_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(TIM4_IRQn);

  TIM_BaseInitStruct.Prescaler = TIMER_PRESCALER;
  TIM_BaseInitStruct.CounterMode = TIM_COUNTERMODE_UP;
  TIM_BaseInitStruct.Period = TIMER_PERIOD;
  TIM_BaseInitStruct.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  if (HAL_TIM_Base_Init(&TIM_Handler) != HAL_OK)
  {
    Error_Handler();
  }
}

/* 启动定时器 */
void Timer_Start(void)
{
  __HAL_TIM_CLEAR_IT(&TIM_Handle, TIM_IT_UPDATE);
  HAL_TIM_Base_Start_IT(&TIM_Handle);
}

/* 处理定时器中断 */
void TIM4_IRQHandler(void)
{
  if (__HAL_TIM_GET_FLAG(&TIM_Handle, TIM_FLAG_UPDATE) != RESET)
  {
    if (__HAL_TIM_GET_IT_SOURCE(&TIM_Handle, TIM_IT_UPDATE) != RESET)
    {
      __HAL_TIM_CLEAR_IT(&TIM_Handle, TIM_IT_UPDATE);
      
      timer_counter++;

      if (timer_counter >= 2)
      {
        HAL_TIM_Base_Stop_IT(&TIM_Handle);
        HAL_UART_Transmit(&UART_HANDLER, (uint8_t *)"无信号输出\r\n", 12, HAL_MAX_DELAY);
        HAL_UART_Transmit(&UART_HANDLER, (uint8_t *)"等待按键...\r\n", 12, HAL_MAX_DELAY);
        HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_RESET);
      }
    }
  }
}

/* 系统初始化 */
void System_Init(void)
{
  HAL_Init();
  SystemClock_Config();
  GPIO_Init();
  UART_Init();
  Timer_Init();
  Timer_Start();
  HAL_UART_Transmit(&UART_HANDLER, (uint8_t *)"等待按键...\r\n", 12, HAL_MAX_DELAY);
}

int main(void)
{
  System_Init();

  while (1)
  {
    if (button_pressed)
    {
      button_pressed = 0;
      timer_counter = 0;
      HAL_TIM_Base_Start_IT(&TIM_Handle);
      HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_SET);
    }
  }
}

希望对您有所帮助！