Vai al contenuto
zerologs
Torna all'indice delle guide
Specifica di formato binario

Il formato log Zero Gen3, record per record

Una specifica a livello di byte del log diagnostico Gen3 (Cypher III / FST): come si delimitano e si de-escapano i record 0xB2, che cosa significa ogni campo decodificato sulle schede MBB e BMS, dove la variante di firmware 538XX rompe le regole e quali byte restano sconosciuti. Ogni offset qui è stato rimisurato su 352 file di log reali, e cinque affermazioni che questa pagina faceva in precedenza sono ritirate sul posto invece di essere cancellate. Ogni conteggio di record riporta la convenzione di delimitazione e il numero di file con cui è stato preso, perché senza non si può riprodurre. La decodifica Gen3 è anche confrontata record per record con il parser della community, e dove le due divergono la pagina spiega perché.

Ultimo aggiornamento: 3 ottobre 2026
~103 min di lettura

TL;DR

  • Chi scrive il log fa l'escape del delimitatore. FE 4D su disco si decodifica in 0xB2 e FE 01 in 0xFE, quindi un record ben formato non contiene mai un 0xB2 grezzo dopo il byte 0. Nei 1.010.093 byte di payload su disco (record[2:]) dei 19.342 record concatenati per lunghezza dichiarata, su tutti e nove i file MBB Gen3 nativi di questo corpus, le occorrenze sono zero. Prima si delimita per lunghezza dichiarata, poi si fa l'unescape del corpo delimitato. Nell'ordine inverso la delimitazione si rompe, ed è così che l'escape fu scambiato per «0xB2 ricorre dentro i payload».
  • Un log MBB Gen3 nativo contiene davvero tensione del pacco e corrente della batteria, a record[34:38] e record[38:42], più la tensione e la corrente del bus DC misurate dal controller e il regime del motore. Sono tutti valorizzati su 144 record RUN su 144 e su zero record HIB su 417, perché vanno a zero con il bus ad alta tensione. Il decoder in produzione li legge dal 2026-09-07, solo con il bus attivo. Sono vuoti negli stati che occupano circa tre quarti di un log reale, quindi la fonte elettrica migliore resta il BMS.
  • In un record 0x51 non c'è nessun contachilometri. Avevamo pubblicato record[71:75] come tale: è una lettura ADC a 12 bit in microvolt e, per peso delle prove, una lettura della linea accessori a 12 V. Ogni valore del corpus soddisfa v = 5128k + 4864, da 0,143 V a 13,440 V, e solo il 51,5% dei campioni consecutivi è non decrescente. Il contachilometri esiste ma sta altrove: nella coda dei record più lunghi 0x52 e 0x53, solo sul layout firmware più recente, dove resta fermo durante una ricarica e sale solo sotto RUN. Di' sempre a quale record si riferisce un risultato negativo.
  • Tutti i record Gen3 condividono un'intestazione di 13 byte: 0xB2 | lunghezza | tipo | timestamp uint32 LE | microsecondi uint32 LE | sequenza uint8 | scostamento UTC int8. I byte 11 e 12 erano pubblicati qui come un unico «contatore di voci» uint16. Sono due campi: il byte 11 sale di uno a ogni record e riparte da zero quando la scheda si risveglia, il byte 12 è l'impostazione del fuso orario della moto in ore (−7 su una moto USA, +1 e +2 in Europa), rimasta ferma a tutti gli 11 giri del byte 11 in questo corpus. Il timestamp è già UTC; il byte 12 dice solo che cosa mostrava il cruscotto.
  • I tipi MBB sono 0xFB (intestazione: VIN, modello, anno modello, revisioni di scheda e firmware, build del firmware), 0xFD (testo, la parte più grossa), 0x51 / 0x52 / 0x53 (telemetria di stato in tre dimensioni), 0x54 (motore: coppia all'albero, corrente motore, tensione del bus DC), 0x48 (un record da 49 byte per ogni caricabatterie che ha risposto: nome, volt, ampere e hertz di rete, uscita DC, id CAN, seriale), 0x49 (limite e obiettivo di carica) e 0x4F (una coda del firmware andata in overflow, quasi sempre una coda CAN). Sono tutti decodificati. Le lunghezze dei record dipendono dalla data del firmware: la stessa SR/F scriveva record da 71 byte di tipo 0x51 nel 2023 e da 75 byte nel 2026.
  • I tipi BMS sono 0xFB (intestazione), 0xFD (testo), 0x4B (52 B, la fonte primaria di telemetria), 0x4D (78 B, esteso) e 0x4C (70 B, dettaglio celle). 0x4D e 0x4C non sono 0x4B con un suffisso: inseriscono 8 e 4 byte dopo l'intestazione condivisa di 13 byte, quindi ogni campo di misura è spostato. Leggerli con gli offset di 0x4B produce tensioni di cella plausibili su esattamente zero record.
  • Ogni pagina da 128 byte di un file BMS Gen3 dopo la prima si apre con 00 F0 FF 00, scritto SOPRA quattro byte di dati del record. Quello che c'era è perso: prima che il decoder lo imparasse, 699 delle 2.894 righe di telemetria emesse da otto file BMS leggevano almeno un campo attraverso un marcatore, e in 268 di esse quel campo era un timestamp che sembrava ancora plausibile, a una mediana di 22 giorni dai vicini. I valori sotto un marcatore ora sono trattenuti, e i 612 record il cui successore aveva lo 0xB2 distrutto dal marcatore sono ri-delimitati alla lunghezza dichiarata invece di andare persi. Un marcatore sul byte del tipo di un record lascia un timestamp di 0xHH00FFF0, lo stesso secondo per ogni moto in un arco di 194 giorni. Ecco perché 2025-10-28 17:40:00 UTC è comparso su moto che non c'entravano nulla. Sul corpus di produzione di 1.220 file la correzione ha eliminato 290 giorni-file falsi e 228 giri con solo la batteria.
  • Il testo BMS comincia al byte 13 del record, subito dopo l'intestazione. Il decoder prendeva invece «il primo byte stampabile dopo il byte 7», che su una moto a UTC+0 partiva dal byte di sequenza e si fermava allo zero del byte di scostamento: il 53,5% degli eventi di testo BMS andava perso e il 14% usciva come spazzatura. Corretto nel 2026-10, più che raddoppia gli eventi della macchina a stati BMS che un file Gen3 nativo restituisce.
  • BMS payload[38:41] è una tensione del pacco misurata, uint24 LE in millivolt, non il «contatore interno» con cui era archiviato da anni. Soddisfa l'inviluppo di accettazione a 28 serie su 2.189 delle 2.319 righe di telemetria che il decoder in produzione emette da sette file BMS (94,4%, e dal 92,1% al 96,5% per file).
  • BMS payload[24] NON è un codice di stato. L'enum 0x0B idle / 0x0C active / 0x09 unlock / 0x0A precharge è ritirato: il byte assume 37 valori distinti, quei quattro coprono il 58,6% delle righe, e fallisce un test del contatore, un test di temperatura e un test di stato testuale. È salvato così com'è e non è decodificato da nessuna parte.
  • Il byte 67 del record NON è un conteggio dei cicli di carica. È il byte basso del registro uint24 LE della capacità a carica completa a record[67:70]. Un decoder che lo leggeva come conteggio dei cicli è stato rilasciato e ritirato lo stesso giorno.
  • Verificato record per record sul ramo main del parser della community (90c8cb2), allineando per offset nel file e non per tempo su tutti i 18 file Gen3 nativi qui presenti: tutte le 2.866 letture di cella, i 1.727 stati del veicolo, i 119 record del caricabatterie e i 18 report di coda concordano, ogni differenza di corrente e di tensione del pacco è una parola che una delle due parti rifiuta come flash cancellata o fuori inviluppo, e il parser upstream non decodifica nessuno dei 33.460 record di testo.
  • La variante MBB con firmware 538XX è una trappola di instradamento. I suoi record 0x2c sono il normale record Riding Status del zero-log-parser upstream, decodificato dal 2015. Portano la tensione del pacco come intero esatto uint32 in millivolt, la corrente della batteria, i giri motore e cinque temperature. Non portano la velocità su strada, e la calibrazione fittata che avevamo pubblicato per loro è ritirata.
In questa pagina

La MBB Gen3 porta una telemetria elettrica scarsa

La frase con cui questa sezione si apriva era troppo forte. Una versione precedente della pagina diceva che una MBB Gen3 nativa «non contiene tensione del pacco, corrente della batteria né velocità su strada che un decoder consumi». Era letteralmente vero e fuorviava, perché l'intera affermazione stava nella precisazione: i byte c'erano e nessuno li leggeva.

Su una moto Gen3 nativa (la piattaforma Cypher III / FST, cioè i file SR/F, SR/S e DSR/X su cui è costruito questo corpus), la Main Bike Board scrive la tensione del pacco come uint32 little-endian in millivolt a record[34:38] e la corrente della batteria come int32 con segno in milliampere a record[38:42], ed entrambe sono valorizzate esattamente quando il sistema ad alta tensione è attivo: non zero su 144 record RUN su 144, 5 REV su 5, 4 PARK su 4, e zero su 417 HIB, zero su 408 PWSU e zero su 51 WAIT. Poiché ibernazione e accensione insieme sono il 75% dei record 0x51 di un log reale, nella pratica il campo di solito è vuoto. Il decoder in produzione lo estrae dal 2026-09-07, e solo da un record il cui bus è attivo: uno zero qui significa «il sistema ad alta tensione era spento», non «zero volt misurati», e pubblicarlo come lettura metterebbe su un grafico una misura per una moto che dorme in garage. Quindi il Battery Management System resta la fonte su cui costruire, perché i campi MBB, pur presenti, sono scarsi.

Il mix dei record rende concreta la forma del file. Su otto file MBB Gen3 nativi di cinque moto diverse (131.200 byte ciascuno, 19.089 record con delimitazione a catena di lunghezze), 16.553 record (86,7%) sono eventi di testo ASCII, 1.311 (6,9%) sono istantanee di telemetria 0x51, 1.061 (5,6%) sono secondari 0x54, 67 (0,35%) sono record estesi 0x52 e 8 sono intestazioni di file. Un log MBB Gen3 è in stragrande maggioranza un log di testo con una sottile spina dorsale binaria. Il lato BMS ha una forma simile, ma la sua spina dorsale binaria è fittamente popolata: i sette dump BMS contengono 15.890 record in tutto, di cui 13.178 (82,9%) di testo, 1.803 (11,4%) con il tipo di telemetria 0x4B, 691 (4,4%) con il tipo esteso 0x4D e 84 con 0x4C. Ogni conteggio in questa pagina ora è preso con la delimitazione a catena di lunghezze e rispettando l'escape, ed è per questo che stanno un po' sopra le cifre con split per intervalli che una versione precedente riportava: la delimitazione a catena recupera circa 250 record in più sugli stessi otto file MBB.

La prova per record[34:38] è un filtro di popolazione più una curva fisica, non una correlazione. Il filtro di popolazione è sopra e non ha eccezioni. La curva è migliore: su un file del 2021 (lo spezzone troncato da 16 kB, il nono file MBB nativo del corpus e l'unico fuori dalla popolazione degli otto dump usata per le cifre del mix dei record), 32 record CHRG consecutivi mostrano il campo che sale in modo monotono da 102,081 V a 114,075 V in 5,51 ore, mentre record[38:42] resta tra −11,6 A e −15,3 A e il SOC sale da 41 a 100. Sugli ultimi sei record il SOC è fisso a 100 mentre la tensione continua a salire da 111,8 V a 114,1 V. È una fase di assorbimento a tensione costante. Nessun campo di riempimento e nessuna tabella di conversione del SOC la produce. Integrando V·I su ΔSOC si ottengono circa 13,6 kWh su quel file e circa 12,4 kWh su uno del 2023, contro un pacco ZF14.4 che ha 14,4 kWh nominali e 12,6 kWh utilizzabili. L'integrazione a rettangolo sinistro dà 13,55 e 12,41 e quella trapezoidale 13,58 e 12,40, quindi il risultato è citato con tre cifre significative e non cambia con la regola di integrazione. Una cautela sulle popolazioni: quei record CHRG stanno nella variante da 71 byte del 0x51, ed è per questo che la tabella degli stati più avanti in questa pagina, contata sui record da 75 byte, mostra solo sette righe CHRG.

La riserva sull'ambito è seria ed è il motivo per cui questo non è presentato come un fatto assodato. Ogni dato dinamico qui sopra viene da un VIN con prefisso 538ZF, la piattaforma SR/F dal 2020 al 2023. L'unica vera moto con WMI PAG in questo corpus, una DSR/X, contribuisce 278 record 0x51 su due file, con 16 e 2 di essi valorizzati, un record RUN e nessun record CHRG. Qui non si può eseguire nemmeno un test di conservazione su hardware PAG. L'alternativa che resta in piedi, cioè che il layout sia condiviso ma il firmware dell'era DSR/X lo popoli solo in stati che questo corpus contiene a stento, non è esclusa.

Una parola separata a record[21:25] misura lo stesso bus con una risoluzione peggiore. È un secondo strumento, la tensione del bus DC letta dal controller del motore a passi di 100 mV, accanto alla tensione del pacco di origine BMS a record[34:38] in 1 mV. L'argomento per «stesso bus» è aritmetico e non statistico. È un multiplo di 100 mV su 281 letture non nulle su 281, mentre record[34:38] è un multiplo di 100 su 2 di 302; sui 247 record in cui entrambi sono valorizzati i due distano una mediana di 0,163 V; ed è zero su tutti i 54 record CHRG mentre record[34:38] è valorizzato su 47 di essi. Preferisci record[34:38]. Una versione precedente della pagina sosteneva record[21:25] con una correlazione di Pearson sulla tensione del pacco BMS; quell'argomento è ritirato. Rieseguito su una coppia MBB e BMS di una SR/F del 2025-12, associando 129 record RUN a una riga BMS entro 60 secondi, sette finestre uint32 nel record ottengono |r| ≥ 0,90, e la più forte è la finestra all'offset 30, con 0,925, davanti a record[21:25] con 0,907. La correlazione non identifica un offset, e trattarla come se lo facesse è l'errore che ha messo sulla pagina una linea a 12 V come contachilometri.

record[25:29] e record[29:33] sono la corrente del bus DC del controller, un int32 con segno in milliampere, e il regime del motore, un int32 con segno. Entrambi sono stati risolti il 2026-09-07 e sono decodificati da allora, con il filtro del bus attivo come per le tensioni. Questa pagina prima diceva che nessuno dei due era risolto, e il motivo era che un record 0x51 nativo non porta un riferimento di velocità indipendente. I record più lunghi 0x52 e 0x53 sì: portano la velocità su strada nella coda, e dividendola per il regime nello stesso record si ottiene una costante per tutto un giro: 0,0252 km/h per rpm su ogni riga del layout più vecchio e 0,0266 sulla moto con il layout più recente. Quella costante è il rapporto di trasmissione, e un campo che non è un regime non la tiene fissa. La corrente del bus DC non mostra ancora nessuna correlazione utile con la corrente del pacco BMS a nessuna tolleranza di associazione provata (|r| ≤ 0,16), perché le due schede non campionano insieme; è pubblicata come la lettura del controller e nient'altro.

Cosa scrive ogni decoder, non cosa codifica il firmwareI canali dell'MBB Gen3 nativo sono decodificati ma legati allo stato o al record. L'acceleratore non esiste su nessun percorso.Gen2 MBBGen2 BMSnativeGen3 MBB538XX MBBGen3 BMSpack voltagepack currentspeedmotor RPMSOCodometer12 V accessorycell mVmotor tempambient tempthrottledecodificato per campioneparziale: derivato dal testo o legato allo statobyte presenti, nessuno li leggeassente dal formatoL'acceleratore è una riga intera di croci di proposito. LogEntry.throttle_pct esiste nello schema (migrazione 20241206_001) ed è unacolonna negli export CSV e FIT, ma nessun decoder la assegna mai: il valore è NULL per ogni generazione.
Si legge così: ciò che backend/app/parser.py scrive sull'oggetto voce, non ciò che il firmware codifica. La distinzione regge il peso di diverse righe. Tensione e corrente del pacco dell'MBB Gen3 nativo fino a 2026-10 erano segnate come byte presenti, nessuno li legge: stanno a record[34:38] e record[38:42], diversi da zero su 144/144 record RUN e 0/417 record HIB, e sono decodificati dal 2026-09-07. Sono parziali perché uno zero lì significa che il bus è spento, non zero volt. Il contachilometri è parziale per un altro motivo: non ce n'è uno nel 0x51 da 75 byte, e quello nella coda dei più lunghi 0x52/0x53 esiste solo sul layout di firmware più recente. Il campo pubblicato qui come contachilometri fino al 2026-07-29, record[71:75], è una tensione analogica quantizzata dall'ADC: ognuno dei 1.121 record 0x51 completi da 75 byte soddisfa v = 5.128k + 4.864 µV, e cala su tanti campioni consecutivi quanti ne sale (51,5% non decrescente), cosa che nessun contachilometri fa. Questo è dimostrato. Leggerlo in particolare come la linea accessori a 12 V no: è un'identificazione a posteriori, ad alta confidenza perché gli eventi di testo del firmware citano le linee del DC-DC e della batteria esattamente in quelle unità e in quella fascia, ma non verificata con una misura. La riga è etichettata su questa base e il valore è memorizzato grezzo, in microvolt, con un nome che non si può scambiare per una distanza. Parziale copre anche valori che non sono un canale per campione: la temperatura del motore dell'MBB Gen3 nativo è post_1 ed è zero ogni volta che il motore non gira, mentre l'ambiente è post_0 (le cinque parole di post-stato erano etichettate con uno slot di scarto fino al 2026-09-07, quando post_2 veniva memorizzato come temperatura del motore; è l'inverter), e i mV di cella dell'MBB Gen2 compaiono solo come min_cell_mv negli eventi di limite di scarica. Quelle temperature non sono zero fuori da WAKE, STOP e CHRG, come sosteneva anche questa didascalia fino al 2026-07-29. Sui nove file MBB Gen3 nativi, delimitati per catena di lunghezze: RUN popola tutti e quattro i campi di temperatura di post-stato su 144/144 dei record 0x51 completi da 75 byte, più 57/57 record 0x52 e 31/31 record 0x53 che sono anch'essi in RUN. Il parcheggio li azzera per lo più, non del tutto: HIB porta post_1/post_2 sul 4,8% dei record (20/417) e PWSU porta post_3/post_4 sull'8,3% (34/408), mai l'insieme completo. I denominatori 141/408/403 pubblicati qui fino al 2026-07-30 non appartengono a nessuna delimitazione che questo decoder abbia mai usato. La colonna 538XX perde il segno della velocità: quel canale era derivato dai giri tramite una costante adattata ed è stato ritirato. I report decodificati da quel percorso sono memorizzati come log_generation = 3, quindi «Gen3» nel database è un insieme più grande di «Gen3 nativo» qui.

Un'eccezione documentata

La variante MBB con firmware 538XX porta davvero tensione del pacco, corrente della batteria, corrente motore e cinque temperature in un record che il decoder in produzione legge. È una moto dell'era Gen2 la cui MBB è stata aggiornata a un buffer circolare in stile Gen3, e i report decodificati da quel percorso sono salvati con log_generation = 3. «Gen3» in un database quindi non è lo stesso insieme di «Gen3 nativo» in questo documento. Non porta la velocità su strada (vedi il ritiro in quella sezione).

Delimitazione: una forma di record, un delimitatore e un escape a byte stuffing

Ogni record Gen3 (MBB, BMS e variante 538XX allo stesso modo) comincia con la stessa intestazione. Il byte 0 è il delimitatore 0xB2. Il byte 1 è la lunghezza totale del record su disco in byte, compreso il delimitatore e compresi gli eventuali byte di escape. Il byte 2 è il tipo di record. I byte da 3 a 6 sono un timestamp Unix come uint32 little-endian, i byte da 7 a 10 sono la parte sotto il secondo in microsecondi, il byte 11 è un contatore di sequenza che sale di uno a ogni record di ogni tipo, modulo 256, e il byte 12 è l'impostazione dello scostamento UTC della moto in ore intere come byte con segno. Il payload segue dal byte 13 e la sua interpretazione dipende interamente dal byte del tipo.

I byte 11 e 12 sono due campi, un numero di sequenza e l'impostazione dello scostamento UTC della moto, e questa pagina li pubblicava come un unico contatore a 16 bit. La sezione successiva mappa tutti i 13 byte dell'intestazione, con il significato di ogni valore e quello che il byte di sequenza rivela su un file.

0xB2 è un normale byte di dati, quindi chi scrive ne fa l'escape. Una versione precedente di questa specifica non menzionava l'escape da nessuna parte. La sequenza di due byte FE 4D su disco si decodifica in 0xB2, e FE 01 si decodifica in 0xFE. Di conseguenza un record ben formato non contiene mai un 0xB2 grezzo dopo il byte 0. Misurato, le occorrenze sono zero nei 1.010.093 byte SU DISCO di record[2:] (tutto il record tranne il delimitatore e il byte di lunghezza) sui 19.342 record concatenati per lunghezza da tutti e nove i file MBB Gen3 nativi di questo corpus, e zero sui record BMS Gen3 nativi. «Su disco» è un termine che regge tutto: se si fa l'unescape degli stessi record, contengono 264 byte 0xB2 grezzi, che è esattamente lo scopo dell'escape. Il censimento sulla stessa popolazione di nove file: 504 record contengono almeno un escape, in totale compaiono 518 byte di escape, che si decodificano in 264 × FE 4D → 0xB2 e 254 × FE 01 → 0xFE, con zero coppie FE xx anomale. Sui soli otto dump completi dell'app (la popolazione che usa ogni cifra del mix dei record in questa pagina), lo stesso censimento dà 19.089 record, 994.299 byte di payload su disco, 468 record con escape e 477 byte di escape. Cita ogni censimento con la sua popolazione. L'assenza di un 0xB2 grezzo è la garanzia che il byte stuffing esiste per dare.

L'ordine conta, e farlo al contrario è ciò che ha prodotto la diagnosi sbagliata che questa pagina pubblicava. Prima si delimita per lunghezza dichiarata, poi si fa l'unescape del corpo delimitato. Il byte 1 è l'unico campo fuori dalla regione con escape, quindi è l'unico di cui un lettore può fidarsi prima dell'unescape: il byte del tipo, il timestamp e ogni offset del payload si spostano quando un escape cade davanti a loro. Fare l'unescape dell'intero buffer e poi dividere su 0xB2 sfilaccia il file, perché l'unescape reintroduce byte 0xB2 a metà payload. Questo è un argomento sull'ordine, non una prova che il delimitatore ricorra.

Tre decoder in questo progetto delimitano in modo diverso, per ragioni storiche e non buone. Solo il percorso MBB Gen3 nativo concatena per lunghezza dichiarata: legge il byte 1, avanza di quel valore e si risincronizza sul 0xB2 successivo se la catena si rompe. Sul corpus di nove file MBB nativi produce 19.342 record da 19.351 delimitatori con 17 risincronizzazioni. Sono circa due rotture strutturali per file, entrambe previste: l'intestazione di file da 128 byte, i cui 117 byte dichiarati non raggiungono il corpo, e il record spezzato al giro del buffer circolare. Il percorso BMS Gen3 divide ancora sul vuoto tra delimitatori e poi fa l'unescape di ogni fetta, tranne dove un marcatore di pagina flash ha sovrascritto lo 0xB2 del record successivo; lì taglia il vuoto alla lunghezza dichiarata (vedi la sezione sul marcatore di pagina). Il percorso 538XX non fa nessuna delle due cose: scorre byte per byte, fa l'unescape di ogni candidato, lo accetta sul filtro del timestamp e poi avanza di un byte invece che della lunghezza del record, quindi valuta candidati sovrapposti e lascia che le protezioni per tipo li assorbano. Tutto quello che si conta su quel percorso è un conteggio per candidato, non un conteggio di record delimitati, e questa pagina lo dice ovunque ne citi uno. Tutti e tre sono abbastanza corretti su questo corpus; la catena è quella da implementare, perché degrada con grazia e gli altri due no.

L'aritmetica delle lunghezze è la prova più pulita che l'escape sia universale. Sottrai il numero di byte di escape dalla lunghezza dichiarata e ogni tipo di record collassa su un unico valore canonico, senza eccezioni: l'MBB nativo 0x51 arriva a 71 o 75, 0x54 a 29, 0x48 a 62, 0x49 a 38; il BMS 0x4B a 52, 0x4C a 70, 0x4D a 78; e sulla variante 538XX, 0x2c arriva a esattamente 40 in 19.516 record su 19.516 le cui lunghezze su disco si distribuiscono su 40 (17.720 di essi), 41 (1.688) e 42 (108). È una popolazione da scansione byte sui 14 file adottati, quindi sono candidati e non record in catena. Altri due oracoli che non toccano mai il byte di lunghezza concordano: il byte di sequenza a record[11] è recuperato dall'unescape su 360 record su 360 in cui un escape lo precede e i due vicini lo fissano a un unico valore (byte grezzi: 9 su 360, sui dieci file MBB Gen3 nativi di questo corpus al 2026-10), e il timestamp cade dentro la forchetta dei vicini su 19 su 19 (grezzo: 0 su 19).

Si presentano solo quelle due sequenze, quindi la trasformazione generale è indeterminata. Il zero-log-parser upstream implementa FE xx come 0xFE XOR (xx − 1); la più semplice xx XOR 0xFF è identica per ogni xx dispari, ed entrambi i successori osservati sono dispari. Implementa le due mappature provate e tratta ogni altra coppia FE xx come un'anomalia da contare e da far emergere, non da trasformare. Quante siano dipende da quale decoder ha percorso i byte, quindi indicalo: attraverso i tre delimitatori in produzione questo corpus di 352 file ne dà 17 in tutto: 12 sui 135 file con firma 538XX con la scansione byte, 5 (tutte FE 00) nei sette file BMS Gen3 nativi, e nessuna nei nove file MBB Gen3 nativi. Le 12 hanno successori 0x27 tre volte, 0x64, 0xC1 e 0x00 due volte ciascuno, e 0x0F, 0xC2 e 0x84 una volta. Anche una cifra rivale di 13 è giusta ed è un'altra popolazione: è quella che conta il decoder del browser sul suo percorso di produzione, e si scompone in 5 nei file BMS, 8 nei file MBB Gen2 che il classificatore manda al delimitatore a catena, e zero nei 14 file 538XX veri. BinaryTools.unescape_block dell'upstream lo implementa da sempre per il Gen2, quindi un decoder costruito su quella libreria non ha bisogno di nessun caso speciale Gen3.

Ignorare l'escape costa record interi. Sul firmware 538XX il vecchio filtro confrontava la lunghezza su disco con 40, il che scarta ogni record di telemetria con escape per costruzione: 1.796 record in tutto il corpus. La perdita è correlata al valore, perché un record diventa non rappresentabile esattamente quando uno dei suoi byte decodificati vale 0xB2 o 0xFE. Interi tratti di sosta spariscono in blocco invece di diradarsi. Sul lato MBB Gen3 nativo, 504 dei 19.342 record del censimento di nove file contengono un escape, e 291 di essi si decodificano con una data diversa una volta rispettato l'escape, perché l'escape sta dentro o davanti al campo del timestamp.

Un record 0xB2Comune a MBB Gen3 nativo, BMS Gen3 e alla variante MBB 538XX[0]0xB2delimiter[1]sizeON-DISK[2]typeuint8[3:7]timestampuint32 LE, Unix s[7:11]microsecondsuint32 LE[11]sequint8[12]UTCint8 h[13:]payloadtype-specificA · delimita per lunghezza dichiarata, poi unescapecorretto: il byte 1 è l'unico campo fuori dalla regione con escapesu discoB20481512FE34D45354C6617D082A90F1000116012F91300140015001600170A1800190020002100220023dimensione dichiarata byte[1] = 0x48 = 72 byte su disco (il record continua oltre questa striscia)FE 4D → B2 · una coppia di escape, dentro il campo del timestampdecodificatoB20481512B235344C5616D072A80F900106011F91200130014001500160A1700180019002000210022lunghezza canonica 71 = 72 − 1 escapeByte del timestamp [3:7] decodificati = B2 53 4C 61 = 0x614C53B2 → 2021-09-23 12:15:14, dentro la finestra del delimitatore.Letto invece dal filo: FE 4D 53 4C = 0x4C534DFE → 2010-07-31, fuori da essa. Il record viene scartato.B · unescape dell'intero buffer, poi divisione su 0xB2si rompe: l'escape esiste per tenere questo byte fuori dal corpoB20481512B235344C5616D072A80F900106011F91200130014001500160A1700180019002000210022frammento 1: 3 Bframmento 2: 68 B, nessuna intestazione validaUn record diventa due frammenti. Nessuno dei due porta un timestamp plausibile a +3, quindi entrambi vengono scartati, equesto è il difetto che per molto tempo è stato scambiato per «0xB2 ricorre dentro i payload».
Ogni record della famiglia Gen3 inizia con B2 · size · type · uint32 LE timestamp · uint32 LE microseconds · uint8 sequence · int8 UTC offset. Gli ultimi due fino a 2026-10 erano disegnati qui come un unico «contatore» uint16, e il byte 12 è l'impostazione del fuso orario della moto, non il byte alto di un contatore. Le strisce qui sotto sono un vero record 0x51, tale e quale da un dump di una SR/S del 2021 (lo spezzone troncato da 16 kB, che è il nono file MBB Gen3 nativo e sta fuori dal censimento degli otto dump dell'app su cui si basano i conteggi aggregati di questa pagina), con una coppia di escape FE 4D dentro il campo del timestamp. L'ordine conta: si delimita per lunghezza dichiarata su disco, poi si fa l'unescape di ciò che si è delimitato. Nell'ordine inverso lo 0xB2 recuperato diventa un delimitatore in mezzo al tuo stesso record. Nei 14 dump 538XX adottati in logs/ ci sono 96.727 byte 0xB2; percorrendo la catena di lunghezze e risincronizzando a ogni strappo del buffer circolare, 96.632 di essi (99,90%) sono vere partenze di record, 61 cadono all'interno di un record delimitato e 34 non sono mai delimitati. Se «all'interno» si restringe a dentro un record la cui lunghezza dichiarata cade esattamente sulla partenza del record successivo il conteggio scende a 2, perché chi scrive fa l'escape del resto. zero-log-parser LOG_STRUCTURE.md documenta lo stesso escape per Gen2, e il suo BinaryTools.unescape_block lo implementa.
Quale decoder prende il fileMBB file bytes_is_538xx_mbb_variant(raw)raw[0:4] == b'MBB\0' AND raw[38:42] == A1 A1 A1 A1run _parse_538xx_mbb_entries() over the whole bufferoutcome gaten_state ≥ 10 AND telemetry_wire_exact ≥ 50 ← the PRE-unescape countis_definitely_pre_gen3(vin, model) ← hard vetomodel ∈ {S, SR, DS, DSR, FX, FXS, XU}OR VIN[9] ∈ 'ABCDEFGHJ' (2010–2018)any positive signal?model ∈ {SR/F, SR/S, DSR/X, FXE} · VIN ~ (ZF[A-Z]Z|XXFZ|DZ[A-Z]Z)OR: ASCII 'MBB' in raw[:32] AND ≥ 10 0xB2 bytes ← the overridenone counts unless the records carry the FST header (gen3_mbb_fst_layout)sìnononessuna firmapassasìsìdecoder 538XX adottatolog_generation = 3ricarica MBB lasciata al BMSpercorso Gen1 / Gen2JSON di zero-log-parser (upstream)→ _json_to_mbb_entriesdecoder Gen3 nativo_parse_gen3_mbb_entries+ _extract_gen3_telemetryIndipendentemente da tutto questo, entrambi i delimitatori binari Gen3 scartano qualunque record il cui timestamp uint32 a +3 cada fuori da2019-01-01 (Unix 1546300800) … oggi + 365 giorni.
Nel classificatore non c'è nessuna soglia sull'anno. Il ramo da guardare è l'ultimo. «Un buffer circolare 0xB2 popolato nel binario» significa, nel codice, solo questo: i byte ASCII MBB da qualche parte nei primi 32 byte, più almeno dieci byte 0xB2 ovunque nel file. Un file 538XX soddisfa entrambe in modo banale (la sua intestazione è MBB\0), quindi la pipeline registra «Gen3 detected from binary structure» e non prende mai il percorso JSON Gen2 upstream. È quella regola, non una lacuna del formato, ad aver mandato nove dei quattordici file 538XX in logs/ a zero giri. Il zero-log-parser upstream decodifica i loro record 0x2c Riding Status dal 2015, e come lo ha eseguito questo sito a luglio 2026 ha letto uno di questi file come 7.629 voci, comprese 2.048 righe Riding strutturate. Una versione precedente di questa didascalia diceva che entrambi i cattivi instradamenti «producono un output vuoto» e che sul percorso Gen2 l'upstream decodifica ogni record come riga «Board Status» vuota; la seconda metà è falsa. La verifica 538XX quindi gira prima della decisione di instradamento, per passare davanti alla regola. I veri file MBB Gen2 condividono la firma MBB\0 + A1 A1 A1 A1 e scrivono lo stesso record 0x2c da 40 byte, quindi né la firma né il tipo di record discriminano. Lo fa solo il criterio sull'esito, contando una popolazione prima dell'unescape che è essa stessa un artefatto di un difetto corretto. Sui 135 file con la firma in logs/ quel criterio ne adotta 14, ne tiene 30 sul percorso Gen2 e ne respinge 91. I 30 tenuti sono il motivo per cui il contatore non è stato sostituito con quello dopo l'unescape: ora decodificano da 425 a 2.408 voci di telemetria ciascuno pur totalizzando da 0 a 8 wire-exact, ed è quel solo numero a tenerli su un percorso Gen2 dove la loro decodifica upstream (della versione che questo sito fissa) è completa e corretta. Nota anche che la docstring di _is_538xx_mbb_variant dice che «must only be consulted INSIDE the firmware-format fallback»; il codice di instradamento la chiama incondizionatamente per i file MBB, e ciò che gira è il codice. Dal 2026-10-03 l'ultima casella ha un criterio davanti: nessuno dei suoi segnali instrada un MBB al decoder nativo se i record non portano l'intestazione di record FST (gen3_mbb_fst_layout). Trentasette file distinti con contenitore Gen2 in logs/ erano stati mandati lì dalla regola o dal ramo VIN XXFZ, con ogni messaggio letto sei caratteri in ritardo e senza contachilometri né giri decodificati; 36 di loro prendono ora la decodifica Gen2 upstream.
L'intestazione comune del record (gli offset sono assoluti nel record, dopo l'unescape)
byte[0]     0xB2        delimiter / fencepost marker
byte[1]     length      total ON-DISK record size in bytes, including byte 0
                        and including any 0xFE escape bytes
