mirrors
/
pimoroni-pico
mirror of https://github.com/pimoroni/pimoroni-pico.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
pimoroni-pico/drivers/esp32spi/esp32spi.cpp

1279 lines
36 KiB
C++
Raw Blame History

#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, //TODO No Matching Function
SET_CERT_KEY = 0x41, //TODO No Matching Function
//NULL, NULL,
SEND_DATA_TCP = 0x44,
GET_DATABUF_TCP = 0x45,
INSERT_DATABUF = 0x46,
//NULL, NULL, NULL,
WPA2_ENT_SET_IDENTITY = 0x4a, //TODO No Matching Function //NOTE Exposed in CPy
WPA2_ENT_SET_USERNAME = 0x4b, //TODO No Matching Function //NOTE Exposed in CPy
WPA2_ENT_SET_PASSWORD = 0x4c, //TODO No Matching Function //NOTE Exposed in CPy
WPA2_ENT_SET_CA_CERT = 0x4d, //TODO No Matching Function
WPA2_ENT_SET_CERT_KEY = 0x4e, //TODO No Matching Function
WPA2_ENT_ENABLE = 0x4f, //TODO No Matching Function //NOTE Exposed in CPy
// 0x50 -> 0x5f
SET_PIN_MODE = 0x50,
SET_DIGITAL_WRITE = 0x51,
SET_ANALOG_WRITE = 0x52,
SET_DIGITAL_READ = 0x53, //TODO No Matching Function //NOTE Exposed in CPy
SET_ANALOG_READ = 0x54, //TODO No Matching Function //NOTE Exposed in CPy
};
bool Esp32Spi::init() {
driver.init();
driver.reset();
return true;
}
void Esp32Spi::get_network_data(uint8_t *ip_out, uint8_t *mask_out, uint8_t *gwip_out) {
SpiDrv::tParam params[SpiDrv::PARAM_NUMS_3] = { {0, ip_out},
{0, mask_out},
{0, gwip_out} };
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_IP_ADDR, SpiDrv::PARAM_NUMS_1);
driver.send_byte_param(SpiDrv::DUMMY_DATA, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
driver.wait_response_params(GET_IP_ADDR, SpiDrv::PARAM_NUMS_3, params);
driver.esp_deselect();
}
void Esp32Spi::get_remote_data(uint8_t sock, uint8_t *ip_out, uint8_t *port_out) {
SpiDrv::tParam params[SpiDrv::PARAM_NUMS_2] = { {0, ip_out},
{0, port_out} };
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_REMOTE_DATA, SpiDrv::PARAM_NUMS_1);
driver.send_param(&sock, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
//Wait for reply
driver.wait_response_params(GET_REMOTE_DATA, SpiDrv::PARAM_NUMS_2, params);
driver.esp_deselect();
}
int8_t Esp32Spi::wifi_set_network(const std::string ssid) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_NET, SpiDrv::PARAM_NUMS_1);
driver.send_param((const uint8_t*)ssid.data(), ssid.length(), SpiDrv::LAST_PARAM);
driver.pad_to_multiple_of_4(5 + ssid.length());
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(SET_NET, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: SET_NET\n");
data = WL_FAILURE;
}
driver.esp_deselect();
return (data == WIFI_SPI_ACK) ? WL_SUCCESS : WL_FAILURE;
}
int8_t Esp32Spi::wifi_set_passphrase(const std::string ssid, const std::string passphrase) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_PASSPHRASE, SpiDrv::PARAM_NUMS_2);
driver.send_param((const uint8_t*)ssid.data(), ssid.length(), SpiDrv::NO_LAST_PARAM);
driver.send_param((const uint8_t*)passphrase.data(), passphrase.length(), SpiDrv::LAST_PARAM);
driver.pad_to_multiple_of_4(6 + ssid.length() + passphrase.length());
driver.esp_deselect();
driver.wait_for_esp_select();
//Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(SET_PASSPHRASE, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: SET_PASSPHRASE\n");
data = WL_FAILURE;
}
driver.esp_deselect();
return data;
}
int8_t Esp32Spi::wifi_set_key(const std::string ssid, uint8_t key_idx, const std::string key) {
driver.wait_for_esp_select();
//Send Command
driver.send_cmd(SET_KEY, SpiDrv::PARAM_NUMS_3);
driver.send_param((uint8_t*)ssid.data(), ssid.length(), SpiDrv::NO_LAST_PARAM);
driver.send_param(&key_idx, KEY_IDX_LEN, SpiDrv::NO_LAST_PARAM);
driver.send_param((uint8_t*)key.data(), key.length(), SpiDrv::LAST_PARAM);
driver.pad_to_multiple_of_4(8 + ssid.length() + key.length());
driver.esp_deselect();
driver.wait_for_esp_select();
//Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(SET_KEY, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: SET_KEY\n");
data = WL_FAILURE;
}
driver.esp_deselect();
return data;
}
void Esp32Spi::config(uint8_t valid_params, uint32_t local_ip, uint32_t gateway, uint32_t subnet) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_IP_CONFIG, SpiDrv::PARAM_NUMS_4);
driver.send_param((uint8_t*)&valid_params, 1, SpiDrv::NO_LAST_PARAM);
driver.send_param((uint8_t*)&local_ip, 4, SpiDrv::NO_LAST_PARAM);
driver.send_param((uint8_t*)&gateway, 4, SpiDrv::NO_LAST_PARAM);
driver.send_param((uint8_t*)&subnet, 4, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(SET_IP_CONFIG, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: SET_IP_CONFIG\n");
data = WL_FAILURE;
}
driver.esp_deselect();
}
void Esp32Spi::set_dns(uint8_t valid_params, uint32_t dns_server1, uint32_t dns_server2) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_DNS_CONFIG, SpiDrv::PARAM_NUMS_3);
driver.send_param((uint8_t*)&valid_params, 1, SpiDrv::NO_LAST_PARAM);
driver.send_param((uint8_t*)&dns_server1, 4, SpiDrv::NO_LAST_PARAM);
driver.send_param((uint8_t*)&dns_server2, 4, SpiDrv::LAST_PARAM);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(SET_DNS_CONFIG, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: SET_DNS_CONFIG\n");
data = WL_FAILURE;
}
driver.esp_deselect();
}
void Esp32Spi::set_hostname(const std::string hostname) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_HOSTNAME, SpiDrv::PARAM_NUMS_1);
driver.send_param((uint8_t*)hostname.data(), hostname.length(), SpiDrv::LAST_PARAM);
driver.pad_to_multiple_of_4(5 + hostname.length());
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0 , data_len = 0;
if(!driver.wait_response_cmd(SET_HOSTNAME, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: SET_HOSTNAME\n");
data = WL_FAILURE;
}
driver.esp_deselect();
}
int8_t Esp32Spi::disconnect() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(DISCONNECT, SpiDrv::PARAM_NUMS_1);
driver.send_byte_param(SpiDrv::DUMMY_DATA, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
int8_t result = driver.wait_response_cmd(DISCONNECT, SpiDrv::PARAM_NUMS_1, &data, &data_len);
driver.esp_deselect();
return result;
}
uint8_t Esp32Spi::get_connection_status() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_CONN_STATUS, SpiDrv::PARAM_NUMS_0);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = WL_FAILURE, data_len = 0;
driver.wait_response_cmd(GET_CONN_STATUS, SpiDrv::PARAM_NUMS_1, &data, &data_len);
driver.esp_deselect();
return data;
}
uint8_t* Esp32Spi::get_mac_address() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_MAC_ADDR, SpiDrv::PARAM_NUMS_1);
driver.send_byte_param(SpiDrv::DUMMY_DATA, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data_len = 0;
driver.wait_response_cmd(GET_MAC_ADDR, SpiDrv::PARAM_NUMS_1, mac, &data_len);
driver.esp_deselect();
return mac;
}
void Esp32Spi::get_ip_address(IPAddress &ip_out) {
get_network_data(local_ip, subnet_mask, gateway_ip);
ip_out = local_ip;
}
void Esp32Spi::get_subnet_mask(IPAddress &mask_out) {
get_network_data(local_ip, subnet_mask, gateway_ip);
mask_out = subnet_mask;
}
void Esp32Spi::get_gateway_ip(IPAddress &ip_out) {
get_network_data(local_ip, subnet_mask, gateway_ip);
ip_out = gateway_ip;
}
std::string Esp32Spi::get_current_ssid() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_CURR_SSID, SpiDrv::PARAM_NUMS_1);
driver.send_byte_param(SpiDrv::DUMMY_DATA, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
memset(ssid, 0x00, sizeof(ssid));
// Wait for reply
uint8_t data_len = 0;
driver.wait_response_cmd(GET_CURR_SSID, SpiDrv::PARAM_NUMS_1, (uint8_t*)ssid, &data_len);
driver.esp_deselect();
return ssid;
}
uint8_t* Esp32Spi::get_current_bssid() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_CURR_BSSID, SpiDrv::PARAM_NUMS_1);
driver.send_byte_param(SpiDrv::DUMMY_DATA, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data_len = 0;
driver.wait_response_cmd(GET_CURR_BSSID, SpiDrv::PARAM_NUMS_1, bssid, &data_len);
driver.esp_deselect();
return bssid;
}
int32_t Esp32Spi::get_current_rssi() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_CURR_RSSI, SpiDrv::PARAM_NUMS_1);
driver.send_byte_param(SpiDrv::DUMMY_DATA, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
int32_t rssi = 0;
uint8_t data_len = 0;
driver.wait_response_cmd(GET_CURR_RSSI, SpiDrv::PARAM_NUMS_1, (uint8_t*)&rssi, &data_len);
driver.esp_deselect();
return rssi;
}
uint8_t Esp32Spi::get_current_encryption_type() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_CURR_ENCT, SpiDrv::PARAM_NUMS_1);
driver.send_byte_param(SpiDrv::DUMMY_DATA, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t enc_type = 0, data_len = 0;
driver.wait_response_cmd(GET_CURR_ENCT, SpiDrv::PARAM_NUMS_1, &enc_type, &data_len);
driver.esp_deselect();
return enc_type;
}
int8_t Esp32Spi::start_scan_networks() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(START_SCAN_NETWORKS, SpiDrv::PARAM_NUMS_0);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(START_SCAN_NETWORKS, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: START_SCAN_NETWORKS\n");
data = WL_FAILURE;
}
driver.esp_deselect();
return ((int8_t)data == WL_FAILURE) ? data : (int8_t)WL_SUCCESS;
}
uint8_t Esp32Spi::get_scan_networks() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SCAN_NETWORKS, SpiDrv::PARAM_NUMS_0);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t ssid_list_num = 0;
driver.wait_response(SCAN_NETWORKS, &ssid_list_num, (uint8_t**)network_ssid, WL_NETWORKS_LIST_MAXNUM);
driver.esp_deselect();
return 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];
}
uint8_t Esp32Spi::get_enc_type_networks(uint8_t network_item) {
if(network_item >= WL_NETWORKS_LIST_MAXNUM)
return ENC_TYPE_UNKNOWN;
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_IDX_ENCT, SpiDrv::PARAM_NUMS_1);
driver.send_param(&network_item, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t enc_type = 0, data_len = 0;
driver.wait_response_cmd(GET_IDX_ENCT, SpiDrv::PARAM_NUMS_1, &enc_type, &data_len);
driver.esp_deselect();
return 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;
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_IDX_BSSID, SpiDrv::PARAM_NUMS_1);
driver.send_param(&network_item, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data_len = 0;
driver.wait_response_cmd(GET_IDX_BSSID, SpiDrv::PARAM_NUMS_1, (uint8_t*)bssid_out, &data_len);
driver.esp_deselect();
return bssid_out;
}
uint8_t Esp32Spi::get_channel_networks(uint8_t network_item) {
if(network_item >= WL_NETWORKS_LIST_MAXNUM)
return 0;
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_IDX_CHANNEL, SpiDrv::PARAM_NUMS_1);
driver.send_param(&network_item, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t channel = 0, data_len = 0;
driver.wait_response_cmd(GET_IDX_CHANNEL, SpiDrv::PARAM_NUMS_1, &channel, &data_len);
driver.esp_deselect();
return channel;
}
int32_t Esp32Spi::get_rssi_networks(uint8_t network_item) {
if(network_item >= WL_NETWORKS_LIST_MAXNUM)
return 0;
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_IDX_RSSI, SpiDrv::PARAM_NUMS_1);
driver.send_param(&network_item, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
int32_t network_rssi = 0;
uint8_t data_len = 0;
driver.wait_response_cmd(GET_IDX_RSSI, SpiDrv::PARAM_NUMS_1, (uint8_t*)&network_rssi, &data_len);
driver.esp_deselect();
return network_rssi;
}
bool Esp32Spi::req_host_by_name(const std::string hostname) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(REQ_HOST_BY_NAME, SpiDrv::PARAM_NUMS_1);
driver.send_param((uint8_t*)hostname.data(), hostname.length(), SpiDrv::LAST_PARAM);
driver.pad_to_multiple_of_4(5 + hostname.length());
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
bool result = driver.wait_response_cmd(REQ_HOST_BY_NAME, SpiDrv::PARAM_NUMS_1, &data, &data_len);
driver.esp_deselect();
if(result) {
result = (data == 1);
}
return result;
}
bool Esp32Spi::get_host_by_name(IPAddress& ip_out) {
IPAddress dummy(0xFF,0xFF,0xFF,0xFF);
bool result = false;
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_HOST_BY_NAME, SpiDrv::PARAM_NUMS_0);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t ip_addr[WL_IPV4_LENGTH];
uint8_t data_len = 0;
if(!driver.wait_response_cmd(GET_HOST_BY_NAME, SpiDrv::PARAM_NUMS_1, ip_addr, &data_len)) {
WARN("Response Err: GET_HOST_BY_NAME\n");
}
else {
ip_out = ip_addr;
result = (ip_out != dummy);
}
driver.esp_deselect();
return result;
}
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() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_FW_VERSION, SpiDrv::PARAM_NUMS_0);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data_len = 0;
if(!driver.wait_response_cmd(GET_FW_VERSION, SpiDrv::PARAM_NUMS_1, (uint8_t*)fw_version, &data_len)) {
WARN("Response Err: GET_FW_VERSION\n");
}
driver.esp_deselect();
return fw_version;
}
uint32_t Esp32Spi::get_time() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_TIME, SpiDrv::PARAM_NUMS_0);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint32_t data = 0;
uint8_t data_len = 0;
if(!driver.wait_response_cmd(GET_TIME, SpiDrv::PARAM_NUMS_1, (uint8_t*)&data, &data_len)) {
WARN("Response Err: GET_TIME\n");
}
driver.esp_deselect();
return data;
}
void Esp32Spi::set_power_mode(uint8_t mode) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_POWER_MODE, SpiDrv::PARAM_NUMS_1);
driver.send_param(&mode, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
driver.wait_response_cmd(SET_POWER_MODE, SpiDrv::PARAM_NUMS_1, &data, &data_len);
driver.esp_deselect();
}
int8_t Esp32Spi::wifi_set_ap_network(const std::string ssid, uint8_t channel) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_AP_NET, SpiDrv::PARAM_NUMS_2);
driver.send_param((uint8_t*)ssid.data(), ssid.length(), SpiDrv::NO_LAST_PARAM);
driver.send_param(&channel, 1, SpiDrv::LAST_PARAM);
driver.pad_to_multiple_of_4(3 + ssid.length());
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(SET_AP_NET, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: SET_AP_NET\n");
data = WL_FAILURE;
}
driver.esp_deselect();
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) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_AP_PASSPHRASE, SpiDrv::PARAM_NUMS_3);
driver.send_param((uint8_t*)ssid.data(), ssid.length(), SpiDrv::NO_LAST_PARAM);
driver.send_param((uint8_t*)passphrase.data(), passphrase.length(), SpiDrv::NO_LAST_PARAM);
driver.send_param(&channel, 1, SpiDrv::LAST_PARAM);
driver.pad_to_multiple_of_4(4 + ssid.length() + passphrase.length());
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(SET_AP_PASSPHRASE, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: SET_AP_PASSPHRASE\n");
data = WL_FAILURE;
}
driver.esp_deselect();
return data;
}
int16_t Esp32Spi::ping(uint32_t ip_address, uint8_t ttl) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(PING, SpiDrv::PARAM_NUMS_2);
driver.send_param((uint8_t*)&ip_address, sizeof(ip_address), SpiDrv::NO_LAST_PARAM);
driver.send_param(&ttl, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint16_t data;
uint8_t data_len = 0;
if(!driver.wait_response_cmd(PING, SpiDrv::PARAM_NUMS_1, (uint8_t*)&data, &data_len)) {
WARN("Response Err: PING\n");
data = WL_PING_ERROR;
}
driver.esp_deselect();
return data;
}
void Esp32Spi::debug(uint8_t on) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_DEBUG, SpiDrv::PARAM_NUMS_1);
driver.send_param(&on, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
driver.wait_response_cmd(SET_DEBUG, SpiDrv::PARAM_NUMS_1, &data, &data_len);
driver.esp_deselect();
}
float Esp32Spi::get_temperature() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_TEMPERATURE, SpiDrv::PARAM_NUMS_0);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
float data = 0;
uint8_t data_len = 0;
if(!driver.wait_response_cmd(GET_TEMPERATURE, SpiDrv::PARAM_NUMS_1, (uint8_t*)&data, &data_len)) {
printf("error get_temperature\n");
}
driver.esp_deselect();
return data;
}
void Esp32Spi::pin_mode(uint8_t pin, uint8_t mode) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_PIN_MODE, SpiDrv::PARAM_NUMS_2);
driver.send_param(&pin, 1, SpiDrv::NO_LAST_PARAM);
driver.send_param(&mode, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(SET_PIN_MODE, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: WL_FAILURE\n");
data = WL_FAILURE;
}
driver.esp_deselect();
}
void Esp32Spi::digital_write(uint8_t pin, uint8_t value) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_DIGITAL_WRITE, SpiDrv::PARAM_NUMS_2);
driver.send_param(&pin, 1, SpiDrv::NO_LAST_PARAM);
driver.send_param(&value, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(SET_DIGITAL_WRITE, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
printf("error digital_write\n");
data = WL_FAILURE;
}
driver.esp_deselect();
}
void Esp32Spi::analog_write(uint8_t pin, uint8_t value) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SET_ANALOG_WRITE, SpiDrv::PARAM_NUMS_2);
driver.send_param(&pin, 1, SpiDrv::NO_LAST_PARAM);
driver.send_param(&value, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(SET_ANALOG_WRITE, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
printf("error analog_write\n");
data = WL_FAILURE;
}
driver.esp_deselect();
}
void Esp32Spi::start_server(uint16_t port, uint8_t sock, uint8_t protocol_mode) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(START_SERVER_TCP, SpiDrv::PARAM_NUMS_3);
driver.send_param(port, SpiDrv::NO_LAST_PARAM);
driver.send_param(&sock, 1, SpiDrv::NO_LAST_PARAM);
driver.send_param(&protocol_mode, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(START_SERVER_TCP, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
printf("No response to server start/n");
}
driver.esp_deselect();
}
void Esp32Spi::start_server(uint32_t ip_address, uint16_t port, uint8_t sock, uint8_t protocol_mode) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(START_SERVER_TCP, SpiDrv::PARAM_NUMS_4);
driver.send_param((uint8_t*)&ip_address, sizeof(ip_address), SpiDrv::NO_LAST_PARAM);
driver.send_param(port, SpiDrv::NO_LAST_PARAM);
driver.send_param(&sock, 1, SpiDrv::NO_LAST_PARAM);
driver.send_param(&protocol_mode, 1, SpiDrv::LAST_PARAM);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(START_SERVER_TCP, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: START_SERVER_TCP\n");
}
driver.esp_deselect();
}
void Esp32Spi::start_client(uint32_t ip_address, uint16_t port, uint8_t sock, uint8_t protocol_mode) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(START_CLIENT_TCP, SpiDrv::PARAM_NUMS_4);
driver.send_param((uint8_t*)&ip_address, sizeof(ip_address), SpiDrv::NO_LAST_PARAM);
driver.send_param(port, SpiDrv::NO_LAST_PARAM);
driver.send_param(&sock, 1, SpiDrv::NO_LAST_PARAM);
driver.send_param(&protocol_mode, 1, SpiDrv::LAST_PARAM);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(START_CLIENT_TCP, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: START_CLIENT_TCP\n");
}
driver.esp_deselect();
}
void Esp32Spi::start_client(std::string host, uint32_t ip_address, uint16_t port, uint8_t sock, uint8_t protocol_mode) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(START_CLIENT_TCP, SpiDrv::PARAM_NUMS_5);
driver.send_param((uint8_t*)host.data(), host.length(), SpiDrv::NO_LAST_PARAM);
driver.send_param((uint8_t*)&ip_address, sizeof(ip_address), SpiDrv::NO_LAST_PARAM);
driver.send_param(port, SpiDrv::NO_LAST_PARAM);
driver.send_param(&sock, 1, SpiDrv::NO_LAST_PARAM);
driver.send_param(&protocol_mode, 1, SpiDrv::LAST_PARAM);
driver.pad_to_multiple_of_4(17 + host.length());
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(START_CLIENT_TCP, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: START_CLIENT_TCP\n");
}
driver.esp_deselect();
}
void Esp32Spi::stop_client(uint8_t sock) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(STOP_CLIENT_TCP, SpiDrv::PARAM_NUMS_1);
driver.send_param(&sock, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(STOP_CLIENT_TCP, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: STOP_CLIENT_TCP\n");
}
driver.esp_deselect();
}
uint8_t Esp32Spi::get_server_state(uint8_t sock) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_STATE_TCP, SpiDrv::PARAM_NUMS_1);
driver.send_param(&sock, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(GET_STATE_TCP, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: GET_STATE_TCP\n");
}
driver.esp_deselect();
return data;
}
uint8_t Esp32Spi::get_client_state(uint8_t sock) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_CLIENT_STATE_TCP, SpiDrv::PARAM_NUMS_1);
driver.send_param(&sock, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_cmd(GET_CLIENT_STATE_TCP, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: GET_CLIENT_STATE_TCP\n");
}
driver.esp_deselect();
return data;
}
uint16_t Esp32Spi::avail_data(uint8_t sock) {
if(!driver.available()) {
return 0;
}
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(AVAIL_DATA_TCP, SpiDrv::PARAM_NUMS_1);
driver.send_param(&sock, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint16_t len = 0;
uint8_t data_len = 0;
driver.wait_response_cmd(AVAIL_DATA_TCP, SpiDrv::PARAM_NUMS_1, (uint8_t*)&len, &data_len);
driver.esp_deselect();
return len;
}
uint8_t Esp32Spi::avail_server(uint8_t sock) {
if(!driver.available()) {
return 255;
}
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(AVAIL_DATA_TCP, SpiDrv::PARAM_NUMS_1);
driver.send_param(&sock, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint16_t socket = 0;
uint8_t data_len = 0;
driver.wait_response_cmd(AVAIL_DATA_TCP, SpiDrv::PARAM_NUMS_1, (uint8_t*)&socket, &data_len);
driver.esp_deselect();
return socket;
}
bool Esp32Spi::get_data(uint8_t sock, uint8_t *data_out, uint8_t peek) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_DATA_TCP, SpiDrv::PARAM_NUMS_2);
driver.send_param(&sock, 1, SpiDrv::NO_LAST_PARAM);
driver.send_param(peek, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_data8(GET_DATA_TCP, &data, &data_len)) {
WARN("Response Err: GET_DATA_TCP\n");
}
driver.esp_deselect();
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) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_DATABUF_TCP, SpiDrv::PARAM_NUMS_2);
driver.send_buffer(&sock, 1);
driver.send_buffer((uint8_t *)data_len_out, sizeof(*data_len_out), SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
if(!driver.wait_response_data16(GET_DATABUF_TCP, data_out, data_len_out)) {
WARN("Response Err: GET_DATABUF_TCP\n");
}
driver.esp_deselect();
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) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(INSERT_DATABUF, SpiDrv::PARAM_NUMS_2);
driver.send_buffer(&sock, 1, SpiDrv::NO_LAST_PARAM);
driver.send_buffer((uint8_t *)data_in, len, SpiDrv::LAST_PARAM);
driver.pad_to_multiple_of_4(9 + len);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_data8(INSERT_DATABUF, &data, &data_len)) {
WARN("Response Err: INSERT_DATABUF\n");
}
driver.esp_deselect();
if(data_len != 0) {
return (data == 1);
}
return false;
}
bool Esp32Spi::send_udp_data(uint8_t sock) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SEND_DATA_UDP, SpiDrv::PARAM_NUMS_1);
driver.send_param(&sock, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = 0, data_len = 0;
if(!driver.wait_response_data8(SEND_DATA_UDP, &data, &data_len)) {
WARN("Response Err: SEND_DATA_UDP\n");
}
driver.esp_deselect();
if(data_len != 0) {
return (data == 1);
}
return false;
}
uint16_t Esp32Spi::send_data(uint8_t sock, const uint8_t *data_in, uint16_t len) {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(SEND_DATA_TCP, SpiDrv::PARAM_NUMS_2);
driver.send_buffer(&sock, sizeof(sock));
driver.send_buffer((uint8_t *)data_in, len, SpiDrv::LAST_PARAM);
driver.pad_to_multiple_of_4(9 + len);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint16_t data = 0;
uint8_t data_len = 0;
if(!driver.wait_response_data8(SEND_DATA_TCP, (uint8_t*)&data, &data_len)) {
WARN("Response Err: SEND_DATA_TCP\n");
}
driver.esp_deselect();
return data;
}
uint8_t Esp32Spi::check_data_sent(uint8_t sock) {
const uint16_t TIMEOUT_DATA_SENT = 25;
uint16_t timeout = 0;
uint8_t data = 0, data_len = 0;
do {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(DATA_SENT_TCP, SpiDrv::PARAM_NUMS_1);
driver.send_param(&sock, 1, SpiDrv::LAST_PARAM);
// Pad to multiple of 4
driver.read_byte();
driver.read_byte();
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
if(!driver.wait_response_cmd(DATA_SENT_TCP, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
WARN("Response Err: DATA_SENT_TCP/n");
}
driver.esp_deselect();
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() {
driver.wait_for_esp_select();
// Send Command
driver.send_cmd(GET_SOCKET, SpiDrv::PARAM_NUMS_0);
driver.esp_deselect();
driver.wait_for_esp_select();
// Wait for reply
uint8_t data = -1, data_len = 0;
driver.wait_response_cmd(GET_SOCKET, SpiDrv::PARAM_NUMS_1, &data, &data_len);
driver.esp_deselect();
return data;
}
}
Reference in New Issue View Git Blame Copy Permalink