pimoroni-pico/drivers/esp32spi/esp32spi.cpp

#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,
  };

  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)) {
      WARN("Response Err: 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: SET_PIN_MODE\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)) {
      WARN("Response Err: SET_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)) {
      WARN("Response Err: SET_ANALOG_WRITE\n");
      data = WL_FAILURE;
    }
    driver.esp_deselect();
  }

  bool Esp32Spi::digital_read(uint8_t pin) {
    driver.wait_for_esp_select();

    // Send Command
    driver.send_cmd(SET_DIGITAL_READ, SpiDrv::PARAM_NUMS_1);
    driver.send_param(&pin, 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(SET_DIGITAL_READ, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
      WARN("Response Err: SET_DIGITAL_READ\n");
    }
    driver.esp_deselect();

    return (data == 1);
  }

  uint16_t Esp32Spi::analog_read(uint8_t pin, uint8_t atten) {
    driver.wait_for_esp_select();

    // Send Command
    driver.send_cmd(SET_ANALOG_READ, SpiDrv::PARAM_NUMS_2);
    driver.send_param(&pin, 1, SpiDrv::NO_LAST_PARAM);
    driver.send_param(&atten, 1, SpiDrv::LAST_PARAM);

    // Pad to multiple of 4
    driver.read_byte();

    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(SET_ANALOG_READ, SpiDrv::PARAM_NUMS_1, (uint8_t*)&data, &data_len)) {
      WARN("Response Err: SET_ANALOG_READ\n");
    }
    driver.esp_deselect();

    return (uint16_t)data; //ESP only has a 12-bit ADC
  }

  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)) {
      WARN("Response Err: START_SERVER_TCP\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(const 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;
  }

  void Esp32Spi::wifi_set_ent_identity(const std::string identity) {
    driver.wait_for_esp_select();

    // Send Command
    driver.send_cmd(WPA2_ENT_SET_IDENTITY, SpiDrv::PARAM_NUMS_1);
    driver.send_param((uint8_t*)identity.data(), identity.length(), SpiDrv::LAST_PARAM);
    driver.pad_to_multiple_of_4(5 + identity.length());

    driver.esp_deselect();
    driver.wait_for_esp_select();

    // Wait for reply
    uint8_t data = 0 , data_len = 0;
    if(!driver.wait_response_cmd(WPA2_ENT_SET_IDENTITY, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
      WARN("Response Err: WPA2_ENT_SET_IDENTITY\n");
      data = WL_FAILURE;
    }
    driver.esp_deselect();
  }

  void Esp32Spi::wifi_set_ent_username(const std::string username) {
    driver.wait_for_esp_select();

    // Send Command
    driver.send_cmd(WPA2_ENT_SET_USERNAME, SpiDrv::PARAM_NUMS_1);
    driver.send_param((uint8_t*)username.data(), username.length(), SpiDrv::LAST_PARAM);
    driver.pad_to_multiple_of_4(5 + username.length());

    driver.esp_deselect();
    driver.wait_for_esp_select();

    // Wait for reply
    uint8_t data = 0 , data_len = 0;
    if(!driver.wait_response_cmd(WPA2_ENT_SET_USERNAME, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
      WARN("Response Err: WPA2_ENT_SET_USERNAME\n");
      data = WL_FAILURE;
    }
    driver.esp_deselect();
  }

  void Esp32Spi::wifi_set_ent_password(const std::string password) {
    driver.wait_for_esp_select();

    // Send Command
    driver.send_cmd(WPA2_ENT_SET_PASSWORD, SpiDrv::PARAM_NUMS_1);
    driver.send_param((uint8_t*)password.data(), password.length(), SpiDrv::LAST_PARAM);
    driver.pad_to_multiple_of_4(5 + password.length());

    driver.esp_deselect();
    driver.wait_for_esp_select();

    // Wait for reply
    uint8_t data = 0 , data_len = 0;
    if(!driver.wait_response_cmd(WPA2_ENT_SET_PASSWORD, SpiDrv::PARAM_NUMS_1, &data, &data_len)) {
      WARN("Response Err: WPA2_ENT_SET_PASSWORD\n");
      data = WL_FAILURE;
    }
    driver.esp_deselect();
  }

  void Esp32Spi::wifi_set_ent_enable() {
    driver.wait_for_esp_select();

    // Send Command
    driver.send_cmd(WPA2_ENT_ENABLE, 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(WPA2_ENT_ENABLE, SpiDrv::PARAM_NUMS_1, (uint8_t*)&data, &data_len)) {
      WARN("Response Err: WPA2_ENT_ENABLE\n");
    }
    driver.esp_deselect();
  }
}