E-Sharp Helpcenter
E-Sharp Helpcenter
Breadcrumbs

Bus Transactions

Bus Transactions

Overview

The Transactions view provides real-time monitoring and analysis of bus communications including I2C, SPI, UART, and Socket transactions. This is essential for debugging communication issues, verifying protocol correctness, and understanding device behavior.

Accessing Transactions

  1. Click Transactions in the navigation panel

  2. Transaction log displays all recent bus activity

  3. Filter by transaction type or other criteria

Supported Transaction Types

I2C (Inter-Integrated Circuit)

Common Uses:

  • Sensor communication

  • EEPROM access

  • PMBus power management

  • RTC (Real-Time Clock)

  • I/O expanders

Transaction Details:

  • Address: 7-bit or 10-bit device address

  • Operation: Read, Write, or Combined

  • Data: Bytes transmitted/received

  • Status: ACK/NACK, success/failure

  • Timing: Start, stop, duration

SPI (Serial Peripheral Interface)

Common Uses:

  • Flash memory

  • ADC/DAC chips

  • Display controllers

  • SD cards

  • Wireless modules

Transaction Details:

  • Chip Select: Which SPI device

  • Mode: Clock polarity/phase

  • Data: MOSI (Master Out Slave In)

  • Data: MISO (Master In Slave Out)

  • Clock Speed: SCK frequency

  • Bit Order: MSB/LSB first

UART (Universal Asynchronous Receiver-Transmitter)

Common Uses:

  • Serial console

  • GPS modules

  • Bluetooth modules

  • Debug interfaces

  • AT command devices

Transaction Details:

  • Direction: TX (transmit) or RX (receive)

  • Data: Bytes sent/received

  • Baud Rate: Communication speed

  • Settings: Data bits, parity, stop bits

  • Errors: Framing, parity, overrun

Socket (Network)

Common Uses:

  • TCP/IP communication

  • UDP packets

  • Network protocols

  • Remote control

  • Data streaming

Transaction Details:

  • Protocol: TCP or UDP

  • Address: IP address and port

  • Direction: Send or receive

  • Data: Packet contents

  • Status: Connection state

Transaction Log View

Grid Columns

Column

Description

Timestamp

Time of transaction

Type

I2C, SPI, UART, Socket

Direction

Read, Write, Send, Receive

Address/Channel

Device address or channel name

Data

Hexadecimal bytes

Status

Success, Error, ACK, NACK

Duration

Time elapsed

Details

Additional information

Auto-Scroll

  • Enabled: Log automatically scrolls to newest transactions

  • Disabled: Stay at current position for analysis

  • Toggle with checkbox or button in toolbar

Transaction Limit

  • Log maintains recent transactions (configurable)

  • Oldest transactions removed automatically

  • Prevents memory issues with long-running sessions

  • Adjust limit in settings (default: 1000 transactions)

Filtering Transactions

Filter by Type

Show only specific bus types:

  1. Use filter dropdown or context menu

  2. Select I2C, SPI, UART, or Socket

  3. Or check/uncheck type checkboxes

Example Uses:

  • Debug I2C sensor without SPI noise

  • Monitor UART console separately

  • Track network traffic independently

Filter by Address/Channel

Show transactions for specific device:

  1. Enter address or channel name in filter

  2. Use hexadecimal (0x3C) or decimal (60)

  3. Or use channel name (I2C_BUS_0)

Example:

Filter: 0x3C          → Shows only I2C address 0x3C transactions
Filter: I2C_BUS_0     → Shows all transactions on I2C_BUS_0
Filter: UART_DEBUG    → Shows UART debug port activity

Filter by Direction

Read vs Write:

  1. Filter Read to see device responses

  2. Filter Write to see host commands

  3. Show both for complete picture

Filter by Time

Show transactions in time range:

  1. Enter start time

  2. Enter end time

  3. Apply filter

Or use relative time:

  • Last 1 minute

  • Last 5 minutes

  • Last hour

Search Data Content

Find specific byte patterns:

  1. Enter hex pattern (e.g., AA BB CC)

  2. Transactions containing pattern highlighted

  3. Use for finding specific commands or responses

Transaction Details

