本程序所用的单片机型号为：STM32F103RE
" |7 }) z# d& ]  U: TPB12端口为外接的WiFi模块电源开关，当PB12输出低电平时接通电源。
注意：WM-G-MR-09模块的芯片组（Chip Set）就是Marvell 88W8686。
. X- Q3 |/ o: q% a+ A% P' i该程序目前只能连接没有设密码的路由器，创建热点时也无法设置密码。
固件内容请参考：http://blog.csdn.net/zlk1214/article/details/74612925
" z( M7 V  ~9 G
注意必须把STM32启动文件*.s中的函数堆栈大小Stack_Size改大，否则函数中无法创建大数组！

1. Stack_Size      EQU     0x00000c00  

复制代码

【main.c】
: ^0 [  g" u1 D: e# l

1. #include <stdio.h>
   
2. #include <stm32f10x.h>
   
3. #include <string.h>
   
4. #include "lwip/init.h" // lwip_init函数所在的头文件
   
5. #include "lwip/timeouts.h" // sys_check_timeouts函数所在的头文件
   
6. #include "netif/ethernet.h" // ethernet_input函数所在头文件
   
7. #include "WiFi.h"
   6 E, ?% j$ n% Y/ [  V- R9 O
8. 
   5 k) I5 Y/ `+ m: y4 u6 q
9. // 这两个函数位于ethernetif.c中, 但没有头文件声明
   
10. err_t ethernetif_init(struct netif *netif);
    
11. void ethernetif_input(struct netif *netif);
    
12. 
    
13. // httptest.c中的函数
    
14. void init_http(void);
    
15. 
    
16. // 延时n毫秒
    
17. void delay(uint16_t n)
    8 O$ F3 H% \0 d
18. {
    
19.     WiFi_PrepareTimer(n);
    9 T. v/ w% N3 q0 G) J5 y9 `
20.     while ((TIM6->SR & TIM_SR_UIF) == 0); // 等待计时完毕
    
21.     TIM6->SR &= ~TIM_SR_UIF; // 清除溢出标志
    * M( K5 ^: d+ x1 U) h' w5 W
22. }
    
23. 
    
24. void dump_data(uint8_t *data, uint16_t len)
    
25. {
    
26.     while (len--)
    $ R) _4 G3 h' W$ r- I* c$ j
27.         printf("%02X", *data++);
    
28.     printf("\n");
    8 C' m! P3 t0 `
29. }
    9 t6 ^0 ?* e, p4 X6 ?) ~! ^
30. 
    
31. int fputc(int ch, FILE *fp)
    ; n5 C, X0 j( G; ~- L
32. {
    / x6 Y0 l. C7 D- ~6 ^
33.     if (fp == stdout)
    
34.     {
    
35.         if (ch == '\n')
    
36.         {
      L/ D1 c$ Z3 [9 X2 h& i
37.             while ((USART1->SR & USART_SR_TXE) == 0);
    
38.             USART1->DR = '\r';
    9 D" _# }- n; e  G4 `
39.         }
    ' |2 D: ]- Z2 J, y
40.         while ((USART1->SR & USART_SR_TXE) == 0);
    
41.         USART1->DR = ch;
    0 S8 k0 Z6 }2 _. [) b8 `
42.     }
    
43.     return ch;
    
44. }
    
45. 
    
46. // RTC时间转化为毫秒数
    
47. uint32_t sys_now(void)
    " D/ ?4 l7 R, x$ x. ?
48. {
    - ?( a& ]$ }! \
49.     uint32_t tmp = (RTC->CNTH << 16) | RTC->CNTL; // 秒
    
50.     tmp = tmp * 1000 + (32767 - RTC->DIVL) * 1000 / 32768; // 毫秒
    
51.     return tmp;
    
52. }
    
53. 
    
54. int main(void)
    
55. {
    
56.     struct ip4_addr ipaddr, netmask, gw;
    
57.     struct netif wifi_88w8686;
    
58.     uint32_t last_check = 0;
    
59.    
    2 i  a% G9 u/ h
60.     RCC->AHBENR = RCC_AHBENR_SDIOEN;
    ' S/ E6 I$ C4 W" E0 E
61.     RCC->APB1ENR = RCC_APB1ENR_PWREN | RCC_APB1ENR_TIM6EN;
    
62.     RCC->APB2ENR = RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPBEN | RCC_APB2ENR_IOPCEN | RCC_APB2ENR_IOPDEN | RCC_APB2ENR_USART1EN;
    
63.    
    , L4 a" c: O% d  s
64.     GPIOA->CRH = 0x000004b0;
    2 F$ _+ I2 c6 {$ Y- {* L
65.     GPIOB->CRH = 0x00030000; // PB12为外接的WiFi模块电源开关, PB12=0时打开WiFi模块
    " e  h4 a0 o6 y3 R# C- V
66.     GPIOC->CRH = 0x000bbbbb;
    6 ?& a8 [. G3 s. H& L$ G
67.     GPIOD->CRL = 0x00000b00;
    , l0 F0 D- o- m5 P/ x6 q6 R
68.    
    + y/ S) h- Z- r% x5 L  j$ P6 ~
69.     USART1->BRR = 0x271; // 波特率: 115200
    9 G+ M7 n0 U% z; T  t+ n
70.     USART1->CR1 = USART_CR1_UE | USART_CR1_TE;
    % G$ j* q, _) Y( m; p
71.    
    
72.     PWR->CR = PWR_CR_DBP; // 允许写入后备寄存器
    
73.     if ((RCC->CSR & RCC_CSR_LSION) == 0)
    5 p, O8 H% C2 i) l+ ~
74.     {
    
75.         RCC->CSR |= RCC_CSR_LSION; // 开内部低速晶振LSI
    
76.         while ((RCC->CSR & RCC_CSR_LSIRDY) == 0);
    3 n& m7 h  B1 S; R2 K
77.         //printf("LSI Ready!\n");
    # B" D. [$ j8 \0 H' u6 M1 t
78.     }
    & G/ Z3 {8 q5 X; B; k7 R) D
79.     if ((RCC->BDCR & RCC_BDCR_RTCEN) == 0)
    ! G% [" u' J$ G% x/ f- ?
80.     {
    : L! ?' j  _4 {5 Y2 D, R& G
81.         // 若RTC还没有打开, 则初始化RTC
    & r9 D0 p3 @4 E8 W% N2 N, {+ l9 V
82.         RCC->BDCR |= RCC_BDCR_RTCEN; // 打开RTC外设, 但暂不开始走时
    
83.         
    ; }0 I  V6 U  |9 L; e
84.         RTC->CRL |= RTC_CRL_CNF; // 进入RTC配置模式
    
85.         RTC->PRLH = 0;
    5 t7 i6 d9 I5 ^. Y! }- z0 r
86.         RTC->PRLL = 39999; // 定时1s (PRLH和PRLL寄存器只能写不能读)
    
87.         //RTC->CNTH = 0;
    
88.         //RTC->CNTL = 50; // 初始时间
    ! P9 N+ S) e& O: e
89.         RTC->CRL &= ~RTC_CRL_CNF; // 保存设置
    
90.         
    
91.         RCC->BDCR |= RCC_BDCR_RTCSEL_1; // 选LSI作为RTC时钟, 准备走时
    
92.         while ((RTC->CRL & RTC_CRL_RTOFF) == 0); // 等待设置生效
    
93.         // RTC从此处开始走时
    6 N3 J# `( Q+ x: T2 z1 o6 O
94.     }
    , a1 }( r9 e' R& T- [5 t4 S
95.    
    / A, Z/ `7 d5 B4 v$ F1 N, O% M
96.     WiFi_Init();
    9 |) T3 ?' Q1 t5 h7 }* x
97.     WiFi_Scan();
    
98.    
    
99.     //WiFi_StartADHOC("Marvell_88W8686"); // 创建一个热点
    
100.     WiFi_Connect("vivo Y29L", NULL); // 连接一个WiFi热点 (目前还不支持设密码)
     9 Y3 K/ r7 S4 w- |! ]1 i! _0 J: K
101.    
     
102.     lwip_init();
     
103.     IP4_ADDR(&ipaddr, 192, 168, 43, 10); // IP地址
     % W) B0 j5 C) V/ P0 v, c, N' P
104.     IP4_ADDR(&netmask, 255, 255, 255, 0); // 子网掩码
     
105.     IP4_ADDR(&gw, 192, 168, 43, 1); // 网关
     * B9 u% o/ T8 p
106.    
     - _# ?+ y1 O1 m3 @& F
107.     netif_add(&wifi_88w8686, &ipaddr, &netmask, &gw, NULL, ethernetif_init, ethernet_input);
     $ }4 J  L3 V' N5 b
108.     netif_set_default(&wifi_88w8686); // 设为默认网卡
     
109.     netif_set_up(&wifi_88w8686);
     0 i/ l5 X7 W. r
110.    
     6 Y  P4 G2 U0 Q4 ~# v, P8 M/ ]
111.     init_http();
     
112.    
     9 w/ M: q. L8 w* j# P, F! J( t" N
113.     while (1)
     8 L; B& Z4 P2 p8 e
114.     {
     ! i: e2 f/ \$ r: d0 y
115.         if (WiFi_PacketPending() || WiFi_PacketArrived())
     
116.             ethernetif_input(&wifi_88w8686);
     
117.         
     
118.         // sys_check_timeouts函数千万不能调用的太频繁, 否则会出错！(例如开机后要等1~2分钟DHCP才能分配到IP地址)
     
119.         if (sys_now() - last_check > 200)
     
120.         {
     
121.             last_check = sys_now();
     
122.             //printf("Time: %d\n", last_check);
     
123.             sys_check_timeouts();
     
124.         }
     + h% q  E6 v- \4 P5 ^
125.     }
     ; b7 B7 T& v- E& X+ Q
126. }

复制代码

【httptest.c】
! ]9 h4 B( F% K

1. #include <string.h>
   : w! ^' n3 K/ g* _1 u
2. #include "lwip/tcp.h" // 一般情况下需要包含的头文件
   # g5 Y  t% T' H
3. 
   
4. #define STR_AND_SIZE(str) (str), strlen(str)
   7 ]# C+ L2 I! o: X
5. 
   
6. err_t http_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
   6 t+ K, a3 P* T" u
7. {
   , _7 H& r6 ^+ M* I# P
8.         char len[10]; // 存放HTML内容的长度
   ' D5 o3 y: E  [
9.         char str[200]; // 存放HTML内容
   
10.         
    7 r; |9 X; a: a3 e1 ?
11.         char name[100];
    
12.         char *pstr;
    3 Z4 \) b1 T9 H
13.         uint8_t i = 0;
    
14.         if (p != NULL)
    
15.         {
    " N2 l& z; a" N# S2 v" G
16.                 // 提取页面名称
    
17.                 pstr = (char *)p->payload;
    9 e6 N0 _5 t$ X1 C  r3 p, F1 c
18.                 while (*pstr++ != ' ');
    9 k$ @. y7 K* p' m, Y  t; z( z
19.                 while (*pstr != ' ')
    & H% J& z6 P. |' |7 z* D# V' d
20.                         name[i++] = *pstr++;
    
21.                 name[i] = '\0'; // 不要忘了结束name字符串
    , j3 _+ y5 }! \' @  _1 P1 n
22.                 tcp_recved(tpcb, p->tot_len);
    4 N4 W6 p4 I3 n! @9 s
23.                
    . Y+ P) g$ ^  M  P; D8 |
24.                 // 生成HTML内容
    ! p2 b8 n1 P; z* b1 t3 O$ ^! @; Z
25.                 sprintf(str, "<meta charset="gb2312"><title>获取网页名称</title><div style="font-family:Arial"><b>请求的网页文件名称是: </b>%s</div>", name);
    
26.                
    
27.                 sprintf(len, "%d", strlen(str)); // HTML内容的长度
    
28.                 tcp_write(tpcb, STR_AND_SIZE("HTTP/1.1 200 OK\r\nContent-Length: "), TCP_WRITE_FLAG_MORE);
    ' C; z6 G% j8 @4 U' X8 `& _
29.                 tcp_write(tpcb, STR_AND_SIZE(len), TCP_WRITE_FLAG_COPY | TCP_WRITE_FLAG_MORE);
    
30.                 tcp_write(tpcb, STR_AND_SIZE("\r\nKeep-Alive: timeout=5, max=100\r\nConnection: Keep-Alive\r\nContent-Type: text/html\r\n\r\n"), TCP_WRITE_FLAG_MORE);
    
31.                 tcp_write(tpcb, STR_AND_SIZE(str), TCP_WRITE_FLAG_COPY); // 发送HTML内容
    
32.                 pbuf_free(p);
    : c" J9 m* x/ d% c, ]' h
33.         }
    9 F0 @" t: ?0 ^9 A& U  C
34.         return ERR_OK;
    
35. }
    ( v/ F! [+ j. X/ n8 T/ F
36. 
    , w4 R- A2 |" U8 x! c( P1 H! E
37. err_t http_accept(void *arg, struct tcp_pcb *newpcb, err_t err)
    ) n- Y2 V1 B6 T- f% f! n' |
38. {
    , E* r5 T# r5 ~- a3 F% M8 z# R" V/ ?
39.         tcp_recv(newpcb, http_recv);
    ! Y  M( n$ V4 p0 N! b: F
40.         return ERR_OK;
    : G; X8 A$ @3 m3 E  M  _  j) Y: B
41. }
    ' D. P9 f8 F* h% ~
42. 
    ' G# ]7 d& O3 K* Y. a! h4 e
43. void init_http(void)
    4 i0 V9 ]( T) d
44. {
    
45.         struct tcp_pcb *tpcb = tcp_new();
    7 B) r4 x  ]+ x! V6 k! m2 j6 }& s
46.         tcp_bind(tpcb, IP_ADDR_ANY, 80);
    
47.         tpcb = tcp_listen(tpcb);
    % [6 j$ w: F! U% q9 u7 v0 K
48.         tcp_accept(tpcb, http_accept);
    
49. }

复制代码

【WiFi.h】
: o& P( D- x, q& `" V

1. #define _BV(n) (1u << (n))
   
2. 
   
3. #define CMD52_WRITE _BV(31)
   8 U8 S' B4 T4 x, h. Q% }
4. #define CMD52_READAFTERWRITE _BV(27)
   ; \4 Z0 V: F7 }
5. 
   1 k* N! _. i0 E2 Z. N8 w* ?3 ~3 N
6. #define CMD53_WRITE _BV(31)
   3 |: v) }2 Z( g) P; O
7. #define CMD53_BLOCKMODE _BV(27)
   1 \8 u5 |6 D3 w0 v& q* P$ ]
8. #define CMD53_INCREMENTING _BV(26)
   
9. 
   
10. // 16.5 SDIO Card Metaformat
    / \5 g8 @0 q2 `2 E7 t& D) I
11. #define CISTPL_NULL 0x00 // Null tuple
    
12. #define CISTPL_VERS_1 0x15 // Level 1 version/product-information
    
13. #define CISTPL_MANFID 0x20 // Manufacturer Identification String Tuple
    + e% M. B3 S/ `; c
14. #define CISTPL_FUNCID 0x21 // Function Identification Tuple
    
15. #define CISTPL_FUNCE 0x22 // Function Extensions
    
16. #define CISTPL_END 0xff // The End-of-chain Tuple
    
17. 
    + g' r, @; r9 F( b* {+ B
18. #define WIFI_DEFAULTTIMEOUT 1500 // WiFi命令回应的超时时间(ms)
    2 @; X. H' j* L. q9 |% b& B
19. 
    
20. #define WIFI_SQREADBASEADDR0 0x10
    % X% Z8 i4 i8 K" m4 M/ T
21. #define WIFI_SQREADBASEADDR1 0x11
    
22. #define WIFI_SQREADBASEADDR2 0x12
    
23. #define WIFI_SQREADBASEADDR3 0x13
    . @2 X4 F/ {$ B2 k! Q
24. 
    
25. #define WIFI_CARDSTATUS 0x20 // Card Status
    & r2 R- x% U7 P, e+ s/ l
26. #define WIFI_CARDSTATUS_IOREADY _BV(3) // I/O Ready Indicator
    
27. #define WIFI_CARDSTATUS_CISCARDRDY _BV(2) // Card Information Structure Card Ready
    ' D* W6 l: b" f
28. #define WIFI_CARDSTATUS_UPLDCARDRDY _BV(1) // Upload Card Ready
    
29. #define WIFI_CARDSTATUS_DNLDCARDRDY _BV(0) // Download Card Ready
    2 q  Q' l- c; G' y! S; X4 i
30. 
      p0 g! S9 ]* `& j% k
31. #define WIFI_CAPABILITY_BSS _BV(0)
    
32. #define WIFI_CAPABILITY_IBSS _BV(1)
    ; K; b3 u% ^" i( {  l
33. #define WIFI_CAPABILITY_CF_POLLABLE _BV(2)
    4 a: u6 D! G4 k
34. #define WIFI_CAPABILITY_CF_POLL_REQUEST _BV(3)
    
35. #define WIFI_CAPABILITY_PRIVACY _BV(4)
    
36. #define WIFI_CAPABILITY_SHORT_PREAMBLE _BV(5)
    
37. #define WIFI_CAPABILITY_PBCC _BV(6)
    5 @( `" |8 x; [6 d
38. #define WIFI_CAPABILITY_CHANNEL_AGILITY _BV(7)
    
39. #define WIFI_CAPABILITY_SPECTRUM_MGMT _BV(8)
    ! d" d4 J0 H& L  A7 F
40. #define WIFI_CAPABILITY_QOS _BV(9)
    6 I% c4 m/ [2 a* D* }& `' F" _
41. #define WIFI_CAPABILITY_SHORT_SLOT _BV(10)
    3 s2 k3 }% _3 ]- u
42. #define WIFI_CAPABILITY_DSSS_OFDM _BV(13)
    
43. 
    
44. #define WIFI_SDIOFRAME_DATA 0x00
    
45. #define WIFI_SDIOFRAME_COMMAND 0x01
    
46. #define WIFI_SDIOFRAME_EVENT 0x03
    
