【打卡帖】7日玩转ESP32——(第4日) 串口的输入输出

小康师兄

物联网领域优质创作者

博客专家认证

2022-01-23 17:43:08

加精

一、打卡步骤

阅读完本文指定的开放【免费试读】的付费文章；
完成课后作业后，直接在课程学习贴下回复跟帖，即可完成打卡；
打卡时间是在课程更新完的当天（如果之前有一天没学习，只要在课程结束之前补卡学完就可以）；
课程发布后的第二天，就会更新参考答案在【免费试读】的付费文章上，学员可以对照学习即可；
学习过程中如有疑问可以跟帖，发帖，或者在社群中提出问题皆可，博客专家、物联网领域优质创作者小康师兄会一一回复解答。

二、试读文章

【试读开放时间】2022/1/23 - 2021/1/26
【试读文章内容】7日玩转ESP32——(第4日) 串口的输入输出
【试读文章链接】https://blog.csdn.net/kangweijian/article/details/122499506

...全文

317 6 打赏收藏转发到动态举报

写回复

用AI写文章

6 条回复

切换为时间正序

请发表友善的回复…

发表回复

雪羽~ 2022-01-26

打赏
举报

打卡 7日玩转ESP32——(第4日) 串口的输入输出
看来我不是唯一一个延迟打卡的，总之，加油，目标是完成课程

#include <stdio.h>
#include <string.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_log.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_spi_flash.h"
#include "nvs_flash.h"
#include "driver/uart.h"
#include "driver/gpio.h"
 
#define TXD_PIN                     (GPIO_NUM_4)
#define RXD_PIN                     (GPIO_NUM_5)
#define DEFAULT_SCAN_LIST_SIZE      64
#define RX_BUF_SIZE                 1024
 
static const char *TAG = "DAY-4";
 
uint16_t number = DEFAULT_SCAN_LIST_SIZE;
uint16_t ap_count = 0, ap_index;
wifi_ap_record_t ap_info[DEFAULT_SCAN_LIST_SIZE];
 
/* Initialize Wi-Fi as sta and set scan method */
static void wifi_scan(void)
{
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_t *sta_netif = esp_netif_create_default_wifi_sta();
    assert(sta_netif);
 
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
 
    uint16_t number = DEFAULT_SCAN_LIST_SIZE;
    wifi_ap_record_t ap_info[DEFAULT_SCAN_LIST_SIZE];
    uint16_t ap_count = 0;
    memset(ap_info, 0, sizeof(ap_info));
 
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_start());
    esp_wifi_scan_start(NULL, true);
    ESP_ERROR_CHECK(esp_wifi_scan_get_ap_records(&number, ap_info));
    ESP_ERROR_CHECK(esp_wifi_scan_get_ap_num(&ap_count));
    ESP_LOGI(TAG, "Total APs scanned = %u", ap_count);
    for (int i = 0; (i < DEFAULT_SCAN_LIST_SIZE) && (i < ap_count); i++) {
        ESP_LOGI(TAG, "SSID \t\t%s", ap_info[i].ssid);
        ESP_LOGI(TAG, "RSSI \t\t%d", ap_info[i].rssi);
        ESP_LOGI(TAG, "Channel \t\t%d\n", ap_info[i].primary);
    }
}
 
int sendData(const char* data)
{
    const int len = strlen(data);
    const int txBytes = uart_write_bytes(UART_NUM_1, data, len);
    ESP_LOGI(TAG, "Wrote %d bytes", txBytes);
    return txBytes;
}
 
