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.
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.
| Gen2 | Gen3 | |
|---|---|---|
| Radio | Bluetooth Classic (BR/EDR) | Bluetooth Low Energy |
| Profilo | Serial Port Profile su RFCOMM | Servizio GATT 0xFEFB, un profilo seriale su BLE |
| Dove | Canale server RFCOMM 1, UUID SPP 00001101-0000-1000-8000-00805f9b34fb | Servizio 0000FEFB-0000-1000-8000-00805F9B34FB |
| Sicurezza | Un bond a livello di sistema; il link è cifrato con la sua chiave | Associazione come la descrive il manuale della moto; un telefono per moto |
| Login nel protocollo | Nessuno | Nessuno noto |
| Nomi dei messaggi | Quattro lettere ASCII (PrVr, MbbR …) | Numeri (1, 3, 22 …) più un contatore |
| Telefoni | Android (iOS richiede MFi) | Android e iOS |
| Stato | Misurato | ZeroBLE (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.
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 link Gen3: una porta seriale dentro il GATT
Una Gen3 annuncia il servizio 0xFEFB, l'UUID a 16 bit che il Bluetooth SIG ha assegnato a Telit (prima Stollmann), il cui profilo "Terminal I/O" porta un flusso seriale su BLE. Il client si collega in LE senza autoConnect e si iscrive, una scrittura alla volta, a 0A (indicazioni), 04 (indicazioni) e 02 (notifiche). Se la moto ha annunciato la lunghezza su 0A, il client la rimanda su 09; altrimenti i pacchetti sono da 20 byte. Poi concede alla moto 64 crediti su 03 e aspetta la prima concessione della moto su 04.
Il controllo di flusso è a crediti. Ogni scrittura fino a 20 byte su 01 spende uno dei crediti che la moto ha concesso su 04, e il client non scrive mai a zero. Ogni notifica su 02 spende uno di quelli del client: quando ne restano 16 o meno, concede alla moto abbastanza su 03 per tornare a 64. Un blocco di log da 128 byte arriva quindi come otto notifiche.
L'associazione è del telefono, non di un'app: la prima iscrizione viene rifiutata finché il link non è cifrato, il telefono chiede un PIN, e il cruscotto mostra le sei cifre da digitare. Un telefono già associato si collega senza PIN. Dopo non c'è login: il primo messaggio è la versione del protocollo, e la moto risponde subito alle letture.
Ogni manuale d'uso Gen3 dal 2020 al 2026 dà l'ID di associazione come Zero_XXXXX, le ultime cinque cifre del VIN, e annota che "only one cell phone can be paired to your motorcycle at a time" (si può associare un solo telefono alla moto). Nessun manuale Gen2 porta quella nota.
0000000x-0000-1000-8000-008025000000)| x | Nome | Ruolo |
|---|---|---|
| 01 | UART TX | dati, dal telefono alla moto: write without response, un credito a scrittura |
| 02 | UART RX | dati, dalla moto al telefono: notifiche |
| 03 | local credits | crediti che il telefono concede alla moto: un byte, in scrittura |
| 04 | remote credits | crediti che la moto concede al telefono: un byte, in indicazione |
| 09 | MTU RX | lunghezza del telefono, u16 LE, in scrittura |
| 0A | MTU TX | lunghezza della moto, u16 LE, in indicazione |
Stato: ZeroBLE (open source) per i nomi; noto, non ancora catturato per l'ordine e gli importi dei crediti. I nomi sono dal lato del telefono; il profilo chiama 01 e 02 al contrario.
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.
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.| Tag | Significato | Cosa fare | Stato |
|---|---|---|---|
| ReSd | La moto non ha preso l'ultima richiesta | Manda di nuovo la stessa richiesta | Noto, non ancora catturato |
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, LEIl 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).
| Tag | Chiede | Payload della risposta | Stato |
|---|---|---|---|
| PrVr | La versione del protocollo | 1 parola | Misurato |
| Gbki | Chi è la moto: VIN, marca, modello, codice della scheda principale | 26 parole (104 B) | Misurato |
| PwPk | Pacco: tensione del pacco, ogni cella, SoC, Ah, sonde di temperatura, corrente | 25 parole (100 B) su un pacco da 28 celle | Misurato |
| BtSt | Stato batteria: tensione, Ah, SoC, temperature del pacco, bit di stato, contachilometri | 11 parole (44 B) | Misurato |
| MbbR | Scheda principale: coppia, rpm, temperatura di motore e centralina, correnti, velocità, interruttori | 7 parole (28 B) | Misurato |
| DSt1 | Cruscotto: parziale A, rpm motore, codice del cruscotto | 2 parole | Misurato |
| DSt2 | Cruscotto: parziale B, stima di autonomia, temperatura motore | 2 parole | Misurato |
| DSt3 | Cruscotto: minuti alla fine della ricarica, tre parole di consumo | 3 parole | Misurato; scale non definite |
| Ecus | Ogni centralina: indice, anno modello, codici e revisioni hardware e firmware | un conteggio, poi 30 B per unità | Noto, non ancora catturato |
| Errs | I codici guasto attivi | un conteggio, poi un u16 per codice | Noto, non ancora catturato |
| MbbD | Il log della scheda principale, un blocco per richiesta | 65 parole: flag di 4 byte + 256 B | Misurato |
| BmsD | Il log della batteria, allo stesso modo | 65 parole | Risposta sulla FXS 2016 |
| CmCh | Il canale comandi; uno scarico ci imposta l'indirizzo di lettura a 0 | 11 parole, in eco | Misurato (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.
| Dal byte | Campo | Esempio |
|---|---|---|
| 0 | VIN, 17 caratteri ASCII + NUL | [VIN] (oscurato qui) |
| 18 | Marca | Zero Motorcycles |
| 38 | Modello | FXS |
| 70 | Codice della scheda principale | 40-08290C |
| 96 | u32, significato non noto | 41 |
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.
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.| Byte | Campo | Unità | Esempio alla connessione |
|---|---|---|---|
| 0–3 | Tensione del pacco | u32, mV | 105,386 V |
| 4–59 | 28 tensioni di cella | u16 ciascuno, mV, tutti ≥ 128 | 3673–3764 mV |
| 60–61 | Stato di carica | u16, % | 60 % |
| 62–63 | Capacità | u16, Ah | 52 Ah |
| 64–65 | Residuo | u16, Ah | 32 Ah |
| 66–91 | 13 posti di temperatura | s16 ciascuno, °C; −100 = nessuno | 34 33 34 34 — — — — 34 33 42 46 35 |
| 92–93 | Corrente del pacco | s16, A; segno non definito | -3 A |
| 94–99 | Non decodificato | ed 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.
| Byte | Campo | Unità | Esempio alla connessione |
|---|---|---|---|
| 0–3 | Tensione del pacco | u32, mV | 105,341 V |
| 4–5 | Capacità | u16, Ah | 52 Ah |
| 6–7 | Residuo | u16, Ah | 32 Ah |
| 8 | Stato di carica | u8, % | 62 % |
| 10–25 | Temperature del pacco | 8 × s16, °C; −100 = nessuno | 34 33 34 34 — — — — |
| 28–31 | Bit di stato | u32, vedi sotto | bike on |
| 32–35 | Contachilometri | u32, miglia intere | 20.776 mi |
| 36–39 | Non definito | u32 | 28.472 in marcia, 0 in sosta |
| 40–43 | Un contatore lento, unità non definita | u32 | 135 → 138 su 42 mi |
Stato: Misurato.
| Bit | Significato | Visto |
|---|---|---|
| 0x10000000 | Caricatore 1 collegato | sì, in 1 risposta |
| 0x08000000 | Caricatore 2 collegato | |
| 0x04000000 | Moto accesa | sì, in tutte le 10 risposte |
| 0x02000000 | Pacco caldo | |
| 0x01000000 | Pacco in temperatura critica | |
| 0x00800000 | Pacco freddo | |
| 0x00400000 | Carica bassa | |
| 0x00200000 | Carica critica | |
| 0x00100000 | Celle 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.
| Byte | Campo | Unità | In marcia | In sosta |
|---|---|---|---|---|
| 0–1 | Coppia motore | s16, N·m | -3 | 0 |
| 2–3 | Velocità motore | s16, rpm | 838 | 0 |
| 4–5 | Temperatura motore | s16, °C | 43 | 44 |
| 6–7 | Temperatura centralina | s16, °C | 35 | 34 |
| 8–9 | Corrente batteria | s16, A; segno non definito | 0 | 0 |
| 10–11 | Corrente motore | s16, A; segno non definito | -15 | 0 |
| 12–15 | Velocità | u32, mph interi | 12 | 0 |
| 16–19 | Bit di stato | u32, vedi sotto | armed | kickstand down, brake |
| 20–27 | Limiti della modalità Eco | 4 × u16, % | 85 / 20 / 0 / 100 | 85 / 20 / 0 / 100 |
Stato: Misurato.
| Bit | Significato | Visto |
|---|---|---|
| 0x10000000 | Cavalletto giù | sì, in sosta |
| 0x08000000 | Kill switch spento | |
| 0x04000000 | Armata (pronta a partire) | sì, in marcia |
| 0x02000000 | Avviso temperatura | |
| 0x01000000 | Freno | sì |
| 0x00200000 | In 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.
| Lettura | Byte | Campo | Unità | Alla connessione |
|---|---|---|---|---|
| DSt1 | 0–3 | Parziale A | u32, km × 100 | 38,60 km |
| DSt1 | 4–5 | Velocità motore | s16, rpm | 0 |
| DSt1 | 6–7 | Codice cruscotto | u16 | 0 (45 in sosta) |
| DSt2 | 0–3 | Parziale B | u32, km × 100 | 1374,10 km |
| DSt2 | 4–5 | Stima di autonomia | u16, km × 100 | 119,06 km |
| DSt2 | 6–7 | Temperatura motore | s16, °C | 44 °C |
| DSt3 | 0–1 | Minuti alla fine della ricarica | u16 | 0 (185 sul caricatore) |
| DSt3 | 4–7 | Consumo, istantaneo? | u32, scala non definita | 0 |
| DSt3 | 8–9 | Consumo, medio? | u16, scala non definita | 1940 |
| DSt3 | 10–11 | Consumo, di vita? | u16, scala non definita | 231 |
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.
| Byte | Campo |
|---|---|
| 0 | Indice unità: 6 scheda principale, 8 batteria, 9 una seconda batteria |
| 2–3 | Anno modello, u16 (la scheda principale lo manda × 10) |
| 4–15 | Codice hardware, ASCII |
| 16 | Revisione hardware |
| 17–28 | Codice firmware, ASCII (vuoto = salta il record) |
| 29 | Revisione 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.
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.
- 1Ferma il polling dal vivo, così in volo restano solo i frame dello scarico.
- 2Manda CmCh con l'indirizzo di lettura a 0. Il payload è di 11 parole:
04 00 00 00e poi zeri. La moto lo rimanda. - 3Manda MbbD (N = 0). La risposta è un flag di 4 byte e 256 byte di log.
- 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. - 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.
- 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. - 7Manda di nuovo CmCh e riprendi il polling. Se la moto manda ReSd, ripeti la tua ultima richiesta.
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.| Valore | |
|---|---|
| Risposte ricevute | 1048 |
| Blocchi tenuti | 1024 × 256 B = 262.144 B |
| Durata | 334,3 s |
| Intervallo mediano tra le risposte | 0,144 s |
| Pause | 17, ognuna 10,97–11,16 s |
| Flag di fine | il 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.
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).
| Tipo | Nome | Cosa porta la risposta | Stato |
|---|---|---|---|
| 1 | Versione del protocollo | major, minor, patch. Major ≥ 27 cambia il layout di LOG_INIT | ZeroBLE (open source) |
| 2 | Reinvio | l'altra parte chiede di nuovo l'ultimo messaggio | ZeroBLE (open source) |
| 3 | Stato (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 loggarlo | ZeroBLE (open source) |
| 4 | Pacco | layout non pubblicato | Noto, non ancora catturato |
| 5 | Stato batteria | layout non pubblicato | Noto, non ancora catturato |
| 6 | Lettura scheda principale | coppia motore, rpm, temperatura di motore e centralina, corrente di batteria e motore, velocità | Noto, non ancora catturato |
| 10 | Statistiche cruscotto | layout non pubblicato | Noto, non ancora catturato |
| 11 | Centraline | per unità: id e tipo del nodo, revisione firmware, banco attivo, codici firmware e hardware | Noto, non ancora catturato |
| 12 | Codici errore | un conteggio u32, poi i codici attivi come u16 | Noto, non ancora catturato |
| 13 | Modalità di guida di fabbrica | cinque 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 vuoto | ZeroBLE (open source) |
| 18 | Modalità 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) |
| 19 | ACK | conferma un messaggio | ZeroBLE (open source) |
| 22 | Dati 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⁸), SoC | ZeroBLE (open source) |
| 23 | Stima di autonomia | autonomia 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, terreno | Noto, non ancora catturato |
| 24–26 | Scarico del log | LOG_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.
| Generazione | Messaggio | Cosa cambia |
|---|---|---|
| Gen2 | CmCh, parametri di guida | i limiti della modalità di guida personalizzata: velocità massima, coppia, rigenerazione in rilascio, rigenerazione in frenata |
| Gen2 | CmCh, modalità di test | una modalità di test; cosa faccia non è documentato |
| Gen2 | CmCh, indice unità, banco di boot, stato aggiornamento e info immagine | il meccanismo di aggiornamento del firmware |
| Gen2 | Upld, Hash | un'immagine firmware e il suo hash |
| Gen3 | 18 modalità di guida, con un corpo | impostazioni delle modalità di guida (13, il set di fabbrica, si legge soltanto) |
| Gen3 | 16 indicatori del cruscotto, con un corpo | cosa mostra il cruscotto |
| Gen3 | 17 ricarica programmata | quando parte la ricarica. L'unica scrittura che ZeroLogs manda, solo con un corpo stretto (vedi sopra) |
| Gen3 | 21 obiettivo di ricarica con un corpo | dove si ferma la ricarica |
| Gen3 | 20 timestamp | imposta l'orologio della moto |
| Gen3 | 27 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) |
| Gen3 | 15 canale comandi | il corrispondente Gen3 di CmCh; nessun uso noto, rifiutato come il resto |
| Gen3 | 31 navigazione | indicazioni svolta per svolta sul cruscotto |
| Gen3 | 32 stato opzione, 33 impostazione opzione | riferiscono 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 |
| Gen3 | 9 upload, 14 hash, 28 firmware init, 29 firmware install | firmware |
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.
- 1Attiva le Opzioni sviluppatore: Impostazioni → Informazioni sul telefono → tocca Numero build sette volte.
- 2Nelle Opzioni sviluppatore metti "Enable Bluetooth HCI snoop log" su Enabled (non Filtered), poi spegni e riaccendi il Bluetooth.
- 3Collega la moto con una qualsiasi app che le parli, e fai una cosa alla volta. Scrivi cosa hai fatto, in ordine.
- 4Opzioni sviluppatore → Crea segnalazione di bug → Segnalazione completa, e tieni lo .zip (il log è
FS/data/misc/bluetooth/logs/btsnoop_hci.logdentro). - 5Rimetti il log di snoop su Disabled: registra ogni scambio Bluetooth finché è acceso.
- 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.
Fonti:
- ZeroBLE, Belkaar (licenza MIT) (si apre in una nuova scheda)
- ZeroNavBridge, Belkaar (si apre in una nuova scheda)
- Avviso CISA ICS ICSA-26-111-06 (CVE-2026-1354) (si apre in una nuova scheda)
- Bluetooth SIG: numeri assegnati (UUID a 16 bit 0xFEFB) (si apre in una nuova scheda)
- Android: log di snoop HCI Bluetooth (si apre in una nuova scheda)
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.