Arduino CAN-Bus Problem

[Roger K. (Firma: privat) (chasperli)]

Hallo zusammen

Ich beschäftige mich seit geraumer Zeit mit dem Thema Arduino und dem 
CAN-Bus. Mein Ziel ist es, eigene Komponenten für die Märklin 
Modelleisenbahn herzustellen.
Den CAN-Bus habe ich mit einem MCP2515 und einem MCP2551 zum laufen 
gebracht. Ich kann Meldungen versenden und empfangen. und die gesendeten 
Meldungen kommen auch auf der CS2 von Märklin an. Getestet habe ich 
dies, indem ich jede Sekunde eine Meldung gesendet habe und geschaut 
habe, was auf der CS2 ankommt.
Jetzt habe ich aber leider das Problem, dass wenn ich viele Meldungen 
senden muss, diese nicht alle versendet werden, wenn von der CS2 
ebenfalls Meldungen gesendet werden.
Kann es sein, dass es auf dem CAN-Bus Kollisionen gibt und die Meldungen 
verloren gehen?
Was passiert, wenn ich empfangene Meldungen nicht vom MCP2515 lade?

Wenn die CS2 Von Märklin nicht an den CAN-Bus angeschlossen ist, werden 
alle Meldungen vom Arduino versendet und ich kann diese mit einem 
zweiten Arduino empfangen.

Gruss Chasperli

[Karl H. (kbuchegg)]

Roger Kreienbühl schrieb:

> Kann es sein, dass es auf dem CAN-Bus Kollisionen gibt und die Meldungen
> verloren gehen?

Kollisionen kann und wird es natürlich geben.
Ob die verloren gehen oder nicht, hängt von deinen unbekannten 
CAN-Routinen ab bzw. wie dein Programm mit einem gemeldeten 
Arbitrierungsfehler umgeht.

> Was passiert, wenn ich empfangene Meldungen nicht vom MCP2515 lade?

Was sagt das Datenblatt zum MCP2515 zu diesem Fall?

[asd (Gast)]

Gibt's keine Funktion:

detect_collision()

?

[R. F. (rfr)]

hallo,

es gibt Kollisionen. Hierbei wird die höher poriorisierte Nachricht 
überleben, die niederpriorisierte Nachricht nicht. Das ist aber ein 
Kennkriterium des CAN-Busses und nicht änderbar.

Wenn deine Mailbox im Can Receiver zu lange verbleibt, wird sie von der 
nächsten Nachricht überschrieben. Aus diesem Grund sind die Mailboxen in 
der Lage, einen Interrupt auszulösen. Die anhängende ISR sollte diese 
Nachricht in eine messageInputQueue kopieren, wo sie dann ausgewertet 
werden kann.

Gruss

Robert

[Roger K. (Firma: privat) (chasperli)]

Hallo

Ich nutze die Canduino Library von 
http://www.daedalus.ei.tum.de/index.php/de/dokumentation/projekte/komm-struktur/canduino
Anhand des Beispielcodes habe ich dann mein Programm gesschrieben. Die 
Library habe ich erweitert, damit auch Extended Identfier benutzt werden 
können.
Zudem habe ich eine zusätzliche Funktion geschrieben, welche jenachdem 
über den ersten freien Buffer versendet. Die Library habe ich in RMDuino 
umbenannt.
Leider bin ich noch nicht sehr bewandert was das "interpretieren" von 
Datenblättern angeht.

Hier mein Code:

#include <RMDuino.h>
#include <SPI.h>

#define BUS_SPEED 250

#define belegt 1
#define frei 0

int rmpin[] = {3, 4, 5};
int rmvalue[] = {0, 0, 0};
int rmstatus[] = {frei, frei, frei};

int ledpin[] = {3, 4, 5};

byte frame_id[4];

byte length = 8;


int modulno = 0;