static void rx_task(void *arg)
{
    static const char *RX_TASK_TAG = "RX_TASK";
    esp_log_level_set(RX_TASK_TAG, ESP_LOG_INFO);
    uint8_t* data = (uint8_t*) malloc(RX_BUF_SIZE+1);
    while (1) {
        const int rxBytes = uart_read_bytes(UART_NUM_1, data, RX_BUF_SIZE, 1000 / portTICK_RATE_MS);
        if (rxBytes > 0) {
            data[rxBytes] = 0;
            ESP_LOGI(RX_TASK_TAG, "Read %d bytes: '%s'", rxBytes, data);
            ESP_LOG_BUFFER_HEXDUMP(RX_TASK_TAG, data, rxBytes, ESP_LOG_INFO);
            if(data[0]=='A' && data[1]==';'){
                wifi_scan();
                sendData("OK\n");
            }else if(data[0]=='Q' && data[1]==':'){
                for (int i = 0; (i < DEFAULT_SCAN_LIST_SIZE) && (i < ap_count); i++) {
                    if(data[3]==ap_info[i].ssid[0] && data[4]==ap_info[i].ssid[1]){ 
                        sendData((char *)ap_info[i].ssid); 
                        sendData((char *)ap_info[i].rssi); 
                        sendData((char *)ap_info[i].primary);
                    }
                }
            }
        }
    }
    free(data);
}
 
void uart_init(void) {
    const uart_config_t uart_config = {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_APB,
    };
    // We won't use a buffer for sending data.
    uart_driver_install(UART_NUM_1, RX_BUF_SIZE * 2, 0, 0, NULL, 0);
    uart_param_config(UART_NUM_1, &uart_config);
    uart_set_pin(UART_NUM_1, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
}
 
void app_main(void)
{
    // Initialize NVS
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK( ret );
 
    wifi_scan();
 
    uart_init();
 
    xTaskCreate(rx_task, "uart_rx_task", 1024*2, NULL, configMAX_PRIORITIES, NULL);
}

trw777 2022-01-26

打赏
举报

打卡----7日玩转ESP32——(第4日) 串口的输入输出
这进度赶不上啊！！！！！！


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "driver/gpio.h"
#include "esp_wifi.h"
#include "esp_log.h"
#include "esp_event.h"
#include "nvs_flash.h"
#include "esp_system.h"
#include "driver/uart.h"


static const int RX_BUF_SIZE = 1024;

#define TXD_PIN (GPIO_NUM_4)  //发送端口
#define RXD_PIN (GPIO_NUM_5)  //接收端口

static const char *TAG = "scan";


wifi_ap_record_t ap_info[DEFAULT_SCAN_LIST_SIZE];
uint32_t ap_max_number = 0,ap_count=0;

//初始化GPIO 9 端口
void init_gpio(){
    gpio_config_t io_conf;
    //disable interrupt 禁用中断
    io_conf.intr_type = GPIO_INTR_DISABLE;
    //set as output mode 设置为输出模式
    io_conf.mode = GPIO_MODE_OUTPUT;
    //bit mask of the pins that you want to set,e.g.GPIO0 你想设置的引脚的位掩码，例如gpio9
    io_conf.pin_bit_mask = GPIO_OUTPUT_PIN_SEL;
    //disable pull-down mode 禁用下拉模式
    io_conf.pull_down_en = 0;
    //disable pull-up mode 禁用上拉拉模式
    io_conf.pull_up_en = 0;
    //configure GPIO with the given settings 写入GPIO 信息
    gpio_config(&io_conf);
}

//初始化GPIO
void init_gpio() {
    const uart_config_t uart_config = {                 //串口参数结构体
        .baud_rate = 115200,                            //波特率
        .data_bits = UART_DATA_8_BITS,                  //数据位
        .parity = UART_PARITY_DISABLE,                  //奇偶校验
        .stop_bits = UART_STOP_BITS_1,                  //停止位
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,          //流控制
        .source_clk = UART_SCLK_APB,                    //时钟源
    };
    // We won't use a buffer for sending data.  我们不会使用缓冲区来发送数据。
    //向系统初始化uart,可以理解为：告诉系统使用的是哪个uart的资源，相应的接收和发送缓冲区大小是多少，是否有事件需要处理等等  启动串口功能，安装uart驱动
    uart_driver_install(UART_NUM_1, RX_BUF_SIZE * 2, 0, 0, NULL, 0);
    //设置串口 配置串口参数，主要是根据串口结构体配置串口的波特率，起始位，校验位，数据位以及是否需要流控等
    uart_param_config(UART_NUM_1, &uart_config);
    //配置串口的映射引脚。也就是说ESP32的串口是支持引脚映射的，比如我的开发板串口一默认的是GPIO9和GPIO10，现在将TX、RX映射到GPIO4和GPIO5上
    uart_set_pin(UART_NUM_1, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
}




//初始化wifi
static void init_wifi_sta()
{
    nvs_flash_init();
    ESP_ERROR_CHECK(esp_netif_init());      //初始化底层TCP/IP堆栈。在应用程序启动时，应该调用此函数一次。
    ESP_ERROR_CHECK(esp_event_loop_create_default());      // 创建系统事件任务并初始化应用程序事件的回调函数。

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();        //使用WIFI_INIT_CONFIG_DEFAULT() 来获取一个默认的wifi配置参数结构体变量
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));               //根据cfg参数初始化wifi连接所需要的资源

    // Initialize default station as network interface instance (esp-netif)
    //将缺省站初始化为网络接口实例(esp-netif)
    esp_netif_t *sta_netif = esp_netif_create_default_wifi_sta();
    assert(sta_netif);

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));                  //设置WiFi的工作模式为 STA
    ESP_ERROR_CHECK(esp_wifi_start());                                 // 启动WiFi连接
}

