• 单片机操作系统，按键与FIFO

    前言

    1.之前做按键，在中断判断并进入回调函数，但是经常会导致其他任务来不及处理，或者是按键触发了但没有执行回调，即用户操作时感觉按键失灵。

    2.这里更新了一下代码，思路是这样的：中断进入按键扫描，有消抖，不阻塞，如果按键事件触发时即入列，然后操作系统每隔10ms进行一次轮询，若队列不为空，则出列并执行按键回调。

    有纰漏请指出，转载请说明。

    学习交流请发邮件 1280253714@qq.com

    key.c

    1.  
    2. #include "includes.h"
    3.  
    4. KEY_S key1;
    5. KEY_S key2;
    6.  
    7.  
    8. //按键平时为高电平，按下为低电平
    9. static void Key_GPIO_Config(void)
    10. {
    11. 	GPIO_InitTypeDef  GPIO_InitStruct;
    12. 	
    13. 	RCC_APB2PeriphClockCmd(KEY1_GPIO_CLK, ENABLE);	
    14. 	RCC_APB2PeriphClockCmd(KEY2_GPIO_CLK, ENABLE);
    15. 	
    16. 	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;		
    17. 	
    18. 	GPIO_InitStruct.GPIO_Pin = KEY1_GPIO_PIN;
    19. 	GPIO_Init(KEY1_GPIO_PORT, &GPIO_InitStruct);	
    20. 		
    21. 	GPIO_InitStruct.GPIO_Pin = KEY2_GPIO_PIN;
    22. 	GPIO_Init(KEY2_GPIO_PORT, &GPIO_InitStruct);	
    23. }
    24.  
    25. void KeyOsInit(void)
    26. {
    27. 	Key_GPIO_Config();
    28. 	
    29. 	key1.keyNum = keyNum1;
    30. 	key1.state = keyNone;
    31. 	key1.pfnKeyCallBack = key1TaskProc;
    32. 	
    33. 	key2.keyNum = keyNum2;
    34. 	key2.state = keyNone;
    35. 	key2.pfnKeyCallBack = key2TaskProc;
    36. }
    37.  
    38.  
    39. static bool readKeyGpioLevel(u8 keyNum)
    40. {
    41. 	bool keyRes = KEY_OFF;
    42. 	switch ( keyNum ){
    43. 		case keyNum1:
    44. 			keyRes = GPIO_ReadInputDataBit(KEY1_GPIO_PORT, KEY1_GPIO_PIN);
    45. 			break;
    46. 		case keyNum2:
    47. 			keyRes = GPIO_ReadInputDataBit(KEY2_GPIO_PORT, KEY2_GPIO_PIN);
    48. 			break;
    49. 		default:
    50. 			break;
    51. 	}
    52. 	return keyRes;
    53. }
    54.  
    55. void keyScanLoop(KEY_S *keyx)
    56. {
    57. 	if ( keyx->state == keyLong ){
    58. 		if (KEY_ON == readKeyGpioLevel(keyx->keyNum)){
    59. 			stKeyData.keyNum = keyx->keyNum;
    60. 			stKeyData.keyState = keyLong;
    61. 			KeyEnQueue(&stKeyQueue,&stKeyData);
    62. //			keyx->pfnKeyCallBack();		//如果是执行这里的话，那么就是在中断进入回调了
    63. 			return;
    64. 		} else {
    65. 			keyx->preState = keyx->state;
    66. 			keyx->state = keyNone;	
    67. 		}			
    68. 	}
    69. 	
    70. 	//	不在检测状态时按键按下
    71. 	if ( 0 == keyx->bIsChecking ){	
    72. 		if (KEY_ON == readKeyGpioLevel(keyx->keyNum)){
    73. 			keyx->readKeyLevel = KEY_ON;
    74. 			keyx->bIsChecking = 1;
    75. 			keyx->keyDownTimes = 0;		
    76. 			keyx->preState = keyx->state;
    77. 			keyx->state = keyNone;
    78. 			keyx->timedReadRes = 0;
    79. 			keyx->checkInterval = checkIntervalMs;
    80. 			keyx->shakeInterval = shakeIntervalMs;
    81. 		}
    82. 	} else {
    83. 		//	按键周期倒计时
    84. 		if ( keyx->checkInterval ){
    85. 			keyx->checkInterval--;
    86. 			
    87. 			//	定时读取
    88. 			if ( keyx->timedReadInterval ){
    89. 				keyx->timedReadInterval--;
    90. 			} else {
    91. 				keyx->timedReadInterval = timedReadIntervalMs;
    92. 				if( KEY_ON == readKeyGpioLevel(keyx->keyNum) ){
    93. 					keyx->timedReadRes++;
    94. 				}
    95. 			}
    96. 	
    97. 			//	检测状态时按键按下
    98. 			if ( KEY_ON == keyx->readKeyLevel ) {				
    99. 				//	按键软件消抖
    100. 				if ( keyx->shakeInterval ){
    101. 					keyx->shakeInterval--;
    102. 				} else {
    103. 					keyx->shakeInterval = shakeIntervalMs;
    104. 					if (KEY_ON == readKeyGpioLevel(keyx->keyNum)){
    105. 						keyx->keyDownTimes++;
    106. 						//	读取的电平反转
    107. 						keyx->readKeyLevel = KEY_OFF;
    108. 					}
    109. 				} 				
    110. 			} else {
    111. 				if (KEY_OFF == readKeyGpioLevel(keyx->keyNum)){
    112. 					keyx->readKeyLevel = KEY_ON;
    113. 				}
    114. 			}
    115. 		} 
    116. 		//	按键倒计时结束，通过按下次数和定时读取次数判断按键键值
    117. 		else {
    118. 			keyx->bIsChecking = 0;			
    119. 			switch (keyx->keyDownTimes){
    120. 				case keyNone:
    121. 					keyx->state = keyNone;
    122. 					return;
    123. 				case keyShort:
    124. 					keyx->state = keyShort;
    125. 					break;
    126. 				case keyDouble:
    127. 				case keyTriple:	//按下三次也算双击
    128. 					keyx->state = keyDouble;
    129. 					break;
    130. 				default :
    131. 					keyx->state = keyLong;
    132. 					break;
    133. 			}
    134. 			if ( keyx->timedReadRes > keyLongTimes ){	//可自定义读取次数
    135. 				keyx->state = keyLong;	
    136. 			}
    137. 			stKeyData.keyNum = keyx->keyNum;
    138. 			stKeyData.keyState = keyx->state;
    139. 			KeyEnQueue(&stKeyQueue,&stKeyData);
    140. //			keyx->pfnKeyCallBack();		//如果是执行这里的话，那么就是在中断进入回调了
    141. 		}
    142. 	}
    143. }
    144.  
    145. void KeyTaskProc(void)
    146. {
    147. 	if(stKeyQueue.state != KeyQueueEmpty)
    148. 	{
    149. 		if(KeyDeQueue(&stKeyQueue) != KeyDataEmpty)
    150. 		{
    151. 			stKeyData = stKeyQueue.dataDeQueue;
    152. 			switch(stKeyData.keyNum)
    153. 			{
    154. 				case keyNum1:
    155. 					key1TaskProc();
    156. 					break;
    157. 				case keyNum2:
    158. 					key2TaskProc();
    159. 					break;
    160. 			}
    161. 		}
    162. 	}
    163. }
    164.  
    165. //定时器设置为1ms进一次中断
    166. void TIM3_IRQHandler()
    167. {
    168. 	if ( TIM_GetITStatus( TIM3, TIM_IT_Update) != RESET ) 
    169. 	{		
    170. 		keyScanLoop(&key1);
    171. 		keyScanLoop(&key2);
    172. 		TIM_ClearITPendingBit(TIM3 , TIM_FLAG_Update);  		 
    173. 	}	
    174. }
    175.  
    176. u32 key1Cnt=0;
    177. u32 key2Cnt=0;
    178.  
    179. void key1TaskProc(void)
    180. {
    181. 	if(key1.state == keyShort){
    182. 		key1Cnt++;
    183.  
    184. 	}
    185. 	if(key1.state == keyLong){
    186. 		if( key1.keyLongExeInterval ){
    187. 			key1.keyLongExeInterval--;
    188. 		} else {
    189. 			key1.keyLongExeInterval = keyLongExeIntervalMs;
    190. 			key1Cnt++;
    191.  
    192. 		}
    193. 	}
    194. }
    195.  
    196. void key2TaskProc(void)
    197. {
    198. 	if(key2.state == keyShort){
    199. 		key2Cnt++;
    200. 	}
    201. 	if(key2.state == keyLong){
    202. 		if( key2.keyLongExeInterval ){
    203. 			key2.keyLongExeInterval--;
    204. 		} else {
    205. 			key2.keyLongExeInterval = keyLongExeIntervalMs;
    206. 			key2Cnt++;
    207. 		}
    208. 	}
    209. }
    210.  
    211. /**************************************** 按键队列处理 ****************************************/
    212.  
    213. KeyQueue_S stKeyQueue;
    214. KeyQueueData_S stKeyData;
    215. /********************************************
    216. *	@函数名	QueueInit
    217. *	@描述	队列初始化
    218. *	@参数	需要初始化的队列
    219. *	@返回值	无
    220. *	@注意	无
    221. ********************************************/
    222. void KeyQueueInit(KeyQueue_S *queue)
    223. {
    224. 	memset(&queue, 0, sizeof(queue));
    225. }
    226.  
    227. /********************************************
    228. *	@函数名	QueueStateDetermine
    229. *	@描述	检查队列当前状态
    230. *	@参数	需要检查的队列
    231. *	@返回值	队列当前状态
    232. *	@注意	无
    233. ********************************************/
    234. KeyQueueState KeyQueueStateDetermine(KeyQueue_S *queue)
    235. {
    236. 	if(queue->size == 0)
    237. 	{
    238. 		return KeyQueueEmpty;
    239. 	}
    240. 	else if(queue->size == KeyQueueMaxSize)
    241. 	{
    242. 		return KeyQueueFull;
    243. 	}
    244. 	else
    245. 	{
    246. 		return KeyQueueNormal;
    247. 	}
    248. }
    249.  
    250. /********************************************
    251. *	@函数名	EnQueue
    252. *	@描述	入列
    253. *	@参数	
    254. 			queue 有入列需要的队列
    255. 			data  需要入列的数据
    256. *	@返回值	无
    257. *	@注意	当队列满时无法入列
    258. ********************************************/
    259. void KeyEnQueue(KeyQueue_S *queue, KeyQueueData_S *data)
    260. {
    261. 	if(queue->size == KeyQueueMaxSize)
    262. 	{
    263. 		return;
    264. 	}	
    265. 	queue->dataEnQueue = *data;
    266. 	queue->data[queue->rear] = queue->dataEnQueue;
    267. 	queue->size++;
    268. 	
    269. 	queue->rear++;
    270. 	if(queue->rear == KeyQueueMaxSize)
    271. 	{
    272. 		queue->rear = 0;
    273. 	}
    274. 	queue->state = KeyQueueStateDetermine(queue);
    275. }
    276.  
    277. /********************************************
    278. *	@函数名	DeQueue
    279. *	@描述	出列
    280. *	@参数	queue 有出列需要的队列
    281. *	@返回值	返回的数据是否为空
    282. *	@注意	实际出列的数据放在 queue->dataDeQueue
    283. ********************************************/
    284. KeyDeQueueState KeyDeQueue(KeyQueue_S *queue)
    285. {
    286. 	if(queue->size == 0)
    287. 	{
    288. 		return KeyDataEmpty;
    289. 	}
    290. 	queue->dataDeQueue = queue->data[queue->front];
    291. 	memset(&queue->data[queue->front], 0, sizeof(queue->data[queue->front]));
    292. 	queue->size--;
    293.  
    294. 	queue->front++;
    295. 	if(queue->front == KeyQueueMaxSize)
    296. 	{
    297. 		queue->front = 0;
    298. 	}
    299. 	queue->state = KeyQueueStateDetermine(queue);
    300. 	return KeyDataNormal;
    301. }
    302.

    key.h

    1. #ifndef __KEY_H
    2. #define __KEY_H	 
    3.  
    4. #include "includes.h"
    5.  
    6. typedef enum {
    7. 	keyNum1,
    8. 	keyNum2,
    9. 	keySum,
    10. } keyOrder;
    11.  
    12. typedef enum {
    13. 	keyNone = 0,
    14. 	keyShort,
    15. 	keyDouble,
    16. 	keyTriple,
    17. 	keyLong
    18. } keyState;
    19.  
    20. typedef struct key_s {
    21. 	keyOrder keyNum;
    22. 	bool bIsChecking;		//正在检测
    23. 	bool bTaskProcessing;
    24. 	bool readKeyLevel;
    25. 	keyState 	preState;	//上一个按键状态
    26. 	keyState 	state;	
    27. 	u8	timedReadInterval;	//定时读取的间隔
    28. 	u8	keyDownTimes;		//一个检测周期按下的次数
    29. 	u16	timedReadRes;		//定时读取，如果在一个检测周期按下的次数为1或2，而每隔n ms读取的低电平次数大于某个值，可认为是长按
    30. 	u16 shakeInterval;		//抖动多少时间后进行检测
    31. 	u16 checkInterval;		//整个检测的持续时间
    32. 	u16 keyLongInterval;	//长按后隔一段时间再检测，避免检测到短按
    33. 	u16 keyLongExeInterval;
    34. 	void (*pfnKeyCallBack)(void);
    35. } KEY_S;
    36.  
    37. extern KEY_S key1;
    38. extern KEY_S key2;
    39.  
    40. #define keyLongTimes		40
    41. #define timedReadIntervalMs	10	
    42. #define shakeIntervalMs		10
    43. #define checkIntervalMs		500
    44. #define keyLongExeIntervalMs	10 //OS 10ms进一次，10次触发一次长按，故为100ms
    45.  
    46. #define		KEY_ON      1	//按键平时为低电平，按下为高电平
    47. #define		KEY_OFF     0
    48.  
    49. #define KEY1_GPIO_PIN           GPIO_Pin_0
    50. #define KEY1_GPIO_PORT          GPIOA
    51. #define KEY1_GPIO_CLK           RCC_APB2Periph_GPIOA
    52.  
    53. #define KEY2_GPIO_PIN           GPIO_Pin_13
    54. #define KEY2_GPIO_PORT          GPIOC
    55. #define KEY2_GPIO_CLK           RCC_APB2Periph_GPIOC
    56.  
    57.  
    58. void KeyOsInit(void);
    59. void keyScanLoop(KEY_S *keyx);
    60. void KeyTaskProc(void);
    61. void key1TaskProc(void);
    62. void key2TaskProc(void);
    63.  
    64. /**************************************** 按键队列处理 ****************************************/
    65.  
    66. #define KeyQueueMaxSize 5	//队列最大存放的数据个数
    67.  
    68. typedef enum {
    69. 	KeyQueueEmpty,		//队列为空
    70. 	KeyQueueNormal,	//队列不为空
    71. 	KeyQueueFull,		//队列已满
    72. } KeyQueueState;	//队列当前状态
    73.  
    74. typedef enum {
    75. 	KeyDataEmpty,		//数据为空
    76. 	KeyDataNormal,		//数据不为空
    77. } KeyDeQueueState;	//出列的数据情况
    78.  
    79. typedef struct {
    80. 	keyOrder keyNum;
    81. 	keyState keyState;
    82. } KeyQueueData_S;		//队列存放的数据类型
    83.  
    84. // 定义队列结构
    85. typedef struct {
    86.     KeyQueueData_S data[KeyQueueMaxSize];	//队列缓存
    87. 	KeyQueueData_S dataEnQueue;				//入列数据
    88. 	KeyQueueData_S dataDeQueue;				//出列数据
    89. 	KeyQueueState state;					//队列当前状态
    90.     u8 front;								//队头
    91.     u8 rear;								//队尾
    92. 	u8 size;								//队列大小
    93. } KeyQueue_S;
    94.  
    95. void KeyQueueInit(KeyQueue_S *queue);
    96. KeyQueueState KeyQueueStateDetermine(KeyQueue_S *queue);
    97. void KeyEnQueue(KeyQueue_S *queue, KeyQueueData_S *data);
    98. KeyDeQueueState KeyDeQueue(KeyQueue_S *queue);
    99.  
    100. extern KeyQueue_S stKeyQueue;
    101. extern KeyQueueData_S stKeyData;
    102.  
    103. #endif

    main.c

    1. #include "includes.h"
    2.  
    3.  
    4. int main(void)
    5. { 
    6. 	TimerOsInit();
    7. 	LED_Init();
    8. 	UartInit();	
    9. 	AdcOsInit();
    10. 	OS_TaskInit();
    11. 	SysTickInit();
    12. 	KeyOsInit();
    13. 	
    14. 	OS_TaskCreat(Task1, UaetSendHeartBeat, 100);
    15. 	OS_TaskCreat(Task2, KeyTaskProc, 10);
    16. 	
    17. 	while (1){
    18. 		AdcTask();
    19. 		UartLoopTask();
    20. 		testPro();
    21. 		ledLoopTask();
    22. 		OS_TaskRun();
    23. 	}
    24. }

    演示效果

    STM32单片机操作系统、按键与FIFO_哔哩哔哩_bilibili

    STM32单片机操作系统、按键与FIFO

  • 相关阅读:
    C++ ，VCPKG那些事
    Java 反射机制到底是什么？
    知识蒸馏和知识图谱相结合的大模型微调方案
    【pytorch】2.2 pytorch 自动求导、 Tensor 与 Autograd
    scipy 与 sympy 模块在数学建模中的应用
    C++ 4种智能指针的定义与使用——学习记录008
    系统架构设计：11 论湖仓一体架构及其应用
    git 新手教程
    算法设计与分析 SCAU19184 传球游戏
    目标检测算法——工业缺陷数据集汇总1（附下载链接）
  • 原文地址：https://blog.csdn.net/weixin_45817947/article/details/132940788