FPGA/ASIC Memory SOFTWARE

PS

Sensors ADC CPU DAC Actuators

Human Diagnostic Auxilliary

Interface Tools Systems/
Cooling/Packing

Electromechanical Backup
and safety

External environment
 System

• A system is an arrangement in which all its unit

assemble work together according to a set of
rules. It can also be defined as a way of working,
organizing or doing one or many tasks according
to a fixed plan.
• For example, a watch is a time displaying system.
Its components follow a set of rules to show
time. If one of its parts fails, the watch will stop
working. So we can say, in a system, all its
subcomponents depend on each other.
 Embedded System

• Embedded systems is an encapsulation of H/W and S/W which is designed to

perform specific dedicated task. An embedded system can be thought of as a
computer hardware system having software embedded in it.
• An embedded system can be an independent system or it can be a part of a large
system.
• An embedded system is a microcontroller or microprocessor based system which
is designed to perform a specific task. For example, a fire alarm is an embedded
system; it will sense only smoke.

• An embedded system has three components −

• It has hardware.
• It has application software.
• It has Real Time Operating system (RTOS) that supervises the application software
and provide mechanism to let the processor run a process as per scheduling by
following a plan to control the latencies. RTOS defines the way the system works.
It sets the rules during the execution of application program. A small scale
embedded system may not have RTOS.
 Building Blocks of an ES
• Sensor − It measures the physical quantity and converts it
to an electrical signal which can be read by an observer or
by any electronic instrument like an A2D converter. A
sensor stores the measured quantity to the memory.
• A-D Converter − An analog-to-digital converter converts
the analog signal sent by the sensor into a digital signal.
• Processor & ASICs − Processors process the data to
measure the output and store it to the memory.
• D-A Converter − A digital-to-analog converter converts the
digital data fed by the processor to analog data
• Actuator − An actuator compares the output given by the
D-A Converter to the actual (expected) output stored in it
and stores the approved output.
Peripherals in Microcontrollers
SENSORS
Power Source
Raspberry Pi-4 B+
 Raspberry Pi 4-B+
• Broadcom BCM2711, Quad core Cortex-A72 (ARM v8) 64-bit SoC @ 1.5GHz
• 1GB, 2GB, 4GB or 8GB LPDDR4-3200 SDRAM (depending on model)
• 2.4 GHz and 5.0 GHz IEEE 802.11ac wireless, Bluetooth 5.0, BLE
• Gigabit Ethernet
• 2 USB 3.0 ports; 2 USB 2.0 ports.
• Raspberry Pi standard 40 pin GPIO header (fully backwards compatible with previous boards)
• 2 × micro-HDMI ports (up to 4kp60 supported)
• 2-lane MIPI DSI display port
• 2-lane MIPI CSI camera port
• 4-pole stereo audio and composite video port
• H.265 (4kp60 decode), H264 (1080p60 decode, 1080p30 encode)
• Micro-SD card slot for loading operating system and data storage
• 5V DC via USB-C connector (minimum 3A*)
• 5V DC via GPIO header (minimum 3A*)
• Power over Ethernet (PoE) enabled (requires separate PoE HAT)
• Operating temperature: 0 – 50 degrees C ambient
ARDUINO UNO
 Arduino Uno Specifications
• Microcontroller: ATmega328P 
• Operating Voltage: 5V 
• Input Voltage (recommended): 7-12V 
• Inout Voltage (limit): 6-20V 
• Digital I/O Pins: 14 (of which 6 provide PWM output) 
• PWM Digital I/O Pins: 6 
• Analog Input Pins: 6 
• DC Current per I/O Pin: 20 mA 
• DC current for 3.3V Pin: 50 mA 
• Flash Memory: 32 KB (ATmega328P) of which 0.5 KB used by bootloader
• SRAM: 2 KB (ATmega328P)
• EEPROM: 1 KB (ATmega328P)
• Clock Speed: 16 MHz
• LED_BUILTIN: 13
• Length: 68.6 mm 
• Width: 58.4 mm 
• Weight: 25 g 
 ARM7 LPC 2148 FEATURES
• Advanced RISC Machine (ARM) is a PERFORMANCE ORIENTED processor architecture based on a 32-bit reduced
instruction set (RISC) computer.
• ARM features include:

• 32 BIT UC
• 32 BIT ALU
• 32 BIT DATABUS
• 32 BIT ADDRESS BUS
• 32 BIT INSTRUCTIONS
• Von Neumann model
• 3 stage pipelining- EACH instruction has same size
• 37 register 32 bit each
• 7 operating modes
• 7 Interrupts / Exceptions
• 7 addressing modes
• 3 data formats
• Load/store-based architecture
• Single-cycle instruction execution
• Link register
• Easy decoding and pipelining
• Power-indexed addressing modes
• Fixed 32-bit instruction set
 ARM Instruction set
