CAN控制器-配置过滤器

首先简单介绍一下CAN总线，关于CAN总线是谁发明的，CAN总线的历史，CAN总线的发展，CAN总线的应用场合，这些，通通不说。这里只是以我个人理解，简单说说CAN通信。CAN总线的端点没有地址（除非自己在帧里定义地址），CAN总线通信不用地址，用标识符，不是单独的谁发给谁，而是，你总是发送给整个网络。然后每个节点都有过滤器，对网络上的传播的帧的标识符进行过滤，自己想要什么样的帧，可以设置自己的过滤器，接收相关的帧信息。如果两个节点同时发送怎么办？这个不用我们担心，CAN控制器会自己仲裁，让高优先级的帧先发。

然后我们可以了解一下stm32的CAN控制器。

如上图所示，stm32有两个can控制器，can1（主），和can2（从），其中过滤器的设置是通过can1来设置，其他工作模式，波特率等，可以各自设置。每个控制器有三个发送邮箱，两个fifo，每个fifo有三个接收邮箱。

         发送：选择一个空的发送邮箱，把帧信息写到该发送邮箱的寄存器里，请求发送，控制器就会根据标识符的优先级把帧先后发送出去。

         接收：如果接收到的帧的标识符能过过滤表的一系列过滤，该帧信息就会保存在fifo接收邮箱的寄存器里。

         过滤器：stm32f407共有28组过滤器，每组过滤器可以设置关联到fifo0或者fifo1，每组都包括两个32位存储器，可以配置成一个32位有位屏蔽功能的标识符过滤器，或者两个32位完全匹配的标识符过滤器，或者两个16位有位屏蔽功能的标识符过滤器，或者四个16位完全匹配的标识符过滤器。如下图所示：

我所说的完全匹配的意思是，接收到的帧的标识符每一位都要跟过滤器对应的位一样，才能过得了这个过滤器。有位屏蔽功能的意思是一个寄存器放标识符，一个放屏蔽掩码，屏蔽掩码为1的位对应的接收到的帧的标识符的位与对应的放标识符的寄存器的位一致，就能通过。

为了过滤出一组标识符，应该设置过滤器组工作在屏蔽位模式。 
为了过滤出一个标识符，应该设置过滤器组工作在标识符列表模式。 
应用程序不用的过滤器组，应该保持在禁用状态。 
过滤器组中的每个过滤器，都被编号为(叫做过滤器号，图 32.1.11 中的 n)从 0 开始，到某
最大数值－取决于过滤器组的模式和位宽的设置。 
举个简单的例子，我们设置过滤器组 0 工作在：1 个 32 位过滤器-标识符屏蔽模式，然后
置 CAN_F0R1=0XFFFF0000，CAN_F0R2=0XFF00FF00。其中存放到 CAN_F0R1 的值就是期
收到的 ID，即我们希望收到的 ID（STID+EXTID+IDE+RTR）最好是：0XFFFF0000。而
FF00FF00 就是设置我们需要必须关心的 ID，表示收到的 ID，其位[31:24]和位[15:8]这 16 个
的必须和 CAN_F0R1 中对应的位一模一样，而另外的 16 个位则不关心，可以一样，也可以
一样，都认为是正确的 ID，即收到的 ID必须是 0XFFxx00xx，才算是正确的（x 表示不关心）。

传输一位的时间和波特率的计算：

 

         CAN控制器的波特率是由APB时钟线和CAN位时序寄存器CAN_BTR的TS2[3：0]、TS1[2:0]和BRP[9：0]确定的，其中，TS1[2：0]定义了时间段1占用多少个时间单元，TS2[3：0]定义了时间段2占用多少个时间单元，BRP[9：0]定义对APB1时钟的分频。

 

PS：设置波特率为1M


其中Tpclk为APB1的时钟周期，假设为

Tpclk = 1/42M

0≦TS1≦7

0≦TS2≦15

0≦BRP≦1021

根据以上数据，有

(TS2+TS1+3)(BRP+1)=42

令BRP=2，有

TS2+TS1=11

令TS1=8，TS2=3

 

 

设置步骤：

1.     设置中断优先级分组（如果之前没有设置），这个最好一个程序里只在开头设置一次。

