Vai al contenuto
zerologs
Torna all'indice delle guide
Riferimento di protocollo

Come una Zero parla via Bluetooth

Una Zero risponde a un piccolo insieme di comandi di quattro lettere via Bluetooth: chi è, ogni tensione di cella, cosa stanno facendo il motore e il cruscotto, e l'intero log, blocco per blocco. Questa pagina elenca ogni comando che conosciamo, cosa porta ogni risposta e in quale unità, e disegna risposte vere da 4 sessioni registrate con una FXS 2016. Ogni riga dice come lo sappiamo: misurato su quelle catture, preso dalla libreria open source ZeroBLE, oppure noto ma non ancora catturato.

Ultimo aggiornamento: 14 novembre 2026
~18 min di lettura7987 frame catturati · 4 sessioni · ogni CRC controllato

TL;DR

  • Le moto Gen2 parlano Bluetooth Classic, Serial Port Profile sul canale RFCOMM 1. Le moto Gen3 parlano Bluetooth LE attraverso un servizio seriale su BLE, 0xFEFB. Nel 2026 XB, XE e LS1 non hanno un'interfaccia nota.
  • Non c'è login. Una volta associato il telefono il link è cifrato e il primo frame può già chiedere i dati. Qualsiasi dispositivo associato potrebbe anche mandare i comandi che cambiano la moto. ZeroLogs manda letture da una allowlist fissa, e una scrittura, la ricarica programmata, sotto un controllo stretto.
  • Un frame Gen2 è F1 F2 F4 F8, un conteggio di parole di payload a 32 bit, un tag ASCII di quattro lettere, il payload, F8 F4 F2 F1 e un CRC-32. Una richiesta è di 20 byte; la risposta ripete il suo tag. Nelle nostre catture tutte le 3995 richieste e le 3992 risposte hanno frame e CRC corretti.
  • I dati dal vivo arrivano da cinque letture a turno (MbbR, PwPk, DSt1, DSt2, DSt3), una richiesta alla volta, circa 85 ms per andata e ritorno, così ogni valore si aggiorna ogni ~0,5 s.
  • La velocità arriva in mph interi e il contachilometri in miglia intere, mentre i parziali e l'autonomia arrivano in centesimi di chilometro. Entrambe le unità sono verificate: la velocità integrata come mph riproduce il parziale, e il contachilometri coincide con il log della moto, al chilometro.
  • Uno scarico del log è un CmCh (indirizzo di lettura 0) e poi MbbD, oppure BmsD per il pacco, ripetuto: un flag di 4 byte e 256 byte per risposta, pause di ~11 s, e un flag di fine. Sulla FXS, 1048 risposte in 334 s hanno dato l'intero log di 262.144 byte.
  • Alcuni campi non sono definiti: le tre parole di consumo di DSt3, due parole di BtSt e il segno delle correnti. Le tabelle lo dicono per ciascuna.
In questa pagina

Quale moto parla su quale radio

Zero ha messo in strada due protocolli Bluetooth, uno per generazione di elettronica, e hanno meno in comune di quanto faccia pensare il marcatore che condividono. Una moto Gen2 (la FX e la FXS, e le S, SR, DS e DSR fino al 2023) è un dispositivo seriale Bluetooth Classic. Una moto Gen3 (la piattaforma Cypher III: SR/F e SR/S dal 2020, la DSR/X dal 2023, e S, SR, DS e DSR dal 2024) è una periferica Bluetooth Low Energy che fa passare un flusso seriale attraverso il GATT. «Gen2» e «Gen3» sono le generazioni di elettronica e di log usate in queste pagine Learn; i manuali di Zero archiviano FX e FXS come generazione di prodotto 1.

Per chi guida, la differenza pratica è il telefono. Android apre un link seriale Classic verso qualsiasi dispositivo associato; iOS non lascia fare lo stesso a un'app, a meno che l'accessorio non sia nel programma MFi di Apple, quindi un'app iPhone di terze parti raggiunge una Gen3 via BLE ma non una Gen2.

Tutto ciò che è misurato su questa pagina viene da una moto Gen2, una FXS 2016 la cui scheda principale riporta il codice 40-08290C. Il lato Gen3 poggia su ZeroBLE, una libreria con licenza MIT; l'app ZeroNavBridge del suo autore, costruita sopra, risulta funzionante su DSR/X (2023), SR/F (2023), SR/S (2021–2023) e sulla S Gen3. Non abbiamo ancora catturato una Gen3 noi stessi, e ogni riga Gen3 lo dice.

Quale moto parla con quale radioGen2FX, FXS; S, SR, DS, DSRup to model year 2023Bluetooth ClassicSerial Port Profile (SPP)RFCOMM channel 1UUID 0x1101Android only (no SPP on iOSwithout Apple’s MFi programme)Measured on a 2016 FXSGen3SR/F, SR/S (2020 on), DSR/X (2023on), S, SR, DS, DSR (2024 on)Bluetooth Low EnergyGATT service 0xFEFB(“Terminal I/O” serial)credit-based flow controlasks for a 512-byte MTUone paired phone per bikeFrom open source, not yet tested by us2026 XB, XE, LS1the 2026 lightmotorcyclesNone knowntheir owner’s manualsnever mention Bluetooth,a phone or an appFrom the owner’s manuals
Due radio, due protocolli che condividono un magic del frame e un CRC ma poco altro. Tutto ciò che è misurato in questa pagina viene da una sola moto Gen2; la colonna Gen3 poggia sulla libreria ZeroBLE con licenza MIT, e l'app ZeroNavBridge del suo autore, costruita su di essa, risulta funzionante su DSR/X, SR/F, SR/S e S Gen3. Il limite di un solo telefono è citato da ogni manuale d'uso Gen3 (2020–2026). I modelli leggeri del 2026 sono elencati perché né il manuale d'uso né quello di assistenza parlano di Bluetooth.
I due link a confronto
Gen2Gen3
RadioBluetooth Classic (BR/EDR)Bluetooth Low Energy
ProfiloSerial Port Profile su RFCOMMServizio GATT 0xFEFB, un profilo seriale su BLE
DoveCanale server RFCOMM 1, UUID SPP 00001101-0000-1000-8000-00805f9b34fbServizio 0000FEFB-0000-1000-8000-00805F9B34FB
SicurezzaUn bond a livello di sistema; il link è cifrato con la sua chiaveAssociazione come la descrive il manuale della moto; un telefono per moto
Login nel protocolloNessunoNessuno noto
Nomi dei messaggiQuattro lettere ASCII (PrVr, MbbR …)Numeri (1, 3, 22 …) più un contatore
TelefoniAndroid (iOS richiede MFi)Android e iOS
StatoMisuratoZeroBLE (open source)