//扫描并记录AP信息
void wifi_scan()
{
    memset(ap_info,0,DEFAULT_SCAN_LIST_SIZE);
    esp_wifi_scan_start(NULL, true);  //扫描所有可用AP
    esp_wifi_scan_get_ap_records(&ap_max_number,ap_info)    //获取AP记录
    esp_wifi_scan_get_ap_num(&ap_count);                //获取上次扫描到的AP个数。
    //搞不明白 ap_max_number 与 ap_count 的区别
    for (int i = 0; (i < DEFAULT_SCAN_LIST_SIZE) && (i < ap_count); i++) {
        ESP_LOGI(TAG, "SSID \t\t%s", ap_info[i].ssid);
        ESP_LOGI(TAG, "RSSI \t\t%d", ap_info[i].rssi);
        ESP_LOGI(TAG, "Channel \t%d\n", ap_info[i].primary);
    }
}

static void read_data()
{
    uint8_t* data = (uint8_t*) malloc(RX_BUF_SIZE+1);
    while (1) {
        const int rxBytes = uart_read_bytes(UART_NUM_1, data, RX_BUF_SIZE, 1000 / portTICK_RATE_MS);  //接收数据
        if (rxBytes > 0) {

            if (NULL != strstr("A;",data))
            {
               wifi_scan()
            }else if (NULL != strstr("Q:",data))
            {
                uint8_t  w_ssid[32] =""
                memset(w_ssid,0,32);
                sscanf(data,"Q:%s",w_ssid);
                for (size_t i = 0; (ap_No < DEFAULT_SCAN_LIST_SIZE) && (ap_No < ap_count); i++)
                {
                    if (0 == strcpm(ap_info[i].ssid,w_ssid))
                    {
                        ESP_LOGI(TAG, "SSID \t\t%s", ap_info[i].ssid);
                        ESP_LOGI(TAG, "RSSI \t\t%d", ap_info[i].rssi);
                        ESP_LOGI(TAG, "Channel \t%d\n", ap_info[i].primary);
                    }
                }
                
                strcmp()
            }        
        }
    }
    free(data);
}

void app_main(void)
{
    init_gpio();
    init_wifi_sta();
    wifi_scan();
    xTaskCreate(read_data, "uart_rx_task", 1024*2, NULL, configMAX_PRIORITIES, NULL);   //创建新的任务实例
}

SXL2383 2022-01-24

打赏
举报

紧赶慢赶终于赶上了课程进度
讲真字符串查找有点难，勉强做了点，坐等小康师兄晚上的答案


#include <stdio.h>
#include <string.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_log.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_spi_flash.h"
#include "nvs_flash.h"
#include "driver/uart.h"
#include "driver/gpio.h"

