1. Arduino Uno
2. Relés de 220V capaces de manejar la corriente necesaria para el ventilador, el panel LED de 400W y el extractor de aire. Necesitarás al menos 3 de estos.
3. Módulo LCD 16x2 con adaptador I2C (para facilitar la comunicación usando menos pines de Arduino).
4. RTC (Real Time Clock) DS3231 para el manejo de tiempo real.
5. Sensor de humedad del suelo para controlar el sistema de riego.
6. Botones para navegar por el menú (al menos 3 serían ideales para "seleccionar", "arriba" y "abajo").
7. Resistencias de pull-up de 10kΩ para los botones, si es que no usan entradas con resistencia interna.
8. Transistores NPN (como el 2N2222) para manejar los relés si el Arduino no puede proporcionar suficiente corriente.

1. Relés:
   • Conecta los pines de control de cada relé a pines digitales en el Arduino (por ejemplo, D2, D3, y D4).
   • Cada relé será conectado a su correspondiente carga (ventilador, panel LED, extractor de aire) y a la fuente de alimentación de 220V. Asegúrate de manejar esta parte con precaución y conocimiento en seguridad eléctrica.
2. Módulo LCD 16x2 con I2C:
   • Conecta SDA a A4 y SCL a A5 en el Arduino Uno.
3. RTC DS3231:
   • Conecta SDA a A4 y SCL a A5 en paralelo con el módulo LCD, ya que ambos utilizan el protocolo I2C.
4. Sensor de Humedad del Suelo:
   • Conecta el pin de señal a un pin analógico en el Arduino (por ejemplo, A0).
5. Botones:
   • Conecta un lado de cada botón a un pin digital en el Arduino (por ejemplo, D5, D6, y D7).
   • El otro lado de cada botón se conecta a tierra a través de una resistencia de pull-up.
6. Transistores para Relés (si es necesario):
   • La base del transistor se conecta al pin de control del Arduino a través de una resistencia de 1kΩ.
   • El emisor se conecta a GND.
   • El colector se conecta al terminal de control del relé.

1. Relés:
   • Conectar Arduino:D2 a Relé 1: Control
   • Conectar Arduino:D3 a Relé 2: Control
   • Conectar Arduino:D4 a Relé 3: Control

2. Módulo LCD 16x2 con I2C:
   • Conectar Arduino:A4 (SDA) a LCD+I2C:SDA
   • Conectar Arduino:A5 (SCL) a LCD+I2C:SCL

3. RTC DS3231:
   • Conectar Arduino:A4 (SDA) a RTC:SDA (en paralelo con el LCD)
   • Conectar Arduino:A5 (SCL) a RTC:SCL (en paralelo también)

4. Sensor de Humedad del Suelo:
   • Conectar Sensor:Humedad Señal a Arduino:A0

5. Botones:
   • Conectar un lado de cada botón a Arduino:D5, D6 y D7
   • El otro lado de cada botón se conecta a tierra (GND). Si usas las entradas internas de pull-up del Arduino, puedes omitir las resistencias externas de pull-up.

• Movimiento Izquierda/Derecha:
  • Conectar U4:L/R a Arduino:A0. Esto permitirá leer el movimiento horizontal del joystick.
• Movimiento Arriba/Abajo:
  • Conectar U4:U/D a Arduino:A1. Esto permitirá leer el movimiento vertical del joystick.
• Tierra:
  • Conectar U4:GND a Arduino:GND. Nota que hay dos pines GND en U4, solo necesitas usar uno para tener una conexión a tierra común.

1. Relés para control de Salidas: Se mantienen las conexiones de los relés a los pines digitales D2, D3 y D4 para el control del ventilador, panel LED y extractor de aire respectivamente.
2. Módulo LCD 16x2 con I2C: Se mantienen las conexiones de SDA y SCL a A4 y A5 en el Arduino.
3. RTC DS3231: También se conecta a A4 y A5 para la comunicación I2C.
4. Sensor de Humedad del Suelo: Conexión mantenida al pin A0.

