{'id': 'rst', 'name': 'RESET#', 'desc': 'Reset line'},
)
annotations = (
- ('bit-out', 'Output bits'),
- ('bit-in', 'Input bits'),
+ ('bit-out', 'Output bit'),
+ ('bit-in', 'Input bit'),
('slot-out-raw', 'Output raw value'),
('slot-out-tag', 'Output TAG'),
('slot-out-cmd-addr', 'Output command address'),
outputs = []
tags = ['Analog/digital', 'IC', 'Sensor']
annotations = (
- ('read', 'Register read commands'),
- ('write', 'Register write commands'),
- ('warning', 'Warnings'),
+ ('read', 'Register read'),
+ ('write', 'Register write'),
+ ('warning', 'Warning'),
)
annotation_rows = (
- ('read', 'Read', (0,)),
- ('write', 'Write', (1,)),
+ ('reads', 'Reads', (0,)),
+ ('writes', 'Writes', (1,)),
('warnings', 'Warnings', (2,)),
)
tags = ['Clock/timing', 'IC', 'Wireless/RF']
annotations = (
# Sent from the host to the chip.
- ('register', 'Register written to the device'),
+ ('write', 'Register write'),
)
annotation_rows = (
- ('registers', 'Register writes', (ANN_REG,)),
+ ('writes', 'Register writes', (ANN_REG,)),
)
def __init__(self):
outputs = []
tags = ['IC', 'PC', 'Sensor']
annotations = (
- ('read', 'Register read commands'),
- ('write', 'Register write commands'),
- ('warning', 'Warnings'),
+ ('read', 'Register read'),
+ ('write', 'Register write'),
+ ('warning', 'Warning'),
)
annotation_rows = (
- ('read', 'Read', (0,)),
- ('write', 'Write', (1,)),
+ ('reads', 'Reads', (0,)),
+ ('writes', 'Writes', (1,)),
('warnings', 'Warnings', (2,)),
)
('bit', 'Bit'),
('end', 'End'),
('byte', 'Byte'),
- ('humidity', 'Relative humidity in percent'),
- ('temperature', 'Temperature in degrees Celsius'),
+ ('humidity', 'Relative humidity'),
+ ('temperature', 'Temperature'),
('checksum', 'Checksum'),
)
annotation_rows = (
tags = ['Debug/trace']
annotations = (
('trace', 'Trace info'),
- ('branch', 'Branches'),
- ('exception', 'Exceptions'),
+ ('branch', 'Branch'),
+ ('exception', 'Exception'),
('execution', 'Instruction execution'),
('data', 'Data access'),
('pc', 'Program counter'),
- ('instr_e', 'Executed instructions'),
- ('instr_n', 'Not executed instructions'),
+ ('instr_e', 'Executed instruction'),
+ ('instr_n', 'Not executed instruction'),
('source', 'Source code'),
('location', 'Current location'),
('function', 'Current function'),
)
annotation_rows = (
- ('trace', 'Trace info', (0,)),
+ ('traces', 'Trace info', (0,)),
('flow', 'Code flow', (1, 2, 3,)),
- ('data', 'Data access', (4,)),
- ('pc', 'Program counter', (5,)),
- ('instruction', 'Instructions', (6, 7,)),
- ('source', 'Source code', (8,)),
- ('location', 'Current location', (9,)),
- ('function', 'Current function', (10,)),
+ ('data-vals', 'Data access', (4,)),
+ ('pc-vals', 'Program counters', (5,)),
+ ('instructions', 'Instructions', (6, 7,)),
+ ('sources', 'Source code', (8,)),
+ ('locations', 'Current locations', (9,)),
+ ('functions', 'Current functions', (10,)),
)
options = (
{'id': 'objdump', 'desc': 'objdump path',
'default': ''},
)
annotations = (
- ('trace', 'Trace information'),
+ ('trace', 'Trace info'),
('timestamp', 'Timestamp'),
('software', 'Software message'),
('dwt_event', 'DWT event'),
('function', 'Current function'),
)
annotation_rows = (
- ('trace', 'Trace information', (0, 1)),
- ('software', 'Software trace', (2,)),
- ('dwt_event', 'DWT event', (3,)),
- ('dwt_watchpoint', 'DWT watchpoint', (4,)),
- ('dwt_exc', 'Exception trace', (5,)),
- ('dwt_pc', 'Program counter', (6,)),
- ('mode', 'Current mode', (7, 8, 9)),
- ('location', 'Current location', (10,)),
- ('function', 'Current function', (11,)),
+ ('traces', 'Trace info', (0, 1)),
+ ('softwares', 'Software traces', (2,)),
+ ('dwt_events', 'DWT events', (3,)),
+ ('dwt_watchpoints', 'DWT watchpoints', (4,)),
+ ('dwt_excs', 'Exception traces', (5,)),
+ ('dwt_pcs', 'Program counters', (6,)),
+ ('modes', 'Current modes', (7, 8, 9)),
+ ('locations', 'Current locations', (10,)),
+ ('functions', 'Current functions', (11,)),
)
def __init__(self):
('data', 'Stream data'),
)
annotation_rows = (
- ('stream', 'Current stream', (0,)),
- ('data', 'Stream data', (1,)),
+ ('streams', 'Current streams', (0,)),
+ ('data-vals', 'Stream data', (1,)),
)
def __init__(self):
('warning', 'Warning'),
)
annotation_rows = (
- ('frame', 'Frame', (0, 1, 2, 3, 4, 5, 6)),
- ('status', 'Status', (7,)),
+ ('frame', 'Frames', (0, 1, 2, 3, 4, 5, 6)),
+ ('status-vals', 'Status', (7,)),
('warnings', 'Warnings', (8,)),
)
('rfb', 'Read fuse bits'),
('rhfb', 'Read high fuse bits'),
('refb', 'Read extended fuse bits'),
- ('warnings', 'Warnings'),
+ ('warning', 'Warning'),
('dev', 'Device'),
)
annotation_rows = (
('bits', 'Bits', ()),
('commands', 'Commands', tuple(range(7 + 1))),
('warnings', 'Warnings', (8,)),
- ('dev', 'Device', (9,)),
+ ('devs', 'Devices', (9,)),
)
def __init__(self):
Ann.PARITY_ERR, Ann.STOP_OK, Ann.STOP_ERR, Ann.BREAK)),
('pdi_fields', 'PDI fields', (Ann.OPCODE, Ann.DATA_PROG, Ann.DATA_DEV,
Ann.PDI_BREAK)),
- ('pdi_cmds', 'PDI Cmds', (Ann.ENABLE, Ann.DISABLE, Ann.COMMAND)),
+ ('pdi_cmds', 'PDI commands', (Ann.ENABLE, Ann.DISABLE, Ann.COMMAND)),
)
binary = (
('bytes', 'PDI protocol bytes'),
{'id': 'sample_point', 'desc': 'Sample point (%)', 'default': 70.0},
)
annotations = (
- ('data', 'CAN payload data'),
+ ('data', 'Payload data'),
('sof', 'Start of frame'),
('eof', 'End of frame'),
('id', 'Identifier'),
('ack-slot', 'ACK slot'),
('ack-delimiter', 'ACK delimiter'),
('stuff-bit', 'Stuff bit'),
- ('warnings', 'Human-readable warnings'),
+ ('warning', 'Warning'),
('bit', 'Bit'),
)
annotation_rows = (
('single_write', 'Single register write'),
('burst_read', 'Burst register read'),
('burst_write', 'Burst register write'),
- ('status', 'Status register'),
+ ('status_reg', 'Status register'),
('warning', 'Warning'),
)
annotation_rows = (
- ('cmd', 'Commands', (ANN_STROBE,)),
+ ('cmds', 'Commands', (ANN_STROBE,)),
('data', 'Data', (ANN_SINGLE_READ, ANN_SINGLE_WRITE, ANN_BURST_READ,
ANN_BURST_WRITE, ANN_STATUS_READ)),
('status', 'Status register', (ANN_STATUS,)),
('eom-1', 'Message continued'),
('nack', 'ACK not set'),
('ack', 'ACK set'),
- ('bits', 'Bits'),
- ('bytes', 'Bytes'),
- ('frames', 'Frames'),
- ('sections', 'Sections'),
- ('warnings', 'Warnings')
+ ('bit', 'Bit'),
+ ('byte', 'Byte'),
+ ('frame', 'Frame'),
+ ('section', 'Section'),
+ ('warning', 'Warning')
)
annotation_rows = (
('bits', 'Bits', (0, 1, 2, 3, 4, 5)),
)
annotations = (
('bit', 'Bit'),
- ('startbit', 'Startbit'),
+ ('startbit', 'Start bit'),
('sbit', 'Select bit'),
('ybit', 'Individual or group'),
('address', 'Address'),
)
annotation_rows = (
('bits', 'Bits', (0,)),
- ('raw', 'Raw data', (7,)),
+ ('raw-data', 'Raw data', (7,)),
('fields', 'Fields', (1, 2, 3, 4, 5, 6)),
)
)
annotations = (
('start-of-minute', 'Start of minute'),
- ('special-bits', 'Special bits (civil warnings, weather forecast)'),
+ ('special-bit', 'Special bit (civil warnings, weather forecast)'),
('call-bit', 'Call bit'),
('summer-time', 'Summer time announcement'),
('cest', 'CEST bit'),
('month', 'Month'),
('year', 'Year'),
('date-parity', 'Date parity bit'),
- ('raw-bits', 'Raw bits'),
- ('unknown-bits', 'Unknown bits'),
- ('warnings', 'Human-readable warnings'),
+ ('raw-bit', 'Raw bit'),
+ ('unknown-bit', 'Unknown bit'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('bits', 'Bits', (17, 18)),
('break', 'Break'),
('mab', 'Mark after break'),
('startbit', 'Start bit'),
- ('stopbits', 'Stop bit'),
+ ('stopbit', 'Stop bit'),
('startcode', 'Start code'),
('channel', 'Channel'),
('interframe', 'Interframe'),
)
annotation_rows = (
('bits', 'Bits', (0, 3, 4)),
- ('data', 'Data', (9,)),
- ('name', 'Logical', (1, 2, 5, 6, 7, 8)),
+ ('data-vals', 'Data', (9,)),
+ ('logical-vals', 'Logical', (1, 2, 5, 6, 7, 8)),
('errors', 'Errors', (10,)),
)
('write-datetime', 'Write date/time'),
('reg-read', 'Register read'),
('reg-write', 'Register write'),
- ('warnings', 'Warnings'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('bits', 'Bits', tuple(range(9, 24))),
outputs = []
tags = ['Embedded/industrial', 'IC']
annotations = (
- ('text', 'Human-readable text'),
+ ('text', 'Text'),
)
def __init__(self):
outputs = []
tags = ['IC', 'Memory']
annotations = (
- ('text', 'Human-readable text'),
+ ('text', 'Text'),
)
binary = (
('mem_read', 'Data read from memory'),
outputs = []
tags = ['IC', 'Sensor']
annotations = (
- ('text', 'Human-readable text'),
+ ('text', 'Text'),
)
def __init__(self):
)
annotation_rows = (
('bits', 'Bits', (0,)),
- ('raw', 'Raw data', (3,)),
+ ('raw-vals', 'Raw data', (3,)),
('fields', 'Fields', (1, 2)),
)
outputs = []
tags = ['Display', 'Memory', 'PC']
annotations = (
- ('fields', 'EDID structure fields'),
- ('sections', 'EDID structure sections'),
+ ('field', 'Field'),
+ ('section', 'Section'),
)
annotation_rows = (
('fields', 'Fields', (0,)),
)
annotations = (
# Warnings
- ('warnings', 'Warnings'),
+ ('warning', 'Warning'),
# Bits/bytes
('control-code', 'Control code'),
('address-pin', 'Address pin (A0/A1/A2)'),
('frame-crc', 'Frame CRC'),
('cid-delimiter', 'Channel idle delimiter'),
('bss', 'Byte start sequence'),
- ('warnings', 'Human-readable warnings'),
+ ('warning', 'Warning'),
('bit', 'Bit'),
('cid', 'Channel idle delimiter'),
('dts', 'Dynamic trailing sequence'),
('phase', 'Phase'),
('increment', 'Increment'),
('count', 'Count'),
- ('turns', 'Turns'),
+ ('turn', 'Turn'),
('interval', 'Interval'),
('average', 'Average'),
('rpm', 'Rate'),
)
- annotation_rows = tuple((u, v, (i,)) for i, (u, v) in enumerate(annotations))
+ annotation_rows = tuple((u + 's', v + 's', (i,)) for i, (u, v) in enumerate(annotations))
def __init__(self):
self.reset()
annotations = \
tuple(('message-0x%02X' % i, 'Message 0x%02X' % i) for i in range(18)) + (
('summary', 'Summary'),
- ('warnings', 'Warnings'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('messages', 'Messages', tuple(range(18))),
- ('summary', 'Summary', (18,)),
+ ('summaries', 'Summaries', (18,)),
('warnings', 'Warnings', (19,)),
)
('address-write', 'Address write'),
('data-read', 'Data read'),
('data-write', 'Data write'),
- ('warnings', 'Human-readable warnings'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('bits', 'Bits', (5,)),
- ('addr-data', 'Address/Data', (0, 1, 2, 3, 4, 6, 7, 8, 9)),
+ ('addr-data', 'Address/data', (0, 1, 2, 3, 4, 6, 7, 8, 9)),
('warnings', 'Warnings', (10,)),
)
binary = (
('eoi', 'EOI'),
('text', 'Talker text'),
('periph', 'IEC bus peripherals'),
- ('warn', 'Warning'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('bits', 'IEC bits', (ANN_RAW_BIT,)),
('eois', 'EOI', (ANN_EOI,)),
('texts', 'Talker texts', (ANN_TEXT,)),
('periphs', 'IEC peripherals', (ANN_IEC_PERIPH,)),
- ('warns', 'Warnings', (ANN_WARN,)),
+ ('warnings', 'Warnings', (ANN_WARN,)),
)
binary = (
('raw', 'Raw bytes'),
('cmd-inv', 'Command#'),
('repeat-code', 'Repeat code'),
('remote', 'Remote'),
- ('warnings', 'Warnings'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('bits', 'Bits', (0, 1, 2, 3, 4)),
('fields', 'Fields', (5, 6, 7, 8, 9, 10)),
- ('remote', 'Remote', (11,)),
+ ('remote-vals', 'Remote', (11,)),
('warnings', 'Warnings', (12,)),
)
)
annotations = (
('jitter', 'Jitter value'),
- ('clk_missed', 'Clock missed'),
- ('sig_missed', 'Signal missed'),
+ ('clk_miss', 'Clock miss'),
+ ('sig_miss', 'Signal miss'),
)
annotation_rows = (
- ('jitter', 'Jitter values', (0,)),
- ('clk_missed', 'Clock missed', (1,)),
- ('sig_missed', 'Signal missed', (2,)),
+ ('jitter_vals', 'Jitter values', (0,)),
+ ('clk_misses', 'Clock misses', (1,)),
+ ('sig_misses', 'Signal misses', (2,)),
)
binary = (
('ascii-float', 'Jitter values as newline-separated ASCII floats'),
annotation_rows = (
('bits-tdi', 'Bits (TDI)', (16,)),
('bits-tdo', 'Bits (TDO)', (17,)),
- ('bitstrings-tdi', 'Bitstring (TDI)', (18,)),
- ('bitstrings-tdo', 'Bitstring (TDO)', (19,)),
+ ('bitstrings-tdi', 'Bitstrings (TDI)', (18,)),
+ ('bitstrings-tdo', 'Bitstrings (TDO)', (19,)),
('states', 'States', tuple(range(15 + 1))),
)
('control_fields_in', 'Control fields in', (10,)),
('control_fields_out', 'Control fields out', (11,)),
('regs', 'Registers', regs_items['rows_range']),
- ('pracc', 'PrAcc', (12,)),
+ ('pracc-vals', 'PrAcc', (12,)),
)
def __init__(self):
annotations = (
('data', 'LIN data'),
('control', 'Protocol info'),
- ('error', 'Error descriptions'),
- ('inline_error', 'Protocol violations and errors'),
+ ('error', 'Error description'),
+ ('inline_error', 'Protocol violation or error'),
)
annotation_rows = (
- ('data', 'Data', (0, 1, 3)),
- ('error', 'Error', (2,)),
+ ('data_vals', 'Data', (0, 1, 3)),
+ ('errors', 'Errors', (2,)),
)
def __init__(self):
'values': (9, 10, 11, 12)},
)
annotations = (
- ('celsius', 'Temperature in degrees Celsius'),
- ('kelvin', 'Temperature in Kelvin'),
- ('text-verbose', 'Human-readable text (verbose)'),
- ('text', 'Human-readable text'),
- ('warnings', 'Human-readable warnings'),
+ ('celsius', 'Temperature / °C'),
+ ('kelvin', 'Temperature / Kelvin'),
+ ('text-verbose', 'Text (verbose)'),
+ ('text', 'Text'),
+ ('warning', 'Warning'),
)
def __init__(self):
{'id': 'lsmi', 'name': 'LSMI#', 'desc': 'System Management Interrupt'},
)
annotations = (
- ('warnings', 'Warnings'),
+ ('warning', 'Warning'),
('start', 'Start'),
('cycle-type', 'Cycle-type/direction'),
('addr', 'Address'),
('tar2', 'Turn-around cycle 2'),
)
annotation_rows = (
- ('data', 'Data', (1, 2, 3, 4, 5, 6, 7)),
+ ('data-vals', 'Data', (1, 2, 3, 4, 5, 6, 7)),
('warnings', 'Warnings', (0,)),
)
outputs = []
tags = ['Display']
annotations = (
- ('register', 'Registers written to the device'),
- ('digit', 'Digits displayed on the device'),
- ('warnings', 'Human-readable warnings'),
+ ('register', 'Register write'),
+ ('digit', 'Digit displayed'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('commands', 'Commands', (ann_reg, ann_digit)),
('decode', 'Decode'),
)
annotation_rows = (
- ('bit-val', 'Bit value', (0,)),
- ('bit-num', 'Bit number', (1,)),
- ('frame', 'Frame', (2, 3)),
- ('frame-error', 'Frame error', (4,)),
- ('decode', 'Decode', (5,)),
+ ('bit-vals', 'Bit values', (0,)),
+ ('bit-nums', 'Bit numbers', (1,)),
+ ('frames', 'Frames', (2, 3)),
+ ('frame-errors', 'Frame errors', (4,)),
+ ('decode-vals', 'Decode', (5,)),
)
def __init__(self):
outputs = []
tags = ['Audio', 'PC']
annotations = (
- ('text-verbose', 'Human-readable text (verbose)'),
- ('text-sysreal-verbose', 'Human-readable SysReal text (verbose)'),
- ('text-error', 'Human-readable Error text'),
+ ('text-verbose', 'Text (verbose)'),
+ ('text-sysreal-verbose', 'SysReal text (verbose)'),
+ ('text-error', 'Error text'),
)
annotation_rows = (
('normal', 'Normal', (0, 2)),
('bit', 'Bit'),
('bitstring', 'Bitstring'),
)
- annotation_rows = tuple((u, v, (i,)) for i, (u, v) in enumerate(annotations))
+ annotation_rows = tuple((u + 's', v + 's', (i,)) for i, (u, v) in enumerate(annotations))
binary = (
('raw', 'Raw binary'),
)
annotation_rows = (
('sc', 'Server->client', (0, 1, 2, 3, 4, 5, 6)),
('cs', 'Client->server', (7, 8, 9, 10, 11, 12, 13)),
- ('error-indicator', 'Errors in frame', (14,)),
+ ('error-indicators', 'Errors in frame', (14,)),
)
options = (
{'id': 'scchannel', 'desc': 'Server -> client channel',
)
annotations = (
('time', 'Time'),
- ('units', 'Units'),
+ ('unit', 'Unit'),
('symbol', 'Symbol'),
('letter', 'Letter'),
('word', 'Word'),
)
- annotation_rows = tuple((u, v, (i,)) for i, (u, v) in enumerate(annotations))
+ annotation_rows = tuple((u + 's', v + 's', (i,)) for i, (u, v) in enumerate(annotations))
def __init__(self):
self.reset()
outputs = []
tags = ['IC', 'Wireless/RF']
annotations = (
- ('sread', 'Short register read commands'),
- ('swrite', 'Short register write commands'),
- ('lread', 'Long register read commands'),
- ('lwrite', 'Long register write commands'),
- ('warning', 'Warnings'),
+ ('sread', 'Short register read'),
+ ('swrite', 'Short register write'),
+ ('lread', 'Long register read'),
+ ('lwrite', 'Long register write'),
+ ('warning', 'Warning'),
('tx-frame', 'TX frame'),
('rx-frame', 'RX frame'),
('tx-retry-1', '1x TX retry'),
('ccafail', 'CCAFAIL (channel busy)'),
)
annotation_rows = (
- ('read', 'Read', (0, 2)),
- ('write', 'Write', (1, 3)),
+ ('reads', 'Reads', (0, 2)),
+ ('writes', 'Writes', (1, 3)),
('warnings', 'Warnings', (4,)),
('tx-frames', 'TX frames', (5,)),
('rx-frames', 'RX frames', (6,)),
outputs = []
tags = ['IC', 'Sensor']
annotations = (
- ('text', 'Human-readable text'),
+ ('text', 'Text'),
)
def __init__(self):
'default': 'Standard gamepad', 'values': ('Standard gamepad',)},
)
annotations = (
- ('button', 'Button states'),
+ ('button', 'Button state'),
('no-press', 'No button press'),
('not-connected', 'Gamepad unconnected')
)
annotation_rows = (
('buttons', 'Button states', (0,)),
- ('no-press', 'No button press', (1,)),
- ('not-connected', 'Gamepad unconnected', (2,)),
+ ('no-presses', 'No button presses', (1,)),
+ ('not-connected-vals', 'Gamepad unconnected', (2,)),
)
def __init__(self):
)
annotations = (
# Sent from the host to the chip.
- ('cmd', 'Commands sent to the device'),
- ('tx-data', 'Payload sent to the device'),
+ ('cmd', 'Command'),
+ ('tx-data', 'Payload'),
# Returned by the chip.
- ('register', 'Registers read from the device'),
- ('rx-data', 'Payload read from the device'),
+ ('register', 'Register read'),
+ ('rx-data', 'Payload read'),
- ('warning', 'Warnings'),
+ ('warning', 'Warning'),
)
ann_cmd = 0
ann_tx = 1
('nunchuk-write', 'Nunchuk write'),
('cmd-init', 'Init command'),
('summary', 'Summary'),
- ('warnings', 'Warnings'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('regs', 'Registers', tuple(range(13))),
- ('summary', 'Summary', (13,)),
+ ('summaries', 'Summaries', (13,)),
('warnings', 'Warnings', (14,)),
)
)
annotations = (
('bit', 'Bit'),
- ('warnings', 'Warnings'),
+ ('warning', 'Warning'),
('reset', 'Reset'),
('presence', 'Presence'),
- ('overdrive', 'Overdrive speed notifications'),
+ ('overdrive', 'Overdrive speed notification'),
)
annotation_rows = (
('bits', 'Bits', (0, 2, 3)),
outputs = ['onewire_network']
tags = ['Embedded/industrial']
annotations = (
- ('text', 'Human-readable text'),
+ ('text', 'Text'),
)
def __init__(self):
('info', 'Info'),
('1111', '1111'),
('1010', '1010'),
- ('diffman', 'Diff Man'),
+ ('diffman', 'Diff man'),
('nrz', 'NRZ'),
)
annotation_rows = (
- ('frame', 'Framing',(0,)),
- ('info', 'Info', (1,)),
+ ('frames', 'Framing', (0,)),
+ ('info-vals', 'Info', (1,)),
('man1111', 'Man 1111', (2,)),
('man1010', 'Man 1010', (3,)),
- ('diffman', 'Diff Man', (4,)),
- ('nrz', 'NRZ', (5,)),
+ ('diffmans', 'Diff man', (4,)),
+ ('nrz-vals', 'NRZ', (5,)),
)
binary = (
('pulse-lengths', 'Pulse lengths'),
annotation_rows = (
('bits', 'Bits', (0,)),
('fields', 'Fields', (1, 3, 4)),
- ('l2', 'Level 2', (2,)),
+ ('l2vals', 'Level 2', (2,)),
)
binary = (
('data-hex', 'Hex data'),
('compare', 'Compare', (1,)),
('fields', 'Fields', (2,)),
('ref_fields', 'Ref fields', (3,)),
- ('level2', 'L2', (4,)),
- ('ref_level2', 'Ref L2', (5,)),
+ ('level2_vals', 'L2', (4,)),
+ ('ref_level2_vals', 'Ref L2', (5,)),
)
options = (
{'id': 'displayas', 'desc': 'Display as', 'default': 'Nibble - Hex',
outputs = []
tags = ['Wireless/RF']
annotations = (
- ('text-verbose', 'Human-readable text (verbose)'),
- ('text', 'Human-readable text'),
- ('warnings', 'Human-readable warnings'),
+ ('text-verbose', 'Text (verbose)'),
+ ('text', 'Text'),
+ ('warning', 'Warning'),
)
def __init__(self):
'default': 'little', 'values': ('little', 'big')},
)
annotations = (
- ('items', 'Items'),
- ('words', 'Words'),
+ ('item', 'Item'),
+ ('word', 'Word'),
)
annotation_rows = (
('items', 'Items', (0,)),
annotations = (
('register', 'Register type'),
('value', 'Register value'),
- ('warning', 'Warning messages'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('regs', 'Registers', (0, 1)),
('period', 'Period'),
)
annotation_rows = (
- ('duty-cycle', 'Duty cycle', (0,)),
- ('period', 'Period', (1,)),
+ ('duty-cycle-vals', 'Duty cycles', (0,)),
+ ('periods', 'Periods', (1,)),
)
binary = (
('raw', 'RAW file'),
{'id': 'qi', 'name': 'Qi', 'desc': 'Demodulated Qi data line'},
)
annotations = (
- ('bits', 'Bits'),
- ('bytes-errors', 'Bit errors'),
- ('bytes-start', 'Start bits'),
- ('bytes-info', 'Info bits'),
- ('bytes-data', 'Data bytes'),
- ('packets-data', 'Packet data'),
- ('packets-checksum-ok', 'Packet checksum'),
- ('packets-checksum-err', 'Packet checksum'),
+ ('bit', 'Bit'),
+ ('byte-error', 'Bit error'),
+ ('byte-start', 'Start bit'),
+ ('byte-info', 'Info bit'),
+ ('byte-data', 'Data byte'),
+ ('packet-data', 'Packet data'),
+ ('packet-checksum-ok', 'Packet checksum OK'),
+ ('packet-checksum-err', 'Packet checksum error'),
)
annotation_rows = (
('bits', 'Bits', (0,)),
tags = ['Wireless/RF']
annotations = (
('cmd', 'Command'),
- ('params', 'Command parameters'),
- ('disabled', 'Disabled bits'),
- ('return', 'Returned values'),
- ('disabled_return', 'Disabled returned values'),
+ ('param', 'Command parameter'),
+ ('disabled', 'Disabled bit'),
+ ('return', 'Returned value'),
+ ('disabled_return', 'Disabled returned value'),
('interpretation', 'Interpretation'),
)
annotation_rows = (
('commands', 'Commands', (0, 1, 2)),
- ('return', 'Return', (3, 4)),
- ('interpretation', 'Interpretation', (5,)),
+ ('returns', 'Returns', (3, 4)),
+ ('interpretations', 'Interpretations', (5,)),
)
def __init__(self):
outputs = []
tags = ['Display']
annotations = (
- ('rgb', 'RGB values'),
+ ('rgb', 'RGB value'),
)
def __init__(self):
('rgb', 'RGB'),
)
annotation_rows = (
- ('bit', 'Bits', (0, 1)),
- ('rgb', 'RGB', (2,)),
+ ('bits', 'Bits', (0, 1)),
+ ('rgb-vals', 'RGB values', (2,)),
)
def __init__(self):
)
annotation_rows = (
('bits', 'Bits', tuple(range(0, 8 + 1)) + (11, 12, 13)),
- ('regs', 'Register access', (14, 15)),
+ ('regs', 'Register accesses', (14, 15)),
('date-time', 'Date/time', (9, 10)),
)
('cmdbit', 'Command bit'),
('databit', 'Data bit'),
('cmd', 'Command'),
- ('data', 'Data byte'),
- ('warnings', 'Human-readable warnings'),
+ ('databyte', 'Data byte'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('bits', 'Bits', (ann_cmdbit, ann_databit)),
annotations = \
tuple(('cmd%d' % i, 'CMD%d' % i) for i in range(64)) + \
tuple(('acmd%d' % i, 'ACMD%d' % i) for i in range(64)) + ( \
- ('bits', 'Bits'),
+ ('bit', 'Bit'),
('field-start', 'Start bit'),
('field-transmission', 'Transmission bit'),
('field-cmd', 'Command'),
('field-arg', 'Argument'),
('field-crc', 'CRC'),
('field-end', 'End bit'),
- ('decoded-bits', 'Decoded bits'),
- ('decoded-fields', 'Decoded fields'),
+ ('decoded-bit', 'Decoded bit'),
+ ('decoded-field', 'Decoded field'),
)
annotation_rows = (
('raw-bits', 'Raw bits', (128,)),
('decoded-bits', 'Decoded bits', (135,)),
('decoded-fields', 'Decoded fields', (136,)),
('fields', 'Fields', tuple(range(129, 135))),
- ('cmd', 'Commands', tuple(range(128))),
+ ('commands', 'Commands', tuple(range(128))),
)
def __init__(self):
('r2', 'R2 reply'),
('r3', 'R3 reply'),
('r7', 'R7 reply'),
- ('bits', 'Bits'),
- ('bit-warnings', 'Bit warnings'),
+ ('bit', 'Bit'),
+ ('bit-warning', 'Bit warning'),
)
annotation_rows = (
('bits', 'Bits', (133, 134)),
- ('cmd-reply', 'Commands/replies', tuple(range(133))),
+ ('commands-replies', 'Commands/replies', tuple(range(133))),
)
def __init__(self):
('bit1', 'Bit1'),
('start', 'START'),
('stop', 'STOP'),
- ('sig', 'Sig')
+ ('signature', 'Signature')
)
annotation_rows = (
('bits', 'Bits', (0, 1, 2, 3)),
- ('sig', 'Sig', (4,))
+ ('signatures', 'Signatures', (4,))
)
def __init__(self):
annotations = (
('bitrate', 'Bitrate / baudrate'),
('preamble', 'Preamble'),
- ('bits', 'Bits'),
- ('aux', 'Auxillary-audio-databits'),
- ('samples', 'Audio Samples'),
+ ('bit', 'Bit'),
+ ('aux', 'Auxillary-audio-databit'),
+ ('sample', 'Audio Sample'),
('validity', 'Data Valid'),
('subcode', 'Subcode data'),
('chan_stat', 'Channnel Status'),
annotations = (
('miso-data', 'MISO data'),
('mosi-data', 'MOSI data'),
- ('miso-bits', 'MISO bits'),
- ('mosi-bits', 'MOSI bits'),
- ('warnings', 'Human-readable warnings'),
+ ('miso-bit', 'MISO bit'),
+ ('mosi-bit', 'MOSI bit'),
+ ('warning', 'Warning'),
('miso-transfer', 'MISO transfer'),
('mosi-transfer', 'MOSI transfer'),
)
annotation_rows = (
('miso-bits', 'MISO bits', (2,)),
- ('miso-data', 'MISO data', (0,)),
- ('miso-transfer', 'MISO transfer', (5,)),
+ ('miso-data-vals', 'MISO data', (0,)),
+ ('miso-transfers', 'MISO transfers', (5,)),
('mosi-bits', 'MOSI bits', (3,)),
- ('mosi-data', 'MOSI data', (1,)),
- ('mosi-transfer', 'MOSI transfer', (6,)),
+ ('mosi-data-vals', 'MOSI data', (1,)),
+ ('mosi-transfers', 'MOSI transfers', (6,)),
('other', 'Other', (4,)),
)
binary = (
annotation_rows = (
('bits', 'Bits', (Ann.BITS,)),
('fields', 'Fields', (Ann.CMD, Ann.DATA)),
- ('description', 'Description', (Ann.DESC,)),
+ ('descriptions', 'Descriptions', (Ann.DESC,)),
)
def __init__(self):
('position', 'Position')
)
annotation_rows = (
- ('speed', 'Speed', (0,)),
- ('position', 'Position', (1,)),
+ ('speeds', 'Speeds', (0,)),
+ ('positions', 'Positions', (1,)),
)
def __init__(self):
('address', 'Address'),
('data-write', 'Data write'),
('data-read', 'Data read'),
- ('debug', 'Debug'),
+ ('debug-msg', 'Debug message'),
)
annotation_rows = (
('bits', 'Bits', (0,)),
annotations = (
('register', 'Register type'),
('value', 'Register value'),
- ('warnings', 'Warning messages'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('regs', 'Registers', (0, 1)),
{'id': 'edge', 'desc': 'Clock edge to sample on', 'default': 'rising', 'values': ('rising', 'falling') }
)
annotations = tuple(('ch%d' % i, 'Ch%d' % i) for i in range(MAX_CHANNELS))
- annotation_rows = tuple(('ch%d' % i, 'Ch%d' % i, (i,)) for i in range(MAX_CHANNELS))
+ annotation_rows = tuple(('ch%d-vals' % i, 'Ch%d' % i, (i,)) for i in range(MAX_CHANNELS))
def __init__(self):
self.reset()
('delta', 'Delta'),
)
annotation_rows = (
- ('time', 'Time', (0,)),
- ('average', 'Average', (1,)),
- ('delta', 'Delta', (2,)),
+ ('times', 'Times', (0,)),
+ ('averages', 'Averages', (1,)),
+ ('deltas', 'Deltas', (2,)),
)
options = (
{ 'id': 'avg_period', 'desc': 'Averaging period', 'default': 100 },
annotations = (
('rx-data', 'RX data'),
('tx-data', 'TX data'),
- ('rx-start', 'RX start bits'),
- ('tx-start', 'TX start bits'),
- ('rx-parity-ok', 'RX parity OK bits'),
- ('tx-parity-ok', 'TX parity OK bits'),
- ('rx-parity-err', 'RX parity error bits'),
- ('tx-parity-err', 'TX parity error bits'),
- ('rx-stop', 'RX stop bits'),
- ('tx-stop', 'TX stop bits'),
- ('rx-warnings', 'RX warnings'),
- ('tx-warnings', 'TX warnings'),
- ('rx-data-bits', 'RX data bits'),
- ('tx-data-bits', 'TX data bits'),
+ ('rx-start', 'RX start bit'),
+ ('tx-start', 'TX start bit'),
+ ('rx-parity-ok', 'RX parity OK bit'),
+ ('tx-parity-ok', 'TX parity OK bit'),
+ ('rx-parity-err', 'RX parity error bit'),
+ ('tx-parity-err', 'TX parity error bit'),
+ ('rx-stop', 'RX stop bit'),
+ ('tx-stop', 'TX stop bit'),
+ ('rx-warning', 'RX warning'),
+ ('tx-warning', 'TX warning'),
+ ('rx-data-bit', 'RX data bit'),
+ ('tx-data-bit', 'TX data bit'),
('rx-break', 'RX break'),
('tx-break', 'TX break'),
('rx-packet', 'RX packet'),
)
annotation_rows = (
('rx-data-bits', 'RX bits', (Ann.RX_DATA_BIT,)),
- ('rx-data', 'RX', (Ann.RX_DATA, Ann.RX_START, Ann.RX_PARITY_OK, Ann.RX_PARITY_ERR, Ann.RX_STOP)),
+ ('rx-data-vals', 'RX data', (Ann.RX_DATA, Ann.RX_START, Ann.RX_PARITY_OK, Ann.RX_PARITY_ERR, Ann.RX_STOP)),
('rx-warnings', 'RX warnings', (Ann.RX_WARN,)),
- ('rx-break', 'RX break', (Ann.RX_BREAK,)),
+ ('rx-breaks', 'RX breaks', (Ann.RX_BREAK,)),
('rx-packets', 'RX packets', (Ann.RX_PACKET,)),
('tx-data-bits', 'TX bits', (Ann.TX_DATA_BIT,)),
- ('tx-data', 'TX', (Ann.TX_DATA, Ann.TX_START, Ann.TX_PARITY_OK, Ann.TX_PARITY_ERR, Ann.TX_STOP)),
+ ('tx-data-vals', 'TX data', (Ann.TX_DATA, Ann.TX_START, Ann.TX_PARITY_OK, Ann.TX_PARITY_ERR, Ann.TX_STOP)),
('tx-warnings', 'TX warnings', (Ann.TX_WARN,)),
- ('tx-break', 'TX break', (Ann.TX_BREAK,)),
+ ('tx-breaks', 'TX breaks', (Ann.TX_BREAK,)),
('tx-packets', 'TX packets', (Ann.TX_PACKET,)),
)
binary = (
('crc', 'Checksum'),
('eop', 'End Of Packet'),
('sym', '4b5b symbols'),
- ('warnings', 'Warnings'),
+ ('warning', 'Warning'),
('src', 'Source Message'),
('snk', 'Sink Message'),
('payload', 'Payload'),
)
annotation_rows = (
('4b5b', 'Symbols', (7,)),
- ('phase', 'Parts', (1, 2, 3, 4, 5, 6)),
- ('payload', 'Payload', (11,)),
- ('type', 'Type', (0, 9, 10)),
+ ('parts', 'Parts', (1, 2, 3, 4, 5, 6)),
+ ('payloads', 'Payloads', (11,)),
+ ('types', 'Types', (0, 9, 10)),
('warnings', 'Warnings', (8,)),
- ('text', 'Full text', (12,)),
+ ('texts', 'Full text', (12,)),
)
binary = (
('raw-data', 'RAW binary data'),
('request-setup-write', 'Setup: Host-to-device'),
('request-bulk-read', 'Bulk: Device-to-host'),
('request-bulk-write', 'Bulk: Host-to-device'),
- ('errors', 'Unexpected packets'),
+ ('error', 'Unexpected packet'),
)
annotation_rows = (
('request-setup', 'USB SETUP', (0, 1)),
'default': 4, 'values': (1, 2, 4, 8, 16, 32)},
)
annotations = (
- ('bits', 'Bits'),
+ ('bit', 'Bit'),
('state', 'State'),
)
annotation_rows = (
- ('bits', 'Binary value', (0,)),
- ('state', 'Stream state', (1,)),
+ ('bits', 'Bits', (0,)),
+ ('states', 'Stream states', (1,)),
)
def __init__(self):
outputs = []
tags = ['Networking']
annotations = (
- ('fieldnames-and-values', 'XFP structure field names and values'),
- ('fields', 'XFP structure fields'),
+ ('field-name-and-val', 'Field name and value'),
+ ('field-val', 'Field value'),
)
def __init__(self):
} for i in range(16)
)
annotations = (
- ('addr', 'Memory or I/O address'),
+ ('addr', 'Memory or I/O address'),
('memrd', 'Byte read from memory'),
('memwr', 'Byte written to memory'),
- ('iord', 'Byte read from I/O port'),
- ('iowr', 'Byte written to I/O port'),
+ ('iord', 'Byte read from I/O port'),
+ ('iowr', 'Byte written to I/O port'),
('instr', 'Z80 CPU instruction'),
- ('rop', 'Value of input operand'),
- ('wop', 'Value of output operand'),
- ('warn', 'Warning message'),
+ ('rop', 'Value of input operand'),
+ ('wop', 'Value of output operand'),
+ ('warning', 'Warning'),
)
annotation_rows = (
('addrbus', 'Address bus', (Ann.ADDR,)),
projects / libsigrokdecode.git / commitdiff