Cpp
#include 

// Definición de pines
const int buttonPin    = 2;   // Primer botón: cuenta pulsos (INPUT_PULLUP)
const int motorBtnPin  = 6;   // Segundo botón: activa motor (INPUT_PULLUP)
const int greenLed     = 3;   // LED verde
const int yellowLed    = 4;   // LED amarillo
const int redLed       = 5;   // LED rojo
const int motorPin     = 8;   // Motor 1
const int servoPin     = 9;   // Servo motor

Servo myServo;  // Instancia para controlar el servo

// Variables para el primer botón (conteo de pulsos) con debounce
int buttonState = HIGH;
int lastButtonState = HIGH;
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50; // Tiempo de debounce en ms

int pulseCount = 0;

// Variables para el segundo botón (motor) con debounce
int motorBtnState = HIGH;
int lastMotorBtnState = HIGH;
unsigned long lastMotorDebounceTime = 0;
const unsigned long motorDebounceDelay = 50;

// Bandera que indica que el motor está activado
bool motorActive = false;

void setup() {
  // Configurar pines
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(motorBtnPin, INPUT_PULLUP);
  pinMode(greenLed, OUTPUT);
  pinMode(yellowLed, OUTPUT);
  pinMode(redLed, OUTPUT);
  pinMode(motorPin, OUTPUT);
  
  // Iniciar el servo y colocarlo en 0 grados
  myServo.attach(servoPin);
  myServo.write(0);
  
  // Apagar todos los LEDs y el motor inicial
  digitalWrite(greenLed, LOW);
  digitalWrite(yellowLed, LOW);
  digitalWrite(redLed, LOW);
  digitalWrite(motorPin, LOW);
  
  Serial.begin(9600);
}

void loop() {
  // Lectura del primer botón (conteo de pulsos)
  int reading = digitalRead(buttonPin);
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != buttonState) {
      buttonState = reading;
      // Se detecta flanco de bajada (presión del botón)
      if (buttonState == LOW) {
        pulseCount++;
        Serial.print("Pulsos: ");
        Serial.println(pulseCount);
        
        // Apagar todos los LEDs antes de encender el correspondiente
        digitalWrite(greenLed, LOW);
        digitalWrite(yellowLed, LOW);
        digitalWrite(redLed, LOW);
        
        if (pulseCount >= 1 && pulseCount = 6 && pulseCount = 11 && pulseCount  motorDebounceDelay) {
    if (motorReading != motorBtnState) {
      motorBtnState = motorReading;
      if (motorBtnState == LOW) {
        motorActive = true;
        Serial.println("Motor activado");
      }
    }
  }
  lastMotorBtnState = motorReading;
  
  // Si el motor está activado y el recuento de pulsos es menor a 15,
  // se mantiene el motor encendido
  if (motorActive && pulseCount = 15) {
    digitalWrite(motorPin, LOW);
    Serial.println("Motor detenido. Esperando 5 segundos...");
    delay(5000);
    
    Serial.println("Moviendo servo a 180 grados");
    myServo.write(180);
    delay(1000);  // Mantener la posición 180° durante 1 segundo
    
    Serial.println("Regresando servo a 0 grados");
    myServo.write(0);
    
    // Reiniciar variables para la siguiente operación
    pulseCount = 0;
    motorActive = false;
    
    // Apagar LEDs tras el reinicio
    digitalWrite(greenLed, LOW);
    digitalWrite(yellowLed, LOW);
    digitalWrite(redLed, LOW);
  }
}

1. Configuración de Pines y Variables:
   • Se utiliza INPUT_PULLUP para los botones, por lo que se deben conectar a GND al ser presionados.
   • Se incluyen variables de debounce para evitar lecturas erráticas.
2. Contador de Pulsos y Selección de LED:
   • Al presionar el primer botón se incrementa la variable pulseCount.
   • Dependiendo de la cantidad de pulsos (1-5, 6-10, 11-15), se enciende el LED verde, amarillo o rojo respectivamente.
3. Activación y Control del Motor:
   • Al presionar el segundo botón se activa el motor (se enciende la salida motorPin), siempre que el contador de pulsos sea menor a 15.
4. Acción al Alcanzar 15 Pulsos:
   • Una vez que pulseCount alcanza 15 y el motor está activo, se detiene el motor.
   • Se espera 5 segundos y luego se mueve el servo a 180° durante 1 segundo antes de regresar a 0°.
   • Finalmente, se reinician las variables para una nueva operación.