21ic电子技术开发论坛 › 已关闭版块 › Cortex-M0助学园地 › LOOK+红杏头文件 学习第四帖：中断抽象类UART0收发练习 ...
返回列表 发新帖我要提问

[LOOK] LOOK+红杏头文件 学习第四帖：中断抽象类UART0收发练习

[复制链接]
 楼主| Swallow_0322 发表于 2011-6-12 10:02 | 显示全部楼层 |阅读模式
UART0, LED, 时钟, 蜂鸣器, include
本帖最后由 hotpower 于 2011-6-19 01:24 编辑

------------------------------2011-06-09------------------------------
LOOK实现四个小任务:
① task_led_t: 助学板上四个LED小灯轮流点亮,有两种显示模式，方式1为LED1--->LED2--->LED3--->LED4--->LED1循环，方式2为LED4--->LED3--->LED2--->LED1--->LED4循环，初始化为方式2；
② task_key_t: 助学板上KEY2通过查询的方式判断按下调整LED的循环方式；
③ 继承于interrupt_t的中断抽象类Key_t: 助学板上KEY1设置为下降沿中断，中断滞后服务函数内置位蜂鸣器鸣叫事件标志；
④ task_beep_t: 助学板上蜂鸣器响3声，该任务由KEY1同步。
初始化设置：时钟配置为 XTL12M_EN: 外部 4~24MHz 晶振使能
                            GPA2~5 GPB10 配置为输出模式
                            GPB14~15     配置为输入模式
                 CPU时钟频率为12MHz

关于flag_t:
ANY是wait()事件标志的集合中，任何一个事件到达都可以唤醒任务，相当于“或”运算；
ALL是wait()事件标志的集合中，所有事件全部到达时才能唤醒任务，相当于“与”运算；
当期待的事件标志只有一位时，无所谓ANY,ALL。
KEEP表示到达的事件标志，在唤醒了等待的任务后，该事件不消失（可以继续唤醒其它任务）；
COSUME表示到达的事件标志，在唤醒了等待的任务后，该事件消失。
------------------------------2011-06-12------------------------------
在原基础上作如下调整:
① 取消中断抽象类任务Key_t，该任务实现的功能整合至一般任务类task_key_t中的key_read中；
② 增加中断抽象类任务uart0_t，该任务主要实现UART输出和接收功能，接收到字符'1'为同步蜂鸣器响3次任务，接收到字符'2'实现与KEY2按下相同功能；(参考Lee老师DS18B20的例程)
③ task_beep_t中增加蜂鸣器响之前发送字符串"Buzzer rang three times!\n"。
初始化设置: PB.0选择多功能输入RXD0 PB.1选择多功能输入TXD0
            UART时钟选择外部12MHZ,并使能UART0时钟

源程序：
led.h
复制
  1. #include "look_config.h"
    

  2. #include <look.h>
    

  3. #include <instantiate>
    


  4. 

  5. #define KEY_NO_DOWN ((1<<14)|(1<<15)) //无按键按下时管脚PIN值
    


  6. 

  7. // 任务类 task_led_t 的定义
    

  8. class task_led_t : public task_t {
    

  9. public:
    

  10. task_led_t() __OPT_ATTR__; // 构造函数
    

  11. protected:
    

  12. void routine(); // 任务例程
    

  13. };
    

  14. // 任务类 task_led_t 的构造函数
    

  15. __OPT_INLINE__ task_led_t::task_led_t()
    

  16. {
    

  17. // TODO: 在此初始化 task_led_t 的类成员
    

  18. }
    

  19. // 任务类 task_key_t 的定义
    

  20. class task_key_t : public task_t {
    

  21. public:
    

  22. task_key_t() __OPT_ATTR__; // 构造函数
    

  23. int32_t key_read() __OPT_ATTR__;
    

  24. protected:
    

  25. void routine(); // 任务例程
    

  26. };
    


  27. 

  28. // 任务类 task_key_t 的构造函数
    

  29. __OPT_INLINE__ task_key_t::task_key_t()
    

  30. {
    

  31. // TODO: 在此初始化 task_led_t 的类成员
    

  32. }
    

  33. // 任务类 task_beep_t 的定义
    

  34. class task_beep_t : public task_t {
    

  35. public:
    

  36. task_beep_t() __OPT_ATTR__; // 构造函数
    

  37. protected:
    

  38. void routine(); // 任务例程
    

  39. };
    


  40. 

  41. // 任务类 task_key_t 的构造函数
    

  42. __OPT_INLINE__ task_beep_t::task_beep_t()
    

  43. {
    

  44. // TODO: 在此初始化 task_led_t 的类成员
    

  45. }
    


  46. 

  47. extern instantiate::task<task_led_t, LOOK_STACK_SIZE> task_led;
    

  48. extern instantiate::task<task_key_t, LOOK_STACK_SIZE> task_key;
    

  49. extern instantiate::task<task_beep_t, LOOK_STACK_SIZE> task_beep;
