Saleae Support
HomeDownloadUser ForumContact Us
  • Saleae Support
  • Orders & Shipping
    • Place an Online Order
    • Place a Purchase Order (PO)
    • Get a Quote
    • Check your Order Status
    • Distributors
    • Pricing and Availability
    • Discounts
    • Tax & VAT Exemption
    • Saleae Business Information
    • Shipping Policy
    • Receiving Invoices
    • Sales FAQ
      • What Is Included with the Product?
      • What Accessories Should I Purchase with My Device?
      • Is the Saleae Software Sold Separately?
      • Does Saleae Have a Trade-In or Upgrade Plan?
      • How Can I Find the Current Status of My Order?
      • Part Numbers, ECCN, HS Codes, and Country of Origin
      • Discontinued Products
      • International Customs and Duty Information
      • Does Saleae Offer Demo Units or Units on Loan?
      • When Is My Card Charged?
      • Unable to Ship to PO Box Error
      • Referred a Friend? Email Us!
      • Does Saleae Provide Drop-Shipping Service?
  • Getting Started
    • Setup
    • Configure
    • Record
    • Navigate
    • Measure
    • Trigger
    • Protocols
  • User Guide
    • Product Summary
    • Safety & Warranty
    • Supported Voltages
    • Device Calibration
    • Using Logic
      • Navigating the Software
      • Connecting the Logic Analyzer
      • Logic Accessories
      • Device Settings
      • Capture Modes
      • Navigating Your Data
      • Time Bar Settings
      • Measurements, Timing Markers & Notes
      • Capture & Preset File Management
      • Exporting Data
      • Delete Part of your Capture
      • Analyzers
      • Data Table & Terminal View
      • Color Themes
      • Demo Mode
      • Software Glitch Filter
      • Keyboard Shortcuts
      • Automatic Updates
      • Message Us Directly
  • Software
    • Supported Operating Systems
    • Download
    • Installation
    • Firmware Updates
    • Driver Install
    • Legacy Software
      • Logic 1.x Download (Deprecated)
      • Logic 1.x Installation (Deprecated)
      • Logic 1.x Changelog (Deprecated)
      • Logic 1.x User Guide (Deprecated)
  • Protocol Analyzers
    • Supported Protocols
    • Analyzer User Guides
      • Async Serial Analyzer - User Guide
        • Decode UART
        • Decode RS-232, RS-485, & RS-422
      • SPI Analyzer - User Guide
      • I2C Analyzer - User Guide
      • CAN Analyzer - User Guide
      • Simple Parallel Analyzer - User Guide
      • I2S / PCM Analyzer - User Guide
      • DMX-512 Analyzer - User Guide
      • SMBus Analyzer - User Guide
      • Decode Differential and High Voltage Data
  • Software Extensions
    • Extension Installation
    • Create and Use Extensions
    • High-Level Analyzer (HLA) Extensions
      • Shared High Level Analyzers (HLAs)
    • Measurement Extensions
      • Analog Measurement Extensions
      • Digital Measurement Extensions
    • Extension File Format
    • About Third-Party Extensions
    • Disabling Marketplace Extensions
    • Publish an Extension
    • HLA - Analyzer Frame Format
      • Async Serial - Frame Format
      • I2C - Frame Format
      • SPI - Frame Format
      • CAN - Frame Format
      • Manchester - Frame Format
      • 1-Wire - Frame Format
      • Async RGB LED - Frame Format
      • Simple Parallel - Frame Format
      • LIN - Frame Format
      • I2S - Frame Format
    • API Documentation
  • Automation & Analyzer SDK
    • Automation API - Logic 2
    • Automation API - Legacy Logic 1.x
    • Protocol Analyzer SDK
      • FrameV2 / HLA Support - Analyzer SDK
      • Rename a Custom Analyzer
    • More Information on our SDKs
      • Can I Access Raw Data in Real Time?
      • Migrate Code to the New Analyzer SDK
      • Sharing Custom Low-Level Analyzer (LLA) Code
      • VB.NET Support for Automation
  • Datasheets & Specifications
    • Datasheets
    • Logic Hardware Revisions
    • Logic Dimensions
    • Compliance Documents
  • Troubleshooting
    • Installation Errors
    • The Software Fails to Launch
    • The Software Crashes
    • Logic is Not Detected
    • Getting your Machine ID
    • Getting your Software Crash Logs
    • Getting the Console Output
    • Location of Your Config File
    • Error Message: ReadTimeout
    • The Captured Data Looks Incorrect
    • The Captured Data is Corrupted
    • A Protocol Analyzer Produces Unexpected Results
    • The 'Waiting for Trigger' Window Never Closes
    • Device USB VID and PID Information
    • Error Message: Out of Memory Exception Was Thrown
    • PC Performance Issues with Logic
    • Data Export Is Not Working
    • Error Message: A device was found, but the software was unable to access it
    • Trouble Downloading the Latest Software
    • Logic Does Not Connect over USB 3.0
    • Why Am I Seeing Spikes in the Digital Capture?
    • Logic Interferes with My Circuit Operation
    • The Add Analyzer Menu Is Not Displaying
    • Other Drivers Interfere with Logic's Operation
    • The Maximum Sample Rate is Not Selectable
    • The Digital and Analog Recording on the Same Channel Appear Different
    • Advanced USB Debugging for USB 3.0 Users with Linux Kernels 3.3 and Older
    • Saving or Loading Anything Crashes the Software
    • Error Message: The application was unable to start correctly (0xc0000005)
    • Memory Usage with Triggered Captures
    • The Cabinet File disk1.cab has an Invalid Digital Signature (Logic 1.x)
    • Software Crashes with Virtual Desktops
    • Pre-Trigger Buffer is Incomplete
    • Linux Shared Memory Crash
    • Missing Files: api-ms-win-crt-runtime-l1-1-0.dll or msvcp140.dll
    • Known Issues on OS X
    • A Measurement Appears Incorrect
    • All Known Issues
    • USB 3.0 Cable Customer Notice (2017)
    • Warning Message: Logic Pro is running as a USB 2.0 device
    • Software Issues with Encryption Products
    • Linux Permission Requirements for Logic Software
    • My Rise Time and Fall Time Measurements Seem Incorrect
    • The Analog Waveform Loads Very Slowly after Capture Is Complete
    • Input Channels are Missing
    • Exported MATLAB File Does Not Open
    • Saleae Logic LED Blinks Red
    • Crashes Caused by macOS Mojave (10.14)
    • Troubleshooting Signal Crosstalk
    • Error Message: DeviceSetupFailure
    • Error Message: Unable to detect WebGL and Other GPU Issues
    • Warning Message: Unsupported Version
    • Error Function: Device2::SetupDevice
    • Warning Message: Possible USB Host Controller Problem Detected
    • Error Message: StartCommandError
    • Logic 2 Error Messages
    • PC Detection Test
    • CentOS Compatibility Issues
    • Error Message: Failed to Load Extension
    • CSV Export is Slow
    • Set an Analyzer Starting Point in your Capture
    • Logic 2 is Consuming Disk Space
    • Connection Conflicts with USB Debuggers
    • PC Restart Causes Logic to Disconnect
    • HLA Fails to Display Special Characters
    • Data Table Shows Incorrect Values
    • Error Message: Failed to Load Custom Analyzer
    • Error Message: Capture Stopped
    • Error Loading Marketplace Extensions
    • Error: Capture stopped because backlog data exceeded 90%
    • This Analyzer's Native Export is Not Supported in Logic 2
    • Mouse Scrolling Issues
    • Error: A device was found, but it was removed before initialization completed
    • Error: An unknown error occurred during device connection
    • Visual Studio Error: Failed to Launch Debug Adapter
    • VS Code Fails to Launch Python Automation API Script
    • Analog Waveforms Do Not Appear on Linux
    • Reinstall USB Host Controller Drivers
  • FAQ
    • Technical FAQ
      • System Requirements for Saleae Products
      • What Is the Normal Behavior of the LED?
      • What Is the Difference between Logic/Logic16 (Gen1) and Logic 8/Pro 8/Pro 16 (Gen2)?
      • Recommended USB 3.0 Host Controller Cards
      • Device Settings Configuration Tips
      • What Is the Worst Case Channel to Channel Skew?
      • What is Asynchronous Sampling?
      • Which Saleae Products Can Decode 4-Bit Parallel LCD Communications?
      • How Can I Compare Two Clock Signals for Synchronization and Drift?
      • Converting I2S/PCM Captures into Audio
      • My Capture Shows an Uneven Duty Cycle
      • Can I Create or Edit .logicdata Files?
      • Can Saleae Logic Run on ARM / Apple Processors?
      • What Annotations Are Supported?
      • Time & Memory Saving Tools
      • How Can I Record Power Consumption?
      • Moving Logic to Its Own Host Controller
      • How Long Does It Take to Save a File?
      • XMonad on Linux Causes Issues
      • What Is the Maximum Bandwidth of Logic?
      • How Long Can I Record Data?
      • Can I Export Protocol Results Between Timing Markers?
      • Can I Generate an Analog Graph from Digital Data?
      • Time Measurement Error
      • Can These Products Replace an Oscilloscope?
      • Can I Use Multiple Logics on a Single PC?
      • Native Windowing Features Are Not Working Such as Snap or Gestures
      • Opening .logicdata Capture Files
      • How to Choose the Right Logic Analyzer for You
      • Saleae Open Source Support
      • How to Trigger the End of a Capture Instead of the Start
      • Using the Hardware with USB Extension Cables, Through Virtual Machines, or Ethernet Extenders
      • Are the Ground Pins Required for Each Input Used?
      • Can Saleae Products Output Data?
      • Resolution of the Analog Inputs
      • What Sampling Rate Should I Use?
      • Can I Share Data Captures with Others?
      • Binary Export Format (Digital) - Logic 1.x
      • MATLAB Data Export Format - Legacy Logic 1.x
      • Recording Multiple Protocols at the Same Time
      • Changing the Display Radix (Base)
      • Which Logic Analyzer Should I Get?
      • How to View and Debug Firmware Variables, State, and Function Calls
      • Using Saleae Logic Devices with Third-Party Pattern Generators
      • Can Logic Operate with a Full-Speed USB Isolator?
      • Which Saleae Devices Support Analog Recording?
      • How to Manage Protocol Analyzers when Using the Socket API
      • How to Export Serial Protocol Results to a Raw Binary File
      • How to Trigger On a Pulse with No Maximum Time Limit - Logic 1.x
      • Finding Your USB 3.0 Host Controller Information
      • Logic Reports Different USB Current Requirements
      • Is It Possible to Adjust the Logic Thresholds for the Digital Inputs?
      • Why Does Channel 0 Use a Black Wire?
      • Software Shows Multiple Logic Analyzers Attached
      • Are the Input Channels Isolated from Each Other?
      • Are There Feature Differences in the Software when Different Logic Analyzers Are Used?
      • Packet Level Decoding Support in the Analyzer SDK
      • What Higher-Level Protocol Analysis Features Are Available?
      • Support for USB 3.0 and USB 3.1
      • How Can I Compare Signals from Different Captures?
      • Do the Saleae Logic Analyzers Support Trigger Out?
      • Why is the Length of my Capture Incorrect?
      • The Options Button is Missing
      • Can I Change the Voltage Range of the Analog Inputs?
      • How Does the ASCII Radix Display Characters?
      • Do I Have a USB 3.0 Port?
      • What Is the Best Way to Compare Similar Sequences of Protocol Data?
      • Which Version of the Software Should I Use?
      • Import Custom Low Level Analyzer
      • OSX Analyzer SDK Xcode Setup
      • Can Custom Analyzers Process Analog Channels?
      • Automating Long Overnight Captures
      • What Options Are There to Export Multiple Protocol Analyzer Results into the Same File?
      • Do the Saleae Devices Support AC Coupling?
      • Suggestions for Capturing Multiple Instances of a Triggered Event Automatically
      • How Many Protocol Analyzers Can Be Used at Once?
      • Is It Possible to Run the Saleae Software on a PC without SSE2 Instructions?
      • Is It Possible to Import Data into the Logic Software?
      • How Do I Convert Exported CSV Analog Data in Voltages?
      • Is There Cross-Platform Support for the SaleaeSocketApi C# Project
      • Why Does Logic Get Warm?
      • Binary Export Format (Analog) - Logic 1.x
      • Electrical Isolation Suggestions
      • FCC and CE Testing Recommendations
      • 'Save Capture' and 'Export Data' is Disabled in the Software
      • File Format Description for Exporting Protocol Analyzer Results
      • Is There a Newer Version of the Software Available?
      • Is There a Way to Change the Window Resolution?
      • How Can I Extract Recorded Data Using Socket API?
      • Does the Software Support Windows 10 Tablets or Windows RT Tablets?
      • Standalone Software Information
      • Does the Saleae Software Support the Original Logic and Logic 16?
      • Timing Markers Disappear When I Start a New Capture
      • What Sample Rate Settings Are Available? Can I Sample at a Slower Rate?
      • How Do I Differentiate Data in the Export File when Duplicate Analyzers Are Used?
      • Running Multiple Versions of the Software
      • Test Clip Differences - Gen 1 & Gen 2
      • USB-C Cable Recommendations
      • Is My Capture Data Private?
      • Ethernet Connectivity Suggestions
      • Binary Export Format - Logic 2
      • Viewing I2C Addresses as 8-bit
      • Can I use Python Packages in my Custom Extension?
      • Are the Inputs Synchronously Sampled or Sweep Sampled?
      • Is Logic Affected by the Log4j Exploit?
      • Connecting Remotely with SSH
      • Is Silent Installation Supported?
      • Is the .sal File Format Documented?
      • Export Data via Socket API
      • Running Logic in a CI Environment on Windows with the SYSTEM Account
    • General FAQ
      • How Do I Get More Help on an Issue That's Outside the Scope of Saleae Support?
      • How to Identify Each Saleae Device
      • License for the Saleae Logic Software, SDKs, and APIs
      • How Do You Pronounce Saleae?
      • How to Create Project Content for Saleae
  • Returns & Warranty
    • Submit a Warranty Claim
  • Community
    • Ideas & Feedback
    • User Forum
    • Community Projects
    • Community Created Accessories
    • Community Shared Analyzers
  • Tutorials
    • Oscilloscope Tutorial
    • Logic Analyzer Tutorial
    • Learning Portal
      • Digital Protocols
        • Learn Asynchronous Serial
        • Learn I2C - Inter-Integrated Circuit
        • Learn SPI - Serial Peripheral Interface
        • Learn CAN – Controller Area Network
        • Digital MultipleX (DMX512)
        • Manchester
        • 1-Wire
        • Learn I2S / PCM
        • Management Data Input/Output (MDIO)
        • BiSS C
        • HDMI Consumer Electronics Control (CEC)
        • PS/2 Keyboard/Mouse
        • Universal Serial Bus (USB) 2.0
        • Single-Wire Interface (SWI)
        • Simple Parallel
        • Local Interconnect Network (LIN)
        • Joint Test Action Group (JTAG)
      • Common Acronyms and Definitions
      • What is a Glitch?
      • What is RAM? Why Does Logic Use it?
      • What is a Display Radix?
      • What is Data Bandwidth? Can I Reduce this in Logic?
    • Example Projects
      • STM32 Nucleo Board - Digital Signals
      • STM32 Nucleo Board - Analog Signals
      • STM32 Nucleo Board - Analyzing UART
      • STM32 Nucleo Board - Analyzing SPI
      • STM32 Nucleo Board - Analyzing I2C
