Tips and Tricks for Creating a Reliable Embedded System

You must have all heard about "Embedded System". An embedded system is a computer system with a particular defined function within a larger mechanical or electrical system. They control many devices in common use. They consume low power, are of small size and their cost is low per-unit. In this article, we will discuss what an embedded system is and how to create a reliable embedded system with some essential tips and tricks.

What is an Embedded System: An Embedded System is a combination of computer software and hardware designed for a specific function within a larger system. Nowadays Industrial machines, agricultural and process industry devices, automobiles, medical equipment, cameras, household appliances, airplanes, vending machines, and toys, as well as mobile devices, are possible locations for an embedded system.

How an Embedded System Works: An embedded system works by incorporating a rugged computer board into an industrial enclosure with associated I/O (Input and Output) to fulfill a function in an embedded environment. The computing element is an embedded motherboard, which is the feature-packed small form factor, the heart of an embedded system. Specialist I/O such as video capture, communication ports, digital and analog signals are connected into the computing heart for the system to work. An embedded operating system runs on the embedded system allowing application software to utilize the features to provide the required functionality in the embedded environment.

Example of Embedded System: Modern Embedded Systems are based on micro-controllers. Almost every Electronic Gadget around us is an Embedded System, digital watches, MP3 players, Washing Machine, Security System, scanner, printer, a cellular phone, Elevators, ATM, Vendor Machines, GPS, traffic lights, Remote Control, Microwave Oven and many more.

Fig: Basic architecture of an Embedded System

As the embedded systems are here with us in our everyday chores, there is a new challenge for the embedded system developers. It is "How you can build more reliable embedded systems". Keeping in mind that Embedded Systems are all part of a large computer or hardware-software based systems, compatibility, upgradeability, and support can be the biggest concerns.

Below here we present some Tips and Tricks for Creating a reliable Embedded System:

1. Define what is really necessary: An embedded system will only work if the targeted device allows it to do so. At the time of documenting the software requirements for your project, pay special attention to how the client will actually be using the target device that houses the embedded system. This will allow you to select and configure the components that will prove most useful. Since many smaller embedded devices have very limited memory, pinpointing the features that are most important will allow you to make the most of available resources. This approach will enhance the end-user experience with the device in terms of reliability and functionality.

2. Evaluate vendors carefully: Using ready-made hardware and third-party software drivers or apps can save you a huge amount of time and effort when you are developing an embedded system. Instead of reinventing software, you can focus on adapting and customizing your device. However, your end product will only be as reliable as the individual components you choose.

3. Do unit testing carefully: Breaking embedded device code up into its smallest testable units and testing each one individually is arguably the most time-consuming part of the development process. However, it is the piece of the puzzle that delivers the highest value from a reliability standpoint. This is especially critical in complex, real-time systems where debuggers and loggers are more difficult to use. Sift bugs out at the unit level so you don't have to track down what's going wrong later.

4. Be aware of the constraints of PC testing: Running unit tests for an embedded device on a PC can create problems if you don't pay attention to the differences between these two systems. For example, if you are writing in C code, the algorithms may seem fine in the desktop testing environment. But they could be buggy in the final embedded environment if you aren't being completely clear about what integer types you are using.

5. Avoid assembly code: On a low-end PIC you have no choice but to use assembly code and on a high-end ARM you probably don't need to use assembly code, but between these two extremes there are a lot of platforms that use assembly code as a means to increase performance and reduce code size. However, the problem is that simply choosing to use assembly code can derail your project and set you back months.

Though assembly code allows your direct access to the machine's functionality, the performance benefit can easily be overridden by the difficulty in understanding just what is happening in a program. It is for precisely this reason that higher-level languages, like C and Java, were conceived.

6. Documentation: Keep all documentation with the code and, ideally, a copy of the hardware too. When documenting your application, try to put as much of the design and application model directly into the source code. If you have to keep it separate, put it in a source file as a giant comment and link it into the program. At the very least, if you use a version control system (such as CVS or Microsoft Source Safe), check the documentation into the same directory as your source " it is really easy to lose the documentation if it is not located with the source.

7. Write wrappers for system calls: Try to separate low-level I/O routines from the higher-level program logic through interfaces, because a program can be made very difficult to manage by developing at a stretch. Putting all of the functionality of an application into a few large functions makes code difficult to understand and much harder to update and debug. This is especially true with hardware interfaces. You may have direct access to hardware registers or the I/O or even an API provided by the platform's vendor, but there is a lot of motivation to create your own 'wrapper' interface.

8. Break up functionality only as needed: Embedded applications will differ from PC applications in that a lot of the functionality will be specialized to the hardware you are working with. Splitting up functional units into the smallest pieces possible is not advisable - keep the number of function calls in a single scope (function) to less than 5 or 6, and make functional units of the hardware correspond to functional units in the software.

These are some of the most essential tips and tricks for creating a reliable embedded system. Though while creating a reliable embedded system there are much more to care about.

We hope you find this discussion helpful. If you want to learn how to create Embedded System from scratch these are the Best Embedded System Books‚ you can search for.