In previous years, I've covered a number of the embedded run-time environments that are affected by these trends. Now I turn my attention toward Integrated Development Environments (IDEs) and how the evolution of embedded systems development, processes, standards, and application areas like the Internet of Things (IoT) and DIY have affected the IDE realm.

Virtualization and multiple environments impact

Device consolidation implies developing for multiple software environments. On one hand, the real-time environment is likely to be C/C++ based (perhaps even assembly). On the other hand, the application environment may be a mix of C++ or Java with higher-level graphics or networking libraries. Providing a solid, consistent, unified IDE for the development of these mixed environments can be very challenging.

The Eclipse Foundation (www.eclipse.org), which had its roots as an open source IDE framework, got its start focusing on Java development. The "CDT" or C/C++ Development Tool project was close on the heels as the second Eclipse language tooling project after Java.

Eclipse is an open, free community with more than 250 projects where plug-ins for multiple environments are available for its IDE framework. Almost every embedded software tool and processor vendor at the 2014 EE Live! conference mentioned terms "Eclipse-based" or "available as an Eclipse plug-in" for their development product, so there is significant support among the embedded development community and many plug-ins available.

Java is especially being used in embedded IoT and M2M applications. Java ME, for example, was conceived and promoted as a mobile solution and within the Maker community. Mike Milinkovich, Executive Director of the Foundation, mentions that these platforms all run Java quite happily, but was quick to point out that the start-up times might be a bit much depending on the application. Java is also making increased connections with the operating system below where next-generation Java native interfaces are being defined. The Java 8 SE profiles support headless operation more easily so graphics contexts are not necessary. It's interesting to note that while Java is typically known for graphics, headless operation within the embedded space isn't uncommon.

IAR Systems (www.iar.com) has long been a supplier of embedded tools and celebrated their 30th anniversary in 2013. Unlike the Eclipse Foundation, IAR's roots have been in C/C++ and assembly development tools and debuggers, and, perhaps most notably, their capable optimizing C/C++ compilers. The IAR corporate strategy involves wide support for a large number of processor architectures and MCUs within those architectures. The strength of wide processor support provides flexibility for their customers to move processor architectures if their products need to.

The IAR Embedded Workbench has been incrementally updated over the past 20 years. They recognize the flexibility of IDE frameworks and offer their compilers and debuggers as Eclipse plug-ins. While the IAR Embedded Workbench doesn’t directly support Java, Thomas Sporrong, Global Sales Engineering Manager, said that many Java stakeholders are partnering with IAR to facilitate the Java/C++ bridges necessary to glue together today’s embedded environment.

"Developing Java Native Interfaces (JNI) is a hot topic in today's embedded space," Sporrong says. "IAR is active in collaborating with Java stakeholders, silicon vendors, and our own tools and compilers to address this area."

Sporrong agrees that Java development, most notably in the GUI software area, is on the rise in embedded, and tools and native interfaces to the embedded C/C++ environment are important.

In addition, IAR offers an in-circuit debugging probe called I-jet that integrates with the IAR Embedded Workbench with plug-and-play compatibility with the environment. The I-scope adds current and voltage measurement capabilities to I-jet. Finally, the JTAGjet probe provides real-time in-circuit debugging for trace, test, and verification of embedded applications.

From coding to debugging and validation, today's embedded virtualized environments are definitely impacting the capabilities of these IDEs.

Multicore processor impact

Device consolidation and running multiple environments requires multiple independently running core processors for true separation between real-time processing and the embedded application GUI, processing, and connectivity functions.

In addition to the coding of the solution, multicore processors dramatically increase the complexity of debugging. Truly asynchronous processor cores may be used separately for asymmetric multiprocessing applications or grouped to increase performance for symmetric multiprocessing. When an application runs across multiple cores, it's vitally important that debuggers are "multicore aware" – providing the ability to set breakpoints, and simultaneously stop all cores or a subset of cores. Stepping through and diagnosing problems is challenging if the problem only occurs when specific code blocks with dependencies execute separately on different cores, creating race conditions due to a missing synchronization element, for example.

