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

Merge remote-tracking branch 'origin/develop' into tweak_papb_busy_polling
Some checks failed
EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit
Details

Browse Source
This commit is contained in:
Robin Müller 2023-03-23 18:42:24 +01:00
commit abf689872d
No known key found for this signature in database
GPG Key ID: 11D4952C8CCEF814
39 changed files with 867 additions and 669 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
CHANGELOG.md
View File

@ -26,7 +26,18 @@ will consitute of a breaking change warranting a new major release:
## Added ## Added
- The persistent TM stores now have low priorities and behave like background threads now. This - The persistent TM stores now have low priorities and behave like background threads now. This
should prevent them from blocking or slowing down the system even during dumps. should prevent them from blocking or slowing down the system even during dumps
(at least in theory).
- STR: Fix weird issues on datalink layer data reception which sometimes occur.
## Changed
- STR: Move datalink layer to `StrComHandler` completely. DLL is now completely hidden from
device handler.
- STR: Is now scheduled twice in ACS PST.
- `StrHelper` renamed to `StrComHandler`, is now a `DeviceHandlerIF` directly and does not wrap
a separate UART COM interface anymore.
- TCS: Local pool variables are members now.
# [v1.39.1] 2023-03-22 # [v1.39.1] 2023-03-22

16
bsp_hosted/fsfwconfig/events/translateEvents.cpp
View File

@ -1,7 +1,7 @@
/** /**
* @brief Auto-generated event translation file. Contains 279 translations. * @brief Auto-generated event translation file. Contains 279 translations.
* @details * @details
* Generated on: 2023-03-21 23:59:36 * Generated on: 2023-03-22 01:14:08
*/ */
#include "translateEvents.h" #include "translateEvents.h"
@ -172,7 +172,7 @@ const char *FIRMWARE_UPDATE_SUCCESSFUL_STRING = "FIRMWARE_UPDATE_SUCCESSFUL";
const char *FIRMWARE_UPDATE_FAILED_STRING = "FIRMWARE_UPDATE_FAILED"; const char *FIRMWARE_UPDATE_FAILED_STRING = "FIRMWARE_UPDATE_FAILED";
const char *STR_HELPER_READING_REPLY_FAILED_STRING = "STR_HELPER_READING_REPLY_FAILED"; const char *STR_HELPER_READING_REPLY_FAILED_STRING = "STR_HELPER_READING_REPLY_FAILED";
const char *STR_HELPER_COM_ERROR_STRING = "STR_HELPER_COM_ERROR"; const char *STR_HELPER_COM_ERROR_STRING = "STR_HELPER_COM_ERROR";
const char *STR_HELPER_NO_REPLY_STRING = "STR_HELPER_NO_REPLY"; const char *STR_HELPER_REPLY_TIMEOUT_STRING = "STR_HELPER_REPLY_TIMEOUT";
const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR"; const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR";
const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH"; const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH";
const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS"; const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS";
@ -617,16 +617,16 @@ const char *translateEvents(Event event) {
case (12510): case (12510):
return STR_HELPER_COM_ERROR_STRING; return STR_HELPER_COM_ERROR_STRING;
case (12511): case (12511):
return STR_HELPER_NO_REPLY_STRING; return STR_HELPER_REPLY_TIMEOUT_STRING;
case (12512):
return STR_HELPER_DEC_ERROR_STRING;
case (12513): case (12513):
return POSITION_MISMATCH_STRING; return STR_HELPER_DEC_ERROR_STRING;
case (12514): case (12514):
return STR_HELPER_FILE_NOT_EXISTS_STRING; return POSITION_MISMATCH_STRING;
case (12515): case (12515):
return STR_HELPER_SENDING_PACKET_FAILED_STRING; return STR_HELPER_FILE_NOT_EXISTS_STRING;
case (12516): case (12516):
return STR_HELPER_SENDING_PACKET_FAILED_STRING;
case (12517):
return STR_HELPER_REQUESTING_MSG_FAILED_STRING; return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
case (12600): case (12600):
return MPSOC_FLASH_WRITE_FAILED_STRING; return MPSOC_FLASH_WRITE_FAILED_STRING;

6
bsp_hosted/fsfwconfig/objects/translateObjects.cpp
View File

@ -2,7 +2,7 @@
* @brief Auto-generated object translation file. * @brief Auto-generated object translation file.
* @details * @details
* Contains 169 translations. * Contains 169 translations.
* Generated on: 2023-03-21 23:59:36 * Generated on: 2023-03-22 01:14:08
*/ */
#include "translateObjects.h" #include "translateObjects.h"
@ -50,7 +50,7 @@ const char *PLPCDU_HANDLER_STRING = "PLPCDU_HANDLER";
const char *RAD_SENSOR_STRING = "RAD_SENSOR"; const char *RAD_SENSOR_STRING = "RAD_SENSOR";
const char *PLOC_UPDATER_STRING = "PLOC_UPDATER"; const char *PLOC_UPDATER_STRING = "PLOC_UPDATER";
const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER"; const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER";
const char *STR_HELPER_STRING = "STR_HELPER"; const char *STR_COM_IF_STRING = "STR_COM_IF";
const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER"; const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER";
const char *AXI_PTME_CONFIG_STRING = "AXI_PTME_CONFIG"; const char *AXI_PTME_CONFIG_STRING = "AXI_PTME_CONFIG";
const char *PTME_CONFIG_STRING = "PTME_CONFIG"; const char *PTME_CONFIG_STRING = "PTME_CONFIG";
@ -267,7 +267,7 @@ const char *translateObject(object_id_t object) {
case 0x44330001: case 0x44330001:
return PLOC_MEMORY_DUMPER_STRING; return PLOC_MEMORY_DUMPER_STRING;
case 0x44330002: case 0x44330002:
return STR_HELPER_STRING; return STR_COM_IF_STRING;
case 0x44330003: case 0x44330003:
return PLOC_MPSOC_HELPER_STRING; return PLOC_MPSOC_HELPER_STRING;
case 0x44330004: case 0x44330004:

22
bsp_q7s/core/ObjectFactory.cpp
View File

@ -4,6 +4,7 @@
#include <linux/devices/AcsBoardPolling.h> #include <linux/devices/AcsBoardPolling.h>
#include <linux/devices/ImtqPollingTask.h> #include <linux/devices/ImtqPollingTask.h>
#include <linux/devices/RwPollingTask.h> #include <linux/devices/RwPollingTask.h>
#include <linux/devices/startracker/StrComHandler.h>
#include <mission/devices/GyrL3gCustomHandler.h> #include <mission/devices/GyrL3gCustomHandler.h>
#include <mission/devices/MgmLis3CustomHandler.h> #include <mission/devices/MgmLis3CustomHandler.h>
#include <mission/devices/MgmRm3100CustomHandler.h> #include <mission/devices/MgmRm3100CustomHandler.h>
@ -45,7 +46,6 @@
#include "linux/devices/ploc/PlocMemoryDumper.h" #include "linux/devices/ploc/PlocMemoryDumper.h"
#include "linux/devices/ploc/PlocSupervisorHandler.h" #include "linux/devices/ploc/PlocSupervisorHandler.h"
#include "linux/devices/startracker/StarTrackerHandler.h" #include "linux/devices/startracker/StarTrackerHandler.h"
#include "linux/devices/startracker/StrHelper.h"
#include "linux/ipcore/AxiPtmeConfig.h" #include "linux/ipcore/AxiPtmeConfig.h"
#include "linux/ipcore/PapbVcInterface.h" #include "linux/ipcore/PapbVcInterface.h"
#include "linux/ipcore/PdecHandler.h" #include "linux/ipcore/PdecHandler.h"
@ -592,7 +592,7 @@ void ObjectFactory::createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitc
void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) { void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
auto* syrlinksUartCookie = auto* syrlinksUartCookie =
new SerialCookie(objects::SYRLINKS_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD, new SerialCookie(objects::SYRLINKS_HANDLER, q7s::UART_SYRLINKS_DEV, serial::SYRLINKS_BAUD,
syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL); syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
syrlinksUartCookie->setParityEven(); syrlinksUartCookie->setParityEven();
@ -623,8 +623,8 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC); mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC);
gpioChecker(gpioComIF->addGpios(mpsocGpioCookie), "PLOC MPSoC"); gpioChecker(gpioComIF->addGpios(mpsocGpioCookie), "PLOC MPSoC");
auto mpsocCookie = auto mpsocCookie =
new SerialCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV, uart::PLOC_MPSOC_BAUD, new SerialCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV,
mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL); serial::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
mpsocCookie->setNoFixedSizeReply(); mpsocCookie->setNoFixedSizeReply();
auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER); auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
auto* mpsocHandler = new PlocMPSoCHandler( auto* mpsocHandler = new PlocMPSoCHandler(
@ -639,9 +639,9 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
auto supvGpioCookie = new GpioCookie; auto supvGpioCookie = new GpioCookie;
supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv); supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv);
gpioComIF->addGpios(supvGpioCookie); gpioComIF->addGpios(supvGpioCookie);
auto supervisorCookie = auto supervisorCookie = new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER,
new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV, q7s::UART_PLOC_SUPERVSIOR_DEV, serial::PLOC_SUPV_BAUD,
uart::PLOC_SUPV_BAUD, supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL); supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
supervisorCookie->setNoFixedSizeReply(); supervisorCookie->setNoFixedSizeReply();
auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER); auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
auto* supvHandler = new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie, auto* supvHandler = new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
@ -934,10 +934,10 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
auto* strAssy = new StrAssembly(objects::STR_ASSY); auto* strAssy = new StrAssembly(objects::STR_ASSY);
strAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM); strAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
auto* starTrackerCookie = auto* starTrackerCookie =
new SerialCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, uart::STAR_TRACKER_BAUD, new SerialCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, serial::STAR_TRACKER_BAUD,
startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL); startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
starTrackerCookie->setNoFixedSizeReply(); starTrackerCookie->setNoFixedSizeReply();
StrHelper* strHelper = new StrHelper(objects::STR_HELPER); StrComHandler* strComIF = new StrComHandler(objects::STR_COM_IF);
const char* paramJsonFile = nullptr; const char* paramJsonFile = nullptr;
#ifdef EGSE #ifdef EGSE
@ -954,8 +954,8 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
} }
auto strFdir = new StrFdir(objects::STAR_TRACKER); auto strFdir = new StrFdir(objects::STAR_TRACKER);
auto starTracker = auto starTracker =
new StarTrackerHandler(objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie, new StarTrackerHandler(objects::STAR_TRACKER, objects::STR_COM_IF, starTrackerCookie,
paramJsonFile, strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V); paramJsonFile, strComIF, pcdu::PDU1_CH2_STAR_TRACKER_5V);
starTracker->setPowerSwitcher(pwrSwitcher); starTracker->setPowerSwitcher(pwrSwitcher);
starTracker->connectModeTreeParent(*strAssy); starTracker->connectModeTreeParent(*strAssy);
starTracker->setCustomFdir(strFdir); starTracker->setCustomFdir(strFdir);

7
bsp_q7s/core/scheduling.cpp
View File

@ -307,11 +307,12 @@ void scheduling::initTasks() {
#endif #endif
#if OBSW_ADD_STAR_TRACKER == 1 #if OBSW_ADD_STAR_TRACKER == 1
// Relatively high priority to make sure STR COM works well.
PeriodicTaskIF* strHelperTask = factory->createPeriodicTask( PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
"STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); "STR_HELPER", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
result = strHelperTask->addComponent(objects::STR_HELPER); result = strHelperTask->addComponent(objects::STR_COM_IF);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
scheduling::printAddObjectError("STR_HELPER", objects::STR_HELPER); scheduling::printAddObjectError("STR_HELPER", objects::STR_COM_IF);
} }
#endif /* OBSW_ADD_STAR_TRACKER == 1 */ #endif /* OBSW_ADD_STAR_TRACKER == 1 */

4
common/config/devConf.h
View File

