In the earliest years of computers in the 1930-40s, computers were sometimes dedicated to a single task, but were far too large and expensive for most kinds of tasks performed by embedded computers of today. Over time however, the concept of programmable controllers evolved from traditional electromechanical sequencers, via solid state devices, to the use of computer technology.

One of the first recognizably modern embedded systems was the Apollo Guidance Computer, developed by Charles Stark Draper at the MIT Instrumentation Laboratory. At the project's inception, the Apollo guidance computer was considered the riskiest item in the Apollo project as it employed the then newly developed monolithic integrated circuits to reduce the size and weight. An early mass-produced embedded system was the Autonetics D-17 guidance computer for the Minuteman missile, released in 1961. It was built from transistor logic and had a hard disk for main memory. When the Minuteman II went into production in 1966, the D-17 was replaced with a new computer that was the first high-volume use of integrated circuits. This program alone reduced prices on quad nand gate ICs from $1000/each to $3/each, permitting their use in commercial products.

Since these early applications in the 1960s, embedded systems have come down in price and there has been a dramatic rise in processing power and functionality. The first microprocessor for example, the Intel 4004 was designed for calculators and other small systems but still required many external memory and support chips. In 1978 National Engineering Manufacturers Association released a "standard" for programmable microcontrollers, including almost any computer-based controllers, such as single board computers, numerical, and event-based controllers.

As the cost of microprocessors and microcontrollers fell it became feasible to replace expensive knob-based analog components such as potentiometers and variable capacitors with up/down buttons or knobs read out by a microprocessor even in some consumer products. By the mid-1980s, most of the common previously external system components had been integrated into the same chip as the processor and this modern form of the microcontroller allowed an even more widespread use, which by the end of the decade were the norm rather than the exception for almost all electronics devices.

What is an Eembedded System?

Embedded Systems are those systems in which a Chip is programmed to perform a certain function. This Chip programming/burning can be done using several languages. These Languages may be C, Assembly, VB, Java etc. but for burning into the Chip mostly micro-controllers, these programs written in High Level Languages (HLL) are to be converted to Hex Code.

8051 is the basic Micro-controller used. Rest all micro-controllers are based upon 8051.

An embedded system is some combination of computer hardware and software, either fixed in capability or programmable, that is specifically designed for a particular kind of application device. Industrial machines, automobiles, medical equipment, cameras, household appliances, airplanes, vending machines, and toys (as well as the more obvious cellular phone and PDA) are among the myriad possible hosts of an embedded system. Embedded systems that are programmable are provided with a programming interface, and embedded systems programming is a specialized occupation.

Embedded Systems has applications in Robotics, Industrial Automation and various latest electronic appliances etc.
Interfacing the micro-controller is very important in Embedded Systems.

How to install a pre-compiled Linux GNU tool-chain for embedded programming

Embedded programming comes with some complexities due to the limitations and specialization of the target hardware. Embedded software is usually installed and executed on small devices like mobile phones, televisions, microwave ovens and other consumer appliances that don't have the resources and power for software engineering. In addition to this many embedded systems use processors with different instruction sets or architectures. The GNU tool-chain is the set of software tools used to build software executables. The tool-chain is compiled and installed for a specific hardware platform like PPC and ARM for example. In this article I explain how to install a pre-compiled GNU tool-chain for developing embedded software for an ARM9 architecture running Linux. Other platforms will have a similar approach to installing the tool-chain software. Using a pre-compiled version of the GNU tool-chain is easier than finding and piecing the tool-chain together yourself. I've done this before while building software, it's very time consuming and should be avoided if possible. You'll avoid the difficulties of searching for sources that will work on your target platform after being compiled and installed. The pre-compiled tool-chain contains the binaries ready to be installed on the host machine.

