1. Código para cada Arduino Esclavo (por nivel):
   Este ejemplo asume que tienes 4 sensores de entrada (pines configurados digitalmente) y una matriz RGB de 10x10 controlada con una librería (por ejemplo, la Adafruit_NeoMatrix) para mostrar la cantidad de lugares disponibles. Además, el Arduino utiliza el módulo RS485 mediante el puerto Serial para comunicar el estado (número de lugares disponibles) al maestro.
2. Código para el Arduino Maestro:
   El maestro recibe mensajes de cada uno de los 7 niveles por RS485, almacena la cantidad de plazas disponibles y actualiza 7 matrices RGB (cada una correspondiente a un nivel) para visualizar la información.
   
   A continuación, se muestran los ejemplos de código:

Cpp
#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

#define SENSOR_ENTRADA1 2
#define SENSOR_SALIDA1 3
#define SENSOR_ENTRADA2 4
#define SENSOR_SALIDA2 5

// Configuración de la matriz RGB 10x10 (parámetros de ejemplo)
// Ajusta los pines y los parámetros según el hardware específico.
#define PIN_MATRIZ 6
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(10, 10, PIN_MATRIZ,
  NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
  NEO_GRB + NEO_KHZ800);

const int CAPACIDAD = 95;
int lugaresDisponibles = CAPACIDAD;

// Variables para detección de cambios (para debouncing básico)
bool estadoAntSensorEnt1 = LOW;
bool estadoAntSensorEnt2 = LOW;
bool estadoAntSensorSal1 = LOW;
bool estadoAntSensorSal2 = LOW;

// Intervalo para enviar datos al maestro (por RS485)
unsigned long tiempoEnvio = 0;
const unsigned long intervaloEnvio = 1000; // cada 1 seg.

void setup() {
  Serial.begin(9600); // RS485 se comunica por Serial; asegúrate de controlar el DE/RE si es necesario.

  pinMode(SENSOR_ENTRADA1, INPUT);
  pinMode(SENSOR_SALIDA1, INPUT);
  pinMode(SENSOR_ENTRADA2, INPUT);
  pinMode(SENSOR_SALIDA2, INPUT);

  matrix.begin();
  matrix.setTextWrap(false);
  matrix.setBrightness(40);
  actualizarDisplay();
}

void loop() {
  // Leer estados de los sensores
  bool sensorEnt1 = digitalRead(SENSOR_ENTRADA1);
  bool sensorEnt2 = digitalRead(SENSOR_ENTRADA2);
  bool sensorSal1 = digitalRead(SENSOR_SALIDA1);
  bool sensorSal2 = digitalRead(SENSOR_SALIDA2);

  // Si detecta un flanco de subida en entrada (vehículo entra)
  if (sensorEnt1 && !estadoAntSensorEnt1) {
    if (lugaresDisponibles > 0) {
      lugaresDisponibles--;
      actualizarDisplay();
    }
  }
  if (sensorEnt2 && !estadoAntSensorEnt2) {
    if (lugaresDisponibles > 0) {
      lugaresDisponibles--;
      actualizarDisplay();
    }
  }
  // Si detecta un flanco de subida en salida (vehículo sale)
  if (sensorSal1 && !estadoAntSensorSal1) {
    if (lugaresDisponibles < CAPACIDAD) {
      lugaresDisponibles++;
      actualizarDisplay();
    }
  }
  if (sensorSal2 && !estadoAntSensorSal2) {
    if (lugaresDisponibles < CAPACIDAD) {
      lugaresDisponibles++;
      actualizarDisplay();
    }
  }

  // Actualizar estados anteriores para debouncing
  estadoAntSensorEnt1 = sensorEnt1;
  estadoAntSensorEnt2 = sensorEnt2;
  estadoAntSensorSal1 = sensorSal1;
  estadoAntSensorSal2 = sensorSal2;

  // Enviar el dato actualizado al maestro cada intervaloEnvio
  if (millis() - tiempoEnvio >= intervaloEnvio) {
    enviarDatos();
    tiempoEnvio = millis();
  }
}

void actualizarDisplay() {
  matrix.fillScreen(0);

  // Si no hay lugares disponibles, mostrar "0" en rojo
  if (lugaresDisponibles == 0) {
    matrix.setTextColor(matrix.Color(255, 0, 0)); // Rojo
  } else {
    matrix.setTextColor(matrix.Color(0, 255, 0)); // Verde por ejemplo
  }
  matrix.setCursor(0, 0);
  matrix.print(lugaresDisponibles);
  matrix.show();
}

void enviarDatos() {
  // Enviar mensaje en formato: "L#;C#" donde # representa nivel (definido de forma fija o configurada por jumper) y cantidad
  // Por ejemplo, si este esclavo es del nivel 3 y tiene 87 lugares disponibles: "L3;C87"
  int nivel = 0;  // Modifica este valor para cada Arduino esclavo, de modo que cada uno conozca su nivel
  Serial.print("L");
  Serial.print(nivel);
  Serial.print(";C");
  Serial.println(lugaresDisponibles);
}

