预备知识 请看下面两贴

STM32 如何快速创建 FREERTOS和RTX 工程
干货 Nucleo072 usart 基于RTOS的应用 方便AT指令类外设开发

使用的 Nucleo 072板子  其他用户请稍许移植一下

原本楼主发上面两贴就开始策划 这个东西 计划参加 方案大赛的。

原方案计划设计一个 智能 开关局域网内 PC  手机APP 可同时管理所有灯具，按键使用 F0的触摸模块，使用WIFI 和433
组网，目前淘宝有十分成熟的 智能灯开关产品 不过都是用RF实现有兴趣可以搜索一下。

结果最近太忙没空弄这个，加之考虑到本方案一个缺陷 那就是WIFI模块加入的热点需要配置。如果使用433模块再设计一套

可以配置WIFI的协议那是相当恐怖的  首先你的 433 主机（其他产品的遥控器）得支持液晶显示了，反正很麻烦了。不整了

现在将第一步完成的 内容分享大家参考  AT WIFI 产品设计，甚至蓝牙串口也可按同样的模式设计  。，纯串口当然不用说了


模块使用的 是8266 连接单片机 串口1  PA9 PA10引脚
下面是 效果。，上位机还没写，使用网络调试助手 给模块发送指令下位机执行相应操作

截图发送了 3条指令  get ip ,get cpu id,和 set led on

使用串口助手或者超级终端波特率115200 连接 stlink的虚拟串口 可以看到调试输出内容截图左边
实际操作可看到板子上LD2 可由 set led on 打开或者又 set led off关闭

1. 
   

复制代码

累死了  论坛竟然限制 发帖最大字符数   10000 帖子太长发帖失败  内容都没了 ，，，可怜的重新码了一次。。。

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

1. 
   
2. void USART1_IRQHandler()
   
