• HC-06:VCC a Arduino Mega:5V: Suministra la energía necesaria al módulo Bluetooth.
• HC-06:GND a Arduino Mega:GND: Completa el circuito de energía.
• HC-06:TXD a Arduino Mega:RX1 (Pin 19): Permite que el módulo Bluetooth envíe datos al Arduino.
• HC-06:RXD a Arduino Mega:TX1 (Pin 18): Permite que el Arduino envíe datos al módulo Bluetooth.

• Asegúrate de que el módulo HC-06 esté funcionando a 5V. Algunos módulos pueden requerir un divisor de voltaje o un adaptador de nivel lógico para el pin RX del HC-06, ya que está diseñado para 3.3V. Sin embargo, muchos usuarios lo conectan directamente al pin TX del Arduino sin problemas.
• En el código del Arduino, utiliza el puerto serial correspondiente (por ejemplo, Serial1 para los pines 18 y 19 en el Mega) para comunicarte con el HC-06.

1. Módulo Bluetooth HC-06:
   • HC-06:VCC a Arduino Mega:5V: Alimenta el módulo Bluetooth.
   • HC-06:GND a Arduino Mega:GND: Completa el circuito de energía.
   • HC-06:TXD a Arduino Mega:RX1 (Pin 19): Para recibir datos.
   • HC-06:RXD a Arduino Mega:TX1 (Pin 18): Para enviar datos. (Considera un divisor de voltaje si es necesario).
2. LED:
   • Conecta el ánodo (+) del LED a Arduino Mega:Pin digital 13 (o el que prefieras usar).
   • Conecta el cátodo (-) del LED a GND a través de una resistencia (por ejemplo, 220 ohmios) para limitar la corriente.

Cpp
void setup() {
  Serial1.begin(9600); // Inicializa la comunicación serial con el módulo Bluetooth
  pinMode(13, OUTPUT); // Configura el pin 13 como salida para el LED
}

void loop() {
  if (Serial1.available()) { // Verifica si hay datos disponibles en el puerto serial
    char data = Serial1.read(); // Lee el dato recibido
    if (data == '1') {
      digitalWrite(13, HIGH); // Enciende el LED
    } else if (data == '0') {
      digitalWrite(13, LOW);  // Apaga el LED
    }
  }
}

• Asegúrate de que el módulo Bluetooth esté configurado para comunicarse a la misma velocidad de baudios que usas en el Arduino (9600 en este caso).
• Puedes utilizar cualquier aplicación de terminal Bluetooth en tu teléfono para enviar los caracteres '1' y '0' al Arduino Mega.

• Arduino Uno
• Módulo Bluetooth HC-06
• 2 LEDs (uno para cada direccional)
• 2 resistencias para los LEDs (220 ohmios es un buen valor)
• 2 botones pulsadores
• 2 resistencias pull-down para los botones (10k ohmios)
• Cables de conexión
• Protoboard

1. Módulo Bluetooth HC-06:
   • HC-06:VCC a Arduino Uno:5V
   • HC-06:GND a Arduino Uno:GND
   • HC-06:TXD a Arduino Uno:RX (Pin 0)
   • HC-06:RXD a Arduino Uno:TX (Pin 1) (utiliza un divisor de voltaje si es necesario).
2. LEDs:
   • LED para izquierda:
     • Ánodo: Conectar a Arduino Uno:Pin digital 8
     • Cátodo: Conectar a GND a través de una resistencia de 220 ohmios
   • LED para derecha:
     • Ánodo: Conectar a Arduino Uno:Pin digital 9
     • Cátodo: Conectar a GND a través de una resistencia de 220 ohmios
3. Botones:
   • Botón para izquierda:
     • Un extremo a Arduino Uno:Pin digital 2
     • Otro extremo a GND a través de una resistencia de 10k ohmios (resistencia pull-down)
   • Botón para derecha:
     • Un extremo a Arduino Uno:Pin digital 3
     • Otro extremo a GND a través de una resistencia de 10k ohmios (resistencia pull-down)

