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

【经验分享】使用STM32F103做CAN的收发通信

[复制链接]
STMCU小助手 发布时间:2021-11-7 15:31
CAN通信
    CAN 是Controller Area Network 的缩写(以下称为CAN),该通信使用的是ISO11898标准,该标准的物理层特征如下图所示。
)857N86HK1E0[0K2MXK36X3.png
    CAN协议是通过以下5种类型的帧进行的:
  • 数据帧
    ) [7 X# Z# k5 p$ x* ]& D* M" W% J
  • 摇控帧
    # h4 O' N+ H: ^& }7 G6 J/ W0 P$ L
  • 错误帧
    7 u; m- t9 m  L, N
  • 过载帧' Y% v. {4 J' A
  • 帧间隔

    $ d- @8 T% Z, [! Q( Y9 p
    另外,数据帧和遥控帧有标准格式和扩展格式两种格式。标准格式有11 个位的标识符(ID),扩展格式有29 个位的ID。
    大部分系统使用的都是数据帧 ,我这里使用的也是数据帧。
) ^' s$ k5 F' j* I& j% H    数据帧一般由7个段构成,即:" B: F$ W6 @2 {, C- T
(1) 帧起始。表示数据帧开始的段。
- G& w/ M5 c7 D% }0 R(2) 仲裁段。表示该帧优先级的段。6 D" n# N+ ^9 c3 S6 `% L
(3) 控制段。表示数据的字节数及保留位的段。
) U2 @" h$ d$ X. X(4) 数据段。数据的内容,一帧可发送0~8个字节的数据。
1 ~8 O, `& O$ q) e* U# p(5) CRC段。检查帧的传输错误的段。% j7 B3 F3 o3 K/ T* t+ N
(6) ACK段。表示确认正常接收的段。; R- M5 n, @% z& s
(7) 帧结束。表示数据帧结束的段。
    明确了数据帧概念,还需要理解一下过滤器的作用。
    STM32的标识符屏蔽滤波目的是减少了CPU处理CAN通信的开销。STM32的过滤器组最多有28个(互联型),但是STM32F103ZET6只有14个(增强型),每个滤波器组x由2个32为寄存器,CAN_FxR1和CAN_FxR2组成。
0 ~; ]2 T. @; k3 [6 |& g  d    STM32每个过滤器组的位宽都可以独立配置,以满足应用程序的不同需求。根据位宽的不同,每个过滤器组可提供:
  • 1个32位过滤器,包括:STDID[10:0]、EXTID[17:0]、IDE和RTR位
  • 2个16位过滤器,包括:STDID[10:0]、IDE、RTR和EXTID[17:15]位

    4 e& c3 K& B! I! @) s# {: o" g1 y
    此外过滤器可配置为,屏蔽位模式和标识符列表模式。
    在屏蔽位模式下,标识符寄存器和屏蔽寄存器一起,指定报文标识符的任何一位,应该按照“必须匹配”或“不用关心”处理。5 W  c5 w/ B: o% F$ t
    而在标识符列表模式下,屏蔽寄存器也被当作标识符寄存器用。因此,不是采用一个标识符加一个屏蔽位的方式,而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。相关文章:CAN总线详解。
    一般也都是使用标识符列表模式,这里使用的也是标识符列表模式。滤波过程举例如下:% a4 O7 e5 G0 L. E% |
PERMNQ{)L%G}{986WRA~Q]W.png

# [8 e  d3 Q: R2 e- v, s2 j, l
    在程序中就是:
  1. //要过滤的ID高位 ( \/ S2 G' b. `3 D& K+ n' x
  2. CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;  : H+ e7 k5 N. s* v
  3. //要过滤的ID低位                 
    * F$ U1 b3 e  z5 a. \! ?- W4 L( M
  4. CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; 8 ~7 c% ?0 d3 s+ {5 u; I
  5. //过滤器屏蔽标识符的高16位值' o3 d# J, X5 _
  6. CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;     ]+ x3 d/ N7 i4 G4 u: }+ s
  7. //过滤器屏蔽标识符的低16位值         7 Q4 e* q8 Z1 n; T. x' l. \* h. d+ i  J
  8. CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;
