Implementazione di comandi di controllo per un MCU su seriale

Sto cercando di integrare un'interfaccia di comando in un progetto che sto realizzando che accetterà comandi tramite seriale da un PC.

L'idea è che il dispositivo farà la sua cosa ma viene inviato un comando, lo eseguirà. Questo è diverso dalla maggior parte degli esempi che sono riuscito a trovare che è solo un dispositivo inattivo in attesa di dati seriali.

Ad esempio, un dispositivo che controlla i LED e riproduce un'animazione. Diciamo che ci sono 3 animazioni preimpostate e quando si accende riproduce sempre il numero 1. Sul lato PC invierei un comando 'gioca preimpostazione 2' o 'cambia colore in verde' o invio di un'animazione in tempo reale dal vivo al dispositivo per giocare sui LED.

Quindi la mia domanda è che non riesco a trovare molte informazioni su questo "modello di progettazione"? Non so da dove cominciare a cercare. Il più vicino che sono venuto è librerie di analisi seriale arduino pre-fatte. Tuttavia, sto cercando altro approccio C / non arduino / teorico.

Ho esaminato i protocolli seriali ma sono solo cose come SPI, I2C ecc., Non in realtà come implementare un'interfaccia controllo / comando nel software.

Ho anche scoperto HDLC, anche se sembra essere più uno standard / un protocollo. Un thread simile è /programming/1445387/how-do-you-design-a-serial-command-protocol-for-an-embedded-system Che ha delle informazioni molto belle ma che deve fare ancora con il protocollo / comunicazione stesso.

Sto cercando di trovare come codificare / implementare questo per creare un'abilità di comando o controllo.

Uso un ciclo infinito per monitorare e rilevare il seriale per un comando in arrivo e utilizzare un elenco di istruzioni IF per scegliere quale comando eseguire, ma poi cosa succede quando nessun comando e il sistema dovrebbero essere normali, o se manca un comando?

Interruzione guidata, macchina a stati?

Esiste un nome ufficiale per questo che può essere utilizzato per ricercare e trovare esempi?

MODIFICARE:

Per chiunque abbia la stessa domanda, ho trovato questo esempio davvero carino durante la ricerca, http://www.adnbr.co.uk/articles/parsing-simple-usart-commands

Esistono molti modi per implementare un protocollo di comunicazione. Ad esempio puoi scegliere di usare:

• formato leggibile o binario
• controllo degli errori come checksum o CRC
• caratteri di inizio e / o fine messaggio
• lunghezza del messaggio, numero ecc. informazioni sul payload
• Meccanismi di riconoscimento / riconoscimento negativo / nuovo tentativo

Il tuo comando di esempio è leggibile e dovrebbe usare '\ n' (invio) come carattere di fine messaggio. L'inizio / fine dei caratteri del messaggio semplifica l'analisi del flusso di input.

Un tipico flusso di programma consisterebbe nell'attendere la ricezione del carattere iniziale, quindi memorizzare i byte successivi in ​​un buffer dei messaggi fino alla ricezione del carattere finale. Una volta che ciò accade, passare il buffer a un'altra funzione per analizzare il messaggio. Se nessun carattere iniziale, inizia a memorizzare i byte immediatamente fino a quando non viene ricevuto il carattere finale.

La maggior parte dei sistemi embedded * funzionano in un ciclo infinito. La gestione della trasmissione e della ricezione seriale viene eseguita tramite interrupt su Arduino (consultare HardwareSerial.cpp). I caratteri ricevuti vengono inseriti in un buffer. Ad ogni iterazione del ciclo, controlli per vedere se ci sono caratteri nel buffer (Serial.available ()) ed elaborali. Ricevendo i personaggi usando gli interrupt, nessun personaggio dovrebbe essere perso. Tuttavia, non si esegue tutta l'elaborazione in queste routine di interruzione, altrimenti diventano troppo lunghe e quindi mancano le interruzioni successive.

Se non si desidera che il dispositivo si trovi in ​​loop inattivo, metterlo in uno stato di sospensione per "mettere in pausa" il loop fino a quando un interruzione o un altro evento.

Mi piace molto questa libreria per la messaggistica leggibile dall'uomo: http://playground.arduino.cc/Code/Messenger

* Non riesco a pensare a un sistema che non lo fa ma forse ce n'è uno là fuori.

Tutto ciò che il tuo programma deve fare è:
1. controllare frequentemente la porta seriale per un nuovo personaggio
2. passare alla routine appropriata / impostare lo stato / qualunque cosa, a seconda del personaggio
3. andare a 1

Il programma può agire su singoli caratteri, oppure è possibile creare il proprio formato di messaggio: spesso ho iniziato un cammand con "$" e ho terminato con newline, e ho usato caratteri ASCII leggibili per il comando (per facilitare il debug!).

Assicurati che il programma non si blocchi se riceve un comando non valido!