Scribd
Upload
19 views

topic1Word

The document discusses programming languages used in embedded systems, highlighting their features, strengths, and weaknesses, particularly focusing on languages like C, C++, Rust, Python, TinyGo, and Assembly. It compares high-level and low-level languages, detailing the advantages of each in terms of programming ease, control, and performance. Additionally, it mentions performance evaluation benchmarks for these languages, noting the lack of comprehensive benchmarks specifically for embedded systems.

Uploaded by

abdklaib233
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
19 views

topic1Word

The document discusses programming languages used in embedded systems, highlighting their features, strengths, and weaknesses, particularly focusing on languages like C, C++, Rust, Python, TinyGo, and Assembly. It compares high-level and low-level languages, detailing the advantages of each in terms of programming ease, control, and performance. Additionally, it mentions performance evaluation benchmarks for these languages, noting the lack of comprehensive benchmarks specifically for embedded systems.

Uploaded by

abdklaib233
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 13

Topic 1 consistis of three points!

First point: Overview of Programming Languages used in Embedded


Systems such as but not limited to C, C++, Rust, Python (MicroPython),
TinyGo, and Assembly; their features, strengths and weaknesses, trade offs.

The
and how widely are they used (provide recent cited statistics).

resource is the following article from


research gate ,ctrl +click to follow the
link .

1. Introduction
The increasingly widespread IoT applications related to the development of
various

embedded systems and signal processing tasks require specialized


hardware. This tech

nical equipment must be characterized by small dimensions, low energy


consumption,

efficient memory use, and sufficient performance for the implementation of


different sig

nal processing functions. The main role in this case is played by various
microcontrollers,

which usually collect data from sensors and end-user devices, process those
data, and
forward results to higher-level systems. Currently, the market offers a whole
range of

specialized signal processing microcontrollers specially adapted for IoT tasks.


One of the

popular choices has become the ESP32 microcontroller, which is attractive to


developers

due to its technical characteristics and good software support, as well as the
ability to use

various programming languages. As concluded by , ESP32 is an excellent


option for

IoT devices due to the price and performance achieved by a dual core
structure and a

significant extension of operational features.

Language selection criteria


/**The most important aspect when choosing a microcontroller programming
language

is the support of its hardware and peripherals, such as GPIO pins and
communication

modules like WiFi, Bluetooth, or SPI. Microcontroller vendors almost always


offer hard

ware abstraction libraries (HALs) to access specific registers and peripherals.


Without

such libraries, even an otherwise very powerful language is not useful for
development

on a chosen platform, in this case, ESP32.

Another aspect is the support for the language itself on a device. It is not
uncommon

that more advanced features of a high-level programming language are


limited or not
supported at all on certain platforms.

Memory management is also an important feature of any programming


language, as

it is closely related to overall safety and performance of any project


developed in that

language. The three most common memory management types are


automatic, manual,

and garbage collector-based. In automatic management, the memory is


allocated by the

compiler without an explicit instruction from the programmer, mainly


occurring with

stack management. In contrast, manual memory management requires the


programmer

to do all the hard work of allocating and deallocating memory. This is usually
used for a

heap. Finally, with garbage collection, memory allocation can be manual, but
deallocation

is performed automatically at certain intervals. While manual memory


management can

introduce bugs and safety issues, garbage collection comes with a


performance penalty

and unpredictability, since the runtime environment must stop the execution
of the actual

code to search for memory that is not in use. This is especially important in
real-time ap

plications, where execution times must be well known and controlled. */


Second point of topic 1 : Comparison
between High-Level and Low-Level
(Assembly) languages in embedded
Systems

Assembly Language Programming

Assembly language programming of an embedded system has the following


advantages:

The machine codes are compact, processor and memory sensitive. This is
due to the fact that, the codes for declaring the conditions, rules and data
type do not exist. The system thus needs a smaller memory. Excess memory
required does not depend on the programmer data type selection and rule
declarations.

Since the assembly codes are sensitive to the process, memory, ports and
devices hardware. It gives a precise control of the processor internal devices
and the complete use of the processor-specific features in its instruction set
and its addressing modes.
The program is not compiler specific and library functions dependent.

Device driver codes may require only a few assembly instructions. A case in
point is a small embedded system like a timer device in a microwave oven.
Assembly codes for this system can be compact and precise.

Some of the key advantages of high-level languages over assembly language


include:

High-level program facilitates data type declarations. These data type


declarations provide programming ease.

High-level program development cycle is short even for complex systems


since we use methods in Java and routines in C/C++, standard library
functions, employ modular programming technique, and use top-down or
object-oriented design (OOP) design approach.

High-level program facilitates ‘type checking’ making the program less prone
to error.

High-level program facilitates use of control structures [e.g. while, do-while,


break and for] and conditional statements [e.g. if, if-else, else-if and switch-
case] to specify the program flow by simple statements.

High-level program has portability of non-processor-specific codes. Hence,


when the hardware changes, only the modules for the interrupt service
routines (ISRs) of device drivers and device management, initialization and
program-locator modules and initial boot-up record data need modifications.

Third point of topic 1 : Performance


evaluation of C, C++, Rust, Python
(MicroPython), TinyGo and assembly
backed by codes and benchmarks or
recent cited research or sources
2.3. Algorithms Used for Performance Comparison

The ideal choice for performance comparison and evaluation would be to use
an already existing comprehensive benchmark suite which includes a wide
selection of different algorithms. However, few exist that are specifically
targeted at embedded systems,

and none exist that would consider relatively new languages like Rust or
TinyGo. Existing

embedded-oriented benchmarks include Bristol Energy Efficiency Benchmark


Suite

(BEEBS) benchmark, aimed at evaluating the energy consumption of


embedded processors [36], MiBench [37], and EEMBC suite [38]. They all
categorize used algorithms into

different application categories, such as security, automotive, network,


telecommunication, etc. These benchmarks test different types of embedded
system applications in reallife use. A subset of algorithms was chosen from
the benchmark suites mentioned above

while considering these aspects

The algorihtims used are :

1.CRC-32

2.SHA-256

3.FFT

4.FIR Filter

5. IIR Filter
The obseravations related to
performance are described in the
following figures :
The following two pictures are
for Benchmark results
comparing algorithm
performance across different
programming languages.
Every thing above is from the article from
research gate website article link
→RESEARCH GATE
As for the requirement of “and
benchmarks” in the
“Performance evaluation of C, C+
+, Rust, Python (MicroPython),
TinyGo and assembly backed by
codes and benchmarks or recent
cited research or sources.” This
word file do not contain it !!!!
every
thing is in the
following GITHUB REPOSITRY
This github :
1. a_bencher.cpp (benchmark setup).

2. One algorithm file (e.g.,


sha256.cpp) as proof

You might also like