Intro to Embedded Systems

Introduction to Embedded Systems

• Embedded systems are specialized computers designed for specific tasks within a larger system.
• They are integrated into the devices they control, such as microwaves or car engines.
• Embedded systems require minimal user interaction and are optimized for efficiency, reliability, and low cost.
• They can be thought of as the hidden brains of everyday devices, doing one or a few jobs perfectly.
• Unlike general-purpose computers, embedded systems do not require a screen or keyboard.
• Mnemonic: FLEA = Firmware, Low-cost, Embedded, Application-specific
• Automotive ABS, medical pacemakers, and consumer thermostats all utilize embedded systems.
• A washing machine's chip that controls water flow and spin cycles is an example of an embedded system.

General-Purpose Computers

• General-purpose computers are designed to run a wide variety of software, like games, browsers, and word processors.
• These computers utilize high-performance hardware, such as fast CPUs, large RAM, and big storage.
• They require a sophisticated operating system such as Windows, Linux, or iOS.
• Peripherals like displays, keyboards, mice, and internet connectivity are essential.
• These computers are expensive, costing $100s–$1000s, and use multiple integrated circuits (ICs) for CPU, memory, and storage.
• Mnemonic: HUGE = High-performance, User-interactive, General, Expensive
• Smartphones, laptops, and desktop workstations are examples of general-purpose computers.
• A laptop running Zoom, Chrome, and a game simultaneously exemplifies the capabilities of general-purpose computers.

Embedded Computers

• Embedded computers are compact systems, often implemented on a single chip.
• They contain a CPU, memory, and peripherals like timers, ADCs (analog-to-digital converters), DACs (digital-to-analog converters), and serial interfaces.
• These computers run firmware (software not meant to be changed often).
• Some embedded computers may use a Real-Time Operating System (RTOS) for task scheduling.
• Embedded computers are low-cost (10s of cents to a few dollars), small, and versatile for specific applications.
• Mnemonic: SLIM = Single-chip, Low-cost, Integrated peripherals, Minimal software
• A smart thermostat chip controlling temperature with a sensor and timer exemplifies an embedded computer.

Embedded vs. General-Purpose Comparison

• Embedded computers are designed for specific tasks, while general-purpose computers are designed for many tasks.
• Embedded computers use a single chip (CPU + memory + peripherals), while general-purpose computers use multiple chips (CPU, RAM, storage).
• Embedded computers run firmware or an optional RTOS, while general-purpose computers use a sophisticated OS (Windows, Linux).
• Embedded computers cost cents to dollars, and general-purpose computers cost $100s to $1000s.
• Embedded computers have minimal user interaction, while general-purpose computers have heavy user interaction.
• Embedded systems prioritize efficiency and reliability, while general-purpose systems prioritize flexibility and user experience.

Computer Definitions

• A computer is a combination of hardware (physical components) and software (instructions) working together to perform tasks.
• Software is a sequence of instructions (called a program) that tells the hardware what to do.
• An operation code (op-code) is a binary code representing a specific instruction (e.g., 1010 might mean "move data").
• The instruction set is the collection of all op-codes a CPU can execute.
• The programmer is the person who writes the software by choosing instructions.
• Mnemonic: SHIP = Software (instructions), Hardware (components), Instruction set (op-codes), Programmer (writes code).

Hardware Overview

• A computer’s hardware includes program memory, data memory, a central processing unit (CPU), input/output (I/O) ports, and a bus system.
• Program memory stores instructions, is read-only during execution, and is non-volatile (e.g., EEPROM).
• Data memory holds temporary variables, is read/write, and is volatile (e.g., RAM).
• The central processing unit (CPU) executes instructions using a control unit, registers, and an arithmetic logic unit (ALU).
• Input/Output (I/O) ports connect to external devices (e.g., sensors, displays). They can be either parallel (fast, multi-bit) or serial (slower, single-bit).
• The bus system routes signals between the CPU, memory, and I/O ports.
• Mnemonic: PICS = Program memory, IO ports, CPU, System bus

Program and Data Memory

• Program Memory is non-volatile (e.g., EEPROM, flash) and stores firmware or instructions.
• It is treated as read-only during execution to avoid accidental changes.
• Data Memory is volatile (e.g., RAM) and used for temporary variables created during program execution.
• It allows both reading and writing of data.
• Mnemonic: PRAM = Program (Read-only, Non-volatile), RAM (Read/Write, Volatile)

