预备知识 请看下面两贴

+ n2 {& r. ?9 k! Z8 |STM32 如何快速创建 FREERTOS和RTX 工程
) f7 I; ^, N$ t$ a5 |干货 Nucleo072 usart 基于RTOS的应用 方便AT指令类外设开发

! J8 r; e  R- g" e$ |. n# Y9 |使用的 Nucleo 072板子  其他用户请稍许移植一下
- u1 @: P; H/ Q
原本楼主发上面两贴就开始策划 这个东西 计划参加 方案大赛的。

原方案计划设计一个 智能 开关局域网内 PC  手机APP 可同时管理所有灯具，按键使用 F0的触摸模块，使用WIFI 和433
组网，目前淘宝有十分成熟的 智能灯开关产品 不过都是用RF实现有兴趣可以搜索一下。
$ k9 a. e( \1 `2 X9 r, j9 h& `
结果最近太忙没空弄这个，加之考虑到本方案一个缺陷 那就是WIFI模块加入的热点需要配置。如果使用433模块再设计一套
6 D) b1 J2 z. ]8 v
可以配置WIFI的协议那是相当恐怖的  首先你的 433 主机（其他产品的遥控器）得支持液晶显示了，反正很麻烦了。不整了
& I) V& m) l+ S1 b7 D
现在将第一步完成的 内容分享大家参考  AT WIFI 产品设计，甚至蓝牙串口也可按同样的模式设计  。，纯串口当然不用说了
% D2 N' @8 p, X+ {- p

模块使用的 是8266 连接单片机 串口1  PA9 PA10引脚
( M4 P  |, u/ v8 i$ v8 Y6 }" m下面是 效果。，上位机还没写，使用网络调试助手 给模块发送指令下位机执行相应操作

5 w9 ]. t- B6 ^: f9 [截图发送了 3条指令  get ip ,get cpu id,和 set led on
/ l: G) @9 }7 l: z6 N" O
使用串口助手或者超级终端波特率115200 连接 stlink的虚拟串口 可以看到调试输出内容截图左边
/ r+ M, @) t8 p' a/ ^实际操作可看到板子上LD2 可由 set led on 打开或者又 set led off关闭
5 D4 f# n8 C& ^. O4 V, [" R  k

% p4 }' ^6 X  a% L

1. 
   

复制代码

+ `3 N6 g7 ~) |) t0 j* L- @
/ h  u+ c; l. G累死了  论坛竟然限制 发帖最大字符数   10000 帖子太长发帖失败  内容都没了 ，，，可怜的重新码了一次。。。

下面贴几个关键函数 讲解一下

# ]; Y' K0 G# W4 g2 Y% H) W+ U8 B

1. 
   , @4 F2 H7 n7 x$ f# U8 d# |  z
2. void USART1_IRQHandler()
   
3. {
   8 G! \' e/ w- f
4.         UART_HandleTypeDef *huart= &UartHandle1;
   
5.        
   + p* G) j. ]: ]% D! S% \: L# x, I
6.         /* UART parity error interrupt occurred -------------------------------------*/
   
7.   if((__HAL_UART_GET_IT(huart, UART_IT_PE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_PE) != RESET))
   
8.   {
   $ @+ A  n3 v3 ~7 |7 v
9.     __HAL_UART_CLEAR_IT(huart, UART_CLEAR_PEF);
   ; w/ D- Y. `( k% H2 d/ F
10.    
    0 V# Y6 A4 ?1 e( G# y* C! D! r7 ^
11.     huart->ErrorCode |= HAL_UART_ERROR_PE;
    
12.     /* Set the UART state ready to be able to start again the process */
    ' e$ x( V! {$ b  W
13.     huart->State = HAL_UART_STATE_READY;
    " x) ^4 b2 N3 [. o2 I, d- u0 D0 A
14.   }
    ' L$ ~8 P9 o  t' L7 K# x
15.   
    / v! U+ U. t' I% t  J8 d5 }$ U& N
