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

heater handler wip

Browse Source
This commit is contained in:
Jakob Meier
2021-01-28 14:55:21 +01:00
parent 61ed56ace9 db15a7921d
commit 560e538f62
60 changed files with 1934 additions and 774 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
mission/devices/GomspaceDeviceHandler.cpp
View File

@ -2,14 +2,14 @@
#include <mission/devices/devicedefinitions/GomSpacePackets.h>
GomspaceDeviceHandler::GomspaceDeviceHandler(object_id_t objectId, object_id_t comIF,
CookieIF * comCookie, uint16_t maxConfigTableAddress,
uint16_t maxHkTableAddress) :
DeviceHandlerBase(objectId, comIF, comCookie), maxConfigTableAddress(
maxConfigTableAddress), maxHkTableAddress(maxHkTableAddress) {
mode = MODE_NORMAL;
if (comCookie == NULL) {
sif::error << "GomspaceDeviceHandler invalid com cookie" << std::endl;
}
CookieIF * comCookie, uint16_t maxConfigTableAddress, uint16_t maxHkTableAddress,
uint16_t hkTableSize) :
DeviceHandlerBase(objectId, comIF, comCookie), maxConfigTableAddress(maxConfigTableAddress), maxHkTableAddress(
maxHkTableAddress), hkTableSize(hkTableSize) {
mode = MODE_NORMAL;
if (comCookie == NULL) {
sif::error << "GomspaceDeviceHandler invalid com cookie" << std::endl;
}
}
GomspaceDeviceHandler::~GomspaceDeviceHandler() {
@ -38,38 +38,41 @@ ReturnValue_t GomspaceDeviceHandler::buildCommandFromCommand(
size_t commandDataLen) {
ReturnValue_t result;
switch(deviceCommand) {
case(PING): {
case(GOMSPACE::PING): {
result = generatePingCommand(commandData, commandDataLen);
if(result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
break;
}
case(REBOOT): {
case(GOMSPACE::REBOOT): {
generateRebootCommand();
break;
}
case(PARAM_SET):{
case(GOMSPACE::PARAM_SET):{
result = generateSetParamCommand(commandData, commandDataLen);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
break;
}
case(PARAM_GET):{
case(GOMSPACE::PARAM_GET):{
result = generateGetParamCommand(commandData, commandDataLen);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
break;
}
case(GNDWDT_RESET): {
case(GOMSPACE::GNDWDT_RESET): {
result = generateResetWatchdogCmd();
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
break;
}
case(GOMSPACE::REQUEST_HK_TABLE): {
generateRequestFullHkTableCmd(hkTableSize);
}
default:
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
}
@ -77,31 +80,38 @@ ReturnValue_t GomspaceDeviceHandler::buildCommandFromCommand(
}
void GomspaceDeviceHandler::fillCommandAndReplyMap(){
this->insertInCommandAndReplyMap(PING, 3);
this->insertInCommandMap(REBOOT);
this->insertInCommandAndReplyMap(PARAM_SET, 3);
this->insertInCommandAndReplyMap(PARAM_GET, 3);
this->insertInCommandMap(GNDWDT_RESET);
this->insertInCommandAndReplyMap(GOMSPACE::PING, 3);
this->insertInCommandMap(GOMSPACE::REBOOT);
this->insertInCommandAndReplyMap(GOMSPACE::PARAM_SET, 3);
this->insertInCommandAndReplyMap(GOMSPACE::PARAM_GET, 3);
this->insertInCommandAndReplyMap(GOMSPACE::REQUEST_HK_TABLE, 3);
this->insertInCommandMap(GOMSPACE::GNDWDT_RESET);
}
ReturnValue_t GomspaceDeviceHandler::scanForReply(const uint8_t *start,
size_t remainingSize, DeviceCommandId_t *foundId, size_t *foundLen) {
switch(rememberCommandId) {
case(PING):
*foundId = PING;
case(GOMSPACE::PING):
*foundId = GOMSPACE::PING;
*foundLen = PING_REPLY_SIZE;
rememberCommandId = NONE;
rememberCommandId = GOMSPACE::NONE;
break;
case(PARAM_GET): {
*foundId = PARAM_GET;
*foundLen = rememberRequestedSize + CspGetParamReply::GS_HDR_LENGTH;
rememberCommandId = NONE;
case(GOMSPACE::PARAM_GET): {
*foundId = GOMSPACE::PARAM_GET;
*foundLen = rememberRequestedSize + GOMSPACE::GS_HDR_LENGTH;
rememberCommandId = GOMSPACE::NONE;
break;
}
case(PARAM_SET): {
*foundId = PARAM_SET;
case(GOMSPACE::PARAM_SET): {
*foundId = GOMSPACE::PARAM_SET;
*foundLen = rememberRequestedSize;
rememberCommandId = NONE;
rememberCommandId = GOMSPACE::NONE;
break;
}
case(GOMSPACE::REQUEST_HK_TABLE): {
*foundId = GOMSPACE::REQUEST_HK_TABLE;
*foundLen = rememberRequestedSize + GOMSPACE::GS_HDR_LENGTH;
rememberCommandId = GOMSPACE::NONE;
break;
}
default:
@ -113,12 +123,12 @@ ReturnValue_t GomspaceDeviceHandler::scanForReply(const uint8_t *start,
ReturnValue_t GomspaceDeviceHandler::interpretDeviceReply(DeviceCommandId_t id,
const uint8_t *packet) {
switch(id) {
case(PING): {
case(GOMSPACE::PING): {
SerializeElement<uint32_t> replyTime = *packet;
handleDeviceTM(&replyTime, id, true);
break;
}
case(PARAM_GET): {
case(GOMSPACE::PARAM_GET): {
// -2 to subtract address size from gomspace parameter reply packet
uint16_t payloadLength = (*(packet + 2) << 8 | *(packet + 3)) - 2;
if(payloadLength > sizeof(uint32_t)){
@ -129,7 +139,7 @@ ReturnValue_t GomspaceDeviceHandler::interpretDeviceReply(DeviceCommandId_t id,
uint8_t tempPayloadBuffer[payloadLength];
/* Extract information from received data */
CspGetParamReply cspGetParamReply(tempPayloadBuffer, payloadLength);
size_t size = CspGetParamReply::GS_HDR_LENGTH + payloadLength;
size_t size = GOMSPACE::GS_HDR_LENGTH + payloadLength;
ReturnValue_t result = cspGetParamReply.deSerialize(&packet, &size,
SerializeIF::Endianness::BIG);
if(result != HasReturnvaluesIF::RETURN_OK){
@ -146,7 +156,7 @@ ReturnValue_t GomspaceDeviceHandler::interpretDeviceReply(DeviceCommandId_t id,
handleDeviceTM(&paramReply, id, true);
break;
}
case(PARAM_SET): {
case(GOMSPACE::PARAM_SET): {
/* When setting a parameter, the p60dock sends back the state of the
* operation */
if(*packet != PARAM_SET_OK){
@ -154,6 +164,10 @@ ReturnValue_t GomspaceDeviceHandler::interpretDeviceReply(DeviceCommandId_t id,
}
break;
}
case(GOMSPACE::REQUEST_HK_TABLE): {
letChildHandleHkReply(id, packet);
break;
}
default:
break;
}
@ -211,7 +225,7 @@ ReturnValue_t GomspaceDeviceHandler::generateSetParamCommand(
rawPacket = cspPacket;
rawPacketLen = cspPacketLen;
rememberRequestedSize = querySize;
rememberCommandId = PARAM_SET;
rememberCommandId = GOMSPACE::PARAM_SET;
return HasReturnvaluesIF::RETURN_OK;
}
@ -256,7 +270,7 @@ ReturnValue_t GomspaceDeviceHandler::generateGetParamCommand(
<< "size" << std::endl;
return INVALID_PARAM_SIZE;
}
uint16_t querySize = parameterSize + CspGetParamCommand::GS_HDR_LENGTH;
uint16_t querySize = parameterSize + GOMSPACE::GS_HDR_LENGTH;
/* Generate the CSP command to send to the P60 Dock */
CspGetParamCommand getParamCmd(querySize, tableId, length,
@ -277,7 +291,7 @@ ReturnValue_t GomspaceDeviceHandler::generateGetParamCommand(
rawPacket = cspPacket;
rawPacketLen = cspPacketLen;
rememberRequestedSize = querySize;
rememberCommandId = PARAM_GET;
rememberCommandId = GOMSPACE::PARAM_GET;
return HasReturnvaluesIF::RETURN_OK;
}
@ -301,7 +315,7 @@ ReturnValue_t GomspaceDeviceHandler::generatePingCommand(
}
rawPacket = cspPacket;
rawPacketLen = cspPacketLen;
rememberCommandId = PING;
rememberCommandId = GOMSPACE::PING;
return HasReturnvaluesIF::RETURN_OK;
}
@ -330,10 +344,32 @@ ReturnValue_t GomspaceDeviceHandler::generateResetWatchdogCmd(){
rawPacketLen = cspPacketLen;
rememberRequestedSize = 0; // No bytes will be queried with the ground
// watchdog command.
rememberCommandId = GNDWDT_RESET;
rememberCommandId = GOMSPACE::GNDWDT_RESET;
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t GomspaceDeviceHandler::generateRequestFullHkTableCmd(uint16_t hkTableSize) {
uint16_t querySize = hkTableSize + GOMSPACE::GS_HDR_LENGTH;
uint8_t tableId = HK_TABLE_ID;
RequestFullTableCommand requestFullTableCommand(querySize, tableId);
size_t cspPacketLen = 0;
uint8_t* buffer = cspPacket;
ReturnValue_t result = requestFullTableCommand.serialize(&buffer,
&cspPacketLen, sizeof(cspPacket), SerializeIF::Endianness::BIG);
if(result != HasReturnvaluesIF::RETURN_OK){
sif::error << "GomspaceDeviceHandler::generateRequestFullHkTableCmd Failed to serialize "
"full table request command " << std::endl;
return result;
}
rawPacket = cspPacket;
rawPacketLen = cspPacketLen;
rememberRequestedSize = querySize;
rememberCommandId = GOMSPACE::REQUEST_HK_TABLE;
return RETURN_OK;
}
uint32_t GomspaceDeviceHandler::getTransitionDelayMs(Mode_t modeFrom,
Mode_t modeTo) {
return 0;