led.cpp
复制
  1. #include "NUC1xx.h" 
    

  2. #include "NUC1xxM051Seriescfg.h" 
    

  3. #include "led.h"
    


  4. 

  5. flag_t Flag(0); //位0为LED闪烁模式 位1为KEY1控制蜂鸣器任务同步标志 位2为UART通信控制蜂鸣器任务同步标志
    


  6. 

  7. // uart0_t 类为应用层提供了简单的 uart 同步输出功能及接收功能。
    

  8. class uart0_t : public interrupt_t {
    

  9. public:
    

  10. uart0_t() __OPT_ATTR__; //构造函数
    

  11. void puts(const char* str); //串口输出函数
    

  12. protected:
    

  13. bool isr(int vector); //中断服务例程
    

  14. void dsr(int vector, uintptr_t count); //中断滞后服务例程
    

  15. private:
    

  16. void fillfifo(const char* str); //填充FIFO
    

  17. private:
    

  18. const char* buffer; // 输出缓冲区
    

  19. task_t* task; // 正在输出的任务
    

  20. };
    


  21. 

  22. // uart0 构造函数
    

  23. __OPT_INLINE__ uart0_t::uart0_t()
    

  24. {
    

  25. attach(UART0_IRQn);
    

  26. vector_t::enable(UART0_IRQn);
    

  27. SYSs.IPRSTC2.Bits.UART0_RST = 1; //UART0 模块复位 
    

  28. SYSs.IPRSTC2.Bits.UART0_RST = 0; //UART0 模块正常工作
    

  29. UART0s.FCR.Bits.TFR = 1; //TX 软件复位
    

  30. UART0s.FCR.Bits.RFR = 1; //RX 软件复位
    

  31. UART0s.FCR.Bits.RFITL = 0x00; //Rx FIFO中断 (INT_RDA) 触发级别 1位
    


  32. 

  33. UART0s.LCR.Bits.SPE = 0; //无校验 奇偶使能位
    

  34. UART0s.LCR.Bits.EPE = 0; // 0----奇校验 1----偶校验
    

  35. UART0s.LCR.Bits.PBE = 0; 
    

  36. UART0s.LCR.Bits.WLS = 0b011; //字长度选择 8bits
    

  37. UART0s.LCR.Bits.NSB = 0; //1位停止位
    


  38. 

  39. UART0s.BAUD.Bits.BRD = 0x66; //外部12MHz 115200bps 对波特率分频寄存器的设置波特率分频设置即该句必须放在第一位
    

  40. UART0s.BAUD.Bits.DIV_X_EN = 1; //使能分频X
    

  41. UART0s.BAUD.Bits.DIV_X_ONE = 1; //Divider X equal 1 
    


  42. 

  43. UART0s.IER.Bits.RDA_IEN = 1; //使能接收中断
    

  44. /*
    

  45. DIV_X_EN DIV_X_ONE Divider X BRD 波特率公式 
    

  46. Disable 0 B A UART_CLK / [16 * (A+2)] 
    

  47. Enable 0 B A UART_CLK / [(B+1) * (A+2)] , B must >= 8 
    

  48. Enable 1 B A UART_CLK / (A+2), A must >=3 
    

  49. */
    

  50. }
    


  51. 

  52. // uart0 输出
    

  53. void uart0_t::puts(const char* str)
    

  54. {
    

  55. fillfifo(str); // 填充 fifo
    

  56. UART0s.IER.Bits.THRE_IEN = 1; // 允许发送中断
    

  57. task = &scheduler.get_current_task();
    

  58. delay(); // 阻塞任务
    

  59. }
    


  60. 

  61. // uart0 中断服务例程
    

  62. bool uart0_t::isr(int vector)
    

  63. {
    

  64. if (UART0s.ISR.Bits.THRE_INT==1)
    

  65. {
    

  66. //UART0发送中断
    

  67. const char* str = buffer;
    

  68. if (str == 0) { // 无数据
    

  69. UART0s.IER.Bits.THRE_IEN = 0; // 禁止发送中断
    

  70. return true;
    

  71. }
    

  72. fillfifo(str); // 填充 fifo
    

  73. return false;
    

  74. }
    

  75. if (UART0s.ISR.Bits.RDA_INT==1)
    

  76. {
    

  77. //UART0接收中断
    

  78. /* Get all the input characters */
    

  79. while(UART0s.ISR.Bits.RDA_IF)
    

  80. {
    

  81. /* Get the character from UART Buffer */
    

  82. uint8_t Received_Data = UART0s.DATA.Regs;
    

  83. if (Received_Data=='1')
    

  84. {
    

  85. //执行蜂鸣器响3次的任务
    

  86. Flag.do_set_bits(0b0100);
    

  87. }
    

  88. else if (Received_Data=='2')
    

  89. {
    

  90. //执行与KEY2相同的动作
    

  91. int ** = Flag.peek();
    

  92. if (**&0b01)
    

  93. Flag.do_mask_bits(~0b01); //清除事件标志 位0
    

  94. else
    

  95. Flag.do_set_bits(0b01); //置位事件标志 位0
    

  96. }
    

  97. return false;
    

  98. }
    

  99. }
    

  100. return false;
    

  101. }
    


  102. 

  103. // uart0 中断滞后服务例程
    

  104. // 所有数据发送完成后，dsr() 被调用
    

  105. void uart0_t::dsr(int vector, uintptr_t count)
    

  106. {
    

  107. task->do_wakeup(); // 唤醒任务
    

  108. }
    


  109. 

  110. // uart0 填充 fifo
    

  111. void uart0_t::fillfifo(const char* str)
    

  112. {
    

  113. do {
    

  114. char ch;
    

  115. ch = *str++;
    

  116. if (ch == 0) {
    

  117. str = 0;
    

  118. break;
    

  119. }
    

  120. UART0s.DATA.Regs = ch;
    

  121. } while (!UART0s.FSR.Bits.TX_FULL);
    

  122. buffer = str;
    

  123. }
    


  124. 

  125. uart0_t uart0; // 创建 uart0 对象
    


  126. 

  127. // 任务类 task_led_t 的例程
    

  128. void task_led_t::routine()
    

  129. {
    

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

  131. GPIOAs.DMASK.Regs = ~0b111100; 
    

  132. GPIOAs.DOUT.Regs = ~0b100; 
    

  133. while (true) 
    

  134. {
    

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

  136. uint32_t data = GPIOAs.DOUT.Regs & 0b111100; 
    

  137. int flag = Flag.peek();
    

  138. if (flag)
    

  139. {
    

  140. data <<= 1; 
    

  141. data += data >> 4; 
    

  142. }
    

  143. else
    

  144. {
    

  145. data >>= 1;
    

  146. data += data << 4;
    

  147. }
    

  148. GPIOAs.DOUT.Regs = data; 
    

  149. delay(LOOK_TICKS_PER_SEC); 
    

  150. }
    

  151. }
    


  152. 

  153. // 任务类 task_key_t 的例程
    

  154. void task_key_t::routine()
    

  155. {
    

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

  157. while (true) 
    

  158. {
    

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

  160. uint32_t Key_Val = key_read();
    

  161. if ((Key_Val&(1<<14))==0)
    

  162. {
    

  163. //KEY2 按下
    

  164. int ** = Flag.peek();
    

  165. if (**&0b01)
    

  166. Flag.mask_bits(~0b01); //清除事件标志 位0
    

  167. else
    

  168. Flag.set_bits(0b01); //置位事件标志 位0
    

  169. }
    

  170. if ((Key_Val&(1<<15))==0)
    

  171. {
    

  172. //KEY1 按下
    

  173. Flag.do_set_bits(0b010);
    

  174. }
    

  175. delay(LOOK_TICKS_PER_SEC/10);
    

  176. }
    

  177. }
    


  178. 

  179. // 任务类 task_key_t 的成员函数
    

  180. __OPT_INLINE__ int32_t task_key_t::key_read()
    

  181. {
    

  182. uint32_t Key_Tmp = TRUE; 
    

  183. static uint32_t Key_Record = KEY_NO_DOWN; //按键记录 
    

  184. Key_Tmp = GPIOBs.PIN.Regs&KEY_NO_DOWN; 
    

  185. if(Key_Tmp==KEY_NO_DOWN) //无有效按键按下 
    

  186. { 
    

  187. Key_Record = KEY_NO_DOWN; //清除按键记录 
    

  188. return KEY_NO_DOWN; //程序退出 
    

  189. } 
    

  190. if(Key_Record!=Key_Tmp) //为新按键 
    

  191. { 
    

  192. Key_Record = Key_Tmp; //保存本次结果 
    

  193. delay(LOOK_TICKS_PER_SEC/100); //延时去抖动 
    

  194. Key_Tmp = GPIOBs.PIN.Regs&KEY_NO_DOWN; 
    

  195. if(Key_Tmp==Key_Record) 
    

  196. return Key_Tmp; 
    

  197. } 
    

  198. return KEY_NO_DOWN; 
    

  199. }
    


  200. 

  201. // 任务类 task_beep_t 的例程
    

  202. void task_beep_t::routine()
    

  203. {
    

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

  205. GPIOBs.DOUT.Bits.Pin10 = 0; //蜂鸣器不响
    

  206. while (true) 
    

  207. {
    

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

  209. int flag = Flag.wait(0b110, flag_t::ANY_CONSUME); 
    

  210. if (flag)
    

  211. {
    

  212. uart0.puts("Buzzer rang three times!\n");
    

  213. for (uint32_t i = 0; i < 6; i ++)
    

  214. { 
    

  215. //蜂鸣器响三次
    

  216. GPIOBs.DOUT.Bits.Pin10 ^= 1; //蜂鸣器响PB10=1，不响PB10=0
    

  217. delay(LOOK_TICKS_PER_SEC); //断续间隔
    

  218. }
    

  219. }
    

  220. }
    

  221. } 
    


  222. 

  223. #ifdef LOOK_SCHEDULING_PRIORITY
    

  224. instantiate::task<task_key_t, LOOK_STACK_SIZE> task_key(0);
    

  225. instantiate::task<task_beep_t, LOOK_STACK_SIZE> task_beep(1);
    

  226. instantiate::task<task_led_t, LOOK_STACK_SIZE> task_led(2);
    

  227. #else
    

  228. instantiate::task<task_key_t, LOOK_STACK_SIZE> task_key;
    

  229. instantiate::task<task_beep_t, LOOK_STACK_SIZE> task_beep;
    

  230. instantiate::task<task_led_t, LOOK_STACK_SIZE> task_led;
    

  231. #endif
