5. Embedded programming¶
This week I worked on defining my final project idea and started to getting used to the documentation process.
Studying topics¶
Von Neumann Vs Harvard Architecture¶
The image compares the Von Neumann and Harvard architectures, two fundamental computing architectures. The Von Neumann architecture (left) uses a single memory unit for both data and instructions, with a shared data and address bus, leading to a bottleneck where the CPU must fetch instructions and data sequentially, slowing down performance. This design is widely used in general-purpose computers due to its simplicity and flexibility. In contrast, the Harvard architecture (right) separates program memory and data memory, each with its own dedicated buses, allowing simultaneous fetching of instructions and data, significantly improving processing speed and efficiency. This makes it ideal for embedded systems, DSPs, and microcontrollers, where high-speed execution is crucial. Modern processors often use a modified Harvard architecture, combining elements of both to optimize performance. For more details, refer to the source article on Medium:
RISC-and-CISC¶
This image illustrates the difference between RISC (Reduced Instruction Set Computer) and CISC (Complex Instruction Set Computer) architectures by depicting their structural design. The RISC architecture (left) features a hardwired control unit, which directly interacts with the instruction cache and command memory, enabling faster execution of simple instructions. It emphasizes a simplified instruction set with uniform execution cycles, leading to higher efficiency and better performance in modern processors. In contrast, the CISC architecture (right) employs a control unit (CU) with control memory, which interacts with the data path, cache, and main memory. This structure supports complex multi-step instructions, reducing the number of instructions in a program but requiring longer execution times per instruction. While RISC prioritizes speed and efficiency with a streamlined approach, CISC focuses on reducing program complexity at the cost of slower execution cycles. Modern processors often adopt a hybrid approach, integrating elements of both architectures to balance performance and complexity.
For more details, refer to the source article on geeksforgeeks:
Microprocessor-vs-Microcontroller¶
These images compare a Microprocessor and a Microcontroller, highlighting their structural and functional differences. A microprocessor (left) consists of an Arithmetic Logic Unit (ALU), Control Unit, and Register Array, but it requires external components like RAM, ROM, and I/O devices to function. It is designed for general-purpose computing, making it ideal for high-performance tasks like running operating systems in computers (e.g., Intel Core i7). In contrast, a microcontroller (right) is a self-contained system that integrates the CPU, RAM, ROM, I/O ports, timers, and serial communication within a single chip (e.g., Microchip ATmega328P). This makes microcontrollers more power-efficient and suitable for embedded systems, automation, and real-time applications such as IoT devices, robotics, and home appliances. While microprocessors focus on processing power and flexibility, microcontrollers prioritize compact, low-power, and task-specific operations.
CPU GPU¶
It compares the architectures of a CPU (Central Processing Unit) and a GPU (Graphics Processing Unit), highlighting their structural differences. The CPU (left) consists of a control unit, a few Arithmetic Logic Units (ALUs), cache memory, and DRAM. CPUs are optimized for sequential processing, handling complex tasks with fewer but more powerful cores, making them ideal for general-purpose computing, operating systems, and single-threaded applications. On the other hand, the GPU (right) features many smaller ALUs arranged in parallel, allowing it to handle massive parallel processing tasks. GPUs excel at graphics rendering, scientific computing, AI processing, and deep learning by efficiently managing thousands of simultaneous operations. While CPUs focus on low-latency, high-precision computing, GPUs prioritize high-throughput parallelism, making them essential for modern gaming, machine learning, and computational workloads.
Embedded FPGA¶
This image illustrates the architecture of an Embedded FPGA (Field-Programmable Gate Array) within a System-on-Chip (SoC) with Programmable Acceleration. The design integrates multiple CPU clusters, each with its own L2 cache, allowing efficient multi-core processing. The Embedded FPGA provides programmable hardware acceleration, enabling high-performance computing for specialized tasks such as AI, signal processing, and real-time data processing. A cache-coherent interconnect ensures seamless communication between the CPU clusters and the FPGA, optimizing data transfer and computational efficiency. The architecture also includes essential components such as a security bridge for secure data access, a DDR controller for memory management, and interfaces for PCIe and Ethernet connectivity, ensuring high-speed data communication. This hybrid SoC architecture balances general-purpose computing with flexible hardware acceleration, making it ideal for applications requiring high efficiency, adaptability, and low latency processing.
For more details, refer to the source article on icdrex.com:
Register Memory¶
It represents the hierarchical structure of memory in a computer system, focusing on register memory, main memory, and storage devices. The CPU contains essential components such as registers, the Arithmetic & Logic Unit (ALU), and the Control Unit, which work together to process instructions. Registers are the fastest memory units, directly integrated into the CPU, storing temporary data for quick access and reducing latency during execution. The main memory (RAM) interacts with the CPU to store active programs and data that require quick access, but it is volatile and loses data when power is off. The I/O controller manages communication between the CPU and external storage devices, such as disk drives, which provide long-term data storage. This architecture highlights the role of registers as the fastest memory, followed by RAM for temporary data storage, and disk drives for persistent storage, ensuring efficient data processing and retrieval.
For more details, refer to the source article on geeksforgeeks.org:
Ports¶
Practical learning¶
Worwi Simulation¶
// WOKWI- ESP32 simulator- Blinking LED - sketch.ino ()
#define LED1 12
void setup() {
// initialize the GP10 pins as outputs:
pinMode(LED1, OUTPUT);
}
void loop() {
// turn on the LED1 for 3 seconds:
digitalWrite(LED1, HIGH);
delay(3000);
digitalWrite(LED1, LOW);
}
This is an Arduino-style sketch written for the ESP32 on the WOKWI simulator. Here’s a breakdown of how it works:
- Definition of LED Pin -#define LED1 12
- Setup Function -void setup() -it runs once when the program starts.
- Loop Function -void loop() It runs repeatedly after setup() has completed. I learned how to blink an LED using an ESP32 in the WOKWI simulator. By setting up pin 12 as an output and alternating between high (on) and low (off) states with a 3-second delay when the LED is on, the program creates a blinking effect.
{
Esp32 Traffic light_Arduino
#define yellow_LED 14
#define green_LED 13
}
void setup() {
// initialize the GP10 pins as outputs:
pinMode(red_LED, OUTPUT);
pinMode(yellow_LED, OUTPUT);
pinMode(green_LED, OUTPUT);
}
void loop() {
// turn on the green LED for 3 seconds:
digitalWrite(green_LED, HIGH);
delay(3000);
digitalWrite(green_LED, LOW);
// turn on the yellow_LED for 3 seconds:
digitalWrite(yellow_LED, HIGH);
delay(4000);
digitalWrite(yellow_LED, LOW);
// turn on the red_LED for 3 seconds:
digitalWrite(red_LED, HIGH);
delay(5000);
digitalWrite(red_LED, LOW);
}
Working on this Arduino-style sketch for the ESP32 in the WOKWI simulator, I learned how to simulate a traffic light by defining three LED pins—red, yellow, and green—and controlling them one after another. In the setup function, I set each LED as an output, and in the loop function, I used digitalWrite and delay commands to turn on the green LED for 3 seconds, the yellow for 4 seconds, and the red for 5 seconds. This project really helped me understand the importance of individually managing each output pin on the ESP32 to create a realistic staged effect.
1.
#define red_LED 13
#define yellow_LED 8
#define green_LED 12
void setup() {
// initialize the GP10 pins as outputs:
pinMode(red_LED, OUTPUT);
pinMode(yellow_LED, OUTPUT);
pinMode(green_LED, OUTPUT);
}
void loop() {
// turn on the green LED for 3 seconds:
digitalWrite(green_LED, HIGH);
delay(3000);
digitalWrite(green_LED, LOW);
// turn on the yellow_LED for 3 seconds:
digitalWrite(yellow_LED, HIGH);
delay(4000);
digitalWrite(yellow_LED, LOW);
// turn on the red_LED for 3 seconds:
digitalWrite(red_LED, HIGH);
delay(5000);
digitalWrite(red_LED, LOW);
}
I decided to chanin op operations in void loop.
2.
#define red_LED 13
#define yellow_LED 8
#define green_LED 12
void setup() {
// initialize the GP10 pins as outputs:
pinMode(red_LED, OUTPUT);
pinMode(yellow_LED, OUTPUT);
pinMode(green_LED, OUTPUT);
}
void loop() {
// turn on the green LED for 1 seconds:
digitalWrite(green_LED, HIGH);
digitalWrite(yellow_LED, LOW);
digitalWrite(red_LED, LOW);
delay(1000);
// turn on the yellow LED for 1 seconds:
digitalWrite(green_LED, LOW);
digitalWrite(yellow_LED, HIGH);
digitalWrite(red_LED, LOW);
delay(1000);
// turn on the red LED for 1 seconds:
digitalWrite(green_LED, LOW);
digitalWrite(yellow_LED, LOW);
digitalWrite(red_LED, HIGH);
delay(1000);
digitalWrite(green_LED, LOW);
digitalWrite(yellow_LED, LOW);
digitalWrite(red_LED, LOW);
delay(1000);
digitalWrite(green_LED, HIGH);
digitalWrite(yellow_LED, HIGH);
digitalWrite(red_LED, HIGH);
delay(1000);
}
The same code run for ESP 32 was repeated for Arduino UNO and it gave the same result.
#define LED 2
#define LED2 4
void setup() {
pinMode(LED, OUTPUT);
pinMode(LED2, OUTPUT);
}
void loop() {
digitalWrite(LED, HIGH);
digitalWrite(LED2, LOW);
delay(500);
digitalWrite(LED, LOW);
digitalWrite(LED2, HIGH);
delay(500);
}
#define red_LED 1
#define yellow_LED 9
#define green_LED 5
void setup() {
// initialize the GP10 pins as outputs:
pinMode(red_LED, OUTPUT);
pinMode(yellow_LED, OUTPUT);
pinMode(green_LED, OUTPUT);
}
void loop() {
// turn on the green LED for 1 seconds:
digitalWrite(green_LED, HIGH);
digitalWrite(yellow_LED, LOW);
digitalWrite(red_LED, LOW);
delay(1000);
// turn on the yellow LED for 1 seconds:
digitalWrite(green_LED, LOW);
digitalWrite(yellow_LED, HIGH);
digitalWrite(red_LED, LOW);
delay(1000);
// turn on the red LED for 1 seconds:
digitalWrite(green_LED, LOW);
digitalWrite(yellow_LED, LOW);
digitalWrite(red_LED, HIGH);
delay(1000);
digitalWrite(green_LED, LOW);
digitalWrite(yellow_LED, LOW);
digitalWrite(red_LED, LOW);
delay(1000);
digitalWrite(green_LED, HIGH);
digitalWrite(yellow_LED, HIGH);
digitalWrite(red_LED, HIGH);
delay(1000);
}
Testing the same code on a Raspberry Pi Pico provided me with valuable insights into how different microcontroller architectures and connection points affect hardware projects, highlighting the importance of adapting pin configurations to suit each platform’s unique structure.
from machine import Pin
import time
# Define LED pins (use valid GPIOs for output)
Red = Pin(2, Pin.OUT)
Green = Pin(3, Pin.OUT)
Yellow = Pin(4, Pin.OUT)
while True:
# Red ON, others OFF (Stop)
Red.value(1)
Yellow.value(0)
Green.value(0)
time.sleep(5)
# Yellow ON (Transition)
Yellow.value(1)
time.sleep(2)
# Green ON, others OFF (Go)
Red.value(0)
Yellow.value(0)
Green.value(1)
time.sleep(5)
# Yellow ON before switching back to Red
Green.value(0)
Yellow.value(1)
time.sleep(2)
# Loop continues
Working on this MicroPython traffic light code, I learned that programming microcontrollers with MicroPython is quite different from using Arduino’s C/C++ approach. Instead of having distinct setup() and loop() functions, I start by importing modules—specifically, Pin from machine and time—which allow me to define and control the LED pins directly. In this script, I set up the red, green, and yellow LEDs on designated GPIOs, then use an infinite while loop to simulate a traffic light: the red LED stays on for 5 seconds, then the yellow for 2 seconds, followed by the green for 5 seconds, and yellow again for 2 seconds before the cycle repeats. This experience helped me understand the unique structure and flow of MicroPython code and how it offers a different but effective way to control hardware.
