Codificatore Intel HEX
L'indirizzo 256, il tipo 0 e sedici byte di dati formano il record :10010000214601360121470136007EFE09D2190140, con il checksum 40 già calcolato. Incolli righe esistenti per verificare ogni conteggio di byte e ogni checksum prima che un'immagine errata arrivi al chip. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Modalità di calcolo
- Encode
- Indirizzo
- 256
- Tipo di record
- 0
- Dati
- 214601360121470136007EFE09D21901
- Numero di record
- 1
Intel HEX è il formato di testo che la maggior parte delle toolchain per microcontrollori emette ancora quando si richiede un’immagine scrivibile in flash: ogni riga inizia con i due punti, poi un conteggio di byte, un indirizzo a sedici bit, un tipo di record, byte di dati opzionali e un checksum in complemento a due che intercetta errori di incolla prima che un programmatore scriva dati errati.
Decodifichi le righe, verifichi ogni checksum e legga i campi
Imposti mode su decode e inserisca una o più righe Intel HEX in text, ciascuna che inizia con i due punti. Gli incolla multilinea vengono divisi sulle interruzioni di riga; le righe vuote sono ignorate.
Per ogni riga non vuota il parser controlla che il corpo sia hex di lunghezza pari, che il campo di conteggio byte corrisponda al numero di cifre di dati presenti, che il tipo di record sia tra zero e cinque, e che il byte finale di checksum sia il complemento a due della somma di tutti i byte precedenti del record.
Preferisca decode quando deve spiegare cosa contiene un dump del fornitore, quando uno studente deve dimostrare che un checksum calcolato a mano coincide con il file, o quando un harness di test deve provare che un artefatto corrisponde ancora al record pubblicato dopo una trasformazione.
Casi d'uso
Controlli di checksum in laboratorio e in aula
Gli studenti incollano righe Intel HEX, verificano ogni checksum e leggono i nomi di tipo senza installare una toolchain del fornitore né rischiare un flash errato.
Dump di supporto e revisione ticket
Gli ingegneri di supporto decodificano frammenti .hex del fornitore per confermare gli offset di carico e intercettare corruzione da incolla prima di scalare sull’hardware.
Domande frequenti
Come codifico un record Intel HEX?
La risposta records[0].line è il record completo con due punti e un checksum corretto.
Come decodifico e verifico righe Intel HEX?
Invii mode decode e metta una o più righe che iniziano con ':' in text.
Quali tipi di record sono supportati?
I tipi 2 e 4 richiedono 2 byte di dati; 3 e 5 ne richiedono 4; il tipo 1 deve essere vuoto.
Quale intervallo di indirizzi accetta un record?
L'indirizzo di un record occupa sedici bit, da 0 a 65535. I valori fuori da questo intervallo vengono rifiutati, perché nel formato Intel HEX classico l'indirizzo occupa soltanto due byte.
Quanti byte di dati può contenere un record?
Fino a 255 byte, scritti come cifre esadecimali. Spazi, due punti, trattini e prefissi 0x vengono tolti prima, e un numero dispari di cifre rimasto dopo la pulizia viene rifiutato.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/enc/intel-hex \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"mode":"encode","direction":"encode"}'const res = await fetch("https://api.kit.forhosting.com/enc/intel-hex", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"mode": "encode",
"direction": "encode"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/intel-hex",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"mode": "encode",
"direction": "encode"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/intel-hex", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"mode":"encode","direction":"encode"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"mode":"encode","direction":"encode"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/intel-hex", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"mode": "encode",
"direction": "encode"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.intel_hex",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Questo codificatore Intel HEX costruisce un record corretto da indirizzo, tipo e payload esadecimale, oppure analizza una o più righe che Lei ha già, controllando la lunghezza rispetto al conteggio dichiarato e rifiutando ogni riga il cui checksum non corrisponda.
Codifichi un record di firmware con indirizzo, tipo e checksum
Imposti mode su encode, oppure lasci il valore predefinito. Il motore poi assembla due punti, conteggio byte, indirizzo, tipo, dati e il checksum in complemento a due di ogni byte precedente, e restituisce un array records con un oggetto contenente la riga intera, l’indirizzo numerico e hex, il nome del tipo, i dati hex e il checksum. Una stringa data vuota è valida per fine file e per esperimenti solo di tipo. Fornisca l’offset di carico a sedici bit in address come intero da zero a sessantacinquemila cinquecentotrentacinque; i valori fuori da quell’intervallo falliscono con invalid_input perché il campo indirizzo classico di Intel HEX è largo solo due byte. Scelga record_type da zero a cinque: zero è dati ordinari, uno è fine file con payload vuoto, due e quattro sono record di indirizzo di segmento esteso e lineare esteso che portano esattamente due byte di dati, e tre e cinque sono record di indirizzo di avvio segmento e di avvio lineare che portano esattamente quattro byte di dati. Metta il payload in data come cifre esadecimali; spazi opzionali, due punti, trattini e prefissi zero-x vengono rimossi, un conteggio dispari di cifre dopo la pulizia viene rifiutato, e più di duecentocinquantacinque byte vengono rifiutati perché il campo lunghezza è un solo byte.
Decodifichi le righe, verifichi ogni checksum e legga i campi
Qualsiasi fallimento solleva invalid_input con un messaggio che indica il numero di riga e il checksum atteso rispetto a quello effettivo quando la matematica non coincide — tali fallimenti non vengono addebitati sul percorso prepagato. In caso di successo riceve mode decode, un array records nell’ordine del file, record_count e all_checksums_ok impostato a true. Ogni oggetto record rispecchia la forma di encode: la riga normalizzata in maiuscolo, byte_count, address e address_hex, record_type e record_type_name, data hex, checksum e checksum_ok. Questo contratto basta per controllare un piccolo frammento .hex senza importare una toolchain completa di file oggetto, ed è abbastanza rigoroso da far fallire subito un nibble invertito in un ticket invece di produrre un’immagine flash silenziosamente errata.
Flussi di lavoro, prezzi, limiti e quando usare questo strumento
Un altro flusso incolla un frammento multilinea che include un record di indirizzo lineare esteso e un marcatore di fine file, confermando ogni checksum prima che un umano approvi un aggiornamento di campo. Questa capacità non espande i record di indirizzo esteso in una mappa di memoria piatta a trentadue bit e non parla con un programmatore hardware; la abbini al proprio flasher o costruttore di mappe quando serve l’assemblaggio completo dell’immagine. Il testo sorgente segue le stesse regole di conservazione degli altri elementi parse KIT, e i risultati sono sicuri da fissare perché l’algoritmo è pienamente deterministico. Chiami il codificatore Intel HEX gratuito nel browser per demo di laboratorio, ticket di supporto e controlli puntuali del checksum senza installare srec_cat, objcopy o un IDE del fornitore. Usi l’API prepagata KIT quando un backend, un worker edge o un SDK devono codificare o verificare record con saldo a $0.002 per elemento riuscito; gli errori di validazione non consumano mai saldo dopo il rifiuto del motore. Mantenga payload abbastanza corti per l’uso interattivo — i dati del record sono limitati a duecentocinquantacinque byte dal formato stesso — e usi strumenti dedicati di caricamento binario per immagini di produzione da più megabyte.
Casi di integrazione
Patch firmware e golden di CI
Codifichi un breve record di dati a un offset fisso, fissi la riga nell’integrazione continua e la decodifichi poi per dimostrare che indirizzo, payload e checksum coincidono ancora.
Domande tecniche
Cosa succede se il checksum è sbagliato?
La decodifica fallisce con invalid_input indicando la riga e il checksum atteso rispetto a quello effettivo. I record corretti restituiscono checksum_ok true e all_checksums_ok true.
Quanto costa il codificatore Intel HEX?
Lo strumento nel browser è gratuito. Le richieste API usano il saldo prepagato KIT a $0.002 per chiamata riuscita; l’input non valido non viene addebitato.