Gen2 contro Gen3: le differenze dei log
Un confronto tecnico dei formati di log di Zero Motorcycles tra le generazioni, basato su reverse engineering e analisi sul campo.
TL;DR
«Gen2» e «Gen3» in questa pagina indicano un formato di log, non una moto. Le generazioni di prodotto di Zero stessa non coincidono con essi modello per modello, e una terza numerazione, quella che registra il nostro parser, differisce ancora; la sezione qui sotto le separa tutte e tre.
I log in formato Gen2 sono file da 262.144 byte le cui righe sono istantanee binarie periodiche che portano tutti i canali insieme, che il parser rende come testo etichettato. Ogni file che abbiamo di una S, SR, DS o DSR (2014-2023) è di questo tipo, e così ogni file di una FX (2014-2025), FXS (2016-2021) o FXE (2022-2025). I log in formato Gen3 sono buffer circolari di record binari con prefisso di lunghezza (131.200 byte sull'MBB, 131.328 sul BMS) e vengono da SR/F e SR/S (dal 2020) e DSR/X (dal 2023). Differiscono soprattutto per ciò che un decodificatore ne ricava. Una riga di guida Gen2 ti dà volt, ampere, RPM e un contachilometri su una sola riga. Un record MBB Gen3 nativo porta la tensione del pacco e la corrente della batteria, a record[34:38] e record[38:42], letti dal nostro decodificatore dal 2026-09-07, ma sono vuoti negli stati di ibernazione e di accensione, che compongono tre quarti di un log reale. La velocità su strada e il contachilometri non stanno in quel record comune: stanno nella coda dei record più rari 0x52 e 0x53, e il contachilometri solo nel più recente dei due layout del firmware. Quindi un upload Gen3 ha ancora bisogno del suo compagno BMS prima che si riempiano la maggior parte dei grafici elettrici: i valori dell'MBB ci sono, ma sono scarsi.
Formato del file
La differenza più visibile è il file in sé: dimensione, convenzione di nome e struttura interna.
Formato Gen2 (istantanee binarie)
Full SupportGen3 (FST / Cypher III)
Full SupportNote: il firmware Gen2 più recente usa VIN_MbbD_date.bin come nome («bb» minuscolo + «D»). Il formato è lo stesso; è cambiata solo la convenzione del nome del file.
Perché i conteggi dei record in questa pagina dicono «framing a catena di lunghezze»
Ci sono più modi di contare i record in un file Gen3, e non concordano, quindi ogni popolazione in questa pagina dice quale ha usato. Il framing a catena di lunghezze è quello che usa il nostro decodificatore MBB: a ogni posizione il byte dopo il 0xB2 delimitatore dà l'estensione su disco del record, e il record successivo comincia esattamente tanti byte dopo. Contare semplicemente i byte 0xB2 o dividere su ognuno di essi dà totali diversi. È anche poco sicuro, perché 0xB2 è un byte di dato lecito che chi scrive protegge con escape come FE 4D (con FE 01 per un valore letterale 0xFE). Delimita il record con la lunghezza dichiarata prima, poi rimuovi l'escape dal record delimitato. Negli otto dump MBB a dimensione piena misurati qui, 468 dei 19.089 record contengono un escape, 477 byte di escape in tutto. Sono pochi, ma cadono dentro timestamp e token di stato, quindi ignorarli corrompe i record invece di farli perdere. Le regole a livello di byte sono nella specifica del formato.
Tre cose qui si chiamano «generazione», e non concordano
1 · Generazione di prodotto: ciò che Zero ha costruito, come lo indicano i suoi manuali d'uso. I manuali mettono FX e FXS alla generazione 1 (XMX · modulare) per tutta la loro vita; S, SR, DS e DSR alla generazione 2 (SDS · Z-Force, Cypher II) dal 2014 al 2023 e alla generazione 3 (FST · Cypher III) dal 2024; SR/F e SR/S alla generazione 3 dal 2020 e DSR/X dal 2023; la FXE alla generazione 2 (XMX · modulare, Cypher II); e LS1, XE e XB 2026 alla generazione 3 sulle piattaforme LS e X-line. Il nostro catalogo delle moto mostra direttamente quelle schede.
2 · Generazione del formato di log: quale layout binario usa il file. È ciò che descrivono le due schede qui sopra, ed è il senso in cui questa pagina lo usa ovunque, salvo diversa indicazione. Attraversa le generazioni di prodotto: una FX (generazione di prodotto 1) e una DSR (generazione di prodotto 2) scrivono lo stesso file in formato Gen2.
3 · Generazione di instradamento: il valore log_generation che il nostro parser memorizza per il tuo upload. È un'indicazione di quale decodificatore ha girato, niente di più.
La FXE è il punto in cui tutte e tre si scontrano
La FXE è una moto Cypher II (senso 1: generazione 2), è nell'insieme del parser GEN3_MODELS quindi memorizziamo log_generation = 3 per essa (senso 3), e i suoi file sono dump ordinari da 262.144 byte MBB\0 / BMS\0 che si decodificano attraverso il percorso del firmware 538XX: un formato di record di lineage Gen2, non quello Gen3 nativo (senso 2). Tutte e tre le affermazioni sono vere insieme, e una frase che ne sceglie una senza dire in quale senso la intende è sbagliata. Nessun file FXE di questo corpus è un buffer circolare Gen3 nativo.
La meccanica: GEN3_MODELS è {SRF, SRS, SR/F, SR/S, DSRX, DSR/X, FXE} e l'elenco di veto GEN2_ONLY_MODELS è {S, SR, DS, DSR, FX, FXS, XU}. La FXE compare nel primo e non nel secondo (backend/app/parser.py, righe 2443 e 2449). Un veto netto scatta per primo se il modello è nell'elenco solo Gen2 oppure il decimo carattere del VIN è un codice anno da A a J (2010-2018), e solo allora si consultano i tre segnali positivi: modello, schema VIN Gen3, schemi di testo solo Gen3 senza telemetria Gen2.
Una conseguenza che non abbiamo potuto verificare. L'elenco di veto contiene nomi di modello nudi senza un termine d'anno, e i manuali mettono S, SR, DS e DSR dal 2024 in poi sulla piattaforma FST / Cypher III. Quindi una DSR 2025 verrebbe messa in veto sul percorso Gen2 solo per il nome, qualunque cosa contenga il suo file. GEN3_MODELS non elenca neppure LS1, XE o XB, quindi la linea leggera 2026 non ha nessun instradamento. Se uno dei due sia un vero difetto non sappiamo dirlo: il nostro corpus di 352 file non contiene nessuna S, SR, DS o DSR dal 2024 in poi né log della linea leggera, quindi non c'è nulla da misurare. Finché non esisterà un file del genere è un rischio aperto, e il veto resta com'è: il commento sopra di esso nel parser registra una regressione che è stato scritto per evitare. Se ne hai uno, mandacelo.
Come vengono registrati i dati
Gen2: istantanee periodiche
Gen2 registra un'istantanea completa di telemetria una volta al minuto durante la guida, e aggiornamenti periodici durante la ricarica e la sosta. Ogni riga contiene i dati all disponibili, decodificati in coppie chiave/valore leggibili. Il record dell'istantanea in sé è binario, e l'inglese che leggi è la tabella del parser e non parole memorizzate dalla moto. Accanto a quei record binari il firmware scrive anche testo suo, in record di stringhe di debug 0xFD: cambi di stato, errori CAN, commutazione del caricatore.
Misurato sugli estratti pubblicati: 56 righe Gen2 su 169 sono testo scritto dalla moto stessa, tutte da quei record 0xFD, contro 43 su 293 su Gen3, dove vengono dai record di evento del pacco. L'MBB Gen3 scrive anche eventi di testo, ma il suo decodificatore non segna quali record ne contenevano uno, quindi le sue righe sono contate come decodifica nostra. Entrambe le generazioni mescolano record binari e testo del firmware.
// Una vera voce di guida MBB Gen2, decodificata (FXS 2016, MBBEntry)
MBB #929 15:22:15 Riding
pack_temp_high_celsius: 34, pack_temp_low_celsius: 32, state_of_charge_percent: 75, pack_voltage_volts: 108.28, motor_temp_celsius: 44, controller_temp_celsius: 32, motor_rpm: 1349, battery_current_amps: 4, motor_current_amps: 5, ambient_temp_celsius: 28, odometer_km: 30800, mods: 11, mods_raw: 3
MBB #930 15:23:15 Riding
pack_temp_high_celsius: 34, pack_temp_low_celsius: 32, state_of_charge_percent: 74, pack_voltage_volts: 106.924, motor_temp_celsius: 46, controller_temp_celsius: 32, motor_rpm: 1744, battery_current_amps: 23, motor_current_amps: 48, ambient_temp_celsius: 28, odometer_km: 30800, mods: 11, mods_raw: 3
// 21 lines in this window · timestamps real · ogni riga è la nostra decodifica dei byte
Ogni campo è disponibile in ogni riga di guida, e la cadenza di 60 secondi è esatta: è l'intervallo dominante tra una riga e l'altra in ogni file Gen2 misurato qui.
Guarda questa finestra riga per riga: lo stesso estratto con ogni campo nominato, accanto alla corsia batteria che stava scrivendo nello stesso momento.
Gen3: buffer circolare a eventi
Gen3 usa un buffer circolare che memorizza gli eventi man mano che accadono. La telemetria è incorporata in record binari da 75 byte, e i record ASCII registrano cambi di stato, guasti e messaggi di sistema. Le righe sono non cronologiche nel file, perché il buffer circolare si riavvolge.
// Record reali, decodificati campo per campo, dal momento in cui una Gen3 parcheggiata va a dormire (DSR/X 2023, Gen3MBBEntry)
MBB #248 08:24:18 State change
from: PWSU, to: HIB
MBB #249 08:24:18 MTC pending change by 3
from: 0, to: 0
MBB #250 08:24:18 Stopping 12v charge
DC-DC: 281776uV, Battery: 13153056uV, Combined: 12340647uV, Ambient: 33C
MBB #251 08:24:18 Unknown
// 26 lines in this window · timestamps real · testo del dispositivo e nostra decodifica mescolati
Guarda una Gen3 ferma andare avanti così, un'ora alla volta, e i due orologi che fanno sembrare una coppia Gen3 come se le schede non scrivessero mai insieme.
I record mescolano binario e ASCII, vanno ordinati per timestamp dopo il parsing e danno meno righe per giro. Le parole di tensione e corrente sono reali: sono popolate in ogni record RUN e in nessun record di ibernazione, e il nostro decodificatore le legge dal 2026-09-07. Poiché vanno a zero con il bus, in pratica volt e ampere vengono ancora dal file BMS. In questo record comune da 75 byte non ci sono km/h né contachilometri (entrambi stanno solo nei record più rari 0x52 / 0x53); il terzo valore qui sopra è la linea accessori a 12 V, che resta viva mentre il pacco è scollegato.
Confronto della telemetria MBB
Quali dati sono disponibili nel log dell'MBB (Main Bike Board) di ogni generazione. Gli offset Gen3 qui sotto sono dati rispetto a s, la posizione della stringa di stato ASCII; in un record di telemetria 0x51 di tipo s = 42, ed è 42 in tutti i 1.356 record di questo tipo nei nove file MBB Gen3 nativi qui (1.347 se conti solo gli otto token di stato che il parser riconosceva prima del 2026-08, e tutti i 1.356 con REV e PARK, che entrambi i decodificatori ora leggono). Diverse righe Gen3 qui sotto erano segnate come «presente ma non letto» o «non registrato» fino a settembre 2026: i byte c'erano da sempre, e il nostro decodificatore li legge dal 2026-09-07. Un report parsato prima di quella data li mostra solo dopo una nuova elaborazione.
| Campo dati | Gen2 | Gen3 |
|---|---|---|
| Pack Voltage | Every entry (Vpack, V) | MBB [s-8] ([34:38], uint32 LE mV), decoded since 2026-09-07, only while the bus is live: non-zero on 144/144 RUN and 0/417 HIB records. The BMS reading (payload[38:41], uint24 LE mV, measured) is the one with continuous coverage |
| Battery Current | Every entry (BattAmps, A) | MBB [s-4] ([38:42], int32 LE mA), decoded since 2026-09-07, populated with the voltage. The BMS reading (payload[20:24], int32 LE mA) is the one with continuous coverage |
| SOC (State of Charge) | Every entry (PackSOC, %) | Binary [s-9]: uint8 0-100% (dashboard value; BMS carries its own at payload[19]) |
| Motor RPM | Every entry (MotRPM) | [s-13] ([29:33], int32 LE): the controller's motor rpm, decoded since 2026-09-07, only while the bus is live |
| Speed | Derived from RPM | Recorded, but only in the tail of the rarer 0x52 / 0x53 records (millimetres per hour); a 0x51 ends before it. Decoded since 2026-09-07 |
| Odometer | Every entry (Odo, km) | Only in the 0x52 / 0x53 tail, and only on the newer firmware layout (tenths of a km), decoded since 2026-09-07 and checked as a series per file. The older layout has none, and no 0x51 has one. [s+29] was published here as one, but it is the 12 V accessory rail (see the retraction below) |
| 12 V accessory rail | Not recorded. None of the Gen2 binary record types the parser decodes has a 12 V field, and no 0xFD text record in the Gen2-format MBB files here prints the rail's voltage. Some firmware writes `Turning ON DCDC` and `Turning OFF DCDC` lines, with no voltage | Post-state field 5 ([s+29], uint32 LE microvolts), decoded and emitted raw as aux_12v_uv. Alive even in hibernation, unlike everything else here |
| Motor Temperature | Every entry (MotTemp, °C) | post_1 ([s+13], uint32 LE °C), zero when the bike is parked. Until 2026-09-07 this word was labelled pack-high and stored as the battery temperature; a reparse corrects older reports |
| Controller Temp | Every entry (CtrlTemp, °C) | post_2 ([s+17], uint32 LE °C): the inverter, tracking the motor and zero when parked. Until 2026-09-07 it was labelled pack-low and stored as the motor temperature |
| Ambient Temp | Every entry (AmbTemp, °C) | post_0 ([s+9], uint32 LE): hundredths of a degree on most firmware, whole degrees on some; each file is internally consistent |
| Pack Temperature | Every entry (hi/lo, °C) | post_3 / post_4 ([s+21] / [s+25], uint32 LE °C): cell high and cell low, written in every state, charging included. Until 2026-09-07 these two words were labelled ambient and controller |
| Torque | Not recorded. While riding, the parser estimates it from battery power (pack voltage times battery current) times 9549 divided by motor RPM, so it includes the losses between pack and shaft | The 0x54 motor record, written beside every 0x51: shaft torque in micro-newton-metres, exactly 0.2 N·m per amp of motor current. Decoded since 2026-09-07; this page called it not recorded until then. On 538XX firmware it is derived (kW × 9549 / rpm) |
| Motor Amps | Every entry (MotAmps) | The 0x54 motor record, int32 LE whole amps, decoded since 2026-09-07, on firmware that writes 0x54 at all (one 2023 SR/F export here has none). The 538XX firmware variant carries it too, as int16 amps at record[26], right after the module bitmask |
| Power (kW) | Derived (V × BattAmps) | Derived from BMS voltage × BMS current; the MBB pair gives the same product, but only while the bus is live |
| Discharge Limit | Not available | 0xFD ASCII records (watts, stored as kW) |
| Charge Limit | Not available | 0xFD ASCII records (watts, stored as kW) |
| Controller Active | Not available | Record byte 17: 0x00=active (144/144 RUN records), 0x6A=standby (408/408 PWSU, 397/417 HIB), 0x60=transition. The decoder indexes it as binary_data[11] because its loader hands over the record from byte 6 onwards |
| Bike State | Derived from event type | ASCII [s:s+9], null-padded. The parser knows ten tokens: RUN/STOP/HIB/STRT/PWSU/CHRG/WAIT/WAKE/REV/PARK. The last two were added in 2026-08; before that they were decoded as records with no state and their telemetry was dropped |
| Error Codes | The binary 0x2F record, shown as SEVCON CAN EMCY Frame, holds a 16-bit error code, the Sevcon controller's own 16-bit code and an error register. A few other binary records each stand for one fault, such as 0x31 MBB BMS Isolation Fault. Most warning and error lines in the MBB log are text the firmware stores in 0xFD records, such as `CAN1 ACK error. count=1` | Fault pending/cleared ASCII records |
| Writes while switched off | Main board writes nothing at all. The BMS wakes about once a day (86,401 s between blocks in the parked window measured here) | Every hour, for ever. The main board declares 3,600 s of sleep and keeps to it to the second; with the 91 s it spends awake the true period is 3,691 s, so about 23 entries a day in a locked garage. This is what fills the ring buffer in roughly three days |
| Ride Mode | Not recorded. No Gen2-format file in this corpus contains a ride-mode string of any spelling; `Mods` on a riding line is the battery-module presence bitmask, not a mode | Recorded, but only as an ASCII event when it changes: `Changing riding mode to 3, SPORT`. Sparse: 8 events across 2 of the 9 native Gen3 MBB files here (tokens seen: 1 ECO, 3 SPORT, 4 ARM, 4 Full). No decoder extracts it, so the app's riding-mode field stays owner-declared |
Ritirato: [s+29] non è un contachilometri, e questa pagina diceva che lo era
Il campo 5 dopo lo stato era pubblicato qui come contachilometri totale in metri, e il suo comportamento era spiegato come jitter. Non è un contachilometri. Ognuno dei 1.121 record completi da 75 byte di tipo 0x51 di questo corpus soddisfa v = 5128k + 4864 (un ADC a 12 bit con un bit meno significativo da 5,128 mV su circa 21 V di fondo scala), e letto come microvolt il campo va da 0,143 V a 13,440 V, che è la banda e l'unità che i testi degli eventi del firmware usano per la batteria accessoria ("Stopping 12v charge. DC-DC 302288uV, Battery 13142800uV"). Una scansione esaustiva di ogni finestra uint32 in quel record non trova nessun campo monotono, salvo il timestamp stesso. In un record 0x51 non c'è affatto un contachilometri. Quella frase finiva con «in un record MBB Gen3 nativo», che era un'affermazione su un record formulata come un'affermazione sulla moto. Il vero contachilometri sta nella coda dei record più lunghi 0x52 / 0x53, solo nel layout più recente del firmware, ed è decodificato dal 2026-09-07.
Il decodificatore è stato cambiato di conseguenza: non scrive più odometer_km da questo campo, ed emette invece aux_12v_uv al suo posto. Un MBB Gen3 nativo il cui log non contiene record 0x52 / 0x53 del layout più recente riporta quindi no nessun contachilometri e nessuna distanza per giro, invece di uno fabbricato. Un vero contachilometri esiste su Gen2 e sulla variante di firmware 538XX, a un offset diverso in un record diverso.
Corretto anche questo: l'MBB porta tensione e corrente del pacco, che avevamo detto di no
Una revisione precedente di questa pagina diceva che i tre slot uint32 prima della stringa di stato erano etichettati male come tensione, corrente e velocità, e concludeva che un record MBB Gen3 non contenga dati elettrici. La prima metà era giusta; la conclusione era troppo forte. 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]. Sono tredici byte più avanti nel record dello slot che era stato etichettato male, quindi sono byte diversi, non una seconda lettura degli stessi.
La prova è un filtro di popolazione e una curva fisica. Sui 1.121 record completi da 75 byte, [34:38] è diverso da zero su 144 su 144 record RUN, 5 su 5 REV e 4 su 4 PARK, e su zero su 417 HIB, zero su 408 PWSU e zero su 51 WAIT. È popolato esattamente quando l'alta tensione è attiva, senza eccezioni in nessuna direzione. La curva è una prova più forte. In un file del 2021 (i cui record di telemetria usano la forma più vecchia da 71 byte, quindi fuori dai 1.121 appena contati), 32 record CHRG consecutivi mostrano il campo che sale in modo monotono da 102,081 V a 114,075 V in 5,5 ore mentre la parola della corrente resta tra −11,6 A e −15,3 A e il SOC va da 41 a 100. Negli ultimi sei record il SOC è inchiodato a 100 mentre la tensione sale ancora, da 111,756 V a 114,075 V. È una fase di assorbimento a tensione costante; nessun campo di riempimento né tabella di conversione del SOC ne produce una. Un secondo file, un'altra SR/F, la ripete su 15 record (da 106,605 V a 114,894 V, SOC da 60 a 100). Integrando V·I sulla variazione di SOC si ottengono circa 13,6 kWh e 12,4 kWh di equivalente a pacco pieno, contro un pacco da 14,4 kWh massimi e 12,6 kWh nominali.
L'avvertenza sul campo di applicazione è seria: ogni dato dinamico qui sopra viene da un VIN con prefisso 538ZF, la piattaforma SR/F 2020-2023. L'unica vera moto con WMI PAG qui, una DSR/X, contribuisce con 278 record di tipo 0x51 di cui 18 popolati, un record RUN e nessun record CHRG, quindi su quell'hardware non si può eseguire nemmeno un test di conservazione. L'alternativa non è esclusa: che il layout sia condiviso ma il firmware dell'era DSR/X lo popoli solo in stati che questo corpus contiene a malapena.
La correlazione di Pearson che questa pagina citava è ritirata. Sosteneva una parola diversa, record[21:25], da r = 0,913 contro la tensione del pacco del BMS, su una moto e una coppia di file. Rifatto su quella stessa coppia (129 record RUN abbinati a una riga BMS entro 60 secondi), sette finestre uint32 nel record ottengono |r| ≥ 0,90 contro la tensione del pacco del BMS, e la vincitrice non è record[21:25]: la parola all'offset 30 ottiene 0,925 contro il suo 0,907, e sono di nuovo quattro byte diversi. Una correlazione non identifica un offset, e trattarla come se lo facesse è esattamente l'errore che ha messo una linea a 12 V in questa pagina come contachilometri.
Ciò che stabilisce record[21:25] è invece l'aritmetica: è un multiplo di 100 mV su 281 delle sue 281 letture diverse da zero, dove record[34:38] è su 2 di 302: la stessa grandezza a un centesimo della risoluzione. Ed è zero su tutti i 54 record CHRG qui mentre record[34:38] è popolato su 47 di essi. Preferisci record[34:38].
Dal 2026-09-07 il nostro decodificatore legge entrambi, condizionati a un bus attivo, insieme alla coppia del bus CC del controller, ai giri del motore e a velocità su strada e contachilometri nella coda 0x52 / 0x53. Poiché vanno tutti a zero con il bus, il file BMS resta la fonte elettrica migliore. La misura completa è nella specifica del formato.
Il vantaggio di Gen2
Telemetria completa in ogni riga. SOC, giri del motore, ampere del motore e tutte le temperature sono sempre disponibili, da un solo file, e lo è anche un vero contachilometri. (Non la modalità di guida: nessun file in formato Gen2 di questo corpus ne registra una; vedi la tabella dei campi qui sopra.) Alta densità di dati: da 6.713 a 9.229 righe negli otto dump MBB misurati per questa pagina. La libreria upstream zero-log-parser decodifica ogni record binario in campi tipizzati.
Il vantaggio di Gen3
A eventi, quindi il tempo di sosta costa poche righe. Le transizioni di stato esatte sono registrate invece che dedotte. Il lato BMS ha una risoluzione più alta di Gen2: minimo e massimo di cella in millivolt, una tensione a circuito aperto compensata per la resistenza interna, corrente in milliampere e una tensione del pacco misurata. Solo Gen3: limiti di potenza in watt, OCV di cella, il flag di controller attivo.
I byte del tipo di record, la mappa completa degli offset, la variante di firmware 538XX e le prove di calibrazione dietro ogni campo stanno nella Specifica del formato di log Gen3.
Macchina a stati e rilevamento delle sessioni
Gen2: basato sulle modalità
Ogni riga ha un'etichetta di modalità chiara. Il rilevamento delle sessioni è semplice:
Gen3: macchina a stati
Usa una macchina a stati con transizioni. Il rilevamento delle sessioni richiede il riconoscimento di schemi:
Questi otto sono i token che il parser riconosceva prima di 2026-08. Ciò che i file contengono è sbilanciato: dei 1.121 record di telemetria completi da 75 byte qui, 417 sono HIB e 408 PWSU, contro 144 RUN, 51 WAIT, 44 WAKE, 41 STOP e 7 CHRG. STRT non compare mai su una. Gli altri nove ne portano REV (cinque) o PARK (quattro), tutti sull'unica DSR/X di questo corpus. Fino ad 2026-08 il parser scartava la loro telemetria; da allora legge entrambi i token, e tutti e nove portano una tensione del pacco popolata (da 102,561 V a 102,630 V).
Segnali per il rilevamento delle sessioni Gen3
Poiché Gen3 non ha etichette «Riding» chiare, ricostruiamo le sessioni da più segnali:
Differenze dei log BMS
Gen2 BMS
Record binari nello stesso formato di quelli dell'MBB, che il parser rende con un'etichetta su ogni campo:
// Una vera riga BMS Gen2, decodificata
Discharge level 2017-06-14 09:06:22
SOC 92%, current 8A, amp_hours 2,
cell low 3.994V unloaded 4.013V high 4.0V,
balance 6mV, pack_temp 26C, bms_temp 35C,
pack_voltage 111.923V, mode Bike On
- Tensioni di cella (alta, bassa) in ogni riga
- SOC (stato di carica) sempre presente
- Temperature del pacco e della scheda
- Scarto di bilanciamento delle celle (mV)
- Modalità di ricarica/scarica/bilanciamento
Gen3 BMS decodificato
Record binari delimitati da 0xB2. Il record 0x4B da 52 byte è la fonte principale di telemetria per tutta la moto:
Due record gemelli portano gli stessi campi a un offset spostato: il 0x4C da 70 byte a +4 e il 0x4D da 78 byte a +8. Leggerli agli offset 0x4B finisce in un blocco di riempimento e il controllo di coerenza delle tensioni di cella scarta la riga, che è ciò che succedeva: smistare in base al byte del tipo ha portato il decodificatore da 1.625 righe di telemetria a 2.319 su questi sette file, +42,7%.
0xB2 + 1B length + 1B type (0x4B) + 4B Unix timestamp (LE) + 1B + 44B payload
Payload[13-14]: CvLow uint16 LE (mV)
Payload[15-16]: Cell OCV low uint16 LE (mV)
Payload[17-18]: CvHigh uint16 LE (mV)
Payload[19]: SOC uint8 (0-100%)
Payload[20-21]: Current int16 LE (mA, neg=charge)
Payload[38-40]: Pack voltage uint24 LE (mV, measured)
Payload[43]: Nessuna temperatura (letto come una fino al 2026-07-31 e ritirato)
- Tensioni di cella min/max (mV), profilo CC/CV visibile
- SOC 0-100% (0 = BMS in sospensione, valore reale quando è attivo)
- Corrente in mA: ricarica circa -15 A in CC, calo nella fase CV
- La tensione del pacco è misurata, non dedotta dalle celle
- Rilevamento delle sessioni di ricarica con calcolo della potenza
Il problema del buffer circolare
Gen3 usa un buffer circolare (buffer circolare) per memorizzare il log, con queste conseguenze per l'analisi dei dati:
Conservazione dei dati: una moto ferma lo riempie in circa 3 giorni
Una moto con buffer circolare (SR/F, SR/S, DSR/X; non la FXE, che scrive il formato Gen2) che resta ferma sovrascrive l'intero buffer circolare dell'MBB in circa 3 giorni.
- 1.Il buffer circolare contiene 2.238-2.535 record in 131.200 byte di flash (framing a catena di lunghezze, otto dump MBB a dimensione piena, 19.089 in totale)
- 2.Anche da ferma, la moto si risveglia ogni circa 1 ora per un ciclo STRT→PWSU→HIB: 444 dei 462 marcatori di ibernazione in quei file dichiarano una sospensione di 3.600 secondi
- 3.Ogni ciclo di risveglio scrive una mediana di 31 record (1.680 byte su disco, intervallo mediano di 3.691 secondi), sui 416 cicli tra marcatori qui il cui intervallo è davvero circa un'ora (una coppia di marcatori di ibernazione consecutivi a 3.000-4.200 secondi di distanza). Contando solo i marcatori che dichiarano 3.600 secondi si hanno 411 cicli e le stesse tre mediane. (Una revisione precedente di questa pagina diceva 426, che non si riproduce con nessuna delle due regole.)
- 4.That is circa 744 record/giorno: 131.200 ÷ 1.680 = 78 cicli orari, quindi il buffer si riavvolge in circa 3,25 giorni per numero di byte e in 3,0-3,4 giorni per numero di record, sovrascrivendo tutti i dati più vecchi
- 5.Non dare per scontato che il file BMS risalga altrettanto indietro. Nelle sei coppie della stessa moto e dello stesso export MBB/BMS qui la finestra BMS va da da 0,19× a 20,9× la finestra MBB (mediana 1,02×), quindi quale buffer si esaurisce per primo non è fisso. Scarica entrambi insieme. (Nel corpus ci sono sette coppie dello stesso giorno; le sei che danno questi rapporti sono quelle scaricate nella stessa sessione, che è il confronto che ha senso.)
Per catturare la storia dei giri, scarica i tuoi log entro 1-2 giorni dalla guida. Se aspetti di più, i dati dei giri verranno probabilmente sovrascritti dai cicli di ibernazione.
Tre giorni è la velocità con cui il buffer si rinnova mentre quella cadenza oraria è in corso, non l'arco che vedrai in ogni file. La cadenza non dura per sempre: diciotto di quei 462 marcatori dichiarano invece una sospensione di 31.536.000 secondi (un anno), e gli otto dump MBB misurati qui coprono da 3,1 a 336 giorni di tempo reale. Quindi un log Gen3 può risalire a quasi un anno e non contenere quasi nient'altro che cicli di risveglio.
Come funziona
Il log ha una capacità fissa (2.238-2.535 record nei dump qui). Quando è pieno, i nuovi record sovrascrivono i più vecchi. Questo significa che il file contiene record di periodi di tempo diversi, e sono non in ordine cronologico.
// Visualizzazione del buffer circolare (semplificata)
File position: [oldest ... wrap point ... newest]
Timestamps: [Jan 15 ... Dec 3 ... Jan 14]
^ write pointer wraps here
Conseguenze
- Le righe vanno ordinate per timestamp prima dell'analisi
- I vecchi dati di guida vengono sovrascritti dai cicli di ibernazione più recenti
- Una moto «rimessata» che continua a svegliarsi ogni ora riempie il buffer in circa 3 giorni, perdendo tutta la storia dei giri
- Nel record di telemetria comune 0x51 non c'è un contachilometri da interpolare attraverso il punto di riavvolgimento. Un MBB Gen3 nativo ne porta uno solo nei suoi record più rari 0x52 / 0x53, e solo nel layout più recente del firmware; altrimenti il vero contachilometri della moto ci arriva dal blocco di riepilogo, da una riga di guida Gen2 o dalla variante di firmware 538XX
- Alcuni timestamp sono corrotti. I framer Gen3 rifiutano ogni record il cui uint32 all'offset 3 cada fuori da 2019-01-01 (Unix 1546300800, il lancio della SR/F) fino a oggi + 365 giorni
Fonti dati: MBB contro BMS
Le parole a record[34:38] e record[38:42] contengono tensione del pacco e corrente della batteria mentre il pacco è attivo, e il nostro decodificatore le legge dal 2026-09-07, ma sono zero negli stati che riempiono la maggior parte del buffer di una moto ferma, e velocità su strada e contachilometri arrivano solo nei record più rari 0x52 / 0x53. In pratica il log del BMS (Battery Management System) è la fonte elettrica, ed è per questo che l'app chiede entrambi i file: carica solo l'MBB di una moto Gen3 e la maggior parte dei grafici elettrici resta scarsa o vuota, per quanto completo sembri l'elenco dei giri.
L'MBB fornisce:
- Stato (RUN, STOP, HIB, CHRG...)
- SOC% (valore del cruscotto)
- Temperature: ambiente, motore, inverter, cella alta e bassa
- Linea accessori a 12 V (microvolt)
- Eventi di testo e codici di guasto
- Tensione e corrente del pacco, coppia del bus, giri del motore (solo con il bus attivo)
- Velocità su strada, autonomia, contachilometri (solo 0x52 / 0x53)
Il BMS fornisce:
- Tensioni di cella (min/max)
- Corrente della batteria (mA)
- Pacco SOC%
- Stato di carico e modalità di report
- Nessuna temperatura (payload[43] ritirato)
Esempio reale: una SR/S «rimessata»
Un dump di una SR/S in questo corpus, scaricato il 31 dicembre 2025, delimita 2.416 record i cui timestamp risalgono a 336 giorni. Non contiene nemmeno un record RUN. Dei suoi 154 record di telemetria completi, 76 sono HIB e 76 PWSU, con un WAIT e uno STOP: quasi un anno di file, tutto della moto che si sveglia ogni ora per tornare a dormire. Qualsiasi giro fatto in quei 336 giorni è stato sovrascritto molto prima che il log venisse scaricato.
Ritirato. Questo riquadro diceva che la stessa moto mostrava «9 letture diverse del contachilometri, 12.635 – 13.153 km», proposte come istantanee da diverse posizioni del buffer circolare. Non erano chilometri. Il campo 5 di quel file assume 11 valori distinti da 12,635 V a 13,168 V: la linea accessori a 12 V, in microvolt, letta come se fossero metri. Che la batteria da 12 V di una moto ferma scivoli di mezzo volt è esattamente ciò che ti aspetteresti di vedere; che il contachilometri di una moto ferma si sposti di 518 km no, e avrebbe dovuto essere il segnale.
Rilevamento della ricarica
Gen2
Semplice e affidabile:
- La riga ha modalità = "Charging"
- Il SOC aumenta nel tempo
- Corrente di ricarica visibile nel BMS
- La sessione finisce quando il SOC smette di aumentare
Gen3
Richiede un rilevamento con più segnali:
- Stato = CHRG (esplicito)
- CHARGER LSS eventi (registrazione del nodo del caricatore)
- Eventi del contattore (Precharging from module)
- Aumento di tensione durante i periodi non RUN (ripiego)
Il segnale 1 è raro in pratica: solo 7 dei 1.121 record di telemetria completi qui sono nello stato CHRG. Per questo esistono gli altri tre segnali.
Stato della decodifica: le sette righe che contano
Il formato Gen3 non è documentato ufficialmente, e nulla in questa pagina viene da Zero Motorcycles. Sette voci portano la maggior parte delle conseguenze pratiche. I conteggi qui sotto sono misurati su otto dump MBB Gen3 nativi a dimensione piena di cinque moto (tre SR/F, una SR/S, una DSR/X) più un nono dump troncato di una sesta, e sette file BMS Gen3 delle stesse cinque, tutti decodificati con il parser in produzione per questa pagina.
| Area | Stato | Note |
|---|---|---|
| Tensione / corrente MBB | partial | Decodificato dal 2026-09-07, condizionato a un bus attivo; fino ad allora questa riga diceva «presente nel record, letto da nulla». uint32 LE mV a record[34:38] e int32 LE mA a record[38:42], diversi da zero su 144 record RUN su 144 e 0 su 417 HIB, 0 su 408 PWSU, 0 su 51 WAIT. Una serie di ricarica letta da essi mostra una fase di assorbimento CV da manuale. Ogni campione dinamico viene da moto della piattaforma SR/F, quindi non è confermato sul firmware dell'era DSR/X. Il file BMS ha la copertura continua |
| Velocità / giri / contachilometri MBB | partial | Decodificato dal 2026-09-07; fino ad allora questa riga diceva «mancante», sulla base di una misura del solo record 0x51. I giri del motore sono in ogni 0x51 a record[29:33], solo finché il bus è attivo. Velocità su strada e autonomia del cruscotto sono nella coda dei più rari record 0x52 / 0x53, e così il contachilometri, solo sul layout di firmware più recente, controllato come serie per file. Nessun 0x51 porta un contachilometri, e il campo che questa pagina pubblicava come tale è la linea a 12 V |
| Macchina a stati MBB | decoded | ASCII da 9 byte riempito con zeri a record[42:51]: RUN/STOP/HIB/STRT/PWSU/CHRG/WAIT/WAKE, più REV e PARK, accettati dal 2026-08. Àncora ogni altro offset: byte 42 su tutti i 1.356 record di tipo 0x51 qui |
| Temperature MBB | partial | Cinque parole uint32 di post-stato a [s+9]/[s+13]/[s+17]/[s+21]/[s+25]: ambiente, motore, inverter, cella alta, cella bassa. Fino al 2026-09-07 erano lette con un'etichetta di scarto (come metrica interna, pacco alto, pacco basso, ambiente e controller), e la lettura del motore era memorizzata come temperatura della batteria; un reparse corregge i report più vecchi. RUN popola le quattro parole di temperatura dopo l'ambiente in 144 record su 144, ma «zero a meno che sia sveglia» è una tendenza, non una regola: HIB riempie la coppia motore/inverter su 20 record su 417 (4,8%) e PWSU la coppia delle celle su 34 su 408 (8,3%) |
| Linea a 12 V dell'MBB | decoded | Campo 5 di post-stato a [s+29], uint32 LE microvolt, emesso come aux_12v_uv. Tutti i 1.121 record di telemetria completi cadono su un reticolo di 5.128 uV (un ADC a 12 bit su ~21 V), da 0,143 V a 13,440 V. È il campo che questa pagina pubblicava come contachilometri in metri |
| Tensione del pacco BMS | decoded | Misurata uint24 LE mV a payload[38:41]. 2.189 delle 2.319 righe emesse (94,4%, per file 92,1-96,5%) cadono dentro 28 x CvMin .. 28 x CvMax; la stima media delle celle x28 è solo il ripiego |
| Codice di stato BMS | partial | payload[24], e ancora opaco. 37 valori distinti su quelle 2.319 righe; da 0x00 a 0x23 ne copre 2.276, più 19 righe di 0xF0 e 24 di 0xFF, le sentinelle flash. 0x0B pende verso lo scarico (516 righe su 603) e 0x0C verso il carico (256 su 566), ma nessun enum sopravvive alla verifica: i quattro codici un tempo pubblicati come idle/active/unlock/precharge coprono solo il 58,6% delle righe, e uno 0x10 senza etichetta (69 righe su 111 sotto carico, 62,2%) sta sopra 0x0C nello stesso ordinamento per carico |
Le righe restanti sono nella Specifica del formato di log Gen3, che porta le prove di calibrazione di ognuna: ogni byte del tipo di record MBB e BMS, il layout dell'intestazione prima e dopo lo stato, il record del motore 0x54 da 29 byte, la tassonomia degli eventi ASCII, il record di salute 0x4D da 78 byte con il suo registro della capacità a carica completa, la variante FST Mono da 50 byte e la variante di firmware 538XX.
Archiviazione nel database e pipeline di parsing
Quando un file di log viene caricato, un worker in background lo analizza e memorizza le righe in PostgreSQL (con TimescaleDB per l'ottimizzazione delle serie temporali). La strategia di archiviazione cambia con la generazione. Le sessioni rilevate sono scritte in due tabelle con chiave VIN, unified_ride_sessions e unified_charging_sessions, ciascuna collegata ai suoi file di origine tramite una tabella molti-a-molti invece di una chiave esterna, perché una sessione può essere ricostruita da più file di log sovrapposti, che è esattamente ciò che produce un buffer circolare che si riavvolge.
Flusso di parsing Gen2
- Decodifica i record binari con lo zero-log-parser upstream, che restituisce campi tipizzati per ogni riga
- Associa il tipo di evento (Riding/Charging/ecc.) a bike_state
- Leggi ogni metrica da quei campi tipizzati
- Calcola la velocità dai giri, la potenza da V×I
- Memorizza con log_generation = 2
- Rileva le sessioni di guida e le sessioni di ricarica dagli schemi di eventi
Colonne dedicate:
pack_voltage_v, battery_amps, motor_rpm,
speed_kmh, odometer_km, motor_temp_c,
controller_temp_c, ambient_temp_c, soc,
power_kw, bike_state
Flusso di parsing Gen3
- Delimita i record 0xB2 e convalida il timestamp all'offset 3 prima di fidarti del record
- Ancora gli offset MBB sulla stringa di stato ASCII; leggi i payload BMS a offset fissi
- Estrai il valore della macchina a stati come bike_state
- Converti le unità (mV→V, mA→A, mm/h→km/h, decimi di km→km, W→kW)
- Analizza i record ASCII per limiti di potenza, guasti e transizioni di stato
- Memorizza con log_generation = 3
Colonne esclusive di Gen3:
bike_state, controller_active,
discharge_limit_kw, charge_limit_kw,
cell_voltage_ocv_min, is_under_load,
bms_state_code
Colonne condivise (come Gen2):
pack_voltage_v, battery_amps, soc,
power_kw (dal file BMS)
motor_temp_c, motor_rpm, torque_nm
(dall'MBB, con il bus attivo)
speed_kmh, odometer_km (dai
soli record 0x52 / 0x53 dell'MBB)
Tipi di riga Gen3 nel database
Le righe MBB Gen3 sono eterogenee: non ogni riga porta ogni campo, e i canali elettrici dell'MBB sono popolati solo mentre il bus ad alta tensione è attivo. I grafici che sembrano scarsi in un report Gen3 di solito mostrano questo, non un errore di parsing:
Telemetria MBB 0x51 (75 B)
bike_state, soc, cinque temperature, controller_active, aux_12v_uv nel blob dei campi grezzi e, con il bus attivo, tensione e corrente del pacco, la coppia del bus del controller e i giri del motore (decodificati dal 2026-09-07). Nessuna velocità e nessun contachilometri: stanno nei record più lunghi 0x52 / 0x53
MBB 0xFD ASCII (variabile)
discharge_limit_kw, charge_limit_kw (report di capacità del BMS), cambi di stato, guasti, interruttore chiave/arresto, cavalletto, eventi del contattore
Telemetria BMS 0x4B (52 B)
pack_voltage_v, battery_amps, power_kw, soc, min/max/OCV di cella, is_under_load, bms_state_code. Nessuna temperatura: payload[43] era letto come tale fino al 2026-07-31 ed è ritirato
Dove è andato il dettaglio a livello di byte
Questa pagina finiva con tre sezioni tecniche chiuse. Sono state rimosse invece di essere corrette, perché una seconda mappa dei byte contraddittoria sullo stesso dominio è peggio di nessuna. Delle 22 righe della loro tabella degli offset MBB, più della metà nominava il campo sbagliato, due puntavano oltre la fine di un record da 75 byte e una scambiava un byte del timestamp Unix (0x69, il byte alto di ogni timestamp tra fine ottobre 2025 e maggio 2026, che copre 14.207 dei 19.089 record delimitati qui) per un marcatore di tipo di record. La specifica completa record per record di Gen3 vive ora in /learn/gen3-log-format.
- Payload binario MBB Gen3. Regole di framing, i tipi di record 0x51 / 0x54 / 0xFD, il layout prima e dopo lo stato e cosa contiene ogni slot: leggi la specifica del record MBB.
- Binario BMS Gen3. Il record di telemetria 0x4B da 52 byte, il record di salute 0x4D da 78 byte e il suo registro della capacità a carica completa, il 0x4C da 70 byte e la variante FST Mono da 50 byte: leggi la specifica del record BMS.
- Rilevamento delle sessioni Gen3. Come giri e ricariche vengono ricostruiti dalle transizioni di stato, dagli eventi di confine ASCII e dai buchi di tempo una volta ordinati i record: leggi la sezione sul rilevamento delle sessioni.
Per quanto tempo un buffer circolare Gen3 conserva i tuoi giri prima di sovrascriverli, vedi Perché il tuo log Gen3 non mostra giri.
Fonti:
- zero-log-parser (Python library): the Gen2 JSON pipeline this app builds on (si apre in una nuova scheda)
- zero-log-parser: LOG_STRUCTURE.md, the community record-layout notes (si apre in una nuova scheda)
- zero-log-parser issue #16: Gen3 (SR/F) log support (si apre in una nuova scheda)
- ZeroManual: Interfacing (si apre in una nuova scheda)
- Zero Motorcycles: owner's manuals, with each model's specifications (Owners page) (si apre in una nuova scheda)
- NHTSA vPIC: VIN decoding, including the 10th-character model-year code (si apre in una nuova scheda)
Quanto di questo è noto. Nulla di tutto questo viene da Zero Motorcycles. Il formato Gen3 è ricavato per reverse engineering da file di log di produzione, e il quadro è disomogeneo. Il record BMS è in gran parte decodificato: minimo e massimo di cella, tensione a circuito aperto, SOC, corrente, tensione misurata del pacco, carico e modalità di report si leggono tutti e si controllano a vicenda (è stato letto anche un byte di temperatura, ritirato il 31 luglio 2026). Il record MBB ha richiesto più tempo. Il suo 0x51 da 75 byte dà uno stato, un byte di SOC, cinque temperature, una linea a 12 V e, solo con il bus attivo, la coppia tensione/corrente del pacco, la coppia del bus del controller e i giri del motore; i suoi record più rari 0x52 / 0x53 aggiungono la velocità su strada e, sui firmware più recenti, il contachilometri. Fino al 7 settembre 2026 questo paragrafo diceva che l'MBB non aveva contachilometri, velocità né giri, un'affermazione su un record formulata come un'affermazione sulla moto. Tra febbraio e luglio 2026 quattro campi di questa pagina sono risultati etichettati male, due erano inventati e uno, il «contachilometri», era sia sbagliato sia scritto nel database; quell'affermazione è stata ritirata e il decodificatore cambiato. I valori che li hanno sostituiti sono stati misurati su 1.121 record di telemetria MBB e 2.319 BMS di cinque moto (una sesta contribuisce con un dump troncato), attraverso il parser in produzione e non una reimplementazione. Se puoi smentirne una parte con i tuoi log, dillo: è così che è stato trovato ogni errore qui sopra. Ultima verifica: 30 luglio 2026 rispetto a backend/app/parser.py; le righe dei canali MBB sono state riviste il 3 ottobre 2026 per allinearle alle correzioni del decodificatore del 7 settembre 2026.