class ISSSimIfaceLib: ROBOT_LIBRARY_SCOPE = "TEST SUITE" cmd_port = 10000 hs_port = 11000 telm_port = 12000 cmd_ip = '127.0.0.1' hs_ip = '127.0.0.1' telm_ip = '127.0.0.1' hs_sock = None telm_sock = None txSeqCnt = 0 session = None def __init__(self, cmd_schema_filename, cmd_dict_filename, cmd_dict_sheet, \ hs_dict_filename, hs_dict_sheet, \ telm_schema_filename, \ dbFilename="roboSCAT.db",byteSwap=False): logger.info("Loading ISS Sim Interface Library") self.dbFilename = dbFilename self.cmd_schema_filename = cmd_schema_filename self.cmd_dict_filename = cmd_dict_filename self.cmd_dict_sheet = cmd_dict_sheet self.hs_dict_filename = hs_dict_filename self.hs_dict_sheet = hs_dict_sheet self.telm_schema_filename = telm_schema_filename self.cmd_database = CmdDatabase(self.dbFilename) self.hs_database = HSDatabase(self.dbFilename) self.telm_database = TelmDatabase(self.dbFilename) self.byteSwap = byteSwap self.hsPacketSize = 1024 self.telmPacketSize = 1024 self.viewer = None def load_cmd_database(self,reload='False'): cmdDatabaseLoaded = self.cmd_database.is_valid_table(self.cmd_database.tableName) if (not cmdDatabaseLoaded) or reload=='RELOAD': self.cmd_database.drop_table() self.cmd_database.load_schema(self.cmd_schema_filename) self.cmd_database.create_table() self.cmd_database.load_cmds(self.cmd_dict_filename,self.cmd_dict_sheet,True) else: self.cmd_database.load_cmds(self.cmd_dict_filename,self.cmd_dict_sheet) def load_hs_database(self,reload='False'): hsDatabaseLoaded = self.hs_database.is_valid_table(self.hs_database.tableName) if (not hsDatabaseLoaded) or reload=='RELOAD': self.hs_database.drop_table() self.hs_database.load_schema(self.hs_dict_filename, self.hs_dict_sheet,True) self.hs_database.create_table() else: self.hs_database.load_schema(self.hs_dict_filename, self.hs_dict_sheet) def load_telm_database(self,reload='False'): telmDatabaseLoaded = self.telm_database.is_valid_table(self.telm_database.tableName) if (not telmDatabaseLoaded) or reload=='RELOAD': self.telm_database.drop_table() self.telm_database.load_schema() self.telm_database.create_table() def set_byte_swap(self,byteSwapEnable): if byteSwapEnable == '1': logger.info("Enabling byte swapping") self.byteSwap = True def set_telm_packet_size(self,sizeInBytes): self.telmPacketSize = sizeInBytes def set_hs_packet_size(self,sizeInBytes): self.hsPackdetSize = sizeInBytes def drop_tables(self): logger.warn("Dropping tables!!!!!!!!!!!!!!!!!!!") self.cmd_database.drop_table() self.hs_database.drop_table() def set_cmd_port(self,cmd_port): self.cmd_port = int(cmd_port) logger.info("Setting command port to %d" % self.cmd_port) def set_hs_port(self,hs_port): self.hs_port = int(hs_port) logger.info("Setting health and status port to %d" % self.hs_port) def set_telm_port(self,telm_port): self.telm_port = int(telm_port) logger.info("Setting telemetry port to %d" % self.telm_port) def set_cmd_ip(self,cmd_ip): logger.info("Setting command port to %s" % cmd_ip) self.cmd_ip = cmd_ip def set_hs_ip(self,hs_ip): logger.info("Setting health and status port to %s" % hs_ip) self.hs_ip = hs_ip def set_telm_ip(self,telm_ip): logger.info("Setting telemetry port to %s" % telm_ip) self.telm_ip = telm_ip def corrupt_next_cmd(self,fieldToCorrupt): logger.info("Setting cmd packet %s to be corrupted") self.session.corrupt_next_cmd(fieldToCorrupt) def create_sock(self,ip,port,bind=False,connect=False): try: sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) if bind: sock.bind((ip,port)) elif connect: sock.connect((ip,port)) except: raise RuntimeError("Can't open socket IP=%s port=%d" % (ip, port)) return sock def set_viewer(self,viewerObj): self.viewer = viewerObj def start_session(self): logger.info("Starting session with the ISS sim") self.hs_sock = self.create_sock(self.hs_ip,self.hs_port,bind=True) self.telm_sock = self.create_sock(self.telm_ip,self.telm_port,bind=True) self.cmdQ = Queue.Queue() hsRecvEvent = threading.Event() telmRecvEvent = threading.Event() self.session = SessionThread(self.cmdQ,self.hs_sock,self.telm_sock,\ self.dbFilename,hsRecvEvent,telmRecvEvent) self.session.set_cmd_addr(self.cmd_ip,self.cmd_port) self.session.set_packet_sizes(self.hsPacketSize,self.telmPacketSize) self.session.set_byte_swap(self.byteSwap) if self.viewer: self.viewer.start() self.session.start() logger.info("Session started") def stop_session(self): logger.info("Stopping session with the ISS sim") if self.session != None: self.session.stop() self.session.join() logger.info("Session stopped") def terminate_session(self): logger.info("Terminating session with the ISS sim") if self.session != None: self.session.stop() self.session.join() if self.hs_sock != None: self.hs_sock.close() if self.telm_sock != None: self.telm_sock.close() logger.info("Session terminated") def send_cmd(self,cmd_name,*args): cmdFormat = self.cmd_database.get_cmd_format(cmd_name) cmd = self.cmd_database.build_cmd(cmdFormat,args) self.cmdQ.put(cmd) logger.info("Sending cmd %s" % cmd_name) def read_hs_field(self,field_name): ret = self.hs_database.read_hs_field(field_name) return ret def get_received_hs_packet_count(self): return self.session.recvdHsPackets def get_received_telm_packet_count(self): return self.session.recvdTelmPackets def get_hs_seq_count(self): return self.session.hsRxSeqCnt def get_telm_seq_count(self): return self.session.telmRxSeqCnt def get_cmd_seq_count(self): return self.session.txSeqCnt def get_cmd_opCode(self,cmdName): return self.cmd_database.get_opCode_from_cmdName(cmdName) def get_hs_APID(self): return self.session.hsAPID def get_telm_APID(self): return self.session.telmAPID def get_telm_data_rate(self): return self.session.telmDataRate def get_last_telm_packet(self): return self.telm_database.read_packet() def wait_for_hs_packet(self,timeoutSecs=60): if not self.session.isAlive(): logger.warn("Can't wait for packet if session not open!") raise RuntimeError("Session not open!") logger.info("Waiting for HS packet with a timeout of %d s" % timeoutSecs) if not self.session.wait_for_next_hs_packet(timeoutSecs): raise RuntimeError("Didn't recieve packet in %s secs" % timeoutSecs) return True def wait_for_telm_packet(self,timeoutSecs=60): if not self.session.isAlive(): logger.warn("Can't wait for packet if session not open!") raise RuntimeError("Session not open!") logger.info("Waiting for HS packet with a timeout of %d s" % timeoutSecs) if not self.session.wait_for_next_telm_packet(timeoutSecs): raise RuntimeError("Didn't recieve packet in %s secs" % timeoutSecs) return True def convert_temp_to_celsius(self,value,calibration): value = float(value) calibration = float(calibration) return convert_to_celsius(value,calibration) def convert_ccsds_time_to_unix(self,ccsdsTime): ccsdsTime = bytearray(ccsdsTime) timeFine,timeCoarse = unpack_ISS_time(ccsdsTime) timeUnix = convert_ISS_to_unix_time(timeFine,timeCoarse,leapSecs=0, gpsEpochStart=( 1970,1,1,0,0,0,3,6,-1)) return timeUnix