micholin

copilot

Cpp
const int sensorPin = A0; // Conecta el pin de señal S del KY-028 al pin A0 en Arduino
const int botonAumentar = 2;
const int botonDisminuir = 3;

int adjustment = 0; // Ajuste inicial arbitrario en grados Celsius

void setup() {
  Serial.begin(9600); // Inicia la comunicación serial a 9600 bps
  pinMode(botonAumentar, INPUT_PULLUP); // Configura el pin del botón como entrada
  pinMode(botonDisminuir, INPUT_PULLUP); // Configura el pin del botón como entrada
}

void loop() {
  int sensorValue = analogRead(sensorPin); // Lee el valor del sensor
  float voltage = sensorValue * 23.0 / 1023.0; // Convierte el valor a voltaje
  
  // Ajuste para la relación inversa entre la temperatura y el voltaje.
  float temperatureCelsius = $1.0 - (voltage / 5.0)$ * 100.0;
  
  // Modifica temperatura basada en los botones
  int estadoBotonAumentar = !digitalRead(botonAumentar); // Nega el valor para manejar INPUT_PULLUP
  int estadoBotonDisminuir = !digitalRead(botonDisminuir); // Nega el valor para manejar INPUT_PULLUP

  if(estadoBotonAumentar) {
    adjustment++; // Aumenta el ajuste
    delay(200); // Pequeño retardo para evitar incrementos demasiado rápidos
  }
  
  if(estadoBotonDisminuir) {
    adjustment--; // Disminuye el ajuste
    delay(200); // Pequeño retardo para evitar decrementos demasiado rápidos
  }

  // Añadir el ajuste a la temperatura calculada
  temperatureCelsius += adjustment;
  
  Serial.print("Temperatura: ");
  Serial.print(temperatureCelsius);
  Serial.println(" °C");
  delay(1000); // Espera un segundo para la próxima lectura
}

• La variable ajustment mantiene el recuento de cuántas veces se ha presionado cada botón desde el inicio del programa o desde el último reinicio.
• Cada vez que se presiona el botón de aumentar, adjustment se incrementa, y cada vez que se presiona el botón de disminuir, adjustment se decrementa.
• Este ajuste se añade directamente a temperatureCelsius para modificar la temperatura mostrada.

micholin

copilot

Cpp
const int sensorPin = A0; // Pin del sensor
const int botonAumentar = 2; // Botón para aumentar el umbral de temperatura
const int botonDisminuir = 3; // Botón para disminuir el umbral de temperatura
const int ventiladorPin = 13; // Controla el ventilador con el pin 13

int temperaturaUmbral = 27; // Umbral inicial de temperatura para activar el ventilador

void setup() {
  Serial.begin(9600);
  pinMode(botonAumentar, INPUT_PULLUP);
  pinMode(botonDisminuir, INPUT_PULLUP);
  pinMode(ventiladorPin, OUTPUT); // Configura el pin del ventilador como salida
}

void loop() {
  int sensorValue = analogRead(sensorPin);
  float voltage = sensorValue * 23.0 / 1023.0;
  float temperatureCelsius = (1.0 - (voltage / 5.0)) * 100.0;
  
  // Modificar el umbral de temperatura con los botones
  if (!digitalRead(botonAumentar)) {
    temperaturaUmbral++;
    delay(200); // Evita cambios demasiado rápidos
  }
  
  if (!digitalRead(botonDisminuir)) {
    temperaturaUmbral--;
    delay(200); // Evita cambios demasiado rápidos
  }

  // Controla el ventilador basado en la temperatura actual y el umbral
  if (temperatureCelsius >= temperaturaUmbral) {
    digitalWrite(ventiladorPin, HIGH); // Enciende el ventilador
  } else {
    digitalWrite(ventiladorPin, LOW); // Apaga el ventilador
  }

  // Imprime la temperatura actual y el umbral en la consola serial
  Serial.print("Temperatura: ");
  Serial.print(temperatureCelsius);
  Serial.print(" °C, ");
  Serial.print("Umbral: ");
  Serial.print(temperaturaUmbral);
  Serial.println(" °C");
  
  delay(1000); // Espera un segundo para la próxima lectura
}

