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.
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.
Does the Future of High-Level Synthesis Belong to Python?
Presented by Jason Pecor
The Python programming language continues to grow in popularity and momentum crossing diverse application boundaries such as web development, data science, artificial intelligence, and - thanks to MicroPython and CircuitPython - micro-controller based embedded systems. More and more engineers are adopting this powerful and flexible language putting it to work for intensive processing use cases.
C and C-based derivatives have traditionally served as the primary language used for high-level FPGA synthesis flows. However, Python is a growing presence in this space. A number of small open source projects such as MyHDL, FuPy and others represent grassroots, bottoms-up efforts to foster the Python and FPGA movement. Meanwhile, major players like Xilinx with their PYNQ platform are clearly embracing Python's place in the programmable logic realm.
As Python gets closer and closer to "the metal", it makes sense to consider the language as a potential successor to C, SystemC, or OpenCL as a preferred FPGA design entry language for high-level synthesis (HLS)based development.
This talk will provide a brief tour though Python's evolution in the world of hardware design and attempt to make a case for Python as tomorrow's HLS language of choice.
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.
Getting Linux To Run On Your Custom Board
Presented by Mohammed Billoo
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.
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.
Implementing a Simultaneous Localization and Mapping (SLAM) system for Robotics/Unmanned Vehicles
Presented by Mike AndersonAs 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.
IoT Hacks: Behind the Scenes
Presented by Joe Hopper
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
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.
Modern Embedded Software Goes Beyond the RTOS
Presented by Miro Samek
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.
Object Classification Techniques using the OpenMV H7 Camera
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.
Operating Systems for Embedded Applications
Presented by Colin WallsMost 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.
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
- 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.
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.
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.)
Test-Driven Development for Embedded Software
Presented by James Grenning
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++.
The 1-Hour Security Bootcamp
Presented by Shawn PrestridgeHow 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.
Unifying DSP, adaptive signal processing, algebra and AI
Presented by Amir KapetanovicUnifying DSP, adaptive signal processing, algebra and AI? The talk will roll out multiple pathways of dealing with issues with the look back at the last 30 years where we started, made progress, arrived to dilemmas, the cross roads, create alternative directions, some of which died, some of which survived, an many which remain untouched and not elaborated. A portrait of the past and portrait of the possible future. There have been many attempts to define the mainstream. The mainstream definition is not so simple - it does not depend of the level of the abstraction but of the level of feasibility measured by many cost penalties often invisible to many. The talk would expose these pathways in the technology provider agnostic way.
What the FAQ is an FPGA
Presented by Clive "Max" Maxfield
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.