Cpp
#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

// Configuración para 7 matrices RGB (10x10)
// Supongamos que cada matriz se conecta a un pin diferente. Ajusta según tu hardware.
const int numNiveles = 7;
const int pinesMatrices[numNiveles] = {7, 8, 9, 10, 11, 12, 13};
Adafruit_NeoMatrix matrices[numNiveles] = {
  Adafruit_NeoMatrix(10, 10, pinesMatrices[0],
    NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
    NEO_GRB + NEO_KHZ800),
  Adafruit_NeoMatrix(10, 10, pinesMatrices[1],
    NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
    NEO_GRB + NEO_KHZ800),
  Adafruit_NeoMatrix(10, 10, pinesMatrices[2],
    NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
    NEO_GRB + NEO_KHZ800),
  Adafruit_NeoMatrix(10, 10, pinesMatrices[3],
    NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
    NEO_GRB + NEO_KHZ800),
  Adafruit_NeoMatrix(10, 10, pinesMatrices[4],
    NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
    NEO_GRB + NEO_KHZ800),
  Adafruit_NeoMatrix(10, 10, pinesMatrices[5],
    NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
    NEO_GRB + NEO_KHZ800),
  Adafruit_NeoMatrix(10, 10, pinesMatrices[6],
    NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
    NEO_GRB + NEO_KHZ800)
};

// Arreglo para almacenar la cantidad de lugares disponibles por nivel
int lugaresPorNivel[numNiveles] = {95, 95, 95, 95, 95, 95, 95};

void setup() {
  Serial.begin(9600);  // RS485: el mismo bus compartido con los esclavos

  for (int i = 0; i < numNiveles; i++) {
    matrices[i].begin();
    matrices[i].setTextWrap(false);
    matrices[i].setBrightness(40);
    actualizarDisplay(i);
  }
}

void loop() {
  // Si hay datos disponibles en el bus RS485, procesarlos
  while (Serial.available() > 0) {
    String mensaje = Serial.readStringUntil('\n');
    procesarMensaje(mensaje);
  }
  
  // Actualizar display maestro (opcional: cada cierto tiempo se refrescan las matrices)
  for (int i = 0; i < numNiveles; i++){
    actualizarDisplay(i);
  }
  delay(200);
}

void procesarMensaje(String msg) {
  // Se espera un formato: "L#;C#" 
  // Ejemplo: "L3;C87" indica nivel 3 con 87 lugares disponibles.
  int posL = msg.indexOf('L');
  int posSemicolon = msg.indexOf(';');
  int posC = msg.indexOf('C');
  
  if (posL != -1 && posSemicolon != -1 && posC != -1) {
    String nivelStr = msg.substring(posL + 1, posSemicolon);
    int nivel = nivelStr.toInt();
    String cuentaStr = msg.substring(posC + 1);
    int cuenta = cuentaStr.toInt();
    
    if (nivel >= 0 && nivel < numNiveles) {
      lugaresPorNivel[nivel] = cuenta;
    }
  }
}

void actualizarDisplay(int indice) {
  // Actualiza la matriz correspondiente según la cantidad de lugares disponibles.
  matrices[indice].fillScreen(0);
  if (lugaresPorNivel[indice] == 0) {
    matrices[indice].setTextColor(matrices[indice].Color(255, 0, 0));  // Rojo si completo
  } else {
    matrices[indice].setTextColor(matrices[indice].Color(0, 255, 0));  // Verde si hay disponibilidad
  }
  matrices[indice].setCursor(0, 0);
  matrices[indice].print(lugaresPorNivel[indice]);
  matrices[indice].show();
}

• RS485 y Control de DE/RE:
  Si usas módulos RS485, es probable que debas controlar (activar/desactivar) los pines DE y RE para cambiar entre transmisión y recepción. En estos ejemplos se usa el puerto Serial de forma básica. De ser necesario, incorpora la lógica correspondiente (por ejemplo, definiendo un pin para DE/RE y poniéndolo en HIGH/LOW según corresponda).
• Detección de flancos:
  El código utiliza un método sencillo para detectar cambios de estado (de LOW a HIGH) en los sensores. Para aplicaciones reales considera usar interrupciones o algoritmos de debouncing más robustos.
• Biblioteca de la matriz RGB:
  Asegúrate de instalar y configurar correctamente la Adafruit_NeoMatrix y la Adafruit_NeoPixel o la librería equivalente que estés utilizando.
• Asignación del número de nivel (en el esclavo):
  Modifica la variable nivel en el sketch del esclavo para que cada placa tenga asignado el nivel correcto (0 a 6 en este ejemplo).