打印
[抢楼250]

菜地公告:即日起创建《菜农Cortex-M0助学园地》(盖楼入口)

[复制链接]
楼主: hotpower
手机看帖
扫描二维码
随时随地手机跟帖
5901
再补一个:lol

使用特权

评论回复
5902
hotpower|  楼主 | 2011-12-2 16:04 | 只看该作者
李老师授课
用户数据长度不够4字节的,可以扩展到4字节,就可以使用邮箱传递了,但要考虑效率问题,4字节的数据,效率是100%,2字节的数据,效率只有50%,单字节的数据,效率只有25%。
大于4字节的数据,一般不采用直接传递数据本身,而是把数据的地址(指针)作为消息来传递。
也可以采用拆分数据的方法,把大数据分成小块从邮箱传递,但这种方法需要考虑多方面的问题,如抢断、邮箱满等情况。
对于消息数据的类型来说,由于传统的邮箱发送和接收函数只能接受固定的数据类型(一般是void*),所以用户的数据类型,需要在本身的类型和固定类型之间强制转换(发送时强制为void*,接收时强制回用户类型),这样做,除了麻烦外,也是一种隐患。
而look由于是基于c++的RTOS,比较容易地解决了这个问题,mbox_t设计为模板类,用户的消息类型需要在邮箱创建时,以模板参数的形式给出,并且消息的发送和接收函数,也会只接受这种用户类型的消息,这就避免了传统的强制的方法,不仅优雅,而且是类型安全的。
下面具体说下mbox_t的使用方法:
首先要创建邮箱实例,上面说了,需要给出用户消息类型和邮箱容量作为创建时的模板参数,语法形式为:
mbox_t<用户消息类型,邮箱容量> 邮箱实例名;
使用邮箱发送和接收消息,有一个限制:不允许在调度器尚未运转之前,这些地方位于:
1、构造函数,当创建全局对象时。
2、LOOK_HWINIT()函数。
发送消息使用mbox_t::put()函数,put()函数的原型为:
bool put(T msg, uintptr_t timeout = 0);
T是用户消息类型,msg是消息实体,timeout是超时限制。
put()函数还有其他几种形式:
bool tryput(T msg);
非阻塞地发送消息。
bool tryput_front(T msg);
非阻塞地以lifo方式发送消息。
bool put_front(T msg, uintptr_t timeout = 0);
以lifo方式发送消息。
bool do_tryput(T msg);
在调度器已锁定的情况下,发送消息,没有阻塞。
bool do_tryput_front(T msg);
在调度器已锁定的情况下,以lifo方式发送消息,没有阻塞。


使用特权

评论回复
5903
hotpower|  楼主 | 2011-12-2 17:41 | 只看该作者
下午测试了15个look的最基本应用的例程。

使用特权

评论回复
5904
5251| | 2011-12-2 18:56 | 只看该作者
签到

使用特权

评论回复
5905
murex| | 2011-12-2 21:08 | 只看该作者
:lol晚上有空了来盖下楼

使用特权

评论回复
5906
老鱼探戈| | 2011-12-2 22:45 | 只看该作者
盖楼。。。。

使用特权

评论回复
5907
hotpower|  楼主 | 2011-12-3 00:48 | 只看该作者
加紧盖楼,LOOK革命教育即将开始

使用特权

评论回复
5908
hotpower|  楼主 | 2011-12-3 00:53 | 只看该作者
目前楼差为1681

使用特权

评论回复
5910
hotpower|  楼主 | 2011-12-3 01:24 | 只看该作者
忘了,不知LOOK的缔造者李老师是否也是俺色诱所为???

菜地公告:TinyThread的缔造者将被菜农色诱入群!

使用特权

评论回复
5911
hotpower|  楼主 | 2011-12-3 01:29 | 只看该作者
delay.cpp
#include "Look_delay.h"
#include "utils/debug.h"
#include "numicro/sfr/gpio"

instance_task1_Look_delay_t task1_Look_delay(1);        // 任务实例

