Public Access
twislaandClaude Opus 5.5
2fce79aebd
The Sniffer lists packets newest first (time, RSSI, SNR, and for Meshtastic the sender, receiver and hops), with the clear header and a hex dump on Enter (Q96); `p` picks an EU868 preset, kept in Settings (Q95). `c` starts a Capture: pcap with LoRaTap in /captures/lora, its own Clean-up category, recorded by a small Service so it carries on with the App closed (Q97, Q100). The Status Bar shows L while listening, bright on each packet, and CAP while capturing (Q101). StorageService gains raw appends for binary files. Debug Builds get `lora inject` to test all of this with no transmitter in range: a Capture made on the device reads back in TShark field for field. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EhqxQ49eCju4CzKYNjZzwT
95 lines
3.6 KiB
C++
95 lines
3.6 KiB
C++
#pragma once
|
|
|
|
#include <freertos/FreeRTOS.h>
|
|
#include <freertos/semphr.h>
|
|
|
|
#include <deque>
|
|
#include <functional>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "cleanup_plan.h"
|
|
#include "service.h"
|
|
#include "storage_monitor.h"
|
|
|
|
namespace roro {
|
|
|
|
// Owns the microSD card. All card access happens on this Service's own task (the SD driver isn't
|
|
// safe across tasks, and a failed mount blocks for seconds): it mounts and watches usage, writes
|
|
// queued Log lines in batches, lists files for Storage Clean-up, deletes, and formats.
|
|
class StorageService : public Service {
|
|
public:
|
|
// The lock exists from the start, so a Service that's never started (Safe Mode) can still be asked.
|
|
explicit StorageService(EventBus& bus) : monitor_(bus), bus_(bus), lock_(xSemaphoreCreateMutex()) {}
|
|
const char* name() const override { return "storage"; }
|
|
void start() override;
|
|
void stop() override;
|
|
|
|
StorageState state() const;
|
|
|
|
// Queues one line for a Log file (created with its folders as needed). Dropped while Logs are
|
|
// paused (over 90 % full, or no card) or if too much is already waiting. A Capture (or a Track,
|
|
// something the user started) keeps going past 90 %, until the card is full.
|
|
void appendLine(const std::string& path, const std::string& line, bool capture = false);
|
|
// The same, for binary files (a pcap Capture): the bytes as they are, no newline.
|
|
void appendBytes(const std::string& path, const std::string& bytes, bool capture = false);
|
|
uint32_t droppedLines() const { return dropped_; }
|
|
|
|
// Storage Clean-up: list every file of every category, then delete a selection.
|
|
void requestListing();
|
|
bool listingReady() const;
|
|
std::vector<std::vector<StoredFile>> listing() const; // one vector per kCleanupCategories entry
|
|
void requestDelete(std::vector<std::string> paths);
|
|
|
|
// Runs `job` on the storage task, where card access is safe (e.g. reading an Update File).
|
|
void runJob(std::function<void()> job);
|
|
// The same, and waits for it (from another task, never the storage task itself). False if it
|
|
// never started within 5 s: no card mounted, and then it never will run.
|
|
bool runAndWait(std::function<void()> job);
|
|
|
|
// Erases the whole card: one partition spanning the card, formatted FAT32.
|
|
bool requestFormat();
|
|
bool formatting() const { return formatRequested_; }
|
|
|
|
private:
|
|
static constexpr uint32_t kWakeMs = 1000;
|
|
static constexpr uint32_t kPollEvery = 15; // wake-ups between usage checks
|
|
static constexpr size_t kMaxPendingBytes = 16 * 1024;
|
|
|
|
static void taskEntry(void* self);
|
|
void loop();
|
|
void poll();
|
|
bool mount();
|
|
void format();
|
|
void writePending();
|
|
void list();
|
|
void remove(const std::vector<std::string>& paths);
|
|
void lock() const { xSemaphoreTake(lock_, portMAX_DELAY); }
|
|
void unlock() const { xSemaphoreGive(lock_); }
|
|
|
|
StorageMonitor monitor_;
|
|
EventBus& bus_;
|
|
bool mounted_ = false;
|
|
TaskHandle_t task_ = nullptr;
|
|
mutable SemaphoreHandle_t lock_ = nullptr;
|
|
|
|
// Shared with other tasks, guarded by lock_.
|
|
struct Pending {
|
|
std::string path, data;
|
|
bool newline;
|
|
};
|
|
std::deque<Pending> pending_;
|
|
void append(const std::string& path, const std::string& data, bool capture, bool newline);
|
|
size_t pendingBytes_ = 0;
|
|
uint32_t dropped_ = 0;
|
|
bool listingRequested_ = false;
|
|
bool listingReady_ = false;
|
|
std::vector<std::vector<StoredFile>> listing_;
|
|
std::vector<std::string> toDelete_;
|
|
std::vector<std::function<void()>> jobs_;
|
|
volatile bool formatRequested_ = false;
|
|
};
|
|
|
|
} // namespace roro
|