Embedded Programming

What is a Microcontroller?

A microcontroller is a small computer integrated into a single chip. It is designed to perform specific tasks within an embedded system. These compact integrated circuits contain a processor core, random-access memory (RAM), and programmable read-only memory (ROM), which can be erased and rewritten to store programs.

Components of a Microcontroller

Different Sizes of Microcontroller Boards

8-bit Microcontrollers

These are basic microcontrollers commonly used in simple devices such as remote controls. They are suitable for small and simple tasks.

16-bit Microcontrollers

These are more powerful than 8-bit microcontrollers and are commonly used in tools, printers, and similar devices.

32-bit Microcontrollers

These are more advanced, faster, and more powerful chips. They are commonly used in smart devices.

64-bit Microcontrollers

They are capable of handling very large amounts of data and are mainly used to perform multiple tasks simultaneously.

Also, the following aspects must be considered:

• Every circuit requires a GND connection.
• All components must share the same GND.

Microcontroller technical specifications

ESP32 Microcontroller

The datasheet can be found here

Features	ESP32
CPU	Xtensa single-/dual-core 32-bit LX6 microprocessor(s)
Clock Speed	Up to 240 MHz
Bit Depth	CPU: 32 bits, ADC (analog): 12 bits
Storage	448 KB ROM, 520 KB SRAM, 16 KB SRAM in RTC
I/O pins	34 programmable GPIOs
Power	3.3 V
Dimensions	5 × 5 mm
Bluetooth	Compliant with Bluetooth v4.2 BR/EDR and Bluetooth LE specifications, Class-1, class-2 and class-3 transmitter without external power amplifier, Enhanced Power Control, +9 dBm transmitting power
Wifi	802.11n (2.4 GHz), up to 150 Mbps
How to program	Arduino IDE, ESP-IDF, MicroPython, C/C++
Special Functions	Touch Sensor, ULP coprocessor, PWM.

Raspberry Pi Pico Microcontroller

The datasheet can be found here

Features	RP2040
CPU	Microcontrolador: RP2040, ARM Cortex-M0+, Dual-core, Bits: 32 bits
Clock Speed	Up to 133 MHz
Bit Depth	32-bit, ADC: 12 bits (0–4095)
Storage	264KB of SRAM, and 2MB of on-board Flash memory
I/O pins	26 GPIO
Power	3.3 V
Dimensions	51 × 21 mm
Bluetooth	No
Wifi	No
How to program	C / C++, MicroPython, Arduino IDE
Special Functions	USB 1.1 Host/Device, 8 Programmable I/O (PIO) state machines

Arduino Microcontroller

The datasheet can be found here

Features	ATmega328P
CPU	AVR RISC, 8 bits
Clock Speed	Up to 16 MHz
Bit Depth	CPU: 8 bits, ADC: 10 bits (0–1023)
Storage	Flash: 32 KB, SRAM: 2 KB, EEPROM: 1 KB
I/O pins	14 digital pins (D0–D13), 6 analog pins (A0–A5), 6 PWM pins
Power	Operating voltage: 5V, VIN input: 6–20V, USB: 5V
Dimensions	68.6x53.4 mm
Bluetooth	No
Wifi	No
How to program	Arduino IDE (Desktop), Arduino Cloud Editor, Lenguaje: C / C++ (Arduino)
Special Functions	Timers (8-bit and 16-bit), PWM (6 channels), UART, SPI, I2C, Watchdog Timer, Per Pin Interrupts.

Embedded System Simulation

I chose ESP32-WROOM microcontroller because I consider its characteristics and components suitable for my project since it can be connected to Bluetooth and Wi-Fi, and these options can help me to develop my project in the future. An Esp32 is also an available microcontroller that is simple to use and program. Additionally, it includes multiple functions that allow me to control a more complex system, especially for managing the mobility of the vehicle. It allows me to do multiple tasks at the same time, as reding sensors, control motors, using wireless communications, low energy consumption, wide variety of modules. I did this simulation in Wokwi as it's a great free tool that can be fully utilized.

Initially, I learned how to turn on LED lights through programming. Later, I gradually added more components. Finally, I created a simulation using an ultrasonic sensor, as this sensor allows me to better understand the elements I will work with throughout my project.

How to use Wokwi?

