mirror of
https://github.com/liquidraver/ZephCore.git
synced 2026-10-15 21:49:55 +00:00
liquidraver
38f815a0a1
Server roles (slice 7) - CommonCLI split into upstream's shape; region CLI moved into CommonCLI; ClientACL, RegionMap, TransportKeyStore and both server meshes in upstream shape over an Arduino compat shim (helpers/compat: Arduino.h, Stream/Print, Serial, SHA256, FILESYSTEM/File over Zephyr fs) - room server processAck port; `get acl` prints as upstream - room: default name Room-XXXX, display/input rotation, live radio UI refresh Event loops (slice 7b) - repeater and room server share server_main_common with a ServerRole descriptor; shared event bits in src/mesh_events.h - room server deadline-driven (idle wakes 2.2/s -> 0.08/s); companion loop() runs on housekeeping (closes the lazy contact-flush gap) - `get loop.wakes` in debug builds (CONFIG_ZEPHCORE_LOOP_WAKE_STATS) Companion transports and WiFi (slice 8) - upstream MultiSerialInterface: BLE, USB/UART and TCP are each a BaseSerialInterface, every connected transport gets every frame; CompanionSerial holds a lossless reply; shared frame_txq for BLE/TCP - SerialCompanionTransport and LinuxTCPTransport replaced by TcpCompanionTransport; ZephyrBLE split (gatt layout, DFU) - WiFi companion (upstream wifi.ssid/pwd/enabled CLI, TCP port 5000) on boards declaring `capabilities: wifi` in zephcore.yml: the PSRAM ESP32-S3 boards, plus Heltec V3 (140 contacts), Wireless Tracker (130) and both C6 boards (280); ESP32-S3 without PSRAM gets bounded WiFi buffers and a measured 72 KB heap; PSRAM boards' internal heap 72 KB - TCP queues: own depth (ZEPHCORE_TCP_QUEUE_SIZE=8), RX waits instead of dropping - RAM: companion ClientACL dropped; main/BT-TX/TCP stacks sized from measured peaks (-7 KB nRF companions, -9 KB ESP32 companions) - ESP32 WiFi stopped working under ~200 frames/s unicast. Fixed by: patches/zephyr/0017 never block the WiFi task in the RX callback; patches/zephyr/0018 lock shared_multi_heap (heap corruption with the WiFi heap in PSRAM); patches/modules/hal_espressif/0001 backport of hal_espressif af97fb02df (PSRAM realloc) Storage and prefs (slice 9) - prefs are now prefs.json through upstream's ConfigSerializer (ported verbatim), with upstream's key names for shared fields and ZephCore's own under "zc"; on first boot the binary new_prefs / repeater prefs is migrated and kept, so a downgrade still boots with the old settings - helpers/PrefsCodec: both legacy binary layouts (companion 272 B, server 311 B) as Zephyr-free codecs; sanitizeNodePrefs is the only validator - fix: server prefs could be replaced by a truncated file when a write failed; identity, prefs and channel writes go through one checked atomic replace (ZephyrFsUtil) - fix: a corrupt cad_auto byte turned adaptive CAD off instead of the default on - fix: a deliberate 300 s GPS duty on a repeater was rewritten to 48 h on every boot (that migration now runs on legacy files only) - one identity loader for all roles (IdentityFile); an unusable key file is always parked as .bad before regenerating - server store no longer stamps repeater defaults on room server and observer; companion first-boot volume policy moved into the store (adoptVolume) - ZephyrDataStore 1435 -> ~850 lines
113 lines
2.0 KiB
C++
113 lines
2.0 KiB
C++
/*
|
|
* SPDX-License-Identifier: MIT
|
|
*/
|
|
|
|
#include "ZephyrFS.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
bool File::openPath(const char *path, fs_mode_t flags)
|
|
{
|
|
close();
|
|
fs_file_t_init(&_file);
|
|
_open = fs_open(&_file, path, flags) == 0;
|
|
return _open;
|
|
}
|
|
|
|
size_t File::read(uint8_t *buf, size_t size)
|
|
{
|
|
if (!_open) {
|
|
return 0;
|
|
}
|
|
ssize_t n = fs_read(&_file, buf, size);
|
|
return n > 0 ? (size_t)n : 0;
|
|
}
|
|
|
|
size_t File::write(const uint8_t *buf, size_t size)
|
|
{
|
|
if (!_open) {
|
|
return 0;
|
|
}
|
|
ssize_t n = fs_write(&_file, buf, size);
|
|
return n > 0 ? (size_t)n : 0;
|
|
}
|
|
|
|
int File::read()
|
|
{
|
|
uint8_t c;
|
|
return read(&c, 1) == 1 ? c : -1;
|
|
}
|
|
|
|
int File::peek()
|
|
{
|
|
int c = read();
|
|
if (c >= 0) {
|
|
fs_seek(&_file, -1, FS_SEEK_CUR);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
int File::available()
|
|
{
|
|
if (!_open) {
|
|
return 0;
|
|
}
|
|
off_t pos = fs_tell(&_file);
|
|
if (pos < 0 || fs_seek(&_file, 0, FS_SEEK_END) < 0) {
|
|
return 0;
|
|
}
|
|
off_t end = fs_tell(&_file);
|
|
fs_seek(&_file, pos, FS_SEEK_SET);
|
|
return end > pos ? (int)(end - pos) : 0;
|
|
}
|
|
|
|
void File::close()
|
|
{
|
|
if (_open) {
|
|
fs_close(&_file);
|
|
_open = false;
|
|
}
|
|
}
|
|
|
|
void ZephyrFS::fullPath(char *dest, size_t dest_len, const char *path) const
|
|
{
|
|
snprintf(dest, dest_len, "%s%s%s", _root, path[0] == '/' ? "" : "/", path);
|
|
}
|
|
|
|
bool ZephyrFS::exists(const char *path)
|
|
{
|
|
char full[64];
|
|
fullPath(full, sizeof(full), path);
|
|
struct fs_dirent entry;
|
|
return fs_stat(full, &entry) == 0;
|
|
}
|
|
|
|
File ZephyrFS::open(const char *path, const char *mode, bool create)
|
|
{
|
|
char full[64];
|
|
fullPath(full, sizeof(full), path);
|
|
File file;
|
|
if (mode[0] == 'w') {
|
|
fs_unlink(full); /* truncate: LittleFS rewrites a file in place otherwise */
|
|
file.openPath(full, FS_O_CREATE | FS_O_WRITE);
|
|
} else {
|
|
file.openPath(full, FS_O_READ);
|
|
}
|
|
(void)create;
|
|
return file;
|
|
}
|
|
|
|
bool ZephyrFS::remove(const char *path)
|
|
{
|
|
char full[64];
|
|
fullPath(full, sizeof(full), path);
|
|
return fs_unlink(full) == 0;
|
|
}
|
|
|
|
bool ZephyrFS::mkdir(const char *path)
|
|
{
|
|
char full[64];
|
|
fullPath(full, sizeof(full), path);
|
|
return fs_mkdir(full) == 0;
|
|
}
|