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

STM32之串口DMA接收不定长数据

[复制链接]
xiaojie0513 发布时间:2018-9-18 21:07
本帖最后由 xiaojie0513 于 2018-9-18 21:07 编辑
5 }, M2 M" _* o5 h* F# G) }9 O3 e$ C
引言
在使用stm32或者其他单片机的时候,会经常使用到串口通讯,那么如何有效地接收数据呢?假如这段数据是不定长的有如何高效接收呢?
  
同学A:数据来了就会进入串口中断,在中断中读取数据就行了!
  
中断就是打断程序正常运行,怎么能保证高效呢?经常把主程序打断,主程序还要不要运行了?
  
同学B:串口可以配置成用DMA的方式接收数据,等接收完毕就可以去读取了!
  
这个同学是对的,我们可以使用DMA去接收数据,不过DMA需要定长才能产生接收中断,如何接收不定长的数据呢?
DMA简介
  
题外话:其实,上面的问题是很有必要思考一下的,不断思考,才能进步。
什么是DMA
DMA:全称Direct Memory Access,即直接存储器访问
DMA 传输将数据从一个地址空间复制到另外一个地址空间。CPU只需初始化DMA即可,传输动作本身是由 DMA 控制器来实现和完成。典型的例子就是移动一个外部内存的区块到芯片内部更快的内存区。这样的操作并没有让处理器参与处理,CPU可以干其他事情,当DMA传输完成的时候产生一个中断,告诉CPU我已经完成了,然后CPU知道了就可以去处理数据了,这样子提高了CPU的利用率,因为CPU是大脑,主要做数据运算的工作,而不是去搬运数据。DMA 传输对于高效能嵌入式系统算法和网络是很重要的。
在STM32的DMA资源
STM32F1系列的MCU有两个DMA控制器(DMA2只存在于大容量产品中),DMA1有7个通道,DMA2有5个通道,每个通道专门用来管理来自于一个或者多个外设对存储器的访问请求。还有一个仲裁器来协调各个DMA请求的优先权。
STM32F1
$ f+ \8 r8 o1 G# ?  SSTM32F1
而STM32F4/F7/H7系列的MCU有两个DMA控制器总共有16个数据流(每个DMA控制器8个),每一个DMA控制器都用于管理一个或多个外设的存储器访问请求。每个数据流总共可以有多达8个通道(或称请求)。每个通道都有一个仲裁器,用于处理 DMA 请求间的优先级。0 `) E, G1 x/ s
STM32F44 L1 o6 _1 T& d; L8 O
STM32F4
4 a7 _, {: c1 d  u

( p/ v7 u: w9 O1 S( c$ O7 ^8 L& x' ^DMA接收数据3 O# i: M, m9 _0 V0 i! B, ?. b; l' V

5 `; }" P/ \. B1 l2 g7 U$ w% J  t$ V3 Q
DMA在接收数据的时候,串口接收DMA在初始化的时候就处于开启状态,一直等待数据的到来,在软件上无需做任何事情,只要在初始化配置的时候设置好配置就可以了。等到接收到数据的时候,告诉CPU去处理即可。
! R% k1 T! X+ B
判断数据接收完成
  
