From 89bbf98b4afb7a7d4e76a006a178d433b61f8622 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 2 Feb 2022 16:07:28 +0100 Subject: [PATCH] continued BPX handler --- fsfw | 2 +- mission/devices/BpxBatteryHandler.cpp | 169 ++++++++++++++++-- mission/devices/BpxBatteryHandler.h | 14 +- .../devicedefinitions/BpxBatteryDefinitions.h | 16 +- 4 files changed, 181 insertions(+), 20 deletions(-) diff --git a/fsfw b/fsfw index 33386550..6698d283 160000 --- a/fsfw +++ b/fsfw @@ -1 +1 @@ -Subproject commit 33386550cf81e47f4a3c95cd063349442dd83d09 +Subproject commit 6698d283b6576bc867b28d06ff772e4b3bb5c33f diff --git a/mission/devices/BpxBatteryHandler.cpp b/mission/devices/BpxBatteryHandler.cpp index 111a5acf..5d6d2d09 100644 --- a/mission/devices/BpxBatteryHandler.cpp +++ b/mission/devices/BpxBatteryHandler.cpp @@ -5,12 +5,28 @@ BpxBatteryHandler::BpxBatteryHandler(object_id_t objectId, object_id_t comIF, Co BpxBatteryHandler::~BpxBatteryHandler() {} -void BpxBatteryHandler::doStartUp() {} +void BpxBatteryHandler::doStartUp() { + if(state == States::CHECK_COM) { + if(commandExecuted) { + state = States::IDLE; + commandExecuted = false; + if(goToNormalModeImmediately) { + setMode(MODE_NORMAL); + } else { + setMode(_MODE_TO_ON); + } + } + } +} -void BpxBatteryHandler::doShutDown() {} +void BpxBatteryHandler::doShutDown() { + // Perform a COM check on reboot + state = States::CHECK_COM; +} ReturnValue_t BpxBatteryHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) { - return HasReturnvaluesIF::RETURN_OK; + *id = BpxBattery::GET_HK; + return buildCommandFromCommand(*id, nullptr, 0); } ReturnValue_t BpxBatteryHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) { @@ -18,34 +34,165 @@ ReturnValue_t BpxBatteryHandler::buildTransitionDeviceCommand(DeviceCommandId_t* } void BpxBatteryHandler::fillCommandAndReplyMap() { - insertInCommandAndReplyMap(BpxBattery::READ_HK, 1, &hkSet); + insertInCommandAndReplyMap(BpxBattery::GET_HK, 1, &hkSet); insertInCommandAndReplyMap(BpxBattery::PING, 1); insertInCommandAndReplyMap(BpxBattery::REBOOT, 1); insertInCommandAndReplyMap(BpxBattery::RESET_COUNTERS, 1); - insertInCommandAndReplyMap(BpxBattery::RESTORE_DEFAULT_CONFIG, 1); - insertInCommandAndReplyMap(BpxBattery::READ_CONFIG, 1); + insertInCommandAndReplyMap(BpxBattery::CONFIG_CMD, 1); + insertInCommandAndReplyMap(BpxBattery::CONFIG_GET, 1, &cfgSet); } ReturnValue_t BpxBatteryHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData, size_t commandDataLen) { + switch(deviceCommand) { + case(BpxBattery::PING): { + if(commandDataLen == 1) { + sentPingByte = commandData[0]; + } else { + sentPingByte = BpxBattery::DEFAULT_PING_SENT_BYTE; + } + + cmdBuf[0] = BpxBattery::PORT_PING; + cmdBuf[1] = sentPingByte; + this->rawPacketLen = 2; + break; + } + case(BpxBattery::REBOOT): { + cmdBuf[0] = BpxBattery::PORT_REBOOT; + cmdBuf[1] = 0x80; + cmdBuf[2] = 0x07; + cmdBuf[3] = 0x80; + cmdBuf[4] = 0x07; + this->rawPacketLen = 5; + triggerEvent(DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT); + break; + } + case(BpxBattery::RESET_COUNTERS): { + cmdBuf[0] = BpxBattery::PORT_RESET_COUNTERS; + cmdBuf[1] = BpxBattery::RESET_COUNTERS_MAGIC_VALUE; + this->rawPacketLen = 2; + break; + } + case(BpxBattery::CONFIG_CMD): { + cmdBuf[0] = BpxBattery::PORT_CONFIG_CMD; + // Needs to be set to 0x01 according to datasheet + cmdBuf[1] = 0x01; + this->rawPacketLen = 2; + break; + } + case(BpxBattery::CONFIG_GET): { + cmdBuf[0] = BpxBattery::PORT_CONFIG_GET; + this->rawPacketLen = 1; + break; + } + case(BpxBattery::CONFIG_SET): { + cmdBuf[0] = BpxBattery::PORT_CONFIG_SET; + if(commandDataLen != 3) { + return DeviceHandlerIF::INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS; + } + for(uint8_t idx = 0; idx < 3; idx ++) { + cmdBuf[idx + 1] = commandData[idx]; + } + this->rawPacketLen = 4; + break; + } + case(BpxBattery::MAN_HEAT_ON): { + cmdBuf[0] = BpxBattery::PORT_MAN_HEAT_ON; + if(commandDataLen != 2) { + return DeviceHandlerIF::INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS; + } + for(uint8_t idx = 0; idx < 2; idx++) { + cmdBuf[idx + 1] = commandData[idx]; + } + this->rawPacketLen = 3; + break; + } + case(BpxBattery::MAN_HEAT_OFF): { + cmdBuf[0] = BpxBattery::PORT_MAN_HEAT_OFF; + this->rawPacketLen = 1; + break; + } + default: { + return DeviceHandlerIF::COMMAND_NOT_SUPPORTED; + } + } + this->rawPacket = cmdBuf.data(); + + lastCmd = deviceCommand; return HasReturnvaluesIF::RETURN_OK; } ReturnValue_t BpxBatteryHandler::scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId, size_t* foundLen) { + switch(lastCmd) { + case(BpxBattery::GET_HK): { + if(remainingSize != 21) { + return DeviceHandlerIF::LENGTH_MISSMATCH; + } + *foundLen = 21; + break; + } + case(BpxBattery::PING): + case(BpxBattery::MAN_HEAT_ON): + case(BpxBattery::MAN_HEAT_OFF): { + if(remainingSize != 1) { + return DeviceHandlerIF::LENGTH_MISSMATCH; + } + *foundLen = 1; + break; + } + case(BpxBattery::REBOOT): + case(BpxBattery::RESET_COUNTERS): + case(BpxBattery::CONFIG_CMD): + case(BpxBattery::CONFIG_SET): { + if(remainingSize != 0) { + return DeviceHandlerIF::LENGTH_MISSMATCH; + } + *foundLen = 0; + break; + } + case(BpxBattery::CONFIG_GET): { + if(remainingSize != 3) { + return DeviceHandlerIF::LENGTH_MISSMATCH; + } + *foundLen = 3; + break; + } + default: { + return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY; + } + } + *foundId = lastCmd; return HasReturnvaluesIF::RETURN_OK; } -ReturnValue_t BpxBatteryHandler::interpretDeviceReply(DeviceCommandId_t ixd, +ReturnValue_t BpxBatteryHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) { + switch(id) { + case(BpxBattery::GET_HK): { + ReturnValue_t result = hkSet.parseRawHk(packet, 21); + if(result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + break; + } + case(BpxBattery::PING): { + if (packet[0] != sentPingByte) { + return DeviceHandlerIF::INVALID_DATA; + } + break; + } + case(BpxBattery::RESET_COUNTERS): { + break; + } + default: { + return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY; + } + } return HasReturnvaluesIF::RETURN_OK; } -void BpxBatteryHandler::setNormalDatapoolEntriesInvalid() {} - -LocalPoolDataSetBase* BpxBatteryHandler::getDataSetHandle(sid_t sid) { return nullptr; } - uint32_t BpxBatteryHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 10000; } ReturnValue_t BpxBatteryHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap, diff --git a/mission/devices/BpxBatteryHandler.h b/mission/devices/BpxBatteryHandler.h index 2699f548..bcd0585b 100644 --- a/mission/devices/BpxBatteryHandler.h +++ b/mission/devices/BpxBatteryHandler.h @@ -11,8 +11,19 @@ class BpxBatteryHandler : public DeviceHandlerBase { virtual ~BpxBatteryHandler(); protected: + enum class States { + CHECK_COM = 0, + IDLE = 1, + }; + + States state = States::CHECK_COM; + bool commandExecuted = false; + bool goToNormalModeImmediately = false; + uint8_t sentPingByte = BpxBattery::DEFAULT_PING_SENT_BYTE; BpxBatteryHk hkSet; + DeviceCommandId_t lastCmd = DeviceHandlerIF::NO_COMMAND_ID; BpxBatteryCfg cfgSet; + std::array cmdBuf = {}; void doStartUp() override; void doShutDown() override; @@ -23,8 +34,7 @@ class BpxBatteryHandler : public DeviceHandlerBase { size_t commandDataLen) override; ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId, size_t* foundLen) override; - ReturnValue_t interpretDeviceReply(DeviceCommandId_t ixd, const uint8_t* packet) override; - void setNormalDatapoolEntriesInvalid() override; + ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override; virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override; uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override; ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap, diff --git a/mission/devices/devicedefinitions/BpxBatteryDefinitions.h b/mission/devices/devicedefinitions/BpxBatteryDefinitions.h index 1fbe4653..d7ef4aa5 100644 --- a/mission/devices/devicedefinitions/BpxBatteryDefinitions.h +++ b/mission/devices/devicedefinitions/BpxBatteryDefinitions.h @@ -23,16 +23,20 @@ enum HkPoolIds { enum CfgPoolIds { BATTERY_HEATER_MODE = 0, BATTHEAT_LOW_LIMIT = 1, BATTHEAT_HIGH_LIMIT = 2 }; -static constexpr DeviceCommandId_t READ_HK = 0; +static constexpr DeviceCommandId_t GET_HK = 0; static constexpr DeviceCommandId_t PING = 1; static constexpr DeviceCommandId_t REBOOT = 2; static constexpr DeviceCommandId_t RESET_COUNTERS = 3; -static constexpr DeviceCommandId_t RESTORE_DEFAULT_CONFIG = 4; -static constexpr DeviceCommandId_t READ_CONFIG = 5; -static constexpr DeviceCommandId_t WRITE_CONFIG = 6; +// This is the mnemonic GomSpace chose, but this command actually restores the default config +static constexpr DeviceCommandId_t CONFIG_CMD = 4; +static constexpr DeviceCommandId_t CONFIG_GET = 5; +static constexpr DeviceCommandId_t CONFIG_SET = 6; -static constexpr DeviceCommandId_t MANUAL_HEATER_ON = 10; -static constexpr DeviceCommandId_t MANUAL_HEATER_OFF = 11; +static constexpr DeviceCommandId_t MAN_HEAT_ON = 10; +static constexpr DeviceCommandId_t MAN_HEAT_OFF = 11; + +static constexpr uint8_t RESET_COUNTERS_MAGIC_VALUE = 0x42; +static constexpr uint8_t DEFAULT_PING_SENT_BYTE = 0x07; static constexpr uint32_t HK_SET_ID = 0; static constexpr uint32_t CFG_SET_ID = 1;