mirrors
/
micropython
mirror of https://github.com/micropython/micropython.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
micropython/drivers/esp-hosted/esp_hosted_wifi.c

702 lines
25 KiB
C
Raw Blame History

/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2023 Arduino SA
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* ESP-Hosted WiFi driver.
*/
#include "py/mphal.h"
#include "py/mperrno.h"
#if MICROPY_PY_NETWORK_ESP_HOSTED
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include "lwip/err.h"
#include "lwip/dns.h"
#include "lwip/dhcp.h"
#include "netif/etharp.h"
#include "shared/netutils/netutils.h"
#include "shared/netutils/dhcpserver.h"
#include "esp_hosted.pb-c.h"
#include "esp_hosted_hal.h"
#include "esp_hosted_stack.h"
#include "esp_hosted_netif.h"
#include "esp_hosted_wifi.h"
#include "esp_hosted_internal.h"
static esp_hosted_state_t esp_state;
static ProtobufCAllocator protobuf_alloc = {
.alloc = &esp_hosted_hal_alloc,
.free = &esp_hosted_hal_free,
.allocator_data = NULL,
};
static void esp_hosted_macstr_to_bytes(const uint8_t *mac_str, size_t mac_len, uint8_t *mac_out) {
uint8_t byte = 0;
for (int i = 0; i < mac_len; i++) {
char c = mac_str[i];
if (c >= '0' && c <= '9') {
byte = (byte << 4) | (c - '0');
} else if (c >= 'a' && c <= 'f') {
byte = (byte << 4) | (c - 'a' + 10);
} else if (c >= 'A' && c <= 'F') {
byte = (byte << 4) | (c - 'A' + 10);
}
if (c == ':' || (i + 1) == mac_len) {
*mac_out++ = byte;
byte = 0;
}
}
}
// to avoid bleeding the protocol buffer API into the public interface, convert esp_hosted_security_t
// to/from CtrlWifiSecProt here.
static esp_hosted_security_t sec_prot_to_hosted_security(CtrlWifiSecProt sec_prot)
{
switch (sec_prot) {
case CTRL__WIFI_SEC_PROT__Open:
return ESP_HOSTED_SEC_OPEN;
case CTRL__WIFI_SEC_PROT__WEP:
return ESP_HOSTED_SEC_WEP;
case CTRL__WIFI_SEC_PROT__WPA_PSK:
return ESP_HOSTED_SEC_WPA_PSK;
case CTRL__WIFI_SEC_PROT__WPA2_PSK:
return ESP_HOSTED_SEC_WPA2_PSK;
case CTRL__WIFI_SEC_PROT__WPA_WPA2_PSK:
return ESP_HOSTED_SEC_WPA_WPA2_PSK;
case CTRL__WIFI_SEC_PROT__WPA2_ENTERPRISE:
return ESP_HOSTED_SEC_WPA2_ENTERPRISE;
case CTRL__WIFI_SEC_PROT__WPA3_PSK:
return ESP_HOSTED_SEC_WPA3_PSK;
case CTRL__WIFI_SEC_PROT__WPA2_WPA3_PSK:
return ESP_HOSTED_SEC_WPA2_WPA3_PSK;
default:
return ESP_HOSTED_SEC_INVALID;
}
}
static CtrlWifiSecProt hosted_security_to_sec_prot(esp_hosted_security_t hosted_security)
{
switch (hosted_security) {
case ESP_HOSTED_SEC_OPEN:
return CTRL__WIFI_SEC_PROT__Open;
case ESP_HOSTED_SEC_WEP:
return CTRL__WIFI_SEC_PROT__WEP;
case ESP_HOSTED_SEC_WPA_PSK:
return CTRL__WIFI_SEC_PROT__WPA_PSK;
case ESP_HOSTED_SEC_WPA2_PSK:
return CTRL__WIFI_SEC_PROT__WPA2_PSK;
case ESP_HOSTED_SEC_WPA_WPA2_PSK:
return CTRL__WIFI_SEC_PROT__WPA_WPA2_PSK;
case ESP_HOSTED_SEC_WPA2_ENTERPRISE:
return CTRL__WIFI_SEC_PROT__WPA2_ENTERPRISE;
case ESP_HOSTED_SEC_WPA3_PSK:
return CTRL__WIFI_SEC_PROT__WPA3_PSK;
case ESP_HOSTED_SEC_WPA2_WPA3_PSK:
return CTRL__WIFI_SEC_PROT__WPA2_WPA3_PSK;
default:
abort(); // Range should be checked by the caller, making this unreachable
}
}
uint16_t esp_hosted_checksum(esp_header_t *esp_header) {
uint16_t checksum = 0;
esp_header->checksum = 0;
uint8_t *buf = (uint8_t *)esp_header;
for (size_t i = 0; i < (esp_header->len + sizeof(esp_header_t)); i++) {
checksum += buf[i];
}
return checksum;
}
#if ESP_HOSTED_DEBUG
static void esp_hosted_dump_header(esp_header_t *esp_header) {
static const char *if_strs[] = { "STA", "AP", "SERIAL", "HCI", "PRIV", "TEST" };
if (esp_header->if_type > ESP_HOSTED_MAX_IF) {
return;
}
debug_printf("esp header: if %s_IF length %d offset %d checksum %d seq %d flags %x\n",
if_strs[esp_header->if_type], esp_header->len, esp_header->offset,
esp_header->checksum, esp_header->seq_num, esp_header->flags);
if (esp_header->if_type == ESP_HOSTED_SERIAL_IF) {
tlv_header_t *tlv_header = (tlv_header_t *)(esp_header->payload);
debug_printf("tlv header: ep_type %d ep_length %d ep_value %.8s data_type %d data_length %d\n",
tlv_header->ep_type, tlv_header->ep_length,
tlv_header->ep_value, tlv_header->data_type, tlv_header->data_length);
}
}
#endif
static int32_t esp_hosted_resp_value(CtrlMsg *ctrl_msg) {
// Each response struct return value is located at a different offset,
// the following array maps response CtrlMsgs to return values (resp)
// offsets within each response struct.
const static size_t ctrl_msg_resp_offset[] = {
offsetof(CtrlMsgRespGetMacAddress, resp),
offsetof(CtrlMsgRespSetMacAddress, resp),
offsetof(CtrlMsgRespGetMode, resp),
offsetof(CtrlMsgRespSetMode, resp),
offsetof(CtrlMsgRespScanResult, resp),
offsetof(CtrlMsgRespGetAPConfig, resp),
offsetof(CtrlMsgRespConnectAP, resp),
offsetof(CtrlMsgRespGetStatus, resp),
offsetof(CtrlMsgRespGetSoftAPConfig, resp),
offsetof(CtrlMsgRespSetSoftAPVendorSpecificIE, resp),
offsetof(CtrlMsgRespStartSoftAP, resp),
offsetof(CtrlMsgRespSoftAPConnectedSTA, resp),
offsetof(CtrlMsgRespGetStatus, resp),
offsetof(CtrlMsgRespSetMode, resp),
offsetof(CtrlMsgRespGetMode, resp),
offsetof(CtrlMsgRespOTABegin, resp),
offsetof(CtrlMsgRespOTAWrite, resp),
offsetof(CtrlMsgRespOTAEnd, resp),
offsetof(CtrlMsgRespSetWifiMaxTxPower, resp),
offsetof(CtrlMsgRespGetWifiCurrTxPower, resp),
offsetof(CtrlMsgRespConfigHeartbeat, resp),
};
int32_t resp = -1;
size_t index = ctrl_msg->msg_id - CTRL_MSG_ID__Resp_Base;
// All types of messages share the same payload base address.
if (ctrl_msg->resp_get_mac_address != NULL &&
ctrl_msg->msg_type == CTRL_MSG_TYPE__Resp &&
index > 0 && index <= MP_ARRAY_SIZE(ctrl_msg_resp_offset)) {
// Return the response struct's return value.
size_t offset = ctrl_msg_resp_offset[index - 1];
resp = *((int32_t *)((char *)ctrl_msg->resp_get_mac_address + offset));
}
return resp;
}
static int esp_hosted_request(CtrlMsgId msg_id, void *ctrl_payload) {
CtrlMsg ctrl_msg = {0};
ctrl_msg__init(&ctrl_msg);
ctrl_msg.msg_id = msg_id;
ctrl_msg.payload_case = msg_id;
// All types of messages share the same payload base address.
ctrl_msg.req_get_mac_address = ctrl_payload;
// Pack protobuf
size_t payload_size = ctrl_msg__get_packed_size(&ctrl_msg);
if ((payload_size + sizeof(tlv_header_t)) > ESP_FRAME_MAX_PAYLOAD) {
error_printf("esp_hosted_request() payload size > max payload %d\n", msg_id);
return -1;
}
esp_header_t *esp_header = (esp_header_t *)(esp_state.buf);
tlv_header_t *tlv_header = (tlv_header_t *)(esp_header->payload);
esp_header->if_type = ESP_HOSTED_SERIAL_IF;
esp_header->if_num = 0;
esp_header->flags = 0;
esp_header->len = payload_size + sizeof(tlv_header_t);
esp_header->offset = sizeof(esp_header_t);
esp_header->seq_num = esp_state.seq_num++;
tlv_header->ep_type = TLV_HEADER_TYPE_EP;
tlv_header->ep_length = 8;
memcpy(tlv_header->ep_value, TLV_HEADER_EP_RESP, 8);
tlv_header->data_type = TLV_HEADER_TYPE_DATA;
tlv_header->data_length = payload_size;
ctrl_msg__pack(&ctrl_msg, tlv_header->data);
esp_header->checksum = esp_hosted_checksum(esp_header);
size_t frame_size = (sizeof(esp_header_t) + esp_header->len + 3) & ~3U;
if (esp_hosted_hal_spi_transfer(esp_state.buf, NULL, frame_size) != 0) {
error_printf("esp_hosted_request() request %d failed\n", msg_id);
return -1;
}
return 0;
}
static CtrlMsg *esp_hosted_response(CtrlMsgId msg_id, uint32_t timeout) {
CtrlMsg *ctrl_msg = NULL;
for (mp_uint_t start = mp_hal_ticks_ms(); ; mp_hal_delay_ms(10)) {
if (!esp_hosted_stack_empty(&esp_state.stack)) {
ctrl_msg = esp_hosted_stack_pop(&esp_state.stack, true);
if (ctrl_msg->msg_id == msg_id) {
ctrl_msg = esp_hosted_stack_pop(&esp_state.stack, false);
break;
}
debug_printf("esp_hosted_response() waiting for id %lu last id %lu\n", msg_id, ctrl_msg->msg_id);
ctrl_msg = NULL;
}
if (timeout == 0) {
// Request expected a sync response.
return NULL;
}
// Check timeout.
if ((mp_hal_ticks_ms() - start) >= timeout) {
return NULL;
}
MICROPY_EVENT_POLL_HOOK
}
// If message type is a response, check the response struct's return value.
if (ctrl_msg->msg_type == CTRL_MSG_TYPE__Resp && esp_hosted_resp_value(ctrl_msg) != 0) {
error_printf("esp_hosted_response() response %d failed %d\n", msg_id, esp_hosted_resp_value(ctrl_msg));
ctrl_msg__free_unpacked(ctrl_msg, &protobuf_alloc);
return NULL;
}
return ctrl_msg;
}
static int esp_hosted_ctrl(CtrlMsgId req_id, void *req_payload, CtrlMsg **resp_msg) {
if (esp_hosted_request(req_id, req_payload) != 0) {
return -1;
}
uint32_t resp_id = (req_id - CTRL_MSG_ID__Req_Base) + CTRL_MSG_ID__Resp_Base;
if ((*resp_msg = esp_hosted_response(resp_id, ESP_SYNC_REQ_TIMEOUT)) == NULL) {
return -1;
}
return 0;
}
int esp_hosted_wifi_poll(void) {
size_t offset = 0;
esp_header_t *esp_header = (esp_header_t *)(esp_state.buf);
tlv_header_t *tlv_header = (tlv_header_t *)(esp_header->payload);
if (!(esp_state.flags & ESP_HOSTED_FLAGS_INIT) || !esp_hosted_hal_data_ready()) {
return 0;
}
do {
esp_header_t *frag_header = (esp_header_t *)(esp_state.buf + offset);
if ((ESP_STATE_BUF_SIZE - offset) < ESP_FRAME_MAX_SIZE) {
// This shouldn't happen, but if it did stop polling.
error_printf("esp_hosted_poll() spi buffer overflow offs %d\n", offset);
return -1;
}
if (esp_hosted_hal_spi_transfer(NULL, esp_state.buf + offset, ESP_FRAME_MAX_SIZE) != 0) {
error_printf("esp_hosted_poll() spi transfer failed\n");
return 0;
}
if (frag_header->len == 0 ||
frag_header->len > ESP_FRAME_MAX_PAYLOAD ||
frag_header->offset != sizeof(esp_header_t)) {
// Invalid or empty packet, just ignore it silently.
warn_printf("esp_hosted_poll() invalid frame size %d offset %d\n",
esp_header->len, esp_header->offset);
return 0;
}
uint16_t checksum = frag_header->checksum;
frag_header->checksum = esp_hosted_checksum(frag_header);
if (frag_header->checksum != checksum) {
warn_printf("esp_hosted_poll() invalid checksum, expected %d\n", checksum);
return 0;
}
if (offset) {
// Combine fragmented packet
if ((esp_header->seq_num + 1) != frag_header->seq_num) {
error_printf("esp_hosted_poll() fragmented frame sequence mismatch\n");
return 0;
}
esp_header->len += frag_header->len;
esp_header->seq_num = frag_header->seq_num;
esp_header->flags = frag_header->flags;
info_printf("esp_hosted_poll() received fragmented packet %d\n", frag_header->len);
// Append the current fragment's payload to the previous one.
memcpy(esp_state.buf + offset, frag_header->payload, frag_header->len);
}
offset = sizeof(esp_header_t) + esp_header->len;
} while ((esp_header->flags & ESP_FRAME_FLAGS_FRAGMENT));
#if ESP_HOSTED_DEBUG
esp_hosted_dump_header(esp_header);
#endif
switch (esp_header->if_type) {
case ESP_HOSTED_STA_IF:
case ESP_HOSTED_AP_IF: {
// Networking traffic
uint32_t itf = esp_header->if_type;
if (netif_is_link_up(&esp_state.netif[itf])) {
if (esp_hosted_netif_input(&esp_state, itf, esp_header->payload, esp_header->len) != 0) {
error_printf("esp_hosted_poll() netif input failed\n");
return -1;
}
debug_printf("esp_hosted_poll() eth frame input %d\n", esp_header->len);
}
return 0;
}
case ESP_HOSTED_PRIV_IF: {
esp_event_t *priv_event = (esp_event_t *)(esp_header->payload);
if (esp_header->priv_pkt_type == ESP_PACKET_TYPE_EVENT &&
priv_event->event_type == ESP_PRIV_EVENT_INIT) {
esp_state.chip_id = priv_event->event_data[2];
esp_state.spi_clk = priv_event->event_data[5];
esp_state.chip_flags = priv_event->event_data[8];
info_printf("esp_hosted_poll() chip id %d spi_mhz %d caps 0x%x\n",
esp_state.chip_id, esp_state.spi_clk, esp_state.chip_flags);
}
return 0;
}
case ESP_HOSTED_HCI_IF:
case ESP_HOSTED_TEST_IF:
case ESP_HOSTED_MAX_IF:
error_printf("esp_hosted_poll() unexpected interface type %d\n", esp_header->if_type);
return 0;
case ESP_HOSTED_SERIAL_IF:
// Requires further processing
break;
}
CtrlMsg *ctrl_msg = ctrl_msg__unpack(&protobuf_alloc, tlv_header->data_length, tlv_header->data);
if (ctrl_msg == NULL) {
error_printf("esp_hosted_poll() failed to unpack protobuf\n");
return 0;
}
if (ctrl_msg->msg_type == CTRL_MSG_TYPE__Event) {
switch (ctrl_msg->msg_id) {
case CTRL_MSG_ID__Event_ESPInit:
esp_state.flags |= ESP_HOSTED_FLAGS_ACTIVE;
break;
case CTRL_MSG_ID__Event_Heartbeat:
esp_state.last_hb_ms = mp_hal_ticks_ms();
info_printf("esp_hosted_poll() heartbeat %lu\n", esp_state.last_hb_ms);
return 0;
case CTRL_MSG_ID__Event_StationDisconnectFromAP:
esp_state.flags &= ~ESP_HOSTED_FLAGS_STA_CONNECTED;
return 0;
case CTRL_MSG_ID__Event_StationDisconnectFromESPSoftAP:
return 0;
default:
error_printf("esp_hosted_poll() unexpected event %d\n", ctrl_msg->msg_id);
return 0;
}
}
// Responses that should be handled here.
if (ctrl_msg->msg_type == CTRL_MSG_TYPE__Resp) {
switch (ctrl_msg->msg_id) {
case CTRL_MSG_ID__Resp_ConnectAP: {
if (esp_hosted_resp_value(ctrl_msg) == 0) {
esp_state.flags |= ESP_HOSTED_FLAGS_STA_CONNECTED;
}
ctrl_msg__free_unpacked(ctrl_msg, &protobuf_alloc);
debug_printf("esp_hosted_poll() state %d\n", esp_state.flags);
return 0;
}
default:
break;
}
}
// A control message resp/event will be pushed on the stack for further processing.
if (!esp_hosted_stack_push(&esp_state.stack, ctrl_msg)) {
error_printf("esp_hosted_poll() message stack full\n");
return -1;
}
debug_printf("esp_hosted_poll() pushed msg_type %lu msg_id %lu\n", ctrl_msg->msg_type, ctrl_msg->msg_id);
return 0;
}
int esp_hosted_wifi_init(uint32_t itf) {
if (esp_state.flags == ESP_HOSTED_FLAGS_RESET) {
// Init state
memset(&esp_state, 0, sizeof(esp_hosted_state_t));
esp_hosted_stack_init(&esp_state.stack);
// Low-level pins and SPI init, memory pool allocation etc...
if (esp_hosted_hal_init(ESP_HOSTED_MODE_WIFI) != 0) {
return -1;
}
// Allow polling the bus.
esp_state.flags |= ESP_HOSTED_FLAGS_INIT;
CtrlMsg *ctrl_msg = NULL;
// Wait for an ESPInit control event.
ctrl_msg = esp_hosted_response(CTRL_MSG_ID__Event_ESPInit, ESP_SYNC_REQ_TIMEOUT);
if (ctrl_msg == NULL) {
return -1;
}
ctrl_msg__free_unpacked(ctrl_msg, &protobuf_alloc);
// Set WiFi mode to STA/AP.
CtrlMsgReqSetMode ctrl_payload;
ctrl_msg__req__set_mode__init(&ctrl_payload);
ctrl_payload.mode = CTRL__WIFI_MODE__APSTA;
if (esp_hosted_ctrl(CTRL_MSG_ID__Req_SetWifiMode, &ctrl_payload, &ctrl_msg) != 0) {
return -1;
}
ctrl_msg__free_unpacked(ctrl_msg, &protobuf_alloc);
info_printf("esp_hosted_init() device initialized\n");
}
if (!netif_is_link_up(&esp_state.netif[itf])) {
// Init lwip netif, and start DHCP client/server.
esp_hosted_netif_init(&esp_state, itf);
info_printf("esp_hosted_init() initialized itf %lu\n", itf);
}
// Re/enable IRQ pin.
esp_hosted_hal_irq_enable(true);
return 0;
}
int esp_hosted_wifi_disable(uint32_t itf) {
// Remove netif
esp_hosted_netif_deinit(&esp_state, itf);
if (itf == ESP_HOSTED_STA_IF) {
esp_state.flags &= ~ESP_HOSTED_FLAGS_STA_CONNECTED;
} else {
esp_state.flags &= ~ESP_HOSTED_FLAGS_AP_STARTED;
}
info_printf("esp_hosted_deinit() deinitialized itf %lu\n", itf);
return 0;
}
int esp_hosted_wifi_deinit(void) {
if (esp_state.flags & ESP_HOSTED_FLAGS_INIT) {
// Remove network interfaces
esp_hosted_wifi_disable(ESP_HOSTED_STA_IF);
esp_hosted_wifi_disable(ESP_HOSTED_AP_IF);
// Reset state
memset(&esp_state, 0, sizeof(esp_hosted_state_t));
esp_hosted_stack_init(&esp_state.stack);
info_printf("esp_hosted_deinit() deinitialized\n");
}
return 0;
}
void *esp_hosted_wifi_get_netif(uint32_t itf) {
return &esp_state.netif[itf];
}
int esp_hosted_wifi_get_mac(int itf, uint8_t *mac) {
CtrlMsgReqGetMacAddress ctrl_payload;
ctrl_msg__req__get_mac_address__init(&ctrl_payload);
ctrl_payload.mode = (itf == ESP_HOSTED_STA_IF) ? CTRL__WIFI_MODE__STA : CTRL__WIFI_MODE__AP;
CtrlMsg *ctrl_msg = NULL;
if (esp_hosted_ctrl(CTRL_MSG_ID__Req_GetMACAddress, &ctrl_payload, &ctrl_msg) != 0) {
error_printf("esp_hosted_get_mac() request failed\n");
return -1;
}
ProtobufCBinaryData macstr = ctrl_msg->resp_get_mac_address->mac;
if (macstr.data) {
esp_hosted_macstr_to_bytes(macstr.data, macstr.len, mac);
}
ctrl_msg__free_unpacked(ctrl_msg, &protobuf_alloc);
return 0;
}
int esp_hosted_wifi_connect(const char *ssid, const char *bssid, esp_hosted_security_t security, const char *key, uint16_t channel) {
CtrlMsgReqConnectAP ctrl_payload;
ctrl_msg__req__connect_ap__init(&ctrl_payload);
if (security >= ESP_HOSTED_SEC_MAX) {
// Note: this argument is otherwise unused(!)
return -1;
}
ctrl_payload.ssid = (char *)ssid;
ctrl_payload.bssid = (char *)bssid;
ctrl_payload.pwd = (char *)key;
ctrl_payload.is_wpa3_supported = false;
ctrl_payload.listen_interval = 0;
if (esp_hosted_request(CTRL_MSG_ID__Req_ConnectAP, &ctrl_payload) != 0) {
return -1;
}
return 0;
}
int esp_hosted_wifi_start_ap(const char *ssid, esp_hosted_security_t security, const char *key, uint16_t channel) {
CtrlMsgReqStartSoftAP ctrl_payload;
ctrl_msg__req__start_soft_ap__init(&ctrl_payload);
if (security >= ESP_HOSTED_SEC_MAX) {
return -1;
}
ctrl_payload.ssid = (char *)ssid;
ctrl_payload.pwd = (char *)key;
ctrl_payload.chnl = channel;
ctrl_payload.sec_prot = hosted_security_to_sec_prot(security);
ctrl_payload.max_conn = ESP_HOSTED_MAX_AP_CLIENTS;
ctrl_payload.ssid_hidden = false;
ctrl_payload.bw = CTRL__WIFI_BW__HT40;
CtrlMsg *ctrl_msg = NULL;
if (esp_hosted_ctrl(CTRL_MSG_ID__Req_StartSoftAP, &ctrl_payload, &ctrl_msg) != 0) {
return -1;
}
ctrl_msg__free_unpacked(ctrl_msg, &protobuf_alloc);
esp_state.flags |= ESP_HOSTED_FLAGS_AP_STARTED;
return 0;
}
int esp_hosted_wifi_disconnect(uint32_t itf) {
CtrlMsg *ctrl_msg = NULL;
CtrlMsgReqGetStatus ctrl_payload;
ctrl_msg__req__get_status__init(&ctrl_payload);
if (itf == ESP_HOSTED_STA_IF) {
esp_state.flags &= ~ESP_HOSTED_FLAGS_STA_CONNECTED;
if (esp_hosted_ctrl(CTRL_MSG_ID__Req_DisconnectAP, &ctrl_payload, &ctrl_msg) != 0) {
return -1;
}
} else {
esp_state.flags &= ~ESP_HOSTED_FLAGS_AP_STARTED;
if (esp_hosted_ctrl(CTRL_MSG_ID__Req_StopSoftAP, &ctrl_payload, &ctrl_msg) != 0) {
return -1;
}
}
ctrl_msg__free_unpacked(ctrl_msg, &protobuf_alloc);
return 0;
}
int esp_hosted_wifi_link_status(uint32_t itf) {
return netif_is_link_up(&esp_state.netif[itf]);
}
int esp_hosted_wifi_is_connected(uint32_t itf) {
if (!esp_hosted_wifi_link_status(itf)) {
return false;
}
if (itf == ESP_HOSTED_AP_IF) {
return esp_state.flags & ESP_HOSTED_FLAGS_AP_STARTED;
}
if ((esp_state.flags & ESP_HOSTED_FLAGS_STA_CONNECTED) &&
((esp_state.flags & ESP_HOSTED_FLAGS_STATIC_IP) ||
dhcp_supplied_address(&esp_state.netif[itf]))) {
return true;
}
return false;
}
int esp_hosted_wifi_get_stations(uint8_t *sta_list, size_t *sta_count) {
CtrlMsgReqSoftAPConnectedSTA ctrl_payload;
ctrl_msg__req__soft_apconnected_sta__init(&ctrl_payload);
CtrlMsg *ctrl_msg = NULL;
if (esp_hosted_ctrl(CTRL_MSG_ID__Req_GetSoftAPConnectedSTAList, &ctrl_payload, &ctrl_msg) != 0) {
return -1;
}
CtrlMsgRespSoftAPConnectedSTA *resp = ctrl_msg->resp_softap_connected_stas_list;
*sta_count = resp->n_stations;
for (size_t i = 0; i < resp->n_stations; i++) {
ProtobufCBinaryData mac = resp->stations[i]->mac;
esp_hosted_macstr_to_bytes(mac.data, mac.len, &sta_list[i * 6]);
}
ctrl_msg__free_unpacked(ctrl_msg, &protobuf_alloc);
return 0;
}
int esp_hosted_wifi_netinfo(esp_hosted_netinfo_t *netinfo) {
CtrlMsgReqGetAPConfig ctrl_payload;
ctrl_msg__req__get_apconfig__init(&ctrl_payload);
CtrlMsg *ctrl_msg = NULL;
if (esp_hosted_ctrl(CTRL_MSG_ID__Req_GetAPConfig, &ctrl_payload, &ctrl_msg) != 0) {
return -1;
}
netinfo->rssi = ctrl_msg->resp_get_ap_config->rssi;
netinfo->security = sec_prot_to_hosted_security(ctrl_msg->resp_get_ap_config->sec_prot);
netinfo->channel = ctrl_msg->resp_get_ap_config->chnl;
ProtobufCBinaryData ssid = ctrl_msg->resp_get_ap_config->ssid;
if (ssid.data) {
size_t ssid_len = MIN(ssid.len, (ESP_HOSTED_MAX_SSID_LEN - 1));
memcpy(netinfo->ssid, ssid.data, ssid_len);
netinfo->ssid[ssid_len] = 0;
}
ProtobufCBinaryData bssid = ctrl_msg->resp_get_ap_config->bssid;
if (bssid.data) {
esp_hosted_macstr_to_bytes(bssid.data, bssid.len, netinfo->bssid);
}
ctrl_msg__free_unpacked(ctrl_msg, &protobuf_alloc);
return 0;
}
int esp_hosted_wifi_scan(esp_hosted_scan_callback_t scan_callback, void *arg, uint32_t timeout) {
CtrlMsgReqScanResult ctrl_payload;
ctrl_msg__req__scan_result__init(&ctrl_payload);
CtrlMsg *ctrl_msg = NULL;
if (esp_hosted_ctrl(CTRL_MSG_ID__Req_GetAPScanList, &ctrl_payload, &ctrl_msg) != 0) {
return -MP_ETIMEDOUT;
}
CtrlMsgRespScanResult *rp = ctrl_msg->resp_scan_ap_list;
for (int i = 0; i < rp->count; i++) {
esp_hosted_scan_result_t result = {0};
result.rssi = rp->entries[i]->rssi;
result.security = sec_prot_to_hosted_security(rp->entries[i]->sec_prot);
result.channel = rp->entries[i]->chnl;
if (rp->entries[i]->bssid.data) {
esp_hosted_macstr_to_bytes(rp->entries[i]->bssid.data, rp->entries[i]->bssid.len, result.bssid);
}
if (rp->entries[i]->ssid.len) {
size_t ssid_len = MIN(rp->entries[i]->ssid.len, (ESP_HOSTED_MAX_SSID_LEN - 1));
memcpy(result.ssid, rp->entries[i]->ssid.data, ssid_len);
result.ssid[ssid_len] = 0;
}
scan_callback(&result, arg);
}
ctrl_msg__free_unpacked(ctrl_msg, &protobuf_alloc);
return 0;
}
#endif // MICROPY_PY_NETWORK_ESP_HOSTED
Reference in New Issue View Git Blame Copy Permalink