Cpp
void setup() {
  Serial.begin(9600); // Inicializa la comunicación serial
  pinMode(2, INPUT);  // Configura el pin 2 como entrada (botón izquierda)
  pinMode(3, INPUT);  // Configura el pin 3 como entrada (botón derecha)
  pinMode(8, OUTPUT); // Configura el pin 8 como salida (LED izquierda)
  pinMode(9, OUTPUT); // Configura el pin 9 como salida (LED derecha)
}

void loop() {
  int leftButtonState = digitalRead(2);
  int rightButtonState = digitalRead(3);

  if (leftButtonState == HIGH) {
    digitalWrite(8, HIGH); // Enciende el LED izquierda
    Serial.println("L");   // Envía 'L' por Bluetooth
  } else {
    digitalWrite(8, LOW);  // Apaga el LED izquierda
  }

  if (rightButtonState == HIGH) {
    digitalWrite(9, HIGH); // Enciende el LED derecha
    Serial.println("R");   // Envía 'R' por Bluetooth
  } else {
    digitalWrite(9, LOW);  // Apaga el LED derecha
  }

  delay(100); // Pequeño retraso para estabilidad
}

Diagram

• Arduino Uno: Es el controlador principal del sistema.
• Módulo HC-06: Se conecta a los pines de 5V, GND, RX y TX del Arduino para permitir la comunicación Bluetooth.
• Botones: Uno para la señal de giro a la izquierda conectado al pin digital 2 y otro para la derecha conectado al pin digital 3, ambos con resistencias pull-down de 10kΩ.
• LEDs: El LED de la izquierda está conectado al pin digital 8 y el de la derecha al pin digital 9, cada uno con una resistencia limitadora de corriente de 220Ω hacia GND.

Cpp
// Declaramos los LEDs
int led1 = 2;
int led2 = 3;
int led3 = 4;
int led4 = 5;
int led5 = 6;
int led6 = 7;
int led7 = 8;
int led8 = 9;
int led9 = 10;
int led10 = 11;

// Declaramos los pulsadores de las direccionales
int pul_izq = A0;
int pul_par = A1;
int pul_der = A2;

// Declaro el estado de las direccionales (iniciar apagados)
bool dir_izq = false;
bool dir_der = false;
bool dir_par = false;

// El tiempo
int tiempo = 200;

void setup() {
  Serial.begin(9600); // Inicializa la comunicación serial para el módulo Bluetooth

  // Los pulsadores son de entrada
  pinMode(pul_izq, INPUT);
  pinMode(pul_der, INPUT);
  pinMode(pul_par, INPUT);

  // Configurar los pines de los LEDs como salida
  for (int i = 2; i <= 11; i++) {
    pinMode(i, OUTPUT);
  }
}

void loop() {
  // Leer el estado de los pulsadores
  dir_izq = digitalRead(pul_izq);
  dir_der = digitalRead(pul_der);
  dir_par = digitalRead(pul_par);

  // Leer comandos desde el módulo Bluetooth
  if (Serial.available()) {
    char command = Serial.read(); // Lee un único carácter
    if (command == 'L') {
      dir_izq = true;
      dir_der = false;
      dir_par = false;
    } else if (command == 'R') {
      dir_izq = false;
      dir_der = true;
      dir_par = false;
    } else if (command == 'P') {
      dir_izq = false;
      dir_der = false;
      dir_par = true;
    }
  }

  // Procesar la señal de la direccional izquierda
  if (dir_izq) {
    toggleLeds({led3, led6, led10});
    toggleLeds({led2, led5, led9});
    toggleLeds({led1, led4, led8});
  }

  // Procesar la señal de la direccional derecha
  if (dir_der) {
    toggleLeds({led1, led5, led8});
    toggleLeds({led2, led6, led9});
    toggleLeds({led3, led7, led10});
  }

  // Procesar la señal de parqueo
  if (dir_par) {
    toggleAllLeds();
  }
}

void toggleLeds(std::initializer_list<int> leds) {
  for (int led : leds) {
    digitalWrite(led, HIGH);
  }
  delay(tiempo);
  for (int led : leds) {
    digitalWrite(led, LOW);
  }
  delay(tiempo);
}

