请选择 进入手机版 | 继续访问电脑版
搜索
专业IC版图外包服务 微信:drclvs
广告位:SY02 广告业务联系QQ:3173974412
无锡芯满微电子有限公司---专业研发电机驱动芯片
IC设计论坛----ictown.com
广告位:SY05 广告业务联系QQ:3173974412
查看: 717|回复: 0

[转帖] 基于时间触发混合式多任务调度器设计

[复制链接]

18

主题

18

帖子

54

E币

技术员

Rank: 2

积分
36
发表于 2017-4-1 15:35:08 | 显示全部楼层 |阅读模式
几个星期了,一直被UC/OS-III搞得焦头烂额;UC/OS-III与II不同之处很多。真正搞懂内核原理确实不易,是块硬骨头。但是本人认为那就是筋头巴脑的酱牛肉,越嚼越有味!学习之余竟然收获了时间触发混合式多任务调度器设计的方法。卧槽,爽!

       操作系统固然好,但是在对稳定性,安全,可靠性要求较高的工程中就不见得好用了。由于嵌入了操作系统导致工程代码复杂,调试程序就要花很长时间,搞不好BUG就会跳出来害人。本人坚信操作系统只能在迫不得已的情况下使用,比如手机,平板电脑等消费电子产品。下面的这个基于时间触发混合式多任务调度器已经能完成较多任务的可靠调度了。

      核心代码“多任务”.c源码部分:

#include "Time_Triggered.h"
#include "stm32f10x.h"
#include "GUI.h"
#include "gui_time.h"
#include "wave.h"

#define  RETURN_ERROR                 0x00;
#define  RETURN_NORMOL                0x01;
#define  ERROR_SCH_CANOT_DELETE_TASK  0x02;
#define  ERROR_SCH_TOO_MANY_TASKS          0x03;

tByte Error_code_G;

sTask hSCH_task_G[hSCH_MAX_TASKS]; /*建立的任务数*/
/*
*********************************************************************************************************
*        函 数 名: hSCH_Update(void)
*        功能说明: 调度器的刷新函数,每个时标中断执行一次。在嘀嗒定时器中断里面执行。
                          当刷新函数确定某个任务要执行的时候,将RunMe加1,要注意的是刷新任务
                          不执行任何函数,需要运行的任务有调度函数激活。
                          抢占式任务需要执行的话,立即就会得到执行。
*        形    参:无
*        返 回 值: 无
*********************************************************************************************************
*/
void hSCH_Update(void)
{
        tByte index;
        /*注意计数单位是时标,不是毫秒*/
        for(index = 0; index < hSCH_MAX_TASKS; index++)
        {
                if(hSCH_task_G[index].pTask)                                   /*检测这里是否有任务*/
                {
                        if(hSCH_task_G[index].Delay == 0)
                        {
                                if(hSCH_task_G[index].Co_op)    /*混合式调度和合作式调度的区分 合作式1 抢占式0*/
                                {
                                        hSCH_task_G[index].RunMe += 1;  /*合作式任务需要运行 将RunMe置1*/        
                                }        
                                else
                                {
                                        //注意:“(*hSCH_task_G[index].pTask)”是函数人口地址
                                        (*hSCH_task_G[index].pTask)();   /*抢占式任务需要立即运行 将RunMe减1*/        
                                        //hSCH_task_G[index].RunMe -= 1;
                                        if(hSCH_task_G[index].Period == 0)
                                        {                                                       /*单次执行的任务 则将其清除*/
                                                hSCH_task_G[index].pTask = 0;                                                                        
                                        }
                                }
                                if(hSCH_task_G[index].Period)
                                {                                                           /*调度周期性的任务再次执行*/
                                        hSCH_task_G[index].Delay = hSCH_task_G[index].Period;                                                                        
                                }
                        }
                        else
                        {                                                                      /*还有准备好运行*/
                                hSCH_task_G[index].Delay -= 1;                                                                                                                        
                        }
                }               
        }
}

