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é.
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.
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.
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.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.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.
| Byte | Campo | Come leggerlo | Misurato sui 18 file nativi |
|---|---|---|---|
| 0 | Delimitatore | 0xB2. Mai grezzo dentro un record: chi scrive ne fa l'escape come FE 4D, e di uno 0xFE letterale come FE 01 | Prima si delimita per il byte 1, poi si fa l'unescape di quello che si è delimitato |
| 1 | Lunghezza | Dimensione 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'unescape | Tolto il numero di escape, ogni tipo di record arriva a una lunghezza canonica |
| 2 | Tipo | 0xFB intestazione, 0xFD testo, da 0x51 a 0x54, 0x48, 0x49 e 0x4F sulla scheda principale; 0x4B, 0x4C e 0x4D sul pacco | Letto dopo l'unescape, come tutto da qui in poi |
| 3–6 | Timestamp | uint32 little-endian, secondi Unix, vero UTC | Il byte 6 cambia una volta ogni 2^24 secondi, circa 194 giorni |
| 7–10 | Microsecondi | uint32 little-endian, la parte sotto il secondo del timestamp | Massimo esattamente 1.000.000; mai oltre |
| 11 | Sequenza | uint8, +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 |
| 12 | Scostamento UTC | int8, 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… | Payload | Specifico del tipo. L'ASCII terminato da NUL di un record di testo 0xFD comincia qui | Il 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.
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.
| Valore | Byte | File in cui è l'impostazione | Record | Che cosa significa |
|---|---|---|---|---|
| −7 | 0xF9 | 1 scheda principale | 322 | Sette ore a ovest di UTC, un'impostazione nordamericana |
| 0 | 0x00 | 3 schede principali, 3 pacchi | 13.315 | UTC, per esempio il Regno Unito fuori dall'ora legale |
| +1 | 0x01 | 2 schede principali, 2 pacchi | 8.877 | Europa centrale in inverno, o Regno Unito in estate |
| +2 | 0x02 | 2 schede principali, 1 pacco | 6.883 | Europa centrale in estate |
| +8 | 0x08 | 2 schede principali, 2 pacchi | 8.908 | Otto 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.
| Regola | Valore | Effetto |
|---|---|---|
| Veto rigido: modello | S, SR, DS, DSR, FX, FXS, XU | Rilevamento Gen3 saltato del tutto |
| Veto rigido: codice anno nel VIN | A–J (2010–2018), carattere 10 del VIN | Rilevamento Gen3 saltato del tutto |
| Segnale 1: modello | SR/F, SR/S, DSR/X, FXE | Classificato Gen3 |
| Segnale 2: famiglia del VIN | ZF?Z, XXFZ o DZ?Z come sottostringa | Classificato 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 binaria | File MBB il cui buffer circolare 0xB2 si delimita, veto rigido non scattato | Instradato al decoder Gen3 fuori dal classificatore |
| Filtro del layout di record: MBB | Intestazione 0xFB nativa, o intestazione di record FST sui record delimitati | Richiesto prima di QUALSIASI segnale sopra per instradare una MBB al decoder nativo |
| Override di instradamento: BMS | Il caricatore binario BMS Gen3 riesce | Instradato al decoder BMS Gen3 |
| Filtro indipendente | Timestamp del record dopo unescape tra 2019-01-01 .. adesso + 365 giorni | Record 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:
- 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
- 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à.
| Popolazione | File | Byte 7–10 entro un secondo | Byte 12 scostamento civile | Scostamento dominante |
|---|---|---|---|---|
| Layout FST (8 file batteria a pagine, 10 file scheda principale) | 18 | ≥ 0,970 | ≥ 0,990 | ≥ 0,959 |
| Ogni altro file | 345 | ≤ 0,160 | ≤ 0,442 | ≤ 0,316 |
| Soglia per FST | — | 0,80 | 0,80 | 0,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.
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.| Tipo | Nome | Dimensione tipica | Conteggio per file | Quota | Contenuto |
|---|---|---|---|---|---|
| 0xFB | Intestazione | 117 B | 1 | — | VIN, tipo di scheda, seriale, codice articolo, build del firmware |
| 0xFD | Evento di testo | variabile, 28–105 B | 1.811–2.331 | 86,7% | Messaggi di log ASCII terminati da nullo |
| 0x51 | Telemetria | 75 B (71 B sul firmware 2023) | 131–239 | 6,9% | Stato, SOC, tensione e corrente del bus DC e del pacco, regime motore, temperature ambiente, motore, inverter e celle, linea a 12 V |
| 0x54 | Motore | 29 B | 0–239 | 5,6% | Coppia all'albero, corrente motore, tensione del bus DC; scritto accanto a ogni 0x51 |
| 0x52 | Esteso | 92 B (88 B sul firmware 2023) | 0–31 | 0,35% | Tutto quello che porta 0x51, più velocità su strada, autonomia stimata e (sul layout più recente) il contachilometri |
| 0x48 / 0x49 / 0x4F / 0x53 | Carica, coda, telemetria più grande | variabile | 0–69 | 0,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.
[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 digitsI 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.
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 secAbbreviato: 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.
| Stato | Record | SOC = 0 | post_1 / post_2 valorizzati | post_3 / post_4 valorizzati |
|---|---|---|---|---|
| HIB | 417 | 9 (2,2%) | 20 (4,8%) | 0 |
| PWSU | 408 | 373 (91,4%) | 0 | 34 (8,3%) |
| RUN | 144 | 0 | 144 (100%) | 144 (100%) |
| WAIT | 51 | 47 (92,2%) | 3 (5,9%) | 3 (5,9%) |
| WAKE | 44 | 0 | 3 (6,8%) | 44 (100%) |
| STOP | 41 | 0 | 18 (43,9%) | 41 (100%) |
| CHRG | 7 | 0 | 0 | 7 (100%) |
| REV | 5 | 0 | 5 (100%) | 5 (100%) |
| PARK | 4 | 0 | 4 (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.
[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 belowTre 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.
[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 measuredRecord 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.
| Byte del record | Campo | Tipo | Visto in questo corpus |
|---|---|---|---|
| 13–22 | Nome | ASCII da 10 byte, riempito con NUL | «3kW» (97), «Flt 6» (22) |
| 23–24 | Flag | uint16 LE | Bit non ancora identificati |
| 25–28 | Tensione di uscita DC | uint32 LE, mV | Tensione lato pacco |
| 29 | Corrente di uscita DC | uint8, A | Da 5 a 26 A |
| 37 | Comando in ingresso | uint8 | Salvato; significato non confermato |
| 39 | Tensione di ingresso AC | uint8, V | 113–115 V o 218–236 V |
| 40 | Corrente di ingresso AC | uint8, A | 5, 7, 9 o 12 A |
| 42 | Frequenza AC | uint8, Hz | 49, 50 o 60 |
| 44 | Id CAN | uint8 | 16, 17 |
| 45–46 | Versione firmware | uint16 LE | 104, 201, 206 |
| 47–50 | Numero di serie | uint32 LE | Decodificato; mai pubblicato |
| 53–56 | Limite di carica | uint32 LE, mV | La tensione che il caricabatterie può raggiungere |
| 57 | Comando in uscita | uint8 | Salvato; 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.
| Nome della coda | Visto qui | Ruolo probabile (dedotto, non dichiarato dal firmware) |
|---|---|---|
| CAN0RxQ, CAN1RxQ, CAN2RxQ | CAN0RxQ una volta | Messaggi ricevuti sul bus CAN 0, 1 o 2 |
| CAN1txQ, CAN2txQ | CAN1txQ 6, CAN2txQ 11 | Messaggi 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.
[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 unconfirmedBanner 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.
[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 bankIl 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.
| File esportato | Modello | Codice MBB | Lunghezze 0x51 su disco (di cui con escape) | 0x54 presente |
|---|---|---|---|---|
| 2021-09 (spezzone da 16 kB) | SR/S | 40-08198 | 71 (32, 0 con escape), 72 (11, 11), 73 (2, 2) | no |
| 2023-04 | SR/F | 40-08155 | 71 (177, 0), 72 (12, 12), 74 (1, 1) | no |
| 2025-10 | DSR/X | 40-08285 | 75 (142, 0), 76 (5, 5) | sì |
| 2025-12-29 | SR/F | 40-08155 | 75 (220, 0), 76 (19, 19) | sì |
| 2025-12-31 | SR/S | 40-08198 | 75 (152, 0), 76 (2, 2) | sì |
| 2026-01-01 | SR/S | 40-08198 | 75 (147, 0), 76 (3, 3) | sì |
| 2026-01-21 | DSR/X | 40-08285 | 75 (130, 0), 76 (1, 1) | sì |
| 2026-02-07 08:53 | SR/F | 40-08198 | 75 (143, 0), 76 (6, 6) | sì |
| 2026-02-07 14:37 | SR/F | 40-08155 | 75 (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.
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 == 40Leggi 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 è.
| Offset | Ampiezza | Campo | Decodifica | Intervallo accettato |
|---|---|---|---|---|
| +7 | uint8 | Temperatura alta del pacco | °C | 0 < t < 80 |
| +8 | uint8 | Temperatura bassa del pacco | °C | 0 < t < 80 |
| +9 | uint16 LE | Stato di carica | % | 0–100 |
| +11 | uint32 LE | Tensione del pacco | millivolt, esatti | 50–130 V |
| +15 | int16 LE | Temperatura del motore | °C | 0 < t < 150 |
| +17 | int16 LE | Temperatura del controller | °C | 0 < t < 150 |
| +19 | uint16 LE | Giri motore | RPM; nessuna velocità derivata | ≤ 8000 |
| +23 | int16 LE | Corrente della batteria | ampere interi, scarica positiva | ±400 A |
| +25 | uint8 | Bitmask di presenza dei moduli | 0/1/2/3 → 00/10/01/11 | ≤ 3 |
| +26 | int16 LE | Corrente del motore | ampere | ±1000 A |
| +28 | int16 LE | Temperatura ambiente | °C | −50 … 70 inclusi |
| +30 | uint16 LE | Contachilometri | km, totale, non decrescente | vedi 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.
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.
| Testo dell'evento, confrontato senza distinguere maiuscole | Stato derivato |
|---|---|
| Module scheme changed from … to Running mode | RUN |
| Module scheme changed from … to Stopped mode | STOP |
| Module scheme changed from … to Charging mode | CHRG |
| Entering charge standby | CHRG |
| Leaving charge standby | STOP |
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.
| Tipo | Nome | Dimensione | Conteggio per file | Totale nel corpus | Contenuto |
|---|---|---|---|---|---|
| 0xFB | Intestazione | 125 B | 1 | 7 | Tipo di scheda, codice articolo, numero di serie, cellbox, firmware |
| 0xFD | Evento di testo | variabile | 1.596–1.997 | 13.178 | Transizioni di stato, guasti, diagnostica |
| 0x4B | Telemetria | 52 B | 186–527 | 1.803 | Tensioni delle celle, corrente, SOC, tensione del pacco, stato |
| 0x4D | Telemetria estesa | 78 B | 79–126 | 691 | I campi del 0x4B spostati di +8, più il registro della capacità a carica piena |
| 0x4C | Dettaglio celle | 70 B | 0–65 | 84 | I campi del 0x4B spostati di +4; scritto nei periodi di funzionamento |
| 0x00 / 0xF0 | Parziale o debug | variabile | 12–28 | 127 | Artefatti 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.
[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 hashRecord 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.
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.
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] | Righe | Modalità di report 3 (sonno) | SOC = 0 | Flag di carico 0x78 | Media |corrente| |
|---|---|---|---|---|---|
| 0x00 | 1.057 | 57 (5,4%) | 19 (1,8%) | 590 (55,8%) | 3.869 mA |
| 0x20 | 517 | 427 (82,6%) | 517 (100%) | 504 (97,5%) | 40 mA |
| 0xF0 / 0xFF | 24 | 6 (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.
| Valore | Significato | Righe | Quota |
|---|---|---|---|
| 1 | Report SOC standard | 522 | 32,7% |
| 3 | Sonno / minimo | 490 | 30,7% |
| 7 | Attivo ad alta frequenza, ricarica o scarica | 437 | 27,3% |
| 4 | Inattivo | 31 | 1,9% |
| 5 | Precarica | 29 | 1,8% |
| 6 | Sconosciuto | 28 | 1,8% |
| 0 / 240 / 255 | Non inizializzato o sentinella della flash | 61 | 3,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[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 belowpayload[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.
| Valore | Righe | Quota | Sotto carico | Enum dichiarato |
|---|---|---|---|---|
| 0x0B | 603 | 26,0% | 14,4% | inattivo |
| 0x0C | 566 | 24,4% | 45,2% | attivo |
| 0x0A | 142 | 6,1% | 34,5% | precarica |
| 0x0D | 131 | 5,6% | 16,0% | senza nome |
| 0x10 | 111 | 4,8% | 62,2% | senza nome |
| 0x0F | 54 | 2,3% | 40,7% | senza nome |
| 0x12 | 52 | 2,2% | 15,4% | senza nome |
| 0x14 | 51 | 2,2% | 3,9% | senza nome |
| 0x09 | 47 | 2,0% | 74,5% | sblocco |
| 0x11 | 41 | 1,8% | 12,2% | senza nome |
| 0x00 | 40 | 1,7% | 12,5% | senza nome |
| 0x08 | 39 | 1,7% | 35,9% | senza nome |
| 0x13 / 0x16 / 0x17 | 106 | 4,6% | 2,7% / 5,9% / 2,9% | senza nome |
| 0x06 | 36 | 1,6% | 13,9% | senza nome |
| 0x15 / 0x18 | 60 | 2,6% | 3,3% / 0,0% | senza nome |
| 0x07 | 29 | 1,3% | 20,7% | senza nome |
| 0x0E | 26 | 1,1% | 7,7% | senza nome |
| 0x05 | 25 | 1,1% | 12,0% | senza nome |
| 0xF0 / 0xFF | 43 | 1,9% | 10,5% / 29,2% | sentinelle della flash |
| 14 altri valori, ciascuno sotto le 20 righe | 117 | 5,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.
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 byteRitirati: 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.
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:
| Il marcatore parte da | Marcatori | Che cosa ottiene un decoder che lo legge attraverso |
|---|---|---|
| Un byte dentro il payload o il testo di un record | 5.807 | Una misura sbagliata (una corrente, una tensione, uno stato di carica) o un messaggio tagliato |
| I microsecondi (byte 7–10 del record) | 635 | Una 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 prima | 612 | Due record fusi in un solo intervallo: dividendo su 0xB2, il primo record, integro, va al parser sbagliato |
| Il timestamp stesso (byte 3–6) | 574 | Un 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) | 302 | Una sequenza o un offset sbagliati, e i primi byte del payload |
| Il byte di tipo (byte 2) | 139 | Tipo 0x00 e un timestamp 0xHH00FFF0, un secondo falso; 138 dei 139 sembrano ancora plausibili |
| Il byte di lunghezza (byte 1) | 131 | Lunghezza 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:
- 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.
- 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.
- 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.
- 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.
| Campo | Righe di telemetria trattenute | Su un totale di |
|---|---|---|
| Tensione del pacco misurata (la riga porta invece la stima basata sulle celle) | 156 | 2.985 |
| Corrente del pacco | 130 | 2.985 |
| Timestamp (la riga resta senza data) | 130 | 2.985 |
| Byte di sequenza | 124 | 2.985 |
| Flag di carico | 122 | 2.985 |
| Modalità di report | 104 | 2.985 |
| Byte di attività | 103 | 2.985 |
| Stato di carica | 24 | 2.985 |
| Uno qualsiasi dei precedenti | 692 | 2.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.
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] 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.
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 countIl 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.
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.| Finestra | Intervallo | Applicata da | Scopo |
|---|---|---|---|
| Delimitazione Gen3 | 2019-01-01 .. now + 365 days | Entrambi i delimitatori binari Gen3, per record, DOPO il ripristino degli escape | Scartare gli slot del buffer circolare non scritti o cancellati |
| Validità generica | anni di calendario 2015 .. 2030 | Dopo il parsing, ogni generazione | Escludere 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.
| Scheda | Campo | Posizione | Stato |
|---|---|---|---|
| BMS | Tensione di cella min / max | payload[13:15], payload[17:19] | Decodificato: uint16 LE mV, validato 2.500–4.500; aggiungi 8 sul 0x4D, 4 sul 0x4C |
| BMS | Tensione a circuito aperto della cella | payload[15:17] | Decodificato: memorizzato, non ancora usato per il SOC |
| BMS | Stato di carica | payload[19] | Decodificato: 0 significa che dorme, non che è scarica |
| BMS | Corrente del pacco | payload[20:24] | Decodificato: int32 LE mA. Letto come int16 fino al 2026-07-31 |
| BMS | Tensione del pacco | payload[38:41] | Decodificato: uint24 LE mV, misurata, 94,4% nell'intervallo |
| BMS | Temperatura | — | 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 |
| BMS | Indicatore di ricarica | payload[22:24] | Derivato: la metà alta della corrente int32; il suo segno, non un flag |
| Both | Contatore di sequenza | record[11] | Decodificato: uint8, +1 per ogni record di qualsiasi tipo; memorizzato come bms_sequence sulle righe BMS |
| Both | Impostazione del fuso UTC | record[12] | Decodificato: int8 ore; riassunto per file, mai applicato a un timestamp |
| BMS | Valori sotto un marcatore di pagina | ogni 128·k | Trattenuto: il campo è nullo e indicato in withheld_fields |
| BMS | Flag di carico / bus inserito | payload[27], payload[28] | Decodificato: segnali complementari |
| BMS | Modalità di report | payload[37] | Decodificato: 7 valori noti nei vari tipi di record; il valore 6 è senza spiegazione |
| BMS | Byte di attività (in precedenza «codice di stato») | payload[24] | NON decodificato: memorizzato così com'è; 37 valori, nessun enum resiste ai test |
| BMS | Indicatore di sonno | payload[9] | Decodificato: 0x20 dorme, 0x00 sveglio (misurato) |
| BMS | Capacità a carica piena | record[67:70] + gemello a [74:77] | Decodificato: uint24 LE mAh, memorizzato, non ancora consumato |
| BMS | Tensione del pacco (copia 0x4D) | record[54:57] | Decodificato: uint24 LE mV; ritirato come «contatore di coulomb» |
| BMS | Contatore cumulativo per moto | extra[10:12] | Sconosciuto: varia da 38.967 a 56.414, nessuna correlazione trovata |
| BMS | Dettaglio per blocco di celle | record 0x4C, campi spostati di +4 | Decodificato: stessa mappa del 0x4B a +4; mappatura per blocco non stabilita |
| BMS | Conteggio dei cicli di ricarica | — | Non esiste. Il byte 67 è un byte della capacità |
| MBB | Stato | record[42:51], [46:55], [50:59] a seconda del tipo | Decodificato: ancorato per tipo di record, dieci token tra cui REV e PARK |
| MBB | Stato di carica | record[33] | Decodificato: uint8, 0 in PWSU significa non inizializzato |
| MBB | Flag della modalità del controller | record[17] | Decodificato: 0x00 attivo, 0x6A standby, 0x60 transizione |
| MBB | Temperature | record[51:71], cinque uint32 | Decodificato: ambiente, motore, inverter, cella alta, cella bassa (rietichettate il 2026-09-07) |
| MBB | Corrente della batteria | record[38:42] | Decodificato: int32 LE mA, solo con il bus attivo |
| MBB | Tensione / corrente del bus DC, giri motore | record[21:33] | Decodificato: le letture del controller, solo con il bus attivo |
| MBB | Linea 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 |
| MBB | Velocità su strada, autonomia stimata | coda 0x52 / 0x53 | Decodificato: mm/h e centesimi di km; non in un 0x51 |
| MBB | Contachilometri | coda 0x52 / 0x53, layout più recente | Decodificato: 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) |
| MBB | Record del motore | 0x54, 29 byte | Decodificato: coppia all'albero, corrente del motore, tensione del bus DC |
| MBB | Tensione del pacco | record[34:38] | Decodificato: solo con il bus attivo |
| MBB | Tabella del caricabatterie / obiettivi di ricarica | 0x48 / 0x49 | Decodificato: ogni record del caricabatterie, V/A/Hz di rete, uscita DC, id CAN, seriale; limite massimo, % obiettivo, tensione di stoccaggio |
| MBB | Coda piena | 0x4F, 31 byte | Decodificato: nome della coda e due contatori, significato non confermato |
| MBB | Intestazione | 0xFB | Decodificato: VIN (cifra di controllo validata), modello, anno modello, revisione della scheda e del firmware, build del firmware |
| MBB | Banner della build del firmware | 0x32, layout più vecchio, dump della piattaforma Gen2 | Decodificato: data di build, numero di build, banco flash; ogni build annunciata da un file, nell'ordine del file |
| Both | Eventi di testo | 0xFD, dal byte 13 del record | Decodificato: ASCII terminato da NUL; il testo tagliato da un marcatore di pagina è conservato fino al marcatore e segnalato |
| MBB | Istantanea dello stato | 0x4B / 0x4C / 0x4D, lato MBB | Solo etichetta: nessuna in questo corpus; non usata per i giri |
| 538XX | Tensione, corrente, giri, 5 temperature, contachilometri | record 0x2c, 40 byte | Decodificato: 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.
| Campo | Record | Concordano | Differiscono | Trattenuti qui |
|---|---|---|---|---|
| Tensione di cella più bassa e più alta del BMS | 2.866 | 2.866 | 0 | 0 |
| Stato di carica del BMS | 2.866 | 2.842 | 0 | 24, sotto un marcatore di pagina |
| Corrente del pacco BMS | 2.866 | 2.707 | 29 | 130, sotto un marcatore di pagina |
| Tensione misurata del pacco BMS | 2.866 | 2.695 | 15 | 156, sotto un marcatore di pagina |
| Stato del veicolo MBB (0x51, 0x52, 0x53) | 1.727 | 1.727 | 0 | — |
| Temperature MBB 0x51: motore, inverter, cella alta, cella bassa | 1.536 ciascuna | 1.536 ciascuna | 0 | — |
| Caricabatterie MBB 0x48: nome, id CAN, versione, seriale, frequenza | 119 ciascuno | 119 ciascuno | 0 | — |
| Coda piena MBB 0x4F: nome ed entrambi i valori | 18 ciascuna | 18 ciascuna | 0 | — |
| Record di testo (0xFD), entrambe le schede | 33.460 | L'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.
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.
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.
Fonti:
- zero-motorcycle-community/zero-log-parser, il parser open source upstream su cui si basa questo progetto (si apre in una nuova scheda)
- zero-log-parser: LOG_STRUCTURE.md, il riferimento della comunità per il layout dei record Gen1/Gen2 (si apre in una nuova scheda)
- zero-log-parser issue #16, "Support SR/F (Gen3) logs", aperta dal 2020-02-21 al 2026-02-08 (si apre in una nuova scheda)
- zero-log-parser commit 2c98751 (2026-09-22): il percorso consapevole delle pagine per il formato di pagina FST/Gen3 BMS (si apre in una nuova scheda)
- zero-log-parser commit 8591af3 (2026-09-15): campi dell'intestazione MBB Gen3 (si apre in una nuova scheda)
- zero-log-parser commit f1e34cb e 1da1827 (2026-09-20): la tabella del caricabatterie 0x48 e i record di coda piena 0x4F (si apre in una nuova scheda)
- NHTSA vPIC: decodifica del VIN, incluso il carattere dell'anno modello usato dal veto Gen3 (si apre in una nuova scheda)
- 49 CFR 565: requisiti del Vehicle Identification Number, la tabella dei codici dell'anno modello (si apre in una nuova scheda)
- ZeroManual: documentazione della comunità sulla diagnostica di Zero Motorcycles (Internet Archive) (si apre in una nuova scheda)
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.