发 帖  
原厂入驻New
[资料] 「ALIENTEK 阿波罗 STM32F767 开发板资料连载」第六十九章 UCOSII 实验 3-消息队列、信号量集和软件定时器
2020-5-25 11:39:25  303 STM32
分享
1)实验平台:alientek 阿波罗 STM32F767 开发板
2)摘自《STM32F7 开发指南(HAL 库版)》关注官方微信号公众号,获取更多资料:正点原子




第六十九章 UCOSII 实验 3-消息队列、信号量集和软件定时器
上一章,我们学习了 UCOSII 的信号量和邮箱的使用,本章,我们将学习消息队列、信号
量集和软件定时器的使用。本章分为如下几个部分:
69.1 UCOSII 消息队列、信号量集和软件定时器简介
69.2 硬件设计
69.3 软件设计
69.4 下载验证
69.1 UCOSII 消息队列、信号量集和软件定时器简介
上一章,我们介绍了信号量和邮箱的使用,本章我们介绍比较复杂消息队列、信号量集以
及软件定时器的使用。
消息队列
使用消息队列可以在任务之间传递多条消息。消息队列由三个部分组成:事件控制块、消
息队列和消息。当把事件控制块成员 OSEventType 的值置为 OS_EVENT_TYPE_Q 时,该事件
控制块描述的就是一个消息队列。
消息队列的数据结构如图 69.1.1 所示。从图中可以看到,消息队列相当于一个共用一个任
务等待列表的消息邮箱数组,事件控制块成员 OSEventPtr 指向了一个叫做队列控制块(OS_Q)
的结构,该结构管理了一个数组 MsgTbl[],该数组中的元素都是一些指向消息的指针。



图 69.1.1 消息队列的数据结构
队列控制块(OS_Q)的结构定义如下:
  1. typedef struct os_q

  2. {

  3. struct os_q *OSQPtr;

  4. void **OSQStart;

  5. void **OSQEnd;

  6. void **OSQIn;

  7. void **OSQOut;

  8. INT16U OSQSize;

  9. INT16U OSQEntries;

  10. } OS_Q;
复制代码

该结构体中各参数的含义如表 69.1.1 所示:



表 69.1.1 队列控制块各参数含义
其中,可以移动的指针为 OSQIn 和 OSQOut,而指针 OSQStart 和 OSQEnd 只是一个标志
(常指针)。当可移动的指针 OSQIn 或 OSQOut 移动到数组末尾,也就是与 OSQEnd 相等时,
可移动的指针将会被调整到数组的起始位置 OSQStart。也就是说,从效果上来看,指针 OSQEnd
与 OSQStart 等值。于是,这个由消息指针构成的数组就头尾衔接起来形成了一个如图 69.1.2
所示的循环的队列。



图 69.1.2 消息指针数组构成的环形数据缓冲区
在UCOSII初始化时,系统将按文件os_cfg.h中的配置常数OS_MAX_QS定义OS_MAX_QS
个队列控制块,并用队列控制块中的指针 OSQPtr 将所有队列控制块链接为链表。由于这时还
没有使用它们,故这个链表叫做空队列控制块链表。
接下来我们看看在 UCOSII 中,与消息队列相关的几个函数(未全部列出,下同)。
1) 创建消息队列函数
创建一个消息队列首先需要定义一指针数组,然后把各个消息数据缓冲区的首地址存
入这个数组中,然后再调用函数 OSQCreate 来创建消息队列。创建消息队列函数 OSQCreate
的原型为:
OS_EVENT *OSQCreate(void**start,INT16U size);
其中,start 为存放消息缓冲区指针数组的地址,size 为该数组大小。该函数的返回值
为消息队列指针。
2) 请求消息队列函数
请求消息队列的目的是为了从消息队列中获取消息。任务请求消息队列需要调用函数
OSQPend,该函数原型为:
void*OSQPend(OS_EVENT*pevent,INT16U timeout,INT8U *err);
其中,pevent 为所请求的消息队列的指针,timeout 为任务等待时限,err 为错误信息。
3) 向消息队列发送消息函数
任务可以通过调用函数 OSQPost 或 OSQPostFront 两个函数来向消息队列发送消息。
函数 OSQPost 以 FIFO(先进先出)的方式组织消息队列,函数 OSQPostFront 以 LIFO(后
进先出)的方式组织消息队列。这两个函数的原型分别为:
INT8U OSQPost(OS_EVENT *pevent,void *msg);
INT8U OSQPostFront (OS_EVENT*pevent,void*msg);
其中,pevent 为消息队列的指针,msg 为待发消息的指针。
消息队列还有其他一些函数,这里我们就不介绍了,感兴趣的朋友可以参考《嵌入式实时
操作系统 UCOSII 原理及应用》第五章,关于队列更详细的介绍,也请参考该书。
信号量集
在实际应用中,任务常常需要与多个事件同步,即要根据多个信号量组合作用的结果来决
定任务的运行方式。UCOSII 为了实现多个信号量组合的功能定义了一种特殊的数据结构——
信号量集。
信号量集所能管理的信号量都是一些二值信号,所有信号量集实质上是一种可以对多个输
入的逻辑信号进行基本逻辑运算的组合逻辑,其示意图如图 69.1.3 所示