void setup() {
  Serial.begin(9600);
  
  pinMode(ledpin[0], OUTPUT);
  pinMode(ledpin[1], OUTPUT);
  pinMode(ledpin[2], OUTPUT);
  
  digitalWrite(ledpin[0], LOW);
  digitalWrite(ledpin[1], LOW);
  digitalWrite(ledpin[2], LOW);
  
  frame_id[0] = 0x01;
  frame_id[1] = 0x0B;
  frame_id[2] = 0x73;
  frame_id[3] = 0x30;
  
  CAN.begin();
  CAN.baudConfig(BUS_SPEED);
  CAN.setMode(NORMAL);  
  
  //Warte 5 Sekunden damit auch hochgeladen werden kann,
 // wenn die vorherige Iteration den Serial Port zuspammt
 
  delay(5000);

}

void loop() {
  
  for (int c=0; c<3; c++) {
    
    rmvalue[c] = analogRead(rmpin[c]);
  }
  
  for (int c=0; c<3; c++) {
    if (rmvalue[c] < 100 && rmstatus[c] == frei) {
         digitalWrite(ledpin[c], HIGH);
      
        sendStatusChange(modulno, c, 1);

        rmstatus[c] = belegt;
      }
    
      else if (rmvalue[c] >= 900 && rmstatus[c] == belegt) {
        digitalWrite(ledpin[c], LOW);
      
        sendStatusChange(modulno, c, 0);

        rmstatus[c] = frei;
      }
    
  }

}


void sendStatusChange(int modul, int pin, bool newstate) {

  int rmnumber = ((modul * 16) + pin +1);
  
  byte low = (byte)(rmnumber & 0xff);
  byte high = (byte)((rmnumber >> 8) & 0xff);
  
  byte frame_data[8];
  
  frame_data[0] = 0x00;
  frame_data[1] = 0x00;
  frame_data[2] = high;
  frame_data[3] = low;
  
  switch(newstate) {
    case frei:
      frame_data[4] = 0x01;
      frame_data[5] = 0x00;
      break;
    
    case belegt:
      frame_data[4] = 0x00;
      frame_data[5] = 0x01;
      break;
  }
  
  frame_data[6] = 0x00;
  frame_data[7] = 0x00;

  CAN.load_and_send(length,frame_id,frame_data);
  
  
}

RMDuino.h:

#include <SPI.h>

/*
Created by: Kyle Crockett
For canduino with 16MHz oscillator.
CNFx register values.
use preprocessor command "_XXkbps" 
"XX" is the baud rate.

10 kbps
CNF1/BRGCON1    b'00110001'     0x31
CNF2/BRGCON2    b'10111000'     0xB8
CNF3/BRGCON3    b'00000101'     0x05

20 kbps
CNF1/BRGCON1    b'00011000'     0x18
CNF2/BRGCON2    b'10111000'     0xB8
CNF3/BRGCON3    b'00000101'     0x05

50 kbps
CNF1/BRGCON1    b'00001001'     0x09
CNF2/BRGCON2    b'10111000'     0xB8
CNF3/BRGCON3    b'00000101'     0x05

100 kbps
CNF1/BRGCON1    b'00000100'     0x04
CNF2/BRGCON2    b'10111000'     0xB8
CNF3/BRGCON3    b'00000101'     0x05

125 kbps
CNF1/BRGCON1    b'00000011'     0x03
CNF2/BRGCON2    b'10111000'     0xB8
CNF3/BRGCON3    b'00000101'     0x05

250 kbps
CNF1/BRGCON1    b'00000001'     0x01
CNF2/BRGCON2    b'10111000'     0xB8
CNF3/BRGCON3    b'00000101'     0x05

500 kbps
CNF1/BRGCON1    b'00000000'     0x00
CNF2/BRGCON2    b'10111000'     0xB8
CNF3/BRGCON3    b'00000101'     0x05

800 kbps
Not yet supported

1000 kbps
Settings added by Patrick Cruce(pcruce_at_igpp.ucla.edu)
CNF1=b'10000000'=0x80 = SJW = 3 Tq. & BRP = 0
CNF2=b'10010000'=0x90 = BLTMode = 1 & SAM = 0 & PS1 = 3 & PR = 1
CNF3=b'00000010'=0x02 = SOF = 0  & WAKFIL = 0 & PS2 = 3

*/
#ifndef can_h
#define can_h

