EMBEDDED SYSTEMS SOFTWARE AND DEVELOPMENT ENVIRONMENT

Embedded Software and Hardware Overview

An embedded system is a computerized system that is purposely built for its
application with limited resources of processing, memory, and peripherals. Typically, an
aspect of either software language or hardware description language in addition to the
physical hardware to run to these programs on. The hardware is a combination of a
processing core and external circuits for the processor to interact with.
The hardware on an embedded system has different components that includes the
following:
a) Printed Circuit Board (PCB): A PCB is a substrate with conductive wires that
interconnect many integrated circuits (including processors and power systems)
and passive developments that all have been soldered into the board.
a. Program Debugger: Previously, a debugger is externally connected to a
PCB but was now simplified into making it a part of the PCB.
b) Microcontroller/ Microprocessor: A microcontroller is a microprocessor with
added functionality such as memory and peripheral hardware.
a. Central Processing Unit (CPU): A CPU is a piece of hardware that runs our
software by fetching and executing assembling instructions for memory. A
CPU has many sub-components including registers that store operation’s
data and system’s state, Arithmetic Logic Unit (ALU) that performs low
level assembly programs, Interrupt Controller that coordinates a
synchronous event request of the processor, and a Debug Interface that
helps in troubleshooting installed programs.
b. Bus Controller: Bus controllers aid the processor in this data transmission
between memory and peripherals.
c. Memory: Memory, including Random Access Memory (RAM), holds data
that user operates on as well as the program that is being executed.
d. Clock System: A clock system within a microcontroller provides
synchronizations across all the other components.
e. Peripheral Hardware: Peripheral hardware may be added in a
microcontroller for additional functionality of communication, analog signal
processing, input and output, timing, and processor support.
In an embedded system, the synchronization of the hardware and the software
is important. Thus, both the development of hardware and software needs meticulous
consideration and planning to ensure quality development.
Embedded System Engineering
A Software Block Diagram is the process of breaking a software concept down
into flow diagrams or software blocks which can help in depicting how a piece of
software or algorithm should behave. Like other block diagrams, it contains the same
functional software contracts such as conditional decision and function calls.
Additionally, the main purpose of a software block diagram is to depict how blocks of
code communicate and connect to one another which also helps in depicting software
system in layers.
Additional to hardware, there is software to help boot or start an embedded
system.
a) Bare-Metal Firmware: Bare-metal firmware refers to a code or program that
directs the interface of the hardware in an embedded system. Metal code has a
steep learning curve and requires deep knowledge of the hardware for the bare-
metal configuration, hardware timing and software design limitations.
b) Hardware Abstraction Layer (HAL): Hardware Abstraction Layer (HAL) refers
to the segmentation of hardware interface which works as a module component
and allows software above it to become platform independent or agnostic to the
specific hardware implementation and concern layers, and portable across
platforms.
c) On-Target Testing: On-target testing refers to the installation of code to a
particular embedded system. Previously, this test was done on physical printed
circuit boards, however, due to new development techniques and system
emulation, quality of resources for low level development is ensured.
In conclusion, in the development of embedded system hardware, there is a lot to
consider. Specifically, the low-level control of the hardware, the hardware abstraction,
the platform independence, the portability of interface and the quality of resources
Additionally, software developers need development tools such as simulators,
emulators, compilers, installers, and debuggers to get started on software development
and testing. Simulators and emulators will allow validation of design to occur before the
arrival of hardware while compilers, installers and debuggers will provide quick
development of embedded system target features.
a) Simulators: Simulators are software that imitates the intended hardware’s
behavior without using the actual hardware.
b) Emulators: Emulators are hardboard platform that imitates the operation of
your intended system
c) Compilers: Compilers are software that allows developers to pre-execute code
for their intended system architecture.
d) Installers: Installers are software-hardware combination that allows compiled
executable programs to be installed onto a platform.
 e) Debuggers: Debuggers are software-hardware combination of solutions that
allows the programmers to test and validate their executable programs.

Development Environments Overview

Development environments are key for software engineers as they are the
means with which a software project is created. It is the environment where a
developer can generate an executable file, install a program, as well as maintain a
program for a better working design. In conclusion, the primary goal of the
development environment would be to allow engineers to write, compile, install and
debug a program.
For software developers, there are two different desktop development
environments called the command line and the integrated development environment.
a) Command Line: The use of a command line like the command line interface
(CLI) is the de facto standard in software development. It gives a powerful level
of control of applications and is typically a power user interface.
b) Integrated Development Environment (IDE): A vendor provided IDE does
not just encapsulate all the functionality that we get from a command line but
also offers a more interactive user interface. Many features of an IDE provide
more user-friendly methods of developing and debugging an application.
In designing software for an embedded system, the first step is to plan the
system using a software block diagram, next is to write the code and to compile the
code. After the compilation of code, is the installation of the program. Finally, to
maintain the software design and ensure its quality, debugging should be done and
considered.

Development Kits and Documentation

Development kits are important tools for software engineers to start becoming
familiar with architecture. By using these kits, a generic hardware platform with lots of
vendor support is ensured. Most projects begin by using development kits to evaluate
platform options. This helps in picking a particular microcontroller for the embedded
system.
In an embedded system, there are different features that need consideration
when developing software for embedded systems. These features that needed
consideration includes:
a) Word Size
b) Number of Registers
c) Flash Memory and RAM sizes
d) Branch Prediction Support
e) Instruction and Data Cache Support
 f) Floating Point Arithmetic Support
After finalizing the features of the embedded system, it is important to document
all detailed information sources like the datasheet. This document gives technical
specifications on a chip or a family of chips with a breakdown of all the differences
between each version or part number within the family. The documentations needed in
developing an embedded system are:
a) Pin Counts and Operation Specifications (diagrams, tables, plots)
b) Electrical Characteristics (voltage, operation ratings, power specs)
c) Timing Characteristics (processor’s clock frequency limitations, timing diagrams)
d) Datasheet (effects of environmental factors)
e) Physical Design Constraints.

Version Control(v9)
Version control systems, or VCS, or alternatively revision control systems, RCS, is
a software package that allows users to track changes in a project over time. The VCS
gets installed on the host machine where you develop your code. The VCS allows you
to track items such as software, documents, build and configuration information, or
even a project compiled build release for customers that download. Also, there are
hidden files, called the repository, that are not visible from a software development
perspective that contain the configuration and tracking information for your code that is
managed by the VCS system itself.
The version control system includes commit, collaboration, and conflict
resolution. In VCS, the workflow starts with the creation of development branch,
making changes, staging file for commit, change of commit, and push change to
remote.