#define TXD_PIN                     (GPIO_NUM_4)
#define RXD_PIN                     (GPIO_NUM_5)
#define DEFAULT_SCAN_LIST_SIZE      64
#define RX_BUF_SIZE                 1024

static const char *TAG = "DAY-4";

uint16_t number = DEFAULT_SCAN_LIST_SIZE;
uint16_t ap_count = 0, ap_index;
wifi_ap_record_t ap_info[DEFAULT_SCAN_LIST_SIZE];


static void print_auth_mode(int authmode)
{
    switch (authmode) {
    case WIFI_AUTH_OPEN:
        ESP_LOGI(TAG, "Authmode \tWIFI_AUTH_OPEN");
        break;
    case WIFI_AUTH_WEP:
        ESP_LOGI(TAG, "Authmode \tWIFI_AUTH_WEP");
        break;
    case WIFI_AUTH_WPA_PSK:
        ESP_LOGI(TAG, "Authmode \tWIFI_AUTH_WPA_PSK");
        break;
    case WIFI_AUTH_WPA2_PSK:
        ESP_LOGI(TAG, "Authmode \tWIFI_AUTH_WPA2_PSK");
        break;
    case WIFI_AUTH_WPA_WPA2_PSK:
        ESP_LOGI(TAG, "Authmode \tWIFI_AUTH_WPA_WPA2_PSK");
        break;
    case WIFI_AUTH_WPA2_ENTERPRISE:
        ESP_LOGI(TAG, "Authmode \tWIFI_AUTH_WPA2_ENTERPRISE");
        break;
    case WIFI_AUTH_WPA3_PSK:
        ESP_LOGI(TAG, "Authmode \tWIFI_AUTH_WPA3_PSK");
        break;
    case WIFI_AUTH_WPA2_WPA3_PSK:
        ESP_LOGI(TAG, "Authmode \tWIFI_AUTH_WPA2_WPA3_PSK");
        break;
    default:
        ESP_LOGI(TAG, "Authmode \tWIFI_AUTH_UNKNOWN");
        break;
    }
}

static void print_cipher_type(int pairwise_cipher, int group_cipher)
{
    switch (pairwise_cipher) {
    case WIFI_CIPHER_TYPE_NONE:
        ESP_LOGI(TAG, "Pairwise Cipher \tWIFI_CIPHER_TYPE_NONE");
        break;
    case WIFI_CIPHER_TYPE_WEP40:
        ESP_LOGI(TAG, "Pairwise Cipher \tWIFI_CIPHER_TYPE_WEP40");
        break;
    case WIFI_CIPHER_TYPE_WEP104:
        ESP_LOGI(TAG, "Pairwise Cipher \tWIFI_CIPHER_TYPE_WEP104");
        break;
    case WIFI_CIPHER_TYPE_TKIP:
        ESP_LOGI(TAG, "Pairwise Cipher \tWIFI_CIPHER_TYPE_TKIP");
        break;
    case WIFI_CIPHER_TYPE_CCMP:
        ESP_LOGI(TAG, "Pairwise Cipher \tWIFI_CIPHER_TYPE_CCMP");
        break;
    case WIFI_CIPHER_TYPE_TKIP_CCMP:
        ESP_LOGI(TAG, "Pairwise Cipher \tWIFI_CIPHER_TYPE_TKIP_CCMP");
        break;
    default:
        ESP_LOGI(TAG, "Pairwise Cipher \tWIFI_CIPHER_TYPE_UNKNOWN");
        break;
    }

    switch (group_cipher) {
    case WIFI_CIPHER_TYPE_NONE:
        ESP_LOGI(TAG, "Group Cipher \tWIFI_CIPHER_TYPE_NONE");
        break;
    case WIFI_CIPHER_TYPE_WEP40:
        ESP_LOGI(TAG, "Group Cipher \tWIFI_CIPHER_TYPE_WEP40");
        break;
    case WIFI_CIPHER_TYPE_WEP104:
        ESP_LOGI(TAG, "Group Cipher \tWIFI_CIPHER_TYPE_WEP104");
        break;
    case WIFI_CIPHER_TYPE_TKIP:
        ESP_LOGI(TAG, "Group Cipher \tWIFI_CIPHER_TYPE_TKIP");
        break;
    case WIFI_CIPHER_TYPE_CCMP:
        ESP_LOGI(TAG, "Group Cipher \tWIFI_CIPHER_TYPE_CCMP");
        break;
    case WIFI_CIPHER_TYPE_TKIP_CCMP:
        ESP_LOGI(TAG, "Group Cipher \tWIFI_CIPHER_TYPE_TKIP_CCMP");
        break;
    default:
        ESP_LOGI(TAG, "Group Cipher \tWIFI_CIPHER_TYPE_UNKNOWN");
        break;
    }
}

