【STM32】中断编程入门

最新推荐文章于 2024-07-14 22:02:12 发布
最新推荐文章于 2024-07-14 22:02:12 发布
阅读量705 收藏 23
点赞数 27
分类专栏： STM32 文章标签： stm32 单片机 嵌入式硬件 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/normog/article/details/139039416
版权

文章目录

一、要求

学习stm32中断原理和开发编程方法。使用标准库完成以下任务：

1.用stm32F103核心板的GPIOA端一管脚接一个LED，GPIOB端口一引脚接一个开关（用杜邦线模拟代替）。采用中断模式编程，当开关接高电平时，LED亮灯；接低电平时，LED灭灯。如果完成后，尝试在main函数while循环中加入一个串口每隔1s 发送一次字符的代码片段，观察按键中断对串口发送是否会带来干扰或延迟。

2.采用串口中断方式重做上周查询方式的串口通信作业，分别实现：

（1）当stm32接收到1个字符“s”时，停止持续发送“hello windows!”; 当接收到1个字符“t”时，持续发送“hello windows!”（提示：采用一个全局标量做信号灯）；

（2）当stm32接收到字符“stop stm32!”时，停止持续发送“hello windows!”; 当接收到字符“go stm32!”时，持续发送“hello windows!”(提示：要将接收到的连续字符保存到一个字符数组里，进行判别匹配。写一个接收字符串的函数。

二、中断介绍

中断：在主程序运行过程中，出现了特定的中断触发条件（中断源），使得CPU暂停当前正在运行的程序，转而去处理中断程序，处理完成后又返回原来被暂停的位置继续运行。

中断优先级：当有多个中断源同时申请中断时，CPU会根据中断源的轻重缓急进行裁决，优先响应更加紧急的中断源。

中断嵌套：当一个中断程序正在运行时，又有新的更高优先级的中断源申请中断，CPU再次暂停当前中断程序，转而去处理新的中断程序，处理完成后依次进行返回。

（一）STM32中断

68个可屏蔽中断通道，包含EXTI、TIM、ADC、USART、SPI、I2C、RTC等多个外设。

使用NVIC统一管理中断，每个中断通道都拥有16个可编程的优先等级，可对优先级进行分组，进一步设置抢占优先级和响应优先级。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

（二）NVIC

1、结构

在这里插入图片描述

2、NVIC优先级分组

NVIC的中断优先级由优先级寄存器的4位（0~15）决定，这4位可以进行切分，分为高n位的抢占优先级和低4-n位的响应优先级。

抢占优先级高的可以中断嵌套，响应优先级高的可以优先排队，抢占优先级和响应优先级均相同的按中断号排队。
在这里插入图片描述

（三）EXTI

1、EXTI简介

EXTI（Extern Interrupt）外部中断。

EXTI可以监测指定GPIO口的电平信号，当其指定的GPIO口产生电平变化时，EXTI将立即向NVIC发出中断申请，经过NVIC裁决后即可中断CPU主程序，使CPU执行EXTI对应的中断程序。

支持的触发方式：上升沿/下降沿/双边沿/软件触发。

支持的GPIO口：所有GPIO口，但相同的Pin不能同时触发中断。

通道数：16个GPIO_Pin，外加PVD输出、RTC闹钟、USB唤醒、以太网唤醒。

触发响应方式：中断响应/事件响应。

2、EXTI基本结构

在这里插入图片描述

（四）AFIO复用IO口

AFIO主要用于引脚复用功能的选择和重定义。

在STM32中，AFIO主要完成两个任务：复用功能引脚重映射、中断引脚选择。
在这里插入图片描述

三、实践

（一）点灯与串口发送数据

1、目标

用stm32F103核心板的GPIOA端一管脚接一个LED，GPIOB端口一引脚接一个开关（用杜邦线模拟代替）。采用中断模式编程，当开关接高电平时，LED亮灯；接低电平时，LED灭灯。如果完成后，尝试在main函数while循环中加入一个串口每隔1s 发送一次字符的代码片段，观察按键中断对串口发送是否会带来干扰或延迟。

2、程序实现

EXIT.c与EXIT.h

#include "stm32f10x.h" 
#include "LED.h"
void EXIT_key_Init(void)
{
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);		
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);		

	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);						

	GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource14);
	
	EXTI_InitTypeDef EXTI_InitStructure;						
	EXTI_InitStructure.EXTI_Line = EXTI_Line14;					
	EXTI_InitStructure.EXTI_LineCmd = ENABLE;					
	EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;			
	EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;		
	EXTI_Init(&EXTI_InitStructure);								

	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);				
	NVIC_InitTypeDef NVIC_InitStructure;						
	NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;		
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;				
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;	
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;			
	NVIC_Init(&NVIC_InitStructure);							
	
	
}

