ForHosting KIT · Ferramentas para dev

Calculadora CRC-16 XMODEM

Os nove caracteres 123456789 dão o valor CRC-16/XMODEM 31c3, ou 12739 em decimal, o resultado de verificação documentado do perfil CCITT com início em zero usado em transferência clássica de arquivos e firmware. Cole qualquer texto para obter o checksum. 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: 31c3
Crc16: 31c3
Hex: 31c3
Decimal: 12.739

CRC-16/XMODEM é um controle de redundância cíclica de dezesseis bits usado no enquadramento clássico de transferência de arquivos, firmware embarcado e pilhas de protocolo que precisam de uma palavra compacta 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 gerador CCITT 0x1021, registrador inicial zero (a semente XMODEM), sem reflexão de bits e XOR final zero—exatamente o perfil CRC-16/XMODEM cujo valor de verificação para os dígitos ASCII de um a nove é 31C3 em hexadecimal. Esta ferramenta de checksum CRC-16 XMODEM aceita texto não vazio, codifica-o como UTF-8, executa esse laço determinístico de deslocamento e XOR e devolve o checksum de dezesseis bits como quatro dígitos hexadecimais em minúsculas junto com o valor decimal e um resumo breve.

O que o CRC-16/XMODEM com polinômio 0x1021 calcula e por que a palavra 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 vira o checksum. No CRC-16 o resto tem dezesseis bits de largura, de modo que o resultado inteiro cabe em uma palavra e se escreve naturalmente como quatro dígitos hexadecimais.

O gerador usado pelo XMODEM e por muitos exemplos no estilo CCITT é 0x1021, que se expande em x à décima sexta mais x à décima segunda mais x à quinta mais um. De forma crítica, o perfil XMODEM semeia o registrador com zero em vez de todos uns; essa única escolha separa CRC-16/XMODEM de CRC-16/CCITT-FALSE, que usa o mesmo poli mas init 0xFFFF e portanto valores de verificação diferentes para a mesma carga.

Em software a divisão é feita com OR exclusivo de cada byte de entrada nos oito bits altos de um registrador de dezesseis bits e deslocamento à esquerda oito vezes, aplicando OR exclusivo com o gerador quando o bit alto está 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 é 31C3.

A resposta também ecoa o inteiro decimal, a string de polinômio 0x1021, o rótulo de algoritmo CRC-16/XMODEM, a contagem de bytes UTF-8 e o texto original para que os clientes exibam uma linha de auditoria completa sem recalcular metadados. Como CRC-16 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 e não um CRC de dois bytes.

Onde um checksum CRC-16 XMODEM é útil

Autores de firmware e estudantes de protocolos seriais usam uma calculadora de checksum CRC-16 XMODEM para verificar restos calculados à mão contra o polinômio CCITT com semente zero 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 CRC-16 XMODEM, calculadora CRC16 XMODEM ou checksum poli CCITT 0x1021 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-32 ou hash criptográfico somente quando a intenção de busca for além de uma verificação de enquadramento XMODEM de dezesseis bits—mantenha esta página focada em CRC-16/XMODEM com poli 0x1021 e semente zero para que a intenção SEO permaneça nítida e não colida com variantes MODBUS, IBM ou CCITT-FALSE que compartilham o nome da família mas não o mesmo vetor de verificação.

Casos de uso

Verificações XMODEM e protocolos seriais

Verifique se uma string de carga produz o trailer CRC-16/XMODEM de dezesseis bits esperado sob o poli 0x1021 e init zero 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 → 31C3 e deixam os alunos recalcular outras strings curtas sem instalar uma biblioteca CRC.

Perguntas frequentes

Quais parâmetros CRC-16 esta ferramenta usa?

CRC-16/XMODEM: poli 0x1021 (CCITT), init 0x0000, sem reflexão, xorout 0x0000. O valor de verificação documentado para ASCII 123456789 é 31C3.

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-16 XMODEM é gratuita?

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

CRC-16/XMODEM é o mesmo que CRC-16/CCITT-FALSE?

Não. Ambos usam o poli 0x1021, mas o XMODEM semeia o registrador com zero enquanto o CCITT-FALSE usa 0xFFFF, de modo que os valores de verificação diferem. Esta ferramenta implementa apenas XMODEM.

Como são contados letras acentuadas e outros caracteres fora do ASCII?

O texto é codificado em UTF-8 antes do cálculo, então um caractere que ocupa vários bytes entra com todos eles, exatamente como um dispositivo embarcado veria se recebesse a mesma sequência UTF-8.

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

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

const res = await fetch("https://api.kit.forhosting.com/enc/crc16-xmodem", {
  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/crc16-xmodem",
    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/crc16-xmodem", 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/crc16-xmodem", 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.crc16_xmodem",
  "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 não confunda um campo ausente com um checksum zero real.

Contrato de entrada, erros de string vazia e formato da resposta JSON

A string é codificada como UTF-8 antes do laço CRC, de forma que caracteres multibyte contribuem com cada byte de unidade de código exatamente como faria um dispositivo embarcado se recebesse o mesmo fluxo UTF-8. 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, 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 você queira verificar. Os aliases input, value, s, data, message e payload são aceitos para o mesmo campo, de modo que stubs de SDK e envios de formulário permaneçam flexíveis. Se text estiver ausente, o valor não for string ou a string estiver vazia, a requisição falha com invalid_input e uma mensagem clara de que se exige uma string não vazia; essas falhas não são cobradas na API pré-paga. Em caso de sucesso o corpo inclui result, crc16 e hex todos com o mesmo checksum hexadecimal de quatro dígitos em minúsculas; decimal com o inteiro de zero a sessenta e cinco mil quinhentos e trinta e cinco; polynomial fixo em 0x1021; algorithm fixo em CRC-16/XMODEM; input_bytes igual ao comprimento UTF-8; text ecoando a entrada; e message resumindo a contagem de bytes e o resultado hex. 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 binários de vários megabytes.

Onde uma API de checksum CRC-16 XMODEM agrega valor e como funciona o preço

Use a ferramenta gratuita no navegador para checagens 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.

Casos de integração

Fixtures de CI para código de enquadramento

Pipelines fixam saídas hex determinísticas de CRC-16/XMODEM e o erro de entrada vazia para que mudanças acidentais de poly ou init falhem rápido.

Perguntas técnicas

Como calcular um checksum CRC-16 XMODEM de texto?

Envie JSON com um campo de string não vazio text. A API codifica a string em UTF-8, executa CRC-16/XMODEM com polinômio 0x1021 e init 0x0000 e devolve a palavra como quatro dígitos hex em minúsculas em result, crc16 e hex.

Ver a documentação completa do KIT →

Executar grátis