一、stm32的WIFI配置
6 o; E* H( \0 B' e6 E" L        通常WIFI模块就是一个独立的单片机，只是内置了WFIF通信软件的单片机，并该通信软件提供了AT通信指令集给开发人员，基于这些指令集我们就可以针对项目需要进行二次集成开发出所需的业务应用软件。

/ j2 e# e2 `8 k: S        本文本文采用的开发板是stm32L496VGT3,该开发板的MCU及WIFI模块（MW31）硬件电路图如下：
' D0 i1 N+ W( p  _9 M
  \9 j+ R6 D# U. g% E5 P( ~; {        MCU采用PC4、PC5连接WIFI实现通信，PB0、PB1作为辅助控制。
+ e2 D) h) C! Q/ h) y; y
: i9 \9 q' k, q
& c8 [  S6 n" ?" ~7 _1 Q6 E
, O* q1 g8 n- n- o; T- ^/ g* P5 b/ r0 W WIFI模块给出了两个通信接口，一个用来连接MCU（电路板已经连接好了，本文就采用该接口实现MCP串口通信控制WIFI模块），一个用来给外置使用。


; e/ m+ J$ A! N7 N5 v& H+ @
# x( Z5 z: ^) G2 X; `与WIFI通信关联的MCU的IO端口设置要求，开发板给出如下：


% n9 o% n5 R  M$ ^
0 V$ M  Z+ X* ]) _4 U: F         以及各个IO口具体参数要求
6 q6 K9 c* E- N5 k* O- D& P
$ P* E" i$ Z; j; Y! k1 S6 r. k

/ l7 K+ c9 m! I6 N' ^8 _# d' e         打开CubeMX配置页面，按上述要求设置WIFI配置通信接口USART3：



         开启USART3外部中断功能：



. y! k5 i6 r7 F/ ^         设置PC4、PC5的IO接口参数



         同时芯片图形化配置页面设置PB0、PB1为GPIO_OutPut模式，并进入GPIO配置页面，设置PB0、PB1的IO接口参数：
! _3 f5 K8 [, a) x8 J& @


          完成配置点击保存按钮或代码生产按钮生成代码：
/ g- ~4 o2 N: G2 C4 o) t



6 J; }" y( Z# q  I& y; L* v二、代码设计
        本文基于前一篇博文的串口通信能力基础上来实现的，即已经完成了printf函数映射到lpusart进行串口通信
6 w1 R1 l  u! I
# s; }6 R9 A9 Z  Q- r         我们先实现串口USART3的接收回调实现，在改写ICore目录下的usart.h、usart.c代码文件：
7 R+ W, W& U8 c  M: h5 u
        usart.h内容如下，类似lpusart串口添加了串口USART3的接收辅助变量:

1. /*
   
2. * usart.h
   . t* j$ z; r6 G  ?6 ^9 p( K
3. *
   & b3 u( G7 L. |8 ]
4. *  Created on: Oct 20, 2022
   * @8 V( a6 w( T% T: P
5. *      Author: Administrator
   
6. */
   3 K1 t4 p! _0 [4 d. C/ g9 s$ Z
7. 
   
8. #ifndef INC_USART_H_
   1 }+ F; y4 k& M$ z+ Z1 Z" u0 X8 u
9. #define INC_USART_H_
   + l2 m0 i+ I# a) X9 o. ^
10. 
    ! F6 a2 a, q+ k2 i) K, @" Y
11. #include "stm32l4xx_hal.h" //HAL库文件声明
    3 Y; A; n) G1 W
12. #include <string.h>//用于字符串处理的库
    
13. #include "print.h"//用于printf函数串口重映射
    
14. 
    
15. extern UART_HandleTypeDef hlpuart1;//声明LPUSART的HAL库结构体
    
16. extern UART_HandleTypeDef huart3;//声明USART3的HAL库结构体
    9 Q' x- J6 Z: i0 n& z5 N" G
17. 
    $ H/ o4 r+ r7 }7 x
18. #define HLPUSART_REC_LEN  256//定义LPUSART最大接收字节数
    
19. #define USART3_REC_LEN  256//定义USART3最大接收字节数
    9 o1 t& _& u9 _9 I0 {2 l$ w7 r
20. 
    
21. extern uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
    % X- s1 j! E7 B7 ^0 O
22. extern uint16_t HLPUSART_RX_STA;//接收状态标记
    
23. extern uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    4 N% Y/ z6 Y/ A4 c- w
24. 
    8 I$ M7 R) q) I+ F* P1 D; X& D