47. 
    + S) ?9 N( @& K/ e6 u  b
48. /* Command List */
    ' L6 n8 i5 A& t' E# r+ f
49. #define CMD_802_11_SCAN 0x0006 // Starts the scan process
    1 [# G: J2 @; ~" s! \& M
50. #define CMD_802_11_ASSOCIATE 0x0012 // Initiate an association with the AP
    
51. #define CMD_MAC_CONTROL 0x0028 // Controls hardware MAC
    ( x9 Z. J/ X5 r# W4 `2 l7 t4 K
52. #define CMD_802_11_AD_HOC_START 0x002b // Starts an Ad-Hoc network
    
53. #define CMD_802_11_MAC_ADDR 0x004d // WLAN MAC address
    
54. #define CMD_802_11_KEY_MATERIAL 0x005e // Gets/sets key material used to do Tx encryption or Rx decryption
    9 m( g8 w4 e5 T6 e$ `1 h
55. #define CMD_802_11_BG_SCAN_CONFIG 0x006b // Gets/sets background scan configuration
    2 G5 R  e* }; I, D* Q
56. #define CMD_802_11_BG_SCAN_QUERY 0x006c // Gets background scan results
    0 A# A# X/ p5 y' X! P) C
57. 
    4 k" J' Z% G" M. W: G
58. /* Command Result Codes */
    1 n& I' t8 i1 t1 N& X  X4 N
59. #define CMD_STATUS_SUCCESS 0x0000 // No error
    
60. #define CMD_STATUS_ERROR 0x0001 // Command failed
    " X8 {" Z# h: g8 p$ ^1 s% u
61. #define CMD_STATUS_UNSUPPORTED 0x0002 // Command is not supported
    6 A) V$ C6 ~# n& ~2 A
62. 
    - J: F, H$ R0 {* a* i& G; n
63. #define WIFI_ACT_GET 0
    * {, g+ |' }& A8 [# h: p" A" B  v
64. #define WIFI_ACT_SET 1
    ( w4 M8 i* s9 t6 X' g
65. 
    
66. /* Authentication Type to be used to authenticate with AP */
    
67. #define AUTH_MODE_OPEN 0x00
    
68. #define AUTH_MODE_SHARED 0x01
    
69. #define AUTH_MODE_NETWORK_EAP 0x80
    
70. 
    
71. /* WiFi_Associate return value */
    
72. #define WIFI_ASSOCIATION_NOTFOUND 0xfffe
    
73. #define WIFI_ASSOCIATION_ERROR 0xffff
    
74. #define WIFI_ASSOCIATION_SUCCESS 0x0000 // 连接成功
    - U. E8 g" o; s/ L
75. #define WIFI_ASSOCIATION_INTERNALERROR 0x0101
    ' n! H: {. V0 e# A) R8 k
76. #define WIFI_ASSOCIATION_AUTHUNHANDLED(ret) (((ret) & 0xff00) == 0x200) // 未处理的认证帧
    
77. #define WIFI_ASSOCIATION_UNSUPPORTEDAUTHALG 0x0213
    
78. #define WIFI_ASSOCIATION_INVALIDSEQUENCENUMBER 0x0214
    7 }3 B9 ^/ S: [7 @$ q* Q2 n
79. #define WIFI_ASSOCIATION_AUTHREFUSED(ret) (((ret) & 0xff00) == 0x300) // 认证失败
    
80. #define WIFI_ASSOCIATION_TIMEOUT(ret) (((ret) & 0xff00) == 0x400) // 超时
    
81. #define WIFI_ASSOCIATION_ASSOCTIMEOUT 0x0401 // 连接超时
    
82. #define WIFI_ASSOCIATION_AUTHTIMEOUT 0x402 // 认证超时
    $ i; i  \. a) g* `# [# F- }/ d# U
83. #define WIFI_ASSOCIATION_NETWORKJOINTIMEOUT 0x403 // 加入网络时超时
    
84. 
    + e# R6 W$ P( @- Y$ V/ w8 a" O
85. #define WIFI_KEYTYPE_WEP 0
    2 V1 I# s! P5 q8 q: F6 c
86. #define WIFI_KEYTYPE_TKIP 1
    # i8 T9 [0 T$ {1 ^' s
87. #define WIFI_KEYTYPE_AES 2
    ; f  P! d! Q0 i8 H6 J0 Y# d
88. 
    # i: G: a3 `. o- u4 ]
89. #define WIFI_KEYINFO_KEYENABLED _BV(2)
    
90. #define WIFI_KEYINFO_UNICASTKEY _BV(1)
    , p2 z! u* ]' w. D4 I0 R
91. #define WIFI_KEYINFO_MULTICASTKEY _BV(0)
    ! d. i+ _1 C- d  {
92. 
    
93. #define WIFI_MACCTRL_RX _BV(0)
    
94. #define WIFI_MACCTRL_TX _BV(1) // 此位必须要置1才能发送数据！！！
    9 J7 z2 m& [: k! U
95. #define WIFI_MACCTRL_LOOPBACK _BV(2)
    
96. #define WIFI_MACCTRL_WEP _BV(3)
    
97. #define WIFI_MACCTRL_ETHERNET2 _BV(4)
    $ a+ T$ W, O5 U0 Y# Y& [  |
98. #define WIFI_MACCTRL_PROMISCUOUS _BV(7)
    , h: ^9 F3 l8 i9 g( x8 }
99. #define WIFI_MACCTRL_ALLMULTICAST _BV(8)
    + q. C  [+ h; j
100. #define WIFI_MACCTRL_ENFORCEPROTECTION _BV(10) // strict protection
     % \$ j$ g/ _( r! K  G2 p5 j
101. #define WIFI_MACCTRL_ADHOCGPROTECTIONMODE _BV(13) // 802.11g protection mode
     
102. 
     
103. /* BSS type */
     
104. #define BSS_INFRASTRUCTURE 0x01
     
105. #define BSS_INDEPENDENT 0x02
     
106. #define BSS_ANY 0x03
     
107. 
     ( p2 b" G2 z' M! u
108. /* Table 45: IEEE 802.11 Standard IE Translated to Marvell IE */
     3 {  I% x+ g# c7 U. z1 W1 Y: P
109. /* PDF中的表45有一些拼写错误, MRVIIE应该改为MRVLIE */
     
110. #define MRVLIETYPES_SSIDPARAMSET 0x0000
     2 w1 T* g* Q8 K' t+ k+ B1 _4 q
111. #define MRVLIETYPES_RATESPARAMSET 0x0001
     
112. #define MRVLIETYPES_DSPARAMSET 0x0003
     
113. #define MRVLIETYPES_CFPARAMSET 0x0004
     
114. #define MRVLIETYPES_IBSSPARAMSET 0x0006
     
115. #define MRVLIETYPES_RSNPARAMSET 0x0030
     1 U# L4 x  @+ F) W& A( h) p- s5 ~
116. #define MRVLIETYPES_VENDORPARAMSET 0x00dd
     - P; Q: C8 `4 ]2 O/ c2 i, p1 E, |. ]
117. 
     0 P; u+ O5 R9 ?* v2 g4 J
118. #define MRVLIETYPES_KEYPARAMSET 0x0100
     
119. #define MRVLIETYPES_CHANLISTPARAMSET 0x0101
     
120. #define MRVLIETYPES_TSFTIMESTAMP 0x0113
     
121. #define MRVLIETYPES_AUTHTYPE 0x011f
     
122. 
     
123. #define MRVLIE_PAYLOADLEN(s) (sizeof(s) - sizeof((s).header)) // 已知结构体大小sizeof(s), 求数据域的大小
     9 v( @+ o' v7 |8 H
124. #define MRVLIE_STRUCTLEN(s) (sizeof((s).header) + (s).header.length) // 已知数据域大小, 求整个结构体的大小
     
125. 
     
126. typedef __packed struct
     
127. {
     
128.         uint8_t type;
     
129.         uint8_t length;
     
130.         uint8_t data[1];
     , g3 s: z/ Y$ y2 }" R" o9 {
131. } IEEEType;
     
132. 
     
133. typedef __packed struct
     * {3 T$ e& w1 j8 ~, f# B
134. {
     8 J0 p3 ?7 f; e# T" N! \
135.         uint16_t ie_length; // Total information element length
     4 E) b3 p& Q' {$ P4 N) J
136.         uint8_t bssid[6]; // BSSID
     * j& N! l# I4 U
137.         uint8_t rssi; // RSSI value as received from peer
     9 z8 L* U" O9 B3 |* R
138.         
     ! Q& M, z" o/ w
139.         /* Probe Response/Beacon Payload */
     4 g% t3 C3 y+ `9 Z4 W+ l
140.         uint64_t pkt_time_stamp; // Timestamp
     
141.         uint16_t bcn_interval; // Beacon interval
     
142.         uint16_t cap_info; // Capabilities information
     6 s) h4 Z) Y+ v/ H2 \1 L
143.         IEEEType ie_parameters; // 存放的是一些IEEE类型的数据
     
144. } WiFi_BssDescSet;
     
145. 
     / C: V% u/ b- n% c, k3 J
146. typedef __packed struct
     % u/ ^& G6 I) H& E
147. {
     5 R  T, r9 x8 w* X
148.         uint8_t oui[3];
     # U' u. Z- \1 W4 P5 V/ }
149.         uint8_t oui_type;
     5 `; r0 z4 w, {3 O7 }
150.         uint8_t oui_subtype;
     
151.         uint8_t version;
     
152. } WiFi_VendorHeader;
     4 r( y. V. j1 [& Y# a
153. 
     
154. typedef __packed struct
     
155. {
     ( H0 v4 ], l4 N% f  }
156.         uint16_t type;
     
157.         uint16_t length;
     
158. } MrvlIEHeader;
     
159. 
     3 X. d- \/ ]  k6 T
160. typedef __packed struct
     ; S7 v, U7 n2 x
161. {
     
162.         MrvlIEHeader header;
     2 F, g$ V  U* ^! |, F# \. L
163.         uint16_t auth_type;
     
164. } MrvlIETypes_AuthType_t;
     
165. 
     
166. typedef uint16_t MrvlIETypes_CapInfo_t; // Section 7.3.1.4: IEEE 802.11-1999 Spec
     & j. q) g( G# r, R
167. 
     
168. typedef __packed struct
     
169. {
     ( V1 b4 u: ?: J7 o" v0 t/ Z
170.         MrvlIEHeader header;
     
171.         uint8_t count;
     
172.         uint8_t period;
     : H' f5 w4 ~. b) ]2 `4 S# w+ t
173.         uint16_t max_duration;
     
174.         uint16_t duration_remaining;
     
175. } MrvlIETypes_CfParamSet_t;
     
176. 
     * U+ n- a# g7 Y3 B0 f, q
177. /*typedef __packed struct
     
178. {
     % F" d# X8 F5 b; {  I. @! W0 d
179.         MrvlIEHeader header;
     
180.         __packed struct
     
181.         {
     
182.                 uint8_t band_config_type;
     3 s( ~, I- _7 k. ]. L3 {2 {( q
183.                 uint8_t chan_number;
     
184.         } channels[1];
     
185. } MrvlIETypes_ChanBandList_t;*/
     1 a6 f* T2 N' u3 V" D
186. 
     & J3 M" l9 [' {4 p
187. typedef __packed struct
     
188. {
     
189.         MrvlIEHeader header;
     7 J9 t2 i$ w6 I  V5 }$ R0 u
190.         __packed struct
     
191.         {
     + K2 {: G7 Q9 m: m: z) ~. k
192.                 uint8_t band_config_type;
     7 [) `9 L2 G9 F8 _7 d# r
193.                 uint8_t chan_number;
     " ^3 o0 @3 e2 E- \  q# z, U! d! K
194.                 uint8_t scan_type;
     
195.                 uint16_t min_scan_time;
     1 k; ]/ {( J# S( W
196.                 uint16_t max_scan_time;
       `0 W5 a. {% {0 Y
197.         } channels[1];
     
198. } MrvlIETypes_ChanListParamSet_t;
     
199. 
     7 z8 D. E1 @) A  j& c
200. typedef __packed struct
     2 Y) B! \: ]3 v, H2 p0 p
201. {
     
202.         MrvlIEHeader header;
       g) K2 @' f  |; Q! i; g
203.         uint8_t channel;
     4 F; F4 Y& D: ^. e' ~$ m  J/ ?# [: K+ i
204. } MrvlIETypes_DsParamSet_t;
     ! Z' w9 k+ B9 d# {
205. 
     
206. typedef MrvlIETypes_DsParamSet_t MrvlIETypes_PhyParamDSSet_t;
     
207. 
     
208. typedef __packed struct
     : t) Y/ e# k  u
209. {
     
210.         MrvlIEHeader header;
     
211.         uint16_t atim_window;
     ; i' U) u; [1 r/ R4 x3 G% U
212. } MrvlIETypes_IbssParamSet_t;
     ; r% P! t. A& d& z5 `3 y( s
213. 
     
214. typedef __packed struct
     + D- i0 M0 F' K0 t
215. {
     
216.         MrvlIEHeader header;
     
217.         uint16_t key_type_id;
     ( S/ m0 N2 j4 ~* k; {8 A# t* G7 H
218.         uint16_t key_info;
     
219.         uint16_t key_len;
     , m) \$ U% U/ U7 O+ L- O# |
220.         uint8_t key[32];
     
221. } MrvlIETypes_KeyParamSet_t;
     
222. 
     5 `* k# z1 c- G/ q; }+ i
223. typedef __packed struct
     
224. {
     
225.         MrvlIEHeader header;
     
226.         uint8_t rates[14];
     ' m: R( U( P5 c
227. } MrvlIETypes_RatesParamSet_t;
     - ~- ^2 \. T+ L, f+ M
228. 
     
229. typedef __packed struct
     / f  r. g, R: v8 I! ^, K5 J5 l
230. {
     
231.         MrvlIEHeader header;
     
232.         uint8_t rsn[64];
     0 z4 ~+ R, d" g% T% ^
233. } MrvlIETypes_RsnParamSet_t;
     
234. 
     
235. typedef __packed struct
     
236. {
     
237.         MrvlIEHeader header;
     % ]0 H* Z' n7 \
238.         uint8_t ssid[32];
     + {0 I7 |3 S% w4 o" I7 `! c
239. } MrvlIETypes_SSIDParamSet_t;
     + h, f, A/ ?3 {0 w
240. 
     
241. typedef __packed struct
     
242. {
     + l( Z' x2 e+ H' d0 K2 O% U
243.         MrvlIEHeader header;
     
244.         uint64_t tsf_table[1];
     
245. } MrvlIETypes_TsfTimestamp_t;
     % K" ~9 z" q3 E1 e- _" x
246. 
     
247. // 整个结构体的最大大小为256字节
     
248. typedef __packed struct
     " ~/ h& p, A# q% w% E
249. {
     
250.         MrvlIEHeader header;
     
251.         uint8_t vendor[64]; // 通常情况下64字节已足够
     
252. } MrvlIETypes_VendorParamSet_t;
     
253. 
     " ]* ]9 t( M- `/ B6 ~, e
254. typedef __packed struct
     5 B/ m. m# P9 q1 a& a" G2 D. V* V) B
255. {
     
256.         uint16_t length;
     0 P& O' J! _/ S1 \; H
257.         uint16_t type;
     
258. } WiFi_SDIOFrameHeader;
     3 t% `  ^" ]3 L' T
259. 
     
260. typedef __packed struct
     
261. {
     
262.         WiFi_SDIOFrameHeader frame_header;
     3 s/ b/ g: f% i  p
263.         uint16_t cmd_code;
     " Y' O  S. J" e
264.         uint16_t size;
     
265.         uint16_t seq_num;
     
266.         uint16_t result;
     
267. } WiFi_CommandHeader;
     
268. 
     + F1 ?' l) M! g0 \/ ~
269. /* Table 2: Fields in Receive Packet Descriptor */
     4 O6 v6 }3 B( V  q8 E6 W: C. B
270. typedef __packed struct
     ( P/ E- ~; ~; C3 [. J8 h/ d4 J; l! B
271. {
     
272.         WiFi_SDIOFrameHeader header;
     
273.         uint16_t reserved1;
     
274.         uint8_t snr; // Signal to noise ratio for this packet (dB)
     
275.         uint8_t reserved2;
     " n1 R8 v; S0 G
276.         uint16_t rx_packet_length; // Number of bytes in the payload
     
277.         uint8_t nf; // Noise floor for this packet (dBm). Noise floor is always negative. The absolute value is passed.
     
278.         uint8_t rx_rate; // Rate at which this packet is received
     , r4 g, ~  }) v" P
279.         uint32_t rx_packet_offset; // Offset from the start of the packet to the beginning of the payload data packet
     
280.         uint32_t reserved3;
     9 e& c+ O* M% w) M1 C
281.         uint8_t priority; // Specifies the user priority of received packet
     & k- T' R+ }  i3 F8 ]$ p2 t% d4 |
282.         uint8_t reserved4[3];
     
283.         uint8_t payload[1]; // 数据链路层上的帧
     
284. } WiFi_DataRx;
     
285. 
     7 x% [( l8 |) x* S* d
286. /* Table 3: Fields in Transmit Packet Descriptor */
     " T- k9 R3 }% x- f+ R( s6 O
287. typedef __packed struct
     
288. {
     
289.         WiFi_SDIOFrameHeader header;
     2 {9 x  T% Z' K, s; G5 ~
290.         uint32_t reserved1;
     & P! E% H: W  |8 r! h
291.         uint32_t tx_control; // See 3.2.1 Per-Packet Settings
     1 ?. O" H/ h# F( u* R* r0 z  @
292.         uint32_t tx_packet_offset; // Offset of the beginning of the payload data packet (802.3 or 802.11 frames) from the beginning of the packet (bytes)
     
293.         uint16_t tx_packet_length; // Number of bytes in the payload data frame
     , Y4 b# b( N0 K& |9 b1 N& Q
294.         uint16_t tx_dest_addr_high; // Destination MAC address bytes 4 to 5
     9 J, x- ^8 ^0 ]. I
295.         uint32_t tx_dest_addr_low; // Destination MAC address bytes 0 to 3
     5 X( d% j3 A( `$ z/ X
296.         uint8_t priority; // Specifies the user priority of transmit packet
     
297.         uint8_t flags;
     
298.         uint8_t pkt_delay_2ms; // Amount of time the packet has been queued in the driver layer for WMM implementations
     
299.         uint8_t reserved2;
     4 k5 t- b0 `- p
300.         uint8_t payload[1]; // 数据链路层上的帧
     & [. G4 v( ?4 A  J2 ^( k
301. } WiFi_DataTx;
     
302. 
     2 b( J* _* H& G" n& X" f  A% H
303. typedef __packed struct
     & K% X8 E8 B3 E3 u9 M! e  C$ r1 u
304. {
     
305.         WiFi_CommandHeader header;
     
306.         uint16_t action;
     
307. } WiFi_Cmd_KeyMaterial;
     + ]- _0 i  n; {( L- y$ O+ P
308. 
     + O* J/ E. k2 \
309. typedef __packed struct
     
310. {
     
311.         WiFi_CommandHeader header;
     
312.         uint16_t action;
     # ]& a) E/ `/ v6 p6 T! {# P( I
313.         uint8_t mac_addr[6];
     
314. } WiFi_Cmd_MACAddr;
     7 W, [. V$ g/ M. Z/ S& K. k9 `; O* ?7 w
315. 
     
316. typedef __packed struct
     & J8 H, W; Z7 d6 F$ N/ A
317. {
     
318.         WiFi_CommandHeader header;
     6 w# _* c5 u: t5 Y
319.         uint16_t action;
     
320.         uint16_t reserved;
     $ V% f3 A3 ?! K+ V( j/ }
321. } WiFi_Cmd_MACCtrl;
     . E0 I- T) ?4 W7 k0 I- j
322. 
     1 l0 b. g" q, A4 H' h! J
323. typedef __packed struct
     
324. {
     
325.         WiFi_CommandHeader header;
     
326.         uint8_t ssid[32];
     : l3 O) C: e0 H+ k+ N  j9 r% G) M
327.         uint8_t bss_type;
     
328.         uint16_t bcn_period;
     ( G/ U+ i# Q3 R7 Y' e0 m/ t
329.         uint8_t reserved1;
     
330.         MrvlIETypes_IbssParamSet_t ibss_param_set; // ATIM window length in TU
     
331.         uint32_t reserved2;
     ! w) J, i# t+ e% c- u
332.         MrvlIETypes_DsParamSet_t ds_param_set; // The channel for ad-hoc network
     
333.         uint16_t reserved3[3];
     : S& Z$ n$ d" a3 s% C' I, I/ \, V
334.         MrvlIETypes_CapInfo_t cap_info; // Capability information
     
335.         uint8_t data_rate[14];
     : K" D$ R7 f4 H! T! w0 f
336. } WiFi_CmdRequest_ADHOCStart;
     
337. 
     * p( ^% m/ X7 D( [  p
338. typedef __packed struct
     ! L! S4 c. m" M$ J) N# L; V% B
339. {
     : r9 I( u) z# D3 n1 o+ ]6 w
340.         WiFi_CommandHeader header;
     
341.         uint8_t peer_sta_addr[6]; // Peer MAC address
     * f6 s% C4 D0 b. K  ^* O: q
342.         MrvlIETypes_CapInfo_t cap_info; // Capability information
     
343.         uint16_t listen_interval; // Listen interval
     
344.         uint16_t bcn_period; // Beacon period
     ' ]1 F) s2 L( h/ E" T
345.         uint8_t dtim_period; // DTIM period
       M$ ?( R% B1 Z
346. } WiFi_CmdRequest_Associate;
     
347. 
     
348. typedef __packed struct
     0 m  ?4 s1 L* {+ _; H7 Y  t$ B
349. {
     
350.         WiFi_CommandHeader header;
     
351.         uint8_t bss_type;
     
352.         uint8_t bss_id[6];
     * ^+ |1 j6 ^/ s: g; S; c, `* z8 k
353. } WiFi_CmdRequest_Scan;
     
354. 
     
355. typedef __packed struct
     
356. {
     
357.         WiFi_CommandHeader header;
     
358.         uint16_t capability;
     / B% I# v$ h3 N6 q0 {7 t
359.         uint16_t status_code;
     
360.         uint16_t association_id;
     
361.         IEEEType ie_buffer;
     
362. } WiFi_CmdResponse_Associate;
     ( H, i1 s/ Z* p7 A# @9 B
363. 
     
364. typedef __packed struct
     
365. {
     : u: @' b0 u& @
366.         WiFi_CommandHeader header;
     
367.         uint16_t buf_size;
     
368.         uint8_t num_of_set;
     # ~. R. a& ?' S5 Q0 x0 x- V2 Q
369. } WiFi_CmdResponse_Scan;
     # I' S  ~; l5 v6 y
370. 
       @7 l* m# Z$ y* J2 h3 V0 W5 r# u- m
371. typedef __packed struct
     
372. {
     . D% `% n" H. H3 o) k% z9 W
373.         MrvlIETypes_SSIDParamSet_t ssid;
     " V& e8 ]$ X+ x
374.         uint8_t mac_addr[6];
     
375.         MrvlIETypes_CapInfo_t cap_info;
     $ s0 J' \5 M$ {" Q9 ^! P
376.         uint16_t bcn_period;
     
377.         uint8_t channel;
     " r4 A8 g+ m1 T: }6 i8 X0 i$ w. h
378.         MrvlIETypes_RatesParamSet_t rates;
     
379.         MrvlIETypes_RsnParamSet_t rsn;
     % D& f. o8 Z2 W4 b& a; o& U
380.         MrvlIETypes_VendorParamSet_t wpa;
     
381.         MrvlIETypes_VendorParamSet_t wwm;
     
382.         MrvlIETypes_VendorParamSet_t wps;
     ( @5 w) c" K1 {( {, v' z# b
383. } WiFi_SSIDInfo;
     6 }9 g/ E; T! k" R
384. 
     
385. #define WiFi_DropPacket() WiFi_ReceivePacket(0, 0)
     
386. #define WiFi_GetBlockSize() _BV((SDIO->DCTRL & SDIO_DCTRL_DBLOCKSIZE) >> 4)
     
387. #define WiFi_GetMACAddr(addr) WiFi_MACAddr((addr), WIFI_ACT_GET)
     
388. #define WiFi_PacketArrived() (WiFi_Read(1, WIFI_CARDSTATUS) & WIFI_CARDSTATUS_UPLDCARDRDY)
     
389. #define WiFi_ResendCommand(cmd) WiFi_SendCommand(0, (cmd), 0)
     4 D& o; o9 K5 E5 T' l
390. #define WiFi_SetMACAddr(addr) WiFi_MACAddr((uint8_t *)(addr), WIFI_ACT_SET)
     
391. #define WiFi_ShowShortResponse() printf("Command response received: CMD%d, RESP_%08x\n", SDIO->RESPCMD, SDIO->RESP1)
     2 e; p: O( k. d
392. 
     / u1 e6 v% ?, T) p7 w
393. uint16_t WiFi_Associate(const char *ssid);
     
394. void WiFi_CheckCmdTimeout(void);
     - a1 P) b* M. p* g1 o
395. uint16_t WiFi_Connect(const char *ssid, const char *password);
     ( `, P. ?% q& H" [' ^6 i
396. uint8_t WiFi_DownloadFirmware(void);
     
397. uint16_t WiFi_GetPacketLength(void);
     
398. void WiFi_Init(void);
     
399. uint16_t WiFi_KeyMaterial(MrvlIETypes_KeyParamSet_t *keys, uint16_t size, uint8_t action);
     
400. void WiFi_MACAddr(uint8_t addr[6], uint8_t action);
     7 p/ ?8 Q. `' {  a# A# G
401. void WiFi_MACControl(uint16_t action);
     3 G6 V) e( g! q# \0 r  k; H
402. uint16_t WiFi_PacketPending(void);
     
403. void WiFi_PrepareTimer(uint16_t nms);
     
404. uint8_t WiFi_Read(uint8_t func, uint32_t addr);
     
405. void WiFi_ReadData(uint8_t func, uint32_t addr, uint8_t *data, uint16_t count, uint16_t bufsize, uint32_t flags);
     % {' `& U( [) t% d6 z
406. uint16_t WiFi_ReadPort(void *buf, uint16_t size, uint16_t bufsize);
     
407. uint16_t WiFi_ReceivePacket(void *buf, uint16_t bufsize);
     
408. uint16_t WiFi_ReceiveResponse(void *buf, uint16_t bufsize);
     
409. void WiFi_Scan(void);
     
410. uint8_t WiFi_ScanSSID(const char *ssid, WiFi_SSIDInfo *info, uint8_t *buffer, uint16_t bufsize);
     ! s4 b' L. v0 k
411. void WiFi_SendCMD52(uint8_t func, uint32_t addr, uint8_t data, uint32_t flags);
     
412. void WiFi_SendCMD53(uint8_t func, uint32_t addr, uint16_t count, uint32_t flags);
     * u4 w" `/ Y; l; Y2 k: ?
413. void WiFi_SendCommand(uint16_t com_code, void *data, uint16_t size);
     
414. uint8_t WiFi_SendPacket(WiFi_DataTx *packet, uint16_t packet_len);
     
415. void WiFi_SetBlockSize(uint8_t func);
     
416. uint8_t WiFi_SetKeyMaterial(uint16_t type, uint16_t info, const uint8_t *key, uint16_t len);
     
417. void WiFi_ShowCIS(uint8_t func);
     8 L* E2 T) G( k" i
418. void WiFi_ShowKeyMaterials(void);
       @" F3 C/ v. I6 M
419. uint8_t WiFi_StartADHOC(const char *ssid);
     8 o. w. i1 p, y, w) ^( y9 s. o7 S
420. uint8_t WiFi_Wait(uint8_t status);
     9 c5 Q& f9 K/ t/ r& z3 Q
421. uint8_t WiFi_Write(uint8_t func, uint32_t addr, uint8_t value);
     
422. void WiFi_WriteData(uint8_t func, uint32_t addr, const uint8_t *data, uint16_t count, uint16_t bufsize, uint32_t flags);
     
423. uint8_t WiFi_WritePort(const void *data, uint16_t size);
     

复制代码

【WiFi.c】
; c+ x& y! e3 J+ `

1. #include <stdio.h>
   
2. #include <stm32f10x.h>
   ' _, Y% G7 p3 _* O9 p& r
3. #include <string.h>
   ) j  _1 p) d5 f. }8 ]6 ?/ I
4. #include "WiFi.h"
   
5. 
   
6. extern const unsigned char firmware_helper_sd[2516];
   
7. extern const unsigned char firmware_sd8686[122916];
   
8. 
   8 w3 \" p8 ]' y4 R8 \7 p: }
9. //const uint8_t wifi_mac_addr[] = {0x62, 0x1d, 0x2f, 0x00, 0x4e, 0x2d}; // MAC地址的第一个字节必须为偶数! 否则为多播地址
   . j) k/ B5 _$ {$ @7 S
10. 
    
11. static uint16_t rca;
    ! l& }- M8 }2 O9 F9 \
12. static uint16_t wifi_timeout = WIFI_DEFAULTTIMEOUT;
    % W2 j3 d: S( K% ^% p0 X
13. static uint32_t io_addr;
    2 m- k: x9 w7 k: N
14. static uint16_t wifi_pending_size = 0; // 未读的数据包大小
    
15. 
    
16. void delay(uint16_t n);
    8 }/ l$ ~3 X4 a* l( s
17. void dump_data(uint8_t *data, uint16_t len);
    ( ], v8 K7 d: I0 ^+ [
18. 
    9 R- y% {: r3 j+ `8 y, M3 f) {
19. /* 关联一个热点 */
    
20. uint16_t WiFi_Associate(const char *ssid)
    + a: z& [8 i' ?. s2 t0 ~2 u
21. {
    
22.         uint8_t buffer[2048];
    
23.         WiFi_SSIDInfo info;
    8 s) u# Q+ Y/ m% T' T
24.         WiFi_CmdRequest_Associate *cmd = (WiFi_CmdRequest_Associate *)buffer;
    
25.         WiFi_CmdResponse_Associate *resp = (WiFi_CmdResponse_Associate *)buffer;
      {9 |$ x/ ]: u! m& D6 o3 Y
26.         MrvlIETypes_DsParamSet_t *ds;
    4 q& O7 |) C1 M  u, {: ]
27.         MrvlIETypes_CfParamSet_t *cf;
    $ B/ F; T' x! y; B0 x
28.         MrvlIETypes_AuthType_t *auth;
    : K6 p3 h6 f; ^  |( j8 S0 p
29.         MrvlIETypes_RsnParamSet_t *rsn;
    5 l' \+ T8 z! L' C; [3 a0 y
30. 
    0 c& `; z& S/ V) w
31.         if (!WiFi_ScanSSID(ssid, &info, buffer, sizeof(buffer)))
    
32.         {
    
33.                 printf("Cannot find AP: %s!\n", ssid);
    * r4 H( w: ?1 x! `9 h
34.                 return WIFI_ASSOCIATION_NOTFOUND;
    
35.         }
    
36.         
    
37.         memcpy(cmd->peer_sta_addr, info.mac_addr, sizeof(info.mac_addr));
    1 W! E4 i+ B: t' u6 V/ X% ~
38.         cmd->cap_info = info.cap_info;
    + d( c& G+ q" D) z4 @
39.         cmd->listen_interval = 10;
    
40.         cmd->bcn_period = info.bcn_period;
    
41.         cmd->dtim_period = 0;
    
42.         memcpy(cmd + 1, &info.ssid, MRVLIE_STRUCTLEN(info.ssid));
    
43.         
    : M! L7 t( R/ g( U
44.         ds = (MrvlIETypes_DsParamSet_t *)((uint8_t *)(cmd + 1) + MRVLIE_STRUCTLEN(info.ssid));
    
45.         ds->header.type = MRVLIETYPES_DSPARAMSET;
    
46.         ds->header.length = 1;
    7 ?$ i& I# P2 o" e5 q
47.         ds->channel = info.channel;
    4 l: z# Q3 w* W( A- @  K$ u
48.         
    5 B5 p9 |( Y! A" N3 w* w# ]
49.         cf = (MrvlIETypes_CfParamSet_t *)(ds + 1);
    
50.         memset(cf, 0, sizeof(MrvlIETypes_CfParamSet_t));
    
51.         cf->header.type = MRVLIETYPES_CFPARAMSET;
    
52.         cf->header.length = MRVLIE_PAYLOADLEN(*cf);
    
53.         
    9 q" Q) H7 o7 X& u4 Y6 S. c! G9 S
54.         memcpy(cf + 1, &info.rates, MRVLIE_STRUCTLEN(info.rates));
    
55.         auth = (MrvlIETypes_AuthType_t *)((uint8_t *)(cf + 1) + MRVLIE_STRUCTLEN(info.rates));
    1 ?, u) i2 G9 e1 P" _) N# h6 j
56.         auth->header.type = MRVLIETYPES_AUTHTYPE;
    
57.         auth->header.length = MRVLIE_PAYLOADLEN(*auth);
    : y+ {( y$ U) {! A
58.         auth->auth_type = AUTH_MODE_OPEN;
    - z8 F: `" x7 _
59.         
    
60.         rsn = (MrvlIETypes_RsnParamSet_t *)(auth + 1);
    ; W5 b, t3 O" n7 h
61.         if (info.rsn.header.type)
    ( p9 m1 f+ [* o- F3 X- E# D
62.         {
    
63.                 // WPA2网络必须在命令中加入RSN参数才能成功连接
    
64.                 memcpy(rsn, &info.rsn, MRVLIE_STRUCTLEN(info.rsn));
    
65.                 WiFi_SendCommand(CMD_802_11_ASSOCIATE, buffer, (uint8_t *)rsn - buffer + MRVLIE_STRUCTLEN(info.rsn));
    
66.         }
    
67.         else
    
68.                 WiFi_SendCommand(CMD_802_11_ASSOCIATE, buffer, (uint8_t *)rsn - buffer); // 其余网络不需要RSN参数
    
69.         
    , p* B% Z7 ~) O8 p! n. j
70.         if (!WiFi_ReceiveResponse(buffer, sizeof(buffer)))
    
71.         {
    9 L" s& u8 v) M' ?
72.                 printf("Association with %s failed!\n", ssid);
    0 j9 x$ ~" v4 I
73.                 return WIFI_ASSOCIATION_ERROR;
    ( c1 F3 y2 Y$ c' X) L4 f; V' T( s
74.         }
    
75.         
    
76.         //printf("capability=0x%04x, status_code=0x%04x, aid=0x%04x\n", resp->capability, resp->status_code, resp->association_id);
    . g* o) i  W+ ~& m9 \/ T8 D
77.         if (resp->association_id == 0xffff)
    8 g' _& u/ L0 h  @2 t  k, ~; M
78.                 return ((-resp->capability) << 8) | resp->status_code;
    5 _( ]5 t, \$ l5 o
79.         return WIFI_ASSOCIATION_SUCCESS;
    , Q3 _& ]4 J/ |& V! E: }7 y# b
80. }
    
81. 
    
82. /* 检查命令是否收到了回应, 若没收到则重发命令 */
    0 t" w0 k/ ?7 m% j+ U0 [
83. void WiFi_CheckCmdTimeout(void)
    6 d: K5 m  t3 L& k- `) w
84. {
    2 C# X9 r* ~' T7 z7 k
85.         while (SDIO->STA & SDIO_STA_CTIMEOUT)
    1 F6 I* s# r, W1 N9 y- c8 ^, J
86.         {
    
87.                 SDIO->ICR = SDIO_ICR_CTIMEOUTC; // 清除标志
      M. _1 m: O9 L, U% w0 C) y8 w& a  M
88.                 SDIO->CMD = SDIO->CMD; // 重发
    
89.                 printf("Timeout! Resend CMD%d\n", SDIO->CMD & SDIO_CMD_CMDINDEX);
    
90.                 while (SDIO->STA & SDIO_STA_CMDACT);
    " @! Q+ b; e! \8 T- D! R. h
91.         }
    , f% Z4 l* X$ v& t7 x  O
92. }
    7 S( K& u9 W+ c" G7 a+ K
93. 
    2 ]% M; n; F0 s/ b" I, _
94. /* 连接WiFi热点, 并输入密码 */
    4 h9 b4 r1 s; \+ @7 M2 h
95. uint16_t WiFi_Connect(const char *ssid, const char *password)
    
96. {
    
97.         uint16_t ret;
    
98.         do
    , l0 Z( M( n* {& x
99.         {
    " x  Z7 @. m0 j9 e7 p
100.                 ret = WiFi_Associate(ssid);
     % L: Z- y9 L; P2 x7 j
101.                 if (ret != WIFI_ASSOCIATION_SUCCESS)
     
102.                 {
     2 S( @! s5 y6 s1 \3 |
103.                         printf("WiFi_Associate returned 0x%04x\n", ret);
     
104.                         delay(2000); // 等待一段时间后重连
     : X& |+ ~8 B* K% P# ?
105.                 }
     
106.         } while (WIFI_ASSOCIATION_TIMEOUT(ret) || ret == WIFI_ASSOCIATION_NOTFOUND); // 若连接超时, 或未扫描到热点, 则重连
     + Y% U1 p( s* N. l# m3 _3 N4 Z
107.         
     4 D( h& x$ t7 U+ w; P% ]
108.         if (ret != WIFI_ASSOCIATION_SUCCESS)
     2 N, c. T, x" P4 i8 m" E
109.                 return ret;
     
110.         
     
111.         printf("Connected to %s!\n", ssid);
     
112.         return ret;
     * P* F  M. n/ O8 d# v% k$ m. b
113. }
     5 d7 @7 Z1 e+ n7 b7 q3 ?
114. 
     
115. /* 下载固件 */
     
116. // 参考文档: marvell-88w8686-固件下载程序说明.doc
     
117. uint8_t WiFi_DownloadFirmware(void)
     2 O& a7 y; o8 P% f) ^$ D2 o0 u' q
118. {
     
119.         uint8_t helper_buf[64];
     $ f* x* h, m, A- Q0 z! G' V& R
120.         const uint8_t *data;
     
121.         uint16_t size;
     
122.         uint32_t len;
     3 U' s  B1 R( e+ ^
123.         
     : @* Z' s; U; b' D8 i  O( f
124.         // 块大小设为32
     ; J7 m5 X1 V5 ]2 o* [# U6 k2 n
125.         SDIO->DCTRL = (SDIO->DCTRL & ~SDIO_DCTRL_DBLOCKSIZE) | SDIO_DCTRL_DBLOCKSIZE_2 | SDIO_DCTRL_DBLOCKSIZE_0;
     5 {- ^1 o  |3 M, }
126.         WiFi_SetBlockSize(1); // 应用到Function 1
     . a0 I# c( I4 `* ?/ |% {# b# D. b
127.         
     
128.         // 下载helper
     
129.         io_addr = WiFi_Read(1, 0x00) | (WiFi_Read(1, 0x01) << 8) | (WiFi_Read(1, 0x02) << 16);
     
130.         data = firmware_helper_sd;
     
131.         len = sizeof(firmware_helper_sd);
     
132.         while (len)
     3 o" Y+ e; @0 f; S" m3 d
133.         {
       ^! G  e6 F6 ~  z8 N& H
134.                 // 每次下载64字节, 其中前4字节为本次下载的数据量
     2 w) x. i4 u, n! M- z8 S( K
135.                 size = (len > 60) ? 60 : len;
     " n7 h* }* a4 E8 E0 q, Q
136.                 *(uint32_t *)helper_buf = size;
     
137.                 memcpy(helper_buf + 4, data, size);
     & ~+ ~; R& s: `) f; @
138.                
     
139.                 WiFi_Wait(WIFI_CARDSTATUS_DNLDCARDRDY);
     * f  l) ^8 K; f. E$ e1 Y% d
140.                 WiFi_WritePort(helper_buf, sizeof(helper_buf));
     
141.                 len -= size;
     2 x- J, P& s0 `- ^& t
142.                 data += size;
     9 t1 V+ ^0 S+ ^% q# K& V6 ^
143.         }
     ! n! S$ y! Z1 _. \- \9 H$ ?
144.         *(uint32_t *)helper_buf = 0;
     
145.         WiFi_WritePort(helper_buf, sizeof(helper_buf)); // 以空数据包结束
     # X  A0 N' H8 z9 r$ T
146.         
     : W( }0 j' e' X$ D1 _% Z
147.         // 下载固件
     
148.         data = firmware_sd8686;
     5 O& C$ e2 y. D3 V- X" _% {1 D) ^
149.         len = sizeof(firmware_sd8686);
     
150.         while (len)
     # Z0 D7 C' N( F; S( q) |
151.         {
     5 s+ Z, e4 T8 ^3 ~# b
152.                 WiFi_Wait(WIFI_CARDSTATUS_DNLDCARDRDY);
     
153.                 while ((size = WiFi_Read(1, WIFI_SQREADBASEADDR0) | (WiFi_Read(1, WIFI_SQREADBASEADDR1) << 8)) == 0); // 获取本次下载的字节数
     
154.                 //printf("Required: %d bytes, Remaining: %d bytes\n", size, len);
     
155.                
     * n& I! w+ u- M% v8 b; _4 _
156.                 if (size & 1)
     
157.                 {
     
158.                         // 若size为奇数(如17), 则说明接收端有CRC校验错误, 应重新传送上一次的内容(这部分代码省略)
     ; b0 \  Q/ a: _
159.                         printf("Error: an odd size is invalid!\n");
     
160.                         return 0;
     0 d: E$ F4 w7 V' b$ [8 I* S# a5 ^
161.                 }
     " a) Y; p% j- z# Z: \
162.                 if (size > len)
     
163.                         size = len;
     7 a; e% ?/ H! P6 R* q- D3 i
164.                
     
165.                 if (!WiFi_WritePort(data, size))
     
166.                 {
     
167.                         printf("Data transfer error! SDIO->STA=0x%08x\n", SDIO->STA);
     
168.                         return 0;
     
169.                 }
     ' C8 v. b/ |; b( n6 {' K: t
170.                
     
171.                 len -= size;
     : f- F: [. H3 E: K4 m6 B- l
172.                 data += size;
     
173.         }
     ' F4 L0 e5 K  M/ D! R
174.         
     
175.         // 等待Firmware启动
     
176.         while (WiFi_GetPacketLength() == 0xfedc);
     
177.         printf("Firmware is successfully downloaded!\n");
     ' x( z$ U& s6 t
178.         return 1;
     1 G5 e  ~  o* K9 U4 V+ j
179. }
       b6 k9 x: U7 j- D# ]
180. 
     
181. /* 获取数据帧大小 */
     
182. uint16_t WiFi_GetPacketLength(void)
     
183. {
     0 U! ^/ B/ g% A6 ^2 q
184.         return WiFi_Read(1, 0x34) | (WiFi_Read(1, 0x35) << 8);
     
185. }
     
186. 
     5 `+ d' }: Z4 T0 ^
187. /* 初始化WiFi模块 */
     
188. // SDIO Simplified Specification Version 3.00: 3. SDIO Card Initialization
     
189. void WiFi_Init(void)
     
190. {
     
191.         printf("Initialization begins...\n");
     
192.         SDIO->POWER = SDIO_POWER_PWRCTRL;
     ! k  h6 u6 G8 ~* r- c
193.         SDIO->CLKCR = SDIO_CLKCR_CLKEN | 178; // 初始化时最高允许的频率: 72MHz/(178+2)=400kHz
     6 D) j! z1 f4 [
194.         delay(5); // 延时可防止CMD5重发
     3 X; p( p6 Y, \! O* L7 q
195.         
     
196.         // 不需要发送CMD0, 因为SD I/O card的初始化命令是CMD52
     ! S! }  B3 v7 O$ X; T
197.         // An I/O only card or the I/O portion of a combo card is NOT reset by CMD0. (See 4.4 Reset for SDIO)
     
198.         
     
199.         /* 发送CMD5: IO_SEND_OP_COND */
     
200.         SDIO->CMD = SDIO_CMD_CPSMEN | SDIO_CMD_WAITRESP_0 | 5;
     
201.         while (SDIO->STA & SDIO_STA_CMDACT);
     
202.         WiFi_CheckCmdTimeout(); // 为了保险起见还是要检查一下是否要重发命令
     
203.         if (SDIO->STA & SDIO_STA_CMDREND)
     
204.         {
     
205.                 SDIO->ICR = SDIO_ICR_CMDRENDC;
     
206.                 WiFi_ShowShortResponse();
     0 V3 T7 h* D; D2 ^. x$ f1 o5 a
207.         }
     + R8 R1 x( ~' H# e8 k, k
208.         
     ; `5 i8 R) o7 ?
209.         /* 设置参数VDD Voltage Window: 3.2~3.4V, 并再次发送CMD5 */
     # k" A1 j( J. W7 [, J% g
210.         SDIO->ARG = 0x300000;
     3 h; m8 ]* ?" x& `' ]
211.         SDIO->CMD = SDIO->CMD;
     5 b7 S5 c  V3 o) d9 f
212.         while (SDIO->STA & SDIO_STA_CMDACT);
     3 h% E& j. u1 ^# g: J/ E! R
213.         if (SDIO->STA & SDIO_STA_CMDREND)
     
214.         {
     
215.                 SDIO->ICR = SDIO_ICR_CMDRENDC;
     
216.                 WiFi_ShowShortResponse();
     ) ?/ c4 {5 T6 y$ w1 C$ ]
217.                 if (SDIO->RESP1 & _BV(31))
     
218.                 {
     
219.                         // Card is ready to operate after initialization
     & u# @" N/ h4 r  }4 v: d( [" G
220.                         printf("Number of I/O Functions: %d\n", (SDIO->RESP1 >> 28) & 7);
     
221.                         printf("Memory Present: %d\n", (SDIO->RESP1 & _BV(27)) != 0);
     
222.                 }
     4 V, r$ @2 {$ p, j7 I! O
223.         }
     
224.         
     , a# P, b) _; ^
225.         /* 获取WiFi模块地址 (CMD3: SEND_RELATIVE_ADDR, Ask the card to publish a new relative address (RCA)) */
     ( `) b4 x; g6 L6 P. E  U/ ?
226.         SDIO->ARG = 0;
     
227.         SDIO->CMD = SDIO_CMD_CPSMEN | SDIO_CMD_WAITRESP_0 | 3;
     ; T8 O4 q1 d( o) A4 ~
228.         while (SDIO->STA & SDIO_STA_CMDACT);
     
229.         if (SDIO->STA & SDIO_STA_CMDREND)
     5 {1 V6 x' d$ G+ ~
230.         {
     - G* `+ R! t/ v+ P) q
231.                 SDIO->ICR = SDIO_ICR_CMDRENDC;
     
232.                 rca = SDIO->RESP1 >> 16;
     
233.                 printf("Relative card address: 0x%04x\n", rca);
     
234.         }
     
235.         
     ! c: o1 d- \5 H) m' ~$ R1 W1 I
236.         /* 选中WiFi模块 (CMD7: SELECT/DESELECT_CARD) */
     & V* x5 K: ~$ ?+ K! K/ M0 l7 G4 t; j
237.         SDIO->ARG = rca << 16;
     
238.         SDIO->CMD = SDIO_CMD_CPSMEN | SDIO_CMD_WAITRESP_0 | 7;
     " y" `$ y/ G; E% a: O
239.         while (SDIO->STA & SDIO_STA_CMDACT);
     
240.         if (SDIO->STA & SDIO_STA_CMDREND)
     4 U9 `  ~' w8 k  }
241.         {
     
242.                 SDIO->ICR = SDIO_ICR_CMDRENDC;
     
243.                 printf("Card selected! status=0x%08x\n", SDIO->RESP1);
     
244.         }
     
245.         
     2 g0 {. G8 a0 |+ @. `& Z# N
246.         // 提高时钟频率
     
247.         SDIO->CLKCR = (SDIO->CLKCR & ~SDIO_CLKCR_CLKDIV) | 70; // 72MHz/(70+2)=1MHz
     6 ^8 x0 }5 b4 }; g# K6 t  b
248.         SDIO->DTIMER = 1000000; // 当频率为1MHz时, 超时时间为1秒
     ) U  m% N: a  ?8 Q4 _8 n" Y4 C5 u
249.         //SDIO->CLKCR = (SDIO->CLKCR & ~SDIO_CLKCR_CLKDIV) | 1; // 72MHz/(1+2)=24MHz
     % U% n* ~, Q! r1 Q/ w) j" }% v
250.         
     * n; Q$ j1 d5 k. x( F
251.         /* 选择总线宽度 (Wide Bus Selection) */
     9 V, Y. K* l* A6 }) y+ k! c
252.         // For an SDIO card a write to the CCCR using CMD52 is used to select bus width. (See 4.5 Bus Width)
     
253.         // CMD52: IO_RW_DIRECT, CCCR: Card Common Control Registers
     
254.         WiFi_Write(0, 0x07, WiFi_Read(0, 0x07) | 0x02); // Bus Width: 4-bit bus
     
255.         SDIO->CLKCR |= SDIO_CLKCR_WIDBUS_0;
     
256.         
     
257.         // 初始化Function 1
     * ^: U6 |: B/ b+ E0 @! |9 B$ A
258.         WiFi_Write(0, 0x02, 0x02); // IOE1=1 (Enable Function)
     
259.         while ((WiFi_Read(0, 3) & 0x02) == 0); // 等到IOR1=1 (I/O Function Ready)
     6 W, p% q/ q8 M% |
260.         
     ' j7 O& T  e( v# \8 B  D/ w; D
261.         // 显示CIS信息
     0 E* v2 U9 U1 j+ R( t
262.         //WiFi_ShowCIS(0);
     + k- v+ T. A" G: h* L& u
263.         //WiFi_ShowCIS(1);
     + S& M* Z8 Q, {- U
264.         
     ! ]0 j' B6 h. e# g7 K9 k. a
265.         // 下载固件
     % y+ E7 i2 s! r6 X2 z# p
266.         WiFi_DownloadFirmware();
     . i* J# Y- [% y) u* ^4 c
267.         
     ( s$ P' R% T$ V; {5 o0 u* X
268.         // 设置数据块大小为256字节
     
269.         SDIO->DCTRL = SDIO_DCTRL_DBLOCKSIZE_3;
     # T3 [4 x; \5 u- l5 b, \
270.         WiFi_SetBlockSize(0);
     ' v8 y, K# K) [0 ?! b- P
271.         WiFi_SetBlockSize(1);
     2 |/ U+ W& l7 T0 f
272.         
     % J8 k3 a' @+ O' ~
273.         // 允许发送和接收
     
274.         // 不使用带有LLC子层的802.2SNAP帧格式, 这样LLC和SNAP这8个字节的内容就不会夹在数据链路层的源地址字段与数据字段之间
     
275.         WiFi_MACControl(WIFI_MACCTRL_ETHERNET2 | WIFI_MACCTRL_TX | WIFI_MACCTRL_RX);
     
276. }
     
277. 
     ) B" w( F/ F' o, M8 P
278. /* 获取或设置密钥 */
     
279. uint16_t WiFi_KeyMaterial(MrvlIETypes_KeyParamSet_t *keys, uint16_t size, uint8_t action)
     
280. {
     " t6 B6 R- F* z" k" f$ a
281.         uint8_t buffer[256];
     ' X6 l6 l4 D' o* U7 ?9 {5 |0 q* _
282.         uint8_t ret_size;
     ! F! `( o: d# I" L0 I, o6 Z+ V
283.         WiFi_Cmd_KeyMaterial *cmd = (WiFi_Cmd_KeyMaterial *)buffer;
     
284.         cmd->action = action;
     7 _, m& o1 J  i8 A
285.         if (action == WIFI_ACT_SET)
     - h7 x$ V- }( x
286.         {
     3 P* d4 p# |" y& O3 w) s
287.                 memcpy(cmd + 1, keys, size);
     ( t5 U3 N* V6 l: K! k% [
288.                 WiFi_SendCommand(CMD_802_11_KEY_MATERIAL, buffer, sizeof(WiFi_Cmd_KeyMaterial) + size);
     , A5 z* `" ^0 q& k9 o) b8 R9 T
289.         }
     # L8 ^- J, R, H; c0 y, O
290.         else
     
291.                 WiFi_SendCommand(CMD_802_11_KEY_MATERIAL, buffer, sizeof(WiFi_Cmd_KeyMaterial));
     
292.         WiFi_ReceiveResponse(buffer, sizeof(buffer));
     
293.         
     5 s5 X) A( ~" Y2 Y
294.         if (action == WIFI_ACT_GET)
     
295.         {
     + r8 C, x3 [% P  }% n- e- c" o
296.                 ret_size = cmd->header.size - sizeof(cmd->header) - sizeof(cmd->action);
     2 f* Q5 N) n: A4 \' @
297.                 if (ret_size <= size)
     ! i9 E1 \# e* q  o* q6 G1 S
298.                         memcpy(keys, cmd + 1, ret_size);
     + Z: m" W2 R& B) b7 v# J
299.                 else
     
300.                         printf("WiFi_KeyMaterial: Buffer size is too small! %d bytes required!\n", ret_size);
     
301.                 return ret_size; // action=get时返回读取的数据大小
     ( z1 p5 l5 b. ]9 f( L1 N4 N, ?
302.         }
     
303.         else
     $ _* _; k! ~0 s: I6 {! E
304.                 return cmd->header.result; // action=set时返回命令执行结果值
     # r, }" S; r2 n+ _! E
305. }
     
306. 
     - p! \* w& k. ?7 ]$ B7 J! k! d
307. /* 获取或设置MAC地址 */
     
308. void WiFi_MACAddr(uint8_t addr[6], uint8_t action)
     
309. {
     / r; S/ L  T4 v
310.         WiFi_Cmd_MACAddr cmd;
     
311.         cmd.action = action;
     " O% P! l$ X, Q% Q, ~/ O" t5 z
312.         if (action == WIFI_ACT_SET)
     $ b1 u! S/ ^4 D( a
313.                 memcpy(cmd.mac_addr, addr, 6);
     
314.         
     
315.         WiFi_SendCommand(CMD_802_11_MAC_ADDR, &cmd, sizeof(cmd));
     
316.         WiFi_ReceiveResponse(&cmd, sizeof(cmd));
     9 U9 [2 T' O2 b7 e7 w7 i
317.         if (action == WIFI_ACT_GET)
     & q! u8 U# P9 r$ Z6 M! c5 L
318.                 memcpy(addr, cmd.mac_addr, 6);
     
319. }
     ! K. Q9 Y" Q3 S+ i3 l
320. 
     5 o/ \$ ]% C) `4 D8 a% m! c* a9 X% h
321. /* 配置MAC */
     
322. void WiFi_MACControl(uint16_t action)
     / j" J5 D# E7 r! x! P# m8 E1 I
323. {
     
324.         WiFi_Cmd_MACCtrl cmd;
     
325.         cmd.action = action;
     ) q* H+ f' J! |3 e9 W+ ]" q, O
326.         cmd.reserved = 0;
     
327.         WiFi_SendCommand(CMD_MAC_CONTROL, &cmd, sizeof(cmd));
     " s- c& @' N& W7 T) E
328.         WiFi_ReceiveResponse(&cmd, sizeof(cmd));
     
329. }
     
330. 
     & {1 o, |% ~' R
331. /* 获取滞留的数据包大小 */
     # {7 \" y: \! y% i/ }
332. uint16_t WiFi_PacketPending(void)
     
333. {
     
334.         return wifi_pending_size;
     : P) X, |4 a" o) c
335. }
     
336. 
     7 N2 {) x6 C5 A' v/ y6 `! x) T
337. /* 准备好超时计时器 */
     
338. void WiFi_PrepareTimer(uint16_t nms)
     5 {- j7 t2 Q' B5 N& Z
339. {
     # W' j1 K* X. Y7 c! g* S; v+ z
340.         TIM6->ARR = 10 * nms - 1;
     
341.         TIM6->PSC = 7199; // 72MHz/7200=10kHz
     - R3 X4 }: x# [) {
342.         TIM6->EGR = TIM_EGR_UG; // 保存设置
     
343.         TIM6->SR &= ~TIM_SR_UIF; // 清除溢出标志位
     
344.         TIM6->CR1 = TIM_CR1_OPM | TIM_CR1_CEN; // 开始计时, 模式为非循环模式
     ) H) Y1 X2 W# u: L" I. J/ m
345. }
     
346. 
     , ^3 o/ D5 G/ U" \" J% j6 u
347. /* 读寄存器 */
     + Q( P. S7 G& ^5 G3 j, l
348. uint8_t WiFi_Read(uint8_t func, uint32_t addr)
     
349. {
     
350.         WiFi_SendCMD52(func, addr, NULL, NULL);
     / D/ x: r8 W5 S' z* q& I$ @
351.         if (SDIO->STA & SDIO_STA_CMDREND)
     
352.         {
     . Q0 L) ]! T( y, _$ w7 L- Y+ w
353.                 SDIO->ICR = SDIO_ICR_CMDRENDC;
     
354.                 return SDIO->RESP1 & 0xff;
     
355.         }
     0 W) H2 H/ T; c  b+ R. v
356.         else
     9 ~- |3 B- q* o1 E; Q9 b% N& r8 ~
357.         {
     
358.                 printf("WiFi_Read failed, SDIO->STA=0x%08x!\n", SDIO->STA);
     
359.                 return 0;
     * k5 U+ H& q) p7 x4 x3 Y- h7 c
360.         }
     ' [6 b# k3 w) b5 m
361. }
     / ^& y& {4 J+ C/ R  o7 J
362. 
     $ l4 w2 b+ {/ I. @) n. K% M
363. /* 读数据 */
     
364. // count为要发送的字节数或块数, bufsize为data缓冲区的大小
     
365. // bufsize=0时, 只读取数据不存入缓冲区
     
366. void WiFi_ReadData(uint8_t func, uint32_t addr, uint8_t *data, uint16_t count, uint16_t bufsize, uint32_t flags)
     
367. {
     ( A& u; Y8 u. i3 R* I! s7 h
368.         uint32_t len, temp;
     
369.         if (flags & CMD53_BLOCKMODE)
     
370.         {
     
371.                 len = count * WiFi_GetBlockSize(); // count表示数据块数
     
372.                 SDIO->DCTRL &= ~SDIO_DCTRL_DTMODE; // Block模式
     0 Q& J: Z% p! R9 s/ G, K& s
373.         }
     5 D9 r6 m9 I& B4 F
374.         else
     / c* H5 w7 |$ V# J. j8 c
375.         {
     
376.                 len = count; // count表示字节数
     
377.                 if (len % 4 != 0)
     " g, @9 W+ D" R# Q' u6 @2 W
378.                 {
     ( x# V8 c  _8 u8 Y/ A
379.                         len += 4 - len % 4; // WiFi模块要求写入的字节数必须为4的整数倍
     / \  g' X) ?: y5 r/ X; C
380.                         count = len;
     
381.                 }
     
382.                 SDIO->DCTRL |= SDIO_DCTRL_DTMODE; // Multibyte模式
     
383.         }
     
384.         SDIO->DLEN = len;
     ( K+ l3 b& I! h+ H6 l3 {, j9 c) _
385.         SDIO->DCTRL |= SDIO_DCTRL_DTDIR | SDIO_DCTRL_DTEN; // 设置传输方向为从模块到主机
     
386.         
     
387.         WiFi_SendCMD53(func, addr, count, flags);
     + U' U) m; A: d9 t% S* m
388.         while (len)
     7 T2 t2 p% E! m% E7 r2 x/ U
389.         {
     6 p' S( u' i8 n
390.                 if (SDIO->STA & SDIO_STA_RXDAVL)
     , e8 }+ o6 P/ ?  s; `
391.                 {
     - W# a3 A. p0 _% S+ m8 M3 @8 `: n( S
392.                         // 若有数据到来就读取数据
     
393.                         len -= 4;
     + l% P% F2 K+ ^: J* l. T" u
394.                         if (bufsize >= 4)
     ; k- e7 R) T9 ?5 Q: ?# x+ p
395.                         {
     
396.                                 *(uint32_t *)data = SDIO->FIFO;
     ) j1 u7 j1 V" o
397.                                 data += 4;
     
398.                         }
     
399.                         else
     / t9 C9 U% K; c
400.                         {
     4 _8 I7 O, G5 j5 w6 k* {1 y7 O
401.                                 temp = SDIO->FIFO;
     
402.                                 if (bufsize > 0)
     
403.                                 {
     6 p. K: a0 P9 }% `# @  b9 T& b! m, o3 d
404.                                         // 写入缓冲区最后1~3字节
     $ Z. f2 T: m2 j
405.                                         memcpy(data, &temp, bufsize);
     
406.                                         bufsize = 0;
     
407.                                 }
     5 V1 p+ X, L$ l  Z' O9 n& T
408.                         }
     
409.                 }
     
410.                
     
411.                 if (SDIO->STA & SDIO_STA_DTIMEOUT)
     
412.                 {
     6 A9 u0 R& z6 ~) W( L" L8 ^; i: h
413.                         printf("Data Timeout!\n");
     : @+ g9 u) [3 _( w/ m
414.                         break;
     0 l, C0 U; a2 ]
415.                 }
     
416.                 else if (SDIO->STA & SDIO_STA_DCRCFAIL)
     2 Z# Q5 O) p9 h6 [7 d' Z' i
417.                 {
     
418.                         printf("Data CRC check failed! %d bytes are lost\n", len);
     0 _$ |: I$ h3 j# _
419.                         break;
     
420.                 }
     8 t( L; x$ k; @* b) o
421.         }
     
422.         
     
423.         while (SDIO->STA & (SDIO_STA_CMDACT | SDIO_STA_RXACT));
     - G6 {5 N- _2 m# W+ w  e) _( a
424.         SDIO->DCTRL &= ~SDIO_DCTRL_DTEN;
     
425.         
     3 B# w9 r8 T" p
426.         SDIO->ICR = SDIO_STA_DATAEND | SDIO_ICR_CMDRENDC;
     - j' o- N: u, {5 W7 Q& ~4 d8 G
427.         if (flags & CMD53_BLOCKMODE)
     + v! H  P9 c* ~; v; M( t( }
428.                 SDIO->ICR = SDIO_ICR_DBCKENDC;
     + x  I2 {- p( I, Z0 ?. z
429.         
     & ?" n  j: ?6 @* V' C. m3 j8 A
430.         // 通过判断SDIO->STA是否等于0可知传输是否成功
     7 u6 g) `% C% {$ d3 \+ r+ y
431. }
     ( z" R. p; N, a% s3 F& h. _
432. 
     1 F3 j! N, i5 ~- _2 m% i0 J2 e& k2 ^) B' [
433. uint16_t WiFi_ReadPort(void *buf, uint16_t size, uint16_t bufsize)
     - W9 [7 x& L0 A& _
434. {
     
435.         uint16_t block_num, block_size;
     
436.         block_size = WiFi_GetBlockSize();
     
437.         
     
438.         // 读取数据
     + M4 v$ R5 h9 |" R0 k. Y
439.         WiFi_Wait(0); // 发送CMD53前必须IOReady=1
     
440.         if (size >= 512 || size % block_size == 0)
     
441.         {
     
442.                 // 采用Block模式传输
     0 `9 G+ L. ]  p
443.                 block_num = size / block_size;
     9 }) M% h7 Z, Z4 }4 _8 y" \' i
444.                 if (size % block_size != 0)
     & g3 R/ h  g. a+ s7 n% V& e7 T
445.                         block_num++;
     2 \# W. f- n0 S6 P
446.                
     
447.                 WiFi_ReadData(1, io_addr, buf, block_num, bufsize, CMD53_BLOCKMODE);
     5 S8 s! r; d: C, Q  t1 f! t
448.         }
     : A2 j( r; |( ?0 R4 c1 _) m9 u
449.         else
     , `& \  j& M/ B6 u6 @0 {7 v& a1 S* L$ j
450.                 WiFi_ReadData(1, io_addr, buf, size, bufsize, 0);
     9 s- B, I* K# y+ o! I
451.         
     6 f- G5 \& Z9 k& G+ J0 [
452.         return SDIO->STA == 0;
     
453. }
     : k( ]. a4 l3 `
454. 
     % k9 {4 @* R/ ?3 V4 K) }, L$ D
455. /* 接收数据帧 */
     . x, Z: A6 K* p- G: i
456. uint16_t WiFi_ReceivePacket(void *buf, uint16_t bufsize)
     
457. {
     
458.         uint16_t size;
     
459.         if (wifi_pending_size)
     
460.         {
     
461.                 size = wifi_pending_size; // 先读取滞留的数据包
     
462.                 wifi_pending_size = 0;
     7 Z) S, Q* I; K4 K1 p' K' g' W% {
463.         }
     0 T; E& S: l$ T/ u$ y
464.         else
     
465.                 size = WiFi_GetPacketLength();
     
466.         return WiFi_ReadPort(buf, size, bufsize);
     
467. }
     3 g$ U0 M# k( g- o
468. 
     ( u0 s7 k& H2 }6 Z9 j* B
469. /* 接收WiFi命令的回应 */
     
470. uint16_t WiFi_ReceiveResponse(void *buf, uint16_t bufsize)
     - r. g& C3 L1 L" r& p
471. {
     ) \9 @( J% y7 k7 ?6 X8 g8 i
472.         uint8_t retry_cnt = 0; // 重试次数
     & V. \; G! S# U2 m. d: S. X
473.         uint8_t wait_status, resend;
     
474.         uint16_t size;
     
475.         WiFi_CommandHeader *cmd = (WiFi_CommandHeader *)buf;
     
476.         WiFi_SDIOFrameHeader temp;
     
477.         
     3 w: T1 \. x; r  Z5 f" U
478.         // 等待数据准备好
     
479.         do
     ! l( y# d& h4 e& K1 K* Y  u6 Y
480.         {
     
481.                 wait_status = WiFi_Wait(WIFI_CARDSTATUS_UPLDCARDRDY);
     % G3 j9 c) n* e* r) {1 ^
482.                
     9 f( U) u2 V: q+ U7 n
483.                 WiFi_ReadPort(&temp, sizeof(temp), sizeof(temp)); // 试着读取头部信息
     
484.                 if (temp.type == WIFI_SDIOFRAME_DATA && temp.length > 0) // 若读取到一个数据帧的头部
     2 k9 l# _" \9 d' p# K/ c8 ^. G' K
485.                 {
     / T6 l5 V7 J+ O0 q* ~/ H* N" ?
486.                         // 若读到的是一个数据帧, 不是命令回应
     ; ^' C4 T" ^, d3 c8 Z
487.                         // 则直接丢掉该数据帧, 然后重发命令, 保证命令执行成功
     ( g7 z( y9 V/ A
488.                         printf("A packet of %d byte(s) preempted the command!\n", temp.length);
     
489.                         wifi_pending_size = temp.length;
     
490.                         WiFi_DropPacket(); // 必须读取完整个数据包, 只读完头部不算
     
491.                         resend = 1;
     2 W  K& }5 `8 `6 e1 A
492.                 }
     0 m. e# I6 k; o& ~( A0 ?! y9 ~
493.                 else if (wait_status == 0)
     1 U4 I4 f* Q* `+ [
494.                 {
     
495.                         // 若WiFi_Wait返回0, 则说明超时 (状态位在规定的时间内未置位)
     
496.                         resend = 1;
     2 \+ u0 i& |( b$ X3 k3 N* }8 s; [
497.                         retry_cnt++;
     
498.                         if (retry_cnt >= 5)
     
499.                         {
     " `$ |' l. f$ C: W& Y8 |
500.                                 printf("No response!\n");
     
501.                                 return 0;
     + n0 w9 R) o( {$ w/ R0 V
502.                         }
     
503.                 }
     
504.                 else
     % [# J2 U. ]- z7 V. M
505.                         resend = 0;
     4 o5 N3 K! h) R$ c. j
506.                
     
507.                 if (resend)
     % M! X1 ?" K2 n( l0 j
508.                 {
     
509.                         if (cmd->frame_header.type == WIFI_SDIOFRAME_COMMAND)
     
510.                         {
     ; O7 U/ n; P8 @( v) u) l
511.                                 // 若超时后还没收到数据, 则重发命令, 然后再次执行WiFi_Wait
     
512.                                 printf("Resend WiFi command 0x%04x! size=%d\n", cmd->cmd_code, cmd->frame_header.length);
     
513.                                 WiFi_ResendCommand(buf);
     ; q. W  W5 R1 ~) H5 m. z
514.                         }
     
515.                         else
     $ m% Q1 P5 r+ l( |: B$ O) H
516.                                 return 0; // 若buf中的内容不是命令, 则直接退出
     
517.                 }
     
518.         } while (resend);
     
519.         
     " H, h, d, L+ b  L. k
520.         size = WiFi_GetPacketLength();
     
521.         if (size > bufsize)
     
522.                 printf("WiFi_ReceiveResponse: Buffer size is too small! %d bytes required!\n", size);
     
523.         return WiFi_ReadPort(buf, size, bufsize);
     : {, C1 e; ^% A, k
524. }
     * `$ _. t( v2 ]2 W  Z4 u0 p
525. 
     , y0 {- \) T" O5 W0 l
526. /* 扫描全部热点 (仅显示) */
     7 P5 H& S1 S: E- m5 ?
527. void WiFi_Scan(void)
     ( A, o7 t! \, y
528. {
     : a4 N6 ~* y8 N
529.         // 必须把STM32启动文件*.s中的Stack_Size改大, 否则函数中无法创建大数组
     
530.         // Stack_Size=0x00000c00
     2 c5 V* f, L- S$ @6 Q. X$ ]
531.         uint8_t buffer[2048]; // 用于接收返回的WiFi接入点信息, 需要较大的内存空间来存放
     . c* Z5 n1 f2 ^. Y) N- n# e
532.         uint8_t i, j, n;
     ' _( t8 a. k- K; i% S, G
533.         uint8_t ssid[33], channel, wpa;
     3 t# t& {7 y1 ^2 P, S
534.         uint16_t ie_size;
     ' @( e3 H3 j- H  g, I. K2 D
535.         
     
536.         WiFi_CmdRequest_Scan *cmd = (WiFi_CmdRequest_Scan *)buffer; // 用buffer空间来存放要发送的命令
     ( V- y8 T  s- Y  f4 q
537.         MrvlIETypes_ChanListParamSet_t *chanlist = (MrvlIETypes_ChanListParamSet_t *)(buffer + sizeof(WiFi_CmdRequest_Scan));
     
538.         
     
539.         WiFi_CmdResponse_Scan *resp = (WiFi_CmdResponse_Scan *)buffer;
     
540.         WiFi_BssDescSet *bss_desc_set;
     
541.         WiFi_VendorHeader *vendor;
     
542.         IEEEType *ie_params;
     
543.         //MrvlIETypes_TsfTimestamp_t *tft_table;
     ) w: b; E) o7 x" ]0 W: U  H& R7 `
544.         
     
545.         // 分4次扫描14个通道
     
546.         for (i = 0; i < 4; i++)
     3 m" G2 v+ J* u6 O
547.         {
     / y0 K" e4 p! k' M# r' ]
548.                 cmd->bss_type = BSS_ANY;
     0 Y6 z0 a4 W  [  v; \3 q
549.                 memset(cmd->bss_id, 0, sizeof(cmd->bss_id));
     % G, o$ X$ h6 g. h- Z
550.                
     
551.                 // 通道的基本参数
     
552.                 n = (i == 3) ? 2 : 4; // 本次要扫描的通道数
     
553.                 chanlist->header.type = MRVLIETYPES_CHANLISTPARAMSET;
     
554.                 chanlist->header.length = n * sizeof(chanlist->channels);
     
555.                 for (j = 0; j < n; j++)
     2 d* h$ C  e  R7 |: W
556.                 {
     
557.                         chanlist->channels[j].band_config_type = 0;
     
558.                         chanlist->channels[j].chan_number = 4 * i + j + 1; // 通道号
     
559.                         chanlist->channels[j].scan_type = 0;
     
560.                         chanlist->channels[j].min_scan_time = 0;
     3 \/ p! z* L" P6 k
561.                         chanlist->channels[j].max_scan_time = 100;
     
562.                 }
     
563.                
     
564.                 // 发送命令并接收数据
     $ X% u4 C; p/ K7 A! @
565.                 WiFi_SendCommand(CMD_802_11_SCAN, buffer, sizeof(WiFi_CmdRequest_Scan) + sizeof(chanlist->header) + chanlist->header.length);
     ( e3 R# w) l/ f7 Y; c( w
566.                 WiFi_ReceiveResponse(buffer, sizeof(buffer)); // 接收的数据会将cmd和chanlist中的内容覆盖掉
     / v0 \# m( _8 X! W4 ]
567.                
     
568.                 // 显示热点信息, num_of_set为热点数
     
569.                 if (resp->num_of_set > 0)
     4 G2 c0 T+ _' s  Y
570.                 {
     
571.                         bss_desc_set = (WiFi_BssDescSet *)(buffer + sizeof(WiFi_CmdResponse_Scan));
     # N2 G+ y, q6 x* ?9 T
572.                         for (j = 0; j < resp->num_of_set; j++)
     
573.                         {
     2 o& F" K. g$ v- x
574.                                 wpa = 0;
     : i1 h6 K2 k% `2 Y" S0 D; u
575.                                 ie_params = &bss_desc_set->ie_parameters;
     & R+ u9 Q! B* @, O# n
576.                                 ie_size = bss_desc_set->ie_length - (sizeof(WiFi_BssDescSet) - sizeof(bss_desc_set->ie_length) - sizeof(bss_desc_set->ie_parameters));
     
577.                                 while (ie_size > 0)
     
578.                                 {
     7 I/ A6 B" X- E6 K2 N
579.                                         switch (ie_params->type)
     
580.                                         {
     $ b/ ~" ?& F6 b, N& }) \
581.                                         case MRVLIETYPES_SSIDPARAMSET:
     
582.                                                 // SSID名称
     9 K. b5 C& ^: }. P$ F
583.                                                 memcpy(ssid, ie_params->data, ie_params->length);
     
584.                                                 ssid[ie_params->length] = '\0';
     
585.                                                 break;
     " i, c" L4 @. J7 v7 ^
586.                                         case MRVLIETYPES_DSPARAMSET:
     
587.                                                 // 通道号
     $ Z9 H. \! c& a) u5 S; n
588.                                                 channel = ie_params->data[0];
     
589.                                                 break;
     
590.                                         case MRVLIETYPES_RSNPARAMSET:
     ; [6 ?9 X! s( T; m3 A; }' R, Y
591.                                                 wpa = 2;
     
592.                                                 break;
     8 B/ L2 a! Y5 c! V# Z, C' f% f
593.                                         case MRVLIETYPES_VENDORPARAMSET:
       X1 }& f" `- s  E) g# V
594.                                                 if (wpa == 0)
     
595.                                                 {
     
596.                                                         vendor = (WiFi_VendorHeader *)ie_params->data;
     
597.                                                         if (vendor->oui[0] == 0x00 && vendor->oui[1] == 0x50 && vendor->oui[2] == 0xf2 && vendor->oui_type == 0x01)
     + a/ X$ l. d4 T4 r, T$ ^
598.                                                                 wpa = 1;
     + `% x! m4 |" V
599.                                                 }
     
600.                                                 break;
     5 i3 z1 O* ^& Z% s3 v! J' I
601.                                         }
     ( ], d4 W) O5 O$ S, }
602.                                         ie_size -= ie_params->length + 2;
     
603.                                         ie_params = (IEEEType *)((uint8_t *)ie_params + ie_params->length + 2);
     2 q8 R% f, z' g% N8 S* A( H; c: {1 Z
604.                                 }
     2 S  J: c" Y; a: P0 \
605.                                 if (ie_size != 0)
     
606.                                         printf("ie_parameters error!\n");
     
607.                                 
     + ^/ b& g' J5 L* ~3 J
608.                                 printf("SSID '%s', ", ssid); // 热点名称
     . V7 D2 D% [" R# w
609.                                 printf("MAC %02X:%02X:%02X:%02X:%02X:%02X, ", bss_desc_set->bssid[0], bss_desc_set->bssid[1], bss_desc_set->bssid[2], bss_desc_set->bssid[3], bss_desc_set->bssid[4], bss_desc_set->bssid[5]); // MAC地址
     
610.                                 printf("RSSI %d, Channel %d\n", bss_desc_set->rssi, channel); // 信号强度和通道号
     4 v; k/ U! T7 M
611.                                 //printf("  Timestamp %lld, Beacon interval %d\n", bss_desc_set->pkt_time_stamp, bss_desc_set->bcn_interval);
     
612.                                 
     0 ?* K8 W% x& \
613.                                 printf("  Capability: 0x%04x", bss_desc_set->cap_info);
     
614.                                 if (bss_desc_set->cap_info & WIFI_CAPABILITY_PRIVACY)
     
615.                                 {
     8 J0 V  B! V6 p' E, `5 t
616.                                         if (wpa == 1)
     
617.                                                 printf("(WPA: ON, ");
     
618.                                         else if (wpa == 2)
     ( e: d0 f0 y2 X3 i- ]! x
619.                                                 printf("(WPA2: ON, ");
     
620.                                         else
     1 S4 n( @/ |, F5 _% ?3 T% L- m7 m( c
621.                                                 printf("(WEP: ON, ");
     8 C$ A! M( E& W/ ?! X) @2 o1 j& h
622.                                 }
     / ]5 A: n: _% B' C
623.                                 else
     
624.                                         printf("(WEP: OFF, ");
     
625.                                 
     
626.                                 if (bss_desc_set->cap_info & WIFI_CAPABILITY_IBSS)
     
627.                                         printf("mode: Ad-Hoc)\n");
     $ I* K" r, T2 T& I4 E9 S5 e
628.                                 else
     
629.                                         printf("mode: Infrastructure)\n");
     
630.                                 
     ( R2 Q+ @7 x. H' ^6 o
631.                                 // 转向下一个热点信息
     
632.                                 bss_desc_set = (WiFi_BssDescSet *)((uint8_t *)bss_desc_set + sizeof(bss_desc_set->ie_length) + bss_desc_set->ie_length);
     
633.                         }
     1 U2 Q, {! T1 F" @
634.                         
     1 [2 n4 `" x* F8 P7 g
635.                         // resp->buf_size就是bss_desc_set的总大小
     
636.                         // 因此tft_table == buffer + sizeof(WiFi_CmdResponse_Scan) + resp->buf_size
     ; k' d$ y9 p# }
637.                         /*tft_table = (MrvlIETypes_TsfTimestamp_t *)bss_desc_set;
     
638.                         if (tft_table->header.type == MRVLIETYPES_TSFTIMESTAMP && tft_table->header.length == resp->num_of_set * sizeof(uint64_t))
     
639.                         {
     2 z3 s4 n+ p, G& `' {
640.                                 printf("Timestamps: ");
     
641.                                 for (j = 0; j < resp->num_of_set; j++)
     
642.                                         printf("%lld ", tft_table->tsf_table[j]);
     
643.                                 printf("\n");
     ) x# N8 T4 n! R
644.                         }*/
     / Y$ j0 z% Q3 `2 p
645.                         
     
646.                         // TSF timestamp table是整个数据的末尾, 后面没有Channel/band table
     
647.                         //if (((uint8_t *)tft_table - buffer) + sizeof(tft_table->header) + resp->num_of_set * sizeof(uint64_t) == cmd->header.frame_header.length)
     
648.                         //        printf("data end!\n");
     
649.                 }
     6 \% a2 ~$ l/ F( Y
650.         }
     5 t4 @' I3 T+ h" ~
651. }
     
652. 
     
653. /* 扫描指定名称的热点 */
     . ~- n* r3 g% o3 `/ J# C) {
654. // buffer用来存放返回的全部结果, 因此bufsize应该足够大
     : C1 a8 ~' R) H& i% K
655. // info用来存放从buffer中提取出来的一些常用信息
     
656. uint8_t WiFi_ScanSSID(const char *ssid, WiFi_SSIDInfo *info, uint8_t *buffer, uint16_t bufsize)
     
657. {
     
658.         uint8_t i;
     ) P) z5 X* M( Z) M2 M) `
659.         uint16_t ie_size;
     9 n! g% `, C8 q  a; b5 ~
660.         WiFi_CmdRequest_Scan *cmd = (WiFi_CmdRequest_Scan *)buffer;
     7 v/ {8 {4 n9 R( ]7 y1 I5 j
661.         WiFi_CmdResponse_Scan *resp = (WiFi_CmdResponse_Scan *)buffer;
     
662.         WiFi_BssDescSet *bss_desc_set = (WiFi_BssDescSet *)(resp + 1);
     
663.         MrvlIETypes_ChanListParamSet_t *chan_list;
     - p2 g5 Q) ~  q; h+ y& I6 S
664.         IEEEType *ie_params;
     
665.         WiFi_VendorHeader *vendor;
     1 r1 \& g3 o' e6 l; r
666.         
     
667.         cmd->bss_type = BSS_ANY;
     
668.         memset(cmd->bss_id, 0, sizeof(cmd->bss_id));
     
669.         
     $ {; S. R* q' ~2 ~. R4 e
670.         // 添加ssid参数
     
671.         info->ssid.header.type = MRVLIETYPES_SSIDPARAMSET;
     
672.         info->ssid.header.length = strlen(ssid);
     
673.         memcpy(info->ssid.ssid, ssid, info->ssid.header.length);
     
674.         memcpy(cmd + 1, &info->ssid, MRVLIE_STRUCTLEN(info->ssid));
     0 ?* Q5 {! K, D/ h
675.         
     
676.         chan_list = (MrvlIETypes_ChanListParamSet_t *)((uint8_t *)(cmd + 1) + MRVLIE_STRUCTLEN(info->ssid));
     7 T1 ~6 E6 d! G
677.         chan_list->header.type = MRVLIETYPES_CHANLISTPARAMSET;
     
678.         chan_list->header.length = 14 * sizeof(chan_list->channels); // 一次性扫描14个通道
     7 x" C$ g+ W! x* z9 f* l! `
679.         for (i = 0; i < 14; i++)
     
680.         {
     
681.                 chan_list->channels[i].band_config_type = 0;
     # c' G) }4 w& q+ k
682.                 chan_list->channels[i].chan_number = i + 1;
     % J; Q6 u  p  x" R6 u: t0 ?
683.                 chan_list->channels[i].scan_type = 0;
     
684.                 chan_list->channels[i].min_scan_time = 0;
     8 A0 {* z; Q7 P2 l, l. r
685.                 chan_list->channels[i].max_scan_time = 100;
     / U3 V6 `+ K* N: ~% F
686.         }
     
687.         
     8 O# Y1 I7 |) D( c4 N: x# ?. g
688.         WiFi_SendCommand(CMD_802_11_SCAN, buffer, ((uint8_t *)chan_list - buffer) + MRVLIE_STRUCTLEN(*chan_list));
     
689.         wifi_timeout = 3000; // 延长超时时间
     ! m! {& {( ^& t+ z8 U5 E
690.         WiFi_ReceiveResponse(buffer, bufsize);
     2 v8 t6 d6 a2 f* \9 p" r. A
691.         wifi_timeout = WIFI_DEFAULTTIMEOUT;
     # a. `, m; H% r  Y1 C- ~3 K4 [
692.         
     5 y2 k  s* E0 `: v- P4 K
693.         if (resp->num_of_set == 0)
     
694.                 return 0; // 失败
     : Q( m# R2 Q: z) v  I
695.         
     
696.         // bss_desc_set以扫描到的第一个信息项为准
     
697.         memcpy(info->mac_addr, bss_desc_set->bssid, sizeof(info->mac_addr));
     
698.         info->cap_info = bss_desc_set->cap_info;
     
699.         info->bcn_period = bss_desc_set->bcn_interval;
     
700.         
     & Y4 Y2 A/ h  ~6 D
701.         // 若type=0, 则表明没有该项的信息 (除SSID结构体外, 因为SSID的type=MRVLIETYPES_SSIDPARAMSET=0)
     
702.         info->rates.header.type = 0;
     ' w4 l; T2 x* k7 y& a. n9 @. v. [5 |
703.         info->rsn.header.type = 0;
     
704.         info->wpa.header.type = 0;
     ) n# X4 ~6 ]9 X; [# B
705.         info->wwm.header.type = 0;
     5 b4 p+ t$ L' U! r+ D8 }3 M  U
706.         info->wps.header.type = 0;
     2 R" s2 o* }4 t5 F2 Z& Y# J# ~
707.         
     # p5 z9 c2 E' m
708.         ie_params = &bss_desc_set->ie_parameters;
     7 K  v4 K/ t# h3 n# \
709.         ie_size = bss_desc_set->ie_length - (sizeof(WiFi_BssDescSet) - sizeof(bss_desc_set->ie_length) - sizeof(bss_desc_set->ie_parameters));
     - p/ B) G2 `6 q
710.         while (ie_size > 0)
     1 ^( q$ w8 u4 J2 Y* e' X; |
711.         {
     
712.                 switch (ie_params->type)
     4 h2 F$ B; m' Z5 L# R' u* p
713.                 {
     
714.                 case MRVLIETYPES_RATESPARAMSET:
     
715.                         // 速率
     7 @+ s! E7 p0 T* e; F
716.                         info->rates.header.type = MRVLIETYPES_RATESPARAMSET;
     
717.                         info->rates.header.length = ie_params->length;
     
718.                         if (info->rates.header.length > sizeof(info->rates.rates))
     
719.                                 info->rates.header.length = sizeof(info->rates.rates);
     
720.                         memcpy(info->rates.rates, ie_params->data, ie_params->length);
     
721.                         break;
     
722.                 case MRVLIETYPES_DSPARAMSET:
     + B: z- `- F  G7 P1 P
723.                         // 通道号
     
724.                         info->channel = ie_params->data[0];
     % b# x/ m; H4 ^5 q: Y
725.                         break;
     
726.                 case MRVLIETYPES_RSNPARAMSET:
     6 w1 q; K1 G- n, R3 j3 @
727.                         // 通常只有一个RSN信息 (与WPA2相关)
     4 l) H5 ~# @# i0 I' Y" w- W
728.                         // printf("RSN len=%d\n", ie_params->length);
     7 |' s2 h3 }# t7 C6 Z
729.                         info->rsn.header.type = MRVLIETYPES_RSNPARAMSET;
     ! `+ @8 K! V( c: ~# W
730.                         info->rsn.header.length = ie_params->length;
     
731.                         if (info->rsn.header.length > sizeof(info->rsn.rsn))
     
732.                                 info->rsn.header.length = sizeof(info->rsn.rsn);
     
733.                         memcpy(info->rsn.rsn, ie_params->data, info->rsn.header.length);
     
734.                         break;
     $ m5 M$ [% t- A, g. g
735.                 case MRVLIETYPES_VENDORPARAMSET:
     4 H/ K$ T* H1 F+ [
736.                         // 通常会有多项VENDOR信息 (与WPA相关)
     
737.                         vendor = (WiFi_VendorHeader *)ie_params->data;
     
738.                         if (vendor->oui[0] == 0x00 && vendor->oui[1] == 0x50 && vendor->oui[2] == 0xf2)
     ) C- W; r+ W9 q" m- c, ^  T$ M
739.                         {
     3 C- t$ a' r7 M( W  q" p3 B
740.                                 switch (vendor->oui_type)
     / |) Q5 H/ H$ R1 m6 J. f) y
741.                                 {
     
742.                                 case 0x01:
     0 O) r1 T5 ^, O, k
743.                                         // wpa_oui
     & y! b6 B- a) g" M8 J& n% K
744.                                         info->wpa.header.type = MRVLIETYPES_VENDORPARAMSET;
     ' b! u1 F9 X: w9 {
745.                                         info->wpa.header.length = ie_params->length;
     7 n$ @$ `" x. f8 r0 o7 y; g& i) v
746.                                         if (info->wpa.header.length > sizeof(info->wpa.vendor))
     
747.                                                 info->wpa.header.length = sizeof(info->wpa.vendor);
     . h3 F" [4 B* R6 Z$ w- M& N
748.                                         memcpy(info->wpa.vendor, ie_params->data, info->wpa.header.length);
     ! @+ s7 K( J0 z3 l+ b! w$ k# r: `
749.                                         break;
     
750.                                 case 0x02:
     4 I2 V$ X* X7 j' X! ~/ u
751.                                         // wmm_oui
     
752.                                         if (ie_params->length == 24) // 合法大小
     7 ^* [% U' F& g( x* @2 x( ^
753.                                         {
     ' ^6 O* }  q# c' {4 D/ q8 Y2 }
754.                                                 info->wwm.header.type = MRVLIETYPES_VENDORPARAMSET;
     0 L0 h( b- M6 X$ j$ A: z
755.                                                 info->wwm.header.length = ie_params->length;
     / Z; h8 J0 g9 o: _% q$ |- M% a
756.                                                 memcpy(info->wwm.vendor, ie_params->data, ie_params->length);
     9 u) s: G! r- y1 a; {1 r# r7 {
757.                                         }
     
758.                                         break;
     # V: Z0 b3 _' k0 U. h9 y  l( \
759.                                 case 0x04:
     
760.                                         // wps_oui
     # ~$ s! d* n1 U( c1 F
761.                                         info->wps.header.type = MRVLIETYPES_VENDORPARAMSET;
     
762.                                         info->wps.header.length = ie_params->length;
     % B: [2 d* Y" M& g/ ]+ g
763.                                         if (info->wps.header.length > sizeof(info->wps.vendor))
     ' v* {' F% l+ u
764.                                                 info->wps.header.length = sizeof(info->wps.vendor);
     . U  L3 B' [1 `8 A+ @1 F
765.                                         memcpy(info->wps.vendor, ie_params->data, info->wps.header.length);
     ! H, c# A+ p! f# H2 t9 c9 r7 N7 N
766.                                         break;
     / {* a' d6 j: h+ u7 f+ H! L
767.                                 }
     
768.                         }
     1 ?" C. D+ L( C
769.                         break;
     
770.                 }
     
771.                 ie_size -= ie_params->length + 2;
     4 |" Z6 l# Z1 Z
772.                 ie_params = (IEEEType *)((uint8_t *)ie_params + ie_params->length + 2);
     6 ?/ X9 B" z1 L8 u9 Q  f9 o, h+ |
773.         }
     
774.         
     ! C' l1 C' `6 s
775.         return 1; // 成功
     
776. }
     
777. 
     
778. void WiFi_SendCMD52(uint8_t func, uint32_t addr, uint8_t data, uint32_t flags)
     
779. {
     
780.         SDIO->ARG = (func << 28) | (addr << 9) | data | flags;
     6 `* p7 e! K; K2 v" f0 J4 h
781.         SDIO->CMD = SDIO_CMD_CPSMEN | SDIO_CMD_WAITRESP_0 | 52;
     
782.         while (SDIO->STA & SDIO_STA_CMDACT);
     # `3 Y$ c% F- l5 X6 B7 Z' w: ]
783. }
     
784. 
     , h- J; Q+ j/ Z. H: c9 |
785. void WiFi_SendCMD53(uint8_t func, uint32_t addr, uint16_t count, uint32_t flags)
     4 {# N+ Y" N/ u6 [+ R
786. {
     
787.         // 当count=512时, 和0x1ff相与后为0, 符合要求
     ( b, q; E7 d% \) K& x1 F
788.         SDIO->ARG = (func << 28) | (addr << 9) | (count & 0x1ff) | flags;
     - N2 Z, \) Z; r! {
789.         SDIO->CMD = SDIO_CMD_CPSMEN | SDIO_CMD_WAITRESP_0 | 53;
     
790. }
     3 ?+ a% w! g+ C3 c- f
791. 
     8 Y7 z, v1 V) v7 |: v  I7 P
792. /* 发送WiFi命令 */
     
793. void WiFi_SendCommand(uint16_t com_code, void *data, uint16_t size)
     
794. {
     
795.         static uint16_t seq_num = 0;
     " {& N5 R' r% w& _& ~& p
796.         WiFi_CommandHeader *cmdhdr = (WiFi_CommandHeader *)data;
     
797.         
     
798.         if (size != 0)
     & L  b6 K, }& t/ F* c
799.         {
     
800.                 cmdhdr->frame_header.length = size;
     
801.                 cmdhdr->frame_header.type = WIFI_SDIOFRAME_COMMAND;
     + K$ I$ i  q$ G- x* A6 B
802.                 cmdhdr->cmd_code = com_code;
     5 O4 t2 Y" n& I: w) j% s, `3 W
803.                 cmdhdr->size = size - sizeof(WiFi_SDIOFrameHeader); // 命令大小包括命令头部, 但不包括SDIO帧头部
     2 X1 ?) h& ~# ]1 a' P
804.                 cmdhdr->seq_num = seq_num++;
     ) b; p- W$ N6 z* D
805.                 cmdhdr->result = 0;
     
806.         }
     % [+ t0 ?' k3 @! L# \- l: H$ p8 R
807.         else
     
808.                 size = cmdhdr->frame_header.length; // 重发命令时不填写cmdhdr
     ) K5 H* t% c  `0 ~7 ~
809.         
     
810.         // 发送命令前若恰好有数据帧到来, 则直接丢弃
     1 X0 V0 B0 v& F4 `. W
811.         if (WiFi_PacketPending() || WiFi_PacketArrived())
     & M' {7 |$ h/ D
812.         {
     
813.                 printf("A new packet happends to arrive when sending command! Drop it!\n");
     - S0 ?2 {! K6 g* B8 g  X
814.                 WiFi_DropPacket();
     
815.         }
     
816.         
     2 H& o9 ~( ?& x  t; o& T% \0 C
817.         WiFi_WritePort(data, size);
     
818. }
     
819. 
     
820. /* 发送数据帧 */
     2 i) C+ l0 d! u3 O
821. uint8_t WiFi_SendPacket(WiFi_DataTx *packet, uint16_t packet_len)
     ' e. m4 P8 G- p, q5 ~8 L- J& V9 B
822. {
     1 v' h  R7 }, O* Z) S
823.         uint8_t ret;
     
824.         
     3 S6 U6 ?+ J1 B0 i1 w+ X# P
825.         // 有关发送数据包的细节, 请参考Firmware Specification PDF的Chapter 3: Data Path
     
826.         packet->header.length = sizeof(WiFi_DataTx) - sizeof(packet->payload) + packet_len;
     5 I& b. h, L  a2 B" P! _
827.         packet->header.type = WIFI_SDIOFRAME_DATA;
     
828.         
     ) w+ w) C( }' t; ]+ u
829.         packet->reserved1 = 0;
     " h4 m6 s; D! o
830.         packet->tx_control = 0; // 控制信息的格式请参考3.2.1 Per-Packet Settings
     
831.         packet->tx_packet_offset = sizeof(WiFi_DataTx) - sizeof(packet->payload) - sizeof(packet->header); // 不包括SDIOFrameHeader
     
832.         packet->tx_packet_length = packet_len;
     0 `; c2 Z$ R1 e0 i
833.         memcpy((void *)&packet->tx_dest_addr_high, packet->payload, 6);
     " g. O6 e* z! ?4 {; [
834.         packet->priority = 0;
     2 G3 T' j: d$ |- x9 K, g  g
835.         packet->flags = 0;
     
836.         packet->pkt_delay_2ms = 0;
     
837.         packet->reserved2 = 0;
     ! q7 }* i) a" N: x
838.         
     & g) l( B6 t1 E) G6 N8 q( }+ _
839.         // 若现在有新收到的数据帧, 则暂存数据包大小
     
840.         // 未读取之前不会收到新的数据帧
     0 c" `( B7 c' _8 J
841.         if (WiFi_PacketArrived())
     
842.                 wifi_pending_size = WiFi_GetPacketLength();
     8 ?2 \; ~  w# s3 ^  v/ C  L7 I2 r
843.         
     1 B6 I+ {; j) d" U6 V& u
844.         ret = WiFi_WritePort(packet, packet->header.length);
     6 c* `8 x) w/ L% \2 v
845.         WiFi_Wait(WIFI_CARDSTATUS_DNLDCARDRDY); // WiFi模块收到数据后, 会将该位置1
     ' {* ?  g8 Z& d
846.         return ret;
     : ?2 z- P7 D  c+ U
847. }
     ' ~% i- M9 j9 }- }
848. 
     ; \/ L+ d' Z( n; c
849. /* 将SDIO->DCTRL中的块大小信息应用到WiFi模块指定的功能区上 */
     
850. void WiFi_SetBlockSize(uint8_t func)
     
851. {
     
852.         // Part E1: 6.9 Card Common Control Registers (CCCR), 6.10 Function Basic Registers (FBR)
     / t/ D0 T( t& j6 j
853.         uint16_t size = WiFi_GetBlockSize();
     " M+ j' y' X& V2 K
854.         WiFi_Write(0, (func << 8) | 0x10, size & 0xff);
     ) i5 K4 T4 h+ v( C# B; m: w
855.         WiFi_Write(0, (func << 8) | 0x11, size >> 8);
     
856. }
     
857. 
     
858. /* 设置密钥 */
     
859. uint8_t WiFi_SetKeyMaterial(uint16_t type, uint16_t info, const uint8_t *key, uint16_t len)
     - p) W: w3 j* J' f: h& I8 @
860. {
     
861.         MrvlIETypes_KeyParamSet_t key_param;
     6 z4 p7 Y: {  t8 q7 l, H
862.         if (len > sizeof(key_param.key))
     # O- h; \8 U$ W' B) {1 S, ]8 R
863.                 return CMD_STATUS_ERROR;
     % {& r3 |1 T1 E7 \5 [1 b
864.         key_param.header.type = MRVLIETYPES_KEYPARAMSET;
     
865.         key_param.header.length = (key_param.key - (uint8_t *)&key_param) - sizeof(key_param.header) + len;
     : E" Z% ~% Q, R4 B, V/ O4 S( e
866.         key_param.key_type_id = type;
     
867.         key_param.key_info = info;
     
868.         key_param.key_len = len; // 当len=0时可保留key的值, 只更新key_info
     # C; `8 _; g. B
869.         if (len)
     
870.                 memcpy(key_param.key, key, len);
     
871.         return WiFi_KeyMaterial(&key_param, MRVLIE_STRUCTLEN(key_param), WIFI_ACT_SET);
     ( c7 J, v1 ?6 o% t3 u5 ?: o" T6 q
872. }
     
873. 
     : m. j, y) b* z; j" f
874. /* 显示WiFi模块信息 */
     
875. void WiFi_ShowCIS(uint8_t func)
     
876. {
     3 w5 Q( T% Q) z* h
877.         uint8_t data[255];
     
878.         uint8_t i, len;
     : C" Y7 {! L% j; Y9 m
879.         uint8_t tpl_code, tpl_link; // 16.2 Basic Tuple Format and Tuple Chain Structure
     
880.         uint32_t cis_ptr;
     ! v9 W4 u* _* t
881.         
     
882.         // 获取CIS的地址
     & h8 E' x. _3 S& V, N& G
883.         cis_ptr = (func << 8) | 0x9;
     2 j. w8 i* B; o: O$ g
884.         cis_ptr        = WiFi_Read(0, cis_ptr) | (WiFi_Read(0, cis_ptr + 1) << 8) | (WiFi_Read(0, cis_ptr + 2) << 16);
     . \8 @2 t: ?% ^, H% W
885.         printf("Pointer to Function %d Card Information Structure (CIS): 0x%08x\n", func, cis_ptr);
     ) z$ A) B" Y( {3 U7 b2 x: I
886.         
     * L) i3 h9 j# h  u
887.         // 遍历CIS, 直到尾节点
     ) ~: O# K8 I- m- n; s
888.         while ((tpl_code = WiFi_Read(0, cis_ptr++)) != CISTPL_END)
     
889.         {
     
890.                 if (tpl_code == CISTPL_NULL)
     2 ]" r- V8 G$ S7 D, S5 L$ `; |
891.                         continue;
     ) I+ w+ s0 H" m" l" U( G, q1 f
892.                
     3 w; A) e* T0 k+ Z: p) E5 n/ K2 }* b
893.                 tpl_link = WiFi_Read(0, cis_ptr++); // 本结点数据的大小
     
894.                 for (i = 0; i < tpl_link; i++)
     
895.                         data[i] = WiFi_Read(0, cis_ptr + i);
     9 U) R/ x$ w" x! `$ _) o
896.                
     7 p: K/ H; m5 h0 W. k  c$ M* V
897.                 printf("[CIS Tuple 0x%02x] addr=0x%08x size=%d\n", tpl_code, cis_ptr - 2, tpl_link);
     
898.                 dump_data(data, tpl_link);
     
899.                 switch (tpl_code)
     " E7 i: O* n, _8 T( I/ w
900.                 {
     
901.                 case CISTPL_VERS_1:
     / x0 e5 N& H) x, m. Z5 X
902.                         i = 2;
     
903.                         while (data[i] != 0xff)
     
904.                         {
     
905.                                 len = strlen((char *)&data[i]);
       Z' p! }+ `  M/ |: T8 X  l$ Y9 J
906.                                 if (len != 0)
     
907.                                         printf("%s\n", data + i);
     " T* d* P' u2 a
908.                                 i += len + 1;
     
909.                         }
     % Z" H- Y6 j5 v+ Z1 M( B; m
910.                         break;
     
911.                 case CISTPL_MANFID:
     
912.                         // 16.6 CISTPL_MANFID: Manufacturer Identification String Tuple
     
913.                         printf("SDIO Card manufacturer code: 0x%04x\n", *(uint16_t *)data); // TPLMID_MANF
     
914.                         printf("manufacturer information (Part Number and/or Revision): 0x%04x\n", *(uint16_t *)(data + 2)); // TPLMID_CARD
     
915.                         break;
     
916.                 case CISTPL_FUNCID:
     4 X# q! S, z- N) D' z+ V
917.                         // 16.7.1 CISTPL_FUNCID: Function Identification Tuple
     
918.                         printf("Card function code: 0x%02x\n", data[0]); // TPLFID_FUNCTION
     5 T0 k2 I1 E7 s, f+ B
919.                         printf("System initialization bit mask: 0x%02x\n", data[1]); // TPLFID_SYSINIT
     
920.                         break;
     
921.                 case CISTPL_FUNCE:
     ' ]6 V3 r' c3 ~8 w4 t# x( o
922.                         // 16.7.2 CISTPL_FUNCE: Function Extension Tuple
     
923.                         if (data[0] == 0)
     5 |5 F0 i/ Z8 }) K- p3 E- I2 ~
924.                         {
     
925.                                 // 16.7.3 CISTPL_FUNCE Tuple for Function 0 (Extended Data 00h)
     3 d1 r& v/ C( o9 c5 V
926.                                 printf("maximum block size: %d\n", *(uint16_t *)(data + 1));
     2 I) O$ ^4 y$ i+ {* w( H' ^) N7 Y
927.                                 printf("maximum transfer rate code: 0x%02x\n", data[3]);
     # j, n/ ^+ B( v; q$ C$ r
928.                         }
     
929.                         else
     % v- P! H; Y7 x, y$ Y/ n) ]
930.                         {
     ( H0 b) t0 l- h" D5 b
931.                                 // 16.7.4 CISTPL_FUNCE Tuple for Function 1-7 (Extended Data 01h)
     
932.                                 printf("maximum block size: %d\n", *(uint16_t *)(data + 0x0c)); // TPLFE_MAX_BLK_SIZE
     
933.                         }
     3 w: }  q( \: b0 e: g2 V. e
934.                 }
     
935.                
     
936.                 cis_ptr += tpl_link;
     5 r# I: C5 ]' n' N) M  U% {% U1 U
937.                 if (tpl_link == 0xff)
     $ z+ K" y. \! x6 c4 B4 l) ~4 P6 m0 S0 ^
938.                         break; // 当TPL_LINK为0xff时说明当前结点为尾节点
     
939.         }
     ( ~' q  v, c9 C' @; f! C
940. }
     
941. 
     2 W5 U, H+ X1 `7 M# |9 z" q6 o5 a
942. /* 显示所有密钥 */
     ) j% S4 o# P8 R6 N7 }' U
943. void WiFi_ShowKeyMaterials(void)
     
944. {
     3 i1 z3 I- }$ Z2 y! T" ?5 K
945.         uint8_t buffer[256];
     
946.         uint16_t size;
     
947.         MrvlIETypes_KeyParamSet_t *key = (MrvlIETypes_KeyParamSet_t *)buffer;
     
948.         
     : j8 U* H) _& f1 v! h
949.         size = WiFi_KeyMaterial(key, sizeof(buffer), WIFI_ACT_GET);
     
950.         while (size)
     ( X2 K7 `9 y6 u2 n( {/ @# @
951.         {
     " r% C% \' c: V/ S+ F# T7 u
952.                 printf("Type %d, Info 0x%04x, Len %d\n", key->key_type_id, key->key_info, key->key_len);
     
953.                 dump_data(key->key, key->key_len);
     
954.                 size -= MRVLIE_STRUCTLEN(*key);
     
955.                 key = (MrvlIETypes_KeyParamSet_t *)((uint8_t *)key + MRVLIE_STRUCTLEN(*key));
     
956.         }
     
957.         if (size == 0)
     
958.                 printf("data end!\n");
     " @# x# G) c5 B/ X1 K* e
959. }
     " N6 c" z2 R3 m# F" r4 Q* M
960. 
     " @6 S# T9 ?5 T" [! p: f. M' e
961. /* 创建一个Ad-Hoc型的WiFi热点 */
     ) T) F; M! p9 |# ]- X3 J2 d
962. uint8_t WiFi_StartADHOC(const char *ssid)
     * W5 S% Q% Q: i, q1 o. b
963. {
     2 J6 r9 Z  M  [3 t
964.         WiFi_CmdRequest_ADHOCStart cmd;
     
965.         memset(&cmd, 0, sizeof(cmd)); // 由于命令中含有Reserved区域, 所以必须先清零
     5 }8 N2 O$ }% W( C- a2 l
966.         
     
967.         strncpy((char *)cmd.ssid, ssid, sizeof(cmd.ssid));
     
968.         cmd.bss_type = BSS_INDEPENDENT;
     
969.         cmd.bcn_period = 100;
     
970.         cmd.ibss_param_set.header.type = MRVLIETYPES_IBSSPARAMSET;
     4 M2 K- E1 |7 Y- M1 Q: n# v
971.         cmd.ibss_param_set.header.length = MRVLIE_PAYLOADLEN(cmd.ibss_param_set);
     
972.         cmd.ibss_param_set.atim_window = 0;
     
973.         cmd.ds_param_set.header.type = MRVLIETYPES_DSPARAMSET;
     + I5 C1 `2 Z  n  D( M8 B& h
974.         cmd.ds_param_set.header.length = MRVLIE_PAYLOADLEN(cmd.ds_param_set);
     
975.         cmd.ds_param_set.channel = 1;
     
976.         cmd.cap_info = WIFI_CAPABILITY_IBSS/* | WIFI_CAPABILITY_PRIVACY*/;
     
977.         *(uint32_t *)cmd.data_rate = 0x968b8482;
     
978.         
     
979.         WiFi_SendCommand(CMD_802_11_AD_HOC_START, &cmd, sizeof(cmd));
     
980.         WiFi_ReceiveResponse(&cmd, sizeof(cmd));
     5 @) q4 S- P" v: r" y9 P( D6 @
981.         return cmd.header.result;
     " c  b! [, Z5 G; b6 r
982. }
     
983. 
     / w8 G. j. a1 Y7 G- V
984. /* 在规定的超时时间内, 等待指定的卡状态位置位(自动包括IO Ready位), 若成功则返回1 */
     / R$ }6 S+ g2 m( {
985. uint8_t WiFi_Wait(uint8_t status)
     
986. {
     
987.         status |= WIFI_CARDSTATUS_IOREADY;
     # e4 O& p; L7 A  y! T/ c
988.         WiFi_PrepareTimer(wifi_timeout);
     
989.         while ((WiFi_Read(1, WIFI_CARDSTATUS) & status) != status)
     0 P1 d! J$ V0 J9 ]( X
990.         {
     
991.                 if (TIM6->SR & TIM_SR_UIF)
     
992.                 {
     ! e! m5 i! T& G8 Q0 c' M
993.                         // 若超时时间已到
     ! l& V' b- z7 `5 n) q1 {. s
994.                         TIM6->SR &= ~TIM_SR_UIF;
     
995.                         printf("WiFi_Wait(0x%02x): timeout!\n", status);
     
996.                         return 0;
     2 M# T6 J3 a/ r, M
997.                 }
     / U* y$ ^; `( v4 R6 j! x3 D& w! f1 w
998.         }
     
999.         TIM6->CR1 &=~ TIM_CR1_CEN; // 关闭定时器
     
1000.         return 1;
      7 y* P9 N1 c9 _' C+ o4 ^
1001. }
      1 [$ \- t  [# f& q! O6 S8 v2 K
1002. 
      ; O3 p$ Z, P. r
1003. /* 写寄存器, 返回写入后寄存器的实际内容 */
      # D8 a0 L4 E1 l- c+ k7 B
1004. uint8_t WiFi_Write(uint8_t func, uint32_t addr, uint8_t value)
      
1005. {
      
1006.         WiFi_SendCMD52(func, addr, value, CMD52_WRITE | CMD52_READAFTERWRITE);
      
1007.         if (SDIO->STA & SDIO_STA_CMDREND)
      
1008.         {
      2 B: Z- Y7 V$ _6 h. O4 o
1009.                 SDIO->ICR = SDIO_ICR_CMDRENDC;
      
1010.                 return SDIO->RESP1 & 0xff;
      1 S+ y5 T$ j2 \" ]  p% @5 h
1011.         }
      ! q% V1 O$ I1 P; @0 x& ?
1012.         else
      
1013.         {
      
1014.                 printf("WiFi_Write failed, SDIO->STA=0x%08x!\n", SDIO->STA);
      
1015.                 return 0;
      
1016.         }
      - A: K1 Q# r' x, r5 P2 J& n
1017. }
      " Q6 O" x- b6 h. a. f* q6 J/ H$ y
1018. 
      
1019. /* 写数据 */
      
1020. // count为要发送的字节数或块数, bufsize为data缓冲区的大小
      ; Y+ n  c. O+ T& ^% n( s( _
1021. void WiFi_WriteData(uint8_t func, uint32_t addr, const uint8_t *data, uint16_t count, uint16_t bufsize, uint32_t flags)
      1 Q2 u! [! B+ q) }+ I
1022. {
      
1023.         uint32_t len, temp;
      
1024.         if (flags & CMD53_BLOCKMODE)
      9 P& H0 l3 v3 E7 }
1025.         {
        w- M  d, b( T4 y+ i& E5 c: w
1026.                 len = count * WiFi_GetBlockSize();
      
1027.                 SDIO->DCTRL &= ~SDIO_DCTRL_DTMODE;
      
1028.         }
      
1029.         else
      : X% |- K! d* Z/ w. o9 v, j: |9 I9 e
1030.         {
      & n( C% }3 y9 N  j: R5 |$ M: d
1031.                 len = count;
      
1032.                 if (len % 4 != 0)
      ; W% o, x" y2 U& m4 O
1033.                 {
      ! r/ u. c3 t) H* B
1034.                         len += 4 - len % 4; // WiFi模块要求写入的字节数必须为4的整数倍
      1 _5 N6 W! W7 ~  S
1035.                         count = len;
      $ Z6 |+ X% c& C& ~0 R3 _
1036.                 }
      - r+ f% [" v8 V
1037.                 SDIO->DCTRL |= SDIO_DCTRL_DTMODE;
      # N- w: \, L3 ~, O$ S
1038.         }
      
1039.         SDIO->DLEN = len;
      
1040.         SDIO->DCTRL &= ~SDIO_DCTRL_DTDIR; // 设置传输方向: 从主机到模块
      ! H; o% y7 r/ u& Y9 }
1041.         
      ; E+ h# f8 C& @* y
1042.         WiFi_SendCMD53(func, addr, count, flags | CMD53_WRITE);
      
1043.         while (SDIO->STA & SDIO_STA_CMDACT);
      , i5 Z6 y- W" r
1044.         if ((SDIO->STA & SDIO_STA_CMDREND) == 0)
      
1045.         {
      1 K- \5 r: T8 g; e4 Z) Z
1046.                 printf("WiFi_WriteData: CMD53 no response!\n");
      , d3 i. N  U3 |! N# R# w
1047.                 return;
      
1048.         }
      
1049.         SDIO->ICR = SDIO_ICR_CMDRENDC;
      
1050.         
      
1051.         SDIO->DCTRL |= SDIO_DCTRL_DTEN; // 开始发送数据
      ( A5 `5 a: I$ h& @) H
1052.         while (len)
      $ l0 l) f$ r3 Q3 d1 q" M$ s+ S8 w9 X
1053.         {
      
1054.                 len -= 4;
      ) R6 u+ J& z9 Q1 A
1055.                 if (bufsize >= 4)
      
1056.                 {
      
1057.                         SDIO->FIFO = *(uint32_t *)data;
      * e, N; v: _' Y& d9 P' r
1058.                         data += 4;
      0 ?" g: }8 p8 X5 q
1059.                         bufsize -= 4;
      
1060.                 }
      & g! T2 z. T- n- h0 `5 b
1061.                 else if (bufsize > 0)
      
1062.                 {
      
1063.                         // 发送缓冲区最后1~3字节
      . |; x  J1 I) \4 v
1064.                         temp = 0; // 不足的位用0填充
      ( f0 O& ]3 j4 \6 T9 j
1065.                         memcpy(&temp, data, bufsize);
      
1066.                         SDIO->FIFO = temp;
      1 A* I7 x7 z/ B9 F4 N9 o. d7 U! T4 J
1067.                         bufsize = 0;
      . C+ ]* {. f; a# u# K
1068.                 }
      
1069.                 else
      * P" M7 c& @0 Y/ C" d! L
1070.                         SDIO->FIFO = 0; // 缓冲区已用完, 因此发送0
      
1071.                 while (SDIO->STA & SDIO_STA_TXFIFOF); // 如果FIFO已满则等待
      % d/ Z0 f8 R. \" p
1072.         }
      2 E. ~9 H2 N, H0 Q9 h1 V5 r
1073.         
      
1074.         while (SDIO->STA & SDIO_STA_TXACT); // 等待发送完毕
      
1075.         SDIO->DCTRL &= ~SDIO_DCTRL_DTEN; // 数据传输完毕后DTEN应及时清零, 防止后续对DCTRL寄存器操作后误启动数据传输导致超时或CRC校验错误
      
1076.         
      2 e- F5 ]5 ?+ x2 @0 z
1077.         // 清除相关标志位
      6 T: j2 P1 W% O: r
1078.         SDIO->ICR = SDIO_ICR_DATAENDC;
      
1079.         if (flags & CMD53_BLOCKMODE)
      ! t0 \2 I, ^* \( E
1080.                 SDIO->ICR = SDIO_ICR_DBCKENDC;
      + [7 V; V- N& [# L- ]
1081. }
      2 b7 @  n7 d2 _: L: H* R( m1 M
1082. 
      
1083. uint8_t WiFi_WritePort(const void *data, uint16_t size)
      
1084. {
      $ M" ?7 o; X% I; B* d
1085.         uint16_t block_num, block_size;
      
1086.         block_size = WiFi_GetBlockSize();
      
1087.         
      
1088.         WiFi_Wait(0); // 发送CMD53前必须IOReady=1
      1 m1 Q. S7 F1 H  v  `5 ?- B
1089.         if (size >= 512 || size % block_size == 0)
      
1090.         {
      
1091.                 // 采用Block模式传输
      
1092.                 block_num = size / block_size;
      
1093.                 if (size % block_size != 0)
      
1094.                         block_num++;
      7 }  [8 j+ }) h  V
1095.                
      / W3 p8 ^# h5 O6 ^0 D% Y
1096.                 WiFi_WriteData(1, io_addr, data, block_num, size, CMD53_BLOCKMODE);
      0 M: u; K3 u: y, y+ A; T1 q
1097.         }
      4 G; |  W: ?% e6 l8 R
1098.         else
      ; }# }" [% K' u( x' z1 S
1099.                 WiFi_WriteData(1, io_addr, data, size, size, 0);
      
1100.         return SDIO->STA == 0;
      " l) P' y5 W' \! N7 ^! Z' g
1101. }
      

复制代码

& I* o# Q0 t' t" {在工程的所在文件夹创建一个lwip文件夹。
然后在lwip的官方网站下载lwip-2.0.2.zip，打开压缩包中的lwip-2.0.2/src文件夹，解压以下文件夹到工程的lwip目录下。

4 m/ a; Q; x& Z3 Y# W7 b1 p. i- @core/
core/ipv4
include/lwip
' _- Z0 H& c7 \0 F% h$ U" Q. kinclude/netif
netif/ethernet.c
0 C  N2 C3 Z' i- n( n4 P$ [netif/ethernetif.c
, m( y5 P. \; l8 @* ^
3 W3 u5 O. `/ p! b9 A解压后，将里面的c文件都添加到工程的lwip分组下。
具体添加的文件请看下图：

6 c, {$ D* O1 S' T5 V
接下来，创建lwip/include/arch/cc.h文件，内容如下：
" i% K) h* c: o3 T7 ]! S, K8 D7 q9 L

1.     #define PACK_STRUCT_BEGIN __packed // struct前的__packed  

复制代码

创建lwip/include/lwipopts.h文件，内容如下：
' f% W. B' i$ I- }1 B$ q  x

1.     #define NO_SYS 1 // 无操作系统  
     i! \; F1 v) j, E$ Y
2.       
   
3.     #define LWIP_NETCONN 0  
   
4.     #define LWIP_SOCKET 0  
   
5.     #define LWIP_STATS 0  
   
6.       
   
7.     #define MEM_ALIGNMENT 4 // STM32单片机是32位的单片机, 因此是4字节对齐的  
   ' P, U1 t+ C3 l8 s; |9 i8 r+ c
8.       
   $ O! X/ G' U2 J6 d1 C  }1 Z
9.     #define SYS_LIGHTWEIGHT_PROT 0 // 不进行临界区保护 (在中断中调用lwip函数时要小心)  

复制代码

打开lwip/netif/ethernetif.c文件，按照下面的中文提示修改代码：
5 Y5 H, g  V% V

1. /**
   # S1 O% r- f# V4 E' d
2. * @file
   
3. * Ethernet Interface Skeleton
   
4. *
   
5. */
   
6. 
   " L5 e: }& k2 u+ ^9 c: |$ q
7. /*
   1 S& X# I8 M5 G/ k# E
8. * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
   1 ?  g% j, j9 O2 P) I. z
9. * All rights reserved.
   " n5 r$ j: e% q5 e" p2 y
10. *
    ( S. f- h- o+ y" n: i3 H5 ~
11. * Redistribution and use in source and binary forms, with or without modification,
    ) v6 s" s# L1 Z# P+ f& ]7 X
12. * are permitted provided that the following conditions are met:
    
13. *
    
14. * 1. Redistributions of source code must retain the above copyright notice,
    " [5 N6 k& Y( b7 W
15. *    this list of conditions and the following disclaimer.
    * l% a# h0 o7 V1 w0 l, A: O
16. * 2. Redistributions in binary form must reproduce the above copyright notice,
    + Y/ u* B' @" F7 Y9 \: c1 S6 N  l
17. *    this list of conditions and the following disclaimer in the documentation
    
18. *    and/or other materials provided with the distribution.
    
19. * 3. The name of the author may not be used to endorse or promote products
    3 T8 H7 _& J- c+ Z1 i# X, A+ {
20. *    derived from this software without specific prior written permission.
    0 W4 J# l. ~3 i; m/ `& g$ @
21. *
    
22. * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
    ' {* X# H; W6 }) N8 g( C1 k4 \! t& k
23. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
    / B, y: ]. s; s: d2 `9 Q
24. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
    
25. * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
      @, ~* t- B7 B1 D# e! u# A3 [
26. * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
    
27. * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    3 b3 m% a7 S5 y' G
28. * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    
29. * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
    
30. * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
    
31. * OF SUCH DAMAGE.
    
32. *
    & a6 g3 o9 y! n2 d
33. * This file is part of the lwIP TCP/IP stack.
    & H2 [: Z$ T4 N# o1 s' s
34. *
    
35. * Author: Adam Dunkels <adam@sics.se>
    0 ^6 {% Y6 r) L' n9 j4 t
36. *
    
37. */
    8 ^  l( E3 g* H/ e
38. 
    4 W& L2 A) _2 n5 U4 F
39. /*
    
40. * This file is a skeleton for developing Ethernet network interface
    9 ^* M, I" l9 M+ b3 o
41. * drivers for lwIP. Add code to the low_level functions and do a
    ) ]6 I+ G/ f# q* W8 m4 n9 n
42. * search-and-replace for the word "ethernetif" to replace it with
    
43. * something that better describes your network interface.
    ! e' }7 g& h5 N* K
44. */
    " g/ D7 ]2 r, N1 D" X# @# g* B1 f
45. 
    2 o( p0 `& ]% g! h
46. #include "lwip/opt.h"
    . J) e* m! O+ C# [2 U
47. 
    
48. #if 1 // 允许编译器编译该文件
    
49. 
    % |4 p5 h  d  s8 ^% O5 _
50. #include "lwip/def.h"
    ! s! g( N; Y+ T  q3 s
51. #include "lwip/mem.h"
    
52. #include "lwip/pbuf.h"
    & s- H. ]0 d( F! D) s) ~0 b
53. #include "lwip/stats.h"
    $ M* J6 d6 r% D1 z9 C
54. #include "lwip/snmp.h"
    
55. #include "lwip/ethip6.h"
    
56. #include "lwip/etharp.h"
    + w3 _5 _" }0 ?7 Q/ G
57. #include "netif/ppp/pppoe.h"
    : Y+ |; S+ a% |4 U" X3 v' G+ q5 G
58. 
    
59. /* Define those to better describe your network interface. */
    ) i. }; f* l- g
60. #define IFNAME0 'e'
    . N% E/ N( C3 R* ]! t
61. #define IFNAME1 'n'
    
62. 
    + S! S) Z) t. `5 @' H! P. q
63. #include <string.h> // memcpy函数所在的头文件
    
64. #include "WiFi.h" // WiFi模块驱动程序头文件
    
65. 
    : N3 j- ?8 [% J' p& S, j' J
66. void dump_data(uint8_t *data, uint16_t len);
    
67. 
    ) C4 j8 U! J% F) ~( M
68. /**
    
69. * Helper struct to hold private data used to operate your ethernet interface.
    & f4 M1 [3 Q; Z/ l9 {" ]! ~
70. * Keeping the ethernet address of the MAC in this struct is not necessary
    
71. * as it is already kept in the struct netif.
    + N7 A! s6 h, ?0 E& k$ V% X
72. * But this is only an example, anyway...
    
73. */
    
74. struct ethernetif {
    1 }* I# {4 T. S* b' D8 U( p
75.   struct eth_addr *ethaddr;
    
76.   /* Add whatever per-interface state that is needed here. */
    
77. };
    
78. 
    % U+ N$ G' R4 I+ i0 \
79. /* Forward declarations. */
    
80. // 这里必须去掉static
    . e: e3 i- @* Z, `
81. /*static */void  ethernetif_input(struct netif *netif);
    ) t+ ]5 N/ N/ A! d- P- V' S9 V  n9 t+ o
82. 
    
83. /**
    $ i, [. b1 _% x$ g5 A+ u& Y
84. * In this function, the hardware should be initialized.
    4 r5 a' `. _' E. \/ M7 J% ~2 C
85. * Called from ethernetif_init().
    
86. *
    
87. * @param netif the already initialized lwip network interface structure
    
88. *        for this ethernetif
    + o# q- V; q0 ]( M' v5 r. t  h
89. */
    
90. static void
    
91. low_level_init(struct netif *netif)
    ; k7 x! C5 _( I$ U/ p4 N
92. {
    
93.   struct ethernetif *ethernetif = netif->state;
    5 z! ~( E9 l6 b1 i7 k
94. 
    2 M* ^  i0 o3 m
95.   /* set MAC hardware address length */
    3 x. \+ m& X2 P6 w( W0 j2 M, ~
96.   netif->hwaddr_len = ETHARP_HWADDR_LEN;
    " M/ ^# p6 \1 u8 `" n. X# [0 O
97. 
    
98.   /* set MAC hardware address */
    
99.   WiFi_GetMACAddr(netif->hwaddr); // 获取网卡的默认MAC地址
    ( l$ t) v5 ~% l  t8 O! o' V
100.   printf("MAC Addr: %02X:%02X:%02X:%02X:%02X:%02X\n", netif->hwaddr[0], netif->hwaddr[1], netif->hwaddr[2], netif->hwaddr[3], netif->hwaddr[4], netif->hwaddr[5]);
     & S5 d4 N7 r" H# ~& [8 Z
101. 
     
102.   /* maximum transfer unit */
     
103.   netif->mtu = 1500;
     # P$ R/ P3 H* P1 o# \
104. 
     
105.   /* device capabilities */
     
106.   /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
     
107.   netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
     
108. 
     
109. #if LWIP_IPV6 && LWIP_IPV6_MLD
     
110.   /*
     , J/ w5 ~( I, t/ ]+ ~# c* s
111.    * For hardware/netifs that implement MAC filtering.
     
112.    * All-nodes link-local is handled by default, so we must let the hardware know
     
113.    * to allow multicast packets in.
     
114.    * Should set mld_mac_filter previously. */
     
115.   if (netif->mld_mac_filter != NULL) {
     
116.     ip6_addr_t ip6_allnodes_ll;
     
117.     ip6_addr_set_allnodes_linklocal(&ip6_allnodes_ll);
     
118.     netif->mld_mac_filter(netif, &ip6_allnodes_ll, NETIF_ADD_MAC_FILTER);
     
119.   }
     ) k! z5 x* I) K/ N& e  Y" d
120. #endif /* LWIP_IPV6 && LWIP_IPV6_MLD */
     ; ]" s0 e2 d, k
121. 
     : b" K+ U/ l/ i9 ^$ b: `
122.   /* Do whatever else is needed to initialize interface. */
     
123. }
     
124. 
     
125. /**
     
126. * This function should do the actual transmission of the packet. The packet is
     % L5 s& M; M* z% ~! ~% f- m4 Z
127. * contained in the pbuf that is passed to the function. This pbuf
     7 ^8 R$ T: D& P( \6 ]
128. * might be chained.
     3 J- j) m7 s1 ~; B7 x4 _
129. *
     5 e4 G9 Y- c% v+ J8 K; T: j& d! w
130. * @param netif the lwip network interface structure for this ethernetif
     
131. * @param p the MAC packet to send (e.g. IP packet including MAC addresses and type)
     7 [* U) r% u8 J) }. a
132. * @return ERR_OK if the packet could be sent
     1 _# Q& x2 b2 y& X/ _& X5 v
133. *         an err_t value if the packet couldn't be sent
     . x$ c  q, j7 C" w: B7 w! i! z
134. *
     . C% P( e5 }& J. W) f
135. * @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to
     7 U* N9 H3 F" B, G, \) s
136. *       strange results. You might consider waiting for space in the DMA queue
     ' K3 W; h) X" F
137. *       to become available since the stack doesn't retry to send a packet
     
138. *       dropped because of memory failure (except for the TCP timers).
     
139. */
     , [2 F' a7 O, B6 o- k1 v! `( D
140. 
     
141. static err_t
     3 W8 Y" h) S6 V9 X
142. low_level_output(struct netif *netif, struct pbuf *p)
     ' \# n5 E' O: c7 U* `
143. {
     $ y' @; q6 {5 b0 C
144.   struct ethernetif *ethernetif = netif->state;
     
145.   struct pbuf *q;
     
146.         
     
147.   // 添加的变量
     . M: b8 B" c' V) L$ M; d
148.   uint8_t buffer[1792];
     
149.   WiFi_DataTx *packet = (WiFi_DataTx *)buffer;
     
150.   uint8_t *bufptr = packet->payload;
     8 O8 q+ E# F3 {
151. 
     
152.   //initiate transfer();
     $ c6 h/ l( V9 z/ ]0 X6 O
153. 
     
154. #if ETH_PAD_SIZE
     0 Z5 X8 X5 f# ]) G; B2 e( y, k9 g
155.   pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
     
156. #endif
     
157. 
     
158.   for (q = p; q != NULL; q = q->next) {
     
159.     /* Send the data from the pbuf to the interface, one pbuf at a
     : z! R  }4 ?) L; `) c2 ~, f
160.        time. The size of the data in each pbuf is kept in the ->len
     / S. C# Y5 n: S0 `9 }' Y; g2 d  k
161.        variable. */
     ( S6 E  `2 A% Y8 n5 j3 g
162.     //send data from(q->payload, q->len);
     - B$ v3 e4 i) ]) t% p
163.         memcpy(bufptr, q->payload, q->len); // 复制数据包内容
     + }' c9 T* ?9 f5 {  i
164.         bufptr += q->len; // 指针前移
     
165.   }
     + Y" I* U5 n4 d! \: x' |! e2 X5 v
166. 
     9 N& F# `  Z+ _4 t7 P4 `2 H
167.   //signal that packet should be sent();
     , K( m0 h4 i8 \; X  m7 m+ L
168.   WiFi_SendPacket(packet, bufptr - packet->payload); // 发送数据包
     
169.   
     8 o8 [4 h; c6 q' c$ ^6 {, C
170.   // 打印数据包内容
     
171.   printf("[Send] size=%d\n", packet->tx_packet_length);
     5 I- a* J; x$ ?! N" y! F
172.   dump_data(packet->payload, packet->tx_packet_length);
     
173. 
     5 k2 |8 |# x$ J0 L/ k
174.   MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p->tot_len);
     
175.   if (((u8_t*)p->payload)[0] & 1) {
     
176.     /* broadcast or multicast packet*/
     ! w, H& e: ^/ c4 r. P
177.     MIB2_STATS_NETIF_INC(netif, ifoutnucastpkts);
     ! u+ y# s+ x# g; ]: |- B- F+ x% u
178.   } else {
     
179.     /* unicast packet */
     1 q, }; H2 Q3 H% l. c2 `6 K, e
180.     MIB2_STATS_NETIF_INC(netif, ifoutucastpkts);
     & `8 x2 b$ W: b3 U0 m/ `
181.   }
     
182.   /* increase ifoutdiscards or ifouterrors on error */
     ' U. l4 b4 v1 T& f
183. 
     ' n8 z9 a: ^/ r% K6 x2 O& _; v
184. #if ETH_PAD_SIZE
     5 N3 X, b# ?+ D
185.   pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
     , E2 _/ B, F! n) N% ?
186. #endif
     ' Q4 @1 M. K/ c* u* L
187. 
     
188.   LINK_STATS_INC(link.xmit);
     
189. 
     
190.   return ERR_OK;
     
191. }
     