byte[2]     type        record type (0xFB, 0xFD, 0x51, 0x52, 0x53, 0x54, 0x48, 0x49,
                        0x4F on the MBB; 0x4B, 0x4C, 0x4D on the BMS; 0x2c on 538XX)
byte[3:7]   timestamp   Unix seconds, uint32 little-endian, TRUE UTC
byte[7:11]  microsec    sub-second part of the timestamp, uint32 LE, at most 1,000,000
byte[11]    sequence    uint8, +1 per record of ANY type, mod 256
byte[12]    utc offset  int8, the bike's time-zone setting in hours (0xF9 = -7).
                        Informational: never add it to the timestamp
byte[13:]   payload     type-specific; text records start their ASCII here

escape      FE 4D  ->  B2
            FE 01  ->  FE
            any other FE xx: an anomaly. Count it, surface it, do not transform it.

Sono in gioco due riferimenti e confonderli costa un pomeriggio. Questi offset sono assoluti nel record, misurati dallo 0xB2. Il zero-log-parser upstream taglia log_data[address+2 : address+length], ne fa l'unescape e poi prende message = block[5:], quindi un offset del payload upstream è 7 sotto l'offset assoluto nel record usato qui, e un campo di stato a record[42] sta a payload[35] upstream. Il decoder di questo progetto passa internamente raw_entry[6:], un terzo riferimento, ed è per questo che record[17] compare nel sorgente come binary_data[11]. Una versione precedente di questa pagina diceva che il payload upstream cominciava al byte 6 del record; era la convenzione di questo progetto, non quella dell'upstream.

Delimita per lunghezza dichiarata, poi fai l'unescape

Il delimitatore non compare mai grezzo dentro un record ben formato, perché chi scrive ne fa l'escape: FE 4D si decodifica in 0xB2 e FE 01 in 0xFE. Dividere su ogni 0xB2 quindi funziona meglio di quanto avrebbe diritto, ma l'escape va comunque rispettato, perché la lunghezza dichiarata conta i byte su disco. Delimita per il byte 1, poi fai l'unescape del record delimitato. Fare prima l'unescape dell'intero buffer reintroduce 0xB2 a metà payload ed è misurabilmente peggio. Questa pagina in passato diceva il contrario, che 0xB2 ricorre dentro i payload e che per questo una divisione ingenua fallisce; sul firmware 538XX che nomina, 96.632 dei 96.727 byte 0xB2 nei 14 file adottati (99,90%) sono veri inizi di record con la delimitazione a catena di lunghezze, 34 non sono mai delimitati e 61 cadono dentro un record. Di questi 61, solo 2 stanno dentro un record la cui lunghezza dichiarata cade esattamente sull'inizio del record successivo. Gli altri 59 sono a strappi al giro del buffer circolare, dove «dentro un record» significa dentro un frame che la catena aveva già perso.

L'intestazione di record di 13 byte, byte per byte

Ogni record Gen3 nativo si apre con gli stessi 13 byte, sulla scheda principale e sulla scheda di gestione della batteria allo stesso modo, e cinque dei suoi campi meritano una lettura a sé: la lunghezza che delimita il record, il tipo che decide come leggerlo, un timestamp UTC al microsecondo, un numero di sequenza per record e l'impostazione del fuso orario della moto. La tabella è la mappa. Le misure accanto riguardano i 18 file Gen3 nativi di questo corpus (dieci dump della scheda principale e otto della scheda di gestione della batteria) e contano solo i record i cui 13 byte di intestazione non sono stati toccati da nessun marcatore di pagina flash.

I byte da 7 a 10 sono la parte sotto il secondo del timestamp, in microsecondi. Non superano mai un secondo: il valore massimo su ogni intestazione intatta in quei 18 file è esattamente 1.000.000, e nessun record va oltre. Quel limite è più utile di quanto sembri, perché un record del layout più vecchio porta payload negli stessi quattro byte e lo rompe quasi a ogni record, ed è così che il decoder distingue i due layout (vedi «Due layout di record, decisi per file» più avanti).

Questo sito ha pubblicato i byte 11 e 12 come un unico «contatore di voci» uint16 little-endian a [11:13] fino a ottobre 2026, su questa pagina e nella documentazione del suo decoder. Era sbagliato, e la misura che lo mostra è breve. Un contatore a 16 bit riporta nel suo byte alto quando il byte basso passa da 255 a 0; il byte 11 gira 11 volte in questi file (nove volte sulle schede principali, due sui pacchi), e a ognuno di quei giri il byte 12 è rimasto esattamente dov'era. Sono due campi: un numero di sequenza di un byte e l'impostazione dello scostamento UTC della moto.

L'intestazione di record Gen3 comune (offset dopo l'unescape, tranne il byte 1)
ByteCampoCome leggerloMisurato sui 18 file nativi
0Delimitatore0xB2. Mai grezzo dentro un record: chi scrive ne fa l'escape come FE 4D, e di uno 0xFE letterale come FE 01Prima si delimita per il byte 1, poi si fa l'unescape di quello che si è delimitato
1LunghezzaDimensione totale SU DISCO, contando il byte 0 e ogni byte di escape. L'unico campo fuori dalla regione con escape, quindi l'unico di cui fidarsi prima dell'unescapeTolto il numero di escape, ogni tipo di record arriva a una lunghezza canonica
2Tipo0xFB intestazione, 0xFD testo, da 0x51 a 0x54, 0x48, 0x49 e 0x4F sulla scheda principale; 0x4B, 0x4C e 0x4D sul paccoLetto dopo l'unescape, come tutto da qui in poi
3–6Timestampuint32 little-endian, secondi Unix, vero UTCIl byte 6 cambia una volta ogni 2^24 secondi, circa 194 giorni
7–10Microsecondiuint32 little-endian, la parte sotto il secondo del timestampMassimo esattamente 1.000.000; mai oltre
11Sequenzauint8, +1 per record di qualsiasi tipo, passa da 255 a 0, e riparte da 0 quando la scheda si risveglia+1 tra il 96,4% dei record adiacenti della scheda principale e il 96,1% di quelli adiacenti del pacco
12Scostamento UTCint8, l'impostazione di correzione oraria della moto in ore intere. Informativo: non sommarlo mai al timestamp−7, 0, +1, +2 e +8 visti; costante su lunghe sequenze
13…PayloadSpecifico del tipo. L'ASCII terminato da NUL di un record di testo 0xFD comincia quiIl byte 13 è stampabile su 8.786 di 8.788 record di testo del pacco non toccati da marcatori, e su 18.570 di 18.570 record di testo della scheda principale

Il zero-log-parser upstream legge i byte da 7 a 12 come un prefisso di sei byte davanti al suo payload: una parola sotto il secondo in microsecondi, un contatore di sequenza per voce (che ha misurato salire di uno tra il 97,3% di 826.535 voci adiacenti), e un byte che lascia senza etichetta come «marker», annotando che una lettura come scostamento UTC è ancora aperta. I microsecondi e la sequenza sono stati i primi dell'upstream.

Che cosa espone il byte di sequenza

Il byte 11 è il controllo di integrità più economico del formato. Sale di uno a ogni record che la scheda scrive, qualunque sia il tipo del record, quindi due record vicini nel file dovrebbero differire esattamente di uno. Sulle coppie di record intatti adiacenti su disco nei 18 file nativi, succede su 20.913 di 21.693 coppie della scheda principale (96,4%) e su 13.628 di 14.177 coppie del pacco (96,1%). Le eccezioni non sono rumore. Ogni tipo dice qualcosa sul file:

  • Una ripartenza da zero: 506 sulle schede principali e 536 sui pacchi. Il contatore ricomincia quando la scheda si risveglia: 499 e 530 di quelle ripartenze seguono almeno un minuto di silenzio, e il record che prende il numero 0 è la riga di risveglio della scheda stessa: «Board was reset» su 453 delle ripartenze della scheda principale e «Exiting Hibernate» su 51, e sui pacchi quasi sempre le stesse due righe. Una ripartenza segna un confine di avvio che si trova senza leggere nessun testo.
  • Un salto in avanti di più di uno: 268 sulle schede principali, 3 sui pacchi. I due record sono vicini su disco, ma i numeri in mezzo sono stati presi da record che non stanno in questo punto del file.
  • Un salto all'indietro: 6 sulle schede principali. All'interno di un solo secondo la scheda a volte salva i record fuori dal loro ordine numerato (una sequenza legge 12, 14, 13, 15), quindi anche dentro un secondo la posizione nel file non è sempre l'ordine con cui i record sono stati numerati.
  • Un salto al giro del buffer circolare (10 sui pacchi), dove il record più recente nel buffer è seguito dal più vecchio.
  • Gli 11 giri da 255 a 0 sono normali passi di +1, e il byte 12 non si è mosso a nessuno di essi.
Il byte è largo otto bit e riparte a ogni risveglio, quindi controlla i vicini e nient'altro: non è mai una chiave di ordinamento. Il decoder di questo sito ordina i record per timestamp e per posizione nella scansione, e pubblica il byte 11 a parte, come bms_sequence sulle righe della batteria.

Byte 12: l'impostazione dello scostamento UTC della moto

Il byte 12 è un byte con segno che contiene l'impostazione di correzione oraria della moto in ore intere: lo scostamento che il cruscotto applica per mostrare l'ora locale. Il timestamp nei byte da 3 a 6 è già UTC; la console della batteria lo prova stampando la stessa epoca accanto alla propria resa. Quindi lo scostamento è informativo: dice che cosa vedeva il pilota sul cruscotto, mai come spostare un'ora salvata, e un decoder che lo somma al timestamp sposta ogni evento del file di ore. Il decoder di questo sito lo salva una volta per file, come valore più frequente, tenendo accanto ogni altro valore visto.

Cinque dei 18 file portano un secondo valore. Un cambio dentro un file è un cambio dell'impostazione, non dell'orologio: un pilota che sposta il cruscotto di un'ora per l'ora legale, o una scheda che ha scritto qualche record prima che la sua impostazione salvata fosse caricata. I conteggi sembrano entrambe le cose: 2.205 record a +1 dopo 33 a +2, 2.300 a 0 accanto a 33 a +1, 2.362 a +2 accanto a 18 a +1, 2.112 a +1 accanto a 2 a 0 su un pacco, e una scheda principale con 69 record a −7 prima di 2.347 a 0. In tutto questo i timestamp restano UTC, quindi niente su una linea temporale si sposta; cambia solo l'etichetta che un pilota avrebbe letto. Il gruppo di file più grande dell'upstream mostra per lo più 0xF9, 0x02, 0xFC, 0xFB e 0x01 in questo byte (−7, +2, −4, −5 e +1 come scostamenti), tutti fusi orari civili.

Valori del byte 12 nei 18 file Gen3 nativi, sui record con intestazione intatta
ValoreByteFile in cui è l'impostazioneRecordChe cosa significa
−70xF91 scheda principale322Sette ore a ovest di UTC, un'impostazione nordamericana
00x003 schede principali, 3 pacchi13.315UTC, per esempio il Regno Unito fuori dall'ora legale
+10x012 schede principali, 2 pacchi8.877Europa centrale in inverno, o Regno Unito in estate
+20x022 schede principali, 1 pacco6.883Europa centrale in estate
+80x082 schede principali, 2 pacchi8.908Otto ore a est di UTC

Un valore fuori da −12 a +14 non è un fuso orario civile, e il decoder non ne legge uno lì. Su un file della batteria di solito è un marcatore di pagina che sta sul byte, ed è per questo che il riepilogo per file conta solo i record la cui intestazione nessun marcatore ha toccato.

Ritirato qui: «un contatore di voci uint16 a [11:13]»

Fino a ottobre 2026 questa pagina, e la documentazione del decoder di questo sito, descrivevano i byte 11 e 12 come un unico contatore di voci a 16 bit little-endian. Un contatore a 16 bit riporta nel byte alto quando il byte basso gira; a tutti gli 11 giri del byte 11 in questo corpus il byte 12 è rimasto fermo, e il byte 12 assume solo la manciata di valori della tabella qui sopra. Letto come contatore, metteva ogni record di una moto UTC+2 a 512 numeri sopra quelli di una moto UTC0 senza nessun motivo.

Quali file contano come Gen3

Nel classificatore non c'è nessuna soglia di anno modello. Un log è trattato come Gen3 quando non scatta un veto rigido e almeno uno di tre segnali positivi sì, oppure, in mancanza, quando lo prende un override di instradamento separato fuori dal classificatore. L'ordine giusto conta, perché il delimitatore 0xB2 è condiviso con i file MbbD in formato dealer Gen2, e un file Gen2 classificato come Gen3 perde in silenzio i suoi eventi Sevcon e acceleratore.

Il veto rigido scatta quando il modello è uno tra S, SR, DS, DSR, FX, FXS o XU, oppure quando il codice dell'anno nel VIN (il decimo carattere) è una lettera da A a J, che corrisponde agli anni modello dal 2010 al 2018. Il codice anno K (2019) è il primo che il veto smette di respingere, ed è anche quando è uscita la SR/F. Il veto è un veto, non una soglia: un VIN del 2019 o successivo ha comunque bisogno di un segnale positivo.

Il classificatore stesso ha tre segnali positivi, controllati in ordine. Primo, il modello è uno tra SR/F, SR/S, DSR/X o FXE, confrontato con la barra tolta. Secondo, il VIN corrisponde all'espressione regolare della famiglia Gen3, che accetta le sottostringhe ZF?Z, XXFZ o DZ?Z dove ? è una qualsiasi lettera singola. Terzo, una congiunzione e non un singolo schema: il testo decodificato contiene un marcatore solo Gen3, o una riga «State change … from … to …» o una riga «Disch limits curr N cap N act N pow N», E non contiene nessuna riga di condizioni MBB Gen2, quella che dice «PackTemp: h NC, l NC, PackSOC: N%». Servono entrambe le metà: un log dealer Gen2 può portare testo di cambio stato suo, ed è la metà dell'assenza di telemetria Gen2 a impedirgli di contare.

Esiste una quarta via verso il decoder Gen3, ed è utile separarla dalle tre sopra perché è facile leggere il codice e concludere che il classificatore abbia quattro segnali, mentre non è così. Dopo che il classificatore ha restituito falso, il chiamante applica un override di instradamento: un file MBB il cui buffer circolare 0xB2 è stato delimitato con successo, su una moto che il veto rigido non ha respinto, viene comunque mandato al decoder Gen3. È ciò che salva un file la cui intestazione di testo non dà né un modello utilizzabile né un VIN. Succede fuori dal classificatore, quindi un'implementazione che riproduce solo la tabella qui sotto non lo riprodurrà. Un file BMS ha la scorciatoia equivalente: è trattato come Gen3 quando il suo caricatore binario Gen3 riesce, indipendentemente da modello e VIN.

Per un file MBB ora decidono i byte prima di tutto il resto (2026-10-03). Il decoder nativo legge l'intestazione di record FST (testo dal byte 13, lo stato a un offset fisso), e un file con contenitore Gen2, l'intestazione «MBB» + nullo con A1 A1 A1 A1 all'offset 38, delimita i suoi record 0xB2 con il payload dal byte 7. Mandato al decoder nativo dall'override o dal ramo XXFZ della famiglia VIN, un file così aveva ogni messaggio letto sei caratteri in ritardo e non cedeva né contachilometri né giri. Quindi nessuno dei segnali sopra instrada una MBB al decoder nativo a meno che la sua intestazione sia il record nativo 0xFB della scheda o i suoi record portino l'intestazione FST: una parola sotto il secondo di al più 1.000.000 su almeno l'80% di essi, e uno scostamento UTC civile nel byte 12 su almeno l'80%, con un valore che ne tiene la metà. Sui 151 file MBB di questo corpus con «MBB» nei primi 32 byte, i due segnali sui byte concordano su ogni file e le popolazioni non si avvicinano nemmeno: i 10 file nativi ottengono 1,0, 1,0 e almeno 0,971, e i 141 file con contenitore Gen2 al più 0,149, 0,442 e 0,316. Dei 37 file distinti con contenitore Gen2 che prima arrivavano al decoder nativo, 36 ora prendono la decodifica Gen2 upstream; l'ultimo ha un orologio al 1970 in ogni record, che nessun decoder può collocare.

La FXE merita una nota a parte, perché è l'unico modello in cui questa specifica e il resto del sito possono sembrare in disaccordo. La FXE è nell'insieme di modelli Gen3 del classificatore insieme a SR/F, SR/S e DSR/X, quindi un log FXE corrisponde al segnale 1 ed è salvato con log_generation = 3. Questa è un'affermazione su quale decoder il file viene instradato, non sulla generazione di prodotto della moto. Un catalogo che descrive la FXE come una macchina Cypher II risponde a un'altra domanda, e le due cose possono essere vere insieme.

Gli unici file FXE di questo corpus sono tre dump dealer da 262.144 byte di un'unica moto, e il loro corpo MBB non è affatto un buffer circolare Gen3 nativo. Si apre con l'ASCII «MBB» più un nullo invece di uno 0xB2, porta A1 A1 A1 A1 all'offset 38, non contiene nessuno dei token RUN, PWSU, HIB o CHRG con riempimento nullo che cerca il decoder Gen3 nativo, e contiene 1.809 e 2.228 record di tipo 0x2c sui due file MBB. Quel conteggio è una scansione byte su ogni 0xB2 il cui byte del tipo è 0x2c, la stessa convenzione che riproduce esattamente la tabella dei tipi di record BMS di questa pagina; se si richiede che la lunghezza su disco sia esattamente 40, gli stessi due file danno 1.682 e 2.093. (Una revisione precedente pubblicava 1.771 e 2.200 senza nominare una convenzione, e quei due numeri non si riproducono con nessuna delle due. Rimisurato il 2026-07-30.) Questa è la variante di firmware 538XX descritta più avanti in questa pagina, ed è il percorso da cui quei file si decodificano. Quindi nulla delle mappe dei record Gen3 nativi qui è stato verificato su una FXE.

Ingressi della classificazione Gen3
RegolaValoreEffetto
Veto rigido: modelloS, SR, DS, DSR, FX, FXS, XURilevamento Gen3 saltato del tutto
Veto rigido: codice anno nel VINA–J (2010–2018), carattere 10 del VINRilevamento Gen3 saltato del tutto
Segnale 1: modelloSR/F, SR/S, DSR/X, FXEClassificato Gen3
Segnale 2: famiglia del VINZF?Z, XXFZ o DZ?Z come sottostringaClassificato Gen3
Segnale 3: schemi di testo("State change … from … to" OR "Disch limits curr …") AND NOT "PackTemp: h …, PackSOC: …"Classificato Gen3
Override di instradamento: struttura binariaFile MBB il cui buffer circolare 0xB2 si delimita, veto rigido non scattatoInstradato al decoder Gen3 fuori dal classificatore
Filtro del layout di record: MBBIntestazione 0xFB nativa, o intestazione di record FST sui record delimitatiRichiesto prima di QUALSIASI segnale sopra per instradare una MBB al decoder nativo
Override di instradamento: BMSIl caricatore binario BMS Gen3 riesceInstradato al decoder BMS Gen3
Filtro indipendenteTimestamp del record dopo unescape tra 2019-01-01 .. adesso + 365 giorniRecord respinto da entrambi i delimitatori Gen3

Le prime cinque righe sono il classificatore: due veti più una disgiunzione a tre vie, non un confronto di anni. Una SR/F del 2021 con una stringa di modello illeggibile è comunque classificata Gen3 tramite la sua famiglia di VIN; una FX del 2019 è vietata sul modello a prescindere da qualsiasi cosa nel file. Le due righe di override NON fanno parte di quella disgiunzione: sono applicate dal chiamante dopo che il classificatore ha già restituito falso, ed è per questo che un'implementazione del solo classificatore instrada meno file al decoder Gen3 del nostro. Gli override rispettano comunque i veti. Il filtro del layout di record sta davanti a tutto per una MBB: nessun modello, famiglia di VIN o override manda al decoder nativo un file i cui record non hanno l'intestazione FST.

Due layout di record, decisi per file

Non ogni file che arriva a un decoder Gen3 usa l'intestazione di 13 byte sopra. I dump della scheda principale della piattaforma Gen2, la variante 538XX e alcune esportazioni della scheda di gestione della batteria sono anch'essi flussi di record 0xB2, ma nel loro layout più vecchio il payload (testo compreso) comincia al byte 7 del record, subito dopo il timestamp: non ci sono microsecondi, sequenza né byte di scostamento. Un dump della batteria con forma Gen2 può arrivare al decoder batteria Gen3, perché porta la telemetria 0xB2 che l'instradatore cerca.

