Lettura da porta seriale

[Wesker]

Salve a tutti

Data la mia incapacità nel programmare, mi trovo bloccato all'input da seriale.

Il sistema deve leggere i dati dalla seriale.
Il messaggio in arrivo ha una struttura così fatta:

Start(1byte)Lunghezza(2byte)ID(1byte)indirizzo(2byte)RSSI(1byte)Opzioni(1byte)numerocampioni(1byte)
dati(nbyte)check(1byte).

Come faccio a laggere i dati?

Avevo pensato ad una read che memorizzi idati in una stringa, ma poi come posso leggere due byte alla volta (tipo Lunghezza)?

Forse devo leggere un carattere alla volta e unirli dopo?

Poichè i dati sono in formato esadecimale che funzione si può usare per covertire i valori in interi?

Grazie

[sottovento]

Ciao,
ho qualche suggerimento e una domanda. Partiamo dalla domanda: cosa intendi
con "i dati sono in formato esadecimale?" Ti tiene spedito una sequenza di due
caratteri per byte?
La prima impressione e' che sia solo un misunderstanding: ti vengono spediti
dei byte, puri e semplici. Giusto?

In tal caso, i suggerimenti che ho da darti sono 3:
1 - Ricorda che la linea seriale e' facilmente soggetta ad errori di
trasmissione, specialmente se hai 220 tonnellate di acciaio fuso circa due
metri sopra la testa :). Il tuo protocollo deve pertanto darti la possibi-
lita' di capire se e' avvenuto un errore;
2 - L'hardware di qualsiasi computer effettua il controllo di parita' (se abili-
tato, ovviamente). Nel caso che venga trovato un errore di parita (i.e. c'e'
stato un numero DISPARI di errori) il byte viene automaticamente eliminato
dall'hardware! Pertanto il tuo software non puo' fare affidamento sul fatto
che "Beh, mi spediscono 10 byte, allora nel mio software leggo 10 byte".
Potrebbero arrivartene meno di quanti ne sono stati spediti.
Per inciso: questo e' il primo motivo di errore nel protocolli software che
ho esaminato in 20 anni di lavoro. Infatti, quando non tieni conto di questo
il tuo software si desincronizza e non lo puoi piu' risincronizzare;
3 - I sistemi operativi "veri" gestiscono la seriale seriamente :).
Se invece devi utilizzare MS-DOS, ricordati che non fa una vera gestione
della seriale (o meglio, dell'interrupt): per avere un dato, il tuo program-
ma deve essere li' in attesa!
Se non sei in attesa e non leggi subito il dato, il dato successivo lo
sovrascrivera'. Per evitare questo, devi scriverti una routine di risposta
all'interrupt (o cercare una libreria su internet).
Nessun problema, invece, con sistemi operativi piu' evoluti (Unix, Linux,
Windows, OS/2, OS9, VMS, pSOS+, VMEexec, vxWorks, RTC, Pharlap, ...)

Mi scuso per la mia supponenza se mi permetto di darti qualche consiglio per
l'implementazione:
- Utilizza un buffer circolare: i dati che leggi dalla seriale NON li metti
in una stringa, bensi' in un buffer circolare. Il buffer circolare e' una
struttura dati che immagino che tu conosca bene, giusto?
Puoi leggere anche un dato alla volta, non ha importanza. Come dicevamo prima,
non fare affidamento sul fatto che se scrivi
int letti = read (seriale, buffer, 10);
tu legga 10 byte!

- Il buffer circolare lo potrai scandire mediante un automa a stati finiti.
Niente paura: si tratta di una sola variabile intera il cui nome e' "stato",
tutto qui.
La variabile "stato" potra' assumere diversi valori (ovviamente interi) che
definirai mediante la #define o qualsiasi altro modo preferisca.
Potresti creare una funzione
int getMessage (&buf)
che ti ritorna il messaggio completo e verificato (nel caso sia arrivato
completamente) e ti ritorna il valore 0, oppure ritorna -1 (o un codice di
errore) se nel buffer circolare non ci sono ancora abbastanza dati per tirare
fuori un messaggio completo.

Vediamo l'automa che potresti realizzare in getMessage:
- all'inizio sei in stato SCAN (avrai definito, per esempio
#define STATUS_SCAN 1). Questo significa che scandira il buffer alla
ricerca del tuo byte di synchro, lo start. E' stata una scelta intelligente,
questo byte, anche se ne avrei messo piu' di uno


status = STATUS_SCAN;
while (dati in buffer)
{
BYTE b = get_current_byte_from_circular_buffer();
switch (status)
{
case STATUS_SCAN: // Se il byte e' quello giusto, cambia stato!
// Altrimenti resta in questo stato.
if (b == START_BYTE)
status = STATUS_SCAN_LENGTH;
break;
}
}


Capito il trucco? A questo punto aggiungi tutti gli stati che ti servono.
Disegnati prima l'automa su un pezzetto di carta (sono pochi stati).

ATTENZIONE - Siccome non e' detto che fra i dati non compaia il carattere di
synchro, sarai costretto a fare un'operazione di backtrack.
Vale a dire: memorizza la posizione nel buffer, quando cominci a scandire.
Nel caso non trovi quanto ti interessa (perche' il checksum o la lunghezza o
qualsiasi altro dato e' errato o irragionevole), torni indietro nel buffer e
ricominci a scandire dal byte successivo. Tutto chiaro?

Per estrarre i valori a due byte, devi leggerli entrambi (or course) e
- se te li spediscono in LITTLE ENDIAN (Intel Format), il primo byte e' il meno
significativo, per cui:
lunghezza = first_byte | (second_byte << 8)
- se te li spediscono in BIG ENDIAN (Motorola Format), il primo byte e' il piu'
significativo, per cui
lunghezza = second_byte | (first_byte << 8)

[sottovento]

Sorry, postato due volte