192. 
     
193. /**
     
194. * Should allocate a pbuf and transfer the bytes of the incoming
     0 m) y( _, `  M9 _& n
195. * packet from the interface into the pbuf.
     
196. *
     ! S8 C6 x7 V* R+ K8 u) s& E) k
197. * @param netif the lwip network interface structure for this ethernetif
     
198. * @return a pbuf filled with the received packet (including MAC header)
     
199. *         NULL on memory error
     + f- V& t( x5 R0 G9 Z  s. Z* q: H8 Z9 \
200. */
     4 r8 O: y- |( `- M  `! f# x+ x$ o
201. static struct pbuf *
     ! g! R# A1 L8 ~) J0 X
202. low_level_input(struct netif *netif)
     8 B2 P' W8 g9 i3 P8 m' T* L; k
203. {
     
204.   struct ethernetif *ethernetif = netif->state;
     
205.   struct pbuf *p, *q;
     
206.   u16_t len;
     5 ~5 J$ l& S9 V0 K
207.         
     
208.   // 添加的变量
     
209.   uint8_t buffer[1792]; // 由于WiFi模块本身不支持使用多个CMD53命令读取数据包, 所以必须建立一个缓冲区, 一次性读取完
     
210.   WiFi_DataRx *packet = (WiFi_DataRx *)buffer;
     3 u2 w) O: Z+ t4 Q0 }5 r3 R) |