void toggleAllLeds() {
  for (int i = 2; i <= 11; i++) {
    digitalWrite(i, HIGH);
  }
  delay(tiempo);
  for (int i = 2; i <= 11; i++) {
    digitalWrite(i, LOW);
  }
  delay(tiempo);
}

• Bluetooth: Ahora está configurado para recibir caracteres 'L', 'R', y 'P' para encender las luces direccionales izquierda, derecha, y de parqueo respectivamente.
• Pulsadores: Continúan funcionando como antes, puedes ejecutarlos manualmente.
• Funciones toggleLeds y toggleAllLeds: Estas funciones facilitan alternar los LEDs en el patrón deseado.

Cpp
// Declaramos los LEDs
int led1 = 2;
int led2 = 3;
int led3 = 4;
int led4 = 5;
int led5 = 6;
int led6 = 7;
int led7 = 8;
int led8 = 9;
int led9 = 10;
int led10 = 11;

// El estado de las direccionales
bool dir_izq = false;
bool dir_der = false;
bool dir_par = false;

// El tiempo
int tiempo = 200;

void setup() {
  Serial.begin(9600); // Inicializa la comunicación serial para el módulo Bluetooth

  // Configurar los pines de los LEDs como salida
  for (int i = 2; i <= 11; i++) {
    pinMode(i, OUTPUT);
  }
}

void loop() {
  // Leer comandos desde el módulo Bluetooth
  if (Serial.available()) {
    char command = Serial.read(); // Lee un único carácter
    if (command == 'L') {
      dir_izq = true;
      dir_der = false;
      dir_par = false;
    } else if (command == 'R') {
      dir_izq = false;
      dir_der = true;
      dir_par = false;
    } else if (command == 'P') {
      dir_izq = false;
      dir_der = false;
      dir_par = true;
    }
  }

  // Procesar la señal de la direccional izquierda
  if (dir_izq) {
    toggleLeds({led3, led6, led10});
    toggleLeds({led2, led5, led9});
    toggleLeds({led1, led4, led8});
  }

  // Procesar la señal de la direccional derecha
  if (dir_der) {
    toggleLeds({led1, led5, led8});
    toggleLeds({led2, led6, led9});
    toggleLeds({led3, led7, led10});
  }

  // Procesar la señal de parqueo
  if (dir_par) {
    toggleAllLeds();
  }
}

void toggleLeds(std::initializer_list<int> leds) {
  for (int led : leds) {
    digitalWrite(led, HIGH);
  }
  delay(tiempo);
  for (int led : leds) {
    digitalWrite(led, LOW);
  }
  delay(tiempo);
}

void toggleAllLeds() {
  for (int i = 2; i <= 11; i++) {
    digitalWrite(i, HIGH);
  }
  delay(tiempo);
  for (int i = 2; i <= 11; i++) {
    digitalWrite(i, LOW);
  }
  delay(tiempo);
}

• Control mediante Bluetooth: Los caracteres 'L' (izquierda), 'R' (derecha), y 'P' (parqueo) se reciben a través del módulo Bluetooth y controlan los LEDs conforme a ellos.
• Eliminación de pulsadores: Todos los elementos relacionados con los pulsadores han sido eliminados del código para que la operación se base completamente en los comandos recibidos vía Bluetooth.

// Realizar acción según el comando
switch (comando) {
  case 'L': // Señal izquierda
    senalIzquierda();
    break;
  case 'R': // Señal derecha
    senalDerecha();
    break;
  case 'P': // Señal de parqueo
    senalParqueo();
    break;
  case 'O': // Apagar todas las luces
    apagarLuces();
    break;
  default:
    // Comando desconocido
    break;
}

Cpp
// Declaramos los LEDs
int led1 = 2;
int led2 = 3;
int led3 = 4;
int led4 = 5;
int led5 = 6;
int led6 = 7;
int led7 = 8;
int led8 = 9;
int led9 = 10;
int led10 = 11;

// Declaramos el estado de las señales
char comando; // Variable para almacenar el comando recibido por Bluetooth
int tiempo = 200;

