设计一个计算器，通过键盘输入 0~9 的数 字，以及运算法则加减乘除，能通过串口 在电脑端串口调试软件上显示运算结果STM32mini版的工程代码（要求分别写出主函数文件和头文件和.c文件）

头文件 calculator.h：

#ifndef __CALCULATOR_H
#define __CALCULATOR_H

#include "stm32f1xx_hal.h"

// 定义计算器状态
typedef enum {
  CALCULATOR_STATE_INIT,   // 初始化状态
  CALCULATOR_STATE_NUM1,   // 输入第一个数字状态
  CALCULATOR_STATE_OP,     // 输入操作符状态
  CALCULATOR_STATE_NUM2,   // 输入第二个数字状态
  CALCULATOR_STATE_RESULT  // 显示结果状态
} CalculatorState;

// 定义计算器结构体
typedef struct {
  CalculatorState state;   // 当前状态
  uint8_t num1;            // 第一个数字
  uint8_t op;              // 操作符：+、-、*、/
  uint8_t num2;            // 第二个数字
  uint8_t result;          // 运算结果
} Calculator;

// 初始化计算器
void Calculator_Init(Calculator *calculator);

// 输入数字
void Calculator_InputNumber(Calculator *calculator, uint8_t number);

// 输入操作符
void Calculator_InputOperator(Calculator *calculator, uint8_t op);

// 计算结果
void Calculator_Calculate(Calculator *calculator);

#endif /* __CALCULATOR_H */

.c文件 calculator.c：

#include "calculator.h"

void Calculator_Init(Calculator *calculator) {
  calculator->state = CALCULATOR_STATE_INIT;
}

void Calculator_InputNumber(Calculator *calculator, uint8_t number) {
  switch (calculator->state) {
    case CALCULATOR_STATE_INIT:
      calculator->num1 = number;
      calculator->state = CALCULATOR_STATE_NUM1;
      break;
    case CALCULATOR_STATE_NUM1:
      calculator->num1 = calculator->num1 * 10 + number;
      break;
    case CALCULATOR_STATE_OP:
      calculator->num2 = number;
      calculator->state = CALCULATOR_STATE_NUM2;
      break;
    case CALCULATOR_STATE_NUM2:
      calculator->num2 = calculator->num2 * 10 + number;
      break;
    default:
      break;
  }
}

void Calculator_InputOperator(Calculator *calculator, uint8_t op) {
  if (calculator->state == CALCULATOR_STATE_NUM1) {
    calculator->op = op;
    calculator->state = CALCULATOR_STATE_OP;
  }
}

void Calculator_Calculate(Calculator *calculator) {
  switch (calculator->op) {
    case '+':
      calculator->result = calculator->num1 + calculator->num2;
      break;
    case '-':
      calculator->result = calculator->num1 - calculator->num2;
      break;
    case '*':
      calculator->result = calculator->num1 * calculator->num2;
      break;
    case '/':
      if (calculator->num2 != 0) {
        calculator->result = calculator->num1 / calculator->num2;
      }
      break;
    default:
      break;
  }
  calculator->state = CALCULATOR_STATE_RESULT;
}

主函数文件 main.c：

#include "main.h"
#include "calculator.h"

UART_HandleTypeDef huart2;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);

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

  MX_GPIO_Init();
  MX_USART2_UART_Init();

  Calculator calculator;
  Calculator_Init(&calculator);

  uint8_t buffer[32];
  uint8_t index = 0;

  while (1) {
    uint8_t ch;
    HAL_StatusTypeDef status = HAL_UART_Receive(&huart2, &ch, 1, 100);
    if (status == HAL_OK) {
      if (ch >= '0' && ch <= '9') {
        Calculator_InputNumber(&calculator, ch - '0');
      } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
        Calculator_InputOperator(&calculator, ch);
      } else if (ch == '=') {
        Calculator_Calculate(&calculator);
        sprintf((char *)buffer, "Result: %d\r\n", calculator.result);
        HAL_UART_Transmit(&huart2, buffer, strlen((char *)buffer), 100);
        Calculator_Init(&calculator);
      } else {
        Calculator_Init(&calculator);
      }
    }
  }
}

void SystemClock_Config(void) {
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {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.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  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_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

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

static void MX_USART2_UART_Init(void) {
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  if (HAL_UART_Init(&huart2) != HAL_OK) {
    Error_Handler();
  }
}

static void MX_GPIO_Init(void) {
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
}

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

#ifdef  USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line) {}
#endif