图 69.1.3 信号量集示意图
不同于信号量、消息邮箱、消息队列等事件,UCOSII 不使用事件控制块来描述信号量集,
而使用了一个叫做标志组的结构 OS_FLAG_GRP 来描述。OS_FLAG_GRP 结构如下:
typedef struct
{
INT8U OSFlagType;
//识别是否为信号量集的标志
void *OSFlagWaitList;
//指向等待任务链表的指针
OS_FLAGS OSFlagFlags; //所有信号列表
}OS_FLAG_GRP;
成员 OSFlagWaitList 是一个指针,当一个信号量集被创建后,这个指针指向了这个信号量
集的等待任务链表。
与其他前面介绍过的事件不同,信号量集用一个双向链表来组织等待任务,每一个等待任
务都是该链表中的一个节点(Node)。标志组 OS_FLAG_GRP 的成员 OSFlagWaitList 就指向了
信号量集的这个等待任务链表。等待任务链表节点 OS_FLAG_NODE 的结构如下:
  1. typedef struct

  2. {

  3. void *OSFlagNodeNext;

  4. //指向下一个节点的指针

  5. void *OSFlagNodePrev;

  6. //指向前一个节点的指针

  7. void *OSFlagNodeTCB;

  8. //指向对应任务控制块的指针

  9. void *OSFlagNodeFlagGrp;

  10. //反向指向信号量集的指针

  11. OS_FLAGS OSFlagNodeFlags; //信号过滤器

  12. INT8U OSFlagNodeWaitType; //定义逻辑运算关系的数据

  13. } OS_FLAG_NODE;
复制代码

其中 OSFlagNodeWaitType 是定义逻辑运算关系的一个常数(根据需要设置),其可选值和
对应的逻辑关系如表 69.1.2 所示:


表 69.1.2 OSFlagNodeWaitType 可选值及其意义
OSFlagFlags、OSFlagNodeFlags、OSFlagNodeWaitType 三者的关系如图 69.1.4 所示:


图 69.1.4 标志组与等待任务共同完成信号量集的逻辑运算及控制
图中为了方便说明,我们将 OSFlagFlags 定义为 8 位,但是 UCOSII 支持 8 位/16 位/32 位
定义,这个通过修改 OS_FLAGS 的类型来确定(UCOSII 默认设置 OS_FLAGS 为 16 位)。
上图清楚的表达了信号量集各成员的关系:OSFlagFlags 为信号量表,通过发送信号量集的
任务设置;OSFlagNodeFlags 为信号滤波器,由请求信号量集的任务设置,用于选择性的挑选
OSFlagFlags 中的部分(或全部)位作为有效信号;OSFlagNodeWaitType 定义有效信号的逻辑
运算关系,也是由请求信号量集的任务设置,用于选择有效信号的组合方式(0/1? 与/或?)。
举个简单的例子,假设请求信号量集的任务设置 OSFlagNodeFlags 的值为 0X0F,设置
OSFlagNodeWaitType 的值为 WAIT_SET_ANY,那么只要 OSFlagFlags 的低四位的任何一位为
1,请求信号量集的任务将得到有效的请求,从而执行相关操作,如果低四位都为 0,那么请求
信号量集的任务将得到无效的请求。
接下来我们看看在 UCOSII 中,与信号量集相关的几个函数。
1) 创建信号量集函数
任务可以通过调用函数 OSFlagCreate 来创建一个信号量集。函数 OSFlagCreate 的原
型为:
OS_FLAG_GRP *OSFlagCreate (OS_FLAGS flags,INT8U *err );
其中,flags 为信号量的初始值(即 OSFlagFlags 的值),err 为错误信息,返回值为该
信号量集的标志组的指针,应用程序根据这个指针对信号量集进行相应的操作。
2) 请求信号量集函数
任务可以通过调用函数 OSFlagPend 请求一个信号量集,函数 OSFlagPend 的原型为:
OS_FLAGS OSFlagPend(OS_FLAG_GRP*pgrp, OS_FLAGS flags, INT8U wait_type,
INT16U timeout, INT8U *err);
其中,pgrp 为所请求的信号量集指针,flags 为滤波器(即 OSFlagNodeFlags 的值),
wait_type 为逻辑运算类型(即 OSFlagNodeWaitType 的值),timeout 为等待时限,err 为错
误信息。
3) 向信号量集发送信号函数
任务可以通过调用函数 OSFlagPost 向信号量集发信号,函数 OSFlagPost 的原型为:
OS_FLAGS OSFlagPost (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U opt, INT8U *err);
其中,pgrp 为所请求的信号量集指针,flags 为选择所要发送的信号,opt 为信号有效
选项,err 为错误信息。
所谓任务向信号量集发信号,就是对信号量集标志组中的信号进行置“1”(置位)或
置“0”(复位)的操作。至于对信号量集中的哪些信号进行操作,用函数中的参数 flags
来指定;对指定的信号是置“1”还是置“0”,用函数中的参数 opt 来指定(opt =
OS_FLAG_SET 为置“1”操作;opt = OS_FLAG_CLR 为置“0”操作)。
信号量集就介绍到这,更详细的介绍,请参考《嵌入式实时操作系统 UCOSII 原理及应用》
第六章。
软件定时器
UCOSII 从 v2.83 版本以后,加入了软件定时器,这使得 UCOSII 的功能更加完善,在其上
的应用程序开发与移植也更加方便。在实时操作系统中一个好的软件定时器实现要求有较高的
精度、较小的处理器开销,且占用较少的存储器资源。
通过前面的学习,我们知道 UCOSII 通过 OSTimTick 函数对时钟节拍进行加 1 操作,同时
遍历任务控制块,以判断任务延时是否到时。软件定时器同样由 OSTimTick 提供时钟,但是软
件定时器的时钟还受 OS_TMR_CFG_TICKS_PER_SEC 设置的控制,也就是在 UCOSII 的时钟
节拍上面再做了一次“分频”,软件定时器的最快时钟节拍就等于 UCOSII 的系统时钟节拍。这
也决定了软件定时器的精度。
软件定时器定义了一个单独的计数器 OSTmrTime,用于软件定时器的计时,UCOSII 并不
在 OSTimTick 中进行软件定时器的到时判断与处理,而是创建了一个高于应用程序中所有其他
任务优先级的定时器管理任务 OSTmr_Task,在这个任务中进行定时器的到时判断和处理。时
钟节拍函数通过信号量给这个高优先级任务发信号。这种方法缩短了中断服务程序的执行时间,
但也使得定时器到时处理函数的响应受到中断退出时恢复现场和任务切换的影响。软件定时器
功能实现代码存放在 tmr.c 文件中,移植时只需在 os_cfg.h 文件中使能定时器和设定定时器的相
关参数。
UCOSII 中软件定时器的实现方法是,将定时器按定时时间分组,使得每次时钟节拍到来
时只对部分定时器进行比较操作,缩短了每次处理的时间。但这就需要动态地维护一个定时器
组。定时器组的维护只是在每次定时器到时时才发生,而且定时器从组中移除和再插入操作不
需要排序。这是一种比较高效的算法,减少了维护所需的操作时间。
UCOSII 软件定时器实现了 3 类链表的维护:
OS_EXT OS_TMR OSTmrTbl[OS_TMR_CFG_MAX]; //定时器控制块数组
OS_EXT OS_TMR *OSTmRFreeList;
//空闲定时器控制块链表指针
OS_EXT OS_TMR_WHEEL OSTmrWheelTbl[OS_TMR_CFG_WHEEL_SIZE];//定时器轮
其中 OS_TMR 为定时器控制块,定时器控制块是软件定时器管理的基本单元,包含软件定
时器的名称、定时时间、在链表中的位置、使用状态、使用方式,以及到时回调函数及其参数
等基本信息。
OSTmrTbl[OS_TMR_CFG_MAX];:以数组的形式静态分配定时器控制块所需的 RAM 空间,
存储所有已建立的定时器控制块,OS_TMR_CFG_MAX 为最大软件定时器的个数。
OSTmrFreeLiSt:为空闲定时器控制块链表头指针。空闲态的定时器控制块(OS_TMR)中,
OSTmrnext 和 OSTmrPrev 两个指针分别指向空闲控制块的前一个和后一个,组织了空闲控制块
双向链表。建立定时器时,从这个链表中搜索空闲定时器控制块。
OSTmrWheelTbl[OS_TMR_CFG_WHEEL_SIZE]:该数组的每个元素都是已开启定时器的
一个分组,元素中记录了指向该分组中第一个定时器控制块的指针,以及定时器控制块的个数。
运行态的定时器控制块(OS_TMR)中,OSTmrnext 和 OSTmrPrev 两个指针同样也组织了所在分
组中定时器控制块的双向链表。软件定时器管理所需的数据结构示意图如图 69.1.5 所示:


图 69.1.5 软件定时器管理所需的数据结构示意图
OS_TMR_CFG_WHEEL_SIZE 定义了 OSTmrWheelTbl 的大小,同时这个值也是定时器分
组的依据。按照定时器到时值与 OS_TMR_CFG_WHEEL_SIZE 相除的余数进行分组:不同余数
的定时器放在不同分组中;相同余数的定时器处在同一组中,由双向链表连接。这样,余数值
为 0~OS_TMR_CFG_WHEEL_SIZE-1 的不同定时器控制块,正好分别对应了数组元素
OSTmr-WheelTbl[0]~OSTmrWheelTbl[OS_TMR_CFGWHEEL_SIZE-1]的不同分组。每次时钟节
拍到来时,时钟数 OSTmrTime 值加 1,然后也进行求余操作,只有余数相同的那组定时器才有
可能到时,所以只对该组定时器进行判断。这种方法比循环判断所有定时器更高效。随着时钟
数的累加,处理的分组也由 0~OS_TMR_CFG_WHE EL_SIZE-1 循环。这里,我们推荐
OS_TMR_CFG_WHEEL_SIZE 的取值为 2 的 N 次方,以便采用移位操作计算余数,缩短处理时
间。
信号量唤醒定时器管理任务,计算出当前所要处理的分组后,程序遍历该分组中的所有控
制块,将当前 OSTmrTime 值与定时器控制块中的到时值(OSTmrMatch)相比较。若相等(即到
时),则调用该定时器到时回调函数;若不相等,则判断该组中下一个定时器控制块。如此操作,
直到该分组链表的结尾。软件定时器管理任务的流程如图 69.1.6 所示。


