Lime Suite is a collection of software supporting several hardware platforms including the LimeSDR, drivers for the LMS7002M transceiver RFIC, and other tools for developing with LMS7-based hardware. This post will cover the components of Lime Suite, how it supports LimeSDR, how it fits with the SDR application ecosystem, and how users can use Lime Suite to create custom applications and new devices based around the LMS7 transceiver.
LMS7002M drivers
Lime Suite offers several driver options for interfacing directly with the LMS7002M RFIC. These drivers act as a bridge between low level SPI bus transactions and high level calls such as tuning, gain controls, and data interface config. Lime Suite uses the LMS7 driver internally to support the bundled hardware and to provide even higher-level device-agnostic interfaces. Further, LMS7 drivers have published C or C++ APIs for developers to create designs based around the LMS7002M RFIC.
LMS7002M C++ driver
Included with the suite is a C++ API for the LMS7 RFIC. This driver provides high level API calls for most settings such as gain, filters, and tuning. It also provides several API utilities for self-calibration, and caching and retrieving calibration results from a SQLite database. An installation of LimeSuite provides all of the development headers and libraries needed to create projects based around this API.
LMS7002M C driver
Also, included with the suite is an embeddable C driver for the LMS7. The code base is small enough and written entirely in C to make it easy to include into projects or compile for embedded architectures. The driver features the usual high level calls for gain, filters, and tuning; but does not include full self-calibration or database caching.
Bundled board support
Several hardware support modules come bundled along with the Lime Suite. This includes support for the new LimeSDR, the STREAM board with EVB7 evaluation hardware, the Novena with LMS7 daughter-card and more. Lime Suite is capable of supporting many different hardware designs through a single connection registry and connection interface. This allows the suite to provide driver, debugging, gui, and application support regardless of the underlying hardware.
The connection interface
The connection interface is a C++ class that abstracts away hardware specific details such as underlying calls to the USB stack. Board-specific implementations create their own custom overloads of the IConnection class, providing the implementations for low level control routines such as SPI bus transactions and register writes; and optional streaming implementations for transmit and receive. The connection interface API is flexible enough to handle multiple LMS7 RFICs, multiple streams, and advanced time and burst controls for streams.
The connection registry
The connection registry is a C++ class that handles enumeration of available devices, and instantiation of each device as an IConnection interface. Using the connection registry, board-specific support modules basically instruct Lime Suite how to locate and instantiate handles to their hardware. The registry supports a variety of ways to identify hardware including serials, indexes, interface types, and device node names.
Supporting custom hardware
Any custom hardware development can be supported within the suite using the discussed connection APIs. As far Lime Suite is concerned, there is no difference between bundled hardware support, and custom developments — as long as the board is in the connection registry, it will be supported by the suite software. Developers can build and install custom support modules compiled against the Lime Suite environment without changing or making any additions to the suite software itself.
Lime Suite graphical utility
Lime Suite also provides a graphical interface for selecting available devices, debugging the LMS7, live spectrum plotting, and updating firmware and FPGA images for various devices. Debugging the LMS7 graphically can be extremely useful. Developers can upload and download the LMS7’s entire configuration as a “.ini” file, and graphically interact with LMS7 using buttons, sliders, and drop-down menus. And the built-in FFT plotter can provide a live view of the spectrum all-the-while, for any board that has implemented the streaming hooks.
SDR application interfaces
Lime Suite offers users many options when it comes to interfacing with supported hardware such as LimeSDR. Users will have low and high-level API access, and integration with a variety of APIs and software applications in the SDR ecosystem through Soapy SDR. Using the connection registry mentioned above, any registered device can be instantiated, configured, and streamed with in C++. In addition, Lime Suite provides C bindings with the development library for C only applications.
Soapy SDR support
The suite comes with a support module called SoapyLMS7 that ties the Lime Suite connection and drivers API in with the SoapySDR library. SoapySDR acts like a bridge between drivers, APIs and SDR applications. It provides APIs in several languages (C, C++, python), remote access to use transparently over a local network, and bindings for multiple SDR programming environments, and graphical SDR applications. Such applications include GQRX, Pothos, CubicSDR, and GNU Radio.
Fitting it all together
LimeSuite is the glue that binds Lime RFIC based hardware designs with the SDR application ecosystem. Hardware developers can create hardware with the aide of debugging tools and driver APIs. Users can interact with LimeSDR and other devices in existing SDR applications. And application developers can create software in a variety of APIs and programming environments.
