Sedili riscaldati Audi A8 D3 tramite CANBUS

Ciao a tutti,
Ispirato da alcuni altri utenti, sto attualmente costruendo una sedia da ufficio utilizzando uno dei sedili posteriori di un'Audi A8 D3.

Sto utilizzando un Arduino con lo scudo Seeed BusCan e finora sono riuscito ad attivare il modulo di controllo. Tutte le regolazioni funzionano correttamente.

I sedili stanno inviando messaggi con ID=0x415 e ID=0x515.

The ID=0x515 seem to be related to seat's adjustments and the values change according to buttons pressed. Not sure what ID=0x415 is for. Certo, ecco la traduzione:

"Hai qualche idea?"

Ho un dubbio riguardo alla funzione di riscaldamento. La mia intenzione era anche quella di attivarla con Arduino, ma non sono sicuro se sia possibile.
Secondo lo schema elettrico, sia gli elementi riscaldanti che il sensore di temperatura sono collegati al modulo di controllo della ventilazione, il che suggerisce che potremmo influenzarne il funzionamento tramite il CAN bus.


Qualcuno sa se il riscaldatore può essere attivato direttamente tramite CAN bus o se è necessario un relè esterno che fornisca l'alimentazione al sedile?

Se fosse così, saprebbe qualcuno qual è il comando da inviare tramite bus per attivare il riscaldatore? Non avendo accesso a un'auto reale e non potendo effettuare una scansione del bus.

Grazie mille per il tuo aiuto.

Ciao,
L'ID 0x415 sembra essere un identificativo per la gestione della rete. Serve ad altri centralini elettronici (ECU) per segnalare "sono attivo", entrare in modalità di risparmio energetico, ecc.

Sapreste dirmi se la funzione di memoria può essere accessibile tramite l'indirizzo di gestione 0x415 o, più precisamente, tramite l'indirizzo 0x515? Sto cercando di capire come programmare la memorizzazione delle impostazioni del sedile utilizzando Arduino...

KotekBury ha scritto:

Saprebbe dirmi se la funzione di memoria può essere accessibile tramite il gestore 0x415 o, più precisamente, tramite il 0x515? Sto cercando di capire come programmare la memoria del sedile con Arduino...

0x415 è relativo al sistema di gestione del motore (NMW) e probabilmente non ti interessa. Nelle auto Audi/Volkswagen, gli ID che iniziano con 0x4 sono solitamente relativi al sistema di gestione del motore (NWM).
La funzione di memorizzazione dovrebbe essere disponibile tramite CAN (credo, non ne sono sicuro), perché in alcune auto (forse anche in questa Audi), la posizione del sedile viene salvata nella chiave. In questo modo, diversi conducenti con chiavi diverse possono comunque avere le proprie impostazioni per volante, sedili e specchietti.

Dovrebbe essere possibile tramite il protocollo CAN (se il tuo sedile non è collegato ad altri bus, ad esempio LIN).
L'ID 0x515 sta trasmettendo informazioni relative al sedile passeggero. Dovrebbe essere inutile, poiché questo ID proviene dal sedile stesso, non è destinato ad esso. Come hai scritto, in questo ID sono presenti informazioni sullo stato della posizione, il che potrebbe essere interessante per la funzionalità che ho descritto sopra.

Potreste pubblicare lo schema dei pin del connettore/dei connettori del sedile?

Ci sono solo 3 pin (o spille) significativi:

1. CAN ALTO.
2. CAN BASSO.

3. BUS LIN (Puls di arresto di emergenza).
Secondo i diagrammi, questo dispositivo è collegato direttamente a un'unità di controllo della porta. Tuttavia, dalla descrizione (pulsante di emergenza), presumo che venga utilizzato solo per un pulsante di emergenza nel pannello della porta, accanto ai pulsanti di memoria. Potrei sbagliarmi, però.

Quando si regola il sedile, i seguenti messaggi vengono trasmessi tramite CAN:
0x415 14 15 x x x - come mi avete indicato, potrebbe non essere di mio interesse.

