用STM32设计LED灯花色系统，要求完成以下内容：
1.使8个led灯以流水灯的形式进行闪烁（每个LED灯亮100ms后熄灭并使下一个LED灯点亮
2.通过key1改变led灯花型，要求至少设计3种花型（含要求1中花型)
3.通过key2强制复位当前花型为要求1中花型
4.每次按键切换花型后，通过串口助手每隔500ms输出当前花型内容
GPIO：在对应的引脚上设置为输出模式。
TIM3：设置定时器周期为100毫秒。
程序可以使用CubeMX和STM32的官方IDE来编写和上传。如果有问题需要手动修改的话，需要自行查阅相关硬件资料和库函数文档
#include "main.h"
#include "stdio.h"
#include "string.h"
// 定义LED显示模式
#define MODE_1 0x01 // 流水灯
#define MODE_2 0x02 // 花型2
#define MODE_3 0x03 // 花型3
// 定义LED引脚
#define LED_0_Pin GPIO_PIN_0
#define LED_1_Pin GPIO_PIN_1
#define LED_2_Pin GPIO_PIN_2
#define LED_3_Pin GPIO_PIN_3
#define LED_4_Pin GPIO_PIN_4
#define LED_5_Pin GPIO_PIN_5
#define LED_6_Pin GPIO_PIN_6
#define LED_7_Pin GPIO_PIN_7
#define LED_GPIO_Port GPIOB
// 定义按键引脚
#define KEY1_Pin GPIO_PIN_10
#define KEY1_GPIO_Port GPIOA
#define KEY2_Pin GPIO_PIN_3
#define KEY2_GPIO_Port GPIOB
// 定义花型状态和输出的花型名字
uint8_t mode = MODE_1;
char mode_name[10] = "MODE_1";
// 定义内部计数器
uint16_t timer_counter = 0;
// 定义串口输出
UART_HandleTypeDef huart2;
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_TIM3_Init(void);
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_USART2_UART_Init();
MX_TIM3_Init();
HAL_TIM_Base_Start_IT(&htim3);
while (1)
{
// 监听按键1，改变LED灯花型
if (HAL_GPIO_ReadPin(KEY1_GPIO_Port, KEY1_Pin) == GPIO_PIN_RESET)
{
HAL_Delay(50);
if (HAL_GPIO_ReadPin(KEY1_GPIO_Port, KEY1_Pin) == GPIO_PIN_RESET)
{
// 改变花型状态，重新设置输出名字
mode++;
if (mode >= 4)
{
mode = MODE_1;
}
switch (mode)
{
case MODE_1:
strcpy(mode_name, "MODE_1");
break;
case MODE_2:
strcpy(mode_name, "MODE_2");
break;
case MODE_3:
strcpy(mode_name, "MODE_3");
break;
}
}
}
// 监听按键2，强制复位花型
if (HAL_GPIO_ReadPin(KEY2_GPIO_Port, KEY2_Pin) == GPIO_PIN_RESET)
{
HAL_Delay(50);
if (HAL_GPIO_ReadPin(KEY2_GPIO_Port, KEY2_Pin) == GPIO_PIN_RESET)
{
mode = MODE_1;
strcpy(mode_name, "MODE_1");
}
}
}
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if (htim->Instance == TIM3)
{
timer_counter++;
if (timer_counter >= 1)
{
timer_counter = 0;
// 根据当前花型状态输出对应的LED显示模式
switch (mode)
{
case MODE_1:
HAL_GPIO_TogglePin(LED_GPIO_Port, LED_0_Pin);
break;
case MODE_2:
// 花型2的实现
break;
case MODE_3:
// 花型3的实现
break;
}
}
// 串口打印当前花型内容
if (timer_counter % 500 == 0)
{
char output[50];
sprintf(output, "Current mode: %s\n", mode_name);
HAL_UART_Transmit(&huart2, (uint8_t *)output, strlen(output), 100);
}
}
}
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_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 = 4;
RCC_OscInitStruct.PLL.PLLN = 72;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 3;
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_TIM3_Init(void)
{
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
htim3.Instance = TIM3;
htim3.Init.Prescaler = 719;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 100;
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
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();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
}
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(LED_GPIO_Port, LED_0_Pin | LED_1_Pin | LED_2_Pin | LED_3_Pin |
LED_4_Pin | LED_5_Pin | LED_6_Pin | LED_7_Pin,
GPIO_PIN_RESET);
/*Configure GPIO pins : BUTTON_1_Pin BUTTON_2_Pin */
GPIO_InitStruct.Pin = KEY1_Pin | KEY2_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pins : LED_0_Pin LED_1_Pin LED_2_Pin LED_3_Pin
LED_4_Pin LED_5_Pin LED_6_Pin LED_7_Pin */
GPIO_InitStruct.Pin = LED_0_Pin | LED_1_Pin | LED_2_Pin | LED_3_Pin |
LED_4_Pin | LED_5_Pin | LED_6_Pin | LED_7_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(LED_GPIO_Port, &GPIO_InitStruct);
}
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();
}
}
void Error_Handler(void)
{
}
在STM32F103C8T6单片机上运行，主要功能是控制8个LED灯，支持三种花型模式（流水灯、交替闪烁、呼吸灯），支持通过USART2串口接收命令控制LED灯和花型模式，支持通过外部中断PA0和PA1控制LED灯和切换花型模式：
#include "stm32f10x.h"
#include "stdio.h"
#define LED_NUM 8
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
uint16_t led_state = 0; // 保存当前LED灯状态
uint16_t led_pattern = 0; // 保存当前LED花型
uint32_t last_pattern_change_time = 0; // 记录上一次花型改变时间
uint8_t pattern_count = 3; // 花型数量
char* patterns[] = {"流水灯", "交替闪烁", "呼吸灯"}; // 花型名称
uint8_t pattern_index = 0; // 当前花型索引
void GPIO_Configuration(void)
{
// 使能GPIOC时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
// 配置PC0~PC7引脚为输出模式
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &GPIO_InitStructure);
// 使能GPIOA时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
// 配置PA0和PA1引脚为输入模式（上拉输入）
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOA, &GPIO_InitStructure);
}
void USART_Configuration(void)
{
// 使能USART2时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
// 配置USART2引脚
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// 配置USART2参数
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(USART2, &USART_InitStructure);
// 使能USART2
USART_Cmd(USART2, ENABLE);
}
void NVIC_Configuration(void)
{
// 配置NVIC中断优先级组
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
// 配置EXTI1中断
NVIC_InitStructure.NVIC_IRQChannel = EXTI1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// 配置EXTI0中断
NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// 配置USART2中断
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
void EXTI_Configuration(void)
{
// 使能AFIO时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
// 配置PA0和PA1为外部中断模式下拉输入
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// 配置EXTI0中断
EXTI_InitStructure.EXTI_Line = EXTI_Line0;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
// 配置EXTI1中断
EXTI_InitStructure.EXTI_Line = EXTI_Line1;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
}
int main(void)
{
GPIO_Configuration();
USART_Configuration();
NVIC_Configuration();
EXTI_Configuration();
// 主循环
while (1) {
// 更新LED灯状态
uint16_t led_value = 0;
for (int i = 0; i < LED_NUM; i++) {
if (led_state & (1 << i)) {
led_value |= 1 << i;
}
}
GPIO_Write(GPIOC, led_value);
// 检测是否需要改变花型
if (HAL_GetTick() - last_pattern_change_time > 5000) {
pattern_index = (pattern_index + 1) % pattern_count;
printf("当前花型：%s\n", patterns[pattern_index]);
last_pattern_change_time = HAL_GetTick();
}
}
}
中花型?什么意思？
STM32 的嵌入式系统题目。下面是方案：
1. 闪烁流水灯：
这里使用的是 STM32 的 HAL 库和定时器（TIM）模块实现的。我们需要配置 TIM 硬件定时器，使其每隔 100ms 产生中断并切换灯的状态。具体实现代码如下：
```c
#include "stm32f1xx_hal.h"
int main(void)
{
/* 使能时钟 */
__HAL_RCC_GPIOA_CLK_ENABLE();
/* 配置GPIO */
GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* 配置TIMER */
TIM_HandleTypeDef htim;
TIM_OC_InitTypeDef sConfig;
htim.Instance = TIM2;
htim.Init.Prescaler = 7200-1; // 72MHz / 7200 = 10kHz
htim.Init.CounterMode = TIM_COUNTERMODE_UP;
htim.Init.Period = 100-1; // 10kHz / 100 = 100Hz
htim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
HAL_TIM_Base_Init(&htim);
HAL_TIM_Base_Start_IT(&htim);
/* 进入循环 */
while (1)
{
}
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
static uint8_t led_idx = 0;
/* 关闭上一个灯 */
HAL_GPIO_WritePin(GPIOA, 1 << ((led_idx + 7) % 8), GPIO_PIN_RESET);
/* 点亮下一个灯 */
HAL_GPIO_WritePin(GPIOA, 1 << led_idx, GPIO_PIN_SET);
/* 选择下一个灯 */
led_idx = (led_idx + 1) % 8;
}
当按下 KEY1 时，我们需要更改 LED 的流水灯模式（即更改灯的顺序点亮）。这里我们设置了三种模式，可以通过按下 KEY1 切换。代码实现如下：
/* 定义 LED 花型，0 表示关闭，1 表示点亮 */
uint8_t led_pattern[3][8] = {
{1, 0, 0, 0, 0, 0, 0, 0}, // 原始流水灯模式
{1, 1, 0, 0, 0, 0, 0, 1}, // 自定义模式 1
{1, 1, 1, 0, 0, 0, 1, 1}, // 自定义模式 2
};
int pattern_idx = 0;
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
/* 来自 KEY1 的中断事件 */
if (GPIO_Pin == GPIO_PIN_0)
{
/* 切换 LED 花型 */
pattern_idx++;
if (pattern_idx >= 3) {
pattern_idx = 0;
}
/* 按钮按下并立即释放，有效防止抖动 */
HAL_Delay(100);
while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_SET);
}
}
当按下 KEY2 时，我们需要强制重新设置 LED 的花型为原始的流水灯模式。代码实现如下：
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
/* 来自 KEY2 的中断事件 */
if (GPIO_Pin == GPIO_PIN_1)
{
/* 强制初始化 LED 花型为原始流水灯模式 */
pattern_idx = 0;
/* 按钮按下并立即释放，有效防止抖动 */
HAL_Delay(100);
while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_SET);
}
}
4. 通过串口输出当前 LEd,花型内容,在主函数中开启串口通信，并在按下 KEY1 后将当前 LED 花型信息通过串口输出。这里借助了 HAL 库的 USART 库函数。代码实现如下：
UART_HandleTypeDef huart;
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
int main(void)
{
/* MCU 启动代码 */
HAL_Init();
SystemClock_Config();
/* 使能时钟 */
__HAL_RCC_GPIOA_CLK_ENABLE();
/* 配置 GPIO 和 TIMER */
MX_GPIO_Init();
MX_TIM2_Init();
/* 配置串口 */
MX_USART1_UART_Init();
/* 进入循环 */
while (1)
{
/* 每隔 500ms 输出 LED 花型信息 */
HAL_Delay(500);
char buf[128];
snprintf(buf, sizeof(buf), "Current pattern: %d\r\n", pattern_idx);
HAL_UART_Transmit(&huart, (uint8_t*) buf, strlen(buf), HAL_MAX_DELAY);
}
}
void MX_USART1_UART_Init(void)
{
huart.Instance = USART1;
huart.Init.BaudRate = 9600;
huart.Init.WordLength = UART_WORDLENGTH_8B;
huart.Init.StopBits = UART_STOPBITS_1;
huart.Init.Parity = UART_PARITY_NONE;
huart.Init.Mode = UART_MODE_TX_RX;
huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart) != HAL_OK)
{
/* 错误处理方式 */
while (1);
}
}
void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
if(uartHandle->Instance==USART1)
{
/* 使能时钟 */
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
/**USART1 GPIO Configuration
PA9 ------> USART1_TX
PA10 ------> USART1_RX
*/
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);
GPIO_InitStruct.Pin = GPIO_PIN_10;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}
}
void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
{
if(uartHandle->Instance==USART1)
{
/* 关闭时钟 */
__HAL_RCC_USART1_CLK_DISABLE();
/**USART1 GPIO Configuration
PA9 ------> USART1_TX
PA10 ------> USART1_RX
*/
HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);
}
}
这是一个简单实现 LED 灯闪烁和花型切换的系统。
简单点亮led流水灯c语言程序,keil软件用单片机控制8个LED流水灯来回点亮
#include "reg51.h"
main()
{
unsigned int i,j;
while(1)
{
P1=0xfe; //点亮第一个LED
for(i=200;i>0;i--)
for(j=500;j>0;j--);
P1=0xfd; //点亮第二个LED
for(i=200;i>0;i--)
for(j=500;j>0;j--);
P1=0xfb; //点亮第三个LED
for(i=200;i>0;i--)
for(j=500;j>0;j--);
P1=0xf7; //点亮第四个LED
for(i=200;i>0;i--)
for(j=500;j>0;j--);
P1=0xef; //点亮第五个LED
for(i=200;i>0;i--)
for(j=500;j>0;j--);
P1=0xdf; //点亮第六个LED
for(i=200;i>0;i--)
for(j=500;j>0;j--);
P1=0xbf; //点亮第七个LED
for(i=200;i>0;i--)
for(j=500;j>0;j--);
P1=0x7f; //点亮第八个LED
for(i=200;i>0;i--)
for(j=500;j>0;j--);
}
}
STM32 实现彩灯实现的几个重要步骤：选择合适的 STM32 型号、设计电路、编写代码，可以使用STM32CubeMX生成代码框架，再在其中编写自己的代码、将代码烧录到STM32芯片中。
具体实现的方法可以参考资料：
基于STM32单片机三色全彩RGB LED灯控制系统 原理图PCB程序设计：https://www.ngui.cc/zz/1872441.html
实现流水灯闪烁功能：使用定时器中断来控制LED灯的亮灭时间，每个LED灯亮100ms后熄灭并使下一个LED灯点亮。
实现按键改变花型功能：当按下key1时，根据当前花型的不同，切换到不同的花型。至少需要设计3种花型，包括要求1中的基本花型。
实现强制复位当前花型为基本花型功能：当按下key2时，将当前花型重置为基本花型。
实现串口输出当前花型内容功能：每隔500ms输出当前花型的名称或描述信息，可以使用串口助手或其他串口通信库来实现。
参考 https://blog.csdn.net/m0_47699870/article/details/116226342