2.     使能相关GPIO时钟。

3.     选择相关GPIO引脚的复用功能。

4.     设置相关GPIO引脚为复用模式。

5.     设置相关GPIO引脚的速度，方式。

6.     设置主控制寄存器MCR，进入初始化模式

7.     等待进入初始化模式

8.     设置波特率。

9.     其他设置。

10.  如果要用到中断，在中断使能寄存器IER中使能相关中断响应。

11.  如果要用到中断，设置相关中断优先级（NVIC_IP）。

12.  如果要用到中断，使能相关中断（NVIC_ISER）。

13.  设置主控制寄存器MCR，进入正常工作模式。

14.  设置FMR，使过滤器组工作在初始化模式。

15.  设置FMR的CAN2SB，确定CAN2的过滤器组从哪一组开始。

16.  设置用到的过滤器组的工作方式。

17.  设置用到的过滤器组的位宽。

18.  给fifo0和fifo2划分（关联）过滤组。

19.  禁用用到的过滤器组。

20.  设置过滤器组的标识符，帧类型等。

21.  使能相关过滤器组。

22.  设置FMR，使过滤器组工作在正常模式。

23.  如果要用中断，编写中断服务函数（函数名是固定的）。

24.  中断服务函数里检查是哪个中断。

25.  编写相应服务程序。

电路请参见本博客：小工具之——CAN收发器 

程序：

