SOFTWARE ANALYSIS

4.1 EMBEDDED C

Embedded C is a set of language extensions for the C Programming

language by the C Standards committee to address commonality issues that exist
between C extensions for different embedded systems. Historically, embedded
C programming requires nonstandard extensions to the C language in order to
support exotic features such as fixed-point arithmetic, multiple distinct memory
banks, and basic I/O operations.

In 2008, the C Standards Committee extended the C language to address

these issues by providing a common standard for all implementations to adhere
to. It includes a number of features not available in normal C, such as, fixed-
point arithmetic, named address spaces, and basic I/O hardware addressing.

Embedded C uses most of the syntax and semantics of standard C, e.g.,

main() function, variable definition, datatype declaration, conditional statements
(if, switch, case), loops (while, for), functions, arrays and strings, structures and
union, bit operations, macros, etc.

A Technical Report was published in 2004 and a second revision in 2006.

4.1.1 NECESSITY
During infancy years of microprocessor based systems, programs were
developed using assemblers and fused into the EPROMs. There used to be no
mechanism to find what the program was doing.
LEDs, switches, etc. were used to check for correct execution of the program.
Some ‘very fortunate’ developers had In-circuit Simulators (ICEs), but they
were too costly and were not quite reliable as well. As time progressed, use of
microprocessor-specific assembly-only as the programming language reduced
and embedded systems moved onto C as the embedded programming language
of choice.
C is the most widely used programming language for embedded
processors/controllers. Assembly is also used but mainly to implement those
portions of the code where very high timing accuracy, code size efficiency, etc.
are prime requirements.
As assembly language programs are specific to a processor, assembly
language didn’t offer portability across systems. To overcome this
disadvantage, several high level languages, including C, came up. Some other
languages like PLM, Modula-2, Pascal, etc. also came but couldn’t find wide
acceptance. Amongst those, C got wide acceptance for not only embedded
systems, but also for desktop applications. Even though C might have lost its
sheen as mainstream language for general purpose applications, it still is having
a strong-hold in embedded programming.
Due to the wide acceptance of C in the embedded systems, various kinds
of support tools like compilers & cross-compilers, ICE, etc. came up and all this
facilitated development of embedded systems using C. Assembly language
seems to be an obvious choice for programming embedded devices. However,
use of assembly language is restricted to developing efficient codes in terms of
size and speed.
Also, assembly codes lead to higher software development costs and
code portability is not there. Developing small codes are not much of a problem,
but large programs/projects become increasingly difficult to manage in
assembly language. Finding good assembly programmers has also become
difficult nowadays. Hence high level languages are preferred for embedded
systems programming.

4.1.2 ADVANTAGES
  It is small and simpler to learn, understand, program and debug.
 Compared to assembly language, C code written is more reliable and
scalable, more portable between different platforms.
 C compilers are available for almost all embedded devices in use today,
and there is a large pool of experienced C programmers.
 Unlike assembly, C has advantage of processor-independence and is not
specific to any particular microprocessor/microcontroller or any system.
This makes it convenient for a user to develop programs that can run on
most of the systems.
 As C combines functionality of assembly language and features of high
level languages, C is treated as a ‘middle-level computer language’ or
‘high level assembly language’.
 It is fairly efficient.
 It supports access to I/O and provides ease of management of large
embedded projects.
 Java is also used in many embedded systems but Java programs require
the Java Virtual Machine (JVM), which consumes a lot of resources.
Hence it is not used for smaller embedded devices.
 Other High-level programming language like Pascal, FORTRAN also
provide some of the advantages.

4.1.3 EMBEDDED SYSTEMS PROGRAMMING

Embedded systems programming is different from developing

applications on a desktop computers. Key characteristics of an embedded
system, when compared to PCs, are as follows:

 Embedded devices have resource constraints(limited ROM, limited

RAM, limited stack space, less processing power)
  Components used in embedded system and PCs are different; embedded
systems typically uses smaller, less power consuming
components. · Embedded systems are more tied to the hardware.

Two salient features of Embedded Programming are code speed and code
size. Code speed is governed by the processing power, timing constraints,
whereas code size is governed by available program memory and use of
programming language. Goal of embedded system programming is to get
maximum features in minimum space and minimum time.

