├── README.md
├── bit_parse.c
├── bit_parse.h
├── can_ctl.c
├── can_ctl.h
├── sync_task.c
├── timing_task.c
└── timing_task.h
/README.md:
--------------------------------------------------------------------------------
1 | # raw_can
2 | A software implemented can bus controller.
3 | Now is run in a freescale(NXP) K60 chip, system clock is 96Mhz.
4 | The can bus can run at bitrate 20Kb.
5 | Becareful most CAN transceiver have a low bitrate limite, such as TJA1050 minimum rate 20Kb.
6 | # use
7 | It can be used to understand the principle of the CAN bus.
8 | It can be used in some applications that are cost sensitive and are not high for transmission rates, such as replacing some of the original RS485 based applications.
9 | It can be used as data transmission between multiple CPU on board, using open - out output, and not using CAN transceiver.
10 | A custom protocol based on CAN protocol can be used to communicate, increasing the complexity of the system and improving the difficulty of solving the problem.
11 |
12 | # 软件CAN控制器
13 | 这是一个软件实现的CAN控制器。
14 | 当前是运行在飞思卡尔K60处理器上，时钟96MHz。
15 | CAN速率运行在20Kb（理论上最高可以到40Kb）。
16 | 需要注意的是，很多CAN收发器有一个最低速率的限制，比如tja1050限制最低速率为20Kb。
17 | # 用处
18 | 可以用来深入理解CAN总线的原理。
19 | 可以用在一些对成本敏感，对传输速率要求不高的应用中，比如替换一些原来基于RS485的应用中。
20 | 可以用作板上多CPU之间的数据传输，使用开漏输出，不使用CAN收发器。
21 | 可以基于CAN协议自定义协议用于通讯，增加系统的复杂度，提高破解难度。
22 |
23 |
--------------------------------------------------------------------------------
/bit_parse.c:
--------------------------------------------------------------------------------
1 | #ifndef BIT_PARSE_C_
2 | #define BIT_PARSE_C_
3 | #endif
4 | #include "sf_Driver.h"
5 | #include "bit_parse.h"
6 |
7 | #pragma define_section code_in_ram ".app_code_ram" abs32 RWX
8 | #pragma section code_in_ram begin
9 |
10 | uint8 can_bit_stuff(TY_BIT_RX_PARSE *p_parse, uint8 bit_val);
11 |
12 |
13 | uint16 can_crc(uint16 crc, uint8 bit)
14 | {
15 | uint16 tmp;
16 |
17 | tmp = bit;
18 | tmp <<= 14;
19 | tmp = tmp^crc;
20 | tmp &= (1<<14);
21 | if(tmp)
22 | tmp = 0x4599;
23 | else
24 | tmp = 0x0000;
25 |
26 | crc <<= 1;
27 |
28 | crc = crc^tmp;
29 | crc &= 0x7fff;
30 |
31 | return crc;
32 | }
33 |
34 | /// 计算CAN报文的CRC
35 | /// 1、SOF不参与计算
36 | /// @param p_frame [i]接收到的CAN报文
37 | /// @retval 计算出来的CRC结果
38 | uint16 can_frame_crc(TY_CAN_FRM *p_frame)
39 | {
40 | TY_CAN_FRM tmp = *p_frame;
41 | uint16 crc=0;
42 | uint8 bit;
43 | uint8 cnt, loop;
44 |
45 | for(cnt=0; cnt<11; cnt++)
46 | {
47 | if(tmp.id & 0x10000000)
48 | {
49 | bit = 1;
50 | }
51 | else
52 | {
53 | bit = 0;
54 | }
55 | tmp.id <<= 1;
56 | crc = can_crc(crc, bit);
57 | }
58 |
59 | for(cnt=0; cnt<1; cnt++)
60 | {
61 | if(tmp.flag & F_SRR)
62 | {
63 | bit = 1;
64 | }
65 | else
66 | {
67 | bit = 0;
68 | }
69 | crc = can_crc(crc, bit);
70 | }
71 |
72 | for(cnt=0; cnt<1; cnt++)
73 | {
74 | if(tmp.flag & F_IDE)
75 | {
76 | bit = 1;
77 | }
78 | else
79 | {
80 | bit = 0;
81 | }
82 | crc = can_crc(crc, bit);
83 | }
84 |
85 | for(cnt=0; cnt<18; cnt++)
86 | {
87 | if(tmp.id & 0x10000000)
88 | {
89 | bit = 1;
90 | }
91 | else
92 | {
93 | bit = 0;
94 | }
95 | tmp.id <<= 1;
96 | crc = can_crc(crc, bit);
97 | }
98 |
99 | for(cnt=0; cnt<1; cnt++)
100 | {
101 | if(tmp.flag & F_RTR)
102 | {
103 | bit = 1;
104 | }
105 | else
106 | {
107 | bit = 0;
108 | }
109 | crc = can_crc(crc, bit);
110 | }
111 |
112 | for(cnt=0; cnt<1; cnt++)
113 | {
114 | if(tmp.flag & F_R0)
115 | {
116 | bit = 1;
117 | }
118 | else
119 | {
120 | bit = 0;
121 | }
122 | crc = can_crc(crc, bit);
123 | }
124 |
125 | for(cnt=0; cnt<1; cnt++)
126 | {
127 | if(tmp.flag & F_R1)
128 | {
129 | bit = 1;
130 | }
131 | else
132 | {
133 | bit = 0;
134 | }
135 | crc = can_crc(crc, bit);
136 | }
137 |
138 | for(cnt=0; cnt<4; cnt++)
139 | {
140 | if(tmp.len & 0x08)
141 | {
142 | bit = 1;
143 | }
144 | else
145 | {
146 | bit = 0;
147 | }
148 | tmp.len <<= 1;
149 | crc = can_crc(crc, bit);
150 | }
151 |
152 | for(cnt=0; cnt<8; cnt++)
153 | {
154 | for(loop=0; loop<8; loop++)
155 | {
156 | if(tmp.dat[cnt] & 0x80)
157 | {
158 | bit = 1;
159 | }
160 | else
161 | {
162 | bit = 0;
163 | }
164 | tmp.dat[cnt] <<= 1;
165 | crc = can_crc(crc, bit);
166 | }
167 | }
168 | return crc;
169 | }
170 |
171 | void bit_rx_parse_init(TY_BIT_RX_PARSE *p_parse)
172 | {
173 | memset(p_parse, 0, sizeof(TY_BIT_RX_PARSE));
174 | }
175 |
176 | void bit_rx_parse_rst(TY_BIT_RX_PARSE *p_parse)
177 | {
178 | p_parse->valid_bit_st = BIT_IDLE;
179 | p_parse->frm_parse_st = 0;
180 | }
181 |
182 | /// 输入若干个bit，解析出can报文，现在实际只处理一位
183 | /// 1、剔除填充位
184 | /// 2、使用状态机对有效bit流进行处理
185 | /// 3、通过返回值+p_parse结构体的信息可以得到当前解码的详细状态
186 | /// @param p_parse [io]解析器句柄
187 | /// @param p_bit [i] bit流缓冲区
188 | /// @param bit_num [i] bit数
189 | /// @param p_can_frm [o] CAN帧缓冲区
190 | /// @param p_can_frm_num [io]输入是CAN帧缓冲区的大小，输出是解码出来的CAN帧的个数
191 | /// @retval true 接收到CRC界定符（接收完毕）
192 | /// @retval false 其他情况
193 | //#define BIT_RX_PARSE_TM
194 | //#define BIT_RX_PARSE_TS
195 | bool bit_rx_parse(TY_BIT_RX_PARSE *p_parse, uint8 bit_val)
196 | {
197 | #ifdef BIT_RX_PARSE_TM
198 | uint32 stat = (p_parse->valid_bit_st<<8)+p_parse->frm_parse_st;
199 | uint32 tm_probe;
200 | #endif
201 | bool res=false;
202 |
203 | #ifdef BIT_RX_PARSE_TM
204 | tm_probe = getTimeTicks();
205 | #endif
206 |
207 | p_parse->valid_bit = 0;
208 | // remove the stuff bit
209 | switch(p_parse->valid_bit_st)
210 | {
211 | case BIT_IDLE:
212 | if(bit_val)
213 | {
214 | p_parse->frm_parse_st = 0;
215 | p_parse->valid_bit_st = BIT_IDLE;
216 | }
217 | else
218 | {
219 | p_parse->valid_bit_st = BIT_L_1;
220 | }
221 | break;
222 | case BIT_H_1: // have rx 1 bit 1
223 | if(bit_val)
224 | p_parse->valid_bit_st = BIT_H_2;
225 | else
226 | p_parse->valid_bit_st = BIT_L_1;
227 | break;
228 | case BIT_H_2:
229 | if(bit_val)
230 | p_parse->valid_bit_st = BIT_H_3;
231 | else
232 | p_parse->valid_bit_st = BIT_L_1;
233 | break;
234 | case BIT_H_3:
235 | if(bit_val)
236 | p_parse->valid_bit_st = BIT_H_4;
237 | else
238 | p_parse->valid_bit_st = BIT_L_1;
239 | break;
240 | case BIT_H_4: // have rx 4 bit 1
241 | if(bit_val)
242 | p_parse->valid_bit_st = BIT_H_5;
243 | else
244 | p_parse->valid_bit_st = BIT_L_1;
245 | break;
246 | case BIT_H_5: // have rx 5 bit 1
247 | // rx 6 bit 1 means bus in idle
248 | // rx 5 bit 1 then rx bit 0 means bit 0 is a stuff bit
249 | if(bit_val)
250 | {
251 | p_parse->error |= ERR_BIT1;
252 | p_parse->frm_parse_st = 0;
253 | p_parse->valid_bit_st = BIT_IDLE;
254 | }
255 | else
256 | {
257 | p_parse->valid_bit_st = BIT_L_1;
258 | p_parse->stf_bit = 1;
259 | #ifdef BIT_RX_PARSE_TM
260 | tm_probe = tm_probe-getTimeTicks();
261 | if(p_parse->tm_max < tm_probe)
262 | {
263 | p_parse->tm_max_stat = stat;
264 | p_parse->tm_max = tm_probe;
265 | }
266 | #endif
267 | return false;
268 | }
269 | break;
270 | case BIT_L_1:
271 | if(!bit_val)
272 | p_parse->valid_bit_st = BIT_L_2;
273 | else
274 | p_parse->valid_bit_st = BIT_H_1;
275 | break;
276 | case BIT_L_2:
277 | if(!bit_val)
278 | p_parse->valid_bit_st = BIT_L_3;
279 | else
280 | p_parse->valid_bit_st = BIT_H_1;
281 | break;
282 | case BIT_L_3:
283 | if(!bit_val)
284 | p_parse->valid_bit_st = BIT_L_4;
285 | else
286 | p_parse->valid_bit_st = BIT_H_1;
287 | break;
288 | case BIT_L_4:
289 | if(!bit_val)
290 | p_parse->valid_bit_st = BIT_L_5;
291 | else
292 | p_parse->valid_bit_st = BIT_H_1;
293 | break;
294 | case BIT_L_5:
295 | // rx 6 bit 0 means bus in error
296 | // rx 5 bit 0 then rx bit 1 means bit 1 is a stuff bit
297 | if(!bit_val)
298 | {
299 | p_parse->error |= ERR_BIT0;
300 | p_parse->frm_parse_st = 0;
301 | p_parse->valid_bit_st = BIT_L_5;
302 | }
303 | else
304 | {
305 | p_parse->valid_bit_st = BIT_H_1;
306 | p_parse->stf_bit = 1;
307 | #ifdef BIT_RX_PARSE_TM
308 | tm_probe = tm_probe-getTimeTicks();
309 | if(p_parse->tm_max < tm_probe)
310 | {
311 | p_parse->tm_max_stat = stat;
312 | p_parse->tm_max = tm_probe;
313 | }
314 | #endif
315 | return false;
316 | }
317 | break;
318 | default:
319 | p_parse->error |= ERR_SM_BIT;
320 | p_parse->frm_parse_st = 0;
321 | p_parse->valid_bit_st = BIT_IDLE;
322 | break;
323 | }
324 | p_parse->stf_bit = 0;
325 | p_parse->valid_bit = 1;
326 |
327 | switch(p_parse->frm_parse_st)
328 | {
329 | case 0:
330 | // SOF
331 | p_parse->valid_bit = 0;
332 | if(bit_val)
333 | {
334 | ;
335 | }
336 | else
337 | {
338 | p_parse->frm_parse_st = 1;
339 | }
340 | break;
341 | case 1:
342 | // EX-ID 28, BASE-ID 10
343 | p_parse->can_frm.id = 0;
344 | if(bit_val)
345 | {
346 | p_parse->can_frm.id |= 0x00000400;
347 | }
348 | else
349 | {
350 | p_parse->can_frm.id &= 0xfffffbff;
351 | }
352 | p_parse->frm_parse_st = 2;
353 | break;
354 | case 2:
355 | // EX-ID 27, BASE-ID 9
356 | if(bit_val)
357 | {
358 | p_parse->can_frm.id |= 0x00000200;
359 | }
360 | else
361 | {
362 | p_parse->can_frm.id &= 0xfffffdff;
363 | }
364 | p_parse->frm_parse_st = 3;
365 | break;
366 | case 3:
367 | // EX-ID 26, BASE-ID 8
368 | if(bit_val)
369 | {
370 | p_parse->can_frm.id |= 0x00000100;
371 | }
372 | else
373 | {
374 | p_parse->can_frm.id &= 0xfffffeff;
375 | }
376 | p_parse->frm_parse_st = 4;
377 | break;
378 | case 4:
379 | // EX-ID 25, BASE-ID 7
380 | if(bit_val)
381 | {
382 | p_parse->can_frm.id |= 0x00000080;
383 | }
384 | else
385 | {
386 | p_parse->can_frm.id &= 0xffffff7f;
387 | }
388 | p_parse->frm_parse_st = 5;
389 | break;
390 | case 5:
391 | // EX-ID 24, BASE-ID 6
392 | if(bit_val)
393 | {
394 | p_parse->can_frm.id |= 0x00000040;
395 | }
396 | else
397 | {
398 | p_parse->can_frm.id &= 0xffffffbf;
399 | }
400 | p_parse->frm_parse_st = 6;
401 | break;
402 | case 6:
403 | // EX-ID 23, BASE-ID 5
404 | if(bit_val)
405 | {
406 | p_parse->can_frm.id |= 0x00000020;
407 | }
408 | else
409 | {
410 | p_parse->can_frm.id &= 0xffffffdf;
411 | }
412 | p_parse->frm_parse_st = 7;
413 | break;
414 | case 7:
415 | // EX-ID 22, BASE-ID 4
416 | if(bit_val)
417 | {
418 | p_parse->can_frm.id |= 0x00000010;
419 | }
420 | else
421 | {
422 | p_parse->can_frm.id &= 0xffffffef;
423 | }
424 | p_parse->frm_parse_st = 8;
425 | break;
426 | case 8:
427 | // EX-ID 21, BASE-ID 3
428 | if(bit_val)
429 | {
430 | p_parse->can_frm.id |= 0x00000008;
431 | }
432 | else
433 | {
434 | p_parse->can_frm.id &= 0xfffffff7;
435 | }
436 | p_parse->frm_parse_st = 9;
437 | break;
438 | case 9:
439 | // EX-ID 20, BASE-ID 2
440 | if(bit_val)
441 | {
442 | p_parse->can_frm.id |= 0x00000004;
443 | }
444 | else
445 | {
446 | p_parse->can_frm.id &= 0xfffffffb;
447 | }
448 | p_parse->frm_parse_st = 10;
449 | break;
450 | case 10:
451 | // EX-ID 19, BASE-ID 1
452 | if(bit_val)
453 | {
454 | p_parse->can_frm.id |= 0x00000002;
455 | }
456 | else
457 | {
458 | p_parse->can_frm.id &= 0xfffffffd;
459 | }
460 | p_parse->frm_parse_st = 11;
461 | break;
462 | case 11:
463 | // EX-ID 18, BASE-ID 0
464 | if(bit_val)
465 | {
466 | p_parse->can_frm.id |= 0x00000001;
467 | }
468 | else
469 | {
470 | p_parse->can_frm.id &= 0xfffffffe;
471 | }
472 | p_parse->frm_parse_st = 12;
473 | break;
474 | case 12:
475 | // SRR
476 | if(bit_val)
477 | {
478 | p_parse->can_frm.flag |= F_SRR;
479 | }
480 | else
481 | {
482 | p_parse->can_frm.flag &= ~F_SRR;
483 | }
484 | p_parse->frm_parse_st = 13;
485 | break;
486 | case 13:
487 | // IDE
488 | if(bit_val)
489 | {
490 | p_parse->can_frm.flag |= F_IDE;
491 | p_parse->can_frm.id <<= 18;
492 | p_parse->frm_parse_st = 14;
493 | }
494 | else
495 | {
496 | p_parse->can_frm.flag &= ~F_IDE;
497 | p_parse->frm_parse_st = 32;
498 | }
499 | break;
500 | case 14:
501 | // EX-ID 17
502 | if(bit_val)
503 | {
504 | p_parse->can_frm.id |= 0x00020000;
505 | }
506 | else
507 | {
508 | p_parse->can_frm.id &= 0xfffdffff;
509 | }
510 | p_parse->frm_parse_st = 15;
511 | break;
512 | case 15:
513 | // EX-ID 16
514 | if(bit_val)
515 | {
516 | p_parse->can_frm.id |= 0x00010000;
517 | }
518 | else
519 | {
520 | p_parse->can_frm.id &= 0xfffeffff;
521 | }
522 | p_parse->frm_parse_st = 16;
523 | break;
524 | case 16:
525 | // EX-ID 15
526 | if(bit_val)
527 | {
528 | p_parse->can_frm.id |= 0x00008000;
529 | }
530 | else
531 | {
532 | p_parse->can_frm.id &= 0xffff7fff;
533 | }
534 | p_parse->frm_parse_st = 17;
535 | break;
536 | case 17:
537 | // EX-ID 14
538 | if(bit_val)
539 | {
540 | p_parse->can_frm.id |= 0x00004000;
541 | }
542 | else
543 | {
544 | p_parse->can_frm.id &= 0xffffbfff;
545 | }
546 | p_parse->frm_parse_st = 18;
547 | break;
548 | case 18:
549 | // EX-ID 13
550 | if(bit_val)
551 | {
552 | p_parse->can_frm.id |= 0x00002000;
553 | }
554 | else
555 | {
556 | p_parse->can_frm.id &= 0xffffdfff;
557 | }
558 | p_parse->frm_parse_st = 19;
559 | break;
560 | case 19:
561 | // EX-ID 12
562 | if(bit_val)
563 | {
564 | p_parse->can_frm.id |= 0x00001000;
565 | }
566 | else
567 | {
568 | p_parse->can_frm.id &= 0xffffefff;
569 | }
570 | p_parse->frm_parse_st = 20;
571 | break;
572 | case 20:
573 | // EX-ID 11
574 | if(bit_val)
575 | {
576 | p_parse->can_frm.id |= 0x00000800;
577 | }
578 | else
579 | {
580 | p_parse->can_frm.id &= 0xfffff7ff;
581 | }
582 | p_parse->frm_parse_st = 21;
583 | break;
584 | case 21:
585 | // EX-ID 10
586 | if(bit_val)
587 | {
588 | p_parse->can_frm.id |= 0x00000400;
589 | }
590 | else
591 | {
592 | p_parse->can_frm.id &= 0xfffffbff;
593 | }
594 | p_parse->frm_parse_st = 22;
595 | break;
596 | case 22:
597 | // EX-ID 9
598 | if(bit_val)
599 | {
600 | p_parse->can_frm.id |= 0x00000200;
601 | }
602 | else
603 | {
604 | p_parse->can_frm.id &= 0xfffffdff;
605 | }
606 | p_parse->frm_parse_st = 23;
607 | break;
608 | case 23:
609 | // EX-ID 8
610 | if(bit_val)
611 | {
612 | p_parse->can_frm.id |= 0x00000100;
613 | }
614 | else
615 | {
616 | p_parse->can_frm.id &= 0xfffffeff;
617 | }
618 | p_parse->frm_parse_st = 24;
619 | break;
620 | case 24:
621 | // EX-ID 7
622 | if(bit_val)
623 | {
624 | p_parse->can_frm.id |= 0x00000080;
625 | }
626 | else
627 | {
628 | p_parse->can_frm.id &= 0xffffff7f;
629 | }
630 | p_parse->frm_parse_st = 25;
631 | break;
632 | case 25:
633 | // EX-ID 6
634 | if(bit_val)
635 | {
636 | p_parse->can_frm.id |= 0x00000040;
637 | }
638 | else
639 | {
640 | p_parse->can_frm.id &= 0xffffffbf;
641 | }
642 | p_parse->frm_parse_st = 26;
643 | break;
644 | case 26:
645 | // EX-ID 5
646 | if(bit_val)
647 | {
648 | p_parse->can_frm.id |= 0x00000020;
649 | }
650 | else
651 | {
652 | p_parse->can_frm.id &= 0xffffffdf;
653 | }
654 | p_parse->frm_parse_st = 27;
655 | break;
656 | case 27:
657 | // EX-ID 4
658 | if(bit_val)
659 | {
660 | p_parse->can_frm.id |= 0x00000010;
661 | }
662 | else
663 | {
664 | p_parse->can_frm.id &= 0xffffffef;
665 | }
666 | p_parse->frm_parse_st = 28;
667 | break;
668 | case 28:
669 | // EX-ID 3
670 | if(bit_val)
671 | {
672 | p_parse->can_frm.id |= 0x00000008;
673 | }
674 | else
675 | {
676 | p_parse->can_frm.id &= 0xfffffff7;
677 | }
678 | p_parse->frm_parse_st = 29;
679 | break;
680 | case 29:
681 | // EX-ID 2
682 | if(bit_val)
683 | {
684 | p_parse->can_frm.id |= 0x00000004;
685 | }
686 | else
687 | {
688 | p_parse->can_frm.id &= 0xfffffffb;
689 | }
690 | p_parse->frm_parse_st = 30;
691 | break;
692 | case 30:
693 | // EX-ID 1
694 | if(bit_val)
695 | {
696 | p_parse->can_frm.id |= 0x00000002;
697 | }
698 | else
699 | {
700 | p_parse->can_frm.id &= 0xfffffffd;
701 | }
702 | p_parse->frm_parse_st = 31;
703 | break;
704 | case 31:
705 | // EX-ID 0
706 | if(bit_val)
707 | {
708 | p_parse->can_frm.id |= 0x00000001;
709 | }
710 | else
711 | {
712 | p_parse->can_frm.id &= 0xfffffffe;
713 | }
714 | p_parse->frm_parse_st = 32;
715 | break;
716 | case 32:
717 | // F_RTR
718 | if(bit_val)
719 | {
720 | p_parse->can_frm.flag |= F_RTR;
721 | }
722 | else
723 | {
724 | p_parse->can_frm.flag &= ~F_RTR;
725 | }
726 | p_parse->frm_parse_st = 33;
727 | break;
728 | case 33:
729 | // F_R0
730 | if(bit_val)
731 | {
732 | p_parse->can_frm.flag |= F_R0;
733 | }
734 | else
735 | {
736 | p_parse->can_frm.flag &= ~F_R0;
737 | }
738 | p_parse->frm_parse_st = 34;
739 | break;
740 | case 34:
741 | // F_R1
742 | if(bit_val)
743 | {
744 | p_parse->can_frm.flag |= F_R1;
745 | }
746 | else
747 | {
748 | p_parse->can_frm.flag &= ~F_R1;
749 | }
750 | p_parse->frm_parse_st = 35;
751 | break;
752 | case 35:
753 | // LEN bit 3
754 | p_parse->can_frm.len = 0;
755 | if(bit_val)
756 | {
757 | p_parse->can_frm.len |= 0x08;
758 | }
759 | else
760 | {
761 | p_parse->can_frm.len &= 0xf7;
762 | }
763 | p_parse->frm_parse_st = 36;
764 | break;
765 | case 36:
766 | // LEN bit 2
767 | if(bit_val)
768 | {
769 | p_parse->can_frm.len |= 0x04;
770 | }
771 | else
772 | {
773 | p_parse->can_frm.len &= 0xfb;
774 | }
775 | p_parse->frm_parse_st = 37;
776 | break;
777 | case 37:
778 | // LEN bit 1
779 | if(bit_val)
780 | {
781 | p_parse->can_frm.len |= 0x02;
782 | }
783 | else
784 | {
785 | p_parse->can_frm.len &= 0xfd;
786 | }
787 | p_parse->frm_parse_st = 38;
788 | break;
789 | case 38:
790 | // LEN bit 0
791 | if(bit_val)
792 | {
793 | p_parse->can_frm.len |= 0x01;
794 | }
795 | else
796 | {
797 | p_parse->can_frm.len &= 0xfe;
798 | }
799 | if(0 == p_parse->can_frm.len)
800 | {
801 | p_parse->frm_parse_st = 103;
802 | }
803 | else if(8 >= p_parse->can_frm.len)
804 | {
805 | p_parse->frm_parse_st = 39;
806 | }
807 | else
808 | {
809 | p_parse->frm_parse_st = 0;
810 | }
811 | break;
812 | case 39:
813 | // DATA 0 bit 7
814 | if(bit_val)
815 | {
816 | p_parse->can_frm.dat[0] |= 0x80;
817 | }
818 | else
819 | {
820 | p_parse->can_frm.dat[0] &= 0x7f;
821 | }
822 | p_parse->frm_parse_st = 40;
823 | break;
824 | case 40:
825 | // DATA 0 bit 6
826 | if(bit_val)
827 | {
828 | p_parse->can_frm.dat[0] |= 0x40;
829 | }
830 | else
831 | {
832 | p_parse->can_frm.dat[0] &= 0xbf;
833 | }
834 | p_parse->frm_parse_st = 41;
835 | break;
836 | case 41:
837 | // DATA 0 bit 5
838 | if(bit_val)
839 | {
840 | p_parse->can_frm.dat[0] |= 0x20;
841 | }
842 | else
843 | {
844 | p_parse->can_frm.dat[0] &= 0xdf;
845 | }
846 | p_parse->frm_parse_st = 42;
847 | break;
848 | case 42:
849 | // DATA 0 bit 4
850 | if(bit_val)
851 | {
852 | p_parse->can_frm.dat[0] |= 0x10;
853 | }
854 | else
855 | {
856 | p_parse->can_frm.dat[0] &= 0xef;
857 | }
858 | p_parse->frm_parse_st = 43;
859 | break;
860 | case 43:
861 | // DATA 0 bit 3
862 | if(bit_val)
863 | {
864 | p_parse->can_frm.dat[0] |= 0x08;
865 | }
866 | else
867 | {
868 | p_parse->can_frm.dat[0] &= 0xf7;
869 | }
870 | p_parse->frm_parse_st = 44;
871 | break;
872 | case 44:
873 | // DATA 0 bit 2
874 | if(bit_val)
875 | {
876 | p_parse->can_frm.dat[0] |= 0x04;
877 | }
878 | else
879 | {
880 | p_parse->can_frm.dat[0] &= 0xfb;
881 | }
882 | p_parse->frm_parse_st = 45;
883 | break;
884 | case 45:
885 | // DATA 0 bit 1
886 | if(bit_val)
887 | {
888 | p_parse->can_frm.dat[0] |= 0x02;
889 | }
890 | else
891 | {
892 | p_parse->can_frm.dat[0] &= 0xfd;
893 | }
894 | p_parse->frm_parse_st = 46;
895 | break;
896 | case 46:
897 | // DATA 0 bit 0
898 | if(bit_val)
899 | {
900 | p_parse->can_frm.dat[0] |= 0x01;
901 | }
902 | else
903 | {
904 | p_parse->can_frm.dat[0] &= 0xfe;
905 | }
906 | if(p_parse->can_frm.len > 1)
907 | {
908 | p_parse->frm_parse_st = 47;
909 | }
910 | else
911 | {
912 | p_parse->frm_parse_st = 103;
913 | }
914 | break;
915 | case 47:
916 | // DATA 1 bit 7
917 | if(bit_val)
918 | {
919 | p_parse->can_frm.dat[1] |= 0x80;
920 | }
921 | else
922 | {
923 | p_parse->can_frm.dat[1] &= 0x7f;
924 | }
925 | p_parse->frm_parse_st = 48;
926 | break;
927 | case 48:
928 | // DATA 1 bit 6
929 | if(bit_val)
930 | {
931 | p_parse->can_frm.dat[1] |= 0x40;
932 | }
933 | else
934 | {
935 | p_parse->can_frm.dat[1] &= 0xbf;
936 | }
937 | p_parse->frm_parse_st = 49;
938 | break;
939 | case 49:
940 | // DATA 1 bit 5
941 | if(bit_val)
942 | {
943 | p_parse->can_frm.dat[1] |= 0x20;
944 | }
945 | else
946 | {
947 | p_parse->can_frm.dat[1] &= 0xdf;
948 | }
949 | p_parse->frm_parse_st = 50;
950 | break;
951 | case 50:
952 | // DATA 1 bit 4
953 | if(bit_val)
954 | {
955 | p_parse->can_frm.dat[1] |= 0x10;
956 | }
957 | else
958 | {
959 | p_parse->can_frm.dat[1] &= 0xef;
960 | }
961 | p_parse->frm_parse_st = 51;
962 | break;
963 | case 51:
964 | // DATA 1 bit 3
965 | if(bit_val)
966 | {
967 | p_parse->can_frm.dat[1] |= 0x08;
968 | }
969 | else
970 | {
971 | p_parse->can_frm.dat[1] &= 0xf7;
972 | }
973 | p_parse->frm_parse_st = 52;
974 | break;
975 | case 52:
976 | // DATA 1 bit 2
977 | if(bit_val)
978 | {
979 | p_parse->can_frm.dat[1] |= 0x04;
980 | }
981 | else
982 | {
983 | p_parse->can_frm.dat[1] &= 0xfb;
984 | }
985 | p_parse->frm_parse_st = 53;
986 | break;
987 | case 53:
988 | // DATA 1 bit 1
989 | if(bit_val)
990 | {
991 | p_parse->can_frm.dat[1] |= 0x02;
992 | }
993 | else
994 | {
995 | p_parse->can_frm.dat[1] &= 0xfd;
996 | }
997 | p_parse->frm_parse_st = 54;
998 | break;
999 | case 54:
1000 | // DATA 1 bit 0
1001 | if(bit_val)
1002 | {
1003 | p_parse->can_frm.dat[1] |= 0x01;
1004 | }
1005 | else
1006 | {
1007 | p_parse->can_frm.dat[1] &= 0xfe;
1008 | }
1009 | if(p_parse->can_frm.len > 2)
1010 | {
1011 | p_parse->frm_parse_st = 55;
1012 | }
1013 | else
1014 | {
1015 | p_parse->frm_parse_st = 103;
1016 | }
1017 | break;
1018 | case 55:
1019 | // DATA 2 bit 7
1020 | if(bit_val)
1021 | {
1022 | p_parse->can_frm.dat[2] |= 0x80;
1023 | }
1024 | else
1025 | {
1026 | p_parse->can_frm.dat[2] &= 0x7f;
1027 | }
1028 | p_parse->frm_parse_st = 56;
1029 | break;
1030 | case 56:
1031 | // DATA 2 bit 6
1032 | if(bit_val)
1033 | {
1034 | p_parse->can_frm.dat[2] |= 0x40;
1035 | }
1036 | else
1037 | {
1038 | p_parse->can_frm.dat[2] &= 0xbf;
1039 | }
1040 | p_parse->frm_parse_st = 57;
1041 | break;
1042 | case 57:
1043 | // DATA 2 bit 5
1044 | if(bit_val)
1045 | {
1046 | p_parse->can_frm.dat[2] |= 0x20;
1047 | }
1048 | else
1049 | {
1050 | p_parse->can_frm.dat[2] &= 0xdf;
1051 | }
1052 | p_parse->frm_parse_st = 58;
1053 | break;
1054 | case 58:
1055 | // DATA 2 bit 4
1056 | if(bit_val)
1057 | {
1058 | p_parse->can_frm.dat[2] |= 0x10;
1059 | }
1060 | else
1061 | {
1062 | p_parse->can_frm.dat[2] &= 0xef;
1063 | }
1064 | p_parse->frm_parse_st = 59;
1065 | break;
1066 | case 59:
1067 | // DATA 2 bit 3
1068 | if(bit_val)
1069 | {
1070 | p_parse->can_frm.dat[2] |= 0x08;
1071 | }
1072 | else
1073 | {
1074 | p_parse->can_frm.dat[2] &= 0xf7;
1075 | }
1076 | p_parse->frm_parse_st = 60;
1077 | break;
1078 | case 60:
1079 | // DATA 2 bit 2
1080 | if(bit_val)
1081 | {
1082 | p_parse->can_frm.dat[2] |= 0x04;
1083 | }
1084 | else
1085 | {
1086 | p_parse->can_frm.dat[2] &= 0xfb;
1087 | }
1088 | p_parse->frm_parse_st = 61;
1089 | break;
1090 | case 61:
1091 | // DATA 2 bit 1
1092 | if(bit_val)
1093 | {
1094 | p_parse->can_frm.dat[2] |= 0x02;
1095 | }
1096 | else
1097 | {
1098 | p_parse->can_frm.dat[2] &= 0xfd;
1099 | }
1100 | p_parse->frm_parse_st = 62;
1101 | break;
1102 | case 62:
1103 | // DATA 2 bit 0
1104 | if(bit_val)
1105 | {
1106 | p_parse->can_frm.dat[2] |= 0x01;
1107 | }
1108 | else
1109 | {
1110 | p_parse->can_frm.dat[2] &= 0xfe;
1111 | }
1112 | if(p_parse->can_frm.len > 3)
1113 | {
1114 | p_parse->frm_parse_st = 63;
1115 | }
1116 | else
1117 | {
1118 | p_parse->frm_parse_st = 103;
1119 | }
1120 | break;
1121 | case 63:
1122 | // DATA 3 bit 7
1123 | if(bit_val)
1124 | {
1125 | p_parse->can_frm.dat[3] |= 0x80;
1126 | }
1127 | else
1128 | {
1129 | p_parse->can_frm.dat[3] &= 0x7f;
1130 | }
1131 | p_parse->frm_parse_st = 64;
1132 | break;
1133 | case 64:
1134 | // DATA 3 bit 6
1135 | if(bit_val)
1136 | {
1137 | p_parse->can_frm.dat[3] |= 0x40;
1138 | }
1139 | else
1140 | {
1141 | p_parse->can_frm.dat[3] &= 0xbf;
1142 | }
1143 | p_parse->frm_parse_st = 65;
1144 | break;
1145 | case 65:
1146 | // DATA 3 bit 5
1147 | if(bit_val)
1148 | {
1149 | p_parse->can_frm.dat[3] |= 0x20;
1150 | }
1151 | else
1152 | {
1153 | p_parse->can_frm.dat[3] &= 0xdf;
1154 | }
1155 | p_parse->frm_parse_st = 66;
1156 | break;
1157 | case 66:
1158 | // DATA 3 bit 4
1159 | if(bit_val)
1160 | {
1161 | p_parse->can_frm.dat[3] |= 0x10;
1162 | }
1163 | else
1164 | {
1165 | p_parse->can_frm.dat[3] &= 0xef;
1166 | }
1167 | p_parse->frm_parse_st = 67;
1168 | break;
1169 | case 67:
1170 | // DATA 3 bit 3
1171 | if(bit_val)
1172 | {
1173 | p_parse->can_frm.dat[3] |= 0x08;
1174 | }
1175 | else
1176 | {
1177 | p_parse->can_frm.dat[3] &= 0xf7;
1178 | }
1179 | p_parse->frm_parse_st = 68;
1180 | break;
1181 | case 68:
1182 | // DATA 3 bit 2
1183 | if(bit_val)
1184 | {
1185 | p_parse->can_frm.dat[3] |= 0x04;
1186 | }
1187 | else
1188 | {
1189 | p_parse->can_frm.dat[3] &= 0xfb;
1190 | }
1191 | p_parse->frm_parse_st = 69;
1192 | break;
1193 | case 69:
1194 | // DATA 3 bit 1
1195 | if(bit_val)
1196 | {
1197 | p_parse->can_frm.dat[3] |= 0x02;
1198 | }
1199 | else
1200 | {
1201 | p_parse->can_frm.dat[3] &= 0xfd;
1202 | }
1203 | p_parse->frm_parse_st = 70;
1204 | break;
1205 | case 70:
1206 | // DATA 3 bit 0
1207 | if(bit_val)
1208 | {
1209 | p_parse->can_frm.dat[3] |= 0x01;
1210 | }
1211 | else
1212 | {
1213 | p_parse->can_frm.dat[3] &= 0xfe;
1214 | }
1215 | if(p_parse->can_frm.len > 4)
1216 | {
1217 | p_parse->frm_parse_st = 71;
1218 | }
1219 | else
1220 | {
1221 | p_parse->frm_parse_st = 103;
1222 | }
1223 | break;
1224 | case 71:
1225 | // DATA 4 bit 7
1226 | if(bit_val)
1227 | {
1228 | p_parse->can_frm.dat[4] |= 0x80;
1229 | }
1230 | else
1231 | {
1232 | p_parse->can_frm.dat[4] &= 0x7f;
1233 | }
1234 | p_parse->frm_parse_st = 72;
1235 | break;
1236 | case 72:
1237 | // DATA 4 bit 6
1238 | if(bit_val)
1239 | {
1240 | p_parse->can_frm.dat[4] |= 0x40;
1241 | }
1242 | else
1243 | {
1244 | p_parse->can_frm.dat[4] &= 0xbf;
1245 | }
1246 | p_parse->frm_parse_st = 73;
1247 | break;
1248 | case 73:
1249 | // DATA 4 bit 5
1250 | if(bit_val)
1251 | {
1252 | p_parse->can_frm.dat[4] |= 0x20;
1253 | }
1254 | else
1255 | {
1256 | p_parse->can_frm.dat[4] &= 0xdf;
1257 | }
1258 | p_parse->frm_parse_st = 74;
1259 | break;
1260 | case 74:
1261 | // DATA 4 bit 4
1262 | if(bit_val)
1263 | {
1264 | p_parse->can_frm.dat[4] |= 0x10;
1265 | }
1266 | else
1267 | {
1268 | p_parse->can_frm.dat[4] &= 0xef;
1269 | }
1270 | p_parse->frm_parse_st = 75;
1271 | break;
1272 | case 75:
1273 | // DATA 4 bit 3
1274 | if(bit_val)
1275 | {
1276 | p_parse->can_frm.dat[4] |= 0x08;
1277 | }
1278 | else
1279 | {
1280 | p_parse->can_frm.dat[4] &= 0xf7;
1281 | }
1282 | p_parse->frm_parse_st = 76;
1283 | break;
1284 | case 76:
1285 | // DATA 4 bit 2
1286 | if(bit_val)
1287 | {
1288 | p_parse->can_frm.dat[4] |= 0x04;
1289 | }
1290 | else
1291 | {
1292 | p_parse->can_frm.dat[4] &= 0xfb;
1293 | }
1294 | p_parse->frm_parse_st = 77;
1295 | break;
1296 | case 77:
1297 | // DATA 4 bit 1
1298 | if(bit_val)
1299 | {
1300 | p_parse->can_frm.dat[4] |= 0x02;
1301 | }
1302 | else
1303 | {
1304 | p_parse->can_frm.dat[4] &= 0xfd;
1305 | }
1306 | p_parse->frm_parse_st = 78;
1307 | break;
1308 | case 78:
1309 | // DATA 4 bit 0
1310 | if(bit_val)
1311 | {
1312 | p_parse->can_frm.dat[4] |= 0x01;
1313 | }
1314 | else
1315 | {
1316 | p_parse->can_frm.dat[4] &= 0xfe;
1317 | }
1318 | if(p_parse->can_frm.len > 5)
1319 | {
1320 | p_parse->frm_parse_st = 79;
1321 | }
1322 | else
1323 | {
1324 | p_parse->frm_parse_st = 103;
1325 | }
1326 | break;
1327 | case 79:
1328 | // DATA 5 bit 7
1329 | if(bit_val)
1330 | {
1331 | p_parse->can_frm.dat[5] |= 0x80;
1332 | }
1333 | else
1334 | {
1335 | p_parse->can_frm.dat[5] &= 0x7f;
1336 | }
1337 | p_parse->frm_parse_st = 80;
1338 | break;
1339 | case 80:
1340 | // DATA 5 bit 6
1341 | if(bit_val)
1342 | {
1343 | p_parse->can_frm.dat[5] |= 0x40;
1344 | }
1345 | else
1346 | {
1347 | p_parse->can_frm.dat[5] &= 0xbf;
1348 | }
1349 | p_parse->frm_parse_st = 81;
1350 | break;
1351 | case 81:
1352 | // DATA 5 bit 5
1353 | if(bit_val)
1354 | {
1355 | p_parse->can_frm.dat[5] |= 0x20;
1356 | }
1357 | else
1358 | {
1359 | p_parse->can_frm.dat[5] &= 0xdf;
1360 | }
1361 | p_parse->frm_parse_st = 82;
1362 | break;
1363 | case 82:
1364 | // DATA 5 bit 4
1365 | if(bit_val)
1366 | {
1367 | p_parse->can_frm.dat[5] |= 0x10;
1368 | }
1369 | else
1370 | {
1371 | p_parse->can_frm.dat[5] &= 0xef;
1372 | }
1373 | p_parse->frm_parse_st = 83;
1374 | break;
1375 | case 83:
1376 | // DATA 5 bit 3
1377 | if(bit_val)
1378 | {
1379 | p_parse->can_frm.dat[5] |= 0x08;
1380 | }
1381 | else
1382 | {
1383 | p_parse->can_frm.dat[5] &= 0xf7;
1384 | }
1385 | p_parse->frm_parse_st = 84;
1386 | break;
1387 | case 84:
1388 | // DATA 5 bit 2
1389 | if(bit_val)
1390 | {
1391 | p_parse->can_frm.dat[5] |= 0x04;
1392 | }
1393 | else
1394 | {
1395 | p_parse->can_frm.dat[5] &= 0xfb;
1396 | }
1397 | p_parse->frm_parse_st = 85;
1398 | break;
1399 | case 85:
1400 | // DATA 5 bit 1
1401 | if(bit_val)
1402 | {
1403 | p_parse->can_frm.dat[5] |= 0x02;
1404 | }
1405 | else
1406 | {
1407 | p_parse->can_frm.dat[5] &= 0xfd;
1408 | }
1409 | p_parse->frm_parse_st = 86;
1410 | break;
1411 | case 86:
1412 | // DATA 5 bit 0
1413 | if(bit_val)
1414 | {
1415 | p_parse->can_frm.dat[5] |= 0x01;
1416 | }
1417 | else
1418 | {
1419 | p_parse->can_frm.dat[5] &= 0xfe;
1420 | }
1421 | if(p_parse->can_frm.len > 6)
1422 | {
1423 | p_parse->frm_parse_st = 87;
1424 | }
1425 | else
1426 | {
1427 | p_parse->frm_parse_st = 103;
1428 | }
1429 | break;
1430 | case 87:
1431 | // DATA 6 bit 7
1432 | if(bit_val)
1433 | {
1434 | p_parse->can_frm.dat[6] |= 0x80;
1435 | }
1436 | else
1437 | {
1438 | p_parse->can_frm.dat[6] &= 0x7f;
1439 | }
1440 | p_parse->frm_parse_st = 88;
1441 | break;
1442 | case 88:
1443 | // DATA 6 bit 6
1444 | if(bit_val)
1445 | {
1446 | p_parse->can_frm.dat[6] |= 0x40;
1447 | }
1448 | else
1449 | {
1450 | p_parse->can_frm.dat[6] &= 0xbf;
1451 | }
1452 | p_parse->frm_parse_st = 89;
1453 | break;
1454 | case 89:
1455 | // DATA 6 bit 5
1456 | if(bit_val)
1457 | {
1458 | p_parse->can_frm.dat[6] |= 0x20;
1459 | }
1460 | else
1461 | {
1462 | p_parse->can_frm.dat[6] &= 0xdf;
1463 | }
1464 | p_parse->frm_parse_st = 90;
1465 | break;
1466 | case 90:
1467 | // DATA 6 bit 4
1468 | if(bit_val)
1469 | {
1470 | p_parse->can_frm.dat[6] |= 0x10;
1471 | }
1472 | else
1473 | {
1474 | p_parse->can_frm.dat[6] &= 0xef;
1475 | }
1476 | p_parse->frm_parse_st = 91;
1477 | break;
1478 | case 91:
1479 | // DATA 6 bit 3
1480 | if(bit_val)
1481 | {
1482 | p_parse->can_frm.dat[6] |= 0x08;
1483 | }
1484 | else
1485 | {
1486 | p_parse->can_frm.dat[6] &= 0xf7;
1487 | }
1488 | p_parse->frm_parse_st = 92;
1489 | break;
1490 | case 92:
1491 | // DATA 6 bit 2
1492 | if(bit_val)
1493 | {
1494 | p_parse->can_frm.dat[6] |= 0x04;
1495 | }
1496 | else
1497 | {
1498 | p_parse->can_frm.dat[6] &= 0xfb;
1499 | }
1500 | p_parse->frm_parse_st = 93;
1501 | break;
1502 | case 93:
1503 | // DATA 6 bit 1
1504 | if(bit_val)
1505 | {
1506 | p_parse->can_frm.dat[6] |= 0x02;
1507 | }
1508 | else
1509 | {
1510 | p_parse->can_frm.dat[6] &= 0xfd;
1511 | }
1512 | p_parse->frm_parse_st = 94;
1513 | break;
1514 | case 94:
1515 | // DATA 6 bit 0
1516 | if(bit_val)
1517 | {
1518 | p_parse->can_frm.dat[6] |= 0x01;
1519 | }
1520 | else
1521 | {
1522 | p_parse->can_frm.dat[6] &= 0xfe;
1523 | }
1524 | if(p_parse->can_frm.len > 7)
1525 | {
1526 | p_parse->frm_parse_st = 95;
1527 | }
1528 | else
1529 | {
1530 | p_parse->frm_parse_st = 103;
1531 | }
1532 | break;
1533 | case 95:
1534 | // DATA 7 bit 7
1535 | if(bit_val)
1536 | {
1537 | p_parse->can_frm.dat[7] |= 0x80;
1538 | }
1539 | else
1540 | {
1541 | p_parse->can_frm.dat[7] &= 0x7f;
1542 | }
1543 | p_parse->frm_parse_st = 96;
1544 | break;
1545 | case 96:
1546 | // DATA 7 bit 6
1547 | if(bit_val)
1548 | {
1549 | p_parse->can_frm.dat[7] |= 0x40;
1550 | }
1551 | else
1552 | {
1553 | p_parse->can_frm.dat[7] &= 0xbf;
1554 | }
1555 | p_parse->frm_parse_st = 97;
1556 | break;
1557 | case 97:
1558 | // DATA 7 bit 5
1559 | if(bit_val)
1560 | {
1561 | p_parse->can_frm.dat[7] |= 0x20;
1562 | }
1563 | else
1564 | {
1565 | p_parse->can_frm.dat[7] &= 0xdf;
1566 | }
1567 | p_parse->frm_parse_st = 98;
1568 | break;
1569 | case 98:
1570 | // DATA 7 bit 4
1571 | if(bit_val)
1572 | {
1573 | p_parse->can_frm.dat[7] |= 0x10;
1574 | }
1575 | else
1576 | {
1577 | p_parse->can_frm.dat[7] &= 0xef;
1578 | }
1579 | p_parse->frm_parse_st = 99;
1580 | break;
1581 | case 99:
1582 | // DATA 7 bit 3
1583 | if(bit_val)
1584 | {
1585 | p_parse->can_frm.dat[7] |= 0x08;
1586 | }
1587 | else
1588 | {
1589 | p_parse->can_frm.dat[7] &= 0xf7;
1590 | }
1591 | p_parse->frm_parse_st = 100;
1592 | break;
1593 | case 100:
1594 | // DATA 7 bit 2
1595 | if(bit_val)
1596 | {
1597 | p_parse->can_frm.dat[7] |= 0x04;
1598 | }
1599 | else
1600 | {
1601 | p_parse->can_frm.dat[7] &= 0xfb;
1602 | }
1603 | p_parse->frm_parse_st = 101;
1604 | break;
1605 | case 101:
1606 | // DATA 7 bit 1
1607 | if(bit_val)
1608 | {
1609 | p_parse->can_frm.dat[7] |= 0x02;
1610 | }
1611 | else
1612 | {
1613 | p_parse->can_frm.dat[7] &= 0xfd;
1614 | }
1615 | p_parse->frm_parse_st = 102;
1616 | break;
1617 | case 102:
1618 | // DATA 7 bit 0
1619 | if(bit_val)
1620 | {
1621 | p_parse->can_frm.dat[7] |= 0x01;
1622 | }
1623 | else
1624 | {
1625 | p_parse->can_frm.dat[7] &= 0xfe;
1626 | }
1627 | if(p_parse->can_frm.len > 8)
1628 | {
1629 | p_parse->frm_parse_st = 103;
1630 | }
1631 | else
1632 | {
1633 | p_parse->frm_parse_st = 103;
1634 | }
1635 | break;
1636 | case 103:
1637 | // CRC bit 14
1638 | p_parse->can_frm.crc = 0;
1639 | p_parse->valid_bit = 0;
1640 | if(bit_val)
1641 | {
1642 | p_parse->can_frm.crc |= 0x4000;
1643 | }
1644 | else
1645 | {
1646 | p_parse->can_frm.crc &= 0xbfff;
1647 | }
1648 | p_parse->frm_parse_st = 104;
1649 | break;
1650 | case 104:
1651 | // CRC bit 13
1652 | p_parse->valid_bit = 0;
1653 | if(bit_val)
1654 | {
1655 | p_parse->can_frm.crc |= 0x2000;
1656 | }
1657 | else
1658 | {
1659 | p_parse->can_frm.crc &= 0xdfff;
1660 | }
1661 | p_parse->frm_parse_st = 105;
1662 | break;
1663 | case 105:
1664 | // CRC bit 12
1665 | p_parse->valid_bit = 0;
1666 | if(bit_val)
1667 | {
1668 | p_parse->can_frm.crc |= 0x1000;
1669 | }
1670 | else
1671 | {
1672 | p_parse->can_frm.crc &= 0xefff;
1673 | }
1674 | p_parse->frm_parse_st = 106;
1675 | break;
1676 | case 106:
1677 | // CRC bit 11
1678 | p_parse->valid_bit = 0;
1679 | if(bit_val)
1680 | {
1681 | p_parse->can_frm.crc |= 0x800;
1682 | }
1683 | else
1684 | {
1685 | p_parse->can_frm.crc &= 0xf7ff;
1686 | }
1687 | p_parse->frm_parse_st = 107;
1688 | break;
1689 | case 107:
1690 | // CRC bit 10
1691 | p_parse->valid_bit = 0;
1692 | if(bit_val)
1693 | {
1694 | p_parse->can_frm.crc |= 0x400;
1695 | }
1696 | else
1697 | {
1698 | p_parse->can_frm.crc &= 0xfbff;
1699 | }
1700 | p_parse->frm_parse_st = 108;
1701 | break;
1702 | case 108:
1703 | // CRC bit 9
1704 | p_parse->valid_bit = 0;
1705 | if(bit_val)
1706 | {
1707 | p_parse->can_frm.crc |= 0x200;
1708 | }
1709 | else
1710 | {
1711 | p_parse->can_frm.crc &= 0xfdff;
1712 | }
1713 | p_parse->frm_parse_st = 109;
1714 | break;
1715 | case 109:
1716 | // CRC bit 8
1717 | p_parse->valid_bit = 0;
1718 | if(bit_val)
1719 | {
1720 | p_parse->can_frm.crc |= 0x100;
1721 | }
1722 | else
1723 | {
1724 | p_parse->can_frm.crc &= 0xfeff;
1725 | }
1726 | p_parse->frm_parse_st = 110;
1727 | break;
1728 | case 110:
1729 | // CRC bit 7
1730 | p_parse->valid_bit = 0;
1731 | if(bit_val)
1732 | {
1733 | p_parse->can_frm.crc |= 0x80;
1734 | }
1735 | else
1736 | {
1737 | p_parse->can_frm.crc &= 0xff7f;
1738 | }
1739 | p_parse->frm_parse_st = 111;
1740 | break;
1741 | case 111:
1742 | // CRC bit 6
1743 | p_parse->valid_bit = 0;
1744 | if(bit_val)
1745 | {
1746 | p_parse->can_frm.crc |= 0x40;
1747 | }
1748 | else
1749 | {
1750 | p_parse->can_frm.crc &= 0xffbf;
1751 | }
1752 | p_parse->frm_parse_st = 112;
1753 | break;
1754 | case 112:
1755 | // CRC bit 5
1756 | p_parse->valid_bit = 0;
1757 | if(bit_val)
1758 | {
1759 | p_parse->can_frm.crc |= 0x20;
1760 | }
1761 | else
1762 | {
1763 | p_parse->can_frm.crc &= 0xffdf;
1764 | }
1765 | p_parse->frm_parse_st = 113;
1766 | break;
1767 | case 113:
1768 | // CRC bit 4
1769 | p_parse->valid_bit = 0;
1770 | if(bit_val)
1771 | {
1772 | p_parse->can_frm.crc |= 0x10;
1773 | }
1774 | else
1775 | {
1776 | p_parse->can_frm.crc &= 0xffef;
1777 | }
1778 | p_parse->frm_parse_st = 114;
1779 | break;
1780 | case 114:
1781 | // CRC bit 3
1782 | p_parse->valid_bit = 0;
1783 | if(bit_val)
1784 | {
1785 | p_parse->can_frm.crc |= 0x08;
1786 | }
1787 | else
1788 | {
1789 | p_parse->can_frm.crc &= 0xfff7;
1790 | }
1791 | p_parse->frm_parse_st = 115;
1792 | break;
1793 | case 115:
1794 | // CRC bit 2
1795 | p_parse->valid_bit = 0;
1796 | if(bit_val)
1797 | {
1798 | p_parse->can_frm.crc |= 0x04;
1799 | }
1800 | else
1801 | {
1802 | p_parse->can_frm.crc &= 0xfffb;
1803 | }
1804 | p_parse->frm_parse_st = 116;
1805 | break;
1806 | case 116:
1807 | // CRC bit 1
1808 | p_parse->valid_bit = 0;
1809 | if(bit_val)
1810 | {
1811 | p_parse->can_frm.crc |= 0x02;
1812 | }
1813 | else
1814 | {
1815 | p_parse->can_frm.crc &= 0xfffd;
1816 | }
1817 | p_parse->frm_parse_st = 117;
1818 | break;
1819 | case 117:
1820 | // CRC bit 0
1821 | p_parse->valid_bit = 0;
1822 | if(bit_val)
1823 | {
1824 | p_parse->can_frm.crc |= 0x01;
1825 | }
1826 | else
1827 | {
1828 | p_parse->can_frm.crc &= 0xfffe;
1829 | }
1830 | p_parse->frm_parse_st = 118;
1831 | break;
1832 | case 118:
1833 | // CRC GAP bit
1834 | p_parse->valid_bit = 0;
1835 | if(bit_val)
1836 | {
1837 | p_parse->can_frm.flag |= F_CRC_GAP;
1838 | }
1839 | else
1840 | {
1841 | p_parse->can_frm.flag &= ~F_CRC_GAP;
1842 | }
1843 | res = true;
1844 | p_parse->valid_bit_st = 0;
1845 | p_parse->frm_parse_st = 0;
1846 | break;
1847 | default:
1848 | p_parse->error |= ERR_SM_FRM;
1849 | p_parse->valid_bit_st = 0;
1850 | p_parse->frm_parse_st = 0;
1851 | break;
1852 | }
1853 | #ifdef BIT_RX_PARSE_TM
1854 | tm_probe = tm_probe-getTimeTicks();
1855 | if(p_parse->tm_max < tm_probe)
1856 | {
1857 | p_parse->tm_max_stat = stat;
1858 | p_parse->tm_max = tm_probe;
1859 | }
1860 | #endif
1861 | return res;
1862 | }
1863 |
1864 |
1865 | void bit_tx_parse_init(TY_BIT_TX_PARSE *p_parse)
1866 | {
1867 | memset(p_parse, 0, sizeof(TY_BIT_RX_PARSE));
1868 | }
1869 |
1870 | void bit_tx_parse_rst(TY_BIT_TX_PARSE *p_parse)
1871 | {
1872 | p_parse->sm = 0;
1873 | }
1874 |
1875 | /// 解析出要发送的数据
1876 | /// @param p_tx_parse [io]发送控制结构体
1877 | /// @param p_tx_bit [o] 待发送数据
1878 | /// @retval bool true-发送中，false-发送完毕
1879 | bool bit_tx_parse(TY_BIT_TX_PARSE *p_tx_parse, uint8 *p_tx_bit)
1880 | {
1881 | bool b_res=true;
1882 |
1883 |
1884 | if(0 != p_tx_parse->sm)
1885 | {
1886 | if(p_tx_parse->bit0_cnt >= 5)
1887 | {
1888 | *p_tx_bit = 1;
1889 | p_tx_parse->bit0_cnt =0;
1890 | p_tx_parse->bit1_cnt =1;
1891 | return true;
1892 | }
1893 | else if(p_tx_parse->bit1_cnt >= 5)
1894 | {
1895 | *p_tx_bit = 0;
1896 | p_tx_parse->bit0_cnt =1;
1897 | p_tx_parse->bit1_cnt =0;
1898 | return true;
1899 | }
1900 | else
1901 | {
1902 | ;
1903 | }
1904 | }
1905 |
1906 | switch(p_tx_parse->sm)
1907 | {
1908 | case 0:
1909 | *p_tx_bit = 0;
1910 | p_tx_parse->bit0_cnt =1;
1911 | p_tx_parse->bit1_cnt =0;
1912 | p_tx_parse->bit_in_seg = 0;
1913 | p_tx_parse->sm = 1;
1914 | break;
1915 | case 1:
1916 | *p_tx_bit = (p_tx_parse->frame.id>>28)&0x01;
1917 | p_tx_parse->frame.id <<= 1;
1918 | p_tx_parse->bit_in_seg ++;
1919 | if(p_tx_parse->bit_in_seg >= 11)
1920 | {
1921 | p_tx_parse->bit_in_seg = 0;
1922 | p_tx_parse->sm = 2;
1923 | }
1924 | break;
1925 | case 2:
1926 | if(p_tx_parse->bit_in_seg) // ide
1927 | {
1928 | if(p_tx_parse->frame.flag&F_IDE)
1929 | *p_tx_bit = 1;
1930 | else
1931 | *p_tx_bit = 0;
1932 | }
1933 | else // srr
1934 | {
1935 | if(p_tx_parse->frame.flag&F_SRR)
1936 | *p_tx_bit = 1;
1937 | else
1938 | *p_tx_bit = 0;
1939 | }
1940 | p_tx_parse->bit_in_seg ++;
1941 | if(p_tx_parse->bit_in_seg >= 2)
1942 | {
1943 | p_tx_parse->bit_in_seg = 0;
1944 | p_tx_parse->sm = 3;
1945 | }
1946 | break;
1947 | case 3:
1948 | *p_tx_bit = (p_tx_parse->frame.id>>28)&0x01;
1949 | p_tx_parse->frame.id <<= 1;
1950 | p_tx_parse->bit_in_seg ++;
1951 | if(p_tx_parse->bit_in_seg >= 18)
1952 | {
1953 | p_tx_parse->bit_in_seg = 0;
1954 | p_tx_parse->sm = 4;
1955 | }
1956 | break;
1957 | case 4:
1958 | if(0 == p_tx_parse->bit_in_seg)
1959 | {
1960 | if(p_tx_parse->frame.flag&F_RTR)
1961 | *p_tx_bit = 1;
1962 | else
1963 | *p_tx_bit = 0;
1964 | }
1965 | else if(1 == p_tx_parse->bit_in_seg)
1966 | {
1967 | if(p_tx_parse->frame.flag&F_R0)
1968 | *p_tx_bit = 1;
1969 | else
1970 | *p_tx_bit = 0;
1971 | }
1972 | else
1973 | {
1974 | if(p_tx_parse->frame.flag&F_R1)
1975 | *p_tx_bit = 1;
1976 | else
1977 | *p_tx_bit = 0;
1978 | }
1979 | p_tx_parse->bit_in_seg ++;
1980 | if(p_tx_parse->bit_in_seg >= 3)
1981 | {
1982 | p_tx_parse->bit_in_seg = 0;
1983 | p_tx_parse->len = p_tx_parse->frame.len;
1984 | p_tx_parse->sm = 5;
1985 | }
1986 | break;
1987 | case 5: // len
1988 | *p_tx_bit = (p_tx_parse->frame.len>>3)&0x01;
1989 | p_tx_parse->frame.len <<= 1;
1990 | p_tx_parse->bit_in_seg ++;
1991 | if(p_tx_parse->bit_in_seg >= 4)
1992 | {
1993 | p_tx_parse->bit_in_seg = 0;
1994 | if(0==p_tx_parse->len)
1995 | {
1996 | p_tx_parse->sm = 7;
1997 | }
1998 | else
1999 | {
2000 | p_tx_parse->sm = 6;
2001 | }
2002 | }
2003 | break;
2004 | case 6:
2005 | *p_tx_bit = (p_tx_parse->frame.dat[p_tx_parse->bit_in_seg/8]>>7)&0x01;
2006 | p_tx_parse->frame.dat[p_tx_parse->bit_in_seg/8] <<= 1;
2007 | p_tx_parse->bit_in_seg ++;
2008 | if(p_tx_parse->bit_in_seg >= p_tx_parse->len*8)
2009 | {
2010 | p_tx_parse->bit_in_seg = 0;
2011 | p_tx_parse->sm = 7;
2012 | }
2013 | break;
2014 | case 7:
2015 | *p_tx_bit = (p_tx_parse->frame.crc>>14)&0x01;
2016 | p_tx_parse->frame.crc <<= 1;
2017 | p_tx_parse->bit_in_seg ++;
2018 | if(p_tx_parse->bit_in_seg >= 15)
2019 | {
2020 | p_tx_parse->bit_in_seg = 0;
2021 | p_tx_parse->sm = 8;
2022 | }
2023 | break;
2024 | case 8:
2025 | *p_tx_bit = 1;
2026 | p_tx_parse->sm = 9;
2027 | break;
2028 | case 9: // ack
2029 | *p_tx_bit = 1;
2030 | p_tx_parse->bit_in_seg = 0;
2031 | p_tx_parse->sm = 0;
2032 | break;
2033 | default:
2034 | *p_tx_bit = 1;
2035 | p_tx_parse->bit_in_seg = 0;
2036 | p_tx_parse->sm = 0;
2037 | b_res = false;
2038 | break;
2039 | }
2040 |
2041 | if(*p_tx_bit)
2042 | {
2043 | p_tx_parse->bit0_cnt =0;
2044 | p_tx_parse->bit1_cnt ++;
2045 | }
2046 | else
2047 | {
2048 | p_tx_parse->bit0_cnt ++;
2049 | p_tx_parse->bit1_cnt =0;
2050 | }
2051 | return b_res;
2052 | }
2053 | #pragma section code_in_ram end
2054 |
--------------------------------------------------------------------------------
/bit_parse.h:
--------------------------------------------------------------------------------
1 | #ifndef BIT_TYPE_H_
2 | #define BIT_TYPE_H_
3 |
4 | #define CAN_CTL_GET_TIME() getTimeTicks()
5 |
6 | #define F_SRR 0x01 // 扩展帧才有（为了兼容标准帧），固定1
7 | #define F_IDE 0x02 // 0-标准帧，1-扩展帧
8 | #define F_RTR 0x04 // 1-远程帧，0-数据帧
9 | #define F_R0 0x08
10 | #define F_R1 0x10
11 | #define F_SOF 0x20
12 | #define F_EOF 0x40
13 | #define F_CRC_GAP 0x80
14 |
15 | typedef enum
16 | {
17 | BIT_STF=0, // 填充位
18 | BIT_ERR_IDLE, // 隐形超限
19 | BIT_LOCK, // 显性超限
20 | BIT_OK, // 正常
21 | }ENUM_BIT_ST;
22 |
23 | typedef enum
24 | {
25 | BIT_IDLE=0,
26 | BIT_H_1,
27 | BIT_H_2,
28 | BIT_H_3,
29 | BIT_H_4,
30 | BIT_H_5,
31 | BIT_L_1, // 6
32 | BIT_L_2,
33 | BIT_L_3,
34 | BIT_L_4, // 9
35 | BIT_L_5,
36 | }ENUM_BIT_SM;
37 |
38 | typedef struct
39 | {
40 | uint32 ts;
41 | uint32 id;
42 | uint8 len;
43 | uint8 dat[8];
44 | uint16 crc;
45 | uint8 flag;
46 | uint8 len_bit;
47 | }TY_CAN_FRM;
48 |
49 | typedef enum
50 | {
51 | MODE_NU=0,
52 | MODE_STD,
53 | MODE_EXT
54 | }ENUM_MODE;
55 |
56 | typedef enum
57 | {
58 | ERR_BIT0 =0x01, // 收到超过5个bit0
59 | ERR_BIT1 =0x02, // 收到超过5个bit1
60 | ERR_LEN =0x04, // 长度超范围
61 | ERR_SM_BIT =0x08, // 删除填充位状态机出错
62 | ERR_SM_FRM =0x10, // BIT流解码状态机出错
63 | }ENUM_ERR;
64 |
65 | typedef struct
66 | {
67 | uint8 valid_bit_st; // 删除填充位状态机
68 | uint8 frm_parse_st; // bit流解码状态机
69 | uint8 bit_in_seg; // 帧内段解码bit计数
70 | uint8 stf_bit; // 填充bit
71 | uint8 valid_bit; // 这个bit是否参与CRC计算，0-不参与
72 | uint8 error; // 错误，见ENUM_ERR
73 | uint8 mode; // CAN网工作模式，标准还是扩展模式
74 | TY_CAN_FRM can_frm; // CAN报文存储区
75 | uint16 tm_max_stat; // 最大耗时状态机
76 | uint32 tm_max; // 最大耗时
77 | }TY_BIT_RX_PARSE;
78 |
79 | typedef struct
80 | {
81 | uint32 bit_cnt;
82 | uint8 sm; // bit流解码状态机
83 | uint8 bit_in_seg; // 帧内段解码bit计数
84 | uint8 bit0_cnt; // bit0连续计数
85 | uint8 bit1_cnt; // bit1连续计数
86 | uint8 error; // 错误
87 | uint8 mode; // CAN网工作模式，标准还是扩展模式
88 | uint8 len;
89 | TY_CAN_FRM frame;
90 | uint16 tm_max_stat;
91 | uint32 tm_max;
92 | }TY_BIT_TX_PARSE;
93 |
94 | uint16 can_frame_crc(TY_CAN_FRM *p_frame);
95 |
96 | void bit_rx_parse_rst(TY_BIT_RX_PARSE *p_parse);
97 |
98 | bool bit_rx_parse(TY_BIT_RX_PARSE *p_parse, uint8 bit_val);
99 |
100 | bool tx_bit_parse(TY_BIT_TX_PARSE *p_tx_parse, uint8 *p_tx_bit);
101 |
102 | #endif
103 |
--------------------------------------------------------------------------------
/can_ctl.c:
--------------------------------------------------------------------------------
1 | #ifndef CAN_CTL_C_
2 | #define CAN_CTL_C_
3 | #endif
4 |
5 | #include "sf_Driver.h"
6 | #include "App_Inc.h"
7 | #include "can_ctl.h"
8 | #include "timing_task.h"
9 |
10 | void can_ctl_init(TY_CAN_CTL *p_can, uint32 bit_rate)
11 | {
12 | memset(p_can, 0, sizeof(TY_CAN_CTL));
13 |
14 | p_can->sm = CAN_CTL_SM_STOP;
15 |
16 | p_can->timing_tm_max =0;
17 | p_can->timing_tm_min =(uint32)(-1);
18 |
19 | p_can->sync_tm_max =0;
20 | p_can->sync_tm_min =(uint32)(-1);
21 | }
22 |
23 | void can_ctl_enable(TY_CAN_CTL *p_can)
24 | {
25 | p_can->sm = CAN_CTL_SM_IDLE;
26 | }
27 |
28 | void can_ctl_disable(TY_CAN_CTL *p_can)
29 | {
30 | p_can->sm = CAN_CTL_SM_STOP;
31 | }
32 |
33 | bool can_ctl_wr(TY_CAN_CTL *p_can, uint32 id, uint8 len, uint8 *p_dat)
34 | {
35 | uint16 tmp;
36 | uint8 cnt;
37 |
38 | if(len > 8)
39 | len = 8;
40 | tmp = (p_can->tx_fifo_wr+1)&TX_FIFO_LEN_MSK;
41 | if(tmp != p_can->tx_fifo_rd)
42 | {
43 | p_can->tx_fifo[p_can->tx_fifo_wr].id = id;
44 | p_can->tx_fifo[p_can->tx_fifo_wr].len = len;
45 | for(cnt=0; cnttx_fifo[p_can->tx_fifo_wr].dat[cnt] = p_dat[cnt];
47 | p_can->tx_fifo[p_can->tx_fifo_wr].flag = 0x83;
48 | p_can->tx_fifo[p_can->tx_fifo_wr].crc = can_frame_crc(&p_can->tx_fifo[p_can->tx_fifo_wr]);
49 | p_can->tx_fifo_wr = tmp;
50 | return true;
51 | }
52 | return false;
53 | }
54 |
55 |
56 | bool can_ctl_rd(TY_CAN_CTL *p_can, uint32 *p_ts, uint32 *p_id, uint8 *p_len, uint8 *p_dat)
57 | {
58 | uint8 cnt;
59 |
60 | if(p_can->rx_fifo_wr != p_can->rx_fifo_rd)
61 | {
62 | *p_ts = p_can->rx_fifo[p_can->rx_fifo_rd].ts;
63 | *p_id = p_can->rx_fifo[p_can->rx_fifo_rd].id;
64 | *p_len = p_can->rx_fifo[p_can->rx_fifo_rd].len;
65 | for(cnt=0; cnt<*p_len; cnt++)
66 | p_dat[cnt] = p_can->rx_fifo[p_can->rx_fifo_rd].dat[cnt];
67 | p_can->rx_fifo_rd = (p_can->rx_fifo_rd+1)&RX_FIFO_LEN_MAK;
68 | return true;
69 | }
70 | return false;
71 | }
72 |
--------------------------------------------------------------------------------
/can_ctl.h:
--------------------------------------------------------------------------------
1 | #ifndef CAN_CTL_H_
2 | #define CAN_CTL_H_
3 |
4 | #include "drvDef.h"
5 | #include "bit_parse.h"
6 |
7 | #ifndef CAN_CTL_DEBUG
8 | //#define CAN_CTL_DEBUG
9 | #endif
10 |
11 | typedef enum
12 | {
13 | CAN_CTL_SM_STOP=0,
14 | CAN_CTL_SM_IDLE,
15 | CAN_CTL_SM_RX_WAIT,
16 |
17 | CAN_CTL_SM_RX_GO,
18 | CAN_CTL_SM_RX,
19 | CAN_CTL_SM_RX_ACK,
20 | CAN_CTL_SM_RX_RST,
21 |
22 | CAN_CTL_SM_TX_ARB,
23 | CAN_CTL_SM_TX,
24 | CAN_CTL_SM_TX_ACK,
25 | CAN_CTL_SM_TX_GAP,
26 | }ENUM_CAN_CTL_SM;
27 |
28 | #define TX_FIFO_LEN (128)
29 | #define TX_FIFO_LEN_MSK (TX_FIFO_LEN-1)
30 | #define RX_FIFO_LEN (128)
31 | #define RX_FIFO_LEN_MAK (RX_FIFO_LEN-1)
32 | #define BIT_BUF_LEN (128)
33 | #define BIT_BUF_LEN_MSK (BIT_BUF_LEN-1)
34 | typedef struct
35 | {
36 | uint8 sm; // 状态机
37 |
38 | uint32 timing_cnt; // 接收，接收处理统计
39 | uint32 timing_tm_max_st;
40 | uint32 timing_tm_max;
41 | uint32 timing_tm_min;
42 |
43 | uint8 sync_tx; // 接收，边沿信号信号量
44 | uint8 sync_rx;
45 | uint8 sync_err;
46 | uint32 sync_cnt; // 接收，同步处理
47 | uint32 sync_tm_max;
48 | uint32 sync_tm_min;
49 | uint32 head_rsync;
50 | uint32 tail_rsync;
51 | uint32 tq9_rsync;
52 |
53 | uint8 bit_stat; // 接收，当前值
54 | uint16 crc;
55 | TY_BIT_RX_PARSE bit_rx_parse; // 接收，bit流解码
56 |
57 | uint8 tq_cnt; // 当前bit中tq的计数
58 | uint8 tq_sync; // 当前bit中是否已经进行过再同步
59 | uint8 tq_sync_err; //
60 |
61 | #ifdef CAN_CTL_DEBUG
62 | uint8 rx_bit_lock; // 接收，调试时抓取bit用
63 | uint32 rx_bit_ts[BIT_BUF_LEN];
64 | uint8 rx_bit[BIT_BUF_LEN];
65 | uint16 rx_bit_wr;
66 | uint16 rx_bit_rd;
67 |
68 | uint8 log_wr;
69 | uint8 log_rd;
70 | uint32 log[8][8]; // 调试，抓取异常数据
71 | #endif
72 |
73 | // rx
74 | uint8 rx_flag;
75 | uint8 rx_crc_ok;
76 | uint8 rx_fifo_ok;
77 | uint32 sm_rx_2_rx_ack;
78 | uint32 rx_err_crc;
79 | uint32 rx_err_bit_parse;
80 | uint32 rx_err_sm;
81 | uint32 sm_rst;
82 | uint32 sm_ack;
83 |
84 |
85 | TY_CAN_FRM rx_fifo[RX_FIFO_LEN]; // 接收，fifo
86 | uint16 rx_fifo_wr;
87 | uint16 rx_fifo_rd;
88 | uint32 rx_ov_cnt;
89 | uint32 rx_cnt;
90 |
91 | // tx
92 | uint16 tx_fifo_wr; // 发送fifo
93 | uint16 tx_fifo_rd;
94 | TY_CAN_FRM tx_fifo[TX_FIFO_LEN];
95 |
96 | uint8 tx_bit;
97 | TY_BIT_TX_PARSE p_tx_bit_parse;
98 |
99 | uint32 tx_cnt;
100 | uint32 arb_fail;
101 | uint32 arb_fail_info;
102 | uint32 ack_err;
103 | uint32 tx_err_sm;
104 | uint32 tx_succ;
105 | }TY_CAN_CTL;
106 |
107 | void can_ctl_init(TY_CAN_CTL *p_can, uint32 bit_rate);
108 | void can_ctl_enable(TY_CAN_CTL *p_can);
109 | void can_ctl_disable(TY_CAN_CTL *p_can);
110 |
111 | bool can_ctl_wr(TY_CAN_CTL *p_can, uint32 id, uint8 len, uint8 *p_dat);
112 | bool can_ctl_rd(TY_CAN_CTL *p_can, uint32 *p_ts, uint32 *p_id, uint8 *p_len, uint8 *p_dat);
113 |
114 | // 读取采样电平
115 | #define RX_PIN_STAT() (0x01&(GPIO_PDD_GetPortDataInput(PTE_BASE_PTR)>>25))
116 | #define TX_PIN_SET(stat) do{if(stat){GPIO_PDD_SetPortDataOutputMask(PTE_BASE_PTR, PORT_PDD_PIN_24);}else{GPIO_PDD_ClearPortDataOutputMask(PTE_BASE_PTR, PORT_PDD_PIN_24);}}while(0)
117 |
118 | #include "MK60DZ10.h"
119 | #define PIT_GET_CNT() (*(uint32*)((uint32)PIT_BASE_PTR+4*(256/4+2*4+1)))
120 | // 设定定时器重装值
121 | #define PIT_SET_LDVAL(val) pit3_set_ldval(val)
122 | #endif
123 |
--------------------------------------------------------------------------------
/sync_task.c:
--------------------------------------------------------------------------------
1 | #ifndef SYNC_TASK_C_
2 | #define SYNC_TASK_C_
3 | #endif
4 | #include "sf_Driver.h"
5 | #include "App_Inc.h"
6 | #include "can_ctl.h"
7 | #include "timing_task.h"
8 |
9 | /*
10 | * 同步信号处理任务
11 | */
12 | #pragma define_section code_in_ram ".app_code_ram" abs32 RWX
13 | #pragma section code_in_ram begin
14 | void sync_task(TY_CAN_CTL *p_can)
15 | {
16 | p_can->sync_cnt ++;
17 | switch(p_can->sm)
18 | {
19 | case CAN_CTL_SM_IDLE:
20 | case CAN_CTL_SM_RX_WAIT:
21 | p_can->sm = CAN_CTL_SM_RX_GO;
22 | PIT_SET_LDVAL(1);
23 | break;
24 | case CAN_CTL_SM_TX_GAP:
25 | case CAN_CTL_SM_RX:
26 | case CAN_CTL_SM_RX_ACK:
27 | case CAN_CTL_SM_TX_ARB:
28 | case CAN_CTL_SM_TX:
29 | case CAN_CTL_SM_TX_ACK:
30 | // 发送同步信号
31 | p_can->sync_tx ++;
32 | break;
33 | default:
34 | // 发送同步信号
35 | p_can->sync_tx ++;
36 | break;
37 | }
38 | }
39 | #pragma section code_in_ram end
40 |
41 |
42 |
43 |
--------------------------------------------------------------------------------
/timing_task.c:
--------------------------------------------------------------------------------
1 | #ifndef TIMING_TASK_C_
2 | #define TIMING_TASK_C_
3 | #endif
4 |
5 | #include "sf_Driver.h"
6 | #include "App_Inc.h"
7 | #include "can_ctl.h"
8 | #include "timing_task.h"
9 |
10 |
11 |
12 |
13 | #pragma define_section code_in_ram ".app_code_ram" abs32 RWX
14 |
15 | #pragma section code_in_ram begin
16 | // M4的时钟为48mhz
17 | // 定时时间us(x)
18 | // 重载值=x*1000/(1000/48)=x*48
19 | #define PIT3_LD_VAL_TQ (5*48-1) // TQ
20 | #define PIT3_LD_VAL_BIT (50*48-1) // BIT
21 | #define PIT3_LD_VAL_IDLE (1000*48-1) // MS
22 | void timing_task(TY_CAN_CTL *p_can)
23 | {
24 | uint32 tm_s=PIT_GET_CNT();//getTimeTicks();
25 | uint32 tm_sm=(p_can->sm<<24)+(p_can->tq_cnt<<16)+(p_can->bit_rx_parse.valid_bit_st<<8)+(p_can->bit_rx_parse.frm_parse_st);
26 | uint16 tmp;
27 | bool b_res;
28 | uint8 sm = p_can->sm;
29 |
30 | p_can->timing_cnt ++;
31 | switch(p_can->sm)
32 | {
33 | case CAN_CTL_SM_STOP:
34 | {
35 | PIT_SET_LDVAL(PIT3_LD_VAL_IDLE);
36 | break;
37 | }
38 | case CAN_CTL_SM_IDLE:
39 | {
40 | // 有待发数据就发送数据，否则降低终端频率
41 | if(p_can->tx_fifo_rd != p_can->tx_fifo_wr)
42 | {
43 | p_can->p_tx_bit_parse.frame = p_can->tx_fifo[p_can->tx_fifo_rd];
44 | p_can->p_tx_bit_parse.sm = 0;
45 | p_can->tx_cnt ++;
46 |
47 | p_can->tq_cnt = 1;
48 | if(bit_tx_parse(&p_can->p_tx_bit_parse, &p_can->tx_bit))
49 | {
50 | TX_PIN_SET(p_can->tx_bit);
51 | }
52 |
53 | p_can->bit_rx_parse.can_frm.ts = tm_s;
54 | PIT_SET_LDVAL(PIT3_LD_VAL_TQ);
55 | p_can->sm = CAN_CTL_SM_TX_ARB;
56 | }
57 | else
58 | {
59 | TX_PIN_SET(1);
60 | PIT_SET_LDVAL(PIT3_LD_VAL_IDLE);
61 | }
62 | break;
63 | }
64 | case CAN_CTL_SM_RX_WAIT:
65 | {
66 | p_can->tq_cnt ++;
67 | if(p_can->tq_cnt >= 7)
68 | {
69 | p_can->tq_cnt = 0;
70 | p_can->sm = CAN_CTL_SM_IDLE;
71 | }
72 | break;
73 | }
74 | case CAN_CTL_SM_RX_GO:
75 | {
76 | // 2000/20-1=99
77 | PIT_SET_LDVAL(PIT3_LD_VAL_TQ);
78 | // 此时对应于SOF的下降沿
79 | // 准备接收数据
80 | p_can->bit_rx_parse.can_frm.ts = tm_s;
81 | p_can->tq_cnt = 0;
82 | p_can->rx_flag = 0;
83 | p_can->sm = CAN_CTL_SM_RX;
84 | }
85 | case CAN_CTL_SM_RX:
86 | {
87 | // |_|_|_|_|_|_|_|_|_|_|
88 | // 0 1 2 3 4 5 6 7 8 9 0
89 | // 1、边沿0、1，出现同步信号是正常信号，不需要处理
90 | // 2、边沿2、3，出现同步信号需要再同步来矫正，直接认为当前TQ=1
91 | // 3、边沿8、9，出现同步信号需要再同步来矫正，直接认为当前TQ=0
92 | // 4、其余边沿，出现同步信号属于不可挽回的错误
93 | // #、在每个TQ=0时要复位tq_sync
94 | switch(p_can->tq_cnt)
95 | {
96 | case 0:
97 | p_can->tq_sync = 0;
98 | case 1:
99 | if(p_can->sync_tx != p_can->sync_rx)
100 | {
101 | p_can->sync_rx = p_can->sync_tx;
102 | }
103 | p_can->tq_cnt ++;
104 | break;
105 | case 2:
106 | case 3:
107 | if(p_can->sync_tx != p_can->sync_rx)
108 | {
109 | p_can->sync_rx = p_can->sync_tx;
110 | if(p_can->tq_sync)
111 | {
112 | p_can->tq_cnt ++;
113 | }
114 | else
115 | {
116 | p_can->head_rsync ++;
117 | p_can->tq_cnt = 2;
118 | p_can->tq_sync = 1;
119 | }
120 | }
121 | else
122 | {
123 | p_can->tq_cnt ++;
124 | }
125 | break;
126 | case 4:
127 | case 5:
128 | case 6:
129 | if(p_can->sync_tx != p_can->sync_rx)
130 | {
131 | p_can->sync_rx = p_can->sync_tx;
132 | p_can->sync_err ++;
133 | }
134 | p_can->tq_cnt ++;
135 | break;
136 | case 7:
137 | // sample point
138 | p_can->bit_stat = RX_PIN_STAT();
139 | #ifdef CAN_CTL_DEBUG
140 | if(!p_can->rx_bit_lock)
141 | {
142 | p_can->rx_bit_ts[p_can->rx_bit_wr] = CAN_CTL_GET_TIME();
143 | p_can->rx_bit[p_can->rx_bit_wr] = p_can->bit_stat;
144 | p_can->rx_bit_wr = (p_can->rx_bit_wr+1)&BIT_BUF_LEN_MSK;
145 | }
146 | #endif
147 | b_res = bit_rx_parse(&p_can->bit_rx_parse, p_can->bit_stat);
148 |
149 | // 下一位是ACK，认为已经解码到数据
150 | if(b_res)
151 | {
152 | p_can->rx_flag = 1;
153 |
154 | if(p_can->sync_tx != p_can->sync_rx)
155 | {
156 | p_can->sync_rx = p_can->sync_tx;
157 | p_can->sync_err ++;
158 | }
159 | p_can->tq_cnt ++;
160 | }
161 | else
162 | {
163 | p_can->rx_flag = 0;
164 | // bit_parse函数异常情况下会把状态机复位
165 | if(0!=p_can->bit_rx_parse.frm_parse_st)
166 | {
167 | if(p_can->sync_tx != p_can->sync_rx)
168 | {
169 | p_can->sync_rx = p_can->sync_tx;
170 | p_can->sync_err ++;
171 | }
172 | p_can->tq_cnt ++;
173 | }
174 | else
175 | {
176 | p_can->rx_err_bit_parse ++;
177 | p_can->tq_cnt = 0;
178 | p_can->sm = CAN_CTL_SM_RX_RST;
179 | }
180 | }
181 | break;
182 | case 8:
183 | // 为了平衡负荷，计算校验和放到了这里
184 | if(p_can->bit_rx_parse.valid_bit)
185 | {
186 | p_can->crc = can_crc(p_can->crc, p_can->bit_stat);
187 | }
188 |
189 | // 检查数据有效性
190 | if(p_can->rx_flag)
191 | {
192 | // 检查CRC
193 | if(p_can->crc == p_can->bit_rx_parse.can_frm.crc)
194 | {
195 | p_can->rx_crc_ok = 1;
196 | }
197 | else
198 | {
199 | p_can->rx_err_crc ++;
200 | p_can->rx_crc_ok = 0;
201 | }
202 | }
203 |
204 | if(p_can->sync_tx != p_can->sync_rx)
205 | {
206 | p_can->sync_rx = p_can->sync_tx;
207 | if(p_can->tq_sync)
208 | {
209 | p_can->tq_cnt ++;
210 | }
211 | else
212 | {
213 | p_can->tail_rsync ++;
214 | p_can->tq_cnt = 0;
215 | // 下一位是ACK
216 | if(p_can->rx_flag)
217 | {
218 | p_can->sm_rx_2_rx_ack ++;
219 | p_can->sm = CAN_CTL_SM_RX_ACK;
220 | }
221 | }
222 | }
223 | else
224 | {
225 | p_can->tq_cnt ++;
226 | }
227 | break;
228 | case 9:
229 | // if next bit is ack, do not check resync
230 | // else check resync
231 | if(p_can->rx_flag)
232 | {
233 | if(p_can->sync_tx != p_can->sync_rx)
234 | {
235 | p_can->sync_rx = p_can->sync_tx;
236 | }
237 | p_can->tq_cnt = 0;
238 | p_can->sm_rx_2_rx_ack ++;
239 | p_can->sm = CAN_CTL_SM_RX_ACK;
240 | }
241 | else
242 | {
243 | if(p_can->sync_tx != p_can->sync_rx)
244 | {
245 | p_can->sync_rx = p_can->sync_tx;
246 | if(p_can->tq_sync)
247 | {
248 | p_can->tq_cnt =0;
249 | }
250 | else
251 | {
252 | p_can->tq9_rsync ++;
253 | p_can->tq_cnt =1;
254 | }
255 | }
256 | else
257 | {
258 | p_can->tq_cnt = 0;
259 | }
260 | }
261 | break;
262 | default:
263 | p_can->rx_err_sm ++;
264 | p_can->tq_cnt = 0;
265 | p_can->sm = CAN_CTL_SM_RX_RST;
266 | break;
267 | }
268 | break;
269 | }
270 | case CAN_CTL_SM_RX_ACK: // 3
271 | {
272 | switch(p_can->tq_cnt)
273 | {
274 | case 0:
275 | // 发送应答信号
276 | if(p_can->rx_crc_ok)
277 | {
278 | TX_PIN_SET(0);
279 | tmp = (p_can->rx_fifo_wr+1)&0x07;
280 | if(p_can->rx_fifo_rd != tmp)
281 | {
282 | p_can->rx_fifo_ok = 1;
283 | }
284 | else
285 | {
286 | p_can->rx_ov_cnt ++;
287 | p_can->rx_fifo_ok = 0;
288 | }
289 | p_can->rx_cnt ++;
290 | }
291 | else
292 | {
293 | TX_PIN_SET(1);
294 | p_can->rx_fifo_ok = 0;
295 | }
296 | p_can->sm_ack ++;
297 | p_can->tq_cnt ++;
298 | break;
299 | case 1:
300 | if(p_can->rx_fifo_ok)
301 | {
302 | p_can->rx_fifo[p_can->rx_fifo_wr].ts = p_can->bit_rx_parse.can_frm.ts;
303 | p_can->rx_fifo[p_can->rx_fifo_wr].id = p_can->bit_rx_parse.can_frm.id;
304 | }
305 | p_can->tq_cnt ++;
306 | break;
307 | case 2:
308 | if(p_can->rx_fifo_ok)
309 | {
310 | p_can->rx_fifo[p_can->rx_fifo_wr].len = p_can->bit_rx_parse.can_frm.len;
311 | p_can->rx_fifo[p_can->rx_fifo_wr].flag = p_can->bit_rx_parse.can_frm.flag;
312 | }
313 | p_can->tq_cnt ++;
314 | break;
315 | case 3:
316 | if(p_can->rx_fifo_ok)
317 | {
318 | p_can->rx_fifo[p_can->rx_fifo_wr].dat[0] = p_can->bit_rx_parse.can_frm.dat[0];
319 | p_can->rx_fifo[p_can->rx_fifo_wr].dat[1] = p_can->bit_rx_parse.can_frm.dat[1];
320 | }
321 | p_can->tq_cnt ++;
322 | break;
323 | case 4:
324 | if(p_can->rx_fifo_ok)
325 | {
326 | p_can->rx_fifo[p_can->rx_fifo_wr].dat[2] = p_can->bit_rx_parse.can_frm.dat[2];
327 | p_can->rx_fifo[p_can->rx_fifo_wr].dat[3] = p_can->bit_rx_parse.can_frm.dat[3];
328 | }
329 | p_can->tq_cnt ++;
330 | break;
331 | case 5:
332 | if(p_can->rx_fifo_ok)
333 | {
334 | p_can->rx_fifo[p_can->rx_fifo_wr].dat[4] = p_can->bit_rx_parse.can_frm.dat[4];
335 | p_can->rx_fifo[p_can->rx_fifo_wr].dat[5] = p_can->bit_rx_parse.can_frm.dat[5];
336 | }
337 | p_can->tq_cnt ++;
338 | break;
339 | case 6:
340 | if(p_can->rx_fifo_ok)
341 | {
342 | p_can->rx_fifo[p_can->rx_fifo_wr].dat[6] = p_can->bit_rx_parse.can_frm.dat[6];
343 | p_can->rx_fifo[p_can->rx_fifo_wr].dat[7] = p_can->bit_rx_parse.can_frm.dat[7];
344 | }
345 | p_can->tq_cnt ++;
346 | break;
347 | case 7:
348 | if(p_can->rx_fifo_ok)
349 | {
350 | p_can->rx_fifo[p_can->rx_fifo_wr].crc = p_can->bit_rx_parse.can_frm.crc;
351 | }
352 | p_can->tq_cnt ++;
353 | break;
354 | case 8:
355 | if(p_can->rx_fifo_ok)
356 | {
357 | p_can->rx_fifo_wr = (p_can->rx_fifo_wr+1)&RX_FIFO_LEN_MAK;
358 | }
359 | p_can->tq_cnt ++;
360 | break;
361 | case 9:
362 | if(p_can->sync_tx != p_can->sync_rx)
363 | {
364 | p_can->sync_rx = p_can->sync_tx;
365 | }
366 | p_can->tq_cnt =0;
367 | p_can->sm = CAN_CTL_SM_RX_RST;
368 | break;
369 | default:
370 | p_can->rx_err_sm ++;
371 | p_can->tq_cnt = 0;
372 | p_can->sm = CAN_CTL_SM_RX_RST;
373 | break;
374 | }
375 | break;
376 | }
377 | case CAN_CTL_SM_RX_RST:
378 | // 接收异常或者接收完毕后的中间态，用来复位接收相关的变量
379 | // 持续4个BIT
380 | switch(p_can->tq_cnt)
381 | {
382 | case 0:
383 | TX_PIN_SET(1);
384 | PIT_SET_LDVAL(PIT3_LD_VAL_BIT);
385 | p_can->tq_cnt ++;
386 | break;
387 | case 1:
388 | p_can->rx_flag = 0;
389 | p_can->rx_crc_ok = 0;
390 | p_can->tq_sync = 0;
391 | p_can->crc = 0;
392 | p_can->sync_rx = p_can->sync_tx;
393 | p_can->sm_rst ++;
394 | p_can->tq_cnt ++;
395 | break;
396 | case 2:
397 | bit_rx_parse_rst(&p_can->bit_rx_parse);
398 | p_can->tq_cnt ++;
399 | break;
400 | case 3:
401 | p_can->tq_cnt ++;
402 | break;
403 | case 4:
404 | p_can->tq_cnt = 0;
405 | p_can->sm = CAN_CTL_SM_RX_WAIT;
406 | break;
407 | default:
408 | p_can->tq_cnt = 0;
409 | p_can->sm = CAN_CTL_SM_RX_WAIT;
410 | break;
411 | }
412 | break;
413 | case CAN_CTL_SM_TX_ARB: //
414 | {
415 | switch(p_can->tq_cnt)
416 | {
417 | case 0:
418 | if(bit_tx_parse(&p_can->p_tx_bit_parse, &p_can->tx_bit))
419 | {
420 | TX_PIN_SET(p_can->tx_bit);
421 | }
422 | p_can->tq_cnt ++;
423 | break;
424 | case 7:
425 | p_can->bit_stat = RX_PIN_STAT();
426 | b_res = bit_rx_parse(&p_can->bit_rx_parse, p_can->bit_stat);
427 | // 仲裁判断
428 | if(p_can->tx_bit == p_can->bit_stat)
429 | {
430 | ;
431 | }
432 | else
433 | {
434 | // 仲裁失败
435 | p_can->arb_fail ++;
436 | p_can->arb_fail_info = (p_can->p_tx_bit_parse.sm<<8)+(p_can->p_tx_bit_parse.bit_in_seg);
437 | p_can->sync_rx = p_can->sync_tx;
438 | p_can->sm = CAN_CTL_SM_RX;
439 | }
440 | p_can->tq_cnt ++;
441 | break;
442 | case 1:
443 | case 2:
444 | case 3:
445 | case 4:
446 | case 5:
447 | case 6:
448 | case 8:
449 | p_can->tq_cnt ++;
450 | break;
451 | case 9:
452 | if(p_can->sync_tx != p_can->sync_rx)
453 | {
454 | p_can->sync_rx = p_can->sync_tx;
455 | }
456 | p_can->tq_cnt =0;
457 | // 检查仲裁场是否结束
458 | if(p_can->p_tx_bit_parse.sm >= 5)
459 | {
460 | p_can->sm = CAN_CTL_SM_TX;
461 | }
462 | break;
463 | default:
464 | p_can->tx_err_sm ++;
465 | p_can->sm = CAN_CTL_SM_TX_GAP;
466 | break;
467 | }
468 | break;
469 | }
470 | case CAN_CTL_SM_TX: //
471 | switch(p_can->tq_cnt)
472 | {
473 | case 0:
474 | if(bit_tx_parse(&p_can->p_tx_bit_parse, &p_can->tx_bit))
475 | {
476 | TX_PIN_SET(p_can->tx_bit);
477 | }
478 | case 1:
479 | case 2:
480 | case 3:
481 | case 4:
482 | case 5:
483 | case 6:
484 | case 7:
485 | case 8:
486 | p_can->tq_cnt ++;
487 | break;
488 | case 9:
489 | if(p_can->sync_tx != p_can->sync_rx)
490 | {
491 | p_can->sync_rx = p_can->sync_tx;
492 | }
493 | p_can->tq_cnt =0;
494 | if(9 == p_can->p_tx_bit_parse.sm)
495 | {
496 | p_can->sm = CAN_CTL_SM_TX_ACK;
497 | }
498 | break;
499 | default:
500 | p_can->tx_err_sm ++;
501 | p_can->sm = CAN_CTL_SM_TX_GAP;
502 | break;
503 | }
504 | break;
505 | case CAN_CTL_SM_TX_ACK: //
506 | switch(p_can->tq_cnt)
507 | {
508 | case 0:
509 | TX_PIN_SET(1);
510 | if(bit_tx_parse(&p_can->p_tx_bit_parse, &p_can->tx_bit))
511 | {
512 | ;
513 | }
514 | p_can->tq_cnt ++;
515 | break;
516 | case 1:
517 | case 2:
518 | case 3:
519 | case 4:
520 | case 5:
521 | case 6:
522 | case 8:
523 | p_can->tq_cnt ++;
524 | break;
525 | case 7:
526 | p_can->bit_stat = RX_PIN_STAT();
527 | // 检查应答
528 | if(0==p_can->bit_stat)
529 | {
530 | p_can->tx_fifo_rd = (p_can->tx_fifo_rd+1)&TX_FIFO_LEN_MSK;
531 | p_can->tx_succ ++;
532 | }
533 | else
534 | {
535 | p_can->ack_err ++;
536 | }
537 | p_can->tq_cnt ++;
538 | break;
539 | case 9:
540 | if(p_can->sync_tx != p_can->sync_rx)
541 | {
542 | p_can->sync_rx = p_can->sync_tx;
543 | }
544 | p_can->tq_cnt =0;
545 |
546 | p_can->sm = CAN_CTL_SM_TX_GAP;
547 | break;
548 | default:
549 | p_can->tx_err_sm ++;
550 | p_can->sm = CAN_CTL_SM_TX_GAP;
551 | break;
552 | }
553 | break;
554 | case CAN_CTL_SM_TX_GAP: // 8
555 | switch(p_can->tq_cnt)
556 | {
557 | case 0:
558 | TX_PIN_SET(1);
559 | PIT_SET_LDVAL(PIT3_LD_VAL_BIT);
560 | p_can->tq_cnt ++;
561 | break;
562 | case 1:
563 | bit_rx_parse_rst(&p_can->bit_rx_parse);
564 | bit_tx_parse_rst(&p_can->p_tx_bit_parse);
565 | p_can->tq_cnt ++;
566 | break;
567 | case 2:
568 | case 3:
569 | p_can->tq_cnt ++;
570 | break;
571 | case 4:
572 | if(p_can->sync_tx != p_can->sync_rx)
573 | {
574 | p_can->sync_rx = p_can->sync_tx;
575 | }
576 | p_can->tq_cnt =0;
577 | p_can->sm = CAN_CTL_SM_RX_WAIT;
578 | break;
579 | default:
580 | p_can->tq_cnt = 0;
581 | p_can->sm = CAN_CTL_SM_RX_WAIT;
582 | break;
583 | }
584 | break;
585 | default:
586 | p_can->sm = 0;
587 | break;
588 | }
589 | if(CAN_CTL_SM_IDLE != sm)
590 | {
591 | tm_s=tm_s-PIT_GET_CNT();//getTimeTicks();
592 | if(tm_s>p_can->timing_tm_max)
593 | {
594 | p_can->timing_tm_max_st = tm_sm;
595 | p_can->timing_tm_max = tm_s;
596 | }
597 | if(tm_stiming_tm_min)
598 | p_can->timing_tm_min = tm_s;
599 | }
600 | }
601 | #pragma section code_in_ram end
602 |
603 |
--------------------------------------------------------------------------------
/timing_task.h:
--------------------------------------------------------------------------------
1 | #ifndef TIMING_TASK_H_
2 | #define TIMING_TASK_H_
3 |
4 | void timing_task(TY_CAN_CTL *p_can);
5 |
6 | #endif
7 |
--------------------------------------------------------------------------------