Powered by GitBook
On this page
  • Overview
  • High Level Analyzer Files
  • HighLevelAnalyzer.py Breakdown
  • HLA Debugging Tips
  • Example - Writing an HLA to search for a value
  • Example Data
  • Remove Unneeded Code
  • Understanding the Input Frames
  • Updating `decode()` to search for "H" or "l"
  • Replace the hardcoded search with a setting
  • What's Next?
Edit on GitHub
Export as PDF
  1. Software Extensions

High-Level Analyzer (HLA) Extensions

Learn how to modify your new High Level Analyzer

PreviousCreate and Use ExtensionsNextShared High Level Analyzers (HLAs)

Last updated 1 month ago

This guide assumes that you have familiarity with the programming language. It is what will be used to customize our HLA. Browse for own use or inspiration.

Overview

This guide assumes a new High-Level Analyzer. In this guide you will learn about:

  1. The files included in the HLA template extension and what they are.

  2. The different parts of HighLevelAnalyzer.py.

  3. How to process input analyzer frames and output new analyzer frames.

High Level Analyzer Files

In your new High Level Analyzer (HLA) extension folder you will find 3 files:

  • README.md

    • Documentation for your extension, shown within Logic 2 when you select an extension, and what users will see if you put your extension on the Marketplace.

  • extension.json

    • Every extension must have this file in its root directory.

    • Contains metadata about the extension, and the HLAs and Measurement scripts that are included with the extension.

    • See for more information.

  • HighLevelAnalyzer.py

    • Python source code for your HLA.