/*
*********************************************************************************************************
*        函 数 名: hSCH_Add_Task
*        功能说明: 添加或者说创建一个任务。
*        形    参:void (*pFuntion)(void) tWord DELAY tWord PERIOD
*        返 回 值: 返回任务的ID号
*   使用说明:                                                                   0 表示是抢占式任务  1 表示是合作式任务
* (1)SCH_Add_Task(DOTASK,1000,0,1) DOTASK是函数的运行地址,1000是1000个时标以后开始运行,
       只运行一次;
*        (2)Task_ID = SCH_Add_Task(DOTASK,1000,0,1); 将任务标示符保存 以便以后删除任务
*        (3)SCH_Add_Task(DOTASK,0,1000,1); 每个1000个时标周期性的运行一次;
*********************************************************************************************************
*/
tByte hSCH_Add_Task(void (*pFuntion)(void),
                                                        tWord DELAY,
                                                        tWord PERIOD,
                                                        tByte Co_op)          /*任务合作式和抢占式的区分*/
{
        tByte index = 0; /*首先在队列中找到一个空隙,(如果有的话)*/
        
        while((hSCH_task_G[index].pTask != 0) && (index <hsch_max_tasks))[ size][="" color]
        {
                index ++;               
        }
        if(index == hSCH_MAX_TASKS)/*超过最大的任务数目 则返错误信息*/
        {
                Error_code_G = ERROR_SCH_TOO_MANY_TASKS;/*设置全局错误变量*/
                return hSCH_MAX_TASKS;        
        }
        
        hSCH_task_G[index].pTask = pFuntion;        /*运行到这里说明申请的任务块成功*/
        hSCH_task_G[index].Delay = DELAY;
        hSCH_task_G[index].Period = PERIOD;
        hSCH_task_G[index].RunMe = 0;
        hSCH_task_G[index].Co_op = Co_op;
        
        return index;                                           /*返回任务的位置,以便于以后删除*/
}
/*
*********************************************************************************************************
*        函 数 名: hSCH_Task_Delete
*        功能说明: 删除任务。就是将任务结构体各个成员全部赋值为0
*        形    参:tByte index
*        返 回 值: 是否删除成功
*********************************************************************************************************
*/
tByte hSCH_Task_Delete(tByte index)
{
        tByte Return_code;
        
        if(hSCH_task_G[index].pTask == 0)                                   /*这里没有任务*/
        {
                Error_code_G = ERROR_SCH_CANOT_DELETE_TASK;/*设置全局错误变量*/
                Return_code  = RETURN_ERROR;
        }
        else
        {
                Return_code  = RETURN_NORMOL;               
        }
        
        hSCH_task_G[index].pTask = 0x0000;
        hSCH_task_G[index].Delay = 0;
        hSCH_task_G[index].Period = 0;
        hSCH_task_G[index].RunMe =0;
        
        return Return_code;                                                /*返回状态*/
}
/*
*********************************************************************************************************
*        函 数 名: hSCH_Dispatch_Tasks
*        功能说明: 在主任务里面执行的调度函数。
*        形    参:无
*        返 回 值: 无
*********************************************************************************************************
*/
void hSCH_Dispatch_Tasks(void)
{
        tByte index;
        /*运行下一个任务,如果下一个任务准备就绪的话*/
        for(index = 0; index < hSCH_MAX_TASKS; index++)
        {
                if((hSCH_task_G[index].RunMe >0) && (hSCH_task_G[index].Co_op))        /*只调度合作式任务*/
                {
                        (*hSCH_task_G[index].pTask)();     /*执行任务 */
                        hSCH_task_G[index].RunMe -= 1;           /*执行任务完成后,将RunMe减一 ,实际上就是恢复为0 */
                        if(hSCH_task_G[index].Period == 0) /*如果是单次任务的话,则将任务删除 */
                        {
                                hSCH_Task_Delete(index);
                        }
                }
        }                        
}
/*
*********************************************************************************************************
*        函 数 名: bsp_Init
*        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
*        形    参:无
*        返 回 值: 无
*********************************************************************************************************
*/
extern void  LedTest(void);
extern void KeyTest(void);
extern void display(void);
extern void display1(void);
extern void Gui_test(void);
// GUI_TOUCH_Exec(); //定时扫描触摸屏


void sTsak_Init(void)
{
        /*
                由于ST固件库的启动文件已经执行了CPU系统时钟的初始化,所以不必再次重复配置系统时钟。
                启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。
                系统时钟缺省配置为168MHz,如果需要更改,可以修改 system_stm32f4xx.c 文件
        */
        
//        bsp_InitLed();                 /* 初始LED指示灯端口 */
//    bsp_InitUart();         /* 初始化串口 */
//        bsp_InitKey();      /* 初始化按键 */
        
         /*混合式调度和合作式调度的区分 合作式1 抢占式0*/
        /* 添加三个任务 */
        hSCH_Add_Task(LedTest, 0, 500, 1);           /* 合作式 周期10ms */
        hSCH_Add_Task( Touch_MainTask, 5000, 0, 0);        /* 抢占式 周期0ms 即只运行一次*/
        hSCH_Add_Task( Multi_MainTask, 20000, 0, 0);    /* 抢占式 周期200ms */
        hSCH_Add_Task(Gui_test, 0, 1000, 1);    /* 合作式1 周期500ms */
        hSCH_Add_Task( KeyTest, 100, 10, 1);        /* 合作式 周期4ms */
        hSCH_Add_Task(display, 0, 3000, 1);   
}