// 任务类 task1_Look_delay_t 的例程
__DEBUG//debug调试不优化便于调试
void task1_Look_delay_t::routine()
{
        // TODO: 在此编写例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写例程的内容
                GPIOA.DOUT().DOUT3(1)//LED2灭
                            .DOUT2(0);//LED1亮
                delay(LOOK_TICKS_PER_SEC / 2);//暂时放弃控制权给Task2
                GPIOA.DOUT().DOUT2 = 1;//LED1灭
                delay(LOOK_TICKS_PER_SEC / 2);//暂时放弃控制权给Task2
        }
}

instance_task2_Look_delay_t task2_Look_delay(2);        // 任务实例

// 任务类 task2_Look_delay_t 的例程
__DEBUG//debug调试不优化便于调试
void task2_Look_delay_t::routine()
{
        // TODO: 在此编写例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写例程的内容
                GPIOA.DOUT().DOUT3 = 0;//LED2亮
//由于Task1任务级别高,故Task2不可能独占CPU,将会被Task1抢占
                for(int i = 0; i < 0x250000; i++) asm volatile("nop");//独占CPU
        }
}

使用特权

评论回复
5912
hotpower|  楼主 | 2011-12-3 01:30 | 只看该作者
yield.cpp
#include "Look_yield.h"
#include "utils/debug.h"
#include "numicro/sfr/gpio"

instance_task1_Look_yield_t task1_Look_yield;        // 任务实例

// 任务类 task1_Look_yield_t 的例程
__DEBUG//debug调试不优化便于调试
void task1_Look_yield_t::routine()
{
        // TODO: 在此编写例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写例程的内容
                GPIOA.DOUT().DOUT3(1)//LED2灭
                            .DOUT2(0);//LED1亮
                for(int i = 0; i < 0x25000; i++) asm volatile("nop");//独占CPU
                scheduler.yield();
        }
}

instance_task2_Look_yield_t task2_Look_yield;        // 任务实例

// 任务类 task2_Look_yield_t 的例程
__DEBUG//debug调试不优化便于调试
void task2_Look_yield_t::routine()
{
        // TODO: 在此编写例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写例程的内容
                GPIOA.DOUT().DOUT2(1)//LED1灭
                            .DOUT3(0);//LED2亮
                for(int i = 0; i < 0x25000; i++) asm volatile("nop");//独占CPU
                scheduler.yield();
        }
}

使用特权

评论回复
5913
hotpower|  楼主 | 2011-12-3 01:31 | 只看该作者
timer.cpp
#include "Look_timer.h"
#include "utils/debug.h"
#include "numicro/sfr/gpio"

instance_task_Look_timer_t task_Look_timer;        // 任务实例

// 任务类 task_Look_timer_t 的例程
void task_Look_timer_t::routine()
{
        // TODO: 在此编写例程的内容
        using namespace sfr::gpio;
        timer1.start(interval1);//启动定时器1
        timer2.start(interval2);//启动定时器1
        while (true) {
                // TODO: 在此编写例程的内容
                GPIOA.DOUT().DOUT2(t1)//LED1
                            .DOUT3(t2);//LED2
                delay(LOOK_TICKS_PER_SEC / 1000);
        }
}

void task_Look_timer_t::on_signal(void* addr, uintptr_t signal)
{
        using namespace sfr::gpio;
        if (addr == &timer1) {
                //处理定时器事务
                t1 = !t1;
                timer1.do_start(interval1);//重置定时器
        }
        else if (addr == &timer2) {
                //处理定时器事务
                timer2.do_start(interval2);//重置定时器
                t2 = !t2;
        }
        else {
                task_t::on_signal(addr, signal);
        }

}

使用特权

评论回复
5914
hotpower|  楼主 | 2011-12-3 01:32 | 只看该作者
idle.cpp
#include "Look_idle.h"
#include "utils/debug.h"
#include "numicro/sfr/gpio"

flag_t Flag(0);//初始化

