你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

基于STM32F103做CAN的收发通信经验分享

[复制链接]
攻城狮Melo 发布时间:2024-6-15 19:28
CAN通信
7 ]+ }3 i" L0 t8 }    CAN 是Controller Area Network 的缩写(以下称为CAN),该通信使用的是ISO11898标准,该标准的物理层特征如下图所示。+ P5 I8 C& _& t7 e* S/ N4 y
9 n& J" A* i$ Z. e# A8 H
微信图片_20240615192751.png
: N+ M- ?  m7 @! q  f; G
0 z9 ~: I8 T, {# w+ _4 D    CAN协议是通过以下5种类型的帧进行的:2 B; r% ^' r+ V" q4 ?8 A. C8 Y
数据帧
: P# W7 ~' y' r摇控帧3 B+ u2 I7 f  D5 |4 ^" C' c
错误帧$ _7 @% r2 X4 l6 R( p
过载帧& _1 V! B' |) }# ^7 f$ c
帧间隔
! s2 i6 I3 c$ `! r# X+ F! n, q3 \& V
. [0 o7 F( Z- z# V
    另外,数据帧和遥控帧有标准格式和扩展格式两种格式。标准格式有11 个位的标识符(ID),扩展格式有29 个位的ID。' I4 ?# q2 e# x" P1 t7 W
, u; e/ j0 W' K- G5 X; a" }+ L
    大部分系统使用的都是数据帧 ,我这里使用的也是数据帧。
' D9 K! r4 b" l, d    数据帧一般由7个段构成,即:
  F1 {* m6 U: c. J(1) 帧起始。表示数据帧开始的段。
7 s, |8 D8 M3 O4 ^(2) 仲裁段。表示该帧优先级的段。* a3 v. l0 |4 n
(3) 控制段。表示数据的字节数及保留位的段。' j7 X) ~# H9 f0 W. Q0 C
(4) 数据段。数据的内容,一帧可发送0~8个字节的数据。- N" K2 U. e4 L& C: K3 {+ X0 t
(5) CRC段。检查帧的传输错误的段。* q0 ^3 h8 R$ d/ f* M
(6) ACK段。表示确认正常接收的段。! H* O, t; G: v
(7) 帧结束。表示数据帧结束的段。* m7 f0 i4 v/ v: T. j: m
5 d, q7 W; P' Y1 R: w4 D
    明确了数据帧概念,还需要理解一下过滤器的作用。
( z9 m# d9 o: G" V
' v- r2 c, T" `( E( g8 S
    STM32的标识符屏蔽滤波目的是减少了CPU处理CAN通信的开销。STM32的过滤器组最多有28个(互联型),但是STM32F103ZET6只有14个(增强型),每个滤波器组x由2个32为寄存器,CAN_FxR1和CAN_FxR2组成。9 {( I" X. ]1 X& F4 w: L
/ H7 ~+ D9 f/ Y/ p* ^. J7 k1 T
    STM32每个过滤器组的位宽都可以独立配置,以满足应用程序的不同需求。根据位宽的不同,每个过滤器组可提供:
' |  |9 Y+ l+ ~# d7 W1个32位过滤器,包括:STDID[10:0]、EXTID[17:0]、IDE和RTR位) n9 \; j3 F; _
2个16位过滤器,包括:STDID[10:0]、IDE、RTR和EXTID[17:15]位4 u* t8 J1 B' i; a6 Y& S: q1 f8 Q6 |; R

5 ~$ Q7 r! {% W4 Q: D8 B8 `* Q
    此外过滤器可配置为,屏蔽位模式和标识符列表模式。. f3 u+ b# n" D' u
2 p: _( |/ c4 r9 ?
    在屏蔽位模式下,标识符寄存器和屏蔽寄存器一起,指定报文标识符的任何一位,应该按照“必须匹配”或“不用关心”处理。
7 J% z' F/ y+ A" H2 p9 M+ ]0 Q
0 [  T8 M- h3 r6 O3 _; m8 _: _: m
    而在标识符列表模式下,屏蔽寄存器也被当作标识符寄存器用。因此,不是采用一个标识符加一个屏蔽位的方式,而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。相关文章:CAN总线详解。# Y0 w, |4 k- K' e9 e) O  t
; Q+ k9 Y6 r+ N" V
    一般也都是使用标识符列表模式,这里使用的也是标识符列表模式。滤波过程举例如下:' ]+ U1 ?- }( v: V. Q4 z

5 d9 x" A# ?! O4 J2 y8 Y 微信图片_20240615192755.png
/ M$ c9 H9 P1 m  \- x# D
+ R$ s' W& t8 D2 J    在程序中就是:! u6 O+ Y& V* e- L5 }
  1. //要过滤的ID高位# x1 Y9 C9 Q2 k
  2. CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;  + z! I0 v$ b6 z, j. ?3 S  m+ T9 r
  3. //要过滤的ID低位                 # i& L+ L: l( v( R" T* b( g
  4. CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
    . G. ~" Q( i" z# G5 R& E; v, x
  5. //过滤器屏蔽标识符的高16位值
    7 n- [5 Y' ]* v, i, ?6 S
  6. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;   
    ! e( o6 F7 o0 w+ r* Q& N
  7. //过滤器屏蔽标识符的低16位值         
    & ~/ j+ n1 f' M7 I
  8. CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;
复制代码
7 x: Y9 [8 @6 L  d  [& ~
    这里的CAN_FilterId和CAN_FilterMaskId是配合使用的,意思是CAN_FilterId指出需要屏蔽ID的什么内容,什么格式;CAN_FilterMaskId是指CAN_FilterId的每一位是否需要过滤,若CAN_FilterMaskId在某位上是1的话,ID对应位上的数值就必须和CAN_FilterId该位上的一样,保持一致,反之则是“不关心”。
) I+ G: j" ?/ [$ o9 ]5 }( B9 G) C, o- J+ |! q" x( w' F: I! N: l* Z. l4 G
上述程序的设置的含义就是:只接收来自0x1314的数据,屏蔽其他ID的数据。
) j6 i0 [9 y. C' {
' w& r$ `, s: b
程序思路$ z: B# \9 r5 ^% E0 Y
    这里准备做一个主机与从机的通信,主要用扩展标识符ExtId来区分,分配的标识符是:
0 F' j5 z/ W+ l6 q) k7 m主机:0x13142 ]2 U- U( w, Q* ]* c2 _
从机:0x1311& {$ O- [1 R7 G( W0 Q+ _4 V
" m/ ^9 J; h  R' X
    主机负责接收所有从机的数据,不需要过滤,用扩展标识符ExtId来区分不同从机的数据;主机还可以向不同从机发送信息。而从机则只接收来自主机的数据,同样用扩展标识符ExtId来区分是否是发向自己的数据;同时,也能够向主机发送信息。! i9 F+ }8 Y+ s6 P

! s$ c* w7 B5 U) W

4 X, m. _  B, K$ O* y! x2 U相关代码
  e- M. Z, i9 n) s8 u4 z* V    代码也是非常简单的,这里贴出了主机和从机的can.c和can.h两个文件。' B0 n. g8 _  t
, ^! k0 _" ^1 h# C4 A* q& D
从机相关代码3 s  d0 M  _) C1 _+ z; m  {
can.c文件:' Z& G& |* L4 G  w  ~4 @
  1. #include "can.h"
    ) d4 `7 q2 v$ Z, @6 f
  2.   x2 Y/ b( n6 }' m! }; N

  3. : ?5 x" L: R% ~0 a* J# c; ^" \. z

  4. . q: H+ k' l6 ]7 A# C

  5. 4 q8 L5 N7 N5 V! s0 d4 Z
  6. /* 在中断处理函数中返回 */
    & z; Z; @9 [5 v0 V) d* r* }
  7. //__IO uint32_t ret = 0;
    % ]5 x" c# B$ |5 H: @
  8.   A5 ~  u7 ]- M' a* m
  9. 9 H. w! T! W5 o0 G4 o+ n& m; ]% s. m

  10. / a% w) W6 {; i" d( O

  11. ; C' C. p. l: a2 u0 w
  12. //接收数据缓冲器# N$ w% {5 y% h2 j0 K/ o- X  w
  13. u8 RxBuf[5];
    4 @  I8 W) h5 o) g8 p, r6 P0 u
  14. u8 Rx_flag=0;
    ' X2 g, P3 F: Y$ E& e

  15. * c7 i0 N! G' t+ `/ T; ~) E

  16. 6 n" m. E/ F- ?& k3 ]2 s

  17. & l; j7 L% V9 @( M. r$ k; `

  18. 0 B+ v) X0 o# W! ?5 q9 k& a
  19. void CAN1_Init(void)
    % B7 Y7 \, M! m6 Z/ R* i+ K3 B
  20. {1 @( \3 `: l% v- m! V6 ^: T; P
  21.     GPIO_InitTypeDef GPIO_InitStructure;
    " i2 @. \/ s9 @
  22.     NVIC_InitTypeDef NVIC_InitStructure;  |* p% @' d; z: Y$ J7 }% y/ ]
  23.     CAN_InitTypeDef        CAN_InitStructure;* a8 D: t2 I1 K0 A+ o
  24.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;/ h1 }4 t1 q; J" b
  25. 9 A  e7 _$ F5 X4 {6 L, l
  26. # o4 h: P" N- B: U3 a" P' b8 _) C) ^
  27. - E; r! M2 w$ M! Q+ T
  28. 1 d6 b, {5 W. Z7 |
  29.     /* 复用功能和GPIOB端口时钟使能*/   
    " j& ?* d. l9 w) H" j: f
  30.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);                                                                     # ]1 A4 |* C% ^# Y$ R
  31. 6 l8 L! G4 ]( D3 L4 J# ]; p/ E# n0 b

  32. - h: L6 @0 p% Q9 _2 m

  33. $ q, [& X3 I0 `. o, C: I+ V
  34. + B! s( y& @/ r+ X$ n' ^
  35.     /* CAN1 模块时钟使能 */
    7 |. \$ E2 `  m: j- }- ]' u
  36.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);6 P3 O$ h9 F& o1 c
  37. ) R+ n+ j3 _* ]) k8 @

  38. & O; r/ S2 W# [! l+ H- A2 H2 D
  39. , j9 `- M, ^1 j  z$ {) P  A; z
  40. 1 I0 t3 r( C. B: Q! t' X
  41.     /* Configure CAN pin: RX */  // PB8( G0 K1 @) D# ]1 p1 j8 u
  42.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;9 y. w: H; {. \8 b5 i3 U) {
  43.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入" k3 S/ k% e3 G" q
  44.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    1 d6 }* I9 `8 R
  45. 6 u9 u, r6 n2 s0 d! r
  46. ; X# |! S! t( ^. `
  47. 5 u4 ~8 h. h1 |) O0 r
  48. # b9 e, X2 ?$ [6 `. {
  49.     /* Configure CAN pin: TX */   // PB9
    9 O/ P$ y5 C2 z8 J$ T% I
  50.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;% B5 g% l0 y5 ~* W
  51.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     //复用推挽输出
    3 M+ q1 L# z8 l2 J4 D
  52.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    9 w+ Z  t: Y; a& J1 O! g: }
  53. 7 L, W; }! _$ q* z1 v; N

  54. 8 l, }- U2 ^9 P% n7 ?0 B% l
  55.   V2 p% I- j2 t' }0 t
  56. + i6 Q' _' ^; g" {
  57.     //#define GPIO_Remap_CAN    GPIO_Remap1_CAN1 本实验没有用到重映射I/O. S! |! M! J" h: y' d8 l3 K  X+ n) n
  58.     GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
    5 _/ n9 p8 K! ]' J  U1 k

  59. / {8 W, ~3 Q/ N& v: T

  60. * E4 ~' o6 e$ ^" o" M. c' q

  61. % B3 \( L+ |1 L! [$ A

  62. 9 o) K$ _* t0 K2 g0 a* k# ^6 E
  63.     //CAN_NVIC_Configuration(); //CAN中断初始化   
    & U4 n8 ^* a6 S; H1 y. W# N4 y
  64.     /* Configure the NVIC Preemption Priority Bits */  
    7 @8 v5 J, y6 i8 {' V  k
  65.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);" a2 }4 q) N2 d8 g" E

  66. ; v" U6 i* l6 B

  67. / D. v3 w3 m5 R! y: N7 |" Y2 Z( ~
  68. 1 h7 A' F5 n! h. G

  69. ' Z8 a. ?5 E  H7 b( m  M) ~
  70.     #ifdef  VECT_TAB_RAM  
    ! n% M5 c: V0 V0 l: R
  71.       /* Set the Vector Table base location at 0x20000000 */
    8 N9 b: j! _; V8 q: |  R% O
  72.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
    $ A3 `$ k3 E, s) V, {$ I: N
  73.     #else  /* VECT_TAB_FLASH  */
      I7 @9 l- a% ~  P$ {9 I" H
  74.       /* Set the Vector Table base location at 0x08000000 */
    * y# t6 s& r* N3 U
  75.       NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   1 z& N- D7 ^0 h; _
  76.     #endif
    3 v0 U% A+ W$ |# |! [

  77. 5 q. N. N0 w; d& S

  78. ; [) C# |" d, A# @& y1 {8 y

  79. 0 Z; c# V' Z5 p& k
  80. # w; X2 h4 N, V$ B
  81.     /* enabling interrupt */( U* x+ ^2 {0 P  w8 U
  82.     NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;: _+ b9 E4 T: f' M" j! o  e
  83.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    & }  X; Z) z' A8 R9 s  ~% S
  84.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;: }1 Z! l+ C" _' s& c% E8 A
  85.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;9 K* P3 F3 X' w& n
  86.     NVIC_Init(&NVIC_InitStructure);0 ^& U+ F) P# L  m  M8 i
  87. 1 Y& a0 o) T/ w1 f( y

  88. % J, l2 v! J/ f4 e9 I/ `
  89. / n5 k2 M. S6 A2 H) w: a' X0 |

  90. + H7 z, \2 b8 |
  91.     //CAN_INIT();//CA初始化N模块( N* b9 t6 S5 f2 s
  92.     /* CAN register init */- U, N  F7 R- B% m
  93.     CAN_DeInit(CAN1);                       //将外设CAN的全部寄存器重设为缺省值
    5 o# K4 A4 I, |7 Z/ @
  94.     CAN_StructInit(&CAN_InitStructure);     //把CAN_InitStruct中的每一个参数按缺省值填入+ C- [- M# I2 V. v2 J; F; O

  95. 8 y. {" v! g* a; w1 f4 U8 o% `$ H0 E
  96. ) J0 ?/ B$ r; U2 |" o2 G

  97. . I5 `1 c/ e; _: M: E# r6 a  R9 \

  98. # q/ K3 s% \1 h# O: S5 m+ S" W
  99.     /* CAN cell init */
    $ E: `% T; r2 Q/ G) o
  100.     CAN_InitStructure.CAN_TTCM=DISABLE;         //没有使能时间触发模式
    # T" T. o$ j/ G( H
  101.     CAN_InitStructure.CAN_ABOM=DISABLE;         //没有使能自动离线管理
    8 H' B  k% S6 x0 ^( J5 }6 }
  102.     CAN_InitStructure.CAN_AWUM=DISABLE;         //没有使能自动唤醒模式
    - [. h" N; x4 a, U  t$ p% ^
  103.     CAN_InitStructure.CAN_NART=DISABLE;         //没有使能非自动重传模式" n0 a& ~0 U7 [+ j0 u/ h
  104.     CAN_InitStructure.CAN_RFLM=DISABLE;         //没有使能接收FIFO锁定模式9 a7 F; k  @8 ~+ Y  `  v
  105.     CAN_InitStructure.CAN_TXFP=DISABLE;         //没有使能发送FIFO优先级6 \; b, T5 Q( u: x3 t
  106.     CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
    ! \3 z0 R* X9 W  A
  107.     CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;      //重新同步跳跃宽度1个时间单位
    2 w, }; g5 u6 X& j1 z9 N4 L
  108.     CAN_InitStructure.CAN_BS1=CAN_BS1_3tq;      //时间段1为3个时间单位
    " u" ]7 s& T% g2 H# i- r7 Z5 x5 l
  109.     CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;      //时间段2为2个时间单位
      I" f$ E! o4 m  H7 m
  110.     CAN_InitStructure.CAN_Prescaler=60;         //时间单位长度为60
    : d* P" [2 n9 G$ r
  111.     CAN_Init(CAN1,&CAN_InitStructure);          //波特率为:72M/2/60(1+3+2)=0.1 即波特率为100KBPs4 e/ ~( n- ~+ m' L- g

  112. 5 T  k( t" F6 M6 I
  113. $ O( F5 W- U; e- e! A" ^+ ?8 J
  114. 2 G/ k; S1 A  \( j5 t& |4 [9 P" C

  115. % m( q! P# t* j' P2 Y' ~/ n4 N
  116.     // CAN filter init 过滤器,注意,只接收主机发过来的数据,屏蔽其他数据2 V+ R% m1 A6 s1 M% U' o* w& P% ^% C4 j- G
  117.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    0 e/ m7 n8 L4 p5 q
  118.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式8 A: p. x" F5 Q% g
  119.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位* H1 |5 E, S+ ?& d
  120. 4 _$ q7 r5 q2 H, Z2 a$ d. y* `
  121. , F' g$ q) G& L7 O( n* J: Y4 k/ k
  122. " O/ k1 Z4 X% @

  123.   v# j1 b+ w/ N% C
  124.     //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;  
    * r! E( G1 ^9 F1 t
  125.     CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;                  //要过滤的ID高位1 s! h* u+ y5 d! j$ n
  126.     CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位$ e  I. f' T1 n$ {, M

  127. % y0 l/ L0 X& s6 f8 K
  128. / a- `$ o5 Y( q
  129. 2 J3 q* Y  x5 g
  130. - A2 [5 n4 N: _) o) u+ T6 y
  131.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;            //过滤器屏蔽标识符的高16位值1 [8 ?/ ?& y" o" G/ y2 g2 q
  132.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;             //过滤器屏蔽标识符的低16位值
    . ~) e) c8 B+ \$ \5 M/ y
  133.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
    5 @6 \. R3 I4 _0 m- m/ W
  134.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
    # k# k, O' @; p* c# l$ _
  135.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器6 g9 B% h* u9 n1 I3 P

  136. * I* \: F+ U2 o1 i0 [

  137. " i  n0 [. `, X8 o3 c8 y9 G

  138. " ^, l7 k& _+ @6 t+ z

  139. 8 a) n1 Y" F/ F$ r
  140.     /* CAN FIFO0 message pending interrupt enable */. p# s8 J7 b4 D& j2 O
  141.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断) p( q& Y! i/ }- g
  142. }
    3 [" K0 C2 S) Q

  143. 5 g0 S1 {6 j5 Z) O

  144. + O& t7 T6 j2 E' j' Z, x5 Q. l

  145. 7 D5 B& ]1 T6 T3 \) C

  146. 0 X' e( m5 \' c; ~+ b! S) X
  147. /* 发送两个字节的数据*/5 D  U' T7 a1 M, U
  148. u8 CAN_SetMsg(u8 Data1,u8 Data2)5 O+ R$ w: ~; c* i& _% t
  149. {
      L7 e% m6 k6 d* F1 v/ I' S7 e
  150.     u8 mbox;
    & N( _- _; W# G2 ?
  151.     u16 i=0;
    % T+ \6 y! H3 ^" K
  152.     CanTxMsg TxMessage;  
    8 b6 ?1 z- p$ P. i4 V

  153. % R3 g& V9 q0 y, Z& m
  154. , _, v+ O0 \6 c& s  Q
  155. % \$ ]5 ]! d6 S% q$ K! Y

  156. 8 I( Y7 G6 i! [2 A
  157.     TxMessage.StdId=0x0000;     //标准标识符为0x00
    - r' c, ?% o0 e) C% d
  158.     TxMessage.ExtId=0x1311;     //扩展标识符0x1311,可以更改该标识符以示区分不同从机# O& m" F- g/ ]0 f3 f2 q4 e
  159.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    7 p& h" b9 _+ p6 w
  160.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧. j- K# w0 z) K$ R$ s, M6 y* @' I
  161.     TxMessage.DLC=2;            //消息的数据长度为2个字节* y0 c7 d6 `8 ?' W! {
  162.     TxMessage.Data[0]=Data1;    //第一个字节数据
    $ q* Y( {+ v4 {" p6 Z3 ~
  163.     TxMessage.Data[1]=Data2;    //第二个字节数据
    5 V6 x+ }) O8 W0 K
  164. - D4 H6 c8 L! S. Z
  165. $ f3 `% G" V1 o8 x8 T

  166. . v4 C4 C/ `' w$ v

  167. ( ]% i: I7 a2 m) b" O0 ~# T* x
  168.     //发送数据6 Y( _. z  P3 Z/ Z9 A
  169.     mbox= CAN_Transmit(CAN1, &TxMessage);  7 o" l2 Z: W% T1 F+ \: }" N
  170.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
    6 D( K+ w' Q  |
  171.         i++;    //等待发送结束2 V7 z2 n% f0 H6 S4 i
  172.     if(i>=0XFFF)0 V; _+ e3 S) O& M! X/ I
  173.         return 0;" @/ t7 E6 b. m, |0 I
  174.     return 1;+ ]- @, t3 `9 `. W( }
  175. }  n) c' `" E& a2 }
  176. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
    8 \" A; {( l; \
  177. {
    & D, j! C: G8 q  H1 i* w, E1 h3 i
  178.     if(Rx_flag == 1)//发现数据
    4 ~- b: d& s4 u# \- A
  179.     {+ h" R+ A. X! V" C8 c
  180.         *msg1=RxBuf[0];
    : D: _, [1 u5 c, Q4 V4 R/ d4 _
  181.         *msg2=RxBuf[1];
    * ~( C2 f: j' Z
  182.         Rx_flag=0;//数据已经取走,可以更新数据$ m5 y, Z1 X* d. O; C
  183.         return 1;) y0 D0 t5 R6 f5 g- g, C
  184.     }else: P: ~, _6 d5 C; Q9 M: O
  185.         return 0;1 A5 [' V. c" h, ~
  186. }% S+ f9 a  ]8 I. Q- n: t8 p% a; {
  187. /* USB中断和CAN接收中断服务程序,USB跟CAN公用I/O,这里只用到CAN的中断。*/) b, B9 f; z+ k9 P8 H0 W
  188. void USB_LP_CAN1_RX0_IRQHandler(void)
    . A9 K  r' Y  h8 `
  189. {1 C& e, s" s4 [0 P5 [# Z* N' n
  190. % E* _6 i2 H" R
  191. # n: t8 h$ j! I9 @) O9 v7 Y7 M
  192. : j# o9 R. s/ N3 o
  193. & N9 r% W2 u9 I! U" C" D+ h) l
  194.   CanRxMsg RxMessage;" v3 ^* q) d( s+ ^* i# d, i
  195. 5 [; w% e, O; Q4 U9 ^

  196. : N1 I( j4 j: s

  197. ! ^: j3 B. A* `. l) ]  Z
  198. ! Z2 m3 h  o1 R9 {/ }
  199.   RxMessage.StdId=0x00;
    4 N0 Y0 h$ G- F2 A0 P# k1 h  E$ }
  200.   RxMessage.ExtId=0x00;
    4 `. X, B% u+ x5 ?4 M$ s
  201.   RxMessage.IDE=0;* j' t( `6 @: i5 w: E2 P/ {  {2 _. {
  202.   RxMessage.DLC=0;% |5 l' M* ?; N7 S
  203.   RxMessage.FMI=0;2 k9 o9 A2 M9 Z' u4 Q* h
  204.   RxMessage.Data[0]=0x00;& V8 O" m4 B/ U2 Z# T
  205.   RxMessage.Data[1]=0x00;   ; \  p: Z* Q9 y9 _" _/ m+ T7 `4 _
  206. 9 h. h0 z1 ^2 O* u- S2 ]. L

  207. 0 J  \( J. k. D0 O  t% b
  208. 1 ^/ \1 i% F( W
  209. ) \8 h3 v1 J, n# n4 Q2 X
  210.   CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
    0 m5 E0 e. X8 B1 t& Z! ^! ~: N

  211. 9 L2 A: [  h+ d# b7 E, [/ u$ P
  212. 8 e8 C4 n( i& W5 Z4 M+ N$ o
  213. 2 U( d5 r  D/ G' l6 q8 ?6 @9 l
  214. $ }2 X7 r9 l; f8 t. D7 v9 R- a1 l
  215.   if(Rx_flag == 0)//数据已取走或者缓冲器为空. q- W- L1 D( A- F
  216.     {
    6 i0 Z( f( H$ n; h$ ]7 D
  217.         RxBuf[0]=RxMessage.Data[0];" e( Z4 z" R" ?  x) P3 c
  218.         RxBuf[1]=RxMessage.Data[1];
    " G  ?7 b- A$ o+ v+ I7 L
  219.         Rx_flag=1;//数据已经备好,等待取走  s+ @( ]2 E$ f0 \" l; m7 g
  220.     }
    7 W$ ?; P8 b( I& R4 e) w; N
  221. ( d: K7 f" l9 b; [
  222. ( o" y% {  O4 M% ~: Q$ T% l
  223. ' ]0 V- D! U. O7 |" D
  224. 1 s0 _4 g" _+ v/ v, c; O  R
  225. }
复制代码

4 R/ A# e- J1 l' X. ]can.h文件
, ^7 X' d$ V$ G9 s9 y7 ~- h1 X( @+ ]' ]6 r: D- o
微信图片_20240615192757.png 4 C) }! k1 d* x1 d  z, n

( H  h7 ~% E1 B主机相关代码
8 k/ T! M/ \5 K. x. ^  a2 `/ X+ H    这里主机代码大部分是和从机类似的,就只贴出不同的地方了。" r2 B) i. a! a8 d/ j! n3 j+ I
can.c文件:
$ Z( _% v5 @' K' }, l+ i; g
  1. #include "can.h"
    * U3 o! w1 o, y
  2. ' x* \( Z; ?6 S1 F: R8 h, C8 L
  3. 4 ?9 g1 D& d+ n+ m
  4. /* 在中断处理函数中返回 *// d# A. C: ?" y5 n# Z5 J+ U
  5. //__IO uint32_t ret = 0;
    $ |  l, [# m7 N: F% T4 j
  6. 2 a9 Z  N( a/ P% g2 P: g& W
  7. # e6 M7 U/ Q. X9 V! q( R3 Y; ~
  8. void CAN1_Init(void)
    ' g, [( o* C& R* C' f
  9. {8 u, Z; H. k7 C/ ^! i
  10.     ......//以上与从机部分相同' Y( E  {# G. N8 p% B! T1 c/ w

  11. 4 H3 ^( \+ T6 O6 y0 [3 k
  12. - n3 w9 H6 l8 s2 b, c
  13.     //CAN filter init 过滤器,已经设置为任意,可以通过ExtId标识符区分从机代号, |8 ~; g: S& \/ T( F3 N5 }
  14.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    % _' Z' t6 ?1 U3 w
  15.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    , r% J1 s. m# [0 g3 L4 r, [% h+ X
  16.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位7 L; Q" Q8 }  n$ E+ m) M% _. L
  17.     CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;                //过滤器标识符的高16位值
    8 K' N4 A+ P4 U( B* U. J
  18.     CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值$ Z. V- k7 L% t
  19.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;            //过滤器屏蔽标识符的高16位值! V; i$ U; H* K! z2 d4 p$ j
  20.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;             //过滤器屏蔽标识符的低16位值
      u. F9 m4 Q! q$ y: f
  21.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0; p( O! h$ ^! `+ i6 b9 S) z& N; H
  22.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器
    & U* c  Z- D6 N5 z+ a$ O8 s4 N
  23.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器& R& m1 H/ X& W4 m1 E% Y% W
  24. 6 l3 m$ v0 m* E' T5 p2 {  _

  25. $ k- J, r0 k0 e- e) S, [
  26.     /* CAN FIFO0 message pending interrupt enable */
    ! g4 R. I  L8 o1 \8 L
  27.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断
    ! H6 h$ W/ Y- R1 g  X
  28. }; s2 [7 q; `8 M3 C! J1 T' b6 u
  29. 8 i# a! r  U+ R& v" O1 l

  30. / D& g! q. F( t" ~& B
  31. //接收数据缓冲器
    * z* ^1 g! U$ ~& r; v# ]8 Q& m
  32. u8 CAN_RX_BUF[CAN_RX_LEN]={0};     //接收缓冲,最大USART_REC_LEN个字节.
    0 K3 `1 i) D( R
  33. //接收标志位
    9 |6 W, n1 p* u. }$ U, q9 s
  34. u8 Rx_flag=0;
    / @  V. P4 O; K' i1 W  o8 U
  35. /* USB中断和CAN接收中断服务程序,USB跟CAN公用I/O,这里只用到CAN的中断。 */! x2 g$ C( V6 [2 c: E; g4 W
  36. void USB_LP_CAN1_RX0_IRQHandler(void)* o/ S5 ^3 a+ P% E  O& R% J: s1 B
  37. {
    1 k$ C2 i# g' i
  38.     u8 i=0;, s% u. {( \. u" F  J& D" G; f  W
  39.     CanRxMsg RxMessage;
    / L+ A# \9 W5 i5 f, C

  40. 0 ]$ i' q. i1 Q( F( |6 E( x

  41. $ q- |1 N6 K- d
  42.     RxMessage.StdId=0x00;& _- i3 n5 a# u3 [! q
  43.     RxMessage.ExtId=0x00;7 i& [. l: ?+ W; ^% L( w9 @5 X+ R
  44.     RxMessage.IDE=0;
    * i" |# `1 N! a& J7 U2 f: q( A( r
  45.     RxMessage.DLC=0;
    % ~5 L3 {# `1 {$ ~
  46.     RxMessage.FMI=0;  _  z; U& E) B

  47. ) ]0 a% ]7 a1 G0 j! [# ]

  48. 8 H+ V* \7 m- T% _4 w& z9 [3 K8 I
  49.     CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  * `) |5 r, s% z. d
  50. 0 F9 y$ _; l3 w3 O* R) i$ y8 O
  51. $ ^- M% h1 \1 o2 h& I; o. |5 m
  52.     if(Rx_flag == 0)//数据已取走或者缓冲器为空* O, s0 ^* P* _* h4 s, G
  53.     {4 u0 L: M1 W5 Z( h! `) e! l9 \
  54.         if((RxMessage.DLC) == 2)//是否收到2位字节数据" W2 G0 Y; D; ~3 ]- L" y
  55.         {
    . i# L0 t, d) \) @3 z# R
  56.              CAN_RX_BUF[0]=RxMessage.Data[0];: L' M$ z. |. \2 {0 _
  57.              CAN_RX_BUF[1]=RxMessage.Data[1];     
    ) x9 d* j+ n+ I/ `! V
  58.         }
    4 T2 Q) U% @3 @' m: \6 S  K
  59.     }
    # @  @6 a1 Z9 J9 W& E
  60. 5 w3 c/ |( n+ D# C

  61. # L* v- V6 d9 D3 W6 x! g
  62. }
    % I; }: ~- r% w7 a3 R

  63. - G$ Z* j5 d8 K3 P9 ?1 o* R

  64. ; S- w  l3 z" V% N* p! I/ u4 C) a
  65. /* 发送两个字节的数据*/0 b1 [2 s7 k: h5 i, F3 k2 T
  66. u8 CAN_SendMsg(u8* data1, u8* data2)
    ( C) U$ V6 p* n: {2 F% j
  67. {; Q  _/ Z: x3 Y# W' f2 z8 i0 T
  68.     u8 mbox;( a4 l* A, y8 {1 w9 `4 C
  69.     u16 i=0;9 I/ C& G9 _  A/ v! T- u
  70.     CanTxMsg TxMessage;  
    ' e% U7 @5 e4 j5 D3 i* M; M' a
  71. 3 t+ A# d0 L  p
  72. + {) o4 h5 `6 l# i
  73.     TxMessage.StdId=0x0000;     //标准标识符为0x008 y. q+ I# U+ u. C" x
  74.     TxMessage.ExtId=0x1314;     //扩展标识符0x00009 q' y3 B8 g4 y8 M
  75.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    9 @7 `. s1 n1 l# m
  76.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧
    # ~4 E( h+ G9 W
  77.     TxMessage.DLC=2;            //消息的数据长度为2个字节  w& G. P; H$ U: |
  78.     TxMessage.Data[0]=Data1;    //第一个字节数据3 F1 q$ E% M$ |& N, ?+ W: x$ O
  79.     TxMessage.Data[1]=Data2;    //第二个字节数据0 Z% m: }( `' `" T% I

  80. , Z. {: |( w, E) J

  81. + z3 [" s, b% O" ?5 N- s
  82.     //发送数据/ G7 n  s2 L. R6 ?* P9 j# s4 i
  83.     mbox= CAN_Transmit(CAN1, &TxMessage);  
    0 P/ C1 r2 l- ]$ x% j; F
  84.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))7 n0 g( o" j8 B; |: ]
  85.         i++;    //等待发送结束
    ' k5 @8 n+ e2 h
  86.     if(i>=0XFFF)" v# ^# C5 c2 X- ]) q: V
  87.         return 0;//发送失败
    , [) h- v; I  y8 V, j9 J
  88.     return 1;//发送成功, s3 s6 q9 P4 Y! ^/ @2 ^
  89. }
    1 C0 t9 ~3 }# M2 G1 d& ^# v" @( u
  90. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)8 I( a4 m" A8 A9 c5 |
  91. {$ f' `' r( h$ R, l; u9 P- l8 R
  92.     if(Rx_flag == 1)//发现数据
    ; \$ a! t/ U+ D0 l) G
  93.     {' l+ O8 h; R' W5 D; B
  94.         *msg1=CAN_RX_BUF[0];/ d  K6 F( P0 ?" k% s. ]
  95.         *msg2=CAN_RX_BUF[1];
      ?) `7 M5 I! \" ?
  96.         Rx_flag=0;//数据已经取走,可以更新数据/ {0 g( p, ~, m9 R/ ]
  97.         return 1;
    " v. p# q6 Y. t1 Y% u! r+ n& d# w
  98.     }else
    3 A1 c+ V/ z0 ~. m6 H
  99.         return 0;' Z$ t. a& E4 o  a/ r
  100. }- d$ m) k+ \) W
  101. void Clear_canBuffer(void)
    3 t3 _, A" y. x7 k$ h
  102. {
    ; z8 C0 A$ O5 p% G$ Z& M" h
  103.     Rx_flag=0;//清楚接收标志位% Z+ H* D* R4 i! M
  104.     memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区0 Q& ]5 D9 R3 ~
  105. }$ K3 T6 a, Q2 l7 Z6 C& P1 M
  106. u8 Check_canRX(void)
    $ e5 }$ i' Y* Y* Q' F! n4 s
  107. {# h/ G; \* K) U7 }  x9 L+ k2 z
  108.     return (Rx_flag == 6);
    0 P8 }" R# M6 e4 T+ V+ ~
  109. }
复制代码

0 |- G  A: U, G2 R) s* n
& y  n! A; s' R/ K1 j$ b
can.h文件:' B; g7 `* ]8 I7 N& Q8 \2 u
  1. #ifndef __CAN_H
    " H3 x5 m( Z8 f' o
  2. #define __CAN_H- y1 J* A- T; ~" u( W' N
  3. + v* ^, t) c' |; m. R
  4. 7 J5 n7 U( e) p8 f/ o* I
  5. #include "sys.h"5 u; h# _3 b, n9 J6 ]
  6. #include "string.h": F6 M6 X1 d, g  S. e' j! u
  7. 9 i' C' Q7 l1 F9 h* ]) }, g

  8. 6 y* u+ C# C: ?& g
  9. #define CAN_RX_LEN          30          //定义最大接收字节数6 V0 m& s7 N, c

  10. & H. S$ z& w7 O" Q9 t. V& j- ~

  11. ) y6 E3 y# _* R5 c; E/ O
  12. extern u8  CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符* J3 d  ?( [8 \5 n; c

  13. 5 R1 |  Y; ~; I( |( P! B8 n

  14. 8 }. R1 Q/ |4 H/ F+ Z' [/ X6 z
  15. void CAN1_Init(void);7 G* [) m. u. _# N) g6 n
  16. u8 CAN_SendMsg(u8* data1, u8* data2);! L1 l( I$ u! \; Y" A' {5 [( R
  17. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);* U& Z# {  Z/ o2 a8 t

  18. # ~0 e0 C6 g1 c

  19. ; e' j' @% l& _
  20. #endif /* __CAN_H */
    7 H: d) v. H% f! Q; G' |/ F
复制代码

. g7 Z; o( w% L3 y3 v$ [8 k
0 q  N  M0 N" P  h5 [转载自:单片机与嵌入式
  y- e; a% W9 z! n3 t) P% b- g  z4 N9 S% z
如有侵权请联系删除
" w* |$ u! ]) l9 N
+ M- E5 u6 I& k; t& V5 I- n
- Y- p; R2 _5 ?  n
0 N( |$ U' Y- `- ~; }/ b! q' V1 V7 b# Z
4 i. t( W+ q( a6 U0 x0 P3 W
赞 收藏 评论0 发布时间:2024-6-15 19:28

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版