|
本帖最后由 xiaojie0513 于 2018-9-18 21:07 编辑 引言 在使用stm32或者其他单片机的时候，会经常使用到串口通讯，那么如何有效地接收数据呢？假如这段数据是不定长的有如何高效接收呢？ 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请求的优先权。 而STM32F4/F7/H7系列的MCU有两个DMA控制器总共有16个数据流（每个DMA控制器8个），每一个DMA控制器都用于管理一个或多个外设的存储器访问请求。每个数据流总共可以有多达8个通道（或称请求）。每个通道都有一个仲裁器，用于处理 DMA 请求间的优先级。) N, Z0 H: L2 c4 G( x/ g6 } b$ o$ P' y8 x2 b DMA接收数据9 M* a/ d# x( r' k DMA在接收数据的时候，串口接收DMA在初始化的时候就处于开启状态，一直等待数据的到来，在软件上无需做任何事情，只要在初始化配置的时候设置好配置就可以了。等到接收到数据的时候，告诉CPU去处理即可。
其实，有很多方法：
DMA+串口空闲中断 这两个资源配合，简直就是天衣无缝啊，无论接收什么不定长的数据，管你数据有多少，来一个我就收一个，就像广东人吃“山竹”，来一个吃一个~（最近风好大，我好怕）。 可能很多人在学习stm32的时候，都不知道idle是啥东西，先看看stm32串口的状态寄存器： 当我们检测到触发了串口总线空闲中断的时候，我们就知道这一波数据传输完成了，然后我们就能得到这些数据，去进行处理即可。这种方法是最简单的，根本不需要我们做多的处理，只需要配置好，串口就等着数据的到来，dma也是处于工作状态的，来一个数据就自动搬运一个数据。 接收完数据时处理串口接收完数据是要处理的，那么处理的步骤是怎么样呢？
注意事项 STM32的IDLE的中断在串口无数据接收的情况下，是不会一直产生的，产生的条件是这样的，当清除IDLE标志位后，必须有接收到第一个数据后，才开始触发，一断接收的数据断流，没有接收到数据，即产生IDLE中断。如果中断发送数据帧的速率很快，MCU来不及处理此次接收到的数据，中断又发来数据的话，这里不能开启，否则数据会被覆盖。有两种方式解决：
实验效果： 当外部给单片机发送数 据的时候，假设这帧数据长度是1000个字节，那么在单片机接收到一个字节的时候并不会产生串口中断，只是DMA在背后默默地把数据搬运到你指定的缓冲区里面。当整帧数据发送完毕之后串口才会产生一次中断，此时可以利用DMA_GetCurrDataCounter()函数计算出本次的数据接受长度，从而进行数据处理。 串口的配置 /**6 g, b+ |+ t/ B- B# ?很简单，基本与使用串口的时候一致，只不过一般我们是打开接收缓冲区非空中断，而现在是打开空闲中断——USART_ITConfig(DEBUG_USARTx, USART_IT_IDLE, ENABLE);。 * @brief USART GPIO 配置,工作参数配置/ S& c0 q$ H( T$ y( \ * @param 无, T6 E/ w* N Z: Q * @retval 无 */ void USART_Config(void) {) Z+ T e; p9 o' E- P1 o GPIO_InitTypeDef GPIO_InitStructure; USART_InitTypeDef USART_InitStructure; - e4 y6 s$ L8 [4 H* ^ // 打开串口GPIO的时钟' V- x; C$ ^! N- [" T2 D DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE); // 打开串口外设的时钟7 L- r9 B; g4 Q0 ~/ R6 Q X DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);) s& O4 Z% Y4 Q% B6 n // 将USART Tx的GPIO配置为推挽复用模式( l" S( T( |5 T6 c8 J GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;7 D1 h& P) z4 x( v" o' K GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure); // 将USART Rx的GPIO配置为浮空输入模式 GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;% |# O6 l' w6 d9 z1 S9 U GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure); // 配置串口的工作参数 // 配置波特率 USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;& U, ]$ I9 `7 I4 w' T( g3 ] // 配置 针数据字长 USART_InitStructure.USART_WordLength = USART_WordLength_8b;: Q5 d* x8 q& T/ ` // 配置停止位 USART_InitStructure.USART_StopBits = USART_StopBits_1; // 配置校验位9 B0 V4 d4 S3 L; d9 j; c6 u USART_InitStructure.USART_Parity = USART_Parity_No ;/ ?8 Y: W! V8 Z P$ H$ @. [ // 配置硬件流控制 USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // 配置工作模式，收发一起& B l9 t3 ~5 x9 h1 u& q( P; K USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; // 完成串口的初始化配置) B7 q% ?+ X* h& X1 G! ? USART_Init(DEBUG_USARTx, &USART_InitStructure);& g4 ]! ]. _* W1 H) J+ }( F // 串口中断优先级配置: u% ^6 D- V0 i$ l+ X NVIC_Configuration();0 }( t$ p9 B6 L7 f+ w7 W #if USE_USART_DMA_RX 6 K! q" c3 Q; n1 g9 t, r // 开启 串口空闲IDEL 中断 USART_ITConfig(DEBUG_USARTx, USART_IT_IDLE, ENABLE); 1 x: `5 ~8 s2 e // 开启串口DMA接收 USART_DMACmd(DEBUG_USARTx, USART_DMAReq_Rx, ENABLE); /* 使能串口DMA */ USARTx_DMA_Rx_Config(); #else // 使能串口接收中断 USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE); #endif + E$ r+ x$ z) I #if USE_USART_DMA_TX // 开启串口DMA发送, f- x) z) k: u! \$ P# W1 c. C) o9 {1 q4 T // USART_DMACmd(DEBUG_USARTx, USART_DMAReq_Tx, ENABLE); USARTx_DMA_Tx_Config(); #endif: A+ i( ?! W* M7 x: d 9 G% ]" Y6 A3 b: y+ I // 使能串口 USART_Cmd(DEBUG_USARTx, ENABLE); , H5 r3 V* p. n% K: w6 j } 串口DMA配置 把DMA配置完成，就可以直接打开DMA了，让它处于工作状态，当有数据的时候就能直接搬运了。 #if USE_USART_DMA_RX 1 l9 n6 E; k2 d0 Z" f+ z' }1 r4 }2 Y- @ static void USARTx_DMA_Rx_Config(void) {9 r* y, Y5 F& b( m/ Z DMA_InitTypeDef DMA_InitStructure;) v R2 H; T' D6 H$ x, k // 开启DMA时钟 RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); // 设置DMA源地址：串口数据寄存器地址*/ DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)USART_DR_ADDRESS;6 f2 p& ^! i, W: G5 G // 内存地址(要传输的变量的指针)! B# a% z5 E4 K2 M8 w2 f. @! @$ X DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)Usart_Rx_Buf; // 方向：从内存到外设 5 c! S0 |) L1 V7 M1 Z; b DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;9 Q7 U$ @4 \$ W S) q5 i1 f // 传输大小 DMA_InitStructure.DMA_BufferSize = USART_RX_BUFF_SIZE; // 外设地址不增 DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;, a, \+ A7 w, N // 内存地址自增3 p$ E. R9 t! ~2 g% N. P. ? DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;4 O; b* b3 |1 L F9 [7 g( C) o: K // 外设数据单位 DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; // 内存数据单位 DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; ) J. Y1 F3 _- ^$ U8 k4 K2 U; F // DMA模式，一次或者循环模式 //DMA_InitStructure.DMA_Mode = DMA_Mode_Normal ;5 D( c6 g) W( @4 \' u7 ^ DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; 1 u. Y* p+ |% y* c) p' u% y5 _ // 优先级：中 DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh; // 禁止内存到内存的传输 DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; // 配置DMA通道 DMA_Init(USART_RX_DMA_CHANNEL, &DMA_InitStructure); // 清除DMA所有标志 DMA_ClearFlag(DMA1_FLAG_TC5);4 n( m7 q# v3 q' U5 E3 Y9 n3 V2 U DMA_ITConfig(USART_RX_DMA_CHANNEL, DMA_IT_TE, ENABLE); // 使能DMA DMA_Cmd (USART_RX_DMA_CHANNEL,ENABLE); }7 O7 c L/ U8 m8 @! P6 ^1 u. T #endif- x2 `2 k6 ?4 _* j3 N/ ^- u4 \ 接收完数据处理 因为接收完数据之后，会产生一个idle中断，也就是空闲中断，那么我们就可以在中断服务函数中知道已经接收完了，就可以处理数据了，但是中断服务函数的上下文环境是中断，所以，尽量是快进快出，一般在中断中将一些标志置位，供前台查询。在中断中先判断我们的产生在中断的类型是不是idle中断，如果是则进行下一步，否则就无需理会。 /********************************************************************7 `9 {: U& y% ^5 Z2 H( \ * @brief 串口中断服务函数 B; Y& M# o# |8 p * @author jiejie * @version V1.01 i* w+ B- n! B1 P) Q * @date 2018-xx-xx* c/ g) g* Y5 h6 ]- j ******************************************************************2 a. u6 Q1 Q+ [5 P/ y# G */ void DEBUG_USART_IRQHandler(void) {, S$ V3 o! }& A# a- O2 u/ ^+ i& _ #if USE_USART_DMA_RX /* 使用串口DMA */8 x6 _7 `: c# L- S) S! a/ B0 E" v( E if(USART_GetITStatus(DEBUG_USARTx,USART_IT_IDLE)!=RESET) { 6 ]) K, R1 M3 Y /* 接收数据 */ Receive_DataPack();4 t2 Z2 n: @( l4 ^$ ^ // 清除空闲中断标志位 USART_ReceiveData( DEBUG_USARTx ); } #else /* 接收中断 */7 m9 d7 s# `; |! r9 _ if(USART_GetITStatus(DEBUG_USARTx,USART_IT_RXNE)!=RESET) { Receive_DataPack();; b4 F( h8 u6 K5 `0 W }3 L1 _* `: C2 G1 _% r* o #endif } Receive_DataPack() 这个才是真正的接收数据处理函数，为什么我要将这个函数单独封装起来呢？因为这个函数其实是很重要的，因为我的代码兼容普通串口接收与空闲中断，不一样的接收类型其处理也不一样，所以直接封装起来更好，在源码中通过宏定义实现选择接收的方式！更考虑了兼容操作系统的，可能我会在系统中使用dma+空闲中断，所以，供前台查询的信号量就有可能不一样，可能需要修改，我就把它封装起来了。不过无所谓，都是一样的。 /************************************************************* @brief Uart_DMA_Rx_Data * @param NULL * @return NULL * @author jiejie& a& J/ b* J7 L1 d( K# q, M4 P * @github http://github.com/jiejieTop * @date 2018-xx-xx2 X- @: }+ V3 y * @version v1.0 * @note 使用串口 DMA 接收时调用的函数 ***********************************************************/; d* |" M$ D% a: }% x- O3 G+ J8 N #if USE_USART_DMA_RX void Receive_DataPack(void)+ E6 A& \) s4 p/ v { /* 接收的数据长度 */ uint32_t buff_length; % h v2 {8 J) N( l /* 关闭DMA ，防止干扰 */* r# Z% o( G i8 N DMA_Cmd(USART_RX_DMA_CHANNEL, DISABLE); /* 暂时关闭dma，数据尚未处理 */ * v: [7 g; s. y 6 h. w2 A9 \7 y. X Z /* 清DMA标志位 */ DMA_ClearFlag( DMA1_FLAG_TC5 ); ( ^; ?+ ~8 u3 W, F |. g9 h /* 获取接收到的数据长度 单位为字节*/' Z( ?1 ^ a* c/ Q7 A buff_length = USART_RX_BUFF_SIZE - DMA_GetCurrDataCounter(USART_RX_DMA_CHANNEL);6 s2 z- v( z* \ " ?3 a9 n1 [+ ]. \& n" i /* 获取数据长度 */# j/ m" N7 |2 L: g+ S7 j; D0 [* M2 h Usart_Rx_Sta = buff_length; ; W* F6 P; h3 e PRINT_DEBUG("buff_length = %d\n ",buff_length);" d! o! g; O! m 0 _; Z/ {7 u1 w" g6 N /* 重新赋值计数值，必须大于等于最大可能接收到的数据帧数目 */& h8 }' y. H- c3 T. @ USART_RX_DMA_CHANNEL->CNDTR = USART_RX_BUFF_SIZE; 0 V2 w1 w( g# k0 z! k Y! G6 @( J /* 此处应该在处理完数据再打开，如在 DataPack_Process() 打开*/4 w" ^* o2 _/ [: d DMA_Cmd(USART_RX_DMA_CHANNEL, ENABLE); /* (OS)给出信号 ，发送接收到新数据标志，供前台程序查询 */ G5 M& L8 ?0 g/ b& d5 q 0 x+ t( F% t; ]; h/ J; ^ /* 标记接收完成，在 DataPack_Handle 处理*/ Usart_Rx_Sta |= 0xC000;4 D: ^! k1 @9 W. ^7 _! ^ $ g% e5 S P; Q, g1 H! L /* 7 J" j! h g, s) D( ` DMA 开启，等待数据。注意，如果中断发送数据帧的速率很快，MCU来不及处理此次接收到的数据， 中断又发来数据的话，这里不能开启，否则数据会被覆盖。有2种方式解决：' B8 M" q V5 f5 n8 h3 E ) j% J" p) I; ~) j: [; v. Y5 ` 1. 在重新开启接收DMA通道之前，将Rx_Buf缓冲区里面的数据复制到另外一个数组中，2 S0 w8 R( t& C: _) l- W 然后再开启DMA，然后马上处理复制出来的数据。) Q: J& C$ U' k" b7 F7 b 7 w3 R5 i' p; U4 T5 _' B( e 2. 建立双缓冲，重新配置DMA_MemoryBaseAddr的缓冲区地址，那么下次接收到的数据就会& M9 }- }5 a1 C8 D 保存到新的缓冲区中，不至于被覆盖。 */ } f1使用dma是非常简单的，我在f4用dma的时候也遇到一些问题，最后看手册解决了，打算下一篇文章就写一下调试过程，没有什么是debug不能解决的，如果有，那就两次。今天台风天气，连着舍友的WiFi更新的文章~中国电信还是强，台风天气信号一点都不虚，我的移动卡一动不动-_-. # M$ a' L" z3 i% z, | 不设置回复可见，大家一起学习~感谢 本文为杰杰原创如需转载，请说明出处： 3 ]+ }) s& G7 q! `7 `) n |
微信公众号
手机版
这篇先前看过，好像是正点原子的例子改的，解析接收数据没有启到环形队列特点；比如当你接收到一帧数据时，（USART_RX_STA|=0x8000; //接收完成了）；假设CPU处理外设多，没有及时处理这一帧数据，此时串口又来了一帧数据，就会丢数据了，没有用到环形队列缓存功能，
6 j6 r% t _7 Y
void USART1_IRQHandler(void) //串口1中断服务程序+ \- F# u+ q5 q9 v4 O
{
u8 Res;
#if SYSTEM_SUPPORT_OS //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
OSIntEnter(); " U" T2 @* a% S+ G1 P" C+ e
#endif
if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾)8 c# I$ E, ~" b6 I# X
{
Res =USART_ReceiveData(USART1); //读取接收到的数据& \$ i) J1 P- }/ t
5 v& ?$ x) R& H6 M' s9 o
if((USART_RX_STA&0x8000)==0)//接收未完成
{5 b$ w1 M* U6 _0 S P9 T! Q
if(USART_RX_STA&0x4000)//接收到了0x0d/ J8 Q4 C8 x# w0 n& w& m, F4 [8 w ?; v
{
if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
else USART_RX_STA|=0x8000; //接收完成了
}1 [. O; d( h I/ i* ^
else //还没收到0X0D
{ . o/ b7 y; n1 [3 u/ S0 r; N0 h
if(Res==0x0d)USART_RX_STA|=0x4000;* ^) l/ j0 w2 R; W0 b
else
{
USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;% l: m- l4 A( r$ S
USART_RX_STA++;
if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收
}
}
} 2 E/ u( e, |9 M7 m. `. ^! t
}
#if SYSTEM_SUPPORT_OS //如果SYSTEM_SUPPORT_OS为真，则需要支持OS., m$ w; W# p) J" b
OSIntExit();
#endif3 r! p' f. U1 H( R$ V
}
这个逻辑好像不对，
1、接收数据就是直接放在环形队列中，待CPU有空闲时根据环形队列队头与队尾位置，逐步取出接收到的数据进行处理；$ S- A# N3 Z. ?) f- W+ j0 N
2、如果你每接收到一个数据都去中断判断是否接收一帧数据，会影响CPU的效率，接收中断只接收数据，不做任何数据分析，来一个存一个，减少在中断里处理的时间；待CPU空闲时去环形队列中取数据、解析数据) {! H* E: `6 S, D
3、已经定义了一个环形队列，还去定义一个缓冲区好像有点多余，如果CPU没有时间处理那就不去环形队列取数据即可了，空闲时去取不就可以了。6 K" @; q. y" `, ]1 [: P/ m
这里说的是你发的“STM32进阶之串口环形缓冲区实现”贴子，对于贴子内容是采用环形串口收接，没有说这篇贴子DMA处理；当然有些单片机没有DMA处理，采用环形接收的数据，看到“STM32进阶之串口环形缓冲区实现”这篇贴子，说了一下个人的理解，. K0 [5 \+ A3 L. N* G/ F2 \% N
对于这种环形队列加中断的方式接收数据和楼主探讨如何更高效接收与解析数据的方法。0 M* E& B1 Q" q+ l' r
有
STM32进阶之串口环形缓冲区实现0 E$ x3 W ~' M
https://www.stmcu.org.cn/module/ ... amp;fromuid=32509414 A7 n0 V: w" l8 h# I T/ ^' P% W' |
(出处: 意法半导体STM32/STM8技术社区)
7 ]3 F( ~! a4 j4 ~1 e. L4 f# [* z9 D
你这是接收，跟缓冲区有啥关系啊？) ]% ^* C: X4 h6 R; o
你接收完如果暂时没法处理可以将数据放到缓冲区去，然后有空再去处理，，，你这仅仅是接收而已，你在哪放入缓冲区呢
我看到我们一同事在用这种代码格式，我想他也写不出这样的格式呀，原来是出自正点原子
f1的dma是没有FIFO的吧，dma接收根本无需CPU去处理的好吗，先理解一下吧，，，，，dma接收的数据是放到指定的缓冲区的，并没有使用环形队列，，，，使用环形队列需要CPU的参与，，这是f1的，你可以在接收完重置dma存放数据的位置，也能起到缓存的作用
& ~# T3 \1 q. ^0 h- V6 \: R
支持FIFO的dma无需这样子做。
每来一个字节的数据就进入中断一次，效率太低，，，
dma接收就可以了，够高效了，
不要断章取义，也不要出口成脏，你说的DMA效率高效，不一定每款单片机都有DMA，同时也不防碍讨论环形队列接收数据高效的方法。
没有出口成章啊，在一般应用中数据流没那么快，所以说高效不高效还得看项目需求。如果每一帧的间隔时间比较长，或者数据交互比较不频繁，我觉得用不用都可以
其实，反正我喜欢dma+空闲中断，，，我一般都用32的芯片，如果非要说环形缓冲区的话，，，，Linux的kfifo很经典，我也移植到32了，，到时候可以发出来看看，支持os