Connessione: il bond, il canale, e niente login

Su Gen2 la moto si associa una volta nelle impostazioni Bluetooth del telefono. Quel bond salva una chiave di link; ogni connessione successiva si autentica con quella e accende la cifratura prima che passi qualsiasi dato. Il link seriale è il canale server RFCOMM 1. Nelle nostre catture il telefono apre il canale 1 direttamente, senza una ricerca dei servizi prima, e poi il primo frame sul link è già una richiesta di dati. Nel protocollo nulla chiede chi sta chiamando.

Tratta il link come se fosse di una persona sola: chiudi un'app prima di collegarti con un'altra. Non abbiamo provato cosa fa una Gen2 con una seconda connessione.

Dopo la connessione, la sessione nelle nostre catture chiede la versione del protocollo, il pacco, lo stato della batteria, una lettura del cruscotto e l'identità della moto, poi si assesta nel giro a rotazione descritto più sotto. In entrambi i giri e nello scarico, ogni risposta è arrivata prima che uscisse la richiesta successiva.

Il primo mezzo secondo dopo il collegamentoFXS 2016, Bluetooth Classic SPP. Prima del frame 1: l'associazione del sistema (chiave di collegamento) e il canale RFCOMM 1, nessun loginTelefonoMotoms0 ms: request PrVr0PrVr protocol version90 ms: reply PrVr, 4 bytes of payload90PrVr 4 B95 ms: request PwPk95PwPk power pack: cells, SoC154 ms: reply PwPk, 100 bytes of payload154PwPk 100 B157 ms: request BtSt157BtSt battery status, odometer249 ms: reply BtSt, 44 bytes of payload249BtSt 44 B253 ms: request DSt3253DSt3 dash: minutes to full383 ms: reply DSt3, 12 bytes of payload383DSt3 12 B393 ms: request Gbki393Gbki bike info: VIN, model506 ms: reply Gbki, 104 bytes of payload506Gbki 104 B514 ms: request PrVr514PrVr protocol version564 ms: reply PrVr, 4 bytes of payload564PrVr 4 B
I primi 12 frame di una sessione reale, tempi in millisecondi dal primo. Nessun frame porta una password: una volta che il sistema operativo ha un'associazione (una chiave di collegamento memorizzata) il collegamento è cifrato, e già il primissimo frame è una richiesta di dati. Ogni richiesta è di 20 byte senza payload; ogni risposta ripete il tag della richiesta. Sia nei giri sia nel download il telefono ha atteso ogni risposta prima di mandare la richiesta successiva, mai più di una in volo.

Senza login non c'è nemmeno un controllo dei permessi

Il protocollo ha comandi che cambiano i limiti delle modalità di guida, l'orologio, la ricarica e il firmware (vedi «Comandi che cambiano la moto» più sotto), e la moto non chiede chi li manda: può farlo qualsiasi dispositivo che abbia il bond. Per questo l'app ZeroLogs non manda nulla che non sia in una breve allowlist di letture, a parte una scrittura controllata stretta, e rifiuta tutto il resto nel codice. Sul lato sicurezza, l'avviso CISA ICSA-26-111-06 (CVE-2026-1354) descrive l'associazione Bluetooth forzata sul firmware Zero 44 e precedenti; l'aggiornamento di giugno 2026 dice che un firmware corretto è disponibile tramite la piattaforma over-the-air (FOTA) di Zero.

Il frame

Ogni messaggio Gen2, in entrambe le direzioni, ha la stessa forma: un marcatore di inizio da 4 byte F1 F2 F4 F8; N, la lunghezza del payload contata in parole a 32 bit, come u32 little-endian; un tag ASCII di quattro caratteri; 4 × N byte di payload; il marcatore di fine F8 F4 F2 F1; e un CRC-32 di tutto, dal marcatore di inizio a quello di fine, memorizzato little-endian. Il CRC è quello ordinario di zlib / IEEE 802.3, quindi lo calcola qualsiasi libreria standard.

Le richieste non portano payload (N = 0), e così ogni richiesta è esattamente di 20 byte; l'unica eccezione è CmCh, più sotto. La risposta ripete il tag della richiesta. Anche i numeri multibyte dentro un payload sono little-endian.

Nelle nostre catture ognuna delle 3995 richieste e delle 3992 risposte ha lunghezza 12 + 4N e supera il suo CRC. Una risposta può arrivare spezzata su più pacchetti Bluetooth, quindi ricomponi il flusso (su Android lo fa il socket) prima di cercare i marcatori.

Gen3 tiene il marcatore di inizio e il CRC-32 ma cambia il resto: un conteggio di blocchi u32, un tipo di messaggio u16 e un contatore u16 sostituiscono N e il tag, il payload è riempito a blocchi interi di 4 byte, e il CRC sta prima del marcatore di fine invece che dopo. Il contatore è sempre 0 e nulla lo controlla. C'è una richiesta in volo alla volta e il frame successivo le risponde; 10 secondi di silenzio, o un tipo 2 (reinvio) dalla moto, chiudono lo scambio, e il client decide se richiedere. La richiesta di versione del protocollo Gen3 è f1 f2 f4 f8 00 00 00 00 01 00 00 00 bd 90 67 f9 f8 f4 f2 f1.

Un frame, due generazioniGen2start4 bytesf1 f2 f4 f8Nu32 LE, words00 00 00 00tag4 ASCII50 72 56 72payload4 × N bytes(none: N = 0)end4 bytesf8 f4 f2 f1CRC-32u32 LE9d 88 03 7brichiesta PrVr = 20 byte. Risposta: N = 1, payload 00 17 00 00, CRC c0 10 3d edil CRC-32 copre da inizio a fine, inclusiGen3startF1 F2 F4 F8blocksu32typeu16counteru16payload4 × blocks, paddedCRC-32u32endF8 F4 F2 F1il CRC-32 copre da inizio a payload, e viene PRIMA del marcatore di fineUn numero sostituisce il tag ASCII e si aggiunge un contatore. Formato da ZeroBLE (MIT); non ancora catturato da noi.
I byte Gen2 sono la vera richiesta e risposta PrVr delle catture; il costruttore di frame della pagina riproduce ogni richiesta al byte, CRC compreso. Il CRC è il normale CRC-32 zlib / IEEE, memorizzato little-endian. La riga Gen3 è il formato che invia la libreria open source ZeroBLE; non abbiamo ancora una cattura Gen3 nostra.
Messaggi che la moto può mandare da sola
TagSignificatoCosa fareStato
ReSdLa moto non ha preso l'ultima richiestaManda di nuovo la stessa richiestaNoto, non ancora catturato
Esempio svolto: lo scambio della versione di protocollo, byte per byte
request  f1 f2 f4 f8  00 00 00 00  50 72 56 72  f8 f4 f2 f1  9d 88 03 7b
         start        N = 0        "PrVr"       end          CRC-32, LE