图 69.1.6 软件定时器管理任务流程
当运行完软件定时器的到时处理函数之后,需要进行该定时器控制块在链表中的移除和再
插入操作。插入前需要重新计算定时器下次到时时所处的分组。计算公式如下:
定时器下次到时的 OSTmrTime 值(OSTmrMatch)=定时器定时值+当前 OSTmrTime 值
新分组=定时器下次到时的 OSTmrTime 值(OSTmrMatch)%OS_TMR_CFG_WHEEL_SIZE
接下来我们看看在 UCOSII 中,与软件定时器相关的几个函数。
1) 创建软件定时器函数
创建软件定时器通过函数 OSTmrCreate 实现,该函数原型为:
OS_TMR *OSTmrCreate (INT32U dly, INT32U period, INT8U opt, OS_TMR_CALLBACK
callback,void *callback_arg, INT8U *pname, INT8U *perr);
dly,用于初始化定时时间,对单次定时(ONE-SHOT 模式)的软件定时器来说,这
就是该定时器的定时时间,而对于周期定时(PERIODIC 模式)的软件定时器来说,这是
该定时器第一次定时的时间,从第二次开始定时时间变为 period。
period,在周期定时(PERIODIC 模式),该值为软件定时器的周期溢出时间。
opt,用于设置软件定时器工作模式。可以设置的值为:OS_TMR_OPT_ONE_SHOT
或 OS_TMR_OPT_PERIODIC,如果设置为前者,说明是一个单次定时器;设置为后者则
表示是周期定时器。
callback,为软件定时器的回调函数,当软件定时器的定时时间到达时,会调用该函数。
callback_arg,回调函数的参数。
pname,为软件定时器的名字。
perr,为错误信息。
软件定时器的回调函数有固定的格式,我们必须按照这个格式编写,软件定时器的回
调函数格式为:void (*OS_TMR_CALLBACK)(void *ptmr, void *parg)。其中,函数名我们
可以自己随意设置,而 ptmr 这个参数,软件定时器用来传递当前定时器的控制块指针,所
以我们一般设置其类型为 OS_TMR*类型,第二个参数(parg)为回调函数的参数,这个就
可以根据自己需要设置了,你也可以不用,但是必须有这个参数。
2) 开启软件定时器函数
任务可以通过调用函数 OSTmrStart 开启某个软件定时器,该函数的原型为:BOOLEAN OSTmrStart (OS_TMR *ptmr, INT8U *perr);
其中 ptmr 为要开启的软件定时器指针,perr 为错误信息。
3) 停止软件定时器函数
任务可以通过调用函数 OSTmrStop 停止某个软件定时器,该函数的原型为:
BOOLEAN OSTmrStop (OS_TMR *ptmr,INT8U opt,void *callback_arg,INT8U *perr);
其中 ptmr 为要停止的软件定时器指针。
opt 为停止选项,可以设置的值及其对应的意义为:
OS_TMR_OPT_NONE,直接停止,不做任何其他处理
OS_TMR_OPT_CALLBACK,停止,用初始化的参数执行一次回调函数
OS_TMR_OPT_CALLBACK_ARG,停止,用新的参数执行一次回调函数
callback_arg,新的回调函数参数。
perr,错误信息。
软件定时器我们就介绍到这。
69.2 硬件设计
本节实验功能简介:本章我们在 UCOSII 里面创建 7 个任务:开始任务、LED 任务、触摸
屏任务、队列消息显示任务、信号量集任务、按键扫描任务和主任务,开始任务用于创建邮箱、
消息队列、信号量集以及其他任务,之后挂起;触摸屏任务用于在屏幕上画图,测试 CPU 使
用率;队列消息显示任务请求消息队列,在得到消息后显示收到的消息数据;信号量集任务用
于测试信号量集,采用 OS_FLAG_WAIT_SET_ANY 的方法,任何按键按下(包括 TPAD),
该任务都会控制蜂鸣器发出“滴”的一声;按键扫描任务用于按键扫描,优先级最高,将得到
的键值通过消息邮箱发送出去;主任务创建 3 个软件定时器(定时器 1,100ms 溢出一次,显
示 CPU 和内存使用率;定时 2,200ms 溢出一次,在固定区域不停的显示不同颜色;定时
3,,100ms 溢出一次,用于自动发送消息到消息队列),并通过查询消息邮箱获得键值,根据
键值执行 DS1 控制、控制软件定时器 3 的开关、触摸区域清屏、触摸屏校和软件定时器 2 的
开关控制等。
所要用到的硬件资源如下:
1) 指示灯 DS0 、DS1
2) 4 个机械按键(KEY0/KEY1/KEY2/KEY_UP)
3) TPAD 触摸按键
5) PCF8574(控制蜂鸣器)
4) LCD 模块
这些,我们在前面的学习中都已经介绍过了。
69.3 软件设计
本章,我们在第四十四章实验 (实验 39)的基础上修改,首先,是 UCOSII 代码的添加,
具体方法同第 67 章一模一样,本章就不再详细介绍了。另外由于我们创建了 7 个任务,加上统
计任务、空闲任务和软件定时器任务,总共 10 个任务。
另外,我们还需要在 os_cfg.h 里面修改软件定时器管理部分的宏定义,修改如下:
  1. #define OS_TMR_EN

  2. 1u

  3. //使能软件定时器功能

  4. #define OS_TMR_CFG_MAX

  5. 16u

  6. //最大软件定时器个数

  7. #define OS_TMR_CFG_NAME_EN

  8. 1u

  9. //使能软件定时器命名

  10. #define OS_TMR_CFG_WHEEL_SIZE 8u //软件定时器轮大小

  11. #define OS_TMR_CFG_TICKS_PER_SEC 100u

  12. //软件定时器的时钟节拍(10ms)

  13. #define OS_TASK_TMR_PRIO

  14. 0u

  15. //软件定时器的优先级,设置为最高
复制代码

