Microcontroller

From Wikipedia, the free encyclopedia

Jump to: navigation, search

The integrated circuit from an Intel 8742, an 8-bit microcontroller that includes a CPU running at
12 MHz, 128 bytes of RAM, 2048 bytes of EPROM, and I/O in the same chip.
A microcontroller (also microcontroller unit, MCU or µC) is a small computer on a single
integrated circuit consisting of a relatively simple CPU combined with support functions such as
a crystal oscillator, timers, watchdog, serial and analog I/O etc. Program memory in the form of
NOR flash or OTP ROM is also often included on chip, as well as a, typically small, read/write
memory.[1]
Microcontrollers are designed for small applications. Thus, in contrast to the microprocessors
used in personal computers and other high-performance applications, simplicity is emphasized.
Some microcontrollers may operate at clock frequencies as low as 32kHz, as this is adequate for
many typical applications, enabling low power consumption (milliwatts or microwatts). They
will generally have the ability to retain functionality while waiting for an event such as a button
press or other interrupt; power consumption while sleeping (CPU clock and most peripherals off)
may be just nanowatts, making many of them well suited for long lasting battery applications.
Microcontrollers are used in automatically controlled products and devices, such as automobile
engine control systems, remote controls, office machines, appliances, power tools, and toys. By
reducing the size and cost compared to a design that uses a separate microprocessor, memory,
and input/output devices, microcontrollers make it economical to digitally control even more
devices and processes.

Contents
[hide]
• 1 Embedded design
○ 1.1 Interrupts
○ 1.2 Programs
○ 1.3 Other microcontroller features
• 2 Higher integration
 • 3 Volumes
• 4 Programming environments
• 5 Types of microcontrollers
• 6 Interrupt latency
• 7 History
• 8 See also
• 9 Notes
• 10 External links

[edit] Embedded design

