eive-obsw/mission/devices/BpxBatteryHandler.cpp

283 lines
9.3 KiB
C++
Raw Normal View History

2022-01-17 15:35:46 +01:00
#include "BpxBatteryHandler.h"
2022-02-02 17:53:07 +01:00
#include <fsfw/datapool/PoolReadGuard.h>
2022-01-17 15:35:46 +01:00
2022-02-03 13:37:48 +01:00
#include "OBSWConfig.h"
2022-01-17 15:35:46 +01:00
BpxBatteryHandler::BpxBatteryHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie)
2022-02-03 13:37:48 +01:00
: DeviceHandlerBase(objectId, comIF, comCookie), hkSet(this), cfgSet(this) {}
2022-01-17 15:35:46 +01:00
BpxBatteryHandler::~BpxBatteryHandler() {}
2022-02-02 16:07:28 +01:00
void BpxBatteryHandler::doStartUp() {
if (state == States::CHECK_COM) {
if (commandExecuted) {
2022-02-02 16:07:28 +01:00
state = States::IDLE;
commandExecuted = false;
if (goToNormalModeImmediately) {
2022-02-02 16:07:28 +01:00
setMode(MODE_NORMAL);
} else {
setMode(_MODE_TO_ON);
}
}
}
}
2022-01-17 15:35:46 +01:00
2022-02-02 16:07:28 +01:00
void BpxBatteryHandler::doShutDown() {
// Perform a COM check on reboot
state = States::CHECK_COM;
}
2022-01-17 15:35:46 +01:00
ReturnValue_t BpxBatteryHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
2022-02-02 16:07:28 +01:00
*id = BpxBattery::GET_HK;
return buildCommandFromCommand(*id, nullptr, 0);
2022-01-17 15:35:46 +01:00
}
ReturnValue_t BpxBatteryHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
2022-02-03 13:37:48 +01:00
if (state == States::CHECK_COM) {
2022-02-02 17:53:07 +01:00
*id = BpxBattery::PING;
return buildCommandFromCommand(*id, nullptr, 0);
}
2022-01-17 15:35:46 +01:00
return HasReturnvaluesIF::RETURN_OK;
}
2022-01-17 17:11:27 +01:00
void BpxBatteryHandler::fillCommandAndReplyMap() {
using namespace BpxBattery;
insertInCommandAndReplyMap(GET_HK, 1, &hkSet, GET_HK_REPLY_LEN);
insertInCommandAndReplyMap(BpxBattery::PING, 1, nullptr, PING_REPLY_LEN);
2022-02-03 15:03:35 +01:00
insertInCommandAndReplyMap(BpxBattery::REBOOT, 1, nullptr, 0);
2022-02-03 16:04:24 +01:00
insertInCommandAndReplyMap(BpxBattery::RESET_COUNTERS, 1, nullptr, EMPTY_REPLY_LEN);
insertInCommandAndReplyMap(BpxBattery::CONFIG_CMD, 1, nullptr, EMPTY_REPLY_LEN);
insertInCommandAndReplyMap(BpxBattery::CONFIG_GET, 1, &cfgSet, CONFIG_GET_REPLY_LEN);
2022-01-17 17:11:27 +01:00
}
2022-01-17 15:35:46 +01:00
ReturnValue_t BpxBatteryHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
const uint8_t* commandData,
size_t commandDataLen) {
switch (deviceCommand) {
2022-02-03 13:37:48 +01:00
case (BpxBattery::GET_HK): {
cmdBuf[0] = BpxBattery::PORT_GET_HK;
this->rawPacketLen = 1;
break;
}
case (BpxBattery::PING): {
2022-02-02 17:53:07 +01:00
if (commandDataLen == 1 and commandData != nullptr) {
sentPingByte = commandData[0];
} else {
sentPingByte = BpxBattery::DEFAULT_PING_SENT_BYTE;
}
2022-02-02 16:07:28 +01:00
cmdBuf[0] = BpxBattery::PORT_PING;
cmdBuf[1] = sentPingByte;
this->rawPacketLen = 2;
break;
2022-02-02 16:07:28 +01:00
}
case (BpxBattery::REBOOT): {
cmdBuf[0] = BpxBattery::PORT_REBOOT;
cmdBuf[1] = 0x80;
cmdBuf[2] = 0x07;
cmdBuf[3] = 0x80;
cmdBuf[4] = 0x07;
this->rawPacketLen = 5;
// This instructs the FDIR to set the device mode off and on again
// to ensure the I2C communication is also verified
triggerEvent(DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT);
break;
2022-02-02 16:07:28 +01:00
}
case (BpxBattery::RESET_COUNTERS): {
cmdBuf[0] = BpxBattery::PORT_RESET_COUNTERS;
cmdBuf[1] = BpxBattery::RESET_COUNTERS_MAGIC_VALUE;
this->rawPacketLen = 2;
break;
2022-02-02 16:07:28 +01:00
}
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;
2022-02-02 16:07:28 +01:00
}
}
this->rawPacket = cmdBuf.data();
lastCmd = deviceCommand;
2022-01-17 15:35:46 +01:00
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t BpxBatteryHandler::scanForReply(const uint8_t* start, size_t remainingSize,
DeviceCommandId_t* foundId, size_t* foundLen) {
using namespace BpxBattery;
switch (lastCmd) {
case (BpxBattery::GET_HK): {
if (remainingSize != GET_HK_REPLY_LEN) {
return DeviceHandlerIF::LENGTH_MISSMATCH;
}
break;
2022-02-02 16:07:28 +01:00
}
case (BpxBattery::PING):
case (BpxBattery::MAN_HEAT_ON):
case (BpxBattery::MAN_HEAT_OFF): {
if (remainingSize != PING_REPLY_LEN) {
return DeviceHandlerIF::LENGTH_MISSMATCH;
}
break;
}
case (BpxBattery::REBOOT): {
// Ignore
break;
}
case (BpxBattery::RESET_COUNTERS):
case (BpxBattery::CONFIG_CMD):
case (BpxBattery::CONFIG_SET): {
if (remainingSize != EMPTY_REPLY_LEN) {
return DeviceHandlerIF::LENGTH_MISSMATCH;
}
break;
}
case (BpxBattery::CONFIG_GET): {
if (remainingSize != CONFIG_GET_REPLY_LEN) {
return DeviceHandlerIF::LENGTH_MISSMATCH;
}
2022-02-03 13:37:48 +01:00
break;
}
default: {
return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
2022-02-02 16:07:28 +01:00
}
}
2022-02-03 13:37:48 +01:00
*foundLen = remainingSize;
2022-02-02 16:07:28 +01:00
*foundId = lastCmd;
2022-01-17 15:35:46 +01:00
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t BpxBatteryHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
if (id != BpxBattery::REBOOT and packet[1] != 0) {
2022-02-03 15:03:35 +01:00
return DeviceHandlerIF::DEVICE_REPORTED_ERROR;
}
switch (id) {
case (BpxBattery::GET_HK): {
2022-02-02 17:53:07 +01:00
PoolReadGuard rg(&hkSet);
2022-02-03 13:37:48 +01:00
ReturnValue_t result = hkSet.parseRawHk(packet + 2, 21);
2022-02-03 15:03:35 +01:00
hkSet.setValidity(true, true);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
2022-02-02 17:53:07 +01:00
#if OBSW_DEBUG_BPX_BATT == 1
2022-02-03 13:37:48 +01:00
sif::info << "BPX Battery HK output:" << std::endl;
sif::info << "Charge current [mA]: " << hkSet.chargeCurrent << std::endl;
sif::info << "Discharge current [mA]: " << hkSet.dischargeCurrent << std::endl;
sif::info << "Heater current [mA]: " << hkSet.heaterCurrent << std::endl;
sif::info << "Battery voltage [mV]: " << hkSet.battVoltage << std::endl;
sif::info << "Battery Temperature 1 [C]: " << hkSet.battTemp1 << std::endl;
sif::info << "Battery Temperature 2 [C]: " << hkSet.battTemp2 << std::endl;
sif::info << "Battery Temperature 3 [C]: " << hkSet.battTemp3 << std::endl;
sif::info << "Battery Temperature 4 [C]: " << hkSet.battTemp4 << std::endl;
sif::info << "Battery Reboot Counter: " << hkSet.rebootCounter << std::endl;
sif::info << "Battery Boot Cause: " << static_cast<int>(hkSet.bootcause.value) << std::endl;
2022-02-02 17:53:07 +01:00
#endif
break;
}
case (BpxBattery::PING): {
2022-02-03 13:37:48 +01:00
if (packet[2] != sentPingByte) {
2022-02-03 16:04:24 +01:00
return DeviceHandlerIF::INVALID_DATA;
}
2022-02-03 13:37:48 +01:00
if (mode == _MODE_START_UP) {
2022-02-03 12:02:25 +01:00
commandExecuted = true;
}
break;
}
case (BpxBattery::RESET_COUNTERS):
case (BpxBattery::CONFIG_CMD):
case (BpxBattery::CONFIG_SET): {
break;
}
case (BpxBattery::MAN_HEAT_ON):
case (BpxBattery::MAN_HEAT_OFF): {
2022-02-03 13:37:48 +01:00
if (packet[2] != 0x01) {
return DeviceHandlerIF::DEVICE_DID_NOT_EXECUTE;
}
break;
}
case (BpxBattery::CONFIG_GET): {
2022-02-02 17:53:07 +01:00
PoolReadGuard rg(&cfgSet);
2022-02-03 13:37:48 +01:00
ReturnValue_t result = cfgSet.parseRawHk(packet + 2, 3);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
2022-02-03 15:31:18 +01:00
cfgSet.setValidity(true, true);
break;
}
2022-02-03 16:04:24 +01:00
case (BpxBattery::REBOOT): {
break;
}
default: {
return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
2022-02-02 16:07:28 +01:00
}
}
2022-01-17 15:35:46 +01:00
return HasReturnvaluesIF::RETURN_OK;
}
uint32_t BpxBatteryHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 10000; }
ReturnValue_t BpxBatteryHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
LocalDataPoolManager& poolManager) {
2022-02-03 15:31:18 +01:00
localDataPoolMap.emplace(BpxBattery::BATT_TEMP_1, &battTemp1);
localDataPoolMap.emplace(BpxBattery::BATT_TEMP_2, &battTemp2);
localDataPoolMap.emplace(BpxBattery::BATT_TEMP_3, &battTemp3);
localDataPoolMap.emplace(BpxBattery::BATT_TEMP_4, &battTemp4);
localDataPoolMap.emplace(BpxBattery::CHARGE_CURRENT, &chargeCurrent);
localDataPoolMap.emplace(BpxBattery::DISCHARGE_CURRENT, &dischargeCurrent);
localDataPoolMap.emplace(BpxBattery::HEATER_CURRENT, &heaterCurrent);
localDataPoolMap.emplace(BpxBattery::BATT_VOLTAGE, &battVolt);
localDataPoolMap.emplace(BpxBattery::REBOOT_COUNTER, &rebootCounter);
localDataPoolMap.emplace(BpxBattery::BOOTCAUSE, &bootCause);
localDataPoolMap.emplace(BpxBattery::BATTERY_HEATER_MODE, &battheatMode);
localDataPoolMap.emplace(BpxBattery::BATTHEAT_LOW_LIMIT, &battheatLow);
localDataPoolMap.emplace(BpxBattery::BATTHEAT_HIGH_LIMIT, &battheatHigh);
#if OBSW_ENABLE_PERIODIC_HK == 1
poolManager.subscribeForPeriodicPacket(hkSet.getSid(), true, 1.0, false);
#endif
2022-01-17 15:35:46 +01:00
return HasReturnvaluesIF::RETURN_OK;
}
2022-02-02 17:36:40 +01:00
void BpxBatteryHandler::setToGoToNormalMode(bool enable) {
this->goToNormalModeImmediately = enable;
}