stm32实例学习-基本操作(寄存器)

已于 2022-03-08 21:11:20 修改
阅读量1.2k 收藏 13
点赞数
分类专栏： 单片机 文章标签： 单片机
于 2022-03-08 11:20:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinshou249/article/details/123259509
版权

stm32实例学习
以stm32f103rc为例

  1. 系统的启动—配置系统时钟，启动运行
    startup_stm32f0x_hd.s：栈空间的设置，进入Rest_Handler函数，设置异常向量表，时钟初始化，跳转到__main执行系统的一些准备工作，跳转到main函数；

    初始化时钟后，单片机就能开始工作

void system_init(void)
{
	RCC->CR |= 1 << 16;					//HSE ON
	while(!(RCC->CR & (1 << 17)));		//Wait HSE ready
	
	RCC->CFGR &= ~(0xF << 4);			//AHB
	RCC->CFGR |= 4 << 8;				//APB1 div 2
	RCC->CFGR &= ~(7 << 11);			//APB2
	RCC->CFGR |= 7 << 18;				//PLL
	
	RCC->CFGR &= ~(1 << 17);
	RCC->CFGR |= 1 << 16;				//HSE as PLL input
	
	RCC->CR |= 1 << 24;					//PLL ON
	while(!(RCC->CR & (1 << 25)));
	
	FLASH->ACR |= 2 << 0;				//latency
	
	RCC->CFGR |= 2 << 0;
	while(((RCC->CFGR >> 2) & 0x3) != 0x02);	
}
  1. led
void led_init(void)
{
	RCC->APB2ENR = 1 << 2;	//GPIOA clock	
	GPIOA->CRH &= ~(0xF << 0);
	GPIOA->CRH |= 3 << 0;
	GPIOA->BSRR |= 1 << 8;
	
	RCC->APB2ENR = 1 << 5;	//GPIOD clock	
	GPIOD->CRL &= ~(0xF << 8);
	GPIOD->CRL |= 3 << 8;
	GPIOD->BSRR |= 1 << 2;
}
  1. 单片机进入待机状态并唤醒
void pwr_init(void)
{
	RCC->APB1ENR |= 1 << 28;	//power clock
	PWR->CSR |= 1 << 8;			//WKUP pin enable
}

/*
	set SLEEPDEEP
	set PDDS
	clear WUF
	WFI
*/
void pwr_go_to_standby(void)
{
	SCB->SCR |= 1 << 2;
	PWR->CR |= 1 << 1;
	PWR->CR |= 1 << 2;
	__WFI();
}

监测单片机的电压PVD

```c
void pwr_init(void)
{
	RCC->APB1ENR |= 1 << 28;	//power clock
	RCC->APB2ENR |= 1 << 0;
	
	PWR->CR |= 7 << 5;			//2.9V
	PWR->CR |= 1 << 4;			//enable PVD
	
	EXTI->IMR |= 1 << 16;		//interrupt
	EXTI->FTSR |= 1 << 16;
	EXTI->RTSR |= 1 << 16;
	nvic_init(PVD_IRQn, 2, 2, 2);	
}

void PVD_IRQHandler(void)
{
	if(EXTI->PR & (1 << 16))
	{
		EXTI->PR |= 1 << 16;
		GPIOD->ODR ^= 1 << 2;
	}
}

4. 延时

```c
static uint32_t usPerTicks = 9;
static volatile uint32_t system_mills = 0;
static volatile uint32_t systick_pending = 0;
static volatile uint32_t systick_stamps = 0;

void delay_init(void)
{
	SysTick->CTRL |= 1 << 1;	//en interrupt
	SysTick->CTRL &= ~(1 << 2);	//clock = system clock / 8;
	SysTick->LOAD = usPerTicks * 1000;		//ticks per ms
	SysTick->VAL= 0;
	SysTick->CTRL |= 1 << 0;	//start
}

void SysTick_Handler(void)
{
	system_mills++;
	systick_stamps = SysTick->VAL;
	systick_pending = 0;
}