Applicare le regole FST a un file così costa caro: leggerne il testo dal byte 13 tagliava i primi sei caratteri di ogni messaggio («DEBUG: CAN Link Is Down» diventava «CAN Link Is Down») e scartava ogni record che il taglio lasciava troppo corto. Su un file di produzione che prende questo percorso, il byte 7 apre il testo su tutti tranne uno dei 3.556 record di testo. Quindi il layout è deciso per file, dai byte del file stesso, con un unico test (has_fst_record_layout nel decoder). Un file usa il layout FST quando vale una di queste due condizioni:

  1. 1il marcatore di pagina flash 00 F0 FF 00 apre sia la sua seconda sia la sua terza pagina da 128 byte (solo un'immagine batteria FST lo scrive, quindi questo basta da solo a chiudere la questione); oppure
  2. 2sui suoi record con un'intestazione completa di 13 byte, i byte da 7 a 10 leggono al più 1.000.000 su almeno l'80% di essi, il byte 12 si legge come scostamento UTC civile (da −12 a +14) su almeno l'80%, e un solo valore di scostamento ne spiega almeno la metà.
I tre punteggi per file, su ogni .bin di questo corpus con almeno dieci byte 0xB2 (363 file)
PopolazioneFileByte 7–10 entro un secondoByte 12 scostamento civileScostamento dominante
Layout FST (8 file batteria a pagine, 10 file scheda principale)18≥ 0,970≥ 0,990≥ 0,959
Ogni altro file345≤ 0,160≤ 0,442≤ 0,316
Soglia per FST—0,800,800,50

Le soglie sono state fissate su un campione più ampio di 374 file: questo corpus più undici file di produzione che un confronto di produzione aveva segnalato. Lì la quota più bassa di scostamento dominante FST era 0,685, su un dump grezzo di batteria da 13,6 MB che aveva attraversato un cambio di ora legale e scritto −5 e −6; ogni file non FST è rimasto a 0,16, 0,44 e 0,32 o meno. Anche i file a pagine hanno un punteggio, ma decide il solo marcatore.

Non decidere mai il layout da un nome di file o da un prefisso del VIN

Un nome di file è quello che ha digitato la persona che ha copiato il file. L'unica immagine FST di questo corpus che non porta il nome di esportazione dell'app è uno spezzone troncato da 16 kB della scheda principale, e gli undici file di produzione segnalati dal confronto includevano immagini FST native i cui nomi dicevano altro. Un prefisso del VIN non è meglio: la variante 538XX scrive un corpo in stile Gen3 dietro un VIN Gen2. Tutto ciò che il test non sa decidere (un file senza record a lunghezza piena) mantiene il comportamento più vecchio, che è quello di cui ha bisogno ogni file non FST. In un record legacy i byte da 7 a 10 sono payload e il byte 12 è il sesto carattere di un messaggio (i «:» di «DEBUG:»), quindi le due popolazioni non si avvicinano mai.

Tipi di record MBB Gen3 nativi

Un file MBB Gen3 nativo è di 131.200 byte come esportato dall'app Zero, con il marcatore «MBB» all'offset 0x0D e il primo 0xB2 all'offset 0. Le esportazioni dei dealer sono di 262.144 byte. I conteggi qui sotto sono per file e sono stati misurati su otto log reali; gli intervalli sono ampi perché dipendono da come è stata usata la moto prima dell'esportazione.

Dove va a finire il buffer circolareMix dei tipi di record di un dump per percorso di decoder, ciascuno normalizzato a 100%87,1%MBB Gen3 nativo131,200 B app dump · 2,368 records0xFD text20630x51 telemetry1510x54 secondary1510x52 / 0xFB313.7 text : 1 telemetry26,6%32,7%40,6%MBB 538XX262,144 B dealer dump · 7,758 records0xFD text20670x2c telemetry254012 other types31510.81 text : 1 telemetry84,5%10,1%BMS Gen3131,328 B app dump · 2,312 records0xFD text19530x4B telemetry2340x4D ext (+8)950x4C/00/FB308.3 text : 1 telemetryI segmenti più sottili di 4 px sono disegnati a 4 px; leggi i conteggi, non la sottile striscia.
Ogni colonna è un file reale nominato, normalizzato al proprio numero di record, quindi il confronto riguarda le proporzioni. Sinistra e destra sono le metà MBB e BMS di un'unica esportazione dell'app da una SR/F (i suoi download di scheda principale e batteria, fatti lo stesso giorno); la colonna centrale è un dump da 262 kB di un concessionario da una FX con la variante di firmware 538XX. Tutte e tre le colonne sono contate allo stesso modo, con la delimitazione per catena di lunghezze (si delimita per lunghezza dichiarata, poi unescape), ed è questo che ha cambiato di più la colonna centrale: veniva citata qui come 6.135 record e 2.487 di telemetria, da un passaggio che non vedeva un record con escape. Due dei tre decoder distribuiti fanno altro in esecuzione (il BMS delimita per gap; il percorso 538XX scandisce i byte con candidati sovrapposti), quindi questa è una misura del formato, tenuta costante sulle colonne per renderle confrontabili. Concorda con la scansione 538XX distribuita, che in questo file legge 2.283 record canonici da 40 0x2c direttamente dal filo più 257 recuperati con l'unescape, per gli stessi 2.540. Questi numeri per file stanno un po' fuori dai valori aggregati del corpus citati dall'articolo (catena di lunghezze: 19.089 record MBB sugli otto dump dell'app, 15.890 BMS su sette); stessa misura, denominatore diverso. Quindi un MBB Gen3 nativo spende l'87,1% dei suoi 2.368 record in testo ASCII e ti dà 151 record di telemetria, che portano davvero tensione e corrente del pacco a record[34:38] e record[38:42]. Il decoder li legge dal 2026-09-07, ma solo finché il bus ad alta tensione è attivo, e sono zero in ibernazione (0 dei 417 record HIB sui nove file MBB Gen3 nativi, contro 144 su 144 in RUN). La variante 538XX scrive 2.540 record di telemetria che un decoder consuma.
Tipi di record MBB, misurati su otto file Gen3 nativi
TipoNomeDimensione tipicaConteggio per fileQuotaContenuto
0xFBIntestazione117 B1—VIN, tipo di scheda, seriale, codice articolo, build del firmware
0xFDEvento di testovariabile, 28–105 B1.811–2.33186,7%Messaggi di log ASCII terminati da nullo
0x51Telemetria75 B (71 B sul firmware 2023)131–2396,9%Stato, SOC, tensione e corrente del bus DC e del pacco, regime motore, temperature ambiente, motore, inverter e celle, linea a 12 V
0x54Motore29 B0–2395,6%Coppia all'albero, corrente motore, tensione del bus DC; scritto accanto a ogni 0x51
0x52Esteso92 B (88 B sul firmware 2023)0–310,35%Tutto quello che porta 0x51, più velocità su strada, autonomia stimata e (sul layout più recente) il contachilometri
0x48 / 0x49 / 0x4F / 0x53Carica, coda, telemetria più grandevariabile0–690,5%Tabella del caricabatterie, obiettivi di carica, overflow di coda FreeRTOS e il record di stato più grande (tutti decodificati, vedi sotto)

Le quote sono sui 19.089 record degli otto file, delimitati per lunghezza dichiarata e con unescape. I totali per file andavano da 2.238 a 2.535 record. Le dimensioni nella terza colonna sono le lunghezze canoniche dopo l'unescape; su disco un record con un escape è più lungo di un byte.

Record di intestazione (0xFB, 117 byte): il file nomina la sua moto

Una sola intestazione apre ogni file della scheda principale Gen3 nativo, e il suo timestamp è l'ora del download e non un'ora di log. Nomina la moto, e dalla release 3.37.0 il decoder di questo sito la legge dai byte (il VIN, il modello, l'anno modello, le revisioni di scheda e firmware e la build del firmware) invece di prenderne una dal nome del file. Sui dieci file nativi della scheda principale di questo corpus ognuno di quei campi è presente e leggibile su tutti e dieci.

Il VIN è accettato solo quando supera la cifra di controllo del 49 CFR 565, il prefisso 538 o PAG e il set di caratteri del VIN. Lo slot è testo scrivibile, e la cifra di controllo è ciò che rende sicuro preferire l'intestazione al nome del file, che è la cosa che una rinomina cambia. Parte dall'offset 0x29 su tutti e dieci i file qui. Il zero-log-parser upstream ha trovato per primo questi offset (la sua decodifica dell'intestazione del 15 settembre 2026, attribuita lì alla pull request del 2022 di AtomicDog), e riporta il VIN un byte più avanti, a 0x2A, su circa il 2,6% dei file di produzione, con ogni altro campo che si sposta con lui; un byte con escape nel timestamp dell'intestazione stessa ne è la causa più probabile. Il decoder quindi prova prima l'intestazione con unescape, poi gli offset grezzi 0x29 e 0x2A, e non legge nulla se nessun VIN convalida, perché lo scostamento è allora ignoto.

L'anno modello è un'aggiunta di questo decoder. I due byte prima del nome del modello sono un uint16 che contiene l'anno per dieci (20210 per un 2021), e su dieci file su dieci è uguale all'anno codificato nel decimo carattere del VIN. Il suo byte alto, 0x4E o 0x4F, è ciò che una scansione di testo stampabile leggeva come parte del modello, da cui «NSRF» e «ODSRX». Qui: modello SRF su quattro file, SRS su tre e DSRX su tre; revisione di scheda 2 su tre, 4 su cinque e 5 su due; revisioni di firmware 19, 29, 42, 43 e 44.

Che cosa ne ricava un pilota: un file che dice ancora da quale moto viene dopo essere stato rinominato o inoltrato, un anno modello che incrocia il VIN, e la revisione hardware e firmware della scheda principale il giorno del download, che è la prima cosa da confrontare quando due file della stessa moto si decodificano in modo diverso. I valori stessi identificano una moto o la restringono, e nessuno è stampato in questa pagina.

Mappa dei campi dell'intestazione MBB 0xFB
[0]        0xB2
[1]        0x75 (117)
[2]        0xFB
[3:7]      timestamp — download time, uint32 LE
[7:11]     microseconds
[11]       sequence
[12]       UTC-offset setting, int8 hours (was "log format version")
[13:16]    "MBB"
[23:25]    model year x 10, uint16 LE — 20210 for an MY2021
[25:41]    model, NUL-padded — "SRF", "SRS", "DSRX" (was read as "NSRF",
           "ODSRX": the N / O is the model-year word's high byte)
[41:58]    VIN, 17 ASCII characters, check digit at the ninth;
           one byte later, [42:59], on ~2.6% of production files
[60:74]    board serial number — not decoded, never published
[92:101]   MBB part number — observed 40-08155, 40-08198, 40-08285
[101]      board revision, uint8 — 2, 4, 5 observed
[103]      firmware revision, uint8 — 19, 29, 42, 43, 44 observed
[107:...]  firmware build identifier, NUL-padded hex digits

I codici articolo osservati corrispondono a piattaforme: 40-08155 sulla SR/F 2020–2021, 40-08198 sulla SR/S e su una SR/F 2023, 40-08285 sulla DSR/X. Il codice articolo da solo non determina il layout dei record (vedi la nota sulla deriva del firmware più sotto).

Record di evento di testo (0xFD, variabile)

Gli eventi di testo sono la parte più grossa del file e l'unico posto in cui una MBB Gen3 nativa dichiara una lettura del pacco ad alta tensione. Il payload è ASCII terminato da nullo che parte dal byte 13 del record, dopo il campo di microsecondi di quattro byte, il byte di sequenza e il byte di scostamento UTC. Quest'ultimo byte era descritto qui come un marcatore di scheda, 0x02 sulla MBB e 0x01 sul BMS; leggeva 0x02 e 0x01 solo perché i file da cui era letto venivano da moto impostate su UTC+2 e UTC+1.

Un singolo ciclo di risveglio dall'ibernazione produce una raffica altamente ripetibile di questi record. Misurata su 416 cicli di risveglio completi negli otto dump completi dell'app, la raffica mediana è di 31 record, più spesso 27 eventi di testo, 2 record di telemetria e 2 secondari, scritti in una finestra di 91 secondi. Un ciclo qui è una coppia di marcatori «Hibernating for N sec» consecutivi a distanza di 3.000–4.200 secondi, su record delimitati a catena di lunghezze; se si contano solo i marcatori che dichiarano 3.600 secondi gli stessi otto file ne danno 411. I marcatori ricorrono con un intervallo mediano di 3.691 secondi, che è il sonno dichiarato di 3.600 secondi più la raffica che segue. Quel periodo non è dedotto: l'ultimo record di ogni raffica è letteralmente il testo «Saving Stats, Hibernating for 3600 sec», e 444 delle 462 direttive di ibernazione in quegli otto file specificano 3600 secondi (446 su 464 se si conta il nono file, troncato). Le restanti 18 specificano 31.536.000 secondi, cioè 365 giorni: una modalità di stoccaggio o trasporto.

La documentazione interna dichiarava la frequenza di ibernazione in due modi diversi, «circa 15–20 voci all'ora» e «circa 15–20 voci per ciclo di risveglio, che avviene ogni 1 ora». Per ciclo di risveglio è l'inquadratura giusta, e poiché il ciclo è orario le due frequenze coincidono. Il numero era la parte sbagliata: la mediana misurata è di 31 record grezzi per ciclo, non 15–20.

  • «State change from STRT to PWSU» e «State change from PWSU to HIB»: le transizioni di risveglio e di nuova ibernazione.
  • «Saving Stats, Hibernating for N sec»: l'intervallo di sonno che la scheda ha appena richiesto.
  • «Registering Mod N (NNNNNNmV, N brick )»: l'unica lettura del pacco ad alta tensione sul lato MBB.
  • «Disch limits: curr N cap N act N pow N» e «Ch limits: ...»: inviluppi di potenza di scarica e di carica in watt.
  • «Fault pending: CODE» e «Fault cleared: CODE»: transizioni di guasto, per esempio HVIL_OPEN.
  • «Requesting 12v charge. DC-DC NuV, Battery NuV, Combined NuV, Ambient NC»: la batteria accessori a 12 V, in microvolt.
Un ciclo di risveglio dall'ibernazione completo, 31 record in 91 secondi
01:43:28  0xFD  Board was reset. Source: Hib Wake RTC, Power-On, Supply WD, ...
01:43:29  0xFD  MBB RTC treated valid.
01:43:29  0xFD  Kill Sw = STOP
01:43:29  0xFD  Immobilizer = LOCKED
01:43:29  0xFD  Control flags changed. Old: 0x0000 New: 0x400020
01:43:29  0xFD  Disable flags changed. Old: 0x0000 New: 0x008d
01:43:29  0xFD  State change from STRT to PWSU
01:43:29  0x51  telemetry  state='PWSU'  soc=0
01:43:29  0xFD  Disch limits: curr 0 cap 0 act 0 pow 0
01:43:29  0xFD  Ch limits: curr 0 cap 0 act 0 pow 0
01:43:29  0x54  secondary
01:43:29  0xFD  Requesting 12v charge. DC-DC 179216uV, Battery 13132544uV, ...
01:43:29  0xFD  Fault pending: HVIL_OPEN sets in 2 seconds
01:43:29  0xFD  Kickstand Sw = DOWN
01:43:32  0xFD  Registering Mod 2 (104832mV, 4 brick )
01:43:32  0xFD  LTSM state: INIT to DIS
01:44:29  0xFD  Timed out in PW Startup
01:44:29  0xFD  State change from PWSU to HIB
01:44:29  0x51  telemetry  state='HIB'  soc=56
01:44:29  0x54  secondary
01:44:29  0xFD  Stopping 12v charge. DC-DC 302288uV, Battery 13142800uV, ...
01:44:59  0xFD  Saving Stats, Hibernating for 3600 sec

Abbreviato: le righe ripetute «Control flags changed» e dei limiti sono omesse, e la raffica completa è di 31 record. La tensione del pacco 104832 mV nella riga «Registering Mod» è l'unica lettura ad alta tensione che una MBB Gen3 nativa produce, ed è testo, non un campo binario.

Record di telemetria (0x51, 75 byte)

Questa è la spina dorsale binaria del log MBB. Il decoder legge il campo di stato a un offset fisso per tipo di record (byte 42 del record su un 0x51, 46 su un 0x52, 50 su un 0x53) e vi accetta uno di dieci token ASCII con riempimento nullo: RUN, STOP, HIB, STRT, PWSU, CHRG, WAIT, WAKE, REV, PARK. Ogni altro offset è relativo a esso. Prima cercava un token in tutto il record, e un record di testo che conteneva per caso una di quelle parole aveva un carattere del suo messaggio letto come stato di carica: quasi sempre uno spazio, 0x20, che vale 32. La produzione conteneva 512 giri che finivano esattamente a SoC 32 prima che l'ancora fosse messa sul server, e il decoder del browser dietro /decode ha continuato a cercare fino al 2026-10. Qui sono in gioco due popolazioni e mescolarle è il modo in cui questa pagina ha sbagliato il numero successivo due volte. Una volta rispettato l'escape ci sono 1.121 record completi da 75 byte di tipo 0x51 sui nove file MBB nativi, e 1.078 di essi erano già di 75 byte su disco. Il token cade al byte 42 del record su ognuno. Su 1.069 dei 1.078 è uno degli otto token che il decoder conosceva all'origine; i restanti 9 portano REV o PARK (cinque e quattro, tutti sull'unica DSR/X qui) e furono scartati finché quei due non vennero aggiunti, lato server nel 2026-08 e in questo decoder del browser poco dopo. Non sono mai stati senza token né vuoti: tutti e 9 portano una tensione del pacco valorizzata a record[34:38], tra 102,561 V e 102,630 V, quindi i due token hanno recuperato telemetria vera e non rumore. La tabella delle ancore è ciò che permette allo stesso decoder di leggere il record da 92 byte 0x52, dove lo stato sta quattro byte più avanti, e quello da 106 byte 0x53, otto byte più avanti.

Due campi sono indirizzati relativamente al token. Il SOC è il singolo byte nove prima di esso, a record[33] su un record da 75 byte. I sei uint32 successivi allo stato cominciano nove byte dopo l'inizio del token, perché il campo di stato è riempito a nove byte.

Il flag di modalità a record[17] merita una nota, perché due revisioni diverse della documentazione interna lo descrivevano in due modi opposti. È un flag di modalità, ed è al byte 17, non al byte 11. Misurato per stato sui 1.121 record completi da 75 byte di tipo 0x51: vale 0x00 su 144 record RUN su 144, 0x6A su 408 record PWSU su 408, 0x6A su 397 record HIB su 417 con 0x60 sugli altri 20, e 0x6A su 7 CHRG su 7. Varia dentro una singola moto a seconda dello stato, quindi non può essere l'identificatore hardware per moto con cui era chiamato un tempo. Il byte 11, che una revisione precedente nominava invece come flag di modalità, è il byte di sequenza del record: assume 105 valori distinti su quegli stessi 144 record RUN e non cade in {0x00, 0x6A, 0x60} su nessuno.

Quali campi 0x51 sono valorizzati, per stato (1.121 record completi da 75 byte, nove file)
StatoRecordSOC = 0post_1 / post_2 valorizzatipost_3 / post_4 valorizzati
HIB4179 (2,2%)20 (4,8%)0
PWSU408373 (91,4%)034 (8,3%)
RUN1440144 (100%)144 (100%)
WAIT5147 (92,2%)3 (5,9%)3 (5,9%)
WAKE4403 (6,8%)44 (100%)
STOP41018 (43,9%)41 (100%)
CHRG7007 (100%)
REV505 (100%)5 (100%)
PARK404 (100%)4 (100%)

La popolazione è fatta dei 1.121 record la cui lunghezza è il valore canonico 75 DOPO l'unescape, che è la stessa popolazione usata da ogni altra cifra 0x51 in questa pagina. Una versione precedente di questa tabella era contata sui 1.078 record che erano già di 75 byte SU DISCO (i 43 con escape scartati, che è proprio la cosa che questa pagina passa una sezione a ritirare) e leggeva HIB 405, PWSU 397, RUN 130, WAIT 50, STOP 36. Quei numeri sono giusti per quella popolazione più stretta e sbagliati come descrizione del formato. I quattro interi successivi allo stato si comportano come due coppie, non come quattro canali indipendenti: post_1 e post_2 sono sempre valorizzati insieme, e così post_3 e post_4. L'affermazione precedente che le temperature compaiono solo in WAKE, STOP e CHRG non è sostenuta: RUN valorizza tutti e quattro, e PWSU e HIB ne valorizzano ciascuno una coppia. REV e PARK si comportano esattamente come RUN, che era il secondo argomento per aggiungerli all'elenco dei token. Questo è stato fatto su entrambi i decoder.

Telemetria MBB 0x51, 75 byte, offset assoluti nel record
[0]       0xB2 delimiter
[1]       0x4B (75) declared length
[2]       0x51 type
[3:7]     timestamp, uint32 LE
[7:11]    microseconds — sub-second part of the timestamp, uint32 LE.
          A multiple of 1000 on 1,121 of 1,121 records, max exactly 1,000,000.
[11]      sequence, uint8 — +1 per record of any type, mod 256. NOT a mode
          flag and NOT half of a uint16 counter; see the note.
[12]      UTC-offset setting, int8 hours
[13:17]   zeros
[17]      controller mode flag — 0x00 active, 0x6A standby, 0x60 transition
[18:21]   zeros
[21:25]   DC-bus voltage, int32 LE, mV, in 100 mV steps — the CONTROLLER's
          reading of the bus [34:38] measures. Zero on every CHRG record.
[25:29]   DC-bus current, int32 LE, mA — only while the bus is live
[29:33]   motor rpm, int32 LE — only while the bus is live
[33]      SOC %, uint8 — 0 means uninitialised, not empty
[34:38]   pack voltage, uint32 LE, mV — non-zero on 144/144 RUN, 5/5 REV,
          4/4 PARK; zero on 417/417 HIB, 408/408 PWSU, 51/51 WAIT
[38:42]   battery current, int32 LE, mA — discharge positive, charge negative
[42:51]   state name, ASCII, null-padded to 9 bytes
[51:55]   post_0 — AMBIENT temperature, hundredths of a degree on most firmware
          and whole degrees on some (each file is internally pure)
[55:59]   post_1 — MOTOR temperature, zero when the bike is parked
[59:63]   post_2 — INVERTER temperature, tracks post_1, zero when parked
[63:67]   post_3 — cell HIGH temperature, written in every state
[67:71]   post_4 — cell LOW temperature, <= post_3 on every record measured
[71:75]   12 V accessory-rail voltage, uint32 LE, microvolts — NOT an odometer,
          see the retraction below

Tre note. Primo, [34:38] e [38:42] erano pubblicati in questa pagina come «[34:42] zeri (riempimento)»; non sono riempimento, e la prova è nella sezione sopra. Sono misurati su cinque moto 538ZF (piattaforma SR/F). Sull'unica moto con WMI PAG di questo corpus solo 18 dei 278 record 0x51 li valorizzano, quindi non è confermato per il firmware dell'era DSR/X. Il decoder legge entrambi dal 2026-09-07, da record il cui bus è attivo. Secondo, le cinque temperature successive allo stato sono state pubblicate qui, e salvate, con i nomi sbagliati fino al 2026-09-07: post_0 come «metrica interna», post_1 come massima del pacco, post_2 come minima del pacco (e salvata come temperatura del motore), post_3 come ambiente e post_4 come controller. L'ordine era giusto e le etichette no, e la tabella degli stati qui sotto lo dimostrava già: post_1 e post_2 sono valorizzati su ogni record RUN e su nessuno in CHRG (un motore e un inverter sono spenti quando la moto è ferma), mentre post_3 e post_4 sono valorizzati in RUN, STOP, WAKE e CHRG indifferentemente, che è quello che fanno le celle. Terzo, il byte 11: una revisione precedente della documentazione interna lo chiamava flag di modalità del controller e chiamava il byte 17 un ID hardware per moto. Entrambe le cose erano al contrario. Il byte 11 è il byte di sequenza ed è ad alta entropia (105 valori distinti sui 144 record RUN), mentre il byte 17 è una funzione pulita dello stato.

Ritirato: record[71:75] non è un contachilometri

Questa pagina pubblicava record[71:75] come contachilometri totale in metri, e ne spiegava il comportamento come jitter: «13.183,8 km a 13.276,1 km dentro un solo giro di 20 minuti, una differenza di 92,3 km». Non è un contachilometri e non fa jitter. Ognuno dei 1.121 record completi da 75 byte di questo corpus soddisfa v = 5128k + 4864 con k tra 27 e 2.620, che è un ADC a 12 bit con un bit meno significativo di 5,128 mV e circa 21 V di fondo scala. Letto come microvolt il campo va da 0,143 V a 13,440 V, e gli eventi di testo del firmware citano la batteria accessori esattamente in quelle unità e in quella banda («Stopping 12v charge. DC-DC 302288uV, Battery 13142800uV»). La differenza di 92,3 «km» dentro un giro è una linea a 12 V che si muove da 13,184 V a 13,276 V. Solo il 51,5% dei campioni consecutivi è non decrescente (un lancio di moneta), e una scansione esaustiva di ogni finestra uint32 dall'offset 3 al 71 non trova nessuna finestra monotona tranne il timestamp stesso. In un record 0x51 non c'è nessun contachilometri. Quella frase fu poi citata come «non c'è nessun contachilometri in un record MBB Gen3 nativo», che è falso: la scansione dietro di essa copriva solo i record da 75 byte di tipo 0x51, e il contachilometri sta nella coda dei record più lunghi 0x52 e 0x53 (vedi la sezione sui record estesi qui sotto).

Come è stato scoperto, e che cosa è costato

L'indizio era aritmetico. Le differenze consecutive del campo condividono un massimo comun divisore di 5.128 con un residuo costante di 4.864 su 1.121 campioni su 1.121: un reticolo che nessuna misura di distanza produce e che ogni ADC produce. La conferma era che cinque moto non imparentate, di tre famiglie di modello e cinque anni modello (SR/F 2020, SR/F 2021, SR/S 2021, SR/F 2023, DSR/X 2024), riportavano tutte «contachilometri» dentro una finestra di 272 km. In questo progetto il campo passava un filtro di intervallo da 100.000 a 200.000.000, che 1.121 campioni su 1.121 superavano, e arrivava sul cruscotto come contachilometri principale e come distanza per giro. È stato rimosso dal decoder; il campo ora è emesso grezzo e non scalato sotto un nome neutro, perché «quale linea» è a confidenza alta ma non provato.

Record motore (0x54, 29 byte)

Il record 0x54 è scritto accanto a ogni 0x51 ed è il canale del motore: quattro parole int32 little-endian con segno dopo l'intestazione (coppia all'albero in micro-newton-metri, corrente motore in ampere interi, un contatore a corsa libera e la tensione del bus DC in millivolt), con FF FF FF FF che significa «non misurato». Questa pagina lo elencava come di scopo ignoto fino al 2026-09-07, perché su una moto ferma è quasi vuoto: dei 968 record la cui lunghezza su disco è il nominale 29 byte, sugli otto dump dell'app, 848 (87,6%) hanno i byte da 13 a 24 a zero (nessuna coppia, nessuna corrente, un contatore fermo), e 782 (80,8%) finiscono con la sentinella FF FF FF FF dove va la tensione del bus; altri 78 (8,1%) finiscono con quattro byte zero.

Devono reggere due controlli interni, ed entrambi reggono su ogni record misurato. La coppia è esattamente 0,2 N·m per ampere di corrente motore (27,6 N·m a 138 A, 49,2 a 246, 59,2 a 296), quindi le prime due parole sono un'unica misura passata per la costante del motore, e quella costante è la prova che la delimitazione è giusta. E la tensione del bus cala al salire della coppia, da 111,9 V a 0,6 N·m a 106,9 V a 59,2 N·m, restando dentro 3,82–4,00 V per cella su un pacco da 28 serie. Una mappa dei campi pubblicata chiama quella parola «potenza di scarica W»; un canale di potenza non cala sotto carico.

MBB 0x54 secondario, 29 byte
[0]       0xB2
[1]       0x1D (29)
[2]       0x54
[3:7]     timestamp — identical to the paired 0x51 record
[7:11]    microseconds
[11]      sequence
[12]      UTC-offset setting (was "0x02, MBB marker")
[13:17]   shaft torque, int32 LE, micro-N·m — 0.2 N·m per amp, exactly
[17:21]   motor current, int32 LE, A
[21:25]   counter, int32 LE
[25:29]   DC-bus voltage, int32 LE, mV — FF FF FF FF when not measured

Record estesi (0x52, 92 byte, e 0x53, 106 byte): velocità, autonomia e contachilometri

Il record 0x52 ha la stessa forma del 0x51 con quattro byte in più inseriti nell'area che precede lo stato, il che sposta il token di stato dal byte 42 al byte 46 del record; il 0x53 ne inserisce otto e lo mette al byte 50. Entrambi sono rari (67 0x52 sugli otto dump dell'app con la delimitazione a catena di lunghezze, 87 includendo il nono file, e da 0 a 31 per file, presenti soprattutto attorno agli eventi WAKE), ed entrambi portano una CODA che un 0x51 finisce prima. Una versione precedente di questa pagina diceva 66 0x52; è la stessa quantità contata come delimitatori 0xB2 grezzi il cui timestamp senza unescape supera la finestra, un'altra convenzione.

