Question of the Week: How do you define embedded system?

Wednesday, April 21st, 2010 by Robert Cravotta

[Editor's Note: This was originally posted on the Embedded Master

I have always noticed a discontinuity in how people use the term embedded system. I commented on how the lack of distinction between application and embedded software might be driving us towards a skill and tools crisis because of material differences between the two types of development. My programming background began with application and system level skills. I designed and wrote my share of automation applications, many of which are still in production use more than twenty years later. I also developed system skills by developing and maintaining assemblers, compilers, and interpreters.

Eventually I found my way into the embedded world. I would say it took me at least a year to adjust to the new things I had to consider in my designs. Embedded development involved working with real world physics including understanding noise, error, and filtering. I had to learn about hysteresis, rigid-body vibrations, and how temperature and humidity can change how things operate.

I also had to come to terms with the fact that the things I worked on as an embedded developer were invisible to the end user – and everyone else for that matter. The tongue-in-cheek extreme example I use to illustrate what is an embedded system involves implementing a function with hamsters – as long as the end user does not need to know of their existence, care, feeding, healthcare, and eventual replacement needs – then it is an embedded system.

I recognize that some people might think this a harshly limited definition of an embedded system, but I learned that the amount of memory a system has, the size of the package, the power consumption, and the cost of the system is relative. If you use those types of metrics to declare something an embedded system, you have a problem because those thresholds shift all the time. My hamster description does not change over time.

Based on the comments I am seeing in multiple online conversations, I think there are a few categories of embedded system in use. Please share how you define an embedded system. Maybe instead of agreeing to disagree, we can discover some defining characteristics between each category that can yield some meaningful insight into the different skill and development tool needs of each type of developer.

52 Responses to “Question of the Week: How do you define embedded system?”

  1. H. @EM says:

    I have worked on systems with as little as 8k bytes of program memory and systems with as much as a gigabyte; full graphic user interfaces and not even a push button.

    I think the definition I would use is that the hardware and software, once combined, are permanently dedicated to the application, and that the application (for the end user) never appears as “some program I run on a computer” but instead something they just use for some task.

    I know that covers a lot of ground technology wise (including hamsters), but from an end users point of view, if it doesn’t “just work” then it’s broken.

  2. D.W. @EM says:

    I like the distinction between application systems (targeted software systems – e.g. accounting package) and embedded systems (software is invisible, e.g. DVD player controller). After thinking a bit, I would add a further distinction in embedded systems: monitoring versus control.
    .
    A monitoring system provides an interface between humans and a machine or process that runs by itself, e.g. a microwave oven controller. The embedded system allows the human to start, stop, adjust and monitor the machine or process. Monitoring systems, being human oriented are soft-real-time, meaning that its operations are best effort (humans will wait) and at human speeds of ~1 Hz.
    .
    Embedded monitoring systems mostly use a task oriented processing model, meaning that a human initiates some task and the system does it to competion while the human waits for it to be done. Think microwave oven.
    .
    A control system is an integral part of a machine or process. The combination of machine and embedded control generate the performance value of the whole system, e.g. an automobile engine controller. The power and fuel economy of the engine is the result of the integrated mechanical and electronic design system. Control systems are machine oriented and are typically hard-real-time, meaning guaranteed, deterministic response times (machines typically cannot wait) at machine speeds of 100 Hz or faster.
    .
    Embedded control systems use a (machine) stream processing model, meaning that the system continuously processes an incoming data stream to produce an output data stream. Think DSP and MP3 player.

    If you do not like “monitoring versus control”, perhaps “human versus machine” would work as descriptors.

  3. D.W. @EM says:

    A post script, created the instant after hitting the “send” button, the email disease.

    Many embedded systems have both components of monitoring and control, where monitoring is the human “front panel” for the real-time machine control portion. Still, the two subsystems are quite different, with different requirements.
    .
    Like many, I have found that using separate processors for monitoring and control can give you better interface functions as well as higher performance and reliability.
    .
    Monitoring functions, being human oriented, look a lot like conventional computing. One approach is to use a web page as the human interface. So monitoring functions can benefit from conventional CPUs with large memory, caches, graphics, TCP/IP etc.
    .
    Control functions, being machine oriented, benefit from specialized CPUs with low latency, high performance processing. Typical features include sophisticated interrupt systems and DSP oriented high speed processing.

  4. E.M. @EM says:

    Most of the confusion in the definition of an embedded system comes from the fact that none/few makes distinction between “small embedded” and “large embedded”. Also many forget that a RTOS is NOT ‘real’ in many respects and typically “small embedded” would suffer from the use of one such whereas “large embedded” would suffer from the abscence of one such.

    E.m.

  5. R.B. @LI says:

    Hi Robert,

    It’s always difficult to explain to “non insiders” what I’m doing for a living.
    Embedded Systems Software Specialist? What’s that?

    It reminds me a bit on the joke with the small boy who was asked at school: “What’s the job of his father.” He answered:”He is piano player in a ‘house of pleasure’”. The teacher invited the father to come to school, since (s)he didn’t believe the small boy. The father answered:”I’m an Embedded Systems Software Specialist, but since most people don’t understand what this means I just say I’m playing piano in a ‘house of pleasure’. Everyone knows what that is.”

    Regards,

    R.

  6. M. @EM says:

    How to learn the basic of embedded system if a person has a limited knowledge of the assembly language and C++ program under tight financial condition.

    Thanks your advise.

  7. A. @EM says:

    Fundamentally, an embedded system is one designed to perform a particular task without user knowledge of how it works nor on what sort or mix of hardware/firmware.

    If the (non-technical) user knows it’s a computer, it’s not an embedded application. (The “non-technical” caveat is necessary because we EE-geek types understand there’s a computer in darned near everything these days.)

    The user interface isn’t really part of the debate although a fancy GUI will tend to make even non-technical users think there’s a computer behind the curtain somewhere.

    Apropos the question about how to learn about embedded systems, well, start dissecting things and figuring out what sorts of controls work. Skip the c++ and drop back to plain old ‘c’ and (better yet) assembly language. Understand the guts of the microcontrollers you plan on using, especially their more esoteric and fun-to-apply specialized I/O subsystems, interrupts, timing controls. etc. Then pick an application and start beating on it until you have something that works.

  8. M.W. @EM says:

    *H. got it right. If a product wakes up and knows exactly what it is and how it is to operate, then it is an embedded device. If a product wakes up and needs to be told what it is going to be doing then it is an open device.

    So, in the morning, an MCU controlled coffee maker is an embedded device. That laptop is an open device as it has to wait to see what application you want it do this time — is it a word processor, a video player, or a game station this time?

    There is a narrowing of the mote between these categories as things get more capable, so it isn’t always black and white. But this is the basic starting point.

  9. D.R. @LI says:

    It seems like this is a very contentious issue. I think the reality today is that there is a huge variety of devices that contain CPUs. On one extreme are small micro-controller based systems that have a single very specific purpose and no direct user interface (most of the computers in your car, for example). On the other extreme are fully programmable general purpose computers (a PC or server). Most systems are fit somewhere in-between. The reality is that most devices have lots of attributes that are “more embedded” or “less embedded”. A device could have a very minimalist “embedded” user-interface, but have a “less embedded” type of implementation with a fully-featured operating system and other complex pieces of software.

    I don’t think there’s any point in trying to devise a simple binary categorization system by which everything is either “embedded” or “not embedded”. I know that annoys people who are trying to sell books or training courses which would benefit from a more simplified world view, but I think it’s the way things are.

  10. S.N. @LI says:

    When asked what I do for a living I would say I was into computers
    hoping they would just nod and not ask more questions.
    Of course, everyone would start saying desktops,
    servers, laptops, etc. I would then tell them I do computing where you
    don’t see the PC which would cause a puzzled look. Then I would have to give real world examples they would know like electronic gambling game machines or automated store check out or airline check-in. Then they would say they think they understand. Recently I found some marketing people use a word I liked.
    Calling our field “pervasive” computing. That kind of summed up using
    computers everywhere instead of the actual computer only as a sole
    general purpose appliance.

  11. P.B. @EM says:

    I see an embedded system as a computing function (data input/output, communication, storage and processing), implemented by the appropriate hardware/software mix, integrated into any device that performs a specific task.

  12. J.P. @EM says:

    Another way to put it is that application platforms of today are embedded platforms of tommorrow, both performance and toolset wise.
    Embedded systems seem to be more constraint limited but this is also not definitive rule.
    In that sense I would not rule out C++, it is more the matter of understanding it’s raison d’etre, what is not merely obscuring ordinary c code.
    In embedded platfrom the stability is more of an issue than with application software where frequently license agreement frees devoloper of all responsibilities and allows subject of change without notice.
    Finally application software can in most cases be replaced by user to alternative provider. Embedded solution (as of today)is more tightly linked to original design entity.
    Is Iphone embedded device?

  13. J.M. @LI says:

    ‘EMBEDDED SOFTWARE’ is software running inside a device, where the user might not even be aware it is using a computer (as opposed to sitting in front of a screen/keyboard/mouse). People think “MS Excel or Internet Explorer” when they think software. Very few people are aware that their flat screen TV has software running in it.
    When designing electronic devices, many function were historically implemented electronically (e.g. a power supply) with discrete and integrated components. Since the emergence of cheap little microcontrollers (thank you Apollo), a lot of these functions can also be implemented with a microcontroller and the function can be modified much more flexible and have a lot more smarts to them. ‘embedded software’ (sometimes also referred to as ‘firmware’) typically runs on the ‘bareboard’ (i.e. no OS) so the programmer needs to do a lot more stuff to get it running. An intimate knowledge of the microprocessor architecture is usually a must. You have to know about register settings, interrupts, timers, memory initialization, … In a lot of cases is the function of these embedded software to ‘drive’ something else (e.g. a motor or a heater) or to take input from an electronic components like a sensor. Usually by converting the analog signal to a digital value and then process that low level signal to extract some useful information from it. In both cases, you need an intimate understanding of the physical processes that go around. For long, using a higher level programming language wasn’t even possible and was assembly the only possibility. Now C and some C++ seem to be the standard (still way behind the PC world that is now using C#, Python, Java, …)

    So it isn’t enough to just know how to program, you also have to know the processing platform your software is running on and the peripherals attached to your processor. So you need a good understanding of electronics and the physics governing your application.

    Over the years, embedded computing platforms have become powerful. An ARM processor based system now matches the power of a desktop PC 10, 15 years ago.

    With increasing demands and more powerful platforms, developers had the option to adopt some of the things that was only possible for PC-based developers. API’s turned into separate layers of hardware-specific device drivers and RTOS started to become available. Stil not exactly the same as DOS/Windows/UNIX, but getting there.

    Then with the advent of Linux becoming better, and hardware becoming cheaper and more powerful, it became possible to actually ‘embed’ a full-blown computer in your device. Adapting the OS to your platform (the Board Support Package) still requires much of the skills described above, but once that is working, all software developed for such a system does not differ that much from software for PC-based Linux systems (also applies to Windows CE). E.g. on a traditional bareboard embedded system, implementing serial communication implied intimate knowledge of the UART device and invloves a lot of register manipulation. Now on an OS (like Linux) reading and writing data on a serial link is as simple as reading and writing it to a ‘file’. The device driver takes care of the rest.

  14. J.M. @LI says:

    So many people now think that embedded development is about Linux development but that isn’t completely true.

    Small devices (e.g. a power supply controller) with a single simple function can be implemented on an 8-bit processor (e.g. AVR) running at a couple megahertz. These rarely have an RTOS and are simply bareboard and implemented in C.
    More complicated devices that have multiple functions (e.g. a device that monitors a sensor and communicates over a link in a certain protocol and need to handle some user interface like buttons and displays) might require higher-end processor like 16-bit MSP430 running at 16 .. 25MHz.

    A level higher is for complicated, multi-function applications that require high throughput are typically put on 32-bit processors (and now even 64-bit). These processors are actually powerful enough to install an OS like Linux, Windows CE or even XP. Once you can do that, you can hire software developers that are not necessarily experienced embedded software developers. Another reason for selecting an OS is if you need complicated device drivers like Ethernet and TCP/IP drivers, or you need complicated user interface or a file system. All these are provided out of the box with an OS and warrant the expense of adding a computationally expensive layer. You do not want to develop all that stuff all over again.

    But sometimes, a projects uses an OS on their system for the wrong reasons. These are projects that don’t need all that stuff and the reason for using the OS is driven by the ‘cool’ factor instead of necessity. In that case you are adding at least $200 per unit. That might be OK if you only need a handfull of them. In that case it makes sense because devloping software for these is much simpler. But if you need bulk production, then any dollar you can save constitutes big savings. In that case, you ask yourself: do I really need an OS?

  15. M.P. @LI says:

    Hi Robert,

    Good question, for me an embedded system tends to be a device that has a fixed function with some level of real time control.

    Embedded systems can be implemented in many ways from 8Bit micro’s to 32bit/64Bit CPU running an OS (Linux/QNX), it all depends on the requirements of the end product.

    My company does lots of embedded development using low end 8Bit Micro’s. We undertake lots of projects that require real world interfacing which has a physics requirement. My current experience tends to suggest that recruiting for this is difficult and there are lot’s more application engineers available but they have little understanding of real time processing.

  16. A.K. @LI says:

    An embedded system can be defined as tightly coupled hardware and software integrated to form a computing environment designed to perform a dedicated task.
    It is also worthwhile to note the differences between general purpose computers and embedded systems. On the one hand a general purpose computer can perform any task provided you install an application that makes performing this task available to the user on the other hand an embedded device is dedicated to a predefined task or tasks it needs to perform. While general purpose computers, for example personal computers, be it desktop workstations or laptops and notebooks, conform to a certain standard and are essentially the same, while embedded devices are not standard at all, these are specific for task, environment and required performance. On general purpose computers, development of software can be performed on the same computer, embedded systems are not suitable for software development and development of embedded software is performed on general purpose workstations. Last but not least, general purpose computers are resources rich and expandable embedded systems are constrained and mostly not flexible for expansion in any way.

  17. M.T. @LI says:

    Interesting question. Some 20 years ago I got that question defending my dissertation (mostly about high performance embedded systems). The main opponent (a senior Intel Processor Architect) asked. Mr. Taveniku, what is an embedded system? Well, needless to say I had not really thought about that question. I had every aspect of my defense thought out, not quite this one. Anyway, long story short, I think it got the entire dissertation committee engaged in the discussion, my answer wasn’t quite on target either.

    After a few beers, a good dinner and many ideas from the CS, CE departments and industry we, I think unanimously concluded that an embedded system is simply a system that contains a “computer” (hardware, firmware, and software) who’s function (purpose in life) is not to be a computer.

    Today, 20 years later, I think the boundaries between an embedded system and a computer system, is getting blurred. Certainly, my iPhone or Droid, is by definition an embedded device, but they both do a very similar job as my Lap Top or desktop computer. They are (were?) primarily phones, but are now general computing devices that can run relatively speaking any app out there. In fact, from my point of view, I probably spend more time using things other than the phone applications on my phone these days. At the same thing, my company uses IP-phones and Skype so I use my laptop as a phone on a daily basis. — still there is a difference?

    On one extreme, I worked on small devices in the sensor network area with an 8051 micro, no OS, multiple sensors, and a radio certainly an embedded system and a very particular set of skills required to work with them.
    On the other extreme, I worked on a couple of systems for our friends at the DoD side one with over 900 processors and another with some 300 processors, a full operating system on each processor node, and a completely different set of skills required by the embedded systems engineers. These systems were definitely embedded, it had nothing to do with general purpose computing, rather solving a specific problem in real-time.

    Maybe (I think so) the community need to develop a finer grain taxonomy for embedded systems, where we take into account the multi-faceted and broad area of embedded computing, dividing it into smaller areas. Certainly knowing how to squeeze code into the poor 8051 helps (a little) when working on the 300+ CPU embedded supercomputer, but in reality the skill sets required are just very different.

  18. T.N. @LI says:

    These are all great answers and shows that the word “embedded” is probably used more loosely than we would like. I wouldn’t try to define an embedded system here as you guys have done a great job; in my business we supply and refer to embedded processors and boards.

    A key factor in supplying an embedded solution (to my customers at least) is defining one that will be available for some time. Using processors only from the embedded groups of CPU manufacturers such as INTEL will guarantee the availability of key components for 5 and in some cases 7 years. This enables us to specify boards and solutions that we can support for at least those 5 years.

    You can design your system and deploy it knowing that for the next 5 years you are going to be able to maintain it without being concerned with changing major components.

    So perhaps one interpretation of an embedded system is one who’s design is not expected to change for some time….

  19. S.V. @LI says:

    Great Input everybody.

    I would define an Embedded system as the following:
    1. A system with Hardware components like Micro controllers, I/O, Memory etc.
    2. A main application software performing certain functions, predefined tasks etc.
    3. An RT-OS /Embedded OS which is an interface between Hardware and Application Software.

  20. M.T. @LI says:

    Interesting comments: Here is a couple of questions;
    Is the radar and image processor on our favorite Global Hawk aircraft considered an embedded system?
    Is the signal processor on a CT (computed tomography) scanner part of an embedded system?
    Is the processing on my iPhone or blackberry embedded?
    Is the application on my Garmin forerunner embedded?
    Or why not the operations on my Harmony remote control?
    Or why not one of the corporate PBX system running Asterisk?

    I personally would tend to answer yes on all of the above…
    They are certainly not general purpose computers, and they do have a purpose other than a computer, — maybe the blackberry/iPhone should be considered general purpose computing devices (since they conform to the user interaction, user installation of general purpose programs, and can be programmed by the user, disqualifying them from the “embedded concept).
    ** what I mean by that is that the user is actually directly exposed to the fact that the unit is a programmable computer for which the user has control **

    Looking into the boxes on these platforms, we run Linux on our favorite bird, depending on the CT macine we have both Windows-XP and Linux as teh base operating system on the machines for the signal processing (some FPGA processing too) while the display systems run Windows (full versions).
    In the case of our asterisk PBX, well the “appliances” definitely run Linux, on a standard PC.
    My son’s PS3 runs linux, our DVR is really a PC, running Windows.. and so on.

    – All of these systems are certainly “embedded” none of them runs a RT-OS, well the Garmin device is the exception in this bunch.

    Now, I do think there is much merit to the definition of RT-OS, Hardware/Software Interface, resource constraints, real-time execution, longevity, etc. but it seems this is necessarily a subclass of embedded systems.

  21. B.W. @LI says:

    Embedded engineering is defined by Embedded application.

    Embedded application is any system consisting of software and/or hardware that follows a program of functions without necessarily involving direct human interaction.

  22. K. @EM says:

    I will put the embedded system and non-embedded system for their target applications. An embedded system does to a large extent predefined applications, with atleast soft real time expectations.

  23. B.A. @LI says:

    I think the main feature that defines an embedded system is the (dedicated task) feature regardless of everything else (hardware, software, architecture, includes an OS or not).

    S.: I dont agree with your second definition, because such application software running on a PC wont represent an embedded system.

    M.: I’d answer yes to all of your questions too. But, many single task devices nowadays are getting equipped with more and more features,
    like a TV that is capable of recording on a USB stick, or a cell phone with a camera and programability features. Still I would define those as
    embedded systems, simply because they are ment to perform a single main task, not general purpose, as you wont buy a cell phone if you need a camera ..etc.

  24. T.D. @LI says:

    Given the wide scope of “embedded” as a term, I think we need to invent some new terminology, if only to make the connecting of employer to employee that much easier (given the use of the web for job searches).

  25. J.M. @LI says:

    When I talk to people about ‘embedded system’ they work on in reference to the skills needed, I usually ask about: microprocessor, programming language, whether it uses an (RT)OS or not and if so, which.
    Those are to me the 3 main parameters that allow me to characterize the project.

    Next to that, you can use some characteristics that describe the type of work like: consumer/industrial/military grade, mission/safety-critical, level of availability, fault-tolerance, communication-intensive, ruggedness, unit volume, unit price, user-interaction, package-size, longevity, ….

  26. J.M. @LI says:

    Another way of categorizing is the type of skills needed by the software engineer:
    Some embedded system are connected to some analog device (motor or sensor) and require signal processing skills
    Other embedded systems are more data-driven and communication-intensive.

  27. J.M. @LI says:

    Device Driver development implies register manipulation for interfacing with an underlying device.
    This can mean different things: in an 8-bit application, you can consider the whole application a device driver.
    Additional complexities occur when the application is multi-threaded (e.g. under an RTOS).
    Another complexity when developing device drivers for full-blown OS’s like Windows and Linux.

  28. R.A. @LI says:

    #define EMBEDDEDSYSTEM 1

    Since space is not a legal character for identifiers in ‘C’.

    Other options are:

    #define EMBEDDED_SYSTEM 1

    or

    #define _EMBEDDED_SYSTEM 1

  29. G.R. @LI says:

    How about a simple definition – embedded system is a small computer embedded in a physical device.

  30. K.F. @LI says:

    Since this is really only an opinion question, I have no problem with most of what has been said. My own personal opinion is that it has nothing to do with “size” of the device or the resources of the device. Most of the time it is the application of the device that can determine its embedded nature.

    My definition (much like B. W. commented above):

    An embedded system is an autonomous system that operates without the need for human control and intervention.

    Consider these three examples: a pump controller, a cell phone, and carrier class network switch. All of these are embedded systems. The pump controller may only have a PIC and tiny resources. The cell phone has a decent CPU and memory and a user interface. The carrier class network switch may a server class CPU, a GB of RAM, and a GB of storage. Still each of these constitutes an embedded system that operates autonomously.

  31. J.C. @LI says:

    Gentlemen, I’d like to direct your attention of the Oxford Reference ‘Dictionary of Computing’, 1984 edition.
    “Embedded computer: any computer used as a component in a device whose prime function is not that of a computer. One example is a weapons-guidance system. ….. “
    “Real-time system: any system in which the time at which output is produced is significant. ….”
    Put the two together and you have the definition, clearly, precisely and accurately, of a real-time embedded system.

  32. K.P. @LI says:

    An “Embedded System” is a system that comprises both hardware and software– ie., the system has a computer in it; and where the system addresses a single problem domain.

    The BIOS in your desktop PC is considered an “embedded system”, but once the OS is installed and running, a desktop PC is no longer classified as an embedded system– it is now a “general purpose computer”. Note that a PC can be “embedded” into a device that (physically) addresses a single problem domain, and an OS can be installed, with an application running on that OS that addresses a single problem domain– (for example, a kiosk at a shopping mall that helps you to find what you are looking for)– and this is indeed an “embedded system”, because in this case the PC is not accessible to the end user– they cannot (normally) install some application on the PC as it is installed, to get the PC to perform some other function.

    This is key to the use of the word “embedded”– the device must have some type of programmable computer; and the fact that the device has a computer in it is not always obvious to the casual end-user of the device.

    On the extreme end of this definition are smart-phones– these are really general purpose computers that are portable and compact– many of them allow the end-user to install software to perform some function that the original designers of the device did not anticipate. Some would argue that these are an “embedded system”, because you can find a few people that don’t know it has a computer in it– but I disagree– these are known to the general population of users to have computers in them; and if the end-user can install application software, then they are not “embedded systems”.

    On the other extreme, we have FPGA’s. These are certainly programmable, but unless they have either a soft-processor [CPU] or a hard-core CPU in them, then they are *NOT* an “embedded system”– and they would be just “hardware” in that case.

    As far as the people required to engineer these systems– on one extreme, you have an engineer that is an expert in both hardware and software– someone that is comfortable with writing low-level driver code that senses and controls the hardware directly– these are called “Embedded Systems Engineers”, and because they have a deep understanding of both hardware and software they are more rare (and thus demand higher salaries) than a (more or less common) applications-level programmer. If you have an embedded system where a real “Embedded Systems Engineer” has already written the low-level code that controls the hardware; and this code presents to applications programmers an API (application programming interface), then you no longer need the services of the “Embedded Systems Engineer”, and may now hire a standard “applications programmer” that is less expensive. Note that, just because an applications programmer (that doesn’t understand hardware) is writing code for an embedded device (using the API calls that were provided to them)– that activity does *NOT* magically make them an “Embedded Systems Engineer”– maybe if you stretch the definition as far as you can go, they could call themselves an “Embedded Systems Programmer”, but that would imply that they have a great deal of understanding of interrupt routines, the proper use of the keyword “volatile” in C, and (possibly) familiarity with concurrent programming techniques– including RTOS’s (as used on larger embedded systems.)

    As horrible as it is, (and like it or not), ‘C’ is the defacto “lingua franca” of embedded systems. Someone that is going to claim that they are an “Embedded Systems Engineer” or an “Embedded Systems Programmer” will need to be an expert-class ‘C’ programmer, and they should also be very comfortable with working in Assembler language. These are the things I look for when I am interviewing engineers for my embedded systems projects. If they are only familiar with C++, Java, or C#, then they will not be hired.

  33. K.F. @LI says:

    A counter-point about mobile phones. Mobile phones incorporate one or more processors in them, a variety of custom hardware peripherals, constrained resources, and a non-trivial amount of driver work. Additionally, significant effort goes into making the phone operate without the user’s intervention for weeks on end, as long as there is power. It is the work of the middle-ware stacks and application frameworks that make it possible for user’s to load “managed applications” onto them. The device expects and is designed to support customer loaded apps. But that does not preclude the “embedded device” from its description.

    Using the argument presented by K. from above, because a user can load applications on it, any “upgradeable” field device and game consoles would also be knocked out of the embedded space simply because the users of the device could add functionality not originally provided for. But I disagree with that position.

    But I think K. actually illustrated the subtle uniqueness of many modern devices: they have an embedded nature, and an application nature. So quite a few consumer electronics with CPUs are ultimately this kind of hybrid device.

    One more point. Whether or not an average user “knows” there is a CPU in a device or not is irrelevant to the discussion. Most people know their cars have computers in them and many of them can be after-market mod’ed. But I hold the position that automotive computers are also embedded devices. General user knowledge is irrelevant to the matter.

  34. M.W. @LI says:

    Agree with J./Oxford Dictionary. Embedded != real-time. Embedded means purposed, for example a cell phone is an embedded system that is not realtime. To me embedded without realtime = boring.

  35. C.H. @LI says:

    Here’s a first stab at how I would define an embedded system. Please bear in mind that this is a 5 minute thought process and I’d like to think more about it:

    1) A computation engine not used for or capable of being used for general user computing when it is in the embedded configuration (e.g. Word, Excel, etc).
    2) Some of the attributes that many embedded systems have, but are not strictly required are:
    a) No keyboard
    b) No Mouse
    c) No Monitor
    d) No way for “user” to access base operating system
    e) Single purpose device (e.g. atm machine – this does have a “keyboard” like device and a monitor, but cannot be used for general purpose computing).
    f) Interfaces with users via non-standard (i.e. not keyboard/mouse/monitor) peripherals – e.g. Easy Pass toll system
    h) Hardened to exist under extreme conditions (e.g. temperature, shock, vibration)
    i) Uses non-standard CPU board (i.e. not an ATX, etc style). One example would be a small PC-104, EBX, EPIC, etc.
    j) Runs operating system other than Windows/Linux/MacOS (e.g. no-OS or some type of RTOS)
    k) Used for some type of real-time computing (e.g. data acquisition, navigation, etc).
    l) Comes with a “controller” that is a “standard” computer running a GUI that communicates with the “embedded” system somehow.
    m) Real time applications – I would argue that they are all “embedded” applications since any attempt to allow a user access to a real time system could seriously jeopardize the realtimeness (how’s that for a new word!) of a system.
    n) User may not even realize there’s a processor there (ok, ok, I know – many “users” don’t realize there’s a CPU in a normal computer either… sigh) :^)

    Before anyone jumps on me about #1, when I say “not capable of”, I don’t mean that it can’t be used that way at any point in time, only that as the item is packaged for the embedded application, there is not a standard keyboard/mouse/monitor/gui that would allow a user to have easy access to the computer. For example, I can build a PC-104 stack and put it into a small enclosure with no socket for monitor or keyboard, but I could indeed open that enclosure and plug those peripherals in.

    So, what do you think?

  36. J.M. @LI says:

    About mr C.’s defintion: not all realtime systems are embedded (e.g. a ground control system). Not all embedded systems need to be realtime (e.g. a thermostat).

    You could argue that an embedded system is one that comprises of hardware and preloaded with dedicated software to deal with a well-defined (subset of) task(s). This in contrast to general-purpose PC’s and servers that can be used for pretty much anything.

    The question comes on how to categorize cell-phone/PDA’s. As a cell-phone, these devices can be categorized as an embedded system according to my definition above, but once you allow users to load pretty much any application on these things, they start overlapping with general-purpose PC’s with which they share a fair amount of common treats (OS, keyboard, external storage, display, gneral-purpose SW, gigabytes of memory…).

  37. D.C. @LI says:

    A great discussion, I just could not add anything not mentioned already.

    If I had to point out just one distinct characteristics of embedded systems, I guess I would say it is the way they interact with their environment. Same goes for embedded systems developers, much skill is needed regarding to interfacing to the outside world, and those skills are getting harder to find as there are less developers with EE know how. Programming skill alone does not get you far enough in embedded world.

    Thank you Robert for starting this thread :-)

  38. M.Y. @LI says:

    It’s a great question and I would like to have a concise answer I can give to people when I get that blank stare. To me, the key is the word “embedded”. It is a computer system jammed inside something whose primary function is not computing.

    M.

  39. C.H. @LI says:

    J., The one big differentiation between the cell-phone/PDA and what I would consider a “general purpose” computer would be the display. On a general purpose computer, I expect to be able to have multiple applications up at once including things like Word, Excel, Firefox, etc, and be able to cut/paste between them – back and forth without having to open/close apps all the time. The display on the iPhone is only 480×320. I suppose this isn’t bad – it’s 1/2 of standard VGA (640×480), but certainly nowhere near what we’ve become used to (my laptop is 1920×1200).

    Years ago there was monochrome, then CGA, EGA, and finally VGA. Today, even VGA at 640×480 seems ridiculously small. My laptop runs 1920×1200 and when it is sitting at home, I run it along with a 2nd monitor (24″) of the same resolution to get more desktop space giving me 15x more space than a single VGA display. To me, 15x is quite an improvement.

    I also believe these smaller devices are pretty much “one app at a time” (I’m sure I’ll be corrected if I’m mistaken), but one of the biggest distinction as I pointed out above would be the very limited display and another one would be the inability to plug in what I would consider “standard peripherals” (keyboard, mouse, printer/fax/scanner/copier, USB sticks, cameras (via USB port), etc.

    A third differentiator might be storage space. Today even the smallest of computers has 320 or 500 gig of hard disk space while the iPhone utilizes a 16gb/32gb flash drive more commonly used for digital cameras, mp3 players/etc. although admittedly, some of the mp3 players actually have hard disks in them with 80/120/etc gb of disk space.

    Finally, another item that is at least iPhone specific (since the iPhone was mentioned specifically), there are adapters (docking station) that allow the device to be connected to a “computer” (i.e. a general purpose computer) for “charging, syncing, and more” (taken directly from Apple web pages). While in many ways the iPhone has the potential to be more, it really is a mainstream cell phone/mp3/video player and simply does not have the cpu horsepower to displace even an introductory general purpose computer.

    C.

  40. F.G. @LI says:

    Many of these definitions are overly restrictive. While C/C++ is very popular for embedded it is by no means a requirement for embedded. My first embedded jobs had me doing 68K and z80 assembler. (That’s when men were men!). What about people developing java for set-top boxes?

    It also has nothing to do with real time. BTW real time does not infer fast or speedy it just means deterministic time responsiveness. So an old fashioned mercury switch thermostat is sort of a real time system since it will respond in a predictable amount of time to a change in stimulus.

    In the old days Windows 3.x was a non-preemptive operating system and thus incapable of running “real time” applications. Now Windows is preemptive and protected mode but you still would not dream of running an important process on it unattended.

    To me the name embedded has always seemed odd and purposefully vague. The only thing you are suggesting by prefacing system with embedded is that something is “under the covers” or hidden in the system. What is it that’s hidden, of course it’s the computer.

    As R. said the technical definitions fall by the wayside as technology progresses. The key to unraveling this riddle is the users perspective. Does the user think they are operating a general purpose computer or not? Did the manufacturer provide the user enough autonomy that they can use the device in surprising ways?

    In the Iphone example users routinely install applications that Apple may or may not have ever contemplated users wanting to run. This is a defacto definition for general purpose computing. I would argue that embedded
    systems are all computer systems that are not considered general purpose by their users.

  41. R.W. @LI says:

    I don’t believe there is any one concise definition that everyone can agree on for an embedded system. In a recent op-ed piece in the RTC Magazine (for embedded computing), authors McCracken & Rosenfeld point out differences in two major categories of embedded computers based on the underlying chip/ operating system. The article is entitled “A Tale of Two Embeddeds”.

    The first class is x86 based computing with Windows OS, and this is currently being taken over by Linux.

    The second class are the RISC based cores using the OSs such as VxWorks, QNX, Integrity, Nucleus, Thread-X, etc. This second class can be more easily adapted to real-time (“deterministic”) computing. They require additional tools such as BSPs (Board Support Packages) and JTAG ICEs.

    This article can be found at URL:

    http://rtcmagazine.com/articles/view/101581#

  42. K.B. @LI says:

    The definition I always use with lay people is: If you are using a device which has a computer in it, but you don’t think you are using a computer, you are using an embedded system. I think that settles the divide on PDA’s and mobile phones nicely – by focusing on the user. Some people look at them like a computing platform and manage the software loaded on it in great detail. Most people, though, just look at them as phones with fancy features.

  43. M.T. @LI says:

    K.: I kind of like your definition. Essentially you are saying that an “embedded system” is a subjective definition depending on the “users” perception of it.

    That is interesting from the point of view of classification, since now the bucket a particular system falls under is dependent on the users perception and/or the designers intent of the same. This would definitely decouple and untangle the discussions based on hardware and software platforms and types of engineers designing the systems etc. and we would have a relatively simple definition of what constitutes an embedded system. Simply; an embedded (computing(er)) system is a system who’s designers intent or users perception of it is not that of a computer.

    Now if we take that as a starting point we could dive into the different kinds of embedded systems and work our way down to something that would make sense from a “work” perspective. Say for example terms like “deeply embedded” or small resource constrained embedded systems, display-less systems, user interactive systems etc…

  44. E.D.J. @LI says:

    There are lots of computer systems that embedded in the sense that the users don’t see it or access it or perhaps even know it’s there — but the computer system is a multiprocessor or multicomputer supercomputer class system. Most of the ones I am familiar with are military systems — e.g., the ground controllers for missile systems, the ground and airborne controllers for AESA radars, etc. All invisible to the users while pumping out teraflops and consuming megawatts of power.

    These mega-embedded systems have something in common with traditional micro-embedded systems: the need for the computer system hardware and software designers to have a deep understanding of the application hardware (e.g., the missile or radar) and environment.

  45. R.F. @LI says:

    I would use a 3 layered definition:
    - System: set of symbolic objects representing a subset of objects (physical or documental) dealt with by the business under consideration.
    -Real-time system: a system for which whatever happens in the targeted (real) context must be immediately recorded within the system, ie, nothing relevant is supposed to happen between those events and their representation. It means that those events can’t be captured through symbolic interfaces (which are mediating and therefore take time), yet that doesn’t exclude symbolic interfaces if used for other purposes.
    -Embedded system: real-time system without any other access except the real ones.

    http://caminao.wordpress.com/what-is-to-be-represented/activities/real-time-activities/

  46. SKV @LI says:

    IMO, Embedded System is a combination of specialized h/w and firmware which is designed for a dedicated functionality (Eg: A simple electronic mirror control unit of a Vehicle to a complex Radar control system) and they pocess certain set of unique characteristics and quality attributes.

    It is not necessary that all embedded systems should contain an Operating System (Either RTOS or customized OS). It all depends on the nature, complexity and response requirement of the functions intented to fullfill by the embedded system. An embedded System can be one with a simple superloop control (All tasks executed repetedly in sequence in a single loop) or one with a Real Time Operating System like VxWorks, Windows CE, etc.. which implements different scheduling policies for task execution to provide real time response.

    The demarcation between embedded computing and general purpose computing is shrinking with advent of latest h/w, processor and memory technologies. Embedded Systems were very constarined in terms of memory, processing, I/O capabilities etc in the olden days. Mobile handests are a typical examples for embedded devices which extends the general computing capabilities to the embedded space… :)

  47. J.F @ LI says:

    Embedded systems are a class of applications where functionality requires both the hardware, and software/firmware to accomplish its objective.

    Embedded systems are characterized by functionality, not choice of Operating systems, nor language, nor development technique.

    A system is embedded if we don’t care about the software or the hardware but rather the totality.

  48. B.G. @ LI says:

    My basic definition is simple: would your grandmother think the unit is a computer?

    If the answer is yes, you probably have a very sophisticated grandmother :^). However, the answer is almost certainly no – consider the humble hotel doorknob. Only an embedded guy knows it is an embedded system. If it does not look like a tower PC or laptop, the vast majority is clueless there is some smarts in the thing – including their cell phone.

    Try this experiment: ask folks what percentage of microprocessors made every year end up in laptop and PCs – most will say 95% or greater (ignore the ‘microcontroller’ label because it doesn’t matter for the test, and some folks ‘know’ there is such a thing as ‘embedded systems’, although they are clueless about specifics). The real answer, as we know, is 0.5% to 2%, depending on the source and year.

    @Shibu: While I agree with your general definition, I have to take issue with one minor point: WinCE is not an RTOS. There is nothing “real-time” about it – ‘soft’ time is being generous. My favorite RTOSs, BTW, are uCos and ThreadX.

  49. SKV @ LI says:

    Hi Bandit,
    I’m not sure about which version of the WinCE Embedded OS (Removing the RT for the time being) you are refering. I have been working on the 4.2.NET version to the latest 7.0. The version CE 6.0 onwards is recognized as Hard Real Time as per the definition of ‘hard real-time’ by the Open, Modular, Architecture Control (OMAC) user group. Read the complete story @ the msdn site http://msdn.microsoft.com/en-us/windowsembedded/ce/aa714541.aspx and http://blogs.msdn.com/b/mikehall/archive/2009/04/23/ce-6-0-hard-real-time-embedded-o-s-here-s-the-proof.aspx

  50. R.L. @ LI says:

    Looks like I’m wayyy late to this discussion, but …

    The simplest (and, I think, best) definition I know is that an embedded system is anything that comes up running when you turn on the power. The sorts of systems mentioned here so far certainly fit the definition, and I have worked on plenty of such systems.

    But I can also point to a SCADA system I worked on. It was hosted on a Dell dual-Xeon rackmount, running Windows Server 2003. The software was implemented as an autostart system service – to run the system, the only user interaction required was to turn on the power.

    Does it qualify as ‘embedded’? I think it does. Your opinions?

  51. SKV @ LI says:

    Embedded Systems are application and domain specific. ie. An embedded system designed to serve a particular requirement for a particular domain cannot be replaced with another one designed for another requirement for another domain. As an example, the embedded control unit of a Washing machine, which serves the consumer electronics segment cannot be replaced by an ECU designed for the automotive industry.

    SCADA systems definitely fall under Embedded System as long as they are implemented with dedicated hardware which has a unique set of I/O interfaces (say sensors and actuators at dedicated ports, with designated memory maps etc) with the approprite control algotithm (P, PI, PD, PID, ON-OFF etc) embedded in the unit.

    The above SCADA example you sited uses a ‘General Computing’ system tailored for a specific function. It uses a genaeral purpose hardware with a general purpose computing operating System. You can easily replace the hardware with a similar configuration general purpose computer as well as another operating system. Also you can use the same hardware for running another applications. In this case the SCADA application is running as a ‘soft’ware on top of a GPOS. It is not a ‘firm’ware. It is no way different from a ‘General Computing’ workstation/PC. The characteristics of embedded systems like application and domain specific hardware, uniquenes etc are not valid for this system. Another typical example is a POS machie running a general computing OS with generic PC h/w.

    Embedded Computing Systems are way different from ‘General Computing Systems’ in terms of memory, processing capabilities, power consumption, operating conditions, response requirements etc….

  52. R.F. @ LI says:

    Whereas those definitions are correct, they are mostly descriptive. In other words they don’t support clear cut decisions for any given project.

Leave a Reply