PyQt5 is a set of Python bindings for Qt, used to create desktop applications with a modern GUI. It requires some knowledge of Python programming and is suitable for more complex PC-based interfaces.

To work with PyQt5, I used Visual Studio Code as the development environment. It’s essential to have Python and the PyQt5 package installed beforehand, and to ensure the environment is properly configured to run and debug graphical applications directly from the editor.

Using Python and with the help of both the official documentation and ChatGPT, I was able to debug a basic script by fixing the errors that were preventing it from running. After installing the Python extension in Visual Studio Code, the script can be executed directly using the "Play" button located in the top-right corner of the editor.

It is important to check the correct installation of both Python and PyQt5 if the code fails to run and an error appears. On this laptop, I didn't have a compatible version of Python installed for PyQt5, so I had to reinstall it to resolve the issue.

This is the initial menu, where we can access either of the two available actuators. Additionally, at the top of the screen, there is a touch button that turns gold when pressed, providing clear visual feedback of the interaction.

As shown here, I also have the option to access one of the specific sections, where I can control the actuators, each with its own dedicated menu.

MIT App Inventor is a block-based programming tool for building Android apps. It uses drag-and-drop components, making it ideal for beginners.

Initial loading screen designed to provide a brief delay while essential resources—such as images, fonts, and system configurations—are being loaded.

This is an introductory video designed to create a visually appealing first impression of the app and enhance its overall aesthetics. It also serves as a smooth transition while resources are initialized in the background.

Initial menu where the user can establish a Bluetooth connection with the ESP32 device. This screen serves as the starting point for pairing the app with the microcontroller, allowing the user to select the available device and initiate communication.

This is one of the app's screens, featuring a color picker that allows the user to choose a specific hue. The selected value is sent to the ESP32, which controls an RGB LED to display the chosen color in real time.

Kodular is an advanced version of App Inventor with more customization and visual components. It's great for building polished Android apps without writing code.

An overview of the Kodular environment and its block-based programming system (Blockly-style). As mentioned earlier, clicking on one of the interface buttons sends a message to the ESP32, provided that a Bluetooth connection is active.

As highlighted in the comparison, Kodular includes a broader range of extensions, visual components, and customization options than other App Inventor-based platforms. It even supports the integration of new features via external add-ons, significantly expanding its development capabilities.

It even supports direct serial communication from a mobile device using the Arduino extension available in Kodular. This allows for sending and receiving data over the serial port, expanding the range of interaction with microcontrollers without requiring an intermediate interface.

This is how the interface appears on the mobile device. So far, only a single screen has been created. At the top, there is a button to open the list of available devices and pair via Bluetooth. At the bottom, there are buttons to turn the LED on or off. When everything is working correctly, no error messages should appear.

Unity is a powerful game engine used to build immersive 3D and VR applications. With Meta devices, you can create virtual environments that interact with hardware like the ESP32. Requires experience in C# and networking.

The process in Unity is more time-consuming and complex, requiring both programming experience and design knowledge. Additionally, the installation and initial setup of the environment can take a considerable amount of time, and a high-performance computer is necessary to ensure a smooth development experience.

The Oculus run on Android, so it is necessary to install the required plugins for this platform.

Once installed, we need to add all the necessary assets and plugins to run the project on the headset. Packages

Para usar las gafas, es requisito tener los drivers instalados junto con el programa correspondiente, por lo que también los estamos instalando mientras el resto se configura.

Now we enable the VR modules in Unity and configure the experience to run on the headset.

Unity, being a collaborative platform with Meta, already includes pre-programmed blocks for interactions, making the work faster and easier when creating VR experiences. I’ve used blocks for the controls, the camera, and object touch interactions for buttons.

Later, you can either use a scene package or create your own. I will use a default one, where I’ll place a table with some buttons for interaction.

Unity allows working with Python to program the actions performed at each instance. Using the MQTT protocol, as covered in week 11, the data is sent via WiFi to the ESP32, and depending on the selected button, the RGB LED is turned on.

Processing is a visual programming language based on Java, commonly used in the creative arts and prototyping. It's beginner-friendly and works well for serial or network-based projects.

For the Processing exercise, we used an ESP32-C3 connected to a Neopixel LED strip. The graphical interface featured a set of eye-shaped colored circles, each corresponding to a specific LED color that could be activated. When a user clicked on the red "eye", for instance, a serial command was sent from Processing to the ESP32-C3, which then lit the LED in red. The same mechanism was used for blue, yellow, and a random mode where the ESP32-C3 would select and display a color at random. This project illustrates key concepts such as serial communication between a PC and microcontroller, RGB LED control, and real-time interactive GUI design for embedded systems.

This is an example of how the system operates. One of the most visually appealing features of the project was that the "eyes" in the graphical interface were not static. Instead, they dynamically tracked the mouse cursortracked the mouse cursor in real time. Each eye rotated to follow the cursor’s position, simulating natural eye movement and giving the GUI a lifelike, interactive quality.

This behavior was implemented by calculating the angle between the center of each eye and the current cursor location, then updating the position of the pupil accordingly. The result was a smooth animation that made the eyes appear to "look" at the user as they moved the mouse. This added not only an aesthetic touch but also enhanced the user experience, making the interface feel more engaging while still serving as a control layer for sending commands to the ESP32-C3 over serial communication.

For the servo motor control example, we initially attempted to use the ESP32-C3, but encountered issues related to PWM signal timing and inconsistent servo behavior. While the ESP32-C3 is capable of generating PWM signals, we noticed erratic movement and latency—likely due to internal clock handling or task scheduling conflicts that interfered with precise timing.

As a solution, we switched to the RP2040, which features dedicated hardware PWM and programmable I/O (PIO) blocks that allow for much more accurate signal generation. With the RP2040, the servos responded quickly and consistently, resulting in smoother operation and a more reliable control setup.