mirror
/
pimoroni-pico
kopia lustrzana https://github.com/pimoroni/pimoroni-pico
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
pimoroni-pico/drivers/esp32spi/esp32spi.cpp

951 wiersze
28 KiB
C++
Czysty Bezpośredni odnośnik Wina Historia

#include "esp32spi.hpp"
namespace pimoroni {
enum cmd {
// 0x10 -> 0x1f
SET_NET = 0x10,
SET_PASSPHRASE = 0x11,
SET_KEY = 0x12,
//NULL
SET_IP_CONFIG = 0x14,
SET_DNS_CONFIG = 0x15,
SET_HOSTNAME = 0x16,
SET_POWER_MODE = 0x17,
SET_AP_NET = 0x18,
SET_AP_PASSPHRASE = 0x19,
SET_DEBUG = 0x1a,
GET_TEMPERATURE = 0x1b,
//NULL, NULL, NULL, NULL,
// 0x20 -> 0x2f
GET_CONN_STATUS = 0x20,
GET_IP_ADDR = 0x21,
GET_MAC_ADDR = 0x22,
GET_CURR_SSID = 0x23,
GET_CURR_BSSID = 0x24,
GET_CURR_RSSI = 0x25,
GET_CURR_ENCT = 0x26,
SCAN_NETWORKS = 0x27,
START_SERVER_TCP = 0x28,
GET_STATE_TCP = 0x29,
DATA_SENT_TCP = 0x2a,
AVAIL_DATA_TCP = 0x2b,
GET_DATA_TCP = 0x2c,
START_CLIENT_TCP = 0x2d,
STOP_CLIENT_TCP = 0x2e,
GET_CLIENT_STATE_TCP = 0x2f,
// 0x30 -> 0x3f
DISCONNECT = 0x30,
//NULL,
GET_IDX_RSSI = 0x32,
GET_IDX_ENCT = 0x33,
REQ_HOST_BY_NAME = 0x34,
GET_HOST_BY_NAME = 0x35,
START_SCAN_NETWORKS = 0x36,
GET_FW_VERSION = 0x37,
//NULL,
SEND_DATA_UDP = 0x39,
GET_REMOTE_DATA = 0x3a,
GET_TIME = 0x3b,
GET_IDX_BSSID = 0x3c,
GET_IDX_CHANNEL = 0x3d,
PING = 0x3e,
GET_SOCKET = 0x3f,
// 0x40 -> 0x4f
SET_CLIENT_CERT = 0x40, //NOTE No matching function
SET_CERT_KEY = 0x41, //NOTE No matching function
//NULL, NULL,
SEND_DATA_TCP = 0x44,
GET_DATABUF_TCP = 0x45,
INSERT_DATABUF = 0x46,
//NULL, NULL, NULL,
WPA2_ENT_SET_IDENTITY = 0x4a,
WPA2_ENT_SET_USERNAME = 0x4b,
WPA2_ENT_SET_PASSWORD = 0x4c,
WPA2_ENT_SET_CA_CERT = 0x4d, //NOTE Not functional in Nina FW
WPA2_ENT_SET_CERT_KEY = 0x4e, //NOTE Not functional in Nina FW
WPA2_ENT_ENABLE = 0x4f,
// 0x50 -> 0x5f
SET_PIN_MODE = 0x50,
SET_DIGITAL_WRITE = 0x51,
SET_ANALOG_WRITE = 0x52,
SET_DIGITAL_READ = 0x53,
SET_ANALOG_READ = 0x54,
SET_WAKE_PIN = 0x55,
SET_LIGHT_SLEEP = 0x56,
SET_DEEP_SLEEP = 0x57,
};
bool Esp32Spi::init() {
driver.init();
driver.reset();
return true;
}
bool Esp32Spi::get_network_data(uint8_t *ip_out, uint8_t *mask_out, uint8_t *gwip_out) {
SpiDrv::outParam params_out[SpiDrv::PARAM_NUMS_3] = { {0, ip_out},
{0, mask_out},
{0, gwip_out} };
return driver.send_command(GET_IP_ADDR, params_out, SpiDrv::PARAM_NUMS_3);
}
bool Esp32Spi::get_remote_data(uint8_t sock, uint8_t *ip_out, uint8_t *port_out) {
SpiDrv::outParam params_out[SpiDrv::PARAM_NUMS_2] = { {0, ip_out},
{0, port_out} };
return driver.send_command(GET_REMOTE_DATA, params_out, SpiDrv::PARAM_NUMS_2);
}
int8_t Esp32Spi::wifi_set_network(const std::string ssid) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&ssid)
};
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(SET_NET, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_NET\n");
}
return (data == WIFI_SPI_ACK) ? WL_SUCCESS : WL_FAILURE;
}
int8_t Esp32Spi::wifi_set_passphrase(const std::string ssid, const std::string passphrase) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&ssid),
SpiDrv::build_param(&passphrase)
};
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(SET_PASSPHRASE, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_PASSPHRASE\n");
}
return data;
}
int8_t Esp32Spi::wifi_set_key(const std::string ssid, uint8_t key_idx, const std::string key) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&ssid),
SpiDrv::build_param(&key_idx),
SpiDrv::build_param(&key)
};
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(SET_KEY, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_KEY\n");
}
return data;
}
void Esp32Spi::config(uint8_t valid_params, uint32_t local_ip, uint32_t gateway, uint32_t subnet) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&valid_params),
SpiDrv::build_param(&local_ip),
SpiDrv::build_param(&gateway),
SpiDrv::build_param(&subnet)
};
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(SET_IP_CONFIG, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_IP_CONFIG\n");
}
}
void Esp32Spi::set_dns(uint8_t valid_params, uint32_t dns_server1, uint32_t dns_server2) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&valid_params),
SpiDrv::build_param(&dns_server1),
SpiDrv::build_param(&dns_server2)
};
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(SET_DNS_CONFIG, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_DNS_CONFIG\n");
}
}
void Esp32Spi::set_hostname(const std::string hostname) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&hostname)
};
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(SET_HOSTNAME, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_HOSTNAME\n");
}
}
int8_t Esp32Spi::disconnect() {
SpiDrv::inParam params[] = {
{.type = SpiDrv::PARAM_DUMMY}
};
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(DISCONNECT, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:DISCONNECT\n");
}
return data;
}
uint8_t Esp32Spi::get_connection_status() {
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(GET_CONN_STATUS, nullptr, 0, &data, &data_len)) {
WARN("Error:GET_CONN_STATUS\n");
}
return data;
}
uint8_t* Esp32Spi::get_mac_address() {
SpiDrv::inParam params[] = {
{.type = SpiDrv::PARAM_DUMMY}
};
uint16_t data_len = 0;
driver.send_command(GET_MAC_ADDR, params, PARAM_COUNT(params), (uint8_t *)&mac, &data_len);
return mac;
}
bool Esp32Spi::get_ip_address(IPAddress &ip_out) {
if (get_network_data(local_ip, subnet_mask, gateway_ip)) {
ip_out = local_ip;
return true;
}
return false;
}
bool Esp32Spi::get_subnet_mask(IPAddress &mask_out) {
if (get_network_data(local_ip, subnet_mask, gateway_ip)) {
mask_out = subnet_mask;
return true;
}
return false;
}
bool Esp32Spi::get_gateway_ip(IPAddress &ip_out) {
if (get_network_data(local_ip, subnet_mask, gateway_ip)) {
ip_out = gateway_ip;
return true;
}
return false;
}
std::string Esp32Spi::get_current_ssid() {
SpiDrv::inParam params[] = {
{.type = SpiDrv::PARAM_DUMMY}
};
uint16_t data_len = 0;
memset(ssid, 0x00, sizeof(ssid));
driver.send_command(GET_CURR_SSID, params, PARAM_COUNT(params), (uint8_t *)&ssid, &data_len);
return ssid;
}
uint8_t* Esp32Spi::get_current_bssid() {
SpiDrv::inParam params[] = {
{.type = SpiDrv::PARAM_DUMMY}
};
uint16_t data_len = 0;
memset(bssid, 0x00, sizeof(bssid));
driver.send_command(GET_CURR_BSSID, params, PARAM_COUNT(params), (uint8_t *)&bssid, &data_len);
return bssid;
}
int32_t Esp32Spi::get_current_rssi() {
SpiDrv::inParam params[] = {
{.type = SpiDrv::PARAM_DUMMY}
};
uint16_t data_len = 0;
int32_t rssi = 0;
driver.send_command(GET_CURR_RSSI, params, PARAM_COUNT(params), (uint8_t *)&rssi, &data_len);
return rssi;
}
uint8_t Esp32Spi::get_current_encryption_type() {
SpiDrv::inParam params[] = {
{.type = SpiDrv::PARAM_DUMMY}
};
uint16_t data_len = 0;
uint8_t enc_type = 0;
driver.send_command(GET_CURR_ENCT, params, PARAM_COUNT(params), &enc_type, &data_len);
return enc_type;
}
int8_t Esp32Spi::start_scan_networks() {
/*uint8_t data = 0;
uint16_t data_len = 0;
driver.send_command(START_SCAN_NETWORKS, &data, &data_len, false);
return ((int8_t)data == WL_FAILURE) ? data : (int8_t)WL_SUCCESS;*/
// This command is a very misleading no-op, see: https://github.com/adafruit/nina-fw/blob/d73fe315cc7f9148a0918490d3b75430c8444bf7/main/CommandHandler.cpp#L336-L345
return WL_SUCCESS;
}
uint8_t Esp32Spi::get_scan_networks() {
uint16_t ssid_list_num = 0;
driver.send_command(SCAN_NETWORKS, nullptr, 0, (uint8_t *)network_ssid, &ssid_list_num, SpiDrv::RESPONSE_TYPE_NORMAL);
return (uint8_t)ssid_list_num;
}
const char* Esp32Spi::get_ssid_networks(uint8_t network_item) {
if(network_item >= WL_NETWORKS_LIST_MAXNUM) {
return nullptr;
}
return network_ssid[network_item];
}
wl_enc_type Esp32Spi::get_enc_type_networks(uint8_t network_item) {
if(network_item >= WL_NETWORKS_LIST_MAXNUM) {
return ENC_TYPE_UNKNOWN;
}
SpiDrv::inParam params[] = {
SpiDrv::build_param(&network_item)
};
uint8_t enc_type = 255;
uint16_t data_len = 0;
driver.send_command(GET_IDX_ENCT, params, PARAM_COUNT(params), &enc_type, &data_len);
return (wl_enc_type)enc_type;
}
uint8_t* Esp32Spi::get_bssid_networks(uint8_t network_item, uint8_t* bssid_out) {
if(network_item >= WL_NETWORKS_LIST_MAXNUM) {
return nullptr;
}
SpiDrv::inParam params[] = {
SpiDrv::build_param(&network_item)
};
uint16_t data_len = 0;
driver.send_command(GET_IDX_BSSID, params, 1, bssid_out, &data_len);
return bssid_out;
}
uint8_t Esp32Spi::get_channel_networks(uint8_t network_item) {
if(network_item >= WL_NETWORKS_LIST_MAXNUM) {
return 0;
}
SpiDrv::inParam params[] = {
SpiDrv::build_param(&network_item)
};
uint8_t channel = 0;
uint16_t data_len = 0;
driver.send_command(GET_IDX_CHANNEL, params, 1, &channel, &data_len);
return channel;
}
int32_t Esp32Spi::get_rssi_networks(uint8_t network_item) {
if(network_item >= WL_NETWORKS_LIST_MAXNUM) {
return 0;
}
SpiDrv::inParam params[] = {
SpiDrv::build_param(&network_item)
};
int32_t network_rssi = 0;
uint16_t data_len = 0;
driver.send_command(GET_IDX_CHANNEL, params, 1, (uint8_t*)&network_rssi, &data_len);
return network_rssi;
}
bool Esp32Spi::req_host_by_name(const std::string hostname) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&hostname)
};
uint8_t data = 0;
uint16_t data_len = 0;
bool result = driver.send_command(REQ_HOST_BY_NAME, params, 1, &data, &data_len);
return result && data == WL_SUCCESS;
}
bool Esp32Spi::get_host_by_name(IPAddress& ip_out) {
IPAddress dummy(0xFF,0xFF,0xFF,0xFF);
uint8_t ip_addr[WL_IPV4_LENGTH];
uint16_t data_len = 0;
if(!driver.send_command(GET_HOST_BY_NAME, nullptr, 0, (uint8_t *)&ip_addr, &data_len)) {
WARN("Error:GET_HOST_BY_NAME\n");
return false;
} else {
ip_out = ip_addr;
return (ip_out != dummy);
}
}
bool Esp32Spi::get_host_by_name(const std::string hostname, IPAddress& ip_out) {
if(req_host_by_name(hostname)) {
return get_host_by_name(ip_out);
}
else {
return false;
}
}
const char* Esp32Spi::get_fw_version() {
uint16_t data_len = 0;
if(!driver.send_command(GET_FW_VERSION, nullptr, 0, (uint8_t*)fw_version, &data_len)){
WARN("Error:GET_FW_VERSION\n");
}
return fw_version;
}
uint32_t Esp32Spi::get_time() {
uint32_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(GET_TIME, nullptr, 0, (uint8_t*)&data, &data_len)) {
WARN("Error:GET_TIME\n");
}
return data;
}
void Esp32Spi::set_power_mode(uint8_t mode) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&mode),
};
uint8_t data = 0;
uint16_t data_len = 0;
driver.send_command(SET_POWER_MODE, params, 1, &data, &data_len);
}
int8_t Esp32Spi::wifi_set_ap_network(const std::string ssid, uint8_t channel) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&ssid),
SpiDrv::build_param(&channel),
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(SET_AP_NET, params, 2, &data, &data_len)) {
WARN("Error:SET_AP_NET\n");
data = WL_FAILURE;
}
return (data == WIFI_SPI_ACK) ? WL_SUCCESS : WL_FAILURE;
}
int8_t Esp32Spi::wifi_set_ap_passphrase(const std::string ssid, const std::string passphrase, uint8_t channel) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&ssid),
SpiDrv::build_param(&passphrase),
SpiDrv::build_param(&channel)
};
int8_t data = WL_FAILURE;
uint16_t data_len = 0;
if(!driver.send_command(SET_AP_PASSPHRASE, params, PARAM_COUNT(params), (uint8_t*)&data, &data_len)) {
WARN("Error:SET_AP_PASSPHRASE\n");
}
return data;
}
int16_t Esp32Spi::ping(uint32_t ip_address, uint8_t ttl) {
// Ping a remote address.
// See: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L919-L935
SpiDrv::inParam params[] = {
SpiDrv::build_param(&ip_address),
SpiDrv::build_param(&ttl)
};
int16_t data = WL_FAILURE;
uint16_t data_len = 0;
if(!driver.send_command(PING, params, PARAM_COUNT(params), (uint8_t*)&data, &data_len)) {
WARN("Error:PING\n");
}
// Returns response time (presumably in milliseconds?)
return data;
}
void Esp32Spi::debug(uint8_t on) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&on)
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(SET_DEBUG, params, PARAM_COUNT(params), (uint8_t*)&data, &data_len)) {
WARN("Error:SET_DEBUG\n");
}
}
float Esp32Spi::get_temperature() {
// Get the ESP32 die temperature?
// This will *not* be ambient.
// See: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L239-L249
float data = WL_FAILURE;
uint16_t data_len = 0;
if(!driver.send_command(GET_TEMPERATURE, nullptr, 0, (uint8_t *)&data, &data_len)) {
WARN("Error:GET_TEMPERATURE\n");
}
return data;
}
void Esp32Spi::pin_mode(uint8_t pin, uint8_t mode) {
// Set the mode of an ESP32 GPIO pin.
// Uses the Arduino HAL "pinModes" internally.
// See: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L955-L967
SpiDrv::inParam params[] = {
SpiDrv::build_param(&pin),
SpiDrv::build_param(&mode)
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(SET_PIN_MODE, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_PIN_MODE\n");
data = WL_FAILURE;
}
}
void Esp32Spi::digital_write(uint8_t pin, uint8_t value) {
// Write a 0 or 1 to an ESP32 GPIO pin.
// Uses the Arduino HAL "digitalWrite" internally.
// See: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L969-L981
SpiDrv::inParam params[] = {
SpiDrv::build_param(&pin),
SpiDrv::build_param(&value),
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(SET_DIGITAL_WRITE, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_DIGITAL_WRITE\n");
data = WL_FAILURE; // ???
}
}
void Esp32Spi::analog_write(uint8_t pin, uint8_t value) {
// Write a 0 to 255 "analog" value to an ESP32 GPIO pin.
// Uses the Arduino HAL "analogWrite" internally.
// See: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L983-L995
SpiDrv::inParam params[] {
SpiDrv::build_param(&pin),
SpiDrv::build_param(&value)
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(SET_ANALOG_WRITE, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_ANALOG_WRITE\n");
data = WL_FAILURE;
}
}
bool Esp32Spi::digital_read(uint8_t pin) {
// Read a 0 (LOW) or 1 (HIGH) from an ESP32 GPIO pin.
// Uses the Arduino HAL "digitalRead" internally.
// See: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L997-L1008
SpiDrv::inParam params[] = {
SpiDrv::build_param(&pin)
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(SET_DIGITAL_READ, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_DIGITAL_READ\n");
}
return data == WL_SUCCESS;
}
uint16_t Esp32Spi::analog_read(uint8_t pin, uint8_t atten) {
// Read an analog value from an ESP32 GPIO pin.
// Uses the Arduino HAL "analogRead" internally.
// See: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L1010-L1023
SpiDrv::inParam params[] = {
SpiDrv::build_param(&pin),
SpiDrv::build_param(&atten)
};
uint32_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(SET_ANALOG_READ, params, PARAM_COUNT(params), (uint8_t*)&data, &data_len)) {
WARN("Error:SET_ANALOG_READ\n");
}
return (uint16_t)data; // ESP only has a 12-bit ADC but returns a uint32
}
void Esp32Spi::start_server(uint16_t port, uint8_t sock, uint8_t protocol_mode) {
port =__builtin_bswap16(port);
SpiDrv::inParam params[] = {
SpiDrv::build_param(&port),
SpiDrv::build_param(&sock),
SpiDrv::build_param(&protocol_mode),
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(START_SERVER_TCP, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:START_SERVER_TCP\n");
}
}
void Esp32Spi::start_server(uint32_t ip_address, uint16_t port, uint8_t sock, uint8_t protocol_mode) {
port =__builtin_bswap16(port);
SpiDrv::inParam params[] = {
SpiDrv::build_param(&ip_address),
SpiDrv::build_param(&port),
SpiDrv::build_param(&sock),
SpiDrv::build_param(&protocol_mode),
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(START_SERVER_TCP, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:START_SERVER_TCP\n");
}
}
void Esp32Spi::start_client(uint32_t ip_address, uint16_t port, uint8_t sock, uint8_t protocol_mode) {
port = __builtin_bswap16(port); // Don't ask, I'll cry
SpiDrv::inParam params[] = {
SpiDrv::build_param(&ip_address),
SpiDrv::build_param(&port),
SpiDrv::build_param(&sock),
SpiDrv::build_param(&protocol_mode)
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(START_CLIENT_TCP, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:START_CLIENT_TCP\n");
}
}
void Esp32Spi::start_client(const std::string host, uint32_t ip_address, uint16_t port, uint8_t sock, uint8_t protocol_mode) {
port = __builtin_bswap16(port); // Don't ask, I'll cry
SpiDrv::inParam params[] = {
SpiDrv::build_param(&host),
SpiDrv::build_param(&ip_address),
SpiDrv::build_param(&port),
SpiDrv::build_param(&sock),
SpiDrv::build_param(&protocol_mode)
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(START_CLIENT_TCP, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:START_CLIENT_TCP\n");
}
}
void Esp32Spi::stop_client(uint8_t sock) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&sock),
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(STOP_CLIENT_TCP, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:STOP_CLIENT_TCP\n");
}
}
uint8_t Esp32Spi::get_server_state(uint8_t sock) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&sock)
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(GET_STATE_TCP, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:GET_STATE_TCP\n");
}
return data;
}
uint8_t Esp32Spi::get_client_state(uint8_t sock) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&sock)
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(GET_CLIENT_STATE_TCP, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:GET_CLIENT_STATE_TCP\n");
}
return data;
}
uint16_t Esp32Spi::avail_data(uint8_t sock) {
if(!driver.available()) {
return 0;
}
SpiDrv::inParam params[] = {
SpiDrv::build_param(&sock),
};
uint16_t bytes_available = 0;
uint16_t data_len = 0;
driver.send_command(AVAIL_DATA_TCP, params, PARAM_COUNT(params), (uint8_t *)&bytes_available, &data_len);
return bytes_available;
}
uint8_t Esp32Spi::avail_server(uint8_t sock) {
// This function has a deliberate narrowing conversion from uint8_t to uint16_t
// see: https://github.com/adafruit/nina-fw/blob/d73fe315cc7f9148a0918490d3b75430c8444bf7/main/CommandHandler.cpp#L437-L498
if(!driver.available()) {
return 255;
}
SpiDrv::inParam params[] = {
SpiDrv::build_param(&sock),
};
uint16_t socket = 0;
uint16_t data_len = 0;
driver.send_command(AVAIL_DATA_TCP, params, PARAM_COUNT(params), (uint8_t *)&socket, &data_len);
return socket;
}
bool Esp32Spi::get_data(uint8_t sock, uint8_t *data_out, bool peek) {
// Peek or get a single byte of data
// see: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L500-L529
SpiDrv::inParam params[] = {
SpiDrv::build_param(&sock),
SpiDrv::build_param((uint8_t *)&peek),
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(GET_DATA_TCP, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:GET_DATA_TCP\n");
}
if(data_len != 0) {
*data_out = data;
return true;
}
return false;
}
bool Esp32Spi::get_data_buf(uint8_t sock, uint8_t *data_out, uint16_t *data_len_out) {
// Get the data buffer for TCP/UDP/TLS clients.
// see: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L870-L896
SpiDrv::inParam params[] = {
SpiDrv::build_param_buffer(&sock, 1),
SpiDrv::build_param_buffer((uint8_t *)&data_len_out, 2),
};
if(!driver.send_command(GET_DATABUF_TCP, params, PARAM_COUNT(params), data_out, data_len_out, SpiDrv::RESPONSE_TYPE_DATA16)) {
WARN("Error:GET_DATABUF_TCP\n");
}
if(*data_len_out != 0) {
return true;
}
return false;
}
bool Esp32Spi::insert_data_buf(uint8_t sock, const uint8_t *data_in, uint16_t len) {
// UDP only. Writes to the socket output buffer.
// See: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L898-L917
SpiDrv::inParam params[] = {
SpiDrv::build_param_buffer(&sock, 1),
SpiDrv::build_param_buffer(data_in, len),
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(INSERT_DATABUF, params, PARAM_COUNT(params), &data, &data_len, SpiDrv::RESPONSE_TYPE_DATA8)) {
WARN("Error:INSERT_DATABUF\n");
}
if(data_len != 0) {
return (data == 1);
}
return false;
}
bool Esp32Spi::send_udp_data(uint8_t sock) {
// UDP only. Writes the socket UDP end packet.
// See: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L763-L777
SpiDrv::inParam params[] = {
SpiDrv::build_param(&sock)
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(SEND_DATA_UDP, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SEND_DATA_UDP\n");
}
// Returns 1 if udps[socket].endPacket() returns true
return data_len && data == WL_SUCCESS;
}
uint16_t Esp32Spi::send_data(uint8_t sock, const uint8_t *data_in, uint16_t len) {
// Send a data buffer over TCP (server/client) or TLS type sockets
// See: https://github.com/adafruit/nina-fw/blob/104c48cb48e2a04c8a8009ef2db1b551414628a5/main/CommandHandler.cpp#L845-L868
SpiDrv::inParam params[] = {
SpiDrv::build_param_buffer(&sock, 1),
SpiDrv::build_param_buffer(data_in, len),
};
uint16_t bytes_written = 0;
uint16_t data_out_len = 0;
if(!driver.send_command(SEND_DATA_TCP, params, PARAM_COUNT(params), (uint8_t *)&bytes_written, &data_out_len, SpiDrv::RESPONSE_TYPE_DATA8)) {
WARN("Error:SEND_DATA_TCP\n");
}
// Returns the number of bytes written
return bytes_written;
}
uint8_t Esp32Spi::check_data_sent(uint8_t sock) {
const uint16_t TIMEOUT_DATA_SENT = 25;
SpiDrv::inParam params[] = {
SpiDrv::build_param(&sock)
};
uint16_t timeout = 0;
uint8_t data = 0;
uint16_t data_len = 0;
do {
if(!driver.send_command(DATA_SENT_TCP, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:DATA_SENT_TCP/n");
}
if(data)
timeout = 0;
else {
++timeout;
sleep_ms(100);
}
} while((data == 0) && (timeout < TIMEOUT_DATA_SENT));
return (timeout == TIMEOUT_DATA_SENT) ? 0 : 1;
}
uint8_t Esp32Spi::get_socket() {
uint8_t socket = -1;
uint16_t data_len = 0;
if(!driver.send_command(GET_SOCKET, nullptr, 0, &socket, &data_len)) {
WARN("Error:GET_SOCKET/n");
}
return socket;
}
void Esp32Spi::wifi_set_ent_identity(const std::string identity) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&identity)
};
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(WPA2_ENT_SET_IDENTITY, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:WPA2_ENT_SET_IDENTITY\n");
}
}
void Esp32Spi::wifi_set_ent_username(const std::string username) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&username)
};
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(WPA2_ENT_SET_USERNAME, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:WPA2_ENT_SET_USERNAME\n");
}
}
void Esp32Spi::wifi_set_ent_password(const std::string password) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&password)
};
uint8_t data;
uint16_t data_len = 0;
if (!driver.send_command(WPA2_ENT_SET_PASSWORD, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:WPA2_ENT_SET_PASSWORD\n");
}
}
void Esp32Spi::wifi_set_ent_enable() {
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(WPA2_ENT_ENABLE, nullptr, 0, &data, &data_len)) {
WARN("Error:WPA2_ENT_ENABLE\n");
}
}
void Esp32Spi::sleep_set_wake_pin(uint8_t wake_pin) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&wake_pin)
};
uint8_t data;
uint16_t data_len = 0;
if(!driver.send_command(SET_WAKE_PIN, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_WAKE_PIN\n");
}
}
void Esp32Spi::sleep_light() {
uint8_t data = 0;
uint16_t data_len = 0;
if (!driver.send_command(SET_LIGHT_SLEEP, nullptr, 0, &data, &data_len)) {
WARN("Error:SET_LIGHT_SLEEP_CMD\n");
} else {
// Because we still have a very murky separation of concerns between esp32spi and spi_drv
// we'll force the sleep state here, rather than have spi_drv understand this commmand
driver.sleep_state = SpiDrv::LIGHT_SLEEP;
}
}
void Esp32Spi::sleep_deep(uint8_t time) {
SpiDrv::inParam params[] = {
SpiDrv::build_param(&time)
};
uint8_t data = 0;
uint16_t data_len = 0;
if(!driver.send_command(SET_DEEP_SLEEP, params, PARAM_COUNT(params), &data, &data_len)) {
WARN("Error:SET_DEEP_SLEEP\n");
} else {
// Because we still have a very murky separation of concerns between esp32spi and spi_drv
// we'll force the sleep state here, rather than have spi_drv understand this commmand
driver.sleep_state = SpiDrv::DEEP_SLEEP;
}
}
}
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik