Longitudinal redundancy check

Da Wikipedia, l'enciclopedia libera.

Nelle telecomunicazioni, un controllo di ridondanza longitudinale (Longitudinal redundancy check, LRC) o controllo di ridondanza orizzontale (HRC) è una forma di controllo di ridondanza che si applica indipendentemente a ciascuno dei gruppo paralleli di bit di un flusso dati. I dati devono essere divisi in blocchi di trasmissione, ai quali il blocco di controllo addizionale viene accodato.

Il termine solitamente si applica ad un singolo bit di parità per bit di flusso, altresì può essere utilizzato per riferirsi ad un più grande Hamming code. Mentre questo tipo di controllo di parità può essere usato per il controllo degli errori, può essere combinato con controlli addizionali (come ad esempio il controllo trasversale di ridondanza) per correggere gli errori.

Lo standard di telecomunicazioni ISO 1155 stabilisce che un controllo di ridondanza longitudinale per una sequenza di bytes può essere calcolato via software con il seguente algoritmo:

       Set LRC = 0
       For each byte b in the buffer
       do
           Set LRC = (LRC + b) AND 0xFF
       end do
       Set LRC = (((LRC XOR 0xFF) + 1) AND 0xFF)
       

Che può essere espresso come "il valore del complemento a due degli 8-bit della somma di tutti i bytes modulo 28."

Un LRC a 8-bit come questo è l'equivalente di un controllo di ridondanza ciclica usando il polinomiale x8+1, ma è meno chiara l'indipendenza del flusso dei dati se visto in questo modo.

Molti protocolli usano un meccanismo simile al controllo di ridondanza longitudinale (spesso chiamato carattere di controllo o BCC), incluso lo standard IEC 62056-21 per le letture elettriche, le smart card come definito nello standard ISO 7816 e i protocolli di gestione e accesso di dispositivi (per esempio ModBus).

C#[modifica | modifica sorgente]

        /// <summary>
        /// Calcolo del Controllo di ridondanza longitudinale (LRC) per un array di byte.
        /// Attenzione: nessuna garanzia viene fornita per questo codice. Controlla e verifica il codice prima di utilizzarlo.
        /// </summary>
        public static byte calculateLRC(byte[] data)
        {
            /* https://gist.github.com/953550
             * http://en.wikipedia.org/wiki/Longitudinal_redundancy_check
             */
            byte lrc = 0x00;
 
            for (int i = 0; i < data.Length; i++)
            {
                lrc ^= data[i];
            }
 
            return lrc;
        }

Java[modifica | modifica sorgente]

    /**
     * Calcola la cifra di controllo in ottemperanza allo standard ISO 1155
     * Maggiori informazioni: http://en.wikipedia.org/wiki/Longitudinal_redundancy_check
     * @param data array di cui calcolare la cifra di controllo
     * @return restituisce la cifra calcolata in formato byte
     */
    public byte calculateLRC(byte[] data) {
        byte checksum = 0;
        for (int i = 0; i <= data.length - 1; i++) {
            checksum = (byte) ((checksum + data[i]) & 0xFF);
        }
        checksum = (byte) (((checksum ^ 0xFF) + 1) & 0xFF);
        return checksum;
    }

C[modifica | modifica sorgente]

unsigned char calculateLRC(unsigned char *buf, unsigned int n){
 unsigned char checksum = 0;
 while(n>0){
  checksum += *buf++;
  n--;
 }
 return ((~checksum) + 1);
}