Control de redundancia longitudinal (LRC)
Los nueve bytes de 123456789 dan el byte de control 31 en hexadecimal, 49 en decimal: cada byte se combina con el o exclusivo (XOR), la paridad por bloques más simple que se enseña en tramas serie y en Modbus ASCII. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Ejemplo resuelto
- Texto
- 123456789
- Resultado
- 31
- Lrc
- 31
- Hex
- 31
- Decimal
- 49
Un control de redundancia longitudinal, a menudo abreviado LRC, es un tráiler de integridad de un byte formado haciendo OR exclusivo de cada byte de un mensaje. Los tutoriales de trama serie, las introducciones a protocolos industriales y los laboratorios de aula sobre Modbus ASCII presentan el LRC como la paridad de bloque más simple que se puede calcular a mano: parta de cero, aplique XOR del siguiente byte al acumulador y, tras el último byte, tendrá un valor de control que cambia si cualquier bit de cualquier byte cambia un número impar de veces en ese plano de bits. Ingenieros, estudiantes y equipos de soporte necesitan ese mismo byte hex determinista para cargas cortas sin instalar una pila de protocolos ni debatir polinomios CRC. Esta herramienta de control de redundancia longitudinal acepta texto no vacío, lo codifica como UTF-8, ejecuta el bucle XOR puro y devuelve el byte de control como dos dígitos hexadecimales en minúsculas junto con el valor decimal y un resumen breve.
Qué calcula el LRC y por qué importa el byte de control XOR
El control de redundancia longitudinal trata un mensaje como una secuencia de columnas de ocho bits y calcula paridad par en cada columna haciendo OR exclusivo de bytes sucesivos en un registro de ocho bits. Tras el último byte, ese registro es el LRC: un único byte de control que suele escribirse como dos dígitos hexadecimales. A diferencia de un control de redundancia cíclica, no hay polinomio generador, ni tabla de desplazamientos, ni opciones de reflexión que se puedan malconfigurar—solo XOR secuencial.
Esa simplicidad explica por qué el LRC aparece en lecciones de trama serie por bloques y en muchas descripciones de campos de control de Modbus ASCII: se puede verificar un cálculo a mano en una pizarra en segundos. Esta página usa siempre la definición XOR pura sobre los bytes UTF-8 del texto enviado, de modo que los caracteres multibyte aportan cada byte de unidad de código exactamente como lo haría un dispositivo embebido si recibiera el mismo flujo UTF-8.
La respuesta también repite el entero decimal, la etiqueta de algoritmo LRC-XOR, el recuento de bytes UTF-8 y el texto original para que los clientes muestren una línea de auditoría completa sin recalcular metadatos. Como el LRC no es resistente a colisiones ni lleva clave, trátelo como comprobación de trama o de corrupción accidental, no como prueba de autenticidad; prefiera digests de la familia CRC o SHA cuando la intención de búsqueda vaya más allá de un tráiler XOR de un byte.
Dónde aporta valor una calculadora LRC y cómo funciona el precio
Autores de firmware y estudiantes de protocolos industriales usan una calculadora de control de redundancia longitudinal para verificar tráilers XOR calculados a mano sin escribir un bucle en cada lenguaje. Las plataformas educativas y los plugins LMS necesitan un oráculo determinista que rechace la entrada vacía en lugar de devolver cero para el mensaje vacío, de modo que los autoevaluadores distingan respuestas ausentes de un control real de cero.
Los sitios de contenido que compiten por control de redundancia longitudinal o calculadora LRC se benefician de una herramienta en vivo cuya ruta gratuita coincide byte a byte con la automatización de pago sobre el mismo módulo puro. Los fallos de validación no consumen saldo tras el rechazo.
Combine con landings de CRC-8, CRC-16 o hash criptográfico solo cuando la intención de búsqueda vaya más allá de una comprobación de trama XOR de ocho bits—mantenga esta página centrada en el LRC como XOR de todos los bytes para que la intención SEO siga nítida.
Qué puede hacer con ella
Trama serie y laboratorios de protocolo
Verifique que una cadena de carga produce el tráiler LRC de un byte esperado bajo XOR secuencial antes de comparar logs de dispositivo o vectores de prueba unitaria.
Demostraciones de LRC en el aula
El profesorado muestra la comprobación clásica de la cadena de dígitos y deja que el alumnado recalcule otras cadenas cortas sin instalar una biblioteca de protocolo.
Preguntas frecuentes
¿Qué algoritmo usa esta herramienta LRC?
XOR secuencial puro de todos los bytes UTF-8 (LRC-XOR). Parta de cero, haga OR exclusivo de cada byte y conserve los ocho bits bajos. El resultado es un byte de control en hex minúsculas.
¿Qué ocurre si el texto está vacío?
Se exige una cadena no vacía; la entrada vacía no se trata como un control cero exitoso.
¿La calculadora de control de redundancia longitudinal es gratuita?
La herramienta del navegador se ejecuta gratis en su dispositivo.
¿El LRC es lo mismo que CRC-8?
No. Aquí el LRC es un XOR simple de todos los bytes. CRC-8 divide por un polinomio con pasos de desplazamiento y XOR. Use la landing CRC-8 si necesita poli 0x07; use esta página para LRC XOR.
¿Cómo se calcula un LRC a mano?
Empiece en cero y combine con XOR cada byte del mensaje con el valor acumulado, uno tras otro. Tras el último byte, ese valor es el LRC, que suele escribirse con dos cifras hexadecimales; para 123456789 es 31.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su stack
curl -X POST https://api.kit.forhosting.com/enc/lrc \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"123456789"}'const res = await fetch("https://api.kit.forhosting.com/enc/lrc", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "123456789"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/lrc",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "123456789"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/lrc", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"123456789"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"123456789"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/lrc", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Ejemplo de solicitud
{
"text": "123456789"
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.lrc",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
La entrada vacía se rechaza con invalid_input para que quien llame no confunda un campo ausente con un control cero real.
Contrato de entrada, errores de cadena vacía y forma de la respuesta JSON
La cadena se codifica como UTF-8 antes del bucle XOR. Fije tanto una ruta de éxito como un error de entrada vacía en la integración continua para que cambios accidentales de algoritmo no pasen desapercibidos. Los campos opcionales nulos se omiten en lugar de emitirse como null, acorde al contrato del renderizador declarativo para formularios web limpios. Envíe por POST un cuerpo JSON con un único campo de cadena obligatorio llamado text: cualquier secuencia no vacía de caracteres que desee proteger con un LRC. Se aceptan los alias input, value, s, data, message y payload para el mismo campo, de modo que los stubs de SDK y los envíos de formulario sigan siendo flexibles. Si falta text, el valor no es una cadena o la cadena está vacía, la petición falla con invalid_input y un mensaje claro de que se exige una cadena no vacía; esos fallos no se facturan en la API prepago. En caso de éxito el cuerpo incluye result, lrc y hex todos con el mismo byte de control hexadecimal de dos dígitos en minúsculas; decimal con el entero de cero a doscientos cincuenta y cinco; algorithm fijo en LRC-XOR; input_bytes igual a la longitud UTF-8; text repitiendo la entrada; y message resumiendo el recuento de bytes y el resultado hex.
Dónde aporta valor una calculadora LRC y cómo funciona el precio
Use la herramienta gratuita en el navegador para comprobaciones puntuales; use la API prepago de KIT desde backends, funciones serverless y SDK cuando necesite un contrato estable bajo saldo a $0.002 por ítem exitoso. Mantenga las cargas en tamaños de texto ordinarios adecuados a una llamada de ítem en un Worker isolate; esta herramienta es para cadenas cortas y fragmentos de protocolo, no para binarios de varios megabytes.
Casos de integración
Fixtures CI para código de trama
Los pipelines fijan salidas hex LRC deterministas y el error de entrada vacía para que los cambios accidentales de algoritmo fallen de inmediato.
Preguntas técnicas
¿Cómo se calcula un control de redundancia longitudinal de un texto?
Envíe JSON con un campo de cadena no vacío text. La API codifica la cadena en UTF-8, hace XOR de cada byte en un registro de ocho bits y devuelve el byte de control como dos dígitos hex en minúsculas en result, lrc y hex.