Single-board microcontroller

From Wikipedia, the free encyclopedia
Jump to: navigation, search
The Make Controller Kit with an Atmel AT91SAM7X256 (ARM) microcontroller.

A single-board microcontroller is a microcontroller built onto a single printed circuit board. This board provides all of the circuitry necessary for a useful control task: microprocessor, I/O circuits, clock generator, RAM, stored program memory and any support ICs necessary. The intention is that the board is immediately useful to an application developer, without them needing to spend time and effort in developing the controller hardware.

As they are usually low-cost hardware, and have an especially low capital cost for development, single-board microcontrollers have long been popular in education. They are also a popular means for developers to gain hands-on experience with a new processor family.

Origins[edit]

Single-board microcontrollers appeared in the late 1970s when the first generations of microprocessors, such as the 6502 and the Z80,[1] made it practical to build an entire controller on a single board, and affordable to dedicate a computer to a relatively minor task.

In March 1976, Intel announced a single-board computer product that integrated all the support components required for their 8080 microprocessor, along with 1 kbyte of RAM, 4 kbytes of user-programmable ROM, and 48 lines of parallel digital I/O with line drivers. The board also offered expansion through a bus connector, but it could be used without an expansion card cage where applications didn't require additional hardware. Software development for this system was hosted on Intel's Intellec MDS microcomputer development system; this provided assembler and PL/M support, and permitted in-circuit emulation for debugging.[2]

Processors of this era required a number of support chips in addition. RAM and EPROM were separate, often requiring memory management or refresh circuitry for dynamic memory as well. I/O processing might be carried out by a single chip such as the 8255, but frequently required several more chips.

A single-board microcontroller differs from a single-board computer in that it lacks the general purpose user interface and mass storage interfaces that a more general-purpose computer would have. Compared to a microprocessor development board, a microcontroller board would emphasize digital and analog control interconnections to some controlled system, where a development board might by comparison have only a few or no discrete or analog input/output devices. The development board exists to showcase or to train on some particular processor family and this internal implementation is more important than the external function.

Internal bus[edit]

The bus of the early single-board devices, such as the Z80 and 6502, was universally a Von Neumann architecture. Program and data memory were accessed by the same shared bus, even though they were stored in fundamentally different types of memory: ROM for programs and RAM for data. This bus architecture was needed to economise on the number of pins needed from the limited 40 available for the processor's ubiquitous dual-in-line IC package.

It was common to offer the internal bus through an expansion connector, or at least the space for such a connector to be soldered on. This was a low-cost option and offered the potential for expansion, even if it was rarely made use of. Typical expansions would be I/O devices, or memory expansion. It was unusual to add peripheral devices such as tape or disk storage, or even a CRT display

When single-chip microcontrollers, such as the 8048, became available later on, the bus no longer needed to be exposed outside the package as all the necessary memory could be provided within the chip package. This generation of processors used a Harvard architecture of separate program and data buses, both internal to the chip. Many of these processors used a modified Harvard architecture, where some write access was possible to the program data space, thus permitting in-circuit programming. None of these processors required, or supported, a Harvard bus across a single-board microcontroller. Where they supported a bus for expansion of peripherals, this used a dedicated I/O bus, such as I2C, One-wire or various serial buses.

External bus expansion[edit]

Some microcontroller boards using a general-purpose microprocessor can bring the address and data bus of the processor to an expansion connector, allowing additional memory or peripherals to be added. This would provide resources not already present on the single board system. Since not all systems require expansion, the connector may be an option, with a mounting position provided for the connector for installation by the user if desired.

Input and output[edit]

Arduino Diecimila with Atmel ATMEGA168

Microcontroller systems provide multiple forms of input and output signals to allow application software to control an external "real-world" system. Discrete digital I/O provides a single bit of data (on, or off). Analog signals, representing a continuously variable range such as temperature or pressure, can also be inputs and outputs for microcontrollers.

