Usare telecomando IR invece del keypad

Sto facendo un progetto che sostituisce il keypad con un telecomando IR tipo questo:
telecomando
sono arrivato al punto di fare la decodifica dei tasti singolarmente, ma non riesco a ostrire un array di 3 cifre sto usando i seguente codice;
codice.ino (474 Bytes)
decodeTasto.ino (1.3 KB)
IrNec.cpp (3.7 KB)
IrNec.h (1.0 KB)
tlc.ino (236 Bytes)

qualcuno mi potrebbe aiutare con codice o logica di programmazione ?
naturalmente manca il file pricipale, che invio in un altro post (al massimo mi fa l'upload di 5 files)

allego il file main
nec2.ino (1.2 KB)

se i programmi li metti in chiaro ci guardo dentro

certamente non mi metto a scaricarli ed aprirli sul mio telefono

..e tra l'altro per una cosa così fare un progetto con 6 file separati di cui due per definire una classe mi pare sparare ad una mossca con un fucile mitragliatore.
Perché non usare poi la libreria IRremote invece di impelagarsi nel protocollo NEC che è già riconosciuto dalla libreria?

Certo che si. Devo dire che ho qualche difficoltà a seguire il codice, in particolare quando ci sono più di un file .ino. Visto che già usi una compile-unit .cpp perché non continuare su questa strada?
Cioè un solo file .ino e tutti il resto .cpp e .h.
Poi anziché postare tutti i file, crei un file .zip della cartella di progetto e fai l'upload di questo file. In questo modo mi basta scompattare il file nella cartella degli sketch e da li si aprono tutti nell'ide di arduino in automatico.

Ok, parlavi di:

Strano, se hai scritto quel codice dovresti sapere come funzionano gli array quindi e inutile che ti posti un link ad una risorsa sugli array. Quindi penso che la difficoltà non sia banale, prova a spiegare meglio.

Comunque attualmente nel file .h e .cpp mi sembra ok, ma non sono stato li a fare calcoli su i tempi per vedere se qualcosa non torna, per cui do per scontato che decodifica correttamente il protocollo NEC.

Ottime osservazioni. Tuttavia la IRremote può essere configurata per lavorare senza impegnare un timer hardware?
Perché la routine che usa non impegna alcun timer hardware, quindi magari gli servono tutti libero, oppure no.

Dimenticavo, nel codice puoi aggiungere commenti utili a chi legge il tuo codice.

Ciao.

Hai ragione sia sul file zip che non mi è venuto in mente, che i file ino, e sprattutto per i commenti che devo abituarmi a scriverli.
Ho creato i file ino perchè volevo renderlo multitasking e leggendo una guida, nell'esempio venivano usati i file ino. Inoltre, essendo autodidatta e quindi anche pasticcione, mi sono reso la vita più semplice usando i file ino e semplificandoli al massimo per fare i cambiamenti.
Non riesco a fare l'array, o come vedi nel codice (le variabili a,b e c che dovrebbero essere la simulazione dell'array) non riesco a salvare la variabile se non in "a" o nella prima posione dell'array.

Per il numero dei files ho risposto a MauroTec, mentre per l'uso della libreria nec invece ddi IRremote Ti posso dire questo:
quando premo un tasto sul telecomando può essere ripetuto, il che a me crea dei problemi.
Nella libreria IRremote il valore della ripetizione del tasto premuto è sempre lo stesso ( 69 69 69 ...), mentre nella libreria Nec il valore dellla ripetizione del tasto e FFFFFFF (es. 16753245 FFFFFFFF FFFFFFFF ...) e quindi mi semplifica la vita.

Ecco i files in chiaro, tranne i 2 file della libreria

//file nec2.ino

/*
 * Light Weight NEC Infrared decoder using interrupt instead of timer.
 *
 * 04_06_2019 v0_05 namespace model
 *
 */