211.   uint8_t *bufptr = packet->payload;
     : J& h9 J* |1 x" h2 [5 d# B
212. 
     
213.   /* Obtain the size of the packet and put it into the "len"
     ; y: e4 `( }  G* A& M) y; r8 T
214.      variable. */
     # @2 H# @5 ?! H
215.   len = WiFi_ReceivePacket(buffer, sizeof(buffer)); // 读取整个数据包, 返回值包含头部大小
     1 C2 A6 f, s# W; V) |6 x
216.   if (len == 0)
     0 a2 Z  L6 F1 o  B( G
217.   {
     
218.           // 若读取失败, 则不分配pbuf, 退出本函数
     
219.           p = NULL;
     
220.           goto after_alloc;
     
221.   }
       r+ v  S" }$ l* P+ o# E5 t
222.   len = packet->rx_packet_length; // 获取数据包的大小
     
223.         
     5 g( L3 |, k6 i- D- r6 m9 P
224.   // 打印数据包内容
     . u2 G0 r$ ?2 p5 n/ B! ^# \6 a
225.   printf("[Recv] size=%d\n", len);
     
226.   dump_data(packet->payload, len);
     
227. 
     
228. #if ETH_PAD_SIZE
     ) f! Q: P/ F: B
229.   len += ETH_PAD_SIZE; /* allow room for Ethernet padding */
     
230. #endif
     
231. 
     
232.   /* We allocate a pbuf chain of pbufs from the pool. */
     & ?/ E1 Z. g* N9 ~
233.   p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
     
234.   
     ' E& j: v$ V) q! U. F/ r# I
235. after_alloc: // 添加此标记
     % w; Q. H1 U, M2 R: q% ^4 V8 i: m( J
236. 
     
237.   if (p != NULL) {
     
238. 
     9 C9 f4 g- j  B' @/ h
239. #if ETH_PAD_SIZE
     
240.     pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
     
241. #endif
     * e+ ~* L; t2 |7 V% y( v3 C
242. 
     
243.     /* We iterate over the pbuf chain until we have read the entire
     
244.      * packet into the pbuf. */
     
245.     for (q = p; q != NULL; q = q->next) {
     7 q, }1 r, `; ~) _8 O) ?
246.       /* Read enough bytes to fill this pbuf in the chain. The
     - k% Y+ J" s8 I1 |7 u, E
247.        * available data in the pbuf is given by the q->len
     
248.        * variable.
     % A0 U" D. t& w8 l9 f
249.        * This does not necessarily have to be a memcpy, you can also preallocate
     8 `) I8 v5 K( P$ T4 t) b# m  w
250.        * pbufs for a DMA-enabled MAC and after receiving truncate it to the
     - C4 s. p$ ^7 ]  L  c1 r. q" R/ \
251.        * actually received size. In this case, ensure the tot_len member of the
     
252.        * pbuf is the sum of the chained pbuf len members.
     ' S6 E0 m1 V2 ~! w# d
253.        */
     
254.       //read data into(q->payload, q->len);
     , P2 }5 x7 ?; Q0 P9 U# Z. B
255.                 memcpy(q->payload, bufptr, q->len); // 复制数据包内容
     9 U+ l; ?4 I& _! p8 L0 F6 m
256.                 bufptr += q->len; // 指针前移
     2 W" `9 |; L! x: m0 K$ b
257.     }
     