micholin

copilot

Cpp
const int sensorPin = A0; // Pin del sensor
const int botonAumentar = 2; // Botón para aumentar el umbral de temperatura del ventilador
const int botonDisminuir = 3; // Botón para disminuir el umbral de temperatura del ventilador
const int botonAumentarCalefactor = 4; // Botón para aumentar el umbral de temperatura del calefactor
const int botonDisminuirCalefactor = 5; // Botón para disminuir el umbral de temperatura del calefactor
const int ventiladorPin = 13; // Controla el ventilador con el pin 13
const int calefactorPin = 12; // Controla el calefactor con el pin 12

int temperaturaUmbralVentilador = 27; // Umbral inicial de temperatura para activar el ventilador
int temperaturaUmbralCalefactor = 20; // Umbral inicial de temperatura para activar el calefactor

void setup() {
  Serial.begin(9600);
  pinMode(botonAumentar, INPUT_PULLUP);
  pinMode(botonDisminuir, INPUT_PULLUP);
  pinMode(botonAumentarCalefactor, INPUT_PULLUP);
  pinMode(botonDisminuirCalefactor, INPUT_PULLUP);
  pinMode(ventiladorPin, OUTPUT);
  pinMode(calefactorPin, OUTPUT);
}

void loop() {
  int sensorValue = analogRead(sensorPin);
  float voltage = sensorValue * 23.0 / 1023.0;
  float temperatureCelsius = $1.0 - (voltage / 5.0)$ * 100.0;
  
  // Modificar el umbral de temperatura del ventilador con los botones
  if (!digitalRead(botonAumentar)) {
    temperaturaUmbralVentilador++;
    delay(200); // Evita cambios demasiado rápidos
  }
  if (!digitalRead(botonDisminuir)) {
    temperaturaUmbralVentilador--;
    delay(200); // Evita cambios demasiado rápidos
  }

  // Modificar el umbral de temperatura del calefactor con otros botones
  if (!digitalRead(botonAumentarCalefactor)) {
    temperaturaUmbralCalefactor++;
    delay(200); // Evita cambios demasiado rápidos
  }
  if (!digitalRead(botonDisminuirCalefactor)) {
    temperaturaUmbralCalefactor--;
    delay(200); // Evita cambios demasiado rápidos
  }

  // Controla el ventilador basado en la temperatura actual y el umbral del ventilador
  if (temperatureCelsius >= temperaturaUmbralVentilador) {
    digitalWrite(ventiladorPin, HIGH);
  } else {
    digitalWrite(ventiladorPin, LOW);
  }

  // Controla el calefactor basado en la temperatura actual y el umbral del calefactor
  if (temperatureCelsius <= temperaturaUmbralCalefactor) {
    digitalWrite(calefactorPin, HIGH);
  } else {
    digitalWrite(calefactorPin, LOW);
  }

  // Imprimir valores en el Serial Monitor
  Serial.print("Temperatura: ");
  Serial.print(temperatureCelsius);
  Serial.print(" °C, Umbral Ventilador: ");
  Serial.print(temperaturaUmbralVentilador);
  Serial.print(" °C, Umbral Calefactor: ");
  Serial.println(temperaturaUmbralCalefactor);
  
  delay(1000); // Espera un segundo para la próxima lectura
}

• El ventilador se enciende si la temperatura es igual o superior al umbral establecido para el ventilador.
• El calefactor se activa si la temperatura es igual o inferior al umbral establecido para el calefactor.
• Cada conjunto de botones ajusta su respectivo umbral para el ventilador o el calefactor.

micholin

copilot

Cpp
const int sensorPin = A0; // Pin del sensor
const int botonAumentarVentilador = 2;
const int botonDisminuirVentilador = 3;
const int botonAumentarCalefactor = 4;
const int botonDisminuirCalefactor = 5;
const int botonModoManual = 6; // Botón para seleccionar el modo manual
const int botonModoDigital = 7; // Botón para seleccionar el modo digital
const int ventiladorPin = 13;
const int calefactorPin = 12;

