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

77
libraries/EEPROM/examples/eeprom_class/eeprom_class.ino Normal file
View File

@ -0,0 +1,77 @@
/*
ESP32 eeprom_class example with EEPROM library
This simple example demonstrates using EEPROM library to store different data in
ESP32 Flash memory in a multiple user-defined EEPROM class objects.
Created for arduino-esp32 on 25 Dec, 2017
by Elochukwu Ifediora (fedy0)
converted to nvs by lbernstone - 06/22/2019
*/
#include "EEPROM.h"
// Instantiate eeprom objects with parameter/argument names and sizes
EEPROMClass NAMES("eeprom0");
EEPROMClass HEIGHT("eeprom1");
EEPROMClass AGE("eeprom2");
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("Testing EEPROMClass\n");
if (!NAMES.begin(0x500)) {
Serial.println("Failed to initialise NAMES");
Serial.println("Restarting...");
delay(1000);
ESP.restart();
}
if (!HEIGHT.begin(0x200)) {
Serial.println("Failed to initialise HEIGHT");
Serial.println("Restarting...");
delay(1000);
ESP.restart();
}
if (!AGE.begin(0x100)) {
Serial.println("Failed to initialise AGE");
Serial.println("Restarting...");
delay(1000);
ESP.restart();
}
const char* name = "Teo Swee Ann";
char rname[32];
double height = 5.8;
uint32_t age = 47;
// Write: Variables ---> EEPROM stores
NAMES.writeString(0, name);
HEIGHT.put(0, height);
AGE.put(0, age);
Serial.print("name: "); Serial.println(name);
Serial.print("height: "); Serial.println(height);
Serial.print("age: "); Serial.println(age);
Serial.println("------------------------------------\n");
// Clear variables
rname[0] = '\0';
height = 0;
age = 0;
Serial.print("name: "); Serial.println(rname);
Serial.print("height: "); Serial.println(height);
Serial.print("age: "); Serial.println(age);
Serial.println("------------------------------------\n");
// Read: Variables <--- EEPROM stores
NAMES.get(0, rname);
HEIGHT.get(0, height);
AGE.get(0, age);
Serial.print("name: "); Serial.println(rname);
Serial.print("height: "); Serial.println(height);
Serial.print("age: "); Serial.println(age);
Serial.println("Done!");
}
void loop() {
delay(0xFFFFFFFF);
}

139
libraries/EEPROM/examples/eeprom_extra/eeprom_extra.ino Normal file
View File