uint32_t micros_isr(void)
{
	register uint32_t ticks, ms, pending;
	
	ticks = SysTick->VAL;
	if(SCB->ICSR & 0x1FF)
	{
		systick_pending = 1;
		ticks = SysTick->VAL;
	}
	
	pending = systick_pending;
	ms = system_mills;
	return ((ms + pending) * 1000 + (usPerTicks * 1000 - ticks) / usPerTicks);
}

uint32_t micros(void)
{
	register uint32_t ticks, ms;
	
	if(SysTick->CTRL & (1 << 16))
	{
		return micros_isr();
	}
	
	do
	{
		ms = system_mills;
		ticks = SysTick->VAL;
	}while((ms != system_mills) || (ticks > systick_stamps));
	
	return (ms * 1000 + (usPerTicks * 1000 - ticks) / usPerTicks);
	
}

void delay_us(uint32_t nus)
{
	uint32_t now = micros();
	while(micros() - now < nus);
}

void delay_ms(uint32_t nms)
{
	while(nms--)
	{
		delay_us(1000);
	}
}
  1. 看门狗
    独立看门狗
void iwdg_init(void)
{
	RCC->CSR |= 1 << 0;
	while(!(RCC->CSR & (1 << 1)));
	
	IWDG->KR = 0x5555;		//cancel protetion
	IWDG->PR = 4;			//prescaler
	IWDG->RLR = 625;		//load val
	IWDG->KR = 0xCCCC;		//start
	IWDG->KR = 0xAAAA;		//reload
}

void iwdg_feed(void)
{
	IWDG->KR = 0xAAAA;
}

窗口看门狗

void wwdg_init(void)
{
	RCC->APB1ENR |= 1 << 11;	//WWDG clock
	
	WWDG->CFR |= 1 << 9;		//interrupt
	WWDG->CFR |= 80;			//config window
	WWDG->CFR |= 3 << 7;
	WWDG->CR = 0x7F;
	WWDG->CR |= 1 << 7;			//start
	
	nvic_init(WWDG_IRQn, 2, 3, 2);
}

void wwdg_feed(void)
{
	WWDG->CR = 0x7F;
}

void WWDG_IRQHandler(void)
{
	WWDG->SR = 0;
	wwdg_feed();	
	GPIOD->ODR ^= 1 << 2;
}
  1. 备份寄存器
void backup_init(void)
{
	RCC->APB1ENR |= 1 << 28;	//PWR
	RCC->APB1ENR |= 1 << 27;	//BKP clock
	
	PWR->CR |= 1 << 8;			//cancel backup protection
	
	if(RCC->CSR & (1 << 27))	//power down/up
	{				
		if(BKP->DR1 != 0x55AA)
		{
			BKP->DR1 = 0x55AA;
		}
		else
		{
			GPIOD->ODR &= ~(1 << 2);
		}		
	}
}
  1. 中断
void exti_init(void)
{
	RCC->APB2ENR |= 1 << 2;		//GPIOA
	RCC->APB2ENR |= 1 << 0;		//AFIO
	
	GPIOA->CRL &= ~(0xF << 0);			//input 
	GPIOA->CRL |= 2 << 0;
	GPIOA->ODR &= ~(1 << 0);
	
	AFIO->EXTICR[0] &= ~(0xF << 0);		//gpio--exti connect
	
	EXTI->IMR |= 1 << 0;				//exti
	EXTI->RTSR |= 1 << 0;
	
	nvic_init(EXTI0_IRQn, 2, 1, 2);
	
}

void EXTI0_IRQHandler(void)
{
	if(EXTI->PR & (1 << 0))
	{
		EXTI->PR |= 1 << 0;
		GPIOD->ODR ^= 1 << 2;
	}	
}
  1. 串口的基本使用