For the purposes of this document, we will be focusing on HighLevelAnalyzer.py

HighLevelAnalyzer.py Breakdown

Let's break down the contents of HighLevelAnalyzer.py .

HighLevelAnalyzer.py
from saleae.analyzers import HighLevelAnalyzer, AnalyzerFrame, StringSetting, NumberSetting, ChoicesSetting

class MyHla(HighLevelAnalyzer):

    # Settings:
    my_string_setting = StringSetting()
    my_number_setting = NumberSetting(min_value=0, max_value=100)
    my_choices_setting = ChoicesSetting(['A', 'B'])

    # Output formats
    result_types = {
        'mytype': {
            'format': 'Output type: {{type}}, Input type: {{data.input_type}}'
        }
    }

    # Initialization
    def __init__(self):
        print("Settings:", self.my_string_setting,
              self.my_number_setting, self.my_choices_setting)

    # Data Processing
    def decode(self, frame: AnalyzerFrame):
        return AnalyzerFrame('mytype', frame.start_time, frame.end_time, {
            'input_type': frame.type
        })

Imports

from saleae.analyzers import HighLevelAnalyzer, AnalyzerFrame, StringSetting, NumberSetting, ChoicesSetting

Declaration and Settings

class MyHla(HighLevelAnalyzer):
    my_string_setting = StringSetting(label='My String')
    my_number_setting = NumberSetting(label='My Number', min_value=0, max_value=100)
    my_choices_setting = ChoicesSetting(label='My Choice', ['A', 'B'])

