21ic电子技术开发论坛 › 已关闭版块 › Cortex-M0助学园地 › 菜地公告：即日起创建《菜农Cortex-M0助学园地》(盖楼 ...
1 ...292293294295296297298299... 937下一页
返回列表 发新帖我要提问

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

[复制链接]
998019|18727
lixiaoxu2meng 发表于 2011-12-2 10:23 | 显示全部楼层
再补一个:lol
回复

收藏1 举报

 楼主| 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方式发送消息，没有阻塞。

回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-2 17:41 | 显示全部楼层
下午测试了15个look的最基本应用的例程。
回复

收藏1 举报

5251 发表于 2011-12-2 18:56 | 显示全部楼层
签到
回复

收藏1 举报

murex 发表于 2011-12-2 21:08 | 显示全部楼层
:lol晚上有空了来盖下楼
回复

收藏1 举报

老鱼探戈 发表于 2011-12-2 22:45 | 显示全部楼层
盖楼。。。。
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 00:48 | 显示全部楼层
加紧盖楼，LOOK革命教育即将开始
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 00:53 | 显示全部楼层
目前楼差为1681
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:21 | 显示全部楼层
菜农助学开发板电路原理图

菜农自贺“单总线硬件控制器”被某大公司申请专利成功

通用异步串口实现单总线硬件控制器的研究和实现方法(菜农)

通用异步串口实现单总线硬件控制器的研究和实现方法(菜农)

菜农群课：讨论原理图及讲授《单总线硬件控制器》

基于 LOOK 系统的助学板 DS18B20 示例

CN(菜鸟)之250助学板-->玩玩1820，就是爽啊...
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:24 | 显示全部楼层
忘了，不知LOOK的缔造者李老师是否也是俺色诱所为？？？

菜地公告：TinyThread的缔造者将被菜农色诱入群！
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:29 | 显示全部楼层
delay.cpp
复制
  1. #include "Look_delay.h"
    

  2. #include "utils/debug.h"
    

  3. #include "numicro/sfr/gpio"
    


  4. 

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


  6. 

  7. // 任务类 task1_Look_delay_t 的例程
    

  8. __DEBUG//debug调试不优化便于调试 
    

  9. void task1_Look_delay_t::routine()
    

  10. {
    

  11.         // TODO: 在此编写例程的内容
    

  12.         using namespace sfr::gpio;
    

  13.         while (true) {
    

  14.                 // TODO: 在此编写例程的内容
    

  15.                 GPIOA.DOUT().DOUT3(1)//LED2灭
    

  16.                             .DOUT2(0);//LED1亮
    

  17.                 delay(LOOK_TICKS_PER_SEC / 2);//暂时放弃控制权给Task2
    

  18.                 GPIOA.DOUT().DOUT2 = 1;//LED1灭
    

  19.                 delay(LOOK_TICKS_PER_SEC / 2);//暂时放弃控制权给Task2
    

  20.         }
    

  21. }
    


  22. 

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


  24. 

  25. // 任务类 task2_Look_delay_t 的例程
    

  26. __DEBUG//debug调试不优化便于调试 
    

  27. void task2_Look_delay_t::routine()
    

  28. {
    

  29.         // TODO: 在此编写例程的内容
    

  30.         using namespace sfr::gpio;
    

  31.         while (true) {
    

  32.                 // TODO: 在此编写例程的内容
    

  33.                 GPIOA.DOUT().DOUT3 = 0;//LED2亮
    

  34. //由于Task1任务级别高，故Task2不可能独占CPU，将会被Task1抢占
    

  35.                 for(int i = 0; i < 0x250000; i++) asm volatile("nop");//独占CPU
    

  36.         }
    

  37. }
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:30 | 显示全部楼层
yield.cpp
复制
  1. #include "Look_yield.h"
    

  2. #include "utils/debug.h"
    

  3. #include "numicro/sfr/gpio"
    


  4. 

  5. instance_task1_Look_yield_t task1_Look_yield;        // 任务实例
    


  6. 

  7. // 任务类 task1_Look_yield_t 的例程
    

  8. __DEBUG//debug调试不优化便于调试 
    

  9. void task1_Look_yield_t::routine()
    

  10. {
    

  11.         // TODO: 在此编写例程的内容
    

  12.         using namespace sfr::gpio;
    

  13.         while (true) {
    

  14.                 // TODO: 在此编写例程的内容
    

  15.                 GPIOA.DOUT().DOUT3(1)//LED2灭
    

  16.                             .DOUT2(0);//LED1亮
    

  17.                 for(int i = 0; i < 0x25000; i++) asm volatile("nop");//独占CPU
    

  18.                 scheduler.yield();
    

  19.         }
    

  20. }
    


  21. 

  22. instance_task2_Look_yield_t task2_Look_yield;        // 任务实例
    


  23. 

  24. // 任务类 task2_Look_yield_t 的例程
    

  25. __DEBUG//debug调试不优化便于调试 
    

  26. void task2_Look_yield_t::routine()
    

  27. {
    

  28.         // TODO: 在此编写例程的内容
    

  29.         using namespace sfr::gpio;
    

  30.         while (true) {
    

  31.                 // TODO: 在此编写例程的内容
    

  32.                 GPIOA.DOUT().DOUT2(1)//LED1灭
    

  33.                             .DOUT3(0);//LED2亮
    

  34.                 for(int i = 0; i < 0x25000; i++) asm volatile("nop");//独占CPU
    

  35.                 scheduler.yield();
    

  36.         }
    

  37. }
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:31 | 显示全部楼层
timer.cpp
复制
  1. #include "Look_timer.h"
    

  2. #include "utils/debug.h"
    

  3. #include "numicro/sfr/gpio"
    


  4. 

  5. instance_task_Look_timer_t task_Look_timer;        // 任务实例
    


  6. 

  7. // 任务类 task_Look_timer_t 的例程
    

  8. void task_Look_timer_t::routine()
    

  9. {
    

  10.         // TODO: 在此编写例程的内容
    

  11.         using namespace sfr::gpio;
    

  12.         timer1.start(interval1);//启动定时器1
    

  13.         timer2.start(interval2);//启动定时器1
    

  14.         while (true) {
    

  15.                 // TODO: 在此编写例程的内容
    

  16.                 GPIOA.DOUT().DOUT2(t1)//LED1
    

  17.                             .DOUT3(t2);//LED2
    

  18.                 delay(LOOK_TICKS_PER_SEC / 1000);
    

  19.         }
    

  20. }
    


  21. 

  22. void task_Look_timer_t::on_signal(void* addr, uintptr_t signal)
    

  23. {
    

  24.         using namespace sfr::gpio;
    

  25.         if (addr == &timer1) {
    

  26.                 //处理定时器事务
    

  27.                 t1 = !t1;
    

  28.                 timer1.do_start(interval1);//重置定时器
    

  29.         }
    

  30.         else if (addr == &timer2) {
    

  31.                 //处理定时器事务
    

  32.                 timer2.do_start(interval2);//重置定时器
    

  33.                 t2 = !t2;
    

  34.         }
    

  35.         else {
    

  36.                 task_t::on_signal(addr, signal);
    

  37.         }
    


  38. 

  39. }
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:32 | 显示全部楼层
idle.cpp
复制
  1. #include "Look_idle.h"
    

  2. #include "utils/debug.h"
    

  3. #include "numicro/sfr/gpio"
    


  4. 

  5. flag_t Flag(0);//初始化
    


  6. 

  7. // eint_t 类提供了 INT0/INT1 的接口
    

  8. // 当 INT0/INT1 发生时，对象将发送相应的 int 消息到 mbox。
    

  9. class eint_t : public interrupt_t {
    

  10. public:
    

  11.         __INLINE eint_t();
    


  12. 

  13. protected:
    

  14.         bool isr(int vector);
    

  15.         void dsr(int vector, uintptr_t count);
    

  16. };
    


  17. 

  18. // eint 构造函数
    

  19. __DEBUG//debug调试不优化便于调试 
    

  20. __INLINE eint_t::eint_t()
    

  21. {
    

  22.         using namespace sfr::gpio;
    

  23.         attach(EINT0_IRQn);//绑定外部中断0
    

  24.         attach(EINT1_IRQn);//绑定外部中断1
    

  25.         GPIOB.IEN(0).IF_EN15(1).IF_EN14(1);//开启Key1,Key2中断
    

  26.         vector_t::enable(EINT0_IRQn);//使能外部中断0即Key1中断
    

  27.         vector_t::enable(EINT1_IRQn);//使能外部中断1即Key2中断
    

  28. }
    


  29. 

  30. // eint 中断服务例程
    

  31. __DEBUG//debug调试不优化便于调试 
    

  32. bool eint_t::isr(int vector)
    

  33. {
    

  34.         using namespace sfr::gpio;
    

  35.         GPIOB.ISRC = GPIOB.ISRC;                        // 清中断 flag
    

  36.         return true;
    

  37. }
    


  38. 

  39. // eint 中断滞后服务例程
    

  40. __DEBUG//debug调试不优化便于调试 
    

  41. void eint_t::dsr(int vector, uintptr_t count)
    

  42. {
    

  43.         using namespace sfr::gpio;
    

  44.         if (vector == EINT0_IRQn)//Key2中断
    

  45.         {
    

  46.                 Flag.do_set_bits(2);//在中断中唤醒任务2
    

  47.         }
    

  48.         else if (vector == EINT1_IRQn)//Key1中断
    

  49.         {
    

  50.                 Flag.do_set_bits(1);//在中断中唤醒任务1
    

  51.         }
    

  52. }
    


  53. 

  54. eint_t eint;                                                                        // 创建 eint 对象
    


  55. 

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


  57. 

  58. // 任务类 task1_Look_idle_t 的例程
    

  59. void task1_Look_idle_t::routine()
    

  60. {
    

  61.         // TODO: 在此编写 task1_Look_idle_t 例程的内容
    

  62.         using namespace sfr::gpio;
    

  63.         while (true) {
    

  64.                 // TODO: 在此编写 task1_Look_idle_t 例程的内容
    

  65.                 int flag = Flag.wait(1, flag_t::ANY_CONSUME);//阻塞等待Key1中断
    

  66.                 if (flag)
    

  67.                 {
    

  68.                         GPIOA.DOUT().DOUT2 = 0;//LED1亮
    

  69.                         delay(LOOK_TICKS_PER_SEC / 2);
    

  70.                         GPIOA.DOUT().DOUT2 = 1;//LED1灭
    

  71.                 }
    

  72.         }
    

  73. }
    


  74. 

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


  76. 

  77. // 任务类 task2_Look_idle_t 的例程
    

  78. void task2_Look_idle_t::routine()
    

  79. {
    

  80.         // TODO: 在此编写 task2_Look_idle_t 例程的内容
    

  81.         using namespace sfr::gpio;
    

  82.         while (true) {
    

  83.                 // TODO: 在此编写 task2_Look_idle_t 例程的内容
    

  84.                 int flag = Flag.wait(2, flag_t::ANY_CONSUME);//阻塞等待Key2中断
    

  85.                 if (flag)
    

  86.                 {
    

  87.                         GPIOA.DOUT().DOUT3 = 0;//LED2亮
    

  88.                         delay(LOOK_TICKS_PER_SEC / 2);
    

  89.                         GPIOA.DOUT().DOUT3 = 1;//LED2灭
    

  90.                 }
    

  91.         }
    

  92. }
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:33 | 显示全部楼层
flag.cpp
复制
  1. #include "Look_flag.h"
    

  2. #include "utils/debug.h"
    

  3. #include "numicro/sfr/gpio"
    


  4. 

  5. flag_t Flag(0);//初始化
    


  6. 

  7. // eint_t 类提供了 INT0/INT1 的接口
    

  8. // 当 INT0/INT1 发生时，对象将发送相应的 int 消息到 mbox。
    

  9. class eint_t : public interrupt_t {
    

  10. public:
    

  11.         __INLINE eint_t();
    


  12. 

  13. protected:
    

  14.         bool isr(int vector);
    

  15.         void dsr(int vector, uintptr_t count);
    

  16. };
    


  17. 

  18. // eint 构造函数
    

  19. __DEBUG//debug调试不优化便于调试 
    

  20. __INLINE eint_t::eint_t()
    

  21. {
    

  22.         using namespace sfr::gpio;
    

  23.         attach(EINT0_IRQn);//绑定外部中断0
    

  24.         attach(EINT1_IRQn);//绑定外部中断1
    

  25.         GPIOB.IEN(0).IF_EN15(1).IF_EN14(1);//开启Key1,Key2中断
    

  26.         vector_t::enable(EINT0_IRQn);//使能外部中断0即Key1中断
    

  27.         vector_t::enable(EINT1_IRQn);//使能外部中断1即Key2中断
    

  28. }
    


  29. 

  30. // eint 中断服务例程
    

  31. __DEBUG//debug调试不优化便于调试 
    

  32. bool eint_t::isr(int vector)
    

  33. {
    

  34.         using namespace sfr::gpio;
    

  35.         GPIOB.ISRC = GPIOB.ISRC;                        // 清中断 flag
    

  36.         return true;
    

  37. }
    


  38. 

  39. // eint 中断滞后服务例程
    

  40. __DEBUG//debug调试不优化便于调试 
    

  41. void eint_t::dsr(int vector, uintptr_t count)
    

  42. {
    

  43.         using namespace sfr::gpio;
    

  44.         if (vector == EINT0_IRQn)//Key2中断
    

  45.         {
    

  46.                 Flag.do_set_bits(2);//在中断中唤醒任务2
    

  47.         }
    

  48.         else if (vector == EINT1_IRQn)//Key1中断
    

  49.         {
    

  50.                 Flag.do_set_bits(1);//在中断中唤醒任务1
    

  51.         }
    

  52. }
    


  53. 

  54. eint_t eint;                                                                        // 创建 eint 对象
    


  55. 

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


  57. 

  58. // 任务类 task1_Look_flag_t 的例程
    

  59. __DEBUG 
    

  60. void task1_Look_flag_t::routine()
    

  61. {
    

  62.         // TODO: 在此编写 task1_Look_flag_t 例程的内容
    

  63.         using namespace sfr::gpio;
    

  64.         while (true) {
    

  65.                 // TODO: 在此编写 task1_Look_flag_t 例程的内容
    

  66.                 int flag = Flag.wait(1, flag_t::ANY_CONSUME);//阻塞等待Key1中断
    

  67.                 if (flag)
    

  68.                 {
    

  69.                         GPIOA.DOUT().DOUT2 ^= 1;//LED1闪烁
    

  70.                         Flag.set_bits(4);//在任务中唤醒任务3
    

  71.                 }
    

  72.         }
    

  73. }
    


  74. 

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


  76. 

  77. // 任务类 task2_Look_flag_t 的例程
    

  78. __DEBUG//debug调试不优化便于调试 
    

  79. void task2_Look_flag_t::routine()
    

  80. {
    

  81.         // TODO: 在此编写 task2_Look_flag_t 例程的内容
    

  82.         using namespace sfr::gpio;
    

  83.         while (true) {
    

  84.                 // TODO: 在此编写 task2_Look_flag_t 例程的内容
    

  85.                 int flag = Flag.wait(2, flag_t::ANY_CONSUME);//阻塞等待Key2中断
    

  86.                 if (flag)
    

  87.                 {
    

  88.                         GPIOA.DOUT().DOUT3 ^= 1;//LED2闪烁
    

  89.                         Flag.set_bits(4);//在任务中唤醒任务3
    

  90.                 }
    

  91.         }
    

  92. }
    


  93. 

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


  95. 

  96. // 任务类 task2_Look_flag_t 的例程
    

  97. __DEBUG//debug调试不优化便于调试 
    

  98. void task3_Look_flag_t::routine()
    

  99. {
    

  100.         // TODO: 在此编写 task2_Look_flag_t 例程的内容
    

  101.         using namespace sfr::gpio;
    

  102.         while (true) {
    

  103.                 // TODO: 在此编写 task3_Look_flag_t 例程的内容
    

  104.                 int flag = Flag.wait(4, flag_t::ANY_CONSUME);
    

  105.                 if (flag)
    

  106.                 {
    

  107.                         GPIOA.DOUT().DOUT4(0).DOUT5(0);//LED3,LED4亮
    

  108.                         delay(LOOK_TICKS_PER_SEC / 2);//延时亮0.5S
    

  109.                         GPIOA.DOUT().DOUT4(1).DOUT5(1);//LED3,LED4灭
    

  110.                 }
    

  111.         }
    

  112. }
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:34 | 显示全部楼层
sem.cpp
复制
  1. #include "Look_sem.h"
    

  2. #include "utils/debug.h"
    

  3. #include "numicro/sfr/gpio"
    


  4. 

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


  6. 

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


  8. 

  9. // 任务类 task1_Look_sem_t 的例程
    

  10. void task1_Look_sem_t::routine()
    

  11. {
    

  12.         // TODO: 在此编写 task1_Look_sem_t 例程的内容
    

  13.         using namespace sfr::gpio;
    

  14.         while (true) {
    

  15.                 // TODO: 在此编写 task1_Look_sem_t 例程的内容
    

  16.                 if (Sem.wait())//等待获取信号量,Sem > 0直接获取,Sem = 0阻塞等待
    

  17.                 {//任务1独占信号量2S,此时Sem-- = Sem = 0,阻止任务2获取信号量
    

  18.                         GPIOA.DOUT().DOUT2(0).DOUT3(0);//LED1,LED2亮
    

  19.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  20.                         GPIOA.DOUT().DOUT2(1).DOUT3(1);//LED1,LED2灭
    

  21.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  22.                         Sem.post();//独占2S后释放信号量，任务2可以获取信号量，Sem++ = Sem = 1
    

  23.                 }
    

  24.         }
    

  25. }
    


  26. 

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


  28. 

  29. // 任务类 task2_Look_sem_t 的例程
    

  30. void task2_Look_sem_t::routine()
    

  31. {
    

  32.         // TODO: 在此编写 task2_Look_sem_t 例程的内容
    

  33.         using namespace sfr::gpio;
    

  34.         while (true) {
    

  35.                 // TODO: 在此编写 task2_Look_sem_t 例程的内容
    

  36.                 if (Sem.wait())//等待获取信号量,Sem > 0直接获取,Sem = 0阻塞等待
    

  37.                 {//任务1独占信号量2S,此时Sem-- = Sem = 0,阻止任务2获取信号量
    

  38.                         GPIOA.DOUT().DOUT4(0).DOUT5(0);//LED3,LED4亮
    

  39.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  40.                         GPIOA.DOUT().DOUT4(1).DOUT5(1);//LED3,LED4灭
    

  41.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  42.                         Sem.post();//独占2S后释放信号量，任务1可以获取信号量，Sem++ = Sem = 1
    

  43.                 }
    

  44.         }
    

  45. }
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:35 | 显示全部楼层
sem_key.cpp
复制
  1. #include "Look_sem_key.h"
    

  2. #include "utils/debug.h"
    

  3. #include "numicro/sfr/gpio"
    

  4. sem_t Sem1 = 0;//Sem1.wait()任务1直接阻塞
    

  5. sem_t Sem2 = 0;//Sem2.wait()任务2直接阻塞
    


  6. 

  7. // eint_t 类提供了 INT0/INT1 的接口
    

  8. // 当 INT0/INT1 发生时，对象将发送相应的 int 消息到 mbox。
    

  9. class eint_t : public interrupt_t {
    

  10. public:
    

  11.         __INLINE eint_t();
    


  12. 

  13. protected:
    

  14.         bool isr(int vector);
    

  15.         void dsr(int vector, uintptr_t count);
    

  16. };
    


  17. 

  18. // eint 构造函数
    

  19. __DEBUG//debug调试不优化便于调试 
    

  20. __INLINE eint_t::eint_t()
    

  21. {
    

  22.         using namespace sfr::gpio;
    

  23.         attach(EINT0_IRQn);//绑定外部中断0
    

  24.         attach(EINT1_IRQn);//绑定外部中断1
    

  25.         GPIOB.IEN(0).IF_EN15(1).IF_EN14(1);//开启Key1,Key2中断
    

  26.         vector_t::enable(EINT0_IRQn);//使能外部中断0即Key1中断
    

  27.         vector_t::enable(EINT1_IRQn);//使能外部中断1即Key2中断
    

  28. }
    


  29. 

  30. // eint 中断服务例程
    

  31. __DEBUG//debug调试不优化便于调试 
    

  32. bool eint_t::isr(int vector)
    

  33. {
    

  34.         using namespace sfr::gpio;
    

  35.         GPIOB.ISRC = GPIOB.ISRC;//清中断flag
    

  36.         return true;
    

  37. }
    


  38. 

  39. // eint 中断滞后服务例程
    

  40. __DEBUG//debug调试不优化便于调试 
    

  41. void eint_t::dsr(int vector, uintptr_t count)
    

  42. {
    

  43.         using namespace sfr::gpio;
    

  44.         if (vector == EINT0_IRQn)//Key2中断
    

  45.         {//Key2按几次，LED3,LED4闪烁几次
    

  46.                 Sem2.do_post();//在中断中唤醒任务2,Sem2++>0
    

  47.         }
    

  48.         else if (vector == EINT1_IRQn)//Key1中断
    

  49.         {//Key1按几次，LED1,LED2闪烁几次
    

  50.                 Sem1.do_post();//在中断中唤醒任务1,Sem1++>0
    

  51.         }
    

  52. }
    


  53. 

  54. eint_t eint;                                                                        // 创建 eint 对象
    


  55. 

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


  57. 

  58. // 任务类 task1_Look_sem_key_t 的例程
    

  59. void task1_Look_sem_key_t::routine()
    

  60. {
    

  61.         // TODO: 在此编写 task1_Look_sem_key_t 例程的内容
    

  62.         using namespace sfr::gpio;
    

  63.         while (true) {
    

  64.                 // TODO: 在此编写 task1_Look_sem_key_t 例程的内容
    

  65.                 if (Sem1.wait())//Sem1=0阻塞等待获取信号量
    

  66.                 {//注意此时Key1释放信号量Sem1++>0
    

  67.                         GPIOA.DOUT().DOUT2(0).DOUT3(0);//LED1,LED2亮
    

  68.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  69.                         GPIOA.DOUT().DOUT2(1).DOUT3(1);//LED1,LED2灭
    

  70.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  71.                 }
    

  72.         }
    

  73. }
    


  74. 


  75. 

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


  77. 

  78. // 任务类 task2_Look_sem_key_t 的例程
    

  79. void task2_Look_sem_key_t::routine()
    

  80. {
    

  81.         // TODO: 在此编写 task2_Look_sem_key_t 例程的内容
    

  82.         using namespace sfr::gpio;
    

  83.         while (true) {
    

  84.                 // TODO: 在此编写 task2_Look_sem_key_t 例程的内容
    

  85.                 if (Sem2.wait())//Sem2=0阻塞等待获取信号量
    

  86.                 {//注意此时Key2释放信号量Sem2++>0
    

  87.                         GPIOA.DOUT().DOUT4(0).DOUT5(0);//LED3,LED4亮
    

  88.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  89.                         GPIOA.DOUT().DOUT4(1).DOUT5(1);//LED3,LED4灭
    

  90.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  91.                 }
    

  92.         }
    

  93. }
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:36 | 显示全部楼层
mutex.cpp
复制
  1. #include "Look_mutex.h"
    

  2. #include "utils/debug.h"
    

  3. #include "numicro/sfr/gpio"
    


  4. 

  5. mutex_t Mutex;
    


  6. 

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


  8. 

  9. // 任务类 task1_Look_mutex_t 的例程
    

  10. void task1_Look_mutex_t::routine()
    

  11. {
    

  12.         // TODO: 在此编写 task1_Look_mutex_t 例程的内容
    

  13.         using namespace sfr::gpio;
    

  14.         while (true) {
    

  15.                 // TODO: 在此编写 task1_Look_mutex_t 例程的内容
    

  16.                 if (Mutex.lock())
    

  17.                 {
    

  18.                         GPIOA.DOUT().DOUT2(0).DOUT3(0);//LED1,LED2亮
    

  19.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  20.                         GPIOA.DOUT().DOUT2(1).DOUT3(1);//LED1,LED2灭
    

  21.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  22.                         Mutex.unlock();
    

  23.                 }
    

  24.         }
    

  25. }
    


  26. 

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


  28. 

  29. // 任务类 task1_Look_mutex_t 的例程
    

  30. void task2_Look_mutex_t::routine()
    

  31. {
    

  32.         // TODO: 在此编写 task2_Look_mutex_t 例程的内容
    

  33.         using namespace sfr::gpio;
    

  34.         while (true) {
    

  35.                 // TODO: 在此编写 task2_Look_mutex_t 例程的内容
    

  36.                 if (Mutex.lock())
    

  37.                 {
    

  38.                         GPIOA.DOUT().DOUT4(0).DOUT5(0);//LED3,LED4亮
    

  39.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  40.                         GPIOA.DOUT().DOUT4(1).DOUT5(1);//LED3,LED4灭
    

  41.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  42.                         Mutex.unlock();
    

  43.                 }
    

  44.         }
    

  45. }
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:36 | 显示全部楼层
mutex.cpp
复制
  1. #include "Look_mutex.h"
    

  2. #include "utils/debug.h"
    

  3. #include "numicro/sfr/gpio"
    


  4. 

  5. mutex_t Mutex;
    


  6. 

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


  8. 

  9. // 任务类 task1_Look_mutex_t 的例程
    

  10. void task1_Look_mutex_t::routine()
    

  11. {
    

  12.         // TODO: 在此编写 task1_Look_mutex_t 例程的内容
    

  13.         using namespace sfr::gpio;
    

  14.         while (true) {
    

  15.                 // TODO: 在此编写 task1_Look_mutex_t 例程的内容
    

  16.                 if (Mutex.lock())
    

  17.                 {
    

  18.                         GPIOA.DOUT().DOUT2(0).DOUT3(0);//LED1,LED2亮
    

  19.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  20.                         GPIOA.DOUT().DOUT2(1).DOUT3(1);//LED1,LED2灭
    

  21.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  22.                         Mutex.unlock();
    

  23.                 }
    

  24.         }
    

  25. }
    


  26. 

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


  28. 

  29. // 任务类 task1_Look_mutex_t 的例程
    

  30. void task2_Look_mutex_t::routine()
    

  31. {
    

  32.         // TODO: 在此编写 task2_Look_mutex_t 例程的内容
    

  33.         using namespace sfr::gpio;
    

  34.         while (true) {
    

  35.                 // TODO: 在此编写 task2_Look_mutex_t 例程的内容
    

  36.                 if (Mutex.lock())
    

  37.                 {
    

  38.                         GPIOA.DOUT().DOUT4(0).DOUT5(0);//LED3,LED4亮
    

  39.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  40.                         GPIOA.DOUT().DOUT4(1).DOUT5(1);//LED3,LED4灭
    

  41.                         delay(LOOK_TICKS_PER_SEC);//延时亮1S
    

  42.                         Mutex.unlock();
    

  43.                 }
    

  44.         }
    

  45. }
回复

收藏1 举报

 楼主| hotpower 发表于 2011-12-3 01:37 | 显示全部楼层
mbox.cpp
复制
  1. #include "Look_mbox.h"
    

  2. #include "utils/debug.h"
    

  3. #include "numicro/sfr/gpio"
    


  4. 

  5. mbox_t<int, 1> Mbox1;// 创建 int 型邮箱
    

  6. mbox_t<int, 1> Mbox2;// 创建 int 型邮箱
    

  7. mbox_t<int, 1> Mbox3;// 创建 int 型邮箱
    


  8. 

  9. // eint_t 类提供了 INT0/INT1 的接口
    

  10. // 当 INT0/INT1 发生时，对象将发送相应的 int 消息到 mbox。
    

  11. class eint_t : public interrupt_t {
    

  12. public:
    

  13.         __INLINE eint_t();
    


  14. 

  15. protected:
    

  16.         bool isr(int vector);
    

  17.         void dsr(int vector, uintptr_t count);
    

  18. };
    


  19. 

  20. // eint 构造函数
    

  21. __DEBUG//debug调试不优化便于调试 
    

  22. __INLINE eint_t::eint_t()
    

  23. {
    

  24.         using namespace sfr::gpio;
    

  25.         attach(EINT0_IRQn);//绑定外部中断0
    

  26.         attach(EINT1_IRQn);//绑定外部中断1
    

  27.         GPIOB.IEN(0).IF_EN15(1).IF_EN14(1);//开启Key1,Key2中断
    

  28.         vector_t::enable(EINT0_IRQn);//使能外部中断0即Key1中断
    

  29.         vector_t::enable(EINT1_IRQn);//使能外部中断1即Key2中断
    

  30. }
    


  31. 

  32. // eint 中断服务例程
    

  33. __DEBUG//debug调试不优化便于调试 
    

  34. bool eint_t::isr(int vector)
    

  35. {
    

  36.         using namespace sfr::gpio;
    

  37.         GPIOB.ISRC = GPIOB.ISRC;                        // 清中断 flag
    

  38.         return true;
    

  39. }
    


  40. 

  41. // eint 中断滞后服务例程
    

  42. __DEBUG//debug调试不优化便于调试 
    

  43. void eint_t::dsr(int vector, uintptr_t count)
    

  44. {
    

  45.         using namespace sfr::gpio;
    

  46.         if (vector == EINT0_IRQn)//Key2中断
    

  47.         {
    

  48.                 Mbox2.do_tryput(1);//在中断中唤醒任务2
    

  49.         }
    

  50.         else if (vector == EINT1_IRQn)//Key1中断
    

  51.         {
    

  52.                 Mbox1.do_tryput(0);//在中断中唤醒任务1
    

  53.         }
    

  54. }
    


  55. 

  56. eint_t eint;                                                                        // 创建 eint 对象
    


  57. 

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


  59. 

  60. // 任务类 task1_Look_mbox_t 的例程
    

  61. __DEBUG//debug调试不优化便于调试 
    

  62. void task1_Look_mbox_t::routine()
    

  63. {
    

  64.         // TODO: 在此编写 task1_Look_mbox_t 例程的内容
    

  65.         using namespace sfr::gpio;
    

  66.         while (true) {
    

  67.                 // TODO: 在此编写 task1_Look_mbox_t 例程的内容
    

  68.                 int mbox;
    

  69.                 if (Mbox1.get(mbox))//阻塞等待Key1中断发送消息
    

  70.                 {
    

  71.                         if (mbox == 0)
    

  72.                         {
    

  73.                                 GPIOA.DOUT().DOUT2 ^= 1;//LED1闪烁
    

  74.                                 Mbox3.tryput(10);//在任务1中唤醒任务3，LED3闪烁
    

  75.                         }
    

  76.                 }
    

  77.         }
    

  78. }
    


  79. 


  80. 

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


  82. 

  83. // 任务类 task2_Look_mbox_t 的例程
    

  84. __DEBUG//debug调试不优化便于调试 
    

  85. void task2_Look_mbox_t::routine()
    

  86. {
    

  87.         // TODO: 在此编写 task2_Look_mbox_t 例程的内容
    

  88.         using namespace sfr::gpio;
    

  89.         while (true) {
    

  90.                 // TODO: 在此编写 task2_Look_mbox_t 例程的内容
    

  91.                 int msg;
    

  92.                 if (Mbox2.get(msg))//阻塞等待Key1中断发送消息
    

  93.                 {
    

  94.                         if (msg == 1)
    

  95.                         {
    

  96.                                 GPIOA.DOUT().DOUT3 ^= 1;//LED2闪烁
    

  97.                                 Mbox3.tryput(11);//在任务2中唤醒任务3，LED4闪烁
    

  98.                         }
    

  99.                 }
    

  100.         }
    

  101. }
    


  102. 

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


  104. 

  105. // 任务类 task2_Look_mbox_t 的例程
    

  106. __DEBUG//debug调试不优化便于调试 
    

  107. void task3_Look_mbox_t::routine()
    

  108. {
    

  109.         // TODO: 在此编写 task3_Look_mbox_t 例程的内容
    

  110.         using namespace sfr::gpio;
    

  111.         while (true) {
    

  112.                 // TODO: 在此编写 task3_Look_mbox_t 例程的内容
    

  113.                 int msg;
    

  114.                 if (Mbox3.get(msg))//阻塞等待任务1或任务2发送消息
    

  115.                 {
    

  116.                         if (msg == 10)//Task1任务发送消息
    

  117.                         {
    

  118.                                 GPIOA.DOUT().DOUT4(0);//LED3亮
    

  119.                                 delay(LOOK_TICKS_PER_SEC / 2);//延时亮0.5S
    

  120.                                 GPIOA.DOUT().DOUT4(1);//LED3灭
    

  121.                         }
    

  122.                         else if (msg == 11)//Task2任务发送消息
    

  123.                         {
    

  124.                                 GPIOA.DOUT().DOUT5(0);//LED4亮
    

  125.                                 delay(LOOK_TICKS_PER_SEC / 2);//延时亮0.5S
    

  126.                                 GPIOA.DOUT().DOUT5(1);//LED4灭
    

  127.                         }
    

  128.                 }
    

  129.         }
    

  130. }
回复

收藏1 举报

下一页 »
1 ...292293294295296297298299... 937下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

快速回复 在线客服 返回列表 返回顶部
0