The majority of computer systems in use today are embedded in other machinery, such as
automobiles, telephones, appliances, and peripherals for computer systems. These are called
embedded systems. While some embedded systems are very sophisticated, many have minimal
requirements for memory and program length, with no operating system, and low software
complexity. Typical input and output devices include switches, relays, solenoids, LEDs, small or
custom LCD displays, radio frequency devices, and sensors for data such as temperature,
humidity, light level etc. Embedded systems usually have no keyboard, screen, disks, printers, or
other recognizable I/O devices of a personal computer, and may lack human interaction devices
of any kind.
[edit] Interrupts
It is mandatory that microcontrolers provide real time response to events in the embedded system
they are controlling. When certain events occur, an interrupt system can signal the processor to
suspend processing the current instruction sequence and to begin an interrupt service routine
(ISR). The ISR will perform any processing required based on the source of the interrupt before
returning to the original instruction sequence. Possible interrupt sources are device dependent,
and often include events such as an internal timer overflow, completing an analog to digital
conversion, a logic level change on an input such as from a button being pressed, and data
received on a communication link. Where power consumption is important as in battery operated
devices, interrupts may also wake a microcontroller from a low power sleep state where the
processor is halted until required to do something by a peripheral event.
[edit] Programs
Microcontroller programs must fit in the available on-chip program memory, since it would be
costly to provide a system with external, expandable, memory. Compilers and assembly language
are used to turn high-level language programs into a compact machine code for storage in the
microcontroller's memory. Depending on the device, the program memory may be permanent,
read-only memory that can only be programmed at the factory, or program memory may be field-
alterable flash or erasable read-only memory.
[edit] Other microcontroller features
Since embedded processors are usually used to control devices, they sometimes need to accept
input from the device they are controlling. This is the purpose of the analog to digital converter.
Since processors are built to interpret and process digital data, i.e. 1s and 0s, they won't be able
to do anything with the analog signals that may be being sent to it by a device. So the analog to
digital converter is used to convert the incoming data into a form that the processor can
recognize. There is also a digital to analog converter that allows the processor to send data to the
device it is controlling.
In addition to the converters, many embedded microprocessors include a variety of timers as
well. One of the most common types of timers is the Programmable Interval Timer, or PIT for
short. A PIT just counts down from some value to zero. Once it reaches zero, it sends an interrupt
to the processor indicating that it has finished counting. This is useful for devices such as
thermostats, which periodically test the temperature around them to see if they need to turn the
air conditioner on, the heater on, etc.
Time Processing Unit or TPU for short is a sophisticated timer. In addition to counting down, the
TPU can detect input events, generate output events, and perform other useful operations.
Dedicated Pulse Width Modulation (PWM) block makes it possible for the CPU to control power
converters, resistive loads, motors, etc., without using lots of CPU resources in tight timer loops.
Universal Asynchronous Receiver/Transmitter (UART) block makes it possible to receive and
transmit data over a serial line with very little load on the CPU.
For those wanting ethernet one can use an external chip like Crystal Semiconductor CS8900A,
Realtek RTL8019, or Microchip ENC 28J60. All of them allow easy interfacing with low pin
count.
[edit] Higher integration
In contrast to general-purpose CPUs, microcontrollers may not implement an external address or
data bus as they integrate RAM and non-volatile memory on the same chip as the CPU. Using
fewer pins, the chip can be placed in a much smaller, cheaper package.
Integrating the memory and other peripherals on a single chip and testing them as a unit
increases the cost of that chip, but often results in decreased net cost of the embedded system as
a whole. Even if the cost of a CPU that has integrated peripherals is slightly more than the cost of
a CPU + external peripherals, having fewer chips typically allows a smaller and cheaper circuit
board, and reduces the labor required to assemble and test the circuit board.
A microcontroller is a single integrated circuit, commonly with the following features:
• central processing unit - ranging from small and simple 4-bit processors to complex 32-
or 64-bit processors
• discrete input and output bits, allowing control or detection of the logic state of an
individual package pin
• serial input/output such as serial ports (UARTs)
• other serial communications interfaces like I²C, Serial Peripheral Interface and Controller
Area Network for system interconnect
• peripherals such as timers, event counters, PWM generators, and watchdog
• volatile memory (RAM) for data storage
• ROM, EPROM, EEPROM or Flash memory for program and operating parameter
storage
• clock generator - often an oscillator for a quartz timing crystal, resonator or RC circuit
 • many include analog-to-digital converters