#include "IrNec.h"
/*
#define KEY_UP  FF18E7
#define KEY_LEFT  FF10EF
#define KEY_OK  FF38C7
#define KEY_RIGHT  FF5AA5
#define KEY_DOWN  FF4AB5
#define KEY_1  FFA25D
#define KEY_2  FF629D
#define KEY_3  FFE21D
#define KEY_4  FF22DD
#define KEY_5  FF02FD
#define KEY_6  FFC23D
#define KEY_7  FFE01F
#define KEY_8  FFA857
#define KEY_9  FF906F
#define KEY_0  FF9867
#define KEY_ASTERISK  FF6897
#define KEY_POUND  FFB04F
*/
#define KEY_UP  16718055
#define KEY_LEFT  16716015
#define KEY_OK  16726215
#define KEY_RIGHT  16734885
#define KEY_DOWN  16730805
#define KEY_1  16753245
#define KEY_2  16736925
#define KEY_3  16769565
#define KEY_4  16720605
#define KEY_5  16712445
#define KEY_6  16761405
#define KEY_7  16769055
#define KEY_8  16754775
#define KEY_9  16748655
#define KEY_0  16750695
#define KEY_ASTERISK  16738455
#define KEY_POUND  16756815
#define ERR   4294967295

String chiave [2];
unsigned long  tasto;
int num;


void setup() {
  Serial.begin(9600) ;
 
  nsIrNec::begin(2) ;  // MUST BE EXTERNAL INTERRUPT PIN 
}

void loop() {

  
tlc();
 
}
***********************************************************
//file tlc.ino

void tlc() {

  int a;
  int b;
  int c;
 
  a = codice();
  b= codice();
  c= codice();
  Serial.println("*********************");
  Serial.print(a);
  Serial.print(b);
  Serial.print(c);
  Serial.println("*********************"); 

}
*****************************************************************
//file codice.ino

int codice(){
 for (num=0; num<3; num++) {
    nsIrNec::loop() ;   // check for new data
  
    if ( nsIrNec::dataOut != 0 ) {
       
      if (tasto != 4294967295) {
        tasto = (nsIrNec::dataOut) ;
        tasto = decodeTasto(tasto);
        //Serial.println(tasto);
        if (tasto != 99) {
        //Serial.println(tasto);
        chiave[num] = tasto;
        
        }
      }
      nsIrNec::dataOut = 0 ; //clear
      
      return tasto;
      
    }
  }

}
*****************************************************************
//file decodeTasto.ino

int decodeTasto( int key) {
 int tasto;
 
 switch (key) {
        case KEY_1: {
          tasto = 1;
          break;
        }
        case KEY_2: {
          tasto = 2;
          break;
        }
        case KEY_3: {
          tasto = 3;
          break;
        }
        case KEY_4: {
          tasto = 4;
          break;
        }
        case KEY_5: {
          tasto = 5;
          break;
        }
        case KEY_6: {
          tasto = 6;
          break;
        }
        case KEY_7: {
          tasto = 7;
          break;
        }
        case KEY_8: {
          tasto = 8;
          break;
        }
        case KEY_9: {
          tasto = 9;
          break;
        }
        case KEY_0: {
          tasto = 0;
          break;
        }
        case KEY_OK: {
          tasto = 99;
          break;
        }
        case KEY_UP: {
          tasto = 99;
          break;
        }
        case KEY_DOWN: {
          tasto = 99;
          break;
        }
        case KEY_LEFT: {
          tasto = 99;
          break;
        }
        case KEY_RIGHT: {
          tasto = 99;
          break;
        }
        case KEY_POUND: {
          tasto = 99;
          break;
        }
        case KEY_ASTERISK: {
          tasto = 99;
          break;
        }
        default: {
          tasto = 99;
        }
      }
 
  return tasto;
  
 }

Una cosa balza all'occhio

Le macro KEY_ le definisci a 8 cifre
Come fai a gestirle con degli interi?

Inoltre non capisco come ti sincronizzi

Non conosco il protocollo NEC né ho telecomandi di quel tipo, ma ho avuto a che fare con ricezione ed invio di segnali IR (ho realizzato un ripetitore di telecomando via WiFi ad esempio), ed ho sempre usato la IRremote. Cercando info ho visto qui che il NEC prevede un repeat code, per cui mi sembra strano che dalla IRremote a te dia sempre lo stesso codice iniziale.
Però, perdonami, se anche fosse così non capisco quali problemi possa darti: basta che tu da qualche parte memorizzi il precedente codice ricevuto e se ne ricevi uno uguale al precedente mandi a tua volta il codice di repeat.

