diff --git a/class-material/FakeSensors/Sensor de Corriente ACS712/readme.md b/class-material/FakeSensors/Sensor de Corriente ACS712/readme.md new file mode 100644 index 0000000..a2e2e1d --- /dev/null +++ b/class-material/FakeSensors/Sensor de Corriente ACS712/readme.md @@ -0,0 +1,141 @@ +# Resultados de la Práctica de Programación con Sensor de Corriente ACS712 en Wokwi + +## Descripción del Proyecto + +En esta práctica de programación, se desarrolló y simuló un proyecto utilizando el sensor de corriente **ACS712** con el propósito de medir la corriente que pasa y visualizar el resultado en un **monitor serial**. El proyecto se implementó en la plataforma **Wokwi**, simulando un circuito con el microcontrolador **ESP32**. + +### Objetivo + +El objetivo principal de esta práctica fue aprender a utilizar el sensor **ACS712** para medir la distancia en un entorno simulado en **Wokwi**. Los resultados de la medición se envían al monitor serial para observar la corriente que recibe el sensor. + +## Requisitos + +- Cuenta en Wokwi. +- Conocimientos básicos de programación en **C/C++** para **ESP32**. +- Conocimientos de cómo funcionan los sensor de corriente ACS712. + +## Hardware Utilizado + +- **Microcontrolador:** ESP32 +- **Sensor de Corriente:** ACS712 + +## Link de Wokwi: +https://wokwi.com/projects/427249570362939393 + +## Video demostracion en Loom del codigo: +https://www.loom.com/share/234a7e0d41a94cfa9a9d7d28b1059402?sid=7c1ad1e5-d467-4a0e-a9f3-e836190731e0 + +## Código Fuente + +El código que se implementó para medir la distancia con el sensor ultrasónico **HC-SR04** es el siguiente: + +```cpp +#include +#include + +// Definir el pin para leer el sensor ACS712 +#define SensorPin A0 // Pin analógico A0 para leer el voltaje del ACS712 + +// Datos de la red Wi-Fi +const char* ssid = "Wokwi-GUEST"; // Reemplaza con tu SSID +const char* password = ""; // Reemplaza con tu contraseña de Wi-Fi + +// Datos de Flespi +const char* mqtt_server = "mqtt.flespi.io"; // Servidor MQTT de Flespi +const char* mqtt_token = "l3VDhmTWtzu6Dbu8kh1POdvVqKMOljAn9MLkQ1KxATR3seK8gYyhHUKezHtnNX15"; // Tu token de Flespi +const char* mqtt_topic = "Sensores/ACS712"; // Tema MQTT para enviar la corriente + +WiFiClient espClient; +PubSubClient client(espClient); + +void setup() { + Serial.begin(115200); // Iniciar la comunicación serial + + // Configurar el pin del sensor como entrada + pinMode(SensorPin, INPUT); + + // Conectar a la red Wi-Fi + setup_wifi(); + + // Configurar el servidor MQTT + client.setServer(mqtt_server, 1883); +} + +void setup_wifi() { + delay(10); + Serial.println("📡 Conectando a WiFi..."); + + // Conexión Wi-Fi + WiFi.begin(ssid, password); + int retries = 0; + + // Esperar hasta que se conecte o llegue al límite de reintentos + while (WiFi.status() != WL_CONNECTED && retries < 20) { // Intentar 20 veces + delay(500); + retries++; + } + + if ((WiFi.status() == WL_CONNECTED)){ + delay(500); + Serial.println("✅ WiFi conectado!"); + } + else{ + delay(500); + Serial.println("🚫 Sin conexion WiFi"); + Serial.println("Estado WiFi: " + String(WiFi.status())); + } +} + +void reconnectMQTT() { + while (!client.connected()) { + Serial.println("👨‍💻 Conectando a MQTT..."); + if (client.connect("ESP32Client", mqtt_token, "")) { + Serial.println("✅ Conectado a MQTT!"); + } + else { + Serial.print("❌ Fallo MQTT, rc="); + Serial.println(client.state()); + switch (client.state()) { + case -1: Serial.println("Error de conexión, motivo: No hay conexión."); break; + case -2: Serial.println("Error de conexión, motivo: No se pudo encontrar el broker MQTT."); break; + case -3: Serial.println("Error de conexión, motivo: Conexión rechazada por broker."); break; + case -4: Serial.println("Error de conexión, motivo: Credenciales incorrectas."); break; + default: Serial.println("Error desconocido."); break; + } + Serial.println("🔄 Reintentando en 5 segundos... "); + delay(5000); + } + } +} + +void loop() { + if (!client.connected()) { + reconnectMQTT(); + } + client.loop(); + + // Leer el valor analógico del sensor ACS712 + int sensorValue = analogRead(SensorPin); // Valor entre 0 y 4095 + + // Convertir el valor a voltaje (3.3V de referencia en ESP32) + float voltage = sensorValue * (3.3 / 4095.0); // Convertir a voltaje + + // Calcular la corriente basada en el voltaje + // El valor de referencia es 2.5V, y la sensibilidad es 0.185 A/V para el ACS712 + float current = (voltage - 2.5) / 0.185; + + // Imprimir el valor de la corriente en el monitor serial + Serial.print("Voltaje: "); + Serial.print(voltage); + Serial.print(" V, Corriente: "); + Serial.print(current); + Serial.println(" A"); + + // Enviar la corriente a Flespi a través de MQTT + char msg[50]; + snprintf(msg, 50, "{\"current\": %.3f}", current); // Formato JSON + client.publish(mqtt_topic, msg); + + delay(1000); // Hacer una pausa de 1 segundo +} + diff --git "a/class-material/FakeSensors/Sensor de nivel ultras\303\263nico (HC-SR04)/readme.md" "b/class-material/FakeSensors/Sensor de nivel ultras\303\263nico (HC-SR04)/readme.md" new file mode 100644 index 0000000..c16f08a --- /dev/null +++ "b/class-material/FakeSensors/Sensor de nivel ultras\303\263nico (HC-SR04)/readme.md" @@ -0,0 +1,161 @@ +# Resultados de la Práctica de Programación con Sensor Ultrasónico HC-SR04 en Wokwi + +## Descripción del Proyecto + +En esta práctica de programación, se desarrolló y simuló un proyecto utilizando el sensor ultrasónico **HC-SR04** con el propósito de medir la distancia y visualizar el resultado en un **monitor serial**. El proyecto se implementó en la plataforma **Wokwi**, simulando un circuito con el microcontrolador **ESP32**. + +### Objetivo + +El objetivo principal de esta práctica fue aprender a utilizar el sensor ultrasónico **HC-SR04** para medir la distancia en un entorno simulado en **Wokwi**. Los resultados de la medición se envían al monitor serial para observar la distancia en centímetros. + +## Requisitos + +- Cuenta en Wokwi. +- Conocimientos básicos de programación en **C/C++** para **ESP32**. +- Conocimientos de cómo funcionan los sensores ultrasónicos HC-SR04. + +## Hardware Utilizado + +- **Microcontrolador:** ESP32 +- **Sensor Ultrasónico:** HC-SR04 + - **VCC** al pin **5V** de ESP32 + - **GND** al pin **GND** de ESP32 + - **Trig** al pin **3** de ESP32 + - **Echo** al pin **4** de ESP32 + +- **Conexiones:** + - El sensor **HC-SR04** se conecta a los pines digitales de Arduino para la transmisión de señales de disparo y eco. + +## Esquema de Circuito + +El circuito se simuló en Wokwi con la siguiente configuración: + +- El **pin Trig** del sensor está conectado al pin **5** de ESP32. +- El **pin Echo** del sensor está conectado al pin **7** de ESP32. +- El **VCC** se conecta al pin de **5V** de ESP32. +- El **GND** se conecta al pin de **GND** de ESP32. + +## Link de Wokwi para mejor identificacion de los pines: +https://wokwi.com/projects/427202158131296257 + +## Video demostracion en Loom del codigo: +https://www.loom.com/share/dea4bcdfa9d24c24bd2977aa33cb42da?sid=a5f5cf3c-c0de-4c44-8808-de383a820ed0 + +## Código Fuente + +El código que se implementó para medir la distancia con el sensor ultrasónico **HC-SR04** es el siguiente: + +```cpp +#include +#include + +// Definir los pines del sensor +#define Trigger 2 // Pin digital 2 para el Trigger del sensor +#define Echo 4 // Pin digital 4 para el Echo del sensor + +// Definir las variables +long t; // Tiempo que demora en llegar el eco +long d; // Distancia en centímetros + +// Datos de la red Wi-Fi +const char* ssid = "Wokwi-GUEST"; // Reemplaza con tu SSID +const char* password = ""; // Reemplaza con tu contraseña de Wi-Fi + +// Datos de Flespi +const char* mqtt_server = "mqtt.flespi.io"; // Servidor MQTT de Flespi +const char* mqtt_token = "l3VDhmTWtzu6Dbu8kh1POdvVqKMOljAn9MLkQ1KxATR3seK8gYyhHUKezHtnNX15"; // Tu token de Flespi +const char* mqtt_topic = "Sensores/HC-SR04"; // Tema MQTT para enviar la distancia + +WiFiClient espClient; +PubSubClient client(espClient); + +void setup() { + Serial.begin(115200); // Iniciar la comunicación serial + pinMode(Trigger, OUTPUT); // Pin como salida + pinMode(Echo, INPUT); // Pin como entrada + digitalWrite(Trigger, LOW); // Inicializamos el pin con 0 + + // Conectar a la red Wi-Fi + setup_wifi(); + + // Configurar el servidor MQTT + client.setServer(mqtt_server, 1883); +} + +void setup_wifi() { + delay(10); + Serial.println("📡 Conectando a WiFi..."); + + // Conexión Wi-Fi + WiFi.begin(ssid, password); + int retries = 0; + + // Esperar hasta que se conecte o llegue al límite de reintentos + while (WiFi.status() != WL_CONNECTED && retries < 20) { // Intentar 20 veces + delay(500); + retries++; + } + + if ((WiFi.status() == WL_CONNECTED)){ + delay(500); + Serial.println("✅ WiFi conectado!"); + } + else{ + delay(500); + Serial.println("🚫 Sin conexion WiFi"); + Serial.println("Estado WiFi: " + String(WiFi.status())); + } +} + +void reconnectMQTT() { + while (!client.connected()) { + Serial.println("👨‍💻 Conectando a MQTT..."); + if (client.connect("ESP32Client", mqtt_token, "")) { + Serial.println("✅ Conectado a MQTT!"); + } + else { + Serial.print("❌ Fallo MQTT, rc="); + Serial.println(client.state()); + switch (client.state()) { + case -1: Serial.println("Error de conexión, motivo: No hay conexión."); break; + case -2: Serial.println("Error de conexión, motivo: No se pudo encontrar el broker MQTT."); break; + case -3: Serial.println("Error de conexión, motivo: Conexión rechazada por broker."); break; + case -4: Serial.println("Error de conexión, motivo: Credenciales incorrectas."); break; + default: Serial.println("Error desconocido."); break; + } + Serial.println("🔄 Reintentando en 5 segundos... "); + delay(5000); + } + } +} + +void loop() { + if (!client.connected()) { + reconnectMQTT(); + } + client.loop(); + + // Enviar un pulso de 10us al Trigger del sensor + digitalWrite(Trigger, HIGH); + delayMicroseconds(10); // Enviar un pulso de 10us + digitalWrite(Trigger, LOW); + + // Recibir el pulso de respuesta del sensor por el pin Echo + t = pulseIn(Echo, HIGH); // Obtener el ancho del pulso + + // Calcular la distancia + d = t / 59; // Escalar el tiempo a una distancia en cm + + // Imprimir la distancia en el monitor serial + Serial.print("Distancia: "); + Serial.print(d); // Enviar serialmente el valor de la distancia + Serial.print(" cm"); + Serial.println(); + + // Enviar la distancia a Flespi a través de MQTT + char msg[50]; + snprintf(msg, 50, "{\"distance\": %ld}", d); // Formato JSON + client.publish(mqtt_topic, msg); + + delay(1000); // Hacer una pausa de 1 segundo +} diff --git a/class-material/U1/sensores/Sensores de Nivel de Liquidos/readme.md b/class-material/U1/sensores/Sensores de Nivel de Liquidos/readme.md new file mode 100644 index 0000000..5dffa33 --- /dev/null +++ b/class-material/U1/sensores/Sensores de Nivel de Liquidos/readme.md @@ -0,0 +1,134 @@ +# Investigación sobre Sensores de Nivel de Líquidos (Ultrasónico, Flotador, Radar) + +Los sensores de nivel de líquidos son dispositivos fundamentales en una variedad de industrias para monitorear el nivel de líquidos en tanques, depósitos y otros contenedores. +Existen varios tipos de sensores de nivel, cada uno con características específicas que lo hacen adecuado para diferentes aplicaciones. + +--- + +## 1. Sensor de Nivel Ultrasónico + +![Sensor de Nivel Ultrasonico](https://th.bing.com/th/id/R.0dd8ca63c1b41438a23a5d174f87e175?rik=Hi7JSue7bucA6g&pid=ImgRaw&r=0) + +### Funcionamiento: +El **sensor ultrasónico** utiliza ondas acústicas de alta frecuencia para medir la distancia entre el sensor y el líquido. El sensor emite pulsos ultrasónicos que viajan hacia la superficie del líquido. Cuando los pulsos llegan a la superficie del líquido, se reflejan de vuelta al sensor. El tiempo que tarda el pulso en regresar es utilizado para calcular el nivel del líquido, basándose en la velocidad de propagación del sonido en el aire. + +#### Principio de medición: +- **Tiempo de vuelo (ToF)**: La tecnología ultrasónica se basa en el tiempo que tarda el pulso acústico en ir y volver de la superficie del líquido. Conociendo la velocidad del sonido en el aire, el sensor calcula la distancia. + +#### Rango de Medición: +- Generalmente, los sensores ultrasónicos tienen un rango de medición que varía entre 0.25 m hasta 10 m, dependiendo del modelo y las condiciones ambientales. + +### Aplicaciones: +- **Industria química y petroquímica**: Monitoreo de líquidos como productos químicos, petróleo, agua, entre otros. +- **Tratamiento de aguas**: Control de niveles en estanques o tanques de tratamiento de aguas residuales. +- **Industria alimentaria**: Medición de líquidos en procesos de producción de alimentos y bebidas. +- **Almacenaje de productos**: Control de nivel en tanques de almacenamiento de productos líquidos en general. + +### Ventajas: +- **Sin contacto**: No requiere que el sensor entre en contacto directo con el líquido, lo que reduce el desgaste y la contaminación. +- **Versatilidad**: Funciona con una amplia gama de líquidos, incluyendo agua, aceites y productos químicos. +- **Fácil instalación**: Generalmente, estos sensores son fáciles de instalar y mantener. +- **Precisión**: Ofrecen alta precisión en condiciones estables. + +### Desventajas: +- **Sensibilidad a condiciones ambientales**: Factores como la temperatura, la presión y la humedad pueden afectar el rendimiento del sensor. +- **Limitaciones en líquidos turbulentos**: Las ondas ultrasónicas pueden ser reflejadas de manera irregular en líquidos agitados o con mucha espuma. +- **Rango limitado**: En algunos casos, tienen un rango limitado de medición en comparación con otras tecnologías, como el radar. + +### Ejemplo práctico: +En un **tanque de almacenamiento de agua** en una planta de tratamiento de aguas, un sensor ultrasónico se coloca en la parte superior del tanque para medir el nivel de agua en tiempo real, ayudando a gestionar el llenado y evitar desbordamientos. + +--- + +## 2. Sensor de Nivel de Flotador + +![Sensor de Nivel de Flotador](https://th.bing.com/th/id/R.7242f9d4afb86633335458139e0cb361?rik=YnWSflWD%2bmVWNg&pid=ImgRaw&r=0) + +### Funcionamiento: +El **sensor de nivel de flotador** se basa en un principio mecánico. Un flotador, que es un objeto que flota sobre la superficie del líquido, se conecta a un mecanismo (generalmente una varilla o un imán) que está asociado con un interruptor o un transductor. A medida que el nivel del líquido sube o baja, el flotador se mueve y activa el mecanismo, proporcionando una señal correspondiente al nivel del líquido. + +#### Tipos de flotadores: +- **Flotador magnético**: Tiene un imán dentro del flotador que interactúa con un sensor de efecto Hall o con un interruptor de conmutación. +- **Flotador mecánico**: Utiliza una varilla que se mueve hacia arriba o hacia abajo, activando una señal de contacto a medida que el nivel cambia. + +### Aplicaciones: +- **Sistemas domésticos**: Control de nivel en cisternas de inodoros y sistemas de agua de viviendas. +- **Industria de la construcción**: Medición del nivel de líquidos en maquinaria pesada y cisternas. +- **Vehículos de almacenamiento**: Medición de nivel en vehículos cisterna. +- **Agricultura**: En sistemas de riego automatizados, para controlar el nivel de agua en reservorios. + +### Ventajas: +- **Simplicidad**: Tecnología sencilla y robusta. +- **Bajo costo**: Los sensores de flotador suelen ser más económicos que otras tecnologías. +- **Fiabilidad**: Son muy fiables en aplicaciones simples y no requieren calibración frecuente. +- **Fácil instalación y mantenimiento**. + +### Desventajas: +- **Limitaciones en aplicaciones complejas**: No son adecuados para líquidos altamente viscosos, corrosivos o con partículas suspendidas sin protección adicional. +- **Desgaste**: El flotador puede desgastarse debido al movimiento constante en el líquido. +- **Inexactitud en líquidos turbulentos**: Si el líquido no es estable, el flotador puede moverse erráticamente y no reflejar el nivel real. + +### Ejemplo práctico: +En un **tanque de gasolina** en una estación de servicio, el flotador se usa para monitorear el nivel del combustible. A medida que el combustible sube o baja, el flotador se desplaza y activa un interruptor que indica el nivel. Además, los sensores de flotador se utilizan en **tanques de agua potable** en edificios residenciales, regulando el llenado y evitando desbordamientos. + +--- + +## 3. Sensor de Nivel Radar + +![Sensor de Nivel Radar](https://th.bing.com/th/id/OIP._qUzuM789WkR7nFsh1Dd1gAAAA?rs=1&pid=ImgDetMain) + +### Funcionamiento: +El **sensor de radar** utiliza ondas electromagnéticas (radar) para medir el nivel de líquidos. El sensor emite una señal de microondas hacia la superficie del líquido. La señal se refleja de vuelta al sensor, y el tiempo que tarda en regresar se utiliza para calcular el nivel. Este principio es similar al de los sensores ultrasónicos, pero con la ventaja de que las ondas de radar son menos afectadas por factores ambientales como la temperatura, el vapor o la presión. + +#### Diferencias clave con los sensores ultrasónicos: +- **Velocidad de propagación**: Las ondas de radar viajan a la velocidad de la luz, mientras que las ondas ultrasónicas viajan a la velocidad del sonido. +- **Condiciones extremas**: El radar es menos sensible a la temperatura, el vapor o las turbulencias que afectan a los sensores ultrasónicos. + +### Aplicaciones: +- **Industria química y farmacéutica**: Control de líquidos agresivos, como ácidos, bases y productos químicos. +- **Industria alimentaria y de bebidas**: Medición de líquidos viscosos y productos como jugos, aceites y leche. +- **Plantas de energía**: Medición de líquidos a alta presión y temperatura. +- **Refinerías de petróleo**: Medición precisa de líquidos con condiciones difíciles, como vapores y altas temperaturas. + +### Ventajas: +- **Alta precisión**: Proporciona mediciones precisas, incluso en condiciones extremas. +- **No influenciado por condiciones ambientales**: A diferencia de los ultrasónicos, el radar no se ve afectado por el vapor, las altas temperaturas o la presión. +- **No necesita contacto**: Similar al ultrasónico, el radar es una tecnología sin contacto, lo que evita la contaminación del líquido. +- **Amplio rango de aplicaciones**: Puede medir niveles en líquidos con alta viscosidad, alta temperatura o agresivos. + +### Desventajas: +- **Costo elevado**: Es una de las tecnologías más caras. +- **Instalación compleja**: Requiere una instalación y configuración más especializada. +- **Puede ser sensible a la geometría del tanque**: En algunos casos, la forma del tanque puede afectar la precisión del sensor. + +### Ejemplo práctico: +En una **planta petroquímica**, los sensores de radar se utilizan para monitorear el nivel de crudo en tanques de almacenamiento a altas temperaturas y con vapores. La alta precisión es crucial para garantizar la seguridad y el control de inventarios. Además, los sensores de radar se utilizan en **plantas de energía nuclear**, donde la medición precisa de líquidos en condiciones extremas es vital. + +--- + +## Conclusiones: + +- **Sensores Ultrasónicos**: Son económicos, fáciles de instalar y adecuados para muchas aplicaciones, pero sensibles a condiciones ambientales como vapor y temperatura. +- **Sensores de Flotador**: Son simples, confiables y baratos, pero tienen limitaciones en aplicaciones más complejas o líquidos agitados. +- **Sensores de Radar**: Ofrecen alta precisión y son ideales para condiciones extremas, pero su costo es elevado y su instalación más compleja. + +| Característica | Sensor de Nivel Ultrasónico | Sensor de Nivel de Flotador | Sensor de Nivel Radar | +|-------------------------------|------------------------------------------------|-----------------------------------------------|--------------------------------------------| +| **Funcionamiento** | Emite ondas ultrasónicas que se reflejan en la superficie del líquido. | Un flotador se mueve con el nivel del líquido, activando un interruptor o transductor. | Emite ondas de radar que se reflejan en la superficie del líquido. | +| **Rango de Medición** | 0.25 m a 10 m (dependiendo del modelo). | Limitado, generalmente a unos pocos metros. | Rango amplio, adecuado para condiciones extremas. | +| **Condiciones Ambientales** | Afectado por temperatura, presión y humedad. | No afectado, pero el flotador puede desgastarse. | No afectado por vapor, temperatura o presión. | +| **Precisión** | Alta precisión en condiciones estables. | Menos preciso, especialmente en líquidos turbulentos. | Alta precisión, incluso en condiciones extremas. | +| **Costo** | Moderado, más accesible que el radar. | Bajo costo. | Alto costo. | +| **Instalación** | Relativamente fácil de instalar. | Muy fácil de instalar y mantener. | Instalación compleja y especializada. | +| **Aplicaciones** | Industria química, tratamiento de aguas, alimentos, almacenaje de líquidos. | Sistemas domésticos, vehículos cisterna, agricultura. | Industria química, alimentaria, plantas de energía y refinerías. | +| **Ventajas** | Sin contacto, fácil instalación, versátil. | Simple, confiable, económico. | Alta precisión, no afectado por condiciones extremas. | +| **Desventajas** | Sensible a condiciones ambientales, limitado en rango. | Limitado en aplicaciones complejas, puede desgastarse. | Costo elevado, instalación compleja. | + + +--- + +## Referencias Técnicas: +1. *Introduction to Level Measurement: Ultrasonic, Radar, and Float Technologies* by Endress+Hauser. +2. *Ultrasonic and Radar Level Measurement* by Siemens. +3. *Level Measurement Technologies and Their Applications* by KROHNE. +4. *Sensors and Transducers for Industrial Applications* by Omega Engineering. diff --git a/class-material/u2/desafio/Cruz Patino Diego - Desafio Agricultura/readme.md b/class-material/u2/desafio/Cruz Patino Diego - Desafio Agricultura/readme.md new file mode 100644 index 0000000..395b93d --- /dev/null +++ b/class-material/u2/desafio/Cruz Patino Diego - Desafio Agricultura/readme.md @@ -0,0 +1,83 @@ +# Sistema de Riego Automatizado para Finca + +Este sistema de riego automatizado está diseñado para una finca de 5 hectáreas en una zona rural con conectividad limitada y energía solar. El objetivo es automatizar el riego para optimizar el uso del agua y mejorar el rendimiento de los cultivos. A continuación, se describe la arquitectura propuesta, que incluye la selección de sensores, dispositivos, protocolos de comunicación, plataformas en la nube y la lógica de riego. + +## Requerimientos + +- **Sensores**: Medición de humedad del suelo, temperatura ambiente y nivel de agua en el tanque. +- **Conectividad**: 3G (intermitente y de baja estabilidad). +- **Energía**: Paneles solares (consumo eficiente). +- **Plataforma en la nube**: Visualización en tiempo real y gestión de alertas. + +--- + +## Arquitectura Propuesta + +### 1. **Sensores** + +Para la correcta automatización del riego, seleccionamos tres tipos de sensores que proporcionan la información clave para tomar decisiones de riego: + +- **Sensor de Humedad del Suelo (Capacitivo)** + - **Modelo**: YL-69 (sensor capacitivo de humedad del suelo). + - **Por qué**: Este sensor mide la humedad del suelo, proporcionando datos cruciales para determinar cuándo debe activarse el sistema de riego. + - **Ventaja**: Comparado con los sensores resistivos, los capacitivos son más duraderos y menos propensos a la corrosión, lo que es crucial en condiciones exteriores. + +- **Sensor de Temperatura y Humedad Ambiente** + - **Modelo**: DHT22 (temperatura y humedad). + - **Por qué**: La temperatura y la humedad ambiental son factores importantes para el cálculo de la evaporación y la transpiración de las plantas, lo que impacta directamente en la cantidad de agua que necesita el cultivo. + +- **Sensor de Nivel de Agua en el Tanque** + - **Modelo**: Sensor ultrasónico HC-SR04. + - **Por qué**: Este sensor medirá el nivel de agua en el tanque de almacenamiento. Esto ayudará a evitar que el sistema de riego se active sin suficiente agua, evitando daños en la bomba. + +### 2. **Microcontrolador / SBC (Single Board Computer)** + +- **Modelo**: **ESP32** + - **Por qué**: El ESP32 es ideal para este tipo de proyectos debido a su bajo consumo de energía, capacidad de conectividad Wi-Fi y Bluetooth, y su potencia de procesamiento. + - **Conectividad**: Aunque la finca tiene conectividad limitada (3G), el ESP32 puede conectarse a un módem 3G o 4G para enviar datos a la nube. + - **Eficiencia Energética**: El ESP32 tiene modos de bajo consumo (Deep Sleep) que optimizan el uso de la energía solar. + +### 3. **Procesamiento de Datos y Envío** + +- **Edge Device**: El ESP32 será responsable de la adquisición de los datos de los sensores, el procesamiento básico y la toma de decisiones sobre el riego. + - **Tareas**: + - Leer los datos de los sensores (suelo, temperatura, humedad). + - Evaluar la condición de los cultivos en base a la humedad del suelo y la temperatura ambiente. + - Controlar la bomba de riego en función de las decisiones de riego. + - Enviar datos a la nube de forma periódica (cada hora o cuando se detecte un evento relevante, como una baja humedad en el suelo). + - **Frecuencia de Envío**: Los datos no se enviarán constantemente para ahorrar en costos de transmisión. El ESP32 enviará los datos a la nube cada 30 minutos o en eventos específicos, como si el nivel de humedad del suelo es bajo o si la bomba de riego no está funcionando correctamente. + - **Estrategia de Energía**: El ESP32 entrará en modo de bajo consumo (Deep Sleep) entre los períodos de transmisión. + +### 4. **Protocolos de Comunicación** + +- **MQTT sobre 3G**: + - **Por qué**: MQTT es un protocolo ligero y eficiente para enviar datos con bajo ancho de banda. Es ideal para aplicaciones con conectividad limitada como en este caso, donde la conexión es intermitente. + - **Configuración**: El ESP32 enviará datos al broker MQTT cada vez que haya una actualización significativa en las condiciones del suelo o del sistema de riego. + - **Cliente MQTT**: El ESP32 actuará como cliente, publicando los datos de los sensores a un servidor MQTT en la nube. + +### 5. **Plataforma en la Nube** + +- **Plataforma**: **Flespi MQTT + Grafana** + - **Flespi MQTT**: Es una plataforma de gestión de datos IoT que soporta MQTT y permite la integración con diversos servicios de visualización y almacenamiento de datos. Flespi es adecuado para gestionar la comunicación con dispositivos IoT de forma eficiente, soportando baja conectividad y sincronización. + - **Grafana**: Es una herramienta poderosa para la visualización de datos. Se utilizará para crear un dashboard interactivo que muestre en tiempo real los datos de humedad del suelo, temperatura, nivel de agua y el estado del sistema de riego. + - **Alertas**: A través de Grafana, se pueden configurar alertas (por ejemplo, si la humedad del suelo es demasiado baja o si hay fallos en la bomba de riego), enviando notificaciones por correo electrónico o incluso SMS. + +### 6. **Lógica de Riego Automático** + +La lógica de riego se basará en las condiciones del suelo y el clima, además del nivel de agua en el tanque. Se implementará de la siguiente manera: + +- **Condiciones del Suelo**: Si la humedad del suelo es inferior al umbral predefinido (por ejemplo, 30%), el sistema de riego se activará. +- **Condiciones Climáticas**: Si la temperatura ambiente es alta y la humedad es baja, el riego será más intensivo. Si las condiciones son frescas y la humedad alta, el sistema puede no activarse. +- **Nivel de Agua**: Si el nivel de agua en el tanque es inferior a un umbral crítico, el sistema de riego no se activará para evitar que la bomba funcione sin suficiente agua. + +### 7. **Sostenibilidad Energética** + +- El sistema de riego se alimentará principalmente a través de energía solar, lo que requiere un diseño eficiente en términos de consumo de energía. +- El ESP32, al utilizar el modo de bajo consumo, y los sensores (que solo activan lecturas cuando es necesario) optimizarán el uso de la energía disponible. +- La bomba de riego se controlará a través de un relé, permitiendo que se active únicamente cuando sea necesario, y apagándose de inmediato una vez que se logre el nivel de humedad adecuado. + +--- + +## Conclusión + +Este sistema de riego automatizado está diseñado para operar de manera eficiente, tanto en términos de consumo energético como de uso de la conectividad limitada. Utilizando sensores adecuados, el ESP32 como microcontrolador, MQTT para la transmisión de datos y Grafana para la visualización y gestión de alertas, se puede lograr un sistema robusto y fiable para la finca, permitiendo un monitoreo en tiempo real y una gestión eficiente del riego. diff --git a/class-material/u2/desafio/Cruz Patino Diego - Desafio Calidad del Aire/desafiocalidadaire.md b/class-material/u2/desafio/Cruz Patino Diego - Desafio Calidad del Aire/desafiocalidadaire.md new file mode 100644 index 0000000..d4af535 --- /dev/null +++ b/class-material/u2/desafio/Cruz Patino Diego - Desafio Calidad del Aire/desafiocalidadaire.md @@ -0,0 +1,95 @@ +# Estación de Monitoreo de Calidad del Aire en Zonas Escolares + +Este proyecto tiene como objetivo implementar una solución de monitoreo de calidad del aire para detectar y mitigar el impacto de la contaminación en la salud. Se han seleccionado sensores para medir los niveles de dióxido de nitrógeno (NO₂), monóxido de carbono (CO), material particulado (PM2.5), temperatura y humedad. Los datos se almacenarán localmente y se enviarán a la nube para su análisis y visualización. + +## Objetivos del Proyecto + +1. Medir la calidad del aire en zonas cercanas a las escuelas. +2. Detectar posibles picos de contaminación que puedan afectar la salud de los niños. +3. Visualizar los datos en tiempo real mediante **Grafana** y **InfluxDB**. +4. Generar alertas automáticas cuando los niveles de contaminación superen umbrales predefinidos. +5. Implementar una solución de bajo mantenimiento, que funcione con energía solar o de farola. + +## Sensores Utilizados + +### 1. **Dióxido de Nitrógeno (NO₂)** + - **Sensor:** MiCS-5524 o CCS811 + - **Justificación:** Sensores de gases que permiten medir NO₂ con buena precisión para aplicaciones urbanas. + +### 2. **Monóxido de Carbono (CO)** + - **Sensor:** MQ-7 o MiCS-5524 + - **Justificación:** El MQ-7 es ampliamente utilizado para la medición de CO en entornos urbanos. + +### 3. **Material Particulado (PM2.5)** + - **Sensor:** Plantower PMS5003 o Nova Fitness SDS011 + - **Justificación:** Sensores precisos para medir PM2.5 y PM10 en ambientes urbanos. + +### 4. **Temperatura y Humedad** + - **Sensor:** BME280 o DHT22 + - **Justificación:** El BME280 ofrece una mayor precisión y fiabilidad, permitiendo correlacionar los contaminantes con las condiciones climáticas. + +## Microcontrolador Seleccionado + +### **ESP32** + - **Razón de elección:** + - Conectividad **WiFi** integrada. + - **Bajo consumo de energía** en modo de reposo, ideal para alimentación solar o de farola. + - Capacidad de procesamiento suficiente para filtrar picos falsos y valores faltantes. + - **Compatibilidad con LoRaWAN**, lo que lo hace flexible para diferentes métodos de comunicación. + +## Arquitectura de Comunicación + +La arquitectura de comunicación depende de la disponibilidad de red en la zona: + +### 1. **WiFi (preferible en las cercanías de las escuelas)** + - El **ESP32** se conectará a la red WiFi de la escuela. + - Los datos se enviarán a la nube cada hora utilizando el protocolo **MQTT**, ideal para integrarse con plataformas como **Grafana** y **InfluxDB**. + +### 2. **LoRaWAN (cuando no hay WiFi disponible o la cobertura es insuficiente)** + - El **ESP32** se conectará a un módulo **LoRa** (como el **SX1278** o **RFM95**) para transmitir los datos a una gateway LoRaWAN. + - Se utilizará **MQTT** para enviar los datos a la nube, o bien el protocolo específico de LoRaWAN para integrarse a la infraestructura del municipio. + +## Procesamiento de Datos + +### Filtrado de Anomalías: +- **Filtrado de picos:** Se aplicarán filtros de mediana o filtros de Kalman para eliminar picos atípicos en los datos de los sensores. +- **Validación de datos:** Verificación de que las lecturas estén dentro de rangos válidos esperados. Por ejemplo, si se detecta una humedad de 0% o un valor negativo para PM2.5, se considera como datos erróneos. +- **Promedio de lecturas:** Se puede almacenar la medición de los sensores durante un período (5 minutos) y enviar el promedio cada hora. + +## Visualización y Generación de Alertas + +### 1. **Almacenamiento de Datos:** + - **InfluxDB** se utilizará para almacenar los datos de calidad del aire en series temporales. + - Los datos se almacenarán en intervalos regulares (por ejemplo, cada hora) para su posterior análisis. + +### 2. **Visualización de Datos:** + - **Grafana** se conectará a **InfluxDB** para mostrar los datos de calidad del aire en tiempo real. + - Se crearán paneles interactivos para visualizar la evolución de contaminantes como NO₂, CO, PM2.5, temperatura y humedad a lo largo del tiempo. + +### 3. **Alertas:** + - Se configurarán **alertas en Grafana** cuando los niveles de contaminantes superen umbrales predefinidos (por ejemplo, PM2.5 > 35 µg/m³ o NO₂ > 100 ppb). + - Las alertas se enviarán por correo electrónico o a plataformas como **Telegram**. + +## Diseño de la Caja y Alimentación + +### 1. **Caja Resistente IP65:** + - La estación de monitoreo estará protegida en una **caja con clasificación IP65**, que asegura resistencia al agua, polvo y otras inclemencias climáticas. + +### 2. **Alimentación Solar o de Farola:** + - El sistema utilizará **paneles solares** para cargar una batería recargable, garantizando una fuente de energía autónoma y sostenible. + - Si es posible, también se podrá utilizar **energía de los postes de luz cercanos** para alimentar la estación. + +## Requisitos de Hardware + +- **ESP32**: Microcontrolador con WiFi o LoRa. +- **Sensores**: MiCS-5524, MQ-7, PMS5003, BME280. +- **Módulos adicionales**: + - **Módulo LoRa**: SX1278 o RFM95. + - **Panel solar y batería recargable** para la alimentación autónoma. + - **Caja IP65** para la protección de los sensores y componentes. + +## Requisitos de Software + +- **InfluxDB**: Base de datos para almacenar las series temporales de los datos de calidad del aire. +- **Grafana**: Herramienta para la visualización de datos y configuración de alertas. +- **MQTT**: Protocolo para la transmisión eficiente de datos entre la estación de monitoreo y la nube. diff --git a/class-material/u2/desafio/Cruz Patino Diego - Desafio Consumo Energetico/readme.md b/class-material/u2/desafio/Cruz Patino Diego - Desafio Consumo Energetico/readme.md new file mode 100644 index 0000000..1408c2c --- /dev/null +++ b/class-material/u2/desafio/Cruz Patino Diego - Desafio Consumo Energetico/readme.md @@ -0,0 +1,97 @@ +# Solución IoT para Monitoreo y Gestión de Consumo Energético en un Edificio Corporativo + +Este proyecto está diseñado para reducir el consumo de energía y detectar anomalías en el uso de electricidad en un +edificio corporativo de 5 pisos. La solución utiliza IoT local y Cloud para ofrecer monitoreo en tiempo real, alertas +automáticas, reportes de eficiencia energética y control remoto de dispositivos. + +## Arquitectura + +La solución se divide en dos partes principales: **IoT Edge** y **Cloud**. El procesamiento inicial de los datos se realiza +localmente en dispositivos IoT (Edge), mientras que el almacenamiento y visualización de los datos se maneja en el Cloud. + +### IoT Edge (Local) +- **Sensores y Actuadores**: Los sensores y actuadores se conectan a microcontroladores (ESP32 o Raspberry Pi 4) que procesan los datos localmente y envían solo los datos filtrados al Cloud. +- **Protocolo de comunicación**: Los dispositivos de monitoreo (como medidores de corriente y Smart meters) se comunican mediante **Modbus TCP** o **UART**. +- **Almacenamiento local**: Los datos se almacenan temporalmente en la memoria local de los dispositivos antes de ser enviados al Cloud cada 15 minutos. + +### Cloud +- **Plataforma en la nube**: Se utiliza un servidor Linux (Ubuntu) o EC2 para almacenar los datos históricos y generar reportes. +- **Visualización y análisis**: Se utilizará un stack open source para la visualización y análisis de los datos. + +## Sensores y Protocolos + +Para monitorear el consumo energético y controlar dispositivos, se utilizarán los siguientes sensores y protocolos: + +- **Smart meters Modbus TCP**: Para obtener información de consumo energético de HVAC e iluminación. +- **Medidores de corriente tipo Clamp Sensor (SCT-013)**: Para medir el consumo de energía en circuitos específicos. +- **Relés de corte remoto**: Para controlar remotamente dispositivos no críticos en horarios no laborables. +- **Microcontroladores ESP32 y Raspberry Pi 4**: Para procesar los datos y gestionar la comunicación entre los sensores, actuadores y el Cloud. + +## Lógica Local + +La lógica de procesamiento local se implementará en los microcontroladores ESP32 y Raspberry Pi 4 para filtrar datos, +detectar anomalías y realizar cálculos de consumo energético. + +### Cálculo de Consumo Horario/Día +- Los sensores registran el consumo energético en tiempo real. +- La lógica local calcula el consumo acumulado por hora y por día. +- El cálculo se realiza utilizando las lecturas de consumo de los medidores Modbus TCP y los medidores de corriente tipo clamp. +- Los datos calculados (consumo horario y diario) se almacenan localmente y se envían al Cloud cada 15 minutos. + +### Detección de Anomalías +- **Sobrecargas**: Si el consumo de energía excede un umbral predefinido, se activa una alerta. +- **Picos de Consumo en HVAC**: Si el consumo de los sistemas HVAC supera el valor promedio por más de un período específico, se genera una alerta. +- **Equipos Encendidos Fuera de Horario**: Si se detecta consumo en un dispositivo no crítico fuera del horario laboral, se genera una alerta y se envía al servidor para su análisis. + +### Control Remoto de Dispositivos +- Los dispositivos no críticos se pueden apagar remotamente utilizando los relés de corte remoto. +- El microcontrolador ESP32 o Raspberry Pi 4 gestiona la conexión con el relé y apaga los dispositivos fuera de horarios laborables. + +## Stack Tecnológico + +### Software Local +- **Node-RED**: Para integrar y gestionar los sensores y actuadores de forma sencilla. Facilita la implementación de lógica de control y procesamiento de datos. +- **Mosquitto (MQTT Broker)**: Para la comunicación entre los dispositivos IoT y el servidor Cloud. +- **Python**: Para el procesamiento de datos y detección de anomalías (en el caso de usar Raspberry Pi 4). +- **Modbus TCP y UART**: Para la comunicación con los Smart meters y medidores de corriente. + +### Software Cloud +- **InfluxDB**: Para almacenar los datos históricos de consumo energético. +- **Grafana**: Para la visualización de los datos de consumo energético en tiempo real y la generación de reportes semanales. +- **Node-RED** (en el Cloud): Para el análisis y procesamiento de los datos, así como para la generación de alertas y la visualización. + +## Requisitos + +- **Hardware**: + - Smart meters Modbus TCP + - Medidores de corriente tipo Clamp Sensor (SCT-013) + - Relés de corte remoto + - Microcontroladores ESP32 o Raspberry Pi 4 +- **Software**: + - Node-RED + - Mosquitto (MQTT Broker) + - InfluxDB + - Grafana + - Python (para procesamiento en Raspberry Pi 4) + +## Procedimiento de Implementación + +### Paso 1: Conectar Sensores y Actuadores +1. Configura los Smart meters Modbus TCP y los medidores de corriente tipo Clamp Sensor en los puntos de consumo de energía relevantes (HVAC, iluminación, etc.). +2. Conecta los relés de corte remoto a los dispositivos no críticos. + +### Paso 2: Implementar el Microcontrolador IoT +1. Utiliza un microcontrolador ESP32 o Raspberry Pi 4 para conectar los sensores y relés a través de Modbus TCP o UART. +2. Implementa la lógica local de cálculo de consumo, detección de anomalías y control remoto de dispositivos. + +### Paso 3: Configurar la Comunicación con el Cloud +1. Establece una comunicación periódica (cada 15 minutos) entre el microcontrolador y el servidor Cloud utilizando MQTT. +2. Almacena los datos históricos en InfluxDB y configura Grafana para visualizar estos datos. + +### Paso 4: Visualización y Reportes +1. Configura dashboards en Grafana para visualizar el consumo energético en tiempo real por planta y por equipo. +2. Configura reportes semanales de eficiencia energética en Grafana para que se envíen automáticamente al personal responsable. + +### Paso 5: Alertas y Control Remoto +1. Configura alertas en Node-RED para notificar sobre anomalías de consumo (sobrecargas, picos de consumo, equipos fuera de horario). +2. Implementa la funcionalidad de apagado remoto de dispositivos no críticos en Node-RED. diff --git a/class-material/u2/desafio/Cruz Patino Diego - Desafio Remoto/readme.md b/class-material/u2/desafio/Cruz Patino Diego - Desafio Remoto/readme.md new file mode 100644 index 0000000..49b03b0 --- /dev/null +++ b/class-material/u2/desafio/Cruz Patino Diego - Desafio Remoto/readme.md @@ -0,0 +1,72 @@ +# Estaciones de Monitoreo Ambiental IoT en Reserva Natural + +## 🆄 Contexto General +Una ONG ambientalista desea implementar estaciones de monitoreo ambiental en una reserva natural montañosa y de difícil acceso. El sistema debe ser autónomo, confiable y capaz de operar sin infraestructura de comunicación tradicional. + +## ⚙️ Sensores Seleccionados + +### 1. Temperatura y Humedad Relativa 🌡️💧 +- **Sensor:** SHT31-D (Sensirion) +- **Justificación:** Alta precisión (±0.3°C, ±2% HR), bajo consumo (<2 µA en modo standby), interfaz I2C, confiable en ambientes extremos. + +### 2. Niveles de CO₂ 🌫️ +- **Sensor:** SCD30 (Sensirion) +- **Justificación:** Alta precisión, mediciones de CO₂ hasta 10,000 ppm, también mide temperatura y humedad relativa (sirve como respaldo). Consumo moderado, interfaz I2C. + +### 3. Humedad del Suelo 🌱 +- **Sensor:** Capacitivo v2.0 +- **Justificación:** No se corroe, bajo consumo, interfaz analógica, buen comportamiento en suelos diversos. + +## 🧰 Nodo IoT + +### Microcontrolador +- **Placa:** Raspberry Pi Pico + Módulo LoRa SX1276 (Ra-02 o similar) +- **Razón:** Bajo consumo, buena documentación, fácil de programar en MicroPython o C++, soporte para almacenamiento local. + +### Conexión LoRaWAN +- **Vía:** Módulo SX1276 conectado por SPI. +- **Protocolo:** Utiliza LoRaWAN mediante stack como LMIC o equivalente. +- **Frecuencia:** 915 MHz (para LATAM) + +## 🔢 Almacenamiento Local +- Si no hay conexión LoRaWAN: + - Los datos se guardan localmente en una microSD (FAT32). + - Cada registro incluye: timestamp, sensores, voltaje de batería. + - Una rutina reintenta el envío cada 30 min hasta tener éxito. + +## 🏠 Estación Base +- **Hardware:** Raspberry Pi 4 + Módulo LoRa concentrador (RAK2245 o equivalente) +- **Software:** ChirpStack para gestionar la red LoRaWAN +- **Conectividad:** + - Prioridad 1: WiFi satelital (ej: Starlink) + - Prioridad 2: 4G LTE USB dongle +- **Agrega los datos recibidos y los reenvía a la nube cada 30 min** + +## ☁️ Arquitectura Nodo → Estación Base → Nube + +``` +[Nodo IoT x N] --LoRaWAN--> [Estación Base (ChirpStack)] --LTE/WiFi--> [Servidor EC2 (Nube)] +``` + +## 📈 Visualización de Datos +- **Servidor Cloud:** Amazon EC2 (Ubuntu) +- **Base de Datos:** InfluxDB (time-series) +- **Visualización:** Grafana +- **Características:** + - Dashboards por estación + - Alertas por: + - CO₂ elevado + - Sensor desconectado/fallo (datos nulos o fuera de rango) + - Batería baja (<20%) + +## ⚠️ Detección de Fallos +- **Sensores:** Verificación por watchdog interno cada hora +- **Batería:** Medición por divisor resistivo al ADC +- **Logs de error:** Enviados junto con los datos o almacenados localmente + +--- + +## 🚀 Futuras Mejores +- Inclusión de panel solar más grande con MPPT +- Deep Sleep para extender autonomía +- Compresión de datos para ahorrar ancho de banda LoRaWAN