前言
今天这一讲注意涉及到WiFi模块ESP8266的使用，主要是用WiFi来控制LED0亮灭，包括会详细介绍一下该模块的使用，废话不多说，正题进入···
2 D! @7 u; ?! B  f+ T& J. z
7 a# P5 P# r( n. G一、ESP8266介绍
互联网+时代，无线传输、无线通信尤为重要，那么在WiFi通信方面就数ESP8266用的最为广泛了，因为ESP8266是一个具备高性能的模块，在不了解其原理的情况下，只要有一定的串口知识理解，那么就可以轻松上手该模块，进而实现手机WiFi操作。简单来说，就是利用编程来实现WiFi模块的透明传输。
% m% S" m0 c1 x5 Y* }( ?2 \& n5 h

' d# H/ V6 ]5 C
4 C1 L- u$ \) e0 f 这里我们看到该模块有8个接口，但是实际上我们只需要用到五个接口就可以操作这个WiFi模块了，主要是3.3V、GND、RXD、TXD、EN这五个接口可以看上图，RXD接单片机上的TXD接口（这里我用的是串口3，所以接PB10），TXD接单片机上的RXD接口（即PB11），EN接3.3V即可。
$ U6 d8 [. G# S, k& S+ E$ `5 @
那么他有哪些指令呢？
6 |8 b! W0 {4 j
这里你会发现它有三种模式即STA、AP、混合，那么我们该如何使用呢，这里简单说明一下
' T& X+ v4 q- i" t: x
) ^2 O2 f2 N& {; c6 f- jSTA模式就是类似一个接收模式，就是开启该模式后，你只能通过串口给他发送信息，ESP8266只负责接收，而不会产生一个热点，（手机或其他设备是找不到热点的）然后这模式我一般会直接用来调试各种AT指令，通过串口调试助手进行数据传输
1 |$ P8 i  C4 d
  a; |& u" r9 H, KAP模式就简单了，就是它发出去一个热点，供手机或其他设备连接，如果要实现手机连热点来控制单片机，那么该模式就要开启了。

混合模式就是两者同时实现。

% u# x( \" Z) R% w接下来关于传输的方式，一般都是采用透传比较好，如果不采用透传模式，那么每发送一次数据都要发送一次AT+CIPSEND=<param>的指令就显得尤为麻烦，因此模式一般设置为透传模式，退出透传模式就给指令“+++”即可，后面代码里也有具体涉及到透传模式的退出操作，后面代码再一一介绍。
/ B0 C. Y' J1 B" f: u& p2 Z
! p& ^; z+ ]) B8 \& I) Z二、如何实现WiFi传输？代码详解附上
- ^' H2 _' ?4 b  A7 _2 \$ N3 m( ?* e串口3初始化函数：
5 q' ?9 n0 I* C/ ]  m: E8 h" k

1. #include "delay.h"
   
2. #include "usart3.h"
   6 [3 y! |( D( V' D( `; B4 @1 o+ I- ]
3. #include "stdarg.h"                  
   - M$ j/ X( f6 V' ?
4. #include "stdio.h"                  
   - ~+ h+ T  q3 x, B( |5 s+ V
5. #include "string.h"         
   
6. #include "timer.h"
   
7. 
   
8.         u8 res;        
     P; C  e# Z3 ?% |
9. //串口接收发送缓存区               
   
10. u8 USART3_RX_BUF[USART3_MAX_RECV_LEN];                        
      ?  X/ X3 c# S& ^& R) P
11. u8  USART3_TX_BUF[USART3_MAX_SEND_LEN];                 
    
12. 
    
13. 
    6 a. ]3 B$ |! A7 k2 N$ b) T
14. 
    ; n1 [1 c* Q8 W3 S
15. vu16 USART3_RX_STA=0;           
    ! z) q( _+ @0 }2 W% b2 ]( h
16. 
    
17. //串口3中断
    
18. void USART3_IRQHandler(void)
    & k4 C8 C/ K% o3 a, c; T( b5 ~  ]
19. {
    # l% V0 h* p# V+ W/ A+ \
20. 
    6 m9 r. m3 R' P6 H) x
21.         if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
    ! x# A: m9 d3 s8 Q: {6 o- s
22.         {         
    
23.                 res =USART_ReceiveData(USART3);                 
    . S& I  F) M. ]4 F0 i+ c" k
24.                 if((USART3_RX_STA&(1<<15))==0)
    * `# p- K5 V( v1 n1 f- s
25.                 {
    ( V! _3 o1 e% _# N/ E0 N
26.                         if(USART3_RX_STA<USART3_MAX_RECV_LEN)        
    9 M3 I) _9 @9 b& y( K' g1 }
27.                         {
    : z" @2 v4 w* ], @1 T7 w6 z" G
28.                                 TIM_SetCounter(TIM7,0);                                         
    6 G8 i! }" q, V) k% c2 u1 @* K9 _
29.                                 if(USART3_RX_STA==0)                                 
    
30.                                 {
    6 m! H* [( d4 _1 [
31.                                         TIM_Cmd(TIM7,ENABLE);
    
32.                                 }
    
33.                                 USART3_RX_BUF[USART3_RX_STA++]=res;        
    $ P8 s2 f3 D; F) Z
34.                         }else
    
35.                         {
    
36.                                 USART3_RX_STA|=1<<15;                        
    
37.                         }
    
38.                 }
    9 n. y1 ^9 S" E1 |% F! f
39.         }                                                                                                                           
    
40. }   
    
41. 
    
42. //串口3初始化
    
43. void usart3_init(u32 bound)
    
44. {  
    
45. 
    ' ?; w$ i1 C: e* I  Y9 g
46.         NVIC_InitTypeDef NVIC_InitStructure;
    
47.         GPIO_InitTypeDef GPIO_InitStructure;
    
48.         USART_InitTypeDef USART_InitStructure;
    
49. 
    / Q( s* {3 x# P% R! G6 v8 f
50.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);        
    
51.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);
    
52. 
    
53.          USART_DeInit(USART3);
    5 [: Y" q5 w: t6 [  c( x
54.                  //USART3_TX   PB10
    & G' o, T- |6 J1 A7 A
55.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    4 z& h; z2 u; t" Z% L% z2 V% ]
56.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    3 L& d" q4 J1 {* t' E4 A& Q9 g
57.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    $ B& s& h: S! z: ]4 z
58.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    
59. 
    
60.     //USART3_RX          PB11
    5 p# @& d, ?+ @& P
61.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    
62.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    5 |3 Q9 b' a, ?- k. m
63.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    ! t, o2 S) P0 J
64.         
    
65.         USART_InitStructure.USART_BaudRate = bound;
    
66.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    4 R* [( l) W2 C+ T
67.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    8 U* y6 Z) F$ c: A8 A4 o: a
68.         USART_InitStructure.USART_Parity = USART_Parity_No;
    
69.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
70.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        
    
71. 
    $ i; w5 G6 f3 K2 T, \+ H
72.         USART_Init(USART3, &USART_InitStructure);
    3 u, C' j# d! S- q
73. 
    $ n' I% n( k' T, g- u
74. 
    $ u1 ~% ?7 M! \0 _1 d" V0 @
75.         USART_Cmd(USART3, ENABLE);              
    ) t7 S1 Q5 ~3 a3 a& P
76.         
    
77. 
    
78.   USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
    
79.         
    3 X7 S9 Y( Y* Y
80. 
    6 K1 _$ y/ H3 w; X4 H
81.         NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    ( P7 e9 J0 w' s2 ]. S- K5 s
82.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;
    
83.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;               
    
84.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        
    4 d; |+ A' N( r( S; f/ T+ o
85.         NVIC_Init(&NVIC_InitStructure);        
    8 X; b( h4 B; V6 \) z$ N8 c
86.         
    
87.         
    
88.         TIM7_Int_Init(1000-1,7200-1);               
      f* B! j4 p) c2 w* j* U. c
89.         USART3_RX_STA=0;               
    
90.         TIM_Cmd(TIM7,DISABLE);                        
    4 Q  ?. k! f+ e4 u( f9 l5 V
91. 
    
92. }
    
93. //串口3printf函数，保证输入不大于设定长度
    
94. void u3_printf(char* fmt,...)  
    
95. {  
    
96.         u16 i,j;
    $ v! E  v5 B: O- a1 ~% w+ m
97.         va_list ap;
    " X8 X) y7 X2 `* }0 k+ E: y4 a* e
98.         va_start(ap,fmt);
    
99.         vsprintf((char*)USART3_TX_BUF,fmt,ap);
    
100.         va_end(ap);
     7 E6 V, C8 y2 V! D& ^& ^2 _$ T  p  H
101.         i=strlen((const char*)USART3_TX_BUF);               
     
102.         for(j=0;j<i;j++)                                                
     
103.         {
     
104.           while(USART_GetFlagStatus(USART3,USART_FLAG_TC)==RESET);
     " L; p# b, J' f$ d
105.                 USART_SendData(USART3,USART3_TX_BUF[j]);
     8 u" J' U1 C* E! j4 @2 G" u) p" M
106.         }
     
107. }
     - B! \8 `9 |( \. E- X+ v

复制代码

ESP8266初始化函数：

1. #include "esp8266.h"
   3 R5 M( s9 o# Z4 G+ L- ]
2. #include "string.h"
   2 w1 C/ A& \; ~" E8 @4 K7 U9 M
3. #include "usart.h"
   ( Y. t# \' h+ ]) G  S) {
4. #include "usart3.h"
   
5. #include "stm32f10x.h"
   ' l% z0 J" \; A8 Z& D
6. #include "sys.h"
   : [) |" \' Y4 G; ]! {+ Z  Y
7. #include "delay.h"
   
8. #include "lcd.h"
   % Q1 R- v: a+ S) S: R
9. 
   
10. //ESP8266初始化
    $ P) F2 h: d2 Q+ l' _2 `$ F
11. void esp8266_start_trans(void)
    9 [2 O; m. M% e+ j+ h; K/ r
12. {
    4 N* B0 N" K. C9 j6 n: b. h) G( u
13.         
    & d8 R2 i( O) e3 P: n, V  h
14.         esp8266_send_cmd("AT+CWMODE=2","OK",50);//设置为AP模式
    
15. 
    
16.         esp8266_send_cmd("AT+RST","ready",20);//重启
    # L# y, Q$ _5 V4 ^  x1 B" w( W2 ^
17.         
    
18.         delay_ms(1000);      
    * ~9 z, k! Y- l* A" K6 H- i$ z- P
19.         delay_ms(1000);
    4 Z7 Q( o8 t; |
20.         delay_ms(1000);
      Q. O: e* k  H) ^) j/ m
21.         delay_ms(1000);
    
22.         
    , w& n) V) U7 ~2 `
23.         esp8266_send_cmd("AT+CWSAP="ESP8266","12345678",1,4","OK",200);//设置WiFi名称、密码，模式
    3 v( Y( b; k% k! E/ U, ?5 ~
24.         esp8266_send_cmd("AT+CIPMUX=1","OK",20);//进入透传模式
    3 \; c6 }1 t* w0 L: M7 l$ y
25.         esp8266_send_cmd("AT+CIPSERVER=1,8080","OK",200);//设置端口8080
    3 U2 l: \( s% o$ J" g- n
26.         esp8266_send_cmd("AT+CIPSEND","OK",50);//开始发送数据
    . t& ?; s+ H9 C8 X* H
27. }
    ' H  S0 l  `+ L; K
