Keil笔记(缘更)

已于 2024-04-22 17:27:39 修改
阅读量2.6k 收藏 51
点赞数 20
文章标签： 笔记 单片机 嵌入式硬件
于 2024-03-15 16:14:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47534339/article/details/136741393
版权

Keil

一、使用Keil时可能会出现的问题

1.Project框不见了

view->Project Window
在这里插入图片描述

2.添加文件时找不到

原因：文件类型忘记选择All files
在这里插入图片描述

3.交换文件位置

当经常使用的文件,排在后面，不方便使用，可以用这个调整文件位置。（点击魔术棒旁边哪个三色图形）
在这里插入图片描述

4.main.c测试报1 warning

原因：last line of file ends without a newline。
没有如图的第10行，记得空一行。(文件最后多一个回车就行)
如果改完后没效果，需要重新打开一下main.c。
在这里插入图片描述
下次打开文件，还是报错，将代码对齐一下后就好了。(上图main函数整体往后了一格)
在这里插入图片描述

5.搜索Ctrl+F

鼠标点击要搜索的函数—》Ctrl+F
在这里插入图片描述

二、常识(小白版)

1、模电常识名词解释(白话随便版)

(1)VCC: 正
(2)GND: 负/接地
(3)GPIO: 引脚
(4)Set: 高电平
(5)ReSet: 低电平

(6)
无符号字符型：Unsigned char 。HAL库符号:Uint8_t。范围：255
无符号整型：Unsigned int。HAL：Uint16_t。范围：65535
无符号长整形：Unsigned long 。HAL：Uint32_t。范围:2^32-1

(7)三极管(电流)：
pnp:低电压导通，emitter箭头指向Base.
npn:高电压导通，Base—>Emitter
（ mos管(电压)）

(8)比较器(运放)： 通过比较输入信号的电压大小来产生输出信号。
(9)双稳态触发器： 是一种具有记忆功能的逻辑单元电路。它能储存一位二进制码。它有两个稳定的工作状态，在外加信号触发下电路可从一种稳定的工作状态转换到另一种稳定的工作状态。

(10)ne555: 通用时基电路。通过改变外部电容器和电阻的数值来控制周期（T=0.693(Ra+2Rb)C）和占空比（ D=(Ra+Rb)/(Ra+2xRb) ），实现各种脉冲波形的产生。
频率F=1/T。

(11)PCB： 印刷电路板

2、基础门电路

1.原理图：
在这里插入图片描述
软件：嘉立创EDA
(2)连线尽量不走直角

在这里插入图片描述

3、stm32缩写定义

(1)GPIO: 通用输入输出
(2)RCC: 复位与时钟控制器
(3)RTC: 实施时钟
(4)TIM: 通用定时器
(5)EXTI: 外部中断事件控制器
(6)SPI: 串行外设接口
(7)USART: 通用同步异步接收发射端
(8)I2C: 内部集成电路
(9)IWDG: 独立看门狗
(10)WWDG: 窗口看门狗

4、GPIO库函数

(1)GPIO_Write

//向指定 GPIO 数据端口写入数据
void GPIO_Write(GPIO_TypeDef* GPIOx, u16 PortVal)
/*参数
GPIOx：x 可以是 A，B，C，D 或者 E，来选择 GPIO 外设
PortVal: 待写入端口数据寄存器的值
*/

(2)GPIO_Init

//根据 GPIO_InitStruct 中指定的参数初始化外设 GPIOx 寄存器
void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
/*参数
GPIOx：x 可以是 A，B，C，D 或者 E，来选择 GPIO 外设
GPIO_InitStruct：指向结构 GPIO_InitTypeDef 的指针，包含了外设 GPIO 的配置信息
参阅 Section：GPIO_InitTypeDef 查阅更多该参数允许取值范围
*/

(3)GPIO_SetBits

set:置位（1）
Reset:复位/清零（0）

//设置指定的数据端口位(某个)
void GPIO_SetBits(GPIO_TypeDef* GPIOx, u16 GPIO_Pin)
/*参数
GPIOx：x 可以是 A，B，C，D 或者 E，来选择 GPIO 外设
GPIO_Pin：待设置的端口位
*/

(4)GPIO_ResetBits

//清除指定的数据端口位(某个)
void GPIO_ResetBits(GPIO_TypeDef* GPIOx, u16 GPIO_Pin)
/*参数
GPIOx：x 可以是 A，B，C，D 或者 E，来选择 GPIO 外设
GPIO_Pin：待设置的端口位
*/

(5)GPIO_WriteBit

//设置或者清除指定的数据端口位(某个)
void GPIO_WriteBit(GPIO_TypeDef* GPIOx, u16 GPIO_Pin, BitAction BitVal) 
/*参数
1: GPIOx：x 可以是 A，B，C，D 或者 E，来选择 GPIO 外设

2: GPIO_Pin：待设置的端口位

3: BitVal: 该参数指定了待写入的值,该参数必须取枚举 BitAction 的其中一个值
Bit_RESET: 清除数据端口位
Bit_SET: 设置数据端口位
*/

(6)GPIO_EXTILINEConfig

//选择 GPIO 管脚用作外部中断线路
void GPIO_EXTILineConfig(u8 GPIO_PortSource, u8 GPIO_PinSource)
/*参数
1: GPIO_PortSource: 选择用作外部中断线源的 GPIO 端口
eg:GPIO_PortSourceGPIOA(选择 GPIOA)

2: GPIO_PinSource：待设置的外部中断线路
*/

(7)GPIO_ReadOutputData

//读取指定的 GPIO 端口输出(整个)
u16 GPIO_ReadOutputData(GPIO_TypeDef* GPIOx)
/*
参数：GPIOx：x 可以是 A，B，C，D 或者 E，来选择 GPIO 外设
返回值：GPIO 输出数据端口值
*/

(8)GPIO_ReadOutputDataBit

//读取指定端口管脚的输出(某个)
u8 GPIO_ReadOutputDataBit(GPIO_TypeDef* GPIOx, u16 GPIO_Pin)
/*
参数1：GPIOx：x 可以是 A，B，C，D 或者 E，来选择 GPIO 外设
参数2：GPIO_Pin：待读取的端口位
返回值：输出端口管脚值
*/

