Testato:
leo tu hai ragione ed anche io preferisco ragionare in termini binari specialmente se si tratta di sfruttare un byte in termini di singoli flag. Pero lastrada del menny funziona ugualmente quindi se per lui e' piu facile ragionare in termini di byte singolo va bene cosi. Meglio avere uno sketch che capisci che uno migliore ma di cui non hai padronanza. Mio parere
O sono io che non mi so spiegare oppure ho disimparato a leggere... ma la questione iniziale era usare un byte come contenitore di impostazioni aggiuntive, quindi flag. 
Così infatti è stato detto e suggerito di usare il 4° byte. Usarlo in formato numerico porta ad un gran casino perché se il byte ha il valore, ad esempio, di 195 a me dice poco ma sapere che i suoi bit sono 11000011 mi fa capire che ho 4 flag ad 1 che mi indicheranno determinate opzioni o configurazioni. Proprio l'uso dei singoli bit permette di immagazzinare informazioni più "specifiche".
Se poi in quel 4° byte non ci deve stare altro che un valore da 0 a 6 allora è un altro discorso però è stato detto che era possibile usarlo anche per scopi futuri: strutturare il codice bene fin da subito in questo modo permette in seguito di non dover cambiare tutti i dati memorizzati e la logica del programma perché si è deciso di aggiungere dei dati a quel byte.
menniti:
Dopo una sana dormita di 10 ore stamattina mi sento in condizioni di poter riaffrontare la cosa, sia dal punto di vista teorico che da quello pratico, che poi, come dice giustamente Test, è quello che mi interessa di più: se non in grado di tirare fuori 1,2,....6 da quel valore memorizzato non mi serve altro, se devo farlo considerando che 6=1100 mi rompe un po' di più ma alla fine è la stessa cosa, l'importante è capire ed implementare il meccanismo, ma prima ho da affrontare due problemi più importanti:
Leggi sopra. Se vuoi metterci solo 0..6 usalo come vuoi, se in futuro pensi di usarlo per altri scopi, usalo nei singoli bit.
1 - la frammentazione del mio firmware in void, mentre prima potevo fare una procedura unica perché l'informazione sul micro la davo io da menu e tutto il resto veniva da sé, ora devo prima riconoscere il micro in automatico, quindi devo eseguire gran parte del firmware per poi rieseguirlo quasi tutto in funzione del micro inserito, chiaro che non posso "ricopiare" un intero firmware togliendo poche cose, quindi ogni spezzone funzionante lo metto in una void e nel loop mi lascio un main semplice semplice che esegua le varie void all'occorrenza.
Una piccola correzione. void indica al compilatore che una funzione restituisce un valore nullo, non è una parola chiave che indica al compilatore una funzione. Cioè, void non indica che si sta scrivendo una sub-routine ma il suo valore. Esempi:
void mario() {
... codice ...
}
Questo codice indica al compilatore che esiste una funzione o sub-routine, chiamala come vuoi, che non restituisce nessun valore. La dichiarazione di funzione è implicita, è come se esistesse una parola chiave "function" omessa.
Questo:
byte beppe() {
byte dato;
... codice ...
return dato;
}
Crea invece una funzione di nome beppe che restituisce un tipo di dati byte.
Quindi, non è corretto indicare una funzione con il termine "void". Ti faccio questa precisazione perché se nell'articolo scrivi che hai creato una void per fare una certa operazione, poi ricevi 100 lettere da programmatori C incacchiati che ti vogliono ardere in piazza tipo Savonarola 
2 - Letta la signature devo confrontare i suoi tre byte con quelli prememorizzati, io direi di semplificare confrontanto solo secondo e terzo, il primo mi serve come controllo della validità della signature, deve essere infatti sempre 1E (=Atmel), sopno il secondo e terzo che cambiano in funzione della memoria e del modello del micro. A tale proposito ho imparato che:
1° byte = produttore = 1E = Atmel
2° byte = memoria del micro -> 91=2K, 92=4K, 93=8k, ecc.ecc.
3° byte =modello del micro ma in coppia col secondo byte -> 950F = 328P (da approfondire quando avrò la tabella completa da studiare)
scrivete gente, scrivete....
Allora la mia idea di confronto della signature è:
un ciclo for di due passi all'interno di un while (flag); logica:
fino a che il flag = 0
leggo il secondo byte del secondo array, se è uguale leggo il terzo, se è uguale fine.
se non è uguale (o primo o secondo byte) passo alla riga successiva dell'array
se arrivo a fine array gli dico : guagliò che tieni inta a capa? mietti o micro giusto XD
idee migliori? (di sicuro ne avete!)
a più tardi e grazie.
Basta un if con un triplo controllo all'interno di un for. Mettiamo che firma[..] contenga la firma digitale letta dal micro e archivioFirme[..][..] le firme memorizzate:
boolean trovato=false;
for (byte i=0; i<num_firme; i++) {
if ((firma[0]==archivioFirme[i][0]) && (firma[1]==archivioFirme[i][1]) && (firma[2]==archivioFirme[i][2])) {
.....codice per firma trovata....
trovato=true;
break;
}
}
if (!trovato) {
....micro non riconosciuto...
}
"trovato" è false all'uscita del ciclo for se non è stato trovato nessun corrispondente modello nell'archivio