void setup() {
  // Configurar los pines de los LEDs como salida
  for (int i = led1; i <= led10; i++) {
    pinMode(i, OUTPUT);
  }

  // Inicializamos la comunicación serial para el HC-06
  Serial.begin(9600);
}

void loop() {
  // Verificamos si hay datos disponibles en el Bluetooth
  if (Serial.available() > 0) {
    comando = Serial.read(); // Leer el comando recibido

    // Realizar acción según el comando
    switch (comando) {
      case 'L': 
        senalIzquierda();
        break;
      case 'R': 
        senalDerecha();
        break;
      case 'P': 
        senalParqueo();
        break;
      case 'O': // Apagar todas las luces
        apagarLuces();
        break;
      default:
        // Comando desconocido
        break;
    }
  }
}

void senalIzquierda() {
  digitalWrite(led3, HIGH);
  digitalWrite(led6, HIGH);
  digitalWrite(led10, HIGH);
  delay(tiempo);
  digitalWrite(led3, LOW);
  digitalWrite(led6, LOW);
  digitalWrite(led10, LOW);
  delay(tiempo);
  digitalWrite(led2, HIGH);
  digitalWrite(led5, HIGH);
  digitalWrite(led9, HIGH);
  delay(tiempo);
  digitalWrite(led2, LOW);
  digitalWrite(led5, LOW);
  digitalWrite(led9, LOW);
  delay(tiempo);
  digitalWrite(led1, HIGH);
  digitalWrite(led4, HIGH);
  digitalWrite(led8, HIGH);
  delay(tiempo);
  digitalWrite(led1, LOW);
  digitalWrite(led4, LOW);
  digitalWrite(led8, LOW);
}

void senalDerecha() {
  digitalWrite(led1, HIGH);
  digitalWrite(led5, HIGH);
  digitalWrite(led8, HIGH);
  delay(tiempo);
  digitalWrite(led1, LOW);
  digitalWrite(led5, LOW);
  digitalWrite(led8, LOW);
  delay(tiempo);
  digitalWrite(led2, HIGH);
  digitalWrite(led6, HIGH);
  digitalWrite(led9, HIGH);
  delay(tiempo);
  digitalWrite(led2, LOW);
  digitalWrite(led6, LOW);
  digitalWrite(led9, LOW);
  delay(tiempo);
  digitalWrite(led3, HIGH);
  digitalWrite(led7, HIGH);
  digitalWrite(led10, HIGH);
  delay(tiempo);
  digitalWrite(led3, LOW);
  digitalWrite(led7, LOW);
  digitalWrite(led10, LOW);
}

void senalParqueo() {
  for (int i = led1; i <= led10; i++) {
    digitalWrite(i, HIGH);
  }
  delay(tiempo);
  for (int i = led1; i <= led10; i++) {
    digitalWrite(i, LOW);
  }
  delay(tiempo);
}

void apagarLuces() {
  for (int i = led1; i <= led10; i++) {
    digitalWrite(i, LOW);
  }
}

• Configuración inicial: Los pines se configuran como salidas mediante un bucle for, lo cual es más compacto.
• Recepción de comandos: La comunicación serial se utiliza para recibir comandos específicos ('L', 'R', 'P', 'O').
• Funciones dedicadas: Las funciones senalIzquierda, senalDerecha, senalParqueo y apagarLuces manejan las acciones correspondientes.

• Arduino Mega
• 6 LEDs (2 para cada direccional y 2 para freno)
• 6 resistencias (220 ohmios para limitar la corriente de los LEDs)
• 3 botones pulsadores
• 3 resistencias pull-down (10k ohmios para los botones)
• Cables de conexión
• Protoboard

1. Direccionales Izquierda:
   • LEDs conectados a pines digitales 8 y 9.
   • Botón conectado al pin digital 2.
2. Direccionales Derecha:
   • LEDs conectados a pines digitales 10 y 11.
   • Botón conectado al pin digital 3.
3. Luces de Freno:
   • LEDs conectados a pines digitales 12 y 13.
   • Botón conectado al pin digital 4.

• Cada LED necesita estar en serie con una resistencia de 220 ohmios, con el cátodo del LED conectado a GND.
• Cada botón de entrada necesita conectarse a GND a través de una resistencia de 10k ohmios (resistencia pull-down).

