首先简单介绍一下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. CSS核心内容之盒子模型

    1.盒子模型具有的属性: 内容(content) 填充(padding) 边框(border) 边界(margin) 图示如下: 2.流概念 1.流的概念 在现实生活中已经流水,在网页设计中就是指元素 ...

  2. 新人如何运行Faster RCNN的tensorflow代码

    0.目的 刚刚学习faster rcnn目标检测算法,在尝试跑通github上面Xinlei Chen的tensorflow版本的faster rcnn代码时候遇到很多问题(我真是太菜),代码地址如下 ...

  3. win7 MySQL Connector/Net 安装卸载问题

    问题1:卸载MySQL Connector Net 6.9.9 卸载程序无法卸载 方法:注册表搜索 MySQL Connector Net 6.9.9 全部删除 ******************* ...

  4. ettercap+urlsnarf+driftnet+wireshark监听妹子上网

    搞事肯定得确认目标.所以我们得先确认一个目标 确认目标这种事情不多说.   1.开启IP转发 echo 1 > /proc/sys/net/ipv4/ip_forward 然后ettercap ...

  5. 【linux之bash】

    bash的发展 1974年 贝尔实验室 Bourne Bourne Shell --> Bsh.sh 1978年 berke bill jey C shell --> Csh tcsh 8 ...

  6. linux下双网卡的绑定

    如果服务器上有两快网卡就可以把它绑定为一块虚拟的网卡,如果一块网卡坏了另一块还可以继续工作,增加了冗余度和负载,具体做法如下: 新建一个虚拟的网卡,命令如下: iv /etc/sysconfig/ne ...

  7. Android 文件下载三种基本方式

    一.自己封装URLConnection 连接请求类 public void downloadFile1() { try{ //下载路径,如果路径无效了,可换成你的下载路径 String url = & ...

  8. C# 使用 SmtpClient 发送邮件注意项

    最近有邮件发送需求,使用 C#  SmtpClient 对象发送邮件 , 报异常, 如下错误代码: 调整代码顺序后,发送邮件成功! 注意:一定要先设置 EnableSsl和UseDefaultCred ...

  9. 项目构建工具Maven

  10. 测试任务汇总v1.0

    2017.08.04 整理了目前我们所在团队需要做的日常任务 定义为v1.0