Overview - Canvas Software Suite

  1. Introduction
    1. Canvas Firmware
    2. Canvas Tools
    3. Canvas Samples
    4. Canvas Documentation
  2. Concepts
    1. Wireless Product Evaluation
    2. Reference Designs
    3. Embrace Application Scripting
    4. Automated Testing
    5. Firmware Update - OTA and UART
    6. Standard Platform Features
  3. Supported Hardware
  4. Software Architecture
  5. Scripting
  6. Native C Applications
  7. Hosted Mode
  8. Canvas Software Suite Website
BL54L10BL54L15BL54L15μCanvas Software SuiteSera NX040

Introduction

Canvas Software Suite comprises embedded firmware, desktop/mobile tools and sample applications designed to accelerate integration of Ezurio wireless components into your IoT products and solutions. This document provides an overview of the concepts behind Canvas Software Suite, how it is designed to accelerate software development and ultimately how you can quickly build your proof-of-concept and streamline taking it to production.

Canvas Software Suite is a software platform enabling rapid, portable development across the Ezurio microcontroller-based wireless product portfolio.

Canvas Firmware

Canvas Firmware is provided for supported products as a firmware image file that can be programmed onto a DVK board or module typically using an SWD programming adapter. Some modules (e.g., Sera NX040) ship pre-programmed with Canvas Firmware installed. The Canvas firmware is optimized for operation with each module’s DVK board and provides the baseline functionality to support product evaluation and software development workflows. This firmware forms the basis for your own products, customized for your use case through application scripts written in Python.

Key features of Canvas Firmware

  • On-device scripting engine. Develop embedded applications in the Python scripting language

  • Flash filesystem storage for scripts, configuration files and application-specific content

  • Bootloader and management protocol over UART/BLE for firmware, script and file system updates

  • UART interface for scripting console (REPL)

  • Middleware provides consistent APIs across products, abstracting RTOS and chipset details

  • Standardized peripheral pinouts to speed hardware integration and firmware compatibility

  • Support for both hosted (w/external MCU) and host-less (standalone) modes of operation

Canvas Tools

Canvas Tools guide your way starting out with sample applications on supported DVK boards for evaluation and leading you toward custom application development on the hardware for your use case.

Xbit VS Code Extension

The Xbit VS Code extension gives you everything you need to interact with your DVK running Canvas firmware. Start developing application scripts in Python leveraging the benefits of the ubiquitous VS Code editor working directly with the hardware to develop and test your application scripts.

Xbit Desktop

The Xbit Desktop application provides Applets (“mini applications”) designed to highlight common use cases with Ezurio products. Whether updating a device’s firmware wirelessly over Bluetooth or presenting a 3D visualization of data from nearby wireless devices, Xbit Desktop delivers guided user interfaces for interacting with Canvas-enabled wireless products.

Xbit Mobile

Like Xbit Desktop, the Xbit Mobile application provides Applets designed to highlight common use cases with Ezurio products. Many of the same Applets you’ll find on Xbit Desktop are available right from your phone or tablet making it easier to demonstrate product functionality when away from your workstation.

Canvas Samples

Sample scripts are provided to get you started quickly with common use cases for Canvas-enabled wireless products. From basic Bluetooth operations to UWB ranging and peripheral I/O, start with our sample application scripts and customize them or just use them as a reference for your own creations. Our library of samples will continue to evolve as more products and features are released so stay tuned!

Canvas Documentation

We understand time is a valuable resource when evaluating a wireless connectivity solution. Our Software User Guides and App Notes focus on getting you up and running as quickly as possible when you need some help getting started. Detailed technical documents such as datasheets and API reference guides are there when you are ready to take a deeper dive. Visit the Canvas Software Suite page for the latest updates.

Concepts

Canvas Software Suite aims to provide embedded software developers a streamlined experience when evaluating and designing with Ezurio wireless radio modules. Whether evaluating modules using a DVK board or testing functionality on your own PCB assembly, Canvas Software Suite provides the tools to ease the burden of adding wireless connectivity to your products. This section outlines some key design concepts behind Canvas Software Suite and why we think you’ll enjoy working with it in your next design.

Wireless Product Evaluation

We’ve designed our tools and firmware to offer a streamlined evaluation and prototyping experience when used with supported DVKs. Get started in minutes with our off-the-shelf sample applications demonstrating key functionality of each wireless radio module. When ready, go one step further by creating your own script-based applications tailored to your use case. Canvas Software Suite provides consistent APIs across the product portfolio promoting code re-use and improving maintenance costs for your application.

Evaluation and designing in wireless radio modules has never been this straight-forward.

Reference Designs