View Full Transaction

Expand transaction:

  1. Double-click transaction row

  2. Or click expand icon

  3. Detailed view shows:

    • Complete byte sequence

    • Timing diagram (if available)

    • Error information

    • Related transactions

I2C Transaction Details

Read Transaction:

START → ADDRESS + W → ACK → REGISTER → ACK → RESTART → ADDRESS + R → ACK → DATA → NACK → STOP

Write Transaction:

START → ADDRESS + W → ACK → REGISTER → ACK → DATA → ACK → STOP

Displayed Information:

  • Address: 7-bit address (displayed as 8-bit with R/W bit)

  • Repeated Start: Indicated if present

  • Clock Stretching: If device held SCL low

  • Errors: NACK on address, NACK on data

SPI Transaction Details

Transaction:

CS LOW → CLOCK PULSES → DATA EXCHANGE → CS HIGH

Displayed Information:

  • MOSI Data: Bytes sent from master

  • MISO Data: Bytes received from slave

  • Mode: SPI mode (0-3) indicating clock polarity/phase

  • Speed: Actual SCK frequency

  • Bit Order: MSB or LSB first

UART Transaction Details

Frame Format:

START BIT → DATA BITS → PARITY BIT (optional) → STOP BITS

Displayed Information:

  • Baud Rate: Communication speed (9600, 115200, etc.)

  • Format: 8N1, 8E1, 7N1, etc. (data-parity-stop)

  • Direction: TX or RX

  • Errors: Frame error, parity error, overrun

Socket Transaction Details

TCP/UDP Packet:

Displayed Information:

  • Protocol: TCP or UDP

  • Source: IP:Port

  • Destination: IP:Port

  • Payload: Data bytes

  • Flags: SYN, ACK, FIN, etc. (TCP)

  • Length: Packet size

Transaction Analysis

Timing Analysis

Measure bus performance:

  1. Select transactions

  2. View timing column

  3. Identify slow transactions

  4. Check for delays between transactions

Common Issues:

  • Clock Stretching: Slave not ready (I2C)

  • Timeouts: No response from device

  • Slow Responses: Device processing delay

Error Detection

Transaction errors highlighted:

  • NACK (I2C): Device didn't acknowledge

  • Timeout: No response within expected time

  • Framing Error (UART): Invalid start/stop bits

  • Parity Error (UART): Checksum mismatch

  • Connection Lost (Socket): Network disconnection

Error Indicators:

  • Red text or background

  • Error icon in status column

  • Details in error column

Pattern Recognition

Identify communication patterns:

  1. Watch for repeated transactions

  2. Identify command-response pairs

  3. Recognize polling intervals

  4. Detect protocol violations

Examples:

  • Sensor read every 100ms

  • Configuration write followed by readback verify

  • Heartbeat messages

  • Burst transfers

Sending Custom Commands

I2C Commands

Send I2C transaction via channel:

  1. Use Channel List to find I2C channel

  2. Configure transaction parameters:

    • Address: Device I2C address

    • Data to write

    • Read length (if reading)

Via AccordionShell:

Bash
# I2C write
AccordionShell i2c --channel "I2C_BUS_0" --address 0x3C --data "01 02 03"

# I2C read
AccordionShell i2c --channel "I2C_BUS_0" --address 0x3C --read --length 4

# I2C write-read
AccordionShell i2c --channel "I2C_BUS_0" --address 0x3C --write "10" --read --length 2

SPI Commands

Send SPI transaction:

Available via AccordionShell or custom modules.

Example:

Bash
# SPI transfer (write and simultaneously read)
# Typically requires custom module or channel implementation

UART Commands

Send UART data:

  1. Find UART TX channel

  2. Set value to string or byte array

  3. Data transmitted on UART

Or use byte stream channel:

Bash
AccordionShell stream --channel "UART_TX_STREAM" --file "data.bin"

Socket Commands

Send network data:

  1. Find socket channel

  2. Write data to send

  3. Monitor response in transaction log

Transaction History

Save Transaction Log

Export transactions:

  1. Right-click transaction grid

  2. Select "Export to Excel" or "Export to CSV"

  3. Choose filename

  4. All visible transactions exported