/* Initialize Wi-Fi as sta and set scan method */
static void wifi_scan(void)
{
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_t *sta_netif = esp_netif_create_default_wifi_sta();
    assert(sta_netif);

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    uint16_t number = DEFAULT_SCAN_LIST_SIZE;
    wifi_ap_record_t ap_info[DEFAULT_SCAN_LIST_SIZE];
    uint16_t ap_count = 0;
    memset(ap_info, 0, sizeof(ap_info));

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_start());
    esp_wifi_scan_start(NULL, true);
    ESP_ERROR_CHECK(esp_wifi_scan_get_ap_records(&number, ap_info));
    ESP_ERROR_CHECK(esp_wifi_scan_get_ap_num(&ap_count));
    ESP_LOGI(TAG, "Total APs scanned = %u", ap_count);
    for (int i = 0; (i < DEFAULT_SCAN_LIST_SIZE) && (i < ap_count); i++) {
        ESP_LOGI(TAG, "SSID \t\t%s", ap_info[i].ssid);
        ESP_LOGI(TAG, "RSSI \t\t%d", ap_info[i].rssi);
        print_auth_mode(ap_info[i].authmode);
        if (ap_info[i].authmode != WIFI_AUTH_WEP) {
            print_cipher_type(ap_info[i].pairwise_cipher, ap_info[i].group_cipher);
        }
        ESP_LOGI(TAG, "Channel \t\t%d\n", ap_info[i].primary);
    }

}

int sendData(const char* data)
{
    const int len = strlen(data);
    const int txBytes = uart_write_bytes(UART_NUM_1, data, len);
    ESP_LOGI(TAG, "Wrote %d bytes", txBytes);
    return txBytes;
}

static void rx_task(void *arg)
{
    static const char *RX_TASK_TAG = "RX_TASK";
    esp_log_level_set(RX_TASK_TAG, ESP_LOG_INFO);
    uint8_t* data = (uint8_t*) malloc(RX_BUF_SIZE+1);
    while (1) {
        const int rxBytes = uart_read_bytes(UART_NUM_1, data, RX_BUF_SIZE, 1000 / portTICK_RATE_MS);
        if (rxBytes > 0) {
            data[rxBytes] = 0;
            ESP_LOGI(RX_TASK_TAG, "Read %d bytes: '%s'", rxBytes, data);
            ESP_LOG_BUFFER_HEXDUMP(RX_TASK_TAG, data, rxBytes, ESP_LOG_INFO);
            if(data[0]=='A' && data[1]==';'){
                wifi_scan();
                sendData("OK\n");
            }else if(data[0]=='Q' && data[1]==':'){
                for (int i = 0; (i < DEFAULT_SCAN_LIST_SIZE) && (i < ap_count); i++) {
                    if(data[3]==ap_info[i].ssid[0] && data[4]==ap_info[i].ssid[1]){ 
                        sendData((char *)ap_info[i].ssid); 
                        sendData((char *)ap_info[i].rssi); 
                        sendData((char *)ap_info[i].primary);
                    }
                }
            }
        }
    }
    free(data);
}