void usart_init(uint32_t baud)
{
	uint32_t mantissa, fraction;
	
	RCC->APB2ENR |= 1 << 4;		//GPIOA
	RCC->APB1ENR |= 1 << 17;	//USART1
	
	GPIOA->CRL &= ~(0xF << 8);
	GPIOA->CRL |= 3 << 8;
	GPIOA->CRL |= 2 << 10;		//PA2
	
	GPIOA->CRL &= ~(0xF << 12);
	GPIOA->CRL |= 1 << 14;		//PA3
	
	USART2->CR1 &= ~(1 << 12);	//8x1
	USART2->CR1 &= ~(1 << 10);	//no parity
	USART2->CR1 |= 1 << 5;		//rx not empty interrupt
	USART2->CR1 |= 1 << 3;		//tx enable
	USART2->CR1 |= 1 << 2;		//rx enable
	
	USART2->CR2 &= ~(3 << 12);	//1 stop bit
	
	mantissa = 36000000 / baud / 16;
	fraction = (uint32_t)((float)36000000 / baud - mantissa);
	USART2->BRR = (mantissa << 4) | fraction;
		
	USART2->CR1 |= 1 << 13;		//enable
	
	nvic_init(USART2_IRQn, 1, 3, 2);
}

void USART2_IRQHandler(void)
{
	uint8_t tmp;
	
	if(USART2->SR & (1 << 5))
	{
		tmp = USART2->DR;
		USART2->DR = tmp;
	}
}
  1. 基本定时器的使用
void tim2_init(void)
{
	RCC->APB1ENR |= 1 << 0;		//TIM2
	
	TIM2->CR1 |= 1 << 7;		//ARR Preload
	TIM2->CR1 &= ~(1 << 4);		//count up
	TIM2->ARR = 10000 - 1;
	TIM2->PSC = 7200 - 1;
	
	TIM2->DIER |= 1 << 0;		//Update interrupt
	
	TIM2->CR1 |= 1 << 0;		//enable
	
	nvic_init(TIM2_IRQn, 1, 2, 2);
}

void TIM2_IRQHandler(void)
{
	if(TIM2->SR & (1 << 0))
	{
		TIM2->SR &= ~(1 << 0);
		GPIOD->ODR ^= 1 << 2;
	}
}
  1. RTC秒中断
void rtc_init(void)
{
	RCC->APB1ENR |= 1 << 28;	//power clock
	RCC->APB2ENR |= 1 << 27;	//backup
	
	PWR->CR |= 1 << 8;			//rtc protection
	
	RCC->BDCR |= 1 << 16;		//reset 
	RCC->BDCR &= ~(1 << 16);	//clear reset flag
	RCC->BDCR |= 1 << 0;
	while(!(RCC->BDCR & (1 << 1)));		
	RCC->BDCR |= 1 << 8;		//LSE as RTC clock
	RCC->BDCR |= 1 << 15;		//rtc clock enable
	
	while(!(RTC->CRL & (1 << 3)));	//wait RTC ready
	
	RTC->CRL |= 1 << 4;				//go to configurtation mode
	while(!(RTC->CRL & (1 << 5)));	//wait RTC oeperation OFF	
	RTC->PRLL = 0x9C39;
	while(!(RTC->CRL & (1 << 5)));	//wait RTC oeperation OFF	
	RTC->CRH |= 1 << 0;			//second interrupt
	while(!(RTC->CRL & (1 << 5)));	//wait RTC oeperation OFF	
	
	nvic_init(RTC_IRQn, 1, 1, 2);
}

void RTC_IRQHandler(void)
{
	if(RTC->CRL & (1 << 0))
	{
		RTC->CRL &= ~(1 << 0);
		while(!(RTC->CRL & (1 << 5)));	//wait RTC oeperation OFF	
		GPIOD->ODR ^= 1 << 2;
	}
}
  1. IIC
void iic_init(void)
{
	RCC->APB2ENR |=  1 << 4;	//GPIOC
	
	GPIOC->CRH &= ~(0xF << 12);
	GPIOC->CRH |= 3 << 12;
	GPIOC->CRH |= 1 << 14;		//PC11
	
	GPIOC->CRH &= ~(0xF << 16);
	GPIOC->CRH |= 3 << 16;
	GPIOC->CRH |= 1 << 18;		//PC12 Open drain
	
	GPIOC->ODR |= 1 << 11;
	GPIOC->ODR |= 1 << 12;
	
}