@ -63,7 +63,7 @@ static constexpr dur_millis_t ACS_BOARD_CS_TIMEOUT = 50 * CS_FACTOR;
} // namespace spi } // namespace spi
namespace uart { namespace serial {
static constexpr size_t HYPERION_GPS_REPLY_MAX_BUFFER = 1024; static constexpr size_t HYPERION_GPS_REPLY_MAX_BUFFER = 1024;
static constexpr UartBaudRate SYRLINKS_BAUD = UartBaudRate::RATE_38400; static constexpr UartBaudRate SYRLINKS_BAUD = UartBaudRate::RATE_38400;
@ -73,6 +73,6 @@ static constexpr UartBaudRate PLOC_MPSOC_BAUD = UartBaudRate::RATE_115200;
static constexpr UartBaudRate PLOC_SUPV_BAUD = UartBaudRate::RATE_921600; static constexpr UartBaudRate PLOC_SUPV_BAUD = UartBaudRate::RATE_921600;
static constexpr UartBaudRate STAR_TRACKER_BAUD = UartBaudRate::RATE_921600; static constexpr UartBaudRate STAR_TRACKER_BAUD = UartBaudRate::RATE_921600;
} // namespace uart } // namespace serial
#endif /* COMMON_CONFIG_DEVCONF_H_ */ #endif /* COMMON_CONFIG_DEVCONF_H_ */

2
common/config/eive/objects.h
View File

@ -62,7 +62,7 @@ enum commonObjects : uint32_t {
RAD_SENSOR = 0x443200A5, RAD_SENSOR = 0x443200A5,
PLOC_UPDATER = 0x44330000, PLOC_UPDATER = 0x44330000,
PLOC_MEMORY_DUMPER = 0x44330001, PLOC_MEMORY_DUMPER = 0x44330001,
STR_HELPER = 0x44330002, STR_COM_IF = 0x44330002,
PLOC_MPSOC_HELPER = 0x44330003, PLOC_MPSOC_HELPER = 0x44330003,
AXI_PTME_CONFIG = 0x44330004, AXI_PTME_CONFIG = 0x44330004,
PTME_CONFIG = 0x44330005, PTME_CONFIG = 0x44330005,

34
generators/bsp_hosted_events.csv
View File

@ -155,23 +155,23 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
12409;0x3079;WRITE_SYSCALL_ERROR_PDEC;HIGH;No description;linux/ipcore/PdecHandler.h 12409;0x3079;WRITE_SYSCALL_ERROR_PDEC;HIGH;No description;linux/ipcore/PdecHandler.h
12410;0x307a;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/PdecHandler.h 12410;0x307a;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/PdecHandler.h
12411;0x307b;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/PdecHandler.h 12411;0x307b;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/PdecHandler.h
12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/devices/startracker/StrHelper.h 12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/devices/startracker/StrComHandler.h
12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/devices/startracker/StrHelper.h 12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/devices/startracker/StrComHandler.h
12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/devices/startracker/StrHelper.h 12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/devices/startracker/StrComHandler.h
12503;0x30d7;IMAGE_DOWNLOAD_SUCCESSFUL;LOW;Image download was successful;linux/devices/startracker/StrHelper.h 12503;0x30d7;IMAGE_DOWNLOAD_SUCCESSFUL;LOW;Image download was successful;linux/devices/startracker/StrComHandler.h
12504;0x30d8;FLASH_WRITE_SUCCESSFUL;LOW;Finished flash write procedure successfully;linux/devices/startracker/StrHelper.h 12504;0x30d8;FLASH_WRITE_SUCCESSFUL;LOW;Finished flash write procedure successfully;linux/devices/startracker/StrComHandler.h
12505;0x30d9;FLASH_READ_SUCCESSFUL;LOW;Finished flash read procedure successfully;linux/devices/startracker/StrHelper.h 12505;0x30d9;FLASH_READ_SUCCESSFUL;LOW;Finished flash read procedure successfully;linux/devices/startracker/StrComHandler.h
12506;0x30da;FLASH_READ_FAILED;LOW;Flash read procedure failed;linux/devices/startracker/StrHelper.h 12506;0x30da;FLASH_READ_FAILED;LOW;Flash read procedure failed;linux/devices/startracker/StrComHandler.h
12507;0x30db;FIRMWARE_UPDATE_SUCCESSFUL;LOW;Firmware update was successful;linux/devices/startracker/StrHelper.h 12507;0x30db;FIRMWARE_UPDATE_SUCCESSFUL;LOW;Firmware update was successful;linux/devices/startracker/StrComHandler.h
12508;0x30dc;FIRMWARE_UPDATE_FAILED;LOW;Firmware update failed;linux/devices/startracker/StrHelper.h 12508;0x30dc;FIRMWARE_UPDATE_FAILED;LOW;Firmware update failed;linux/devices/startracker/StrComHandler.h
12509;0x30dd;STR_HELPER_READING_REPLY_FAILED;LOW;Failed to read communication interface reply data P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed;linux/devices/startracker/StrHelper.h 12509;0x30dd;STR_HELPER_READING_REPLY_FAILED;LOW;Failed to read communication interface reply data P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed;linux/devices/startracker/StrComHandler.h
12510;0x30de;STR_HELPER_COM_ERROR;LOW;Unexpected stop of decoding sequence P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed;linux/devices/startracker/StrHelper.h 12510;0x30de;STR_HELPER_COM_ERROR;LOW;Unexpected stop of decoding sequence P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed;linux/devices/startracker/StrComHandler.h
12511;0x30df;STR_HELPER_NO_REPLY;LOW;Star tracker did not send replies (maybe device is powered off) P1: Position of upload or download packet for which no reply was sent;linux/devices/startracker/StrHelper.h 12511;0x30df;STR_HELPER_REPLY_TIMEOUT;LOW;Star tracker did not send a valid reply for a certain timeout. P1: Position of upload or download packet for which the packet wa sent. P2: Timeout;linux/devices/startracker/StrComHandler.h
12512;0x30e0;STR_HELPER_DEC_ERROR;LOW;Error during decoding of received reply occurred P1: Return value of decoding function P2: Position of upload/download packet, or address of flash write/read request;linux/devices/startracker/StrHelper.h 12513;0x30e1;STR_HELPER_DEC_ERROR;LOW;Error during decoding of received reply occurred P1: Return value of decoding function P2: Position of upload/download packet, or address of flash write/read request;linux/devices/startracker/StrComHandler.h
12513;0x30e1;POSITION_MISMATCH;LOW;Position mismatch P1: The expected position and thus the position for which the image upload/download failed;linux/devices/startracker/StrHelper.h 12514;0x30e2;POSITION_MISMATCH;LOW;Position mismatch P1: The expected position and thus the position for which the image upload/download failed;linux/devices/startracker/StrComHandler.h
12514;0x30e2;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not exist P1: Internal state of str helper;linux/devices/startracker/StrHelper.h 12515;0x30e3;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not exist P1: Internal state of str helper;linux/devices/startracker/StrComHandler.h
12515;0x30e3;STR_HELPER_SENDING_PACKET_FAILED;LOW;No description;linux/devices/startracker/StrHelper.h 12516;0x30e4;STR_HELPER_SENDING_PACKET_FAILED;LOW;No description;linux/devices/startracker/StrComHandler.h
12516;0x30e4;STR_HELPER_REQUESTING_MSG_FAILED;LOW;No description;linux/devices/startracker/StrHelper.h 12517;0x30e5;STR_HELPER_REQUESTING_MSG_FAILED;LOW;No description;linux/devices/startracker/StrComHandler.h
12600;0x3138;MPSOC_FLASH_WRITE_FAILED;LOW;Flash write fails;linux/devices/ploc/PlocMPSoCHelper.h 12600;0x3138;MPSOC_FLASH_WRITE_FAILED;LOW;Flash write fails;linux/devices/ploc/PlocMPSoCHelper.h
12601;0x3139;MPSOC_FLASH_WRITE_SUCCESSFUL;LOW;Flash write successful;linux/devices/ploc/PlocMPSoCHelper.h 12601;0x3139;MPSOC_FLASH_WRITE_SUCCESSFUL;LOW;Flash write successful;linux/devices/ploc/PlocMPSoCHelper.h
12602;0x313a;MPSOC_SENDING_COMMAND_FAILED;LOW;No description;linux/devices/ploc/PlocMPSoCHelper.h 12602;0x313a;MPSOC_SENDING_COMMAND_FAILED;LOW;No description;linux/devices/ploc/PlocMPSoCHelper.h

1 Event ID (dec) Event ID (hex) Name Severity Description File Path
155 12409 0x3079 WRITE_SYSCALL_ERROR_PDEC HIGH No description linux/ipcore/PdecHandler.h
156 12410 0x307a PDEC_RESET_FAILED HIGH Failed to pull PDEC reset to low linux/ipcore/PdecHandler.h
157 12411 0x307b OPEN_IRQ_FILE_FAILED HIGH Failed to open the IRQ uio file linux/ipcore/PdecHandler.h
158 12500 0x30d4 IMAGE_UPLOAD_FAILED LOW Image upload failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
159 12501 0x30d5 IMAGE_DOWNLOAD_FAILED LOW Image download failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
160 12502 0x30d6 IMAGE_UPLOAD_SUCCESSFUL LOW Uploading image to star tracker was successfulop linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
161 12503 0x30d7 IMAGE_DOWNLOAD_SUCCESSFUL LOW Image download was successful linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
162 12504 0x30d8 FLASH_WRITE_SUCCESSFUL LOW Finished flash write procedure successfully linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
163 12505 0x30d9 FLASH_READ_SUCCESSFUL LOW Finished flash read procedure successfully linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
164 12506 0x30da FLASH_READ_FAILED LOW Flash read procedure failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
165 12507 0x30db FIRMWARE_UPDATE_SUCCESSFUL LOW Firmware update was successful linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
166 12508 0x30dc FIRMWARE_UPDATE_FAILED LOW Firmware update failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
167 12509 0x30dd STR_HELPER_READING_REPLY_FAILED LOW Failed to read communication interface reply data P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
168 12510 0x30de STR_HELPER_COM_ERROR LOW Unexpected stop of decoding sequence P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
169 12511 0x30df STR_HELPER_NO_REPLY STR_HELPER_REPLY_TIMEOUT LOW Star tracker did not send replies (maybe device is powered off) P1: Position of upload or download packet for which no reply was sent Star tracker did not send a valid reply for a certain timeout. P1: Position of upload or download packet for which the packet wa sent. P2: Timeout linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
170 12512 12513 0x30e0 0x30e1 STR_HELPER_DEC_ERROR LOW Error during decoding of received reply occurred P1: Return value of decoding function P2: Position of upload/download packet, or address of flash write/read request linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
171 12513 12514 0x30e1 0x30e2 POSITION_MISMATCH LOW Position mismatch P1: The expected position and thus the position for which the image upload/download failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
172 12514 12515 0x30e2 0x30e3 STR_HELPER_FILE_NOT_EXISTS LOW Specified file does not exist P1: Internal state of str helper linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
173 12515 12516 0x30e3 0x30e4 STR_HELPER_SENDING_PACKET_FAILED LOW No description linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
174 12516 12517 0x30e4 0x30e5 STR_HELPER_REQUESTING_MSG_FAILED LOW No description linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
175 12600 0x3138 MPSOC_FLASH_WRITE_FAILED LOW Flash write fails linux/devices/ploc/PlocMPSoCHelper.h
176 12601 0x3139 MPSOC_FLASH_WRITE_SUCCESSFUL LOW Flash write successful linux/devices/ploc/PlocMPSoCHelper.h
177 12602 0x313a MPSOC_SENDING_COMMAND_FAILED LOW No description linux/devices/ploc/PlocMPSoCHelper.h

2
generators/bsp_hosted_objects.csv
View File

@ -42,7 +42,7 @@
0x443200A5;RAD_SENSOR 0x443200A5;RAD_SENSOR
0x44330000;PLOC_UPDATER 0x44330000;PLOC_UPDATER
0x44330001;PLOC_MEMORY_DUMPER 0x44330001;PLOC_MEMORY_DUMPER
0x44330002;STR_HELPER 0x44330002;STR_COM_IF
0x44330003;PLOC_MPSOC_HELPER 0x44330003;PLOC_MPSOC_HELPER
0x44330004;AXI_PTME_CONFIG 0x44330004;AXI_PTME_CONFIG
0x44330005;PTME_CONFIG 0x44330005;PTME_CONFIG

1 0x42694269 TEST_TASK
42 0x443200A5 RAD_SENSOR
43 0x44330000 PLOC_UPDATER
44 0x44330001 PLOC_MEMORY_DUMPER
45 0x44330002 STR_HELPER STR_COM_IF
46 0x44330003 PLOC_MPSOC_HELPER
47 0x44330004 AXI_PTME_CONFIG
48 0x44330005 PTME_CONFIG

34
generators/bsp_q7s_events.csv
View File

@ -155,23 +155,23 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
12409;0x3079;WRITE_SYSCALL_ERROR_PDEC;HIGH;No description;linux/ipcore/PdecHandler.h 12409;0x3079;WRITE_SYSCALL_ERROR_PDEC;HIGH;No description;linux/ipcore/PdecHandler.h
12410;0x307a;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/PdecHandler.h 12410;0x307a;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/PdecHandler.h
12411;0x307b;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/PdecHandler.h 12411;0x307b;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/PdecHandler.h
12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/devices/startracker/StrHelper.h 12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/devices/startracker/StrComHandler.h
12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/devices/startracker/StrHelper.h 12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/devices/startracker/StrComHandler.h
12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/devices/startracker/StrHelper.h 12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/devices/startracker/StrComHandler.h
12503;0x30d7;IMAGE_DOWNLOAD_SUCCESSFUL;LOW;Image download was successful;linux/devices/startracker/StrHelper.h 12503;0x30d7;IMAGE_DOWNLOAD_SUCCESSFUL;LOW;Image download was successful;linux/devices/startracker/StrComHandler.h
12504;0x30d8;FLASH_WRITE_SUCCESSFUL;LOW;Finished flash write procedure successfully;linux/devices/startracker/StrHelper.h 12504;0x30d8;FLASH_WRITE_SUCCESSFUL;LOW;Finished flash write procedure successfully;linux/devices/startracker/StrComHandler.h
12505;0x30d9;FLASH_READ_SUCCESSFUL;LOW;Finished flash read procedure successfully;linux/devices/startracker/StrHelper.h 12505;0x30d9;FLASH_READ_SUCCESSFUL;LOW;Finished flash read procedure successfully;linux/devices/startracker/StrComHandler.h
12506;0x30da;FLASH_READ_FAILED;LOW;Flash read procedure failed;linux/devices/startracker/StrHelper.h 12506;0x30da;FLASH_READ_FAILED;LOW;Flash read procedure failed;linux/devices/startracker/StrComHandler.h
12507;0x30db;FIRMWARE_UPDATE_SUCCESSFUL;LOW;Firmware update was successful;linux/devices/startracker/StrHelper.h 12507;0x30db;FIRMWARE_UPDATE_SUCCESSFUL;LOW;Firmware update was successful;linux/devices/startracker/StrComHandler.h
12508;0x30dc;FIRMWARE_UPDATE_FAILED;LOW;Firmware update failed;linux/devices/startracker/StrHelper.h 12508;0x30dc;FIRMWARE_UPDATE_FAILED;LOW;Firmware update failed;linux/devices/startracker/StrComHandler.h
12509;0x30dd;STR_HELPER_READING_REPLY_FAILED;LOW;Failed to read communication interface reply data P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed;linux/devices/startracker/StrHelper.h 12509;0x30dd;STR_HELPER_READING_REPLY_FAILED;LOW;Failed to read communication interface reply data P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed;linux/devices/startracker/StrComHandler.h
12510;0x30de;STR_HELPER_COM_ERROR;LOW;Unexpected stop of decoding sequence P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed;linux/devices/startracker/StrHelper.h 12510;0x30de;STR_HELPER_COM_ERROR;LOW;Unexpected stop of decoding sequence P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed;linux/devices/startracker/StrComHandler.h
12511;0x30df;STR_HELPER_NO_REPLY;LOW;Star tracker did not send replies (maybe device is powered off) P1: Position of upload or download packet for which no reply was sent;linux/devices/startracker/StrHelper.h 12511;0x30df;STR_HELPER_REPLY_TIMEOUT;LOW;Star tracker did not send a valid reply for a certain timeout. P1: Position of upload or download packet for which the packet wa sent. P2: Timeout;linux/devices/startracker/StrComHandler.h
12512;0x30e0;STR_HELPER_DEC_ERROR;LOW;Error during decoding of received reply occurred P1: Return value of decoding function P2: Position of upload/download packet, or address of flash write/read request;linux/devices/startracker/StrHelper.h 12513;0x30e1;STR_HELPER_DEC_ERROR;LOW;Error during decoding of received reply occurred P1: Return value of decoding function P2: Position of upload/download packet, or address of flash write/read request;linux/devices/startracker/StrComHandler.h
12513;0x30e1;POSITION_MISMATCH;LOW;Position mismatch P1: The expected position and thus the position for which the image upload/download failed;linux/devices/startracker/StrHelper.h 12514;0x30e2;POSITION_MISMATCH;LOW;Position mismatch P1: The expected position and thus the position for which the image upload/download failed;linux/devices/startracker/StrComHandler.h
12514;0x30e2;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not exist P1: Internal state of str helper;linux/devices/startracker/StrHelper.h 12515;0x30e3;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not exist P1: Internal state of str helper;linux/devices/startracker/StrComHandler.h
12515;0x30e3;STR_HELPER_SENDING_PACKET_FAILED;LOW;No description;linux/devices/startracker/StrHelper.h 12516;0x30e4;STR_HELPER_SENDING_PACKET_FAILED;LOW;No description;linux/devices/startracker/StrComHandler.h
12516;0x30e4;STR_HELPER_REQUESTING_MSG_FAILED;LOW;No description;linux/devices/startracker/StrHelper.h 12517;0x30e5;STR_HELPER_REQUESTING_MSG_FAILED;LOW;No description;linux/devices/startracker/StrComHandler.h
12600;0x3138;MPSOC_FLASH_WRITE_FAILED;LOW;Flash write fails;linux/devices/ploc/PlocMPSoCHelper.h 12600;0x3138;MPSOC_FLASH_WRITE_FAILED;LOW;Flash write fails;linux/devices/ploc/PlocMPSoCHelper.h
12601;0x3139;MPSOC_FLASH_WRITE_SUCCESSFUL;LOW;Flash write successful;linux/devices/ploc/PlocMPSoCHelper.h 12601;0x3139;MPSOC_FLASH_WRITE_SUCCESSFUL;LOW;Flash write successful;linux/devices/ploc/PlocMPSoCHelper.h
12602;0x313a;MPSOC_SENDING_COMMAND_FAILED;LOW;No description;linux/devices/ploc/PlocMPSoCHelper.h 12602;0x313a;MPSOC_SENDING_COMMAND_FAILED;LOW;No description;linux/devices/ploc/PlocMPSoCHelper.h

1 Event ID (dec) Event ID (hex) Name Severity Description File Path
155 12409 0x3079 WRITE_SYSCALL_ERROR_PDEC HIGH No description linux/ipcore/PdecHandler.h
156 12410 0x307a PDEC_RESET_FAILED HIGH Failed to pull PDEC reset to low linux/ipcore/PdecHandler.h
157 12411 0x307b OPEN_IRQ_FILE_FAILED HIGH Failed to open the IRQ uio file linux/ipcore/PdecHandler.h
158 12500 0x30d4 IMAGE_UPLOAD_FAILED LOW Image upload failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
159 12501 0x30d5 IMAGE_DOWNLOAD_FAILED LOW Image download failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
160 12502 0x30d6 IMAGE_UPLOAD_SUCCESSFUL LOW Uploading image to star tracker was successfulop linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
161 12503 0x30d7 IMAGE_DOWNLOAD_SUCCESSFUL LOW Image download was successful linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
162 12504 0x30d8 FLASH_WRITE_SUCCESSFUL LOW Finished flash write procedure successfully linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
163 12505 0x30d9 FLASH_READ_SUCCESSFUL LOW Finished flash read procedure successfully linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
164 12506 0x30da FLASH_READ_FAILED LOW Flash read procedure failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
165 12507 0x30db FIRMWARE_UPDATE_SUCCESSFUL LOW Firmware update was successful linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
166 12508 0x30dc FIRMWARE_UPDATE_FAILED LOW Firmware update failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
167 12509 0x30dd STR_HELPER_READING_REPLY_FAILED LOW Failed to read communication interface reply data P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
168 12510 0x30de STR_HELPER_COM_ERROR LOW Unexpected stop of decoding sequence P1: Return code of failed communication interface read call P1: Upload/download position for which the read call failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
169 12511 0x30df STR_HELPER_NO_REPLY STR_HELPER_REPLY_TIMEOUT LOW Star tracker did not send replies (maybe device is powered off) P1: Position of upload or download packet for which no reply was sent Star tracker did not send a valid reply for a certain timeout. P1: Position of upload or download packet for which the packet wa sent. P2: Timeout linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
170 12512 12513 0x30e0 0x30e1 STR_HELPER_DEC_ERROR LOW Error during decoding of received reply occurred P1: Return value of decoding function P2: Position of upload/download packet, or address of flash write/read request linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
171 12513 12514 0x30e1 0x30e2 POSITION_MISMATCH LOW Position mismatch P1: The expected position and thus the position for which the image upload/download failed linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
172 12514 12515 0x30e2 0x30e3 STR_HELPER_FILE_NOT_EXISTS LOW Specified file does not exist P1: Internal state of str helper linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
173 12515 12516 0x30e3 0x30e4 STR_HELPER_SENDING_PACKET_FAILED LOW No description linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
174 12516 12517 0x30e4 0x30e5 STR_HELPER_REQUESTING_MSG_FAILED LOW No description linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
175 12600 0x3138 MPSOC_FLASH_WRITE_FAILED LOW Flash write fails linux/devices/ploc/PlocMPSoCHelper.h
176 12601 0x3139 MPSOC_FLASH_WRITE_SUCCESSFUL LOW Flash write successful linux/devices/ploc/PlocMPSoCHelper.h
177 12602 0x313a MPSOC_SENDING_COMMAND_FAILED LOW No description linux/devices/ploc/PlocMPSoCHelper.h

2
generators/bsp_q7s_objects.csv
View File

@ -41,7 +41,7 @@
0x443200A5;RAD_SENSOR 0x443200A5;RAD_SENSOR
0x44330000;PLOC_UPDATER 0x44330000;PLOC_UPDATER
0x44330001;PLOC_MEMORY_DUMPER 0x44330001;PLOC_MEMORY_DUMPER
0x44330002;STR_HELPER 0x44330002;STR_COM_IF
0x44330003;PLOC_MPSOC_HELPER 0x44330003;PLOC_MPSOC_HELPER
0x44330004;AXI_PTME_CONFIG 0x44330004;AXI_PTME_CONFIG
0x44330005;PTME_CONFIG 0x44330005;PTME_CONFIG

1 0x00005060 P60DOCK_TEST_TASK
41 0x443200A5 RAD_SENSOR
42 0x44330000 PLOC_UPDATER
43 0x44330001 PLOC_MEMORY_DUMPER
44 0x44330002 STR_HELPER STR_COM_IF
45 0x44330003 PLOC_MPSOC_HELPER
46 0x44330004 AXI_PTME_CONFIG
47 0x44330005 PTME_CONFIG

21
generators/bsp_q7s_returnvalues.csv
View File

@ -491,15 +491,18 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
0x58a1;SUSS_ErrorLockMutex;No description;161;SUS_HANDLER;mission/devices/LegacySusHandler.h 0x58a1;SUSS_ErrorLockMutex;No description;161;SUS_HANDLER;mission/devices/LegacySusHandler.h
0x59a0;IPCI_PapbBusy;No description;160;CCSDS_IP_CORE_BRIDGE;linux/ipcore/PapbVcInterface.h 0x59a0;IPCI_PapbBusy;No description;160;CCSDS_IP_CORE_BRIDGE;linux/ipcore/PapbVcInterface.h
0x5aa0;PTME_UnknownVcId;No description;160;PTME;linux/ipcore/Ptme.h 0x5aa0;PTME_UnknownVcId;No description;160;PTME;linux/ipcore/Ptme.h
0x5ca0;STRHLP_SdNotMounted;SD card specified in path string not mounted;160;STR_HELPER;linux/devices/startracker/StrHelper.h 0x5c00;STRHLP_Busy;No description;0;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5ca1;STRHLP_FileNotExists;Specified file does not exist on filesystem;161;STR_HELPER;linux/devices/startracker/StrHelper.h 0x5c01;STRHLP_SdNotMounted;SD card specified in path string not mounted;1;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5ca2;STRHLP_PathNotExists;Specified path does not exist;162;STR_HELPER;linux/devices/startracker/StrHelper.h 0x5c02;STRHLP_FileNotExists;Specified file does not exist on filesystem;2;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5ca3;STRHLP_FileCreationFailed;Failed to create download image or read flash file;163;STR_HELPER;linux/devices/startracker/StrHelper.h 0x5c03;STRHLP_PathNotExists;Specified path does not exist;3;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5ca4;STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;164;STR_HELPER;linux/devices/startracker/StrHelper.h 0x5c04;STRHLP_FileCreationFailed;Failed to create download image or read flash file;4;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5ca5;STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;165;STR_HELPER;linux/devices/startracker/StrHelper.h 0x5c05;STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;5;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5ca6;STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;166;STR_HELPER;linux/devices/startracker/StrHelper.h 0x5c06;STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;6;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5ca7;STRHLP_StatusError;Status field in reply signals error;167;STR_HELPER;linux/devices/startracker/StrHelper.h 0x5c07;STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;7;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5ca8;STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);168;STR_HELPER;linux/devices/startracker/StrHelper.h 0x5c08;STRHLP_StatusError;Status field in reply signals error;8;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5c09;STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);9;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5c0a;STRHLP_ReceptionTimeout;No description;10;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5c0b;STRHLP_DecodingError;No description;11;STR_HELPER;linux/devices/startracker/StrComHandler.h
0x5d00;GOMS_PacketTooLong;No description;0;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h 0x5d00;GOMS_PacketTooLong;No description;0;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
0x5d01;GOMS_InvalidTableId;No description;1;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h 0x5d01;GOMS_InvalidTableId;No description;1;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
0x5d02;GOMS_InvalidAddress;No description;2;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h 0x5d02;GOMS_InvalidAddress;No description;2;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h

1 Full ID (hex) Name Description Unique ID Subsytem Name File Path
491 0x58a1 SUSS_ErrorLockMutex No description 161 SUS_HANDLER mission/devices/LegacySusHandler.h
492 0x59a0 IPCI_PapbBusy No description 160 CCSDS_IP_CORE_BRIDGE linux/ipcore/PapbVcInterface.h
493 0x5aa0 PTME_UnknownVcId No description 160 PTME linux/ipcore/Ptme.h
494 0x5ca0 0x5c00 STRHLP_SdNotMounted STRHLP_Busy SD card specified in path string not mounted No description 160 0 STR_HELPER linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
495 0x5ca1 0x5c01 STRHLP_FileNotExists STRHLP_SdNotMounted Specified file does not exist on filesystem SD card specified in path string not mounted 161 1 STR_HELPER linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
496 0x5ca2 0x5c02 STRHLP_PathNotExists STRHLP_FileNotExists Specified path does not exist Specified file does not exist on filesystem 162 2 STR_HELPER linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
497 0x5ca3 0x5c03 STRHLP_FileCreationFailed STRHLP_PathNotExists Failed to create download image or read flash file Specified path does not exist 163 3 STR_HELPER linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
498 0x5ca4 0x5c04 STRHLP_RegionMismatch STRHLP_FileCreationFailed Region in flash write/read reply does not match expected region Failed to create download image or read flash file 164 4 STR_HELPER linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
499 0x5ca5 0x5c05 STRHLP_AddressMismatch STRHLP_RegionMismatch Address in flash write/read reply does not match expected address Region in flash write/read reply does not match expected region 165 5 STR_HELPER linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
500 0x5ca6 0x5c06 STRHLP_LengthMismatch STRHLP_AddressMismatch Length in flash write/read reply does not match expected length Address in flash write/read reply does not match expected address 166 6 STR_HELPER linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
501 0x5ca7 0x5c07 STRHLP_StatusError STRHLP_LengthMismatch Status field in reply signals error Length in flash write/read reply does not match expected length 167 7 STR_HELPER linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
502 0x5ca8 0x5c08 STRHLP_InvalidTypeId STRHLP_StatusError Reply has invalid type ID (should be of action reply type) Status field in reply signals error 168 8 STR_HELPER linux/devices/startracker/StrHelper.h linux/devices/startracker/StrComHandler.h
503 0x5c09 STRHLP_InvalidTypeId Reply has invalid type ID (should be of action reply type) 9 STR_HELPER linux/devices/startracker/StrComHandler.h
504 0x5c0a STRHLP_ReceptionTimeout No description 10 STR_HELPER linux/devices/startracker/StrComHandler.h
505 0x5c0b STRHLP_DecodingError No description 11 STR_HELPER linux/devices/startracker/StrComHandler.h
506 0x5d00 GOMS_PacketTooLong No description 0 GOM_SPACE_HANDLER mission/devices/GomspaceDeviceHandler.h
507 0x5d01 GOMS_InvalidTableId No description 1 GOM_SPACE_HANDLER mission/devices/GomspaceDeviceHandler.h
508 0x5d02 GOMS_InvalidAddress No description 2 GOM_SPACE_HANDLER mission/devices/GomspaceDeviceHandler.h

16
generators/events/translateEvents.cpp
View File