Embedded systems are programmed using different type of languages:

 Machine Code
 Low level language, i.e., assembly
 High level language like C, C++, Java, Ada, etc.
 Application level language like Visual Basic, scripts, Access, etc.

Assembly language maps mnemonic words with the binary machine

codes that the processor uses to code the instructions. Assembly language seems
to be an obvious choice for programming embedded devices. However, use of
assembly language is restricted to developing efficient codes in terms of size
and speed. Also, assembly codes lead to higher software development costs and
code portability is not there. Developing small codes are not much of a problem,
but large programs/projects become increasingly difficult to manage in
assembly language. Finding good assembly programmers has also become
difficult nowadays. Hence high level languages are preferred for embedded
systems programming.

Use of C in embedded systems is driven by following advantages

 It is small and reasonably simpler to learn, understand, program and debug.
 C Compilers are available for almost all embedded devices in use today, and
there is a large pool of experienced C programmers.
 Unlike assembly, C has advantage of processor-independence and is not
specific to any particular microprocessor/ microcontroller or any system.
This makes it convenient for a user to develop programs that can run on
most of the systems.
 As C combines functionality of assembly language and features of high
level languages, C is treated as a ‘middle-level computer language’ or ‘high
level assembly language’
 It is fairly efficient
 It supports access to I/O and provides ease of management of large
embedded projects.

Many of these advantages are offered by other languages also, but what
sets C apart from others like Pascal, FORTRAN, etc. is the fact that it is a
middle level language; it provides direct hardware control without sacrificing
benefits of high level languages.

Compared to other high level languages, C offers more flexibility because

C is relatively small, structured language; it supports low-level bit-wise data
manipulation.

Compared to assembly language, C Code written is more reliable and

scalable, more portable between different platforms (with some changes).
Moreover, programs developed in C are much easier to understand, maintain
and debug. Also, as they can be developed more quickly, codes written in C
offers better productivity. C is based on the philosophy ‘programmers know
what they are doing’; only the intentions are to be stated explicitly.

It is easier to write good code in C & convert it to an efficient assembly

code (using high quality compilers) rather than writing an efficient code in
assembly itself. Benefits of assembly language programming over C are
negligible when we compare the ease with which C programs are developed by
programmers.

Objected oriented language, C++ is not apt for developing efficient

programs in resource constrained environments like embedded devices. Virtual
functions & exception handling of C++ are some specific features that are not
efficient in terms of space and speed in embedded systems. Sometimes C++ is
used only with very few features, very much as C.

And, also an object-oriented language, is different than C++. Originally

designed by the U.S. DOD, it didn’t gain popularity despite being accepted as
an international standard twice (Ada83 and Ada95). However, Ada language
has many features that would simplify embedded software development.

Java is another language used for embedded systems programming. It

primarily finds usage in high-end mobile phones as it offers portability across
systems and is also useful for browsing applications. Java programs require Java
Virtual Machine (JVM), which consume lot of resources. Hence it is not used
for smaller embedded devices.
 Dynamic C and B# are some proprietary languages which are also being
used in embedded applications.

Efficient embedded C programs must be kept small and efficient; they

must be optimized for code speed and code size. Good understanding of
processor architecture embedded C programming and debugging tools facilitate
this.

4.1.4 DIFFERENCE BETWEEN C AND EMBEDDED C

Though C and embedded C appear different and are used in different

contexts, they have more similarities than the differences. Most of the
constructs are same; the difference lies in their applications.

C is used for desktop computers, while embedded C is for microcontroller

based applications. Accordingly, C has the luxury to use resources of a desktop
PC like memory, OS, etc. While programming on desktop systems, we need not
bother about memory. However, embedded C has to use with the limited
resources (RAM, ROM, I/Os) on an embedded processor. Thus, program code
must fit into the available program memory. If code exceeds the limit, the
system is likely to crash.

Compilers for C (ANSI C) typically generate OS dependant

executables. Embedded C requires compilers to create files to be downloaded to
the microcontrollers/microprocessors where it needs to run. Embedded
compilers give access to all resources which is not provided in compilers for
desktop computer applications.
 Embedded systems often have the real-time constraints, which is usually
not there with desktop computer applications.

Embedded systems often do not have a console, which is available in case

of desktop applications.

So, what basically is different while programming with embedded C is

the mindset; for embedded applications, we need to optimally use the resources,
make the program code efficient, and satisfy real time constraints, if any. All
this is done using the basic constructs, syntaxes, and function libraries of ‘C’.

4.2 PROTUES:

Proteus (PROcessor for TExt Easy to USe) is a fully functional,

procedural programming language created in 1998 by Simone Zanella. Proteus
incorporates many functions derived from several other
languages: C, BASIC, Assembly, Clipper/dBase; it is especially versatile in
dealing with strings, having hundreds of dedicated functions; this makes it one
of the richest languages for text manipulation.

Proteus owes its name to a Greek god of the sea (Proteus), who took care
of Neptune's crowd and gave responses; he was renowned for being able to
transform himself, assuming different shapes. Transforming data from one form
to another is the main usage of this language.

4.2.1 INTRODUCTION
Proteus was initially created as a multiplatform (DOS, Windows, Unix)
system utility, to manipulate text and binary files and to create CGI scripts. The
language was later focused on Windows, by adding hundreds of specialized
functions for: network and serial communication, database interrogation, system
service creation, console applications, keyboard emulation, ISAPI scripting
(for IIS). Most of these additional functions are only available in the Windows
flavor of the interpreter, even though a Linux version is still available.

Proteus was designed to be practical (easy to use, efficient, complete), readable

and consistent.
 Its strongest points are:
 powerful string manipulation;
 comprehensibility of Proteus scripts;
 availability of advanced data structures: arrays, queues (single or
double), stacks, bit maps, sets, AVL trees.
 The language can be extended by adding user functions written in Proteus
or DLLs created in C/C++.

4.2.2 LANGUAGE FEATURES

At first sight, Proteus may appear similar to Basic because of its straight syntax,
but similarities are limited to the surface:
 Proteus has a fully functional, procedural approach;
 variables are un typed, do not need to be declared, can be local or public
and can be passed by value or by reference;
 all the typical control structures are available (if-then-else; for-next;
while-loop; repeat-until; switch-case);
 new functions can be defined and used as native functions.

Data types supported by Proteus are only three: integer numbers, floating
point numbers and strings. Access to advanced data structures (files, arrays,
queues, stacks, AVL trees, sets and so on) takes place by using handles, i.e.
integer numbers returned by item creation functions.

Type declaration is unnecessary: variable type is determined by the

function applied – Proteus converts on the fly every variable when needed and
holds previous data renderings, to avoid performance degradation caused by
repeated conversions.
There is no need to add parenthesis in expressions to determine the
evaluation order, because the language is fully functional (there are no
operators).

Proteus includes hundreds of functions for:

 accessing file system;
 sorting data;
 manipulating dates and strings;
 interacting with the user (console functions)
 Calculating logical and mathematical expressions.
 Proteus supports associative arrays (called sets) and AVL trees, which are
very useful and powerful to quickly sort and lookup values.

Two types of regular expressions are supported:
 extended (Unix like);
 basic (Dos like, having just the wildcards "?" and "*").

Both types of expressions can be used to parse and compare data.

The functional approach and the extensive library of built-in functions allow to
write very short but powerful scripts; to keep them comprehensible, medium-
length keywords were adopted.
The user, besides writing new high-level functions in Proteus, can add new
functions in C/C++ by following the guidelines and using the templates
available in the software development kit; the new functions can be invoked
exactly the same way as the predefined ones, passing expressions by value or
variables by reference.
Proteus is an interpreted language: programs are loaded into memory, pre-
compiled and run; since the number of built-in functions is large, execution
speed is usually very good and often comparable to that of compiled programs.
One of the most interesting features of Proteus is the possibility of running
scripts as services or ISAPI scripts.
Running a Proteus script as a service, started as soon as the operating system
has finished loading, gives many advantages:
 No user needs to login to start the script;
 A service can be run with different privileges so that it cannot be stopped
by a user.
This is very useful to protect critical processes in industrial environments (data
collection, device monitoring), or to avoid that the operator inadvertently closes
a utility (keyboard emulation).
The ISAPI version of Proteus can be used to create scripts run through Internet
Information Services and is equipped with specific functions to cooperate with
the web server.
For intellectual property protection Proteus provides:
 Script encryption;
 Digital signature of the scripts, by using the development key (which is
unique);
 The option to enable or disable the execution of a script (or part of it) by
using the key of the customer.
Proteus is appreciated because it is relatively easy to write short, powerful and
comprehensible scripts; the large numbers of built-in functions, together with
the examples in the manual keep low the learning curve.
The development environment includes a source code editor with syntax
highlighting and a context-sensitive guide. Proteus does not need to be installed:
the interpreter is a single executable (below 400 Kb) that does not require
additional DLLs to be run on recent Windows systems.

4.2.3 SYNOPSIS AND LICENSING

The main features of this language are:
 fully functional, procedural language;
 multi-language support: Proteus is available in several languages
(keywords and messages);
 no data types: all variables can be used as integer numbers, floating point
numbers or strings; variables are interpreted according to the functions
being applied – Proteus keeps different representations of their values
between calls, to decrease execution time in case of frequent conversions
between one type and the other;
 no pre-allocated structures: all data used by Proteus are dynamically
allocated at execution time; there are no limits on: recursion, maximum
data size, number of variables, etc.;
 no operators: Proteus is a completely functional language – there are no
operators; thus, there is no ambiguity when evaluating expressions and
parenthesis are not needed;
 large library of predefined functions: Proteus is not a toy-language, it
comes with hundreds of library functions ready to be used for working on
strings, dates, numbers, for sorting, searching and so on;
 advanced data access (DAO), pipes, Windows sockets, serial ports: in the
Windows version, Proteus includes hundreds of system calls which are
operating system-specific;
 clear and comprehensible syntax: the names of the library functions
resamble those of corresponding functions in C, Clipper/Flagship and
Assembly; by using medium-length keywords, Proteus programs are very
easy to understand;
 native support for high-level data structures: arrays, queues (single or
double), stacks, bit maps, sets, AVL trees are already available in Proteus
and do not require additional code or libraries to be used;
 ISAPI DLL and Windows Service versions: Proteus is available as a
Windows service or as an ISAPI DLL (for using together with Microsoft
Internet Information Server);
 user libraries: it is possible to write user defined functions (UDF) in
separate files, and include them (even conditionally and recursively)
inside new programs; UDFs can be referenced before or after the
definition; it is also possible to write external functions in Visual C++
and invoke them from a Proteus script;
 native support for Ms-Dos/Windows, Macintosh and Unix text files (all
versions);
 three models for dates (English, American, Japanese), with functions to
check them and to do calculations according to gregorian calendar;
 epoch setting for 2-digit-year dates;
 support for time in 12 and 24 hour format;
 support for simple (Dos-like) and extended (Unix-like) regular
expressions, in all versions;
 intellectual property protection, by using digital signature and
cryptography;
  extensive library of functions to write interactive console programs.
 Proteus is available in demo version (script execution limited to three
minutes) and registered version, protected by a USB dongle. At the
moment, is available as a Windows or Ubuntu package and is distributed
by SZP.

4.2.4 EXAMPLE PROGRAMS

Hello World
The following example prints out "Hello world!".
CONSOLELN "Hello World!"
Extract two fields
The following example reads the standard input (CSV format, separator ";") and
prints out the first two fields separated by "|":
CONSOLELN TOKEN(L, 1, ";") "|" TOKEN(L, 2, ";")
Proteus scripts by default work on an input file and write to an output file; the
predefined identifier L gets the value of every line in input. The function
TOKEN returns the requested item of the string; the third parameter represents
the delimiter. String concatenation is implicit.
The same program can be written in this way:
H = TOKNEW(L, ";")
CONSOLELN TOKGET(H, 1) "|" TOKGET(H, 2)
TOKFREE(H)
In this case, we used another function (TOKGET), which builds the list of the
tokens in the line; this is more efficient if we need to access several items in the
string.

4.3 8051- C51 C Compiler

 The Keil C51 C Compiler for the 8051 microcontroller is the most popular
8051 C compiler in the world. It provides more features than any other 8051 C
compiler available today. The C51 Compiler allows you to write 8051
microcontroller applications in C that, once compiled, have the efficiency and
speed of assembly language. Language extensions in the C51 Compiler give
you full access to all resources of the 8051.

The C51 Compiler translates C source files into re locatable object modules
which contain full symbolic information for debugging with the µVision
Debugger or an in-circuit emulator. In addition to the object file, the compiler
generates a listing file which may optionally include symbol table and cross
reference information.

4.3.1 Features

 Nine basic data types, including 32-bit IEEE floating-point,

 Flexible variable allocation with bit, data, bdata, idata, xdata, and pdata
memory types,
 Interrupt functions may be written in C,
 Full use of the 8051 register banks,
 Complete symbol and type information for source-level debugging,
 Use of AJMP and ACALL instructions,
 Bit-addressable data objects,
 Built-in interface for the RTX51 Real-Time Kernel,
 Support for dual data pointers on Atmel, AMD, Cypress, Dallas
Semiconductor, Infineon, Philips, and Triscend microcontrollers,
 Support for the Philips 8xC750, 8xC751, and 8xC752 limited instruction
sets,
 Support for the Infineon 80C517 arithmetic unit.
4.3.2 Development Tool Overview

The following chart shows the Keil development tools and how they
interface to each other.

Keil development tools for the 8051 Microcontroller Architecture support

every level of software developer from the professional applications engineer to
the student just learning about embedded software development.
The industry-standard Keil C Compilers, Macro Assemblers, Debuggers,
Real-time Kernels, Single-board Computers, and Emulators support all 8051
derivatives and help you get your projects completed on schedule.

 When starting a new project, simply select the microcontroller you use
from the Device Database and the µVision IDE sets all compiler, assembler,
linker, and memory options for you.
 Numerous example programs are included to help you get started with the
most popular embedded 8051 devices.
 The Keil µVision Debugger accurately simulates on-chip peripherals
(I²C, CAN, UART, SPI, Interrupts, I/O Ports, A/D Converter, D/A
Converter, and PWM Modules) of your 8051 device. Simulation helps you
understand hardware configurations and avoids time wasted on setup
 problems. Additionally, with simulation, you can write and test applications
before target hardware is available.
 When you are ready to begin testing your software application with target
hardware, use the MON51, MON390, MONADI, or FlashMON51 Target
Monitors, the ISD51 In-System Debugger, or the ULINK USB-JTAG
Adapter to download and test program code on your target system.

4.3.3 Installation

This chapter explains how to setup an operating environment and how to

install the software on your hard disk. Before starting the installation program,
you must do the following:

 Verify that your computer system meets the minimum requirements.

 Make a copy of the installation diskette for backup purposes.

4.3.4 System Requirements

There are minimum hardware and software requirements that must be

satisfied to

ensure that the compiler and utilities function properly.

For our Windows-based tools, you must have the following:

 100% IBM compatible 386 or higher PC,

 Windows 3.1 or higher,
 4 MB RAM minimum,
 Hard disk with 6 MB free disk space.
For our DOS-based tools, you must have the following:

 100% IBM compatible 386 or higher PC with 640 KB RAM,

 MS-DOS Version 3.1 or higher,
 Hard disk with 6 MB free disk space

4.3.5 A51 Assembler Kit

The CA51 Compiler Kit for the 8051 microcontroller family supports all
8051 derivatives including classic devices and IP cores from companies like
Analog Devices, Atmel, Cypress Semiconductor, Dallas Semiconductor, Goal,
Hynix, Infineon, Intel, NXP (founded by Philips), OKI, Silicon Labs, SMSC,
STMicroelectronics, Synopsis, TDK, Temic, Texas Instruments, and Win bond.

On-chip peripherals and other key features of the 8051 are easy to access
with the CA51 Compiler Kit.

Features

 µVision
o Integrated Development Environment

 Keil Classic 8051 Compilation Tools

o A51 Macro Assembler

o C51 ANSI C Compiler

o BL51 Code Banking Linker/Locator

 o OH51 Object-HEX Converter

o OC51 Banked Object Converter

You should consider the CA51 Compiler Kit if you...

 Will work with a variety of 8051 microcontrollers,

 Need to write code in C,
 Already have a simulator or emulator.

Keil Tools for Embedded Development

Keil™, an ARM® Company, makes C compilers, assemblers, integrated

development environments, real-time kernels, debuggers, simulators and JTAG
emulators for embedded systems using the the ARM7/ARM9/Cortex-M3,
XC16x/C16x/ST10, 251, and 8051 cores.