3. {
   
4.         UART_HandleTypeDef *huart= &UartHandle1;
   
5.        
   
6.         /* UART parity error interrupt occurred -------------------------------------*/
   
7.   if((__HAL_UART_GET_IT(huart, UART_IT_PE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_PE) != RESET))
   
8.   {
   
9.     __HAL_UART_CLEAR_IT(huart, UART_CLEAR_PEF);
   
10.    
    
11.     huart->ErrorCode |= HAL_UART_ERROR_PE;
    
12.     /* Set the UART state ready to be able to start again the process */
    
13.     huart->State = HAL_UART_STATE_READY;
    
14.   }
    
15.   
    
16.   /* UART frame error interrupt occured --------------------------------------*/
    
17.   if((__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
    
18.   {
    
19.     __HAL_UART_CLEAR_IT(huart, UART_CLEAR_FEF);
    
20.    
    
21.     huart->ErrorCode |= HAL_UART_ERROR_FE;
    
22.     /* Set the UART state ready to be able to start again the process */
    
23.     huart->State = HAL_UART_STATE_READY;
    
24.   }
    
25.   
    
26.   /* UART noise error interrupt occured --------------------------------------*/
    
27.   if((__HAL_UART_GET_IT(huart, UART_IT_NE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
    
28.   {
    
29.     __HAL_UART_CLEAR_IT(huart, UART_CLEAR_NEF);
    
30.    
    
31.     huart->ErrorCode |= HAL_UART_ERROR_NE;   
    
32.     /* Set the UART state ready to be able to start again the process */
    
33.     huart->State = HAL_UART_STATE_READY;
    
34.   }
    
35.   
    
36.   /* UART Over-Run interrupt occured -----------------------------------------*/
    
37.   if((__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET))
    
38.   {
    
39.     __HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
    
40.    
    
41.     huart->ErrorCode |= HAL_UART_ERROR_ORE;     
    
42.     /* Set the UART state ready to be able to start again the process */
    
43.     huart->State = HAL_UART_STATE_READY;
    
44.   }
    
45.   
    
46.    /* Call UART Error Call back function if need be --------------------------*/
    
47.   if(huart->ErrorCode != HAL_UART_ERROR_NONE)
    
48.   {
    
49.     HAL_UART_ErrorCallback(huart);
    
50.   }
    
51.   
    
52. #if !defined(STM32F030x6) && !defined(STM32F030x8)  
    
53.   /* UART wakeup from Stop mode interrupt occurred -------------------------------------*/
    
54.   if((__HAL_UART_GET_IT(huart, UART_IT_WUF) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_WUF) != RESET))
    
55.   {
    
56.     __HAL_UART_CLEAR_IT(huart, UART_CLEAR_WUF);
    
57.     /* Set the UART state ready to be able to start again the process */
    
58.     huart->State = HAL_UART_STATE_READY;
    
59.     HAL_UART_WakeupCallback(huart);
    
60.   }
    
61. #endif /* !defined(STM32F030x6) && !defined(STM32F030x8) */
    
62.   
    
63.   /* UART in mode Receiver ---------------------------------------------------*/
    
64.   if((__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET))
    
65.   {
    
66.     /* Clear RXNE interrupt flag */
    
67.                
    
68.                 rx_buf[0].buff[rx_buf[0].rx_index]=huart->Instance->RDR;
    
69.                 //huart->Instance->TDR=rx_buf.buff[rx_buf.rx_index];
    
70.                 rx_buf[0].rx_index++;//储存接收到的数据到 缓冲区
    
71.                 osSemaphoreRelease(usart_Rx[0]);//通知  scanf 有数据收到
    
72.                 if(rx_buf[0].rx_index==BUFFSIZE)
    
73.                 {
    
74.                         rx_buf[0].rx_index=0;
    
75.                 }
    
76.                 if(rx_buf[0].rx_index==rx_buf[0].save_index)
    
77.                 {
    
78.                         rx_buf[0].save_index++;
    
79.                         if(rx_buf[0].save_index==BUFFSIZE)
    
80.                         {
    
81.                                 rx_buf[0].save_index=0;
    
82.                         }
    
83.                 }
    
84.                  __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);
    
85. 
    
86.   }
    
87. 
    
88. }
    

复制代码

//下面这个函数被scanf所调用

1. 
   
2. int fgetc(FILE* f)
   
3. {
   
4.                 osStatus st;
   
5.        
   
6.         char index=0;
   
7.         int ch;
   
8.        
   
9.         if(f->usart==USART2)
   
10.         {
    
11.         index=1;
    
12.         }
    
13.        
    
14. if(rx_buf[index].rx_index!=rx_buf[index].save_index)
    
15. {
    
16.         ch= rx_buf[index].buff[rx_buf[index].save_index++];
    
17.         if(rx_buf[index].save_index==BUFFSIZE)
    
18.         {
    
19.         rx_buf[index].save_index=0;
    
20.         }
    
21.         return ch;//缓冲区有数据则取得数据
    
22. }
    
23. else
    
24. {//没有数据等待数据
    
25.                 if(index==0)
    
26.                 {
    
27.                         st=osSemaphoreWait(usart_Rx[index],wifi_wait);
    
28.                 }
    
29.                 else
    
30.                 {
    
31.                 st=osSemaphoreWait(usart_Rx[index],usart_wait);
    
32.                 }
    
33.         if(st!=osOK)
    
34.                 return EOF;
    
35. return fgetc(f);
    
36. }
    
37. 
    
38. }

复制代码

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

1. int Send_Wifi_cmd(const char *str,unsigned int wait,char *buf)
   
2. {
   
3.                         int ERR;
   
4.                         fprintf(&wifi,"%s\r\n",str);//发送指令
   
5.                         set_wifi_wait(wait);//设置超时时间
   
6.                                 if(fscanf(&wifi,"%s",buf)!=EOF)//扫描模块返回
   
7.                                 {
   
8.                                 fprintf(stdout,"%s\r\n",buf);
   
9.                                 }
   
10.                                 while(1)
    
11.                                 {//循环扫描模块返回 直到超时或者返回OK或 ERROR
    
12.                                 if(fscanf(&wifi,"%s",buf)==EOF)
    
13.                                 {
    
14.                                         break;
    
15.                                 }
    
16.                                 set_wifi_wait(1000);
    
17.                                 fprintf(stdout,"%s\r\n",buf);
    
18.                                
    
19.                                 if(fscanf(&wifi,"%s",buf)==EOF)
    
20.                                 {
    
21.                                         ERR=osEventTimeout;
    
22.                                         break;
    
23.                                 }
    
24.                                 //set_usat_wait(500);
    
25.                                 fprintf(stdout,"%s\r\n",buf);
    
26.                                 if(memcmp("OK",buf,2)==0)
    
27.                                 {
    
28.                                         ERR=osOK;
    
29.                                                 break;
    
30.                                 }
    
31.                                 else if(memcmp("ERROR",buf,5)==0)
    
32.                                 {
    
33.                                         ERR=osErrorOS;
    
34.                                                 break;
    
35.                                 }
    
36.                                
    
37.                                 }
    
38.                                 return ERR;
    
39.                                
    
40. }
    

复制代码

1. 
   
2. static char buf[40];
   
3. void  usart_wifi(void const * argument)//WIFI的线程
   
4. {
   
5.                         static char IP[20];
   
6.                         if(AT_test())
   
7.                         {
   
8.                                 Send_Wifi_cmd("AT+CIOBAUD=115200",300,buf);
   
9.                         }
   
10.                         usart_init(115200);
    
11.                        
    
12.                         Send_Wifi_cmd("AT+RST",500,buf);
    
13.                         Send_Wifi_cmd("AT+CWMODE=?",500,buf);
    
14.                         //Send_Wifi_cmd("AT+CWLAP",5000,buf);
    
15.                         Send_Wifi_cmd("AT+CWJAP="TP-LINK_C6FC68","123456789"",5000,buf); //加入热点
    
16.                         Send_Wifi_cmd("AT+CWJAP?",300,buf);
    
17.                         Send_Wifi_cmd("AT+CIPMUX=1",300,buf);//启动多连接
    
18.                         Send_Wifi_cmd("AT+CIPSERVER=1,1234",300,buf);//启动服务器模式
    
19.                        
    
20.                         fprintf(&wifi,"AT+CIFSR\r\n");//获取 模块IP
    
21.                         set_wifi_wait(1000);
    
22.                         fscanf(&wifi,"%s",buf);
    
23.                         printf("%s",buf);
    
24.                         fscanf(&wifi,"%s%*s",buf);
    
25.                         printf("%s",buf);
    
26.                         if(memcmp("ERROR",buf,5)!=0)
    
27.                         {
    
28.                         memcpy(IP,&buf,20);//储存IP  由于模块IP是DHCP动态获取的  上位机APP无法预知IP地址所以 模块先获得自己IP 储存等待上位机使用 UDP                                  //广播get ip 命令获取IP
    
29.                         printf("%s",IP);
    
30.                         }
    
31.                         Connect(buf,1,"UDP","192.168.2.255",1234);//启动UDP模式
    
32.                         set_wifi_wait(50);
    
33.                         set_wifi_wait(osWaitForever);
    
34.                        
    
35.                                 if(fscanf(&wifi,"%[^\n]",buf)==EOF);
    
36.                                 fprintf(stdout,"%s\r\n",buf);
    
37. 
    
38.                        
    
39.                                 while(1)
    
40.                                 {
    
41.                                         timeout:
    
42.                                 set_wifi_wait(osWaitForever);
    
43.                                 if(fscanf(&wifi,"%*9c%[^\n]",buf)==EOF)goto timeout;//扫描 WIFI输出
    
44.                                         {
    
45.                                                 char cmd[5];
    
46.                                                 fprintf(stdout,"%s\r\n",buf);
    
47.                                                
    
48.                                                 sscanf(buf,"%*d:%s%*c%[^\n]",cmd,buf);//解析命令
    
49.                                                 printf("%s\r\n",cmd);
    
50.                                                
    
51.                                                 fscanf(&wifi,"%*s");
    
52.                                         if(memcmp("get",cmd,3)==0)//get data 如果是get命令
    
53.                                         {
    
54.                                                
    
55.                                                 if(memcmp("ip",buf,2)==0)// get ip命令
    
56.                                                 {
    
57.                                                         send_data(IP,buf);//发送本机IP
    
58.                                                 }
    
59.                                                 else if(memcmp("cpu id",buf,6)==0)
    
60.                                                 {
    
61.                                                 send_data("CPU uid",buf);
    
62.                                                 }
    
63.                                                 }
    
64.                                         else if(memcmp("set",cmd,3)==0) //set data
    
65.                                         {
    
66.                                                 if(memcmp("led on",buf,6)==0)
    
67.                                                 {
    
68.                                                 GPIOA->ODR|=GPIO_PIN_5;
    
69.                                                         send_data("LD2 ON",buf);
    
70.                                                 }
    
71.                                                 else if (memcmp("led off",buf,7)==0)
    
72.                                                 {
    
73.                                                 GPIOA->ODR&=~GPIO_PIN_5;
    
74.                                                         send_data("LD2 OFF",buf);
    
75.                                                 }
    
76.                                         }       
    
77.                                         }
    
78.                                 }
    
79. }

复制代码

注意usart_wifi.c 一开始有 几个 FILE定义  主要是为了区分  printf 和 scanf 操作的 串口




然后需要注意 8266 TX右边的 引脚是需要接VCC的

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

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

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

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

有可能 命令忘记 \r\n了？

效果图不见了  现在补上

很详细   

不错，支持，有空试下

谢谢楼主分享！