void iic_start(void)
{
	IIC_SDA = 1;
	IIC_SCL = 1;
	delay_us(2);
	IIC_SDA = 0;
	delay_us(2);
	IIC_SCL = 0;
}

void iic_stop(void)
{
	IIC_SDA = 0;
	IIC_SCL = 0;
	delay_us(2);
	IIC_SCL = 1;
	delay_us(2);
	IIC_SDA = 1;
}

void iic_send_byte(uint8_t byte)
{
	IIC_SCL = 0;
	for(uint8_t i = 0; i < 8; i++)
	{
		IIC_SDA = (byte >> 7) & 0x1;
		byte <<= 1;
		delay_us(2);
		IIC_SCL = 1;
		delay_us(2);
		IIC_SCL = 0;
		delay_us(2);
	}
}

uint8_t iic_recv_byte(void)
{
	uint8_t tmp;
	
	for(uint8_t i = 0; i < 8; i++)
	{
		IIC_SCL = 0;
		delay_us(2);
		IIC_SCL = 1;
		tmp <<= 1;
		if(SDA_READ == 1)
		{
			tmp += 1;
		}
		delay_us(2);		
	}
	iic_ack();
	return tmp;
}

void iic_ack(void)
{
	IIC_SCL = 0;
	IIC_SDA = 0;
	delay_us(2);
	IIC_SCL = 1;
	delay_us(2);
	IIC_SCL = 0;
}

void iic_no_ack(void)
{
	IIC_SCL = 0;
	IIC_SDA = 1;
	delay_us(2);
	IIC_SCL = 1;
	delay_us(2);
	IIC_SCL = 0;
}

uint8_t iic_wait_ack(void)
{
	uint8_t time_out;
	
	IIC_SDA = 1;
	delay_us(2);
	IIC_SCL = 1;
	delay_us(2);
	while(SDA_READ)
	{
		if(time_out++ > 250)
		{
			iic_stop();
			return 1;
		}
	}
	IIC_SCL = 0;
	return 0;
}
  1. SPI
void spi_init(void)
{
	RCC->APB2ENR |= 1 << 2;
	RCC->APB2ENR |= 1 << 12;
	
	GPIOA->CRL &= ~(0xF << 20);
	GPIOA->CRL |= 3 << 20;		//SCK
	GPIOA->CRL |= 2 << 22;
	GPIOA->CRL &= ~(0xF << 24);
	GPIOA->CRL |= 2 << 26;
	GPIOA->ODR |= 1 << 6;		//MISO input 
	GPIOA->CRL |= ~((uint32_t)0xF << 28);
	GPIOA->CRL |= (uint32_t)2 << 30;
	GPIOA->CRL |= (uint32_t)3 << 28;		//MOSI	output
	
	SPI1->CR1 |= 1 << 15;		//bidirection
	SPI1->CR1 &= ~(1 << 11);	//8bit
	SPI1->CR1 |= 1 << 9;		//soft 
	SPI1->CR1 |= 1 << 8;		//SSI
	SPI1->CR1 &= ~(1 << 7);		//MSB
	SPI1->CR1 |= 2 << 3;		//BAUD
	SPI1->CR1 |= 1 << 2;		//Master
	SPI1->CR1 &= ~(1 << 1);		//CPOL low
	SPI1->CR1 &= ~(1 << 0);		//CPHA low	
	
	SPI1->CR1 |= 1 << 6;		//enable
	
}