reply    f1 f2 f4 f8  01 00 00 00  50 72 56 72  00 17 00 00  f8 f4 f2 f1  c0 10 3d ed
         start        N = 1        "PrVr"       payload      end          CRC-32, LE

Il payload della risposta, 00 17 00 00, è la versione di protocollo che riporta la FXS 2016. Entrambi i frame sono esattamente i byte della cattura, e il costruttore di frame di questa pagina riproduce ogni richiesta delle catture, CRC compreso.

Ogni comando Gen2, e cosa torna indietro

Queste sono le letture. Ognuna è una richiesta di 20 byte; la dimensione della risposta è quella che manda la FXS 2016. Gli offset nelle sezioni sotto contano dal primo byte di payload, dopo l'header di 12 byte (marcatore di inizio, N, tag).

Le letture Gen2
TagChiedePayload della rispostaStato
PrVrLa versione del protocollo1 parolaMisurato
GbkiChi è la moto: VIN, marca, modello, codice della scheda principale26 parole (104 B)Misurato
PwPkPacco: tensione del pacco, ogni cella, SoC, Ah, sonde di temperatura, corrente25 parole (100 B) su un pacco da 28 celleMisurato
BtStStato batteria: tensione, Ah, SoC, temperature del pacco, bit di stato, contachilometri11 parole (44 B)Misurato
MbbRScheda principale: coppia, rpm, temperatura di motore e centralina, correnti, velocità, interruttori7 parole (28 B)Misurato
DSt1Cruscotto: parziale A, rpm motore, codice del cruscotto2 paroleMisurato
DSt2Cruscotto: parziale B, stima di autonomia, temperatura motore2 paroleMisurato
DSt3Cruscotto: minuti alla fine della ricarica, tre parole di consumo3 paroleMisurato; scale non definite
EcusOgni centralina: indice, anno modello, codici e revisioni hardware e firmwareun conteggio, poi 30 B per unitàNoto, non ancora catturato
ErrsI codici guasto attiviun conteggio, poi un u16 per codiceNoto, non ancora catturato
MbbDIl log della scheda principale, un blocco per richiesta65 parole: flag di 4 byte + 256 BMisurato
BmsDIl log della batteria, allo stesso modo65 paroleRisposta sulla FXS 2016
CmChIl canale comandi; uno scarico ci imposta l'indirizzo di lettura a 011 parole, in ecoMisurato (solo indirizzo di lettura)

Una moto che non gestisce una lettura può semplicemente non rispondere; prendi il silenzio dopo qualche secondo come «non gestita», invece di riprovare all'infinito.

PrVr e Gbki: chi c'è in linea

PrVr risponde con una parola, 00 17 00 00 su questa moto. Gbki risponde con 104 byte di ASCII quasi tutto terminato da NUL. Gli offset sotto sono misurati sull'unica moto catturata; leggi le stringhe fino al primo NUL, invece di fidarti di lunghezze fisse.

Gbki, come risponde la FXS 2016
Dal byteCampoEsempio
0VIN, 17 caratteri ASCII + NUL[VIN] (oscurato qui)
18MarcaZero Motorcycles
38ModelloFXS
70Codice della scheda principale40-08290C
96u32, significato non noto41

Stato: Misurato, una moto. Dove inizia ogni stringa è misurato; quanto può essere lungo ogni campo non si sa.

PwPk: ogni cella, due volte al secondo

PwPk è la lettura dal vivo più ricca. La lista delle celle non ha un campo lunghezza: le tensioni di cella, come u16 millivolt, corrono fino al primo valore sotto 128, e quel valore è lo stato di carica. Questo pacco da 28 celle ha letto da 3,673 V a 3,764 V alla connessione, uno scarto di 91 mV.

Dopo lo stato di carica vengono la capacità del pacco e la carica rimanente in ampere-ora, poi tredici posti di temperatura in °C, dove −100 significa «nessun sensore montato». Su questa moto i posti 0–3 e 8–9 seguono la temperatura del pacco che la scheda principale registra negli stessi istanti, i posti 4–7 sono assenti, e i posti 10–12 stanno con l'elettronica: il posto 10 segue la temperatura motore di MbbR (uguale in 541 su 566, e mai a più di 1 °C) e il posto 12 la temperatura della sua centralina (545 su 566, e mai a più di 1 °C), accoppiando ogni risposta con la lettura MbbR di meno di un secondo prima. La corrente del pacco sta 8 byte prima della fine; la convenzione di segno non è definita, e gli ultimi 6 byte non sono decodificati.

Ogni cella, due volte al secondoPwPk on the 2016 FXS at connect: pack 105,386 V, SoC 60 %, spread 91 mV3,65 V3,70 V3,75 V3,80 Vcell 1: 3,759 V1cell 2: 3,706 Vcell 3: 3,695 Vcell 4: 3,673 V3673cell 5: 3,694 V5cell 6: 3,688 Vcell 7: 3,687 Vcell 8: 3,689 Vcell 9: 3,695 V9cell 10: 3,703 Vcell 11: 3,689 Vcell 12: 3,695 Vcell 13: 3,707 V13cell 14: 3,718 Vcell 15: 3,706 Vcell 16: 3,698 Vcell 17: 3,713 V17cell 18: 3,719 Vcell 19: 3,732 Vcell 20: 3,724 Vcell 21: 3,737 V21cell 22: 3,737 Vcell 23: 3,752 Vcell 24: 3,754 Vcell 25: 3,760 V25cell 26: 3,764 V3764cell 27: 3,763 Vcell 28: 3,759 V28numero di cella, nell'ordine in cui la risposta le elenca
Una risposta PwPk decodificata: le 28 celle in serie del pacco come le riporta la moto, in millivolt. L'elenco non ha un campo di lunghezza: continua fino al primo valore sotto 128, che è lo stato di carica (60 %). L'asse y parte da 3,65 V perché una dispersione di 91 mV sia visibile; ogni punto è una lettura, non una barra di grandezza.
PwPk su un pacco da 28 celle (gli offset si spostano col numero di celle)
ByteCampoUnitàEsempio alla connessione
0–3Tensione del paccou32, mV105,386 V
4–5928 tensioni di cellau16 ciascuno, mV, tutti ≥ 1283673–3764 mV
60–61Stato di caricau16, %60 %
62–63Capacitàu16, Ah52 Ah
64–65Residuou16, Ah32 Ah
66–9113 posti di temperaturas16 ciascuno, °C; −100 = nessuno34 33 34 34 — — — — 34 33 42 46 35
92–93Corrente del paccos16, A; segno non definito-3 A
94–99Non decodificatoed ff ae 00 00 00

