【板子测评】Ai-WB2 Socket首次使用

Socket初步测试

环境搭建在参考
【新提醒】vscode Ai-wb2-12F环境搭建、烧录 - Ai-WB2系列 - 物联网开发者社区-安信可论坛 - Powered by Discuz!

【新提醒】Ai-WB2-32S VS Code开发环境部署与GPIO控制 - Ai-WB2系列 - 物联网开发者社区-安信可论坛 - Powered by Discuz!

综合这两篇之后，也是很简单的完成了环境的搭建

make 编译 make clean清楚make -j8 flash p=COM4烧录下载，顺便好评，这个环境里面make可以只编译修改过的文件，不用修改一次整个编译一次，Windows环境下整个编译真是磨人，好几分钟(我也没想通为啥这个可以只编译修改，可能sdk优化的比较好？？？？，反正有的文件环境修改一次必须整个重新编，头大）

正文

先上图，结果是socket正常使用，也是通过socke直接访问了天气服务，杭州,天气阴，当前温度二十度

使用applications/Wifi/quick_connect 这个Demo 直接强行放个socket测试函数进去

/**
 * @file main.c
 * @author your name (you@domain.com)
 * @brief
 * @version 0.1
 * @date 2022-10-09
 *
 * @copyright Copyright (c) 2022
 *
 */
#include <FreeRTOS.h>
#include <task.h>
#include <stdio.h>
#include <string.h>
#include "blog.h"
#include <aos/yloop.h>
#include <aos/kernel.h>
#include <lwip/tcpip.h>
#include <wifi_mgmr_ext.h>
#include <hal_wifi.h>
#include <easyflash.h>
#include <sys/socket.h>
#include <netdb.h>

#define ROUTER_SSID "1" //你的wifi名字
#define ROUTER_PWD "12345678"//密码
//没看懂
#define EF_SSID_KEY "key_ssid"
#define EF_PWD_KEY "key_pwd"
#define EF_PMK_KEY "key_pmk"
#define EF_CHAN_KEY "key_channel"


#define SSID_LEN 33
#define PASSWORD_LEN 66
#define PMK_LEN 65

//天气服务地址
#define PORT "80" //常用端口
#define HOST "api.seniverse.com" //域名

int socketTest()
{
    blog_info("111111");
    // 初始化 addrinfo 结构体，用于指定要连接的服务器的信息
    struct addrinfo hints, *servinfo, *p;
    int rv, sockfd;
    char request[256];
    char buffer[1024];
    int numbytes;
    int found_start = 0;

    // 清空 hints 结构体，设置地址族为不指定，套接字类型为流式套接字（TCP）
    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    // 获取指定主机和服务的信息，存储在 servinfo 链表中
    if ((rv = getaddrinfo(HOST, PORT, &hints, &servinfo)) != 0)
    {
        return 1;
    }
    blog_info("111111");
    // 遍历 servinfo 链表，尝试创建并连接套接字
    for (p = servinfo; p != NULL; p = p->ai_next)
    {
        if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1)
        {
            continue;
        }

        if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1)
        {
            close(sockfd);
            continue;
        }

        break;
    }
    blog_info("111111");
    // 如果没有成功连接到任何地址，输出错误信息并退出
    if (p == NULL)
    {
        blog_info("failed to connect\n");
        return 2;
    }

    // 释放 servinfo 结构体占用的内存
    freeaddrinfo(servinfo);
    blog_info("111111");
    // 构造 HTTP GET 请求字符串
    snprintf(request, sizeof(request), "GET /v3/weather/now.json?key=SOGXnVRmQE-ISnQRo&location=hangzhou&language=zh-Hans&unit=c HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n", HOST);
    // 发送 HTTP 请求到服务器
    send(sockfd, request, strlen(request), 0);
    blog_error("Socket send request:%s", request);
    // 接收服务器返回的数据，直到没有更多数据可接收
    while ((numbytes = recv(sockfd, buffer, sizeof(buffer) - 1, 0)) > 0)
    {
        buffer[numbytes] = '\0';

        // 如果还没有找到 JSON 数据的开始部分
        if (!found_start)
        {
            // 查找第一个 '{' 的位置
            char *start = strchr(buffer, '{');
            if (start != NULL)
            {
                found_start = 1;
                blog_info("%s", start);
            }
            else
            {
                // 如果这一块数据中没有找到 '{'，继续接收下一块数据
                continue;
            }
        }
        else
        {
            // 如果已经找到 JSON 数据的开始部分，直接打印
            blog_info("%s", buffer);
        }
    }

    // 关闭套接字
    close(sockfd);
    blog_error("close socket");

    return 0;
}