那么问题来了,怎么知道数据是否接收完成呢?
其实,有很多方法:
  • 对于定长的数据,只需要判断一下数据的接收个数,就知道是否接收完成,这个很简单,暂不讨论。
  • 对于不定长的数据,其实也有好几种方法,麻烦的我肯定不会介绍,有兴趣做复杂工作的同学可以在网上看看别人怎么做,下面这种方法是最简单的,充分利用了stm32的串口资源,效率也是非常之高。
    8 G( Z+ R7 C. m( W: N: I# A
    9 L" L7 N3 x' j. q4 @1 l' C2 w( P
DMA+串口空闲中断
这两个资源配合,简直就是天衣无缝啊,无论接收什么不定长的数据,管你数据有多少,来一个我就收一个,就像广东人吃“山竹”,来一个吃一个~(最近风好大,我好怕)。
可能很多人在学习stm32的时候,都不知道idle是啥东西,先看看stm32串口的状态寄存器:
# H0 ]$ j% _+ R! D5 V
idle+ c3 B0 ]9 V9 Z" f1 V8 \
idle说明
当我们检测到触发了串口总线空闲中断的时候,我们就知道这一波数据传输完成了,然后我们就能得到这些数据,去进行处理即可。这种方法是最简单的,根本不需要我们做多的处理,只需要配置好,串口就等着数据的到来,dma也是处于工作状态的,来一个数据就自动搬运一个数据。
接收完数据时处理
串口接收完数据是要处理的,那么处理的步骤是怎么样呢?
  • 暂时关闭串口接收DMA通道,有两个原因:1.防止后面又有数据接收到,产生干扰,因为此时的数据还未处理。2.DMA需要重新配置。
  • 清DMA标志位。
  • 从DMA寄存器中获取接收到的数据字节数(可有可无)。
  • 重新设置DMA下次要接收的数据字节数,注意,数据传输数量范围为0至65535。这个寄存器只能在通道不工作(DMA_CCRx的EN=0)时写入。通道开启后该寄存器变为只读,指示剩余的待传输字节数目。寄存器内容在每次DMA传输后递减。数据传输结束后,寄存器的内容或者变为0;或者当该通道配置为自动重加载模式时,寄存器的内容将被自动重新加载为之前配置时的数值。当寄存器的内容为0时,无论通道是否开启,都不会发生任何数据传输。
  • 给出信号量,发送接收到新数据标志,供前台程序查询。
  • 开启DMA通道,等待下一次的数据接收,注意,对DMA的相关寄存器配置写入,如重置DMA接收数据长度,必须要在关闭DMA的条件进行,否则操作无效。7 @3 B( Y2 R7 y0 e( B3 b$ @

    " M4 S8 h( \  ]$ p0 s# g' }3 ?7 A
注意事项
STM32的IDLE的中断在串口无数据接收的情况下,是不会一直产生的,产生的条件是这样的,当清除IDLE标志位后,必须有接收到第一个数据后,才开始触发,一断接收的数据断流,没有接收到数据,即产生IDLE中断。如果中断发送数据帧的速率很快,MCU来不及处理此次接收到的数据,中断又发来数据的话,这里不能开启,否则数据会被覆盖。有两种方式解决:
  • 在重新开启接收DMA通道之前,将Rx_Buf缓冲区里面的数据复制到另外一个数组中,然后再开启DMA,然后马上处理复制出来的数据。
  • 建立双缓冲,重新配置DMA_MemoryBaseAddr的缓冲区地址,那么下次接收到的数据就会保存到新的缓冲区中,不至于被覆盖。
    . f+ B6 D! m* q. {

    5 w6 l: c8 X& n$ h; b9 U: F: p
程序实现
实验效果:
0 U8 W. N5 a- Y6 L8 i9 _当外部给单片机发送数 据的时候,假设这帧数据长度是1000个字节,那么在单片机接收到一个字节的时候并不会产生串口中断,只是DMA在背后默默地把数据搬运到你指定的缓冲区里面。当整帧数据发送完毕之后串口才会产生一次中断,此时可以利用DMA_GetCurrDataCounter()函数计算出本次的数据接受长度,从而进行数据处理。
串口的配置
# n4 l) n+ E# V4 z3 x很简单,基本与使用串口的时候一致,只不过一般我们是打开接收缓冲区非空中断,而现在是打开空闲中断——USART_ITConfig(DEBUG_USARTx, USART_IT_IDLE, ENABLE);。
/**
$ m7 X1 M# V1 N0 |. O* ^  * @brief  USART GPIO 配置,工作参数配置! i! V) O  r# h1 \1 d
  * @param  无$ y( O; I7 v" r7 W; a" F
  * @retval 无
6 y: D- |1 p5 ?3 T0 \  */

5 E) [3 D! c! s$ [9 k; Z7 m2 ]! avoid USART_Config(void): d7 A- g" j$ n" W8 _. i& m" |+ I
{6 u2 J& f  \( K- i1 u9 @$ H/ u
    GPIO_InitTypeDef GPIO_InitStructure;
8 _1 q% Z2 V" U* w    USART_InitTypeDef USART_InitStructure;5 e' Q* f8 J" J

$ K: S# R8 J( a6 H    // 打开串口GPIO的时钟: }4 R$ V1 m0 j9 ^& W+ }4 O5 R
    DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
/ d) e0 s7 D9 w$ e' d( i/ _7 c- U
3 f% |9 j) v, o    // 打开串口外设的时钟! f3 ^5 b2 ?8 K7 x8 R
    DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);
* n: a1 Y6 P8 S- _7 y6 M* h4 |3 C' C2 X" l$ B$ v% E
    // 将USART Tx的GPIO配置为推挽复用模式
5 B% O+ c% }: Q    GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;1 i% u4 i- D2 k3 o1 \" d
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
3 Z& v  _/ D! P# e. `  W% N    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
* H  f4 g7 G0 ?: }" u    GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);
! Q/ y3 E$ C. ]6 t. b( {& {% Z+ [$ ^- H7 d" ^3 g' b% K& Z
  // 将USART Rx的GPIO配置为浮空输入模式
$ G" H% P$ ~- r9 f( i$ q7 d$ p; |    GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;* F' ]. z0 w( t: X8 Q! @
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;' K1 p: w% Q, Y, L2 A( t
    GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);) h5 O7 M4 a0 K/ R( Y! }$ Y8 ~
0 B& _5 ]7 i9 c7 ]5 f# |
    // 配置串口的工作参数