int temperaturaUmbralVentilador = 27;
int temperaturaUmbralCalefactor = 20;
bool modoManual = true; // Inicialmente en modo manual

void setup() {
  Serial.begin(9600);
  pinMode(botonAumentarVentilador, INPUT_PULLUP);
  pinMode(botonDisminuirVentilador, INPUT_PULLUP);
  pinMode(botonAumentarCalefactor, INPUT_PULLUP);
  pinMode(botonDisminuirCalefactor, INPUT_PULLUP);
  pinMode(botonModoManual, INPUT_PULLUP);
  pinMode(botonModoDigital, INPUT_PULLUP);
  pinMode(ventiladorPin, OUTPUT);
  pinMode(calefactorPin, OUTPUT);
}

void loop() {
  actualizarModo();
  
  int sensorValue = analogRead(sensorPin);
  float voltage = sensorValue * 23.0 / 1023.0;
  float temperatureCelsius = $1.0 - (voltage / 5.0)$ * 100.0;
  
  if (modoManual) {
    // En modo manual, permitir ajustes a través de los botones
    ajustarUmbralVentilador();
    ajustarUmbralCalefactor();
  }

  // Control de ventilador y calefactor basado en sus respectivos umbrales
  controlarVentilador(temperatureCelsius);
  controlarCalefactor(temperatureCelsius);

  // Imprimir valores en el Serial Monitor
  Serial.print("Temperatura: ");
  Serial.print(temperatureCelsius);
  Serial.print(" °C, Umbral Ventilador: ");
  Serial.print(temperaturaUmbralVentilador);
  Serial.print(" °C, Umbral Calefactor: ");
  Serial.print(temperaturaUmbralCalefactor);
  Serial.print(", Modo: ");
  Serial.println(modoManual ? "Manual" : "Digital");
  
  delay(1000); // Espera un segundo para la próxima lectura
}

void actualizarModo() {
  if (!digitalRead(botonModoManual)) {
    modoManual = true;
    delay(200); // Debounce delay
  }
  if (!digitalRead(botonModoDigital)) {
    modoManual = false;
    // Establecer valores predeterminados para el modo digital
    temperaturaUmbralVentilador = 27;
    temperaturaUmbralCalefactor = 20;
    delay(200); // Debounce delay
  }
}

void ajustarUmbralVentilador() {
  if (!digitalRead(botonAumentarVentilador)) {
    temperaturaUmbralVentilador++;
    delay(200); // Debounce delay
  }
  if (!digitalRead(botonDisminuirVentilador)) {
    temperaturaUmbralVentilador--;
    delay(200); // Debounce delay
  }
}

void ajustarUmbralCalefactor() {
  if (!digitalRead(botonAumentarCalefactor)) {
    temperaturaUmbralCalefactor++;
    delay(200); // Debounce delay
  }
  if (!digitalRead(botonDisminuirCalefactor)) {
    temperaturaUmbralCalefactor--;
    delay(200); // Debounce delay
  }
}

void controlarVentilador(float temperatureCelsius) {
  if (temperatureCelsius >= temperaturaUmbralVentilador) {
    digitalWrite(ventiladorPin, HIGH);
  } else {
    digitalWrite(ventiladorPin, LOW);
  }
}

void controlarCalefactor(float temperatureCelsius) {
  if (temperatureCelsius <= temperaturaUmbralCalefactor) {
    digitalWrite(calefactorPin, HIGH);
  } else {
    digitalWrite(calefactorPin, LOW);
  }
}

• Modo Manual: Permite a los usuarios ajustar los umbrales de temperatura para el ventilador y el calefactor utilizando los botones correspondientes.
• Modo Digital (Automático): Fija los umbrales en valores predeterminados (27°C para el ventilador y 20°C para el calefactor) y desactiva la posibilidad de ajustarlos manualmente.

micholin

copilot

Cpp
#include <LiquidCrystal.h>

