Microprocessor Application, Organisation and Embedded

Systems (EEE5232)
Lecture – 1: Introduction

An embedded system is a dedicated computing system or processing unit which performs the desired function
upon power up, repeatedly. They are found in a variety of common electronic devices such as:

• In consumer electronics: cell phones, pagers, digital cameras, camcorders, videocassette recorders,
portable video games, calculators, and personal digital assistants
• In home appliances: microwave ovens, answering machines, thermostat, home security, washing
machines, and lighting systems
• In office automation & business equipment: fax machines, copiers, printers, scanners, cash registers,
alarm systems, card readers, product scanners, and automated teller machines
• In automobiles: transmission control unit, Brain Box, cruise control, fuel injection, anti-lock brakes, and
active suspension

Fig. 1.1. Block diagram of a Generic multi-function media player.

The above diagram illustrates the concept of an embedded system with a very specific application (in a media
device). There are embedded system units serving as the core processing and control part of each of these
systems. Embedded systems can be primarily classified into Small-Scale, medium scale and Large-scale, based
on factors like processing power, power consumption, number of processors used, memory size, etc.
1. Small Scale Embedded Systems: These systems are usually designed with a single 8- or 16-bit
microcontroller or microprocessor as its core. They have little hardware and software complexities, and
they typically involve board-level designs and are battery operated (as in your undergraduate project) and
are interfaced with few external peripherals at their input/output ports. During their development, tools
like code editor and assembler/compiler specific to the microcontroller or microprocessor are used.
Usually, C or C++ programming language is used for developing these systems. The program compilation
is done into the assembly, and executable codes are then appropriately located in the system memory.
The resulting software/code has to fit within the memory available.

2. Medium – Scale Embedded Systems: are usually designed with a single or few 16- or 32-bit
microcontrollers, microprocessors, DSPs or some Reduced Instruction Set Computers (RISCs). Embedded
systems in this category have more hardware and software complexities (control more input/output
peripherals). The software design is more complex and require the use of programming tools, Simulators,
Debugger and other Integrated Development Environment (IDE). Systems at this level may also employ
readily available Application-Specific System Processors (ASSPs) for the various functions – like, for bus
interfacing, encrypting, deciphering, discrete cosine transformation and inverse transformation, TCP/IP
protocol stacking and other network connecting functions.

3. Large – Scale Embedded Systems: Are sophisticated embedded systems and they have enormous
hardware and software complexities and are used for cutting edge applications. They may need scalable
processors or configurable processors and or Programmable Logic Arrays (PLAs). Their main constraint is
usually the processing speeds available in their hardware units. Therefore, certain software functions
(such as encryption/decryption algorithms, discrete cosine transformation and inverse transformation
algorithms, TCP/IP protocol etc) are implemented in the hardware to obtain additional speeds by saving
time. The development tools for these systems are often not be readily available at an easy cost or may
not be available at all (they are often proprietary).

Fig. 1.2.
An embedded system is made up of both hardware and software part. The hardware components of an
embedded system include all the electronics necessary for the system to perform the function it was designed
for. Three core hardware components are essential in an embedded system are The Central Processing Unit
(CPU), the system memory, and a set of input-output ports. The CPU executes software instructions to process
the system inputs and to make the decisions that guide the system operation. Memory stores programs and
data necessary for system operation. Most systems differentiate between program and data memories.
Program memory stores the software programs executed by the CPU. Data memory stores the data processed
by the system. The I/O ports allow conveying signals between the CPU and the world external to it. Beyond
this point, several other supporting and I/O devices needed for system functionality might be present,
depending on the application. These include:
• Communication ports for serial and/or parallel information exchanges with other devices or systems.
USB ports, printer ports, wireless RF and infrared ports, are some representative examples of I/O
communication devices.
• User interfaces to interact with humans. Keypads, switches, buzzers and audio, lights, numeric,
alphanumeric, and graphic displays, are examples of I/O user interfaces.
• Sensors and electromechanical actuators to interact with the environment external to the system.
Sensors provide inputs related to physical parameters such as temperature, pressure, displacement,
acceleration, rotation, etc. Motor speed controllers, stepper motor controllers, relays, and power
drivers are some examples of actuators to receive outputs from the system I/O ports.
• Data converters (Analog-to-digital (ADC) and/or Digital-to-Analog (DAC)) to allow interaction with
analog sensors and actuators. When the signal coming out from a sensor interface is analog, an ADC
converts it to the digital format understood by the CPU. Similarly, when the CPU needs to command an
analog actuator, a DAC is required to change the signal format.
• Diagnostics and redundant components to verify and provide for robust, reliable system operation.
• System support components to provide essential services that allow the system to operate. Essential
support devices include power supply and management components, and clock frequency generators.
Other optional support components include timers, interrupt management logic, DMA controllers, etc.
Other sub-systems to enable functionality, that might include Application Specific Integrated Circuits
(ASIC), Field Programmable Gate Arrays (FPGA), and other dedicated units, according to the complexity
of the application.
The software components of an embedded system include all the programs necessary to give functionality to
the system hardware. These programs, frequently referred to as the system firmware, are stored in some sort
of non-volatile memory. Firmware is not meant to be modifiable by users, although some systems could
provide means of performing upgrades. System programs are organized around some form of operating
system and application routines.
Embedded systems can be further classified bed on the type of processing unit used. An embedded
system with a microcontroller as its core unit is termed a microcontroller
– based embedded system. One with a DSP as its core processing unit is
referred to as a DSP – Based embedded system. Recently however, there
are more ASSPs as the main processing unit in an embedded system.
There are also complex embedded systems having multiple processing
units.
One of the earliest electronic computing devices credited with the
term “embedded system” and closer to our present conception of such
was the Apollo Guidance Computer (AGC). Developed at the MIT
Instrumentation Laboratory in the early 1960s, the AGC was part of the
guidance and navigation system used by NASA in the Apollo program for
various spaceships. In its early days it was considered one of the riskiest items in the Apollo program due to
the usage of the then newly developed monolithic integrated circuits. The AGC incorporated a user interface
module based on keys, lamps, and seven-segment numeric displays; a hardwired control unit based on 4,100
single three-input RTL NOR gates, 4KB of magnetic core RAM, and 32KB of core rope ROM. The unit CPU was
run by a 2.048MHz primary clock, had four 16-bit central registers and executed eleven instructions. It
supported five vectored interrupt sources, including a 20-register timer-counter, a real-time clock module, and
even allowed for a low-power standby mode that reduced in over 85% the module’s power consumption,
while keeping alive all critical components. The system software of the Apollo Guidance Computer was written
in AGC assembly language and supported a non-preemptive real-time operating system that could
simultaneously run up to eight prioritized jobs. The AGC was indeed an advanced system for its time.
However, it was an expensive, bulky system that remained used only for highly specialized applications. For
this reason, among others, the flourishing of embedded systems in commercial applications had to wait until
another remarkable event in electronics: the advent of the microprocessor.

Brief History of the microprocessor

By the end of 1971, almost simultaneously and independently, design teams working for Texas
Instruments, Intel, and the US Navy had developed implementations of the first microprocessors. Gary Boone
from Texas Instruments in 1973 patented the first single-chip microprocessor architecture, the TMS1000. The
chip was a 4-bit CPU that incorporated 1K of ROM and 256 bits of RAM to offer a complete computer
functionality in a single-chip, making it the first microcomputer-on-a-chip (a.k.a microcontroller). The
TMS1000 was launched in September 1971 as a calculator chip with part number TMS1802NC.

Fig. 1.4. Die microphotograph and packaged parts for the TMS1000 and i4004

The i4004, recognized as the first commercial, stand-alone single chip microprocessor, was launched by
Intel in November 1971. The chip was developed by a design team led by Federico Faggin at Intel. This design
was also a 4-bit CPU intended for use in electronic calculators. The 4004 was able to address 4K of memory,
operating at a maximum clock frequency of 740KHz. Integrating a minimum system around the i4004 required
at least three additional chips: a 4001 ROM, a 4002 RAM, and a 4003 I/O interface.
The third pioneering microprocessor design of that age was a less known project for the US Navy named the
Central Air Data Computer (CADC). This system implemented a chipset CPU for the F-14 Tomcat fighter named
the MP944. The system supported 20-bit operands in a pipelined, parallel multiprocessor architecture
designed around 28 chips. Due to the classified nature of this design, public disclosure of its existence was
delayed until 1998, although the disclosed documentation indicates it was completed by 1970.
 After these developments, it did not take long for designers to realize the potential of microprocessors
and its advantages for implementing embedded applications. Microprocessor designs soon evolved from 4-bit
to 8-bit CPUs. By the end of the 1970s, the design arena was dominated by 8-bit CPUs and the market for
microprocessors-based embedded applications had grown to hundreds of millions of dollars. The list of initial
players grew to more than a dozen of chip manufacturers that, besides Texas Instruments and Intel, included
Motorola, Zilog, Intersil, National Instruments, MOS Technology, and Signetics, to mention just a few of the
most renowned. Remarkable parts include the Intel 8080 (that eventually evolved into the famous 80 ×
86/Pentium series), the Zilog Z-80, Motorola 6800 and MOS 6502. The evolution in CPU sizes continued
through the 1980s and 1990s to 16-, 32-, and 64-bit designs, and nowadays even some specialized CPUs
crunching data at 128-bit widths. In terms of manufacturers and availability of processors, the list has grown
to the point that it is possible to find over several dozens of different choices for processor sizes 32-bit and
above, and hundreds of 16- and 8-bit processors.

Microprocessor Vs Microcontroller
A Microprocessor Unit (referred to as MPU), fundamentally contains a general-purpose CPU in its die.
All other components other than the CPU (i.e., the buses, memory, and I/O interfaces), are implemented
externally. Other characteristics of MPUs include an optimized architecture to move code and data from
external memory into the chip such as queues and caches, and the inclusion of architectural elements to
accelerate processing such as multiple functional units, ability to issue multiple instructions at once,
and other features such as branch prediction units and numeric co-processors. In other words, a microprocessor
is designed with optimized data processing capability in mind. The most common examples of systems
designed around an MPUs are personal computers and mainframes. Manufacturers of MPU’s include INTEL,
Freescale, Zilog, Fujitsu, Siemens, and many others. Microprocessor design has advanced from the initial
models in the early 1970s to present day technologies. Intel’s initial 4004 in 1971 was built using 10μm
technology, ran at 400kHz and contained 2,250 transistors. Intel’s Xeon E7 MPU, released in 2011, was built
using 32 nm technology, runs at 2GHz and contains 2.6×109 transistors. MPUs indeed, represent the most
powerful type of processing components available to implement a microcomputer. Most small embedded
systems, however, do not need the large computational and processing power that characterize microprocessors,
and hence the orientation to microcontrollers for these tasks. In this course however, we will be focusing on
the Intel’s 8085 microprocessor.
A microcontroller unit, (referred to as MCU), has a central processing unit (CPU) core, usually less
complex than that of an MPU. This basic CPU is then surrounded with memory of both types (program and
data) and several types of peripherals, all of them embedded into a single integrated circuit, or chip. This
blending of CPU, memory, and I/O within a single chip is what we call a microcontroller. The assortment of
components embedded into a microcontroller allows for implementing complete applications requiring only a
minimal number of external components. Peripheral timers, input/output (I/O) ports, interrupt handlers, and data
converters are among those commonly found in most microcontrollers. The provision of such an assortment of
resources inside the same chip is what has gained them the denomination of computers-on-a-chip.
Microcontrollers are usually marketed as family members. Each family is developed around a basic architecture
which defines the common characteristics of all the members. Features differentiating family members include
the amount of on-chip data and program memory and the assortment of on-chip peripherals. There are literally
hundreds, perhaps thousands, of microprocessors and microcontrollers on the market. Table below shows a very
small sample of microcontroller family models of different sizes from six companies. We will concentrate on
the 8051/8052 family for practical hands-on introduction in this course.
 Internal Structure of a typical microcontroller

Manufacturer Examples of commercially available microcontrollers

Altera 32-bit: NIOS II
16-bit: NIOS
Atmel AT89 series (Intel’s 8051 architecture)
AT90, ATtiny, ATmega series, ATxmega series (AVR architecture), AVR32 (32-bit AVR
architecture)
Freescale 8-bit: Freescale S08, 68HC05, 68HC08, 68HC11
Semiconductor 16-bit: Freescale S12, 68HC12, 68HC16
32-bit: Freescale 683XX, MPC5777, MPC5554/5566, MPC8240/8250
Infenon 8-bit: XC800 family based on the 8051 architectures
16-bit: XE166 family, XC2000 family, C166/167 family
32-bit: Infenon XMC4000
Intel 8-bit: MCS-48 (8048 family), MCS-51 (8051 family, e.g. 8X31, 8X32, 8X52, X=0,3,7 or 9).
16-bit: MCS-96 (8096 family)
32-bit: MCS-251
Microchip Tech. 8-bit: PIC10, PIC16 series (e.g. PIC16F84) and PIC18 series
16-bit: PIC24 series
32-bit: PIC32MM, PIC32MX and PIC32MZ series

Digital Signal Processors (DSPs):

DSPs are Powerful special purpose 8- or 16- or 32-bit microprocessors designed specifically to meet the
computational demands and power constraints of today's embedded audio, video, and communications
applications. DSPs are several times faster than the general-purpose microprocessors in signal processing
applications. The key difference is that DSPs implement algorithms in hardware which speeds up the execution
whereas general purpose processors implement algorithms in firmware and the speed of execution depends
primarily on the clock for the processors. DSPs can be viewed as microchips designed for performing high
speed computational operations (in signal processing applications). A typical example is the Texas
Instrument’s TMS320F2833X series 32-bit DSP shown below.

The 176-pin pin assignment of the TMS320F2833x DSP and its corresponding Development board.

Harvard vs Von-Neumann Processor/Controller Architecture

With respect to the contents, the structure of a microcomputer includes two differentiable types of
memory (depending on the kind of information they store) viz Program Memory and Data Memory. Program
memory, as inferred by its name, refers to the portion of memory that stores the system programs in a form
directly accessible by the CPU. A program is a logical sequence of instructions that describe the functionality of
a computer system. In embedded systems, programs are fixed and must always be accessible to the CPU to
allow the system to operate correctly. Thus, when power is removed from the system and later restored,
programs must still be there to allow the system to function properly. This implies that program is usually
stored in nonvolatile memory. Some microcontroller models may run a program from the RAM portion while
others enforce using only ROM sections.

Von-Neuman and Harvard Architectures Concept of CPU – memory connection

Data memory is used for storing variables and data expected to change during program execution (like
operation results or measurements for making decisions). Therefore, this type of memory allows for easily
modifying its contents. Most embedded systems implement data memory in RAM (Random-Access Memory).
The average amount of RAM needed in most embedded applications is relatively small. Particularly important
data which cannot be lost when the system is de-energized, must be stored in the ROM section. Some
microcontroller families may access these data directly from there, although they cannot change data during
program execution.

Program and data memories may share the same system buses or not, depending on the MCU architecture.
Systems with a single set of buses for accessing both programs and data are said to have a Von Neumann
architecture. An alternate organization is offered by the Harvard Architecture, here there is a physically
separate address spaces for programs and data and therefore uses separate buses for accessing each. Data and
address buses may be of different width for both subsystems. Numerous arguments can be brought in favor of
either of these architectural styles. Both are present in embedded systems. Some Texas Instruments MCU use a
Von Neumann architecture while Microchip PIC and Intel’s 8051 utilize Harvard architecture.
Microprocessors/controllers based on the Harvard architecture will have separate data bus and instruction bus.
This allows the data transfer and program fetching to occur simultaneously on both buses. With Harvard
architecture, the data memory can be read and written while the program memory is being accessed. These
separated data memory and code memory buses allow one instruction to execute while the next instruction is
fetched (“Pre-fetching”).

CISC vs RISC systems

CISC (Complex Instruction Set Computing) machines are characterized by variable length instruction
words, i.e., with different number of bits, small code sizes, and multiple clocked-complex instructions at
machine level. CISC architecture focuses in accomplishing as much as possible with each instruction, in order
to generate simple programs. This focus helps the programmer’s task while augmenting hardware complexity.
RISC (Reduced Instruction Set Computing) machines, on the other hand, are designed with focus on
simple instructions, even if that results in longer programs. This orientation simplifies the hardware structure.
The design expects that any single instruction execution is reduced – at most a single data memory cycle –
when compared to the “complex instructions” of a CISC system. It is usually accepted that RISC
microcontrollers are faster, although this may not be necessarily true for all instructions.

Evaluation Questions
1. What is an Embedded System? In your opinion, what makes it different from a general-purpose
computer?
2. Write a list of at least 5 tasks you perform regularly that are enabled by embedded systems.
3. What are the fundamental components of an embedded system? Briefly describe how each is
structured.
4. In a tabular form, list the key differences between a microcontroller and a microprocessor.
5. Draw a detailed diagram showing the architectural structure of a typical microcontroller.
6. Write short notes on the Von-Neumann and Harvard architecture.