Central Processing Unit (CPU)

• The CPU fetches instructions from program memory, decodes them, and executes them.
• Control Unit - A finite state machine that manages the fetch-decode-execute cycle.
• Registers are small, fast storage for data, status, and addresses.
• Important registers include the Program Counter (PC), Stack Pointer (SP), Status Register (SR), Instruction Register (IR), and general-purpose registers.
• The Arithmetic Logic Unit (ALU) performs mathematical (e.g., addition, subtraction) and logical operations (e.g., AND, OR), setting status flags.
• Mnemonic: CAR = Control unit, ALU, Registers

Bus System

• Memory Address Bus (MAB) carries addresses from the CPU to memory or I/O ports.
• It specifies where to read or write data.
• Memory Data Bus (MDB) transfers data between the CPU, memory, and I/O ports.
• Memory Map: A table defining address ranges for program memory, data memory, and I/O ports.
• Mnemonic: MAD = MAB (Address bus), Data bus, Memory map

Input/Output (I/O) Ports

• I/O ports connect the computer to external devices (e.g., sensors, displays, motors).
• Ports can be input (receive data), output (send data), or bidirectional (both input and output).
• Parallel ports transfer multiple bits at once (fast), while serial ports transfer one bit at a time (slower).
• Mnemonic: PINS = Parallel (fast), Input, Not serial, System interface

RISC vs. CISC

• RISC (Reduced Instruction Set Computer) uses a small number of simple instructions.
• This makes the CPU smaller, faster, and more power-efficient.
• RISC requires more instructions to complete complex tasks.
• CISC (Complex Instruction Set Computer) uses a large number of complex instructions.
• This allows fewer instructions for tasks but makes the CPU larger and slower.
• Mnemonic: RC = RISC (Reduced, fast), CISC (Complex, large)

Classes of Instructions

• Data Movement Instructions move data between CPU registers, memory, or I/O ports without using the ALU (e.g., mov src, dst copies data from source to destination).
• Data Manipulation Instructions use the ALU for arithmetic (e.g., add, subtract) or logical operations (e.g., AND, XOR, inc increments a value).
• Program Flow Instructions change the Program Counter (PC) for loops or conditions.
• Unconditional flow instructions which always jump to a new address (e.g., jmp).
• Conditional flow instructions which only jump if a condition is met (e.g., jz jumps if zero flag is set).
• Mnemonic: MFP = Movement (data), Flow (control), Processing (calculations)

Op-codes and Operands

• An Op-code is a unique binary code for each instruction (e.g., 0100 for mov).
• A Mnemonic is a human-readable name for the op-code (e.g., mov, add).
• The Operand is additional information needed (e.g., src and dst in mov src, dst).
• Assembly Language uses mnemonics to write programs (e.g., mov R1, R2).
• An Assembler translates mnemonics to binary op-codes.
• Mnemonic: MOA = Mnemonic (name), Op-code (binary), Assembler (translator)

Program Development Flow

• Write code in a High-Level Language (C): (e.g., x = y + 1), then compile to assembly by a compiler.
• Write in Assembly Language using mnemonics (e.g., add R1, R2), then translate to op-codes by an assembler
• The Linker Combines multiple source files (e.g., C and assembly) and assigns final memory addresses.
• Then Debug by running the program step-by-step, showing register and memory values.
• Finally output an executable file (e.g., for MSP430) loaded via an EEPROM programmer.
• Mnemonic: CALD = Compiler (C to assembly), Assembler (mnemonics to binary), Linker (combines files), Debugger (tests code)

Applications of Embedded Systems

• Automotive: Engine control units, anti-lock braking systems (ABS), airbag controllers
• Medical: Pacemakers, blood glucose monitors, imaging systems
• Consumer Electronics: Microwaves, smart thermostats, fitness trackers
• Mnemonic: ARC = Automotive, Reliable, Consumer

Challenges of Embedded Systems

• Low Power: Must run on batteries or minimal energy (e.g., smartwatch).
• Reliability: Cannot fail in critical applications (e.g., medical devices).
• Real-Time Constraints: Must respond instantly (e.g., automotive sensors).
• Size/Cost: Must be small and cheap for mass production.
• Mnemonic: PRCS = Power (low), Reliability, Constraints (real-time), Size/cost.