28. 
    3 V  N2 i; a  V! F( R: m# B
29. //退出透传模式
    
30. u8 esp8266_quit_trans(void)
    2 Y6 B6 O9 K; ]& z& H
31. {
    7 x1 A$ z$ l5 \2 u8 \
32.         u8 result=1;
    ( Q7 t2 G5 S/ y7 x. N; g
33.         u3_printf("+++");
    
34.         delay_ms(1000);                                       
    
35.         result=esp8266_send_cmd("AT","OK",20);
    4 z5 O( p6 N) f! r: S- P
36.         if(result)
    1 h# |' O# ^# _3 _
37.                 printf("quit_trans failed!");
    $ L* n$ m; J& \3 b, z
38.         else
    
39.                 printf("quit_trans success!");
    ( N/ y+ ]" `  M; r" O# d& l+ T* I" y
40.         return result;
    
41. }
    
42. 
    
43. //发送指令，返回0发送成功，1则失败
    + N( j9 Z0 G* \. T3 ~% V1 a
44. u8 esp8266_send_cmd(u8 *cmd,u8 *ack,u16 waittime)
    ; S" p7 S2 y" w; c
45. {
    
46.         u8 res=0;
    $ q/ Y0 ~6 B) q! M3 m% {
47.         USART3_RX_STA=0;
    
48.         u3_printf("%s\r\n",cmd);        
    ! C3 w: M% E3 b- q0 t$ n, T3 S- R
49.         if(ack&&waittime)               
    
50.         {
    3 V4 d: G6 X$ \0 P* H
51.                 while(--waittime)        
    
52.                 {
    ; [1 t) E6 s8 Y% F8 d5 s9 i/ o
53.                         delay_ms(10);
    
54.                         if(USART3_RX_STA&0X8000)
    $ c/ M- [- i- V9 ]: Q! j+ n' [/ V
55.                         {
    4 j, j  M3 i% A% u/ n) y
56.                                 if(esp8266_check_cmd(ack))
    5 ?1 o) p1 z; O# I! n; [
57.                                 {
    6 P8 i! R2 }* g- U8 t8 s
58.                                         printf("ack:%s\r\n",(u8*)ack);
    
59.                                 
    
60.                                         break;
    
61.                                 }
    $ h8 M; H. C' K9 w& ]0 @1 ]
62.                                         USART3_RX_STA=0;
    5 `3 U: R/ s2 H. n9 v
63.                         }
    
64.                 }
    ) q( S. D' Z* z+ a) @; u' R
65.                 if(waittime==0)res=1;
    , o3 d$ f! S/ u
66.         }
    0 d: b/ b, E1 F9 o; v7 d: d* L
67.         return res;
      u. p. N1 w0 n9 }$ U, |
68. }
    9 p) x2 C+ [; ~' j. f
69. 
    
70. 
    
71. //检测是否应答指令
    
72. u8* esp8266_check_cmd(u8 *str)
    
73. {
    
74.         char *strx=0;
    3 H5 E9 F" \4 L/ B
75.         if(USART3_RX_STA&0X8000)               
    
76.         {
    1 i/ ]1 s' m1 F. P. j1 G# ?" z% T
77.                 USART3_RX_BUF[USART3_RX_STA&0X7FFF]=0;
    
78.                 strx=strstr((const char*)USART3_RX_BUF,(const char*)str);
    
79.         }
    / x; N; s' y& \" M+ t& W* i
80.         return (u8*)strx;
    
81. }
    ! h; ^3 Q. B* {( ?/ P8 W
82. 
    * t* E" a, O( f' ^; ]
83. 
    - U6 M, Z5 ^9 M  W
84. //向ESP8266发送指令（数据）的函数，暂时用不到，可以自己斟酌加上
    
85. //u8* esp8266_send_data(u8 *cmd,u16 waittime)
    
86. //{
    
87. 
    / n. Q. u, w# ]
88. //        char temp[5];
    ; U, z" t1 r3 O1 }; W3 H
89. //        char *ack=temp;
    " U/ v; u) P5 k6 Q2 ]" u
90. //        USART3_RX_STA=0;
    7 L1 b2 N( l1 g; a- b3 s6 D- c* g
91. //        u3_printf("%s",cmd);        
    ! B6 x# a' Q" A4 x
92. //                LCD_ShowString(30,130,200,16,16,cmd);        
    
93. //        if(waittime)               
    2 ^7 O& j4 e9 t6 x
94. //        {
    
95. //                while(--waittime)        
    # f( g2 X1 W3 q) M1 c" g
96. //                {
    # c" w9 K* t" o
97. //                        delay_ms(10);
    
98. //                        if(USART3_RX_STA&0X8000)
    
99. //                        {
    
100. //                                USART3_RX_BUF[USART3_RX_STA&0X7FFF]=0;
     
101. //                                ack=(char*)USART3_RX_BUF;
     5 U% d$ u; C6 ~5 F) r3 G) w' F2 j
102. //                                printf("ack:%s\r\n",(u8*)ack);
     
103. //                        LCD_ShowString(30,190,200,16,16,(u8*)ack);        
     , I/ I2 z1 q# b2 ^) Q9 l! @) r
104. //                                USART3_RX_STA=0;
     
105. //                                break;
     ! |7 r/ G3 }7 ]* y
106. //                        }
     5 i; M: _5 _$ F4 L7 J
107. //                }
     * c, H; \8 O3 B/ ], T! x
108. //        }
     
109. //        return (u8*)ack;
     $ e* m; ~* r8 d2 z& D' c8 {% E
110. //}

复制代码

主函数：
* J& X1 Z$ c/ L  v) _( b* |! W
3 i2 m- Z- }. y

1. #include "delay.h"
   
2. #include "sys.h"
   6 {! b, n5 v: \4 \. ^
3. #include "usart.h"
   0 n( N, o9 T0 `% U
4. #include "usart3.h"
   
5. #include "esp8266.h"
   
6. #include "string.h"
   
7. #include "timer.h"
   
8. #include "led.h"
   
9. 
   0 g' Q- [+ j' m8 u2 x
10. 
      a) h; O7 @  A+ u' ^( z: G
11. int main(void)
    & Q  G2 T) F3 I  D( a6 x4 r
12. {        
    2 N0 ]# R4 H6 n' Q$ v! {! F
13.         char a[15];         
    
14.         delay_init();                                               
    4 k# {" X5 b( b2 p3 y2 ~7 e
15.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                        
    ' i$ z4 ]. ^- p' }5 F! R5 h4 Q
16.         uart_init(115200);                                 
    
17.         usart3_init(115200);         
    
18.         LED_Init();  
    
19.         esp8266_start_trans();                //ESP8266初始化                        
    1 t& D+ V1 _( Y2 J1 o  ^: q6 F
20. 
    
21.          while(1)
    . g2 y* E' ?$ P% r2 R
22.         {
    
23.         if(USART3_RX_STA&0x8000)
    ( H; }0 c% w. k- R+ E0 a2 t: d
24.                 {
    
25.                     sprintf(a,"%s",USART3_RX_BUF);
    2 ]# \* Y; A9 k! m% e- F3 l
26. 
    
27.                         if(strstr((const char*)a,"on")) //输入on，LED0亮
    
28.                                 LED0=0;
    1 g6 Y) S# n) t5 Y" ]
29.                         if(strstr((const char*)a,"off")) //输入off，LED0灭
    
30.                                 LED0=1;        
    ) ^+ V  I3 C; n7 x
31.         
    
32.                         USART3_RX_STA=0;
    0 W$ k& w( s' `& V9 `/ ~
33.                         
    , F$ N8 ~  U: r# S3 g
34.                         
    
35.         }
    ' W( |& i; ]& E# D& n
36. }
    : n- G9 E! t# x. P6 E0 i. U