258.     //acknowledge that packet has been read(); // 无需确认
     ' ~$ o) M, z2 K+ V# H
259. 
     
260.     MIB2_STATS_NETIF_ADD(netif, ifinoctets, p->tot_len);
     4 z& @. a1 E+ L
261.     if (((u8_t*)p->payload)[0] & 1) {
     
262.       /* broadcast or multicast packet*/
     $ _, x; }2 J7 r8 [
263.       MIB2_STATS_NETIF_INC(netif, ifinnucastpkts);
     
264.     } else {
     ; x4 j0 |! }' E0 e4 V3 t5 _
265.       /* unicast packet*/
     3 p* b6 u( {1 N7 o, R- T# c9 i
266.       MIB2_STATS_NETIF_INC(netif, ifinucastpkts);
     
267.     }
     ! L# l) B* L9 X
268. #if ETH_PAD_SIZE
     
269.     pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
     
270. #endif
     / O" W, C" D3 x
271. 
     " l/ d0 L9 i. y0 i" P. {$ M2 T4 u
272.     LINK_STATS_INC(link.recv);
     % [5 \+ h2 k% S' E! V
273.   } else {
     
274.     //drop packet(); // 注释掉此行
     $ U; m: f5 _, E) O% y" i6 S& C
275.     LINK_STATS_INC(link.memerr);
     4 B8 L7 U0 C6 c8 z
276.     LINK_STATS_INC(link.drop);
     0 B$ ?! W( o% r  ]
277.     MIB2_STATS_NETIF_INC(netif, ifindiscards);
     
278.   }
     
279. 
     
280.   return p;
     , o- z* }1 C' L5 r