This declares our new HLA class, which extends from HighLevelAnalyzer, and 3 settings options that will be shown within the Logic 2 UI. Note: if the name of the class MyHla() is used it must be referenced in the accompanying json file. Note that Hla() is the default value.

Output formats

    result_types = {
        'mytype': {
            'format': 'Output type: {{type}}, Input type: {{data.input_type}}'
        }
    }

This specifies how we want output AnalyzerFrames to be displayed within the Logic 2 UI. We will come back to this later.

Initialization

    def __init__(self):
        print("Settings:", self.my_string_setting,
              self.my_number_setting, self.my_choices_setting)

This is called when your HLA is first created, before processing begins. The values for the settings options declared at the top of this class will be available as instance variables here. In this case, the settings values will be printed out and visible within the Logic 2 terminal view.

Data Processing

    def decode(self, frame: AnalyzerFrame):
        return AnalyzerFrame('mytype', frame.start_time, frame.end_time, {
            'input_type': frame.type
        })

This is where the bulk of the work will be done. This function is called every time the input to this HLA produces a new frame. It is also where we can return and output new frames, to be displayed within the Logic 2 UI. In this case we are outputting a new frame of type 'mytype', which spans the same period of time as the input frame, and has 1 data value 'input_type' that contains the value of the type of the input frame.