. e* A# p! M! z3 v9 k    // 配置波特率
* D5 j8 M; m6 ^& B1 l; P+ v    USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;6 q( n' J- [! P& l
    // 配置 针数据字长
3 S% b- Q7 I/ L! n    USART_InitStructure.USART_WordLength = USART_WordLength_8b;* J! t0 Q+ l4 t3 |" s
    // 配置停止位
, `0 x1 s8 `( m* I$ a4 B+ T5 Y    USART_InitStructure.USART_StopBits = USART_StopBits_1;
! ^" |+ Z, D1 ]. ^3 {0 a    // 配置校验位$ U7 `1 E- {2 d7 z( M7 L
    USART_InitStructure.USART_Parity = USART_Parity_No ;
* y# c6 m& n8 D5 D& @    // 配置硬件流控制8 r4 W4 S& R, J8 g; j4 Q, X+ M
    USART_InitStructure.USART_HardwareFlowControl = & q$ ~1 N2 a; L2 Z& C# x& h6 y
    USART_HardwareFlowControl_None;9 J* W/ b4 @$ b) i5 B6 }9 F
    // 配置工作模式,收发一起8 _- d" m8 s" x$ ?: h7 l0 u% n# d
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
9 b& n; A' ?$ b- `    // 完成串口的初始化配置
; j1 w' s" r  J    USART_Init(DEBUG_USARTx, &USART_InitStructure);
" O* H3 a0 `. H    // 串口中断优先级配置
0 @# D  o7 R* d! W: F. c4 d    NVIC_Configuration();
2 i0 b+ R* W; p2 @- ]. A. R5 o' I/ ~4 m) Z$ J% J
#if USE_USART_DMA_RX 1 u8 W3 R, ^5 d9 m/ T- p
    // 开启 串口空闲IDEL 中断! N% g' p! n/ V2 Y- H# o& y$ c5 x
    USART_ITConfig(DEBUG_USARTx, USART_IT_IDLE, ENABLE);  
/ Y3 t* V# g8 r  d/ B, t4 a  // 开启串口DMA接收
% ~0 L/ i0 b* Q6 I2 d7 J; W, ^/ T    USART_DMACmd(DEBUG_USARTx, USART_DMAReq_Rx, ENABLE);
8 U) C8 S1 p% J/ r: e    /* 使能串口DMA */
' q6 R3 S& d% r/ Q    USARTx_DMA_Rx_Config();' `  S) x, W  |
#else
7 l8 m* \5 A$ s! V; h7 Q: j    // 使能串口接收中断& u: q0 W5 S) c
    USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE);   
1 c" M7 y2 w" x3 C$ T5 W#endif! m- v" Z0 z4 g4 q' ]
  [# o9 k, H% d
#if USE_USART_DMA_TX # T# n8 x/ B1 \
    // 开启串口DMA发送/ D% S7 C8 V& S
//    USART_DMACmd(DEBUG_USARTx, USART_DMAReq_Tx, ENABLE); ' A' |" B& p1 R' ?" `
    USARTx_DMA_Tx_Config();( h9 B  S* H" H4 @2 t
#endif% O6 ]! n  f6 E3 O6 ]

: y! D! l+ L+ W$ `3 S6 y    // 使能串口
' i5 ^8 Q5 K8 r0 V    USART_Cmd(DEBUG_USARTx, ENABLE);        
! i' {% V& q7 u, Q2 m8 \1 a# a" y}
) ?& f2 Y9 [- n. K5 T
串口DMA配置
把DMA配置完成,就可以直接打开DMA了,让它处于工作状态,当有数据的时候就能直接搬运了。
#if USE_USART_DMA_RX 8 G- s" u& h$ i8 H8 \3 N
8 F! i8 P5 j  a
static void USARTx_DMA_Rx_Config(void)
( _( k3 B& O8 [2 x( O3 F
{& P# I* P8 ?& A# e& h) k5 W7 J5 ~4 A- H+ I
    DMA_InitTypeDef DMA_InitStructure;
9 b/ G- A3 R; J8 ^* v+ ]
/ k. D# y, ]+ |$ q: d0 g- J2 J    // 开启DMA时钟! T0 X% y1 ~. ]( [
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
. j/ ~; D2 Q5 U7 }0 y8 Q    // 设置DMA源地址:串口数据寄存器地址*/, y$ A7 N7 B0 s$ T1 k. d
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)USART_DR_ADDRESS;: V% q, P1 l% I0 w6 \
    // 内存地址(要传输的变量的指针)
2 P5 W- J! G+ C/ f; M1 ?' x7 T# |: E    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)Usart_Rx_Buf;: j* g( q# m) t7 H9 q
    // 方向:从内存到外设   
: X; ]  R$ f+ s* U! J8 x; S    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
0 S4 E. Z- m8 ?5 N( p1 a    // 传输大小
9 b) x; i# m* U0 v9 u    DMA_InitStructure.DMA_BufferSize = USART_RX_BUFF_SIZE;
0 V6 v& Z9 @/ U. V( f    // 外设地址不增       & ?! y" ^! t9 h& @
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
3 p2 P- v5 h: \3 U    // 内存地址自增
4 Z, f/ N( ^6 m7 T    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
7 d3 c, y% q: I0 n# b! f    // 外设数据单位   # E5 n' Y; z. {) [: O# T
    DMA_InitStructure.DMA_PeripheralDataSize =
( l4 Q3 c0 y, Q# D2 f    DMA_PeripheralDataSize_Byte;
9 Y3 ?3 f, s; N& R. L6 k; A; _- O    // 内存数据单位
2 J/ ^1 T, \3 D/ o3 ]; o    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;  
3 i  r2 l5 F& j6 V8 l- Z5 M: m* `    // DMA模式,一次或者循环模式5 d, _- [  W! O0 o0 U3 K% V
    //DMA_InitStructure.DMA_Mode = DMA_Mode_Normal ;4 \5 A- y; Z" B9 }8 ]% z
    DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
" Z: ?# n* |* s4 m    // 优先级:中   
# G, t; Q4 @" Z4 r+ t    DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh; : n$ d) `5 g6 s. [
    // 禁止内存到内存的传输
& z% c) |7 P  C+ M+ I' _    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;9 ], F& A; s5 L" n6 Q
    // 配置DMA通道         % M( K7 j, B$ l
    DMA_Init(USART_RX_DMA_CHANNEL, &DMA_InitStructure);     