#ifndef __EXIT_H
#define __EXIT_H

void EXIT_key_Init(void);


#endif

main函数

#include "stm32f10x.h"                
#include "Delay.h"
#include "EXIT.h"
#include "LED.h"
#include "Serial.h"
int main(void)
{
	
	LED_Init();
	Serial_Init();
	GPIO_ResetBits(GPIOC,GPIO_Pin_13);
	EXIT_key_Init();
	
	while (1)
	{
		Delay_ms(1000);	
	Serial_Printf("HELLO WINDOWS");
	Serial_Printf("\r\n");
	}
}
void EXTI15_10_IRQHandler(void)
{
	if (EXTI_GetITStatus(EXTI_Line14) == SET)		
	{
		
		if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_14) == 0)
		{
				LED_Turn();	
		}
		EXTI_ClearITPendingBit(EXTI_Line14);		
													
	}
}

3、实践

在这里插入图片描述
结果：点灯与发送数据不会互相干扰。

（二）发送与接受之字符中断

1、程序实现

Serial.c与Serial.h

#include "stm32f10x.h"                 
#include <stdio.h>
#include <stdarg.h>
volatile uint8_t sending_enabled = 1; 
uint8_t Serial_RxData;		
uint8_t Serial_RxFlag;		
void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					
	USART_InitTypeDef USART_InitStructure;					
	USART_InitStructure.USART_BaudRate = 9600;				
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;	
	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;	
	USART_InitStructure.USART_Parity = USART_Parity_No;		
	USART_InitStructure.USART_StopBits = USART_StopBits_1;	
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;		
	USART_Init(USART1, &USART_InitStructure);				
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);			
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);			
	NVIC_InitTypeDef NVIC_InitStructure;					
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;		
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;		
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;		
	NVIC_Init(&NVIC_InitStructure);						
	USART_Cmd(USART1, ENABLE);							
}
void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1, Byte);		
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);	
	
}
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)		
	{
		Serial_SendByte(Array[i]);		
	}
}
void Serial_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		Serial_SendByte(String[i]);		
	}
}
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;	
	while (Y --)			
	{
		Result *= X;		
	}
	return Result;
}

void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i ++)		
	{
		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');	
	}
}

int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);			
	return ch;
}

void Serial_Printf(char *format, ...)
{
	char String[100];				
	va_list arg;					
	va_start(arg, format);			
	vsprintf(String, format, arg);	
	va_end(arg);					
	Serial_SendString(String);		
}

uint8_t Serial_GetRxFlag(void)
{
	if (Serial_RxFlag == 1)			
	{
		Serial_RxFlag = 0;
		return 1;					
	}
	return 0;					
}

uint8_t Serial_GetRxData(void)
{
	return Serial_RxData;	
	
}
void send_hello_windows(void) {
    if (sending_enabled) {
			 Serial_Printf("HELLO WINDOWS");
            Serial_Printf("\r\n");}}

						
void USART1_IRQHandler(void)
{
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)		
	{
		Serial_RxData = USART_ReceiveData(USART1);	
		
	Serial_RxFlag = 1;										
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);																	
		if(Serial_RxData==0x73)
			{
			Serial_Printf("\r\nStop stm32!\r\n"); 
				sending_enabled = 0;
			}else if (Serial_RxData == 't') {
           sending_enabled = 1;
        }													
	}
}

main.c

#include "stm32f10x.h"                 
#include "Delay.h"
#include "Serial.h"

uint8_t RxData;		

int main(void)
{
    Serial_Init();
    while (1)
    {
       send_hello_windows();
			Delay_ms(500);
    }
}

2、实践

