Ricevitore IR replicato

Salve a tutti, sono Luca. Da poco mi sono avvicinato ad Arduino ed ho disperato aiuto da parte vostra.
Ho realizzato un ricevitore IR con un TSOP 4840, perfettamente funzionante (sketch già fatto), che quando colpito in pieno accende un led rosso, quando colpito di striscio accende un led verde.
Il problema che ho ora è che vorrei ampliarlo, cioè replicare questi comandi con più ricevitori IR e led corrispondenti utilizzando ovviamente un solo Arduino nano.
Non ho idea di quanto sia complesso il lavoro, mi auguro non sia difficile, purtroppo mi mancano molte parti di conoscenza C e C++ e da solo non riesco ancora ad arrivarci.
Posto lo sketch, magari riuscite a darmi la soluzione se non troppo impegnativa.
Grazie in anticipo

#include <IRremote.h>

#define PIN_TSOP 11
#define PIN_LED_GREEN 10
#define PIN_LED_RED 9

IRrecv irrecv(PIN_TSOP);

void setup() {
  pinMode(PIN_LED_GREEN, OUTPUT);
  pinMode(PIN_LED_RED, OUTPUT);
  
  digitalWrite(PIN_LED_GREEN, LOW);
  digitalWrite(PIN_LED_RED, LOW);
  
  irrecv.enableIRIn();
}

bool getParityBit(uint32_t data, unsigned int len) {
  unsigned int bits1count = 0;

  for (int i=0; i<len; i++)
  {
    if ((data >> i) & 0b1) bits1count++;
  }

  return (bits1count % 2);
}

bool isValidMessage(decode_results res) {
  // Controllo che il formato sia SONY
  if (res.decode_type != SONY)
    return false;
    
  // Estraggo il messaggio composto da 17bit (16 + 1 di parità)
  uint32_t rawMessage = res.value & 0x1ffff;
  
  // Estraggo la parte di messaggio senza il bit di parità (16 bit = 2 bytes)
  uint32_t message = (rawMessage >> 1) & 0xffff;
  
  // Estraggo l'ultimo bit che rappresent+ il bit di parità
  boolean parityBit = rawMessage & 0b1;
  
  // Controllo che il messaggio contenga qualcosa
  if (!message)
    return false;
  
  // Controllo che il bit di parità corrisponda
  if (getParityBit(message, 16) != parityBit)
    return false;
    
  // Tutti i controlli sono OK, il pacchetto è valido
  return true;
}

void loop() {
  decode_results res;
  
  // Decodifico i pacchetti in ingresso
  if (irrecv.decode(&res)) {
    if (isValidMessage(res)) {
      // Messaggio valido: Led verde
      digitalWrite(PIN_LED_GREEN, HIGH);
    } else {
      // Messaggio valido: Led rosso
      digitalWrite(PIN_LED_RED, HIGH);
    }

    delay(1000);

    digitalWrite(PIN_LED_GREEN, LOW);
    digitalWrite(PIN_LED_RED, LOW);
    
    // Via libera al prossimo pacchetto IR
    irrecv.resume();
  }
}

Non ho mai usato più ricevitori contemporaneamente ma credo che tu possa fare qualche prova per verificare se sia possibile, modificando il programma creando più oggetti IRrecv, una cosa del tipo:

#define PIN_TSOP1 11
#define PIN_TSOP2 12

IRrecv irrecv1(PIN_TSOP1);
IRrecv irrecv2(PIN_TSOP2);
...

    irrecv1.resume();
    irrecv2.resume();

...
  byte colpito = 0;
  // Decodifico i pacchetti in ingresso
  if (irrecv1.decode(&res)) {
    if (isValidMessage(res))
      colpito = 1;
  } else {
  if (irrecv2.decode(&res))
    if (isValidMessage(res))
      colpito = 2;
  }

  if (colpito > 0) {
      digitalWrite(PIN_LED_GREEN, HIGH);
    } else {
      digitalWrite(PIN_LED_RED, HIGH);
    }
  }

Ho qualche altra perplessità, ma riguarda più che altro la logica generale del "gioco" (suppongo), per cui non sapendo nulla del "contorno" evito. :slight_smile:
intanto quindi prova a fare quel tipo di modifica e fammi sapere.

PS però una curiosità, tu nel codice verifichi se il segnale ricevuto è stato decodificato e riconosciuto come SONY ma perché poi lo elabori quasi come un RAW, andando a leggerti i 16 bit più la parità, considerando ricevuto quando la parità è corretta o "di striscio" (?) quando è errata?
Non ti basta semplicemente riconoscere il codice SONY che la libreria ti ha già riconosciuto, quindi se il codice del segnale ricevuto corrisponde con il valore (o uno dei valori) che per te sono validi allora il colpo è a segno, altrimenti è "di striscio"?