The Eclipse Foundation and their ecosystem of embedded IDE vendors have been working on this for a long time. A multicore working group has been in existence for many years and multiprocessor code display of cores in the debug view, resource usage, core interactions, and loading across cores in addition to the breakpoint and code-stepping capabilities above are all things that seem to be well represented in embedded IDEs using the Eclipse Framework. Milinkovich mentioned at the recent EclipseCon conference they demonstrated a multicore environment working with the Adapteva Parallela board, which includes a dual-core ARMv7 and 16-core Epiphany multicore coprocessor.

IAR launched their latest multicore-capable debugger at embedded world 2014. Their customers have been working on multicore designs for a number of years and this launch represents the features needed for effective execution of those projects. Capabilities include synchronization between cores, "stop world," start individual cores, or any combination in between. Sporrong mentions that this launch was very successful, but work is still continuing to provide additional advances and capabilities for multicore since it has become the norm as opposed to the exception for embedded development projects.

DIY and IoT impact

Anyone who's been following embedded development over the past few years shouldn’t be surprised by the fact that embedded virtualization and multicore processing support is being addressed across the board in embedded IDEs. However, one thing that did surprise me is the sheer number of projects and focus the Eclipse Foundation has in the DIY and IoT spaces. Milinkovich says the IoT community is focused on protocols, services, and frameworks around these boards and devices. And while we were speaking, Mike mentioned he literally had two Raspberry Pis and an Arduino running Eclipse software on his desk at that moment! The Eclipse DIY/IoT community (iot.eclipse.org) has publically available sandbox servers that allow developers to try a number of the different protocols being implemented at Eclipse such as MQTT, CoAP, and LWM2M. Even stepping outside of the Eclipse moniker, Milinkovich says a completely new tooling platform is being worked on within the Eclipse community called Orion (www.orionhub.org) – an open source platform for cloud based development – where developers can link up a Raspberry Pi or Arduino from their phones, laptops, whatever, and develop code.

Of the current 250 Eclipse projects, many of them are related to or valuable for IoT development. Milinkovich says that when people talk about IoT, they underestimate the amount of training and understanding that's needed in order to create a properly functioning embedded device (as opposed to desktop or web application), especially in IoT software where developers likely do not have a background in embedded. Over the next decade, Milinkovich believes there are going to be a significant number of platforms that will emerge and Eclipse projects created that will make developing IoT easier than ever before.

"Mobile was once considered a branch of embedded," Milinkovich says. "But the tools and frameworks available today for people building smartphone applications have dramatically simplified what the developer needs to do, and reduced the learning curve for new developers. We predict that a similar trajectory will occur in IoT over the next few years."

IAR’s mantra is "focus on your code" and their take on DIY is a bit different. Sporrong says the IAR Embedded Workbench is widely used for IoT building blocks such as communications platforms supporting wireless connectivity like Wi-Fi, ZigBee, and Bluetooth from vendors such as Texas Instruments, Silicon Labs, Qualcomm, and others. IAR has a list of bundled starter kits available that includes the workbench, debug probe, and evaluation board along with sample projects to provide a complete out-of-the-box solution to get started with a particular MCU family (www.iar.com/Products/Starter-kits-debug-probes).

Industry regulatory standards impact

Depending on the embedded industry segment, quality standards and regulatory compliance may also be involved, and development environments are getting into the standards assurance and requirements validation realm.

IBM Rational products (www.ibm.com/software/rational) are an example of IDEs that start with requirements development and tracking, and include an element of process control and standards compliance. In a recent OpenSystems Media E-cast (ecast.opensystemsmedia.com/462), IBM Rational described the functional safety workflow and process templates used within the Rational environment to achieve compliance with the ISO26262 automotive functional safety standard. The templates within their IDE provide a separate safety management section, and define main phases for compliance and their applicable practices. From this global template, depending on the project or team focus, the templates can be tailored to the phases needed for that project.

The evolving future of IDEs

IDEs have been extended into the applications and industries they support. While the IDE framework is generic, these environments have and are continuing to advance to provide more capabilities and features involving increased software support and compilers for specific processor architectures, DIY board connectivity and development, and standards compliance for specific embedded industry segments.

For more information, contact Curt at [email protected].