Stato: Misurato. Lo stato di carica qui (60 %) e quello di BtSt (62 %) sono due letture diverse e non devono per forza coincidere.

BtSt: la batteria, e il contachilometri in miglia

BtSt ripete la tensione del pacco e gli ampere-ora e aggiunge due cose che a PwPk mancano: una parola di bit di stato e il contachilometri, in miglia intere: 20.776 mi (33.436 km) al primo giro e 20.818 mi (33.503 km) al secondo. Il log che la stessa moto ha scritto, letto dal parser di questo sito, mostra gli stessi due valori di contachilometri in chilometri in quei due giri.

BtSt
ByteCampoUnitàEsempio alla connessione
0–3Tensione del paccou32, mV105,341 V
4–5Capacitàu16, Ah52 Ah
6–7Residuou16, Ah32 Ah
8Stato di caricau8, %62 %
10–25Temperature del pacco8 × s16, °C; −100 = nessuno34 33 34 34 — — — —
28–31Bit di statou32, vedi sottobike on
32–35Contachilometriu32, miglia intere20.776 mi
36–39Non definitou3228.472 in marcia, 0 in sosta
40–43Un contatore lento, unità non definitau32135 → 138 su 42 mi

Stato: Misurato.

Bit di stato di BtSt (byte 28–31 come u32)
BitSignificatoVisto
0x10000000Caricatore 1 collegatosì, in 1 risposta
0x08000000Caricatore 2 collegato
0x04000000Moto accesasì, in tutte le 10 risposte
0x02000000Pacco caldo
0x01000000Pacco in temperatura critica
0x00800000Pacco freddo
0x00400000Carica bassa
0x00200000Carica critica
0x00100000Celle sbilanciate (il giudizio della batteria stessa)

«Moto accesa» e «Caricatore 1 collegato»: misurato; gli altri nomi si conoscono ma non li abbiamo ancora visti attivi.

MbbR: motore, velocità e interruttori

MbbR è la lettura dal vivo della scheda principale, e la sua velocità è un numero intero di miglia orarie. Il controllo: integrala su ogni giro e leggila come mph, e ottieni 4,71 km e 1,90 km, contro 4,80 km e 2,00 km sul parziale del cruscotto; letta come km/h darebbe solo 2,93 e 1,18 km. Il motore gira a un ritmo costante di 68,3 rpm per mph (mediana, entrambi i giri). Nel giro disegnato sotto la lettura ha toccato 38 mph e 2601 rpm.

I byte 20–27 sono quattro percentuali rimaste uguali in ogni risposta, in marcia e in sosta. Si conoscono come i limiti della modalità Eco (velocità massima, coppia, rigenerazione in rilascio, rigenerazione in frenata), non quelli della modalità selezionata: la modalità attiva non è in nessuna lettura Gen2 che conosciamo. I valori sono misurati; il nome no.

MbbR
ByteCampoUnitàIn marciaIn sosta
0–1Coppia motores16, N·m-30
2–3Velocità motores16, rpm8380
4–5Temperatura motores16, °C4344
6–7Temperatura centralinas16, °C3534
8–9Corrente batterias16, A; segno non definito00
10–11Corrente motores16, A; segno non definito-150
12–15Velocitàu32, mph interi120
16–19Bit di statou32, vedi sottoarmedkickstand down, brake
20–27Limiti della modalità Eco4 × u16, %85 / 20 / 0 / 10085 / 20 / 0 / 100

Stato: Misurato.

Bit di stato di MbbR (byte 16–19 come u32)
BitSignificatoVisto
0x10000000Cavalletto giùsì, in sosta
0x08000000Kill switch spento
0x04000000Armata (pronta a partire)sì, in marcia
0x02000000Avviso temperatura
0x01000000Frenosì
0x00200000In ricarica

DSt1, DSt2, DSt3: cosa mostra il cruscotto

Le tre letture DSt sono corte e tornano con i numeri del cruscotto. I parziali e la stima di autonomia sono in centesimi di chilometro, quindi il parziale avanza a passi di 10 (lo 0,1 km del cruscotto). Il codice del cruscotto è un numero semplice: ha letto 0 in marcia e 45 in sosta, e cosa significhi ogni valore non è pubblicato, quindi mostralo come numero, mai come allarme.

La prima parola di DSt3 è una cifra di minuti alla fine della ricarica: 185 in una sessione breve con il bit «Caricatore 1 collegato» di BtSt attivo. Per il resto è 0 quasi sempre, ma in 38 delle 564 risposte durante i due giri ha letto da 75 a 148, per pochi secondi alla volta, intorno ai 20 mph con il bit del freno attivo, forse in rigenerazione; non è definito. Le altre tre parole sembrano cifre di consumo, ma con la scala «Wh/km × 100» che si propone da sola leggono 19,4 e 2,31 Wh/km, cosa che nessuna Zero fa. Tienile grezze finché un giro non le sistema.

DSt1, DSt2 e DSt3
LetturaByteCampoUnitàAlla connessione
DSt10–3Parziale Au32, km × 10038,60 km
DSt14–5Velocità motores16, rpm0
DSt16–7Codice cruscottou160 (45 in sosta)
DSt20–3Parziale Bu32, km × 1001374,10 km
DSt24–5Stima di autonomiau16, km × 100119,06 km
DSt26–7Temperatura motores16, °C44 °C
DSt30–1Minuti alla fine della ricaricau160 (185 sul caricatore)
DSt34–7Consumo, istantaneo?u32, scala non definita0
DSt38–9Consumo, medio?u16, scala non definita1940
DSt310–11Consumo, di vita?u16, scala non definita231