// eint_t 类提供了 INT0/INT1 的接口
// 当 INT0/INT1 发生时,对象将发送相应的 int 消息到 mbox。
class eint_t : public interrupt_t {
public:
        __INLINE eint_t();

protected:
        bool isr(int vector);
        void dsr(int vector, uintptr_t count);
};

// eint 构造函数
__DEBUG//debug调试不优化便于调试
__INLINE eint_t::eint_t()
{
        using namespace sfr::gpio;
        attach(EINT0_IRQn);//绑定外部中断0
        attach(EINT1_IRQn);//绑定外部中断1
        GPIOB.IEN(0).IF_EN15(1).IF_EN14(1);//开启Key1,Key2中断
        vector_t::enable(EINT0_IRQn);//使能外部中断0即Key1中断
        vector_t::enable(EINT1_IRQn);//使能外部中断1即Key2中断
}

// eint 中断服务例程
__DEBUG//debug调试不优化便于调试
bool eint_t::isr(int vector)
{
        using namespace sfr::gpio;
        GPIOB.ISRC = GPIOB.ISRC;                        // 清中断 flag
        return true;
}

// eint 中断滞后服务例程
__DEBUG//debug调试不优化便于调试
void eint_t::dsr(int vector, uintptr_t count)
{
        using namespace sfr::gpio;
        if (vector == EINT0_IRQn)//Key2中断
        {
                Flag.do_set_bits(2);//在中断中唤醒任务2
        }
        else if (vector == EINT1_IRQn)//Key1中断
        {
                Flag.do_set_bits(1);//在中断中唤醒任务1
        }
}

eint_t eint;                                                                        // 创建 eint 对象

instance_task1_Look_idle_t task1_Look_idle(1);        // 任务实例

// 任务类 task1_Look_idle_t 的例程
void task1_Look_idle_t::routine()
{
        // TODO: 在此编写 task1_Look_idle_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task1_Look_idle_t 例程的内容
                int flag = Flag.wait(1, flag_t::ANY_CONSUME);//阻塞等待Key1中断
                if (flag)
                {
                        GPIOA.DOUT().DOUT2 = 0;//LED1亮
                        delay(LOOK_TICKS_PER_SEC / 2);
                        GPIOA.DOUT().DOUT2 = 1;//LED1灭
                }
        }
}

instance_task2_Look_idle_t task2_Look_idle(2);        // 任务实例

// 任务类 task2_Look_idle_t 的例程
void task2_Look_idle_t::routine()
{
        // TODO: 在此编写 task2_Look_idle_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task2_Look_idle_t 例程的内容
                int flag = Flag.wait(2, flag_t::ANY_CONSUME);//阻塞等待Key2中断
                if (flag)
                {
                        GPIOA.DOUT().DOUT3 = 0;//LED2亮
                        delay(LOOK_TICKS_PER_SEC / 2);
                        GPIOA.DOUT().DOUT3 = 1;//LED2灭
                }
        }
}

使用特权

评论回复
5915
hotpower|  楼主 | 2011-12-3 01:33 | 只看该作者
flag.cpp
#include "Look_flag.h"
#include "utils/debug.h"
#include "numicro/sfr/gpio"

flag_t Flag(0);//初始化

// eint_t 类提供了 INT0/INT1 的接口
// 当 INT0/INT1 发生时,对象将发送相应的 int 消息到 mbox。
class eint_t : public interrupt_t {
public:
        __INLINE eint_t();

protected:
        bool isr(int vector);
        void dsr(int vector, uintptr_t count);
};

// eint 构造函数
__DEBUG//debug调试不优化便于调试
__INLINE eint_t::eint_t()
{
        using namespace sfr::gpio;
        attach(EINT0_IRQn);//绑定外部中断0
        attach(EINT1_IRQn);//绑定外部中断1
        GPIOB.IEN(0).IF_EN15(1).IF_EN14(1);//开启Key1,Key2中断
        vector_t::enable(EINT0_IRQn);//使能外部中断0即Key1中断
        vector_t::enable(EINT1_IRQn);//使能外部中断1即Key2中断
}