Cpp
// Inicia el objeto LCD y define los pines de Arduino que se utilizarán para el LCD
LiquidCrystal lcd(8, 9, 10, 11, 12, 13);

Cpp
void setup() {
  // Reservado para otras inicializaciones
  lcd.begin(16, 2); // Indica al LCD que es de 16x2
}

Cpp
void loop() {
  // Reservado para lectura de sensores y lógica de control

  // Actualiza la pantalla LCD con los valores actuales
  lcd.clear(); // Limpia la pantalla antes de mostrar nuevos valores
  lcd.setCursor(0, 0); // Establece el cursor en la primera línea
  lcd.print("Temp: ");
  lcd.print(temperatureCelsius);
  lcd.print((char)223); // Imprime el símbolo de grado °
  lcd.print("C");

  lcd.setCursor(0, 1); // Establece el cursor en la segunda línea
  lcd.print("Modo: ");
  lcd.print(modoManual ? "Manual" : "Digital");
  
  delay(1000); // Espera un segundo antes de la próxima actualización
}

micholin

copilot

Cpp
// Define el pin analógico donde está conectado el botón.
const int botonPin = A0; // A0 es el pin analógico utilizado.

void setup() {
  // Configura el pin del botón como entrada con una resistencia pull-up interna.
  pinMode(botonPin, INPUT_PULLUP);
  Serial.begin(9600); // Inicia la comunicación serial.
}

void loop() {
  // Lee el estado del pin del botón.
  int estadoBoton = digitalRead(botonPin);
  
  // Verifica si el botón está presionado.
  // Si el botón está presionado, digitalRead retornará LOW.
  if (estadoBoton == LOW) {
    Serial.println("Botón presionado");
  } else {
    Serial.println("Botón sin presionar");
  }
  
  delay(200); // Pequeño retardo para evitar lecturas múltiples.
}

copilot

• Conectar R1:2 a C1:1.
• Conectar C1:2 a L1:1.

micholin

copilot

• Un Arduino (Uno, Nano, Mega, etc.)
• Sensor de temperatura KY-028
• Cable USB para conectar el Arduino a la computadora
• El IDE de Arduino instalado en la computadora

• Pata GND del KY-028 a GND en Arduino
• Pata + (Vcc) del KY-028 a 5V en Arduino
• Pata S (Señal) del KY-028 a un pin analógico, por ejemplo, A0 en Arduino

Cpp
const int sensorPin = A0; // Pata S del KY-028 conectada a A0 en Arduino

void setup() {
  Serial.begin(9600); // Inicia la comunicación serial a 9600 bps
}

void loop() {
  int sensorValue = analogRead(sensorPin); // Lee el valor del sensor
  float voltage = sensorValue * $5.0 / 1023.0$; // Convierte el valor a voltaje
  // Calcula la temperatura en grados Celsius. 
  // El factor de conversión dependerá específicamente del sensor y de su respuesta a la temperatura.
  // Este es un valor supuesto para ilustrar.
  // Debes calibrar este valor según tu sensor y las especificaciones del módulo KY-028.
  float temperatureCelsius = $(voltage - 0.5) * 100.0$; 
  
  Serial.print("Temperatura: ");
  Serial.print(temperatureCelsius);
  Serial.println(" °C");
  
  delay(1000); // Espera un segundo para la próxima lectura
}

micholin

copilot

Cpp
const int sensorPin = A0; // Pata S del KY-028 conectada a A0 en Arduino

void setup() {
  Serial.begin(9600); // Inicia la comunicación serial a 9600 bps
}

void loop() {
  int sensorValue = analogRead(sensorPin); // Lee el valor del sensor
  float voltage = sensorValue * 5.0 / 1023.0; // Convierte el valor a voltaje
  // Calcula la temperatura en grados Celsius. 
  // El factor de conversión dependerá específicamente del sensor y de su respuesta a la temperatura.
  // Este es un valor supuesto para ilustrar.
  // Debes calibrar este valor según tu sensor y las especificaciones del módulo KY-028.
  float temperatureCelsius = (voltage - 0.5) * 100.0; 
  
  Serial.print("Temperatura: ");
  Serial.print(temperatureCelsius);
  Serial.println(" °C");
  
  delay(1000); // Espera un segundo para la próxima lectura
}

