STM32基础

/** Timer.c */
#include "stm32f10x.h"

void Timer_Init() {
    // 使能APB1总线
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    // 选择内部定时器（TIM2）
    TIM_InternalClockConfig(TIM2);

    // 初始化定时器
    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure = {
        .TIM_ClockDivision = TIM_CKD_DIV1,
        .TIM_CounterMode = TIM_CounterMode_Up,
        /* 注意！Period和Prescaler寄存器都是16位，最大仅能表示65535，故不能写成重装1000，分频72000的形式！*/
        .TIM_Period = 10000 - 1,
        .TIM_Prescaler = 7200 - 1,
        .TIM_RepetitionCounter = 0,
    };
    // 由于缓冲寄存器的存在，为了使值立刻生效，调用该函数时会即刻产生一次更新中断
    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure);
    // 故调用ClearFlag清除该中断，使计数器从0开始
    TIM_ClearFlag(TIM2, TIM_FLAG_Update);

    // 使能定时器中断
    TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);

    // 配置NVIC
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

    NVIC_InitTypeDef NVIC_InitStructure = {
        .NVIC_IRQChannel = TIM2_IRQn,
        .NVIC_IRQChannelCmd = ENABLE,
        .NVIC_IRQChannelPreemptionPriority = 1,
        .NVIC_IRQChannelSubPriority = 1,
    };
    NVIC_Init(&NVIC_InitStructure);

    // 最后别忘了启动定时器
    TIM_Cmd(TIM2, ENABLE);
}

/** main.c */
#include "OLED.h"
#include "Timer.h"
#include "stm32f10x.h"

int count = 0;

void main() {
    OLED_Init();
    Timer_Init();
    while (1) {
        OLED_ShowNum(1, 1, count, 10);
        OLED_ShowNum(2, 1, TIM_GetCounter(TIM2), 5);
    }
}

void TIM2_IRQHandler() {
    if (TIM_GetITStatus(TIM2, TIM_IT_Update) == SET) {
        count++;
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
    }
}

#include "stm32f10x.h"

void PWM_Init() {
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    TIM_InternalClockConfig(TIM2);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    GPIO_InitTypeDef GPIO_InitStructure = {
        .GPIO_Pin = GPIO_Pin_0,
        .GPIO_Mode = GPIO_Mode_AF_PP,
        .GPIO_Speed = GPIO_Speed_50MHz,
    };
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure = {
        .TIM_ClockDivision = TIM_CKD_DIV1,
        .TIM_CounterMode = TIM_CounterMode_Up,
        .TIM_Period = 2 - 1,     // ARR
        .TIM_Prescaler = 36 - 1,  // PSC
        .TIM_RepetitionCounter = 0,
    };

    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure);

    TIM_OCInitTypeDef TIM_OCInitStructure;
    TIM_OCStructInit(&TIM_OCInitStructure);

    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    TIM_OCInitStructure.TIM_Pulse = 1; // CCR

    TIM_OC1Init(TIM2, &TIM_OCInitStructure);

    TIM_Cmd(TIM2, ENABLE);
}

#include "stm32f10x.h"

void ADC1_Init() {
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    // 把ADC频率限制到12MHz
    RCC_ADCCLKConfig(RCC_PCLK2_Div6);

    GPIO_InitTypeDef GPIO_InitStructure = {
        .GPIO_Mode = GPIO_Mode_AIN,
        .GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1,
        .GPIO_Speed = GPIO_Speed_50MHz,
    };
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    ADC_InitTypeDef ADC_InitStructure = {
        .ADC_Mode = ADC_Mode_Independent,
        //^ AD多通道状态下禁止使用连续扫描!!!
        .ADC_ContinuousConvMode = DISABLE,
        .ADC_ScanConvMode = DISABLE,
        .ADC_DataAlign = ADC_DataAlign_Right,
        // 配置使用内部软件触发
        .ADC_ExternalTrigConv = ADC_ExternalTrigConv_None,
        // 采集规则组的一个通道
        .ADC_NbrOfChannel = 1,
    };
    ADC_Init(ADC1, &ADC_InitStructure);

    // 打开ADC开关（上电）
    ADC_Cmd(ADC1, ENABLE);

    // 初始化ADC
    ADC_ResetCalibration(ADC1);
    while (ADC_GetResetCalibrationStatus(ADC1));
    ADC_StartCalibration(ADC1);
    while (ADC_GetCalibrationStatus(ADC1));
}