#define SCK 13 //spi
#define MISO 12
#define MOSI 11
#define SS 10
#define RESET 2//reset pin

#define RESET_REG 0xc0  
#define READ 0x03 
#define WRITE 0x02 //read and write comands for SPI

#define READ_RX_BUF_0_ID 0x90
#define READ_RX_BUF_0_DATA 0x92
#define READ_RX_BUF_1_ID 0x94
#define READ_RX_BUF_1_DATA 0x96 //SPI commands for reading CAN RX buffers

#define LOAD_TX_BUF_0_ID 0x40
#define LOAD_TX_BUF_0_DATA 0x41
#define LOAD_TX_BUF_1_ID 0x42
#define LOAD_TX_BUF_1_DATA 0x43
#define LOAD_TX_BUF_2_ID 0x44
#define LOAD_TX_BUF_2_DATA 0x45 //SPI commands for loading CAN TX buffers

#define SEND_TX_BUF_0 0x81
#define SEND_TX_BUF_1 0x82
#define SEND_TX_BUF_2 0x83 //SPI commands for transmitting CAN TX buffers

#define READ_STATUS 0xA0
#define RX_STATUS 0xB0
#define BIT_MODIFY 0x05 //Other commands


//Registers
#define CNF0 0x2A
#define CNF1 0x29
#define CNF2 0x28
#define TXB0CTRL 0x30 
#define TXB1CTRL 0x40
#define TXB2CTRL 0x50 //TRANSMIT BUFFER CONTROL REGISTER
#define TXB0DLC 0x35 //Data length code registers
#define TXB1DLC 0x45
#define TXB2DLC 0x55
#define CANCTRL 0x0F //Mode control register
#define CANSTAT 0x0E //Mode status register

#include "Arduino.h"

enum CANMode {CONFIGURATION,NORMAL,SLEEP,LISTEN,LOOPBACK};

class CANClass
{
private:

public:
        static void begin();//sets up MCP2515
        static void baudConfig(int bitRate);//sets up baud

        //Method added to enable testing in loopback mode.(pcruce_at_igpp.ucla.edu)
        static void setMode(CANMode mode) ;//put CAN controller in one of five modes

        static void send_0();//request to transmit buffer X
        static void send_1();
        static void send_2();

        static char readID_0();//read ID/DATA of recieve buffer X
        static char readID_1();

        static char readDATA_0();
        static char readDATA_1();

        //extending CAN data read to full frames(pcruce_at_igpp.ucla.edu)
        //data_out should be array of 8-bytes or frame length.
        static void readDATA_ff_0(byte* length_out,byte *data_out,byte *id_out);
        static void readDATA_ff_1(byte* length_out,byte *data_out,byte *id_out);

        //Adding can to read status register(pcruce_at_igpp.ucla.edu)
        //can be used to determine whether a frame was received.
        //(readStatus() & 0x80) == 0x80 means frame in buffer 0
        //(readStatus() & 0x40) == 0x40 means frame in buffer 1
        static byte readStatus();

        static void load_0(byte identifier, byte data);//load transmit buffer X
        static void load_1(byte identifier, byte data);
        static void load_2(byte identifier, byte data);

        //extending CAN write to full frame(pcruce_at_igpp.ucla.edu)
        //Identifier should be a value between 0 and 2^11-1, longer identifiers will be truncated(ie does not support extended frames)
        static void load_ff_0(byte length,byte *identifier,byte *data);
        static void load_ff_1(byte length,byte *identifier,byte *data);
        static void load_ff_2(byte length,byte *identifier,byte *data);
    
        static void load_and_send(byte length,byte *identifier,byte *data);

};
extern CANClass CAN;
#endif

RMDuino.cpp:

#include <SPI.h>
#include "Arduino.h"
#include "RMDuino.h"

CANClass CAN;//create can object