Cpp
// Pines para los LEDs
int ledsIzq[] = {8, 9};
int ledsDer[] = {10, 11};
int ledsFreno[] = {12, 13};

// Pines para los botones
int botonIzq = 2;
int botonDer = 3;
int botonFreno = 4;

// Tiempo de retardo para la secuencia
int tiempo = 200;

void setup() {
  // Configuración de pines para LEDs como salida
  for (int i = 0; i < 2; i++) {
    pinMode(ledsIzq[i], OUTPUT);
    pinMode(ledsDer[i], OUTPUT);
    pinMode(ledsFreno[i], OUTPUT);
  }

  // Configuración de pines para botones como entrada
  pinMode(botonIzq, INPUT);
  pinMode(botonDer, INPUT);
  pinMode(botonFreno, INPUT);
}

void loop() {
  // Leer el estado de los botones
  bool estadoIzq = digitalRead(botonIzq);
  bool estadoDer = digitalRead(botonDer);
  bool estadoFreno = digitalRead(botonFreno);

  // Secuencia de intermitentes izquierda
  if (estadoIzq) {
    for (int i = 0; i < 2; i++) {
      digitalWrite(ledsIzq[i], HIGH);
      delay(tiempo);
      digitalWrite(ledsIzq[i], LOW);
    }
  }

  // Secuencia de intermitentes derecha
  if (estadoDer) {
    for (int i = 0; i < 2; i++) {
      digitalWrite(ledsDer[i], HIGH);
      delay(tiempo);
      digitalWrite(ledsDer[i], LOW);
    }
  }

  // Luz de freno encendida
  if (estadoFreno) {
    for (int i = 0; i < 2; i++) {
      digitalWrite(ledsFreno[i], HIGH);
    }
  } else {
    for (int i = 0; i < 2; i++) {
      digitalWrite(ledsFreno[i], LOW);
    }
  }
}

• Intermitentes: Los LEDs parpadean en secuencia cuando se presionan los botones correspondientes a las direccionales izquierda o derecha.
• Luces de Freno: Se encienden continuamente cuando se presiona el botón de freno.

graph TD;
    subgraph Arduino_Mega
        BotonIzq([Botón Izquierda]) -->|D2| D2[MEGA_Pin_2]
        BotonDer([Botón Derecha]) -->|D3| D3[MEGA_Pin_3]
        BotonFreno([Botón Freno]) -->|D4| D4[MEGA_Pin_4]
        D8[MEGA_Pin_8] -->|LED_Izq| LedIzq1[LED_Izquierda_1]
        D9[MEGA_Pin_9] -->|LED_Izq| LedIzq2[LED_Izquierda_2]
        D10[MEGA_Pin_10] -->|LED_Der| LedDer1[LED_Derecha_1]
        D11[MEGA_Pin_11] -->|LED_Der| LedDer2[LED_Derecha_2]
        D12[MEGA_Pin_12] -->|LED_Freno| LedFreno1[LED_Freno_1]
        D13[MEGA_Pin_13] -->|LED_Freno| LedFreno2[LED_Freno_2]
        VCC$5V$ -.-> BotonVCC1[Botón VCC]
        VCC$5V$ -.-> BotonVCC2[Botón VCC]
        VCC$5V$ -.-> BotonVCC3[Botón VCC]
        GND --o BotonGND1[Botón GND]
        GND --o BotonGND2[Botón GND]
        GND --o BotonGND3[Botón GND]
    end

    subgraph Botones
        BotonIzq -->|Resistencia node_10k| BotonGND1
        BotonDer -->|Resistencia node_10k| BotonGND2
        BotonFreno -->|Resistencia node_10k| BotonGND3
    end

    subgraph LEDs
        LedIzq1 -->|Resistencia 220Ω| GND1$GND$
        LedIzq2 -->|Resistencia 220Ω| GND2$GND$
        LedDer1 -->|Resistencia 220Ω| GND3$GND$
        LedDer2 -->|Resistencia 220Ω| GND4$GND$
        LedFreno1 -->|Resistencia 220Ω| GND5$GND$
        LedFreno2 -->|Resistencia 220Ω| GND6$GND$
    end

