4. Embedded programming

group assignments

in the group task, the programming of devices, using various platforms and tools. Environments such as Arduino, Python, and PlatformIO were explored.

Exploring from the basics within programming, from variable declaration to I2C and UART communications.

One of the key focuses was programming microcontrollers like ATtiny and ESP32, where I learned to optimize memory and resource usage to improve device performance. Communication protocols such as I2C and UART, essential for interaction between sensors and actuators, were also explored.

Grupal Assignments

Introduction to Microcontrollers

There are numerous microcontrollers available today, each with unique features. Which one ought to be used, then? In order to respond, we need to take into account a number of factors:

• Type of memory: What kind of memory is required, and how much does it have? (RAM, EEPROM, FLASH)
• Speed: Performance is impacted by processing speed.
• Power consumption: Crucial for applications that run on batteries.
• Connectivity: Does it allow Bluetooth, WiFi, or other forms of communication?
• Number of pins: Digital, analog, PWM, and other input/output choices are included.
• Dimensions: In small applications, size may be important.
• Interface: Protocols for communication such as SPI, UART, I²C, and EDP.
• Cost: Mass production budget considerations.

The microcontroller's datasheet has technical information for all of these features, with the exception of cost.

What is a Microcontroller?

An integrated circuit made specifically for electronic system control is called a microcontroller. It includes:

• The central processing unit, or CPU, processes data and carries out commands.
• RAM: Program-running temporary memory.
• User programs and firmware are stored in flash memory.
• Peripherals: Timers, ADC/DAC, and communication interfaces such as I²C, SPI, and UART.
• GPIOs: Sensors, actuators, and other devices are connected to general-purpose input/output pins.

Microcontrollers are more effective for embedded applications than microprocessors since they combine all required parts onto a single chip.

Types of Microcontrollers

Microcontrollers vary in architecture, impacting performance and capabilities:

• 8-bit MCUs: Low power, simple applications (e.g., ATmega328 in Arduino Uno).
• 16-bit MCUs: More processing power, used in industrial automation.
• 32-bit MCUs: High performance, often found in IoT and robotics (e.g., ESP32, STM32, RP2040).

Popular Microcontrollers and Their Features

Microcontroller	Bits	Speed	Memory	Connectivity
ATmega328 (Arduino Uno)	8-bit	16 MHz	2KB RAM, 32KB Flash	No built-in connectivity
ESP32	32-bit	240 MHz	520KB RAM, 4MB Flash	WiFi, Bluetooth
STM32	32-bit	Up to 480 MHz	Varies	SPI, I²C, UART
RP2040	32-bit	133 MHz	264KB RAM, 2MB Flash	No built-in connectivity

The Basics for Learning to Program

Programming is the procedure of writing and structuring instructions for a computer to carry out specific tasks. These guidelines have been written in a programming language, which converts the code into a format that the machine can understand and execute.

Programming is based on three fundamental principles:

• Input: The computer receives data from the user or from sensors.
• Processing: Calculations, decisions, and operations are made with the data.
• Output: A result is generated, such as displaying information on the screen or activating a device.

Language Overview

Language	Creator and Year	Main Purpose	Problems it solves	Unique Features	Advantages	Disadvantages
Python	Guido van Rossum, 1991	Web development, AI, data science, automation	Simplify development with readable code	Interpreted, dynamic typing, extensive standard library	Easy to learn, versatile, extensive community	Less efficient than C/C++, high memory consumption
C	Dennis Ritchie, 1972	OS development, low-level programming	Delivers hardware efficiency and control	Mid-level language, memory access with pointers	Fast, efficient, used in critical systems	Difficult to learn, prone to memory errors
C++	Bjarne Stroustrup, 1983	High-performance applications, video games, embedded systems	Extend C with OOP and generic programming	Support for OOP, more control over resources	High performance, flexible memory management	High complexity, difficult to debug errors
Assembly	Various (1940-1950)	Low-level programming, direct hardware control	Maximize hardware performance and efficiency	Lower-level, architecture-dependent language	Maximum control, efficiency on specific hardware	Complex, processor dependent
Java	James Gosling, 1995	Business applications, mobile, web	Portability to multiple platforms with the JVM	"Write once, run anywhere" (WORA)	Portability, strong community, automatic memory management	High resource consumption, speed lower than C++
JavaScript	Brendan Eich, 1995	Frontend and backend web development	Makes web pages dynamic	Executed in browser, asynchrony with event loop	Versatile, run in a browser without additional installation	Browser dependency, security issues
Rust	Mozilla Foundation, 2010	Security and performance in secure software	Prevents memory errors	Focus on security without garbage collector	Memory security without losing performance, high efficiency	Steep learning curve, slow builds