• in-circuit programming and debugging support
This integration drastically reduces the number of chips and the amount of wiring and circuit
board space that would be needed to produce equivalent systems using separate chips.
Furthermore, and on low pin count devices in particular, each pin may interface to several
internal peripherals, with the pin function selected by software. This allows a part to be used in a
wider variety of applications than if pins had dedicated functions. Microcontrollers have proved
to be highly popular in embedded systems since their introduction in the 1970s.
Some microcontrollers use a Harvard architecture: separate memory buses for instructions and
data, allowing accesses to take place concurrently. Where a Harvard architecture is used,
instruction words for the processor may be a different bit size than the length of internal memory
and registers; for example: 12-bit instructions used with 8-bit data registers.
The decision of which peripheral to integrate is often difficult. The microcontroller vendors often
trade operating frequencies and system design flexibility against time-to-market requirements
from their customers and overall lower system cost. Manufacturers have to balance the need to
minimize the chip size against additional functionality.
Microcontroller architectures vary widely. Some designs include general-purpose microprocessor
cores, with one or more ROM, RAM, or I/O functions integrated onto the package. Other designs
are purpose built for control applications. A microcontroller instruction set usually has many
instructions intended for bit-wise operations to make control programs more compact.[2] For
example, a general purpose processor might require several instructions to test a bit in a register
and branch if the bit is set, where a microcontroller could have a single instruction to provide that
commonly-required function.
Microcontroller typically do not have a math coprocessor, so fixed point or floating point
arithmetic are performed by program code.
[edit] Volumes
About 55% of all CPUs sold in the world are 8-bit microcontrollers and microprocessors.
According to Semico, Over 4 billion 8-bit microcontrollers were sold in 2006.[3]
A typical home in a developed country is likely to have only four general-purpose
microprocessors but around three dozen microcontrollers. A typical mid range automobile has as
many as 30 or more microcontrollers. They can also be found in any electrical device: washing
machines, microwave ovens, telephones etc.
A PIC 18F8720 microcontroller in an 80-pin TQFP package.
Manufacturers have often produced special versions of their microcontrollers in order to help the
hardware and software development of the target system. Originally these included EPROM
versions that have a "window" on the top of the device through which program memory can be
erased by ultra violet light, ready for reprogramming after a programming ("burn") and test
cycle. Since 1998, EPROM versions are rare and have been replaced by EEPROM and flash,
which are easier to use (can be erased electronically) and cheaper to manufacture.
Other versions may be available where the ROM is accessed as an external device rather than as
internal memory, however these are becoming increasingly rare due to the widespread
availability of cheap microcontroller programmers.
The use of field-programmable devices on a microcontroller may allow field update of the
firmware or permit late factory revisions to products that have been assembled but not yet
shipped. Programmable memory also reduces the lead time required for deployment of a new
product.
Where hundreds of thousands of identical devices are required, using parts programmed at the
time of manufacture can be an economical option. These 'Mask Programmed' parts have the
program laid down in the same way as the logic of the chip, at the same time.
[edit] Programming environments
Microcontrollers were originally programmed only in assembly language, but various high-level
programming languages are now also in common use to target microcontrollers. These languages
are either designed specially for the purpose, or versions of general purpose languages such as
the C programming language. Compilers for general purpose languages will typically have some
restrictions as well as enhancements to better support the unique characteristics of
microcontrollers. Some microcontrollers have environments to aid developing certain types of
applications. Microcontroller vendors often make tools freely available to make it easier to adopt
their hardware.
Many microcontrollers are so quirky that they effectively require their own non-standard dialects
of C, such as SDCC for the 8051, which prevent using standard tools (such as code libraries or
static analysis tools) even for code unrelated to hardware features. Interpreters are often used to
hide such low level quirks.
Interpreter firmware is also available for some microcontrollers. For example, BASIC on the
early microcontrollers Intel 8052[4]; BASIC and FORTH on the Zilog Z8[5] as well as some
modern devices. Typically these interpreters support interactive programming.
Simulators are available for some microcontrollers, such as in Microchip's MPLAB environment.
These allow a developer to analyze what the behavior of the microcontroller and their program
should be if they were using the actual part. A simulator will show the internal processor state
and also that of the outputs, as well as allowing input signals to be generated. While on the one
hand most simulators will be limited from being unable to simulate much other hardware in a
system, they can exercise conditions that may otherwise be hard to reproduce at will in the
physical implementation, and can be the quickest way to debug and analyze problems.
Recent microcontrollers are often integrated with on-chip debug circuitry that when accessed by
an In-circuit emulator via JTAG, allow debugging of the firmware with a debugger.
[edit] Types of microcontrollers
This section requires expansion.
See also: List of common microcontrollers
As of 2008 there are several architectures:
• 68HC11
• 8051
• ARM
• Atmel AVR 8-bit architecture
• Atmel AVR32 32-bit architecture
• Freescale CF (32-bit)
• Freescale S08
• Hitachi H8, Hitachi SuperH
• MIPS (32-bit PIC32)
• NEC V850
• PIC (8-bit PIC16, PIC18, 16-bit dsPIC33 / PIC24)
• PowerPC ISE
• PSoC (Programmable System-on-Chip)
• Rabbit 2000
• TI MSP430 (16-bit)
• Toshiba TLCS-870
• Zilog eZ8, eZ80
and many others, some of which are used in very narrow range of applications or are more like
processors than microcontrollers.
[edit] Interrupt latency
In contrast to general-purpose computers, microcontrollers used in embedded systems often seek
to minimize interrupt latency over instruction throughput.
When an electronic device causes an interrupt, the intermediate results, the registers, have to be
saved before the software responsible for handling the interrupt can run, and then must be put
back after it is finished. If there are more registers, this saving and restoring process takes more
time, increasing the latency.
Low-latency MCUs generally have relatively few registers in their central processing units, or
they have "shadow registers", a duplicate register set that is only used by the interrupt software.
[edit] History
 This section requires expansion.

