21ic电子技术开发论坛 › 已关闭版块 › Cortex-M0助学园地 › LOOK+红杏头文件 学习第六帖：I2C(中断方式) ...
12下一页
返回列表 发新帖我要提问

[LOOK] LOOK+红杏头文件 学习第六帖：I2C(中断方式)

[复制链接]
 楼主| Swallow_0322 发表于 2011-6-14 17:13 | 显示全部楼层 |阅读模式
中断方式, I2c, LED, 时钟, AD
本帖最后由 hotpower 于 2011-6-19 01:23 编辑

-----------------2011-06-14---------------
在原基础上做如下调整:
① 增加main.h文件 包含所需头文件
② 继承于interrupt_t的中断抽象类I2C1_t:I2C接口的单字节及多字节的读写操作；
③ task_AT24C16_t:接收UART命令完成对AT24C16的单字节及多字节的读写操作；
   'r'为读地址0x00单字节指令、'u'为地址0x00单字节加1并存储指令、d'为地址0x00单字节减1并存储指令；
   R'为读地址0x10开始单页指令、'u'为地址0x10开始单页加1并存储指令、'D'为地址0x10开始单页减1并存储指令。

初始化设置:HCLK时钟源:外部 4~24MHz 晶振使能
                分频: 1
               I2C1时钟使能
               PA.10 PA.11配置为I2C功能

--------------------------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 AM--------------------------------------------------
在原基础上作如下调整:
① 取消中断抽象类任务Key_t，该任务实现的功能整合至一般任务类task_key_t中的key_read中；
② 增加中断抽象类任务uart0_t，该任务主要实现UART输出和接收功能，接收到字符'1'为同步蜂鸣器响3次任务，接收到字符'2'实现与KEY2按下相同功能；
③ task_beep_t中增加蜂鸣器响之前发送字符串"Buzzer rang three times!\n"。
初始化设置: PB.0选择多功能输入RXD0 PB.1选择多功能输入TXD0
            UART时钟选择外部12MHZ,并使能UART0时钟
--------------------------------------------------2011-06-12 PM--------------------------------------------------
在原基础上做如下调整：
① 增加任务类task_ad_t，完成对AD1的单次AD转换并通过串口发送转换结果；
② 使用信号灯作为在UART0接收字符'3'时AD转换任务的同步。
初始化设置：ADC时钟选择外部12MHz，分频为3 并使能ADC时钟
            PA.1配置为AD引脚功能

源程序：
main.h
复制
  1. #ifndef __LOOK_MAIN_H
    

  2. #define __LOOK_MAIN_H
    


  3. 

  4. /*------------------------------------
    

  5. LOOK头文件放入此处
    

  6. ------------------------------------*/
    

  7. #include "look_config.h"
    

  8. #include <look.h>
    

  9. #include <instantiate>
    


  10. 

  11. /*------------------------------------
    

  12. 芯片及红杏头文件放入此处
    

  13. ------------------------------------*/
    

  14. #include "NUC1xx.h" 
    

  15. #include "NUC1xxM051Seriescfg.h"
    


  16. 

  17. /*------------------------------------
    

  18. 系统定义的C++语言的头文件应该放入此处
    

  19. ------------------------------------*/
    

  20. #include "led.h"
    

  21. #include "I2C.h"
    


  22. 

  23. /*------------------------------------
    

  24. 全局类对象实例声明放入此位置
    

  25. ------------------------------------*/
    

  26. #endif