16.   /* UART frame error interrupt occured --------------------------------------*/
    
17.   if((__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
    
18.   {
    
19.     __HAL_UART_CLEAR_IT(huart, UART_CLEAR_FEF);
    
20.    
    9 A8 o  v2 }6 i! K
21.     huart->ErrorCode |= HAL_UART_ERROR_FE;
    
22.     /* Set the UART state ready to be able to start again the process */
    $ C7 K, x$ D1 [$ M' {% p
23.     huart->State = HAL_UART_STATE_READY;
    # R4 A5 L6 y, s
24.   }
    
25.   
    5 Q+ \( X: c5 B- p* I! B4 w0 }9 _
26.   /* UART noise error interrupt occured --------------------------------------*/
    
27.   if((__HAL_UART_GET_IT(huart, UART_IT_NE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
      s5 _8 g: e4 C- S% M$ I) Y1 Q# k
28.   {
    
29.     __HAL_UART_CLEAR_IT(huart, UART_CLEAR_NEF);
    1 G& i8 x. {0 q, L# v! ?
30.    
    
31.     huart->ErrorCode |= HAL_UART_ERROR_NE;   
    1 G* Y. R! m0 [- a) u  Z' p1 x
32.     /* Set the UART state ready to be able to start again the process */
    
33.     huart->State = HAL_UART_STATE_READY;
    8 i* O$ {: [7 K0 z3 t
34.   }
    % W. M9 c$ O0 S0 X( ~' G& t
35.   
    $ q/ n7 L+ Y/ d/ ]' D9 S- j! q
36.   /* UART Over-Run interrupt occured -----------------------------------------*/
    % C$ E: o3 x: [
37.   if((__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
    
38.   {
    / g0 U' }' o+ J6 y0 i
39.     __HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
    
40.    
    8 F+ m8 x0 R# F' Z
41.     huart->ErrorCode |= HAL_UART_ERROR_ORE;     
    : o6 U" y' O2 r
42.     /* Set the UART state ready to be able to start again the process */
    2 E- q- ~: U( q' A
43.     huart->State = HAL_UART_STATE_READY;
    
44.   }
    ' ]- U4 {* @# Q
45.   
    
46.    /* Call UART Error Call back function if need be --------------------------*/
    . M3 y; I7 a+ [0 h' H# |: O6 y9 b
47.   if(huart->ErrorCode != HAL_UART_ERROR_NONE)
    
48.   {
    # j; r& j7 o& W7 q- N
49.     HAL_UART_ErrorCallback(huart);
    . {- A- ^* s* t! |
50.   }
    
51.   
    : e" i$ q* k5 B
52. #if !defined(STM32F030x6) && !defined(STM32F030x8)  
    5 F+ q1 p5 |& H! G$ {' n2 w
53.   /* UART wakeup from Stop mode interrupt occurred -------------------------------------*/
    7 H! T5 v* ~+ @, x7 w
54.   if((__HAL_UART_GET_IT(huart, UART_IT_WUF) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_WUF) != RESET))
    1 o' m6 h% c( w" C
55.   {
    + K) n: p" t2 d" a4 i
56.     __HAL_UART_CLEAR_IT(huart, UART_CLEAR_WUF);
    5 b% ^- z, U6 y/ H. c3 x& O+ S! n
57.     /* Set the UART state ready to be able to start again the process */
    
58.     huart->State = HAL_UART_STATE_READY;
    $ G) R7 p  o9 b1 _* r
59.     HAL_UART_WakeupCallback(huart);
    
60.   }
    
61. #endif /* !defined(STM32F030x6) && !defined(STM32F030x8) */
    2 C" X" w  u" q( S7 q3 f. {) s
62.   
    / O' z2 o" N* X% i
63.   /* UART in mode Receiver ---------------------------------------------------*/
    : Q7 |. W7 o4 r
64.   if((__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET))
    
65.   {
      g$ }/ F% ]5 B6 _
66.     /* Clear RXNE interrupt flag */
    
67.                
    ; Q( N3 h4 p/ f' ?! ^
68.                 rx_buf[0].buff[rx_buf[0].rx_index]=huart->Instance->RDR;
    
69.                 //huart->Instance->TDR=rx_buf.buff[rx_buf.rx_index];
    
70.                 rx_buf[0].rx_index++;//储存接收到的数据到 缓冲区
    + H3 v  v6 r, U8 `
71.                 osSemaphoreRelease(usart_Rx[0]);//通知  scanf 有数据收到
    * @! w% P5 q! \5 {; q2 e% q9 D7 x& z
72.                 if(rx_buf[0].rx_index==BUFFSIZE)
    # c& G) l8 b1 N7 o; p7 m- x" k
73.                 {
    
74.                         rx_buf[0].rx_index=0;
    
75.                 }
    0 E+ H7 ~% s) ^6 P; }
76.                 if(rx_buf[0].rx_index==rx_buf[0].save_index)
    9 ~1 g3 j2 I( {, l; H  u- F
77.                 {
    $ Q& J9 o' w) _
78.                         rx_buf[0].save_index++;
    
79.                         if(rx_buf[0].save_index==BUFFSIZE)
    
80.                         {
    % s% k& A6 [, b. m' Q& @
81.                                 rx_buf[0].save_index=0;
    . q% D  W7 K; i4 [. }' U. m* h6 n
82.                         }
    4 p% ?$ s6 j4 [2 E1 ~0 H" v) {) m
83.                 }
    
84.                  __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);
    & I0 y6 ^$ v. x5 ^$ t$ w
85. 
    6 E/ G" ]4 U/ o' h% ]3 X
86.   }
    8 b) o  N# o2 v8 R* p, F  O( S
87. 
    
88. }
    

复制代码

! F" A6 Q. |6 k4 o0 D7 T3 ~/ [
//下面这个函数被scanf所调用
4 y2 _2 h4 Z# b1 S& r

1. 
   
2. int fgetc(FILE* f)
   
3. {
   ! Q" b0 k0 C$ n2 I
4.                 osStatus st;
   
5.        
   2 C% ~3 ?# r4 _8 M; j
6.         char index=0;
   ' y: R; R8 ~) a9 @6 h+ m% D, `
7.         int ch;
   
8.        
   
9.         if(f->usart==USART2)
   & e% o/ o: O9 l# l
10.         {
    # s7 J' j) L8 L- t6 t$ X* w$ E
11.         index=1;
    * W  c2 O, |/ W  K
12.         }
    7 S" Y- p' ~8 U' ]4 s4 B
13.        
    
14. if(rx_buf[index].rx_index!=rx_buf[index].save_index)
    - T+ ~, r# }8 }! W5 T0 J' e
15. {
    , n4 b/ N8 m$ l5 b3 n2 ^
16.         ch= rx_buf[index].buff[rx_buf[index].save_index++];
    9 U+ l% C1 R' q7 H# p$ k2 [
17.         if(rx_buf[index].save_index==BUFFSIZE)
    
18.         {
    
19.         rx_buf[index].save_index=0;
    
20.         }
    
21.         return ch;//缓冲区有数据则取得数据
    ; g: k8 V5 W5 w
22. }
    
23. else
    1 r! ~7 o: g% B1 T1 ?" p3 S
24. {//没有数据等待数据
    5 z" v  x) H5 d' a4 U
25.                 if(index==0)
    
26.                 {
    
27.                         st=osSemaphoreWait(usart_Rx[index],wifi_wait);
    
28.                 }
    
29.                 else
    . C+ x# @* k* g( h. y% h/ c# R
30.                 {
    $ x4 Z: k% F' J' R7 K
31.                 st=osSemaphoreWait(usart_Rx[index],usart_wait);
    ( S  `) y" Q4 a
32.                 }
    
33.         if(st!=osOK)
    
34.                 return EOF;
    4 `1 `$ v) r% _2 Y2 E7 S
35. return fgetc(f);
    , j, f3 |$ V0 N+ M2 d
36. }
    & `8 a" X" _. n" b; E5 f4 P
37. 
    # a8 T$ M: U" Q5 q7 S! {
38. }

复制代码

//这个函数用于发送 指令给WIFI

1. int Send_Wifi_cmd(const char *str,unsigned int wait,char *buf)
   
2. {
   - t1 Y% x6 T+ s3 s' O9 A7 U/ B9 q
3.                         int ERR;
   
4.                         fprintf(&wifi,"%s\r\n",str);//发送指令
   , ?+ M7 R6 r- N' R/ |/ L
5.                         set_wifi_wait(wait);//设置超时时间
   
6.                                 if(fscanf(&wifi,"%s",buf)!=EOF)//扫描模块返回
     e1 ^8 X3 w7 p+ B, [* Q
7.                                 {
   & \" G8 E1 g) o
8.                                 fprintf(stdout,"%s\r\n",buf);
   
9.                                 }
   7 M8 I7 q; p5 H' j. E
10.                                 while(1)
    
11.                                 {//循环扫描模块返回 直到超时或者返回OK或 ERROR
    8 x' Z# {4 b/ x
12.                                 if(fscanf(&wifi,"%s",buf)==EOF)
    
13.                                 {
    
14.                                         break;
    ; Y* G& R7 j7 U2 m
15.                                 }
    , J& J; |: S" A- A. z
16.                                 set_wifi_wait(1000);
    
17.                                 fprintf(stdout,"%s\r\n",buf);
    9 P  D, K4 ~" l$ o  {( D) v9 h' Z  A
18.                                
    * S4 u0 t* d( g
19.                                 if(fscanf(&wifi,"%s",buf)==EOF)
    
20.                                 {
    
21.                                         ERR=osEventTimeout;
    
22.                                         break;
    
23.                                 }
    ; l" w, [6 `- F1 Q+ K
24.                                 //set_usat_wait(500);
    . P" ]& b5 @' `8 _
25.                                 fprintf(stdout,"%s\r\n",buf);
    
26.                                 if(memcmp("OK",buf,2)==0)
    
27.                                 {
    2 Z3 u5 W: P6 r7 z0 n1 E0 j
28.                                         ERR=osOK;
    2 j0 N4 R; x, @# z
29.                                                 break;
    2 n6 l! A+ W& b8 \, d
30.                                 }
    , N/ J4 D' K; v6 w
31.                                 else if(memcmp("ERROR",buf,5)==0)
    
32.                                 {
    5 s3 U# Q. r* O! ~! ?- E
33.                                         ERR=osErrorOS;
    7 J; W& v: m' q* ~$ V
34.                                                 break;
    ( [) X  O# ?2 M
35.                                 }
    - p* g, j8 Z/ T1 ~
36.                                
    3 a# t) |  ?2 k( ?) H; w+ Y
37.                                 }
    . [" g/ W6 p! N- d/ r/ ]; J
38.                                 return ERR;
    
39.                                
    
40. }
    ; z) J, w! o2 x( Z3 G

复制代码

- D/ \4 P4 ]! ?2 h3 C) {5 F/ {
  Q. |& q( p, U7 H' l  u8 Z' O. O
4 [! i1 l' i! h2 Z: d

1. 
   1 S; h1 d- E" t; {8 t" n6 `' x& F
2. static char buf[40];
   7 x) s2 i& ~7 B. z3 N! G  h) V$ D9 C2 ]
3. void  usart_wifi(void const * argument)//WIFI的线程
   0 ^5 ^5 J0 ?$ }
4. {
   
5.                         static char IP[20];
   
6.                         if(AT_test())
   
7.                         {
   
8.                                 Send_Wifi_cmd("AT+CIOBAUD=115200",300,buf);
   ! W5 s( M3 E# O! v+ Y( K' `
9.                         }
   
10.                         usart_init(115200);
    
11.                        
    6 y2 |* C6 n! i8 }, _
12.                         Send_Wifi_cmd("AT+RST",500,buf);
    1 ~! F" O7 A* o5 K9 H) V$ D8 N, ~
13.                         Send_Wifi_cmd("AT+CWMODE=?",500,buf);
    
14.                         //Send_Wifi_cmd("AT+CWLAP",5000,buf);
    
15.                         Send_Wifi_cmd("AT+CWJAP="TP-LINK_C6FC68","123456789"",5000,buf); //加入热点
    
16.                         Send_Wifi_cmd("AT+CWJAP?",300,buf);
    
17.                         Send_Wifi_cmd("AT+CIPMUX=1",300,buf);//启动多连接
    
18.                         Send_Wifi_cmd("AT+CIPSERVER=1,1234",300,buf);//启动服务器模式
    
19.                        
    * ?) H6 b0 q  h/ @' k+ p9 D5 w, E
20.                         fprintf(&wifi,"AT+CIFSR\r\n");//获取 模块IP
    6 k# @7 V6 [. {) y+ ^
21.                         set_wifi_wait(1000);
    
22.                         fscanf(&wifi,"%s",buf);
    # {5 x4 F; e* s1 A5 H
23.                         printf("%s",buf);
    0 m3 V" ~$ h& u2 p
24.                         fscanf(&wifi,"%s%*s",buf);
    7 T+ u6 `, l8 Z( S1 b' Q
25.                         printf("%s",buf);
    8 S. V6 ^5 @3 P& Y; P$ X- ]
26.                         if(memcmp("ERROR",buf,5)!=0)
    3 a' b- C: [# K3 f
27.                         {
    ! H$ L4 a( k2 h: a+ y
28.                         memcpy(IP,&buf,20);//储存IP  由于模块IP是DHCP动态获取的  上位机APP无法预知IP地址所以 模块先获得自己IP 储存等待上位机使用 UDP                                  //广播get ip 命令获取IP
    1 V/ m) v# S: ]
29.                         printf("%s",IP);
    # @- ~: b+ I0 W+ M
30.                         }
    6 G' q: W! W) B# h' g, z
31.                         Connect(buf,1,"UDP","192.168.2.255",1234);//启动UDP模式
    
32.                         set_wifi_wait(50);
    
33.                         set_wifi_wait(osWaitForever);
    # H4 E) H' p. L9 D$ Z4 u6 ?
34.                        
    
35.                                 if(fscanf(&wifi,"%[^\n]",buf)==EOF);
      K2 i, `% v: l  s" M
36.                                 fprintf(stdout,"%s\r\n",buf);
    3 T* I4 W$ u# s- b4 a% m; F
37. 
    
38.                        
    1 }/ p8 r: x; D2 L
39.                                 while(1)
    
40.                                 {
    4 D, S* ^/ r0 L5 }
41.                                         timeout:
    
42.                                 set_wifi_wait(osWaitForever);
    
43.                                 if(fscanf(&wifi,"%*9c%[^\n]",buf)==EOF)goto timeout;//扫描 WIFI输出
    ; s! R0 j! G) Y1 Y
44.                                         {
    
45.                                                 char cmd[5];
    6 q; ?0 S1 F, P" F7 P$ ~
46.                                                 fprintf(stdout,"%s\r\n",buf);
    0 P* h9 L4 U/ U. ^
47.                                                
    8 O+ H- b  r$ d/ G# E2 [
48.                                                 sscanf(buf,"%*d:%s%*c%[^\n]",cmd,buf);//解析命令
    & a; ~3 n1 l2 c+ T5 ]9 i( j0 o: F
49.                                                 printf("%s\r\n",cmd);
    2 C/ ?  {6 f0 z, g  Q- ]+ M
50.                                                
    
51.                                                 fscanf(&wifi,"%*s");
    ; n  @# _( U" P* H
52.                                         if(memcmp("get",cmd,3)==0)//get data 如果是get命令
    1 h4 s/ b1 m% r9 a
53.                                         {
    
54.                                                
    
55.                                                 if(memcmp("ip",buf,2)==0)// get ip命令
    
56.                                                 {
    
57.                                                         send_data(IP,buf);//发送本机IP
    
58.                                                 }
    
59.                                                 else if(memcmp("cpu id",buf,6)==0)
    7 a5 \  b  a' O* W1 [( Q5 {+ T
60.                                                 {
    
61.                                                 send_data("CPU uid",buf);
    : z8 L5 M+ W- m+ ~* k: }+ A# G
62.                                                 }
    8 H: n4 \7 {! N* r. C3 H
63.                                                 }
    1 ?5 w8 v$ B1 H! Y
64.                                         else if(memcmp("set",cmd,3)==0) //set data
    
65.                                         {
    
66.                                                 if(memcmp("led on",buf,6)==0)
    
67.                                                 {
    : p+ p. i; v2 ]: y- C5 C, C
68.                                                 GPIOA->ODR|=GPIO_PIN_5;
    
69.                                                         send_data("LD2 ON",buf);
    + \7 R( ~  M7 Y( J! W7 Z. l
70.                                                 }
    4 U# C. X5 d4 u9 `
71.                                                 else if (memcmp("led off",buf,7)==0)
    / M0 _* g; p7 N6 z
72.                                                 {
    
73.                                                 GPIOA->ODR&=~GPIO_PIN_5;
    
74.                                                         send_data("LD2 OFF",buf);
    - p4 y  L) @9 D7 P6 j: Z( R
75.                                                 }
    
76.                                         }       
    
77.                                         }
    
78.                                 }
    
79. }

复制代码

* F; j, C, R9 v5 s* {+ d


注意usart_wifi.c 一开始有 几个 FILE定义  主要是为了区分  printf 和 scanf 操作的 串口
9 i& t, p/ \% b5 R' u

  G% J" s) H* {0 {7 c9 L% |$ a2 z

然后需要注意 8266 TX右边的 引脚是需要接VCC的
% l0 S5 D" n& U
* z6 i0 j) V: y1 S& E/ j1 o
( `; q+ `3 }$ ^- W( q9 I: O5 a8 N

lovewyufeng 发表于 2015-1-23 11:05
建议 MCU调试的时候的使用两个串口 一个用于和 WIFI通信 另一个将WIFI回复内容  全部上传  方便调试 ...

另外一个已经占用了，太纠结了，呵呵！\r\n已经加上了，不是这个的原因，先前配置都是这么处理的，配置提交都成功了，到这步卡死了

Hi，楼主，我用WiFi模块设置为STA模式，串口配置工具配置的时候是通讯正常的，但是写程序的时候同样的参数就是连不上路由器，但是配置已经成功了，就是到连接路由器连不上了，楼主遇到过这种问题吗

巅峰残狼 发表于 2015-1-23 11:03
Hi，楼主，我用WiFi模块设置为STA模式，串口配置工具配置的时候是通讯正常的，但是写程序的时候同样的参数 ...

建议 MCU调试的时候的使用两个串口 一个用于和 WIFI通信 另一个将WIFI回复内容  全部上传  方便调试

巅峰残狼 发表于 2015-1-23 11:03
Hi，楼主，我用WiFi模块设置为STA模式，串口配置工具配置的时候是通讯正常的，但是写程序的时候同样的参数 ...

& i& G- _% H; S8 x# u8 y# w有可能 命令忘记 \r\n了？

效果图不见了  现在补上
) I$ W/ @) _) p( R) w9 w  t
$ J+ K  C7 Y- V: [
+ A# t  p+ S" m8 e

不错，支持，有空试下
5 l' G9 H1 \6 K: z4 z) W7 |7 r

谢谢楼主分享！

witnessiz 发表于 2015-1-23 11:55
不错，支持，有空试下

3 Q- r- V3 o( f! H; V/ k哈哈 wit 出现了~~

LZ好人啊

用的啥wifi模块啊？

好帖，学习下