• sensorPin es el pin al que conectas la salida del sensor KY-028 en tu Arduino.
• Serial.begin(9600); inicia comunicación serial que te permite ver la temperatura en grados Celsius en el monitor serial en el IDE de Arduino.
• analogRead(sensorPin); lee el valor analógico del sensor.
• sensorValue * 5.0 / 1023.0; convierte ese valor leído en el voltaje, asumiendo 5V como el voltaje de referencia.
• (voltage - 0.5) * 100.0; es una conversión general para calcular la temperatura en grados Celsius a partir del voltaje. Esta fórmula es simplemente un ejemplo y puede que necesites ajustarla basándote en las características y la respuesta específica de tu módulo KY-028.

micholin

copilot

Cpp
const int sensorPin = A0; // Conecta el pin de señal S del KY-028 al pin A0 en Arduino

void setup() {
  Serial.begin(9600); // Inicia la comunicación serial a 9600 bps
}

void loop() {
  int sensorValue = analogRead(sensorPin); // Lee el valor del sensor
  float voltage = sensorValue * 5.0 / 1023.0; // Convierte el valor a voltaje
  
  // Ajuste para la relación inversa entre la temperatura y el voltaje.
  // Esta es una fórmula ajustada para reflejar una relación inversa.
  // Este es un ejemplo basado en una asunción y es necesario calibrarlo con datos reales.
  float temperatureCelsius = $1.0 - (voltage / 5.0)$ * 100.0;
  
  Serial.print("Temperatura: ");
  Serial.print(temperatureCelsius);
  Serial.println(" °C");
  
  delay(1000); // Espera un segundo para la próxima lectura
}

micholin

copilot

• 1 x Arduino (Uno, Nano, etc.)
• 2 x botón pulsador
• Resistencias de 10k ohmios para las resistencias de pull-down (opcional según la configuración)
• Cables de conexión

• Botón Aumentar: Conecta un pin de un botón a la entrada digital 2 en Arduino. Conecta el otro pin del botón a tierra (GND), idealmente a través de una resistencia de 10k ohmios como resistencia de pull-down.
• Botón Disminuir: Conecta un pin del otro botón a la entrada digital 3 en Arduino. Conecta el otro pin del botón a tierra (GND), también a través de una resistencia de pull-down de 10k ohmios, si eliges usarla.

Cpp
// Definición de los pines para los botones
const int botonAumentar = 2;
const int botonDisminuir = 3;

// Variable para almacenar la temperatura deseada
int temperaturaObjetivo = 25; // Temperatura inicial arbitraria

void setup() {
  Serial.begin(9600); // Inicia la comunicación serial
  pinMode(botonAumentar, INPUT_PULLUP); // Configura el pin del botón como entrada
  pinMode(botonDisminuir, INPUT_PULLUP); // Configura el pin del botón como entrada
}

void loop() {
  // Lee el estado de los botones
  int estadoBotonAumentar = !digitalRead(botonAumentar); // Nega el valor para manejar INPUT_PULLUP
  int estadoBotonDisminuir = !digitalRead(botonDisminuir); // Nega el valor para manejar INPUT_PULLUP

  // Aumenta la temperatura si se presiona el botón correspondiente
  if (estadoBotonAumentar) {
    temperaturaObjetivo++;
    Serial.print("Temperatura Objetivo: ");
    Serial.println(temperaturaObjetivo);
    delay(200); // Pequeño retardo para evitar incrementos demasiado rápidos
  }

  // Disminuye la temperatura si se presiona el botón correspondiente
  if (estadoBotonDisminuir) {
    temperaturaObjetivo--;
    Serial.print("Temperatura Objetivo: ");
    Serial.println(temperaturaObjetivo);
    delay(200); // Pequeño retardo para evitar decrementos demasiado rápidos
  }
}

