copilot

• Microcontrolador:
  • Arduino Uno
• Sensores:
  • Sensor de humedad del suelo (ej. FC-28)
• Actuadores:
  • Bomba de agua de 5V o 12V
  • Relé para controlar la bomba
• Fuentes de alimentación:
  • Fuente de alimentación para la bomba (dependiendo del voltaje de la bomba)
  • Cable USB o adaptador para alimentar el Arduino
• Otros:
  • Tubos de riego
  • Cables de conexión
  • Protoboard y/o soldadura

1. Conecta el sensor de humedad:
   • Conecta la salida analógica del sensor (A0) al pin analógico (A0) del Arduino.
   • Conecta la alimentación y tierra del sensor al 5V y GND del Arduino, respectivamente.
2. Conecta el relé para controlar la bomba:
   • Conecta una de las entradas del relé a un pin digital del Arduino (ej. D7).
   • Conecta la alimentación y tierra del relé al 5V y GND del Arduino.
3. Conecta la bomba de agua al relé:
   • Conecta la bomba al circuito de conmutación del relé.
   • Conecta la bomba a una fuente de alimentación externa adecuada (esto puede ser una batería o un adaptador de corriente, dependiendo de la especificación de la bomba).

Cpp
const int soilMoisturePin = A0;
const int relayPin = 7;
int moistureLevel = 0;
int threshold = 300;  // Ajusta este valor según la calibración de tu sensor

void setup() {
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, HIGH);  // Apaga la bomba inicialmente
  Serial.begin(9600);
}

void loop() {
  moistureLevel = analogRead(soilMoisturePin);
  Serial.print("Moisture Level: ");
  Serial.println(moistureLevel);

  if (moistureLevel < threshold) {
    digitalWrite(relayPin, LOW);  // Enciende la bomba
  } else {
    digitalWrite(relayPin, HIGH);  // Apaga la bomba
  }

  delay(1000);  // Espera un segundo entre lecturas
}

• Calibración del sensor: Ajusta el valor de threshold según las condiciones de sequedad deseadas.
• Fuente de alimentación: Asegúrate de que la fuente de alimentación de la bomba sea adecuada para su voltaje y corriente de operación.
• Protección: Considera el uso de un diodo de rueda libre en paralelo con la bomba para proteger contra picos de voltaje.

copilot

• Microcontrolador:
  • Arduino Uno
• Sensores:
  • Sensor de humedad del suelo (ej. FC-28)
• Actuadores:
  • Bomba de agua de 5V o 12V
  • Módulo de relé para manejar la bomba
• Alimentación:
  • Fuente de alimentación externa para la bomba
  • Cable USB o adaptador para alimentar el Arduino
• Cables y otros:
  • Protoboard (opcional para prototipos)
  • Cables de conexión

1. Conectar el Sensor de Humedad:
   • Conecta la salida analógica del sensor a $A0$ del Arduino.
   • Conecta la alimentación (VCC) del sensor a $5V$ del Arduino y el GND del sensor al $GND$ del Arduino.
2. Conectar el Módulo de Relé:
   • Conecta la entrada de control del relé al pin digital $D7$ del Arduino.
   • Conecta el VCC del relé a 5V y el GND del relé a GND del Arduino.
3. Conectar la Bomba de Agua:
   • Conecta la bomba a través del contacto de conmutación del relé.
   • Alimenta la bomba con una fuente externa adecuada (ej. si la bomba es de 12V, utiliza una fuente de 12V).

Cpp
const int soilMoisturePin = A0;
const int relayPin = 7;
int moistureLevel = 0;
int threshold = 300;  // Ajusta según las pruebas

void setup() {
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, HIGH);  // Bomba apagada inicialmente
  Serial.begin(9600);
}

void loop() {
  moistureLevel = analogRead(soilMoisturePin);
  Serial.print("Nivel de Humedad: ");
  Serial.println(moistureLevel);

  if (moistureLevel < threshold) {
    digitalWrite(relayPin, LOW);  // Encender la bomba
  } else {
    digitalWrite(relayPin, HIGH); // Apagar la bomba
  }

  delay(1000);  // Espera un segundo entre lecturas
}

• Calibración del Sensor: Ajusta el valor del umbral threshold basándote en las condiciones del suelo.
• Seguridad: Asegúrate de proteger el circuito de picos de voltaje utilizando un diodo en paralelo con la carga inductiva (bomba).

luisjavier27

copilot

• Microcontrolador:
  • Arduino Uno
• Módulo de Tiempo Real:
  • DS1307 o DS3231 RTC para el seguimiento preciso del tiempo.
