diff --git a/README.md b/README.md
index 04249cfa..adb3c3e5 100644
--- a/README.md
+++ b/README.md
@@ -11,14 +11,15 @@
4. [Useful and Common Host Commands](#host-commands)
5. [Setting up Prerequisites](#set-up-prereq)
6. [Remote Debugging](#remote-debugging)
-7. [TMTC testing](#tmtc-testing)
-8. [Direct Debugging](#direct-debugging)
-9. [Transfering Files to the Q7S](#file-transfer)
-10. [Q7S OBC](#q7s)
-11. [Static Code Analysis](#static-code-analysis)
-12. [Eclipse](#eclipse)
-13. [Running the OBSW on a Raspberry Pi](#rpi)
-14. [FSFW](#fsfw)
+6. [Remote Reset](#remote-reset)
+8. [TMTC testing](#tmtc-testing)
+9. [Direct Debugging](#direct-debugging)
+10. [Transfering Files to the Q7S](#file-transfer)
+11. [Q7S OBC](#q7s)
+12. [Static Code Analysis](#static-code-analysis)
+13. [Eclipse](#eclipse)
+14. [Running the OBSW on a Raspberry Pi](#rpi)
+15. [FSFW](#fsfw)
# General information
@@ -535,10 +536,10 @@ ssh root@192.168.133.10
```
If this has not been done yet, you can access the serial
-console of the Q7S like this to set it
+console of the Q7S like this
```sh
-picocom -b 115200 /dev/ttyUSB0
+picocom -b 115200 /dev/q7sSerial
```
The flatsat has the aliases and shell scripts `q7s_ssh` and `q7s_serial` for this task as well.
@@ -575,6 +576,29 @@ alias or shell script to do this quickly.
Note: When now setting up a debug session in the Xilinx SDK or Eclipse, the host must be set
to localhost instead of the IP address of the Q7S.
+# Remote Reset
+1. Launch xilinx hardware server on flatsat with alias
+````
+launch-hwserver-xilinx
+````
+2. On host PC start xsc
+3. In xsct console type the follwing command to connect to the hardware server (replace with the IP address of the flatsat PC. Can be found out with ifconfig)
+````
+connect -url tcp::3121
+````
+4. The following command will list all available devices
+````
+targets
+````
+5. Connect to the APU of the Q7S
+````
+target
+````
+6. Perform reset
+````
+rst
+````
+
# TMTC testing
The OBSW supports sending PUS TM packets via TCP or the PDEC IP Core which transmits the data as
diff --git a/bsp_q7s/boardconfig/busConf.h b/bsp_q7s/boardconfig/busConf.h
index e6f9ae54..34516fa6 100644
--- a/bsp_q7s/boardconfig/busConf.h
+++ b/bsp_q7s/boardconfig/busConf.h
@@ -8,13 +8,11 @@ static constexpr char SPI_RW_DEV[] = "/dev/spidev3.0";
static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-1";
-static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ttyUL3";
-static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ttyUL4";
-static constexpr char UART_SYRLINKS_DEV[] = "/dev/ttyUL5";
-static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ttyUL8";
-
-static constexpr char UART_GNSS_0_DEV[] = "/dev/ttyUL0";
-static constexpr char UART_GNSS_1_DEV[] = "/dev/ttyUL2";
+static constexpr char UART_GNSS_DEV[] = "/dev/ttyUL0";
+static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ttyUL2";
+static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ttyUL3";
+static constexpr char UART_SYRLINKS_DEV[] = "/dev/ttyUL4";
+static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ttyUL7";
static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio0";
static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio2";
@@ -56,7 +54,7 @@ namespace gpioNames {
static constexpr char EN_RW_2[] = "enable_rw_2";
static constexpr char EN_RW_3[] = "enable_rw_3";
static constexpr char EN_RW_4[] = "enable_rw_4";
- static constexpr char SPI_MUX_SELECT[] = "spi_mux_select";
+ static constexpr char GNSS_MUX_SELECT[] = "gnss_mux_select";
static constexpr char RAD_SENSOR_CHIP_SELECT[] = "rad_sensor_chip_select";
static constexpr char PAPB_BUSY_SIGNAL_VC0[] = "papb_busy_signal_vc0";
static constexpr char PAPB_EMPTY_SIGNAL_VC0[] = "papb_empty_signal_vc0";
diff --git a/bsp_q7s/boardtest/Q7STestTask.cpp b/bsp_q7s/boardtest/Q7STestTask.cpp
index 965a6d63..5cead3d5 100644
--- a/bsp_q7s/boardtest/Q7STestTask.cpp
+++ b/bsp_q7s/boardtest/Q7STestTask.cpp
@@ -127,8 +127,18 @@ void Q7STestTask::testDummyParams() {
param.writeJsonFile();
param.print();
- int test = param.getValue(DummyParameter::DUMMY_KEY_PARAM_1);
- std::string test2 = param.getValue(DummyParameter::DUMMY_KEY_PARAM_2);
+ int test = 0;
+ result = param.getValue(DummyParameter::DUMMY_KEY_PARAM_1, &test);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
+ << " does not exist" << std::endl;
+ }
+ std::string test2;
+ result = param.getValue(DummyParameter::DUMMY_KEY_PARAM_2, &test2);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
+ << " does not exist" << std::endl;
+ }
sif::info << "Test value (3 expected): " << test << std::endl;
sif::info << "Test value 2 (\"blirb\" expected): " << test2 << std::endl;
}
diff --git a/bsp_q7s/callbacks/rwSpiCallback.cpp b/bsp_q7s/callbacks/rwSpiCallback.cpp
index ad99d505..1e60e3c0 100644
--- a/bsp_q7s/callbacks/rwSpiCallback.cpp
+++ b/bsp_q7s/callbacks/rwSpiCallback.cpp
@@ -51,11 +51,6 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
return result;
}
- /** Disconnect PS SPI peripheral and select AXI SPI core */
- if(gpioIF->pullHigh(gpioIds::SPI_MUX) != HasReturnvaluesIF::RETURN_OK) {
- sif::error << "rwSpiCallback::spiCallback: Failed to pull spi mux gpio high" << std::endl;
- }
-
/** Sending frame start sign */
writeBuffer[0] = 0x7E;
writeSize = 1;
@@ -239,10 +234,5 @@ void closeSpi (gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex) {
if(mutex->unlockMutex() != HasReturnvaluesIF::RETURN_OK) {
sif::error << "rwSpiCallback::closeSpi: Failed to unlock mutex" << std::endl;;
}
-
- /** Route SPI interface again to PS SPI peripheral */
- if(gpioIF->pullLow(gpioIds::SPI_MUX) != HasReturnvaluesIF::RETURN_OK) {
- sif::error << "rwSpiCallback::spiCallback: Failed to pull spi mux gpio low" << std::endl;
- }
}
}
diff --git a/bsp_q7s/core/InitMission.cpp b/bsp_q7s/core/InitMission.cpp
index 803339a2..7977deed 100644
--- a/bsp_q7s/core/InitMission.cpp
+++ b/bsp_q7s/core/InitMission.cpp
@@ -127,12 +127,15 @@ void initmission::initTasks() {
initmission::printAddObjectError("FILE_SYSTEM_TASK", objects::FILE_SYSTEM_HANDLER);
}
+#if OBSW_ADD_STAR_TRACKER == 1
PeriodicTaskIF* strImgLoaderTask = factory->createPeriodicTask(
"FILE_SYSTEM_TASK", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
result = strImgLoaderTask->addComponent(objects::STR_HELPER);
if(result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("FILE_SYSTEM_TASK", objects::STR_HELPER);
}
+#endif /* OBSW_ADD_STAR_TRACKER == 1 */
+
#endif /* BOARD_TE0720 */
#if OBSW_TEST_CCSDS_BRIDGE == 1
@@ -194,7 +197,9 @@ void initmission::initTasks() {
#if BOARD_TE0720 == 0
fsTask->startTask();
+#if OBSW_ADD_STAR_TRACKER == 1
strImgLoaderTask->startTask();
+#endif /* OBSW_ADD_STAR_TRACKER == 1 */
#endif
sif::info << "Tasks started.." << std::endl;
diff --git a/bsp_q7s/core/ObjectFactory.cpp b/bsp_q7s/core/ObjectFactory.cpp
index f01ed223..ffc9693b 100644
--- a/bsp_q7s/core/ObjectFactory.cpp
+++ b/bsp_q7s/core/ObjectFactory.cpp
@@ -570,22 +570,14 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF *gpioComIF, UartComI
resetArgsGnss0.gnss1 = false;
resetArgsGnss0.gpioComIF = gpioComIF;
resetArgsGnss0.waitPeriodMs = 100;
- auto uartCookieGps0 = new UartCookie(objects::GPS0_HANDLER, q7s::UART_GNSS_0_DEV,
+ auto uartCookieGps0 = new UartCookie(objects::GPS0_HANDLER, q7s::UART_GNSS_DEV,
UartModes::CANONICAL, uart::GNSS_BAUD, uart::HYPERION_GPS_REPLY_MAX_BUFFER);
uartCookieGps0->setToFlushInput(true);
uartCookieGps0->setReadCycles(6);
- auto uartCookieGps1 = new UartCookie(objects::GPS1_HANDLER, q7s::UART_GNSS_1_DEV,
- UartModes::CANONICAL, uart::GNSS_BAUD, uart::HYPERION_GPS_REPLY_MAX_BUFFER);
- uartCookieGps1->setToFlushInput(true);
- uartCookieGps1->setReadCycles(6);
auto gpsHandler0 = new GPSHyperionHandler(objects::GPS0_HANDLER, objects::UART_COM_IF,
uartCookieGps0, debugGps);
gpsHandler0->setResetPinTriggerFunction(gps::triggerGpioResetPin, &resetArgsGnss0);
gpsHandler0->setStartUpImmediately();
- auto gpsHandler1 = new GPSHyperionHandler(objects::GPS1_HANDLER, objects::UART_COM_IF,
- uartCookieGps1, debugGps);
- gpsHandler1->setResetPinTriggerFunction(gps::triggerGpioResetPin, &resetArgsGnss1);
- gpsHandler1->setStartUpImmediately();
}
void ObjectFactory::createHeaterComponents() {
@@ -854,15 +846,6 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
gpio::LOW);
gpioCookieRw->addGpio(gpioIds::EN_RW4, gpio);
- /**
- * This GPIO is only internally connected to the SPI MUX module and responsible to disconnect
- * the PS SPI peripheral from the SPI interface and route out the SPI lines of the AXI SPI core.
- * Per default the PS SPI is selected (EMIO = 0).
- */
- gpio = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_SELECT,
- "SPI Reaction Wheel Callback ", gpio::DIR_OUT, gpio::LOW);
- gpioCookieRw->addGpio(gpioIds::SPI_MUX, gpio);
-
gpioComIF->addGpios(gpioCookieRw);
auto rw1SpiCookie = new SpiCookie(addresses::RW1, gpioIds::CS_RW1, q7s::SPI_RW_DEV,
diff --git a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h
index 22214cb0..f1f7b7d0 100644
--- a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h
+++ b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h
@@ -59,7 +59,6 @@ enum PoolIds: lp_id_t {
TIME_TEMPERATURE_SET,
MCU_TEMPERATURE,
CMOS_TEMPERATURE,
-
TICKS_SOLUTION_SET,
TIME_SOLUTION_SET,
CALI_QW,
@@ -83,7 +82,6 @@ enum PoolIds: lp_id_t {
TRUST_WORTHY,
STABLE_COUNT,
SOLUTION_STRATEGY,
-
TICKS_HISTOGRAM_SET,
TIME_HISTOGRAM_SET,
HISTOGRAM_BINA0,
@@ -122,7 +120,6 @@ enum PoolIds: lp_id_t {
HISTOGRAM_BIND6,
HISTOGRAM_BIND7,
HISTOGRAM_BIND8,
-
TICKS_CONTRAST_SET,
TIME_CONTRAST_SET,
CONTRAST_BINA0,
@@ -160,7 +157,46 @@ enum PoolIds: lp_id_t {
CONTRAST_BIND5,
CONTRAST_BIND6,
CONTRAST_BIND7,
- CONTRAST_BIND8
+ CONTRAST_BIND8,
+ CHKSUM,
+ DWL_ID,
+ DWL_PIXX,
+ DWL_PIXY,
+ DWL_X_UNCORRECTED,
+ DWL_Y_UNCORRECTED,
+ DWL_X_CORRECTED,
+ DWL_Y_CORRECTED,
+ DWL_MAGNITUDE,
+ DWL_CXA,
+ DWL_CYA,
+ DWL_QUALITY,
+ MATCHEDSTR_ID,
+ MATCHEDSTR_CAMFPX,
+ MATCHEDSTR_CAMFPY,
+ MATCHEDSTR_CAMCARTX,
+ MATCHEDSTR_CAMCARTY,
+ MATCHEDSTR_CAMCARTZ,
+ MATCHEDSTR_CAMMAGNITUDE,
+ MATCHEDSTR_DBFPX,
+ MATCHEDSTR_DBFPY,
+ MATCHEDSTR_DBCARTX,
+ MATCHEDSTR_DBCARTY,
+ MATCHEDSTR_DBCARTZ,
+ MATCHEDSTR_DBMAGNITUDE,
+ MATCHEDSTR_CATALOGID,
+ DBIMAGE_ID,
+ DBIMAGE_PIXX,
+ DBIMAGE_PIXY,
+ DBIMAGE_X,
+ DBIMAGE_Y,
+ DBIMAGE_MAGNITUDE,
+ BLOBPIX_ID,
+ BLOBPIX_X,
+ BLOBPIX_Y,
+ BLOBPIX_TOT_VAL,
+ BLOBPIX_IN_USE,
+ BLOBPIX_BRIGHT_NEIGHBOURS,
+ BLOBPIX_REGION
};
static const DeviceCommandId_t PING_REQUEST = 0;
@@ -197,11 +233,18 @@ static const DeviceCommandId_t CHECKSUM = 50;
static const DeviceCommandId_t READ = 51;
static const DeviceCommandId_t WRITE = 52;
static const DeviceCommandId_t DOWNLOAD_MATCHED_STAR = 53;
-static const DeviceCommandId_t DOWNLOAD_DB_IMAGE = 54;
static const DeviceCommandId_t STOP_IMAGE_LOADER = 55;
static const DeviceCommandId_t RESET_ERROR = 56;
static const DeviceCommandId_t CHANGE_DOWNLOAD_FILE = 57;
static const DeviceCommandId_t SET_JSON_FILE_NAME = 58;
+static const DeviceCommandId_t SET_READ_FILENAME = 59;
+static const DeviceCommandId_t SET_TIME = 60;
+static const DeviceCommandId_t DOWNLOAD_DBIMAGE = 61;
+static const DeviceCommandId_t DOWNLOAD_BLOBPIXEL = 62;
+static const DeviceCommandId_t DOWNLOAD_FPGA_IMAGE = 63;
+static const DeviceCommandId_t CHANGE_FPGA_DOWNLOAD_FILE = 64;
+static const DeviceCommandId_t UPLOAD_FPGA_IMAGE = 65;
+static const DeviceCommandId_t FPGA_ACTION = 66;
static const DeviceCommandId_t NONE = 0xFFFFFFFF;
static const uint32_t VERSION_SET_ID = REQ_VERSION;
@@ -212,6 +255,11 @@ static const uint32_t TIME_SET_ID = REQ_TIME;
static const uint32_t SOLUTION_SET_ID = REQ_SOLUTION;
static const uint32_t HISTOGRAM_SET_ID = REQ_HISTOGRAM;
static const uint32_t CONTRAST_SET_ID = REQ_CONTRAST;
+static const uint32_t CHECKSUM_SET_ID = CHECKSUM;
+static const uint32_t DOWNLOADCENTROID_SET_ID = DOWNLOAD_CENTROID;
+static const uint32_t DOWNLOAD_MATCHED_STAR_SET_ID = DOWNLOAD_MATCHED_STAR;
+static const uint32_t DOWNLOAD_DBIMAGE_SET_ID = DOWNLOAD_DBIMAGE;
+static const uint32_t DOWNLOAD_BLOBPIXEL_SET_ID = DOWNLOAD_BLOBPIXEL;
/** Max size of unencoded frame */
static const size_t MAX_FRAME_SIZE = 1200;
@@ -224,6 +272,11 @@ static const uint8_t TIME_SET_ENTRIES = 4;
static const uint8_t SOLUTION_SET_ENTRIES = 23;
static const uint8_t HISTOGRAM_SET_ENTRIES = 38;
static const uint8_t CONTRAST_SET_ENTRIES = 38;
+static const uint8_t CHECKSUM_SET_ENTRIES = 1;
+static const uint8_t DOWNLOAD_CENTROID_SET_ENTRIES = 11;
+static const uint8_t DOWNLOAD_MATCHED_STAR_SET_ENTRIES = 14;
+static const uint8_t DOWNLOAD_DBIMAGE_SET_ENTRIES = 6;
+static const uint8_t DOWNLOAD_BLOBPIXEL_SET_ENTRIES = 7;
// Action, parameter and telemetry IDs
namespace ID {
@@ -244,6 +297,7 @@ namespace ID {
static const uint8_t REBOOT = 7;
static const uint8_t UPLOAD_IMAGE = 10;
static const uint8_t POWER = 11;
+ static const uint8_t SET_TIME = 14;
static const uint8_t SUBSCRIBE = 18;
static const uint8_t SOLUTION = 24;
static const uint8_t TEMPERATURE = 25;
@@ -257,6 +311,12 @@ namespace ID {
static const uint8_t UNLOCK = 6;
static const uint8_t TAKE_IMAGE = 15;
static const uint8_t ERROR_RESET = 12;
+ static const uint8_t DOWNLOAD_CENTROID = 16;
+ static const uint8_t UPLOAD_CENTROID = 17;
+ static const uint8_t DOWNLOAD_MATCHED_STAR = 18;
+ static const uint8_t DOWNLOAD_DBIMAGE = 19;
+ static const uint8_t DOWNLOAD_BLOBPIXEL = 24;
+ static const uint8_t FPGA_ACTION = 22;
}
namespace Program {
@@ -281,7 +341,7 @@ public:
StaticLocalDataSet(sid_t(objectId, TEMPERATURE_SET_ID)) {
}
- // Ticks is time reference generated by interanl counter of the star tracker
+ // Ticks is time reference generated by internal counter of the star tracker
lp_var_t ticks = lp_var_t(sid.objectId,
PoolIds::TICKS_TEMPERATURE_SET, this);
/** Unix time in microseconds */
@@ -321,7 +381,6 @@ public:
StaticLocalDataSet(sid_t(objectId, VERSION_SET_ID)) {
}
- // Ticks is time reference generated by interanl counter of the star tracker
lp_var_t ticks = lp_var_t(sid.objectId,
PoolIds::TICKS_VERSION_SET, this);
/** Unix time in microseconds */
@@ -845,6 +904,307 @@ public:
sif::info << "ContrastSet::printSet: BinD8: " << this->binD8 << std::endl;
}
};
-}
+/**
+ * @brief Helper Class to extract information from bytestream.
+ */
+class ChecksumReply {
+public:
+
+ /**
+ * @brief Constructor
+ *
+ * @param datafield Pointer to datafield in reply buffer
+ *
+ */
+ ChecksumReply(const uint8_t* datafield) {
+ ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+ region = *(datafield);
+ const uint8_t* addressData = datafield + ADDRESS_OFFSET;
+ size_t size = sizeof(address);
+ result = SerializeAdapter::deSerialize(&address, &addressData, &size,
+ SerializeIF::Endianness::LITTLE);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::debug << "ChecksumReply::ChecksumReply: Failed to deserialize address"
+ << std::endl;
+ }
+ const uint8_t* lengthData = datafield + LENGTH_OFFSET;
+ size = sizeof(length);
+ result = SerializeAdapter::deSerialize(&length, &lengthData, &size,
+ SerializeIF::Endianness::LITTLE);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::debug << "ChecksumReply::ChecksumReply: Failed to deserialize length"
+ << std::endl;
+ }
+ const uint8_t* checksumData = datafield + CHECKSUM_OFFSET;
+ size = sizeof(checksum);
+ result = SerializeAdapter::deSerialize(&checksum, &checksumData, &size,
+ SerializeIF::Endianness::LITTLE);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::debug << "ChecksumReply::ChecksumReply: Failed to deserialize checksum"
+ << std::endl;
+ }
+ }
+
+ uint8_t getRegion() {
+ return region;
+ }
+
+ uint32_t getAddress() {
+ return address;
+ }
+
+ uint32_t getLength() {
+ return length;
+ }
+
+ uint32_t getChecksum() {
+ return checksum;
+ }
+
+ void printChecksum() {
+ sif::info << "ChecksumReply::printChecksum: 0x" << std::hex << checksum << std::endl;
+ }
+
+private:
+
+ static const uint8_t ADDRESS_OFFSET = 1;
+ static const uint8_t LENGTH_OFFSET = 5;
+ static const uint8_t CHECKSUM_OFFSET = 9;
+
+ uint8_t region = 0;
+ uint32_t address = 0;
+ uint32_t length = 0;
+ uint32_t checksum = 0;
+};
+
+class EraseReply {
+public:
+ EraseReply(const uint8_t* datafield) {
+ region = *datafield;
+ }
+
+ uint8_t getRegion() {
+ return region;
+ }
+
+private:
+ uint8_t region = 0;
+};
+
+class ChecksumSet:
+ public StaticLocalDataSet {
+public:
+
+ // Size of dataset
+ static const size_t SIZE = 156;
+
+ ChecksumSet(HasLocalDataPoolIF* owner):
+ StaticLocalDataSet(owner, CHECKSUM_SET_ID) {
+ }
+
+ ChecksumSet(object_id_t objectId):
+ StaticLocalDataSet(sid_t(objectId, CHECKSUM_SET_ID)) {
+ }
+
+ lp_var_t checksum = lp_var_t(sid.objectId, PoolIds::CHKSUM, this);
+};
+
+/**
+ * @brief Dataset to store download centroid response
+ */
+class DownloadCentroidSet:
+ public StaticLocalDataSet {
+public:
+
+ // Size of dataset
+ static const size_t SIZE = 34;
+
+ DownloadCentroidSet(HasLocalDataPoolIF* owner):
+ StaticLocalDataSet(owner, DOWNLOADCENTROID_SET_ID) {
+ }
+
+ DownloadCentroidSet(object_id_t objectId):
+ StaticLocalDataSet(sid_t(objectId, DOWNLOADCENTROID_SET_ID)) {
+ }
+
+ lp_var_t id = lp_var_t(sid.objectId, PoolIds::DWL_ID, this);
+ lp_var_t pixx = lp_var_t(sid.objectId, PoolIds::DWL_PIXX, this);
+ lp_var_t pixy = lp_var_t(sid.objectId, PoolIds::DWL_PIXY, this);
+ lp_var_t xUncorrected = lp_var_t(sid.objectId, PoolIds::DWL_X_UNCORRECTED, this);
+ lp_var_t yUncorrected = lp_var_t(sid.objectId, PoolIds::DWL_Y_UNCORRECTED, this);
+ lp_var_t xCorrected = lp_var_t(sid.objectId, PoolIds::DWL_X_CORRECTED, this);
+ lp_var_t yCorrected = lp_var_t(sid.objectId, PoolIds::DWL_Y_CORRECTED, this);
+ lp_var_t magnitude = lp_var_t(sid.objectId, PoolIds::DWL_MAGNITUDE, this);
+ lp_var_t cxa = lp_var_t(sid.objectId, PoolIds::DWL_CXA, this);
+ lp_var_t cya = lp_var_t(sid.objectId, PoolIds::DWL_CYA, this);
+ lp_var_t quality = lp_var_t(sid.objectId, PoolIds::DWL_QUALITY, this);
+
+ void printSet() {
+ PoolReadGuard rg(this);
+ sif::info << "ContrastSet::printSet: id: " << static_cast(this->id.value)
+ << std::endl;
+ sif::info << "ContrastSet::printSet: pixx: " << this->pixx << std::endl;
+ sif::info << "ContrastSet::printSet: pixy: " << this->pixy << std::endl;
+ sif::info << "ContrastSet::printSet: xUncorrected: " << this->xUncorrected << std::endl;
+ sif::info << "ContrastSet::printSet: yUncorrected: " << this->yUncorrected << std::endl;
+ sif::info << "ContrastSet::printSet: xCorrected: " << this->xCorrected << std::endl;
+ sif::info << "ContrastSet::printSet: yCorrected: " << this->yCorrected << std::endl;
+ sif::info << "ContrastSet::printSet: magnitude: " << this->magnitude << std::endl;
+ sif::info << "ContrastSet::printSet: cxa: " << this->cxa << std::endl;
+ sif::info << "ContrastSet::printSet: cya: " << this->cya << std::endl;
+ sif::info << "ContrastSet::printSet: quality: " << this->quality << std::endl;
+ }
+};
+
+namespace UploadCentroidKeys {
+ static const char id[] = "id";
+ static const char pixx[] = "pixx";
+ static const char pixy[] = "pixy";
+ static const char x_uncorrected[] = "x_uncorrected";
+ static const char y_uncorrected[] = "y_uncorrected";
+ static const char x_corrected[] = "x_corrected";
+ static const char y_corrected[] = "y_corrected";
+ static const char magnitude[] = "magnitude";
+ static const char cxa[] = "cxa";
+ static const char cya[] = "cya";
+ static const char quality[] = "quality";
+};
+
+/**
+ * @brief Dataset to store matched star information
+ */
+class DownloadMatchedStar :
+ public StaticLocalDataSet {
+public:
+
+ // Size of dataset
+ static const size_t SIZE = 53;
+
+ DownloadMatchedStar(HasLocalDataPoolIF* owner):
+ StaticLocalDataSet(owner, DOWNLOAD_MATCHED_STAR_SET_ID) {
+ }
+
+ DownloadMatchedStar(object_id_t objectId):
+ StaticLocalDataSet(sid_t(objectId, DOWNLOAD_MATCHED_STAR_SET_ID)) {
+ }
+
+ lp_var_t id = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_ID, this);
+ lp_var_t camfpx = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMFPX, this);
+ lp_var_t camfpy = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMFPY, this);
+ lp_var_t camcartx = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMCARTX, this);
+ lp_var_t camcarty = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMCARTY, this);
+ lp_var_t camcartz = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMCARTZ, this);
+ lp_var_t cammagnitude = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMMAGNITUDE,
+ this);
+ lp_var_t dbfpx = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBFPX, this);
+ lp_var_t dbfpy = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBFPY, this);
+ lp_var_t dbcartx = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBCARTX, this);
+ lp_var_t dbcarty = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBCARTY, this);
+ lp_var_t dbcartz = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBCARTZ, this);
+ lp_var_t dbmagnitude = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBMAGNITUDE,
+ this);
+ lp_var_t catalogid = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CATALOGID,
+ this);
+
+ void printSet() {
+ PoolReadGuard rg(this);
+ sif::info << "DownloadMatchedStar::printSet: id: "
+ << static_cast(this->id.value) << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: camfpx: " << this->camfpx << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: camfpy: " << this->camfpy << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: camcartx: " << this->camcartx << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: camcarty: " << this->camcarty << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: camcartz: " << this->camcartz << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: cammagnitude: " << this->cammagnitude
+ << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: dbfpx: " << this->dbfpx << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: dbfpy: " << this->dbfpy << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: dbcartx: " << this->dbcartx << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: dbcarty: " << this->dbcarty << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: dbcartz: " << this->dbcartz << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: dbmagnitude: " << this->dbmagnitude
+ << std::endl;
+ sif::info << "DownloadMatchedStar::printSet: catalogid: " << this->catalogid << std::endl;
+ }
+};
+
+/**
+ * @brief Dataset to store the response to the DownloadDBImage request
+ */
+class DownloadDBImage :
+ public StaticLocalDataSet {
+public:
+
+ // Size of dataset
+ static const size_t SIZE = 21;
+
+ DownloadDBImage(HasLocalDataPoolIF* owner):
+ StaticLocalDataSet(owner, DOWNLOAD_DBIMAGE_SET_ID) {
+ }
+
+ DownloadDBImage(object_id_t objectId):
+ StaticLocalDataSet(sid_t(objectId, DOWNLOAD_DBIMAGE_SET_ID)) {
+ }
+
+ lp_var_t id = lp_var_t(sid.objectId, PoolIds::DBIMAGE_ID, this);
+ lp_var_t pixx = lp_var_t(sid.objectId, PoolIds::DBIMAGE_PIXX, this);
+ lp_var_t pixy = lp_var_t(sid.objectId, PoolIds::DBIMAGE_PIXY, this);
+ lp_var_t x = lp_var_t(sid.objectId, PoolIds::DBIMAGE_X, this);
+ lp_var_t y = lp_var_t(sid.objectId, PoolIds::DBIMAGE_Y, this);
+ lp_var_t magnitude = lp_var_t(sid.objectId, PoolIds::DBIMAGE_MAGNITUDE, this);
+
+ void printSet() {
+ PoolReadGuard rg(this);
+ sif::info << "DownloadDBImage::printSet: id: "
+ << static_cast(this->id.value) << std::endl;
+ sif::info << "DownloadDBImage::printSet: pixx: " << this->pixx << std::endl;
+ sif::info << "DownloadDBImage::printSet: pixy: " << this->pixy << std::endl;
+ sif::info << "DownloadDBImage::printSet: x: " << this->x << std::endl;
+ sif::info << "DownloadDBImage::printSet: y: " << this->y << std::endl;
+ sif::info << "DownloadDBImage::printSet: magnitude: " << this->magnitude << std::endl;
+ }
+};
+
+/**
+ * @brief Dataset to store the response to the download blob pixel action request
+ */
+class DownloadBlobPixel: public StaticLocalDataSet {
+public:
+
+ // Size of dataset
+ static const size_t SIZE = 22;
+
+ DownloadBlobPixel(HasLocalDataPoolIF* owner) :
+ StaticLocalDataSet(owner, DOWNLOAD_BLOBPIXEL_SET_ID) {
+ }
+
+ DownloadBlobPixel(object_id_t objectId) :
+ StaticLocalDataSet(sid_t(objectId, DOWNLOAD_BLOBPIXEL_SET_ENTRIES)) {
+ }
+
+ lp_var_t id = lp_var_t(sid.objectId, PoolIds::BLOBPIX_ID, this);
+ lp_var_t x = lp_var_t(sid.objectId, PoolIds::BLOBPIX_X, this);
+ lp_var_t y = lp_var_t(sid.objectId, PoolIds::BLOBPIX_Y, this);
+ lp_var_t totalValue = lp_var_t(sid.objectId, PoolIds::BLOBPIX_TOT_VAL, this);
+ lp_var_t inUse = lp_var_t(sid.objectId, PoolIds::BLOBPIX_IN_USE, this);
+ lp_var_t brightNeighbours = lp_var_t(sid.objectId,
+ PoolIds::BLOBPIX_BRIGHT_NEIGHBOURS, this);
+ lp_var_t region = lp_var_t(sid.objectId, PoolIds::BLOBPIX_REGION, this);
+
+ void printSet() {
+ PoolReadGuard rg(this);
+ sif::info << "DownloadBlobPixel::printSet: id: "
+ << static_cast(this->id.value) << std::endl;
+ sif::info << "DownloadBlobPixel::printSet: x: " << this->x << std::endl;
+ sif::info << "DownloadBlobPixel::printSet: y: " << this->y << std::endl;
+ sif::info << "DownloadBlobPixel::printSet: totalValue: " << this->totalValue << std::endl;
+ sif::info << "DownloadBlobPixel::printSet: inUse: "
+ << static_cast(this->inUse.value) << std::endl;
+ sif::info << "DownloadBlobPixel::printSet: brightNeighbours: " << this->brightNeighbours
+ << std::endl;
+ sif::info << "DownloadBlobPixel::printSet: region: " << this->region << std::endl;
+ }
+};
+}
#endif /* MISSION_STARTRACKER_DEFINITIONS_H_ */
diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp
index bb9018be..de70037a 100644
--- a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp
+++ b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp
@@ -1,23 +1,25 @@
#include
-
#include "StarTrackerHandler.h"
#include "OBSWConfig.h"
#include "StarTrackerJsonCommands.h"
-
#include
#include
-
+#include
extern "C" {
#include
#include
#include "common/misc.h"
}
+using json = nlohmann::json;
+
StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF,
CookieIF * comCookie, StrHelper* strHelper) :
DeviceHandlerBase(objectId, comIF, comCookie), temperatureSet(this), versionSet(this), powerSet(
- this), interfaceSet(this), timeSet(this), solutionSet(this), histogramSet(this),
- contrastSet(this), strHelper(strHelper) {
+ this), interfaceSet(this), timeSet(this), solutionSet(this), histogramSet(this), contrastSet(
+ this), checksumSet(this), downloadCentroidSet(this), downloadMatchedStar(this),
+ downloadDbImage(this), downloadBlobPixel(this), strHelper(
+ strHelper) {
if (comCookie == nullptr) {
sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl;
}
@@ -51,7 +53,7 @@ ReturnValue_t StarTrackerHandler::initialize() {
}
result = manager->subscribeToEventRange(eventQueue->getId(),
event::getEventId(StrHelper::IMAGE_UPLOAD_FAILED),
- event::getEventId(StrHelper::FLASH_READ_FAILED));
+ event::getEventId(StrHelper::FPGA_UPLOAD_FAILED));
if (result != RETURN_OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "StarTrackerHandler::initialize: Failed to subscribe to events from "
@@ -105,7 +107,7 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
if (result != RETURN_OK) {
return result;
}
- if (size > MAX_PATH_SIZE) {
+ if (size > MAX_PATH_SIZE + MAX_FILE_NAME) {
return FILE_PATH_TOO_LONG;
}
result = strHelper->startImageUpload(
@@ -145,6 +147,18 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
strHelperExecuting = true;
return EXECUTION_FINISHED;
}
+ case(StarTracker::READ): {
+ result = DeviceHandlerBase::acceptExternalDeviceCommands();
+ if (result != RETURN_OK) {
+ return result;
+ }
+ result = executeReadCommand(data, size);
+ if (result != RETURN_OK) {
+ return result;
+ }
+ strHelperExecuting = true;
+ return EXECUTION_FINISHED;
+ }
case(StarTracker::CHANGE_DOWNLOAD_FILE): {
if (size > MAX_FILE_NAME) {
return FILENAME_TOO_LONG;
@@ -153,6 +167,51 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
std::string(reinterpret_cast(data), size));
return EXECUTION_FINISHED;
}
+ case(StarTracker::CHANGE_FPGA_DOWNLOAD_FILE): {
+ if (size > MAX_FILE_NAME) {
+ return FILENAME_TOO_LONG;
+ }
+ strHelper->setDownloadFpgaImage(std::string(reinterpret_cast(data), size));
+ return EXECUTION_FINISHED;
+ }
+ case(StarTracker::SET_READ_FILENAME): {
+ if (size > MAX_FILE_NAME) {
+ return FILENAME_TOO_LONG;
+ }
+ strHelper->setDownloadImageName(
+ std::string(reinterpret_cast(data), size));
+ return EXECUTION_FINISHED;
+ }
+ case(StarTracker::DOWNLOAD_FPGA_IMAGE): {
+ result = DeviceHandlerBase::acceptExternalDeviceCommands();
+ if (result != RETURN_OK) {
+ return result;
+ }
+ if (size > MAX_PATH_SIZE) {
+ return FILE_PATH_TOO_LONG;
+ }
+ result = executeFpgaDownloadCommand(data, size);
+ if (result != RETURN_OK) {
+ return result;
+ }
+ strHelperExecuting = true;
+ return EXECUTION_FINISHED;
+ }
+ case(StarTracker::UPLOAD_FPGA_IMAGE): {
+ result = DeviceHandlerBase::acceptExternalDeviceCommands();
+ if (result != RETURN_OK) {
+ return result;
+ }
+ if (size > MAX_PATH_SIZE + MAX_FILE_NAME) {
+ return FILE_PATH_TOO_LONG;
+ }
+ result = strHelper->startFpgaUpload(std::string(reinterpret_cast(data), size));
+ if (result != RETURN_OK) {
+ return result;
+ }
+ strHelperExecuting = true;
+ return EXECUTION_FINISHED;
+ }
default:
break;
}
@@ -396,6 +455,46 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
result = prepareParamCommand(commandData, commandDataLen, tracking);
return result;
}
+ case (StarTracker::ERASE): {
+ result = prepareEraseCommand(commandData, commandDataLen);
+ return result;
+ }
+ case (StarTracker::UNLOCK): {
+ result = prepareUnlockCommand(commandData, commandDataLen);
+ return result;
+ }
+ case (StarTracker::CHECKSUM): {
+ result = prepareChecksumCommand(commandData, commandDataLen);
+ return result;
+ }
+ case (StarTracker::SET_TIME): {
+ result = prepareSetTimeCommand(commandData, commandDataLen);
+ return result;
+ }
+ case (StarTracker::DOWNLOAD_CENTROID): {
+ result = prepareDownloadCentroidCommand(commandData, commandDataLen);
+ return result;
+ }
+ case (StarTracker::UPLOAD_CENTROID): {
+ result = prepareUploadCentroidCommand(commandData, commandDataLen);
+ return result;
+ }
+ case (StarTracker::DOWNLOAD_MATCHED_STAR): {
+ result = prepareDownloadMatchedStarCommand(commandData, commandDataLen);
+ return result;
+ }
+ case (StarTracker::DOWNLOAD_DBIMAGE): {
+ result = prepareDownloadDbImageCommand(commandData, commandDataLen);
+ return result;
+ }
+ case (StarTracker::DOWNLOAD_BLOBPIXEL): {
+ result = prepareDownloadBlobPixelCommand(commandData, commandDataLen);
+ return result;
+ }
+ case (StarTracker::FPGA_ACTION): {
+ result = prepareFpgaActionCommand(commandData, commandDataLen);
+ return result;
+ }
default:
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
}
@@ -454,6 +553,26 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::RESET_ERROR, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
+ this->insertInCommandAndReplyMap(StarTracker::ERASE, 3, nullptr,
+ StarTracker::MAX_FRAME_SIZE * 2 + 2);
+ this->insertInCommandAndReplyMap(StarTracker::UNLOCK, 3, nullptr,
+ StarTracker::MAX_FRAME_SIZE * 2 + 2);
+ this->insertInCommandAndReplyMap(StarTracker::CHECKSUM, 3, nullptr,
+ StarTracker::MAX_FRAME_SIZE * 2 + 2);
+ this->insertInCommandAndReplyMap(StarTracker::SET_TIME, 3, nullptr,
+ StarTracker::MAX_FRAME_SIZE * 2 + 2);
+ this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_CENTROID, 3, nullptr,
+ StarTracker::MAX_FRAME_SIZE * 2 + 2);
+ this->insertInCommandAndReplyMap(StarTracker::UPLOAD_CENTROID, 3, nullptr,
+ StarTracker::MAX_FRAME_SIZE * 2 + 2);
+ this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_MATCHED_STAR, 3, &downloadMatchedStar,
+ StarTracker::MAX_FRAME_SIZE * 2 + 2);
+ this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_DBIMAGE, 3, &downloadDbImage,
+ StarTracker::MAX_FRAME_SIZE * 2 + 2);
+ this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_BLOBPIXEL, 3, &downloadBlobPixel,
+ StarTracker::MAX_FRAME_SIZE * 2 + 2);
+ this->insertInCommandAndReplyMap(StarTracker::FPGA_ACTION, 3, nullptr,
+ StarTracker::MAX_FRAME_SIZE * 2 + 2);
}
ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t *start, size_t remainingSize,
@@ -522,16 +641,41 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, con
result = handlePingReply();
break;
}
- case (StarTracker::BOOT): {
+ case (StarTracker::BOOT):
+ case (StarTracker::TAKE_IMAGE):
+ case (StarTracker::RESET_ERROR):
+ case (StarTracker::UNLOCK):
+ case (StarTracker::SET_TIME):
+ case (StarTracker::FPGA_ACTION): {
result = handleActionReply();
break;
}
- case (StarTracker::RESET_ERROR): {
- result = handleActionReply();
+ case (StarTracker::DOWNLOAD_CENTROID): {
+ result = handleActionReplySet(downloadCentroidSet, StarTracker::DownloadCentroidSet::SIZE);
break;
}
- case (StarTracker::TAKE_IMAGE): {
- result = handleActionReply();
+ case (StarTracker::DOWNLOAD_MATCHED_STAR): {
+ result = handleActionReplySet(downloadMatchedStar, StarTracker::DownloadMatchedStar::SIZE);
+ break;
+ }
+ case (StarTracker::DOWNLOAD_DBIMAGE): {
+ result = handleActionReplySet(downloadDbImage, StarTracker::DownloadDBImage::SIZE);
+ break;
+ }
+ case (StarTracker::DOWNLOAD_BLOBPIXEL): {
+ result = handleActionReplySet(downloadBlobPixel, StarTracker::DownloadBlobPixel::SIZE);
+ break;
+ }
+ case (StarTracker::UPLOAD_CENTROID): {
+ result = handleUploadCentroidReply();
+ break;
+ }
+ case (StarTracker::ERASE): {
+ result = handleEraseReply();
+ break;
+ }
+ case (StarTracker::CHECKSUM): {
+ result = handleChecksumReply();
break;
}
case (StarTracker::REQ_VERSION): {
@@ -754,7 +898,42 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
localDataPoolMap.emplace(StarTracker::CONTRAST_BIND6, new PoolEntry( { 0 }));
localDataPoolMap.emplace(StarTracker::CONTRAST_BIND7, new PoolEntry( { 0 }));
localDataPoolMap.emplace(StarTracker::CONTRAST_BIND8, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::CHKSUM, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::DWL_ID, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::DWL_PIXX, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::DWL_PIXY, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::DWL_X_UNCORRECTED, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::DWL_Y_UNCORRECTED, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::DWL_X_CORRECTED, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::DWL_Y_CORRECTED, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::DWL_MAGNITUDE, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::DWL_CXA, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::DWL_CYA, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::DWL_QUALITY, new PoolEntry( { 0 }));
+
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_ID, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMFPX, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMFPY, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMCARTX, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMCARTY, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMCARTZ, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMMAGNITUDE, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBFPX, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBFPY, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBCARTX, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBCARTY, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBCARTZ, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBMAGNITUDE, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CATALOGID, new PoolEntry( { 0 }));
+
+ localDataPoolMap.emplace(StarTracker::BLOBPIX_ID, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::BLOBPIX_X, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::BLOBPIX_Y, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::BLOBPIX_TOT_VAL, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::BLOBPIX_IN_USE, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::BLOBPIX_BRIGHT_NEIGHBOURS, new PoolEntry( { 0 }));
+ localDataPoolMap.emplace(StarTracker::BLOBPIX_REGION, new PoolEntry( { 0 }));
return RETURN_OK;
}
@@ -809,6 +988,46 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t *foundId)
*foundId = StarTracker::RESET_ERROR;
break;
}
+ case (StarTracker::ID::ERASE): {
+ *foundId = StarTracker::ERASE;
+ break;
+ }
+ case (StarTracker::ID::UNLOCK): {
+ *foundId = StarTracker::UNLOCK;
+ break;
+ }
+ case (StarTracker::ID::CHECKSUM): {
+ *foundId = StarTracker::CHECKSUM;
+ break;
+ }
+ case (StarTracker::ID::SET_TIME): {
+ *foundId = StarTracker::SET_TIME;
+ break;
+ }
+ case (StarTracker::ID::DOWNLOAD_CENTROID): {
+ *foundId = StarTracker::DOWNLOAD_CENTROID;
+ break;
+ }
+ case (StarTracker::ID::UPLOAD_CENTROID): {
+ *foundId = StarTracker::UPLOAD_CENTROID;
+ break;
+ }
+ case (StarTracker::ID::DOWNLOAD_MATCHED_STAR): {
+ *foundId = StarTracker::DOWNLOAD_MATCHED_STAR;
+ break;
+ }
+ case (StarTracker::ID::DOWNLOAD_DBIMAGE): {
+ *foundId = StarTracker::DOWNLOAD_DBIMAGE;
+ break;
+ }
+ case (StarTracker::ID::DOWNLOAD_BLOBPIXEL): {
+ *foundId = StarTracker::DOWNLOAD_BLOBPIXEL;
+ break;
+ }
+ case (StarTracker::ID::FPGA_ACTION): {
+ *foundId = StarTracker::FPGA_ACTION;
+ break;
+ }
default:
sif::warning << "StarTrackerHandler::scanForParameterReply: Unknown parameter reply id"
<< std::endl;
@@ -945,7 +1164,7 @@ ReturnValue_t StarTrackerHandler::executeWriteCommand(const uint8_t* commandData
size_t size = sizeof(address);
const uint8_t* addressPtr = commandData + WriteCmd::ADDRESS_OFFSET;
result = SerializeAdapter::deSerialize(&address, addressPtr, &size,
- SerializeIF::Endianness::LITTLE);
+ SerializeIF::Endianness::BIG);
if (result != RETURN_OK) {
sif::debug << "StarTrackerHandler::executeWriteCommand: Deserialization of address failed"
<< std::endl;
@@ -966,6 +1185,89 @@ ReturnValue_t StarTrackerHandler::executeWriteCommand(const uint8_t* commandData
return result;
}
+ReturnValue_t StarTrackerHandler::executeFpgaDownloadCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ ReturnValue_t result = RETURN_OK;
+ if (commandDataLen < FpgaDownloadCmd::MIN_LENGTH) {
+ sif::warning << "StarTrackerHandler::executeFpgaDownloadCommand: Command too short"
+ << std::endl;
+ return COMMAND_TOO_SHORT;
+ }
+ uint32_t position;
+ size_t size = sizeof(position);
+ result = SerializeAdapter::deSerialize(&position, &commandData, &size,
+ SerializeIF::Endianness::BIG);
+ if (result != RETURN_OK) {
+ sif::debug << "StarTrackerHandler::executeWriteCommand: Deserialization of position failed"
+ << std::endl;
+ return result;
+ }
+ uint32_t length;
+ size = sizeof(length);
+ result = SerializeAdapter::deSerialize(&length, &commandData, &size,
+ SerializeIF::Endianness::BIG);
+ if (result != RETURN_OK) {
+ sif::debug << "StarTrackerHandler::executeWriteCommand: Deserialization of length failed"
+ << std::endl;
+ return result;
+ }
+ if (commandDataLen - sizeof(position) - sizeof(length) > MAX_PATH_SIZE) {
+ sif::warning << "StarTrackerHandler::executeFpgaDownloadCommand: Received command with "
+ " invalid path and filename" << std::endl;
+ return FILE_PATH_TOO_LONG;
+ }
+ std::string fullname = std::string(reinterpret_cast(commandData),
+ commandDataLen - sizeof(position) - sizeof(length));
+ result = strHelper->startFpgaDownload(fullname, position, length);
+ if (result != RETURN_OK) {
+ return result;
+ }
+ return result;
+}
+
+ReturnValue_t StarTrackerHandler::executeReadCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ ReturnValue_t result = RETURN_OK;
+ if (commandDataLen < ReadCmd::MIN_LENGTH) {
+ sif::warning << "StarTrackerHandler::executeReadCommand: Command too short" << std::endl;
+ return COMMAND_TOO_SHORT;
+ }
+ uint8_t region = *(commandData);
+ uint32_t address;
+ size_t size = sizeof(address);
+ const uint8_t* addressPtr = commandData + ReadCmd::ADDRESS_OFFSET;
+ result = SerializeAdapter::deSerialize(&address, addressPtr, &size,
+ SerializeIF::Endianness::BIG);
+ if (result != RETURN_OK) {
+ sif::debug << "StarTrackerHandler::executeReadCommand: Deserialization of address failed"
+ << std::endl;
+ return result;
+ }
+ uint32_t length;
+ size = sizeof(length);
+ const uint8_t* lengthPtr = commandData + ReadCmd::LENGTH_OFFSET;
+ result = SerializeAdapter::deSerialize(&length, lengthPtr, &size,
+ SerializeIF::Endianness::BIG);
+ if (result != RETURN_OK) {
+ sif::debug << "StarTrackerHandler::executeReadCommand: Deserialization of length failed"
+ << std::endl;
+ return result;
+ }
+ if (commandDataLen - sizeof(address) - sizeof(region) - sizeof(length) > MAX_PATH_SIZE) {
+ sif::warning << "StarTrackerHandler::executeReadCommand: Received command with invalid"
+ << " path and filename" << std::endl;
+ return FILE_PATH_TOO_LONG;
+ }
+ const uint8_t* filePtr = commandData + ReadCmd::FILE_OFFSET;
+ std::string fullname = std::string(reinterpret_cast(filePtr),
+ commandDataLen - sizeof(address) - sizeof(region) - sizeof(length));
+ result = strHelper->startFlashRead(fullname, region, address, length);
+ if (result != RETURN_OK) {
+ return result;
+ }
+ return result;
+}
+
void StarTrackerHandler::prepareBootCommand() {
uint32_t length = 0;
struct BootActionRequest bootRequest = {BOOT_REGION_ID};
@@ -975,6 +1277,215 @@ void StarTrackerHandler::prepareBootCommand() {
rawPacketLen = dataLinkLayer.getEncodedLength();
}
+ReturnValue_t StarTrackerHandler::prepareEraseCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ ReturnValue_t result = RETURN_OK;
+ if (commandDataLen != EraseCmd::LENGTH) {
+ return INVALID_LENGTH;
+ }
+ uint32_t length = 0;
+ struct EraseActionRequest req;
+ req.region = *commandData;
+ arc_pack_erase_action_req(&req, commandBuffer, &length);
+ dataLinkLayer.encodeFrame(commandBuffer, length);
+ rawPacket = dataLinkLayer.getEncodedFrame();
+ rawPacketLen = dataLinkLayer.getEncodedLength();
+ eraseCmd.rememberRegion = req.region;
+ return result;
+}
+
+ReturnValue_t StarTrackerHandler::prepareUnlockCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ ReturnValue_t result = RETURN_OK;
+ uint32_t length = 0;
+ struct UnlockActionRequest req;
+ req.region = *commandData;
+ size_t size = sizeof(req.code);
+ const uint8_t* codePtr = commandData + UnlockCmd::CODE_OFFSET;
+ result = SerializeAdapter::deSerialize(&req.code, &codePtr, &size,
+ SerializeIF::Endianness::BIG);
+ if (result != RETURN_OK) {
+ return result;
+ }
+ arc_pack_unlock_action_req(&req, commandBuffer, &length);
+ dataLinkLayer.encodeFrame(commandBuffer, length);
+ rawPacket = dataLinkLayer.getEncodedFrame();
+ rawPacketLen = dataLinkLayer.getEncodedLength();
+ return result;
+}
+
+ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ struct ChecksumActionRequest req;
+ ReturnValue_t result = RETURN_OK;
+ if (commandDataLen != ChecksumCmd::LENGTH) {
+ sif::warning << "StarTrackerHandler::prepareChecksumCommand: Invalid length" << std::endl;
+ return INVALID_LENGTH;
+ }
+ req.region = *(commandData);
+ size_t size = sizeof(req.address);
+ const uint8_t* addressPtr = commandData + ChecksumCmd::ADDRESS_OFFSET;
+ result = SerializeAdapter::deSerialize(&req.address, addressPtr, &size,
+ SerializeIF::Endianness::BIG);
+ if (result != RETURN_OK) {
+ sif::debug << "StarTrackerHandler::prepareChecksumCommand: Deserialization of address "
+ << "failed" << std::endl;
+ return result;
+ }
+ size = sizeof(req.length);
+ const uint8_t* lengthPtr = commandData + ChecksumCmd::LENGTH_OFFSET;
+ result = SerializeAdapter::deSerialize(&req.length, lengthPtr, &size,
+ SerializeIF::Endianness::BIG);
+ if (result != RETURN_OK) {
+ sif::debug << "StarTrackerHandler::prepareChecksumCommand: Deserialization of length failed"
+ << std::endl;
+ return result;
+ }
+ uint32_t rawCmdLength = 0;
+ arc_pack_checksum_action_req(&req, commandBuffer, &rawCmdLength);
+ dataLinkLayer.encodeFrame(commandBuffer, rawCmdLength);
+ rawPacket = dataLinkLayer.getEncodedFrame();
+ rawPacketLen = dataLinkLayer.getEncodedLength();
+ checksumCmd.rememberRegion = req.region;
+ checksumCmd.rememberAddress = req.address;
+ checksumCmd.rememberLength = req.length;
+ return result;
+}
+
+
+ReturnValue_t StarTrackerHandler::prepareSetTimeCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ ReturnValue_t result = RETURN_OK;
+ struct SetTimeActionRequest req;
+ if (commandDataLen != SetTimeCmd::LENGTH) {
+ sif::warning << "StarTrackerHandler::prepareSetTimeCommand: Invalid length" << std::endl;
+ return INVALID_LENGTH;
+ }
+ size_t size = sizeof(req.unixTime);
+ result = SerializeAdapter::deSerialize(&req.unixTime, commandData, &size,
+ SerializeIF::Endianness::BIG);
+ if (result != RETURN_OK) {
+ sif::debug << "StarTrackerHandler::prepareSetTimeCommand: Deserialization failed"
+ << std::endl;
+ return result;
+ }
+ uint32_t length = 0;
+ arc_pack_settime_action_req(&req, commandBuffer, &length);
+ dataLinkLayer.encodeFrame(commandBuffer, length);
+ rawPacket = dataLinkLayer.getEncodedFrame();
+ rawPacketLen = dataLinkLayer.getEncodedLength();
+ return result;
+}
+
+ReturnValue_t StarTrackerHandler::prepareDownloadCentroidCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ ReturnValue_t result = RETURN_OK;
+ struct DownloadCentroidActionRequest req;
+ if (commandDataLen != DownloadCentroidCmd::LENGTH) {
+ sif::warning << "StarTrackerHandler::prepareDownloadCentroidCommand: Invalid length"
+ << std::endl;
+ return INVALID_LENGTH;
+ }
+ req.id = *commandData;
+ uint32_t length = 0;
+ arc_pack_downloadcentroid_action_req(&req, commandBuffer, &length);
+ dataLinkLayer.encodeFrame(commandBuffer, length);
+ rawPacket = dataLinkLayer.getEncodedFrame();
+ rawPacketLen = dataLinkLayer.getEncodedLength();
+ return result;
+}
+
+ReturnValue_t StarTrackerHandler::prepareUploadCentroidCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ if (commandDataLen > MAX_PATH_SIZE) {
+ return FILE_PATH_TOO_LONG;
+ }
+ ReturnValue_t result = RETURN_OK;
+ struct UploadCentroidActionRequest req;
+ std::string jsonFileName = std::string(reinterpret_cast(commandData),
+ commandDataLen);
+ NVMParameterBase j(jsonFileName);
+ result = j.readJsonFile();
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: " << jsonFileName
+ << " does not exist" << std::endl;
+ return result;
+ }
+ result = j.getValue(StarTracker::UploadCentroidKeys::id, &req.id);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
+ << StarTracker::UploadCentroidKeys::id << " does not exist" << std::endl;
+ return result;
+ }
+ result = j.getValue(StarTracker::UploadCentroidKeys::pixx, &req.pixx);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
+ << StarTracker::UploadCentroidKeys::pixx << " does not exist" << std::endl;
+ return result;
+ }
+ result = j.getValue(StarTracker::UploadCentroidKeys::pixy, &req.pixy);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
+ << StarTracker::UploadCentroidKeys::pixy << " does not exist" << std::endl;
+ return result;
+ }
+ result = j.getValue(StarTracker::UploadCentroidKeys::x_uncorrected, &req.x_uncorrected);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
+ << StarTracker::UploadCentroidKeys::x_uncorrected << " does not exist" << std::endl;
+ return result;
+ }
+ result = j.getValue(StarTracker::UploadCentroidKeys::y_uncorrected, &req.y_uncorrected);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
+ << StarTracker::UploadCentroidKeys::y_uncorrected << " does not exist" << std::endl;
+ return result;
+ }
+ result = j.getValue(StarTracker::UploadCentroidKeys::x_corrected, &req.x_corrected);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
+ << StarTracker::UploadCentroidKeys::x_corrected << " does not exist" << std::endl;
+ return result;
+ }
+ result = j.getValue(StarTracker::UploadCentroidKeys::y_corrected, &req.y_corrected);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
+ << StarTracker::UploadCentroidKeys::y_corrected << " does not exist" << std::endl;
+ return result;
+ }
+ result = j.getValue(StarTracker::UploadCentroidKeys::magnitude, &req.magnitude);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
+ << StarTracker::UploadCentroidKeys::magnitude << " does not exist" << std::endl;
+ return result;
+ }
+ result = j.getValue(StarTracker::UploadCentroidKeys::cxa, &req.cxa);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
+ << StarTracker::UploadCentroidKeys::cxa << " does not exist" << std::endl;
+ return result;
+ }
+ result = j.getValue(StarTracker::UploadCentroidKeys::cya, &req.cya);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
+ << StarTracker::UploadCentroidKeys::cya << " does not exist" << std::endl;
+ return result;
+ }
+ result = j.getValue(StarTracker::UploadCentroidKeys::quality, &req.quality);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
+ << StarTracker::UploadCentroidKeys::quality << " does not exist" << std::endl;
+ return result;
+ }
+ uint32_t length = 0;
+ arc_pack_uploadcentroid_action_req(&req, commandBuffer, &length);
+ dataLinkLayer.encodeFrame(commandBuffer, length);
+ rawPacket = dataLinkLayer.getEncodedFrame();
+ rawPacketLen = dataLinkLayer.getEncodedLength();
+ uploadCentroid.rememberId = req.id;
+ return result;
+}
+
void StarTrackerHandler::prepareTimeRequest() {
uint32_t length = 0;
arc_tm_pack_time_req(commandBuffer, &length);
@@ -1122,6 +1633,73 @@ ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData
return RETURN_OK;
}
+ReturnValue_t StarTrackerHandler::prepareDownloadMatchedStarCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ if (commandDataLen != DownloadMatchedStarCmd::LENGTH) {
+ return INVALID_LENGTH;
+ }
+ struct DownloadMatchedStarActionRequest req;
+ req.id = *commandData;
+ uint32_t length = 0;
+ arc_pack_downloadmatchedstar_action_req(&req, commandBuffer, &length);
+ dataLinkLayer.encodeFrame(commandBuffer, length);
+ rawPacket = dataLinkLayer.getEncodedFrame();
+ rawPacketLen = dataLinkLayer.getEncodedLength();
+ return RETURN_OK;
+}
+
+ReturnValue_t StarTrackerHandler::prepareDownloadDbImageCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ if (commandDataLen != DownloadDbImageCmd::LENGTH) {
+ return INVALID_LENGTH;
+ }
+ struct DownloadDBImageActionRequest req;
+ req.id = *commandData;
+ uint32_t length = 0;
+ arc_pack_downloaddbimage_action_req(&req, commandBuffer, &length);
+ dataLinkLayer.encodeFrame(commandBuffer, length);
+ rawPacket = dataLinkLayer.getEncodedFrame();
+ rawPacketLen = dataLinkLayer.getEncodedLength();
+ return RETURN_OK;
+}
+
+ReturnValue_t StarTrackerHandler::prepareDownloadBlobPixelCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ if (commandDataLen != DownloadBlobPixCmd::LENGTH) {
+ return INVALID_LENGTH;
+ }
+ struct DownloadBlobPixelActionRequest req;
+ req.id = *commandData;
+ req.type = *(commandData + 1);
+ if ((req.type != DownloadBlobPixCmd::NORMAL) && (req.type != DownloadBlobPixCmd::FAST)) {
+ return INVALID_TYPE;
+ }
+ uint32_t length = 0;
+ arc_pack_downloadblobpixel_action_req(&req, commandBuffer, &length);
+ dataLinkLayer.encodeFrame(commandBuffer, length);
+ rawPacket = dataLinkLayer.getEncodedFrame();
+ rawPacketLen = dataLinkLayer.getEncodedLength();
+ return RETURN_OK;
+}
+
+ReturnValue_t StarTrackerHandler::prepareFpgaActionCommand(const uint8_t* commandData,
+ size_t commandDataLen) {
+ if (commandDataLen != FpgaActionCmd::LENGTH) {
+ return INVALID_LENGTH;
+ }
+ struct FPGAActionActionRequest req;
+ req.id = *commandData;
+ if (req.id != FpgaActionCmd::ID) {
+ return INVALID_ID;
+ }
+ uint32_t length = 0;
+ arc_pack_fpgaaction_action_req(&req, commandBuffer, &length);
+ dataLinkLayer.encodeFrame(commandBuffer, length);
+ rawPacket = dataLinkLayer.getEncodedFrame();
+ rawPacketLen = dataLinkLayer.getEncodedLength();
+ return RETURN_OK;
+}
+
ReturnValue_t StarTrackerHandler::handleSetParamReply() {
const uint8_t* reply = dataLinkLayer.getReply();
uint8_t status = *(reply + STATUS_OFFSET);
@@ -1145,7 +1723,7 @@ ReturnValue_t StarTrackerHandler::handleActionReply() {
uint8_t status = *(reply + STATUS_OFFSET);
if (status != StarTracker::STATUS_OK) {
sif::warning << "StarTrackerHandler::handleActionReply: Failed to execute action "
- << " command with action ID "
+ << "command with action ID "
<< static_cast(*(reply + ACTION_ID_OFFSET))
<< " and status "<< static_cast(status) << std::endl;
return ACTION_FAILED;
@@ -1153,6 +1731,63 @@ ReturnValue_t StarTrackerHandler::handleActionReply() {
return RETURN_OK;
}
+ReturnValue_t StarTrackerHandler::handleUploadCentroidReply() {
+ ReturnValue_t result = RETURN_OK;
+ result = handleActionReply();
+ if (result != RETURN_OK) {
+ return result;
+ }
+ const uint8_t* reply = dataLinkLayer.getReply();
+ if (*(reply + ACTION_DATA_OFFSET) != uploadCentroid.rememberId) {
+ return UPLOAD_CENTROID_ID_MISMATCH;
+ }
+ return RETURN_OK;
+}
+
+ReturnValue_t StarTrackerHandler::handleEraseReply() {
+ ReturnValue_t result = RETURN_OK;
+ result = handleActionReply();
+ if (result != RETURN_OK) {
+ return result;
+ }
+ const uint8_t* replyData = dataLinkLayer.getReply() + ACTION_DATA_OFFSET;
+ StarTracker::EraseReply eraseReply(replyData);
+ if (eraseReply.getRegion() != eraseCmd.rememberRegion) {
+ sif::warning << "StarTrackerHandler::handleEraseReply: Region mismatch" << std::endl;
+ return REGION_MISMATCH;
+ }
+ return result;
+}
+
+ReturnValue_t StarTrackerHandler::handleChecksumReply() {
+ ReturnValue_t result = RETURN_OK;
+ result = handleActionReply();
+ if (result != RETURN_OK) {
+ return result;
+ }
+ const uint8_t* replyData = dataLinkLayer.getReply() + ACTION_DATA_OFFSET;
+ StarTracker::ChecksumReply checksumReply(replyData);
+ if (checksumReply.getRegion() != checksumCmd.rememberRegion) {
+ sif::warning << "StarTrackerHandler::handleChecksumReply: Region mismatch" << std::endl;
+ return REGION_MISMATCH;
+ }
+ if (checksumReply.getAddress() != checksumCmd.rememberAddress) {
+ sif::warning << "StarTrackerHandler::handleChecksumReply: Address mismatch" << std::endl;
+ return ADDRESS_MISMATCH;
+ }
+ if (checksumReply.getLength() != checksumCmd.rememberLength) {
+ sif::warning << "StarTrackerHandler::handleChecksumReply: Length mismatch" << std::endl;
+ return LENGTH_MISSMATCH;
+ }
+ PoolReadGuard rg(&checksumSet);
+ checksumSet.checksum = checksumReply.getChecksum();
+ handleDeviceTM(&checksumSet, StarTracker::CHECKSUM);
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1
+ checksumReply.printChecksum();
+#endif /* OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1 */
+ return RETURN_OK;
+}
+
ReturnValue_t StarTrackerHandler::handlePingReply() {
ReturnValue_t result = RETURN_OK;
uint32_t pingId = 0;
@@ -1207,7 +1842,7 @@ ReturnValue_t StarTrackerHandler::handleTm(LocalPoolDataSetBase& dataset, size_t
if(status != StarTracker::STATUS_OK) {
sif::warning << "StarTrackerHandler::handleTm: Reply error: "
<< static_cast(status) << std::endl;
- return TM_REPLY_ERROR;
+ return REPLY_ERROR;
}
result = dataset.read(TIMEOUT_TYPE, MUTEX_TIMEOUT);
if (result != RETURN_OK) {
@@ -1232,6 +1867,37 @@ ReturnValue_t StarTrackerHandler::handleTm(LocalPoolDataSetBase& dataset, size_t
return result;
}
+ReturnValue_t StarTrackerHandler::handleActionReplySet(LocalPoolDataSetBase& dataset, size_t size) {
+ ReturnValue_t result = RETURN_OK;
+ uint8_t status = *(dataLinkLayer.getReply() + STATUS_OFFSET);
+ if(status != StarTracker::STATUS_OK) {
+ sif::warning << "StarTrackerHandler::handleActionReplySet: Reply error: "
+ << static_cast(status) << std::endl;
+ return REPLY_ERROR;
+ }
+ result = dataset.read(TIMEOUT_TYPE, MUTEX_TIMEOUT);
+ if (result != RETURN_OK) {
+ return result;
+ }
+ const uint8_t* reply = dataLinkLayer.getReply() + ACTION_DATA_OFFSET;
+ dataset.setValidityBufferGeneration(false);
+ result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE);
+ if (result != RETURN_OK) {
+ sif::warning << "StarTrackerHandler::handleActionReplySet Deserialization failed"
+ << std::endl;
+ }
+ dataset.setValidityBufferGeneration(true);
+ dataset.setValidity(true, true);
+ result = dataset.commit(TIMEOUT_TYPE, MUTEX_TIMEOUT);
+ if (result != RETURN_OK) {
+ return result;
+ }
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1
+ dataset.printSet();
+#endif
+ return result;
+}
+
void StarTrackerHandler::handleStartup(const uint8_t* parameterId) {
switch(*parameterId) {
case (StarTracker::ID::LIMITS): {
diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.h b/bsp_q7s/devices/startracker/StarTrackerHandler.h
index 7d22592e..65bd65b8 100644
--- a/bsp_q7s/devices/startracker/StarTrackerHandler.h
+++ b/bsp_q7s/devices/startracker/StarTrackerHandler.h
@@ -111,12 +111,28 @@ private:
static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xAC);
//! [EXPORT] : [COMMENT] Received version reply with invalid program ID
static const ReturnValue_t INVALID_PROGRAM = MAKE_RETURN_CODE(0xAD);
- //! [EXPORT] : [COMMENT] Status field of tm reply signals error
- static const ReturnValue_t TM_REPLY_ERROR = MAKE_RETURN_CODE(0xAE);
+ //! [EXPORT] : [COMMENT] Status field reply signals error
+ static const ReturnValue_t REPLY_ERROR = MAKE_RETURN_CODE(0xAE);
//! [EXPORT] : [COMMENT] Status field of contrast reply signals error
static const ReturnValue_t CONTRAST_REQ_FAILED = MAKE_RETURN_CODE(0xAE);
//! [EXPORT] : [COMMENT] Received command which is too short (some data is missing for proper execution)
static const ReturnValue_t COMMAND_TOO_SHORT = MAKE_RETURN_CODE(0xAF);
+ //! [EXPORT] : [COMMENT] Received command with invalid length (too few or too many parameters)
+ static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xB0);
+ //! [EXPORT] : [COMMENT] Region mismatch between send and received data
+ static const ReturnValue_t REGION_MISMATCH = MAKE_RETURN_CODE(0xB1);
+ //! [EXPORT] : [COMMENT] Address mismatch between send and received data
+ static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(0xB2);
+ //! [EXPORT] : [COMMENT] Length field mismatch between send and received data
+ static const ReturnValue_t lENGTH_MISMATCH = MAKE_RETURN_CODE(0xB3);
+ //! [EXPORT] : [COMMENT] Specified file does not exist
+ static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xB4);
+ //! [EXPORT] : [COMMENT] Reply to upload centroid does not match commanded centroid id
+ static const ReturnValue_t UPLOAD_CENTROID_ID_MISMATCH = MAKE_RETURN_CODE(0xB5);
+ //! [EXPORT] : [COMMENT] Download blob pixel command has invalid type field
+ static const ReturnValue_t INVALID_TYPE = MAKE_RETURN_CODE(0xB6);
+ //! [EXPORT] : [COMMENT] Received FPGA action command with invalid ID
+ static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xB7);
static const size_t MAX_PATH_SIZE = 50;
static const size_t MAX_FILE_NAME = 30;
@@ -147,6 +163,86 @@ private:
static const size_t MIN_LENGTH = 7;
};
+ class ReadCmd {
+ public:
+ static const uint8_t ADDRESS_OFFSET = 1;
+ static const uint8_t LENGTH_OFFSET = 5;
+ static const uint8_t FILE_OFFSET = 9;
+ // Minimum length of a read command (region, address, length and filename)
+ static const size_t MIN_LENGTH = 11;
+ };
+
+ class EraseCmd {
+ public:
+ static const uint8_t LENGTH = 1;
+ uint8_t rememberRegion = 0;
+ };
+
+ EraseCmd eraseCmd;
+
+ class UnlockCmd {
+ public:
+ static const uint8_t CODE_OFFSET = 1;
+ };
+
+ class ChecksumCmd {
+ public:
+ static const uint8_t ADDRESS_OFFSET = 1;
+ static const uint8_t LENGTH_OFFSET = 5;
+ // Length of checksum command
+ static const size_t LENGTH = 9;
+ uint8_t rememberRegion = 0;
+ uint32_t rememberAddress = 0;
+ uint32_t rememberLength = 0;
+ };
+
+ ChecksumCmd checksumCmd;
+
+ class SetTimeCmd {
+ public:
+ static const uint8_t LENGTH = 8;
+ };
+
+ class DownloadCentroidCmd {
+ public:
+ static const uint8_t LENGTH = 1;
+ };
+
+ class UploadCentroid {
+ public:
+ uint8_t rememberId = 0;
+ };
+
+ UploadCentroid uploadCentroid;
+
+ class DownloadMatchedStarCmd {
+ public:
+ static const uint8_t LENGTH = 1;
+ };
+
+ class DownloadDbImageCmd {
+ public:
+ static const uint8_t LENGTH = 1;
+ };
+
+ class DownloadBlobPixCmd {
+ public:
+ static const uint8_t LENGTH = 2;
+ static const uint8_t NORMAL = 0;
+ static const uint8_t FAST = 1;
+ };
+
+ class FpgaDownloadCmd {
+ public:
+ static const uint8_t MIN_LENGTH = 10;
+ };
+
+ class FpgaActionCmd {
+ public:
+ static const uint8_t LENGTH = 1;
+ static const uint8_t ID = 3;
+ };
+
MessageQueueIF* eventQueue = nullptr;
ArcsecDatalinkLayer dataLinkLayer;
@@ -159,6 +255,11 @@ private:
StarTracker::SolutionSet solutionSet;
StarTracker::HistogramSet histogramSet;
StarTracker::ContrastSet contrastSet;
+ StarTracker::ChecksumSet checksumSet;
+ StarTracker::DownloadCentroidSet downloadCentroidSet;
+ StarTracker::DownloadMatchedStar downloadMatchedStar;
+ StarTracker::DownloadDBImage downloadDbImage;
+ StarTracker::DownloadBlobPixel downloadBlobPixel;
// Pointer to object responsible for uploading and downloading images to/from the star tracker
StrHelper* strHelper = nullptr;
@@ -245,12 +346,61 @@ private:
*/
ReturnValue_t executeWriteCommand(const uint8_t* commandData, size_t commandDataLen);
+ /**
+ * @brief Starts the execution of the fpga download command
+ *
+ * @param commandData Pointer to buffer with command data
+ * @param commandDataLen Size of received command
+ */
+ ReturnValue_t executeFpgaDownloadCommand(const uint8_t* commandData, size_t commandDataLen);
+
+ /**
+ * @brief Extracts information for flash-read-command from TC data and starts execution of
+ * flash-read-procedure
+ *
+ * @param commandData Pointer to received command data
+ * @param commandDataLen Size of received command data
+ *
+ * @return RETURN_OK if start of execution was successful, otherwise error return value
+ */
+ ReturnValue_t executeReadCommand(const uint8_t* commandData, size_t commandDataLen);
+
/**
* @brief Fills command buffer with data to boot image (works only when star tracker is
* in bootloader mode).
*/
void prepareBootCommand();
+ /**
+ * @brief Fills command buffer with command to erase a flash region
+ */
+ ReturnValue_t prepareEraseCommand(const uint8_t* commandData, size_t commandDataLen);
+
+ /**
+ * @brief Fills command buffer with command to unlock flash region
+ */
+ ReturnValue_t prepareUnlockCommand(const uint8_t* commandData, size_t commandDataLen);
+
+ /**
+ * @brief Fills command buffer with command to get the checksum of a flash part
+ */
+ ReturnValue_t prepareChecksumCommand(const uint8_t* commandData, size_t commandDataLen);
+
+ /**
+ * @brief Fills command buffer with command to set the unix time
+ */
+ ReturnValue_t prepareSetTimeCommand(const uint8_t* commandData, size_t commandDataLen);
+
+ /**
+ * @brief Fills command buffer with command to request a centroid
+ */
+ ReturnValue_t prepareDownloadCentroidCommand(const uint8_t* commandData, size_t commandDataLen);
+
+ /**
+ * @brief Fills command buffer with command to upload a centroid for testing purpose
+ */
+ ReturnValue_t prepareUploadCentroidCommand(const uint8_t* commandData, size_t commandDataLen);
+
/**
* @brief Fills the command buffer with the command to take an image.
*/
@@ -319,11 +469,54 @@ private:
ReturnValue_t prepareParamCommand(const uint8_t* commandData, size_t commandDataLen,
ArcsecJsonParamBase& paramSet);
+ /**
+ * @brief Fills command buffer with data to request matched star.
+ */
+ ReturnValue_t prepareDownloadMatchedStarCommand(const uint8_t* commandData,
+ size_t commandDataLen);
+
+ /**
+ * @brief Fills command buffer with data to request matched star coordinates.
+ */
+ ReturnValue_t prepareDownloadDbImageCommand(const uint8_t* commandData,
+ size_t commandDataLen);
+
+ /**
+ * @brief Fills command buffer with data to request output of the blob filter algorithm.
+ */
+ ReturnValue_t prepareDownloadBlobPixelCommand(const uint8_t* commandData,
+ size_t commandDataLen);
+
+ /**
+ * @brief With this command the FPGA update will be applied to the star tracker
+ */
+ ReturnValue_t prepareFpgaActionCommand(const uint8_t* commandData, size_t commandDataLen);
+
+ /**
+ * @brief Handles action replies with datasets.
+ */
+ ReturnValue_t handleActionReplySet(LocalPoolDataSetBase& dataset, size_t size);
+
/**
* @brief Default function to handle action replies
*/
ReturnValue_t handleActionReply();
+ /**
+ * @brief Handles reply to upload centroid command
+ */
+ ReturnValue_t handleUploadCentroidReply();
+
+ /**
+ * @brief Handles reply to erase command
+ */
+ ReturnValue_t handleEraseReply();
+
+ /**
+ * @brief Handles reply to checksum command
+ */
+ ReturnValue_t handleChecksumReply();
+
/**
* @brief Handles all set parameter replies
*/
diff --git a/bsp_q7s/devices/startracker/StrHelper.cpp b/bsp_q7s/devices/startracker/StrHelper.cpp
index a3d28305..0be38ad7 100644
--- a/bsp_q7s/devices/startracker/StrHelper.cpp
+++ b/bsp_q7s/devices/startracker/StrHelper.cpp
@@ -63,6 +63,39 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) {
internalState = InternalState::IDLE;
break;
}
+ case InternalState::FLASH_READ: {
+ result = performFlashRead();
+ if (result == RETURN_OK){
+ triggerEvent(FLASH_READ_SUCCESSFUL);
+ }
+ else {
+ triggerEvent(FLASH_READ_FAILED);
+ }
+ internalState = InternalState::IDLE;
+ break;
+ }
+ case InternalState::DOWNLOAD_FPGA_IMAGE: {
+ result = performFpgaDownload();
+ if (result == RETURN_OK){
+ triggerEvent(FPGA_DOWNLOAD_SUCCESSFUL);
+ }
+ else {
+ triggerEvent(FPGA_DOWNLOAD_FAILED);
+ }
+ internalState = InternalState::IDLE;
+ break;
+ }
+ case InternalState::UPLOAD_FPGA_IMAGE: {
+ result = performFpgaUpload();
+ if (result == RETURN_OK){
+ triggerEvent(FPGA_UPLOAD_SUCCESSFUL);
+ }
+ else {
+ triggerEvent(FPGA_UPLOAD_FAILED);
+ }
+ internalState = InternalState::IDLE;
+ break;
+ }
default:
sif::debug << "StrHelper::performOperation: Invalid state" << std::endl;
break;
@@ -83,30 +116,30 @@ void StrHelper::setComCookie(CookieIF* comCookie_) {
comCookie = comCookie_;
}
-ReturnValue_t StrHelper::startImageUpload(std::string uploadImage_) {
- ReturnValue_t result = checkPath(uploadImage_);
+ReturnValue_t StrHelper::startImageUpload(std::string fullname) {
+ ReturnValue_t result = checkPath(fullname);
if (result != RETURN_OK) {
return result;
}
- uploadImage = uploadImage_;
- if(not std::filesystem::exists(uploadImage)) {
+ uploadImage.uploadFile = fullname;
+ if(not std::filesystem::exists(fullname)) {
return FILE_NOT_EXISTS;
}
- internalState = InternalState::UPLOAD_IMAGE;
+ internalState = InternalState::UPLOAD_FPGA_IMAGE;
semaphore.release();
terminate = false;
return RETURN_OK;
}
-ReturnValue_t StrHelper::startImageDownload(std::string downloadPath_) {
- ReturnValue_t result = checkPath(downloadPath_);
+ReturnValue_t StrHelper::startImageDownload(std::string path) {
+ ReturnValue_t result = checkPath(path);
if (result != RETURN_OK) {
return result;
}
- if(not std::filesystem::exists(downloadPath_)) {
+ if(not std::filesystem::exists(path)) {
return PATH_NOT_EXISTS;
}
- downloadPath = downloadPath_;
+ downloadImage.path = path;
internalState = InternalState::DOWNLOAD_IMAGE;
terminate = false;
semaphore.release();
@@ -117,39 +150,87 @@ void StrHelper::stopProcess() {
terminate = true;
}
-void StrHelper::setDownloadImageName(std::string image) {
- downloadImage = image;
+void StrHelper::setDownloadImageName(std::string filename) {
+ downloadImage.filename = filename;
}
-ReturnValue_t StrHelper::startFlashWrite(std::string flashWriteFile_, uint8_t region,
- uint32_t flashWriteAddress) {
- ReturnValue_t result = checkPath(flashWriteFile_);
+void StrHelper::setFlashReadFilename(std::string filename) {
+ flashRead.filename = filename;
+}
+
+void StrHelper::setDownloadFpgaImage(std::string filename) {
+ fpgaDownload.fileName = filename;
+}
+
+ReturnValue_t StrHelper::startFlashWrite(std::string fullname, uint8_t region,
+ uint32_t address) {
+ ReturnValue_t result = checkPath(fullname);
if (result != RETURN_OK) {
return result;
}
- flashWriteFile = flashWriteFile_;
- if(not std::filesystem::exists(flashWriteFile)) {
+ flashWrite.fullname = fullname;
+ if(not std::filesystem::exists(flashWrite.fullname)) {
return FILE_NOT_EXISTS;
}
+ flashWrite.address = address;
+ flashWrite.region = region;
internalState = InternalState::FLASH_WRITE;
semaphore.release();
terminate = false;
return RETURN_OK;
}
+ReturnValue_t StrHelper::startFlashRead(std::string path, uint8_t region,
+ uint32_t address, uint32_t length) {
+ ReturnValue_t result = checkPath(path);
+ if (result != RETURN_OK) {
+ return result;
+ }
+ flashRead.path = path;
+ if(not std::filesystem::exists(flashRead.path)) {
+ return FILE_NOT_EXISTS;
+ }
+ flashRead.address = address;
+ flashRead.region = region;
+ flashRead.size = length;
+ internalState = InternalState::FLASH_READ;
+ semaphore.release();
+ terminate = false;
+ return RETURN_OK;
+}
+
+ReturnValue_t StrHelper::startFpgaDownload(std::string path, uint32_t startPosition,
+ uint32_t length) {
+ fpgaDownload.path = path;
+ fpgaDownload.startPosition = startPosition;
+ fpgaDownload.length = length;
+ internalState = InternalState::DOWNLOAD_FPGA_IMAGE;
+ semaphore.release();
+ terminate = false;
+ return RETURN_OK;
+}
+
+ReturnValue_t StrHelper::startFpgaUpload(std::string uploadFile) {
+ fpgaUpload.uploadFile = uploadFile;
+ internalState = InternalState::UPLOAD_FPGA_IMAGE;
+ semaphore.release();
+ terminate = false;
+ return RETURN_OK;
+}
+
ReturnValue_t StrHelper::performImageDownload() {
ReturnValue_t result;
struct DownloadActionRequest downloadReq;
uint32_t size = 0;
uint32_t retries = 0;
Timestamp timestamp;
- std::string image = downloadPath + "/" + timestamp.str() + downloadImage ;
+ std::string image = downloadImage.path + "/" + timestamp.str() + downloadImage.filename ;
std::ofstream file(image, std::ios_base::app | std::ios_base::out);
if(not std::filesystem::exists(image)) {
return FILE_CREATION_FAILED;
}
downloadReq.position = 0;
- while(downloadReq.position < LAST_POSITION) {
+ while(downloadReq.position < ImageDownload::LAST_POSITION) {
if (terminate) {
return RETURN_OK;
}
@@ -164,7 +245,7 @@ ReturnValue_t StrHelper::performImageDownload() {
file.close();
return result;
}
- result = checkReply();
+ result = checkActionReply();
if (result != RETURN_OK) {
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
uartComIF->flushUartRxBuffer(comCookie);
@@ -184,7 +265,7 @@ ReturnValue_t StrHelper::performImageDownload() {
file.close();
return result;
}
- file.write(reinterpret_cast(datalinkLayer.getReply() + DATA_OFFSET),
+ file.write(reinterpret_cast(datalinkLayer.getReply() + IMAGE_DATA_OFFSET),
IMAGE_DATA_SIZE);
downloadReq.position++;
retries = 0;
@@ -200,12 +281,12 @@ ReturnValue_t StrHelper::performImageUpload() {
struct UploadActionRequest uploadReq;
uploadReq.position = 0;
std::memset(&uploadReq.data, 0, sizeof(uploadReq.data));
- if (not std::filesystem::exists(uploadImage)) {
+ if (not std::filesystem::exists(uploadImage.uploadFile)) {
triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast(internalState));
internalState = InternalState::IDLE;
return RETURN_FAILED;
}
- std::ifstream file(uploadImage, std::ifstream::binary);
+ std::ifstream file(uploadImage.uploadFile, std::ifstream::binary);
// Set position of next character to end of file input stream
file.seekg(0, file.end);
// tellg returns position of character in input stream
@@ -221,7 +302,7 @@ ReturnValue_t StrHelper::performImageUpload() {
if (result != RETURN_OK) {
return RETURN_FAILED;
}
- result = checkReply();
+ result = checkActionReply();
if (result != RETURN_OK) {
return result;
}
@@ -238,7 +319,7 @@ ReturnValue_t StrHelper::performImageUpload() {
if (result != RETURN_OK) {
return RETURN_FAILED;
}
- result = checkReply();
+ result = checkActionReply();
if (result != RETURN_OK) {
return result;
}
@@ -251,17 +332,17 @@ ReturnValue_t StrHelper::performFlashWrite() {
uint32_t remainingBytes = 0;
uint32_t fileSize = 0;
struct WriteActionRequest req;
- if (not std::filesystem::exists(flashWriteFile)) {
+ if (not std::filesystem::exists(flashWrite.fullname)) {
triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast(internalState));
internalState = InternalState::IDLE;
return RETURN_FAILED;
}
- std::ifstream file(flashWriteFile, std::ifstream::binary);
+ std::ifstream file(flashWrite.fullname, std::ifstream::binary);
file.seekg(0, file.end);
fileSize = file.tellg();
remainingBytes = fileSize;
- req.region = flashWriteRegion;
- req.address = flashWriteAddress;
+ req.region = flashWrite.region;
+ req.address = flashWrite.address;
req.length = MAX_FLASH_DATA;
while(remainingBytes >= MAX_FLASH_DATA) {
if (terminate) {
@@ -274,7 +355,7 @@ ReturnValue_t StrHelper::performFlashWrite() {
if (result != RETURN_OK) {
return RETURN_FAILED;
}
- result = checkFlashWriteReply(req);
+ result = checkFlashActionReply(req.region, req.address, req.length);
if (result != RETURN_OK) {
return result;
}
@@ -288,13 +369,170 @@ ReturnValue_t StrHelper::performFlashWrite() {
if (result != RETURN_OK) {
return RETURN_FAILED;
}
- result = checkFlashWriteReply(req);
+ result = checkFlashActionReply(req.region, req.address, req.length);
if (result != RETURN_OK) {
return result;
}
return RETURN_OK;
}
+ReturnValue_t StrHelper::performFlashRead() {
+ ReturnValue_t result;
+ struct ReadActionRequest req;
+ uint32_t bytesRead = 0;
+ uint32_t size = 0;
+ uint32_t retries = 0;
+ Timestamp timestamp;
+ std::string fullname = flashRead.path + "/" + timestamp.str() + flashRead.filename ;
+ std::ofstream file(fullname, std::ios_base::app | std::ios_base::out);
+ if (not std::filesystem::exists(fullname)) {
+ return FILE_CREATION_FAILED;
+ }
+ req.region = flashRead.region;
+ while(bytesRead < flashRead.size) {
+ if (terminate) {
+ return RETURN_OK;
+ }
+ if ((flashRead.size - bytesRead) < MAX_FLASH_DATA) {
+ req.length = flashRead.size - bytesRead;
+ }
+ else {
+ req.length = MAX_FLASH_DATA;
+ }
+ req.address = flashRead.address + bytesRead;
+ arc_pack_read_action_req(&req, commandBuffer, &size);
+ result = sendAndRead(size, req.address);
+ if (result != RETURN_OK) {
+ if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
+ uartComIF->flushUartRxBuffer(comCookie);
+ retries++;
+ continue;
+ }
+ file.close();
+ return result;
+ }
+ result = checkActionReply();
+ if (result != RETURN_OK) {
+ if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
+ uartComIF->flushUartRxBuffer(comCookie);
+ retries++;
+ continue;
+ }
+ file.close();
+ return result;
+ }
+ result = checkFlashActionReply(req.region, req.address, req.length);
+ if (result != RETURN_OK) {
+ if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
+ uartComIF->flushUartRxBuffer(comCookie);
+ retries++;
+ continue;
+ }
+ file.close();
+ return result;
+ }
+ file.write(reinterpret_cast(datalinkLayer.getReply() + FLASH_READ_DATA_OFFSET),
+ req.length);
+ bytesRead += req.length;
+ retries = 0;
+ }
+ file.close();
+ return RETURN_OK;
+}
+
+ReturnValue_t StrHelper::performFpgaDownload() {
+ ReturnValue_t result;
+ struct DownloadFPGAImageActionRequest req;
+ uint32_t size = 0;
+ uint32_t retries = 0;
+ Timestamp timestamp;
+ std::string image = fpgaDownload.path + "/" + timestamp.str() + fpgaDownload.fileName;
+ std::ofstream file(image, std::ios_base::app | std::ios_base::out);
+ if(not std::filesystem::exists(image)) {
+ return FILE_CREATION_FAILED;
+ }
+ req.pos = fpgaDownload.startPosition;
+ while(req.pos < fpgaDownload.length) {
+ if (terminate) {
+ return RETURN_OK;
+ }
+ if (fpgaDownload.length - req.pos >= FpgaDownload::MAX_DATA) {
+ req.length = FpgaDownload::MAX_DATA;
+ }
+ else {
+ req.length = fpgaDownload.length - req.pos;
+ }
+ arc_pack_downloadfpgaimage_action_req(&req, commandBuffer, &size);
+ result = sendAndRead(size, req.pos);
+ if (result != RETURN_OK) {
+ if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
+ uartComIF->flushUartRxBuffer(comCookie);
+ retries++;
+ continue;
+ }
+ file.close();
+ return result;
+ }
+ result = checkFpgaActionReply(req.pos, req.length);
+ if (result != RETURN_OK) {
+ if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
+ uartComIF->flushUartRxBuffer(comCookie);
+ retries++;
+ continue;
+ }
+ file.close();
+ return result;
+ }
+ file.write(reinterpret_cast(datalinkLayer.getReply() + FpgaDownload::DATA_OFFSET),
+ req.length);
+ req.pos += req.length;
+ retries = 0;
+ }
+ file.close();
+ return RETURN_OK;
+}
+
+ReturnValue_t StrHelper::performFpgaUpload() {
+ ReturnValue_t result = RETURN_OK;
+ uint32_t commandSize = 0;
+ uint32_t bytesUploaded = 0;
+ uint32_t fileSize = 0;
+ struct UploadFPGAImageActionRequest req;
+ if (not std::filesystem::exists(fpgaUpload.uploadFile)) {
+ triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast(internalState));
+ internalState = InternalState::IDLE;
+ return RETURN_FAILED;
+ }
+ std::ifstream file(flashWrite.fullname, std::ifstream::binary);
+ file.seekg(0, file.end);
+ fileSize = file.tellg();
+ req.pos = 0;
+ while(bytesUploaded <= fileSize) {
+ if (terminate) {
+ return RETURN_OK;
+ }
+ if (fileSize - bytesUploaded > FpgaUpload::MAX_DATA) {
+ req.length = FpgaUpload::MAX_DATA;
+ }
+ else {
+ req.length = fileSize - bytesUploaded;
+ }
+ file.seekg(bytesUploaded, file.beg);
+ file.read(reinterpret_cast(req.data), req.length);
+ arc_pack_uploadfpgaimage_action_req(&req, commandBuffer, &commandSize);
+ result = sendAndRead(commandSize, req.pos);
+ if (result != RETURN_OK) {
+ return RETURN_FAILED;
+ }
+ result = checkFpgaActionReply(req.pos, req.length);
+ if (result != RETURN_OK) {
+ return result;
+ }
+ bytesUploaded += req.length;
+ }
+ return RETURN_OK;
+}
+
ReturnValue_t StrHelper::sendAndRead(size_t size, uint32_t parameter) {
ReturnValue_t result = RETURN_OK;
ReturnValue_t decResult = RETURN_OK;
@@ -351,19 +589,18 @@ ReturnValue_t StrHelper::sendAndRead(size_t size, uint32_t parameter) {
return RETURN_OK;
}
-ReturnValue_t StrHelper::checkReply() {
+ReturnValue_t StrHelper::checkActionReply() {
uint8_t type = datalinkLayer.getReplyFrameType();
if (type != TMTC_ACTIONREPLY) {
- sif::warning << "StrHelper::checkReply: Received reply with invalid type ID"
+ sif::warning << "StrHelper::checkActionReply: Received reply with invalid type ID"
<< std::endl;
- triggerEvent(INVALID_TYPE_ID);
- return RETURN_FAILED;
+ return INVALID_TYPE_ID;
}
uint8_t status = datalinkLayer.getStatusField();
if (status != ArcsecDatalinkLayer::STATUS_OK) {
- triggerEvent(STATUS_ERROR);
- sif::warning << "StrHelper::checkReply: Status failure" << std::endl;
- return RETURN_FAILED;
+ sif::warning << "StrHelper::checkActionReply: Status failure: "
+ << static_cast(status) << std::endl;
+ return STATUS_ERROR;
}
return RETURN_OK;
}
@@ -378,8 +615,13 @@ ReturnValue_t StrHelper::checkReplyPosition(uint32_t expectedPosition) {
return RETURN_OK;
}
-ReturnValue_t StrHelper::checkFlashWriteReply(struct WriteActionRequest& req) {
+ReturnValue_t StrHelper::checkFlashActionReply(uint8_t region_, uint32_t address_,
+ uint16_t length_) {
ReturnValue_t result = RETURN_OK;
+ result = checkActionReply();
+ if (result != RETURN_OK) {
+ return result;
+ }
const uint8_t* data = datalinkLayer.getReply();
uint8_t region = *(data + REGION_OFFSET);
uint32_t address;
@@ -388,8 +630,9 @@ ReturnValue_t StrHelper::checkFlashWriteReply(struct WriteActionRequest& req) {
result = SerializeAdapter::deSerialize(&address, &addressData, &size,
SerializeIF::Endianness::LITTLE);
if (result != RETURN_OK) {
- sif::warning << "StrHelper::checkFlashWriteReply: Deserialization of address failed"
+ sif::warning << "StrHelper::checkFlashActionReply: Deserialization of address failed"
<< std::endl;
+ return result;
}
uint16_t length;
size = sizeof(length);
@@ -397,21 +640,50 @@ ReturnValue_t StrHelper::checkFlashWriteReply(struct WriteActionRequest& req) {
result = SerializeAdapter::deSerialize(&length, lengthData, &size,
SerializeIF::Endianness::LITTLE);
if (result != RETURN_OK) {
- sif::warning << "StrHelper::checkFlashWriteReply: Deserialization of length failed"
+ sif::warning << "StrHelper::checkFlashActionReply: Deserialization of length failed"
<< std::endl;
}
- if (region != req.region) {
+ if (region != region_) {
return REGION_MISMATCH;
}
- if (address != req.address) {
+ if (address != address_) {
return ADDRESS_MISMATCH;
}
- if (region != req.length) {
+ if (length != length_) {
return LENGTH_MISMATCH;
}
return RETURN_OK;
}
+ReturnValue_t StrHelper::checkFpgaActionReply(uint32_t expectedPosition,
+ uint32_t expectedLength) {
+ ReturnValue_t result = RETURN_OK;
+ result = checkActionReply();
+ if (result != RETURN_OK) {
+ return result;
+ }
+ const uint8_t* data = datalinkLayer.getReply() + ACTION_DATA_OFFSET;
+ uint32_t position;
+ size_t size = sizeof(position);
+ result = SerializeAdapter::deSerialize(&position, &data, &size,
+ SerializeIF::Endianness::LITTLE);
+ if (result != RETURN_OK) {
+ sif::warning << "StrHelper::checkFpgaActionReply: Deserialization of position failed"
+ << std::endl;
+ return result;
+ }
+ uint32_t length;
+ size = sizeof(length);
+ result = SerializeAdapter::deSerialize(&length, &data, &size,
+ SerializeIF::Endianness::LITTLE);
+ if (result != RETURN_OK) {
+ sif::warning << "StrHelper::checkFpgaActionReply: Deserialization of length failed"
+ << std::endl;
+ return result;
+ }
+ return result;
+}
+
ReturnValue_t StrHelper::checkPath(std::string name) {
if (name.substr(0, sizeof(SdCardManager::SD_0_MOUNT_POINT))
== std::string(SdCardManager::SD_0_MOUNT_POINT)) {
diff --git a/bsp_q7s/devices/startracker/StrHelper.h b/bsp_q7s/devices/startracker/StrHelper.h
index f7a994b4..e140a4d6 100644
--- a/bsp_q7s/devices/startracker/StrHelper.h
+++ b/bsp_q7s/devices/startracker/StrHelper.h
@@ -28,7 +28,7 @@ public:
static const Event IMAGE_UPLOAD_FAILED = MAKE_EVENT(0, severity::LOW);
//! [EXPORT] : [COMMENT] Image download failed
static const Event IMAGE_DOWNLOAD_FAILED = MAKE_EVENT(1, severity::LOW);
- //! [EXPORT] : [COMMENT] Uploading image to star tracker was successful
+ //! [EXPORT] : [COMMENT] Uploading image to star tracker was successfulop
static const Event IMAGE_UPLOAD_SUCCESSFUL = MAKE_EVENT(2, severity::LOW);
//! [EXPORT] : [COMMENT] Image download was successful
static const Event IMAGE_DOWNLOAD_SUCCESSFUL = MAKE_EVENT(3, severity::LOW);
@@ -40,39 +40,43 @@ public:
static const Event FLASH_WRITE_FAILED = MAKE_EVENT(6, severity::LOW);
//! [EXPORT] : [COMMENT] Flash read procedure failed
static const Event FLASH_READ_FAILED = MAKE_EVENT(7, severity::LOW);
+ //! [EXPORT] : [COMMENT] Download of FPGA image successful
+ static const Event FPGA_DOWNLOAD_SUCCESSFUL = MAKE_EVENT(8, severity::LOW);
+ //! [EXPORT] : [COMMENT] Download of FPGA image failed
+ static const Event FPGA_DOWNLOAD_FAILED = MAKE_EVENT(9, severity::LOW);
+ //! [EXPORT] : [COMMENT] Upload of FPGA image successful
+ static const Event FPGA_UPLOAD_SUCCESSFUL = MAKE_EVENT(10, severity::LOW);
+ //! [EXPORT] : [COMMENT] Upload of FPGA image failed
+ static const Event FPGA_UPLOAD_FAILED = MAKE_EVENT(11, severity::LOW);
//! [EXPORT] : [COMMENT] 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
- static const Event STR_HELPER_READING_REPLY_FAILED = MAKE_EVENT(8, severity::LOW);
+ static const Event STR_HELPER_READING_REPLY_FAILED = MAKE_EVENT(12, severity::LOW);
//! [EXPORT] : [COMMENT] Unexpected stop of decoding sequence
//!P1: Return code of failed communication interface read call
//!P1: Upload/download position for which the read call failed
- static const Event STR_HELPER_COM_ERROR = MAKE_EVENT(9, severity::LOW);
+ static const Event STR_HELPER_COM_ERROR = MAKE_EVENT(13, severity::LOW);
//! [EXPORT] : [COMMENT] Star tracker did not send replies (maybe device is powered off)
//!P1: Position of upload or download packet for which no reply was sent
- static const Event STR_HELPER_NO_REPLY = MAKE_EVENT(10, severity::LOW);
- //! [EXPORT] : [COMMENT] Received reply with invalid type ID
- static const Event INVALID_TYPE_ID = MAKE_EVENT(11, severity::LOW);
- //! [EXPORT] : [COMMENT] Status field in reply signals error
- static const Event STATUS_ERROR = MAKE_EVENT(12, severity::LOW);
+ static const Event STR_HELPER_NO_REPLY = MAKE_EVENT(14, severity::LOW);
//! [EXPORT] : [COMMENT] 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
- static const Event STR_HELPER_DEC_ERROR = MAKE_EVENT(13, severity::LOW);
+ static const Event STR_HELPER_DEC_ERROR = MAKE_EVENT(15, severity::LOW);
//! [EXPORT] : [COMMENT] Position mismatch
//! P1: The expected position and thus the position for which the image upload/download failed
- static const Event POSITION_MISMATCH = MAKE_EVENT(14, severity::LOW);
+ static const Event POSITION_MISMATCH = MAKE_EVENT(16, severity::LOW);
//! [EXPORT] : [COMMENT] Specified file does not exist
//!P1: Internal state of str helper
- static const Event STR_HELPER_FILE_NOT_EXISTS = MAKE_EVENT(15, severity::LOW);
+ static const Event STR_HELPER_FILE_NOT_EXISTS = MAKE_EVENT(17, severity::LOW);
//! [EXPORT] : [COMMENT] Sending packet to star tracker failed
//!P1: Return code of communication interface sendMessage function
//!P2: Position of upload/download packet, or address of flash write/read request for which sending failed
- static const Event STR_HELPER_SENDING_PACKET_FAILED = MAKE_EVENT(16, severity::LOW);
+ static const Event STR_HELPER_SENDING_PACKET_FAILED = MAKE_EVENT(18, severity::LOW);
//! [EXPORT] : [COMMENT] Communication interface requesting reply failed
//!P1: Return code of failed request
//!P1: Upload/download position, or address of flash write/read request for which transmission failed
- static const Event STR_HELPER_REQUESTING_MSG_FAILED = MAKE_EVENT(17, severity::LOW);
+ static const Event STR_HELPER_REQUESTING_MSG_FAILED = MAKE_EVENT(19, severity::LOW);
StrHelper(object_id_t objectId);
virtual ~StrHelper();
@@ -86,27 +90,54 @@ public:
/**
* @brief Starts sequence to upload image to star tracker
*
- * @param image Name including absolute path if to image to upload. Must be previously
- * transferred to the OBC with the CFDP protocoll.
+ * @param uploadImage_ Name including absolute path of the image to upload. Must be previously
+ * transferred to the OBC with the CFDP protocol.
*/
ReturnValue_t startImageUpload(std::string uploadImage_);
/**
* @brief Calling this function initiates the download of an image from the star tracker.
*
- * @param Name of the image which will be created
+ * @param path Path where downloaded image will be stored
*/
- ReturnValue_t startImageDownload(std::string downloadPath_);
+ ReturnValue_t startImageDownload(std::string path);
/**
* @brief Starts the flash write procedure
*
- * @param flashWriteFile_ Full name including absolute path of file to write to flash
+ * @param fullname Full name including absolute path of file to write to flash
* @param region Region ID of flash region to write to
- * @param flashWriteAddress Start address of flash write procedure
+ * @param address Start address of flash write procedure
*/
- ReturnValue_t startFlashWrite(std::string flashWriteFile_, uint8_t region,
- uint32_t flashWriteAddress);
+ ReturnValue_t startFlashWrite(std::string fullname, uint8_t region, uint32_t address);
+
+ /**
+ * @brief Starts the flash read procedure
+ *
+ * @param path Path where file with read flash data will be created
+ * @param region Region ID of flash region to read from
+ * @param address Start address of flash section to read
+ * @param length Number of bytes to read from flash
+ */
+ ReturnValue_t startFlashRead(std::string path, uint8_t region, uint32_t address,
+ uint32_t length);
+
+ /**
+ * @brief Starts the download of the FPGA image
+ *
+ * @param path The path where the file with the downloaded data will be created
+ * @param startPosition Offset in fpga image to read from
+ * @param length Number of bytes to dwonload from the FPGA image
+ *
+ */
+ ReturnValue_t startFpgaDownload(std::string path, uint32_t startPosition, uint32_t length);
+
+ /**
+ * @brief Starts upload of new image to FPGA
+ *
+ * @param uploadFile Full name of file containing FPGA image data
+ */
+ ReturnValue_t startFpgaUpload(std::string uploadFile);
/**
* @brief Can be used to interrupt a running data transfer.
@@ -116,7 +147,17 @@ public:
/**
* @brief Changes the dafault name of downloaded images
*/
- void setDownloadImageName(std::string image);
+ void setDownloadImageName(std::string filename);
+
+ /**
+ * @brief Sets the name of the file which will be created to store the data read from flash
+ */
+ void setFlashReadFilename(std::string filename);
+
+ /**
+ * @brief Set download FPGA image name
+ */
+ void setDownloadFpgaImage(std::string filename);
private:
@@ -136,16 +177,48 @@ private:
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
static const size_t SIZE_IMAGE_PART = 1024;
- static const uint32_t LAST_POSITION = 4095;
+ class ImageDownload {
+ public:
+ static const uint32_t LAST_POSITION = 4095;
+ };
+
+ class FpgaDownload {
+ public:
+ static const uint16_t MAX_DATA = 1024;
+ static const uint8_t DATA_OFFSET = 10;
+ // Start position of fpga image part to download
+ uint32_t startPosition = 0;
+ // Length of image part to download
+ uint32_t length = 0;
+ // Path where downloaded FPGA image will be stored
+ std::string path;
+ // Name of file containing downloaded FPGA image
+ std::string fileName = "fpgaimage.bin";
+ };
+ FpgaDownload fpgaDownload;
+
+ class FpgaUpload {
+ public:
+ static const uint32_t MAX_DATA = 1024;
+ // Full name of file to upload
+ std::string uploadFile;
+ };
+ FpgaUpload fpgaUpload;
static const uint32_t MAX_POLLS = 10000;
+ static const uint8_t ACTION_DATA_OFFSET = 2;
static const uint8_t POS_OFFSET = 2;
- static const uint8_t DATA_OFFSET = 5;
+ static const uint8_t IMAGE_DATA_OFFSET = 5;
+ static const uint8_t FLASH_READ_DATA_OFFSET = 8;
static const uint8_t REGION_OFFSET = 2;
static const uint8_t ADDRESS_OFFSET = 3;
static const uint8_t LENGTH_OFFSET = 7;
@@ -158,7 +231,9 @@ private:
UPLOAD_IMAGE,
DOWNLOAD_IMAGE,
FLASH_WRITE,
- FLASH_READ
+ FLASH_READ,
+ DOWNLOAD_FPGA_IMAGE,
+ UPLOAD_FPGA_IMAGE
};
InternalState internalState = InternalState::IDLE;
@@ -167,24 +242,49 @@ private:
BinarySemaphore semaphore;
- // Name including absolute path of image to upload
- std::string uploadImage;
- // Path where the downloaded image will be stored
- std::string downloadPath;
- // File which contains data to write when executing the flash write command
- std::string flashWriteFile;
- // Path where the file containing the read data will be stored
- std::string flashReadFilePath = "";
+ class UploadImage {
+ public:
+ // Name including absolute path of image to upload
+ std::string uploadFile;
+ };
+ UploadImage uploadImage;
- // Default name of downloaded image, can be changed via command
- std::string downloadImage = "image";
- // Default name of file containing the data read from flash, can be changed via command
- std::string flashReadImage = "flashread";
- // Will be set with the flash write command
- uint8_t flashWriteRegion = 0;
- // Will be set with the flash write command and specifies the start address where to write the
- // flash data to
- uint32_t flashWriteAddress = 0;
+ class DownloadImage {
+ public:
+ // Path where the downloaded image will be stored
+ std::string path;
+ // Default name of downloaded image, can be changed via command
+ std::string filename = "image.bin";
+ };
+ DownloadImage downloadImage;
+
+ class FlashWrite {
+ public:
+ // File which contains data to write when executing the flash write command
+ std::string fullname;
+ // Will be set with the flash write command
+ uint8_t region = 0;
+ // Will be set with the flash write command and specifies the start address where to write the
+ // flash data to
+ uint32_t address = 0;
+ };
+ FlashWrite flashWrite;
+
+ class FlashRead {
+ public:
+ // Path where the file containing the read data will be stored
+ std::string path = "";
+ // Default name of file containing the data read from flash, can be changed via command
+ std::string filename = "flashread.bin";
+ // Will be set with the flash read command
+ uint8_t region = 0;
+ // Will be set with the flash read command and specifies the start address of the flash section
+ // to read
+ uint32_t address = 0;
+ // Number of bytes to read from flash
+ uint32_t size = 0;
+ };
+ FlashRead flashRead;
SdCardManager* sdcMan = nullptr;
@@ -225,6 +325,24 @@ private:
*/
ReturnValue_t performFlashWrite();
+ /**
+ * @brief Sends a sequence of commands to the star tracker to read larger parts from the
+ * flash memory.
+ */
+ ReturnValue_t performFlashRead();
+
+ /**
+ * @brief Performs the download of the FPGA image which requires to be slip over multiple
+ * action requests.
+ */
+ ReturnValue_t performFpgaDownload();
+
+ /**
+ * @brief Performs upload of new FPGA image. Upload sequence split over multiple commands
+ * because one command can only transport 1024 bytes of image data.
+ */
+ ReturnValue_t performFpgaUpload();
+
/**
* @brief Sends packet to the star tracker and reads reply by using the communication
* interface
@@ -237,11 +355,11 @@ private:
ReturnValue_t sendAndRead(size_t size, uint32_t parameter);
/**
- * @brief Checks the reply header (type id and status fields)
+ * @brief Checks the header (type id and status fields) of the action reply
*
* @return RETURN_OK if reply confirms success of packet transfer, otherwise REUTRN_FAILED
*/
- ReturnValue_t checkReply();
+ ReturnValue_t checkActionReply();
/**
* @brief Checks the position field in a star tracker upload/download reply.
@@ -253,12 +371,20 @@ private:
ReturnValue_t checkReplyPosition(uint32_t expectedPosition);
/**
- * @brief Checks the region, address and length value of a flash write reply.
+ * @brief Checks the region, address and length value of a flash write or read reply.
*
* @return RETURN_OK if values match expected values, otherwise appropriate error return
* value.
*/
- ReturnValue_t checkFlashWriteReply(struct WriteActionRequest& req);
+ ReturnValue_t checkFlashActionReply(uint8_t region_, uint32_t address_, uint16_t length_);
+
+ /**
+ * @brief Checks the reply to the fpga download and upload request
+ *
+ * @param expectedPosition The expected position value in the reply
+ * @param expectedLength The expected length field in the reply
+ */
+ ReturnValue_t checkFpgaActionReply(uint32_t expectedPosition, uint32_t expectedLength);
/**
* @brief Checks if a path points to an sd card and whether the SD card is monuted.
diff --git a/common/config/commonClassIds.h b/common/config/commonClassIds.h
index 4c769260..cd90272d 100644
--- a/common/config/commonClassIds.h
+++ b/common/config/commonClassIds.h
@@ -25,6 +25,7 @@ enum commonClassIds: uint8_t {
PDEC_HANDLER, //PDEC
CCSDS_HANDLER, //CCSDS
ARCSEC_JSON_BASE, //JSONBASE
+ NVM_PARAM_BASE, //NVMB
COMMON_CLASS_ID_END // [EXPORT] : [END]
};
diff --git a/generators/bsp_q7s_events.csv b/generators/bsp_q7s_events.csv
index a2a4784a..cdf4d181 100644
--- a/generators/bsp_q7s_events.csv
+++ b/generators/bsp_q7s_events.csv
@@ -120,19 +120,21 @@
11904;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/linux/obc/PdecHandler.h
12000;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
12001;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
-12002;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successful;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12002;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
12003;IMAGE_DOWNLOAD_SUCCESSFUL;LOW;Image download was successful;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
12004;FLASH_WRITE_SUCCESSFUL;LOW;Finished flash write procedure successfully;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
12005;FLASH_READ_SUCCESSFUL;LOW;Finished flash read procedure successfully;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
12006;FLASH_WRITE_FAILED;LOW;Flash write procedure failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
12007;FLASH_READ_FAILED;LOW;Flash read procedure failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
-12008;STR_HELPER_READING_REPLY_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
-12009;STR_HELPER_COM_ERROR;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
-12010;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;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
-12011;INVALID_TYPE_ID;LOW;Received reply with invalid type ID;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
-12012;STATUS_ERROR;LOW;Status field in reply signals error;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
-12013;STR_HELPER_DEC_ERROR;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
-12014;POSITION_MISMATCH;LOW;Position mismatch P1: The expected position and thus the position for which the image upload/download failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
-12015;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not existP1: Internal state of str helper;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
-12016;STR_HELPER_SENDING_PACKET_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
-12017;STR_HELPER_REQUESTING_MSG_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12008;FPGA_DOWNLOAD_SUCCESSFUL;LOW;Download of FPGA image successful;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12009;FPGA_DOWNLOAD_FAILED;LOW;Download of FPGA image failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12010;FPGA_UPLOAD_SUCCESSFUL;LOW;Upload of FPGA image successful;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12011;FPGA_UPLOAD_FAILED;LOW;Upload of FPGA image failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12012;STR_HELPER_READING_REPLY_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12013;STR_HELPER_COM_ERROR;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12014;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;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12015;STR_HELPER_DEC_ERROR;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12016;POSITION_MISMATCH;LOW;Position mismatch P1: The expected position and thus the position for which the image upload/download failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12017;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not existP1: Internal state of str helper;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12018;STR_HELPER_SENDING_PACKET_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
+12019;STR_HELPER_REQUESTING_MSG_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h
diff --git a/generators/events/translateEvents.cpp b/generators/events/translateEvents.cpp
index 76159e0c..17150762 100644
--- a/generators/events/translateEvents.cpp
+++ b/generators/events/translateEvents.cpp
@@ -1,7 +1,7 @@
/**
- * @brief Auto-generated event translation file. Contains 138 translations.
+ * @brief Auto-generated event translation file. Contains 140 translations.
* @details
- * Generated on: 2021-12-21 17:08:50
+ * Generated on: 2021-12-29 20:24:08
*/
#include "translateEvents.h"
@@ -133,11 +133,13 @@ const char *FLASH_WRITE_SUCCESSFUL_STRING = "FLASH_WRITE_SUCCESSFUL";
const char *FLASH_READ_SUCCESSFUL_STRING = "FLASH_READ_SUCCESSFUL";
const char *FLASH_WRITE_FAILED_STRING = "FLASH_WRITE_FAILED";
const char *FLASH_READ_FAILED_STRING = "FLASH_READ_FAILED";
+const char *FPGA_DOWNLOAD_SUCCESSFUL_STRING = "FPGA_DOWNLOAD_SUCCESSFUL";
+const char *FPGA_DOWNLOAD_FAILED_STRING = "FPGA_DOWNLOAD_FAILED";
+const char *FPGA_UPLOAD_SUCCESSFUL_STRING = "FPGA_UPLOAD_SUCCESSFUL";
+const char *FPGA_UPLOAD_FAILED_STRING = "FPGA_UPLOAD_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_NO_REPLY_STRING = "STR_HELPER_NO_REPLY";
-const char *INVALID_TYPE_ID_STRING = "INVALID_TYPE_ID";
-const char *STATUS_ERROR_STRING = "STATUS_ERROR";
const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR";
const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH";
const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS";
@@ -403,24 +405,28 @@ const char * translateEvents(Event event) {
case(12007):
return FLASH_READ_FAILED_STRING;
case(12008):
- return STR_HELPER_READING_REPLY_FAILED_STRING;
+ return FPGA_DOWNLOAD_SUCCESSFUL_STRING;
case(12009):
- return STR_HELPER_COM_ERROR_STRING;
+ return FPGA_DOWNLOAD_FAILED_STRING;
case(12010):
- return STR_HELPER_NO_REPLY_STRING;
+ return FPGA_UPLOAD_SUCCESSFUL_STRING;
case(12011):
- return INVALID_TYPE_ID_STRING;
+ return FPGA_UPLOAD_FAILED_STRING;
case(12012):
- return STATUS_ERROR_STRING;
+ return STR_HELPER_READING_REPLY_FAILED_STRING;
case(12013):
- return STR_HELPER_DEC_ERROR_STRING;
+ return STR_HELPER_COM_ERROR_STRING;
case(12014):
- return POSITION_MISMATCH_STRING;
+ return STR_HELPER_NO_REPLY_STRING;
case(12015):
- return STR_HELPER_FILE_NOT_EXISTS_STRING;
+ return STR_HELPER_DEC_ERROR_STRING;
case(12016):
- return STR_HELPER_SENDING_PACKET_FAILED_STRING;
+ return POSITION_MISMATCH_STRING;
case(12017):
+ return STR_HELPER_FILE_NOT_EXISTS_STRING;
+ case(12018):
+ return STR_HELPER_SENDING_PACKET_FAILED_STRING;
+ case(12019):
return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
default:
return "UNKNOWN_EVENT";
diff --git a/linux/fsfwconfig/events/translateEvents.cpp b/linux/fsfwconfig/events/translateEvents.cpp
index 76159e0c..17150762 100644
--- a/linux/fsfwconfig/events/translateEvents.cpp
+++ b/linux/fsfwconfig/events/translateEvents.cpp
@@ -1,7 +1,7 @@
/**
- * @brief Auto-generated event translation file. Contains 138 translations.
+ * @brief Auto-generated event translation file. Contains 140 translations.
* @details
- * Generated on: 2021-12-21 17:08:50
+ * Generated on: 2021-12-29 20:24:08
*/
#include "translateEvents.h"
@@ -133,11 +133,13 @@ const char *FLASH_WRITE_SUCCESSFUL_STRING = "FLASH_WRITE_SUCCESSFUL";
const char *FLASH_READ_SUCCESSFUL_STRING = "FLASH_READ_SUCCESSFUL";
const char *FLASH_WRITE_FAILED_STRING = "FLASH_WRITE_FAILED";
const char *FLASH_READ_FAILED_STRING = "FLASH_READ_FAILED";
+const char *FPGA_DOWNLOAD_SUCCESSFUL_STRING = "FPGA_DOWNLOAD_SUCCESSFUL";
+const char *FPGA_DOWNLOAD_FAILED_STRING = "FPGA_DOWNLOAD_FAILED";
+const char *FPGA_UPLOAD_SUCCESSFUL_STRING = "FPGA_UPLOAD_SUCCESSFUL";
+const char *FPGA_UPLOAD_FAILED_STRING = "FPGA_UPLOAD_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_NO_REPLY_STRING = "STR_HELPER_NO_REPLY";
-const char *INVALID_TYPE_ID_STRING = "INVALID_TYPE_ID";
-const char *STATUS_ERROR_STRING = "STATUS_ERROR";
const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR";
const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH";
const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS";
@@ -403,24 +405,28 @@ const char * translateEvents(Event event) {
case(12007):
return FLASH_READ_FAILED_STRING;
case(12008):
- return STR_HELPER_READING_REPLY_FAILED_STRING;
+ return FPGA_DOWNLOAD_SUCCESSFUL_STRING;
case(12009):
- return STR_HELPER_COM_ERROR_STRING;
+ return FPGA_DOWNLOAD_FAILED_STRING;
case(12010):
- return STR_HELPER_NO_REPLY_STRING;
+ return FPGA_UPLOAD_SUCCESSFUL_STRING;
case(12011):
- return INVALID_TYPE_ID_STRING;
+ return FPGA_UPLOAD_FAILED_STRING;
case(12012):
- return STATUS_ERROR_STRING;
+ return STR_HELPER_READING_REPLY_FAILED_STRING;
case(12013):
- return STR_HELPER_DEC_ERROR_STRING;
+ return STR_HELPER_COM_ERROR_STRING;
case(12014):
- return POSITION_MISMATCH_STRING;
+ return STR_HELPER_NO_REPLY_STRING;
case(12015):
- return STR_HELPER_FILE_NOT_EXISTS_STRING;
+ return STR_HELPER_DEC_ERROR_STRING;
case(12016):
- return STR_HELPER_SENDING_PACKET_FAILED_STRING;
+ return POSITION_MISMATCH_STRING;
case(12017):
+ return STR_HELPER_FILE_NOT_EXISTS_STRING;
+ case(12018):
+ return STR_HELPER_SENDING_PACKET_FAILED_STRING;
+ case(12019):
return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
default:
return "UNKNOWN_EVENT";
diff --git a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
index 474483ca..07bc4a8f 100644
--- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
+++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
@@ -439,8 +439,8 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
#endif
#if OBSW_ADD_ACS_BOARD == 1
- bool enableAside = false;
- bool enableBside = true;
+ bool enableAside = true;
+ bool enableBside = false;
if(enableAside) {
// A side
thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0,
diff --git a/mission/memory/NVMParameterBase.h b/mission/memory/NVMParameterBase.h
index 4814acf4..f41f9e63 100644
--- a/mission/memory/NVMParameterBase.h
+++ b/mission/memory/NVMParameterBase.h
@@ -7,7 +7,7 @@
#include
#include
-class NVMParameterBase {
+class NVMParameterBase : public HasReturnvaluesIF {
public:
virtual~ NVMParameterBase() {}
@@ -34,12 +34,18 @@ public:
ReturnValue_t setValue(std::string key, T value);
template
- T getValue(std::string key) const;
+ ReturnValue_t getValue(std::string key, T* value) const;
void printKeys() const;
void print() const;
private:
+
+ static const uint8_t INTERFACE_ID = CLASS_ID::NVM_PARAM_BASE;
+
+ //! [EXPORT] : [COMMENT] Specified key does not exist in json file
+ static const ReturnValue_t KEY_NOT_EXISTS = MAKE_RETURN_CODE(0xA0);
+
nlohmann::json json;
std::vector keys;
std::string fullName;
@@ -62,8 +68,12 @@ inline ReturnValue_t NVMParameterBase::setValue(std::string key, T value) {
}
template
-inline T NVMParameterBase::getValue(std::string key) const {
- return json[key];
+inline ReturnValue_t NVMParameterBase::getValue(std::string key, T* value) const {
+ if (!json.contains(key)) {
+ return KEY_NOT_EXISTS;
+ }
+ *value = json[key];
+ return RETURN_OK;
}
#endif /* BSP_Q7S_CORE_NVMPARAMS_NVMPARAMIF_H_ */
diff --git a/mission/utility/Timestamp.cpp b/mission/utility/Timestamp.cpp
index 36ddf4d8..c0848a59 100644
--- a/mission/utility/Timestamp.cpp
+++ b/mission/utility/Timestamp.cpp
@@ -12,8 +12,17 @@ Timestamp::~Timestamp() {
}
std::string Timestamp::str() {
- return std::to_string(time.year) + "-" + std::to_string(time.month) + "-"
- + std::to_string(time.day) + "--" + std::to_string(time.hour) + "-"
- + std::to_string(time.minute) + "-" + std::to_string(time.second) + "-";
+ timestamp << std::to_string(time.year) << "-"
+ << std::setw(2) << std::setfill('0')
+ << std::to_string(time.month) << "-"
+ << std::setw(2) << std::setfill('0')
+ << std::to_string(time.day) << "--"
+ << std::setw(2) << std::setfill('0')
+ << std::to_string(time.hour) << "-"
+ << std::setw(2) << std::setfill('0')
+ << std::to_string(time.minute) << "-"
+ << std::setw(2) << std::setfill('0')
+ << std::to_string(time.second) << "--";
+ return timestamp.str();
}
diff --git a/mission/utility/Timestamp.h b/mission/utility/Timestamp.h
index 05dae31f..7146de53 100644
--- a/mission/utility/Timestamp.h
+++ b/mission/utility/Timestamp.h
@@ -2,6 +2,8 @@
#define MISSION_UTILITY_TIMESTAMP_H_
#include
+#include
+#include
#include "fsfw/timemanager/Clock.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
@@ -21,6 +23,7 @@ public:
std::string str();
private:
+ std::stringstream timestamp;
Clock::TimeOfDay_t time;
};