Stato: Misurato. La temperatura motore di DSt2 coincide con quella di MbbR in 519 su 558, e mai a più di 1 °C, accoppiando ogni risposta con la lettura MbbR di meno di un secondo prima.

Ecus ed Errs: firmware e guasti

Altre due letture si conoscono ma non sono ancora nelle nostre catture. Ecus elenca le centraline: un conteggio u32, poi un record di 30 byte per unità. Errs elenca i codici guasto attivi: un conteggio u32, poi un u16 per codice, con zero codici come riempimento. Non ogni Gen2 risponde a Errs.

Un record Ecus (30 byte)
ByteCampo
0Indice unità: 6 scheda principale, 8 batteria, 9 una seconda batteria
2–3Anno modello, u16 (la scheda principale lo manda × 10)
4–15Codice hardware, ASCII
16Revisione hardware
17–28Codice firmware, ASCII (vuoto = salta il record)
29Revisione firmware

Stato: Noto, non ancora catturato.

Una sessione dal vivo, disegnata

Una volta connessa, la sessione interroga cinque letture in ordine fisso (MbbR, PwPk, DSt1, DSt2, DSt3), con una richiesta in volo alla volta. L'andata e ritorno mediana è 85 ms, quindi ogni lettura torna circa ogni 0,5 s. PrVr, Gbki e BtSt si chiedono solo nel primo secondo circa dopo la connessione.

La seconda figura è 8 minuti di un giro, ogni risposta MbbR e DSt2 decodificata agli offset sopra. Nulla è lisciato.

Come appare una connessione dal vivoRichiesta → risposta rigorosa, cinque letture a rotazioneTelefonoMotoDSt2: request at 0 ms, reply at 103 ms (103 ms)DSt2DSt3: request at 109 ms, reply at 203 ms (94 ms)DSt3MbbR: request at 214 ms, reply at 301 ms (87 ms)MbbRPwPk: request at 312 ms, reply at 406 ms (94 ms)PwPkDSt1: request at 420 ms, reply at 514 ms (94 ms)DSt1DSt2: request at 523 ms, reply at 611 ms (88 ms)DSt2DSt3: request at 622 ms, reply at 710 ms (88 ms)DSt3MbbR: request at 724 ms, reply at 773 ms (49 ms)MbbRPwPk: request at 779 ms, reply at 879 ms (100 ms)PwPkDSt1: request at 884 ms, reply at 1001 ms (117 ms)DSt1DSt2: request at 1012 ms, reply at 1088 ms (76 ms)DSt2DSt3: request at 1098 ms, reply at 1191 ms (93 ms)DSt3MbbR: request at 1202 ms, reply at 1283 ms (81 ms)MbbRPwPk: request at 1290 ms, reply at 1360 ms (70 ms)PwPkDSt1: request at 1373 ms, reply at 1442 ms (69 ms)DSt1DSt2: request at 1453 ms, reply at 1499 ms (46 ms)DSt2DSt3: request at 1509 ms, reply at 1594 ms (85 ms)DSt3MbbR: request at 1606 ms, reply at 1672 ms (66 ms)MbbRPwPk: request at 1686 ms, reply at 1794 ms (108 ms)PwPkDSt1: request at 1805 ms, reply at 1925 ms (120 ms)DSt10 ms500 ms1000 ms1500 ms2000 msandata e ritorno mediano 85 ms · ogni lettura ogni ~0,5 s
Due secondi di una sessione dal vivo, disegnati dalla cattura: ogni linea inclinata è una richiesta e la sua risposta. Cinque letture girano in ordine fisso, una alla volta in volo. Su 2857 risposte il tempo di andata e ritorno mediano è 85 ms (90° percentile 106 ms), ed è questo a fissare la frequenza di aggiornamento: ogni lettura torna circa ogni 0,5 s, grosso modo due volte al secondo.
Otto minuti di guida, come li riporta la motoUn pannello per grandezza, asse del tempo condiviso (minuti dal collegamento)Velocità mph, as sent (MbbR)0204038 mph at 2:1538 mph ≈ 61 km/hMotore rpm (MbbR)015003000Temperature °C (MbbR)304560motorcontrollerStima di autonomia del cruscotto km (DSt2)8010012084.98 km0:001:002:003:004:005:006:007:008:009:00
Ogni risposta MbbR e DSt2 di una sessione di 8:13 sulla FXS 2016, decodificata agli offset delle tabelle qui sopra e disegnata com'è stata inviata: la velocità viaggia davvero in mph intere, qualunque cosa mostri il cruscotto. Ogni punto è una risposta; il polling è andato a raffiche, e la linea tenue unisce le letture solo nelle pause tra l'una e l'altra. La stima di autonomia cala di 34,1 km mentre il parziale B avanza di 4,8 km. È l'aritmetica del cruscotto, non nostra.

Come funziona lo scarico di un log

Lo stesso link porta il log della moto, il file che un computer leggerebbe altrimenti sulla porta diagnostica. Su Gen2 arriva in blocchi da 256 byte, e la richiesta non ha un numero di blocco: la moto tiene il suo puntatore di lettura e serve il blocco successivo ogni volta che glielo chiedi.

  1. 1Ferma il polling dal vivo, così in volo restano solo i frame dello scarico.
  2. 2Manda CmCh con l'indirizzo di lettura a 0. Il payload è di 11 parole: 04 00 00 00 e poi zeri. La moto lo rimanda.
  3. 3Manda MbbD (N = 0). La risposta è un flag di 4 byte e 256 byte di log.
  4. 4Il flag 00 00 00 c0 è un blocco di dati. Se i suoi 256 byte sono identici al blocco che hai appena tenuto, è un reinvio: scartalo. Altrimenti accodalo.
  5. 5Ripeti MbbD. Quando la moto si ferma, aspetta la risposta. Nella cattura ognuna delle 1048 richieste ha avuto esattamente una risposta, con mai più di una richiesta in volo; le 17 lente sono arrivate dopo circa 11 s, e ognuna era semplicemente il blocco successivo.
  6. 6Il flag 00 00 00 e0 è la fine del file: fermati lì. Chiedere di nuovo riporta solo il flag di fine; nella cattura la lettura è ripartita dal primo blocco solo dopo che il client ha mandato CmCh una seconda volta.
  7. 7Manda di nuovo CmCh e riprendi il polling. Se la moto manda ReSd, ripeti la tua ultima richiesta.
