Zynq ® Ultrascale+™ delivers Deterministic Processing for Mixed Criticality Applications in Industrial, Automotive, and Aviation Markets
Presented by Dr. Giulio Corradi
Today's market requirements are forcing increased computational requirements across all embedded applications through the use of multi-core SoCs, while simultaneously requiring the preservation of legacy real-time code often developed decades ago for single core processors. Often, the performance limitations of real-time processors lead designers to consider and use application processors to achieve desired performance at expense of determinism and worst case execution time (WCET).
This webinar describes how to use the ARM Cortex® A53 application processor cluster in Zynq® Ultrascale+™ to implement real-time asymmetric multiprocessing (RTAMP). This approach results in improving worst case execution time (WCET) and reducing latency by isolating and partitioning the cluster such that software developed for single cores can be reused. Demand for this solution is has skyrocketed in Industrial, Automotive and Avionics applications because software architects strongly prefer to use an application processing cluster like a set of single cores when executing real time code. Shared resources like the level 2 cache and memory controller guarantee performances on average, however worst case execution time is affected by interference amongst cores when accessing shared caches and memories. The combination of programmable logic technology and coloured lockdown concepts for shared cache management in conjunction with the open-source Jailhouse hypervisor make it possible to use Linux and bare-metal isolated applications running independently in the cluster. The overhead introduced by a hypervisor is also reduced, making the overall approach very lean.
Developed in partnership with the world’s leading chip companies over an 18-year period, and now downloaded every 170 seconds, FreeRTOS is a market-leading real-time operating system (RTOS) for microcontrollers and small microprocessors. While FreeRTOS remains an independent, open source project, Amazon Web Services's backing of FreeRTOS, has accelerated FreeRTOS kernel and related libraries development. In this keynote, you will learn about the top 5 FreeRTOS benefits surfaced by time-tested project tenets.
This talk presents an overview of channel estimation theory and techniques for IEEE 802.11 / Wi-Fi systems. It includes a review of the 802.11 preamble formats, estimation of SISO and MIMO channels, and a discussion of how channel estimates are used in demodulation and decoding. It concludes with recent results in semi-blind channel estimation for 802.11.
In 2011 ISO published a new version of C++. The C++11 standard was a major change to the language, not only from syntactical perspective but, more significantly, requiring a new approach to designing and developing with C++.
Over the last decade, we have seen three further revisions of the standard (C++14/17/20), culminating in the release of C++20 in December of last year.
However, many embedded engineers are still wary of C++ and live with the misconception that it is unsuitable for embedded development.
This talk looks at the evolution of C++ and where an embedded engineer may realise significant safety and performance benefits by adopting modern C++.
A Medical Device Primer for Embedded Software Engineers
Presented by Jeff Gable
The medical device space is rapidly evolving and becoming more open to, and accepting of, technologies and practices from other industries. While the pace is slower and the documentation requirements are more extensive than for consumer electronics, the medical device industry is ripe for disruption and presents a great opportunity for embedded developers to bring skills they’ve honed elsewhere.
This talk is an introduction to what embedded developers should understand if they want to work on medical devices. I’ll introduce relevant safety standards and regulatory pathways, explain Design Controls and risk analysis, bust myths about using open source software, and give an insider view to the industry.
When talking about "distortion," we often throw it into one of two buckets: an undesirable quality squashed as low as possible to impress fastidious audio engineers, or a revered sound transmutation that imparts mythical qualities to otherwise drab sounds. How can it be that these are the same animal?
This talk provides practical understanding for audio engineers, enthusiasts, and programmers of the two most fundamental types of audio distortion: harmonic and intermodulation. You'll learn what these distortions are and how they relate to basic math, dispel some common myths, better understand measurements, and gain conceptual tools to push your sound in new directions.
Most of us are here because we enjoy writing code that makes things happen in the real world. Throughout this conference and tech talks during the year, we are presented with lots of options for our embedded systems.
These options are often presented to us as floating gently down a calm river.
Yet, when we come to use these technologies in our serious systems, where we want reliability, unit testing and CI/CD, we feel like we are rapidly tumbling down towards a big waterfall.
How do I get a simple embedded system to work for me?
In this talk, I will discuss my experience getting a simple embedded system (reading a sensor and displaying it to a user) working in X technologies such as:
Simulation: Custom, Renode, Wokwi
Bare Metal / Languages: C, C++, Rust (Ferrocene), Ada, Circuit Python, Arduino, LibHal
RTOS: ThreadX, FreeRTOS, Zephyr, Integrity OS, Riot OS, PX5, uC OS III, eCos, SafeRTOS, Nucleus
Active Noise Cancellation for Headphones and Vehicles
Presented by Nikos Zafeiropoulos
Active Noise Cancellation of broadband noise has now become a standard audio feature for TWS headphones and it is also getting spread in the automotive. In this workshop you will learn how to generate FIR filters using adaptive algorithms with recorded data from a headphone and create a hybrid fixed filtering ANC. We will introduce multichannel ANC for cars and explain the same methodology on how to apply in a vehicle.
The Active Object design pattern is a concurrency pattern that decouples method execution from method invocation to enhance the responsiveness and scalability of an application. This pattern is particularly useful in scenarios where multiple operations need to be performed concurrently without blocking the main thread of execution.
This talk presents modern methods for the Active Object design pattern, also known as Actor objects, in C++ and introduces activecpp (https://github.com/samiralavi/activecpp), a useful single-header templated library to implement this pattern effectively. Key features of the Active Object design pattern, alongside best practices for low-power embedded systems, are discussed, and the activecpp library is showcased for a typical IoT application on an ESP32-S3 SoC-based devkit.
In modern embedded systems development, integrating observability into Continuous Integration (CI) and system testing is crucial for ensuring software reliability and performance.
Moreover, observability can speed up overall product development by faster issue resolution, in particular by reducing the need to reproduce reported issues in a separate debugging environment.
This talk will explore techniques for early detection of system anomalies, including random crashes and latent stability risks.
We will discuss methods for collecting debugging data like call-stack traces, system traces, and logs for effective diagnostics on detected anomalies.
Additionally, strategies for managing data flow from devices to development teams will be covered, emphasizing seamless integration and collaborative workflows.
Attendees will gain insights into implementing proactive observability practices to enhance software quality and accelerate development cycles.
In the world of IoT, energy efficiency is a critical factor that determines the success of a device. With the increasing number of IoT devices, it is important to choose the right generation of mobile communication technology that can support the device's requirements while maximizing energy efficiency.
In this presentation, we will explore the different generations of mobile communication technology and the protocols that are available for IoT devices. We will examine the pros and cons of each technology and highlight the key features that make them suitable for different types of IoT applications.
We will also discuss the optimal way to send messages in an energy-efficient manner, taking into account factors such as data rate, latency, and power consumption. By choosing the right combination of technology and protocol, IoT devices can achieve optimal energy efficiency and reliable communication.
The goal of this presentation is to educate IoT developers and decision-makers on the best practices for choosing the right generation of mobile communication and sending messages in an energy-efficient manner. By doing so, they can ensure that their IoT devices are reliable, cost-effective, and sustainable.
Advanced Debugging and Performance Analysis Techniques for Embedded Applications
Presented by Axel Wolf
Presented by SEGGER Microcontroller
Packed with live demos, this session introduces you to advanced debugging and performance analysis techniques for your embedded system. See how Streaming Instruction Tracing lets you capture what your embedded system really executes, in a non-intrusive way. Learn about measuring the execution time and frequency of functions, blocks, and instructions using Code Profiling, making it easier to discover optimization potential. Discover how Code Coverage lets you measure the execution of code, detect unreachable code, and code not covered by tests, allowing for fast, efficient code improvement. Find out how you can do real-time recording and visualization of your embedded application, revealing its true runtime behavior. Going far deeper than the system insights provided by debuggers, this is especially useful when developing and working with complex embedded systems comprising of multiple threads and interrupts. Once you know about these advanced techniques and the tools behind them, you’ll never want to go back to basic debugging!
Advanced Integrations of Sensors Semantics and Ontology on the Azure IoT Hub
Presented by Olivier Hersent
Advanced Cloud Services Mediation: Each cloud platform requires painful manual mapping of each device payload to the cloud semantics, and coordination of device lifecycle in cloud and NS. By managing the cloud ontology, applications can automatically expose the right graphical format regarding device type. We will do demos to showcase how certified sensors are automatically recognized by Azure IoT hub as an example.
Advanced Serial Communications in an RTOS Environment
Presented by Peifang Zhou
This workshop marks the conclusion of our trilogy on the serial interface, building upon the insights shared in the last two Embedded Online Conferences. In this session, we will explore an advanced Direct Memory Access (DMA) technique that transforms the traditional character-based serial interface into a variable-length, packet-oriented one, similar to Ethernet. This powerful approach opens up new possibilities for reducing the complexity of software required for command handling and file transfers.
We will start by examining the theoretical foundations of this DMA technique, discussing its implementation for managing data packets of varying lengths. Following this, we will demonstrate practical applications through live coding on an STM32 Nucleo board. You will witness firsthand how this transformation simplifies the development of software for command handling and file transfer. By the end of the workshop, you will have a clear understanding of how to apply these concepts to your own projects to enhance the robustness and efficiency of your embedded systems.
Join us for this comprehensive session, where theory meets practice, and elevate your understanding of serial interfaces to the next level.
Machine learning has advanced to the point where it is now feasible
to incorporate it directly into DSP applications. The major advantage
is in the ability for DSP algorithms to "learn" to perform well. In
this talk we will discuss how methods such as nonlinear and
non-Gaussian inference and Bayesian nonparametrics can be exploited to
develop novel DSP algorithms with a much higher level of specificity
and efficiency than classical LTI methods.
There's a famous joke where someone starts to ask a comedian "What's the secret to good comedy?" but before they can finish, the comedian interrupts with "Good timing." The same can be said for digital communications (well, good timing and good carrier recovery).
This talk will cover algorithmically efficient means to estimate (and correct for) timing and carrier (frequency/phase) offsets for various signal types to generate custom waveforms. It will include practical examples with source code for participants to follow along with.
Aggregating Data and Sensor Programming With The Arduino Nano 33BLE Sense Board
Presented by Dr. Don Wilcher
Aggregating data from industrial or environmental systems can require costly data logging or acquisition devices. With micro-miniaturization or MEMs technologies, sensors can be populated on small form factor Printed Circuit Boards (PCBs). Included on these PCBs are System on Chip (SoC) microcontrollers. Combining sensors and SoC microcontrollers, PCBs can provide an approach to aggregating data from industrial and environmental systems.
This online conference talk will present an approach to obtaining data from industrial and environmental systems using an Arduino Nano 33 BLE Sense board, Communication Terminal software, and sensor programming techniques. Topics to be presented for this online talk are listed next.
Arduino Nano 33 BLE Sense Overview
Accessing On-board Sensors
temperature
relative humidity
microphone
gesture
Logging sensor data with Communication Terminal Software
Agile Embedded Software Design With Virtual Hardware
Presented by EMBEDDETECH
The process of designing embedded software is often an iterative process, progressing in lock-step with the custom hardware design. During a time of global pandemic and backlogged supply chains, getting functional hardware prototypes to work productively towards validated embedded software can be a challenge. In this demonstration, you will learn how you can combine virtual hardware with real-world peripherals to create a workflow that maximizes your productivity in embedded software design and validation.
Artificial Intelligence (AI) has been around for a long time in one form or another. In fact, the underlying concept first emerged around the 1850s. However, AI had relatively little impact on the collective consciousness until the launch of ChatGPT on 20 November 2022. That’s only two and a half years before this year’s Embedded Online Conference—but my, how things have changed.
Today, AI is being used to design embedded hardware (from chips to boards) and embedded software. It’s also being used to write documentation and to extract useful information from it. Furthermore, the embedded systems designed with the help of AI are being used to run AI, the AIs are now capable of cloning themselves, and then things start to get complicated. And, just to add a dollop of metaphorical cream on top of the allegorical cake, AI is insinuating itself into our lives in ways most people aren’t even aware of.
In this presentation, we will explore so many aspects of AI that it will make your head spin. As is often the case with sessions like this, we will be leaping from topic to topic with the agility of young mountain goats—so I encourage you to dress appropriately and responsibly.
UPDATE 2024/10/28 We regret to inform you that this session has been postponed due to personal circumstances. We appreciate your understanding and will share any new updates as soon as they become available. Thank you for your patience.
This lecture offers a comprehensive overview of the evolution, principles, and cutting-edge applications of radar technology. We trace radar's development from its early days to modern advancements, emphasizing the integration of digital and statistical signal processing with artificial intelligence (AI). Key topics include the history of radar, modern techniques such as FMCW (Frequency Modulated Continuous Wave) and Pulse Doppler radars, and AI's transformative role in detection, tracking, classification, and decision-making.
We delve into the technical foundations of radar signal processing, explaining concepts like frequency modulation, signal mixing, and range-Doppler processing. The lecture also covers the significant AI applications in radar, such as clutter suppression, target classification, and adaptive waveform optimization. Challenges like the need for large training datasets, model interpretability, and robust AI systems are discussed alongside solutions like data augmentation and generative models.
Through detailed explanations and high-level block diagrams, the lecture aims to provide a solid understanding of radar systems' operational principles and AI's role in enhancing their capabilities. This foundational knowledge prepares participants for deeper exploration of these technologies in subsequent modules.
Phased array radar and sonar are common applications of signal processing. In this talk Chris Bore outlines the application of similar techniques to make a simple acoustic camera that renders a sound scene visually.
An Introduction To High Efficiency And Multi-rate Digital Filters
Presented by John Edwards
There are many ways to implement digital filters and many architectures
that can be chosen to achieve the optimum performance, which is typically
measured in terms of MIPS and memory. This presentation will describe several
optimized filtering techniques and architectures and show how they are used.
Examples will include Comb, Polyphase, Cascaded Integrator Comb (CIC)
and more.
Many experienced embedded programmers still, rightly, have concerns or are sceptical about using C++ in deeply embedded applications. However, many of their misconceptions are based on the original definition of C++ (ISO C++98). In the subsequent 20+ years, C++ has moved on significantly and is no longer _the language you tried to learn and hated_.
Both C and C++ had major revisions in 2011 (C11, C++11) and subsequently C++ has had three further revisions (C++14, C++17, C++20).
This two-hour workshop will introduce, using hands-on programming, what we refer to internally, as "C+(+)". C+(+) is a natural subset of C++ for the embedded programmer. Rather than introducing the full depth and breadth of the language, it focusses on this part most useful.
By 'useful' it focusses on the following:
performance gains
memory safety
type safety
It also readdresses the sticky area of using dynamic memory in an embedded application; banned by many coding standards.
At the end of the workshop don't expect to be a fully-fledged C++ programmer, but more importantly, you will discover the "quick wins" by merely changing your file extension from ".c" to ".cpp".
A Realtime Operating System (RTOS) is a staple of most embedded systems. The Zephyr Project RTOS is relatively young and borrows certain elements and paradigms from Linux that may stump experienced embedded software developers, who are accustomed to a more "traditional" RTOS.
This talk will introduce The Zephyr Project RTOS, demonstrating the similarities and differences between Zephyr and a traditional RTOS. The focus will be on how to use the data structures and paradigms offered by Zephyr to accomplish tasks common to most embedded systems. This talk will also highlight key differences that seasoned embedded software developers will need to keep in mind when incorporating Zephyr into their projects.
The Yocto Project is an open-source framework backed by The Linux Foundation. It enables users to create custom Linux-based distributions for an embedded target.
Some of the key advantages of using Yocto:
Ability to create minimal and lightweight Linux distributions
Leveraging contributions from open-source projects
Maintainability and repeatability for building images
Support for multiple hardware architectures and Quick EMUlator (QEMU)
This talk will help you understand key concepts of Embedded Linux and gain practical experience in building your custom Linux distribution for a BeagleBone Black or Raspberry Pi.
The talk covers a brief overview of Bluetooth MESH networking and data structures. It then introduces an example application and walks through the dataflow and data models from sensor node to Raspberry Pi datastore (HomeAssistant). A walkthrough of the provisioning process is also covered.
This session aims to talk about one popular IoT protocol called LwM2M. The session is an overview that includes key characteristics and technical specification information, discusses how the protocol works, and finally mentions some example applications.
Android's use in the automotive industry has been silently increasing over the past few years. While Android's use in a car inherits quite a few things from classic Embedded Android, there are several automotive-related additions to the Android Open Source Project (AOSP) that are worth a closer look. This session will cover the Car System Service, the internal Car system APIs, the built-in Car Apps, the car-related HIDLs and car-related specific features such as Exterior View System, Vehicle Properties, Audio, Power Management, wear leveling and boot time optimizations.
Architecting for Safe Embedded Systems that Integrate Open Source Components
Presented by Kate Stewart
Products are no longer created from monolithic code bases, they are composed of components that are integrated over time, and maintained by different entities, some of which are open source communities. For a system to be dependable (maintainable, safe, secure, etc.) all the components need to be integrated together and tested as updates occur to demonstrate they still adhere to the necessary requirements. Effective system engineering depends on requirements being tested for the system as a whole and for the individual components. However, open source projects frequently don't have requirements expressed in a form that is consumable for this level of analysis.
This talk will discuss a proposed framework for a "system" bill of materials that will enable those components providing requirements to be integrated so that product lines can be managed, and open source components that are able to surface up their requirements can be integrated.
Arm® Pelion™ Device Management with PSoC® 64 Secure MCUs
Presented by Cypress
In this demo, we will show how you can securely manage IoT devices with Arm's Pelion Device Management Platform using PSoC 64 Secure MCUs from Cypress Semiconductor, an Infineon Technologies company.
Artificial Intelligence for Safety-Critical Systems
Presented by Safak Akinci
Artificial Intelligence (AI) is transforming the landscape of safety-critical systems, from automotive to aerospace, and aviation applications. While AI has the potential to significantly enhance system performance and decision-making, its integration into regulated environments presents unique challenges. In safety-critical systems, where failure can lead to severe consequences, the need for rigorous, well-defined processes is paramount.
This presentation will focus on the role of AI in such systems, emphasizing the importance of transparency, validation, and verification in ensuring reliability, safety, and compliance with regulatory standards. We will explore best practices for designing and deploying AI models that adhere to stringent certification requirements, such as traceability, explainability, and continuous monitoring. Special attention will be given to how these processes can address the inherent uncertainties and complexities of AI, ensuring that safety-critical applications meet the highest standards of performance and regulatory oversight. By implementing structured processes, developers can leverage the power of AI to innovate while maintaining the required safety and integrity.
Asset Monitoring and Supply-Chain Visibility, why has it become essential for organizations?
Presented by Mohib Hassan
In today's era, visibility has become a crucial component. Without having visibility it is nearly impossible to make data driven decisions. As organizations grow the need of monitoring and keeping a track of assets is becoming a paramount requirement. From inventory management to maintenance and eliminating down times, asset monitoring plays a very important role in making any organization successful.
With the growing global political and climate challenges, the market is aggressively inclining to towards end-to-end supply-chain visibility to meet the increasing demands of the consumers.
In this talk, we will learn about how can organizations, benefit from asset tracking/monitoring and supply-chain visibility solutions and what does the future of these technologies look like in the next 5-10 years.
You have a product idea for using IoT technologies! You have an awesome
greenfield development opportunity! Congratulation! You start staring
at that clean sheet, that blank page. There are more unknowns than
knowns! It's getting scary. What should you do?
This talk is the story of starting a greenfield IoT project. You see
there are risks. You are attracted to the familiar tasks. If you defer
risks, saving them until the end, it won't end well. In this story
we'll look at identifying risks and attacking them directly with tracer
bullets, building a walking skeleton of the product. The tracer bullets
give you insight on a solution to your technical problem. The walking
skeleton helps prove your product concept and demonstrate your ability
to deliver it. You'll look at how to make progress with off-the-shelf
hardware and software without becoming overly dependent on any vendor.
Louis Moreau will show you how to create complete automated data pipelines so you can work on your active learning strategies. To create your first data source, we will be using an S3-compatible open-source solution that you can install locally on your laptop and expose publicly. Then, we will see how to set up your labeling strategy. Finally, we will configure the pipeline so it can automatically refresh the data explorer, train your model, create a new version of your project, build a library and notify you when it is ready.
Louis Moreau will show you how to create complete automated data pipelines so you can work on your active learning strategies. To create your first data source, we will be using an S3-compatible open-source solution that you can install locally on your laptop and expose publicly. Then, we will see how to set up your labeling strategy. Finally, we will configure the pipeline so it can automatically refresh the data explorer, train your model, create a new version of your project, build a library and notify you when it is ready.
Automated HIL(Hardware in the Loop) Test Processes
Presented by Komathi Sundaram
This talk will focus on how end-to-end automation of Hardware-in-the-Loop (HIL) test processes accelerates developer feedback, ensures more robust development pipelines, and streamlines release cycles.
AUTOSAR Methodology applied to ECU Diagnostics Architecture and Workflow
Presented by Salvador Almanza
The system complexity of automotive E/E systems keeps growing, reaching an impressive number of 100+ million lines of code in recent years. Most of this complexity is due to the algorithm implementation in each Electronic System Unit (ECU) in the vehicle architecture. Additionally, automobiles must meet multiple standards and government regulations (e.g., Diagnostics and OBD), adding contributing factors not just to complexity but also to the development effort, making it very difficult to meet deadlines, milestones, and time to market. This presentation focuses on the AUTOSAR methodology and the architecture solution to diagnostics modeling and workflow using a top-down approach that helps reduce time and effort during ECU development by abstracting the complexity of the implementation and relieving the ECU integrators of exhausting and complex manual work.
Back to the Future with Embedded Software (and Predictable Timing)
Presented by Henk Muller
Presented by XMOS
In this session, we will explore how we can still learn a thing or two from the past. The very first microprocessors employed a simple model that enabled programmers to reason about the speed of their programs - up to the clock-cycle precision. Taking advantage of this, some early computers generated video and audio streams directly from software. Over time, microprocessors and microcontrollers became faster and more complex, and they lost this property, making it harder for embedded programs to respond in a precise way. At the same time, embedded programs became more complex - and the focus shifted to executing multiple real-time tasks, simultaneously.
Discover how we, at XMOS, have gone back to a computational model that enables the programmer to reason about time, and to write software that you proof once correct, and can re-use in different contexts. We offer a bag of 16 hardware threads that each have predictable timing. Each thread can be programmed in hard-real-time individually, and be composed with other threads without affecting each other’s timing. Offering both vector compute and IO compute, xcores can deal with 10 ns accurate IO timings from software, whilst offering up to a million FFTs per second (256 points) for DSP; all in a 7x7mm QFN.
We will explain how the hardware enables event driven programming - where the compiler and programmer can reason about response times and throughput – which means that interrupts are mostly avoided. For computational code the compiler can verify the timing, so the programmer can guarantee that their DSP is fast enough to keep up with the IO.
Measuring energy consumption during product development is crucial, especially for battery-powered and always-on devices. Until recently, accurate measurement has been expensive, tedious, or error-prone.
Meet Joulescope, the most affordable and easy-to-use precision DC energy analyzer. In this session, Matt Liberty, the creator of Joulescope, demonstrates how to use this exciting, new USB-connected test instrument to measure the current, voltage, power, and energy of a target device. See how Joulescope makes it easy to iterate and improve battery life. Find out why so many engineers say Joulescope is now one of their favorite and most effective tools.
Measuring energy consumption during product development is crucial, especially for battery-powered and always-on devices. Until recently, accurate measurement has been expensive, tedious, or error-prone.
Meet Joulescope, the most affordable and easy-to-use precision DC energy analyzer. In this session, Matt Liberty, the creator of Joulescope, demonstrates how to use this exciting, new USB-connected test instrument to measure the current, voltage, power, and energy of a target device. See how Joulescope makes it easy to iterate and improve battery life. Find out why so many engineers say Joulescope is now one of their favorite and most effective tools.
Battery-less IoT devices - An Introduction to Energy Harvesting for Embedded Systems
Presented by Mustafa Shamsi
With the recent explosion of IoT devices, the number of embedded computing devices deployed in the field have increased exponentially. Majority of these embedded devices are battery powered and considering the current battery lifespan, it would cost thousands of dollars in replacement, time and effort for maintaining these devices. This poses a major challenge in scaling IoT solutions of the future and calls for a solution that is scalable for sustainable growth.
In this lightning talk, I would like to introduce the concept of energy harvesting which enables devices to be powered from ambient sources of energy. This capability helps develop battery-less computing devices reducing the potential maintenance cost of IoT deployments. This talk would focus on introducing the concept of energy harvesting , the major challenges in developing energy harvesting embedded devices and it's impact on IoT devices.
Over the last decade, energy harvesting has seen significant growth as different markets adopt green, sustainable ways to produce electrical energy. Even though costs have fallen, the embedded computing and internet-of-things community have not yet widely adopted energy harvesting-based solutions. This is partly due to a mismatch between power density in energy harvesters and electronic devices which, until recently, required a battery to be functional. This mismatch is especially accentuated in indoor environments, where there is comparably less primary energy available than in outdoor environments. In this talk, I will focus on photovoltaic harvesting, which has little requirements and a high energy density. Furthermore, I will present a design methodology based on source-load decoupling that can optimize energy flow in dynamic environments. To demonstrate its general applicability, I will present studies on the availability of indoor-based energy and a batteryless smartcard designed for efficient operation using only indoor lighting to sense environmental data and emit Bluetooth beacons.
Key Learning Points:
Energy Harvesting Technologies
Maximum Power Point Tracking for Photovoltaic Cells
Cellular networks have to minimize the interference among network users in addition to maximizing their individual data rates. From this perspective, beamforming is the core technology behind the design of the 5G physical layer. In this tutorial, we start from the basic signals and build the fundamental ideas on which physical and virtual beamforming methodologies are based. We will explore how its integration with massive MIMO leads to a simple yet efficient system. No prior DSP knowledge is required to understand the concepts.
Over the last few years there has been a lot of movement in the world of open source silicon and we now have lots of options to design chips and even a few to get them manufactured. Ok While it's unlikely you'll be beating the supply chain anytime soon, in this talk I'll show you how to get started with simple chip design using free and open source tools.
Become A DSP Tuning Master and Build More Efficient Neural Networks
Presented by Alex Elium
Presented by Edge Impulse
Sensor data is typically preprocessed with DSP in TinyML applications. As engineers deploy NNs on ever smaller processors, it is becoming necessary to tune DSP algorithms in order to fit within RAM or real-time processing constraints. But not all steps in a DSP pipeline are created equal! Knowing how to find sections to slim down can mean the difference between giving up a few percent of accuracy, and ending up with a model that’s no longer usable.
This presentation will show experimentation with DSP parameter choices (number of cepstral coefficients, spectrogram frame size, etc) for an example keyword spotting classifier, and analyze the RAM, latency, and accuracy impacts of various scenarios. Attendees will leave with ideas on where to find elusive kB of RAM and mS of latency next time they need to optimize a DSP pipeline.
Many musicians around the world have developed hearing impairment (too loud music, industrial noise, etc.). Hearing aids only help speech perception but badly distort the timbres of musical instruments. Using DSP we can pre-warp sounds so that music playback sounds correct to them, instead of turning oboes into muted jazz trumpet sounds. The secret is understanding human loudness perception and performing spectral multi-channel nonlinear compression to compensate for degraded hearing. I aim to describe how our perception operates and then how to easily perform the nonlinear compression needed to compensate sensioneural hearing impairment.
Development teams are always under pressure to deliver faster and at lower costs, but this is becoming more challenging as system complexity has risen exponentially with features for IoT and Machine Learning. The increased complexity can easily handcuff a development team and lead to not just longer development cycles with higher costs but also lower quality products.
In this session, we will explore best practices for developing real-time embedded systems that will help the modern developer stay on track and produce a quality product within their development cycle. We will explore best practices ranging from how to properly architect a system for scalability, how to manage a development cycle, secure and test a system. We will also discuss best practices for using frameworks and open-source software.
Best Practices for Developing Real-time Embedded Systems
Presented by Jacob Beningo
Development teams are always under pressure to deliver faster and at lower costs, but this is becoming more challenging as system complexity has risen exponentially with features for IoT and Machine Learning. The increased complexity can easily handcuff a development team and lead to not just longer development cycles with higher costs but also lower quality products.
In this session, we will explore best practices for developing real-time embedded systems that will help the modern developer stay on track and produce a quality product within their development cycle. We will explore best practices ranging from how to properly architect a system for scalability, how to manage a development cycle, secure and test a system. We will also discuss best practices for using frameworks and open source software.
Real-time Operating Systems (RTOS) have been finding their way into nearly every embedded system both connected and disconnected. They provide a convenient paradigm for designing flexible and scalable systems, interacting with hardware, scheduling tasks and many other capabilities. The problem though is that RTOS best practices are not well documented and even seasoned developers can run into costly and time-consuming issues that could have been avoided.
In this session, Jacob Beningo will walk attendees through best practices for RTOS application design such as:
Decomposing an application into tasks
How to set task priorities
Analyzing applications data flow
Useful design patterns handling events, interrupts and initializing tasks
Arduino is an incredibly popular way for beginners to be introduced to microcontrollers, but leaving the Arduino ecosystem can be quite scary. This presentation is directed at beginners AND experienced embedded engineers. It focuses on what it feels like to learn new microcontrollers beyond Arduino, and where you can go to find answers when you run out of youtube videos, books, and tutorials.
Beyond Coding: Toward Software Development Expertise
Presented by Marian Petre
Based on decades of research with professional software developers, this talk will summarise some of the perspectives, practices, and social conventions that distinguish expert developers and lead to better software.
Explore Bluetooth® LE Audio with Auracast™ & STMicroelectronics’ STM32WBA MCU solution. Auracast™ enables audio broadcast capabilities to Bluetooth LE devices and opens new use cases such as shared audio experiences and assistive listening.
Bluetooth Low Energy (BLE) is a cornerstone of modern embedded connectivity, enabling low-power communication between devices across countless applications. While Zephyr RTOS offers a powerful BLE stack, many embedded developers struggle to move beyond simple examples to create robust, real-world BLE applications. This workshop aims to bridge that gap.
In this two-hour workshop, we’ll start with a one-hour lecture introducing BLE fundamentals, the Zephyr RTOS BLE architecture, and how to configure and extend BLE functionality within a Zephyr application. You’ll learn the differences between BLE and Bluetooth Classic, explore the BLE stack layers, and understand how Zephyr enables both standard and custom BLE services.
During the hands-on lab session, you’ll configure a Zephyr application to advertise BLE data, integrate standard BLE services such as the Device Information Service, and develop a custom service to notify data, triggered by onboard hardware like a button. You’ll test functionality using the nRF Connect mobile app and gain practical experience in service definition, characteristic creation, and data synchronization techniques.
Key Takeaways:
Understand the fundamentals of BLE and how it differs from Bluetooth Classic
Explore Zephyr’s BLE stack and how to configure it using Kconfig and source code
Learn to integrate standard BLE services like Device Information Service
Develop and test custom BLE services with read and notify characteristics
Use the nRF Connect app to validate BLE functionality in real time
Gain hands-on experience building and testing BLE applications in Zephyr
Join us to gain the skills and confidence to integrate robust BLE capabilities into your Zephyr-based embedded projects!
This workshop uses the Nordic nRF52840 development board. Please purchase one here before attending the workshop if you plan to do the hands-on exercises.
Bluetooth Low Energy: The Swiss-Army Knife of Wireless Technologies
Presented by Mohammad Afaneh
To an outsider, Bluetooth and Bluetooth Low Energy (BLE) technology may seem complex—and rightfully so!
This workshop will break it down and cover all the basics you need to know about Bluetooth Low Energy to help you start your first BLE project. (Already familiar with the technology? No worries—I guarantee there’s something here for you as well!)
Some of the topics we'll cover:
An overview of the current state of Bluetooth Low Energy (BLE)
The basics of the technology and how it works
Different topologies in which BLE can operate
Use cases and applications most suitable for BLE (and the ones that are not!)
Exercises using a Nordic Semiconductor nRF dev kit and a smartphone
The future of Bluetooth technology and where it's going
Bluetooth mesh and Zigbee mesh networks on STM32WB MCUs
Presented by Colin Ramrattan
Presented by STMicroelectronics
In this webinar we will explore the STM32WB features, portfolio, and options available for purchase to help you identify the best solution for your design. We will then dive into the details of Bluetooth Mesh and Zigbee Mesh networks.
At the end of this webinar, you will know how each mesh network is segmented inside the STM32WB MCU. We will also explain how the certified STM32WB5MMG module helps product teams reduce design time and complexity. You will discover the numerous STM32WB development kits offered in the STM32WB series. These include the NUCLEO-WB55RG the NUCLEO-WB15CC, as well as the STM32WB5MM-DK Discovery kit for the STM23WB module, featuring multiple sensors, a digital microphone, QSPI Flash, RGB LEDs and an OLED display to facilitate quick prototyping. We will also show you demos of Bluetooth and Zigbee Mesh networking on the STM32WB discovery kit.
Simulation is a super power: it lets you develop faster, debug harder, collaborate better, and test stronger.
In this session, we'll explore how leveraging virtual hardware platforms like Wokwi can transform the embedded systems and IoT development landscape: speeding up your code-flash-test cycles, running unlimited hardware-in-the-loop tests without actual hardware, breaking free from breakpoint limitations, and sharing your complete hardware and firmware setup with your HAL allies instantly.
Demand to design and develop Interactive products is raising as they are coming more and more ubiquitous.
The presentation discusses what are the common pitfalls in product development and how to enable rapid, iterative product design while ensuring great user experience.
Designing look AND feel of the product
Validating and iterating the designs with real hardware
Speeding up the development process and reducing the need for writing specifications
Bringing Low Power, High Performance Audio and Voice to Market on the i.MX RT600 Crossover MCU
Presented by Brendon Slade
Presented by NXP
Join this session to learn how DSP Concept's Audioweaver tools and libraries can unleash the performance of NXP's new i.MX RT600 MCU, allowing audio designers to quickly implement designs from the algorithm level.
When developing embedded systems, the decision to build or to buy a subsystem is difficult. Most of the issues are not of a technical nature but of human failings. Commitment to one another and to the project, along with a negotiated plan is the only feasible antidote to biases and irrational thought-processes that lead to failure to meet schedule, budget, and requirements.
Topics covered in this talk will include:
Identify some problems in developing embedded systems
Understand some cognitive biases
Consider modeling and simulation of the development process
Compare parameters that tend to be important in projects
This talk aims to provide attendees with a basic understanding of middleware, its relationship with distributed systems, communication protocols, and the system structure of an embedded system. With these fundamentals in place, attendees will be introduced to a toolbox of design patterns that can be used to systematically design a message-based middleware that is tailored to the problems at hand. This talk will be a great opportunity for attendees to learn about the latest trends and best practices in middleware design and implementation.
Building a bulletproof OTA update system for your IoT devices
Presented by Francois Baldassari
Presented by Memfault
OTA updates are used for everything from updating the firmware on an embedded device to delivering new features or content to a mobile app. Given the growing popularity and complexity of IoT devices, OTA updates have become a critical tool for managing the firmware on these devices. A robust OTA update system enables teams to resolve bugs quicker, ship more features, and keep customers happy. However, OTA updates can also pose a security risk if not implemented correctly.
To get the most out of OTA updates, it is important to follow best practices such as ensuring the device firmware update code is updateable, and testing OTA update functionality before rolling it out to a larger number of devices. Watch this presentation to learn how to build an OTA system that will ensure your IoT devices are updated safely and securely.
After blinking a LED and sending out “Hello, World” over a serial port, the next step in a typical embedded development is to build a command-line interface (CLI) to bring up other components and interfaces.
This workshop will demonstrate how to design a clean and simple CLI in an RTOS environment by partitioning functionalities and distributing them to functional blocks. The key insight is to view a console command as an immutable object and it flows through individual functional blocks. As a result of this streamlined design, simplicity is achieved by eliminating interactions between any non-neighboring blocks. In particular, there are three key ingredients in this simple CLI design:
A terminal utility program (e.g., Termite) as a builder to assemble command objects. Once a command object is fully constructed, it will be sent out to a target board over a serial interface.
The UART ISR as a de-serializer to reassemble the command object and notify a console task of the availability of such command object.
The console task as a dispatcher to find a command handler and delegate the rest of command processing to a worker task.
The workshop will first present the architectural design of the proposed simple CLI interface and then walk through its implementation with live coding. A low-cost STM32 Nucleo board will be used to demonstrate how simple it is to implement each functional block with less than a dozen lines of C code. After the workshop, the participants will be able to apply this clean and simple CLI design to their real-world projects.
Building a Modular Codebase with Zephyr RTOS and Devicetree
Presented by Mike Szczys
Presented by Golioth
If there’s one thing the chip shortage has taught us, it’s to be ready to pivot to different hardware on a short timeline. I’ve found that the Zephyr Real-Time Operating System makes this much less painful for firmware engineers. It borrows many concepts from the Linux ecosystem, delivering Devicetree, Pin Control, and Kconfig to microcontroller-land.
In this talk I will detail how I use Zephyr to maintain one codebase that can be built for many different hardware combinations. Once a Kconfig and Devicetree overlay files have been created for each target, compiling the same project for Nordic, Espressif, or NXP chips (to name just a few) is simple. Changing vendors or models of sensor and other peripherals is a similar experience. The C code grabs all necessary hardware information like what pins are connected and which peripheral bus should be used for a particular build. From there it’s just a matter of changing the board name in the build command.
Join me for a tour of what this looks like in real-world examples where changing out a microcontroller or sensor no longer leads to premature hair loss and hypertension.
Adding a command-line interface (CLI) to an embedded device doesn't need to be difficult! In this microtalk, I'll demonstrate how to build a simple CLI over UART using just a few dozen lines of code. We'll finish up by looking at a few improvements to that implementation, as well as some libraries that can allow for some exceedingly capable command-line interfaces.
Building A Tensorflow Lite Neural Network Vibration Classifier, With A Little Help From DSP
Presented by John Edwards
This presentation will walk through a Python Notebook that uses a combination of DSP and a Convolutional Neural Network (CNN) to classify multiple vibration modes of a rotating machine. The key to developing an efficient vibration mode classifier is the use of DSP algorithms to optimize the task. The DSP functions will pre-process the data to allow a simpler Neural Network to be used for the classification. The CNN will use a Tensorflow model that is trained on the supplied data, it will then use the model to classify new data. We will also include the code to generate and test both the Tensorflow and Tensorflow Lite models. Once generated, we will test the Tensorflow Lite model to ensure it classifies the data as well as the floating point model.
Setting up a Video Surveillance System with a commercial off-the-shelf solution is relatively easy to do, albeit potentially costly. With the availability of low-cost embedded hardware and USB webcams, there is no reason we cannot easily make our own system. Open-source software for managing such a system is readily available, distributed as containers for easy installation and configuration in a system. In this talk, we will cover the how-to of creating a surveillance system. We will use the Torizon platform and hardware from Toradex to quickly set up connected Embedded Linux devices to function as a Video Surveillance system. Commodity webcams will be used. The web-based front-end is easy to use and allows the hardware to be deployed and configured remotely. By the end of this talk, we will have a functioning system that viewers of this talk can replicate in their home or office.
Do you want to benefit from the acceleration of programmable logic using C or C++, for your quantitative finance / signal or image processing or AI/ML applications. The Vitis Unified Software Platform enables developers to more easily tap into the benefits of Xilinx heterogeneous SoCs and accelerate their applications, without needing advanced hardware development knowledge. This workshop will provide an in-depth tutorial on how to get started with Vitis and Vitis AI.
Topics covered in this workshop include:
Vitis features and elements
Vitis libraries
OpenCL
Vitis development flows
Optimizing software for programmable logic implementation
Vitis AI for machine learning inference acceleration
Building an Agile Development Team with a Framework you can use Anywhere
Presented by Harrison Donahue
Presented by The Qt Company
Your development project needs predictable delivery timelines, cost and scheduling that allows to changing scopes - even during a pandemic. Join Harrison Donahue, Business Development Manager at The Qt Company to hear about how to address problems with efficient development when developers need to "change gears" when working on multiple projects of differing scope, or taking over for someone else. You will also find out about the advantages of leveraging a framework where the tooling and APIs are the same across MCU, MPU, Desktop and Mobile.
Building an Interactive IoT Dashboard With Speech Synthesis Using Node-RED
Presented by Dr. Don Wilcher
Hardware devices, Application Programming Interface (API), and online services can be wired together using a data flow-based programming tool called Node-RED. Node-RED allows developers to build IoT devices using a web browser editor quickly. A developer can create an IoT device using a variety of Node-RED widgets provided with the data flow-based programming tool. In this talk, the participant will learn the essential visual programming environment by building an IoT interactive flow dashboard with a speech synthesis demonstrator.
Building IoT Machine Learning Applications using the Raspberry Pi Pico
Presented by Jacob Beningo
Machine Learning is finding its way into various microcontroller-based IoT devices. Unfortunately, embedded software developers typically aren’t experienced in machine learning, making designing these new device types challenging.
In this workshop, attendees will learn hands-on about machine learning using the inexpensive Raspberry Pi Pico. We will introduce machine learning concepts and how they affect embedded software developers. Attendees will then get the opportunity to collect their dataset, train, and deploy a machine-learning model to their Raspberry Pi Pico.
Topics covered in this session include:
Introduction to machine learning
A Raspberry Pi Pico overview
Hands-on data collection and model training
Model validation, testing, and deployment
Next steps
The hands-on portion is optional, but if you wish to participate, the following hardware will be required:
In this talk I'll go over various considerations for building LoRaWAN devices and solutions, such as the use of LoRa Alliance standards (which ones to use, the new developments), open source implementations, certification, interop, end-to-end solution elements to use (network server, join server, FUOTA, roaming, activation, etc.)
C & C++ vs. Python: The Rise of Scripting Languages
Presented by Peter McLaughlin
Python is the world's fastest growing programming language. It has become the most popular introductory teaching language for computer science courses and the number of Google searches for Python has trebled since 2010. Python's versatility has led to its adoption in web applications, desktop applications, data analytics, and artificial intelligence. In the Embedded System space, however, more than 70% of new systems are programmed in C with C++ strongly positioned as number two. Given the explosive growth of scripting languages such as Python, hiring C/C++ developers is becoming increasingly difficult. In this session, Peter McLaughlin will explore the pros and cons of scripting languages versus compiled languages in the embedded system space. Topics to be covered include: hardware constraints, library support, coding efficiency, readability, robustness, and real-time capability. Real-life examples of Python usage in Embedded Systems will be examined and future trends will be considered. Attendees will walk away armed with information to help them get started with Python and apply it in their next project.
Although not designed for embedded software development, C is the most popular programming language for such application. We will consider why the language is so popular and conduct a brief "refresher" of C language functionality, with an emphasis on the benefits to the embedded developer.
Cancelled - Mastering the Fine Art of the Hardware / Software / FPGA Boundaries
Presented by Glenn Kirilow
***** We regret to inform you that this session by Glenn Kirilow, has been cancelled due to unforeseen circumstances. It will possibly be rescheduled for later in the year, based on the speaker availability. Thank you for your understanding. *****
This talk will explore key insights for greater success at solving challenging problems which may exist within an Embedded System at the Hardware/Software, Software/FPGA and Hardware/FPGA boundaries both during the board bring-up, development and customer release phases.
A modern Efinix development board will be used to explore/illustrate the concepts throughout the slides.
To draw scientifically meaningful conclusions and draw
reliable statistical signal processing inferences of quantitative
phenomena, signal processing must take cause and effect into
consideration (either implicitly or explicitly). This is particularly
challenging when the relevant measurements are not obtained from
controlled experimental (interventional) settings, so that cause and
effect can be obscured by spurious, indirect influences. Modern
predictive techniques from machine learning are capable of capturing
high-dimensional, complex, nonlinear relationships between variables
while relying on few parametric or probabilistic modelling
assumptions. However, since these techniques are associational,
applied to observational data they are prone to picking up spurious
influences from non-experimental (observational) data, making their
predictions unreliable. Techniques from causal inference, such as
probabilistic causal diagrams and do-calculus, provide powerful
(nonparametric) tools for drawing causal inferences from such
observational data. However, these techniques are often incompatible
with modern, nonparametric machine learning algorithms since they
typically require explicit probabilistic models. In this talk I'll
describe causal bootstrapping, a new set of techniques we have
developed for augmenting classical nonparametric bootstrap resampling
with information about the causal relationship between variables. This
makes it possible to resample observational data such that, if it is
possible to identify an interventional relationship from that data,
new data representing that relationship can be simulated from the
original observational data. In this way, we can use modern
statistical machine learning and signal processing algorithms
unaltered to make statistically powerful, yet causally-robust,
inferences.
Challenges and techniques to use Linux in Real-Time Systems
Presented by Sergio Prado
Is the Linux kernel a good fit for real-time systems? Can we consider Linux a deterministic and fully-preemptible kernel so it can be used in real-time applications? If so, how is it possible, and what we should be aware of? Although Linux (with the PREEMPT_RT patch) is designed to be used on Real-Time Systems, it takes more than just a kernel to make sure you can meet all real-time requirements. This talk will cover the main aspects related to designing real-time applications on Linux-based operating systems, from configuring the kernel to writing real-time user space applications and measuring latencies.
ChatGPT for Embedded Systems - A game changer or Pure hype?
Presented by Sree Harsha Angara
ChatGPT is all the buzz these days with a stream of articles, and worst of all, unending streams of LinkedIn posts. This talk covers my explorations using ChatGPT for embedded systems use-cases, from simple snippets and questions, to a reasonably complex design on a MCU. This talk will uncover the nature of ChatGPT as we put it through its paces to try and answer the question “Are embedded engineers replaceable with AI?”.
The answer(spoiler: No), while unsurprising, leads to some very interesting thought experiments on what the future of this field looks like as we head into a new world of AI-assisted design and learning.
Chilling Out the Digital Transformation: A Deep Dive into Cold Chain Management
Presented by Guenaelle Blanchet
Join me on a journey through the cool world of cold chain management, where digital transformation takes center stage. In this engaging talk, we'll explore how technology has redefined the way we handle and safeguard perishable goods. Discover the essential role of data, sensor calibration, and seamless interactions with third-party services in ensuring the efficiency and reliability of the cold chain. We'll also delve into real-world challenges and innovative solutions that have shaped this critical sector. Get ready to chill out with the latest insights on optimizing cold chain management through digital innovation.
Cloud Connect All Your Devices with FreeRTOS - From Tiny MCUs to Feature-Rich Processors
Presented by Richard Barry
In this session, developers will learn how to use FreeRTOS products and libraries to quickly and securely connect both capable and tiny MCUs to the cloud. The first demonstration shows how device developers designing-in more capable devices benefit from FreeRTOS’s decoupled and modular C libraries and reference integrations. The second follows by showing the convenience and simplicity of using AWS IoT ExpressLink to connect even the most resource constrained MCU families.
For many years embedded developers have relied on building an application image by invoking a "build" menu option with their development IDE. Unfortunately, this can lead to two challenges; first, it doesn't scale very well when a team of engineers develops a codebase. Second, it often ends up with an independent and often complicated set of scripts to create the complete build.
Build systems were developed to simplify and automate running the compiler and linker and are an essential part of modern, agile software development. Historically GNU Make has been the de facto build tool for many years but can become challenging to maintain as codebases grow.
Recent surveys show that CMake has become the build system of choice for the majority of new C/C++ projects. This presentation introduces the CMake build system and explains the steps required to add it to an existing embedded C/C++ project. It will also discuss "the good, the bad and the ugly" of CMake. By the end of the presentation you should be in a position to understand CMake based projects and make an informed decision whether CMake is the right tool for your future projects.
Common cryptography mistakes for software engineers
Presented by Aljoscha Lautenbach
Most implementations of security mechanisms depend on cryptography, and yet, many vulnerabilities exist because cryptography is used incorrectly. This is partly due to lacking user-friendliness of cryptographic library API designs [1][2], and partly due to a lack of education in the developer community of the underlying mechanisms. As for the API design, we can only lobby for more user-focused design during library development and advocate user-friendly libraries. We can, however, try to improve the communal understanding of how to use cryptography securely. By way of examples, this talk will explore questions such as: What is an IV and why does it matter? Why does entropy matter? Which cipher mode is appropriate for my application? In essence, we highlight points to watch out for when implementing security mechanisms using cryptography.
It is difficult to create a common platform to support completely different applications. In this presentation we will examine heterogenous platforms that tightly couple microcontrollers with FPGAs to increase computing capacity, provide flexible interface capabilities or use other features. We will examine how to setup a link between Coldfire and Spartan 6 devices through mini-flex bus. Bus differences for Kinetis devices will be noted, that shows the advantages of these newer devices and some application examples will be shown.
Prerequisite: Solid knowledge of the C, as well as the fundamentals of C++ classes, constructors, and the const qualifier.
C++’s constexpr qualifier is a powerful tool for writing “constant expressions” — that is, expressions that can be computed at compile time. These constant expressions have several advantages over non-constant expressions, particularly for embedded systems. Objects with values that are constant expressions can be placed in ROM (read-only memory), and can be used as array dimensions, case labels, and enumerator initializers. Moreover, code that uses constant expressions is generally smaller and faster than similar code that uses non-constant expressions.
In this session, we’ll look at how you can use the constexpr qualifier to write functions that yield constant expressions. We’ll examine the differences between const and constexpr objects and see why const objects don’t necessarily qualify as constant expressions. We’ll also discuss the related C++20 keywords consteval and constinit and see how they fit into the picture.
Security cameras are the most deployed “IoT” devices according to IT managers in a recent study by Spiceworks and Cradlepoint. Security of IoT devices is the highest concern of these IT managers. In addition, according to a recent Harvard Business Review survey of facilities managers, more than 60% of successful cyber attacks against organizations come through IoT building systems, with video surveillance the number 2 place for such attacks to be launched from.
Despite the clear and urgent imperative for comprehensive cyber hygiene of physical security systems, it is not happening very quickly. There are both new processes that need to be added, and existing processes must become more automated. While many organizations are aware of the need to update firmware, they are not yet aware of other cyber hygiene capabilities like using TLS or 802.1x certificates at the device level, or having a comprehensive password management process.
The learning objectives for this session will be to understand that comprehensive cyber hygiene must incorporate management of passwords, firmware, and certificates, and to best achieve that at scale.
Compressive Sensing Application for Transient Photometric Measurements
Presented by Asmita Korde-Patel
Compressive Sensing (CS) is a mathematical theory for simultaneous data acquisition and compression. Natural phenomena may be sparse in some physical or temporal domain. If we exploit this sparsity by applying the technique of CS to obtain information, how do our measurements change as a function of domain and measurement systematics? What are the specific implications for the science and for the sensing infrastructure? In this talk, we will discuss the generalized systematic effects consequent to the application of CS to time-series photometric measurements. We assess implications for observability, sparsification, and information loss in the detection, retrieval and reconstruction process.
To study time-series photometry, we explore the field of gravitational microlensing. A source star, typically in the galactic bulge, gets microlensed when there is a precise alignment of a lensing star and its planetary system, with the source star. The microlensed source star changes in flux magnification as the lensing system crosses the precise path of alignment, resulting in a microlensing curve in time domain. A high-cadence, high-resolution system, which uses low power and bandwidth is essential to obtain valuable science measurements. Hence, we discuss application of CS to gravitational microlensing data sets, which in turn can be generalized to any time-ordered photometric measurements.
Computer vision, a type of artificial intelligence, enables computers to interpret and analyze the visual world, simulating the way humans see and understand their environment. Watch this video to learn more about computer vision for IoT applications, with an end-to-end proof-of-concept powered by Arm Cortex-A72, Ethos-N57 and Mali-C52 processors, and using the Arm NN software library.
Connecting CI, DevOps, and Security: What You Need to Know
Presented by Joe Schneider
Join Joe Schneider, and Shawn Prestridge to learn about continuous integration, DevOps and security approaches. Gain practical advice on implementing best practices into the embedded space (CI, embedded tools, orchestration platforms, compilers, security, developer efficiency and speed) and on how to prevent security issues from affecting your product. Hear from experts ranging from wireless (BLE, WiFi, Cellular), compiler, secure boot, toolchain, design, and testing to protect your products.
Considerations for Abstraction Based Connectivity Solutions
Presented by Gokhan Tanyeri
The purpose of this paper is to delve into the utilization of software abstraction strategies in order to overcome platform-specific limitations and foster the reuse of existing software across various platforms. The implementation of an abstraction-based approach requires careful consideration of several key elements, such as abstracting processor architecture, microcontroller/microprocessor unit (MCU/MPU), operating system/real-time operating system (OS/RTOS), Bluetooth or Wi-Fi chipset, hardware interface, TCP/IP network stack, permanent storage, and debugging software. As a demonstration of how abstraction-based connectivity solutions can be executed, we will showcase the example of ClarinoxSoftFrame, developed by Clarinox.
Constant Level Stopband Sidelobes: Tsk-Tsk-Tsk, Don’t do it!
Presented by fred harris
This presentation will show you how to design and implement FIR filters with an interesting and desired variation of its spectrum. The Remez (or FIRPM) filter algorithm designs FIR filters with selectable and different constant level pass band ripple and constant level stop band ripple. This is what the recursive elliptic filter does. In an alternate design we modify the Remez to replace the constant level stop band attenuation ripple with a 1/f spectral decay. Why would we do this? We do it to protect our signal passband from stopband aliasing levels when we reduce sample rate after reducing signal bandwidth. Come by and listen, I will show you why and how and demonstrate the advantages of using this option.
Container-ize Your Build Environment: Advantages of Docker For Firmware Development
Presented by Akbar Dhanaliwala
Docker is a relatively new technology that has revolutionized the web world, but is underutilized in the embedded systems industry. However, Docker's light-weight virtualization technology is perfectly suited for solving many of the biggest pain points firmware developers face today. In this talk we'll briefly go over how containerization works (vs. traditional virtual machines), the benefits of containerization for firmware development and automated testing, and walk through what developing with a Docker container actually looks like.
Containerize All The Things. For Embedded? Really?
Presented by Drew Moseley
Using containers in Embedded Linux devices is becoming more of a reality every day. Many of these devices are extremely high-powered and the benefits provided by containers are attractive to system designers. The ability to easily install, update and replace application payloads makes for a powerful design that is used in a variety of industries.
In this talk, Drew will provide an overview of containers, including a discussion of their architecture and implementation, as well as both technical and non-technical benefits of using them. We will discuss their impact on system performance as well as touch on the developer workflows needed to create and use them in systems.
We will then compare a few common approaches for creating, managing, and deploying containers including Docker, the Open Container Initiative) and OpenEmbedded. We will highlight the benefits of each approach and include considerations that designers can use to help decide which approach to use.
We will wrap up with some examples that highlight the value of containers in real-world use cases.
Containerized, cloud-enabled, and compliant: embedded DevSecOps at scale
Presented by Aaron Bauch
Presented by IAR
As embedded systems evolve and development scales across teams and geographies, maintaining quality, security, and compliance becomes a serious challenge. Manual workflows and fragmented toolchains no longer meet the demands of modern product development, especially when time-to-market and regulatory readiness are critical.
In this session, we’ll explore how engineering teams are implementing DevSecOps best practices to automate embedded CI/CD pipelines, reduce risk, and deliver secure, high-quality software, whether deploying in cloud, hybrid, or on-prem environments.
You’ll learn how containerized, cloud-enabled workflows help:
Support compliance with standards like ISO 26262, IEC 61508, and IEC 62304 using TÜV-certified tools
Integrate secure boot, encryption, and IP protection directly into development pipelines
Adopt architecture-agnostic toolchains across Arm, RISC-V, and more, minimizing vendor lock-in
Enable CI/CD automation using familiar tools like GitHub, GitLab, Kubernetes, and containers
Whether you're building safety-critical devices or scaling across multiple product lines, this session offers real-world strategies that embedded software teams are using today to modernize, secure, and accelerate development across any deployment model.
Containers and Managed Software on Micro-controllers
Presented by Kasper Lund
Building all functionality for your micro-controllers as monolithic firmware is error-prone and costly. Taking a page from server- and desktop systems, we propose running your code as individual apps, isolated from each other in containers, and managing them over-the-air through a remote serviceability protocol. Want to catch a glimpse of this on an ESP32?
Many organizations have adopted agentless asset discovery to improve IoT security, and reports from the field are that it takes longer than expected to deploy and even longer to effectively remediate IoT device vulnerabilities. In part, this is because asset discovery alone does not provide the context that IoT devices operate in, especially when it comes to the overall application workflow and how all elements need to work together in a tightly coupled fashion.
This talk will show how application-directed discovery adds to the information uncovered in asset discovery, and how the two together dramatically accelerate the time to remediation and shrinking of the attack surface. Data examples from application-directed discovery will be provided, as well as an industrial IoT use case.
Continuous Software Improvement with IoT Device Monitoring and Visual Trace Diagnostics
Presented by Dr. Johan Kraft
Presented by Percepio
Even the best developers cannot anticipate all the issues that may occur in deployed Internet of Things (IoT) devices: elusive software bugs, hardware glitches, algorithms that do not perform as well as intended, and user-interface issues. DevAlert enables continuous software improvement, so you can build flawless products through data-driven product improvements and the rapid resolution of remaining issues that would otherwise harm data integrity, device availability, battery life, and the overall user experience. Instead, IoT device monitoring and visual trace diagnostics adds an essential layer of defense to reduce support costs and increases sales revenue—and may even prevent accidents, product recalls and legal action.
Join Dr. Johan Kraft as he explores IoT device monitoring and remote diagnostics and demonstrates Percepio's DevAlert service.
This session focuses on the practical aspects of convolution and FIR filtering and some of its applications, from algorithm exploration through to real-time signal processing.
We discuss the tradeoffs between time and frequency domain implementations, including latency and computational cost. For both domains we review the best-known implementation variants and some of the hardware technologies most used for performance acceleration.
Cyclic Redundancy Checks are a vastly used method for error detection and they are foundationally based on math. This short talk aims aims to give an overview of CRC concepts, their algorithms design and some of the ways that they can be implemented within a solution.
Creating Advanced User Interfaces with STM32 Microcontrollers
Presented by Mike Hartmann
Presented by STMicroelectronics
In today's fast-paced and interactive world, it is necessary for technology to provide a simple and compelling experience to the end user.
Through advancements in graphics software frameworks and embedded technology and integration, this can be easily achieved with the STM32 microcontrollers. In this 2-hour hands-on workshop, you will be introduced to the STM32 Microcontrollers with advanced graphics technology. You will be introduced to graphics software frameworks and tools, and get hands-on experience using the STM32H7B3I-DK discovery kit with the latest STM32H7 microcontroller and the TouchGFX Designer tool.
Workshop Agenda:
Advanced Graphics with STM32 Microcontrollers
STM32 Graphics Software and Tools
Hands-on: Quick Start with STM32H7B3I-DK Board
STM32 Graphics Ecosystem and Support
Hands-on: Custom Project Start with STM32 + TouchGFX
Note: The STM32H7B3I-DK board will be available at a discounted cost of $20.00 excluding shipping and handling fee to the first 100 registrants using a business email address. An email with a dedicated board link to Digi-Key Electronics website will be provided.
The materials for this workshop can be downloaded at:
The best way to understand why the processor is sending you love letters (exceptions) is to see what they look like when you aren’t also frantically trying to fix your code. This talk goes over the code necessary to cause (and debug) divide by zero, bus errors, stack overflows, and buffer overflows.
For each one, Elecia looks at the information the Cortex-M processor provides and how to use that to determine the cause of the fault. She describes how to use the information in a hard fault handler to create small core dumps to be stored after a system reboot.
Join TI and Edge Impulse for a hands-on enterprise webinar and learn how to use embedded machine learning to detect and respond to audio events in an emergency. Whether designing a smart baby monitor, breaking glass, or detecting a call for help, Edge Impulse and Texas Instruments enable you with the right tools for rapid prototyping of new applications - going from raw data to deployment in minutes.
Join TI and Edge Impulse for a hands-on enterprise webinar and learn how to use embedded machine learning to detect and respond to audio events in an emergency. Whether designing a smart baby monitor, breaking glass, or detecting a call for help, Edge Impulse and Texas Instruments enable you with the right tools for rapid prototyping of new applications - going from raw data to deployment in minutes.
Modern software development tools have allowed more rapid, collaborative application development, but IoT and embedded software developers haven't always been able to best use these tools. Much of this is due to industry-defined development environments requiring clunky, non-automatic interfaces and platform-specific dependencies before you can deploy to your target. In this talk, I'll walk you through concepts and tools I use to build my environments, including versioning, virtualization, compilation, testing, continuous integration and deployment. After this talk, you'll be able to set up a snappy, replicable, and collaborative development environment to free your team from a constrained environment and build an integrated environment that best suits your needs.
In this time of great uncertainty, it is important to remember that creativity thrives with constraints. In this interactive session, Tina Seelig will explore ways to look at limitations as fuel for innovation, using examples from across time and space from Apollo XIII to San Quentin State Prison. The talk will be followed by Q&A with the participants.
This demonstration shows how power interruption causes failures in the FAT file system. Tuxera's Reliance family of file systems - including Reliance Edge and Reliance EdgeNAND - is incorruptible under the same conditions. Reliance Edge™ is a small-footprint IoT embedded file system designed to capture and preserve decision-quality data. A transactional file system, Reliance Edge protects critical system and user data from corruption, specifically for systems where power loss may occur. It works with a broad array of storage media including: eMMC, SD/MMC, NVRAM, USB mass storage, and SATA (or PATA) disks, and with a wide variety of real-time operating systems.
Crossovers are heavily used in many aspects of audio signal processing. Crossover design involves a significant amount of trade offs. The presentation describes what these tradeoffs are, presents different architectures (Linkwitz Riley, odd order Butterworth, linear phase FIR, etc) derives their properties and discusses the pros and cons and how they map to typical real world requirements.
Data-Centric AI for Signal Processing Applications
Presented by Frantz Bouchereau
Presented by MathWorks
Model-centric approaches to solve AI problems have been dominant in applications where large and high-quality datasets are available. Such approaches aim to improve model performance through the development of more complex architectures.
In signal processing applications, where data is usually scarce and noisy and where advanced models and architecture experts are hard to find, a potentially more fruitful approach is a data-centric one that focuses on improving the data to make simpler network architectures perform better. The idea is to enhance signal data by improving its labels, removing noise, and reducing variance and dimensionality. This idea can be extended to include transforming signals into domains where key features become more prominent and easier to distinguish.
In this talk I go over various examples that follow a data-centric approach to improve AI-model performance. I show how signal processing techniques like time-frequency transformations, filtering, denoising, multiresolution analysis, data synthesis, and data augmentation can be used to obtain state-of-the-art results with simpler AI architectures in the solution of signal classification, signal regression, and anomaly detection problems.
Debugging Embedded Devices at Scale: Effective Techniques for Diagnosis and Resolution
Presented by Tyler Hoffman
Presented by Memfault
In this presentation, I’ll walk through effective approaches for detecting, diagnosing, debugging, and resolving issues in embedded firmware and devices deployed at a large scale, such as in populations of hundreds of thousands or millions. While much has been written on monitoring smaller fleets, typical strategies like onsite debugging, debugger-based diagnosis, and manual log analysis can fail when dealing with massive populations of devices.
The presentation focuses on low-level debugging techniques like fault handling and exception parsing on the device, as well as a novel approach to capturing core dumps on Cortex-M MCUs. The presentation provides guidance on collecting core dumps and diagnosing crashes and faults without a debugger. I’ll also explore the changes in developer behavior that can be implemented when core dump functionality is integrated into firmware, and dumps are received centrally.
This presentation includes content that is often overlooked by online resources, which assume that firmware works flawlessly and bugs are not introduced by developers. We know this is not the case and have developed these strategies to offer real-world solutions for new and experienced firmware engineers who are eager to tackle the challenges of debugging at scale.
Debugging IoT Connectivity from Arm Virtual Hardware
Presented by Alina Dima
Presented by Amazon AWS
Arm Virtual Hardware (AVH)—a family of functionally accurate representations of Arm-based processors, systems, and hardware—accelerates embedded developer experience when building and testing IoT applications. AVH helps engineers quickly resolve issues related to cloud connectivity, security, OTA updates, and more. In this session, discover how AVH and AWS IoT can be used to quickly debug connectivity issues commonly seen in IoT applications. Also, explore tips to validate your IoT devices for reliable and secure connectivity using AWS IoT Core Device Advisor test suites and AWS IoT logging features.
Debugging cross-platfrom embedded micro-controller architectures is a major challenge as the demands on compute and power increase with AI knocking on the edge. OpenOCD is a powerful novel cross-platform open-source software tool that lets us debug and program embedded devices directly on their hardware, using a JTAG interface. It's like having a virtual microscope and workshop for our microcontrollers for most architectures like - ARM, RISC-V, MIPS, AVR32, Xtensa, EnSilica eSi-RISC, and many more.
This talk is about how to design drivers that are decoupled from a specific hardware platform so they can be reused on different microcontrollers. Decoupled drivers also enable the creation of a functional simulator for your embedded application. Writing decoupled drivers does not require more effort or time to implement than a traditional platform-specific driver.
A decoupled driver requires a public interface that is defined without direct hardware dependencies and a mechanism (e.g., a Hardware Abstraction Layer) that decouples the driver implementation from a specific hardware platform.
There are numerous ways to create interfaces for a Hardware Abstraction Layer (HAL). The following list covers three ways to create abstract interfaces that decouple a driver from platform-specific dependencies. In this context, an “abstract interface” is an interface that defines a behavior with late binding.
Façade. Using link-time bindings.
Separation of concerns. Using compile-time bindings.
The path to developing, testing, and deploying deep learning inference in embedded system products is marked by obstacles you must avoid. To do it sucessfully -- and avoid your investors and managers losing faith -- here are some crucial, high level guidlines.
Deep Learning, Wireless Communications, and Signal Processing: Bridging the Gap
Presented by Dheeraj Sharma
The talk explores the role of Deep Learning in enhancing wireless communications, specifically how it helps optimize signal processing, increase efficiency, and address challenges like signal interference and latency. Through real-world examples and forward-looking perspectives, the talk illustrates how the synergistic integration of these technologies is forging the path for the future of communication.
Defending against Hackers: Exploit Mitigations and Attacks on Arm Cortex-A Devices
Presented by Maria "Azeria" Markstedter
With the proliferation of Arm-based mobile and IoT devices, exploit mitigations for Arm-based devices are often the front-line in defending these devices from hackers. For this reason it is important to understand how they work, and their limitations. This talk will look at the most common exploit mitigations available for C/C++ programs running on the Arm Cortex-A architecture and how these mitigations work under-the-hood to block certain categories of memory-corruption-based exploits. The aim of this talk is to educate developers on how hackers can bypass individual mitigations, and the importance of combining them to increase the level of security on these devices.
Deliver rich graphical UX without blowing your hardware costs
Presented by Aurindam Jana
Presented by The Qt Company
Microcontrollers (MCUs) are ubiquitous in electronic appliances in consumer electronics, industrial automation, healthcare and the automotive industry, but the user experience of the user interfaces has been lagging behind. Users and operators expect smartphone-like user experiences with every screen they interact - a huge challenge for manufacturers to achieve. The desire to maintain existing supply chains and keeping the bill of materials low requires manufacturers to both improve the performance of their user interfaces while overcoming performance bottlenecks. Now, the most popular C++ development framework, Qt, is expanding its offering for the MCU market, with a new and lightweight implementation which enables the creation of high-performance user interfaces for the most low-end hardware.
IoT and embedded developers can take advantage of an unprecedented uplift in energy-efficient machine learning and signal processing performance for next-generation voice, vision or vibration use cases with Arm's latest endpoint AI technologies; The Cortex-M55 processor, Arm's most AI-capable Cortex-M processor and the Ethos-U55, the industry's first micro neural microprocessor (microNPU) that's designed to work with Cortex-M processors.
These technologies can be developed in a unified software toolchain for the simplest and fastest development path for AI. Join this talk to be one the first to get started today to write optimized code for the exciting features these processors bring.
IoT and embedded developers can take advantage of an unprecedented uplift in energy-efficient machine learning and signal processing performance for next-generation voice, vision or vibration use cases with Arm's latest endpoint AI technologies; The Cortex-M55 processor, Arm's most AI-capable Cortex-M processor and the Ethos-U55, the industry's first micro neural microprocessor (microNPU) that's designed to work with Cortex-M processors.
These technologies can be developed in a unified software toolchain for the simplest and fastest development path for AI. Join this talk to be one the first to get started today to write optimized code for the exciting features these processors bring.
In this tech talk, I will introduce an approach to AWS IoT device provisioning that is both practical and scalable. Our focus will be on the implementation strategies that enable efficient device provisioning, especially for large-scale deployments. Drawing from real-world challenges encountered by TIER, we'll explore key ideas that ensure a smooth AWS IoT device provisioning flow.
Lately there has been a resurgence of interest in beamformers
following the success of the Amazon Echo. This talk presents
beamformers in a simple-to-understand and straightforward light.
You'll understand how the number of microphones and geometry impacts
performance. The importance of microphone matching and SNR, and even
how to create steerable arrays. The talk has a minimum of math and an
emphasis on practical applications. Although the focus is on audio,
the techniques presented extend to other applications such as RF.
Demystifying Embedded: Techniques for Low-level Testing and Debugging
Presented by Gillian Minnehan
Many embedded software engineers start their careers with the expected software testing and debugging skills such as writing unit tests, leveraging a visual debugger, finding memory leaks with valgrind, and, let’s face it, using print statements. However, embedded software development requires more embedded-specific strategies that many do not get the chance to learn in school. This talk shares the best techniques for understanding what a microcontroller is doing at a low level, such as reading fault registers, looking at disassembly, counting clock cycles, and using logic analyzers -- strategies used by newbies and veterans alike. Each strategy will be accompanied by a demonstration and all necessary instructions so listeners can easily apply what they have learned to their work.
A Memory Protection Unit (MPU) is hardware that improves the safety and security of an embedded device by only allowing access to memory and peripheral devices by the code that needs to access those resources. The application can be organized by processes, each having access to its own memory and peripheral space. Not only does the MPU prevent application code from accessing memory or peripheral devices outside its designated area, but it can also be a useful tool for detecting stack overflows, one of the most common causes of issues when using an RTOS.
This class discusses some of the features provided by most MPUs, but specific examples assume the MPU found in most ARM Cortex-M MCUs. Topics covered include:
In this workshop, Dan will introduce the Hilbert Transform and the Analytic Signal, and the various uses for them. Dan will review the fundamental points in understanding the Hilbert Transform intuitively and then he will show practical implementations and applications both in the analog and digital signal processing domains. Key limitations and gotchas will be presented that every designer should be aware of. Dan will demonstrate creative implementations using Python, and provide similar scripts compatible with MATLAB. Attendees will gain a more intuitive insight of key signal processing concepts using complex signals that are applicable to a wide range of applications.
Workshop Instructions
Thank you for your interest in the Demystifying the Hilbert Transform workshop! Below are the installation instructions for Python in case you want to follow along hands-on with the examples given or run the examples later.
Note: We will not be debugging any installation issues in the Workshop, and a Python installation is not necessary to follow along with the workshop presentation. Having a Python installation running with the above libraries is convenient if you want to follow along hands-on, as Dan will be demonstrating the material using Python. A Jupyter Notebook of the material presented will also be distributed here after the workshop for future reference, along with similar scripts that work in Matlab or Octave. If you would like further basics on running the Notebook, please see this link:
Demystifying the IEC/ISA 62443 Security Standard for Industrial Systems
Presented by Xavier Bignalet
Presented by Microchip
As industry 4.0 and smart factories continue to connect their assets and equipment to the cloud, the attack surface grows exponentially. The IEC/ISA 62443 specification has been developed to help companies providing equipment and infrastructure to the industrial segment to architect their systems with security in mind. Join Microchip's webinar to learn how our ATECC608 secure element and consulting expertise from our partner, Security Pattern, can facilitate your journey to a successful IEC 62443 certification.
-Read our blog post about IEC62443 and secure element [link to come later]
-Read our application note about IEC 62443, which includes valuable technical information about our solutions [link to come later]
Visit our TrustFLEX ATECC608 page to discover how our preconfigured use cases can accelerate your IEC62443 design.
FUOTA is critical for IoT applications and deployments, providing future-proofing of connected device deployments and ensuring that devices will continue to operate over long lifetimes.
LoRaWAN® has the unique capability among LPWANs to support FUOTA, securely and reliably delivering updates over the air to many devices at one time, while consuming ~1% of the battery capacity. Entire fleets of devices can be scheduled and updated simultaneously within 5 to 10 minutes.
In this presentation, Ashley Pope from Oxit, will share use cases of mass FUOTA update across millions of devices globally, such as, in data centers across retail security, for irrigation systems, within the smart home, and for the utilities sectors. Come hear how FUOTA and LoRaWAN are already enabling interoperability, especially among devices and sensors in remote or difficult locations, to allow you quicker time to market and optimized cost efficiency.
Join this short webinar to understand the design considerations designers should be aware of when creating a wirelessly connected device. We will then provide a quick overview of STMicroelectronics Bluetooth LE and LPWAN portfolio of devices.
Here is a quick overview of what will be discussed during this webinar.
Typical design constraints of Bluetooth LE designs
Typical design constraints of LPWAN/SubGHz designs
How to overcome these design considerations and create robust RF designs
How STMicroelectronics development board designs from Nucleo boards to DK with the module can accelerate your RF development
Where to find software examples in the ST Cube Ecosystem to accelerate development
STMicroelectronics portfolio of Bluetooth LE and LPWAN SoC’s and modules that fit any application
Design Considerations for Serial Communications in an RTOS Environment
Presented by Peifang Zhou
Serial communications such as console are prevalent in the embedded software development. This workshop will explore options and tradeoffs when implementing serial communications in an RTOS environment, in particular the methods to receive serial data and the interactions between ISR and the data receiving task. The workshop will go through standard techniques and present a simple yet powerful design for high-speed and bursty serial traffic.
The workshop uses an STM32 board for hands-on experience. Any STM32 board is fine. STM32CubeIDE is used to generate the initial startup code to save time. A simple terminal program named Termite is used for serial communications between the STM32 board and a Windows computer. To maximize the benefits of hands-on experience, the hardware and software requirements are detailed below:
STM32 board – an STM32 Nucleo-64 board is recommended since it is low-cost and uses a single USB cable for power, debugging, programing, and serial communications. It requires little effort to get started quickly.
USB cable to connect the STM32 board to a Windows computer.
Terminal program – go to the Termite website https://www.compuphase.com/software_termite.htm, click the “Termite version 3.4 (program only) (76 KiB)” link, unzip the downloaded file in any folder on a Windows computer, and double-click Terminite.exe to run the program.
It would save time to review one of the following documents to identify the UART Rx/Tx pins and the user LED pin (optional) before the start of the workshop:
user manual – under the Documentation tab of the board webpage, or
schematic – under the CAD Resources tab of the board webpage
For example, the STM32 Nucleo-F303RE webpage is https://www.st.com/en/evaluation-tools/nucleo-f303re.html#. Under the Documentation tab, there is a link to the user manual “UM1724STM32 Nucleo-64 boards (MB1136)”. Under the CAD Resources tab, there are three links to the Rev. C03/C04/C05 board schematics. On STM32 Nucleo-64 boards marked with the MB1136 identifier, USART2 interface is available on the PA2/PA3 pins and LD2 is a user controlled green LED connected to the PA5 pin.
Note that the examples from the workshop are only intended to illustrate concepts. For the ease of presentation, they are much simpler than the production-level source code developed in real-world projects.
Designing Portable Firmware: Key Principles and Patterns
Presented by Alexey Karelin
Portable firmware is more than just migrating code across hardware platforms. It involves organizing firmware in a modular, scalable, and reusable way while adhering to better design principles.
This talk begins with a personal story of challenges and setbacks, shedding light on common pitfalls and ineffective approaches. It then explores the principles and patterns essential for creating portable firmware for embedded systems, illustrated with simple examples in C.
Attendees will learn how to develop adaptable firmware capable of running on different microcontrollers and hardware configurations with minimal changes to the application code.
Developing and Maintaining Application-Independent Driver and Hardware Abstraction Layers for Embedded C
Presented by Prabo Semasinghe
Creating reusable, easily maintainable, and scalable firmware with a modular architecture greatly benefits development teams. When similar hardware is replicated in multiple projects, the temptation to copy and paste code across projects is strong! However, is this the most effective approach to code reuse? How do you manage bug fixes and improvements for code that is duplicated in various projects?
This session will explore how to generalize and decouple the driver layer and hardware interfacing layer into independently manageable firmware components. Topics covered will include:
The benefits of developing separate, manageable Driver and Hardware Abstraction Layers (HAL).
Strategies for writing and managing generalized code:
Using submodules for code management and reuse.
Linking generalized driver and hardware abstraction layers with applications via a specific manager module.
Handling product-specific functionalities using function pointers.
The session will provide examples to illustrate these concepts and demonstrate their application in practice.
Developing embedded real-time applications with heterogeneous multiprocessing systems
Presented by Sergio Prado
There are a lot of embedded applications that have conflicting requirements like high throughput and data processing, responsive user interface, low-latency operations and determinism to handle hard real-time events. It is very hard (and most of the times impossible) to meet all these requirements with just a single processor.
A common approach to meet these conflicting requirements is using multiple heterogeneous processors, where a high-end processor takes care of general computing like network communication, user interface and data processing, and a low-end processor is responsible to handle low-latency and real-time events. This type of system is called Heterogeneous Multiprocessing System or HMP.
In this session, we will learn all the theory behind the development of embedded applications using heterogeneous multiprocessing systems and put into practice with hands-on demonstrations based on a board with a heterogeneous multicore SoC containing both a Cortex-A and a Cortex-M processor, capable of running multiple operating systems on the different cores.
In the hands-on demonstration, we will learn how to run an RTOS (FreeRTOS) in the Cortex-M processor to handle deterministic and real-time events and report them back to a full-featured OS (GNU/Linux) running on the Cortex-A. We will study how the communication between the cores works and use an implementation of the OpenAMP standard in the hands-on.
In this session, the attendees will understand how a heterogeneous multiprocessing system works and when to use it. They will also learn how to use a heterogeneous multicore SoC and run multiple operating systems on it, understanding how the communication between the cores are implemented in the hardware level, and learning how this communication is abstracted at the software level with the OpenAMP standard.
Developing Embedded Systems with (Apache) NuttX RTOS
Presented by Alan Carvalho de Assis
In this talk, I will present the NuttX RTOS, a POSIX and Linux-like RTOS for small microcontrollers, and show how you can use it to develop products faster than with existing alternatives. NuttX offers many advantages compared to other state-of-the-art RTOSes, primarily because it is POSIX compliant—meaning you can develop your application for Linux and then simply recompile it for NuttX. Additionally, NuttX includes many advanced features typically found only in more sophisticated operating systems like Linux or QNX, and it is already used by major companies like Sony, Samsung, Fitbit/Google, Xiaomi, and many others.
Developing for the IoT Using Secure-enabled NXP MCUs with TrustZone®-M Technology
Presented by Tomas Voda
Presented by NXP
In this session, you'll learn how Secure Thingz Embedded Trust provides lifecycle management of secrets and integrates with Secure Deploy for production programming of NXP's LPC55Sxx devices.
Developing Low Cost Embedded Products as a Small Team
Presented by Sai Yamanoor
With the advent of open hardware prototyping platforms, it is easy to build a prototype but prove a concept. It is something else to build a product that meets a certain target cost. There are several factors to consider including assembly costs, power options, battery life, device provisioning, product lifecycle management etc. Problems in hardware development tend to surface either during the later phases of development or during pilot manufacturing of the product.
As a member of a three person team, we have developed three low cost products and encountered different challenges. I would like to share some lessons learned. They include:
Navigating supply chain constraints during the pandemic
Estimating bottlenecks in components costs
Utilizing rapid prototyping tools to effectively iterate hardware design
Criteria to consider while selecting embedded hardware platforms
Product lifecycle management including planning for hardware obsolescence & parts approaching end-of-life
Planning time investment in projects when it comes to smaller teams
Once upon a time, firmware developers wrote code that was tightly coupled, spaghetti code that was fit for a single purpose and nothing else. That has changed! The ability to reuse embedded software has the potential to decrease time to market, decrease costs and prevent teams from reinventing the wheel.
In this session, we will explore how to develop reusable firmware for microcontroller-based systems. We will explore reusable and portable firmware best practices, software architecture, how to create abstractions and walk through an example.
Developing Rugged IoT Devices by Integrating Off-the-Shelf Hardware
Presented by Sai Yamanoor
The availability of IoT hardware prototyping platforms (e.g.: an Arduino shield or the ‘Feather’ form factor) enables the construction of ‘quick and dirty’ prototypes. The effort required to convert the prototype into a product is of a higher magnitude. There are several factors to consider including product form factor, power options, target costs, etc. Problems in connected hardware development tend to surface either during the later phases of development or during pilot manufacturing of the product.
The talk is going to be structured around a hardware design example whose target unit cost is supposed to be sub $100. The following is discussed:
Utilizing rapid prototyping tools like 3D printing and a low-cost 24-hour turn-around PCB fab to effectively iterate hardware design
Criteria to consider for selecting off-the-shelf hardware for your product
Estimating product development costs to avoid surprises in your budget
Product lifecycle management including planning for hardware obsolescence & parts approaching end-of-life
Things to consider while integrating off-the-shelf hardware & third-party tools e.g.: recurring costs for cloud services, platform fee, billing structure, etc.
Developing secure IoT devices with AWS IoT and the STM32L4 Discovery kit IoT node
Presented by Slim Jallouli
Presented by STMicroelectronics
Development of modern IoT devices is impossible without 2 features that fundamentally differentiate them from their non-connected siblings:
Strong Root of Trust
Ability to reliably update their firmware Over-the-Air (or Over-the-Wire)
STMicroelectronics collaborated with AWS to create reference designs for connected devices. Those designs leverage the power of secure hyperscale AWS IoT message broker, STM32 MCUs, and STSAFE secure elements.
During this session with hands-on lab demo, we will show how you can easily start developing your first IoT connected device using the flagship STM32L4+ Discovery kit IoT node (B-L4S5I-IOT01A), STM32 Cube IDE and AWS CLI. The presentation will be accompanied with a code repository so you can replicate all the steps of the demonstration.
Digital Signal processing for Hearing Aids, Constant Q Filter Banks
Presented by fred harris
In this presentation, we will show FIR bandpass filters with an unusual spectral variation. We describe why we want that variation and then show how to design and implement it.
We have need for bandpass filters with selectable and different transition bandwidths on its left (lower frequency) and right (higher frequency) sides. Now why would we need that? We need this to build proportional bandwidth filter banks. In such a bank, channel bandwidths are proportional to channel center frequency. This means that the filter above my band has a higher bandwidth with a wider transition bandwidth and the filter below my band has a lower bandwidth and a narrower transition bandwidth.
To obtain a perfect reconstruction filter bank, the transition bandwidths of my band must match the transition bandwidths of the filters below and above my band. Thus, my filter must have a lower transition bandwidth on its lower edge than it has on its upper edge. Can we design a filter to do that? Yes! Why? Ask the hearing aid filter bank designer (or ask me)!
One problem with reduced bandwidth filters with reduced transition bandwidth is they have increased filter length. Increased length means more computational work. We include multirate processing to reduce filter length in the reduced bandwidth filters.
Digital Signal Processing for Satellite Communications
Presented by Bradford Watson
Communications satellites are a booming business, and are increasingly using sophisticated DSP techniques to manage bandwidth for users distributed over wide geographic areas. There are several flavors of satellite communications, that include transponded and regenerative digital payloads for commercial and military platforms.
This talk gives an overview of the market, the end-to-end system level view, the actual digital processing that takes place onboard a satellite, specifications, and challenges of designing systems for spaceflight.
Discover the ST60 - New high-speed 60GHz RF Transceiver
Presented by Shray Khullar
Presented by STMicroelectronics
ST60 is STMicroelectronics latest breakthrough in short-range RF connectivity. This small form factor wireless link transceiver with a high data rate is optimized for short-range, point-to-point contactless communications. It leverages unlicensed 60 GHz RF millimeter-wave band, opening a world of possibilities for your product design.
Replace cables for board-to-board communication, enable connector-free solutions, and solve mechanical challenges.
In this session we will cover:
Key features of the ST60
3 Applications with demonstration
360 Degree Rotating Camera
No-Drill contactless power over ethernet (PoE)
Connector-Free LED Display Walls
Overview of ST60 Contactless Ethernet module with hands-on demonstration using STM32MP1 board
Overview of the ST60 evaluation kit options with demonstration of how to run electrical measurements
Do you waste time “plumbing” firmware to connect a new feature? Worry about managing dependencies between modules? Struggle to manage state when things go wrong?
In this session, we discuss real-world software architecture, dependencies, and state. We examine the publish-subscribe (PubSub) design pattern, what problems it solves, and what challenges it creates. We discuss how to create a distributed, reliable PubSub implementation that can span multiple microcontrollers with state recovery on failure. We explore one solution, Fitterbap, a new open-source C library with host Python bindings, which includes:
An efficient, distributed PubSub implementation with simple metadata that allows you to quickly add, remove, and modify firmware controls.
A small, high-reliability data link layer, suitable for local data streams including UART.
Multiplexed, fast, reliable data streams, such as for sample waveform data.
A UI (python + Qt + PySide) that runs on your host computer. The UI automatically instantiates controls from the metadata and plots streaming data.
NXP’s MCUXpresso Ecosystem has added exciting new advantages for developers. NXP’s Visual Studio Code extension makes it easy to use the MCUXpresso suite of software and tools. In addition, the new Application Code Hub provides quick access to examples from NXP’s internal experts that solve challenging requirements of popular applications. Learn how you can benefit from VS Code and the Application Code Hub.
AI-powered coding assistants like GitHub Copilot and ChatGPT are transforming software development—but what do they mean for embedded systems engineers? Unlike traditional software, embedded programming comes with unique constraints such as limited resources, real-time requirements, and hardware dependencies.
This talk explores the real-world impact of GitHub Copilot on embedded development. We’ll separate hype from reality through practical examples, showcasing where AI tools can truly boost productivity—and where they fall short. Whether you're skeptical or excited about AI-driven coding, this session will help you understand how (and when) to make these tools work for you.
DSP remains a skill-shortage area: yet an employer obsession with experience means legions of freshly qualified Masters students - who have literally mastered their trade - are ignored by employers and recruiters.
In this talk I will moan about pointless and pathetic recruitment gatekeeping practices, big up the star quality of the many hundreds of Masters students, and engineers transitioning from othe fields into digital, with whom I have worked, trash the supposed superior knowledge of the gatekeepers, and politely suggest that employers take a long hard look at themselves and start to take some responsibility for growing the next generation of DSP engineers.
Don't Let the FFT Fool You - Avoiding its pitfalls for a more accurate frequency analysis
Presented by Mark Newman
The Fast Fourier Transform is a cornerstone of audio processing providing a representation of a time domain signal in the frequency domain. The ability to manipulate signals in the frequency domain gives us the power to isolate, enhance, and sculpt specific frequency components, redefining the very essence of sound. However, for this to work, an accurate frequency domain representation is essential.
As DSP enthusiasts, we tend to treat the FFT as a magic bullet solution, a library function that is so commonplace, we can implement it with an “include” statement and a few lines of code. But what do we really know about its inner workings, its nuances and most importantly, its limitations? Can we be confident that the frequencies reported by the FFT are truly present in the original signal, or is our ignorance of how it works pulling the wool over our eyes and causing unwanted artefacts in our output?
In this presentation we’re going to lift the hood on the FFT and discover:
How the Fourier Transform works
Why the FFT is only an approximation (albeit a good one) of the true Fourier Transform
What the limitations of the FFT’s approximation are
How to mitigate these limitations by windowing your signal before it enters the FFT
How to navigate the trade-off between processing speed and frequency resolution in the FFT
This presentation aims to equip you with a practical understanding of the FFT, empowering you to create higher-quality and more precise DSP applications.
Phase is often the poor relation to magnitude in Fourier Transform analysis but can be the crucial measurement in some applications. Such is the case with phased array methods for imaging: in radar, security and medical imaging applications. The key to such applications is physics modelling and measurement of phase to reconstruct wave propagation and hence reconstruct 3D or 4D images of reflecting, refracting or scattering objects. This talk offers an overview of phased array imaging from the viewpoint of DSP, modelled as a 3D Fourier or Laplace Transform problem.
CMSIS-NN and CMSIS-DSP provide developers with a collection of efficient neural network kernels aimed at maximizing performance and minimizing the memory footprint on Cortex-M processors for applications that require machine learning and DSP capabilities. Join Laurent Le Faucheur, Principal IoT Software Engineer at Arm as he shares the latest developments for these computing libraries and how they can be used efficiently with future processing technology, including the Arm Cortex-M55 processor.
Dynamic Memory Allocation & Fragmentation in C/C++
Presented by Colin Walls
In C and C++, it can be very convenient to allocate and de-allocate blocks of memory as and when needed. This is certainly standard practice in both languages and almost unavoidable in C++. However, the handling of such dynamic memory can be problematic and inefficient. For desktop applications, where memory is freely available, these difficulties can be ignored. For embedded - generally real time - applications, ignoring the issues is not an option.
Dynamic memory allocation tends to be non-deterministic; the time taken to allocate memory may not be predictable and the memory pool may become fragmented, resulting in unexpected allocation failures. In this session the problems will be outlined in detail and an approach to deterministic dynamic memory allocation detailed.
Continuous Integration and Continuous Delivery are a great fit for embedded IoT devices, and it has never been easier to get started with it. CI/CD lets you perform automated code quality and functionality tests against your firmware and software prior to it being deployed to your fleet.
I will build a container-based CI/CD pipeline using Concourse CI using a popular IoT based embedded platform. I will review the design of the CI/CD pipeline, showing all the details to build your own and conclude with a demo showing the full workflow from source code commit to automated update using the CI/CD pipeline.
Easy Embedded Security Integration with STSAFE and STM32CubeMX
Presented by John Tran
Presented by STMicroelectronics
During this technical talk session, you will learn how to quickly integrate Secure Element STSAFE into your new or existing STM32 MCU applications. We will show you how easy the process can be using STM32CubeMX development platform. Harness the power of STSAFE embedded security features to implement authentication, signature verification, key pairing and more.
Artificial intelligence is a rapidly developing technology, which has already strongly affected our lives in many ways. However, for the traditional embed area, due to the limitation of the constrained resources such as CPU frequency and small RAM, high performance AI is quite hard to implemented. In our topic, by using the combination of the RT-Thread OS and the RISC-V processors, we will show its high performance and low costs on Edge AI computing. Firstly, we will introduce the relationship between the RISC-V and the RT-Thread OS. Secondly, a detail process for transplanting RT-Thread OS on the RISC-V processors will be demonstrated. Thirdly, a rapid Edge AI deployment platform for RT-Thread OS named RT-AK will be showed, and its principle and usage will be analyzed detailedly. At last, we will demonstrate RT-AK, on a RISC-V processor, we will implement two typical Edge AI applications with C programming and Python programming respectively.
Until recently, the key platforms in the embedded space were the microcontrollers, microprocessors, and FPGAs. But now the playing field is changing. With the inclusion of GPUs, AI accelerators, Blockchain Chips within the embedded ecosystem the whole field is primed to explode into the new era. I believe that this new era of embedded will be powered by and based on Edge Computing.
Edge Computing can be described as a paradigm of traditional artificial intelligence. It aims at bringing AI and ML closer to the edge. Executing the models on the edge nodes rather than on the centralized servers. This idea has many advantages. Applications of the same have started popping up in the industry at various places.
This short talk introduces the concept and idea behind edge computing. We look at the advantages and disadvantages currently present in the technology. We further explore Fog Computing, a sub-part of edge computing in detail. Taking real-world examples, we predict the future of technology.
Edge Computing: Reshaping the Agricultural Sector with Smart Farming Practices
Presented by Dr Bala Murugan MS
In order the manage the crop efficiently and continually, a drone fitted with a camera will be used to take pictures aerially. These pictures will be transmitted to the data processing system as part of the Intelligent Crop Monitoring and Warning System. A platform built on the Internet of Things and Artificial Intelligence processes these images. These images can help determine the stage of infestation, the crops affected, how to prevent the spread of the disease, and what types and amounts of pesticides to use. These UAVs can also protect crops from animal and human predators. The purpose of agricultural drones is to optimize agricultural operations, increase crop production, and monitor crop growth. Farmers can monitor their fields using sensors and digital imaging. Crop yields and agricultural efficiency can be improved by collecting information using agricultural drones.
Efficient Arbitrary Resampling using Frequency Domain Techniques.
Presented by Wessel Lubberhuizen
It is well known that filtering can be done very efficiently in the frequency domain. It is usually assumed that the input and output sampling frequencies need to be the same, or integer multiples of one another. In this talk I will show how frequency domain filtering can even be applied when the input and output sampling rates are completely arbitrary, i.e. not related by an integer or even a rational factor. The approach can be used for communications systems and audio applications.
Efficient DDC Implementation for Analytic Signal Processing
Presented by Jim Shima
Abstract: Most sampled systems rely on real-valued ADC data that is then converted to complex-valued (analytic) signals for processing. Examples include comm demodulators, channelizers, adaptive beamforming, phase interferometry, etc. Since conversion to complex-valued (I/Q) happens at the native sample rate post ADC, it uses an everly increasing number of MACs (multiply accumulates) per sec. This equates to more power draw for a given system, and efficient implementations bear the most fruit in mitigating computational load.
Description: Recall, analytic signals can be created using a Hilbert transform or using the modulation property of a half-complex mixer. Digital down converters are heavily used in SDRs and direct-sampled RF digital systems to mix signals to baseband, create analytic signals from real-valued inputs, and reduce the bandwidth of said signals (via resampling) to a more usable sample rate. Efficient filters such as the Hogenauer (CIC) were developed decades ago to help mitigate the use of multiplications during resampling. This talk goes over a very efficient implementation of a specific DDC that performs 2x decimation, does not use any multiplications for the mix operation, and only requires one FIR filter to create I/Q samples from real-valued inputs. This results in 4-8x reduction in computations compared to brute-force classical techniques.
Electromagnetic Fault Injection Made Easy with PicoEMP
Presented by Colin O'Flynn
Electromagnetic Fault Injection (EMFI) is a powerful method of injecting "faults" into devices, which can be used for both security and safety evaluations. Various platforms for EMFI exist (including the ChipSHOUTER tool Colin has designed), but they are often overkill when it comes to performing basic work or trying to get started with EMFI. This talk introduces the PicoEMP, a low-cost EMFI tool Colin designed and released as open-source hardware. Coverage of the theory behind EMFI along with how to build your own PicoEMP will be covered, including some recent examples of real-world usage.
Frogs, mycellium, albatrosses. Unexpected organisms that share similarities with embedded systems! Get ready to embark on a journey through the elements as we will explore robot prototypes that are deployed in terrestrial, water, and wind settings. In these settings, the three organisms will serve as inspiration to describe nature's analogue to the tech behind the robots.
Eliminate Programming and Test Connectors with Tag-Connect Plug-of-Nails ™ Programming Cables
Presented by Tag-Connect
Save Cost and Space on every board by replacing bulky and expensive traditional JTAG connectors with a tiny footprint of pads and holes in your board. Tag-Connect's comprehensive range of Programming Cables and Adapters connect directly to the PCB footprint without needing any mating connector on your board. Tag-Connect - No Header - No Brainer!
Embedded AI: Leveraging AI Agents for Smarter Development
Presented by Jacob Beningo
Artificial intelligence (AI) is transforming how software is developed, tested, and deployed; yet most embedded engineers have barely scratched the surface of what AI can do for them. AI agents, in particular, have the potential to accelerate development workflows, automate repetitive tasks, and enhance productivity in embedded systems. But where do you start?
In this workshop, we’ll demystify AI agents and explore how embedded developers can integrate them into their daily workflow. We’ll begin with a one-hour lecture, covering key concepts such as AI agents, their architectures, and their role in embedded development. You’ll learn how to leverage AI tools for code generation, debugging, and optimization and see real-world examples of AI-powered automation in embedded projects.
The second hour will be hands-on, where participants will connect an AI agent to GitHub, explore practical AI tools, and experiment with automating everyday embedded development tasks. By the end of the session, you’ll have first-hand experience using AI in an embedded context and a clear roadmap to continue integrating AI into your workflow.
Key Takeaways:
What AI agents are and how they apply to embedded systems
How to connect an AI agent to GitHub for automation
Exploring AI-powered tools for embedded software development
Hands-on experience with AI-driven code generation and optimization
Strategies for integrating AI into your embedded development workflow
Join us for this practical and forward-looking workshop to explore how AI can enhance your embedded software development processes today!
This talk is mainly focused on embedded engineers who write embedded codes for devices using C as their main language. There have been code bugs in millions of products around the world due to memory mismanagement and one of the causes of this crash is having multiple returns within a function. So I will be discussing extensively the recommended standards and rules to follow when programming embedded devices and why single exit point matters.
In these modern times of chip shortages, the need for flexibility and portability in the design of embedded products has been pushed to center stage.
There are three main factors that tie your development to a particular microcontroller: the RTOS, the toolchain, and the peripheral controllers. This presentation describes the embedded development practices Tuxera uses to free users of microcontroller dependency, in order to make their software solutions portable – an absolute must for an embedded software company. Your product expertise should not be held hostage to the global supply chain problems. By making good design decisions early in the development process you can make it easier to move to alternative architectures when unexpected supply chain issues appear.
Embedded Development with Qt: Exploring Use Cases Beyond MCUs and MPUs
Presented by Veli-Pekka Heinonen
Presented by The Qt Company
You may already be familiar with Qt's ability to support the entire embedded software lifecycle – from design and development to testing and deployment – but Qt can support a variety of use cases beyond the traditional. During this session, we will explore conventional scenarios, as well as newer innovations, such as WebAssembly and other solutions. Additionally, we will provide an overview of piloting Qt usage in the cloud and a Qt angle to Digital Twins.
Embedded DevOps: Hardware in the CI Loop and the Transformative Power of Sharing Work-in-Progress
Presented by Darwin Sanoy
It took 36 years for humans to be able to dominate the computer game Tetris and it happened because of a need that forced global sharing of gaming expertise.
Traditionally, embedded software development has been tethered to workstations due to the necessity of interfacing with embedded hardware. However, as technological advancements increasingly liberate embedded developers from desk-bound constraints, the ingrained habit of work-in-progress isolation persists. This deeply rooted practice makes it challenging for teams to benefit from shared wisdom and collaboration.
Collaborative innovation is not possible if work-in-progress is not shared as it is being done. If you reflect on your habits to gain expertise, you might notice that you're doing those searches "while you work". Sharing work-in-progress also allows other sources of expertise to be a part of your expertise searching such as AI and automated testing.
Things you will learn:
That sharing work-in-progress is foundational to benefiting from collaborating agents.
Software engineering expertise sharing through code reviews.
Shared software manufacturing expertise sharing through CI automation.
Automated sharing of costly physical hardware resources.
A culture of continuous wisdom transfer grows internal talent.
This session is about breaking free from the inertia of isolated practices and transforming work-in-progress into a shared, collaborative activity that accelerates innovation.
Attempting to add-on AI and ML modeling to existing IoT networks delivers marginal results compared to when it's designed into the architecture. Organizations that have accomplished this in their IIoT/IoT architectures can support model processing in multiple stages of their solution while reducing networking throughput and latency, making everything more purposeful and even more secure.
Embedded Software Programming Rules, Tips and Tricks
Presented by Jean Labrosse
In this class, I will provide some of my favorite Embedded Systems Programming rules, tips and tricks. Specifically, I’ll cover some good design, coding and optimization techniques as well as things that will improve the overall quality of your code. Finally, I will also provide references to must have books.
Embedded System for IoT in Rural : A Proposed Solution
Presented by Agus Mulyana
Embedded systems have an important role for the internet of things. This unit usually consists of a microcontroller, sensors, actuators and an energy source. For IoT in rural areas, it has its own challenges, due to unstable internet network conditions which can reduce system performance, wasteful energy consumption and can cause the system to malfunction. To overcome this, it is necessary to design embedded systems specifically to anticipate these problems
Computer vision is being revolutionized by advances in artificial intelligence and edge hardware. By applying Deep Learning, computers can detect features in images more reliably and more effectively than the human eye. Integrating computer vision into embedded systems creates powerful new functionality, exciting new use-cases, and opportunities for entirely new products. Present-day capability and applications are merely scratching the surface of computer vision’s potential, which according to Forbes magazine is essential to the Forth Industrial Revolution. Deploying computer vision in embedded systems however presents considerable technical challenges, in particular requiring knowledge of camera optics and advanced image processing techniques. In this session, Peter McLaughlin will provide a broad introduction to computer vision in the embedded system space. Topics covered include computer vision technologies and their use-cases, camera types and data interfaces, optics, image processing and hardware requirements. Attendees will walk away armed with information to help them get started with embedded vision and apply it to their projects.
emlearn - Machine Learning for Tiny Embedded Systems
Presented by Jon Nordby
Modern Machine Learning makes it possible to automatically extract valuable information from sensor data. While Machine Learning is often associated with costly, compute-intensive systems, it is becoming feasible to deploy ML systems to very small embedded devices and sensors. These devices typically use low-power, microcontrollers that cost as little as 1 USD. This niche is often referred to as "TinyML", and is enabling a range of new applications in scientific applications, industry, and consumer electronics.
emlearn is an open-source Python library that allows converting scikit-learn and Keras models to efficient C code. This makes it easy to deploy to any microcontroller with a C99 compiler, while keeping Python-based workflow that is familiar to Machine Learning Engineers. The library has been used in a wide range of applications, from the detection of vehicles in acoustic sensor nodes, to hand gesture recognition based on sEMG data, to real-time malware detection in Android devices.
In this presentation we will give an introduction to the emlearn project. We will cover the models that are supported, the key features and tools that are provided, and demonstrate how this can be used to solve Machine Learning tasks: classification, regression and anomaly detection - with relevant examples to embedded systems.
Employing TSN Over Ethernet to Enable Precision Motor Control Through Operator Gesture
Presented by Nicolas Lehment
Presented by NXP
TSN allows designers to combine multiple real-time applications on the same cable, even with multiple protocols.
This demo shows the i.MX 8M Plus processor, i.MX RT1170 MCU and Layerscape LS1028A using different protocols such as Profinet and Open Platform Communications Unified Architecture (OPC UA), as well as custom motor control messages over TSN Ethernet in a complex industrial system.
Enabling Motor Control Across a Range of NXP MCUs with MCUXpresso and FreeMASTER Visualization Tools
Presented by Jaroslav Lepka
Presented by NXP
Join this session to explore the latest NXP motor control solutions, tools, and expert advice for creating cost-effective and energy-efficient motor control designs using NXP MCUs.
Enabling Rapid Prototype for Physical Interaction Design Using A M5Stack Core
Presented by Dr. Don Wilcher
The M5Stack Core is an ESP32 microcontroller-based controller that allows a variety of wearable, Human Machine Interface (HMI) and Human-Computer Interaction (HCI) devices to be developed quickly. This microtalk will discuss enabling rapid prototyping for physical interaction design using the M5Stack Core. A set of prototyping, software tools, and circuits will be provided in this microtalk.
Enabling the Future of IoT with RISC-V Next Generation Processor
Presented by Tzu-Shun Huang
RISC-V is a free and open-source licensed processor that can be developed by anyone using standard tools. As it becomes more widely adopted around the world, its applications are becoming more varied. Engineers are applying RISC-V to all kinds of applications including AI, IoT, and automotive. Through years of interaction with customers, Andes has become a professional in designing details that are important to SoCs. AndesStar comes with V5 architecture with extensions. In this talk, we will introduce the next generation processor features that are designed to fit upcoming AI, IoT, and automotive applications.
Arm's TrustZone technology, available on Arm application processors for many years, was released for microcontroller cores a few years ago and is now becoming common in the leading microcontroller vendor product lines. While TrustZone provides some very valuable and relatively simple technologies for securing embedded systems, once enabled, it can be significantly difficult to set up and manage. This talk will focus on what TrustZone is, and how IAR's security add-on tools can enable a secure boot based system using TrustZone to be implemented simply while utilizing all of the features afforded by the new technology.
Ensuring Data Integrity Using Blockchain With Toradex Torizon
Presented by Mohammed Billoo
The blockchain has seen explosive growth in the past few years, especially with the advent of cryptocurrency. The blockchain has also become popular in the IoT space, as a mechanism to verify the integrity of data collected by sensor nodes. In this presentation, Mohammed provides an overview of the blockchain and its different uses and applications in the IoT. He also provides a demonstration on a Toradex SoM and carrier board running Torizon which implements a simple blockchain solution. In this example, data is collected on the device and added to the blockchain. Finally, the integrity of the data on the blockchain is verified.
Digital transformation is accelerating the evolution of IoT-to-Cloud architecture. Technology innovation from Silicon to Software, that initially was intended for cloud computing is now fast making its way to the end-point devices at the edge of the network. As a result, the edge devices are in the cusp of becoming way more smarter than they have ever been to take collaboration to the next level. Video and Audio are collaboration’s key corner stone technologies. A combination of modern Machine Learning techniques and traditional signal-processing techniques are bound to change for good how we collaborate in the future.
Envisaging Real-time Industrial and Intelligent Applications leveraging the Edge AI Paradigm
Presented by Pethuru Raj Chelliah
There are a bevy of digital transformation technologies and tools emerging and evolving fast in the recent past in order to fulfill the digital life dream. The strategically imperative combination of edge/fog computing and artificial intelligence (AI) paradigms is being touted as the distinct innovation and disruption for enterprises to visualize and realize next-generation software services and applications.
This talk is primarily intended to convey the latest trends and transitions happening in the edge/fog computing space, artificial intelligence(AI), the Internet of Things (IoT), block chain, digital twins, 5G, real-time and streaming data analytics, industry 4.5 vision, edge device monitoring, automated edge application deployment, governance, orchestration and management, etc. There are AI chips exclusively to be used in edge devices to accelerate intelligent processing at edge. There are AI toolkits and platforms for facilitating edge intelligence. The proposed talk covers all these noteworthy developments in order to accentuate and articulate how the latest improvisations at chip, algorithm, and tool levels come handy in implementing and sustaining the relatively new field of edge AI. The talk also will cover the various industrial use cases such as smart factories, self-driving vehicles, robots-assisted surgeries, etc. out of the delectable technology clusters.
Edge AI (alternatively termed as intelligent processing at edge, edge intelligence, intelligent edge or intelligence at edge) is being proclaimed as the next-generation technology paradigm to realize real-world intelligent applications and services for accelerating, augmenting and automating most of the industrial as well as people activities in real time. Capturing, cleansing and crunching edge device data in real-time can bring forth a number of real-time applications. Further on, with the increased usage of data analytics and AI toolkits in edge devices, business houses and commoners can gain hitherto unknown, sophisticated and situation-aware services.
The ESP32 is a low-cost microcontroller System-on-a-Chip (SoC). An SoC is a microcontroller that integrates a computer's or device's components into a single chip. The ESP32 includes a microprocessor, memory, various interfaces and peripherals, and integrated WiFi and Bluetooth capabilities. To use the ESP32 microcontroller in various industrial products and applications like temperature controllers, motor controls, object sensing/detection, and visual alarm indicators, an understanding of basic input/output electronic circuit interfaces is required. A basic I/O primer will allow the development and testing of control application code to be created by the software developer. This talk will explain basic I/O interfacing circuit techniques using electrical and electronic components like tactile pushbutton switches, transistors, and sensors. The talk will include operating electromechanical and solid state relays (SSR) using an ESP32 microcontroller. Circuit diagrams and basic microcontroller code will be presented in this talk.
As embedded engineers, we love data. Our desk is littered with tools that help capture tons of data, such as oscilloscopes, logic analyzers, debuggers, tracers, and power meters. However, once a device (or thousands) leave our desk and are shipped to customers, all of these tools are paperweights. It's now up to the devices to report issues back to the developers.
This is where metrics come in. Throughout my career, metrics have been the most powerful and simplest way to monitor thousands to millions of devices. This talk covers what metrics are, how to capture them, and explores the seemingly infinite metrics you can capture and creative uses to help you solve real-world, elusive device issues, such as power consumption, performance, and battery life issues.
Essential Skills for Embedded Systems Engineers to Have
Presented by Stephane Boucher
Pre-conference release
We've asked some of our speakers what they think are some of the essential skills that Embedded Systems engineers should have these days. Feel free to share you own opinion on the matter by adding a comment.
Everyday Usage of UML State Charts for Your Embedded Application - Minimization of Code
Presented by Ismet Faik Saglar
This presentation will show you how UML State Charts are used to design the behavior of the main functionality without coding.
Next, you will learn the best practices for design re-use.
After that, simulation and automatic testing of the designed UML state charts will be shown.
And finally, you will learn several alternatives to integrate the designed UML state charts with the embedded source code.
In the session, C language and generic ARM Cortex-M CPU board will be used for demonstration. IAR Visual State Software will be used as a design, simulation, automatic testing and code generation tool.
Example of BDD Style TDD For Embedded System Software
Presented by Steve Branam
Based on the blog post https://www.embeddedrelated.com/showarticle/1544.php and repo "Bit-Banged Async Serial Output And Disciplined Engineering" and under the aegis of Dojo Five, this session walks through a practical example of using the Behavior-Driven Development style to perform Test-Driven Development to develop an embedded system software module.
BDD adds several advantages to TDD:
It results in an executable specification of a module that is understandable by both technical and non-technical stakeholders. This makes it easier to understand by all parties, and easier for them to specify additional behavior.
Because of its emphasis on behavior, it guides the developer to test to interface, not internals. This minimizes the risk of creating brittle tests. That minimizes the need for test maintenance when doing production code maintenance: changing the internals doesn't create a mass of failing tests.
It focuses on one aspect of behavior at a time. This ensures that tests only test one thing at a time, keeping them simple. When a test fails, it's clear what failed and what should have happened. That makes isolating and fixing the problem faster.
It avoids code bloat and untested code, since every bit of production code is there because a behavioral test required it.
This additional layer of discipline makes TDD even more effective for both immediate development and long-term maintenance. It's easily applied to embedded systems modules to enable off-target testing, resulting in known-good components. It works equally as well when you start with a well-defined idea of what the module internals will be and when you only have a vague idea.
Programmers often focus on designing the "happy path" for their code—the scenario where everything goes smoothly, values are within range, and no timeouts occur. However, this emphasis can come at the expense of a program's robustness: its ability to continue operating effectively when exceptions or unexpected conditions arise.
In this workshop, participants will actively explore run-time options for handling exceptions, including techniques like global and local error indicators, return values, immutable sections of code, goto chains, and try-catch mechanisms. Through hands-on exercises, you'll learn how to implement these approaches with minimal extra code and complexity.
By the end of this workshop, you'll have practical strategies for building more robust and reliable programs, ensuring that your code can gracefully handle the unexpected while maintaining simplicity and clarity.
Update 10/28: Please find here the Installation Guide for the tools that you can optionally install if you want to be able to run the example files
Are you capturing real-world waveforms and striving for pinpoint accuracy in your measurements? Whether you're working with single tones, broadband noise, or arbitrary waveforms in the analog or digital domain, this workshop is designed for you!
Explore advanced but user-friendly frequency and time domain methods applicable to the assessment of signal to noise ratios and EVM (error vector magnitude) for communications waveforms, number of effective bits in A/D conversion, or any application where an accurate measurement of noise is critical.
Learn from a seasoned expert the industry-leading techniques that push the boundaries of traditional test set-ups. The workshop will feature practical “cookbook” techniques using Python (with similar methods in MATLAB and Octave) and provide in-depth insights into both the effective use and potential pitfalls of these methods.
In this engaging session, you will:
Master FFT-based techniques for single tone measurements of any frequency without any concern for scalloping loss.
Extend the accurate measurement of single tones to multi-tones and broadband arbitrary waveforms.
Achieve sub-dB precision in broadband noise density measurements.
Optimize signal capture duration using the Allan Deviation statistical tool.
Don't miss this opportunity to refine your measurement skills and overcome common limitations. Whether you're a seasoned professional or new to the field, you'll leave with actionable insights and hands-on techniques to elevate your waveform measurement capabilities.
Explore Meadow.Foundation for Seamless Integration of Sensors and Peripherals into C# .NET IoT
Presented by Jorge Ramirez
In this session, we'll unveil the immense potential of Meadow.Foundation, an open-source treasure trove of drivers that empowers your C# .NET IoT creations. With support for a huge range of peripherals—over 200 and counting—Meadow.Foundation opens the door to a world of creative possibilities. Imagine seamlessly incorporating standard off-the-shelf hardware, from vibrant displays to precise environmental sensors, into your projects with unparalleled ease.
We'll showcase real hardware and demonstrate how, with Meadow.Foundation, you can swiftly transform your concepts into reality. Through code demos, you'll witness firsthand how a few lines of code can breathe life into sensors and peripherals.
Whether you're a seasoned developer seeking to expedite your IoT journey or an enthusiast curious about the world of C# .NET IoT, this session is your gateway to streamlined innovation. Join us and be part of a revolution that empowers you to create with confidence and efficiency.
Exploring Node-RED IoT Widgets With The Raspberry Pi
Presented by Dr. Don Wilcher
In this conference talk, information will be presented to participants on creating embedded IoT concepts using Node-RED Widgets. The conference talk Agenda will consist of the following topics.
1. What is Node-RED? 2. Review of the Node-RED Website 3. Introduction to Node-RED Dashboards a) What is a Dashboard? b) Widget Nodes: Key parts of a Dashboard 4. Mini Lab Activity: Creating a simple Raspberry Pi IoT based Dashboard with Interactive Widgets 5. Lab: Creating an IoT Temperature Sensor Simulator
This conference talk is for participants exploring development tools and approaches to developing interactive IoT dashboards for Industry 4.0 applications using off the shelf components.
Exploring the Arm® TrustZone® Feature on LPC5500 Series MCUs
Presented by NXP
Arm TrustZone technology, available with the LPC5500 MCU series based on Arm® Cortex®-M33 core, provides the means to implement separation and access control to isolate trusted software and resources to reduce the attack on critical components. Watch this secure GPIO TrustZone example to better understand how to implement this feature within your design.
Exploring the ESP32 based M5Stack Core WiFi Applications
Presented by Dr. Don Wilcher
This talk will discuss the ESP32 with WiFi from the perspective of the M5Stack Core. The ESP32 WiFi architecture will be explained in the presentation. The following talking points for the discussion will consist of the following topics.
Seminal Research Perspective on Communication Systems.
ESP32 with WiFi Introduction
M5Stack Core WiFi Setup
Build a basic M5Stack Core WiFi Scanner
Build a M5Stack Core Access Point and Web Server Controller
The two build projects will align with the ESP32 with WiFi discussion and provide physical examples participants can explore on the bench.
Today’s code editors are very powerful tools that offer syntax highlight, code completion, versatile search, variable browser, function browser, hover-over and jump to declaration/definition, etc. However, even with these amazing features, you are still staring at a few hundred lines or so of source code, putting you straight in front of a proverbial tree thus missing the view of the forest.
There are literally dozens of software modeling methods and methodologies, yet many embedded software developers jump directly to the coding aspect, often bypassing an important step that would help you understand and document the structure of an application. That being said, I’m not trained in most of these formal methods however, I use graphical techniques adapted to software from my Electrical Engineering background.
This class will explore some of the techniques that served me well when designing and architecting applications. As simple as some of these techniques might be, they have helped me develop complex applications.
Extracting Microservices from a Ports-and-Adapters Architecture
Presented by Burkhard Stubert
A typical application controlling a machine interfaces with users, with the actuators and sensors of the machine, with cameras, with the IoT cloud, with local and remote databases, with a fleet management server, and with other system parts. The application core, which implements the business rules, must not know which technology components are used to communicate with the user, machine, cloud, or database. Well-defined ports (interfaces) hide the implementation of the adapters (components) from the core. This is the ports-and-adapters architecture in a nutshell.
The ports-and-adapters architecture leads to loosely coupled and cohesive components with well-defined interfaces. This sounds a lot like a microservice architecture, doesn’t it? It does, indeed—with one difference. Microservices run in their own processes (often on different computers) and talk to each other over a lightweight protocol. In contrast, the ports-and-adapters architecture is mostly implemented in a monolithic application running in a single process. The core and adapters communicate through function calls.
We can find good reasons to extract adapters from the monolithic application as services. The application keeps a proxy for the extracted service. The proxy and the service implement the same port. The proxy and service are very much like the two USB ports connected by a USB cable. Here are two examples.
These days, the main HMI application should have a component performing OTA updates of the embedded Linux system. OTA updates require root privileges. For security reasons, user applications should not have root privileges. If we extract an update service from the application, the application can run with user privileges and the service with root privileges. Only a properly authenticated application may use the service.
HMIs of agricultural and construction machines provide functionality for normal operation by the driver and for diagnosis by a support technician. When we split the monolith into two applications accordingly, we face a resource-sharing problem. If one application reads a message from the CAN bus, the other application will never see this message. The solution is the introduction of a service doing all the CAN message processing and replicating the messages for all the interested applications.
As long as it makes sense, we can transform the adapters from our applications into services. As the services will most likely implement the ports-and-adapters architecture, we may be able to identify even more services. The operating-system and hardware-abstraction layers are fertile ground for more services. The applications and services use inter-process communication like DBus or gRPC to talk to each other.
We have transformed a few monolithic applications into several smaller applications and services talking to each other over a lightweight protocol. In short, we end up with a microservice architecture, where each microservice (including applications) implements the ports-and-adapters architecture.
Electric motors are the fundamental actuators in any factory shop floor. Their control and synchronization for proper operation relay key embedded components with real-time, safety, security and connectivity capabilities. NXP’s comprehensive portfolio for motor control applications in the industrial automation segment provides the right combination to enable fast product development.
Factory Automation: NXP Solutions Bringing AI & ML to Embedded Applications
Presented by Nicolas Lehment
Presented by NXP
As AI methods gain maturity, we see interpretation and decision making migrate from industrial PCs or datacenters into embedded devices. This change puts new demands on both the embedded processors and the tooling used to design and implement these systems.
In this session we examine why industrial applications benefit from embedded AI and how NXP devices support the shift of intelligence to the edge.
Thank you for your interest in the Fast Track to Designing FIR Filters with Python workshop! Below are the installation instructions as well as a Jupyter Notebook with the material that will be presented in the workshop.
Being able to run Jupyter Notebooks is not necessary for the workshop but convenient as I am sharing the details of the workshop in the attached Jupyter Notebook for future reference. If you would like further basics on running the Notebook, please see this link:
Finite Impulse Response (FIR) filters are the more popular of the two main types of digital filter implementations used in DSP applications. In this workshop, we will go through best practice approaches for optimized FIR filter design and implementation using the free and open-source Python programming language. This will include the common techniques for going from filter requirements to practical implementation and demonstrate both creating FIR filter designs as well as evaluating filter frequency responses using the Python language and its signal processing library.
This workshop will include:
Complete setup to get Python up and running for signal processing applications.
Summary of the high-level approaches to FIR filter design – which are best and why?
Fast track to using the signal processing library in Python for creating FIR designs.
The complete design flow for FIR filters from specification through verification.
Using Python for filter evaluation, including plotting magnitude and phase responses.
Finding Needles in the Haystack - Device Observability and Anomaly Detection
Presented by Dr. Johan Kraft
Due to the risk of software defects and vulnerabilities, effective means for detecting and analyzing behavioral anomalies in device software is key for ensuring secure and reliable operation. Traditional logging is however not effective for large-scale deployments. Watch this presentation to learn about an alternative approach where anomalies are detected directly in the device and reported in a structured way to ensure nothing is missed. This allows for providing detailed information when it matters, while keeping the overall data uploads to a minimum. The presentation is concluded by a demonstration.
Electromagnetic Compatibility (EMC) is a crucial factor in embedded product development. EMC measures how well electrical devices can function without performance degradation when exposed to EMI (electromagnetic interference, or energy released from other electrical devices) and ensures that device radiation does not affect the operation of other devices. While EMI is the problem, EMC assesses how effectively that problem can be managed.
Typically, the first time system designers realize they have a radiated emission problem is after the prototype system has been built and evaluated. In such situations, costly and ineffective patches are often applied, often necessitating a redesign. Electronics hardware and firmware coexist, and depending on factors such as time-to-market, cost, and resources, one must choose the best possible solution to address EMC issues.
In this talk, we will highlight methods a firmware developer can follow to achieve good electromagnetic compatibility.
Firmware Co-Design & Development for IP Cores in C++/SystemC using Verilator
Presented by Amir Alavi
Co-design of software and hardware for FGPA-based embedded systems has become a major challenge for tech companies, pushing them to follow development processes that require special care to lower the risks. The risk becomes a major factor for system on chip (SoC) solutions with integrated intellectual property (IP) cores that require custom firmware or driver development. A solution to this problem that has received a lot of interest in the last few years is by simulating the IPs and using them to design and validate the corresponding software stacks. Verilator is an open-source tool that is specifically developed for this purpose to simulate the IPs written in Verilog or SystemVerilog hardware description languages. In this talk, I am going to discuss the following topics for the audience:
A brief introduction to SystemC and simulation of logic blocks in C++
Common processes for co-design of firmware and FPGA IP cores
Introduction to Verilator and using it for creating simulation models from IP cores
Protecting IPs by encrypting their simulated models and sharing pre-releases
An example workflow for Verilog IP simulation and firmware design in C++
Analysis of simulation results with open source tools
Real-time simulation of verilated models with QEMU for system integration
Five considerations when building secure IoT devices
Presented by Mohit Kedia
Presented by Arm
The ongoing Internet of Things (IoT) revolution is bringing online billions of devices, from fridges to traffic lights, connected and controllable from afar. Industry verticals like Utilities, Telecom, and other service providers encounter increasing security regulations, and a need to automate field equipment reading, billing, and service status updates.
Industry adoption of IoT is going to grow. For example, it is expected that there would be more than 2.5 Billion IoT devices in Power and Energy vertical by 2023. These IoT deployments are a growing target for cybercriminals; exposing individuals, their data and their privacy to risk if security is left unaddressed. For example, 250,000 peoplein Ukraine were left without power when attackers used “Crash Override” malware to take control of power gridresulting in a shut down of 30 power substations. As a result, industries that deploy IoT will demand security that is integral to the devices and manageable through remote device management.
For device makers, this market trend underscores the need to ‘design in’ security into the devices.For example, an IoT device that has secure root of trust, remote authentication, over-the-air software patching capabilities, and other features that proactively mitigate security vulnerabilities. In order to minimize threats at each stage of a IoT device’s life cycle and to ensure security in every IoT deployment, we need to answer following key questions,
How to efficiently store the secrets such as device keys?
How to create secure processing environment for tiny IoT sensors?
How to ensure the data I communicate between the device and the cloud is private?
How to track abnormal behaviour of the device when it is compromised?
How to securely update the firmware of a device?
This session will present these considerations to help you identify the best approach to secure your devices for scalable IoT.
Fixed-Point Filters – Modelling and
Verification Using Python
Presented by Dan Boschen
NEW: All files related to this workshop have been zipped and can be downloaded by clicking on the link in the left column "Click Here to Download Slides (PDF)"
Digital filters are commonly used in the processing of signals, whether they be wireless waveforms,
captured sounds, and biomedical signals such as ECG; typically for the purpose of passing certain
frequencies and suppressing others. Fixed-point implementation is attractive for lowest power lowest
cost solutions when it is critical to make the most out of limited computing resources, however there
can be significant performance challenges when implementing filters in fixed-point binary arithmetic.
When a fixed-point implementation is required, a typical design process is to start with a floating-point
design that has been validated to meet all performance requirements, and then simulate a fixed-point
implementation of that design while modifying the precision used to ensure the requirements are met.
In this workshop, Dan takes you through the practical process of simulating a fixed-point digital filter using open-source Python libraries. This is of interest to participants wanting to see a motivating example for learning Python as well as those with experience using Python. Also included: a quick recap of basic filter structures and filter performance concerns. A significant background in Digital Signal Processing (DSP) or digital filter design is not required. Having taken an undergraduate Signals and Systems course is sufficient. For a more detailed review of binary fixed-point operations and notations that will be used in this workshop, please attend Dan's Theatre Talk "Fixed-Point Made Easy: A Guide for Newcomers and Seasoned Engineers" that will be scheduled before this. After attending this talk, the participants will be equipped to confidently convert a given filter implementation to fixed-point prior to detailed implementation. If you have a floating-point filter design and need to implement it in fixed-point, this workshop is for you!
Fixed-Point Made Easy: A Guide for Newcomers and Seasoned Engineers
Presented by Dan Boschen
Fixed-point implementation is popular for lowest power, lowest cost solutions when it is critical to make the most out of limited computing resources. However, the jargon and rules can be overwhelming to newcomers and seasoned engineers alike.
In this theatre talk, Dan will guide you through the common representations and rules for working with binary fixed point. This will include the Q notation for fractional number representation, two's complement, signed and unsigned numbers, considerations for truncation, rounding and overflow, and easy to follow rules for binary arithmetic. There will be plenty of fun examples to demonstrate the key concepts and practical use of the methodologies. If you are new to fixed-point or rusty and would like a refresher, this talk is for you! This would particularly apply to anyone that needs a recap on fixed-point and is interested in attending Dan's talk "Fixed-Point Filters - Modelling and Verification Using Python".
Even those exposed to fixed point in the past will appreciate this work-out session to quickly get back in top fixed-point shape!
Flexible and Layered Embedded Firmware through Test Driven Development (TDD)
Presented by Alexopoulos Ilias
Recent years the software industry has developed different methodologies with camps to support them many of them claiming better quality of work and speed. Embedded real-time firmware due to it's challenges makes adoption of these tools more difficult as we need to test systems interacting with the hardware that have timing constraints. Not all methods work well or there is often the question if the effort is worth the benefit.
In this session we will discuss the application of TDD,
what is TDD and the difference with unit testing,
example application of the method,
how we can model the hardware registers transparently,
how to tackle challenges porting to different architectures,
using object oriented techniques for configurability
the benefits and pitfalls of the method,
The session will be based on actual application of the method on real medium scale bare-bones systems projects.
FlexLink, a Practical OFDM Datalink, Introduction and Python Demonstrations
Presented by Leonard Dieguez
This presentation can be described as a technical deep-dive into the design and implementation of the FlexLink waveform, specifically tailored for drone communication systems. It covers both theoretical and practical aspects, providing an in-depth look into the key elements of the waveform, such as the Burst, Preamble A, Preamble B, first control signal with references, and Payload A.
In addition to the technical breakdown, the presentation includes a live demonstration of how Python-based model design code runs, showcasing the practical implementation of the waveform. The focus is on how this waveform optimizes communication in high-mobility environments, specifically on drones, and how its features support real-time video transmission, telemetry, and control.
Description of the Presentation:
Content Focus: Detailed exploration of FlexLink waveform elements and how they apply to the waveform and drone communications.
Hands-On Demonstration: Demonstrating Python code for model-based design, bridging theory and practical implementation.
Target Audience: Engineers, designers, and technologists interested in RF waveforms, drone communication systems, and model-based design.
Outcome: Attendees will gain an understanding of how FlexLink is implemented in real-world UAV applications, including insights into the signal structure, operational advantages, and how to use Python for performance modeling.
This presentation serves as both an overview and demonstration that blends knowledge with practical coding and design applications.
Flight Software Design for Lunar Exploration: A Case Study
Presented by Jacob Beningo
A typical satellite flight computer will often directly control its propulsion system. Direct control, while convenient, adds hardware and software complexity to a flight computer system that is often already overburdened with duties. In the CAPSTONE mission to the moon, the Stellar Exploration Inc. propulsion module was used to uniquely decouple propulsive maneuvers from the flight computer to a propulsion controller.
This session will explore the techniques and tools employed to create robust flight software for Capstone's propulsion controller. Attendees will gain insight into modern development processes, tools, and techniques through real-world examples and learn how software architecture was broken down and implemented as a quasi-microservices architecture. Additionally, we will showcase how RTOS task code was modularized and how configuration tools were utilized to manage RTOS tasks automatically.
Topics covered in this talk will include:
Software architecture best practices
How to write mission configurable flight software
Modern development software processes such as unit testing, DevOps, etc
Flight software quality analysis
Examples from CAPSTONE, an Artemis mission to Lunar orbit
Preparing a firmware image has never been so easy. Avoiding the struggles to implement a custom software update procedure. Facilitating even more the developer life. Freeing time to concentrate on the actual business logic of the application. All these targets are reachable if you start your next product development from the implementation of the chosen software update strategy. Leveraging all the community-backed implementations of common best-practices will help your team in delivering safer and maintainable products to the market on schedule. I will briefly show you how to have a FOTA-first approach with the Yocto Project, SWUpdate and Jenkins pipelines on a RaspberryPi 3.
FPGA are devices where DSP algorithms fit perfectly. The MACC blocks in FPGA are almost designed for this kind of algorithms but they are also a limited resource. Small FPGA like Spartan 7 or Intel MAX10 have a reduced number of MACC blocks but well used, that little amount can be enough to implement even high-order filters. This session talks about how to optimize the number of MACC blocks used in DSP algorithms by applying technics like folding, optimizing the number of bits, or changing the structure of the DSP algorithm. During the session, we will see the implementation results of the different technics and how much we can reduce the amount of MACC blocks and also the number of general resources used.
FreeRTOS and AWS IoT ExpressLink: Simplify and fast-track your embedded designs
Presented by Dan Gross
Presented by Amazon AWS
AWS IoT ExpressLink encapsulates security and cloud connectivity into a communication module, simplifying the development of embedded applications for IoT devices. Pairing FreeRTOS with AWS IoT ExpressLink helps developers focus on the differentiated value of their IoT devices rather than wrangling with provisioning and connectivity code. A serial interface to an AWS IoT ExpressLink module, along with some simple AT commands, are all that’s needed to quickly connect to AWS from an embedded application using FreeRTOS.
Frequency domain signal processing is not just about using the Fast Fourier Transform for calculating a power spectrum, it is also a very efficient method of processing signals compared to traditional time domain techniques. This presentation will describe several common frequency domain algorithms and show how they are used. Examples will include Frequency Domain Filtering, Time Delay Estimation and Interpolation; and more.
Garbage In, Quality Out? Mastering Agile Product and Portfolio Management in Embedded Systems Development
Presented by Luca Ingianni
In the embedded systems industry, technical prowess often takes center stage. Yet, in my observation, many projects falter not because of engineering challenges, but due to shortcomings in product and portfolio management. This talk examines how these crucial aspects have become a significant vulnerability in numerous embedded systems projects.
We'll look at common pitfalls in product and portfolio management, their ripple effects throughout project lifecycles, and practical strategies to address these issues. The discussion will cover implementing agile methodologies tailored for embedded systems, aligning product vision with market demands, and harmonizing portfolio decisions with broader corporate strategies.
Drawing from real-world examples, we'll explore how effective management practices can steer challenging projects towards successful outcomes. Attendees will gain insights into transforming potential project pitfalls into opportunities for delivering quality embedded systems, even when faced with difficult starting conditions.
GDB is a powerful tool to analyze and debug firmware. It enables developers to step through instructions, view disassembly, peer into registers, analyze back traces, and so much more to help debug. Without it, I cannot imagine developing firmware! There is a lot to unpack about how to use GDB effectively, so this talk will focus on a few key topics including a rundown of important GDB commands, the GDB Python API, options for visual debugging, and how GDB plays a role even after you ship IoT device firmware.
GDB is a powerful tool to analyze and debug firmware. It enables developers to step through instructions, view disassembly, peer into registers, analyze back traces, and so much more to help debug. Without it, I cannot imagine developing firmware! There is a lot to unpack about how to use GDB effectively, so this talk will focus on a few key topics including a rundown of important GDB commands, the GDB Python API, options for visual debugging, and how GDB plays a role even after you ship IoT device firmware.
Representing signals as geometric vectors is a simple and fundamental basis of signal processing. Outlined by Shannon in the same paper that introduced Sampling Theory, it offers powerful and intuitive ways to think about and analyze signal processing, but is often neglected in favour of the numerical technique that implement its methods. In this talk Chris Bore revisits this interesting topic and its relationship especially with Fourier Transforms, filters and communications.
TinyML is opening up incredible new applications for sensors on embedded devices, from predictive maintenance to health applications using vibration, audio, biosignals and much more! 99% of sensor data is discarded today due to power, cost or bandwidth constraints.
This webinar introduces why ML is useful to unleash meaningful information from that data, how this works in practice from signal processing to neural networks, and walks the audience through hands-on examples of gesture and audio recognition using Edge Impulse.
What you will learn:
What is TinyML and why does it matter for real-time sensors on the edge
Understanding of the applications and types of sensors that benefit from ML
What kinds of problems ML can solve and the role of signal processing
Hands-on demonstration of the entire process: sensor data capture, feature extraction, model training, testing and deployment to any device
The ability of silicon vendors to pack more components and capability into a single silicon die has allowed these System On Chips (SoCs) to support Linux. In turn, developers have been able to quickly migrate their application to be deployed "to the edge" without significant rework. The main objective of this session is to provide embedded systems engineers an overview on the steps necessary to get Linux running on a custom board, issues they may face, and how to debug these issues. This session will provide an introduction to Linux and its value in embedded systems, and how it differs from "traditional" Linux that runs on desktops. This session will also discuss how Linux differs from other embedded software paradigms, such as "bare-metal" and RTOS-based application development.
IoT Edge devices need a robust, secure, real-time operating system that simplifies connecting to the cloud. In this webinar, attendees will learn how to leverage Azure RTOS to securely connect to Azure Cloud and view hands-on demonstrations using the STM32L4 Discovery board.
Join us to gain an understanding of:
Real-time Operating Systems (RTOS)
Azure RTOS
Deploying Azure RTOS to the STM32
Connecting an embedded system to Azure Cloud
Tracing RTOS applications using Percepio Tracealyzer
Getting Started with Embedded DevOps using Gitlab CI/CD Pipelines
Presented by Jacob Beningo
Continuous Integration and Continuous Delivery (CI/CD) have become critical tools to IoT edge device developers. In this workshop, participants will delve into the fundamentals of Embedded DevOps by designing and implementing their own CI/CD pipeline using Gitlab.
Attendees will gain practical experience in configuring build systems, designing a CI/CD pipeline, and implementing it. (At least as much as can be done in a few hours). We’ll explore how to containerize your build environment in Docker, so that you can easily integrate it into an embedded CI/CD pipeline. You’ll also learn how to use Visual Studio Code to seamlessly integrate your build processes within a single environment.
Attendees will walk away with a basic, but functional CI pipeline that they can easily scale to meet their needs.
Key topics covered in this workshop include:
The role of DevOps in Edge and embedded system development
Getting Started with Embedded DevOps using Gitlab CI/CD Pipelines
Presented by Jacob Beningo
Continuous Integration and Continuous Delivery (CI/CD) have become critical tools to IoT edge device developers. In this workshop, participants will delve into the fundamentals of Embedded DevOps by designing and implementing their own CI/CD pipeline using Gitlab.
Attendees will gain practical experience in configuring build systems, designing a CI/CD pipeline, and implementing it. (At least as much as can be done in a few hours). We’ll explore how to containerize your build environment in Docker, so that you can easily integrate it into an embedded CI/CD pipeline. You’ll also learn how to use Visual Studio Code to seamlessly integrate your build processes within a single environment.
Attendees will walk away with a basic, but functional CI pipeline that they can easily scale to meet their needs.
Key topics covered in this workshop include:
The role of DevOps in Edge and embedded system development
Delving into the world of FPGA-based hardware and PCB design can be daunting. In comparison to 'simple' microcontroller-based embedded system design, and when incorporating FPGAs and SoCs, the complexity of system, schematic, and PCB design is driven up substantially.
For instance, we need to worry about the finesses of controlled impedance traces, delay tuning, stack-up choice, DDR memory layout, power distribution and decoupling network design, power delivery for multiple voltage rails with high currents - and that's just naming a few examples!
This talk will show you - in a very condensed form - the basics and what you need to pay attention to when attempting your first FPGA-based hardware and PCB design, including real-world, practical examples.
The Zephyr Project is rapidly emerging as a leading real-time operating system (RTOS). Commonly referred to as “Zephyr”, its vision is to be the premier RTOS for connected, resource-constrained devices. Zephyr integreates both open-source and security best practices to ensure a vendor-neutral, secure and reliable platform.
In this webinar, we delve into an introductory exploration of The Zephyr Project RTOS. Attendees will gain insight into the fundamental elements of an RTOS and Zephyr’s implementation stands out. We will unpack the key components of Zephyr and offer a roadmap for getting comfortable navigating its codebase.
The session will discuss the intricacies of a Zephyr application, guiding attendees on how to craft their own application, using a “Hello World” application as a demonstration. Finally, we will discuss advanced topics, including how to gain in-depth insights into our firmware using the Memfault framework, which is built right into Zephyr.
Green FIR Filters with Large Ratio of Sample Rate to Bandwidth
Presented by fred harris
This presentation will show you how to design and implement narrowband filters with more than an order of magnitude reduction of workload. I was recently challenged to reduce the workload for a 301 tap low pass FIR filter with sample rate 50 times the bandwidth. After my first approach in which I reduced the workload to 21 multiplies I wondered by how much could we reduce the workload? I finally stopped playing with the question when I reached 6 multiplies, which is a 50-to-1 workload reduction. The technique we present usually reduces the workload by a factor greater than 10. The only requirement to apply these techniques is that there be a large ratio of sample rate to bandwidth. Once we learn the simple trick to accomplish this reduction we then pose the next question: can we achieve similar reduction in workload when there is not a large ratio of sample rate to bandwidth? The answer surprisingly is yes? We will share the recipe for the secret sauce so you too will know how wideband filters can also be implement with more than an order of magnitude workload reduction. How about a pair of 1400 complex tap filters replaced with 100 real multiplies?
When I first started showing folks how to build FIR filters with an order of magnitude workload reduction, no-one seemed interested in clever solutions. I realized I had a marketing blind spot. I fixed that blind spot and now tell folks let me show you a green solution to your problem! There is hardly any room left on the bandwagon.
FPGAs are increasingly being used in sensitive applications. Examples include our national infrastructures (power grids, network routers, satellites), transportation (planes, trains, automobiles), military equipment (weapons, radar, software defined radio) and medical devices.
Unfortunately, as FPGA hardware continues to become more powerful and cheaper, it also becomes more attractive to attackers to attempt and exploit any security weakness in them.
Such attacks have serious consequences. They can steal confidential information, modify the system to perform devious, unintended activities, perform denial of service, or even destroy the system.
Therefore, securing is of utmost importance!
Unfortunately, the security of FPGA has largely been ignored (until recently).
In this talk we discuss the possible attacks against FPGAs & SoC FPGAs, and what are the technologies, methods, tools and techniques that are used to secure FPGAs.
The explosion of silicon density in the past decade has resulted in increased massive compute capabilities of modern-day microprocessors in power-efficient packages. Processors supporting trillions of floating point operations (TFLOPS) are now becoming widely available in smaller form factors. Software paradigms have also been created to leverage the underlying hardware. In this talk, Mohammed Billoo will introduce Nvidia's CUDA framework, targeting a variant of the C programming language. Care needs to be taken when implementing applications using CUDA-C. The underlying hardware, specifically the memory architecture and layout, need to be considered to ensure that the final implementation is performant. Mohammed will cover the following topics in this talk:
Architectural differences between GPUs and CPUs
Relevant applications for GPUs
CUDA-C overview and build process
CUDA-C code structure
Mohammed will conclude the talk with a hands-on demonstration of an image processing algorithm implemented in CUDA-C on a Nvidia Jetson Nano development kit. He will compare the performance of the CUDA-C implementation on the GPU against a naive implementation on a CPU.
Hands-On Workshop Integrating Toradex Torizon and Amazon AWS
Presented by Mohammed Billoo
Toradex's Torizon ecosystem provides a complete solution for IoT device management, from device provisioning and OTA updates to device health monitoring. While the Torizon web interface may be sufficient for limited deployments, its extensibility shines when using the API to integrate with an external cloud provider. In this workshop, Mohammed will provide hands-on demonstrations on how to use Torizon's API for common cloud tasks in an IoT solution. He will show real examples using Amazon AWS as an example cloud platform.
With increasing regulatory requirements on cybersecurity around the world, it is more important than ever to secure the systems you develop. As Linux is an integral part of many embedded systems, we will address how to harden Linux systems, in other words, how to reduce their attack surface by applying appropriate configurations. Linux hardening is a vast topic, so we will give a high-level overview of the topic, and then dive deeper into a few chosen topics.
Among other things, you will learn the following:
What is hardening and when is a system sufficiently "hardened"
How to weigh trade-offs between security and performance of certain kernel configurations
Which Linux Security Modules (LSMs) exist, and which are most useful for embedded use cases
How to configure a standard firewall with nftables
How to configure SSH for maintenance & diagnostics
Which tools can help you with the hardening process
Designers releasing embedded devices need to understand what
sort of hardware attacks they will face in the field. We will discuss how
two different types of advanced attacks work: side channel power analysis
and fault injection. Not limited to theory, we will demonstrate how they are
used in practice and work through real products the attacks have been
used on. Low-cost tools and open-source material will be highlighted, so the
attendee can learn more details & even perform these attacks themselves.
Hardware in the Loop in Containers: Why Docker is Hardware's Best Friend
Presented by Ari Mahpour
Have you ever tried to set up a second or third test machine only to discover you forgot to document the first one? Are you one of those people who spend hours installing drivers and configuring settings on your test machine? With containerization we can set up our second or millionth computer in less than a few seconds. Containerization has become ubiquitous among software developers but barely known to the embedded community, let alone hardware engineers. In this talk we will review how to use containers to solve your automation frustration (and tackle world peace if time permits).
Hardware Security Analysis on Soft-Core RISC-V Processors
Presented by Colin O'Flynn
Attacks against embedded systems cover a wide range of surfaces. Some of them, such as power analysis and fault injection, are low-level attacks that depend on the construction of the microcontroller running your firmware. The release of open-source RISC-V microcontroller cores allows you to investigate how changes in the microcontroller core impacts these attacks in a way that using off-the-shelf microcontrollers never allowed before. This talk will demonstrate how power analysis & fault injection works, and then demonstrate how you can setup different types of RISC-V cores on a FPGA platform to perform these sorts of attacks.
Harnessing the power of ST's NFC ST25DV dynamic Tag using your smart phone
Presented by John Tran
Presented by STMicroelectronics
Learn how to use all the functionalities of STMicroelectronics NFC ST25DV-I2C Dynamic tag from your Smart Phone on both Android and IOS platform using NDEF message, Data Protection, Fast-Transfer-Mode, Bluetooth, Wi-Fi static and negotiated handover.
Hawkbit and SWUpdate for OTA Updates of Linux IoT Devices
Presented by Mohammed Billoo
Linux-based IoT devices don't have a flat Flash structure that allows for a straightforward OTA update process. There are a multitude of bootloader, kernel, and root file system combinations that must be taken into consideration, along with the different failure modes. The combination of Hawkbit and SWUpdate aim to standardize the OTA update process for IoT devices running Linux. This session will provide an overview of Hawkbit and SWUpdate, the different components that can be updated, and the different failure modes that are supported. A case study will be presented to demonstrate how to set up Hawkbit and SWUpdate to support OTA updates for a Linux-based IoT device. Finally, ongoing work by the presenter to address current shortcomings will be discussed.
High Resolution Spectral Analysis Using Channelizers
Presented by Ric Losada
Modern spectral estimation is most often done using FFTs. Spectral windows are used to tradeoff spectral leakage for resolution (the ability to distinguish between spectral lines that are close to each other). Rectangular, flat-top, Hann, Kaiser windows (among others) are all commonly used, and each have their strengths and weaknesses. The window + FFT approach is called a (modified) periodograms and, when used in conjunction with overlapping and averaging, Welch’s method.
We discuss here an alternative to this approach using efficient polyphase-FFT filter banks (a.k.a. channelizers). Channelizers find wide application in wireless communications systems. The analysis filter bank can also be used for high resolution spectral analysis. The tradeoff between resolution and spectral leakage is much less of an issue with the channelizer approach. You’ll also get more stable and accurate peaks and a more consistent noise floor. Channelizers are the modern/digital equivalent of sweeping a narrow bandpass filter across the spectrum and computing the average power of its output. However, there is no sweeping required and no spectral window either.
This talk explores the features that can be added to an RTOS to create more secure microcontroller software. We start with the advantages of partitioning. Then show how to partition code and how to isolate the partitions. These methods build upon the security features of the Cortex-M architecture. Next, methods are introduced to limit system damage by malware that has invaded a partition. The talk includes numerous diagrams and code samples and emphasis is upon practical solutions that work. The presentation is expected to be beneficial to both programmers and security experts -- it introduces many new concepts that go beyond best programming practices. The talk concludes with suggestions for microcontroller security improvements to further advance the state of the art.
Holistic prototyping: A systems-level approach to DFM
Presented by Duane Benson
There was a time when, once the design was done, the engineer could move on to the next embedded project. Design for manufacturing (DFM) was the responsibility of a PCB designer, components engineer or manufacturing engineer. In other words, someone else would take care of all of the details related to ensuring a working finished printed circuit board assembly. Those days are gone. With compressed schedules, quick-turn everything, and a bit of supply chain madness thrown in for good measure, a design engineer must be cognisant of manufacturing from the first days of concept development until the boards roll out of the reflow oven and into a test fixture. DFM now requires a holistic systems level perspective.
This session will walk you through the systems level DFM process showing when and where the most common prototyping pitfalls occur and how to avoid them.
Key topics covered
Component selection for a broken supply chain
Design issues that will affect manufacturability
Getting ready for the hand off
Keeping involved in the prototype manufacturing process
How Agile is Changing the Face of Embedded Software Development
Presented by Niall Cooling
This presentation is ideal for anyone who is either new to Agile, considering using Agile or even has experience in working with Agile methodologies and practices with embedded software or firmware developments.
It will clarify the Agile landscape, covering both process based aspects, such as Scrum and various techniques, including Test Driven Development (TDD) and some of the underlying foundation principles, such as Continuous Integration (CI).
As part of the discussion, we shall look at some of the modern-day tools that help apply Agile techniques(e.g. Docker) and finally look ahead to the current gaps and where embedded systems offer particular challenges to the use of Agile techniques.
How AI Accelerated Microcontrollers Will Change Embedded Systems
Presented by Kwabena Agyeman
New Microcontrollers available on the market today have megabytes of RAM onboard with AI accelerators providing hundreds of gigaops of computation resources. These new microcontrollers now can replace application processor systems with lower heat generation, power consumption, size, and cost.
The newly announced OpenMV N6 and OpenMV AE3 leverage such Microcontrollers from STMicroelectronics and Alif Semiconductor, which can both run modern YOLO networks onboard at real-time, 30 FPS, frame rates while drawing less than 1W of power.
In the talk we’ll cover how you can use MicroPython to effectively leverage the resources of these new Microcontrollers with Numpy running onboard to efficiently utilize new vector instructions thanks to the new Cortex-M55 processors onboard.
LPWANs play a major role in IoT systems, making low energy demanding and long range communication range projects possible to be done. In this talk, LoRaWAN and SigFox LPWANs will be discussed. This discussion goes from its ground-basics (such as explaining what are LPWANs and what they're used for) to the details and differences of LoRaWAN and SigFox and real use cases of both LPWANs. Talk topics:
What is a LPWAN?
Common features of LPWANs
Why are LPWANs so important for IoT?
LoRa and LoRaWAN: overview
SigFox: overview
SigFox and LoRaWAN: classes and how to use each class
Key factors when choosing a LPWAN for your project
Moving forward in your career is harder than it used to be. People are changing jobs more regularly and no longer rely on traditional career paths to progress into higher-level positions. Understanding what is important to you and how to use those goals to progress professionally is often an underrated component of building a fulfilling career - even engineers, who are highly logical people, can sometimes neglect this way of thinking!
In this webinar, I will present a high-level overview of the embedded systems employment market, discussing how you can use this readily available information to help plan your career. In the second part, I will provide job searching and interview techniques, specifically tailored for embedded software and electronics engineers.
How to avoid end of life from NAND correctable errors
Presented by Thom Denholm
Presented by TUXERA
Flash media is fabulous for most use cases, but heavy reads can cause correctable errors. Linux flash file systems actually shorten the life of the media when dealing with these errors. How does this change with multiple bits per cell, including recent QLC NAND? What other sorts of media management can help get the most lifetime out of your flash media based device?
This talk will cover these sorts of problems and impacts in detail, from flash file systems to SSDs and other NAND flash-based media. While we can't speak to what the firmware in your devices are doing, we have an excellent knowledge of what they should be doing, and also detail the sorts of conversations a system designer should have with their flash media vendors.
How to Design a Hardware Product from Idea to Market
Presented by Matiss Drusts
Designing a hardware product from start to finish can be a daunting challenge. It requires various
skills like circuit design and embedded systems design. The numerous potential pitfalls and points
of failure are a major reason why many people put off developing their own products or why those
that do try, often fail.
Therefore, in the case that you are looking to design your own hardware product or are working in
collaboration with others, it is essential for you to understand how a hardware product is developed
from beginning to end. This is what you will learn in this session.
How to design a hardware product from idea to market
General pitfalls to avoid
How to manage the economic of building a hardware product
How to design your hardware and software in parallel
How to Design a Multi-Technology Outdoor-Indoor Tracking Device
Presented by Nicolas Jordan
In this talk, we will introduce the start of the heart of technologies (BLE, Wifi, LoRaWAN…) to deploy a wide range of IoT tracking solutions while minimizing the Total Cost of Ownership (TCO) of IoT geolocation use cases.
With new generations of integrated low cost module, we will see how to allow engineering efforts focus on use cases, optimizing time-to-market and costs, by using less complex PCBs reducing certification risk and budget, as well as testing time and cost for mass production.
If you work with embedded software, you have probably encountered many anomalies over the years. Unexpected deviations in the software behavior, big or small, that may indicate elusive software issues, malfunctioning hardware or even cybersecurity attacks. Such anomalies may cause major problems if not detected and resolved quickly.
Join this webinar to learn best practices for detecting anomalies in RTOS application behavior. You will also gain insight how anomaly detection can be deployed to provide diagnostic data for remote analysis and debugging, both during system testing and in deployment at scale.
How to Develop IoT Applications Using RISC-V and Embedded Linux
Presented by Nenad Ilic
Presented by Amazon AWS
There’s a good chance that next-generation IoT projects will start transitioning to open-source hardware running fit-for-purpose compute modules having the RISC-V architecture. This transition may be concerning to some who have been using Arm and Intel architectures for decades. In this session, learn how making this transition might be advantageous for your future projects. First, learn how to get started with embedded Linux development on RISC-V architectures, then adapt your development environment to build embedded Linux–based IoT projects, and then prepare your projects for the prototype-to-production pivot. This session provides you with the building blocks needed to start your new RISC-V based IoT project with confidence.
Agile: what is it, and what isn't it -- you might think that this topic would be settled by now, but the debate seems to be increasing if anything. I've encountered many doubts about whether agile makes sense for embedded in the first place, and how to apply its principles.
So in this talk I'll try to summarise how to understand agile, and how to apply it in the embedded domain.
What's the mindset and philosophy behind Agile (I promise, it's not sprints)
Should you be using agile in the first place?
How can you possibly apply it in physical products?
How does it work in regulated, i.e. safety-critical contexts?
How can you convince your coworkers, your managers -- and perhaps even yourself, to give it a try?
Where should I start, and who do I need to ask for permission?
I'll also try to address the most frequent doubts, criticisms and especially misunderstandings of agile, particularly as applied to embedded systems.
How to Employ Scalable and Reliable IoT Management Systems
Presented by Tyler Hoffman
Presented by Memfault
IoT management systems that can handle large-scale deployments are complex to build and maintain, especially at scale. Firmware updates, debugging, monitoring, and security are all critical components of an IoT system, and they must be managed carefully to ensure smooth operations.
Building IoT management systems from scratch can be a daunting task. However, by understanding the key challenges involved and taking steps to address them, it is possible to build systems that are scalable, reliable, and easy to maintain. Watch this presentation to learn how to build IoT management systems that will ensure the smooth operation of an IoT deployment and flexibly adapt to your needs as your devices grow.
How to get started with Arm Cortex-M55 software development
Presented by Christopher Seidl
Presented by Arm
IoT and embedded developers can take advantage of an unprecedented uplift in energy-efficient machine learning and signal processing performance for next-generation voice, vision or vibration use cases with Arm's latest endpoint AI technologies; The Cortex-M55 processor, Arm's most AI-capable Cortex-M processor and the Ethos-U55, the industry's first micro neural microprocessor (microNPU) that's designed to work with Cortex-M processors.
These technologies can be developed in a unified software toolchain for the simplest and fastest development path for AI. Join this talk to be one the first to get started today to write optimized code for the exciting features these processors bring.
This talk will be a hands-on demo of the development flow available with Arm tools and will cover:
New architectural features of the Cortex-M55 processor
How to benchmark an application using Cycle Model
How to run the application on an FPGA prototyping board
How to optimize your code with Keil MDK debug features
What approaches really work for development and especially shaking out the bugs?
Test-driven development?
Simulation?
Code and design reviews?
Memory access checkers?
Scripted tests with coverage analysis?
Dumb Luck?
This is case study of a project to 'fix a small setup bug' in an existing product, which proved a wee bit larger than expected.
We'll review a bunch of actual bugs, techniques used, and statistics.
The approaches discussed could help you with your current project!
Agile is one of the most successful methodologies in software development. Agile is being used by the most successful tech companies as well as outside technology, including education, healthcare and HR. Let's implement Agility in the IoT space.
Key points for talk:
How to implement Agile and reap Agile benefits in an IoT organization:
Quicker delivery to market
Allow for constant feedback and improvement from the customer, to inspect and adapt product
Empowering teams to self manage to improve process and efficiency
Explore various methods to improve IoT processes through Scrum/Kanban
How to Leverage Dev Containers for Quick and Easy Zephyr OS Development Setup
Presented by Stefano Fiorentino
Unlock the potential of rapid Zephyr OS development through strategic utilization of Dev Containers. Learn to expedite environment setup with precision, fostering a streamlined and efficient workflow.
In the world of smart phones and tablet PCs memory might be cheap, but in the more constrained universe of deeply embedded devices, such as those that support the IoT, it is still a precious resource. This is one of the many reasons why most 16- and 32-bit embedded designs rely on the services of a scalable real-time operating system (RTOS). An RTOS allows product designers to focus on the added value of their solution while delegating efficient resource (memory, peripheral, etc.) management. In addition to footprint advantages, an RTOS operates with a degree of determinism that is an essential requirement for a variety of embedded applications. This session takes a look at “typical” reported performance metrics for an RTOS in the embedded industry.
Discuss how to approach going from an AMD (previously Xilinx) FPGA to a different brand such as Efinix which is becoming a common task with the global supply chain issues.
How to Rapidly Develop IoT devices with Arm and AWS
Presented by Reinhard Keil
Presented by Arm
Arm Cortex-M processors have been shipped in more than 45 billion chips for a vast range of applications, from industrial sensors to wearables. This growth has exploded more so in the last few years due to the significant rise in connected products for diverse markets. AWS IoT provides broad and deep functionality, spanning the edge to the cloud, so customers can build IoT solutions for virtually any use case across a wide range of devices. With designers of IoT applications under extraordinary pressure to build innovative solutions quickly, affordably, and satisfy many design requirements, how can the IoT continue to scale across a growing number of use cases? The talk provides a tour of a simple path to developing secure Cortex-M based IoT devices with Arm and AWS, and how together, the collaboration provides choice and scalability for IoT developers.
FOMO (Faster Objects, More Objects) is a novel machine-learning algorithm that brings object detection to highly constrained devices.
FOMO counts objects, finds the location of objects in an image, and tracks multiple objects in real-time using up to 30x less processing power and memory than MobileNet SSD or YOLOv5. In this session, we'll walk through how to use FOMO and where it can be applied.
How to shorten the development time of an IoT product with the Zerynth Platform
Presented by Zerynth
By showing a power consumption demo, we wanted to introduce the Zerynth IoT toolchain and demonstrate how easy it is to IoT enable an application (consumer or industrial) with our tools. Thanks to the combined power of Zerynth OS and Zerynth Device Manager, you can substantially reduce the time to market needed to develop an IoT product.
In this demo, an edge device sends real-time power consumption data to the Cloud. Moreover, this is a Python embedded application running on Zerynth OS sending data points securely in real-time. Watch the video to learn more.
How to Survive Designing Hardware in a Software Company
Presented by Orkhan Amiraslanov
The Generic Node project is an ambitious hardware venture that tries to build a hardware device that is built for software engineers and integrators. It's product vision tants many of the given paradigms and principles in hardware development. Not BOM optimization is the key but reducing the Total Cost of Ownership for the end to end solutions that are built with it. The design is made with the supply chain in mind. With the right security tools the device can be safely distributed across a supply chain of multiple actors yet not expose its security credentials to the third parties involved. The device is made for many different types of applications and comes with a series of cloud integrations.
With Covid19 impacting hands-on learning at higher education and postsecondary institutions, undergraduates and postsecondary learners have no to limited access to engineering and technical instructional labs. How can instructional training in IoT be implemented remotely? In this Virtual Talk (VT), the spending cost of IoT products and the demand for a technology- oriented workforce needed will be presented. To meet this workforce demand, instructional strategies for learning IoT technologies remotely with low cost hardware development platforms will be discussed. Also, open source software tools to aid in creating IoT applications will be presented. Further, WiFi and Bluetooth (BT) development approaches will be compared along with alignment of hardware platforms. The specific hardware platforms to be discussed in this VT will include ESP32, ESP8266, the Raspberry Pi, Arduino Nano 33 BLE/Nano 33 BLE Sense, and the BBC micro:bit. In addition, WiFi and BT application concepts for sensing and control will be presented.
IEC 62304 is the worldwide standard for developing medical device software. In this presentation, we'll start with a brief overview of the standard, then we'll look at how we can use it, along with some recent FDA regulation changes, that can substantially reduce development efforts while also increasing device safety.
"All functions are ok now - we just need it to be faster." Everyone has heard this before and we all know how hard it is to improve the performance of a system towards the end of a project. In our experience, the system / hardware / software architecture defines the limits of performance. Some things may be improved in implementation and integration, but the big things are set during architecture phase. Making the right decisions in the architecture & design phase ensures that performance requirements are met and avoids late changes.
Real-time systems - both big and small - have to find an optimal balance between CPU load and end-to-end latency. Either you put all software on one core and avoid communication or you distribute software load to multiple cores, but introduce communication overhead. Communication overhead also means extra latency. If your system has critical latency requirements for data flows, it is wise to find a good distribution of software loads while maintaining the maximum latency requirements. It is the job of the system and software architects to design for an optimal real-time behavior and manage real-time requirements.
A model-based simulation approach supports architects in exploring design alternatives. In early project phases performance requirements can be checked and the system can be optimized. During the project the same requirements can be applied to the implementation and integration in order to ensure, that the architecture is implemented correctly.
This talk discusses the value of model-based design and optimization of the dynamic architecture.
Implementing a Convolutional Neural Network (CNN) Layer on Hardware
Presented by Amr Adel
In this talk, we will explore the ways of implementing convolutional neural network (CNN) layers on hardware platforms. As deep learning continues to drive advancements in various fields, the need for efficient and high-performance hardware implementations becomes critical. We will delve into the architectural considerations, including data flow, parallel processing, and memory optimization, necessary for translating CNNs from software to hardware.
Starting with an overview of CNN operations, we will discuss fixed-point arithmetic and its advantages for hardware efficiency. We will then demonstrate a practical example of implementing a CNN layer on an FPGA, highlighting the steps from algorithmic design to hardware synthesis and deployment.
The talk will also cover optimization techniques to enhance throughput and reduce latency, such as parallelism and pipelining. Real-world case studies will illustrate the performance gains and energy efficiency improvements achieved through hardware acceleration of CNNs. By the end of the session, participants will have a comprehensive understanding of the challenges and solutions in implementing CNN layers on hardware, equipping them with the knowledge to embark on their own hardware acceleration projects.
Implementing a Simultaneous Localization and Mapping (SLAM) system for Robotics/Unmanned Vehicles
Presented by Mike Anderson
As robotics and unmanned vehicles like drones start to proliferate, many developers find that they need a means of fixing the device to a specific location and then have the device navigate to a destination while avoiding obstacles. In addition, we frequently want the device to create a map of the surrounding area for future reference. In order to most efficiently accomplish these goals, we need to create a SLAM for the device. In this session, we will discuss the various approaches and requirements for 3D SLAMs and how they are constructed. We will address implementations ranging from autonomous cars down to robots based on platforms such as the Raspberry Pi.
Improve your Embedded Device Development: Effective UX & Back-End Collaboration
Presented by Maurice Kalinowski
Presented by The Qt Company
Are you responsible for the development of modern embedded devices? If so, you know that the process of creating these devices has undergone significant changes in the past decade. With the addition of screens, we’ve gained the ability more easily and dynamically visualize data. And with the introduction of touch technology, there are completely new patterns and mechanisms to control an environment. To truly take advantage of these capabilities, development teams must incorporate UI and UX specialists into their workflow.
But what exactly does this involve, and how can it benefit your development process and the user experience of your devices? On the one hand, a strong focus on UX can improve the workflow of using a device. But customers also have higher expectations regarding the look and feel of user interfaces. They want visually appealing interfaces that provide a gaming-like experience. So what are the steps required to combine different user personas?
In this webinar, you’ll learn how to effectively incorporate UI and UX specialists into your development process to streamline product creation and deliver a top-notch user experience. You'll also discover ways to avoid complexity and accelerate product creation times so that you can bring your modern embedded devices to market faster and more efficiently.
Join Qt’s Product Director, Maurice Kalinowski, for this free webinar. Don't miss this opportunity to learn from the expert and take your embedded device development to the next level.
We all want to build hardware that is bulletproof on the first rev. I can't promise you that, but I know how to add in hooks and capabilities that make troubleshooting, upgrading, and measuring deficiencies much easier. Your second rev will be leaps and bounds ahead of your first, and you can get to market faster.
This talk will showcase components, tools, and troubleshooting methods that enable better hardware, regardless of the parts you choose or the form factor you need to fit into. This talk will also feature some recently created hardware that focused on modularity and flexbility, as it was not targeted at a production environment; this could form the basis of a good “rev a” build of hardware and help engineers to focus on validating new product ideas before digging into more complex layouts and smaller form factors.
Improved Binary FSK Carrier Offset Tracking using Model-Based Parameter Estimation
Presented by Randy Yates
Frequency modulation and detection is known for its superior resistance to noise when the carrier-to-noise ratio is sufficiently high, particularly for wideband FM. Conversely, its performance in lower CNR environments is known to degrade quickly and acutely, especially when operating at or below the second threshold, ending finally in total noise capture.
This behavior can wreak havoc with digitally modulated FSK systems, for example, when attempting to estimate carrier offset frequency in an AFC loop, and especially with mobile systems in which fades or changing channel conditions can cause temporary drops in CNR.
This problem can be addressed by using linear, model-based parameter estimation to model the input to the carrier offset estimator, estimate the model parameters on each AFC input block, reconstruct the estimated signal from the model parameters, and compute the mean-square error between the estimated signal and actual signal. If the mean-square error exceeds a heuristically-determined threshold, then the input signal is deemed corrupt and not used to update the AFC loop, otherwise one of the estimated parameters is used to update the loop.
Key Learning Points
Introduction to Frequency Modulation
Use-case for FSK Communications:
Power Efficiency versus Other Modulations
Bandwidth Efficiency versus other modulations
Implementation Complexity
Variations of FSK Modulation:
Continuous-Phase Frequency Shift Keying (CPFSK), AKA Sunde’s FSK ([1, p.381])
Minimum Shift Keying (MSK)
Gaussian Minimum Shift Keying (GMSK)
M-ary FSK (M > 2)
Detection approaches and their effect on power efficiency
Noise performance of FM modulation and detection
Theory of linear, model-based parameter estimation:
definition
representing model
estimating model parameters
Simulations
References
[1] S. Haykin, Communication Systems, fourth edition. Wiley, 2001.
When I was working on Think DSP, I encountered a small mystery. As you might know:
A sawtooth wave contains harmonics at integer multiples of the fundamental frequency, and their amplitudes drop off in proportion to 1/f.
A square wave contains only odd multiples of the fundamental, but they also drop off like 1/f.
A triangle wave also contains only odd multiples, but they drop off like 1/f².
This pattern suggests that there is a fourth simple waveform that contains all integer multiples (like a sawtooth) and drops off like 1/f² (like a triangle wave). Do you know what it is?
In this talk, I'll suggest three ways we can solve this mystery and show how to compute each of them using Python, NumPy, and SciPy. This talk is appropriate for beginners in both DSP and Python.
Increasing Air Quality Data through Trainings on Internet of Things and Low-Cost Sensors
Presented by Bertrand Tchanche
Atmospheric pollution is a global threat with increasing social and economic costs. Poor air quality is a concern in African cities, but governments have been too slow to react. Low-cost sensors and Internet of Things (IoT) are increasingly considered as solutions to evaluate the concentration of different pollutants in place of standard monitors. They are cheap and can be easily deployed. However, there is a lack of training and education on how to design and implement them. The IoT4AQ project, funded by the International Astronomical Union (IAU), aims to address this gap by organizing training sessions for researchers and students on low-cost sensors for air quality monitoring. The project started in February 2023 and will last for two years. It will be implemented in African countries, where participants will be trained in IoT techniques, showing how to build and deploy low-cost sensor-based instruments. The specific objectives of the project are:
To organize hands-on trainings and seminars on IoT and air quality monitoring
To train researchers, teachers, and students on various aspects of air quality monitoring
To improve Physics education in Africa through low-cost sensors and IoT
The expected outcomes of the project are:
To train participants on IoT and air quality monitoring
To improve the experimental skills of participants
To increase awareness of the threat that atmospheric pollution represents
Incremental rotary encoders are either something you know about, or you don’t. This is, of course, true of everything, but more-so in the case of these little scamps.
Most people come into contact with these rotary encoding rascals many times each day without even realizing it or thinking about it. Not-so-long ago, for example, the volume control on your car radio was implemented using a potentiometer. This had a smooth motion and a limited rotational range of say 270 degrees. Today, this function will almost invariably have been replaced with an incremental rotary encoder that has a tactile “click-click-click” feel as it turns, and that has no limit on how far you can rotate it clockwise or widdershins.
The cheap-and-cheerful versions of these devices, which are proliferating everywhere, are mechanical in nature. Although conceptually simple, their internal mechanisms vary wildly, while their switch bounce characteristics can make your eyes water.
In this MicroTalk, we will take a short, sharp plunge into the world of incremental rotary encoders, answering all the questions you never even thought to ask.
Inspiring Students and Empowering Teachers: Firia Labs Levels-Up Educational Robotics!
Presented by David Ewing
We have Maker Spaces in schools now. Huzzah! Surely by 8th grade all the kiddos are hacking on Arduinos and Raspberry Pi’s then, right? …um, not so much. We still have a long way to go before the tools and training we supply teachers meets the need to reach lots more students. And hey, every student deserves a chance to experience the awesomeness of embedded systems, right!?
Edtech startup Firia Labs launched their first robotics product into the education market back in 2018, and has been successfully equipping classrooms worldwide with state-of-the-art hardware and software ever since. Custom hardware, supercharged MicroPython firmware, cloud backends, amazing user-interfaces, and rich real-world-oriented curriculum… it’s amazing what a small team of motivated engineers can achieve!
In this presentation David will discuss the hardware and software Firia Labs has developed to meet this challenge. Along the way you’ll learn of some “world first” technologies they created to meet the need, tales from the “startup bleeding edge”, and more!
On the desktop, everyone learns to observe what their program is doing using print statements and logging. Embedded systems aren't amenable to such approaches because they run in real-time and don't have screens or memory to spare for logs, so new techniques need to be applied. Fortunately, modern CPUs provide surprisingly rich facilities for meeting these needs. In this presentation, we will introduce a range of these capabilities, from a novel twist on the simple flashing LED progressing all the way to full post-mortem instruction trace.
Integrating NFC into your application: What you need to know
Presented by Dan Merino
Presented by STMicroelectronics
In this session we will show you how to overcome the most common design challenges in NFC integration to achieve optimal performance and fast time-to-market.
Near Field Communication (NFC) is a technology that uses magnetic field induction to enable contact-less data exchange between two compatible devices moved within close proximity to one another. While simple in concept, implementing a robust and high-performing NFC design can be daunting, as developers must first consider things like passing certifications, interoperability, shrinking size requirements, low power consumption, and development time.
In the session, we will start by exploring the most common NFC reader applications in today's fast-growing NFC market. We will discuss the principle design challenges faced by engineers, and how to resolve them using the ST25R3916 high-performance NFC universal reader.
This industry-leading device boasts a unique set of features including dynamic power output, automatic antenna tuning, noise suppression receiver, and low power wake up, which make it ideal for robust and efficient designs over a wide range of consumer and industrial NFC applications.
You will learn:
the main challenges of designing an NFC reader and how to overcome them
about the ST25R3916 high-performance NFC universal reader device
how to exploit the device's unique features to design a best-in-class solution
This presentation will show you how to design and implement FIR filters with interesting variations of its spectrum. One example is a remez design with constant level in-band ripple but with 1/f spectral decay of its stopband ripple (rather than constat level sidelobe levels). Why would we do this? Come by and listen, I’ll tell you! We will show you why and how and demonstrate advantages of this option.
In another example we will show how to design and implement FIR bandpass filters with different transition bandwidths on its low frequency band edge and its high frequency band edge. Now why would we do that? We do this to build proportional bandwidth filter banks in which bandwidth is proportional to band center frequency. In such a filter bank, the filter above my center frequency band, say at 4 kHz, has a higher bandwidth with a wider transition bandwidth and the filter below my center frequency band has a lower bandwidth and a narrower transition bandwidth. If we want a perfect reconstruction filter bank my center frequency band must match the transition bandwidth of the filters below and above my center frequency. Thus, my filter must have a lower transition bandwidth on its lower edge than it has on its upper edge. Can a filter do that? Yes! Why? Ask the hearing aid filter bank designer (or ask me)!
Internet of Things Operating System Development Under "Light" Smart Age
Presented by Leo Zou
IoT technology is affecting our lives at a rapid pace, and becoming such an integral part of daily life. RTOS powered "Light" Smart tech is considered to be more applicable to fit the requirements of IoT development.
In this session, we'll explore the "Light" Smart tech and how RT-Thread works to fit this trend. Major topics that we will discuss include:
The concept of the "Light" Smart tech and how it applies to daily life.
The requirements to an RTOS for AIoT devices. How OpenSource RT-Thread IoT OS works to fit this trend.
The architecture of the RT-Thread IoT OS Project and the project features and pros.
This quick demo shows how to use modern CLI-based tools for embedded development. It introduces Keil Studio, a set of VS Code extensions that are relying on the CMSIS-Toolbox for managing and building projects. We will also show how to use Arm Virtual Hardware with GitHub Actions to enable DevOps in the cloud.
PX5 Enhances, Simplifies, and Unites embedded development. We deliver on this mission with superior products, an expert team, and a focus on supporting you throughout your development effort. All of this helps you deliver higher quality, safer, and more secure products to market in less time and with lower cost. When you succeed, we succeed!
Introduction to an Open Approach for Low-Power IoT Development
Presented by Reinhard Keil
Presented by Arm
Today, embedded developers start with low-cost evaluation boards utilizing reference designs that are based on open source software. For rapid IoT device development, scaling of these reference designs to cost-optimized and resource-constrained, high-volume production is critical.
Introduction to Encryption for Embedded Linux Developers
Presented by Sergio Prado
Data confidentiality is a requirement in the design of many embedded Linux devices. And encryption plays a significant role in developing products where confidentiality is a must. But there are different approaches, methods, and algorithms depending on the problem, which is not always clear to the developer. Should we use symmetric or asymmetric key encryption? What are the best algorithms for a specific situation? How to store the encryption key? In this talk, we will answer these and many other questions, covering the most common problems a developer could face to protect data-at-rest and data-in-transit when designing an embedded Linux device.
Introduction to Machine Learning and Deep Learning
Presented by Peter McLaughlin
In 2016 the Google supercomputer AlphaGo beat the world champion of the board game Go, a highly
complex mathematical game. This milestone demonstrated the possibilities of Artificial Intelligence and
set the scene for new technologies which are now transforming our lives, from the way we drive to the
way we buy clothes. Thanks to recent advances in graphics acceleration hardware and neural network
development tools, the benefits of Artificial Intelligence are within reach for any business. This
presentation introduces the underlying theory of Machine Learning and Deep Learning and explains how
to practically apply it. Topics covered include the training process, model types, development tools,
common pitfalls and real-life examples. Attendees will walk away with a kick start to help them apply
Machine Learning and Deep Learning in their projects.
Millimeter wave (mmWave) is a special class of radar technology that uses short-wavelength electromagnetic waves. Radar systems transmit electromagnetic wave signals that object in their path then reflect. By capturing the reflected signal, a radar system can determine the range, velocity and angle of the objects. mmWave radars transmit signals with a wavelength that is in the millimeter range. This is considered a short wavelength in the electromagnetic spectrum and is one of the advantages of this technology. Indeed, the size of system components such as the antennas required to process mmWave signals is small. Another advantage of short wavelengths is the high accuracy. A mmWave system operating at 76–81 GHz (with a corresponding wavelength of about 4 mm), will have the ability to detect movements that are as small as a fraction of a millimeter. A complete mmWave radar system includes transmit (TX) and receive (RX) radio frequency (RF) components; analog components such as clocking; and digital components such as analog-to-digital converters (ADCs), microcontrollers (MCUs) and digital signal processors (DSPs).
Introduction to Radio Frequency measurements for Cellular and Wireless Communication Systems
Presented by Ramakrishna Yellapantula
While the modulation and demodulation techniques described in the text books is perfect, in reality they are far from perfect. Due to the tolerance of different components used in manufacturing of Radio Frequency (RF) chipsets, we notice different impairments in the transmitted and received RF signals. In this presentation, we will introduce and discuss the RF measurements for Cellular and Wireless Communication Systems
The embedded software architecture has changed a lot in recent past.
Most of the embedded software has evolved from monolithic design to well abstracted, modular, scalable, configurable, and extensible in recent past.
However, the embedded processors on which these embedded software run did not undergo much change in this regard.
This talk discusses how RISC-V’s unique characteristics of its free and open ISA (Instruction Set Architecture) brings the modularity, extensibility, scalability, and customizability to embedded processor design.
Introduction to the Data Model Architecture for Embedded Systems
Presented by John Taylor
The Data Model architecture is used to design highly decoupled code. It allows for the exchange of data between modules with neither modules having dependencies on each other.
Warped FIR (WFIR) filters are a hybrid between FIR and IIR filters combining some of the advantages of both. Design methods are similar to FIR filters including arbitrary magnitude and phase response but in contrast to FIR filters, they offer good resolution at low frequencies at very low orders and they can be implemented efficiently. They are a particularly good fit for loudspeaker arrays as deployed in soundbars and Atmos speakers.
The IoT is evolving rapidly and software development is being forced to evolve to match new demands. Increasingly, developers are under pressure to release earlier and update more often. Historically, early development has been tied to availability of hardware platforms on which to develop, test and prove new software. With the speed of change we are seeing these days, this is increasingly becoming a barrier.
At DevSummit recently, Arm announced Arm Virtual Hardware. This uses Arm Fast Models technology to enable cloud-based IoT development. Removing the requirement for hardware enables earlier start to the software development process, reduces cost and time-to-market. We’ll discuss in detail this technology and how we expect it to transform and accelerate software development and deployment.
We’ll also look to the future and imagine what the ecosystem in the cloud might look like.
Steve will outline the fault lines in the elements of the IoT triad: the embedded devices, the frontend user applications, and the backend server applications.
These fault lines are a common source of problems during development, testing, deployment, operation, and maintenance of IoT products. The goal of the presentation is to heighten awareness of them to avoid nasty surprises, and present some strategies for managing and mitigating them.
News reports of IoT breaches are now commonplace, with manufacturers often blaming end-user misconfigurations or 'sophisticated attacks'. This implies the victim customers and organizations were simply unlucky, but have you ever wondered exactly how these hacks occurred and what could have been done to prevent them?
Joe Hopper, a professional hacker for the Fracture Labs technology security company, will walk you through:
How hackers target the victim devices
How vulnerabilities are discovered
How the weaknesses are exploited
What could have been done to prevent the breaches in the first place
A short but useful live meeting on Zoom between attendees and conference organizers Jacob and Stephane. In this live zoom we will be sharing a few pointers to help attendees navigate and take full advantage of the IoT Online Conference.
In this presentation, IOT embedded system security, software and hardware solutions, security threat due to WiFi/ RF communication, security threats due to advanced wireless sensors, over the air software updating, data routers with cloud-based computing are presented. Need for real time protection, secure protocols for communication, role of Hardware Security Modules (HSM) in IOT are also discussed. Software algorithms, modeling and testing are presented.
This talk gives an overview of devices and network connectivity and presents the key characteristics of the most common technology stacks used for industry IoT projects nowadays: Cellular, LPWAN, Wi-Fi and Bluetooth.
Spoiler alert, the tech stack to be chosen will be different depending on the project requirements but this talk shares some notable pros and cons for the most popular tech stacks.
No, that's not a typo – C+ is a common programming model where effectively C is being written but compiled with a C++ compiler. Why would you do that? Surprisingly two very popular IoT programming platforms; Arduino (https://www.arduino.cc/) and Arm’s Mbed (https://os.mbed.com/) use this programming paradigm. C+ (C++ as C) brings with it several useful extensions to C that can help enhance program safety and security. This talk looks at some of the small, but significant, useful features that compiling with a C++ compiler brings, without any penalties to size or performance.
Isolating MCU hardware and firmware using TrustZone security technology
Presented by Bob Waskeiwicz
Presented by STMicroelectronics
In the IoT and connected device marketplace, device security is paramount to protect customer information and to prevent outside attacks.
The new STM32L5 series MCU based on ARM Cortex M33 core with TrustZone technology is part of the STM32Trust Security Ecosystem, where the TrustZone is a dynamic firewall providing hardware and software isolation to the system. Developers can isolate critical security firmware, authentication and private information from other parts of the device. The STM32L5 provides crypto accelerators for Public Key, AES, Hash and a True Random Number Generator and On-the-Fly Decrypt for external memories. The STM32L5 can provide secure boot with Root Secure Services and TF-M (ARM PSA compliant Trusted Firmware) with a unique boot entry, providing a secure framework to base the system on "Root of Trust". The new series further pushes the low power footprint of our already class leading devices while offering new peripherals (USB Type C & PD) and power management innovation allowing for a class leading 62uA/MHz current consumption.
You will learn:
The new features and peripherals in the STM32L5
Understand how to create a "Root of Trust" with the STM32L5 Security features
How to use STM32 Trusted Package Creator
How to interface to other ST products (NFC) for a digital signature verification application
Iterative Development: XP, Test-Driven Development and Refactoring
Presented by James Grenning
Systems are not just developed, deployed and never touched again. Systems evolve. Systems have multiple releases and long lives. This talks gives you a quick look at Extreme Programming, and two of its core technical practices: Test-Driven Development and Refactoring. These are techniques and practices for the real world, where systems evolve.
Watch this intro if you are:
tired fixing fires before every release
writing code with no where to run it
suffering from Scrum being imposed on your group
One lucky viewer will receive complimentary tuition to Wingman Software's self-paced Test-Driven Development Training. All attendees that finish the video in the first wee of the conference, can claim a 50% off coupon.
Origins of DSP can be found in the two-tone drum language of the Lokele People: introduced to European culture by John Carrington in 1949. In this short talk, Chris Bore outlines the insights Carrington offered into drum language, its parallels to DSP, and the lessons that can still be learned from this piece of history. Assisted by Kevin Bulford - drummer of The King Cats rock'n'roll band - to bring life to the jungle drums.
In this session, you will get a quick introduction to the powerful TouchGFX GUI design tool for STM32 microcontrollers. Attendees can simply listen in, or follow along with the exercises on their PC with TouchGFX Designer.
Civil engineers have learned how to avoid failure from their rich history of bridge collapses, tunnel floodings, and building disintegrations. The firmware world is quite different; it seems we all make the same mistakes, repeatedly. Yet most problems have similar root causes. In this class we’ll examine a number of embedded disasters, large and small, and extract lessons we must learn to improve our code. It’s a fun, wild ride though avoidable catastrophes!
Visual AI solutions combined with powerful sound diagnostics for real-time decision-making are some of the hallmarks of the Sony Spresense with Edge Impulse’s embedded ML technology. Together, Edge Impulse and Sony bring a unique combination of solid computing performance as well as serious power efficiency that is ideal for edge computing applications.
Join our hands-on workshop to learn how to build future-proof solutions with smart sensor analysis, image processing, data filtering, collecting raw data, getting insight into that data using signal processing and machine learning, and deploying your ML models, ready for scale and industrial production.
Learn how embedded ML gives real-time insights into complex sensor streams
Build your first embedded ML model in real-time
Gain insight into the types of problems ML solves, then build better products
Learn how to take your ideas to production and scale through complete MLOps
Workshop details:
A 90-minute workshop
Beginner/Intermediate skill level
Hands-On, Instructor-Led, Live
A recording will be shared post-event
A personalized Certificate of Accomplishment from Edge Impulse
This will cover my experience learning to work in Rust for embedded systems.
This is from working as a volunteer firmware developer on the VolksEEG open source/open hardware project. Most of my experience is with C and C++, and this is my first project using Rust.
I'll cover the resources I've used to learn both general Rust and the specifics of Rust on embedded systems, as well as the challenges I've run into. Rust eliminates several classes of problems that typically occur with other languages, but in order to do so it follows some different language philosophies and rules.
Lessons Learned With Using Bluetooth Low Energy in Wearables
Presented by Jacky Cheung
The cost of integrating Bluetooth Low Energy (LE) into consumer electronics has dropped significantly over the years. With all the promising features introduced in Bluetooth 5.X, Bluetooth LE has become the de-facto connectivity solution for wearables.
This talk will present lessons learned with using Bluetooth Low Energy in wearable projects. It highlights some of the key design considerations and offers some practical tips on planning, implementation and debugging.
Leveraging DevOps for Streamlined Firmware Delivery
Presented by Dylan Swartz
Presented by Golioth
This talk aims to provide a comprehensive understanding of how DevOps principles can be applied to IoT development for improved efficiency and reliability. We will discuss integrating firmware building and over-the-air (OTA) updates into a continuous integration/continuous deployment (CI/CD) pipeline, resulting in increased release frequency, dependability, and quality. The presentation will draw from real-world IoT projects that have successfully implemented DevOps methodologies to expedite time-to-market and enhance overall performance.
Attendees will also gain practical knowledge of best practices for troubleshooting, monitoring, and scaling IoT deployments, ensuring that devices remain secure and updated throughout their life cycle. This session will offer valuable insights into implementing DevOps for IoT, equipping attendees with the tools and techniques necessary to optimize their embedded system development processes.
While the increasing use of software in embedded systems has led to more powerful and capable devices, it has made them more complex to control. Traditional mechanical buttons and controls are being replaced with touch control panels having a graphical HMI for operators to better handle the complexity while controlling such devices. Users have become so accustomed to smartphones that they expect a similar user experience when operating other touch-based devices. As device manufacturers look at ways to provide smartphone-like user experiences at reasonable costs, we will be walking through some of the options that Qt offers in this area.
Linear Algebraic Perspective on the FFT/IFFT and Its Role in the OFDM Modulations Employed in 4G/5G
Presented by Jeff Correia
This talk will be a tutorial on the Orthogonal Frequency Division Multiplexing (OFDM) Modulations and variants employed in 4G/5G and how they are parameterized via the forward/inverse Fast Fourier Transforms (FFT/IFFT). The talk will discuss the complex baseband formulation of the underlying digital modulations used via a brief introduction to quadrature amplitude modulation, its complex baseband representation, and subsequent extension into OFDM. The talk will address the FFT/IFFT properties employed in the conceptual formulation of the scheme and will motivate how thinking about the FFT/IFFT in a linear-algebraic sense can add insight into the complicated-looking structure of the FFT/IFFT and other transforms used in engineering sciences.
Linux Kernel Security - Inside the Linux Security Modules (LSMs)
Presented by Vandana Salve
The Linux Security Module (LSM) framework provides a mechanism for various security checks to be hooked by new kernel extensions.
The primary users of the LSM interface are Mandatory Access Control (MAC) extensions which provide a comprehensive security policy. Examples include SELinux, Smack, Tomoyo, and AppArmor. In addition to the larger MAC extensions, other extensions can be built using the LSM to provide specific changes to system operation when these tweaks are not available in the core functionality of Linux itself.
The topic deep dives into the
Understanding LSMs,
Types of LSMs,
Architecture of LSM,
The various hooks and the functionality provided by these hooks
It is an exciting time for Linux on RISC-V, the open instruction set (ISA) that is quickly gaining critical mass. I will introduce the pieces needed to boot Linux on RISC-V including the Privileged Architecture, OpenSBI and U-Boot, and how that fits into the upcoming RISC-V Platform Specification. I will break down support for existing hardware and current upstreaming efforts. I will also discuss how the arch/riscv maintenance guidelines try to avoid unnecessary churn as the landscape of RISC-V extensions continues to evolve.
Live Discussion - Bringing Low Power, High Performance Audio and Voice to Market on the i.MX RT600 Crossover MCU
Presented by Brendon Slade
Presented by NXP
This is your chance to chat with Brendon Slade, Director of the general purpose MCU Ecosystem team @ NXP, and Mike Vartanian, Director of Strategic Partnerships at DSP Concepts. Discussions will be centered around Audioweaver tools and the new i.MX RT600 MCU,
This is your chance to chat with Max about FPGA's, Embedded Systems, Artificial Intelligence, Science Fiction, and any of your other burning questions.
Live Hack: Demonstrating Common IoT Security Weaknesses
Presented by Joe Hopper
How would hackers attack your IoT device? Joe Hopper, Principal Security Consultant at Fracture Labs, will demonstrate several complex hacks against off-the-shelf IoT devices to shed light on the design and implementation weaknesses seen across the industry. He will walk through common attacks such as: finding and connecting to hidden serial consoles, boot process hijacking, memory analysis, firmware extraction, password cracking, and more to gain unauthorized access to IoT devices and customer information.
By using the same approach hackers use against your devices, you will walk away with a better understanding of where and how you need to tighten security controls.
Live Hack: Demonstrating Common IoT Security Weaknesses
Presented by Joe Hopper
How would hackers attack your IoT device? Joe Hopper, Principal Security Consultant at Fracture Labs, will demonstrate several complex hacks against off-the-shelf IoT devices to shed light on the design and implementation weaknesses seen across the industry. He will walk through common attacks such as: finding and connecting to hidden serial consoles, boot process hijacking, memory analysis, firmware extraction, password cracking, and more to gain unauthorized access to IoT devices and customer information.
By using the same approach hackers use against your devices, you will walk away with a better understanding of where and how you need to tighten security controls.
Live Q&A - Envisaging Real-time Industrial and Intelligent Applications leveraging the Edge AI Paradigm
Presented by Pethuru Raj Chelliah
Live Q&A with Pethuru Raj Chelliah following his talk titled 'Envisaging Real-time Industrial and Intelligent Applications leveraging the Edge AI Paradigm'
Live Q&A - Using Low Power Wide Area Networks For Industries with Minimal Total Cost Of Ownership And High Robustness
Presented by Burak Polat
Live Q&A with Burak Polat following his talk titled 'Using Low Power Wide Area Networks For Industries with Minimal Total Cost Of Ownership And High Robustness'
Live Q&A Discussion - DSP in Phased Array 3D Imaging
Presented by Chris Bore
13:04:53 From Michael Kirkhart : nanovna
13:05:12 From Leonard Dieguez : those are fairly low cost but also do not cover the frequency range
13:05:17 From Leonard Dieguez : the nano VNA
13:05:27 From Michael Kirkhart : The version 2 goes to 3 GHz.
13:05:39 From Michael Kirkhart : Not quite to 8 GHz, but getting closer.
13:05:54 From Leonard Dieguez : cool that is a good improvement. I would love to have one that goes to 8GHz
13:06:40 From Leonard Dieguez : do you know of a good link to get the version 2 , 3GHz version?
13:06:50 From shadasharif : Thank you
Live Q&A Discussion - Signal Processing Techniques in Condition Monitoring and Control of Power Electronics Converters and Battery System
Presented by Maher Al-Greer
Live Q&A Discussion with Maher Al-Greer following his talk 'Signal Processing Techniques in Condition Monitoring and Control of Power Electronics Converters and Battery System'
Live Q&A with Jacob Beningo and Kristoffer Martinsson - Getting Started with Azure RTOS Using STM32 MCUs
Presented by Jacob Beningo
Presented by Percepio
Live Q&A session with Jacob Beningo and Kristoffer Martinsson following the release of the webinar titled 'Getting Started with Azure RTOS Using STM32 MCUs'
Live Q&A with Jacob Beningo and Kristoffer Martinsson - Getting Started with Azure RTOS Using STM32 MCUs
Presented by Jacob Beningo
Presented by Percepio
Live Q&A session with Jacob Beningo and Kristoffer Martinsson following the release of the webinar titled 'Getting Started with Azure RTOS Using STM32 MCUs'
Join us for a dynamic live Zoom Q&A session, offering you a unique opportunity to engage with and pose questions to the distinguished speakers at the 2023 IoT Online Conference.
Fun get-together with most Theatre Talks Speakers. Attendees will have the opportunity to ask questions and interact with the speakers in a LIVE Zoom session.
In this talk, we emphasize the pivotal role of secure elements in fortifying IoT cybersecurity. With an emphasis on safeguarding keys, secrets, and cryptographic primitives, we explore how secure elements offer robust protection. Moreover, we illustrate how integrating secure elements in IoT devices can facilitate compliance with existing and forthcoming globally recognized regulations that will shape the IoT industry. Join us to discover how secure elements can bolster IoT security and align your devices with the changing landscape of cybersecurity regulations.
LoRaWAN & NB-IoT Complementary Deployment: City of Kyiv Use Case
Presented by Olivier Hersent
In this talk, we will explain how LoRaWAN and Cellular IoT (LTE-M/NB-IoT) complement each other to build horizontal IoT Platforms that can be used in a variety of use cases.
IoT use cases have wide requirements in terms of throughput, cost and battery lifetime, and no single radio access technology can address them completely. We will show how to address the need for a multi-technology LPWAN platform and present the example use case of the City of Kiev, which is already deploying this multi-technology network for the city and its own enterprise customers.
Key Learning / Audience Takeaway Points:
How LoRaWAN and Cellular IoT complement each other
Key enterprise use cases leveraging multi-technology platforms
The availability of low power integrated circuits, specifically in the category of embedded system on a chip (SOC) microprocessors with wireless radio (WiFi, Bluetooth, LoRa, etc) functions has enabled battery powered solutions in a broad range of new markets and categories. Products in the last decade have shrunk in size, from common cell phones, to smart watches, to ID badges, putting pressure on battery size. In many applications, battery life is a key performance parameter for market acceptance, or competitive advantage.
The presentation introduces the audience to considerations that go into creating an optimal battery powered design from both hardware and software perspectives, and the importance of modeling. Throughout the presentation there is focus on what to expect in the current profile based on the hardware and software design choices. The audience will appreciate the difficulty in making good current measurements and why such measurements can’t be ignored in the product development life cycle.
Low-Power Algorithmic Approaches in DSP Implementations
Presented by Bryant Sorensen
Hearing aid signal processing is a challenging task because of the extreme low-power, highly-constrained cycle performance required. The audio signal processing is always on, and requires complex algorithms and computations. A typical hearing aid will have multi-band analysis and synthesis, automatic feedback cancellation, environment detection and action, automatic gain control, and user interface - and AI is arriving as well. In order to reconcile the two disparate requirements (complexity vs. low power & reduced cycles), various approaches are needed to achieve low power while still providing sophisticated calculations. In this talk, I will discuss a sampling of numerical methods, shortcuts, refactorings, and approximations which significantly lower power in DSP algorithms. This will be an overview which I hope sparks thinking to extend the presented concepts to other low-power algorithmic tasks. While the focus is on algorithms and computations, some of these topics will also touch on implications to HW design, HW vs. FW tradeoffs, and ASIP / programmable DSP core design.
Machine Learning with Python: Introduction to Clustering and Classification
Presented by Matous Cejnek
In this workshop, the difference between clustering and classification will be explained with illustrative examples. The examples will demonstrate utilization of common machine learning algorithms (random forests, k-means, SVM) implemented in popular Python libraries.
Make your IoT device feel, hear and see things with TinyML
Presented by Jan Jongboom
Many IoT devices are very simple: just a radio sending raw sensor values to the cloud. But this limits the usefulness of a deployment. A sensor can send that it saw movement in front of it, but not what it saw. Or a sensor might notice that it's being moved around, but not whether it's attached to a vehicle or is just being carried around. The reason is simple: for knowing what happens in the real world you'll need lots of data, and sending all that data over your IoT network quickly drains your battery and racks up your network bill.
How can we do better? In this talk we'll look at ways to draw conclusions from raw sensor data right on the device. From signal processing to running neural networks on the edge. It's time to add some brains to your IoT deployment. In this talk you'll learn:
What is TinyML, and how can your sensors benefit from it?
How signal processing can help you make your TinyML deployment more predictable, and better performing.
How you can start making your devices feel, hear and see things - all running in realtime on Cortex-M-class devices.
Hands-on demonstrations: from initial data capture from real devices, to building and verifying TinyML models, and to deployment on device
Making a Robot Butterfly goes beyond aesthetic appeal—it requires managing inputs, outputs, and coordinating them seamlessly. This project is ideal for beginners, as it leverages ESP32 and the accessible FreeRTOS API through the Arduino IDE. In this talk, we’ll delve into code that enables smooth coordination between the butterfly’s flapping wings, lights (outputs), and environmental sensors (inputs)—and relate these to RTOS principles. This creates a responsive and interactive experience with its surroundings. Whether you're an embedded systems engineer, hobbyist, or creative technologist, this session offers valuable insights into breathing life into robotic creatures through embedded programming. https://github.com/RobotGrrl/RobotButterfly/.
Firmware Update Over-The-Air (FUOTA) is a must-have feature in all IoT-like embedded solutions in operation today, once FUOTA can be the only possible and affordable solution for fixing some bugs, security flaws and other software malfunctions in devices in the field, using internet to provide new firmware devices located anywhere in the world. But, how do we ensure robustness to FUOTA process?
One big ally to add robustness to FUOTA process is the rollback resource. Using rollback, in case of bad firmware update (caused by some predictable or unpredictable reason), the embedded device can automatically get back to the last firmware version. It means, in case of bad firmware update, they can automatically recover themselves, without having any bricked device in the field, and requiring zero human intervention.
This presentation will show how to use rollback in FUOTA for ESP32 microcontroller, including a full demo of this process.
Managing a Fleet of Global IoT Devices (The Easy Way)
Presented by David Tischler
Low cost, readily-available devices like the Raspberry Pi, Jetson Nano, and BeagleBone products have made prototyping IoT projects extremely simple for developers. Engineers can have functioning solutions quickly, without breaking the bank. However, there is a very important step that is often overlooked when embarking on a new IoT project: Device and Fleet Management.
While it’s cheap and easy to get started with IoT, once you exceed more than a handful of devices, and those devices are no longer on your desk, how do you continue to interact, manage, and maintain those devices? How do you deploy updated applications to them, if the devices end up located all over the globe? And how do you minimize downtime, or avoid traveling to the device to troubleshoot when things go wrong?
In this talk, we’ll take a look at best practices for IoT Fleet Management, introduce balenaCloud as one platform and methodology to help with this task, and cover some lessons learned maintaining fleets of IoT devices at scale.
More specifically, we will investigate:
Hardware selection
OS considerations
Workload segmentation
Containerization
Application updates
OS updates
Sample use-cases
Attendees will not need any specific knowledge or previous experience, but familiarity with Linux, Containers, and some Hardware fundamentals would be helpful to have.
Managing Software Components with Conan Package Manager
Presented by Amar Mahmutbegovic
C and C++ based firmware projects are often managed as monorepos—a single repository with all software components in one place, usually including third-party libraries to keep them in a desired state.
Conan is a package manager for C and C++ that allows us to handle dependencies through Conan recipes. Using Conan, we can download recipes and install them in the Conan cache, allowing other software components to use them. For each recipe, we can specify dependencies and their exact versions.
Conan works well with build systems such as CMake. We can build projects using Conan profiles, which allow us to specify all build options for CMake, making the build process a more seamless experience.
This talk will help embedded developers better understand the modern approach to package management using Conan. It will cover the following topics:
Marketing Malarkey and Some Truths About Ultra-Low Power Design
Presented by Jack Ganssle
Many systems need to run for years from small batteries. Vendors offer many solutions and even more promises. Alas, too often these are, at the best, wildly optimistic. Pick an MCU which only needs one electron a year to remain in a sleep mode and your system will still likely drain the battery in months.
This talk will present the results of 18 months of experiments on battery life, MCU sleep currents, and “sneak” circuits that drain charge from batteries. It is complemented by engineering analysis of real-world systems and what their actual power requirements are. Does PCB contamination effect battery life? Can a big capacitor give a millisecond power boost? What is the effect of temperature on these decisions?
The answers are surprising, and the bottom line is that none of us will achieve the battery lives touted in the trade press.
To achieve years of operation from a coin cell an MCU-based system must use the right components, careful analysis of energy needs and availability, and the proper algorithms in the firmware.
In this talk you’ll learn how to make these tradeoffs. And you may never trust a vendor promise again!
After several years in development, the Perseverance rover launched from Cape
Canaveral Florida on July 30, 2020 on its 300 million mile and 203 day journey to the
surface of Mars. The spacecraft successfully performed a precision landing at the
Jezero crater landing site on February 18, 2021 beginning its two year primary mission
and ensuring the continued flow of interplanetary science from the surface of Mars. The
command, control and communication of the spacecraft is carried out by the onboard
flight software (FSW) operating on the rover computer element (RCE) avionics. This talk
will discuss Mars exploration objectives and provide a background of the FSW used on
these missions.
Mastering Embedded Systems: Essential Skills and Trends for 2023
Presented by Lance Harvie
The topics I cover in this talk include passion for one's craft, upskilling to stay relevant and valuable in the market, and new trends such as RISC-V, Embedded Linux Kernel, and Yocto.
Additionally, leveraging ChatGPT can help individuals learn faster and prototype more quickly. Skills in demand include bare metal C, Rust, C++18/19, embedded Linux (kernel and user level), graphic libraries (open and closed source), cloud connectivity for analytics, security (chip and firmware level), open source RTOS's (RT-Thread, FreeRTOS, NuttX), debugging at the chip and firmware level, and expertise in robotics, EVs, medical devices, and IOT for industrial purposes.
Driver design is still a critical need in nearly every system whether it’s to improve access to a microcontroller peripheral or interface to an external chip. Designing drivers that meet performance, scalability, and reuse requirements can be challenging. In this workshop, we will explore various driver design techniques and walk through the design of both “internal and external” drivers on a microcontroller-based system.
Topics covered in this workshop:
Characteristics of good drivers
The software stack-up
API Design
Peripheral Driver Design and Implementation
External device driver design and implementation
C/C++ Driver Techniques
This workshop is designed to be interactive. There will be generic hands-on examples that can be applied to nearly any microcontroller-based development board.
The video showcases Memfault, a powerful device reliability platform that empowers hardware companies and firmware engineers to monitor their devices' behavior in the field, from just a few devices to millions. The platform features an intuitive crash analysis tool that mimics the experience of a debugger connected over JTAG to a device. With Memfault, developers can efficiently diagnose issues such as crashes, asserts, performance problems, and connectivity issues.
Accidents with memory are a well-known problem in the world of embedded systems. Now, they have entered the mainstream, with documents produced by the White House, NSA, and international cybersecurity organizations highlighting the threats posed by memory safety bugs. In the next few years, regulations will put increasing focus on these issues. So, what can we do?
In this talk, I will focus on the leading options for addressing memory safety:
One of the great things about being me (in addition to my dashing good looks and trend-setting sense of style) is that -- based on the fact that I write about high-tech topics for various online publications, coupled with my providing technical writing and consulting services to a cornucopia of high-tech companies -- I get to hear about many of the latest and greatest technologies before they appear on the market (I also get to write long sentences).
Even better, I’m not tied to any subject sector or technological territory; instead, I’m free to meander around gathering noteworthy nuggets of knowledge and tasty tidbits of trivia. At any particular time, you may find me learning about something like a new artificial intelligence neural network processor, after which I might find myself up to my armpits in virtual reality, and just a little later I could well be feasting my orbs on next-generation camera-sensor combos that are only 1 mm thick for use in state-of-the-art machine vision systems -- and all of this before I’ve had my breakfast.
In this presentation, we will take a tour around a curated selection of the weird and wonderful things I’ve been exposed to recently, including anything I’ve found interesting or has made me exclaim, “Ooh, Shiny!” As is usually the case in my presentations, we will be leaping from topic to topic with the agility of young mountain goats, so I urge you to dress appropriately and responsibly.
MING - An OpenSource LAMP-like stack for the Internet of Things
Presented by Marc Pous
Remember the LAMP stack (Linux, Apache, MySQL and PHP/Perl/Python) from the late 90’s when the World Wide Web was exploding into the public consciousness? As you’ll recall, LAMP came about as an answer to a set of challenges that the web development community were facing. At that moment, Open Source came to the rescue!
Time has moved on… Our team works predominantly within the Embedded Systems and Internet of Things (IoT) domain, but many of the challenges we face are parallels to those faced by the creators of the LAMP stack. This is why we think that the open source MING (MQtt, InfluxDB, Node-Red and Grafana) stack can enable the next generation of IoT Application developers.
With this masterclass we aim to take attendees through the journey we’ve been on as we’ve been developing Internet of Things solutions.
We talk through how Open Source solutions exist to fulfill these needs today, and how we arrived at the MING stack:
(M)osquitto for MQTT based assured data-comms using a publication/subscriber model
(I)nfluxDB for time-series data storage
(N)ode-Red for intuitive wiring of “nodes” to ingest telemetry data, transform, and deliver internally or to 3rd Parties
(G)rafana for data-visualisation and alerting
In particular, we will cover how each of these Open Source technologies can be managed and deployed using container platforms such as balena.io with balena “Blocks” to componentize each of the functional blocks within MING, to easily control, configure and update the stack.
MISRA C: A Focus on Writing Clear, Maintainable Code
Presented by Colin Walls
MISRA C is a programming standard that is focussed on writing safe, secure code using the C language. This is achieved by the definition of a number of guidelines that lead the developer away from operations and constructs that may compromise the safety of the code. By taking a fresh look at the standard, this session concentrates on the benefits of MISRA C in an additional priority in embedded software development: the writing of clear and maintainable code.
Mission Possible: An Emergency Release From the Beach with EBF
Presented by Timesys
Picture this: you’re on a beautiful, tropical island vacation with your family. You hear your phone ding. It’s your coworker: “We need an emergency firmware release tested ASAP.” Another late release, last minute fire drill…but you’re thousands of miles from the device you need to test. Your co-worker is stressed, but you’re calm, cool, and collected.
Why? Because you’ve got your secret weapon: EBF.
Timesys’ EBF, or Embedded Board Farm, is a test automation infrastructure that makes your boards remotely accessible for collaborative software development, testing, and debugging from anywhere in the world. It’s an easy, scalable way to bring your embedded device into your CI/CT process.
So how does it work? Embedded Board Farm’s REST API and Timesys IO controller hardware allow for seamless test automation on real hardware, pre-integrating with test frameworks including LAVA, Squish, Robot Framework, and Fuego. It also allows for automation of hardware tests (e.g. USB or ethernet hot plug, power control, and audio/video capture).
EBF puts project hardware and Board Support Packages (BSPs) at your fingertips by providing secure remote access for your developers, testers, support engineers, sales engineers and others. This is donely privately and securely behind your firewall, and is completely in your team’s control. You can develop and debug BSPs for any embedded OS (Linux, Android, QNX, etc).
Over the last few years, we're starting to see machine learning be more effectively deployed closer to where data is collected in embedded systems. These end point devices may be resource constrained though, either in terms of power, memory or communication capabilities - sometimes all three. Being able to apply machine learning on these end point devices is possible, and enables system-wide efficiencies to be realized. This talk will explore the requirements and tradeoffs for such systems to be considered when using the Zephyr RTOS and Tensorflow Lite for Embedded Microcontrollers projects.
Model-Based Design of IoT End Node Devices Via Matlab/Simulink
Presented by Nannan He
Model-based design is an emerging software development methodology for designing and implementing modern embedded systems. This presented research project examines the existing model-based techniques and modeling tools for developing dependable embedded software programs running on smart devices in IoT applications. To be specific, we experimented with a popular system-modeling tool called Matlab/Simulink from Mathworks. We developed a new set of Matlab libraries and Simulink models on low-power 32-bit ARM Cortex-M4 microcontrollers from STMicroelectronics. We also used the created Simulink libraries to build an embedded application for a smart home energy monitoring system as a case study. The case study demonstrates that it is much easier and cost-effective to develop reliable embedded end nodes for cloud-based IoT.
Modeling IoT Systems in a Reactive Computing Environment
Presented by Enzo Alda
IoT systems perform continuous data processing in real-time, transforming data from sensors into final results and actions. Complex IoT systems may feature multiple devices, with different hardware and real-time operating systems, yet having a common programming language to model such data transformations is a desirable property: makes it easier to simulate a complex system and verify its soundness. The presentation demonstrates a programming environment well suited for such a purpose: the audience will see how it embodies the reactive computing paradigm, why that paradigm is ideal for IoT systems, and how it is amenable to a wide-spectrum of users.
Modern C++ in Embedded Development: Compile-Time Observer Pattern
Despite C remaining the dominant language in embedded development, accounting for up to 65% of embedded projects, the adoption of C++ has grown steadily. With an estimated usage of 20% - 30% in the embedded development field, C++ offers classes, improved type safety, and quality of life features such as range-based for loops, the auto keyword, and lambdas.
Modern C++ provides a range of features that enhance the expressiveness and flexibility of codebases in embedded development while maintaining low binary size and memory usage. This session aims to dispel common misconceptions about C++, such as increased binary size and slow runtime performance, through an example implementation of the observer pattern. Attendees will gain insight into the simple yet effective application of Modern C++ for solving common problems in the embedded domain.
Topics covered in this talk will include:
Debunking embedded developers' misconceptions about C++
Modern C++ quality of life features: auto, lambdas, and constexpr
An introduction to templates and fold expressions
Implementing a compile-time observer pattern in C++
Modern C++ in Embedded Development: Expressive Compile-Time Computation
Presented by Amar Mahmutbegovic
C++11 made a significant impact on C++, bringing in features such as auto, lambdas, and constexpr. These features modernized language, making it more expressive.
This talk guides embedded developers who dominantly use C for their daily tasks through compile-time evaluation of functions and expressions in C++. It demonstrates language capabilities to generate lookup tables and mathematical signals in compile time while providing expressive abstractions similar to Matlab.
The talk will help embedded developers to better understand modern C++ capabilities, and it will cover the following topics:
Constexpr variables,
Constexpr functions,
Operator overloading,
Lambdas,
Templates,
Abbreviated function template.
The talk aims to demonstrate C++’s compile-time computation capability through a practical example while gradually guiding the audience through the language features needed to build the example.
Prerequisite: Solid knowledge of C, C++ classes, and traditional C enumeration types, as well as a basic understanding of simple C++ templates.
Good interface design is an important part of writing safe, reliable software. By writing interfaces that are easy to use correctly, we let software engineers communicate clearly and reduce maintenance costs. By using the type system to write interfaces that are hard to use incorrectly, we can catch many potential errors at compile time and improve development time.
In this session, we’ll take an existing C++ interface and look at how we can improve on it using Modern C++ features. We’ll see how Modern C++ lets you write enumeration types that avoid common problems and misuses. We’ll discuss new library types and language features that help you write interfaces with more convenient parameter passing and return conventions. We’ll also examine how you can use C++ attributes like [[nodiscard]] to get more feedback from your compiler and catch mistakes earlier in development.
scoped enumerations and underlying type specifiers
Modern Embedded Programming with Hierarchical State Machines and Active Objects
Presented by Miro Samek
Perhaps you've heard about hierarchical state machines (UML statecharts), modeling tools and automatic code generation, but have never tried them or seen them used in practice.
This presentation will show you, step-by-step, the process of designing and implementing a fun "Fly 'n' Shoot" game to run on an embedded ARM Cortex-M board as well as on your PC.
Specifically, you will see how to partition a problem into loosely coupled, event-driven components called active objects and then how to design interactions among them using sequence diagrams.
Next, you will see how to elaborate the internal behavior of identified active objects with modern hierarchical state machines.
And finally, you will see how the state machines are implemented in C and how this code can be generated automatically.
The session will utilize hands-on demonstrations using EFM32 Pearl-Gecko ARM Cortex-M4 board, the QP/C real-time embedded framework and the QM modeling and code-generation tool.
Some of the most difficult problems with real-time and embedded programing are related to concurrent code execution as well as code organization, which all too often degenerates into "spaghetti code". These problems are usually intermittent, subtle, hard-to-reproduce, hard-to-isolate, hard-to-debug, and hard-to-remove. They pose the highest risk to the project schedule.
This session presents a set of best practices of concurrent programming, which are collectively known as the active object (or actor) design pattern. In this pattern, applications are built from event-driven, non-blocking, asynchronous, encapsulated threads (active objects), with the internal behavior of each active object controlled by a state machine.
While active objects can be implemented manually on top of a traditional RTOS, a better way is to use an active object framework. You will see how this leads to inversion of control, enables architectural reuse, and allows the framework to automatically enforce the best practices.
In the second part, the session will introduce modern hierarchical state machines as the powerful "spaghetti reducers". You will see how state machines complement active objects and enable graphical modeling and automatic code generation.
The session will utilize hands-on demonstrations using EFM32 Pearl-Gecko ARM Cortex-M4 board, the QP/C real-time embedded framework and the QM modeling and code-generation tool.
I'd like to talk about how companies should think about and build out their IoT monitoring solutions using metrics. The differences between logs, metrics, and traces have been talked about at length in the software engineering space, but not for firmware. Using metrics to monitor a fleet of devices allows for assessing the health of thousands to millions of devices, even across groups of devices or firmware versions, all while keeping complexity, bandwidth, and power consumption to a minimum.
Takeaways:
Know how to think about and build a metrics library for gathering compressed and aggregated metrics on devices
Understand the differences between logs, metrics, and traces, and why using metrics is the best way to monitor fleets of devices post-deployment.
Know the next steps on how to ingest the data in a server under their control to do monitoring analysis.
Learn some formulas for calculating fleet health, such as expected battery life, crash free hours, and average connectivity per hour.
Multirate Polyphase Filters and Filter Banks, (GREEN Technology, also known as DSP Magic)
Presented by fred harris
Recently, someone posted a question on a DSP blog I visit occasionally. How does one design a very narrow bandwidth low pass filter? One version of the problem is a filter with 10 Hz wide pass band, a 10 Hz wide transition band, and a 1 kHz sample rate. Stopband attenuation >80 dB with passband ripple <0.01 dB. This a very bad combination: low transition bandwidth with high sample rate! I think students post their homework problems on the blog so I seldom volunteer to do their homework. I did however read the many suggestions posted on the blog submitted by regular subscribers to the blog. They were interesting to read but nothing clever and of limited value. Some were just plain silly, but to quote a famous line, “who am I to judge?” The consensus was that some problems are hard and require lots of resources, this is one of them! All it takes is lots of filter coefficients and lots of multiply and adds. 405 taps seemed to be about the right number. When I read one suggestion from someone I know at Westminster University in London, I simply had to throw my hat in the ring. It then became a game: how small could you make the filter and still satisfy the specifications? For a week I submitted daily solutions requiring fewer and fewer coefficients. I started at 38 M&A per input sample and I stopped when I reached 6 M&A per input sample!
The presentation will show how to build narrowband filters with more than an order of magnitude reduction of workload. The only requirement is that there be a large ratio of sample rate to bandwidth. Once we learn the simple trick to accomplish this reduction we pose the question, Can we achieve similar reduction in workload when there is not a large ratio of sample rate to bandwidth? The answer surprisingly is yes! We will share the recipe for the secret sauce so you too will know how wideband filters can also be implement with more than an order of magnitude workload reduction. How about an I-Q filter pair with 1400 taps per arm replaced with a resampling filter requiring only 100 real multiplies?
In this session, embedded systems consultant and author Jacob Beningo discusses MicroPython and how it is being used today to build products. Jacob also provides an overview of his new book MicroPython projects and demonstrates a gesture controller written completely in MicroPython.
MySQL is a highly favored embedded database, trusted by many of the world’s largest software companies, as well as numerous startups and mid-tier ISVs, to drive their applications, appliances, and devices.
Join this demo to learn how integrating MySQL as an embedded database can enhance three key business metrics—costs, revenue, and risk.
Mysteries of the Ancients: Binary-Coded Decimal (BCD)
Presented by Clive "Max" Maxfield
It has to be acknowledged that growing old is not as much fun as I had hoped it would be. Having said this, one of the great things about being old (I’m clutching at straws) is that you end up having learned a whole lot of “stuff” about a whole lot of “stuff” (some of this stuff may even be useful).
When most people hear the term “binary-coded decimal (BCD),” they think “I know all about that” (they usually don’t) and “no one uses BCD anymore” (you’d be amazed how much they do).
Apart from anything else, engineers in the early days of digital computing had to do a lot of “stuff” using not much “stuff,” as it were. As such, BCD provides a great platform to introduce all sorts of cunning tricks, many of which may prove to be useful in modern designs.
In this presentation, we will dive headfirst into the BCD fray with gusto and abandon (and aplomb, of course). As is usually the case in my presentations, we will be leaping from topic to topic with the agility of young mountain goats, so I urge all attendees to dress appropriately and responsibly.
NanoEdge AI Studio's simplifies the creation of machine learning, anomaly learning, detection and classification, regression and outliers libraries for direct implementation on any STM32 microcontroller. NanoEdge AI Studio makes it easier for users to integrate such cutting-edge machine-learning capabilities quickly, easily, and cost-effectively into their equipment. No data-science expertise is needed.
Do you have questions on NanoEdge AI Studio and how you can implement edge AI machine learning capabilities on our STM32 microcontroller family? Feel free to ask in the comments section.
Join this webinar to understand step-by-step how to port your machine learning model from your preferred development environment to an MCU. We will go over a few of the pipelines available to you and cover:
This will be a short (20 minutes or so) information session where Jacob and Stephane will present the concept of Micro-Talks, which will be introduced for the first time in the EOC this year.
Jacob will also show an example of a MicroTalk by presenting Why Function Pointers are Awesome.
Nobody likes doing static analysis, but we all know that it helps improve software quality early in the development cycle. In my day-to-day job I see many people struggle with this challenge, especially in deeply embedded projects. In reality though, integrating static analysis is not complicated, the technology exists to turn static analysis into the superpower that enables your development teams to deliver better quality code faster:
Integrate static analysis into the workflow, such that it happens automatically
Make it easy for developers to understand the results and make corrections
Automate acceptance gates
Scale compute
This section will be a generic overview of the technology that you can use immediately: - Integrate static analysis into GitLab, GitHub, Gerrit, BitBucket, Jenkins, ... - Containers to standardize build environments for native and cross compilation - Use Kubernetes to scale compute, either in your own data-centre, AWS, GCP, Azure or others - IDEs to bring the results to developers desktops.
Since this is a conference about embedded systems, and assuming most of the attendees have something to do with developing these systems, one might think there is some level of expectation that everyone taking part could agree on a definition as to exactly what is (and isn’t) an embedded system. Ah, if only life were so simple.
In this wide-ranging presentation, Max will first rend the veils asunder and make you look at embedded systems from a new perspective. Next, he will briefly consider the evolution of embedded systems leading to today’s state-of-the-art embedded technologies. Finally, he will cogitate, contemplate, and ruminate as to where we are headed in embedded space (where no one can hear you scream).
Max warns that participants will be leaping from topic to topic with the agility of young mountain goats, so he strongly recommends that attendees dress appropriately.
This session will be about how NXP technologies enable Industrial automation in smart factories with our latest and greatest innovative products. From I/O modules and PLCs, to Motor Control and Industrial Networking - this session will give you an overview of what are the latest Industrial trends and customer requirements and how NXP portfolio makes this happen. We will also have a look at how NXP's enablement and support for these products helps customers to shorten their design in time. Lastly, we will also be giving you a feel of the future with our progressive roadmap of Industrial products.
Object Classification Techniques using the OpenMV Cam H7
Presented by Lorenzo Rizzello
Machine Learning for embedded systems has recently started to make sense: on-device inference reduces latency, costs and minimizes power consumption compared to cloud-based solutions. Thanks to Google TFLite Micro, and its optimized ARM CMSIS NN kernel, on-device inference now also means microcontrollers such as ARM Cortex-M processors.
In this session, we will examine machine vision examples running on the small and power-efficient OpenMV H7 camera. Attendees will learn what it takes to train models with popular desktop Machine Learning frameworks and deploy them to a microcontroller. We will take a hands-on approach, using the OpenMV camera to run the inference and detect objects placed in front of the camera.
Objectively Measuring the Reliability of IoT Devices
Presented by Tyler Hoffman
Presented by Memfault
In the realm of IoT devices, the metric that reigns supreme is device reliability. When managing thousands or even millions of devices, tracking this metric becomes paramount.
While Mean Time Between Failure (MTBF) has been a historical stalwart for assessing product stability, its utility diminishes when dealing with extensive device fleets and complex operating patterns.
Join us in this talk as we introduce a groundbreaking metric for evaluating the reliability of expansive device fleets: Failure Free Hours. Discover how this metric unveils the frequency of firmware faults, unexpected device reboots, and core function failures. Through a systematic approach to calculate this metric device operators and engineers gain the power to actively monitor and enhance IoT fleet reliability, thereby ensuring seamless operations and exceptional user experiences.
Believe it or not, it's possible (and encouraged!) to use object-oriented programming (OOP) in plain-old C. Object-oriented code exhibits the qualities of abstraction, encapsulation, polymorphism, and inheritance, and these qualities can help make an application easier to write, debug, and change. In this talk, I'll demonstrate how to do achieve these qualities in C, ranging from the simple to the complex. This talk is based entirely on work I share publicly here: https://github.com/nathancharlesjones/Comparison-of-OOP-techniques-in-C.
This talk will explore what open source hardware actually means and how engineers, academics and scientists are using it to work together and share knowledge all over the world. We’ll take a whistlestop tour of the exciting world of open hardware, from DEFCON-inspired PCB badge culture to the instruction sets used in the chips that go on them. We’ll also learn about some inspiring open source hardware engineers, including Twitch streamers, successful independent product designers and the team on a mission to create a computer system that is open source all the way down to the lowest level possible -- the transistor.
Open Source OTA Updates and Reporting for Edge Devices
Presented by Dustin Reynolds
Companies often release devices based on features the customer cares about while neglecting hidden features such as security, updates, error monitoring, and application logging. Operating system and application updates are straightforward to implement and provide companies a path to fix security vulnerabilities and improve device performance through the life of the device. Application reporting allows you to close the loop in understanding device performance in the field so you can target the most critical updates
OpenPLC: A Unique Approach to Programming Microchip Atmega328 microcontrollers
Presented by Dr. Don Wilcher
The traditional approach to programming a microcontroller has been with high-level languages like C or C++. Programmer Tools like compilers are used to take the high-level language code and disassemble it to a machine code format. A no-code approach can now be used to program a microcontroller using a ladder diagram programming language. In this talk, an open-source ladder diagram programming platform called OpenPLC will be discussed. OpenPLC is based on the International Electrotechnical Commission (IEC) 61131-1 Functional Programming Languages standard. Participants will learn the basics of a programmable logic controller ladder diagram and how to implement control function tasks using the OpenPLC Editor. The OpenPLC Runtime environment for programming and monitoring the control functions embedded on the microcontroller will be presented in the talk discussion. The Arduino Uno -Microchip ATMega328 based platform will be the development tool for implementing specific OpenPLC control function tasks.
Most modern embedded applications employ and operating system of some sort. We will look at how operating systems work - the scheduler and various services provided by an OS to the application code - and at the options open for OS selection. We will also compare the use of commercial, open source and in-house products.
Optimizing the Developer DevSecOps Experience for Embedded Systems
Presented by Mark Hermeling
Presented by CodeSecure
Providing software developers with flexible, fast workflows in which they receive
the information they need at the time they need it is crucial, especially in embedded systems.
Embedded systems have strict security, safety, and quality standards to adhere to.
Building guidance for these standards into the workflow makes developers more efficient,
allows them to learn as they go, and ultimately reduces risk while helping the team meet deadlines.
These workflows include static and dynamic testing, testing on hardware, server-based
and local build options, as well as hardware-based debug workflows.
GitLab has extensive support to automate all these actions, which is what we’ll
demonstrate during this presentation.
Drive all actions through an IDE (VS Code)
Use Merge Requests to track all actions
Use AI to automate common programming tasks
Use Security Policies to drive security fixes before merges
Find deep security findings and remediate them easily using CodeSonar
Automate testing on hardware in a remote hardware lab
This in-workflow pipeline automation saves engineers many hours per month,
allowing them to spend more time building secure and safe software.
All artifacts used during this presentation are publicly available, and links will be provided.
Otii Arc – Power Analyzer, UART Sync, Power Supply
Presented by Qoitech
Otii Arc is the ultimate tool for any
developer wanting to design highly energy efficient hardware and software. It
is a power analyzer, UART log sync and power supply in one powerful tool. Otii
Arc comes with featured packed standard Otii software (perpetual license).
Comprehensive and accurate yet affordable and easy to use – for every
developer’s desktop.
Book a 1:1 demo with our Power Specialist Björn Rosqvist here:
We’ll be giving away 2 Otii Arcs. All you need to do to participate in the raffle to win one is to book a demo session with our Power Specialist during May. Write EMB21 in the “How did you find us” section when you book.
Get to know more about Otii Arc, the UART function or how to automate your testing throughout the development cycle. Watch the demo above!
Endless patching is a race that cannot be won. To build sustainable, secure IoT solutions we must change that ineffective paradigm.
To appreciate what we can do differently, we should start by considering both the defender's and attacker's perspectives. This session will provide a unique view of that attacker's perspective, from former exploit/attack experts within the IDF Unit 8200. We will review the impossible task of identifying and mitigating all vulnerabilities - and will demonstrate the inadequacies of current IoT security practices focused on continuous patching, static analysis, encryption and risk controls. We will also explain how attackers can easily evade such barriers.
By contrast, the session will explore methods for achieving embedded, on-device runtime exploits protection to immunize devices from all underlying vulnerabilities, and provide zero-day protection as well. These methods, commonplace in IT endpoint detection and response, are just now finding their way into heretofore unprotected and unmanaged IoT edge devices.
Overcoming Obstacles for Developing Exceptional Embedded User Interfaces
Presented by Nik Schultz
Presented by Crank Software
The route to developing exceptional user interfaces (UI) is often not a straight one. Nearly all projects encounter detours (prototyping, testing, and design changes) that can often derail the project.
Historically, changes at the design level resulted in teams needing to hunt for and replace all changed assets manually. This would result in changes being missed, coded behavior being lost and ultimately, poor UX.
Join Crank Software, leaders in embedded GUI development, to learn how to streamline design changes and develop embedded GUI applications that provide outstanding user experiences while getting to market on a tight deadline.
Painless Multithreading: How to Verify RTOS Best Practices in Runtime
Presented by Dr. Johan Kraft
Developing reliable and performant RTOS applications is easier said than done, and is greatly facilitated by a solid software design that follows best practices in RTOS application development. While an RTOS makes it easier to develop more advanced applications, the use of multithreading brings new challenges in software design, verification and debugging. Such issues are often not apparent in the application code.
In this presentation, we will discuss a selection of best practices in RTOS-based software design and the concept of visual trace diagnostics. Finally, we will explore how visual trace diagnostics can be used to analyze the software design and detect deviations from best practices.
A typical embedded system has no security structure. If a hacker breaks in anywhere he has access everywhere — to the keys, critical data, and everything. Secure coding is a great thing to do, but it only takes a single flaw to compromise the whole system, and on a system with thousands of lines of code, it could take a long time to find and fix all problems. It’s a never ending battle because new exploits are conceived continually. Partitioning greatly limits the scope of an intrusion and allows focusing secure coding efforts on the most critical partitions. This talk focuses on use of the Cortex-M Memory Protection Unit to partition the application and RTOS for security. After introducing the MPU and partitioning briefly, it discusses novel techniques at a fairly detailed level. It shows the mechanics with code and build file snippets.
Percepio DevAlert - IoT Device Monitoring and Diagnostics
Presented by Percepio
People often have problems with IoT devices due to software issues, and the developers are largely unaware. What if IoT device developers could be notified about real-world issues in IoT devices automatically and get detailed diagnostics on the very first occurrence? This is provided by Percepio DevAlert, a novel cloud service that gives real-world feedback about issues in the device software, that allows for rapid continuous improvement and for embracing DevOps in IoT device development. Learn from real-world usage and make a great product that beats the competition.
This is a brief summary of the full presentation, found at
https://percepio.com/devalert
Percepio Tracealyzer - Efficient Firmware Development with Visual Trace Diagnostics
Presented by Percepio
Learn how visual trace diagnostics can improve embedded software development. This is a short summary of the full presentation, found at https://percepio.com/tracealyzer
Polyphase Analysis and Synthesis filter banks, a very important segment of the multirate signal processing community, are the most incredible signal processing algorithms. Your first reaction to your understanding them is: “I’ll be darned!” Your second reaction is: “I can hardly wait to tell all my friends about this!” Do you know about these things?
Let’s start with the analysis filter bank which has a dual structure called the synthesis filter bank. Each does the opposite of the other. The analysis channelizer processes a sampled data input signal spanning a wide frequency band containing many contiguous narrow bandwidth channels. The result of that processing is a set of narrow bandwidth signals translated from their original centers to baseband and low-pass filtered to their channel bandwidths to separate them from their neighbors and further down sampled to a rate commensurate with their reduced bandwidths. This process for a single channel is called a digital down converter (DDC). The remarkable property of the analysis channelizer is the cost of M (say 100) channels is only about the cost of 5 channels. Amazingly the process occurs in a completely different manner and order of what you would imagine! Rather than down convert, filter, and reduce sample rate, the sample rate is reduced on the way into the filter bank and the processing is performed at the reduced output rate instead at the high input rate.
If we were a fly on the wall we might overhear this conversation between a potential buyer and the salesperson in the polyphase analysis filter bank store. The customer asks “What will a single channel DDC cost me?” The salesperson answers “It will cost you $10”. The customer then asks “What will 10 equal BW channels of DDCs cost me?” The salesperson answers “it will cost you $100 but if you are interested, we have a special this week; we have a 100 channel DDC for only $50. For that price, you can compute all 100 channels, throw away 90 of them and still have your 10 channels at a reduced price!” Which option do you think the customer will buy? Have we caught your attention?
There is surely another store in town that sells synthesis filter banks. These banks up sample many baseband narrowband signals a higher sample rate and translates the baseband signals to selected center frequencies to form a composite broadband spectrum. These are digital up converters (DUCs). The two filter banks are duals of each other; one uses aliasing caused by down sampling to translate all the band center signals to baseband and a clever trick to separate the aliases while the other uses aliasing caused by up-sampling to translate all the baseband signals to selected band centers and the same trick to perform the dual task of separating the up-sampled aliased spectral bands.
We will review the signal processing sequence of the M-path analysis and synthesis channelizers. We will then go through all the steps to implement the MATLAB realizations of the same and illustrate performance and methods of verifying its operation. This is a process you have to do three or four times till it finally clicks. I have former students contact me and ask “Remind me why we did this thing at this point in the script?” Reset time!
Polyphase Wide-Bandwidth Filters Implemented with Order of Magnitude Workload Reduction: Capabilities and Implementation
Presented by fred harris
We examined Polyphase Analysis and Synthesis filter banks in an earlier workshop. The two filter banks are duals and can operate independently of each other. In this
workshop, we use both banks in a tightly coupled manner to synthesize broadband
filters with an order of magnitude workload reduction. For this design process,
the filter bandwidths are a large fraction of the sample rate. Since the target
filter specification has a wide bandwidth, it would seem that the signal
processing that we conduct here can’t be the same as that used in the analysis
filter banks. That is we can’t reduce the sample rate to the reduced bandwidth
of the signal and operate the script at the reduced clock rate as we did in
channelizer designs. In fact, we can do that! We can form a filter with a wide
bandwidth from a set of narrow bandwidth fragments of the wide bandwidth system
by using the perfect reconstruction properties of the analysis channelizer’s
Nyquist segments. The synthesis channelizer seamlessly reassembles the desired
wide BW filter from multiple contiguous narrow BW fragments formed by the
analysis channelizer. The process trivially accommodates sample rate changes if
there is a BW reduction in the assembled band as well as frequency offsets and
Hilbert transforms. The remarkable attribute of this process is the order of
magnitude reduction in computational workload of the composite processing chain
relative to the direct implementation of the same process.
We will build
the MATLAB processing chain of the Analysis and Synthesis filter banks and then
demonstrate variations of how they interact to simulate variable BW, variable
sample rate, and variable frequency shift operations
The importance of power management in today’s embedded designs has been steadily growing as an increasing number of battery powered devices are developed. Often power optimizations are left to the very end of the project cycle, almost as an afterthought. In this session we will discuss design considerations that should be made when starting a new power sensitive embedded design, which include choosing the hardware with desired capabilities, defining a hardware architecture that will allow software to dynamically control power consumption, defining appropriate power usage profiles, making the appropriate choice of an operating system and drivers, choosing measurable power goals and providing these goals to the software development team to track throughout the development process.
Power Management on Linux: From the Hardware to the Kernel and User Space Interfaces
Presented by Sergio Prado
Power management on modern hardware is quite complex. There are so many concepts and features provided by the hardware like frequency scaling, idle states, wake-up sources, sleep states, suspend-to-RAM, hibernation, etc! All this needs to be abstracted so kernel and user space code can properly manage power consumption.
In this talk, we will deep dive into all these concepts, from the resources provided by the hardware to standard and portable software interfaces provided by the kernel and consumed by device drivers and user space applications, including tools and techniques to monitor and improve power consumption on an embedded Linux system.
Embedded robots have varied power needs: including their microcontroller, motors / actuators, sensors, and communications. A proper power distribution design enables the robot to avoid ‘brown out’ when its wheels require more torque on difficult terrain. As well as protecting from fluctuations that may interfere with the reliable operation of sensors and communications. This talk will show how both the electronics and embedded sides are applied together. The embedded robots focused on are small 40 - 70 W mobile rovers (ie, Pathfinder sized, or Vex / FTC sized), and wearable companion robots that are typically powered from a limited supply. he concepts discussed will be illustrated with hands-on lessons learned from my robotics projects.
At the end of this talk you should be able to:
Design a power distribution setup for your robot
Identify the electronics factors involved with power distribution
Estimate efficiencies and battery life
Analyze power usage with external measurement, and data logging on microcontroller
Practical Approach for High-End Embedded System Design
Presented by Khalil Rashid
Embedded system design is very challenging as it requires multi-disciplinary expertise in Hardware, Firmware and Software. Most of embedded systems developments ends up as a failed project or not delivering performance as planned initially.
This can be address by proper planning and selection of suitable hardware and software components. Also design goals and parameters to consider a very important to be evaluated before starting project like:
Hardware Complexity
Software Complexity
Time to Market
Development Cost
Certifications
Functional Safety and Security
Feasible Solution
In this seminar, we will learn how to plan a complex Embedded System from hardware, firmware and software point of view. Furthermore, we will see how actually each part will be developed by utilizing Standard off the shelf components available. This makes design simple, cost effective, feature rich and most feasible for particular market.
Writing secure embedded software is a challenging task. What's more, what might be considered secure today may not be secure tomorrow. A Zephyr application is composed of many components, from the Zephyr kernel, to device drivers, to vendor HALs, to application code, and it can be difficult to exactly identify the components you're depending on to be able to assess whether you're vulnerable to a particular CVE or not.
This talk will show you in very practical terms how to leverage state of the art standards and tools to precisely identify the "manifest" (a.k.a. Software Bill of Materials, SBOM) of your Zephyr application, and how to use that information to assess your security posture and to respond to security incidents.
We will demo a variety of tools that you may want to add to your development workflow to generate Zephyr SBOMs, visualize the information they contain, check them against known vulnerabilities, and more.
Practical Strategies for Developing with the QP Framework
Presented by Jeff Gable
Quantum Leap's QP framework offers a compelling alternative to traditional RTOS solutions for hard real-time, high-reliability embedded software development. The event-driven hierarchical state machine framework and implementation of the actor model are excellent for effectively managing complexity and preventing common concurrency issues. However, good resources and examples of design patterns using QP for common microcontroller use cases are limited.
This talk provides an opinionated guide to developing a complex microcontroller application using the QP framework, in C or C++. I’ll cover device drivers, shared I2C and SPI buses, board communication with USB and/or UART, host-based unit testing, and design patterns for controlling electromechanical systems.
By the end of this talk, you should have a roadmap for how to use QP in your next microcontroller project.
While digital filter design – given a filter specification - is very well covered in numerous works, the essential practical question of how to arrive at the filter specification from the application is largely ignored: so the practicing engineer is faced with a well developed design methodology, but very little information to guide in specifying what to design. Similarly, there is little information available to guide decisions on the hardware platforms that are suitable to implement such a specification – including balancing issues such as numeric precision, speed, cost and power consumption – to assess whether the requirement may be met in a cost effective way: so the practicing engineer has limited guidance in deciding whether the application requirement may be met at all given practical constraints. The result is that engineers have limited ability to quickly assess whether a filtering requirement can be met: and digital filters very often under- or over-perform and are often implemented on needlessly costly or power-hungry hardware platforms. This talk addresses these twin gaps in the filter designer’s toolbox and outlines, with specific methods and examples, how the specification for a digital filter may be arrived at from consideration of the application aim and requirement. It also describes, again with specific methods and examples, how to arrive at a specification for the hardware platform necessary to implement such a filter. It does not address the issue of designing such a filter, which is very well covered in numerous texts elsewhere.
Pre-Conference Orientation with Jacob and Stephane
Presented by Jacob Beningo
In this short live session, Jacob and Stephane will welcome you to this years conference and explain all the "need to knows" like how to navigate the conference, setup your schedule and take full advantage of your participation.
Diagnosing Oral Cavity Cancer (OCC) in its initial stages is an effective way to reduce patient mortality. However, current pre-screening solutions are manual and the resultant clinical treatment isn’t cost-effective for the average individual, primarily in developing nations. We present an automated and inexpensive pre-screening solution utilizing Artificial Intelligence (AI) deployed on embedded edge devices to detect benign and pre-malignant superficial oral tongue lesions. The proposed machine vision solution utilizes a clinically annotated photographic dataset of 9 types of superficial oral tongue lesions to retrain a MobileNetV2 neural network using transfer learning. In this approach, we also utilized TensorFlow Lite for Microcontrollers to quantize a 32-bit floating-point (float32) precision model into an 8-bit integer (int8) model for deployment on power and resource-constrained OpenMV Cam H7 Plus embedded edge device.
The Cyber Resilience Act is a European effort to raise the cybersecurity level of industrial products. It aims to help European consumers make informed choices when buying a product, and lay down the normative work needed for the industry to make that happen.
The CRA's details were debated by the European Commission last Fall. Circa 2024, when the legislation will start getting transposed into national laws, we should be prepared for guaranteeing that the software running on our connected devices is secure. With fines up to 2.5% of the annual revenue of your company, you might want to look at CRA. Let's decipher the text and get a grasp at what awaits us.
Preparing for the Future of Embedded C Programming: An Overview of the Upcoming ISO/IEC 9899:2023 C Standard
Presented by Niall Cooling
The ISO/IEC 9899:2023 C programming standard (C23) has been finalised and is set to release in the near future, and it is expected to bring several changes and improvements to the language. This talk is specifically aimed at embedded C programmers, who will benefit from understanding the changes in the upcoming standard.
The talk will begin by providing an overview of the significant changes and improvements that the new standard will introduce (with a quick review of C11 and C18) of interest to the embedded programmer. Many changes include an aim to “harmonize” with modern C++ and improve code interoperability. The presentation will also cover the potential challenges and issues that embedded C programmers may face when migrating to the new standard. This will include an overview of the potential compatibility issues and the need to update existing code and development practices.
The talk will conclude by highlighting the benefits that embedded C programmers can expect from adopting the new standard, including increased reliability, and reduced development time and costs.
The overall goal of the presentation is to provide embedded C programmers with a comprehensive understanding of the upcoming changes to the C programming language and how it will impact their work.
Prototyping DSP algorithms on real-world signals using MATLAB
Presented by Gabriele Bunkheila
DSP engineers across Industry and Academia have long been familiar with writing MATLAB code for early algorithm exploration and signal analysis. In many situations, signal processing algorithms also need validation using real-world signals, which in turn often drives the need for real-time implementations.
In this talk, we discuss practical coding advice for creating real-time DSP prototypes directly using MATLAB programs. The goal is to process real-world signals, such as signals streaming from audio devices or software-defined radios, but remove the complexity of hardware and real-time programming. Throughout the session, we use practical code examples, including digital filtering and other common signal processing tasks. Some programming experience will be beneficial, but it is not required.
Prototyping Industrial Control Concept Applications Using MicroPython and the BBC micro:bit.
Presented by Dr. Don Wilcher
Automation is being impacted by smaller more efficient programmable logic controllers (PLCs) and programmable automation controllers. With such controllers, mechanical based systems, like conveyors, transfer stations, hydraulic, and pneumatic machines are able to operate at higher efficiency and quality performance. Therefore, how can innovative industrial controllers be implemented to ensure manufacturing processing and methods can be adjusted properly with reliability and accuracy? In this virtual talk, industrial control application concepts using MicroPython and the BBC micro:bit will be explored. The big ideas to be learned in this talk are prototyping methods in the development and validating sensing, detection, and control applications using MicroPython and the BBC micro:bit.
PYNQ: Using FPGA to Accelerate Python applications
Presented by Adam Taylor
PYNQ is an open source Python framework from Xilinx which enables Python developers to access the performance provided by programmable logic, traditionally in the realm of electronic engineers. Being able to access programmable logic from Python brings with it acceleration factors of 10x, 100x and beyond to applications. This session will introduce the PYNQ framework, before demonstrating a number of image processing and machine learning applications developed using the PYNQ framework, showcasing not only the performance boost but also the ease of use.
Qt for MCUs. Ultimate performance. Tiny footprint.
Presented by The Qt Company
Qt for MCUs is a complete graphics framework and toolkit with everything you need to design, develop, and deploy GUIs on MCUs. Run your application on bare metal or a real-time operating system.
Smartphone-like UX
Reuse code across MCU/MPUs
Fast development with Qt’s tools and UI language
The demo features use cases for different industries.
Catch the ‘Smartphone-like user interface without compromising on performance’ session by Aurindam Jana or find out more about Qt for MCUs here: https://www.qt.io/qt-for-mcus
Control loops are ubiquitous in various applications where we wish to maintain or stabilize process variables to a desired set point or value. The speaker, Dan Boschen, brings a wealth of experience in the mixed signal (digital or analog) practical control loop design of microwave synthesizers, modems and radio transceivers, and, most recently, atomic clocks.
In this live workshop, Dan will first provide an overview of control loop theory sufficient for the implementation of a Phase-Lock-Loop (PLL). Topics covered will include:
Transfer Functions
Loop Order and Tracking
Stability
Bode and Nyquist Plots
Noise Transfer Functions
PLL implementations in both the analog and all-digital domain will be detailed for practical implementation. The modeling and simulation of control loops will be demonstrated with use of the free Python programming language.
This is a great opportunity for anyone wishing to get a quick jump start on practical control loop implementations in both the digital and analog domains, and to see what Python can offer for use in the simulation and modeling of control loops.
GNU Radio is a framework to implement software-defined radio applications on standard PC hardware, embedded systems (from handheld spectrum analyzers to Raspberry Pis) to servers. This talk will take the surprise out of how to implement a very simple transmitter and a matching receiver application, where to go from there, how to improve upon existing designs, and address common pitfalls.
The audience will be introduced to the flowgraph as a means of describing a signal processing application, to core GNU Radio concepts, important design patterns, and how they interact with common communications engineering approaches. As a prerequisite for following the talk, you should be familiar with the basics of signals. An understanding of complex baseband and IQ signals will enhance the value of the talk to the reader, but is not strictly necessary.
To (optionally) replicate the examples shown, a computer running a recent version of Windows, Linux, or Mac OS on which the user is able to install software is required.
Rapid Development of Hardware Prototype Concepts using an AI LLM and a Renesas EK-RA2E1 Kit
Presented by Dr. Don Wilcher
Developing a hardware prototype proof of concept (PoC) does not require a major investment in electronic components and test equipment. Such electronic components and test equipment include active integrated circuits, electromechanical tactile switches, LEDs, oscilloscopes, and function generators. Several prototype PoCs can be built quite rapidly using an embedded hardware development board or kit, one to three electronic modules, and an AI LLM.
Another item that can aid in providing design focus when engineering a PoC is the use of Maslow's Hierarchy of Needs model. The model has five characteristic levels that can identify the customers’ requirements. With such a model, a needs analysis can be included within the hardware PoC development process.
This talk will illustrate the application of Maslow's Hierarchy of Needs model with an AI LLM to create a 3-bit binary counter for a PoC controller. The Renesas EK-RA3E1 kit will serve as the rapid hardware development platform for the project demonstrator.
This talk will present and revisit very briefly the concepts of Polyphase Filter Banks. The idea is to show applications with real-life and actual implementations over RFSoC devices. In this talk I want to show you what are the details to keep in mind when going from Matlab to FPGA: arthitectural decisions, clocking schemes, fixed-point issues, etc. I will make available the Vivado project together with all the source files for different RFSoC platforms.
Real-time systems must respond to events in a timely manner. We view this as a software thing, when in fact it is a systems problem. The hardware and software should be tuned to achieve the response times we need.
In this talk you’ll learn how to profile software execution times, understand hardware design tradeoffs for working with high-speed systems, and we’ll look at some common myths about how real-time systems should be designed. And, as embedded people, we often have the ability to trade off hardware versus software to achieve the best performance.
Reconfigurable Acceleration Platform: Harnessing FPGA Potential at the Edge
Presented by Efinix, Inc.
This presentation introduces Efinix’s Reconfigurable Acceleration Platform, which is an initiative that helps designers intuitively incorporate FPGAs into domain-specific compute applications. We show an edge vision SoC demonstration that illustrates how you can accelerate image processing functions using hardware/software co-design featuring a RISC-V processor. Additionally, we discuss an image classification accelerator from our partner PlumerAI.
Remote Debugging & Monitoring for IoT Devices at Scale
Presented by Memfault
In this demo, you'll see how Memfault collects performance data like battery level and connectivity information and provides engineers with actionable insights. When an error happens, Memfault sends your team all the information you need to fix it right away. No need to reproduce it or ship the device back to the office. By automating data extraction, deduplication, aggregation, and alerting, Memfault reduces the detection of issues to minutes or hours instead of days or weeks.
Memfault's cloud-based firmware issue detection and resolution features dramatically reduce engineering and support overhead, enabling you to ship and manage thousands to millions of IoT devices with confidence.
Replacing printf; Effective Debugging Techniques for Arm Microcontrollers
Presented by Niall Cooling
Debugging microcontrollers can be a challenging task, especially when trying to diagnose runtime issues. Probably the most popular method for debugging is the use of print statements, such as printf, to output information to a console. However, the overhead of using printf can impact the system's performance and may not be suitable for all situations. In this talk, we will review the use and overhead of printf for runtime debugging and introduce alternative techniques using Arm Coresight. Specifically, we will explain the ITM and ETM options available in Arm Coresight and describe the ITM architecture. We will also differentiate between JTAG and SWO debugging on the Arm Cortex-M series and cover basic SWO output. Finally, we will introduce an open-source tool that provides expansive runtime diagnostics for microcontrollers.
By the end of this talk, attendees will better understand the various debugging options available for microcontrollers and how to use them in their projects effectively.
Resampling Filters: Interpolators and Interpolation
Presented by fred harris
The first time I had to design an interpolator to change the sample rate of an existing time series from one sample rate to another sample rate was in the early 1960s. A group of engineers were determining the acoustic signature of a ship in San Diego Harbor. Two small vessels circled the ship and collected samples of the ship’s sounds to be cross correlated off-line in a main frame computer. Imagine our surprised response when we realized that the two collection platforms had operated at different sample rates to collect their versions of the sampled data signal: 10 kHz and 12 kHz! You can’t correlate time sequences that have different sample rates! It was an interesting learning process.
My Webster’s Second Collegiate Dictionary lists, in its third entry, a math definition of interpolate as: “To estimate a missing functional value by taking a weighted average of known functional values at neighboring points.” Not bad, and that certainly describes the processing performed by a multirate filter. Interpolation is an old skill that many of us learned before the advent of calculators and key strokes replaced tables of transcendental functions such as log(x) and the various trigonometry functions. Take for example the NBS Applied Mathematics Series, AMS-55 Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables by Abramowitz and Stegan. This publication contains numerous tables listing functional values of different functions, sin(θ) for example, for values of θ equal to …40.0, 40.1, 40.2,….etcetera. Interpolation is required to determine the value of sin(θ) for the values of θ between the listed values. Interpolation was such an important tool in numerical analysis that three pages in the introduction of the handbook are devoted to the interpolation process. Interpolation continues to be an important tool in signal processing and we now present and discuss the DSP filtering description of the interpolation process.
The ability to change sample rate of a sequence to another selected sample rate has become the core enabler of software defined radios and of sampled data communication systems. Synchronizing remote clocks on moving platforms, adjusting clocks to remove clock offsets due to environmental, manufacturing tolerances, and Doppler induced frequency shifts are but the tip of the many things we accomplish with arbitrary interpolators. Let’s have a cheer, Here, Here, for interpolators!
Revolutionizing Embedded Systems with AI: A Discussion on the Latest Developments
Presented by Jacob Beningo
In this panel, we will discuss how AI can enhance the design and implementation of embedded systems. Through this discussion, attendees will gain insights into the latest trends and developments in AI, as well as the challenges and opportunities for implementing AI in embedded systems and to assist in developing embedded systems.
The panelists will share their experiences, research findings, and best practices, providing valuable insights for professionals, academics, and researchers alike. Overall, this panel promises to be a thought-provoking and informative discussion on the cutting-edge developments in the intersection of AI and embedded systems.
Revolutionizing Embedded with WebAssembly-based Containerization
Presented by Stephen Berard
Presented by atym
Born in the browser, WebAssembly (Wasm) has immense potential to revolutionize software development and deployment for embedded devices and systems.
Unlike traditional containerization technologies like Docker, Wasm-based application containers do not require Linux as a foundation and are portable across any silicon architecture – spanning CPUs to MPUs and MCUs. Applications can be developed in different languages (e.g. C, Rust, Golang) and executed on devices in isolated containers, providing greater security and IP protection. Individual containers can be fractionally updated on devices without requiring a reboot or impacting the overall code base.
These attributes enable software for resource-constrained devices to be developed, deployed, managed, and maintained using modern cloud-native methods. Benefits include greatly reduced development complexity and cost, improved security and uptime, fractional updates without requiring reboots, and simplified ecosystem collaboration – especially when implementing new technologies such as on-device AI/ML.
Join this session with Atym co-founder and CTO Stephen Berard to learn more about WebAssembly and key benefits and use cases in the embedded space. He will also walk through industry collaboration to facilitate standardization, including the WebAssembly Embedded Special Interest Group (eSIG) in the Bytecode Alliance (a collaboration between Amazon, Atym, Bosch, Emerson, Microsoft, Siemens, Sony Midokura, and more), and the Linux Foundation’s Ocre project.
The intent of the Ocre community is to codify output from the eSIG, and with a footprint of just 128KB, the Ocre runtime supports containers on MCUs with as little as 256KB of memory. Atym leverages Ocre as part of its commercial device edge orchestration solution.
RISC-V CFU: The Nexus of Embedded Software and FPGAs
Presented by Mohammed Billoo
RISC-V’s instruction set architecture (ISA) has enabled seasoned embedded software engineers to experiment with FPGAs since numerous open-source RISC-V cores can be flashed onto an FPGA. One of the exciting features of the RISC-V ISA is the Custom Function Unit (CFU), which enables a framework to support custom operations in hardware that is accessible from software. In this talk, Mohammed will demonstrate the process of interacting with a RISC-V CFU using embedded software.
Robust, Bare-Metal Security that works on any IoT Device
Presented by Shawn Prestridge
Are you looking to enable security on your IoT device but don’t really know where to start? This is the session for you! We will delve into the elements you need in an embedded design to establish security and explain why the components are necessarily. We will cover the differences between poor, “good enough”, and robust security and explain what you need to do to up your security game in your IoT device in simple, easy-to-follow steps. We will explain how to use a crypto toolbox to establish security fundamentals like: safe-and-secure boot, encrypted and authenticated communication, encrypted data storage, exploit detection/prevention, and more. Start your security journey here!
RT-Smart Open Source Micro-kernel Operating System
Presented by Bernard Xiong
There's a growing demand for embedded operating systems, and it's best when the one you build upon is open source. The RT-Thread project's R&D team has spent three years of research and intensive development to arrive at the project's latest offering: RT-Thread Smart. It is a microkernel operating system aimed primarily at midrange to high-end processors such as RISC-V or Arm Cortex-A that with a memory management unit (MMU) and provides a competitive and POSIX-based software platform for all industries in the embedded space.
Real-time operating systems (RTOS) have found their way into nearly every embedded system. The problem though is that an RTOS can often complicate implementation, increase module coupling and make debugging a nightmare.
In this workshop, Jacob Beningo will walk attendees through RTOS implementation and debugging techniques that will help developers accelerate their design cycle and implement more robust and flexible design techniques. Attendees will learn hands-on about topics such as:
How to initialize tasks
How to properly set task stack size and monitor for stack overflows
Decouple application code from the RTOS
Properly protect shared resources
Minimize response time for system events
Perform application tracing and performance analysis
Additional topics and details about specifics boards and RTOS will be provided closer to the conference.
Running DSP Algorithms on Arm® Cortex®-M Processors
Presented by Jacob Beningo
The modern embedded system has many applications for digital signal processing (DSP), especially with the demand for intelligence on the end device and machine learning. DSP is an important tool for real-time embedded system engineers, critical for projects that require converting analog filter circuits into digital IIR or FIR filters, using Fast Fourier Transform (FFT) to observe a signal’s frequency component and even speech processing.
In this session, we will examine how attendees can speed development time with DSP software available through the Arm ecosystem, making DSP achievable in their own applications running on Arm Cortex-M based devices.
This session will include:
How to use the free CMSIS-DSP library
Examples for implementing FIR and IIR filters
Using FFT to observe a signal’s frequency component
Modern examples on how DSP is being applied to embedded systems
Tool and techniques available to developers to speed up DSP implementations
Hardware In the Loop (HIL) is a testing methodology that enables the testing of embedded systems with real-world hardware components. This talk aims to demonstrate how HIL can be used to develop, test and evaluate complex embedded systems, with a real-world approach based on countless HIL projects with multiple clients across the embedded industry. Attendees will gain understanding of the HIL approach and the benefits it can bring for embedded system development. They will learn how to use HIL for verification and validation of embedded systems, and see how it can be applied in real-world scenarios. Finally, this talk will provide a very minimum HIL setup needed to start exploring your own project HIL needs.
Rust promises to enable everybody to write reliable and efficient software. Many embedded developers find this a tempting offer, but what about all the C++ code?
This presentation takes a look at different approaches for Rust and C++ code to interoperate.
In this talk, I will present how Rust fits into the medical device development process. What are the pros and cons of using Rust in medical device development? How can Rust help with fulfilling rigorous mendatory regulatory requirements? Join me to find out!
The C programming language has been a staple of embedded software development for 50 years. Many languages like Ada, C++, and others have attempted to usurp it, only to fail. Rust is a memory-safe systems programming language that has been gaining interest across a wide variety of industries. This workshop will introduce the Rust programming language for experienced C programmers.
The focus will be on highlighting the similarities and differences between the two languages, with an emphasis on showing how Rust can provide improved memory safety and performance without sacrificing the low-level control that C programmers are accustomed to. Attendees will learn the basics of Rust's syntax and standard library, as well as best practices for writing safe and efficient code in Rust. By the end of the workshop, participants will have a solid understanding of Rust and will be able to start using it in their own projects.
Example topics covered in this workshop include:
Similarities and differences between C and Rust
An introduction to the Rust toolchain
Memory mapped I/O
How to utilize peripheral access crate (PAC) and HAL crate
Best practices for developing embedded applications in Rust
Examples and code walk throughs will use the STM32F3 Discovery board
Rust for Embedded Developers: The Peripheral Access Crate
Presented by Jacob Beningo
The C programming language has dominated embedded software development for the last 50 years. Despite other languages coming and going, C has withstood the winds of change. The latest language to challenge C’s dominance is Rust. Rust is a system programming language offering modern features, including memory safety.
In this session, we will explore the Rust programming language from an embedded developer’s perspective. We will look at the peripheral access crate (PAC), and examine how to develop low-level drivers. As an example, we’ll look at creating a blinky hello world application and then move on to a serial peripheral driver. Attendees will walk away, understanding the advantages and disadvantages of using Rust in an embedded system.
Topics covered in this talk will include:
The Peripheral Access Crate (PAC)
How to create a PAC
Advantages and Disadvantages of Rust in embedded systems
Rust fundamentals
How Rust fits into the industry in the big picture
Safe Rust Multi-core Development on PSoC Microcontrollers
Presented by Nitinchandra Hegade
Embedded systems are being deployed in a variety of safety-critical applications. In such systems, failures can have severe consequences. Thus, the safety requirements and reliability expectations from real-time systems have increased drastically over time. Hence Rust programming language is well suited for embedded software development due to its focus on safety, performance, and concurrency. It is designed to prevent common programming errors such as null pointer dereferences, buffer overflows, and data races, which can lead to system crashes and security vulnerabilities. Additionally, Rust's strict ownership model and lifetime tracking help to ensure that resources are used safely and efficiently.
Furthermore, Rust's strong support for concurrency and its lightweight threading model help to make it well-suited for developing systems that need to handle multiple tasks simultaneously. It also has a growing ecosystem of libraries and frameworks specifically designed for embedded development, such as the embedded-hal, and RTIC framework. The RTIC is an open-source, community-driven project designed specifically for real-time systems. It leverages hardware acceleration through the NVIC in Cortex-M microcontrollers to perform scheduling, rather than relying on traditional software-based kernels. The framework also includes a set of APIs for managing tasks and synchronization primitives, making it easy to implement complex, real-time systems. Additionally, RTIC provides fine-grained control over available resources for each task, ensuring stability and responsiveness even under heavy loads.
The RTIC framework does not currently support multi-core architecture. However, this presentation will demonstrate how RTIC can be extended using the Multi-core abstraction trait to support secure multicore applications on PSoC Microcontrollers.
With the recent focus on improving Cybersecurity, the expectation that a Software Bill of Materials (SBOM) can be produced, is becoming the norm. Having a clear understanding of the software running on an embedded system, especially in safety critical applications, like medical devices, energy infrastructure, etc. has become essential. Regulatory authorities have recognized this and are starting to expect it as a condition for engagement. Safety critical certifications require this level of information already, it just needs to be shared in a standard format so others can do better risk management and vulnerability analysis, as well. This talk will provide an overview of the emerging regulatory landscape, as well as examples of how SBOMs are already being generated today for embedded systems by open source projects such as Zephyr, Yocto and others.
Scaling Agile Development in Large-Scale Embedded Projects
Presented by Luca Ingianni
This presentation dives into the nuances of applying agile methodologies in the complex and demanding field of large-scale embedded systems. This talk is specifically tailored to address the multifaceted challenges that professionals face when scaling agile practices in large-scale projects, ranging from the technical (what does a multi-team embedded CI/CD pipeline look like?) to issues of team structure and product architecture.
The first part of the presentation lays the groundwork by exploring the fundamental principles of agile development and the common challenges encountered when scaling these methodologies in large-scale projects. It sets the stage for a deeper exploration into the specific challenges and solutions pertinent to embedded systems development, a field characterized by its unique blend of hardware and software integration, functional safety issues, and often complex regulatory requirements.
The talk then transitions to a focused discussion on the integration of agile practices in embedded systems. This includes an examination of how DevOps, as one of the many strategies in agile development, can be effectively implemented in such environments. The aim here is to provide attendees with actionable insights and strategies that are specifically tailored to the unique environment of embedded systems.
Lastly, we lead the conversation back to the agile mantra of focusing on value – which is easier said than done. The talk introduces the concept of value streams to understand who takes part in value creation, and how, and extends it to value loops – explicitly closing feedback loops to enable pursuit of value.
The attendants should gain understanding of the challenges of scaling agile to larger endeavors, and what to pay attention to in order to be successful.
Key Topics:
Overview of Scaling Agile Development: Understanding the foundational principles and common challenges in scaling agile processes in large-scale projects.
Scaling Agile in Embedded Systems: Delving into the specific challenges and considerations unique to embedded systems development, including hardware-software integration and compliance with safety standards.
It’s Called Conway’s Law, not Conway’s Suggestion: On the pitfalls an intricacies interaction between architecture and team structure in larger product organizations.
Role of DevOps in Agile Embedded Systems: Discussing how DevOps principles can enhance agile methodologies in embedded systems, as one of the many strategies employed.
Value, Value Streams, and Value Loops: Re-focusing the conversation to what actually counts: creating value for the users, as quickly and reliably as we can.
Real-World Case Studies: Analyzing successful applications of agile methodologies, including DevOps, in large-scale embedded system projects, providing practical examples of implementation and outcomes.
October 25th, 2021: Tesla market cap reached 1.01 Trillions, equivalent to the next 10 biggest automakers in the world. All that, not defining them as an Automotive, but a Software Company. Had the Automotive OEMs and Tier-1s not realized how important software is becoming in the modern vehicle, at that point they understood that by hard.
What Tesla did, apart from all EV technology, factory models, etc, was putting the software at the center and building the organization around it. In that sense, Tesla was the precursor of SDV: Software Defined Vehicles, a term the Automotive industry created, in analogy to software defined radios.
In this theater talk, Vinicius Zein will cover the drivers for the changes in the automotive industry, the main goals the carmakers are pursuing, the pillars of SDV and the challenges they are facing. He will also cover the changes in the automotive electronics, moving from a fully distributed to a zonal and central computer architecture, the so called Vehicle OS (what is definitely not only an operating system, but a set of tools, a SW framework and eventually 2 or 3 different OS), examples of SW stacks being used in the cars, as well as two big open source initiatives the automotive industry is looking at.
Secure and Non-Secure application co-existence using TrustZone security technology
Presented by Bob Waskeiwicz
Presented by STMicroelectronics
This 2-hour hands-on workshop will use the STMicroelectronics NUCLEO-L552ZE-Q board to configure and activate the Cortex-M33 TrustZone to secure an application. A Blinky application will be used to demonstrate how the STM32L5 TrustZone can secure the peripherals and memory. The workshop will be divided into approximately 20-minute segments alternating between lecture and hands-on. The STM32CubeMX configuration tool will be used to configure the STM32L5 device and to generate the Blinky LED application code for secure and non-secure applications. No source code compiler or IDE is required as the pre-complied binaries will be provided. The STM32cube Programmer tool and the embedded STLINK/V3 will be used to load the binaries into the STM32L5 device.
Workshop Agenda (may change prior to event)
1.Overview of the STM32L5 and Cortex M33 Device Hands-On: Configure and download a non-secure Blinky application
2. Overview of the TrustZone Hands-On: Configure and download a secure Blinky application
3. Review the secure and Non-Secure application co-existence using TrustZone Hands-On: Add the non-secure Blinky application to the trusted application.
4. Review the trustZone Faults and Regression Hands-On: Change the non-secure Blinky application to attempt access to the secure LED. Hands-On: Turnoff and mass erase the STM32L5 TrustZone.
The materials for this workshop can be downloaded at:
During this session, you will learn about the implementation and logistic challenges to add a secure authentication in a system in the first part of the lecture. Then, you will be exposed to Microchip Trust Platform for the CryptoAuthentication and the problems are addressed to make secure authentication more accessible to the fragmented IoT market.
Secure Boot in Embedded Systems: Potential Impact and Weakness
Presented by Khalil Rashid
Original embedded device manufacturers must implement security measures, with a major focus on Secure Boot. Secure Boot establishes a Chain of Trust, where each boot component verifies the signature of the next component before loading it. According to GSPR guidelines, Secure Boot will be mandatory for electronic products by December 13, 2024.
In this talk, we will break down GSPR regulations into a clear, step-by-step guide for implementing Secure Boot throughout each component of the boot process. Attendees will gain practical insights into building a secure, compliant boot sequence for embedded devices.
Secure Device Management for the Internet of Things
Presented by Gary Sugita
Presented by Cypress
According to IHS Markit research, the number of connected devices in the market will reach nearly 40 billion by the end of 2020. While these IoT devices can significantly improve everyday life, they come with increasing cybersecurity risks. In this session, attendees will learn how to safeguard their IoT device throughout its lifecycle, from production and provisioning through decommissioning and termination, with PSoC® 64 Secure MCUs.
Securing the IoT from Chip to Cloud:An Application Guide to Applying Platform Security Architecture (PSA) Principles
Presented by Jacob Beningo
With the explosive growth in the Internet of Things (IoT) and the number of devices soaring, security is critical maintain device integrity and protect user privacy.However, designing consistent security across connected devices can be a minefield to navigate and implementation can be costly.Using a smart door lock as an example, in this webinar, attendees will learn how to design security from the ground up using PSA principles and guidelines with a PSoC® 64 secure MCU from Cypress Semiconductor.
Attendees will walk away with the best practices to develop their own security solutions.In addition, the importance of secure device management throughout the IoT products lifecycle will also be reviewed.
Topics Covered in this Webinar Include:
Developing a threat model and Defining security counter measures
Maintaining asset security through hardware architecture and security IP
Implementing trusted boot and Secure application partitioning
Using Trusted Firmware-M to isolate security critical functionality from non-secure code
Leveraging the Arm Pelion Secure IoT Device Management Platform for full device lifecycle management (design, onboard, provision, secure, update, manage, etc.)
Security is usually an afterthought. Edge AI models can be copied, cloned, reverse-engineered, and tampered with. In this presentation, we will talk about how AI models can be secured for deployment.
Struggling to protect your end-devices while complying with complex regulations and certification schemes? Join STMicroelectronics during this workshop to discover the power of the STM32Trust TEE Secure Manager, a new set of certified security services that automatically sets up a range of security features.
In this 1.5-hour session, you will learn about the security features of the STM32H5 MCU, and how to integrate the Secure Manager into your embedded design to enable highly secure end-devices that meet the unique security requirements of your project.
Who should watch?
This workshop is intended for firmware developers, system integrators, and design engineers interested in secure solutions for STM32 microcontrollers.
Workshop agenda
Introduction to the STM32Trust TEE Secure Manager
Overview of the STM32H5 security features
Hands-on sessions:
install and get started with Secure Manager
build and debug your application using Secure Manager services
safely reopen debug access with Debug Authentication on STM32H5
Prerequisites
For those who wish to participate in the workshop exercises, you will need the following:
A laptop running Windows® 10 or higher, with administrator rights for software and driver installation and an available USB port.
Selecting the Right Microcontroller for your Embedded Application
Presented by Jacob Beningo
Selecting a microcontroller can be an intimidating endeavor. With dozens of chip suppliers and thousands of microcontrollers to choose from, how on Earth is someone supposed to select the one that best fits their application needs?
In this session, we will explore how to winnow down the 73,000+ microcontroller options down to a manageable few and select the microcontroller that best fits your application and business needs. We will examine the process developers should follow to select a microcontroller that goes beyond the hardware capabilities and focuses on picking a platform solution that provides the right hardware, software frameworks and improves development productivity.
Topics Discussed in this Webinar Include:
The dramatic growth of the microcontroller industry
Microcontroller hardware architectures
The role of software in microcontroller selection
The microcontroller selection process
Avoiding supply chain constraints
Tips and tricks for successful microcontroller selection
Selecting the Right Microcontroller for your Embedded Application
Presented by Jacob Beningo
Selecting a microcontroller can be an intimidating endeavor. With dozens of chip suppliers and thousands of microcontrollers to choose from, how on Earth is someone supposed to select the one that best fits their application needs?
In this session, we will explore how to winnow down the 73,000+ microcontroller options down to a manageable few and select the microcontroller that best fits your application and business needs. We will examine the process developers should follow to select a microcontroller that goes beyond the hardware capabilities and focuses on picking a platform solution that provides the right hardware, software frameworks and improves development productivity.
Topics Discussed in this Webinar Include:
The dramatic growth of the microcontroller industry
Microcontroller hardware architectures
The role of software in microcontroller selection
The microcontroller selection process
Avoiding supply chain constraints
Tips and tricks for successful microcontroller selection
All electronic systems carry the possibility of failure. An embedded system has intrinsic intelligence that facilitates the possibility of predicting failure and mitigating its effects. This talk will review the options for self-testing that are open to the embedded software developer. Testing algorithms for memory will be outlined and some ideas for self-monitoring software in multi-tasking and multi-CPU systems will be discussed.
Cloud-based IIoT servers are receiving too much data, far too frequently, from an increasing number of edge devices. We present a complementary pair of AI solutions for reducing the data sent from the sensor and for efficiently processing it when it reaches the cloud server. The AI deployed at the sensor intelligently extracts insights from raw data with the help of inexpensive microcontrollers while operating on µWs of battery power. The server-side AI translates the insights received from a multitude of edge devices into decisions rapidly while employing a minimum of resources. The result is a low-latency, high-throughput cloud-based IIoT system.
Setting up an Embedded Software Development Environment
Presented by Mutheu Atsiaya
In this talk, we will explore the essential tools and techniques for setting up a robust embedded software development environment tailored for both beginners and advanced engineers.
We will begin by setting up a coding environment using Visual Studio Code (VSCode), followed by identifying the necessary toolchains required for compiling and building embedded firmware. From there, we'll dive into build systems like Make and build generators such as CMake to streamline and manage project builds efficiently.
Next, we will examine the basic file structure of an embedded software project, focusing on a hierarchical and modular approach that promotes scalability and maintainability.
Finally, we will discuss the role of Software Development Kits (SDKs), highlighting their importance in simplifying development for specific microcontrollers by providing drivers, libraries, and peripheral abstraction.
By the end of this session, participants will have a clear understanding of how to set up a complete embedded development environment, enabling them to build and manage projects more effectively, whether they are just getting started or aiming to enhance their existing workflow.
Signal Processing and Machine Learning: Connections and Applications
Presented by Kirty Vedula
The talk starts with introducing connections between signal processing and machine learning in two applications: a) speech processing b) wireless communication. First, we explore some concepts on linear algebra, the core connection between the two topics and some basic DSP concepts. Then, we look at the first application, speech processing and explore basic ideas like cepstrum and mel-frequency cepstral coefficients (MFCC) and then introduce wavelets and its connections to machine learning. Then, we look at another application: wireless communication, and explore connections between traditional estimation and detection methods and their machine learning counterparts. The objective of the talk is to connect signal processing and machine learning and explore their correlations.
Today’s sequence models (such as large language models) in machine learning (AI) arose from a blend of principle-based design and empirical discovery, spanning several fields. This talk describes how many of the main ideas could have emerged from an elementary signal-processing approach. This viewpoint offers some features:
Signal processing folks can quickly learn what is happening in a motivated way
Machine-learning experts might benefit from signal-processing insights
Obvious suggestions for things to try next naturally arise
FMCW radars are widely used in short range applications such as autonomous vehicles, heartbeat monitoring, vibration measurement in residential and industrial products, drones ranging and intrusion detection. Building the main concepts from the ground up, I will describe in detail FMCW waveform design, FFT processing and the utility of radar date cube that covers all three dimensions, namely range, Doppler and angle. The talk will conclude with practical tips for designing an FMCW radar system.
In the field of rotating machinery, the vibration are widely used to measure health, detect failing parts, improve efficiency or increase life duration of engines and all rotating parts attached. The talk will go through some techniques used and their goals.
Signal Processing Techniques in Condition Monitoring and Control of Power Electronics Converters and Battery System
Presented by Maher Al-Greer
There are several fundamental challenges in condition monitoring, fault detection, and control of power electronics converters and Li-Ion batteries. These are linked to the computation complexity of the signal processing algorithms, suitability for on-line and real-time implementation, cost of implementation, ability to deal with rapid real-time changes, etc.
Advanced signal processing algorithms have been found to provide superior condition monitoring, system identification, and state estimation solutions to tackle the aforementioned issues with fast dynamic performance, cost-effective solution, high accuracy prediction, good tracking ability to system changes.
This talk offers basic theory and some recent advances of innovative signal processing algorithms for condition monitoring and control of power converters and batteries. The talk covers different system identification and parameter estimation of power converters, adaptive signal processing algorithms for on-line modelling and estimation of power converters, parametric/ non-parametric system identification, remaining useful prediction, and sate of health estimation of Lithium-Ion batteries. This talk is intended for researchers and engineers in the area of signal processing and artificial intelligence to explore new applications of signal processing algorithms in power electronics applications and battery management systems, and for postgraduate students in these fields.
Developing programmable logic solutions is moving up the levels of abstraction.
In this session we will use the Arty Z7 board and the Xilinx PYNQ framework to accelerate signal processing algorithms (FFT, FIR Filters) in programmable logic using with a combination of Python and High-Level Synthesis (C/C++). Techniques such as this will allow us to leverage the processing capabilities of programmable logic without the requirement to develop solutions using traditional FPGA Register Transfer Languages. This enables smaller, more power-efficient solutions.
This session will introduce the PYNQ framework and explain how it interacts with the programmable logic. We will then explore how we can use HLS – what is it, how do we go from untimed C to logic gates and what optimisations do we need. Finally, we will look at how we can build PYNQ overlays using IP Integrator which can be loaded onto the Arty Z7 for use with our Python application using Jupyter Notebooks / Labs.
Simplifying High-Performance IoT and Industrial Applications with the i.MX RT1170 MCUs
Presented by Patrick Kennedy
Presented by NXP
The massive growth of connected devices in-home and across cities has led to a need for high-performance devices with multimedia and machine learning functionality typical of applications processors, while maintaining low-cost, power-efficient packages typical of MCUs.
In this session, we’ll explore how the full capabilities of the i.MX RT1170 crossover MCU family blends the best of both worlds to simplify your next IoT Design.
Simplifying integration of sensor data using NFC enabled Multi-Sensor Node
Presented by John Tran
Presented by STMicroelectronics
As NFC becomes ubiquitous, its applications range from mobile payment to sensor data logging. During this approximately 2 hour workshop, you will learn how to integrate NFC, sensors and a microcontroller to create an NFC Sensor node. This workshop will combine the STM32L031 low-power MCU, ST25DV NFC Dynamic Tag IC, HTS221 Humidity and Temperature Sensor, LPS22HB Barometer/Altimeter and LIS2DW12 3-axis accelerometer into the NFC Sensor node.
This workshop will cover the following topics:
Overview of NFC Technology
ST NFC Product Portfolio
ST Sensors Technology
Firmware and hardware structure
Using ST25R3911B NFC reader to read sensor data from the Sensor Tag.
The NFC hands-on will use the following kits and are available from our Distributors such as DigiKey or Mouser Electronics.
As NFC becomes more ubiquitous, its applications can range anywhere from mobile payments to sensor data logging. One of the most commonly used capabilities of NFC technology is in asset tracking applications. During this approximately 1-hour webinar, you will learn about the integration of NFC, sensors, secure element, and microcontroller to create an intelligent NFC Sensor node for asset tracking.
Smart Wireless Protocols: Unleashing ML in Embedded Systems
Presented by Abhijeet Srivastava
I would like to go over how ML can improve communication protocols like Bluetooth and 5G. Discuss canonical algorithms of channel estimation and Error correction and how ML can improve upon them to provide better range and spectral efficiency. How do you deploy high-latency ML algorithms in systems that have tight deadlines of a few microseconds and ensure the system remains reliable?
This talk explores the softer side of electronics, from electronic embroidery and e-textiles to soft robotics and flexible PCB design. We will take a look at some of the exciting technologies in this field, including industrial machines that embroider traces to microcontrollers, open source soft robotics, 'pick and place' sewable LEDs, e-textiles in space, fabric speakers and the world of flexible and stretchable PCB design. I will also share examples of how engineers, scientists and artists are using these soft electronics technologies in their work.
As well as this higher level overview, we will take a look at a number of accessible DIY projects, along with practical tips on materials and techniques, and suggestions for further learning. I will also talk about softness in electronics in a non-literal sense, looking at some cool projects from the community that link emotions, vulnerability and physical computing.
With the rapidly increasing prevalence of IoT smart devices, most user experiences are now digital, making modern software the ultimate product differentiator. However, for the product developer, perfecting software is more than just updating user features and functionality; the challenge is creating unique user interactions that result in increased adoption and sales. This talk will explore how differentiating your product UI/UX through software can maximize your overall business outcomes. We’ll also explore how innovative strategies like embedded digital advertising can turn devices into continuous revenue generators.
Software-Defined Radio: Principles and Applications
Presented by Travis Collins
Software-defined radio (SDR) has transitioned from primarily a research topic to a common tool used by practitioners in many fields of RF. Made possible through hardware integrations, economics, and the growth of processing power. Making SDR devices accessible to the masses and providing a high configuration ceiling for advanced users.
In this talk, we will discuss the evolution of SDR and the key driving forces and methodologies behind both the hardware and software ecosystems. We will provide insights into the philosophies of current and historical SDR architectures. This will include several examples and demos with modern devices like transceivers and RF data converters. Throughout the different discussions, the talk will focus on the usage models and practical workflows that have been developed over the years to leverage the flexibility of SDRs. Touching upon and connecting the complex tooling for FPGAs, embedded processors, and high-performance x86 that are used in applications like communications, radar, and instrumentation. Finally, an outlook upon the next frontier of SDR in the space of Direct-RF and its related challenges will be discussed.
In general, this talk will provide a solid foundation to those new to SDR and provide context for the next generation of solutions for seasoned professionals. The talk will also connect the dots among the sea of software and hardware that has flourished over the last few decades for SDR.
C does not have to be spaghetti code. C code can be modular and flexible if you apply the SOLID design principles. Too often design is just about personal preference. In this session we'll see that there are objective qualities that we can use to assess software design. We look at applying Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation and Dependency Inversion principles to C. SOLID gives good guidance on modularity and coupling; these principles are not just for programmers with an OO language. You can use the SOLID principles to build better C code.
Solving Remote Manufacturing Challenges using the Cloud
Presented by Kevin Perreault
Presented by PE Micro
Remote manufacturing of products is challenging to manage and control. How do we keep secure control of the firmware IP used to program a product? How can we authorize legitimate builds of our product while preventing over-production and counterfeiting? How do we update the firmware IP being used during manufacturing? How do we keep a detailed accounting of every device programmed, including recorded unique device identifiers?
In an ideal production flow, we should be able to answer these questions regardless of where a product is produced. This talk is a discussion of how cloud technologies can be leveraged to provide the necessary control and visibility over our programming IP to achieve this in remote manufacturing facilities. A demonstration of such a novel system is shown.
Spectrometer Signal Processing Systems for NASA Space Applications
Presented by Damon Bradley
For many NASA Space Science Instruments flown aboard various spacecraft, digital spectrometers are a very common instrument class. These instruments are used for a vast array of scientific monitoring and observational applications, such as detecting organic compounds on distant planetary satellites in the solar system, measuring solar plasma interaction with the surface of our own Moon, monitoring geophysical parameters here on Earth, and determining the composition of exoplanet atmospheres several light years away. In particular, these instruments process signals arising from a vast swath of the radio spectrum, covering frequencies from near DC all the way up to sub-mm THz frequencies. Moreover, these systems must operate under extreme conditions of temperature and radiation environment, while also performing efficient computation under severe power constraints. This talk will cover practical implementation of digital spectrometers for these space applications, as well as some of the statistical signal processing methods used for detecting various phenomena in-orbit for particular Earth-observing instruments.
Speech Dereverberation using Coherent to Diffuse Power Ratio Estimators (CDR)
Presented by David Castro Pinol
I will give a Talk regarding Coherent to Diffuse power Ratio (CDR) estimators for dereverberation. I will show the basic theory and how to apply them in dereverberation in audio signals. In addition, I will show implementation codes in Matlab and I will reproduce examples. The topic is part of my recent research. I hope you find it interesting and hope to meet you!
Strategies for Developing Scalable Embedded Software for Microcontrolllers
Presented by Timothy Adu
This talk will focus on useful strategies for developing embedded software - strategies that facilitate reuse, maintainability, ease of testing and scalability. Key topics that will be covered include:
Scalable Architecture/Design
CI/CD
Observability mechanisms
Virtualization
Rules of Engagement
Strategies for application (business logic) development
The talk will introduce a simple framework for implementing the strategies listed above.
The modern embedded software team has a lot of challenges to overcome to successfully deliver software. Today’s systems are complex and require a careful balance between the software architecture design, development processes, and implementation. Failure to do so results in embedded software projects that are delivered late, over budget, and buggy.
In this session, we will explore modern firmware development techniques and processes that will help you improve how you design, build, and deploy your embedded software.
Topics covered in this session include:
How to define your embedded software design philosophy
The software architecture design process
Software domains
Application Modeling
Introduction to the modern embedded software build processes
The build process
CI/CD for Embedded Engineers
Tips and tricks for successful implementation
Getting process buy-in at all business levels
Attendees will learn critical concepts and processes that they can immediately apply to their own development cycles. Attendees will also see examples on modern build system set ups, CI/CD, and more.
Super-Simple Tasker - Hardware RTOS for ARM Cortex-M
Presented by Miro Samek
Super-Simple Tasker (SST) is a preemptive, priority-based RTOS kernel fully compatible with Rate Monotonic Analysis/Scheduling (RMA/RMS). It was initially published in 2006.
This session will present a unique hardware implementation of a modern version of SST for ARM Cortex-M (M0, M0+, M3, M4, M7, etc.).
The session will begin with introducing preemptive but non-blocking multitasking with so-called basic tasks (as defined in the OSEK/VDX/AUTOSAR operating system). Such tasks are ideal for executing event-driven state machines (a.k.a. active objects), which are also non-blocking and handle events in a run-to-completion fashion.
Next, you will see how these basic tasks can be mapped to ARM Cortex-M interrupts and how to program the NVIC interrupt controller to manage both interrupts and basic tasks.
The bulk of the session will demonstrate various preemption scenarios, including inter-task communication and the compatibility of SST with RMA/RMS. The demos will utilize a logic analyzer and will run on a low-end ARM Cortex-M0 and on a high-end ARM Cortex-M7 with FPU.
If you are interested in real-time performance, you should see SST in action. SST is available on GitHub under the permissive MIT open-source license. SST is likely the most efficient and performant RMS-compatible RTOS kernel for ARM Cortex-M.
Supercharging Embedded Linux Development with Visual Studio Code
Presented by Drew Moseley
Visual Studio Code (VS Code) has quickly become one of the most popular code editors for many developers, including Embedded Linux developers. VS Code is a lightweight and extensible editor that can be used to develop and debug embedded Linux applications. In this talk, we will explore how you can streamline your embedded Linux development workflows using VS Code with many readily available plugins.
Features that make it well-suited for Embedded Linux development include:
A powerful code editor with syntax highlighting, completion, and refactoring
Intellisense support for intelligent, context-aware help
Support for languages common in Linux designs, including C, C++, Python, and JavaScript
A built-in terminal for running commands and troubleshooting
Transparent remote access using SSH, making working with your remote device feel like local development
We will cover the basics of using VS Code for Embedded Linux development, with no assumptions about your familiarity with it. We will demo basic VS Code usage as well as show several useful plugins that can make your life easier, such as:
Remote SSH access
Integrated version control using Git
Language-specific syntax highlighting and code navigation
Remote source-level debugging of Embedded Linux applications
Finally, we will demo a real-world Embedded Linux system using VS Code. By the end of this talk, developers will have a toolbox of skills and knowledge to boost their productivity and reduce development time.
Symmetric Multiprocessing (SMP) with FreeRTOS and Raspberry Pi Pico
Presented by Dan Gross
Presented by Amazon AWS
Recently, semiconductor companies have been producing microcontrollers with multiple compute cores. Although FreeRTOS has supported Asymmetric Multiprocessing for years, only recently has it started supporting Symmetric Multiprocessing (SMP). SMP support in the FreeRTOS Kernel enables one instance of the FreeRTOS kernel to schedule tasks across multiple identical processor cores, which is helpful for IoT applications. This session will showcase the FreeRTOS Raspberry Pi Pico port to demonstrate support for SMP in the FreeRTOS Kernel. The Raspberry Pi Pico board uses the RP2040 microcontroller from Raspberry Pi that features a Dual-core ARM Cortex M0+ processor.
Test-Driven Development is a technical practice that supports Agile's iterative and incremental development cycle. TDD helps you quickly discover mistakes, preventing defects. You weave a test safety net as you grow your product's behavior one test at a time. This safety net supports you now and in the future to help you keep code working as you change it. Oh yeah, don't let me forget to tell you it's fun and once you learn it, you save time and money.
Maybe you have heard of Test-Driven Development but don't quite get it. A good way to understand TDD is to pair program with an experienced practitioner. We will start with a brief overview and demo of Test-Driven Development. In this interactive workshop, you can practice TDD in C. You don't need to install any tools for this workshop. You'll run the exercise on my exercise server. You will know what TDD is after this session. We'll conclude the workshop with a debrief on your experience.
Before attending this workshop, it is highly recommended that you watch this talk from the 2020 Embedded Online Conference.
If you missed this workshop at EOC earlier this year, here's a second chance to attend
Test-Driven Development is a technical practice that supports Agile's iterative and incremental development cycle. TDD helps you quickly discover mistakes, preventing defects. You weave a test safety net as you grow your product's behavior one test at a time. This safety net supports you now and in the future to help you keep code working as you change it. Oh yeah, don't let me forget to tell you it's fun and once you learn it, you save time and money.
Maybe you have heard of Test-Driven Development but don't quite get it. A good way to understand TDD is to pair program with an experienced practitioner. We will start with a brief overview and demo of Test-Driven Development. In this interactive workshop, you can practice TDD in C. You don't need to install any tools for this workshop. You'll run the exercise on my exercise server. You will know what TDD is after this session. We'll conclude the workshop with a debrief on your experience.
Before attending this workshop, it is highly recommended that you watch this talk from the 2020 Embedded Online Conference.
Test-Driven Development is a technical practice that supports Agile's iterative and incremental development cycle. TDD helps you quickly discover mistakes, preventing defects. You weave a test safety net as you grow your product's behavior one test at a time. This safety net supports you now and in the future to help you keep code working as you change it. Oh yeah, don't let me forget to tell you it's fun and once you learn it, you save time and money.
Maybe you have heard of Test-Driven Development but don't quite get it. A good way to understand TDD is to pair program with an experienced practitioner. We will start with a brief overview and demo of Test-Driven Development. In this interactive workshop, you can practice TDD in C. You don't need to install any tools for this workshop. You'll run the exercise on my exercise server. You will know what TDD is after this session. We'll conclude the workshop with a debrief on your experience.
Before attending this workshop, it is highly recommended that you watch this talk from the 2020 Embedded Online Conference.
You've heard about Test-Driven Development but have never tried it or don't quite get it. Test-Driven Development is an important design and problem solving technique that helps software developers improve product quality and the quality of their life. How? By preventing defects, protecting your code from unintended consequences, and giving you warning when your design starts to deteriorate.
In this presentation James describes the problems addressed by TDD. He will define TDD and show you a short example of TDD. He'll tell you some of the benefits you can expect from TDD as well as the challenges of applying TDD to embedded C and C++.
James Grenning is inviting you to a scheduled Zoom meeting.
Meeting ID: 824 6418 8187 Password: 031453 One tap mobile +13017158592,,82464188187#,,1#,031453# US (Germantown) +13126266799,,82464188187#,,1#,031453# US (Chicago)
Dial by your location +1 301 715 8592 US (Germantown) +1 312 626 6799 US (Chicago) +1 646 558 8656 US (New York) +1 253 215 8782 US (Tacoma) +1 346 248 7799 US (Houston) +1 669 900 6833 US (San Jose) Meeting ID: 824 6418 8187 Password: 031453 Find your local number: https://us02web.zoom.us/u/kflJGFuSy
Testing of Event-Driven Embedded Software with Python
Presented by Miro Samek
Testing event-driven software typically involves injecting events to the system and verifying that the software reacts by executing the expected sequence of actions. These actions might be quite complex. For example, a single transition in a hierarchical state machine might trigger several exit actions from the source state configuration, followed by entry actions and nested initial transitions into the target state configuration. The actions themselves might involve interactions with multiple hardware components, such as toggling GPIOs, sending data through various interfaces, etc.
In traditional unit testing frameworks, the verification of such potentially complex interactions typically requires applying mock objects as the test doubles for the various hardware components. But even though generating mocks can be automated, it's difficult to verify sequences of expected interactions among multiple mocks (multiple hardware components). Also, working with mocks reverses the natural sequencing, because the expectations must be specified before the actual call to the CUT (code under test).
This session will show a more intuitive approach, conceptually similar to "debugging with printf", where you instrument the code with printf statements to output the software trace information. You then run the CUT with a controlled set of inputs, and examine the produced trace to determine whether the CUT operates correctly. The main differences from using actual printfs will be: (1) that the much more efficient software tracing mechanism will be used instead and (2) that both generating the inputs and the checking of the trace output will be automated.
This approach has many interesting implications:
It separates the execution of the CUT from checking of the "test assertions". The embedded target is concerned only with running a test fixture that calls the CUT and produces the trace, but it does not check the test expectations.
Checking the generated trace output against the expectations is performed separately on the host computer and can be done in a different programming language (e.g., Python) than the CUT (C or C++).
Virtually all test doubles can be implemented as simple "spy" test doubles without the need to applying mocks or other complex test doubles. Verifying trace output from multiple such "spy" test doubles is trivial.
The testing process follows the natural sequencing where the generating of inputs to the CUT is naturally followed by the expectations of the performed actions.
This session will utilize hands-on demonstrations of the QUTest (pronounced "cutest") unit testing harness running on both the host computer and STM32-NUCLEO board. Specifically, you will see a comparison between the traditional approach with a mock test double and the QUTest approach with software tracing and a "spy" test double.
The $5 Wrench: Realistic Embedded Security Threats
Presented by Colin O'Flynn
Blockchain. Secure Boot. E-Fuse. ECDSA. Secure Manufacturing. When it comes time to ship your product you'll hear all sorts of comforting words like this - but when it comes time for attackers to steal your IP, they will ignore about 95% of them. This talk will discuss some recent attacks & show you where they fall in terms of realism. It will then show you how to recreate some of them, which is useful in understanding how to protect your own products. It will also discuss products that have shown to be vulnerable, and how you can still use these products without totally redesigning your product.
How do you keep your company from being front page news for the wrong reasons? You can start by implementing a rigorous security solution on your embedded devices. The most common reason developers give for not using security is that they perceive it to be too hard, so they will just sit back until they are forced to imbue their devices with security by either their customers or the government... or until they get hacked and shamed. Good security is hard, but with the right tools, it doesn't have to be that way. In this session, we're going to take a holistic approach to implementing security by examining the Chain of Trust, hardware requirements, and working in a secure workflow to minimize the attack surface a hacker can use to attack your system. We're going to show you how easy it can be to enable a high degree of security in just a few easy steps.
The 10 Minute Embedded GUI App Development with Crank Software's Storyboard
Presented by Crank Software
A 10 minute Storyboard overview demo with Nik Schultz, Crank Software Field Application Engineer.
Crank Storyboard, a GUI design and development tool, accelerates embedded GUI development, embraces GUI design change, and maximizes GUI flexibility. It provides product teams with a streamlined, parallel workflow enabling them to collaboratively work together when creating user interfaces.
Check out the 2022 Embedded Online Conference Promo Video and consider using the opportunity to post a comment in order to test the comments/questions system.
Let's face it. The firmware we write has bugs, and we need to defend against and accept failures when our system experiences bugs. This is when we typically employ defensive programming practices, but if not used correctly, they may cause more problems than they solve.
There is an alternative and complimentary set of programming practices, often called "offensive programming", which takes defensive programming and flips it on its head. Instead of defending against errors in firmware, this technique will surface them immediately using liberal asserting and proper fault handling.
This talk will cover offensive programming techniques, prerequisites to implementing the suggestions in your firmware, and how you can use them to quickly and easily track down and root cause 1 in 1,000 hour bugs and keep your sanity at the same time.
The Device Feedback Loop - What does it mean for IoT Operations and Development?
Presented by Dr. Johan Kraft
Presented by Percepio
Join this interactive session with Percepio founder Dr. Johan Kraft and learn why the IoT industry is embracing the idea of a Device Feedback Loop to safeguard IoT operations. Based on interviews with senior stakeholders at leading OEMs, examples of relevant metrics are provided to illustrate how monitoring them could help your business. Afterwards, you are welcome to join an open discussion in the Q&A session where you can hear additional views from other attendees and share your own experiences.
The Device Feedback Loop - What does it mean for IoT Operations and Development?
Presented by Dr. Johan Kraft
Presented by Percepio
Join this interactive session with Percepio founder Dr. Johan Kraft and learn why the IoT industry is embracing the idea of a Device Feedback Loop to safeguard IoT operations. Based on interviews with senior stakeholders at leading OEMs, examples of relevant metrics are provided to illustrate how monitoring them could help your business. Afterwards, you are welcome to join an open discussion in the Q&A session where you can hear additional views from other attendees and share your own experiences.
The DSP Biquadratic Recursive Filter: A Fox in the Hen House
Presented by fred harris
When we studied active analog filters we were taught that the biquadratic second order filter was the work horse of active filter design. What made it so was that fact we could form second order polynomials in both denominator and numerator with real coefficients. We also learned that when we performed sensitivity analysis reflecting root shifts with component value variation due to tolerance spreads that lower order polynomials had reduced sensitivity levels. We learned active filters should be implemented with multiple second order filters and possibly one first order filter. Control folks also learned this lesson. That was good perspective for a designer to have.
When we started to implement high order recursive filters in DSP land we followed the standard understanding that the sampled data biquadratic filter with decoupled second order denominator and second order numerators offered us the same capabilities, complex roots with real coefficients and low sensitivity to root shifts due to coefficient quantization. We were so pleased that the carryover from active analog filters to sampled data filters we failed to notice that it was not true! We let the Fox in the Hen house without realizing what we did.
The fox comes out to play when we try to form IIR low-pass filters with a large ratio of sample rate to bandwidth. What we learn is that it just doesn’t work! We need an alternate architecture or we should stop designing recursive filters with very small bandwidths relative to sample rate. One I see all the time is a 30 Hz wide low-pass or high-pass filter running at 48 kHz sample rate. Have you run into that? Did it take long for the hurt to go away when you found out your design didn’t work? We will discuss how to fix the problem and make the fox go away.
The Embedded Frontier: Modern Trends and Practices
Presented by Jacob Beningo
Embedded systems development has dramatically changed over the last decade. Navigating today's trends and where you need to be tomorrow can impact whether you’ll be successful or struggle to deliver your products on time. The latest trends can lead to best practices that help you develop more reliable embedded devices faster and within customer budgets.
In this session, we will explore the current state of the embedded software industry, the trends, and the practices that are helping teams be successful. We will look at the dynamics between C, C++, and Rust adoption. The impact that AI and ML are having on how we develop and debug embedded systems. We’ll look at changes to how systems are architected and the improvements in build systems and lifecycle processes that help teams manage complexity.
Attendees will walk away, understanding where the industry is at today, where it’s going, and the changes they need to make to stay up to date.
The Embedded Renaissance: Reimagining How We Build Firmware in a Modern World
Presented by Jacob Beningo
In today’s rapidly evolving embedded landscape, outdated development methods can leave you struggling to hit deadlines, control costs, and maintain quality.
Whether you’re leading a team or writing the code yourself, it’s time to modernize your approach, secure your competitive edge, and open new doors for innovation.
This talk presents a proven, 7-step roadmap for transforming your embedded software practices, designed for both strategic decision-makers and hands-on developers.
Discover how to establish a metrics-driven scoreboard to measure progress, adopt modern, modular architectures to streamline delivery,
and integrate DevOps pipelines that enhance speed and consistency. Learn how to standardize build systems, embrace test-driven development and simulation for earlier feedback,
and incorporate AI/ML capabilities that propel you ahead of market trends.
Attendees will walk away from this talk with a clear, actionable roadmap to modernize their embedded software practices—from planning and measurement to delivery and innovation—empowering them to stay ahead in an ever-changing landscape.
Topics Covered in This Talk Include:
Metrics Scoreboard: Automate a Software Metrics Scoreboard
Architecture: Adopt Modern Architecture Methodologies
DevOps: Integrate DevOps Pipelines
Build Systems: Standardize Your Build Systems
AI/ML: Leverage AI/ML to Accelerate
TDD: Embrace Test-Driven Development to Improve Testability
It’s no surprise—Agile is often misunderstood as little more than two-week sprints, burn-down charts, and daily stand-up meetings. In reality, Agile isn’t a micro-management framework; it’s a mindset rooted in continuous improvement and technical excellence.
When Extreme Programming (XP) emerged in 1999 with its provocative name, it challenged the status quo with sound engineering practices designed to support tight iterative cycles. Yet today, many Agile teams struggle to integrate these practices, leading to poor product quality, hard-to-change code, endless debugging, long stabilization phases, and the growing burden of manual testing.
In this keynote, we’ll cut through the noise to uncover why Technical Excellence is the cornerstone of successful Agile teams. You’ll discover how XP practices like test-driven development, refactoring, and automation can address the hidden challenges of Agile and set your team on the path to true agility.
The IoT Business Case for Smart Cities & COVID19 Recovery
Presented by Catherine Caruana-McManus
This session will highlight the leading IoT use cases for Smart Cities and Industries using the global standard LoRaWAN.
The session will also highlight the findings of the COVID19 Pedestrian Index, a research collaboration between Meshed, the University of Wollongong and 24 Local Government Authorities in Australia and the ways in which they are using pedestrian counting solutions to inform targeted stimulus for economic, social and cultural recovery from the global pandemic.
The Journey Towards a Secure Industrial IoT Network
Presented by Vikram Sharma
Protecting industrial operations against cyber threats is a very specific challenge. As industrial organizations connect more devices, enable more remote access, and build new applications, the airgap between IT and OT networks erodes and the IDMZ falls short of being sufficient.
Enhancing the security of your industrial network will not happen overnight. This session will present a phased and pragmatic approach where each phase builds the foundation for the next so that you can mature your OT security strategy at your own pace and lay the ground for a converged IT/OT security architecture.
What you will learn in this session:
What information is needed to build an industrial network that is secure by design
What are the key security technologies that must be deployed immediately to secure your industrial operations
How to add OT to your existing IT security tools and what are the benefits of doing so
How to demonstrate value to both IT and OT teams and embark all stakeholders in this journey to maximize your chances of success.
The Micro-Doppler Effect in Radar: Next Generation Remote Medical Applications
Presented by Nir Regev
In the last two and a half decades there has been an increasing body of work on the micro-
Doppler effect for various applications. Researchers used micro-Doppler signatures to
analyze, classify and detect human gait, hovering helicopters and wind-turbines, as well as jet
engine modulation (JEM) to detect jet aircrafts.
In recent years, the use of the micro-Doppler effect has expanded and taken also to the monitoring of
biological signals. Researchers started investigating the use of the effect to extract vital signs
such as breathing and heartbeat. The employment of various algorithms, such as the Chirp Z
Transform and Fourier analysis, has been advocated. Multiple radars have been investigated in
this context, from UWB and X-Band, to 24, 60, and 77GHz radar bands. The methods developed
suffer from insufficient spectral resolution, as Fourier analysis type algorithms need a large time-
window of data to support a certain resolution. Another caveat is the fact that the respiration
frequency is lower than the heart-beat, while its amplitude is much larger coupled with inherent
nonlinearities in the radar hardware, rendering the spectrum of the signal densely populated with
harmonics of both the respiration and heartbeat and their inter-modulations. This tutorial will
give an introduction to micro-Doppler with the derivation of the micro-Doppler effect of a
vibrating target with a live-demo of radar based vital signs extraction from afar.
This year marks the 50th anniversary of the invention of the microprocessor. It’s hard to imagine a world without this device! Yet the story goes back long before 1971. In this session Jack gives the history of electronics from the early days to today, with special focus on computers.
The Modern UX is Mine: How Personalizing the Embedded GUI Unlocks the User Experience of Tomorrow
Presented by Harrison Donahue
Presented by The Qt Company
In a world where mobile and web set the bar for the most modern and intuitive experiences, how can we extend that to the most constrained platforms like embedded devices and make a great user experience ubiquitous? Personalization is the key, however delivering a unique static experience isn't scalable. This talk will look at how embracing higher-level languages can help the user interface meet the consumer’s wants and needs. We'll walk through how to use Qt to develop for a variety of embedded platforms in a way that maximizes code and design asset reuse to deliver a consistent experience that is both dynamic and flexible.
The Past, Present, and Future of Embedded Machine Learning
Presented by Pete Warden
Pete Warden, from Google's TensorFlow Lite Micro project, will be talking about how machine learning on embedding devices began, and where it's heading. ML has been deployed to microcontrollers and DSPs for many years, but until recently it has been a niche solution for very particular problems. As deep learning has revolutionized the analysis of messy sensor data from cameras, microphones, and accelerometers it has begun to spread across many more applications. He will discuss how voice interfaces are leading the charge for ML on low-power, cheap devices, and what other uses are coming. He'll also look into the future of embedded machine learning to try to predict how hardware, software and applications will be evolving over the next few years.
The Ports-and-Adapters Architecture for Embedded HMIs
Presented by Burkhard Stubert
The ports-and-adapters architecture (a.k.a. hexagonal architecture) is based on the same idea as USB ports and adapters. USB adapters enable PCs to communicate with embedded devices over CAN, RS232, (W)LAN or BLE. The USB port hides from the PC which technology is used for the communication - as a good interface should do. Different companies can manufacture the adapters as long as they comply with the USB interface.
A typical machine HMI has a UI, machine, accounting and monitoring port. These ports are the interface between the application core implementing the business rules and the adapters connecting the HMI to the user, the cloud, databases and the rest of the machine. Ports lift the abstraction level from concrete technologies like SQL, J1939, Qt and MQTT to the business domain.
The machine port, for example, hides from the core whether the machine adapter uses the J1939 or OpenCAN protocol over CAN bus or Ethernet. If the manufacturer decides in 5 years to switch from CAN to Ethernet, it can do so without impacting the core and the other adapters. The architecture becomes loosely coupled, cohesive and easy to extend.
Each port has at least two adapters: one for production and one for testing. Test adapters are either test cases or mocks. As the core, they are technology agnostic and I/O-free. We can write I/O-free tests for the core. Such tests are ideally suited for TDD or BDD.
Conway’s law tells us that the software architecture mirrors the organisation structure. So, it is not surprising that the architecture more often than not resembles a big ball of mud. We can avoid this by inverting Conway’s law. We map the core and adapters to separate teams. The ports become the team APIs. Some teams can be merged - especially if too small. Other teams should not be merged.
The ports-and-adapters architecture has gained a lot of traction in enterprise software, but is little known in the embedded world. This is unfortunate, because it is an excellent architecture not only for embedded HMIs but also for firmware.
Look-up tables have been speeding up math operations for time immemorial, but there's more to this simple programming "idiom" than just numbers in an array. Join me in this talk as we discover and categorize the different ways we can store and retrieve data from arrays in ways that enable all sorts of fun and useful things, from creating digital music to building jump tables that drive command parsers or finite state machines.
Modern software engineering practices and embedded systems development are often in conflict.
Software engineering has seen major progression in the last few decades – the way we design systems has changed with object oriented methods (including the ability to add layers of abstractions and generic types); inheritance has significantly altered how we implement systems, and garbage collection has improved many programmer’s sleep. Combined, these advances have given us improvements in maintainability, verification, reusability, and time to market.
The issue at hand is that not all of these mechanisms translate into efficient structures – the driving force between cost and energy savings. Examples of where it would be acceptable to deliver a system that needs twice the resources to operate, are few and far between.
In this talk we explore where the inefficiencies crept in and discover how simple software engineering can help to reclaim those losses.
The Quest for the Perfect Asynchronous Sample Rate Converter
Presented by Wessel Lubberhuizen
In audio applications you often need to convert audio streams from one sampling domain to another. When the clocks of these domains are unrelated and possible drifting, you’ll need an asynchronous sample rate converter. In this talk we'll discuss ways to implement these with a minimal number of multiplications per sample, using multistage, multirate IIR filters based on all-pass filters and halfband filters, and polynomial interpolation using normal, transposed and partially transposed Farrow structures.
Let’s shake the habits of the past, the world’s largest LoRaWAN event goes hybrid! The world's largest LoRaWAN event goes hybrid. Join the global, week-long virtual LoRaWAN conference from January 25 to 29, 2021 and participate in local events all around the world.
Things We Should Not Do In Future Radios, (Future Designs Should Not Include Past Mistakes)
Presented by fred harris
Wireless technology is a shining example of a disruptive innovation that has changed society in remarkable ways. The innovation has altered how people communicate, how people access information, how people are entertained, and how people conduct and schedule their social lives. Every human activity advances and grows through a number of influences. One is experience, one is market forces, another is effective education, and yet another is common wisdom. Common wisdom is entrenched perspectives and levels of understanding accepted by the community as guide posts of the process. In fact there are many examples to be found in the wireless community of common wisdom being faulty. Samuel Clemens’ comment “It ain’t what you don’t know that gets you in trouble, it’s what you know for sure that just ain’t so” The wireless community is not free of entrenched faulty common wisdom which is passed on to successive practitioners of the art. Universities are just as liable as industry for not examining and questioning common wisdom. In this presentation we examine the evolution of wireless technology from the early days through now and show how a number of wisdoms can be shown to not be wise but never-the-less have become entrenched in the fabric of our wireless technology
Real-world signals often have frequency content that changes over time. Therefore, there is a need to describe signals jointly in time and frequency. Signal processing techniques for time-frequency analysis have been developed in response to this need and constitute a powerful tool for practitioners.
There is no unique or universally optimal time-frequency analysis technique. However, the proliferation of time-frequency analysis techniques should be regarded as an advantage. The signal processing engineer or data scientist is free to choose the method best suited to their type of data or application.
In this talk we discuss several time-frequency analysis techniques and illustrate their application to common signal processing workflows. The theoretical underpinnings of these techniques and differences between them are highlighted to elucidate their strengths or weaknesses with respect to specific types of signals and applications. Finally, we discuss the important role that time-frequency analysis plays in AI applications with signals.
Most interesting data series consist of signal and noise series that are usually non-stationary, i.e. the properties fluctuate with time.Fourier analysis (FT) of the whole time series provides the spectrum of the whole time series, but is not capable of showing the time variation of the spectrum.The S-transform, also known as the Stockwell Transform (ST), uses a scalable, translating Gaussian window to determine the local spectrum at every point on the time series.The local spectrum supplements the local temporal information in the time series, and aids in the detection of onsets and cessations of events.For a N point time series, the output of the FT is a N point complex spectrum; the output of ST is a Nx N, 2D time-frequency matrix, giving a N point spectrum at every point on the time series.Since the original time series contains only N points, the additional N2 - N points is a measure of the non-independent, redundant information computed for the ST.The redundancy is useful in presenting the similarities in the neighbouring local spectra and contributes to the visual continuity and smoothness to the 2-D time-frequency spectrum. The computation and storage of N2 - N additional points is a major drag on the usage of ST. Several approaches to reducing the computational burden are presented.Local spectra aids in analysis of 1D data. In images, the 2D local spectra aids in definition of texture and image segmentation.For 3 and 4 colour images, Trinion ST and Quaternion ST have been defined.In use since 1997, ST has found applications in numerous disciplines, including medical data series and images; power quality disturbance; atmospheric physics; exploration geophysics etc.The ST has been implemented in ARM and Raspberry Pi processors by several researchers.
This presentation is introductory, for the interested practitioner.Mathematical content will be at the absolute minimum.
Timing Synchronization in Software Defined Radios (SDR)
Presented by Qasim Chaudhari
A Software Defined Radio (SDR) merges the two fields of digital communication and digital signal processing into an efficient implementation of transmitters and receivers. One outcome of this combination is an interesting perspective on how timing synchronization is performed in digital communication receivers. This session will explain the timing synchronization problem in both time and frequency domains and then discuss in detail a timing locked loop consisting of timing error detectors, loop filter, interpolation and interpolation control. Insights into the relation of timing synchronization with general receiver design will also be presented.
Tiny devices, like the ones suitable for low-power IoT applications, are now capable of extracting meaningful data from images of the surrounding environment.
Machine vision algorithms, even Deep Learning powered ones, need only a few hundred kilobytes of ROM and RAM to run. But what are the optimizations involved to execute on constrained hardware? What is it possible to do, and how does it really work?
In this session, we will focus on the capabilities that are available for Cortex-M microcontrollers, starting from the user-friendly environment provided by EdgeImpulse to train and deploy Machine Learning models to the OpenMV Cam H7+.
We will guide attendees through the process using a straightforward example that illuminates inner workings so that attendees can get a grasp on technologies and frameworks. Attendees will walk away understanding the basic principles and be able to apply them not just to the Cortex-M but beyond.
Machine learning allows small, battery-powered devices to understand speech, protect wildlife, diagnose and even treat diseases. In this talk, Pete Warden, lead of the TensorFlow Lite Micro open source project, will talk about how embedded ML opens up a new world of possibilities, and will introduce some easy ways to get started.
Tips and Tricks for Avoiding and Fixing Real-Time Issues
Presented by Olaf Schmidt
Today embedded systems are made up of a large number of hardware parts, SoC, CPU and networks. On the software side many layers of large software stacks, API and applications are used. The complexity of the systems is ever increasing. Most people set their focus on getting the multitude of functional requirements done. Functional requirements are what the customers sees in the first line.
But, hey, there are also temporal requirements in many use cases. Users expect a certain reaction time of their system. They don't care about complexity, well defined interfaces or big amounts of data being transferred. Press a button and immediately see a light switch on. In an autonomous vehicle the required time from recognizing an obstacle to making the decision to turning the steering wheel is only milliseconds. The requirements describe end-to-end timing in many cases. Data coming from an input has to be at output within a certain time. We call the data flow "event chain".
This talk will take you on a journey through a model-based approach. Using a model to design the system and its timing behavior has the big advantage, that it can be used in simulation. The simulation runs the model and shows the timing behavior of all components, busses, scheduling, end-to-end timing and so on. It is possible to try out different scenarios quickly and find the best configuration. In the talk we will look at both the system view and the device view. They have to be synchronized and contribute to the overall user experience. On the way timing requirements are formalized, evaluated and violation is reported. Timing requirements for individual parts of the systems like cores and software components can be derived from the model and simulation.
After determining the best configuration teams will spread out and start the implementation. Trace files, that contain the timing of the implementation are taken. The traces are tested against the timing requirements already defined in the design step. The adherence to all timing requirements can be check upon every step in the projects. Upcoming problems are found early.
Join me in the exciting journey of flashing the light of a car within the expected time.
Tips and Tricks for Designing Real-time IoT Systems
Presented by Jacob Beningo
IoT devices are becoming more complex and compute-intensive with every passing month. Keeping up with customer needs and requirements requires a design that is not just updatable and robust but also scalable and configurable.
In this session, we will explore practical tips and tricks for designing real-time IoT systems. Major topics that we will discuss include:
Tips and Tricks for Designing Real-time IoT Systems
Presented by Jacob Beningo
IoT devices are becoming more complex and compute-intensive with every passing month. Keeping up with customer needs and requirements requires a design that is not just updatable and robust but also scalable and configurable.
In this session, we will explore practical tips and tricks for designing real-time IoT systems. Major topics that we will discuss include:
Tips and Tricks for Developing Products using the ESP32
Presented by Jacob Beningo
The ESP32 Wi-Fi / Bluetooth module has found its way into not only hobbyist applications but also professional IoT devices. This low-cost device with its open source software and strong ecosystem has many interesting characteristics that make it extremely attractive for use in a design. In this session, we are going to look at the nuances of designing products using the ESP32 and provide tips and tricks for successfully launching a product with it.
Topics covered in the session include:
How to select the right ESP32 module
Partitioning the Wi-Fi and Bluetooth capabilities with application software
Advanced processor features, multiplexing and other capabilities
How to leverage the open source software ecosystem
Tips to Boost Your Productivity with Modern RTOSes
Presented by Benjamin Cabé
Developing embedded applications using modern real-time operating systems (RTOS) can be challenging, and going from a quick prototype to a production-ready application can be daunting. In this talk, we will be going through concrete examples of embedded development best practices, and useful development tools that can not only save you time, but also help you build more robust applications. We will be using the Zephyr RTOS as an example, but the concepts and tools we will be discussing are applicable to any RTOS.Some of the topics we will be covering include:
Simplifying testing through emulation software (ex. Wokwi, Renode, qemu, ...)
Boosting you command line
Setting up CI/CD for your embedded project
Leveraging Software Bill of Materials (SBOM) to improve security and traceability
Leveraging some cool Visual Studio Code extensions for embedded development
By the end of this talk, participants will have gained practical insights and knowledge to improve their productivity when developing embedded applications using an RTOS, and Zephyr in particular.
Tools and Techniques to Debug an Embedded Linux System
Presented by Sergio Prado
Summary: In this talk, we will learn how to use different tools and techniques to debug an embedded Linux system.
Description: There are several tools and techniques to debug an embedded Linux system that can be applied in both user space and kernel space. Depending on the problem, you may need different tools like addr2line for crash dump analysis, GDB for interactive debugging, ftrace for kernel tracing, valgring to catch memory-related issues, gprof for application profiling, etc! In this hands-on oriented talk, we will learn how these and many other tools and techniques can be used when debugging an embedded Linux system.
We've asked some of our speakers to tell us about their favorite hardware and software tools for Embedded Systems development.
What about you? What are your favorite tools?
Tour of Embedded Systems: What in the World is Going On?
Presented by Tim Guite
It is hard to define an embedded system and even harder to decide where the world of embedded systems ends and becomes electronics on one side, software on the other side and system design on the other other side. In this talk, I will present the current state of two complimentary pillars of embedded systems - chips and software – with possible tangents into areas such as PCB design, testing and simulation.
The traditional hierarchy of chips (IC → FPGA → MCU → SoC) nicely mirrors the traditional hierarchy of embedded software (Bare Metal → RTOS → OS). However, this is not the world we live in: AMD owns Xilinx, Amazon and Microsoft are handing out RTOS’s, ST is presenting AI solutions. MCUs and FPGAs in the same chip, containers for embedded, RISC-V picking up steam. Consolidation and disruption has produced new combinations of technologies which challenge us on how best to use them and connect everything together.
After watching this talk, you should walk away with a better understanding of:
The major industry players in embedded systems
How new chips fit into the traditional hierarchy
What tools are available at different layers of the software stack
Training and Deploying ML models to STM32 Microcontrollers
Presented by Jacob Beningo
Machine learning (ML) has often been considered a technology that operates on high-end servers and doesn’t have a place in traditional embedded systems. That perception is quickly changing. This workshop will explore how embedded software engineers can get started with machine learning for microcontroller based systems.
This session balances theory with practical hands-on experience using an STM32 development board.
Attendees will learn:
How to collect and classify data
Methods available to embedded developers to train a model
Hands-on experience training a model
How to convert a model to run on an STM32 MCU
How to run an inference on a microcontroller
Additional details for development board and tools will be provided closer to the conference.
Troubleshooting Embedded Applications with Runtime Visualizations
Presented by Kristoffer Martinsson
Presented by Percepio
Using an RTOS often increases the complexity of embedded applications. For example, there could be timing issues that only happen in certain situations that are difficult to replicate and debug. Normal debug techniques such as breakpoints often fail to isolate the problem.
Join this presentation to learn how visualization of runtime behavior can ease debugging and help you quickly identify the root cause of an issue, using a hands-on example.
Trustzone-M and beyond, with Renesas RA MCUs and tools
Presented by Andy Beeson
Presented by Renesas
TrustZone-M is a core technology developed by Arm as part of the v8-M architecture. It was designed to enforce a logical partition between Secure and Non-Secure MCU regions, acting as a building block in producing more secure MCU applications. However, on its own Trustzone-M is not MCU security.
In this session, we will examine the implementation of Trustzone-M in Renesas Cortex-M33 based RA4 and RA6 MCUs, along with the additional features that build on top of this to further enhance embedded security. Also covered will be the software development tools that provide the necessary workflows to allow customers to deliver a secure system.
This talk will cover what is fact, hype, and pure fiction about automated vehicle safety, including both vehicles without human drivers and those that require a human driver to be present.
Tutorial: Modeling and Deploying DSP Algorithms to STM32 Microcontrollers using Matlab
Presented by Jacob Beningo
The ability to model and simulate a digital signal processing (DSP) algorithm is critical to modern embedded systems. Unfortunately, many developers aren’t familiar with the techniques necessary to model and deploy their model to their target microcontroller. Instead, they lose valuable time by hand coding the algorithms.
In this session, we will show how to produce an embedded implementation of a DSP algorithm based on a simulation model written in MATLAB, and then deploy an algorithm to an embedded system. We’ll use the STM32 microcontroller family as an example.
This session will include:
How to model a simple DSP algorithm.
An example for simulating algorithm behavior.
The process for deploying the model to a microcontroller target.
Techniques to tie the model into existing embedded software.
Tool and techniques that are available to developers to simplify development.
Tuxera Reliance Edge power-failsafe file system demo
Presented by TUXERA
This demonstration shows how power interruption causes failures in the FAT file system. Tuxera's Reliance family of file systems - including Reliance Edge and Reliance EdgeNAND - is incorruptible under the same conditions. Reliance Edge™ is a small-footprint IoT embedded file system designed to capture and preserve decision-quality data. A transactional file system, Reliance Edge protects critical system and user data from corruption, specifically for systems where power loss may occur. It works with a broad array of storage media including: eMMC, SD/MMC, NVRAM, USB mass storage, and SATA (or PATA) disks, and with a wide variety of real-time operating systems.
Unbrickable remote firmware updates for highly secure MCUs
Presented by Tobias Goebel
The development of embedded software for connected devices usually follows traditional, linear “waterfall” approaches, and cannot adopt modern “agile” methods. This is due to the belief that hardware and firmware are interdependent, and that manufacturing is the final stage of the production process.
While over-the-air firmware updates are possible, they are mostly used to fix bugs or patch security holes, not to improve an existing product over time. This causes long release cycles for product innovation and costly troubleshooting. It’s time for a new approach.
We're introducing a new IoT architecture we call the microvisor-based approach, which brings:
Unbrickable over-the-air firmware updates,
A reference security implementation built on top of the must-have feature of secure boot,
Secure remote LIVE debugging, which allows you to log into a device and inspect/debug the code as it gets executed in the field
Most embedded systems have some aspect of safety or mission criticality involved in their design. All embedded developers need to know the safety basics. But this is not a typical safety talk that crawls through the various parts of some specific safety standard. Instead, we will discuss what makes safety engineering processes different from other types of engineering activities, how to think about safety when the loss event is less dramatic than an airplane falling out of the sky, and how to determine how much and what kind of safety engineering you need for your system.
This approach will give attendees a robust framework for thinking about safety without getting caught up in the details of any particular safety standard.
Understanding Frequency Response on Mixed-Signal Systems
Presented by Miguel Angel Castillo Martinez
In Mixed signal applications we must consider the operating bandwidth. The most visual representation of this behavior is obtained by a bode diagram, stimulating the system with a known fundamental signal to compare and measure the magnitude and phase in the output. For academic purposes, the most widely used platform is the Arduino, with boards based on the AVR microcontroller.
This talk will investigate the software and hardware tools required to implement a basic mixed-signal system, bringing a better understanding of frequency system response using a microcontroller and Analog filters. You will be able to implement an experiment to facilitate your own learning system.
Although it might seem complex at first glance, the concepts behind a real-time operating system, or RTOS, are fairly simple to understand. An RTOS is little more than software that manages the time and resources of a CPU. An RTOS ensures that time critical code executes before non-time critical one, and allow you to split your application into separate functional units called tasks. An RTOS also provides valuable services to your application such that tasks can interact with one another as needed. This simple model happens to be effective, which is one of the reasons why RTOSes are used in countless IoT and embedded systems.
In this RTOS introductory class, I will describe most of the RTOS concepts in generic terms using visual aids. I will also expose both the benefits and drawbacks of RTOS-based systems. By the end of this class, you should be able to determine whether an RTOS is a good fit for your application.
Duration: 60 minutes (with Q&A)
Audience:
All levels
Requirements:
Understanding of CPU architectures, memory, interrupts
Understanding VFIO and UIO user space driver framework
Presented by Vandana Salve
VFIO and UIO are Linux kernel frameworks that securely provide direct device access to userspace. This presentation will provide attendees with an overview of VFIO and UIO work. In addition, developers will learn how PCI devices are exported to userspace and how applications like QEMU use devices in virtual machines (VMs).
Topics covered include:
How virtualization uses VFIO to assign physical devices to VMs
How VFIO decomposes devices as a set of userspace APIs and applications like QEMU
How devices create, a programming interface made up of I/O access, interrupts, and DMA and IOMMU.
Discuss supported features such as interrupts/MSIx, DMA, IOMMU, and limitations of UIO with VFIO.
Unlocking Cryptography: Fundamentals and Applications in Embedded Systems
Presented by Frida Gail Rojas Contreras
The goal of this talk is to provide an overview of cryptography, including security fundamentals, types of cryptography, cryptography algorithms, and some of its applications in embedded systems.
Using C++ Features for Embedded System Development
Presented by Ravindra Singh
From the introduction of C++14 onwards, there are various C++ features such as templates, constexpr, specialized classes, etc., which provide new ways to develop bare-metal software for embedded systems that is as efficient as, and in some cases more efficient than, a bare-metal C program.
Using Low Power Wide Area Networks For Industries with Minimal Total Cost Of Ownership And High Robustness
Presented by Burak Polat
Low power wide area networking technologies enable users to use low cost, battery-powered sensors from long communication distances with minimal service and setup requirements. This accelerates industrial digitalization efforts by lowering down the cost of IoT for enterprises, it also creates an enormous opportunity for better industrial AI. However, due to the very nature of those technologies and the current hardware ecosystem, there are some important aspects that users need to be aware of such as hardware management, network optimization, and overall system modeling. Burak will talk about the fundamentals of using low-cost networking and IoT technologies for industrial requirements.
Using Open-Source Build Tools in a Professional Environment
Presented by Christopher Seidl
The open-source CMSIS-Toolbox offers new ways of working on embedded projects. It uses CMSIS-Packs for device/board support and access to reusable software components. The operation is controlled via intuitive csolution project files in YAML format. The build engine CMake/Ninja calls the C/C++ compiler toolchain that generates the build output. In this session, professional developers will learn how to use the new project format in an IDE integration, and on CI and MLOps systems.
Getting started with embedded Linux can be a daunting task due to the inherent complexity of the Linux kernel; it can also be costly, since generally any sort of driver development and testing requires hardware. QEMU can serve as an alternative to allow engineers to get started with embedded Linux with minimal cost.
In this workshop, Mohammed Billoo will walk through what QEMU is and the different workflows that it enables, with hands-on demonstrations that attendees can follow along. Demonstrations will include setting up QEMU to emulate an ARM-based machine on a x86-based host PC and launching into a terminal, using QEMU to step through the Linux kernel, and developing and testing a simple device driver with device emulation in QEMU.
This workshop has the following prerequisites:
Install Ubuntu >= 18.04 on your PC (either on bare-metal or as a VM):
Install your favorite text editor (e.g. nano, vim)
Clone the buildroot repository on your Ubuntu installation by executing the following from the command line: $> git clone git://git.buildroot.net/buildroot
Clone the qemu repository on your Ubuntu installation by executing the following from the command line: $> git clone --depth 1 --branch v6.2.0 https://github.com/qemu/qemu.git
Clone the Linux kernel repository on your Ubuntu installation by executing the following from the command line: $> git clone --depth 1 --branch v5.17 git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Developing any FPGA or Embedded system can be complex, especially when it comes to validating either on development boards or in the real system that it functions as intended across all operating and failure conditions.
This is especially true when we are working with high reliability or mission critical systems such as satellite applications where we might want to retire functional risk early in the development program.
In this session we will explore how we can use RPI Pico to emulate system interfaces connected to our embedded system / FPGA. This allows the emulation of failure conditions, boundary conditions and corner cases with ease. Implementing such an approach will assist with validation and reduce the risks of issues later in development.
We will present several real-world examples where Adiuvo has used RPI Pico to simulate interfaces from SPI and I2C to clocking and advanced communication interfaces like SpaceWire.
Every silicon vendor seems to have their own IDE. They often have desirable diagnostic capabilities but are lacking in terms of a modern editing experience and are tightly coupled with specialized compilers.
What if you would prefer to use Visual Studio Code instead? How can you get your embedded compilers working in that environment? Will you have the diagnostic capabilities you need? If you get things working there will that extend to your CI system? This talk will help you answer those questions:
Getting your compiler working
Deploying and debugging your firmware
Using embedded diagnostic capabilities like RTOS and peripheral views
Importing IAR and STM32 projects
Using GitHub Actions and CodeQL for embedded projects
Using Visual Trace Diagnostics to Evaluate Linux User space and Kernel space Implementations
Presented by Mohammed Billoo
Developing performant implementations for Linux-based embedded systems can be difficult, due to the sheer complexity of the Linux kernel and the volume of processes and applications that generally exist on a Linux-based embedded system. For kernel space implementations, such as kernel modules, it is important to leverage the appropriate interfaces to the kernel and pay careful attention to the hardware interface. For user space applications, performance is key to ensure that the application can scale without substantial rework.
Software tracing can be an invaluable tool to ensure that an implementation is performant. It enables a developer to identify any anomalies that may exist while the system is running. While there exist numerous open-source utilities that can provide textual cues towards the performance of the implementation, they are generally not amenable to quickly identify any clear issues, due to the way the human brain operates.
Visual trace diagnostics can significantly reduce the time to identify anomalies in a Linux-based implementation. It leverages software tracing, but presents data in a manner that is easily consumed by the human brain. This results in quickly identifying and rectifying anomalies in an implementation.
Join Mohammed Billoo as he explores the different facets of visual trace diagnostics. His talk will consist of hands-on demonstrations that show the different elements of capturing and analyzing software traces on a Linux-based embedded system, in both user space and kernel space.
Using Visual Trace Diagnostics to Uncover Hidden Issues
Presented by Dr. Johan Kraft
Presented by Percepio
Embedded IoT software is often multi-threaded, event driven, and resource-constrained. This increases the difficulty of IoT software development and calls for better means for debugging, beyond the limited scope of traditional debugging tools.
Software event tracing can improve IoT software development by providing a timeline of the overall software activity. This is very useful information for debugging, profiling and for finding software design flaws. Tracing can be performed entirely in software and remain active over long durations. It can even be used in deployment.
However, tracing produces lots of repetitive data. When debugging, you need to find a small number of anomalies. This can be like searching for needles in a haystack.
The human brain is visual and excels at pattern recognition. Visual trace diagnostics makes it possible to leverage this capability to make the anomalies stand out. This builds on software event tracing, but refines the data into a rich, meaningful model and visual overviews that makes it easy to spot anomalies. The result is quick, intuitive comprehension, even for large traces. This approach is invaluable in system-level debugging and for finding software design flaws.
Join Dr. Johan Kraft as he explores visual trace diagnostics and presents real-world examples of its use in locating and solving hidden software issues.
Let's dive into state machines by building an embedded security system!
State machines are an incredibly helpful pattern for embedded systems, but hand-coded state machines can be difficult to understand and maintain, especially as designs become more complex with additional states and transitions.
To make our lives easier, we are going to use StateSmith to visually model our state machines in draw.io and PlantUML.
StateSmith is a cross-platform, free/open source tool for generating state machines in multiple programming languages (C, C++, C#, Java, Python, JavaScript, TypeScript). The generated code is human-readable, has zero dependencies, and is suitable for use with tiny bare-metal microcontrollers, video games, apps, web, computers, and more. It avoids dynamic memory allocations for those focused on safety or performance. Each state machine instance only requires a single byte of RAM.
We'll start by creating a simple button state machine that performs debouncing and long press detection. Then we will connect those button state machines to our Control and Display state machines.
Every step of the way, we will simulate our design using Wokwi (an online electronics simulator) so that you can easily follow along without any physical hardware.
Following the success of Voice Assistant over Smart Speaker, a new breed of voice-enable devices are services are being developed which will enable massive dissemination of voice activation services, everywhere. Smart home, smart health and Industrial applications are some of the first that will benefit with deployment through smart home appliances, health assistants and smart manufacturing. This talk goes through a case study of a constrained IoT voice assistant implementation on an ultra low power, lost cost device. It describes the hardware and software functional blocks that is needed in order to perform voice recognition in harsh audio environments. It shows the benchmarks of analog front end processing and Keyword Spotting in the system. It explains the communication and security services integration, from the root of trust to cloud communication. Finally, it analyses what the future of voice and accompanying services and devices will look like what solutions will be needed.
Want to Reduce Power in Always-on IoT Devices? Analyze First
Presented by Tom Doyle
Hundreds of millions of portable smart speakers are listening for a wake word. Millions more acoustic event-detection devices are listening for window breaks, baby cries or dog barks. Consumers appreciate how easy it is to use their always-on listening devices – but the battery drain that results from continuously processing all sounds in their environment? Not so much.
The problem is that this massive number of battery-powered IoT devices are notoriously power-inefficient in the way that they handle sound data. Relying on the age-old “digitize-first” system architecture, these devices digitize all the incoming sensor data as soon as they enter the device; then the data are processed for relevance, and in some cases, sent to the cloud for further analysis and verification. Since 80-90% of all sound data are irrelevant in most always-listening IoT devices, the digitize-first approach wastes significant battery life.
This session will show attendees how an “analyze first” edge architecture that uses analogML at the front end of an always-listening device eliminates the wasteful digitization and processing of irrelevant data, to deliver unprecedented power-saving and data efficiency in IoT devices.
Session attendees will:
Understand that while most of today’s machine learning is implemented digitally, machine learning can also be implemented in ultra-low-power programmable analog blocks (analogML) so that feature extraction and classification can be performed on a sensor’s native analog data.
Understand that the power problem for IoT devices is really a problem of the device treating all data as equally important and that determining which data are important earlier in the signal chain — while the data are still analog — reduces the amount of data that are processed through higher-power digital components. This approach saves up to 10x in system power in IoT devices.
Learn how to integrate this new analogML edge architecture with sensors and MCUs from leading semiconductor suppliers into current and next-generation IoT devices.
You'll find Workshop setup instructions, project files, and slides in the download link located under "Files Provided by the Speaker(s)" on the left (you need to be logged in to access those files).
Prerequisite: Solid knowledge of C. Some exposure to C++ and classes will be helpful, but not essential.
C is a “low-level high-level” language. It has flow control and data structures found in many other high-level languages. It also has “low-level” data types and operators that let you get close to the hardware. The result is a language that’s easier to use than assembly language, but with comparable performance. As such, C has been a natural choice for many embedded applications, including automotive, aerospace, consumer products, and medicine. So why consider using C++ instead of C?
Embedded software keeps showing up in more and more products. More powerful processors and larger memories have led to ever more complex systems, with increasing demands for safety and security. Embedded developers need more effective tools to help reduce, if not eliminate, defects that pose safety and security risks.
C++ is nearly all of C, plus a whole lot more. C++ classes, namespaces, and templates help manage large-scale software. C++’s richer and more rigorous type system can turn potential run-time defects into code that simply doesn’t compile or link. This leads to software that’s easier to use correctly and harder to use incorrectly.
This workshop uses concrete embedded programming examples to show in detail how selected C++ language features can benefit embedded software development. The selected features include:
references
overloaded functions and operators
enhancements for enumerations
classes, member functions, and access control
user-defined conversions
Attendees will have the opportunity to do programming exercises during the workshop. You'll be able to compile the exercises using desktop tools such as GNU C++ or Visual C++. We've provided a sample program that you can use to test your compiler setup before you attend.
A lot of people design embedded systems. Some of them are the hardware design engineers who create the boards. Others are the software developers who program the boards. The one thing that most of them have in common (apart from mutual distrust of each other) is that they predominantly use microcontrollers (MCUs) as the primary processing element in their designs.
Most of them have heard of FPGAs, but all they typically know is that these devices can be programmed to perform different functions -- they don't know how. Similarly, most of them have heard about languages like Verilog and VHDL, but all they typically know is that FPGA designers use these languages to capture the design -- they don't know how these hardware description languages (HDLs) differ from programming languages like C/C++.
In this presentation, engineer, writer, and communicator Max The Magnificent (a legend in his own lunchtime) will rend the veils asunder and reveal all. Max says that we will be leaping from topic to topic with the agility of young mountain goats, so he urges attendees to dress appropriately.
Switches bounce -- that's what they do. To ensure our processors don't "see" multiple events, we have to debounce these signals, which we can do in hardware or software. Unfortunately, this is something of an arcane area because there are as many different approaches as there are engineers (some of them even work). In this MicroTalk, we will plunge into this esoteric topic with gusto and abandon, so please ensure you are wearing appropriate attire.
Bluetooth 5.4 introduced many new interesting features such as PAwR (Periodic Advertising with Response), and Encrypted Advertising Data. It also introduced the ESL profile which uses these features. Let's dive a little deeper into this and gain a deeper understanding.
Why Cybersecurity Should be Earlier in the Design Cycle
Presented by Jeridiah Welti
An exploration and justification of why cybersecurity needs to be an upfront consideration in design projects. The author examines the benefits of incorporating secure design early and integrating it throughout the entire lifecycle, as well as the drawbacks of postponing it until the end. Key considerations include budget, time to market, and overall security of the final product.
Why Embedded is Broken (and What to Do About It): Transforming Legacy Development Practices Through Modern Principles
Presented by Joe Schneider
The embedded systems industry remains anchored to outdated development practices that increase technical debt, slow innovation, and increase security risks.
This presentation examines how modern software development principles can revolutionize embedded development. We'll explore practical strategies for implementing modern toolchains, automated testing, and DevOps practices in embedded projects, demonstrating how these approaches reduce development cycles and improve code quality.
Attendees will learn actionable steps to modernize their embedded development workflow, from selecting appropriate tools to managing the cultural shift within their organizations.
Why IoT Devices Mandate a Zero Tolerance Security Architecture. Saving our Toasters, and Possibly the World!
Presented by Antoinette Hodes
Organizations must prioritize their strategic and tactical security requirements concerning Internet of Things (IoT) and adopt a proactive approach. This entails implementing an agnostic model that guarantees the utmost security posture. Security of IoT devices plays a critical role in ensuring the efficient and dependable operation of interconnected systems. It is of utmost importance to implement robust security controls based on the Zero Tolerance framework to safeguard data integrity, user privacy, and overall system stability.
In this talk, Andrew Banks will discuss the importance of the static analysis in general, and the MISRA C/C++ Guidelines in particular, within Verification and Validation ("V&V") activities.
It will showcase common pitfalls that MISRA seeks to help avoid, and rationale behind some of the guidelines, while introducing the recent Amendment 2 to MISRA C:2012.
The presentation will also highlight why it is important to analyse and release "production" code.
Historically, real-time systems and database systems have been like oil and water. The reason? Making an API call to a non-deterministic database system could cause a real-time task to exceed its deadline. Previously, real-time systems were not overly complex and could do without database support. Today, however, real-time systems’ tasks need to collect, aggregate, correlate and analyze data from disparate sources (sensor data fusion) and could benefit greatly from a shared repository. This MicroTalk will present a solution: adding time-cognizance to database transactions, and suitable transaction schedulers.
Continuous Integration and Continuous Deployment (CI/CD) are all the rage today…but what does it actually mean and what can it really do for you? In this session, we’re going to talk about how it differs from traditional embedded development and what advantages CI/CD can give you, all backed up by research. We will show you how it can easily help you improve code quality and why, helping you to foreshorten your time-to-market. We’ll also tell you who all the major players are in CI/CD and finish the session by showing you how you can quickly get into the CI/CD game!
Why your FPGA Design Might Need a Softcore Processor – What are the Options ?
Presented by Adam Taylor
FPGA are great for implementing highly parallel structures for image, signal, data processing and algorithms. These structures are ideal for implementation in programmable logic however, the control, configuration, interfacing and man machine interfacing require more often than not sequential processing. Of course for simple applications Finite State Machines can be used however designing, modifying and maintain which makes the difficult to implement complex control structures. The solution is to implement a simple soft core processor in the FPGA, this session will explore what our processor choices are proprietary vs open source, the decision matrix for implementation and trade-offs which occur when we decide to include the softcore processor in the FPGA.
One of the major benefits of using RISC-V is the flexibility the architecture provides, which enables OEMs as well as SoC vendors to design custom cores with the exact definitions needed for the application or product. The fact that you can add any instruction you need provides full flexibility for innovation and differentiation without compromising code quality or performance. These application-specific instructions (custom ISA extensions) is enabled through the .insn directive. In this webinar your will learn how to make use of your custom extensions in the development of your RISC-V based application.
One of the major benefits of using RISC-V is the flexibility the architecture provides, which enables OEMs as well as SoC vendors to design custom cores with the exact definitions needed for the application or product. The fact that you can add any instruction you need provides full flexibility for innovation and differentiation without compromising code quality or performance. These application-specific instructions (custom ISA extensions) is enabled through the .insn directive. In this webinar your will learn how to make use of your custom extensions in the development of your RISC-V based application.
In embedded systems, particularly in reliability-demanding environments like space, deterministic programming is crucial. A key aspect of this is avoiding dynamic memory allocation, especially on memory-constrained devices. This talk will explore the challenges and strategies for developing portable C++ libraries that operate solely on the stack.
We will emphasize the importance of stack-only programming in ensuring predictability and reliability in systems where memory management failures can lead to catastrophic outcomes. Attendees will learn techniques for managing constraints and implementing design patterns specifically tailored for stack usage.
Additionally, we will highlight practical examples and case studies, demonstrating how to leverage C++ features, such as type safety, encapsulation, and templates, to create robust libraries suited for resource-constrained environments. By the end of the session, participants will gain the tools and knowledge necessary to write efficient, reliable, stack-only C++ libraries that excel in the most demanding embedded contexts.
Yocto Customization and Large Scale Scalability in Embedded Systems
Presented by Aaksha Jaywant
Embedded systems have become the foundation of many technological innovations across industries, from automotive to consumer electronics and beyond. As these systems evolve, so too do the challenges faced by developers and engineers. The demands for flexibility, customizability, and scalability have never been greater. This is where the Yocto Project—a framework for creating custom Linux distributions—comes into play. In this conference, we’ll explore two critical areas: (1) creating custom Linux distributions with Yocto, and (2) the strategies and challenges involved in scaling Yocto-based solutions across large production environments.
If you don't already have an account on the Embedded Online Conference platform, you can register here and gain free access to this webinar.
It may be difficult for novice to intermediate Linux users and developers to get a fundamental understanding of the "Yocto Project", as it doesn't necessarily follow the same paradigms as traditional software development. Additionally, System on Module (SoM) vendors, such as Toradex, may apply their own customizations to the Yocto Project as part of their Board Support Package (BSP) that may require some additional understanding.
In this webinar, we will take a hands-on look at the Yocto Project and how to get a BSP up and running.
Attendees will learn:
- The paradigm of the Yocto project
- The mindset that an engineer should have when working with a BSP based on Yocto
- The organization and structure of the BSP provided by Toradex.
- Best practices engineers should follow when customizing a vendor-provided BSP to fit their custom hardware
This webinar will focus heavily on demos and examples targeting a Toradex Verdin iMX8M Mini on a Dahlia carrier board.
No customer wants to change or recharge batteries. This talk explores the techniques and methods to develop products that wisely consume only the energy that they need. Following a quick review of current, voltage, power, and energy, this session will cover:
The techniques used to budget for energy consumption during the initial product design
The equipment and methods used to measure voltage, current, power & energy
The common ways of reducing energy consumption in your product after you have hardware and software. These techniques span both hardware and software.
Energy management applies to nearly all battery-powered products including mobile phones, toys, and Internet of Things end node. Even always-on mains powered devices are concerned with power consumption to meet energy regulations, reduce cost, and consume less energy. This talk will help you develop better, more energy-efficient products.
Zephyr RTOS in Action: Versatile Development for Embedded Software
Presented by Pedro Bertoleti
This talk will explore Zephyr RTOS, in order to show how this RTOS can be a smart RTOS choice for versatile embedded software development. The following topics will be covered:
What's Zephyr RTOS project
Zephyr RTOS organization
Using device tree overlays to describe embedded system hardware in a smart way
Benefits of using Zephyr RTOS in scalable products
Practical example: developing a pulse counter project with LoRaWAN connectivity for three different Microcontrollers archtectures (Arm, Xtensa and Risc-V)
When logged in, you should be able to find and download, in the left column and under 'Files Provided by the Speaker', the 'Slides and Code' zip file.
Introducing Zephyr RTOS IoT programming and embedded C Programming using the BBC Microbit. A practical workshop suitable for makers, artists, and inventors.
Requirements to “follow along” and try out the examples.
1. Have nRF Connect SDK installed and also the required toolchains, Python and python packages required by West and Zephyr, and CMake, and, also Cmake.
There are many less known subsystems within Zephyr (the popular open source RTOS and ecosystem) that can help hardware and firmware teams bring up their new custom hardware designs. This talk will be a selection of these tools and pointers on how to get started within the ecosystem. This is a good talk for beginner to intermediate embedded engineers, including hardware engineers who are looking to do more firmware development (like I was!).
The Cyber Resilience Act (CRA) will be coming into effect in a few short years. The Zephyr project has been working towards making it easier for product makers to comply with the CRA over the last few years, and will continue to work with the community to refine these capabilities as more details become available.
From automatic "Build SBOM" generation to LTS vulnerability fixes, the project has some useful starting points already in place that will help product makers leveraging Zephyr in their solutions.
This talk will discuss what is available, and where some of the gaps will be for product makers to consider.
5 years ago the Zephyr project was launched at Embedded World, with the vision to deliver the best-in-class RTOS for connected resource-constrained devices, built to be secure and safe. Since then, many companies have collaborated together to create a vendor neutral solution to achieve these goals. The project has actively worked to adopt open source best practices, as well as best security practices. This talk will go into details about the practices Zephyr has adopted, and that other open source projects should consider, as we work to make the endpoints devices of the IoT ecosystem secure.
Creating an account on our platform is quick and easy - and it's a one-time process! Once registered, you'll be able to purchase passes for the upcoming 2025 Embedded Online Conference and unlock access to our extensive archives from past years.