Use Cases:

  • Archive for later analysis

  • Share with team

  • Import into analysis tools

  • Documentation

Clear Transaction Log

Remove old transactions:

  1. Click "Clear History" button

  2. Or right-click grid → "Clear All"

  3. Confirms before clearing

  4. New transactions continue to appear

Transaction History Limit

Configure retention:

  1. Ribbon → Chart → Lookback Points (applies to transactions too)

  2. Enter number of transactions to keep

  3. Default: 1000 transactions

  4. Increase for longer sessions, decrease for performance

Real-Time Monitoring

Live View

Monitor bus activity in real-time:

  1. Ensure auto-scroll enabled

  2. Watch transactions as they occur

  3. Filter to focus on relevant transactions

  4. Pause scrolling to examine specific transaction

Performance Impact

Considerations:

  • High Traffic: May impact GUI responsiveness

  • Filtering: Reduces displayed transactions, improves performance

  • Disable When Not Needed: Turn off transaction monitoring if not required

Trigger on Event

Alert on specific transaction:

Not directly supported in GUI. Use external monitoring or custom code to watch transaction log and trigger alerts.

Advanced Features

Transaction Grouping

Group related transactions:

  1. Drag "Channel" column to group area

  2. Transactions organize by bus/channel

  3. Expand/collapse groups

  4. Easier to track multiple buses

Transaction Timing Diagram

Visual representation:

Some transaction types may support timing diagram view:

  • Shows signal levels over time

  • Indicates clock and data

  • Highlights start/stop conditions

Protocol Decoding

Higher-level interpretation:

For some protocols, raw bytes decoded to meaning:

  • PMBus: Register names and values

  • SMBus: Commands and parameters

  • Custom Protocols: If decoder loaded

Common Workflows

Debug I2C Communication 

1. Navigate to Transactions
2. Filter: I2C
3. Enable auto-scroll
4. Trigger I2C operation from Channels
5. Watch for transaction
6. Check for ACK/NACK
7. Verify data bytes

Verify SPI Flash Write 

1. Filter: SPI, Chip Select = Flash
2. Clear transaction log
3. Perform write operation
4. Verify write command (e.g., 0x02)
5. Verify address bytes
6. Verify data bytes
7. Check for correct CS timing

Monitor UART Console 

1. Filter: UART, Channel = DEBUG_UART
2. Filter Direction: RX (receive)
3. Watch console output
4. Look for error messages
5. Export log for analysis

Analyze Network Protocol 

1. Filter: Socket, Port = 1234
2. Group by Direction
3. Identify command packets (TX)
4. Identify response packets (RX)
5. Verify protocol sequence
6. Check timing between packets

Troubleshooting

Transaction Log Empty

Problem: No transactions appear

Solutions:

  1. Verify connection to device

  2. Check that bus activity is occurring

  3. Ensure transaction monitoring enabled

  4. Check filter settings (may be hiding all)

  5. Verify module with bus support loaded

Too Many Transactions

Problem: Log fills quickly, hard to find relevant data

Solutions:

  1. Use filtering to show only needed bus

  2. Filter by address/channel

  3. Reduce transaction history limit

  4. Export and clear periodically

  5. Disable monitoring when not debugging

Missing Transaction Details

Problem: Transaction shows but details incomplete

Solutions:

  1. Expand transaction for full details

  2. Check if protocol decoder available

  3. Verify hardware captured full transaction

  4. Review logs for errors

Performance Degradation

Problem: Application slow with transactions enabled

Solutions:

  1. Reduce transaction history limit

  2. Increase polling interval on Channels page

  3. Filter to show fewer transactions

  4. Clear transaction log

  5. Close transaction view when not needed

Tips and Best Practices

  1. Filter Aggressively: Show only what you need

  2. Clear Regularly: Don't let log grow indefinitely

  3. Export Before Clearing: Save important sessions

  4. Use Auto-Scroll Wisely: Disable when analyzing past transactions

  5. Group by Channel: Easier to track multiple buses

  6. Watch for Errors: Red highlighted transactions indicate issues

  7. Correlate with Channels: Trigger from channel, watch in transactions

  8. Time Sync: Use timestamp to correlate with external events