uint16_t Get_ADC_Value(uint8_t ADC_Channel) {
    //// 通道ADC_Channel_0排在第一位
    // 用户自定义通道
    ADC_RegularChannelConfig(ADC1, ADC_Channel, 1, ADC_SampleTime_55Cycles5);
    // 软件触发采样
    ADC_SoftwareStartConvCmd(ADC1, ENABLE);
    while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
    return ADC_GetConversionValue(ADC1);
}

#include "ADC.h"
#include "Delay.h"
#include "OLED.h"
#include "stm32f10x.h"

int main() {
    OLED_Init();
    ADC1_Init();

    OLED_ShowString(1, 1, "PA0ADValue:");
    OLED_ShowString(2, 1, "PA1ADValue:");
    // OLED_ShowString(2, 1, "Volatge:0.00V");

    while (1) {
        uint16_t PA0_Value = Get_ADC_Value(ADC_Channel_0);
        //* 如果不小心设置了连续模式，所有通道都会被PA1_Value覆盖，如果电位器接PA0值会变成PA1
        uint16_t PA1_Value = Get_ADC_Value(ADC_Channel_1);
        OLED_ShowNum(1, 12, PA0_Value, 4);
        OLED_ShowNum(2, 12, PA1_Value, 4);
    }
}

#include "stm32f10x.h"
#include "MPU6050_Reg.h"
#include "stm32f10x_i2c.h"

#define MPU6050_Address 0xD0

uint8_t MPU6050_ReadReg(uint8_t address) {
    I2C_GenerateSTART(I2C2, ENABLE);
    while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);  // 等待EV5

    I2C_Send7bitAddress(I2C2, MPU6050_Address, I2C_Direction_Transmitter);
    while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);  // 等待EV6

    I2C_SendData(I2C2, address);
    while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);    // 等待EV8事件


    I2C_GenerateSTART(I2C2, ENABLE);
    while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);  // 等待EV5

    I2C_Send7bitAddress(I2C2, MPU6050_Address, I2C_Direction_Receiver);
    while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);  // 等待EV6(接收模式)

    // 根据STM32硬件I2C外设的设计特性，必须在数据的第一个字节接收开始之前设置好应答位，不能等到接收了才设置，否则针对的是下一个字节
    I2C_AcknowledgeConfig(I2C2,DISABLE);
    I2C_GenerateSTOP(I2C2, ENABLE);

    while(I2C_CheckEvent(I2C2,I2C_EVENT_MASTER_BYTE_RECEIVED)!=SUCCESS);    // 等待EV7
    uint8_t value = I2C_ReceiveData(I2C2);
    I2C_AcknowledgeConfig(I2C2,ENABLE);

    return value;
}

void MPU6050_WriteReg(uint8_t address, uint8_t value) {
    I2C_GenerateSTART(I2C2, ENABLE);
    while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);  // 等待EV5

    I2C_Send7bitAddress(I2C2, MPU6050_Address, I2C_Direction_Transmitter);
    while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);  // 等待EV6

    I2C_SendData(I2C2, address);
    while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);    // 等待EV8事件

    I2C_SendData(I2C2, value);
    while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);    // 等待EV8事件

    I2C_GenerateSTOP(I2C2, ENABLE);
}

void MPU6050_GetData(int16_t *arr) {}

void MPU6050_Init(){
	/*开启时钟*/
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);		//开启I2C2的时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);		//开启GPIOB的时钟

	/*GPIO初始化*/
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);					//将PB10和PB11引脚初始化为复用开漏输出

	/*I2C初始化*/
	I2C_InitTypeDef I2C_InitStructure;						//定义结构体变量
	I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;				//模式，选择为I2C模式
	I2C_InitStructure.I2C_ClockSpeed = 50000;				//时钟速度，选择为50KHz
	I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;		//时钟占空比，选择Tlow/Thigh = 2（实际仅在快速模式下生效）
	I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;				//应答，选择使能
	I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;	//应答地址，选择7位，从机模式下才有效
	I2C_InitStructure.I2C_OwnAddress1 = 0x00;				//自身地址，从机模式下才有效
	I2C_Init(I2C2, &I2C_InitStructure);						//将结构体变量交给I2C_Init，配置I2C2

	/*I2C使能*/
	I2C_Cmd(I2C2, ENABLE);									//使能I2C2，开始运行

	/*MPU6050寄存器初始化，需要对照MPU6050手册的寄存器描述配置，此处仅配置了部分重要的寄存器*/
	MPU6050_WriteReg(MPU6050_PWR_MGMT_1, 0x01);				//电源管理寄存器1，取消睡眠模式，选择时钟源为X轴陀螺仪
	MPU6050_WriteReg(MPU6050_PWR_MGMT_2, 0x00);				//电源管理寄存器2，保持默认值0，所有轴均不待机
	MPU6050_WriteReg(MPU6050_SMPLRT_DIV, 0x09);				//采样率分频寄存器，配置采样率
	MPU6050_WriteReg(MPU6050_CONFIG, 0x06);					//配置寄存器，配置DLPF
	MPU6050_WriteReg(MPU6050_GYRO_CONFIG, 0x18);			//陀螺仪配置寄存器，选择满量程为±2000°/s
	MPU6050_WriteReg(MPU6050_ACCEL_CONFIG, 0x18);			//加速度计配置寄存器，选择满量程为±16g
}