: L9 Y3 O5 l0 A  H% W  z/ }' j    // 清除DMA所有标志& u8 L/ |1 A1 R9 A
    DMA_ClearFlag(DMA1_FLAG_TC5);
7 d. J* e8 v2 y/ z7 ?1 k8 Y+ \    DMA_ITConfig(USART_RX_DMA_CHANNEL, DMA_IT_TE, ENABLE);
+ x6 W$ r2 i1 \$ B, t' d6 q    // 使能DMA0 p7 O1 m: m2 t. r7 r! @1 p
    DMA_Cmd (USART_RX_DMA_CHANNEL,ENABLE);9 K" _* Q+ i  w1 {# V* m
}. u6 S; R- T5 ~8 Y* A7 b
#endif3 t/ @" v- P7 D  ]( }
接收完数据处理
因为接收完数据之后,会产生一个idle中断,也就是空闲中断,那么我们就可以在中断服务函数中知道已经接收完了,就可以处理数据了,但是中断服务函数的上下文环境是中断,所以,尽量是快进快出,一般在中断中将一些标志置位,供前台查询。在中断中先判断我们的产生在中断的类型是不是idle中断,如果是则进行下一步,否则就无需理会。
/**8 y# s4 m" s. ~/ I1 C6 X/ \6 D
  ******************************************************************& U; o, J- |" ]2 U+ k2 T7 p5 h% f
  * @brief   串口中断服务函数0 j5 R& c9 R' p7 N* a# D4 \
  * @author  jiejie
0 g( Q- f( b" ]' ~( B( V% t6 K  * @version V1.0
0 N. a8 h  O5 h) W; T, e  * @date    2018-xx-xx% E* S/ b) i- u' c+ b
  ******************************************************************
! z  l$ s, f! g( D/ ?  */