Key Programming Concepts

0. Libraries

Libraries are collections of functions and definitions that allow programmers to reuse code, simplifying complex tasks. In Arduino, they are files that facilitate interaction with hardware.

1. Common Syntax Rules

Syntax rules in programming dictate how to write code correctly. They include reserved keywords, declaration of variables with type and name, delimiters to separate statements, and the use of indentation, quotes, and comments. They also address operators and control structures to manage program flow.

Variables:
In Python, variables are declared dynamically, while in C/C++ they require a static declaration. Python allows changing the type of variables, while C/C++ prohibits it without explicit conversion.

2. Control Structures

Control structures manage the flow of code execution. Conditionals (if, else) and loops (for, while) are essential for making decisions and repeating actions. Although Python does not have a native switch statement, it can be simulated with control structures.

3. Functions

Functions are reusable blocks of code that perform specific tasks, allowing you to modularize and simplify your code. They facilitate debugging and maintenance, improving collaboration and program scalability.

4. Comments

Comments are annotations in the code that do not affect its execution, helping other programmers better understand what each block of code does.

5. Initialization of a Pin

Initializing a pin involves configuring a microcontroller pin as an input or output, allowing the reading of sensors or the control of devices.

6. Reading a Pin

Reading a pin means getting its value set as input. On Arduino, this is done with digitalRead() and analogRead().

7. Writing to a Pin

Writing to a pin involves sending signals to a pin configured as an output, allowing control of devices such as LEDs.

8. Analog Reading with ADC

Analog reading refers to obtaining values from continuous signals. An analog to digital converter (ADC) is used to convert the analog signal into a processable digital value.

9. Timers

Timers in microcontrollers manage the frequency of execution of parts of the code, useful for tasks such as flashing an LED or regular sensor readings.

10. Printing

Console printing displays information or results from a program, using functions such as print() in Python or Serial.println() in C/C++.

11. Pulse Width Modulation (PWM)

PWM converts digital signals to analog, controlling devices such as servomotors through the duration of the pulses sent.

12. Interruptions

Interrupts allow a microcontroller to interrupt its current execution to execute a specific function by detecting events such as changes in signals.

Using a XIAO RP2040

Seeed Studio's XIAO RP2040 board features an RP2040 dual-core processor, 264KB of SRAM memory, and 2MB of built-in Flash memory. It has an adaptive clock that can operate up to 133 MHz, making it ideal for portable devices and small initiatives. The board features 14 GPIO pins, including 11 digital, 4 analog, 11 PWM, I2C, 1 UART, 1 SPI, and 1 SWD bonding pad interface.

rp2040_datasheet

Specification

Item	Value
CPU	Dual-core ARM Cortex M0+ processor up to 133MHz
Flash Memory	2MB
SRAM	264KB
Digital I/O Pins	11
Analog I/O Pins	4
PWM Pins	11
I2C interface	1
SPI interface	1
UART interface	1
Power supply and downloading interface	Type-C
Power	3.3V/5V DC
Dimensions	21×17.8×3.5mm

For more information about this microprocessor: https://wiki.seeedstudio.com/XIAO-RP2040/

In addition to that microcontroller, I chose to incorporate a color sensor, since I want to incorporate it into my robot. An example of how it would work would be to pick up something that is a different color than the floor, like a red sock.

Why this?

I want my final project to have the ability to grab objects and "carry" them, so I think a good start would be to recognize the color of things and distinguish them from the ground.

TCS34725

The TCS34725 is an RGB color sensor equipped with an anti-infrared filter and a programmable gain amplifier. It operates by identifying the intensity of red, green, blue, and white light (without a color filter) and transforming it into digital signals that are understandable by a microcontroller.

Main features:

• Integrated IR blocking filter: Minimizes interference caused by infrared light, increasing the accuracy of color identification.
• Large dynamic spectrum: It is appropriate for different light conditions, from environments with low light to those with high light intensity.
• I2C System: Promotes communication with microcontrollers and other devices, which facilitates its integration into different projects.
• 16-bit Analogue-Digital Converters (ADC): They offer high resolution in color measurements.

