erki/esp-vfd-clock
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Firmware: Provisioner now kinda works

Browse Source
This commit is contained in:
erki 2024-01-18 15:22:40 +02:00
parent 4929fe4caf
commit f3df59b0fe
4 changed files with 220 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
firmware/main/main.cpp
View File

@ -25,7 +25,10 @@ extern "C" void app_main(void)
ESP_ERROR_CHECK(err);
auto* provisioner = new WifiProvisioner("wifi_settings");
auto* provisioner = new WifiProvisioner("wifi_settings", [](const auto& params)
{
printf("Settings successfully done.");
});
if (!provisioner->addParameter("SSID", "ssid", WifiProvisioner::Parameter::Type::STRING).has_value())
{
printf("Error adding parameter.");

56
firmware/main/static/index.html
View File

@ -12,11 +12,58 @@
<h1>ESP Captive Portal</h1>
<p>Hello World, this is ESP32!</p>
<form action="/configure" method="post" id="submit_form">
<div id="interface">
<form id="submit_form">
</form>
</div>
<script>
function outputSuccess(response_object) {
let root = document.getElementById("interface");
root.innerHTML = "";
root.innerHTML = `<b>${response_object.response_str}</b>`;
}
function outputFailure(response_object) {
let root = document.getElementById("interface");
root.innerHTML = "";
root.innerHTML = `<p><b>Request failed.</b></br>Reason:${response_object.response_str}</p>`;
}
function submitFormHandler(event) {
console.log("In the post handler.");
event.preventDefault();
const form_data = new FormData(document.getElementById("submit_form"));
let configuration_data = [];
for (const pair of form_data.entries()) {
configuration_data.push({
nvs_name: pair[0],
value: pair[1]
});
}
console.log(`Posting data: ${JSON.stringify(configuration_data)}`);
fetch("configure", {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(configuration_data)
}).then((r) => {
console.log("Got a response.");
console.log(r);
if (r.ok) {
outputSuccess(r.json());
} else {
outputFailure(r.json());
}
});
}
async function getParameterFields() {
const response = await fetch("parameters", {
method: "GET",
@ -51,7 +98,10 @@
let submit = document.createElement("input");
submit.setAttribute("type", "submit");
submit.setAttribute("value", "Configure");
form_root.appendChild(submit);
form_root.addEventListener("submit", submitFormHandler, true);
}
populateSubmitForm(document.getElementById("submit_form"));

164
firmware/main/wifi_provisioner.cpp
View File

@ -61,9 +61,12 @@ esp_err_t rootPostHandler_(httpd_req_t* req)
content.initialize_free_space();
const std::size_t size = MIN(req->content_len, content.max_size() - 1);
ESP_LOGI(TAG, "Post handler.");
if (const int ret = httpd_req_recv(req, content.data_end(), size);
ret <= 0)
{
ESP_LOGE(TAG, "Error, socket timeout.");
if (ret == HTTPD_SOCK_ERR_TIMEOUT)
httpd_resp_send_408(req);
@ -72,21 +75,64 @@ esp_err_t rootPostHandler_(httpd_req_t* req)
content.trim_to_terminator();
etl::string<100> header;
if (const auto err = httpd_req_get_hdr_value_str(req, "Content-Type", header.data(), header.max_size() - 1);
auto dispatch_error = [req](const char* error_str)
{
ESP_LOGE(TAG, "Request error: %s", error_str);
auto json_root = CJsonPtr(cJSON_CreateObject());
cJSON_AddStringToObject(json_root.get(), "response_str", error_str);
auto response_str = CJsonStrPtr(cJSON_Print(json_root.get()));
httpd_resp_set_status(req, "400 Bad Request");
httpd_resp_set_type(req, HTTPD_TYPE_JSON);
httpd_resp_sendstr(req, response_str.get());
};
etl::string<100> content_type;
if (const auto err = httpd_req_get_hdr_value_str(req, "Content-Type", content_type.data(), content_type.max_size() - 1);
err != ESP_OK)
{
ESP_LOGE(TAG, "Error reading content header.");
dispatch_error("Cannot parse header.");
return ESP_FAIL;
}
//httpd_query_key_value
ESP_LOGI(TAG, "Data from post: %s, %s", header.data(), content.data());
content_type.trim_to_terminator();
if (content_type != "application/json")
{
ESP_LOGE(TAG, "Invalid content-type header: %s", content_type.c_str());
dispatch_error("Invalid Content-Type header.");
return ESP_FAIL;
}
auto json_object = CJsonPtr(cJSON_Parse(content.c_str()));
if (!json_object || !cJSON_IsArray(json_object.get()))
{
dispatch_error("Invalid JSON sent.");
return ESP_FAIL;
}
auto* provisioner = static_cast<WifiProvisioner*>(req->user_ctx);
std::expected<void, const char*> result = provisioner->tryConfigureParameters(std::move(json_object));
if (result)
{
httpd_resp_set_type(req, HTTPD_TYPE_JSON);
auto json_root = CJsonPtr(cJSON_CreateObject());
cJSON_AddStringToObject(json_root.get(), "response_str", "Configuration successful. ESP rebooting.");
auto response_str = CJsonStrPtr(cJSON_Print(json_root.get()));
httpd_resp_sendstr(req, response_str.get());
ESP_LOGI(TAG, "Post successful.");
const char resp[] = "URI POST Response";
httpd_resp_send(req, resp, HTTPD_RESP_USE_STRLEN);
return ESP_OK;
}
else
{
dispatch_error(result.error());
return ESP_FAIL;
}
}
esp_err_t parametersGetHandler_(httpd_req_t* req)
{
@ -112,20 +158,20 @@ esp_err_t parametersGetHandler_(httpd_req_t* req)
std::expected<WifiProvisioner::Parameter::Value, esp_err_t> WifiProvisioner::Parameter::getValue(nvs::NVSHandle* file_handle) const
{
if (type == Parameter::Type::INT)
if (type == Type::INT)
{
std::int32_t value = 0;
TRY_ESP(file_handle->get_item(nvs_name.c_str(), value));
return value;
}
else if (type == Parameter::Type::FLOAT)
else if (type == Type::FLOAT)
{
std::int32_t value_raw = 0;
TRY_ESP(file_handle->get_item(nvs_name.c_str(), value_raw));
return std::bit_cast<float>(value_raw);
}
else if (type == Parameter::Type::STRING)
else if (type == Type::STRING)
{
etl::string<100> value;
value.initialize_free_space();
@ -139,7 +185,42 @@ std::expected<WifiProvisioner::Parameter::Value, esp_err_t> WifiProvisioner::Par
return ESP_FAIL;
}
WifiProvisioner::WifiProvisioner(const char* settings_namespace)
std::expected<WifiProvisioner::Parameter::Value, const char*> WifiProvisioner::Parameter::tryValidateAndAssign(cJSON* object)
{
if (!cJSON_IsObject(object))
return std::unexpected("Invalid parameter JSON.");
const cJSON* in_nvs_name = cJSON_GetObjectItem(object, "nvs_name");
if (!cJSON_IsString(in_nvs_name))
return std::unexpected("Invalid parameter JSON.");
if (cJSON_GetStringValue(in_nvs_name) != nvs_name)
return std::unexpected("Mismatching parameter nvs_name. Invalid sequence or invalid parameter.");
const cJSON* in_value = cJSON_GetObjectItem(object, "value");
if (type == Type::INT || type == Type::FLOAT)
{
if (!cJSON_IsNumber(in_value))
return std::unexpected("Mismatching or missing parameter value.");
const double json_value = cJSON_GetNumberValue(in_value);
if (type == Type::INT)
return {data = Value{std::int32_t(json_value)}};
else
return {data = Value{float(json_value)}};
}
else
{
if (!cJSON_IsString(in_value))
return std::unexpected("Mismatching or missing parameter value.");
const char* json_value = cJSON_GetStringValue(in_value);
return {data = Value{json_value}};
}
}
WifiProvisioner::WifiProvisioner(const char* settings_namespace, etl::delegate<void (const etl::vector<Parameter, 10>&)> success_cb)
: success_cb_(success_cb)
{
esp_err_t err = ESP_OK;
file_handle_ = nvs::open_nvs_handle(settings_namespace, NVS_READWRITE, &err);
@ -154,6 +235,14 @@ WifiProvisioner::WifiProvisioner(const char* settings_namespace)
}
}
WifiProvisioner::~WifiProvisioner()
{
if (http_server_)
{
httpd_stop(http_server_);
}
}
bool WifiProvisioner::parametersAreConfigured()
{
if (params_.empty())
@ -208,6 +297,31 @@ CJsonPtr WifiProvisioner::getParameterObjects() const
return root;
}
std::expected<void, const char*> WifiProvisioner::tryConfigureParameters(CJsonPtr json_root)
{
if (params_.size() != cJSON_GetArraySize(json_root.get()))
return std::unexpected("Mismatching parameters array sizes.");
cJSON* entry = nullptr;
int i = 0;
cJSON_ArrayForEach(entry, json_root)
{
auto& param = params_[i];
TRY(param.tryValidateAndAssign(entry));
i++;
}
const auto& result = writeAndCommitParameters_();
if (!result.has_value())
return std::unexpected(esp_err_to_name(result.error()));
if (settings_initialized_ && success_cb_)
success_cb_(params_);
return {};
}
esp_err_t WifiProvisioner::initializeNvsNamespace_()
{
esp_err_t err = file_handle_->set_item(NVS_IS_INITED, false);
@ -317,3 +431,31 @@ std::expected<httpd_handle_t, esp_err_t> WifiProvisioner::initializeCaptivePorta
return server;
}
std::expected<void, esp_err_t> WifiProvisioner::writeAndCommitParameters_()
{
for (const auto& param : params_)
{
if (param.type == Parameter::Type::INT)
{
TRY_ESP(file_handle_->set_item(param.nvs_name.c_str(), std::get<std::int32_t>(param.data)));
}
else if (param.type == Parameter::Type::FLOAT)
{
const auto temporary = std::bit_cast<std::int32_t>(std::get<float>(param.data));
TRY_ESP(file_handle_->set_item(param.nvs_name.c_str(), temporary));
}
else
{
const auto temporary = std::get<etl::string<100>>(param.data);
TRY_ESP(file_handle_->set_string(param.nvs_name.c_str(), temporary.c_str()));
}
}
TRY_ESP(file_handle_->set_item(NVS_IS_INITED, true));
TRY_ESP(file_handle_->commit());
settings_initialized_ = true;
return {};
}

10
firmware/main/wifi_provisioner.hpp
View File

@ -8,6 +8,7 @@
#include <esp_http_server.h>
#include <etl/vector.h>
#include <etl/string.h>
#include <etl/delegate.h>
#include <expected>
#include <variant>
#include <memory>
@ -36,7 +37,6 @@ struct CJsonDeleter
using CJsonPtr = std::unique_ptr<cJSON, CJsonDeleter>;
class WifiProvisioner
{
public:
@ -64,9 +64,11 @@ public:
{ }
std::expected<Value, esp_err_t> getValue(nvs::NVSHandle* file_handle) const;
std::expected<Value, const char*> tryValidateAndAssign(cJSON* object);
};
explicit WifiProvisioner(const char* settings_namespace);
explicit WifiProvisioner(const char* settings_namespace, etl::delegate<void (const etl::vector<Parameter, 10>&)> success_cb);
~WifiProvisioner();
WifiProvisioner() = delete;
WifiProvisioner(const WifiProvisioner&) = delete;
@ -81,13 +83,17 @@ public:
std::expected<void, std::error_code> addParameter(const char* name, const char* nvs_name, const Parameter::Type type);
CJsonPtr getParameterObjects() const;
std::expected<void, const char*> tryConfigureParameters(CJsonPtr json_root);
private:
std::unique_ptr<nvs::NVSHandle> file_handle_;
bool settings_initialized_ = false;
httpd_handle_t http_server_ = nullptr;
etl::vector<Parameter, 10> params_;
etl::delegate<void (const etl::vector<Parameter, 10>& params)> success_cb_;
esp_err_t initializeNvsNamespace_();
std::expected<void, esp_err_t> initializeWifiAp_();
std::expected<httpd_handle_t, esp_err_t> initializeCaptivePortal_();
std::expected<void, esp_err_t> writeAndCommitParameters_();
};