Discrete digital inputs and outputs might only be buffered from the microprocessor data bus by an addressable latch, or might be operated by a specialized input/output integrated circuit such as an Intel 8255 or Motorola 6821 parallel input/output adapter. Later single-chip micrcontrollers have input and output pins available. The input/output circuits usually do not provide enough current to directly operate such devices as lamps or motors, so solid-state relays are operated by the microcontroller digital outputs, and inputs are isolated by signal conditioning level-shifting and protection circuits.

One or more analog inputs, with an analog multiplexer and common analog to digital converter, are found on some microcontroller boards. Analog outputs may use a digital-to-analog converter, or on some microcontrollers may be controlled by pulse-width modulation. As for discrete inputs, external circuits may be required to scale inputs, or to provide such functions as bridge excitation or cold junction compensation.

To control component costs, many boards were designed with extra hardware interface circuits but the components for these circuits weren't installed and the board was left bare. The circuit was only added as an option on delivery, or could be populated later.

It is common practice for boards to include "prototyping areas", areas of the board already laid out as a solderable breadboard area with the bus and power rails available, but without a defined circuit. Several controllers, particularly those intended for training, also include a pluggable re-usable breadboard for easy prototyping of extra I/O circuits that could be changed or removed for later projects.

Communications and user interfaces[edit]

Communications interfaces vary depending on the age of the microcontroller system. Early systems might implement a serial port to provide RS-232 or current loop. The serial port could be used by the application program, or could be used, in conjunction with a monitor ROM, to transfer programs into the microcontroller memory. Current microcontrollers may support USB, wireless network (Wi-Fi, ZigBee, or others) ports, or provide an Ethernet connection, and may support a TCP/IP protocol stack. Some devices have firmware available to implement a Web server, allowing an application developer to rapidly build a Web-enabled instrument or system.

Programming[edit]

Many of the earliest systems had no internal facility for programming at all, and relied on a separate "host" system. This programming was typically in assembly language, sometimes C or even PL/M, and then cross-assembled or cross-compiled on the host. Some single-board microcontrollers support a BASIC language system, allowing programs to be developed on the target hardware. Hosted development allows all the storage and peripherals of a desktop computer to be used, providing a more powerful development environment.

EPROM burning[edit]

Early microcontrollers relied on erasable programmable read-only memory (EPROM) devices to hold the application program. The completed object code from a host system would be "burned" onto an EPROM with an EPROM programmer,[3] this EPROM was then physically plugged into the board. As the EPROM would be removed and replaced many times during program development, it was usual to provide a ZIF socket to avoid wear or damage. Erasing an EPROM with a UV eraser takes a considerable time, and so it was also usual for a developer to have several EPROMs in circulation at any one time.

Some microcontroller devices were available with on-board EPROM; these, too, would be programmed in a separate burner, then put into a socket on the target system.

The use of EPROM sockets allowed field update of the application program, either to fix errors or to provide updated features.

Keypad monitors[edit]

A single-board computer with a hex keypad and 7-segment display

Where the single-board controller formed the entire development environment (typically in education) the board might also be provided with a simple hexadecimal keypad, calculator-style LED display and a "monitor" program set permanently in ROM. This monitor allowed machine code programs to be entered directly through the keyboard and held in RAM. These programs were in machine code, not even in assembly language, and were assembled by hand on paper first. It's arguable as to which process was more time-consuming and error prone: assembling by hand, or keying byte-by-byte.

Single-board "keypad and calculator display" microcontrollers of this type were very similar to some low-end microcomputers of the time, such as the KIM-1 or the Microprofessor I.[4] Some of these microprocessor "trainer" systems are still in production today, as a very low-cost introduction to microprocessors at the hardware programming level.[5]

Hosted development[edit]

