Technical Publications
How to Rapidly Create and Customize Compelling GUIs for Android-Based Devices
This paper takes a closer look at one available GUI technology that allows for the rapid creation and radical customization of a GUI in any Android-based device.
As the Android platform gains widespread adoption, it’s incumbent upon device manufacturers and network operators to find compelling and innovative new ways to differentiate one Android-based device from the other. Of course, there are the basic factors that influence the success of a handheld device such as price, functionality, ease-of-use, network carrier, and brand name recognition to name a few. But the device’s graphical user interface (GUI) also has a direct impact on its success or failure. Unfortunately, differentiating a GUI usually requires significant engineering investment and while the Android platform does offer basic GUI functionality, the platform doesn’t go far enough to facilitate a truly unique and one-of-a-kind user experience.
Getting Started With Android Development for Embedded Systems
This paper takes a look at the design of Android, how it works, and how it may be deployed to accelerate the development of a connected device. Along with basic guidelines to getting started with Android, the Android SDK, its available tools and resources are reviewed and some consideration is given to applications for Android beyond conventional mobile handsets such as medical devices, consumer electronics and military/aerospace systems.
How Multicore Enables the Fast and Efficient Deployment of Multi-OS Systems
This paper discusses how multicore designs are creating the need for a true multi-OS system. Within this discussion Symmetric Multi-Processing (SMP), Asymmetric Multi-Processing (AMP), multicore hardware and software, development tools, and actual use cases will be covered.
Multicore is becoming increasingly popular in today’s embedded systems. In order to circumvent the physical limitations of silicon design, stacking up multiple homogenous or heterogeneous processors is often a preferred approach. This is particularly true for many convergent devices that require media-rich graphics, always-on functionality, multi-band connectivity, or extensive processing requirements such as car “infotainment” systems or portable medical devices. In many cases, to facilitate the divergent requirements for subsystems, there is a need for an environment where heterogeneous operating systems can co-exist within multicore systems. For instance, a Real Time Operating System (RTOS) is required to support deterministic real-time behavior (on the data plane) for a communication subsystem, whereas a General Purpose OS (GPOS), such as embedded Linux, is used to run applications on the control plane where very little real-time requirements exist. Such heterogeneous operating system environments demand a system level approach in designing an application.
Effective Embedded Differentiation with Graphical User Interfaces
In today’s competitive embedded markets, manufacturers need to find ways to differentiate without adversely impacting development time and cost. This is particularly true in relation to embedded devices that are designed for use by consumers. As such products become more sophisticated, user interaction via traditional switches, dials, and basic displays becomes less desirable for a number of reasons.
An alternative is to capitalize on recent innovation in the mobile phone space, which has made it possible to deploy inexpensive and high quality LCD and touch screen interfaces. But such innovation is accompanied by expectation: today’s consumers demand a rich ‘smartphone-like’ interactive experience anywhere they find a screen, and products that fall short may ultimately fail.
The challenge, therefore, lies in how to deliver an effective and aesthetically appealing Graphical User Interface (GUI). Making the right decision depends to a large extent on choosing the right software strategy.
This paper discusses the motivations for and potential benefits of switching to LCD-based interfaces, and goes on to describe the challenges facing anyone attempting to deliver a great embedded GUI. This paper concludes with a checklist of things to look for when assessing the merits of the various off-the-shelf GUI software solutions available today.
The Promise of M2M: How Pervasive Connected Machines Are Fueling the Next Wireless Revolution
As people and devices with electronic systems become more inter-connected, machine-to-machine (M2M) technology is poised to become a powerful force in the 21st century. There are billions of electronic devices in the world today that are well-suited to take advantage of M2M technology. These devices range from security surveillance cameras casting a watchful eye on the street below, handheld medical devices that scan and transmit vital data to a healthcare professional miles away, to smart home appliances such as refrigerators, stove tops, climate control systems, etc. that add safety, convenience, and comfort to the home. There is an abundance of electronic devices waiting to benefit from M2M technology with enhanced productivity and performance for businesses and users alike.
This paper defines the concept of M2M, cites examples on how M2M is being implemented in various businesses/industries, and discusses how some of the partners in M2M are beginning to offer innovative solutions.
Microtec C/C++ Compiler Toolkit for PowerPC
Embedded developers need a set of compiler tools that can take high-level languages such as C, C++, or assembly language, and produce reliable code for their embedded target. These development tools should also offer flexibility in code optimizations for space and fast execution speeds. And finally, developers today require a complete set of compiler tools that reliably produce executable binaries.
The Microtec C/C++ compiler toolkit for PowerPC is a complete cross-compiler solution that includes a compiler, assembler, and linker – all designed exclusively for building today’s advanced embedded applications. This paper discusses the many advantages of the Microtec C/C++ compiler toolkit, which has been developed to deliver capabilities far beyond traditional compilers.
Simtest Simulation: A Powerful Tool for Embedded Software Development
Embedded software is no longer written in assembly language macros. In fact, the same high-level languages and tools used for writing embedded software are the same tools used for designing application software of non-embedded computers. However, embedded software is still decidedly different from non-embedded application software. With embedded software, the constraints are tighter and the requirements are stricter. This dichotomy has produced two different simulation methodologies: the traditional hardware-related simulation that consists of a target-based development; and host-based simulation which is quickly becoming the preferred method within the embedded community. This paper discusses host-based simulation and introduces two new tools that utilize this type of technology.
Prevention is Better Than the Cure: Compiler Run-Time Error Checking
Compilers are generally thought of as being tools that convert a high level language, like C or C++, into assembler or machine code. Of course, they do perform this function, but have the potential to do much more. Code may be generated by a compiler, or be extracted from its run-time library, which adds to the functionality of the user-written code in order to detect run-time errors and take appropriate action. This is useful in any software development context, but for embedded systems, where a fail-safe error control system is often required, this compiler functionality is essential. This paper reviews a number of the error detecting and trapping techniques that are available and discusses how these techniques are implemented in modern compilers. The availability of such functionality in embedded compilers on the market today is also reviewed.
Advantages of Host Simulation Over Other Types of Embedded Software Simulators
During the last decade, embedded software’s nature in devices has changed radically. As devices have taken on increasingly more functionality, the complexity of higher level software has grown accordingly. Today’s devices employ high-performance hardware such as accelerators and multi-core architectures, which in turn, enable more sophisticated software applications to cater to growing customer demands and using hardware drivers that come out-of-the-box. This quantum leap in software complexity, combined with ever tightening development schedules, requires more advanced software development tools and a new approach to embedded software development.
In this paper, the differences between three different types simulators are examined. All three simulation approaches are viable and the decision to choose one over the other depends not only on the requirements burdened upon the software, but also on the needs embedded device manufacturers are facing today.
User Interface and Graphics Development for Embedded Systems
The drastic fall in price and refinement in technology has resulted in graphical displays becoming ubiquitous – from tiny screens on basic cell phones to large, high definition flat-screen TVs. While one type of display may only present information, other displays actually facilitate user interaction, such as the popular touch-screen technology now seen on a variety of devices. Regardless of complexity all graphical displays have one thing in common, software is required to control them.
This paper discusses various cost-effective methods to build and control a full range of graphical displays using the very latest in software. Basic widget-based UIs to the more sophisticated graphical 3D interfaces are covered.
Delivering Rich and Customizable User Interfaces for Multimedia-Enabled Products
In today’s increasingly competitive consumer device markets, multimedia-enabled products must offer a user interface (UI) that is both visually compelling and easy to use. But changing an embedded UI can often require a lot of time and work. By taking a new approach to the UI problem as a whole, software developers can seriously reduce the amount of effort involved in making changes to a device’s interface throughout the product development life cycle, without adversely impacting time to market