• Display:
  • Display de 7 segmentos de 4 dígitos o una pantalla LCD (ej. LCD 16x2).
• Botones:
  • Botones para:
    • Ajuste de hora
    • Ajuste de minutos
    • Ajuste de alarma
    • Activar/desactivar alarma
• Buzzer:
  • Buzzer piezoeléctrico para la alarma sonora.
• Otros:
  • Resistencias (para los leds del display, si se usan de 7 segmentos)
  • Protoboard y cables de conexión

1. Conectar el RTC:
   • SDA del RTC al pin A4 del Arduino
   • SCL del RTC al pin A5 del Arduino
   • VCC del RTC a 5V del Arduino
   • GND del RTC a GND del Arduino
2. Conectar el Display:
   • Dependiendo del display elegido, conectar los pines correspondientes a los digitales del Arduino. Para un LCD 16x2, utilizar la librería LiquidCrystal y conectar a los pines digitales (ej. D2-D7).
3. Conectar los Botones:
   • Conectar cada botón a un pin digital, utilizando pull-down resistors (conectar el otro pin de cada botón a GND).
4. Conectar el Buzzer:
   • Conectar una terminal del buzzer al pin digital (ej. D8) y la otra terminal a GND.

Cpp
#include 
#include 
#include 

// Inicializa RTC y LCD
RTC_DS3231 rtc;
LiquidCrystal lcd(2, 3, 4, 5, 6, 7);

// Variables para almacenar hora
int hora, minuto;
int alarmaHora = 6, alarmaMinuto = 30; // Hora predeterminada de la alarma
bool alarmaActiva = false;

const int buzzerPin = 8;
const int alarmaButton = 9; // Botón de desactivación de alarma

void setup() {
  // Configuración de pines
  pinMode(buzzerPin, OUTPUT);
  pinMode(alarmaButton, INPUT_PULLUP);

  // Inicializa la pantalla
  lcd.begin(16, 2);
  
  // Inicializa el RTC
  if (!rtc.begin()) {
    lcd.print("Error RTC");
    while (1);
  }

  // Configurar RTC si es necesario
  if (rtc.lostPower()) {
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Ajusta a la hora de compilación
  }
}

void loop() {
  DateTime now = rtc.now();
  hora = now.hour();
  minuto = now.minute();
  
  // Mostrar hora actual
  lcd.setCursor(0, 0);
  lcd.print("Hora: ");
  lcd.print(hora);
  lcd.print(":");
  lcd.print(minuto);

  // Verifica si la alarma debe sonar
  if (hora == alarmaHora && minuto == alarmaMinuto && alarmaActiva) {
    sonarAlarma();
  }

  // Maneja input de los botones para ajustes de hora/minuto/alarma
  manejarAjustes();
}

void sonarAlarma() {
  for (int i = 0; i < 120; i++) { // Suena la alarma por 2 minutos
    if (digitalRead(alarmaButton) == LOW) { // Revisa si el botón de desactivación se presiona
      alarmaActiva = false;
      break;
    }
    tone(buzzerPin, 1000, 500); // Produce un tono de 1000Hz durante 0.5s
    delay(500);
    tone(buzzerPin, 1500, 500); // Produce un tono de 1500Hz durante 0.5s
    delay(500);
  }
  noTone(buzzerPin); // Detiene el tono
}

// Funciones adicionales para manejar botones y ajustar reloj
void manejarAjustes() {
  // Implementar la lógica para ajustar hora y minutos con los botones
  // Leer los pines de los botones y ajustar variables correspondientemente
}

• Configuración del Hardware: Asegúrate de que el módulo RTC tenga instalada la batería e inicialízalo si es nuevo.
• Ajustes de Tiempos: Es importante agregar la lógica para ajustar la hora del reloj y la alarma utilizando los botones. También implementar debouncing para los botones.
• Bibliotecas: Utiliza la biblioteca RTClib para manejar el RTC y LiquidCrystal para manejar el display LCD.

luisjavier27

copilot

• Microcontrolador:
  • Arduino Uno
• Módulo de Tiempo Real (RTC):
  • DS3231 RTC (más preciso y confiable que el DS1307)
• Display:
  • Módulo de 7 segmentos de 4 dígitos con controlador (por ejemplo, TM1637 )
• Botones:
  • Cuatro botones pulsadores para:
    • Ajustar horas del reloj
    • Ajustar minutos del reloj
    • Ajustar horas de la alarma
    • Ajustar minutos de la alarma
  • Un botón adicional para desactivar la alarma