• Este código usa INPUT_PULLUP en las entradas de los botones, lo que significa que los botones conectan a tierra cuando se presionan. Si tus botones están configurados para conectarse a 5V en lugar de a GND cuando se presionan, deberás modificar la lógica (eliminar las negaciones ! en las lecturas de los botones y usar resistencias de pull-up en lugar).
• El valor inicial de temperaturaObjetivo es arbitrario y se puede ajustar según las necesidades de tu proyecto.
• Se incluye un delay(200) tras detectar la presión de un botón para evitar cambios demasiado rápidos debido al rebote del botón o a presiones prolongadas. Esto puede ajustarse según las necesidades específicas de tu aplicación.

copilot

1. Alimentación del sensor:

   • Conecta el pin VCC del KY-028 a tu fuente de alimentación.
   • Conecta el pin GND del KY-028 a tu tierra común.

2. Conexión del sensor al circuito:

   • Dado que $R_1$, $C_1$, y $L_1$ no están directamente relacionados con la lectura de temperatura, vamos a enfocarnos en cómo conectar el sensor a un microcontrolador para la lectura. Para esto, necesitarás un pin adicional (no listado en tu diseño actual) que pueda leer voltajes analógicos si el KY-028 no tiene un conversor analógico a digital incorporado.
   • Conecta el pin de salida (usualmente marcado con un simbolo de señal o OUT) del KY-028 al pin analógico de entrada en tu microcontrolador.

micholin

copilot

1. Sensor de temperatura NTC KY-028.
2. Arduino Uno o compatible.
3. Cables de conexión.

• KY-028 a Arduino:

  • Connect VCC del KY-028 to 5V del Arduino.
  • Connect GND del KY-028 to GND del Arduino.
  • Connect Señal (S) del KY-028 to A0 del Arduino.

Cpp
void setup() {
  // Inicia la comunicación serial a 9600 bps.
  Serial.begin(9600);
}

void loop() {
  // Leer el valor del pin analógico A0.
  int sensorValue = analogRead(A0);
  // Enviar el valor al monitor serial.
  Serial.println(sensorValue);
  delay(1000); // Esperar un segundo para la próxima lectura.
}

1. Conecta los componentes según las indicaciones dadas.
2. Carga el código de ejemplo a tu Arduino usando el IDE de Arduino.
3. Abre el Monitor Serial desde el IDE para ver en tiempo real los valores que se leen del sensor.

micholin

copilot

Cpp
void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(A0); // Leer el valor desde el sensor

  // Convertir ese valor a voltaje, dado que la resolución del ADC es de 10 bits (1024 pasos) y la referencia es de 5V.
  float voltage = sensorValue * (5.0 / 1023.0);

  // Convertir el voltaje a temperatura.
  // Este es un ejemplo genérico, y deberías reemplazarlo con la fórmula específica para tu sensor NTC.
  float temperature = (voltage - 0.5) * 100; // Ejemplo genérico

  Serial.print("Temperatura: ");
  Serial.print(temperature);
  Serial.println(" Celsius");

  delay(1000); // Esperar un segundo para la próxima lectura
}

micholin

copilot

1. Inversión del comportamiento de medición: Los NTC (Termistores de Coeficiente de Temperatura Negativa) disminuyen su resistencia a medida que la temperatura aumenta. Esto significa que si estás midiendo directamente el voltaje a través del sensor en un divisor de voltaje, el voltaje disminuirá a medida que la temperatura aumente, lo cual podría estar causando tus lecturas invertidas.
2. Ajuste de offset: Si las mediciones están consistentemente 10 grados por encima de lo que deberían ser, necesitas ajustar esta diferencia en tu cálculo.

Cpp
void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(A0); // Leer el valor desde el sensor

  // Convertir ese valor a voltaje
  float voltage = sensorValue * (5.0 / 1023.0);

  // Asumiendo que tu sensor se comporta al revés, ajustaremos el cálculo
  // NOTA: Este ajuste es ilustrativo. Deberías calibrar este cálculo con los datos precisos de tu NTC.
  float temperature = ((5.0 - voltage) - 0.5) * 100;

  // Ajustar el offset de 10 grados
  temperature -= 10;

  Serial.print("Temperatura: ");
  Serial.print(temperature);
  Serial.println(" Celsius");

  delay(1000); // Esperar un segundo para la próxima lectura
}