复制代码
" T0 ]3 s+ e; S7 [9 N
    这里的CAN_FilterId和CAN_FilterMaskId是配合使用的,意思是CAN_FilterId指出需要屏蔽ID的什么内容,什么格式;CAN_FilterMaskId是指CAN_FilterId的每一位是否需要过滤,若CAN_FilterMaskId在某位上是1的话,ID对应位上的数值就必须和CAN_FilterId该位上的一样,保持一致,反之则是“不关心”。! Z" z6 s: Y% [0 L. t( ^
上述程序的设置的含义就是:只接收来自0x1314的数据,屏蔽其他ID的数据。
程序思路
    这里准备做一个主机与从机的通信,主要用扩展标识符ExtId来区分,分配的标识符是:
- S! ^5 M2 Q1 W1 v. K: h# R1 e: X+ U主机:0x13143 p* ]1 [6 g; L9 P
从机:0x1311
    主机负责接收所有从机的数据,不需要过滤,用扩展标识符ExtId来区分不同从机的数据;主机还可以向不同从机发送信息。而从机则只接收来自主机的数据,同样用扩展标识符ExtId来区分是否是发向自己的数据;同时,也能够向主机发送信息。
相关代码
    代码也是非常简单的,这里贴出了主机和从机的can.c和can.h两个文件。
