diff --git a/libcsp/src/drivers/can/can_socketcan.c b/libcsp/src/drivers/can/can_socketcan.c index 94c6bdde..d6d6b9e1 100644 --- a/libcsp/src/drivers/can/can_socketcan.c +++ b/libcsp/src/drivers/can/can_socketcan.c @@ -95,6 +95,12 @@ static void * socketcan_rx_thread(void * parameters) /* Strip flags */ frame.can_id &= CAN_EFF_MASK; + printf("socketcan_rx_thread: CAN bytes received: "); + /* Print received data */ + for (int i = 0; i < 8; i++) { + printf("%x, ", frame.data[i]); + } + /* Call RX callbacsp_can_rx_frameck */ csp_can_rx(&socketcan[0].interface, frame.can_id, frame.data, frame.can_dlc, NULL); } diff --git a/linux/csp/CspComIF.cpp b/linux/csp/CspComIF.cpp index bfe7e7e9..1798b152 100644 --- a/linux/csp/CspComIF.cpp +++ b/linux/csp/CspComIF.cpp @@ -28,7 +28,7 @@ ReturnValue_t CspComIF::initializeInterface(CookieIF *cookie) { int buf_count = 10; int buf_size = 300; /* Init CSP and CSP buffer system */ - if (csp_init(cspClientAddress) != CSP_ERR_NONE + if (csp_init(cspOwnAddress) != CSP_ERR_NONE || csp_buffer_init(buf_count, buf_size) != CSP_ERR_NONE) { sif::error << "Failed to init CSP\r\n" << std::endl; return HasReturnvaluesIF::RETURN_FAILED; diff --git a/linux/csp/CspComIF.h b/linux/csp/CspComIF.h index 78f5158f..4855fbf8 100644 --- a/linux/csp/CspComIF.h +++ b/linux/csp/CspComIF.h @@ -65,7 +65,7 @@ private: uint16_t replySize = 0; /* This is the CSP address of the OBC. */ - node_t cspClientAddress = 1; + node_t cspOwnAddress = 1; /* Interface struct for csp protocol stack */ csp_iface_t csp_if; diff --git a/mission/devices/PDU1Handler.cpp b/mission/devices/PDU1Handler.cpp index 92281f49..559ce94d 100644 --- a/mission/devices/PDU1Handler.cpp +++ b/mission/devices/PDU1Handler.cpp @@ -20,7 +20,7 @@ ReturnValue_t PDU1Handler::buildNormalDeviceCommand( void PDU1Handler::letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *packet) { parseHkTableReply(packet); -// handleDeviceTM(&pdu1HkTableDataset, id, true); + handleDeviceTM(&pdu1HkTableDataset, id, true); #if OBSW_VERBOSE_LEVEL >= 1 && PDU1_DEBUG == 1 pdu1HkTableDataset.read(); diff --git a/mission/devices/SolarArrayDeploymentHandler.cpp b/mission/devices/SolarArrayDeploymentHandler.cpp index 9c0ebed4..45521800 100644 --- a/mission/devices/SolarArrayDeploymentHandler.cpp +++ b/mission/devices/SolarArrayDeploymentHandler.cpp @@ -84,14 +84,13 @@ void SolarArrayDeploymentHandler::handleStateMachine() { break; case WAIT_FOR_MAIN_SWITCH_OFF: if (mainLineSwitcher->getSwitchState(mainLineSwitch) == PowerSwitchIF::SWITCH_OFF) { - stateMachine = FINISHED_DEPLOYMENT; + stateMachine = WAIT_ON_DELOYMENT_COMMAND; } else if (mainSwitchCountdown.hasTimedOut()) { triggerEvent(MAIN_SWITCH_OFF_TIMEOUT); - stateMachine = FINISHED_DEPLOYMENT; sif::error << "SolarArrayDeploymentHandler::handleStateMachine: Failed to switch main" << " switch off" << std::endl; + stateMachine = WAIT_ON_DELOYMENT_COMMAND; } - case FINISHED_DEPLOYMENT: break; default: sif::debug << "SolarArrayDeploymentHandler::handleStateMachine: Invalid state" << std::endl; @@ -143,7 +142,6 @@ void SolarArrayDeploymentHandler::switchDeploymentTransistors() { void SolarArrayDeploymentHandler::handleDeploymentFinish() { ReturnValue_t result = RETURN_OK; if (deploymentCountdown.hasTimedOut()) { - stateMachine = FINISHED_DEPLOYMENT; actionHelper.finish(rememberCommanderId, DEPLOY_SOLAR_ARRAYS, RETURN_OK); result = gpioInterface->pullLow(deplSA1); if (result != RETURN_OK) { @@ -157,6 +155,7 @@ void SolarArrayDeploymentHandler::handleDeploymentFinish() { } mainLineSwitcher->sendSwitchCommand(mainLineSwitch, PowerSwitchIF::SWITCH_OFF); mainSwitchCountdown.setTimeout(mainLineSwitcher->getSwitchDelayMs()); + stateMachine = WAIT_FOR_MAIN_SWITCH_OFF; } } diff --git a/mission/devices/SolarArrayDeploymentHandler.h b/mission/devices/SolarArrayDeploymentHandler.h index c45c2ba7..279ae5da 100644 --- a/mission/devices/SolarArrayDeploymentHandler.h +++ b/mission/devices/SolarArrayDeploymentHandler.h @@ -76,8 +76,7 @@ private: WAIT_ON_8V_SWITCH, SWITCH_DEPL_GPIOS, WAIT_ON_DEPLOYMENT_FINISH, - WAIT_FOR_MAIN_SWITCH_OFF, - FINISHED_DEPLOYMENT + WAIT_FOR_MAIN_SWITCH_OFF }; StateMachine stateMachine = WAIT_ON_DELOYMENT_COMMAND; diff --git a/mission/devices/SyrlinksHkHandler.cpp b/mission/devices/SyrlinksHkHandler.cpp new file mode 100644 index 00000000..68c202cd --- /dev/null +++ b/mission/devices/SyrlinksHkHandler.cpp @@ -0,0 +1,145 @@ +#include +#include +#include + +SyrlinksHkHandler::SyrlinksHkHandler(object_id_t objectId, object_id_t comIF, + CookieIF * comCookie) : + DeviceHandlerBase(objectId, comIF, comCookie), dataset( + this) { + if (comCookie == NULL) { + sif::error << "SyrlinksHkHandler: Invalid com cookie" << std::endl; + } +} + +SyrlinksHkHandler::~SyrlinksHkHandler() { +} + + +void SyrlinksHkHandler::doStartUp(){ + if(mode == _MODE_START_UP){ + setMode(MODE_ON); + } +} + +void SyrlinksHkHandler::doShutDown(){ + +} + +ReturnValue_t SyrlinksHkHandler::buildNormalDeviceCommand( + DeviceCommandId_t * id) { + + if(communicationStep == CommunicationStep::START_ADC_CONVERSION) { + *id = TMP1075::START_ADC_CONVERSION; + communicationStep = CommunicationStep::GET_TEMPERATURE; + return buildCommandFromCommand(*id, NULL, 0); + } + else { + *id = TMP1075::GET_TEMP; + communicationStep = CommunicationStep::START_ADC_CONVERSION; + return buildCommandFromCommand(*id, NULL, 0); + } + return HasReturnvaluesIF::RETURN_OK; +} + +ReturnValue_t SyrlinksHkHandler::buildTransitionDeviceCommand( + DeviceCommandId_t * id){ + return HasReturnvaluesIF::RETURN_OK; +} + +ReturnValue_t SyrlinksHkHandler::buildCommandFromCommand( + DeviceCommandId_t deviceCommand, const uint8_t * commandData, + size_t commandDataLen) { + switch(deviceCommand) { + case(TMP1075::START_ADC_CONVERSION): { + std::memset(cmdBuffer, 0, sizeof(cmdBuffer)); + prepareAdcConversionCommand(); + rawPacket = cmdBuffer; + rawPacketLen = TMP1075::CFGR_CMD_SIZE; + return RETURN_OK; + } + case(TMP1075::GET_TEMP): { + std::memset(cmdBuffer, 0, sizeof(cmdBuffer)); + prepareGetTempCommand(); + rawPacket = cmdBuffer; + rawPacketLen = TMP1075::POINTER_REG_SIZE; + rememberCommandId = TMP1075::GET_TEMP; + return RETURN_OK; + } + default: + return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; + } + return HasReturnvaluesIF::RETURN_FAILED; +} + +void SyrlinksHkHandler::fillCommandAndReplyMap(){ + this->insertInCommandMap(TMP1075::START_ADC_CONVERSION); + this->insertInCommandAndReplyMap(TMP1075::GET_TEMP, 1, &dataset, + TMP1075::GET_TEMP_REPLY_SIZE); +} + +ReturnValue_t SyrlinksHkHandler::scanForReply(const uint8_t *start, + size_t remainingSize, DeviceCommandId_t *foundId, size_t *foundLen) { + switch(rememberCommandId) { + case(TMP1075::GET_TEMP): + *foundId = TMP1075::GET_TEMP; + *foundLen = TMP1075::GET_TEMP_REPLY_SIZE; + rememberCommandId = TMP1075::NONE; + break; + default: + return IGNORE_REPLY_DATA; + } + return HasReturnvaluesIF::RETURN_OK; +} + +ReturnValue_t SyrlinksHkHandler::interpretDeviceReply(DeviceCommandId_t id, + const uint8_t *packet) { + switch (id) { + case TMP1075::GET_TEMP: { + int16_t tempValueRaw = 0; + tempValueRaw = packet[0] << 4 | packet[1] >> 4; + float tempValue = ((static_cast(tempValueRaw)) * 0.0625); +#if OBSW_VERBOSE_LEVEL >= 1 + sif::info << "Tmp1075 with object id: 0x" << std::hex << getObjectId() + << ": Temperature: " << tempValue<< " °C" + << std::endl; +#endif + ReturnValue_t result = dataset.read(); + if(result == HasReturnvaluesIF::RETURN_OK) { + dataset.temperatureCelcius = tempValue; + dataset.commit(); + } + break; + } + + default: { + return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY; + } + + } + return HasReturnvaluesIF::RETURN_OK; +} + +void SyrlinksHkHandler::setNormalDatapoolEntriesInvalid(){ + +} + +void SyrlinksHkHandler::prepareAdcConversionCommand(){ + cmdBuffer[0] = TMP1075::CFGR_ADDR; + cmdBuffer[1] = TMP1075::ONE_SHOT_MODE >> 8; + cmdBuffer[2] = TMP1075::ONE_SHOT_MODE & 0xFF; +} + +void SyrlinksHkHandler::prepareGetTempCommand(){ + cmdBuffer[0] = TMP1075::TEMP_REG_ADDR; +} + +uint32_t SyrlinksHkHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo){ + return 500; +} + +ReturnValue_t SyrlinksHkHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap, + LocalDataPoolManager& poolManager) { + localDataPoolMap.emplace(TMP1075::TEMPERATURE_C_TMP1075_1, new PoolEntry( { 0.0 })); + return HasReturnvaluesIF::RETURN_OK; +} + diff --git a/mission/devices/SyrlinksHkHandler.h b/mission/devices/SyrlinksHkHandler.h new file mode 100644 index 00000000..d2d80efa --- /dev/null +++ b/mission/devices/SyrlinksHkHandler.h @@ -0,0 +1,65 @@ +#ifndef MISSION_DEVICES_SYRLINKSHKHANDLER_H_ +#define MISSION_DEVICES_SYRLINKSHKHANDLER_H_ + +#include +#include + +/** + * @brief This is the device handler for the syrlinks transceiver. It handles the command + * transmission and reading of housekeeping data via the housekeeping interface. The + * transmission of telemetry and the reception of telecommands is handled by an additional + * class. + * + * @author J. Meier + */ +class SyrlinksHkHandler: public DeviceHandlerBase { +public: + + SyrlinksHkHandler(object_id_t objectId, object_id_t comIF, + CookieIF * comCookie); + virtual ~SyrlinksHkHandler(); + +protected: + void doStartUp() override; + void doShutDown() override; + ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) override; + ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) override; + void fillCommandAndReplyMap() override; + ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, + const uint8_t * commandData,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 id, + const uint8_t *packet) override; + void setNormalDatapoolEntriesInvalid() override; + uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override; + ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap, + LocalDataPoolManager& poolManager) override; + +private: + + /** + * @brief Function fills cmdBuffer with command to start the adc + * conversion for a new temperature value. + */ + void prepareAdcConversionCommand(); + + void prepareGetTempCommand(); + + enum class CommunicationStep { + START_ADC_CONVERSION, + GET_TEMPERATURE + }; + + TMP1075::Tmp1075Dataset dataset; + + static const uint8_t MAX_CMD_LEN = 3; + + uint8_t rememberRequestedSize = 0; + uint8_t rememberCommandId = TMP1075::NONE; + uint8_t cmdBuffer[MAX_CMD_LEN]; + CommunicationStep communicationStep = + CommunicationStep::START_ADC_CONVERSION; +}; + +#endif /* MISSION_DEVICES_SYRLINKSHKHANDLER_H_ */