@ -1,7 +1,7 @@
/** /**
* @brief Auto-generated event translation file. Contains 279 translations. * @brief Auto-generated event translation file. Contains 279 translations.
* @details * @details
* Generated on: 2023-03-21 23:59:36 * Generated on: 2023-03-22 01:14:08
*/ */
#include "translateEvents.h" #include "translateEvents.h"
@ -172,7 +172,7 @@ const char *FIRMWARE_UPDATE_SUCCESSFUL_STRING = "FIRMWARE_UPDATE_SUCCESSFUL";
const char *FIRMWARE_UPDATE_FAILED_STRING = "FIRMWARE_UPDATE_FAILED"; const char *FIRMWARE_UPDATE_FAILED_STRING = "FIRMWARE_UPDATE_FAILED";
const char *STR_HELPER_READING_REPLY_FAILED_STRING = "STR_HELPER_READING_REPLY_FAILED"; const char *STR_HELPER_READING_REPLY_FAILED_STRING = "STR_HELPER_READING_REPLY_FAILED";
const char *STR_HELPER_COM_ERROR_STRING = "STR_HELPER_COM_ERROR"; const char *STR_HELPER_COM_ERROR_STRING = "STR_HELPER_COM_ERROR";
const char *STR_HELPER_NO_REPLY_STRING = "STR_HELPER_NO_REPLY"; const char *STR_HELPER_REPLY_TIMEOUT_STRING = "STR_HELPER_REPLY_TIMEOUT";
const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR"; const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR";
const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH"; const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH";
const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS"; const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS";
@ -617,16 +617,16 @@ const char *translateEvents(Event event) {
case (12510): case (12510):
return STR_HELPER_COM_ERROR_STRING; return STR_HELPER_COM_ERROR_STRING;
case (12511): case (12511):
return STR_HELPER_NO_REPLY_STRING; return STR_HELPER_REPLY_TIMEOUT_STRING;
case (12512):
return STR_HELPER_DEC_ERROR_STRING;
case (12513): case (12513):
return POSITION_MISMATCH_STRING; return STR_HELPER_DEC_ERROR_STRING;
case (12514): case (12514):
return STR_HELPER_FILE_NOT_EXISTS_STRING; return POSITION_MISMATCH_STRING;
case (12515): case (12515):
return STR_HELPER_SENDING_PACKET_FAILED_STRING; return STR_HELPER_FILE_NOT_EXISTS_STRING;
case (12516): case (12516):
return STR_HELPER_SENDING_PACKET_FAILED_STRING;
case (12517):
return STR_HELPER_REQUESTING_MSG_FAILED_STRING; return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
case (12600): case (12600):
return MPSOC_FLASH_WRITE_FAILED_STRING; return MPSOC_FLASH_WRITE_FAILED_STRING;

6
generators/objects/translateObjects.cpp
View File

@ -2,7 +2,7 @@
* @brief Auto-generated object translation file. * @brief Auto-generated object translation file.
* @details * @details
* Contains 173 translations. * Contains 173 translations.
* Generated on: 2023-03-21 23:59:36 * Generated on: 2023-03-22 01:14:08
*/ */
#include "translateObjects.h" #include "translateObjects.h"
@ -49,7 +49,7 @@ const char *PLPCDU_HANDLER_STRING = "PLPCDU_HANDLER";
const char *RAD_SENSOR_STRING = "RAD_SENSOR"; const char *RAD_SENSOR_STRING = "RAD_SENSOR";
const char *PLOC_UPDATER_STRING = "PLOC_UPDATER"; const char *PLOC_UPDATER_STRING = "PLOC_UPDATER";
const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER"; const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER";
const char *STR_HELPER_STRING = "STR_HELPER"; const char *STR_COM_IF_STRING = "STR_COM_IF";
const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER"; const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER";
const char *AXI_PTME_CONFIG_STRING = "AXI_PTME_CONFIG"; const char *AXI_PTME_CONFIG_STRING = "AXI_PTME_CONFIG";
const char *PTME_CONFIG_STRING = "PTME_CONFIG"; const char *PTME_CONFIG_STRING = "PTME_CONFIG";
@ -269,7 +269,7 @@ const char *translateObject(object_id_t object) {
case 0x44330001: case 0x44330001:
return PLOC_MEMORY_DUMPER_STRING; return PLOC_MEMORY_DUMPER_STRING;
case 0x44330002: case 0x44330002:
return STR_HELPER_STRING; return STR_COM_IF_STRING;
case 0x44330003: case 0x44330003:
return PLOC_MPSOC_HELPER_STRING; return PLOC_MPSOC_HELPER_STRING;
case 0x44330004: case 0x44330004:

2
linux/ObjectFactory.cpp
View File

@ -314,7 +314,7 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher, void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher,
SdCardMountedIF& mountedIF, bool onImmediately, SdCardMountedIF& mountedIF, bool onImmediately,
std::optional<power::Switch_t> switchId) { std::optional<power::Switch_t> switchId) {
auto* cookie = new SerialCookie(objects::SCEX, uartDev, uart::SCEX_BAUD, 4096); auto* cookie = new SerialCookie(objects::SCEX, uartDev, serial::SCEX_BAUD, 4096);
cookie->setTwoStopBits(); cookie->setTwoStopBits();
// cookie->setParityEven(); // cookie->setParityEven();
auto scexUartReader = new ScexUartReader(objects::SCEX_UART_READER); auto scexUartReader = new ScexUartReader(objects::SCEX_UART_READER);

13
linux/devices/ScexUartReader.cpp
View File

@ -98,11 +98,11 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
} }
// Setting up UART parameters // Setting up UART parameters
tty.c_cflag &= ~PARENB; // Clear parity bit tty.c_cflag &= ~PARENB; // Clear parity bit
uart::setStopbits(tty, uartCookie->getStopBits()); serial::setStopbits(tty, uartCookie->getStopBits());
uart::setBitsPerWord(tty, BitsPerWord::BITS_8); serial::setBitsPerWord(tty, BitsPerWord::BITS_8);
tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
uart::enableRead(tty); serial::enableRead(tty);
uart::ignoreCtrlLines(tty); serial::ignoreCtrlLines(tty);
// Use non-canonical mode and clear echo flag // Use non-canonical mode and clear echo flag
tty.c_lflag &= ~(ICANON | ECHO); tty.c_lflag &= ~(ICANON | ECHO);
@ -111,7 +111,7 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
tty.c_cc[VTIME] = 0; tty.c_cc[VTIME] = 0;
tty.c_cc[VMIN] = 0; tty.c_cc[VMIN] = 0;
uart::setBaudrate(tty, uartCookie->getBaudrate()); serial::setBaudrate(tty, uartCookie->getBaudrate());
if (tcsetattr(serialPort, TCSANOW, &tty) != 0) { if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
sif::warning << "ScexUartReader::initializeInterface: tcsetattr call failed with error [" sif::warning << "ScexUartReader::initializeInterface: tcsetattr call failed with error ["
<< errno << ", " << strerror(errno) << std::endl; << errno << ", " << strerror(errno) << std::endl;
@ -148,8 +148,7 @@ ReturnValue_t ScexUartReader::sendMessage(CookieIF *cookie, const uint8_t *sendD
} }
size_t bytesWritten = write(serialPort, cmdbuf.data(), encodedLen); size_t bytesWritten = write(serialPort, cmdbuf.data(), encodedLen);
if (bytesWritten != encodedLen) { if (bytesWritten != encodedLen) {
sif::warning << "ScexUartReader::sendMessage: Sending ping command to solar experiment failed" sif::warning << "ScexUartReader::sendMessage: Sending command failed" << std::endl;
<< std::endl;
return FAILED; return FAILED;
} }

12
linux/devices/ploc/PlocSupvUartMan.cpp
View File