Ma a parte questo, il tuo codice è un po' diciamo "minestrone". Intanto fai svariati inutili #include (ne basta uno, nel modulo principale), poi mi sfugge perché tu faccia addirittura file *.ino separati per metterci dentro una sola funzione ciascuno. Capisco la modularità, ed è un principio che anche io applico, ma non è così che va applicata e soprattutto non per programmi così semplici.

Ma ci sono ben altre cose che mi lasciano perplesso. Per iniziare, è quando pensi di poter mettere in una variabile "int" valori come 4294967295 e quindi mi chiedo come possa funzionare correttamente! Gli "int" sono di 2 byte e vanno da -32768 a 32767, quindi quei codici non puoi metterli in un "int". La libreria per "dataOut" usa "uint32_t" ossia "unsigned long" da 4 byte, per cui assegnare "tasto = (nsIrNec::dataOut) ;" può portare a risultati imprevisti in quanto si perdono sicuramente informazioni. Poi anche la funzione "codice()": se esce dal for() perché non è stato premuto nulla non restituisce nulla (manca un "return qualchecosa;") o, meglio, potrebbe restituire solo zero ma non si fanno funzioni nelle quali esiste un ramo che non restituisce un valore (in altri ambienti questo viene segnalato come errore o almeno warning).

In pratica, a me sembra che il problema del repeat di tasti sia veramente l'ultimo dei tuoi pensieri.

Dammi retta, lascia perdere quella libreria astrusa ed usa la ben più standard e nota IRremote, e soprattutto lascia perdere la "proliferazione" di file *.ino, almeno in prima battuta finché il codice non diventa abbastanza grande. Sempre poi che sia necessario farlo, ad esempio per raggruppare in un file *.h (lascia .ino solo per il main) tuttele variabili e funzioni che gestiscono un certo aspetto, e se anche questi dovessero superare una certa complessità o fosse necessaria una migliore separazione, allora potresti pensare di fare tue classi (.cpp e relativo *.h).

Ma dato che qui non siamo ancora a quel livello, ti consiglio intanto di semplificare il tuo sketch usando la IRremote (e qui se vuoi possiamo già darti una mano se posti il tuo tentativo di usarla), poi una volta fatto questo pensiamo anche a come aiutarti per memorizzare gli ultimi 3 tasti premuti, ok?

Per ora invio il confronto delle 2 librerie con i dati del serial monitor.
Come si puo' vedere esistono i tasti ripetuti, che vorreei escudere.

// file preso dall'esempio IRremote (TinyReceiver)

#include <Arduino.h>

#define IR_RECEIVE_PIN    2   // INT0
#define NO_LED_FEEDBACK_CODE   // Activate this if you want to suppress LED feedback or if you do not have a LED. This saves 14 bytes code and 2 clock cycles per interrupt.

#include "TinyIRReceiver.hpp"


volatile struct TinyIRReceiverCallbackDataStruct sCallbackData;

void setup() {
    Serial.begin(9600);

 
    // Enables the interrupt generation on change of IR input signal
    if (!initPCIInterruptForTinyReceiver()) {
    }

    Serial.println("Ready to receive NEC IR signals at pin " );

}

void loop() {
    if (sCallbackData.justWritten) {
        sCallbackData.justWritten = false;

        Serial.print(F("Address=0x"));
        Serial.print(sCallbackData.Address, HEX);
        Serial.print(F(" Command=0x"));

        Serial.print(sCallbackData.Command, HEX);
        if (sCallbackData.Flags == IRDATA_FLAGS_IS_REPEAT) {
            Serial.print(F(" Repeat"));
        }
        if (sCallbackData.Flags == IRDATA_FLAGS_PARITY_FAILED) {
            Serial.print(F(" Parity failed"));
        }
        Serial.println();
    }
    /*
     * Put your code here
     */
}

/*
 * This is the function is called if a complete command was received
 * It runs in an ISR context with interrupts enabled, so functions like delay() etc. should work here
 */


void handleReceivedTinyIRData(uint8_t aAddress, uint8_t aCommand, uint8_t aFlags)

        {

    sCallbackData.Command = aCommand;
    sCallbackData.Flags = aFlags;
    sCallbackData.justWritten = false;

    /*
     * Printing is not allowed in ISR context for any kind of RTOS
     * For Mbed we get a kernel panic and "Error Message: Semaphore: 0x0, Not allowed in ISR context" for Serial.print()
     * for ESP32 we get a "Guru Meditation Error: Core  1 panic'ed" (we also have an RTOS running!)
     */
    // Print only very short output, since we are in an interrupt context and do not want to miss the next interrupts of the repeats coming soon

    printTinyReceiverResultMinimal(&Serial, aAddress, aCommand, aFlags);


}