/*
    时间触发混合式任务调度器使用注意:
1,任务执行时间较长的或者当前任务在循环体执行期间别的任务就无法执行,可以通过改变中断优先级的方法
    来设计;
2,本工程中,原子delay延时函数不能用,否则会死机!
3,可以和软件定时器配合设计出复杂的多任务调度器;尝试在回调函数中运用软件定时器进行任务调度和通信;
4,时钟滴答定时器默认优先级15;
5, 实验证明,当程序进入循环体时,滴答定时器停止工作,所以基于滴答定时器的如计数,计时等等任务相当于
    休眠,等待程序走出循环体,滴答定时器才开始工作;这就是滴答定时器中断优先级最低的好处!
6,本工程中使用的中断资源:uart1,TIM3_IRQHandler,SysTick,Timer5




*/
“多任务”相应的.H 头文件:

#ifndef __TIME_TRIGGERED_H

#define __TIME_TRIGGERED_H


#define         hSCH_MAX_TASKS     10


typedef unsigned char    tByte;
typedef unsigned int     tWord;

typedef  struct
{
        void (*pTask)();                             /*指向任务的指针必须是一个*void(void)*函数;*/
        
        tWord Delay;                                       /*延时(时标)知道下一个函数的运行*/
        
        tWord Period;                                     /*连续运行之间的间隔*/
        
        tByte RunMe;                                   /*当任务需要运行的时候由调度器加1*/

    tByte Co_op;                                   /*混合式调度和合作式调度的区分 合作式1 抢占式0*/
}sTask;

void   hSCH_Update(void);
tByte  hSCH_Add_Task(void (*pFuntion)(void),
                                  tWord DELAY,
                                  tWord PERIOD,
                                  tByte Co_op);
tByte  hSCH_Task_Delete(tByte TASK_INDEX);
void   hSCH_Dispatch_Tasks(void);  
void sTsak_Init(void);
extern sTask hSCH_task_G[hSCH_MAX_TASKS];  /*建立的任务数*/

#endif


/*****************************  (END OF FILE) *********************************/
下面是软件定时器部分.C 源码:

#include "Time_Triggered.h"
#include "ILI9341.h"
#include "key.h"
#include "bsp_timer.h"
#include "stm32f10x_tim.h"
#include "stm32f10x_rcc.h"
#include "led.h"
/*
        定义用于硬件定时器的TIM, 可以使 TIM2 - TIM5
        TIM3 和TIM4 是16位
        TIM2 和TIM5 是32位
*/
#define TIM_HARD                TIM5
#define TIM_HARD_IRQn        TIM5_IRQn
#define TIM_HARD_RCC        RCC_APB1Periph_TIM5

/* 这2个全局变量转用于 bsp_DelayMS() 函数 */
static volatile uint32_t s_uiDelayCount = 0;
static volatile uint8_t s_ucTimeOutFlag = 0;

/* 定于软件定时器结构体变量 */
static SOFT_TMR s_tTmr[TMR_COUNT];

/*
        全局运行时间,单位1ms
        最长可以表示 24.85天,如果你的产品连续运行时间超过这个数,则必须考虑溢出问题
*/
__IO int32_t g_iRunTime = 0;

static void bsp_SoftTimerDec(SOFT_TMR *_tmr);

/* 保存 TIM定时中断到后执行的回调函数指针 */
static void (*s_TIM_CallBack1)(void);
static void (*s_TIM_CallBack2)(void);
static void (*s_TIM_CallBack3)(void);
static void (*s_TIM_CallBack4)(void);

/*
*********************************************************************************************************
*        函 数 名: bsp_InitTimer
*        功能说明: 配置systick中断,并初始化软件定时器变量
*        形    参:  无
*        返 回 值: 无
*********************************************************************************************************
*/
void bsp_InitTimer(void)
{
        uint8_t i;

        /* 清零所有的软件定时器 */
        for (i = 0; i < TMR_COUNT; i++)
        {
                s_tTmr.Count = 0;
                s_tTmr.PreLoad = 0;
                s_tTmr.Flag = 0;
                s_tTmr.Mode = TMR_ONCE_MODE;        /* 缺省是1次性工作模式 */
        }

        /*
                配置systic中断周期为1ms,并启动systick中断。

            SystemCoreClock 是固件中定义的系统内核时钟,对于STM32F4XX,一般为 168MHz

            SysTick_Config() 函数的形参表示内核时钟多少个周期后触发一次Systick定时中断.
                    -- SystemCoreClock / 1000  表示定时频率为 1000Hz, 也就是定时周期为  1ms
                    -- SystemCoreClock / 500   表示定时频率为 500Hz,  也就是定时周期为  2ms
                    -- SystemCoreClock / 2000  表示定时频率为 2000Hz, 也就是定时周期为  500us

            对于常规的应用,我们一般取定时周期1ms。对于低速CPU或者低功耗应用,可以设置定时周期为 10ms
    */
        SysTick_Config(SystemCoreClock / 1000);

        bsp_InitHardTimer();        /* 开启硬件定时中断 */
}
/*
*********************************************************************************************************
*        函 数 名: bsp_RunPer10ms
*        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些需要周期性处理
*                        的事务可以放在此函数。比如:按键扫描、蜂鸣器鸣叫控制等。
*        形    参:无
*        返 回 值: 无
*********************************************************************************************************
*/
//void LedTest()
//{
//         LED0=0;
//         LED1=0;
//   bsp_DelayMS(50);
//         LED0=1;
//         LED1=1;
//}
void bsp_RunPer30ms(void)
{
   if(key0()==0)
                {
                        LCD_ShowString(16 ,66,240,240,24,"hello!");
           
                  
                }
                if(key1()==1)
    {
                  LCD_Clear(WHITE);
                }

//         bsp_DelayMS(50);
//        GUI_Clear();
}

