The goal of this week is to begin incorporating the knowledge learned into the different parts of the Final Project. Two primary situations are identified where the project would require programming for proper functionality:
Since these are the first programming exercises, it has been decided to focus on problem number 1.
The areas of learning are two. On one hand, basic coding for reading sensors that activate an LED to indicate when our element is leveled. On the other hand, we need to understand the necessary hardware to develop the exercise. A research study was conducted to determine which sensors could provide the desired results, leading to two options: the gyroscope and the inclinometer. The latter was chosen due to the ease of access to the sensor at that time, and from there, further research was conducted on its interaction with the ESP32 architecture.
To use our ESP32 DevKit S1 processor, the Arduino IDE will be used along with a plugin that facilitates code interpretation for better understanding of our hardware. To do this, it must first be installed from the following link: ESP32 Arduino Add-on
Subsequently, the focus shifts to understanding the basic criteria of digital and analog pins, as well as their relationship within the C programming language, in order to visualize them in the IDE.
Finally, the focus shifts to understanding how to integrate an SW-520D tilt sensor with the ESP32 hardware to achieve and control real-time readings, allowing us to indicate when our object is in an optimal state to execute the program.
The main objective of this week will be to advance with one of the systems of the final project. For this, two tilt sensors will be mounted on a base model, which will have four screws inserted at the corners to allow adaptation to different obstacles. These will be temporarily operated manually.
1. Together with my group partner, we conducted a technical comparison between architectures based on the information provided in their datasheets. We compared the two boards we used, the Xiao Seeeduino and my ESP32 DevKit, with two others to obtain partial results and understand where they perform best.
The ESP32-C3 is a low-power microcontroller based on the RISC-V architecture, featuring built-in Wi-Fi and Bluetooth 5.0 (BLE) support, making it ideal for IoT applications that require secure wireless communication. It also includes secure boot and encryption for enhanced cybersecurity. However, it has a single-core processor, making it less powerful than other ESP32 variants, and its RAM is more limited. It is best suited for low-power IoT projects, secure wireless communication, and battery-operated devices. The RP2040, developed by Raspberry Pi, is a dual-core ARM Cortex-M0+ microcontroller running at 133 MHz. It excels in low-power applications and offers extensive GPIO availability (26 pins), making it highly versatile for embedded projects. It supports MicroPython and C/C++, adding flexibility in development. However, it lacks built-in Wi-Fi or Bluetooth, requiring external modules for wireless communication. This board is ideal for general embedded systems, robotics, and real-time applications where networking is not a priority. The ESP32 DEVKIT-C S1 is a powerful and widely used microcontroller featuring a dual-core processor, integrated Wi-Fi and Bluetooth, and extensive peripheral support. It is great for IoT applications, automation systems, and real-time data monitoring. One of its key advantages is its robust wireless communication and strong processing power. However, it has higher power consumption compared to low-power alternatives like the ESP32-C3, making it less ideal for battery-powered applications. It is best suited for projects requiring continuous wireless connectivity and edge computing. The Arduino Nano 33 IoT is a compact microcontroller designed for IoT applications, featuring an ARM Cortex-M0+ processor, integrated Wi-Fi and Bluetooth connectivity, and a built-in IMU sensor. It is optimized for low-power applications and has a user-friendly development environment, making it accessible to beginners. However, its processing power is lower than the ESP32 series, and it has fewer GPIO pins compared to other boards like the RP2040. This board is perfect for IoT prototyping, environmental monitoring, and projects that require motion sensing due to its built-in IMU.
2. Understanding the basic concepts of sensor assembly, power sources, grounding connections, and the microcontroller, an exercise is proposed to control the illumination of a set of LEDs arranged in a line using a joystick. Depending on the movement along the X-axis, the lighting will gradually and smoothly shift between the LEDs. As an initial testing model, the Wokwi canvas is used.
// Pines del joystick y LEDs const int JOYSTICK_X_PIN = 34; // Entrada analógica del joystick (Eje X) const int LED_LEFT_PIN = 25; // LED izquierdo const int LED_MIDDLE_PIN = 26; // LED central const int LED_RIGHT_PIN = 27; // LED derecho // Rango de entrada del ESP32 (ADC de 12 bits) const int ADC_MIN = 0; const int ADC_MAX = 4095; // Rango de salida PWM (0-255) const int PWM_MIN = 0; const int PWM_MAX = 255; // Variables para suavizar transiciones float smoothLeft = 0; float smoothMiddle = 0; float smoothRight = 0; const float smoothFactor = 0.1; // Cuanto más bajo, más suave la transición // Función para suavizar transiciones usando un filtro exponencial float smoothTransition(float currentValue, float targetValue) { return currentValue + smoothFactor * (targetValue - currentValue); } void setup() { pinMode(LED_LEFT_PIN, OUTPUT); pinMode(LED_MIDDLE_PIN, OUTPUT); pinMode(LED_RIGHT_PIN, OUTPUT); } void loop() { // Leer la posición del joystick en el eje X int joyX = analogRead(JOYSTICK_X_PIN); // Convertir el valor del joystick a un rango de -1.0 (izquierda) a 1.0 (derecha) float position = map(joyX, ADC_MIN, ADC_MAX, -100, 100) / 100.0; // Determinar los valores objetivo para los LEDs según la posición del joystick int targetLeft = map(position * 100, -100, 100, PWM_MAX, PWM_MIN); // Izquierda fuerte int targetMiddle = map(abs(position * 100), 0, 100, PWM_MIN + 100, PWM_MAX); // Medio fuerte en centro int targetRight = map(position * 100, -100, 100, PWM_MIN, PWM_MAX); // Derecha fuerte // Aplicar los valores correctos según las posiciones requeridas if (position < -0.5) { // Joystick a la izquierda targetLeft = PWM_MAX; // 100% targetMiddle = PWM_MAX * 0.4; // 40% targetRight = PWM_MAX * 0.1; // 10% } else if (position > 0.5) { // Joystick a la derecha targetLeft = PWM_MAX * 0.1; // 10% targetMiddle = PWM_MAX * 0.4; // 40% targetRight = PWM_MAX; // 100% } else { // Joystick en el centro targetLeft = PWM_MAX * 0.4; // 40% targetMiddle = PWM_MAX; // 100% targetRight = PWM_MAX * 0.4; // 40% } // Suavizar la transición de los LEDs smoothLeft = smoothTransition(smoothLeft, targetLeft); smoothMiddle = smoothTransition(smoothMiddle, targetMiddle); smoothRight = smoothTransition(smoothRight, targetRight); // Aplicar valores PWM a los LEDs analogWrite(LED_LEFT_PIN, (int)smoothLeft); analogWrite(LED_MIDDLE_PIN, (int)smoothMiddle); analogWrite(LED_RIGHT_PIN, (int)smoothRight); // Pequeño retraso para estabilidad delay(10); }
3. After validation in the simulator, the assembly of the components on the microcontroller is carried out. Following this, its functionality is validated and recorded.
4. The next step was to start testing the possibility of using inclinometers to determine the angle of inclination of a surface relative to the zero plane or the nearest flat surface. For this, inclinometers were purchased. However, it was not possible to use an inclinometer in the simulator, so a gyroscope was used instead to try to replicate the desired functionality.
#include #include #include Adafruit_MPU6050 mpu; #define LED_PIN 2 // Pin donde está conectado el LED #define TOLERANCE 2.0 // Grados de inclinación permitidos void setup() { Serial.begin(115200); pinMode(LED_PIN, OUTPUT); // Inicializar el sensor MPU6050 if (!mpu.begin()) { Serial.println("Error al detectar el MPU6050"); while (1); } } void loop() { sensors_event_t a, g, temp; mpu.getEvent(&a, &g, &temp); // Calcular ángulo de inclinación en el eje Y float angle = atan2(a.acceleration.y, a.acceleration.z) * 180 / PI; Serial.print("Ángulo: "); Serial.println(angle); // Verificar si el sensor está dentro del umbral de equilibrio if (abs(angle) < TOLERANCE) { digitalWrite(LED_PIN, HIGH); // Enciende LED si está plano } else { digitalWrite(LED_PIN, LOW); // Apaga LED si no está alineado } delay(500); // Pequeño retraso para evitar lecturas demasiado rápidas }
5. After the failure in the simulator, the decision was made to proceed with the physical assembly of the inclinometers along with the LED to establish the flatness or level of the device.
#define INCLINOMETER_1_PIN 32 // Pin del primer inclinómetro #define INCLINOMETER_2_PIN 33 // Pin del segundo inclinómetro #define LED_PIN 2 // Pin donde está conectado el LED void setup() { Serial.begin(115200); pinMode(INCLINOMETER_1_PIN, INPUT); pinMode(INCLINOMETER_2_PIN, INPUT); pinMode(LED_PIN, OUTPUT); } void loop() { int state1 = digitalRead(INCLINOMETER_1_PIN); int state2 = digitalRead(INCLINOMETER_2_PIN); Serial.print("Estado 1: "); Serial.print(state1); Serial.print(" | Estado 2: "); Serial.println(state2); // Si ambos sensores indican posición plana (cerrado = 0), encender LED if (state1 == LOW && state2 == LOW) { digitalWrite(LED_PIN, HIGH); } else { digitalWrite(LED_PIN, LOW); } delay(100); // Pequeño retraso para evitar lecturas demasiado rápidas }
6. To verify the proper functioning of the system, a base platform was designed with four legs in the form of lead screws to validate its support on multiple surfaces. For this, Rhinoceros and 3D printing were used to optimize time and design iterations.
7. The final phase of the project consisted of correctly positioning the leveling system inside the 3D-printed base piece and placing it on uneven surfaces to evaluate the result, which turned out to be satisfactory.