// file preso dall'esempio Nec

#include "IrNec.h"
/*
#define KEY_UP  FF18E7
#define KEY_LEFT  FF10EF
#define KEY_OK  FF38C7
#define KEY_RIGHT  FF5AA5
#define KEY_DOWN  FF4AB5
#define KEY_1  FFA25D
#define KEY_2  FF629D
#define KEY_3  FFE21D
#define KEY_4  FF22DD
#define KEY_5  FF02FD
#define KEY_6  FFC23D
#define KEY_7  FFE01F
#define KEY_8  FFA857
#define KEY_9  FF906F
#define KEY_0  FF9867
#define KEY_ASTERISK  FF6897
#define KEY_POUND  FFB04F
*/
#define KEY_UP  16718055
#define KEY_LEFT  16716015
#define KEY_OK  16726215
#define KEY_RIGHT  16734885
#define KEY_DOWN  16730805
#define KEY_1  16753245
#define KEY_2  16736925
#define KEY_3  16769565
#define KEY_4  16720605
#define KEY_5  16712445
#define KEY_6  16761405
#define KEY_7  16769055
#define KEY_8  16754775
#define KEY_9  16748655
#define KEY_0  16750695
#define KEY_ASTERISK  16738455
#define KEY_POUND  16756815
#define ERR   4294967295


int long unsigned  tasto;

void setup() {
  Serial.begin(9600) ;
 
  nsIrNec::begin(2) ;  // MUST BE EXTERNAL INTERRUPT PIN 
}

void loop() {

  
  
    nsIrNec::loop() ;   // check for new data
  
    if ( nsIrNec::dataOut != 0 ) {
   
      // print interpreted data then reset it
      Serial.println(nsIrNec::dataOut,DEC) ;
      tasto = nsIrNec::dataOut,DEC;
      
      }
      //Serial.println();
      nsIrNec::dataOut = 0 ; //clear
      Serial.println(tasto);
    }

Dati letti sul Serial Monitor

con libreria IRremote

Ready to receive NEC IR signals at pin 
A=0x0 C=0x45
A=0x0 C=0x45 R
A=0x0 C=0x46
A=0x0 C=0x46 R
A=0x0 C=0x46 R
A=0x0 C=0x47
A=0x0 C=0x47 R
A=0x0 C=0x47 R

****************************************
con libreria Nec come da esempio senza variabili

16753245
4294967295
4294967295
16736925
4294967295
4294967295
4294967295
16769565
4294967295
4294967295
4294967295
4294967295

****************************************
con libreria Nec  introducendo variabile tasto int

0
0
0
.........
0
0
16753245
-23971
-23971
-23971
-23971
-23971
4294967295
-1
-1
..........
-1
-1
4294967295
-1
-1
............
-1
-1
-1
4294967295
-1
-1
........
-1
4294967295
-1
-1
..........
-1
-1
16736925
25245
25245
25245
25245
25245
25245
4294967295
-1
-1
........
-1
-1
4294967295
-1
-1
............
-1
-1
16769565
-7651
-7651
-7651
-7651
-7651
-7651
4294967295
-1
-1
............
-1
-1
4294967295
-1
-1
..........
-1
-1
-1
4294967295
-1
-1
-1
............
-1
-1
4294967295
-1
-1
........
-1
-1
..............

*********************************************
con libreria Nec  introducendo variabile tasto int long unsigned

0
0
..........
0
0
0
16753245
16753245
16753245
16753245
16753245
16753245
4294967295
4294967295
...........
4294967295
4294967295
4294967295
16736925
16736925
16736925
16736925
16736925
4294967295
4294967295
.........
4294967295
4294967295
4294967295
16769565
16769565
16769565
16769565
16769565
4294967295
4294967295
4294967295
..........
4294967295
4294967295
4294967295
...........

Per momento mi basterebbe sapere il modo per leggere e salvare solo i dati che mi servono e che poi verranno inseriti in un array

Mah, non capisco, io non ci vedo problemi. Se vuoi escluderli basta sapere se è un codice ripetuto, e stando all'esempio che hai postato c'è persino una "if" specifica, che puoi usare per ignorare il tasto ripetuto:

void loop() {
  if (sCallbackData.justWritten) {
    sCallbackData.justWritten = false;
    if (sCallbackData.Flags != IRDATA_FLAGS_IS_REPEAT) {
        // Il tsto è buono e non è un repeat
        Serial.print(F("Address=0x"));
        Serial.print(sCallbackData.Address, HEX);
        Serial.print(F(" Command=0x"));
        Serial.print(sCallbackData.Command, HEX);
        // Ora ci faccio qui quello che mi serve...
...
    }
  }
}
...

Il codice deve essere un unsigned long se vuoi memorizzare quei valori. Ma come vedi, con IRremote è tutto più semplice.

Ti posto qui qualche spezzone di codice che ho in uno dei miei progetti, vedi se può esserti utile:
Receiver.ino:

#define RECV_PIN D3
// Ritardo minimo tra un tasto e il successivo (ms)
#define KEY_DELAY 300

// Gestione IR
#include <IRrecv.h>
#include <IRremoteESP8266.h>
IRrecv irrecv(RECV_PIN, 1024, 15, true);
#include "IrCode.h"
decode_results results;

void setup() {
  Serial.begin(115200);
  irrecv.enableIRIn();

  Serial.println("STARTED");
  Serial.println();
}

void loop() {
  if (irrecv.decode(&results)) {
    if (results.decode_type == PROTO) {
      int key = decodeValue();
      if ( key > -1 ) { // Tasto riconosciuto
        // Controllo il repeat locale
        if ( key == lastKey && millis()-tmrRepeat < KEY_DELAY ) {
          Serial.println("**REPEAT IGNORATO**");
        } else {
          Serial.print(" Tasto: "); Serial.println(keyLbl[key]);
          // Uso il tasto...
...
          lastKey = key;
          tmrRepeat = millis();
        }
      }
    }
    irrecv.resume(); // Receive the next value
  }
}

// --------------------------------------------------
// DECODIFICA TASTI
// --------------------------------------------------
int decodeValue() {
  unsigned long kCode = results.value - PROTO_OFFSET;
  Serial.print(" 0x"); Serial.print(kCode, HEX);
  // Cerca il codice nella tabella dei codici
  int k = -1; // Indice del tasto all'interno della tabella
  for (int i = 0; i < KEYS; i++) {
    if ( keyCode[i] == kCode ) {
      // Trovato!
      return i;
    }
  }
  // Se non trovato restituisce -1 perché non devo farci nulla
  return -1;
}

