diff --git "a/class-material/FakeSensors/Aceler\303\263metro (MPU6050)/readme.md" "b/class-material/FakeSensors/Aceler\303\263metro (MPU6050)/readme.md" new file mode 100644 index 0000000..74c75ba --- /dev/null +++ "b/class-material/FakeSensors/Aceler\303\263metro (MPU6050)/readme.md" @@ -0,0 +1,191 @@ +# Proyecto de Integración de Acelerómetro MPU6050 con ESP32, Python, MQTT y Flespi + +**Alumno**: Lennyn Alejandro Castillejo Robles +**Materia**: Sistemas Programables + +## Introducción + +Este proyecto tiene como objetivo integrar un **acelerómetro MPU6050** con un **ESP32**, procesar los datos en **Python** y luego enviar esos datos a **Flespi** mediante el protocolo **MQTT**. El sistema está diseñado para permitir la visualización de los datos de acelerómetro a través de un **dashboard** de Flespi, utilizando widgets para representar los valores en tiempo real. + +## Componentes Utilizados + +- **ESP32**: Tarjeta de desarrollo basada en un microcontrolador de 32 bits. +- **MPU6050**: Acelerómetro y giroscopio con interfaz I2C. +- **Python**: Lenguaje de programación utilizado para procesar y enviar los datos a través de MQTT. +- **Flespi**: Plataforma IoT para la gestión de datos en tiempo real y visualización mediante MQTT. +- **MQTT**: Protocolo de comunicación utilizado para enviar datos desde el ESP32 a Flespi y otros sistemas. + +## Configuración del Hardware + +1. **Conexión del Acelerómetro al ESP32**: + - **MPU6050** se conecta al **ESP32** utilizando la interfaz **I2C**: + - **VCC** del MPU6050 al **3.3V** del ESP32. + - **GND** del MPU6050 al **GND** del ESP32. + - **SDA** del MPU6050 al **GPIO21** del ESP32. + - **SCL** del MPU6050 al **GPIO22** del ESP32. + +## Configuración del ESP32 + +### Código en el ESP32 (para leer los datos del MPU6050 y enviarlos por MQTT) + +```cpp + import time + import network + from umqtt.simple import MQTTClient + from random import randint + + # Configuración del Wi-Fi + SSID = "Wokwi-GUEST" + PASSWORD = "" + + wifi = network.WLAN(network.STA_IF) + wifi.active(True) + wifi.connect(SSID, PASSWORD) + + while not wifi.isconnected(): + print("Conectando a WiFi...") + time.sleep(1) + + print("✅ WiFi Conectado. IP:", wifi.ifconfig()[0]) + + # Configuración MQTT + BROKER = "test.mosquitto.org" + TOPIC = "geps/sensor" + client = MQTTClient("esp32", BROKER) + client.connect() + + # Función para generar datos del sensor MPU6050 + def generate_sensor_data(): + # Generar valores aleatorios para acelerómetro (x, y, z) + accel_x = randint(-16000, 16000) + accel_y = randint(-16000, 16000) + accel_z = randint(-16000, 16000) + + # Generar valores aleatorios para giroscopio (x, y, z) + gyro_x = randint(-2000, 2000) + gyro_y = randint(-2000, 2000) + gyro_z = randint(-2000, 2000) + + # Devolver los valores como un diccionario + return { + "accel_x": accel_x, + "accel_y": accel_y, + "accel_z": accel_z, + "gyro_x": gyro_x, + "gyro_y": gyro_y, + "gyro_z": gyro_z + } + + # Bucle infinito para el sensor y enviar datos cada 3 segundos + while True: + # Obtener los datos simulados del sensor + sensor_data = generate_sensor_data() + + # Crear el mensaje para MQTT + payload = "Acelerómetro -> x: {0}, y: {1}, z: {2}; Giroscopio -> x: {3}, y: {4}, z: {5}".format( + sensor_data["accel_x"], sensor_data["accel_y"], sensor_data["accel_z"], + sensor_data["gyro_x"], sensor_data["gyro_y"], sensor_data["gyro_z"] + ) + + # Publicar los datos a MQTT + client.publish(TOPIC, payload) # Enviar los datos simulados al topic + print("📤 Enviado:", payload) # Imprimir los datos enviados en la consola + + time.sleep(3) # Esperar 3 segundos antes de enviar los siguientes datos + +``` +![image](https://github.com/user-attachments/assets/e6e4b7c1-391e-47a8-95e8-1bb2b6f997b0) + +## Código de visual code en python +``` +import paho.mqtt.client as mqtt +import time + +# Configuración de Wokwi +WOKWI_BROKER = "test.mosquitto.org" +WOKWI_PORT = 1883 +WOKWI_TOPIC = "geps/sensor" + +# Configuración de Flespi +FLESPI_BROKER = "mqtt.flespi.io" +FLESPI_PORT = 1883 +FLESPI_TOPIC = "geps/sensor" # Puedes cambiarlo según tus necesidades +FLESPI_TOKEN = "EgSoZ4aHSwmmMTHJHkNl1oy7rynU87drVAJMt3HnkzdzDIyAlzEDaYKnC6s6QBFG" # Reemplaza con tu token de Flespi + +# Función para conectar con el broker y verificar la conexión +def on_connect(client, userdata, flags, rc, properties=None): + if rc == 0: + print("✅ Conectado correctamente") + else: + print(f"❌ Error de conexión: {rc}") + +# Función para procesar los mensajes recibidos desde Wokwi +def on_message_wokwi(client, userdata, msg): + try: + payload = msg.payload.decode() + print(f"📥 Recibido de Wokwi: {payload}") + + # Verificar si el mensaje contiene datos del acelerómetro + if 'accelerometer' in payload: + # Procesar los datos del acelerómetro (suponiendo que están en formato JSON o similar) + data = eval(payload) # Convertir la cadena de texto a un diccionario (esto es solo un ejemplo, usa json.loads en lugar de eval) + + accelerometer_data = data.get("accelerometer", {}) + if accelerometer_data: + # Crear un payload para Flespi con solo los datos del acelerómetro + json_payload = { + 'accelerometer': accelerometer_data + } + + # Enviar los datos a Flespi + flespi_client.publish(FLESPI_TOPIC, str(json_payload).replace("'", '"')) + print(f"📤 Enviado a Flespi: {json_payload}") + + # Enviar siempre el mensaje recibido (aunque no sea acelerómetro) + else: + flespi_client.publish(FLESPI_TOPIC, payload) + print(f"📤 Enviado a Flespi (raw): {payload}") + + except Exception as e: + print(f"⚠ Error al procesar mensaje: {e}") + +# Configurar cliente Wokwi (versión actualizada para evitar warning) +wokwi_client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2) +wokwi_client.on_message = on_message_wokwi +wokwi_client.on_connect = on_connect + +# Configurar cliente Flespi +flespi_client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2) +flespi_client.username_pw_set(FLESPI_TOKEN) +flespi_client.on_connect = on_connect + +try: + # Conectar a Flespi + flespi_client.connect(FLESPI_BROKER, FLESPI_PORT) + flespi_client.loop_start() + + # Conectar a Wokwi + wokwi_client.connect(WOKWI_BROKER, WOKWI_PORT) + wokwi_client.subscribe(WOKWI_TOPIC) + print("📡 Esperando datos de Wokwi...") + + # Mantener el script corriendo + wokwi_client.loop_forever() + +except KeyboardInterrupt: + print("\n🔌 Desconectando...") + wokwi_client.disconnect() + flespi_client.disconnect() +except Exception as e: + print(f"❌ Error crítico: {e}") +``` + +![image](https://github.com/user-attachments/assets/2ec6b0c2-01e5-4f69-afde-390c231d303d) + +## Board en MQTT + + +![image](https://github.com/user-attachments/assets/4a5a88c5-d735-41c3-aac4-6b5ed31e4bcd) + + + diff --git a/class-material/FakeSensors/Sensor de sonido (KY-038)/readme.md b/class-material/FakeSensors/Sensor de sonido (KY-038)/readme.md new file mode 100644 index 0000000..19631b3 --- /dev/null +++ b/class-material/FakeSensors/Sensor de sonido (KY-038)/readme.md @@ -0,0 +1,139 @@ +# 📌 Integración del Sensor de Sonido KY-038 con ESP32 y Flespi + +**Alumno**: Lennyn Alejandro Castillejo Robles +**Materia**: Sistemas Programables + +--- + +## 📖 Descripción +Este proyecto documenta la integración de un **ESP32** con un **Sensor de Sonido KY-038** para la monitorización de niveles de sonido en tiempo real. +Los datos son enviados mediante **MQTT** desde **Wokwi** a **Visual Studio Code**, donde se procesan y reenvían a **Flespi** para su visualización en un **dashboard interactivo**. + +--- + +## 🛠️ Tecnologías y Herramientas Utilizadas +- **ESP32** (Simulado en Wokwi) +- **MicroPython** (en ESP32 para lectura del sensor) +- **Mosquitto MQTT** (para comunicación entre dispositivos) +- **Paho MQTT (Python en VS Code)** (para recibir y reenviar datos) +- **Flespi MQTT** (para almacenamiento y visualización) +- **Wokwi** (Simulación del ESP32 y sensor KY-038) + +--- + +## 🏗️ Implementación + +### **1️⃣ Configuración del ESP32 en Wokwi** +Se programó un **ESP32 en Wokwi** con **MicroPython** para leer datos del **Sensor de Sonido KY-038** y enviarlos a **Mosquitto MQTT**. + +```python +import machine +import network +import time +from umqtt.simple import MQTTClient + +# Configuración WiFi en Wokwi +SSID = "Wokwi-GUEST" +PASSWORD = "" +wifi = network.WLAN(network.STA_IF) +wifi.active(True) +wifi.connect(SSID, PASSWORD) + +while not wifi.isconnected(): + time.sleep(1) + +print("✅ WiFi Conectado.") + +# Configurar MQTT +BROKER = "test.mosquitto.org" +TOPIC = "geps/sensor" +client = MQTTClient("esp32", BROKER) +client.connect() + +# Configuración del sensor KY-038 +adc = machine.ADC(machine.Pin(34)) + +while True: + sonido = adc.read() # Leer valor analógico + client.publish(TOPIC, str(sonido)) + print(f"📤 Enviado: {sonido}") + time.sleep(2) + + ``` + +![image](https://github.com/user-attachments/assets/afab46e4-2a3a-469f-b5fc-2a814e19781d) + + ## Código en python en visual code + ``` + import paho.mqtt.client as mqtt +import json + +# Configuración de MQTT para Wokwi +WOKWI_BROKER = "test.mosquitto.org" +WOKWI_PORT = 1883 +WOKWI_TOPIC = "geps/sensor" + +# Configuración de MQTT para Flespi +FLESPI_BROKER = "mqtt.flespi.io" +FLESPI_PORT = 1883 +FLESPI_TOPIC = "geps/sensor" +FLESPI_TOKEN = "9nMgowguNbbC43z3PaqxN22gqgSNCzz6cUeefWheFpXSTpAbBNA5eMHSkmAK7ogL" # + +def on_connect(client, userdata, flags, rc): + if rc == 0: + print("✅ Conectado a Wokwi MQTT Broker.") + client.subscribe(WOKWI_TOPIC) + else: + print(f"❌ Error al conectar: {rc}") + +def on_message(client, userdata, msg): + try: + payload = msg.payload.decode() + print(f"📥 Recibido de Wokwi: {payload}") + + # Convertir mensaje JSON + data = json.loads(payload) + sound_level = data.get("sound_level", 0) + + # Enviar datos a Flespi + json_payload = json.dumps({"sound_level": sound_level}) + flespi_client.publish(FLESPI_TOPIC, json_payload) + print(f"📤 Enviado a Flespi: {json_payload}") + + except Exception as e: + print(f"⚠ Error procesando mensaje: {e}") + +# Cliente MQTT para Wokwi +wokwi_client = mqtt.Client() +wokwi_client.on_connect = on_connect +wokwi_client.on_message = on_message + +# Cliente MQTT para Flespi +flespi_client = mqtt.Client() +flespi_client.username_pw_set(FLESPI_TOKEN) +flespi_client.connect(FLESPI_BROKER, FLESPI_PORT) + +# Conectar a los brokers +wokwi_client.connect(WOKWI_BROKER, WOKWI_PORT) +wokwi_client.loop_start() +flespi_client.loop_start() + +print("📡 Esperando datos de Wokwi...") + +# Mantener el script corriendo +try: + while True: + pass +except KeyboardInterrupt: + print("\n🔌 Desconectando...") + wokwi_client.disconnect() + flespi_client.disconnect() + +``` +![image](https://github.com/user-attachments/assets/fe83e8d6-f1de-4b8e-83a5-80bcf672d447) + + +## Board en Flespi + +![image](https://github.com/user-attachments/assets/b3f30971-85b0-417f-8531-70c930055e0b) +