281. }
     4 W9 I5 [4 i, @# @4 I5 |2 u+ B
282. 
     
283. /**
     ; J$ `1 c' l5 s6 e: r0 C% M+ C
284. * This function should be called when a packet is ready to be read
     
285. * from the interface. It uses the function low_level_input() that
     # M  z, z: U) H; h7 N  O
286. * should handle the actual reception of bytes from the network
     2 k% S+ c- y6 y$ P2 w/ p! Q8 R
287. * interface. Then the type of the received packet is determined and
     5 c9 k1 W& e( k: I
288. * the appropriate input function is called.
     8 @7 a2 U3 {( t& N0 ?; o! T
289. *
     ! ?+ M+ t+ Y! k" I$ u
290. * @param netif the lwip network interface structure for this ethernetif
     
291. */
     
292. // 必须去掉static
     , T0 q3 r3 T1 F( c9 k+ q
293. /*static */void
     ) G5 q1 v! O4 o
294. ethernetif_input(struct netif *netif)
     
295. {
     
296.   struct ethernetif *ethernetif;
     1 c) U7 m3 m" o4 a# p3 h6 z% l# s
297.   struct eth_hdr *ethhdr;
     1 ?7 z! _% ~3 A
298.   struct pbuf *p;
     
299. 
     ) q, e! n0 U' Q2 J; t