When desktop personal computers appeared, initially CP/M or Apple II, then later the IBM PC and compatibles, there was a shift to hosted development. Hardware was now cheaper and RAM capacity had expanded such that it was possible to download the program through the serial port and hold it in RAM. This massive reduction in the cycle time to test a new version of a program gave an equally large boost in development speed.

This program memory was still volatile and would be lost if power was turned off. Flash memory was not yet available at a viable price. As a completed controller project usually required to be non-volatile, the final step in a project was often to burn an EPROM again.

Single-chip microcontrollers[edit]

A 8048-family microcontroller with on-board UV EPROM, the 8749
A development board for a PIC family device

Single-chip microcontrollers such as the 8748 combined many of the features of the previous boards into a single IC package. Single-chip microcontrollers integrate memory (both RAM and ROM) on-package and so do not need to expose the data and address bus through the IC package's pins. These pins are then available for I/O lines. These changes reduce the area required on a printed circuit board and simplify the design of a single-board microcontroller. Examples of single-chip microcontrollers include:

Program memory[edit]

For production use as embedded systems, the on-board ROM would be either mask programmed at the chip factory or one-time programmed (OTP) by the developer as a PROM. PROMs often used the same UV EPROM technology for the chip, but in a cheaper package without the transparent erasure window. During program development it was still necessary to burn EPROMs, this time the entire controller IC, and so ZIF sockets would be provided.

With the development of affordable EEPROM, EAROM and eventually flash memory, it became practical to attach the controller permanently to the board and to download program code to it through a serial connection to a host computer. This was termed "in-circuit programming". Erasure of old programs was carried out by either over-writing them with a new download, or bulk erasing them electrically (for EEPROM) which was slower, but could be carried out in-situ.

The main function of the controller board was now to carry the support circuits for this serial interface, or USB on later boards. As a further convenience feature during development, many boards also carried low-cost features like LED monitors of the I/O lines or reset switches mounted on board.

Single-board microcontrollers today[edit]

Dwengo board

Microcontrollers are now cheap and simple to design circuit boards for. Development host systems are also cheap, especially when using open source software. Higher level programming languages abstract details of the hardware, making differences between specific processors less obvious to the application programmer. Rewritable flash memory has replaced slow programming cycles, at least during program development. Accordingly almost all development now is based on cross-compilation from personal computers and download to the controller board through a serial-like interface, usually appearing to the host as a USB device.

The original market demand of a simplified board implementation is no longer so relevant to microcontrollers. Single-board microcontrollers are still important, but have shifted their focus to:

  • Easily accessible platforms aimed at traditionally "non-programmer" groups, such as artists, designers, hobbyists, and others interested in creating interactive objects or environments.[6] Some typical projects in 2011 included; the backup control of DMX stage lights and special effects, multi-camera control, autonomous fighting robots, controlling bluetooth projects from a computer or smart phone,[7] LEDs and multiplexing, displays, audio, motors, mechanics, and power control.[8] These controllers may be embedded to form part of a physical computing project. Popular choices for this work are the Arduino,[9] Dwengo[7] or the Wiring (development platform).[10][11]
  • Technology demonstrator boards for innovative processors or peripheral features:


See also[edit]

References[edit]

  1. ^ Peter Grigson; David Harris (August, September, October 1983). "'Marvin' - Z80 Control Computer". Electronics Today International. 
  2. ^ Intel SBC 80/10 Single Board Computer brochure, 1976
  3. ^ Mike Bedford (August, September 1983). "Universal EPROM Programmer". Electronics Today International: 45–51, 37–39. 
  4. ^ "KIM 1". Old Computers.com. 
  5. ^ "Microprofessor Training System". Flite Electronics International. 
  6. ^ Arduino's home page
  7. ^ a b "Project homepage". Dwengo. 
  8. ^ Arduino User's forum
  9. ^ "Project homepage". Arduino project. 
  10. ^ Wiring.org's Wiring development platform home page
  11. ^ "Wiring: Hardware". Wiring project. 

External links[edit]