La coda contiene la velocità su strada in millimetri all'ora (km/h × 1.000.000), l'autonomia residua stimata dal cruscotto in centesimi di chilometro e, solo sul layout firmware più recente (quello il cui 0x51 è di 75 byte), il contachilometri in decimi di chilometro. Relativamente al token di stato: sul layout più recente il contachilometri sta a +35, la velocità a +39 e l'autonomia a +43 come uint16; sul layout più vecchio la velocità sta a +35, l'autonomia a +39 come uint32, e il contachilometri non c'è affatto. La parola a +39 del layout più vecchio è la trappola: sale con regolarità da 5.000 a 11.773 su un file e da 11.005 a 18.642 su un altro, in piena fascia di chilometraggio di una Zero, e ogni campione di quella salita è un record CHRG. Un contachilometri non si muove mentre la moto è in carica; è la stima dell'autonomia che sale mentre il pacco si riempie. Il contachilometri del layout più recente supera il test che gli impostori falliscono: resta fermo per tutta una ricarica, sale solo sotto RUN, ed è non decrescente su 48 passi su 48 e 36 su 36 sui due file con campioni sufficienti. Il decoder controlla comunque la serie per file e la ritira se più di un decimo dei suoi passi va all'indietro.

Obiettivi di carica e istantanee di stato della scheda principale (0x49, 0x4B–0x4D)

Sono decodificati altri quattro tipi di record della scheda principale. La tabella del caricabatterie (0x48), il report di coda piena (0x4F) e il banner della build del firmware (0x32) hanno ciascuno una sottosezione a sé più sotto; i due brevi sono qui.

Il tipo 0x49 porta il limite di carica in millivolt, l'obiettivo di carica in percentuale e una tensione di stoccaggio: 117,60 V, 90% e 106,00 V su una moto, dove il 90 è il limite impostato dal pilota stesso.

I tipi 0x4B, 0x4C e 0x4D compaiono anche sul lato scheda principale di alcuni file di produzione, come istantanee di stato da 53, 84 e 96 byte con un token di stato al byte 42, 46 o 50 del record, le stesse tre posizioni di 0x51, 0x52 e 0x53. Nessuno compare in questo corpus, quindi il decoder legge il token e nient'altro, e non lo usa per il rilevamento dei giri finché qualcuno non ha misurato che cosa farebbe lì. La scheda della batteria scrive gli stessi tre codici di tipo con lunghezze diverse e un layout non correlato; è la lunghezza a distinguerli.

Tabella del caricabatterie (0x48): quali caricabatterie hanno risposto, e da quale rete

Mentre la moto si ricarica, la scheda principale scrive un 0x48 circa ogni 640 secondi: l'intestazione di 13 byte seguita da un blocco di 49 byte per ogni caricabatterie che ha risposto sul bus CAN (62 byte con un blocco, 111 con due). Questo corpus ne contiene 119, in tre dei dieci file nativi della scheda principale, da tre moto, e ognuno è lungo 62 byte. Dove una moto ha due caricabatterie non condividono un record qui: ognuno risponde in un record a un blocco suo, con id CAN 16 e 17, e in 48 occasioni i due cadono nello stesso secondo. È così che un confronto che appaiava i record per timestamp una volta ha accoppiato i due sbagliati e ha riportato un disaccordo sull'id CAN dove non ce n'era.

I campi della rete provano il layout, e lo provano perché questo corpus copre due reti. Una moto legge da 113 a 115 V a 60 Hz sugli stessi byte in cui le altre due leggono da 218 a 236 V a 49 o 50 Hz, e nient'altro che una vera lettura di rete separa quelle popolazioni sugli stessi offset. La frequenza è quindi letta come classe per moto e non come numero: una moto qui si ricarica da una rete a 60 Hz e due a 50 Hz.

Il nome è l'ASCII del caricabatterie stesso: «3kW» su 97 record e «Flt 6» su 22 qui; il zero-log-parser upstream riporta anche «Charger», «6kW» e «3kWFCC» dai suoi file. «Flt 6» è ciò che l'unico caricabatterie di una moto scrive nel suo campo nome a ogni record mentre eroga da 15 a 26 A, quindi non è un caricabatterie che si è fermato, e non si sa che cosa abbrevi. Compaiono le versioni firmware del caricabatterie 201 (66 record), 206 (31) e 104 (22), ciascuna su una moto. Il numero di serie è decodificato e mai pubblicato.

Che cosa ne ricava un pilota: quali caricabatterie hanno risposto, e quando uno smette di rispondere; tensione e frequenza alla presa; quanta corrente ha tirato dalla rete ogni unità (da 5 a 12 A qui) e che cosa ha erogato al pacco. È il lato AC di una ricarica, e nessun altro record lo porta.

Un blocco di caricabatterie da 49 byte: offset nel record del primo blocco; aggiungi 49 per il successivo
Byte del recordCampoTipoVisto in questo corpus
13–22NomeASCII da 10 byte, riempito con NUL«3kW» (97), «Flt 6» (22)
23–24Flaguint16 LEBit non ancora identificati
25–28Tensione di uscita DCuint32 LE, mVTensione lato pacco
29Corrente di uscita DCuint8, ADa 5 a 26 A
37Comando in ingressouint8Salvato; significato non confermato
39Tensione di ingresso ACuint8, V113–115 V o 218–236 V
40Corrente di ingresso ACuint8, A5, 7, 9 o 12 A
42Frequenza ACuint8, Hz49, 50 o 60
44Id CANuint816, 17
45–46Versione firmwareuint16 LE104, 201, 206
47–50Numero di serieuint32 LEDecodificato; mai pubblicato
53–56Limite di caricauint32 LE, mVLa tensione che il caricabatterie può raggiungere
57Comando in uscitauint8Salvato; significato non confermato

Il zero-log-parser upstream ha decodificato per primo questo record, il 20 settembre 2026, e legge nome, flag, frequenza, id CAN, versione e seriale agli stessi byte; l'uscita DC, la tensione e la corrente AC e il limite di carica sono di questo decoder. Dove entrambi leggono un byte concordano su tutti i 119 record.

Coda piena (0x4F): al firmware è mancato lo spazio per un messaggio

Un 0x4F è di 31 byte: l'intestazione, un nome di coda di 10 byte riempito con NUL e due valori uint32. Viene scritto quando un task del firmware prova a mettere un messaggio in una coda FreeRTOS già piena. Il messaggio è scartato, e questo record è il firmware che lo dice. Qui ne compaiono diciotto, in quattro dei dieci file nativi della scheda principale, e ognuno nomina una coda CAN: CAN2txQ undici volte, CAN1txQ sei e CAN0RxQ una. Su queste moto una coda piena è congestione del bus CAN.

Il primo valore è costante per ogni coda (64 per CAN1txQ, 16 per CAN2txQ e 48 per CAN0RxQ) e sembra la capacità della coda. Il secondo varia, da 46 a 76 su CAN2txQ e da 735 a 79.252 su CAN1txQ. Nessuno dei due significati è confermato, quindi entrambi sono pubblicati con nomi neutri, come fa l'upstream.

Che cosa ne ricava un pilota: un record è un messaggio scartato, non un guasto, e nulla sul cruscotto gli corrisponde. Conta la ricorrenza: la stessa coda che va in overflow a ogni giro, o overflow che si addensano attorno a una ricarica o a un guasto, dice quale bus era sovraccarico, e quando.

Gli undici nomi di coda dell'upstream, e che cosa portano probabilmente (dedotto dal solo nome)
Nome della codaVisto quiRuolo probabile (dedotto, non dichiarato dal firmware)
CAN0RxQ, CAN1RxQ, CAN2RxQCAN0RxQ una voltaMessaggi ricevuti sul bus CAN 0, 1 o 2
CAN1txQ, CAN2txQCAN1txQ 6, CAN2txQ 11Messaggi in attesa di essere inviati sul bus CAN 1 o 2
logQ—Voci in attesa di essere scritte in questo log
dashQ—Messaggi per il cruscotto
uarttxQ, uartrxQ—Una porta seriale, in uscita e in ingresso, plausibilmente la console diagnostica
pduQ—Un'unità di distribuzione dell'alimentazione, se PDU significa quello che di solito significa
lssQ—CANopen Layer Setting Services, che assegna gli id di nodo sul bus (lo stesso LSS che dà il nome alla riga di log che libera l'id di nodo di un caricabatterie)

Gli undici nomi sono quelli del zero-log-parser upstream, che ha decodificato per primo questo record, il 20 settembre 2026. Solo i nomi della colonna centrale sono stati misurati qui; ogni ruolo nell'ultima colonna è una deduzione da un nome.

Mappa dei campi 0x4F (31 byte)
[0:13]   the common header
[13:23]  queue name, 10 bytes, NUL-padded ASCII
[23:27]  value a, uint32 LE — constant per queue: 64, 16, 48 here
[27:31]  value b, uint32 LE — varies; meaning unconfirmed

Banner della build del firmware (0x32): quale software girava, e se è cambiato

Il tipo 0x32 è un banner della build del firmware. Usa il layout di record più vecchio (nessun microsecondo, sequenza o byte di scostamento, payload dal byte 7 del record), e i suoi quattro byte di tempo contengono un piccolo numero relativo all'avvio, non una data. In questo corpus tutti i 59 stanno in 32 file di schede principali della piattaforma Gen2: 31 di essi sono dump della variante 538XX, quelli instradati sul percorso della scheda principale Gen3, e nessuno è un buffer circolare Gen3 nativo.

Dopo un byte di significato ignoto, il payload è il timbro di build di un compilatore C (mese, giorno, anno e ora, come li stampano __DATE__ e __TIME__), seguito, facoltativamente, da un numero di build e da un banco flash, «banka» o «bankb», ciascuno terminato da NUL. Qui 54 record portano tutti e tre (un payload di 32 byte) e 5 portano solo la data (22 byte); l'upstream elenca anche forme da 31 e 38 byte. I banchi si dividono in 45 «banka», 9 «bankb» e 5 senza nome, e le build sono state compilate tra il 2019 e il 2024.

Che cosa ne ricava un pilota: quale build del firmware girava sulla scheda principale mentre il buffer veniva scritto, e se è cambiata. Un file che nomina più di una build copre un aggiornamento (11 dei 32 file qui lo fanno), e il decoder elenca ogni build nell'ordine del file, con quanti record l'hanno annunciata. Due nomi di banco suggeriscono uno schema flash A/B, in cui un aggiornamento è scritto sul banco non in uso; è una deduzione dai nomi. I numeri di build e le date restringono una moto a una piccola popolazione, quindi questa pagina non li stampa.

Mappa dei campi 0x32 (layout più vecchio, offset dopo l'unescape)
[0]      0xB2
[1]      length, on disk
[2]      0x32
[3:7]    uint32 LE — a small boot-relative value, NOT a Unix time
[7]      one byte, meaning unknown
[8:]     "Mmm DD YYYY HH:MM:SS" NUL    build date and time (__DATE__ __TIME__)
         build number NUL               optional
         "banka" or "bankb" NUL         optional: the flash bank

Il zero-log-parser upstream ha decodificato per primo questo record, il 15 settembre 2026. Il decoder qui applica la stessa regola strutturale: la data deve essere interpretabile e ogni campo finale deve essere ASCII stampabile, altrimenti il record è rifiutato invece di essere nominato a metà.

Il layout dei record dipende dalla data del firmware, non dal codice articolo

Questa è la trappola che costerà più tempo a chi implementa per conto terzi. La stessa moto può scrivere layout di record diversi in momenti diversi, e il codice articolo della MBB non cambia con essi.

Una SR/F del 2021 con codice articolo MBB 40-08155 ha prodotto un'esportazione del 2023 con 190 record di tipo 0x51 a lunghezze dichiarate di 71, 72 e 74 byte, più 31 record di tipo 0x48, 30 di tipo 0x53 e 8 di tipo 0x49, e nessun record 0x54. Lo stesso VIN, lo stesso codice articolo, ha prodotto un'esportazione del 2026 con 151 record di tipo 0x51 a 75 e 76 byte, 151 di tipo 0x54, e nessuno di 0x48, 0x49 o 0x53. Un aggiornamento del firmware ha cambiato l'insieme dei record e la loro dimensione mentre l'intestazione riportava ancora 40-08155.

La conseguenza pratica: un decoder deve basare la sua mappa dei campi sulla lunghezza dichiarata del record, non sul codice articolo, sul modello o sull'anno. Ma questa pagina in precedenza traeva dalla stessa tabella una seconda conclusione, sbagliata: che una lunghezza di uno o due byte sopra il nominale (76 invece di 75, o 30 invece di 29) sia deriva del firmware e innocua. Non è né l'una né l'altra. Sono record con escape, e L meno il numero di escape arriva alla lunghezza canonica senza una sola eccezione in tutto il corpus. La distinzione è verificabile. Sui nove file MBB nativi ci sono 69 record 0x51 troppo lunghi, e 56 di essi portano il loro token di stato un byte in ritardo, al byte grezzo 43, che è esattamente ciò che fa un escape non rispettato; gli altri 13 ne portano più di uno e sono spostati di più. (Una versione precedente di questa pagina diceva 81 e 71. L'81 somma i 12 record 0x52 troppo lunghi al conteggio 0x51, e il 71 non si riproduce con nessuna convenzione di delimitazione provata.) Fai prima l'unescape e il token sta al byte 42 su 1.347 record su 1.356 con gli otto token del decoder, e su tutti i 1.356 una volta contati REV e PARK.

Lunghezze su disco 0x51 osservate per file: ogni lunghezza sopra il nominale è un escape
File esportatoModelloCodice MBBLunghezze 0x51 su disco (di cui con escape)0x54 presente
2021-09 (spezzone da 16 kB)SR/S40-0819871 (32, 0 con escape), 72 (11, 11), 73 (2, 2)no
2023-04SR/F40-0815571 (177, 0), 72 (12, 12), 74 (1, 1)no
2025-10DSR/X40-0828575 (142, 0), 76 (5, 5)sì
2025-12-29SR/F40-0815575 (220, 0), 76 (19, 19)sì
2025-12-31SR/S40-0819875 (152, 0), 76 (2, 2)sì
2026-01-01SR/S40-0819875 (147, 0), 76 (3, 3)sì
2026-01-21DSR/X40-0828575 (130, 0), 76 (1, 1)sì
2026-02-07 08:53SR/F40-0819875 (143, 0), 76 (6, 6)sì
2026-02-07 14:37SR/F40-0815575 (144, 0), 76 (7, 7)sì

Tutti e nove i file MBB Gen3 nativi, delimitati a catena di lunghezze. Leggi la coppia tra parentesi come (record a quella lunghezza su disco, di cui con almeno un escape 0xFE). Ogni lunghezza sopra il nominale ha il 100% di record con escape e ogni lunghezza nominale ha il 100% senza, che è il punto: 76 non è una variante firmware di 75, è 75 più un byte di escape. Una versione precedente di questa tabella elencava sei file e sottostimava cinque dei conteggi con escape.

La variante firmware 538XX: un formato di record noto e una trappola di instradamento

Alcune moto con VIN a prefisso 538XX (storicamente Gen2, e respinte del tutto dal veto pre-Gen3 sul modello, sul codice anno del VIN, o su entrambi) sono state portate da un aggiornamento del firmware a un corpo MBB che è un buffer circolare flash di record 0xB2 con prefisso di lunghezza. Il file sembra Gen2 da fuori e Gen3 da dentro. Questo è vero ed è il motivo per cui questa sezione esiste.

Quello che questa pagina diceva subito dopo è falso. Diceva: «Prima che esistesse un decoder fatto apposta, nessuno dei due percorsi riusciva a leggerlo. Il parser di testo Gen2 decodificava ogni record in una riga Board Status vuota e non produceva nessuna voce utilizzabile». Questi file non sono mai stati illeggibili. Il record 0x2c è il normale record Riding Status del zero-log-parser upstream, smistato dal 2015, con la sua tensione del pacco uint32 in millivolt letta dal 2020. Esegui il parser upstream su uno di questi file, come ha fatto questo sito nel luglio 2026, ed esce pulito con 7.629 voci, comprese 2.048 righe Riding completamente strutturate con contachilometri, tensione del pacco, giri motore, corrente della batteria e temperatura ambiente.

Quello che è fallito è stato l'instradamento, dentro questo progetto. Il caricatore Gen3 nativo richiede solo l'ASCII «MBB» da qualche parte nei primi 32 byte e almeno dieci byte 0xB2, ed entrambe le cose sono banalmente vere di un file 538XX, la cui intestazione è letteralmente "MBB\0". Restituisce migliaia di voci, quindi la pipeline imposta «Gen3 rilevato dalla struttura binaria» e non prende mai il percorso JSON Gen2 upstream. Nove dei quattordici file di questo corpus sono andati a zero giri in questo modo; gli altri cinque funzionavano già. La correzione rilasciata è stata un decoder, anche se il bug era nell'instradatore. Prima di concludere che la libreria upstream non gestisce un formato, controlla se lo fa già.

La variante resta un'eccezione documentata alla regola con cui si apre questa specifica, e i suoi record meritano comunque una mappa dei campi, perché un decoder in produzione ne legge i canali elettrici. Portano tensione del pacco, corrente della batteria, corrente del motore, cinque temperature, SOC, giri del motore e un contachilometri. Non portano la velocità su strada. Quando la decodifica è adottata il report è riclassificato come generazione 3 e le sue voci sono passate invariate al rilevatore di giri Gen3 esistente.

Rilevamento: una firma di intestazione più un filtro sul risultato

La firma è letta dai byte del file, non dal VIN: i byte da 0 a 3 sono l'ASCII «MBB» più un nullo, e i byte da 38 a 41 sono A1 A1 A1 A1, seguiti nei file reali da una data di build in ASCII.

I veri file MBB Gen2 condividono esattamente quella firma, quindi da sola non discrimina. La sonda quindi esegue prima la decodifica completa e adotta il risultato solo se l'esito supera una soglia: almeno 10 voci di cambio stato e almeno 50 voci di telemetria.

Questa pagina spiegava quella soglia dicendo «il vero Gen2 passa la firma ma non scrive alcun record di telemetria 0x2c». È decisamente sbagliato. I veri file Gen2 ne scrivono parecchi: i 121 file con la stessa firma che questo filtro respinge contengono tra loro 137.944 record 0x2c concatenati per lunghezza, 46.721 dei quali hanno la stessa forma canonica da 40 byte, e un campione di 40 file ne decodifica 22.831 su 22.867 in una tensione del pacco plausibile con una mediana di 104.392 mV e un rapporto pacco-cella di 28,043. Il record da 40 byte 0x2c è il record Riding Status del firmware più recente, presente in tutto il corpus Gen2 principale che l'upstream già interpreta.

Quello che separava le due popolazioni era un secondo bug. Il vecchio filtro confrontava la lunghezza su disco con 40 e quindi non poteva vedere un record con escape; sulla maggior parte delle moto Gen2 un campo fisso su un valore il cui byte basso è 0xB2 significa che ogni record di telemetria ha un escape, quindi ottenevano da 0 a 8 mentre i veri file 538XX ottenevano da 146 a 2.353. Correggere l'escape cancella quella separazione accidentale: 30 dei 135 file con la stessa firma salgono tra 425 e 2.408 record di telemetria. Adottare questo decoder per loro sarebbe un cambio di instradamento e non una correzione della decodifica, quindi il filtro sulla resa continua di proposito a contare la popolazione prima dell'unescape finché la questione non sarà risolta di per sé, e gli stessi 14 file sono adottati prima e dopo. Il Gen3 nativo comincia con 0xB2 e fallisce del tutto la firma.

La sonda gira prima della classificazione Gen3 e non dopo, perché i VIN 538XX cadono da entrambe le parti del veto: alcuni sono vietati verso il percorso Gen2 e altri non sono vietati e verrebbero instradati al decoder Gen3 nativo.

Rilevamento 538XX
signature   raw[0:4]  == "MBB\0"
            raw[38:42] == A1 A1 A1 A1
outcome     >= 10 state-change entries  AND  >= 50 telemetry entries
            (counted PRE-unescape, deliberately — see above)
framing     scan for 0xB2, take byte[+1] as the ON-DISK length,
            unescape the framed record, then accept it only when the
            uint32 LE at +3 OF THE UNESCAPED RECORD is a plausible
            timestamp (2019-01-01 .. now + 365 days)
gate        telemetry records are gated on the UNESCAPED length == 40

Leggi il timestamp dopo l'unescape, non prima. La sequenza di cinque byte 06 FE 01 5D 65 compare esattamente una volta in questo corpus di 352 file, in un dump dealer 538XX: letto grezzo, l'uint32 a +3 è 0x5D01FE06, cioè il 13 giugno 2019; dopo l'unescape è 0x655DFE06, cioè il 22 novembre 2023. Un record datato quattro anni e mezzo prima va in testa al file e avvelena qualsiasi protezione a massimo corrente a valle. Lo stesso errore su larga scala sta sul lato MBB Gen3 nativo, dove 291 dei 19.342 record delimitati a catena sui nove file si decodificano con una data diversa una volta rispettato l'escape. Filtrare sulla lunghezza su disco invece che su quella dopo l'unescape è lo stesso tipo di errore, e sul percorso 538XX costa 1.796 record di telemetria.

Record di telemetria (0x2c, esattamente 40 byte)

Gli offset sono assoluti nel record, sul record dopo l'unescape. Questa mappa è la tabella run_status del zero-log-parser upstream, non qualcosa ricavato qui; gli offset del payload upstream sono questi meno 7. Ogni canale è protetto da un intervallo, così che i frame corrotti del buffer circolare siano scartati invece di essere tracciati. Il decoder calcola due grandezze derivate: la potenza come V × A / 1000, e la coppia all'albero come kW × 9549 / rpm per rpm sopra 100, che è indipendente dal rapporto di trasmissione in un modo in cui la velocità non lo è.

Mappa dei campi di telemetria 538XX 0x2c (run_status upstream, assoluta nel record)
OffsetAmpiezzaCampoDecodificaIntervallo accettato
+7uint8Temperatura alta del pacco°C0 < t < 80
+8uint8Temperatura bassa del pacco°C0 < t < 80
+9uint16 LEStato di carica%0–100
+11uint32 LETensione del paccomillivolt, esatti50–130 V
+15int16 LETemperatura del motore°C0 < t < 150
+17int16 LETemperatura del controller°C0 < t < 150
+19uint16 LEGiri motoreRPM; nessuna velocità derivata≤ 8000
+23int16 LECorrente della batteriaampere interi, scarica positiva±400 A
+25uint8Bitmask di presenza dei moduli0/1/2/3 → 00/10/01/11≤ 3
+26int16 LECorrente del motoreampere±1000 A
+28int16 LETemperatura ambiente°C−50 … 70 inclusi
+30uint16 LEContachilometrikm, totale, non decrescentevedi la protezione sotto

Il contachilometri è l'unico punto in cui questo decoder si discosta di proposito dall'upstream, che legge un uint32 a +30. I due concordano su 19.480 record su 19.516. I 36 disaccordi sono distribuiti su quattro file, 31 in uno solo, e ognuno è un record in cui il byte 32 legge 2 e trasforma un contachilometri di 6972 km in 138.044 km, che è implausibile per la moto e non monotono rispetto ai vicini. Il contatore odometer_high_word_rejected del decoder sugli stessi file legge 36, il che corrobora il conteggio in modo indipendente. La lettura uint16 è mantenuta, al costo di girare oltre 65.535 km; nessuna moto di questo corpus ci si avvicina.

Ritirato: la calibrazione fittata

Questa sottosezione si intitolava «Provenienza della calibrazione» e si apriva così: «Nessuno dei fattori di scala sopra è stato supposto. Ogni canale è stato fittato contro la verità a terra del BMS o una legge fisica di conservazione, e le statistiche del fit sono il motivo per cui la mappa è affidabile». Poi citava la tensione fittata contro la tensione del pacco BMS con r = 0,96, la corrente validata per corrispondenza di distribuzione e una scala di velocità di 0,023323 km/h per RPM che usciva dalla conservazione della distanza del contachilometri con r = 0,999. Tutte e tre le affermazioni sono ritirate. È stato l'errore peggiore della pagina, e mostra come un fit con un buon coefficiente di correlazione possa essere sbagliato.

Tensione. La lettura ritirata era un uint16 a +12 scalato di 0,24608 con uno scostamento di 4,25 V. Quell'uint16 sono i due byte centrali di un intero esatto a 32 bit in millivolt, con il byte basso scartato: l'identità u32 a +11 uguale a 256 × u16 a +12 più il byte 11 del record vale su 19.513 record su 19.516. Fittare una retta su una fetta con perdita di un numero che si ha già esatto non può essere giusto, e non lo è: rispetto al valore vero la retta fittata sbaglia di una mediana di 0,1391 V, un 99° percentile di 0,5710 V e un massimo di 0,9728 V, e supera 0,1 V sul 62,8% dei record. Un controllo autonomo che non richiede riferimenti esterni: u32 a +11 diviso la tensione di cella a +36 ha una mediana di 28,070, che è un pacco da 28 serie letto in millivolt. La correlazione di 0,96 era reale e non informativa, perché una trasformazione monotona con perdita di una grandezza è correlata a quella grandezza per costruzione.

Corrente. Questa era peggio di un'approssimazione. La lettura ritirata era un int16 a +22 diviso 256, presentato come ampere Q8.8. Il byte 22 del record è un byte di riempimento (zero su 19.511 record su 19.516), quindi quell'espressione si riduce algebricamente all'int8 del byte 23 del record, un'identità verificata su tutti i 19.516. Il campo vero è un int16 a +23 in ampere interi. 487 record (2,50%) superano l'intervallo int8 e 418 di essi uscivano con il segno invertito, quindi uno spunto di +206 A era tracciato come −50 A. Il picco di scarica di ogni moto era tagliato a circa 127 A contro picchi veri per file da 199 a 385 A, sottostimando il picco dal 37,7% al 70,5%. Quell'intervallo confronta il picco di ogni decoder sotto la propria protezione, che è ciò che avrebbe visto un utente; limitando la lettura ritirata ai soli record che la protezione attuale di ±400 A accetta, diventa dal 37,7% al 73,8%.

Velocità su strada. In questo record non c'è nessun campo di velocità, e non c'è mai stato. La costante 0,023323 era fittata dalla conservazione della distanza del contachilometri, che è un metodo solido per una costante che esiste; rifittarla per file dà da 0,02273 a 0,02504 sui 13 file con più di 50 km di movimento, una dispersione di ±5,2%, perché rapporto finale e circonferenza dello pneumatico differiscono per modello. La costante rilasciata stava tra il 6,9% sotto e il 2,6% sopra a seconda della moto. Si sarebbe potuta fittare una tabella per modello, ma i 14 file adottati portano sette VIN distinti e quattro di essi contribuiscono un file ciascuno, quindi quella tabella avrebbe fittato rumore, lo stesso errore che la calibrazione della tensione ha fatto un livello più su. Il decoder ora pubblica i giri del motore, che sono misurati, e nessuna velocità derivata.

Il fit è stato sostituito dalla mappa dei campi run_status del zero-log-parser upstream, che smista 0x2c dal 2015. La verifica indipendente che sia giusta è fisica e non statistica: su 483 sessioni di giro con almeno il 5% di SOC usato e almeno 2 km percorsi, l'energia elettrica integrata per percentuale di SOC è passata da 43,1 Wh/% a 50,0 Wh/%, il che implica un pacco utilizzabile di 5,00 kWh invece di 4,31 kWh (corretto per i pacchi ZF3.6 e ZF7.2 che queste moto montano), e l'energia per chilometro è passata da 46,3 a 54,1 Wh/km contro i 55–70 pubblicati dalla stessa Zero. Il coefficiente di variazione tra le sessioni è sceso dal 44,8% al 39,4%. Una correzione che sposta una stima sul valore fisicamente giusto e ne riduce la dispersione fa qualcosa che una retta che si adatta meglio non può fare.

Il contachilometri porta una sua protezione, perché è non decrescente per tutta la vita e il buffer circolare no. Qualsiasi lettura sotto il massimo corrente, o zero, è respinta e l'ultimo valore buono è riportato avanti invariato. Un passo in avanti è accettato solo quando l'aumento non supera il maggiore tra 5 km e 200 km/h per le ore trascorse dall'ultima lettura accettata. Il termine di cadenza impedisce alla telemetria rada di sottostimare un lungo intervallo, scartando comunque i frame con bit invertiti.

Cosa è costata la calibrazione adattata 538XXMisurato su 19.516 record canonici da 40 0x2c · 14 file · 7 prefissi VIN · scansione dei byte distribuitaA · tensione: errore assoluto della retta adattata ritirata, voltrispetto a u32 LE @ +11, che è esattamente la stessa grandezza · 19.512 record dentro la protezione 50–130 V0,00,20,40,60,81,0median 0,139 Vp99 0,571 Vmax 0,973 V37.2%62.8% dei record sbaglia di più di 0,1 VL'adattamento approssimava un numero già presente nel record, dopo averne buttato il byte basso.B · corrente: cosa un int8 poteva e non poteva esprimere, ampereint8: −128 … +127 Avera scarica di picco per file, 199-385 A-400-2000200400487 record (2.5%) cadono fuori dalla finestra int8; 418 di loro sono usciti con il segno invertito, tracciando uno scatto da +206 A come −50 A.Con ogni lettura giudicata sotto la propria protezione, quella ritirata sottostimava il picco dal 37,7% al 70,5%.
Questa figura sostituisce una ritrattazione, e non contiene dati inventati. Lo slot conteneva prima due pannelli di dispersione schematici che drammatizzavano r = 0,96 per una retta di tensione adattata e r = 0,999 per una costante di velocità adattata. Entrambi gli adattamenti sono ritirati, quindi i pannelli se ne sono andati con loro. Ciò che viene tracciato ora è il costo misurato dell'adattamento, sui 19.516 record canonici da 40 0x2c che la scansione dei byte distribuita accetta nei 14 file che superano il criterio di adozione 538XX (17.720 già da 40 byte su disco, 1.796 recuperati con l'unescape). Il pannello della tensione è quello decisivo, e le sue statistiche d'errore sono sui 19.512 di quei record dentro la protezione del decoder di 50–130 V. I quattro fuori sono frame corrotti che si adattano a megavolt, quindi il massimo di 0,9728 V è un numero protetto ed è citato rispetto alla popolazione protetta. La u16 @+12 × 0,24608 + 4,25 ritirata adattava una fetta a 16 bit di un campo che è già un intero esatto a 32 bit in millivolt (u32 @+11 == 256 × u16 @+12 + rec[11] vale su 19.513 record su 19.516), quindi una correlazione di 0,96 era garantita per costruzione e non diceva nulla. Il pannello della corrente è quello che contava per chi guida: i16 @+22 / 256 a cavallo di un byte di riempimento si riduce algebricamente a int8(rec[23]), tagliando a circa 127 A la scarica di picco di ogni moto. Confrontando il picco di ogni lettura sotto la propria protezione (quella ritirata non aveva una protezione a ±400 A, perché un int8 non può mai farla scattare), la sottostima va dal 37,7% al 70,5%, peggiore su 538xx8z19gcj0XX68_MBB_2025-10-26.bin, 102,43 → 347 A. (Se si limita invece la vecchia lettura ai record che la nuova protezione accetta, l'intervallo è 37,7–73,8%; la prima coppia è quella che avrebbe visto chi guida, quindi è la coppia pubblicata.) Mappa dei campi ora presa alla lettera da quella di upstreamzero-log-parser tabella run_status, che instrada 0x2c dal 2015.