void CANClass::begin()//constructor for initializing can module.
{
        // set the slaveSelectPin as an output 
        pinMode (SCK,OUTPUT);
        pinMode (MISO,INPUT);
        pinMode (MOSI, OUTPUT);
        pinMode (SS, OUTPUT);
        pinMode(RESET,OUTPUT);

        // initialize SPI:
        SPI.begin(); 
        SPI.setDataMode(SPI_MODE0);
        SPI.setClockDivider(SPI_CLOCK_DIV4);
        SPI.setBitOrder(MSBFIRST);

        digitalWrite(RESET,LOW); /* RESET CAN CONTROLLER*/
        delay(10);
        digitalWrite(RESET,HIGH);
        delay(100);
}

void CANClass::baudConfig(int bitRate)//sets bitrate for CAN node
{
        byte config0, config1, config2;

        switch (bitRate)
        {
case 10:
                config0 = 0x31;
                config1 = 0xB8;
                config2 = 0x05;
                break;

case 20:
                config0 = 0x18;
                config1 = 0xB8;
                config2 = 0x05;
                break;

case 50:
                config0 = 0x09;
                config1 = 0xB8;
                config2 = 0x05;
                break;

case 100:
                config0 = 0x04;
                config1 = 0xB8;
                config2 = 0x05;
                break;

case 125:
                config0 = 0x03;
                config1 = 0xB8;
                config2 = 0x05;
                break;

case 250:
                config0 = 0x01;
                config1 = 0xB8;
                config2 = 0x05;
                break;

case 500:
                config0 = 0x00;
                config1 = 0xB8;
                config2 = 0x05;
                break;
case 1000:
        //1 megabit mode added by Patrick Cruce(pcruce_at_igpp.ucla.edu)
        //Faster communications enabled by shortening bit timing phases(3 Tq. PS1 & 3 Tq. PS2) Note that this may exacerbate errors due to synchronization or arbitration.
        config0 = 0x80;
        config1 = 0x90;
        config2 = 0x02;
        }
        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer(WRITE);
        SPI.transfer(CNF0);
        SPI.transfer(config0);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);

        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer(WRITE);
        SPI.transfer(CNF1);
        SPI.transfer(config1);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);

        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer(WRITE);
        SPI.transfer(CNF2);
        SPI.transfer(config2);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);
}

//Method added to enable testing in loopback mode.(pcruce_at_igpp.ucla.edu)
void CANClass::setMode(CANMode mode) { //put CAN controller in one of five modes

        byte writeVal,mask,readVal;

        switch(mode) {
        case CONFIGURATION:
                        writeVal = 0x80;
                        break;
        case NORMAL:
                  writeVal = 0x00;
                        break;
        case SLEEP:
                        writeVal = 0x20;
                break;
    case LISTEN:
                        writeVal = 0x60;
                break;
        case LOOPBACK:
                        writeVal = 0x40;
                break;
   }

        mask = 0xE0;

        digitalWrite(SS, LOW);
        SPI.transfer(BIT_MODIFY);
        SPI.transfer(CANCTRL);
        SPI.transfer(mask);
        SPI.transfer(writeVal);
        digitalWrite(SS, HIGH);

}


void CANClass::send_0()//transmits buffer 0
{

        //delays removed from SEND command(pcruce_at_igpp.ucla.edu)
        //In testing we found that any lost data was from PC<->Serial Delays,
        //Not CAN Controller/AVR delays.  Thus removing the delays at this level
        //allows maximum flexibility and performance.
        digitalWrite(SS, LOW);
        SPI.transfer(SEND_TX_BUF_0);
        digitalWrite(SS, HIGH);
}

void CANClass::send_1()//transmits buffer 1
{
        digitalWrite(SS, LOW);
        SPI.transfer(SEND_TX_BUF_1);
        digitalWrite(SS, HIGH);
}

void CANClass::send_2()//transmits buffer 2
{
        digitalWrite(SS, LOW);
        SPI.transfer(SEND_TX_BUF_2);
        digitalWrite(SS, HIGH);
}

