The Embedded Systems Conference continues to evolve and change with the embedded systems industry. This year, the papers, classes, venues, and events offered at the ESC Boston (September 24 to 24) represent a major shift in focus beyond the various parts of an embedded system–analog and power design, DSP, FPGAs, microcontrollers, multiprocessing, consumer electronics, networks, wireless, sensors, ASICs, C and C++ programming, and so on–to the whole of systems design.
For example, Ron Wilson, executive editor at EDN Magazine, will host a panel session titled “Who's taking over whom: Is EDA moving into embedded or embedded into EDA?” EDA at ESC? Times, they are a changin'.
The widened scope of the conference is also apparent in the product tear downs, where the aim is to deconstruct devices, often from the consumer market, to see their constituent elements and how they were put together into a working system. Two of the tear downs to be presented at the ESC Theater are of the BionX Bicycle Energy Management System and the Pico Projector.
In the regular conference program, several system-oriented tracks that focus on process have been added: design-team management, system-level design issues, and improving productivity at the HW/SW interface.
Classes in these new tracks include “Software development: The next security frontier” (ESC-204, Jim Molini); “Managing embedded projects” (ESC-103, Jack Ganssle); “Agile embedded software development” (ESC-254, James Grenning); “Acquisition of software development expertise through deliberate practice” (ESC-325, Arthur Friedrich); and “How to get the training you need” (ESC-345, Niall Cooling).
All of the meat-and-potatoes classes on programming, debugging, and verification are still there but with a systems-design perspective that acts as the “conceptual backplane” to hold all the diverse elements together. The increasing emphasis on systems in the industry and at the ESC is driven by six fundamental changes in the nature of the embedded systems design environment over the past 20 or so years.
Multicores and SoC s
One of those changes has been the increase in the size and power of embedded processors. Another is the sheer size and capabilities of the circuits, increasingly based not on a single uniprocessor but on multicore system-on-chip designs.
Some of the sessions dealing with the multicore challenge include “Architectural design of software for multicore Systems” (ESC-343, David Kalinsky); “Debugging complex multicore embedded systems” (ESC-364, Robert Oshana); “Multicore and virtualization: embedded synergy” (ESC-422, David Kleidermacher); and “Practical migration of sequential C/C++ code to multicore systems” (ESC-442, Skip Hovesmith).
Dealing with software/hardware systems issues at the SoC level are “Lessons learned from hardware/firmware integration problems” (ESC-304, Gary Stringham); “Developing software prior to silicon using system prototyping” (ESC-342, Frank Schirrmeister and Juergen Jaeger); and “Common hardware mistakes by embedded system designers” (ESC-421, Craig Hillman).
Another change over the years is the increasing role programmable logic technology plays in most designs. On one hand this has forced embedded systems developers to adapt to unfamiliar design methodologies, but on the other it also has forced developers of the FPGAs and PLDs to come up with high-level system design tools that mask the differences and the complexity.
Three classes demonstrate this trend: “Implementing DSP functions within FPGAs” (ESC-445, Ben Harding); “Single and multicore processor design within FPGAs” (ESC-425, Harding); and “Taming your data pipeline execution with an FPGA Linux processor” (ESC-401, Dan Issacs, David Pellerin, and Glenn Steiner).
Another shift has been the increasing connectivity of all embedded devices. With the ubiquitously connected world we live in, gone are the days of embedded devices and systems that were islands unto themselves–closed systems in which there was some hope of building a virtually bug-free application so long as the designers defined the boundary conditions properly.
But now, in the connected environment, most embedded devices are members of loosely or tightly coupled confederations of other systems and devices, either occasionally contacting servers for upgrades or regularly networking with other devices to share resources. This means that, for example, it's necessary to debug and check the code not only on the device under design, but the protocols and connections linking it to other devices.
Excellent examples of this trend at ESC will include “Using Web services with your device” (ESC-321, Steve Kapp); “Securing network communications with OpenSSL” (ESC-303, Kapp); and “Reduce costs with intelligent, distributed wireless sensor networks” (ESC-305, Kurt Williams).
Hardware System Tools
Then there's the development of hardware description languages that enable developers to move between hardware and software design and to make decisions where and how to implement certain critical functions. This trend will be explored in “Model-based design for FPGA development” (ESC-465, Charles Fulks) and “A new approach to post-silicon verification and debug” (ESC-443, Paul Bradley).
System Design Tools
Another fundamental change is the realization that in increasingly complex systems, simply getting the code right is no longer adequate. The software in C/C++ or hardware code in VHDL and Verilog may be absolutely bug free and still not work, because the system for which it was developed may not have been correctly defined.
This has lead to increased attention to high-level system development frameworks such as UML and SysML as well as Agile on the software side and ESL and virtual software environments on the hardware side. Within them, developers can work out the correct systems design parameters and their interactions before developing either the software code or the hardware description in Verilog or VHDL.
At the ESC these issues will be addressed in such classes as “Concurrency architecture in UML” (ESC-464, Bruce Douglass); “Event-driven programming (ESC-404 and 444, Miro Samek); and “The baker's dozen of use cases” (ESC-345, Niall Cooling).
Program, Debug, Test
But for all of the increased emphasis on systems design, at the core of the conference is still the challenge of embedded systems programming, the languages and techniques to get it right, and the tools and methodologies to allow you to debug your designs in the most efficient and cost-effective manner.
Key classes among the 30 or so on these topics include “Writing better C and C++ for embedded systems” (ESC-346, Dan Saks); “Hardware interfacing in C” (ESC-101, Michael Barr); “Undercover C++: What's efficient and what's not” (ESC-366, Stephen Dewhurst); and “How to write reusable device drivers” (ESC-403, Gary Stringham).