Calculateur CRC-8
Les neuf caractères 123456789 donnent la valeur CRC-8 f4, soit 244 en décimal, le contrôle documenté du profil SMBus au polynôme 07 : vous pouvez vérifier une trame de bus ou un exercice de manuel. Collez un texte pour obtenir sa somme sur un octet. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Texte
- 123456789
- Résultat
- f4
- Crc8
- f4
- Hex
- f4
- Décimal
- 244
Le CRC-8 est un contrôle de redondance cyclique sur huit bits utilisé dans les bus embarqués, les protocoles de trame simples et le matériel pédagogique qui a besoin d'un octet 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 standard 0x07 (x à la huitième plus x au carré plus x plus un), registre initial à zéro, sans réflexion de bits et XOR final à zéro—exactement le profil CRC-8/SMBus dont la valeur de contrôle pour les chiffres ASCII de un à neuf est F4 en hexadécimal. Cet outil de checksum CRC-8 accepte un texte non vide, l'encode en UTF-8, exécute cette boucle déterministe de décalage et de XOR et renvoie l'unique octet de checksum sous la forme de deux chiffres hexadécimaux en minuscules, avec la valeur décimale et un court résumé.
Ce que calcule le CRC-8 avec le polynôme 0x07 et pourquoi l'octet 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, en laissant un reste qui devient le checksum. Pour le CRC-8 le reste n'a que huit bits de large, de sorte que le résultat entier tient dans un octet et s'écrit naturellement en deux chiffres hexadécimaux.
Le générateur standard utilisé par SMBus, de nombreux exemples de style HEC ATM et la plupart des démos CRC-8 en ligne est 0x07, qui se développe en x à la huitième plus x au carré plus x plus un. En logiciel la division s'effectue en faisant un OU exclusif de chaque octet d'entrée dans un registre de huit bits puis en décalant à gauche huit fois, avec OU exclusif du générateur chaque fois que 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 F4. La réponse reprend aussi l'entier décimal, la chaîne de polynôme 0x07, l'étiquette d'algorithme CRC-8, le nombre d'octets UTF-8 et le texte d'origine pour que les clients affichent une ligne d'audit complète sans recalculer les métadonnées.
Comme le CRC-8 n'est ni résistant aux collisions ni muni d'une clé, traitez-le comme un contrôle de trame 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 d'un octet.
Où un contrôle CRC-8 sur un octet a du sens
Les auteurs de microprogrammes et les étudiants en protocoles de bus utilisent un calculateur de checksum CRC-8 pour vérifier des restes calculés à la main contre le polynôme de style SMBus 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 correcteurs automatiques distinguent une réponse manquante d'un vrai checksum à zéro.
Les sites de contenu qui se positionnent sur checksum CRC-8 ou calculatrice CRC8 bénéficient d'un outil vivant dont le parcours gratuit correspond octet pour octet à l'automatisation payante sur le même module pur. Les échecs de validation ne consomment jamais le solde après rejet. Associez-le à des landings CRC-32 ou de hachage cryptographique seulement lorsque l'intention de recherche dépasse un contrôle de trame sur huit bits—gardez cette page centrée sur le CRC-8 au poly standard 0x07 pour que l'intention SEO reste nette.
Cas d’usage
Contrôles SMBus et protocoles embarqués
Vérifiez qu'une chaîne de charge produit la bande-annonce CRC-8 d'un octet attendue sous le poly 0x07 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 → F4 et laissent les étudiants recalculer d'autres chaînes courtes sans installer de bibliothèque CRC.
Questions fréquentes
Quel polynôme CRC-8 cet outil utilise-t-il ?
Le poly standard 0x07 (CRC-8/SMBus) : init 0x00, sans réflexion, xorout 0x00. Le contrôle documenté pour ASCII 123456789 est F4.
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 zéro réussi.
Le CRC-8 est-il un hachage cryptographique ?
Non. Le CRC-8 est un contrôle d'intégrité sur huit bits pour la trame et la corruption accidentelle. Utilisez SHA-256 ou équivalent lorsque vous avez besoin de résistance aux collisions ou d'authentification.
Où ce profil CRC-8 est-il utilisé ?
Le polynôme 07 avec un départ à zéro est le générateur de SMBus, de nombreux exemples de contrôle d'en-tête ATM et de la plupart des démonstrations de CRC-8 en ligne. Il convient aux bus embarqués, aux protocoles de trames simples et à l'enseignement.
Quelles valeurs une somme CRC-8 peut-elle prendre ?
Elle tient sur un seul octet : de 00 à ff en hexadécimal, soit de 0 à 255 en décimal. L'outil affiche les deux formes, deux chiffres hexadécimaux en minuscules et l'entier correspondant.
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
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/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)Exemple de requête
{
"text": "123456789"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.crc8",
"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
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 à zéro.
Contrat d'entrée, erreurs de chaîne vide et forme de la réponse JSON
Épinglez à la fois un chemin de succès et une erreur d'entrée vide en intégration continue pour qu'un changement accidentel de poly ou d'init ne passe pas inaperçu. Les champs optionnels nuls sont omis plutôt qu'émis comme null, conformément au contrat du moteur de 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 dont vous souhaitez le checksum. Les alias input, value, s, data, message et payload sont acceptés pour le même champ afin que les stubs de SDK et les envois de formulaire restent souples. 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é s'il recevait le même flux UTF-8. text manquant, valeur non chaîne ou chaîne vide échouent 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, crc8 et hex tous fixés au même checksum hexadécimal de deux chiffres en minuscules ; decimal à l'entier de zéro à deux cent cinquante-cinq ; polynomial fixe à 0x07 ; algorithm fixe à CRC-8 ; 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.
Où une API de checksum CRC-8 se justifie et comment fonctionne le tarif
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 élément réussi. Gardez les charges à des tailles de texte ordinaires adaptées à un appel d'élément dans un Worker isolate ; cet outil vise les chaînes courtes et les extraits de protocole, pas les blobs binaires multi-mégaoctets.
Cas d'intégration
Fixtures CI pour le code de trame
Les pipelines épinglent des sorties hex CRC-8 déterministes et l'erreur d'entrée vide pour qu'un changement accidentel de poly ou d'init échoue immédiatement.
Questions techniques
Comment calculer un checksum CRC-8 d'un texte ?
Envoyez un JSON avec un champ chaîne non vide text. L'API encode la chaîne en UTF-8, exécute le CRC-8 avec le polynôme 0x07 et renvoie l'octet en deux chiffres hex minuscules dans result, crc8 et hex.
Le calculateur de checksum CRC-8 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 élément réussi ; les échecs de validation ne sont pas facturés.