• STM32 入门教程（江科大教材）#笔记2

    3-4按键控制LED

    1. /** LED.c**/
    2. #include "stm32f10x.h"                  // Device header
    3.  
    4. void LED_Init(void)
    5. {
    6. 	/*开启时钟*/
    7. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);		//开启GPIOA的时钟
    8. 	
    9. 	/*GPIO初始化*/
    10. 	GPIO_InitTypeDef GPIO_InitStructure;
    11. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    12. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
    13. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    14. 	GPIO_Init(GPIOA, &GPIO_InitStructure);						//将PA1和PA2引脚初始化为推挽输出
    15. 	
    16. 	/*设置GPIO初始化后的默认电平*/
    17. 	GPIO_SetBits(GPIOA, GPIO_Pin_1 | GPIO_Pin_2);				//设置PA1和PA2引脚为高电平
    18. }
    19.  
    20. /**
    21.   * 函    数：LED1开启
    22.   * 参    数：无
    23.   * 返 回 值：无
    24.   */
    25. void LED1_ON(void)
    26. {
    27. 	GPIO_ResetBits(GPIOA, GPIO_Pin_1);		//设置PA1引脚为低电平
    28. }
    29.  
    30. /**
    31.   * 函    数：LED1关闭
    32.   * 参    数：无
    33.   * 返 回 值：无
    34.   */
    35. void LED1_OFF(void)
    36. {
    37. 	GPIO_SetBits(GPIOA, GPIO_Pin_1);		//设置PA1引脚为高电平
    38. }
    39.  
    40. void LED1_Turn(void)
    41. {
    42. 	if (GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_1) == 0)		//获取输出寄存器的状态，如果当前引脚输出低电平
    43. 	{
    44. 		GPIO_SetBits(GPIOA, GPIO_Pin_1);					//则设置PA1引脚为高电平
    45. 	}
    46. 	else													//否则，即当前引脚输出高电平
    47. 	{
    48. 		GPIO_ResetBits(GPIOA, GPIO_Pin_1);					//则设置PA1引脚为低电平
    49. 	}
    50. }
    51.  
    52. /**
    53.   * 函    数：LED2开启
    54.   * 参    数：无
    55.   * 返 回 值：无
    56.   */
    57. void LED2_ON(void)
    58. {
    59. 	GPIO_ResetBits(GPIOA, GPIO_Pin_2);		//设置PA2引脚为低电平
    60. }
    61.  
    62. /**
    63.   * 函    数：LED2关闭
    64.   * 参    数：无
    65.   * 返 回 值：无
    66.   */
    67. void LED2_OFF(void)
    68. {
    69. 	GPIO_SetBits(GPIOA, GPIO_Pin_2);		//设置PA2引脚为高电平
    70. }
    71.  
    72. /**
    73.   * 函    数：LED2状态翻转
    74.   * 参    数：无
    75.   * 返 回 值：无
    76.   */
    77. void LED2_Turn(void)
    78. {
    79. 	if (GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_2) == 0)		//获取输出寄存器的状态，如果当前引脚输出低电平
    80. 	{                                                  
    81. 		GPIO_SetBits(GPIOA, GPIO_Pin_2);               		//则设置PA2引脚为高电平
    82. 	}                                                  
    83. 	else                                               		//否则，即当前引脚输出高电平
    84. 	{                                                  
    85. 		GPIO_ResetBits(GPIOA, GPIO_Pin_2);             		//则设置PA2引脚为低电平
    86. 	}
    87. }
    1. /**Key.c**/
    2. #include "stm32f10x.h"                  // Device header
    3. #include "Delay.h"
    4. #include "stm32f10x_gpio.h"
    5. #include "stm32f10x_rcc.h"
    6.  
    7. void Key_Init(void)
    8. {
    9. 	/*开启时钟*/
    10. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);		//开启GPIOB的时钟
    11. 	
    12. 	/*GPIO初始化*/
    13. 	GPIO_InitTypeDef GPIO_InitStructure;
    14. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    15. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_11;
    16. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    17. 	GPIO_Init(GPIOB, &GPIO_InitStructure);						//将PB1和PB11引脚初始化为上拉输入
    18. }
    19.  
    20. /**
    21.   * 函    数：按键获取键码
    22.   * 参    数：无
    23.   * 返 回 值：按下按键的键码值，范围：0~2，返回0代表没有按键按下
    24.   * 注意事项：此函数是阻塞式操作，当按键按住不放时，函数会卡住，直到按键松手
    25.   */
    26. uint8_t Key_GetNum(void)
    27. {
    28. 	uint8_t KeyNum = 0;		//定义变量，默认键码值为0
    29. 	
    30. 	if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 0)			//读PB1输入寄存器的状态，如果为0，则代表按键1按下
    31. 	{
    32. 		Delay_ms(20);											//延时消抖
    33. 		while (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 0);	//等待按键松手
    34. 		Delay_ms(20);											//延时消抖
    35. 		KeyNum = 1;												//置键码为1
    36. 	}
    37. 	
    38. 	if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11) == 0)			//读PB11输入寄存器的状态，如果为0，则代表按键2按下
    39. 	{
    40. 		Delay_ms(20);											//延时消抖
    41. 		while (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11) == 0);	//等待按键松手
    42. 		Delay_ms(20);											//延时消抖
    43. 		KeyNum = 2;												//置键码为2
    44. 	}
    45. 	
    46. 	return KeyNum;			//返回键码值，如果没有按键按下，所有if都不成立，则键码为默认值0
    47. }
    1. /**main.c**/
    2. #include "stm32f10x.h"                  // Device header
    3. #include "Delay.h"
    4. #include "LED.h"
    5. #include "Key.h"
    6. uint8_t KeyNum;		//定义用于接收按键键码的变量
    7.  
    8. int main(void)
    9. {
    10. 	/*模块初始化*/
    11. 	LED_Init();		//LED初始化
    12. 	Key_Init();		//按键初始化
    13. 	
    14. 	while (1)
    15. 	{
    16. 		KeyNum = Key_GetNum();		//获取按键键码
    17. 		
    18. 		if (KeyNum == 1)			//按键1按下
    19. 		{
    20. 			LED1_Turn();			//LED1翻转
    21. 		}
    22. 		
    23. 		if (KeyNum == 2)			//按键2按下
    24. 		{
    25. 			LED2_Turn();			//LED2翻转
    26. 		}
    27. 	}
    28. }

    3-5光敏传感器控制蜂鸣器

    1. /*buzzer.c*/
    2. #include "stm32f10x.h"                  // Device header
    3.  
    4. void Buzzer_Init(void)
    5. {
    6. 	/*开启时钟*/
    7. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);		//开启GPIOB的时钟
    8. 	
    9. 	/*GPIO初始化*/
    10. 	GPIO_InitTypeDef GPIO_InitStructure;
    11. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    12. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
    13. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    14. 	GPIO_Init(GPIOB, &GPIO_InitStructure);						//将PB12引脚初始化为推挽输出
    15. 	
    16. 	/*设置GPIO初始化后的默认电平*/
    17. 	GPIO_SetBits(GPIOB, GPIO_Pin_12);							//设置PB12引脚为高电平
    18. }
    19.  
    20. void Buzzer_ON(void)
    21. {
    22. 	GPIO_ResetBits(GPIOB, GPIO_Pin_12);		//设置PB12引脚为低电平
    23. }
    24.  
    25. /**
    26.   * 函    数：蜂鸣器关闭
    27.   * 参    数：无
    28.   * 返 回 值：无
    29.   */
    30. void Buzzer_OFF(void)
    31. {
    32. 	GPIO_SetBits(GPIOB, GPIO_Pin_12);		//设置PB12引脚为高电平
    33. }
    34.  
    35. void Buzzer_Turn(void)
    36. {
    37. 	if (GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_12) == 0)		//获取输出寄存器的状态，如果当前引脚输出低电平
    38. 	{
    39. 		GPIO_SetBits(GPIOB, GPIO_Pin_12);						//则设置PB12引脚为高电平
    40. 	}
    41. 	else														//否则，即当前引脚输出高电平
    42. 	{
    43. 		GPIO_ResetBits(GPIOB, GPIO_Pin_12);						//则设置PB12引脚为低电平
    44. 	}
    45. }
    46. /*lightsensor*/
    47. #include "stm32f10x.h"                  // Device header
    48.  
    49. void LightSensor_Init(void)
    50. {
    51. 	/*开启时钟*/
    52. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);		//开启GPIOB的时钟
    53. 	
    54. 	/*GPIO初始化*/
    55. 	GPIO_InitTypeDef GPIO_InitStructure;
    56. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    57. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
    58. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    59. 	GPIO_Init(GPIOB, &GPIO_InitStructure);						//将PB13引脚初始化为上拉输入
    60. }
    61.  
    62. uint8_t LightSensor_Get(void)
    63. {
    64. 	return GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_13);			//返回PB13输入寄存器的状态
    65. }
    66. /*main.c*/
    67. #include "stm32f10x.h"                  // Device header
    68. #include "Delay.h"
    69. #include "Buzzer.h"
    70. #include "LightSensor.h"
    71.  
    72. int main(void)
    73. {
    74. 	/*模块初始化*/
    75. 	Buzzer_Init();			//蜂鸣器初始化
    76. 	LightSensor_Init();		//光敏传感器初始化
    77. 	
    78. 	while (1)
    79. 	{
    80. 		if (LightSensor_Get() == 1)		//如果当前光敏输出1
    81. 		{
    82. 			Buzzer_ON();				//蜂鸣器开启
    83. 		}
    84. 		else							//否则
    85. 		{
    86. 			Buzzer_OFF();				//蜂鸣器关闭
    87. 		}
    88. 	}
    89. }
    90.  
    91.  
    92.

    4-1 OLED调试工具

    OLED（Organic Light Emitting Diode）：有机发光二极管

    OLED显示屏：性能优异的新型显示屏，具有功耗低、相应速度快、宽视角、轻薄柔韧等特点

    0.96寸OLED模块：小巧玲珑、占用接口少、简单易用，是电子设计中非常常见的显示屏模块

    供电：3~5.5V，通信协议：I2C/SPI，分辨率：128*64

    三种调试方式

    OLED的驱动函数

     

    1. /**OLED.c**/
    2. #include "stm32f10x.h"
    3. #include "OLED_Font.h"
    4.  
    5. /*引脚配置*/
    6. #define OLED_W_SCL(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_8, (BitAction)(x))
    7. #define OLED_W_SDA(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_9, (BitAction)(x))
    8.  
    9. /*引脚初始化*/
    10. void OLED_I2C_Init(void)
    11. {
    12.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    13. 	
    14. 	GPIO_InitTypeDef GPIO_InitStructure;
    15.  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
    16. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    17. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    18.  	GPIO_Init(GPIOB, &GPIO_InitStructure);
    19. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    20.  	GPIO_Init(GPIOB, &GPIO_InitStructure);
    21. 	
    22. 	OLED_W_SCL(1);
    23. 	OLED_W_SDA(1);
    24. }
    25.  
    26. void OLED_I2C_Start(void)
    27. {
    28. 	OLED_W_SDA(1);
    29. 	OLED_W_SCL(1);
    30. 	OLED_W_SDA(0);
    31. 	OLED_W_SCL(0);
    32. }
    33.  
    34. /**
    35.   * @brief  I2C停止
    36.   * @param  无
    37.   * @retval 无
    38.   */
    39. void OLED_I2C_Stop(void)
    40. {
    41. 	OLED_W_SDA(0);
    42. 	OLED_W_SCL(1);
    43. 	OLED_W_SDA(1);
    44. }
    45.  
    46. void OLED_I2C_SendByte(uint8_t Byte)
    47. {
    48. 	uint8_t i;
    49. 	for (i = 0; i < 8; i++)
    50. 	{
    51. 		OLED_W_SDA(Byte & (0x80 >> i));
    52. 		OLED_W_SCL(1);
    53. 		OLED_W_SCL(0);
    54. 	}
    55. 	OLED_W_SCL(1);	//额外的一个时钟，不处理应答信号
    56. 	OLED_W_SCL(0);
    57. }
    58.  
    59. /**
    60.   * @brief  OLED写命令
    61.   * @param  Command 要写入的命令
    62.   * @retval 无
    63.   */
    64. void OLED_WriteCommand(uint8_t Command)
    65. {
    66. 	OLED_I2C_Start();
    67. 	OLED_I2C_SendByte(0x78);		//从机地址
    68. 	OLED_I2C_SendByte(0x00);		//写命令
    69. 	OLED_I2C_SendByte(Command); 
    70. 	OLED_I2C_Stop();
    71. }
    72.  
    73. void OLED_WriteData(uint8_t Data)
    74. {
    75. 	OLED_I2C_Start();
    76. 	OLED_I2C_SendByte(0x78);		//从机地址
    77. 	OLED_I2C_SendByte(0x40);		//写数据
    78. 	OLED_I2C_SendByte(Data);
    79. 	OLED_I2C_Stop();
    80. }
    81. void OLED_SetCursor(uint8_t Y, uint8_t X)
    82. {
    83. 	OLED_WriteCommand(0xB0 | Y);					//设置Y位置
    84. 	OLED_WriteCommand(0x10 | ((X & 0xF0) >> 4));	//设置X位置高4位
    85. 	OLED_WriteCommand(0x00 | (X & 0x0F));			//设置X位置低4位
    86. }
    87. void OLED_Clear(void)
    88. {  
    89. 	uint8_t i, j;
    90. 	for (j = 0; j < 8; j++)
    91. 	{
    92. 		OLED_SetCursor(j, 0);
    93. 		for(i = 0; i < 128; i++)
    94. 		{
    95. 			OLED_WriteData(0x00);
    96. 		}
    97. 	}
    98. }
    99.  
    100. void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char)
    101. {      	
    102. 	uint8_t i;
    103. 	OLED_SetCursor((Line - 1) * 2, (Column - 1) * 8);		//设置光标位置在上半部分
    104. 	for (i = 0; i < 8; i++)
    105. 	{
    106. 		OLED_WriteData(OLED_F8x16[Char - ' '][i]);			//显示上半部分内容
    107. 	}
    108. 	OLED_SetCursor((Line - 1) * 2 + 1, (Column - 1) * 8);	//设置光标位置在下半部分
    109. 	for (i = 0; i < 8; i++)
    110. 	{
    111. 		OLED_WriteData(OLED_F8x16[Char - ' '][i + 8]);		//显示下半部分内容
    112. 	}
    113. }
    114.  
    115. void OLED_ShowString(uint8_t Line, uint8_t Column, char *String)
    116. {
    117. 	uint8_t i;
    118. 	for (i = 0; String[i] != '\0'; i++)
    119. 	{
    120. 		OLED_ShowChar(Line, Column + i, String[i]);
    121. 	}
    122. }
    123.  
    124. /**
    125.   * @brief  OLED次方函数
    126.   * @retval 返回值等于X的Y次方
    127.   */
    128. uint32_t OLED_Pow(uint32_t X, uint32_t Y)
    129. {
    130. 	uint32_t Result = 1;
    131. 	while (Y--)
    132. 	{
    133. 		Result *= X;
    134. 	}
    135. 	return Result;
    136. }
    137.  
    138. void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
    139. {
    140. 	uint8_t i;
    141. 	for (i = 0; i < Length; i++)							
    142. 	{
    143. 		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(10, Length - i - 1) % 10 + '0');
    144. 	}
    145. }
    146.  
    147. void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length)
    148. {
    149. 	uint8_t i;
    150. 	uint32_t Number1;
    151. 	if (Number >= 0)
    152. 	{
    153. 		OLED_ShowChar(Line, Column, '+');
    154. 		Number1 = Number;
    155. 	}
    156. 	else
    157. 	{
    158. 		OLED_ShowChar(Line, Column, '-');
    159. 		Number1 = -Number;
    160. 	}
    161. 	for (i = 0; i < Length; i++)							
    162. 	{
    163. 		OLED_ShowChar(Line, Column + i + 1, Number1 / OLED_Pow(10, Length - i - 1) % 10 + '0');
    164. 	}
    165. }
    166.  
    167. void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
    168. {
    169. 	uint8_t i, SingleNumber;
    170. 	for (i = 0; i < Length; i++)							
    171. 	{
    172. 		SingleNumber = Number / OLED_Pow(16, Length - i - 1) % 16;
    173. 		if (SingleNumber < 10)
    174. 		{
    175. 			OLED_ShowChar(Line, Column + i, SingleNumber + '0');
    176. 		}
    177. 		else
    178. 		{
    179. 			OLED_ShowChar(Line, Column + i, SingleNumber - 10 + 'A');
    180. 		}
    181. 	}
    182. }
    183.  
    184. void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
    185. {
    186. 	uint8_t i;
    187. 	for (i = 0; i < Length; i++)							
    188. 	{
    189. 		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(2, Length - i - 1) % 2 + '0');
    190. 	}
    191. }
    192.  
    193. void OLED_Init(void)
    194. {
    195. 	uint32_t i, j;
    196. 	
    197. 	for (i = 0; i < 1000; i++)			//上电延时
    198. 	{
    199. 		for (j = 0; j < 1000; j++);
    200. 	}
    201. 	
    202. 	OLED_I2C_Init();			//端口初始化
    203. 	
    204. 	OLED_WriteCommand(0xAE);	//关闭显示
    205. 	
    206. 	OLED_WriteCommand(0xD5);	//设置显示时钟分频比/振荡器频率
    207. 	OLED_WriteCommand(0x80);
    208. 	
    209. 	OLED_WriteCommand(0xA8);	//设置多路复用率
    210. 	OLED_WriteCommand(0x3F);
    211. 	
    212. 	OLED_WriteCommand(0xD3);	//设置显示偏移
    213. 	OLED_WriteCommand(0x00);
    214. 	
    215. 	OLED_WriteCommand(0x40);	//设置显示开始行
    216. 	
    217. 	OLED_WriteCommand(0xA1);	//设置左右方向，0xA1正常 0xA0左右反置
    218. 	
    219. 	OLED_WriteCommand(0xC8);	//设置上下方向，0xC8正常 0xC0上下反置
    220.  
    221. 	OLED_WriteCommand(0xDA);	//设置COM引脚硬件配置
    222. 	OLED_WriteCommand(0x12);
    223. 	
    224. 	OLED_WriteCommand(0x81);	//设置对比度控制
    225. 	OLED_WriteCommand(0xCF);
    226.  
    227. 	OLED_WriteCommand(0xD9);	//设置预充电周期
    228. 	OLED_WriteCommand(0xF1);
    229.  
    230. 	OLED_WriteCommand(0xDB);	//设置VCOMH取消选择级别
    231. 	OLED_WriteCommand(0x30);
    232.  
    233. 	OLED_WriteCommand(0xA4);	//设置整个显示打开/关闭
    234.  
    235. 	OLED_WriteCommand(0xA6);	//设置正常/倒转显示
    236.  
    237. 	OLED_WriteCommand(0x8D);	//设置充电泵
    238. 	OLED_WriteCommand(0x14);
    239.  
    240. 	OLED_WriteCommand(0xAF);	//开启显示
    241. 		
    242. 	OLED_Clear();				//OLED清屏
    243. }
    244. /**main.c**/
    245. #include "stm32f10x.h"                  // Device header
    246. #include "Delay.h"
    247. #include "OLED.h"
    248.  
    249. int main(void)
    250. {
    251. 	/*模块初始化*/
    252. 	OLED_Init();		//OLED初始化
    253. 	
    254. 	/*OLED显示*/
    255. 	OLED_ShowChar(1, 1, 'A');				//1行1列显示字符A
    256. 	
    257. 	OLED_ShowString(1, 3, "HelloWorld!");	//1行3列显示字符串HelloWorld!
    258. 	
    259. 	OLED_ShowNum(2, 1, 12345, 5);			//2行1列显示十进制数字12345，长度为5
    260. 	
    261. 	OLED_ShowSignedNum(2, 7, -66, 2);		//2行7列显示有符号十进制数字-66，长度为2
    262. 	
    263. 	OLED_ShowHexNum(3, 1, 0xAA55, 4);		//3行1列显示十六进制数字0xA5A5，长度为4
    264. 	
    265. 	OLED_ShowBinNum(4, 1, 0xAA55, 16);		//4行1列显示二进制数字0xA5A5，长度为16
    266. 											//C语言无法直接写出二进制数字，故需要用十六进制表示
    267. 	
    268. 	while (1)
    269. 	{
    270. 		
    271. 	}
    272. }
    273.

  • 相关阅读:
    pgsql_全文检索_使用空间换时间的方法支持中文搜索
    [附源码]java毕业设计-室内田径馆预约管理系统
    【C++】pow函数实现的伽马变换详解和示例
    Pr：代理工作流程
    OpenCV（三十九）：积分图像
    高等教育学：课程
    PostgreSQL 查询某个属性相同内容出现的次数
    MediaCodec视频编码H264流程及参考demo
    TEINet: Towards an Efficient Architecture for Video Recognition 论文阅读
    joplin更新后找不到文章
  • 原文地址：https://blog.csdn.net/2301_79706774/article/details/139277561