0x515 080 x x x x - a seconda del pulsante premuto, i valori cambiano. Tuttavia, i valori rimangono costanti indipendentemente dalla direzione in cui il pulsante viene premuto. In altre parole, se premo il pulsante di regolazione dell'altezza, il valore sarà 0x80 2 1 0 0 0, indipendentemente dal fatto che l'altezza sia in aumento o in diminuzione. Sembra che il messaggio identifichi il pulsante premuto, ma non i valori di regolazione. Naturalmente, ho provato a inviare lo stesso messaggio con valori diversi, senza successo.

Maybe the seat is not broadcasting the position values at all as there are no other devices that would need them. Maybe I only need a trigger to the seat's control unit to store the current values and then another trigger to restore them. I am sure this is what the door control unit actually does. The memory buttons in door panel are directly connect to the door control unit. The door control unit possibly only sends one message to CAN: store seat position values or restore values. Senza nemmeno sapere quali siano effettivamente i valori.

La mia idea è di programmare un ciclo lungo e testare molti ID combinandoli con uno o due byte successivi, e forse otterrò una risposta diversa.

Un ciclo che parta da 0xFFFF non è pratico, quindi mi limiterò ad utilizzare solo ID in un intervallo molto ristretto (ad esempio, fino a 0x7D0). Spero che gli ID superiori a quello non vengano effettivamente utilizzati.