Ritirato: raw × 0.24608 + 4.25, corrente Q8.8 e rpm × 0.023323

Se hai costruito un decoder 538XX dalla versione precedente di questa tabella, tre dei suoi canali sono sbagliati. Sostituisci la tensione uint16 a +12 con l'intero uint32 in millivolt a +11. Sostituisci la corrente Q8.8 a +22 con il campo int16 in ampere interi a +23, che è quello che smette di invertire il segno alle tue accelerazioni forti. E cancella la velocità derivata: il record non ha nessun campo di velocità, e la costante che abbiamo pubblicato sbaglia fino al 7% in una direzione che dipende dal modello. I giri del motore a +19 sono la grandezza misurata.

Eventi di stato (0xFD) e perché la ricarica resta al BMS

Questo firmware non scrive nessuno dei token binari di stato Gen3 nativi. Lo stato è derivato da eventi di testo ASCII il cui payload parte dal byte 7 del record e non dal 13, ed è riportato avanti per timestamp sui record di telemetria successivi.

La ricarica di proposito non è rilevata su questo percorso. La MBB 538XX non porta telemetria di ricarica, e i suoi eventi del contattore del caricabatterie scattano ripetutamente dentro una singola ricarica, il che frammenta una ricarica vera in decine di marcatori senza dati. Il decoder quindi non emette nessuna sessione di ricarica MBB e lascia il rilevamento della ricarica interamente al BMS.

Derivazione dello stato 538XX dal testo
Testo dell'evento, confrontato senza distinguere maiuscoleStato derivato
Module scheme changed from … to Running modeRUN
Module scheme changed from … to Stopped modeSTOP
Module scheme changed from … to Charging modeCHRG
Entering charge standbyCHRG
Leaving charge standbySTOP

Che cosa ha recuperato la correzione dell'instradamento

I numeri prima e dopo sono veri risultati della pipeline e vanno tenuti, ma etichettati per ciò che misurano. Due moto 538XX sono passate dal nulla a una storia completa: una da 0 giri e 0 km a 112 giri e 678 km, l'altra da 0 a 88 giri e 423 km. Nella stessa esecuzione, i file Gen3 nativi e i veri Gen2 hanno prodotto un output identico byte per byte, quindi il nuovo percorso non ha introdotto regressioni sui formati che già funzionavano.

Quei numeri misurano un file che finalmente raggiunge un decoder. L'upstream sapeva già leggere questi record; le voci andavano perse nell'override sulla struttura binaria descritto in cima a questa sezione. Leggi le cifre come il costo di un bug di instradamento, non come prova che sia stato decifrato un nuovo layout di record.

Una seconda difesa del percorso fatto apposta regge, ed è più stretta dell'affermazione originale. Sui cinque file che hanno raggiunto il percorso Gen2 upstream, il suo rilevatore di sessioni sovra-frammenta pesantemente (546 giri su 602 km, circa 1,1 km per «giro», contro 131 giri e 491 km qui), e le protezioni fisiche di questo progetto respingono circa lo 0,24% delle righe upstream come impossibili. Quindi la logica delle sessioni e le protezioni si meritano il loro posto. Il decoder dei record non aveva bisogno di essere scritto; serviva solo correggere l'instradatore.

L'unità del contachilometri è stata confermata in chilometri, non in metri, per continuità con le letture storiche del contachilometri Gen2 delle stesse moto. Il contratto del formato e il discriminatore sono entrambi fissati da test automatici, quindi una modifica futura che rompe uno dei due fa fallire la build invece di riportare in silenzio queste moto a zero giri.

Perché la soglia è un esito e non una firma

Un rilevamento basato sulla firma scatterebbe a vuoto su ogni vero file Gen2, perché i byte dell'intestazione sono identici. Eseguire la decodifica e giudicare il risultato costa di più, ma si credeva a prova di falsi positivi. Non lo è: il potere discriminante del filtro sulla resa veniva da un bug nel decoder che filtrava, quindi correggere l'escape ha cancellato la separazione. Il filtro ora di proposito conta una popolazione prima dell'unescape che sa essere un artefatto, perché cambiarlo sposterebbe in silenzio 30 file su un altro decoder. Quando una soglia funziona, controlla se sta misurando quello che pensi.

Tipi di record del BMS Gen3

Un file BMS Gen3 esportato dall'app Zero pesa 131.328 byte, esattamente 128 byte in più del file MBB, per un motivo spiegato più sotto, nei marcatori di pagina flash. Le esportazioni del concessionario pesano 262.144 byte. I nomi dei file compaiono come VIN_BMS.bin, VIN_BMS0.bin, VIN_BMS1.bin, VIN_BmsD0_*.bin o VIN_10.bin, a seconda del percorso di esportazione.

È la scheda che conta per i dati elettrici. Tutto ciò che l'applicazione mostra per una moto Gen3 nativa (tensione del pacco, corrente, potenza, scostamento tra le celle, stato di carica, energia di ricarica) nasce dai record qui sotto.

Tipi di record del BMS, misurati su sette file BMS Gen3
TipoNomeDimensioneConteggio per fileTotale nel corpusContenuto
0xFBIntestazione125 B17Tipo di scheda, codice articolo, numero di serie, cellbox, firmware
0xFDEvento di testovariabile1.596–1.99713.178Transizioni di stato, guasti, diagnostica
0x4BTelemetria52 B186–5271.803Tensioni delle celle, corrente, SOC, tensione del pacco, stato
0x4DTelemetria estesa78 B79–126691I campi del 0x4B spostati di +8, più il registro della capacità a carica piena
0x4CDettaglio celle70 B0–6584I campi del 0x4B spostati di +4; scritto nei periodi di funzionamento
0x00 / 0xF0Parziale o debugvariabile12–28127Artefatti di sovrascrittura del buffer circolare e debug del firmware

I sette file contengono in tutto 15.890 record concatenati per lunghezza, da cinque VIN distinti, e le sei righe qui sopra li coprono tutti; la riga dell'intestazione corrisponde ai sette record 0xFB, uno per file. Contati in un altro modo, gli stessi sette file danno 16.005 delimitatori 0xB2 grezzi e 15.998 record delimitati dagli intervalli, che è il numero pubblicato nella pagina sul buffer circolare; sono tre convenzioni sugli stessi byte, non tre misure in disaccordo. Cinque byte di tipo isolati (0x78 due volte, 0x6B, 0x6C, 0x76 una volta ciascuno) sono confluiti nella riga parziale/debug e sono troppo rari per essere caratterizzati. Un 0x4C è un record di 70 byte, e 70 non è nell'elenco di lunghezze che ogni decoder basato sulla lunghezza usa per smistare gli intervalli: per questo ognuno di essi finiva nel parser di testo, finché non è arrivato lo smistamento per tipo.

Record di intestazione (0xFB, 125 byte)

Uno per file. L'intestazione del BMS identifica la scheda di controllo della batteria, non la moto, ed è per questo il posto giusto dove guardare quando un pacco è stato sostituito.

Mappa dei campi dell'intestazione BMS 0xFB
[0]        0xB2
[1]        0x7D (125)
[2]        0xFB
[3:7]      timestamp
[11]       sequence
[12]       UTC-offset setting, int8 hours
[13:16]    "BMS"
[23:31]    board type — "FST BCB" on every Gen3 file measured
[40:52]    part number — 40-08247-01 (3 files), 40-08295-01 (2),
           40-08367-01 (2). That is every value in this corpus
[56:69]    serial number
[72:80]    cellbox part number
[96]       firmware version major
[97:99]    cell count
[99:108]   firmware hash

Record di evento di testo (0xFD, variabile)

Stessa struttura del record di testo dell'MBB: l'intestazione comune di 13 byte, poi ASCII terminato da NUL a partire dal byte 13 del record. Questa pagina diceva che il BMS si distingue per un «marcatore di scheda» pari a 0x01 al byte 12, dove l'MBB ha 0x02; in realtà il byte 12 è l'impostazione del fuso orario UTC, e i due valori erano i fusi orari di due moto. Questi eventi sono il segnale più affidabile per sapere quando la moto è stata accesa, e per questo sono determinanti per il rilevamento delle sessioni.

Fino al 2026-10 il decoder non sapeva dove iniziasse il testo. Prendeva «il primo byte stampabile dal byte 7 in poi», quindi ogni volta che un byte di sotto-secondo, di sequenza o di offset risultava stampabile il testo cominciava lì, e finiva allo zero successivo, che su una moto a UTC+0 è proprio il byte 12. Su 13.522 record di testo BMS in otto file con intestazione integra e timestamp plausibile, 4.268 (31,6%) venivano letti correttamente, 7.234 (53,5%) venivano scartati perché «troppo corti» (7.025 di essi con testo reale, come «Entering ZERO_BMS_STATE_IDLE») e 1.890 venivano pubblicati come spazzatura, tipo «Po\x0e», con altri 130 che avevano un prefisso spurio. Il byte 13 è stampabile in 8.786 degli 8.788 record di testo BMS non toccati da alcun marcatore di pagina, e in 18.570 su 18.570 record di testo MBB. Solo il tipo 0xFD è testo: ogni altro record arrivato al parser di testo (un record di telemetria di lunghezza sbagliata, un record il cui byte di tipo era stato sovrascritto da un marcatore di pagina) veniva setacciato per i byte stampabili e pubblicato come «evento», e ora non più. La correzione più che raddoppia gli eventi della macchina a stati che un file restituisce, e migliora il rilevamento dei giri dal BMS: i giri spezzati tornano a fondersi nell'unico giro registrato dall'MBB.

Tutto questo è il layout dei record FST, e ora il decoder lo verifica file per file, dai byte, prima di applicarlo. Lo stesso decoder riceve anche file che non sono FST (dump BMS di forma Gen2 e strane esportazioni che la sonda di telemetria 0xB2 instrada qui), e nei loro record il testo parte davvero dal byte 7. Su quei file la regola del byte 13 tagliava sei caratteri da ogni messaggio («DEBUG: CAN Link Is Down» diventava «CAN Link Is Down») e scartava i record rimasti troppo corti. Un file conta come FST quando il marcatore di pagina apre la sua seconda e terza pagina, oppure, in mancanza, quando la parola dei sotto-secondi è al massimo 1.000.000 in almeno l'80% dei record e il byte 12 si legge come un unico offset UTC civile dominante; su 374 file le due popolazioni stanno molto distanti (almeno 0,97 contro al massimo 0,16 nel primo test). Tutto il resto segue esattamente la regola originale.

Un record di testo attraversato da un marcatore di pagina è un prefisso di ciò che il firmware ha scritto, perché il marcatore comincia con un byte zero e lì termina la stringa. Viene conservato e segnalato come troncato, e un pattern che cattura fino alla sua fine non è considerato affidabile: «Entering ZERO_BMS_STATE_HIB» tagliato a metà non è lo stato HIB.

  • «Entering ZERO_BMS_STATE_OPERATIONAL»: la moto è stata accesa.
  • «Entering ZERO_BMS_STATE_IDLE»: la moto è stata spenta.
  • «Entering ZERO_BMS_STATE_HIBERNATE», «…_STANDBY», «…_PRECHARGE», «…_UNLOCK»: gli altri stati.
  • «Precharge complete» e «Precharge: 95%»: avanzamento della precarica dei contattori.
  • «Contactor open command received», preceduto da un conteggio in millivolt delle celle.
  • «Fault set: INVALID/NO CELL TYPE»: un errore CRC nella lettura del cellbox.
  • «Saving stats, hibernating for 86400 sec»: l'intervallo di sonno del BMS, di solito un giorno, contro l'ora dell'MBB.
Byte 24 del BMS: payload[24] / record[32]Frazione sotto carico per valore osservato: un indicatore di attività monotono, non una macchina a statibyte 24sotto carico: payload[27] = 0xFFnquotabus attivomediana |I| mA25%50%75%100%0x0974,5%472.0%72,3%5,7960x1062,2%1114.8%57,7%2130x0C45,2%56624.4%44,3%00x0F40,7%542.3%40,7%720x0835,9%391.7%35,9%00x0A34,5%1426.1%34,5%00xFF29,2%241.0%29,2%00x0720,7%291.3%20,7%00x0D16,0%1315.6%15,3%00x1215,4%522.2%15,4%00x0B14,4%60326.0%13,6%00x0613,9%361.6%11,1%00x0012,5%401.7%25,0%00x1112,2%411.8%12,2%10x0512,0%251.1%12,0%00x0E7,7%261.1%7,7%00x165,9%341.5%5,9%00x143,9%512.2%2,0%00x153,3%301.3%3,3%00x172,9%351.5%2,9%00x132,7%371.6%0,0%00x180,0%301.3%0,0%0uno dei quattro valori nominati dall'enum ritirato (0x09 · 0x0A · 0x0B · 0x0C)un valore che l'enum non nominava mai0xFF: una sentinella flash, non un valore di stato. Elencato solo perché supera la soglia n ≥ 20.Perché la lettura a quattro stati non sopravvive alla rimisurazioneRicorrono 37 valori distinti, da 0x00 a 0x23 più le sentinelle flash 0xF0 / 0xFF. 0x09, 0x0A, 0x0B e 0x0Cinsieme coprono 1.358 delle 2.319 righe (58,6%). L'altro 41% sono valori per cui l'enum non ha alcun nome.Non è un contatore: l'82,0% delle differenze consecutive dentro una finestra di 120 s è esattamente zero (973 su 1.186).Nemmeno una temperatura: r = −0,05 contro il byte 43, a sua volta ritrattato come temperatura (r = −0,41 contro le celle MBB).Uno dei quattro si allinea con gli stati di testo propri del BMS. Portando avanti nel tempoogni evento «Entering ZERO_BMS_STATE_x», 0x09 sta sotto UNLOCK sul 62% delle righe (n = 45), ilnome che gli era stato dato. 0x0B no: il valore chiamato IDLE sta sotto HIBERNATE al 41%, IDLE al 26%, UNLOCK al 14%.Portato dai record 0x4B da 52 B, FST Mono da 50 B, 0x4C da 70 B (+4) e 0x4D da 78 B (+8). Nessun decoder si ramifica su di esso:memorizzato tale e quale come LogEntry.bms_state_code. I discriminatori affidabili del carico sono payload[27] e payload[28].
payload[24] (record[32]) è memorizzato come LogEntry.bms_state_code e nessun codice si ramifica su di esso; tasks.py lo raggruppa solo in una distribuzione per report. docs/GEN3_BINARY_FORMAT.md una volta ha mappato quattro dei suoi valori su una macchina a stati (0x0B idle, 0x09 unlock, 0x0A precharge, 0x0C active), e quella lettura è stata ritrattata; il documento ora porta la ritrattazione e la docstring di parser.py dice a chiare lettere di non ripubblicarla. Questa figura un tempo la disegnava, frecce comprese. Ciò che sopravvive alla rimisurazione è più debole e a una dimensione: la frazione sotto carico sale in modo grossomodo monotono su almeno otto codici, e due valori che l'enum non nominava mai, 0x10 (n = 111, 62,2% sotto carico) e 0x0F (n = 54, 40,7%), stanno dentro quella catena, 0x10 sopra 0x0C. Quindi l'ordinamento depone contro il trattare uno dei quattro come stato con nome. Rimisurato sulle 2.319 righe di telemetria che il decoder distribuito emette dai 7 dump BMS Gen3 in logs/: divisione a ogni 0xB2, unescape di ogni fetta, distribuzione sul byte del tipo con la lunghezza dopo l'unescape come controllo incrociato (0x4C → +4, 0x4D → +8, altrimenti la regola di lunghezza 50/52/78 a +0), poi il filtro delle celle 2.500–4.500 mV. La figura portava una tabella di 1.557 righe fino al 2026-07-30; 1.557 è ciò che questo decoder emetteva prima della correzione dell'escape e della distribuzione per tipo, quindi ogni conteggio al suo interno è stato ricavato di nuovo e non riscalato. Tratta il byte come un suggerimento di attività opaco per firmware, non come una decodifica.

Record di telemetria (0x4B, 52 byte): la fonte dati principale

Gli offset del payload qui sotto sono relativi all'inizio del payload, al byte 8 del record, secondo la convenzione del decoder. Per convertirli in assoluti del record, aggiungi 8: payload[38] è record[46].

Il decoder valida prima di fidarsi. Tensioni delle celle fuori da 2.500–4.500 mV fanno scartare l'intero record come corrotto, ed è anche ciò che respinge gli eventi di testo che ogni tanto finiscono su un intervallo della dimensione di una telemetria. Il SOC è accettato solo da 1 a 100; uno zero significa che il pacco dorme o che il valore non è stato calcolato, non che è vuoto.