• ARM mostly comes with 2 instruction set
• 32 bit ARM instruction set
• 16 bit thumb instruction set
• In addition to above 2 instructions sets
ARM also implements JAZELLE instruction
set that is used in concepts that use JAVA.
Von neumann model
RISC VS CISC
 RISC VS CISC
• At first, this may seem like RISC is much
less efficient way of completing the
operation. Because there are more lines
of code, more RAM is needed to store the
assembly level instructions.
• The compiler must also perform more
work to convert a high-level language
statement into code of this form.
 Advantages of RISC
• However, the RISC strategy also brings some very
important advantages. Because each instruction
requires only one clock cycle to execute, the entire
program will execute in approximately the same
amount of time as the multi-cycle "MULT" command.
• These RISC "reduced instructions" require less
transistors of hardware space than the complex
instructions, leaving more room for general purpose
registers.
• In RISC Architecture all instructions are same size.
• Because all of the instructions execute in a uniform
amount of time (i.e. one clock), pipelining is possible
with RISC Architecture.
 Advantages of RISC
• Separating the "LOAD" and "STORE"
instructions actually reduces the amount of
work that the computer must perform.
• After a CISC-style "MULT" command is
executed, the processor automatically
erases the registers. If one of the operands
needs to be used for another computation,
the processor must re-load the data from
the memory bank into a register.
• In RISC, the operand will remain in the
register until another value is loaded in its
place.
PIPELINING
 PIPELINING
• The four stages are Instruction fetch (IF) from memory, Instruction decode
(ID) in CPU, Instruction execution (IE) in ALU and Result writing (RW) in
memory or Register. Since there are four stages, all the instructions pass
through the four stages to complete the instruction execution.
• Instruction 1 gets completed in t4.
• At t1, while Instruction1 is in IF stage, that being the first stage for any
execution, there is no possibility of overlapping another instruction.
• Thus when Instruction1 moves on to stage 2 (ID)at t2, second instruction
enters the pipeline at IF stage.
• You may observe at t2, there are two stages busy with one each
instruction. Similarly, at t3, I1 and I2 move on to IE and ID stages
respectively and I3 enters IF and so on.
• You may observe that from t4 onwards maximum stages are utilised until
the instruction in-flow.
• After t4, executed instructions leave the pipeline one in each timing state.
Refer to the phase diagram to observe that from timing state t5, one each
instruction completes the execution and out of pipeline paving way for
new instructions if any to enter in.
The family of ARM processors is based
on the RISC architecture
ARM solutions are dedicated to the needs of:
– system-on-chips architecture-built products
– system-on-modules architecture-built products.
ARM Holdings offers users the following types of processors:
– Cortex-A: built for advanced operating systems and exhibits the
highest possible performance;
– Cortex-R: caters perfectly to the needs of real-time applications
and provides its users with the fastest response times;
– Cortex-M: mainly built for microcontrollers;
– SecurCore: takes care of security applications;
– Machine Learning: for ML application purposes.
• We will highlight general information, areas of application,
and the main characteristics of representatives of the A, R,
and M types of processors.
 Microprocessor

• A microprocessor is a single VLSI chip having a

CPU. In addition, it may also have other units
such as coaches, floating point processing
arithmetic unit, and pipelining units that help
in faster processing of instructions.
• Earlier generation microprocessors’ fetch-and-
execute cycle was guided by a clock frequency
of order of ~1 MHz. Processors now operate
at a clock frequency of 2GHz
• A microcontroller is a single-chip VLSI unit
(also called microcomputer) which, although
having limited computational capabilities,
possesses enhanced input/output capability
and a number of on-chip functional units.
• Microcontrollers are particularly used in
embedded systems for real-time control
applications with on-chip program memory
and devices
8086
 Basic Functionalities of a
Microprocessor
• 1. The Bus Interface Unit (BIU):
• It provides the interface of 8086 to external memory and I/O devices via the System Bus.
• It performs various machine cycles such as memory read, I/O read, etc. to transfer data between
memory and I/O devices. 
• BIU performs the following functions are as follows: 
• It generates the 20-bit physical address for memory access.
• It fetches instructions from the memory.
• It transfers data to and from the memory and I/O.
• Maintains the 6-byte pre-fetch instruction queue(supports pipelining).

• BIU mainly contains the 4 Segment registers, the Instruction Pointer, a pre-fetch queue, and
an Address Generation Circuit. 
• Instruction Pointer (IP): 
• It is a 16-bit register. It holds offset of the next instructions in the Code Segment.
• IP is incremented after every instruction byte is fetched.
• IP gets a new value whenever a branch instruction occurs.  
• CS is multiplied by 10H to give the 20-bit physical address of the Code Segment.
• The address of the next instruction is calculated by using the formula CS x 10H + IP.
 The Execution Unit (EU):

