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")