led.h
复制
  1. #ifndef __LOOK_LED_H
    

  2. #define __LOOK_LED_H
    


  3. 

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


  5. 

  6. // 任务类 task_led_t 的定义
    

  7. class task_led_t : public task_t {
    

  8. public:
    

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

  10. protected:
    

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

  12. };
    

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

  14. __OPT_INLINE__ task_led_t::task_led_t()
    

  15. {
    

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

  17. }
    


  18. 


  19. 

  20. // 任务类 task_key_t 的定义
    

  21. class task_key_t : public task_t {
    

  22. public:
    

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

  24. int32_t key_read() __OPT_ATTR__;
    

  25. protected:
    

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

  27. };
    

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

  29. __OPT_INLINE__ task_key_t::task_key_t()
    

  30. {
    

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

  32. }
    


  33. 


  34. 

  35. // 任务类 task_beep_t 的定义
    

  36. class task_beep_t : public task_t {
    

  37. public:
    

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

  39. protected:
    

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

  41. };
    

  42. // 任务类 task_beep_t 的构造函数
    

  43. __OPT_INLINE__ task_beep_t::task_beep_t()
    

  44. {
    

  45. // TODO: 在此初始化 task_beep_t 的类成员
    

  46. }
    


  47. 


  48. 

  49. // 任务类 task_ad_t 的定义
    

  50. class task_ad_t : public task_t {
    

  51. public:
    

  52. task_ad_t() __OPT_ATTR__; // 构造函数
    

  53. sem_t sem; // 信号灯为AD转换提供同步
    

  54. protected:
    

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

  56. };
    

  57. // 任务类 task_beep_t 的构造函数
    

  58. __OPT_INLINE__ task_ad_t::task_ad_t():sem(0)
    

  59. {
    

  60. // TODO: 在此初始化 task_ad_t 的类成员
    

  61. }
    


  62. 

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

  64. class uart0_t : public interrupt_t {
    

  65. public:
    

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

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

  68. void put_numeral(uint8_t data);
    

  69. protected:
    

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

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

  72. private:
    

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

  74. private:
    

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

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

  77. };
    

  78. extern uart0_t uart0; // 创建 uart0 对象
    


  79. 

  80. // 任务类 task_AT24C16_t 的定义
    

  81. class task_AT24C16_t : public task_t {
    

  82. public:
    

  83. task_AT24C16_t() __OPT_ATTR__; // 构造函数
    

  84. protected:
    

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

  86. };
    

  87. // 任务类 task_beep_t 的构造函数
    

  88. __OPT_INLINE__ task_AT24C16_t::task_AT24C16_t()
    

  89. {
    

  90. // TODO: 在此初始化 task_ad_t 的类成员
    

  91. }
    


  92. 


  93. 

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

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

  96. extern instantiate::task<task_beep_t, LOOK_STACK_SIZE> task_beep;
    

  97. extern instantiate::task<task_ad_t, LOOK_STACK_SIZE> task_ad;
    

  98. extern instantiate::task<task_AT24C16_t, LOOK_STACK_SIZE> task_AT24C16;
    


  99. 

  100. #endif
I2C.h
复制

  1. 

  2. #ifndef __LOOK_I2C_H
    

  3. #define __LOOK_I2C_H
    

  4. // I2C1_t 类为应用层提供了 I2C 接口
    

  5. class I2C1_t : public interrupt_t {
    

  6. public:
    

  7.     I2C1_t() __OPT_ATTR__;   //构造函数
    

  8.     sem_t sem;      // 信号灯为AD转换提供同步
    

  9. protected:
    

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

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

  12. private://私有方法
    

  13.     inline void Start(void);//复位I2C
    

  14.     inline void REStart(void);//重复位I2C
    

  15. //inline void Wait(void);//超时等待
    

  16. inline void Exit(void);//出错退出
    

  17.     inline void Stop(void);//成功结束
    

  18. public://公有方法及属性
    

  19. unsigned char ReadByte(unsigned int Address, unsigned char *Data);//读字节函数(方法)
    

  20. unsigned char WriteByte(unsigned int, unsigned char);//写字节函数(方法)
    

  21. unsigned char ReadBuffer(unsigned int, unsigned char *, unsigned int);//读块函数(方法)
    

  22. unsigned char WriteBuffer(unsigned int, unsigned char *, unsigned int);//写块函数(方法)
    

  23. void SetAddress(unsigned int I2CAddress);//公有只写方法(属性)
    

  24. //void WriteWait(void);//EEPROM写入等待函数(方法)
    

  25. unsigned int GetState(void);//公有只读方法(属性)
    

  26. //void SetSystickCount(void);//公有只写方法(属性)
    

  27. private://私有属性
    

  28. volatile bool Busy;//忙属性
    

  29. volatile unsigned int State;//私有属性
    

  30. //volatile unsigned int SystickCount;//私有属性
    

  31. volatile unsigned int Count;//私有属性 
    

  32. volatile unsigned int MainCount, SubCount;//主从计数
    

  33. volatile unsigned int SubAddr;//私有属性
    

  34. volatile unsigned char MainComm, SubComm;//主从通讯命令
    

  35. volatile unsigned char TxBuffer[16], RxBuffer[16];//接收数据缓冲区
    

  36. };
    

  37. extern I2C1_t I2C_1;
    

  38. #endif
工程结构截图：


工程包：

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复 赏

举报

相关帖子
 楼主| Swallow_0322 发表于 2011-6-14 17:16 | 显示全部楼层
本帖最后由 Swallow_0322 于 2011-6-14 17:38 编辑