/*
*********************************************************************************************************
*        函 数 名: bsp_RunPer1ms
*        功能说明: 该函数每隔1ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些需要周期性处理的
*                        事务可以放在此函数。比如:触摸坐标扫描。
*        形    参:无
*        返 回 值: 无
*********************************************************************************************************
*/
void bsp_RunPer1ms(void)
{

}

/*
*********************************************************************************************************
*        函 数 名: SysTick_ISR
*        功能说明: SysTick中断服务程序,每隔1ms进入1次
*        形    参:  无
*        返 回 值: 无
*********************************************************************************************************
*/
//extern void bsp_RunPer1ms(void);
//extern void bsp_RunPer10ms(void);
void SysTick_ISR(void)
{
        static uint8_t s_count = 0;
        uint8_t i;

        /* 每隔1ms进来1次 (仅用于 bsp_DelayMS) */
        if (s_uiDelayCount > 0)
        {
                if (--s_uiDelayCount == 0)
                {
                        s_ucTimeOutFlag = 1;
                }
        }

        /* 每隔1ms,对软件定时器的计数器进行减一操作 */
        for (i = 0; i < TMR_COUNT; i++)
        {
                bsp_SoftTimerDec(&s_tTmr);
        }
   hSCH_Update();
        /* 全局运行时间每1ms增1 */
        g_iRunTime++;
//        if (g_iRunTime == 0x7FFFFFFF)        /* 这个变量是 int32_t 类型,最大数为 0x7FFFFFFF */
//        {
//                g_iRunTime = 0;
//        }

//        bsp_RunPer1ms();                /* 每隔1ms调用一次此函数,此函数在 bsp.c */

//        if (++s_count >= 30)
//        {
//                s_count = 0;

//                bsp_RunPer30ms();        /* 每隔10ms调用一次此函数,此函数在 bsp.c */
//        }
}

/*
*********************************************************************************************************
*        函 数 名: bsp_SoftTimerDec
*        功能说明: 每隔1ms对所有定时器变量减1。必须被SysTick_ISR周期性调用。
*        形    参:  _tmr : 定时器变量指针
*        返 回 值: 无
*********************************************************************************************************
*/
static void bsp_SoftTimerDec(SOFT_TMR *_tmr)
{
        if (_tmr->Count > 0)
        {
                /* 如果定时器变量减到1则设置定时器到达标志 */
                if (--_tmr->Count == 0)
                {
                        _tmr->Flag = 1;

                        /* 如果是自动模式,则自动重装计数器 */
                        if(_tmr->Mode == TMR_AUTO_MODE)
                        {
                                _tmr->Count = _tmr->PreLoad;
                        }
                }
        }
}

/*
*********************************************************************************************************
*        函 数 名: bsp_DelayMS
*        功能说明: ms级延迟,延迟精度为正负1ms
*        形    参:  n : 延迟长度,单位1 ms。 n 应大于2
*        返 回 值: 无
*********************************************************************************************************
*/
void bsp_DelayMS(uint32_t n)
{
        if (n == 0)
        {
                return;
        }
        else if (n == 1)
        {
                n = 2;
        }

        DISABLE_INT();                          /* 关中断 */

        s_uiDelayCount = n;
        s_ucTimeOutFlag = 0;

        ENABLE_INT();                                  /* 开中断 */

        while (1)
        {
                //bsp_Idle();                                /* CPU空闲执行的操作, 见 bsp.c 和 bsp.h 文件 */

                /*
                        等待延迟时间到
                        注意:编译器认为 s_ucTimeOutFlag = 0,所以可能优化错误,因此 s_ucTimeOutFlag 变量必须申明为 volatile
                */
                if (s_ucTimeOutFlag == 1)
                {
                        break;
                }
        }
}