37. }
    

复制代码

' Z. ^; v# @: w; e2 @三、结果实现流程与展示
0 }# u# J+ i4 w3 j下面如何用手机实现控制呢？
) k9 |  G: |$ X) I' |" X+ l) A* A
3 l; e% o2 \$ x0 n; X1、首先在手机端下载一个TCP，在各大浏览器搜索就有了


: d: C0 J8 p% @+ T
2、打开WiFi，搜索你设置的热点并连接

3 M& F4 y8 {$ o2 R: [0 T/ Q
  @  Z- l3 p2 s  {: _% u
9 B3 n! P7 }$ q) s5 S/ I$ i7 l3、查看该WiFi的地址
, D; q' C" S7 n+ v! u
/ G1 S: f. f* f* H+ b" Q

这里可能会有一定的误差错误，可能会是192.168.4.1，好像要正确的我是去串口调试助手查了一下，跟这里又不太一样，具体原因我也不太了解，如果手机上显示的IP地址不对，那就只能利用调试助手进行一下AT指令查询，这样比较准确，就把串口更改一下就行了（记得代码串口也要更改，自己尝试上手比较有收获）。
) v3 s! j" G1 Y/ K! s
4、打开TCP，输入地址和端口，连接上热点，然后就可以进行各种命令了
, V. }: n7 B# r  t! H3 L
2 k* C- N( K$ M1 N5 D+ ~! V, r. [结果：
8 Q# |% d3 M+ z4 w# z
输入on



输入off

: t( z0 C% F$ ^. ?5 q; c9 Q) Q6 H
4 \6 [4 r) p  O+ M% B7 {
四、总结
哈哈，学到这里就会发现你已经轻松掌握了如何使用ESP8266WiFi串口模块了，那么接下来就是对所学知识的巩固与实践操作，再然后就是利用该模块进阶完成各种设计
& }2 [5 ~8 [" W* B- l0 R