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 :
[Link]-32
[Link]-256
[Link]
[Link] 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.,
[Link]) as proof