25. extern uint8_t USART3_RX_BUF[USART3_REC_LEN];        //接收缓冲,最大USART_REC_LEN个字节.
    
26. extern uint16_t USART3_RX_STA;                                //接收状态标记,bit15：接收完成标志，bit14：接收到0x0d，bit11~0：接收到的有效字节数目
    4 s8 c/ M8 {4 N2 Y5 q. L
27. extern uint8_t USART3_NewData;                                        //当前串口中断接收的1个字节数据的缓存
    1 `9 i% R/ `  D  N; l3 y6 q
28. 
    ' o" f2 c& F! s- a& C) T# N
29. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    $ K9 h+ D# w8 y! _% R- ^
30. 
    
31. #endif /* INC_USART_H_ */

复制代码

        usart.c内容如下，添加了USART3的回调处理，实现接收来自WIFI模块的数据，lpusart和USART3的回调处理几乎一样的，主要就是接收到一个数据，就缓存起来，并再次开启中断接收；在接收到回车字段或缓存溢出是，进行标记（HLPUSART_RX_STA和USART3_RX_STA的前四位可以标记，后12位为数据长度记录）改写，该标记留给外部调用来处理，不再回调函数中进行接收标记复位：

1. /*
   ) z: `: R, E/ C
2. * usart.c
   " y- z9 z% l) B' N
3. *
   % E5 D! [4 I8 d0 y: w
4. *  Created on: Oct 20, 2022
   
5. *      Author: Administrator
   8 R! f5 a3 T/ E0 _% G( v
6. */
   1 A* m/ O, Q  F
7. 
   
8. #include "usart.h"
   6 a9 N. W( h& l
9. #include "wifi.h"
     \8 L2 }1 S8 Z+ k! |$ R* v1 D# W
10. 
    
11. uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
    
12. /*
    5 e) z  q. `" r7 |5 c. Q* k( ]
13. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
    
14. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
    ' z- B: c5 T' O( ~/ l) a& e
15. * bit13:预留
    
16. * bit12:预留
    8 o; N/ b; n- O( O
17. * bit11~0：接收到的有效字节数目(0~4095)
    
18. */
    9 o0 @/ e+ m7 C/ W# N
19. uint16_t HLPUSART_RX_STA=0;接收状态标记//bit15：接收完成标志，bit14：接收到回车(0x0d)，bit13~0：接收到的有效字节数目
    4 h" p$ ~4 t4 q9 s- ^
20. uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    0 A! S7 U* b. u. G: f
21. 
    + x$ D& o  g' O7 y, F7 a
22. uint8_t USART3_RX_BUF[USART3_REC_LEN];        //接收缓冲,最大USART_REC_LEN个字节.
    1 X! }, W5 w" q4 K7 r# Z
23. uint16_t USART3_RX_STA=0;                                //接收状态标记,bit15：接收完成标志，bit14：接收到0x0d，bit11~0：接收到的有效字节数目
    
24. uint8_t USART3_NewData;                                        //当前串口中断接收的1个字节数据的缓存
    , G0 q6 u6 s& ?3 W  z8 \. @  \
25. 
    * y9 e* R( m2 R" N$ n' c1 g4 z* R
26. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    5 @" C: j4 d& A% g( r4 K/ C
27. {
    ( h$ t, G4 U- y0 i4 I7 a6 \. Z( T! b
28.         if(huart ==&hlpuart1)//判断中断来源（串口1：USB转串口）
    , Z8 q5 i: c$ n* G9 J7 k
29.     {
    
30.                 if(HLPUSART_NewData==0x0d){//回车标记
    
31.                HLPUSART_RX_STA|=0x8000;//标记接到回车
    8 N' m3 n- r# x
32.                 }else{
    * P9 D: m' O# m, q" N+ P+ W
33.                         if((HLPUSART_RX_STA&0X0FFF)<HLPUSART_REC_LEN){
    0 U  o. V& d0 ]: m/ G) b
34.                                 HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=HLPUSART_NewData; //将收到的数据放入数组
    
35.                                 HLPUSART_RX_STA++;  //数据长度计数加1
    ; s0 x' H/ }/ I( b, u7 Q
36.                         }else{
    
37.                                 HLPUSART_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    ) l" y$ h* J' V; s
38.                         }
    6 z2 L( w4 o& ^) i; ]' X: a& K- s
39.         }
    # g8 {  q& f% y8 e* A$ |
40.        HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启接收中断
    
41.     }
    + S5 s/ }+ _) F' E
