Cpp
#include 
#include 

// Configuración del LCD I2C (dirección: 0x27; 16 columnas, 2 filas)
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Definición de pines
const int buttonPin = 2;    // Botón para cambiar entre modos (se recomienda usar modo INPUT_PULLUP)
const int motorPin  = 9;    // Salida PWM para el motor DC
const int relayPin  = 8;    // Salida digital para el relevador
const int tempPin   = A0;   // Entrada analógica para el sensor de temperatura (ej. LM35)

// Valores PWM correspondientes a cada velocidad (33%, 66% y 100%)
const int PWM_33  = 84;     // Aproximadamente 33% de 255
const int PWM_66  = 168;    // Aproximadamente 66% de 255
const int PWM_100 = 255;    // 100%

// Variables de estado
int mode = 1;               // Modo actual (1 a 5)
bool buttonState = HIGH;
bool lastButtonState = HIGH;
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50;

// Para el modo brisa (modo 4)
unsigned long mode4StartTime = 0;
bool mode4Active = false;   // Para saber si se está ejecutando la rampa

void setup() {
  // Configuración de pines
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(motorPin, OUTPUT);
  pinMode(relayPin, OUTPUT);
  
  // Inicializa el LCD
  lcd.init();
  lcd.backlight();
  
  // Mensaje de inicio
  lcd.setCursor(0, 0);
  lcd.print("Modo: 1");
  lcd.setCursor(0, 1);
  lcd.print("Inicializando");
  
  delay(1500);
  // Inicializamos estado: apagar relevador
  digitalWrite(relayPin, LOW);
}

void loop() {
  // Lectura y control del botón con debounce para cambiar modo
  int reading = digitalRead(buttonPin);
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != buttonState) {
      buttonState = reading;
      if (buttonState == LOW) {
        // Cambia de modo al presionar el botón
        mode++;
        if (mode > 5) {
          mode = 1;
        }
        // Reiniciar variables del modo 4
        if (mode == 4) {
          mode4StartTime = millis();
          mode4Active = true;
        } else {
          mode4Active = false;
        }
      }
    }
  }
  lastButtonState = reading;

  // Lectura de la temperatura (supongamos sensor LM35: 10 mV por grado)
  int analogVal = analogRead(tempPin);
  // Voltaje en mV: (analogVal*5000)/1023, temperatura en °C=(voltaje en mV)/10
  float temperature = (analogVal * (5000.0 / 1023.0)) / 10.0;
  
  // Variable para el valor PWM actual
  int pwmValue = 0;
  
  // Variable para porcentaje de velocidad
  int percent = 0;
  
  // Según el modo, calculamos la acción del motor y del relevador.
  switch (mode) {
    case 1:
      // Modo 1: Motor al 33%
      pwmValue = PWM_33;
      digitalWrite(relayPin, LOW);
      break;
  
    case 2:
      // Modo 2: Motor al 66%
      pwmValue = PWM_66;
      digitalWrite(relayPin, LOW);
      break;
  
    case 3:
      // Modo 3: Motor al 100%
      pwmValue = PWM_100;
      digitalWrite(relayPin, LOW);
      break;
  
    case 4:
      // Modo brisa: Rampa de 33% a 100% en 4 segundos
      {
        unsigned long elapsed = millis() - mode4StartTime;
        if (elapsed >= 4000) {
          pwmValue = PWM_100;
          mode4Active = false; // Fin de la rampa, se mantiene en 100%
        } else {
          // Interpolación lineal
          float ratio = elapsed / 4000.0;
          pwmValue = PWM_33 + (int)((PWM_100 - PWM_33) * ratio);
        }
        digitalWrite(relayPin, LOW);
      }
      break;
  
    case 5:
      // Modo 5: Control por temperatura, con relevador.
      // Si la temperatura es menor a 30°C, motor al 33%, y si es mayor o igual, motor al 100%
      if (temperature < 30.0) {
        pwmValue = PWM_33;
        digitalWrite(relayPin, LOW);
      } else {
        pwmValue = PWM_100;
        digitalWrite(relayPin, HIGH); // Activa el relevador
      }
      break;
      
    default:
      pwmValue = 0;
      digitalWrite(relayPin, LOW);
      break;
  }

  // Actualización de salida PWM (motor DC)
  analogWrite(motorPin, pwmValue);
  
  // Calcular el porcentaje de velocidad
  percent = (pwmValue * 100) / 255;
  
  // Actualización del display LCD
  lcd.clear();
  lcd.setCursor(0, 0);
  // Mostrar el modo y su descripción breve
  switch (mode) {
    case 1:
      lcd.print("Modo 1: 33%");
      break;
    case 2:
      lcd.print("Modo 2: 66%");
      break;
    case 3:
      lcd.print("Modo 3: 100%");
      break;
    case 4:
      lcd.print("Modo Brisa");
      break;
    case 5:
      lcd.print("Modo Temp");
      break;
  }
  
  lcd.setCursor(0, 1);
  lcd.print("T:");
  lcd.print(temperature, 1);
  lcd.print("C V:");
  lcd.print(percent);
  lcd.print("%");
  
  delay(200);  // Pequeño retardo para estabilidad del display
}

/*
Conexiones sugeridas:
--------------------------------------------
1. Sensor de temperatura (ej. LM35):
   - Salida del LM35: Conectar a A0.
   - Vcc del LM35: 5V.
   - GND del LM35: GND.

2. Motor DC (vía controlador PWM o MOSFET):
   - Control PWM: Conectar la entrada de control al pin 9.
   - Alimentación del motor: Fuente de 5V o según especificación.
   - Conectar la tierra (GND) en común.

3. Relevador:
   - Bobina del relevador: Conectar a la salida digital del pin 8 (se recomienda utilizar un transistor y diodo flyback según el circuito del relevador).
   - Los contactos del relevador se conectan según la aplicación (por ejemplo, para encender una carga adicional).

4. Botón:
   - Un terminal del botón al pin 2.
   - El otro terminal del botón a GND.
   - Se utiliza el resistor pull-up interno (INPUT_PULLUP) por lo que no requiere resistor adicional.

5. LCD I2C:
   - SDA: Conectar al pin A4 (para Arduino Uno).
   - SCL: Conectar al pin A5 (para Arduino Uno).
   - Vcc y GND según la alimentación (5V y GND).
   
Asegúrate de que todas las conexiones compartan una tierra común.
--------------------------------------------
*/

• Modos 1 a 3: Al presionar el botón se cambia secuencialmente el modo de operación:
  • Modo 1: Motor al 33% (valor PWM ≈ 84).
  • Modo 2: Motor al 66% (valor PWM ≈ 168).
  • Modo 3: Motor al 100% (valor PWM = 255).
• Modo 4 (Modo Brisa): Inicia una rampa lineal que incrementa el PWM desde 33% hasta 100% durante 4 segundos.
• Modo 5 (Control por Temperatura): Se lee la temperatura. Si es inferior a 30 °C, el motor se mantiene al 33% y el relevador se apaga; por encima de 30 °C, el motor corre a 100% y se activa el relevador.
• Display LCD: Se muestran el modo activo, la temperatura medida (con 1 decimal) y el porcentaje de velocidad (calculado a partir del valor PWM).
• Conexiones: Se incluyen comentarios al final del sketch que describen cómo realizar las conexiones de cada componente.

• Wire.h: Para la comunicación I2C.
• LiquidCrystal_I2C.h: Para controlar el display LCD a través del bus I2C.