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

如何让STM32优雅地“说”hello world?

[复制链接]
Lumhao 发布时间:2020-6-17 15:48
01
前言

* F3 x) Z2 f- ]: u( R
STM32上hello world,说白了就是使用串口向PC上的上位机软件或者串口调试助手发送字符串。
串口的使用方法百度一下就能知道了,简单来说就是下面这样。
uint8_t buff[BUFF_SIZE];//定义一个缓存数组
# @1 u, G) B' P1 jHAL_UART_Receive_IT(&huart1, (uint8_t *)buff, BUFF_SIZE);//打开串口接收中断
' K# g9 l6 X3 E* i9 E- n
串口中断打开之后,当接收到BUFF_SIZE个数据后就会进入
# t, b2 }8 A; `; x' p3 L' b1 n* B
[backcolor=rgba(0, 0, 0, 0.027)]void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)[backcolor=rgba(0, 0, 0, 0.027)];
5 |8 X8 d/ d* {' [5 q
然后我们就可以在上面这个函数下操作收到的数据啦,简单方便快捷。当然实际操作一遍后大家就会发现,这个程序只能进入一次中断,之后就再也收不到数据了,这是因为HAL库在每次进入串口中断时都会把这个中断关闭,所以我们处理完数据之后,要重新打开中断。
+ Y# j$ }6 r% c" B6 E3 X3 W  Q

  • 8 ~+ V' Z: T$ w6 h% i( L
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){    //处理数据...
1 P0 S- W2 h" J4 ?- f" q& d, r    HAL_UART_Receive_IT(&huart1, (uint8_t *)buff, BUFF_SIZE);}
而发送数据呢,就用
( D' Z6 ?& c; E& b! M) \- A% }
% E; F( R8 D3 F( M5 A
[backcolor=rgba(0, 0, 0, 0.027)]HAL_UART_Transmit(&huart1, ([backcolor=rgba(0, 0, 0, 0.027)]uint8_t[backcolor=rgba(0, 0, 0, 0.027)] *)buff, BUFF_SIZE,[backcolor=rgba(0, 0, 0, 0.027)]0xffff[backcolor=rgba(0, 0, 0, 0.027)]);
  d" M  J- H. w6 R7 @
知道串口怎么用了,我们就可以想办法hello world。重定向printf的方法百度一搜一大片,fputc这个函数是_weak定义的,自己写一个就可以覆盖过去了。

; \3 z; {; W, |0 N$ h3 D9 x4 {1 [5 u4 k8 A2 r9 t  g9 q7 l2 d

    & B5 s; O$ U: @2 n
    int
    fputc
    (int ch, FILE *f)
  • + {3 F9 g( C, C  s; @, J2 F
{  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1,0xffff);  return ch;}0 h* @. Q/ w2 ]
然后写下终极代码,完美。

9 ~  z) O# M# _$ z9 j6 d/ I4 E3 l; B* P9 {* M
[backcolor=rgba(0, 0, 0, 0.027)]printf[backcolor=rgba(0, 0, 0, 0.027)]([backcolor=rgba(0, 0, 0, 0.027)]"hello world\r\n"[backcolor=rgba(0, 0, 0, 0.027)]);

: E4 S- [$ Y0 o. t* S( K: M
上面的内容百度上可以找到很多很多文章,而且讲的又详细又生动,这里我只是带大家复习一下,如果你能够熟练掌握上面的内容了,那接下来就可以进入正题,看看如何变得更优雅。
02
变优雅第一步
5 V' w% \6 n% n5 U$ u( D7 x. }- H! T
我们实际运行这个代码,发现在串口接收几次数据之后,又突然会再也接收不到数据了。因为即使你记得在处理完数据之后及时打开了接收中断,开启中断的的函数也不一定总是能正确开启,我一直觉得这是HAL库的一个坑。我翻了很久的百度,终于找到一种解决方案。
" U$ f' c( C" w7 N% _% p

/ F5 h  l# w9 O* k, n' }9 I
    . C7 @  J0 ~9 Z
    void
    HAL_UART_RxCpltCallback
    (UART_HandleTypeDef *huart)
    {
    //处理数据...5 O  Z- M( m) ]6 n6 g
    int i=0;    while(HAL_UART_Receive_IT(&huart1,(uint8_t *)&buff,1) != HAL_OK )       {  i++;  if(i>10000)  {    huart6.RxState=HAL_UART_STATE_READY;    __HAL_UNLOCK(&huart1);    i=0;  }    }}
- M% y6 f4 Y+ S( z
事情就是这么神奇,单单执行一句开中断不一定能成功的,开完还要检查一下是不是真的开成功了,不行的话再打开一下试试,试了10000次还不行,生气了,强制开。

9 Q* {& t5 ]' M$ P
03
变优雅第二步

! q2 Z9 v: j' z5 B
百度上看到的串口教程,大家都是用下面这个函数
; T% W1 o( g, h% j
5 o- Y& D' T! d; u# U
[backcolor=rgba(0, 0, 0, 0.027)]HAL_UART_Transmit(&huart1, ([backcolor=rgba(0, 0, 0, 0.027)]uint8_t[backcolor=rgba(0, 0, 0, 0.027)] *)buff, BUFF_SIZE,[backcolor=rgba(0, 0, 0, 0.027)]0xffff[backcolor=rgba(0, 0, 0, 0.027)]);

+ C& Z5 y0 n& n( @+ E3 N  n- V$ P9 T" E
就是说,CPU找到串口,给串口huart1安排好任务:
“从这个buff的地址开始,挨个发BUFF_SIZE个数据,我就在边上守着,等你0XFFFF的时间,干不完就别给我干了!”
其实看到这么个代码我是很生气的,CPU作为大领导,员工干活的时候不去喝咖啡?在边上守着?这成何体统?
优雅的办法肯定是CPU交代好任务之后,转身去忙自己的事情了,而串口接到命令之后,默默完成任务,然后再跟CPU汇报一下。所以我们不光接收要用中断,发送也要用中断。
所以我们要用下面这个串口中断发送的函数
HAL_UART_Transmit_IT(&huart1, (uint8_t*)buff, BUFF_SIZE);
这个函数会使能发送中断,然后挨个发数据,发完之后执行一个回调函数,然后自己关掉发送中断。一条龙服务,用户什么都不用管。如果用户想多管闲事,可以把代码写在回调函数里。
于是乎,我们优雅地把串口发送改用中断的方式,那我们重定向的fputc可以写成

) {1 q8 {2 [% l- Q, n. X
4 M6 X$ X' o% B# V3 K' \8 G
[backcolor=rgba(0, 0, 0, 0.027)]HAL_UART_Transmit_IT(&huart1, ([backcolor=rgba(0, 0, 0, 0.027)]uint8_t[backcolor=rgba(0, 0, 0, 0.027)] *)buff, BUFF_SIZE);

8 }! Z7 q% j9 C1 e4 i" s
这样我们可以用先前的方法快乐地hello world了。
4 M- f0 u- [! o* H, {
, I& P$ K/ M% o
  • 7 }: I' V2 \4 m& B
int fputc(int ch, FILE *f){  HAL_UART_Transmit_IT(&huart1, (uint8_t *)&ch, 1);  return ch;}
& _% V" g5 d2 G3 C! K; E
爱动手的小伙伴一旦尝试一下就会发现,这傻逼的文章里的代码都没法跑,helloworld发了个h就不发了???
那么这是为什么呢?我们来分析一下这个程序执行的过程。printf里是把格式化好的字符一个一个交给fputc发送的,当发送第一个字符'h'时,串口处于空闲状态,能够正确地使能串口发送中断。因此,字符'h'正确发送。
但我们注意到,CPU给串口安排好工作后,并没有在原地等待,而是去执行后续的任务了,那后续的任务就是发送字符'e'。CPU再次来到fputc函数内,再次执行
9 q$ {0 H" Q3 t% B. o( G4 S* Q" A& V

3 ~! b5 H% i7 H0 Z; W; l2 G$ }
[backcolor=rgba(0, 0, 0, 0.027)]printf[backcolor=rgba(0, 0, 0, 0.027)]([backcolor=rgba(0, 0, 0, 0.027)]"hello world\r\n"[backcolor=rgba(0, 0, 0, 0.027)]);

* _5 g, ~) f2 `, Q
由于CPU的运行速度比串口快得多,此时串口还没有完成先前的字符'h'的发送任务,串口处于忙碌的状态,因此现在是无法正确打开串口发送中断的,因此字符'e'发送失败。后续的字符也是同样的情况。
这就说明,采用中断发送方式时,连续发送是会发送失败的,串口就只有这点速度,你枪顶着他脑袋他也快不起来。在每次使用串口发送中断时,都要检查一下是否正确打开了中断,和先前提到的串口接收中断一样,打开中断并不是总能成功的。于是,我们修改fputc函数成下面的样子。

, l( f: ~0 @9 G6 o( G# g
% T# T% O4 \+ w! }
[backcolor=rgba(0, 0, 0, 0.027)]HAL_UART_Transmit_IT(&huart1, ([backcolor=rgba(0, 0, 0, 0.027)]uint8_t[backcolor=rgba(0, 0, 0, 0.027)] *)&ch, [backcolor=rgba(0, 0, 0, 0.027)]1[backcolor=rgba(0, 0, 0, 0.027)]);

0 H/ b4 y) d$ Z5 f5 G. v) `) C
这样子,CPU不断地尝试打开串口中断直至成功为止。由于串口要完成先前的任务后才会由BUSY状态变成READY状态,所以这里际就是在等待串口发送。
仔细一想这个过程我们会发现,这不傻逼吗?用中断发送就是为了不堵塞CPU的工作,结果搞了半天,还是在这儿堵着?
那我们还是要进一步改进一下。如果使用了多线程的话,那我们可以进行任务切换,让CPU切换到别的线程工作一会儿。
# e/ T& P% h4 P+ H" P. n
' W6 j7 V. q9 V& M4 ?  q: |1 q" |

  • 8 f$ `3 A( P4 M6 |
int fputc(int ch, FILE *f){  while(HAL_UART_Transmit_IT(&huart1, (uint8_t *)&ch, 1)!=HAL_OK);  return ch;}% x( R2 c$ P; t3 H. b
但是这也有一个很明显的问题,CPU虽然释放出来了,但是串口堵了啊。当我们连续发送字符的时候,CPU总是会在前一个字符发送完成之前尝试发送下一个字符,然后中断打开失败,进入osDelay(1),要等1ms之后才会回来。这其实是非常慢的,hello world要大约10ms才能发送完毕,串口以1ms一个数据的速度发送,这依然不优雅。
要么CPU堵,要么串口堵,总有一个要等待,这可怎么办呢?我们回顾一下串口中断的API

3 s6 K" ]% G0 {$ |$ x
. g$ b7 ^! r* N, T2 b4 ]/ |8 a+ d

  • % b% g6 g6 R2 @" l
int fputc(int ch, FILE *f){  while(HAL_UART_Transmit_IT(&huart1, (uint8_t *)&ch, 1)!=HAL_OK) {    osDelay(1);//ARM CMSIS的API,相当于一般理解的sleep_ms(1); }  return ch;}! e: \: Z) W* S7 V
明显看到这个函数的第三个参数是一个size,它可以一次设置发送很多个数据,但我们在fputc中使用时,由于fputc是单个字符发送的,因此我们只能把size设置成1。如果能够一口气把所有要发送的数据都设置好,我们就不用重复地打开中断了,也就避免了前述的尴尬。
所以接下来要做的便是避开fputc这个令人尴尬的单个字符发送的函数,可是printf就是用这个函数的呀,要避开fputc,就不能用printf。我们自己搞一个更加优雅的!起一个好听的名字叫做debug,当然你喜欢的话叫别的也可以。
( W5 o/ ^% o; ?
. m2 S, @/ D9 h8 ]9 m

  • ' ?# R& Q* B( r
void debug(const char *format, ...){  static char tmpStr[64];        /*在静态区申请一块缓存,因为CPU开启中断之后不会原地等待,而是退出这个函数,          如果在栈上申请空间,函数退出时缓存区会直接释放掉,导致串口发送数据错误。          因此把缓存区申请在静态区        */
1 ?0 e$ w) \& {# h; j3 M        /*等待串口发送完毕,在串口忙于发送先前的数据时,不能修改缓存区内的数据,          否则数据会出错。等串口发送完成后,再把新的数据放进缓存区。        */  while(huart6.gState!=HAL_UART_STATE_READY);
8 f$ I' e9 x, c  //把数据放进缓存区里  va_list list;  va_start(list, format);  vsprintf(tmpStr,format, list);//这一部分不懂得同学请百度这个API,<stdio.h>里的  va_end(list);7 R' v& P# i, `& h" ~
  while(HAL_UART_Transmit_IT(&huart6,(uint8_t*)tmpStr,strlen(tmpStr))!=HAL_OK);        //开启中断发送,由于先前已经等待过串口发送完成了,按理说串口肯定是可以打开的        //但为了避免多线程或者中断等原因在别的地方打开了这个中断,依然用while尝试打开直到成功为止}  @6 i0 F. p" B$ m$ G; l, {
上面的函数接收不定长的输入,这个输入和printf的格式化是一模一样的,使用方法和printf完全一样。这样的话,每执行一次debug,只会开启一次中断,只要等待一次中断开启就可以了,不必像先前重映射fputc那样每发送一个字符都要开一次中断。
重映射fputc时,必然会产生连续发送的情形,而用后面这种方法的话,如果你没有连续地调用debug,很少会出现想发送却串口忙碌的情况,while的等待时间是比较少的。
当然如果你使用了多线程,并且串口发送数据没有那么多,但是又希望CPU一点儿也不堵塞。那就更可以稍微修改一下。
: g' c) z6 }( h+ d' A
9 p& [& b9 w# O# _

  • . T) k) X! Q9 m3 |. i
void debug(const char *format, ...){  static char tmpStr[64];  while(huart6.gState!=HAL_UART_STATE_READY)  {    osDelay(1);  }! x) Q+ x8 c( ]" e5 W; W/ }5 h/ J
  va_list list;  va_start(list, format);  vsprintf(tmpStr,format, list);  va_end(list);
5 _1 X% h- d4 e7 S' H* D  while(HAL_UART_Transmit_IT(&huart6,(uint8_t*)tmpStr,strlen(tmpStr)))        {                osDelay(1);        }}3 h# p9 g" w3 l. C" l, h
这样在连续执行debug时,会进行线程切换,好处是CPU不堵了,坏处是串口要延后1ms才能发送下一个字符串,但也远好于每个字符都延后1ms的方式,况且连续地debug也不是特别常见。在实际应用中,根据需求来使用吧。

! v# Y* y+ O. c& g
收藏 评论6 发布时间:2020-6-17 15:48

举报

6个回答
李康1202 回答时间:2020-6-17 16:24:08
顶一下
神圣雅诗人 回答时间:2020-6-18 08:30:50
签到
yklstudent 回答时间:2020-6-18 08:32:40
签到+1
yanxinboy 回答时间:2020-6-29 10:49:50
好文章, 解决了我最近的一个板子问题。
溪悦 回答时间:2020-6-29 15:46:13

( a6 t! v! g" ~$ t好文章% E$ A( E  z$ T5 S
好文章
lebment 回答时间:2020-7-30 16:19:31
呃,提个意见,废话太多。。。。。速览三遍找到结果,做个简单的表也很快。

所属标签

相似分享

关于意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新和工艺
招聘信息
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
关注我们
st-img 微信公众号
st-img 手机版