在这里插入图片描述

（三）发送与接受之字符串中断

1、程序实现

Serial.c进行修改，Serial.h与main如上不变

#include "stm32f10x.h"                 
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
volatile uint8_t sending_enabled = 1; 
char received_string[20] = {0}; 
uint8_t string_index = 0;     
uint8_t Serial_RxFlag = 0;				
void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					
	USART_InitTypeDef USART_InitStructure;					
	USART_InitStructure.USART_BaudRate = 9600;				
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;	
	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;	
	USART_InitStructure.USART_Parity = USART_Parity_No;		
	USART_InitStructure.USART_StopBits = USART_StopBits_1;	
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;		
	USART_Init(USART1, &USART_InitStructure);				
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);			
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);			
	NVIC_InitTypeDef NVIC_InitStructure;					
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;		
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;		
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;		
	NVIC_Init(&NVIC_InitStructure);						
	USART_Cmd(USART1, ENABLE);							
}
void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1, Byte);		
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);	
	
}
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)		
	{
		Serial_SendByte(Array[i]);		
	}
}
void Serial_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i ++)
	{
		Serial_SendByte(String[i]);		
	}
}
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;	
	while (Y --)			
	{
		Result *= X;		
	}
	return Result;
}

void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i ++)		
	{
		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');	
	}
}

int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);			
	return ch;
}

void Serial_Printf(char *format, ...)
{
	char String[100];				
	va_list arg;					
	va_start(arg, format);			
	vsprintf(String, format, arg);	
	va_end(arg);					
	Serial_SendString(String);		
}

uint8_t Serial_GetRxFlag(void)
{
	if (Serial_RxFlag == 1)			
	{
		Serial_RxFlag = 0;
		return 1;					
	}
	return 0;					
}



void send_hello_windows(void) {
    if (sending_enabled) {
			 Serial_Printf("HELLO WINDOWS");
            Serial_Printf("\r\n");}}

						

						
void USART1_IRQHandler(void)
{
    if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)
    {
        char received_char = USART_ReceiveData(USART1);
        USART_ClearITPendingBit(USART1, USART_IT_RXNE);

        if (received_char == '\n' || received_char == '\r')
        {
            received_string[string_index] = '\0'; 
            string_index = 0;                     
            if (strcmp(received_string, "stop stm32!") == 0)
            {
                sending_enabled = 0; 
                Serial_Printf("\r\nStop stm32!\r\n");
            }
            else if (strcmp(received_string, "go stm32!") == 0)
            {
                sending_enabled = 1; 
                Serial_Printf("Go on stm32!\r\n");
            }
            else
            {
                
            }
        }
        else
        {
            
            received_string[string_index++] = received_char;
            if (string_index >= 19)
            {
                // ?????????,???????
                string_index = 0;
                memset(received_string, 0, sizeof(received_string));
            }
        }
    }
}

2、实践

在这里插入图片描述

四、总结

以上为此次学习成果，如有不足，烦请指教。

