STM32 按键控制4位数码管，数码管显示使用定时中断

要使用定时中断控制数码管显示，可以按照以下步骤进行：

1. 配置定时器：使用一个定时器来产生中断，可以选择TIM2或TIM3，具体选择哪个定时器需要根据你使用的MCU型号和引脚资源来确定。在配置定时器时，需要设置计数器的自动重装载值和分频系数，以产生适当的定时中断时间。

2. 配置按键：通过GPIO配置按键引脚，并设置为输入模式。在按键中断函数中，判断按键是否按下，并根据需要修改数码管显示的内容。

3. 配置数码管：使用GPIO配置数码管引脚，并设置为输出模式。在主循环中，通过控制数码管引脚输出高低电平来控制数码管的显示。

4. 编写定时器中断函数：在定时器中断函数中，根据需要修改数码管显示的内容。这里可以选择使用定时器来控制数码管的扫描速度，例如每隔一段时间就更新一次数码管显示内容。

5. 启动定时器：在初始化完成后，启动定时器开始产生中断，并进入主循环等待按键事件的发生。

以上是一个基本的流程，具体实现时需要根据实际情况进行调整。

相关问题

STM32 按键控制4位数码管，数码管显示使用定时中断 编程

以下是使用定时器中断和外部中断控制 STM32 上的 4 位数码管的示例代码：

#include "stm32f10x.h"

// 定义数码管段码
#define SEG_A 0x01
#define SEG_B 0x02
#define SEG_C 0x04
#define SEG_D 0x08
#define SEG_E 0x10
#define SEG_F 0x20
#define SEG_G 0x40
#define SEG_DP 0x80

// 定义数码管数字0~9的段码
const uint8_t seg_number[] = {
    SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F,           // 0
    SEG_B | SEG_C,                                           // 1
    SEG_A | SEG_B | SEG_D | SEG_E | SEG_G,                   // 2
    SEG_A | SEG_B | SEG_C | SEG_D | SEG_G,                   // 3
    SEG_B | SEG_C | SEG_F | SEG_G,                           // 4
    SEG_A | SEG_C | SEG_D | SEG_F | SEG_G,                   // 5
    SEG_A | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G,           // 6
    SEG_A | SEG_B | SEG_C,                                   // 7
    SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G,   // 8
    SEG_A | SEG_B | SEG_C | SEG_D | SEG_F | SEG_G            // 9
};

// 定义数码管显示变量和计数器
volatile uint8_t display[4] = {0};
volatile uint8_t display_idx = 0;

// 外部中断处理函数，按下按键时触发
void EXTI0_IRQHandler(void)
{
    if (EXTI_GetITStatus(EXTI_Line0) != RESET) {
        // 按下按键时，将数码管显示的数字加一
        display[0]++;
        if (display[0] > 9) {
            display[0] = 0;
            display[1]++;
            if (display[1] > 9) {
                display[1] = 0;
                display[2]++;
                if (display[2] > 9) {
                    display[2] = 0;
                    display[3]++;
                    if (display[3] > 9) {
                        display[3] = 0;
                    }
                }
            }
        }
        // 清除 EXTI0 中断标志位
        EXTI_ClearITPendingBit(EXTI_Line0);
    }
}

// 定时器中断处理函数，用于定时更新数码管显示
void TIM2_IRQHandler(void)
{
    if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET) {
        // 更新数码管显示
        GPIO_Write(GPIOB, 0x00);
        GPIO_Write(GPIOA, seg_number[display[display_idx]] | SEG_DP << display_idx);
        GPIO_Write(GPIOB, 1 << display_idx);
        display_idx++;
        if (display_idx > 3) {
            display_idx = 0;
        }
        // 清除定时器中断标志位
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
    }
}

int main(void)
{
    // 初始化 GPIO 和定时器
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE);
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    TIM_TimeBaseStructure.TIM_Period = 999;
    TIM_TimeBaseStructure.TIM_Prescaler = 7199;
    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);
    TIM_Cmd(TIM2, ENABLE);

    // 初始化外部中断
    EXTI_InitTypeDef EXTI_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource0);
    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);
    NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    // 进入主循环
    while (1) {
    }
}

上述代码中，我们使用 GPIO 控制了数码管的显示，使用定时器中断和外部中断来控制数码管的更新和按键输入。在 `EXTI0_IRQHandler` 中处理按键输入，每次按下按键，数码管显示的数字加一；在 `TIM2_IRQHandler` 中处理数码管显示，每次更新数码管显示变量 `display` 中的数字，并将其转换为相应的段码输出到 GPIO 端口。需要注意的是，在 `TIM2_IRQHandler` 中需要控制 GPIO 端口的输出顺序，以显示各个数码管的数字。

STM32 使用4个按键控制8位数码管，数码管显示使用定时中断 编程

首先，你需要连接 4 个按键和 8 位数码管到 STM32 上。然后，你需要编写代码来初始化 GPIO 和定时器，并在定时器中断中更新数码管的显示。