[plain] view plaincopy

  1. /************************************
  2. 标题：操作CAN的练习
  3. 软件平台：IAR for ARM6.21
  4. 硬件平台：stm32f4-discovery
  5. 主频：168M
  6. 描述：通过硬件收发器连接CAN1,CAN2
  7. 组成一个两个端点的网络
  8. CAN1循环发出数据帧
  9. CAN2接收过滤数据帧
  10. 用uart把CAN2接收到
  11. 的数据帧发到超级终端
  12. author：小船
  13. data：2012-08-14
  14. *************************************/
  15. #include <stm32f4xx.h>
  16. #include "MyDebugger.h"
  17. #define RECEIVE_BUFFER_SIZE 20
  18. u32 CAN2_receive_buffer[RECEIVE_BUFFER_SIZE][4];
  19. u8 UART_send_buffer[1800];
  20. u8 Consumer = 0;
  21. u8 Producer = 0;
  22. u32 Gb_TimingDelay;
  23. void Delay(uint32_t nTime);
  24. void TIM7_init();//定时1s
  25. u32 get_rece_data();
  26. void CAN_GPIO_config();
  27. void main ()
  28. {
  29. u32 empty_box;
  30. SysTick_Config(SystemCoreClock / 1000); //设置systemtick一毫秒中断
  31. SCB->AIRCR = 0x05FA0000 | 0x400;  //中断优先级分组 抢占：响应=3:1
  32. MyDebugger_Init();
  33. TIM7_init();
  34. MyDebugger_Message( "\n\rtesting......\n\r" ,
  35. sizeof("\n\rtesting......\n\r")/sizeof(char) );
  36. CAN_GPIO_config();
  37. RCC->APB1ENR |= ((1<<25)|(1<<26));//使能CAN1、CAN2时钟
  38. CAN1->MCR = 0x00000000;
  39. /*
  40. 请求进入初始化模式
  41. 禁止报文自动重传
  42. 自动唤醒模式
  43. */
  44. CAN1->MCR |= ((1<<0)|(1<<4)|(1<<5));
  45. CAN1->MCR &= ~(1<<16);//在调试时，CAN照常工作
  46. while(!(CAN1->MSR & 0xfffffffe))  //等待进入初始化模式
  47. {
  48. MyDebugger_LEDs(orange, on);
  49. }
  50. MyDebugger_LEDs(orange, off);
  51. /*
  52. 正常模式
  53. 重新同步跳跃宽度（1+1）tq
  54. TS2[2:0]=3
  55. TS1[3:0]=8
  56. BRP[9:0]=2
  57. ps：
  58. tq = (BRP[9:0] + 1) x tPCLK,
  59. tBS2 = tq x (TS2[2:0] + 1),
  60. tBS1 = tq x (TS1[3:0] + 1),
  61. NominalBitTime = 1 × tq+tBS1+tBS2,
  62. BaudRate = 1 / NominalBitTime
  63. 波特率设为1M
  64. */
  65. CAN1->BTR = ((0<<30)|(0x01<<24)|(3<<20)|(8<<16)|(2<<0));
  66. CAN1->MCR &= ~(0x00000001);//正常工作模式
  67. CAN2->MCR = 0x00000000;
  68. /*
  69. 请求进入初始化模式
  70. 禁止报文自动重传
  71. 自动唤醒模式
  72. */
  73. CAN2->MCR |= ((1<<0)|(1<<4)|(1<<5));
  74. CAN2->MCR &= ~(1<<16);//在调试时，CAN照常工作
  75. while(!(CAN2->MSR & 0xfffffffe))  //等待进入初始化模式
  76. {
  77. MyDebugger_LEDs(orange, on);
  78. }
  79. MyDebugger_LEDs(orange, off);
  80. /*
  81. 正常模式
  82. 重新同步跳跃宽度（1+1）tq
  83. TS2[2:0]=3
  84. TS1[3:0]=8
  85. BRP[9:0]=2
  86. ps：
  87. tq = (BRP[9:0] + 1) x tPCLK,
  88. tBS2 = tq x (TS2[2:0] + 1),
  89. tBS1 = tq x (TS1[3:0] + 1),
  90. NominalBitTime = 1 × tq+tBS1+tBS2,
  91. BaudRate = 1 / NominalBitTime
  92. 波特率设为1M
  93. */
  94. CAN2->BTR = ((0<<30)|(0x01<<24)|(3<<20)|(8<<16)|(2<<0));
  95. CAN2->IER &= 0x00000000;
  96. /*
  97. FIFO1消息挂号中断使能
  98. FIFO1满中断使能
  99. FIFO1溢出中断使能
  100. */
  101. CAN2->IER |= ((1<<4)|(1<<5)|(1<<6));
  102. NVIC->IP[65] = 0xa0;   //抢占优先级101,响应优先级0
  103. NVIC->ISER[2] |= (1<<1);  //使能中断线65，也就是can2_rx1中断
  104. CAN2->MCR &= ~(0x00000001);//正常工作模式
  105. //总共有28组过滤器
  106. CAN1->FMR |= 1; //过滤器组工作在初始化模式
  107. CAN1->FMR &= 0xffffc0ff;//CAN2的过滤器组从14开始
  108. CAN1->FMR |= (14<<8);
  109. CAN1->FM1R |= (1<<14);//过滤器组14的寄存器工作在标识符列表模式
  110. //位宽为16位，2个32位分为四个16位寄存器，过滤四个标识符
  111. //CAN1->FS1R |= (1<<15);//过滤器组15为单个32位寄存器，用于扩展标识符
  112. CAN1->FFA1R = 0x0fffc000;//0~13号过滤器组关联到fifo0，14~27号过滤器组关联到fifo1
  113. CAN1->FA1R &= ~(1<<14);//禁用过滤器组14
  114. /*
  115. 过滤器组0寄存器分为4个十六位过滤器：
  116. 标识符列表：
  117. 过滤器编号        匹配标准标识符             RTR       IDE           EXID[17：15]
  118. 0              0x7cb（111 1100 1011b）    数据帧    标准标识符     000b
  119. 1              0x4ab（100 1010 1011b）    数据帧    标准标识符     000b
  120. 2              0x7ab（111 1010 1011b）    数据帧    标准标识符     000b
  121. 3              0x40b（100 0000 1011b）    数据帧    标准标识符     000b
  122. */
  123. CAN1->sFilterRegister[14].FR1 &= 0x00000000;
  124. CAN1->sFilterRegister[14].FR2 &= 0x00000000;
  125. CAN1->sFilterRegister[14].FR1 |= ((0x7cb<<5)|(0<<4)|(0<<3));
  126. CAN1->sFilterRegister[14].FR1 |= ((0x4ab<<21)|(0<<20)|(0<<19));
  127. CAN1->sFilterRegister[14].FR2 |= ((0x7ab<<5)|(0<<4)|(0<<3));
  128. CAN1->sFilterRegister[14].FR2 |= ((0x40b<<21)|(0<<20)|(0<<19));
  129. CAN1->FA1R |= (1<<14);//使能过滤器组14
  130. CAN1->FMR &= ~1; //过滤器组正常工作
  131. while(1)
  132. {
  133. /*
  134. 选择空的发送邮箱：
  135. 标准标识符0x7ab（111 1010 1011b）
  136. 数据帧
  137. 不使用扩展标识符
  138. */
  139. if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )
  140. {
  141. empty_box = ((CAN1->TSR>>24) & 0x00000003);
  142. CAN1->sTxMailBox[empty_box].TIR = (0x7ab<<21);
  143. CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;
  144. CAN1->sTxMailBox[empty_box].TDTR |= 0x00000008;//发送数据长度为8
  145. CAN1->sTxMailBox[empty_box].TDLR = 0x12345678;
  146. CAN1->sTxMailBox[empty_box].TDHR = 0x9abcdef0;
  147. CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送
  148. }
  149. else
  150. {
  151. MyDebugger_LEDs(orange, on);
  152. }
  153. Delay(100);
  154. /*
  155. 选择空的发送邮箱：
  156. 标准标识符0x4ab（100 1010 1011b）
  157. 数据帧
  158. 不使用扩展标识符
  159. */
  160. if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )
  161. {
  162. empty_box = ((CAN1->TSR>>24) & 0x00000003);
  163. CAN1->sTxMailBox[empty_box].TIR = (0x4ab<<21);
  164. CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;
  165. CAN1->sTxMailBox[empty_box].TDTR |= 0x00000008;//发送数据长度为8
  166. CAN1->sTxMailBox[empty_box].TDLR = 0x56781234;
  167. CAN1->sTxMailBox[empty_box].TDHR = 0x9abcdef0;
  168. CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送
  169. }
  170. else
  171. {
  172. MyDebugger_LEDs(orange, on);
  173. }
  174. Delay(100);
  175. /*
  176. 选择空的发送邮箱：
  177. 标准标识符0x7cb（100 1010 1011b）
  178. 数据帧
  179. 不使用扩展标识符
  180. */
  181. if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )
  182. {
  183. empty_box = ((CAN1->TSR>>24) & 0x00000003);
  184. CAN1->sTxMailBox[empty_box].TIR = (0x7cb<<21);
  185. CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;
  186. CAN1->sTxMailBox[empty_box].TDTR |= 0x00000006;//发送数据长度为6
  187. CAN1->sTxMailBox[empty_box].TDLR = 0x56781234;
  188. CAN1->sTxMailBox[empty_box].TDHR = 0x00009abc;
  189. CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送
  190. }
  191. else
  192. {
  193. MyDebugger_LEDs(orange, on);
  194. }
  195. Delay(100);
  196. /*
  197. 选择空的发送邮箱：
  198. 标准标识符0x40b（100 0000 1011b）
  199. 数据帧
  200. 不使用扩展标识符
  201. */
  202. if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )
  203. {
  204. empty_box = ((CAN1->TSR>>24) & 0x00000003);
  205. CAN1->sTxMailBox[empty_box].TIR = (0x40b<<21);
  206. CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;
  207. CAN1->sTxMailBox[empty_box].TDTR |= 0x00000004;//发送数据长度为4
  208. CAN1->sTxMailBox[empty_box].TDLR = 0x56781234;
  209. CAN1->sTxMailBox[empty_box].TDHR = 0x00000000;
  210. CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送
  211. }
  212. else
  213. {
  214. MyDebugger_LEDs(orange, on);
  215. }
  216. Delay(100);
  217. }
  218. }
  219. /****************************************
  220. 函数名：CAN_GPIO_config
  221. 参数：无
  222. 返回值：无
  223. 功能：设置CAN1，2控制器用到IO口
  224. CAN1_TX---------PD1
  225. CAN1_RX---------PB8
  226. CAN2_TX---------PB13
  227. CAN2_RX---------PB5
  228. ****************************************/
  229. void CAN_GPIO_config()
  230. {
  231. RCC->AHB1ENR |= ((1<<1) | (1<<3));//使能GPIOB、D时钟
  232. GPIOB->AFR[0] |= 0x00900000;      //AF9
  233. GPIOB->AFR[1] |= 0x00900009;
  234. GPIOD->AFR[0] |= 0x00000090;
  235. GPIOB->MODER &= 0xF3FCF3FF; //第二功能
  236. GPIOB->MODER |= 0x08020800;
  237. GPIOD->MODER &= 0xFFFFFFF3;
  238. GPIOD->MODER |= 0x00000008;
  239. GPIOB->OSPEEDR &= 0xF3FCF3FF; //50M
  240. GPIOB->OSPEEDR |= 0x08020800;
  241. GPIOD->OSPEEDR &= 0xFFFFFFF3;
  242. GPIOD->OSPEEDR |= 0x00000008;
  243. GPIOB->PUPDR &= 0xF3FCF3FF;   //上拉
  244. GPIOB->PUPDR |= 0x04010400;
  245. GPIOD->PUPDR &= 0xFFFFFFF3;
  246. GPIOD->PUPDR |= 0x00000004;
  247. }
  248. /****************************************
  249. 函数名：CAN2_RX1_IRQHandler
  250. 参数：无
  251. 返回值：无
  252. 功能：CAN2fifo1接收中断处理
  253. 把信息存进循环队列
  254. ****************************************/
  255. void CAN2_RX1_IRQHandler()
  256. {
  257. if(CAN2->RF1R & (0x00000003))//接收到新的消息，fifo1非空
  258. {
  259. Producer++;
  260. if(Producer == RECEIVE_BUFFER_SIZE)Producer = 0;
  261. if(Producer != Consumer)
  262. {
  263. CAN2_receive_buffer[Producer][0] = CAN2->sFIFOMailBox[1].RIR;
  264. CAN2_receive_buffer[Producer][1] = CAN2->sFIFOMailBox[1].RDTR;
  265. CAN2_receive_buffer[Producer][2] = CAN2->sFIFOMailBox[1].RDLR;
  266. CAN2_receive_buffer[Producer][3] = CAN2->sFIFOMailBox[1].RDHR;
  267. }
  268. else
  269. {
  270. if(Producer == 0)Producer = RECEIVE_BUFFER_SIZE;
  271. Producer--;
  272. MyDebugger_LEDs(blue, on);
  273. }
  274. CAN2->RF1R |= (1<<5);//释放邮箱
  275. }
  276. if(CAN2->RF1R & (1<<3))//fifo0满
  277. {
  278. MyDebugger_LEDs(red, on);
  279. CAN2->RF1R &= ~(1<<3);
  280. }
  281. if(CAN2->RF1R & (1<<4))//fifo0溢出
  282. {
  283. MyDebugger_LEDs(red, on);
  284. CAN2->RF1R &= ~(1<<4);
  285. }
  286. }
  287. /****************************************
  288. 函数名：TIM7_init
  289. 参数：无
  290. 返回值：无
  291. 功能：初始化定时器7
  292. 作1s定时用
  293. ****************************************/
  294. void TIM7_init()
  295. {
  296. RCC->APB1ENR |= (1<<5); //打开TIM7时钟
  297. TIM7->PSC = 8399; //对时钟84M进行8400分频，使得计数频率为10k
  298. TIM7->ARR = 10000;  //定时一秒
  299. TIM7->CNT = 0;  //清空计数器
  300. TIM7->CR1 |= (1<<7); //自动重装载预装载使能
  301. TIM7->DIER |= 1; //使能中断
  302. NVIC->IP[55] = 0xe0;
  303. NVIC->ISER[1] |= (1<<(55-32));
  304. TIM7->CR1 |= 1; //开始计时
  305. }
  306. /****************************************
  307. 函数名：TIM7_IRQHandler
  308. 参数：无
  309. 返回值：无
  310. 功能：定时器7中断处理
  311. 1s定时到
  312. 把can2收到的信息转换格式
  313. 用usrt发送到超级终端显示
  314. ****************************************/
  315. void TIM7_IRQHandler(void)
  316. {
  317. u32 length;
  318. if(TIM7->SR)
  319. {
  320. length = get_rece_data();
  321. MyDebugger_Message( UART_send_buffer, length );
  322. TIM7->SR &= ~(0x0001);
  323. }
  324. }
  325. /****************************************
  326. 函数名：get_rece_data
  327. 参数：无
  328. 返回值：length 整理后要发送数据的长度
  329. 功能：把循环队列的信息取出
  330. 进行格式转换
  331. 把信息存到uart发送缓冲区
  332. ****************************************/
  333. u32 get_rece_data()
  334. {
  335. u8 filter_No;
  336. u8 Data_length;
  337. char i;
  338. u32 length = 0;
  339. const char ascii[16] = {‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘,
  340. ‘8‘, ‘9‘, ‘A‘, ‘B‘, ‘C‘, ‘D‘, ‘E‘, ‘F‘};
  341. while(1)
  342. {
  343. if(Producer != Consumer)
  344. {
  345. Consumer++;
  346. if(Consumer == RECEIVE_BUFFER_SIZE)Consumer=0;
  347. UART_send_buffer[length++] = ‘\n‘;
  348. UART_send_buffer[length++] = ‘\r‘;
  349. //Filter No.xx
  350. UART_send_buffer[length++] = ‘F‘;
  351. UART_send_buffer[length++] = ‘i‘;
  352. UART_send_buffer[length++] = ‘l‘;
  353. UART_send_buffer[length++] = ‘t‘;
  354. UART_send_buffer[length++] = ‘e‘;
  355. UART_send_buffer[length++] = ‘r‘;
  356. UART_send_buffer[length++] = ‘ ‘;
  357. UART_send_buffer[length++] = ‘N‘;
  358. UART_send_buffer[length++] = ‘o‘;
  359. UART_send_buffer[length++] = ‘.‘;
  360. filter_No = (CAN2_receive_buffer[Consumer][1]>>8) & 0x000000ff;
  361. UART_send_buffer[length++] = filter_No%100/10 + ‘0‘;
  362. UART_send_buffer[length++] = filter_No%10 + ‘0‘;
  363. UART_send_buffer[length++] = ‘\n‘;
  364. UART_send_buffer[length++] = ‘\r‘;
  365. //DataLength:x
  366. UART_send_buffer[length++] = ‘D‘;
  367. UART_send_buffer[length++] = ‘a‘;
  368. UART_send_buffer[length++] = ‘t‘;
  369. UART_send_buffer[length++] = ‘a‘;
  370. UART_send_buffer[length++] = ‘L‘;
  371. UART_send_buffer[length++] = ‘e‘;
  372. UART_send_buffer[length++] = ‘n‘;
  373. UART_send_buffer[length++] = ‘g‘;
  374. UART_send_buffer[length++] = ‘t‘;
  375. UART_send_buffer[length++] = ‘h‘;
  376. UART_send_buffer[length++] = ‘:‘;
  377. Data_length = CAN2_receive_buffer[Consumer][1] & 0x0000000f;
  378. UART_send_buffer[length++] = Data_length % 10 + ‘0‘;
  379. UART_send_buffer[length++] = ‘\n‘;
  380. UART_send_buffer[length++] = ‘\r‘;
  381. if(CAN2_receive_buffer[Consumer][0] & (1<<1))
  382. {
  383. UART_send_buffer[length++] = ‘R‘;
  384. UART_send_buffer[length++] = ‘e‘;
  385. UART_send_buffer[length++] = ‘m‘;
  386. UART_send_buffer[length++] = ‘o‘;
  387. UART_send_buffer[length++] = ‘t‘;
  388. UART_send_buffer[length++] = ‘e‘;
  389. UART_send_buffer[length++] = ‘F‘;
  390. UART_send_buffer[length++] = ‘r‘;
  391. UART_send_buffer[length++] = ‘a‘;
  392. UART_send_buffer[length++] = ‘m‘;
  393. UART_send_buffer[length++] = ‘e‘;
  394. }
  395. else
  396. {
  397. UART_send_buffer[length++] = ‘D‘;
  398. UART_send_buffer[length++] = ‘a‘;
  399. UART_send_buffer[length++] = ‘t‘;
  400. UART_send_buffer[length++] = ‘a‘;
  401. UART_send_buffer[length++] = ‘F‘;
  402. UART_send_buffer[length++] = ‘r‘;
  403. UART_send_buffer[length++] = ‘a‘;
  404. UART_send_buffer[length++] = ‘m‘;
  405. UART_send_buffer[length++] = ‘e‘;
  406. }
  407. UART_send_buffer[length++] = ‘\n‘;
  408. UART_send_buffer[length++] = ‘\r‘;
  409. if(CAN2_receive_buffer[Consumer][0] & (1<<2))
  410. {
  411. UART_send_buffer[length++] = ‘e‘;
  412. UART_send_buffer[length++] = ‘x‘;
  413. UART_send_buffer[length++] = ‘t‘;
  414. UART_send_buffer[length++] = ‘ ‘;
  415. UART_send_buffer[length++] = ‘I‘;
  416. UART_send_buffer[length++] = ‘D‘;
  417. UART_send_buffer[length++] = ‘:‘;
  418. UART_send_buffer[length++] =
  419. ascii[CAN2_receive_buffer[Consumer][0] >> 31];
  420. UART_send_buffer[length++] =
  421. ascii[(CAN2_receive_buffer[Consumer][0] >> 27)& 0x0000000f];
  422. UART_send_buffer[length++] =
  423. ascii[(CAN2_receive_buffer[Consumer][0] >> 23)& 0x0000000f];
  424. UART_send_buffer[length++] =
  425. ascii[(CAN2_receive_buffer[Consumer][0] >> 19)& 0x0000000f];
  426. UART_send_buffer[length++] =
  427. ascii[(CAN2_receive_buffer[Consumer][0] >> 15)& 0x0000000f];
  428. UART_send_buffer[length++] =
  429. ascii[(CAN2_receive_buffer[Consumer][0] >> 11)& 0x0000000f];
  430. UART_send_buffer[length++] =
  431. ascii[(CAN2_receive_buffer[Consumer][0] >> 7)& 0x0000000f];
  432. UART_send_buffer[length++] =
  433. ascii[(CAN2_receive_buffer[Consumer][0] >> 3)& 0x0000000f];
  434. }
  435. else
  436. {
  437. UART_send_buffer[length++] = ‘s‘;
  438. UART_send_buffer[length++] = ‘t‘;
  439. UART_send_buffer[length++] = ‘d‘;
  440. UART_send_buffer[length++] = ‘ ‘;
  441. UART_send_buffer[length++] = ‘I‘;
  442. UART_send_buffer[length++] = ‘D‘;
  443. UART_send_buffer[length++] = ‘:‘;
  444. UART_send_buffer[length++] =
  445. ascii[CAN2_receive_buffer[Consumer][0] >> 29];
  446. UART_send_buffer[length++] =
  447. ascii[(CAN2_receive_buffer[Consumer][0] >> 25)& 0x0000000f];
  448. UART_send_buffer[length++] =
  449. ascii[(CAN2_receive_buffer[Consumer][0] >> 21)& 0x0000000f];
  450. }
  451. UART_send_buffer[length++] = ‘\n‘;
  452. UART_send_buffer[length++] = ‘\r‘;
  453. UART_send_buffer[length++] = ‘D‘;
  454. UART_send_buffer[length++] = ‘a‘;
  455. UART_send_buffer[length++] = ‘t‘;
  456. UART_send_buffer[length++] = ‘a‘;
  457. UART_send_buffer[length++] = ‘:‘;
  458. if(Data_length > 4)
  459. {
  460. for(i = 2*Data_length - 8; i > 0; i--)
  461. UART_send_buffer[length++] =
  462. ascii[(CAN2_receive_buffer[Consumer][3] >> ((i-1)*4))& 0x0000000f];
  463. for(i = 8; i > 0; i--)
  464. UART_send_buffer[length++] =
  465. ascii[(CAN2_receive_buffer[Consumer][2] >> ((i-1)*4))& 0x0000000f];
  466. }
  467. else
  468. {
  469. for(i = 2*Data_length; i > 0; i--)
  470. UART_send_buffer[length++] =
  471. ascii[(CAN2_receive_buffer[Consumer][2] >> ((i-1)*4))& 0x0000000f];
  472. }
  473. UART_send_buffer[length++] = ‘\n‘;
  474. UART_send_buffer[length++] = ‘\r‘;
  475. }
  476. else
  477. break;
  478. }
  479. return length;
  480. }
  481. void Delay(uint32_t nTime)
  482. {
  483. Gb_TimingDelay = nTime;
  484. while(Gb_TimingDelay != 0);
  485. }
  486. void SysTick_Handler(void)
  487. {
  488. if (Gb_TimingDelay != 0x00)
  489. {
  490. Gb_TimingDelay--;
  491. }
  492. }