Cpp
int lrValue = analogRead(A0); // Lee el eje izquierda/derecha
int udValue = analogRead(A1); // Lee el eje arriba/abajo

// Para navegar en el menú
if (lrValue < 400) {
  // Mover a la izquierda
} else if (lrValue > 600) {
  // Mover a la derecha
}

if (udValue < 400) {
  // Mover hacia arriba
} else if (udValue > 600) {
  // Mover hacia abajo
}

• El joystick podría no necesitar resistencias de pull-up o pull-down externas si solo estás leyendo las posiciones analógicas de sus ejes ($L/R$ y $U/D$). Sin embargo, si tu joystick tiene un botón de "click" o selección (no mencionado en la descripción inicial), y decides usarlo, podrías necesitar una resistencia de pull-up o pull-down para asegurar un estado lógico definido cuando el botón no esté presionado.

• Para el módulo LCD 16x2 con adaptador I2C, generalmente no necesitarás resistencias adicionales, ya que estos módulos suelen estar preparados para conectarse directamente a un microcontrolador como Arduino.
• Si tu diseño incluye LEDs (por ejemplo, indicadores de estado), cada LED deberá tener una resistencia en serie para limitar la corriente y prevenir daños en el LED o en el pin de salida del Arduino.

• Es una buena práctica agregar capacitores de desacoplo cerca de la alimentación de cada IC (circuito integrado), incluido el propio Arduino, los módulos RTC y cualquier otro chip. Un valor típico es de $100 nF$ a $0.1 \mu F$ para filtrar el ruido de alta frecuencia y estabilizar las líneas de alimentación.

• Si planeas alimentar tu Arduino y otros componentes con una fuente superior a los 5V recomendados (como una batería de 9V o 12V), el Arduino Uno (asumiendo que es la versión que utilizas) ya incluye reguladores de voltaje integrados que pueden manejar entradas de hasta 12V (aunque no se recomienda superar los 9V para evitar el calentamiento excesivo). Por lo tanto, no necesitarías un regulador adicional para el Arduino.
• Sin embargo, si cualquier otro componente requiere 3.3V o un nivel de voltaje que no proporciona directamente el Arduino, necesitarías emplear un regulador de voltaje externo para ese componente específico.

• Si las salidas de 220V están cerca de la lógica de bajo voltaje y los componentes sensibles, considera usar optoacopladores para aislar completamente la lógica de control del alto voltaje manejado por los relés.
• Para una protección adicional contra picos de voltaje, en particular para líneas largas de sensores o actuadores, podrían ser adecuados diodos TVS (Transient Voltage Suppressors).

1. Transformador o Convertidor AC-DC: Necesitas un transformador o convertidor AC-DC que baje los 220V AC a un nivel seguro de DC que el Arduino pueda manejar. Generalmente, los Arduinos operan a 5V DC. Una opción común es utilizar un convertidor AC-DC que proporcione entre 7V y 12V DC para alimentar al Arduino a través de su jack de alimentación o el pin VIN, aprovechando el regulador de voltaje interno del Arduino para bajarlo a 5V. Asegúrate de que la fuente de alimentación pueda proporcionar la corriente necesaria para el Arduino y todos los componentes conectados a él.

1. Uso de Relés o SSR (Relés de Estado Sólido):
   • Los relés mecánicos son una opción común. Asegúrate de que estén clasificados para manejar la corriente y el voltaje de tus dispositivos de 220V. Los relés permiten el control de los dispositivos encendiéndolos y apagándolos. Tendrás que conectar el lado de bajo voltaje del relé al Arduino, lo cual suele requerir:
     • Transistores: Para manejar la corriente del bobinado del relé si es más alta de lo que el Arduino puede suministrar directamente.
     • Diodo Flyback: Para proteger el circuito de los picos de voltaje generados cuando se desactiva el relé.
     • Resistencias: Para limitar la corriente en la base del transistor.
   • Los SSR (Relés de Estado Sólido) son otra opción y tienen la ventaja de no tener partes móviles y de operar más rápidamente y silenciosamente. Asegúrate de que el SSR pueda ser activado con los 5V que el Arduino proporciona.