(9)GPIO_ReadInputData

//读取指定的 GPIO 端口输入(整个)
u16 GPIO_ReadInputData(GPIO_TypeDef* GPIOx)
/*
参数：GPIOx：x 可以是 A，B，C，D 或者 E，来选择 GPIO 外设
返回值：GPIO 输入数据端口值
*/

(10)GPIO_ReadInputDataBit

//读取指定端口管脚的输入(某个)
u8 GPIO_ReadInputDataBit(GPIO_TypeDef* GPIOx, u16 GPIO_Pin)
/*
参数1：GPIOx：x 可以是 A，B，C，D 或者 E，来选择 GPIO 外设
参数2：GPIO_Pin：待读取的端口位
返回值：输入端口管脚值
*/

(11)补充

1.GPIO_Pin值
GPIO_Pin_None     //无管脚被选中
GPIO_Pin_0        //选中管脚 0
...
GPIO_Pin_15       //选中管脚 15
GPIO_Pin_All      //选中全部管脚


2.GPIO_Speed
GPIO_Speed_10MHz   //最高输出速率 10MHz 
GPIO_Speed_2MHz    //最高输出速率 2MHz
GPIO_Speed_50MHz   //最高输出速率 50MHz

3.GPIO_Mode
GPIO_Mode_AIN              //模拟输入
GPIO_Mode_IN_FLOATING      //浮空输入
GPIO_Mode_IPD              //下拉输入
GPIO_Mode_IPU              //上拉输入
GPIO_Mode_Out_OD           //开漏输出
GPIO_Mode_Out_PP           //推挽输出
GPIO_Mode_AF_OD            //复用开漏输出
GPIO_Mode_AF_PP            //复用推挽输出

5、RCC库

(1)RCC_APB2PeriphClockCmd

//使能或者失能 APB2 外设时钟
void RCC_APB2PeriphClockCmd(u32 RCC_APB2Periph, FunctionalState NewState)
/*
RCC_APB2Periph: 门控 APB2 外设时钟
NewState：指定外设时钟的新状态。这个参数可以取：ENABLE 或者 DISABLE
*/

(2)RCC_APB1PeriphClockCmd

//使能或者失能 APB1 外设时钟
void RCC_APB1PeriphClockCmd(u32 RCC_APB1Periph, FunctionalState NewState)
/*
参数1：RCC_APB1Periph: 门控 APB1 外设时钟
参数2：NewState：指定外设时钟的新状态。这个参数可以取：ENABLE 或者 DISABLE 
*/

补充

1.RCC_AHB2Periph 值
RCC_APB2Periph_AFIO     //功能复用 IO 时钟
RCC_APB2Periph_GPIOA    //GPIOA 时钟
...
RCC_APB2Periph_GPIOE    //GPIOE 时钟
RCC_APB2Periph_ADC1     //ADC1 时钟
RCC_APB2Periph_ADC2     //ADC2 时钟
RCC_APB2Periph_TIM1     //TIM1 时钟
RCC_APB2Periph_SPI1     //SPI1 时钟
RCC_APB2Periph_USART1   //USART1 时钟
RCC_APB2Periph_ALL      //全部 APB2 外设时钟



2.RCC_AHB1Periph 值
RCC_APB1Periph_TIM2      //TIM2 时钟
RCC_APB1Periph_TIM3      //TIM3 时钟
RCC_APB1Periph_TIM4      //TIM4 时钟   
RCC_APB1Periph_WWDG      //WWDG时钟
RCC_APB1Periph_SPI2      //SPI2 时钟
RCC_APB1Periph_USART2    //USART2 时钟
RCC_APB1Periph_USART3    //USART3 时钟
RCC_APB1Periph_I2C1      //I2C1 时钟
RCC_APB1Periph_I2C2      //I2C2 时钟
RCC_APB1Periph_USB       //USB 时钟
RCC_APB1Periph_CAN       //CAN 时钟
RCC_APB1Periph_BKP       //BKP 时钟
RCC_APB1Periph_PWR       //PWR 时钟
RCC_APB1Periph_ALL       //全部 APB1 外设时钟

6、I2C库函数

(1)I2C_ AcknowledgeConfig

//使能或者失能指定 I2C 的应答功能
void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState) 
/*
参数1：I2Cx：x 可以是 1 或者 2，来选择 I2C 外设
参数2：NewState: I2Cx 应答的新状态,这个参数可以取：ENABLE 或者 DISABLE 
*/

(2)I2C_ GenerateSTART

//产生 I2Cx 传输 START 条件
void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState)
/*
参数1：I2Cx：x 可以是 1 或者 2，来选择 I2C 外设
参数2：NewState: I2Cx START 条件的新状态,这个参数可以取：ENABLE 或者 DISABLE
*/

(3)I2C_ GenerateSTOP

//产生 I2Cx 传输 STOP 条件
void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState) 
/*
参数1：I2Cx：x 可以是 1 或者 2，来选择 I2C 外设
参数2：NewState: I2Cx STOP 条件的新状态,这个参数可以取：ENABLE 或者 DISABLE
*/

(4)I2C_ SendData

//通过外设 I2Cx 发送一个数据
void I2C_SendData(I2C_TypeDef* I2Cx, u8 Data)
/*
参数1：I2Cx：x 可以是 1 或者 2，来选择 I2C 外设
参数2：Data: 待发送的数据
*/

(5)I2C_ ReceiveData

//返回通过 I2Cx 最近接收的数据
u8 I2C_ReceiveData(I2C_TypeDef* I2Cx)
/*
参数：I2Cx：x 可以是 1 或者 2，来选择 I2C 外设
*/

(6)I2C_ ReadRegister

//读取指定的 I2C 寄存器并返回其值
u16 I2C_ReadRegister(I2C_TypeDef* I2Cx, u8 I2C_Register)
/*
参数1：I2Cx：x 可以是 1 或者 2，来选择 I2C 外设
参数2：I2C_Register：待读取的 I2C 寄存器
返回值：被读取的寄存器值（读取寄存器可能会清除某些标志位）
*/

