Problema con il filtro CAN Bus

Ho trovato questo thread, ma non riesco a capire niente e non riesco a filtrare il messaggio 0x280 (che vedo nel monitor seriale dell'IDE di Arduino, tra le altre cose).

Vorrei visualizzare, ad esempio, il numero di giri del motore su un display TFT. Domanda: come posso fare? Ho lavorato a questo problema per tutto il fine settimana, dedicandoci molte ore. Non ce la faccio.

Il mio codice.

Codice:

#include <mcp_can> #include <SPI> long unsigned int rxId; unsigned char len = 0; unsigned char rxBuf[8]; MCP_CAN CAN0(5); // CS ist am Pin 5 am ESP32 void setup() { Serial.begin(115200); if(CAN0.begin(MCP_STD, CAN_500KBPS, MCP_8MHZ) == CAN_OK) Serial.print("MCP2515 Init Okay!!\r\n"); else Serial.print("MCP2515 Init Failed!!\r\n"); pinMode(34, INPUT); // Setting pin 2 for /INT input CAN0.init_Mask(0,0,0x07FF); // Init first mask... CAN0.init_Filt(0,0,0x280); // Init first filte CAN0.init_Filt(0,0,0x288); // Init first filter... CAN0.init_Mask(1,0,0x07FF); // Init second mask... // CAN0.init_Filt(0,0,0x0288); // Init third filter... // Init sixth filter... Serial.println("MCP2515 Library Mask & Filter Example..."); CAN0.setMode(MCP_NORMAL); } void loop() { if(!digitalRead(34)) // Int ist am Pin 34 am ESP32 { CAN0.readMsgBuf(&rxId, &len, rxBuf); // Read data: len = data length, buf = data byte(s) Serial.print("ID: "); Serial.print(rxId, HEX); Serial.print(" Data: "); for(int i = 0; i<len; i++) // Print each byte of the data { if(rxBuf[i] < 0x10) // If data byte is less than 0x10, add a leading zero { Serial.print("0"); } Serial.print(rxBuf[i], HEX); Serial.print(" "); } Serial.println(); } } Die Ausgabe im Arduino Seriellen Monitor: D2 Data: 00 00 00 20 00 06 6B ID: 2A0 Data: 00 00 00 00 00 00 30 30 ID: 4A0 Data: 00 00 00 00 00 00 00 00 ID: 2A0 Data: 00 00 00 00 00 00 40 40 ID: 4A0 Data: 00 00 00 00 00 00 00 00 ID: 2A0 Data: 00 00 00 00 00 00 50 50 ID: 4A0 Data: 00 00 00 00 00 00 00 00 ID: 2A0 Data: 00 00 00 00 00 00 60 60 ID: 4A0 Data: 00 00 00 00 00 00 00 00 ID: 2A0 Data: 00 00 00 00 00 00 70 70 ID: 4A0 Data: 00 00 00 00 00 00 00 00 ID: 2A0 Data: 00 00 00 00 00 00 80 80 ID: 4A0 Data: 00 00 00 00 00 00 00 00 ID: 2A0 Data: 00 00 00 00 00 00 90 90 ID: 4A0 Data: 00 00 00 00 00 00 00 00 ID: 2A0 Data: 00 00 00 00 00 00 A0 A0 ID: 4A0 Data: 00 00 00 00 00 00 00 00 ID: 2A0 Data: 00 00 00 00 00 00 B0 B0 ID: 4A0 Data: 00 00 00 00 00 00 00 00 ID: 2A0 Data: 00 00 00 00 00 00 C0 C0 ID: 4A0 Data: 00 00 00 00 00 00 00 00 Ich verstehe den Zusammenhang (trotz lesens im Internet u. im Code) nicht, wie ich a) die FIlter setze. b) wieso 2A0 und 4A0 dabei herauskommen. c) Muss ich in meinem Fall überhaupt Filter setzen ? d) wie kann ich mit (cansniffer) mit dem Arduino + mcp2515 Daten auslesen. Im Seriellen Monitor der Arduino IDE sehe ich die Can Nachrichten, in Savvy Can oder cansniffer in der bash, sehe ich gar nichts. e) wie kommt man überhaupt auf "07FF" in der Maske? Ich bin Automechaniker und lerne C+ seit 7 Monaten mit ChatGPT aber nach meiner Logik sollte die Maske doch ab 0x000 alle Daten blockieren ? Die Maske ist doch dafür da, alle Nachrichten draußen zu halten ? Und die Filter lassen jeweils die einzelnen Nachrichten durch ? Wer kann mir helfen ? Ich komme absolut nicht weiter und es ist nur noch ein Rätsel raten.

Non è necessario utilizzare i filtri, tuttavia, se c'è molto traffico sul bus, è necessario occuparsi dell'elaborazione dei pacchetti desiderati, e in questo modo potrebbero andare persi dei pacchetti (in caso di output seriale).

Ecco la scheda tecnica del MCP2515, che è il componente utilizzato in questo caso.

https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf

A pagina 33 vengono spiegati i filtri.

Devi visualizzare i filtri a livello di bit, non come byte, altrimenti potrebbe essere più complicato.

Prendi il computer con Windows e configuralo per gli sviluppatori.
In questo modo, puoi passare direttamente da esadecimale a binario e capire esattamente cosa viene filtrato e cosa no.
07FF -> 00000111 11111111

Grazie per il tuo impegno, ma non riesco a capirlo. Tutto questo è fittizio e non è spiegabile.

ID 0x280, i byte 2 e 3 relativi alla velocità di rotazione (rpm) che devo modificare e calcolare. A cosa servono quei bit? Io non sto facendo debugging. Per ora, si tratta solo del calcolo. Inoltre, la libreria mcp_2515.h non presenta problemi con i filtri. Ha funzionato subito, mostrando solo il valore "0x280" in seriale.

Ho capito male qualcosa?

Un'altra domanda: è possibile far funzionare in qualche modo l'Arduino + mcp2515 con Scavvy Can o cansniffer? Uso Linux e non ho Windows (lo ho solo nella macchina virtuale).

Ho un'Audi A3 8P che utilizzo solo per fare dei test. Riguarda una centralina TCU di una Ferrari 360. Voglio intercettare la sequenza di dati proveniente dal costoso strumento Texa, tramite un cavo Y OBD. L'obiettivo è quello di visualizzare e modificare il valore PIS (probabilmente un parametro specifico) dell'auto su un display TFT o OLED. Su questa vettura, sicuramente tutto sarà nuovo. Non esistono documentazioni o esperienze a riguardo. Dalla centralina TCU, avrei bisogno del valore PIS, del consumo della frizione e della pressione della pompa SMG. Sarebbe fantastico, almeno in teoria. Senza uno strumento di analisi come Savvy Can, che possa rappresentare graficamente le sequenze di bit dei singoli byte, sarà difficile, se non impossibile. Ho qui un adattatore USB TTL e un cavo diagnostico OBD per VAG COM.

Non ho ancora capito: da dove provengono gli identificativi univoci (PID)? Ci sono solo CANId, lunghezza e dati.

Grazie mille per il tuo impegno...

E un'altra domanda...

Se qualcuno ha una sequenza di byte con un'alta probabilità di essere quella desiderata... come hanno scoperto il metodo di calcolo? Attraverso informazioni trapelate dai produttori? Ho anche un tester Launch X431... è possibile filtrare i PID con questo strumento? Cavi o software?

Sto ancora cercando gli ID CAN per la posizione chilometrica e la tensione della batteria: per caso li conosci? Finora non sono riuscito a trovare nulla online a riguardo. Grazie ancora per il tuo aiuto. Farò del mio meglio per capire tutto. Per me, i sistemi HEX/BIN/HEXADECIMALE sono completamente nuovi. Non capisco come distinguere la parte alta dalla parte bassa, e ho un'altra domanda: i protocolli CAN servono solo per sapere se i bit vengono contati dall'inizio o dalla fine? E sì, ho il PDF "The Car Hackers Handbook", ma ci sono solo informazioni di base, a quanto pare. Finora, questo libro non mi ha offerto molte informazioni che non avessi già scoperto attraverso ricerche o ChatGPT.

Attualmente, il mio progetto è composto da un display TFT da 4" e una scheda ESP32dev. Su questa, ho integrato un modulo Neo 6M e sono riuscito a visualizzare numeri in stile a 7 segmenti, l'ora GPS con l'aggiustamento dell'ora legale, la velocità media, e ho implementato un sistema di menu/pagine tramite pulsanti, oltre all'aggiornamento del codice tramite OTA. Inizialmente, tutto funzionava su un display OLED, ma poi ho dovuto imparare a usare la funzione "drawrec" per cancellare i vecchi caratteri/numeri sul display TFT, il che era una novità per me. Durante questo processo, ho imparato cosa sono un array e una stringa, e come programmarli. Lavoro a questo progetto da 7 mesi e ho iniziato da zero. All'inizio, non avrei mai pensato di arrivare a questo punto... Per 3 mesi, non sono riuscito ad andare avanti perché il quarzo che avevo aggiornato da 8 a 16 MHz era difettoso e non riuscivo a ricevere dati seriali, nonostante le impostazioni corrette nel codice (baud rate, pin CS, pin INT, velocità del bus).

Quindi, la maschera definisce i bit che vengono trasmessi? Quindi, per la maschera di un messaggio CAN standard, ho bisogno solo di 7FF, che corrisponde a 11 bit, corretto?

Secondo la mia logica, non avrei bisogno di ulteriori filtri, dato che voglio accedere a tutti i bit di diversi identificativi CAN (CanID) – è corretto?

Certo, posso aiutarti. Per favore, fornisci il testo che desideri tradurre dal tedesco all'italiano.

italiano
if (mcp2515.readMessage(&canMsg) == 0x280 {....

Certo, fornisci il testo che desideri tradurre.

elaborare? Si verificano perdite di pacchetti solo in comunicazioni seriali?

Proprio per questo l'interfaccia di questo sito è molto adatta!

https://www.canhack.de/it/viewtopic.php?t=1852

Con questo strumento, puoi filtrare e visualizzare le modifiche ai dati in modo chiaro, per capire quali byte contengono.

Suona bene...

Se il supporto include questa assistenza, sono disposto a pagare l'importo anche senza questo cavo. Suppongo che sia possibile utilizzare anche i classici sniffer con l'Arduino e un adattatore TTLUSB.

Acquisterò un cavo da voi la prossima settimana.

Grazie ancora per il tuo impegno. Sei stato molto gentile. Era corretto quello che ho detto riguardo alle mascherine e ai filtri?

Secondo quello che ho sentito, i produttori stanno pianificando di implementare un CAN crittografato in futuro... ma comunque, sconsiglio a tutti di acquistare auto nuove. Sono una vera porcheria. Catena di distribuzione posteriore, tra motore e cambio... cinghie di distribuzione immerse nell'olio... cilindri senza manicotti... frizioni del cambio DSG che durano solo 50.000 km. Ormai circolano solo rottami per le strade. *scuote la testa*

I diversi adattatori utilizzano protocolli specifici tra hardware e software, e l'hardware stesso integra processori dedicati che gestiscono gran parte delle operazioni direttamente nell'interfaccia.

Ho personalmente utilizzato diversi adattatori CAN-USB per il settore marittimo, e in questi sistemi, le configurazioni dei dispositivi vengono effettuate tramite il software proprietario del dispositivo stesso e il gateway associato; un gateway Arduino viene semplicemente ignorato.

I dati crittografati sul bus CAN sono ormai diffusi, ma a causa della bassa velocità di trasmissione, sono molto rari.

Certo, anche la mia vecchia A6 4F 3.0 TDI del 2010 aveva la catena di trasmissione tra il motore e il cambio, ma non ho mai avuto problemi con essa.

Michael42 ha scritto:

suona bene... Se il supporto include questa assistenza, sono disposto a pagare l'importo anche senza questo cavo. Suppongo che sia possibile utilizzare anche i classici sniffer con l'Arduino e un adattatore TTLUSB. Acquisterò un cavo da voi la prossima settimana. Grazie ancora per il tuo impegno. Sei stato molto gentile. Era corretto quello che ho detto riguardo alle mascherine e ai filtri? Secondo quello che ho sentito, i produttori stanno pianificando di implementare un CAN crittografato in futuro... ma comunque, sconsiglio a tutti di acquistare auto nuove. Sono una vera porcheria. Catena di distribuzione posteriore, tra motore e cambio... cinghie di distribuzione immerse nell'olio... cilindri senza manicotti... frizioni del cambio DSG che durano solo 50.000 km. Ormai, nelle strade, c'è solo rottame.*kopfschüttel*

Un'interfaccia USB non funziona con una porta seriale Rx/Tx, né sul lato USB (host) né sul lato dispositivo USB, indipendentemente da quanti adattatori si utilizzino.
Una missione destinata al fallimento.

L'interfaccia USB CAN è progettata per essere utilizzata con un PC o un laptop. Consultare i requisiti di sistema nella descrizione del prodotto.

Non ho assolutamente detto o inteso questo. Incomprensione...

La mia domanda era se fosse possibile collegare i pin CAN High/Low ai pin RX/TX del CH340 e poi intercettare il traffico del bus tramite un analizzatore CAN, oppure utilizzando il cavo Rosstech. Questa era la mia intenzione. Se il vostro cavo è più adatto, allora sarà così. Secondo me, nella maggior parte dei cavi diagnostici vengono utilizzati chip FTDI.

L'ho scritto in modo abbastanza gentile. Ti mancano le basi. Voglio dire, la scheda tecnica del MCP, cosa vuoi di più?

Qui ci sono tutte le informazioni necessarie sull'IC.

Sono felice di aiutare, ma da parte tua sarebbe opportuno mostrare un po' più di umiltà. L'affermazione di voler ricevere supporto (inteso come aiuto didattico) per l'elettronica e lo sviluppo con un'interfaccia USB è un po' strana. Formulato con estrema cautela.

Con il tuo Arduino, non era incluso un corso di programmazione.

Mi stai capendo male di nuovo: apprezzo e rispetto il vostro aiuto. E vi sono molto grato per la vostra assistenza. Non volevo sembrare ingrato. Mi dispiace.

Ho già letto il programma di autoapprendimento di Audo 286 per capire come è strutturato un messaggio CAN. Tuttavia, non ho studiato informatica e credo che non ne abbia bisogno per il mio progetto. Per questo, si sarebbe potuto semplicemente spiegare che...

Una maschera non è altro che un "filtro a bit", e ogni filtro successivo filtra semplicemente gli ID dei CAN. In sintesi, è possibile lasciare passare un determinato byte senza modifiche, oppure modificare l'intero identificativo CAN.
Ho acquisito tutte le mie conoscenze su C++ e Arduino attraverso internet e l'intelligenza artificiale, e fin dall'inizio cerco sempre di seguire e comprendere il codice, perché è così che si impara. Prima, senza l'intelligenza artificiale, sarebbe stato impossibile imparare tutto da soli a casa in un tempo ragionevole.

Con CH340 intendevo l'adattatore USB-TTL. Lo uso per la comunicazione seriale, ad esempio per configurare il Neo6m tramite l'U Center. Non ho ancora capito da dove provengono gli identificativi (PID). Cioè, tramite Arduino, vedo i dati grezzi sul CAN? E gli identificativi sono definiti tramite il protocollo del bus, a cui si può accedere solo se si dispone dell'hardware appropriato? Comunque, lo trovo tutto molto interessante e voglio imparare tutto sul CAN bus, perché voglio padroneggiarlo e lo trovo interessante. Il traffico che arriva all'Arduino è in ingresso seriale. Esatto. Purtroppo, non riesco a elaborarlo ulteriormente tramite un analizzatore di protocollo. Ho già provato Vcan e Slcan, cercando semplicemente di reindirizzare i dati seriali a Vcan. Sono riuscito anche io a farlo funzionare e a ricevere dati, ma non venivano più visualizzati gli ID CAN e l'output mostrava solo "leng" e numeri a una cifra. Naturalmente, la velocità di trasmissione e le altre impostazioni sono state configurate correttamente.

Hai perfettamente ragione riguardo all'intelligenza artificiale. Questo strumento commette un sacco di errori. Ma quando non capisco qualcosa, lo attivo e mi spiega il codice, e finora ho capito ogni codice. Prima, non avrei mai capito cosa fosse un array o una stringa, o un carattere, ecc. Però, finora, mi è sembrato molto interessante e vorrei approfondire l'argomento per hobby. Ho anche il diploma di maturità e ho studiato all'università, ma mi piace semplicemente riparare le auto. Ho studiato giurisprudenza per 7 semestri e, prima di questo, ho frequentato una scuola professionale per meccanici automobilistici, conseguendo il diploma.

Le interfacce VCDS non sono adatte per l'accesso diretto al bus, non perché l'hardware non lo permetterebbe, ma perché il software e i driver sono progettati per un pubblico diverso.

Cosa intendi con CH340?

Il tuo codice sorgente sembra già essere progettato per stampare il traffico di dati sulla porta seriale.

Citazione:

ID: 2A0 Dati: 00 00 00 00 00 00 30 30

Beh, alla fine ce l'abbiamo fatta.
0x2a0 è l'ID CAN, quindi quale messaggio. E poi, dopo, si trovano gli 8 byte di dati di ogni messaggio.

0x280 non è incluso nella tua risposta. Il comando 0x280 viene inviato dalla centralina motore (modelli VAG), non da una centralina motore VW/Audi/Seat/Skoda, e non corrisponde al comando 0x280.

PID: altro banco prova, probabilmente OBD2.

ChatGPT: produce codice discutibile e di scarsa utilità. La funzione inversa del codice esistente funziona bene.

Devi capire cosa sta succedendo e farlo da solo. Quando chiedi a ChatGPT come sta, è come chiedere a qualcuno seduto in tribuna allo stadio cosa ha sbagliato il campione del mondo.

Non si può imparare a sciare da qualcuno che ha solo visto tutte le gare di sci in televisione e ora fantastica, con convinzione, su come diventare campione del mondo.

Ho ancora un problema: sono riuscito a far funzionare il can tool con l'ESP32 e il MCP2515, ma il CAN bus viene letto solo all'inizio, durante l'inizializzazione. Successivamente, non vengono più ricevuti aggiornamenti. Ho provato a collegare i pin INT a 34, 36 e 39 nel codice, ma senza successo. Nel file can tool.h, ho modificato la frequenza di clock a 8 MHz.

Dato che il codice è scritto per Arduino e per il CanShield, devo apportare alcune modifiche per farlo funzionare con l'ESP32? Grazie per il vostro impegno.

Ecco il testo tradotto:

"Ho utilizzato il seguente codice:"

Codice:

#include <can> #include <mcp2515> #include <can tool> #include <CanHackerLineReader> #include <lib> #include <SPI> const int SPI_CS_PIN = 5; const int INT_PIN = 32; CanHackerLineReader *lineReader = NULL; can tool *can tool = NULL; void setup() {     Serial.begin(115200);     SPI.begin();         can tool = new can tool(&Serial, NULL, SPI_CS_PIN);     lineReader = new CanHackerLineReader(can tool);         pinMode(INT_PIN, INPUT); } void loop() {     if (digitalRead(INT_PIN) == LOW) {         can tool->processInterrupt();     }     // uncomment that lines for Leonardo, Pro Micro or Esplora     // if (Serial.available()) {     //   lineReader->process();        // } } // serialEvent handler not supported by Leonardo, Pro Micro and Esplora void serialEvent() {     lineReader->process(); }

A quanto ne so io, il codice presuppone che il pin MCP2515 sia portato a livello basso quando vengono ricevuti nuovi dati.

Michael42 ha scritto:

Ho ancora un problema: sono riuscito a farlo funzionare con l'ESP32+mcp2515 come strumento CAN, ma il bus CAN viene letto solo all'inizio, durante l'inizializzazione. Successivamente, non ci sono più aggiornamenti. Ho provato a collegare i pin INT a 34, 36 e 39 nel codice, ma senza successo. Nel file CAN Tool.h, ho modificato la frequenza di clock a 8 MHz. Dato che il codice è scritto per Arduino e per il CanShield, devo apportare alcune modifiche per farlo funzionare con l'ESP32? Grazie per il vostro impegno. Secondo la mia comprensione, il codice presuppone che il pin MCP2515 int venga portato a livello basso quando vengono ricevuti nuovi dati.

Non conosco il CANShild, ma il pin di interrupt deve essere collegato a livello hardware nel punto in cui è definito anche a livello software.
L'MPC ha 3 buffer e finché ci sono dati in questi buffer, il INT è a livello basso.

https://github.com/autowp/arduino-mcp2515

Ieri ho già provato a modificare il codice per farlo funzionare senza l'uso di interi. Il problema (per me) è che nel codice è inclusa la libreria mcp2515.h, ma non viene utilizzata. Non riesco proprio a capire la libreria can tool. Non ho nemmeno trovato una sintassi di riferimento per essa. Nel file can tool.h? Il codice funziona, ma solo una volta. Non capisco l'errore.

Michael42 ha scritto:

Ieri ho provato a modificare il codice senza usare INT. Il problema (per me) è che nel codice è inclusa la libreria `mcp2515.h`, ma non viene utilizzata. Non capisco affatto la libreria CAN Tool. Non ho trovato nemmeno la sintassi per usarla. Nel file `CAN Tool.h`? Il codice funziona, ma solo una volta. Non capisco l'errore.https://github.com/autowp/arduino-mcp2515
Nel post all'inizio si potevano vedere molti frame CAN, come può quindi non arrivare l'IRQ?

È questo davvero il risultato che hai ottenuto con il tuo sistema di test?

Ha mai funzionato? Esiste del codice di esempio specifico per il tuo shield CAN? Assicurati di non mescolare elementi diversi (come il codice di A, lo shield di B, ecc.).

Modifica: Il codice all'inizio è diverso, quindi riprenderei da dove funzionava prima.
E il codice sottostante, dal punto di vista logico, non è effettivamente più intelligente o diverso... nel primo esempio, il pin IRQ è il 34 e, qui sotto, è il 32... se ha funzionato con il 34, è ovvio che il pin 32 sia quello sbagliato.

Penso che prima di tutto tu debba imparare come è strutturata una libreria.
I file .h sono file di intestazione corrispondenti ai file .cpp.

Ho trovato qualcosa, qui viene spiegato in modo molto semplice come funziona.

[url]

Utilizzerei sicuramente l'interrupt, perché è più semplice per te capire quando ci sono dati nel buffer.
Puoi anche far funzionare il sistema senza [/url]https://wolles-elektronikkiste.de/bibliotheken-und-klassen-erstellen-teil-i, ma questo comporta un maggiore carico sul bus SPI, poiché i registri devono essere interrogati continuamente per verificare la presenza di dati.

Come Rainer ha già scritto, a quanto pare all'inizio l'interrupt funzionava.

Prima di iniziare a sperimentare con il CAN direttamente sull'auto, ti consiglio di costruire un piccolo circuito con due Arduino e far comunicare i dati da uno all'altro.
In questo momento, i filtri e le maschere non sono importanti, devi ancora imparare molto.https://github.com/autowp/arduino-mcp2515/blob/master/examples/CAN_read/CAN_read.ino{MARKER}