ForHosting KIT · Outils pour développeurs

Checksum CRC-16 XMODEM

Les neuf caractères 123456789 donnent la valeur CRC-16/XMODEM 31c3, soit 12739 en décimal, le résultat de contrôle documenté du profil CCITT à départ nul utilisé en transfert de fichiers classique et en firmware. Collez un texte pour obtenir sa somme. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

Texte: 123456789

Vous obtenez

Résultat: 31c3
Crc16: 31c3
Hex: 31c3
Décimal: 12 739

CRC-16/XMODEM est un contrôle de redondance cyclique sur seize bits utilisé dans le cadrage classique de transfert de fichiers, le micrologiciel embarqué et les piles de protocoles qui ont besoin d'un mot d'intégrité compact plutôt que d'un hachage cryptographique complet. Ingénieurs, étudiants et équipes de support ont souvent besoin du même résultat de manuel pour une chaîne courte : le polynôme générateur CCITT 0x1021, registre initial à zéro (la graine XMODEM), sans réflexion de bits et XOR final à zéro—exactement le profil CRC-16/XMODEM dont la valeur de contrôle pour les chiffres ASCII de un à neuf est 31C3 en hexadécimal. Cet outil de checksum CRC-16 XMODEM accepte un texte non vide, l'encode en UTF-8, exécute cette boucle déterministe de décalage et de XOR et renvoie le checksum de seize bits sous la forme de quatre chiffres hexadécimaux en minuscules, avec la valeur décimale et un court résumé.

Ce que calcule le CRC-16/XMODEM avec le polynôme 0x1021 et pourquoi le mot hex compte

Un contrôle de redondance cyclique traite le message comme un polynôme sur le corps de Galois à deux éléments et le divise par un polynôme générateur fixe, laissant un reste qui devient le checksum. Pour le CRC-16 le reste fait seize bits de large, de sorte que le résultat entier tient dans un mot et s'écrit naturellement sous quatre chiffres hexadécimaux.

Le générateur utilisé par XMODEM et de nombreux exemples de style CCITT est 0x1021, qui se développe en x à la seizième plus x à la douzième plus x à la cinquième plus un. De façon critique, le profil XMODEM initialise le registre à zéro plutôt qu'à tous les uns ; ce seul choix sépare CRC-16/XMODEM de CRC-16/CCITT-FALSE, qui utilise le même poly mais init 0xFFFF et donc des valeurs de contrôle différentes pour la même charge utile.

En logiciel la division s'effectue en exclusif-OU de chaque octet d'entrée dans les huit bits de poids fort d'un registre de seize bits puis en décalant à gauche huit fois, avec exclusif-OU du générateur lorsque le bit de poids fort est positionné. Cette page utilise toujours cet algorithme non réfléchi avec valeur initiale zéro et XOR final zéro, le profil dont la valeur de contrôle documentée pour la chaîne ASCII de neuf octets un deux trois quatre cinq six sept huit neuf est 31C3.

La réponse reprend aussi l'entier décimal, la chaîne de polynôme 0x1021, l'étiquette d'algorithme CRC-16/XMODEM, le nombre d'octets UTF-8 et le texte d'origine afin que les clients affichent une ligne d'audit complète sans recalculer les métadonnées. Comme le CRC-16 n'est ni résistant aux collisions ni muni d'une clé, traitez-le comme un contrôle de cadrage ou de corruption accidentelle, non comme une preuve d'authenticité ; préférez les digests de la famille SHA lorsque l'intention de recherche est le hachage cryptographique plutôt qu'un CRC de deux octets.

Où une somme CRC-16 XMODEM est utile

Les auteurs de micrologiciel et les étudiants en protocoles série utilisent un calculateur de checksum CRC-16 XMODEM pour vérifier des restes calculés à la main contre le polynôme CCITT à graine zéro sans écrire une boucle de décalage dans chaque langage. Les plateformes d'enseignement et les plugins LMS ont besoin d'un oracle déterministe qui rejette l'entrée vide au lieu de renvoyer zéro pour le message vide, afin que les auto-correcteurs distinguent les réponses manquantes d'un vrai checksum nul.

Les sites de contenu qui se positionnent sur CRC-16 XMODEM, calculateur CRC16 XMODEM ou checksum poly CCITT 0x1021 bénéficient d'un outil en direct dont le chemin gratuit correspond octet pour octet au chemin d'automatisation payant sur le même module pur. Les échecs de validation ne consomment jamais le solde après rejet.

Associez aux landings CRC-8, CRC-32 ou hachage cryptographique uniquement lorsque l'intention de recherche dépasse un contrôle de cadrage XMODEM sur seize bits—gardez cette page centrée sur CRC-16/XMODEM à poly 0x1021 et graine zéro pour que l'intention SEO reste nette et n'entre pas en collision avec les variantes MODBUS, IBM ou CCITT-FALSE qui partagent un nom de famille mais pas le même vecteur de contrôle.

Cas d’usage

Contrôles XMODEM et protocoles série