//I2C_Register ：
I2C_Register_SR1
I2C_Register_SR2
I2C_Register_CR1
I2C_Register_CR2
I2C_Register_OAR1
I2C_Register_OAR2
I2C_Register_DR
I2C_Register_CCR
I2C_Register_TRISE

(7)I2C_ GetFlagStatus

//检查指定的 I2C 标志位设置与否
FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, u32 I2C_FLAG)
/*
参数1：I2Cx：x 可以是 1 或者 2，来选择 I2C 外设
参数2：I2C_FLAG：待检查的 I2C 标志位
*/

//I2C_FLAG 值:
I2C_FLAG_BUSY        //总线忙标志位
I2C_FLAG_AF          //应答错误标志位
I2C_FLAG_ADDR        //地址发送标志位（主模式）“ADSL” ,地址匹配标志位（从模式）“ENDAD”
I2C_FLAG_SB          //起始位标志位（主模式）
I2C_FLAG_BERR        //总线错误标志位
I2C_FLAG_TRA         //发送/接收标志位
I2C_FLAG_RXNE        //数据寄存器非空标志位（接收端）
I2C_FLAG_STOPF       //停止探测标志位（从模式）
I2C_FLAG_TXE         //数据寄存器空标志位（发送端）
I2C_FLAG_BTF         //字传输完成标志位
I2C_FLAG_OVR         //溢出/不足标志位（从模式）
......

(8)I2C_ ClearFlag

//清除 I2Cx 的待处理标志位
void I2C_ClearFlag(I2C_TypeDef* I2Cx, u32 I2C_FLAG)
/*
参数1：I2Cx：x 可以是 1 或者 2，来选择 I2C 外设
参数2：I2C_FLAG：待清除的 I2C 标志位
注意：标志位 DUALF, SMBHOST,SMBDEFAULT,GENCALL,TRA,BUSY,MSL,TXE和RXNE 不能被本函数清除
*/

(9)I2C_ PECPositionConfig

//选择指定 I2C 的 PEC 位置
void I2C_PECPositionConfig(I2C_TypeDef* I2Cx, u16 I2C_PECPosition)
/*
参数1：I2Cx：x 可以是 1 或者 2，来选择 I2C 外设
参数2：I2C_ PECPosition：PEC 位置
*/

//I2C_ PECPosition 值:
2C_PECPosition_Next        //PEC 位提示下一字为 PEC
I2C_PECPosition_Current    //PEC 位提示当前字为 PEC

三、STLINK点灯操作

1.配置寄存器进行点灯

#include "stm32f10x.h"                  // Device header
int main(void)
{
	//配置寄存器进行点灯(需要查手册，)
	RCC->APB2ENR=0x00000010;//打开GPIOC时钟
	GPIOC->CRH=0x00300000;//PC13口的模式
	GPIOC->ODR=0x00002000;//输出数据：全零（亮），2（灭）
	while(1)
	{
	}
}

2.使用库函数进行点灯

#include "stm32f10x.h"                  // Device header
int main(void)
{
	//使用库函数进行点灯
	
	//1.配置外设时钟
	//可以右键-》GO To Definition...查看定义
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF,ENABLE);
	
	//2.配置端口模式
	//结构体
	GPIO_InitTypeDef CPIO_InitStructure;
	CPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;//模式
	CPIO_InitStructure.GPIO_Pin=GPIO_Pin_13;//端口
	CPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;//速度
	GPIO_Init(GPIOC,&CPIO_InitStructure);
	
	//3.设置端口高低电平(二选一进行测试)
	GPIO_SetBits(GPIOC,GPIO_Pin_13);//高电平(灭)
	GPIO_ResetBits(GPIOC,GPIO_Pin_13);//低电平(亮)
	while(1)
	{
	}
}

四.GPIO

（1）General PurPose Input Output： 通用输入输出口。
（2）引脚电平： 0V~3.3V。
（3）LED的接法：
在这里插入图片描述

1.LED闪烁

在这里插入图片描述
相关的用法：

	//将指定端口设置为高电平
	void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);
	//将指定端口设置为低电平
    void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);
	//根据第三个参数的值设置指定端口
    void GPIO_WriteBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, BitAction BitVal);
	//可以同时对16个端口进行写入操作
    void GPIO_Write(GPIO_TypeDef* GPIOx, uint16_t PortVal);

代码：

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
int main(void)
{
	//RCC中APB2外设时钟控制函数(右键可看参数)
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;//推挽输出
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;//引脚
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;//速度
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	
	//GPIO_SetBits(GPIOA,GPIO_Pin_0);
	//GPIO_ResetBits(GPIOA,GPIO_Pin_0);
	//GPIO_WriteBit(GPIOA,GPIO_Pin_0,Bit_RESET);//LED亮
	//GPIO_WriteBit(GPIOA,GPIO_Pin_0,Bit_SET);//LED灭
	while(1)
	{
		//方法2
		GPIO_ResetBits(GPIOA,GPIO_Pin_0);
		Delay_ms(500);
		GPIO_SetBits(GPIOA,GPIO_Pin_0);
		Delay_ms(500);
		
		//方法1.2
		GPIO_WriteBit(GPIOA,GPIO_Pin_0,(BitAction)0);
		Delay_ms(500);
		GPIO_WriteBit(GPIOA,GPIO_Pin_0,(BitAction)1);
		Delay_ms(500);
		
		//方法1
		GPIO_WriteBit(GPIOA,GPIO_Pin_0,Bit_RESET);
		Delay_ms(500);//毫秒延时函数：Delay文件中
		GPIO_WriteBit(GPIOA,GPIO_Pin_0,Bit_SET);
		Delay_ms(500);
	}
}

补充：
(1)复用推挽输出：由片上外设控制，高电平接VDD，低电平接VSS。

(2)复用开漏输出：由片上外设控制，高电平为高组态，低电平接VSS。

4.按键控制LED