• Arduino Mega: Tiene las conexiones de los botones a los pines 2, 3 y 4, y las conexiones de los LEDs a los pines 8, 9, 10, 11, 12, y 13.
• Botones: Cada botón está conectado a GND a través de una resistencia de 10kΩ (resistencia pull-down) para leer su estado.
• LEDs: Cada LED está conectado a través de una resistencia de 220Ω a GND y controlado por un pin digital del Arduino.

Cpp
// Configuración de pines para el movimiento del carro
#define IN1 5
#define IN2 6
#define IN3 9
#define IN4 10

// Configuración de pines para los LEDs
const int ledsIzq[] = {22, 23, 24, 25, 26, 27};  // Cambié los números de pins para no interferir con IN1-IN4
const int ledsDer[] = {28, 29, 30, 31, 32, 33};
const int ledsFreno[] = {34, 35, 36, 37};

void setup() {
  // Configuración de pines de salida para movimiento
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);

  // Configuración de pines de salida para LEDs
  for (int i = 0; i < 6; i++) {
    pinMode(ledsIzq[i], OUTPUT);
    pinMode(ledsDer[i], OUTPUT);
  }
  for (int i = 0; i < 4; i++) {
    pinMode(ledsFreno[i], OUTPUT);
  }

  Serial.begin(9600); // Velocidad del módulo Bluetooth
}

void loop() {
  if (Serial.available()) {
    char command = Serial.read();

    switch (command) {
      // Movimiento del carro
      case 'U': // Adelante
        digitalWrite(IN1, HIGH);
        digitalWrite(IN2, LOW);
        digitalWrite(IN3, HIGH);
        digitalWrite(IN4, LOW);
        apagarFreno();
        break;
        
      case 'D': // Atrás
        digitalWrite(IN1, LOW);
        digitalWrite(IN2, HIGH);
        digitalWrite(IN3, LOW);
        digitalWrite(IN4, HIGH);
        apagarFreno();
        break;
        
      case 'L': // Izquierda
        digitalWrite(IN1, LOW);
        digitalWrite(IN2, LOW);
        digitalWrite(IN3, HIGH);
        digitalWrite(IN4, LOW);
        apagarFreno();
        break;
        
      case 'R': // Derecha
        digitalWrite(IN1, HIGH);
        digitalWrite(IN2, LOW);
        digitalWrite(IN3, LOW);
        digitalWrite(IN4, LOW);
        apagarFreno();
        break;
        
      case 'Y': // Stop y enciende luces de freno
        digitalWrite(IN1, LOW);
        digitalWrite(IN2, LOW);
        digitalWrite(IN3, LOW);
        digitalWrite(IN4, LOW);
        encenderFreno();
        break;
        
      // Lógica de LEDs
      case 'A': // Intermitentes izquierda
        secuenciaIntermitente(ledsIzq, 6);
        break;
        
      case 'O': // Intermitentes derecha
        secuenciaIntermitente(ledsDer, 6);
        break;
    }
  }
}

void secuenciaIntermitente(const int leds[], int cantidad) {
  for (int i = 0; i < cantidad; i++) {
    digitalWrite(leds[i], HIGH);
    delay(50);
  }
  delay(200);
  for (int i = 0; i < cantidad; i++) {
    digitalWrite(leds[i], LOW);
    delay(50);
  }
}

void encenderFreno() {
  for (int i = 0; i < 4; i++) {
    digitalWrite(ledsFreno[i], HIGH); // Activa las luces de freno
  }
}

void apagarFreno() {
  for (int i = 0; i < 4; i++) {
    digitalWrite(ledsFreno[i], LOW); // Apaga las luces de freno
  }
}