static wifi_conf_t conf =
{
    .country_code = "CN",
};

static void quick_connect_wifi(char* ssid, char* password)
{
    wifi_interface_t wifi_interface;
    uint8_t channel = 0;
    size_t len = 0;
    int quick_connect = 1;
    bool open_bss_flag = 1;
    uint32_t flags = 0;
    char ef_ssid[SSID_LEN], ef_password[PASSWORD_LEN], pmk[PMK_LEN];
    memset(pmk, 0, PMK_LEN);
    memset(ef_ssid, 0, SSID_LEN);
    memset(ef_password, 0, PASSWORD_LEN);


    if (quick_connect > 0) {
        flags |= WIFI_CONNECT_STOP_SCAN_CURRENT_CHANNEL_IF_TARGET_AP_FOUND;
    }
    size_t ef_len = ef_get_env_blob(EF_CHAN_KEY, &channel, sizeof(uint8_t), &len);

    if (ef_len==0) {
        open_bss_flag = 0;
        ef_del_env(EF_SSID_KEY);
        ef_del_env(EF_PWD_KEY);
        ef_del_env(EF_PMK_KEY);
        ef_set_env_blob(EF_SSID_KEY, ssid, strlen(ssid));
        ef_set_env_blob(EF_PWD_KEY, password, strlen(password));
        wifi_mgmr_psk_cal(
               password,
               ssid,
               strlen(ssid),
               pmk
        );
        ef_set_env_blob(EF_PMK_KEY, pmk, PMK_LEN);
        wifi_interface = wifi_mgmr_sta_enable();
        wifi_mgmr_sta_connect_mid(wifi_interface, ssid, NULL, pmk, NULL, 0, 0, 1, flags);

    }
    else if (ef_len) {
        uint8_t channel = 0;
        ef_get_env_blob(EF_SSID_KEY, ef_ssid, SSID_LEN, &len);

        ef_get_env_blob(EF_PMK_KEY, pmk, PMK_LEN, &len);
        ef_get_env_blob(EF_CHAN_KEY, &channel, sizeof(uint8_t), &len);
        open_bss_flag = 0;
        blog_info("read connenct msg,ssid:%s channel:%d pmk:%s  ", ef_ssid, channel, pmk);
        wifi_interface = wifi_mgmr_sta_enable();
        wifi_mgmr_sta_connect_mid(wifi_interface, ssid, NULL, open_bss_flag ? NULL : pmk, NULL, 0, channel, 1, flags);

    }
    else {
        blog_error("%s:<ssid> [password] or no parameters", __func__);
    }

}

static void wifi_sta_connect(char* ssid, char* password)
{
    wifi_interface_t wifi_interface;
    char pmk[PMK_LEN];
    int quick_connect = 1;
    uint32_t flags = 0;

    memset(pmk, 0, PMK_LEN);

    if (quick_connect > 0) {
        flags |= WIFI_CONNECT_STOP_SCAN_CURRENT_CHANNEL_IF_TARGET_AP_FOUND;
    }

    wifi_mgmr_psk_cal(
               password,
               ssid,
               strlen(ssid),
               pmk
    );
    wifi_interface = wifi_mgmr_sta_enable();
    wifi_mgmr_sta_connect_mid(wifi_interface, ssid, NULL, pmk, NULL, 0, 8, 1, flags);
}

