1. Inicio del sistema:
   • Al encender, se muestra en la pantalla (en este ejemplo se usa el monitor serial, pero puedes reemplazarlo por tu pantalla LCD u otro) el mensaje

     BI: Dairo Arenas Ortiz
     

     durante 1 segundo.
2. Señalización con LEDs:
   • El LED verde indica que el circuito está activo.
   • El LED rojo se enciende cuando se detecta un error en el modo manual y también se enciende (al finalizar) en el modo automático.
3. Modo Manual:
   • Se ingresa al modo manual cuando se presiona un botón asignado (aquí, el mismo botón de selección se usa para determinar el modo mediante la duración de la pulsación).
   • En este modo el usuario gira el encoder lentamente; el software verifica que la secuencia de posiciones sea continua (asumiendo un rango de 0 a 249, es decir 250 posiciones). Si se detecta que la posición esperada se “salta” (por ejemplo, si después de la posición 63 se espera la 64 y se detecta otro valor), se imprime en pantalla el mensaje:

     error en la posicion X
     

     donde X es la posición que no se leyó. Además se enciende el LED rojo hasta que el usuario pulse el botón de reset.
4. Modo Automático:
   • Se ingresa al modo automático cuando se presiona el botón de modo durante más de 1 segundo.
   • Al entrar se imprime en pantalla “modo automatico”. Luego, el sistema realiza una "lectura" continua del encoder hasta que se detecta que se repite un valor (p. ej. se inicia en la posición 3 y al volver a aparecer la misma posición se concluye el modo).
   • Se analizan los valores leídos; en caso de encontrar “saltos” entre la mínima y la máxima posición, se forma un mensaje del tipo:

     error en los pines X X X ... 
     

     donde cada X indica una posición faltante. Al concluir se enciende el LED rojo (durante 1 segundo) para marcar la finalización de la prueba.
5. Consideraciones adicionales:
   • Se agregan los LED faltantes configurando los pines correspondientes (por ejemplo, LED verde en PIN_LED_VERDE y LED rojo en PIN_LED_ROJO).
   • Se utiliza una estructura sencilla para ilustrar la lectura del encoder (en una implementación real podrías usar interrupciones o una librería de encoder).

Cpp
#include 

// Pines asignados (modifícalos según tu hardware)
const int PIN_ENCODER_A    = 2;
const int PIN_ENCODER_B    = 3;
const int PIN_MODE_BUTTON  = 4;
const int PIN_RESET_BUTTON = 5;
const int PIN_LED_ROJO     = 6;
const int PIN_LED_VERDE    = 7;

// Variables globales del encoder y modos
volatile int encoderPos = 0;     // posición del encoder (0 a 249)
int lastEncoderPos    = -1;       // para comparar en modo manual

// Prototipos de funciones
void manualMode();
void autoMode();
void updateEncoder();

void setup() {
  // Inicializar el monitor serial (o la pantalla que uses)
  Serial.begin(9600);
  
  // Mensaje de bienvenida durante 1 segundo
  Serial.println("BI: Dairo Arenas Ortiz");
  delay(1000);
  
  // Configuración de pines
  pinMode(PIN_ENCODER_A, INPUT);
  pinMode(PIN_ENCODER_B, INPUT);
  pinMode(PIN_MODE_BUTTON, INPUT_PULLUP);
  pinMode(PIN_RESET_BUTTON, INPUT_PULLUP);
  
  // Configurar pines de LEDs
  pinMode(PIN_LED_ROJO, OUTPUT);
  pinMode(PIN_LED_VERDE, OUTPUT);
  
  // Encender LED verde para indicar circuito activo
  digitalWrite(PIN_LED_VERDE, HIGH);
  digitalWrite(PIN_LED_ROJO, LOW);
  
  // Si deseas usar interrupciones para el encoder, configúralas aquí
  // Por ejemplo:
  // attachInterrupt(digitalPinToInterrupt(PIN_ENCODER_A), updateEncoder, CHANGE);
}

void loop() {
  // Esperar la pulsación del botón de modo
  if (digitalRead(PIN_MODE_BUTTON) == LOW) {
    delay(50);  // debounce
    // Se mide la duración de la pulsación:
    unsigned long pressTime = millis();
    while (digitalRead(PIN_MODE_BUTTON) == LOW) { }
    unsigned long duration = millis() - pressTime;
    
    if (duration  maxVal) maxVal = scanned[i];
  }
  
  String errorMsg = "error en los pines ";
  bool errorFound = false;
  for (int expected = minVal; expected <= maxVal; expected++) {
    bool found = false;
    for (int i = 0; i < scanCount; i++) {
      if (scanned[i] == expected) {
        found = true;
        break;
      }
    }
    if (!found) {
      errorMsg += String(expected) + " ";
      errorFound = true;
    }
  }
  
  if (errorFound) {
    Serial.println(errorMsg);
  } else {
    Serial.println("No se detectaron errores en el modo automatico");
  }
  
  // Enciende el LED rojo para indicar la finalización del modo automático
  digitalWrite(PIN_LED_ROJO, HIGH);
  delay(1000);
  digitalWrite(PIN_LED_ROJO, LOW);
}

// Función ficticia que simula la actualización de la posición del encoder
// Reemplaza esta función por la lógica real (por ejemplo, mediante interrupciones o usando una librería específica)
void updateEncoder() {
  // Ejemplo básico: se incrementa o decrementa la posición con base en la lectura de los pines A y B
  // (La lógica de un encoder requiere decodificación de las señales; este es solo un placeholder)
  int a = digitalRead(PIN_ENCODER_A);
  int b = digitalRead(PIN_ENCODER_B);
  
  if (a == b) {
    encoderPos = (encoderPos + 1) % 250;
  } else {
    encoderPos = (encoderPos - 1 + 250) % 250;
  }
}

• Asegúrate de adaptar la lectura del encoder a tu hardware; existen librerías (por ejemplo, Encoder) que facilitan el manejo de estos dispositivos.
• El ejemplo utiliza el monitor serial para simular la pantalla. Si usas un display (LCD, OLED, etc.), reemplaza las instrucciones Serial.println() por las funciones de tu librería de display.
• El manejo de botones se hace con INPUT_PULLUP, por lo que se asume que la conexión de los botones hace que el pin se ponga en LOW al presionarlos.
• Se incorporaron los LED faltantes según la descripción para señalizar correctamente los estados de error y funcionamiento.