syrlinks handler wip

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);
 	}

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;

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;

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();

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;
     }
 }
 

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,
+	    WAIT_FOR_MAIN_SWITCH_OFF
-	    FINISHED_DEPLOYMENT
 	};
 
 	StateMachine stateMachine = WAIT_ON_DELOYMENT_COMMAND;

mission/devices/SyrlinksHkHandler.cpp

@@ -0,0 +1,145 @@
+#include <mission/devices/SyrlinksHkHandler.h>
+#include <mission/devices/devicedefinitions/Tmp1075Definitions.h>
+#include <fsfwconfig/OBSWConfig.h>
+
+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<float>(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<float>( { 0.0 }));
+    return HasReturnvaluesIF::RETURN_OK;
+}
+

mission/devices/SyrlinksHkHandler.h

@@ -0,0 +1,65 @@
+#ifndef MISSION_DEVICES_SYRLINKSHKHANDLER_H_
+#define MISSION_DEVICES_SYRLINKSHKHANDLER_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <mission/devices/devicedefinitions/Tmp1075Definitions.h>
+
+/**
+ * @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_ */