Comprovació longitudinal de redundància

En telecomunicacions , una comprovació de redundància longitudinal (LRC) o una comprovació de redundància horitzontal (HRC) és una forma de comprovació de redundància que s’aplica independentment a cadascun dels conjunts de bits paral·lels d’un flux de dades. Les dades s'han de dividir en blocs de transmissió, als quals s'afegeix el bloc de control addicional.

Descripció

El terme normalment s'aplica a un bit de paritat únic per bit de flux, també es pot utilitzar per referir-se a un codi Hamming més gran. Tot i que aquest tipus de comprovació de paritat es pot utilitzar per a la comprovació d’errors, es pot combinar amb comprovacions addicionals (com la comprovació de redundància creuada) per corregir els errors.

L' estàndard de telecomunicacions ISO 1155 estableix que es pot calcular una comprovació de redundància longitudinal d'una seqüència de bytes mitjançant un programari amb l'algoritme següent:

 Estableix LRC = 0
       Per a cada byte b del buffer
       fer
           Estableix LRC = (LRC + b) I 0xFF
       acabar fer
       Estableix LRC = (((LRC XOR 0xFF) + 1) I 0xFF)
       

Que es pot expressar com "el valor complementari dels dos dels 8 bits de la suma de tots els mòduls de 2 bytes ^8. "

Un LRC de 8 bits com aquest és l'equivalent d'una comprovació de redundància cíclica que utilitza el polinomi x ⁸ +1, però la independència del flux de dades és menys clara quan es veu d'aquesta manera.

Molts protocols utilitzen un mecanisme similar a la comprovació de redundància longitudinal (sovint anomenada caràcter de verificació o BCC), inclosa la norma IEC 62056-21 per a lectures elèctriques, targetes intel·ligents definides a ISO 7816 i protocols d’accés i gestió de dispositius (per exemple, ModBus ) .

C #

 /// <resum>
        /// Càlcul de la verificació de la redundància longitudinal (LRC) per a una matriu de bytes.
        /// Advertència: no es garanteix aquest codi. Comproveu i verifiqueu el codi abans d’utilitzar-lo.
        /// </summary>
        byte estàtic públic calculateLRC ( dades de bytes [] )
        {
            / * https://gist.github.com/953550
* http://ca.wikipedia.org/wiki/Longitudinal_redundancy_check
* /
            byte lrc = 0 x00 ;

            for ( int i = 0 ; i < data . Longitud ; i ++)
            {
                lrc ^ = data [ i ];
            }

            tornar lrc ;
        }

Java

 / **
* Calculeu el dígit de comprovació segons la norma ISO 1155
* Més informació: http://en.wikipedia.org/wiki/Longitudinal_redundancy_check
* matriu de dades @param per calcular el dígit de verificació de
* @return retorna el dígit calculat en format de bytes
* /
    byte públic calculateLRC ( dades de bytes [] ) {
        byte suma de comprovació = 0 ;
        for ( int i = 0 ; i <= data . length - 1 ; i ++ ) {
            suma de comprovació = ( byte ) (( suma de comprovació + dades [ i ] ) & 0xFF );
        }
        checksum = ( byte ) ((( checksum ^ 0xFF ) + 1 ) & 0xFF );
        retornar la suma de verificació ;
    }

C.

 unsigned char calculateLRC ( unsigned char * buf , unsigned int n ) {
 suma de verificació de caràcters sense signar = 0 ;
 while ( n > 0 ) {
  suma de comprovació + = * buf ++ ;
  n - ;
 }
 return (( ~ suma de comprovació ) + 1 );
}

Python

 '' '
Càlcul de la comprovació de la redundància longitudinal (LRC) per a una matriu de bytes.
'' '
def calculate_LRC ( data ):
    lrc = 0x00
    per a l' element de la data :
        lrc ^ = element

    tornar lrc

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