Verificação de redundância longitudinal (LRC)
Os nove bytes de 123456789 dão o byte de controle 31 em hexadecimal, 49 em decimal: cada byte é combinado com o ou exclusivo (XOR), a paridade por blocos mais simples ensinada em quadros seriais e no Modbus ASCII. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Texto
- 123456789
- Resultado
- 31
- Lrc
- 31
- Hex
- 31
- Decimal
- 49
Uma verificação de redundância longitudinal, muitas vezes abreviada LRC, é um trailer de integridade de um byte formado pela operação OR exclusivo de cada byte de uma mensagem. Tutoriais de trama serial, introduções a protocolos industriais e laboratórios de sala de aula sobre Modbus ASCII apresentam o LRC como a paridade de bloco mais simples que se pode calcular à mão: comece em zero, faça XOR do próximo byte no acumulador e, após o último byte, terá um valor de verificação que muda se qualquer bit de qualquer byte mudar um número ímpar de vezes naquele plano de bits. Engenheiros, estudantes e equipes de suporte precisam desse mesmo byte hex determinístico para cargas curtas sem instalar uma pilha de protocolos nem debater polinômios CRC. Esta ferramenta de verificação de redundância longitudinal aceita texto não vazio, codifica-o como UTF-8, executa o laço XOR puro e devolve o byte de verificação como dois dígitos hexadecimais em minúsculas junto com o valor decimal e um resumo breve.
O que o LRC calcula e por que o byte de verificação XOR importa
A verificação de redundância longitudinal trata uma mensagem como uma sequência de colunas de oito bits e calcula paridade par em cada coluna fazendo OR exclusivo de bytes sucessivos em um registrador de oito bits. Após o último byte, esse registrador é o LRC: um único byte de verificação geralmente escrito como dois dígitos hexadecimais. Diferente de uma verificação de redundância cíclica, não há polinômio gerador, nem tabela de deslocamento, nem opções de reflexão para configurar errado—apenas XOR sequencial.
Essa simplicidade explica por que o LRC aparece em lições de trama serial por blocos e em muitas descrições de campos de verificação de Modbus ASCII: é possível conferir um cálculo manual no quadro em segundos. Esta página usa sempre a definição XOR pura sobre os bytes UTF-8 do texto enviado, de modo que caracteres multi-byte contribuem com cada byte de unidade de código exatamente como um dispositivo embarcado faria se recebesse o mesmo fluxo UTF-8.
A resposta também ecoa o inteiro decimal, o rótulo de algoritmo LRC-XOR, a contagem de bytes UTF-8 e o texto original para que clientes exibam uma linha de auditoria completa sem recalcular metadados. Como o LRC não é resistente a colisões nem é chaveado, trate-o como verificação de trama ou de corrupção acidental, não como prova de autenticidade; prefira digests da família CRC ou SHA quando a intenção de busca for além de um trailer XOR de um byte.
Onde uma calculadora LRC agrega valor e como funciona o preço
Autores de firmware e estudantes de protocolos industriais usam uma calculadora de verificação de redundância longitudinal para conferir trailers XOR calculados à mão sem escrever um laço em cada linguagem. Plataformas de ensino e plugins LMS precisam de um oráculo determinístico que rejeite entrada vazia em vez de devolver zero para a mensagem vazia, para que autoavaliadores distinga respostas ausentes de uma verificação real de zero.
Sites de conteúdo que concorrem por verificação de redundância longitudinal ou calculadora LRC se beneficiam de uma ferramenta ao vivo cujo caminho gratuito coincide byte a byte com a automação paga no mesmo módulo puro. Falhas de validação nunca consomem saldo após a rejeição. Combine com landings de CRC-8, CRC-16 ou hash criptográfico apenas quando a intenção de busca for além de uma verificação de trama XOR de oito bits—mantenha esta página focada no LRC como XOR de todos os bytes para que a intenção SEO permaneça nítida.
Casos de uso
Trama serial e laboratórios de protocolo
Verifique se uma string de carga produz o trailer LRC de um byte esperado sob XOR sequencial antes de comparar logs de dispositivo ou vetores de teste unitário.
Demonstrações de LRC em sala de aula
Professores mostram a verificação clássica da string de dígitos e deixam os alunos recalcularem outras strings curtas sem instalar uma biblioteca de protocolo.
Perguntas frequentes
Qual algoritmo esta ferramenta LRC usa?
XOR sequencial puro de todos os bytes UTF-8 (LRC-XOR). Comece em zero, faça OR exclusivo de cada byte e mantenha os oito bits baixos. O resultado é um byte de verificação em hex minúsculas.
O que acontece se o texto estiver vazio?
Uma string não vazia é obrigatória; entrada vazia não é tratada como verificação zero bem-sucedida.
A calculadora de verificação de redundância longitudinal é grátis?
A ferramenta do navegador roda grátis no seu dispositivo.
LRC é o mesmo que CRC-8?
Não. Aqui o LRC é um XOR simples de todos os bytes. CRC-8 divide por um polinômio com passos de deslocamento e XOR. Use a landing CRC-8 se precisar de poli 0x07; use esta página para LRC XOR.
Como calcular um LRC à mão?
Comece em zero e combine com XOR cada byte da mensagem com o valor acumulado, um após o outro. Depois do último byte, esse valor é o LRC, normalmente escrito com dois dígitos hexadecimais; para 123456789 ele é 31.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
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)Exemplo de requisição
{
"text": "123456789"
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.lrc",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
A entrada vazia é rejeitada com invalid_input para que quem chama não confunda um campo ausente com uma verificação zero real.
Contrato de entrada, erros de string vazia e formato da resposta JSON
Fixe tanto um caminho de sucesso quanto um erro de entrada vazia na integração contínua para que mudanças acidentais de algoritmo não passem despercebidas. Campos opcionais nulos são omitidos em vez de emitidos como null, conforme o contrato do renderizador declarativo para formulários web limpos. Envie por POST um corpo JSON com um único campo de string obrigatório chamado text: qualquer sequência não vazia de caracteres que deseja proteger com um LRC. Os aliases input, value, s, data, message e payload são aceitos para o mesmo campo, para que stubs de SDK e envios de formulário permaneçam flexíveis. A string é codificada como UTF-8 antes do laço XOR. text ausente, valor que não é string ou string vazia falham com invalid_input e uma mensagem clara de que uma string não vazia é obrigatória; essas falhas não são cobradas na API pré-paga. Em caso de sucesso o corpo inclui result, lrc e hex todos com o mesmo byte de verificação hexadecimal de dois dígitos em minúsculas; decimal com o inteiro de zero a duzentos e cinquenta e cinco; algorithm fixo em LRC-XOR; input_bytes igual ao comprimento UTF-8; text ecoando a entrada; e message resumindo a contagem de bytes e o resultado hex.
Onde uma calculadora LRC agrega valor e como funciona o preço
Use a ferramenta gratuita no navegador para checagens pontuais; chame a API pré-paga do KIT a partir de backends, funções serverless e SDKs quando precisar de um contrato estável sob saldo a US$ 0,002 por item bem-sucedido. Mantenha as cargas em tamanhos de texto ordinários adequados a uma chamada de item em um Worker isolate; esta ferramenta é para strings curtas e trechos de protocolo, não para blobs binários de vários megabytes.
Casos de integração
Fixtures CI para código de trama
Pipelines fixam saídas hex LRC determinísticas e o erro de entrada vazia para que mudanças acidentais de algoritmo falhem rápido.
Perguntas técnicas
Como calcular uma verificação de redundância longitudinal de um texto?
Envie JSON com um campo de string não vazio text. A API codifica a string em UTF-8, faz XOR de cada byte em um registrador de oito bits e devolve o byte de verificação como dois dígitos hex em minúsculas em result, lrc e hex.