This package provides a pin-level protocol analyzer extension for the impulse framework, focusing on the analysis and decoding of serial communication protocols commonly found in embedded systems, digital designs, and electronic measurements. impulse is a powerful, extensible platform for signal analysis, visualization, and processing, widely used in engineering and scientific domains.
About impulse
impulse is a powerful visualization and analysis workbench designed to help engineers understand, analyze, and debug complex semiconductor and multi-core software systems. It provides seamless integration into IDE frameworks and enables interoperability with a growing set of extensions, such as language IDEs and reporting tools.
impulse is based on a modular framework designed to unify the handling of signal and measurement data from diverse sources. It provides a robust infrastructure for reading, writing, analyzing, and visualizing signals, supporting both simple and highly structured data. impulse's extensible architecture allows developers to add support for new data formats by implementing custom readers and writers, making it a versatile tool for engineers, scientists, and developers.
About Pin-Level Protocol Analysis
Pin-level protocol analysis involves decoding and interpreting digital communication protocols at the signal level. Unlike transaction-level analysis which deals with high-level bus protocols (AMBA, AXI, etc.), pin-level analysis focuses on simple serial protocols used for chip-to-chip communication, sensor interfaces, and peripheral connections. These protocols are commonly analyzed using logic analyzers and oscilloscopes in hardware debugging, embedded system development, and verification workflows.
Purpose of this Extension
The EDA Analyzer Extension brings comprehensive pin-level protocol decoding capabilities to impulse, similar to what's available in dedicated logic analyzers and tools like sigrok/PulseView. This extension enables users to:
- Decode serial protocols from captured waveform data (VCD, FST, FSDB, or other formats)
- Analyze embedded system communications including I2C, SPI, UART, and many specialized protocols
- Debug hardware interfaces with detailed protocol-level visualization
- Verify sensor and peripheral communications in mixed-signal designs
- Complement transaction-level analysis by focusing on simple, pin-level protocols
This extension specifically excludes complex bus interfaces (AMBA, AXI, AHB) and transaction-level protocols, which are covered by separate impulse extensions. Instead, it focuses on the "simple" protocols that are the bread and butter of logic analyzer users and embedded system developers.
Supported and Planned Protocol Analyzers
The following protocols are prioritized based on actual support in professional logic analyzers (Saleae, Rigol, Keysight), widespread use in embedded systems, and availability in open-source tools like sigrok (131+ decoders). Priority levels: Critical (universal, in all logic analyzers), High (very common, widely supported), Medium (domain-specific, good support), Low (specialized applications).
Priority: Critical (Universal)
| Protocol | Description | Inputs | Output Type | Status |
|---|---|---|---|---|
| I2C | Two-wire synchronous serial bus for chip-to-chip communication | 2 (SDA, SCL) | struct of {addr: integer, r/w: enum, data[]: array of integer, ack: binary} | Development |
| SPI | Full-duplex synchronous serial interface for high-speed peripherals | 3-4 (MOSI, MISO, CLK, CS) | struct of {mosi[]: array of integer, miso[]: array of integer, cs_state: enum} | Development |
| UART / Async Serial | Asynchronous serial communication, universal in embedded systems | 1-2 (TX, RX) | struct of {data: integer, parity: binary, framing_error: binary} | Development |
| CAN | Controller Area Network for automotive and industrial applications | 1-2 (CAN_H, CAN_L) | struct of {id: integer, dlc: integer, data[]: array of integer, crc: integer, ack: binary} | Development |
Priority: High (Very Common - Widely Supported)
| Protocol | Description | Inputs | Output Type | Status |
|---|---|---|---|---|
| 1-Wire | Single-wire bidirectional serial bus (Dallas/Maxim devices) | 1 (DATA) | struct of {rom_code: integer, cmd: integer, data[]: array of integer} | Planned |
| JTAG | Standard test/debug interface (IEEE 1149.1) for processors | 4 (TDI, TDO, TCK, TMS) | struct of {ir: integer, dr: integer, state: enum} | Planned |
| SWD | Serial Wire Debug, two-wire debug interface for ARM cores | 2 (SWDIO, SWCLK) | struct of {addr: integer, data: integer, ack: enum, parity: binary} | Planned |
| I2S / PCM | Inter-IC Sound for digital audio data transfer | 3-4 (SCK, WS, SD, MCLK) | array of struct {left_sample: integer, right_sample: integer} | Planned |
| Manchester | Manchester/Biphase encoding (Differential, Biphase Space/Mark) | 1-2 (DATA or +/-) | binary (decoded bits) | Planned |
| USB (LS/FS) | Low-speed and full-speed USB signaling and packet decoding | 2 (D+, D-) | struct of {pid: enum, addr: integer, ep: integer, data[]: array of integer, crc: integer} | Planned |
| Parallel Bus | Generic synchronous parallel data bus analysis | 9-33 (DATA[8-32], CLK) | integer or array of integer | Planned |
| LIN | Local Interconnect Network for automotive applications | 1 (LIN) | struct of {sync: integer, id: integer, data[]: array of integer, checksum: integer} | Planned |
| Modbus RTU/ASCII | Industrial automation protocol over serial lines | 1-2 (TX, RX) | struct of {addr: integer, function: enum, data[]: array of integer, crc: integer} | Planned |
| SMBus / PMBus | System Management Bus (I2C variant for PC and power management) | 2 (SDA, SCL) | struct of {addr: integer, cmd: integer, data[]: array of integer, pec: integer} | Planned |
Priority: Medium (Common in Specific Domains)
| Protocol | Description | Inputs | Output Type | Status |
|---|---|---|---|---|
| DMX-512 | Digital lighting control protocol (entertainment/stage lighting) | 1 (DMX) | array of integer (512 channels) | Planned |
| MDIO | Management Data I/O for Ethernet PHY configuration | 2 (MDC, MDIO) | struct of {phy_addr: integer, reg_addr: integer, data: integer} | Planned |
| MIDI | Musical Instrument Digital Interface | 1 (MIDI) | struct of {status: enum, channel: integer, data1: integer, data2: integer} | Planned |
| PS/2 | Keyboard and mouse interface protocol | 2 (CLK, DATA) | struct of {scancode: integer, make/break: enum} | Planned |
| HDLC | High-Level Data Link Control framing protocol | 1 (DATA) | struct of {addr: integer, ctrl: integer, data[]: array of integer, fcs: integer} | Planned |
| HDMI-CEC | HDMI Consumer Electronics Control | 1 (CEC) | struct of {initiator: integer, dest: integer, opcode: enum, params[]: array of integer} | Planned |
| HD44780 | Parallel LCD controller protocol | 11 (D[0-7], RS, RW, E) | struct of {cmd/data: enum, ascii_char: integer} | Planned |
| Atmel SWI | Atmel Single Wire Interface for crypto devices | 1 (SWI) | struct of {flag: integer, count: integer, data[]: array of integer} | Planned |
| BISS-C | Bidirectional Serial Synchronous protocol (industrial encoders) | 2-3 (MA, SL, CLK) | struct of {position: integer, crc: integer, status: enum} | Planned |
| I3C | Improved Inter-Integrated Circuit (MIPI I3C) | 2 (SDA, SCL) | struct of {addr: integer, cmd: enum, data[]: array of integer, hdr: binary} | Planned |
| PWM | Pulse-width modulation signal analysis and decoding | 1 (PWM) | struct of {duty_cycle: float, frequency: float, pulse_width: float} | Planned |
| Wiegand | Protocol for access control card readers | 2 (D0, D1) | struct of {facility_code: integer, card_number: integer, parity: binary} | Planned |
| Microwire | Three-wire serial bus (often used for EEPROMs) | 3 (DI, DO, CLK, CS) | struct of {opcode: enum, addr: integer, data[]: array of integer} | Planned |
| RS-232/RS-485 | Standard serial voltage levels and differential serial | 1-2 (TX/RX or A/B) | struct of {data: integer, parity: binary, framing_error: binary} | Planned |
Priority: Medium-Low (Supported by Sigrok, Less Common)
| Protocol | Description | Inputs | Output Type | Status |
|---|---|---|---|---|
| S/PDIF | Sony/Philips Digital Interface Format for digital audio | 1 (S/PDIF) | struct of {audio_sample[]: array of integer, channel_status: integer} | Planned |
| DALI | Digital Addressable Lighting Interface | 1-2 (DALI or +/-) | struct of {addr: integer, cmd: enum, data: integer, response: integer} | Planned |
| DCF77 | European longwave time signal (77.5kHz) | 1 (DCF77) | struct of {year: integer, month: integer, day: integer, hour: integer, minute: integer} | Planned |
| SD Card (SPI) | SD card protocol in SPI mode | 4 (MOSI, MISO, CLK, CS) | struct of {cmd: enum, response: integer, data_block[]: array of integer} | Planned |
| SD Card (SD) | SD card native protocol | 6 (CMD, CLK, DAT[0-3]) | struct of {cmd: enum, response: integer, data_block[]: array of integer} | Planned |
| IEEE-488 (GPIB) | General Purpose Interface Bus for test instruments | 16 (DIO[1-8], CTRL[8]) | struct of {cmd: enum, data: integer, eoi: binary, status: integer} | Planned |
| FlexRay | Advanced automotive network protocol | 2 (BP, BM) | struct of {id: integer, cycle: integer, data[]: array of integer, crc: integer} | Planned |
| Stepper Motor | Step/direction signal analysis for motor control | 2-3 (STEP, DIR, EN) | struct of {position: integer, speed: float, direction: enum} | Planned |
| Quadrature Encoder | Incremental encoder A/B/Z signal decoding | 2-3 (A, B, Z) | struct of {position: integer, direction: enum, index: binary} | Planned |
| Gray Code | Rotary encoder with Gray code position | 4-10 (bits) | integer (position) | Planned |
| Caliper | Digital caliper measurement protocol | 1 (DATA) | float (measurement in mm/inch) | Planned |
| RGB LED (WS2812) | WS2812/NeoPixel/WS2811 RGB LED strip protocols | 1 (DATA) | array of struct {r: integer, g: integer, b: integer} | Planned |
| DHT11/DHT22 | Aosong temperature/humidity sensor protocol | 1 (DATA) | struct of {temp: float, humidity: float, checksum: integer} | Planned |
| DS18x20 | Dallas/Maxim 1-Wire temperature sensors | 1 (1-WIRE) | struct of {temp: float, resolution: integer, rom_code: integer} | Planned |
Priority: Low (Specialized - Niche Applications)
| Protocol | Description | Inputs | Output Type | Status |
|---|---|---|---|---|
| IR NEC | NEC infrared remote control protocol | 1 (IR) | struct of {addr: integer, cmd: integer, repeat: binary} | Planned |
| IR RC-5 | Philips RC-5 infrared remote control | 1 (IR) | struct of {addr: integer, cmd: integer, toggle: binary} | Planned |
| IR RC-6 | Philips RC-6 infrared remote control | 1 (IR) | struct of {mode: integer, addr: integer, cmd: integer, toggle: binary} | Planned |
| IR SIRC | Sony SIRC infrared remote control | 1 (IR) | struct of {cmd: integer, addr: integer, extended: integer} | Planned |
| Miller Encoding | Miller/Modified Frequency Modulation encoding | 1 (DATA) | binary (decoded bits) | Planned |
| Morse Code | Demodulated morse code decoding | 1 (KEY) | array of struct {char: integer, timing: float} | Planned |
| EM4100 RFID | 125kHz RFID card protocol (EM4100/EM4102) | 1 (DEMOD) | struct of {customer_id: integer, card_id: integer, parity: binary} | Planned |
| EM4305 RFID | 125kHz programmable RFID (EM4205/EM4305) | 1 (DEMOD) | struct of {cmd: enum, data[]: array of integer, crc: integer} | Planned |
| T5577 RFID | 125kHz programmable RFID protocol | 1 (DEMOD) | struct of {cmd: enum, data[]: array of integer, pwd: integer} | Planned |
| Wiegand (RFID) | Wiegand interface for access control | 2 (D0, D1) | struct of {facility_code: integer, card_number: integer} | Planned |
| SWIM | STM8 Single Wire Interface Module debug protocol | 1 (SWIM) | struct of {cmd: enum, addr: integer, data: integer} | Planned |
| PDI | Atmel/AVR Program and Debug Interface | 2 (PDI_DATA, PDI_CLK) | struct of {cmd: enum, addr: integer, data[]: array of integer} | Planned |
| TPI | Atmel Tiny Programming Interface | 3 (TPIDATA, TPICLK, /RESET) | struct of {cmd: enum, data: integer} | Planned |
| AVR ISP | AVR In-System Programming (SPI-based) | 4 (MOSI, MISO, SCK, /RESET) | struct of {cmd: enum, response: integer, data[]: array of integer} | Planned |
| cJTAG | Compact JTAG (IEEE 1149.7) | 2 (TMSC, TCKC) | struct of {ir: integer, dr: integer, state: enum} | Planned |
| Nunchuk | Nintendo Wii Nunchuk controller I2C protocol | 2 (SDA, SCL) | struct of {joy_x: integer, joy_y: integer, accel_xyz: array of integer, buttons: integer} | Planned |
| SBUS (Futaba) | RC hobby serial bus protocol | 1 (SBUS) | array of integer (16 channels) | Planned |
| SAE J1850 | Automotive diagnostic protocol (VPW/PWM) | 1 (J1850) | struct of {priority: integer, header: integer, data[]: array of integer, crc: integer} | Planned |
| SENT | Single Edge Nibble Transmission (automotive sensors) | 1 (SENT) | struct of {status: enum, data[]: array of integer, crc: integer, pause: float} | Planned |
| OBD-II | On-Board Diagnostics (over CAN/J1850) | 1-2 (CAN/J1850) | struct of {mode: enum, pid: integer, data[]: array of integer, dtc[]: array of integer} | Planned |
| X10 | Home automation power line protocol | 1 (X10) | struct of {house_code: enum, unit_code: integer, function: enum} | Planned |
| KNX | Building automation bus protocol | 1 (KNX) | struct of {src: integer, dst: integer, cmd: enum, data[]: array of integer} | Planned |
| Maple Bus | Sega Dreamcast peripheral protocol | 2 (DATA_A, DATA_B) | struct of {cmd: enum, addr: integer, data[]: array of integer} | Planned |
| Z80 Bus | Zilog Z80 processor bus disassembly | 28 (A[0-15], D[0-7], CTRL[5]) | struct of {addr: integer, opcode: integer, mnemonic: string, data: integer} | Planned |
| MCS-48 | Intel MCS-48 external memory access | 19 (P1[0-7], P2[0-7], ALE, /RD, /WR) | struct of {addr: integer, data: integer, r/w: enum} | Planned |
Specialty Protocols (Domain-Specific)
| Protocol | Description | Inputs | Output Type | Domain | Status |
|---|---|---|---|---|---|
| AC'97 | Audio Codec '97 for PC audio | 5 (SYNC, BIT_CLK, SDATA_OUT, SDATA_IN, /RESET) | struct of {slot: integer, tag: integer, addr: integer, data: integer} | PC/Audio | Planned |
| LPC | Low Pin Count bus (PC peripherals) | 6 (LAD[0-3], LFRAME#, LCLK) | struct of {cyctype: enum, addr: integer, data: integer} | PC Systems | Planned |
| EDID | Extended Display Identification Data (over I2C) | 2 (SDA, SCL) | struct of {mfr: string, model: string, resolution[]: array of struct, timing[]: array of struct} | Display | Planned |
| DDC/CI | Display Data Channel / Command Interface | 2 (SDA, SCL) | struct of {vcp_code: enum, value: integer, max_value: integer} | Display | Planned |
| Qi Wireless | Wireless charging protocol decoder | 1 (DATA) | struct of {header: integer, msg_type: enum, data[]: array of integer, checksum: integer} | Consumer | Planned |
| LANC | Sony LANC camera control protocol | 1 (LANC) | struct of {cmd: enum, data[]: array of integer} | Video | Planned |
| NMEA 0183 | Marine GPS/navigation protocol (over UART) | 1 (TX) | struct of {sentence_id: string, data[]: array of string, checksum: integer} | Marine | Planned |
| NMEA 2000 | Marine CAN-based protocol | 2 (CAN_H, CAN_L) | struct of {pgn: integer, src: integer, dst: integer, data[]: array of integer} | Marine | Planned |
| DCC | Digital Command Control (model trains) | 1 (DCC) | struct of {addr: integer, speed: integer, direction: enum, functions[]: array of binary} | Hobby | Planned |
| Ethernet MII/RMII | Media Independent Interface | 9-17 (TXD, RXD, CLK, etc) | struct of {preamble: integer, dst_mac: integer, src_mac: integer, data[]: array of integer, fcs: integer} | Networking | Planned |
| TDM Audio | Time Division Multiplex audio | 3-4 (FS, SCK, SD, MCLK) | array of array of integer (channels×samples) | Audio | Planned |
Protocol Analysis Utilities
| Tool | Description | Inputs | Output Type | Status |
|---|---|---|---|---|
| Edge Counter | Count edges and measure frequency | 1 (SIGNAL) | struct of {edge_count: integer, frequency: float, period: float} | Planned |
| Timing/Jitter | Measure timing between edges, jitter calculation | 1-2 (CLK, DATA) | struct of {period: float, jitter: float, min: float, max: float, mean: float, stddev: float} | Planned |
| Bitrate Detector | Automatic bitrate/baudrate detection | 1 (SIGNAL) | struct of {bitrate: float, confidence: float, unit_interval: float} | Planned |
| Number Decoder | Interpret bit patterns as integers, floats, enums | 1-32 (DATA[n]) | integer or float or enum | Planned |
| Signature Analysis | Pattern signature generation and matching | 1-8 (DATA[n]) | struct of {signature: integer, match_count: integer} | Planned |
Quick Start
- Select a file to view.
- Use the context menus 'Open with' and select the impulse Viewer (You may select the impulse Viewer as the default option at this point).
- On activation, it may take a while (a few secs) to load the backend java server. The OS may ask you for approval.
- Accept the license.
- Create a new view.
- DnD signals into the view.
- Have fun !
License
Our guiding principle for this and all subsequent versions is:
- Non-commercial use is free.
- Commercial use requires a commercial license (including a free plan).
- see LICENSE.md
- see Plans
Documentation
Enter https://toem.io/resources/ for more information about impulse.
Status
Contributions and feedback are welcome as this extension continues to evolve.