Week​ 4

Embedded Programming

Checklist

Group assignment

• Demonstrate and compare the toolchains and development workflows for available embedded architectures
• Document your work to the group work page and reflect on your individual page what you learned

Individual assignments 

• Browse through the datasheet for your microcontroller
• Write a program for a microcontroller, and simulate its operation, to interact (with local input &/or output devices) and communicate (with remote wired or wireless connection)

Group assignment

Introduction

Embedded programming (EP) involves writing software that directly interacts with hardware in resource-constrained environments. It is used to control devices like sensors, motors, displays, and communication modules through microcontrollers or embedded processors. Programs, often written in C or C++, must be optimized for speed, memory usage, and power efficiency due to limited hardware capabilities. Embedded systems frequently operate in real-time, requiring fast and reliable responses to external events. Developers use debugging tools like serial monitors and JTAG/SWD interfaces to test and troubleshoot firmware, which is the permanent software stored in flash memory. Communication with other devices is often achieved through protocols like I2C, SPI, UART, or wireless methods such as Bluetooth and Wi-Fi. EP is essential in various domains including IoT, robotics, automotive systems, industrial automation, and consumer electronics, with power management being a crucial consideration, especially for battery-powered applications.

What is embedded programming

• Definition: Writing software for embedded systems—special-purpose devices designed for specific functions.
• Hardware Control: Interacts directly with hardware components like sensors, actuators, and displays.
• Languages Used: Commonly uses C, C++, and assembly for efficiency and hardware-level control.
• Limited Resources: Programs must be optimized for low memory, limited CPU speed, and low power consumption.
• Real-Time Operation: Often used in systems requiring immediate response (e.g., automotive, medical, industrial).
• Microcontrollers & Microprocessors: Runs on chips like ARM Cortex, AVR, ESP32, or XIAO RP2040.
• Applications: Found in appliances, robotics, IoT devices, automation systems, and more.

You Need to Know About Embedded System Programming link

How it works

Program Development: Code is written using languages like C/C++ in an Integrated Development Environment (IDE) such as Arduino IDE, Keil, or MPLAB 
Compilation & Linking: The source code is compiled into machine code (binary) that the microcontroller can understand.
Uploading to Hardware: The compiled program is uploaded to the embedded system's memory (usually via USB, Serial, or SWD interface). 
Execution: Once powered, the microcontroller fetches, decodes, and executes the instructions continuously. 
Interfacing with Hardware: The code controls inputs (like sensors) and outputs (like LEDs or motors) in real-time. 
Monitoring & Debugging: Developers use debugging tools, serial monitors, and LEDs to check the functionality and fix issues.

datasheet  microcontroller

Summary of ESP32-C3 Datasheet 
The ESP32-C3 is a cost-effective, low-power, 32-bit RISC-V microcontroller with integrated Wi-Fi and Bluetooth LE 5.0. Designed for secure and efficient IoT applications, it provides robust wireless connectivity and flexible I/O configuration. 

Technical Specifications
 Microcontroller: 32-bit RISC-V Single-Core CPU 
Clock Speed: Up to 160 MHz 
SRAM: 400 KB 
ROM: 384 KB 
Flash: External (typically 4 MB via SPI) 
EEPROM: Not available (can be emulated using flash) 
Operating Voltage: 3.0V to 3.6V 
Input Voltage (recommended): Via 3.3V regulated supply 
Wi-Fi: IEEE 802.11 b/g/n (2.4 GHz, up to 150 Mbps) 
Bluetooth: Bluetooth 5.0 LE with Mesh and Long Range 
Digital I/O Pins: 22 GPIOs 
ADC: 12-bit, up to 6 channels 
UART: 2 
SPI: 2 
I2C: 1 
PWM: Available on all GPIOs 
Timers: Multiple hardware timers 
USB: USB 2.0 Full-Speed (native support) 
Security: AES, SHA, RSA, ECC, Flash Encryption, Secure Boot 
Power Consumption: Active Mode ~130 mA, Light Sleep ~0.8 mA, Deep Sleep ~5 µA 
Package: QFN32 (5 mm × 5 mm) 
Supported Tools: ESP-IDF, Arduino IDE, PlatformIO, MicroPython 

ESP32-C3 Pin Details 
The ESP32-C3 supports flexible pin assignment using its GPIO matrix, allowing peripherals to be remapped to available pins as needed. 

Digital I/O Pins (GPIO0 to GPIO21) 
All GPIOs are multifunctional and support input, output, pull-up/down, PWM, and peripheral mapping. Maximum current draw per GPIO is approximately 20–40 mA depending on usage. 

Important GPIOs 
GPIO0 – Used for boot mode selection during flashing 
GPIO1 and GPIO3 – Default UART TX and RX (avoid using when Serial Monitor is active) 
GPIO9 and GPIO10 – Usually connected to internal flash, should not be used for I/O 
GPIO19 and GPIO20 – USB D- and D+ on some modules 

Analog Input Pins (ADC1 Channels)
 ESP32-C3 has 6 ADC1 channels with 12-bit resolution, mapped to GPIOs like GPIO0 to GPIO5. These are used for reading analog voltages from 0 to 3.3V. 

Power Pins 
3V3 – Regulated 3.3V power input 
GND – Ground reference 
EN – Chip enable (reset if pulled low) 
VBUS – USB power input (5V on USB) 
LDO Cap – Capacitor pin for internal LDO regulator (used in specific modules) 