Step1:
******
Find a tool-chain package for your target board, for instance ARM9,PPC and download the package(s). There are sites on the internet where you can download the GNU tool-chain.Download
____
sites:
*****
http://www.codesourcery.com/gnu_toolchains/arm
http://www.kegel.com/crosstool
http://www.aleph1.co.uk/oldsite/armlinux//docs/toolchain/toolchHOWTO/x43.htm/
Step2:
******
Extract the binaries to the host machine. You can test the extraction in a temp directory. If you feel the need to verify the integrity of the zipped file use the MD5 version.

Step3:
******
After you extract the files you should have a path to your tool-chain that contains GNU tools used for compiling programs for your target board. Create links inside your tool-chain directory to your binaries used by GCC to build target executables. The link names should be the short names used by the GCC. The command on a host machine for an ARM9 target where the tool-chain is located in /usr/local/arm is ln -s /usr/local/bin/arm-linux-gcc /usr/local/arm/bin/gcc. However, this must be done for each tool so, a script would be much more efficient than doing this by hand. I used a BASH script that I wrote, but it could not be included here.

Step4:
******
You must make sure your paths are correct when you compile your programs for your target. When the tool-chain was built it should have been configured to search its install path for the GNU build tools. In this case it was prefix=/usr/local/arm. Use the -Bprefix option if you get an error saying a utility could not be found, for example /usr/local/arm/bin/gcc -v -o test -B/usr/local/arm test.c. -Bprefix tells GCC to look at the path specified after -B for the utilities used for building your executable. The resulting executable will not run on your host machine so, move it to your target and verify that it was built correctly.If you don't have the shared libraries used by your program installed on your embedded board you can use the -static option of GCC. When you use -static the linker program will compile the libraries into your executable instead of searching the library paths for the shared binary. If this is not done and you don't have the shared libraries on your embedded board, your the program will complain about not being able to find the shared libraries. One of the disadvantage of using this option is that your executable will be much larger, but an advantage is that your executable will load faster and run without the shared library. Make sure you modify the build scripts for your source code to use the right tools.

Apple provides powerful tools and robust programming interfaces to move your code to Mac OS X, where you can take full advantage of a stable customer base and dynamic technologies. Mac OS X includes a wide assortment of advanced features and utilities, such as the Aqua user interface, the Quartz graphics system, the Xcode graphical IDE, Interface Builder, and the PackageMaker installation tool. Mac OS X offers powerful functionality in several areas that make porting your applications to the Macintosh easy, including the solid Darwin foundation, a great visual interface, an enhanced file system architecture, free development tools, and convenient packaging and distribution tools. Whether you are porting from UNIX, Windows, or Java, you can turn it into an application with the most usable interface on the planet.

Based on Darwin, which is derived from BSD UNIX, Mac OS X enjoys all the benefits of a robust UNIX system, including protected memory, preemptive multitasking, BSD system services, and a full toolset. In addition, Mac OS X implements many POSIX APIs, which gives you access to a number of powerful UNIX tools and APIs and allows you to call supported POSIX routines from the BSD, Carbon, and Cocoa application environments.

Layered on top of its Darwin foundation, Mac OS X includes a visual interface that users see and use every day. This includes both the elegant Aqua user interface and the Finder, the primary application through which users find and manage directories, applications, and documents.

The Mac OS X file system architecture provides enhanced behavior that builds on its UNIX foundation. File access is governed by the traditional UNIX owner/group/other permissions system. In addition, the file system integrity and security is enhanced through the use of multiple file-system domains, which UNIX groups use to control user permissions on the files based on the domain to which they belong. Furthermore, the Carbon and Cocoa APIs offer powerful file system behavior that you can incorporate in your ported application. For example, you can include the use of aliases to find files when their location has changed, standard file open and save dialogs, and the traditional Mac OS X directory structure that is multiply rooted from individual volumes instead of singly rooted from the root volume.

