ForHosting KIT · Ferramentas para dev

Calculadora CRC-8

Os nove caracteres 123456789 dão o valor CRC-8 f4, ou 244 em decimal, a verificação documentada do perfil SMBus com polinômio 07, então você pode conferir um frame de barramento ou um exercício de livro. Cole qualquer texto para obter o checksum de um byte. Grátis no seu navegador.

Grátis
Funciona no seu navegador
Sem cadastro
Seus dados não saem do seu aparelho

Executar grátis Ver a API

Use pelo WebAPIE-mailTelegramApp em breve

Exemplo resolvido

Se você digitar

Texto: 123456789

Você obtém

Resultado: f4
Crc8: f4
Hex: f4
Decimal: 244

CRC-8 é um controle de redundância cíclica de oito bits usado em barramentos embarcados, protocolos de enquadramento simples e material didático que precisa de um byte compacto de integridade em vez de um hash criptográfico completo. Engenheiros, estudantes e equipes de suporte costumam precisar do mesmo resultado de livro para uma string curta: o polinômio padrão 0x07 (x à oitava mais x ao quadrado mais x mais um), registrador inicial zero, sem reflexão de bits e XOR final zero—exatamente o perfil CRC-8/SMBus cujo valor de verificação para os dígitos ASCII de um a nove é F4 em hexadecimal. Esta ferramenta de checksum CRC-8 aceita texto não vazio, codifica-o como UTF-8, executa esse laço determinístico de deslocamento e XOR e devolve o único byte de checksum como dois dígitos hexadecimais em minúsculas junto com o valor decimal e um resumo breve.

O que o CRC-8 com polinômio 0x07 calcula e por que o byte hex importa

Um controle de redundância cíclica trata a mensagem como um polinômio sobre o corpo de Galois de dois elementos e a divide por um polinômio gerador fixo, deixando um resto que se torna o checksum. No CRC-8 o resto tem apenas oito bits de largura, de modo que o resultado inteiro cabe em um byte e se escreve de forma natural como dois dígitos hexadecimais.

O gerador padrão usado pelo SMBus, por muitos exemplos no estilo HEC de ATM e pela maioria das demos CRC-8 online é 0x07, que se expande em x à oitava mais x ao quadrado mais x mais um. Em software a divisão é feita com OR exclusivo de cada byte de entrada em um registrador de oito bits e deslocamento à esquerda oito vezes, aplicando OR exclusivo com o gerador sempre que o bit alto estiver ativo.

Esta página usa sempre esse algoritmo não refletido com valor inicial zero e XOR final zero, o perfil cujo valor de verificação documentado para a string ASCII de nove bytes um dois três quatro cinco seis sete oito nove é F4. A resposta também ecoa o inteiro decimal, a string de polinômio 0x07, o rótulo de algoritmo CRC-8, a contagem de bytes UTF-8 e o texto original para que os clientes exibam uma linha de auditoria completa sem recalcular metadados.

Como o CRC-8 não é resistente a colisões nem possui chave, trate-o como verificação de enquadramento ou de corrupção acidental, não como prova de autenticidade; prefira digests da família SHA quando a intenção de busca for hashing criptográfico em vez de um CRC de um byte.

Onde um checksum CRC-8 de um byte faz sentido

Autores de firmware e estudantes de protocolos de barramento usam uma calculadora de checksum CRC-8 para verificar restos calculados à mão contra o polinômio estilo SMBus sem escrever um laço de deslocamento 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 distingam respostas ausentes de um checksum real de zero.

Sites de conteúdo que competem por checksum CRC-8 ou calculadora CRC8 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-32 ou hash criptográfico apenas quando a intenção de busca for além de uma verificação de enquadramento de oito bits—mantenha esta página focada no CRC-8 com poli padrão 0x07 para que a intenção de SEO continue nítida.

Casos de uso

Verificações SMBus e protocolos embarcados

Confirme que uma string de carga produz o trailer CRC-8 de um byte esperado sob o poli 0x07 antes de comparar logs de dispositivo ou vetores de teste unitário.

Demonstrações de resto CRC em sala de aula

Professores mostram o valor clássico 123456789 → F4 e permitem que alunos recalculem outras strings curtas sem instalar uma biblioteca CRC.

Perguntas frequentes

Qual polinômio CRC-8 esta ferramenta usa?

O poli padrão 0x07 (CRC-8/SMBus): init 0x00, sem reflexão, xorout 0x00. A verificação documentada para ASCII 123456789 é F4.

O que acontece se o texto estiver vazio?

Uma string não vazia é obrigatória; entrada vazia não é tratada como checksum zero bem-sucedido.

A calculadora de checksum CRC-8 é gratuita?

A ferramenta do navegador roda grátis no seu dispositivo.

CRC-8 é um hash criptográfico?

Não. CRC-8 é uma verificação de integridade de oito bits para enquadramento e corrupção acidental. Use SHA-256 ou similar quando precisar de resistência a colisões ou autenticação.

Onde este perfil CRC-8 é usado?

O polinômio 07 com início em zero é o gerador do SMBus, de muitos exemplos de verificação de cabeçalho ATM e da maioria das demonstrações de CRC-8 online. Serve para barramentos embarcados, protocolos de quadros simples e material didático.

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

POSThttps://api.kit.forhosting.com/enc/crc8

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/crc8 \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"123456789"}'

const res = await fetch("https://api.kit.forhosting.com/enc/crc8", {
  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/crc8",
    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/crc8", 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/crc8", 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.crc8",
  "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

por chamadaUS$ 0,002

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 nunca confunda um campo ausente com um checksum zero real.

Contrato de entrada, erros de string vazia e forma 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 poly ou init não passem despercebidas. Campos opcionais nulos são omitidos em vez de emitidos como null, alinhados ao 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 você deseja verificar. 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 CRC, 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. 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, crc8 e hex todos com o mesmo checksum hexadecimal de dois dígitos em minúsculas; decimal com o inteiro de zero a duzentos e cinquenta e cinco; polynomial fixo em 0x07; algorithm fixo em CRC-8; input_bytes igual ao comprimento UTF-8; text ecoando a entrada; e message resumindo a contagem de bytes e o resultado hex.

Onde uma API de checksum CRC-8 se paga e como funciona o preço

Use a ferramenta gratuita no navegador para verificações pontuais; use 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 de CI para código de enquadramento

Pipelines fixam saídas hex CRC-8 determinísticas e o erro de entrada vazia para que mudanças acidentais de poly ou init falhem de imediato.

Perguntas técnicas

Como calcular um checksum CRC-8 de um texto?

Envie JSON com um campo de string não vazio text. A API codifica a string em UTF-8, executa CRC-8 com polinômio 0x07 e devolve o byte como dois dígitos hex em minúsculas em result, crc8 e hex.

Ver a documentação completa do KIT →

Executar grátis