Importante:

• Estos ejemplos son ilustrativos y deberán adaptarse al hardware real (pines, alimentación y conexiones de RS485).
• La librería y función de dibujo (por ejemplo, para escribir texto) deben adecuarse a la pantalla de 62×32.
• En el proyecto maestro, se asume que cada uno de los 7 paneles (con 62×32) está conectado de forma independiente (por ejemplo, usando salidas habilitadas o multiplexación) para formar el totem de visualización vertical.

• Lee cuatro sensores infrarrojos (dos para entrada, dos para salida).
• Calcula la cantidad de espacios ocupados (a partir de 95 espacios totales).
• Actualiza la matriz LED 62×32 para mostrar, por ejemplo, el número de espacios disponibles.
• Envía un mensaje vía RS485 con el número de nivel y la cantidad de espacios disponibles.

Cpp
#include <SoftwareSerial.h>
#include <PxMatrix.h>

// ---------------------------
// Configuración RS485
// ---------------------------
#define RS485_RX_PIN 10
#define RS485_TX_PIN 11
SoftwareSerial rs485Serial(RS485_RX_PIN, RS485_TX_PIN);

// ---------------------------
// Configuración de Sensores
// ---------------------------
const int sensorPins[4] = {2, 3, 4, 5}; // Ajusta según conexión

// ---------------------------
// Variables del sistema
// ---------------------------
const int totalEspacios = 95;
int espaciosOcupados = 0;

// ---------------------------
// Configuración de la Matriz 62x32 RGB
// ---------------------------
// Los parámetros de constructor dependen de tu panel y wiring.
// Este ejemplo usa PxMatrix. Ajusta pines según tu hardware.
#define P_LAT 8
#define P_OE  9
#define P_A  A2
#define P_B  A3
#define P_C  A4
// Para una matriz 62x32, deberás definir el ancho y alto adecuados.
PxMatrix display(62, 32, P_LAT, P_OE, P_A, P_B, P_C);

void setup() {
  // Iniciar RS485 a 9600 baudios
  rs485Serial.begin(9600);
  
  // Configurar pines de sensores como entrada
  for (int i = 0; i < 4; i++) {
    pinMode(sensorPins[i], INPUT);
  }
  
  // Inicialización de la matriz 62x32  
  display.begin(16); // El valor del bus clock depende de tu hardware
  display.clearDisplay();
  display.swapBuffers(false);
  
  // Comunicación Serial para debugging
  Serial.begin(9600);
}

void loop() {
  // Lógica simple para incrementar o decrementar espacios ocupados
  // (Implementar debounce y lógica robusta según sea necesario)
  if(digitalRead(sensorPins[0]) == HIGH || digitalRead(sensorPins[2]) == HIGH) {
    if (espaciosOcupados < totalEspacios) {
      espaciosOcupados++;
      delay(300);
    }
  }
  if(digitalRead(sensorPins[1]) == HIGH || digitalRead(sensorPins[3]) == HIGH) {
    if (espaciosOcupados > 0) {
      espaciosOcupados--;
      delay(300);
    }
  }
  
  int disponibles = totalEspacios - espaciosOcupados;
  
  // Actualizar la matriz 62x32: mostrar texto con la cantidad de espacios disponibles
  display.clearDisplay();
  // Se asume que existe una función para dibujar texto; por ejemplo:
  display.drawString(0, 10, "Disp: " + String(disponibles));
  display.showBuffer();
  
  // Enviar datos al maestro vía RS485 con formato: <Nivel>:<Disponibles>\n
  int nivel = 1;  // Definir el número de nivel asignado al nodo
  String msg = String(nivel) + ":" + String(disponibles) + "\n";
  rs485Serial.print(msg);
  
  // Debug
  Serial.print("Nivel ");
  Serial.print(nivel);
  Serial.print(" - Espacios disponibles: ");
  Serial.println(disponibles);
  
  delay(500);
}

• Recibe datos vía RS485 de los 7 esclavos.
• Actualiza cada uno de los 7 paneles LED (cada uno de 62×32) para mostrar, en forma vertical, la disponibilidad de cada nivel.
• Se ilustra el uso de colores: si el nivel está lleno (disponibles = 0), se mostrará el texto en rojo; en otro caso, en verde.

Nota: Este ejemplo asume que cuentas con la forma de direccionar cada panel (por ejemplo, asignando pines de habilitación o usando instancias distintas de PxMatrix). Los detalles de multiplexación o la conexión en cadena dependerán de tu hardware real.

