copilot

• Arduino Mega: El cerebro de nuestro sistema.
• LEDs: Verde, amarillo y rojo.
• Resistencias: Para limitar la corriente a los LEDs, asumiendo unos 220Ω.
• Pulsadores (x2): Uno para iniciar el ciclo y otro para apagar el sistema.
• Switches (x2): Uno para cambiar la dirección y otro para el modo intermitente.

1. LEDs a Arduino:
   • Conectar el ánodo (+) de cada LED a través de una resistencia de 220Ω a los pines digitales del Arduino (ej: Verde a pin 2, Amarillo a pin 3, Rojo a pin 4).
   • Conectar el cátodo (-) de cada LED a GND.
2. Pulsadores al Arduino:
   • Conectar un terminal de cada pulsador a GND y el otro terminal a un pin digital (ej: pulsador de inicio a pin 5, pulsador de apagar a pin 6). Utilizar resistencias de pull-up internas en el código o resistencias de pull-up externas.
3. Switches al Arduino:
   • Conectar de manera similar a los pulsadores; switch de dirección a pin 7 y switch de modo intermitente a pin 8.

1. Busca y coloca los componentes mencionados en tu espacio de trabajo de Proteus.
2. Realiza las conexiones de acuerdo a las especificaciones anteriores.
3. Asigna los pines digitales del Arduino a los componentes correspondientes.

Cpp
// Definición de pines
const int pinVerde = 2;
const int pinAmarillo = 3;
const int pinRojo = 4;
const int pinInicio = 5;
const int pinApagar = 6;
const int pinDireccion = 7;
const int pinModoIntermitente = 8;

// Variables de estado
bool estadoSistema = false;
bool direccion = false; // false = normal, true = inverso
bool modoIntermitente = false;

void setup() {
  // Configurar pines de LED como salida
  pinMode(pinVerde, OUTPUT);
  pinMode(pinAmarillo, OUTPUT);
  pinMode(pinRojo, OUTPUT);

  // Configurar pines de botones y switch como entrada
  pinMode(pinInicio, INPUT_PULLUP);
  pinMode(pinApagar, INPUT_PULLUP);
  pinMode(pinDireccion, INPUT_PULLUP);
  pinMode(pinModoIntermitente, INPUT_PULLUP);
}

void loop() {
  leerEntradas();

  if (estadoSistema) {
    if (modoIntermitente) {
      parpadearAmarillo();
    } else {
      cicloNormal();
    }
  }
}

void leerEntradas() {
  // Leer inicio
  if (digitalRead(pinInicio) == LOW) {
    estadoSistema = true;
  }
  
  // Leer apagar
  if (digitalRead(pinApagar) == LOW) {
    estadoSistema = false;
    apagarLEDs();
  }

  // Leer dirección
  direccion = digitalRead(pinDireccion) == HIGH;

  // Leer modo intermitente
  modoIntermitente = digitalRead(pinModoIntermitente) == HIGH;
}

void cicloNormal() {
  if (direccion) { // Inverso
    encenderRojo();
    delay(1500);
    encenderAmarillo();
    delay(1000);
    encenderVerde();
    delay(2000);
  } else { // Normal
    encenderVerde();
    delay(2000);
    encenderAmarillo();
    delay(1000);
    encenderRojo();
    delay(1500);
  }
}

void parpadearAmarillo() {
  encenderAmarillo();
  delay(500);
  apagarLEDs();
  delay(500);
}

void apagarLEDs() {
  digitalWrite(pinVerde, LOW);
  digitalWrite(pinAmarillo, LOW);
  digitalWrite(pinRojo, LOW);
}

void encenderVerde() {
  digitalWrite(pinVerde, HIGH);
  digitalWrite(pinAmarillo, LOW);
  digitalWrite(pinRojo, LOW);
}

void encenderAmarillo() {
  digitalWrite(pinVerde, LOW);
  digitalWrite(pinAmarillo, HIGH);
  digitalWrite(pinRojo, LOW);
}

void encenderRojo() {
  digitalWrite(pinVerde, LOW);
  digitalWrite(pinAmarillo, LOW);
  digitalWrite(pinRojo, HIGH);
}

copilot

1. LEDs: Un LED rojo, uno amarillo y uno verde.
2. Resistencias: Para limitar la corriente a los LEDs, típicamente de $220,\Omega$ o $330,\Omega$.
3. Pulsadores: Dos pulsadores, uno para iniciar el ciclo y otro para apagar el sistema.
4. Switches: Dos interruptores (switches), uno para cambiar la dirección de los LEDs y otro para cambiar el modo de operación a intermitente.

1. LED Verde:
   • Conecta el ánodo (lado más largo) del LED verde a un pin digital del Arduino (por ejemplo, pin 2).
   • Conecta el cátodo (lado más corto) del LED verde a una resistencia de $220,\Omega$ o $330,\Omega$.
   • Conecta el otro extremo de la resistencia a GND (tierra) en el Arduino.
2. LED Amarillo y LED Rojo: Repite el mismo proceso para los LEDs amarillo (por ejemplo, conectado al pin 3) y rojo (por ejemplo, conectado al pin 4), asegurándote de que cada LED tenga su propia resistencia conectada a GND.

1. Pulsador para Iniciar el Ciclo:
   • Conecta un extremo del pulsador al pin 5 en el Arduino.
   • Conecta el otro extremo del pulsador a GND.
2. Pulsador para Apagar el Sistema:
   • Conecta un extremo del segundo pulsador al pin 6 en el Arduino.
   • Conecta el otro extremo del pulsador a GND.

1. Switch para Cambiar la Dirección de los LEDs:
   • Conecta un extremo del switch al pin 7 en el Arduino.
   • Conecta el otro extremo del switch a GND.
2. Switch para Cambiar el Funcionamiento a Intermitente:
   • Conecta un extremo del segundo switch al pin 8 en el Arduino.
   • Conecta el otro extremo del switch a GND.

• LEDs:
  • Connect LED Verde $Pin anodo$ to Arduino Pin 2.
  • Connect LED Amarillo $Pin anodo$ to Arduino Pin 3.
  • Connect LED Rojo $Pin anodo$ to Arduino Pin 4.
  • Todos los LEDs tienen su cátodo conectado a través de una resistencia a GND.
• Pulsadores:
  • Connect Pulsador para iniciar: un extremo a Arduino Pin 5, otro extremo a GND.
  • Connect Pulsador para apagar: un extremo a Arduino Pin 6, otro extremo a GND.
• Interruptores (Switches):
  • Connect Switch de dirección: un extremo a Arduino Pin 7, el otro extremo a GND.
  • Connect Switch de modo intermitente: un extremo a Arduino Pin 8, el otro extremo a GND.

1. Leer el estado de los pulsadores para iniciar el ciclo o apagar el sistema.
2. Cambiar la secuencia de LEDs según el switch de dirección.
3. Alternar el modo de operación (normal o intermitente) según el switch correspondiente.

• Uso de pinMode(), digitalRead(), y digitalWrite() para controlar pines.
• Estructuras condicionales (if, else) para implementar la lógica de control.
• Posiblemente, el uso de millis() para el control de tiempos sin usar delay(), para permitir una respuesta fluida a los pulsadores y switches sin bloquear el código.