char CANClass::readID_0()//reads ID in recieve buffer 0
{
        char retVal;
        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer(READ_RX_BUF_0_ID);
        retVal = SPI.transfer(0xFF);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);
        return retVal;
}

char CANClass::readID_1()//reads ID in reciever buffer 1
{
        char retVal;
        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer(READ_RX_BUF_1_ID);
        retVal = SPI.transfer(0xFF);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);
        return retVal;
}

char CANClass::readDATA_0()//reads DATA in recieve buffer 0
{
        char retVal;
        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer( READ_RX_BUF_0_DATA);
        retVal = SPI.transfer(0xFF);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);
        return retVal;
}

char CANClass::readDATA_1()//reads data in recieve buffer 1
{
        char retVal;
        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer( READ_RX_BUF_1_DATA);
        retVal = SPI.transfer(0xFF);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);
        return retVal;
}

        //extending CAN data read to full frames(pcruce_at_igpp.ucla.edu)
        //It is the responsibility of the user to allocate memory for output.
        //If you don't know what length the bus frames will be, data_out should be 8-bytes
void CANClass::readDATA_ff_0(byte* length_out,byte *data_out,byte *id_out){

        byte len,i;
        unsigned short id_h,id_l;

        digitalWrite(SS, LOW);
        SPI.transfer(READ_RX_BUF_0_ID);
        id_out[0] = SPI.transfer(0xFF); //id high
        id_out[1] = SPI.transfer(0xFF); //id low
        id_out[2] = SPI.transfer(0xFF); //extended id high(unused)
        id_out[3] = SPI.transfer(0xFF); //extended id low(unused)
        len = (SPI.transfer(0xFF) & 0x0F); //data length code
        for (i = 0;i<len;i++) {
                data_out[i] = SPI.transfer(0xFF);
        }
        digitalWrite(SS, HIGH);
        (*length_out) = len;
        //(*id_out) = ((id_h << 3) + ((id_l & 0xE0) >> 5)); //repack identifier
        
}

void CANClass::readDATA_ff_1(byte* length_out,byte *data_out,byte *id_out){

        byte id_h,id_l,len,i;

        digitalWrite(SS, LOW);
        SPI.transfer(READ_RX_BUF_1_ID);
        id_out[0] = SPI.transfer(0xFF); //id high
        id_out[1] = SPI.transfer(0xFF); //id low
        id_out[2] = SPI.transfer(0xFF); //extended id high(unused)
        id_out[3] = SPI.transfer(0xFF); //extended id low(unused)
        len = (SPI.transfer(0xFF) & 0x0F); //data length code
        for (i = 0;i<len;i++) {
                data_out[i] = SPI.transfer(0xFF);
        }
        digitalWrite(SS, HIGH);

        (*length_out) = len;
        //(*id_out) = ((((unsigned short) id_h) << 3) + ((id_l & 0xE0) >> 5)); //repack identifier
}

        //Adding method to read status register
        //can be used to determine whether a frame was received.
        //(readStatus() & 0x80) == 0x80 means frame in buffer 0
        //(readStatus() & 0x40) == 0x40 means frame in buffer 1
byte CANClass::readStatus() 
{
        byte retVal;
        digitalWrite(SS, LOW);
        SPI.transfer(READ_STATUS);
        retVal = SPI.transfer(0xFF);
        digitalWrite(SS, HIGH);
        return retVal;

}

void CANClass::load_0(byte identifier, byte data)//loads ID and DATA into transmit buffer 0
{
        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer(LOAD_TX_BUF_0_ID);
        SPI.transfer(identifier);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);

        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer(LOAD_TX_BUF_0_DATA);
        SPI.transfer(data);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);
}

void CANClass::load_1(byte identifier, byte data)//loads ID and DATA into transmit buffer 1
{
        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer(LOAD_TX_BUF_1_ID);
        SPI.transfer(identifier);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);

        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer(LOAD_TX_BUF_1_DATA);
        SPI.transfer(data);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);
}