300.   ethernetif = netif->state;
     
301. 
     
302.   /* move received packet into a new pbuf */
     
303.   p = low_level_input(netif);
     
304.   /* if no packet could be read, silently ignore this */
     & U7 B; c1 ~/ O. ~  R
305.   if (p != NULL) {
     
306.     /* pass all packets to ethernet_input, which decides what packets it supports */
     
307.     if (netif->input(p, netif) != ERR_OK) {
     6 H" F! ?! p$ i/ n+ @1 I
308.       LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n"));
     
309.       pbuf_free(p);
     
310.       p = NULL;
     , u: L5 _& M! e1 n
311.     }
     
312.   }
     ! }; H% W+ k# {
313. }
     
314. 
     
315. /**
     
316. * Should be called at the beginning of the program to set up the
     
317. * network interface. It calls the function low_level_init() to do the
     
318. * actual setup of the hardware.
     
319. *
     / ~( E9 i! S( d
320. * This function should be passed as a parameter to netif_add().
     $ b( @' z( [0 b1 j9 X
321. *
     7 y4 r% p9 K! t& J' n# @7 N2 U& X
322. * @param netif the lwip network interface structure for this ethernetif
     1 u9 u& w9 B" ~# K7 v# K
323. * @return ERR_OK if the loopif is initialized
     
324. *         ERR_MEM if private data couldn't be allocated
       j# ~% T, h8 s# `( v
325. *         any other err_t on error
     ( K7 D$ k; [* w5 ?/ q
326. */
     , j) u) Y) m( y' L5 n
327. err_t
     1 p9 M( p7 P. t. M1 X' j$ I
328. ethernetif_init(struct netif *netif)
     $ b# y# N% J' {$ ]* v' a- |
329. {
     
330.   struct ethernetif *ethernetif;
     
331. 
     3 G+ _% @- K6 g$ x* G( Q
332.   LWIP_ASSERT("netif != NULL", (netif != NULL));
     3 q( X# R" X6 v% C( y# g' T6 b
333. 
     
334.   ethernetif = mem_malloc(sizeof(struct ethernetif));
     
335.   if (ethernetif == NULL) {
     
336.     LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_init: out of memory\n"));
     
337.     return ERR_MEM;
     
338.   }
     ) ]) Q$ k# ]$ P, J. y) j
339. 
     
340. #if LWIP_NETIF_HOSTNAME
     
341.   /* Initialize interface hostname */
     3 E, h# O) k: _3 k+ j1 J3 T0 ]
342.   netif->hostname = "lwip";
     0 K! k% |" p7 B: {  d
343. #endif /* LWIP_NETIF_HOSTNAME */
     $ m) e6 y' A7 n* u' P/ y4 ]4 {
344. 
     
345.   /*
     9 M* Q* ~+ s' j  o
346.    * Initialize the snmp variables and counters inside the struct netif.
     
347.    * The last argument should be replaced with your link speed, in units
     
348.    * of bits per second.
     
349.    */
     8 I( I5 n% h0 y; P  U/ ?( j3 W" d
350.   MIB2_INIT_NETIF(netif, snmp_ifType_ethernet_csmacd, LINK_SPEED_OF_YOUR_NETIF_IN_BPS);
     ! ^" e, I/ N6 W. @" w
351. 
     + J' b" b/ Z5 x: n" I- Z- q
352.   netif->state = ethernetif;
     . G" ]# K  R- @5 G! c: I; B
353.   netif->name[0] = IFNAME0;
     
354.   netif->name[1] = IFNAME1;
     
355.   /* We directly use etharp_output() here to save a function call.
     2 q# G$ A  D0 t9 R
356.    * You can instead declare your own function an call etharp_output()
     0 e- T% e4 M+ B, Q% u; N
357.    * from it if you have to do some checks before sending (e.g. if link
     
358.    * is available...) */
     
359.   netif->output = etharp_output;
     & S7 b$ t+ R/ b: q* H9 c- J6 h
360. #if LWIP_IPV6
     
361.   netif->output_ip6 = ethip6_output;
     
362. #endif /* LWIP_IPV6 */
     2 K& w, c$ m/ ?9 ~, U+ R. C
363.   netif->linkoutput = low_level_output;
     
364. 
     9 d% u, t' a: p: A
365.   ethernetif->ethaddr = (struct eth_addr *)&(netif->hwaddr[0]);
     ( I* S: r8 r, u
366. 
     
367.   /* initialize the hardware */
     
368.   low_level_init(netif);
     
369. 
     0 T1 L# A) ?& k  c: g0 o% C
370.   return ERR_OK;
     
371. }
     
372. 
     2 v" `$ I2 Z& n
373. #endif /* 0 */
     ' V5 ^$ l0 h# G! L

复制代码

6 [1 {3 r, H! F* q在项目属性中，设置Include Paths为：.;.\lwip\include
& i6 [5 h4 L" C5 x- g3 P! D4 v其中点表示工程根目录。

7 A4 ~8 M6 |7 ~0 j6 l( Y: N另外，为了在程序中使用printf函数，Target选项卡下的Use MicroLIB复选框也要勾选上。
1 W+ ~. R+ i) a. H
编译并下载程序，电脑和WiFi模块要连同一个WiFi热点。
5 y9 d, m9 v1 [+ p7 \$ t电脑的IP地址要手动配置。IP地址为192.168.43.71（最后一个数随便），子网掩码为255.255.255.0，网关为192.168.43.1。
1 p% Z% f* d* v, J/ ^/ J9 G5 k配置完成后，即可用电脑上的浏览器访问开发板上面的HTTP服务器。

楼主你好，我最近也在做esp8266数据传输。做了一个stm32控制的tcp server可以传递数据，但是传递时间有点慢。可以和你讨论一下吗？我的qq是1632401541

个人给个建议，大量代码最好用文件的形式...然后将一些注意的地方，和自己整个开发过程的经验！！！！

版主说的是，不过还是谢谢楼主分享

Mark....
0 D$ V+ h8 M' g+ j
多谢分享