(1)用法：
读取按键值：

    //用来读取输入数据寄存器某一个端口的输入值（返回值代表这个端口的高低电平）
	uint8_t GPIO_ReadInputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);
	//用来读取整个输入寄存器(唯一参数用来指定外设)
    uint16_t GPIO_ReadInputData(GPIO_TypeDef* GPIOx);
	//用来读取输出数据寄存器某一个位
    uint8_t GPIO_ReadOutputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);
	//用来读取整个输出寄存器
    uint16_t GPIO_ReadOutputData(GPIO_TypeDef* GPIOx);

五、通信接口

名称引脚双工时钟电平设备
USARTTX(数据发送脚)、RX(数据接收脚)全双工异步单端点对点
I2CSCL(时钟)、SDA(数据)半双工同步单端多设备
SPISCLK(时钟)、MOSI(主机输出数据脚)、MISO(主机输入数据脚)、CS(片选，用于指定通信对象)全双工同步单端多设备
CANCAN_H、CAN_L半双工异步差分多设备
USBDP、DM半双工异步差分点对点

1.串口参数及时序

(1)波特率： 串口通信的速率。
(2)起始位： 标志一个数据帧的开始，固定为低电平。
(3)数据位: 数据帧的有效载荷,1为高电平，0为低电平，低位先行。
(4)校验位: 用于数据验证，根据数据位计算得来。
(5)停止位: 用于数据帧间隔，固定为高电平。

2.USART

在这里插入图片描述

(1)串口接收：

//Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>
#include <stdarg.h>

void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);	//开启USART1的时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	//开启GPIOA的时钟
	
	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);					//将PA9引脚初始化为复用推挽输出
	
	USART_InitTypeDef USART_InitStructure;					//定义结构体变量
	USART_InitStructure.USART_BaudRate = 9600;				//波特率
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;	//硬件流控制，不需要
	USART_InitStructure.USART_Mode = USART_Mode_Tx;			//模式，选择为发送模式
	USART_InitStructure.USART_Parity = USART_Parity_No;		//奇偶校验，不需要
	USART_InitStructure.USART_StopBits = USART_StopBits_1;	//停止位，选择1位
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;		//字长，选择8位
	USART_Init(USART1, &USART_InitStructure);				//将结构体变量交给USART_Init，配置USART1
	
	USART_Cmd(USART1, ENABLE);								//使能USART1，串口开始运行
}

//串口发送一个字节(Byte 要发送的一个字节)
void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1, Byte);		//将字节数据写入数据寄存器，写入后USART自动生成时序波形
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);	//等待发送完成
	/*下次写入数据寄存器会自动清除发送完成标志位，故此循环后，无需清除标志位*/
}

//串口发送一个数组(Array 要发送数组的首地址,Length 要发送数组的长度)
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)		//遍历数组
	{
		Serial_SendByte(Array[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

//串口发送一个字符串(String为要发送字符串的首地址)
void Serial_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i ++)//遍历字符数组（字符串），遇到字符串结束标志位后停止
	{
		Serial_SendByte(String[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

//X的Y次方
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;	//设置结果初值为1
	while (Y --)			//执行Y次
	{
		Result *= X;		//将X累乘到结果
	}
	return Result;
}

 //串口发送数字(Number 要发送的数字,Length 要发送数字的长度)
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');	//依次调用Serial_SendByte发送每位数字
	}
}

int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);			//将printf的底层重定向到自己的发送字节函数
	return ch;
}

//自己封装的prinf函数(format 格式化字符串, ... 可变的参数列表)
void Serial_Printf(char *format, ...)
{
	char String[100];				//定义字符数组
	va_list arg;					//定义可变参数列表数据类型的变量arg
	va_start(arg, format);			//从format开始，接收参数列表到arg变量
	vsprintf(String, format, arg);	//使用vsprintf打印格式化字符串和参数列表到字符数组中
	va_end(arg);					//结束变量arg
	Serial_SendString(String);		//串口发送字符数组（字符串）
}

(2)串口发送：

//main.c
#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"

uint8_t RxData;			//定义用于接收串口数据的变量

int main(void)
{
	OLED_Init();		//OLED初始化
	OLED_ShowString(1, 1, "RxData:");  //显示静态字符串
	Serial_Init();		//串口初始化
/*	
	//查询
	while(1)
	{
		//不断判断RXNE标志位，如果为1,则已经收到数据
		if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE)==SET)
		{
			//读取DR寄存器
			RxData=USART_ReceiveData(USART1);//读DR可以自动清零标志位
			OLED_ShowHexNum(1,1,RxData,2);
		}
	}
*/
	
	//中断
	while (1)
	{
		if (Serial_GetRxFlag() == 1)			//检查串口接收数据的标志位
		{
			RxData = Serial_GetRxData();		//获取串口接收的数据
			Serial_SendByte(RxData);			//串口将收到的数据回传回去，用于测试
			OLED_ShowHexNum(1, 8, RxData, 2);	//显示串口接收的数据
		}
	}
}

//Serial.c

//获取串口接收标志位(返回值：串口接收标志位，范围：0~1，接收到数据后，标志位置1，读取后标志位自动清零)
uint8_t Serial_GetRxFlag(void)
{
	if (Serial_RxFlag == 1)			//如果标志位为1
	{
		Serial_RxFlag = 0;
		return 1;					//则返回1，并自动清零标志位
	}
	return 0;						//如果标志位为0，则返回0
}

//获取串口接收的数据
uint8_t Serial_GetRxData(void)
{
	return Serial_RxData;			//返回接收的数据变量(范围：0~255)
}

/*
   注意事项：此函数为中断函数，无需调用，中断触发后自动执行
           函数名为预留的指定名称，可以从启动文件复制
           请确保函数名正确，不能有任何差异，否则中断函数将不能进入
*/
//USART1中断函数
void USART1_IRQHandler(void)
{
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)		//判断是否是USART1的接收事件触发的中断
	{
		Serial_RxData = USART_ReceiveData(USART1);				//读取数据寄存器，存放在接收的数据变量
		Serial_RxFlag = 1;										//置接收标志位变量为1
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);			//清除USART1的RXNE标志位
																//读取数据寄存器会自动清除此标志位
																//如果已经读取了数据寄存器，也可以不执行此代码
	}
}

