mirror of
https://github.com/MrUnknownDE/OpenIris-ESPIDF.git
synced 2026-04-18 14:03:45 +02:00
Begin porting OpenIris from platformio to ESP-IDF, wifi works, blinking works, Preferences work, flashing etc works, configuration for xiaos works
This commit is contained in:
Lorow
4
components/Preferences/CMakeLists.txt
Normal file
4
components/Preferences/CMakeLists.txt
Normal file
@@ -0,0 +1,4 @@
|
||||
idf_component_register(SRCS "Preferences/Preferences.cpp"
|
||||
INCLUDE_DIRS "Preferences"
|
||||
REQUIRES nvs_flash
|
||||
)
|
||||
668
components/Preferences/Preferences/Preferences.cpp
Normal file
668
components/Preferences/Preferences/Preferences.cpp
Normal file
@@ -0,0 +1,668 @@
|
||||
// source: https://github.com/espressif/arduino-esp32/blob/master/libraries/Preferences/src/Preferences.cpp
|
||||
// ported by: Lorow
|
||||
|
||||
#include "Preferences.hpp"
|
||||
|
||||
const char *PREFERENCES_TAG = "[PREFERENCES]";
|
||||
const char *nvs_errors[] = {"OTHER", "NOT_INITIALIZED", "NOT_FOUND", "TYPE_MISMATCH", "READ_ONLY", "NOT_ENOUGH_SPACE", "INVALID_NAME",
|
||||
"INVALID_HANDLE", "REMOVE_FAILED", "KEY_TOO_LONG", "PAGE_FULL", "INVALID_STATE", "INVALID_LENGTH"};
|
||||
#define nvs_error(e) (((e) > ESP_ERR_NVS_BASE) ? nvs_errors[(e) & ~(ESP_ERR_NVS_BASE)] : nvs_errors[0])
|
||||
|
||||
Preferences::Preferences() : _handle(0), _started(false), _readOnly(false) {}
|
||||
bool Preferences::begin(const char *name, bool readOnly, const char *partition_label)
|
||||
{
|
||||
if (_started)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_readOnly = readOnly;
|
||||
esp_err_t err = ESP_OK;
|
||||
if (partition_label != NULL)
|
||||
{
|
||||
err = nvs_flash_init_partition(partition_label);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_flash_init_partition failed: %s", nvs_error(err));
|
||||
return false;
|
||||
}
|
||||
err = nvs_open_from_partition(partition_label, name, readOnly ? NVS_READONLY : NVS_READWRITE, &_handle);
|
||||
}
|
||||
else
|
||||
{
|
||||
err = nvs_open(name, readOnly ? NVS_READONLY : NVS_READWRITE, &_handle);
|
||||
}
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_open failed: %s", nvs_error(err));
|
||||
return false;
|
||||
}
|
||||
_started = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
Preferences::~Preferences()
|
||||
{
|
||||
end();
|
||||
}
|
||||
|
||||
void Preferences::end()
|
||||
{
|
||||
if (!_started)
|
||||
{
|
||||
return;
|
||||
}
|
||||
nvs_close(_handle);
|
||||
_started = false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Clear all keys in opened preferences
|
||||
* */
|
||||
|
||||
bool Preferences::clear()
|
||||
{
|
||||
if (!_started || _readOnly)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
esp_err_t err = nvs_erase_all(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_erase_all fail: %s", nvs_error(err));
|
||||
return false;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s", nvs_error(err));
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Remove a key
|
||||
* */
|
||||
|
||||
bool Preferences::remove(const char *key)
|
||||
{
|
||||
if (!_started || !key || _readOnly)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
esp_err_t err = nvs_erase_key(_handle, key);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_erase_key fail: %s %s", key, nvs_error(err));
|
||||
return false;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s %s", key, nvs_error(err));
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Put a key value
|
||||
* */
|
||||
|
||||
size_t Preferences::putChar(const char *key, int8_t value)
|
||||
{
|
||||
if (!_started || !key || _readOnly)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_set_i8(_handle, key, value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_set_i8 fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
size_t Preferences::putUChar(const char *key, uint8_t value)
|
||||
{
|
||||
if (!_started || !key || _readOnly)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_set_u8(_handle, key, value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_set_u8 fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
size_t Preferences::putShort(const char *key, int16_t value)
|
||||
{
|
||||
if (!_started || !key || _readOnly)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_set_i16(_handle, key, value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_set_i16 fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return 2;
|
||||
}
|
||||
|
||||
size_t Preferences::putUShort(const char *key, uint16_t value)
|
||||
{
|
||||
if (!_started || !key || _readOnly)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_set_u16(_handle, key, value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_set_u16 fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return 2;
|
||||
}
|
||||
|
||||
size_t Preferences::putInt(const char *key, int32_t value)
|
||||
{
|
||||
if (!_started || !key || _readOnly)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_set_i32(_handle, key, value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_set_i32 fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return 4;
|
||||
}
|
||||
|
||||
size_t Preferences::putUInt(const char *key, uint32_t value)
|
||||
{
|
||||
if (!_started || !key || _readOnly)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_set_u32(_handle, key, value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_set_u32 fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return 4;
|
||||
}
|
||||
|
||||
size_t Preferences::putLong(const char *key, int32_t value)
|
||||
{
|
||||
return putInt(key, value);
|
||||
}
|
||||
|
||||
size_t Preferences::putULong(const char *key, uint32_t value)
|
||||
{
|
||||
return putUInt(key, value);
|
||||
}
|
||||
|
||||
size_t Preferences::putLong64(const char *key, int64_t value)
|
||||
{
|
||||
if (!_started || !key || _readOnly)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_set_i64(_handle, key, value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_set_i64 fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return 8;
|
||||
}
|
||||
|
||||
size_t Preferences::putULong64(const char *key, uint64_t value)
|
||||
{
|
||||
if (!_started || !key || _readOnly)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_set_u64(_handle, key, value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_set_u64 fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return 8;
|
||||
}
|
||||
|
||||
size_t Preferences::putFloat(const char *key, const float_t value)
|
||||
{
|
||||
return putBytes(key, (void *)&value, sizeof(float_t));
|
||||
}
|
||||
|
||||
size_t Preferences::putDouble(const char *key, const double_t value)
|
||||
{
|
||||
return putBytes(key, (void *)&value, sizeof(double_t));
|
||||
}
|
||||
|
||||
size_t Preferences::putBool(const char *key, const bool value)
|
||||
{
|
||||
return putUChar(key, (uint8_t)(value ? 1 : 0));
|
||||
}
|
||||
|
||||
size_t Preferences::putString(const char *key, const char *value)
|
||||
{
|
||||
if (!_started || !key || !value || _readOnly)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_set_str(_handle, key, value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_set_str fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return strlen(value);
|
||||
}
|
||||
|
||||
size_t Preferences::putString(const char *key, const std::string value)
|
||||
{
|
||||
return putString(key, value.c_str());
|
||||
}
|
||||
|
||||
size_t Preferences::putBytes(const char *key, const void *value, size_t len)
|
||||
{
|
||||
if (!_started || !key || !value || !len || _readOnly)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_set_blob(_handle, key, value, len);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_set_blob fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
err = nvs_commit(_handle);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_commit fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
PreferenceType Preferences::getType(const char *key)
|
||||
{
|
||||
if (!_started || !key || strlen(key) > 15)
|
||||
{
|
||||
return PT_INVALID;
|
||||
}
|
||||
int8_t mt1;
|
||||
uint8_t mt2;
|
||||
int16_t mt3;
|
||||
uint16_t mt4;
|
||||
int32_t mt5;
|
||||
uint32_t mt6;
|
||||
int64_t mt7;
|
||||
uint64_t mt8;
|
||||
size_t len = 0;
|
||||
if (nvs_get_i8(_handle, key, &mt1) == ESP_OK)
|
||||
{
|
||||
return PT_I8;
|
||||
}
|
||||
if (nvs_get_u8(_handle, key, &mt2) == ESP_OK)
|
||||
{
|
||||
return PT_U8;
|
||||
}
|
||||
if (nvs_get_i16(_handle, key, &mt3) == ESP_OK)
|
||||
{
|
||||
return PT_I16;
|
||||
}
|
||||
if (nvs_get_u16(_handle, key, &mt4) == ESP_OK)
|
||||
{
|
||||
return PT_U16;
|
||||
}
|
||||
if (nvs_get_i32(_handle, key, &mt5) == ESP_OK)
|
||||
{
|
||||
return PT_I32;
|
||||
}
|
||||
if (nvs_get_u32(_handle, key, &mt6) == ESP_OK)
|
||||
{
|
||||
return PT_U32;
|
||||
}
|
||||
if (nvs_get_i64(_handle, key, &mt7) == ESP_OK)
|
||||
{
|
||||
return PT_I64;
|
||||
}
|
||||
if (nvs_get_u64(_handle, key, &mt8) == ESP_OK)
|
||||
{
|
||||
return PT_U64;
|
||||
}
|
||||
if (nvs_get_str(_handle, key, NULL, &len) == ESP_OK)
|
||||
{
|
||||
return PT_STR;
|
||||
}
|
||||
if (nvs_get_blob(_handle, key, NULL, &len) == ESP_OK)
|
||||
{
|
||||
return PT_BLOB;
|
||||
}
|
||||
return PT_INVALID;
|
||||
}
|
||||
|
||||
bool Preferences::isKey(const char *key)
|
||||
{
|
||||
return getType(key) != PT_INVALID;
|
||||
}
|
||||
|
||||
/*
|
||||
* Get a key value
|
||||
* */
|
||||
|
||||
int8_t Preferences::getChar(const char *key, const int8_t defaultValue)
|
||||
{
|
||||
int8_t value = defaultValue;
|
||||
if (!_started || !key)
|
||||
{
|
||||
return value;
|
||||
}
|
||||
esp_err_t err = nvs_get_i8(_handle, key, &value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGV(PREFERENCES_TAG, "nvs_get_i8 fail: %s %s", key, nvs_error(err));
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
uint8_t Preferences::getUChar(const char *key, const uint8_t defaultValue)
|
||||
{
|
||||
uint8_t value = defaultValue;
|
||||
if (!_started || !key)
|
||||
{
|
||||
return value;
|
||||
}
|
||||
esp_err_t err = nvs_get_u8(_handle, key, &value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGV(PREFERENCES_TAG, "nvs_get_u8 fail: %s %s", key, nvs_error(err));
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
int16_t Preferences::getShort(const char *key, const int16_t defaultValue)
|
||||
{
|
||||
int16_t value = defaultValue;
|
||||
if (!_started || !key)
|
||||
{
|
||||
return value;
|
||||
}
|
||||
esp_err_t err = nvs_get_i16(_handle, key, &value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGV(PREFERENCES_TAG, "nvs_get_i16 fail: %s %s", key, nvs_error(err));
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
uint16_t Preferences::getUShort(const char *key, const uint16_t defaultValue)
|
||||
{
|
||||
uint16_t value = defaultValue;
|
||||
if (!_started || !key)
|
||||
{
|
||||
return value;
|
||||
}
|
||||
esp_err_t err = nvs_get_u16(_handle, key, &value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGV(PREFERENCES_TAG, "nvs_get_u16 fail: %s %s", key, nvs_error(err));
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
int32_t Preferences::getInt(const char *key, const int32_t defaultValue)
|
||||
{
|
||||
int32_t value = defaultValue;
|
||||
if (!_started || !key)
|
||||
{
|
||||
return value;
|
||||
}
|
||||
esp_err_t err = nvs_get_i32(_handle, key, &value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGV(PREFERENCES_TAG, "nvs_get_i32 fail: %s %s", key, nvs_error(err));
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
uint32_t Preferences::getUInt(const char *key, const uint32_t defaultValue)
|
||||
{
|
||||
uint32_t value = defaultValue;
|
||||
if (!_started || !key)
|
||||
{
|
||||
return value;
|
||||
}
|
||||
esp_err_t err = nvs_get_u32(_handle, key, &value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGV(PREFERENCES_TAG, "nvs_get_u32 fail: %s %s", key, nvs_error(err));
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
int32_t Preferences::getLong(const char *key, const int32_t defaultValue)
|
||||
{
|
||||
return getInt(key, defaultValue);
|
||||
}
|
||||
|
||||
uint32_t Preferences::getULong(const char *key, const uint32_t defaultValue)
|
||||
{
|
||||
return getUInt(key, defaultValue);
|
||||
}
|
||||
|
||||
int64_t Preferences::getLong64(const char *key, const int64_t defaultValue)
|
||||
{
|
||||
int64_t value = defaultValue;
|
||||
if (!_started || !key)
|
||||
{
|
||||
return value;
|
||||
}
|
||||
esp_err_t err = nvs_get_i64(_handle, key, &value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGV(PREFERENCES_TAG, "nvs_get_i64 fail: %s %s", key, nvs_error(err));
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
uint64_t Preferences::getULong64(const char *key, const uint64_t defaultValue)
|
||||
{
|
||||
uint64_t value = defaultValue;
|
||||
if (!_started || !key)
|
||||
{
|
||||
return value;
|
||||
}
|
||||
esp_err_t err = nvs_get_u64(_handle, key, &value);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGV(PREFERENCES_TAG, "nvs_get_u64 fail: %s %s", key, nvs_error(err));
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
float_t Preferences::getFloat(const char *key, const float_t defaultValue)
|
||||
{
|
||||
float_t value = defaultValue;
|
||||
getBytes(key, (void *)&value, sizeof(float_t));
|
||||
return value;
|
||||
}
|
||||
|
||||
double_t Preferences::getDouble(const char *key, const double_t defaultValue)
|
||||
{
|
||||
double_t value = defaultValue;
|
||||
getBytes(key, (void *)&value, sizeof(double_t));
|
||||
return value;
|
||||
}
|
||||
|
||||
bool Preferences::getBool(const char *key, const bool defaultValue)
|
||||
{
|
||||
return getUChar(key, defaultValue ? 1 : 0) == 1;
|
||||
}
|
||||
|
||||
size_t Preferences::getString(const char *key, char *value, const size_t maxLen)
|
||||
{
|
||||
size_t len = 0;
|
||||
if (!_started || !key || !value || !maxLen)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_get_str(_handle, key, NULL, &len);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_get_str len fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
if (len > maxLen)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "not enough space in value: %u < %u", maxLen, len);
|
||||
return 0;
|
||||
}
|
||||
err = nvs_get_str(_handle, key, value, &len);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_get_str fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
std::string Preferences::getString(const char *key, const std::string defaultValue)
|
||||
{
|
||||
char *value = NULL;
|
||||
size_t len = 0;
|
||||
if (!_started || !key)
|
||||
{
|
||||
return defaultValue;
|
||||
}
|
||||
esp_err_t err = nvs_get_str(_handle, key, value, &len);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_get_str len fail: %s %s", key, nvs_error(err));
|
||||
return defaultValue;
|
||||
}
|
||||
char buf[len];
|
||||
value = buf;
|
||||
err = nvs_get_str(_handle, key, value, &len);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_get_str fail: %s %s", key, nvs_error(err));
|
||||
return defaultValue;
|
||||
}
|
||||
return std::string(buf);
|
||||
}
|
||||
|
||||
size_t Preferences::getBytesLength(const char *key)
|
||||
{
|
||||
size_t len = 0;
|
||||
if (!_started || !key)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_get_blob(_handle, key, NULL, &len);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_get_blob len fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
size_t Preferences::getBytes(const char *key, void *buf, size_t maxLen)
|
||||
{
|
||||
size_t len = getBytesLength(key);
|
||||
if (!len || !buf || !maxLen)
|
||||
{
|
||||
return len;
|
||||
}
|
||||
if (len > maxLen)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "not enough space in buffer: %u < %u", maxLen, len);
|
||||
return 0;
|
||||
}
|
||||
esp_err_t err = nvs_get_blob(_handle, key, buf, &len);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "nvs_get_blob fail: %s %s", key, nvs_error(err));
|
||||
return 0;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
size_t Preferences::freeEntries()
|
||||
{
|
||||
nvs_stats_t nvs_stats;
|
||||
esp_err_t err = nvs_get_stats(NULL, &nvs_stats);
|
||||
if (err)
|
||||
{
|
||||
ESP_LOGE(PREFERENCES_TAG, "Failed to get nvs statistics");
|
||||
return 0;
|
||||
}
|
||||
return nvs_stats.free_entries;
|
||||
}
|
||||
87
components/Preferences/Preferences/Preferences.hpp
Normal file
87
components/Preferences/Preferences/Preferences.hpp
Normal file
@@ -0,0 +1,87 @@
|
||||
// source: https://github.com/espressif/arduino-esp32/blob/master/libraries/Preferences/src/Preferences.h
|
||||
// ported by: Lorow, do not trust this please
|
||||
|
||||
#pragma once
|
||||
#ifndef _PREFERENCES_HPP_
|
||||
#define _PREFERENCES_HPP_
|
||||
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <math.h>
|
||||
#include "esp_log.h"
|
||||
#include "nvs_flash.h"
|
||||
#include "nvs.h"
|
||||
|
||||
typedef enum
|
||||
{
|
||||
PT_I8,
|
||||
PT_U8,
|
||||
PT_I16,
|
||||
PT_U16,
|
||||
PT_I32,
|
||||
PT_U32,
|
||||
PT_I64,
|
||||
PT_U64,
|
||||
PT_STR,
|
||||
PT_BLOB,
|
||||
PT_INVALID
|
||||
} PreferenceType;
|
||||
|
||||
class Preferences
|
||||
{
|
||||
protected:
|
||||
uint32_t _handle;
|
||||
bool _started;
|
||||
bool _readOnly;
|
||||
|
||||
public:
|
||||
Preferences();
|
||||
~Preferences();
|
||||
|
||||
bool begin(const char *name, bool readOnly = false, const char *partition_label = nullptr);
|
||||
void end();
|
||||
|
||||
bool clear();
|
||||
bool remove(const char *key);
|
||||
|
||||
size_t putChar(const char *key, int8_t value);
|
||||
size_t putUChar(const char *key, uint8_t value);
|
||||
size_t putShort(const char *key, int16_t value);
|
||||
size_t putUShort(const char *key, uint16_t value);
|
||||
size_t putInt(const char *key, int32_t value);
|
||||
size_t putUInt(const char *key, uint32_t value);
|
||||
size_t putLong(const char *key, int32_t value);
|
||||
size_t putULong(const char *key, uint32_t value);
|
||||
size_t putLong64(const char *key, int64_t value);
|
||||
size_t putULong64(const char *key, uint64_t value);
|
||||
size_t putFloat(const char *key, float_t value);
|
||||
size_t putDouble(const char *key, double_t value);
|
||||
size_t putBool(const char *key, bool value);
|
||||
size_t putString(const char *key, const char *value);
|
||||
size_t putString(const char *key, std::string value);
|
||||
size_t putBytes(const char *key, const void *value, size_t len);
|
||||
|
||||
bool isKey(const char *key);
|
||||
PreferenceType getType(const char *key);
|
||||
int8_t getChar(const char *key, int8_t defaultValue = 0);
|
||||
uint8_t getUChar(const char *key, uint8_t defaultValue = 0);
|
||||
int16_t getShort(const char *key, int16_t defaultValue = 0);
|
||||
uint16_t getUShort(const char *key, uint16_t defaultValue = 0);
|
||||
int32_t getInt(const char *key, int32_t defaultValue = 0);
|
||||
uint32_t getUInt(const char *key, uint32_t defaultValue = 0);
|
||||
int32_t getLong(const char *key, int32_t defaultValue = 0);
|
||||
uint32_t getULong(const char *key, uint32_t defaultValue = 0);
|
||||
int64_t getLong64(const char *key, int64_t defaultValue = 0);
|
||||
uint64_t getULong64(const char *key, uint64_t defaultValue = 0);
|
||||
float_t getFloat(const char *key, float_t defaultValue = NAN);
|
||||
double_t getDouble(const char *key, double_t defaultValue = NAN);
|
||||
bool getBool(const char *key, bool defaultValue = false);
|
||||
size_t getString(const char *key, char *value, size_t maxLen);
|
||||
std::string getString(const char *key, std::string defaultValue = std::string());
|
||||
size_t getBytesLength(const char *key);
|
||||
size_t getBytes(const char *key, void *buf, size_t maxLen);
|
||||
size_t freeEntries();
|
||||
};
|
||||
|
||||
#endif _PREFERENCES_HPP_
|
||||
4
components/customSomething/CMakeLists.txt
Normal file
4
components/customSomething/CMakeLists.txt
Normal file
@@ -0,0 +1,4 @@
|
||||
idf_component_register(SRCS "customSomething/customSomething.hpp"
|
||||
INCLUDE_DIRS "customSomething"
|
||||
REQUIRES "driver"
|
||||
)
|
||||
@@ -0,0 +1,6 @@
|
||||
#include "esp_log.h"
|
||||
|
||||
void printTheInclude()
|
||||
{
|
||||
ESP_LOGI("customSomething", "test");
|
||||
}
|
||||
4
components/openiris_logo/CMakeLists.txt
Normal file
4
components/openiris_logo/CMakeLists.txt
Normal file
@@ -0,0 +1,4 @@
|
||||
idf_component_register(SRCS "openiris_logo/openiris_logo.hpp"
|
||||
INCLUDE_DIRS "openiris_logo"
|
||||
REQUIRES "driver"
|
||||
)
|
||||
76
components/openiris_logo/openiris_logo/openiris_logo.hpp
Normal file
76
components/openiris_logo/openiris_logo/openiris_logo.hpp
Normal file
@@ -0,0 +1,76 @@
|
||||
// Made by ZanzyTHEBar
|
||||
#pragma once
|
||||
#ifndef OPENIRIS_LOGO_HPP
|
||||
#define OPENIRIS_LOGO_HPP
|
||||
#include "esp_log.h"
|
||||
|
||||
namespace Logo
|
||||
{
|
||||
static const char *LOGO_TAG = "[LOGO]";
|
||||
|
||||
inline static void printASCII()
|
||||
{
|
||||
ESP_LOGI(LOGO_TAG, " : === WELCOME === TO === : ");
|
||||
ESP_LOGI(LOGO_TAG, " <===========================================================================================================================> ");
|
||||
ESP_LOGI(LOGO_TAG, " ██████╗ ██████╗ ███████╗███╗ ██╗██╗██████╗ ██╗███████╗ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██╔═══██╗██╔══██╗██╔════╝████╗ ██║██║██╔══██╗██║██╔════╝ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██║ ██║██████╔╝█████╗ ██╔██╗ ██║██║██████╔╝██║███████╗ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██║ ██║██╔═══╝ ██╔══╝ ██║╚██╗██║██║██╔══██╗██║╚════██║ ");
|
||||
ESP_LOGI(LOGO_TAG, " ╚██████╔╝██║ ███████╗██║ ╚████║██║██║ ██║██║███████║ ");
|
||||
ESP_LOGI(LOGO_TAG, " ╚═════╝ ╚═╝ ╚══════╝╚═╝ ╚═══╝╚═╝╚═╝ ╚═╝╚═╝╚══════╝ ");
|
||||
ESP_LOGI(LOGO_TAG, " ");
|
||||
ESP_LOGI(LOGO_TAG, " ██████████████ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▓▓▓▓▒▒▒▒▒▒▒▒░░▒▒▓▓▓▓██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ████▓▓░░░░▒▒░░░░░░▒▒░░░░░░▒▒░░████ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▒▒▓▓▓▓▒▒▒▒░░░░░░▒▒░░▒▒░░░░░░▒▒░░▒▒▓▓▓▓ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▒▒▒▒▒▒▒▒░░▒▒░░░░░░░░░░░░▒▒░░░░▒▒░░░░▒▒░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▓▓░░░░▒▒░░░░▒▒▒▒░░░░░░░░░░▒▒░░ ░░░░░░░░▒▒░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▓▓▓▓▓▓▓▓░░░░░░▒▒░░░░░░░░░░░░░░ ░░░░░░░░░░░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░▒▒░░░░░░░░░░░░ ░░ ▒▒▒▒██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▒▒▒▒▒▒▒▒░░░░▒▒░░░░░░░░░░░░░░░░░░ ░░░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ▓▓▓▓▒▒▒▒▒▒▒▒▒▒░░░░░░▒▒░░░░░░░░░░░░░░░░░░▓▓▓▓▓▓▓▓▓▓ ░░ ▒▒▓▓ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓▓▓▓ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ▓▓▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░ ▓▓▒▒▒▒▒▒▒▒░░░░▒▒▒▒▓▓▒▒ ░░▒▒▓▓ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▒▒░░░░░░▒▒▒▒▒▒░░░░░░░░░░░░░░░░▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░▒▒▓▓▓▓ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▓▓▒▒▒▒▒▒▒▒░░░░▒▒░░░░░░░░░░░░ ▒▒▒▒▒▒▒▒▒▒▒▒████▓▓░░░░▒▒▓▓ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▒▒▒▒▒▒▓▓▒▒▓▓░░░░░░░░░░░░░░░░░░▓▓▒▒▒▒░░▒▒▒▒████ ▒▒██░░▒▒▓▓▓▓ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░▓▓░░▒▒▒▒▒▒██████▒▒ ▓▓▓▓░░▓▓▓▓ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▒▒▒▒░░▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░▓▓▒▒░░▒▒░░████████▓▓ ██▓▓▒▒▓▓ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▓▓▓▓▓▓▒▒▒▒▒▒░░░░░░▒▒░░░░░░░░░░▒▒░░▒▒░░▒▒██████████▒▒██▒▒▒▒▓▓ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▒▒▒▒▒▒░░░░░░░░▒▒▒▒░░░░░░░░░░░░▒▒▒▒░░░░▒▒██▒▒██████ ██▒▒▒▒▓▓ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▒▒░░▓▓▓▓▓▓▒▒░░░░░░░░░░░░░░░░▒▒░░ ▒▒░░██ ▒▒████▒▒██▒▒▒▒▓▓ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▓▓▓▓▓▓░░▒▒▒▒░░▒▒░░░░░░░░░░░░░░▒▒▒▒░░░░░░▒▒██ ██████▒▒▒▒▒▒▓▓░░░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓██▓▓▒▒▒▒▓▓░░░░▒▒░░░░░░░░░░░░░░░░░░▒▒▒▒░░▒▒░░▒▒██████▒▒▒▒▒▒▓▓ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓██▒▒▒▒▒▒▒▒▓▓▓▓▒▒░░░░░░░░░░░░░░░░░░▒▒░░▒▒░░▒▒░░▒▒░░▒▒▒▒▒▒▒▒▓▓░░░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▓▓██▓▓▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░▒▒░░▒▒░░░░░░▒▒▒▒▒▒▒▒▓▓ ░░░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▓▓██▓▓▓▓▒▒▒▒▒▒▒▒░░░░░░░░▒▒░░░░░░░░░░░░▒▒▒▒▒▒░░▒▒▒▒▒▒▓▓▓▓ ░░░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ▓▓▓▓▒▒▒▒▓▓██▓▓▒▒▒▒▒▒░░░░▒▒▒▒░░▒▒░░░░░░░░░░░░░░░░░░▒▒▒▒▓▓▓▓▓▓░░░░░░░░▒▒██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▓▓▒▒▓▓██▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ░░ ░░░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▓▓░░▒▒▒▒██▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▓▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒░░▒▒██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▓▓▒▒░░▓▓▒▒██▓▓▒▒▒▒▒▒▒▒░░▓▓▒▒▓▓▒▒░░░░▒▒░░░░░░░░░░░░░░░░░░░░░░▓▓██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▒▒░░▒▒▒▒▒▒▓▓██▓▓▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▓▓░░░░░░░░░░▒▒░░░░▒▒░░▒▒▒▒██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒░░▒▒░░▒▒████ ██▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░▓▓▒▒▒▒▒▒▓▓▒▒██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▓▓░░▒▒░░▓▓ ████▓▓▒▒▓▓▒▒▒▒▒▒░░▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒██▓▓ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▒▒▒▒ ██ ████▓▓▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒████ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▒▒▒▒░░██ ██████▓▓▒▒▒▒▒▒▒▒▓▓▓▓██████ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▒▒▒▒░░ ████ ██████████████ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▒▒▒▒▒▒▒▒░░ ░░████ ");
|
||||
ESP_LOGI(LOGO_TAG, " ████▒▒▒▒▒▒░░░░ ░░████ ");
|
||||
ESP_LOGI(LOGO_TAG, " ████▒▒▒▒▒▒░░░░ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ████▒▒▒▒▒▒░░ ░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██▓▓▒▒▒▒░░ ▒▒▓▓ ");
|
||||
ESP_LOGI(LOGO_TAG, " ████▒▒░░ ▒▒██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ▓▓▒▒░░░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██░░ ██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ▓▓██ ██░░░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██░░██ ██░░░░██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██░░██ ██░░▒▒██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ██░░▒▒████░░▒▒██ ");
|
||||
ESP_LOGI(LOGO_TAG, " ▓▓▒▒▒▒▒▒▒▒▓▓ ");
|
||||
ESP_LOGI(LOGO_TAG, " ████████ ");
|
||||
ESP_LOGI(LOGO_TAG, " ");
|
||||
ESP_LOGI(LOGO_TAG, " <============================================================================================================================> ");
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
4
components/wifiManager/CMakeLists.txt
Normal file
4
components/wifiManager/CMakeLists.txt
Normal file
@@ -0,0 +1,4 @@
|
||||
idf_component_register(SRCS "wifiManager/wifiManager.cpp"
|
||||
INCLUDE_DIRS "wifiManager"
|
||||
REQUIRES esp_wifi nvs_flash esp_event esp_netif lwip
|
||||
)
|
||||
113
components/wifiManager/wifiManager/wifiManager.cpp
Normal file
113
components/wifiManager/wifiManager/wifiManager.cpp
Normal file
@@ -0,0 +1,113 @@
|
||||
#include "wifiManager.hpp"
|
||||
|
||||
WiFiManager::state_e WiFiManager::_state = {state_e::NOT_INITIALIZED};
|
||||
|
||||
void event_handler(void *arg, esp_event_base_t event_base,
|
||||
int32_t event_id, void *event_data)
|
||||
{
|
||||
ESP_LOGI(WIFI_MAMANGER_TAG, "Trying to connect, got event: %d", (int)event_id);
|
||||
if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START)
|
||||
{
|
||||
esp_err_t err = esp_wifi_connect();
|
||||
if (err != ESP_OK)
|
||||
{
|
||||
ESP_LOGI(WIFI_MAMANGER_TAG, "esp_wifi_connect() failed: %s", esp_err_to_name(err));
|
||||
// xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
|
||||
}
|
||||
}
|
||||
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED)
|
||||
{
|
||||
if (s_retry_num < EXAMPLE_ESP_MAXIMUM_RETRY)
|
||||
{
|
||||
esp_wifi_connect();
|
||||
s_retry_num++;
|
||||
ESP_LOGI(WIFI_MAMANGER_TAG, "retry to connect to the AP");
|
||||
}
|
||||
else
|
||||
{
|
||||
xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
|
||||
}
|
||||
ESP_LOGI(WIFI_MAMANGER_TAG, "connect to the AP fail");
|
||||
}
|
||||
|
||||
else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP)
|
||||
{
|
||||
ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
|
||||
ESP_LOGI(WIFI_MAMANGER_TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));
|
||||
s_retry_num = 0;
|
||||
xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
|
||||
}
|
||||
}
|
||||
|
||||
void WiFiManager::SetCredentials(const char *ssid, const char *password)
|
||||
{
|
||||
memcpy(_wifi_cfg.sta.ssid, ssid, std::min(strlen(ssid), sizeof(_wifi_cfg.sta.ssid)));
|
||||
|
||||
memcpy(_wifi_cfg.sta.password, password, std::min(strlen(password), sizeof(_wifi_cfg.sta.password)));
|
||||
}
|
||||
|
||||
void WiFiManager::Begin()
|
||||
{
|
||||
s_wifi_event_group = xEventGroupCreate();
|
||||
|
||||
ESP_ERROR_CHECK(esp_netif_init());
|
||||
ESP_ERROR_CHECK(esp_event_loop_create_default());
|
||||
esp_netif_create_default_wifi_sta();
|
||||
|
||||
wifi_init_config_t esp_wifi_init_config = WIFI_INIT_CONFIG_DEFAULT();
|
||||
ESP_ERROR_CHECK(esp_wifi_init(&esp_wifi_init_config));
|
||||
|
||||
ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
|
||||
ESP_EVENT_ANY_ID,
|
||||
&event_handler,
|
||||
NULL,
|
||||
&instance_any_id));
|
||||
ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
|
||||
IP_EVENT_STA_GOT_IP,
|
||||
&event_handler,
|
||||
NULL,
|
||||
&instance_got_ip));
|
||||
|
||||
_wifi_cfg = {};
|
||||
_wifi_cfg.sta.threshold.authmode = WIFI_AUTH_WEP;
|
||||
_wifi_cfg.sta.pmf_cfg.capable = true;
|
||||
_wifi_cfg.sta.pmf_cfg.required = false;
|
||||
|
||||
// we try to connect with the hardcoded credentials first
|
||||
// todo, add support for more networks and setting up an AP
|
||||
this->SetCredentials(CONFIG_WIFI_SSID, CONFIG_WIFI_PASSOWRD);
|
||||
|
||||
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
|
||||
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &_wifi_cfg));
|
||||
|
||||
_state = state_e::READY_TO_CONNECT;
|
||||
esp_wifi_start();
|
||||
ESP_LOGI(WIFI_MAMANGER_TAG, "wifi_init_sta finished.");
|
||||
|
||||
_state = state_e::CONNECTING;
|
||||
EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
|
||||
WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
|
||||
pdFALSE,
|
||||
pdFALSE,
|
||||
portMAX_DELAY);
|
||||
|
||||
/* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually
|
||||
* happened. */
|
||||
if (bits & WIFI_CONNECTED_BIT)
|
||||
{
|
||||
ESP_LOGI(WIFI_MAMANGER_TAG, "connected to ap SSID:%s password:%s",
|
||||
_wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
|
||||
_state = state_e::CONNECTED;
|
||||
}
|
||||
|
||||
else if (bits & WIFI_FAIL_BIT)
|
||||
{
|
||||
ESP_LOGE(WIFI_MAMANGER_TAG, "Failed to connect to SSID:%s, password:%s",
|
||||
_wifi_cfg.sta.ssid, _wifi_cfg.sta.password);
|
||||
_state = state_e::ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
ESP_LOGE(WIFI_MAMANGER_TAG, "UNEXPECTED EVENT");
|
||||
}
|
||||
}
|
||||
58
components/wifiManager/wifiManager/wifiManager.hpp
Normal file
58
components/wifiManager/wifiManager/wifiManager.hpp
Normal file
@@ -0,0 +1,58 @@
|
||||
#pragma once
|
||||
#ifndef WIFIHANDLER_HPP
|
||||
#define WIFIHANDLER_HPP
|
||||
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include "esp_event.h"
|
||||
#include "esp_wifi.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
#define EXAMPLE_ESP_MAXIMUM_RETRY 3
|
||||
#define WIFI_CONNECTED_BIT BIT0
|
||||
#define WIFI_FAIL_BIT BIT1
|
||||
|
||||
static int s_retry_num = 0;
|
||||
static EventGroupHandle_t s_wifi_event_group;
|
||||
static const char *WIFI_MAMANGER_TAG = "[WIFI_MANAGER]";
|
||||
|
||||
class WiFiManager
|
||||
{
|
||||
public:
|
||||
public:
|
||||
enum class state_e
|
||||
{
|
||||
NOT_INITIALIZED,
|
||||
INITIALIZED,
|
||||
READY_TO_CONNECT,
|
||||
CONNECTING,
|
||||
WAITING_FOR_IP,
|
||||
CONNECTED,
|
||||
DISCONNECTED,
|
||||
ERROR
|
||||
};
|
||||
|
||||
private:
|
||||
uint8_t channel;
|
||||
wifi_init_config_t _wifi_init_cfg = WIFI_INIT_CONFIG_DEFAULT();
|
||||
wifi_config_t _wifi_cfg = {};
|
||||
|
||||
esp_event_handler_instance_t instance_any_id;
|
||||
esp_event_handler_instance_t instance_got_ip;
|
||||
|
||||
static state_e _state;
|
||||
|
||||
int8_t power;
|
||||
bool _enable_adhoc;
|
||||
|
||||
// static void event_handler(void *arg, esp_event_base_t event_base,
|
||||
// int32_t event_id, void *event_data);
|
||||
|
||||
public:
|
||||
void SetCredentials(const char *ssid, const char *password);
|
||||
constexpr const state_e &GetState(void) { return _state; }
|
||||
void Begin();
|
||||
};
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user