// eint 中断服务例程
__DEBUG//debug调试不优化便于调试
bool eint_t::isr(int vector)
{
        using namespace sfr::gpio;
        GPIOB.ISRC = GPIOB.ISRC;                        // 清中断 flag
        return true;
}

// eint 中断滞后服务例程
__DEBUG//debug调试不优化便于调试
void eint_t::dsr(int vector, uintptr_t count)
{
        using namespace sfr::gpio;
        if (vector == EINT0_IRQn)//Key2中断
        {
                Flag.do_set_bits(2);//在中断中唤醒任务2
        }
        else if (vector == EINT1_IRQn)//Key1中断
        {
                Flag.do_set_bits(1);//在中断中唤醒任务1
        }
}

eint_t eint;                                                                        // 创建 eint 对象

instance_task1_Look_flag_t task1_Look_flag(1);        // 任务实例,优化级别1

// 任务类 task1_Look_flag_t 的例程
__DEBUG
void task1_Look_flag_t::routine()
{
        // TODO: 在此编写 task1_Look_flag_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task1_Look_flag_t 例程的内容
                int flag = Flag.wait(1, flag_t::ANY_CONSUME);//阻塞等待Key1中断
                if (flag)
                {
                        GPIOA.DOUT().DOUT2 ^= 1;//LED1闪烁
                        Flag.set_bits(4);//在任务中唤醒任务3
                }
        }
}

instance_task2_Look_flag_t task2_Look_flag(2);        // 任务实例,优化级别2

// 任务类 task2_Look_flag_t 的例程
__DEBUG//debug调试不优化便于调试
void task2_Look_flag_t::routine()
{
        // TODO: 在此编写 task2_Look_flag_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task2_Look_flag_t 例程的内容
                int flag = Flag.wait(2, flag_t::ANY_CONSUME);//阻塞等待Key2中断
                if (flag)
                {
                        GPIOA.DOUT().DOUT3 ^= 1;//LED2闪烁
                        Flag.set_bits(4);//在任务中唤醒任务3
                }
        }
}

instance_task3_Look_flag_t task3_Look_flag(0);        // 任务实例,优化级别0

// 任务类 task2_Look_flag_t 的例程
__DEBUG//debug调试不优化便于调试
void task3_Look_flag_t::routine()
{
        // TODO: 在此编写 task2_Look_flag_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task3_Look_flag_t 例程的内容
                int flag = Flag.wait(4, flag_t::ANY_CONSUME);
                if (flag)
                {
                        GPIOA.DOUT().DOUT4(0).DOUT5(0);//LED3,LED4亮
                        delay(LOOK_TICKS_PER_SEC / 2);//延时亮0.5S
                        GPIOA.DOUT().DOUT4(1).DOUT5(1);//LED3,LED4灭
                }
        }
}

使用特权

评论回复
5916
hotpower|  楼主 | 2011-12-3 01:34 | 只看该作者
sem.cpp
#include "Look_sem.h"
#include "utils/debug.h"
#include "numicro/sfr/gpio"

sem_t Sem = 1;//Sem > 0 Sem.wait()任务可以直接获取信号量

instance_task1_Look_sem_t task1_Look_sem(1);        // 任务实例

// 任务类 task1_Look_sem_t 的例程
void task1_Look_sem_t::routine()
{
        // TODO: 在此编写 task1_Look_sem_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task1_Look_sem_t 例程的内容
                if (Sem.wait())//等待获取信号量,Sem > 0直接获取,Sem = 0阻塞等待
                {//任务1独占信号量2S,此时Sem-- = Sem = 0,阻止任务2获取信号量
                        GPIOA.DOUT().DOUT2(0).DOUT3(0);//LED1,LED2亮
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        GPIOA.DOUT().DOUT2(1).DOUT3(1);//LED1,LED2灭
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        Sem.post();//独占2S后释放信号量,任务2可以获取信号量,Sem++ = Sem = 1
                }
        }
}