这样我们就使能 UCOSII 的软件定时器功能了,并且设置最大软件定时器个数为 16,定时
器轮大小为 8,软件定时器时钟节拍为 10ms(即定时器的最少溢出时间为 10ms)。
最后,我们只需要修改 main.c 函数了,打开 main.c,输入如下代码:
  1. /////////////////////////UCOSII 任务设置///////////////////////////////////
  2. //START 任务
  3. #define START_TASK_PRIO 10 //设置任务优先级
  4. #define START_STK_SIZE 128 //设置任务堆栈大小
  5. OS_STK START_TASK_STK[START_STK_SIZE]; //任务堆栈
  6. void start_task(void *pdata); //任务函数
  7. //LED 任务
  8. #define LED_TASK_PRIO 7 //设置任务优先级
  9. #define LED_STK_SIZE 128 //设置任务堆栈大小
  10. OS_STK LED_TASK_STK[LED_STK_SIZE]; //任务堆栈
  11. void led_task(void *pdata); //任务函数
  12. //触摸屏任务
  13. #define TOUCH_TASK_PRIO 6 //设置任务优先级
  14. #define TOUCH_STK_SIZE 128 //设置任务堆栈大小
  15. OS_STK TOUCH_TASK_STK[TOUCH_STK_SIZE]; //任务堆栈
  16. void touch_task(void *pdata); //任务函数
  17. //队列消息显示任务
  18. #define QMSGSHOW_TASK_PRIO 5 //设置任务优先级
  19. #define QMSGSHOW_STK_SIZE 128 //设置任务堆栈大小
  20. OS_STK QMSGSHOW_TASK_STK[QMSGSHOW_STK_SIZE]; //任务堆栈
  21. void qmsgshow_task(void *pdata); //任务函数
  22. //主任务
  23. #define MAIN_TASK_PRIO 4 //设置任务优先级
  24. #define MAIN_STK_SIZE 128 //设置任务堆栈大小
  25. OS_STK MAIN_TASK_STK[MAIN_STK_SIZE]; //任务堆栈
  26. void main_task(void *pdata); //任务函数
  27. //信号量集任务
  28. #define FLAGS_TASK_PRIO 3 //设置任务优先级
  29. #define FLAGS_STK_SIZE 128 //设置任务堆栈大小
  30. OS_STK FLAGS_TASK_STK[FLAGS_STK_SIZE]; //任务堆栈
  31. void flags_task(void *pdata); //任务函数
  32. //按键扫描任务
  33. #define KEY_TASK_PRIO 2 //设置任务优先级
  34. #define KEY_STK_SIZE 128 //设置任务堆栈大小
  35. OS_STK KEY_TASK_STK[KEY_STK_SIZE]; //任务堆栈
  36. void key_task(void *pdata); //任务函数
  37. OS_EVENT * msg_key; //按键邮箱事件块
  38. OS_EVENT * q_msg; //消息队列
  39. OS_TMR * tmr1; //软件定时器 1
  40. OS_TMR * tmr2; //软件定时器 2
  41. OS_TMR * tmr3; //软件定时器 3
  42. OS_FLAG_GRP * flags_key; //按键信号量集
  43. void * MsgGrp[256]; //消息队列存储地址,最大支持 256 个消息
  44. //软件定时器 1 的回调函数
  45. //每 100ms 执行一次,用于显示 CPU 使用率和内存使用率
  46. void tmr1_callback(OS_TMR *ptmr,void *p_arg)
  47. {
  48. static u16 cpuusage=0;
  49. static u8 tcnt=0;
  50. POINT_COLOR=BLUE;
  51. if(tcnt==5)
  52. {
  53. LCD_ShowxNum(182,10,cpuusage/5,3,16,0); //显示 CPU 使用率
  54. cpuusage=0;
  55. tcnt=0;
  56. }
  57. cpuusage+=OSCPUUsage;
  58. tcnt++;
  59. LCD_ShowxNum(182,30,my_mem_perused(SRAMIN),3,16,0);//显示内存使用率
  60. LCD_ShowxNum(182,50,((OS_Q*)(q_msg->OSEventPtr))->OSQEntries,3,16,0X80);
  61. //显示队列当前的大小
  62. }
  63. //软件定时器 2 的回调函数
  64. void tmr2_callback(OS_TMR *ptmr,void *p_arg)
  65. {
  66. static u8 sta=0;
  67. switch(sta)
  68. {
  69. case 0: LCD_Fill(131,221,lcddev.width-1,lcddev.height-1,RED); break;
  70. case 1: LCD_Fill(131,221,lcddev.width-1,lcddev.height-1,GREEN); break;
  71. case 2: LCD_Fill(131,221,lcddev.width-1,lcddev.height-1,BLUE); break;
  72. case 3: LCD_Fill(131,221,lcddev.width-1,lcddev.height-1,MAGENTA); break;
  73. case 4: LCD_Fill(131,221,lcddev.width-1,lcddev.height-1,GBLUE); break;
  74. case 5: LCD_Fill(131,221,lcddev.width-1,lcddev.height-1,YELLOW); break;
  75. case 6: LCD_Fill(131,221,lcddev.width-1,lcddev.height-1,BRRED); break;
  76. }
  77. sta++;
  78. if(sta>6)sta=0;
  79. }
  80. //软件定时器 3 的回调函数
  81. void tmr3_callback(OS_TMR *ptmr,void *p_arg)
  82. {
  83. u8* p;
  84. u8 err;
  85. static u8 msg_cnt=0; //msg 编号
  86. p=mymalloc(SRAMIN,13); //申请 13 个字节的内存
  87. if(p)
  88. {
  89. sprintf((char*)p,"ALIENTEK %03d",msg_cnt);
  90. msg_cnt++;
  91. err=OSQPost(q_msg,p); //发送队列
  92. if(err!=OS_ERR_NONE) //发送失败
  93. {
  94. myfree(SRAMIN,p); //释放内存
  95. OSTmrStop(tmr3,OS_TMR_OPT_NONE,0,&err); //关闭软件定时器 3 } }
  96. }
  97. //加载主界面
  98. void ucos_load_main_ui(void)
  99. { …//此处省略函数定义
  100. }
  101. int main(void)
  102. {
  103. Cache_Enable(); //打开 L1-Cache
  104. HAL_Init(); //初始化 HAL 库
  105. Stm32_clock_Init(432,25,2,9); //设置时钟,216Mhz
  106. delay_init(216); //延时初始化
  107. uart_init(115200); //串口初始化
  108. LED_Init(); //初始化 LED
  109. KEY_Init(); //初始化按键
  110. PCF8574_Init(); //初始化 PCF8574
  111. SDRAM_Init(); //初始化 SDRAM
  112. LCD_Init(); //初始化 LCD
  113. TPAD_Init(8); //初始化触摸按键
  114. tp_dev.init(); //初始化触摸屏
  115. my_mem_init(SRAMIN); //初始化内部内存池
  116. ucos_load_main_ui(); //加载主界面
  117. OSInit(); //UCOS 初始化
  118. OSTaskCreateExt((void(*)(void*) )start_task, //任务函数
  119. (void* )0, //传递给任务函数的参数
  120. (OS_STK* )&START_TASK_STK[START_STK_SIZE-1],
  121. //任务堆栈栈顶
  122.    (INT8U )START_TASK_PRIO, //任务优先级
  123. (INT16U )START_TASK_PRIO, //任务 ID,这里设置
  124. //为和优先级一样
  125. (OS_STK* )&START_TASK_STK[0], //任务堆栈栈底
  126. (INT32U )START_STK_SIZE, //任务堆栈大小
  127. (void* )0, //用户补充的存储区
  128. (INT16U ) OS_TASK_OPT_STK_CHK|\
  129. OS_TASK_OPT_STK_CLR|\
  130. OS_TASK_OPT_SAVE_FP);//任务选项
  131. OSStart(); //开始任务
  132. }
  133. ///////////////////////////////////////////////////////////////////////////////////////////////////
  134. //画水平线
  135. //x0,y0:坐标 len:线长度 color:颜色
  136. void gui_draw_hline(u16 x0,u16 y0,u16 len,u16 color)
  137. {
  138. …//此处省略函数定义
  139. }
  140. //画实心圆
  141. //x0,y0:坐标 r:半径 color:颜色
  142. void gui_fill_circle(u16 x0,u16 y0,u16 r,u16 color)
  143. {
  144. …//此处省略函数定义
  145. }
  146. //两个数之差的绝对值
  147. //x1,x2:需取差值的两个数
  148. //返回值:|x1-x2|
  149. u16 my_abs(u16 x1,u16 x2)
  150. {
  151. if(x1>x2)return x1-x2;
  152. else return x2-x1;
  153. }
  154. //画一条粗线
  155. //(x1,y1),(x2,y2):线条的起始坐标
  156. //size:线条的粗细程度 color:线条的颜色
  157. void lcd_draw_bline(u16 x1, u16 y1, u16 x2, u16 y2,u8 size,u16 color)
  158. {
  159. …//此处省略函数定义
  160. }
  161. ///////////////////////////////////////////////////////////////////////////////////////////////////
  162. //开始任务
  163. void start_task(void *pdata)
  164. {
  165.   OS_CPU_SR cpu_sr=0;
  166. u8 err;
  167. pdata=pdata;
  168. msg_key=OSMboxCreate((void*)0); //创建消息邮箱
  169. q_msg=OSQCreate(&MsgGrp[0],256); //创建消息队列
  170. flags_key=OSFlagCreate(0,&err); //创建信号量集
  171. OSStatInit(); //开启统计任务
  172. OS_ENTER_CRITICAL(); //进入临界区(关闭中断)
  173. //LED 任务
  174. OSTaskCreateExt((void(*)(void*) )led_task,
  175. (void* )0,
  176. (OS_STK* )&LED_TASK_STK[LED_STK_SIZE-1],
  177. (INT8U )LED_TASK_PRIO,
  178. (INT16U )LED_TASK_PRIO,
  179. (OS_STK* )&LED_TASK_STK[0],
  180. (INT32U )LED_STK_SIZE,
  181. (void* )0,
  182. (INT16U ) OS_TASK_OPT_STK_CHK|、
  183. OS_TASK_OPT_STK_CLR|\
  184. OS_TASK_OPT_SAVE_FP);
  185. OSTaskCreateExt(……//省略部分代码); //触摸任务
  186. OSTaskCreateExt(……//省略部分代码); //消息队列显示任务
  187. OSTaskCreateExt(……//省略部分代码); //主任务
  188. OSTaskCreateExt(……//省略部分代码); //信号量集任务
  189. OSTaskCreateExt(……//省略部分代码); //按键任务
  190. OS_EXIT_CRITICAL(); //退出临界区(开中断)
  191. OSTaskSuspend(START_TASK_PRIO); //挂起开始任务
  192. }
  193. //LED 任务
  194. void led_task(void *pdata)
  195. {
  196. u8 t;
  197. while(1)
  198. {
  199. t++;
  200. delay_ms(10);
  201. if(t==8)LED0(1); //LED0 灭
  202. if(t==100) //LED0 亮 {
  203. t=0; LED0(0); } }
  204. }
  205. //触摸屏任务
  206. void touch_task(void *pdata)
  207. {
  208. u32 cpu_sr;
  209. u16 lastpos[2]; //最后一次的数据
  210. while(1)
  211. {
  212. tp_dev.scan(0);
  213. if(tp_dev.sta&TP_PRES_DOWN) //触摸屏被按下
  214. {
  215. if(tp_dev.x[0]<(130-1)&&tp_dev.y[0]<lcddev.height&&tp_dev.y[0]>(220+1))
  216. {
  217. if(lastpos[0]==0XFFFF)
  218. {
  219. lastpos[0]=tp_dev.x[0];
  220. lastpos[1]=tp_dev.y[0];
  221. }
  222. //进入临界段,防止其他任务,打断 LCD 操作,导致液晶乱序.
  223. OS_ENTER_CRITICAL();
  224. lcd_draw_bline(lastpos[0],lastpos[1],tp_dev.x[0],tp_dev.y[0],2,RED);//画线
  225. OS_EXIT_CRITICAL();
  226. lastpos[0]=tp_dev.x[0];
  227. lastpos[1]=tp_dev.y[0];
  228. }
  229. }else
  230. {
  231. lastpos[0]=0XFFFF;
  232. delay_ms(10); //没有按键按下的时候
  233. } } }
  234. //队列消息显示任务
  235. void qmsgshow_task(void *pdata)
  236. {
  237. u8 *p,err;
  238. while(1)
  239. {
  240. p=OSQPend(q_msg,0,&err);//请求消息队列
  241. LCD_ShowString(5,170,240,16,16,p);//显示消息
  242. myfree(SRAMIN,p);
  243. delay_ms(500);
  244. }
  245. }
  246. //主任务
  247. void main_task(void *pdata)
  248. {
  249. u32 key=0;
  250. u8 err;
  251. u8 tmr2sta=1; //软件定时器 2 开关状态
  252. u8 tmr3sta=0; //软件定时器 3 开关状态
  253. u8 flagsclrt=0;//信号量集显示清零倒计时
  254. tmr1=OSTmrCreate(10,10,OS_TMR_OPT_PERIODIC,\ //100ms 执行一次
  255. (OS_TMR_CALLBACK)tmr1_callback,0,"tmr1",&err);
  256. tmr2=OSTmrCreate(10,20,OS_TMR_OPT_PERIODIC,\ //200ms 执行一次
  257. (OS_TMR_CALLBACK)tmr2_callback,0,"tmr2",&err);
  258. tmr3=OSTmrCreate(10,10,OS_TMR_OPT_PERIODIC,\ //100ms 执行一次
  259. (OS_TMR_CALLBACK)tmr3_callback,0,"tmr3",&err);
  260. OSTmrStart(tmr1,&err);//启动软件定时器 1
  261. OSTmrStart(tmr2,&err);//启动软件定时器 2
  262. while(1)
  263. {
  264. key=(u32)OSMboxPend(msg_key,10,&err);
  265. if(key)
  266. {
  267. flagsclrt=51;//500ms 后清除
  268. //设置对应的信号量为 1
  269. OSFlagPost(flags_key,1<<(key-1),OS_FLAG_SET,&err);
  270. }
  271. if(flagsclrt)//倒计时
  272. {
  273. flagsclrt--;
  274. if(flagsclrt==1)LCD_Fill(140,162,239,162+16,WHITE);//清除显示
  275. }
  276. switch(key)
  277. {
  278. case 1://控制 DS1
  279. LED1_Toggle;break;
  280. case 2://控制软件定时器 3
  281. tmr3sta=!tmr3sta;
  282. if(tmr3sta)OSTmrStart(tmr3,&err);
  283. else OSTmrStop(tmr3,OS_TMR_OPT_NONE,0,&err);//关闭软件定时器 3
  284. break;
  285. case 3://清除
  286. LCD_Fill(0,221,129,lcddev.height-1,WHITE);
  287. break;
  288. case 4://校准
  289.     OSTaskSuspend(TOUCH_TASK_PRIO);//挂起触摸屏任务
  290. OSTaskSuspend(QMSGSHOW_TASK_PRIO);//挂起队列信息显示任务
  291. OSTmrStop(tmr1,OS_TMR_OPT_NONE,0,&err);//关闭软件定时器 1
  292. //关闭软件定时器 2
  293. if(tmr2sta)OSTmrStop(tmr2,OS_TMR_OPT_NONE,0,&err);
  294. if((tp_dev.touchtype&0X80)==0)TP_Adjust();
  295. OSTmrStart(tmr1,&err); //重新开启软件定时器 1
  296. if(tmr2sta)OSTmrStart(tmr2,&err); //重新开启软件定时器 2
  297. OSTaskResume(TOUCH_TASK_PRIO); //解挂
  298. OSTaskResume(QMSGSHOW_TASK_PRIO); //解挂
  299. ucos_load_main_ui(); //重新加载主界面
  300. break;
  301. case 5://软件定时器 2 开关
  302. tmr2sta=!tmr2sta;
  303. if(tmr2sta)OSTmrStart(tmr2,&err); //开启软件定时器 2
  304. else
  305. {
  306. //关闭软件定时器 2
  307. OSTmrStop(tmr2,OS_TMR_OPT_NONE,0,&err);
  308. //提示定时器 2 关闭了
  309. LCD_ShowString(148,262,240,16,16,"TMR2 STOP");
  310. }
  311. break;
  312. }
  313. delay_ms(10);
  314. } }
  315. //信号量集处理任务
  316. void flags_task(void *pdata)
  317. {
  318. u16 flags;
  319. u8 err;
  320. while(1)
  321. {
  322. //等待信号量
  323. flags=OSFlagPend(flags_key,0X001F,OS_FLAG_WAIT_SET_ANY,0,&err);
  324. if(flags&0X0001)LCD_ShowString(140,162,240,16,16,"KEY0 DOWN ");
  325. if(flags&0X0002)LCD_ShowString(140,162,240,16,16,"KEY1 DOWN ");
  326. if(flags&0X0004)LCD_ShowString(140,162,240,16,16,"KEY2 DOWN ");
  327. if(flags&0X0008)LCD_ShowString(140,162,240,16,16,"KEY_UP DOWN");
  328. if(flags&0X0010)LCD_ShowString(140,162,240,16,16,"TPAD DOWN ");
  329. PCF8574_WriteBit(BEEP_IO,0);
  330.   delay_ms(50);
  331. PCF8574_WriteBit(BEEP_IO,1);
  332. OSFlagPost(flags_key,0X001F,OS_FLAG_CLR,&err);//全部信号量清零
  333. }
  334. }
  335. //按键扫描任务
  336. void key_task(void *pdata)
  337. {
  338. u8 key;
  339. while(1)
  340. {
  341. key=KEY_Scan(0);
  342. if(key==0)
  343. {
  344. if(TPAD_Scan(0))key=5;
  345. }
  346. if(key)OSMboxPost(msg_key,(void*)key);//发送消息
  347. delay_ms(10);
  348. }
  349. }
复制代码

本章 main.c 的代码有点多,因为我们创建了 7 个任务,3 个软件定时器及其回调函数,所
以,整个代码有点多,我们创建的 7 个任务为:start_task、led_task、touch_task、qmsgshow_task 、
flags_task 、main_task 和 key_task,优先级分别是 10 和 7~2,堆栈大小都是 128。
我们还创建了 3 个软件定时器 tmr1、tmr2 和 tmr3,tmr1 用于显示 CPU 使用率和内存使用
率,每 100ms 执行一次;tmr2 用于在 LCD 的右下角区域不停的显示各种颜色,每 200ms 执行
一次;tmr3 用于定时向队列发送消息,每 100ms 发送一次。
本章,我们依旧使用消息邮箱 msg_key 在按键任务和主任务之间传递键值数据,我们创建
信号量集 flags_key,在主任务里面将按键键值通过信号量集传递给信号量集处理任务 flags_task,
实现按键信息的显示以及发出按键提示音。
本章,我们还创建了一个大小为 256 的消息队列 q_msg,通过软件定时器 tmr3 的回调函数
向消息队列发送消息,然后在消息队列显示任务 qmsgshow_task 里面请求消息队列,并在 LCD
上面显示得到的消息。消息队列还用到了动态内存管理。
在主任务 main_task 里面,我们实现了 69.2 节介绍的功能:KEY0 控制 LED1 亮灭;KEY1
控制软件定时器 tmr3 的开关,间接控制队列信息的发送;KEY2 清除触摸屏输入;KEY_UP 用
于触摸屏校准,在校准的时候,要先挂起触摸屏任务、队列消息显示任务,并停止软件定时器
tmr1 和 tmr2,否则可能对校准时的 LCD 显示造成干扰;TPAD 按键用于控制软件定时器 tmr2
的开关,间接控制屏幕显示。
软件设计部分就为大家介绍到这里。
69.4 下载验证
在代码编译成功之后,我们通过下载代码到阿波罗 STM32 开发板上,可以看到 LCD 显示
界面如图 69.4.1 所示:


图 69.4.1 初始界面
从图中可以看出,默认状态下,CPU 使用率为 7%左右。比上一章多出一些,这主要是
key_task 里面增加不停的刷屏(tmr2)操作导致的。
通过按 KEY0,可以控制 DS1 的亮灭;
通过按 KEY1 则可以启动 tmr3 控制消息队列发送,可以在 LCD 上面看到 Q 和 MEM 的值
慢慢变大(说明队列消息在增多,占用内存也随着消息增多而增大),在 QUEUE MSG 区,开
始显示队列消息,再按一次 KEY1 停止 tmr3,此时可以看到 Q 和 MEM 逐渐减小。当 Q 值变
为 0 的时候,QUEUE MSG 也停止显示(队列为空)。
通过 KEY2 按键,清除 TOUCH 区域的输入。
通过 KEY_UP 按键,可以进行触摸屏校准(仅电阻屏,电容屏无需校准)。
通过 TPAD 按键,可以启动/停止 tmr2,从而控制屏幕的刷新。
在 TOUCH 区域,可以输入手写内容。
任何按键按下,蜂鸣器都会发出“滴”的一声,提示按键被按下,同时在 FLAGS 区域显
示按键信息。
正点原子
2016-10-28
于广州

2
分享淘帖 显示全部楼层

评论

高级模式
您需要登录后才可以回帖 登录 | 注册

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容图片侵权或者其他问题,请联系本站作侵删。 侵权投诉
发资料
关闭

站长推荐 上一条 /7 下一条

快速回复 返回顶部 返回列表