42.         if(huart ==&huart3)//判断中断来源（串口3：WIFI模块）
    
43.         {
    ' g. o, z6 f; [3 Q& {/ D6 s% ~8 N
44.                 if(USART3_NewData==0x0d){//回车标记
    
45.                         USART3_RX_STA|=0x8000;//标记接到回车
    . F( ^) _1 x* F( U9 u6 t2 R$ Q
46.                 }else{
    
47.                         if((USART3_RX_STA&0X0FFF)<USART3_REC_LEN){
    + M/ C3 S/ E, q/ l
48.                                 USART3_RX_BUF[USART3_RX_STA&0X0FFF]=USART3_NewData; //将收到的数据放入数组
    
49.                                 USART3_RX_STA++;  //数据长度计数加1
    
50.                         }else{
    % g3 N4 }( w5 y5 @+ L4 K2 ]8 G( J
51.                                 USART3_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    
52.                         }
    + j7 f( R/ ~- b. z
53.         }
    7 J# p9 X- q) n$ G" i
54.                 HAL_UART_Receive_IT(&huart3,(uint8_t *)&USART3_NewData,1); //再开启接收中断
      }: }( H4 _5 S2 z. Z4 i7 x
55.         }
    3 H/ c* t9 X- b( T
56. }

复制代码

6 ]( Y! ?  M7 m! F; d& J3 M" m8 ~        在ICore目录下创建wifi.h和wifi.c源码文件实现WIFI驱动：
& J6 o% q6 H" @0 y" P8 ]( \' u
        wifi.h内容如下：

1. /*
   * Y/ ^% Z8 p, p: m! Z( {. c% e2 F
2. * wifi.h
   
3. *
   , w& f6 w+ U  g2 o
4. *  Created on:
   % J, ?6 s. t+ a" ?+ B
5. *      Author: Administrator
   
6. */
   9 m6 ^/ b1 y# i2 x% c7 S
7. 
   " b3 w. a% D: s5 r
8. #ifndef WIFI_WIFI_H_
   ) N( T) B* q' m
9. #define WIFI_WIFI_H_
   ' [% ^0 `/ v0 T7 t) _
10. 
    
11. #include "stm32l4xx_hal.h" //HAL库文件声明
    " m& R; e. T( J  `! X
12. #include "usart.h"
    
13. #include "main.h"
    
14. #include <string.h>//用于字符串处理的库
    
15. #include <stdarg.h>
    
16. #include <stdlib.h>
    
17. #include "stdio.h"
    & }; T4 K6 V* Y5 k1 k
18. 
    
19. extern UART_HandleTypeDef huart3;//声明UART2的HAL库结构体
    
20. 
    # \0 Y' x* Q$ _4 O4 M
21. void WIFI_printf (char *fmt, ...); //WIFI模块发送
    
22. void WIFI_TCP_SEND (char *fmt, ...);//在TCP模式下的发送数据（不处理返回状态的盲发）
    
23. 
    
24. #endif /* WIFI_WIFI_H_ */

复制代码

        wifi.c内容如下，本质上就是调用HAL_UART_Transmit函数对huart3句柄进行写入数据操作，实现发送数据到WIFI模块：

1. /*
   3 @, _3 X4 Z) r. k8 h6 R1 H/ [
2. * wifi.c
   
3. *
   7 O/ o* X& m, P2 V' u& y4 v. t
4. *  Created on:
   5 M3 U0 D/ O6 I% ?3 Y4 N
5. *      Author: Administrator
   3 G+ l* }0 s. G' c* a& C6 M8 F
6. */
   
7. 
   
8. #include "wifi.h"
   