Il ciclo di downloadGen2 · MbbD / BmsDGen3 · blocchi in ordine1. ferma il pollingone request in flight, always2. CmCh: indirizzo di lettura = 0payload 04 00 00 00 00 … (11 words)3. MbbD (N = 0)answer: 4-byte flag + 256 Bflag?c0 · datistessi byte del bloccojust kept? drop it : append itMbbD successivoe0 · fine file4. fermati: il file è completo1024 × 256 B = 262.144 B here5. di nuovo CmCh, riprendi il pollingReSd dalla moto:rimanda l'ultima richiestaLOG_INIT (24)per file: id, bytes, block countLOG_BLOCK (25)file → its next 128 B, in orderLOG_DONE (26)the bike answers LOG_DONE or ACKper ogni file: blocchi da 0 a conteggio − 1,prima la scheda principale, poi la batteria.Chiedi esattamente conteggio blocchi: unoin più restituisce 128 B che non sono log.131.200 B per scheda = 1.025 × 128 B
Gen2 (a sinistra) è misurato: il comando di indirizzo, le 1048 risposte MbbD e il flag di fine sono tutti nella cattura, e la richiesta non porta un numero di blocco, perché la moto tiene un proprio puntatore di lettura. Nella cattura il client ha semplicemente atteso ogni stallo, e la risposta dopo era il blocco dopo. BmsD esegue lo stesso ciclo per il log della batteria. Gen3 (a destra) viene dai log tecnici di ZeroLogs di una SR/F, non da una cattura Bluetooth: la richiesta nomina un blocco, e la moto serve comunque il successivo in ordine.
Scaricare un log da 256 KiB, blocco per bloccoMbbD on a 2016 FXS: 1048 answers in 334 s, 17 stalls of ~11 sstall: 11 s with no answer, from 1.2 sstall: 11 s with no answer, from 16.2 sstall: 11.02 s with no answer, from 47.1 sstall: 10.99 s with no answer, from 62.2 sstall: 11.1 s with no answer, from 108.4 sstall: 11.12 s with no answer, from 119.5 sstall: 11.13 s with no answer, from 138.5 sstall: 11.12 s with no answer, from 149.6 sstall: 11.12 s with no answer, from 177.6 sstall: 11.16 s with no answer, from 188.7 sstall: 11.11 s with no answer, from 225.5 sstall: 11.12 s with no answer, from 236.6 sstall: 11.01 s with no answer, from 255.7 sstall: 11 s with no answer, from 267.8 sstall: 10.97 s with no answer, from 295.9 sstall: 11.1 s with no answer, from 309.8 sstall: 11.16 s with no answer, from 320.9 s02565127681024flag di fine file a 308.2 s1048 risposte1024 tenutistallo0:001:002:003:004:005:00minuti dal primo blocco · y: blocchi
L'intero download della scheda principale, ogni risposta disegnata. Gli 17 gradini piatti sono la moto che si ferma per 10.97-11.16 s; non si perde nulla se il client aspetta semplicemente e tiene ogni blocco nell'ordine in cui arriva. A 308.2 s la moto manda il flag di fine file, e lo rimanda a ogni richiesta (6× di fila) finché il client non riporta a zero l'indirizzo di lettura con CmCh; dopo, il log riparte dal primo blocco. Nessuna delle 23 risposte dal flag di fine in poi appartiene al file. Risultato: 1024 × 256 B = 262.144 B, che il parser del progetto legge senza blocchi duplicati e senza salti all'indietro nel tempo.
Lo scarico sulla FXS 2016, misurato
Valore
Risposte ricevute1048
Blocchi tenuti1024 × 256 B = 262.144 B
Durata334,3 s
Intervallo mediano tra le risposte0,144 s
Pause17, ognuna 10,97–11,16 s
Flag di fineil primo a 308,2 s, 6 di fila

Tenuti in ordine di arrivo, un reinvio esatto scartato e stop al primo flag di fine, i blocchi fanno l'intero log: il parser del progetto lo legge senza un blocco duplicato e senza un passo indietro nel tempo.

Cosa ha fatto diversamente la cattura