static void event_cb_wifi_event(input_event_t* event, void* private_data)
{
    static char* ssid;
    static char* password;

    switch (event->code)
    {
        case CODE_WIFI_ON_INIT_DONE:
        {
            blog_info("[APP] [EVT] INIT DONE %lld", aos_now_ms());
            wifi_mgmr_start_background(&conf);
        }
        break;
        case CODE_WIFI_ON_MGMR_DONE:
        {
            blog_info("[APP] [EVT] MGMR DONE %lld", aos_now_ms());
            //_connect_wifi();

            // wifi_sta_connect(ROUTER_SSID, ROUTER_PWD);
            quick_connect_wifi(ROUTER_SSID, ROUTER_PWD);
        }
        break;
        case CODE_WIFI_ON_SCAN_DONE:
        {
            blog_info("[APP] [EVT] SCAN Done %lld", aos_now_ms());
            // wifi_mgmr_cli_scanlist();
        }
        break;
        case CODE_WIFI_ON_DISCONNECT:
        {
            blog_info("[APP] [EVT] disconnect %lld", aos_now_ms());
        }
        break;
        case CODE_WIFI_ON_CONNECTING:
        {
            blog_info("[APP] [EVT] Connecting %lld", aos_now_ms());
        }
        break;
        case CODE_WIFI_CMD_RECONNECT:
        {
            blog_info("[APP] [EVT] Reconnect %lld", aos_now_ms());
        }
        break;
        case CODE_WIFI_ON_CONNECTED:
        {
            blog_info("[APP] [EVT] connected %lld", aos_now_ms());
        }
        break;
        case CODE_WIFI_ON_PRE_GOT_IP:
        {
            blog_info("[APP] [EVT] connected %lld", aos_now_ms());
        }
        break;
        case CODE_WIFI_ON_GOT_IP:
        {
            uint8_t channel = 0;
            blog_info("[APP] [EVT] GOT IP %lld", aos_now_ms());
            blog_info("[SYS] Memory left is %d Bytes", xPortGetFreeHeapSize());
            wifi_mgmr_channel_get(&channel);
            blog_info("ap channel:%d", channel);
            ef_del_env(EF_CHAN_KEY);
            ef_set_env_blob(EF_CHAN_KEY, &channel, sizeof(uint8_t));
        }
        break;
        case CODE_WIFI_ON_PROV_SSID:
        {
            blog_info("[APP] [EVT] [PROV] [SSID] %lld: %s",
                   aos_now_ms(),
                   event->value ? (const char*)event->value : "UNKNOWN");
            if (ssid)
            {
                vPortFree(ssid);
                ssid = NULL;
            }
            ssid = (char*)event->value;
        }
        break;
        case CODE_WIFI_ON_PROV_BSSID:
        {
            blog_info("[APP] [EVT] [PROV] [BSSID] %lld: %s",
                   aos_now_ms(),
                   event->value ? (const char*)event->value : "UNKNOWN");
            if (event->value)
            {
                vPortFree((void*)event->value);
            }
        }
        break;
        case CODE_WIFI_ON_PROV_PASSWD:
        {
            blog_info("[APP] [EVT] [PROV] [PASSWD] %lld: %s", aos_now_ms(),
                   event->value ? (const char*)event->value : "UNKNOWN");
            if (password)
            {
                vPortFree(password);
                password = NULL;
            }
            password = (char*)event->value;
        }
        break;
        case CODE_WIFI_ON_PROV_CONNECT:
        {
            blog_info("[APP] [EVT] [PROV] [CONNECT] %lld", aos_now_ms());
            blog_info("connecting to %s:%s...", ssid, password);
            wifi_sta_connect(ssid, password);
        }
        break;
        case CODE_WIFI_ON_PROV_DISCONNECT:
        {
            blog_info("[APP] [EVT] [PROV] [DISCONNECT] %lld", aos_now_ms());
        }
        break;
        default:
        {
            blog_info("[APP] [EVT] Unknown code %u, %lld", event->code, aos_now_ms());
            /*nothing*/
        }
    }
}

static void proc_main_entry(void* pvParameters)
{

    aos_register_event_filter(EV_WIFI, event_cb_wifi_event, NULL);
    hal_wifi_start_firmware_task();
    aos_post_event(EV_WIFI, CODE_WIFI_ON_INIT_DONE, 0);
    blog_error("SSSSSSSS------------------------------------------------------->Socket Test");
    blog_error("time: %s", __DATE__);
    blog_error("time: %s", __TIME__);
    static int i = 0;
    while(i<3)
    {
        blog_error("SSSSSSSS------------------------------------------------------->Socket Test");
        socketTest();
        i++;
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
    blog_error("SSSSSSSS------------------------------------------------------->Socket End");
    vTaskDelete(NULL);
}

static void system_thread_init()
{
    easyflash_init();
}

void main()
{
    system_thread_init();
    puts("[OS] Starting TCP/IP Stack...");
    tcpip_init(NULL, NULL);
    puts("[OS] proc_main_entry task...");
    xTaskCreate(proc_main_entry, (char*)"main_entry", 1024, NULL, 15, NULL);
}

赞～

厉害了