ESF Signal Base™ is an OS and platform independent data structure, algorithm and digital signal processing library. The library helps engineers to design, integrate and test custom system architectures for a wide range of resource constrained applications requiring computationally efficient (e.g. fixed-point/floating-point/block floating-point arithmetic) and/or algorithmically sophisticated signal processing.

ESF Signal Base provides a highly productive framework to quickly create reliable, deterministic real-time digital signal processing instrumentation for measurement and system control, management, and data acquisition applications.

ESF Signal Base enables rapid design of statistical classifiers including biomedical signal detection and classification systems, target recognition systems, and anomaly detection in machines.

Rapidly implement customized, computationally efficient DSP filter solutions such as;
• real-time Fast Fourier Transform (FFT) signal analysis
• finite impulse response (FIR) filter banks
• Infinite Impulse Response filter (IIR) filter banks
• Polynomial Filters ("Sharpening")
• Huffman Coding
• Multi Channel Filter Bank Implementations
• Morphological Filters

Signal Processing Framework Overview

Signal processing components include a sophisticated template library that uses state-of-the-art generic programming techniques for both extreme flexibility and efficiency. Its features include:
• MATLAB like high-level abstractions for matrix/vector based algorithms,e.g. C = A+B, where A,B,C are matrices.
• "Streaming mode" signal processing to support concatenation of multi-channel filters and internal management of circular buffering issues.
• Algorithms coded independent of policies, such as allocation strategy or whether arithmetic is fixed-point or floating-point.
• Compile-time insertion of policies, so there are no virtual functions slowing down computation.
• Support for resource constrained embedded systems.
• Complete algorithm configuration flexibility - number of samples to process per iteration, number of signal channels, etc.
• Common style interface for easy learning.
• Components have handcrafted size and performance efficiency and can be configured for almost any application context. The typical abstraction layers illustrated in Figure 3 motivate component organization and modularization.

Typical Signal Processing Software Layers of Abstraction

Starting from the bottom, general datatypes and algorithms support the creation of any type of software. Basic mathematical datatypes and algorithms, e.g. for matrix/vector arithmetic, are more particularly used to build signal basic processing components, such as filters, windows, Fast-Fourier Transforms (FFT's), etc. Advanced signal processing components such as adaptive filters and learning algorithms, are built from lower-level components. Rule, event, and alarm components that interpret the results of signal processing algorithms are at the highest level. This layer generally hides the detailed algorithmic means of processing.

Simple Filter Design/Simulation Example

This is an example project to design and simulate a multi-channel digital filter. The complete source code and build files for the project can be found in the directory,
…/projects/EminentMicro/examples/filterSimple

This diagram illustrates the toolset components that support rapid implementation and testing of the design. Main.m is the highest-level project specific simulation script. It is a signal source for the filter application represented by main.cpp. FilterExtern.m pipes signal data to/from the simulation script and the application.

ESF Signal Base contains many C++ classes that have hybrid architectures of base classes and template classes providing the benefits of inheritance (small code size) as well as the benefits of templates (fast code). It complements other libraries, such as the C++ Standard Template Library (STL), but distinguishes itself by supporting the needs of embedded applications (reentrancy, no C lib dependencies, no code bloat, advanced buffer management, etc.). For code compactness, reliability, and efficiency, all ESF modules use these data structures.

ESF Signal Base Features

• Small footprint
• No external library dependencies
• No heap based allocation
• Containers – linked lists, hash tables, AVL trees, etc.
• Memory – alignment, circular buffers, block allocators, etc.
• Event/Callback management
• CRC encoding/decoding
• ROMable and reentrant
• CPU and OS independent
• Fast speed and reliability
• Over 8 years of design wins
• Royalty-free