Protocollo CAN - Sì, possiamo!: 24 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Un altro argomento recentemente suggerito dai follower del mio canale YouTube è stato il protocollo CAN (Controller Area Network), su cui ci concentreremo oggi. È importante spiegare che CAN è un protocollo di comunicazione seriale simultanea. Ciò significa che il sincronismo tra i moduli connessi alla rete viene eseguito rispetto all'inizio di ogni messaggio inviato sul bus. Inizieremo introducendo i concetti di base del protocollo CAN ed eseguire un semplice assemblaggio con due ESP32.

Nel nostro circuito, gli ESP possono fungere sia da Master che da Slave. Puoi avere più microcontrollori che trasmettono contemporaneamente, perché il CAN si occupa della collisione di tutto automaticamente. Il codice sorgente di questo progetto è semplicissimo. Controlla!

Passaggio 1: risorse utilizzate

• Due moduli di ESP WROOM 32 NodeMcu
• Due ricetrasmettitori CAN di WaveShare
• Ponticelli per i collegamenti
• Analizzatore logico per la cattura
• Tre cavi USB per ESP e analizzatore
• 10 metri di doppino intrecciato per fare da bus

Passaggio 2: CAN (Controller Area Network)

• È stato sviluppato da Robert Bosch GmbH negli anni '80 per servire l'industria automobilistica.
• Si è diffuso negli anni grazie alla sua robustezza e flessibilità di implementazione. Viene utilizzato con attrezzature militari, macchine agricole, automazione industriale e degli edifici, robotica e attrezzature mediche.

Passaggio 3: CAN - Funzionalità