2. Aislamiento:
   • Para mayor seguridad, es importante mantener un buen aislamiento entre la parte de control (Arduino y circuito de bajo voltaje) y los circuitos de 220V. Utiliza canaletas o barreras físicas y mantén una distancia adecuada entre los dos tipos de circuitos en tu diseño.

• 220V AC -> Convertidor AC-DC -> Arduino: Para alimentar al Arduino.
• Arduino -> Relé/SSR -> Dispositivo de 220V: Se utilizan pines digitales del Arduino para controlar los relés, que a su vez encienden y apagan los dispositivos de 220V.

• Siempre trabaja con 220V AC con precaución. Si no estás familiarizado con las prácticas seguras de trabajo con alto voltaje, considera buscar ayuda de alguien con experiencia en electricidad.
• Utiliza un fusible adecuado en la línea de entrada de 220V para proteger contra sobrecorrientes.
• Considera el uso de una carcasa para aislar y proteger tanto la electrónica de bajo voltaje como los componentes de alta tensión.
• Asegúrate de que todos los componentes que interactúan con 220V AC estén homologados y sean adecuados para su uso previsto.

• Abre Flux.ai y crea un nuevo proyecto.
• Asegúrate de tener seleccionadas las bibliotecas de componentes que vas a necesitar, como Arduino, relés, módulos de joystick, LCD con interfaz I2C, RTC DS3231 y, si es necesario, componentes para la protección de circuitos como diodos y resistencias.

• Busca en la biblioteca de componentes un Arduino (puede ser un Arduino Uno, Nano, o cualquier otro que prefieras) y colócalo en la hoja de diseño.
• Para cada componente que vayas a conectar al Arduino, sigue un proceso similar: selecciónalo de la biblioteca y colócalo en el diseño.

• Añade al diseño los relés (o SSRs) adecuados para controlar cargas de 220V.
• Conecta los pines de control de los relés a los pines digitales especificados del Arduino (por ejemplo, D2, D3, y D4).

• Coloca el módulo de joystick en el diseño.
• Conecta los ejes $L/R$ y $U/D$ a dos pines analógicos del Arduino, por ejemplo, A0 y A1.
• Conecta uno de los pines $GND$ al GND del Arduino.

• Coloca el módulo LCD 16x2 y conecta los pines SDA y SCL al Arduino, usualmente en los pines A4 y A5 correspondientemente.

• Coloca el RTC en el diseño y conéctalo en paralelo con el módulo LCD utilizando los pines SDA y SCL del Arduino.

• Agrega cualquier componente adicional de protección o interfaz, como diodos de protección para los relés, si es necesario.
• Revisa todas tus conexiones para asegurarte de que coincidan con la funcionalidad deseada y la seguridad.

• Utiliza las herramientas de Flux.ai para documentar tu proyecto: nombra los componentes, los nets y describe su funcionamiento.
• Si Flux.ai ofrece alguna opción de simulación, comprueba el funcionamiento básico de tu circuito.

• A lo largo de este proceso, consulta las hojas de datos de tus componentes para asegurarte de que tus conexiones son correctas y seguras.
• Debate tu diseño con otros o busca asesoramiento si no estás seguro de alguna conexión, especialmente cuando se trata de trabajar con 220V AC.

1. Arduino Uno: Será el cerebro del proyecto, encargado de procesar la información del sensor de humedad y controlar la válvula solenoide para el riego.
2. Sensor de humedad del suelo: Se utiliza para medir la humedad presente en el suelo.
3. Válvula solenoide: Permite controlar el flujo de agua. Para este ejemplo, asumo que funciona a 12V, que es común para estas aplicaciones.
4. Transistor NPN (por ejemplo, 2N2222): Actúa como un interruptor controlado por el Arduino para manejar cargas mayores que las que el Arduino puede manejar directamente (como la válvula solenoide).
5. Resistencia de 1kΩ: Para limitar la corriente al transistor.
6. Diodo de protección (por ejemplo, 1N4007): Para proteger el circuito de los picos de voltaje generados por la bobina de la válvula solenoide al desenergizarse.
7. Fuente de alimentación de 12V: Para la válvula solenoide.
8. Protoboard y cables: Para las conexiones.