(3)串口收发HEX数据包
在这里插入图片描述

//Serial.c部分代码
#include "stm32f10x.h"                  // Device header
#include <stdio.h>
#include <stdarg.h>

uint8_t Serial_TxPacket[4];				//定义发送数据包数组，数据包格式：FF 01 02 03 04 FE
uint8_t Serial_RxPacket[4];				//定义接收数据包数组
uint8_t Serial_RxFlag;					//定义接收数据包标志位

void Serial_Init(void)
{
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);			//开启串口接收数据的中断
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);			//配置NVIC为分组2
	
	//NVIC配置
	NVIC_InitTypeDef NVIC_InitStructure;					//定义结构体变量
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;		//选择配置NVIC的USART1线
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//指定NVIC线路使能
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;		//指定NVIC线路的抢占优先级为1
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;		//指定NVIC线路的响应优先级为1
	NVIC_Init(&NVIC_InitStructure);							//将结构体变量交给NVIC_Init，配置NVIC外设
	
	//USART使能
	USART_Cmd(USART1, ENABLE);								//使能USART1，串口开始运行
}

//串口发送数据包(调用此函数后，Serial_TxPacket数组的内容将加上包头（FF）包尾（FE）后，作为数据包发送出去)
void Serial_SendPacket(void)
{
	Serial_SendByte(0xFF);
	Serial_SendArray(Serial_TxPacket, 4);
	Serial_SendByte(0xFE);
}

//USART1中断函数
void USART1_IRQHandler(void)
{
	static uint8_t RxState = 0;		//定义表示当前状态机状态的静态变量
	static uint8_t pRxPacket = 0;	//定义表示当前接收数据位置的静态变量
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)		//判断是否是USART1的接收事件触发的中断
	{
		uint8_t RxData = USART_ReceiveData(USART1);				//读取数据寄存器，存放在接收的数据变量
		/*使用状态机的思路，依次处理数据包的不同部分*/
		/*当前状态为0，接收数据包包头*/
		if (RxState == 0)
		{
			if (RxData == 0xFF)			//如果数据确实是包头
			{
				RxState = 1;			//置下一个状态
				pRxPacket = 0;			//数据包的位置归零
			}
		}
		/*当前状态为1，接收数据包数据*/
		else if (RxState == 1)
		{
			Serial_RxPacket[pRxPacket] = RxData;	//将数据存入数据包数组的指定位置
			pRxPacket ++;				//数据包的位置自增
			if (pRxPacket >= 4)			//如果收够4个数据
			{
				RxState = 2;			//置下一个状态
			}
		}
		/*当前状态为2，接收数据包包尾*/
		else if (RxState == 2)
		{
			if (RxData == 0xFE)			//如果数据确实是包尾部
			{
				RxState = 0;			//状态归0
				Serial_RxFlag = 1;		//接收数据包标志位置1，成功接收一个数据包
			}
		}
		
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);		//清除标志位
	}
}


//main.c
#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "Key.h"

uint8_t KeyNum;			//定义用于接收按键键码的变量

int main(void)
{
	//模块初始化
	OLED_Init();		//OLED初始化
	Key_Init();			//按键初始化
	Serial_Init();		//串口初始化
	
	//显示静态字符串
	OLED_ShowString(1, 1, "TxPacket");
	OLED_ShowString(3, 1, "RxPacket");
	
	//设置发送数据包数组的初始值，用于测试
	Serial_TxPacket[0] = 0x01;
	Serial_TxPacket[1] = 0x02;
	Serial_TxPacket[2] = 0x03;
	Serial_TxPacket[3] = 0x04;
	while (1)
	{
		KeyNum = Key_GetNum();			//获取按键键码
		if (KeyNum == 1)				//按键1按下
		{
			Serial_TxPacket[0] ++;		//测试数据自增
			Serial_TxPacket[1] ++;
			Serial_TxPacket[2] ++;
			Serial_TxPacket[3] ++;
			Serial_SendPacket();		//串口发送数据包Serial_TxPacket
			OLED_ShowHexNum(2, 1, Serial_TxPacket[0], 2);	//显示发送的数据包
			OLED_ShowHexNum(2, 4, Serial_TxPacket[1], 2);
			OLED_ShowHexNum(2, 7, Serial_TxPacket[2], 2);
			OLED_ShowHexNum(2, 10, Serial_TxPacket[3], 2);
		}
		
		if (Serial_GetRxFlag() == 1)	//如果接收到数据包
		{
			OLED_ShowHexNum(4, 1, Serial_RxPacket[0], 2);	//显示接收的数据包
			OLED_ShowHexNum(4, 4, Serial_RxPacket[1], 2);
			OLED_ShowHexNum(4, 7, Serial_RxPacket[2], 2);
			OLED_ShowHexNum(4, 10, Serial_RxPacket[3], 2);
		}
	}
}

(4)串口收发文本数据包
在这里插入图片描述

oid USART1_IRQHandler(void)
{
	static uint8_t RxState = 0;		//定义表示当前状态机状态的静态变量
	static uint8_t pRxPacket = 0;	//定义表示当前接收数据位置的静态变量
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)	//判断是否是USART1的接收事件触发的中断
	{
		uint8_t RxData = USART_ReceiveData(USART1);			//读取数据寄存器，存放在接收的数据变量
		/*使用状态机的思路，依次处理数据包的不同部分*/
		/*当前状态为0，接收数据包包头*/
		if (RxState == 0)
		{
			if (RxData == '@' && Serial_RxFlag == 0)		//如果数据确实是包头，并且上一个数据包已处理完毕
			{
				RxState = 1;			//置下一个状态
				pRxPacket = 0;			//数据包的位置归零
			}
		}
		/*当前状态为1，接收数据包数据，同时判断是否接收到了第一个包尾*/
		else if (RxState == 1)
		{
			if (RxData == '\r')			//如果收到第一个包尾
			{
				RxState = 2;			//置下一个状态
			}
			else						//接收到了正常的数据
			{
				Serial_RxPacket[pRxPacket] = RxData;		//将数据存入数据包数组的指定位置
				pRxPacket ++;			//数据包的位置自增
			}
		}
		/*当前状态为2，接收数据包第二个包尾*/
		else if (RxState == 2)
		{
			if (RxData == '\n')			//如果收到第二个包尾
			{
				RxState = 0;			//状态归0
				Serial_RxPacket[pRxPacket] = '\0';			//将收到的字符数据包添加一个字符串结束标志
				Serial_RxFlag = 1;		//接收数据包标志位置1，成功接收一个数据包
			}
		}
		
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);		//清除标志位
	}
}