Communication Pins 
Serial (UART): Default UART uses GPIO1 (TX) and GPIO3 (RX). UARTs can be remapped to other pins using software. 
SPI: SPI0 is reserved for internal flash. SPI1 is available for general-purpose communication and can be mapped to any free GPIOs. 
I2C: Supports one I2C controller in master/slave mode. SDA and SCL lines can be assigned to most GPIOs. Common assignments are GPIO4 (SDA) and GPIO5 (SCL). 
USB: Native USB 2.0 interface supported on modules like ESP32-C3-DevKit. D+ and D- are usually mapped to GPIO19 and GPIO20. 

Security Features 
Hardware-based Flash Encryption 
Secure Boot (version 2) 
Cryptographic acceleration for AES-128/256, SHA-2, RSA-3072, and ECC 
Digital Signature Peripheral
 
Summary 
Digital Pins (GPIO0–GPIO21): General-purpose I/O with PWM and peripheral mapping 
Analog Pins: 6 channels of 12-bit ADC 
Power Pins: 3.3V input, multiple GND, EN, USB VBUS 
Communication Interfaces: UART, SPI, I2C, USB 
Connectivity: Integrated Wi-Fi (2.4 GHz) and Bluetooth 5.0 LE 
Security: Supports advanced encryption, secure boot, and digital signature 
Power Modes: Active (~130 mA), Light Sleep (~0.8 mA), Deep Sleep (~5 µA)

Source Link

some other micro controllers

For Coding

For coding and uploading programs to my microcontroller, I am using the Arduino IDE. It is a user-friendly open-source platform that supports various boards like the ESP32-C3. With the help of its built-in libraries and community support, I can easily write, verify, and upload code to test different hardware functionalities

Arduino Installation Link

Wokwi Introduction

Wokwi Link

Wokwi is an online simulator designed for developing and testing Arduino, ESP32, Raspberry Pi Pico, and other microcontroller-based projects. It allows users to create circuits, write code, and see real-time simulations in a browser without the need for physical hardware. Wokwi supports popular components like LEDs, sensors, displays, and more, making it an excellent tool for prototyping and learning embedded systems quickly and interactively.

As part of the embedded programming assignment, I worked with the ESP32-C3 module integrated with the MPU6050 sensor. I explored I2C communication to read accelerometer and gyroscope data. This setup helped me understand real-time motion sensing and sensor interfacing, laying the foundation for integrating it into my final project.

Coding Part

To interface the MPU6050 sensor with my ESP32-C3 board, I used the Adafruit MPU6050 library in the Arduino IDE. This library simplifies communication with the sensor by providing easy-to-use functions for accessing accelerometer and gyroscope data. After installing the library through the Library Manager, I was able to write and upload code to read motion and orientation values effectively.

Arduino library for the MPU6050 sensors

             #include <Adafruit_MPU6050.h> // Include the library for MPU6050 sensor
#include <Adafruit_Sensor.h>   // Include Adafruit sensor support
#include <Wire.h>              // I2C communication library
Adafruit_MPU6050 mpu;          // Create an MPU6050 sensor object
sensors_event_t event;         // Define a variable to hold sensor data
void setup() {
  Serial.begin(115200);       // Start serial communication at 115200 baud
  pinMode(D2, OUTPUT);        // Set pin D2 as OUTPUT (e.g., for LED or other output)
  pinMode(D3, OUTPUT);        // Set pin D3 as OUTPUT
  Serial.println("");         
  Serial.println("Hello, XIAO ESP32-C3!"); // Welcome message
  Serial.println("Welcome to Wokwi :-)");
  while (!mpu.begin()) {      // Keep trying until MPU6050 initializes
    Serial.println("MPU6050 not connected!"); // Error message
    delay(1000);              // Wait for 1 second before retrying
  }
  Serial.println("MPU6050 ready!"); // MPU6050 successfully initialized
}
void loop() {
  // The following commented lines were for testing LEDs on different pins
  // Serial.println("Red");
  // digitalWrite(D2, HIGH);   // Turn on LED on D2
  // delay(500);               // Wait for 0.5 seconds
  // digitalWrite(D2, LOW);    // Turn off LED
  // Serial.println("Green");
  // digitalWrite(D3, HIGH);   // Turn on LED on D3
  // delay(500);
  // digitalWrite(D3, LOW);    // Turn off LED
  // Serial.println("Blue");
  // digitalWrite(D4, HIGH);   // This line would cause an error unless D4 is defined
  // delay(500);
  // digitalWrite(D4, LOW);
  mpu.getAccelerometerSensor()->getEvent(&event); // Read acceleration data
  Serial.print("[");                 
  Serial.print(millis());           // Print current time in milliseconds
  Serial.print("] X: ");
  Serial.print(event.acceleration.x); // Print X-axis acceleration
  Serial.print(", Y: ");
  Serial.print(event.acceleration.y); // Print Y-axis acceleration
  Serial.print(", Z: ");
  Serial.print(event.acceleration.z); // Print Z-axis acceleration
  Serial.println(" m/s^2");         // Print units
  delay(500);                       // Wait for half a second before next reading
} 
          

To assist with embedded programming, I utilized AI coding tools to help write and debug the code for interfacing the ESP32-C3 with the MPU6050 sensor. These tools provided suggestions, reduced development time, and improved accuracy in setting up I2C communication, making the programming process more efficient and insightful.