exercises: add Exercise 08 SystemStartup scaffold with early SPI deselect and SD/OLED startup orchestration
This commit is contained in:
parent
2aec641fc2
commit
322a77bfe4
9 changed files with 720 additions and 0 deletions
360
exercises/08_SystemStartup/lib/startup_sd/StartupSdManager.cpp
Normal file
360
exercises/08_SystemStartup/lib/startup_sd/StartupSdManager.cpp
Normal file
|
|
@ -0,0 +1,360 @@
|
|||
#include "StartupSdManager.h"
|
||||
|
||||
#include <stdarg.h>
|
||||
#include "driver/gpio.h"
|
||||
|
||||
StartupSdManager::StartupSdManager(Print& serial) : serial_(serial) {}
|
||||
|
||||
bool StartupSdManager::begin(const SdWatcherConfig& cfg, SdStatusCallback callback) {
|
||||
cfg_ = cfg;
|
||||
callback_ = callback;
|
||||
|
||||
forceSpiDeselected();
|
||||
dumpSdPins("very-early");
|
||||
|
||||
if (!initPmuForSdPower()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
cycleSdRail();
|
||||
delay(cfg_.startupWarmupMs);
|
||||
|
||||
bool warmMounted = false;
|
||||
for (uint8_t i = 0; i < 3; ++i) {
|
||||
if (mountPreferred(false)) {
|
||||
warmMounted = true;
|
||||
break;
|
||||
}
|
||||
delay(200);
|
||||
}
|
||||
|
||||
// Some cards need a longer power/settle window after cold boot.
|
||||
// Before declaring ABSENT, retry with extended settle and a full scan.
|
||||
if (!warmMounted) {
|
||||
logf("Watcher: startup preferred mount failed, retrying with extended settle");
|
||||
cycleSdRail(400, 1200);
|
||||
delay(cfg_.startupWarmupMs + 1500);
|
||||
warmMounted = mountCardFullScan();
|
||||
}
|
||||
|
||||
if (warmMounted) {
|
||||
setStateMounted();
|
||||
} else {
|
||||
setStateAbsent();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void StartupSdManager::update() {
|
||||
const uint32_t now = millis();
|
||||
const uint32_t pollInterval =
|
||||
(watchState_ == SdWatchState::MOUNTED) ? cfg_.pollIntervalMountedMs : cfg_.pollIntervalAbsentMs;
|
||||
|
||||
if ((uint32_t)(now - lastPollMs_) < pollInterval) {
|
||||
return;
|
||||
}
|
||||
lastPollMs_ = now;
|
||||
|
||||
if (watchState_ == SdWatchState::MOUNTED) {
|
||||
if (verifyMountedCard()) {
|
||||
presentVotes_ = 0;
|
||||
absentVotes_ = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
if (mountPreferred(false) && verifyMountedCard()) {
|
||||
presentVotes_ = 0;
|
||||
absentVotes_ = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
absentVotes_++;
|
||||
presentVotes_ = 0;
|
||||
if (absentVotes_ >= cfg_.votesToAbsent) {
|
||||
setStateAbsent();
|
||||
absentVotes_ = 0;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
bool mounted = mountPreferred(false);
|
||||
if (!mounted && (uint32_t)(now - lastFullScanMs_) >= cfg_.fullScanIntervalMs) {
|
||||
lastFullScanMs_ = now;
|
||||
if (cfg_.recoveryRailCycleOnFullScan) {
|
||||
logf("Watcher: recovery rail cycle before full scan");
|
||||
cycleSdRail(cfg_.recoveryRailOffMs, cfg_.recoveryRailOnSettleMs);
|
||||
delay(150);
|
||||
}
|
||||
logf("Watcher: preferred probe failed, running full scan");
|
||||
mounted = mountCardFullScan();
|
||||
}
|
||||
|
||||
if (mounted) {
|
||||
presentVotes_++;
|
||||
absentVotes_ = 0;
|
||||
if (presentVotes_ >= cfg_.votesToPresent) {
|
||||
setStateMounted();
|
||||
presentVotes_ = 0;
|
||||
}
|
||||
} else {
|
||||
absentVotes_++;
|
||||
presentVotes_ = 0;
|
||||
if (absentVotes_ >= cfg_.votesToAbsent) {
|
||||
setStateAbsent();
|
||||
absentVotes_ = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool StartupSdManager::consumeMountedEvent() {
|
||||
bool out = mountedEventPending_;
|
||||
mountedEventPending_ = false;
|
||||
return out;
|
||||
}
|
||||
|
||||
bool StartupSdManager::consumeRemovedEvent() {
|
||||
bool out = removedEventPending_;
|
||||
removedEventPending_ = false;
|
||||
return out;
|
||||
}
|
||||
|
||||
void StartupSdManager::logf(const char* fmt, ...) {
|
||||
char msg[196];
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
vsnprintf(msg, sizeof(msg), fmt, args);
|
||||
va_end(args);
|
||||
serial_.printf("[%10lu][%06lu] %s\r\n",
|
||||
(unsigned long)millis(),
|
||||
(unsigned long)logSeq_++,
|
||||
msg);
|
||||
}
|
||||
|
||||
void StartupSdManager::notify(SdEvent event, const char* message) {
|
||||
if (callback_ != nullptr) {
|
||||
callback_(event, message);
|
||||
}
|
||||
}
|
||||
|
||||
void StartupSdManager::forceSpiDeselected() {
|
||||
pinMode(tbeam_supreme::sdCs(), OUTPUT);
|
||||
digitalWrite(tbeam_supreme::sdCs(), HIGH);
|
||||
pinMode(tbeam_supreme::imuCs(), OUTPUT);
|
||||
digitalWrite(tbeam_supreme::imuCs(), HIGH);
|
||||
}
|
||||
|
||||
void StartupSdManager::dumpSdPins(const char* tag) {
|
||||
if (!cfg_.enablePinDumps) {
|
||||
(void)tag;
|
||||
return;
|
||||
}
|
||||
|
||||
const gpio_num_t cs = (gpio_num_t)tbeam_supreme::sdCs();
|
||||
const gpio_num_t sck = (gpio_num_t)tbeam_supreme::sdSck();
|
||||
const gpio_num_t miso = (gpio_num_t)tbeam_supreme::sdMiso();
|
||||
const gpio_num_t mosi = (gpio_num_t)tbeam_supreme::sdMosi();
|
||||
logf("PINS(%s): CS=%d SCK=%d MISO=%d MOSI=%d",
|
||||
tag, gpio_get_level(cs), gpio_get_level(sck), gpio_get_level(miso), gpio_get_level(mosi));
|
||||
}
|
||||
|
||||
bool StartupSdManager::initPmuForSdPower() {
|
||||
if (!tbeam_supreme::initPmuForPeripherals(pmu_, &serial_)) {
|
||||
logf("ERROR: PMU init failed");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void StartupSdManager::cycleSdRail(uint32_t offMs, uint32_t onSettleMs) {
|
||||
if (!cfg_.enableSdRailCycle) {
|
||||
return;
|
||||
}
|
||||
if (!pmu_) {
|
||||
logf("SD rail cycle skipped: pmu=null");
|
||||
return;
|
||||
}
|
||||
|
||||
forceSpiDeselected();
|
||||
pmu_->disablePowerOutput(XPOWERS_BLDO1);
|
||||
delay(offMs);
|
||||
pmu_->setPowerChannelVoltage(XPOWERS_BLDO1, 3300);
|
||||
pmu_->enablePowerOutput(XPOWERS_BLDO1);
|
||||
delay(onSettleMs);
|
||||
}
|
||||
|
||||
bool StartupSdManager::tryMountWithBus(SPIClass& bus, const char* busName, uint32_t hz, bool verbose) {
|
||||
SD.end();
|
||||
bus.end();
|
||||
delay(10);
|
||||
forceSpiDeselected();
|
||||
|
||||
bus.begin(tbeam_supreme::sdSck(), tbeam_supreme::sdMiso(), tbeam_supreme::sdMosi(), tbeam_supreme::sdCs());
|
||||
digitalWrite(tbeam_supreme::sdCs(), HIGH);
|
||||
delay(2);
|
||||
for (int i = 0; i < 10; i++) {
|
||||
bus.transfer(0xFF);
|
||||
}
|
||||
delay(2);
|
||||
|
||||
if (verbose) {
|
||||
logf("SD: trying bus=%s freq=%lu Hz", busName, (unsigned long)hz);
|
||||
}
|
||||
|
||||
if (!SD.begin(tbeam_supreme::sdCs(), bus, hz)) {
|
||||
if (verbose) {
|
||||
logf("SD: mount failed (possible non-FAT format, power, or bus issue)");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
if (SD.cardType() == CARD_NONE) {
|
||||
SD.end();
|
||||
return false;
|
||||
}
|
||||
|
||||
sdSpi_ = &bus;
|
||||
sdBusName_ = busName;
|
||||
sdFreq_ = hz;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool StartupSdManager::mountPreferred(bool verbose) {
|
||||
return tryMountWithBus(sdSpiH_, "HSPI", 400000, verbose);
|
||||
}
|
||||
|
||||
bool StartupSdManager::mountCardFullScan() {
|
||||
const uint32_t freqs[] = {400000, 1000000, 4000000, 10000000};
|
||||
|
||||
for (uint8_t i = 0; i < (sizeof(freqs) / sizeof(freqs[0])); ++i) {
|
||||
if (tryMountWithBus(sdSpiH_, "HSPI", freqs[i], true)) {
|
||||
logf("SD: card detected and mounted");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
for (uint8_t i = 0; i < (sizeof(freqs) / sizeof(freqs[0])); ++i) {
|
||||
if (tryMountWithBus(sdSpiF_, "FSPI", freqs[i], true)) {
|
||||
logf("SD: card detected and mounted");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
logf("SD: begin() failed on all bus/frequency attempts");
|
||||
return false;
|
||||
}
|
||||
|
||||
bool StartupSdManager::verifyMountedCard() {
|
||||
File root = SD.open("/", FILE_READ);
|
||||
if (!root) {
|
||||
return false;
|
||||
}
|
||||
root.close();
|
||||
return true;
|
||||
}
|
||||
|
||||
const char* StartupSdManager::cardTypeToString(uint8_t type) {
|
||||
switch (type) {
|
||||
case CARD_MMC:
|
||||
return "MMC";
|
||||
case CARD_SD:
|
||||
return "SDSC";
|
||||
case CARD_SDHC:
|
||||
return "SDHC/SDXC";
|
||||
default:
|
||||
return "UNKNOWN";
|
||||
}
|
||||
}
|
||||
|
||||
void StartupSdManager::printCardInfo() {
|
||||
uint8_t cardType = SD.cardType();
|
||||
uint64_t cardSizeMB = SD.cardSize() / (1024ULL * 1024ULL);
|
||||
uint64_t totalMB = SD.totalBytes() / (1024ULL * 1024ULL);
|
||||
uint64_t usedMB = SD.usedBytes() / (1024ULL * 1024ULL);
|
||||
|
||||
logf("SD type: %s", cardTypeToString(cardType));
|
||||
logf("SD size: %llu MB", cardSizeMB);
|
||||
logf("FS total: %llu MB", totalMB);
|
||||
logf("FS used : %llu MB", usedMB);
|
||||
logf("SPI bus: %s @ %lu Hz", sdBusName_, (unsigned long)sdFreq_);
|
||||
}
|
||||
|
||||
bool StartupSdManager::ensureDirRecursive(const char* path) {
|
||||
String full(path);
|
||||
if (!full.startsWith("/")) {
|
||||
full = "/" + full;
|
||||
}
|
||||
|
||||
int start = 1;
|
||||
while (start > 0 && start < (int)full.length()) {
|
||||
int slash = full.indexOf('/', start);
|
||||
String partial = (slash < 0) ? full : full.substring(0, slash);
|
||||
if (!SD.exists(partial.c_str()) && !SD.mkdir(partial.c_str())) {
|
||||
logf("ERROR: mkdir failed for %s", partial.c_str());
|
||||
return false;
|
||||
}
|
||||
if (slash < 0) {
|
||||
break;
|
||||
}
|
||||
start = slash + 1;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool StartupSdManager::rewriteFile(const char* path, const char* payload) {
|
||||
if (SD.exists(path) && !SD.remove(path)) {
|
||||
logf("ERROR: failed to erase %s", path);
|
||||
return false;
|
||||
}
|
||||
|
||||
File f = SD.open(path, FILE_WRITE);
|
||||
if (!f) {
|
||||
logf("ERROR: failed to create %s", path);
|
||||
return false;
|
||||
}
|
||||
|
||||
size_t wrote = f.println(payload);
|
||||
f.close();
|
||||
if (wrote == 0) {
|
||||
logf("ERROR: write failed for %s", path);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void StartupSdManager::permissionsDemo(const char* path) {
|
||||
logf("Permissions demo: FAT has no Unix chmod/chown, use open mode only.");
|
||||
File r = SD.open(path, FILE_READ);
|
||||
if (!r) {
|
||||
logf("Could not open %s as FILE_READ", path);
|
||||
return;
|
||||
}
|
||||
size_t writeInReadMode = r.print("attempt write while opened read-only");
|
||||
if (writeInReadMode == 0) {
|
||||
logf("As expected, FILE_READ write was blocked.");
|
||||
} else {
|
||||
logf("NOTE: FILE_READ write returned %u (unexpected)", (unsigned)writeInReadMode);
|
||||
}
|
||||
r.close();
|
||||
}
|
||||
|
||||
void StartupSdManager::setStateMounted() {
|
||||
if (watchState_ != SdWatchState::MOUNTED) {
|
||||
logf("EVENT: card inserted/mounted");
|
||||
mountedEventPending_ = true;
|
||||
notify(SdEvent::CARD_MOUNTED, "SD card mounted");
|
||||
}
|
||||
watchState_ = SdWatchState::MOUNTED;
|
||||
}
|
||||
|
||||
void StartupSdManager::setStateAbsent() {
|
||||
if (watchState_ == SdWatchState::MOUNTED) {
|
||||
logf("EVENT: card removed/unavailable");
|
||||
removedEventPending_ = true;
|
||||
notify(SdEvent::CARD_REMOVED, "SD card removed");
|
||||
} else if (watchState_ != SdWatchState::ABSENT) {
|
||||
logf("EVENT: no card detected");
|
||||
notify(SdEvent::NO_CARD, "Missing SD card or invalid FAT16/FAT32 format");
|
||||
}
|
||||
SD.end();
|
||||
watchState_ = SdWatchState::ABSENT;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue