首先简单介绍一下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. }

运行结果：

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

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

    以前我们在配置过滤器和拦截器的时候,都是一个类继承一个接口,然后在xml中配置一下就ok 但是,但是,这是springboot的环境,没有xml的配置.所以我们还要继续学习啊啊啊啊啊~~~~~ 先简单 ...

  2. springboot 配置过滤器

    能配置例外 先写配置文件类 FilterConfig.java package com.ty.tyzxtj.config; import javax.servlet.Filter; import or ...

  3. springboot配置过滤器和拦截器

    import javax.servlet.*; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.Http ...

  4. Spring Boot配置过滤器的两种方式

    过滤器(Filter)是Servlet中常用的技术,可以实现用户在访问某个目标资源之前,对访问的请求和响应进行拦截,常用的场景有登录校验.权限控制.敏感词过滤等,下面介绍下Spring Boot配置过 ...

  5. 使用SpringBoot的方式配置过滤器

    springboot 不存在web.xml 那么如何配置过滤器呢 springboot提供了一种方式 通过spring容器配置 @Bean public FilterRegistrationBean ...

  6. CAS学习笔记三：SpringBoot自动配置与手动配置过滤器方式集成CAS客户端

    本文目标 基于SpringBoot + Maven 分别使用自动配置与手动配置过滤器方式集成CAS客户端. 需要提前搭建 CAS 服务端,参考 https://www.cnblogs.com/hell ...

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

    一:Scope简介 Scope(作用域) 是应用在 HTML (视图) 和 JavaScript (控制器)之间的纽带.Scope 是一个对象,有可用的方法和属性.Scope 可应用在视图和控制器上. ...

  8. springboot中配置过滤器以及可能出现的问题

    在springboot添加过滤器有两种方式: 1.通过创建FilterRegistrationBean的方式(建议使用此种方式,统一管理,且通过注解的方式若不是本地调试,如果在filter中需要增加c ...

  9. Cisco无线控制器配置Radius

    使用Cisco无线控制器管理AP,配置Radius服务器,用于企业加密wifi的认证. 结合上一篇文档进行操作: http://www.cnblogs.com/helloworldtoyou/p/80 ...

随机推荐

  1. 所不为人知的Python装饰器

    装饰器可以说是Python中非常重要的特性之一.有些人要么从没使用过装饰器,要么就是对装饰器的使用一知半解.也有些人觉得装饰器很简单:"装饰器不就是那些把函数作为参数并输出一个函数的函数&q ...

  2. Axure的中继器如何实现两个列表之间的交互

    Axure RP 8安装包+注册码+中文语言包下载地址如下: 链接: https://pan.baidu.com/s/1nwRnCUl 密码: yy36 将中文语言包下的lang文件夹直接放在安装Ax ...

  3. 排序算法之low B三人组

    排序low B三人组 列表排序:将无序列表变成有充列表 应用场景:各种榜单,各种表格,给二分法排序使用,给其他算法使用 输入无序列表,输出有序列表(升序或降序) 排序low B三人组 1. 冒泡排序 ...

  4. cookie和session的那些事

    对于经常网购的朋友来说,经常会遇到一种情况: 打开淘宝或京东商城的首页,输入个人账号和密码进行登陆,然后进行购物,支付等操作都不需要用户再次输入用户名和密码 但是如果用户换一个浏览器或者等几个小时后再 ...

  5. iOS-FMDB事务【批量更新数据】

    打开数据库(sqlite) ///打开数据库 + (BOOL)openDataBase{ _TYDatabase = [[FMDatabase alloc]initWithPath:[self dat ...

  6. Android图像处理 - 高斯模糊的原理及实现

    欢迎大家前往云+社区,获取更多腾讯海量技术实践干货哦~ 由 天天P图攻城狮 发布在云+社区 作者简介:damonxia(夏正冬),天天P图Android工程师 前言 高斯模糊是图像处理中几乎每个程序员 ...

  7. 洛谷 [P1024]一元三次方程求解

    一道水题然而坑点很多. #include <iostream> #include <cstdio> #include <algorithm> #include &l ...

  8. BZOJ 3168: [Heoi2013]钙铁锌硒维生素 [线性基 Hungary 矩阵求逆]

    3168: [Heoi2013]钙铁锌硒维生素 题意:给一个线性无关组A,再给一个B,要为A中每个向量在B中选一个可以代替的向量,替换后仍然线性无关.判断可行和求字典序最小的解 PoPoQQQ orz ...

  9. BZOJ 3622: 已经没有什么好害怕的了 [容斥原理 DP]

    3622: 已经没有什么好害怕的了 题意:和我签订契约,成为魔法少女吧 真·题意:零食魔女夏洛特的结界里有糖果a和药片b各n个,两两配对,a>b的配对比b>a的配对多k个学姐就可能获胜,求 ...

  10. BZOJ 1982: [Spoj 2021]Moving Pebbles [博弈论 对称]

    给你N堆Stone,两个人玩游戏. 每次任选一堆,首先拿掉至少一个石头,然后移动任意个石子到任意堆中. 谁不能移动了,谁就输了... 以前在poj做过已经忘记了... 构造对称,选最多的一堆往其他堆分 ...