Nello scarico registrato il primo MbbD è uscito un attimo prima del CmCh. Il suo blocco (l'inizio del log) è tornato subito dopo il CmCh, ed è l'unica ripetizione esatta che la regola sopra scarta. Anche il polling non si è fermato del tutto: un MbbR è uscito in mezzo ai due.

Il log della batteria: BmsD

BmsD fa lo stesso ciclo per il sistema di gestione della batteria: CmCh con indirizzo di lettura 0, poi BmsD ripetuto. Sulla FXS 2016 la batteria ha continuato a rispondere oltre 1024 blocchi senza mai mandare il flag di fine (visto con l'app ZeroLogs in ottobre 2026), quindi un client ha bisogno di un suo stop. ZeroLogs si ferma al conteggio di blocchi della scheda principale, 1024 su questa moto; se sia esattamente la dimensione del log della batteria non è ancora confermato.

Una moto con un secondo modulo batteria seleziona il sistema di gestione di quel modulo tramite CmCh prima di BmsD: SET_BMS_INDEX 1 (sottocomando 5), MEM_READ_SIZE (3) e MEM_READ_ADDR 0 (4), tre secondi dopo ciascuno, poi il ciclo BmsD, e SET_BMS_INDEX 0 dopo. L'argomento è il byte alto della prima parola di testo: l'indice 1 è 00 00 00 01 e la dimensione 00 04 00 00. Scritto nell'altro ordine di byte (01 00 00 00) lo switch è rimandato e ignorato, e BmsD serve di nuovo la prima batteria. Nell'ordine giusto ha funzionato su una FXS 2016 a due moduli nel novembre 2026.

Gen3: blocchi in ordine

LOG_INIT (tipo 24, corpo vuoto) risponde con il numero di file e, per ogni file, la dimensione in byte (u32 LE) e il conteggio dei blocchi (u16 LE); dalla versione major 27 del protocollo in poi, ogni voce di file è anche preceduta dal suo unit id. LOG_BLOCK (tipo 25) porta un numero di file (u8) e un numero di blocco (u16 LE), e il corpo della risposta è di 128 byte di flash grezza. Il file della scheda principale viene prima, poi quello della batteria. LOG_DONE (tipo 26) chiude la sessione; la moto risponde LOG_DONE oppure ACK.

Il numero di blocco non viene obbedito. Su una SR/F (protocollo 29.0.0) nel novembre 2026, dopo LOG_INIT la moto ha servito il blocco 0, 1, 2… di un file, uno per ogni richiesta ricevuta, qualunque numero portasse la richiesta. Tre scarichi che chiedevano i blocchi fuori turno lo mostrano byte per byte. Un client legge ogni file dal blocco 0, in ordine, e uno scarico che si ferma a metà rilegge quel file dall'inizio.

Neanche la risposta ripete il numero di blocco. Una risposta che arriva dopo un timeout è comunque un blocco: se la butti, la richiesta successiva resta col blocco dopo, e ogni blocco da lì in poi sta un posto troppo presto. Tieni una risposta in ritardo, e quando un blocco ha chiesto due richieste ed entrambe hanno avuto risposta, prendi la seconda risposta come blocco successivo. Manda LOG_DONE a ogni uscita, anche per uno scarico fallito o annullato.

Chiedi esattamente il conteggio dei blocchi, da 0 a conteggio − 1. Una richiesta un passo oltre la fine restituisce comunque 128 byte, e non sono dati di log: nei file Gen3 che abbiamo e che portano un blocco così, è quasi sempre una pagina vuota: il marcatore 00 F0 FF 00 e zeri. Un log completo di scheda Gen3 è 131.200 byte, 1.025 blocchi da 128.

Stato: Noto, non ancora catturato come cattura Bluetooth. L'ordine in cui tornano i blocchi è misurato, dai log tecnici ZeroLogs di una SR/F; la dimensione di 131.200 byte è misurata sui file di log Gen3.

I tipi di messaggio Gen3

I messaggi Gen3 sono numerati. La tabella elenca le letture; le scritture sono nella sezione dopo. I tipi da 16 a 21 portano due nomi diversi nelle fonti che abbiamo. Il secondo insieme (indicatori del cruscotto, ricarica programmata, modalità di guida personalizzate, ACK, timestamp, obiettivo di ricarica) si usa qui: concorda con ZeroBLE ovunque ZeroBLE nomini il tipo (16, 18, 19, 20).

Letture Gen3
TipoNomeCosa porta la rispostaStato
1Versione del protocollomajor, minor, patch. Major ≥ 27 cambia il layout di LOG_INITZeroBLE (open source)
2Reinviol'altra parte chiede di nuovo l'ultimo messaggioZeroBLE (open source)
3Stato (info moto)VIN, marca, modello, caricatore collegato, in ricarica, SoC, pronta (armata), potenza di ricarica (× 100 W), minuti alla fine. Anche un campo passcode: scartalo in decodifica, non salvarlo e non loggarloZeroBLE (open source)
4Paccolayout non pubblicatoNoto, non ancora catturato
5Stato batterialayout non pubblicatoNoto, non ancora catturato
6Lettura scheda principalecoppia motore, rpm, temperatura di motore e centralina, corrente di batteria e motore, velocitàNoto, non ancora catturato
10Statistiche cruscottolayout non pubblicatoNoto, non ancora catturato
11Centralineper unità: id e tipo del nodo, revisione firmware, banco attivo, codici firmware e hardwareNoto, non ancora catturato
12Codici erroreun conteggio u32, poi i codici attivi come u16Noto, non ancora catturato
13Modalità di guida di fabbricacinque modalità da 22 byte: nome, velocità massima, coppia, rigenerazione in rilascio e in frenata, potenza, controllo di trazione, ABS, colore del cruscotto. Mandate sempre con corpo vuotoZeroBLE (open source)
18Modalità di guida personalizzate (solo corpo vuoto)gli stessi cinque record, e il byte 111 è la modalità ATTIVA. Con un corpo, lo stesso numero di tipo riscrive le modalitàZeroBLE (open source)
19ACKconferma un messaggioZeroBLE (open source)
22Dati dal vivo (condivisione del giro)contachilometri (× 100 m), energia usata (kWh), consumo, velocità (km/h × 100), angolo di piega (° × 10, negativo a sinistra), potenza, coppia, rigenerazione e rigenerazione in frenata, longitudine poi latitudine (radianti × 10⁸), SoCZeroBLE (open source)
23Stima di autonomiaautonomia per tipo di percorso (città, extraurbana, misto, autostrada) e gli ingressi del modello: capacità del pacco nuovo / a metà vita / vecchio, stile di guida, temperatura, terrenoNoto, non ancora catturato
24–26Scarico del logLOG_INIT, LOG_BLOCK, LOG_DONE (vedi la sezione sullo scarico)Noto, non ancora catturato

I tipi 16, 18 e 21 sono letture con corpo vuoto e scritture con un corpo, sotto lo stesso numero. Chi controlla solo il tipo non distingue una lettura da una modifica, quindi ZeroLogs controlla anche il corpo: ogni richiesta che manda è vuota tranne file e numero di blocco di LOG_BLOCK. Legge 18 per la modalità di guida attiva e lascia fuori 16 e 21.

Comandi che cambiano la moto

Il protocollo porta anche comandi che cambiano come si comporta la moto, impostano l'orologio o caricano il firmware. Sono elencati, mai con un payload, così una cattura si può riconoscere. L'app ZeroLogs non ne manda nessuno, con un'eccezione: il suo codice Bluetooth accetta solo le letture delle tabelle sopra, l'unico CmCh che mette l'indirizzo di lettura a 0, e una scrittura, la ricarica programmata (messaggio 17). Rifiuta tutto il resto prima che arrivi alla radio.

Quella scrittura è ammessa solo con un corpo che un controllo stretto accetta: la stessa finestra tutti e sette i giorni, ogni durata tra mezz'ora e 23,5 ore, e l'inizio della ricarica alla fine della finestra di collegamento. Qualsiasi altro messaggio 17 è rifiutato, qualunque cosa contenga. L'app lo manda solo a una moto Gen3 connessa, in sosta e non pronta a partire, che sia sull'account del rider, e solo mentre la policy del server lo consente; il server può spegnerlo. Lo manda nella stessa connessione in cui lo costruisce, al massimo tre volte se la moto non risponde, e non è mai salvato per dopo. Il riscontro della moto non vale come prova: la programmazione conta come applicata solo quando il log successivo della moto la mostra. Se una moto applica esattamente ciò che è stato mandato si deduce, non è ancora confermato da un log.

Scritture
GenerazioneMessaggioCosa cambia
Gen2CmCh, parametri di guidai limiti della modalità di guida personalizzata: velocità massima, coppia, rigenerazione in rilascio, rigenerazione in frenata
Gen2CmCh, modalità di testuna modalità di test; cosa faccia non è documentato
Gen2CmCh, indice unità, banco di boot, stato aggiornamento e info immagineil meccanismo di aggiornamento del firmware
Gen2Upld, Hashun'immagine firmware e il suo hash
Gen318 modalità di guida, con un corpoimpostazioni delle modalità di guida (13, il set di fabbrica, si legge soltanto)
Gen316 indicatori del cruscotto, con un corpocosa mostra il cruscotto
Gen317 ricarica programmataquando parte la ricarica. L'unica scrittura che ZeroLogs manda, solo con un corpo stretto (vedi sopra)
Gen321 obiettivo di ricarica con un corpodove si ferma la ricarica
Gen320 timestampimposta l'orologio della moto
Gen327 registrazione di connettivitàsegna la moto come registrata al servizio connesso del costruttore, o rimossa. Una libreria open source manda un'impostazione di ricarica sotto questo numero, il cui primo byte la moto leggerebbe come "registered" (registrata)
Gen315 canale comandiil corrispondente Gen3 di CmCh; nessun uso noto, rifiutato come il resto
Gen331 navigazioneindicazioni svolta per svolta sul cruscotto
Gen332 stato opzione, 33 impostazione opzioneriferiscono e accendono le funzioni opzionali (33 con una chiave). 32 solo riferisce, ma il suo numero di tipo sta con le scritture delle funzioni, quindi ZeroLogs non manda nessuno dei due
Gen39 upload, 14 hash, 28 firmware init, 29 firmware installfirmware

Non sperimentare le scritture su una moto che guidi

Un parametro di guida sbagliato o un'immagine firmware scritta a metà può lasciarti una moto che non si comporta come ti aspetti, o che non parte. Leggere non fa danni; un comando che non sai nominare sì.

Cattura una tua sessione

Tutto ciò che è misurato qui è partito da un log Bluetooth di Android, e le righe Gen3 diventeranno misurate solo allo stesso modo. Una cattura contiene il VIN della moto, quindi si manda a noi in privato, e non si pubblica.

  1. 1Attiva le Opzioni sviluppatore: Impostazioni → Informazioni sul telefono → tocca Numero build sette volte.
  2. 2Nelle Opzioni sviluppatore metti "Enable Bluetooth HCI snoop log" su Enabled (non Filtered), poi spegni e riaccendi il Bluetooth.
  3. 3Collega la moto con una qualsiasi app che le parli, e fai una cosa alla volta. Scrivi cosa hai fatto, in ordine.
  4. 4Opzioni sviluppatore → Crea segnalazione di bug → Segnalazione completa, e tieni lo .zip (il log è FS/data/misc/bluetooth/logs/btsnoop_hci.log dentro).
  5. 5Rimetti il log di snoop su Disabled: registra ogni scambio Bluetooth finché è acceso.
  6. 6Carica lo .zip o il .log nella pagina Aiuto decodifica della tua dashboard ZeroLogs.

Domande frequenti

Mi serve una password o un PIN per leggere i dati di una Zero via Bluetooth?

No. Il telefono si associa alla moto una volta nelle sue impostazioni Bluetooth; dopo, il link è cifrato, e il protocollo stesso non ha login. Il primo frame dopo la connessione è già una richiesta di dati.

Un iPhone può parlare con una Zero Gen2?

Non da un'app di terze parti. Le Gen2 usano il seriale Bluetooth Classic (SPP), che iOS apre solo per gli accessori nel programma MFi di Apple. Le Gen3 usano Bluetooth LE, che le app iOS possono usare.

Perché la moto manda le miglia se il suo log è in chilometri?

Il protocollo è fatto così: la velocità di MbbR è in mph interi e il contachilometri di BtSt in miglia intere, mentre DSt1 e DSt2 danno i parziali e l'autonomia in centesimi di chilometro. Sulla FXS, i 20.776 mi di BtSt sono i 33.436 km che il suo log ha registrato, e la velocità di MbbR integrata come mph dà 4,71 km su un giro che il parziale mette a 4,80 km. Abbiamo misurato solo questa moto.

Perché uno scarico del log via Bluetooth è così lento?

Muove 256 byte per richiesta, una richiesta alla volta, circa 0,144 s ciascuna, e la moto si ferma per circa 11 s ogni tanto (17 volte in uno scarico). Un log di scheda principale da 256 KiB ha chiesto 5,6 minuti sulla FXS.

Due telefoni o due app possono collegarsi insieme?

Su Gen3, ogni manuale d'uso dal 2020 al 2026 dice che si può associare un solo telefono alla volta. Su Gen2 non abbiamo provato una seconda connessione; chiudi un'app prima di aprirne un'altra.

Leggere i dati via Bluetooth cambia qualcosa sulla moto?

Le letture no. L'unico comando di cui uno scarico ha bisogno, oltre a quelle, mette il puntatore di lettura all'inizio del log. I comandi che cambiano la moto sono elencati in questa pagina così li riconosci e li eviti.

Quanto è sicura la parte Gen3 di questa pagina?

Meno della parte Gen2. Gen2 è misurato sulle nostre catture. Gen3 viene dalla libreria open source ZeroBLE (l'app ZeroNavBridge del suo autore, costruita sopra, risulta funzionante su DSR/X, SR/F, SR/S e S Gen3) e da ciò che si conosce ma non è ancora catturato; ogni riga dice quale. Una cattura Gen3 lo chiuderebbe, e l'app Android ZeroLogs ora si collega alle Gen3 (nuova, in prova), e tiene un log tecnico che il rider può condividere.

Le misure Gen2 vengono da 4 sessioni registrate nell'agosto 2026 tra un telefono Android e una FXS 2016 (due giri, uno scarico di log e una breve riconnessione), lette con gli strumenti btsnoop di questo progetto: pacchetti Bluetooth ricomposti, ogni frame controllato sul suo CRC, ogni risposta decodificata agli offset di questa pagina. I tempi sono dall'inizio di ogni sessione; il VIN è oscurato. Il comportamento dello scarico Gen3 viene dai log tecnici ZeroLogs di una SR/F (protocollo 29.0.0) nel novembre 2026: i blocchi chiesti, e i byte tornati indietro.

Questo è un riferimento di interoperabilità indipendente, non affiliato né approvato da Zero Motorcycles, Inc. Gli offset sono stati misurati su una FXS 2016 e possono differire su altro firmware. Leggi pure; non mandare mai un comando che non sai nominare, e mai uno della tabella «Comandi che cambiano la moto» a una moto che guidi.