• Buzzer:
  • Buzzer piezoeléctrico para la señal de alarma sonora.
• Otros:
  • Resistencias (para botones)
  • Protoboard y cables de conexión.

1. Conectar el RTC:
   • SDA del RTC a A4 en el Arduino
   • SCL del RTC a A5 en el Arduino
   • Alimentación y GND del RTC a 5V y GND del Arduino
2. Conectar el Display:
   • Conectar los pines del display (CLK y DIO) a dos pines digitales del Arduino (por ejemplo, D2 y D3).
3. Conectar Botones:
   • Conectar cada botón a un pin digital con resistencias pull-down (ejemplos: D4, D5, D6, D7, D8).
4. Conectar el Buzzer:
   • Conecta una terminal del buzzer al pin digital (ej. D9) y la otra terminal a GND.

Cpp
#include 
#include 
#include 

// Declaraciones para el RTC y el displays
RTC_DS3231 rtc;
TM1637Display display(2, 3); // Ajusta estos pines según la conexión

// Pines de botones
const int buttonHour = 4;
const int buttonMinute = 5;
const int alarmHourButton = 6;
const int alarmMinuteButton = 7;
const int disableAlarmButton = 8;
const int buzzerPin = 9;

// Variables para tiempo y alarma
int alarmHour = 6, alarmMinute = 0;
bool alarmActive = true; // Para permitir la desactivación de la alarma
bool alarmRinging = false;

void setup() {
  // Configuración inicial
  pinMode(buttonHour, INPUT_PULLUP);
  pinMode(buttonMinute, INPUT_PULLUP);
  pinMode(alarmHourButton, INPUT_PULLUP);
  pinMode(alarmMinuteButton, INPUT_PULLUP);
  pinMode(disableAlarmButton, INPUT_PULLUP);
  pinMode(buzzerPin, OUTPUT);

  Wire.begin();
  display.setBrightness(0x0f); // Máxima intensidad del display

  if (!rtc.begin()) {
    while (1); // Error en la inicialización del RTC
  }

  // Inicializa la hora si es necesario:
  if (rtc.lostPower()) {
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
}

void loop() {
  DateTime now = rtc.now();
  int currentHour = now.hour();
  int currentMinute = now.minute();

  // Actualiza display con la hora actual
  int displayValue = currentHour * 100 + currentMinute;
  display.showNumberDecEx(displayValue, 0b01000000, true);

  // Comprobación de alarma
  if (currentHour == alarmHour && currentMinute == alarmMinute && alarmActive && !alarmRinging) {
    startAlarm();
  }

  if (alarmRinging && digitalRead(disableAlarmButton) == LOW) {
    stopAlarm();
  }

  // Manejar ajustes con botones
  handleTimeAdjustment();
  delay(1000);
}

void handleTimeAdjustment() {
  if (digitalRead(buttonHour) == LOW) {
    adjustTime(1, 0);
  }
  if (digitalRead(buttonMinute) == LOW) {
    adjustTime(0, 1);
  }
  if (digitalRead(alarmHourButton) == LOW) {
    alarmHour = (alarmHour + 1) % 24;
  }
  if (digitalRead(alarmMinuteButton) == LOW) {
    alarmMinute = (alarmMinute + 1) % 60;
  }
  delay(250); // Pequeña pausa para evitar rebotes
}

void adjustTime(int incrHour, int incrMin) {
  DateTime now = rtc.now();
  int newHour = (now.hour() + incrHour) % 24;
  int newMinute = (now.minute() + incrMin) % 60;
  rtc.adjust(DateTime(now.year(), now.month(), now.day(), newHour, newMinute, now.second()));
}

void startAlarm() {
  unsigned long startTime = millis();
  alarmRinging = true;

  while (alarmRinging && (millis() - startTime < 120000)) {  // Sonar durante 2 minutos como máximo
    tone(buzzerPin, 1000, 500); // Tonos alternos
    delay(500);
    tone(buzzerPin, 1500, 500);
    delay(500);

    if (digitalRead(disableAlarmButton) == LOW) {
      stopAlarm();
      break;
    }
  }

  stopAlarm(); // Parada automática tras 2 minutos
}

void stopAlarm() {
  alarmRinging = false;
  noTone(buzzerPin);
}

• Rebote de Botones: Implementa un debouncing adecuado para los botones si encuentras problemas con falsas lecturas.
• Modificar y Ajustar: Este código es un prototipo básico y debes ajustarlo para satisfacer las necesidades específicas de tu proyecto, incluido el ajuste visual y control para los elementos del hardware.

luisjavier27