Notes Microcontroller
Computers :
A general purpose computer has four main components: the arithmetic logic unit (ALU), the control unit,
the memory, and the input and output devices (collectively termed I/O). These parts are interconnected
by buses, often made of groups of wires.
Inside each of these parts are thousands to trillions of small electrical circuits which can be turned off or
on by means of an electronic switch. Each circuit represents a bit (binary digit) of information so that
when the circuit is on it represents a “1”, and when off it represents a “0” (in positive logic
representation). The circuits are arranged in logic gates so that one or more of the circuits may control
the state of one or more of the other circuits.
The control unit, ALU, registers, and basic I/O (and often other hardware closely linked with these) are
collectively known as a central processing unit (CPU). Early CPUs were composed of many separate
components but since the mid-1970s CPUs have typically been constructed on a single integrated circuit
called a microprocessor.
Control unit
The control unit (often called a control system or central controller) manages the computer's various
components; it reads and interprets (decodes) the program instructions, transforming them into a series
of control signals which activate other parts of the computer.[59] Control systems in advanced
computers may change the order of some instructions so as to improve performance.
A key component common to all CPUs is the program counter, a special memory cell (a register) that
keeps track of which location in memory the next instruction is to be read from.[60]
The control system's function is as follows—note that this is a simplified description, and some of these
steps may be performed concurrently or in a different order depending on the type of CPU:
Read the code for the next instruction from the cell indicated by the program counter.
Decode the numerical code for the instruction into a set of commands or signals for each of the other
systems.
Increment the program counter so it points to the next instruction.
Read whatever data the instruction requires from cells in memory (or perhaps from an input device).
The location of this required data is typically stored within the instruction code.
Provide the necessary data to an ALU or register.
Page 1 of 17
If the instruction requires an ALU or specialized hardware to complete, instruct the hardware to perform
the requested operation.
Write the result from the ALU back to a memory location or to a register or perhaps an output device.
Jump back to step .
Since the program counter is (conceptually) just another set of memory cells, it can be changed by
calculations done in the ALU. Adding 100 to the program counter would cause the next instruction to be
read from a place 100 locations further down the program. Instructions that modify the program
counter are often known as “jumps” and allow for loops (instructions that are repeated by the
computer) and often conditional instruction execution (both examples of control flow).
The sequence of operations that the control unit goes through to process an instruction is in itself like a
short computer program, and indeed, in some more complex CPU designs, there is another yet smaller
computer called a microsequencer, which runs a microcode program that causes all of these events to
happen.
Arithmetic logic unit (ALU)
Main article: Arithmetic logic unit
The ALU is capable of performing two classes of operations: arithmetic and logic.[61]
The set of arithmetic operations that a particular ALU supports may be limited to addition and
subtraction, or might include multiplication, division, trigonometry functions such as sine, cosine, etc.,
and square roots. Some can only operate on whole numbers (integers) whilst others use floating point
to represent real numbers, albeit with limited precision. However, any computer that is capable of
performing just the simplest operations can be programmed to break down the more complex
operations into simple steps that it can perform. Therefore, any computer can be programmed to
perform any arithmetic operation—although it will take more time to do so if its ALU does not directly
support the operation. An ALU may also compare numbers and return boolean truth values (true or
false) depending on whether one is equal to, greater than or less than the other (“is 64 greater than
65?”).
Logic operations involve Boolean logic: AND, OR, XOR and NOT. These can be useful for creating
complicated conditional statements and processing boolean logic.
Superscalar computers may contain multiple ALUs, allowing them to process several instructions
simultaneously.[62] Graphics processors and computers with SIMD and MIMD features often contain
ALUs that can perform arithmetic on vectors and matrices.
Page 2 of 17
Memory
Magnetic core memory was the computer memory of choice throughout the 1960s, until it was replaced
by semiconductor memory.
A computer's memory can be viewed as a list of cells into which numbers can be placed or read. Each
cell has a numbered “address” and can store a single number. The computer can be instructed to “put
the number 123 into the cell numbered 1357” or to “add the number that is in cell 1357 to the number
that is in cell 2468 and put the answer into cell 1595.” The information stored in memory may represent
practically anything. Letters, numbers, even computer instructions can be placed into memory with
equal ease. Since the CPU does not differentiate between different types of information, it is the
software's responsibility to give significance to what the memory sees as nothing but a series of
numbers.
In almost all modern computers, each memory cell is set up to store binary numbers in groups of eight
bits (called a byte). Each byte is able to represent 256 different numbers (2^8 = 256); either from 0 to
255 or −128 to +127. To store larger numbers, several consecutive bytes may be used (typically, two,
four or eight). When negative numbers are required, they are usually stored in two's complement
notation. Other arrangements are possible, but are usually not seen outside of specialized applications
or historical contexts. A computer can store any kind of information in memory if it can be represented
numerically. Modern computers have billions or even trillions of bytes of memory.
The CPU contains a special set of memory cells called registers that can be read and written to much
more rapidly than the main memory area. There are typically between two and one hundred registers
depending on the type of CPU. Registers are used for the most frequently needed data items to avoid
having to access main memory every time data is needed. As data is constantly being worked on,
reducing the need to access main memory (which is often slow compared to the ALU and control units)
greatly increases the computer's speed.
Computer main memory comes in two principal varieties: random-access memory or RAM and read-only
memory or ROM. RAM can be read and written to anytime the CPU commands it, but ROM is preloaded
with data and software that never changes, therefore the CPU can only read from it. ROM is typically
used to store the computer's initial start-up instructions. In general, the contents of RAM are erased
when the power to the computer is turned off, but ROM retains its data indefinitely. In a PC, the ROM
contains a specialized program called the BIOS that orchestrates loading the computer's operating
system from the hard disk drive into RAM whenever the computer is turned on or reset. In embedded
computers, which frequently do not have disk drives, all of the required software may be stored in ROM.
Software stored in ROM is often called firmware, because it is notionally more like hardware than
software. Flash memory blurs the distinction between ROM and RAM, as it retains its data when turned
off but is also rewritable. It is typically much slower than conventional ROM and RAM however, so its
use is restricted to applications where high speed is unnecessary.[63]
Page 3 of 17
In more sophisticated computers there may be one or more RAM cache memories, which are slower
than registers but faster than main memory. Generally computers with this sort of cache are designed to
move frequently needed data into the cache automatically, often without the need for any intervention
on the programmer's part.
Input/output (I/O)
Hard disk drives are common storage devices used with computers.
I/O is the means by which a computer exchanges information with the outside world.[64] Devices that
provide input or output to the computer are called peripherals.[65] On a typical personal computer,
peripherals include input devices like the keyboard and mouse, and output devices such as the display
and printer. Hard disk drives, floppy disk drives and optical disc drives serve as both input and output
devices. Computer networking is another form of I/O.
I/O devices are often complex computers in their own right, with their own CPU and memory. A graphics
processing unit might contain fifty or more tiny computers that perform the calculations necessary to
display 3D graphics.[citation needed] Modern desktop computers contain many smaller computers that
assist the main CPU in performing I/O.
Multitasking
While a computer may be viewed as running one gigantic program stored in its main memory, in some
systems it is necessary to give the appearance of running several programs simultaneously. This is
achieved by multitasking i.e. having the computer switch rapidly between running each program in
turn.[66]
One means by which this is done is with a special signal called an interrupt, which can periodically cause
the computer to stop executing instructions where it was and do something else instead. By
remembering where it was executing prior to the interrupt, the computer can return to that task later. If
several programs are running “at the same time,” then the interrupt generator might be causing several
hundred interrupts per second, causing a program switch each time. Since modern computers typically
execute instructions several orders of magnitude faster than human perception, it may appear that
many programs are running at the same time even though only one is ever executing in any given
instant. This method of multitasking is sometimes termed “time-sharing” since each program is
allocated a “slice” of time in turn.[67]
Before the era of cheap computers, the principal use for multitasking was to allow many people to share
the same computer.
Seemingly, multitasking would cause a computer that is switching between several programs to run
more slowly, in direct proportion to the number of programs it is running, but most programs spend
much of their time waiting for slow input/output devices to complete their tasks. If a program is waiting
for the user to click on the mouse or press a key on the keyboard, then it will not take a “time slice” until
Page 4 of 17
the event it is waiting for has occurred. This frees up time for other programs to execute so that many
programs may be run simultaneously without unacceptable speed loss.
Multiprocessing
Cray designed many supercomputers that used multiprocessing heavily.
Some computers are designed to distribute their work across several CPUs in a multiprocessing
configuration, a technique once employed only in large and powerful machines such as supercomputers,
mainframe computers and servers. Multiprocessor and multi-core (multiple CPUs on a single integrated
circuit) personal and laptop computers are now widely available, and are being increasingly used in
lower-end markets as a result.
Supercomputers in particular often have highly unique architectures that differ significantly from the
basic stored-program architecture and from general purpose computers.[68] They often feature
thousands of CPUs, customized high-speed interconnects, and specialized computing hardware. Such
designs tend to be useful only for specialized tasks due to the large scale of program organization
required to successfully utilize most of the available resources at once. Supercomputers usually see
usage in large-scale simulation, graphics rendering, and cryptography applications, as well as with other
so-called “embarrassingly parallel” tasks.
Networking and the Internet
Visualization of a portion of the routes on the Internet.
Computers have been used to coordinate information between multiple locations since the 1950s. The
U.S. military's SAGE system was the first large-scale example of such a system, which led to a number of
special-purpose commercial systems such as Sabre.[69]
In the 1970s, computer engineers at research institutions throughout the United States began to link
their computers together using telecommunications technology. The effort was funded by ARPA (now
DARPA), and the computer network that resulted was called the ARPANET.[70] The technologies that
made the Arpanet possible spread and evolved.
In time, the network spread beyond academic and military institutions and became known as the
Internet. The emergence of networking involved a redefinition of the nature and boundaries of the
computer. Computer operating systems and applications were modified to include the ability to define
and access the resources of other computers on the network, such as peripheral devices, stored
information, and the like, as extensions of the resources of an individual computer. Initially these
facilities were available primarily to people working in high-tech environments, but in the 1990s the
spread of applications like e-mail and the World Wide Web, combined with the development of cheap,
fast networking technologies like Ethernet and ADSL saw computer networking become almost
ubiquitous. In fact, the number of computers that are networked is growing phenomenally. A very large
proportion of personal computers regularly connect to the Internet to communicate and receive
Page 5 of 17
information. “Wireless” networking, often utilizing mobile phone networks, has meant networking is
becoming increasingly ubiquitous even in mobile computing environments.
Computer architecture paradigms
There are many types of computer architectures:
Quantum computer vs Chemical computer
Scalar processor vs Vector processor
Non-Uniform Memory Access (NUMA) computers
Register machine vs Stack machine
Harvard architecture vs von Neumann architecture
Cellular architecture
Of all these abstract machines, a quantum computer holds the most promise for revolutionizing
computing
Logic gates are a common abstraction which can apply to most of the above digital or analog paradigms.
The ability to store and execute lists of instructions called programs makes computers extremely
versatile, distinguishing them from calculators. The Church–Turing thesis is a mathematical statement of
this versatility: any computer with a minimum capability (being Turing-complete) is, in principle, capable
of performing the same tasks that any other computer can perform. Therefore any type of computer
(netbook, supercomputer, cellular automaton, etc.) is able to perform the same computational tasks,
given enough time and storage capacity.
Page 6 of 17
Page 7 of 17
MICROCONTROLLER
A microcontroller (sometimes abbreviated µC, uC or MCU) is a small computer on a single integrated
circuit containing a processor core, memory, and programmable input/output peripherals. Program
memory in the form of NOR flash or OTP ROM is also often included on chip, as well as a typically small
amount of RAM. Microcontrollers are designed for embedded applications, in contrast to the
microprocessors used in personal computers or other general purpose applications.
Microcontrollers are used in automatically controlled products and devices, such as automobile engine
control systems, implantable medical devices, remote controls, office machines, appliances, power
tools, toys and other embedded systems. 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. Mixed signal microcontrollers are common,
integrating analog components needed to control non-digital electronic systems.
Some microcontrollers may use 4-bit words and operate at clock rate frequencies as low as 4 kHz, for
low power consumption (single-digit 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. Other microcontrollers may serve performancecritical roles, where they may need to act more like a digital signal processor (DSP), with higher clock
speeds and power consumption.
The first microprocessor was the 4-bit Intel 4004 released in 1971, with the Intel 8008 and other more
capable microprocessors becoming available over the next several years. However, both processors
required external chips to implement a working system, raising total system cost, and making it
impossible to economically computerize appliances.
The Smithsonian Institution says TI engineers Gary Boone and Michael Cochran succeeded in creating
the first microcontroller in 1971. The result of their work was the TMS 1000, which went commercial in
1974. It combined read-only memory, read/write memory, processor and clock on one chip and was
targeted at embedded systems.[1]
Partly in response to the existence of the single-chip TMS 1000,[2] Intel developed a computer system
on a chip optimized for control applications, the Intel 8048, with commercial parts first shipping in
1977.[2] It combined RAM and ROM on the same chip. This chip would find its way into over one billion
PC keyboards, and other numerous applications. At that time Intel's President, Luke J. Valenter, stated
that the microcontroller was one of the most successful in the company's history, and expanded the
division's budget over 25%.
Most microcontrollers at this time had two variants. One had an erasable EPROM program memory,
with a transparent quartz window in the lid of the package to allow it to be erased by exposure to
ultraviolet light. The other was a PROM variant which was only programmable once; sometimes this was
Page 8 of 17
signified with the designation OTP, standing for "one-time programmable". The PROM was actually
exactly the same type of memory as the EPROM, but because there was no way to expose it to
ultraviolet light, it could not be erased. The erasable versions required ceramic packages with quartz
windows, making them significantly more expensive than the OTP versions, which could be made in
lower-cost opaque plastic packages. For the erasable variants, quartz was required, instead of less
expensive glass, for its transparency to ultraviolet—glass is largely opaque to UV—but the main cost
differentiator was the ceramic package itself.
In 1993, the introduction of EEPROM memory allowed microcontrollers (beginning with the Microchip
PIC16x84)[citation needed] to be electrically erased quickly without an expensive package as required
for EPROM, allowing both rapid prototyping, and In System Programming. (EEPROM technology had
been available prior to this time, but the earlier EEPROM was more expensive and less durable, making
it unsuitable for low-cost mass-produced microcontrollers.) The same year, Atmel introduced the first
microcontroller using Flash memory, a special type of EEPROM.[3] Other companies rapidly followed
suit, with both memory types.
Cost has plummeted over time, with the cheapest 8-bit microcontrollers being available for under 0.25
USD in quantity (thousands) in 2009,[citation needed] and some 32-bit microcontrollers around 1 USD
for similar quantities. The NXP-LPC810 is a 32 bit ARM CORTEX M0+ in an 8 pin DIP package and sells in
single quantity for £0.66 or $1.00 in 2013.
Nowadays microcontrollers are cheap and readily available for hobbyists, with large online communities
around certain processors.
In the future, MRAM could potentially be used in microcontrollers as it has infinite endurance and its
incremental semiconductor wafer process cost is relatively low.
VolumesAbout 55% of all CPUs sold in the world are 8-bit microcontrollers and microprocessors. According to
Semico, over four billion 8-bit microcontrollers were sold in 2006.[4] More recently, Semico has claimed
the MCU market grew 36.5% in 2010 and 12% in 2011.[5] 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 many
electrical devices such as washing machines, microwave ovens, and telephones.
Embedded design-
Page 9 of 17
A microcontroller can be considered a self-contained system with a processor, memory and peripherals
and can be used as an embedded system.[6] The majority of microcontrollers in use today are
embedded in other machinery, such as automobiles, telephones, appliances, and peripherals for
computer 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.
InterruptsMicrocontrollers must provide real time (predictable, though not necessarily fast) 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, or "interrupt handler"). 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.
ProgramsTypically 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 assemblers are used to
convert high-level language and assembler language codes 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 that may be fieldalterable flash or erasable read-only memory.
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
ultraviolet 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.
Page 10 of 17
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.
A customizable microcontroller incorporates a block of digital logic that can be personalized in order to
provide additional processing capability, peripherals and interfaces that are adapted to the
requirements of the application. For example, the AT91CAP from Atmel has a block of logic that can be
customized during manufacture according to user requirements.
Other microcontroller featuresMicrocontrollers generally contain numerous general purpose input/output pins (GPIO). GPIO pins are
software configurable to either an input or an output state. When GPIO pins are configured to an input
state, they are often used to read sensors or external signals. Configured to the output state, GPIO pins
can drive external devices such as LEDs or motors.
Analog-to-digital converter (ADC) units read analog signals and convert them into digital signals. A less
common feature is the DAC which allows the microcontroller to generate an analog output.
Pulse Width Modulation (PWM) units provide on/off signals on a GPIO pin at a well defined
frequency/duty cycle.
Universal Asynchronous Receiver/Transmitter (USART) units facilitate receiving and transmitting data
over a serial line with very little load on the CPU (such as RS232/RS485).
Timers to generate periodic interrupts or time internal/external events are present on all
microcontrollers[citation needed].
Chip to chip protocols such as SPI and I2C are also common.
Higher integration-
Die of a PIC12C508 8-bit, fully static, EEPROM/EPROM/ROM-based CMOS microcontroller manufactured
by Microchip Technology using a 1200 nanometre process.
Page 11 of 17
Die of a STM32F100C4T6B ARM Cortex-M3 microcontroller with 16 KB flash memory, 24 MHz Central
Processing Unit (CPU), motor control and Consumer Electronics Control (CEC) functions. Manufactured
by STMicroelectronics.
Micro-controllers may not implement an external address or data bus as they integrate RAM and nonvolatile 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 and 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, in addition to tending to decrease the defect rate
for the finished assembly.
A micro-controller 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
volatile memory (RAM) for data storage
ROM, EPROM, EEPROM or Flash memory for program and operating parameter storage
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
clock generator - often an oscillator for a quartz timing crystal, resonator or RC circuit
many include analog-to-digital converters, some include digital-to-analog converters
in-circuit programming and debugging support
USB and Ethernet are common on high end microcontrollers.
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, on low
pin count devices in particular, each pin may interface to several internal peripherals, with the pin
Page 12 of 17
function selected by software. This allows a part to be used in a wider variety of applications than if pins
had dedicated functions. Micro-controllers 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 micro-controller instruction set usually has many instructions intended
for bit-wise operations to make control programs more compact.[7] 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
micro-controller could have a single instruction to provide that commonly required function.
Microcontrollers typically do not have a math coprocessor, so floating point arithmetic is performed by
software.
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;[8] BASIC and FORTH on the Zilog Z8[9] as well as some modern devices.
Typically these interpreters support interactive programming.
Page 13 of 17
Simulators are available for some microcontrollers. 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 incircuit emulator via JTAG, allow debugging of the firmware with a debugger.
Types of microcontrollers-
See also: List of common microcontrollers
As of 2008 there are numerous microcontroller architectures and vendors including:
65802 and 65816
8051 (many variations and vendors of original Intel-product)
ARM (many vendors) and ARM Cortex-M, specifically targeted towards microcontroller applications
Atmel AVR (8-bit), AVR32 (32-bit), and AT91SAM (32-bit)
Cypress Semiconductor's M8C Core used in their PSoC (Programmable System-on-Chip)
eZ8 8-bit based family of microcontrollers
eZ80 8/16/24-bit family of microcontrollers and microprocessors
Freescale ColdFire (32-bit) and S08 (8-bit)
Freescale 68HC11 (8-bit)
Infineon: 8-bit XC800, 16-bit XE166, 32-bit XMC4000 (ARM based Cortex M4F), 32-bit TriCore and, 32-bit
Aurix Tricore Bit microcontrollers[10]
MIPS
Microchip Technology PIC, (8-bit PIC16, PIC18, 16-bit dsPIC33 / PIC24), (32-bit PIC32)
NXP Semiconductors LPC1000, LPC2000, LPC3000, LPC4000 (32-bit), LPC900, LPC700 (8-bit)
Parallax Propeller
PowerPC ISE
Page 14 of 17
Rabbit 2000 (8-bit)
Renesas Electronics: RL78 16-bit MCU; RX 32-bit MCU; SuperH; V850 32-bit MCU; H8; R8C 16-bit MCU
Silicon Laboratories Pipelined 8-bit 8051 Microcontrollers and mixed-signal ARM-based 32-bit
microcontrollers
STMicroelectronics STM8 (8-bit), ST10 (16-bit) and STM32 (32-bit)
Texas Instruments TI MSP430 (16-bit) C2000 (32-bit)
Toshiba TLCS-870 (8-bit/16-bit).
Many others exist, some of which are used in very narrow range of applications or are more like
applications processors than microcontrollers. The microcontroller market is extremely fragmented,
with numerous vendors, technologies, and markets. Note that many vendors sell or have sold multiple
architectures.
Interrupt latency-
In contrast to general-purpose computers, microcontrollers used in embedded systems often seek to
optimize interrupt latency over instruction throughput. Issues include both reducing the latency, and
making it be more predictable (to support real-time control).
When an electronic device causes an interrupt, the intermediate results (registers) have to be saved
before the software responsible for handling the interrupt can run. They must also be restored after that
software is finished. If there are more registers, this saving and restoring process takes more time,
increasing the latency. Ways to reduce such context/restore latency include having relatively few
registers in their central processing units (undesirable because it slows down most non-interrupt
processing substantially), or at least having the hardware not save them all (this fails if the software then
needs to compensate by saving the rest "manually"). Another technique involves spending silicon gates
on "shadow registers": One or more duplicate registers used only by the interrupt software, perhaps
supporting a dedicated stack.
Other factors affecting interrupt latency include:
Cycles needed to complete current CPU activities. To minimize those costs, microcontrollers tend to
have short pipelines (often three instructions or less), small write buffers, and ensure that longer
instructions are continuable or restartable. RISC design principles ensure that most instructions take the
same number of cycles, helping avoid the need for most such continuation/restart logic.
The length of any critical section that needs to be interrupted. Entry to a critical section restricts
concurrent data structure access. When a data structure must be accessed by an interrupt handler, the
critical section must block that interrupt. Accordingly, interrupt latency is increased by however long
Page 15 of 17
that interrupt is blocked. When there are hard external constraints on system latency, developers often
need tools to measure interrupt latencies and track down which critical sections cause slowdowns.
One common technique just blocks all interrupts for the duration of the critical section. This is easy to
implement, but sometimes critical sections get uncomfortably long.
A more complex technique just blocks the interrupts that may trigger access to that data structure. This
is often based on interrupt priorities, which tend to not correspond well to the relevant system data
structures. Accordingly, this technique is used mostly in very constrained environments.
Processors may have hardware support for some critical sections. Examples include supporting atomic
access to bits or bytes within a word, or other atomic access primitives like the LDREX/STREX exclusive
access primitives introduced in the ARMv6 architecture.
Interrupt nesting. Some microcontrollers allow higher priority interrupts to interrupt lower priority ones.
This allows software to manage latency by giving time-critical interrupts higher priority (and thus lower
and more predictable latency) than less-critical ones.
Trigger rate. When interrupts occur back-to-back, microcontrollers may avoid an extra context
save/restore cycle by a form of tail call optimization.
Lower end microcontrollers tend to support fewer interrupt latency controls than higher end ones.
Microcontroller embedded memory technology-
Since the emergence of microcontrollers, many different memory technologies have been used. Almost
all microcontrollers have at least two different kinds of memory, a non-volatile memory for storing
firmware and a read-write memory for temporary data.
DataFrom the earliest microcontrollers to today, six-transistor SRAM is almost always used as the read/write
working memory, with a few more transistors per bit used in the register file. MRAM could potentially
replace it as it is 4 to 10 times denser which would make it more cost effective.
In addition to the SRAM, some microcontrollers also have internal EEPROM for data storage; and even
ones that do not have any (or not enough) are often connected to external serial EEPROM chip (such as
the BASIC Stamp) or external serial flash memory chip.
A few recent microcontrollers beginning in 2003 have "self-programmable" flash memory.[3]
Firmware-
Page 16 of 17
The earliest microcontrollers used mask ROM to store firmware. Later microcontrollers (such as the
early versions of the Freescale 68HC11 and early PIC microcontrollers) had quartz windows that allowed
ultraviolet light in to erase the EPROM.
The Microchip PIC16C84, introduced in 1993,[11] was the first microcontroller to use EEPROM to store
firmware. In the same year, Atmel introduced the first microcontroller using NOR Flash memory to store
firmware.[3]
Page 17 of 17