源文件：
I2C.CPP
复制

  1. 

  2. #include "main.h"
    


  3. 

  4. __OPT_INLINE__ I2C1_t::I2C1_t():sem(0) //构造函数
    

  5. {
    

  6. //I2C的引脚配置及时钟配置使用LOOK配置
    


  7. 

  8. SubAddr = 0xA0; //I2C设备地址
    

  9. for (uint32_t i = 0; i < sizeof(TxBuffer); i ++) 
    

  10. { //清空缓存
    

  11. TxBuffer = 0;
    

  12. RxBuffer = 0;
    

  13. }
    

  14. SYSCLKs.APBCLK.Bits.I2C1_EN = 1;
    

  15. SYSs.IPRSTC2.Bits.I2C1_RST = 1; //I2C1模块复位
    

  16. SYSs.IPRSTC2.Bits.I2C1_RST = 0; //I2C1正常工作
    

  17. I2C1s.CON.Bits.ENSI = 1; //允许I2C串行功能
    

  18. I2C1s.CLK.Regs = ((12000000/2*10)/(50000 * 4) + 5) / 10 - 1; 
    

  19. I2C1s.CON.Bits.EI = 1; //I2C1 使能中断
    

  20. I2C1s.CON.Bits.STA = 0; //I2C1起始标志清零
    

  21. I2C1s.CON.Bits.STO = 0; //I2C1结束标志清零
    

  22. I2C1s.CON.Bits.AA = 0; //I2C1应答标志清零
    

  23. I2C1s.CON.Bits.EI = 1; //I2C1 使能中断
    

  24. I2C1s.CON.Bits.ENSI = 1; //允许I2C串行功能
    

  25. I2C1s.CON.Bits.SI= 1; //清中断标志位
    


  26. 

  27. attach(I2C1_IRQn);
    

  28. vector_t::enable(I2C1_IRQn);
    

  29. }
    


  30. 

  31. // 中断服务例程
    

  32. bool I2C1_t::isr(int vector)
    

  33. {
    

  34. bool Back_Val = FALSE;
    

  35. switch(I2C1s.STATUS.Regs& 0xf8) 
    

  36. { 
    

  37. case I2C_START: //主机收到自己发送的开始信号
    

  38. if (State == I2C_START) { //本次中断应该接收TW_START信号
    

  39. I2C1s.DATA.Regs = SubAddr & 0xfe; //发送子机地址(写)
    

  40. I2C1s.CON.Bits.STA = 0;
    

  41. I2C1s.CON.Bits.SI = 1; //STA位必须清除，否则死机 清除中断标志
    

  42. State = I2C_MT_SLA_ACK; //Status下次I2C_MT_SLA_ACK
    

  43. }
    

  44. else 
    

  45. {
    

  46. Exit(); //通讯失败
    

  47. Back_Val = TRUE;
    

  48. }
    

  49. break;
    

  50. case I2C_REP_START: //主机收到自己发送的重新开始信号
    

  51. if (State == I2C_REP_START) { //本次中断应该接收TW_RESTART信号
    

  52. I2C1s.DATA.Regs = SubAddr | 0x01; //发送子机地址(读)
    

  53. I2C1s.CON.Bits.STA = 0; //STA位必须清除，否则死机 清除中断标志
    

  54. I2C1s.CON.Bits.SI = 1; 
    

  55. I2C1s.CON.Bits.AA = 1;
    

  56. State = I2C_MR_SLA_ACK; //Status下次I2C_MR_SLA_ACK
    

  57. }
    

  58. else 
    

  59. {
    

  60. Exit(); //通讯失败
    

  61. Back_Val = TRUE;
    

  62. }
    

  63. break;
    

  64. case I2C_MT_SLA_ACK: //主发机接收到从机的地址应答信号后发送命令
    

  65. if (State == I2C_MT_SLA_ACK) { //本次中断应该接收TW_MT_SLA_ACK信号
    

  66. State = I2C_MT_DATA_ACK; //Status下次应该收TW_MT_DATA_ACK
    

  67. I2C1s.DATA.Regs = SubComm; //发送子机命令
    

  68. I2C1s.CON.Bits.SI = 1;
    

  69. I2C1s.CON.Bits.AA = 1;
    

  70. }
    

  71. else 
    

  72. {
    

  73. Exit(); //通讯失败
    

  74. Back_Val = TRUE;
    

  75. }
    

  76. break;
    

  77. case I2C_MR_SLA_ACK: //主收机接收到从机的地址应答信号
    

  78. if ((State == I2C_MR_SLA_ACK) && SubCount) { //本次中断应该接收TW_MR_SLA_ACK信号
    

  79. State = I2C_MR_DATA_ACK; //Status下次应该收TW_MR_DATA_ACK
    

  80. I2C1s.CON.Bits.SI = 1;
    

  81. I2C1s.CON.Bits.AA = 1;
    

  82. }
    

  83. else 
    

  84. {
    

  85. Exit(); //通讯失败
    

  86. Back_Val = TRUE;
    

  87. }
    

  88. break;
    

  89. case I2C_MT_DATA_ACK: //主收机接收到从机的数据应答信号
    

  90. if ((State == I2C_MT_DATA_ACK) && (Count < MainCount)) {//本次中断应该接收TW_MT_DATA_ACK信号
    

  91. I2C1s.DATA.Regs = TxBuffer[Count ++];//发送子机数据
    

  92. I2C1s.CON.Bits.SI = 1;
    

  93. I2C1s.CON.Bits.AA = 1;
    

  94. }
    

  95. else {
    

  96. if ((State == I2C_MT_DATA_ACK) && (Count == MainCount) && (SubAddr & 1)) {//本次中断应该接收TW_MT_DATA_ACK信号
    

  97. REStart();//
    

  98. }
    

  99. else 
    

  100. {
    

  101. Stop(); //通讯成功
    

  102. Back_Val = TRUE;
    

  103. }
    

  104. }
    

  105. break;
    

  106. case I2C_MR_DATA_ACK:
    

  107. if ((State == I2C_MR_DATA_ACK) && (Count < SubCount)) {
    

  108. RxBuffer[Count ++] = I2C1s.DATA.Regs;//接收子机数据
    

  109. if (Count < SubCount) {
    

  110. I2C1s.CON.Bits.SI = 1;
    

  111. I2C1s.CON.Bits.AA = 1;
    

  112. }
    

  113. else {
    

  114. I2C1s.CON.Bits.AA = 0;
    

  115. I2C1s.CON.Bits.SI = 1;
    

  116. State = I2C_MR_DATA_NACK;//下次进入I2C_MR_DATA_NACK，接收数据准备完成
    

  117. }
    

  118. }
    

  119. else 
    

  120. {
    

  121. Exit(); //通讯失败
    

  122. Back_Val = TRUE;
    

  123. }
    

  124. break;
    

  125. case I2C_MR_DATA_NACK: //数据接收结束
    

  126. if ((State == I2C_MR_DATA_NACK) && (Count == SubCount)) {
    

  127. Stop(); //通讯成功
    

  128. }
    

  129. else Exit(); //通讯失败
    

  130. Back_Val = TRUE;
    

  131. break;
    

  132. // case I2C_MT_DATA_NACK:
    

  133. // Exit();//通讯失败
    

  134. // break;
    

  135. default:
    

  136. Exit(); //通讯失败
    

  137. Back_Val = TRUE;
    

  138. break;
    

  139. }
    

  140. return Back_Val;
    

  141. }
    


  142. 

  143. // 中断滞后服务例程
    

  144. void I2C1_t::dsr(int vector, uintptr_t count)
    

  145. {
    

  146. sem.do_post(); //释放一个信号量资源 
    

  147. }
    


  148. 


  149. 

  150. void I2C1_t::Start(void)
    

  151. {
    

  152. Busy = true;
    

  153. State = I2C_START; //主机准备发送启始位
    

  154. Count = 0; //发送数据个数
    

  155. //SystickCount = 0; //清除节拍计数器 
    

  156. I2C1s.CON.Bits.STO = 0; //I2C1结束标志清零
    

  157. I2C1s.CON.Bits.AA = 0; //I2C1应答标志清零
    

  158. I2C1s.CON.Bits.EI = 1; //I2C1 使能中断
    

  159. I2C1s.CON.Bits.ENSI = 1; //允许I2C串行功能
    

  160. I2C1s.CON.Bits.SI= 1; //清中断标志位
    

  161. I2C1s.CON.Bits.STA = 1; //I2C1起始标志置位
    

  162. //delay(LOOK_TICKS_PER_SEC); 
    

  163. while(!sem.wait());
    

  164. // task = &scheduler.get_current_task();
    

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

  166. }
    


  167. 

  168. void I2C1_t::REStart(void)
    

  169. {
    

  170. Busy = true;
    

  171. State = I2C_REP_START; //主机准备发送启始位
    

  172. Count = 0; //发送数据个数
    

  173. I2C1s.CON.Bits.STA = 1; //I2C1起始标志置位
    

  174. I2C1s.CON.Bits.SI= 1; //清中断标志位*/
    

  175. }
    


  176. 

  177. void I2C1_t::Stop(void)
    

  178. {
    

  179. Busy = false;
    

  180. State = I2C_BUS_OK;//通讯成功
    

  181. I2C1s.CON.Bits.STO = 1; //I2C1结束标志置位
    

  182. I2C1s.CON.Bits.SI = 1; //清中断标志位*/
    

  183. }
    


  184. 

  185. void I2C1_t::Exit(void)
    

  186. {
    

  187. Busy = false;
    

  188. State = I2C_BUS_ERROR; //通讯失败
    

  189. I2C1s.CON.Bits.STO = 1; //I2C1结束标志置位
    

  190. I2C1s.CON.Bits.SI = 1; //清中断标志位
    

  191. }
    


  192. 

  193. unsigned char I2C1_t::ReadByte(unsigned int Address, unsigned char *Data)
    

  194. {
    

  195. SubAddr |= 0x01;
    

  196. MainCount = 0; //发送0个数据(只读)
    

  197. //本程序为通用I2C,故发送器件后一般为命令，对EEPROM来说，命令实际是EEPROM地址
    

  198. SubComm = Address; //读出地址
    

  199. SubCount = 1; //接收1个数据
    

  200. //SystickCount = 0;
    

  201. Start(); //启动I2C模块
    

  202. if (State == I2C_BUS_OK) 
    

  203. {
    

  204. //通讯成功
    

  205. Data[0] = RxBuffer[0]; //从接收缓冲区取出一个字节
    

  206. }
    

  207. return State; //(读出数据在RxBuffer[0]~RxBuffer[15])
    

  208. }
    


  209. 

  210. unsigned char I2C1_t::WriteByte(unsigned int Address, unsigned char Data)
    

  211. {
    

  212. SubAddr &= 0xfe;
    

  213. MainCount = 1; //发送1个数据
    

  214. //本程序为通用I2C,故发送器件后一般为命令，对EEPROM来说，命令实际是EEPROM地址
    

  215. SubComm = Address; //写入地址
    

  216. TxBuffer[0] = Data; //写入1个数据到发送缓冲区
    

  217. SubCount = 0; //接收0个数据
    

  218. Start(); //启动I2C模块
    

  219. delay(LOOK_TICKS_PER_SEC/10); //延时100mS等待写入完成
    

  220. return State;
    

  221. }
    


  222. 

  223. unsigned char I2C1_t::ReadBuffer(unsigned int Address, unsigned char *Data, unsigned int Cnt)
    

  224. {
    

  225. SubAddr |= 0x01;
    

  226. MainCount = 0;//发送0个数据(只读)
    

  227. //本程序为通用I2C,故发送器件后一般为命令，对EEPROM来说，命令实际是EEPROM地址
    

  228. SubComm = Address;//读出地址
    

  229. SubCount = (Cnt <= sizeof(RxBuffer)) ? Cnt : sizeof(RxBuffer);//接收Cnt个数据
    

  230. Start();//启动I2C模块
    

  231. if (State == I2C_BUS_OK) {//通讯成功
    

  232. for (uint8_t i = 0; i < SubCount; i ++) Data = RxBuffer;//从接收缓冲区取出Cnt个字节
    

  233. }
    

  234. return State;//(读出数据在RxBuffer[0]~RxBuffer[15])
    

  235. }
    


  236. 

  237. unsigned char I2C1_t::WriteBuffer(unsigned int Address, unsigned char *Data, unsigned int Cnt)
    

  238. {
    

  239. SubAddr &= 0xfe;
    

  240. MainCount = (Cnt <= sizeof(TxBuffer)) ? Cnt : sizeof(TxBuffer);//发送Cnt个数据
    

  241. //本程序为通用I2C,故发送器件后一般为命令，对EEPROM来说，命令实际是EEPROM地址
    

  242. SubComm = Address;//写入地址
    

  243. for (uint8_t i = 0; i < MainCount; i ++) TxBuffer = Data;//写入Cnt个数据到发送缓冲区
    

  244. SubCount = 0;//接收0个数据
    

  245. Start();//启动I2C模块
    

  246. delay(LOOK_TICKS_PER_SEC/10); //延时100mS等待写入完成
    

  247. return State;
    

  248. }
    


  249. 


  250. 

  251. unsigned int I2C1_t::GetState(void)
    

  252. {
    

  253. return State;
    

  254. }
    


  255. 

  256. void I2C1_t::SetAddress(unsigned int I2CAddress)
    

  257. {
    

  258. SubAddr = I2CAddress;
    

  259. }
    


  260. 

  261. /*void I2cObj::SetSystickCount(void)
    

  262. {
    

  263. SystickCount ++;
    

  264. }*/
    


  265. 

  266. I2C1_t I2C_1;


