def process(self):
frame: AnalyzerFrame = yield
pending_frame: AnalyzerFrame = None
# If not explicitly written, reads start at register 0
cur_register_subaddress = 0
while True:
while True:
# Idle, waiting for start
while frame.type != 'start':
frame = yield pending_frame
pending_frame = None
frame = yield
if frame.type != 'address':
frame = yield AnalyzerFrame('error', frame.start_time, frame.end_time)
break
elif frame.data['address'][0] != TUSB422_I2C_ADDRESS:
# Not a matching address, break back out to idle
break
is_read = frame.data['read']
frame = yield
while frame.type == 'data':
if is_read:
frame = yield AnalyzerFrame('read', frame.start_time, frame.end_time, {
'register': cur_register_subaddress,
'register_name': registers.get_register_name(cur_register_subaddress),
'value': frame.data['data'][0]
})
cur_register_subaddress += 1
else:
cur_register_subaddress = frame.data['data'][0]
prev_frame = frame
frame = yield
if frame.type == 'data':
frames = [
AnalyzerFrame('set_register_offset', prev_frame.start_time, prev_frame.end_time, {
'register': cur_register_subaddress,
'register_name': registers.get_register_name(cur_register_subaddress),
})]
while frame.type == 'data':
frames.append(
AnalyzerFrame('write', frame.start_time, frame.end_time, {
'register': cur_register_subaddress,
'register_name': registers.get_register_name(cur_register_subaddress),
'value': frame.data['data'][0]
}))
frame = yield frames
frames = []
cur_register_subaddress += 1
else:
cur_register_subaddress = prev_frame.data['data'][0]
pending_frame = AnalyzerFrame(
'set_register_offset', prev_frame.start_time, prev_frame.end_time, {
'register': cur_register_subaddress,
'register_name': registers.get_register_name(cur_register_subaddress),
})
def decode(self, frame: AnalyzerFrame):
retval = None
data = frame.data["data"]
if self.frame_start_time is None:
self.frame_start_time = frame.start_time
if data == b"\0":
if self.received:
try:
data = self.decode_bytes(b"".join(self.received))
retval = AnalyzerFrame("Message", self.frame_start_time,
self.frame_end_time, {
"data": data,
})
except DecodeError as de:
retval = AnalyzerFrame("Error", self.frame_start_time,
self.frame_end_time, {
"error": str(de),
})
self.received = []
self.frame_start_time = frame.start_time
else:
self.received.append(data)
self.frame_end_time = frame.end_time
return retval
def dump_stream(self, start_time, end_time, streamid, databytes):
if self.dstyle is DecodeStyleTPIU.Stream:
if streamid != self.stream_match:
return None
if len(databytes) != 0:
if self.dstyle is DecodeStyleTPIU.Saleae:
if streamid != self.stream_match:
return None
# We return Analyzer frames for each byte to be decoded by our higher layer:
frames = []
for idx in range(len(databytes)):
raw_byte = databytes[idx][0]
byte_start = databytes[idx][1]
byte_end = databytes[idx][2]
if (byte_start != None) and (byte_end != None):
nf = AnalyzerFrame('data', byte_start, byte_end,
{'data': bytes([raw_byte])})
frames.append(nf)
return frames
data_str = 'Stream{0:d}:'.format(streamid)
for idx in range(len(databytes)):
raw_byte = databytes[idx][0]
byte_start = databytes[idx][1]
byte_end = databytes[idx][2]
if (byte_start != None) and (byte_end != None):
data_str += ' {0:02X}'.format(raw_byte)
return AnalyzerFrame('tpiu', start_time, end_time,
{'val': data_str})
return None
def decode(self, frame: AnalyzerFrame):
'''
Process a frame from the input analyzer, and optionally return a single `AnalyzerFrame` or a list of `AnalyzerFrame`s.
The type and data values in `frame` will depend on the input analyzer.
'''
try:
ch = frame.data['data'].decode('ascii')
except:
# Not an ASCII character
return
if ch == '\r':
try:
parsed = LssPacket(self.packet)
error = not parsed.known
type = 'request' if parsed.direction == REQUEST else 'reply'
# this is the end of the packet
frame = AnalyzerFrame(
type if parsed.known else 'error',
self.packet_start,
frame.end_time, {
'id': str(parsed.id),
'kind': LssHLA.action_name(parsed.kind),
'command': parsed.description,
'value': str(parsed.value),
'bytes': self.packet,
'description': parsed.description
})
except LssException as e:
error = True
# exception frame
frame = AnalyzerFrame(
'error',
self.packet_start,
frame.end_time, {
'kind': '?',
'bytes': self.packet,
'description': e.message
})
self.packet_start = 0
self.packet_error = False
self.packet = None
# return a valid LSS packet frame
return frame if error or self.DisplayLevel == 'All' else None
else:
if self.packet is None:
self.packet = ch
self.packet_start = frame.start_time
else:
self.packet += ch
return
def decode(self, frame):
frame = super().decode(frame)
if not frame:
return
# Handle new transactions (Read or Write)
if frame.type == 'address':
action_name = self.get_action_name()
new_frame = None
if self.read_transaction:
self.read_transaction.end_time = self.last_frame.end_time
self.format_read_value()
new_frame = self.read_transaction
elif self.write_transaction:
self.write_transaction.end_time = self.last_frame.end_time
self.write_transaction.data['value'] = action_name
new_frame = self.write_transaction
value = frame.data['address']
if self.is_read:
if (self.write_transaction):
frame_type = self.action.name if self.action in FORMATTED_ACTIONS else 'default'
self.read_transaction = AnalyzerFrame(
type=frame_type, start_time=frame.start_time, end_time=frame.end_time, data={"value": 0})
self.write_transaction = None
else:
self.write_transaction = AnalyzerFrame(
type='default', start_time=frame.start_time, end_time=frame.end_time, data={})
self.read_transaction = None
self.base_action = None
self.action = None
return new_frame
# Handle the data
elif frame.type == 'data':
value = frame.data['data'][0]
if self.is_read:
if self.read_transaction:
self.read_transaction.data['value'] = (self.read_transaction.data['value'] << 8) | value
else:
if not self.write_transaction:
# Handle the case where we missed the address frame
return None
if not self.base_action:
self.base_action = base_addresses.get(value, Hla.NOT_FOUND)
elif self.base_action != Hla.NOT_FOUND:
current_actions = actions.get(self.base_action)
if current_actions:
self.action = current_actions.get(value)
self.last_frame = frame
else:
return None
def decode(self, frame: AnalyzerFrame):
'''
Process a frame from the input analyzer, and return a single `AnalyzerFrame`
The type and data values in `frame` will depend on the input analyzer.
'''
if not 'error' in frame.data:
int_value = frame.data['data'][0]
#Test if a new start of header as been detected
if int_value in DATA_LABELS:
self.current_packet = AirDataPacket(frame.start_time,
int_value)
elif self.current_packet is not None:
self.current_packet.parse_byte(int_value, frame.end_time)
if self.current_packet.stop_time is not None:
if self.current_packet.error is not None:
returned_frame = AnalyzerFrame(
'error', self.current_packet.start_time,
self.current_packet.stop_time,
{'error_msg': self.current_packet.error})
elif isinstance(self.current_packet.content, StatusPacket):
returned_frame = AnalyzerFrame(
'status', self.current_packet.start_time,
self.current_packet.stop_time, {
'label':
self.current_packet.content.label,
'hex_value':
hex(self.current_packet.content.int_value)
})
else:
returned_frame = AnalyzerFrame(
'data',
self.current_packet.start_time,
self.current_packet.stop_time,
{
'label':
self.current_packet.content.label,
'flag':
self.current_packet.content.flag,
# Logic SW crash when NaN is returned, as a workaround we need to convert the float in string
'value':
str(
round(
self.current_packet.content.
float_value, 3))
})
self.current_packet = None
return returned_frame
def get_analyzer_frame(self, start_time, end_time):
event_code = self._header[0]
if event_code in BT_EVENT_DESC:
if event_code == 0x0E:
assert len(self._data) >= 3
num_packets = self._data[0]
opcode = struct.unpack("<H", self._data[1:3])[0]
status = self._data[3]
opcode_str = LE_OPCODE_DESC[
opcode] if opcode in LE_OPCODE_DESC else f"Unknown Opcode"
status_str = "Success" if status == 0 else f"Error {hex(status)}"
event_str = f"Command Complete | {status_str} | {opcode_str}"
else:
event_str = BT_EVENT_DESC[event_code]
elif event_code == 0x3e:
# LE event
assert len(self._data) >= 1
subevent = self._data[0]
if subevent in LE_SUBEVENT_DESC:
event_str = LE_SUBEVENT_DESC[subevent]
else:
event_str = f"Unknown LE Event"
else:
event_str = f"Unknown Event"
return AnalyzerFrame('event', start_time, end_time, {
'packet_type': "Event",
'operation': event_str,
})
def handle_error(self, frame):
result = AnalyzerFrame(
"SpiTransactionError", frame.start_time, frame.end_time, {
"error_info":
"The clock was in the wrong state when the enable signal transitioned to active"
})
self.reset()
def get_analyzer_frame(self, start_time, end_time):
opcode, param_len = self._header
return AnalyzerFrame(
'command', start_time, end_time, {
'packet_type': "Command",
'operation': LE_OPCODE_DESC.get(opcode, "Unknown Opcode"),
'length': param_len,
})
def initHlaFrame(self, frame):
try:
del self.myHlaFrame
except:
pass
self.myHlaFrame = AnalyzerFrame('message', frame.start_time,
frame.end_time, {'str': ''})
return self.myHlaFrame
def global_timestamp1(self, frame):
self.end_time = frame.end_time
data_str = 'Global TS {0:d}'.format(self.pdata)
if (self.pcode & (1 << 5)):
data_str += ' ClkChk'
if (self.pcode & (1 << 6)):
data_str += ' Wrap'
return AnalyzerFrame('console', self.start_time, self.end_time,
{'val': data_str})
def decode(self, frame: AnalyzerFrame):
if frame.type == 'address':
direction = 'Read' if frame.data['read'] else 'Write'
address = (frame.data['address'][0] << 1) | (
1 if frame.data['read'] else 0)
ack = frame.data['ack']
return AnalyzerFrame(
'i2c-address', frame.start_time, frame.end_time, {
'description':
'Setup {} to [0x{:02X}] + {}'.format(
direction, address, 'ACK' if ack else 'NAK')
})
elif frame.type == 'data':
data = frame.data['data'][0]
ack = frame.data['ack']
return AnalyzerFrame(
'i2c-data', frame.start_time, frame.end_time, {
'description':
'0x{:02X} + {}'.format(data, 'ACK' if ack else 'NAK')
})
def decode(self, data):
info = self.state.add_byte(
data.data["mosi"], data.start_time, data.end_time
)
if info:
return AnalyzerFrame(
'mytype',
info["start_time"],
info["end_time"],
{"info": info["info"]}
)
def handle_disable(self, frame):
if self.is_valid_transaction():
result = AnalyzerFrame(
"SpiTransaction",
self.transaction_start_time,
frame.end_time,
self.get_frame_data(),
)
else:
result = AnalyzerFrame(
"SpiTransactionError", frame.start_time, frame.end_time, {
"error_info":
"Invalid SPI transaction (spi_enable={}, error={}, transaction_start_time={})"
.format(
self.spi_enable,
self.error,
self.transaction_start_time,
)
})
self.reset()
return result
def decode(self, frame):
global first
if first:
print('-' * 5 + 'IL0373' + '-' * 5)
first = False
frame_complete = False
if frame.type == "result":
octet = frame.data['mosi']
if self._expecting_command:
command_id = octet
self._remaining_data_len = commands[command_id][1]
if self._remaining_data_len is None:
self._remaining_data_len = pixel_count / 8
self._start_time = frame.start_time
self._end_time = frame.end_time
self._data = []
if self._remaining_data_len > 0:
self._expecting_command = False
else:
frame_complete = True
self._command_name = commands[command_id][0]
self._command_id = command_id
else:
self._remaining_data_len -= 1
self._data.append(octet)
self._end_time = frame.end_time
if self._remaining_data_len == 0:
self._expecting_command = True
frame_complete = True
if frame_complete:
self.handle_frame()
data_to_print = ",".join(map(
to_hex, self._data)) if len(self._data) < 6 else ''
command_id_to_print = to_hex(self._command_id)
print(
f'{self._command_name}({command_id_to_print}) data = [{data_to_print}]'
)
return AnalyzerFrame(
'IL0373_frame', self._start_time, self._end_time, {
'input_type': frame.type,
'display_command_id': command_id_to_print,
'command_name': self._command_name,
'display_command_data': data_to_print
})
def decode(self, frame: AnalyzerFrame):
if (frame.type != 'data' and frame.type != 'result'):
return
try:
if (frame.type == 'data'):
ch = frame.data['data'][0]
elif (frame.type == 'result'):
if (self.for_spi_test == 'MOSI'):
ch = frame.data['mosi'][0]
else:
ch = frame.data['miso'][0]
else:
return
except:
return
if self.search_len == 0:
return
if ch != self.search_raw[self.search_index]:
self.search_index = 0
if ch == self.search_raw[self.search_index]:
frames = []
if self.search_index == 0:
self.match_start_time = frame.start_time
self.search_index = self.search_index + 1
if self.search_index == self.search_len:
self.match_end_time = frame.end_time
char = ''
for i in range(self.search_len):
if (self.search_in_type == "Dec"):
char += "%d " % self.search_raw[i]
elif (self.search_in_type == "Hex"):
char += "0x%02x " % self.search_raw[i]
else:
char += chr(self.search_raw[i])
frames.append(
AnalyzerFrame('match', self.match_start_time,
self.match_end_time, {'char': char.strip()}))
self.search_index = 0
return frames
def cdata(self, frame, cc):
nf = None
if cc == 0x0A or cc == 0x00:
nf = AnalyzerFrame('console', self.start_time, frame.end_time,
{'val': self.ctext})
self.ctext = ''
else:
if self.ctext == '':
self.start_time = frame.start_time
newchr = chr(cc)
if str(newchr).isprintable():
self.ctext += newchr
return nf
def local_timestamp(self, frame):
self.end_time = frame.end_time
data_str = 'Local TS {0:d}'.format(self.pdata)
if self.pcode == 0:
data_str += ' synchronous'
elif self.pcode == 1:
data_str += ' delayed'
elif self.pcode == 2:
data_str += ' delayed-generated'
elif self.pcode == 3:
data_str += ' delayed-relative'
else:
data_str += ' UNKNOWN'
return AnalyzerFrame('console', self.start_time, self.end_time,
{'val': data_str})
def lts(self, frame, db):
decoded = None
self.pdata |= ((db & 0x7F) << (self.size * 7))
if (db & (1 << 7)):
self.size += 1
if (self.size == 4):
data_str = 'Local TimeStamp Continuation'
decoded = AnalyzerFrame('err', self.start_time, frame.end_time,
{'val': data_str})
self.fsm = TPIU_FSM.HDR
else:
decoded = self.local_timestamp(frame)
self.fsm = TPIU_FSM.HDR
return decoded
def get_analyzer_frame(self, start_time, end_time):
assert len(self._data) >= 4
data_len, cid = struct.unpack("<HH", self._data[:4])
data = self._data[4:]
assert data_len == len(data)
if data_len > 4:
data_bytes_str = ''.join([f"{b:02X}" for b in data[:4]]) + "..."
else:
data_bytes_str = ''.join([f"{b:02X}" for b in data])
return AnalyzerFrame(
'async', start_time, end_time, {
'packet_type': "Async Data",
'cid': cid,
'length': data_len,
'data': data_bytes_str,
})
def decode(self, frame: AnalyzerFrame):
if frame.type == "enable":
return self.handle_enable(frame)
elif frame.type == "result":
return self.handle_result(frame)
elif frame.type == "disable":
return self.handle_disable(frame)
elif frame.type == "error":
return self.handle_error(frame)
else:
return AnalyzerFrame(
"SpiTransactionError", frame.start_time, frame.end_time, {
"error_info":
"Unexpected frame type from input analyzer: {}".format(
frame.type)
})
def gts2(self, frame, db):
# Hi-order bits for most recently transmitted GTS1 packet
decoded = None
self.pdata |= ((db & 0x7F) << (self.size * 7))
if (db & (1 << 7)):
self.size += 1
# may be 5-byte (bits 26..47) or 7-byte (bits 26..63) packet
if (self.size == 6):
data_str = 'Global TimeStamp2 Continuation'
decoded = AnalyzerFrame('err', self.start_time, frame.end_time,
{'val': data_str})
self.fsm = TPIU_FSM.HDR
else:
decoded = self.global_timestamp2(frame)
self.fsm = TPIU_FSM.HDR
return decoded
def decode(self, frame):
data_copy = {}
for key in frame.data:
value = frame.data[key]
if type(value) is bytes:
data_copy[key] = [x for x in value]
else:
data_copy[key] = value
summary = json.dumps(data_copy, indent=0,
separators=(', ',
': ')).replace("\n",
"").replace("\"", "")
print(summary)
# Return the data frame itself
return AnalyzerFrame('summary', frame.start_time, frame.end_time, {
'input_type': frame.type,
'summary': summary
})
def gts1(self, frame, db):
decoded = None
if (self.size != 3):
self.pdata |= ((db & 0x7F) << (self.size * 7))
else: # bits 21..25
self.pdata |= ((db & 0x1F) << (self.size * 7))
self.pcode = (db & 0x60) # Wrap and ClkCh flags
if (db & (1 << 7)):
self.size += 1
if (self.size == 4):
data_str = 'Global TimeStamp1 Continuation'
decoded = AnalyzerFrame('err', self.start_time, frame.end_time,
{'val': data_str})
self.fsm = TPIU_FSM.HDR
else:
decoded = self.global_timestamp1(frame)
self.fsm = TPIU_FSM.HDR
return decoded
def process_transaction(self):
# This doesn't need to be in here?
self.current_transaction.register_address = self.current_transaction.data.pop(0)
self.current_transaction.write = self.address_is_write
# we can also set the type here
transaction_string = self.decoder.decode_transaction(self.current_transaction)
new_frame = {
'type': 'transaction',
'start_time': self.current_transaction.start_time,
'end_time': self.current_transaction.end_time,
'data': {
'transaction_string' : transaction_string
}
}
new_frame = AnalyzerFrame('transaction',
self.current_transaction.start_time, self.current_transaction.end_time, {
'input_type': self.current_frame.type, 'transaction_string':transaction_string
})
return new_frame
def decode(self, frame: AnalyzerFrame):
'''
Process a frame from the input analyzer, and optionally return a single `AnalyzerFrame` or a list of `AnalyzerFrame`s.
The type and data values in `frame` will depend on the input analyzer.
'''
value = ''
if frame.type == "result":
msb = frame.data['miso'][0]
lsb = frame.data['miso'][1]
result = (msb << 8) + lsb
if result >= 0x8000:
result -= 0x10000
value = (result * 5) / 32768
value = round(value, 4)
# Return the data frame itself
return AnalyzerFrame('ads858x', frame.start_time, frame.end_time, {
'value': value
})
def decode(self, frame: AnalyzerFrame):
if frame.type != 'data':
# Only care about data frame
return
if 'error' in frame.data:
# Ignore error frames (i.e. framing / parity errors)
return
data = frame.data['data']
if not self._packet:
# This is the start of a new packet - determine the type based on the first byte
packet_class = PACKETS.get(data[0], None)
if not packet_class:
return AnalyzerFrame('unknown', frame.start_time,
frame.end_time, {})
self._start_time = frame.start_time
self._packet = packet_class()
elif self._packet.process_data(data):
# This is the end of the packet
result = self._packet.get_analyzer_frame(self._start_time,
frame.end_time)
self._packet = None
self._start_time = None
return result
def clear_stored_message(self, frame):
self.temp_frame = AnalyzerFrame('message', frame.start_time, frame.end_time, {
'str': ''
})
def decode(self, frame: AnalyzerFrame):
if frame.type == 'address':
self.last_address = int.from_bytes(frame.data['address'],
byteorder='little')
if self.last_address == self.pcf8583_addr and not frame.data[
'read']:
self.last_was_index_write = True
self.register_addr = 0
return
if self.last_address == self.pcf8583_addr:
if frame.type == 'data':
if self.last_was_index_write:
self.register_addr = int.from_bytes(frame.data['data'],
byteorder='little')
self.last_was_index_write = False
return AnalyzerFrame('indexReg', frame.start_time,
frame.end_time,
{'register': self.register_addr})
else:
self.register_addr = self.register_addr + 1
if self.register_addr - 1 == 1:
return AnalyzerFrame(
'msecond', frame.start_time, frame.end_time,
{'value': self.__frame_data_to_int(frame) * 10})
if self.register_addr - 1 == 2:
self.second = self.__bcd_to_int(
int.from_bytes(frame.data['data'],
byteorder='little'))
self.time_start_time = frame.start_time
return AnalyzerFrame(
'second', frame.start_time, frame.end_time, {
'value':
self.__bcd_to_int(
int.from_bytes(frame.data['data'],
byteorder='little'))
})
if self.register_addr - 1 == 3:
self.minute = self.__bcd_to_int(
int.from_bytes(frame.data['data'],
byteorder='little'))
return AnalyzerFrame(
'minute', frame.start_time, frame.end_time, {
'value':
self.__bcd_to_int(
int.from_bytes(frame.data['data'],
byteorder='little'))
})
# Here comes the hour, try to combine with seconds and minutes we
# probably got earlier
if self.register_addr - 1 == 4:
d = int.from_bytes(frame.data['data'],
byteorder='little')
self.hour = self.__bcd_to_int(d & 0x3f)
if d & 0x80:
if d & 0x40:
ampm = 'pm'
else:
ampm = 'am'
else:
ampm = ''
if self.time_start_time:
return AnalyzerFrame(
'time', self.time_start_time, frame.end_time, {
'second': str(self.second).zfill(2),
'minute': str(self.minute).zfill(2),
'hour': str(self.hour).zfill(2),
'ampm': ampm
})
else:
return AnalyzerFrame('hour', frame.start_time,
frame.end_time, {
'value': self.hour,
'ampm': ampm
})
# Year+Date
if self.register_addr - 1 == 5:
self.date_start_time = frame.start_time
d = int.from_bytes(frame.data['data'],
byteorder='little')
self.year = 2020 + (d >> 6)
self.day = self.__bcd_to_int(d & 0x3f)
return AnalyzerFrame('yearday', frame.start_time,
frame.end_time, {
'year': self.year,
'day': self.day
})
# Weekday+Month
# Try to combine with Year+Date data
if self.register_addr - 1 == 6:
d = int.from_bytes(frame.data['data'],
byteorder='little')
self.month = self.__bcd_to_int(d & 0x1f)
self.weekday = self.weekdays[d >> 5]
if self.date_start_time:
return AnalyzerFrame(
'date', self.date_start_time, frame.end_time, {
'year': self.year,
'month': self.month,
'day': self.day,
'weekday': self.weekday
})
return AnalyzerFrame('weekdaymonth', frame.start_time,
frame.end_time, {
'month': self.month,
'weekday': self.weekday
})
# Anything else we don't recognize
return AnalyzerFrame(
'data', frame.start_time, frame.end_time, {
'register':
self.register_addr - 1,
'value':
hex(
int.from_bytes(frame.data['data'],
byteorder='little'))
})
return
def state_machine(self):
next = None
while True:
preamble_start = None
preamble_end = None
self.leftover_bits.clear()
for x in range(8):
frame = next
if frame is None:
frame = yield
next = None
if frame.data['data'] != 0xAA:
next = None
return
if x == 0:
preamble_start = frame.start_time
if x == 7:
preamble_end = frame.end_time
print('Preamble')
next = yield AnalyzerFrame('preamble', preamble_start,
preamble_end, {})
address_word = yield from self.get_bits(next, 20)
self.leftover_bits.extend(address_word.data)
address_cmd = self.decode_address(self.leftover_bits)
self.leftover_bits = self.leftover_bits[20:]
print(address_cmd)
next = yield AnalyzerFrame('address', address_word.start_time,
address_word.end_time,
{'address': address_cmd})
header_word = yield from self.get_bits(next, 20)
header_decoded = self.bits_to_bytes(header_word.data, 2)
header_int = int.from_bytes(header_decoded, "little")
object_count = (header_int >> 12) & 0x07
header_data = self.decode_header(header_int, address_cmd)
# object_count = 7
print(header_data)
next = yield AnalyzerFrame('header', header_word.start_time,
header_word.end_time, header_data)
for object_index in range(object_count):
object_word = yield from self.get_bits(next, 40)
object_decoded = self.bits_to_bytes(object_word.data, 4)
object_int = int.from_bytes(object_decoded, "little")
data_object_data = {
'index': object_index,
'data': hex(object_int)
}
data_object_type = 'object'
if header_data['command_code'] == 'Source_Capabilities':
frame_type, data_object_data = decode_source_power_data_object(
object_int)
data_object_type = frame_type
data_object_data['index'] = object_index
data_object_data['raw'] = hex(object_int)
self.source_capabilities_pdo_types[
object_index] = data_object_data['pdo_type']
elif header_data['command_code'] == 'Request':
object_position = (object_int >> 28) & 0x7
if len(self.source_capabilities_pdo_types
) >= object_position:
source_capabilities_pdo_type = self.source_capabilities_pdo_types[
object_position - 1]
frame_type, data_object_data = decode_request_data_object(
object_int, source_capabilities_pdo_type)
data_object_type = frame_type
data_object_data['index'] = object_index
data_object_data['raw'] = hex(object_int)
else:
data_object_type = 'error'
data_object_data = {
'error':
'"Request" for object position "{}" received without "Source_Capabilities" message observed first'
.format(str(object_position)),
'raw':
hex(object_int)
}
elif header_data['command_code'] == 'BIST':
frame_type, data_object_data = decode_bist_data_object(
object_int)
data_object_type = frame_type
data_object_data['index'] = object_index
data_object_data['raw'] = hex(object_int)
elif header_data['command_code'] == 'Sink_Capabilities':
frame_type, data_object_data = decode_sink_power_data_object(
object_int)
data_object_type = frame_type
data_object_data['index'] = object_index
data_object_data['raw'] = hex(object_int)
elif header_data['command_code'] == 'Battery_Status':
frame_type, data_object_data = decode_battery_status_data_object(
object_int)
data_object_type = frame_type
data_object_data['index'] = object_index
data_object_data['raw'] = hex(object_int)
elif header_data['command_code'] == 'Alert':
frame_type, data_object_data = decode_alert_data_object(
object_int)
data_object_type = frame_type
data_object_data['index'] = object_index
data_object_data['raw'] = hex(object_int)
elif header_data['command_code'] == 'Get_Country_Info':
frame_type, data_object_data = decode_get_country_info_data_object(
object_int)
data_object_type = frame_type
data_object_data['index'] = object_index
data_object_data['raw'] = hex(object_int)
elif header_data['command_code'] == 'Enter_USB':
frame_type, data_object_data = decode_enter_usb_data_object(
object_int)
data_object_type = frame_type
data_object_data['index'] = object_index
data_object_data['raw'] = hex(object_int)
elif header_data[
'command_code'] == 'Vendor_Defined' and object_index == 0:
frame_type, data_object_data = decode_vendor_header_data_object(
object_int)
data_object_type = frame_type
data_object_data['index'] = object_index
data_object_data['raw'] = hex(object_int)
# TODO: support all vendor requests
# TODO: support extended headers, and data blocks
print(data_object_data)
next = yield AnalyzerFrame(data_object_type,
object_word.start_time,
object_word.end_time,
data_object_data)
crc_word = yield from self.get_bits(next, 40)
crc_decoded = self.bits_to_bytes(crc_word.data, 4)
crc_int = int.from_bytes(crc_decoded, "little")
print('crc {crc}'.format(crc=hex(crc_int)))
next = yield AnalyzerFrame('crc', crc_word.start_time,
crc_word.end_time,
{'crc': hex(crc_int)})