//main.c
#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "LED.h"
#include "string.h"
int main(void)
{
	OLED_Init();		//OLED初始化
	LED_Init();			//LED初始化
	Serial_Init();		//串口初始化
	//显示静态字符串
	OLED_ShowString(1, 1, "TxPacket");
	OLED_ShowString(3, 1, "RxPacket");
	
	while (1)
	{
		if (Serial_RxFlag == 1)		//如果接收到数据包
		{
			OLED_ShowString(4, 1, "                ");
			OLED_ShowString(4, 1, Serial_RxPacket);				//OLED清除指定位置，并显示接收到的数据包
			
			/*将收到的数据包与预设的指令对比，以此决定将要执行的操作*/
			if (strcmp(Serial_RxPacket, "LED_ON") == 0)			//如果收到LED_ON指令
			{
				LED1_ON();										//点亮LED
				Serial_SendString("LED_ON_OK\r\n");				//串口回传一个字符串LED_ON_OK
				OLED_ShowString(2, 1, "                ");
				OLED_ShowString(2, 1, "LED_ON_OK");				//OLED清除指定位置，并显示LED_ON_OK
			}
			else if (strcmp(Serial_RxPacket, "LED_OFF") == 0)	//如果收到LED_OFF指令
			{
				LED1_OFF();										//熄灭LED
				Serial_SendString("LED_OFF_OK\r\n");			//串口回传一个字符串LED_OFF_OK
				OLED_ShowString(2, 1, "                ");
				OLED_ShowString(2, 1, "LED_OFF_OK");			//OLED清除指定位置，并显示LED_OFF_OK
			}
			else						//上述所有条件均不满足，即收到了未知指令
			{
				Serial_SendString("ERROR_COMMAND\r\n");			//串口回传一个字符串ERROR_COMMAND
				OLED_ShowString(2, 1, "                ");
				OLED_ShowString(2, 1, "ERROR_COMMAND");			//OLED清除指定位置，并显示ERROR_COMMAND
			}
			
			Serial_RxFlag = 0;			//处理完成后，需要将接收数据包标志位清零，否则将无法接收后续数据包
		}
	}
}

3.I2C通信

1.理论

在这里插入图片描述
在这里插入图片描述

2.实现

(1)电路连接(b站铁头山羊)
在这里插入图片描述
(2)初始化
在这里插入图片描述

static void App_I2C_Init(void)
{
	// #1. 初始化SCL和SDA引脚
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStruct;
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_OD;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStruct);
	
	// #2. 为I2C1开启时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
	RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
	RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, DISABLE);
	
	// #3. 配置I2C的参数
	I2C_InitTypeDef I2C_InitStruct;
	I2C_InitStruct.I2C_ClockSpeed = 400000;
	I2C_InitStruct.I2C_Mode = I2C_Mode_I2C;
	I2C_InitStruct.I2C_DutyCycle = I2C_DutyCycle_2;
	// I2C_InitStruct.I2C_OwnAddress1 = 0x12;
	// I2C_InitStruct.I2C_Ack = I2C_Ack_Disable;
	// I2C_InitStruct.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
	I2C_Init(I2C1, &I2C_InitStruct);
	
	// #4. 使能I2C
	I2C_Cmd(I2C1, ENABLE);
}

(3)主机数据发送
在这里插入图片描述

static ErrorStatus App_I2C_MasterTransmit(uint8_t SlaveAddr, const uint8_t *pData, uint16_t Size)
{	
	// #1. 等待总线空闲
	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY) == SET);
	
	// #2. 发送起始位
	I2C_GenerateSTART(I2C1, ENABLE);
	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_SB) == RESET);
	
	// #3. 发送从机地址
	I2C_ClearFlag(I2C1, I2C_FLAG_AF);
	I2C_SendData(I2C1, SlaveAddr & 0xfe);
	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_ADDR) == RESET)
	{
		if(I2C_GetFlagStatus(I2C1, I2C_FLAG_AF) == SET)
		{
			goto TAG_ERROR;
		}
	}
	I2C_ReadRegister(I2C1, I2C_Register_SR1);
	I2C_ReadRegister(I2C1, I2C_Register_SR2);
	
	// #4. 发送数据
	uint32_t i;
	for(i=0;i<Size;i++)
	{
		while(I2C_GetFlagStatus(I2C1, I2C_FLAG_TXE) == RESET)
		{
			if(I2C_GetFlagStatus(I2C1, I2C_FLAG_AF) == SET)
			{
				goto TAG_ERROR;
			}
		}
		I2C_SendData(I2C1, pData[i]);
	}
	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF) == RESET)
	{
		if(I2C_GetFlagStatus(I2C1, I2C_FLAG_AF) == SET)
		{
			goto TAG_ERROR;
		}
	}
	
	// #5. 发送停止位
	I2C_GenerateSTOP(I2C1, ENABLE);
	return SUCCESS;
	
TAG_ERROR:
	I2C_GenerateSTOP(I2C1, ENABLE);
	return ERROR;
}

测试

int main(void)
{
	 const uint8_t oled_init_command[] = {
		0x00, // Data Stream
		0xa8, 0x3f, // Set MUX Ratio
		0xd3, 0x00, // Set Display Offset
		0x40, // Set Display Start Line
		0xa0, // Set Segment re-map
		0xc0, // Set COM Output Scan Direction
		0xda, 0x02, // Set COM Pins hardware configuration
		0x81, 0x7f, // Set Contrast Control
		0xa5, // Enable Entire Display On
		0xa6, // Set Normal Display
		0xd5, 0x80, // Set OSC Frequency
		0x8d, 0x14, // Enable charge pump regulator
		0xaf, // Display on
	}; 
	PAL_Init();
	App_I2C_Init();
	App_I2C_MasterTransmit(0x78, oled_init_command, sizeof(oled_init_command)/sizeof(uint8_t));
	
	while(1)
	{
	}
}