void CANClass::load_2(byte identifier, byte data)//loads ID and DATA into transmit buffer 2
{
        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer(LOAD_TX_BUF_2_ID);
        SPI.transfer(identifier);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);

        digitalWrite(SS, LOW);
        delay(10);
        SPI.transfer(LOAD_TX_BUF_2_DATA);
        SPI.transfer(data);
        delay(10);
        digitalWrite(SS, HIGH);
        delay(10);
}

void CANClass::load_ff_0(byte length,byte *identifier,byte *data)
{
        
        byte i,id_high,id_low;

        //generate id bytes before SPI write
        // id_high = (byte) (identifier >> 3);
        // id_low = (byte) ((identifier << 5) & 0x00E0);

        digitalWrite(SS, LOW);
        SPI.transfer(LOAD_TX_BUF_0_ID);
        SPI.transfer(identifier[0]); //identifier high bits
        SPI.transfer(identifier[1]); //identifier low bits
        SPI.transfer(identifier[2]); //extended identifier registers(unused)
        SPI.transfer(identifier[3]);
        SPI.transfer(length);
        for (i=0;i<length;i++) { //load data buffer
                SPI.transfer(data[i]);
        }

        digitalWrite(SS, HIGH);

}

void CANClass::load_ff_1(byte length,byte *identifier,byte *data)
{
        
        byte i,id_high,id_low;

        //generate id bytes before SPI write
        // id_high = (byte) (identifier >> 3);
        // id_low = (byte) ((identifier << 5) & 0x00E0);

        digitalWrite(SS, LOW);
        SPI.transfer(LOAD_TX_BUF_1_ID);
        SPI.transfer(identifier[0]); //identifier high bits
        SPI.transfer(identifier[1]); //identifier low bits
        SPI.transfer(identifier[2]); //extended identifier registers(unused)
        SPI.transfer(identifier[3]);
        SPI.transfer(length);
        for (i=0;i<length;i++) { //load data buffer
                SPI.transfer(data[i]);
        }

        digitalWrite(SS, HIGH);


}

void CANClass::load_ff_2(byte length,byte *identifier,byte *data)
{
        
        byte i,id_high,id_low;

        //generate id bytes before SPI write
        // id_high = (byte) (identifier >> 3);
        // id_low = (byte) ((identifier << 5) & 0x00E0);

        digitalWrite(SS, LOW);

        SPI.transfer(LOAD_TX_BUF_2_ID);
        SPI.transfer(identifier[0]); //identifier high bits
        SPI.transfer(identifier[1]); //identifier low bits
        SPI.transfer(identifier[2]); //extended identifier registers(unused)
        SPI.transfer(identifier[3]);
        SPI.transfer(length); //data length code
        for (i=0;i<length;i++) { //load data buffer
                SPI.transfer(data[i]);
        }

        digitalWrite(SS, HIGH);

}

void CANClass::load_and_send(byte length,byte *identifier,byte *data)
{
    
    byte i,id_high,id_low, status, address, send_buf;
    
    status = CAN.readStatus();
    
    if ((status & 0b10) == 0) {
    address = LOAD_TX_BUF_0_ID;
        send_buf = SEND_TX_BUF_0;
  }
  else if ((status & 0b1000) == 0) {
    address = LOAD_TX_BUF_1_ID;
        send_buf = SEND_TX_BUF_1;
  }
  else if ((status & 0b100000) == 0) {
    address = LOAD_TX_BUF_2_ID;
        send_buf = SEND_TX_BUF_2;
  }
  else {
    // all buffer used => could not send message
        Serial.println("Fehler");
    return;
  }
    
    //generate id bytes before SPI write
    // id_high = (byte) (identifier >> 3);
    // id_low = (byte) ((identifier << 5) & 0x00E0);
    
    digitalWrite(SS, LOW);
    
    SPI.transfer(address);
    SPI.transfer(identifier[0]); //identifier high bits
    SPI.transfer(identifier[1]); //identifier low bits
    SPI.transfer(identifier[2]); //extended identifier registers(unused)
    SPI.transfer(identifier[3]);
    SPI.transfer(length); //data length code
    for (i=0;i<length;i++) { //load data buffer
        SPI.transfer(data[i]);
    }
    
    digitalWrite(SS, HIGH);
    delay(50);
    digitalWrite(SS, LOW);
    SPI.transfer(send_buf);
    digitalWrite(SS, HIGH);
    
}