Record di telemetria BMS 0x4B (52 byte)Offset assoluti nel record. payload[k] = record[8+k]. Su uno 0x4D aggiungi 8 a ogni offset qui sotto; su uno 0x4C aggiungi 4.+0+1+2+3+4+5+6+7+8+9+10+11+12[0][13][26][39]0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051★ record[46:49] = payload[38:41]: tensione del pacco misurata, uint24 LE, millivoltDocumentato come contatore interno dal primo decoder Gen3 fino al 2026-07-01. Reidentificato perché il«contatore» calava sotto carico: 2.189/2.319 righe = 94,4% (92,1–96,5% per file) cadono dentro 28 × cell_min … 28 × cell_max.intestazione: delimitatore · size · type · µs · seq · offset UTCtimestamp uint32 LE, [3:7]tensioni di cella (bassa / OCV / alta)SOC %corrente del pacco, int32 LE mAbyte di attività, carico, bus, modalità di report★ tensione del pacco misurata, uint24 LE mVnon decodificato / riempimento
Il record 0x4B da 52 byte è l'unico canale elettrico per campione che produce una moto Gen3 nativa. Gli offset sono assoluti nel record; il decoder legge un payload da 44 byte che parte dal byte 8 del record, quindi payload[k] == record[8+k]. Il campo evidenziato record[46:49] (payload[38:41]) portava il commento «contatore interno ~43000-49000» che «misteriosamente calava sotto carico». Cala perché è la tensione del pacco. Rimisurato qui sui 7 dump BMS Gen3, sulle 2.319 righe di telemetria che il decoder distribuito emette: 2.189 su 2.319 (94,4%; per file 92,1–96,5%) soddisfano 28 × cell_min ≤ value ≤ 28 × cell_max, che è esattamente l'intervallo di accettazione che _parse_gen3_bms_entries usa ora prima di ripiegare su 28 × mean(cell_low, cell_high). Questa griglia è il formato 0x4B e nient'altro. Uno 0x4D condivide solo l'intestazione di 13 byte e poi inserisce 8 byte; uno 0x4C ne inserisce 4. Provando gli scostamenti candidati e controllando se le parole di cella cadono in una fascia plausibile di 2.500–4.500 mV, uno 0x4D ottiene 0 a questi offset e 619 su 666 a +8, e uno 0x4C ottiene 0 qui e 75 su 78 a +4. Applicata a un record esteso, questa mappa dà valori che un controllo di plausibilità scarta in silenzio, non valori leggermente sbagliati. Prima che lo scostamento fosse trovato, qui questo è costato 694 righe di telemetria, il 42,7% della popolazione. (La vecchia cifra di 1.557 righe ancora in circolazione è ciò che questo decoder emetteva prima di quella correzione e prima della correzione dell'escape; 1.557 → 1.625 → 2.319.)
payload[9] stabilito empiricamente sulle 1.598 righe 0x4B che il decoder emette
payload[9]RigheModalità di report 3 (sonno)SOC = 0Flag di carico 0x78Media |corrente|
0x001.05757 (5,4%)19 (1,8%)590 (55,8%)3.869 mA
0x20517427 (82,6%)517 (100%)504 (97,5%)40 mA
0xF0 / 0xFF246 (25,0%)6 (25,0%)14 (58,3%)3.356 mA

La popolazione sono i 1.598 record 0x4B dentro le 2.319 righe di telemetria che il decoder in produzione emette, perché payload[9] sta a questo offset solo in un 0x4B; in un 0x4D è otto byte più avanti e in un 0x4C quattro. Tutte le 517 righe con payload[9] = 0x20 hanno SOC = 0, il 97,5% non ha carico e la loro corrente media è 40 mA contro i 3.869 mA delle righe 0x00. 0x20 è il valore di sonno e 0x00 è sveglio. La documentazione interna indicava la polarità opposta; il codice e la misura concordano tra loro e la documentazione è sbagliata. 0xF0 e 0xFF sono sentinelle della flash, non stati. Una versione precedente di questa tabella riportava 1.022 / 511 / 24 ed era stata contata prima della correzione dell'escape del 2026-07-29.

Distribuzione della modalità di report, payload[37], sulle 1.598 righe 0x4B
ValoreSignificatoRigheQuota
1Report SOC standard52232,7%
3Sonno / minimo49030,7%
7Attivo ad alta frequenza, ricarica o scarica43727,3%
4Inattivo311,9%
5Precarica291,8%
6Sconosciuto281,8%
0 / 240 / 255Non inizializzato o sentinella della flash613,8%

Questo byte è payload[37], cioè il byte 45 del record in un 0x4B. A volte viene citato come «byte 37 di ogni voce BMS», che indica il byte sbagliato. La popolazione sono le 1.598 righe 0x4B, perché è l'unico tipo di record in cui payload[37] e il byte 45 del record coincidono; un 0x4D scrive la sua modalità al byte 53 del record. Sei valori reali più le sentinelle spiegano ogni riga 0x4B e, a differenza di payload[24] più sotto, questo si comporta davvero come un enum. Su tutte le 2.319 righe emesse, lette all'offset spostato di ciascun tipo, la distribuzione è 7 su 592, 1 su 530, 2 su 520, 3 su 500, 4 su 31, 5 su 30, 6 su 28 e una sentinella su 88. Il valore 2 viene interamente dallo 0x4D.

Payload BMS 0x4B, 44 byte, offset relativi al byte 8 del record
payload[0:3]    = record[8:11], the upper three bytes of the microsecond word.
                payload[2] is always 0x00 (the word never exceeds 1,000,000);
                the 0xF0 / 0xFF once read here as a "flag" is the page marker
payload[3]      = record[11], the sequence counter (same byte on 0x4C / 0x4D)
payload[4]      = record[12], the UTC-offset setting, int8 hours
payload[5]      = record[13], 0x00 on 1,347 of 1,347 marker-free 0x4B records
                (was "constant 0x01, BMS marker")
payload[9]      sleep indicator — 0x20 sleeping, 0x00 awake (measured, see below)
payload[13:15]  cell voltage minimum, uint16 LE, mV
payload[15:17]  cell open-circuit voltage low, uint16 LE, mV
payload[17:19]  cell voltage maximum, uint16 LE, mV
payload[19]     SOC %, uint8 — 0xFF or 0xF0 means invalid
payload[20:24]  pack current, int32 LE, mA — positive discharge, negative charge
payload[22:24]  the HIGH HALF of that word, not a flag — see below
payload[24]     opaque byte — stored verbatim, NOT decoded; 37 values, no enum
payload[25]     constant 0x33
payload[26]     flag — 0x00 normal, 0x0C transitional
payload[27]     load flag — 0x78 no load, 0xFF under load
payload[28]     bus engaged — 0x00 off, 0x01 on
payload[37]     report mode — 1 standard, 3 sleep, 4 idle, 5 precharge,
                6 unknown, 7 active. A seventh value, 2, is written only
                by the 0x4D record.
payload[38:41]  measured pack voltage, uint24 LE, mV — see the next section
payload[41:43]  unknown / padding
payload[43]     NOT a temperature - retracted, see below

payload[24] non è un codice di stato: una ritrattazione

La corrente del pacco è il più grande errore di misura che questa pagina abbia dovuto correggere. Veniva letta come un valore a 16 bit con segno in milliampere, che arriva al massimo a ±32,767 A. Un pacco Zero assorbe parecchie centinaia di ampere in accelerazione e, siccome nulla lo limita, il valore memorizzato andava in overflow invece di saturare: conteneva la corrente vera modulo 65.536 mA, che inverte il segno anziché appiattire il picco. Per questo il verso registrato durante la guida era quasi un testa o croce: 55,5% di scarica, contro il 78,4% sul log MBB della stessa moto negli stessi giri.

È un valore a 32 bit, e i due byte che questa pagina descriveva come indicatore firmware di ricarica ne sono la metà alta. Su tutti i 72 file BMS Gen3 nativi in produzione, 45.060 record di telemetria: quei byte valgono FF FF nell'80,5% dei record con la metà bassa negativa e 00 00 nell'84,9% di quelli con la metà bassa positiva. È un'estensione del segno. Il flag era reale nel senso che scattava durante la ricarica, ma non per il motivo indicato: FF FF è l'aspetto di un numero negativo, e le correnti di ricarica sono negative.

Tre verifiche, ciascuna contro la propria ipotesi nulla. Il conteggio dei coulomb contro lo stato di carica del pacco stesso: su 84 segmenti contigui il segno della corrente integrata concorda con la direzione della variazione di SOC in 83 casi su 84 con la lettura a 32 bit, contro 49 su 84 con quella a 16 bit, dove il 50% è l'ipotesi nulla del testa o croce. La capacità implicita è di 138,7 Ah ogni 100 punti di SOC (un pacco ZF14.4, ZF15.6 o ZF17.3 ne ha 129, 139 o 154), contro i 16,8 Ah di prima, che non è una moto. E la legge di Ohm contro la tensione del pacco verificata separatamente dà una pendenza mediana di −29,9 mΩ, negativa su 35 moto su 38, una resistenza interna plausibile per un 28 in serie; la vecchia lettura dava −5,6 mΩ e negativa su 20 su 38.

Una finestra di corrente illeggibile ora non restituisce nulla invece di zero, perché lo zero si legge come pacco inattivo. Uno zero genuino viene conservato: è una lettura vera in circa un quinto di tutti i record.

Questo sito ha pubblicato, e le nostre note interne riportavano, un enum a quattro valori per payload[24]: 0x0B inattivo, 0x0C attivo, 0x09 sblocco, 0x0A precarica. È ritirato. Il byte viene letto da ogni record di telemetria e memorizzato così com'è, nessun decoder agisce sul suo valore e nulla nel corpus sostiene di collegarlo ai nomi degli stati del BMS. Se hai preso quell'enum da qui, da una sua copia o da un decoder costruito su di esso, scartalo.

Sulle stesse 2.319 righe di telemetria che il decoder in produzione emette, usate in tutto il resto della pagina, payload[24] assume 37 valori distinti: ogni valore da 0x00 a 0x23 tranne 0x02, più le due sentinelle della flash 0xF0 e 0xFF. I quattro codici nominati dall'enum coprono 1.358 righe, cioè il 58,6%, quindi due righe su cinque hanno un valore per cui l'enum non ha un nome; e 0x09, lo stato «sblocco», sono 47 righe, il 2,0% del corpus.

Il byte è stato sottoposto a tre test separati e li ha falliti tutti e tre. Non è un contatore: l'82,0% dei delta consecutivi dentro una finestra di 120 secondi è esattamente zero, 973 su 1.186, e la sequenza non cresce in modo monotono né si riavvolge. Non è una temperatura: correlato con payload[43] nello stesso record dà r = −0,05, e i due byte sono uguali nell'1,3% delle righe, anche se quel confronto in particolare ora non vale nulla, perché anche payload[43] si è rivelato non essere una temperatura. E non segue la macchina a stati di testo del BMS come una partizione. Se trascini avanti nel tempo ogni evento «Entering ZERO_BMS_STATE_x», uno dei quattro corrisponde al nome che gli era stato dato (0x09 sta sotto UNLOCK nel 62% delle righe, n = 45), ma 0x0B no: il valore chiamato «inattivo» sta sotto HIBERNATE nel 41%, IDLE nel 26% e UNLOCK nel 14%. Una corrispondenza su quattro è ciò che si vede quando un enum a quattro stati è sbagliato.

L'unica proprietà che sopravvive è debole e non è un enum. Ordinato per la frazione di righe sotto carico, il byte funziona come un indicatore grossolano dell'attività su almeno otto valori, ma due valori mai nominati dall'enum, 0x10 con il 62,2% sotto carico e 0x0F con il 40,7%, stanno dentro la stessa catena che l'enum usava come prova, uno dei due sopra il presunto codice «attivo». Una macchina a quattro stati non può avere stati senza nome in mezzo ai suoi stati.

payload[24] è un byte interno del firmware che varia con l'attività, ha almeno 37 valori e nessun significato decodificato. Trattalo come opaco, e non scrivere da nessuna parte «0x0B = inattivo, 0x0C = attivo» senza averlo prima ricavato di nuovo dai tuoi file.

Distribuzione misurata di payload[24], 2.319 righe di telemetria, sette file BMS
ValoreRigheQuotaSotto caricoEnum dichiarato
0x0B60326,0%14,4%inattivo
0x0C56624,4%45,2%attivo
0x0A1426,1%34,5%precarica
0x0D1315,6%16,0%senza nome
0x101114,8%62,2%senza nome
0x0F542,3%40,7%senza nome
0x12522,2%15,4%senza nome
0x14512,2%3,9%senza nome
0x09472,0%74,5%sblocco
0x11411,8%12,2%senza nome
0x00401,7%12,5%senza nome
0x08391,7%35,9%senza nome
0x13 / 0x16 / 0x171064,6%2,7% / 5,9% / 2,9%senza nome
0x06361,6%13,9%senza nome
0x15 / 0x18602,6%3,3% / 0,0%senza nome
0x07291,3%20,7%senza nome
0x0E261,1%7,7%senza nome
0x05251,1%12,0%senza nome
0xF0 / 0xFF431,9%10,5% / 29,2%sentinelle della flash
14 altri valori, ciascuno sotto le 20 righe1175,0%0–33%senza nome

Ogni valore osservato nel corpus è elencato o confluito nell'ultima riga; nulla è omesso per ordine estetico, e le righe sommano a 2.319. «Sotto carico» è la frazione di righe di quel gruppo con payload[27] = 0xFF, letto all'offset spostato di ciascun tipo di record, la stessa definizione usata dalla figura qui sopra, così le due concordano riga per riga. L'ordinamento per quella colonna è l'unica struttura del byte, ed è un continuo su almeno otto valori, non quattro stati. Una versione precedente di questa tabella era contata su 1.557 righe, la popolazione che questo decoder emetteva prima della correzione dell'escape e dello smistamento per tipo del 2026-07-29; ogni conteggio è cambiato, quindi tutti sono stati ricavati di nuovo e non riscalati.

Ritirato: l'enum di stato 0x09–0x0C

La corrispondenza 0x0B inattivo / 0x0C attivo / 0x09 sblocco / 0x0A precarica è stata pubblicata su questo sito ed è sbagliata. Copre il 58,6% delle 2.319 righe di telemetria che il decoder in produzione emette, fallisce un test del contatore e uno della temperatura, coincide con la macchina a stati di testo su uno solo dei suoi quattro valori e non su quattro, ed è intercalata da valori senza nome che si comportano allo stesso modo. La macchina a stati del BMS esiste, ma vive negli eventi di testo ASCII, non in questo byte.

Telemetria estesa (0x4D, 78 byte) e lo spostamento di +8

Questa pagina diceva «i primi 52 byte di un record 0x4D hanno lo stesso layout di un record 0x4B». Non è così, ed è l'errore nella mappa dei campi che più probabilmente fa perdere una giornata a chi implementa il formato per conto suo. Un 0x4D condivide solo l'intestazione di 13 byte. Poi inserisce otto byte, quindi ogni campo di misura sta otto byte più avanti rispetto alla posizione nel 0x4B, e i «26 byte extra» che questa sezione descriveva sono gli ultimi 26 byte di un payload spostato, non un suffisso aggiunto a uno non spostato.

La misura è inequivocabile. Abbiamo provato spostamenti candidati da 0 a 12 verificando se le due parole di tensione delle celle cadono tra 2.500 e 4.500 mV, sui record di lunghezza esatta in sette file BMS Gen3: un 0x4B totalizza 1.598 su 1.732 con spostamento 0 e al massimo 14 in qualsiasi altro; un 0x4D totalizza zero con spostamento 0 e 619 su 666 a +8, con il secondo miglior spostamento a 2; un 0x4C totalizza zero con spostamento 0 e 75 su 78 a +4, con il secondo a 3. I denominatori cambiano di qualche record a seconda di come si percorre il file (una scansione per lunghezza concatenata sugli stessi dump dà 624 su 671), ma la frazione è del 92,9% in ogni modo in cui l'abbiamo contata, e il punteggio agli offset del 0x4B è zero in ogni modo. Lo zero agli offset nominali è il numero importante: un decoder che usa la mappa del 0x4B su un 0x4D fallisce del tutto invece di peggiorare gradualmente, e se ha un controllo di plausibilità sulle celle scarterà ogni record in silenzio.

Quattro conferme del +8 che non toccano mai il filtro sulle celle con cui quei record sono stati selezionati. L'uint24 a record[54:57] è la tensione del pacco che il 0x4B scrive a record[46:49], con una mediana di 104.793 mV, dentro l'intervallo delle 28 celle su 578 record, un rapporto tra pacco e cella più bassa con mediana 28,020, e cella bassa non maggiore della cella alta su 619 record su 619. Il byte 59 del record si comporta esattamente come il byte al record 51 di un 0x4B (il byte che questa pagina pubblicò una volta come temperatura, e che non lo è; vedi il riquadro più sotto): mediana 10, mentre sul 0x4B è 13, e un intervallo da 0 a 27 una volta messe da parte le 14 righe con una sentinella della flash 0xF0 o 0xFF; preso grezzo l'intervallo è tutto 0–255, ed è ciò che una sentinella fa a un campo di piccoli interi. I byte 51 e 52 del record sono ciascuno zero su 603 di 619 e entrambi zero su 594, a specchio dei due riempimenti a zero che affiancano il byte di modalità di report del 0x4B. E il flag di carico, il byte di bus inserito e la modalità di report concordano tra loro e non con qualcosa di esterno, anche se non alla perfezione: dei 72 record con carico 0xFF, 68 leggono anche bus inserito e 67 modalità di report 7; dei 527 con carico 0x78, 502 leggono modalità di report 2. La modalità di report 2 compare in tutto su 520 righe, quindi i due insiemi quasi coincidono ma non esattamente.

Quest'ultimo numero è una piccola scoperta a sé. La modalità di report 2 è un valore che il record 0x4B non scrive mai, quindi l'enum ha sette valori, non sei: 1, 3, 4, 5, 6 e 7 dal 0x4B più il 2 dal 0x4D.

Il costo dello spostamento, prima di scoprirlo, era che ogni riga di telemetria 0x4D e 0x4C veniva scartata: 744 record alle lunghezze canoniche arrivavano al ramo della telemetria e ognuno veniva fermato dal controllo sulla tensione delle celle. Correggere gli offset ne ha recuperati 694 su questo corpus, 619 dal 0x4D e 75 dal 0x4C, cioè il 42,7% di telemetria BMS Gen3 in più senza perderne nessuna. L'ottantaquattro per cento delle righe 0x4D recuperate (521 su 619, e dal 47% al 96% a seconda del file) cade dentro un intervallo di più di un'ora nella serie 0x4B dello stesso file, quindi è densità di campionamento reale e non duplicati, e alimenta la pagina della batteria e la stima dello stato di salute. L'unico campo che si è sempre salvato è il registro della capacità, perché viene raccolto in base alla lunghezza del record prima che il filtro entri in azione.

Byte extra del BMS 0x4D, offset da 52 a 77 del record completo
extra[0:2]    = record[52:54]  two zero pad bytes flanking the report-mode byte
                               (the 0x4B writes the same pair at record[43:45])
extra[1]      = record[53]     report mode — 2 on 520/619, 7 on 72
extra[2:5]    = record[54:57]  measured pack voltage, uint24 LE, mV — the 0x4B's
                               record[46:49] shifted +8. NOT a coulomb counter.
extra[5]      = record[57]     zero pad
extra[6]      = record[58]     flag byte — 0, 1, 3, 5, 6, 9, 25 observed
extra[7]      = record[59]     the 0x4B's record[51] shifted +8 - NOT a temperature
extra[8:10]   per-bike calibration, uint16 LE — observed 3,083–5,910; the two
              bytes differ by 0–2. Unverified — treat as undecoded.
extra[10:12]  per-bike cumulative counter, uint16 LE — observed 38,967–56,414
extra[12:14]  calibration — byte 12 constant 0x03, byte 13 varies 150–162
extra[14]     constant 0x00
extra[15:18]  full-charge capacity, uint24 LE, mAh = record[67:70]
extra[18:20]  constant 0x0000
extra[20]     sub-mode — alternates between 4 and 5
extra[21]     constant 0x00
extra[22:25]  full-charge capacity, twin copy = record[74:77]
extra[25]     trailing byte

Ritirati: il contatore di coulomb e l'enum dei sotto-stati

Due righe della versione precedente di questa mappa sono ritirate. extra[2:4] era pubblicato come «contatore di coulomb, uint16 LE: cala di circa 3 unità all'ora in ibernazione». Sono i 16 bit bassi dell'uint24 della tensione del pacco a record[54:57], un'identità che vale su 619 record accettati su 619, e il calo di «3 unità all'ora» è circa 3 millivolt all'ora di cedimento della tensione del pacco a moto ferma. È lo stesso errore di lettura che questa pagina aveva già ritrattato per la copia 0x4B del campo, diciotto righe prima. La copia 0x4D era sfuggita, ed è un buon argomento per cercare una ritrattazione con grep invece di correggerla in un solo punto. E extra[6:8] era pubblicato come «flag dei sotto-stati, uint16 LE: osservati 256, 1024, 5632». È una coppia di byte [flag, valore]: il byte alto è lo stesso byte da 0 a 27 che il 0x4B porta al byte 51 del record (256 → 1, 1024 → 4, 5632 → 22). Questo riquadro lo chiamava «gradi Celsius», e non è una temperatura. È stato ritirato il 2026-07-31 rispetto alla temperatura del pacco del gemello MBB (r = −0,074 su 1.275 coppie), e quel confronto risultò aver usato la parola MBB sbagliata, perché le etichette di temperatura dell'MBB erano loro stesse sfasate di uno slot fino al 2026-09-07. Rimisurato rispetto alle temperature delle celle MBB corrette, accoppiate entro 90 secondi sulle otto coppie della stessa moto qui presenti (n = 339), correla a r = −0,41 con la temperatura della cella più bassa e −0,43 con l'ambiente, sta in mediana a 7 °C di distanza, ed è entro 1 °C nell'1,5% delle coppie. Una temperatura non va in senso opposto a due termometri. Il byte basso non è sempre zero: le coppie osservate includono (0,2), (6,18), (0,4), (6,24), (1,13) e (3,10). L'enum a tre valori era un artefatto dell'aver guardato solo righe il cui byte di flag era per caso zero. Il zero-log-parser upstream è arrivato indipendentemente alla stessa conclusione e ha abbandonato la propria lettura del byte nel 2026-09.

Dettaglio celle (0x4C, 70 byte), spostato di +4, e la questione dei 50 byte

Il record 0x4C compare solo nei periodi di funzionamento ed è raro: 84 record in tutto il corpus, con un conteggio per file tra 0 e 65: tre dei sette file non ne hanno nessuno, e uno ne ha 65 degli 84. (Questa frase diceva «0 e 58», in contraddizione con la tabella qui sopra. Rimisurato il 2026-07-30 con la scansione dei byte in produzione: i conteggi per file sono 0, 0, 0, 4, 7, 8, 65, e la stessa scansione riproduce esattamente i valori della tabella, 0x4B 186–527 / 1.803 e 0x4D 79–126 / 691. La tabella era giusta.) Porta lo stesso payload di un 0x4B spostato di quattro byte più avanti, con lo stesso meccanismo degli otto del 0x4D: quattro byte inseriti dopo l'intestazione condivisa di 13 byte. Sui 78 record 0x4C di lunghezza esatta qui presenti, le tensioni delle celle sono plausibili a +4 su 75 (96,2%) e agli offset del 0x4B su zero.

A +4 il resto del record è altrettanto coerente, ed è ciò che distingue uno spostamento reale da uno fortuito. Il byte 48 del record è un riempimento a zero su 75 di 75 e il byte 47 su 74 di 75, il byte 49 del record è la modalità di report e vale 7 (attivo ad alta frequenza) su 75 di 75, il byte «non è una temperatura» al byte 55 del record ha una mediana di 14 escluse le tre righe con sentinella della flash (16 se non le escludi), e l'uint24 della tensione del pacco a record[50:53] ha una mediana di 108.144 mV. La corrente mediana è −9,5 A, quindi questi record vengono scritti durante la ricarica.

Finché questo decoder non ha imparato lo spostamento, non ne ha mai letto uno: 70 non era nell'elenco di smistamento per intervallo, quindi ogni 0x4C andava al parser di testo e di eventi. Diciotto di essi, nel corpus, hanno prodotto un «evento» il cui testo erano tre byte stampabili consecutivi del payload binario, stringhe come «@~\x05» e «7\x0b3». Quelle diciotto righe sono le uniche voci che lo smistamento per tipo toglie.

Una variante di telemetria da 50 byte, a volte chiamata FST Mono, è documentata sulla scheda SR/S con codice articolo 40-08201. Usa la stessa mappa dei campi del record da 52 byte, tagliata dei due byte finali, quindi non ha affatto payload[43]. Su questa base il decoder accetta un intervallo di 50 byte nel percorso della telemetria.

Risolto da allora, e conservato per la storia. Misurato su tutti i 72 file BMS Gen3 nativi in produzione, otto file di quattro moto sono scritti interamente nella famiglia corta (40-08201 «FST Mono» su sette, 40-08213 «FST Mod» su uno), senza alcun record di telemetria della famiglia standard in mezzo, e gli spostamenti +4 / +8 valgono invariati. Quanto segue valeva per il corpus di sette file. Nessuno dei sette file BMS misurati qui viene da una scheda 40-08201 (sono 40-08247-01 su tre file, 40-08295-01 su due e 40-08367-01 su due, e quell'elenco è esaustivo per questo corpus), quindi nulla qui può confermare la variante. Quello che mostra è un costo. Dei 514 intervalli da cinquanta byte nel corpus, 509 sono ancora cinquanta byte dopo il ripristino degli escape, e il 98,0% porta il byte di tipo 0xFD, cioè sono eventi di testo; nessuno porta 0x4B. Ognuno di essi viene passato al decoder della telemetria e poi respinto dal controllo di plausibilità sulle celle, ed è per questo che l'instradamento sbagliato è innocuo nella pratica e non solo non rilevato.

Controlla il byte di tipo, non solo l'intervallo

Un decoder scritto a partire da questa specifica dovrebbe smistare su record[2] e usare la lunghezza dopo il ripristino degli escape come controllo incrociato, cioè l'inverso di ciò che fa un decoder che parte dall'intervallo. Servono tre mappe di offset, non una: 0x4B a +0, 0x4C a +4, 0x4D a +8. Smistare solo sulla lunghezza non può esprimerlo, perché non distingue un record da 78 byte di tipo 0x4D da qualsiasi altro record da 78 byte. È esattamente così che 744 righe di telemetria venivano lette agli offset sbagliati e poi scartate in silenzio da un controllo di plausibilità che faceva il suo lavoro. (744 è la cifra che questa pagina misura altrove: 666 0x4D estesi più 78 0x4C di dettaglio celle che arrivano al ramo, di cui 694 recuperati. Una bozza precedente diceva 675, che appartiene alla convenzione solo 0x4D, cieca agli escape, che questa pagina passa una sezione a ritrattare.)

Il marcatore di pagina flash del BMS: quattro byte sovrascritti a ogni pagina

Un file nativo della gestione batteria Gen3 viene scritto nella flash in pagine da 128 byte, e l'inizio di ogni pagina dopo la prima porta gli stessi quattro byte: 00 F0 FF 00. Non sono un separatore tra record e non vengono inseriti da nessuna parte. Sono scritti SOPRA ciò che il firmware aveva messo a quell'offset (il delimitatore di un record, la sua lunghezza, il suo tipo, parte del timestamp o una misura), e i quattro byte che c'erano sono andati. Nulla nel file può riportarli indietro.

Riconoscere il marcatore è facile, perché la sua posizione non varia mai: offset di file 128·k per k da 1 a 1.025 (1.025 pagine su 1.025 dopo la prima) in tutti gli otto file nativi della batteria Gen3 di questo corpus, 8.200 marcatori in tutto, e in nessuno dei dieci file della scheda principale, che non sono paginati. Un decoder può quindi trovare ogni marcatore prima di delimitare un solo record. Quello che non può fare è guardare un valore decodificato dopo e capire se l'ha prodotto un marcatore, perché i byte del marcatore si decodificano in numeri dall'aspetto ordinario. La figura mostra due record veri che ne sono stati colpiti.

Il marcatore di pagina flash del BMS, scritto sopra un recordDue veri record 0x4B (52 byte), anonimizzati. Rosso = i quattro byte che il marcatore ha sostituito. ·· = oscurato.A · il marcatore cade dentro i campi: byte del record 29–32B203414B2··3··4··56A6887E980690010381102120013001400150016001700180019002015210E2215230E2418250E26232700280029F030FF3100323333F0347835…intestazione da 13 bytecelleSoCcorrenteattivitàLetto attraverso il marcatore (versione 3.36): corrente = byte 28–31 = 00 00 F0 FF → −1.048.576 mA, una carica da 1.048 A3.37.0: corrente e byte di attività trattenuti; SoC 35 %, cella più bassa / più alta 3.605 / 3.608 mV letti come scrittiB · il marcatore cade sull'intestazione: il byte del tipo e i tre byte bassi del timestampB20341002F03FF4005696487C480790010141101120013001400150016001700180019002075210F2275230F2478250F264C27CA28FF29FF30FF310C32333300347835…tipotimestampµsseqUTCcelleSoCcorrenteLetto attraverso (versione 3.36): tipo 0x00, decodificato come telemetria perché lungo 52 byte; timestamp F0 FF 00 69→ 0x6900FFF0 = 2025-10-28 17:40:00 UTC, lo stesso secondo su 95 record di 5 delle 6 moto di questo corpus3.37.0: timestamp trattenuto, la riga resta senza data; celle 3.957 / 3.960 mV, SoC 76 %, corrente −54 mA come scrittiDove cadono gli 8.200 marcatori negli 8 file BMS Gen3 nativi, per record in cui capitano:5.807 dentro payload o testo · 635 sui microsecondi · 612 sullo 0xB2 del record successivo · 574 sul byte alto di un timestamp302 sul byte di sequenza o di offset · 139 sul byte del tipo e sui tre byte bassi del timestamp · 131 sulla lunghezza,il tipo e i due byte bassi. Solo gli ultimi due lasciano un timestamp che sembra ancora plausibile: 268 righe, 38 secondi falsi distinti.
Due veri record degli otto file BMS Gen3 nativi in logs/, anonimizzati: non è mostrato nessun file, VIN o data di chi guida, e nel record A i tre byte bassi del vero timestamp sono oscurati. I byte rossi sono il marcatore. La flash del pacco scrive 00 F0 FF 00 all'offset di file 128·k su ogni pagina dopo la prima (1.025 volte in ciascuno degli otto file, 8.200 in tutto), e sostituisce i quattro byte che c'erano. Prima della release 3.37.0 il decoder leggeva dritto attraverso di esso: il record A pubblicava una carica di più di mille ampere, e il record B pubblicava un timestamp costruito con i byte stessi del marcatore. Dalla 3.37.0 entrambi i decoder individuano il marcatore per offset di file, ne portano la posizione attraverso l'unescape e trattengono esattamente i campi che copre; tutto il resto del record è letto come scritto. I byte da 36 a 51 sono omessi perché il marcatore non li raggiunge.

Dove cade il marcatore

Dove il marcatore cade dentro un record decide quanto costa leggerlo attraverso. Contati su tutti gli 8.200 marcatori degli otto file della batteria, rispetto all'intervallo tra delimitatori in cui cade ciascuno:

Dove cadono gli 8.200 marcatori negli otto file nativi della batteria Gen3
Il marcatore parte daMarcatoriChe cosa ottiene un decoder che lo legge attraverso
Un byte dentro il payload o il testo di un record5.807Una misura sbagliata (una corrente, una tensione, uno stato di carica) o un messaggio tagliato
I microsecondi (byte 7–10 del record)635Una temporizzazione dei sotto-secondi sbagliata, e a volte anche il byte di sequenza o di offset
Il 0xB2 del record successivo, o 1–3 byte prima612Due record fusi in un solo intervallo: dividendo su 0xB2, il primo record, integro, va al parser sbagliato
Il timestamp stesso (byte 3–6)574Un anno 1970, 2097 o 2105, rifiutato dalla finestra dei timestamp, quindi il record si perde
Il byte di sequenza o di offset (byte 11–12)302Una sequenza o un offset sbagliati, e i primi byte del payload
Il byte di tipo (byte 2)139Tipo 0x00 e un timestamp 0xHH00FFF0, un secondo falso; 138 dei 139 sembrano ancora plausibili
Il byte di lunghezza (byte 1)131Lunghezza 0x00, tipo 0xF0 e un timestamp 0xHHHH00FF, fino a 18 ore sballato; 130 dei 131 sembrano ancora plausibili

Ogni marcatore individuato per offset di file e contato rispetto all'intervallo tra delimitatori in cui cade. Le ultime due righe sono le uniche che lasciano un timestamp credibile: 268 righe in tutto, su 38 secondi falsi distinti.

Sovrascrittura, non inserimento: come lo dimostra il file

Questa pagina descriveva una volta un «piè di pagina» di tre byte, F0 FF 00, che un decoder poteva togliere. Entrambe le metà erano sbagliate: il marcatore è di quattro byte e non c'è nulla da togliere, perché non sta tra un record e l'altro.

Le lunghezze dei record lo dimostrano: è una sovrascrittura. Sugli 8.005 intervalli tra delimitatori che attraversano un confine di pagina negli otto file della batteria, la lunghezza dichiarata è uguale all'intervallo in 7.246 casi ed è più corta in 759, e non è mai l'intervallo meno quattro: i byte del marcatore sono contati dentro il record in cui cadono. Sui 10.365 intervalli senza marcatore, la lunghezza dichiarata è uguale all'intervallo ogni volta. La dimensione del file concorda: un'esportazione della batteria è di 131.328 byte e una della scheda principale di 131.200, esattamente una pagina da 128 byte di differenza.

Un controllo di integrità del file a basso costo

Un'esportazione BMS Gen3 nativa porta esattamente 1.025 marcatori, uno a ciascuno degli offset 128, 256, … 131.200. Un conteggio diverso significa che il file è troncato, riempito o non è affatto un'esportazione BMS Gen3. Un decoder che trova marcatori a 128 e 256 sa che deve aspettarsi il resto.

Perché la stessa data falsa compare su moto non correlate

Un timestamp è fatto di quattro byte little-endian, quindi il byte basso viene per primo. Quando il marcatore parte dal byte di tipo di un record, scrive F0 FF 00 sui tre byte bassi del timestamp e lascia solo quello alto, che cambia una volta ogni 2^24 secondi, circa 194 giorni. Ogni record colpito così nello stesso arco di 194 giorni si decodifica quindi nello stesso secondo, qualunque moto l'abbia scritto: 0x6800FFF0 è 2025-04-17 13:19:44 UTC, 0x6900FFF0 è 2025-10-28 17:40:00 UTC e 0x6A00FFF0 è 2026-05-10 22:00:16 UTC. Quando il marcatore parte un byte prima, sulla lunghezza, i due byte bassi del timestamp diventano FF 00, e l'ora falsa cade fino a 18 ore dalla vera, su un valore che condivide ogni record colpito nello stesso blocco di 18 ore.

In questo corpus ciò ha prodotto 268 righe con un timestamp falso ma plausibile, su 38 secondi distinti, e il solo 2025-10-28 17:40:00 compare su 95 record di cinque delle sei moto di cui qui ci sono i file della batteria. Quando moto non correlate condividono una data al secondo, la causa è questo marcatore, non una coincidenza né un evento del firmware.

Su quelle righe sono stati costruiti giorni e giri. Una manciata di timestamp falsi in un giorno in cui la moto era ferma diventa un giorno di attività; valori di corrente veri portati su una data falsa diventano un giro mai avvenuto. Ridecodificati con la versione 3.37.0, gli otto file locali della batteria perdono 13 giorni-file e 18 dei loro 65 giri rilevati dalla batteria, e ogni giorno rimosso era uno sostenuto solo da timestamp falsi.

Che cosa fa ora il decoder

Dalla versione 3.37.0 entrambi i decoder (quello del server e il port nel browser dietro /decode) fanno quattro cose con il marcatore, e mai una quinta:

  1. 1Individua ogni marcatore per offset di file prima di delimitare i record, con lo stesso test a due pagine usato dall'upstream: un file è paginato quando il marcatore apre sia la sua seconda sia la sua terza pagina, così una singola corrispondenza casuale non può attivare il trattamento.
  2. 2Porta la posizione di ogni marcatore attraverso il ripristino degli escape, così un record sa esattamente quali dei suoi byte sono stati sovrascritti anche quando un escape sta davanti a loro.
  3. 3Trattiene esattamente i campi a cui quei byte appartengono: una corrente diventa «non misurata», un timestamp diventa illeggibile e la riga resta senza data, un record di testo che finisce contro un marcatore viene conservato fino al marcatore e segnalato come troncato, e un record di telemetria i cui byte del filtro sulle celle sono stati colpiti viene scartato, perché un filtro che ha letto spazzatura non dimostra nulla. Tutto il resto del record è letto così com'è scritto.
  4. 4Dove il marcatore sta sul 0xB2 del record successivo (612 volte qui), taglia l'intervallo alla lunghezza dichiarata dal primo record, così quel record integro viene decodificato invece di essere passato al parser di testo come un blocco troppo grande. Il secondo record, la cui intestazione è sparita, non viene decodificato.
Che cosa trattiene la decodifica 3.37.0 degli otto file locali della batteria
CampoRighe di telemetria trattenuteSu un totale di
Tensione del pacco misurata (la riga porta invece la stima basata sulle celle)1562.985
Corrente del pacco1302.985
Timestamp (la riga resta senza data)1302.985
Byte di sequenza1242.985
Flag di carico1222.985
Modalità di report1042.985
Byte di attività1032.985
Stato di carica242.985
Uno qualsiasi dei precedenti6922.985

Dei 13.127 eventi di testo della stessa decodifica, 4.316 sono segnalati come tagliati a un marcatore. Prima della correzione gli stessi otto file davano 2.894 righe di telemetria, 699 delle quali portavano almeno un valore letto attraverso un marcatore; le popolazioni differiscono perché la correzione ha anche recuperato record che la vecchia delimitazione perdeva.

Mai ricucire, e mai preferire un numero a un vuoto

Ricucire (togliere i quattro byte del marcatore e unire ciò che sta ai due lati) è la quinta cosa, e non si fa mai. Nulla è stato inserito: i quattro byte originali sono stati sovrascritti, quindi unire il resto produce un record corto di un campo, con ogni campo successivo al posto sbagliato. E un valore inventato è peggio di un vuoto. Un vuoto si vede: un lettore, un grafico o un rilevatore di sessioni possono vedere che nulla è stato misurato e aggirarlo. Un valore letto attraverso il marcatore sembra proprio una misura (una ricarica da 1.048 A, una data che cinque moto condividono), e confluisce in ogni totale, ogni sessione e ogni confronto a valle senza nulla che lo segnali come diverso. Trattenere costa qualche lettura per pagina e mantiene credibile ogni numero rimasto.

Misurato sul corpus di produzione

La modifica è stata valutata sull'intero corpus di produzione prima del rilascio: 1.220 file di log, decodificati da master e dalla versione 3.37.0. I file della scheda principale Gen1, Gen2 e Gen3 si decodificano in modo identico su ogni metrica; cambiano solo i 224 file nativi della batteria Gen3, e cambiano nel modo che l'aritmetica qui sopra dice che devono.

  • +243.755 voci utilizzabili sui 224 file della batteria.
  • 290 giorni-file rimossi, ognuno una data falsata dal marcatore. Ricorrono su moto non correlate: il 2026-05-10, il giorno del secondo 0x6A00FFF0, era comparso su 57 moto diverse, e il 2025-10-28, il giorno di 0x6900FFF0, su 38.
  • 228 «giri» rilevati solo dalla batteria non vengono più prodotti. Per 196 di essi il log della scheda principale della stessa moto copre quel periodo e non registra alcun giro.
Le cifre di produzione vengono dal confronto del manutentore sull'archivio di produzione e non si possono rieseguire da questo corpus pubblico. Le cifre locali di questa sezione invece sì, e concordano con quelle per direzione e per forma: gli stessi secondi falsi, e la stessa scomparsa dei giorni che solo le righe false sostenevano.

payload[38:41]: la tensione del pacco archiviata come contatore

Per anni questo campo è stato documentato come spazio riservato a un contatore. Una vecchia mappa dei campi lo chiamava «contatore interno, uint16 LE, circa da 43.000 a 49.000 a riposo, cala sotto carico», e notava che calava durante la guida senza spiegare perché.

Cala sotto carico perché è la tensione del pacco. Il campo è di tre byte, non due: un uint24 little-endian a payload[38:41], uguale a record[46:49], che contiene la tensione misurata del pacco in millivolt. La lettura troncata a uint16, da 43.000 a 49.000, erano i due byte bassi di un numero come 109.500.

Il decoder accetta il valore misurato solo quando soddisfa l'intervallo di accettazione per 28 in serie, cioè quando 28 × cell_min ≤ valore ≤ 28 × cell_max, usando le tensioni minima e massima delle celle dello stesso record. Misurato sul corpus, 2.189 delle 2.319 righe di telemetria che il decoder in produzione emette (94,4%) lo soddisfano, con un intervallo per file dal 92,1% al 96,5%. Quelle cifre erano 1.473 su 1.557, 94,6% e dal 92,2% al 96,6% prima che la correzione dell'escape e lo smistamento per tipo del 2026-07-29 ampliassero la popolazione; entrambe sono giuste per la propria popolazione, e 2.319 è quella in produzione. Quando il valore cade fuori dall'intervallo (frame di sonno e righe corrotte dal buffer circolare), il decoder ripiega sulla vecchia stima di 28 volte la media delle tensioni di cella bassa e alta.

La potenza del pacco si calcola come valore assoluto di V × I, quindi ogni dato di potenza Gen3, ogni integrale dell'energia di ricarica e tutto ciò che ne deriva è cambiato quando il campo è stato identificato. È anche una buona illustrazione del perché un intervallo di accettazione batte un fattore di scala: l'intervallo è ricavato da altri due campi dello stesso record, quindi convalida la lettura rispetto alla moto e non rispetto a un'ipotesi.

Il segnale era nei dati fin dall'inizio

Un contatore non cala quando acceleri. Ogni campo il cui comportamento contraddice la sua etichetta merita di essere riletto con un'altra ampiezza e un altro segno prima di essere archiviato come riservato.

Il registro della capacità, il byte 67, e quale stato di salute puoi calcolare

Il record esteso 0x4D contiene la capacità a carica piena del pacco in milliampere-ora come uint24 little-endian a record[67:70], replicata a record[74:77]. È un vero registro memorizzato e non rumore: la copia gemella segue la primaria entro circa l'1%.

L'estrazione è volutamente prudente. Un campione viene raccolto da un record di 78 byte solo se valgono tre condizioni: nessun byte sentinella della flash (0xF0 o 0xFF) compare in record[67:70] o record[74:77]; le copie gemelle concordano meglio del 2%; e il valore cade tra 50.000 e 250.000 mAh, che copre ogni pacco Zero dallo ZF7.2 allo ZF17.3. La mediana dei campioni sopravvissuti viene impressa su una sola voce di telemetria per log, perché il registro è un valore stabile del pacco e una riga portatrice basta.

Misurato sul corpus, ciò dà da 50 a 100 campioni puliti per file e mediane per pacco di 124.521, 127.419, 134.793, 143.313 e 144.656 mAh su cinque moto. È una lettura della capacità del pacco, a una divisione da una percentuale di stato di salute, ottenuta senza dover catturare una grande sessione di ricarica. Il registro è l'unico campo di un 0x4D sopravvissuto al bug degli offset descritto prima, perché la raccolta seleziona i record per lunghezza prima che il controllo sulle celle del decoder della telemetria venga mai eseguito.

Una lettura sbagliata che potresti incontrare altrove: il byte 67 non è un conteggio dei cicli

Il byte 67 del record è stato descritto (anche nelle nostre note interne e in un decoder che è stato in produzione per poco) come un uint8 del conteggio dei cicli di ricarica, presentato come metrica chiave di salute con una tabella di valori per moto: 16, 105, 137, 187 e 209 su cinque moto. Quella lettura è sbagliata, e la tabella è stata cancellata invece che corretta, perché i numeri al suo interno non significavano nulla.

Il byte 67 è il byte basso del registro della capacità a carica piena, uint24 little-endian, a record[67:70]. Vaga tra 0 e 255 senza monotonia e senza alcun rapporto con il conteggio delle ricariche, ed è esattamente ciò che fa il byte basso di una lettura di capacità in milliampere-ora.

La vecchia tabella si smentisce con i suoi stessi numeri. Registrava i due byte sopra il presunto conteggio dei cicli come «costante per moto, ad es. 486». Leggi 486 come i due byte alti dello stesso uint24 e il registro sta al byte 67 più 124.416 mAh. I cinque «conteggi dei cicli» erano lo 0,2% inferiore di un'unica lettura della capacità del pacco, di circa 124 Ah, un numero che, senza sorpresa, è nello stesso intervallo delle mediane misurate sopra.

Il decoder che scriveva questo valore in una colonna dei cicli di ricarica è andato in produzione ed è stato annullato lo stesso giorno, appena il registro è stato identificato. Il campo della dataclass esiste ancora per compatibilità e non viene mai popolato, e la mancata assegnazione è documentata nel punto in cui altrimenti avverrebbe. Tutto ciò che legge da questa pipeline un conteggio dei cicli di ricarica Gen3 legge un nullo.

Questa pagina racconta la storia invece di correggere l'offset senza commenti, perché la lettura sbagliata è in giro per il mondo. Se hai un decoder Gen3, un foglio di calcolo o un articolo che riporta i cicli di ricarica dal byte 67, il numero che contiene è il byte basso di un registro della capacità e va scartato, non ricalibrato.

record[67:70]: un registro, non due campiCapacità a carica piena, uint24 LE, mAh · una SR/F 2021, mediana di 88 campioni concordi tra i gemelliqui record[67] = 105i due byte alti = 486 → 486 × 256 = 124.416 mAh0 mAh124.521 mAh99,916% del registrorecord[67] ingrandito ×1.190064128192255cinque valori pubblicati sull'intervallo di un byterecord[67] = 105105 ÷ 124.521 = 0,084% del registro255 ÷ 124.521 = 0,20%, il tettoDisegnato a 1,2 px; la larghezza reale a questa scala è 0,61 px.record[67]record[67:70]record gemello[74:77]moto (seriale oscurato)16144.656 mAhconcorda entro il 2%DSR/X 2024105124.521 mAhconcorda entro il 2%SR/F 2021137134.793 mAhconcorda entro il 2%SR/F 2023187127.419 mAhconcorda entro il 2%SR/F 2020209143.313 mAhconcorda entro il 2%SR/S 2021La tabella pubblicata riportava 16 / 105 / 137 / 171 / 209. Sui file in logs/ lo stesso byte legge16 / 105 / 137 / 187 / 209. Ognuno è il registro modulo 256, e nessuno è stabile per moto.
record[67] era pubblicato come «CHARGE CYCLE COUNT ← KEY HEALTH METRIC» con una tabella di valori di cinque moto. È il byte basso del registro di capacità a carica piena uint24 LE a record[67:70], replicato a record[74:77]. Il decoder che lo scrisse in LogEntry.charge_cycles è stato distribuito in 5fd0793 alle 18:57 del 2026-07-01 ed è stato annullato in 56f78c5 alle 20:18 della stessa sera, 81 minuti dopo. I registri qui sono la mediana dei campioni senza sentinelle e concordi tra i due gemelli di ogni file (n = da 50 a 100 per file, mediana superiore come la prende il decoder, sorted(samples)[n // 2]); i numeri di serie dei VIN sono oscurati, come in docs/. Un uint8 non può mai superare 255, quindi la quota massima che questo byte può contenere di un registro da ~124 Ah è lo 0,20%.

Nel binario Gen3 non esiste un conteggio dei cicli

Non al byte 67 e non in nessun altro punto finora identificato. Se ti serve un conteggio dei cicli per una moto Gen3, va ricostruito dalle sessioni di ricarica rilevate, con tutte le cautele che un buffer circolare comporta.

Quale stato di salute si può calcolare, e quanto costa

In nessuna generazione del formato binario Zero esiste un campo esplicito con la percentuale di stato di salute. Sulla Gen3 esistono tre segnali legati alla salute, e solo il primo è vicino a essere utilizzabile.

Il registro della capacità a carica piena è la lettura diretta, e dividerlo per la capacità di progetto nominale ricavata dal VIN dà un rapporto di stato di salute che non dipende dall'aver catturato una ricarica grande. Oggi viene estratto e memorizzato ma non è ancora consumato da nessun endpoint, quindi nessuna percentuale mostrata ora da qualche parte ne deriva. La tensione a circuito aperto a payload[15:17] è una tensione di cella a riposo compensata per la resistenza interna, che in linea di principio si potrebbe mappare sul SOC tramite una curva di riferimento della cella, ed è disponibile anche in un dump di sola ibernazione; una curva del genere non è implementata. Un terzo segnale elencato qui in precedenza, un contatore di coulomb a extra[2:4] che si diceva seguisse l'autoscarica a circa 3 unità all'ora, non esiste: quei byte sono la metà bassa della tensione del pacco 0x4D, e il calo è cedimento del pacco in millivolt.

Ciò che è in produzione è un metodo per sessioni indipendente dalla generazione: la capacità viene stimata per sessione come energia divisa per la frazione di SOC spostata, divisa per il numero di moduli batteria attivi, e lo stato di salute è la media delle ultime cinque stime rispetto alla capacità nominale per modulo.

  • In nessuna generazione esiste un byte diretto dello stato di salute. La Gen3 ha un registro della capacità, a una divisione di distanza, e per ora nulla lo rilegge.
  • Il metodo per sessioni richiede una grande escursione di SOC. Con la soglia del 15%, una moto che viene solo rabboccata non produce alcuna stima e quindi nessuna cifra.
  • Un buffer circolare Gen3 può affamare del tutto il metodo per sessioni su una moto che sta ferma per lo più, perché le sessioni vengono sovrascritte prima di essere esportate.
  • La via della tensione a circuito aperto richiede una curva di riferimento accurata per la chimica delle celle in questione, che non è pubblicata.
Il metodo di stato di salute per sessioni in produzione
SoH % = mean(last 5 capacity estimates) / nominal_per_module x 100
capacity estimate (per session)
        = energy_kwh / (delta_SOC / 100) / active_module_count
sources : charging sessions (energy, SOC gained)
          ride sessions     (energy consumed, SOC used)
filters : delta_SOC >= 15
          charging: energy must be measured, not SOC-inferred
          estimate within 0.4x .. 1.15x of nominal
          interquartile-range outlier removal once >= 10 estimates exist
nominal : nameplate pack capacity, divided by active module count

Il filtro «misurata, non dedotta» è determinante. Una ricarica ricostruita da un vuoto di SOC porta un valore di energia che era stato a sua volta calcolato come delta-SOC per capacità, quindi dividerlo di nuovo per delta-SOC è circolare e trascinerebbe il risultato verso il 100%.

Finestre di validità dei timestamp

C'è un dettaglio a livello di file che confonde un decoder che non se lo aspetta: quali timestamp credere. Il marcatore di pagina flash, che ne falsifica alcuni nei file della batteria, ha più sopra una sezione tutta sua.

Due diverse finestre di validità dei timestamp

Il timestamp è un uint32 little-endian ai byte da 3 a 6 del record, e due finestre diverse gli vengono applicate in due fasi diverse. Confonderle produce record scartati in silenzio oppure sessioni senza senso.

I delimitatori binari Gen3 usano la finestra rigida dal 2019-01-01 (Unix 1.546.300.800) a oggi più 365 giorni. Questa pagina descriveva prima quella finestra come un segnale di delimitazione: ciò che distingue un vero confine di record da un byte 0xB2 dentro un payload. Misurato, non fa quasi nulla di tutto ciò. Sui 14 file 538XX adottati, i contatori del decoder in produzione respingono 21.106 candidati: 18.002 il cui campo timestamp vale esattamente zero (uno slot di flash cancellato che il firmware non ha mai scritto) e 3.104 che contengono qualcosa fuori dalla finestra. Nessuna delle due classi è disambiguazione dei delimitatori; la fa l'escape. (Su tutti i 135 file con firma gli stessi contatori leggono 154.668 e 164.256 contro 614.539 candidati accettati. È un altro denominatore e una popolazione da scansione dei byte, quindi citalo solo con entrambi indicati.) Una versione precedente di questa pagina dava 23.026 scarti, 22.972 inizi genuini, 17.992 zeri e «solo 54 veri non-confini»; nessuno di questi quattro numeri si riproduce, e la scomposizione in inizi genuini dei 3.104 non è qualcosa che questo corpus chiarisce, quindi qui non è sostenuta.

Il filtro generico dopo il parsing, applicato a ogni generazione dopo la decodifica, accetta gli anni di calendario dal 2015 al 2030. È ciò che separa le voci con timestamp utilizzabili dalla spazzatura da azzeramento dell'orologio in tempo reale prima che parta il rilevamento delle sessioni. I record che non lo superano vengono conservati ma messi in fondo, perché un record con l'orologio rotto può comunque portare una misura valida.

Due note pratiche sui valori stessi. Il byte più significativo del timestamp, il byte 6 del record, è intorno a 0x69 per le date del 2025 e 2026; quel byte è stato ogni tanto scambiato per un marcatore di tipo del record, e non lo è: il byte di tipo è record[2]. E leggi il timestamp dal record dopo il ripristino degli escape, mai dal flusso grezzo. Un escape che cade dentro i byte da 3 a 6 sposta tutto ciò che segue, e un record i cui byte su disco si leggono come giugno 2019 può decodificarsi in novembre 2023 una volta rispettata la coppia FE 01.

Due finestre di timestamp, due compitiNessuna delle due è una scelta stilistica. La più rigorosa è un filtro sugli slot non scritti, NON l'unico controllo di confine del delimitatore201020122014201620182020202220242026202820302032«reset RTC 1970»21052015-01-01 … 2030-12-31genericais_valid_timestamp()2019-01-01 (Unix 1546300800) …oggi + 365 gscorre in avantiDelimitatore Gen3filtro sugli slot non scrittiCosa filtra la finestra rigorosa: gli slot non scritti del buffer circolare, non il rumore nel payload. Sui 14dump 538XX adottati il decoder distribuito respinge qui 21.106 candidati, 18.002 dei quali (85,3%) leggono un timestampesattamente zero, uno slot flash cancellato; gli altri 3.104 leggono un altro valore fuori finestra. È l'escape 0xFE,non questa finestra, a tenere il delimitatore fuori dai payload, ed è il byte 1 a delimitare un record.Leggi l'uint32 dal record DOPO L'UNESCAPE: 291 record sui 9 file MBB Gen3 nativi cambiano data una voltafatto l'unescape, fino a undici anni: il record della figura 1 legge 2010 sul filo e 2021 decodificato.Il codice anno K = 2019 è anche il primo anno VIN che il veto pre-Gen3 smette di respingere.
Nel codice esistono due finestre e fanno lavori diversi. is_valid_timestamp() (MIN_VALID_YEAR = 2015, MAX_VALID_YEAR = 2030) è il filtro generico dopo il parsing che ogni generazione esegue, e separa le voci utilizzabili dai rifiuti di un reset dell'RTC prima del rilevamento delle sessioni. I delimitatori binari Gen3 usano una finestra più rigorosa, da 1546300800 (2019-01-01) a now + 365 days. Questa didascalia una volta lo giustificava dicendo che un timestamp plausibile è l'unica cosa che distingue un vero confine di record da un byte 0xB2 dentro un payload. Non è così: l'escape 0xFE tiene il delimitatore fuori dai payload e la lunghezza dichiarata al byte 1 è ciò che delimita un record; la finestra è un filtro per slot non scritti, e buono. Ciò che respinge, dalla diagnostica del decoder distribuito sui 14 dump 538XX adottati in logs/: 21.106 candidati, di cui 18.002 leggono un timestamp esattamente zero (uno slot flash cancellato) e 3.104 leggono altro fuori finestra. (La terna 23.026 / 22.972 / 54 pubblicata qui fino al 2026-07-30 non si riproduce su nessuna popolazione; non portarla avanti.) Una cosa non è cambiata: leggi l'uint32 dal record dopo l'unescape, perché un escape che cade nei byte 3–6 lo sposta. Sui nove file MBB Gen3 nativi, delimitati per catena di lunghezze, 291 record decodificano a una data diversa dopo l'unescape, 37 dei quali nel dump SR/F del 2023, i cui byte sul filo leggono 1992 e i cui byte decodificati leggono 2023.
Finestre dei timestamp
FinestraIntervalloApplicata daScopo
Delimitazione Gen32019-01-01 .. now + 365 daysEntrambi i delimitatori binari Gen3, per record, DOPO il ripristino degli escapeScartare gli slot del buffer circolare non scritti o cancellati
Validità genericaanni di calendario 2015 .. 2030Dopo il parsing, ogni generazioneEscludere dal rilevamento delle sessioni la spazzatura da azzeramento dell'RTC

Stato della decodifica: noto, parziale e sconosciuto

La tabella qui sotto sostituisce le righe Gen3 della vecchia tabella di stato pubblicata nella pagina di confronto tra le generazioni. Sostituisce anche una sua versione precedente: quattro righe qui contraddicono ciò che questa pagina diceva prima, e sono segnalate così puoi capire quale affermazione hai in mano. Si usano volutamente tre stati: «Decodificato» significa che il decoder in produzione lo scrive su una voce, «Presente ma NON letto» significa che i byte sono identificati e nessun percorso del codice li consuma, e «Non esiste» significa che il canale è assente dal formato, non semplicemente non decodificato.

Stato della decodifica dei campi Gen3
SchedaCampoPosizioneStato
BMSTensione di cella min / maxpayload[13:15], payload[17:19]Decodificato: uint16 LE mV, validato 2.500–4.500; aggiungi 8 sul 0x4D, 4 sul 0x4C
BMSTensione a circuito aperto della cellapayload[15:17]Decodificato: memorizzato, non ancora usato per il SOC
BMSStato di caricapayload[19]Decodificato: 0 significa che dorme, non che è scarica
BMSCorrente del paccopayload[20:24]Decodificato: int32 LE mA. Letto come int16 fino al 2026-07-31
BMSTensione del paccopayload[38:41]Decodificato: uint24 LE mV, misurata, 94,4% nell'intervallo
BMSTemperatura—Non esiste nel record di telemetria. payload[43] va da 0 a 27 e corre contro le temperature delle celle MBB (r = −0,41); ritirato
BMSIndicatore di ricaricapayload[22:24]Derivato: la metà alta della corrente int32; il suo segno, non un flag
BothContatore di sequenzarecord[11]Decodificato: uint8, +1 per ogni record di qualsiasi tipo; memorizzato come bms_sequence sulle righe BMS
BothImpostazione del fuso UTCrecord[12]Decodificato: int8 ore; riassunto per file, mai applicato a un timestamp
BMSValori sotto un marcatore di paginaogni 128·kTrattenuto: il campo è nullo e indicato in withheld_fields
BMSFlag di carico / bus inseritopayload[27], payload[28]Decodificato: segnali complementari
BMSModalità di reportpayload[37]Decodificato: 7 valori noti nei vari tipi di record; il valore 6 è senza spiegazione
BMSByte di attività (in precedenza «codice di stato»)payload[24]NON decodificato: memorizzato così com'è; 37 valori, nessun enum resiste ai test
BMSIndicatore di sonnopayload[9]Decodificato: 0x20 dorme, 0x00 sveglio (misurato)
BMSCapacità a carica pienarecord[67:70] + gemello a [74:77]Decodificato: uint24 LE mAh, memorizzato, non ancora consumato
BMSTensione del pacco (copia 0x4D)record[54:57]Decodificato: uint24 LE mV; ritirato come «contatore di coulomb»
BMSContatore cumulativo per motoextra[10:12]Sconosciuto: varia da 38.967 a 56.414, nessuna correlazione trovata
BMSDettaglio per blocco di cellerecord 0x4C, campi spostati di +4Decodificato: stessa mappa del 0x4B a +4; mappatura per blocco non stabilita
BMSConteggio dei cicli di ricarica—Non esiste. Il byte 67 è un byte della capacità
MBBStatorecord[42:51], [46:55], [50:59] a seconda del tipoDecodificato: ancorato per tipo di record, dieci token tra cui REV e PARK
MBBStato di caricarecord[33]Decodificato: uint8, 0 in PWSU significa non inizializzato
MBBFlag della modalità del controllerrecord[17]Decodificato: 0x00 attivo, 0x6A standby, 0x60 transizione
MBBTemperaturerecord[51:71], cinque uint32Decodificato: ambiente, motore, inverter, cella alta, cella bassa (rietichettate il 2026-09-07)
MBBCorrente della batteriarecord[38:42]Decodificato: int32 LE mA, solo con il bus attivo
MBBTensione / corrente del bus DC, giri motorerecord[21:33]Decodificato: le letture del controller, solo con il bus attivo
MBBLinea accessori a 12 V (identificazione non provata)record[71:75]Emesso grezzo: uint32 LE microvolt su un reticolo di 5.128 µV; il reticolo dell'ADC è provato, «quale linea» no
MBBVelocità su strada, autonomia stimatacoda 0x52 / 0x53Decodificato: mm/h e centesimi di km; non in un 0x51
MBBContachilometricoda 0x52 / 0x53, layout più recenteDecodificato: decimi di km, controllato in serie per file; il layout più vecchio e il 0x51 non ne portano. record[71:75] è una linea a 12 V (ritirato)
MBBRecord del motore0x54, 29 byteDecodificato: coppia all'albero, corrente del motore, tensione del bus DC
MBBTensione del paccorecord[34:38]Decodificato: solo con il bus attivo
MBBTabella del caricabatterie / obiettivi di ricarica0x48 / 0x49Decodificato: ogni record del caricabatterie, V/A/Hz di rete, uscita DC, id CAN, seriale; limite massimo, % obiettivo, tensione di stoccaggio
MBBCoda piena0x4F, 31 byteDecodificato: nome della coda e due contatori, significato non confermato
MBBIntestazione0xFBDecodificato: VIN (cifra di controllo validata), modello, anno modello, revisione della scheda e del firmware, build del firmware
MBBBanner della build del firmware0x32, layout più vecchio, dump della piattaforma Gen2Decodificato: data di build, numero di build, banco flash; ogni build annunciata da un file, nell'ordine del file
BothEventi di testo0xFD, dal byte 13 del recordDecodificato: ASCII terminato da NUL; il testo tagliato da un marcatore di pagina è conservato fino al marcatore e segnalato
MBBIstantanea dello stato0x4B / 0x4C / 0x4D, lato MBBSolo etichetta: nessuna in questo corpus; non usata per i giri
538XXTensione, corrente, giri, 5 temperature, contachilometrirecord 0x2c, 40 byteDecodificato: mappa run_status dell'upstream; la calibrazione adattata è ritirata

Gli offset del payload sono relativi al byte 8 del record sul BMS e al byte 0 del record sull'MBB, secondo la convenzione di ciascun decoder. Aggiungi 8 a un offset del payload BMS per ottenere la posizione assoluta nel record.

Come questa decodifica è stata confrontata con il parser della comunità

La decodifica Gen3 di questa pagina è stata confrontata, campo per campo, con il parser della comunità zero-log-parser al commit 90c8cb2 del suo ramo principale, del 29 settembre 2026. L'upstream è una seconda opinione, non la verità assoluta, e lo scopo dell'esercizio era capire dove i due concordano, dove no e perché. La versione breve è la prima sottosezione; seguono il metodo, i numeri e i riconoscimenti.

La versione breve

Questo sito decodifica i log Gen1 e Gen2 con il parser della comunità, zero-log-parser, fissato al commit 90c8cb2 (29 settembre 2026; prima era 87c6e757, febbraio 2026); i record Gen3 nativi di questa pagina sono decodificati dal codice del sito. Il 3 ottobre 2026 i due decoder Gen3 sono stati confrontati record per record, allineati per offset di file, con il ramo principale del parser al commit 90c8cb2 (29 settembre 2026, la versione che esegue il parser ospitato su home.hasslers.net/zerologparser). Ovunque entrambi decodifichino un record, concordano: tutte le 2.866 letture di tensione delle celle, lo stato di carica, i campi di stato, le temperature, la tabella del caricabatterie e i rapporti di coda piena. Parecchi di quei record erano stati decodificati prima dall'upstream (l'intestazione della scheda principale Gen3 e la build del firmware 0x32 il 15 settembre, la tabella del caricabatterie 0x48 e la coda piena 0x4F il 20 settembre, un percorso consapevole delle pagine per le pagine flash del pacco il 22 settembre), e le versioni di questo sito, rilasciate il 3 ottobre, sono state verificate su di essi. Restano quattro differenze, una a favore del parser: legge entrambi i numeri di serie dall'intestazione di un pacco Gen3, cosa che questa decodifica non fa. Da quando il pin si è spostato, il sito registra i due seriali che il parser legge, solo a titolo informativo; per ora nulla identifica un pacco da essi. In senso opposto, il parser non decodifica ancora i record di testo Gen3 (tipo 0xFD), la più grande classe di record su Gen3: il suo decoder dei messaggi legge come stringa il prefisso di sei byte del record. Legge i primi quattro byte del payload del record 0x54 come un contachilometri; sono invece la parte dei sotto-secondi del timestamp del record. E il suo LOG_STRUCTURE.md colloca ancora un contachilometri nei byte 0–3 del record 0x51, dove questo corpus non ne trova; secondo la lettura di questo sito il contachilometri sta nella coda dei record 0x52 e 0x53 del layout più recente.

Metodo: allineare per offset di file, mai per timestamp

Ogni record viene delimitato una volta sola, dai delimitatori di questo sito (la catena a lunghezza dichiarata sulla scheda principale, l'intervallo tra delimitatori con il taglio del marcatore di pagina sulla scheda della batteria), e gli stessi byte con gli escape ripristinati vengono passati a entrambi i decoder: a questo il suo frame, all'upstream il suo payload, che parte dal byte 7 del record. Un record è identificato da dove sta nel file, e nient'altro.

I timestamp non possono fare questo lavoro. Due record scritti nello stesso secondo sono il caso normale, non l'eccezione: nei dieci file nativi della scheda principale, 19.705 dei 21.724 record delimitati (90,7%) condividono il secondo con almeno un altro record, e 16.919 (77,9%) con un altro record dello stesso tipo; negli otto file della batteria sono 15.735 su 18.370 (85,7%) e 13.184 (71,8%). Un join sul tempo accoppia i record sbagliati e segnala disaccordi che non esistono. Un confronto precedente segnalava che i due decoder non concordavano sull'id CAN di un caricabatterie, 16 contro 17, mentre aveva accoppiato due caricabatterie diversi che avevano risposto nello stesso secondo.

Il corpus è ogni file Gen3 nativo in questo repository: 18 file, dieci dump della scheda principale e otto della gestione batteria. Il codice attuale dell'upstream viene caricato solo per il confronto e mai nello stesso processo di una decodifica completa, perché caricarlo accanto alla versione che questo sito fissa cambia ciò che la libreria fissata restituisce. Lo script che lo esegue, gen3_upstream_crosscheck.py tra gli script backend di questo repository, non scrive nulla ed esce con 0: è un rapporto, non un controllo bloccante, perché un disaccordo può essere un errore dell'upstream tanto quanto nostro.

Risultati, campo per campo

Misurato il 3 ottobre 2026 rispetto al ramo principale dell'upstream al commit 90c8cb2.

Questo decoder contro il ramo principale dell'upstream, record allineati per offset di file, 18 file Gen3 nativi
CampoRecordConcordanoDifferisconoTrattenuti qui
Tensione di cella più bassa e più alta del BMS2.8662.86600
Stato di carica del BMS2.8662.842024, sotto un marcatore di pagina
Corrente del pacco BMS2.8662.70729130, sotto un marcatore di pagina
Tensione misurata del pacco BMS2.8662.69515156, sotto un marcatore di pagina
Stato del veicolo MBB (0x51, 0x52, 0x53)1.7271.7270—
Temperature MBB 0x51: motore, inverter, cella alta, cella bassa1.536 ciascuna1.536 ciascuna0—
Caricabatterie MBB 0x48: nome, id CAN, versione, seriale, frequenza119 ciascuno119 ciascuno0—
Coda piena MBB 0x4F: nome ed entrambi i valori18 ciascuna18 ciascuna0—
Record di testo (0xFD), entrambe le schede33.460L'upstream non restituisce nessuno dei messaggi——

Le 2.866 righe della batteria sono i record di telemetria che entrambi i decoder emettono. Oltre a quelli, 119 record di telemetria sono decodificati qui e non dall'upstream, 625 da nessuno dei due, 235 l'upstream li decodifica e questo decoder li scarta perché un marcatore di pagina ha sovrascritto parte del record, e 1 questo decoder lo scarta per un altro motivo.

Dove i due non concordano, e perché

Ogni differenza nella tabella ha una causa che si può nominare:

  • Tutte le 29 differenze di corrente sono parole che questo decoder rifiuta come flash cancellata. Ventisette volte i quattro byte valgono FF FF FF FF, che l'upstream pubblica come −1 mA; due volte sono altre combinazioni di byte sentinella della flash, che l'upstream legge come 240 mA e −16 mA.
  • Tutte le 15 differenze di tensione del pacco sono righe la cui parola misurata cade fuori dall'intervallo delle 28 celle o sotto un marcatore. Questo decoder allora pubblica 28 volte la tensione media di cella del record stesso, e l'upstream la parola così com'è letta: 13 differiscono da 39 a 647 mV, e nelle altre due la parola vale 0 e 164 mV.
  • Sul testo i due si separano del tutto. I 18 file contengono 33.460 record di testo, 18.570 sulle schede principali e 14.890 sui pacchi, e questo decoder ne legge 31.686 come testo: 18.023 messaggi della scheda principale e 13.663 eventi della batteria. Il ramo principale dell'upstream non restituisce nessuno di quei messaggi. Il suo decoder dei messaggi legge come stringa il prefisso FST di sei byte del record, quindi un record che dice «State change from CHRG to …» torna indietro come due caratteri di controllo. Il testo è la più grande classe di record di un file Gen3, ed è dove la macchina a stati, i guasti e gli eventi dei contattori sono scritti a parole.

La protezione contro le regressioni: 43 record veri, due decoder, un file

Un confronto con un upstream in movimento è una misura, non un test. Ciò che impedisce a questa decodifica di derivare è una fixture versionata di 43 record veri anonimizzati (22 della scheda principale, 18 della gestione batteria e 3 della batteria con layout più vecchio), insieme ai valori che questo decoder produce da ciascuno. Non contiene alcun record di intestazione né testo identificativo, e i seriali dei caricabatterie sono azzerati. Il decoder Python è testato su di essa nella suite del backend e il decoder del browser dietro /decode sullo stesso file nella suite del frontend, quindi le due implementazioni non possono divergere su un record senza che un test fallisca. Quando il port nel browser è stato riallineato per la versione 3.37.0, differiva dal decoder del server su 0 valori nei 18 file nativi.

Che cosa ha trovato prima l'upstream

Buona parte di ciò che questa pagina ha aggiunto nell'ottobre 2026 è stata trovata prima dal parser della comunità, e il decoder di qui è stato confrontato con esso invece di essere scritto in isolamento. Nel ramo principale dell'upstream:

  • gli offset dell'intestazione della scheda principale Gen3 per VIN, modello, revisione di scheda e firmware e build del firmware, il 15 settembre 2026 (commit 8591af3), sulla base della pull request del 2022 di AtomicDog;
  • il banner della build del firmware 0x32, anch'esso il 15 settembre (825c9d2);
  • la tabella del caricabatterie 0x48 e il rapporto di coda piena 0x4F con i suoi undici nomi di coda, il 20 settembre (f1e34cb, 1da1827);
  • le istantanee di stato 0x4B, 0x4C e 0x4D della scheda principale, il 20 settembre (82475b7);
  • i microsecondi dei sotto-secondi e il contatore di sequenza per voce nel prefisso del record;
  • e il marcatore di pagina flash come sovrascrittura e non come inserimento, con i due casi in cui distrugge l'intestazione o il tipo di un record e un percorso consapevole delle pagine per il file della batteria, il 22 settembre (2c98751), misurato dall'upstream su 291 file.
Ciò che questo decoder aggiunge è il resto della gestione del marcatore di pagina (trattenere i campi che un marcatore copre dentro un record invece di leggerli, e tagliare un intervallo a un delimitatore distrutto), insieme al testo letto dal byte 13, il test di layout per file, l'anno modello, la lettura del fuso orario dal byte 12 e i campi di misura DC e AC della tabella del caricabatterie. Ora ogni progetto ha una seconda opinione sull'altro, e lo script di confronto c'è perché ciascuno possa essere verificato di nuovo.

Decoder nel browser

Questo decoder applica la specifica qui sopra a un file che scegli tu. Delimita i record 0xB2, classifica ogni byte del tipo, decodifica le mappe dei campi documentate in questa pagina e riporta ciò che non ha saputo leggere, così puoi controllare ogni offset di qui sul tuo log.

È la stessa decodifica della pipeline lato server: validata campo per campo contro il parser Python su un percorso forzato, che esegue ogni decoder applicabile su ognuno dei 352 file di log reali: 1.190.446 voci, zero divergenze, hash canonici identici al byte su tutti e 352. Sul percorso di produzione, dove il classificatore sceglie un decoder per file, lo stesso corpus dà 67 file decodificati e 317.124 voci, anche qui con zero divergenze. Sono supportati Gen3 MBB, Gen3 BMS e la variante di firmware 538XX; i file Gen1/Gen2 sono riconosciuti e identificati ma qui non decodificati, ed è per questo che il totale di produzione è il più piccolo dei due.

Quell'accordo è una garanzia di portabilità: dimostra che le due implementazioni concordano, e non può dimostrare che l'una o l'altra concordi con il firmware. Dove il decoder Python sbaglia, questo sbaglia esattamente allo stesso modo, di proposito, ed è questo a dare senso al controllo incrociato. Gli scostamenti noti dal formato sono quelli esposti sopra: diversi campi identificati che nessun decoder legge, e le ritrattazioni segnate sul posto.

Decodificato interamente nel tuo browser. Questo file non viene mai caricato.

Il decoder è JavaScript che gira in questa scheda. Il tuo .bin viene letto con l'API standard dei file, decodificato in memoria e mostrato qui sotto. La decodifica non fa alcuna richiesta di rete: non viene caricato nulla, non viene trasmesso nessun VIN, e nessun evento di analisi porta qualcosa del tuo log. Chiudi la scheda e non resta niente.

Un file è una finestra di tre giorni. Gen3 scrive in un buffer circolare che si sovrascrive partendo dal più vecchio: una moto parcheggiata si sveglia circa una volta all'ora e scrive una mediana di 31 voci, quindi il buffer si riempie in circa 3,1–3,3 giorni di sosta, e ancora più in fretta durante la guida o la ricarica, quando le schede scrivono diverse volte più spesso. Tutto ciò che è più vecchio è già sparito dal file che hai appena decodificato: l'ha sovrascritto la moto, e questo strumento non l'ha perso. Perché il log della tua Gen3 non mostra giri spiega come riconoscerlo e come esportare prima che succeda. Conservare la storia vuol dire conservare i file: un account memorizza ogni export e cuce quelli sovrapposti in un'unica linea del tempo continua per VIN. Questo decoder resta gratuito e completo in ogni caso.
La pipeline di analisi completa (rilevamento delle sessioni, salute della batteria e risultati sui guasti) è disponibile caricando un log, oppure puoi provarla su dati di esempio nella demo in sola lettura.

Domande frequenti

Il log MBB Gen3 contiene tensione del pacco, corrente o velocità?

Tensione e corrente: sì, e questa pagina prima diceva il contrario. La tensione del pacco è un uint32 little-endian in millivolt a record[34:38] e la corrente della batteria è un int32 con segno in milliampere a record[38:42], ed entrambe sono valorizzate esattamente quando il sistema ad alta tensione è attivo: diverse da zero su 144 record RUN su 144 e zero su 417 record di ibernazione su 417. Una sessione di ricarica letta da questi byte mostra una fase di assorbimento a tensione costante da manuale, e integrandoli sul SOC si arriva alla capacità utilizzabile del pacco. Il decoder in produzione legge entrambe dal 2026-09-07, dai record in cui il bus è attivo; negli stati che compongono il 75% di un log reale sono vuote, quindi il BMS resta la fonte migliore. Velocità: sì, ma non nel record comune. I record più lunghi 0x52 e 0x53 portano nella coda la velocità su strada, l'autonomia stimata e (sul firmware più recente) il contachilometri; il record da 75 byte 0x51 non ne porta nessuno, e record[71:75], pubblicato qui come contachilometri, è una linea accessori a 12 V in microvolt. Le misure di tensione e corrente vengono da cinque moto della piattaforma SR/F; l'unica DSR/X di questo corpus le popola appena, quindi considerale non confermate su quell'hardware.

Com'è fatto un record Gen3 0xB2?

Il byte 0 è il delimitatore 0xB2, il byte 1 è la lunghezza totale del record su disco, delimitatore ed eventuali byte di escape inclusi, il byte 2 è il tipo di record, i byte da 3 a 6 sono un timestamp Unix come uint32 little-endian in UTC, i byte da 7 a 10 sono la parte dei sotto-secondi in microsecondi, il byte 11 è un contatore di sequenza che sale di uno a ogni record, e il byte 12 è l'impostazione del fuso UTC della moto in ore come byte con segno (due campi che questa pagina descriveva come un unico uint16 «contatore di voci»). Il payload parte dal byte 13. I tipi MBB sono 0xFB intestazione, 0xFD testo, 0x51, 0x52 e 0x53 telemetria di stato, 0x54 motore, 0x48 tabella del caricabatterie, 0x49 obiettivi di ricarica e 0x4F overflow della coda. I tipi BMS sono 0xFB intestazione, 0xFD testo, 0x4B telemetria, 0x4D telemetria estesa e 0x4C dettaglio celle. Delimita usando il byte 1, poi ripristina gli escape nel corpo delimitato. Su un file BMS, ricorda che quattro byte a ogni confine di pagina da 128 byte sono un marcatore, non dati.

Devo gestire l'escape 0xFE?

Sì, e una versione precedente di questa pagina non ne parlava affatto. Chi scrive il file fa l'escape del delimitatore: FE 4D su disco si decodifica in 0xB2 e FE 01 in 0xFE, quindi un record ben formato non contiene alcun 0xB2 grezzo dopo il byte 0. Ce ne sono zero occorrenze nei 1.010.093 byte su disco di record[2:] nei 19.342 record concatenati per lunghezza da tutti e nove i file MBB Gen3 nativi, di cui 504 portano un escape e 518 byte di escape compaiono in tutto (264 FE 4D, 254 FE 01, nessun'altra coppia). Sui soli otto dump completi dell'app lo stesso censimento dà 19.089 record, 994.299 byte, 468 con escape e 477 byte di escape. Delimita prima con la lunghezza dichiarata nel byte 1, poi ripristina gli escape nel corpo delimitato; il byte 1 è l'unico campo fuori dalla regione con escape, quindi è l'unico di cui ti puoi fidare prima del ripristino. Farlo nell'ordine opposto reintroduce 0xB2 in mezzo al payload e riduce il file a pezzi, ed è così che l'escape è stato scambiato per il delimitatore che ricorre nei payload. Ignorarlo costa caro: sul firmware 538XX, filtrare la telemetria sulla lunghezza su disco invece che su quella dopo il ripristino scarta 1.796 record, e la perdita è correlata ai valori e non casuale.

C'è un contachilometri in un log MBB Gen3 nativo?

Non nel record comune, e non su ogni firmware. Sul layout di firmware più recente (quello il cui 0x51 è di 75 byte), i record più lunghi 0x52 e 0x53 portano il contachilometri nella coda, in decimi di chilometro; è decodificato dal 2026-09-07, resta fermo durante una ricarica e sale solo in RUN, e viene controllato come serie per file prima di essere conservato. Il layout più vecchio, il cui 0x51 è di 71 byte, non ne porta: la parola che lì sale in modo regolare fino a un chilometraggio plausibile lo fa solo mentre la moto è in carica, ed è l'autonomia stimata. Quello che questa pagina pubblicava come contachilometri era un'altra cosa ancora. record[71:75] era pubblicato qui come contachilometri totale in metri, le cui letture «oscillano di decine di chilometri». È una lettura ADC a 12 bit in microvolt e, per peso delle prove, una lettura della linea accessori a 12 V; il reticolo è provato e l'etichetta della linea no. Ognuno degli 1.121 record di telemetria completi di questo corpus soddisfa v = 5128k + 4864 (un bit meno significativo da 5,128 mV su circa 21 V di fondo scala) e, letto in volt, il campo va da 0,143 V a 13,440 V, che è ciò che gli eventi di testo del firmware riportano per la batteria accessoria proprio in quelle unità. Solo il 51,5% dei campioni consecutivi non è decrescente, e nessuna finestra uint32 del record è monotona tranne il timestamp. Cinque moto non correlate di tre famiglie di modelli e cinque anni modello hanno riportato tutte dei «contachilometri» dentro una finestra di 272 km. Il campo è stato ritirato dal decoder: una moto il cui log non ha un record 0x52 o 0x53 del layout recente ora non riporta né contachilometri né distanza per giro, invece di uno inventato. Un vero contachilometri esiste anche sulla Gen2 e sulla variante di firmware 538XX, a un offset diverso in un record diverso.

Posso leggere un record BMS 0x4D con la mappa dei campi del 0x4B?

No, e non fallirà in modo evidente. Un 0x4D condivide solo l'intestazione di 13 byte e poi inserisce otto byte, quindi ogni campo di misura sta otto byte più avanti; un 0x4C ne inserisce quattro. Provando spostamenti da 0 a 12 e verificando se le parole di tensione delle celle cadono in una banda plausibile da 2.500 a 4.500 mV, un 0x4D totalizza zero agli offset del 0x4B e 619 su 666 a +8, e un 0x4C totalizza zero e 75 su 78 a +4. Lo zero è il numero che conta: un decoder con un controllo di plausibilità sulle celle legge il blocco di riempimento a zero, fallisce il controllo e scarta in silenzio ogni record esteso. In questo progetto erano 744 record alle lunghezze canoniche. Correggere gli offset ne ha recuperati 694, il 42,7% di telemetria BMS Gen3 in più, con l'84% delle righe 0x4D che cadono dentro intervalli di più di un'ora nella serie standard. Smista sul byte di tipo a record[2] e usa la lunghezza dopo il ripristino degli escape solo come controllo incrociato; la sola lunghezza non distingue un record da 78 byte di tipo 0x4D da qualsiasi altro record da 78 byte.

Che cosa c'è nel payload[38:41] del BMS?

La tensione misurata del pacco, come uint24 little-endian in millivolt. Per anni è stata documentata come un contatore interno di circa 43.000–49.000 che misteriosamente calava sotto carico. Era una lettura uint16 dei due byte bassi del vero valore a tre byte. Il decoder lo accetta quando cade tra 28 volte la tensione minima di cella e 28 volte la tensione massima di cella dello stesso record, cosa soddisfatta su 2.189 delle 2.319 righe di telemetria che il decoder in produzione emette (94,4%, e dal 92,1% al 96,5% per file), e altrimenti ripiega su una stima basata sulla media delle celle per 28 in serie. Il dato 1.473 su 1.557, molto copiato, è lo stesso test sulla popolazione che questo decoder emetteva prima della correzione dell'escape del 2026-07-29.

Che cosa significa il payload[24] del BMS? È il codice di stato del BMS?

No. È stato pubblicato, anche su questo sito, un enum che leggeva 0x0B inattivo, 0x0C attivo, 0x09 sblocco e 0x0A precarica, ed è ritirato. Sulle 2.319 righe di telemetria che il decoder in produzione emette, il byte assume 37 valori distinti (ogni valore da 0x00 a 0x23 tranne 0x02, più le sentinelle della flash 0xF0 e 0xFF), e quei quattro codici coprono solo il 58,6% delle righe. Non è un contatore (l'82,0% dei delta consecutivi dentro una finestra di 120 secondi è esattamente zero), non è una temperatura (r = -0,05 rispetto al byte di temperatura nello stesso record), e non partiziona le transizioni ZERO_BMS_STATE_ negli eventi di testo: trascinale avanti e 0x09 sta davvero sotto UNLOCK nel 62% delle righe, ma 0x0B, il valore chiamato «inattivo», sta sotto HIBERNATE, IDLE e UNLOCK indifferentemente. Correla vagamente con l'essere il pacco sotto carico, ma due valori mai nominati dall'enum, 0x10 con il 62,2% sotto carico e 0x0F con il 40,7%, stanno dentro quell'ordinamento. Il decoder memorizza il byte così com'è e non agisce su di esso da nessuna parte. Trattalo come opaco.

Il byte 67 di un record BMS Gen3 è un conteggio dei cicli di ricarica?

No. È il byte basso del registro della capacità a carica piena, uint24 little-endian, a record[67:70], replicato a record[74:77], che contiene la capacità del pacco in milliampere-ora, di solito intorno a 124.000–145.000 mAh. Letto come uint8 a sé vaga tra 0 e 255 senza monotonia. Un decoder che lo scriveva in un campo dei cicli di ricarica è andato in produzione ed è stato annullato lo stesso giorno. Nel formato binario Gen3 non c'è alcun campo noto per i cicli di ricarica.

Che cos'è la variante di firmware 538XX?

Una moto dell'era Gen2 il cui MBB è stato aggiornato via firmware a un buffer circolare in flash di stile Gen3, fatto di record 0xB2 con prefisso di lunghezza. Il file ha un'intestazione Gen2 («MBB» seguito da un nullo all'offset 0, e A1 A1 A1 A1 all'offset 38) ma un corpo di stile Gen3. Questa pagina aggiungeva «nessuno dei due percorsi riusciva a leggerlo»; è falso. Il suo record 0x2c è l'ordinario record Riding Status dello zero-log-parser upstream, smistato dal 2015, e la versione upstream fissata da questo sito legge questi file. Quello che falliva era l'instradamento dentro questo progetto: il loader Gen3 nativo richiede solo l'«MBB» ASCII e dieci byte 0xB2, entrambi veri qui, quindi una decodifica Gen2 funzionante veniva scartata. I record sono esattamente di 40 byte e portano la tensione del pacco come intero uint32 esatto in millivolt, corrente della batteria e del motore, cinque temperature, SOC, giri motore e un contachilometri, ma nessuna velocità su strada. Il rilevamento esegue la decodifica e la adotta solo se ne escono almeno 10 voci di cambio stato e 50 di telemetria, perché i veri file Gen2 condividono la firma dell'intestazione e scrivono lo stesso record.

Quanti record contiene un log Gen3, e che cosa li riempie?

Tra 2.238 e 2.535 record delimitati per file MBB da 131.200 byte, e da 2.038 a 2.327 per file BMS da 131.328 byte, misurati rispettivamente su otto e sette file e delimitati concatenando la lunghezza dichiarata. Gli eventi di testo dominano entrambi: l'86,7% dei record MBB (16.553 su 19.089) e l'82,9% dei record BMS (13.178 su 15.890). Conta gli stessi file BMS dividendo invece sull'intervallo tra delimitatori e ottieni 15.998 record con l'82,4% di testo, che è la coppia pubblicata nella pagina sul buffer circolare; dichiarare la convenzione è ciò che impedisce ai due di leggersi come una contraddizione. Sull'MBB il riempitivo è il ciclo di risveglio dell'ibernazione, che scrive una mediana di 31 record (27 di testo, 2 di telemetria, 2 secondari) in una raffica di 91 secondi, ripetuta con un periodo di 60 minuti annunciato nel log come «Saving Stats, Hibernating for 3600 sec».

Un log Gen3 può dirmi lo stato di salute della batteria?

Indirettamente. In nessuna generazione del formato esiste un campo esplicito di stato di salute. La Gen3 memorizza un registro della capacità a carica piena nei suoi record 0x4D, che è a una divisione per la capacità di progetto nominale da una percentuale, ma per ora viene estratto e memorizzato, non consumato. Ciò che c'è oggi in produzione è una stima per sessioni: energia divisa per la frazione di SOC spostata, per modulo, mediata sulle ultime cinque sessioni valide, che richiede un'escursione di SOC di almeno il 15% per produrre una qualsiasi stima.

Che cosa significa la sequenza di byte 00 F0 FF 00 in un file BMS Gen3?

È il marcatore di pagina flash, che non è né una corruzione casuale né un separatore. In ogni file nativo della batteria Gen3 misurato sta all'offset di file 128·k per k da 1 a 1.025, 1.025 volte per file, e in nessun file della scheda principale. È scritto sopra quattro byte di qualunque record occupasse quella posizione, quindi quei quattro byte sono andati: un decoder deve individuare il marcatore per offset di file e trattenere i campi che copre, e non deve mai ricucirlo, perché nulla è stato inserito. Una versione precedente di questa risposta diceva che il marcatore era di tre byte, F0 FF 00, che partiva dall'offset 129 e che si poteva togliere prima della delimitazione; tutte e tre le affermazioni erano sbagliate. Contare i marcatori resta un controllo di integrità a basso costo: un'esportazione BMS Gen3 nativa ne porta esattamente 1.025.

Perché alcuni log della batteria Gen3 mostrano attività in una data che altre moto condividono al secondo?

Perché il marcatore di pagina flash l'ha falsificata. Quando il marcatore cade sul byte di tipo di un record, sovrascrive i tre byte bassi del timestamp con F0 FF 00 e lascia solo il byte alto, quindi ogni record colpito così entro gli stessi 194 giorni si decodifica in un unico secondo, qualunque moto l'abbia scritto: 0x6900FFF0 è 2025-10-28 17:40:00 UTC e 0x6A00FFF0 è 2026-05-10 22:00:16 UTC. In questo corpus 2025-10-28 17:40:00 compare su 95 record di cinque moto diverse; sul corpus di produzione un giorno falso era comparso su 57 moto e un altro su 38. Dalla versione 3.37.0 quei timestamp sono trattenuti, le righe restano senza data, e i giorni e i giri solo-batteria costruiti su di essi sono spariti.

Lo zero-log-parser decodifica i log Gen3?

Dipende dalla versione, e questo sito non lo usa comunque per nessuna delle sue decodifiche Gen3. La versione che questo sito aveva fissato prima per Gen1 e Gen2, il commit 87c6e757 di febbraio 2026, stampa l'intestazione di un file Gen3 come vuota o «Unknown». La versione che fissa ora, 90c8cb2 del 29 settembre 2026, ha fatto molta strada: legge l'intestazione della scheda principale Gen3, la telemetria della batteria, i record del caricabatterie, di coda piena e di build del firmware, e percorre le pagine flash del file della batteria, e dove lei e il decoder di questo sito decodificano entrambi un record concordano: 2.866 letture di cella su 2.866 sui 18 file Gen3 nativi di qui. Ciò che non decodifica ancora sono i record di testo, la classe più grande in un file Gen3: il suo decoder dei messaggi legge come stringa il prefisso di sei byte del record.

Crediti: il progetto upstream zero-log-parser

Tutto in questa pagina poggia su zero-motorcycle-community/zero-log-parser, il progetto open source che ha documentato per primo il formato dei log Zero. Lo usiamo direttamente per il parsing Gen1 e Gen2, e il suo LOG_STRUCTURE.md resta il riferimento della comunità per quelle generazioni. Le mappe dei record Gen3 qui sopra sono nostre solo perché quel progetto ha reso leggibile il problema per primo.

Il supporto Gen3 era seguito nella issue #16, aperta dal 21 febbraio 2020 all'8 febbraio 2026. Il giudizio del maintainer merita di essere citato per intero, perché è esattamente giusto ed è il motivo per cui questa pagina esiste:

«Zero ha un nuovo formato per i log SR/F che corrisponde solo vagamente ai formati esistenti, quindi il parser dovrà quasi essere scritto da zero… non abbiamo copie di log decodificati ufficialmente da prendere a modello.»

Non esiste ancora una specifica ufficiale né un output di riferimento decodificato. Ogni offset qui è stato recuperato con misure, e le correzioni su file reali sono benvenute.

Ogni offset di byte pubblicato qui è stato misurato su file reali e non letto da un decoder. Le cifre sul mix dei record e sulla popolazione dei campi vengono da otto dump completi dell'app di MBB Gen3 nativi e sette dump BMS Gen3 che coprono cinque moto distinte (SR/F, SR/S, DSR/X). Esiste un nono file MBB nativo (uno spezzone troncato di 16.384 byte da una sesta moto, che la pipeline decodifica come Gen3), ed è incluso nel censimento degli escape, nelle popolazioni di stato 0x51 e nelle cifre di delimitazione ma escluso dalle quote del mix dei record; ogni conteggio di questa pagina dice a quale dei due appartiene. Le cifre su delimitazione, escape e 538XX vengono dall'intero corpus di 352 file, di cui 135 condividono la firma dell'intestazione 538XX e 14 superano il suo filtro di resa. Le misure sono state prese il 2026-07-30. Dove il decoder e i byte non concordavano, hanno vinto i byte: di conseguenza cinque affermazioni pubblicate in precedenza su questa pagina sono state ritrattate, e ogni ritrattazione è lasciata al suo posto con la misura che l'ha smentita, invece di essere cancellata in silenzio.

Questa è una specifica indipendente, mantenuta dalla comunità e prodotta per reverse engineering. Non è pubblicata, approvata né rivista da Zero Motorcycles, e nessuna sua parte va trattata come una descrizione ufficiale del formato. I layout dei record cambiano con il firmware (una moto di questo corpus ha cambiato la dimensione del suo record di telemetria tra due esportazioni), quindi verifica sui tuoi file prima di fidarti di qualsiasi offset qui riportato.