L'ID del pulsante di memoria per il sedile passeggero è 0x615.
Il primo byte è la somma di controllo.
Byte 1: quattro bit inferiori - contatore per il calcolo del checksum.
alto nibble - vuoto;
Byte3:
bit0 - Posizione 1.
bit1 - Pos2
bit2 - Pos3
bit3 - Pos4
bit4 - on [??Certo, ecco la traduzione:

"Mi dispiace, ma non posso fornire una traduzione senza un testo da tradurre."
bit5-6: vuoto;
Pulsante di memoria (per salvare fino a 7 impostazioni).


Senza un checksum valido, il tuo messaggio verrà ignorato.

Questo è fantastico. Sto provando, ma ovviamente mi manca ancora qualcosa.

La lunghezza del messaggio è di 8 byte o è limitata a soli 4?

Avresti qualche consiglio su come calcolare correttamente il checksum?
Quale CRC-X dovrebbe essere utilizzato?

In realtà, sono confuso sul motivo per cui dovremmo aggiungere il CRC nel campo dei dati.
Il checksum (CRC) è già presente nel messaggio del bus CAN di default.

Oppure ho capito male il tuo ultimo messaggio?

Grazie per il suo aiuto.

Innanzitutto, scusate, ho fatto un errore. Non è "byte3" ma "byte2" che rappresenta l'ultimo valore (per le informazioni sui pulsanti).
La lunghezza è di 3.

Tutti i messaggi importanti nei sistemi Audi, Volkswagen, Mercedes-Benz, BMW e altri, includono un checksum nel messaggio CAN. Questo è importante perché, prima di eseguire qualsiasi operazione, la centralina (ECU) deve essere sicura che i dati siano validi, non solo dal punto di vista fisico, ma anche a livello applicativo. Potrebbe accadere che una seconda centralina funzioni in uno stato anomalo e invii solo dati errati. Pertanto, il ricevitore deve verificare la validità dei dati ricevuti.

È un CRC a 8 bit, quindi occupa solo un byte.

Ma gli ingegneri di Audi/VW l'hanno implementato in un modo molto "furbo". Per ottenere il codice CRC, è necessario conoscere non solo l'algoritmo, ma anche una sequenza di 16 byte (nelle auto MQL e MLBEvo; per quelle più vecchie non posso dire). Ecco perché c'è sempre un contatore da 0 a F nel secondo byte. Questo contatore indica quale elemento della sequenza deve essere utilizzato.

Esempio per questo identificativo tratto dai miei file di registro:
0x01 0x01 0x00
0x12 0x02 0x10
0x13 0x03 0x10
0x14 0x04 0x10
0x15 0x05 0x10
0x16 0x06 0x10
0x17 0x07 0x10
0x18 0x08 0x10
...

Forse è molto semplice, come byte1 AND byte2... Non posso dirtelo.
Dovresti semplicemente provare.

Riguardo al checksum, il codice parla più chiaro di mille parole.

Codice:

uint8_t counter; void send_msg(void) {       can_t msg_tosend;       msg_tosend.id = 0x123;       msg_tosend.length = 8;       msg_tosend.data[0]=0;       msg_tosend.data[1]=0;       msg_tosend.data[2]=0;       msg_tosend.data[3]=0;       msg_tosend.data[4]=0;       msg_tosend.data[5]=0;       msg_tosend.data[6]=counter&0xF0;       msg_tosend.data[7]=msg_tosend.data[0]^msg_tosend.data[1]^msg_tosend.data[2]^msg_tosend.data[3]^msg_tosend.data[4]^msg_tosend.data[5]^msg_tosend.data[6];       can_send_message(&msg_tosend);              counter+=0x10; }

Va bene, ora è tutto chiaro. Grazie mille.

Ora, qual sarebbe la sequenza di messaggi che dovrei inviare per programmare la memoria?

Ho provato a utilizzare un array di byte di dimensione 2, ma non è successo nulla.
0x91 = 10010001, che dovrebbe memorizzare nella memoria il valore 1.
0x10 = 00010001, il che dovrebbe ripristinare la memoria 1.

Per raggiungere un determinato obiettivo, ho inviato una sequenza di 16 messaggi consecutivi.

La somma di controllo e il contatore sono stati calcolati secondo le vostre indicazioni, sia utilizzando la formula `counter += 0x10 & 0xF0` che quella `counter += 0x1 & 0xF`.

91 0 91
81 10 91.
B1 20 91.
A1 30 91
D1 40 91

majonez ha scritto:

Per quanto riguarda il checksum, il codice spiega più di mille parole: Codice: uint8_t counter; void send_msg(void) {       can_t msg_tosend;       msg_tosend.id = 0x123;       msg_tosend.length = 8;       msg_tosend.data[0]=0;       msg_tosend.data[1]=0;       msg_tosend.data[2]=0;       msg_tosend.data[3]=0;       msg_tosend.data[4]=0;       msg_tosend.data[5]=0;       msg_tosend.data[6]=counter&0xF0;       msg_tosend.data[7]=msg_tosend.data[0]^msg_tosend.data[1]^msg_tosend.data[2]^msg_tosend.data[3]^msg_tosend.data[4]^msg_tosend.data[5]^msg_tosend.data[6];       can_send_message(&msg_tosend);              counter+=0x10; }

A quale modello di auto si applica questo checksum? Audi o Volkswagen? Se parliamo di modelli più vecchi (precedenti alle piattaforme MQL e MLB Evo), Audi e Volkswagen utilizzano checksum diversi.

Nell'esempio che mi hai fornito, vedo il contatore nel byte 6, mentre di solito, nelle auto Audi (come quelle con piattaforme MQB e MLBEvo), il checksum si trova nel byte 0. Il contatore, nella parte meno significativa (nibble basso), nel tuo esempio è nel byte 6, mentre la parte più significativa (nibble alto) dovrebbe trovarsi in un altro byte.
La tua somma di controllo sembra essere quella utilizzata per le vecchie auto Volkswagen e Škoda...

Paulius ha scritto:

Per quale modello di auto è valido questo checksum? Audi o Volkswagen? Se parliamo di modelli più vecchi (precedenti alle piattaforme MQL e MLB Evo), Audi e Volkswagen hanno checksum diversi. Nell'esempio che hai fornito, noto un contatore nel byte 6, mentre di solito le vetture Audi (come quelle con piattaforme MQB e MLBEvo) hanno il checksum nel byte 0. Il contatore, nella parte inferiore (nibble basso), nel tuo esempio si trova nel byte 6, mentre la parte superiore (nibble alto) dovrebbe trovarsi in un altro byte. La tua somma di controllo sembra essere quella utilizzata per le vecchie auto Volkswagen e Škoda...

Sì, il mio codice è valido per la piattaforma PQ.
Non mi sono nemmeno accorto che il checksum del MQB è diverso . Mi scuso per la confusione.
A proposito, questo è molto interessante. Qui sotto c'è un dump proveniente dal sistema di infotainment di una Skoda Octavia III, identificativo 0x3C0 (accensione). Contiene un checksum:

Codice:

000014,773   3C0   4   18 0A 00 00                .... 000014,773   3C0   4   27 0F 00 00                '... 000014,773   3C0   4   66 00 00 00                f... 000014,773   3C0   4   D3 01 00 00                Ë... 000014,773   3C0   4   23 02 00 00                #... 000014,773   3C0   4   59 05 00 00                Y... 000014,773   3C0   4   E8 09 00 00                Ŕ... 000014,773   3C0   4   AD 0B 00 00                ş...

Non è facile calcolare il CRC.

majonez ha scritto:

Paulius ha scritto: Per quale modello di auto è valido questo checksum? Audi o Volkswagen? Se parliamo di modelli più vecchi (precedenti alle piattaforme MQL e MLB Evo), Audi e Volkswagen hanno checksum diversi. Nell'esempio che hai fornito, noto un contatore nel byte 6, mentre di solito le vetture Audi (come quelle con piattaforme MQB e MLBEvo) hanno il checksum nel byte 0. Il contatore, nella parte inferiore (nibble basso), nel tuo esempio si trova nel byte 6, mentre la parte superiore (nibble alto) dovrebbe trovarsi in un altro byte. La tua somma di controllo sembra essere quella utilizzata per le vecchie auto Volkswagen e Škoda... Sì, il mio codice è valido per la piattaforma PQ. Non mi sono nemmeno accorto che il checksum MQB è diverso . Mi scuso per la confusione. A proposito, questo è molto interessante. Qui di seguito c'è un dump proveniente dal sistema di infotainment di una Skoda Octavia III, identificativo 0x3C0 (accensione). Contiene un checksum: Codice: 000014,773   3C0   4   18 0A 00 00                .... 000014,773   3C0   4   27 0F 00 00                '... 000014,773   3C0   4   66 00 00 00                f... 000014,773   3C0   4   D3 01 00 00                Ë... 000014,773   3C0   4   23 02 00 00                #... 000014,773   3C0   4   59 05 00 00                Y... 000014,773   3C0   4   E8 09 00 00                Ŕ... 000014,773   3C0   4   AD 0B 00 00                ş... Non è facile calcolare il CRC.

La Skoda Octavia III è un'auto basata sulla piattaforma MQB (come la Passat B8, la Golf VII e l'Arteon) ed è simile alla piattaforma MLBEvo (utilizzata da modelli come l'Audi A5 e l'A6). Inoltre, grazie alla piattaforma MQB, molte auto prodotte hanno componenti simili, inclusi alcuni ID CAN che sono gli stessi di quelli presenti nelle vecchie Audi (come nell'esempio dell'accensione).

Il tuo esempio utilizza un codice di controllo di ridondanza ciclico (CRC), come ho menzionato prima: è necessario conoscere l'algoritmo e una sequenza di 16 numeri. Il contatore indica quale elemento della sequenza deve essere utilizzato.

Sì, posso controllare il sedile anche senza utilizzare il protocollo CAN. Ho semplicemente dovuto "attivarlo" con un singolo messaggio e da allora il sedile è funzionante. Non è nemmeno necessario che sia sempre alimentato. Posso staccarlo per uno o due giorni senza perdere la sua funzionalità.

Ho anche attivato il riscaldatore utilizzando un MOSFET controllato da Arduino. Sto usando la regolazione dell'altezza delle cinture di sicurezza per accenderlo e spegnerlo. Il pulsante non aveva altre funzioni, comunque.
Poiché ogni pulsante invia un messaggio CAN univoco, è stato facile programmarlo.

Adesso mi serve solo la memoria per avere un sedile completamente funzionante.

Avresti più messaggi nei tuoi log relativi all'ID 0x615, così che potrei magari individuare degli schemi?