Wie kann ich eine Kollision detektieren und die Meldung allenfalls 
erneut senden?

[R. F. (rfr)]

So nicht. Eine Nachricht, die verschwindet, ist weg. Es wird nichts 
detektiert. Einzige Abhilfe ist die Implementation eines Rollcounters in 
jedes Paket.

Gruss

Robert

[Roger K. (Firma: privat) (chasperli)]

Was meinst du mit Rollcounter? (Tut mir leid falls dies eine blöde Frage 
ist, ich befasse mich noch nicht sehr lange mit dem Thema).

Gruss Roger

[Gerd B. (bertr2d2)]

Normalerweise wird ein Paket nochmals gesendet. Es sei denn, das 
One-Shot Bit ist gesetzt:

CANCTRL:
bit 3:
OSM: One Shot Mode bit
1 = Enabled. Message will only attempt to transmit one time
0 = Disabled. Messages will reattempt transmission, if required

Wie ist das Bit denn gesetzt ?

[Karl H. (kbuchegg)]

R. Freitag schrieb:
> So nicht. Eine Nachricht, die verschwindet, ist weg. Es wird nichts
> detektiert. Einzige Abhilfe ist die Implementation eines Rollcounters in
> jedes Paket.


Ohne jetzt der Spezialist für MCP2515 zu sein.
Eine andere CAN IMplementierung macht das so

INT8U MCP_CAN::sendMsg()
{
    INT8U res, res1, txbuf_n;
    uint16_t uiTimeOut = 0;

    do {
        res = mcp2515_getNextFreeTXBuf(&txbuf_n);                       /* info = addr.                 */
        uiTimeOut++;
    } while (res == MCP_ALLTXBUSY && (uiTimeOut < TIMEOUTVALUE));

    if(uiTimeOut == TIMEOUTVALUE) return CAN_GETTXBFTIMEOUT;            /* get tx buff time out         */
    uiTimeOut = 0;
    mcp2515_write_canMsg( txbuf_n);
    mcp2515_start_transmit( txbuf_n );
    do
    {
        uiTimeOut++;        
        res1= CAN.mcp2515_readRegister(txbuf_n);        /* read send buff ctrl reg   */
        res1 = res1 & 0x08;                                   
    }while(res1 && (uiTimeOut < TIMEOUTVALUE));   
    if(uiTimeOut == TIMEOUTVALUE) return CAN_SENDMSGTIMEOUT;            /* send msg timeout             */  
    return CAN_OK;

}

Interessant ist der letzte Teil

    mcp2515_start_transmit( txbuf_n );
    do
    {
        uiTimeOut++;        
        res1= CAN.mcp2515_readRegister(txbuf_n);        /* read send buff ctrl reg   */
        res1 = res1 & 0x08;                                   
    }while(res1 && (uiTimeOut < TIMEOUTVALUE));

nachdem der MCP2515 angewiesen wurde, die Nachricht zu versenden, wird 
offenbar ein Control Register gelesen und festgestellt, ob die Nachricht 
rausging (mit einer Timeout Option).

Sehe ich mir das Datenblatt zum MCP2515 an
https://www.sparkfun.com/datasheets/DevTools/Arduino/MCP2515.pdf
dann ist auf Seite 17 ein Flowchart, in dem der Fall im Prinzip 
behandelt wird. Dort wird von diesem Control Register das Bit MLOA 
untersucht, welches doch eigentlich genau für diesen Fall gilt, dass 
eine Message nicht korrekt raus ging, weil die Arbitrierung verloren 
ging.

Wie man das dann behandeln will, ist eine andere Sache. Normalerweise 
würde ich sagen: bischen warten und nochmal versuchen, denn irgendwann 
muss ja auch der andere Busteilnehmer fertig sein.

