Longitudinal redundancy check

Nelle telecomunicazioni, un controllo di ridondanza longitudinale (in inglese Longitudinal redundancy check, LRC) o controllo di ridondanza orizzontale (HRC) è una forma di controllo di ridondanza che si applica indipendentemente a ciascuno dei gruppi 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.

Descrizione

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 2⁸."

Un LRC a 8-bit come questo è l'equivalente di un controllo di ridondanza ciclica usando il polinomiale x⁸ 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#

        /// <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

    /**
     * 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

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

Python

'''
Calcolo del Controllo di ridondanza longitudinale (LRC) per un array di byte.
'''
def calculate_LRC(data):
    lrc = 0x00
    for element in data:
        lrc^=element

    return lrc

lrc = calculate_LRC([ord('H'),ord('E'),ord('L'),ord('L'),ord('O')])
print lrc