led.cpp
复制
  1.  
    

  2. #include "main.h"
    

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

  4. flag_t Flag_I2C(0);  //通过I2C读写AT24c16同步标志
    

  5. // uart0 构造函数
    

  6. __OPT_INLINE__ uart0_t::uart0_t()
    

  7. {
    

  8.     attach(UART0_IRQn);
    

  9.     vector_t::enable(UART0_IRQn);
    

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

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

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

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

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

  15.     
    

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

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

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

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

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

  21.     
    

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

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

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

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

  26.     /*
    

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

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

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

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

  31. */
    

  32. }
    

  33. // uart0 输出
    

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

  35. {
    

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

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

  38.     task = &scheduler.get_current_task();
    

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

  40. }
    

  41. void uart0_t::put_numeral(uint8_t data)
    

  42. {
    

  43. char str[2];
    

  44. char *p;
    

  45. str[0] = ((data/16%16>9)?(data/16%16+'A'-10)data/16%16+'0'));
    

  46. str[1] = ((data%16>9)?(data%16+'A'-10)data%16+'0'));
    

  47. p = &str[0];
    

  48. puts(p);
    

  49. }
    

  50. // uart0 中断服务例程
    

  51. bool uart0_t::isr(int vector)
    

  52. {
    

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

  54. {
    

  55.   //UART0发送中断
    

  56.      const char* str = buffer;
    

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

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

  59.          return true;
    

  60.      }
    

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

  62.      return false;
    

  63. }
    

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

  65. {
    

  66.   //UART0接收中断
    

  67.   /* Get all the input characters */
    

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

  69.   {
    

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

  71.    char Received_Data = UART0s.DATA.Regs;
    

  72.    switch (Received_Data)
    

  73.    {
    

  74.     case '1':
    

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

  76.      Flag.do_set_bits(0b0100);
    

  77.      break;
    

  78.     case '3':
    

  79.      task_ad.sem.do_post();   //释放一个信号量资源 
    

  80.      break;
    

  81.     case 'R':
    

  82.      Flag_I2C.do_set_bits(0b01);
    

  83.      break;
    

  84.     case 'r':
    

  85.      Flag_I2C.do_set_bits(0b010);
    

  86.      break;
    

  87.     case 'U':
    

  88.      Flag_I2C.do_set_bits(0b0100);
    

  89.      break;
    

  90.     case 'u':
    

  91.      Flag_I2C.do_set_bits(0b01000);
    

  92.      break;
    

  93.     case 'D':
    

  94.      Flag_I2C.do_set_bits(0b010000);
    

  95.      break;
    

  96.     case 'd':
    

  97.      Flag_I2C.do_set_bits(0b0100000);
    

  98.      break;
    

  99.     case '2':
    

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

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

  102.        if (**&0b01)
    

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

  104.         else
    

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

  106.         break;
    

  107.    }
    

  108.    return false;
    

  109.   }
    

  110. }
    

  111. return false;
    

  112. }
    

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

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

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

  116. {
    

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

  118. }
    

  119. // uart0 填充 fifo
    

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

  121. {
    

  122.     do {
    

  123.         char ch;
    

  124.         ch = *str++;
    

  125.         if (ch == 0) {
    

  126.             str = 0;
    

  127.             break;
    

  128.         }
    

  129.         UART0s.DATA.Regs = ch;
    

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

  131.     buffer = str;
    

  132. }
    

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

  134. // 任务类 task_led_t 的例程
    

  135. void task_led_t::routine()
    

  136. {
    

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

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

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

  140. while (true) 
    

  141. {
    

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

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

  144.     int flag = Flag.peek();
    

  145.     if (flag)
    

  146.     {
    

  147.       data <<= 1; 
    

  148.       data += data >> 4; 
    

  149.     }
    

  150.     else
    

  151.     {
    

  152.       data >>= 1;
    

  153.       data += data << 4;
    

  154.     }
    

  155.     GPIOAs.DOUT.Regs = data; 
    

  156.     delay(LOOK_TICKS_PER_SEC/2); 
    

  157. }
    

  158. }
    

  159. // 任务类 task_key_t 的例程
    

  160. void task_key_t::routine()
    

  161. {
    

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

  163. while (true) 
    

  164. {
    

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

  166.     uint32_t Key_Val = key_read();
    

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

  168.   {
    

  169.    //KEY2 按下
    

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

  171.      if (**&0b01)
    

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

  173.       else
    

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

  175.   }
    

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

  177.   {
    

  178.    //KEY1 按下
    

  179.    Flag.do_set_bits(0b010);
    

  180.   }
    

  181.     delay(LOOK_TICKS_PER_SEC/10);
    

  182. }
    

  183. }
    

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

  185. __OPT_INLINE__ int32_t task_key_t::key_read()
    

  186. {
    

  187. uint32_t Key_Tmp = TRUE; 
    

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

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

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

  191. { 
    

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

  193.     return KEY_NO_DOWN;          //程序退出 
    

  194. } 
    

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

  196. { 
    

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

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

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

  200.     if(Key_Tmp==Key_Record) 
    

  201.     return Key_Tmp; 
    

  202. } 
    

  203. return KEY_NO_DOWN; 
    

  204. }
    

  205. // 任务类 task_beep_t 的例程
    

  206. void task_beep_t::routine()
    

  207. {
    

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

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

  210. while (true) 
    

  211. {
    

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

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

  214.      if (flag)
    

  215.      {
    

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

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

  218.       {  
    

  219.     //蜂鸣器响三次
    

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

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

  222.       }
    

  223.       }
    

  224. }
    

  225. }   
    

  226. // 任务类 task_ad_t 的例程
    

  227. void task_ad_t::routine()
    

  228. {
    

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

  230. SYSs.IPRSTC2.Bits.ADC_RST = 1;
    

  231. SYSs.IPRSTC2.Bits.ADC_RST = 0;  /* Reset ADC */
    

  232. //ADC时钟、分频及配置为AD引脚在look中配置
    

  233. ADCs.ADCR.Bits.ADEN = 1;   //使能AD模块
    

  234. ADCs.ADCALR.Bits.CALEN = 1;   //自校正使能
    

  235. while(!ADCs.ADCALR.Bits.CALDONE); //等待自校正结束
    

  236. ADCs.ADCR.Bits.DIFFEN = 0;   //单端输入
    

  237. ADCs.ADCR.Bits.ADST = 0;   //停止AD
    

  238. ADCs.ADCR.Bits.ADMD = 0;   //单一转换
    

  239. ADCs.ADCHER.Bits.CHEN = 0x02;  //模拟输入通道1使能
    

  240. ADCs.ADSR.Bits.ADF = 1;    //清AD中断标志
    

  241. while (true) 
    

  242. {
    

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

  244.   if (sem.wait())
    

  245.   {
    

  246.    ADCs.ADCR.Bits.ADST = 1; //启动AD
    

  247.    while(!ADCs.ADSR.Bits.ADF); //等待转换结束
    

  248.    ADCs.ADSR.Bits.ADF = 1;  //清AD中断标志
    

  249.    uint32_t AD_Result = ADCs.ADDR1.Regs&0xFFF;
    

  250.    char str[4];
    

  251.    char *p;
    

  252.    str[0] = AD_Result/1000+'0';
    

  253.    str[1] = AD_Result/100%10+'0';
    

  254.    str[2] = AD_Result/10%10+'0';
    

  255.    str[3] = AD_Result%10+'0';
    

  256.    p = &str[0];
    

  257.    uart0.puts("ADC_RESULT_AD1:");
    

  258.    uart0.puts(p);
    

  259.   }
    

  260.   
    

  261. }
    

  262. } 
    

  263. // 任务类 task_AT24C16_t 的例程
    

  264. void task_AT24C16_t::routine()
    

  265. {
    

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

  267. uint8_t EEPROM_Data = 0;  //IIC地址0x00读写数据
    

  268. uint8_t I2C_Page_Test[16];  //IIC地址0x10页读写数据
    

  269. uint8_t i = 0;
    

  270. while (true) 
    

  271. {
    

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

  273.     //uint8_t ** = Flag_I2C.peek();
    

  274.     int flag = Flag_I2C.wait(0b0111111, flag_t::ANY_CONSUME); 
    

  275.      switch (flag)
    

  276.      {
    

  277.       case 0x01:
    

  278.     if (I2C_BUS_OK==I2C_1.ReadBuffer(0x10,I2C_Page_Test,16))
    

  279.     {
    

  280.      uart0.puts("\nAT24C16地址0x10开始16字节的内容为:\n");
    

  281.      for (i=0;i<16;i++)
    

  282.       uart0.put_numeral(I2C_Page_Test);
    

  283.     }
    

  284.     else
    

  285.      uart0.puts("\nAT24C16地址0x10开始16字节的内容读取失败!");
    

  286.     break;
    

  287.    case 0x02:
    

  288.     if (I2C_BUS_OK==I2C_1.ReadByte(0x00,&EEPROM_Data))
    

  289.     {
    

  290.      uart0.puts("\nAT24C16地址0的内容为:0x");
    

  291.      uart0.put_numeral(EEPROM_Data);
    

  292.     }
    

  293.     else
    

  294.      uart0.puts("\nAT24C16地址0的内容读取失败!");
    

  295.     break;
    

  296.    case 0x04:
    

  297.     for (i=0;i<16;i++)
    

  298.      I2C_Page_Test++;
    

  299.     if (I2C_BUS_OK==I2C_1.WriteBuffer(0x10,I2C_Page_Test,16))
    

  300.      uart0.puts("\nAT24C16地址0x10开始16字节的内容加1成功!");
    

  301.     else
    

  302.     {
    

  303.      uart0.puts("\nAT24C16地址0x10开始16字节的内容加1失败!");
    

  304.      for (i=0;i<16;i++)
    

  305.       I2C_Page_Test--;
    

  306.     }
    

  307.     break;
    

  308.    case 0x08:
    

  309.     if (I2C_BUS_OK==I2C_1.WriteByte(0x00,++EEPROM_Data))
    

  310.      uart0.puts("\nAT24C16地址0的内容加1成功!");
    

  311.     else
    

  312.      uart0.puts("\nAT24C16地址0的内容加1失败!");
    

  313.     break;
    

  314.    case 0x10:
    

  315.     for (i=0;i<16;i++)
    

  316.      I2C_Page_Test--;
    

  317.     if (I2C_BUS_OK==I2C_1.WriteBuffer(0x10,I2C_Page_Test,16))
    

  318.      uart0.puts("\nAT24C16地址0x10开始16字节的内容减1成功!");
    

  319.     else
    

  320.     {
    

  321.      uart0.puts("\nAT24C16地址0x10开始16字节的内容减1失败!");
    

  322.      for (i=0;i<16;i++)
    

  323.       I2C_Page_Test++;
    

  324.     }
    

  325.     break;
    

  326.    case 0x20:
    

  327.     if (I2C_BUS_OK==I2C_1.WriteByte(0x00,--EEPROM_Data))
    

  328.      uart0.puts("\nAT24C16地址0的内容减1成功!");
    

  329.     else
    

  330.      uart0.puts("\nAT24C16地址0的内容减1失败!");
    

  331.     break;
    

  332.     default:
    

  333.      uart0.puts("\nAT24C16读写操作错误!");
    

  334.         }
    

  335.     }
    

  336. }  
    

  337. #ifdef LOOK_SCHEDULING_PRIORITY
    

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

  339. instantiate::task<task_beep_t, LOOK_STACK_SIZE> task_beep(3);
    

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

  341. instantiate::task<task_ad_t, LOOK_STACK_SIZE> task_ad(1);
    

  342. instantiate::task<task_AT24C16_t, LOOK_STACK_SIZE> task_AT24C16(4);
    

  343. #else
    

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

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

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

  347. instantiate::task<task_ad_t, LOOK_STACK_SIZE> task_ad;
    

  348. instantiate::task<task_AT24C16_t, LOOK_STACK_SIZE> task_AT24C16;
    

  349. #endif
回复 赏

举报

hotpower 发表于 2011-6-14 19:22 | 显示全部楼层
挺好的，多任务呀，adc，uart，iic，gpio
回复 赏

举报

Cube 发表于 2011-6-14 19:25 | 显示全部楼层
沙发没了。。。
回复 赏

举报

 楼主| Swallow_0322 发表于 2011-6-14 19:25 | 显示全部楼层
呵呵 都是简单的应用 任务的关联不大
回复 赏

举报

weshiluwei6 发表于 2011-6-14 19:26 | 显示全部楼层
太牛了太牛了太牛了 太牛了
回复 赏

举报

hotpower 发表于 2011-6-14 20:40 | 显示全部楼层
水王考试完了就look
回复 赏

举报

hotpower 发表于 2011-6-16 08:30 | 显示全部楼层
刚运行了三心的例程，很不错！http://bbs.21ic.com/icview-242344-1-1.html
回复 赏

举报

hotpower 发表于 2011-6-16 11:51 | 显示全部楼层
运行了，很不错！
初始化蜂鸣器输出为0就好了。
回复 赏

举报

 楼主| Swallow_0322 发表于 2011-6-16 14:07 | 显示全部楼层
本帖最后由 Swallow_0322 于 2011-6-16 14:08 编辑

多谢大叔关注！
现在蜂鸣器的控制初始化就是0啊，您运行有问题吗？
复制

  1. 

  2. // 任务类 task_beep_t 的例程
    

  3. void task_beep_t::routine()
    

  4. {
    

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

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

  7. while (true) 
    

  8. {
    

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

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

  11.      if (flag)
    

  12.      {
    

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

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

  15.       {  
    

  16.           //蜂鸣器响三次
    

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

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

  19.       }
    

  20.       }
    

  21. }
    

  22. }  
回复 赏

举报

hotpower 发表于 2011-6-16 21:22 | 显示全部楼层
void task_beep_t::routine()

{

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

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



这个有点慢，也可能是我设置了断点。
在老师的配置向导里要关掉快的多。
例程必须这个任务在运行状态，故初始化应该在其构造函数里面
回复 赏

举报

hotpower 发表于 2011-6-17 11:37 | 显示全部楼层
今晚我想讲讲这个例程，不知道我理解正确否。
最近问iic的问题很多，刚好用这个例程讲讲。
三心的iic做了三个了，我在群里有2个。
回复 赏

举报

 楼主| Swallow_0322 发表于 2011-6-17 19:01 | 显示全部楼层
void task_beep_t::routine()

{

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

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



这个有点慢，也可能是我设置了断点。
在老师的配置向导里要关掉快的多。
例 ...
hotpower 发表于 2011-6-16 21:22

哦 知道了  多谢大叔指导！
回复 赏

举报

 楼主| Swallow_0322 发表于 2011-6-17 19:03 | 显示全部楼层
12# hotpower

强烈支持!
这周一直在忙，SPI的例程还需稍推迟些！
回复 赏

举报

hotpower 发表于 2011-6-17 19:21 | 显示全部楼层
知道了，以后你写笔记，俺评述~~~
回复 赏

举报

plc_avr 发表于 2011-6-17 19:34 | 显示全部楼层
支持三心！多出笔记..........嘿嘿。
回复 赏

举报

 楼主| Swallow_0322 发表于 2011-6-18 07:31 | 显示全部楼层
15# hotpower

谢谢大叔的支持，一定努力！
回复 赏

举报

 楼主| Swallow_0322 发表于 2011-6-18 07:32 | 显示全部楼层
16# plc_avr

多谢烈火支持，多多指教！
回复 赏

举报

hotpower 发表于 2011-6-18 07:41 | 显示全部楼层
感觉以后要多讲讲笔记
回复 赏

举报

 楼主| Swallow_0322 发表于 2011-6-18 14:04 | 显示全部楼层
19# hotpower

支持！
最好对笔记内容提出些建议，作为对作笔记者的一种奖励，呵呵！
:P
回复 赏

举报

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

本版积分规则

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

121

主题

1393

帖子

4

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

121

主题

1393

帖子

4

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