diff --git a/.gitignore b/.gitignore
index 2f7acd11..c337ab89 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,7 +9,7 @@
!misc/eclipse/**/.project
#vscode
-.vscode
+/.vscode
# Python
__pycache__
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c4497b22..2587740e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -99,7 +99,7 @@ pre_source_hw_os_config()
if(TGT_BSP)
if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/raspberrypi"
- OR TGT_BSP MATCHES "arm/beagleboneblack"
+ OR TGT_BSP MATCHES "arm/beagleboneblack" OR TGT_BSP MATCHES "arm/egse"
)
set(FSFW_CONFIG_PATH "linux/fsfwconfig")
if(NOT BUILD_Q7S_SIMPLE_MODE)
@@ -109,11 +109,17 @@ if(TGT_BSP)
endif()
endif()
- if(TGT_BSP MATCHES "arm/raspberrypi")
+ if(TGT_BSP MATCHES "arm/raspberrypi" )
# Used by configure file
set(RASPBERRY_PI ON)
set(FSFW_HAL_ADD_RASPBERRY_PI ON)
endif()
+
+ if(TGT_BSP MATCHES "arm/egse")
+ # Used by configure file
+ set(EGSE ON)
+ set(FSFW_HAL_LINUX_ADD_LIBGPIOD OFF)
+ endif()
if(TGT_BSP MATCHES "arm/beagleboneblack")
# Used by configure file
@@ -140,7 +146,7 @@ configure_file(${FSFW_CONFIG_PATH}/FSFWConfig.h.in FSFWConfig.h)
configure_file(${FSFW_CONFIG_PATH}/OBSWConfig.h.in OBSWConfig.h)
if(TGT_BSP MATCHES "arm/q7s")
configure_file(${BSP_PATH}/boardconfig/q7sConfig.h.in q7sConfig.h)
-elseif(TGT_BSP MATCHES "arm/raspberrypi")
+elseif(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/egse")
configure_file(${BSP_PATH}/boardconfig/rpiConfig.h.in rpiConfig.h)
endif()
@@ -266,7 +272,11 @@ if(TGT_BSP MATCHES "arm/q7s")
)
endif()
-
+if(TGT_BSP MATCHES "arm/egse")
+ target_link_libraries(${OBSW_NAME} PRIVATE
+ ${LIB_ARCSEC}
+ )
+endif()
if(ADD_CSP_LIB)
target_link_libraries(${OBSW_NAME} PRIVATE
@@ -305,7 +315,7 @@ target_include_directories(${LIB_EIVE_MISSION} PUBLIC
${LIB_ARCSEC_PATH}
)
-if(TGT_BSP MATCHES "arm/q7s")
+if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/egse")
target_include_directories(${LIB_EIVE_MISSION} PUBLIC
${ARCSEC_LIB_PATH}
)
diff --git a/README.md b/README.md
index 8268ea24..0effabb8 100644
--- a/README.md
+++ b/README.md
@@ -19,9 +19,10 @@
12. [Static Code Analysis](#static-code-analysis)
13. [Eclipse](#eclipse)
14. [Running the OBSW on a Raspberry Pi](#rpi)
-15. [Manually preparing sysroots to compile gpsd](#gpsd)
-16. [FSFW](#fsfw)
-17. [Coding Style](#coding-style)
+15. [Running OBSW on EGSE](#egse)
+16. [Manually preparing sysroots to compile gpsd](#gpsd)
+17. [FSFW](#fsfw)
+18. [Coding Style](#coding-style)
# General information
@@ -441,12 +442,24 @@ Beagle Bone Black for download here
Download it and unzip it somewhere in the Xilinx installation folder.
You can use the following command if `wget` can be used or for CI/CD:
-```
-wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/agnJGYeRf6fw2ci/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
+```sh
+wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/SyXpdBBQX32xPgE/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
```
Then, create a new environmental variables `Q7S_SYSROOT` and set it to the local system root path.
+### Updating system root for CI
+
+If the system root is updated, it needs to be manually updated on the buggy file server.
+If access on `buggy.irs.uni-stuttgart.de` is possible with `ssh` and the rootfs in the cloud
+[was updated](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/rootfs&fileid=831849)
+as well, you can update the rootfs like this:
+
+```sh
+cd /var/www/eive/tools
+wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/SyXpdBBQX32xPgE/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
+```
+
## Setting up UNIX environment for real-time functionalities
Please note that on most UNIX environments (e.g. Ubuntu), the real time functionalities
@@ -1140,6 +1153,35 @@ sudo apt-get install gpiod libgpiod-dev
to install the required GPIO libraries before cloning the system root folder.
+# Running OBSW on EGSE
+The EGSE is a test system from arcsec build arround a raspberry pi 4 to test the star tracker. The IP address of the EGSE (raspberry pi) is 192.168.18.31. An ssh session can be opened with
+````
+ssh pi@192.168.18.31
+````
+Password: raspberry
+
+To run the obsw perform the following steps:
+1. Build the cmake EGSE Configuration
+ * the sysroots for the EGSE can be found [here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/egse&fileid=1190471)
+ * toolchain for linux host can be downloaded from [here](https://github.com/Pro/raspi-toolchain)
+ * toolchain for windows host from [here](https://gnutoolchains.com/raspberry/) (the raspios-buster-armhf toolchain is the right one for the EGSE)
+2. Disable the ser2net systemd service on the EGSE
+````sh
+$ sudo systemctl stop ser2net.service
+````
+3. Power on the star tracker by running
+````sh
+$ ~/powerctrl/enable0.sh`
+````
+4. Run portforwarding script for tmtc tcp connection and tcf agent on host PC
+````sh
+$ ./scripts/egse-port.sh
+````
+5. The star tracker can be powered off by running
+````sh
+$ ~/powerctrl/disable0.sh
+````
+
# Manually preparing sysroots to compile gpsd
Copy all header files from [here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/gpsd&fileid=1189985) to the /usr/include directory and all static libraries to /usr/lib.
diff --git a/bsp_egse/CMakeLists.txt b/bsp_egse/CMakeLists.txt
new file mode 100644
index 00000000..cb02f937
--- /dev/null
+++ b/bsp_egse/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${OBSW_NAME} PUBLIC
+ InitMission.cpp
+ main.cpp
+ ObjectFactory.cpp
+)
+
+add_subdirectory(boardconfig)
diff --git a/bsp_egse/InitMission.cpp b/bsp_egse/InitMission.cpp
new file mode 100644
index 00000000..d6b192c2
--- /dev/null
+++ b/bsp_egse/InitMission.cpp
@@ -0,0 +1,192 @@
+#include "InitMission.h"
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+#include "OBSWConfig.h"
+#include "ObjectFactory.h"
+#include "objects/systemObjectList.h"
+#include "pollingsequence/pollingSequenceFactory.h"
+
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR");
+
+ObjectManagerIF* objectManager = nullptr;
+
+void initmission::initMission() {
+ sif::info << "Make sure the systemd service ser2net on the egse has been stopped "
+ << "(alias stop-ser2net)" << std::endl;
+ sif::info << "Make sure the power lines of the star tracker have been enabled "
+ << "(alias enable-startracker)" << std::endl;
+ sif::info << "Building global objects.." << std::endl;
+ /* Instantiate global object manager and also create all objects */
+ ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
+ sif::info << "Initializing all objects.." << std::endl;
+ ObjectManager::instance()->initialize();
+
+ /* This function creates and starts all tasks */
+ initTasks();
+}
+
+void initmission::initTasks() {
+ TaskFactory* factory = TaskFactory::instance();
+ ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+ if (factory == nullptr) {
+ /* Should never happen ! */
+ return;
+ }
+#if OBSW_PRINT_MISSED_DEADLINES == 1
+ void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
+#else
+ void (*missedDeadlineFunc)(void) = nullptr;
+#endif
+
+ /* TMTC Distribution */
+ PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
+ "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+ result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::error << "Object add component failed" << std::endl;
+ }
+ result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::error << "Object add component failed" << std::endl;
+ }
+ result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::error << "Object add component failed" << std::endl;
+ }
+
+ PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
+ "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+ result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::error << "Add component TMTC Bridge failed" << std::endl;
+ }
+ PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
+ "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+ result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::error << "Add component TMTC Polling failed" << std::endl;
+ }
+
+ /* PUS Services */
+ std::vector pusTasks;
+ createPusTasks(*factory, missedDeadlineFunc, pusTasks);
+
+ std::vector pstTasks;
+ FixedTimeslotTaskIF* pst = factory->createFixedTimeslotTask(
+ "STAR_TRACKER_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
+ result = pst::pstUart(pst);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+ }
+ pstTasks.push_back(pst);
+
+ PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
+ "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+ result = strHelperTask->addComponent(objects::STR_HELPER);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
+ }
+ pstTasks.push_back(strHelperTask);
+
+ auto taskStarter = [](std::vector& taskVector, std::string name) {
+ for (const auto& task : taskVector) {
+ if (task != nullptr) {
+ task->startTask();
+ } else {
+ sif::error << "Task in vector " << name << " is invalid!" << std::endl;
+ }
+ }
+ };
+
+ sif::info << "Starting tasks.." << std::endl;
+ tmtcDistributor->startTask();
+ tmtcBridgeTask->startTask();
+ tmtcPollingTask->startTask();
+
+ taskStarter(pstTasks, "PST Tasks");
+ taskStarter(pusTasks, "PUS Tasks");
+
+ sif::info << "Tasks started.." << std::endl;
+}
+
+void initmission::createPusTasks(TaskFactory& factory,
+ TaskDeadlineMissedFunction missedDeadlineFunc,
+ std::vector& taskVec) {
+ ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+ PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
+ "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+ result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ sif::error << "Object add component failed" << std::endl;
+ }
+ taskVec.push_back(pusVerification);
+
+ PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
+ "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+ result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
+ }
+ result = pusEvents->addComponent(objects::EVENT_MANAGER);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
+ }
+ taskVec.push_back(pusEvents);
+
+ PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
+ "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+ result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+ }
+ result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
+ }
+ taskVec.push_back(pusHighPrio);
+
+ PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
+ "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+ result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+ }
+ result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
+ }
+ result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
+ }
+ result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+ }
+ taskVec.push_back(pusMedPrio);
+
+ PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
+ "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
+ result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
+ }
+ result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
+ if (result != HasReturnvaluesIF::RETURN_OK) {
+ initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
+ }
+ taskVec.push_back(pusLowPrio);
+}
diff --git a/bsp_egse/InitMission.h b/bsp_egse/InitMission.h
new file mode 100644
index 00000000..c3ba58ec
--- /dev/null
+++ b/bsp_egse/InitMission.h
@@ -0,0 +1,21 @@
+#ifndef BSP_LINUX_INITMISSION_H_
+#define BSP_LINUX_INITMISSION_H_
+
+#include
+
+#include "fsfw/tasks/Typedef.h"
+
+class PeriodicTaskIF;
+class TaskFactory;
+
+namespace initmission {
+void initMission();
+void initTasks();
+
+void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+ std::vector& taskVec);
+void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+ std::vector& taskVec);
+}; // namespace initmission
+
+#endif /* BSP_LINUX_INITMISSION_H_ */
diff --git a/bsp_egse/ObjectFactory.cpp b/bsp_egse/ObjectFactory.cpp
new file mode 100644
index 00000000..10eea471
--- /dev/null
+++ b/bsp_egse/ObjectFactory.cpp
@@ -0,0 +1,49 @@
+#include "ObjectFactory.h"
+
+#include
+#include
+#include
+#include
+
+#include "OBSWConfig.h"
+#include "busConf.h"
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/tmtcpacket/pus/tm.h"
+#include "fsfw/tmtcservices/CommandingServiceBase.h"
+#include "fsfw/tmtcservices/PusServiceBase.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
+#include "linux/devices/startracker/StarTrackerHandler.h"
+#include "mission/core/GenericFactory.h"
+#include "mission/utility/TmFunnel.h"
+#include "objects/systemObjectList.h"
+#include "tmtc/apid.h"
+#include "tmtc/pusIds.h"
+
+void Factory::setStaticFrameworkObjectIds() {
+ PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+ PusServiceBase::packetDestination = objects::TM_FUNNEL;
+
+ CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
+ CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+
+ TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
+ TmFunnel::storageDestination = objects::NO_OBJECT;
+
+ VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+ TmPacketBase::timeStamperId = objects::TIME_STAMPER;
+}
+
+void ObjectFactory::produce(void* args) {
+ Factory::setStaticFrameworkObjectIds();
+ ObjectFactory::produceGenericObjects();
+
+ UartCookie* starTrackerCookie =
+ new UartCookie(objects::STAR_TRACKER, egse::STAR_TRACKER_UART, UartModes::NON_CANONICAL,
+ uart::STAR_TRACKER_BAUD, startracker::MAX_FRAME_SIZE * 2 + 2);
+ new UartComIF(objects::UART_COM_IF);
+ starTrackerCookie->setNoFixedSizeReply();
+ StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
+ StarTrackerHandler* starTrackerHandler = new StarTrackerHandler(
+ objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie, strHelper);
+ starTrackerHandler->setStartUpImmediately();
+}
diff --git a/bsp_egse/ObjectFactory.h b/bsp_egse/ObjectFactory.h
new file mode 100644
index 00000000..b24dd321
--- /dev/null
+++ b/bsp_egse/ObjectFactory.h
@@ -0,0 +1,8 @@
+#ifndef BSP_LINUX_OBJECTFACTORY_H_
+#define BSP_LINUX_OBJECTFACTORY_H_
+
+namespace ObjectFactory {
+void produce(void* args);
+}; // namespace ObjectFactory
+
+#endif /* BSP_LINUX_OBJECTFACTORY_H_ */
diff --git a/bsp_egse/boardconfig/CMakeLists.txt b/bsp_egse/boardconfig/CMakeLists.txt
new file mode 100644
index 00000000..f9136e3e
--- /dev/null
+++ b/bsp_egse/boardconfig/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(${OBSW_NAME} PRIVATE
+ print.c
+)
+
+target_include_directories(${OBSW_NAME} PUBLIC
+ ${CMAKE_CURRENT_SOURCE_DIR}
+)
diff --git a/bsp_egse/boardconfig/busConf.h b/bsp_egse/boardconfig/busConf.h
new file mode 100644
index 00000000..4df55edc
--- /dev/null
+++ b/bsp_egse/boardconfig/busConf.h
@@ -0,0 +1,8 @@
+#ifndef BSP_EGSE_BOARDCONFIG_BUSCONF_H_
+#define BSP_EGSE_BOARDCONFIG_BUSCONF_H_
+
+namespace egse {
+static constexpr char STAR_TRACKER_UART[] = "/dev/serial0";
+}
+
+#endif /* BSP_EGSE_BOARDCONFIG_BUSCONF_H_ */
diff --git a/bsp_egse/boardconfig/etl_profile.h b/bsp_egse/boardconfig/etl_profile.h
new file mode 100644
index 00000000..54aca344
--- /dev/null
+++ b/bsp_egse/boardconfig/etl_profile.h
@@ -0,0 +1,38 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2019 jwellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+#ifndef __ETL_PROFILE_H__
+#define __ETL_PROFILE_H__
+
+#define ETL_CHECK_PUSH_POP
+
+#define ETL_CPP11_SUPPORTED 1
+#define ETL_NO_NULLPTR_SUPPORT 0
+
+#endif
diff --git a/bsp_egse/boardconfig/gcov.h b/bsp_egse/boardconfig/gcov.h
new file mode 100644
index 00000000..80acdd86
--- /dev/null
+++ b/bsp_egse/boardconfig/gcov.h
@@ -0,0 +1,15 @@
+#ifndef LINUX_GCOV_H_
+#define LINUX_GCOV_H_
+#include
+
+#ifdef GCOV
+extern "C" void __gcov_flush();
+#else
+void __gcov_flush() {
+ sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
+ "coverage information is desired.\n"
+ << std::flush;
+}
+#endif
+
+#endif /* LINUX_GCOV_H_ */
diff --git a/bsp_egse/boardconfig/print.c b/bsp_egse/boardconfig/print.c
new file mode 100644
index 00000000..5b3a0f91
--- /dev/null
+++ b/bsp_egse/boardconfig/print.c
@@ -0,0 +1,10 @@
+#include
+#include
+
+void printChar(const char* character, bool errStream) {
+ if (errStream) {
+ putc(*character, stderr);
+ return;
+ }
+ putc(*character, stdout);
+}
diff --git a/bsp_egse/boardconfig/print.h b/bsp_egse/boardconfig/print.h
new file mode 100644
index 00000000..8e7e2e5d
--- /dev/null
+++ b/bsp_egse/boardconfig/print.h
@@ -0,0 +1,8 @@
+#ifndef HOSTED_BOARDCONFIG_PRINT_H_
+#define HOSTED_BOARDCONFIG_PRINT_H_
+
+#include
+
+void printChar(const char* character, bool errStream);
+
+#endif /* HOSTED_BOARDCONFIG_PRINT_H_ */
diff --git a/bsp_egse/boardconfig/rpiConfig.h.in b/bsp_egse/boardconfig/rpiConfig.h.in
new file mode 100644
index 00000000..af4f0dd2
--- /dev/null
+++ b/bsp_egse/boardconfig/rpiConfig.h.in
@@ -0,0 +1,6 @@
+#ifndef BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+#define BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+
+#include
+
+#endif /* BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_ */
diff --git a/bsp_egse/main.cpp b/bsp_egse/main.cpp
new file mode 100644
index 00000000..ce7966ff
--- /dev/null
+++ b/bsp_egse/main.cpp
@@ -0,0 +1,28 @@
+#include
+
+#include "InitMission.h"
+#include "OBSWConfig.h"
+#include "OBSWVersion.h"
+#include "fsfw/FSFWVersion.h"
+#include "fsfw/tasks/TaskFactory.h"
+
+/**
+ * @brief This is the main program entry point for the egse (raspberry pi 4)
+ * @return
+ */
+int main(void) {
+ std::cout << "-- EIVE OBSW --" << std::endl;
+ std::cout << "-- Compiled for EGSE from Arcsec"
+ << " --" << std::endl;
+ std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
+ << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << FSFW_REVISION
+ << "--" << std::endl;
+ std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
+
+ initmission::initMission();
+
+ for (;;) {
+ /* Suspend main thread by sleeping it. */
+ TaskFactory::delayTask(5000);
+ }
+}
diff --git a/bsp_linux_board/InitMission.cpp b/bsp_linux_board/InitMission.cpp
index b8da1b3e..6dfe3af1 100644
--- a/bsp_linux_board/InitMission.cpp
+++ b/bsp_linux_board/InitMission.cpp
@@ -64,17 +64,17 @@ void initmission::initTasks() {
}
/* UDP bridge */
- PeriodicTaskIF* udpBridgeTask = factory->createPeriodicTask(
- "UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
- result = udpBridgeTask->addComponent(objects::TMTC_BRIDGE);
+ PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
+ "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+ result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
if (result != HasReturnvaluesIF::RETURN_OK) {
- sif::error << "Add component UDP Unix Bridge failed" << std::endl;
+ sif::error << "Add component TMTC Bridge failed" << std::endl;
}
- PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
- "UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
- result = udpPollingTask->addComponent(objects::TMTC_POLLING_TASK);
+ PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
+ "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+ result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
if (result != HasReturnvaluesIF::RETURN_OK) {
- sif::error << "Add component UDP Polling failed" << std::endl;
+ sif::error << "Add component TMTC Polling failed" << std::endl;
}
/* PUS Services */
@@ -100,8 +100,8 @@ void initmission::initTasks() {
sif::info << "Starting tasks.." << std::endl;
tmTcDistributor->startTask();
- udpBridgeTask->startTask();
- udpPollingTask->startTask();
+ tmtcBridgeTask->startTask();
+ tmtcPollingTask->startTask();
taskStarter(pusTasks, "PUS Tasks");
#if OBSW_ADD_TEST_CODE == 1
diff --git a/bsp_linux_board/boardconfig/print.c b/bsp_linux_board/boardconfig/print.c
index 3aba2d73..c2b2e15d 100644
--- a/bsp_linux_board/boardconfig/print.c
+++ b/bsp_linux_board/boardconfig/print.c
@@ -1,4 +1,4 @@
-#include
+#include
#include
void printChar(const char* character, bool errStream) {
diff --git a/bsp_q7s/boardtest/Q7STestTask.cpp b/bsp_q7s/boardtest/Q7STestTask.cpp
index 5d9042ac..1f14d0e1 100644
--- a/bsp_q7s/boardtest/Q7STestTask.cpp
+++ b/bsp_q7s/boardtest/Q7STestTask.cpp
@@ -142,13 +142,13 @@ void Q7STestTask::testDummyParams() {
param.print();
int test = 0;
- result = param.getValue(DummyParameter::DUMMY_KEY_PARAM_1, &test);
+ 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);
+ 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;
@@ -170,15 +170,15 @@ void Q7STestTask::testProtHandler() {
bool opPerformed = false;
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
// If any chips are unlocked, lock them here
- result = coreController->setBootCopyProtection(
- CoreController::Chip::ALL_CHIP, CoreController::Copy::ALL_COPY, true, opPerformed, true);
+ result = coreController->setBootCopyProtection(xsc::Chip::ALL_CHIP, xsc::Copy::ALL_COPY, true,
+ opPerformed, true);
if (result != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
}
// unlock own copy
- result = coreController->setBootCopyProtection(
- CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, false, opPerformed, true);
+ result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, false,
+ opPerformed, true);
if (result != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
}
@@ -191,8 +191,8 @@ void Q7STestTask::testProtHandler() {
}
// lock own copy
- result = coreController->setBootCopyProtection(
- CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, true, opPerformed, true);
+ result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, true,
+ opPerformed, true);
if (result != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
}
@@ -205,8 +205,8 @@ void Q7STestTask::testProtHandler() {
}
// unlock specific copy
- result = coreController->setBootCopyProtection(
- CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, false, opPerformed, true);
+ result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, false,
+ opPerformed, true);
if (result != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
}
@@ -219,8 +219,8 @@ void Q7STestTask::testProtHandler() {
}
// lock specific copy
- result = coreController->setBootCopyProtection(
- CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, true, opPerformed, true);
+ result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, true,
+ opPerformed, true);
if (result != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
}
diff --git a/bsp_q7s/callbacks/gpioCallbacks.cpp b/bsp_q7s/callbacks/gpioCallbacks.cpp
index 8f554a65..e5fd877a 100644
--- a/bsp_q7s/callbacks/gpioCallbacks.cpp
+++ b/bsp_q7s/callbacks/gpioCallbacks.cpp
@@ -12,6 +12,7 @@ namespace gpioCallbacks {
GpioIF* gpioComInterface;
void initSpiCsDecoder(GpioIF* gpioComIF) {
+ using namespace gpio;
ReturnValue_t result;
if (gpioComIF == nullptr) {
@@ -26,29 +27,29 @@ void initSpiCsDecoder(GpioIF* gpioComIF) {
GpiodRegularByLineName* spiMuxBit = nullptr;
/** Setting mux bit 1 to low will disable IC21 on the interface board */
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_0_PIN, "SPI Mux Bit 1",
- gpio::DIR_OUT, gpio::HIGH);
+ Direction::OUT, Levels::HIGH);
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_0, spiMuxBit);
/** Setting mux bit 2 to low disables IC1 on the TCS board */
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_1_PIN, "SPI Mux Bit 2",
- gpio::DIR_OUT, gpio::HIGH);
+ Direction::OUT, Levels::HIGH);
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit);
/** Setting mux bit 3 to low disables IC2 on the TCS board and IC22 on the interface board */
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_2_PIN, "SPI Mux Bit 3",
- gpio::DIR_OUT, gpio::LOW);
+ Direction::OUT, Levels::LOW);
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, spiMuxBit);
/** The following gpios can take arbitrary initial values */
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_3_PIN, "SPI Mux Bit 4",
- gpio::DIR_OUT, gpio::LOW);
+ Direction::OUT, Levels::LOW);
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_3, spiMuxBit);
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_4_PIN, "SPI Mux Bit 5",
- gpio::DIR_OUT, gpio::LOW);
+ Direction::OUT, Levels::LOW);
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_4, spiMuxBit);
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_5_PIN, "SPI Mux Bit 6",
- gpio::DIR_OUT, gpio::LOW);
+ Direction::OUT, Levels::LOW);
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_5, spiMuxBit);
- GpiodRegularByLineName* enRwDecoder =
- new GpiodRegularByLineName(q7s::gpioNames::EN_RW_CS, "EN_RW_CS", gpio::DIR_OUT, gpio::HIGH);
+ GpiodRegularByLineName* enRwDecoder = new GpiodRegularByLineName(
+ q7s::gpioNames::EN_RW_CS, "EN_RW_CS", Direction::OUT, Levels::HIGH);
spiMuxGpios->addGpio(gpioIds::EN_RW_CS, enRwDecoder);
result = gpioComInterface->addGpios(spiMuxGpios);
@@ -60,6 +61,7 @@ void initSpiCsDecoder(GpioIF* gpioComIF) {
void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Levels value,
void* args) {
+ using namespace gpio;
if (gpioComInterface == nullptr) {
sif::debug << "spiCsDecoderCallback: No gpioComIF specified. Call initSpiCsDecoder "
<< "to specify gpioComIF" << std::endl;
@@ -71,7 +73,7 @@ void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Lev
return;
}
- if (value == gpio::HIGH) {
+ if (value == Levels::HIGH) {
switch (gpioId) {
case (gpioIds::RTD_IC_3): {
disableDecoderTcsIc1();
@@ -204,7 +206,7 @@ void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Lev
default:
sif::debug << "spiCsDecoderCallback: Invalid gpio id " << gpioId << std::endl;
}
- } else if (value == gpio::LOW) {
+ } else if (value == Levels::LOW) {
switch (gpioId) {
case (gpioIds::RTD_IC_3): {
selectY7();
diff --git a/bsp_q7s/core/CoreController.cpp b/bsp_q7s/core/CoreController.cpp
index bdbd51cc..b1783054 100644
--- a/bsp_q7s/core/CoreController.cpp
+++ b/bsp_q7s/core/CoreController.cpp
@@ -1,5 +1,7 @@
#include "CoreController.h"
+#include
+
#include "OBSWConfig.h"
#include "OBSWVersion.h"
#include "fsfw/FSFWVersion.h"
@@ -20,8 +22,8 @@
#include "bsp_q7s/memory/SdCardManager.h"
#include "bsp_q7s/memory/scratchApi.h"
-CoreController::Chip CoreController::CURRENT_CHIP = Chip::NO_CHIP;
-CoreController::Copy CoreController::CURRENT_COPY = Copy::NO_COPY;
+xsc::Chip CoreController::CURRENT_CHIP = xsc::Chip::NO_CHIP;
+xsc::Copy CoreController::CURRENT_COPY = xsc::Copy::NO_COPY;
CoreController::CoreController(object_id_t objectId)
: ExtendedControllerBase(objectId, objects::NO_OBJECT, 5), opDivider(5) {
@@ -57,6 +59,7 @@ ReturnValue_t CoreController::handleCommandMessage(CommandMessage *message) {
void CoreController::performControlOperation() {
performWatchdogControlOperation();
sdStateMachine();
+ performMountedSdCardOperations();
}
ReturnValue_t CoreController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
@@ -77,6 +80,8 @@ ReturnValue_t CoreController::initialize() {
}
sdStateMachine();
+
+ triggerEvent(REBOOT_SW, CURRENT_CHIP, CURRENT_COPY);
return ExtendedControllerBase::initialize();
}
@@ -89,7 +94,7 @@ ReturnValue_t CoreController::initializeAfterTaskCreation() {
}
}
sdStateMachine();
- result = initVersionFile();
+ performMountedSdCardOperations();
if (result != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "CoreController::initialize: Version initialization failed" << std::endl;
}
@@ -102,6 +107,72 @@ ReturnValue_t CoreController::initializeAfterTaskCreation() {
return result;
}
+ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+ const uint8_t *data, size_t size) {
+ switch (actionId) {
+ case (LIST_DIRECTORY_INTO_FILE): {
+ return actionListDirectoryIntoFile(actionId, commandedBy, data, size);
+ }
+ case (SWITCH_REBOOT_FILE_HANDLING): {
+ if (size < 1) {
+ return HasActionsIF::INVALID_PARAMETERS;
+ }
+ std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+ // Disable the reboot file mechanism
+ parseRebootFile(path, rebootFile);
+ if (data[0] == 0) {
+ rebootFile.enabled = false;
+ rewriteRebootFile(rebootFile);
+ } else if (data[0] == 1) {
+ rebootFile.enabled = true;
+ rewriteRebootFile(rebootFile);
+ } else {
+ return HasActionsIF::INVALID_PARAMETERS;
+ }
+ return HasActionsIF::EXECUTION_FINISHED;
+ }
+ case (RESET_REBOOT_COUNTERS): {
+ if (size == 0) {
+ resetRebootCount(xsc::ALL_CHIP, xsc::ALL_COPY);
+ } else if (size == 2) {
+ if (data[0] > 1 or data[1] > 1) {
+ return HasActionsIF::INVALID_PARAMETERS;
+ }
+ resetRebootCount(static_cast(data[0]), static_cast(data[1]));
+ }
+ return HasActionsIF::EXECUTION_FINISHED;
+ }
+ case (SWITCH_IMG_LOCK): {
+ if (size != 3) {
+ return HasActionsIF::INVALID_PARAMETERS;
+ }
+ if (data[1] > 1 or data[2] > 1) {
+ return HasActionsIF::INVALID_PARAMETERS;
+ }
+ setRebootMechanismLock(data[0], static_cast(data[1]),
+ static_cast(data[2]));
+ return HasActionsIF::EXECUTION_FINISHED;
+ }
+ case (SET_MAX_REBOOT_CNT): {
+ if (size < 1) {
+ return HasActionsIF::INVALID_PARAMETERS;
+ }
+ std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+ // Disable the reboot file mechanism
+ parseRebootFile(path, rebootFile);
+ rebootFile.maxCount = data[0];
+ rewriteRebootFile(rebootFile);
+ return HasActionsIF::EXECUTION_FINISHED;
+ }
+ case (REBOOT_OBC): {
+ return actionPerformReboot(data, size);
+ }
+ default: {
+ return HasActionsIF::INVALID_ACTION_ID;
+ }
+ }
+}
+
ReturnValue_t CoreController::checkModeCommand(Mode_t mode, Submode_t submode,
uint32_t *msToReachTheMode) {
return HasReturnvaluesIF::RETURN_OK;
@@ -500,21 +571,6 @@ ReturnValue_t CoreController::sdCardSetup(sd::SdCard sdCard, sd::SdState targetS
return HasReturnvaluesIF::RETURN_OK;
}
-ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
- const uint8_t *data, size_t size) {
- switch (actionId) {
- case (LIST_DIRECTORY_INTO_FILE): {
- return actionListDirectoryIntoFile(actionId, commandedBy, data, size);
- }
- case (REBOOT_OBC): {
- return actionPerformReboot(data, size);
- }
- default: {
- return HasActionsIF::INVALID_ACTION_ID;
- }
- }
-}
-
ReturnValue_t CoreController::sdColdRedundantBlockingInit() {
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
@@ -689,7 +745,7 @@ ReturnValue_t CoreController::actionListDirectoryIntoFile(ActionId_t actionId,
ReturnValue_t CoreController::initBootCopy() {
if (not std::filesystem::exists(CURR_COPY_FILE)) {
- // Thils file is created by the systemd service eive-early-config so this should
+ // This file is created by the systemd service eive-early-config so this should
// not happen normally
std::string cmd = "xsc_boot_copy > " + std::string(CURR_COPY_FILE);
int result = std::system(cmd.c_str());
@@ -697,22 +753,18 @@ ReturnValue_t CoreController::initBootCopy() {
utility::handleSystemError(result, "CoreController::initBootCopy");
}
}
- std::ifstream file(CURR_COPY_FILE);
- std::string line;
- std::getline(file, line);
- std::istringstream iss(line);
- int value = 0;
- iss >> value;
- CURRENT_CHIP = static_cast(value);
- iss >> value;
- CURRENT_COPY = static_cast(value);
+
+ getCurrentBootCopy(CURRENT_CHIP, CURRENT_COPY);
return HasReturnvaluesIF::RETURN_OK;
}
-void CoreController::getCurrentBootCopy(Chip &chip, Copy ©) {
+void CoreController::getCurrentBootCopy(xsc::Chip &chip, xsc::Copy ©) {
+ xsc_libnor_chip_t xscChip;
+ xsc_libnor_copy_t xscCopy;
+ xsc_boot_get_chip_copy(&xscChip, &xscCopy);
// Not really thread-safe but it does not need to be
- chip = CURRENT_CHIP;
- copy = CURRENT_COPY;
+ chip = static_cast(xscChip);
+ copy = static_cast(xscCopy);
}
ReturnValue_t CoreController::initWatchdogFifo() {
@@ -759,8 +811,8 @@ ReturnValue_t CoreController::actionPerformReboot(const uint8_t *data, size_t si
SdCardManager::instance()->switchOffSdCard(sd::SdCard::SLOT_0);
SdCardManager::instance()->switchOffSdCard(sd::SdCard::SLOT_1);
// If any boot copies are unprotected
- ReturnValue_t retval =
- setBootCopyProtection(Chip::SELF_CHIP, Copy::SELF_COPY, true, protOpPerformed, false);
+ ReturnValue_t retval = setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, true,
+ protOpPerformed, false);
if (retval == HasReturnvaluesIF::RETURN_OK and protOpPerformed) {
sif::info << "Running slot was writeprotected before reboot" << std::endl;
}
@@ -771,7 +823,7 @@ ReturnValue_t CoreController::actionPerformReboot(const uint8_t *data, size_t si
}
return HasActionsIF::EXECUTION_FINISHED;
}
- if (size < 3) {
+ if (size < 3 or (data[1] > 1 or data[2] > 1)) {
return HasActionsIF::INVALID_PARAMETERS;
}
#if OBSW_VERBOSE_LEVEL >= 1
@@ -782,21 +834,53 @@ ReturnValue_t CoreController::actionPerformReboot(const uint8_t *data, size_t si
// Check that the target chip and copy is writeprotected first
generateChipStateFile();
// If any boot copies are unprotected, protect them here
- ReturnValue_t retval = setBootCopyProtection(
- static_cast(data[1]), static_cast(data[2]), true, protOpPerformed, false);
+ auto tgtChip = static_cast(data[1]);
+ auto tgtCopy = static_cast(data[2]);
+
+ ReturnValue_t retval =
+ setBootCopyProtection(static_cast(data[1]), static_cast(data[2]), true,
+ protOpPerformed, false);
if (retval == HasReturnvaluesIF::RETURN_OK and protOpPerformed) {
sif::info << "Target slot was writeprotected before reboot" << std::endl;
}
- // The second byte in data is the target chip, the third byte is the target copy
- std::string cmdString =
- "xsc_boot_copy " + std::to_string(data[1]) + " " + std::to_string(data[2]);
- int result = std::system(cmdString.c_str());
- if (result != 0) {
- utility::handleSystemError(result, "CoreController::executeAction");
- return HasReturnvaluesIF::RETURN_FAILED;
+ switch (tgtChip) {
+ case (xsc::Chip::CHIP_0): {
+ switch (tgtCopy) {
+ case (xsc::Copy::COPY_0): {
+ xsc_boot_copy(XSC_LIBNOR_CHIP_0, XSC_LIBNOR_COPY_NOMINAL);
+ break;
+ }
+ case (xsc::Copy::COPY_1): {
+ xsc_boot_copy(XSC_LIBNOR_CHIP_0, XSC_LIBNOR_COPY_GOLD);
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+ break;
+ }
+ case (xsc::Chip::CHIP_1): {
+ switch (tgtCopy) {
+ case (xsc::Copy::COPY_0): {
+ xsc_boot_copy(XSC_LIBNOR_CHIP_1, XSC_LIBNOR_COPY_NOMINAL);
+ break;
+ }
+ case (xsc::Copy::COPY_1): {
+ xsc_boot_copy(XSC_LIBNOR_CHIP_1, XSC_LIBNOR_COPY_GOLD);
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+ break;
+ }
+ default:
+ break;
}
- return HasActionsIF::EXECUTION_FINISHED;
+ return HasReturnvaluesIF::RETURN_FAILED;
}
CoreController::~CoreController() {}
@@ -850,8 +934,8 @@ ReturnValue_t CoreController::generateChipStateFile() {
return HasReturnvaluesIF::RETURN_OK;
}
-ReturnValue_t CoreController::setBootCopyProtection(Chip targetChip, Copy targetCopy, bool protect,
- bool &protOperationPerformed,
+ReturnValue_t CoreController::setBootCopyProtection(xsc::Chip targetChip, xsc::Copy targetCopy,
+ bool protect, bool &protOperationPerformed,
bool updateProtFile) {
bool allChips = false;
bool allCopies = false;
@@ -860,14 +944,14 @@ ReturnValue_t CoreController::setBootCopyProtection(Chip targetChip, Copy target
protOperationPerformed = false;
switch (targetChip) {
- case (Chip::ALL_CHIP): {
+ case (xsc::Chip::ALL_CHIP): {
allChips = true;
break;
}
- case (Chip::NO_CHIP): {
+ case (xsc::Chip::NO_CHIP): {
return HasReturnvaluesIF::RETURN_OK;
}
- case (Chip::SELF_CHIP): {
+ case (xsc::Chip::SELF_CHIP): {
selfChip = true;
targetChip = CURRENT_CHIP;
break;
@@ -877,14 +961,14 @@ ReturnValue_t CoreController::setBootCopyProtection(Chip targetChip, Copy target
}
}
switch (targetCopy) {
- case (Copy::ALL_COPY): {
+ case (xsc::Copy::ALL_COPY): {
allCopies = true;
break;
}
- case (Copy::NO_COPY): {
+ case (xsc::Copy::NO_COPY): {
return HasReturnvaluesIF::RETURN_OK;
}
- case (Copy::SELF_COPY): {
+ case (xsc::Copy::SELF_COPY): {
selfCopy = true;
targetCopy = CURRENT_COPY;
break;
@@ -907,10 +991,10 @@ ReturnValue_t CoreController::setBootCopyProtection(Chip targetChip, Copy target
return HasReturnvaluesIF::RETURN_OK;
}
-int CoreController::handleBootCopyProtAtIndex(Chip targetChip, Copy targetCopy, bool protect,
- bool &protOperationPerformed, bool selfChip,
- bool selfCopy, bool allChips, bool allCopies,
- uint8_t arrIdx) {
+int CoreController::handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy,
+ bool protect, bool &protOperationPerformed,
+ bool selfChip, bool selfCopy, bool allChips,
+ bool allCopies, uint8_t arrIdx) {
bool currentProt = protArray[arrIdx];
std::ostringstream oss;
bool performOp = false;
@@ -923,22 +1007,22 @@ int CoreController::handleBootCopyProtAtIndex(Chip targetChip, Copy targetCopy,
return 1;
}
}
- Chip currentChip;
- Copy currentCopy;
+ xsc::Chip currentChip;
+ xsc::Copy currentCopy;
oss << "writeprotect ";
if (arrIdx == 0 or arrIdx == 1) {
oss << "0 ";
- currentChip = Chip::CHIP_0;
+ currentChip = xsc::Chip::CHIP_0;
} else {
oss << "1 ";
- currentChip = Chip::CHIP_1;
+ currentChip = xsc::Chip::CHIP_1;
}
if (arrIdx == 0 or arrIdx == 2) {
oss << "0 ";
- currentCopy = Copy::COPY_0;
+ currentCopy = xsc::Copy::COPY_0;
} else {
oss << "1 ";
- currentCopy = Copy::COPY_1;
+ currentCopy = xsc::Copy::COPY_1;
}
if (protect) {
oss << "1";
@@ -1033,29 +1117,29 @@ ReturnValue_t CoreController::handleProtInfoUpdateLine(std::string nextLine) {
uint8_t wordIdx = 0;
uint8_t arrayIdx = 0;
istringstream iss(nextLine);
- Chip currentChip = Chip::CHIP_0;
- Copy currentCopy = Copy::COPY_0;
+ xsc::Chip currentChip = xsc::Chip::CHIP_0;
+ xsc::Copy currentCopy = xsc::Copy::COPY_0;
while (iss >> word) {
if (wordIdx == 1) {
- currentChip = static_cast(stoi(word));
+ currentChip = static_cast(stoi(word));
}
if (wordIdx == 3) {
- currentCopy = static_cast(stoi(word));
+ currentCopy = static_cast(stoi(word));
}
if (wordIdx == 3) {
- if (currentChip == Chip::CHIP_0) {
- if (currentCopy == Copy::COPY_0) {
+ if (currentChip == xsc::Chip::CHIP_0) {
+ if (currentCopy == xsc::Copy::COPY_0) {
arrayIdx = 0;
- } else if (currentCopy == Copy::COPY_1) {
+ } else if (currentCopy == xsc::Copy::COPY_1) {
arrayIdx = 1;
}
}
- else if (currentChip == Chip::CHIP_1) {
- if (currentCopy == Copy::COPY_0) {
+ else if (currentChip == xsc::Chip::CHIP_1) {
+ if (currentCopy == xsc::Copy::COPY_0) {
arrayIdx = 2;
- } else if (currentCopy == Copy::COPY_1) {
+ } else if (currentCopy == xsc::Copy::COPY_1) {
arrayIdx = 3;
}
}
@@ -1101,3 +1185,463 @@ void CoreController::performWatchdogControlOperation() {
}
}
}
+
+void CoreController::performMountedSdCardOperations() {
+ if (doPerformMountedSdCardOps) {
+ bool sdCardMounted = false;
+ sdCardMounted = sdcMan->isSdCardMounted(sdInfo.pref);
+ if (sdCardMounted) {
+ std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + "/" + CONF_FOLDER;
+ if (not std::filesystem::exists(path)) {
+ std::filesystem::create_directory(path);
+ }
+ initVersionFile();
+ performRebootFileHandling(false);
+ doPerformMountedSdCardOps = false;
+ }
+ }
+}
+
+void CoreController::performRebootFileHandling(bool recreateFile) {
+ using namespace std;
+ std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+ if (not std::filesystem::exists(path) or recreateFile) {
+#if OBSW_VERBOSE_LEVEL >= 1
+ sif::info << "CoreController::performRebootFileHandling: Recreating reboot file" << std::endl;
+#endif
+ rebootFile.enabled = true;
+ rebootFile.img00Cnt = 0;
+ rebootFile.img01Cnt = 0;
+ rebootFile.img10Cnt = 0;
+ rebootFile.img11Cnt = 0;
+ rebootFile.lastChip = xsc::Chip::CHIP_0;
+ rebootFile.lastCopy = xsc::Copy::COPY_0;
+ rebootFile.img00Lock = false;
+ rebootFile.img01Lock = false;
+ rebootFile.img10Lock = false;
+ rebootFile.img11Lock = false;
+ rebootFile.mechanismNextChip = xsc::Chip::NO_CHIP;
+ rebootFile.mechanismNextCopy = xsc::Copy::NO_COPY;
+ rebootFile.bootFlag = false;
+ rewriteRebootFile(rebootFile);
+ } else {
+ if (not parseRebootFile(path, rebootFile)) {
+ performRebootFileHandling(true);
+ }
+ }
+
+ if (CURRENT_CHIP == xsc::CHIP_0) {
+ if (CURRENT_COPY == xsc::COPY_0) {
+ rebootFile.img00Cnt++;
+ } else {
+ rebootFile.img01Cnt++;
+ }
+ } else {
+ if (CURRENT_COPY == xsc::COPY_0) {
+ rebootFile.img10Cnt++;
+ } else {
+ rebootFile.img11Cnt++;
+ }
+ }
+
+ if (rebootFile.bootFlag) {
+ // Trigger event to inform ground that a reboot was triggered
+ uint32_t p1 = rebootFile.lastChip << 16 | rebootFile.lastCopy;
+ uint32_t p2 = rebootFile.img00Cnt << 24 | rebootFile.img01Cnt << 16 | rebootFile.img10Cnt << 8 |
+ rebootFile.img11Cnt;
+ triggerEvent(REBOOT_MECHANISM_TRIGGERED, p1, p2);
+ // Clear the boot flag
+ rebootFile.bootFlag = false;
+ }
+
+ if (rebootFile.mechanismNextChip != xsc::NO_CHIP and
+ rebootFile.mechanismNextCopy != xsc::NO_COPY) {
+ if (CURRENT_CHIP != rebootFile.mechanismNextChip or
+ CURRENT_COPY != rebootFile.mechanismNextCopy) {
+ std::string infoString = std::to_string(rebootFile.mechanismNextChip) + " " +
+ std::to_string(rebootFile.mechanismNextCopy);
+ sif::warning << "CoreController::performRebootFileHandling: Expected to be on image "
+ << infoString << " but currently on other image. Locking " << infoString
+ << std::endl;
+ // Firmware or other component might be corrupt and we are on another image then the target
+ // image specified by the mechanism. We can't really trust the target image anymore.
+ // Lock it for now
+ if (rebootFile.mechanismNextChip == xsc::CHIP_0) {
+ if (rebootFile.mechanismNextCopy == xsc::COPY_0) {
+ rebootFile.img00Lock = true;
+ } else {
+ rebootFile.img01Lock = true;
+ }
+ } else {
+ if (rebootFile.mechanismNextCopy == xsc::COPY_0) {
+ rebootFile.img10Lock = true;
+ } else {
+ rebootFile.img11Lock = true;
+ }
+ }
+ }
+ }
+
+ rebootFile.lastChip = CURRENT_CHIP;
+ rebootFile.lastCopy = CURRENT_COPY;
+ // Only reboot if the reboot functionality is enabled.
+ // The handler will still increment the boot counts
+ if (rebootFile.enabled and (*rebootFile.relevantBootCnt >= rebootFile.maxCount)) {
+ // Reboot to other image
+ bool doReboot = false;
+ xsc::Chip tgtChip = xsc::NO_CHIP;
+ xsc::Copy tgtCopy = xsc::NO_COPY;
+ determineAndExecuteReboot(rebootFile, doReboot, tgtChip, tgtCopy);
+ if (doReboot) {
+ rebootFile.bootFlag = true;
+#if OBSW_VERBOSE_LEVEL >= 1
+ sif::info << "Boot counter for image " << CURRENT_CHIP << " " << CURRENT_COPY
+ << " too high. Rebooting to " << tgtChip << " " << tgtCopy << std::endl;
+#endif
+ rebootFile.mechanismNextChip = tgtChip;
+ rebootFile.mechanismNextCopy = tgtCopy;
+ rewriteRebootFile(rebootFile);
+ xsc_boot_copy(static_cast(tgtChip),
+ static_cast(tgtCopy));
+ }
+ } else {
+ rebootFile.mechanismNextChip = xsc::NO_CHIP;
+ rebootFile.mechanismNextCopy = xsc::NO_COPY;
+ }
+ rewriteRebootFile(rebootFile);
+}
+
+void CoreController::determineAndExecuteReboot(RebootFile &rf, bool &needsReboot,
+ xsc::Chip &tgtChip, xsc::Copy &tgtCopy) {
+ tgtChip = xsc::CHIP_0;
+ tgtCopy = xsc::COPY_0;
+ needsReboot = false;
+ if ((CURRENT_CHIP == xsc::CHIP_0) and (CURRENT_COPY == xsc::COPY_0) and
+ (rf.img00Cnt >= rf.maxCount)) {
+ needsReboot = true;
+ if (rf.img01Cnt < rf.maxCount and not rf.img01Lock) {
+ tgtCopy = xsc::COPY_1;
+ return;
+ }
+ if (rf.img10Cnt < rf.maxCount and not rf.img10Lock) {
+ tgtChip = xsc::CHIP_1;
+ return;
+ }
+ if (rf.img11Cnt < rf.maxCount and not rf.img11Lock) {
+ tgtChip = xsc::CHIP_1;
+ tgtCopy = xsc::COPY_1;
+ return;
+ }
+ // Can't really do much here. Stay on image
+ sif::warning
+ << "All reboot counts too high or all fallback images locked, already on fallback image"
+ << std::endl;
+ needsReboot = false;
+ return;
+ }
+ if ((CURRENT_CHIP == xsc::CHIP_0) and (CURRENT_COPY == xsc::COPY_1) and
+ (rf.img01Cnt >= rf.maxCount)) {
+ needsReboot = true;
+ if (rf.img00Cnt < rf.maxCount and not rf.img00Lock) {
+ // Reboot on fallback image
+ return;
+ }
+ if (rf.img10Cnt < rf.maxCount and not rf.img10Lock) {
+ tgtChip = xsc::CHIP_1;
+ return;
+ }
+ if (rf.img11Cnt < rf.maxCount and not rf.img11Lock) {
+ tgtChip = xsc::CHIP_1;
+ tgtCopy = xsc::COPY_1;
+ }
+ if (rf.img00Lock) {
+ needsReboot = false;
+ }
+ // Reboot to fallback image
+ }
+ if ((CURRENT_CHIP == xsc::CHIP_1) and (CURRENT_COPY == xsc::COPY_0) and
+ (rf.img10Cnt >= rf.maxCount)) {
+ needsReboot = true;
+ if (rf.img11Cnt < rf.maxCount and not rf.img11Lock) {
+ tgtChip = xsc::CHIP_1;
+ tgtCopy = xsc::COPY_1;
+ return;
+ }
+ if (rf.img00Cnt < rf.maxCount and not rf.img00Lock) {
+ return;
+ }
+ if (rf.img01Cnt < rf.maxCount and not rf.img01Lock) {
+ tgtCopy = xsc::COPY_1;
+ return;
+ }
+ if (rf.img00Lock) {
+ needsReboot = false;
+ }
+ // Reboot to fallback image
+ }
+ if ((CURRENT_CHIP == xsc::CHIP_1) and (CURRENT_COPY == xsc::COPY_1) and
+ (rf.img11Cnt >= rf.maxCount)) {
+ needsReboot = true;
+ if (rf.img10Cnt < rf.maxCount and not rf.img10Lock) {
+ tgtChip = xsc::CHIP_1;
+ return;
+ }
+ if (rf.img00Cnt < rf.maxCount and not rf.img00Lock) {
+ return;
+ }
+ if (rf.img01Cnt < rf.maxCount and not rf.img01Lock) {
+ tgtCopy = xsc::COPY_1;
+ return;
+ }
+ if (rf.img00Lock) {
+ needsReboot = false;
+ }
+ // Reboot to fallback image
+ }
+}
+
+bool CoreController::parseRebootFile(std::string path, RebootFile &rf) {
+ using namespace std;
+ std::string selfMatch;
+ if (CURRENT_CHIP == xsc::CHIP_0) {
+ if (CURRENT_COPY == xsc::COPY_0) {
+ selfMatch = "00";
+ } else {
+ selfMatch = "01";
+ }
+ } else {
+ if (CURRENT_COPY == xsc::COPY_0) {
+ selfMatch = "10";
+ } else {
+ selfMatch = "11";
+ }
+ }
+ ifstream file(path);
+ string word;
+ string line;
+ uint8_t lineIdx = 0;
+ while (std::getline(file, line)) {
+ istringstream iss(line);
+ switch (lineIdx) {
+ case 0: {
+ iss >> word;
+ if (word.find("on:") == string::npos) {
+ // invalid file
+ return false;
+ }
+ iss >> rf.enabled;
+ break;
+ }
+ case 1: {
+ iss >> word;
+ if (word.find("maxcnt:") == string::npos) {
+ return false;
+ }
+ iss >> rf.maxCount;
+ break;
+ }
+ case 2: {
+ iss >> word;
+ if (word.find("img00:") == string::npos) {
+ return false;
+ }
+ iss >> rf.img00Cnt;
+ if (word.find(selfMatch) != string::npos) {
+ rf.relevantBootCnt = &rf.img00Cnt;
+ }
+ break;
+ }
+ case 3: {
+ iss >> word;
+ if (word.find("img01:") == string::npos) {
+ return false;
+ }
+ iss >> rf.img01Cnt;
+ if (word.find(selfMatch) != string::npos) {
+ rf.relevantBootCnt = &rf.img01Cnt;
+ }
+ break;
+ }
+ case 4: {
+ iss >> word;
+ if (word.find("img10:") == string::npos) {
+ return false;
+ }
+ iss >> rf.img10Cnt;
+ if (word.find(selfMatch) != string::npos) {
+ rf.relevantBootCnt = &rf.img10Cnt;
+ }
+ break;
+ }
+ case 5: {
+ iss >> word;
+ if (word.find("img11:") == string::npos) {
+ return false;
+ }
+ iss >> rf.img11Cnt;
+ if (word.find(selfMatch) != string::npos) {
+ rf.relevantBootCnt = &rf.img11Cnt;
+ }
+ break;
+ }
+ case 6: {
+ iss >> word;
+ if (word.find("img00lock:") == string::npos) {
+ return false;
+ }
+ iss >> rf.img00Lock;
+ break;
+ }
+ case 7: {
+ iss >> word;
+ if (word.find("img01lock:") == string::npos) {
+ return false;
+ }
+ iss >> rf.img01Lock;
+ break;
+ }
+ case 8: {
+ iss >> word;
+ if (word.find("img10lock:") == string::npos) {
+ return false;
+ }
+ iss >> rf.img10Lock;
+ break;
+ }
+ case 9: {
+ iss >> word;
+ if (word.find("img11lock:") == string::npos) {
+ return false;
+ }
+ iss >> rf.img11Lock;
+ break;
+ }
+ case 10: {
+ iss >> word;
+ if (word.find("bootflag:") == string::npos) {
+ return false;
+ }
+ iss >> rf.bootFlag;
+ break;
+ }
+ case 11: {
+ iss >> word;
+ int copyRaw = 0;
+ int chipRaw = 0;
+ if (word.find("last:") == string::npos) {
+ return false;
+ }
+ iss >> chipRaw;
+ if (iss.fail()) {
+ return false;
+ }
+ iss >> copyRaw;
+ if (iss.fail()) {
+ return false;
+ }
+
+ if (chipRaw > 1 or copyRaw > 1) {
+ return false;
+ }
+ rf.lastChip = static_cast(chipRaw);
+ rf.lastCopy = static_cast(copyRaw);
+ break;
+ }
+ case 12: {
+ iss >> word;
+ int copyRaw = 0;
+ int chipRaw = 0;
+ if (word.find("next:") == string::npos) {
+ return false;
+ }
+ iss >> chipRaw;
+ if (iss.fail()) {
+ return false;
+ }
+ iss >> copyRaw;
+ if (iss.fail()) {
+ return false;
+ }
+
+ if (chipRaw > 2 or copyRaw > 2) {
+ return false;
+ }
+ rf.mechanismNextChip = static_cast(chipRaw);
+ rf.mechanismNextCopy = static_cast(copyRaw);
+ break;
+ }
+ }
+ if (iss.fail()) {
+ return false;
+ }
+ lineIdx++;
+ }
+ if (lineIdx < 12) {
+ return false;
+ }
+ return true;
+}
+
+void CoreController::resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy) {
+ std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+ // Disable the reboot file mechanism
+ parseRebootFile(path, rebootFile);
+ if (tgtChip == xsc::ALL_CHIP and tgtCopy == xsc::ALL_COPY) {
+ rebootFile.img00Cnt = 0;
+ rebootFile.img01Cnt = 0;
+ rebootFile.img10Cnt = 0;
+ rebootFile.img11Cnt = 0;
+ } else {
+ if (tgtChip == xsc::CHIP_0) {
+ if (tgtCopy == xsc::COPY_0) {
+ rebootFile.img00Cnt = 0;
+ } else {
+ rebootFile.img01Cnt = 0;
+ }
+ } else {
+ if (tgtCopy == xsc::COPY_0) {
+ rebootFile.img10Cnt = 0;
+ } else {
+ rebootFile.img11Cnt = 0;
+ }
+ }
+ }
+ rewriteRebootFile(rebootFile);
+}
+
+void CoreController::rewriteRebootFile(RebootFile file) {
+ std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+ std::ofstream rebootFile(path);
+ if (rebootFile.is_open()) {
+ // Initiate reboot file first. Reboot handling will be on on initialization
+ rebootFile << "on: " << file.enabled << "\nmaxcnt: " << file.maxCount
+ << "\nimg00: " << file.img00Cnt << "\nimg01: " << file.img01Cnt
+ << "\nimg10: " << file.img10Cnt << "\nimg11: " << file.img11Cnt
+ << "\nimg00lock: " << file.img00Lock << "\nimg01lock: " << file.img01Lock
+ << "\nimg10lock: " << file.img10Lock << "\nimg11lock: " << file.img11Lock
+ << "\nbootflag: " << file.bootFlag << "\nlast: " << static_cast(file.lastChip)
+ << " " << static_cast(file.lastCopy)
+ << "\nnext: " << static_cast(file.mechanismNextChip) << " "
+ << static_cast(file.mechanismNextCopy) << "\n";
+ }
+}
+
+void CoreController::setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy) {
+ std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+ // Disable the reboot file mechanism
+ parseRebootFile(path, rebootFile);
+ if (tgtChip == xsc::CHIP_0) {
+ if (tgtCopy == xsc::COPY_0) {
+ rebootFile.img00Lock = lock;
+ } else {
+ rebootFile.img01Lock = lock;
+ }
+ } else {
+ if (tgtCopy == xsc::COPY_0) {
+ rebootFile.img10Lock = lock;
+ } else {
+ rebootFile.img11Lock = lock;
+ }
+ }
+ rewriteRebootFile(rebootFile);
+}
diff --git a/bsp_q7s/core/CoreController.h b/bsp_q7s/core/CoreController.h
index 5365000a..48bc9b7f 100644
--- a/bsp_q7s/core/CoreController.h
+++ b/bsp_q7s/core/CoreController.h
@@ -2,6 +2,9 @@
#define BSP_Q7S_CORE_CORECONTROLLER_H_
#include
+#include
+
+#include
#include "bsp_q7s/memory/SdCardManager.h"
#include "events/subsystemIdRanges.h"
@@ -10,24 +13,72 @@
class Timer;
class SdCardManager;
+namespace xsc {
+
+enum Chip : int { CHIP_0, CHIP_1, NO_CHIP, SELF_CHIP, ALL_CHIP };
+enum Copy : int { COPY_0, COPY_1, NO_COPY, SELF_COPY, ALL_COPY };
+
+} // namespace xsc
+
+struct RebootFile {
+ static constexpr uint8_t DEFAULT_MAX_BOOT_CNT = 10;
+
+ bool enabled = true;
+ size_t maxCount = DEFAULT_MAX_BOOT_CNT;
+ uint32_t img00Cnt = 0;
+ uint32_t img01Cnt = 0;
+ uint32_t img10Cnt = 0;
+ uint32_t img11Cnt = 0;
+ bool img00Lock = false;
+ bool img01Lock = false;
+ bool img10Lock = false;
+ bool img11Lock = false;
+ uint32_t* relevantBootCnt = &img00Cnt;
+ bool bootFlag = false;
+ xsc::Chip lastChip = xsc::Chip::CHIP_0;
+ xsc::Copy lastCopy = xsc::Copy::COPY_0;
+ xsc::Chip mechanismNextChip = xsc::Chip::NO_CHIP;
+ xsc::Copy mechanismNextCopy = xsc::Copy::NO_COPY;
+};
+
class CoreController : public ExtendedControllerBase {
public:
- enum Chip : uint8_t { CHIP_0, CHIP_1, NO_CHIP, SELF_CHIP, ALL_CHIP };
-
- enum Copy : uint8_t { COPY_0, COPY_1, NO_COPY, SELF_COPY, ALL_COPY };
+ static xsc::Chip CURRENT_CHIP;
+ static xsc::Copy CURRENT_COPY;
static constexpr char CHIP_PROT_SCRIPT[] = "/home/root/scripts/get-chip-prot-status.sh";
static constexpr char CHIP_STATE_FILE[] = "/tmp/chip_prot_status.txt";
static constexpr char CURR_COPY_FILE[] = "/tmp/curr_copy.txt";
- static constexpr char VERSION_FILE[] = "/conf/sd_status";
+ static constexpr char CONF_FOLDER[] = "conf";
+ static constexpr char VERSION_FILE_NAME[] = "version.txt";
+ static constexpr char REBOOT_FILE_NAME[] = "reboot.txt";
+ const std::string VERSION_FILE =
+ "/" + std::string(CONF_FOLDER) + "/" + std::string(VERSION_FILE_NAME);
+ const std::string REBOOT_FILE =
+ "/" + std::string(CONF_FOLDER) + "/" + std::string(REBOOT_FILE_NAME);
static constexpr ActionId_t LIST_DIRECTORY_INTO_FILE = 0;
+ static constexpr ActionId_t SWITCH_REBOOT_FILE_HANDLING = 5;
+ static constexpr ActionId_t RESET_REBOOT_COUNTERS = 6;
+ static constexpr ActionId_t SWITCH_IMG_LOCK = 7;
+ static constexpr ActionId_t SET_MAX_REBOOT_CNT = 8;
+
static constexpr ActionId_t REBOOT_OBC = 32;
static constexpr ActionId_t MOUNT_OTHER_COPY = 33;
static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CORE;
static constexpr Event ALLOC_FAILURE = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
+ //! [EXPORT] : [COMMENT] Software reboot occured. Can also be a systemd reboot.
+ //! P1: Current Chip, P2: Current Copy
+ static constexpr Event REBOOT_SW = event::makeEvent(SUBSYSTEM_ID, 1, severity::MEDIUM);
+ //! [EXPORT] : [COMMENT] The reboot mechanism was triggered.
+ //! P1: First 16 bits: Last Chip, Last 16 bits: Last Copy,
+ //! P2: Each byte is the respective reboot count for the slots
+ static constexpr Event REBOOT_MECHANISM_TRIGGERED =
+ event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);
+ //! Trying to find a way how to determine that the reboot came from ProASIC3 or PCDU..
+ static constexpr Event REBOOT_HW = event::makeEvent(SUBSYSTEM_ID, 3, severity::MEDIUM);
CoreController(object_id_t objectId);
virtual ~CoreController();
@@ -48,7 +99,7 @@ class CoreController : public ExtendedControllerBase {
*/
static ReturnValue_t generateChipStateFile();
static ReturnValue_t incrementAllocationFailureCount();
- static void getCurrentBootCopy(Chip& chip, Copy& copy);
+ static void getCurrentBootCopy(xsc::Chip& chip, xsc::Copy& copy);
ReturnValue_t updateProtInfo(bool regenerateChipStateFile = true);
@@ -63,15 +114,12 @@ class CoreController : public ExtendedControllerBase {
* @param updateProtFile Specify whether the protection info file is updated
* @return
*/
- ReturnValue_t setBootCopyProtection(Chip targetChip, Copy targetCopy, bool protect,
+ ReturnValue_t setBootCopyProtection(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
bool& protOperationPerformed, bool updateProtFile = true);
bool sdInitFinished() const;
private:
- static Chip CURRENT_CHIP;
- static Copy CURRENT_COPY;
-
// Designated value for rechecking FIFO open
static constexpr int RETRY_FIFO_OPEN = -2;
int watchdogFifoFd = 0;
@@ -120,8 +168,9 @@ class CoreController : public ExtendedControllerBase {
sd::SdState currentlyCommandedState = sd::SdState::OFF;
sd::SdCard commandedCard = sd::SdCard::NONE;
sd::SdState commandedState = sd::SdState::OFF;
- };
- SdInfo sdInfo;
+ } sdInfo;
+ RebootFile rebootFile = {};
+ bool doPerformMountedSdCardOps = true;
/**
* Index 0: Chip 0 Copy 0
@@ -136,7 +185,7 @@ class CoreController : public ExtendedControllerBase {
LocalDataPoolManager& poolManager) override;
LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t* msToReachTheMode);
-
+ void performMountedSdCardOperations();
ReturnValue_t initVersionFile();
ReturnValue_t initBootCopy();
ReturnValue_t initWatchdogFifo();
@@ -148,10 +197,12 @@ class CoreController : public ExtendedControllerBase {
ReturnValue_t sdCardSetup(sd::SdCard sdCard, sd::SdState targetState, std::string sdChar,
bool printOutput = true);
ReturnValue_t sdColdRedundantBlockingInit();
+
void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);
void determinePreferredSdCard();
void executeNextExternalSdCommand();
void checkExternalSdCommandStatus();
+ void performRebootFileHandling(bool recreateFile);
ReturnValue_t actionListDirectoryIntoFile(ActionId_t actionId, MessageQueueId_t commandedBy,
const uint8_t* data, size_t size);
@@ -160,9 +211,15 @@ class CoreController : public ExtendedControllerBase {
void performWatchdogControlOperation();
ReturnValue_t handleProtInfoUpdateLine(std::string nextLine);
- int handleBootCopyProtAtIndex(Chip targetChip, Copy targetCopy, bool protect,
+ int handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
bool& protOperationPerformed, bool selfChip, bool selfCopy,
bool allChips, bool allCopies, uint8_t arrIdx);
+ void determineAndExecuteReboot(RebootFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
+ xsc::Copy& tgtCopy);
+ void resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy);
+ void setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy);
+ bool parseRebootFile(std::string path, RebootFile& file);
+ void rewriteRebootFile(RebootFile file);
};
#endif /* BSP_Q7S_CORE_CORECONTROLLER_H_ */
diff --git a/bsp_q7s/core/InitMission.cpp b/bsp_q7s/core/InitMission.cpp
index c4e3805d..b265ce33 100644
--- a/bsp_q7s/core/InitMission.cpp
+++ b/bsp_q7s/core/InitMission.cpp
@@ -86,7 +86,7 @@ void initmission::initTasks() {
"TCPIP_TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
if (result != HasReturnvaluesIF::RETURN_OK) {
- initmission::printAddObjectError("UDP_BRIDGE", objects::TMTC_BRIDGE);
+ initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
}
PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
"TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
@@ -135,9 +135,9 @@ void initmission::initTasks() {
}
#if OBSW_ADD_STAR_TRACKER == 1
- PeriodicTaskIF* strImgLoaderTask = factory->createPeriodicTask(
+ PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
"STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
- result = strImgLoaderTask->addComponent(objects::STR_HELPER);
+ result = strHelperTask->addComponent(objects::STR_HELPER);
if (result != HasReturnvaluesIF::RETURN_OK) {
initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
}
@@ -204,7 +204,7 @@ void initmission::initTasks() {
#if BOARD_TE0720 == 0
fsTask->startTask();
#if OBSW_ADD_STAR_TRACKER == 1
- strImgLoaderTask->startTask();
+ strHelperTask > startTask();
#endif /* OBSW_ADD_STAR_TRACKER == 1 */
#endif
diff --git a/bsp_q7s/core/ObjectFactory.cpp b/bsp_q7s/core/ObjectFactory.cpp
index 782f112b..bcf5a50f 100644
--- a/bsp_q7s/core/ObjectFactory.cpp
+++ b/bsp_q7s/core/ObjectFactory.cpp
@@ -16,9 +16,6 @@
#include "bsp_q7s/devices/PlocMemoryDumper.h"
#include "bsp_q7s/devices/PlocSupervisorHandler.h"
#include "bsp_q7s/devices/PlocUpdater.h"
-#include "bsp_q7s/devices/startracker/StarTrackerDefinitions.h"
-#include "bsp_q7s/devices/startracker/StarTrackerHandler.h"
-#include "bsp_q7s/devices/startracker/StrHelper.h"
#include "bsp_q7s/memory/FileSystemHandler.h"
#include "busConf.h"
#include "ccsdsConfig.h"
@@ -57,13 +54,13 @@
#include "linux/boardtest/SpiTestClass.h"
#include "linux/csp/CspComIF.h"
#include "linux/csp/CspCookie.h"
-#include "mission/devices/SolarArrayDeploymentHandler.h"
-#include "mission/devices/SusHandler.h"
-#include "mission/devices/devicedefinitions/SusDefinitions.h"
+#include "linux/devices/GPSHyperionLinuxController.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
+#include "linux/devices/startracker/StarTrackerHandler.h"
+#include "linux/devices/startracker/StrHelper.h"
#include "mission/core/GenericFactory.h"
#include "mission/devices/ACUHandler.h"
#include "mission/devices/BpxBatteryHandler.h"
-#include "linux/devices/GPSHyperionLinuxController.h"
#include "mission/devices/GyroADIS1650XHandler.h"
#include "mission/devices/HeaterHandler.h"
#include "mission/devices/IMTQHandler.h"
@@ -75,6 +72,7 @@
#include "mission/devices/PlocMPSoCHandler.h"
#include "mission/devices/RadiationSensorHandler.h"
#include "mission/devices/RwHandler.h"
+#include "mission/devices/SolarArrayDeploymentHandler.h"
#include "mission/devices/SusHandler.h"
#include "mission/devices/SyrlinksHkHandler.h"
#include "mission/devices/Tmp1075Handler.h"
@@ -290,14 +288,15 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF) {
}
void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
+ using namespace gpio;
GpioCookie* gpioCookieRadSensor = new GpioCookie;
std::stringstream consumer;
consumer << "0x" << std::hex << objects::RAD_SENSOR;
GpiodRegularByLineName* gpio = new GpiodRegularByLineName(
- q7s::gpioNames::RAD_SENSOR_CHIP_SELECT, consumer.str(), gpio::DIR_OUT, gpio::HIGH);
+ q7s::gpioNames::RAD_SENSOR_CHIP_SELECT, consumer.str(), Direction::OUT, Levels::HIGH);
gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, gpio);
- gpio = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_RADFET, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_RADFET, consumer.str(), Direction::OUT,
+ Levels::LOW);
gpioCookieRadSensor->addGpio(gpioIds::ENABLE_RADFET, gpio);
gpioComIF->addGpios(gpioCookieRadSensor);
@@ -314,43 +313,44 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
}
void ObjectFactory::createSunSensorComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF) {
+ using namespace gpio;
GpioCookie* gpioCookieSus = new GpioCookie();
GpioCallback* susgpio = nullptr;
- susgpio = new GpioCallback("Chip select SUS 0", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 0", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_0, susgpio);
- susgpio = new GpioCallback("Chip select SUS 1", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 1", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_1, susgpio);
- susgpio = new GpioCallback("Chip select SUS 2", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 2", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_2, susgpio);
- susgpio = new GpioCallback("Chip select SUS 3", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 3", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_3, susgpio);
- susgpio = new GpioCallback("Chip select SUS 4", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 4", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_4, susgpio);
- susgpio = new GpioCallback("Chip select SUS 5", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 5", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_5, susgpio);
- susgpio = new GpioCallback("Chip select SUS 6", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 6", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_6, susgpio);
- susgpio = new GpioCallback("Chip select SUS 7", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 7", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_7, susgpio);
- susgpio = new GpioCallback("Chip select SUS 8", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 8", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_8, susgpio);
- susgpio = new GpioCallback("Chip select SUS 9", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 9", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_9, susgpio);
- susgpio = new GpioCallback("Chip select SUS 10", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 10", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_10, susgpio);
- susgpio = new GpioCallback("Chip select SUS 11", gpio::DIR_OUT, gpio::HIGH,
+ susgpio = new GpioCallback("Chip select SUS 11", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieSus->addGpio(gpioIds::CS_SUS_11, susgpio);
@@ -474,101 +474,102 @@ void ObjectFactory::createSunSensorComponents(LinuxLibgpioIF* gpioComIF, SpiComI
}
void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF) {
+ using namespace gpio;
GpioCookie* gpioCookieAcsBoard = new GpioCookie();
std::stringstream consumer;
GpiodRegularByLineName* gpio = nullptr;
consumer << "0x" << std::hex << objects::GYRO_0_ADIS_HANDLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ADIS_CS, consumer.str(), gpio::DIR_OUT,
- gpio::HIGH);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ADIS_CS, consumer.str(), Direction::OUT,
+ Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::GYRO_1_L3G_HANDLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_1_L3G_CS, consumer.str(), gpio::DIR_OUT,
- gpio::HIGH);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_1_L3G_CS, consumer.str(), Direction::OUT,
+ Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_1_L3G_CS, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::GYRO_2_ADIS_HANDLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ADIS_CS, consumer.str(), gpio::DIR_OUT,
- gpio::HIGH);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ADIS_CS, consumer.str(), Direction::OUT,
+ Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ADIS_CS, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::GYRO_3_L3G_HANDLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_3_L3G_CS, consumer.str(), gpio::DIR_OUT,
- gpio::HIGH);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_3_L3G_CS, consumer.str(), Direction::OUT,
+ Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_3_L3G_CS, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::MGM_0_LIS3_HANDLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_0_CS, consumer.str(), gpio::DIR_OUT,
- gpio::HIGH);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_0_CS, consumer.str(), Direction::OUT,
+ Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::MGM_0_LIS3_CS, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::MGM_1_RM3100_HANDLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_1_CS, consumer.str(), gpio::DIR_OUT,
- gpio::HIGH);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_1_CS, consumer.str(), Direction::OUT,
+ Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::MGM_1_RM3100_CS, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::MGM_2_LIS3_HANDLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_2_CS, consumer.str(), gpio::DIR_OUT,
- gpio::HIGH);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_2_CS, consumer.str(), Direction::OUT,
+ Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::MGM_2_LIS3_CS, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::MGM_3_RM3100_HANDLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_3_CS, consumer.str(), gpio::DIR_OUT,
- gpio::HIGH);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_3_CS, consumer.str(), Direction::OUT,
+ Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::MGM_3_RM3100_CS, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::GPS_CONTROLLER;
// GNSS reset pins are active low
- gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_0, consumer.str(), gpio::DIR_OUT,
- gpio::HIGH);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_0, consumer.str(), Direction::OUT,
+ Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_NRESET, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::GPS_CONTROLLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_1, consumer.str(), gpio::DIR_OUT,
- gpio::HIGH);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_1, consumer.str(), Direction::OUT,
+ Levels::HIGH);
gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_NRESET, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::GYRO_0_ADIS_HANDLER;
// Enable pins must be pulled low for regular operations
- gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ENABLE, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ENABLE, consumer.str(), Direction::OUT,
+ Levels::LOW);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ENABLE, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::GYRO_2_ADIS_HANDLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ENABLE, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ENABLE, consumer.str(), Direction::OUT,
+ Levels::LOW);
gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ENABLE, gpio);
// Enable pins for GNSS
consumer.str("");
consumer << "0x" << std::hex << objects::GPS_CONTROLLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_0_ENABLE, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_0_ENABLE, consumer.str(), Direction::OUT,
+ Levels::LOW);
gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_ENABLE, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::GPS_CONTROLLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_1_ENABLE, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_1_ENABLE, consumer.str(), Direction::OUT,
+ Levels::LOW);
gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_ENABLE, gpio);
// Select pin. 0 for GPS side A, 1 for GPS side B
consumer.str("");
consumer << "0x" << std::hex << objects::GPS_CONTROLLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_SELECT, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_SELECT, consumer.str(), Direction::OUT,
+ Levels::LOW);
gpioCookieAcsBoard->addGpio(gpioIds::GNSS_SELECT, gpio);
gpioComIF->addGpios(gpioCookieAcsBoard);
@@ -695,43 +696,44 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
}
void ObjectFactory::createHeaterComponents() {
+ using namespace gpio;
GpioCookie* heaterGpiosCookie = new GpioCookie;
GpiodRegularByLineName* gpio = nullptr;
std::stringstream consumer;
consumer << "0x" << std::hex << objects::HEATER_HANDLER;
/* Pin H2-11 on stack connector */
- gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_0, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_0, consumer.str(), Direction::OUT,
+ Levels::LOW);
heaterGpiosCookie->addGpio(gpioIds::HEATER_0, gpio);
/* Pin H2-12 on stack connector */
- gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_1, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_1, consumer.str(), Direction::OUT,
+ Levels::LOW);
heaterGpiosCookie->addGpio(gpioIds::HEATER_1, gpio);
/* Pin H2-13 on stack connector */
- gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_2, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_2, consumer.str(), Direction::OUT,
+ Levels::LOW);
heaterGpiosCookie->addGpio(gpioIds::HEATER_2, gpio);
- gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_3, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_3, consumer.str(), Direction::OUT,
+ Levels::LOW);
heaterGpiosCookie->addGpio(gpioIds::HEATER_3, gpio);
- gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_4, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_4, consumer.str(), Direction::OUT,
+ Levels::LOW);
heaterGpiosCookie->addGpio(gpioIds::HEATER_4, gpio);
- gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_5, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_5, consumer.str(), Direction::OUT,
+ Levels::LOW);
heaterGpiosCookie->addGpio(gpioIds::HEATER_5, gpio);
- gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_6, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_6, consumer.str(), Direction::OUT,
+ Levels::LOW);
heaterGpiosCookie->addGpio(gpioIds::HEATER_6, gpio);
- gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_7, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::HEATER_7, consumer.str(), Direction::OUT,
+ Levels::LOW);
heaterGpiosCookie->addGpio(gpioIds::HEATER_7, gpio);
new HeaterHandler(objects::HEATER_HANDLER, objects::GPIO_IF, heaterGpiosCookie,
@@ -739,16 +741,17 @@ void ObjectFactory::createHeaterComponents() {
}
void ObjectFactory::createSolarArrayDeploymentComponents() {
+ using namespace gpio;
GpioCookie* solarArrayDeplCookie = new GpioCookie;
GpiodRegularByLineName* gpio = nullptr;
std::stringstream consumer;
consumer << "0x" << std::hex << objects::SOLAR_ARRAY_DEPL_HANDLER;
- gpio = new GpiodRegularByLineName(q7s::gpioNames::SA_DPL_PIN_0, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::SA_DPL_PIN_0, consumer.str(), Direction::OUT,
+ Levels::LOW);
solarArrayDeplCookie->addGpio(gpioIds::DEPLSA1, gpio);
- gpio = new GpiodRegularByLineName(q7s::gpioNames::SA_DPL_PIN_1, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::SA_DPL_PIN_1, consumer.str(), Direction::OUT,
+ Levels::LOW);
solarArrayDeplCookie->addGpio(gpioIds::DEPLSA2, gpio);
// TODO: Find out burn time. For now set to 1000 ms.
@@ -768,54 +771,55 @@ void ObjectFactory::createSyrlinksComponents() {
}
void ObjectFactory::createRtdComponents(LinuxLibgpioIF* gpioComIF) {
+ using namespace gpio;
GpioCookie* rtdGpioCookie = new GpioCookie;
- GpioCallback* gpioRtdIc0 = new GpioCallback("Chip select RTD IC0", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc0 = new GpioCallback("Chip select RTD IC0", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_3, gpioRtdIc0);
- GpioCallback* gpioRtdIc1 = new GpioCallback("Chip select RTD IC1", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc1 = new GpioCallback("Chip select RTD IC1", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_4, gpioRtdIc1);
- GpioCallback* gpioRtdIc2 = new GpioCallback("Chip select RTD IC2", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc2 = new GpioCallback("Chip select RTD IC2", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_5, gpioRtdIc2);
- GpioCallback* gpioRtdIc3 = new GpioCallback("Chip select RTD IC3", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc3 = new GpioCallback("Chip select RTD IC3", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_6, gpioRtdIc3);
- GpioCallback* gpioRtdIc4 = new GpioCallback("Chip select RTD IC4", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc4 = new GpioCallback("Chip select RTD IC4", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_7, gpioRtdIc4);
- GpioCallback* gpioRtdIc5 = new GpioCallback("Chip select RTD IC5", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc5 = new GpioCallback("Chip select RTD IC5", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_8, gpioRtdIc5);
- GpioCallback* gpioRtdIc6 = new GpioCallback("Chip select RTD IC6", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc6 = new GpioCallback("Chip select RTD IC6", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_9, gpioRtdIc6);
- GpioCallback* gpioRtdIc7 = new GpioCallback("Chip select RTD IC7", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc7 = new GpioCallback("Chip select RTD IC7", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_10, gpioRtdIc7);
- GpioCallback* gpioRtdIc8 = new GpioCallback("Chip select RTD IC8", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc8 = new GpioCallback("Chip select RTD IC8", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_11, gpioRtdIc8);
- GpioCallback* gpioRtdIc9 = new GpioCallback("Chip select RTD IC9", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc9 = new GpioCallback("Chip select RTD IC9", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_12, gpioRtdIc9);
- GpioCallback* gpioRtdIc10 = new GpioCallback("Chip select RTD IC10", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc10 = new GpioCallback("Chip select RTD IC10", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_13, gpioRtdIc10);
- GpioCallback* gpioRtdIc11 = new GpioCallback("Chip select RTD IC11", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc11 = new GpioCallback("Chip select RTD IC11", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_14, gpioRtdIc11);
- GpioCallback* gpioRtdIc12 = new GpioCallback("Chip select RTD IC12", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc12 = new GpioCallback("Chip select RTD IC12", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_15, gpioRtdIc12);
- GpioCallback* gpioRtdIc13 = new GpioCallback("Chip select RTD IC13", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc13 = new GpioCallback("Chip select RTD IC13", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_16, gpioRtdIc13);
- GpioCallback* gpioRtdIc14 = new GpioCallback("Chip select RTD IC14", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc14 = new GpioCallback("Chip select RTD IC14", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_17, gpioRtdIc14);
- GpioCallback* gpioRtdIc15 = new GpioCallback("Chip select RTD IC15", gpio::DIR_OUT, gpio::HIGH,
+ GpioCallback* gpioRtdIc15 = new GpioCallback("Chip select RTD IC15", Direction::OUT, Levels::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_18, gpioRtdIc15);
@@ -960,40 +964,45 @@ void ObjectFactory::createRtdComponents(LinuxLibgpioIF* gpioComIF) {
}
void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
+ using namespace gpio;
GpioCookie* gpioCookieRw = new GpioCookie;
- GpioCallback* csRw1 = new GpioCallback("Chip select reaction wheel 1", gpio::DIR_OUT, gpio::HIGH,
- &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+ GpioCallback* csRw1 =
+ new GpioCallback("Chip select reaction wheel 1", Direction::OUT, Levels::HIGH,
+ &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieRw->addGpio(gpioIds::CS_RW1, csRw1);
- GpioCallback* csRw2 = new GpioCallback("Chip select reaction wheel 2", gpio::DIR_OUT, gpio::HIGH,
- &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+ GpioCallback* csRw2 =
+ new GpioCallback("Chip select reaction wheel 2", Direction::OUT, Levels::HIGH,
+ &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieRw->addGpio(gpioIds::CS_RW2, csRw2);
- GpioCallback* csRw3 = new GpioCallback("Chip select reaction wheel 3", gpio::DIR_OUT, gpio::HIGH,
- &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+ GpioCallback* csRw3 =
+ new GpioCallback("Chip select reaction wheel 3", Direction::OUT, Levels::HIGH,
+ &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieRw->addGpio(gpioIds::CS_RW3, csRw3);
- GpioCallback* csRw4 = new GpioCallback("Chip select reaction wheel 4", gpio::DIR_OUT, gpio::HIGH,
- &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+ GpioCallback* csRw4 =
+ new GpioCallback("Chip select reaction wheel 4", Direction::OUT, Levels::HIGH,
+ &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
gpioCookieRw->addGpio(gpioIds::CS_RW4, csRw4);
std::stringstream consumer;
GpiodRegularByLineName* gpio = nullptr;
consumer << "0x" << std::hex << objects::RW1;
- gpio =
- new GpiodRegularByLineName(q7s::gpioNames::EN_RW_1, consumer.str(), gpio::DIR_OUT, gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_1, consumer.str(), Direction::OUT,
+ Levels::LOW);
gpioCookieRw->addGpio(gpioIds::EN_RW1, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::RW2;
- gpio =
- new GpiodRegularByLineName(q7s::gpioNames::EN_RW_2, consumer.str(), gpio::DIR_OUT, gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_2, consumer.str(), Direction::OUT,
+ Levels::LOW);
gpioCookieRw->addGpio(gpioIds::EN_RW2, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::RW3;
- gpio =
- new GpiodRegularByLineName(q7s::gpioNames::EN_RW_3, consumer.str(), gpio::DIR_OUT, gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_3, consumer.str(), Direction::OUT,
+ Levels::LOW);
gpioCookieRw->addGpio(gpioIds::EN_RW3, gpio);
consumer.str("");
consumer << "0x" << std::hex << objects::RW4;
- gpio =
- new GpiodRegularByLineName(q7s::gpioNames::EN_RW_4, consumer.str(), gpio::DIR_OUT, gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::EN_RW_4, consumer.str(), Direction::OUT,
+ Levels::LOW);
gpioCookieRw->addGpio(gpioIds::EN_RW4, gpio);
gpioComIF->addGpios(gpioCookieRw);
@@ -1045,6 +1054,7 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
}
void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
+ using namespace gpio;
// GPIO definitions of signals connected to the virtual channel interfaces of the PTME IP Core
GpioCookie* gpioCookiePtmeIp = new GpioCookie;
GpiodRegularByLineName* gpio = nullptr;
@@ -1122,8 +1132,8 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
consumer.str("");
consumer << "0x" << std::hex << objects::PDEC_HANDLER;
// GPIO also low after linux boot (specified by device-tree)
- gpio = new GpiodRegularByLineName(q7s::gpioNames::PDEC_RESET, consumer.str(), gpio::DIR_OUT,
- gpio::LOW);
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::PDEC_RESET, consumer.str(), Direction::OUT,
+ Levels::LOW);
gpioCookiePdec->addGpio(gpioIds::PDEC_RESET, gpio);
gpioComIF->addGpios(gpioCookiePdec);
@@ -1134,18 +1144,18 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
#if BOARD_TE0720 == 0
GpioCookie* gpioRS485Chip = new GpioCookie;
gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_CLOCK, "RS485 Transceiver",
- gpio::Direction::DIR_OUT, gpio::LOW);
+ Direction::OUT, Levels::LOW);
gpioRS485Chip->addGpio(gpioIds::RS485_EN_TX_CLOCK, gpio);
gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_DATA, "RS485 Transceiver",
- gpio::Direction::DIR_OUT, gpio::LOW);
+ Direction::OUT, Levels::LOW);
gpioRS485Chip->addGpio(gpioIds::RS485_EN_TX_DATA, gpio);
// Default configuration enables RX channels (RXEN = LOW)
gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_RX_CLOCK, "RS485 Transceiver",
- gpio::Direction::DIR_OUT, gpio::LOW);
+ Direction::OUT, Levels::LOW);
gpioRS485Chip->addGpio(gpioIds::RS485_EN_RX_CLOCK, gpio);
gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_RX_DATA, "RS485 Transceiver",
- gpio::Direction::DIR_OUT, gpio::LOW);
+ Direction::OUT, Levels::LOW);
gpioRS485Chip->addGpio(gpioIds::RS485_EN_RX_DATA, gpio);
gpioComIF->addGpios(gpioRS485Chip);
@@ -1153,44 +1163,45 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
}
void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF) {
+ using namespace gpio;
// Create all GPIO components first
GpioCookie* plPcduGpios = new GpioCookie;
GpiodRegularByLineName* gpio = nullptr;
std::string consumer;
// Switch pins are active high
consumer = "PLPCDU_ENB_VBAT_0";
- gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_VBAT0, consumer, gpio::DIR_OUT,
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_VBAT0, consumer, Direction::OUT,
gpio::Levels::LOW);
plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_VBAT0, gpio);
consumer = "PLPCDU_ENB_VBAT_1";
- gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_VBAT1, consumer, gpio::DIR_OUT,
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_VBAT1, consumer, Direction::OUT,
gpio::Levels::LOW);
plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_VBAT1, gpio);
consumer = "PLPCDU_ENB_DRO";
- gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_DRO, consumer, gpio::DIR_OUT,
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_DRO, consumer, Direction::OUT,
gpio::Levels::LOW);
plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_DRO, gpio);
consumer = "PLPCDU_ENB_HPA";
- gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_HPA, consumer, gpio::DIR_OUT,
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_HPA, consumer, Direction::OUT,
gpio::Levels::LOW);
plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_HPA, gpio);
consumer = "PLPCDU_ENB_MPA";
- gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_MPA, consumer, gpio::DIR_OUT,
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_MPA, consumer, Direction::OUT,
gpio::Levels::LOW);
plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_MPA, gpio);
consumer = "PLPCDU_ENB_X8";
- gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_X8, consumer, gpio::DIR_OUT,
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_X8, consumer, Direction::OUT,
gpio::Levels::LOW);
plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_X8, gpio);
consumer = "PLPCDU_ENB_TX";
- gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_TX, consumer, gpio::DIR_OUT,
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_TX, consumer, Direction::OUT,
gpio::Levels::LOW);
plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_TX, gpio);
// Chip select pin is active low
consumer = "PLPCDU_ADC_CS";
- gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ADC_CS, consumer, gpio::DIR_OUT,
+ gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ADC_CS, consumer, Direction::OUT,
gpio::Levels::HIGH);
plPcduGpios->addGpio(gpioIds::PLPCDU_ADC_CS, gpio);
gpioComIF->addGpios(plPcduGpios);
@@ -1204,10 +1215,10 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
#if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1
#if OBSW_TEST_GPIO_OPEN_BYLABEL == 1
/* Configure MIO0 as input */
- GpiodRegular* testGpio = new GpiodRegular("MIO0", gpio::DIR_OUT, 0, "/amba_pl/gpio@41200000", 0);
+ GpiodRegular* testGpio = new GpiodRegular("MIO0", Direction::OUT, 0, "/amba_pl/gpio@41200000", 0);
#elif OBSW_TEST_GPIO_OPEN_BY_LINE_NAME
GpiodRegularByLineName* testGpio =
- new GpiodRegularByLineName("test-name", "gpio-test", gpio::DIR_OUT, 0);
+ new GpiodRegularByLineName("test-name", "gpio-test", Direction::OUT, 0);
#else
/* Configure MIO0 as input */
GpiodRegular* testGpio = new GpiodRegular("gpiochip0", 0, "MIO0", gpio::IN, 0);
@@ -1220,7 +1231,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
#if BOARD_TE0720 == 1 && OBSW_TEST_SUS == 1
GpioCookie* gpioCookieSus = new GpioCookie;
GpiodRegular* chipSelectSus = new GpiodRegular(
- std::string("gpiochip1"), 9, std::string("Chip Select Sus Sensor"), gpio::DIR_OUT, 1);
+ std::string("gpiochip1"), 9, std::string("Chip Select Sus Sensor"), Direction::OUT, 1);
gpioCookieSus->addGpio(gpioIds::CS_SUS_0, chipSelectSus);
gpioComIF->addGpios(gpioCookieSus);
@@ -1249,7 +1260,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
#if BOARD_TE0720 == 1 && OBSW_TEST_RAD_SENSOR == 1
GpioCookie* gpioCookieRadSensor = new GpioCookie;
GpiodRegular* chipSelectRadSensor = new GpiodRegular(
- std::string("gpiochip1"), 0, std::string("Chip select radiation sensor"), gpio::DIR_OUT, 1);
+ std::string("gpiochip1"), 0, std::string("Chip select radiation sensor"), Direction::OUT, 1);
gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, chipSelectRadSensor);
gpioComIF->addGpios(gpioCookieRadSensor);
diff --git a/bsp_q7s/devices/CMakeLists.txt b/bsp_q7s/devices/CMakeLists.txt
index eed234f5..e0f6ee2f 100644
--- a/bsp_q7s/devices/CMakeLists.txt
+++ b/bsp_q7s/devices/CMakeLists.txt
@@ -2,6 +2,4 @@ target_sources(${OBSW_NAME} PRIVATE
PlocSupervisorHandler.cpp
PlocUpdater.cpp
PlocMemoryDumper.cpp
-)
-
-add_subdirectory(startracker)
\ No newline at end of file
+)
\ No newline at end of file
diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp
deleted file mode 100644
index e5601ac0..00000000
--- a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp
+++ /dev/null
@@ -1,2107 +0,0 @@
-#include "StarTrackerHandler.h"
-
-#include
-#include
-#include
-
-#include
-
-#include "OBSWConfig.h"
-#include "StarTrackerJsonCommands.h"
-extern "C" {
-#include
-#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),
- checksumSet(this),
- downloadCentroidSet(this),
- downloadMatchedStar(this),
- downloadDbImage(this),
- downloadBlobPixel(this),
- cameraSet(this),
- limitsSet(this),
- blobSet(this),
- strHelper(strHelper) {
- if (comCookie == nullptr) {
- sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl;
- }
- if (strHelper == nullptr) {
- sif::error << "StarTrackerHandler: Invalid str image loader" << std::endl;
- }
- auto mqArgs = MqArgs(this->getObjectId());
- eventQueue = QueueFactory::instance()->createMessageQueue(
- EventMessage::EVENT_MESSAGE_SIZE * 5, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
-}
-
-StarTrackerHandler::~StarTrackerHandler() {}
-
-ReturnValue_t StarTrackerHandler::initialize() {
- ReturnValue_t result = RETURN_OK;
- result = DeviceHandlerBase::initialize();
- if (result != RETURN_OK) {
- return result;
- }
-
- EventManagerIF* manager = ObjectManager::instance()->get(objects::EVENT_MANAGER);
- if (manager == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
- sif::error << "StarTrackerHandler::initialize: Invalid event manager" << std::endl;
-#endif
- return ObjectManagerIF::CHILD_INIT_FAILED;
- ;
- }
- result = manager->registerListener(eventQueue->getId());
- if (result != RETURN_OK) {
- return result;
- }
- result = manager->subscribeToEventRange(eventQueue->getId(),
- event::getEventId(StrHelper::IMAGE_UPLOAD_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 "
- " str helper"
- << std::endl;
-#endif
- return ObjectManagerIF::CHILD_INIT_FAILED;
- }
-
- result = strHelper->setComIF(communicationInterface);
- if (result != RETURN_OK) {
- return ObjectManagerIF::CHILD_INIT_FAILED;
- }
- strHelper->setComCookie(comCookie);
- return RETURN_OK;
-}
-
-ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
- const uint8_t* data, size_t size) {
- ReturnValue_t result = RETURN_OK;
-
- switch (actionId) {
- case (StarTracker::STOP_IMAGE_LOADER): {
- strHelper->stopProcess();
- return EXECUTION_FINISHED;
- }
- case (StarTracker::SET_JSON_FILE_NAME): {
- if (size > MAX_PATH_SIZE) {
- return FILE_PATH_TOO_LONG;
- }
- paramJsonFile = std::string(reinterpret_cast(data), size);
- return EXECUTION_FINISHED;
- }
- default:
- break;
- }
-
- if (strHelperExecuting == true) {
- return IMAGE_LOADER_EXECUTING;
- }
-
- result = checkMode(actionId);
- if (result != RETURN_OK) {
- return result;
- }
-
- // Intercept image loader commands which do not follow the common DHB communication flow
- switch (actionId) {
- case (StarTracker::UPLOAD_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->startImageUpload(std::string(reinterpret_cast(data), size));
- if (result != RETURN_OK) {
- return result;
- }
- strHelperExecuting = true;
- return EXECUTION_FINISHED;
- }
- case (StarTracker::DOWNLOAD_IMAGE): {
- result = DeviceHandlerBase::acceptExternalDeviceCommands();
- if (result != RETURN_OK) {
- return result;
- }
- if (size > MAX_PATH_SIZE) {
- return FILE_PATH_TOO_LONG;
- }
- result =
- strHelper->startImageDownload(std::string(reinterpret_cast(data), size));
- if (result != RETURN_OK) {
- return result;
- }
- strHelperExecuting = true;
- return EXECUTION_FINISHED;
- }
- case (StarTracker::WRITE): {
- result = DeviceHandlerBase::acceptExternalDeviceCommands();
- if (result != RETURN_OK) {
- return result;
- }
- result = executeWriteCommand(data, size);
- if (result != RETURN_OK) {
- return result;
- }
-
- 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;
- }
- strHelper->setDownloadImageName(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;
- }
- return DeviceHandlerBase::executeAction(actionId, commandedBy, data, size);
-}
-
-void StarTrackerHandler::performOperationHook() {
- EventMessage event;
- for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == RETURN_OK;
- result = eventQueue->receiveMessage(&event)) {
- switch (event.getMessageId()) {
- case EventMessage::EVENT_MESSAGE:
- handleEvent(&event);
- break;
- default:
- sif::debug << "CCSDSHandler::checkEvents: Did not subscribe to this event message"
- << std::endl;
- break;
- }
- }
-}
-
-void StarTrackerHandler::doStartUp() {
- switch (startupState) {
- case StartupState::IDLE:
- startupState = StartupState::CHECK_BOOT_STATE;
- return;
- case StartupState::BOOT_DELAY:
- if (bootCountdown.hasTimedOut()) {
- startupState = StartupState::LIMITS;
- }
- return;
- case StartupState::DONE:
- break;
- default:
- return;
- }
- setMode(_MODE_TO_ON);
-}
-
-void StarTrackerHandler::doShutDown() {
- // If star tracker is shutdown also stop all running processes in the image loader task
- strHelper->stopProcess();
- setMode(_MODE_POWER_DOWN);
-}
-
-void StarTrackerHandler::doOffActivity() { startupState = StartupState::IDLE; }
-
-ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
- switch (internalState) {
- case InternalState::TEMPERATURE_REQUEST:
- *id = StarTracker::REQ_TEMPERATURE;
- break;
- default:
- sif::debug << "StarTrackerHandler::buildNormalDeviceCommand: Invalid internal step"
- << std::endl;
- break;
- }
- return buildCommandFromCommand(*id, NULL, 0);
-}
-
-ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
- if (mode != _MODE_START_UP) {
- return NOTHING_TO_SEND;
- }
- switch (startupState) {
- case StartupState::CHECK_BOOT_STATE:
- *id = StarTracker::REQ_VERSION;
- startupState = StartupState::WAIT_FOR_EXECUTION;
- return buildCommandFromCommand(*id, nullptr, 0);
- case StartupState::BOOT:
- *id = StarTracker::BOOT;
- bootCountdown.setTimeout(BOOT_TIMEOUT);
- startupState = StartupState::BOOT_DELAY;
- return buildCommandFromCommand(*id, nullptr, 0);
- case StartupState::LIMITS:
- startupState = StartupState::WAIT_FOR_EXECUTION;
- *id = StarTracker::LIMITS;
- return buildCommandFromCommand(*id, reinterpret_cast(paramJsonFile.c_str()),
- paramJsonFile.size());
- case StartupState::TRACKING:
- startupState = StartupState::WAIT_FOR_EXECUTION;
- *id = StarTracker::TRACKING;
- return buildCommandFromCommand(*id, reinterpret_cast(paramJsonFile.c_str()),
- paramJsonFile.size());
- case StartupState::MOUNTING:
- startupState = StartupState::WAIT_FOR_EXECUTION;
- *id = StarTracker::MOUNTING;
- return buildCommandFromCommand(*id, reinterpret_cast(paramJsonFile.c_str()),
- paramJsonFile.size());
- case StartupState::CAMERA:
- startupState = StartupState::WAIT_FOR_EXECUTION;
- *id = StarTracker::CAMERA;
- return buildCommandFromCommand(*id, reinterpret_cast(paramJsonFile.c_str()),
- paramJsonFile.size());
- case StartupState::BLOB:
- startupState = StartupState::WAIT_FOR_EXECUTION;
- *id = StarTracker::BLOB;
- return buildCommandFromCommand(*id, reinterpret_cast(paramJsonFile.c_str()),
- paramJsonFile.size());
- case StartupState::CENTROIDING:
- startupState = StartupState::WAIT_FOR_EXECUTION;
- *id = StarTracker::CENTROIDING;
- return buildCommandFromCommand(*id, reinterpret_cast(paramJsonFile.c_str()),
- paramJsonFile.size());
- case StartupState::LISA:
- startupState = StartupState::WAIT_FOR_EXECUTION;
- *id = StarTracker::LISA;
- return buildCommandFromCommand(*id, reinterpret_cast(paramJsonFile.c_str()),
- paramJsonFile.size());
- case StartupState::MATCHING:
- startupState = StartupState::WAIT_FOR_EXECUTION;
- *id = StarTracker::MATCHING;
- return buildCommandFromCommand(*id, reinterpret_cast(paramJsonFile.c_str()),
- paramJsonFile.size());
- case StartupState::VALIDATION:
- startupState = StartupState::WAIT_FOR_EXECUTION;
- *id = StarTracker::VALIDATION;
- return buildCommandFromCommand(*id, reinterpret_cast(paramJsonFile.c_str()),
- paramJsonFile.size());
- case StartupState::ALGO:
- startupState = StartupState::WAIT_FOR_EXECUTION;
- *id = StarTracker::ALGO;
- return buildCommandFromCommand(*id, reinterpret_cast(paramJsonFile.c_str()),
- paramJsonFile.size());
- default:
- break;
- }
- return NOTHING_TO_SEND;
-}
-
-ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
- const uint8_t* commandData,
- size_t commandDataLen) {
- ReturnValue_t result = RETURN_OK;
- switch (deviceCommand) {
- case (StarTracker::PING_REQUEST): {
- preparePingRequest();
- return RETURN_OK;
- }
- case (StarTracker::REQ_TIME): {
- prepareTimeRequest();
- return RETURN_OK;
- }
- case (StarTracker::BOOT): {
- prepareBootCommand();
- return RETURN_OK;
- }
- case (StarTracker::REQ_VERSION): {
- prepareVersionRequest();
- return RETURN_OK;
- }
- case (StarTracker::REQ_INTERFACE): {
- prepareInterfaceRequest();
- return RETURN_OK;
- }
- case (StarTracker::REQ_POWER): {
- preparePowerRequest();
- return RETURN_OK;
- }
- case (StarTracker::SWITCH_TO_BOOTLOADER_PROGRAM): {
- prepareRebootCommand();
- return RETURN_OK;
- }
- case (StarTracker::TAKE_IMAGE): {
- prepareTakeImageCommand(commandData);
- return RETURN_OK;
- }
- case (StarTracker::SUBSCRIBE_TO_TM): {
- prepareSubscriptionCommand(commandData);
- return RETURN_OK;
- }
- case (StarTracker::REQ_SOLUTION): {
- prepareSolutionRequest();
- return RETURN_OK;
- }
- case (StarTracker::REQ_TEMPERATURE): {
- prepareTemperatureRequest();
- return RETURN_OK;
- }
- case (StarTracker::REQ_HISTOGRAM): {
- prepareHistogramRequest();
- return RETURN_OK;
- }
- case (StarTracker::REQ_CONTRAST): {
- prepareContrastRequest();
- return RETURN_OK;
- }
- case (StarTracker::RESET_ERROR): {
- prepareErrorResetRequest();
- return RETURN_OK;
- }
- case (StarTracker::LIMITS): {
- Limits limits;
- result = prepareParamCommand(commandData, commandDataLen, limits);
- return result;
- }
- case (StarTracker::MOUNTING): {
- Mounting mounting;
- result = prepareParamCommand(commandData, commandDataLen, mounting);
- return result;
- }
- case (StarTracker::CAMERA): {
- Camera camera;
- result = prepareParamCommand(commandData, commandDataLen, camera);
- return result;
- }
- case (StarTracker::BLOB): {
- Blob blob;
- result = prepareParamCommand(commandData, commandDataLen, blob);
- return result;
- }
- case (StarTracker::CENTROIDING): {
- Centroiding centroiding;
- result = prepareParamCommand(commandData, commandDataLen, centroiding);
- return result;
- }
- case (StarTracker::LISA): {
- Lisa lisa;
- result = prepareParamCommand(commandData, commandDataLen, lisa);
- return result;
- }
- case (StarTracker::MATCHING): {
- Matching matching;
- result = prepareParamCommand(commandData, commandDataLen, matching);
- return result;
- }
- case (StarTracker::VALIDATION): {
- Validation validation;
- result = prepareParamCommand(commandData, commandDataLen, validation);
- return result;
- }
- case (StarTracker::ALGO): {
- Algo algo;
- result = prepareParamCommand(commandData, commandDataLen, algo);
- return result;
- }
- case (StarTracker::TRACKING): {
- Tracking tracking;
- 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;
- }
- case (StarTracker::REQ_CAMERA): {
- result = prepareRequestCameraParams();
- return result;
- }
- case (StarTracker::REQ_LIMITS): {
- result = prepareRequestLimitsParams();
- return result;
- }
- case (StarTracker::REQ_BLOB_PARAMS): {
- result = prepareRequestBlobParams();
- return result;
- }
- default:
- return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
- }
- return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-void StarTrackerHandler::fillCommandAndReplyMap() {
- /** Reply lengths are unknown because of the slip encoding. Thus always maximum reply size
- * is specified */
- this->insertInCommandAndReplyMap(StarTracker::PING_REQUEST, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandMap(StarTracker::BOOT);
- this->insertInCommandAndReplyMap(StarTracker::REQ_VERSION, 3, &versionSet,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::REQ_TIME, 3, &timeSet,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandMap(StarTracker::UPLOAD_IMAGE);
- this->insertInCommandMap(StarTracker::DOWNLOAD_IMAGE);
- this->insertInCommandAndReplyMap(StarTracker::REQ_POWER, 3, &powerSet,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::REQ_INTERFACE, 3, &interfaceSet,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- // Reboot has no reply. Star tracker reboots immediately
- this->insertInCommandMap(StarTracker::SWITCH_TO_BOOTLOADER_PROGRAM);
- this->insertInCommandAndReplyMap(StarTracker::SUBSCRIBE_TO_TM, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::REQ_SOLUTION, 3, &solutionSet,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::REQ_TEMPERATURE, 3, &temperatureSet,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::REQ_HISTOGRAM, 3, &histogramSet,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::REQ_CONTRAST, 3, &contrastSet,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::LIMITS, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::MOUNTING, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::CAMERA, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::BLOB, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::CENTROIDING, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::LISA, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::MATCHING, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::TRACKING, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::VALIDATION, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::ALGO, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::TAKE_IMAGE, 3, nullptr,
- 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);
- this->insertInCommandAndReplyMap(StarTracker::REQ_CAMERA, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::REQ_LIMITS, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
- this->insertInCommandAndReplyMap(StarTracker::REQ_BLOB_PARAMS, 3, nullptr,
- StarTracker::MAX_FRAME_SIZE * 2 + 2);
-}
-
-ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t* start, size_t remainingSize,
- DeviceCommandId_t* foundId, size_t* foundLen) {
- ReturnValue_t result = RETURN_OK;
- size_t bytesLeft = 0;
-
- result = dataLinkLayer.decodeFrame(start, remainingSize, &bytesLeft);
- switch (result) {
- case ArcsecDatalinkLayer::DEC_IN_PROGRESS: {
- remainingSize = bytesLeft;
- // Need a second doSendRead pass to reaa in whole packet
- return IGNORE_REPLY_DATA;
- }
- case RETURN_OK: {
- break;
- }
- default:
- remainingSize = bytesLeft;
- return result;
- }
-
- switch (dataLinkLayer.getReplyFrameType()) {
- case TMTC_ACTIONREPLY: {
- *foundLen = remainingSize - bytesLeft;
- result = scanForActionReply(foundId);
- break;
- }
- case TMTC_SETPARAMREPLY: {
- *foundLen = remainingSize - bytesLeft;
- result = scanForSetParameterReply(foundId);
- break;
- }
- case TMTC_PARAMREPLY: {
- *foundLen = remainingSize - bytesLeft;
- result = scanForGetParameterReply(foundId);
- break;
- }
- case TMTC_TELEMETRYREPLYA:
- case TMTC_TELEMETRYREPLY: {
- *foundLen = remainingSize - bytesLeft;
- result = scanForTmReply(foundId);
- break;
- }
- default: {
- sif::debug << "StarTrackerHandler::scanForReply: Reply has invalid type id" << std::endl;
- result = RETURN_FAILED;
- }
- }
-
- remainingSize = bytesLeft;
-
- return result;
-}
-
-ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
- const uint8_t* packet) {
- ReturnValue_t result = RETURN_OK;
-
- switch (id) {
- case (StarTracker::SUBSCRIBE_TO_TM): {
- result = handleSetParamReply();
- break;
- }
- case (StarTracker::REQ_TIME): {
- result = handleTm(timeSet, StarTracker::TimeSet::SIZE);
- break;
- }
- case (StarTracker::PING_REQUEST): {
- result = handlePingReply();
- break;
- }
- 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::DOWNLOAD_CENTROID): {
- result = handleActionReplySet(downloadCentroidSet, StarTracker::DownloadCentroidSet::SIZE);
- break;
- }
- 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): {
- result = handleTm(versionSet, StarTracker::VersionSet::SIZE);
- if (result != RETURN_OK) {
- return result;
- }
- result = checkProgram();
- if (result != RETURN_OK) {
- return result;
- }
- break;
- }
- case (StarTracker::REQ_INTERFACE): {
- result = handleTm(interfaceSet, StarTracker::InterfaceSet::SIZE);
- break;
- }
- case (StarTracker::REQ_POWER): {
- result = handleTm(powerSet, StarTracker::PowerSet::SIZE);
- break;
- }
- case (StarTracker::REQ_SOLUTION): {
- result = handleTm(solutionSet, StarTracker::SolutionSet::SIZE);
- break;
- }
- case (StarTracker::REQ_TEMPERATURE): {
- result = handleTm(temperatureSet, StarTracker::TemperatureSet::SIZE);
- break;
- }
- case (StarTracker::REQ_HISTOGRAM): {
- result = handleTm(histogramSet, StarTracker::HistogramSet::SIZE);
- break;
- }
- case (StarTracker::REQ_CONTRAST): {
- result = handleTm(contrastSet, StarTracker::ContrastSet::SIZE);
- break;
- }
- case (StarTracker::LIMITS):
- case (StarTracker::MOUNTING):
- case (StarTracker::CAMERA):
- case (StarTracker::BLOB):
- case (StarTracker::CENTROIDING):
- case (StarTracker::LISA):
- case (StarTracker::MATCHING):
- case (StarTracker::TRACKING):
- case (StarTracker::VALIDATION):
- case (StarTracker::ALGO): {
- result = handleSetParamReply();
- break;
- }
- case (StarTracker::REQ_CAMERA): {
- handleParamRequest(cameraSet, StarTracker::CameraSet::SIZE);
- break;
- }
- case (StarTracker::REQ_LIMITS): {
- handleParamRequest(limitsSet, StarTracker::LimitsSet::SIZE);
- break;
- }
- case (StarTracker::REQ_BLOB_PARAMS): {
- handleParamRequest(blobSet, StarTracker::BlobSet::SIZE);
- break;
- }
- default: {
- sif::debug << "StarTrackerHandler::interpretDeviceReply: Unknown device reply id:" << id
- << std::endl;
- result = DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
- }
- }
-
- return result;
-}
-
-void StarTrackerHandler::setNormalDatapoolEntriesInvalid() {}
-
-uint32_t StarTrackerHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 20000; }
-
-ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
- LocalDataPoolManager& poolManager) {
- localDataPoolMap.emplace(StarTracker::TICKS_TIME_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TIME_TIME_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::RUN_TIME, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::UNIX_TIME, new PoolEntry({0}));
-
- localDataPoolMap.emplace(StarTracker::TICKS_VERSION_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TIME_VERSION_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::PROGRAM, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::MAJOR, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::MINOR, new PoolEntry({0}));
-
- localDataPoolMap.emplace(StarTracker::TICKS_INTERFACE_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TIME_INTERFACE_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::FRAME_COUNT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CHECKSUM_ERROR_COUNT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::SET_PARAM_COUNT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::SET_PARAM_REPLY_COUNT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::PARAM_REQUEST_COUNT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::PARAM_REPLY_COUNT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::REQ_TM_COUNT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TM_REPLY_COUNT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::ACTION_REQ_COUNT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::ACTION_REPLY_COUNT, new PoolEntry({0}));
-
- localDataPoolMap.emplace(StarTracker::TICKS_POWER_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TIME_POWER_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::MCU_CURRENT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::MCU_VOLTAGE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::FPGA_CORE_CURRENT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::FPGA_CORE_VOLTAGE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::FPGA_18_CURRENT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::FPGA_18_VOLTAGE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::FPGA_25_CURRENT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::FPGA_25_VOLTAGE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CMV_21_CURRENT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CMV_21_VOLTAGE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CMV_PIX_CURRENT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CMV_PIX_VOLTAGE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CMV_33_CURRENT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CMV_33_VOLTAGE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CMV_RES_CURRENT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CMV_RES_VOLTAGE, new PoolEntry({0}));
-
- localDataPoolMap.emplace(StarTracker::TICKS_TEMPERATURE_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TIME_TEMPERATURE_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::MCU_TEMPERATURE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CMOS_TEMPERATURE, new PoolEntry({0}));
-
- localDataPoolMap.emplace(StarTracker::TICKS_SOLUTION_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TIME_SOLUTION_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CALI_QW, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CALI_QX, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CALI_QY, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CALI_QZ, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TRACK_CONFIDENCE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TRACK_QW, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TRACK_QX, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TRACK_QY, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TRACK_QZ, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TRACK_REMOVED, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::STARS_CENTROIDED, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::STARS_MATCHED_DATABASE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::LISA_QW, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::LISA_QX, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::LISA_QY, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::LISA_QZ, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::LISA_PERC_CLOSE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::LISA_NR_CLOSE, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TRUST_WORTHY, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::STABLE_COUNT, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::SOLUTION_STRATEGY, new PoolEntry({0}));
-
- localDataPoolMap.emplace(StarTracker::TICKS_HISTOGRAM_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TIME_HISTOGRAM_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINA0, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINA1, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINA2, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINA3, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINA4, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINA5, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINA6, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINA7, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINA8, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINB0, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINB1, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINB2, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINB3, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINB4, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINB5, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINB6, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINB7, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINB8, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINC0, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINC1, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINC2, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINC3, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINC4, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINC5, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINC6, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINC7, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BINC8, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BIND0, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BIND1, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BIND2, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BIND3, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BIND4, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BIND5, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BIND6, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BIND7, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::HISTOGRAM_BIND8, new PoolEntry({0}));
-
- localDataPoolMap.emplace(StarTracker::TICKS_CONTRAST_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::TIME_CONTRAST_SET, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINA0, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINA1, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINA2, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINA3, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINA4, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINA5, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINA6, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINA7, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINA8, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINB0, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINB1, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINB2, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINB3, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINB4, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINB5, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINB6, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINB7, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINB8, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINC8, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINC0, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINC1, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINC2, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINC3, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINC4, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINC5, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINC6, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINC7, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BINC8, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BIND0, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BIND1, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BIND2, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BIND3, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BIND4, new PoolEntry({0}));
- localDataPoolMap.emplace(StarTracker::CONTRAST_BIND5, new PoolEntry({0}));
- 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