• Pins de LEDs: Asegúrate de que los pines usados para los LEDs (22-37 en este código) no interfieran con los pines IN1-IN4 para la movilidad.
• Comandos adicionales: 'A' para intermitentes izquierda y 'O' para intermitentes derecha añaden capacidad de control a través del Bluetooth.
• Luces de freno: Se encienden al recibir el comando 'Y', permaneciendo encendidas hasta que se reciba un nuevo comando de movimiento.

  checkAlerts(distance);
  i++;  // Incrementar solo si el objeto está lejos
  stopped = false;
} else {
  if (!stopped) {
    Serial.println("Movimiento detenido, objeto cerca.");
    stopped = true;
  }
  checkAlerts(distance); // Mantener alerta activada
}
delay(20);

if (distance > 10) {
  myServo.write(i);
  Serial.print(i);
  Serial.print(",");
  Serial.print(distance);
  Serial.print(".");
  
  checkAlerts(distance);
  i--;  // Decrementar solo si el objeto está lejos
  stopped = false;
} else {
  if (!stopped) {
    Serial.println("Movimiento detenido, objeto cerca.");
    stopped = true;
  }
  checkAlerts(distance); // Mantener alerta activada
}
delay(20);

• Mantendremos los pines del primer código tal como están.
• Cambiaremos los pines usados en el segundo código, asegurándonos de no usar los pines 5-13 y 22-37.

Cpp
#include <Servo.h>
#include <LiquidCrystal.h>

// Configuración de pines para el movimiento del carro
#define IN1 5
#define IN2 6
#define IN3 9
#define IN4 10

// Configuración de pines para los LEDs
const int ledsIzq[] = {22, 23, 24, 25, 26, 27};
const int ledsDer[] = {28, 29, 30, 31, 32, 33};
const int ledsFreno[] = {34, 35, 36, 37};

// Definición de pines para el LCD
LiquidCrystal lcd(38, 39, 40, 41, 42, 43); // Cambié los números de pines para el LCD

// Definición de pines para el sensor HC-SR04
const int trigPin = 44;
const int echoPin = 45;

// Pines adicionales
const int led1 = 46;  // LED de alerta
const int led2 = 47;  // LED de objeto fuera de rango
const int buzzer = 48; // Buzzer para alerta sonora

long duration;
int distance;
Servo myServo; // Objeto servo

void setup() {
  // Configuración de pines de salida para movimiento
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);

  // Configuración de pines de salida para LEDs
  for (int i = 0; i < 6; i++) {
    pinMode(ledsIzq[i], OUTPUT);
    pinMode(ledsDer[i], OUTPUT);
  }
  
  for (int i = 0; i < 4; i++) {
    pinMode(ledsFreno[i], OUTPUT);
  }

  // Configuración de pines de Ultrasonido y otros
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(buzzer, OUTPUT);
  
  Serial.begin(9600);
  myServo.attach(49);

  // Configuración del LCD
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("BIENVENIDOS");
  lcd.setCursor(0, 1);
  lcd.print("UNIVDEP PRESENTE");
  delay(2000);
  lcd.clear();
}