/*
*********************************************************************************************************
*    函 数 名: bsp_DelayUS
*    功能说明: us级延迟。 必须在systick定时器启动后才能调用此函数。
*    形    参:  n : 延迟长度,单位1 us
*    返 回 值: 无
*********************************************************************************************************
*/
void bsp_DelayUS(uint32_t n)
{
    uint32_t ticks;
    uint32_t told;
    uint32_t tnow;
    uint32_t tcnt = 0;
    uint32_t reload;

        reload = SysTick->LOAD;
    ticks = n * (SystemCoreClock / 1000000);         /* 需要的节拍数 */

    tcnt = 0;
    told = SysTick->VAL;             /* 刚进入时的计数器值 */

    while (1)
    {
        tnow = SysTick->VAL;
        if (tnow != told)
        {
            /* SYSTICK是一个递减的计数器 */
            if (tnow < told)
            {
                tcnt += told - tnow;
            }
            /* 重新装载递减 */
            else
            {
                tcnt += reload - tnow + told;
            }
            told = tnow;

            /* 时间超过/等于要延迟的时间,则退出 */
            if (tcnt >= ticks)
            {
                    break;
            }
        }
    }
}


/*
*********************************************************************************************************
*        函 数 名: bsp_StartTimer
*        功能说明: 启动一个定时器,并设置定时周期。
*        形    参:          _id     : 定时器ID,值域【0,TMR_COUNT-1】。用户必须自行维护定时器ID,以避免定时器ID冲突。
*                                _period : 定时周期,单位1ms
*        返 回 值: 无
*********************************************************************************************************
*/
void bsp_StartTimer(uint8_t _id, uint32_t _period)
{
        if (_id >= TMR_COUNT)
        {
                /* 打印出错的源代码文件名、函数名称 */
                BSP_Printf("Error: file %s, function %s()", __FILE__, __FUNCTION__);
                while(1); /* 参数异常,死机等待看门狗复位 */
        }

        DISABLE_INT();                          /* 关中断 */

        s_tTmr[_id].Count = _period;                /* 实时计数器初值 */
        s_tTmr[_id].PreLoad = _period;                /* 计数器自动重装值,仅自动模式起作用 */
        s_tTmr[_id].Flag = 0;                                /* 定时时间到标志 */
        s_tTmr[_id].Mode = TMR_ONCE_MODE;        /* 1次性工作模式 */

        ENABLE_INT();                                  /* 开中断 */
}

/*
*********************************************************************************************************
*        函 数 名: bsp_StartAutoTimer
*        功能说明: 启动一个自动定时器,并设置定时周期。
*        形    参:          _id     : 定时器ID,值域【0,TMR_COUNT-1】。用户必须自行维护定时器ID,以避免定时器ID冲突。
*                                _period : 定时周期,单位10ms
*        返 回 值: 无
*********************************************************************************************************
*/
void bsp_StartAutoTimer(uint8_t _id, uint32_t _period)
{
        if (_id >= TMR_COUNT)
        {
                /* 打印出错的源代码文件名、函数名称 */
                BSP_Printf("Error: file %s, function %s()", __FILE__, __FUNCTION__);
                while(1); /* 参数异常,死机等待看门狗复位 */
        }

        DISABLE_INT();                  /* 关中断 */

        s_tTmr[_id].Count = _period;                        /* 实时计数器初值 */
        s_tTmr[_id].PreLoad = _period;                /* 计数器自动重装值,仅自动模式起作用 */
        s_tTmr[_id].Flag = 0;                                /* 定时时间到标志 */
        s_tTmr[_id].Mode = TMR_AUTO_MODE;        /* 自动工作模式 */

        ENABLE_INT();                          /* 开中断 */
}

/*
*********************************************************************************************************
*        函 数 名: bsp_StopTimer
*        功能说明: 停止一个定时器
*        形    参:          _id     : 定时器ID,值域【0,TMR_COUNT-1】。用户必须自行维护定时器ID,以避免定时器ID冲突。
*        返 回 值: 无
*********************************************************************************************************
*/
void bsp_StopTimer(uint8_t _id)
{
        if (_id >= TMR_COUNT)
        {
                /* 打印出错的源代码文件名、函数名称 */
                BSP_Printf("Error: file %s, function %s()", __FILE__, __FUNCTION__);
                while(1); /* 参数异常,死机等待看门狗复位 */
        }

        DISABLE_INT();          /* 关中断 */

        s_tTmr[_id].Count = 0;                                /* 实时计数器初值 */
        s_tTmr[_id].Flag = 0;                                /* 定时时间到标志 */
        s_tTmr[_id].Mode = TMR_ONCE_MODE;        /* 自动工作模式 */

        ENABLE_INT();                  /* 开中断 */
}