Common uses:

• Backlight regulation in monitors: Dynamic modification of the backlight depending on the surrounding light conditions.
• Evaluation of color temperature: Establishment of the color temperature of light resources for lighting uses.

Programming with a XIAO RP2040

Push Button to Blink LED

Hardware Connection:

Component	Connection	Description
Seeed XIAO RP2040	-	Main microcontroller
Push Button	- One end to the pin D0 of the XIAO RP2040 - Another end to 3.3V	Input button to control the LED
Resistance 10kΩ	- One end to the pin D0 - Another end to GND	Avoid floating states (pull-down)
Internal LED	- Connected to pin 25 of the XIAO RP2040	No external wiring required

const int buttonPin = D0;     // the number of the pushbutton pin
const int ledPin =  25;      // the number of the LED pin

// const indicates that a variable or object cannot be modified
int buttonState = 0;         // variable for reading the pushbutton status

void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);
}

void loop() {
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);
 
  if (buttonState == HIGH) {
    // turn LED on:
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

Color Sensor

Hardware Connection:

The TCS34725 uses I2C communication (referring to the abbreviation for Inter-IC, a type of bus created by Philips Semiconductors in the early 1980s, used to join integrated circuits), so you must connect its pins to the I2C pins of the XIAO RP2040.

TCS34725	XIAO RP2040	Description
VIN	3V3	Power (3.3V)
GND	GND	-
SDA	GP6	I2C data
SCL	GP7	I2C clock
INT	(Optional)	Interrupt (you can leave it unconnected)
LED	(Optional)	Integrated LED control

Arduino Code (C++)

Here we use Arduino and add the library to the code Adafruit_TCS34725 from the Library Manager.

Code:

1. Included Libraries

#include  // Library for I2C communication
#include "Adafruit_TCS34725.h" // Sensor-specific library

Wire.h: It is the standard Arduino library for managing I2C devices.

Adafruit_TCS34725.h: Adafruit library that facilitates communication with the TCS34725 sensor.

2. Creating the Sensor Object

Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_700MS, TCS34725_GAIN_4X);

Here we create an object called tcs to communicate with the sensor. Two important parameters are configured:

• Integration time: TCS34725_INTEGRATIONTIME_700MS - Controls how long the sensor captures light before sending data. A higher value improves accuracy in dark environments.
• Gain: TCS34725_GAIN_4X - Increases sensor sensitivity. Options: 1X, 4X, 16X, 60X (higher values capture more light).

3. Initial Setup setup()

void setup() {
  Serial.begin(115200);
  Wire.setSDA(6); // GP6 on XIAO RP2040
  Wire.setSCL(7);  // GP7 on XIAO RP2040
  Wire.begin();

Serial.begin(115200); → Starts serial communication at 115200 baud.
Wire.setSDA(6); → Configure GP6 as the SDA line.
Wire.setSCL(7); → Configure GP7 as the SCL line.
Wire.begin(); → Starts I2C communication.

Sensor Check

 if (!tcs.begin()) {
    Serial.println("TCS34725 sensor not found.");
    while (1);
  }

tcs.begin() tries to communicate with the sensor. If it can't find it, it prints the message "TCS34725 sensor not found." and enters an infinite loop (while(1)) to stop the program.

4. Reading Data in loop()

void loop() {
  uint16_t r, g, b, c;
  tcs.getRawData(&r, &g, &b, &c);

Four variables r, g, b, and c of type uint16_t (values from 0 to 65535) are declared.
tcs.getRawData(&r, &g, &b, &c); gets the raw values of the Red, Green, Blue, and Clear Light channels.

5. Show Data in Serial

 Serial.print("R: "); Serial.print(r);
 Serial.print(" G: "); Serial.print(g);
 Serial.print(" B: "); Serial.print(b);
 Serial.print(" C: "); Serial.println(c);

This displays the values R, G, B, and C on the Arduino Serial Monitor.
"C" is the total amount of light detected.

6. Pause Before Next Reading

 delay(1000);

delay(1000); → Wait 1 second before taking another reading.

Final Notes:

The XIAO RP2040 works with 3.3V, so the TCS34725 should also run at 3.3V to avoid damaging the board.