C++ Code Structure for Arduino IDE

For me, it was very important to understand the structure to follow when programming. I used the following structure:

This structure allows the program to be configured, executed, and divided into tasks. Additionally, there are fundamental programming structures that should be considered or learned:

Programming Language

The programming language used in this project is C++. Some of the most important commands include:

Pin Commands

Time Commands

Analog Commands

Serial Communication Commands

It is important to consider the main operators, which are:

Operator	Meaning
==	Equal
!=	Not equal
<	Less tan
>	Greater than
&&	AND

To declare blocks of code using functions, the data type is specified first, followed by the function name. Example:

            int leerSensor() {
                return 123;
            }
            

The existing data types include:

• void: returns no data
• int: returns an integer
• bool: returns true or false
• float: returns a decimal value

A useful example that helped me understand and become familiar with programming structure follows this format:

• () contains the required parameters.
• {} contains the instructions executed by the function.

LED simulation with buttons

First, I created a simulation using a button and an LED.

This was the result:

Subsequently, I increased the number of LEDs and buttons.

So, here you can find this simulation.

The code used was written in C++ and programmed following the structure described above. In this code, the first section declares the pins that will be used, followed by the definition of their corresponding input types. Finally, the code allows a series of actions to be executed continuously, in which the signals from the buttons are read and, based on these inputs, a decision is made regarding which LED will turn on.

This code is an excellent example for beginning to become familiar with programming this type of system, understanding its structure, and experimenting with simulations in a safe and interactive manner.

                int led1 = 23;
                int led2 = 22;

                int boton1 = 18;
                int boton2 = 19;

                void setup() {
                  pinMode(led1, OUTPUT);
                  pinMode(led2, OUTPUT);
                  pinMode(boton1, INPUT_PULLUP);
                  pinMode(boton2, INPUT_PULLUP);
                }

                void loop() {
                  int estadoBoton1 = digitalRead(boton1);
                  if (estadoBoton1 == LOW) {
                    digitalWrite(led1, HIGH);
                  }
                  else {
                    digitalWrite(led1, LOW);
                  }

                  int estadoBoton2 = digitalRead(boton2);
                  if (estadoBoton2 == LOW) {
                    digitalWrite(led2, HIGH);
                  }
                  else {
                    digitalWrite(led2, LOW);
                  }
                }
              

Simulation with ultrasonic sensor that turns on LEDs

For the second example, I used an ultrasonic sensor in order to become familiar with its operation.

Later, additional LEDs were added.

In this simulation, it was planned that, based on the data obtained from the ultrasonic sensor, the distance between objects could be calculated and, from this information, determine which LED would be activated. This code implements a more advanced use of programming, as it includes different instructions that allow signals to be sent and received, which is essential due to the sensor being used. Additionally, conditional statements are declared, allowing for better control over the behavior and logic integrated into this simulation. The code used was written in C++ and programmed following the structure described above.

                int TRIGPin = 19;
                int ECHOPin = 18;
                int led1 = 17;
                int led2 = 16;
                int led3 = 4;
                int led4 = 0;

                void setup() {
                  Serial.begin(115200);

                  pinMode(TRIGPin, OUTPUT);
                  pinMode(ECHOPin, INPUT);

                  pinMode(led1, OUTPUT);
                  pinMode(led2, OUTPUT);
                  pinMode(led3, OUTPUT);
                  pinMode(led4, OUTPUT);
                }

                void loop() {
                  long duration;        // variable declaration
                  float distance;       // variable declaration

                  // Trigger pulse (clean signal)
                  digitalWrite(TRIGPin, LOW); 
                  delayMicroseconds(2); // pause before sending the pulse

                  // Send trigger pulse
                  digitalWrite(TRIGPin, HIGH); 
                  delayMicroseconds(10); // pulse duration
                  digitalWrite(TRIGPin, LOW);  // stop sending pulse

                  duration = pulseIn(ECHOPin, HIGH, 40000); // read echo pulse
                  distance = duration * 0.034 / 2;          // distance calculation

                  Serial.print("Distance: ");   // screen output
                  Serial.print(distance);       // print distance value
                  Serial.println(" cm");        // units

                  if (distance >= 0 && distance < 100) {
                    digitalWrite(led1, HIGH);
                    digitalWrite(led2, LOW);
                    digitalWrite(led3, LOW);
                    digitalWrite(led4, LOW);
                  }
                  else if (distance >= 100 && distance < 200) {
                    digitalWrite(led1, LOW);
                    digitalWrite(led2, HIGH);
                    digitalWrite(led3, LOW);
                    digitalWrite(led4, LOW);
                  }
                  else if (distance >= 200 && distance < 300) {
                    digitalWrite(led1, LOW);
                    digitalWrite(led2, LOW);
                    digitalWrite(led3, HIGH);
                    digitalWrite(led4, LOW);
                  }
                  else {
                    digitalWrite(led1, LOW);
                    digitalWrite(led2, LOW);
                    digitalWrite(led3, LOW);
                    digitalWrite(led4, HIGH);
                  }

                  delay(300); // waiting time
                }
            