/*
*********************************************************************************************************
*        函 数 名: bsp_CheckTimer
*        功能说明: 检测定时器是否超时
*        形    参:          _id     : 定时器ID,值域【0,TMR_COUNT-1】。用户必须自行维护定时器ID,以避免定时器ID冲突。
*                                _period : 定时周期,单位1ms
*        返 回 值: 返回 0 表示定时未到, 1表示定时到
*********************************************************************************************************
*/
uint8_t bsp_CheckTimer(uint8_t _id)
{
        if (_id >= TMR_COUNT)
        {
                return 0;
        }

        if (s_tTmr[_id].Flag == 1)
        {
                s_tTmr[_id].Flag = 0;
                return 1;
        }
        else
        {
                return 0;
        }
}

/*
*********************************************************************************************************
*        函 数 名: bsp_GetRunTime
*        功能说明: 获取CPU运行时间,单位1ms。最长可以表示 24.85天,如果你的产品连续运行时间超过这个数,则必须考虑溢出问题
*        形    参:  无
*        返 回 值: CPU运行时间,单位1ms
*********************************************************************************************************
*/
int32_t bsp_GetRunTime(void)
{
        int32_t runtime;

        DISABLE_INT();          /* 关中断 */

        runtime = g_iRunTime;        /* 这个变量在Systick中断中被改写,因此需要关中断进行保护 */

        ENABLE_INT();                  /* 开中断 */

        return runtime;
}

/*
*********************************************************************************************************
*        函 数 名: SysTick_Handler
*        功能说明: 系统嘀嗒定时器中断服务程序。启动文件中引用了该函数。
*        形    参:  无
*        返 回 值: 无
*********************************************************************************************************
*/
void SysTick_Handler(void)
{
        SysTick_ISR();
}

/*
*********************************************************************************************************
*        函 数 名: bsp_InitHardTimer
*        功能说明: 配置 TIM4,用于us级别硬件定时。TIM4将自由运行,永不停止.
*                        TIM4可以用TIM2 - TIM5 之间的TIM, 这些TIM有4个通道, 挂在 APB1 上,输入时钟=SystemCoreClock / 2
*        形    参: 无
*        返 回 值: 无
*********************************************************************************************************
*/
void bsp_InitHardTimer(void)
{
        TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
        uint16_t usPeriod;
        uint16_t usPrescaler;
        uint32_t uiTIMxCLK;

          /* 使能TIM时钟 */
        RCC_APB1PeriphClockCmd(TIM_HARD_RCC, ENABLE);

    /*-----------------------------------------------------------------------
                system_stm32f4xx.c 文件中 void SetSysClock(void) 函数对时钟的配置如下:

                HCLK = SYSCLK / 1     (AHB1Periph)
                PCLK2 = HCLK / 2      (APB2Periph)
                PCLK1 = HCLK / 4      (APB1Periph)

                因为APB1 prescaler != 1, 所以 APB1上的TIMxCLK = PCLK1 x 2 = SystemCoreClock / 2;
                因为APB2 prescaler != 1, 所以 APB2上的TIMxCLK = PCLK2 x 2 = SystemCoreClock;

                APB1 定时器有 TIM2, TIM3 ,TIM4, TIM5, TIM6, TIM7, TIM12, TIM13,TIM14
                APB2 定时器有 TIM1, TIM8 ,TIM9, TIM10, TIM11

        ----------------------------------------------------------------------- */
        uiTIMxCLK = SystemCoreClock / 2;

        usPrescaler = uiTIMxCLK / 1000000 ;        /* 分频到周期 1us */
        usPeriod = 0xFFFF;

        /* Time base configuration */
        TIM_TimeBaseStructure.TIM_Period = usPeriod;
        TIM_TimeBaseStructure.TIM_Prescaler = usPrescaler;
        TIM_TimeBaseStructure.TIM_ClockDivision = 0;
        TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

        TIM_TimeBaseInit(TIM_HARD, &TIM_TimeBaseStructure);

        //TIM_ARRPreloadConfig(TIMx, ENABLE);

        /* TIMx enable counter */
        TIM_Cmd(TIM_HARD, ENABLE);

        /* 配置TIM定时中断 (Update) */
        {
                NVIC_InitTypeDef NVIC_InitStructure;        /* 中断结构体在 misc.h 中定义 */

                NVIC_InitStructure.NVIC_IRQChannel = TIM_HARD_IRQn;

                NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;        /* 比串口优先级低 */
                NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
                NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
                NVIC_Init(&NVIC_InitStructure);
        }
}