instance_task2_Look_sem_t task2_Look_sem(2);        // 任务实例

// 任务类 task2_Look_sem_t 的例程
void task2_Look_sem_t::routine()
{
        // TODO: 在此编写 task2_Look_sem_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task2_Look_sem_t 例程的内容
                if (Sem.wait())//等待获取信号量,Sem > 0直接获取,Sem = 0阻塞等待
                {//任务1独占信号量2S,此时Sem-- = Sem = 0,阻止任务2获取信号量
                        GPIOA.DOUT().DOUT4(0).DOUT5(0);//LED3,LED4亮
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        GPIOA.DOUT().DOUT4(1).DOUT5(1);//LED3,LED4灭
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        Sem.post();//独占2S后释放信号量,任务1可以获取信号量,Sem++ = Sem = 1
                }
        }
}

使用特权

评论回复
5917
hotpower|  楼主 | 2011-12-3 01:35 | 只看该作者
sem_key.cpp
#include "Look_sem_key.h"
#include "utils/debug.h"
#include "numicro/sfr/gpio"
sem_t Sem1 = 0;//Sem1.wait()任务1直接阻塞
sem_t Sem2 = 0;//Sem2.wait()任务2直接阻塞

// eint_t 类提供了 INT0/INT1 的接口
// 当 INT0/INT1 发生时,对象将发送相应的 int 消息到 mbox。
class eint_t : public interrupt_t {
public:
        __INLINE eint_t();

protected:
        bool isr(int vector);
        void dsr(int vector, uintptr_t count);
};

// eint 构造函数
__DEBUG//debug调试不优化便于调试
__INLINE eint_t::eint_t()
{
        using namespace sfr::gpio;
        attach(EINT0_IRQn);//绑定外部中断0
        attach(EINT1_IRQn);//绑定外部中断1
        GPIOB.IEN(0).IF_EN15(1).IF_EN14(1);//开启Key1,Key2中断
        vector_t::enable(EINT0_IRQn);//使能外部中断0即Key1中断
        vector_t::enable(EINT1_IRQn);//使能外部中断1即Key2中断
}

// eint 中断服务例程
__DEBUG//debug调试不优化便于调试
bool eint_t::isr(int vector)
{
        using namespace sfr::gpio;
        GPIOB.ISRC = GPIOB.ISRC;//清中断flag
        return true;
}

// eint 中断滞后服务例程
__DEBUG//debug调试不优化便于调试
void eint_t::dsr(int vector, uintptr_t count)
{
        using namespace sfr::gpio;
        if (vector == EINT0_IRQn)//Key2中断
        {//Key2按几次,LED3,LED4闪烁几次
                Sem2.do_post();//在中断中唤醒任务2,Sem2++>0
        }
        else if (vector == EINT1_IRQn)//Key1中断
        {//Key1按几次,LED1,LED2闪烁几次
                Sem1.do_post();//在中断中唤醒任务1,Sem1++>0
        }
}

eint_t eint;                                                                        // 创建 eint 对象

instance_task1_Look_sem_key_t task1_Look_sem_key(1);        // 任务实例

// 任务类 task1_Look_sem_key_t 的例程
void task1_Look_sem_key_t::routine()
{
        // TODO: 在此编写 task1_Look_sem_key_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task1_Look_sem_key_t 例程的内容
                if (Sem1.wait())//Sem1=0阻塞等待获取信号量
                {//注意此时Key1释放信号量Sem1++>0
                        GPIOA.DOUT().DOUT2(0).DOUT3(0);//LED1,LED2亮
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        GPIOA.DOUT().DOUT2(1).DOUT3(1);//LED1,LED2灭
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                }
        }
}


instance_task2_Look_sem_key_t task2_Look_sem_key(2);        // 任务实例

