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

star tracker firmware update
All checks were successful
EIVE/eive-obsw/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
Jakob Meier
2022-02-23 18:15:34 +01:00
parent 7d01aa463b
commit b822ee77bc
11 changed files with 294 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -233,20 +233,14 @@ void StarTrackerHandler::performOperationHook() {
void StarTrackerHandler::doStartUp() {
switch (startupState) {
case StartupState::IDLE:
startupState = StartupState::CHECK_BOOT_STATE;
startupState = StartupState::CHECK_PROGRAM;
return;
case StartupState::BOOT_DELAY:
if (bootCountdown.hasTimedOut()) {
startupState = StartupState::VERIFY_BOOT;
}
return;
case StartupState::FAILED_FIRMWARE_BOOT:
startupState = StartupState::IDLE;
// Though the star tracker failed to boot the firmware the device handler will go to
// mode on. In bootloader mode the star tracker is still on and can e.g. perform firmware
// updates.
break;
case StartupState::BOOT_BOOTLOADER:
// This step is required in case the star tracker is already in firmware mode to harmonize
// the device handler's submode to the star tracker's mode
return;
case StartupState::DONE:
submode = SUBMODE_BOOTLOADER;
startupState = StartupState::IDLE;
break;
default:
@ -258,26 +252,18 @@ void StarTrackerHandler::doStartUp() {
void StarTrackerHandler::doShutDown() {
// If the star tracker is shutdown also stop all running processes in the image loader task
strHelper->stopProcess();
internalState = InternalState::IDLE;
startupState = StartupState::IDLE;
setMode(_MODE_POWER_DOWN);
}
void StarTrackerHandler::doOffActivity() { startupState = StartupState::IDLE; }
void StarTrackerHandler::doOffActivity() { internalState = InternalState::IDLE; }
ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
if (!bootCountdown.hasTimedOut()) {
return NOTHING_TO_SEND;
}
switch (internalState) {
case InternalState::CHECK_PROGRAM:
*id = startracker::REQ_VERSION;
break;
case InternalState::TEMPERATURE_REQUEST:
switch (normalState) {
case NormalState::TEMPERATURE_REQUEST:
*id = startracker::REQ_TEMPERATURE;
break;
default:
sif::debug << "StarTrackerHandler::buildNormalDeviceCommand: Invalid internal step"
sif::debug << "StarTrackerHandler::buildNormalDeviceCommand: Invalid normal step"
<< std::endl;
break;
}
@ -285,94 +271,103 @@ ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id
}
ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
if (mode == _MODE_TO_NORMAL && currentProgram != startracker::Program::FIRMWARE) {
internalState = InternalState::CHECK_PROGRAM;
*id = startracker::BOOT;
bootCountdown.setTimeout(BOOT_TIMEOUT);
return buildCommandFromCommand(*id, nullptr, 0);
} else if (mode != _MODE_START_UP) {
return NOTHING_TO_SEND;
}
switch (startupState) {
case StartupState::CHECK_BOOT_STATE:
*id = startracker::REQ_VERSION;
startupState = StartupState::STARTUP_CHECK;
return buildCommandFromCommand(*id, nullptr, 0);
case StartupState::BOOT:
switch (internalState) {
case InternalState::BOOT:
*id = startracker::BOOT;
bootCountdown.setTimeout(BOOT_TIMEOUT);
startupState = StartupState::BOOT_DELAY;
internalState = InternalState::BOOT_DELAY;
return buildCommandFromCommand(*id, nullptr, 0);
case StartupState::VERIFY_BOOT:
case InternalState::REQ_VERSION:
internalState = InternalState::VERIFY_BOOT;
// Again read program to check if firmware boot was successful
*id = startracker::REQ_VERSION;
startupState = StartupState::FIRMWARE_CHECK;
return buildCommandFromCommand(*id, nullptr, 0);
case StartupState::LOGLEVEL:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::LOGLEVEL:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::LOGLEVEL;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::LIMITS:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::LIMITS:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::LIMITS;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::TRACKING:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::TRACKING:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::TRACKING;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::MOUNTING:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::MOUNTING:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::MOUNTING;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::IMAGE_PROCESSOR:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::IMAGE_PROCESSOR:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::IMAGE_PROCESSOR;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::CAMERA:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::CAMERA:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::CAMERA;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::CENTROIDING:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::CENTROIDING:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::CENTROIDING;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::LISA:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::LISA:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::LISA;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::MATCHING:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::MATCHING:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::MATCHING;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::VALIDATION:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::VALIDATION:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::VALIDATION;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::ALGO:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::ALGO:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::ALGO;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::LOG_SUBSCRIPTION:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::LOG_SUBSCRIPTION:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::LOGSUBSCRIPTION;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::DEBUG_CAMERA:
startupState = StartupState::WAIT_FOR_EXECUTION;
case InternalState::DEBUG_CAMERA:
internalState = InternalState::WAIT_FOR_EXECUTION;
*id = startracker::DEBUG_CAMERA;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case InternalState::BOOT_BOOTLOADER:
internalState = InternalState::BOOTLOADER_CHECK;
*id = startracker::SWITCH_TO_BOOTLOADER_PROGRAM;
return buildCommandFromCommand(*id, nullptr, 0);
case InternalState::BOOTLOADER_CHECK:
*id = startracker::REQ_VERSION;
return buildCommandFromCommand(*id, nullptr, 0);
default:
break;
}
switch (startupState) {
case StartupState::CHECK_PROGRAM:
startupState = StartupState::WAIT_CHECK_PROGRAM;
*id = startracker::REQ_VERSION;
return buildCommandFromCommand(*id, nullptr, 0);
break;
case StartupState::BOOT_BOOTLOADER:
startupState = StartupState::CHECK_PROGRAM;
*id = startracker::SWITCH_TO_BOOTLOADER_PROGRAM;
return buildCommandFromCommand(*id, nullptr, 0);
break;
default:
break;
}
@ -409,7 +404,6 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
return RETURN_OK;
}
case (startracker::SWITCH_TO_BOOTLOADER_PROGRAM): {
currentProgram = startracker::Program::BOOTLOADER;
prepareRebootCommand();
return RETURN_OK;
}
@ -727,7 +721,7 @@ ReturnValue_t StarTrackerHandler::isModeCombinationValid(Mode_t mode, Submode_t
return INVALID_SUBMODE;
}
case MODE_ON:
if (submode == SUBMODE_BOOTLOADER || submode == SUBMODE_FIRMWARE || submode == SUBMODE_NONE) {
if (submode == SUBMODE_BOOTLOADER || submode == SUBMODE_FIRMWARE) {
return RETURN_OK;
} else {
return INVALID_SUBMODE;
@ -737,6 +731,86 @@ ReturnValue_t StarTrackerHandler::isModeCombinationValid(Mode_t mode, Submode_t
}
}
void StarTrackerHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
switch (mode) {
case _MODE_TO_ON:
doOnTransition(subModeFrom);
break;
case _MODE_TO_RAW:
setMode(MODE_RAW);
break;
case _MODE_TO_NORMAL:
doNormalTransition(modeFrom, subModeFrom);
break;
case _MODE_POWER_DOWN:
internalState = InternalState::IDLE;
startupState = StartupState::IDLE;
break;
default:
break;
}
}
void StarTrackerHandler::doOnTransition(Submode_t subModeFrom) {
if (submode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_FIRMWARE) {
bootBootloader();
} else if (submode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_FIRMWARE) {
setMode(MODE_ON);
} else if (submode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_BOOTLOADER) {
bootFirmware(MODE_ON);
} else if (submode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_BOOTLOADER) {
setMode(MODE_ON);
} else if (submode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_NONE) {
setMode(MODE_ON);
} else if (submode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_NONE) {
setMode(MODE_ON);
}
}
void StarTrackerHandler::doNormalTransition(Mode_t modeFrom, Submode_t subModeFrom) {
if (subModeFrom == SUBMODE_FIRMWARE) {
setMode(MODE_NORMAL);
} else if (subModeFrom == SUBMODE_BOOTLOADER) {
bootFirmware(MODE_NORMAL);
} else if (modeFrom == MODE_NORMAL && subModeFrom == SUBMODE_NONE){
// Device handler already in mode normal
setMode(MODE_NORMAL);
}
}
void StarTrackerHandler::bootFirmware(Mode_t toMode) {
switch (internalState) {
case InternalState::IDLE:
internalState = InternalState::BOOT;
break;
case InternalState::BOOT_DELAY:
if (bootCountdown.hasTimedOut()) {
internalState = InternalState::REQ_VERSION;
}
break;
case InternalState::FAILED_FIRMWARE_BOOT:
internalState = InternalState::IDLE;
break;
case InternalState::DONE:
setMode(toMode);
internalState = InternalState::IDLE;
break;
default:
return;
}
}
void StarTrackerHandler::bootBootloader() {
if (internalState == InternalState::IDLE) {
internalState = InternalState::BOOT_BOOTLOADER;
} else if (internalState == InternalState::BOOTING_BOOTLOADER_FAILED) {
internalState = InternalState::IDLE;
} else if (internalState == InternalState::DONE) {
internalState = InternalState::IDLE;
setMode(MODE_ON);
}
}
ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t* start, size_t remainingSize,
DeviceCommandId_t* foundId, size_t* foundLen) {
ReturnValue_t result = RETURN_OK;
@ -955,7 +1029,14 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
void StarTrackerHandler::setNormalDatapoolEntriesInvalid() {}
uint32_t StarTrackerHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 20000; }
uint32_t StarTrackerHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
// if (modeTo == MODE_ON && (submode == SUBMODE_NONE || submode == SUBMODE_BOOTLOADER)) {
// return BOOTLOADER_TRANSITION_DELAY;
// } else if (modeTo == MODE_ON && submode == SUBMODE_FIRMWARE && modeFrom == MODE_) {
// return FIRMWARE_TRANSITION_DELAY;
// }
return DEFAULT_TRANSITION_DELAY;
}
ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
LocalDataPoolManager& poolManager) {
@ -2161,12 +2242,12 @@ ReturnValue_t StarTrackerHandler::handleSetParamReply() {
sif::warning << "StarTrackerHandler::handleSetParamReply: Failed to execute parameter set "
" command with parameter ID"
<< static_cast<unsigned int>(*(reply + PARAMETER_ID_OFFSET)) << std::endl;
if (startupState != StartupState::IDLE) {
startupState = StartupState::IDLE;
if (internalState != InternalState::IDLE) {
internalState = InternalState::IDLE;
}
return SET_PARAM_FAILED;
}
if (startupState != StartupState::IDLE) {
if (internalState != InternalState::IDLE) {
handleStartup(reply + PARAMETER_ID_OFFSET);
}
return RETURN_OK;
@ -2293,30 +2374,27 @@ ReturnValue_t StarTrackerHandler::checkProgram() {
PoolReadGuard pg(&versionSet);
switch (versionSet.program.value) {
case startracker::Program::BOOTLOADER:
// Star tracker currently in bootloader program. Need to send boot command to switch to
// firmware program
currentProgram = startracker::Program::BOOTLOADER;
if (startupState == StartupState::STARTUP_CHECK) {
startupState = StartupState::BOOT;
} else if (startupState == StartupState::FIRMWARE_CHECK) {
startupState = StartupState::FAILED_FIRMWARE_BOOT;
if (startupState == StartupState::WAIT_CHECK_PROGRAM) {
startupState = StartupState::DONE;
}
if (internalState == InternalState::CHECK_PROGRAM) {
// Firmware boot failed when trying to switch to normal mode
internalState = InternalState::IDLE;
sif::warning << "StarTrackerHandler::checkProgram: Failed to boot firmware when "
<< "trying to switch to normal mode" << std::endl;
setMode(_MODE_TO_ON);
if (internalState == InternalState::VERIFY_BOOT) {
sif::warning << "StarTrackerHandler::checkProgram: Failed to boot firmware" << std::endl;
// Device handler will run into timeout and fall back to transition source mode
triggerEvent(BOOTING_FIRMWARE_FAILED);
internalState = InternalState::FAILED_FIRMWARE_BOOT;
} else if (internalState == InternalState::BOOTLOADER_CHECK) {
internalState = InternalState::DONE;
}
break;
case startracker::Program::FIRMWARE:
// Firmware already booted
currentProgram = startracker::Program::FIRMWARE;
if (startupState == StartupState::FIRMWARE_CHECK) {
startupState = StartupState::LOGLEVEL;
if (startupState == StartupState::WAIT_CHECK_PROGRAM) {
startupState = StartupState::BOOT_BOOTLOADER;
}
if (internalState == InternalState::CHECK_PROGRAM) {
internalState = InternalState::TEMPERATURE_REQUEST;
if (internalState == InternalState::VERIFY_BOOT) {
internalState = InternalState::LOGLEVEL;
} else if (internalState == InternalState::BOOTLOADER_CHECK) {
triggerEvent(BOOTING_BOOTLOADER_FAILED);
internalState = InternalState::BOOTING_BOOTLOADER_FAILED;
}
break;
default:
@ -2390,55 +2468,55 @@ ReturnValue_t StarTrackerHandler::handleActionReplySet(LocalPoolDataSetBase& dat
void StarTrackerHandler::handleStartup(const uint8_t* parameterId) {
switch (*parameterId) {
case (startracker::ID::LOG_LEVEL): {
startupState = StartupState::LIMITS;
internalState = InternalState::LIMITS;
break;
}
case (startracker::ID::LIMITS): {
startupState = StartupState::TRACKING;
internalState = InternalState::TRACKING;
break;
}
case (startracker::ID::TRACKING): {
startupState = StartupState::MOUNTING;
internalState = InternalState::MOUNTING;
break;
}
case (startracker::ID::MOUNTING): {
startupState = StartupState::IMAGE_PROCESSOR;
internalState = InternalState::IMAGE_PROCESSOR;
break;
}
case (startracker::ID::IMAGE_PROCESSOR): {
startupState = StartupState::CAMERA;
internalState = InternalState::CAMERA;
break;
}
case (startracker::ID::CAMERA): {
startupState = StartupState::CENTROIDING;
internalState = InternalState::CENTROIDING;
break;
}
case (startracker::ID::CENTROIDING): {
startupState = StartupState::LISA;
internalState = InternalState::LISA;
break;
}
case (startracker::ID::LISA): {
startupState = StartupState::MATCHING;
internalState = InternalState::MATCHING;
break;
}
case (startracker::ID::MATCHING): {
startupState = StartupState::VALIDATION;
internalState = InternalState::VALIDATION;
break;
}
case (startracker::ID::VALIDATION): {
startupState = StartupState::ALGO;
internalState = InternalState::ALGO;
break;
}
case (startracker::ID::ALGO): {
startupState = StartupState::LOG_SUBSCRIPTION;
internalState = InternalState::LOG_SUBSCRIPTION;
break;
}
case (startracker::ID::LOG_SUBSCRIPTION): {
startupState = StartupState::DEBUG_CAMERA;
internalState = InternalState::DEBUG_CAMERA;
break;
}
case (startracker::ID::DEBUG_CAMERA): {
startupState = StartupState::DONE;
internalState = InternalState::DONE;
break;
}
default: {
@ -2451,11 +2529,6 @@ void StarTrackerHandler::handleStartup(const uint8_t* parameterId) {
ReturnValue_t StarTrackerHandler::checkCommand(ActionId_t actionId) {
switch (actionId) {
case startracker::BOOT:
if (currentProgram != startracker::Program::BOOTLOADER) {
return STARTRACKER_ALREADY_BOOTED;
}
break;
case startracker::REQ_INTERFACE:
case startracker::REQ_TIME:
case startracker::SWITCH_TO_BOOTLOADER_PROGRAM:
@ -2472,12 +2545,12 @@ ReturnValue_t StarTrackerHandler::checkCommand(ActionId_t actionId) {
case startracker::DOWNLOAD_MATCHED_STAR:
case startracker::DOWNLOAD_DBIMAGE:
case startracker::DOWNLOAD_BLOBPIXEL:
if (currentProgram != startracker::Program::FIRMWARE) {
if (!(mode == MODE_ON && submode == startracker::Program::FIRMWARE)) {
return STARTRACKER_RUNNING_BOOTLOADER;
}
break;
case startracker::FIRMWARE_UPDATE:
if (currentProgram != startracker::Program::BOOTLOADER) {
if (!(mode == MODE_ON && submode == startracker::Program::BOOTLOADER)) {
return STARTRACKER_RUNNING_FIRMWARE;
}
break;