/*
*********************************************************************************************************
*        函 数 名: bsp_StartHardTimer
*        功能说明: 使用TIM2-5做单次定时器使用, 定时时间到后执行回调函数。可以同时启动4个定时器,互不干扰。
*             定时精度正负10us (主要耗费在调用本函数的执行时间,函数内部进行了补偿减小误差)
*                         TIM2和TIM5 是32位定时器。定时范围很大
*                         TIM3和TIM4 是16位定时器。
*        形    参: _CC : 捕获通道几,1,2,3, 4
*             _uiTimeOut : 超时时间, 单位 1us.       对于16位定时器,最大 65.5ms; 对于32位定时器,最大 4294秒
*             _pCallBack : 定时时间到后,被执行的函数
*        返 回 值: 无
*********************************************************************************************************
*/
void bsp_StartHardTimer(uint8_t _CC, uint32_t _uiTimeOut, void * _pCallBack)
{
    uint32_t cnt_now;
    uint32_t cnt_tar;

    /*
        执行下面这个语句,时长 = 18us (通过逻辑分析仪测量IO翻转)
        bsp_StartTimer2(3, 500, (void *)test1);
    */
    if (_uiTimeOut < 5)
    {
        ;
    }
    else
    {
        _uiTimeOut -= 5;
    }

    cnt_now = TIM_GetCounter(TIM_HARD);            /* 读取当前的计数器值 */
    cnt_tar = cnt_now + _uiTimeOut;                        /* 计算捕获的计数器值 */
    if (_CC == 1)
    {
        s_TIM_CallBack1 = (void (*)(void))_pCallBack;

        TIM_SetCompare1(TIM_HARD, cnt_tar);              /* 设置捕获比较计数器CC1 */
        TIM_ClearITPendingBit(TIM_HARD, TIM_IT_CC1);
                TIM_ITConfig(TIM_HARD, TIM_IT_CC1, ENABLE);        /* 使能CC1中断 */

    }
    else if (_CC == 2)
    {
                s_TIM_CallBack2 = (void (*)(void))_pCallBack;

        TIM_SetCompare2(TIM_HARD, cnt_tar);              /* 设置捕获比较计数器CC2 */
                TIM_ClearITPendingBit(TIM_HARD, TIM_IT_CC2);
                TIM_ITConfig(TIM_HARD, TIM_IT_CC2, ENABLE);        /* 使能CC2中断 */
    }
    else if (_CC == 3)
    {
        s_TIM_CallBack3 = (void (*)(void))_pCallBack;

        TIM_SetCompare3(TIM_HARD, cnt_tar);              /* 设置捕获比较计数器CC3 */
        TIM_ClearITPendingBit(TIM_HARD, TIM_IT_CC3);
                TIM_ITConfig(TIM_HARD, TIM_IT_CC3, ENABLE);        /* 使能CC3中断 */
    }
    else if (_CC == 4)
    {
        s_TIM_CallBack4 = (void (*)(void))_pCallBack;

        TIM_SetCompare4(TIM_HARD, cnt_tar);              /* 设置捕获比较计数器CC4 */
                TIM_ClearITPendingBit(TIM_HARD, TIM_IT_CC4);
                TIM_ITConfig(TIM_HARD, TIM_IT_CC4, ENABLE);        /* 使能CC4中断 */
    }
        else
    {
        return;
    }
}

/*
*********************************************************************************************************
*        函 数 名: TIMx_IRQHandler
*        功能说明: TIM 中断服务程序
*        形    参:无
*        返 回 值: 无
*********************************************************************************************************
*/
//void TIM2_IRQHandler(void)
//void TIM3_IRQHandler(void)
//void TIM4_IRQHandler(void)
void TIM5_IRQHandler(void)
{
    if (TIM_GetITStatus(TIM_HARD, TIM_IT_CC1))
    {
        TIM_ClearITPendingBit(TIM_HARD, TIM_IT_CC1);
        TIM_ITConfig(TIM_HARD, TIM_IT_CC1, DISABLE);        /* 禁能CC1中断 */

        /* 先关闭中断,再执行回调函数。因为回调函数可能需要重启定时器 */
        s_TIM_CallBack1();
    }

    if (TIM_GetITStatus(TIM_HARD, TIM_IT_CC2))
    {
        TIM_ClearITPendingBit(TIM_HARD, TIM_IT_CC2);
        TIM_ITConfig(TIM_HARD, TIM_IT_CC2, DISABLE);        /* 禁能CC2中断 */

        /* 先关闭中断,再执行回调函数。因为回调函数可能需要重启定时器 */
        s_TIM_CallBack2();
    }

    if (TIM_GetITStatus(TIM_HARD, TIM_IT_CC3))
    {
        TIM_ClearITPendingBit(TIM_HARD, TIM_IT_CC3);
        TIM_ITConfig(TIM_HARD, TIM_IT_CC3, DISABLE);        /* 禁能CC3中断 */

        /* 先关闭中断,再执行回调函数。因为回调函数可能需要重启定时器 */
        s_TIM_CallBack3();
    }

    if (TIM_GetITStatus(TIM_HARD, TIM_IT_CC4))
    {
        TIM_ClearITPendingBit(TIM_HARD, TIM_IT_CC4);
        TIM_ITConfig(TIM_HARD, TIM_IT_CC4, DISABLE);        /* 禁能CC4中断 */

        /* 先关闭中断,再执行回调函数。因为回调函数可能需要重启定时器 */
        s_TIM_CallBack4();
    }
}
//void bsp_Init(void)
//{
//        /*
//                由于ST固件库的启动文件已经执行了CPU系统时钟的初始化,所以不必再次重复配置系统时钟。
//                启动文件配置了CPU主时钟频率、内部Flash访问速度和可选的外部SRAM FSMC初始化。

