eive/eive-obsw
eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 120 Wiki Activity

str transition fixes #498

Merged
muellerr merged 9 commits from bugfix_str_mode_transitions into develop 2023-03-20 17:56:11 +01:00
Conversation 0 Commits 9 Files Changed 4 +146 -128
2 changed files with 146 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 043a458f42 - Show all commits

227
linux/devices/startracker/StarTrackerHandler.cpp
View File

@ -268,18 +268,17 @@ void StarTrackerHandler::doStartUp() {
default: default:
return; return;
} }
startupState = StartupState::IDLE; startupState = StartupState::DONE;
internalState = InternalState::IDLE; internalState = InternalState::IDLE;
boot = true;
setMode(_MODE_TO_ON); setMode(_MODE_TO_ON);
} }
void StarTrackerHandler::doShutDown() { void StarTrackerHandler::doShutDown() {
// If the star tracker is shutdown also stop all running processes in the image loader task // If the star tracker is shutdown also stop all running processes in the image loader task
strHelper->stopProcess(); strHelper->stopProcess();
boot = false;
internalState = InternalState::IDLE; internalState = InternalState::IDLE;
startupState = StartupState::IDLE; startupState = StartupState::IDLE;
bootState = FwBootState::NONE;
setMode(_MODE_POWER_DOWN); setMode(_MODE_POWER_DOWN);
} }
@ -303,81 +302,103 @@ ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id
ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) { ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
switch (internalState) { switch (internalState) {
case InternalState::BOOT: case InternalState::BOOT_FIRMWARE: {
*id = startracker::BOOT; if (bootState == FwBootState::WAIT_FOR_EXECUTION or bootState == FwBootState::VERIFY_BOOT) {
bootCountdown.setTimeout(BOOT_TIMEOUT); return NOTHING_TO_SEND;
internalState = InternalState::BOOT_DELAY; }
return buildCommandFromCommand(*id, nullptr, 0); if (bootState == FwBootState::NONE) {
case InternalState::REQ_VERSION: *id = startracker::BOOT;
internalState = InternalState::VERIFY_BOOT; bootCountdown.setTimeout(BOOT_TIMEOUT);
// Again read program to check if firmware boot was successful bootState = FwBootState::BOOT_DELAY;
*id = startracker::REQ_VERSION; return buildCommandFromCommand(*id, nullptr, 0);
return buildCommandFromCommand(*id, nullptr, 0); }
case InternalState::LOGLEVEL: if (bootState == FwBootState::BOOT_DELAY) {
internalState = InternalState::WAIT_FOR_EXECUTION; if (bootCountdown.isBusy()) {
*id = startracker::LOGLEVEL; return NOTHING_TO_SEND;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), }
paramJsonFile.size()); bootState = FwBootState::REQ_VERSION;
case InternalState::LIMITS: }
internalState = InternalState::WAIT_FOR_EXECUTION; switch (bootState) {
*id = startracker::LIMITS; case (FwBootState::REQ_VERSION): {
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), bootState = FwBootState::VERIFY_BOOT;
paramJsonFile.size()); // Again read program to check if firmware boot was successful
case InternalState::TRACKING: *id = startracker::REQ_VERSION;
internalState = InternalState::WAIT_FOR_EXECUTION; return buildCommandFromCommand(*id, nullptr, 0);
*id = startracker::TRACKING; }
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), case (FwBootState::LOGLEVEL): {
paramJsonFile.size()); bootState = FwBootState::WAIT_FOR_EXECUTION;
case InternalState::MOUNTING: *id = startracker::LOGLEVEL;
internalState = InternalState::WAIT_FOR_EXECUTION; return buildCommandFromCommand(
*id = startracker::MOUNTING; *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), }
paramJsonFile.size()); case (FwBootState::LIMITS): {
case InternalState::IMAGE_PROCESSOR: bootState = FwBootState::WAIT_FOR_EXECUTION;
internalState = InternalState::WAIT_FOR_EXECUTION; *id = startracker::LIMITS;
*id = startracker::IMAGE_PROCESSOR; return buildCommandFromCommand(
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
paramJsonFile.size()); }
case InternalState::CAMERA: case (FwBootState::TRACKING): {
internalState = InternalState::WAIT_FOR_EXECUTION; bootState = FwBootState::WAIT_FOR_EXECUTION;
*id = startracker::CAMERA; *id = startracker::TRACKING;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), return buildCommandFromCommand(
paramJsonFile.size()); *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
case InternalState::CENTROIDING: }
internalState = InternalState::WAIT_FOR_EXECUTION; case FwBootState::MOUNTING:
*id = startracker::CENTROIDING; bootState = FwBootState::WAIT_FOR_EXECUTION;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), *id = startracker::MOUNTING;
paramJsonFile.size()); return buildCommandFromCommand(
case InternalState::LISA: *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
internalState = InternalState::WAIT_FOR_EXECUTION; case FwBootState::IMAGE_PROCESSOR:
*id = startracker::LISA; bootState = FwBootState::WAIT_FOR_EXECUTION;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), *id = startracker::IMAGE_PROCESSOR;
paramJsonFile.size()); return buildCommandFromCommand(
case InternalState::MATCHING: *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
internalState = InternalState::WAIT_FOR_EXECUTION; case FwBootState::CAMERA:
*id = startracker::MATCHING; bootState = FwBootState::WAIT_FOR_EXECUTION;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), *id = startracker::CAMERA;
paramJsonFile.size()); return buildCommandFromCommand(
case InternalState::VALIDATION: *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
internalState = InternalState::WAIT_FOR_EXECUTION; case FwBootState::CENTROIDING:
*id = startracker::VALIDATION; bootState = FwBootState::WAIT_FOR_EXECUTION;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), *id = startracker::CENTROIDING;
paramJsonFile.size()); return buildCommandFromCommand(
case InternalState::ALGO: *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
internalState = InternalState::WAIT_FOR_EXECUTION; case FwBootState::LISA:
*id = startracker::ALGO; bootState = FwBootState::WAIT_FOR_EXECUTION;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), *id = startracker::LISA;
paramJsonFile.size()); return buildCommandFromCommand(
case InternalState::LOG_SUBSCRIPTION: *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
internalState = InternalState::WAIT_FOR_EXECUTION; case FwBootState::MATCHING:
*id = startracker::LOGSUBSCRIPTION; bootState = FwBootState::WAIT_FOR_EXECUTION;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), *id = startracker::MATCHING;
paramJsonFile.size()); return buildCommandFromCommand(
case InternalState::DEBUG_CAMERA: *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
internalState = InternalState::WAIT_FOR_EXECUTION; case FwBootState::VALIDATION:
*id = startracker::DEBUG_CAMERA; bootState = FwBootState::WAIT_FOR_EXECUTION;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), *id = startracker::VALIDATION;
paramJsonFile.size()); return buildCommandFromCommand(
*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
case FwBootState::ALGO:
bootState = FwBootState::WAIT_FOR_EXECUTION;
*id = startracker::ALGO;
return buildCommandFromCommand(
*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
case FwBootState::LOG_SUBSCRIPTION:
bootState = FwBootState::WAIT_FOR_EXECUTION;
*id = startracker::LOGSUBSCRIPTION;
return buildCommandFromCommand(
*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
case FwBootState::DEBUG_CAMERA:
bootState = FwBootState::WAIT_FOR_EXECUTION;
*id = startracker::DEBUG_CAMERA;
return buildCommandFromCommand(
*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
default: {
sif::error << "STR: Unexpected boot state" << (int)bootState << std::endl;
return NOTHING_TO_SEND;
}
}
}
case InternalState::BOOT_BOOTLOADER: case InternalState::BOOT_BOOTLOADER:
internalState = InternalState::BOOTLOADER_CHECK; internalState = InternalState::BOOTLOADER_CHECK;
*id = startracker::SWITCH_TO_BOOTLOADER_PROGRAM; *id = startracker::SWITCH_TO_BOOTLOADER_PROGRAM;
@ -711,7 +732,7 @@ void StarTrackerHandler::doOnTransition(Submode_t subModeFrom) {
// We hide that the transition to submode firmware actually goes through the submode bootloader. // We hide that the transition to submode firmware actually goes through the submode bootloader.
// This is because the startracker always starts in bootloader mode but we want to allow direct // This is because the startracker always starts in bootloader mode but we want to allow direct
// transitions to firmware mode. // transitions to firmware mode.
if (boot) { if (startupState == StartupState::DONE) {
subModeFrom = SUBMODE_BOOTLOADER; subModeFrom = SUBMODE_BOOTLOADER;
} }
if (dhbSubmode == SUBMODE_NONE) { if (dhbSubmode == SUBMODE_NONE) {
@ -746,13 +767,10 @@ void StarTrackerHandler::doNormalTransition(Mode_t modeFrom, Submode_t subModeFr
void StarTrackerHandler::bootFirmware(Mode_t toMode) { void StarTrackerHandler::bootFirmware(Mode_t toMode) {
switch (internalState) { switch (internalState) {
case InternalState::IDLE: case InternalState::IDLE:
internalState = InternalState::BOOT; sif::info << "STR: Booting to firmware mode" << std::endl;
internalState = InternalState::BOOT_FIRMWARE;
break; break;
case InternalState::BOOT_DELAY: case InternalState::BOOT_FIRMWARE:
if (bootCountdown.hasTimedOut()) {
sif::info << "STR: Starting firmware boot" << std::endl;
internalState = InternalState::REQ_VERSION;
}
break; break;
case InternalState::FAILED_FIRMWARE_BOOT: case InternalState::FAILED_FIRMWARE_BOOT:
internalState = InternalState::IDLE; internalState = InternalState::IDLE;
@ -763,7 +781,9 @@ void StarTrackerHandler::bootFirmware(Mode_t toMode) {
} else { } else {
setMode(toMode, SUBMODE_FIRMWARE); setMode(toMode, SUBMODE_FIRMWARE);
} }
sif::info << "STR: Firmware boot success" << std::endl;
internalState = InternalState::IDLE; internalState = InternalState::IDLE;
startupState = StartupState::IDLE;
break; break;
default: default:
return; return;
@ -791,10 +811,11 @@ void StarTrackerHandler::setUpJsonCfgs(JsonConfigs& cfgs, const char* paramJsonF
void StarTrackerHandler::bootBootloader() { void StarTrackerHandler::bootBootloader() {
if (internalState == InternalState::IDLE) { if (internalState == InternalState::IDLE) {
internalState = InternalState::BOOT_BOOTLOADER; internalState = InternalState::BOOT_BOOTLOADER;
} else if (internalState == InternalState::BOOTING_BOOTLOADER_FAILED) { } else if (internalState == InternalState::FAILED_BOOTLOADER_BOOT) {
internalState = InternalState::IDLE; internalState = InternalState::IDLE;
} else if (internalState == InternalState::DONE) { } else if (internalState == InternalState::DONE) {
internalState = InternalState::IDLE; internalState = InternalState::IDLE;
startupState = StartupState::IDLE;
setMode(MODE_ON); setMode(MODE_ON);
} }
} }
@ -1949,7 +1970,7 @@ ReturnValue_t StarTrackerHandler::checkProgram() {
if (startupState == StartupState::WAIT_CHECK_PROGRAM) { if (startupState == StartupState::WAIT_CHECK_PROGRAM) {
startupState = StartupState::DONE; startupState = StartupState::DONE;
} }
if (internalState == InternalState::VERIFY_BOOT) { if (bootState == FwBootState::VERIFY_BOOT) {
sif::warning << "StarTrackerHandler::checkProgram: Failed to boot firmware" << std::endl; sif::warning << "StarTrackerHandler::checkProgram: Failed to boot firmware" << std::endl;
// Device handler will run into timeout and fall back to transition source mode // Device handler will run into timeout and fall back to transition source mode
triggerEvent(BOOTING_FIRMWARE_FAILED_EVENT); triggerEvent(BOOTING_FIRMWARE_FAILED_EVENT);
@ -1962,11 +1983,11 @@ ReturnValue_t StarTrackerHandler::checkProgram() {
if (startupState == StartupState::WAIT_CHECK_PROGRAM) { if (startupState == StartupState::WAIT_CHECK_PROGRAM) {
startupState = StartupState::BOOT_BOOTLOADER; startupState = StartupState::BOOT_BOOTLOADER;
} }
if (internalState == InternalState::VERIFY_BOOT) { if (bootState == FwBootState::VERIFY_BOOT) {
internalState = InternalState::LOGLEVEL; bootState = FwBootState::LOGLEVEL;
} else if (internalState == InternalState::BOOTLOADER_CHECK) { } else if (internalState == InternalState::BOOTLOADER_CHECK) {
triggerEvent(BOOTING_BOOTLOADER_FAILED_EVENT); triggerEvent(BOOTING_BOOTLOADER_FAILED_EVENT);
internalState = InternalState::BOOTING_BOOTLOADER_FAILED; internalState = InternalState::FAILED_BOOTLOADER_BOOT;
} }
break; break;
default: default:
@ -2040,55 +2061,55 @@ ReturnValue_t StarTrackerHandler::handleActionReplySet(LocalPoolDataSetBase& dat
void StarTrackerHandler::handleStartup(const uint8_t* parameterId) { void StarTrackerHandler::handleStartup(const uint8_t* parameterId) {
switch (*parameterId) { switch (*parameterId) {
case (startracker::ID::LOG_LEVEL): { case (startracker::ID::LOG_LEVEL): {
internalState = InternalState::LIMITS; bootState = FwBootState::LIMITS;
break; break;
} }
case (startracker::ID::LIMITS): { case (startracker::ID::LIMITS): {
internalState = InternalState::TRACKING; bootState = FwBootState::TRACKING;
break; break;
} }
case (startracker::ID::TRACKING): { case (startracker::ID::TRACKING): {
internalState = InternalState::MOUNTING; bootState = FwBootState::MOUNTING;
break; break;
} }
case (startracker::ID::MOUNTING): { case (startracker::ID::MOUNTING): {
internalState = InternalState::IMAGE_PROCESSOR; bootState = FwBootState::IMAGE_PROCESSOR;
break; break;
} }
case (startracker::ID::IMAGE_PROCESSOR): { case (startracker::ID::IMAGE_PROCESSOR): {
internalState = InternalState::CAMERA; bootState = FwBootState::CAMERA;
break; break;
} }
case (startracker::ID::CAMERA): { case (startracker::ID::CAMERA): {
internalState = InternalState::CENTROIDING; bootState = FwBootState::CENTROIDING;
break; break;
} }
case (startracker::ID::CENTROIDING): { case (startracker::ID::CENTROIDING): {
internalState = InternalState::LISA; bootState = FwBootState::LISA;
break; break;
} }
case (startracker::ID::LISA): { case (startracker::ID::LISA): {
internalState = InternalState::MATCHING; bootState = FwBootState::MATCHING;
break; break;
} }
case (startracker::ID::MATCHING): { case (startracker::ID::MATCHING): {
internalState = InternalState::VALIDATION; bootState = FwBootState::VALIDATION;
break; break;
} }
case (startracker::ID::VALIDATION): { case (startracker::ID::VALIDATION): {
internalState = InternalState::ALGO; bootState = FwBootState::ALGO;
break; break;
} }
case (startracker::ID::ALGO): { case (startracker::ID::ALGO): {
internalState = InternalState::LOG_SUBSCRIPTION; bootState = FwBootState::LOG_SUBSCRIPTION;
break; break;
} }
case (startracker::ID::LOG_SUBSCRIPTION): { case (startracker::ID::LOG_SUBSCRIPTION): {
internalState = InternalState::DEBUG_CAMERA; bootState = FwBootState::DEBUG_CAMERA;
break; break;
} }
case (startracker::ID::DEBUG_CAMERA): { case (startracker::ID::DEBUG_CAMERA): {
sif::info << "Star Tracker configuration done" << std::endl; bootState = FwBootState::NONE;
internalState = InternalState::DONE; internalState = InternalState::DONE;
break; break;
} }

47
linux/devices/startracker/StarTrackerHandler.h
View File

@ -211,7 +211,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
// Pointer to object responsible for uploading and downloading images to/from the star tracker // Pointer to object responsible for uploading and downloading images to/from the star tracker
StrHelper* strHelper = nullptr; StrHelper* strHelper = nullptr;
bool boot = false;
uint8_t commandBuffer[startracker::MAX_FRAME_SIZE]; uint8_t commandBuffer[startracker::MAX_FRAME_SIZE];
@ -247,14 +246,31 @@ class StarTrackerHandler : public DeviceHandlerBase {
NormalState normalState = NormalState::TEMPERATURE_REQUEST; NormalState normalState = NormalState::TEMPERATURE_REQUEST;
enum class StartupState {
IDLE,
CHECK_PROGRAM,
WAIT_CHECK_PROGRAM,
BOOT_BOOTLOADER,
WAIT_JCFG,
DONE
};
StartupState startupState = StartupState::IDLE;
enum class InternalState { enum class InternalState {
IDLE, IDLE,
BOOT, BOOT_FIRMWARE,
DONE,
FAILED_FIRMWARE_BOOT,
BOOT_BOOTLOADER,
BOOTLOADER_CHECK,
FAILED_BOOTLOADER_BOOT
};
enum class FwBootState {
NONE,
BOOT_DELAY,
REQ_VERSION, REQ_VERSION,
VERIFY_BOOT, VERIFY_BOOT,
STARTUP_CHECK,
BOOT_DELAY,
FIRMWARE_CHECK,
LOGLEVEL, LOGLEVEL,
LIMITS, LIMITS,
TRACKING, TRACKING,
@ -270,30 +286,11 @@ class StarTrackerHandler : public DeviceHandlerBase {
LOG_SUBSCRIPTION, LOG_SUBSCRIPTION,
DEBUG_CAMERA, DEBUG_CAMERA,
WAIT_FOR_EXECUTION, WAIT_FOR_EXECUTION,
DONE,
FAILED_FIRMWARE_BOOT,
BOOT_BOOTLOADER,
BOOTLOADER_CHECK,
BOOTING_BOOTLOADER_FAILED
};
enum class CfgSetupState {
}; };
FwBootState bootState = FwBootState::NONE;
InternalState internalState = InternalState::IDLE; InternalState internalState = InternalState::IDLE;
enum class StartupState {
IDLE,
CHECK_PROGRAM,
WAIT_CHECK_PROGRAM,
BOOT_BOOTLOADER,
WAIT_JCFG,
DONE
};
StartupState startupState = StartupState::IDLE;
bool strHelperExecuting = false; bool strHelperExecuting = false;
const power::Switch_t powerSwitch = power::NO_SWITCH; const power::Switch_t powerSwitch = power::NO_SWITCH;