The first single chip microprocessor was the 4 bit Intel 4004 released in 1971, with other more
capable processors available over the next several years.
These however all required external chip(s) to implement a working system, raising total system
cost, and making it impossible to economically computerise appliances.
The first computer system on a chip optimised for control applications - microcontroller was the
Intel 8048 released in 1975[citation needed], with both RAM and ROM on the same chip. This chip
went on to be found in over a billion PC keyboards, and numerous applications.
Most microcontrollers at this time had two variants. One had an erasable EEPROM program
memory, which was significantly more expensive than the PROM variant which was only
programmable once.
In 1993, the introduction of EEPROM memory allowed microcontrollers (beginning with the
Microchip PIC16x84) [1][citation needed]) to be electrically erased quickly without an expensive
package as required for EPROM, allowing both rapid prototyping, and In System Programming.
The same year, Atmel introduced the first microcontroller using Flash memory. [6].
Other companies rapidly followed suit, with both memory types.
Cost has plummeted over time, with the cheapest microcontrollers being available for well under
$0.25 in quantity in 2009 , and 32 bit microcontrollers under $5.
Nowadays microcontrollers are low cost and readily available for hobbyists, with large online
communities around certain processors

[Home]

pictutorial.hub.io

Search

This
Web
Site
pub-3510089450

1 0597911029 ISO-8859-1
 ISO-8859-1 active GALT:#008000;G

en

What is a Microcontroller?

Basically, a microcontroller is a device which integrates a number of the components

of a microprocessor system onto a single microchip and optimised to interact with the
outside world through on-board interfaces; i.e. it is a little gadget that houses a
microprocessor, ROM (Read Only Memory), RAM (Random Access Memory), I/O (Input
Output functions), and various other specialized circuits all in one package.

On the other hand, a microprocessor is normally optimised to co-ordinate the flow of

information between separate memory and peripheral devices which are located
outside itself. Connections to a microprocessor include address, control and data
busses that allow it to select one of its peripherals and send to or retrieve data from
it. Because a microcontrollers processor and peripherals are built on the same silicon,
the devices are self-contained and rarely have any bus structures extending outside
their packages.
So a microcontroller incorporates onto the same microchip the following:

• The CPU core

• Memory (both ROM and RAM)
• Some parallel digital I/O

Microcontroller's fundamental components

Microcontrollers will also combine other devices such as:
• A Timer module to allow the microcontroller to perform tasks for certain time
periods.
 • A serial I/O port to allow data to flow between the microcontroller and other
devices such as a PC or another microcontroller.
• An ADC to allow the microcontroller to accept analogue input data for
processing.

Basic microcontroller architecture

The microcontroller's building blocks explained

To illustrate the functions and interconnectivity of the building blocks of the
microcontroller, we shall construct the microcontroller block by block:

Memory unit
Memory is part of the microcontroller whose function is to store data.
The easiest way to explain it is to describe it as one big closet with lots of drawers. If
we suppose that we marked the drawers in such a way that they can not be confused,
any of their contents will then be easily accessible. It is enough to know the
designation of the drawer and so its contents will be known to us for sure.
Memory components are exactly like that. For a certain input we get the contents of
a certain addressed memory location and that's all. Two new concepts are brought to
us: addressing and memory location. Memory consists of all memory locations, and
addressing is nothing but selecting one of them. This means that we need to select
the desired memory location on one hand, and on the other hand we need to wait for
the contents of that location. Beside reading from a memory location, memory must
also provide for writing onto it. This is done by supplying an additional line called
control line. We will designate this line as R/W (read/write). Control line is used in the
following way: if r/w=1, reading is done, and if opposite is true then writing is done on
the memory location. Memory is the first element, and we need a few operation of
our microcontroller.

Central Processing Unit