void loop() {
  // Lógica del primer código (Movimientos y LEDs)
  if (Serial.available()) {
    char command = Serial.read();
    switch (command) {
      // Movimiento del carro
      case 'U': // Adelante
        digitalWrite(IN1, HIGH);
        digitalWrite(IN2, LOW);
        digitalWrite(IN3, HIGH);
        digitalWrite(IN4, LOW);
        apagarFreno();
        break;
        
      case 'D': // Atrás
        digitalWrite(IN1, LOW);
        digitalWrite(IN2, HIGH);
        digitalWrite(IN3, LOW);
        digitalWrite(IN4, HIGH);
        apagarFreno();
        break;
        
      case 'L': // Izquierda
        digitalWrite(IN1, LOW);
        digitalWrite(IN2, LOW);
        digitalWrite(IN3, HIGH);
        digitalWrite(IN4, LOW);
        apagarFreno();
        break;
        
      case 'R': // Derecha
        digitalWrite(IN1, HIGH);
        digitalWrite(IN2, LOW);
        digitalWrite(IN3, LOW);
        digitalWrite(IN4, LOW);
        apagarFreno();
        break;
        
      case 'Y': // Stop y enciende luces de freno
        digitalWrite(IN1, LOW);
        digitalWrite(IN2, LOW);
        digitalWrite(IN3, LOW);
        digitalWrite(IN4, LOW);
        encenderFreno();
        break;
        
      // Lógica de LEDs
      case 'A': // Intermitentes izquierda
        secuenciaIntermitente(ledsIzq, 6);
        break;
        
      case 'O': // Intermitentes derecha
        secuenciaIntermitente(ledsDer, 6);
        break;
    }
  }

  // Lógica del segundo código (Ultrasonido, Servo, LCD)
  int i = 0;
  bool stopped = false;

  // Rotar el servo de 0 a 180 grados y medir distancia
  while (i <= 180) {
    distance = calculateDistance();
    displayDistanceOnLCD(distance); // Siempre mostrar la distancia

    if (distance > 10) {
      myServo.write(i);
      Serial.print(i);
      Serial.print(",");
      Serial.print(distance);
      Serial.print(".");
      
      checkAlerts(distance);
      i++;  // Incrementar solo si el objeto está lejos
      stopped = false;
    } else {
      if (!stopped) {
        Serial.println("Movimiento detenido, objeto cerca.");
        stopped = true;
      }
      checkAlerts(distance); // Mantener alerta activada
    }
    delay(20);
  }

  i = 180;
  
  // Rotar el servo de 180 a 0 grados y medir distancia
  while (i >= 0) {
    distance = calculateDistance();
    displayDistanceOnLCD(distance); // Siempre mostrar la distancia

    if (distance > 10) {
      myServo.write(i);
      Serial.print(i);
      Serial.print(",");
      Serial.print(distance);
      Serial.print(".");
      
      checkAlerts(distance);
      i--;  // Decrementar solo si el objeto está lejos
      stopped = false;
    } else {
      if (!stopped) {
        Serial.println("Movimiento detenido, objeto cerca.");
        stopped = true;
      }
      checkAlerts(distance); // Mantener alerta activada
    }
    delay(20);
  }
}

// Funciones del primer código
void secuenciaIntermitente(const int leds[], int cantidad) {
  for (int i = 0; i < cantidad; i++) {
    digitalWrite(leds[i], HIGH);
    delay(50);
  }
  delay(200);
  for (int i = 0; i < cantidad; i++) {
    digitalWrite(leds[i], LOW);
    delay(50);
  }
}

void encenderFreno() {
  for (int i = 0; i < 4; i++) {
    digitalWrite(ledsFreno[i], HIGH); // Activa las luces de freno
  }
}

void apagarFreno() {
  for (int i = 0; i < 4; i++) {
    digitalWrite(ledsFreno[i], LOW); // Apaga las luces de freno
  }
}

// Funciones del segundo código
int calculateDistance() { 
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  duration = pulseIn(echoPin, HIGH);
  distance = duration * 0.034 / 2;

  return distance;
}

void displayDistanceOnLCD(int distance) {
  lcd.setCursor(0, 0);
  lcd.print("Distancia: ");
  lcd.print(distance);
  lcd.print(" cm ");

  lcd.setCursor(0, 1);
  if (distance <= 10 && distance > 0) {
    lcd.print("OBJETO MUY CERCA ");
  } else if (distance > 10 && distance <= 500) {
    lcd.print("                 ");
  } else {
    lcd.print("FUERA DE RANGO   ");
  }
}

void checkAlerts(int distance) {
  if (distance > 0 && distance <= 10) {
    digitalWrite(led1, HIGH);  // Activar LED de alerta
    digitalWrite(buzzer, HIGH); // Activar buzzer
    digitalWrite(led2, LOW);   // Apagar LED de fuera de rango
  } else {
    digitalWrite(led1, LOW);   // Apagar LED de alerta
    digitalWrite(buzzer, LOW); // Apagar buzzer
    digitalWrite(led2, HIGH);  // Encender LED de fuera de rango
  }
}

• Definición de Pines: Los pines para el LCD, el sensor HC-SR04, los LEDs adicionales y el buzzer fueron reasignados para evitar conflictos.
• Separación de Lógica: La lógica de movimiento del carro y de los LEDs se mantiene independiente de la lógica del sensor y la pantalla LCD, combinando ambas funcionalidades en el loop().