(4)主机数据接收
在这里插入图片描述

static ErrorStatus App_I2C_MasterReceive(uint8_t SlaveAddr, uint8_t *pDataOut, uint16_t Size)
{
	if(Size == 0)
	{
		return ERROR;
	}
	
	// #1. 等待总线空闲
	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY) == SET);
	
	// #2. 发送起始位
	I2C_GenerateSTART(I2C1, ENABLE);
	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_SB) == RESET);	
	
	// #3. 发送从机地址
	I2C_ClearFlag(I2C1, I2C_FLAG_AF);
	I2C_SendData(I2C1, SlaveAddr | 0x01);
	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_ADDR) == RESET)
	{
		if(I2C_GetFlagStatus(I2C1, I2C_FLAG_AF) == SET)
		{
			goto TAG_ERROR;
		}
	}
	
	// #4. 接收数据
	
	I2C_AcknowledgeConfig(I2C1, ENABLE);
	I2C_NACKPositionConfig(I2C1, I2C_NACKPosition_Current);
	
	if(Size == 1)
	{
		I2C_ReadRegister(I2C1, I2C_Register_SR1);
		I2C_ReadRegister(I2C1, I2C_Register_SR2);
		I2C_AcknowledgeConfig(I2C1, DISABLE);
		I2C_NACKPositionConfig(I2C1, I2C_NACKPosition_Current);
		I2C_GenerateSTOP(I2C1, ENABLE);
		while(I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE)==RESET);
		pDataOut[0] = I2C_ReceiveData(I2C1);
	}
	else if(Size == 2)
	{
		I2C_AcknowledgeConfig(I2C1, ENABLE);
		I2C_ReadRegister(I2C1, I2C_Register_SR1);
		I2C_ReadRegister(I2C1, I2C_Register_SR2);
		while(I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE) == RESET);
		I2C_AcknowledgeConfig(I2C1, DISABLE);
		I2C_GenerateSTOP(I2C1, ENABLE);
		while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF) == RESET);
		pDataOut[0] = I2C_ReceiveData(I2C1);
		pDataOut[1] = I2C_ReceiveData(I2C1);
	}
	else
	{
		uint32_t i;
		
		I2C_ReadRegister(I2C1, I2C_Register_SR1);
		I2C_ReadRegister(I2C1, I2C_Register_SR2);
		
		for(i=0;i<Size-3;i++)
		{
			while(I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE) == RESET);
			pDataOut[i] = I2C_ReceiveData(I2C1);
		}
		
		while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF) == RESET);
		
		I2C_AcknowledgeConfig(I2C1, DISABLE);
		
		pDataOut[Size-3] = I2C_ReceiveData(I2C1);
		
		I2C_GenerateSTOP(I2C1, ENABLE);
		
		pDataOut[Size-2] = I2C_ReceiveData(I2C1);
		
		while(I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE) == RESET);
		pDataOut[Size-1] = I2C_ReceiveData(I2C1);
	}
	
	return SUCCESS;
TAG_ERROR:
	I2C_GenerateSTOP(I2C1, ENABLE);
	return ERROR;
}

测试

int main(void)
{
	PAL_Init();
	
	App_I2C_Init();
	
  const uint8_t oled_init_command[] = {
		0x00, // Data Stream
		0xa8, 0x3f, // Set MUX Ratio
		0xd3, 0x00, // Set Display Offset
		0x40, // Set Display Start Line
		0xa0, // Set Segment re-map
		0xc0, // Set COM Output Scan Direction
		0xda, 0x02, // Set COM Pins hardware configuration
		0x81, 0x7f, // Set Contrast Control
		0xa5, // Enable Entire Display On
		0xa6, // Set Normal Display
		0xd5, 0x80, // Set OSC Frequency
		0x8d, 0x14, // Enable charge pump regulator
		0xaf, // Display on
	}; 
	
	App_I2C_MasterTransmit(0x78, oled_init_command, sizeof(oled_init_command)/sizeof(uint8_t));
	
	const uint8_t oled_display_off_command[] = {0x00, 0xae};
	const uint8_t oled_display_on_command[] = {0x00, 0xaf};
	
	uint8_t buffer[8];
	
	// 熄灭屏幕
	App_I2C_MasterTransmit(0x78, oled_display_off_command, sizeof(oled_display_off_command)/sizeof(uint8_t));
	
	App_I2C_MasterReceive(0x78, buffer, 1);
	App_I2C_MasterReceive(0x78, buffer, 2);
	App_I2C_MasterReceive(0x78, buffer, 8);
	
	App_I2C_MasterTransmit(0x78, oled_display_on_command, sizeof(oled_display_on_command)/sizeof(uint8_t));
	
	App_I2C_MasterReceive(0x78, buffer, 1);
	App_I2C_MasterReceive(0x78, buffer, 2);
	App_I2C_MasterReceive(0x78, buffer, 8);
	
	while(1)
	{
	}
}

注：

内容来自b站STM32入门教程-江协科技，黑马程序员，铁头山羊，百度。

可在www.st.com下载芯片RM0008参考手册和DS5319数据手册。

