Sparklet is an embedded graphics library designed to facilitate the creation and management of graphical user interfaces (GUIs) for embedded systems. This library equips developers with a suite of capabilities to implement advanced graphics in resource-constrained environments, making it ideal for various embedded applications.
Sparklet holds significance in the field of embedded graphics libraries due to several key factors:
Efficiency in Embedded Systems: Sparklet excels in providing a lightweight and efficient solution for creating graphical user interfaces (GUIs) on devices with limited resources. This efficiency allows embedded developers to implement sophisticated visuals without compromising performance.
Versatility: The library supports a wide range of display types and configurations, allowing it to be used in various embedded applications, from consumer electronics to industrial control systems.
Scalability: As embedded systems evolve, Sparklet continues to evolve with them. It scales from basic graphical functionalities in its earlier versions to advanced features in its latest series, catering to the growing demands of modern embedded applications.
Developer-Friendly Features: With intuitive APIs and comprehensive documentation, Sparklet simplifies the development process for embedded designers. Its robust feature set and functionalities facilitate the creation of visually engaging and responsive user interfaces, making development more efficient.
To facilitate the design and deployment of GUIs, Sparklet is integrated with the Flint UI Designer-IDE. This integrated development environment (IDE) streamlines the process of creating and implementing GUI designs through a simplified workflow.
Sparklet was first introduced in June 2012 with the intention to provide advanced graphics features to even the most resource constrained device. A brief overview of the revisions is given below.
Releases 1.x
The early versions provided basic features essential for embedding graphical interfaces in small-scale devices. The focus was on delivering a lightweight and efficient library that could run on limited hardware resources without compromising performance. Initially, support was available for platforms such as Renesas RX62N, Freescale Kinetis K70, and STM32.
Releases 2.x
Over time, Sparklet evolved, and the 2nd series of versions were developed. This series introduced standard properties that enhanced the library’s functionality and usability. The improvements included better support for different display types, more robust drawing capabilities, and enhanced performance optimizations. Additionally, ports to Linux on Direct FB and Microblaze were introduced during this phase.
Releases 3.x
Currently, the 3rd series of versions is active, with version 3.3.4 being the latest release as of June 2024. This series incorporates advanced properties including 2.5D and 3D rendering, further expanding the capabilities of Sparklet. It also includes support for OpenGL-based backends, leveraging the computational power of modern GPUs on Linux-based systems. Key features of the 3rd series include enhanced graphics rendering techniques, improved user interface components, and greater customization options. These advancements make Sparklet suitable for more complex and visually demanding embedded applications. Supported platforms now include NXP iMXRT, IMX8, IMX6, RH850, RA6M3, RA8D1, among others.
For more details on the current Sparklet versions, visit the Release Versions section.
Current Status and Future Prospects
Embien Technologies is actively developing Sparklet to introduce more advanced features and keep up with the evolving needs of embedded systems developers. Key areas of current development include expanding the widget library to enrich user interface options and functionality, streamlining the development process with templates, enhancing the user experience through visual effects, and optimizing resource usage to ensure efficient performance on embedded hardware.
Sparklet’s ongoing development and enhancements reflect its commitment to providing a robust and versatile graphics library that meets the demands of modern embedded applications. The future roadmap for Sparklet includes further optimizations, additional functionalities, and support for emerging display technologies, ensuring it remains a vital tool for developers in the embedded systems industry.
Sparklet is available in four editions: Basic, Essential, Standard, and Premium.
Basic Edition
The Basic Edition of Sparklet is designed to offer the essential features required for creating functional and visually appealing GUIs for embedded systems. It includes the core components necessary for building basic graphical interfaces, making it an excellent starting point for projects that need a simple, yet effective design. Despite being the entry-level edition, the Basic version provides sufficient features to achieve a better design without overwhelming resource-constrained devices.
Essential Edition
The Essential Edition builds upon the Basic version by incorporating additional functionalities that cater to more complex design requirements. This edition is suitable for projects that need more advanced features without requiring the full suite of capabilities offered by the higher-tier editions. It strikes a balance between simplicity and functionality, providing developers with enhanced features to create more sophisticated user interfaces while still maintaining efficiency.
Standard Edition
The Standard Edition of Sparklet offers a comprehensive set of features that significantly expand the capabilities available in the Basic and Essential editions. This edition includes advanced design features and functionalities that allow for the creation of highly interactive and dynamic GUIs. The Standard Edition is ideal for developers working on projects that require a robust and feature-rich graphical interface, suitable for a wide range of applications in various industries.
Premium Edition
The Premium Edition is the most feature-rich version of Sparklet, designed for projects that demand the highest level of functionality and performance. It includes all the features available in the Basic, Essential, and Standard editions, along with exclusive advanced capabilities. The Premium Edition is perfect for high-end applications that need the most sophisticated and powerful graphical interfaces, providing developers with unparalleled flexibility and control over their design process.
For more details on the Sparklet variants, visit the Sparklet Editions section.
Sparklet is seamlessly integrated into user applications through a well-defined architecture that ensures efficiency and flexibility. The high-level architecture of the Sparklet library is as follows:
Sparklet API: Interfaces with the Sparklet Library, offering a set of functions and methods for developers to utilize Sparklet’s capabilities in their applications. Of many APIs present, only 6 to 10 of them need to be used for most use cases.
Widgets: A variety of customizable UI elements that can be used to create rich and interactive user interfaces. These widgets are managed and rendered by the Sparklet API.
Device Independent Interface: Abstracts the specifics of the underlying hardware, allowing Sparklet to function across different platforms without modification. This layer ensures that the same code can run on various devices without any impact on the higher-level layer.
Hardware Abstraction Layer (HAL): Provides the necessary low-level functions to interact with the specific hardware components. The HAL bridges the gap between the device-independent interface and the actual hardware, ensuring efficient operation and compatibility. Wherever possible, Sparklet leverages the hardware capabilities on the platform such a GPUs, hardware compositors, Blit Engines etc. Further. Sparklet is designed to run seamlessly on any platform including with OS, with RTOS and on bater metal.
This architecture ensures that Sparklet can be easily ported on to any target hardware and integrated into user applications, providing robust and efficient graphical user interfaces for a wide range of embedded systems.
Sparklet’s broad platform support ensures that developers can create advanced, high-performance graphical user interfaces across a wide range of microcontroller and processor families, catering to various industries and applications.
Renesas RH850
The Renesas RH850 series is a family of 32-bit microcontrollers designed for automotive applications, offering high performance, reliability, and extensive peripheral sets. Sparklet supports the RH850 platform, enabling developers to create sophisticated graphical user interfaces (GUIs) for automotive systems, such as instrument clusters, infotainment systems, and advanced driver-assistance systems (ADAS). The RH850’s robust architecture ensures that Sparklet can deliver smooth and responsive graphics even in demanding automotive environments.
Renesas RA6M3
The Renesas RA6M3 series is part of the RA family of 32-bit Arm Cortex-M microcontrollers, designed for high-performance and low-power applications in industrial and IoT markets. Sparklet’s support for the RA6M3 platform allows developers to leverage its powerful processing capabilities and rich set of peripherals to create advanced GUI applications. Whether it’s for industrial automation, home appliances, or wearable devices, Sparklet on RA6M3 ensures efficient and visually appealing interfaces with low power consumption.
Renesas RA8D1
The Renesas RA8D1 microcontroller series is known for its high performance and robust feature set, making it suitable for a wide range of applications including industrial automation, IoT devices, and automotive applications.
Sparklet is optimized to leverage the capabilities of the Renesas RA8D1 platform, ensuring efficient operation and seamless integration of graphical user interfaces (GUIs). It utilizes the device’s resources effectively, including its processing power and memory, to deliver responsive and visually appealing UIs.
ST Micro STM32
STM32 is a popular family of 32-bit microcontrollers from STMicroelectronics, based on the Arm Cortex-M cores. Known for their versatility and extensive peripheral integration, STM32 microcontrollers are widely used in various applications, including consumer electronics, industrial control, and medical devices. Sparklet’s compatibility with STM32 allows developers to take full advantage of these microcontrollers’ capabilities to create high-quality, responsive GUIs. The wide range of STM32 series, from the entry-level to high-performance lines, ensures that Sparklet can be used in diverse projects with different requirements.
NXP i.MX 8/i.MX6
The NXP i.MX 8 and i.MX 6 series are widely used in applications requiring multimedia processing, automotive infotainment, industrial control, and more. These processors are known for their versatility and performance.
Sparklet supports both the i.MX 8 and i.MX 6 platforms, harnessing their multimedia capabilities and processing prowess to create sophisticated GUIs. It optimizes graphical rendering and utilizes hardware acceleration features available on these platforms to deliver smooth animations, high-definition graphics, and responsive user interfaces.
NXP i.MX RT
The NXP i.MX RT series, known as crossover processors, combine the high performance of application processors with the real-time capabilities of microcontrollers. This unique combination makes them suitable for a wide range of applications, from industrial control to consumer electronics. Sparklet’s compatibility with the i.MX RT platform allows developers to create responsive and high-quality GUIs that can handle complex tasks while maintaining real-time performance. The i.MX RT series’ integration of advanced security features and connectivity options further enhances the development of secure and connected GUI applications.
By leveraging Sparklet on these supported platforms, developers can achieve a seamless integration of advanced graphics into their embedded systems, ensuring superior user experience and efficient performance.
Sparklet’s rendering capabilities span from efficient 2D rendering, through visually enhanced 2.5D, to fully immersive 3D rendering. These capabilities allow developers to choose the appropriate rendering technique based on the application’s requirements and the performance characteristics of the target embedded system. Whether creating simple, functional interfaces or rich, interactive graphical environments, Sparklet provides the tools needed to achieve compelling visual experiences.
2D Rendering in Sparklet
2D rendering in Sparklet focuses on creating flat, two-dimensional images and interfaces. This mode of rendering is commonly used for simple and straightforward graphical elements such as buttons, icons, and text. Here are the key aspects of 2D rendering in Sparklet:
Efficiency: 2D rendering is highly efficient, requiring less computational power and memory, making it ideal for resource-constrained embedded systems.
Basic Elements: Supports basic shapes like lines, rectangles, circles, and polygons, as well as bitmap images and text rendering.
Transforms: Basic transformations such as translation, rotation, and scaling can be applied to 2D objects.
Antialiasing: Implements antialiasing techniques to smooth the edges of rendered shapes, improving visual quality.
2D rendering is suitable for applications where simplicity, speed, and low resource consumption are paramount, such as in industrial control panels, basic consumer electronics interfaces, and simple medical devices.
2.5D Rendering in Sparklet
2.5D rendering, also known as pseudo-3D or two-and-a-half-dimensional rendering, combines 2D and 3D techniques to create an illusion of depth and perspective without the full computational complexity of true 3D rendering.
Depth Effects: Adds depth and perspective to 2D objects, giving a more immersive and realistic appearance.
Transformation: Transformation involves manipulating objects in 2.5D space through operations like rotation, translation (movement), scaling (resizing), and skewing (distortion).
In 2.5D rendering, the concept of frustum refers to the simulated viewing volume that determines what is visible on the screen. This viewing volume, similar to its 3D counterpart, helps manage depth cues and perspective projection, ensuring objects appear correctly relative to the viewer’s simulated perspective.
2.5D rendering is ideal for applications that require more visual depth than 2D can offer but do not need the full complexity of 3D. This includes advanced automotive infotainment systems, mid-range consumer electronics, and interactive kiosks.
3D Rendering in Sparklet
3D rendering in Sparklet involves creating three-dimensional graphical representations that provide a realistic view with depth, lighting, and shading. Here are the key aspects of 3D rendering in Sparklet:
True 3D Objects: Supports the creation and manipulation of true 3D objects, including complex shapes and models.
Textures and Materials: Supports the application of textures and materials to 3D objects, adding detail and realism to surfaces.
Camera Views: Allows manipulation of camera angles and perspectives to view 3D scenes from different viewpoints.
Performance Optimization: Includes optimization techniques like level of detail (LOD) management, culling, and efficient memory usage to ensure smooth performance on embedded systems.
3D rendering is suitable for high-end applications that demand detailed and immersive graphics, such as advanced medical imaging systems, high-end automotive interfaces, and sophisticated gaming and entertainment devices.
The table below offers a summary of the supported widgets. For detailed instructions on using each widget and customizing its appearance to meet user design preferences, refer to the Widget Library section.
Debug Support
Description
FixedView
The FixedView is a container widget that enables users to position multiple
child widgets at fixed locations.
Labels
The Labels widget is an input element designed to hold alphanumeric data,
allowing users to enter textual information.
Imageholder
The Imageholder widget is used to place images, primarily for displaying
static or dynamic visual content to the user.
Button
The Button widget is used to trigger actions. Flint supports three types of
buttons: push button, toggle button, and radio button.
Push Button: Performs an action when clicked by the user.
Toggle Button: Functions as a switch, allowing users to toggle between two
states, typically “on” and “off.”
Radio Button: Allows the user to select one option from a set.
ProgressBar
The ProgressBar widget visually represents the progress of a task or
operation. Flint supports both horizontal and vertical progress bar styles.
Slider
The Slider widget enables users to select a value from a defined range by
moving a knob. It consists of a seek bar and a knob (a control that the user
can drag). Flint supports both vertical and horizontal sliders.
Dial
The Dial widget is a circular input control used to indicate the current
value of a metric within a specified range using a pointer or needle.
Circular
Progressbar
The circular progress bar widget is used to show progress of a task in a
circular fashion.
Rotary Knob
The Rotary Knob widget allows users to select a value from a defined range
by moving the knob in a circular motion.
ListView
The ListView is a container widget that arranges its child widgets
sequentially, either horizontally or vertically, based on the selected type.
ScrollView
The ScrollView widget creates scrollable views, commonly using ListView as
its scrolling widget. ScrollView accepts only one child and contains three
internal widgets: two scrollbars and a viewport. The scrollbar controls the
content scrolling within the viewing area, while the viewport defines the
visible area to the user.
CarouselView
The CarouselView widget presents a collection of views in a scrolling
manner, either horizontally or vertically. Users can navigate through the
views by swiping or clicking, similar to a carousel of images or content.
Clock
An analog clock widget that is fully customizable, featuring hands to
indicate hours, minutes, and seconds.
Dialog
The Dialog widget displays information, prompts user input, or presents
messages in a pop-up window. Flint supports three types of dialogs: Modal,
Non-Modal, and Auto Hide.