HLA Debugging Tips

Although we don't have the ability to attach debuggers to Python extensions at the moment, here are some suggestions to help debug your HLA.

  • Use print() statements to print debug messages to our in-app terminal. More information on our in-app terminal can be found below.

  • Use the Wall Clock Format and Timing Markers to locate the exact frame listed in your error message.

  • Use the reload source button in the app to quickly re-run your HLA after editing your source code.

Example - Writing an HLA to search for a value

Now that we've gone over the different parts of an HLA, we will be updating our example HLA to search for a value from an Async Serial analyzer.

Example Data

In the Extensions Quickstart you should have downloaded and opened a capture of i2c data. For this quickstart we will be using a capture of Async Serial data that repeats the message "Hello Saleae".

Remove Unneeded Code

To start, let's remove most of the code from the example HLA, and replace the settings with a single search_for setting, which we will be using later.

from saleae.analyzers import HighLevelAnalyzer, AnalyzerFrame, StringSetting

class MyHla(HighLevelAnalyzer):
    search_for = StringSetting()
    result_types = {
        'mytype': {
            'format': 'Output type: {{type}}, Input type: {{data.input_type}}'
        }
    }

    def __init__(self):
        pass

    def decode(self, frame: AnalyzerFrame):
        return AnalyzerFrame('mytype', frame.start_time, frame.end_time, {
            'input_type': frame.type
        })

If you open the example data from above and add this analyzer, selecting the Async Serial analyzer as input, you should see the following when zooming in:

Our HLA (top) is outputting a frame for every frame from the input analyzer (bottom), and displaying their types.

Understanding the Input Frames

The Async Serial output is simple - it only outputs one frame type, data, with 3 fields: data , error, and address. The serial data we are looking at will not be configured to produce frames with the address field, so we can ignore that.

To recap, the decode(frame) function in our HLA will be called once for each frame from the Async Serial analyzer, where:

  • frame.type will always be data

  • frame.data['data'] will be a `bytes` object with the data for that frame

  • frame.data['error'] will be set if there was an error