The block that will have a built in capability to multiply, divide, subtract, and move its
contents from one memory location onto another is called "central processing unit"
(CPU). Its memory locations are called registers.

Registers are therefore memory locations whose role is to help with performing
various mathematical operations or any other operations with data wherever data
can be found. Look at the current situation. We have two independent entities
(memory and CPU) which are interconnected, and thus any exchange of data is
hindered, as well as its functionality. If, for example, we wish to add the contents of
two memory locations and return the result again back to memory, we would need a
connection between memory and CPU. Simply stated, we must have some "way"
through data goes from one block to another.

Bus
That "way" is called "bus". Physically, it represents a group of 8, 16, or more wires
There are two types of buses: address and data bus. The first one consists of as many
lines as the amount of memory we wish to address, and the other one is as wide as
data, in our case 8 bits or the connection line. First one serves to transmit address
from CPU memory, and the second to connect all blocks inside the microcontroller.

As far as functionality, the situation has improved, but a new problem has also
appeared: we have a unit that's capable of working by itself, but which does not have
any contact with the outside world, or with us! In order to remove this deficiency, let's
add a block which contains several memory locations whose one end is connected to
the data bus, and the other has connection with the output lines on the
microcontroller which can be seen as pins on the electronic component.

Input-output unit
Those locations we've just added are called "ports". There are several types of ports :
input, output or bidirectional ports. When working with ports, first of all it is necessary
to choose which port we need to work with, and then to send data to, or take it from
the port.
When working with it the port acts like a memory location. Something is simply being
written into or read from it, and it could be noticed on the pins of the microcontroller.

Serial communication
Beside stated above we've added to the already existing unit the possibility of
communication with an outside world. However, this way of communicating has its
drawbacks. One of the basic drawbacks is the number of lines which need to be used
in order to transfer data. What if it is being transferred to a distance of several
kilometres? The number of lines times number of kilometres doesn't promise the
economy of the project. It leaves us having to reduce the number of lines in such a
way that we don't lessen its functionality. Suppose we are working with three lines
only, and that one line is used for sending data, other for receiving, and the third one
is used as a reference line for both the input and the output side. In order for this to
work, we need to set the rules of exchange of data. These rules are called protocol.
Protocol is therefore defined in advance so there wouldn't be any misunderstanding
between the sides that are communicating with each other. For example, if one man
is speaking in French, and the other in English, it is highly unlikely that they will
quickly and effectively understand each other. Let's suppose we have the following
protocol. The logical unit "1" is set up on the transmitting line until transfer begins.
Once the transfer starts, we lower the transmission line to logical "0" for a period of
time (which we will designate as T), so the receiving side will know that it is receiving
data, and so it will activate its mechanism for reception. Let's go back now to the
transmission side and start putting logic zeros and ones onto the transmitter line in
the order from a bit of the lowest value to a bit of the highest value. Let each bit stay
on line for a time period which is equal to T, and in the end, or after the 8th bit, let us
bring the logical unit "1" back on the line which will mark the end of the transmission
of one data. The protocol we've just described is called in professional literature NRZ
(Non-Return to Zero).

As we have separate lines for receiving and sending, it is possible to receive and send
data (info.) at the same time. So called full-duplex mode block which enables this way
of communication is called a serial communication block. Unlike the parallel
transmission, data moves here bit by bit, or in a series of bits what defines the term
serial communication comes from. After the reception of data we need to read it from
the receiving location and store it in memory as opposed to sending where the
process is reversed. Data goes from memory through the bus to the sending location,
and then to the receiving unit according to the protocol.

Timer unit
Since we have the serial communication explained, we can receive, send and process
data.
However, in order to utilize it in industry we need a few additionally blocks. One of
those is the timer block which is significant to us because it can give us information
about time, duration, protocol etc. The basic unit of the timer is a free-run counter
which is in fact a register whose numeric value increments by one in even intervals,
so that by taking its value during periods T1 and T2 and on the basis of their
difference we can determine how much time has elapsed. This is a very important
part of the microcontroller whose understanding requires most of our time.