// 任务类 task2_Look_sem_key_t 的例程
void task2_Look_sem_key_t::routine()
{
        // TODO: 在此编写 task2_Look_sem_key_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task2_Look_sem_key_t 例程的内容
                if (Sem2.wait())//Sem2=0阻塞等待获取信号量
                {//注意此时Key2释放信号量Sem2++>0
                        GPIOA.DOUT().DOUT4(0).DOUT5(0);//LED3,LED4亮
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        GPIOA.DOUT().DOUT4(1).DOUT5(1);//LED3,LED4灭
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                }
        }
}

使用特权

评论回复
5918
hotpower|  楼主 | 2011-12-3 01:36 | 只看该作者
mutex.cpp
#include "Look_mutex.h"
#include "utils/debug.h"
#include "numicro/sfr/gpio"

mutex_t Mutex;

instance_task1_Look_mutex_t task1_Look_mutex(1);        // 任务实例

// 任务类 task1_Look_mutex_t 的例程
void task1_Look_mutex_t::routine()
{
        // TODO: 在此编写 task1_Look_mutex_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task1_Look_mutex_t 例程的内容
                if (Mutex.lock())
                {
                        GPIOA.DOUT().DOUT2(0).DOUT3(0);//LED1,LED2亮
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        GPIOA.DOUT().DOUT2(1).DOUT3(1);//LED1,LED2灭
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        Mutex.unlock();
                }
        }
}

instance_task2_Look_mutex_t task2_Look_mutex(2);        // 任务实例

// 任务类 task1_Look_mutex_t 的例程
void task2_Look_mutex_t::routine()
{
        // TODO: 在此编写 task2_Look_mutex_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task2_Look_mutex_t 例程的内容
                if (Mutex.lock())
                {
                        GPIOA.DOUT().DOUT4(0).DOUT5(0);//LED3,LED4亮
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        GPIOA.DOUT().DOUT4(1).DOUT5(1);//LED3,LED4灭
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        Mutex.unlock();
                }
        }
}

使用特权

评论回复
5919
hotpower|  楼主 | 2011-12-3 01:36 | 只看该作者
mutex.cpp
#include "Look_mutex.h"
#include "utils/debug.h"
#include "numicro/sfr/gpio"

mutex_t Mutex;

instance_task1_Look_mutex_t task1_Look_mutex(1);        // 任务实例

// 任务类 task1_Look_mutex_t 的例程
void task1_Look_mutex_t::routine()
{
        // TODO: 在此编写 task1_Look_mutex_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task1_Look_mutex_t 例程的内容
                if (Mutex.lock())
                {
                        GPIOA.DOUT().DOUT2(0).DOUT3(0);//LED1,LED2亮
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        GPIOA.DOUT().DOUT2(1).DOUT3(1);//LED1,LED2灭
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        Mutex.unlock();
                }
        }
}

instance_task2_Look_mutex_t task2_Look_mutex(2);        // 任务实例

// 任务类 task1_Look_mutex_t 的例程
void task2_Look_mutex_t::routine()
{
        // TODO: 在此编写 task2_Look_mutex_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task2_Look_mutex_t 例程的内容
                if (Mutex.lock())
                {
                        GPIOA.DOUT().DOUT4(0).DOUT5(0);//LED3,LED4亮
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        GPIOA.DOUT().DOUT4(1).DOUT5(1);//LED3,LED4灭
                        delay(LOOK_TICKS_PER_SEC);//延时亮1S
                        Mutex.unlock();
                }
        }
}

使用特权

评论回复
5920
hotpower|  楼主 | 2011-12-3 01:37 | 只看该作者
mbox.cpp
#include "Look_mbox.h"
#include "utils/debug.h"
#include "numicro/sfr/gpio"

mbox_t<int, 1> Mbox1;// 创建 int 型邮箱
mbox_t<int, 1> Mbox2;// 创建 int 型邮箱
mbox_t<int, 1> Mbox3;// 创建 int 型邮箱

// eint_t 类提供了 INT0/INT1 的接口
// 当 INT0/INT1 发生时,对象将发送相应的 int 消息到 mbox。
class eint_t : public interrupt_t {
public:
        __INLINE eint_t();

protected:
        bool isr(int vector);
        void dsr(int vector, uintptr_t count);
};

