11 Functional Blocks

Functional blocks are the core building elements of impulse, enabling flexible data acquisition, processing, visualization, and analysis. Each functional block type serves a specific role in the workflow, and impulse’s architecture allows users to extend, configure, and combine these blocks to suit their unique requirements.

Types of Functional Blocks

Impulse provides several types of functional blocks, each designed for a particular aspect of the signal analysis workflow:

• Serializers: Read and write external content, supporting import/export in various formats.
• Signal Processors: Create new signals from existing ones, perform mathematical operations, extract patterns, and decode protocols.
• Diagrams: Visualize signals in different forms, such as time-domain or frequency-domain charts.
• Producers: Generate new data elements (signals or records) from existing content using rules and algorithms.
• Adaptors: Interface with external systems, hardware, or data sources for seamless data acquisition.
• Search Engines: Locate samples or patterns within signals efficiently.
• Formatters: Convert signal values into human-readable text for logs, tables, or reports.

These blocks can be extended and configured to match the needs of any workflow, making impulse highly adaptable for a wide range of engineering and analysis tasks.

Functional Block Integration

Impulse supports multiple integration patterns for functional blocks, allowing users and developers to choose the most suitable approach for their needs. The main integration types are:

Singleton

A singleton functional block is a unique, specific implementation provided by impulse. These blocks are typically built-in and serve a dedicated purpose, such as a VCD reader for handling Value Change Dump files. Singletons are not intended to be duplicated or customized by users, but rather offer a ready-to-use solution for common tasks.

Use case: When a standard, well-defined implementation is required (e.g., reading a specific file format).

Conversion to Java: Many singleton implementations support conversion to a Java-based block. This feature allows users to create a new Java functional block initialized with the same implementation as the singleton. Users can then fix issues or enhance the functionality as needed, providing a path for customization and extension.

Multiton

Multiton integration allows users to create and manage multiple specific versions of a functional block. For example, a "Pattern Log Reader" can be instantiated several times, each with its own configuration (such as different regular expressions for parsing various log formats). Each instance appears as a distinct block (e.g., "MyPatternLogReader") and can be selected and configured independently.

Use case: When users need to define and reuse multiple customized variants of a block for different data sources or workflows.

Java

The Java integration type enables developers to implement a functional block as a single Java class directly within the impulse environment. This approach allows for rapid development, testing, and debugging of new blocks without the need for a separate development environment or build process. Java-based blocks can be used for advanced customization or prototyping.

Use case: When custom logic or advanced processing is needed, and the user wants to implement and debug the block within impulse itself.

Repository Integration: The UI supports pulling Java block implementations from a shared repository and pushing user enhancements or proposals back to the provider. This collaborative workflow enables users to contribute improvements and share customizations with the broader community or the original provider.

Customizing Functional Blocks

Each functional block in impulse can be customized to fit specific user requirements. Customization is performed using the Preferences dialog, which provides a dedicated interface for each block type. This dialog allows users to adjust a specific set of properties relevant to the selected block, ensuring that the configuration is both comprehensive and context-sensitive.

• Preferences Dialog: Every functional block has its own customization dialog or property set, accessible through the Preferences interface. This dialog presents all available options for the block, enabling users to fine-tune its behavior and integration.
• User Configurations: Most functional blocks support user-defined configurations. These configurations allow users to override the default settings with their own preferences. When selecting a functional block, users can also choose from their saved configurations, ensuring that the block operates according to their specific needs and workflows.

Selecting Functional Blocks

Impulse provides a unified UI for selecting, configuring, and managing functional blocks throughout the application. When loading files, choosing diagrams, or setting up data processing, users interact with this interface to tailor the system to their needs.

The functional block selection UI consists of:

• Text Field: Type the name of the functional block, with suggestions as you type.
• Edit Button: Opens configuration options for the selected block.
• In-Place Dialog: Provides a detailed interface for selection and configuration.

The image above shows the typical UI for customizing and managing functional blocks, including the text field, edit button, and in-place dialog for both the block and its configuration.

If left blank, impulse selects a default block based on context.

Most blocks support configuration, either directly in the UI or via predefined configurations. After selecting a block, you can choose or edit its configuration using a second field in the UI, with similar controls.

In many cases, when no configuration has been selected, the UI supports direct management of properties—either through the Property Tab Folder or a specific UI for the block—allowing users to adjust settings on the fly without needing a saved configuration.