Keil also offers an extensive range of evaluation boards and starter kits to
quick start your development. Evaluation boards are available for ARM, 8051
and C16x devices.

Keil's product-range includes:

 µVision IDE and Debugger

 RealView Microcontroller Development Kit for ARM®
 RealView Real-Time Library for ARM®
 Developer's Kit for 8051
 XC16x, C16x and ST10 Development Tools
 ULINK JTAG and Serial Wire Debug interfaces

µVision Integrated Development Environment

 Common to all Keil software development tools, Keil's µVision IDE and
Debugger combines project management, make facilities, revision control,
source code editing, target program debugging, device simulation and Flash
programming in a single fully-integrated environment. With a simple and
logical Getting-Started process, the µVision development platform helps you to
quickly create embedded programs that work. The Editor and Debugger are
integrated in a single application that provides a seamless embedded project
development environment.

µVision IDE/Debugger/Simulator

µVision is the Keil Integrated Development and Debugging Environment

that helps you quickly create, test and debug embedded applications for ARM7,
ARM9, Cortex-M3, C16x, ST10, XC16x, C251, and C51 embedded
microcontrollers.

The µVision Debugger supports simulation using only your PC or laptop,

and debugging using your target system and a debugger interface. µVision
includes all essential debugging capabilities, including simple and complex
breakpoints, watch windows, and execution control, together with industrial-
strength features that include trace capture, execution profiler, code coverage,
and logic analysis.

Developer's Kit for 8051

The Keil Developer's Kit for 8051 supports all 8051 derivatives from
vendors that include Analog Devices, Atmel, Cypress, Maxim (Dallas),
Infineon, Intel, NXP, SMC, Synopsis, TDK, Temic, TI, Triscend and Win bond.

The Keil Cx51 ANSI C Compiler supports all classic and extended 8051
device variants, including those from Analog Devices, Atmel, Cypress, Maxim
(Dallas), Infineon, NXP, SMC, Synopsis, TDK, Temic, TI, Triscend and Win
bond. Compiler extensions provide full access to all CPU resources, and support
up to 16MB memory. The full range of NXP C51Mx-core extended memory
devices is supported, together with NXP's SmartMX2 Smart Card devices.

Keil Cx51 generates code with the efficiency and speed of hand-optimized
assembly. New compiler and linker optimizations shrink programs into the
smallest single-chip devices.

The Keil μVision® IDE fully integrates Cx51 Version 8 and provides
control of the Compiler, Assembler, Real-Time OS, Project Manager, and
Debugger in a single, intelligent environment. With support for all 8051 devices
and full compatibility with emulators and third party tools, Keil Cx51 is clearly
the best choice for your 8051 project.

 Supports all 8051 variants, up to 16MB memory

 Easy-to-use IDE supports the complete development cycle
 Complete Device Support, including peripherals simulation
 Drivers for Flexible Debugging in Target Hardware
 Supports Flash Programming and JTAG/OCDS debugging on suitable
target-devices, using ULINK debug interfaces
 Fully supported by Ashling's PathFinder Source Debugger and the
Ashling Ultra-51 and Ultra-SmartMX Emulators.

The Keil PK51, CA51 and A51 software packages contain the following
components:

Keil 8051 Development Packages

Product: PK51 CA51 A51

IDE µVision IDE µVision IDE µVision IDE

µVision
Debugger
debugger

µVision
Simulator
simulator

CX51 C
C Compiler, extended memory
Compiler

AX51
Assembler, extended memory
Assembler

Linker, extended memory LX51 Linker

Hex converter, extended OHX51

memory converter

C51 C C51 C
C Compiler, standard memory
Compiler Compiler

A51 A51
Assembler, standard memory A51 Assembler
Assembler Assembler

Linker, standard and banked

BL51 Linker BL51 Linker BL51 Linker
memory

Hex converter, standard OH51 OH51

OH51 converter
memory converter converter

OC51
Banked object converter OC51 converter
converter

Real-Time Kernel RTX51 Tiny

In-System Debugger ISD51

MON51 Target Monitor MON51

MON390 Target Monitor MON390

MONADI Target Monitor MONADI

4.3.6 Concept of compiler: -

Compilers are programs used to convert a High Level Language to object