Springender Punkt:
Das alles fällt unter den Punkt 'Error Handlung'. Und das vermisse ich 
komplett im vom TO geposteten Code. Dieser Code ist 'Schönwettercode'. 
WEnn die Sonne scheint und der Wind günstig steht, dann funktioniert das 
alles. Aber wehe, wehe, wenn nicht. Robuster Code sieht anders aus. Der 
muss auch eine entsprechende Fehlerbehandlung enthalten.

[R. F. (rfr)]

Hallo,

"weil die Arbitrierung verloren ging" != weil eine Buskollision 
stattfand.
Im Falle einer Buskollision fehlt ei Paket. Ein Rollcounter ist ein 
kleine Teil eines Paketes, welchjes einen Zählerstand darstellt, der bei 
jedem Senden eines neuen Paketes ein rauf (oder runter) gezählt wird. 
Der Empfänger kann die Zählerstände erkennen, fehlt ein Wert in einer 
sonst vollständigen Kette, ist das Paket verloren gegangen.

Gruss

Robert

[Gerd B. (bertr2d2)]

Karl Heinz hat natürlich vollkommen recht. Ein Error Handling ist 
notwendig. Der obige Code reagiert (in irgendeiner Form) auf 
Übertragungsfehler.

Aber Retransmission wird normalerweise automatisch gemacht. Es sei denn, 
man verwendet den One-Shot Modus:

3.4 One-Shot Mode
One-shot mode ensures that a message will only attempt to transmit one 
time. Normally, if a CAN message loses arbitration, or is destroyed by 
an error frame, the message is retransmitted. With One-shot mode 
enabled, a message will only attempt to transmit one time, regardless of 
arbitration loss or error frame.
One-shot mode is required to maintain time slots in deterministic 
systems, such as TTCAN.

[Karl H. (kbuchegg)]

Gerd B. schrieb:

> Aber Retransmission wird normalerweise automatisch gemacht.

Wobei ich nicht schlau geworden bin.
Wird das im Falle eines Falles vom MCP 'unendlich oft' wiederholt?

Denn dann hab ich dem Autor eventuell unrecht getan.
Er hat schon ein implizites einfaches Error Handling drinn. Wenn die 
Message nicht rausgeht, dann bleibt der Sendebuffer 'allokiert' und der 
nächste Aufruf von

void CANClass::load_and_send(byte length,byte *identifier,byte *data)

findet keinen freien Buffer mehr vor.
Allerdings ist die Behandlung davon

  else {
    // all buffer used => could not send message
        Serial.println("Fehler");
    return;
  }

ein bischen dürftig. Wie überhaupt der Code in dieser Beziehung ein 
wenig dürftig ist. Wird load_and_send zu schnell aufgerufen, dann ist es 
fast unvermeidlich, dass es trotz 3-er Sendebuffer im MCP irgendwann mal 
dazu kommt, dass eine Msg aufgrund nicht verfügbarer Sendebuffer eben 
nicht rausgeht. Da jetzt einfach "Fehler" hinzuschreiben und den 
Aufrufer noch nicht mal darüber zu informieren, das geht gar nicht.

[Rolf Magnus (Gast)]

R. Freitag schrieb:
> "weil die Arbitrierung verloren ging" != weil eine Buskollision
> stattfand.

Buskollisionen gibt es beim CAN eigentlich gar nicht. Genau das soll 
durch die Bitarbitrierung ja verhindert werden.

> Im Falle einer Buskollision fehlt ei Paket. Ein Rollcounter ist ein
> kleine Teil eines Paketes, welchjes einen Zählerstand darstellt, der bei
> jedem Senden eines neuen Paketes ein rauf (oder runter) gezählt wird.

Ich kenne das unter dem Begriff "Message Counter".

[Roger K. (Firma: privat) (chasperli)]

Danke Für die vielen und schnellen Antworten. Ich werd mich somit 
nochmals in das Datenblatt einlesen und die MCP_CAN Library anschauen.

Gruss Chasperli