Event Driven Class OSAL
基于事件驱动的模拟操作系统
##前言
什么是OSAL
OASL采用3层架构:硬件层,OASL+HAL层,应用层
LIB层：为芯片原创提供的库文件
应用层,用户自己应用程序.
OSAL详解
概要
OSAL框架
TICK(心跳):为系统时间节拍使用;osTimer(软件定时器）、osEvent（事件）、osDelay（系统延时）均基于此定时器来运行；故此定时器是整个OSAL的心脏。
任务是一个程序的入口（这里说的程序是指一个较小的功能模块），任务通常指所接受的工作，所担负的职责，是指为了完成某个有方向性的目的而产生的活动。
osEvent是思路来源于NXP的BLE模块思路，使用他可以即时使或者延时回调指定的函数。
定时器属于用软件实现了多个硬件定时器;
任务配置:
/** define Max Task Num
* 定义最大任务数 MAX<0xFFFF ,用户根据项目实际大小修改,
* 任务数越多,所占用的RAM就越多.
**/
#define MAX_TASK_NUM (IDLE_TASK_NUM+8u)
/** define Max Task Message Buffer Num
* 定义最大任务消息缓冲数,
* 建议与MAX_TASK_NUM相等或者更大
**/
#define MAX_TASK_MSG_BUF_NUM (MAX_TASK_NUM*3)
任务函数原型:
/* Defining task function pointer array types */
/* 定义任务函数指针数组类型
* uint8_t id:任务的ID,向任务发送消息时,需要用到此ID
* uint8_t msg: 消息号
* void *pData: 消息所携带的数据
* uint16_t dataSize: 数据大小
*/
typedef void(*tpfTaskFunc)(uint8_t id, uint8_t msg, void *pData, uint16_t dataSize);
void idleTask(uint8_t taskId, uint8_t msg, void *pData, uint16_t dataSize)
调用函数createTask创建一个任务,函数原型uint8_t createTask(tpfTaskFunc pfFunction), pfFunction是任务的函数指针;创建成功返回任务的ID,创建失败返回0;
uint8_t createTask(tpfTaskFunc pfFunction)
有时创建的任务工作任务已经完成,可以被删除,调用uint8_t delTask(tpfTaskFunc pfFunction)可以删除任务.
uint8_t delTask(tpfTaskFunc pfFunction)
注意被删除后,应用层无法对应用是否删除进行判断,此时用户要避免还要此任务发送消息.
任务创建时系统会自动发一个初始化消息给任务,任务接是到此消息时可以初始化各变量,或者硬件资源.
/* 给当前任务发送初始化消息 */
sendMsgToTask(gtTask.taskIdMax, TASK_INIT, NULL, 0);
/* 系统初始化 */
case TASK_INIT:
{
adcInit(>CfgAdcVol);
createTimer(1000,secTimer);
}break;
当有消息发给任务时,任务调度器(osScheduler)会从任务消息取出消息,并回调任务函数。
调用sendMsgToTask可以发送消息给指定的任务.
/**
* function:
* 作用: 创建一个任务
* parame 1:
* 参数1: taskId为接收消息的任务ID
* parame 2:
* 参数2: msg为发送的消息内容
* parame 3:
* 参数3: pData传递的数据,
* parame 4:
* 参数4: dataSize传递数据的大小
* return :
* 返回: 消息发送成功返回true,否则返回false.
**/
bool sendMsgToTask(uint8_t taskId, uint8_t msg, void *pData, uint16_t dataSize)
一旦有消息发给任务,对应的任务函数就会被调度,并且通过任务函数的形参收到消息.
任务消息处理:
任务被调度时,可以从形参msg获取消息, pData获取携带的数据, dataSize获取数据长度,任务根据消息内存做出相应的处理,处理完成后返回,系统再次调度其它任务.
当任务在处理消息发生新的消息,任务可以向自己发送另外一个消息.
void mainTask(uint8_t taskId, uint8_t msg ,void *pData, uint16_t dataSize)
{
switch(msg)
{
/* 系统初始化 */
case TASK_INIT:
{
adcInit(>CfgAdcVol);
}break;
/* 按键 */
case MAIN_KEY_MSG:
{
switch((uint32_t)pData)
{
case KEY_0:
case KEY_1:
{
data = (uint8_t)(uint32_t)pData;
printf("key=%d",data );
}break;
}
}
}
}
任务中通常不允许Delay,大多Delay可以由延时事件来完成,如果必需用到Delay,那么可以使用OS提供的osDelayMs函数和taskDelayMs函数;
/*
** 系统延时并发数
** 加大此时,在任务中用到bOsDelayMs(),会增加栈的空间消耗,注意调整栈大小,并控制使用bOsDelayMs().
*/
#define OS_DELAY_MAX_CONCURRENT 1u
/*
** 系统延时
** 最小单位1/2个TICK周期;延时时可调度其它任务和事件.
** 需要注意,延时中的函数可能会被其它任务或者事件调用,
** 要防止函数递归调用时全局变量或静态变量被修改,造成程序异常.
*/
/
/* 特别声明:由于vOsDelayMs时当前运行的函数会阻塞,
** 但为了做多任务,系统在函数阻塞时,调度其它任务和事件.
** 同时可能调用已经阻塞的任务,发生递归调用的情况;
** 这样压栈的数据就会大大增加,严重时发生栈溢出,导致程序崩溃.
** 为了解决此问题,当已经有任务在延时的,不允许有任务再延时,
** 这样可能会对某个任务造成异常,但保护了系统不会崩溃.
** 用户调用此延时程序时,需要判断返回值,如果返回值为fals,说明延时失败,
** 此时用户需要自行设法解决
*/
bool osDelayMs(uint16_t usDelayMs)
/
/* 特别声明:由于bTaskDelayMs时所有任务会阻塞,
** 任务阻塞时,事件会被调度.
*/
bool taskDelayMs(uint16_t usDelayMs)
/*
** 系统指令延时,调用此函数,会使所有任务和事件阻塞,非必要情况下尽量少用
*/
void osDirectiveDelay(uint16_t usDelay)
/*
** 较精准延时,但最小延时不得小于TICK;
*/
void osDirectiveDelayMs(uint16_t usDelayMs)
当调用osDelayMs时系统会调用其它任务或者事件(这需要消耗大量的栈空间,还可以能因为栈空间不足导致异常,甚至因为这里发生了递归调用,造成后面处理的逻辑顺序错误,故osDelayMs谨慎使用,最好不用);
当调用taskDelayMs所有任务会被卡死,不再调度任务,而一直在调度事件Event,这样可以把一些优先级高的,以事件的方式进行处理,然后任务调用taskDelayMs,优先处理事件.
将#define OS_DELAY_MAX_CONCURRENT 的定义改为非0时;当一个任务调用osDelayMs时,其它任务可能就会被调用,由于OSAL没有任务切换功能,那里这里就是采用递归调用的方法实际了多任务的假象，使用时务必要留心，递归调用会极大的增加栈空间的消耗，严重造成栈空间不足而程序异常。
故osDelayMs在非必要是不要使用。
由于OSAL没有任务切换,不能实现多任务,故没有任务优先级的说法.
只有一个任务退出,其它任务才能被调度，所有任务不能长时间被占用，更不能写成while(1) 。
当所有任务都处于空闲时,如果在使能空闲任务的情况下,系统会调度空闲任务,用户可以在空闲任务处理扫描事件,或者让CPU休眠.
##osEvent事件:
事件配置:
在”osConfig.h”文件定义了任务最大数
#define EVNT_CONCURRENT 16u
需要开发者根据情况需求调整大小,此值越大所占内成RAM就越大.
注意:此值并不是可以创建事件的数量,而是事件同时运行的并发数量.事件一旦调度运行后,就会释放出内存来给其它事件使用.
事件函数的原型：
/* Defining task function pointer array types */
/* 定义事件函数指针数组类型*/
typedef void(*tpEventFunc)(uint32_t eventId, uint32_t param);
void closeLed(uint32_t eventId, uint32_t param)
{
close(param)
}s
调用函数createEvent和createEvents可以创建一个事件,
/**
* function: Create Event
* 采用回调函数方式操作事件,同一个回调函数不能被创建多次
* 作用: 创建一个事件,可以是及时的,也可以是延时的.
* uint32_t uiTime:
* 参数1: 设置延时时间,以mS为单位.
* tpfTimerFunc pFunction:
* 参数2: 定时事件回调函数
* uint32_t param
* 参数3: 传递给回调函数的参数
* return : true or false
* 返回:
* 注意:软件定时器是一个相对定时器,不能完全保证精确度,另外尽量不要用最小单位来创建定时器,那样会非常不准
**/
bool createEvent(uint32_t delayMs, tpEventFunc pFunction, uint32_t param)
/**
* function: usCreateEvents
* 采用事件ID方式操作事件,同一个回调函数可能被创建多次
* 作用: 创建一个事件,可以是及时的,也可以是延时的.
* uint32_t uiTime:
* 参数1: 设置延时时间,以mS为单位.
* tpfTimerFunc pFunction:
* 参数2: 定时事件回调函数
* uint32_t param
* 参数3: 传递给回调函数的参数
* return :事件ID
* 返回:
* 注意:软件定时器是一个相对定时器,不能完全保证精确度,另外尽量不要用最小单位来创建定时器,那样会非常不准
**/
uint32_t createEvents(uint32_t delayMs, tpEventFunc pFunction, uint32_t param)
根据回调函数指针作为唯一标识创建事件，同一个回调函数反复创建只会发生一次回调，第二次创建时，上一次所有参数会被覆盖，通常可以用创建来刷新延时时间。
第一个参数delayMs：是事件延时时间,以mS为单位,传0为即时事件,
第二个参数pFunction：为事件回调函数,第三个参数是传递给回调函数的参数,即是传递给事件的消息.返回创建成功与失败.
第三个参数param：传入给事件函数的参数
采用事件ID方式操作事件,同一个回调函数被创建多次，就会产品不同的ID，同一个函数会被多次回调。
此方法创建事件会返回一个ID,做为事件的唯一标识,为便于日后的删/查/改此ID需要保存下来。
参数与createEvent相同.
事件创建后,延时时间到时,系统会自动调度任务,任务只会运行一次,如果需要周期运行,需要在任务函数中再次创建.
事件创建后可调用cleanEvent和cleanEventForId,删除已经创建的事件;
事件被创建后,在事件还未回调前,可以重置事件的计时.
采用createEvent和createEvents创建的事件,在重置和清除需要用对应的API,不可混用.
例1:我们需要点一个灯,但延迟一定时间后就关掉,传统有两个方法解决：
led_on（）;
delay_ms(100);
led_off();
led_on（）;
led_off_time = 100;
void timer(void)
{
if(led_off_time)
{
if(--led_off_time == 0)
led_off();
}
}
led_on（）;
osCreatEvent(ledOff)
void ledOff(uint32_t eventId, uint32_t param)
{
led_off();
}
在”osConfig.h”文件定义了任务最大数 #define MAX_TIMER_NUM 3u,
需要开发者根据情况需求调整大小,此值越大所占内成RAM就越大.
定时器回调函数原型
/* 定义定时器函数指针数组类型*/
typedef void(*tpfTimerFunc)(void);
void secTimer(void)
{
static uint8_t ucVoltageCount=0;
static uint16_t usHourCount=0;
if(++ucVoltageCount == 1)/* 每3秒检查一次当前工作电压 */
{
ucVoltageCount = 0;
sendMsgToTask(gMainTaskId, MAIN_CHECK_CURRUCT_VOLTAGE_MSG, NULL, 0);
}
if(++usHourCount == 3600)/* 每1小时检查一次最低工作电压 */
{
usHourCount = 0;
sendMsgToTask(gMainTaskId, MAIN_CHECK_MIN_VOLTAGE_MSG, NULL, 0);
}
}
软件定时器是基于TICK中断的回调实现的，其是在中断中运行，并分像RTOS那样是由任务Task在运行，故使用定时器时避免耗时太多。
定时器创建:
调用函数createTimer可以创建一个定时器.
/**
* function: Create timer
* 作用: 创建一个定时器,此定时器属于硬件定时器,避免定时器回调函数中有大量代码.
* 定时器一旦创建后,在删除前,就会周期性运行;如果需要单次定时器,请用延时事件来实现.
* 参数1: 定时时间,1mS为单位,0-65535
* 参数2: 回调函数指针,即任务函数指针,任务函数原型 void vTimerFunc(void *param);
* 返回: false or true
* 任务创建失败时,请检查osConfig中任务最大数量"MAX_TASK_NUM",或者定时器已经被创建.
**/
bool createTimer(uint32_t timeMs, tpfTimerFunc pfFunction)
//函数原型bool createTimer(uint32_t timeMs, tpfTimerFunc pfFunction):
//第一个参数timeMs:设定定时器的时间,以mS为单位
//第二个参数pfFunction:定时器回调函数.
//返回:创建成功与失败,false or true
此方法创建定时器,是用回调函数做为味一标识;同一个回调函数只能创建一个定时器、
调用使用同一回调函数支持创建定时器,回调函数并不会被多个定时器调用,只能更新其参数。
定时器设置定时器到后,会在定时器中断中直接回调函数处理定时器,这样达到抢占CPU的目的,但正由于在中断中处理,定时器中不能写太多程序,以免影响定时器正常运行.
调用函数createTimer可以重置一个定时器的时间.
定时器删除:
事件创建后可调用delTimer,删除已经创建的事件;
函数原型delTimer(tpfTimerFunc pfFunction),参数为定时器的回调函数指针,返回成功或失败.
消息队列是OSAL的基础，任务的通讯和调度可以说就是基于消息队列来实现的，用户根据需要可自由创建各种类型的队列。
队列的底层是链表，研究队列可适合初始化学习链表。
定义消息结构
根据用户根据需求创建一个队列缓冲区,队列可以是单个字节的数据类型,可以是一个复杂的结构体类型,可参考任务部分创建的消息类型.
示例：
/* Define task structure */
/* 定义任务消息结构 */
typedef struct strTaskMessage
{
uint8_t taskId; //任务ID
uint8_t message; //消息值（标题）
uint16_t dataSize; //消息携带的数据大小
void *pData; //消息携带的数据缓冲区指针
}tsTaskMsg;
static tsTask gtTaskBuffer[MAX_TASK_MSG_BUF_NUM];
使用结构体tsQueue,创建一个变量.以后读队列和取队列均通过此变量操作.
tsQueue gtTaskQueue;
/**
* function:
* 作用: 创建一个消息队列,队列可以是任意形式的
* tsQueue *psQueue: Queue structure pointer
* 参数1: 消息队列对象指针,实际是一个机构体变量,用于存放链表.
* void *pBuf: Buffer pointer for storing messages
* 参数2: 用于存放消息的缓冲区指针,
* 缓冲区可以是结构体类型BUF,可以是一个基本类型的BUF.
* uint8_t deep: sizeof(buf)/sizeof(buf[0])
* 参数3: 缓冲区的深度,sizeof(buf)/sizeof(width);
* uint8_t width: Length of message data
* 参数4: 消息数据宽度;sizeof(data)
* return : false of true
* 返回: 成功 或 失败
**/
bool createQueue(tsQueue *psQueue, void *pBuf, uint8_t deep, uint8_t width)
使用bool createQueue(tsQueue *psQueue, void *pBuf, uint8_t bufLen, uint8_t dataLen); 来创建队列
/***
** Function name: PushQueue
** Descriptions: 数据入队（正常入队）
** Param[input]: psQueue 队列指针
** Param[input]: vpBuf 数据指针
** Param[input]: num 消息的数量,注意:这里并非数据长度,而是装入消息的数量
** Returned value: 操作结果
***/
bool pushQueue(tsQueue *psQueue,void *pBuf, uint8_t num)；
bool pushQueue(tsQueue *psQueue,void *pBuf,uint8_t ucLen)：
第一个参数psQueue：消息队列对象指针,此对象是在创业消息队列前已经被创建。
第二个参数pBuf：是发送数据的指针,
第三个参数num：消息的数量,注意:这里并非数据长度,而是装入消息的数量，每个消息的大小是固定的。
返回值：发送成功与否
#define pushQuBuf(S_QUEUE, P_BUF, NUM) pushQueue(&S_QUEUE, (void *)P_BUF, NUM)
#define pushQuOne(S_QUEUE, S_BUF) pushQueue(&S_QUEUE, (void *)&S_BUF, 1)
pushQuOne()发送一个消息，
pushQuBuf()用来发数多个消息
消息的插入
/**
** Function name: PushQueueHead
** Descriptions: 数据入队（插队）,此数据会优先出队
** Param[input]: psQueue 队列指针
** Param[input]: vpBuf 数据指针
** Param[input]: num 数据长度
** Param[output]: node
** Returned value: 操作结果
**/
bool pushQueuePrior(tsQueue *psQueue,void *pbuf,uint8_t num)
消息队列采用先进先出策略，有时有希望部分消息能各得到优先处理，这里就可以采用插入的方式处理。
bool pushQueuePrior(tsQueue *psQueue,void *pbuf,uint8_t num)
第一个参数psQueue：消息队列对象指针,此对象是在创业消息队列前已经被创建。
第二个参数pBuf：是发送数据的指针,
第三个参数num：消息的数量,注意:这里并非数据长度,而是装入消息的数量，每个消息的大小是固定的。
返回值：发送成功与否
判断是否有消息
uint8_t getQueueDataNum(tsQueue *psQueue)可以判断队列中是否有消息和消息的条数.
/*
* 获取当前队列数据个数
*/
uint8_t getQueueDataNum(tsQueue *psQueue)
宏定义#define getQuDataNum(S_QUEUE) getQueueDataNum(&S_QUEUE)简化操作
#define getQuDataNum(S_QUEUE) getQueueDataNum(&S_QUEUE)
/*
** Function name: PullQueue
** Descriptions: 数据出队（队头出队队）
** Param[input]: psQueue 队列指针
** Param[input]: pbuf 数据指针
** Param[input]: num 消息的数量(或称为条数)
** Returned value: 取出消息的条数
*********************************************************************************************************/
uint8_t pullQueue(tsQueue *psQueue, void *pbuf, uint8_t num)
使用uint8_t pullQueue(tsQueue *psQueue,void *pbuf,uint8_t len)可以取出消息：
第一个参数psQueue：消息队列对象指针
第二个参数pbuf：为取消息缓冲区,
第三个参数num：要取的消息条数
返回：实际期出消息的条数。
系统的移植较为简单, 只需要定义全局中断开关、创建一个定时器,并移植看门狗程序即可运行.
OSAL非抢占式,不带任务切换,故在任务中不能写死循环,任务执行某事件完成后必需立即返回,以便其它使用使用CPU,这样就大大提高了系统实时性,感觉系统像一个多任务在运行.
为了更好的实现模块化设计,彻底解除应用与硬件的耦合,OSAL设计了HAL层.
驱动做为HAL的基础驱动库，大多外设均需要依赖于bspGPIO来实现。
采用HAL的bspGPIO最大的好处就是不需要调用复杂的函数去初始化GPIO,而是采用简单的配置即可初始化GPIO,极的方便地程序的开发,也便于在同一个MCU上开发不同的程序,大大提高了工作效率。
typedef struct
{
rcu_periph_enum gpioRcu; //RCU_GPIOAx
uint32_t gpioPeriph; //GPIOx
uint32_t pin; //GPIO_PIN_x
uint32_t mode; //GPIO_MODE_INPUT,GPIO_MODE_OUTPUT,GPIO_MODE_AF,GPIO_MODE_ANALOG
uint32_t pull; //GPIO_PUPD_NONE,GPIO_PUPD_PULLUP,GPIO_PUPD_PULLDOWN
uint32_t otype; //GPIO_OTYPE_PP,GPIO_OTYPE_OD
uint32_t speed; //GPIO_OSPEED_2MHZ,GPIO_OSPEED_10MHZ,GPIO_OSPEED_50MHZ
uint32_t af; //GPIO_AF_x
}tsCfgGpio;
void gpioConfig(tsCfgGpio *cfg)
{
/* enable clock */
rcu_periph_clock_enable(cfg->gpioRcu);
/* connect port to cfg */
gpio_af_set(cfg->gpioPeriph, cfg->af, cfg->pin);
gpio_mode_set(cfg->gpioPeriph, cfg->mode, cfg->pull, cfg->pin);
gpio_output_options_set(cfg->gpioPeriph, cfg->otype, cfg->speed, cfg->pin);
}
#define UART_TX {RCU_GPIOA, GPIOA, GPIO_PIN_3, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_OTYPE_OD, GPIO_OSPEED_10MHZ, GPIO_AF_1)
例：初始化GPIO
/* 配置GPIO */
#define UART_TX {RCU_GPIOA, GPIOA, GPIO_PIN_3, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_OTYPE_OD, GPIO_OSPEED_10MHZ, GPIO_AF_1)
tsCfgGpio gtCfgTx = UART_TX; //定义UART_TX脚对象
gpioConfig（>CfgTx）；//初始化GPIO
typedef struct
{
rcu_periph_enum rcu;
uint32_t com;
uint32_t nvicIrq;
uint32_t nvicIrqPriority;
uint32_t nvicIrqSubPriority;
tsCfgGpio txIo;
tsCfgGpio rxIo;
}tsCfgUart;
#define DEV_UART0_0 /*UART0_A2A3, AF1*/ \
{RCU_USART0, USART0, USART0_IRQn, 2, 2,/*COM*/\
RCU_GPIOA, GPIOA, GPIO_PIN_2, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_OTYPE_PP, GPIO_OSPEED_10MHZ, GPIO_AF_1, /*TX*/\
RCU_GPIOA, GPIOA, GPIO_PIN_3, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_OTYPE_OD, GPIO_OSPEED_10MHZ, GPIO_AF_1 /*RX*/}
typedef void (*pUartCallBackFun)(uint8_t *pBuf, uint16_t size);
/*!
\brief init Uart function
\param[in] cfg: USARTx(x = 0,1,2)
\param[in] baudRate: 2400,9600... 115200
\param[in] ePort: teUartPort
\param[in] bufSize: 0~65535
\param[in] pCallBack: UART Call Back Funce
\retval none
GPIO_AF:参考 datasheet 2.6.7 GD32E230xx pin alternate functions
注意:uart1不支持超时定时器,串口成帧需要应用层自行实现
*/
void uartInit(tsCfgUart *cfg, uint32_t baudRate,uint8_t *pReceBuf, uint32_t bufSize, pUartCallBackFun pCallBack)
/* UART接收回调函数 */
void rxCcb(uint8_t *pucBuf, uint16_t usSize)
{
uint8_t *pPtr;
bool bRet ;
pPtr = (uint8_t *)osMalloc(usSize+1);
if(NULL == pPtr)
return;
memcpy(pPtr,pucBuf,usSize);
bRet = sendMsgToTask(TaskId, MSG, (void *)pPtr, usSize);
if(false == bRet)
osFree(pPtr);
}
tsCfgUart gtCfgUart = DEV_UART0_0; //UART对象
uartInit(>CfgUart,9600, rxBuffer, BUF_UART_SIZE, rxCcb); //初始化UART
uartWrite(>CfgUart, txBuffer, 128); //UART发送
通过以上代码，您是否发现，现在我们操作UART是如此的简单；已经做到应用程序和UART硬件完全的隔离，这使得同一个应用可以被运行在不同的MCU，而不需要花太多的精力去修改；您需要做的只是移植驱动程序。