从机相关代码
can.c文件:

  1. 2 H- R8 P/ D( B: g2 v2 J
  2. #include "can.h"
    # a! A* ~. f8 C( K% @

  3. ; k/ r" Q' }) M. M: R4 t# j

  4. / ~2 w: D- ]' e
  5. /* 在中断处理函数中返回 */
    . P' V! L3 Y  J( Z
  6. //__IO uint32_t ret = 0;7 u3 W+ y4 L" a1 L

  7. " b! E" J8 P" }7 Z' M: T/ T

  8. ) f  X0 `7 s5 ?( G
  9. //接收数据缓冲器$ k! F) f; m* T/ }6 o
  10. u8 RxBuf[5];8 `9 j4 k* W: Q0 E0 j. v  R
  11. u8 Rx_flag=0;1 ^# A! y. Q, [# j, p# N) O5 h

  12. % L: s  v, y9 Y$ q+ d
  13. % }  a7 d- \  x; F
  14. void CAN1_Init(void)
    ) P/ o, P7 N& p0 S. c
  15. {
    " ^. x$ @" f- W- P
  16.     GPIO_InitTypeDef GPIO_InitStructure;
    8 l# w9 S/ Y9 N
  17.     NVIC_InitTypeDef NVIC_InitStructure;8 ]; E8 u2 j5 k. c" B
  18.     CAN_InitTypeDef        CAN_InitStructure;
    2 j1 B( P: a) C8 R' l
  19.     CAN_FilterInitTypeDef  CAN_FilterInitStructure;
    / V8 ]+ r0 v3 B8 x2 x! y9 }7 \: r
  20. & O+ ~, D) l  }5 p! m& f" f1 F
  21. 0 m  x' e6 |5 T
  22.     /* 复用功能和GPIOB端口时钟使能*/   
    0 O& }  g% w  c. _; o5 f: V
  23.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);                                                                     
    3 {0 g* r' q  o: |' E! I( I
  24. 0 G1 X2 N" N: g) o+ j

  25. 4 p" C. w7 o, I2 j) g  t
  26.     /* CAN1 模块时钟使能 */2 b+ f. E  Y' I" l$ Z1 Z+ f1 Y
  27.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    " z! ?0 v) ~- g  k; O. [& C
  28. ( l5 n; {3 ?& E9 j
  29. + j5 m- @6 N- u8 Z/ O
  30.     /* Configure CAN pin: RX */  // PB8
    2 S1 f3 ~: r+ @3 Z, A
  31.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    3 P: |4 X  q+ ]# y; r
  32.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入
    ' p) f" _: {3 y% P# N! d
  33.     GPIO_Init(GPIOB, &GPIO_InitStructure);3 K5 G7 S1 c; e0 N% v% V% \

  34. : o; m5 |" r2 c# r9 p
  35. & C" C/ H/ N5 T, `+ K2 ?5 i" A% {
  36.     /* Configure CAN pin: TX */   // PB9+ t/ `- y- R; h% E, v
  37.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    0 _  o# n2 k' \/ e6 {
  38.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     //复用推挽输出
    ; p: L* f7 o* k( _0 r& H5 C1 M' h3 O
  39.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    1 R! I; b+ n8 _& |* L

  40. / E, r8 w7 S* }, Y5 `' t; |8 W

  41. , O7 z5 V8 A  i$ r* }
  42.     //#define GPIO_Remap_CAN    GPIO_Remap1_CAN1 本实验没有用到重映射I/O7 v1 V( N. H7 e3 Y! h
  43.     GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
    * l0 j0 w$ z7 G0 _+ V( R+ W% `
  44. " J2 l; \$ D! T6 P8 r& {5 S7 u4 N% [# {

  45. ( b3 r7 t+ C* g0 B5 e# ?
  46.     //CAN_NVIC_Configuration(); //CAN中断初始化   
    4 V8 Y* p$ j9 g2 H& V
  47.     /* Configure the NVIC Preemption Priority Bits */  9 G9 X) S) X& l( b. B- g( _5 p
  48.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    6 I8 w; g9 f. Q7 h/ \3 @1 J9 y7 @
  49. 4 z# C4 V. o* o5 [" R* Y2 S3 R) [
  50. % Z3 @1 u7 \4 g# a
  51.     #ifdef  VECT_TAB_RAM  / Z- y& X) b: P+ H7 u$ Y/ r; g  k
  52.       /* Set the Vector Table base location at 0x20000000 */
    - m+ H+ v. S+ Q! k6 L6 L; y
  53.       NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); & Z: x# Q( B! ~$ k! A1 c
  54.     #else  /* VECT_TAB_FLASH  */6 q3 ?) `4 j; O* W4 G
  55.       /* Set the Vector Table base location at 0x08000000 */
    6 R' c* `# B/ Y$ o$ `
  56.       NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    7 Q, x( P. j( M2 ^2 L
  57.     #endif# H" R/ Y# g5 X9 \, u

  58. & O2 e: i, v$ m: D+ j6 M" w
  59.   G2 H9 h3 Y+ z: e( ~# p
  60.     /* enabling interrupt */
    : M2 y7 x8 X* i" M- z
  61.     NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;/ e+ i& K( O5 n. h8 s" N. v
  62.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    ) z# R- i- W7 v* W- x
  63.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;" ^3 S2 n/ u8 v. ]8 v4 Y$ Q7 I
  64.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    ) \3 z6 |. O6 U8 a2 O  v
  65.     NVIC_Init(&NVIC_InitStructure);9 m, l$ }6 C5 ~' z
  66. 0 d2 U* o/ ~. l/ [7 @$ N3 g
  67. * j+ J! |) b+ F' T
  68.     //CAN_INIT();//CA初始化N模块
    ' C( U  _: S3 |1 o3 a( _+ m
  69.     /* CAN register init */
    5 t) {3 A/ |" h2 X  B
  70.     CAN_DeInit(CAN1);                       //将外设CAN的全部寄存器重设为缺省值
    ( p  A; G% v( L3 U( R' a! @7 _9 h
  71.     CAN_StructInit(&CAN_InitStructure);     //把CAN_InitStruct中的每一个参数按缺省值填入& o/ b+ T( a; [
  72. 1 L" `- b; P/ L( R. S$ s5 q' s
  73. 8 b4 o( b/ ]$ R, V8 N
  74.     /* CAN cell init */
      F" }8 h8 A+ V
  75.     CAN_InitStructure.CAN_TTCM=DISABLE;         //没有使能时间触发模式
    & `# u: o+ O* A+ n0 X4 w2 G
  76.     CAN_InitStructure.CAN_ABOM=DISABLE;         //没有使能自动离线管理6 m- U. P8 Z+ p/ A7 R
  77.     CAN_InitStructure.CAN_AWUM=DISABLE;         //没有使能自动唤醒模式
      U8 l. |  I5 c, C5 E, B( |
  78.     CAN_InitStructure.CAN_NART=DISABLE;         //没有使能非自动重传模式, B; F" F7 K' w5 ~! q3 }
  79.     CAN_InitStructure.CAN_RFLM=DISABLE;         //没有使能接收FIFO锁定模式" l/ N+ K8 o6 _8 @
  80.     CAN_InitStructure.CAN_TXFP=DISABLE;         //没有使能发送FIFO优先级4 R8 ^' s" T* O1 Y* [* g
  81.     CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式0 R$ e( U9 z1 K/ L0 `/ A: _
  82.     CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;      //重新同步跳跃宽度1个时间单位
    ) v" n' _' C/ c9 \
  83.     CAN_InitStructure.CAN_BS1=CAN_BS1_3tq;      //时间段1为3个时间单位
    . x! D7 I9 f4 L' K9 h
  84.     CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;      //时间段2为2个时间单位
    % V% L  j8 Y8 y1 |1 S& @5 q
  85.     CAN_InitStructure.CAN_Prescaler=60;         //时间单位长度为60   j+ R. k4 v. n7 ?& H
  86.     CAN_Init(CAN1,&CAN_InitStructure);          //波特率为:72M/2/60(1+3+2)=0.1 即波特率为100KBPs
    $ S" S: Z# m& g! S- q( g+ [  o' r
  87. 2 q3 C+ [. i  l$ U+ {; N

  88. , o" o7 ^1 ~0 Y
  89.     // CAN filter init 过滤器,注意,只接收主机发过来的数据,屏蔽其他数据
    + G# n3 d( H8 i5 [8 \
  90.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1$ `- @1 q# X9 A
  91.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式+ z& `, G" A6 v0 b
  92.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位% a  B/ F0 G' ?" l/ d, }8 J
  93. - _; @. T& V- n6 q

  94. 2 u+ Z4 u1 _# a
  95.     //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;  5 y% Q; [$ I2 {$ N! k6 {& D
  96.     CAN_FilterInitStructure.CAN_FilterIdHigh=0X00;                  //要过滤的ID高位
    8 S2 h+ l1 u. w0 ~
  97.     CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
    ( ]9 p, R5 F7 w
  98. 9 n8 Z3 U* ?5 P( T/ d2 j
  99. $ w+ k1 K3 E) j
  100.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;            //过滤器屏蔽标识符的高16位值4 l4 ?2 c8 t; J1 R4 g/ |% g
  101.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;             //过滤器屏蔽标识符的低16位值
    / r/ T7 B) m- J- L7 B7 G
  102.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0, `) \6 g  |' m/ {5 w" c
  103.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器; v0 T2 \/ P& O4 J* l
  104.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器6 ^( S7 Z4 \, w/ P. H! R

  105. / D: O3 j: o2 V  W+ A) f+ c
  106. 2 p, E0 ^3 o* @( X* ~, s3 b: z
  107.     /* CAN FIFO0 message pending interrupt enable */
    9 v: c$ B7 P& C) E  K6 C
  108.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断# Z7 G, t( ~, L( \1 P( ?+ w# _
  109. }
    / ~$ N; r( z' k# e8 S* Q
  110. : H& a7 |* e1 p: ~: C3 p
  111. & H) r9 A( I1 W
  112. /* 发送两个字节的数据*/
    ) G, p2 F: G) ]( S* {. l
  113. u8 CAN_SetMsg(u8 Data1,u8 Data2)- }% {$ ^& E# q: b
  114. {   N& g. V, w4 t4 x" l
  115.     u8 mbox;& T; _: ~- s0 N# r9 k
  116.     u16 i=0; 2 M" Y+ ^  _/ x$ [+ E2 H
  117.     CanTxMsg TxMessage;  
    % Q1 q6 _) W- E7 W4 K. ~

  118. ) S  v0 R% e- b0 P7 i! w+ p9 ?

  119. : K) p0 n( e! o/ C+ f
  120.     TxMessage.StdId=0x0000;     //标准标识符为0x00' h7 a( Z9 C& K& G: _6 k" w
  121.     TxMessage.ExtId=0x1311;     //扩展标识符0x1311,可以更改该标识符以示区分不同从机, K: s# l4 G# Q- {3 {; {
  122.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    + N3 F% l3 i3 N% i
  123.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧, Y' y/ b1 a; ]% v
  124.     TxMessage.DLC=2;            //消息的数据长度为2个字节
    6 K" K% Y( ^& @
  125.     TxMessage.Data[0]=Data1;    //第一个字节数据; v4 ]3 u0 e( j
  126.     TxMessage.Data[1]=Data2;    //第二个字节数据
    ; k4 h- }  f. Z$ b+ i& Z
  127. 9 j  r) |- V* @: M0 p$ \" b6 M$ `

  128. 0 U% Z& F( M  C' b* B
  129.     //发送数据: X$ g. `2 i1 h
  130.     mbox= CAN_Transmit(CAN1, &TxMessage);  
    - R" n+ T( Y2 g
  131.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))1 {# \# o' S/ V* z9 B5 J" B
  132.         i++;    //等待发送结束3 U9 q. \" i! `* z0 y# [
  133.     if(i>=0XFFF)
    # V% n+ e5 X9 E3 W# w
  134.         return 0;
    8 R: b6 F$ H7 c+ `9 T( C9 n# {; G9 s
  135.     return 1;
    2 w: R7 b0 U1 @2 V; @6 g
  136. }
    8 j3 C4 H+ W8 C
  137. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)- \  [  z2 o8 j& e, f9 B
  138. {$ y) n0 f/ @2 U9 i5 W- J
  139.     if(Rx_flag == 1)//发现数据9 D& {. @# J. F' N; D
  140.     {
    ; l& R# j" T* E+ t- I# }  }
  141.         *msg1=RxBuf[0];9 t1 R) @; W4 [+ y6 G( Z7 a
  142.         *msg2=RxBuf[1];" I, u. p, K7 B; l
  143.         Rx_flag=0;//数据已经取走,可以更新数据6 d' {9 r4 {3 r0 H1 j
  144.         return 1;
    0 s) P: I/ b/ M6 Y4 R# L
  145.     }else) A$ ^% S9 q4 m# E/ g
  146.         return 0;! K5 n* n- S, t3 R0 d$ R
  147. }, N$ B8 j* c' `) Q* L8 n/ @
  148. /* USB中断和CAN接收中断服务程序,USB跟CAN公用I/O,这里只用到CAN的中断。 */
    ( D0 V* r$ F& }8 s* @, V+ i  s
  149. void USB_LP_CAN1_RX0_IRQHandler(void)
    - ~) e0 Y  ?; a/ V0 y5 i( \
  150. {: T* [" n( J1 B5 S* h+ j
  151. - x2 _! d1 M# s( m% ?0 ^
  152. 4 r) ^0 D* Q6 t5 ?
  153.   CanRxMsg RxMessage;5 _0 T4 N  D1 I7 @
  154. 5 x- T( f; ^: {# u2 a- J- A

  155. , w9 ]% S7 G$ }1 p+ P( H8 K" N
  156.   RxMessage.StdId=0x00;
    . E% E# z" R7 W! p9 p2 a4 n
  157.   RxMessage.ExtId=0x00;3 ~6 N! o# N0 P/ d/ X& J
  158.   RxMessage.IDE=0;
    4 s& F3 z" q( O0 @( R- P! ]
  159.   RxMessage.DLC=0;; Q6 Z1 G, D9 @1 W
  160.   RxMessage.FMI=0;
    0 U$ o& T0 M+ v9 ?: ?/ s' j' [6 d
  161.   RxMessage.Data[0]=0x00;
    7 v9 l  J- l4 I9 f" W' g, p# M
  162.   RxMessage.Data[1]=0x00;    0 G3 l; c) J2 {. ~
  163.   c' e  s/ r, O
  164. : R9 s: g1 n3 x0 H5 _& @
  165.   CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  7 c5 N5 \, x0 O$ s
  166. 2 P0 M: M6 N' K7 C) H- Z

  167. 1 r( g  e5 M0 h. ?1 X# W7 f: ^/ s
  168.   if(Rx_flag == 0)//数据已取走或者缓冲器为空
    ; V  p8 a4 p3 B5 \! K# _
  169.     {
    1 k% J5 ]; V3 _) O# z# R* r
  170.         RxBuf[0]=RxMessage.Data[0];
    $ z* Q+ z/ U5 u4 w
  171.         RxBuf[1]=RxMessage.Data[1];- s4 U2 U; Y' n
  172.         Rx_flag=1;//数据已经备好,等待取走7 `3 m$ J- _9 `0 A
  173.     }. ]- ?5 g( C' }, M8 l

  174. 3 m- S: [" h9 b) J' k
  175. 2 }& Z" \5 c) v9 ^
  176. }
复制代码
, I5 N4 P8 g, Y
can.h文件
NQOI@[X5(~C{N5(@A93Y4.png
主机相关代码
    这里主机代码大部分是和从机类似的,就只贴出不同的地方了。3 Z( k+ H( K4 o  h! B9 l+ h
can.c文件:

  1. % [4 L+ E1 v( w' m1 r" c
  2. #include "can.h"
    2 z7 d% q7 t' Y: ~( J2 M7 \
  3. $ a: }& K2 ?! X; O" `4 C

  4. 1 f; y4 D! W* ^# A8 i
  5. /* 在中断处理函数中返回 *// B; j* U; \4 }& ^, b4 D8 {$ y
  6. //__IO uint32_t ret = 0;
    # x( [* g. {: a" V& ?2 }& z
  7. # h. J0 B& B& k! q( y, n- q

  8. / N2 e" H3 I# I
  9. void CAN1_Init(void)
    " Z9 C5 x6 y% t4 u9 C6 ?2 \
  10. {
    / P, x$ n0 x  ~7 ?" P- k
  11.     ......//以上与从机部分相同; l2 s" A/ L: i3 ~$ x

  12. 6 _0 R7 r' P  |% j; p
  13. . A% ~- h! Q3 O1 M# ^  [0 `
  14.     //CAN filter init 过滤器,已经设置为任意,可以通过ExtId标识符区分从机代号5 n/ s0 e% l+ o
  15.     CAN_FilterInitStructure.CAN_FilterNumber=1;                     //指定过滤器为1
    * C/ h6 Z7 y* |+ d( [) z1 ^4 j1 r
  16.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   //指定过滤器为标识符屏蔽位模式
    0 H( M3 i4 s5 i3 ], D
  17.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;  //过滤器位宽为32位
    ' B& B2 g, k9 I  {0 E
  18.     CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;                //过滤器标识符的高16位值
    & k$ e" w, ?8 ?& h1 O5 j8 }+ }
  19.     CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值
    ) s+ P9 R5 `/ V. o  }5 _
  20.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;            //过滤器屏蔽标识符的高16位值2 W' R! {/ B9 P1 @! U/ K- U
  21.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;             //过滤器屏蔽标识符的低16位值1 h1 K, Q% ?- r" Z, P' _4 W: M2 X( D
  22.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;     //设定了指向过滤器的FIFO为0
    ) F. N3 ]; z9 W8 H% ]3 }* |( Y
  23.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;            //使能过滤器! s- G, T; o8 }+ J
  24.     CAN_FilterInit(&CAN_FilterInitStructure);                       //按上面的参数初始化过滤器
    * y! I9 P9 i* Y( W& L

  25. ! R7 k1 _! c" ]1 v" d( x* M
  26. 1 @; _: s' y4 G& ?7 }% W' }
  27.     /* CAN FIFO0 message pending interrupt enable */ + V% |* w# t* H' ?
  28.     CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);                         //使能FIFO0消息挂号中断" x, \8 a' e) m  C8 c1 g6 o
  29. }; b+ A3 ?) V$ c, m

  30. 9 t+ ~: [7 u) g' J- ]* w
  31. ) n7 E. @$ w: n1 x4 b+ k: S1 X
  32. //接收数据缓冲器
    / `8 c7 ^( b' K& `- ?2 b
  33. u8 CAN_RX_BUF[CAN_RX_LEN]={0};     //接收缓冲,最大USART_REC_LEN个字节.
    ) F* ^. L, ?8 j' r6 k9 w$ `
  34. //接收标志位+ y. e5 V/ F+ @9 C. p% ~
  35. u8 Rx_flag=0;
    % W1 S- {/ o" ^0 O
  36. /* USB中断和CAN接收中断服务程序,USB跟CAN公用I/O,这里只用到CAN的中断。 */  ^( C; H9 E: _
  37. void USB_LP_CAN1_RX0_IRQHandler(void)
    & Q5 t" h) X9 Y8 W- b) ~  z
  38. {( K: Q  }' d. u
  39.     u8 i=0;- t. r9 E1 Q, w
  40.     CanRxMsg RxMessage;
    ' q. h9 `  D' v/ M0 Q
  41. , a; ^+ t7 U7 ^4 U  [& K  h

  42. * ~( d" ~: ?/ ~5 C5 C" w
  43.     RxMessage.StdId=0x00;
    1 v& f- D& ]6 X: t7 r% b! K$ D4 E
  44.     RxMessage.ExtId=0x00;
    $ g/ A. p9 z# b/ F* r
  45.     RxMessage.IDE=0;$ u4 Z" K2 ?' z+ K) l- {( c
  46.     RxMessage.DLC=0;$ y2 v  g6 F3 Y7 o
  47.     RxMessage.FMI=0;- `! I! L2 b. }9 D, D4 F
  48. 2 \% L! t+ T! n! N% W$ O' d

  49. $ _$ C! w. b0 n) B
  50.     CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  . K+ J% H6 K' e* A! _) c+ G+ a

  51. 8 L; u" a" u. E7 u( P3 Q5 P7 l% s

  52. & J! @  t+ Z7 _9 t" F
  53.     if(Rx_flag == 0)//数据已取走或者缓冲器为空7 T6 P4 r7 u/ }3 j- v
  54.     {6 I( f  V$ o; F& B2 e9 T, l( K
  55.         if((RxMessage.DLC) == 2)//是否收到2位字节数据
    ! ~5 n: c0 I8 `! O
  56.         {
    + z$ G; N( X  a/ ]
  57.              CAN_RX_BUF[0]=RxMessage.Data[0];2 A8 m0 l6 w2 _% ^) [5 {( n. W
  58.              CAN_RX_BUF[1]=RxMessage.Data[1];     
    , G: N+ e' M5 w/ ?! G+ @
  59.         }. U  a' f; k1 D# d) D
  60.     }% L/ u9 s! x/ C3 T2 R

  61. % V! p( x+ m! f! B" V8 \
  62. 0 u+ ]$ h6 B! |0 ]" {
  63. }
    7 }( f# F% _4 u! y" N

  64. & p" k. o9 ]: ^

  65. 2 p$ e. ?- |2 ]# A' P2 j0 Y
  66. /* 发送两个字节的数据*/0 }6 s) I) v$ F) T3 a
  67. u8 CAN_SendMsg(u8* data1, u8* data2)+ R( z1 K# Z  ^  o& g
  68. { 0 t2 V" e# I& K+ D$ R0 O" m
  69.     u8 mbox;
    ' {* i+ [# l  |/ S$ a8 S; E5 A
  70.     u16 i=0;
    . d! e% h* y) H9 U( b6 N/ l
  71.     CanTxMsg TxMessage;  
    $ i5 G" u% W( C2 b5 B& ~/ B
  72. $ P: |0 W; Q. ?
  73. 5 _/ L6 a: O- O% g1 z
  74.     TxMessage.StdId=0x0000;     //标准标识符为0x00
    0 e+ G6 w8 U& @; Z
  75.     TxMessage.ExtId=0x1314;     //扩展标识符0x0000
    ( s1 J! i  R  z8 s
  76.     TxMessage.IDE=CAN_ID_EXT;   //使用扩展标识符
    , ]8 i2 B9 b3 b0 T
  77.     TxMessage.RTR=CAN_RTR_DATA; //为数据帧9 A2 f' A8 s3 m5 b" o# H
  78.     TxMessage.DLC=2;            //消息的数据长度为2个字节4 C& E: y! c0 K
  79.     TxMessage.Data[0]=Data1;    //第一个字节数据* R" s0 j/ E0 D* u, t: w- B2 P
  80.     TxMessage.Data[1]=Data2;    //第二个字节数据
    ) h+ _+ F: R- e
  81. ) Y' z9 b. ^5 Y$ U8 P3 j6 e
  82. , T8 s% n. q' r% l( m. N
  83.     //发送数据/ D0 o' C% _  x! V# [' Y7 [6 V- a, T
  84.     mbox= CAN_Transmit(CAN1, &TxMessage);  9 |/ r8 h3 Q% m- @
  85.     while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
    3 R6 w8 i2 ~+ [7 e* ?, d% i; [. E
  86.         i++;    //等待发送结束
    : N! h) P7 F- c* q' E- {2 ^0 h% n: `
  87.     if(i>=0XFFF)
    ! v' x# S# c2 M
  88.         return 0;//发送失败
    0 C+ a- W3 z- e+ c: I
  89.     return 1;//发送成功 ' U6 \3 c' C1 g8 f9 N
  90. }
    8 x7 f1 K+ B) o) Q5 U" I. @- d
  91. u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
    0 l# d* Z4 ?+ D1 Y
  92. {8 |- {! }* m& ~7 K& D& O& h
  93.     if(Rx_flag == 1)//发现数据: z% M' O4 e0 S" Q! I+ ]& o! x
  94.     {
    + W8 _' X7 i* M3 G& C- F0 \
  95.         *msg1=CAN_RX_BUF[0];
    5 G: v/ Q7 P  ]9 \" m  Z5 N( O
  96.         *msg2=CAN_RX_BUF[1];
    * F. k6 X0 W3 a+ F
  97.         Rx_flag=0;//数据已经取走,可以更新数据$ X* j* `0 J2 M9 [4 w5 W% j
  98.         return 1;0 r# T: o6 t+ f8 _/ q
  99.     }else
    / M0 w( k5 K) @% J9 |
  100.         return 0;& w4 g0 ^5 g' N- L7 J
  101. }
    2 X3 m4 W, H5 X2 S" I; L5 c
  102. void Clear_canBuffer(void)
    ; ~& e; d$ L$ v( i4 {, u2 `
  103. {" M% i: j1 r# m$ z
  104.     Rx_flag=0;//清楚接收标志位6 R* ^5 p0 l/ \- P
  105.     memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区2 F1 R$ f$ E# x" s5 g5 o" l4 ~! m
  106. }0 W# U: ?! h6 }! L6 c/ _& Z
  107. u8 Check_canRX(void), W9 ?; G" y9 j/ r
  108. {% B3 V/ }; t4 _4 E% K' M  `
  109.     return (Rx_flag == 6);5 K7 }, x* U# z1 e( y
  110. }
复制代码
9 R6 V9 s( ~" a5 {" g: }# n
can.h文件:
  1. - Z" h/ n! Y  e! _% s* P( M6 D
  2. #ifndef __CAN_H
    0 b2 E/ r# H: [/ y3 C! I% c1 K& p
  3. #define __CAN_H
    1 w; ~0 y. z2 m* I# Y, C
  4. # y  Q  x" l# h9 Q

  5. , H' R4 z( U  q; {  R- F
  6. #include "sys.h"
    * i, Q7 b( W  R
  7. #include "string.h"' w7 J8 `+ p5 I: H. B5 c

  8. 2 M! q3 E4 h" f+ k& k

  9. ) j( X& U& s5 z2 v
  10. #define CAN_RX_LEN          30          //定义最大接收字节数   A  a) o5 L9 e* o( U
  11. % Y; q2 B2 y  u5 m+ a/ h

  12. ) q  ]9 [# @4 k
  13. extern u8  CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符   ]) N5 ~* f2 o) K7 y* H& _* }7 i

  14. 4 Q# h" ~" s0 ~! D: r9 G3 C: i! ^

  15. 6 u( n" }; ]' g3 A3 Q
  16. void CAN1_Init(void);
    & w0 U7 B" W- F5 y9 T* n
  17. u8 CAN_SendMsg(u8* data1, u8* data2);5 K! u1 i) u) w  O( Y
  18. u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
    8 e2 D, l3 l1 V0 }+ Y2 F6 C

  19. : d" o6 |: l' o% N8 F
  20. 8 i" |3 x' v6 r* G
  21. #endif /* __CAN_H */
复制代码

' g8 c, D3 ]8 m. T: y% @& \
赞 收藏 评论0 发布时间:2021-11-7 15:31

举报

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