Canvas Software Suite supports several hardware reference designs, providing an easy on-ramp for you to quickly experience the wireless performance of our modules in a real-world use case. DVKs offer designers insight into hardware design details like power supply options, antenna placement and debug interfaces.

Embrace Application Scripting

Whenever possible, the Canvas Software Suite enables developers to leverage scripting languages to design application-specific functionality. Whether it is controlling an embedded BLE radio to broadcast advertisement data in a specific way, providing a 3D visualization of wireless data on a desktop workstation or building a mobile application to support configuring and firmware update of a wireless device; we empower developers to use scripting to develop and customize these features.

We are introducing Python scripting on our script-capable embedded products, accelerating customization of radio module applications to your needs and reducing the time it takes to evaluate performance.

Similarly, we’ve embraced JavaScript/TypeScript and frameworks like VS Code, Electron and .NET MAUI Blazor to maximize re-use of our desktop and mobile tools across various platforms. We heavily leverage Python on the workstation/desktop side for automated testing and device configuration scripts.

Automated Testing

On-module scripting support takes automation to new heights. On-device automated testing can use the same scripting languages you currently use on your workstation and VMs. Familiar with Python scripting to automate your unit and integration tests? Now you can develop test scripts to perform firmware operations directly on the hardware! Coordinate your workstation and device test scripts via the device REPL and speed up test cycles significantly compared to having to design and maintain embedded test code in C.

Firmware Update - OTA and UART

Bluetooth Low Energy capable products w/Canvas Firmware provide the SMP GATT service for standardized over-the-air firmware update support. Building your application on Canvas Firmware means you always have support for over-the-air firmware updates. Canvas APIs provide access to query firmware version, product ID and other system info for easy integration into your firmware update system. SMP over UART is also available for applications where cabled firmware updates are preferred.

Standard Platform Features

Canvas Software Suite defines a set of minimum hardware requirements to support standard platform features aiming for a consistent developer experience across the product portfolio. Beyond standard platform features, additional features such as scripting capability and advanced software stacks may optionally available depending on the capabilities of the underlying hardware. The set of features available on each hardware platform are identified on the Canvas firmware page for each hardware platform.

Supported Hardware

Common product hardware supporting base platform features of Canvas Firmware include:

  • MCU: ARM Cortex-M family

  • RAM: 256KB (RTOS, thread stacks, radio stack, scripting heap)

  • Bootloader: 40KB ROM

  • Filesystem: 96KB ROM (application scripts, configuration, data logging)

  • Canvas Firmware: 460KB ROM (RTOS, SDK libraries, radio stack, middleware, scripting engine)

  • Scripting Console: 1 x UART (e.g., REPL interface to Python)

  • RTOS Shell (OPTIONAL): 1 x UART (e.g., Zephyr shell)

  • Peripheral Bus: GPIO, I2C, SPI

Wireless interfaces supported by Canvas Firmware include:

  • Bluetooth: Bluetooth 5.x radio stack (depends on hardware capabilities)

  • UWB: UWB firmware w/UCI command support (depends on hardware capabilities)

Software Architecture

The Canvas Firmware architecture can be thought of as a stacked layers designed to abstract low-level chipset-specific hardware details from upper layers providing common APIs to the scripting engine and application scripts through a platform middleware layer.

By developing your application scripts on top of this stack, your applications are inherently shielded from differences in chipset SDKs, RTOS selection and complicated radio stack interfaces that can slow down development. By defining easy to use script-based APIs to access most common embedded firmware functionality, applications remain portable and easier to design, develop, understand and maintain.

Scripting

For hardware with enough resources, Canvas Firmware includes a scripting engine to speed development of embedded firmware applications. Features include access to the flash filesystem, RTOS support with scripts running in their own thread/context, scripting console support (if supported by the language) and focused operating modes for hosted and host-less operation within a larger product design. Python scripting is currently supported by several products providing easy-to-use APIs to underlying RTOS and radio features without needing to setup complex C-based development tools and build environments.

Native C Applications

For applications where scripting does not meet the performance requirements or more advanced access to the underlying hardware is needed, C-based development is an option. Our platform middleware can be leveraged to keep your C code portable and speed time to market. If you’d rather interface directly with the hardware yourself, you have the option to work directly with vendor provided SDKs and development tools.

Hosted Mode

Need to use a Canvas-enabled radio module with your own host microcontroller? We’ve got you covered with easy-to-use AT command interfaces. On some products, you can even extend the AT command set functionality yourself by modifying the Python scripts implementing the AT command interface.

We also provide simple portable C source code for use on any host microcontroller that can support a UART interface with APIs required to operate the module.

Canvas Software Suite Website

For more information, check out the Canvas Software Suite site for links to other documents pertaining to developing solutions with Canvas-enabled wireless modules and IoT products.