运行结果：

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-08-29 16:38:11

CAN控制器-配置过滤器的相关文章

struct2配置过滤器，以及通配符的问题

配置过滤器出了问题 我的web配置的过滤器是 <filter> <filter-name>struts2</filter-name> <filter-class> org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter </filter-class> </filter> 然后就出现了如下问题: java.lang.ClassNotFoundExcept

springboot环境下配置过滤器和拦截器

以前我们在配置过滤器和拦截器的时候,都是一个类继承一个接口,然后在xml中配置一下就ok 但是,但是,这是springboot的环境,没有xml的配置.所以我们还要继续学习啊啊啊啊啊~~~~~ 先简单大致说明一下,过滤器我们可以直接在类上加上@Component注解实现,但是有些参数啥的还是不好配置,还是需要一个配置文件来搞,所以,spring给我们提供了一个注解,就相当于xml,然后每个方法返回一个对象用@Bean来标注,相当于<bean></bean>注解   看代码吧 Tim

angualrjs学习总结二(作用域、控制器、过滤器)

一:Scope简介 Scope(作用域) 是应用在 HTML (视图) 和 JavaScript (控制器)之间的纽带.Scope 是一个对象,有可用的方法和属性.Scope 可应用在视图和控制器上.举例:<!doctype html><html> <head> <script src="http://apps.bdimg.com/libs/angular.js/1.4.6/angular.min.js"> </script>