9. 
   ( _# B/ j2 z8 C# I. N5 W6 z4 X
10. //WIFI模块通信，使用UART3，这是专用的printf函数
    / b! J2 ]% [7 w0 {2 @
11. //调用方法：WIFI_printf("123"); //向USART2发送字符123
    
12. void WIFI_printf (char *fmt, ...)
    * i0 l$ {0 u- {1 ?
13. {
    
14.         char buff[USART3_REC_LEN+1];  //用于存放转换后的数据 [长度]
    
15.         uint16_t i=0;
    
16.         va_list arg_ptr;
    
17.         va_start(arg_ptr, fmt);
    
18.         vsnprintf(buff, USART3_REC_LEN+1, fmt, arg_ptr);//数据转换
    
19.         i=strlen(buff);//得出数据长度
    
20.         if(strlen(buff)>USART3_REC_LEN)i=USART3_REC_LEN;//如果长度大于最大值，则长度等于最大值（多出部分忽略）
    
21.         /*HAL_StatusTypeDef ret =*/ HAL_UART_Transmit(&huart3,(uint8_t *)buff,i,0xffff);//串口发送函数（串口号，内容，数量，溢出时间）
    
22.     //printf("WIFI_printf Len:%02d\r\n",ret);
    
23.     va_end(arg_ptr);
      L% b$ U% A& D. @
24. }
    
25. //WIFI模块在TCP模式下的数据发送：TCP发送的规定是先发AT+CIPSEND=数量，等待返回“>“后再发送数据内容。
    5 d; T: g- e8 w
26. //调用方法：WIFI_TCP_SEND("123\r\n"); //TCP方式发送字符123和回车换行
    - w( \7 d  [  d2 H
27. void WIFI_TCP_SEND (char *fmt, ...)
    
28. {
    + F9 P6 b; v3 Z& q5 z9 {
29.         char buff[USART3_REC_LEN+1];  //用于存放转换后的数据 [长度]
    
30.         uint16_t i=0;
    ; N; ]* K9 z5 d  Y; k8 k
31.         va_list arg_ptr;
    & B" {. X8 A8 x
32.         va_start(arg_ptr, fmt);
    
33.         vsnprintf(buff, USART3_REC_LEN+1, fmt, arg_ptr);//数据转换
    % V' H& r; ^3 g) ]
34.         i=strlen(buff);//得出数据长度
    
35.         if(strlen(buff)>USART3_REC_LEN)i=USART3_REC_LEN;//如果长度大于最大值，则长度等于最大值（多出部分忽略）
    : ^' z# z3 _4 ]/ Z2 o# H* M
36.         WIFI_printf("AT+CIPSEND=%d\r\n",i);//先发送AT指令和数据数量
    / `' F# G- J+ }5 G' d
37.         HAL_Delay(100);//等待WIFI模块返回">"，此处没做返回是不是">"的判断。稳定性要求高的项目要另加判断。
    & g8 n; s7 z) h8 `/ v5 @! E5 {
38.     HAL_UART_Transmit(&huart3,(uint8_t *)buff,i,0xffff);//发送数据内容（串口号，内容，数量，溢出时间）
    6 c/ ^, j; l) u8 c
39.     va_end(arg_ptr);
    ) B2 H' J7 d; v) [4 _
40. }
    : m& }# ]9 M  n# n# c: q* ~! n0 t
41. 
    
42. //所有USART串口的中断回调函数HAL_UART_RxCpltCallback，统一存放在【usart.C】文件中。
    

复制代码

4 l+ I/ d! k3 S. f8 L9 n        在main.c文件添加WIFI通信实现代码，main.c部分内容如下：

1. /* USER CODE END Header */
   - T3 O* q3 A  B$ t5 d' H
2. /* Includes ------------------------------------------------------------------*/
   
3. #include "main.h"
   
4. #include "usart.h"
   
5. #include "gpio.h"
   - [5 b, t$ @* F- b3 b. Y8 p/ v3 l
6. 
   
7. /* Private includes ----------------------------------------------------------*/
   
8. /* USER CODE BEGIN Includes */
   4 c1 @1 \4 S3 A2 _
9. //用户编写1
   + |1 T7 @/ ~% Y! D
10. #include "../../ICore/key.h"
    # v) ^5 k( W* L* ]$ ~3 o4 V
11. #include "../../ICore/led.h"
    
12. #include "../../ICore/print.h"
    
13. #include "../../ICore/usart.h"   //添加串口usart3接收回调实现的头文件
    / W& p6 y8 o( {4 M3 K2 B1 \: _4 M
14. #include "../../ICore/wifi.h"    //添加串口usart3写入数据实现的头文件
    3 P* o, c, l5 k
15. /* USER CODE END Includes */
    9 o1 F3 `' b5 g" Z; y- S: ^0 U- A
16. 
    
17. /* Private typedef -----------------------------------------------------------*/
      m2 k  e1 |" d0 A5 [& @7 m/ m! r) }
18. /* USER CODE BEGIN PTD */
    ( y, f$ D* }/ ~* x; [
19. 
    
20. /* USER CODE END PTD */
    
21. 
    
22. /* Private define ------------------------------------------------------------*/
    
23. /* USER CODE BEGIN PD */
    # M6 E/ |; s7 g( h
24. /* USER CODE END PD */
    
25. 
    
26. /* Private macro -------------------------------------------------------------*/
    
27. /* USER CODE BEGIN PM */
    
28. 
    2 O: m. @  z) x: ?' K( [- n
29. /* USER CODE END PM */
    
30. 
    
31. /* Private variables ---------------------------------------------------------*/
    , K/ T- k( S4 u( J: d( y- d$ N- E
32. 
    ( v/ Q1 |! B( g7 E* {1 n8 a6 P
33. /* USER CODE BEGIN PV */
    
34. 
    
35. /* USER CODE END PV */
    , |6 i2 r& s" C) w( b( G
36. 
    1 Q6 @. ~5 B$ a: d5 V) s+ b
37. /* Private function prototypes -----------------------------------------------*/
    3 u9 n1 F& C9 L  b- B6 F; P; G
38. void SystemClock_Config(void);
    
39. /* USER CODE BEGIN PFP */
    % T, I" N# f- u' D6 P
40. 
    " s" e3 y3 t9 ~; T- O
41. /* USER CODE END PFP */
    9 p9 M* G: @0 e
42. 
    
43. /* Private user code ---------------------------------------------------------*/
    ) d3 G# o& u0 L9 [; q
44. /* USER CODE BEGIN 0 */
    
45. 
    
46. /* USER CODE END 0 */
    
47. 
    
48. /**
    
49.   * @brief  The application entry point.
    
50.   * @retval int
    
51.   */
    + H8 r3 N2 Z$ T$ ?8 w. o+ {
52. int main(void)
    
53. {
      T( k6 f/ |3 S2 e
54.   /* USER CODE BEGIN 1 */
    
55. 
    1 h0 @5 i/ T/ ]3 c9 P. V
56.   /* USER CODE END 1 */
    $ L* A4 d5 N( i9 ^* f) M! A
57. 
    6 G' Z6 x/ I  H. K/ t8 M
58.   /* MCU Configuration--------------------------------------------------------*/
    . ~( K% _* Q/ o' l/ c# P
59. 
    8 N6 j4 C+ w4 E, N% W3 Q+ w
60.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
61.   HAL_Init();
    
62. 
    9 ?: x* M" n; |! Q' B5 E
63.   /* USER CODE BEGIN Init */
    
64. 
    % s+ m0 s2 U) _9 Y  y
65.   /* USER CODE END Init */
    " p8 i% g7 F; n3 \# ^
66. 
    
67.   /* Configure the system clock */
    
68.   SystemClock_Config();
    
69. 
    
70.   /* USER CODE BEGIN SysInit */
    9 [8 Q4 S, k/ R5 V
71. 
    
72.   /* USER CODE END SysInit */
    
73. 
    6 p6 T5 U. F* }2 N
74.   /* Initialize all configured peripherals */
    
75.   MX_GPIO_Init();
    & e4 P/ y  T: s/ E8 B. d3 c. \
76.   MX_LPUART1_UART_Init();
    5 S  R8 _. F1 X
77.   MX_USART3_UART_Init();
    " w# u* O6 ]  ~. _
78.   /* USER CODE BEGIN 2 */
    
79.   //用户编写2
    0 a/ X; i, E2 {( N5 a6 y: f+ L
80.   ResetPrintInit(&hlpuart1);
    ; D1 g2 v- I0 {
81.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
    
82.   HLPUSART_RX_STA = 0;
      M1 A5 @  D( C% E: }
83.   HAL_UART_Receive_IT(&huart3,(uint8_t *)&USART3_NewData, 1); //usart3开启接收中断
    ! A: d/ D; S' k" g. I
84.   USART3_RX_STA = 0;
    " Z; U4 i! f+ X/ M  |( U
85.   set_led0_val(0);
    ' Y4 y' u6 Q3 l$ S. p
86.   set_led1_val(get_key0_val());
    : U+ H+ H0 ?! T6 ~7 u
87.   /* USER CODE END 2 */
    
88. 
    
89.   /* Infinite loop */
    
90.   /* USER CODE BEGIN WHILE */
    ) u6 c# Y+ f) ^  G4 K
91.   while (1)
    
92.   {
    
93.     //用户编写3
      S' k0 g2 J2 x
94.         //接收到电脑发送给(lpusart)数据，转身将其发送到给usart3，进而实现送数据给WIFI模块
    
95.                 if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
    
96.                         WIFI_printf("%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
    
97.                         HLPUSART_RX_STA=0;//接收错误,重新开始
    $ C( |) d% q4 r9 j$ L
98.                         HAL_Delay(100);//等待
    
99.                 }
    ! X5 ^& J2 @6 O# ^% [) q! s6 z
100.         //接收到WIFI模块发送给(usart3)数据，转身将其发送到给lpusart，进而实现送数据给电脑终端
     ' E3 C: G% L( g  q) s
101.                 if(USART3_RX_STA&0xC000){//溢出或换行，重新开始
     ; A. }* _  Y& \, R1 O
102.                         printf("%.*s\r\n", USART3_RX_STA&0X0FFF, USART3_RX_BUF);
     ( V, H& y% a) m1 b. f* F4 ~
103.                         USART3_RX_STA=0;//接收错误,重新开始
     
104.                         HAL_Delay(100);//等待
       X& e" a1 I3 r8 v& f/ W( P
105.                 }
     
106.     /*
     : p# F/ r9 E& ^1 |% o
107.           if(KEY_0())//按下KEY0判断
     
108.           {
     
109.                   printf("KEY0被按下\r\n");
     
110.                   WIFI_printf("AT+UARTE?\r\n");//发送AT指令
       ]( z1 G+ V) P8 A, R9 ]. {
111.                   HAL_Delay(100);//等待
     7 p% Z/ J$ {% e6 u; F: `6 p# e
112.           }
     
113.     */
     
114. 
     ( s, k; L/ b+ B
115.     /* USER CODE END WHILE */
     ) |% l4 n; T/ j7 e& T5 W: s
116. 
     % ^) k5 M: T, H3 w
117.     /* USER CODE BEGIN 3 */
     
118.   }
     
119.   /* USER CODE END 3 */
     / l0 b" X& \# ?0 J. Q/ v" u3 Y  [
120. }

复制代码

6 ]2 v* {4 }8 U三、编译及测试
5 {0 `) ?, ?9 j+ w+ n        点击编译及运行按钮，

: o' {) U! d8 p7 l+ S6 _2 N
+ Z0 t  l8 N; }' w
* b$ p$ V9 w" \8 }8 w. ?$ n4 s9 L
! I2 T' q( L; f% I  A, T         如果编译及下载无异常，采用串口助手连接开发板，本文将开发板作为Station 模式连接家里的路由，设置账号密码及查询是否成功：

5 E; r' Z# [% Q9 r/ Z  ]



测试运行结果如下：


) Z& u5 R- e2 h9 \6 t4 C+ g+ X5 h
5 f. G7 Y6 s0 P0 u: E4 q         访问家里的路由控制界面查看如下：


9 u# G7 U& k$ U: u# u0 n( \% y

四、关于WIFI模块的串口应用
        通过上面的实现，市面上大部分WIFI模块都能适用。只要AT指令能直达WIFI模块，无论是从MCU还是从电脑端，对于WIFI模块的操作就是看AT指令支持的情况及我们对AT指令的组合应用，可以实现项目开发中各种对WIFI使用的要求。当然在具体项目中，对于WIFI模块的选型就是看他们WIFI模块给的AT指令能否直接或间接组合满足项目要求。
# K% S1 G0 c9 }8 w  ^' y; ^& V
; P6 T, d$ f* D" @5 @$ A* j" n        2022-11-21补充下面给出MW31模块的AT指令及部分测试演示。

& i: ?; p! e2 }$ ~, g- o【1】基础指令



3 P5 x4 \4 y: q! I% ^- v8 m. U【2】UASRT管理

$ D) K- m, A; E$ F( X

【3】WIFI管理
; p0 u# F4 k" n, V

9 k: Q, @1 u  k6 ?3 {
【4】 TCP/UDP通信
3 Q: }' w6 R) d: v& A8 K$ a8 C
1 N) {( r* u+ l7 k  U& Z
: {, }* o- E$ {! y; \
. ^& |3 X! K) O) K
% W$ c$ M  X4 q% k5 r$ I 关键指令测试演示：
/ B8 N% z1 q" L  h+ k
1）部分查询指令测试：

" t3 z& S7 M4 Z& v9 }* w4 z

2）部分TCP通信测试

, }8 f$ D& e  f! [3 d- q  P. y( P

7 P; E0 F( l$ K' S6 t/ M' `& n————————————————
4 H& T! m5 ?: z0 Z" f, V" I版权声明：py_free-物联智能
- K( o& k: s& V如有侵权请联系删除



/ U# }$ d3 m. R- M