下面是一个简单的例子代码，你可以根据你的需要进行修改：

#include "stm32f10x.h"

#define TIMER_PERIOD 1000 // 定时器中断时间间隔，单位为微秒
#define KEY1_PIN GPIO_Pin_0
#define KEY2_PIN GPIO_Pin_1
#define KEY3_PIN GPIO_Pin_2
#define KEY4_PIN GPIO_Pin_3
#define SEG_A_PIN GPIO_Pin_4
#define SEG_B_PIN GPIO_Pin_5
#define SEG_C_PIN GPIO_Pin_6
#define SEG_D_PIN GPIO_Pin_7
#define SEG_E_PIN GPIO_Pin_8
#define SEG_F_PIN GPIO_Pin_9
#define SEG_G_PIN GPIO_Pin_10
#define SEG_DP_PIN GPIO_Pin_11

volatile uint32_t timer_count = 0;
volatile uint8_t display_value = 0;

void GPIO_Configuration(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    // 初始化按键引脚
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    GPIO_InitStructure.GPIO_Pin = KEY1_PIN | KEY2_PIN | KEY3_PIN | KEY4_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    // 初始化数码管引脚
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    GPIO_InitStructure.GPIO_Pin = SEG_A_PIN | SEG_B_PIN | SEG_C_PIN | SEG_D_PIN |
                                  SEG_E_PIN | SEG_F_PIN | SEG_G_PIN | SEG_DP_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
}

void TIM2_Configuration(void)
{
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

    TIM_TimeBaseStructure.TIM_Period = TIMER_PERIOD - 1;
    TIM_TimeBaseStructure.TIM_Prescaler = SystemCoreClock / 1000000 - 1;
    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 = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    TIM_Cmd(TIM2, ENABLE);
}

void TIM2_IRQHandler(void)
{
    if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
    {
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
        timer_count++;

        // 每 10 次定时器中断更新一次显示
        if (timer_count % 10 == 0)
        {
            display_value++;
            if (display_value > 9)
            {
                display_value = 0;
            }
        }
    }
}

int main(void)
{
    GPIO_Configuration();
    TIM2_Configuration();

    while (1)
    {
        // 检测按键状态，根据按键更新显示值
        if (GPIO_ReadInputDataBit(GPIOA, KEY1_PIN) == RESET)
        {
            display_value = 0;
        }
        if (GPIO_ReadInputDataBit(GPIOA, KEY2_PIN) == RESET)
        {
            display_value = 1;
        }
        if (GPIO_ReadInputDataBit(GPIOA, KEY3_PIN) == RESET)
        {
            display_value = 2;
        }
        if (GPIO_ReadInputDataBit(GPIOA, KEY4_PIN) == RESET)
        {
            display_value = 3;
        }

        // 根据显示值更新数码管显示
        switch (display_value)
        {
        case 0:
            GPIO_SetBits(GPIOB, SEG_A_PIN | SEG_B_PIN | SEG_C_PIN | SEG_D_PIN |
                                   SEG_E_PIN | SEG_F_PIN);
            GPIO_ResetBits(GPIOB, SEG_G_PIN | SEG_DP_PIN);
            break;
        case 1:
            GPIO_SetBits(GPIOB, SEG_B_PIN | SEG_C_PIN);
            GPIO_ResetBits(GPIOB, SEG_A_PIN | SEG_D_PIN | SEG_E_PIN |
                                        SEG_F_PIN | SEG_G_PIN | SEG_DP_PIN);
            break;
        case 2:
            GPIO_SetBits(GPIOB, SEG_A_PIN | SEG_B_PIN | SEG_D_PIN | SEG_E_PIN |
                                   SEG_G_PIN);
            GPIO_ResetBits(GPIOB, SEG_C_PIN | SEG_F_PIN | SEG_DP_PIN);
            break;
        case 3:
            GPIO_SetBits(GPIOB, SEG_A_PIN | SEG_B_PIN | SEG_C_PIN | SEG_D_PIN |
                                   SEG_G_PIN);
            GPIO_ResetBits(GPIOB, SEG_E_PIN | SEG_F_PIN | SEG_DP_PIN);
            break;
        }

        // 延时等待一段时间，使数码管显示稳定
        for (int i = 0; i < 10000; i++);
    }
}

在这个例子中，我们使用 TIM2 定时器，并将其配置为每隔 1 毫秒触发一次中断。在中断处理函数中，我们使用一个计数器变量 `timer_count` 记录定时器中断的次数，并在每 10 次中断时更新一次数码管的显示值 `display_value`。

在 `main` 函数中，我们不断循环检测按键状态和更新数码管的显示。根据按键状态更新 `display_value`，然后根据 `display_value` 更新数码管的显示。为了使数码管显示稳定，我们在更新显示后添加了一个简单的延时。

当程序运行时，你应该能够看到数码管上显示的数字随着按键的按下而改变，同时每隔一段时间数码管上的数字也会自动更新。