Simplifying integration of sensor data using NFC enabled Multi-Sensor Node
Instructor(s): John Tran
When: 05/20/2020 14:00:00 (EST)
Duration: 2 hours
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.
- ST25R3911B-DISCO (this is an NFC/RFID discovery board)
https://www.st.com/content/st_com/en/products/eval...
- STEVAL-SMARTAG1 (this is an NFC/RFIF evaluation board)
https://www.st.com/content/st_com/en/products/eval...
- CABLES USB A to Micro B
- CR2032 battery
Secure and Non-Secure application co-existence using TrustZone security technology
Instructor(s): Bob Waskeiwicz, Tim Nakonsut
When: 05/21/2020 10:00:00 (EST)
Duration: 2 hours
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:
https://www.dropbox.com/sh/9r810zc8pjxg83e/AADBTOrcSGIJX43auwkT_ziya?dl=0
Creating Advanced User Interfaces with STM32 Microcontrollers
Instructor(s): Mike Hartmann, Soren Mikkelsen
When: 05/21/2020 12:00:00 (EST)
Duration: 2 hours
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:
https://www.dropbox.com/sh/gsvu5d8u6d9e4ga/AAC2chHAdj-q2SzmEJe5VRjUa?dl=0
RTOS Design and Debugging Techniques Hands-on
Instructor(s): Jacob Beningo
When: 05/18/2021 15:00:00 (EST)
Duration: 2 hours
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.
Test-Driven Development
Instructor(s): James Grenning
When: 05/18/2021 13:00:00 (EST)
Duration: 2 hours
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.
An Introduction to Modern C+(+) for Embedded Programmers
Instructor(s): Niall Cooling
When: 05/18/2021 08:00:00 (EST)
Duration: 2 hours
Audience: experienced embedded C programmers
Duration: 2 Hours
Type: Hands-on labs
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".
The recording of this workshop will be made available on-demand within 24 hours after the workshop took place.
Building Accelerated Applications with Vitis
Instructor(s): Adam Taylor
When: 05/18/2021 10:00:00 (EST)
Duration: 2 hours
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
- …and more!
Learning how to Deliver AI Solutions In Days, Not Months
Instructor(s): Jenny Plunkett
When: 07/27/2021 14:00:00 (EST)
Duration: 2 hours
Please visit the following URL and read about a few things you should consider doing to prepare and take full advantage of the workshop:
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
- Purchase your Sony's Spresense kit from Adafruit today or check here for more buying options.
Fast Track to Designing FIR Filters with Python
Instructor(s): Dan Boschen
When: 10/06/2021 10:00:00 (EST)
Duration: 2 hours
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.
Option 1: Easy path to Python: Install the Anaconda Individual Edition which will have all the tools we will be using: https://www.anaconda.
Option 2: Alternative manual path to Python: As a minimum install we will be using Python 3, Numpy, Matplotlib, and Scipy:
Install python: https://www.python.
From command window type:
pip install ipython
pip install numpy
pip install matplotlib
pip install scipy
(if you encounter any difficulty with installing the packages, see this page: https://packaging.
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:
https://www.datacamp.com/
Notebook: Fast Track FIR Filter Workshop.ipynb
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.
Machine Learning with Python: Introduction to Clustering and Classification
Instructor(s): Matous Cejnek
When: 10/07/2021 08:00:00 (EST)
Duration: 2 hours
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.
Notebooks:
Training and Deploying ML models to STM32 Microcontrollers
Instructor(s): Jacob Beningo
When: 10/07/2021 10:00:00 (EST)
Duration: 2 hours
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.
Bluetooth Low Energy: The Swiss-Army Knife of Wireless Technologies
Instructor(s): Mohammad Afaneh
When: To be scheduled soon
Duration: 2 hours
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
- And more!
The recording of this workshop will be made available on-demand within 24 hours after the workshop took place.
Signal Processing with FPGA, Python & no RTL Design!
Instructor(s): Adam Taylor
When: 10/06/2021 08:00:00 (EST)
Duration: 2 hours
To take full advantage of this workshop, you'll need an Arty Z7 board. If you decide to purchase one, make sure to:
- Select the Z7-20 version.
- Enter the promo code DSPARTYZ725 to save 25%
Before attending the workshop, make sure to download and install:
- Pynq 2.6 for the PYNQ Z1 http://bit.ly/pynqz1_v2_6
- Vitis 2020.1 this includes Vivado and Vitis HLS - https://www.xilinx.com/support/download/index.html/content/xilinx/en/downloadNav/vitis/archive-vitis.html
- Check out this github link for more workshop material, including a pdf of the slides: https://github.com/AdiuvoEngineering/EOC_DSP
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.
Test-Driven Development
Instructor(s): James Grenning
When: 12/09/2021 14:00:00 (EST)
Duration: 2 hours
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.
MCU Driver Design Techniques
Instructor(s): Jacob Beningo
When: 04/29/2022 13:30:00 (EST)
Duration: 2 hours
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.
Using QEMU to Get Started with Embedded Linux
Instructor(s): Mohammed Billoo
When: 04/27/2022 14:30:00 (EST)
Duration: 2 hours
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 qemu-system-arm (sudo apt-get install qemu-system-arm)
- 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
What C++ Can Do For Embedded Systems
Instructor(s): Dan Saks
When: To be scheduled soon
Duration: 4 hours
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.
The recording of this workshop will be made available on-demand within 24 hours after the workshop took place.
Demystifying the Hilbert Transform
Instructor(s): Dan Boschen
When: 10/05/2022 10:00:00 (EST)
Duration: 2 hours
Workshop Description
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.
Option 1: Easy path to Python: Install the Anaconda Individual Edition which will have all the tools we will be using: https://www.anaconda.
Option 2: Alternative manual path to Python: As a minimum install we will be using Python 3, Numpy, Matplotlib, and Scipy:
Install python: https://www.python.
From command window type:
pip install ipython
pip install numpy
pip install matplotlib
pip install scipy
(if you encounter any difficulty with installing the packages, see this page: https://packaging.
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:
https://www.datacamp.com/
Polyphase Analysis and Synthesis Filter banks: capabilities and implementation
Instructor(s): fred harris
When: 10/04/2022 10:00:00 (EST)
Duration: 2 hours
Two papers related to this workshop and made available by fred harris:
- Performance Options of a High Performance Receiver Filter Bank Channelizer
- Analysis Channelizers with Even and Odd Indexed Bin Centers
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
Instructor(s): fred harris
When: 10/06/2022 10:00:00 (EST)
Duration: 2 hours
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
Building IoT Machine Learning Applications using the Raspberry Pi Pico
Instructor(s): Jacob Beningo
When: 12/15/2022 15:00:00 (EST)
Duration: 2 hours
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:
- https://www.digikey.com/en/products/detail/raspberry-pi/SC0915/13624793
- https://www.digikey.com/en/products/detail/seeed-technology-co-ltd/105020012/5973992
- https://www.digikey.com/en/products/detail/seeed-technology-co-ltd/103100142/13688265
- https://www.digikey.com/en/products/detail/te-connectivity-amp-connectors/5-826936-0/2276291
We will discuss several machine learning frameworks and tools, but the hands-on piece will use Edge Impulse Studio.
Hands-On Workshop Integrating Toradex Torizon and Amazon AWS
Instructor(s): Mohammed Billoo
When: 12/14/2022 15:00:00 (EST)
Duration: 2 hours
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.
Fixed-Point Filters – Modelling and Verification Using Python
Instructor(s): Dan Boschen
When: 04/26/2023 10:00:00 (EST)
Duration: 2 hours
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!
Rust for C Programmers
Instructor(s): Jacob Beningo
When: 04/28/2023 10:00:00 (EST)
Duration: 2 hours
If you plan to attend and work through the hands-on materials, we recommend that you set up the following tools prior to the class:
1) Visit https://rustup.rs/ and follow the instructions to install Rust
2) Visit https://docs.rust-embedded.
- itmdump
- cargo-binutils
- arm-none-eabi-gdb
- OpenOCD
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
Test-Driven Development
Instructor(s): James Grenning
When: 04/24/2023 10:00:00 (EST)
Duration: 2 hours
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.
Design Considerations for Serial Communications in an RTOS Environment
Instructor(s): Peifang Zhou
When: 04/25/2023 12:00:00 (EST)
Duration: 2 hours
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.
- IDE – Create a user account, download STM32CubeIDE from ST website https://www.st.com/en/
development-tools/ , and install it on a Windows computer.stm32cubeide.html - 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.
Quick Start on Control Loops with Python
Instructor(s): Dan Boschen
When: 09/28/2023 11:00:00 (EST)
Duration: 2 hours
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.
Getting Started with Embedded DevOps using Gitlab CI/CD Pipelines
Instructor(s): Jacob Beningo
When: 11/15/2023 12:00:00 (EST)
Duration: 2 hours
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
- CI/CD pipeline design for embedded systems
- Containerizing your build system in Docker
- Set up and deployment of CI/CD solutions
- Best practices and steps to go further
Getting Started with Embedded DevOps using Gitlab CI/CD Pipelines
Instructor(s): Jacob Beningo
When: 05/02/2024 10:00:00 (EST)
Duration: 2 hours
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
- CI/CD pipeline design for embedded systems
- Containerizing your build system in Docker
- Set up and deployment of CI/CD solutions
- Best practices and steps to go further
Modern C++ Interface Design
Instructor(s): Ben Saks
When: 04/30/2024 10:00:00 (EST)
Duration: 2 hours
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
- explicit conversion operators
- attributes (e.g., [[deprecated]], [[nodiscard]], [[fallthrough]], etc.)
- structured bindings
- std::optional
- std::expected
Building a Clean and Simple Command Line Interface in an RTOS Environment
Instructor(s): Peifang Zhou
When: 05/03/2024 10:00:00 (EST)
Duration: 2 hours
It is a sequel to last year’s two presentations: Design Considerations for Serial Communications in an RTOS Environment and Building a Simple Command-Line Interface.
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.
Zephyr RTOS Programming with the BBC Microbit v2
Instructor(s): Andrew Eliasz
When: 05/01/2024 10:00:00 (EST)
Duration: 2 hours
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.
https://developer.nordicsemi.
2. Download the BBC Microbit examples from Frank Duigan’s github site
https://github.com/fduignan/
3. Setup a CLI (Command Line Interface) Zephyr development (build) environment using Chocolatey on Windows.
Useful guide : https://zafersn.medium.com/
[ The Zephyr BBC Microbit examples do not (currently) play nicely with the nRF Connect SDK plugin for VSCode ]
4. Get hold of a BBC Microbit v2 (v2.2) board and a USB cable e.g. from adafruit
Security made easy on STM32H5: STM32Trust TEE Secure Manager
Instructor(s): Massimo Panzica, Mena Roumbakis
When: 04/29/2024 10:00:00 (EST)
Duration: 2 hours
***** Giveaway Alert! *****
Watch this workshop before May 5, 2024, for a chance to win one of 15 STM32H573I-DK board !!!
Prerequisites for this workshop can be downloaded here.
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.
- One STM32H5 Discovery kit (part number: STM32H573I-DK), which you can purchase in the ST eStore or from one of our distributors.
- One USB cable (Type C, or Type C-to-Type A)
- Software tools, downloaded and installed prior to the workshop.
Expert Insights into Waveform Analysis Techniques
Instructor(s): Dan Boschen
When: 10/30/2024 11:00:00 (EST)
Duration: 2 hours
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.
Advanced Serial Communications in an RTOS Environment
Instructor(s): Peifang Zhou
When: To be scheduled soon
Duration: 2 hours
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.
The recording of this workshop will be made available on-demand within 24 hours after the workshop took place.
OUR SPONSORS