Updating `decode()` to search for "H" or "l"

Now that we we understand the input data, let's update our HLA to search for the character "H".

    def decode(self, frame: AnalyzerFrame):
        # The `data` field only contains one byte
        try:
            ch = frame.data['data'].decode('ascii')
        except:
            # Not an ASCII character
            return

        # If ch is 'H' or 'l', output a frame
        if ch in 'Hl':
            return AnalyzerFrame('mytype', frame.start_time, frame.end_time, {
                'input_type': frame.type
            })

After applying the changes, you can open the menu for your HLA and select Reload Source Files to reload your HLA:

You should now only see HLA frames where the Async Serial frame is an H or l:

Replace the hardcoded search with a setting

Now that we can search for characters, it would be much more flexible to allow the user to choose the characters to search for - this is where our search_for setting that we added earlier comes in.

class MyHla(HighLevelAnalyzer):
    search_for = StringSetting()

Instead of using the hardcoded 'Hl', let's replace that with the value of search_for:

In decode()
# If the character matches the one we are searching for, output a new frame
if ch in self.search_for:
    return AnalyzerFrame('mytype', frame.start_time, frame.end_time, {
        'input_type': frame.type
    })

Now if you can specify the characters to search for in your HLA settings:

Updating the display string

To update the display string shown in the analyzer bubbles, the format string in result_types variable will need to be updated. 'mytype' will also be updated to 'match' to better represent that the frame represents a matched character.

result_types = {
    'match': {
        'format': 'Found: {{data.char}}'
    }
}

And in decode(): we need to update the data in AnalyzerFrame to include 'char', and update the frame 'type' to 'match'.

# If the character matches the one we are searching for, output a new frame
if ch in self.search_for:
    return AnalyzerFrame('match', frame.start_time, frame.end_time, {
        'char': ch
    })

After reloading your HLA you should see the new display strings:

Using time

AnalyzerFrames include a start_time and end_time. These get passed as the second and third parameter of AnalyzerFrame, and can be used to control the time span of a frame. Let's use it to fill in the gaps between the matching frames.

Let's add a __init__() to initialize the 2 time variables we will use to track the span of time that doesn't have a match:

def __init__(self):
    self.no_match_start_time = None
    self.no_match_end_time = None

And update decode() to track these variables:

# If the character matches the one we are searching for, output a new frame
if ch in self.search_for:
    frames = []

    # If we had a region of no matches, output a frame for it
    if self.no_match_start_time is not None and self.no_match_end_time is not None:
        frames.append(AnalyzerFrame(
            'nomatch', self.no_match_start_time, self.no_match_end_time, {}))

        # Reset match start/end variables
        self.no_match_start_time = None
        self.no_match_end_time = None

    frames.append(AnalyzerFrame('match', frame.start_time, frame.end_time, {
        'char': ch
    }))

    return frames
else:
    # This frame doesn't match, so let's track when it began, and when it might end
    if self.no_match_start_time is None:
        self.no_match_start_time = frame.start_time
    self.no_match_end_time = frame.end_time

And lastly, add an entry in result_types for our new AnalyzerFrame type 'nomatch':

    result_types = {
        'match': {
            'format': 'Match: {{data.char}}'
        },
        'nomatch': {
            'format': 'No Match'
        }
    }

The final output after reloading:

What's Next?

  • Browse the Saleae Marketplace in Logic 2 for more ideas and examples of extensions you can create.

All HLAs must subclass , and additionally output . The Setting classes are included so we can specify settings options within the Logic 2 UI.

The goal is to search for a message within the input analyzer, but first we need to understand what frames the input analyzer (Async Serial in this case) produces so we can know what frames will be passed into the decode(frame: ) function.

The frame formats are documented under , where we can find .

Find out about other analyzers and the AnalyzerFrames they output in the documentation.

Use the as a reference.

to the Saleae Marketplace!

Python
user shared HLAs
you have generated
Extension File Format
Data Table & Terminal View
Time Bar Settings
Measurements, Timing Markers & Notes
Analyzer Frame Types
Async Serial
Analyzer Frame Types
API Documentation
Publish your extension
10KB
hla-quickstart.zip
archive
Async Serial Example Data
"Reload Extension" button
Click Edit to show the settings
Set the "Search For" setting
Now only the values 'S' and 'H' have frames
That's a lot more descriptive!
HighLevelAnalyzer
AnalyzerFrames
AnalyzerFrame