• Sensor de humedad del suelo
  • Conectar el pin VCC del sensor a 5V en el Arduino (se puede usar cualquier pin de 5V).
  • Conectar el pin GND del sensor a GND en el Arduino.
  • Conectar el pin Signal del sensor al pin A0 en el Arduino.
• Válvula solenoide
  • Conectar el colector del transistor NPN a un terminal de la válvula solenoide.
  • Conectar el otro terminal de la válvula solenoide a la fuente de alimentación de 12V.
  • Conectar el emisor del transistor NPN a GND.
  • Conectar el diodo de protección en paralelo con la válvula solenoide, asegurándose de que el cátodo (la banda) esté conectado al terminal de la válvula conectado a la fuente de 12V.
• Transistor NPN
  • Conectar el pin Base del transistor a través de una resistencia de 1kΩ a un pin digital del Arduino (por ejemplo, D3).

• Programar el Arduino para leer el valor de humedad del suelo y activar la válvula solenoide cuando la humedad esté por debajo de un umbral definido. El umbral se puede ajustar según las necesidades de tus plantas.
• No olvides añadir la fuente de alimentación adecuada para tu Arduino además de la fuente de 12V para la válvula solenoide.

1. Arduino Uno: Controla el sensor de humedad y el actuador de riego (por ejemplo, una válvula solenoide).
2. Sensor de humedad de suelo: Detecta el nivel de humedad del suelo.
3. Válvula solenoide: Controla el flujo de agua para el riego. Asumiremos que funciona con 12V DC, lo cual es común.
4. Transistor NPN (Por ejemplo, 2N2222): Utilizado para activar la válvula solenoide, ya que Arduino no puede suministrar la corriente o voltaje necesarios directamente.
5. Resistencia de 1kΩ: Limita la corriente al transistor para proteger el pin de salida del Arduino.
6. Diodo de protección (Por ejemplo, 1N4007): Protege al Arduino de los picos de voltaje generados cuando la válvula se apaga.
7. Fuente de alimentación de 12V: Para alimentar la válvula solenoide.
8. Cables y protoboard: Para realizar las conexiones.

• VCC del sensor a 5V del Arduino.
• GND del sensor a GND del Arduino.
• Signal del sensor a una entrada analógica del Arduino, por ejemplo, A0.

• El emisor del transistor a GND.
• El colector del transistor al terminal negativo (o uno de los terminales, si no es polarizada) de la válvula solenoide.
• El otro terminal de la válvula solenoide a +12V (positivo) de la fuente externa.
• Base del transistor conectada a un pin digital del Arduino (ejemplo, D7) a través de una resistencia de 1kΩ.
• Un diodo de protección en paralelo con la válvula solenoide, asegurando que el lado del anodo esté conectado al emisor del transistor y el cátodo al +12V (para proteger de picos de voltaje)

Cpp
int sensorPin = A0; // Pin donde se conecta el sensor de humedad
int valvePin = 7; // Pin de control de la válvula (conectado al transistor)
int sensorValue = 0; // Para almacenar el valor leído del sensor
int threshold = 400; // Umbral de humedad para activar la válvula

void setup() {
  pinMode(valvePin, OUTPUT); // Configura el pin de la válvula como salida
  Serial.begin(9600); // Inicia la comunicación serial
}

void loop() {
  sensorValue = analogRead(sensorPin); // Lee el valor de humedad
  Serial.println(sensorValue); // Imprime el valor de humedad
  
  if(sensorValue < threshold) {
    digitalWrite(valvePin, HIGH); // Enciende la válvula
  } else {
    digitalWrite(valvePin, LOW); // Apaga la válvula
  }
  
  delay(1000); // Espera un segundo antes de la próxima lectura
}