// eint 构造函数
__DEBUG//debug调试不优化便于调试
__INLINE eint_t::eint_t()
{
        using namespace sfr::gpio;
        attach(EINT0_IRQn);//绑定外部中断0
        attach(EINT1_IRQn);//绑定外部中断1
        GPIOB.IEN(0).IF_EN15(1).IF_EN14(1);//开启Key1,Key2中断
        vector_t::enable(EINT0_IRQn);//使能外部中断0即Key1中断
        vector_t::enable(EINT1_IRQn);//使能外部中断1即Key2中断
}

// eint 中断服务例程
__DEBUG//debug调试不优化便于调试
bool eint_t::isr(int vector)
{
        using namespace sfr::gpio;
        GPIOB.ISRC = GPIOB.ISRC;                        // 清中断 flag
        return true;
}

// eint 中断滞后服务例程
__DEBUG//debug调试不优化便于调试
void eint_t::dsr(int vector, uintptr_t count)
{
        using namespace sfr::gpio;
        if (vector == EINT0_IRQn)//Key2中断
        {
                Mbox2.do_tryput(1);//在中断中唤醒任务2
        }
        else if (vector == EINT1_IRQn)//Key1中断
        {
                Mbox1.do_tryput(0);//在中断中唤醒任务1
        }
}

eint_t eint;                                                                        // 创建 eint 对象

instance_task1_Look_mbox_t task1_Look_mbox(1);        // 任务实例

// 任务类 task1_Look_mbox_t 的例程
__DEBUG//debug调试不优化便于调试
void task1_Look_mbox_t::routine()
{
        // TODO: 在此编写 task1_Look_mbox_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task1_Look_mbox_t 例程的内容
                int mbox;
                if (Mbox1.get(mbox))//阻塞等待Key1中断发送消息
                {
                        if (mbox == 0)
                        {
                                GPIOA.DOUT().DOUT2 ^= 1;//LED1闪烁
                                Mbox3.tryput(10);//在任务1中唤醒任务3,LED3闪烁
                        }
                }
        }
}


instance_task2_Look_mbox_t task2_Look_mbox(2);        // 任务实例

// 任务类 task2_Look_mbox_t 的例程
__DEBUG//debug调试不优化便于调试
void task2_Look_mbox_t::routine()
{
        // TODO: 在此编写 task2_Look_mbox_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task2_Look_mbox_t 例程的内容
                int msg;
                if (Mbox2.get(msg))//阻塞等待Key1中断发送消息
                {
                        if (msg == 1)
                        {
                                GPIOA.DOUT().DOUT3 ^= 1;//LED2闪烁
                                Mbox3.tryput(11);//在任务2中唤醒任务3,LED4闪烁
                        }
                }
        }
}

instance_task3_Look_mbox_t task3_Look_mbox(0);        // 任务实例

// 任务类 task2_Look_mbox_t 的例程
__DEBUG//debug调试不优化便于调试
void task3_Look_mbox_t::routine()
{
        // TODO: 在此编写 task3_Look_mbox_t 例程的内容
        using namespace sfr::gpio;
        while (true) {
                // TODO: 在此编写 task3_Look_mbox_t 例程的内容
                int msg;
                if (Mbox3.get(msg))//阻塞等待任务1或任务2发送消息
                {
                        if (msg == 10)//Task1任务发送消息
                        {
                                GPIOA.DOUT().DOUT4(0);//LED3亮
                                delay(LOOK_TICKS_PER_SEC / 2);//延时亮0.5S
                                GPIOA.DOUT().DOUT4(1);//LED3灭
                        }
                        else if (msg == 11)//Task2任务发送消息
                        {
                                GPIOA.DOUT().DOUT5(0);//LED4亮
                                delay(LOOK_TICKS_PER_SEC / 2);//延时亮0.5S
                                GPIOA.DOUT().DOUT5(1);//LED4灭
                        }
                }
        }
}

使用特权

评论回复
发新帖 我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则