7 g, Y6 h+ q9 C+ hvoid DEBUG_USART_IRQHandler(void)
. l) w( D. k+ z( V{
  h( J7 C+ _( a$ H6 {& h#if USE_USART_DMA_RX! c9 W5 L- H5 y) z" A1 g' V9 I$ W
    /* 使用串口DMA */# `1 P  u% X- l
    if(USART_GetITStatus(DEBUG_USARTx,USART_IT_IDLE)!=RESET)- f1 t/ }9 v! n7 N
    {      
- r7 F6 }# q% f        /* 接收数据 */! o: m* R! p8 ?( h
        Receive_DataPack();9 F7 ^- d; T) [* r3 r' e5 ^
        // 清除空闲中断标志位9 r" G, t4 |3 `' \( q
        USART_ReceiveData( DEBUG_USARTx );; N  E6 \/ a. {* V
    }   + p: Q; v+ U0 ~3 G! [9 a
#else
) A+ e3 p: f$ {8 @. Q% ]; U  ]7 ?  /* 接收中断 */- E8 r; _. @' Q& A; o
    if(USART_GetITStatus(DEBUG_USARTx,USART_IT_RXNE)!=RESET)9 g0 r/ q% Z. f6 @6 ^% |
    {      
5 G5 h4 z4 L3 g+ Z    Receive_DataPack();9 Y" j2 i* ^9 I- V& H4 |- @
    }
4 o2 N: l, V- s& }2 G- ]9 _5 v#endif' N0 z0 h- r' a- W: q2 r
}
# W9 I2 U: `3 |0 v2 ?/ H
Receive_DataPack()
这个才是真正的接收数据处理函数,为什么我要将这个函数单独封装起来呢?因为这个函数其实是很重要的,因为我的代码兼容普通串口接收与空闲中断,不一样的接收类型其处理也不一样,所以直接封装起来更好,在源码中通过宏定义实现选择接收的方式!更考虑了兼容操作系统的,可能我会在系统中使用dma+空闲中断,所以,供前台查询的信号量就有可能不一样,可能需要修改,我就把它封装起来了。不过无所谓,都是一样的。
/************************************************************7 `. H) E. k" m* X7 a" N/ J
  * @brief   Uart_DMA_Rx_Data& L" K/ T( ^/ P5 J. g+ Y2 u7 B
  * @param   NULL
" u( R) h' P! K9 {% n  * @return  NULL
3 o4 F) \/ H) |4 I9 X  * @author  jiejie+ x  x. t; `: F$ H7 v( T
  * @github  http://github.com/jiejieTop* O# F7 t  |3 H
  * @date    2018-xx-xx
- b1 r. o& Y  y% s/ W, p5 B  * @version v1.05 ]4 h0 i) B3 ]9 v8 K. v
  * @note    使用串口 DMA 接收时调用的函数5 q3 w# l3 c& ^4 P: S1 e/ k) l
  ***********************************************************/
, J- U3 a0 h) l- k) C! W* u
#if USE_USART_DMA_RX
8 ?9 @9 Z; W+ P( R( m# uvoid Receive_DataPack(void)
$ Y& w! X7 I$ v2 c6 ^% s) r{- A' {8 U- h1 ^+ u. [
    /* 接收的数据长度 */
2 m3 m0 _. r: D9 J    uint32_t buff_length;3 c% e9 J) g* T+ T) x
7 L# ?7 O  ?  e8 g
    /* 关闭DMA ,防止干扰 */
* w6 Q, N! l% c9 f2 d/ M    DMA_Cmd(USART_RX_DMA_CHANNEL, DISABLE);  /* 暂时关闭dma,数据尚未处理 */ 9 U  T2 G- t3 S2 D

8 R% v# O- Z4 a. [4 T    /* 清DMA标志位 */3 j4 T* F) X5 L3 m/ s
    DMA_ClearFlag( DMA1_FLAG_TC5 );  
2 z# F% s9 F$ A
3 K  L, G" m3 Z    /* 获取接收到的数据长度 单位为字节*/0 u7 R& t( a; v6 p, F) w% Z8 A
    buff_length = USART_RX_BUFF_SIZE - DMA_GetCurrDataCounter(USART_RX_DMA_CHANNEL);