#include "stm32f10x.h"                  // Device header

/**
  * 函    数：SPI写SS引脚电平，SS仍由软件模拟
  * 参    数：BitValue 协议层传入的当前需要写入SS的电平，范围0~1
  * 返 回 值：无
  * 注意事项：此函数需要用户实现内容，当BitValue为0时，需要置SS为低电平，当BitValue为1时，需要置SS为高电平
  */
void MySPI_W_SS(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)BitValue);		//根据BitValue，设置SS引脚的电平
}

/**
  * 函    数：SPI初始化
  * 参    数：无
  * 返 回 值：无
  */
void MySPI_Init(void)
{
	/*开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	//开启GPIOA的时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);	//开启SPI1的时钟

	/*GPIO初始化*/
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					//将PA4引脚初始化为推挽输出

	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					//将PA5和PA7引脚初始化为复用推挽输出

	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					//将PA6引脚初始化为上拉输入

	/*SPI初始化*/
	SPI_InitTypeDef SPI_InitStructure;						//定义结构体变量
	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;			//模式，选择为SPI主模式
	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;	//方向，选择2线全双工
	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;		//数据宽度，选择为8位
	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;		//先行位，选择高位先行
	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;	//波特率分频，选择128分频
	SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;				//SPI极性，选择低极性
	SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;			//SPI相位，选择第一个时钟边沿采样，极性和相位决定选择SPI模式0
	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;				//NSS，选择由软件控制
	SPI_InitStructure.SPI_CRCPolynomial = 7;				//CRC多项式，暂时用不到，给默认值7
	SPI_Init(SPI1, &SPI_InitStructure);						//将结构体变量交给SPI_Init，配置SPI1

	/*SPI使能*/
	SPI_Cmd(SPI1, ENABLE);									//使能SPI1，开始运行

	/*设置默认电平*/
	MySPI_W_SS(1);											//SS默认高电平
}

/**
  * 函    数：SPI起始
  * 参    数：无
  * 返 回 值：无
  */
void MySPI_Start(void)
{
	MySPI_W_SS(0);				//拉低SS，开始时序
}

/**
  * 函    数：SPI终止
  * 参    数：无
  * 返 回 值：无
  */
void MySPI_Stop(void)
{
	MySPI_W_SS(1);				//拉高SS，终止时序
}

/**
  * 函    数：SPI交换传输一个字节，使用SPI模式0
  * 参    数：ByteSend 要发送的一个字节
  * 返 回 值：接收的一个字节
  */
uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
	while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) != SET);	//等待发送数据寄存器空

	SPI_I2S_SendData(SPI1, ByteSend);								//写入数据到发送数据寄存器，开始产生时序

	while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) != SET);	//等待接收数据寄存器非空

	return SPI_I2S_ReceiveData(SPI1);								//读取接收到的数据并返回
}

/* 非常简单 */
    OLED_Init();
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP, ENABLE);

    PWR_BackupAccessCmd(ENABLE);

    BKP_WriteBackupRegister(BKP_DR1, 0x1234);
    OLED_ShowHexNum(1, 1, BKP_ReadBackupRegister(BKP_DR1), 4);

#include "MyRTC.h"
#include "OLED.h"
#include "stm32f10x.h"
#include "time.h"