uint8_t spi_write_read_byte(uint8_t byte)
{
	while(!(SPI1->SR & (1 << 1)))
	{
		
	}
	SPI1->DR = byte;
	
	while(!(SPI1->SR & (1 << 0)))
	{
		
	}
	return SPI1->DR;
}
xinshou249
关注
  • 0
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
stm32库编程
2301_76143875的博客
01-01 1832
在用寄存器点亮 LED 的时候，我们会发现 STM32 的寄存器都是 32 位的，每次配置的时候都要对照着《STM32F10X-中文参考手册》中寄存器的说明，然后根据说明对每个控制的寄存器位写入特定参数，因此在配置的时候非常容易出错，而且代码还很不好理解，不便于维护。而STM32单片机的外设数量要比51单片机丰富的多，架构和功能也复杂的多，带来的必然是寄存器的数量和复杂度的增加，如仅一个GPIO端口就有7个可配置的寄存器，还不包括与之配套的时钟、中断部分，更不包括依赖IO的其他外设的复用和重定义功能。
STM32-寄存器编程-使用寄存器点亮LED
pangyujinqwe的博客
05-21 4796
本文章详细的介绍了如何使用寄存器编程，简单的介绍了STM32的启动文件。附带了如何配置寄存器和使用寄存器点亮LED的代码
关于STM32的寄存器操作学习
lemou1211的博客
02-23 4496
STM32的寄存器操作学习记录
STM32通用定时器的应用实例（基于STM32F103）
最新发布
mftang的博客
05-25 1033
本文主要讲述STM32F103系列芯片通用定时器的使用方法，通用定时器仅仅只能实现定时功能，笔者使用STM32Cube工具，快速实现和定时器相关的功能代码，然后编写回调函数，以测试定时器功能的精确度。采用逻辑分析仪捕捉波形验证了其准确度。
AT24CXX系列芯片在STM32F103单片机下的读写程序
ba_wang_mao的专栏
08-21 5005
本程序取自正点原子开发板，应用于STM32F103单片机，适用AT24C01，AT24C02，AT24C04，AT24C08，AT24C16，AT24C32，AT24C64，AT24C128，AT24C256，AT24C512系列I2C存储芯片。 一、sys.h #ifndef __SYS_H #define __SYS_H #include "stm32f10x.h" //////////////////////////////////////////////////////////////.
STM32基于寄存器编程
WWester的博客
02-22 1935
在51中让一个引脚输出高低电平只需要一个步骤，而在32中至少需要三个步骤。本文将一步步进阶的讲解，三种寄存器编程的方法。
STM32 入门 —— 寄存器与 GPIO
ppqppl的博客
10-02 4083
STM32 入门 —— 寄存器与 GPIO STM32 总线构图： 寄存器 什么是寄存器 根据百度百科介绍，寄存器是中央处理器内的组成部分。寄存器是有限存贮容量的高速存贮部件，它们可用来暂存指令、数据和地址。简单来说，寄存器就是存放东西的东西，存放的东西是指令、数据或地址 存放数据的寄存器最容易理解，不同的数据存在不同的寄存器下，不同的寄存器有不同的地址，要想获得数据，我们直接访问寄存器，就可...
1，STM32F1标准例程-寄存器版本.zip
04-22
这个"STM32F1标准例程-寄存器版本"是一个专门针对STM32F1芯片的开发资源包，它包含了使用寄存器级别的编程实例，帮助开发者深入了解并掌握STM32F1的硬件功能和底层控制。 STM32F1系列拥有丰富的外设集，包括ADC...
STM32F4开发指南-寄存器版本.docx
12-05
本手册将由浅入深，带领大家学习 STM32F407 的各个功能，为您开启全新的 STM32 之旅。本手册总共分为三篇：1，...3，实战篇，主要通过 58 个实例（绝大部分是直接操作寄存器完成的）带领大家一步步深入了解STM32F4。
STM32F4xx标准例程-寄存器版本
08-09
这个“STM32F4xx标准例程-寄存器版本”是针对该系列芯片的一个开发资源包，它包含了用寄存器级别的编程实现的各种功能示例，这对于理解STM32F4的底层工作原理以及进行高效低级编程非常有帮助。 首先，STM32F4的...
1，标准例程-寄存器版本_STM32F103_STM32F103寄存器_
09-30
总结来说，STM32F103的标准例程-寄存器版本教程将引导学习者了解和掌握STM32F103芯片的各个功能模块，通过直接操作寄存器实现硬件功能，这对于深入理解微控制器的工作原理和优化系统性能至关重要。通过实践这些例程...
【STM32学习】定时器寄存器配置、功能工作过程详解
一年之内毫无半点成绩，想起来做人真是没趣。
03-22 4465
STM32定时器详解
STM32的四种开发方式
weixin_46251230的博客
08-20 8904
并且HAL库也很好的解决了程序移植的问题，不同型号的stm32芯片它的标准库是不一样的，例如在F4上开发的程序移植到F3上是不能通用的，而使用HAL库，只要使用的是相通的外设，程序基本可以完全复制粘贴，注意是相通外设，意思也就是不能无中生有，例如F7比F3要多几个定时器，不能明明没有这个定时器却非要配置，但其实这种情况不多，绝大多数都可以直接复制粘贴。且官方的驱动库为了容错性高一些等原因，会引入一些判断机制，相对复杂一些，但是实际上有的东西是我们用不到的，这就会造成代码执行效率会相对低一些。
stm32 直接读写寄存器代码风格总结
小磊's blog
05-06 5571
简单的总结了一下stm32 寄存器读写代码风格，以备后用： 根据memory mapping 直接写寄存器代码风格： #define GPIOA_BASE1 (uint32_t)0x40010800 #define GPIOA_CRH ((uint32_t*)(GPIOA_BASE1+0x04)) 转换为指针之后，直接读写： *GPIOA_CRH=0x000004B0; /
STM32的寄存器操作
qq_28576837的博客
08-18 2736
STM32的寄存器操作
寄存器1、怎么操作stm32寄存器/操作单片机寄存器
zd845101500的博客
08-28 8187
通过3个问题理解寄存器及其操作。 什么是寄存器（就是个数字）？ 简单可以理解为能够通过软件改写数值、控制硬件的一个32bit的数字。多个数字一起控制一个外设。 这个数值在哪？ 这个数字要被存起来，就一定有一个存储的地址，地址可以通过单片机的数据手册查到。 如何改写这个数值？ 有了地址，可以设置一个指针指向此地址，然后写入数据。有库可以直接写寄存器名字进行操作。 详细解读： 1、什么是寄存器（就是个数字）？ 寄存器是实现软硬件的接口，几乎所有的硬件功能控制都是通过操作寄存器来实现的，..
stm32 寄存器操作一看就会
热门推荐
yangyaokun0220的博客
05-02 2万+
1. 寄存器是什么？ 可以查百度，查看详情。。。。。。。。。我的总结：在嵌入式里面寄存器非常非常重要重，就是实现软硬件的接口，几乎所有的功能操作都是通过操作寄存器来实现的。2. 寄存器操作，点亮一盏led灯。以stm32f103为例，点亮PB8控制的led灯，PB8输出高电平led灯亮，输入低电平led灭。查看参考手册，一定学会阅读手册。操作分为四步。第一步 开启外设时钟使能寄存器，当外设时钟没有...
stm32的GPIO编程之寄存器操作
qq_46523260的博客
06-21 1558
直接寄存器操作 编程思路 ① 找到控制LED灯连接的GPIO口PB5和PE5 ② 确定GPIO口工作模式：推挽输出，高电平灯灭，低电平灯亮 ③ 确定端口寄存器映射地址 ④ 编程，读写相应的寄存器 3种方式： • 直接写寄存器ODR • 写BSRR • 位带操作 ⑤ 编译、下载、调试 1. ODR直写方式： PB的基地址0x40010C00 PE的基地址0x40011800 PB5设置: • CRL：地址0x4001 0C00 + 0x00。值：CNF5[1:0]=00、 MODE5[1:0]=11，故CRL
stm32l431实例 寄存器版
06-24
在编写STM32L431的寄存器编程实例时，我们需要先了解STM32L431的寄存器地址映射。STM32L431的寄存器分为若干个寄存器组，每个寄存器组包含若干个寄存器，每个寄存器有固定的地址和位域定义。我们需要根据需要的功能...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值