starred/OpenEPaperLink
1
0
Fork 0
mirror of https://github.com/OpenEPaperLink/OpenEPaperLink.git synced 2026-03-21 06:06:23 +01:00
Code Issues 826 Packages Projects Releases 10 Wiki Activity

added improv protocol for wifi provisioning

Browse Source
This commit is contained in:
Nic Limper
2023-07-19 17:27:00 +02:00
parent 5ba982cb47
commit 4eb89e9596
2 changed files with 417 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
ESP32_AP-Flasher/include/wifimanager.h
View File

@@ -1,3 +1,11 @@
#pragma once
#include <Arduino.h>
#include <cstdint>
#include <functional>
#include <string>
#include <vector>
#ifndef WIFI_MANAGER_H
#define WIFI_MANAGER_H
@@ -26,6 +34,8 @@ class WifiManager {
const int SERIAL_BUFFER_SIZE = 64;
char serialBuffer[64];
int serialIndex = 0;
uint8_t x_buffer[16];
uint8_t x_position = 0;
String WiFi_SSID();
String WiFi_psk();
@@ -47,3 +57,72 @@ class WifiManager {
};
#endif
// **** Improv Wi-Fi ****
// https://www.improv-wifi.com/
// https://github.com/jnthas/improv-wifi-demo
// http://www.apache.org/licenses/LICENSE-2.0
namespace improv {
enum Error : uint8_t {
ERROR_NONE = 0x00,
ERROR_INVALID_RPC = 0x01,
ERROR_UNKNOWN_RPC = 0x02,
ERROR_UNABLE_TO_CONNECT = 0x03,
ERROR_NOT_AUTHORIZED = 0x04,
ERROR_UNKNOWN = 0xFF,
};
enum State : uint8_t {
STATE_STOPPED = 0x00,
STATE_AWAITING_AUTHORIZATION = 0x01,
STATE_AUTHORIZED = 0x02,
STATE_PROVISIONING = 0x03,
STATE_PROVISIONED = 0x04,
};
enum Command : uint8_t {
UNKNOWN = 0x00,
WIFI_SETTINGS = 0x01,
IDENTIFY = 0x02,
GET_CURRENT_STATE = 0x02,
GET_DEVICE_INFO = 0x03,
GET_WIFI_NETWORKS = 0x04,
BAD_CHECKSUM = 0xFF,
};
static const uint8_t CAPABILITY_IDENTIFY = 0x01;
static const uint8_t IMPROV_SERIAL_VERSION = 1;
enum ImprovSerialType : uint8_t {
TYPE_CURRENT_STATE = 0x01,
TYPE_ERROR_STATE = 0x02,
TYPE_RPC = 0x03,
TYPE_RPC_RESPONSE = 0x04
};
struct ImprovCommand {
Command command;
std::string ssid;
std::string password;
};
ImprovCommand parse_improv_data(const std::vector<uint8_t> &data, bool check_checksum = true);
ImprovCommand parse_improv_data(const uint8_t *data, size_t length, bool check_checksum = true);
bool parse_improv_serial_byte(size_t position, uint8_t byte, const uint8_t *buffer,
std::function<bool(ImprovCommand)> &&callback, std::function<void(Error)> &&on_error);
std::vector<uint8_t> build_rpc_response(Command command, const std::vector<std::string> &datum,
bool add_checksum = true);
std::vector<uint8_t> build_rpc_response(Command command, const std::vector<String> &datum, bool add_checksum = true);
} // namespace improv
void set_state(improv::State state);
void send_response(std::vector<uint8_t> &response);
void set_error(improv::Error error);
void getAvailableWifiNetworks();
bool onCommandCallback(improv::ImprovCommand cmd);
void onErrorCallback(improv::Error err);

378
ESP32_AP-Flasher/src/wifimanager.cpp
View File

@@ -158,47 +158,53 @@ void WifiManager::pollSerial() {
while (Serial.available() > 0) {
char receivedChar = Serial.read();
if (receivedChar == 27) {
memset(serialBuffer, 0, sizeof(serialBuffer));
serialIndex = 0;
Serial.println();
continue;
}
if (receivedChar == 8) {
if (serialIndex > 0) {
serialIndex--;
serialBuffer[serialIndex] = '\0';
Serial.print("\r");
Serial.print(serialBuffer);
}
continue;
}
if (receivedChar == '\r') {
continue;
}
if (receivedChar == '\n') {
serialBuffer[serialIndex] = '\0';
String command = String(serialBuffer);
if (command.startsWith("ssid ")) {
_ssid = command.substring(5);
Serial.println("\rSSID set to: " + _ssid);
} else if (command.startsWith("pass ")) {
_pass = command.substring(5);
Serial.println("\rPassword set to: " + _pass);
} else if (command.startsWith("connect")) {
connectToWifi(_ssid, _pass, true);
}
memset(serialBuffer, 0, sizeof(serialBuffer));
serialIndex = 0;
if (parse_improv_serial_byte(x_position, receivedChar, x_buffer, onCommandCallback, onErrorCallback)) {
x_buffer[x_position++] = receivedChar;
} else {
if (serialIndex < SERIAL_BUFFER_SIZE - 1) {
serialBuffer[serialIndex] = receivedChar;
serialIndex++;
Serial.print("\r");
Serial.print(serialBuffer);
x_position = 0;
if (receivedChar == 27) {
memset(serialBuffer, 0, sizeof(serialBuffer));
serialIndex = 0;
Serial.println();
continue;
}
if (receivedChar == 8) {
if (serialIndex > 0) {
serialIndex--;
serialBuffer[serialIndex] = '\0';
Serial.print("\r");
Serial.print(serialBuffer);
}
continue;
}
if (receivedChar == '\r') {
continue;
}
if (receivedChar == '\n') {
serialBuffer[serialIndex] = '\0';
String command = String(serialBuffer);
if (command.startsWith("ssid ")) {
_ssid = command.substring(5);
Serial.println("\rSSID set to: " + _ssid);
} else if (command.startsWith("pass ")) {
_pass = command.substring(5);
Serial.println("\rPassword set to: " + _pass);
} else if (command.startsWith("connect")) {
connectToWifi(_ssid, _pass, true);
}
memset(serialBuffer, 0, sizeof(serialBuffer));
serialIndex = 0;
} else {
if (serialIndex < SERIAL_BUFFER_SIZE - 1) {
serialBuffer[serialIndex] = receivedChar;
serialIndex++;
Serial.print("\r");
Serial.print(serialBuffer);
}
}
}
}
@@ -264,3 +270,295 @@ void WifiManager::WiFiEvent(WiFiEvent_t event) {
break;
}
}
// *** Improv
#define STR_IMPL(x) #x
#define STR(x) STR_IMPL(x)
#ifndef BUILD_ENV_NAME
#define BUILD_ENV_NAME unknown
#endif
#ifndef BUILD_TIME
#define BUILD_TIME 0
#endif
#ifndef BUILD_VERSION
#define BUILD_VERSION custom
#endif
std::vector<std::string> getLocalUrl() {
return { String("http://" + WiFi.localIP().toString()).c_str() };
}
void onErrorCallback(improv::Error err) {
}
bool onCommandCallback(improv::ImprovCommand cmd) {
switch (cmd.command) {
case improv::Command::GET_CURRENT_STATE: {
if ((WiFi.status() == WL_CONNECTED)) {
set_state(improv::State::STATE_PROVISIONED);
std::vector<uint8_t> data = improv::build_rpc_response(improv::GET_CURRENT_STATE, getLocalUrl(), false);
send_response(data);
} else {
set_state(improv::State::STATE_AUTHORIZED);
}
break;
}
case improv::Command::WIFI_SETTINGS: {
if (cmd.ssid.length() == 0) {
set_error(improv::Error::ERROR_INVALID_RPC);
break;
}
set_state(improv::STATE_PROVISIONING);
WifiManager wm;
if (wm.connectToWifi(String(cmd.ssid.c_str()), String(cmd.password.c_str()), true)) {
set_state(improv::STATE_PROVISIONED);
std::vector<uint8_t> data = improv::build_rpc_response(improv::WIFI_SETTINGS, getLocalUrl(), false);
send_response(data);
} else {
set_state(improv::STATE_STOPPED);
set_error(improv::Error::ERROR_UNABLE_TO_CONNECT);
}
break;
}
case improv::Command::GET_DEVICE_INFO: {
std::vector<std::string> infos = {
// Firmware name
"OpenEPaperLink",
// Firmware version
STR(BUILD_VERSION),
// Hardware chip/variant
STR(BUILD_ENV_NAME),
// Device name
"Access Point"};
std::vector<uint8_t> data = improv::build_rpc_response(improv::GET_DEVICE_INFO, infos, false);
send_response(data);
break;
}
case improv::Command::GET_WIFI_NETWORKS: {
getAvailableWifiNetworks();
break;
}
default: {
set_error(improv::ERROR_UNKNOWN_RPC);
return false;
}
}
return true;
}
void getAvailableWifiNetworks() {
int networkNum = WiFi.scanNetworks();
for (int id = 0; id < networkNum; ++id) {
std::vector<uint8_t> data = improv::build_rpc_response(
improv::GET_WIFI_NETWORKS, {WiFi.SSID(id), String(WiFi.RSSI(id)), (WiFi.encryptionType(id) == WIFI_AUTH_OPEN ? "NO" : "YES")}, false);
send_response(data);
delay(1);
}
// final response
std::vector<uint8_t> data =
improv::build_rpc_response(improv::GET_WIFI_NETWORKS, std::vector<std::string>{}, false);
send_response(data);
}
void set_state(improv::State state) {
std::vector<uint8_t> data = {'I', 'M', 'P', 'R', 'O', 'V'};
data.resize(11);
data[6] = improv::IMPROV_SERIAL_VERSION;
data[7] = improv::TYPE_CURRENT_STATE;
data[8] = 1;
data[9] = state;
uint8_t checksum = 0x00;
for (uint8_t d : data)
checksum += d;
data[10] = checksum;
Serial.write(data.data(), data.size());
}
void send_response(std::vector<uint8_t> &response) {
std::vector<uint8_t> data = {'I', 'M', 'P', 'R', 'O', 'V'};
data.resize(9);
data[6] = improv::IMPROV_SERIAL_VERSION;
data[7] = improv::TYPE_RPC_RESPONSE;
data[8] = response.size();
data.insert(data.end(), response.begin(), response.end());
uint8_t checksum = 0x00;
for (uint8_t d : data)
checksum += d;
data.push_back(checksum);
Serial.write(data.data(), data.size());
}
void set_error(improv::Error error) {
std::vector<uint8_t> data = {'I', 'M', 'P', 'R', 'O', 'V'};
data.resize(11);
data[6] = improv::IMPROV_SERIAL_VERSION;
data[7] = improv::TYPE_ERROR_STATE;
data[8] = 1;
data[9] = error;
uint8_t checksum = 0x00;
for (uint8_t d : data)
checksum += d;
data[10] = checksum;
Serial.write(data.data(), data.size());
}
// **** improv ****
namespace improv {
ImprovCommand parse_improv_data(const std::vector<uint8_t> &data, bool check_checksum) {
return parse_improv_data(data.data(), data.size(), check_checksum);
}
ImprovCommand parse_improv_data(const uint8_t *data, size_t length, bool check_checksum) {
ImprovCommand improv_command;
Command command = (Command)data[0];
uint8_t data_length = data[1];
if (data_length != length - 2 - check_checksum) {
improv_command.command = UNKNOWN;
return improv_command;
}
if (check_checksum) {
uint8_t checksum = data[length - 1];
uint32_t calculated_checksum = 0;
for (uint8_t i = 0; i < length - 1; i++) {
calculated_checksum += data[i];
}
if ((uint8_t)calculated_checksum != checksum) {
improv_command.command = BAD_CHECKSUM;
return improv_command;
}
}
if (command == WIFI_SETTINGS) {
uint8_t ssid_length = data[2];
uint8_t ssid_start = 3;
size_t ssid_end = ssid_start + ssid_length;
uint8_t pass_length = data[ssid_end];
size_t pass_start = ssid_end + 1;
size_t pass_end = pass_start + pass_length;
std::string ssid(data + ssid_start, data + ssid_end);
std::string password(data + pass_start, data + pass_end);
return {.command = command, .ssid = ssid, .password = password};
}
improv_command.command = command;
return improv_command;
}
bool parse_improv_serial_byte(size_t position, uint8_t byte, const uint8_t *buffer,
std::function<bool(ImprovCommand)> &&callback, std::function<void(Error)> &&on_error) {
if (position == 0)
return byte == 'I';
if (position == 1)
return byte == 'M';
if (position == 2)
return byte == 'P';
if (position == 3)
return byte == 'R';
if (position == 4)
return byte == 'O';
if (position == 5)
return byte == 'V';
if (position == 6)
return byte == IMPROV_SERIAL_VERSION;
if (position <= 8)
return true;
uint8_t type = buffer[7];
uint8_t data_len = buffer[8];
if (position <= 8 + data_len)
return true;
if (position == 8 + data_len + 1) {
uint8_t checksum = 0x00;
for (size_t i = 0; i < position; i++)
checksum += buffer[i];
if (checksum != byte) {
on_error(ERROR_INVALID_RPC);
return false;
}
if (type == TYPE_RPC) {
auto command = parse_improv_data(&buffer[9], data_len, false);
return callback(command);
}
}
return false;
}
std::vector<uint8_t> build_rpc_response(Command command, const std::vector<std::string> &datum, bool add_checksum) {
std::vector<uint8_t> out;
uint32_t length = 0;
out.push_back(command);
for (const auto &str : datum) {
uint8_t len = str.length();
length += len + 1;
out.push_back(len);
out.insert(out.end(), str.begin(), str.end());
}
out.insert(out.begin() + 1, length);
if (add_checksum) {
uint32_t calculated_checksum = 0;
for (uint8_t byte : out) {
calculated_checksum += byte;
}
out.push_back(calculated_checksum);
}
return out;
}
std::vector<uint8_t> build_rpc_response(Command command, const std::vector<String> &datum, bool add_checksum) {
std::vector<uint8_t> out;
uint32_t length = 0;
out.push_back(command);
for (const auto &str : datum) {
uint8_t len = str.length();
length += len;
out.push_back(len);
out.insert(out.end(), str.begin(), str.end());
}
out.insert(out.begin() + 1, length);
if (add_checksum) {
uint32_t calculated_checksum = 0;
for (uint8_t byte : out) {
calculated_checksum += byte;
}
out.push_back(calculated_checksum);
}
return out;
}
} // namespace improv