@ -58,12 +58,12 @@ ReturnValue_t PlocSupvUartManager::initializeInterface(CookieIF* cookie) {
} }
// Setting up UART parameters // Setting up UART parameters
tty.c_cflag &= ~PARENB; // Clear parity bit tty.c_cflag &= ~PARENB; // Clear parity bit
uart::setParity(tty, uartCookie->getParity()); serial::setParity(tty, uartCookie->getParity());
uart::setStopbits(tty, uartCookie->getStopBits()); serial::setStopbits(tty, uartCookie->getStopBits());
uart::setBitsPerWord(tty, BitsPerWord::BITS_8); serial::setBitsPerWord(tty, BitsPerWord::BITS_8);
tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
uart::enableRead(tty); serial::enableRead(tty);
uart::ignoreCtrlLines(tty); serial::ignoreCtrlLines(tty);
// Use non-canonical mode and clear echo flag // Use non-canonical mode and clear echo flag
tty.c_lflag &= ~(ICANON | ECHO); tty.c_lflag &= ~(ICANON | ECHO);
@ -72,7 +72,7 @@ ReturnValue_t PlocSupvUartManager::initializeInterface(CookieIF* cookie) {
tty.c_cc[VTIME] = 2; tty.c_cc[VTIME] = 2;
tty.c_cc[VMIN] = 0; tty.c_cc[VMIN] = 0;
uart::setBaudrate(tty, uartCookie->getBaudrate()); serial::setBaudrate(tty, uartCookie->getBaudrate());
if (tcsetattr(serialPort, TCSANOW, &tty) != 0) { if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
sif::warning << "PlocSupvUartManager::initializeInterface: tcsetattr call failed with error [" sif::warning << "PlocSupvUartManager::initializeInterface: tcsetattr call failed with error ["
<< errno << ", " << strerror(errno) << std::endl; << errno << ", " << strerror(errno) << std::endl;

2
linux/devices/ploc/PlocSupvUartMan.h
View File

@ -246,9 +246,9 @@ class PlocSupvUartManager : public DeviceCommunicationIF,
std::array<uint8_t, 2048> recBuf = {}; std::array<uint8_t, 2048> recBuf = {};
std::array<uint8_t, 2048> encodedBuf = {}; std::array<uint8_t, 2048> encodedBuf = {};
std::array<uint8_t, 1200> decodedBuf = {}; std::array<uint8_t, 1200> decodedBuf = {};
std::array<uint8_t, 1200> ipcBuffer = {};
SimpleRingBuffer decodedRingBuf; SimpleRingBuffer decodedRingBuf;
FIFO<size_t, MAX_STORED_DECODED_PACKETS> decodedQueue; FIFO<size_t, MAX_STORED_DECODED_PACKETS> decodedQueue;
std::array<uint8_t, 1200> ipcBuffer = {};
SimpleRingBuffer ipcRingBuf; SimpleRingBuffer ipcRingBuf;
FIFO<size_t, MAX_STORED_DECODED_PACKETS> ipcQueue; FIFO<size_t, MAX_STORED_DECODED_PACKETS> ipcQueue;

72
linux/devices/startracker/ArcsecDatalinkLayer.cpp
View File

@ -1,39 +1,36 @@
#include "ArcsecDatalinkLayer.h" #include "ArcsecDatalinkLayer.h"
ArcsecDatalinkLayer::ArcsecDatalinkLayer() { slipInit(); } ArcsecDatalinkLayer::ArcsecDatalinkLayer() : decodeRingBuf(BUFFER_LENGTHS, true) { slipInit(); }
ArcsecDatalinkLayer::~ArcsecDatalinkLayer() {} ArcsecDatalinkLayer::~ArcsecDatalinkLayer() {}
void ArcsecDatalinkLayer::slipInit() { ReturnValue_t ArcsecDatalinkLayer::checkRingBufForFrame(const uint8_t** decodedFrame,
slipInfo.buffer = rxBuffer; size_t& frameLen) {
slipInfo.maxlength = startracker::MAX_FRAME_SIZE; size_t currentLen = decodeRingBuf.getAvailableReadData();
slipInfo.length = 0; decodeRingBuf.readData(rxAnalysisBuffer, currentLen);
slipInfo.unescape_next = 0; for (size_t idx = 0; idx < currentLen; idx++) {
slipInfo.prev_state = SLIP_COMPLETE;
}
ReturnValue_t ArcsecDatalinkLayer::decodeFrame(const uint8_t* rawData, size_t rawDataSize,
size_t* bytesLeft) {
size_t bytePos = 0;
for (bytePos = 0; bytePos < rawDataSize; bytePos++) {
enum arc_dec_result decResult = enum arc_dec_result decResult =
arc_transport_decode_body(*(rawData + bytePos), &slipInfo, decodedFrame, &decFrameSize); arc_transport_decode_body(rxAnalysisBuffer[idx], &slipInfo, decodedRxFrame, &rxFrameSize);
*bytesLeft = rawDataSize - bytePos - 1;
switch (decResult) { switch (decResult) {
case ARC_DEC_INPROGRESS: { case ARC_DEC_INPROGRESS: {
if (bytePos == rawDataSize - 1) { break;
return DEC_IN_PROGRESS;
}
continue;
} }
case ARC_DEC_ERROR_FRAME_SHORT: case ARC_DEC_ERROR_FRAME_SHORT: {
decodeRingBuf.deleteData(idx);
return REPLY_TOO_SHORT; return REPLY_TOO_SHORT;
}
case ARC_DEC_ERROR_CHECKSUM: case ARC_DEC_ERROR_CHECKSUM:
decodeRingBuf.deleteData(idx);
return CRC_FAILURE; return CRC_FAILURE;
case ARC_DEC_ASYNC: case ARC_DEC_ASYNC:
case ARC_DEC_SYNC: { case ARC_DEC_SYNC: {
// Reset length of SLIP struct for next frame // Reset length of SLIP struct for next frame
slipInfo.length = 0; slipInfo.length = 0;
if (decodedFrame != nullptr) {
*decodedFrame = decodedRxFrame;
}
frameLen = rxFrameSize;
decodeRingBuf.deleteData(idx);
return returnvalue::OK; return returnvalue::OK;
} }
default: default:
@ -42,21 +39,32 @@ ReturnValue_t ArcsecDatalinkLayer::decodeFrame(const uint8_t* rawData, size_t ra
return returnvalue::FAILED; return returnvalue::FAILED;
} }
} }
return returnvalue::FAILED; decodeRingBuf.deleteData(currentLen);
return DEC_IN_PROGRESS;
} }
uint8_t ArcsecDatalinkLayer::getReplyFrameType() { return decodedFrame[0]; } ReturnValue_t ArcsecDatalinkLayer::feedData(const uint8_t* rawData, size_t rawDataLen) {
if (rawDataLen > 4096) {
const uint8_t* ArcsecDatalinkLayer::getReply() { return &decodedFrame[1]; } sif::error << "ArcsecDatalinklayer: Can not write more than 4096 bytes to ring buffer"
<< std::endl;
void ArcsecDatalinkLayer::encodeFrame(const uint8_t* data, uint32_t length) { return returnvalue::FAILED;
arc_transport_encode_body(data, length, encBuffer, &encFrameSize); }
return decodeRingBuf.writeData(rawData, rawDataLen);
} }
uint8_t* ArcsecDatalinkLayer::getEncodedFrame() { return encBuffer; } void ArcsecDatalinkLayer::reset() {
slipInit();
decodeRingBuf.clear();
}
uint32_t ArcsecDatalinkLayer::getEncodedLength() { return encFrameSize; } void ArcsecDatalinkLayer::slipInit() {
slip_decode_init(rxBufferArc, sizeof(rxBufferArc), &slipInfo);
}
uint8_t ArcsecDatalinkLayer::getStatusField() { return *(decodedFrame + STATUS_OFFSET); } void ArcsecDatalinkLayer::encodeFrame(const uint8_t* data, size_t length, const uint8_t** txFrame,
size_t& size) {
uint8_t ArcsecDatalinkLayer::getId() { return *(decodedFrame + ID_OFFSET); } arc_transport_encode_body(data, length, txEncoded, &size);
if (txFrame != nullptr) {
*txFrame = txEncoded;
}
}

85
linux/devices/startracker/ArcsecDatalinkLayer.h
View File

@ -1,14 +1,14 @@
#ifndef BSP_Q7S_DEVICES_ARCSECDATALINKLAYER_H_ #ifndef BSP_Q7S_DEVICES_ARCSECDATALINKLAYER_H_
#define BSP_Q7S_DEVICES_ARCSECDATALINKLAYER_H_ #define BSP_Q7S_DEVICES_ARCSECDATALINKLAYER_H_
#include <fsfw/container/SimpleRingBuffer.h>
#include <fsfw/devicehandlers/CookieIF.h>
#include "arcsec/common/misc.h"
#include "eive/resultClassIds.h" #include "eive/resultClassIds.h"
#include "fsfw/returnvalues/returnvalue.h" #include "fsfw/returnvalues/returnvalue.h"
#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h" #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
extern "C" {
#include "common/misc.h"
}
/** /**
* @brief Helper class to handle the datalinklayer of replies from the star tracker of arcsec. * @brief Helper class to handle the datalinklayer of replies from the star tracker of arcsec.
*/ */
@ -25,17 +25,30 @@ class ArcsecDatalinkLayer {
static const uint8_t STATUS_OK = 0; static const uint8_t STATUS_OK = 0;
static constexpr size_t BUFFER_LENGTHS = 4096;
ArcsecDatalinkLayer(); ArcsecDatalinkLayer();
virtual ~ArcsecDatalinkLayer(); virtual ~ArcsecDatalinkLayer();
/** /**
* @brief Applies decoding to data referenced by rawData pointer * Feed received data to the internal ring buffer.
* * @param rawData
* @param rawData Pointer to raw data received from star tracker * @param rawDataLen
* @param rawDataSize Size of raw data stream * @return
* @param remainingBytes Number of bytes left
*/ */
ReturnValue_t decodeFrame(const uint8_t* rawData, size_t rawDataSize, size_t* bytesLeft); ReturnValue_t feedData(const uint8_t* rawData, size_t rawDataLen);
/**
* Runs the arcsec datalink layer decoding algorithm on the data in the ring buffer, decoding
* frames in the process.
* @param decodedFrame
* @param frameLen
* @return
* - returnvalue::OK if a frame was found
* - DEC_IN_PROGRESS if frame decoding is in progress
* - Anything else is a decoding error
*/
ReturnValue_t checkRingBufForFrame(const uint8_t** decodedFrame, size_t& frameLen);
/** /**
* @brief SLIP encodes data pointed to by data pointer. * @brief SLIP encodes data pointed to by data pointer.
@ -43,53 +56,31 @@ class ArcsecDatalinkLayer {
* @param data Pointer to data to encode * @param data Pointer to data to encode
* @param length Length of buffer to encode * @param length Length of buffer to encode
*/ */
void encodeFrame(const uint8_t* data, uint32_t length); void encodeFrame(const uint8_t* data, size_t length, const uint8_t** txFrame, size_t& frameLen);
/** void reset();
* @brief Returns the frame type field of a decoded frame.
*/
uint8_t getReplyFrameType();
/**
* @brief Returns pointer to reply packet (first entry normally action ID, telemetry ID etc.)
*/
const uint8_t* getReply();
/**
* @brief Returns size of encoded frame
*/
uint32_t getEncodedLength();
/**
* @brief Returns pointer to encoded frame
*/
uint8_t* getEncodedFrame();
/**
* @brief Returns status of reply
*/
uint8_t getStatusField();
/**
* @brief Returns ID of reply
*/
uint8_t getId();
private: private:
static const uint8_t ID_OFFSET = 1; static const uint8_t ID_OFFSET = 1;
static const uint8_t STATUS_OFFSET = 2; static const uint8_t STATUS_OFFSET = 2;
// Used by arcsec slip decoding function process received data // User to buffer and analyse data and allow feeding and checking for frames asychronously.
uint8_t rxBuffer[startracker::MAX_FRAME_SIZE]; SimpleRingBuffer decodeRingBuf;
uint8_t rxAnalysisBuffer[BUFFER_LENGTHS];
// Used by arcsec slip decoding function to process received data. This should only be written
// to or read from by arcsec functions!
uint8_t rxBufferArc[startracker::MAX_FRAME_SIZE];
// Decoded frame will be copied to this buffer // Decoded frame will be copied to this buffer
uint8_t decodedFrame[startracker::MAX_FRAME_SIZE]; uint8_t decodedRxFrame[startracker::MAX_FRAME_SIZE];
// Size of decoded frame
uint32_t rxFrameSize = 0;
// Buffer where encoded frames will be stored. First byte of encoded frame represents type of // Buffer where encoded frames will be stored. First byte of encoded frame represents type of
// reply // reply
uint8_t encBuffer[startracker::MAX_FRAME_SIZE * 2 + 2]; uint8_t txEncoded[startracker::MAX_FRAME_SIZE * 2 + 2];
// Size of decoded frame
uint32_t decFrameSize = 0;
// Size of encoded frame // Size of encoded frame
uint32_t encFrameSize = 0; uint32_t txFrameSize = 0;
slip_decode_state slipInfo; slip_decode_state slipInfo;

11
linux/devices/startracker/ArcsecJsonParamBase.cpp
View File

@ -1,17 +1,10 @@
#include "ArcsecJsonParamBase.h" #include "ArcsecJsonParamBase.h"
#include "ArcsecJsonKeys.h" #include "arcsecJsonKeys.h"
ArcsecJsonParamBase::ArcsecJsonParamBase(std::string setName) : setName(setName) {} ArcsecJsonParamBase::ArcsecJsonParamBase(std::string setName) : setName(setName) {}
ReturnValue_t ArcsecJsonParamBase::create(std::string fullname, uint8_t* buffer) { ReturnValue_t ArcsecJsonParamBase::create(uint8_t* buffer) {
// ReturnValue_t result = returnvalue::OK;
// result = init(fullname);
// if (result != returnvalue::OK) {
// sif::warning << "ArcsecJsonParamBase::create: Failed to init parameter command for set "
// << setName << std::endl;
// return result;
// }
ReturnValue_t result = createCommand(buffer); ReturnValue_t result = createCommand(buffer);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sif::warning << "ArcsecJsonParamBase::create: Failed to create parameter command for set " sif::warning << "ArcsecJsonParamBase::create: Failed to create parameter command for set "

9
linux/devices/startracker/ArcsecJsonParamBase.h
View File

@ -5,15 +5,12 @@
#include <fstream> #include <fstream>
#include <nlohmann/json.hpp> #include <nlohmann/json.hpp>
#include "arcsec/common/generated/tmtcstructs.h"
#include "arcsec/common/genericstructs.h"
#include "eive/resultClassIds.h" #include "eive/resultClassIds.h"
#include "fsfw/returnvalues/returnvalue.h" #include "fsfw/returnvalues/returnvalue.h"
#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h" #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
extern "C" {
#include "thirdparty/arcsec_star_tracker/common/generated/tmtcstructs.h"
#include "thirdparty/arcsec_star_tracker/common/genericstructs.h"
}
using json = nlohmann::json; using json = nlohmann::json;
/** /**
@ -59,7 +56,7 @@ class ArcsecJsonParamBase {
* parameter set. * parameter set.
* @param buffer Pointer to the buffer the command will be written to * @param buffer Pointer to the buffer the command will be written to
*/ */
ReturnValue_t create(std::string fullname, uint8_t* buffer); ReturnValue_t create(uint8_t* buffer);
/** /**
* @brief Returns the size of the parameter command. * @brief Returns the size of the parameter command.

4
linux/devices/startracker/CMakeLists.txt
View File

@ -1,4 +1,4 @@
target_sources( target_sources(
${OBSW_NAME} ${OBSW_NAME}
PRIVATE StarTrackerHandler.cpp StarTrackerJsonCommands.cpp PRIVATE StarTrackerHandler.cpp strJsonCommands.cpp ArcsecDatalinkLayer.cpp
ArcsecDatalinkLayer.cpp ArcsecJsonParamBase.cpp StrHelper.cpp) ArcsecJsonParamBase.cpp StrComHandler.cpp helpers.cpp)

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

@ -1,5 +1,8 @@
#include "StarTrackerHandler.h" #include "StarTrackerHandler.h"
#include <arcsec/client/generated/actionreq.h>
#include <arcsec/client/generated/parameter.h>
#include <arcsec/client/generated/telemetry.h>
#include <fsfw/ipc/QueueFactory.h> #include <fsfw/ipc/QueueFactory.h>
#include <fsfw/timemanager/Stopwatch.h> #include <fsfw/timemanager/Stopwatch.h>
@ -8,19 +11,14 @@
#include <thread> #include <thread>
#include "OBSWConfig.h" #include "OBSWConfig.h"
#include "StarTrackerJsonCommands.h" #include "arcsec/common/misc.h"
extern "C" { #include "helpers.h"
#include <thirdparty/arcsec_star_tracker/client/generated/actionreq.h> #include "strJsonCommands.h"
#include <thirdparty/arcsec_star_tracker/client/generated/parameter.h>
#include <thirdparty/arcsec_star_tracker/client/generated/telemetry.h>
#include "common/misc.h"
}
std::atomic_bool JCFG_DONE(false); std::atomic_bool JCFG_DONE(false);
StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie, StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
const char* jsonFileStr, StrHelper* strHelper, const char* jsonFileStr, StrComHandler* strHelper,
power::Switch_t powerSwitch) power::Switch_t powerSwitch)
: DeviceHandlerBase(objectId, comIF, comCookie), : DeviceHandlerBase(objectId, comIF, comCookie),
temperatureSet(this), temperatureSet(this),
@ -84,8 +82,8 @@ ReturnValue_t StarTrackerHandler::initialize() {
return result; return result;
} }
result = manager->subscribeToEventRange(eventQueue->getId(), result = manager->subscribeToEventRange(eventQueue->getId(),
event::getEventId(StrHelper::IMAGE_UPLOAD_FAILED), event::getEventId(StrComHandler::IMAGE_UPLOAD_FAILED),
event::getEventId(StrHelper::FIRMWARE_UPDATE_FAILED)); event::getEventId(StrComHandler::FIRMWARE_UPDATE_FAILED));
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "StarTrackerHandler::initialize: Failed to subscribe to events from " sif::warning << "StarTrackerHandler::initialize: Failed to subscribe to events from "
@ -95,11 +93,6 @@ ReturnValue_t StarTrackerHandler::initialize() {
return ObjectManagerIF::CHILD_INIT_FAILED; return ObjectManagerIF::CHILD_INIT_FAILED;
} }
result = strHelper->setComIF(communicationInterface);
if (result != returnvalue::OK) {
return ObjectManagerIF::CHILD_INIT_FAILED;
}
strHelper->setComCookie(comCookie);
return returnvalue::OK; return returnvalue::OK;
} }
@ -828,41 +821,36 @@ ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t* start, size_t rema
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
size_t bytesLeft = 0; size_t bytesLeft = 0;
result = dataLinkLayer.decodeFrame(start, remainingSize, &bytesLeft); if (remainingSize == 0) {
switch (result) { *foundLen = remainingSize;
case ArcsecDatalinkLayer::DEC_IN_PROGRESS: { return returnvalue::OK;
remainingSize = bytesLeft; }
// Need a second doSendRead pass to reaa in whole packet if (remainingSize < 3) {
return IGNORE_REPLY_DATA; sif::error << "StarTrackerHandler: Reply packet with length less than 3 is invalid"
} << std::endl;
case returnvalue::OK: { return returnvalue::FAILED;
break;
}
default:
remainingSize = bytesLeft;
return result;
} }
switch (dataLinkLayer.getReplyFrameType()) { switch (str::getReplyFrameType(start)) {
case TMTC_ACTIONREPLY: { case TMTC_ACTIONREPLY: {
*foundLen = remainingSize - bytesLeft; *foundLen = remainingSize - bytesLeft;
result = scanForActionReply(foundId); result = scanForActionReply(str::getId(start), foundId);
break; break;
} }
case TMTC_SETPARAMREPLY: { case TMTC_SETPARAMREPLY: {
*foundLen = remainingSize - bytesLeft; *foundLen = remainingSize - bytesLeft;
result = scanForSetParameterReply(foundId); result = scanForSetParameterReply(str::getId(start), foundId);
break; break;
} }
case TMTC_PARAMREPLY: { case TMTC_PARAMREPLY: {
*foundLen = remainingSize - bytesLeft; *foundLen = remainingSize - bytesLeft;
result = scanForGetParameterReply(foundId); result = scanForGetParameterReply(str::getId(start), foundId);
break; break;
} }
case TMTC_TELEMETRYREPLYA: case TMTC_TELEMETRYREPLYA:
case TMTC_TELEMETRYREPLY: { case TMTC_TELEMETRYREPLY: {
*foundLen = remainingSize - bytesLeft; *foundLen = remainingSize - bytesLeft;
result = scanForTmReply(foundId); result = scanForTmReply(str::getId(start), foundId);
break; break;
} }
default: { default: {
@ -882,22 +870,22 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
switch (id) { switch (id) {
case (startracker::REQ_TIME): { case (startracker::REQ_TIME): {
result = handleTm(timeSet, startracker::TimeSet::SIZE); result = handleTm(packet, timeSet, startracker::TimeSet::SIZE);
break; break;
} }
case (startracker::PING_REQUEST): { case (startracker::PING_REQUEST): {
result = handlePingReply(); result = handlePingReply(packet);
break; break;
} }
case (startracker::BOOT): case (startracker::BOOT):
case (startracker::TAKE_IMAGE): case (startracker::TAKE_IMAGE):
break; break;
case (startracker::CHECKSUM): { case (startracker::CHECKSUM): {
result = handleChecksumReply(); result = handleChecksumReply(packet);
break; break;
} }
case (startracker::REQ_VERSION): { case (startracker::REQ_VERSION): {
result = handleTm(versionSet, startracker::VersionSet::SIZE); result = handleTm(packet, versionSet, startracker::VersionSet::SIZE);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
@ -908,23 +896,23 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
break; break;
} }
case (startracker::REQ_INTERFACE): { case (startracker::REQ_INTERFACE): {
result = handleTm(interfaceSet, startracker::InterfaceSet::SIZE); result = handleTm(packet, interfaceSet, startracker::InterfaceSet::SIZE);
break; break;
} }
case (startracker::REQ_POWER): { case (startracker::REQ_POWER): {
result = handleTm(powerSet, startracker::PowerSet::SIZE); result = handleTm(packet, powerSet, startracker::PowerSet::SIZE);
break; break;
} }
case (startracker::REQ_SOLUTION): { case (startracker::REQ_SOLUTION): {
result = handleTm(solutionSet, startracker::SolutionSet::SIZE); result = handleTm(packet, solutionSet, startracker::SolutionSet::SIZE);
break; break;
} }
case (startracker::REQ_TEMPERATURE): { case (startracker::REQ_TEMPERATURE): {
result = handleTm(temperatureSet, startracker::TemperatureSet::SIZE); result = handleTm(packet, temperatureSet, startracker::TemperatureSet::SIZE);
break; break;
} }
case (startracker::REQ_HISTOGRAM): { case (startracker::REQ_HISTOGRAM): {
result = handleTm(histogramSet, startracker::HistogramSet::SIZE); result = handleTm(packet, histogramSet, startracker::HistogramSet::SIZE);
break; break;
} }
case (startracker::SUBSCRIPTION): case (startracker::SUBSCRIPTION):
@ -941,63 +929,63 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
case (startracker::VALIDATION): case (startracker::VALIDATION):
case (startracker::IMAGE_PROCESSOR): case (startracker::IMAGE_PROCESSOR):
case (startracker::ALGO): { case (startracker::ALGO): {
result = handleSetParamReply(); result = handleSetParamReply(packet);
break; break;
} }
case (startracker::REQ_CAMERA): { case (startracker::REQ_CAMERA): {
handleParamRequest(cameraSet, startracker::CameraSet::SIZE); handleParamRequest(packet, cameraSet, startracker::CameraSet::SIZE);
break; break;
} }
case (startracker::REQ_LIMITS): { case (startracker::REQ_LIMITS): {
handleParamRequest(limitsSet, startracker::LimitsSet::SIZE); handleParamRequest(packet, limitsSet, startracker::LimitsSet::SIZE);
break; break;
} }
case (startracker::REQ_LOG_LEVEL): { case (startracker::REQ_LOG_LEVEL): {
handleParamRequest(loglevelSet, startracker::LogLevelSet::SIZE); handleParamRequest(packet, loglevelSet, startracker::LogLevelSet::SIZE);
break; break;
} }
case (startracker::REQ_MOUNTING): { case (startracker::REQ_MOUNTING): {
handleParamRequest(mountingSet, startracker::MountingSet::SIZE); handleParamRequest(packet, mountingSet, startracker::MountingSet::SIZE);
break; break;
} }
case (startracker::REQ_IMAGE_PROCESSOR): { case (startracker::REQ_IMAGE_PROCESSOR): {
handleParamRequest(imageProcessorSet, startracker::ImageProcessorSet::SIZE); handleParamRequest(packet, imageProcessorSet, startracker::ImageProcessorSet::SIZE);
break; break;
} }
case (startracker::REQ_CENTROIDING): { case (startracker::REQ_CENTROIDING): {
handleParamRequest(centroidingSet, startracker::CentroidingSet::SIZE); handleParamRequest(packet, centroidingSet, startracker::CentroidingSet::SIZE);
break; break;
} }
case (startracker::REQ_LISA): { case (startracker::REQ_LISA): {
handleParamRequest(lisaSet, startracker::LisaSet::SIZE); handleParamRequest(packet, lisaSet, startracker::LisaSet::SIZE);
break; break;
} }
case (startracker::REQ_MATCHING): { case (startracker::REQ_MATCHING): {
handleParamRequest(matchingSet, startracker::MatchingSet::SIZE); handleParamRequest(packet, matchingSet, startracker::MatchingSet::SIZE);
break; break;
} }
case (startracker::REQ_TRACKING): { case (startracker::REQ_TRACKING): {
handleParamRequest(trackingSet, startracker::TrackingSet::SIZE); handleParamRequest(packet, trackingSet, startracker::TrackingSet::SIZE);
break; break;
} }
case (startracker::REQ_VALIDATION): { case (startracker::REQ_VALIDATION): {
handleParamRequest(validationSet, startracker::ValidationSet::SIZE); handleParamRequest(packet, validationSet, startracker::ValidationSet::SIZE);
break; break;
} }
case (startracker::REQ_ALGO): { case (startracker::REQ_ALGO): {
handleParamRequest(algoSet, startracker::AlgoSet::SIZE); handleParamRequest(packet, algoSet, startracker::AlgoSet::SIZE);
break; break;
} }
case (startracker::REQ_SUBSCRIPTION): { case (startracker::REQ_SUBSCRIPTION): {
handleParamRequest(subscriptionSet, startracker::SubscriptionSet::SIZE); handleParamRequest(packet, subscriptionSet, startracker::SubscriptionSet::SIZE);
break; break;
} }
case (startracker::REQ_LOG_SUBSCRIPTION): { case (startracker::REQ_LOG_SUBSCRIPTION): {
handleParamRequest(logSubscriptionSet, startracker::LogSubscriptionSet::SIZE); handleParamRequest(packet, logSubscriptionSet, startracker::LogSubscriptionSet::SIZE);
break; break;
} }
case (startracker::REQ_DEBUG_CAMERA): { case (startracker::REQ_DEBUG_CAMERA): {
handleParamRequest(debugCameraSet, startracker::DebugCameraSet::SIZE); handleParamRequest(packet, debugCameraSet, startracker::DebugCameraSet::SIZE);
break; break;
} }
default: { default: {
@ -1328,9 +1316,8 @@ ReturnValue_t StarTrackerHandler::checkMode(ActionId_t actionId) {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t* foundId) { ReturnValue_t StarTrackerHandler::scanForActionReply(uint8_t replyId, DeviceCommandId_t* foundId) {
const uint8_t* reply = dataLinkLayer.getReply(); switch (replyId) {
switch (*reply) {
case (startracker::ID::PING): { case (startracker::ID::PING): {
*foundId = startracker::PING_REQUEST; *foundId = startracker::PING_REQUEST;
break; break;
@ -1359,9 +1346,9 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t* foundId)
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::scanForSetParameterReply(DeviceCommandId_t* foundId) { ReturnValue_t StarTrackerHandler::scanForSetParameterReply(uint8_t replyId,
const uint8_t* reply = dataLinkLayer.getReply(); DeviceCommandId_t* foundId) {
switch (*reply) { switch (replyId) {
case (startracker::ID::SUBSCRIPTION): { case (startracker::ID::SUBSCRIPTION): {
*foundId = startracker::SUBSCRIPTION; *foundId = startracker::SUBSCRIPTION;
break; break;
@ -1426,9 +1413,9 @@ ReturnValue_t StarTrackerHandler::scanForSetParameterReply(DeviceCommandId_t* fo
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::scanForGetParameterReply(DeviceCommandId_t* foundId) { ReturnValue_t StarTrackerHandler::scanForGetParameterReply(uint8_t replyId,
const uint8_t* reply = dataLinkLayer.getReply(); DeviceCommandId_t* foundId) {
switch (*reply) { switch (replyId) {
case (startracker::ID::CAMERA): { case (startracker::ID::CAMERA): {
*foundId = startracker::REQ_CAMERA; *foundId = startracker::REQ_CAMERA;
break; break;
@ -1494,9 +1481,8 @@ ReturnValue_t StarTrackerHandler::scanForGetParameterReply(DeviceCommandId_t* fo
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::scanForTmReply(DeviceCommandId_t* foundId) { ReturnValue_t StarTrackerHandler::scanForTmReply(uint8_t replyId, DeviceCommandId_t* foundId) {
const uint8_t* reply = dataLinkLayer.getReply(); switch (replyId) {
switch (*reply) {
case (startracker::ID::VERSION): { case (startracker::ID::VERSION): {
*foundId = startracker::REQ_VERSION; *foundId = startracker::REQ_VERSION;
break; break;
@ -1527,7 +1513,7 @@ ReturnValue_t StarTrackerHandler::scanForTmReply(DeviceCommandId_t* foundId) {
} }
default: { default: {
sif::debug << "StarTrackerHandler::scanForTmReply: Reply contains invalid reply id: " sif::debug << "StarTrackerHandler::scanForTmReply: Reply contains invalid reply id: "
<< static_cast<unsigned int>(*reply) << std::endl; << static_cast<unsigned int>(replyId) << std::endl;
return returnvalue::FAILED; return returnvalue::FAILED;
break; break;
} }
@ -1538,7 +1524,7 @@ ReturnValue_t StarTrackerHandler::scanForTmReply(DeviceCommandId_t* foundId) {
void StarTrackerHandler::handleEvent(EventMessage* eventMessage) { void StarTrackerHandler::handleEvent(EventMessage* eventMessage) {
object_id_t objectId = eventMessage->getReporter(); object_id_t objectId = eventMessage->getReporter();
switch (objectId) { switch (objectId) {
case objects::STR_HELPER: { case objects::STR_COM_IF: {
// All events from image loader signal either that the operation was successful or that it // All events from image loader signal either that the operation was successful or that it
// failed // failed
strHelperHandlingSpecialRequest = false; strHelperHandlingSpecialRequest = false;
@ -1586,9 +1572,8 @@ void StarTrackerHandler::prepareBootCommand() {
uint32_t length = 0; uint32_t length = 0;
struct BootActionRequest bootRequest = {BOOT_REGION_ID}; struct BootActionRequest bootRequest = {BOOT_REGION_ID};
arc_pack_boot_action_req(&bootRequest, commandBuffer, &length); arc_pack_boot_action_req(&bootRequest, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
} }
ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandData, ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandData,
@ -1620,9 +1605,8 @@ ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandD
} }
uint32_t rawCmdLength = 0; uint32_t rawCmdLength = 0;
arc_pack_checksum_action_req(&req, commandBuffer, &rawCmdLength); arc_pack_checksum_action_req(&req, commandBuffer, &rawCmdLength);
dataLinkLayer.encodeFrame(commandBuffer, rawCmdLength); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = rawCmdLength;
rawPacketLen = dataLinkLayer.getEncodedLength();
checksumCmd.rememberRegion = req.region; checksumCmd.rememberRegion = req.region;
checksumCmd.rememberAddress = req.address; checksumCmd.rememberAddress = req.address;
checksumCmd.rememberLength = req.length; checksumCmd.rememberLength = req.length;
@ -1632,51 +1616,45 @@ ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandD
void StarTrackerHandler::prepareTimeRequest() { void StarTrackerHandler::prepareTimeRequest() {
uint32_t length = 0; uint32_t length = 0;
arc_tm_pack_time_req(commandBuffer, &length); arc_tm_pack_time_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
} }
void StarTrackerHandler::preparePingRequest() { void StarTrackerHandler::preparePingRequest() {
uint32_t length = 0; uint32_t length = 0;
struct PingActionRequest pingRequest = {PING_ID}; struct PingActionRequest pingRequest = {PING_ID};
arc_pack_ping_action_req(&pingRequest, commandBuffer, &length); arc_pack_ping_action_req(&pingRequest, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
} }
void StarTrackerHandler::prepareVersionRequest() { void StarTrackerHandler::prepareVersionRequest() {
uint32_t length = 0; uint32_t length = 0;
arc_tm_pack_version_req(commandBuffer, &length); arc_tm_pack_version_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
} }
void StarTrackerHandler::prepareInterfaceRequest() { void StarTrackerHandler::prepareInterfaceRequest() {
uint32_t length = 0; uint32_t length = 0;
arc_tm_pack_interface_req(commandBuffer, &length); arc_tm_pack_interface_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
} }
void StarTrackerHandler::preparePowerRequest() { void StarTrackerHandler::preparePowerRequest() {
uint32_t length = 0; uint32_t length = 0;
arc_tm_pack_power_req(commandBuffer, &length); arc_tm_pack_power_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
} }
void StarTrackerHandler::prepareSwitchToBootloaderCmd() { void StarTrackerHandler::prepareSwitchToBootloaderCmd() {
uint32_t length = 0; uint32_t length = 0;
struct RebootActionRequest rebootReq {}; struct RebootActionRequest rebootReq {};
arc_pack_reboot_action_req(&rebootReq, commandBuffer, &length); arc_pack_reboot_action_req(&rebootReq, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
} }
void StarTrackerHandler::prepareTakeImageCommand(const uint8_t* commandData) { void StarTrackerHandler::prepareTakeImageCommand(const uint8_t* commandData) {
@ -1684,33 +1662,29 @@ void StarTrackerHandler::prepareTakeImageCommand(const uint8_t* commandData) {
struct CameraActionRequest camReq; struct CameraActionRequest camReq;
camReq.actionid = *commandData; camReq.actionid = *commandData;
arc_pack_camera_action_req(&camReq, commandBuffer, &length); arc_pack_camera_action_req(&camReq, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
} }
void StarTrackerHandler::prepareSolutionRequest() { void StarTrackerHandler::prepareSolutionRequest() {
uint32_t length = 0; uint32_t length = 0;
arc_tm_pack_solution_req(commandBuffer, &length); arc_tm_pack_solution_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
} }
void StarTrackerHandler::prepareTemperatureRequest() { void StarTrackerHandler::prepareTemperatureRequest() {
uint32_t length = 0; uint32_t length = 0;
arc_tm_pack_temperature_req(commandBuffer, &length); arc_tm_pack_temperature_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
} }
void StarTrackerHandler::prepareHistogramRequest() { void StarTrackerHandler::prepareHistogramRequest() {
uint32_t length = 0; uint32_t length = 0;
arc_tm_pack_histogram_req(commandBuffer, &length); arc_tm_pack_histogram_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
} }
ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData, ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData,
@ -1721,182 +1695,164 @@ ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData
if (commandDataLen > MAX_PATH_SIZE) { if (commandDataLen > MAX_PATH_SIZE) {
return FILE_PATH_TOO_LONG; return FILE_PATH_TOO_LONG;
} }
std::string fullName(reinterpret_cast<const char*>(commandData), commandDataLen);
result = paramSet.create(fullName, commandBuffer); result = paramSet.create(commandBuffer);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
dataLinkLayer.encodeFrame(commandBuffer, paramSet.getSize()); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = paramSet.getSize();
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestCameraParams() { ReturnValue_t StarTrackerHandler::prepareRequestCameraParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_camera_parameter_req(commandBuffer, &length); arc_pack_camera_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestLimitsParams() { ReturnValue_t StarTrackerHandler::prepareRequestLimitsParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_limits_parameter_req(commandBuffer, &length); arc_pack_limits_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestLogLevelParams() { ReturnValue_t StarTrackerHandler::prepareRequestLogLevelParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_loglevel_parameter_req(commandBuffer, &length); arc_pack_loglevel_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestMountingParams() { ReturnValue_t StarTrackerHandler::prepareRequestMountingParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_mounting_parameter_req(commandBuffer, &length); arc_pack_mounting_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestImageProcessorParams() { ReturnValue_t StarTrackerHandler::prepareRequestImageProcessorParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_imageprocessor_parameter_req(commandBuffer, &length); arc_pack_imageprocessor_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestCentroidingParams() { ReturnValue_t StarTrackerHandler::prepareRequestCentroidingParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_centroiding_parameter_req(commandBuffer, &length); arc_pack_centroiding_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestLisaParams() { ReturnValue_t StarTrackerHandler::prepareRequestLisaParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_lisa_parameter_req(commandBuffer, &length); arc_pack_lisa_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestMatchingParams() { ReturnValue_t StarTrackerHandler::prepareRequestMatchingParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_matching_parameter_req(commandBuffer, &length); arc_pack_matching_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestTrackingParams() { ReturnValue_t StarTrackerHandler::prepareRequestTrackingParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_tracking_parameter_req(commandBuffer, &length); arc_pack_tracking_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestValidationParams() { ReturnValue_t StarTrackerHandler::prepareRequestValidationParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_validation_parameter_req(commandBuffer, &length); arc_pack_validation_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestAlgoParams() { ReturnValue_t StarTrackerHandler::prepareRequestAlgoParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_algo_parameter_req(commandBuffer, &length); arc_pack_algo_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestSubscriptionParams() { ReturnValue_t StarTrackerHandler::prepareRequestSubscriptionParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_subscription_parameter_req(commandBuffer, &length); arc_pack_subscription_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestLogSubscriptionParams() { ReturnValue_t StarTrackerHandler::prepareRequestLogSubscriptionParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_logsubscription_parameter_req(commandBuffer, &length); arc_pack_logsubscription_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::prepareRequestDebugCameraParams() { ReturnValue_t StarTrackerHandler::prepareRequestDebugCameraParams() {
uint32_t length = 0; uint32_t length = 0;
arc_pack_debugcamera_parameter_req(commandBuffer, &length); arc_pack_debugcamera_parameter_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length); rawPacket = commandBuffer;
rawPacket = dataLinkLayer.getEncodedFrame(); rawPacketLen = length;
rawPacketLen = dataLinkLayer.getEncodedLength();
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::handleSetParamReply() { ReturnValue_t StarTrackerHandler::handleSetParamReply(const uint8_t* rawFrame) {
const uint8_t* reply = dataLinkLayer.getReply(); uint8_t status = str::getStatusField(rawFrame);
uint8_t status = *(reply + STATUS_OFFSET);
if (status != startracker::STATUS_OK) { if (status != startracker::STATUS_OK) {
sif::warning << "StarTrackerHandler::handleSetParamReply: Failed to execute parameter set " sif::warning << "StarTrackerHandler::handleSetParamReply: Failed to execute parameter set "
" command with parameter ID" " command with parameter ID"
<< static_cast<unsigned int>(*(reply + PARAMETER_ID_OFFSET)) << std::endl; << static_cast<unsigned int>(*(rawFrame + PARAMETER_ID_OFFSET)) << std::endl;
if (internalState != InternalState::IDLE) { if (internalState != InternalState::IDLE) {
internalState = InternalState::IDLE; internalState = InternalState::IDLE;
} }
return SET_PARAM_FAILED; return SET_PARAM_FAILED;
} }
if (internalState != InternalState::IDLE) { if (internalState != InternalState::IDLE) {
handleStartup(reply + PARAMETER_ID_OFFSET); handleStartup(*(rawFrame + PARAMETER_ID_OFFSET));
} }
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::handleActionReply() { ReturnValue_t StarTrackerHandler::handleActionReply(const uint8_t* rawFrame) {
const uint8_t* reply = dataLinkLayer.getReply(); uint8_t status = str::getStatusField(rawFrame);
uint8_t status = *(reply + STATUS_OFFSET);
if (status != startracker::STATUS_OK) { if (status != startracker::STATUS_OK) {
sif::warning << "StarTrackerHandler::handleActionReply: Failed to execute action " sif::warning << "StarTrackerHandler::handleActionReply: Failed to execute action "
<< "command with action ID " << "command with action ID "
<< static_cast<unsigned int>(*(reply + ACTION_ID_OFFSET)) << " and status " << static_cast<unsigned int>(*(rawFrame + ACTION_ID_OFFSET)) << " and status "
<< static_cast<unsigned int>(status) << std::endl; << static_cast<unsigned int>(status) << std::endl;
return ACTION_FAILED; return ACTION_FAILED;
} }
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::handleChecksumReply() { ReturnValue_t StarTrackerHandler::handleChecksumReply(const uint8_t* rawFrame) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
result = handleActionReply(); result = handleActionReply(rawFrame);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
const uint8_t* replyData = dataLinkLayer.getReply() + ACTION_DATA_OFFSET; const uint8_t* replyData = rawFrame + ACTION_DATA_OFFSET;
startracker::ChecksumReply checksumReply(replyData); startracker::ChecksumReply checksumReply(replyData);
if (checksumReply.getRegion() != checksumCmd.rememberRegion) { if (checksumReply.getRegion() != checksumCmd.rememberRegion) {
sif::warning << "StarTrackerHandler::handleChecksumReply: Region mismatch" << std::endl; sif::warning << "StarTrackerHandler::handleChecksumReply: Region mismatch" << std::endl;
@ -1919,13 +1875,14 @@ ReturnValue_t StarTrackerHandler::handleChecksumReply() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::handleParamRequest(LocalPoolDataSetBase& dataset, size_t size) { ReturnValue_t StarTrackerHandler::handleParamRequest(const uint8_t* rawFrame,
LocalPoolDataSetBase& dataset, size_t size) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
result = dataset.read(TIMEOUT_TYPE, MUTEX_TIMEOUT); result = dataset.read(TIMEOUT_TYPE, MUTEX_TIMEOUT);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
const uint8_t* reply = dataLinkLayer.getReply() + PARAMS_OFFSET; const uint8_t* reply = rawFrame + PARAMS_OFFSET;
dataset.setValidityBufferGeneration(false); dataset.setValidityBufferGeneration(false);
result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE); result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
@ -1943,25 +1900,20 @@ ReturnValue_t StarTrackerHandler::handleParamRequest(LocalPoolDataSetBase& datas
return result; return result;
} }
ReturnValue_t StarTrackerHandler::handlePingReply() { ReturnValue_t StarTrackerHandler::handlePingReply(const uint8_t* rawFrame) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
uint32_t pingId = 0; uint32_t pingId = 0;
const uint8_t* reply = dataLinkLayer.getReply(); uint8_t status = str::getStatusField(rawFrame);
uint8_t status = dataLinkLayer.getStatusField(); const uint8_t* buffer = rawFrame + ACTION_DATA_OFFSET;
const uint8_t* buffer = reply + ACTION_DATA_OFFSET;
size_t size = sizeof(pingId); size_t size = sizeof(pingId);
SerializeAdapter::deSerialize(&pingId, &buffer, &size, SerializeIF::Endianness::LITTLE); SerializeAdapter::deSerialize(&pingId, &buffer, &size, SerializeIF::Endianness::LITTLE);
#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1
sif::info << "StarTracker: Ping status: " << static_cast<unsigned int>(status) << std::endl; sif::info << "StarTracker: Ping status: " << static_cast<unsigned int>(status) << std::endl;
sif::info << "Ping id: 0x" << std::hex << pingId << std::endl; sif::info << "Ping ID: 0x" << std::hex << pingId << std::endl;
#endif /* OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1 */
if (status != startracker::STATUS_OK || pingId != PING_ID) { if (status != startracker::STATUS_OK || pingId != PING_ID) {
sif::warning << "StarTrackerHandler::handlePingReply: Ping failed" << std::endl; sif::warning << "STR: Ping failed" << std::endl;
result = PING_FAILED; result = PING_FAILED;
} else { } else {
#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1 sif::info << "STR: Ping OK" << std::endl;
sif::info << "StarTracker: Ping successful" << std::endl;
#endif
} }
return result; return result;
} }
@ -2001,9 +1953,10 @@ ReturnValue_t StarTrackerHandler::checkProgram() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StarTrackerHandler::handleTm(LocalPoolDataSetBase& dataset, size_t size) { ReturnValue_t StarTrackerHandler::handleTm(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset,
size_t size) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
uint8_t status = *(dataLinkLayer.getReply() + STATUS_OFFSET); uint8_t status = str::getStatusField(rawFrame);
if (status != startracker::STATUS_OK) { if (status != startracker::STATUS_OK) {
sif::warning << "StarTrackerHandler::handleTm: Reply error: " sif::warning << "StarTrackerHandler::handleTm: Reply error: "
<< static_cast<unsigned int>(status) << std::endl; << static_cast<unsigned int>(status) << std::endl;
@ -2013,7 +1966,7 @@ ReturnValue_t StarTrackerHandler::handleTm(LocalPoolDataSetBase& dataset, size_t
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
const uint8_t* reply = dataLinkLayer.getReply() + TICKS_OFFSET; const uint8_t* reply = rawFrame + TICKS_OFFSET;
dataset.setValidityBufferGeneration(false); dataset.setValidityBufferGeneration(false);
result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE); result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
@ -2031,9 +1984,10 @@ ReturnValue_t StarTrackerHandler::handleTm(LocalPoolDataSetBase& dataset, size_t
return result; return result;
} }
ReturnValue_t StarTrackerHandler::handleActionReplySet(LocalPoolDataSetBase& dataset, size_t size) { ReturnValue_t StarTrackerHandler::handleActionReplySet(const uint8_t* rawFrame,
LocalPoolDataSetBase& dataset, size_t size) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
uint8_t status = *(dataLinkLayer.getReply() + STATUS_OFFSET); uint8_t status = str::getStatusField(rawFrame);
if (status != startracker::STATUS_OK) { if (status != startracker::STATUS_OK) {
sif::warning << "StarTrackerHandler::handleActionReplySet: Reply error: " sif::warning << "StarTrackerHandler::handleActionReplySet: Reply error: "
<< static_cast<unsigned int>(status) << std::endl; << static_cast<unsigned int>(status) << std::endl;
@ -2043,7 +1997,7 @@ ReturnValue_t StarTrackerHandler::handleActionReplySet(LocalPoolDataSetBase& dat
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
const uint8_t* reply = dataLinkLayer.getReply() + ACTION_DATA_OFFSET; const uint8_t* reply = rawFrame + ACTION_DATA_OFFSET;
dataset.setValidityBufferGeneration(false); dataset.setValidityBufferGeneration(false);
result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE); result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
@ -2061,8 +2015,8 @@ ReturnValue_t StarTrackerHandler::handleActionReplySet(LocalPoolDataSetBase& dat
return result; return result;
} }
void StarTrackerHandler::handleStartup(const uint8_t* parameterId) { void StarTrackerHandler::handleStartup(uint8_t parameterId) {
switch (*parameterId) { switch (parameterId) {
case (startracker::ID::LOG_LEVEL): { case (startracker::ID::LOG_LEVEL): {
bootState = FwBootState::LIMITS; bootState = FwBootState::LIMITS;
break; break;
@ -2117,8 +2071,8 @@ void StarTrackerHandler::handleStartup(const uint8_t* parameterId) {
break; break;
} }
default: { default: {
sif::debug << "StarTrackerHandler::handleStartup: Received parameter reply with unexpected" sif::warning << "StarTrackerHandler::handleStartup: Received parameter reply with unexpected"
<< " parameter ID" << std::endl; << " parameter ID " << (int)parameterId << std::endl;
break; break;
} }
} }

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

@ -2,20 +2,19 @@
#define MISSION_DEVICES_STARTRACKERHANDLER_H_ #define MISSION_DEVICES_STARTRACKERHANDLER_H_
#include <fsfw/datapool/PoolReadGuard.h> #include <fsfw/datapool/PoolReadGuard.h>
#include <linux/devices/startracker/StarTrackerJsonCommands.h>
#include <thread> #include <thread>
#include "ArcsecDatalinkLayer.h"
#include "ArcsecJsonParamBase.h" #include "ArcsecJsonParamBase.h"
#include "OBSWConfig.h" #include "OBSWConfig.h"
#include "StrHelper.h" #include "StrComHandler.h"
#include "arcsec/common/SLIP.h"
#include "devices/powerSwitcherList.h" #include "devices/powerSwitcherList.h"
#include "fsfw/devicehandlers/DeviceHandlerBase.h" #include "fsfw/devicehandlers/DeviceHandlerBase.h"
#include "fsfw/src/fsfw/serialize/SerializeAdapter.h" #include "fsfw/src/fsfw/serialize/SerializeAdapter.h"
#include "fsfw/timemanager/Countdown.h" #include "fsfw/timemanager/Countdown.h"
#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h" #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
#include "thirdparty/arcsec_star_tracker/common/SLIP.h" #include "strJsonCommands.h"
/** /**
* @brief This is the device handler for the star tracker from arcsec. * @brief This is the device handler for the star tracker from arcsec.
@ -38,7 +37,8 @@ class StarTrackerHandler : public DeviceHandlerBase {
* to high to enable the device. * to high to enable the device.
*/ */
StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie, StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
const char* jsonFileStr, StrHelper* strHelper, power::Switch_t powerSwitch); const char* jsonFileStr, StrComHandler* strHelper,
power::Switch_t powerSwitch);
virtual ~StarTrackerHandler(); virtual ~StarTrackerHandler();
ReturnValue_t initialize() override; ReturnValue_t initialize() override;
@ -147,14 +147,14 @@ class StarTrackerHandler : public DeviceHandlerBase {
static const size_t MAX_PATH_SIZE = 50; static const size_t MAX_PATH_SIZE = 50;
static const size_t MAX_FILE_NAME = 30; static const size_t MAX_FILE_NAME = 30;
static const uint8_t STATUS_OFFSET = 1; static const uint8_t STATUS_OFFSET = 2;
static const uint8_t PARAMS_OFFSET = 1; static const uint8_t PARAMS_OFFSET = 2;
static const uint8_t TICKS_OFFSET = 2; static const uint8_t TICKS_OFFSET = 3;
static const uint8_t TIME_OFFSET = 6; static const uint8_t TIME_OFFSET = 7;
static const uint8_t TM_DATA_FIELD_OFFSET = 14; static const uint8_t PARAMETER_ID_OFFSET = 1;
static const uint8_t PARAMETER_ID_OFFSET = 0; static const uint8_t ACTION_ID_OFFSET = 1;
static const uint8_t ACTION_ID_OFFSET = 0; static const uint8_t ACTION_DATA_OFFSET = 3;
static const uint8_t ACTION_DATA_OFFSET = 2;
// Ping request will reply ping with this ID (data field) // Ping request will reply ping with this ID (data field)
static const uint32_t PING_ID = 0x55; static const uint32_t PING_ID = 0x55;
static const uint32_t BOOT_REGION_ID = 1; static const uint32_t BOOT_REGION_ID = 1;
@ -182,8 +182,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
MessageQueueIF* eventQueue = nullptr; MessageQueueIF* eventQueue = nullptr;
ArcsecDatalinkLayer dataLinkLayer;
startracker::TemperatureSet temperatureSet; startracker::TemperatureSet temperatureSet;
startracker::VersionSet versionSet; startracker::VersionSet versionSet;
startracker::PowerSet powerSet; startracker::PowerSet powerSet;
@ -208,7 +206,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
startracker::DebugCameraSet debugCameraSet; startracker::DebugCameraSet debugCameraSet;
// 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; StrComHandler* strHelper = nullptr;
uint8_t commandBuffer[startracker::MAX_FRAME_SIZE]; uint8_t commandBuffer[startracker::MAX_FRAME_SIZE];
@ -310,10 +308,10 @@ class StarTrackerHandler : public DeviceHandlerBase {
*/ */
void slipInit(); void slipInit();
ReturnValue_t scanForActionReply(DeviceCommandId_t* foundId); ReturnValue_t scanForActionReply(uint8_t replyId, DeviceCommandId_t* foundId);
ReturnValue_t scanForSetParameterReply(DeviceCommandId_t* foundId); ReturnValue_t scanForSetParameterReply(uint8_t replyId, DeviceCommandId_t* foundId);
ReturnValue_t scanForGetParameterReply(DeviceCommandId_t* foundId); ReturnValue_t scanForGetParameterReply(uint8_t replyId, DeviceCommandId_t* foundId);
ReturnValue_t scanForTmReply(DeviceCommandId_t* foundId); ReturnValue_t scanForTmReply(uint8_t replyId, DeviceCommandId_t* foundId);
/** /**
* @brief Fills command buffer with data to ping the star tracker * @brief Fills command buffer with data to ping the star tracker
@ -435,12 +433,13 @@ class StarTrackerHandler : public DeviceHandlerBase {
/** /**
* @brief Handles action replies with datasets. * @brief Handles action replies with datasets.
*/ */
ReturnValue_t handleActionReplySet(LocalPoolDataSetBase& dataset, size_t size); ReturnValue_t handleActionReplySet(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset,
size_t size);
/** /**
* @brief Default function to handle action replies * @brief Default function to handle action replies
*/ */
ReturnValue_t handleActionReply(); ReturnValue_t handleActionReply(const uint8_t* rawFrame);
/** /**
* @brief Handles reply to upload centroid command * @brief Handles reply to upload centroid command
@ -450,16 +449,17 @@ class StarTrackerHandler : public DeviceHandlerBase {
/** /**
* @brief Handles reply to checksum command * @brief Handles reply to checksum command
*/ */
ReturnValue_t handleChecksumReply(); ReturnValue_t handleChecksumReply(const uint8_t* rawFrame);
/** /**
* @brief Handles all set parameter replies * @brief Handles all set parameter replies
*/ */
ReturnValue_t handleSetParamReply(); ReturnValue_t handleSetParamReply(const uint8_t* rawFrame);
ReturnValue_t handlePingReply(); ReturnValue_t handlePingReply(const uint8_t* rawFrame);
ReturnValue_t handleParamRequest(LocalPoolDataSetBase& dataset, size_t size); ReturnValue_t handleParamRequest(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset,
size_t size);
/** /**
* @brief Checks the loaded program by means of the version set * @brief Checks the loaded program by means of the version set
@ -469,7 +469,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
/** /**
* @brief Handles the startup state machine * @brief Handles the startup state machine
*/ */
void handleStartup(const uint8_t* parameterId); void handleStartup(uint8_t parameterId);
/** /**
* @brief Handles telemtry replies and fills the appropriate dataset * @brief Handles telemtry replies and fills the appropriate dataset
@ -479,7 +479,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
* *
* @return returnvalue::OK if successful, otherwise error return value * @return returnvalue::OK if successful, otherwise error return value
*/ */
ReturnValue_t handleTm(LocalPoolDataSetBase& dataset, size_t size); ReturnValue_t handleTm(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset, size_t size);
/** /**
* @brief Checks if star tracker is in valid mode for executing the received command. * @brief Checks if star tracker is in valid mode for executing the received command.

439
linux/devices/startracker/StrHelper.cpp → linux/devices/startracker/StrComHandler.cpp
View File

@ -1,6 +1,9 @@
#include "StrHelper.h" #include <fcntl.h>
#include <fsfw/filesystem/HasFileSystemIF.h> #include <fsfw/filesystem/HasFileSystemIF.h>
#include <fsfw/tasks/TaskFactory.h>
#include <fsfw/timemanager/Stopwatch.h>
#include <linux/devices/startracker/StrComHandler.h>
#include <unistd.h>
#include <filesystem> #include <filesystem>
#include <fstream> #include <fstream>
@ -8,16 +11,22 @@
#include "OBSWConfig.h" #include "OBSWConfig.h"
#include "eive/definitions.h" #include "eive/definitions.h"
#include "fsfw/timemanager/Countdown.h" #include "fsfw/timemanager/Countdown.h"
#include "helpers.h"
#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h" #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
#include "mission/utility/Filenaming.h" #include "mission/utility/Filenaming.h"
#include "mission/utility/ProgressPrinter.h" #include "mission/utility/ProgressPrinter.h"
#include "mission/utility/Timestamp.h" #include "mission/utility/Timestamp.h"
StrHelper::StrHelper(object_id_t objectId) : SystemObject(objectId) {} using namespace returnvalue;
StrHelper::~StrHelper() {} StrComHandler::StrComHandler(object_id_t objectId) : SystemObject(objectId) {
lock = MutexFactory::instance()->createMutex();
semaphore.acquire();
}
ReturnValue_t StrHelper::initialize() { StrComHandler::~StrComHandler() {}
ReturnValue_t StrComHandler::initialize() {
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
sdcMan = SdCardManager::instance(); sdcMan = SdCardManager::instance();
if (sdcMan == nullptr) { if (sdcMan == nullptr) {
@ -28,53 +37,63 @@ ReturnValue_t StrHelper::initialize() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StrHelper::performOperation(uint8_t operationCode) { ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
semaphore.acquire();
while (true) { while (true) {
switch (internalState) { lock->lockMutex();
case InternalState::IDLE: { state = InternalState::SLEEPING;
semaphore.acquire(); datalinkLayer.reset();
lock->unlockMutex();
semaphore.acquire();
switch (state) {
case InternalState::POLL_ONE_REPLY: {
// Stopwatch watch;
replyTimeout.setTimeout(200);
replyResult = readOneReply(static_cast<uint32_t>(state));
{
MutexGuard mg(lock);
replyWasReceived = true;
}
break; break;
} }
case InternalState::UPLOAD_IMAGE: { case InternalState::UPLOAD_IMAGE: {
replyTimeout.setTimeout(200);
result = performImageUpload(); result = performImageUpload();
if (result == returnvalue::OK) { if (result == returnvalue::OK) {
triggerEvent(IMAGE_UPLOAD_SUCCESSFUL); triggerEvent(IMAGE_UPLOAD_SUCCESSFUL);
} else { } else {
triggerEvent(IMAGE_UPLOAD_FAILED); triggerEvent(IMAGE_UPLOAD_FAILED);
} }
internalState = InternalState::IDLE;
break; break;
} }
case InternalState::DOWNLOAD_IMAGE: { case InternalState::DOWNLOAD_IMAGE: {
replyTimeout.setTimeout(200);
result = performImageDownload(); result = performImageDownload();
if (result == returnvalue::OK) { if (result == returnvalue::OK) {
triggerEvent(IMAGE_DOWNLOAD_SUCCESSFUL); triggerEvent(IMAGE_DOWNLOAD_SUCCESSFUL);
} else { } else {
triggerEvent(IMAGE_DOWNLOAD_FAILED); triggerEvent(IMAGE_DOWNLOAD_FAILED);
} }
internalState = InternalState::IDLE;
break; break;
} }
case InternalState::FLASH_READ: { case InternalState::FLASH_READ: {
replyTimeout.setTimeout(200);
result = performFlashRead(); result = performFlashRead();
if (result == returnvalue::OK) { if (result == returnvalue::OK) {
triggerEvent(FLASH_READ_SUCCESSFUL); triggerEvent(FLASH_READ_SUCCESSFUL);
} else { } else {
triggerEvent(FLASH_READ_FAILED); triggerEvent(FLASH_READ_FAILED);
} }
internalState = InternalState::IDLE;
break; break;
} }
case InternalState::FIRMWARE_UPDATE: { case InternalState::FIRMWARE_UPDATE: {
replyTimeout.setTimeout(200);
result = performFirmwareUpdate(); result = performFirmwareUpdate();
if (result == returnvalue::OK) { if (result == returnvalue::OK) {
triggerEvent(FIRMWARE_UPDATE_SUCCESSFUL); triggerEvent(FIRMWARE_UPDATE_SUCCESSFUL);
} else { } else {
triggerEvent(FIRMWARE_UPDATE_FAILED); triggerEvent(FIRMWARE_UPDATE_FAILED);
} }
internalState = InternalState::IDLE;
break; break;
} }
default: default:
@ -84,18 +103,13 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) {
} }
} }
ReturnValue_t StrHelper::setComIF(DeviceCommunicationIF* communicationInterface_) { ReturnValue_t StrComHandler::startImageUpload(std::string fullname) {
uartComIF = dynamic_cast<SerialComIF*>(communicationInterface_); {
if (uartComIF == nullptr) { MutexGuard mg(lock);
sif::warning << "StrHelper::initialize: Invalid uart com if" << std::endl; if (state != InternalState::SLEEPING) {
return returnvalue::FAILED; return BUSY;
}
} }
return returnvalue::OK;
}
void StrHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
ReturnValue_t StrHelper::startImageUpload(std::string fullname) {
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
ReturnValue_t result = checkPath(fullname); ReturnValue_t result = checkPath(fullname);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
@ -106,13 +120,22 @@ ReturnValue_t StrHelper::startImageUpload(std::string fullname) {
if (not std::filesystem::exists(fullname)) { if (not std::filesystem::exists(fullname)) {
return FILE_NOT_EXISTS; return FILE_NOT_EXISTS;
} }
internalState = InternalState::UPLOAD_IMAGE; {
MutexGuard mg(lock);
state = InternalState::UPLOAD_IMAGE;
}
semaphore.release(); semaphore.release();
terminate = false; terminate = false;
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StrHelper::startImageDownload(std::string path) { ReturnValue_t StrComHandler::startImageDownload(std::string path) {
{
MutexGuard mg(lock);
if (state != InternalState::SLEEPING) {
return BUSY;
}
}
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
ReturnValue_t result = checkPath(path); ReturnValue_t result = checkPath(path);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
@ -123,19 +146,32 @@ ReturnValue_t StrHelper::startImageDownload(std::string path) {
return PATH_NOT_EXISTS; return PATH_NOT_EXISTS;
} }
downloadImage.path = path; downloadImage.path = path;
internalState = InternalState::DOWNLOAD_IMAGE; {
MutexGuard mg(lock);
state = InternalState::DOWNLOAD_IMAGE;
}
terminate = false; terminate = false;
semaphore.release(); semaphore.release();
return returnvalue::OK; return returnvalue::OK;
} }
void StrHelper::stopProcess() { terminate = true; } void StrComHandler::stopProcess() {
terminate = true;
}
void StrHelper::setDownloadImageName(std::string filename) { downloadImage.filename = filename; } void StrComHandler::setDownloadImageName(std::string filename) {
downloadImage.filename = filename;
}
void StrHelper::setFlashReadFilename(std::string filename) { flashRead.filename = filename; } void StrComHandler::setFlashReadFilename(std::string filename) { flashRead.filename = filename; }
ReturnValue_t StrHelper::startFirmwareUpdate(std::string fullname) { ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
{
MutexGuard mg(lock);
if (state != InternalState::SLEEPING) {
return BUSY;
}
}
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
ReturnValue_t result = checkPath(fullname); ReturnValue_t result = checkPath(fullname);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
@ -148,13 +184,23 @@ ReturnValue_t StrHelper::startFirmwareUpdate(std::string fullname) {
} }
flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST); flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST);
flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST); flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST);
internalState = InternalState::FIRMWARE_UPDATE; {
MutexGuard mg(lock);
state = InternalState::FIRMWARE_UPDATE;
}
semaphore.release(); semaphore.release();
terminate = false; terminate = false;
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StrHelper::startFlashRead(std::string path, uint8_t startRegion, uint32_t length) { ReturnValue_t StrComHandler::startFlashRead(std::string path, uint8_t startRegion,
uint32_t length) {
{
MutexGuard mg(lock);
if (state != InternalState::SLEEPING) {
return BUSY;
}
}
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
ReturnValue_t result = checkPath(path); ReturnValue_t result = checkPath(path);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
@ -167,17 +213,20 @@ ReturnValue_t StrHelper::startFlashRead(std::string path, uint8_t startRegion, u
} }
flashRead.startRegion = startRegion; flashRead.startRegion = startRegion;
flashRead.size = length; flashRead.size = length;
internalState = InternalState::FLASH_READ; {
MutexGuard mg(lock);
state = InternalState::FLASH_READ;
}
semaphore.release(); semaphore.release();
terminate = false; terminate = false;
return returnvalue::OK; return returnvalue::OK;
} }
void StrHelper::disableTimestamping() { timestamping = false; } void StrComHandler::disableTimestamping() { timestamping = false; }
void StrHelper::enableTimestamping() { timestamping = true; } void StrComHandler::enableTimestamping() { timestamping = true; }
ReturnValue_t StrHelper::performImageDownload() { ReturnValue_t StrComHandler::performImageDownload() {
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
if (not sdcMan->getActiveSdCard()) { if (not sdcMan->getActiveSdCard()) {
return HasFileSystemIF::FILESYSTEM_INACTIVE; return HasFileSystemIF::FILESYSTEM_INACTIVE;
@ -190,6 +239,7 @@ ReturnValue_t StrHelper::performImageDownload() {
struct DownloadActionRequest downloadReq; struct DownloadActionRequest downloadReq;
uint32_t size = 0; uint32_t size = 0;
uint32_t retries = 0; uint32_t retries = 0;
size_t replySize = 0;
std::string image = Filenaming::generateAbsoluteFilename(downloadImage.path, std::string image = Filenaming::generateAbsoluteFilename(downloadImage.path,
downloadImage.filename, timestamping); downloadImage.filename, timestamping);
std::ofstream file(image, std::ios_base::out); std::ofstream file(image, std::ios_base::out);
@ -202,21 +252,21 @@ ReturnValue_t StrHelper::performImageDownload() {
file.close(); file.close();
return returnvalue::OK; return returnvalue::OK;
} }
arc_pack_download_action_req(&downloadReq, commandBuffer, &size); arc_pack_download_action_req(&downloadReq, cmdBuf.data(), &size);
result = sendAndRead(size, downloadReq.position); result = sendAndRead(size, downloadReq.position);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
uartComIF->flushUartRxBuffer(comCookie); serial::flushRxBuf(serialPort);
retries++; retries++;
continue; continue;
} }
file.close(); file.close();
return result; return result;
} }
result = checkActionReply(); result = checkActionReply(replySize);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
uartComIF->flushUartRxBuffer(comCookie); serial::flushRxBuf(serialPort);
retries++; retries++;
continue; continue;
} }
@ -226,15 +276,14 @@ ReturnValue_t StrHelper::performImageDownload() {
result = checkReplyPosition(downloadReq.position); result = checkReplyPosition(downloadReq.position);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
uartComIF->flushUartRxBuffer(comCookie); serial::flushRxBuf(serialPort);
retries++; retries++;
continue; continue;
} }
file.close(); file.close();
return result; return result;
} }
file.write(reinterpret_cast<const char*>(datalinkLayer.getReply() + IMAGE_DATA_OFFSET), file.write(reinterpret_cast<const char*>(replyPtr + IMAGE_DATA_OFFSET), CHUNK_SIZE);
CHUNK_SIZE);
#if OBSW_DEBUG_STARTRACKER == 1 #if OBSW_DEBUG_STARTRACKER == 1
progressPrinter.print(downloadReq.position); progressPrinter.print(downloadReq.position);
#endif /* OBSW_DEBUG_STARTRACKER == 1 */ #endif /* OBSW_DEBUG_STARTRACKER == 1 */
@ -245,7 +294,7 @@ ReturnValue_t StrHelper::performImageDownload() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StrHelper::performImageUpload() { ReturnValue_t StrComHandler::performImageUpload() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
uint32_t size = 0; uint32_t size = 0;
uint32_t imageSize = 0; uint32_t imageSize = 0;
@ -258,8 +307,7 @@ ReturnValue_t StrHelper::performImageUpload() {
#endif #endif
std::memset(&uploadReq.data, 0, sizeof(uploadReq.data)); std::memset(&uploadReq.data, 0, sizeof(uploadReq.data));
if (not std::filesystem::exists(uploadImage.uploadFile)) { if (not std::filesystem::exists(uploadImage.uploadFile)) {
triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(internalState)); triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(state));
internalState = InternalState::IDLE;
return returnvalue::FAILED; return returnvalue::FAILED;
} }
std::ifstream file(uploadImage.uploadFile, std::ifstream::binary); std::ifstream file(uploadImage.uploadFile, std::ifstream::binary);
@ -276,26 +324,29 @@ ReturnValue_t StrHelper::performImageUpload() {
#endif /* OBSW_DEBUG_STARTRACKER == 1 */ #endif /* OBSW_DEBUG_STARTRACKER == 1 */
while ((uploadReq.position + 1) * SIZE_IMAGE_PART < imageSize) { while ((uploadReq.position + 1) * SIZE_IMAGE_PART < imageSize) {
if (terminate) { if (terminate) {
file.close();
return returnvalue::OK; return returnvalue::OK;
} }
file.seekg(uploadReq.position * SIZE_IMAGE_PART, file.beg); file.seekg(uploadReq.position * SIZE_IMAGE_PART, file.beg);
file.read(reinterpret_cast<char*>(uploadReq.data), SIZE_IMAGE_PART); file.read(reinterpret_cast<char*>(uploadReq.data), SIZE_IMAGE_PART);
arc_pack_upload_action_req(&uploadReq, commandBuffer, &size); arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
result = sendAndRead(size, uploadReq.position); result = sendAndRead(size, uploadReq.position);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
file.close();
return returnvalue::FAILED; return returnvalue::FAILED;
} }
result = checkActionReply(); result = checkActionReply(replyLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
file.close();
return result; return result;
} }
#if OBSW_DEBUG_STARTRACKER == 1 #if OBSW_DEBUG_STARTRACKER == 1
progressPrinter.print((uploadReq.position + 1) * SIZE_IMAGE_PART); progressPrinter.print((uploadReq.position + 1) * SIZE_IMAGE_PART);
#endif /* OBSW_DEBUG_STARTRACKER == 1 */ #endif /* OBSW_DEBUG_STARTRACKER == 1 */
uploadReq.position++; uploadReq.position++;
// This does a bit of delaying roughly every second
if (uploadReq.position % 50 == 0) {
// Some grace time for other tasks
TaskFactory::delayTask(2);
}
} }
std::memset(uploadReq.data, 0, sizeof(uploadReq.data)); std::memset(uploadReq.data, 0, sizeof(uploadReq.data));
uint32_t remainder = imageSize - uploadReq.position * SIZE_IMAGE_PART; uint32_t remainder = imageSize - uploadReq.position * SIZE_IMAGE_PART;
@ -303,12 +354,12 @@ ReturnValue_t StrHelper::performImageUpload() {
file.read(reinterpret_cast<char*>(uploadReq.data), remainder); file.read(reinterpret_cast<char*>(uploadReq.data), remainder);
file.close(); file.close();
uploadReq.position++; uploadReq.position++;
arc_pack_upload_action_req(&uploadReq, commandBuffer, &size); arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
result = sendAndRead(size, uploadReq.position); result = sendAndRead(size, uploadReq.position);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return returnvalue::FAILED; return returnvalue::FAILED;
} }
result = checkActionReply(); result = checkActionReply(replyLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
@ -318,7 +369,7 @@ ReturnValue_t StrHelper::performImageUpload() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StrHelper::performFirmwareUpdate() { ReturnValue_t StrComHandler::performFirmwareUpdate() {
using namespace startracker; using namespace startracker;
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
result = unlockAndEraseRegions(static_cast<uint32_t>(startracker::FirmwareRegions::FIRST), result = unlockAndEraseRegions(static_cast<uint32_t>(startracker::FirmwareRegions::FIRST),
@ -330,7 +381,7 @@ ReturnValue_t StrHelper::performFirmwareUpdate() {
return result; return result;
} }
ReturnValue_t StrHelper::performFlashWrite() { ReturnValue_t StrComHandler::performFlashWrite() {
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
if (not sdcMan->getActiveSdCard()) { if (not sdcMan->getActiveSdCard()) {
return HasFileSystemIF::FILESYSTEM_INACTIVE; return HasFileSystemIF::FILESYSTEM_INACTIVE;
@ -340,13 +391,16 @@ ReturnValue_t StrHelper::performFlashWrite() {
uint32_t size = 0; uint32_t size = 0;
uint32_t bytesWritten = 0; uint32_t bytesWritten = 0;
uint32_t fileSize = 0; uint32_t fileSize = 0;
struct WriteActionRequest req; struct WriteActionRequest req;
if (not std::filesystem::exists(flashWrite.fullname)) { if (not std::filesystem::exists(flashWrite.fullname)) {
triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(internalState)); triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(state));
internalState = InternalState::IDLE;
return returnvalue::FAILED; return returnvalue::FAILED;
} }
std::ifstream file(flashWrite.fullname, std::ifstream::binary); std::ifstream file(flashWrite.fullname, std::ifstream::binary);
if (file.bad()) {
return returnvalue::FAILED;
}
file.seekg(0, file.end); file.seekg(0, file.end);
fileSize = file.tellg(); fileSize = file.tellg();
if (fileSize > FLASH_REGION_SIZE * (flashWrite.lastRegion - flashWrite.firstRegion)) { if (fileSize > FLASH_REGION_SIZE * (flashWrite.lastRegion - flashWrite.firstRegion)) {
@ -362,7 +416,6 @@ ReturnValue_t StrHelper::performFlashWrite() {
req.length = CHUNK_SIZE; req.length = CHUNK_SIZE;
for (uint32_t idx = 0; idx < fileChunks; idx++) { for (uint32_t idx = 0; idx < fileChunks; idx++) {
if (terminate) { if (terminate) {
file.close();
return returnvalue::OK; return returnvalue::OK;
} }
file.seekg(idx * CHUNK_SIZE, file.beg); file.seekg(idx * CHUNK_SIZE, file.beg);
@ -372,21 +425,23 @@ ReturnValue_t StrHelper::performFlashWrite() {
bytesWritten = 0; bytesWritten = 0;
} }
req.address = bytesWritten; req.address = bytesWritten;
arc_pack_write_action_req(&req, commandBuffer, &size); arc_pack_write_action_req(&req, cmdBuf.data(), &size);
result = sendAndRead(size, req.address); result = sendAndRead(size, req.address);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
file.close();
return result; return result;
} }
result = checkActionReply(); result = checkActionReply(replyLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
file.close();
return result; return result;
} }
bytesWritten += CHUNK_SIZE; bytesWritten += CHUNK_SIZE;
#if OBSW_DEBUG_STARTRACKER == 1 #if OBSW_DEBUG_STARTRACKER == 1
progressPrinter.print(idx * CHUNK_SIZE); progressPrinter.print(idx * CHUNK_SIZE);
#endif /* OBSW_DEBUG_STARTRACKER == 1 */ #endif /* OBSW_DEBUG_STARTRACKER == 1 */
if (idx % 50 == 0) {
// Some grace time for other tasks
TaskFactory::delayTask(2);
}
} }
uint32_t remainingBytes = fileSize - fileChunks * CHUNK_SIZE; uint32_t remainingBytes = fileSize - fileChunks * CHUNK_SIZE;
file.seekg((fileChunks - 1) * CHUNK_SIZE, file.beg); file.seekg((fileChunks - 1) * CHUNK_SIZE, file.beg);
@ -399,12 +454,12 @@ ReturnValue_t StrHelper::performFlashWrite() {
req.address = bytesWritten; req.address = bytesWritten;
req.length = remainingBytes; req.length = remainingBytes;
bytesWritten += remainingBytes; bytesWritten += remainingBytes;
arc_pack_write_action_req(&req, commandBuffer, &size); arc_pack_write_action_req(&req, cmdBuf.data(), &size);
result = sendAndRead(size, req.address); result = sendAndRead(size, req.address);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
result = checkActionReply(); result = checkActionReply(replyLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
@ -414,7 +469,7 @@ ReturnValue_t StrHelper::performFlashWrite() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StrHelper::performFlashRead() { ReturnValue_t StrComHandler::performFlashRead() {
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
if (not sdcMan->getActiveSdCard()) { if (not sdcMan->getActiveSdCard()) {
return HasFileSystemIF::FILESYSTEM_INACTIVE; return HasFileSystemIF::FILESYSTEM_INACTIVE;
@ -446,29 +501,28 @@ ReturnValue_t StrHelper::performFlashRead() {
} else { } else {
req.length = CHUNK_SIZE; req.length = CHUNK_SIZE;
} }
arc_pack_read_action_req(&req, commandBuffer, &size); arc_pack_read_action_req(&req, cmdBuf.data(), &size);
result = sendAndRead(size, req.address); result = sendAndRead(size, req.address);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
uartComIF->flushUartRxBuffer(comCookie); serial::flushRxBuf(serialPort);
retries++; retries++;
continue; continue;
} }
file.close(); file.close();
return result; return result;
} }
result = checkActionReply(); result = checkActionReply(replyLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
uartComIF->flushUartRxBuffer(comCookie); serial::flushRxBuf(serialPort);
retries++; retries++;
continue; continue;
} }
file.close(); file.close();
return result; return result;
} }
file.write(reinterpret_cast<const char*>(datalinkLayer.getReply() + FLASH_READ_DATA_OFFSET), file.write(reinterpret_cast<const char*>(replyPtr + FLASH_READ_DATA_OFFSET), req.length);
req.length);
bytesRead += req.length; bytesRead += req.length;
req.address += req.length; req.address += req.length;
if (req.address >= FLASH_REGION_SIZE) { if (req.address >= FLASH_REGION_SIZE) {
@ -484,70 +538,29 @@ ReturnValue_t StrHelper::performFlashRead() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StrHelper::sendAndRead(size_t size, uint32_t parameter, uint32_t delayMs) { ReturnValue_t StrComHandler::sendAndRead(size_t size, uint32_t failParameter) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
ReturnValue_t decResult = returnvalue::OK;
size_t receivedDataLen = 0; const uint8_t* sendData;
uint8_t* receivedData = nullptr; size_t txFrameLen = 0;
size_t bytesLeft = 0; datalinkLayer.encodeFrame(cmdBuf.data(), size, &sendData, txFrameLen);
uint32_t missedReplies = 0; int writeResult = write(serialPort, sendData, txFrameLen);
datalinkLayer.encodeFrame(commandBuffer, size); if (writeResult < 0) {
result = uartComIF->sendMessage(comCookie, datalinkLayer.getEncodedFrame(),
datalinkLayer.getEncodedLength());
if (result != returnvalue::OK) {
sif::warning << "StrHelper::sendAndRead: Failed to send packet" << std::endl; sif::warning << "StrHelper::sendAndRead: Failed to send packet" << std::endl;
triggerEvent(STR_HELPER_SENDING_PACKET_FAILED, result, parameter); triggerEvent(STR_HELPER_SENDING_PACKET_FAILED, result, failParameter);
return returnvalue::FAILED; return returnvalue::FAILED;
} }
decResult = ArcsecDatalinkLayer::DEC_IN_PROGRESS;
while (decResult == ArcsecDatalinkLayer::DEC_IN_PROGRESS) { return readOneReply(failParameter);
Countdown delay(delayMs);
delay.resetTimer();
while (delay.isBusy()) {
}
result = uartComIF->requestReceiveMessage(comCookie, startracker::MAX_FRAME_SIZE * 2 + 2);
if (result != returnvalue::OK) {
sif::warning << "StrHelper::sendAndRead: Failed to request reply" << std::endl;
triggerEvent(STR_HELPER_REQUESTING_MSG_FAILED, result, parameter);
return returnvalue::FAILED;
}
result = uartComIF->readReceivedMessage(comCookie, &receivedData, &receivedDataLen);
if (result != returnvalue::OK) {
sif::warning << "StrHelper::sendAndRead: Failed to read received message" << std::endl;
triggerEvent(STR_HELPER_READING_REPLY_FAILED, result, parameter);
return returnvalue::FAILED;
}
if (receivedDataLen == 0 && missedReplies < MAX_POLLS) {
missedReplies++;
continue;
} else if ((receivedDataLen == 0) && (missedReplies >= MAX_POLLS)) {
triggerEvent(STR_HELPER_NO_REPLY, parameter);
return returnvalue::FAILED;
} else {
missedReplies = 0;
}
decResult = datalinkLayer.decodeFrame(receivedData, receivedDataLen, &bytesLeft);
if (bytesLeft != 0) {
// This should never happen
sif::warning << "StrHelper::sendAndRead: Bytes left after decoding" << std::endl;
triggerEvent(STR_HELPER_COM_ERROR, result, parameter);
return returnvalue::FAILED;
}
}
if (decResult != returnvalue::OK) {
triggerEvent(STR_HELPER_DEC_ERROR, decResult, parameter);
return returnvalue::FAILED;
}
return returnvalue::OK;
} }
ReturnValue_t StrHelper::checkActionReply() { ReturnValue_t StrComHandler::checkActionReply(size_t replySize) {
uint8_t type = datalinkLayer.getReplyFrameType(); uint8_t type = str::getReplyFrameType(replyPtr);
if (type != TMTC_ACTIONREPLY) { if (type != TMTC_ACTIONREPLY) {
sif::warning << "StrHelper::checkActionReply: Received reply with invalid type ID" << std::endl; sif::warning << "StrHelper::checkActionReply: Received reply with invalid type ID" << std::endl;
return INVALID_TYPE_ID; return INVALID_TYPE_ID;
} }
uint8_t status = datalinkLayer.getStatusField(); uint8_t status = str::getStatusField(replyPtr);
if (status != ArcsecDatalinkLayer::STATUS_OK) { if (status != ArcsecDatalinkLayer::STATUS_OK) {
sif::warning << "StrHelper::checkActionReply: Status failure: " sif::warning << "StrHelper::checkActionReply: Status failure: "
<< static_cast<unsigned int>(status) << std::endl; << static_cast<unsigned int>(status) << std::endl;
@ -556,9 +569,9 @@ ReturnValue_t StrHelper::checkActionReply() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t StrHelper::checkReplyPosition(uint32_t expectedPosition) { ReturnValue_t StrComHandler::checkReplyPosition(uint32_t expectedPosition) {
uint32_t receivedPosition = 0; uint32_t receivedPosition = 0;
std::memcpy(&receivedPosition, datalinkLayer.getReply() + POS_OFFSET, sizeof(receivedPosition)); std::memcpy(&receivedPosition, replyPtr + POS_OFFSET, sizeof(receivedPosition));
if (receivedPosition != expectedPosition) { if (receivedPosition != expectedPosition) {
triggerEvent(POSITION_MISMATCH, receivedPosition); triggerEvent(POSITION_MISMATCH, receivedPosition);
return returnvalue::FAILED; return returnvalue::FAILED;
@ -567,7 +580,7 @@ ReturnValue_t StrHelper::checkReplyPosition(uint32_t expectedPosition) {
} }
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
ReturnValue_t StrHelper::checkPath(std::string name) { ReturnValue_t StrComHandler::checkPath(std::string name) {
if (name.substr(0, sizeof(config::SD_0_MOUNT_POINT)) == std::string(config::SD_0_MOUNT_POINT)) { if (name.substr(0, sizeof(config::SD_0_MOUNT_POINT)) == std::string(config::SD_0_MOUNT_POINT)) {
if (!sdcMan->isSdCardUsable(sd::SLOT_0)) { if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
sif::warning << "StrHelper::checkPath: SD card 0 not mounted" << std::endl; sif::warning << "StrHelper::checkPath: SD card 0 not mounted" << std::endl;
@ -584,7 +597,113 @@ ReturnValue_t StrHelper::checkPath(std::string name) {
} }
#endif #endif
ReturnValue_t StrHelper::unlockAndEraseRegions(uint32_t from, uint32_t to) { ReturnValue_t StrComHandler::initializeInterface(CookieIF* cookie) {
if (cookie == nullptr) {
return returnvalue::FAILED;
}
SerialCookie* serCookie = dynamic_cast<SerialCookie*>(cookie);
if (serCookie == nullptr) {
return DeviceCommunicationIF::INVALID_COOKIE_TYPE;
}
// comCookie = serCookie;
std::string devname = serCookie->getDeviceFile();
/* Get file descriptor */
serialPort = open(devname.c_str(), O_RDWR);
if (serialPort < 0) {
sif::warning << "StrComHandler: open call failed with error [" << errno << ", "
<< strerror(errno) << std::endl;
return returnvalue::FAILED;
}
// Setting up UART parameters
tty.c_cflag &= ~PARENB; // Clear parity bit
serial::setStopbits(tty, serCookie->getStopBits());
serial::setBitsPerWord(tty, BitsPerWord::BITS_8);
tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
serial::enableRead(tty);
serial::ignoreCtrlLines(tty);
// Use non-canonical mode and clear echo flag
tty.c_lflag &= ~(ICANON | ECHO);
// Non-blocking mode, use polling
tty.c_cc[VTIME] = 0;
tty.c_cc[VMIN] = 0;
serial::setBaudrate(tty, serCookie->getBaudrate());
if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
sif::warning << "ScexUartReader::initializeInterface: tcsetattr call failed with error ["
<< errno << ", " << strerror(errno) << std::endl;
}
// Flush received and unread data
tcflush(serialPort, TCIOFLUSH);
return returnvalue::OK;
}
ReturnValue_t StrComHandler::sendMessage(CookieIF* cookie, const uint8_t* sendData,
size_t sendLen) {
{
MutexGuard mg(lock);
if (state != InternalState::SLEEPING) {
return BUSY;
}
}
serial::flushRxBuf(serialPort);
const uint8_t* txFrame;
size_t frameLen;
datalinkLayer.encodeFrame(sendData, sendLen, &txFrame, frameLen);
size_t bytesWritten = write(serialPort, txFrame, frameLen);
if (bytesWritten != frameLen) {
sif::warning << "ScexUartReader::sendMessage: Sending ping command to solar experiment failed"
<< std::endl;
return returnvalue::FAILED;
}
// Hacky, but the alternatives look bleak. The raw data contains the information we need
// and there are not too many special cases.
if (sendData[0] == TMTC_ACTIONREQ) {
// 1 is a firmware boot request and 7 is a reboot request. For both, no reply is expected.
if (sendData[1] == 7 or sendData[1] == 1) {
return returnvalue::OK;
}
}
{
MutexGuard mg(lock);
state = InternalState::POLL_ONE_REPLY;
}
// Unlock task to perform reply reading.
semaphore.release();
return returnvalue::OK;
}
ReturnValue_t StrComHandler::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
ReturnValue_t StrComHandler::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
return returnvalue::OK;
}
ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
// Consider it a configuration error if the task is not done with a command -> reply cycle
// in time.
bool replyWasReceived = false;
{
MutexGuard mg(lock);
if (state != InternalState::SLEEPING) {
return BUSY;
}
replyWasReceived = this->replyWasReceived;
}
if (not replyWasReceived) {
*size = 0;
return returnvalue::OK;
}
if (replyResult == returnvalue::OK) {
*buffer = const_cast<uint8_t*>(replyPtr);
*size = replyLen;
}
return replyResult;
}
ReturnValue_t StrComHandler::unlockAndEraseRegions(uint32_t from, uint32_t to) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
#if OBSW_DEBUG_STARTRACKER == 1 #if OBSW_DEBUG_STARTRACKER == 1
ProgressPrinter progressPrinter("Unlock and erase", to - from); ProgressPrinter progressPrinter("Unlock and erase", to - from);
@ -595,17 +714,20 @@ ReturnValue_t StrHelper::unlockAndEraseRegions(uint32_t from, uint32_t to) {
for (uint32_t idx = from; idx <= to; idx++) { for (uint32_t idx = from; idx <= to; idx++) {
unlockReq.region = idx; unlockReq.region = idx;
unlockReq.code = startracker::region_secrets::secret[idx]; unlockReq.code = startracker::region_secrets::secret[idx];
arc_pack_unlock_action_req(&unlockReq, commandBuffer, &size); arc_pack_unlock_action_req(&unlockReq, cmdBuf.data(), &size);
sendAndRead(size, unlockReq.region); result = sendAndRead(size, unlockReq.region);
result = checkActionReply(); if (result != returnvalue::OK) {
return result;
}
result = checkActionReply(replyLen);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sif::warning << "StrHelper::unlockAndEraseRegions: Failed to unlock region with id " sif::warning << "StrHelper::unlockAndEraseRegions: Failed to unlock region with id "
<< static_cast<unsigned int>(unlockReq.region) << std::endl; << static_cast<unsigned int>(unlockReq.region) << std::endl;
return result; return result;
} }
eraseReq.region = idx; eraseReq.region = idx;
arc_pack_erase_action_req(&eraseReq, commandBuffer, &size); arc_pack_erase_action_req(&eraseReq, cmdBuf.data(), &size);
result = sendAndRead(size, eraseReq.region, FLASH_ERASE_DELAY); result = sendAndRead(size, eraseReq.region);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sif::warning << "StrHelper::unlockAndEraseRegions: Failed to erase region with id " sif::warning << "StrHelper::unlockAndEraseRegions: Failed to erase region with id "
<< static_cast<unsigned int>(eraseReq.region) << std::endl; << static_cast<unsigned int>(eraseReq.region) << std::endl;
@ -617,3 +739,48 @@ ReturnValue_t StrHelper::unlockAndEraseRegions(uint32_t from, uint32_t to) {
} }
return result; return result;
} }
ReturnValue_t StrComHandler::handleSerialReception() {
ssize_t bytesRead = read(serialPort, reinterpret_cast<void*>(recBuf.data()),
static_cast<unsigned int>(recBuf.size()));
if (bytesRead == 0) {
return NO_SERIAL_DATA_READ;
} else if (bytesRead < 0) {
sif::warning << "PlocSupvHelper::performOperation: read call failed with error [" << errno
<< ", " << strerror(errno) << "]" << std::endl;
return FAILED;
} else if (bytesRead >= static_cast<int>(recBuf.size())) {
sif::error << "PlocSupvHelper::performOperation: Receive buffer too small for " << bytesRead
<< " bytes" << std::endl;
return FAILED;
} else if (bytesRead > 0) {
// sif::info << "Received " << bytesRead << " bytes from the STR" << std::endl;
// arrayprinter::print(recBuf.data(), bytesRead);
datalinkLayer.feedData(recBuf.data(), bytesRead);
}
return OK;
}
ReturnValue_t StrComHandler::readOneReply(uint32_t failParameter) {
ReturnValue_t result;
uint32_t nextDelayMs = 1;
replyTimeout.resetTimer();
while (true) {
handleSerialReception();
result = datalinkLayer.checkRingBufForFrame(&replyPtr, replyLen);
if (result == returnvalue::OK) {
return returnvalue::OK;
} else if (result != ArcsecDatalinkLayer::DEC_IN_PROGRESS) {
triggerEvent(STR_HELPER_DEC_ERROR, result, failParameter);
return DECODING_ERROR;
}
if (replyTimeout.hasTimedOut()) {
triggerEvent(STR_COM_REPLY_TIMEOUT, failParameter, replyTimeout.getTimeoutMs());
return RECEPTION_TIMEOUT;
}
TaskFactory::delayTask(nextDelayMs);
if (nextDelayMs < 32) {
nextDelayMs *= 2;
}
}
}

155
linux/devices/startracker/StrHelper.h → linux/devices/startracker/StrComHandler.h
View File

@ -10,6 +10,8 @@
#include "bsp_q7s/fs/SdCardManager.h" #include "bsp_q7s/fs/SdCardManager.h"
#endif #endif
#include "arcsec/client/generated/actionreq.h"
#include "arcsec/common/generated/tmtcstructs.h"
#include "fsfw/devicehandlers/CookieIF.h" #include "fsfw/devicehandlers/CookieIF.h"
#include "fsfw/objectmanager/SystemObject.h" #include "fsfw/objectmanager/SystemObject.h"
#include "fsfw/osal/linux/BinarySemaphore.h" #include "fsfw/osal/linux/BinarySemaphore.h"
@ -17,18 +19,37 @@
#include "fsfw/tasks/ExecutableObjectIF.h" #include "fsfw/tasks/ExecutableObjectIF.h"
#include "fsfw_hal/linux/serial/SerialComIF.h" #include "fsfw_hal/linux/serial/SerialComIF.h"
extern "C" {
#include "thirdparty/arcsec_star_tracker/client/generated/actionreq.h"
#include "thirdparty/arcsec_star_tracker/common/generated/tmtcstructs.h"
}
/** /**
* @brief Helper class for the star tracker handler to accelerate large data transfers. * @brief Helper class for the star tracker handler to accelerate large data transfers.
* *
* @author J. Meier * @author J. Meier
*/ */
class StrHelper : public SystemObject, public ExecutableObjectIF { class StrComHandler : public SystemObject, public DeviceCommunicationIF, public ExecutableObjectIF {
public: public:
static const uint8_t INTERFACE_ID = CLASS_ID::STR_HELPER;
static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0);
//! [EXPORT] : [COMMENT] SD card specified in path string not mounted
static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(1);
//! [EXPORT] : [COMMENT] Specified file does not exist on filesystem
static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(2);
//! [EXPORT] : [COMMENT] Specified path does not exist
static const ReturnValue_t PATH_NOT_EXISTS = MAKE_RETURN_CODE(3);
//! [EXPORT] : [COMMENT] Failed to create download image or read flash file
static const ReturnValue_t FILE_CREATION_FAILED = MAKE_RETURN_CODE(4);
//! [EXPORT] : [COMMENT] Region in flash write/read reply does not match expected region
static const ReturnValue_t REGION_MISMATCH = MAKE_RETURN_CODE(5);
//! [EXPORT] : [COMMENT] Address in flash write/read reply does not match expected address
static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(6);
//! [EXPORT] : [COMMENT] Length in flash write/read reply does not match expected length
static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(7);
//! [EXPORT] : [COMMENT] Status field in reply signals error
static const ReturnValue_t STATUS_ERROR = MAKE_RETURN_CODE(8);
//! [EXPORT] : [COMMENT] Reply has invalid type ID (should be of action reply type)
static const ReturnValue_t INVALID_TYPE_ID = MAKE_RETURN_CODE(9);
static const ReturnValue_t RECEPTION_TIMEOUT = MAKE_RETURN_CODE(10);
static const ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(11);
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_HELPER; static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_HELPER;
//! [EXPORT] : [COMMENT] Image upload failed //! [EXPORT] : [COMMENT] Image upload failed
@ -57,39 +78,36 @@ class StrHelper : public SystemObject, public ExecutableObjectIF {
//! P1: Return code of failed communication interface read call //! P1: Return code of failed communication interface read call
//! P1: Upload/download position for which the read call failed //! P1: Upload/download position for which the read call failed
static const Event STR_HELPER_COM_ERROR = MAKE_EVENT(10, severity::LOW); static const Event STR_HELPER_COM_ERROR = MAKE_EVENT(10, severity::LOW);
//! [EXPORT] : [COMMENT] Star tracker did not send replies (maybe device is powered off) //! [EXPORT] : [COMMENT] Star tracker did not send a valid reply for a certain timeout.
//! P1: Position of upload or download packet for which no reply was sent //! P1: Position of upload or download packet for which the packet wa sent. P2: Timeout
static const Event STR_HELPER_NO_REPLY = MAKE_EVENT(11, severity::LOW); static const Event STR_COM_REPLY_TIMEOUT = MAKE_EVENT(11, severity::LOW);
//! [EXPORT] : [COMMENT] Error during decoding of received reply occurred //! [EXPORT] : [COMMENT] Error during decoding of received reply occurred
// P1: Return value of decoding function //! P1: Return value of decoding function
// P2: Position of upload/download packet, or address of flash write/read request //! P2: Position of upload/download packet, or address of flash write/read request
static const Event STR_HELPER_DEC_ERROR = MAKE_EVENT(12, severity::LOW); static const Event STR_HELPER_DEC_ERROR = MAKE_EVENT(13, severity::LOW);
//! [EXPORT] : [COMMENT] Position mismatch //! [EXPORT] : [COMMENT] Position mismatch
//! P1: The expected position and thus the position for which the image upload/download failed //! P1: The expected position and thus the position for which the image upload/download failed
static const Event POSITION_MISMATCH = MAKE_EVENT(13, severity::LOW); static const Event POSITION_MISMATCH = MAKE_EVENT(14, severity::LOW);
//! [EXPORT] : [COMMENT] Specified file does not exist //! [EXPORT] : [COMMENT] Specified file does not exist
//! P1: Internal state of str helper //! P1: Internal state of str helper
static const Event STR_HELPER_FILE_NOT_EXISTS = MAKE_EVENT(14, severity::LOW); static const Event STR_HELPER_FILE_NOT_EXISTS = MAKE_EVENT(15, severity::LOW);
//! [EXPORT] : [COMMENT] Sending packet to star tracker failed //! [EXPORT] : [COMMENT] Sending packet to star tracker failed
//! P1: Return code of communication interface sendMessage function //! P1: Return code of communication interface sendMessage function
//! P2: Position of upload/download packet, or address of flash write/read request for which //! P2: Position of upload/download packet, or address of flash write/read request for which
//! sending failed //! sending failed
static const Event STR_HELPER_SENDING_PACKET_FAILED = MAKE_EVENT(15, severity::LOW); static const Event STR_HELPER_SENDING_PACKET_FAILED = MAKE_EVENT(16, severity::LOW);
//! [EXPORT] : [COMMENT] Communication interface requesting reply failed //! [EXPORT] : [COMMENT] Communication interface requesting reply failed
//! P1: Return code of failed request //! P1: Return code of failed request
//! P1: Upload/download position, or address of flash write/read request for which transmission //! P1: Upload/download position, or address of flash write/read request for which transmission
//! failed //! failed
static const Event STR_HELPER_REQUESTING_MSG_FAILED = MAKE_EVENT(16, severity::LOW); static const Event STR_HELPER_REQUESTING_MSG_FAILED = MAKE_EVENT(17, severity::LOW);
StrHelper(object_id_t objectId); StrComHandler(object_id_t objectId);
virtual ~StrHelper(); virtual ~StrComHandler();
ReturnValue_t initialize() override; ReturnValue_t initialize() override;
ReturnValue_t performOperation(uint8_t operationCode = 0) override; ReturnValue_t performOperation(uint8_t operationCode = 0) override;
ReturnValue_t setComIF(DeviceCommunicationIF* communicationInterface_);
void setComCookie(CookieIF* comCookie_);
/** /**
* @brief Starts sequence to upload image to star tracker * @brief Starts sequence to upload image to star tracker
* *
@ -148,26 +166,8 @@ class StrHelper : public SystemObject, public ExecutableObjectIF {
void enableTimestamping(); void enableTimestamping();
private: private:
static const uint8_t INTERFACE_ID = CLASS_ID::STR_HELPER; //! [EXPORT] : [SKIP]
static constexpr ReturnValue_t NO_SERIAL_DATA_READ = MAKE_RETURN_CODE(128);
//! [EXPORT] : [COMMENT] SD card specified in path string not mounted
static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(0xA0);
//! [EXPORT] : [COMMENT] Specified file does not exist on filesystem
static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xA1);
//! [EXPORT] : [COMMENT] Specified path does not exist
static const ReturnValue_t PATH_NOT_EXISTS = MAKE_RETURN_CODE(0xA2);
//! [EXPORT] : [COMMENT] Failed to create download image or read flash file
static const ReturnValue_t FILE_CREATION_FAILED = MAKE_RETURN_CODE(0xA3);
//! [EXPORT] : [COMMENT] Region in flash write/read reply does not match expected region
static const ReturnValue_t REGION_MISMATCH = MAKE_RETURN_CODE(0xA4);
//! [EXPORT] : [COMMENT] Address in flash write/read reply does not match expected address
static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(0xA5);
//! [EXPORT] : [COMMENT] Length in flash write/read reply does not match expected length
static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(0xA6);
//! [EXPORT] : [COMMENT] Status field in reply signals error
static const ReturnValue_t STATUS_ERROR = MAKE_RETURN_CODE(0xA7);
//! [EXPORT] : [COMMENT] Reply has invalid type ID (should be of action reply type)
static const ReturnValue_t INVALID_TYPE_ID = MAKE_RETURN_CODE(0xA8);
// Size of one image part which can be sent per action request // Size of one image part which can be sent per action request
static const size_t SIZE_IMAGE_PART = 1024; static const size_t SIZE_IMAGE_PART = 1024;
@ -179,25 +179,34 @@ class StrHelper : public SystemObject, public ExecutableObjectIF {
static const uint32_t MAX_POLLS = 10000; static const uint32_t MAX_POLLS = 10000;
static const uint8_t ACTION_DATA_OFFSET = 2; static const uint8_t ACTION_DATA_OFFSET = 3;
static const uint8_t POS_OFFSET = 2; static const uint8_t POS_OFFSET = 3;
static const uint8_t IMAGE_DATA_OFFSET = 5; static const uint8_t IMAGE_DATA_OFFSET = 6;
static const uint8_t FLASH_READ_DATA_OFFSET = 8; static const uint8_t FLASH_READ_DATA_OFFSET = 9;
static const uint8_t REGION_OFFSET = 2; static const uint8_t REGION_OFFSET = 3;
static const uint8_t ADDRESS_OFFSET = 3; static const uint8_t ADDRESS_OFFSET = 4;
static const uint8_t LENGTH_OFFSET = 7;
static const size_t CHUNK_SIZE = 1024; static const size_t CHUNK_SIZE = 1024;
static const size_t CONFIG_MAX_DOWNLOAD_RETRIES = 3; static const size_t CONFIG_MAX_DOWNLOAD_RETRIES = 3;
static const uint32_t FLASH_ERASE_DELAY = 500; static const uint32_t FLASH_ERASE_DELAY = 500;
enum class InternalState { IDLE, UPLOAD_IMAGE, DOWNLOAD_IMAGE, FLASH_READ, FIRMWARE_UPDATE }; enum class InternalState {
SLEEPING,
POLL_ONE_REPLY,
UPLOAD_IMAGE,
DOWNLOAD_IMAGE,
FLASH_READ,
FIRMWARE_UPDATE
};
InternalState internalState = InternalState::IDLE; InternalState state = InternalState::SLEEPING;
ArcsecDatalinkLayer datalinkLayer; ArcsecDatalinkLayer datalinkLayer;
MutexIF *lock;
BinarySemaphore semaphore; BinarySemaphore semaphore;
Countdown replyTimeout = Countdown(20);
struct UploadImage { struct UploadImage {
// Name including absolute path of image to upload // Name including absolute path of image to upload
std::string uploadFile; std::string uploadFile;
@ -238,10 +247,16 @@ class StrHelper : public SystemObject, public ExecutableObjectIF {
FlashRead flashRead; FlashRead flashRead;
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
SdCardManager* sdcMan = nullptr; SdCardManager *sdcMan = nullptr;
#endif #endif
uint8_t commandBuffer[startracker::MAX_FRAME_SIZE]; std::array<uint8_t, startracker::MAX_FRAME_SIZE> cmdBuf{};
std::array<uint8_t, 4096> recBuf{};
bool replyWasReceived = false;
const uint8_t *replyPtr = nullptr;
size_t replyLen = 0;
ReturnValue_t replyResult = returnvalue::OK;
bool terminate = false; bool terminate = false;
@ -251,17 +266,20 @@ class StrHelper : public SystemObject, public ExecutableObjectIF {
bool timestamping = true; bool timestamping = true;
#endif #endif
/** int serialPort = 0;
* UART communication object responsible for low level access of star tracker struct termios tty = {};
* Must be set by star tracker handler
*/
SerialComIF* uartComIF = nullptr;
// Communication cookie. Must be set by the star tracker handler
CookieIF* comCookie = nullptr;
// Queue id of raw data receiver // Queue id of raw data receiver
MessageQueueId_t rawDataReceiver = MessageQueueIF::NO_QUEUE; MessageQueueId_t rawDataReceiver = MessageQueueIF::NO_QUEUE;
ReturnValue_t initializeInterface(CookieIF *cookie) override;
ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) override;
ReturnValue_t getSendSuccess(CookieIF *cookie) override;
ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) override;
ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) override;
ReturnValue_t handleSerialReception();
/** /**
* @brief Performs image uploading * @brief Performs image uploading
*/ */
@ -302,21 +320,23 @@ class StrHelper : public SystemObject, public ExecutableObjectIF {
/** /**
* @brief Sends packet to the star tracker and reads reply by using the communication * @brief Sends packet to the star tracker and reads reply by using the communication
* interface * interface
* * @details
* The reply frame is stored in the data link layer helper. A pointer to the start of the frame
* is assigned to the @replyPtr member of this class. The frame length will be assigned to
* the @replyLen member.
* @param size Size of data beforehand written to the commandBuffer * @param size Size of data beforehand written to the commandBuffer
* @param parameter Parameter 2 of trigger event function * @param parameter Parameter 2 of trigger event function
* @param delayMs Delay in milliseconds between send and receive call
* *
* @return returnvalue::OK if successful, otherwise returnvalue::FAILED * @return returnvalue::OK if successful, otherwise returnvalue::FAILED
*/ */
ReturnValue_t sendAndRead(size_t size, uint32_t parameter, uint32_t delayMs = 0); ReturnValue_t sendAndRead(size_t size, uint32_t parameter);
/** /**
* @brief Checks the header (type id and status fields) of the action reply * @brief Checks the header (type id and status fields) of the action reply
* *
* @return returnvalue::OK if reply confirms success of packet transfer, otherwise REUTRN_FAILED * @return returnvalue::OK if reply confirms success of packet transfer, otherwise REUTRN_FAILED
*/ */
ReturnValue_t checkActionReply(); ReturnValue_t checkActionReply(size_t replySize);
/** /**
* @brief Checks the position field in a star tracker upload/download reply. * @brief Checks the position field in a star tracker upload/download reply.
@ -345,6 +365,15 @@ class StrHelper : public SystemObject, public ExecutableObjectIF {
* *
*/ */
ReturnValue_t unlockAndEraseRegions(uint32_t from, uint32_t to); ReturnValue_t unlockAndEraseRegions(uint32_t from, uint32_t to);
/**
* The reply frame is stored in the data link layer helper. A pointer to the start of the frame
* is assigned to the @replyPtr member of this class. The frame length will be assigned to
* the @replyLen member.
* @param failParameter
* @return
*/
ReturnValue_t readOneReply(uint32_t failParameter);
}; };
#endif /* BSP_Q7S_DEVICES_STRHELPER_H_ */ #endif /* BSP_Q7S_DEVICES_STRHELPER_H_ */

0
linux/devices/startracker/ArcsecJsonKeys.h → linux/devices/startracker/arcsecJsonKeys.h
View File

7
linux/devices/startracker/helpers.cpp Normal file
View File

@ -0,0 +1,7 @@
#include "helpers.h"
uint8_t str::getReplyFrameType(const uint8_t* rawFrame) { return rawFrame[0]; }
uint8_t str::getId(const uint8_t* rawFrame) { return rawFrame[1]; }
uint8_t str::getStatusField(const uint8_t* rawFrame) { return rawFrame[2]; }

17
linux/devices/startracker/helpers.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef LINUX_DEVICES_STARTRACKER_HELPERS_H_
#define LINUX_DEVICES_STARTRACKER_HELPERS_H_
#include "arcsec/common/genericstructs.h"
namespace str {
/**
* @brief Returns the frame type field of a decoded frame.
*/
uint8_t getReplyFrameType(const uint8_t* rawFrame);
uint8_t getId(const uint8_t* rawFrame);
uint8_t getStatusField(const uint8_t* rawFrame);
} // namespace str
#endif /* LINUX_DEVICES_STARTRACKER_HELPERS_H_ */

4
linux/devices/startracker/StarTrackerJsonCommands.cpp → linux/devices/startracker/strJsonCommands.cpp
View File

@ -1,6 +1,6 @@
#include "StarTrackerJsonCommands.h" #include "strJsonCommands.h"
#include "ArcsecJsonKeys.h" #include "arcsecJsonKeys.h"
Limits::Limits() : ArcsecJsonParamBase(arcseckeys::LIMITS) {} Limits::Limits() : ArcsecJsonParamBase(arcseckeys::LIMITS) {}

0
linux/devices/startracker/StarTrackerJsonCommands.h → linux/devices/startracker/strJsonCommands.h
View File

16
linux/fsfwconfig/events/translateEvents.cpp
View File

@ -1,7 +1,7 @@
/** /**
* @brief Auto-generated event translation file. Contains 279 translations. * @brief Auto-generated event translation file. Contains 279 translations.
* @details * @details
* Generated on: 2023-03-21 23:59:36 * Generated on: 2023-03-22 01:14:08
*/ */
#include "translateEvents.h" #include "translateEvents.h"
@ -172,7 +172,7 @@ const char *FIRMWARE_UPDATE_SUCCESSFUL_STRING = "FIRMWARE_UPDATE_SUCCESSFUL";
const char *FIRMWARE_UPDATE_FAILED_STRING = "FIRMWARE_UPDATE_FAILED"; const char *FIRMWARE_UPDATE_FAILED_STRING = "FIRMWARE_UPDATE_FAILED";
const char *STR_HELPER_READING_REPLY_FAILED_STRING = "STR_HELPER_READING_REPLY_FAILED"; const char *STR_HELPER_READING_REPLY_FAILED_STRING = "STR_HELPER_READING_REPLY_FAILED";
const char *STR_HELPER_COM_ERROR_STRING = "STR_HELPER_COM_ERROR"; const char *STR_HELPER_COM_ERROR_STRING = "STR_HELPER_COM_ERROR";
const char *STR_HELPER_NO_REPLY_STRING = "STR_HELPER_NO_REPLY"; const char *STR_HELPER_REPLY_TIMEOUT_STRING = "STR_HELPER_REPLY_TIMEOUT";
const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR"; const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR";
const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH"; const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH";
const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS"; const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS";
@ -617,16 +617,16 @@ const char *translateEvents(Event event) {
case (12510): case (12510):
return STR_HELPER_COM_ERROR_STRING; return STR_HELPER_COM_ERROR_STRING;
case (12511): case (12511):
return STR_HELPER_NO_REPLY_STRING; return STR_HELPER_REPLY_TIMEOUT_STRING;
case (12512):
return STR_HELPER_DEC_ERROR_STRING;
case (12513): case (12513):
return POSITION_MISMATCH_STRING; return STR_HELPER_DEC_ERROR_STRING;
case (12514): case (12514):
return STR_HELPER_FILE_NOT_EXISTS_STRING; return POSITION_MISMATCH_STRING;
case (12515): case (12515):
return STR_HELPER_SENDING_PACKET_FAILED_STRING; return STR_HELPER_FILE_NOT_EXISTS_STRING;
case (12516): case (12516):
return STR_HELPER_SENDING_PACKET_FAILED_STRING;
case (12517):
return STR_HELPER_REQUESTING_MSG_FAILED_STRING; return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
case (12600): case (12600):
return MPSOC_FLASH_WRITE_FAILED_STRING; return MPSOC_FLASH_WRITE_FAILED_STRING;

6
linux/fsfwconfig/objects/translateObjects.cpp
View File

@ -2,7 +2,7 @@
* @brief Auto-generated object translation file. * @brief Auto-generated object translation file.
* @details * @details
* Contains 173 translations. * Contains 173 translations.
* Generated on: 2023-03-21 23:59:36 * Generated on: 2023-03-22 01:14:08
*/ */
#include "translateObjects.h" #include "translateObjects.h"
@ -49,7 +49,7 @@ const char *PLPCDU_HANDLER_STRING = "PLPCDU_HANDLER";
const char *RAD_SENSOR_STRING = "RAD_SENSOR"; const char *RAD_SENSOR_STRING = "RAD_SENSOR";
const char *PLOC_UPDATER_STRING = "PLOC_UPDATER"; const char *PLOC_UPDATER_STRING = "PLOC_UPDATER";
const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER"; const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER";
const char *STR_HELPER_STRING = "STR_HELPER"; const char *STR_COM_IF_STRING = "STR_COM_IF";
const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER"; const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER";
const char *AXI_PTME_CONFIG_STRING = "AXI_PTME_CONFIG"; const char *AXI_PTME_CONFIG_STRING = "AXI_PTME_CONFIG";
const char *PTME_CONFIG_STRING = "PTME_CONFIG"; const char *PTME_CONFIG_STRING = "PTME_CONFIG";
@ -269,7 +269,7 @@ const char *translateObject(object_id_t object) {
case 0x44330001: case 0x44330001:
return PLOC_MEMORY_DUMPER_STRING; return PLOC_MEMORY_DUMPER_STRING;
case 0x44330002: case 0x44330002:
return STR_HELPER_STRING; return STR_COM_IF_STRING;
case 0x44330003: case 0x44330003:
return PLOC_MPSOC_HELPER_STRING; return PLOC_MPSOC_HELPER_STRING;
case 0x44330004: case 0x44330004:

39
mission/controller/ThermalController.cpp
View File

@ -605,7 +605,6 @@ void ThermalController::copySus() {
} }
void ThermalController::copyDevices() { void ThermalController::copyDevices() {
lp_var_t<float> tempQ7s = lp_var_t<float>(objects::CORE_CONTROLLER, core::PoolIds::TEMPERATURE);
{ {
PoolReadGuard pg(&tempQ7s, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempQ7s, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() == returnvalue::OK) { if (pg.getReadResult() == returnvalue::OK) {
@ -618,8 +617,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<int16_t> battTemp1 =
lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_1);
PoolReadGuard pg(&battTemp1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&battTemp1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read battery temperature 1" << std::endl; sif::warning << "ThermalController: Failed to read battery temperature 1" << std::endl;
@ -632,8 +629,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<int16_t> battTemp2 =
lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_2);
PoolReadGuard pg(&battTemp2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&battTemp2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read battery temperature 2" << std::endl; sif::warning << "ThermalController: Failed to read battery temperature 2" << std::endl;
@ -646,8 +641,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<int16_t> battTemp3 =
lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_3);
PoolReadGuard pg(&battTemp3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&battTemp3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read battery temperature 3" << std::endl; sif::warning << "ThermalController: Failed to read battery temperature 3" << std::endl;
@ -660,8 +653,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<int16_t> battTemp4 =
lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_4);
PoolReadGuard pg(&battTemp4, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&battTemp4, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read battery temperature 4" << std::endl; sif::warning << "ThermalController: Failed to read battery temperature 4" << std::endl;
@ -674,7 +665,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<int32_t> tempRw1 = lp_var_t<int32_t>(objects::RW1, rws::TEMPERATURE_C);
PoolReadGuard pg(&tempRw1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempRw1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read reaction wheel 1 temperature" << std::endl; sif::warning << "ThermalController: Failed to read reaction wheel 1 temperature" << std::endl;
@ -687,7 +677,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<int32_t> tempRw2 = lp_var_t<int32_t>(objects::RW2, rws::TEMPERATURE_C);
PoolReadGuard pg(&tempRw2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempRw2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read reaction wheel 2 temperature" << std::endl; sif::warning << "ThermalController: Failed to read reaction wheel 2 temperature" << std::endl;
@ -700,7 +689,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<int32_t> tempRw3 = lp_var_t<int32_t>(objects::RW3, rws::TEMPERATURE_C);
PoolReadGuard pg(&tempRw3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempRw3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read reaction wheel 3 temperature" << std::endl; sif::warning << "ThermalController: Failed to read reaction wheel 3 temperature" << std::endl;
@ -713,7 +701,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<int32_t> tempRw4 = lp_var_t<int32_t>(objects::RW4, rws::TEMPERATURE_C);
PoolReadGuard pg(&tempRw4, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempRw4, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read reaction wheel 4 temperature" << std::endl; sif::warning << "ThermalController: Failed to read reaction wheel 4 temperature" << std::endl;
@ -726,8 +713,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempStartracker =
lp_var_t<float>(objects::STAR_TRACKER, startracker::MCU_TEMPERATURE);
PoolReadGuard pg(&tempStartracker, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempStartracker, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read startracker temperature" << std::endl; sif::warning << "ThermalController: Failed to read startracker temperature" << std::endl;
@ -740,8 +725,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempSyrlinksPowerAmplifier =
lp_var_t<float>(objects::SYRLINKS_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER);
PoolReadGuard pg(&tempSyrlinksPowerAmplifier, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempSyrlinksPowerAmplifier, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read syrlinks power amplifier temperature" sif::warning << "ThermalController: Failed to read syrlinks power amplifier temperature"
@ -755,8 +738,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempSyrlinksBasebandBoard =
lp_var_t<float>(objects::SYRLINKS_HANDLER, syrlinks::TEMP_BASEBAND_BOARD);
PoolReadGuard pg(&tempSyrlinksBasebandBoard, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempSyrlinksBasebandBoard, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read syrlinks baseband board temperature" sif::warning << "ThermalController: Failed to read syrlinks baseband board temperature"
@ -770,7 +751,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<int16_t> tempMgt = lp_var_t<int16_t>(objects::IMTQ_HANDLER, imtq::MCU_TEMPERATURE);
PoolReadGuard pg(&tempMgt, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempMgt, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read MGT temperature" << std::endl; sif::warning << "ThermalController: Failed to read MGT temperature" << std::endl;
@ -783,8 +763,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_vec_t<float, 3> tempAcu =
lp_vec_t<float, 3>(objects::ACU_HANDLER, ACU::pool::ACU_TEMPERATURES);
PoolReadGuard pg(&tempAcu, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempAcu, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read ACU temperatures" << std::endl; sif::warning << "ThermalController: Failed to read ACU temperatures" << std::endl;
@ -799,7 +777,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempPdu1 = lp_var_t<float>(objects::PDU1_HANDLER, PDU::pool::PDU_TEMPERATURE);
PoolReadGuard pg(&tempPdu1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempPdu1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read PDU1 temperature" << std::endl; sif::warning << "ThermalController: Failed to read PDU1 temperature" << std::endl;
@ -812,7 +789,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempPdu2 = lp_var_t<float>(objects::PDU2_HANDLER, PDU::pool::PDU_TEMPERATURE);
PoolReadGuard pg(&tempPdu2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempPdu2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read PDU2 temperature" << std::endl; sif::warning << "ThermalController: Failed to read PDU2 temperature" << std::endl;
@ -825,8 +801,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> temp1P60dock =
lp_var_t<float>(objects::P60DOCK_HANDLER, P60Dock::pool::P60DOCK_TEMPERATURE_1);
PoolReadGuard pg(&temp1P60dock, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&temp1P60dock, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read P60 dock temperature 1" << std::endl; sif::warning << "ThermalController: Failed to read P60 dock temperature 1" << std::endl;
@ -839,8 +813,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> temp2P60dock =
lp_var_t<float>(objects::P60DOCK_HANDLER, P60Dock::pool::P60DOCK_TEMPERATURE_2);
PoolReadGuard pg(&temp2P60dock, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&temp2P60dock, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read P60 dock temperature 2" << std::endl; sif::warning << "ThermalController: Failed to read P60 dock temperature 2" << std::endl;
@ -853,8 +825,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempGyro0 =
lp_var_t<float>(objects::GYRO_0_ADIS_HANDLER, adis1650x::TEMPERATURE);
PoolReadGuard pg(&tempGyro0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempGyro0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read gyro 0 temperature" << std::endl; sif::warning << "ThermalController: Failed to read gyro 0 temperature" << std::endl;
@ -867,7 +837,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempGyro1 = lp_var_t<float>(objects::GYRO_1_L3G_HANDLER, l3gd20h::TEMPERATURE);
PoolReadGuard pg(&tempGyro1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempGyro1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read gyro 1 temperature" << std::endl; sif::warning << "ThermalController: Failed to read gyro 1 temperature" << std::endl;
@ -880,8 +849,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempGyro2 =
lp_var_t<float>(objects::GYRO_2_ADIS_HANDLER, adis1650x::TEMPERATURE);
PoolReadGuard pg(&tempGyro2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempGyro2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read gyro 2 temperature" << std::endl; sif::warning << "ThermalController: Failed to read gyro 2 temperature" << std::endl;
@ -894,7 +861,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempGyro3 = lp_var_t<float>(objects::GYRO_3_L3G_HANDLER, l3gd20h::TEMPERATURE);
PoolReadGuard pg(&tempGyro3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempGyro3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read gyro 3 temperature" << std::endl; sif::warning << "ThermalController: Failed to read gyro 3 temperature" << std::endl;
@ -907,8 +873,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempMgm0 =
lp_var_t<float>(objects::MGM_0_LIS3_HANDLER, mgmLis3::TEMPERATURE_CELCIUS);
PoolReadGuard pg(&tempMgm0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempMgm0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read MGM 0 temperature" << std::endl; sif::warning << "ThermalController: Failed to read MGM 0 temperature" << std::endl;
@ -921,8 +885,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempMgm2 =
lp_var_t<float>(objects::MGM_2_LIS3_HANDLER, mgmLis3::TEMPERATURE_CELCIUS);
PoolReadGuard pg(&tempMgm2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempMgm2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read MGM 2 temperature" << std::endl; sif::warning << "ThermalController: Failed to read MGM 2 temperature" << std::endl;
@ -935,7 +897,6 @@ void ThermalController::copyDevices() {
} }
{ {
lp_var_t<float> tempAdcPayloadPcdu = lp_var_t<float>(objects::PLPCDU_HANDLER, plpcdu::TEMP);
PoolReadGuard pg(&tempAdcPayloadPcdu, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT); PoolReadGuard pg(&tempAdcPayloadPcdu, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
if (pg.getReadResult() != returnvalue::OK) { if (pg.getReadResult() != returnvalue::OK) {
sif::warning << "ThermalController: Failed to read payload PCDU ADC temperature" << std::endl; sif::warning << "ThermalController: Failed to read payload PCDU ADC temperature" << std::endl;

48
mission/controller/ThermalController.h
View File

@ -1,12 +1,22 @@
#ifndef MISSION_CONTROLLER_THERMALCONTROLLER_H_ #ifndef MISSION_CONTROLLER_THERMALCONTROLLER_H_
#define MISSION_CONTROLLER_THERMALCONTROLLER_H_ #define MISSION_CONTROLLER_THERMALCONTROLLER_H_
#include <bsp_q7s/core/CoreDefinitions.h>
#include <fsfw/controller/ExtendedControllerBase.h> #include <fsfw/controller/ExtendedControllerBase.h>
#include <fsfw/devicehandlers/DeviceHandlerThermalSet.h> #include <fsfw/devicehandlers/DeviceHandlerThermalSet.h>
#include <fsfw/timemanager/Countdown.h> #include <fsfw/timemanager/Countdown.h>
#include <fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h>
#include <fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h>
#include <linux/devices/devicedefinitions/StarTrackerDefinitions.h>
#include <mission/controller/controllerdefinitions/ThermalControllerDefinitions.h> #include <mission/controller/controllerdefinitions/ThermalControllerDefinitions.h>
#include <mission/devices/devicedefinitions/BpxBatteryDefinitions.h>
#include <mission/devices/devicedefinitions/Max31865Definitions.h> #include <mission/devices/devicedefinitions/Max31865Definitions.h>
#include <mission/devices/devicedefinitions/SyrlinksDefinitions.h>
#include <mission/devices/devicedefinitions/Tmp1075Definitions.h> #include <mission/devices/devicedefinitions/Tmp1075Definitions.h>
#include <mission/devices/devicedefinitions/gyroAdisHelpers.h>
#include <mission/devices/devicedefinitions/imtqHelpers.h>
#include <mission/devices/devicedefinitions/payloadPcduDefinitions.h>
#include <mission/devices/devicedefinitions/rwHelpers.h>
#include <mission/devices/devicedefinitions/susMax1227Helpers.h> #include <mission/devices/devicedefinitions/susMax1227Helpers.h>
#include <list> #include <list>
@ -125,6 +135,44 @@ class ThermalController : public ExtendedControllerBase {
susMax1227::SusDataset susSet10; susMax1227::SusDataset susSet10;
susMax1227::SusDataset susSet11; susMax1227::SusDataset susSet11;
lp_var_t<float> tempQ7s = lp_var_t<float>(objects::CORE_CONTROLLER, core::PoolIds::TEMPERATURE);
lp_var_t<int16_t> battTemp1 =
lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_1);
lp_var_t<int16_t> battTemp2 =
lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_2);
lp_var_t<int16_t> battTemp3 =
lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_3);
lp_var_t<int16_t> battTemp4 =
lp_var_t<int16_t>(objects::BPX_BATT_HANDLER, BpxBattery::BATT_TEMP_4);
lp_var_t<int32_t> tempRw1 = lp_var_t<int32_t>(objects::RW1, rws::TEMPERATURE_C);
lp_var_t<int32_t> tempRw2 = lp_var_t<int32_t>(objects::RW2, rws::TEMPERATURE_C);
lp_var_t<int32_t> tempRw3 = lp_var_t<int32_t>(objects::RW3, rws::TEMPERATURE_C);
lp_var_t<int32_t> tempRw4 = lp_var_t<int32_t>(objects::RW4, rws::TEMPERATURE_C);
lp_var_t<float> tempStartracker =
lp_var_t<float>(objects::STAR_TRACKER, startracker::MCU_TEMPERATURE);
lp_var_t<float> tempSyrlinksPowerAmplifier =
lp_var_t<float>(objects::SYRLINKS_HANDLER, syrlinks::TEMP_POWER_AMPLIFIER);
lp_var_t<float> tempSyrlinksBasebandBoard =
lp_var_t<float>(objects::SYRLINKS_HANDLER, syrlinks::TEMP_BASEBAND_BOARD);
lp_var_t<int16_t> tempMgt = lp_var_t<int16_t>(objects::IMTQ_HANDLER, imtq::MCU_TEMPERATURE);
lp_vec_t<float, 3> tempAcu =
lp_vec_t<float, 3>(objects::ACU_HANDLER, ACU::pool::ACU_TEMPERATURES);
lp_var_t<float> tempPdu1 = lp_var_t<float>(objects::PDU1_HANDLER, PDU::pool::PDU_TEMPERATURE);
lp_var_t<float> tempPdu2 = lp_var_t<float>(objects::PDU2_HANDLER, PDU::pool::PDU_TEMPERATURE);
lp_var_t<float> temp1P60dock =
lp_var_t<float>(objects::P60DOCK_HANDLER, P60Dock::pool::P60DOCK_TEMPERATURE_1);
lp_var_t<float> temp2P60dock =
lp_var_t<float>(objects::P60DOCK_HANDLER, P60Dock::pool::P60DOCK_TEMPERATURE_2);
lp_var_t<float> tempGyro0 = lp_var_t<float>(objects::GYRO_0_ADIS_HANDLER, adis1650x::TEMPERATURE);
lp_var_t<float> tempGyro1 = lp_var_t<float>(objects::GYRO_1_L3G_HANDLER, l3gd20h::TEMPERATURE);
lp_var_t<float> tempGyro2 = lp_var_t<float>(objects::GYRO_2_ADIS_HANDLER, adis1650x::TEMPERATURE);
lp_var_t<float> tempGyro3 = lp_var_t<float>(objects::GYRO_3_L3G_HANDLER, l3gd20h::TEMPERATURE);
lp_var_t<float> tempMgm0 =
lp_var_t<float>(objects::MGM_0_LIS3_HANDLER, mgmLis3::TEMPERATURE_CELCIUS);
lp_var_t<float> tempMgm2 =
lp_var_t<float>(objects::MGM_2_LIS3_HANDLER, mgmLis3::TEMPERATURE_CELCIUS);
lp_var_t<float> tempAdcPayloadPcdu = lp_var_t<float>(objects::PLPCDU_HANDLER, plpcdu::TEMP);
// TempLimits // TempLimits
TempLimits acsBoardLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0); TempLimits acsBoardLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
TempLimits mgtLimits = TempLimits(-40.0, -40.0, 65.0, 70.0, 70.0); TempLimits mgtLimits = TempLimits(-40.0, -40.0, 65.0, 70.0, 70.0);

16
mission/core/pollingSeqTables.cpp
View File

@ -318,11 +318,23 @@ ReturnValue_t pst::pstTcsAndAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg
} }
if (cfg.scheduleStr) { if (cfg.scheduleStr) {
// 2 COM cycles for full PST for STR. The STR requests 2 packets types in NORMAL mode, this
// ensures we always get an updated STR dataset for a regular normal mode cycle.
thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::STAR_TRACKER, length * config::spiSched::SCHED_BLOCK_2_PERIOD,
thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_READ); DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::STAR_TRACKER, length * config::spiSched::SCHED_BLOCK_2_PERIOD,
DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::STAR_TRACKER, length * config::spiSched::SCHED_BLOCK_2_PERIOD,
DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::STAR_TRACKER, length * config::spiSched::SCHED_BLOCK_2_PERIOD,
DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::STAR_TRACKER, length * config::spiSched::SCHED_BLOCK_3_PERIOD,
DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::STAR_TRACKER, length * config::spiSched::SCHED_BLOCK_3_PERIOD,
DeviceHandlerIF::GET_READ);
} }
bool enableAside = true; bool enableAside = true;

2
thirdparty/arcsec_star_tracker vendored

@ -1 +1 @@
Subproject commit 42907c36c58e7133d3d3cbefbf96c1a8e35b60b7 Subproject commit cbb3b24dc1993b727735fd63576088401ba351ec

2
tmtc

@ -1 +1 @@
Subproject commit c171654d2b18547249ee03ace3a4016e8837cf4a Subproject commit 9f17661f529e045e92714817bdc52572f976da2d