//                系统时钟缺省配置为168MHz,如果需要更改,可以修改 system_stm32f4xx.c 文件
//        */

//        //bsp_InitUart();         /* 初始化串口 */
////        bsp_InitTimer();        /* 初始化系统滴答定时器 */

//        /* 针对不同的应用程序,添加需要的底层驱动模块初始化函数 */

//        //bsp_InitLed();                 /* 初始LED指示灯端口 */
//}


/*
*********************************************************************************************************
*        函 数 名: bsp_Idle
*        功能说明: 空闲时执行的函数。一般主程序在for和while循环程序体中需要插入 CPU_IDLE() 宏来调用本函数。
*                         本函数缺省为空操作。用户可以添加喂狗、设置CPU进入休眠模式的功能。
*        形    参:无
*        返 回 值: 无
*********************************************************************************************************
*/
//void bsp_Idle(void)
//{
//        /* --- 喂狗 */

//        /* --- 让CPU进入休眠,由Systick定时中断唤醒或者其他中断唤醒 */

//        /* 对于 emWin 图形库,可以插入图形库需要的轮询函数 */
//        //GUI_Exec();

//        /* 对于 uIP 协议实现,可以插入uip轮询函数 */
//}

软件定时器相应的.H 头文件:
#ifndef __BSP_TIMER_H
#define __BSP_TIMER_H
#include "bsp_timer.h"

/* 开关全局中断的宏 */
#define ENABLE_INT()        __set_PRIMASK(0)        /* 使能全局中断 */
#define DISABLE_INT()        __set_PRIMASK(1)        /* 禁止全局中断 */

/* 这个宏仅用于调试阶段排错 */
#define BSP_Printf                printf
//#define BSP_Printf(...)

#include "stm32f10x.h"
#include
#include
#include

#ifndef TRUE
        #define TRUE  1
#endif

#ifndef FALSE
        #define FALSE 0
#endif
/*
        在此定义若干个软件定时器全局变量
        注意,必须增加__IO 即 volatile,因为这个变量在中断和主程序中同时被访问,有可能造成编译器错误优化。
*/
#define TMR_COUNT        4                /* 软件定时器的个数 (定时器ID范围 0 - 3) */

/* 定时器结构体,成员变量必须是 volatile, 否则C编译器优化时可能有问题 */
typedef enum
{
        TMR_ONCE_MODE = 0,                /* 一次工作模式 */
        TMR_AUTO_MODE = 1                /* 自动定时工作模式 */
}TMR_MODE_E;

/* 定时器结构体,成员变量必须是 volatile, 否则C编译器优化时可能有问题 */
typedef struct
{
        volatile u8 Mode;                /* 计数器模式,1次性 */
        volatile u8 Flag;                /* 定时到达标志  */
        volatile u32 Count;        /* 计数器 */
        volatile u32 PreLoad;        /* 计数器预装值 */
}SOFT_TMR;

/* 提供给其他C文件调用的函数 */
void bsp_InitTimer(void);
void bsp_DelayMS(uint32_t n);
void bsp_DelayUS(uint32_t n);
void bsp_StartTimer(uint8_t _id, uint32_t _period);
void bsp_StartAutoTimer(uint8_t _id, uint32_t _period);
void bsp_StopTimer(uint8_t _id);
uint8_t bsp_CheckTimer(uint8_t _id);
int32_t bsp_GetRunTime(void);

void bsp_InitHardTimer(void);
void bsp_StartHardTimer(uint8_t _CC, uint32_t _uiTimeOut, void * _pCallBack);

#endif



/*
        
*/


/* 通过取消注释或者添加注释的方式控制是否包含底层驱动模块 */

/*****************************   (END OF FILE) *********************************/
积分规则
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则



版权所有:EDABOSS论坛 投诉受理:13816911948 合作热线:13816911948

备案信息:苏经营性ICP B2-20090218号 皖ICP备09697823号 电子公告服务许可文件号:皖通[2009]556号

Powered by EDABOSS X3.4 Tamplate By EDABOSS论坛  © 2001-2013 Comsenz Inc.

广告投放 微信:drclvs

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