xPablo.cz/arduino-esp32-custom-lwip-ppp-enabled
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Prvni ulozeni z chegewara githubu

Browse Source
This commit is contained in:
Pavel Brychta
2023-02-25 16:13:53 +01:00
commit 01eb80dfe2
3279 changed files with 638407 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
libraries/Preferences/examples/Prefs2Struct/Prefs2Struct.ino Normal file
View File

@ -0,0 +1,43 @@
/*
This example shows how to use Preferences (nvs) to store a
structure. Note that the maximum size of a putBytes is 496K
or 97% of the nvs partition size. nvs has signifcant overhead,
so should not be used for data that will change often.
*/
#include <Preferences.h>
Preferences prefs;
typedef struct {
uint8_t hour;
uint8_t minute;
uint8_t setting1;
uint8_t setting2;
} schedule_t;
void setup() {
Serial.begin(115200);
prefs.begin("schedule"); // use "schedule" namespace
uint8_t content[] = {9, 30, 235, 255, 20, 15, 0, 1}; // two entries
prefs.putBytes("schedule", content, sizeof(content));
size_t schLen = prefs.getBytesLength("schedule");
char buffer[schLen]; // prepare a buffer for the data
prefs.getBytes("schedule", buffer, schLen);
if (schLen % sizeof(schedule_t)) { // simple check that data fits
log_e("Data is not correct size!");
return;
}
schedule_t *schedule = (schedule_t *) buffer; // cast the bytes into a struct ptr
Serial.printf("%02d:%02d %d/%d\n",
schedule[1].hour, schedule[1].minute,
schedule[1].setting1, schedule[1].setting2);
schedule[2] = {8, 30, 20, 21}; // add a third entry (unsafely)
// force the struct array into a byte array
prefs.putBytes("schedule", schedule, 3*sizeof(schedule_t));
schLen = prefs.getBytesLength("schedule");
char buffer2[schLen];
prefs.getBytes("schedule", buffer2, schLen);
for (int x=0; x<schLen; x++) Serial.printf("%02X ", buffer[x]);
Serial.println();
}
void loop() {}

56
libraries/Preferences/examples/StartCounter/StartCounter.ino Normal file
View File

@ -0,0 +1,56 @@
/*
ESP32 startup counter example with Preferences library.
This simple example demonstrates using the Preferences library to store how many times
the ESP32 module has booted. The Preferences library is a wrapper around the Non-volatile
storage on ESP32 processor.
created for arduino-esp32 09 Feb 2017
by Martin Sloup (Arcao)
*/
#include <Preferences.h>
Preferences preferences;
void setup() {
Serial.begin(115200);
Serial.println();
// Open Preferences with my-app namespace. Each application module, library, etc
// has to use a namespace name to prevent key name collisions. We will open storage in
// RW-mode (second parameter has to be false).
// Note: Namespace name is limited to 15 chars.
preferences.begin("my-app", false);
// Remove all preferences under the opened namespace
//preferences.clear();
// Or remove the counter key only
//preferences.remove("counter");
// Get the counter value, if the key does not exist, return a default value of 0
// Note: Key name is limited to 15 chars.
unsigned int counter = preferences.getUInt("counter", 0);
// Increase counter by 1
counter++;
// Print the counter to Serial Monitor
Serial.printf("Current counter value: %u\n", counter);
// Store the counter to the Preferences
preferences.putUInt("counter", counter);
// Close the Preferences
preferences.end();
// Wait 10 seconds
Serial.println("Restarting in 10 seconds...");
delay(10000);
// Restart ESP
ESP.restart();
}
void loop() {}

54
libraries/Preferences/keywords.txt Normal file
View File

@ -0,0 +1,54 @@
#######################################
# Syntax Coloring Map NVS
#######################################
#######################################
# Datatypes (KEYWORD1)
#######################################
Preferences KEYWORD1
#######################################
# Methods and Functions (KEYWORD2)
#######################################
begin KEYWORD2
end KEYWORD2
clear KEYWORD2
remove KEYWORD2
putChar KEYWORD2
putUChar KEYWORD2
putShort KEYWORD2
putUShort KEYWORD2
putInt KEYWORD2
putUInt KEYWORD2
putLong KEYWORD2
putULong KEYWORD2
putLong64 KEYWORD2
putULong64 KEYWORD2
putFloat KEYWORD2
putDouble KEYWORD2
putBool KEYWORD2
putString KEYWORD2
putBytes KEYWORD2
getChar KEYWORD2
getUChar KEYWORD2
getShort KEYWORD2
getUShort KEYWORD2
getInt KEYWORD2
getUInt KEYWORD2
getLong KEYWORD2
getULong KEYWORD2
getLong64 KEYWORD2
getULong64 KEYWORD2
getFloat KEYWORD2
getDouble KEYWORD2
getBool KEYWORD2
getString KEYWORD2
getBytes KEYWORD2
#######################################
# Constants (LITERAL1)
#######################################

