stockcropper/SC-F001
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

DNS, web ui nearly done, great log streaming, attempted https (abandoned that though)

Browse Source
This commit is contained in:
Thaddeus Hughes
2025-12-30 18:51:11 -06:00
parent 012d28ae14
commit d46cb252fb
134 changed files with 19226 additions and 740 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
main/storage.h
View File

@@ -1,5 +1,5 @@
/*
* storage.h
* storage.h - Simple variable-size parameter storage with per-param CRC
*
* Created on: Nov 5, 2025
* Author: Thad
@@ -17,9 +17,10 @@
#include <stdarg.h>
#include "i2c.h"
#define PARAM_CRC_SALT 0xDEADBEEF // Salt to prevent all-zero CRC collision
// Union for parameter values - now sized appropriately
typedef union {
uint8_t u8;
int8_t i8;
uint16_t u16;
int16_t i16;
uint32_t u32;
@@ -28,25 +29,43 @@ typedef union {
int64_t i64;
float f32;
double f64;
char str[16]; // 15 chars + null terminator
} param_value_t;
typedef struct {
param_value_t val;
uint32_t crc;
// Enum for parameter types
typedef enum {
PARAM_TYPE_u16 = 0,
PARAM_TYPE_i16 = 1,
PARAM_TYPE_u32 = 2,
PARAM_TYPE_i32 = 3,
PARAM_TYPE_u64 = 4,
PARAM_TYPE_i64 = 5,
PARAM_TYPE_f32 = 6,
PARAM_TYPE_f64 = 7,
PARAM_TYPE_str = 8
} param_type_e;
// Storage format: each param stored as [data][crc32]
typedef struct __attribute__((packed)) {
uint8_t data[16]; // Max size needed (for strings)
uint32_t crc; // CRC of actual data bytes used
} param_stored_t;
typedef enum {
PARAM_TYPE_u8,
PARAM_TYPE_i8,
PARAM_TYPE_u16,
PARAM_TYPE_i16,
PARAM_TYPE_u32,
PARAM_TYPE_i32,
PARAM_TYPE_u64,
PARAM_TYPE_i64,
PARAM_TYPE_f32,
PARAM_TYPE_f64
} param_type_e;
// Get storage size for a given type (data only, not including CRC)
static inline uint8_t param_type_size(param_type_e type) {
switch(type) {
case PARAM_TYPE_u16:
case PARAM_TYPE_i16: return 2;
case PARAM_TYPE_u32:
case PARAM_TYPE_i32:
case PARAM_TYPE_f32: return 4;
case PARAM_TYPE_u64:
case PARAM_TYPE_i64:
case PARAM_TYPE_f64: return 8;
case PARAM_TYPE_str: return 16;
default: return 8; // Fallback
}
}
// ============================================================================
// PARAMETER DEFINITION MACRO
@@ -56,9 +75,9 @@ typedef enum {
// Examples:
// PARAM_DEF(NUM_MOVES, u32, 0, "")
// PARAM_DEF(EFUSE_1_AS, u16, 2400, "mA")
// PARAM_DEF(JACK_DIST, u8, 5, "mm")
// PARAM_DEF(KEYCODE_0, i64, -1, "")
// PARAM_DEF(TEMPERATURE, f32, 25.5, "C")
// PARAM_DEF(DEVICE_NAME, str, "ESP32", "")
// ============================================================================
// REMEMBER: ORDER IS IMPERATIVE! PARAMETERS ARE ENTERED IN THE TABLE BY INDEX!
// ============================================================================
@@ -68,39 +87,40 @@ typedef enum {
PARAM_DEF(NUM_MOVES, u32, 0, "") \
PARAM_DEF(MOVE_START, u32, 0, "s") \
PARAM_DEF(MOVE_END, u32, 0, "s") \
PARAM_DEF(DRIVE_DIST, u16, 10, "ft") /*4*/\
PARAM_DEF(JACK_DIST, u8, 5, "in") \
PARAM_DEF(DRIVE_DIST, f32, 10, "ft") \
PARAM_DEF(JACK_DIST, f32, 5, "in") \
PARAM_DEF(DRIVE_KE, f32, 4000, "n/ft") \
PARAM_DEF(DRIVE_KT, f32, 600, "ms/ft") \
PARAM_DEF(JACK_KT, f32, 600, "ms/in") /*8*/\
PARAM_DEF(KEYCODE_0, i64, 0x19000000005D0C61, "") \
PARAM_DEF(KEYCODE_1, i64, 0x19000000005D0C62, "") \
PARAM_DEF(KEYCODE_2, i64, 0x19000000005D0C64, "") \
PARAM_DEF(KEYCODE_3, i64, 0x19000000005D0C68, "") /*12*/\
PARAM_DEF(KEYCODE_4, i64, -1, "") \
PARAM_DEF(KEYCODE_5, i64, -1, "") \
PARAM_DEF(KEYCODE_6, i64, -1, "") \
PARAM_DEF(KEYCODE_7, i64, -1, "") /*16*/\
PARAM_DEF(JACK_KT, f32, 600, "ms/in") \
PARAM_DEF(KEYCODE_0, i32, -1, "") \
PARAM_DEF(KEYCODE_1, i32, -1, "") \
PARAM_DEF(KEYCODE_2, i32, -1, "") \
PARAM_DEF(KEYCODE_3, i32, -1, "") \
PARAM_DEF(KEYCODE_4, i32, -1, "") \
PARAM_DEF(KEYCODE_5, i32, -1, "") \
PARAM_DEF(KEYCODE_6, i32, -1, "") \
PARAM_DEF(KEYCODE_7, i32, -1, "") \
PARAM_DEF(ADC_ALPHA_BATTERY, f32, 0.02, "-") \
PARAM_DEF(ADC_ALPHA_ISENS, f32, 0.02, "-") \
PARAM_DEF(ADC_ALPHA_IAZ, f32, 0.005, "-") \
PARAM_DEF(ADC_DB_IAZ, f32, 5.0, "A") /*20*/\
PARAM_DEF(ADC_DB_IAZ, f32, 5.0, "A") \
PARAM_DEF(EFUSE_INOM_1, f32, 40.0, "A") \
PARAM_DEF(EFUSE_INOM_2, f32, 6.0, "A") \
PARAM_DEF(EFUSE_INOM_3, f32, 2.0, "A") \
PARAM_DEF(EFUSE_HEAT_THRESH, f32, 60.0, "i/i^2-s") /*24*/\
PARAM_DEF(EFUSE_HEAT_THRESH, f32, 60.0, "i/i^2-s") \
PARAM_DEF(EFUSE_KINST, f32, 4.0, "i/i") \
PARAM_DEF(EFUSE_TAUCOOL, f32, 0.2, "i") \
PARAM_DEF(EFUSE_TCOOL, i64, 5000000, "us") \
PARAM_DEF(LOW_PROTECTION_V, f32, 10.0, "V") /*28*/\
PARAM_DEF(LOW_PROTECTION_V, f32, 10.0, "V") \
PARAM_DEF(LOW_PROTECTION_S, i64, 10, "s") \
PARAM_DEF(CHG_LOW_V, f32, 5.0, "V") \
PARAM_DEF(CHG_LOW_S, i64, 5.0, "s") \
PARAM_DEF(CHG_BULK_S, i64, 20, "s") /*32*/\
PARAM_DEF(CHG_LOW_S, i64, 5, "s") \
PARAM_DEF(CHG_BULK_S, i64, 20, "s") \
PARAM_DEF(RF_PULSE_LENGTH, u64, 350000, "us") \
PARAM_DEF(V_SENS_OFFSET, f32, 0.4, "V") \
PARAM_DEF(WIFI_CHANNEL, i16, 6, "") \
PARAM_DEF(WIFI_SSID, str, "sc.local", "") \
PARAM_DEF(WIFI_PASS, str, "password", "") \
// Generate enum for parameter indices
@@ -111,9 +131,10 @@ typedef enum {
} param_idx_t;
#undef PARAM_DEF
#define PARAMS_SIZE sizeof(param_stored_t)
#define FLASH_SECTOR_SIZE 4096
#define PARAMS_OFFSET 0
#define PARAMS_TOTAL_SIZE (NUM_PARAMS * PARAMS_SIZE)
#define PARAMETER_NUM_SECTORS 4
#define LOG_START_OFFSET (FLASH_SECTOR_SIZE * PARAMETER_NUM_SECTORS)
// External declarations
extern param_value_t parameter_table[NUM_PARAMS];
@@ -122,36 +143,38 @@ extern const param_type_e parameter_types[NUM_PARAMS];
extern const char* parameter_names[NUM_PARAMS];
extern const char parameter_units[NUM_PARAMS][8];
esp_err_t storage_init();
esp_err_t log_init();
// Core functions
esp_err_t storage_init(void);
esp_err_t log_init(void);
void storage_deinit(void);
// Parameter access functions
param_value_t get_param_value_t(param_idx_t id);
esp_err_t set_param_value_t(param_idx_t id, param_value_t val);
param_type_e get_param_type(param_idx_t id);
const char* get_param_name(param_idx_t id);
param_value_t get_param_default(param_idx_t id);
const char* get_param_unit(param_idx_t id);
const char* get_param_json_string(param_idx_t id, char* buffer, size_t buf_size);
esp_err_t commit_params();
uint32_t get_log_head();
uint32_t get_log_tail();
uint32_t get_log_offset();
esp_err_t write_dummy_log_1();
esp_err_t write_dummy_log_2();
esp_err_t write_dummy_log_3();
// Helper functions for string parameters
esp_err_t set_param_string(param_idx_t id, const char* str);
char* get_param_string(param_idx_t id);
// Storage operations
esp_err_t commit_params(void);
// Log functions
#define LOG_ENTRY_SIZE 32
#define FLASH_SECTOR_SIZE 4096
// Calculate offset for log area (after parameters sector)
#define PARARMETER_NUM_SECTORS 4
#define LOG_START_OFFSET FLASH_SECTOR_SIZE*PARARMETER_NUM_SECTORS
uint32_t get_log_head(void);
uint32_t get_log_tail(void);
uint32_t get_log_offset(void);
esp_err_t write_log(char* entry);
void storage_deinit();
// Test functions
esp_err_t write_dummy_log_1(void);
esp_err_t write_dummy_log_2(void);
esp_err_t write_dummy_log_3(void);
#endif /* MAIN_STORAGE_H_ */