Ok, fatto al volo
NON lo ho fatto per te, ma perchè mi serviva per altro, ma comunque sarai il primo a provarlo, io non ho una DUE per provare, non posso nemeno compilare, dato che non ho le librerie
per prima cosa la loop()
void loop(void)
{
byte comando = 0;
if (Serial1.available())
{
// un byte disponibile
// passo a trattarlo
comando = parserizza((byte)Serial1.read());
// tutto il lavoro lo fa la parserizza
// che restituisce un valore numerico
// 0 per non trovato
// 1 per trovato primo comando
// 2 per trovato.......
}
switch (comando)
{
case 0:
// nessun comando da eseguire
break;
case 1:
// qui eseguo il primo comando
break;
case 2:
// qui eseguo il secondo comando
break;
// e via così....
default:
// comando non trovato
}
}
come vedi ho semplicemente passato il lavoro sporco ad una funzione apposita, che riceve un byte per volta dalla loop, solo se la seriale è available
e restituisce 0 se non ha ancora trovato un comando valido
il numero del comando se lo ha trovato
e poi una switch case esegue il comando, abbastanza banale
per seconda cosa la funzione di parser
byte parserizza(byte in)
{
// riceve byte a byte un comando e lo usa per riconoscere il comando complessivo
// dichiaro una matrice di matrici di byte
// il problema è che le sequenza non hanno lunghezza uguale tra loro
// quindi devo anche dichiarare un array di lunghezze
// potessi usare le stringhe, sarebbe comodo ma esistono degli 00 nel flusso
// quindi una matrice bidimensionale di byte (larga quanto il più lungo comando)
// con una matrice monodimensionale di lunghezze
byte comandi[6][9];// 6 comandi per nove byte massimi
byte lunghez[6]; // 6 lunghezze
// inizializzo
comandi[1] = {0x00, 0x60, 0xFE, 0x00};
lunghez[1] = 4;
// e qui si prosegue per gli altri 5 comandi possibili
// siccome leggo il comando byte a byte devo tenere traccia di quanto lungo ho letto
// e siccome devo confrontarlo con 6 possibili comandi devo avere sei indici, uno per possibile comando
// statico per non perdere l'informazione da un ingresso al successivo
static byte trovato[6] = {0, 0, 0, 0, 0, 0}; // variabili locali vanno inizializzate
// adesso conosco un byte e vedo se corrisponde con la posizione raggiunta in ognuno dei possibili comandi
for (byte i = 0; i < 6; i++)
{
// per ogni comando
if (comandi[i][trovato[i]] != in)
{
// se il byte 'in' non corrisponde al byte in posizione [trovato[i]]
// non e' il carattere giusto
trovato[i] = 0; // riporto indietro il contatore
}
else
{
// è il carattere giusto
// delle due l'una
// o siamo alla fine del comando oppure no
if (trovato[i] == lunghez[i])
{
// comando finito, ho trovato tutti i byte
// riporto a zero l'indice, per ripartire bene la prossima volta
trovato[i] = 0;
// me ne esco da questa funzione restituendo il numero del comando trovato
// più uno perchè zero indica comando non trovato
return i + 1;
}
else
{
// comando non ancora finito, devo aspettare altri byte per sepere se è il giusto
// aggiorno l'indice per controllare il prossimo byte
trovato[i]++;
}
}
}
// se sono arrivato fin qui vuol dire che non ho trovato nessun comando
// restituisco 0 -> comando non trovato
return 0;
}
Tieni presente che ho appena finito di scriverla, e non so se compila, casomai vedi che problemi ti da
fondamentalmnte una matrice bidimensionale di byte, che contengono le sequenze possibili di byte in ricezione
letta "riga a riga" si può interpretare come una matrice di sequenze
quindi, in una for, sequenza per sequenza, controlla se il byte appena arrivato corrisponde al punto che ha già raggiunto, se corrisponde e ha finito la sequenza restiruisce il numero della sequenza riconosciuta
se corrisponde e non ha finito la sequenza "avanza di uno" nella lettura della sequenza
se non corrisponde riporta a zero l'indice di lettura
se non corrisponde per nessuna sequenza restituisce 0 per dire che non ha ancora trovato nulla
Personalmente credo che non andrà, per i dubbi che ti avevo esposto prima, ma tentar onn nuoce
a comunque NON accenderà mai la ventola DX a velocità 1, dato che con quella sequenza comunque interpreta ventola DX velocità 3