void uart_init(void) {
    const uart_config_t uart_config = {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_APB,
    };
    // We won't use a buffer for sending data.
    uart_driver_install(UART_NUM_1, RX_BUF_SIZE * 2, 0, 0, NULL, 0);
    uart_param_config(UART_NUM_1, &uart_config);
    uart_set_pin(UART_NUM_1, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
}

void app_main(void)
{
    // Initialize NVS
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK( ret );

    wifi_scan();

    uart_init();

    xTaskCreate(rx_task, "uart_rx_task", 1024*2, NULL, configMAX_PRIORITIES, NULL);
}

小康师兄 2022-01-24

@SXL2383 好的好的，用strstr函数

MzMyLhz 2022-01-23

打赏
举报

字符串操作卡了挺久T_T
从大一后就没怎么碰过了，弄起来好痛苦
万分感谢上次小康师兄的指导，改用vscode内置终端读取串口内容终于没有乱码了

/* Hello World Example

   This example code is in the Public Domain (or CC0 licensed, at your option.)

   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/
#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "freertos/event_groups.h"
#include "driver/gpio.h"
#include "driver/uart.h"
#include "esp_wifi.h"
#include "esp_log.h"

#define WIFI_SCAN_FLAG (1<<0)
#define WIFI_GET_INFO  (1<<1)
#define SCAN_MAX 16

#define UART0_BAUD_RATES (115200)                   //波特率
#define UART0_DATA_BITS  (UART_DATA_8_BITS)
#define UART0_PARITY     (UART_PARITY_DISABLE)
#define UART0_STOP_BITS  (UART_STOP_BITS_1)
#define UART0_FLOW_CTRL  (UART_HW_FLOWCTRL_DISABLE)
#define UART0_NUM        (UART_NUM_0)
#define UART0_TX         (GPIO_NUM_2)
#define UART0_RX         (GPIO_NUM_3)
#define UART0_RTS        (UART_PIN_NO_CHANGE)
#define UART0_CTS        (UART_PIN_NO_CHANGE)


EventGroupHandle_t wifi_event_group = NULL;  //事件组句柄
static char rcv_ssid[32] = {0};   //传递SSID用的全局变量

const char* TAG = "DAY-4";

void wifi_scan(void *arg);
void uart_scan(void *arg);

void wifi_init(void)
{
  //从例程中引用
  //wifi初始化代码
  ESP_ERROR_CHECK(esp_netif_init());
  ESP_ERROR_CHECK(esp_event_loop_create_default());
  esp_netif_t *sta_netif = esp_netif_create_default_wifi_sta();
  assert(sta_netif);

  wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
  ESP_ERROR_CHECK(esp_wifi_init(&cfg));

  ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
  ESP_ERROR_CHECK(esp_wifi_start());
}

void app_main(void)
{
  //创建两个任务，所有初始化操作都在对应任务里做
  //防止主线程过于臃肿

  wifi_init();

  wifi_event_group = xEventGroupCreate();  //创建一个事件组，用于传递重新扫描/查询信息

  xTaskCreate(wifi_scan,
              "wifi_scan",
              4096,
              NULL,
              20,
              NULL);
  
  xTaskCreate(uart_scan,
              "uart_scan",
              2048,
              NULL,
              5,
              NULL);
  
  while(1)
  {
    vTaskDelay(10/portTICK_RATE_MS);
  }
}

void uart_scan(void *arg)
{
  char *uart_rcv_data = (char *)malloc(256);
  memset(uart_rcv_data, 0, 256);  //先清空
  uint8_t uart_rcv_length = 0;

  char *rcv_type = (char *)malloc(256);
  memset(rcv_type, 0, 256);  //先清空

  char* ssid = NULL;

  int length = 0;

  const char separate1[2] = ";";
  const char separate2[2] = " ";

  uart_config_t uart_config = {
    .baud_rate = UART0_BAUD_RATES,
    .data_bits = UART0_DATA_BITS,
    .parity = UART0_PARITY,
    .stop_bits = UART0_STOP_BITS,
    .flow_ctrl = UART0_FLOW_CTRL
  };
  
  //对第0个串口做配置
  uart_param_config(UART0_NUM, &uart_config);
  uart_set_pin(UART0_NUM, UART0_TX, UART0_RX, UART0_RTS, UART0_CTS);
  uart_driver_install(UART0_NUM, 1024, 0, 0, NULL, 0);


  while(1)
  {
    uart_rcv_length = uart_read_bytes(UART0_NUM, uart_rcv_data, 1024, 20);
    if(uart_rcv_length>0)
    {
      //printf("%s\n", uart_rcv_data);
      rcv_type = strtok(uart_rcv_data, separate1);
      //printf("截取的指令串:%s\n", rcv_type);

      switch(rcv_type[0])
      {
        case 'A':
          xEventGroupSetBits(wifi_event_group, WIFI_SCAN_FLAG);
        break;

        case 'Q':
          ssid = strtok(rcv_type, separate2);
          ssid = strtok(NULL, separate2);
          length = strlen(ssid);
          strncpy(rcv_ssid, ssid, length);
          //printf("截取的SSID:%s\n", ssid);
          xEventGroupSetBits(wifi_event_group, WIFI_GET_INFO);
        break;

        default:
          ESP_LOGI(TAG, "未知指令\n");
        break;
      }

      memset(uart_rcv_data, 0, 256);  //先清空
      memset(rcv_type, 0, 256);  //先清空
    }
    vTaskDelay(10/portTICK_RATE_MS);
  }
}

static void print_wifi_msg(wifi_ap_record_t ap_info[], uint16_t ap_count)
{
  ESP_LOGI(TAG, "--------------- 以下是扫描到的WiFi信息: -----------------\n");
  for (int i = 0; (i < SCAN_MAX) && (i < ap_count); i++) {
    ESP_LOGI(TAG, "---- 第 %d 个 ----\n", i+1);
    ESP_LOGI(TAG, "SSID: %s, \t\t强度: -%d, \t信道: %d\n", ap_info[i].ssid, ap_info[i].rssi, ap_info[i].primary);
  }
}

void wifi_scan(void *arg)
{
  EventBits_t wifi_bits;

  uint16_t number = SCAN_MAX;
  wifi_ap_record_t ap_info[SCAN_MAX];
  uint16_t ap_count = 0;
  memset(ap_info, 0, sizeof(ap_info));  //先清空

  char ssid[32] = {0};

  ESP_LOGI(TAG, "开始开机扫描...\n");
  esp_wifi_scan_start(NULL, true);
  ESP_ERROR_CHECK(esp_wifi_scan_get_ap_records(&number, ap_info));
  ESP_ERROR_CHECK(esp_wifi_scan_get_ap_num(&ap_count));
  print_wifi_msg(ap_info, ap_count);

  while(1)
  {
    wifi_bits = xEventGroupWaitBits(wifi_event_group, 
                                   WIFI_SCAN_FLAG|WIFI_GET_INFO,  //短按或长按
                                   true,    //判断完成离开后清除对应位
                                   false,   //不需要所有标志位都置1
                                   portMAX_DELAY);
    
    if(wifi_bits & WIFI_GET_INFO)
    {
      ESP_LOGI(TAG, "获取wifi信息中...\n");
      strcpy(ssid, rcv_ssid);
      //printf("ssid: %s\n", ssid);
      for(int i = 0; (i < SCAN_MAX) && (i < ap_count); i++)
      {
        if(!strcmp((char*)ap_info[i].ssid, ssid))
        {
          ESP_LOGI(TAG, "找到该WiFi!\n");
          ESP_LOGI(TAG, "SSID: %s, \t\t强度: -%d, \t信道: %d\n", ap_info[i].ssid, ap_info[i].rssi, ap_info[i].primary);
          break;
        }
      }
    }
    else if(wifi_bits & WIFI_SCAN_FLAG)
    {
      ESP_LOGI(TAG, "准备扫描wifi...\n");
      esp_wifi_scan_start(NULL, true);
      ESP_ERROR_CHECK(esp_wifi_scan_get_ap_records(&number, ap_info));
      ESP_ERROR_CHECK(esp_wifi_scan_get_ap_num(&ap_count));
      print_wifi_msg(ap_info, ap_count);
    }
    vTaskDelay(100/portTICK_RATE_MS);
  }
}