Come costruire un bus CAN con una breadboard e Arduino

Il bus CAN (Controller Area Network) è un protocollo di comunicazione robusto e affidabile ampiamente utilizzato in varie applicazioni industriali, automobilistiche e aerospaziali. È progettato per la trasmissione di dati tra microcontrollori e dispositivi su una rete CAN bus. Potresti non saperlo ancora, ma è la cosa dietro quelle pazze mod del cruscotto dell'auto che vedi sui social media.

Ti guideremo attraverso come costruire un bus CAN con il modulo CAN MCP2515 utilizzando un Arduino e una breadboard. Esamineremo anche la libreria CAN di Arduino e dimostreremo come inviare e ricevere dati tramite il bus CAN.

Cos'è un bus CAN?

Il bus CAN è un protocollo di comunicazione seriale sviluppato da Bosch negli anni '80. È ampiamente utilizzato in varie applicazioni grazie alla sua elevata affidabilità e robustezza. Consente la trasmissione di dati tra dispositivi ad alta velocità con latenza minima su due sole linee: CAN High e CAN Low.

Nel 1994, il bus CAN è diventato uno standard internazionale (ISO 11898) progettato specificamente per lo scambio rapido di dati seriali tra controller elettronici nelle applicazioni automobilistiche. Consulta la nostra guida completa su cos'è un bus CAN e che ruolo svolge nei sistemi automobilistici per maggiori dettagli.

Uno dei motivi per cui il bus CAN è così popolare è dovuto alle sue funzioni di rilevamento e correzione degli errori. Il protocollo può rilevare e correggere errori nella trasmissione dei dati. Ciò lo rende ideale per le applicazioni in cui l'integrità dei dati è fondamentale, come nell'automazione industriale.

Conoscere il modulo CAN MCP2515

Il modulo MCP2515 CAN Bus Controller è un dispositivo che fornisce un supporto eccezionale per il protocollo CAN ampiamente utilizzato versione 2.0B. Questo modulo è ideale per la comunicazione a velocità dati elevate fino a 1 Mbps.

L'IC MCP2515 è un controller CAN indipendente con un'interfaccia SPI che consente la comunicazione con un'ampia gamma di microcontrollori. L'IC TJA1050, invece, funge da interfaccia tra l'IC del controller CAN MCP2515 e il bus CAN fisico.

Per maggiore praticità, è presente un ponticello che consente di collegare una terminazione da 120 ohm, rendendo ancora più semplice il collegamento dei cavi al CAN_H & POSSO viti per la comunicazione con altri moduli CAN.

È possibile ottenere ulteriori informazioni dal Scheda tecnica MCP2515 nel caso abbiate bisogno di questo modulo per un progetto più avanzato.

Struttura dei messaggi CAN

La struttura del messaggio CAN è composta da più segmenti, ma i segmenti più critici per questo progetto sono l'identificatore e i dati. L'identificatore, noto anche come CAN ID o Parameter Group Number (PGN), identifica i dispositivi sulla CAN rete e la lunghezza dell'identificatore può essere di 11 o 29 bit, a seconda del tipo di protocollo CAN usato.

Nel frattempo, i dati rappresentano i dati effettivi del sensore/controllo trasmessi. I dati possono avere una lunghezza compresa tra 0 e 8 byte e il codice di lunghezza dei dati (DLC) indica il numero di byte di dati presenti.

La libreria bus CAN Arduino MCP2515

Questa libreria implementa il Protocollo CAN V2.0B, che può funzionare a velocità fino a 1 Mbps. Fornisce un'interfaccia SPI che può funzionare a velocità fino a 10 MHz supportando sia dati standard (11 bit) che estesi (29 bit). Inoltre, viene fornito con due buffer di ricezione, che consentono l'archiviazione prioritaria dei messaggi.

Inizializzazione del bus CAN

Ecco il codice di configurazione necessario per inizializzare il bus CAN:

#includere
#includere
MCP2515 mcp2515(10); // Imposta il pin CS
vuotoimpostare(){
Mentre (!Seriale);
Seriale.inizio(9600);
SPI.inizio(); //Inizia la comunicazione SPI
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}

Ciò inizializza l'MCP2515 con un bit rate CAN di 500 Kbps e una frequenza dell'oscillatore di 8 MHz.

MCP2515 Modalità operative CAN

Esistono tre modalità operative utilizzate con il controller del bus CAN MCP2515:

• setNormalMode(): imposta il controller per inviare e ricevere messaggi.
• setLoopbackMode(): imposta il controller per inviare e ricevere messaggi, ma anche i messaggi che invia verranno ricevuti da solo.
• setListenOnlyMode(): imposta il controller in modo che riceva solo messaggi.

Si tratta di chiamate di funzione utilizzate per impostare la modalità operativa del controller del bus CAN MCP2515.

mcp2515.setNormalMode();

mcp2515.setLoopbackMode();

mcp2515.setListenOnlyMode();

Invio di dati tramite il bus CAN

Per inviare un messaggio tramite il bus CAN, utilizzare il inviaMsgBuf() metodo:

non firmatochar dati[] = {0x01, 0x02, 0x03, 0x04};
CAN.sendMsgBuf(0x01, 0, 4, dati);

Questo invia un messaggio con l'ID 0x01 e un carico utile di dati di {0x01, 0x02, 0x03, 0x04}. Il primo parametro è l'ID CAN, il secondo è la priorità del messaggio, il terzo è la lunghezza del payload dei dati e il quarto è il payload dei dati stesso.

IL inviaMsgBuf() Il metodo restituisce un valore che indica se il messaggio è stato inviato correttamente o meno. Puoi controllare questo valore chiamando il metodo verificaErrore() metodo:

Se (CAN.checkError()) {
Seriale.println("Errore durante l'invio del messaggio.");
}

Questo controlla se si è verificato un errore durante la trasmissione del messaggio e se necessario stampa un messaggio di errore.

Ricezione di dati dal bus CAN

Per ricevere un messaggio sul bus CAN, è possibile utilizzare il leggiMsgBuf() metodo:

non firmatochar len = 0;
non firmatochar buf[8];
non firmatochar canID = 0;
Se (CAN.checkReceive()) {
 CAN.readMsgBuf(&len, buf);
 canID = CAN.getCanId();
}

Questo controlla se un messaggio è disponibile sul bus CAN e quindi legge il messaggio nel buf vettore. La lunghezza del messaggio è memorizzata nel file len variabile e l'ID del messaggio è memorizzato nella canID variabile.

Dopo aver ricevuto un messaggio, è possibile elaborare il payload dei dati secondo necessità. Ad esempio, è possibile stampare il payload dei dati sul monitor seriale:

Seriale.stampa("Messaggio ricevuto con ID");
Seriale.stampa(canID, HEX);
Seriale.stampa(" e dati: ");
per (int io = 0; io < lente; i++) {
Seriale.stampa(buf[i], HEX);
Seriale.stampa(" ");
}
Seriale.println();

Questo stampa l'ID del messaggio ricevuto e il payload dei dati sul monitor seriale.

Come collegare un ricetrasmettitore bus CAN a una breadboard

Per costruire un bus CAN per connettere due dispositivi in ​​questo progetto di esempio, avrai bisogno di:

• Due microcontrollori (due schede Arduino Nano per questo esempio)
• Due moduli CAN MCP2515
• Una tagliere
• Fili di ponticello
• Un modulo schermo LCD I2C 16x2
• Sensore a ultrasuoni HC-SR04

Per questo esempio di progetto, vengono utilizzate quattro librerie nello sketch Arduino. C'è il Nuovo Ping libreria, che fornisce un'interfaccia di facile utilizzo per il sensore a ultrasuoni, nonché il Libreria SPI, che facilita la comunicazione tra la scheda Arduino e il controller del bus CAN MCP2515. IL LiquidCrystal_I2C library viene utilizzata per il modulo display.

Infine, c'è il libreria mcp2515 per interfacciarsi con il chip MCP2515, permettendoci di trasmettere facilmente i dati sulla rete CAN bus.

Configurazione hardware (esempio HC-SR04)

In questo progetto che utilizza un sensore HC-SR04 e un LCD, una scheda Arduino Nano fungerà da ricevitore, mentre l'altra Arduino fungerà da mittente. Collegare i componenti dell'emettitore in base allo schema elettrico seguente:

Ecco lo schema per il circuito del ricevitore:

Infine, collega i due nodi insieme usando il CAN_H E POSSO linee come mostrato:

Quando si collegano i moduli, è importante assicurarsi che la tensione di alimentazione rientri nell'intervallo specificato e che il CAN H E POSSO i pin siano correttamente collegati al bus.

Programmazione del modulo CAN Bus MCP2515

Si noti che durante la programmazione del modulo MCP2515, è importante utilizzare il bit rate corretto per garantire una comunicazione corretta con altri dispositivi CAN sulla rete.

Codice mittente:

#includere
#includere
#includere
MCP2515 mcp2515(10);
costbyte trigPin = 3;
costbyte echoPin = 4;
Nuovo Ping sonar(trigPin, ecoPin, 200);
structcan_framecanMsg;
vuotoimpostare(){
Seriale.inizio(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}
vuotociclo continuo(){
non firmatoint distanza = sonar.ping_cm();
 canMsg.can_id = 0x036; // ID CAN come 0x036
 canMsg.can_dlc = 8; //Lunghezza dati CAN come 8
 canMsg.data[0] = distanza; //Aggiorna il valore di umidità in [0]
 canMsg.data[1] = 0x00; //Resta tutto con 0 
 canMsg.data[2] = 0x00;
 canMsg.data[3] = 0x00;
 canMsg.data[4] = 0x00;
 canMsg.data[5] = 0x00;
 canMsg.data[6] = 0x00;
 canMsg.data[7] = 0x00;
 mcp2515.sendMessage(&canMsg);//Invia il messaggio CAN
ritardo(100);
}

Codice ricevitore:

#includere
#includere
#includere
MCP2515 mcp2515(10);
LiquidCrystal_I2C lcd(0x27,16,2);
structcan_framecanMsg;
vuotoimpostare(){
Seriale.inizio(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
 lcd.init();
 lcd.retroilluminazione();
 lcd.setCursore(0, 0);
 lcd.stampa("MUO CAN TUTORIAL");
ritardo(3000);
 lcd.chiaro();
}
vuotociclo continuo(){
Se (mcp2515.readMessage(&canMsg) == MCP2515::ERROR_OK) // Per ricevere dati
 {
int distanza = canMsg.data[0];
 lcd.setCursore(0,0);
 lcd.stampa("Distanza: ");
 lcd.stampa(distanza);
 lcd.stampa("cm ");
 }
}

Porta i tuoi progetti Arduino al livello successivo

La combinazione di CAN bus e Arduino fornisce una potente piattaforma per la creazione o l'apprendimento di sofisticate reti di comunicazione utilizzate in varie applicazioni. Sebbene possa sembrare una curva di apprendimento ripida, avere la propria configurazione su una breadboard è un modo abbastanza pratico per imparare le basi dell'utilizzo di una rete CAN bus in complessi progetti fai-da-te.