- E! x& \4 n) h; a% F" j8 Z7 ^* N6 e+ T1 G
' N) \$ A' T1 a2 d' x6 J    /* 获取数据长度 */* p, t3 N( S: U  _0 D
    Usart_Rx_Sta = buff_length;2 }2 x1 ]6 f; q* ^( N. ~

4 _: ~5 ^) J& A4 v" T0 I7 n3 P    PRINT_DEBUG("buff_length = %d\n ",buff_length);" `+ d" A( U7 i: H! f% A

/ p/ w; K- B$ F- i9 W% I    /* 重新赋值计数值,必须大于等于最大可能接收到的数据帧数目 */
  {6 X) f9 W( r: M$ N5 O: I    USART_RX_DMA_CHANNEL->CNDTR = USART_RX_BUFF_SIZE;    : m: [9 w5 @; ^+ J- n

( F7 _( O+ l( k' L    /* 此处应该在处理完数据再打开,如在 DataPack_Process() 打开*/
( S+ H- W) C2 s* v! q) W    DMA_Cmd(USART_RX_DMA_CHANNEL, ENABLE);      
4 q" J7 [8 a# s+ L9 g4 }4 y) t/ I/ \# ^: U% a% H/ n( _
    /* (OS)给出信号 ,发送接收到新数据标志,供前台程序查询 *// P0 O. C/ W' ~+ h7 M
- H4 F4 c( O/ O4 k
    /* 标记接收完成,在 DataPack_Handle 处理*/$ _$ B9 R7 V2 l8 \
    Usart_Rx_Sta |= 0xC000;2 m' o* q, c2 q) q

) u. m1 z5 W1 [" j    /* 2 i# y0 q" \9 E
    DMA 开启,等待数据。注意,如果中断发送数据帧的速率很快,MCU来不及处理此次接收到的数据,3 Q5 c$ U# ?" J  b) g6 P7 f
    中断又发来数据的话,这里不能开启,否则数据会被覆盖。有2种方式解决:
5 g  n" i1 \/ l8 [7 Z1 O  ~: c4 R5 j, k
    1. 在重新开启接收DMA通道之前,将Rx_Buf缓冲区里面的数据复制到另外一个数组中,
$ p( @3 t$ U7 p    然后再开启DMA,然后马上处理复制出来的数据。4 v6 g3 P, n; o* P& G! N# a
5 ?, R3 a. Q! f& Y9 h
    2. 建立双缓冲,重新配置DMA_MemoryBaseAddr的缓冲区地址,那么下次接收到的数据就会7 H% h1 {  R! p0 s8 y" I
    保存到新的缓冲区中,不至于被覆盖。+ Y2 t( H; l( L% a6 P1 I
    */

/ Z1 F$ X, ^7 A' C1 x# R9 L}
4 L1 H, W  W! l0 A
f1使用dma是非常简单的,我在f4用dma的时候也遇到一些问题,最后看手册解决了,打算下一篇文章就写一下调试过程,没有什么是debug不能解决的,如果有,那就两次。今天台风天气,连着舍友的WiFi更新的文章~中国电信还是强,台风天气信号一点都不虚,我的移动卡一动不动-_-.

; h6 g4 `; j& F5 E: c& D1 m5 d
不设置回复可见,大家一起学习~感谢
本文为杰杰原创如需转载,请说明出处:
( i0 M3 W' t" I9 A) y& s9 y8 X5 ~

$ m# r7 C: T2 v
收藏 3 评论19 发布时间:2018-9-18 21:07

举报

19个回答
wdshuang09 回答时间:2018-9-18 23:11:56
xiaojie0513 发表于 2018-9-18 22:49
5 H+ ?" T$ S/ L1 E; c9 o6 J- y% j( W  K( I1 v- M
STM32进阶之串口环形缓冲区实现
- s; ?+ t% g& w; Bhttps://www.stmcu.org.cn/module/forum/forum.php?mod=viewthread&tid=61 ...

0 i9 K7 b' K8 b% e这篇先前看过,好像是正点原子的例子改的,解析接收数据没有启到环形队列特点;比如当你接收到一帧数据时,(USART_RX_STA|=0x8000;        //接收完成了);假设CPU处理外设多,没有及时处理这一帧数据,此时串口又来了一帧数据,就会丢数据了,没有用到环形队列缓存功能,# V- R$ M' n9 V. h5 w6 i  V

: S8 f6 p" y; Xvoid USART1_IRQHandler(void)                        //串口1中断服务程序
5 _4 ?( h6 Z" N6 \        {; L  e" b: p+ t1 q/ M3 j9 Y! f1 m" I2 F( F
        u8 Res;; f1 t* S6 ]9 ~. R( I8 R3 ^8 K
#if SYSTEM_SUPPORT_OS                 //如果SYSTEM_SUPPORT_OS为真,则需要支持OS.2 w% k3 E3 p3 `1 c6 d2 l# c
        OSIntEnter();   
8 G' Q9 u" @  V#endif: G. B2 E5 {6 x) m% ]: Z" D
        if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)! @- `0 W8 B  e% K" y8 T
                {% Q& X8 S* m! x( W! K1 `
                Res =USART_ReceiveData(USART1);        //读取接收到的数据- X  H( @- R& g! T
                9 C, K. b% i, ~  a( d6 N# L  G
                if((USART_RX_STA&0x8000)==0)//接收未完成
, A' G" j( q; a; c8 M                        {
0 R0 i* s' `& P" V" K                        if(USART_RX_STA&0x4000)//接收到了0x0d5 x3 f7 ?$ P* K8 v. x
                                {
0 V: p* `' f4 z' E  S                                if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始+ Z2 k2 D( f0 h
                                else USART_RX_STA|=0x8000;        //接收完成了
8 e4 c7 j+ ]; Y% N                                }
& E7 C8 {' v+ O8 s' Y% G( E7 R# Z; t4 I                        else //还没收到0X0D+ v4 p# l$ q" M* {# Y. _
                                {       
" i% D0 ^- F* Z" t                                if(Res==0x0d)USART_RX_STA|=0x4000;
, R1 G* T! R1 m0 \; X% I                                else, i% N! k- `; ?. q0 @% |& n% m* i
                                        {
6 g0 Q. L3 k% M5 {/ d                                        USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
! w. }0 E9 }5 [: e& F                                        USART_RX_STA++;2 w7 u- D5 I8 P. A, v+ v% Y3 b0 z
                                        if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收          
1 f/ |) U+ w  T0 a6 ]                                        }                 
3 X% |. Q. S. @  M1 O                                }$ g8 b' W! y6 P! X# `6 ~
                        }                    