To speed up your development process, Apple provides the Xcode Tools suite to prototype, compile, debug, and optimize your software. The Xcode application provides a powerful user interface to many industry standard and open source tools, including the GNU Compiler Collection (GCC), javac, jikes, and the GNU Debugger (GDB). Xcode contains templates for creating applications, frameworks, libraries, plug-ins, command-line tools, and Java applications and applets, and supports both Cocoa and Carbon development using C, C++, Objective-C, and Java.

Two of the most important programs in Xcode Tools are Interface Builder, for creating the user interface, and Xcode, for writing, compiling, and debugging your application. Interface Builder shows you exactly where to place interface elements so that they conform to Apple's spacing and placement guidelines found in the Apple Human Interface Guidelines. Xcode creates a nib-based project with a single directory containing all the files associated with your project. This makes it easy for you to back up your project or move it to another location. Xcode also manages build rules and dependency checking, eliminating the need for creating and maintaining a makefile. Your application's executable code and resources are assembled into an application bundle that you can build and deploy immediately by dragging the bundle's single icon to the desired location.

Disk Copy packages your ported application and documentation into a simple disk image, compresses it, and distributes it. A compressed disk image preserves any resource forks, and allows drag-and-drop installation, license display, and even encryption of data. For more complex applications that require administrator privileges or more than a simple drag-and-drop installation, you can use PackageMaker to build installer packages.

Mac OS X supports multiple application environments for developing and porting your applications, including Cocoa, Carbon, Java, and BSD. Cocoa is the best choice when developing a new application; Carbon for porting a Windows-based application or one already implemented in C or C++; BSD for command-line tools and other UNIX programs; and Java for existing Java applications.

To make life easier for UNIX developers, Apple provides a complete X Window System implementation that is compatible, fast, and fully integrated with Mac OS X. X11 for Mac OS X includes a Quartz window manager so that you can provide Aqua title bars and buttons for X11 windows, including fully functional close, minimize to Dock, and maximize buttons. Mac OS X also supports OpenGL, Qt, Tcl/Tk, and a number of other traditional UNIX graphics technologies. If you need to port a command-line utility that uses GNU Autoconf to Mac OS X, the utility usually configures itself, requiring only a small amount of adjustment. Just run configure and make as you would on any other UNIX-based system.

Windows developers will notice similarities between the Carbon and Win32 APIs, which eases the task of porting a Windows-based application. The Carbon framework provides procedural interfaces to Mac OS X functionality. You need to set up a Carbon-based project and user interface using Xcode and Interface Builder, and write an event handler for each control and application-specific menu item in your code. You will also need to rework any application logic that is not ready for cross-platform use such as byte-swapping to maintain cross-platform file compatibility.

Because Java is already installed and configured to work on Mac OS X, Java applications become nearly indistinguishable from native applications. Using the Mac OS X—specific system properties, you can add native behavior with very little work on your part. For example, you can put Swing menus in the Mac OS X menu bar, display a window's resize control or grow box, and display your main windows with the textured Aqua window appearance.

In addition, AppleScript and Apple Events allow you to script actions in your Java applications so you can generate and handle basic events such as Print and Open, choose menu items, click buttons, enter text into text fields, and generally control the GUI of your Java applications. The Jar Bundler tool packages your Java program's files and resources into a single double-clickable file that makes it easy for users to install and uninstall it, simply by dragging the file onto the desktop or off into the Trash.

As a developer on Mac OS X, you have access to many of the development tools and environments that you have on other platforms, like Java, OpenGL, POSIX libraries, and the BSD TCP/IP stack, but you also have built-in benefits like the Cocoa object-oriented development environment, the Quartz PDF-based display system, the Aqua user interface, and a suite of world-class developer tools. By adding a native Mac OS X front end to your application, you can achieve a new deployment platform with minimal additional development effort, ensuring that your application behaves the way that Macintosh users expect.

If you are ready to begin learning about the APIs and tools available for Porting, go to Getting Started With Porting, for a guided introduction and learning path.