IrCode.h: (questo ovviamente devi adattarlo al tuo caso, io ho la codifica Samsung, ed i valori li ho acquisiti con IRrecvDump e messi in keyCode e nel mio caso uso un offset per semplificarmi le cose, ma tu metterai i codici senza offset, ed infine l'etichetta equivalente adf ognuno dei codici è in keyLbl):

// Tabella codifica SAMSUNG codice 1648
#define PROTO SAMSUNG
// Offset dei codici
#define PROTO_OFFSET 0xE0E00000
// Numero di elementi nell'array
#define KEYS 36

// MAPPA DEI TASTI
// Etichetta (solo per stampare il nome del tasto)
char keyLbl[KEYS][4] = {
  "0"   ,"1"   ,"2"   ,"3"   ,"4"   ,"5"   ,"6"   ,"7"   ,"8"   ,"9"   ,
  "HLP" ,"ESC" ,"P+"  ,"P-"  ,"UP"  ,"LT"  ,"OK"  ,"RT"  ,"DN"  ,"MNU" ,
  "GUI" ,"PRI" ,"INT" ,"BCK" ,"INF" ,"TXT" ,"RED" ,"GRN" ,"YLW" ,"BLU" ,
  "REC" ,"PAU" ,"STP" ,"PLY" ,"REW" ,"FFW"};

// **** CODIFICA (da sommare all'offset)
unsigned long keyCode[KEYS] = {
  0x8877, 0x20DF, 0xA05F, 0x609F, 0x10EF, 0x906F, 0x50AF, 0x30CF, 0xB04F, 0x708F,
  0x7C83, 0xB44B, 0x48B7, 0x08F7, 0x06F9, 0xA659, 0x16E9, 0x46B9, 0x8679, 0x58A7,
  0xF20D, 0xD629, 0x9E61, 0x1AE5, 0xF807, 0x34CB, 0x36C9, 0x28D7, 0xA857, 0x6897,
  0x926D, 0x52AD, 0x629D, 0xE21D, 0xA25D, 0x12ED };

Per il momento sto studiando quello quello che postato e che sembra il mio caso.
Intanto Ti ringrazio per l'aiuto

Ho provato a modificare questa parte del codice, ma non funziona.
Le istruzioni serial.print è come non esistessero, mi stampa tutti gli input.

Ho dovuto lasciare la riga:
printTinyReceiverResultMinimal(&Serial, aAddress, aCommand, aFlags);
nella funzione:
void handleReceivedTinyIRData(uint8_t aAddress, uint8_t aCommand, uint8_t aFlags)
Altrimenti non visualizzava niente sul serial monitor.

Ho lasciato nel codice della funzione:
void handleReceivedTinyIRData(uint8_t aAddress, uint8_t aCommand, uint8_t aFlags)
il codice relativo alla riga:
printTinyReceiverResultMinimal(&Serial, aAddress, aCommand, aFlags);

Altrimenti non visualizzava niente sul serial monitor.

Sto provando l'altra soluzione, ma non trova i tasti e non capito a cosa serve la variabile "k"

file ircode.h

#define KEYS 17

// MAPPA DEI TASTI
// Etichetta (solo per stampare il nome del tasto)
char keyLbl[KEYS][3] = {
  "1"   ,"2"   ,"3"   ,"4"   ,"5"   ,"6"   ,"7"   ,"8"   ,"9"   , "0"  ,
  "UP"  ,"DN"  ,"SN"  ,"DX"  ,"OK"  ,"*"   ,"#" };


unsigned long keyCode[KEYS] = {
  0x45, 0x46, 0x47, 0x44, 0x40, 0x43,  0x7, 0x15, 0x9, 0x19,
  0x18, 0x52,  0x8, 0x5A, 0x1C, 0x16,  0xD };

dallo sketch IRrecvDump ricevo questi dati (parziali) per il tasto "1"

1
uint16_t address = 0x0;
uint16_t command = 0x45;
uint32_t rawData = 0xBA45FF00;

non quale dato inserire, perchè il programma alla riga Serial.print mi stampa solo 0x10 per qualsiasi tasto, è giusto ?
mentre nel loop li stampa correttamente, senza lo 0x.

Non ho capito, se stampa gli input le serial.print funzionano, se non funzionano perché non stampa può solamente essere che non entra nella if()... Li stampa o no?
In ogni caso io non uso quella versione "tiny", ho solo dedotto la "if (sCallbackData.Flags != IRDATA_FLAGS_IS_REPEAT)" dal tuo esempio dove evidenziava i repeat code, che qui escludo.
Se devi/vuoi continuare ad usare la TinyIRReceiver dovresti verificare cosa contiene quel campo "Flags" ed agire di conseguenza.

Si, è un refuso, la usavo io per altro (come ti dicevo, è un "estratto" da un altro mio progetto analogo). Puoi eliminarla o ignorarla.

Beh intanto inutile mettere le Serial.print dentro alla funzione decodeValue() visto che nel loop già mostra il tasto (in realtà l'etichetta del tasto, cioè "keyLbl[key]") o il repeat ignorato. Se vuoi aggiungere la stampa di tasto ignorato come "else" della if ( key > -1 ).
Poi se hai usato il mio codice (ma hai usato tutto il codice che ti ho postato?) nel loop non può stamparti 0x10 perché stampa, appunto, l'etichetta del tasto (es. "SX", "*", p "5") e non un valore esadecimale.
Se IRdump ti dà comando 0x45, è il tasto "1" quindi il mio codice (a parte la tua implementazione di IrCode.h con i tuoi codici) dovrebbe scrivere:
Tasto: 1
Poi hai tolto anche il controllo del protocollo (nel mio caso "SAMSUNG" nel tuo dovevi mettere "NEC"), per l'offset se lo hai tolto va anche bene così, visto che per te non ce n'è bisogno. Ma dato che hai postato solo la tua versione di decodeValue() e di IrCode.h ma non il resto, non so dirti.

Quindi verifica di aver usato tutto il codice che ti ho mandato, tranne come dicevo il tuo IrCode.h, e se hai problemi rimanda sempre tutto il tuo codice, non solo un pezzo.

Forse ho capito perchè i codici che mi hai postato non funzionavano in modo corretto.
Ho cercato usare e adattare il codica alla nuova verione 4 della libreria.
Domani non so se ho tempo, ma in seguito proverò a crivere il codice nel formato della versione 2 oppure fare l'installazione della versione 2 ".
nella versione 4 della versione tiny dell'esempio ci sono le callback (che non ancora capito bene come usarle, specialmente in javascript) e nella funzione void handleReceivedTinyIRData c'è &serial che non so cosa sia o faccia, comunque tale funzione non mi salva nessun valore in una variabile globale, mentre nella prova veloce che fatto oggi, nella versione 2 invece lo fa, non capisco come salvare le variabili in quella funzione.

Scusa, ma effettivamente ancora mi manca una informazione: tu con quale board stai lavorando?

Nel mio caso, come puoi vedere dall'esempio di codice che avevo mandato nel post #12, uso una ESP8266 (vedi la #include). Tu quale stai usando? Perché ovviamente la libreria IRremoteESP8266, anche se direttamente derivata dalla IRremote per Arduino di Ken Shirriff, ha sicuramente delle differenze visto che equivale alla versione 2.0.

Se quindi usi una UNO e vuoi usare la 4.0, prova a vedere QUI cosa va modificato. Perdonami, io non ho più usato la IRremote per Arduino (anche se ho la 4.0 installata in realtà) perché tutti i miei progetti erano su ESP8266 (WeMos D1 per l'esattezza). Altrimenti se hai una WeMos a portata di mano prova ad usare quella.

Sto usando nano, è quello che ho provato a fare.
ora sto facendo il downgrade alla versione 2.81 e mi sembra anche più semplice capire il codice.

Per il momento Ti ringrazio per l'aiuto che mi stai fornendo, domani proverò e Ti farò sapere.

Sono riuscito leggere i tasti non ripetuti, ma non riesco a salvarli in un array, o meglio riesco salvarli, ma l' array contiene sempre il valore dell'ultimo valore.

/*
 *  MinimalReceiver.cpp
 *
 *  Receives IR protocol data of NEC protocol using pin change interrupts.
 *  On complete received IR command the function handleReceivedIRData(uint16_t aAddress, uint8_t aCommand, bool isRepetition)
 *  is called in Interrupt context but with interrupts being enabled to enable use of delay() etc.
 *  !!!!!!!!!!!!!!!!!!!!!!
 *  Functions called in interrupt context should be running as short as possible,
 *  so if you require longer action, save the data (address + command) and handle them in the main loop.
 *  !!!!!!!!!!!!!!!!!!!!!
 *
 *
 *  Copyright (C) 2021  Armin Joachimsmeyer
 *  armin.joachimsmeyer@gmail.com
 *
 *  This file is part of IRMP https://github.com/ukw100/IRMP.
 *  This file is part of Arduino-IRremote https://github.com/z3t0/Arduino-IRremote.
 *
 *  IRMP is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/gpl.html>.
 *
 */

#include <Arduino.h>


#define IR_INPUT_PIN    2
#define DO_NOT_USE_FEEDBACK_LED_PIN

#include "TinyIRReceiver.cpp.h"

int key; 
int codice[2];

void setup()
{
    Serial.begin(9600);
    initPCIInterruptForTinyReceiver();
}

void loop()
{
    /*
     * Put your code here
     */
    /*
     for (;;) {
      codice[0] = key;
      if (key!= 0) break;
     } 
      for (;;) {
      codice[1] = key;
      if (key!= 0) break;
     }  
      for (;;) {
      codice[2] = key;
      if (key!= 0) break;
     }   
  */

       // Serial.println(key);
     //if (key == 69) Serial.println("trovato");
     /*
      Serial.print(codice[0]);
      Serial.print(" , ");
      Serial.print(codice[1]);
      Serial.print(" , ");
      Serial.println(codice[2]);
      Serial.println("**************");
     */
}


void handleReceivedTinyIRData(uint16_t aAddress, uint8_t aCommand, bool isRepeat)

{

    if (!isRepeat) {
      key = aCommand;
      Serial.println(key);
    }
}

nel codice ho messo solo la parte funzionante, il salvataggio dei valori nell' array che non capisco come fare.