• The main components of the EU are General purpose

registers, the ALU, Special purpose registers, the Instruction
Register and Instruction Decoder, and the Flag/Status
Register. 
• Fetches instructions from the Queue in BIU, decodes, and
executes arithmetic and logic operations using the ALU.
• Sends control signals for internal data transfer operations
within the microprocessor.(Control Unit)
• Sends request signals to the BIU to access the external
module.
• It operates with respect to T-states (clock cycles) and not
machine cycles.
Compilation process in an ES
 Locator
• It gives information of memory of target
board.
• It uses information to assign physical address
to code.
• It produces output file that contains binary
memory image which can be loaded into
memory
 The compilation process in an
embedded system
• The compilation process in an embedded system refers to the transformation of source code
written in a high-level programming language into machine code that can be executed by the
microcontroller or processor of the embedded system.
• The process typically involves the following steps:

• Preprocessing: The source code is processed by a preprocessor, which handles any macro
definitions, file inclusion, and conditional compilation directives.
• Compilation: The preprocessed code is then passed to a compiler, which converts the high-level
code into an intermediate representation called assembly code.
• Assembly: The assembly code is then converted into machine code by an assembler, which
generates an object file that contains the machine code and information needed for linking.
• Linking: The object file generated by the assembler is then passed to a linker, which combines the
object files and resolves any inter-module references to produce a final executable binary.
• Loading: The final binary is then loaded into the memory of the embedded system, ready for
execution by the microcontroller or processor.
• The specific tools used for each step of the compilation process may vary depending on the
embedded system architecture, operating system, and programming language being used.
• Here's a list of some commonly used tools for each step of the compilation process in an
embedded system:
• Preprocessing: The commonly used preprocessor tools are cpp (C Preprocessor) for C language and
cpp for C++ language.
• Compilation: The most commonly used compilers for embedded systems are GCC (GNU Compiler
Collection) and LLVM (Low Level Virtual Machine). GCC supports multiple programming languages
including C, C++, and Assembly, while LLVM supports multiple programming languages including C,
C++, and Swift.
• Assembly: The commonly used assembler tools are NASM (Netwide Assembler) for x86
architecture and GAS (GNU Assembler) for multiple architectures.
• Linking: The commonly used linker tools are LD (GNU Linker) and ELF (Executable and Linkable
Format).
• Loading: The commonly used tools for loading the final binary into the memory of the embedded
system are GDB (GNU Debugger) and JTAG (Joint Test Action Group) debugger.
• It's important to note that the specific tools used may vary depending on the architecture,
operating system, and programming language of the embedded system. The tools listed here are
some of the commonly used ones, but others may be used as well.
• Regenerate response
 For an embedded system based on an ARM (Advanced RISC Machines)
controller, the following tools are commonly used in each step of the
compilation process:

• Preprocessing: GCC preprocessor (cpp) is commonly used for

preprocessing source code written in C or C++.
• Compilation: GCC (GNU Compiler Collection) is widely used as a compiler
for ARM controllers, supporting languages such as C, C++, and Assembly.
• Assembly: The commonly used assembler tool for ARM controllers is GAS
(GNU Assembler), which generates machine code for the ARM
architecture.
• Linking: LD (GNU Linker) is a commonly used linker for ARM controllers,
which combines object files and resolves any inter-module references.
• Loading: OpenOCD (Open On-Chip Debugger) is a widely used tool for
loading the final binary into the memory of the ARM controller and for
debugging the executed code.
• It's important to note that the specific tools used may vary depending on
the exact architecture of the ARM controller, the operating system, and
the programming language being used. However, the above-mentioned
tools are commonly used in ARM-based embedded systems.
• For an embedded system based on an 8051 microcontroller, the following tools
are commonly used in each step of the compilation process:
• Preprocessing: The commonly used preprocessor tool for 8051 controllers is the
Keil C preprocessor.
• Compilation: Keil C51 is a widely used compiler for 8051 controllers, supporting
languages such as C, Assembly, and C++.
• Assembly: The commonly used assembler tool for 8051 controllers is the Keil A51
Assembler, which generates machine code for the 8051 architecture.
• Linking: The Keil BL51 Linker is a commonly used linker for 8051 controllers, which
combines object files and resolves any inter-module references.
• Loading: The commonly used tools for loading the final binary into the memory of
the 8051 controller are the Keil UVision Debugger and the Silicon Labs Debugger.
• It's important to note that the specific tools used may vary depending on the exact
architecture of the 8051 microcontroller, the operating system, and the
programming language being used. However, the above-mentioned tools are
commonly used in 8051-based embedded systems.
• https://www.digikey.in/en/products/filter/
microcontrollers-microprocessor-fpga-
modules/721
Embedded Development Life Cycle
• https://slideplayer.com/slide/12714559/