def notifyTCack(self, tcAckSubType): """ notifies a PUS service 1 acknowledgement: implementation of MC.IF.TCmodel.notifyTCack """ # packet is a PUS TC Acknowledgement command if tcAckSubType == PUS.SERVICES.TC_ACK_ACCEPT_SUCC: LOG_INFO("--> TC_ACK_ACCEPT_SUCC", "TC") elif tcAckSubType == PUS.SERVICES.TC_ACK_ACCEPT_FAIL: LOG_ERROR("--> TC_ACK_ACCEPT_FAIL", "TC") elif tcAckSubType == PUS.SERVICES.TC_ACK_EXESTA_SUCC: LOG_INFO("--> TC_ACK_EXESTA_SUCC", "TC") elif tcAckSubType == PUS.SERVICES.TC_ACK_EXESTA_FAIL: LOG_ERROR("--> TC_ACK_EXESTA_FAIL", "TC") elif tcAckSubType == PUS.SERVICES.TC_ACK_EXEPRO_SUCC: LOG_INFO("--> TC_ACK_EXEPRO_SUCC", "TC") elif tcAckSubType == PUS.SERVICES.TC_ACK_EXEPRO_FAIL: LOG_ERROR("--> TC_ACK_EXEPRO_FAIL", "TC") elif tcAckSubType == PUS.SERVICES.TC_ACK_EXECUT_SUCC: LOG_INFO("--> TC_ACK_EXECUT_SUCC", "TC") elif tcAckSubType == PUS.SERVICES.TC_ACK_EXECUT_FAIL: LOG_ERROR("--> TC_ACK_EXECUT_FAIL", "TC") else: LOG_ERROR( "unexpected TC Acknowledgement SubType: " + str(tcAckSubType), "TC")
def notifyTCcltuDataUnit(self, tcCltuDu): """CLTU received""" # send UV ACCEPT confirmation if GRND.IF.s_configuration.grndAck1 == GRND.IF.ENABLE_ACK: LOG_INFO("generate ACK1 (TC_ACK_UV_ACCEPT_CONFIRM)") self.sendResponseDataUnit(tcCltuDu, GRND.NCTRSDU.TC_ACK_UV_ACCEPT_CONFIRM) elif GRND.IF.s_configuration.grndAck1 == GRND.IF.ENABLE_NAK: LOG_WARNING("generate NAK1 (TC_ACK_UV_ACCEPT_FAILURE)") self.sendResponseDataUnit(tcCltuDu, GRND.NCTRSDU.TC_ACK_UV_ACCEPT_FAILURE) else: LOG_WARNING("suppress ACK1 (TC_ACK_UV_ACCEPT_CONFIRM)") # send UV TRANSMIT confirmation if GRND.IF.s_configuration.grndAck2 == GRND.IF.ENABLE_ACK: LOG_INFO("generate ACK2 (TC_ACK_UV_TRANSMIT_CONFIRM)") self.sendResponseDataUnit(tcCltuDu, GRND.NCTRSDU.TC_ACK_UV_TRANSMIT_CONFIRM) elif GRND.IF.s_configuration.grndAck2 == GRND.IF.ENABLE_NAK: LOG_ERROR("generate NAK2 (TC_ACK_UV_TRANSMIT_FAILURE)") self.sendResponseDataUnit(tcCltuDu, GRND.NCTRSDU.TC_ACK_UV_TRANSMIT_FAILURE) else: LOG_WARNING("suppress ACK2 (TC_ACK_UV_TRANSMIT_CONFIRM)") # extract the CLTU from the NCTRS CLTU data unit try: cltu = tcCltuDu.getCltu() except Exception as ex: self.notifyError("CLTU extraction failed", ex) return self.notifyCltu(cltu)
def notifyTCpacketDataUnit(self, tcPktDu): """AD packet / BD segment received""" # send UV ACCEPT confirmation if GRND.IF.s_configuration.grndAck1 == GRND.IF.ENABLE_ACK: LOG_INFO("generate ACK1 (TC_ACK_UV_ACCEPT_CONFIRM)") self.sendResponseDataUnit(tcPktDu, GRND.NCTRSDU.TC_ACK_UV_ACCEPT_CONFIRM) elif GRND.IF.s_configuration.grndAck1 == GRND.IF.ENABLE_NAK: LOG_WARNING("generate NAK1 (TC_ACK_UV_ACCEPT_FAILURE)") self.sendResponseDataUnit(tcPktDu, GRND.NCTRSDU.TC_ACK_UV_ACCEPT_FAILURE) else: LOG_WARNING("suppress ACK1 (TC_ACK_UV_ACCEPT_CONFIRM)") # send UV TRANSMIT confirmation if GRND.IF.s_configuration.grndAck2 == GRND.IF.ENABLE_ACK: LOG_INFO("generate ACK2 (TC_ACK_UV_TRANSMIT_CONFIRM)") self.sendResponseDataUnit(tcPktDu, GRND.NCTRSDU.TC_ACK_UV_TRANSMIT_CONFIRM) elif GRND.IF.s_configuration.grndAck2 == GRND.IF.ENABLE_NAK: LOG_ERROR("generate NAK2 (TC_ACK_UV_TRANSMIT_FAILURE)") self.sendResponseDataUnit(tcPktDu, GRND.NCTRSDU.TC_ACK_UV_TRANSMIT_FAILURE) else: LOG_WARNING("suppress ACK2 (TC_ACK_UV_TRANSMIT_CONFIRM)") # send UV TRANSFER confirmation # this verification stage does not provide ENABLE/DISABLE LOG_INFO("generate ACK3 (TC_ACK_UV_TRANSFER_CONFIRM)") self.sendResponseDataUnit(tcPktDu, GRND.NCTRSDU.TC_ACK_UV_TRANSFER_CONFIRM) # extract the TC packet from the NCTRS TC packet data unit try: packetData = tcPktDu.getTCpacket() except Exception, ex: self.notifyError("TC packet extraction failed", ex) return
def processTCpacket(self, tcPacketDu): """ processes a telecommand C&C packet from the CCS implementation of SPACE.IF.ApplicationSoftware.processTCpacket """ apid = tcPacketDu.applicationProcessId LOG_INFO("EUCLIDpowerFEEsim_BS.processTCpacket(" + str(apid) + ")", "SPACE") # packet is a PUS Function Management command if tcPacketDu.serviceType == PUS.SERVICES.TC_FKT_TYPE: if tcPacketDu.serviceSubType == PUS.SERVICES.TC_FKT_PERFORM_FUNCTION: tcFunctionId = tcPacketDu.getUnsigned( self.tcFunctionIdBytePos, self.tcFunctionIdByteSize) LOG("tcFunctionId = " + str(tcFunctionId), "SPACE") if tcFunctionId == BS_Initialize: LOG_INFO("*** BS_Initialize ***", "SPACE") LOG("push HKTM", "SPACE") return self.sendBS_Monitor() elif tcFunctionId == BS_SetLocal: LOG_INFO("*** BS_SetLocal ***", "SPACE") LOG("set the SCOE into the LOCAL commanding mode", "SPACE") self.commandingMode = EPWR_CMD_LOCAL elif tcFunctionId == BS_SetRemote: LOG_INFO("*** BS_SetRemote ***", "SPACE") LOG("set the SCOE into the REMOTE commanding mode", "SPACE") self.commandingMode = EPWR_CMD_REMOTE elif tcFunctionId == BS_LockInstruments: LOG_INFO("*** BS_LockInstruments ***", "SPACE") LOG("not used for simulation", "SPACE") elif tcFunctionId == BS_UnlockInstruments: LOG_INFO("*** BS_UnlockInstruments ***", "SPACE") LOG("not used for simulation", "SPACE") elif tcFunctionId == BS_SetOnline: LOG_INFO("*** BS_SetOnline ***", "SPACE") LOG("set the SCOE into the ONLINE operation mode", "SPACE") self.operationMode = EPWR_OP_ONLINE return self.sendBS_Monitor() elif tcFunctionId == BS_SetOffline: LOG_INFO("*** BS_SetOffline ***", "SPACE") LOG("set the SCOE into the OFFLINE operation mode", "SPACE") self.operationMode = EPWR_OP_OFFLINE return self.sendBS_Monitor() elif tcFunctionId == BS_SelfTest: LOG_INFO("*** BS_SelfTest ***", "SPACE") # the SELFTEST is only allowed in OFFLINE mode if self.operationMode == EPWR_OP_ONLINE: LOG_ERROR("SELFTEST not allowed when system is ONLINE", "SPACE") return False else: # unexpected Function ID LOG_WARNING( "no simulation for Function ID " + str(tcFunctionId) + " implemented", "SPACE") return True LOG_WARNING("TC ignored by simulation", "SPACE") return True
def notifyTMpacket(self, tmPacket): """TM packet received: overloaded from EGSE.CNC.TMclient""" if PUS.PACKET.isPUSpacket(tmPacket): # PUS packet tmPacketDu = PUS.PACKET.TMpacket(tmPacket) LOG_INFO("PUS TM packet extracted", "CNC") else: # CCSDS packet tmPacketDu = CCSDS.PACKET.TMpacket(tmPacket) LOG_INFO("CCSDS TM packet extracted", "CNC") MC.IF.s_tmModel.pushTMpacket(tmPacketDu, None)
def notifyTmScoe(self, tmPacket): """(TM,SCOE) received: overloaded from EGSE.EDEN.Client""" if PUS.PACKET.isPUSpacket(tmPacket): # PUS packet tmPacketDu = PUS.PACKET.TMpacket(tmPacket) LOG_INFO("PUS TM/SCOE packet extracted", "EDEN") else: # CCSDS packet tmPacketDu = CCSDS.PACKET.TMpacket(tmPacket) LOG_INFO("CCSDS TM/SCOE packet extracted", "EDEN") MC.IF.s_tmModel.pushTMpacket(tmPacketDu, None)
def receiveCallback(self, socket, stateMask): """Callback when the SCOE has send data""" # read the packet header from the data socket packetHeader = self.recv(CCSDS.PACKET.PRIMARY_HEADER_BYTE_SIZE) if packetHeader == None: # failure handling was done automatically by derived logic return # consistency check packetHeaderLen = len(packetHeader) if packetHeaderLen != CCSDS.PACKET.PRIMARY_HEADER_BYTE_SIZE: LOG_ERROR( "Read of CnC header failed: invalid size: " + str(packetHeaderLen), "CNC") self.disconnectFromServer() return ccsdsTMpacketDU = CCSDS.PACKET.TMpacket(packetHeader) # read the data field for the packet from the data socket dataFieldLength = ccsdsTMpacketDU.packetLength + 1 dataField = self.recv(dataFieldLength) if dataField == None: # failure handling was done automatically by derived logic return # consistency check remainingSizeRead = len(dataField) if remainingSizeRead != dataFieldLength: LOG_ERROR( "Read of remaining packet failed: invalid remaining size: " + str(remainingSizeRead), "CNC") self.disconnectFromServer() return ccsdsTMpacketDU.append(dataField) # convert and dispatch the data depending on the CNC/TM packet type try: if ccsdsTMpacketDU.versionNumber == EGSE.CNCPDU.VERSION_NUMBER: # CNC ACK/NAK cncAckNakDU = EGSE.CNCPDU.CNCackNak( ccsdsTMpacketDU.getBuffer()) LOG_INFO("CNC.TCclient.receiveCallback(CnC response)", "CNC") self.notifyCNCresponse(cncAckNakDU) elif ccsdsTMpacketDU.dataFieldHeaderFlag == 1: # TC ACK/NAK tcAckNakDU = EGSE.CNCPDU.TCackNak(ccsdsTMpacketDU.getBuffer()) LOG_INFO("CNC.TCclient.receiveCallback(TC response)", "CNC") self.notifyCCSDSresponse(tcAckNakDU) else: LOG_ERROR( "Unexpected CnC response: " + ccsdsTMpacketDU.getDumpString(), "CNC") except Exception as ex: LOG_ERROR("Processing of received CnC response failed: " + str(ex), "CNC") self.disconnectFromServer()
def receiveCallback(self, socket, stateMask): """Callback when the CCS has send data""" # read the packet header from the data socket strBuffer = self.recv(CCSDS.PACKET.PRIMARY_HEADER_BYTE_SIZE) if strBuffer == None: # failure handling was done automatically by derived logic return packetHeader = array.array("B", strBuffer) # consistency check packetHeaderLen = len(packetHeader) if packetHeaderLen != CCSDS.PACKET.PRIMARY_HEADER_BYTE_SIZE: LOG_ERROR("Read of CnC header failed: invalid size: " + str(packetHeaderLen)) self.disconnectClient() return packetVersionNumber = packetHeader[0] >> 5 if packetVersionNumber == EGSE.CNCPDU.VERSION_NUMBER: LOG_INFO("CNC.TCserver.receiveCallback(CnC command)") tcPacketDU = EGSE.CNCPDU.CNCcommand(packetHeader) else: LOG_INFO("CNC.TCserver.receiveCallback(CCSDS telecommand)") tcPacketDU = CCSDS.PACKET.TCpacket(packetHeader) # read the data field for the packet from the data socket dataFieldLength = tcPacketDU.packetLength + 1 dataField = self.recv(dataFieldLength) if dataField == None: # failure handling was done automatically by derived logic return # consistency check remainingSizeRead = len(dataField) if remainingSizeRead != dataFieldLength: LOG_ERROR( "Read of remaining packet failed: invalid remaining size: " + str(remainingSizeRead)) self.disconnectClient() return tcPacketDU.setDataField(dataField) # dispatch the telecommand try: if packetVersionNumber == EGSE.CNCPDU.VERSION_NUMBER: # CnC command okStatus = self.notifyCNCcommand(tcPacketDU) self.sendCNCackNak(tcPacketDU, okStatus) else: # normal CCSDS TC packet okStatus = self.notifyCCSDScommand(tcPacketDU) self.sendTCackNak(tcPacketDU, okStatus) except Exception as ex: LOG_ERROR("Processing of received CnC command failed: " + str(ex)) self.disconnectClient()
def generateAcksFromTCpacket(self, tcPacketDu, ack1, ack2, ack3, ack4): """ generates a TC acknowledgements according to PUS service 1: implementation of SPACE.IF.OnboardComputer.generateAcksFromTCpacket """ ok = True tcAPID = str(tcPacketDu.applicationProcessId) tcSSC = str(tcPacketDu.sequenceControlCount) if ack1 == SPACE.IF.ENABLE_ACK: LOG_INFO("generate ACK1 (TC_ACK_ACCEPT_SUCC)", "SPACE") ok &= self.generateAck(tcAPID, tcSSC, PUS.SERVICES.TC_ACK_ACCEPT_SUCC) elif ack1 == SPACE.IF.ENABLE_NAK: LOG_ERROR("generate NAK1 (TC_ACK_ACCEPT_FAIL)", "SPACE") ok &= self.generateAck(tcAPID, tcSSC, PUS.SERVICES.TC_ACK_ACCEPT_FAIL) else: LOG_WARNING("suppress ACK1 (TC_ACK_ACCEPT_SUCC)", "SPACE") if ack2 == SPACE.IF.ENABLE_ACK: LOG_INFO("generate ACK2 (TC_ACK_EXESTA_SUCC)", "SPACE") ok &= self.generateAck(tcAPID, tcSSC, PUS.SERVICES.TC_ACK_EXESTA_SUCC) elif ack2 == SPACE.IF.ENABLE_NAK: LOG_ERROR("generate NAK2 (TC_ACK_EXESTA_FAIL)", "SPACE") ok &= self.generateAck(tcAPID, tcSSC, PUS.SERVICES.TC_ACK_EXESTA_FAIL) else: LOG_WARNING("suppress ACK2 (TC_ACK_EXESTA_SUCC)", "SPACE") if ack3 == SPACE.IF.ENABLE_ACK: LOG_INFO("generate ACK3 (TC_ACK_EXEPRO_SUCC)", "SPACE") ok &= self.generateAck(tcAPID, tcSSC, PUS.SERVICES.TC_ACK_EXEPRO_SUCC) elif ack3 == SPACE.IF.ENABLE_NAK: LOG_ERROR("generate NAK3 (TC_ACK_EXEPRO_FAIL)", "SPACE") ok &= self.generateAck(tcAPID, tcSSC, PUS.SERVICES.TC_ACK_EXEPRO_FAIL) else: LOG_WARNING("suppress ACK3 (TC_ACK_EXEPRO_SUCC)", "SPACE") if ack4 == SPACE.IF.ENABLE_ACK: LOG_INFO("generate ACK4 (TC_ACK_EXECUT_SUCC)", "SPACE") ok &= self.generateAck(tcAPID, tcSSC, PUS.SERVICES.TC_ACK_EXECUT_SUCC) elif ack4 == SPACE.IF.ENABLE_NAK: LOG_ERROR("generate NAK4 (TC_ACK_EXECUT_FAIL)", "SPACE") ok &= self.generateAck(tcAPID, tcSSC, PUS.SERVICES.TC_ACK_EXECUT_FAIL) else: LOG_WARNING("suppress ACK4 (TC_ACK_EXECUT_SUCC)", "SPACE") return ok
def clientAccepted(self): """Overloaded from GRND.NCTRS.AdminMessageSender""" LOG_INFO("NCTRS admin message receiver (client) accepted", "GRND") # notify the status change UTIL.TASK.s_processingTask.setTCconnected() # establish TC link self.sendAdminMessageTC(GRND.NCTRSDU.ADMIN_MSG_TC_LINK_ESTABLISHED_TO_GS)
def notifyTMpacketCallback(self, binPacket): """notifies when the next TM packet is assembled""" # overloaded from Packetizer if self.ignoreIdlePackets: apid = CCSDS.PACKET.getApplicationProcessId(binPacket) if apid == CCSDS.PACKET.IDLE_PKT_APID: return if PUS.PACKET.isPUSpacket(binPacket): # PUS packet tmPacketDu = PUS.PACKET.TMpacket(binPacket) LOG_INFO("PUS TM packet extracted", "FRAME") else: # CCSDS packet tmPacketDu = CCSDS.PACKET.TMpacket(binPacket) LOG_INFO("CCSDS TM packet extracted", "FRAME") MC.IF.s_tmModel.pushTMpacket(tmPacketDu, None)
def sendTCackNak(self, ccsdsTCpacketDU, okStatus): """Send a TC ACK or NAK as response to a CCSDSC TC packet to the CCS""" # format the response message according to the ccsdsTCpacketDU if EGSE.IF.s_configuration.egseAck2 == EGSE.IF.ENABLE_ACK: # normal processing if okStatus: LOG_INFO("CNC.TCserver.sendTCackNak(ACK)") else: LOG_ERROR("CNC.TCserver.sendTCackNak(NAK)") elif EGSE.IF.s_configuration.egseAck2 == EGSE.IF.ENABLE_NAK: LOG_WARNING("force TC NAK") okStatus = False else: LOG_WARNING("suppress TC ACK/NAK") return apid = ccsdsTCpacketDU.applicationProcessId ssc = ccsdsTCpacketDU.sequenceControlCount tcAckNakDU = EGSE.CNCPDU.TCackNak() if okStatus: tcAckNakDU.setACK() else: tcAckNakDU.setNAK() PUS.SERVICES.service1_setTCackAPID(tcAckNakDU, apid) PUS.SERVICES.service1_setTCackSSC(tcAckNakDU, ssc) self.dataSocket.send(tcAckNakDU.getBufferString())
def sendTCackNak(self, ccsdsTCpacketDU, okStatus): """Send a TC ACK or NAK as response to a CCSDSC TC packet to the CCS""" # format the response message according to the ccsdsTCpacketDU if EGSE.IF.s_serverConfiguration.egseAck2 == EGSE.IF.ENABLE_ACK: # normal processing if okStatus: LOG_INFO("CNC.TCserver.sendTCackNak(ACK)") else: LOG_ERROR("CNC.TCserver.sendTCackNak(NAK)") elif EGSE.IF.s_serverConfiguration.egseAck2 == EGSE.IF.ENABLE_NAK: LOG_WARNING("force TC NAK") okStatus = False else: LOG_WARNING("suppress TC ACK/NAK") return apid = ccsdsTCpacketDU.applicationProcessId ssc = ccsdsTCpacketDU.sequenceControlCount tcAckNakDU = EGSE.CNCPDU.TCackNak() # set TM packet header info tcAckNakDU.sequenceControlCount = self.tcAckNakSSC self.tcAckNakSSC = (self.tcAckNakSSC + 1) % 16384 if okStatus: tcAckNakDU.setACK() else: tcAckNakDU.setNAK() setTCackNakAPID(tcAckNakDU, apid) setTCackNakSSC(tcAckNakDU, ssc) # send the ACK/NAK response over the TC link # note: if the ACK/NAK response shall be sent over the TM link, then the # use the following: EGSE.IF.s_ccsLink.pushTMpacket(tcAckNakDU) self.send(tcAckNakDU.getBuffer())
def helpCmd(self, argv): """Decoded help command""" LOG_INFO("Available commands:") LOG("") LOG("h | help ........provides this information") LOG("q | quit ........terminates the application") LOG("")
def sendCNCackNak(self, cncCommandDU, okStatus): """Send a CnC ACK or NAK as response to a CnC TC packet to the CCS""" # format the response message according to the cncCommandDU # TODO: the recent implementation does not consider specific CnC messages # but simply appends the message to the ACK/NAK token if EGSE.IF.s_serverConfiguration.egseAck2 == EGSE.IF.ENABLE_ACK: # normal processing if okStatus: LOG_INFO("CNC.TCserver.sendCNCackNak(ACK)") else: LOG_ERROR("CNC.TCserver.sendCNCackNak(NAK)") elif EGSE.IF.s_serverConfiguration.egseAck2 == EGSE.IF.ENABLE_NAK: LOG_WARNING("force CnC NAK") okStatus = False else: LOG_WARNING("suppress CNC ACK/NAK") return apid = cncCommandDU.applicationProcessId ssc = cncCommandDU.sequenceControlCount cncMessage = cncCommandDU.getCNCmessage() if okStatus: responseMessage = "ACK " + cncMessage else: responseMessage = "NAK " + cncMessage cncAckNakDU = EGSE.CNCPDU.CNCackNak() cncAckNakDU.applicationProcessId = apid cncAckNakDU.sequenceControlCount = ssc cncAckNakDU.segmentationFlags = CCSDS.PACKET.UNSEGMENTED cncAckNakDU.setCNCmessage(responseMessage) # send the ACK/NAK response over the TC link self.send(cncAckNakDU.getBuffer())
def notifyMILdatablockDistribution(self, rtAddress, dataBlock): """ The mRT has received on the MIL Bus a data block from the BC """ LOG_INFO( "ApplicationSoftwareImpl.notifyMILdatablockDistribution(" + str(rtAddress) + ")", "SPACE")
def selfTest(self, bus): LOG_INFO("MILbusRemoteTerminalsImpl.selfTest", "MIL") if SPACE.IF.s_testMode == SELFTEST_RT_ERROR or \ SPACE.IF.s_testMode == SELFTEST_BC_RT_ERROR: LOG_WARNING("inject error", "MIL") return False return True
def receiveCallback(self, socket, stateMask): """Callback when the SCOE has send data""" # read the packet header from the data socket packetHeader = self.recv(CCSDS.PACKET.PRIMARY_HEADER_BYTE_SIZE) if packetHeader == None: # failure handling was done automatically by derived logic return # consistency check packetHeaderLen = len(packetHeader) if packetHeaderLen != CCSDS.PACKET.PRIMARY_HEADER_BYTE_SIZE: LOG_ERROR("Read of CCSDS packet header failed: invalid size: " + str(packetHeaderLen), "CNC") self.disconnectFromServer() return ccsdsTMpacketDU = CCSDS.PACKET.TMpacket(packetHeader) # read the data field for the packet from the data socket dataFieldLength = ccsdsTMpacketDU.packetLength + 1 dataField = self.recv(dataFieldLength) if dataField == None: # failure handling was done automatically by derived logic return # consistency check remainingSizeRead = len(dataField) if remainingSizeRead != dataFieldLength: LOG_ERROR("Read of remaining packet failed: invalid remaining size: " + str(remainingSizeRead), "CNC") self.disconnectFromServer() return ccsdsTMpacketDU.append(dataField) # dispatch the CCSDS tm packet try: LOG_INFO("CNC.TMclient.receiveCallback(TM packet)", "CNC") self.notifyTMpacket(ccsdsTMpacketDU.getBufferString()) except Exception as ex: LOG_ERROR("Processing of received TM packet failed: " + str(ex), "CNC") self.disconnectFromServer()
def receiveCallback(self, socket, stateMask): """Callback when the SCOE has send data""" # read the packet header from the data socket packetHeader = self.recv(CCSDS.PACKET.PRIMARY_HEADER_BYTE_SIZE) if packetHeader == None: # failure handling was done automatically by derived logic return # consistency check packetHeaderLen = len(packetHeader) if packetHeaderLen != CCSDS.PACKET.PRIMARY_HEADER_BYTE_SIZE: LOG_ERROR("Read of CnC header failed: invalid size: " + str(packetHeaderLen), "CNC") self.disconnectFromServer() return cncTMpacketDU = EGSE.CNCPDU.CNCackNak(packetHeader) # read the data field for the packet from the data socket dataFieldLength = cncTMpacketDU.packetLength + 1 dataField = self.recv(dataFieldLength) if dataField == None: # failure handling was done automatically by derived logic return # consistency check remainingSizeRead = len(dataField) if remainingSizeRead != dataFieldLength: LOG_ERROR("Read of remaining packet failed: invalid remaining size: " + str(remainingSizeRead), "CNC") self.disconnectFromServer() return cncTMpacketDU.setCNCmessage(dataField) # dispatch the CnC response try: LOG_INFO("CNC.TCclient.receiveCallback(CnC response)", "CNC") self.notifyCNCresponse(cncTMpacketDU) except Exception as ex: LOG_ERROR("Processing of received CnC response failed: " + str(ex), "CNC") self.disconnectFromServer()
def pushTCpacket(self, tcPacketDu): """ consumes a telecommand packet from the uplink: implementation of SPACE.IF.OnboardComputer.pushTCpacket """ LOG_INFO("pushTCpacket", "SPACE") LOG("APID = " + str(tcPacketDu.applicationProcessId), "SPACE") LOG("SSC = " + str(tcPacketDu.sequenceControlCount), "SPACE") if tcPacketDu.dataFieldHeaderFlag == 1: # CCSDS packet is a PUS packet object.__setattr__( tcPacketDu, "attributeMap2", PUS.PACKET.TC_PACKET_DATAFIELD_HEADER_ATTRIBUTES) LOG("TYPE = " + str(tcPacketDu.serviceType), "SPACE") LOG("SUBTYPE = " + str(tcPacketDu.serviceSubType), "SPACE") # the existence of a CRC for PUS packets is mission dependant # for SCOS-2000 compatibility we expect a CRC if not tcPacketDu.checkChecksum(): LOG_ERROR("invalid TC packet CRC", "SPACE") return False else: LOG("non-PUS packet", "SPACE") LOG("tcPacketDu = " + str(tcPacketDu), "SPACE") # further processing of the TC packet (e.g. reply telemetry) return self.processTCpacket(tcPacketDu, SPACE.IF.s_configuration.obcAck1, SPACE.IF.s_configuration.obcAck2, SPACE.IF.s_configuration.obcAck3, SPACE.IF.s_configuration.obcAck4)
def notifyMILdatablockAcquisition(self, rtAddress, dataBlock): """ The BC has received on the MIL Bus a data block from a RT """ LOG_INFO( "ApplicationSoftwareImpl.notifyMILdatablockAcquisition(" + str(rtAddress) + ")", "SPACE")
def sendCmdAnsw(self, message): """Send a (CMD,ANSW) PDU to the CCS""" LOG_INFO("EDEN.Server.sendCmdAnsw") pdu = EGSE.EDENPDU.PDU() pdu.pduType = EGSE.EDENPDU.PDU_TYPE_CMD pdu.subType = EGSE.EDENPDU.SUB_TYPE_ANSW pdu.setDataField(message) self.sendPDU(pdu)
def clientAccepted(self): """hook for derived classes""" LOG_INFO("NCTRS admin message receiver (client) accepted", "GRND") # notify the status change UTIL.TASK.s_processingTask.setAdminConnected() # establish TC link self.sendAdminMessageTC( GRND.NCTRSDU.ADMIN_MSG_TC_LINK_ESTABLISHED_TO_GS)
def notifyTMdataUnit(self, tmDu): """TM frame received""" # overloaded from GRND.NCTRS.TMreceiver LOG_INFO("TM frame received", "NCTRS") # extract the TM frame from the NCTRS data unit # and send it to the frame processing frame = tmDu.getFrame() CS.FRAMEmodel.s_frameModel.receiveTMframe(frame)
def dump(self): """Dumps the status of the server configuration attributes""" LOG_INFO("EGSE interface server configuration", "EDEN") LOG("EDEN host = " + self.edenHost, "EDEN") LOG("EDEN connected = " + str(self.connected), "EDEN") LOG("EDEN interface port = " + str(self.edenPort), "EDEN") LOG("EDEN connected 2 = " + str(self.connected2), "EDEN") LOG("EDEN interface port 2 = " + str(self.edenPort2), "EDEN")
def sendCmdExec(self, tcPacket): """Send a (CMD,EXEC) PDU to the SCOE""" LOG_INFO("EDEN.Client.sendCmdExec", "EDEN") pdu = EGSE.EDENPDU.PDU() pdu.pduType = EGSE.EDENPDU.PDU_TYPE_CMD pdu.subType = EGSE.EDENPDU.SUB_TYPE_EXEC pdu.setDataField(tcPacket) self.sendPDU(pdu)
def helpCmd(self, argv): """Decoded help command""" LOG_INFO("Available commands:") LOG("") LOG("h | help .......provides this information") LOG("q | quit .......terminates the application") LOG("1 | cmd_answ ...send message via EDEN (CMD,ANSW)") LOG("")
def helpCmd(self, argv): """Decoded help command""" LOG_INFO("Available EGSE interface commands:", "EGSE") LOG("", "EGSE") LOG("x | exit ...............terminates client connection (only for TCP/IP clients)", "EGSE") LOG("h | help ...............provides this information", "EGSE") LOG("q | quit ...............terminates SIM application", "EGSE") LOG("u | dumpConfiguration...dumps the configuration", "EGSE") LOG("aa | egseEnableAck1......enables autom. sending of ACK1 for TCs", "EGSE") LOG("na | egseEnableNak1......enables autom. sending of NAK1 for TCs", "EGSE") LOG("da | egseDisableAck1.....disables autom. sending of ACK1 for TCs", "EGSE") LOG("ab | egseEnableAck2......enables autom. sending of ACK2 for TCs", "EGSE") LOG("nb | egseEnableNak2......enables autom. sending of NAK2 for TCs", "EGSE") LOG("db | egseDisableAck2.....disables autom. sending of ACK2 for TCs", "EGSE") LOG_INFO("Available space segment commands:", "SPACE") LOG("", "SPACE") LOG("x | exit ...............terminates client connection (only for TCP/IP clients)", "SPACE") LOG("h | help ...............provides this information", "SPACE") LOG("q | quit ...............terminates SIM application", "SPACE") LOG("u | dumpConfiguration...dumps the configuration", "SPACE") LOG("p | setPacketData <pktMnemonic> [<params> <values>]", "SPACE") LOG(" predefine data for the next TM packet", "SPACE") LOG("s | sendPacket [<pktMnemonic> [<params> <values>]]", "SPACE") LOG(" send predefined or specific TM packet", "SPACE") LOG("e | enableCyclic........enables cyclic sending of TM packet", "SPACE") LOG("d | disableCyclic.......disables cyclic sending of TM packet", "SPACE") LOG("a1 | obcEnableAck1.......enables autom. sending of ACK1 for TCs", "SPACE") LOG("n1 | obcEnableNak1.......enables autom. sending of NAK1 for TCs", "SPACE") LOG("d1 | obcDisableAck1......disables autom. sending of ACK1 for TCs", "SPACE") LOG("a2 | obcEnableAck2.......enables autom. sending of ACK2 for TCs", "SPACE") LOG("n2 | obcEnableNak2.......enables autom. sending of NAK2 for TCs", "SPACE") LOG("d2 | obcDisableAck2......disables autom. sending of ACK2 for TCs", "SPACE") LOG("a3 | obcEnableAck3.......enables autom. sending of ACK3 for TCs", "SPACE") LOG("n3 | obcEnableNak3.......enables autom. sending of NAK3 for TCs", "SPACE") LOG("d3 | obcDisableAck3......disables autom. sending of ACK3 for TCs", "SPACE") LOG("a4 | obcEnableAck4.......enables autom. sending of ACK4 for TCs", "SPACE") LOG("n4 | obcEnableNak4.......enables autom. sending of NAK4 for TCs", "SPACE") LOG("d4 | obcDisableAck4......disables autom. sending of ACK4 for TCs", "SPACE") LOG("a | sendAck <apid> <ssc> <stype> sends a TC acknowledgement", "SPACE") LOG("sp | stopPacketRecorder..stops recording of TM packets", "SPACE") LOG("pp | replayPackets <replayFile> replays TM packets", "SPACE") LOG("pp | replayPackets <replayFile> replays TM packets", "SPACE") LOG("l | listPackets.........lists available packets", "SPACE") LOG("g | generate............generates the testdata.sim file in testbin directory", "SPACE") LOG("t | test <testMode>.....executes a test command", "SPACE") return True
def dump(self): """Dumps the status of the server configuration attributes""" LOG_INFO("EGSE interface server configuration", "CNC") LOG("CNC host = " + self.cncHost, "CNC") LOG("CNC connected = " + str(self.connected), "CNC") LOG("CNC interface port = " + str(self.cncPort), "CNC") LOG("CNC connected 2 = " + str(self.connected2), "CNC") LOG("CNC interface port 2 = " + str(self.cncPort2), "CNC")
def dump(self): """Dumps the status of the configuration attributes""" LOG_INFO("Monitoring an Control configuration", "CFG") LOG("Connected = " + str(self.connected), "CFG") if self.tcPacketData == None: LOG("No packet defined", "CFG") else: LOG("Packet = " + self.tcPacketData.pktName, "CFG")