def __init__(self, time_base=0, time_context=0, seconds=0, useconds=0):
'''
Constructor
Args
time_base (int): Time base index for the time tag. Must be a valid
integer for a TimeBase Enum value.
time_context (int): Time context for the time tag
seconds (int): Seconds elapsed since specified time base
useconds (int): Microseconds since start of current second. Must
be in range [0, 999999] inclusive
Returns:
An initialized TimeType object
'''
# Layout of time tag:
#
# START (LSB)
# | 2 bytes | 1 byte | 4 bytes | 4 bytes |
# |-----------|--------------|---------|--------------|
# | Time Base | Time Context | Seconds | Microseconds |
self._check_time_base(time_base)
self._check_useconds(useconds)
self.__timeBase = u16_type.U16Type(time_base)
self.__timeContext = u8_type.U8Type(time_context)
self.__secs = u32_type.U32Type(seconds)
self.__usecs = u32_type.U32Type(useconds)
def decode_desc_api(self, msg):
"""
Decode the size and descriptor and return them.
"""
ptr = 0
# Decode size here...
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, 0)
size = u32_obj.val
ptr += u32_obj.getSize()
#print "Size = 0x%x" % size
# Decode descriptor part of message
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
desc = u32_obj.val
ptr += u32_obj.getSize()
#print "Desc = 0x%x" % desc
# Decode log event ID here...
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
i = u32_obj.val
#print "ID: %d" % i
return (desc, size, i)
def decode_ch_api(self, msg):
"""
Decode channel telemetry item using Channel object dictionary.
"""
#type_base.showBytes(msg)
#
ptr = 0
# Decode log channel ID here...
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
tlm_id = u32_obj.val
#print "ID: %d" % i
# Decode time...
# Time base
u32_obj = u16_type.U16Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_base = u32_obj.val
#print "Time Base: %d" % time_base
# Time context
u8_obj = u8_type.U8Type()
u8_obj.deserialize(msg, ptr)
ptr += u8_obj.getSize()
time_context = u8_obj.val
# Seconds
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_secs = u32_obj.val
#print "Time Seconds: %d" % time_secs
# Micro-seconds
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_usecs = u32_obj.val
#print "Time MicroSeconds: %d" % time_usecs
# Decode value here...
# Look up correct Channel channel telemetry instance object for decoding
if tlm_id in self.__ch_obj_dict:
ch_obj = self.__ch_obj_dict[tlm_id]
# Deserialize to a tuple to stringify
ch_value = ch_obj.deserialize(msg, ptr)
return (tlm_id, ch_value)
else:
return None
def decode_event_api(self, msg):
"""
Decode event log message using Event object dictionary.
@return (Event ID, Event Arguments)
"""
ptr = 0
# Decode log event ID here...
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
event_id = u32_obj.val
#print "ID: %d" % i
# Decode time...
# Base
u32_obj = u16_type.U16Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_base = u32_obj.val
#print "Time Base: %d" % time_base
# Time context
u8_obj = u8_type.U8Type()
u8_obj.deserialize(msg, ptr)
ptr += u8_obj.getSize()
time_context = u8_obj.val
# Seconds
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_secs = u32_obj.val
#print "Time Seconds: %d" % time_secs
# Micro-seconds
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_usecs = u32_obj.val
#print "Time MicroSeconds: %d" % time_usecs
if event_id in self.__event_obj_dict:
event_obj = self.__event_obj_dict[event_id]
event_args = event_obj.deserialize(msg[ptr:])[1:]
return (event_id, event_args)
else:
return None
def set_datetime(self, dt, time_base=0xffff):
'''
Sets the timebase from a datetime object.
Args:
dt (datetime): datetime object to read from time.
'''
total_seconds = (dt - datetime.fromtimestamp(0)).total_seconds()
seconds = int(total_seconds)
useconds = int((total_seconds - seconds) * 1000000)
self._check_time_base(time_base)
self._check_useconds(useconds)
self.__timeBase = u16_type.U16Type(time_base)
self.__secs = u32_type.U32Type(seconds)
self.__usecs = u32_type.U32Type(useconds)
def decode_packet(self, msg):
"""
Decode packetized telemetry using packet specification.
"""
#type_base.showBytes(msg)
#
ptr = 0
# Decode packet ID here...
u16_obj = u16_type.U16Type()
u16_obj.deserialize(msg, ptr)
ptr += u16_obj.getSize()
packet_id = u16_obj.val
# print "ID: %d" % packet_id
time_tag = msg[ptr:ptr + 11]
# get packet from dictionary
if not self.__packet_dict.has_key(packet_id):
print("Packetized telemetry packet id %d not found!" % packet_id)
return
(packet_name, packet_size,
channel_list) = self.__packet_dict[packet_id]
# check size
if (packet_size != len(msg)):
print("Packet %s, id %d, size mismatch. Expected: %d Actual: %d" %
(packet_name, packet_id, packet_size, len(msg)))
return
# extract channels from packet
# print("Decoding packet %s"%packet_name)
packet_offset = 11 + 2 # start at data part of packet
for (channel_id, channel_size, channel_name) in channel_list:
#print("Decoding channel %s, ID %d, size %d"%(channel_name,channel_id,channel_size))
# build a new channel object for each channel and pass it to the channel listener
ch_id_obj = u32_type.U32Type(channel_id)
#ch_id_obj.val(channel_id)
# build message for channel decode
channel_msg = ch_id_obj.serialize(
) + time_tag + msg[packet_offset:packet_offset + channel_size]
# send the channel
self.__channel_listener.put_data(channel_msg)
packet_offset += channel_size
def parse_raw_msg_api(self, raw_msg):
"""
Parse the given raw message into its component parts
Args:
raw_msg (bytearray): Raw message to parse. Must be a valid raw msg
Returns:
Tuple: (length, descriptor, msg). length is type int. Descriptor is
type int. Msg is a bytearray.
"""
# Data Entry Structure
#
# +---------------------------+
# | Length (n bytes) |
# +---------------------------+
# | Descriptor Type (4 bytes) | -
# +---------------------------+ |
# | | |
# | Message data... | Length
# | ... | |
# | .. | |
# . :
offset = 0
# Parse length
self.len_obj.deserialize(raw_msg, offset)
offset += self.len_obj.getSize()
length = self.len_obj.val
# Parse Descriptor type
desc_obj = u32_type.U32Type()
desc_obj.deserialize(raw_msg, offset)
offset += desc_obj.getSize()
desc = desc_obj.val
# Retrieve message section
msg = raw_msg[offset:]
return (length, desc, msg)
def receive_packet(self, sock):
"""
Receive packet by first reading 4 byte size,
then 4 byte desc. Then recieve the rest of message.
Send size, desc, id, and optional args for decoding.
"""
pkt_len = sock.recv(4)
if self.__binfile != None:
self.__binfile.write(pkt_len)
pkt_desc = sock.recv(4)
if self.__binfile != None:
self.__binfile.write(pkt_desc)
desc = int(struct.unpack(">I",pkt_desc)[0])
size = int(struct.unpack(">I",pkt_len)[0])
data = sock.recv(size - u32_type.U32Type().getSize())
if self.__binfile != None:
self.__binfile.write(data)
return (size, desc, data)
def decode_api(self, data):
'''
Decodes the given data and returns the result.
This function allows for non-registered code to call the same decoding
code as is used to parse data passed to the data_callback function.
Args:
data: Binary data to decode
Returns:
Parsed version of the event data in the form of a EventData object
or None if the data is not decodable
'''
ptr = 0
# Decode event ID here...
id_obj = u32_type.U32Type()
id_obj.deserialize(data, ptr)
ptr += id_obj.getSize()
event_id = id_obj.val
# Decode time...
event_time = time_type.TimeType()
event_time.deserialize(data, ptr)
ptr += event_time.getSize()
if event_id in self.__dict:
event_temp = self.__dict[event_id]
arg_vals = self.decode_args(data, ptr, event_temp)
return event_data.EventData(arg_vals, event_time, event_temp)
else:
print("Event decode error: id %d not in dictionary"%event_id)
return None
def decode_event(self, msg):
"""
Decode event log message using Event object dictionary.
"""
#type_base.showBytes(msg)
#
ptr = 0
# Decode log event ID here...
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
i = u32_obj.val
#print "ID: %d" % i
# Decode time...
# Base
u32_obj = u16_type.U16Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_base = u32_obj.val
#print "Time Base: %d" % time_base
# Time context
u8_obj = u8_type.U8Type()
u8_obj.deserialize(msg, ptr)
ptr += u8_obj.getSize()
time_context = u8_obj.val
# Seconds
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_secs = u32_obj.val
#print "Time Seconds: %d" % time_secs
# Micro-seconds
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_usecs = u32_obj.val
#print "Time MicroSeconds: %d" % time_usecs
# Decode arguments here...
# Look up correct Event event log message instance object for decoding
if i in self.__event_obj_dict:
event_obj = self.__event_obj_dict[i]
#
# Deserialize to a tuple to stringify
event_args = event_obj.deserialize(msg[ptr:])
# Stringify to formatted message string for GUI updates
fmt = event_obj.stringify(event_args)
#
# Package NAME, ID, SEVERITY, and formatted string into tuple for views update.
# 'Name (id) Severity : formatted string'
name = event_obj.getName()
event_id = event_obj.getId()
severity = event_obj.getSeverity()
# See if set to workstation time
if (time_base == 2) or (time_base == 3):
if self.__opt.log_time == "local":
event_time = time.strftime("%m/%d-%H:%M:%S",
time.localtime(time_secs))
else:
event_time = time.strftime("%m/%d-%H:%M:%S",
time.gmtime(time_secs))
else:
event_time = "%f" % (float(time_secs) +
(float(time_usecs) / 1000000))
# Create tuple of log msg string and log msg object
msg_tup = (event_time, name, event_id, severity, fmt)
self.__current_event_log_msg = ("%s: %s (%d) %s : %s" % msg_tup,
msg_tup)
#print self.__current_event_log_msg
else:
self.__current_event_log_msg = "EVR ID Received but could not be decoded: %d" % i
def decode_ch(self, msg):
"""
Decode channel telemetry item using Channel object dictionary.
"""
#type_base.showBytes(msg)
#
ptr = 0
# Decode channel ID here...
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
i = u32_obj.val
#print "ID: 0x%04X" % i
# Decode time...
# Base
u32_obj = u16_type.U16Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_base = u32_obj.val
#print "Time Base: %d" % time_base
# Decode context
u8_obj = u8_type.U8Type()
u8_obj.deserialize(msg, ptr)
ptr += u8_obj.getSize()
time_context = u8_obj.val
#print "Time Context: %d" % time_context
# Seconds
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_secs = u32_obj.val
#print "Time Seconds: %d" % time_secs
# Micro-seconds
u32_obj = u32_type.U32Type()
u32_obj.deserialize(msg, ptr)
ptr += u32_obj.getSize()
time_usecs = u32_obj.val
#print "Time MicroSeconds: %d" % time_usecs
# Decode value here...
# Look up correct Channel channel telemetry instance object for decoding
if i in self.__ch_obj_dict:
ch_obj = self.__ch_obj_dict[i]
#
# Set time here...
ch_obj.setTime(time_base, time_context, time_secs, time_usecs)
#
# Deserialize to a tuple to stringify
ch_value = ch_obj.deserialize(msg, ptr)
#print "Value: %s" % ch_value
#
# Package NAME, ID, CH. Desc., time, and Value into tuple for views update.
# '(Name, id, ch. desc., time_sec, time_usec, value)'
name = ch_obj.getName()
i = ch_obj.getId()
ch = ch_obj.getChDesc()
t = ch_obj.getTime()
f = ch_obj.getFormatString()
lr = ch_obj.getLowRed()
lo = ch_obj.getLowOrange()
ly = ch_obj.getLowYellow()
hy = ch_obj.getHighYellow()
ho = ch_obj.getHighOrange()
hr = ch_obj.getHighRed()
self.__current_ch_msg = (name, i, ch, t, ch_value, f, lr, lo, ly,
hy, ho, hr)
#print self.__current_ch_msg
else:
self.__current_ch_msg = ("Not_Defined", i, "", ("", "", "",
""), "Not_Defined",
"Not_Defined", "NoLowRed", "NoLowOrange",
"NoLowYellow", "NoHighYellow",
"NoHighOrange", "NoHighRed")
def useconds(self, val):
self._check_useconds(val)
self.__usecs = u32_type.U32Type(val)
def seconds(self, val):
self.__secs = u32_type.U32Type(val)