int main() {
    struct tm time_structure;
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP, ENABLE);
    OLED_Init();

    PWR_BackupAccessCmd(ENABLE);

    RCC_LSEConfig(RCC_LSE_ON);
    while (!RCC_GetFlagStatus(RCC_FLAG_LSERDY));

    RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    RCC_RTCCLKCmd(ENABLE);

    RTC_WaitForSynchro();
    RTC_WaitForLastTask();

    // 设置32768分频，在32.768KHz下每秒振动1次
    RTC_SetPrescaler(32768 - 1);
    RTC_WaitForLastTask();

    // 如果没有检测到0xCC就设置0xCC标志，同时重置时间
    uint16_t signal = BKP_ReadBackupRegister(BKP_DR1);
    if (signal != 0xCC) {
        MyRTC_SetCounter();
        BKP_WriteBackupRegister(BKP_DR1, 0xCC);
    }

    OLED_ShowString(1, 1, "Date:XXXX-XX-XX");
    OLED_ShowString(2, 1, "Time:XX:XX:XX");

    while (1) {
        time_t time_cnt = RTC_GetCounter();
        RTC_WaitForLastTask();
        time_structure = *localtime(&time_cnt);
        OLED_ShowNum(1, 6, time_structure.tm_year + 1900, 4);
        OLED_ShowNum(1, 11, time_structure.tm_mon + 1, 2);
        OLED_ShowNum(1, 14, time_structure.tm_mday, 2);
        OLED_ShowNum(2, 6, time_structure.tm_hour, 2);
        OLED_ShowNum(2, 9, time_structure.tm_min, 2);
        OLED_ShowNum(2, 12, time_structure.tm_sec, 2);
    }
}

#include "stm32f10x.h"
#include "time.h"

// 以2026年5月19日12点13分0秒为时间戳
uint16_t Date[] = {2026, 5, 19, 12, 13, 0};
void MyRTC_SetCounter() {
    time_t cnt;
    struct tm time_struct;
    time_struct.tm_year = Date[0] - 1900;
    time_struct.tm_mon = Date[1] - 1;
    time_struct.tm_mday = Date[2];
    time_struct.tm_hour = Date[3];
    time_struct.tm_min = Date[4];
    time_struct.tm_sec = Date[5];
    // mktime把struct tm结构体转换成时间戳
    cnt = mktime(&time_struct);

    RTC_SetCounter(cnt);
    RTC_WaitForLastTask();
}

#include "Delay.h"
#include "OLED.h"
#include "stm32f10x.h"
#include "Key.h"

int main() {
    OLED_Init();
    OLED_ShowString(1, 1, "IWDG");
    IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
    IWDG_SetPrescaler(IWDG_Prescaler_16);
    IWDG_SetReload(2500 - 1);
    // 使能之前喂一下狗
    IWDG_ReloadCounter();
    IWDG_Enable();
    // RCC_FLAG_IWDGRST的值取决于上次复位的原因，因为看门狗复位就等于1，否则等于0
    // 要明显观察此现象可以考虑把看门狗时间变长一些，1638.4ms足够
    if (RCC_GetFlagStatus(RCC_FLAG_IWDGRST)) {
        OLED_ShowString(3, 1, "IWDG_RST");
        Delay_ms(500);
        OLED_ShowString(3, 1, "        ");
        Delay_ms(500);
        RCC_ClearFlag();
    } else {
        OLED_ShowString(2, 1, "RST");
        Delay_ms(500);
        OLED_ShowString(2, 1, "   ");
        Delay_ms(500);
    }
    while (1) {
        GetKey_A0();
        IWDG_ReloadCounter();
        OLED_ShowString(4, 1, "FEED");
        Delay_ms(500);
        OLED_ShowString(4, 1, "    ");
        Delay_ms(500);
    }
}

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

void GetKey_A0() {
    RCC_APB2PeriphClockCmd(GPIOA, ENABLE);
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStruct);

    // 检测到引脚电平被拉低后等待20ms跳过波动阶段，然后如果低电平稳定就阻塞
    if (!GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0)) {
        Delay_ms(20);
        while (!GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0));
    }
}

#include "Delay.h"
#include "OLED.h"
#include "stm32f10x.h"

int main() {
    OLED_Init();
    OLED_Clear();

    // 在看门狗开启之前提示上一次的复位情况，持续一秒
    if (RCC_GetFlagStatus(RCC_FLAG_WWDGRST)) {
        OLED_ShowString(3, 1, "WWDGRST");
        Delay_ms(50);
        OLED_ShowString(3, 1, "       ");
    }

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE);
    WWDG_SetPrescaler(WWDG_Prescaler_8);
    // 对应窗口时间30ms，即写入WWDG_CR时如果WWDG_CR > 30触发窗口看门狗复位
    WWDG_SetWindowValue(0x40 | 21);
    // 对应超时时间50ms，如果过50ms还不喂狗，触发看门狗复位
    WWDG_Enable(0x40 | 54);

    while (1) {
        OLED_ShowString(4, 1, "Feed");
        Delay_ms(15);
        OLED_ShowString(4, 1, "    ");
        Delay_ms(15);
        WWDG_SetCounter(0x40 | 54);
    }
}