6 E/ r+ J% s5 h1 q; [+ t     }
# {) i/ L0 m( }, L; `- b#if SYSTEM_SUPPORT_OS         //如果SYSTEM_SUPPORT_OS为真,则需要支持OS.8 |" H. c" G, l, i! K3 H' @1 O
        OSIntExit();                                                                                           
7 N6 Z3 [% _! _. G' M* U" q+ d#endif
& h& K. @+ a8 l7 t+ Y* z0 `}                  
wdshuang09 回答时间:2018-9-19 08:57:50
xiaojie0513 发表于 2018-9-19 01:47, C* X2 |" E$ q$ \4 t3 t* a4 u4 W
你接收完如果暂时没法处理可以将数据放到缓冲区去,然后有空再去处理,,,你这仅仅是接收而已,你在哪放 ...
! Q; Q% ~- x0 f+ R  ]
这个逻辑好像不对,/ ]9 e; Q0 N4 }. C& |( c) y
1、接收数据就是直接放在环形队列中,待CPU有空闲时根据环形队列队头与队尾位置,逐步取出接收到的数据进行处理;$ [" z9 D( o+ k; B5 h
2、如果你每接收到一个数据都去中断判断是否接收一帧数据,会影响CPU的效率,接收中断只接收数据,不做任何数据分析,来一个存一个,减少在中断里处理的时间;待CPU空闲时去环形队列中取数据、解析数据! p# K, _) q* U& u" k8 G7 K. H) {9 a
3、已经定义了一个环形队列,还去定义一个缓冲区好像有点多余,如果CPU没有时间处理那就不去环形队列取数据即可了,空闲时去取不就可以了。
, Y' v& ^9 P- n# i
wdshuang09 回答时间:2018-9-19 13:48:31
xiaojie0513 发表于 2018-9-19 12:25
- D% G4 W9 [! B3 }$ r& V8 u0 n; Mf1的dma是没有FIFO的吧,dma接收根本无需CPU去处理的好吗,先理解一下吧,,,,,dma接收的数据是放到指 ...

3 [2 T1 D$ {* U3 V7 O1 O0 W" n$ s0 O这里说的是你发的“STM32进阶之串口环形缓冲区实现”贴子,对于贴子内容是采用环形串口收接,没有说这篇贴子DMA处理;当然有些单片机没有DMA处理,采用环形接收的数据,看到“STM32进阶之串口环形缓冲区实现”这篇贴子,说了一下个人的理解,6 w7 i. b8 X5 w4 @6 s, x; U
对于这种环形队列加中断的方式接收数据和楼主探讨如何更高效接收与解析数据的方法。
3 Q/ P1 Z5 ^& i. y
1.jpg
wdshuang09 回答时间:2018-9-18 22:17:10
有些单片机是没有DMA,可以用环形串口接收数据,不知楼主有没有环形串口结合中断方式接收定长与不定长的数据例子,
xiaojie0513 回答时间:2018-9-18 22:49:39
wdshuang09 发表于 2018-9-18 22:17
& z: T0 S  L- p. \; F有些单片机是没有DMA,可以用环形串口接收数据,不知楼主有没有环形串口结合中断方式接收定长与不定长的数 ...

* @0 I* B% ?1 o% z$ }* q
8 D+ G- V$ s% @STM32进阶之串口环形缓冲区实现2 L' }2 `0 f* {% M0 {2 f
https://www.stmcu.org.cn/module/ ... amp;fromuid=3250941
& x8 I  i" I, x1 ?(出处: 意法半导体STM32/STM8技术社区)4 H, w, }" v. B$ `

1 u9 m& @) }5 S& N; W6 Q- m+ t" R
xiaojie0513 回答时间:2018-9-19 01:46:40
wdshuang09 发表于 2018-9-18 23:11
3 Z$ @5 X# h6 \1 x" h8 M  ^" B这篇先前看过,好像是正点原子的例子改的,解析接收数据没有启到环形队列特点;比如当你接收到一帧数据时 ...

$ f/ U0 R) o2 D- r" i. ?+ a你这是接收,跟缓冲区有啥关系啊?
! f: O8 K5 S1 v9 K1 `4 S
xiaojie0513 回答时间:2018-9-19 01:47:31
xiaojie0513 发表于 2018-9-19 01:46
& C6 r3 T. Q6 ^你这是接收,跟缓冲区有啥关系啊?
. ]) S$ a5 X% W7 e/ ^; ~+ N7 P; b
你接收完如果暂时没法处理可以将数据放到缓冲区去,然后有空再去处理,,,你这仅仅是接收而已,你在哪放入缓冲区呢
loveu99 回答时间:2018-9-19 09:33:55
wdshuang09 发表于 2018-9-18 23:11/ Q+ B; E0 V4 a( E
这篇先前看过,好像是正点原子的例子改的,解析接收数据没有启到环形队列特点;比如当你接收到一帧数据时 ...
( y8 B  I, L+ G' i' t4 g
我看到我们一同事在用这种代码格式,我想他也写不出这样的格式呀,原来是出自正点原子
xiaojie0513 回答时间:2018-9-19 12:25:08
wdshuang09 发表于 2018-9-19 08:57
( F( m( j. F, o% H7 O7 I这个逻辑好像不对,
2 n4 }$ k' I" h- i7 Y1、接收数据就是直接放在环形队列中,待CPU有空闲时根据环形队列队头与队尾位置,逐 ...

& z8 W! i3 x" W4 K  T; Af1的dma是没有FIFO的吧,dma接收根本无需CPU去处理的好吗,先理解一下吧,,,,,dma接收的数据是放到指定的缓冲区的,并没有使用环形队列,,,,使用环形队列需要CPU的参与,,这是f1的,你可以在接收完重置dma存放数据的位置,也能起到缓存的作用' E1 ^: h+ [; w( U

! m0 ]4 \$ Y' Y% }4 G支持FIFO的dma无需这样子做。
xiaojie0513 回答时间:2018-9-19 12:26:06
loveu99 发表于 2018-9-19 09:33
; ~# V4 }4 b8 D* n! Q我看到我们一同事在用这种代码格式,我想他也写不出这样的格式呀,原来是出自正点原子 ...

) {8 \; n8 K0 G4 i每来一个字节的数据就进入中断一次,效率太低,,,
ssssss 回答时间:2018-9-19 14:39:46
本帖最后由 wwwheihei 于 2018-9-19 15:53 编辑 5 N" ~4 [; g! G: B8 Y) P
wdshuang09 发表于 2018-9-19 13:48; R, ]" c; k" V+ m& c) P
这里说的是你发的“STM32进阶之串口环形缓冲区实现”贴子,对于贴子内容是采用环形串口收接 ...
1 @) n4 p, C- W  R5 x
dma接收就可以了,够高效了,
wdshuang09 回答时间:2018-9-19 14:57:49
wwwheihei 发表于 2018-9-19 14:396 y' ]3 f% J; a9 `% _) ?' S
dma接收就可以了,够高效了,再往高就是装x了

6 M% A# i  h; y不要断章取义,也不要出口成脏,你说的DMA效率高效,不一定每款单片机都有DMA,同时也不防碍讨论环形队列接收数据高效的方法。
ssssss 回答时间:2018-9-19 15:15:20
wdshuang09 发表于 2018-9-19 14:57- f5 Y: I9 C& r0 P- T
不要断章取义,也不要出口成脏,你说的DMA效率高效,不一定每款单片机都有DMA,同时也不防碍讨论环形队列 ...

+ O/ H& s2 z) }' C没有出口成章啊,在一般应用中数据流没那么快,所以说高效不高效还得看项目需求。如果每一帧的间隔时间比较长,或者数据交互比较不频繁,我觉得用不用都可以
xiaojie0513 回答时间:2018-9-19 20:16:13
wdshuang09 发表于 2018-9-19 13:48
. k) i; d4 j  {1 q. b. D/ {这里说的是你发的“STM32进阶之串口环形缓冲区实现”贴子,对于贴子内容是采用环形串口收接 ...
2 h7 r) W+ G- [- ~8 ?
其实,反正我喜欢dma+空闲中断,,,我一般都用32的芯片,如果非要说环形缓冲区的话,,,,Linux的kfifo很经典,我也移植到32了,,到时候可以发出来看看,支持os
12下一页

所属标签

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32Cube扩展软件包
意法半导体边缘AI套件
ST - 理想汽车豪华SUV案例
ST意法半导体智能家居案例
STM32 ARM Cortex 32位微控制器
关注我们
st-img 微信公众号
st-img 手机版