Property Tab Folder

When configuring functional blocks, the Property Tab Folder offers two ways to view and edit properties:

• Property Table Tab: Shows all available properties in a table, with in-place editing and type-specific controls. Useful for advanced or comprehensive configuration.
• UI Fields Tab: Presents only the most important properties in a streamlined, user-friendly layout, with contextual grouping and visual aids. Ideal for quick setup and new users.

The image above illustrates the Property Tab Folder, highlighting the difference between the comprehensive property table and the streamlined UI fields tab.

You can switch between these tabs to balance detailed control and ease of use.

Functional Block Types in Detail

Serializer

A serializer enables reading and writing of external content, supporting import and export in various formats. Serializers are essential for integrating impulse with external tools and workflows. The UI for managing serializers is organized as a tree, allowing users to add or modify serializers and their configurations.

Serializers are used whenever data needs to be imported into or exported from impulse, such as loading waveform, log, or trace files, or including external data via the Includes element in records. The dedicated serializer dialog allows you to adjust properties, and optionally choose or create user configurations for specific needs.

Signal Processor

Signal processors create new signals from existing ones or from scratch. They combine signals, extract patterns, and decode data using protocol parsers. Signal processors are vital for advanced analysis, debugging, and deriving insights. The UI for processors is a hierarchical tree, listing all processors and their configurations.

Signal processors are used in multiple contexts: as part of View Signals (to derive or combine signals for visualization) or in the Deduce section of View Signals (to provide additional context or breakdowns). The dedicated processor dialog allows users to select a processor, configure its properties, and save or reuse configurations. Typical use cases include mathematical transformations, protocol decoding, and extracting statistics or features from raw data.

Diagram

Diagrams provide specialized visual representations for signals, such as time-domain plots, frequency-domain charts, or custom visualizations. Users can customize diagram properties to tailor the visualization to their analysis needs.

Diagrams are selected in the Visualize section of View Signals, determining how the signal data is displayed. The diagram UI allows users to pick a diagram type (e.g., line, bar, logic, chart) and configure its appearance, axes, and overlays. Diagrams support both predefined and user-defined configurations, enabling consistent visual styles or custom layouts for specific analysis tasks. Diagrams are central to making complex data interpretable and actionable.

Producer

Producers generate new data elements (signals or records) from existing content, applying rules and algorithms for automated content creation. The UI for producers is a tree view, showing all producers and their configurations.

Producers are used in record Analysis elements and other automation scenarios, where new signals or records need to be generated based on rules, templates, or algorithms. Producers can automate repetitive data transformations, generate reference signals, or synthesize test data. The producer UI allows users to select, configure, and manage producers, supporting both default and user-defined configurations.

Adaptor

Adaptors connect impulse to external systems, hardware, or data sources, enabling seamless data acquisition and interaction. The UI for adaptors is structured as a tree, presenting all adaptors and their configurations for easy management.

Adaptors are used in record Interface elements to connect to live data sources such as hardware devices, TCP/serial ports, or external libraries. The adaptor UI allows users to select the appropriate adaptor, configure connection parameters, and manage user configurations. Adaptors are essential for integrating impulse into test benches, lab setups, or real-time monitoring environments.

Search Engine

Search engines help locate specific samples, events, or patterns within signals, even in large datasets. The UI for managing searches provides a list of previous searches and allows users to define new ones.

Search engines are used in the search dialog (Ctrl+F) to find samples matching specific criteria within selected signals. Users can select a search engine (e.g., expression search), configure its properties, and optionally use or save configurations for recurring searches. Search engines streamline the process of finding events, anomalies, or patterns in complex datasets, supporting both simple and advanced search scenarios.

Formatter

Formatters convert signal values into text for logs, tables, or reports. The UI for formatters lists all available formatters and their properties, which can be customized for different use cases.

Formatters are used throughout impulse wherever signal values need to be displayed in a human-readable form, such as in sample tables, logs, or reports. The formatter UI allows users to select or configure how values are rendered, supporting custom formats for different data types or domains. Formatters enhance clarity and communication by adapting raw data to the needs of the user or audience.

Impulse’s functional block system provides the flexibility and extensibility needed to address a wide range of engineering challenges, from data acquisition to advanced analysis and visualization.