code. Desktop compilers produce an output object code for the underlying
microprocessor, but not for other microprocessors. I.E the programs written in
one of the HLL like ‘C’ will compile the code to run on the system for a
particular processor like x86 (underlying microprocessor in the computer). For
example compilers for Dos platform is different from the Compilers for Unix
platform

So if one wants to define a compiler then compiler is a program that

translates source code into object code. The compiler derives its name from the
way it works, looking at the entire piece of source code and collecting and
reorganizing the instruction. See there is a bit little difference between compiler
and an interpreter. Interpreter just interprets whole program at a time while
compiler analyzes and execute each line of source code in succession, without
looking at the entire program.

The advantage of interpreters is that they can execute a program

immediately. Secondly programs produced by compilers run much faster than
the same programs executed by an interpreter. However compilers require some
time before an executable program emerges. Now ascompilers translate source
code into object code, which is unique for each type of computer, many
compilers are available for the same language.
Evaluation and Demo Kits

Keil Software provides two kits that let you evaluate our tools.

The 8051/251 Demo Kit includes demonstration versions of our tools. The
tools in the Demo Kit do not generate actual object code. They generate listing
files where you can see the code generated by the compiler and other tools.

The 8051/251 Evaluation Kit includes evaluation versions of our tools. The
tools in the Evaluation Kit let you generate applications up to 2 Kbytes in size.
You may use this kit to evaluate the effectiveness of our tools and to generate
small target applications.

Both kits include this user’s guide and software. This user’s guide is also
included in each of our tool kits.

Types of Users

This manual addresses three types of users: evaluation users, new users, and
experienced users.

Evaluation Users are those users who have not yet purchased the software
but have requested the evaluation package to get a better feel for what the tools
do and how they perform. The evaluation package includes evaluation copies of
the development tools. You may use the included sample programs to get real-
world experience with our 8051 and 251 development tools. Even if you are
only a evaluation user, take the time to read this manual. It explains how to
install the software, provides you with an overview of the development tools,
and introduces the sample programs.

New Users are those users who are purchasing our 8051 development tools
for the first time. The included software provides you with the latest
development tool versions as well as sample programs. If you are new to the
8051 or 251 or the tools, take the time to review the sample programs described
in this manual. This manual provides a quick tutorial and helps new or
inexperienced users quickly get started with the tools.

Experienced Users are those users who have previously used our 8051
development tools and are now upgrading to the latest 8051 or 251 tools. The
software included with a product upgrade contains the latest development tools,
the sample programs, and a full set of manuals.

Embedded Development Tools

MDK Version 5 Microcontroller Development Kit

Keil MDK Version 5 is the latest release of our complete software

development environment for a wide range of ARM, Cortex-M, and Cortex-R
based microcontroller devices. MDK includes the µVision IDE/Debugger,
ARM C/C++ Compiler, and essential middleware components. It's easy to learn
and use.

DS-5 Development Studio

The ARM DS-5 Development Studio is an Eclipse based tool suite for
ARM application processors and System-on-Chip (SoC) devices. It supports
multicore debugging, Streamline performance analyzer, and Linux application
profiling. DS-5 is the right choice for Cortex-A based devices such as Atmel
SAMA5, Freescale i.MX/Vybrid, nvidia Tegra, Renesas EM/EV2, Samsung
Exynos, STEricsson Nova, TI OMAP or Xilinx Zync.

8051 Development Tools

 Keil C51 is the industry-standard toolchain for all 8051-compatible devices,
it supports classic 8051, Dallas 390, NXP MX, extended 8051 variants, and
C251 devices. The µVision IDE/Debugger integrates complete device
simulation, interfaces to many target debug adapters, and provides various
monitor debug solutions.

C166 Development Tools

Keil C166 development tools support the Infineon C166, XC166, XE166,
XC2000 and ST10 microcontroller families. The µVision IDE/Debugger
interfaces to the Infineon DAVE code generation tool and various debug
solutions including the ULINK2.

Evaluation Boards

Keil offers an extensive range of evaluation boards and starter kits to quick
start your development. Boards are available for ARM, 8051, and 166
processor-based devices.

µVision IDE and Debugger

The Keil µVision IDE is common to all Keil software development tools.

Supported Microcontrollers

The Keil development tools support a huge range of standard

microcontroller devices from a variety of vendors, a complete list of the
supported devices is available in the Device Database.