• Comunicazione seriale a due fili
• Massimo 8 byte di informazioni utili per frame, con possibile frammentazione
• Indirizzo diretto al messaggio e non al nodo
• Assegnazione della priorità ai messaggi e ritrasmissione dei messaggi "in attesa"
• Capacità effettiva di rilevare e segnalare errori
• Capacità multi-master (tutti i nodi possono richiedere l'accesso al bus)
• Capacità multicast (un messaggio per più destinatari contemporaneamente)
• Velocità di trasferimento fino a 1Mbit/s su bus da 40 metri (riduzione della velocità con aumento della lunghezza delle sbarre)
• Flessibilità di configurazione e introduzione di nuovi nodi (fino a 120 nodi per bus)
• Hardware standard, basso costo e buona disponibilità
• Protocollo regolamentato: ISO 11898

Passaggio 4: circuito utilizzato

Ecco, ho i ricetrasmettitori. Ce n'è uno su ciascun lato e sono collegati da una coppia di fili. Uno è responsabile dell'invio e l'altro della ricezione dei dati.

Passaggio 5: tensioni della linea di trasmissione (rilevamento differenziale)

In CAN, il bit dominante è Zero.

Il rilevamento del differenziale di linea riduce la sensibilità al rumore (EFI)

Passaggio 6: standard CAN e formato frame

Formato standard con identificatore a 11 bit

Passaggio 7: standard CAN e formato frame

Formato esteso con identificatore a 29 bit

Passaggio 8: standard CAN e formato frame

È importante notare che un protocollo calcola già il CRC e invia segnali ACK ed EOF, che sono cose già eseguite dal protocollo CAN. Ciò garantisce che il messaggio inviato non arrivi nel modo sbagliato. Questo perché se dà un problema nel CRC (Redundant Cyclic Check o Redundancy Check), che è lo stesso di una cifra di controllo delle informazioni, verrà identificato dal CRC.

Passaggio 9: quattro tipi di frame (frame)

È importante notare che un protocollo calcola già il CRC e invia segnali ACK ed EOF, che sono cose già eseguite dal protocollo CAN. Ciò garantisce che il messaggio inviato non arrivi nel modo sbagliato. Questo perché se dà un problema nel CRC (Redundant Cyclic Check o Redundancy Check), che è lo stesso di una cifra di controllo delle informazioni, verrà identificato dal CRC.

Quattro tipi di frame (frame)

La trasmissione e la ricezione dei dati nel CAN si basano su quattro tipi di frame. I tipi di frame saranno identificati da variazioni nei bit di controllo o anche da cambiamenti nelle regole di scrittura dei frame per ogni caso.

• Data Frame: contiene i dati del trasmettitore per il/i ricevitore/i
• Remote Frame: questa è una richiesta di dati da uno dei nodi
• Frame di errore: è un frame inviato da uno qualsiasi dei nodi quando si identifica un errore nel bus e può essere rilevato da tutti i nodi
• Overload Frame: Serve per ritardare il traffico sul bus a causa di sovraccarico di dati o ritardo su uno o più nodi.

Passaggio 10: Circuito - Dettagli delle connessioni

Passaggio 11: Circuito - Acquisizione dati

Lunghezze d'onda ottenute per CAN standard con ID a 11 bit

Passaggio 12: Circuito - Acquisizione dati

Lunghezze d'onda ottenute per CAN esteso con ID a 29 bit

Passaggio 13: Circuito - Acquisizione dati

Dati ottenuti dall'analizzatore logico

Passaggio 14: libreria Arduino - CAN

Mostro qui le due opzioni in cui è possibile installare la CAN Driver Library

Gestore libreria IDE Arduino

Passaggio 15: Github

github.com/sandeepmistry/arduino-CAN

Passaggio 16: codice sorgente del trasmettitore

Codice sorgente: include e imposta ()

Includeremo la libreria CAN, avvieremo la seriale per il debug e avvieremo il bus CAN a 500 kbps.

#include //Inclui a biblioteca CAN void setup() { Serial.begin(9600); //inicia a serial para debug while (!Serial); Serial.println("Trasmettitore CAN"); // Inicia o barramento CAN a 500 kbps if (!CAN.begin(500E3)) { Serial.println("Falha ao iniciar o controlador CAN"); //caso não seja possível iniciar o controlador while (1); } }

Passaggio 17: Codice sorgente: Loop (), invio di un pacchetto CAN 2.0 standard

Utilizzando lo standard CAN 2.0, inviamo un pacco. L'ID a 11 bit identifica il messaggio. Il blocco dati deve contenere fino a 8 byte. Inizia il pacchetto con ID 18 in esadecimale. Impacchetta 5 byte e chiude la funzione.

void loop() { // Usando o CAN 2.0 padrão //Envia um pacote: o id tem 11 bits e identifica a mensagem (prioridade, event) //o bloco de dados deve possuir até 8 bytes Serial.println("Enviando pacote …"); CAN.beginPacket(0x12); //id 18 esadecimale CAN.write('h'); //1º byte CAN.write('e'); ///2º byte CAN.write('l'); ///3º byte CAN.write('l'); ///4º byte CAN.write('o'); ///5º byte CAN.endPacket(); //encerra o pacote para envio Serial.println("Enviado."); ritardo(1000);

Passaggio 18: Codice sorgente: Loop (), Invio di un pacchetto CAN 2.0 esteso

In questo passaggio, l'ID ha 29 bit. Inizia a inviare 24 bit di ID e, ancora una volta, impacchetta 5 byte e si chiude.

//Usando CAN 2.0 Estendido //Invia um pacote: o id tem 29 bits e identifica a mensagem (prioridade, evento) //o bloco de dados deve possuir até 8 bytes Serial.println("Enviando pacote estendido…"); CAN.beginExtendedPacket(0xabcdef); //id 11259375 decimale (abcdef esa) = 24 bit preenchidos até aqui CAN.write('w'); //1º byte CAN.write('o'); ///2º byte CAN.write('r'); ///3º byte CAN.write('l'); ///4º byte CAN.write('d'); ///5º byte CAN.endPacket(); //encerra o pacote para envio Serial.println("Enviado."); ritardo(1000); }

Passaggio 19: codice sorgente del ricevitore

Codice sorgente: include e imposta ()

Di nuovo, includeremo la libreria CAN, avvieremo la seriale per il debug e avvieremo il bus CAN a 500 kbps. Se si verifica un errore, questo errore verrà stampato.

#include //Inclui a biblioteca CAN void setup() { Serial.begin(9600); //inicia a serial para debug while (!Serial); Serial.println("Recettore CAN"); // Inicia o barramento CAN a 500 kbps if (!CAN.begin(500E3)) { Serial.println("Falha ao iniciar o controlador CAN"); //caso não seja possível iniciar o controlador while (1); } }

Passaggio 20: codice sorgente: loop (), ottenere il pacchetto e controllare il formato

Abbiamo provato a controllare la dimensione del pacchetto ricevuto. Il metodo CAN.parsePacket() mi mostra la dimensione di questo pacchetto. Quindi, se abbiamo un pacchetto, controlleremo se è esteso o meno.

void loop() { // Tenta verificar o tamanho do acote recebido int packetSize = CAN.parsePacket(); if (packetSize) { // Se temos um pacote Serial.println("Recebido pacote. "); if (CAN.packetExtended()) { //verifica se o pacote é estendido Serial.println("Estendido"); }

Passaggio 21: Sorgente: Loop (), controlla se si tratta di un pacchetto remoto

Qui, controlliamo se il pacchetto ricevuto è una richiesta di dati. In questo caso non ci sono dati.

if (CAN.packetRtr()) { //Verifica se o pacote é um pacote remoto (Requisição de dados), neste caso não há dados Serial.print("RTR "); }

Passaggio 22: codice sorgente: loop (), lunghezza dati richiesta o ricevuta

Se il pacchetto ricevuto è una richiesta, indichiamo la lunghezza richiesta. Otteniamo quindi il Data Length Code (DLC), che indica la lunghezza dei dati. Infine, indichiamo la lunghezza ricevuta.

Serial.print("Pacote com id 0x"); Serial.print(CAN.packetId(), HEX); if (CAN.packetRtr()) { //se o pacote recebido é de requisição, indicamos o comprimento sollecitato Serial.print(" e requsitou o comprimento "); Serial.println(CAN.packetDlc()); //obtem o DLC (Data Length Code, que indica o comprimento dos dados) } else { Serial.print(" e comprimento "); // aqui somente indica o comprimento recebido Serial.println(packetSize);

Passaggio 23: codice sorgente: loop (), se i dati vengono ricevuti, vengono stampati

Stampiamo (sul monitor seriale) i dati, ma solo se il pacchetto ricevuto non è una richiesta.

//Imprimere i dati anche se non è possibile ricevere la richiesta while (CAN.available()) { Serial.print((char)CAN.read()); } Serial.println(); } Serial.println(); } }

Passaggio 24: scarica i file

PDF

IO NO