mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
269 lines
8.3 KiB
C
269 lines
8.3 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "esp_log.h"
|
|
#include "esp_wifi.h"
|
|
#include "esp_console.h"
|
|
#include "linenoise/linenoise.h"
|
|
#include "argtable3/argtable3.h"
|
|
#include "esp_pm.h"
|
|
#include "esp_private/esp_clk.h"
|
|
|
|
#define MAX_RECONNECT_TIMES (5)
|
|
|
|
const static char *TAG = "WIFI";
|
|
static int s_reconnect_times = 0;
|
|
|
|
|
|
static void wifi_event_any_handler(void* arg, esp_event_base_t event_base,
|
|
int32_t event_id, void* event_data)
|
|
{
|
|
ESP_LOGI(TAG, "WiFi event: 0x%"PRIx32, event_id);
|
|
}
|
|
|
|
static void wifi_event_disconnected_handler(void* arg, esp_event_base_t event_base,
|
|
int32_t event_id, void* event_data)
|
|
{
|
|
ESP_LOGI(TAG, "WIFI_EVENT_STA_DISCONNECTED");
|
|
if (s_reconnect_times++ < MAX_RECONNECT_TIMES) {
|
|
esp_wifi_connect();
|
|
} else {
|
|
ESP_LOGE(TAG, "MAX RECONNECT TIME, STOP!");
|
|
}
|
|
}
|
|
|
|
static void wifi_event_connected_handler(void* arg, esp_event_base_t event_base,
|
|
int32_t event_id, void* event_data)
|
|
{
|
|
ESP_LOGI(TAG, "WIFI_EVENT_STA_CONNECTED");
|
|
s_reconnect_times = 0;
|
|
}
|
|
|
|
|
|
static void ip_event_got_ip_handler(void* arg, esp_event_base_t event_base,
|
|
int32_t event_id, void* event_data)
|
|
{
|
|
ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
|
|
ESP_LOGI(TAG, "STA_GOT_IP:" IPSTR, IP2STR(&event->ip_info.ip));
|
|
}
|
|
|
|
static int initialize_wifi(int argc, char **argv)
|
|
{
|
|
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
|
|
ESP_ERROR_CHECK(esp_wifi_init(&cfg));
|
|
|
|
esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, wifi_event_any_handler, NULL);
|
|
esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, wifi_event_disconnected_handler, NULL);
|
|
esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, wifi_event_connected_handler, NULL);
|
|
esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, ip_event_got_ip_handler, NULL);
|
|
|
|
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) );
|
|
ESP_ERROR_CHECK(esp_wifi_start() );
|
|
/* always enable wifi sleep */
|
|
ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_MIN_MODEM));
|
|
ESP_LOGI(TAG, "initialize_wifi DONE.");
|
|
return 0;
|
|
}
|
|
|
|
static void register_wifi_init(void)
|
|
{
|
|
const esp_console_cmd_t cmd = {
|
|
.command = "wifi_init",
|
|
.help = "Initialize WiFi",
|
|
.hint = NULL,
|
|
.func = &initialize_wifi,
|
|
.argtable = NULL
|
|
};
|
|
ESP_ERROR_CHECK(esp_console_cmd_register(&cmd));
|
|
}
|
|
|
|
typedef struct {
|
|
struct arg_str *ssid;
|
|
struct arg_str *password;
|
|
struct arg_int *authmode;
|
|
struct arg_int *channel;
|
|
struct arg_int *max_conn;
|
|
struct arg_end *end;
|
|
} ap_set_args_t;
|
|
static ap_set_args_t ap_set_args;
|
|
|
|
static int cmd_do_ap_set(int argc, char **argv)
|
|
{
|
|
int nerrors = arg_parse(argc, argv, (void **) &ap_set_args);
|
|
|
|
if (nerrors != 0) {
|
|
arg_print_errors(stderr, ap_set_args.end, argv[0]);
|
|
return 1;
|
|
}
|
|
|
|
wifi_config_t wifi_config = {};
|
|
|
|
const char *ssid = ap_set_args.ssid->sval[0];
|
|
strncpy((char *) wifi_config.ap.ssid, ssid, sizeof(wifi_config.ap.ssid));
|
|
const char *pass = ap_set_args.password->sval[0];
|
|
if (ap_set_args.password->count > 0) {
|
|
strncpy((char *) wifi_config.ap.password, pass, sizeof(wifi_config.ap.password));
|
|
wifi_config.ap.authmode = WIFI_AUTH_WPA2_PSK; // set default auth mode
|
|
}
|
|
if (ap_set_args.channel->count > 0) {
|
|
wifi_config.sta.channel = (uint8_t)(ap_set_args.channel->ival[0]);
|
|
}
|
|
if (ap_set_args.authmode->count > 0) {
|
|
wifi_config.ap.authmode = ap_set_args.authmode->ival[0];
|
|
}
|
|
if (ap_set_args.max_conn->count > 0) {
|
|
wifi_config.ap.max_connection = ap_set_args.max_conn->ival[0];
|
|
} else {
|
|
wifi_config.ap.max_connection = 2;
|
|
}
|
|
|
|
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP) );
|
|
esp_err_t err = esp_wifi_set_config(WIFI_IF_AP, &wifi_config);
|
|
if (err == ESP_OK) {
|
|
ESP_LOGI(TAG, "set ap config OK.");
|
|
} else {
|
|
ESP_LOGE(TAG, "set ap config Failed! (%s)", esp_err_to_name(err));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void register_ap_set(void)
|
|
{
|
|
ap_set_args.ssid = arg_str1(NULL, NULL, "<ssid>", "SSID of AP");
|
|
ap_set_args.password = arg_str0(NULL, NULL, "<pass>", "password of AP");
|
|
ap_set_args.authmode = arg_int0("a", "authmode", "<authmode>", "wifi auth type (ie. open | wep| wpa2 | wpa2_enterprise)");
|
|
ap_set_args.channel = arg_int0("n", "channel", "<channel>", "channel of AP");
|
|
ap_set_args.max_conn = arg_int0("m", "max_conn", "<max_conn>", "Max station number, default: 2");
|
|
ap_set_args.end = arg_end(2);
|
|
const esp_console_cmd_t cmd = {
|
|
.command = "ap_set",
|
|
.help = "WiFi is ap mode, set ap config.",
|
|
.hint = NULL,
|
|
.func = &cmd_do_ap_set,
|
|
.argtable = &ap_set_args
|
|
};
|
|
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd) );
|
|
|
|
}
|
|
|
|
typedef struct {
|
|
struct arg_str *ssid;
|
|
struct arg_str *password;
|
|
struct arg_int *channel;
|
|
struct arg_end *end;
|
|
} sta_connect_args_t;
|
|
static sta_connect_args_t connect_args;
|
|
|
|
|
|
static int cmd_do_sta_connect(int argc, char **argv)
|
|
{
|
|
int nerrors = arg_parse(argc, argv, (void **) &connect_args);
|
|
|
|
if (nerrors != 0) {
|
|
arg_print_errors(stderr, connect_args.end, argv[0]);
|
|
return 1;
|
|
}
|
|
|
|
wifi_config_t wifi_config = {
|
|
.sta = {
|
|
.scan_method = WIFI_ALL_CHANNEL_SCAN,
|
|
.sort_method = WIFI_CONNECT_AP_BY_SIGNAL,
|
|
},
|
|
};
|
|
|
|
const char *ssid = connect_args.ssid->sval[0];
|
|
memcpy((char *) wifi_config.sta.ssid, ssid, sizeof(wifi_config.sta.ssid));
|
|
const char *pass = connect_args.password->sval[0];
|
|
if (connect_args.password->count > 0) {
|
|
memcpy((char *) wifi_config.sta.password, pass, sizeof(wifi_config.sta.password));
|
|
wifi_config.sta.threshold.authmode = WIFI_AUTH_WEP;
|
|
}
|
|
if (connect_args.channel->count > 0) {
|
|
wifi_config.sta.channel = (uint8_t)(connect_args.channel->ival[0]);
|
|
}
|
|
|
|
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) );
|
|
ESP_LOGI(TAG, "Connecting to %s...", ssid);
|
|
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
|
|
s_reconnect_times = 0;
|
|
esp_err_t err = esp_wifi_connect();
|
|
ESP_LOGI(TAG, "WIFI_CONNECT_START, ret: 0x%x", err);
|
|
return 0;
|
|
}
|
|
|
|
static void register_sta_connect(void)
|
|
{
|
|
connect_args.ssid = arg_str1(NULL, NULL, "<ssid>", "SSID of AP");
|
|
connect_args.password = arg_str0(NULL, NULL, "<pass>", "password of AP");
|
|
connect_args.channel = arg_int0("n", "channel", "<channel>", "channel of AP");
|
|
connect_args.end = arg_end(2);
|
|
const esp_console_cmd_t cmd = {
|
|
.command = "sta_connect",
|
|
.help = "WiFi is station mode, join specified soft-AP",
|
|
.hint = NULL,
|
|
.func = &cmd_do_sta_connect,
|
|
.argtable = &connect_args
|
|
};
|
|
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd) );
|
|
}
|
|
|
|
|
|
typedef struct {
|
|
struct arg_str *type;
|
|
struct arg_end *end;
|
|
} light_sleep_args_t;
|
|
static light_sleep_args_t sleep_args;
|
|
|
|
static int cmd_do_light_sleep(int argc, char **argv)
|
|
{
|
|
int nerrors = arg_parse(argc, argv, (void **) &sleep_args);
|
|
if (nerrors != 0) {
|
|
arg_print_errors(stderr, sleep_args.end, argv[0]);
|
|
return 1;
|
|
}
|
|
const char *sleep_type = sleep_args.type->sval[0];
|
|
if (!strcmp(sleep_type, "enable")) {
|
|
esp_pm_config_t pm_config = {
|
|
.max_freq_mhz = CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ,
|
|
.min_freq_mhz = esp_clk_xtal_freq() / 1000000,
|
|
.light_sleep_enable = true,
|
|
};
|
|
ESP_ERROR_CHECK(esp_pm_configure(&pm_config));
|
|
ESP_LOGI(TAG, "LIGHT_SLEEP_ENABLED,OK");
|
|
} else {
|
|
ESP_LOGE(TAG, "invaild arg!");
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void register_light_sleep(void)
|
|
{
|
|
sleep_args.type = arg_str1(NULL, NULL, "<type>", "light sleep mode: enable");
|
|
sleep_args.end = arg_end(2);
|
|
const esp_console_cmd_t cmd = {
|
|
.command = "light_sleep",
|
|
.help = "Config light sleep mode",
|
|
.hint = NULL,
|
|
.func = &cmd_do_light_sleep,
|
|
.argtable = &sleep_args,
|
|
};
|
|
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd) );
|
|
}
|
|
|
|
extern void register_wifi_cmd(void)
|
|
{
|
|
register_wifi_init();
|
|
register_ap_set();
|
|
register_sta_connect();
|
|
register_light_sleep();
|
|
}
|