• Inversión del Comportamiento: Se calcula la temperatura basándose en $(5.0 - voltaje)$ en lugar de solo $voltaje$ para invertir la relación de medición. Esto asume un comportamiento lineal, lo cual puede no ser exacto para un NTC sin una característica de calibración precisa.
• Offset de Temperatura: Restar directamente 10 del cálculo final de la temperatura para corregir el offset observado.

copilot

• 1x Arduino UNO
• 1x Sensor de temperatura digital (DS18B20)
• 1x Calentador (controlar a través de un relé)
• 1x Ventilador (controlar a través de un relé)
• 2x Push Button
• 1x Pantalla LCD 16x2 (con módulo I2C opcionalmente para simplificar la conexión)
• Resistencias, cables, protoboard/breadboard

1. Sensor de temperatura DS18B20:

   • VCC a 5V Arduino
   • GND a GND Arduino
   • DATA a un pin digital (Por ejemplo, D2). Usa una resistencia de pull-up de 4.7kΩ entre VCC y DATA.

2. Calentador y Ventilador (a través de relés):

   • Controla cada relé usando un pin digital (Por ejemplo, D3 para el ventilador y D4 para el calentador).
   • Asegúrate de que los relés sean compatibles con la corriente y voltaje de tu calentador y ventilador.

3. Push Buttons:

   • Conecta un lado de cada botón a 5V y el otro lado a un pin digital (Por ejemplo, D5 y D6), usando resistencias de pull-down para mantener los pines en bajo cuando no se presionen los botones.

4. Pantalla LCD 16x2:

   • Si estás usando módulo I2C, conecta VCC a 5V, GND a GND, SDA a A4, y SCL a A5 en el Arduino.

Cpp
#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>

// Inicializa el sensor DS18B20
OneWire oneWire(D2);
DallasTemperature sensors(&oneWire);

// Inicializa la pantalla LCD
LiquidCrystal_I2C lcd(0x27,16,2);

// Variables para almacenar la temperatura ideal
float temperaturaIdeal = 25.0; // Valor inicial
float temperaturaActual;

void setup() {
  pinMode(D3, OUTPUT); // Ventilador
  pinMode(D4, OUTPUT); // Calentador
  pinMode(D5, INPUT); // Botón para subir la temperatura ideal
  pinMode(D6, INPUT); // Botón para bajar la temperatura ideal
  sensors.begin();
  lcd.begin();
  lcd.backlight();
}

void loop() {
  sensors.requestTemperatures();
  temperaturaActual = sensors.getTempCByIndex(0);

  // Actualizar temperatura ideal con botones
  if (digitalRead(D5) == HIGH) {
    temperaturaIdeal++;
    delay(200); // Debounce
  }
  if (digitalRead(D6) == HIGH) {
    temperaturaIdeal--;
    delay(200); // Debounce
  }

  // Control del ventilador y calentador
  if (temperaturaActual >= temperaturaIdeal + 3) {
    digitalWrite(D3, HIGH); // Enciende ventilador
    digitalWrite(D4, LOW); // Apaga calentador
  } else if (temperaturaActual <= temperaturaIdeal - 3) {
    digitalWrite(D4, HIGH); // Enciende calentador
    digitalWrite(D3, LOW); // Apaga ventilador
  } else {
    digitalWrite(D3, LOW); // Apaga ventilador
    digitalWrite(D4, LOW); // Apaga calentador
  }

  // Muestra la información en la pantalla LCD
  lcd.clear();
  lcd.print("Temp:");
  lcd.print(temperaturaActual);
  lcd.setCursor(0, 1);
  lcd.print("T Ideal:");
  lcd.print(temperaturaIdeal);

  delay(1000); // Actualiza cada segundo
}