Spring入门程序-前端控制器配置器

1,处理器的第二种配置方式 <!--配置handler --> <bean id="/FirstController" class="com.songyan.controller.FirstController"></bean> <bean id="logoon" class="com.songyan.controller.LoginHandler"> </bean>

MVC中Spring.net 对基类控制器无效 过滤器控制器无效

比如现在我又一个BaseController作为基类控制器,用于过滤权限.登录判断等作用,其它控制由原本的继承Controller,改为继承BaseController.然后BaseController重写Controller中方法OnActionExecuting 当我们此时再访问 User控制器下的某个Action,那么问题就来了,服务器会先执行BaseController中的OnActionExecuting方法,而此时,iu并没有由spring.net创建!!依旧为null 经过几次测试

配置过滤器解决中文乱码问题

<!-- 字符集过滤器 -->      <filter>          <filter-name>Charset</filter-name>          <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>            <init-param>              <param

shiro 的 web.xml 和 spring-context.xml 配置过滤器名称与 bean ID相同

shiro 源码 , 启动会去加载这个授权过滤器代理类的 filter name 的 bean,如果没有则报错.至于为什么要去加载这个 bean ,因为用到这个类,至于在哪里用到,未完待续. 原文地址:https://www.cnblogs.com/yangzihong/p/11595917.html

Druid监控必须配置过滤器

参考外链 2 3 4 5 6 7 8 9 10 11 12 <filter>     <filter-name>DruidWebStatFilter</filter-name>     <filter-class>com.alibaba.druid.support.http.WebStatFilter</filter-class>     <init-param>         <param-name>exclusion

tiny210(S5PV210)LCD控制器RGB配置相关学习记录

最近在弄210LCD的配置,在这里记录下一些学习的东西,有错恳请指正,互相学习. datasheet里面有好多名词,先记录一下一些名词的大概意思: alpha blending:本来采用R.G.B三通道来表示颜色,但是显示控制器分为5个图层,故图层混合时需要按照一定的比例因子来混合以实现图层的透明度,而不至于将背景图层完全覆盖掉,现在增加alpha通道来作为那个颜色混合时的调节因子,配置相关的设置后,透过调节alpha值则可以实现图层间透明度的控制,而所谓的透明度,相当于是两图层的按照不同的合成