@ -0,0 +1,139 @@
/*
ESP32 eeprom_extra example with EEPROM library
This simple example demonstrates using other EEPROM library resources
Created for arduino-esp32 on 25 Dec, 2017
by Elochukwu Ifediora (fedy0)
*/
#include "EEPROM.h"
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
Serial.println("\nTesting EEPROM Library\n");
if (!EEPROM.begin(1000)) {
Serial.println("Failed to initialise EEPROM");
Serial.println("Restarting...");
delay(1000);
ESP.restart();
}
int address = 0;
EEPROM.writeByte(address, -128); // -2^7
address += sizeof(byte);
EEPROM.writeChar(address, 'A'); // Same as writyByte and readByte
address += sizeof(char);
EEPROM.writeUChar(address, 255); // 2^8 - 1
address += sizeof(unsigned char);
EEPROM.writeShort(address, -32768); // -2^15
address += sizeof(short);
EEPROM.writeUShort(address, 65535); // 2^16 - 1
address += sizeof(unsigned short);
EEPROM.writeInt(address, -2147483648); // -2^31
address += sizeof(int);
EEPROM.writeUInt(address, 4294967295); // 2^32 - 1
address += sizeof(unsigned int);
EEPROM.writeLong(address, -2147483648); // Same as writeInt and readInt
address += sizeof(long);
EEPROM.writeULong(address, 4294967295); // Same as writeUInt and readUInt
address += sizeof(unsigned long);
int64_t value = -1223372036854775808LL; // -2^63
EEPROM.writeLong64(address, value);
address += sizeof(int64_t);
uint64_t Value = 18446744073709551615ULL; // 2^64 - 1
EEPROM.writeULong64(address, Value);
address += sizeof(uint64_t);
EEPROM.writeFloat(address, 1234.1234);
address += sizeof(float);
EEPROM.writeDouble(address, 123456789.123456789);
address += sizeof(double);
EEPROM.writeBool(address, true);
address += sizeof(bool);
String sentence = "I love ESP32.";
EEPROM.writeString(address, sentence);
address += sentence.length() + 1;
char gratitude[21] = "Thank You Espressif!";
EEPROM.writeString(address, gratitude);
address += 21;
// See also the general purpose writeBytes() and readBytes() for BLOB in EEPROM library
EEPROM.commit();
address = 0;
Serial.println(EEPROM.readByte(address));
address += sizeof(byte);
Serial.println((char)EEPROM.readChar(address));
address += sizeof(char);
Serial.println(EEPROM.readUChar(address));
address += sizeof(unsigned char);
Serial.println(EEPROM.readShort(address));
address += sizeof(short);
Serial.println(EEPROM.readUShort(address));
address += sizeof(unsigned short);
Serial.println(EEPROM.readInt(address));
address += sizeof(int);
Serial.println(EEPROM.readUInt(address));
address += sizeof(unsigned int);
Serial.println(EEPROM.readLong(address));
address += sizeof(long);
Serial.println(EEPROM.readULong(address));
address += sizeof(unsigned long);
value = 0;
value = EEPROM.readLong64(value);
Serial.printf("0x%08X", (uint32_t)(value >> 32)); // Print High 4 bytes in HEX
Serial.printf("%08X\n", (uint32_t)value); // Print Low 4 bytes in HEX
address += sizeof(int64_t);
Value = 0; // Clear Value
Value = EEPROM.readULong64(Value);
Serial.printf("0x%08X", (uint32_t)(Value >> 32)); // Print High 4 bytes in HEX
Serial.printf("%08X\n", (uint32_t)Value); // Print Low 4 bytes in HEX
address += sizeof(uint64_t);
Serial.println(EEPROM.readFloat(address), 4);
address += sizeof(float);
Serial.println(EEPROM.readDouble(address), 8);
address += sizeof(double);
Serial.println(EEPROM.readBool(address));
address += sizeof(bool);
Serial.println(EEPROM.readString(address));
address += sentence.length() + 1;
Serial.println(EEPROM.readString(address));
address += 21;
}
void loop() {
// put your main code here, to run repeatedly:
}

63
libraries/EEPROM/examples/eeprom_write/eeprom_write.ino Normal file
View File

@ -0,0 +1,63 @@
/*
EEPROM Write
Stores random values into the EEPROM.
These values will stay in the EEPROM when the board is
turned off and may be retrieved later by another sketch.
*/
#include "EEPROM.h"
// the current address in the EEPROM (i.e. which byte
// we're going to write to next)
int addr = 0;
#define EEPROM_SIZE 64
void setup()
{
Serial.begin(115200);
Serial.println("start...");
if (!EEPROM.begin(EEPROM_SIZE))
{
Serial.println("failed to initialise EEPROM"); delay(1000000);
}
Serial.println(" bytes read from Flash . Values are:");
for (int i = 0; i < EEPROM_SIZE; i++)
{
Serial.print(byte(EEPROM.read(i))); Serial.print(" ");
}
Serial.println();
Serial.println("writing random n. in memory");
}
void loop()
{
// need to divide by 4 because analog inputs range from
// 0 to 1023 and each byte of the EEPROM can only hold a
// value from 0 to 255.
// int val = analogRead(10) / 4;
int val = byte(random(10020));
// write the value to the appropriate byte of the EEPROM.
// these values will remain there when the board is
// turned off.
EEPROM.write(addr, val);
Serial.print(val); Serial.print(" ");
// advance to the next address. there are 512 bytes in
// the EEPROM, so go back to 0 when we hit 512.
// save all changes to the flash.
addr = addr + 1;
if (addr == EEPROM_SIZE)
{
Serial.println();
addr = 0;
EEPROM.commit();
Serial.print(EEPROM_SIZE);
Serial.println(" bytes written on Flash . Values are:");
for (int i = 0; i < EEPROM_SIZE; i++)
{
Serial.print(byte(EEPROM.read(i))); Serial.print(" ");
}
Serial.println(); Serial.println("----------------------------------");
}
delay(100);
}