If you want to access to my simulation, you can find it here.

Other Programming Languages

In addition to C++, I experimented with Micropython. This language is known for being more intuitive and easier to understand. A comparison table between programming languages is presented below.

I did the same simulation to compare the programs. The code used is described above:

                from machine import Pin, time_pulse_us
                import time

                # Pines del sensor
                TRIG = Pin(19, Pin.OUT)
                ECHO = Pin(18, Pin.IN)

                # LEDs
                led1 = Pin(17, Pin.OUT)
                led2 = Pin(16, Pin.OUT)
                led3 = Pin(4, Pin.OUT)
                led4 = Pin(0, Pin.OUT)

                def medir_distancia():
                    TRIG.value(0)
                    time.sleep_us(2)

                    TRIG.value(1)
                    time.sleep_us(10)
                    TRIG.value(0)

                    duracion = time_pulse_us(ECHO, 1, 40000)
                    if duracion < 0:
                        return 0

                    distancia = (duracion * 0.034) / 2
                    return distancia

                while True:
                    distancia = medir_distancia()
                    print("Distance:", distancia, "cm")

                    if 0 <= distancia < 100:
                        led1.on()
                        led2.off()
                        led3.off()
                        led4.off()

                    elif 100 <= distancia < 200:
                        led1.off()
                        led2.on()
                        led3.off()
                        led4.off()

                    elif 200 <= distancia < 300:
                        led1.off()
                        led2.off()
                        led3.on()
                        led4.off()

                     else:
                        led1.off()
                        led2.off()
                        led3.off()
                        led4.on()

                    time.sleep(0.3)
            

Finally, here you can acess to my simulation.

Comparison between C++ and MicroPython Programming for ESP32

Once both programs were implemented, a comparative table is presented below, analyzing the main differences between programming in C++ (Arduino framework) and MicroPython, considering different functional categories of the system.

Use	C++	Micropython
Pin Definition	pinMode(19, OUTPUT)	TRIG = Pin(19, Pin.OUT)
LED Pin Definition	pinMode(17, OUTPUT);	led1 = Pin(17, Pin.OUT)
Distance Measurement Function	float medirDistancia() {	def medir_distancia():
Sending Ultrasonic Pulse	digitalWrite(TRIG, HIGH); delayMicroseconds(10); digitalWrite(TRIG, LOW);	TRIG.value(1) time.sleep_us(10) TRIG.value(0)
Echo Reading	duration = pulseIn(ECHOPin, HIGH, 40000);	duracion = time_pulse_us(ECHO, 1, 40000)
Distance Calculation	distance = duration * 0.034 / 2;	distancia = (duracion * 0.034) / 2 return distancia
Main Loop	loop()	while True:
Console Output	Serial.print("Distance: "); Serial.print(distance); Serial.println(" cm");	print("Distance:", distancia, "cm")
LED Conditions	if (distance >= 0 && distance < 100) { digitalWrite(led1, HIGH); digitalWrite(led2, LOW); digitalWrite(led3, LOW); digitalWrite(led4, LOW);	if 0 <= distancia < 100: led1.on() led2.off() led3.off() led4.off()
Final Delay	delay(300);	time.sleep(0.3)

As can be observed in the comparative table, using MicroPython is easier and more intuitive to learn; however, it has slower performance and higher memory consumption. Meanwhile, C++, despite having greater learning complexity, has better performance and speed.