normog
关注
专栏目录
STM32入门教程：定时器中断
m0_72166538的博客
07-18 301
定时器中断是利用定时器模块的计数功能，在达到设定的计数值时触发中断。通过定时器中断，我们可以定期执行特定的任务，实现定时功能。通过定时器中断，我们可以实现定时功能，并在中断服务函数中进行相应的处理。STM32是STMicroelectronics（意法半导体）公司的一款32位单片机系列产品，具有丰富的外设和强大的性能，被广泛应用于嵌入式系统开发中。本教程将介绍STM32的定时器中断功能，并提供详细的代码案例。三、定时器中断的代码案例 下面以STM32F4系列为例，展示一个基本的定时器中断的代码案例。
江科大STM32入门教程资料（课程源码）
05-31
编程基础：详细讲解STM32的编程基础，包括GPIO、中断、定时器等外设的使用。 项目实践：提供一系列入门级项目实践，帮助学习者通过动手实践加深理解。 例程代码：每个项目都配有完整的例程代码，方便学习者学习和...
STM32——中断编程入门（使用标准库）
qq_74179376的博客
05-19 765
本次实验进一步学习了STM32的基础知识，了解了STM32的中断编程，标准库的使用较之于之前的操作看上去略显复杂，但只是函数的引用加入，代码编写方面是更简便的。由于本人认知浅薄，上述内容或有诸多不详错漏之处，望各位海涵并指出批正。
stm32中断模式编程
m0_58807717的博客
10-24 896
stm32中断模式编程
[STM32]中断编程入门
weixin_50037440的博客
05-18 871
本次学习使用中断点灯+发送接收数据。初学多有不足，请多指教。
STM32中断编程入门
m0_74327085的博客
05-15 903
收获构成了STM32中断编程的基础，为进一步深入学习高级中断应用、优化系统性能及解决实际问题打下了坚实的基础。
STM32中断编程入门：初识外部中断
"STM32入门系列教程之九《初试STM32中断》" STM32中断系统是STM32微控制器中的一个重要特性，它允许处理器在执行其他任务的同时响应外部事件。在这个教程中，我们将深入理解如何配置和使用STM32的中断功能。 首先...
stm32 ARM单片机入门.rar_stm32编程资料
09-20
"STM32 ARM单片机入门.rar_stm32编程资料"是一个压缩包，包含了对初学者了解和学习STM32单片机编程的基础资源。 首先，"STM32_入门教程.pdf"可能是STM32的基础教程，它可能会涵盖以下内容： 1. **STM32系列概述**...
STM32串口编程入门教程：从查询到中断
"该资源是一份关于STM32入门系列教程的第八部分，主题是《USART串口编程》。教程由福州芯达工作室提供，旨在帮助初学者理解并掌握STM32芯片上的串行通信接口USART的使用。教程强调了实际应用中的串口功能，即用于STM...
stm32中断按键
07-28
stm32中断按键，里面有中断 按键 串口程序
STM32中断流程处理
04-30
中断的定义：指当出现需要时，CPU暂时停止当前程序的执行转而执行处理新情况的程序和执行过程。即在程序运行过程中，中断的定义：指当出现需要时，CPU暂时停止当前程序的执行转而执行处理新情况的程序和执行过程。即在程序运行过程中
第四篇，STM32中断控制编程
weixin_44651073的博客
07-02 3120
STM32中断控制编程
STM32—中断详解（配合按键中断代码，代码亲测）
热门推荐
肥宅快乐博客
07-25 6万+
在STM32中执行中断主要分三部分： 1.配置NVIC_Config()函数 2.配置EXTI_Config()函数 3.编写中断服务函数 （注：本文章所用代码为中断按键代码，实现了按键进入中断从而控制LED亮灭） 配置NVIC_Config()函数 NVIC 是嵌套向量中断控制器，控制着整个芯片中断相关的功能，它跟内核紧密耦合，是内核里面的一个外设。 NVIC_Config()函数代码如下： s...
STM32--中断使用（超详细！）
m0_56399733的博客
12-14 4万+
本文主要讲解了STM32单片机的中断使用，主要内容有：中断的概念、NVIC、EXIT的介绍，以及中断使用的步骤。并且利用中断实现了按键控制LED灯实验。
stm32中断详解
最新发布
weixin_73497355的博客
07-14 1221
本文对stm32的中断进行了详细的讲解，并通过一个例子演示了中断的配置流程。
STM32 学习（四）中断系统
欢迎一起交流问题！
02-28 1792
众所周知，轮询是 CPU 通过不断地查询某个外部设备的状态，如果外部设备准备好，就可以向其发送数据或者读取数据，这种方式由于CPU不断查询总线，导致指令执行受到影响，效率非常低。而与之相对应的就是中断，正常情况 CPU 会处理其他的事情，如果设备有需要 CPU 处理的事情就产生一个中断，CPU 就会停下正在做的事情来处理中断。中断的执行流程如下：STM32 中断包含很多中断源（中断通道），并且使用 NVIC 统一管理中断，由左边的地址组成的表称为，表中的内容为中断入口的地址：为。
STM32 中断流程介绍
weixin_43732386的博客
03-02 1217
stm32中断流程
STM32学习笔记（三）——STM32的中断
m0_58326153的博客
01-11 2245
STM32的中断简介，STM32有很多中断，介绍了其中一种--外部中断EXTI，并介绍了如何管理这些中断的模块NVIC，中断管理器
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值