回复 赏

举报

相关帖子
 楼主| Swallow_0322 发表于 2011-6-12 10:36 | 显示全部楼层
本帖最后由 Swallow_0322 于 2011-6-12 10:37 编辑

呵呵！现在M0的学习气氛好淡，自己占沙发并在此预报下一贴目标，作为对自己的监督和鞭策！
uart收到某命令后以启动AD转换任务（此时使用信号灯同步任务），然后uart发送AD转换结果（此时会涉及到互斥信号灯），调度算法使用固定优先级。
回复 赏

举报

hotpower 发表于 2011-6-12 20:03 | 显示全部楼层
好！俺在路上回家看。
刚与吴旭光教授和牛博士谈了look和ucos。
回复 赏

举报

 楼主| Swallow_0322 发表于 2011-6-12 20:19 | 显示全部楼层
什么结果？等大叔好消息！
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

Swallow_0322
个人签名：播种一种行为，收获一种习惯；播种一种习惯，收获一种性格；播种一种性格，收获一种人生！

121

主题

1393

帖子

4

粉丝
快速回复 在线客服 返回列表 返回顶部
Swallow_0322
个人签名：播种一种行为，收获一种习惯；播种一种习惯，收获一种性格；播种一种性格，收获一种人生！

121

主题

1393

帖子

4

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