Come comprimi le stringhe ASCII in meno byte?

Sto lavorando con un dispositivo incorporato con un protocollo univoco che invia messaggi ad altri dispositivi e sto creando un'applicazione che analizza i pacchetti inviati. Ogni pacchetto contiene 8 byte. Il protocollo è definito come dove il primo byte è l'intestazione e i restanti 7 byte sono i dati.

Stanno provando a passare una particolare stringa ID ma la stringa ID è lunga 8 caratteri (ASCII), quindi non si adatta a 7 byte.

Quello che mi ha detto il mio collega è che trasformeranno gli 8 ASCII byte della stringa originale in intero (decimale) e me ne invieranno 4 byte. Mi hanno detto che avrei dovuto essere in grado di ottenere la stringa originale dai 4 byte. Sto facendo fatica a pensarci su.

Quindi se hai una stringa ID come "IO123456", è 0x49 0x4f 0x31 0x32 0x33 0x34 0x35 0x36 in ASCII .. Come mai puoi comprimerlo in 4 byte trasformandolo in un numero intero e posso ottenere la stringa originale da esso ? Mi sto perdendo qualcosa o il mio collega si sbaglia? Capisco che questa sia una domanda davvero bizzare, ma questo sul serio non ha alcun senso per me.

L'ID è sempre nella forma: IO123456? Ciò che il tuo collega potrebbe significare è che invia solo la parte numerica, che si adatta facilmente a 4 byte omettendo la parte "IO".

Se i primi due caratteri non sono costanti (ma sono sempre lettere) e i restanti sei caratteri sono sempre numeri, una stringa come "IO123456" può essere impacchettata in 5 byte convertendo i numeri in formato decimale con codice binario (BCD):

IO123456 -> 0x49 0x4f 0x31 0x32 0x33 0x34 0x35 0x36
             |    |      \   /     \   /     \   /
            0x49 0x4f     0x12      0x34      0x56

Se esiste un numero limitato di possibili identificatori (le prime due lettere), è possibile codificarli in un numero e inviarlo invece (purché non vi siano più di 256 combinazioni), ad esempio:

IO -> 0x00
RD -> 0x01
WT -> 0x02
   ...
AB -> 0x10
   ...
ZZ -> 0xff

in modo che la stringa originale sia impacchettata in 4 byte senza alcuna perdita di informazioni:

IO123456 -> 0x49 0x4f 0x31 0x32 0x33 0x34 0x35 0x36
              \    /     \   /     \   /     \   /
               0x00       0x12      0x34      0x56

Naturalmente questo processo può anche essere invertito per ottenere la stringa ID originale.

Se la stringa può essere qualsiasi sequenza di caratteri:

• Se si può essere certi che le stringhe non utilizzino il bit più significativo in ciascun byte, è possibile tagliare ciascuna fino a sette bit e utilizzare le operazioni bit per spostare i restanti 56 bit nei 56 bit disponibili.

• Se le stringhe sono solo lettere e cifre, crea una rappresentazione a 6 bit di quell'insieme e crea una stringa a 48 bit del tuo identificatore.

Se il formato è sempre composto da due lettere seguite da una stringa di cifre:

• Lasciare soli i primi due byte e codificare il numero in un numero intero a sei byte. IO123456diventa 0x49 0x4f 0x01E240.

• Lasciare soli i primi due byte e comprimere le cifre come decimali con codice binario . IO123456diventa 0x49 0x4f 0x12 0x34 0x56.

Dal contesto della domanda pubblicata qui, indica un protocollo industriale chiamato HART. Questo protocollo ha un modo unico di avvolgere i caratteri ASCII. Si chiama Packed-ASCII. Ma comunque non racchiude gli 8 personaggi in 4! Secondo Packed-ASCII, gli 8 byte ASCII vengono convertiti in 6. 4 a 3 e così via.

In questo protocollo, la lunghezza dei parametri in una determinata richiesta è sempre fissa. Quindi i personaggi rimanenti devono essere riempiti con i caratteri Spazio. Tuttavia, tutto questo è specifico di HART. Se confermi che stai lavorando a questo, metterò la procedura esatta di imballaggio e disimballaggio.

Forse convertendo '0123456' in un numero intero lungo.

Ma questo funzionerebbe solo con ID numerici.

Un altro possibile schema sarebbe quello di convertire la codifica ECMA-1 da 7 a 6 bit che ti darebbe una stringa di sei byte ma saresti limitato al set di caratteri in lettere maiuscole numeri e un set limitato di caratteri di punteggiatura.