Computer systems are essentially split in two categories. The first and most obvious category is that of personal computers. The second one is that of embedded computers. Even if every house has al least 10 embedded computers, this last category is far less obvious. Just think that your TV, DVD, cell phone, washing machine, even your children’s toys are simple embedded systems.

The main difference between these two systems is their application domain. They both have a processor, some types of memories and several forms of specific inputs and outputs.

Embedded computers are dedicated to a specific task. The steps for building an embedded system (development board) for a particular application are described bellow.

1. Selecting the CPU
The processor is the heart of any computer system. It’s a hardware device which manages the entire embedded system. Firmware is a special program that resides on the internal memory of the CPU (mostly ROM, Flash or EEPROM memories). Firmware is somewhere between hardware and software.

Fig.1 System Architectures

Microprocessors (or CPUs – based on CISC architecture) are single chip implementation. There are a lot of companies that develop CPUs (Intel, ARM, Sun SPARC), but these are designed for large-scale applications. Probable you won't use these processors for your home made system because of high complexity.

The microprocessor’s architecture defines the instruction set and programmer’s model for any processor that will be based on that architecture. Different processor implementations may be built to comply with the architecture. Each processor may vary in performance and features and may be optimized to target different applications.

Fig.2 AT91SAM9260 block diagram (including an ARM9 CISC core)

Microcontrollers are processors with memory and peripherals on the same chip. The common and easy to use microcontrollers are PICs (from Microchip) and AVRs (from Atmel). PIC16F86A microcontroller from Microchip has a RISC architecture (slow/medium complexity and relative low number of instructions).

The compiler is essential for the microcontroller systems. It can optimize the code so the software will perform faster. The RISC architecture has low complexity and it is much easier to program. That’s why it’s the excellent choice for many applications.
Short Description of RISC CPU PIC16F84A:

- 35 single word instructions
- Operating speed: DC - 20 MHz clock input
- 1024 words of program memory
- 68 bytes of Data RAM
- 64 bytes of Data EEPROM
- 13 I/O pins with individual direction control
- TMR0: 8-bit timer/counter with 8-bit programmable prescaler.

Fig.3 PIC18F84 RISC Architecture

2. Selecting the Power Supply
The power supply must be selected in concordance with the system needs. If it should be a portable application then we need to take into consideration that a battery will be enough to supply the board (this means maximum effectiveness for power supply). More complex systems can consider using a switched-mode power supply, like the Buck or Boost converter, which has a remarkable efficiency (up to 95%).

Fig.4 LTC3822 Switched-Mode Power Supply

Another solution is the linear regulator. It is easily to implement and it has much better noise and drift characteristics than the switching regulator. It has also a big disadvantage: inefficiency; a lot of energy is dissipated as heat and this is the reason that you’ll always see large heat-sinks in many power sources.

Fig.5 Linear Power Supply

3.Adding peripherals to your board
External Memory

- 16bits data lines: AD[15:0] (shared with 16 bits of address lines)
- 4bits additional for address bus: A[19:16]
- CE/ signal for enabling the memory chip
- OE/ signal for read operation
- WR/ for write operation
- Memory Chip: EPROM, SRAM, FLASH

Fig.6 External Memory Interface

I2C Devices

I2C (Inter-Integrated Circuit) was first developed by Philips. The physical interface for the I2C bus consists of 2 open drain lines: SCL (clock) and SDA (data). The I2C bus can have one master and multiple slaves or more masters. The master is the device that generates clock for slaves. Devices connected on I2C: memories, sensors, analog to digital converters.

Fig.7 I2C Device Interface

SPI Devices

SPI (Serial Peripheral Interface) Bus operates in full duplex mode, unlike I2C which supports a half duplex communication.
SPI has 4 lines:

- SCLK – clock
- MOSI (or SDI) – master output, slave input
- MISO (or SDO) – master input, slave output
- SS – slave select

Fig.8 SPI Device Interface

CAN Bus Communication
CAN (Controller Area Network) is a serial communication bus with a linear structure. The CAN protocol reaches a speed up to 1Mbit/sec which makes it the perfect communication channel for automotive industry. CAN is CSMA/CD (Carrier Sense Multiple Access/Collision Detection): every node must monitor the bus for a period of no activity before sending a message on bus (carrier sense) and every node has an equal opportunity to transmit (multiple access). If 2 nodes transmit in the same time a collision detection scenario will occur. The CAN bus interface uses a transceiver and a controller. Controllers are usually incorporated within microcontroller chip.

Fig.9 Sensor CAN Interface

Use your imagination to add new peripherals on your development board. I just want to mention some of them that I have used in the past:
a. RS232 interface communication.

Fig.10 RS232 Interface

b. USB interface communication.

Fig.11 USB Interface

c. LCD/GLCD & keypad.

Fig.12 LCD Interface

d. DC brushless & stepper motors.

Fig.13 Brushless Motor Control

e. ADC & DAC.

Fig.14 External A/D Converter Interface

f. RF & ZigBee communication.

Fig.15 rfRXD0420 Receiver Module

g. A lot of sensors: temperature, pressure, humidity, luminosity, gas, etc.
F

Fig.16 Temperature Sensing Using an Integrator

It’s a great experience and a big satisfaction when you build the development board with your hand and then try to program the CPU for controlling it.