9
libraries/Preferences/library.properties Normal file
View File

@ -0,0 +1,9 @@
name=Preferences
version=2.0.0
author=Hristo Gochkov
maintainer=Hristo Gochkov <hristo@espressif.com>
sentence=Provides friendly access to ESP32's Non-Volatile Storage
paragraph=
category=Data Storage
url=
architectures=esp32

534
libraries/Preferences/src/Preferences.cpp Normal file
View File

@ -0,0 +1,534 @@
// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "Preferences.h"
#include "nvs.h"
#include "nvs_flash.h"
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)
{}
Preferences::~Preferences(){
end();
}
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) {
log_e("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){
log_e("nvs_open failed: %s", nvs_error(err));
return false;
}
_started = true;
return true;
}
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){
log_e("nvs_erase_all fail: %s", nvs_error(err));
return false;
}
err = nvs_commit(_handle);
if(err){
log_e("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){
log_e("nvs_erase_key fail: %s %s", key, nvs_error(err));
return false;
}
err = nvs_commit(_handle);
if(err){
log_e("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){
log_e("nvs_set_i8 fail: %s %s", key, nvs_error(err));
return 0;
}
err = nvs_commit(_handle);
if(err){
log_e("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){
log_e("nvs_set_u8 fail: %s %s", key, nvs_error(err));
return 0;
}
err = nvs_commit(_handle);
if(err){
log_e("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){
log_e("nvs_set_i16 fail: %s %s", key, nvs_error(err));
return 0;
}
err = nvs_commit(_handle);
if(err){
log_e("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){
log_e("nvs_set_u16 fail: %s %s", key, nvs_error(err));
return 0;
}
err = nvs_commit(_handle);
if(err){
log_e("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){
log_e("nvs_set_i32 fail: %s %s", key, nvs_error(err));
return 0;
}
err = nvs_commit(_handle);
if(err){
log_e("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){
log_e("nvs_set_u32 fail: %s %s", key, nvs_error(err));
return 0;
}
err = nvs_commit(_handle);
if(err){
log_e("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){
log_e("nvs_set_i64 fail: %s %s", key, nvs_error(err));
return 0;
}
err = nvs_commit(_handle);
if(err){
log_e("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){
log_e("nvs_set_u64 fail: %s %s", key, nvs_error(err));
return 0;
}
err = nvs_commit(_handle);
if(err){
log_e("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){
log_e("nvs_set_str fail: %s %s", key, nvs_error(err));
return 0;
}
err = nvs_commit(_handle);
if(err){
log_e("nvs_commit fail: %s %s", key, nvs_error(err));
return 0;
}
return strlen(value);
}
size_t Preferences::putString(const char* key, const 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){
log_e("nvs_set_blob fail: %s %s", key, nvs_error(err));
return 0;
}
err = nvs_commit(_handle);
if(err){
log_e("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){
log_v("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){
log_v("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){
log_v("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){
log_v("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){
log_v("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){
log_v("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){
log_v("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){
log_v("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){
log_e("nvs_get_str len fail: %s %s", key, nvs_error(err));
return 0;
}
if(len > maxLen){
log_e("not enough space in value: %u < %u", maxLen, len);
return 0;
}
err = nvs_get_str(_handle, key, value, &len);
if(err){
log_e("nvs_get_str fail: %s %s", key, nvs_error(err));
return 0;
}
return len;
}
String Preferences::getString(const char* key, const String defaultValue){
char * value = NULL;
size_t len = 0;
if(!_started || !key){
return String(defaultValue);
}
esp_err_t err = nvs_get_str(_handle, key, value, &len);
if(err){
log_e("nvs_get_str len fail: %s %s", key, nvs_error(err));
return String(defaultValue);
}
char buf[len];
value = buf;
err = nvs_get_str(_handle, key, value, &len);
if(err){
log_e("nvs_get_str fail: %s %s", key, nvs_error(err));
return String(defaultValue);
}
return 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){
log_e("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){
log_e("not enough space in buffer: %u < %u", maxLen, len);
return 0;
}
esp_err_t err = nvs_get_blob(_handle, key, buf, &len);
if(err){
log_e("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){
log_e("Failed to get nvs statistics");
return 0;
}
return nvs_stats.free_entries;
}

77
libraries/Preferences/src/Preferences.h Normal file
View File

@ -0,0 +1,77 @@
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef _PREFERENCES_H_
#define _PREFERENCES_H_
#include "Arduino.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=NULL);
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, 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);
String getString(const char* key, String defaultValue = String());
size_t getBytesLength(const char* key);
size_t getBytes(const char* key, void * buf, size_t maxLen);
size_t freeEntries();
};
#endif