Cpp
#include <SoftwareSerial.h>
#include <PxMatrix.h>

// ---------------------------
// Configuración RS485
// ---------------------------
#define RS485_RX_PIN 10
#define RS485_TX_PIN 11
SoftwareSerial rs485Serial(RS485_RX_PIN, RS485_TX_PIN);

// ---------------------------
// Configuración de 7 matrices 62x32
// ---------------------------
// Supongamos que cada panel se conecta a pines diferentes o cuenta con una línea de habilitación.
// Aquí se crean 7 instancias; ajusta los parámetros y pines para cada panel según tu cableado.
#define PANEL_WIDTH 62
#define PANEL_HEIGHT 32

// Ejemplo de pines para el primer panel; los siguientes deberán tener pines dedicados
PxMatrix panel1(PANEL_WIDTH, PANEL_HEIGHT, /*P_LAT=*/8, /*P_OE=*/9, /*P_A=*/A2, /*P_B=*/A3, /*P_C=*/A4);
PxMatrix panel2(PANEL_WIDTH, PANEL_HEIGHT, /*P_LAT=*/10, /*P_OE=*/11, /*P_A=*/A5, /*P_B=*/A6, /*P_C=*/A7);
PxMatrix panel3(PANEL_WIDTH, PANEL_HEIGHT, /*Configurar pines*/);
PxMatrix panel4(PANEL_WIDTH, PANEL_HEIGHT, /*Configurar pines*/);
PxMatrix panel5(PANEL_WIDTH, PANEL_HEIGHT, /*Configurar pines*/);
PxMatrix panel6(PANEL_WIDTH, PANEL_HEIGHT, /*Configurar pines*/);
PxMatrix panel7(PANEL_WIDTH, PANEL_HEIGHT, /*Configurar pines*/);

// Arreglo de punteros para facilidad al actualizar
PxMatrix* panels[7] = { &panel1, &panel2, &panel3, &panel4, &panel5, &panel6, &panel7 };

// Estado de cada nivel, inicialmente 95 espacios disponibles.
int nivelDisponibles[7] = {95, 95, 95, 95, 95, 95, 95};

void setup() {
  rs485Serial.begin(9600);
  Serial.begin(9600);
  
  // Inicializar cada panel
  for (int i = 0; i < 7; i++) {
    panels[i]->begin(16);  // Ajusta el parámetro del bus clock según hardware
    panels[i]->clearDisplay();
    panels[i]->swapBuffers(false);
  }
}

void loop() {
  // Recepción de datos vía RS485
  if (rs485Serial.available()) {
    String data = rs485Serial.readStringUntil('\n');
    // El formato esperado es "nivel:disponibles"
    int sep = data.indexOf(':');
    if (sep > 0) {
      int nivel = data.substring(0, sep).toInt();
      int disponibles = data.substring(sep + 1).toInt();
      if (nivel >= 1 && nivel <= 7) {
        nivelDisponibles[nivel - 1] = disponibles;
        Serial.print("Nivel ");
        Serial.print(nivel);
        Serial.print(" actualizado, disponibles: ");
        Serial.println(disponibles);
      }
    }
  }
  
  // Actualizar cada panel con su texto respectivo.
  // Se muestra el número de espacios disponibles.  
  // El color se determina (ej. rojo si 0, verde en otro caso).
  for (int i = 0; i < 7; i++) {
    panels[i]->clearDisplay();
    String txt = "Disp: " + String(nivelDisponibles[i]);
    // Ejemplo: si disponibles==0, se usa color rojo. La función drawStringColor es ilustrativa:
    uint16_t color = (nivelDisponibles[i] == 0) ? display.Color333(7,0,0) : display.Color333(0,7,0);
    // La función para dibujar texto y colorear dependerá de la librería PxMatrix.
    panels[i]->drawString(0, 10, txt, color);
    panels[i]->showBuffer();
  }
  
  delay(300);
}

• Librería y Funciones:
  La manera de inicializar y escribir en los paneles depende de la versión de la librería que uses. Consulta la documentación de PxMatrix o la que hayas elegido para ajustar funciones como begin(), drawString(), y el manejo de colores.
• Configuración RS485:
  Revisa que los pines de DE/RE estén definidos y controlados según el módulo RS485 que utilices.
• Multiplexación y Control:
  Si los 7 paneles comparten algunas líneas de datos o se conectan en cadena, deberás ajustar la lógica para actualizar cada uno de forma individual o secuencial.