Watchdog
One more thing is requiring our attention is a flawless functioning of the
microcontroller
during its run-time. Suppose that as a result of some interference (which often does
occur in industry) our microcontroller stops executing the program, or worse, it starts
working incorrectly.
Of course, when this happens with a computer, we simply reset it and it will keep
working. However, there is no reset button we can push on the microcontroller and
thus solve our problem. To overcome this obstacle, we need to introduce one more
block called watchdog. This block is in fact another free-run counter where our
program needs to write a zero in every time it executes correctly. In case that
program gets "stuck", zero will not be written in, and counter alone will reset the
microcontroller upon achieving its maximum value. This will result in executing the
program again, and correctly this time around. That is an important element of every
program to be reliable without man's supervision.

Analog to Digital Converter (ADC)

As the peripheral signals usually are substantially different from the ones that
microcontroller can understand (zero and one), they have to be converted into a
pattern which can be comprehended by a microcontroller. This task is performed by a
block for analog to digital conversion or by an ADC. This block is responsible for
converting an information about some analog value to a binary number and for follow
it through to a CPU block so that CPU block can further process it.

Finally, the microcontroller is now completed, and all we need to do now is to

assemble it into an electronic component where it will access inner blocks through
the outside pins. The picture below shows what a microcontroller looks like inside.
Thin lines which lead from the center towards the sides of the microcontroller
represent wires connecting inner blocks with the pins on the housing of the
microcontroller so called bonding lines. Chart on the following page represents the
center section of a microcontroller.

For a real application, a microcontroller alone is not enough. Beside a microcontroller,

we need a program that would be executed, and a few more elements which make up
a interface logic towards the elements of regulation .

Program
Program writing is a special field of work with microcontrollers and is called
"programming". Try to write a small program in a language that we will make up
ourselves first and then would be understood by anyone.

START
REGISTER1=MEMORY LOCATION_A
REGISTER2=MEMORY LOCATION_B
PORTA=REGISTER1 + REGISTER2

END

The program adds the contents of two memory locations, and views their sum on port
A. The first line of the program stands for moving the contents of memory location
"A" into one of the registers of central processing unit. As we need the other data as
well, we will also move it into the other register of the central processing unit. The
next instruction instructs the central processing unit to add the contents of those two
registers and send a result to port A, so that sum of that addition would be visible to
the outside world. For a more complex problem, program that works on its solution
will be bigger.
Programming can be done in several languages such as Assembler, C and Basic
which are most commonly used languages. Assembler belongs to lower level
languages that are programmed slowly, but take up the least amount of space in
memory and gives the best results where the speed of program execution is
concerned. As it is the most commonly used language in programming
microcontrollers it will be discussed in a later chapter. Programs in C language are
easier to be written, easier to be understood, but are slower in executing from
assembler programs. Basic is the easiest one to learn, and its instructions are nearest
a man's way of reasoning, but like C programming language it is also slower than
assembler. In any case, before you make up your mind about one of these languages
you need to consider carefully the demands for execution speed, for the size of
memory and for the amount of time available for its assembly.
After the program is written, we would install the microcontroller into a device and
run it. In order to do this we need to add a few more external components necessary
for its work. First we must give life to a microcontroller by connecting it to a power
supply (power needed for operation of all electronic instruments) and oscillator whose
role is similar to the role that heart plays in a human body. Based on its clocks
microcontroller executes instructions of a program. As it receives supply
microcontroller will perform a small check up on itself, look up the beginning of the
program and start executing it. How the device will work depends on many
parameters, the most important of which is the skilfulness of the developer of
hardware, and on programmer's expertise in getting the maximum out of the device
with his program.
Microcontrollers vs. Microprocessors:
Microcontroller differs from a microprocessor in many ways. First and the most
important is its functionality. In order for a microprocessor to be used, other
components such as memory, or components for receiving and sending data must be
added to it. In short that means that microprocessor is the very heart of the
computer. On the other hand, microcontroller is designed to be all of that in one. No
other external components are needed for its application because all necessary
peripherals are already built into it.