一、RTOS程序任务结构
如上图所示，在实时操作系统中，开发人员可以把要实现的功能划分为多个任务，每个任务负责实现其中的一部分，每个任务都是一个很简单的程序，通常是一个死循环。
二、多任务系统基本概念
1、FreeRTOS相关函数
内核控制
o s D e l a y 函 数 是用户常用的毫秒级延时函数，osKernelGetTickCount是RTOS内核计数的获取函数，在系统内核节拍频率为默认的1000Hz时，这个内核计数即为系统启动到当前时刻的累计时间毫秒数（简称系统时间戳）。这两个函数是CMSIS多任务程序设计中常用的系统函数。
任务管理函数
2、任务及任务管理
除了任务创建与终止执行，常见任务管理还包括暂停任务与恢复任务两种操作。 osThreadSuspend可以让任务A挂起，保持在阻塞状态，直到其他任务使用
osThreadResume唤起任务A。如果其他任务的优先级低于任务A，那么唤起任务A的瞬间系统内核就会上下文切换至任务A，即马上运行。程序设计时，如果要暂停某个任务运行而后在某个时刻又恢复该任务的运行，就应该使用osThreadSuspend暂停任务而不是用osThreadTerminate终止任务。因为终止任务后只能用osThreadNew再新建一个任务，然而新建任务的内部变量值并不能恢复到终止任务时的状态。
3、任务优先级
任务优先级是RTOS内核给任务指定的优先等级，它决定了任务获 取CPU资源的优先次序。和STM32的中断优先级不同，在FreeRTOS中的任务优先级数值越小，任务的优先次序越低。FreeRTOS允许创建多个相同优先级的任务，同优先级任务将使用时间片算法进行调度。
IRQ任务：IRQ任务是在中断中进行触发的任务，此类任务可以设置较高优先级，其优先级数值可以设置为osPriorityHigh及其以上的几个优先级。
高优先级后台任务：如按键检测、串口消息处理等，都可以归类为这一类任务，其优先级数值可以设置为osPriorityNormal及其附近的几个优先级。
低优先级的时间片调度任务：如GUI界面显示、LED数码管显示等不需要实时执行的都可以归为这一类任务，这一类任务的优先级可以是osPriorityLow及其上下附近的几个优先级。
特别注意的是，IRQ任务和高优先级任务必须设置为阻塞式（任务函数循环中有调用消息等待或者延时等函数），只有这样，高优先级任务才会释放CPU资源，从而让低优先级任务有机会运行。
4、消息队列
CMSIS常见的任务间通信方式有消息队列（Message Queues）、信号量（Semaphores）互斥锁（Mutexes）和任务通知（Notifications）。这几种通信方式中，除了任务通知，其他几种方式都是基于消息队列来实现的。
消息队列作为任务间通信的一种数据结构，支持在任务与任务间、中断和任务间传递消息内容。通常情况下，消息队列的数据结构实现是一种FIFO（先入先出）缓冲区，即最先写入的消息也是最先被读出的。消息队列可以存储有限个具有确定长度的数据单元，可以保存的最大单元数目被称为队列的“深度” ，在消息队列创建时需要设定其深度和每个单元的大小。
当某个任务试图从一个消息队列读取数据时，可以指定一个阻塞超时时间。在这段时间内，如果消息队列为空，该任务将保持阻塞状态以等待新的消息，当其它任务或中断中向其等待的消息队列写入了数据，该任务将自动从阻塞状态转入就绪状态。
5、任务通知
FreeRTOS的每一个任务都有一个32位的通知（标志）值，用户可以用这个通知值保存一个32位整数或指针值。大多数情况下，任务通知可以替代二值信号量、计数信号量、事件标志，也可替代长度为1的消息队列。而且相对之前使用信号量、消息队列和事件标志时必须先创建（定义）对应的数据对象，使用任务通知不需要另外创建通知变量，显然更为灵活。
FreeRTOS的CMSIS v2封装中，任务通知又称为线程标志（ThreadFlag），任务通知的常用函数如下表所示：
6、内存管理
程序运行时的内存管理包括堆和栈两个概念：
堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）。
栈又称堆栈，是用户存放程序临时创建的局部变量，在函数内部定义的变量（不包括static声明的静态变量，static意味着在数据段中存放变量）。除此以外，在函数被调用时，其参数也会被压入发起调用的任务栈中，调用结束时函数的返回值也会被存放回栈中。由于栈的后进先出(LIFO)特点，所以栈特别方便用来保存/恢复调用现场。
7、程序存储空间
关于程序的存储空间，一个程序本质上都是由bss段、data段、text段三个组成的，在嵌入式系统的设计中了解这三个概念也非常重要，牵涉到嵌入式系统运行时的内存大小分配，存储单元占用空间大小的问题。
bss段通常是指用来存放程序中未初始化的全局变量的一块内存区域，一般在初始化时bss段部分将会清零。
data段也称为数据段，程序编译完成之后，已初始化的全局变量保存在data段中，未初始化的全局变量保存在bss段中。
text段也称为代码段，通常是指用来存放程序执行代码的一块内存区域。对嵌入式系统程序，text和data段都在可执行文件中（只读存储空间），而bss段不在可执行文件中，由系统运行时初始化。一般而言，MDK工程编译成功后，全局变量和静态变量会存放到bss段和data段空间，如果是用了const修饰的不可变全局变量，会存储到text段空间。
MDK工程编译成功后，输出信息中有一条PromgramSize语句，如“ProgramSize: Code=13866 RO-data=578 RW-data=16 ZI-data=20488”说明了程序存储信息。
Code：即代码域，对应上页中的text段，这些内容被存储到ROM区。
RO-data：即只读数据域，指程序中的只读数据，其也被存储在ROM区。
RW-data：即可读写数据域，它指初始化为“非0值”的可读写数据，程序运行时它们会常驻在RAM区。
ZI-data：即0初始化数据（包括未初始化的全局变量），程序刚运行时这些数据初始值全都为0，它们也常驻在RAM区。ZI-data与RW-data的区别除了初值不同，其对应的存储空间也不同，RW-data和RO-data都是上一页中的data段，需要占用ROM空间，而ZI-data则对应bss段，仅占用RAM空间。
所以，根据上述的Promgram Size信息，可以计算程序大小为：
占用ROM = “Code” + “RO-data” + “RW-data” = 13866 + 578 + 16 = 14460
占用RAM = “RW-data” + “ZI-data” = 16 + 20488 = 20504
三、CUBEMX配置
1、开启FreeRTOS
2、添加任务
修改任务名、优先级...
3、修改SYS模块中的基准时钟源，修改为TIM7
四、FreeRTOS应用编译器V6选择
工程默认的编译器是V5版本编译器，为了提高编译效率，编译器列表中可以选择V6版本编译进行编译，编译速度将大大提高。
为此，使用V6编译器时还需要修改 FreeRTOS源码中的两个文件。
1、打开CubeMX软件安装固件包的目录：
我存放的地址如下：
E:\STM32cubemx\STM32Cube_FW_F4_V1.28.1\Middlewares\Third_Party\FreeRTOS\Source\portable\GCC\ARM_CM4F2、找到图中的两个GCC版本移植文件，进行复制
3、将上面两个文件粘贴替换工程文件夹中的RVDS版本移植文件
4、复制替换后，在 MDK中设置工程选项，选择V6版本编译器编译即可。
要注意的是，每次用CubeMX导出工程后，这两个文件都会恢复为RVDS版本。更直接的方法是替换固件包中FreeRTOS源码目录下的RVDS版本移植文件。不过这个做法会导致以后所有使用FreeRTOS的工程都只能用V6版本编译器进行编译。
五、示例程序
实验一：流水灯
1、新建按键、数码管任务
2、默认任务StartDefaultTask
根据按键任务的返回值控制流水灯的循环方向
SetLeds()、ScanKey()、DispSeg()等函数详见附录部分
void StartDefaultTask(void *argument)
{
/* USER CODE BEGIN StartDefaultTask */
uint8_t sta = 0x01;
uint8_t dir = 1;
uint16_t key_dat = 0;
/* Infinite loop */
for(;;)
{
SetLeds(sta); // 调用SetLeds函数设置LED状态
// 任务通知相关操作
int key = osThreadFlagsWait(KEY_MASK, osFlagsWaitAny, 0); // 等待按键任务通知标志，返回值赋给key
// 如果K1按下，流水灯反向
if(key == K1_Pin) dir =!dir;
/*
// 消息队列相关操作
if(osMessageQueueGet(RX1_QueueHandle, &key_dat, 0, 10) == osOK)// 从消息队列获取消息
if(key_dat == K1_Pin) dir =!dir;
*/
// 根据dir的值更新sta的值
if(dir) sta = (sta < 0x80)? (sta << 1) : 0x01;
else sta = (sta > 0x01)? (sta >> 1) : 0x80;
osDelay(100);
}
/* USER CODE END StartDefaultTask */
}3、按键任务
用任务通知或消息队列的方式传递当前读取的按键值
void StartKeyTask(void *argument)
{
/* USER CODE BEGIN StartKeyTask */
uint8_t brun = 1;
/* Infinite loop */
for(;;)
{
uint16_t key = ScanKey(); // 调用ScanKey函数扫描按键
if (key > 0)
{
// 设置defaultTaskHandle任务的任务通知标志为按键对应的key
osThreadFlagsSet(defaultTaskHandle, key);// 用于通知defaultTaskHandle任务有按键事件发生
// osMessageQueuePut(RX1_QueueHandle,&key,0,0); //任务通知的方式来传递按键信息
// 避免一次按键操作被多次误处理
while (ScanKey() > 0);
if (K3_Pin == key)
{
brun =!brun;
// 恢复defaultTaskHandle任务的执行
if (brun)
osThreadResume(defaultTaskHandle);
// 暂停defaultTaskHandle任务的执行
else
osThreadSuspend(defaultTaskHandle);
}
}
else
{
// 如果没有按键按下，设置defaultTaskHandle任务的任务通知标志为K6_Pin左移1位的值
osThreadFlagsSet(defaultTaskHandle, K6_Pin << 1);
}
osDelay(100);
}
/* USER CODE END StartKeyTask */
}4、数码管显示任务
通过读取按键任务中获取的按键值进行数码管显示
void SegTask(void *argument)
{
/* USER CODE BEGIN SegTask */
char buf[20] = {"1234"};
/* Infinite loop */
for(;;)
{
int key = osThreadFlagsWait(KEY_MASK,osFlagsWaitAny,0);
uint16_t key_dat = 0;
if(key > 0)
{
if(key & K1_Pin) key_dat = key_dat + 1;
if(key & K2_Pin) key_dat = key_dat * 10 + 2;
if(key & K3_Pin) key_dat = key_dat * 10 + 3;
if(key & K4_Pin) key_dat = key_dat * 10 + 4;
if(key & K5_Pin) key_dat = key_dat * 10 + 5;
if(key & K6_Pin) key_dat = key_dat * 10 + 6;
buf[0] = key_dat/1000;
buf[1] = (key_dat/100)%10;
buf[2] = (key_dat/10)%10;
buf[3] = key_dat%10;
sprintf(buf,"%04d",key_dat);
}
DispSeg(buf);
}
/* USER CODE END SegTask */
}5、成果展示
按键控制流水灯
实验二：串口通信
1、开启异步通信串口1、2
2、添加串口任务
3、串口任务StartUartTask
通过上位机发送指令，通过串口接收数据后控制流水灯的状态
/* USER CODE END Header_StartUartTask */
void StartUartTask(void *argument)
{
/* USER CODE BEGIN StartUartTask */
/* Infinite loop */
HAL_UARTEx_ReceiveToIdle_IT(&huart1, rx_buf, 127); // 开启空闲中断接收
HAL_UARTEx_ReceiveToIdle_IT(&huart2, rx_buf2, 127); //串口2
for(;;)
{
char dat[128]; // 定义消息队列读取缓冲
if(osMessageQueueGet(RX1_QueueHandle, dat, NULL, 10) == osOK)
{
printf("%s", dat); // 打印获取的消息
// 对应不同的串口命令，向默认任务发送不同的任务通知
if (strstr(dat, "START") == dat)
osThreadFlagsSet(defaultTaskHandle, 0x10);
else if (strstr(dat, "STOP") == dat)
osThreadFlagsSet(defaultTaskHandle, 0x20);
else if (strstr(dat, "SPEED") == dat) {
uint8_t sp = dat[5] - '0'; // 提取速度数值
if (sp > 0 && sp < 10) // 将数值1-9发送通知给默认任务
osThreadFlagsSet(defaultTaskHandle, sp);
}
}
osDelay(1);
}
/* USER CODE END StartUartTask */
}4、默认任务StartDefaultTask
void StartDefaultTask(void *argument)
{
/* USER CODE BEGIN StartDefaultTask */
uint8_t sta, dir, brun, speed = 5;
sta = dir = brun = 1; // LED灯初始状态
/* Infinite loop */
for(;;)
{
osDelay((10 - speed) * 100); // 流水灯间隔时间
if (brun) { // 如果流水灯运行
if (sta == 0x01 || sta == 0x80)
dir = !dir;
sta = dir ? (sta >> 1) : (sta << 1);
// 打印流水灯状态
for (int i = 0; i < 8; ++i)
printf("%s", (sta & (0x01 << i)) ? "●" : "○");
printf("\r\n");
}
SetLeds(sta); // 调用亮灯函数，刷新LED灯
// 等待任务通知，并设置10毫秒超时
uint32_t flag =
osThreadFlagsWait(0xFF, osFlagsWaitAny, 10);
switch (flag) {
case 0x10: brun = 1; break; // 启动流水灯
case 0x20: brun = 0; break; // 暂停流水灯
default:
if (flag > 0 && flag <10) // 流水灯速度
speed = flag;
break;
}
}
/* USER CODE END StartDefaultTask */
}5、串口空闲中断接收数据
/* 串口空闲中断 */
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
if (huart == &huart1) {
rx_buf[Size] = '\0'; // 接收数据末尾添加字符串结束符
osMessageQueuePut(RX1_QueueHandle, rx_buf, NULL, 0); // 发送消息
__HAL_UNLOCK(huart); // 解锁串口状态
HAL_UARTEx_ReceiveToIdle_IT(&huart1, rx_buf, 127); // 再次开启接收
}
else if (huart == &huart2) {
rx_buf2[Size] = '\0'; // 接收数据末尾添加字符串结束符
osMessageQueuePut(RX1_QueueHandle, rx_buf2, NULL, 0); // 发送消息
__HAL_UNLOCK(huart); // 解锁串口状态
HAL_UARTEx_ReceiveToIdle_IT(&huart2, rx_buf2, 127); // 再次开启接收
}
}6、成果展示
串口通信
实验三：OLED显示
1、软件模拟IIC引脚设置，IIC任务开启
2、默认任务StartDefaultTask
void StartDefaultTask(void *argument)
{
/* USER CODE BEGIN StartDefaultTask */
uint8_t sta = 0x01; // 流水灯初始状态（L1亮）
uint16_t cnt = 150;
/* Infinite loop */
for(;;) {
SetLeds(sta); // 流水灯亮灯
// 等待按键消息
int key = osThreadFlagsWait(KEY_MASK, osFlagsWaitAny, 0);
if(statue == 1) //LED 模式
{
if (key == K1_Pin) // K1按下
dir = !dir;
}
else if(statue == 3) //参数模式
{
if (par_sta == 0) // 方向模式
{
if (key == K3_Pin) dir = 1;
else if (key == K2_Pin) dir = 0;
}
else // 速度模式
{
if(key == K3_Pin) cnt = (cnt > 249) ? 250 : cnt + 50;
else if(key == K2_Pin) cnt = (cnt < 51) ? 50 : cnt - 50;
speed = cnt / 50;
}
}
if (dir) sta = (sta < 0x80) ? (sta << 1) : 0x01;
else sta = (sta > 0x01) ? (sta >> 1) : 0x80;
osDelay(cnt);
}
/* USER CODE END StartDefaultTask */
}3、GUI切换任务
void StartGUITask(void *argument)
{
/* USER CODE BEGIN StartGUITask */
GUI_Init();
/* Infinite loop */
for(;;) { // 任务循环
switch (g_sta) { // 根据当前显示状态调用对应绘图函数
default: break;
case GUI_LOGO: UILogo(); break;
case GUI_MAIN: UIMain(); break;
case GUI_LED: UILeds(); break;
case GUI_KEY: UIKeys(); break;
case GUI_PARA: UIPara();break;
}
osDelay(10);
}
/* USER CODE END StartGUITask */
}4、按键任务StartKeyTask
void StartKeyTask(void *argument)
{
/* USER CODE BEGIN StartKeyTask */
/* Infinite loop */
for(;;)
{
uint8_t key = ScanKey(); // 扫描按键键码
if (key > 0) { // 有按键按下
while (ScanKey() > 0); // 等待按键放开，防止按键连按
osThreadFlagsSet(defaultTaskHandle, key); // 向默认任务发送key通知
}
switch (key)
{
case K1_Pin:
if (GUI_MAIN == g_sta) statue = (statue == 1) ? statue : (statue - 1);
Show_sta_select(statue); par_sta = 1;
break;
case K4_Pin: if (GUI_MAIN == g_sta) statue = (statue == 3) ? statue : (statue + 1);
Show_sta_select(statue); par_sta = 0;
break;
case K5_Pin: if (GUI_MAIN == g_sta) g_sta = g_sta_select;
break;
case K6_Pin: if (GUI_MAIN == g_sta) g_sta = GUI_LOGO;
else g_sta = GUI_MAIN;
break;
default: break;
}
osDelay(10);
}
/* USER CODE END StartKeyTask */
}5、UI界面设计函数
void UILogo(void)
{
static uint32_t tick = 0; // 定义静态变量，存储进入界面时的时间戳
if (0 == tick) tick = osKernelGetTickCount(); // 开始进入界面时，记录时间戳
GUI_Clear(); // 屏幕内容清空
GUI_DrawBitmap(&bmLOGO,
(128 - bmLOGO.XSize) / 2, (64 - bmLOGO.YSize) / 2); // 居中显示校徽图片
GUI_Update(); // 刷新屏幕显示
if (osKernelGetTickCount() >= tick + 2000) { // 如果当前时间已经超过进入时间2秒
g_sta = GUI_MAIN; // 界面状态跳转到主菜单界面
tick = 0; // 时间戳清零，以备再次进入
}
}
void UIMain(void)
{
GUI_Clear(); // 屏幕内容清空
GUI_SetFont(&GUI_FontHZ_SimSun_16); // 设置文本字体为16号宋体
GUI_DispStringHCenterAt("主菜单", 64, 0); // 屏幕正上方居中显示标题
if (GUI_LED == g_sta_select) { // 如果待选界面为LED状态
GUI_DispStringHCenterAt("* LED状态", 64, 16);
GUI_DispStringHCenterAt("按键状态", 64, 32);
GUI_DispStringHCenterAt("参数设置", 64, 48);
}
else if(g_sta_select == GUI_KEY){ // 如果待选界面为按键状态
GUI_DispStringHCenterAt("LED状态", 64, 16);
GUI_DispStringHCenterAt("* 按键状态", 64, 32);
GUI_DispStringHCenterAt("参数设置", 64, 48);
}
else if(g_sta_select == GUI_PARA){
GUI_DispStringHCenterAt("LED状态", 64, 16);
GUI_DispStringHCenterAt("按键状态", 64, 32);
GUI_DispStringHCenterAt("* 参数设置", 64, 48);
}
GUI_Update(); // 刷新屏幕显示
}
void UILeds(void)
{
GPIO_TypeDef* LED_Ports[8] = { // 定义LED灯端口数组，如果8个灯都是一个Port，可以不用
L1_GPIO_Port, L2_GPIO_Port, L3_GPIO_Port, L4_GPIO_Port,
L5_GPIO_Port, L6_GPIO_Port, L7_GPIO_Port, L8_GPIO_Port};
uint16_t LED_Pin[8] = {L1_Pin, L2_Pin, L3_Pin, L4_Pin, L5_Pin, L6_Pin, L7_Pin, L8_Pin}; // 引脚数组
GUI_Clear(); // 屏幕内容清空
GUI_SetFont(&GUI_FontHZ_SimSun_16); // 设置文本字体为16号宋体
GUI_DispStringHCenterAt("LED状态", 64, 0); // 屏幕正上方居中显示标题
int tx, ty; // 定义绘图临时变量
tx = ty = 12;
for (int i = 0; i < 8; ++i) { // 循环遍历8个LED灯
GUI_DrawRect(16 * i + 1, 20, 16 * i + tx, 20 + ty); // 绘制边框
if (HAL_GPIO_ReadPin(LED_Ports[i], LED_Pin[i]) == GPIO_PIN_RESET) // 读取端口电平
GUI_FillRect(16 * i + 1, 20, 16 * i + tx, 20 + ty); // 如果亮灯则填充矩形
}
GUI_Update(); // 刷新屏幕显示
}
void UIKeys(void)
{
GUI_Clear(); // 屏幕内容清空
GUI_SetFont(&GUI_FontHZ_SimSun_16); // 设置文本字体为16号宋体
GUI_DispStringHCenterAt("按键状态", 64, 0);// 屏幕正上方居中显示标题
GPIO_PinState ps = HAL_GPIO_ReadPin(K1_GPIO_Port, K1_Pin);// 定义变量，读取K1按键电平
GUI_DispStringAt(GPIO_PIN_RESET == ps ? "●" : "○", 26, 20); // 绘制不同符号表示按键按压状态
ps = HAL_GPIO_ReadPin(K4_GPIO_Port, K4_Pin); // K4按键
GUI_DispStringAt(GPIO_PIN_RESET == ps ? "●" : "○", 26, 48);
ps = HAL_GPIO_ReadPin(K2_GPIO_Port, K2_Pin); // K2按键
GUI_DispStringAt(GPIO_PIN_RESET == ps ? "●" : "○", 6, 34);
ps = HAL_GPIO_ReadPin(K3_GPIO_Port, K3_Pin); // K3按键
GUI_DispStringAt(GPIO_PIN_RESET == ps ? "●" : "○", 46, 34);
ps = HAL_GPIO_ReadPin(K5_GPIO_Port, K5_Pin); // K5按键
GUI_DispStringAt(GPIO_PIN_SET == ps ? "●" : "○", 86, 34); // 注意电平方式和前4个按键不同
ps = HAL_GPIO_ReadPin(K6_GPIO_Port, K6_Pin); // K6按键
GUI_DispStringAt(GPIO_PIN_SET == ps ? "●" : "○", 106, 34);
GUI_Update(); // 刷新屏幕显示
}
void UIPara(void)
{
GUI_Clear(); // 屏幕内容清空
GUI_SetFont(&GUI_FontHZ_SimSun_16); // 设置文本字体为16号宋体
GUI_DispStringHCenterAt("参数设置", 64, 0); // 屏幕正上方居中显示标题
GUI_DispStringHCenterAt("速度:", 30, 20);
GUI_DispStringHCenterAt("方向:", 30, 40);
sprintf(str_sp, "%d", speed);
GUI_DispStringHCenterAt(str_sp, 64, 20);
if(dir) GUI_DispStringHCenterAt("->", 64, 40);
else GUI_DispStringHCenterAt("<-", 64, 40);
GUI_Update(); // 刷新屏幕显示
}
void Show_sta_select(uint8_t x)
{
switch (x)
{
case 1:g_sta_select = GUI_LED;
break;
case 2:g_sta_select = GUI_KEY;
break;
case 3:g_sta_select = GUI_PARA;
break;
default:
break;
}
}
6、成果展示
OLED显示
附录
1、SetLeds()：LED亮灭控制函数
void SetLeds(uint8_t dat)
{
HAL_GPIO_WritePin(L1_GPIO_Port, L1_Pin,
(dat & 0x01) ? GPIO_PIN_RESET : GPIO_PIN_SET);
HAL_GPIO_WritePin(L2_GPIO_Port, L2_Pin,
(dat & 0x02) ? GPIO_PIN_RESET : GPIO_PIN_SET);
HAL_GPIO_WritePin(L3_GPIO_Port, L3_Pin,
(dat & 0x04) ? GPIO_PIN_RESET : GPIO_PIN_SET);
HAL_GPIO_WritePin(L4_GPIO_Port, L4_Pin,
(dat & 0x08) ? GPIO_PIN_RESET : GPIO_PIN_SET);
HAL_GPIO_WritePin(L5_GPIO_Port, L5_Pin,
(dat & 0x10) ? GPIO_PIN_RESET : GPIO_PIN_SET);
HAL_GPIO_WritePin(L6_GPIO_Port, L6_Pin,
(dat & 0x20) ? GPIO_PIN_RESET : GPIO_PIN_SET);
HAL_GPIO_WritePin(L7_GPIO_Port, L7_Pin,
(dat & 0x40) ? GPIO_PIN_RESET : GPIO_PIN_SET);
HAL_GPIO_WritePin(L8_GPIO_Port, L8_Pin,
(dat & 0x80) ? GPIO_PIN_RESET : GPIO_PIN_SET);
}2、ScanKey()：按键扫描函数
uint8_t ScanKey(void)
{
uint8_t key = 0;
if (HAL_GPIO_ReadPin(K1_GPIO_Port, K1_Pin) == GPIO_PIN_RESET)
key |= K1_Pin;
if (HAL_GPIO_ReadPin(K2_GPIO_Port, K2_Pin) == GPIO_PIN_RESET)
key |= K2_Pin;
if (HAL_GPIO_ReadPin(K3_GPIO_Port, K3_Pin) == GPIO_PIN_RESET)
key |= K3_Pin;
if (HAL_GPIO_ReadPin(K4_GPIO_Port, K4_Pin) == GPIO_PIN_RESET)
key |= K4_Pin;
if (HAL_GPIO_ReadPin(K5_GPIO_Port, K5_Pin) == GPIO_PIN_SET)
key |= K5_Pin;
if (HAL_GPIO_ReadPin(K6_GPIO_Port, K6_Pin) == GPIO_PIN_SET)
key |= K6_Pin;
if (key > 0) {
osDelay(10);
uint8_t key2 = 0;
if (HAL_GPIO_ReadPin(K1_GPIO_Port, K1_Pin) == GPIO_PIN_RESET) key2 |= K1_Pin;
if (HAL_GPIO_ReadPin(K2_GPIO_Port, K2_Pin) == GPIO_PIN_RESET) key2 |= K2_Pin;
if (HAL_GPIO_ReadPin(K3_GPIO_Port, K3_Pin) == GPIO_PIN_RESET) key2 |= K3_Pin;
if (HAL_GPIO_ReadPin(K4_GPIO_Port, K4_Pin) == GPIO_PIN_RESET) key2 |= K4_Pin;
if (HAL_GPIO_ReadPin(K5_GPIO_Port, K5_Pin) == GPIO_PIN_SET) key2 |= K5_Pin;
if (HAL_GPIO_ReadPin(K6_GPIO_Port, K6_Pin) == GPIO_PIN_SET) key2 |= K6_Pin;
if (key == key2) return key;
else return 0;
}
return 0;
}3、DispSeg()：数码管显示函数
void Write595(uint8_t sel, uint8_t num, uint8_t bdot)
{
// 共阴数码管，'0'～'9'，'A'～'F' 编码
static const uint8_t TAB[16] = { 0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07,
0x7F, 0x6F, 0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71};
// 74HC138关数码管显示
HAL_GPIO_WritePin(A3_GPIO_Port, A3_Pin, GPIO_PIN_RESET);
uint8_t dat = TAB[num & 0x0F] | (bdot ? 0x80 : 0x00);
if (' ' == num) dat = 0; // 空格关闭显示
else if ('.' == num) dat = 0x80;// 单独小数点显示
else if ('-' == num) dat = 0x40;// 负号显示
else if (num > 0x0F) dat = num;// 其余数值按实际段码显示
// 595串行移位输入段码
for (uint8_t i = 0; i < 8; ++i) {
HAL_GPIO_WritePin(SCK_GPIO_Port, SCK_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(SER_GPIO_Port, SER_Pin, (dat & 0x80) ? GPIO_PIN_SET : GPIO_PIN_RESET);
dat <<= 1;
HAL_GPIO_WritePin(SCK_GPIO_Port, SCK_Pin, GPIO_PIN_SET);
}
// DISLK脉冲锁存8位输出
HAL_GPIO_WritePin(DISLK_GPIO_Port, DISLK_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(DISLK_GPIO_Port, DISLK_Pin, GPIO_PIN_SET);
// 4位数码管片选
HAL_GPIO_WritePin(A0_GPIO_Port, A0_Pin, (sel & 0x01) ? GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(A1_GPIO_Port, A1_Pin, (sel & 0x02) ? GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(A2_GPIO_Port, A2_Pin, GPIO_PIN_RESET);
// 74HC138开数码管显示
HAL_GPIO_WritePin(A3_GPIO_Port, A3_Pin, GPIO_PIN_SET);
}
// 4位数码管动态扫描显示
void DispSeg(char dat[8])
{
uint8_t sel = 0; // 数码管位选
uint8_t bdot = 0; // 是否有小数点
for(uint8_t i = 0; i < 8; ++i) {
uint8_t num = dat[i];
if (dat[i] != '.') {
if (dat[i + 1] == '.')
bdot = 1; // 下一位小数点合并到当前位显示
}
else { // 小数点处理
if (bdot) {
bdot = 0;
continue; // 跳过已经合并显示的小数点
}
}
// 十六进制字符显示支持
if (num >= '0' && num <= '9') num -= '0';
else if (num >= 'A' && num <= 'F')
num = num - 'A' + 10;
else if (num >= 'a' && num <= 'f')
num = num - 'a' + 10;
// 点亮对应数码管
Write595(sel++, num, bdot);
osDelay(3); // 延时3毫秒
if (sel >= 4) // 只显示4位数码管
break;
}
}