Vérifiez qu'une chaîne de charge produit la remorque CRC-16/XMODEM de seize bits attendue sous le poly 0x1021 et init zéro avant de comparer des journaux d'appareil ou des vecteurs de tests unitaires.

Démonstrations de reste CRC en classe

Les enseignants montrent la valeur classique 123456789 → 31C3 et laissent les étudiants recalculer d'autres chaînes courtes sans installer une bibliothèque CRC.

Questions fréquentes

Quels paramètres CRC-16 cet outil utilise-t-il ?

CRC-16/XMODEM : poly 0x1021 (CCITT), init 0x0000, sans réflexion, xorout 0x0000. La valeur de contrôle documentée pour ASCII 123456789 est 31C3.

Que se passe-t-il si le texte est vide ?

Une chaîne non vide est requise ; l'entrée vide n'est pas traitée comme un checksum nul réussi.

CRC-16/XMODEM est-il identique à CRC-16/CCITT-FALSE ?

Non. Les deux utilisent le poly 0x1021, mais XMODEM initialise le registre à zéro tandis que CCITT-FALSE utilise 0xFFFF, donc les valeurs de contrôle diffèrent. Cet outil n'implémente que XMODEM.

Comment les lettres accentuées et autres caractères non ASCII sont-ils comptés ?

Le texte est encodé en UTF-8 avant le calcul : un caractère qui occupe plusieurs octets apporte chacun d'eux, exactement comme le verrait un appareil embarqué recevant le même flux UTF-8.

Une somme CRC-16 XMODEM prouve-t-elle qu'un fichier est authentique ?

Non. Ce contrôle sur deux octets n'est ni résistant aux collisions ni protégé par une clé ; il détecte surtout les erreurs accidentelles. Si vous cherchez une vraie empreinte cryptographique, tournez-vous vers la famille SHA.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/enc/crc16-xmodem

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

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)

Exemple de requête

{
  "text": "123456789"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "enc.crc16_xmodem",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

L'entrée vide est rejetée avec invalid_input afin que les appelants ne confondent jamais un champ manquant avec un vrai checksum nul.

Contrat d'entrée, erreurs de chaîne vide et forme de la réponse JSON

La chaîne est encodée en UTF-8 avant la boucle CRC, de sorte que les caractères multi-octets contribuent chaque octet d'unité de code exactement comme le ferait un appareil embarqué recevant le même flux UTF-8. Épinglez à la fois un chemin de succès et une erreur d'entrée vide dans l'intégration continue pour qu'un changement accidentel de poly ou d'init ne puisse pas passer inaperçu. Les champs optionnels nuls sont omis plutôt qu'émis comme null, conformément au contrat du rendu déclaratif pour des formulaires web propres. Envoyez en POST un corps JSON avec un unique champ chaîne obligatoire nommé text : toute séquence non vide de caractères que vous souhaitez contrôler. Les alias input, value, s, data, message et payload sont acceptés pour le même champ afin que les stubs SDK et les envois de formulaire restent souples. Si text est absent, si la valeur n'est pas une chaîne ou si la chaîne est vide, la requête échoue avec invalid_input et un message clair indiquant qu'une chaîne non vide est requise ; ces échecs ne sont pas facturés sur l'API prépayée. En cas de succès le corps inclut result, crc16 et hex tous fixés au même checksum hexadécimal de quatre chiffres en minuscules ; decimal égal à l'entier de zéro à soixante-cinq mille cinq cent trente-cinq ; polynomial fixé à 0x1021 ; algorithm fixé à CRC-16/XMODEM ; input_bytes égal à la longueur UTF-8 ; text reprenant l'entrée ; et message résumant le nombre d'octets et le résultat hex. Gardez les charges à des tailles de texte ordinaires adaptées à un appel d'item dans un Worker isolate ; cet outil est destiné aux chaînes courtes et aux extraits de protocole, pas aux binaires de plusieurs mégaoctets.

Où une API de checksum CRC-16 XMODEM apporte de la valeur et comment fonctionne le prix

Appelez l'outil gratuit dans le navigateur pour des contrôles ponctuels ; appelez l'API prépayée KIT depuis des backends, des fonctions serverless et des SDK lorsque vous avez besoin d'un contrat stable sous solde à $0.002 par item réussi.

Cas d'intégration

Fixtures CI pour le code de cadrage

Les pipelines épinglent des sorties hex déterministes CRC-16/XMODEM et l'erreur d'entrée vide pour que les changements accidentels de poly ou d'init échouent rapidement.

Questions techniques

Comment calculer un checksum CRC-16 XMODEM de texte ?

Envoyez un JSON avec un champ chaîne non vide text. L'API encode la chaîne en UTF-8, exécute CRC-16/XMODEM avec polynôme 0x1021 et init 0x0000, et renvoie le mot sous quatre chiffres hex en minuscules dans result, crc16 et hex.

Le calculateur de checksum CRC-16 XMODEM est-il gratuit ?

L'outil navigateur s'exécute gratuitement sur votre appareil. Les appels API utilisent le solde prépayé KIT à $0.002 par item réussi ; les échecs de validation ne sont pas facturés.

Consulter la documentation complète du KIT →

Lancer gratuitement