星云之
关注
小白自学c51笔记之独立按键
hyy0723的博客
04-11 1454
时隔一个星期我终于又继续自学了，先夸夸我自己???? 先强调一下，横线划掉的部分是瞎扯，先记录一下，等我有缘知道了再回来???? 好了，先上个单片机开发板上独立按键的图（我的有四个）： 上述按键中23之间，14之间（即引脚之间距离长的）本来就是连通的，按下按键后1和2，3和4连通，如果想让按键连接两支路则可把两支路分别连到1，2或分别连到3，4（我觉得连到任两引脚都可）。 开发板原理图上独立按键模块： ...
笔记：8051中断源
mrwangwang的专栏
05-06 2493
在Keil上写了段C程序，搞清楚中断的实现。记下笔记：     1.8051的五个中断源  编号  中断源  入口地址   0  /INT0  0x0003   1  TIMER0  0x000b   2  /INT1  0x0013   3  TIMER1  0x001b   4  UART  0x
μC/OS-II 源码阅读笔记 —— 内核深度剖析
wangshixu0633的专栏
03-16 447
该笔记并非源代码的详细讲解，亦非μC/OS-II的使用说明，而是汇总了阅读源码过程中产生的疑问及解答，进而从中归纳总结出μC/OS-II系统的内在机理，对于想从本质和源头探索操作系统的程序猿或许有点参考帮助，或许能够启发更优质的使用μC/OS-II的方法，甚者若能就实际情况来优化μC/OS-II的内核以提高软件的质量则更当令此文欣慰了。
51单片机学习笔记（郭天祥版）（2）——第一课作业、流水灯、蜂鸣器
裂缘冰释
03-21 1474
免费样片申请(暂时无用，不说了，很简单) 作业讲解 1-5点亮灯过简单，不说了 6：尝试让第一个发光管闪烁 闪烁，就是亮，灭，再亮，再灭这样一个循环的过程，就是写程序控制某一个IO口先输出低电平，再输出高电平，再输出低电平，如此循环，没变化一个状态要持续一个时间(即为延时)。简单的延时就用一个while或者for循环就可以。 1 #include<reg52.h> 2 sbi...
keil 使用笔记
05-16
在Memory窗口上输入address_type:address才能看到正确地址的变量 debug～perfermance analyzer加入要察看的模块名称，然后view～perfermance analyzer window 可以察看各个模块运行时间
keil软件暗黑主题包
03-22
总之，“keil软件暗黑主题包”是针对Keil IDE的一种视觉改进，旨在提供一个更舒适、低疲劳的编程环境。通过安装和应用Monokai主题，用户可以在享受暗色界面带来的好处的同时，提升代码阅读和编写体验。
【笔记】keil使用技巧
08-03
以下是一些关于Keil的使用技巧，这些技巧可以帮助你更好地理解和优化你的开发流程。 1. **编译告警信息处理**： 当遇到"warning: #1295-D: Deprecated declaration"这样的告警时，这意味着你在代码中使用了一种被...
keil烧录笔记-代码保护
06-24
keil烧录HEX文件
C51#学习笔记01#| Keil软件的使用入门教程
01-20
 keil软件使用具体教程 烧录软件使用 IAR工程模板的创建 Keil软件的使用具体教程： 1、新建项目【project】-【New】-【uvision project】选择保存文件目录后，在弹出来的菜单栏中选择芯片型号【Atmel】-【STC89C...
微信小程序开发笔记之”表单读不出数据“解决指南
qq_46396470的博客
07-12 314
脑瓜子好了后，忘记了表单控件必须要加上。提交后打印的字典是空的，卡了十几分钟。
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
hanmo22357的博客
07-12 809
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
java Web学习笔记（三）
qq_62678419的博客
07-12 1030
java 前端工程框架 vue3 包括以下依赖的学习 vite npm router axios
OpenGL笔记十一之Uniform变量及实现一个颜色忽明忽暗的三角形
小勇博客
07-14 292
— 2024-07-14 上午。
STM32 - FLASH 笔记
上山的月的博客
07-15 774
关于江科大STM32中FLASH闪存模块的笔记，理解不能，步骤比较难，不过利用库函数操作还是比较简单的。至此江科大STM32 笔记已全部写完
STM32学习和实践笔记（40）：DS18B20温度传感器实验
qq_37191547的博客
07-15 16
DS18B20温度传感器的内部存储器包括一个高速的暂存器RAM和一个非易失性的可电擦除的EEPROM,后者存放高温度和低温度触发器TH、TL和配置寄存器。60~240 us，以产生低电平应答脉冲。单总线器件仅在主机发出读时序时，才向主机传输数据，所以，在主机发出读数据命令后，必须马上产生读时序，以便从机能够传输数据。比如我们要计算+85度，数据输出十六进制是0X0550，因为高字节的高5位为0，表明检测的温度是正温度，接着主机释放总线，外部的上拉电阻将单总线拉高，延时 15～60 us，并进入接收模式。
Cadence23学习笔记（三）
zjb6668的博客
07-15 253
焊接FPC的时候先上锡，焊台加热后再图上焊油，再放置元器件，再加热：万用表测电流只需要把表笔接到电流的孔位即可测量电流，不需要接再串联一个负载：有些线性电源两个通道可以串联，并联起来使用；
Linux笔记之shell终端命令后显示指定行数的grep和head
小勇博客
07-14 489
在Linux中，grep命令和head命令常用于文本处理。grep命令用于搜索文本中的特定模式，而head命令用于显示文件的开头部分。了解如何结合这两个命令（例如使用管道）可以帮助你更高效地处理和查看文本数据。grep -A选项用于在匹配到的行之后显示指定数量的行。例如，将显示匹配到的行及其后面的三行。选项用于显示文件的前n行。例如，将显示file.txt的前五行。
Scala学习笔记17: Try与异常处理
最新发布
Taerge0110的博客
07-15 328
Try类型是 Scala中函数式异常处理的重要工具, 它让挖煤可以用更优雅、更简洁的方式来处理异常, 使代码更易于理解和维护 .
keil 背景颜色更爱
07-28
抱歉，根据提供的引用内容，我无法找到与Keil背景颜色相关的信息。引用内容中提到了一些与C/C++文件和汇编文件相关的属性设置，但没有提到与背景颜色有关的内容。如果您有关于Keil背景颜色的具体问题，请提供更多的信息，我将尽力帮助您解答。 #### 引用[.reference_title] - *1* [keil主题颜色背景](https://blog.csdn.net/qq_36958104/article/details/109452307)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [更改keil主题颜色背景](https://blog.csdn.net/AN15778423590/article/details/124246658)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值