[funktioniert] UNO - Mega - Teensy mittels CAN-Bus verbinden

Ich habe mir CANquitto angesehen. Das ist eine Bibliothek für die Kommunikation ausschließlich von Teensys untereinander, verstehe ich das richtig? Oder ist eine Mischung mit MCP2515 möglich? Ist eine Mischung mit FlexCAN möglich?

Ich frage, weil ich derzeit nur genau einen Teensy 3.2 besitze.

Ja, es ist gebaut, um IFCT zu arbeiten und nur für Teensy 3.2 / 3.5 / 3.6 FlexCan Controller nur eingebaut. Ich habe Pläne, einige zusätzliche Dinge wie Netzwerk zu implementieren (alle Knoten haben Zugang zu Internet-Knoten) über Canbus, aber das werde ich wahrscheinlich für die T4.0-Version halten.

IFCT basiert auf Caws und Collin80s, verfügt jedoch über erweiterte Steuerungs- und Funktionalität, wie sequenzielles Senden und automatische Filter, die keine Kenntnisse erfordern, um spezifische IDs zu erfassen. Es wurde von Grund auf neu geschrieben und läuft seit langem, besonders einige Leute benutzen es als Gateway und CANquitto nutzt seine Hintergrunddienste und sequenzielles Framing. CANquitto hat die Fähigkeit, Arrays beliebiger Größe in Canbus-Pakete zu zerlegen, die sie alle über den Bus streamen, und der andere Knoten ist in der Lage, sie in jeder Reihenfolge wieder zusammenzusetzen, in der sie empfangen werden. Die Hardware-Port-Zugriffe sind ein Bonus, sie ermöglichen dem Benutzer eine zentralisierte Skizze, die SPI / UART / I2C-Geräte an jedem beliebigen Knoten an dem Bus steuern kann, und die Kommunikation / Steuerungen sind bidirektional (parallele Übertragungen ohne Kollision). Möglicherweise sind noch mehr Funktionen verfügbar, aber im Moment bin ich an ein anderes Projekt gebunden. Sie können bis zu 127 verschiedene Knoten auf CANquitto steuern, also viel Spaß und lassen Sie mich wissen, wie es Ihnen gefällt und / oder Sie haben irgendwelche Vorschläge, die ich in Zukunft hinzufügen könnte. es hat sogar primitive Funktionen wie myNode.digitalRead (13); und ein myNode.pinMode (13, OUTPUT); und myNode.toggle (13) Funktionen, können Sie die Quellen für alle Funktionen überprüfen, die es derzeit hat. Es verfügt auch über einen Erkennungsrückruf, mit dem Sie wissen, wann ein Knoten vom Bus fällt oder wann er zurückkommt. Sie können den Erkennungsrückruf verwenden, um die Parameter des Knotens bei der Erkennung automatisch zu konfigurieren, z. B. pinModes oder myNode.Serial2.begin (115200);

Ich hoffe ich habe es einfach genug gemacht, das war meine Absicht :slight_smile: sogar TouchRead funktioniert, wenn man Berührungssensoren über ein Netzwerk haben wollte

Tony

und lassen Sie mich wissen

Ich glaube, dass agmue sich eine AVR Implementierung für den MCP2515 wünscht, und keine Werbeveranstaltung.

Ich fördere nichts, noch werde ich dafür bezahlt ... wie kannst du es wagen, mich anzuklagen, ist es meine Schuld, dass ich auf einem integrierten Can-Controller eines anderen MCU für dich entwickelt habe, um mich zu beschuldigen, irgendetwas zu promoten, als ob ich etwas herausbekomme es? das soll eine Gemeinschaft sein, eine Gemeinschaft dessen, was ich tue, arbeite kostenlos für nichts, aber deine harten Kommentare sind nicht notwendig :frowning:

Tony

combie:
Ich glaube, dass agmue sich eine AVR Implementierung für den MCP2515 wünscht, ...

Bis dahin stimme ich Dir zu. Aber da ich auch einen Teensy habe, binde ich den natürlich auch gleich in meine Überlegungen ein.

@tonton81: Danke für die Informationen.

Aber da ich auch einen Teensy habe, binde ich den natürlich auch gleich in meine Überlegungen ein.

Wieso "aber"?

Habe ich ich mich so unklar ausgedrückt?

Dann versuche ich es nochmal:
Ich glaube, dass agmue eine zusätzliche AVR Implementierung für den MCP2515 benötigt, um deine Lib nutzen zu können, und keine Werbeveranstaltung für eine Library, welche nur auf dem Teensy läuft.

Denn das geht doch aus den ersten Postings klar hervor, dass die Kommunikation bisher zwischen 2 AVR und 1 Teensy erfolgen soll.
Zumindest ist mir noch nichts gegenteiliges aufgefallen.

tonton81 scheint das, mit 2 AVR und 1 Teensy, nicht bewusst zu sein
Und, dass er den Hinweis darauf so persönlich nimmt... finde ich schon etwas seltsam.
Mir scheint, sein Fokus steht deutlich mehr auf Präsentation seiner Lib, als auf Lösung deines Problems.

Aber vielleicht sollte ich euch hier besser alleine weiter machen lassen.....

nicht hier, um euch zu missachten, aber ich schrieb diesen Code in meiner Freizeit und ich bin der einzige Coder für CANquitto, schließlich, wenn Interesse entsteht, könnte ich einen Port schreiben, der zumindest auf Arduino Mega mit mcp2515, aber nur in meinem freien beginnen wird Zeit arbeite ich gerade an einem neuen Projekt. dann können wir auch AVRs kontrollieren, aber bitte entmutigen Sie mich nicht, ich mache keinen Cent von irgendwelchen Arbeiten, überhaupt ... keine meiner Bibliotheken ist sogar in der Verbreitung von teensyduino ...

Hi

Willkommen im Club - mir wäre derzeit kein Lohn-Progger hier im Forum bekannt, Der Seinen Code hier zum Verkauf anbietet.

Bisher verstand ich Das hier so, daß ALLE hier in Ihrer Freizeit mit den Arduinos spielen, oder hier Rede und Antwort stehen - ebenfalls ganz ohne Bezahlung (ob die Teamer hier ebenfalls unendgeldlich arbeiten, ist mir weder bekannt, noch würde mich Das, oder das Gegenteil davon, stören.

Zumindest mein Chef würde es mir übel nehmen, wenn ich während der Arbeitszeit an meinen Spielereien rumstricke - schließlich werde ich für 'Was ganz Anderes' von Ihm bezahlt.

Wenn Deine Lib auf einem MEGA irgendwie zum Laufen gebracht werden kann, wäre ein Thread hierzu bestimmt für eine Menge Leute hier interessant.

Trotzdem musst Du einsehen, daß '2 AVR, 1 Teensy' mit einer 'nur Teensy-Lib' irgendwie blöd ist - und SO las sich Dein oberer Post.

MfG

Mich interessierten noch die MCP2515 Masken und Filter, die mit der Bibliothek gesetzt werden können. Dazu lasse ich den Teensy senden und den UNO empfangen, wobei die vorhandene Kommunikation weiterläuft, die LEDs blinken auch weiter. Das Beispiel MCP_CAN\examples\Extended_MaskFilter\Extended_MaskFilter.ino habe ich in meinen bestehenden UNO-Sketch eingebunden:

If you send the following extended IDs below to an Arduino loaded with this sketch
you will find that 0x00FFCC00 and 0x00FF9900 will not get in.

ID in Hex is the same as the Filter in Hex.
0x00FFEE00
0x00FFDD00
0x00FFCC00 This example will NOT be receiving this ID
0x00FFBB00
0x00FFAA00
0x00FF9900 This example will NOT be receiving this ID
0x00FF8800
0x00FF7700

Bei den Masken markiert ein Bit mit 1 ein signifikantes Bit für die Filterung. Beispiel:

Maske:       0x1FFFFF00  [sub](habe ich gegenüber dem Beispiel verändert, 0x1FFFFFFF Maximum für Maske und ID)[/sub]
Extended ID: 0x00FF7700  kommt durch
Extended ID: 0x00FF7755  kommt durch
Extended ID: 0x00FF9900  kommt nicht durch
// UNO
// http://henrysbench.capnfatz.com/henrys-bench/arduino-projects-tips-and-more/arduino-can-bus-module-1st-network-tutorial/
// CAN Send Example der Bibliothek https://github.com/coryjfowler/MCP_CAN_lib
#include <mcp_can.h>
#include <SPI.h>

MCP_CAN CAN0(10);     // Set CS to pin 10
char msgString[128];            // Serial Output String Buffer
const uint32_t sendeIntervall = 1000;
uint32_t jetzt, sendeMillis;

void setup()
{
  Serial.begin(115200);

  while (CAN_OK != CAN0.begin(MCP_STDEXT, CAN_500KBPS, MCP_8MHZ))  // init can bus : masks and filters disabled, baudrate, Quarz vom MCP2551
  {
    Serial.println("CAN BUS Shield init fail");
    Serial.println(" Init CAN BUS Shield again");
    delay(100);
  }
  Serial.println("CAN BUS Shield init ok!");

  CAN0.init_Mask(0, 1, 0x1FFFFF00);              // Init first mask...
  CAN0.init_Filt(0, 1, 0x00FFEE00);              // Init first filter...

  CAN0.init_Mask(1, 1, 0x1FFFFF00);              // Init second mask...
  CAN0.init_Filt(1, 1, 0x00FFDD00);              // Init second filter...
  CAN0.init_Filt(2, 1, 0x00FFBB00);              // Init third filter...
  CAN0.init_Filt(3, 1, 0x00FFAA00);              // Init fouth filter...
  CAN0.init_Filt(4, 1, 0x00FF8800);              // Init fifth filter...
  CAN0.init_Filt(5, 1, 0x00FF7700);              // Init sixth filter...

  CAN0.setMode(MCP_NORMAL);   // Change to normal mode to allow messages to be transmitted
}

byte data[] = {0, 1, 2, 3, 4, 5, 6, 7};
byte len = sizeof(data);

void loop()
{
  jetzt = millis();
  if (jetzt - sendeMillis >= sendeIntervall) {
    sendeMillis = jetzt;
    // byte sndStat = CAN0.sendMsgBuf(0x70, 0, len, data);  // send data:  id = 0x70, standard frame, data len = 8, data buf
    byte sndStat = CAN0.sendMsgBuf(0x12345670, 1, len, data);  // send data:  id = 0x12345670, extended frame, data len = 8, data buf
    if (sndStat == CAN_OK) {
      Serial.println("Message Sent Successfully!");
    } else {
      Serial.println("Error Sending Message...");
    }
    data[2]++;
  }

  unsigned long rxId = 0;
  byte len = 0;
  byte rxBuf[8];

  if (CAN_MSGAVAIL == CAN0.checkReceive())           // check if data coming
  {
    CAN0.readMsgBuf(&rxId, &len, rxBuf);      // Read data: len = data length, buf = data byte(s)
    //Serial.println("-----------------------------");
    if ((rxId & 0x80000000) == 0x80000000)            // Determine if ID is standard (11 bits) or extended (29 bits)
      sprintf(msgString, "Extended ID: 0x%.8lX  DLC: %1d  Data:", (rxId & 0x1FFFFFFF), len);
    else
      sprintf(msgString, "Standard ID: 0x%.3lX       DLC: %1d  Data:", rxId, len);

    Serial.print(msgString);

    if ((rxId & 0x40000000) == 0x40000000) {          // Determine if message is a remote request frame.
      sprintf(msgString, " REMOTE REQUEST FRAME");
      Serial.print(msgString);
    } else {
      for (byte i = 0; i < len; i++) {
        sprintf(msgString, " 0x%.2X", rxBuf[i]);
        Serial.print(msgString);
      }
    }
    Serial.println();
  }
}
// Mega2560
// SCK - 52
// SI  - 51
// SO  - 50
// CS  - 53
// http://henrysbench.capnfatz.com/henrys-bench/arduino-projects-tips-and-more/arduino-can-bus-module-1st-network-tutorial/

// CAN Receive Example der Bibliothek https://github.com/coryjfowler/MCP_CAN_lib
#include <mcp_can.h>
#include <SPI.h>

MCP_CAN CAN0(53);               // Set CS pin

char msgString[128];            // Serial Output String Buffer
const int LEDpin = 13;

void setup()
{
  Serial.begin(115200);
  pinMode(LEDpin, OUTPUT);

  while (CAN_OK != CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_8MHZ))  // init can bus : masks and filters disabled, baudrate, Quarz vom MCP2551
  {
    Serial.println("CAN BUS Shield init fail");
    Serial.println(" Init CAN BUS Shield again");
    delay(100);
  }
  Serial.println("CAN BUS Shield init ok!");
  CAN0.setMode(MCP_NORMAL);   // Change to normal mode to allow messages to be transmitted
}

void loop()
{
  unsigned long rxId = 0;
  byte len = 0;
  byte rxBuf[8];

  if (CAN_MSGAVAIL == CAN0.checkReceive())           // check if data coming
  {
    CAN0.readMsgBuf(&rxId, &len, rxBuf);      // Read data: len = data length, buf = data byte(s)
    Serial.println("-----------------------------");
    if ((rxId & 0x80000000) == 0x80000000)            // Determine if ID is standard (11 bits) or extended (29 bits)
      sprintf(msgString, "Extended ID: 0x%.8lX  DLC: %1d  Data:", (rxId & 0x1FFFFFFF), len);
    else
      sprintf(msgString, "Standard ID: 0x%.3lX       DLC: %1d  Data:", rxId, len);

    Serial.print(msgString);

    if ((rxId & 0x40000000) == 0x40000000) {          // Determine if message is a remote request frame.
      sprintf(msgString, " REMOTE REQUEST FRAME");
      Serial.print(msgString);
    } else {
      for (byte i = 0; i < len; i++) {
        sprintf(msgString, " 0x%.2X", rxBuf[i]);
        Serial.print(msgString);
        if (i == 2)
        {
          digitalWrite(LEDpin, rxBuf[i] % 2);
        }
      }
    }
    Serial.println();
  }
}

Fortsetzung folgt …

#include <FlexCAN.h>

elapsedMillis RXtimer;
uint32_t RXCount = 0;
const uint8_t redLEDpin = 13;
static CAN_message_t msg0;

class CANClass : public CANListener
{
  public:
    void printFrame(CAN_message_t &frame, int mailbox);
    void gotFrame(CAN_message_t &frame, int mailbox); //overrides the parent version so we can actually do something
};

void CANClass::printFrame(CAN_message_t &frame, int mailbox)
{
  Serial.print("Mailbox: ");
  Serial.print(mailbox);
  Serial.print(" ID: ");
  Serial.print(frame.id, HEX);
  Serial.print(" Data: ");
  for (int c = 0; c < frame.len; c++)
  {
    if (0x10 > frame.buf[c]) Serial.write(' ');
    Serial.print(frame.buf[c], HEX);
    Serial.write(' ');
    if (c == 2) digitalWrite(redLEDpin, frame.buf[c] % 2);
  }
  Serial.println();
  RXCount++;
}

void CANClass::gotFrame(CAN_message_t &frame, int mailbox)
{
  printFrame(frame, mailbox);
}

CANClass CANClass0;

// -------------------------------------------------------------
void setup(void)
{
  delay(3000);
  Serial.println(F("Teensy 3.2 CAN Test With Objects."));
  pinMode(redLEDpin, OUTPUT);

  Can0.begin(500000);
  Can0.attachObj(&CANClass0);

  CAN_filter_t allPassFilter;
  allPassFilter.id = 0;
  allPassFilter.ext = 1;
  allPassFilter.rtr = 0;

  //leave the first 4 mailboxes to use the default filter. Just change the higher ones
  for (uint8_t filterNum = 4; filterNum < 16; filterNum++) {
    Can0.setFilter(allPassFilter, filterNum);
  }
  for (uint8_t filterNum = 0; filterNum < 16; filterNum++) {
    CANClass0.attachMBHandler(filterNum);
  }
  //CANClass0.attachGeneralHandler();
  //CANClass1.attachGeneralHandler();
}

// -------------------------------------------------------------
void loop(void)
{
  static byte nachricht = 1;
  if (RXtimer == 2100 && nachricht == 1) {
    nachricht++;
    msg0.id = 0x00FF7700;
    msg0.ext = 1;
    msg0.rtr = 0;
    msg0.len = 2;
    msg0.buf[0] = 0x26;
    msg0.buf[1] = 0x48;
    Can0.write(msg0); //Write message
    Serial.println("Nachricht ID 0x00FF7700 verschickt");
  }
  if (RXtimer == 2200 && nachricht == 2) {
    nachricht++;
    msg0.id = 0x00FF8800;
    Can0.write(msg0); //Write message
    Serial.println("Nachricht ID 0x00FF8800 verschickt");
  }
  if (RXtimer == 2300 && nachricht == 3) {
    nachricht++;
    msg0.id = 0x00FF9900;
    Can0.write(msg0); //Write message
    Serial.println("Nachricht ID 0x00FF9900 verschickt");
  }
  if (RXtimer == 2400 && nachricht == 4) {
    nachricht++;
    msg0.id = 0x00FFAA00;
    Can0.write(msg0); //Write message
    Serial.println("Nachricht ID 0x00FFAA00 verschickt");
  }
  if (RXtimer == 2500 && nachricht == 5) {
    nachricht++;
    msg0.id = 0x00FFBB00;
    Can0.write(msg0); //Write message
    Serial.println("Nachricht ID 0x00FFBB00 verschickt");
  }
  if (RXtimer == 2600 && nachricht == 6) {
    nachricht++;
    msg0.id = 0x00FFCC00;
    Can0.write(msg0); //Write message
    Serial.println("Nachricht ID 0x00FFCC00 verschickt");
  }
  if (RXtimer == 2700 && nachricht == 7) {
    nachricht++;
    msg0.id = 0x00FFDD00;
    Can0.write(msg0); //Write message
    Serial.println("Nachricht ID 0x00FFDD00 verschickt");
  }
  if (RXtimer == 2800 && nachricht == 8) {
    nachricht++;
    msg0.id = 0x00FFEE00;
    Can0.write(msg0); //Write message
    Serial.println("Nachricht ID 0x00FFEE00 verschickt");
  }
  if (RXtimer == 2900 && nachricht == 9) {
    nachricht++;
    msg0.id = 0x00FFEE77;
    Can0.write(msg0); //Write message
    Serial.println("Nachricht ID 0x00FFEE77 verschickt");
  }
  if (RXtimer == 2950 && nachricht == 10) {
    nachricht++;
    msg0.id = 0x00FF7755;
    Can0.write(msg0); //Write message
    Serial.println("Nachricht ID 0x00FF7755 verschickt");
  }
  if (RXtimer > 10000) {
    Serial.print("Total Received Messages in 10 Sec: ");
    Serial.println(RXCount);
    RXtimer = 0;
    RXCount = 0;
    nachricht = 1;
  }
}

Dank guter Unterstützung habe ich derzeit zu diesem Thema keine weiteren Fragen :slight_smile:

macht dein Filter mit der coryjfowler das was du wolltest? weil das hat mich zur Weißglut gebracht, und ich hab schlussendlich second mask und die weiteren Filter analog den first gesetzt ...

noiasca:
macht dein Filter mit der coryjfowler das was du wolltest?

Soweit ich es beurteilen kann, ja.

Dank MCP_ANY kommt erstmal alles rein, was auf dem Bus ist. Das mache ich beim Mega zur Kontrolle.

Beim UNO habe ich die Masken und Filter aus dem Beispiel zusammen mit MCP_STDEXT genommen. Die IDs, die mit den Filtern übereinstimmen, kommen durch, die anderen nicht. Mit der ID 0x00FF7755 habe ich dann noch die nicht signifikanten Bits getestet.

Noch habe ich die Hardware zusammengesteckt, wenn ich was testen soll, dann gerne.

also ich hab momentan 3 Boards/Teilnehmer im CANBus.

Die PGN’s vergebe ich in der Form

uint32_t currentTxId(byte _priority)
// returns a txId/PGN with the given priority specific for this board
{
  /* 12345678901   basic format with 11 bits
   * PPPRRUUUUUU 
     PPP           3 bit Priority according emuration priority - maximal 8 priorities possible
        RR         2 bit reserve - could be used to extend the boards or priority later on
          UUUUUU   6 bit BOARD for a maximum of 64 Boards
  */
  return _priority << 8 | (USE_BOARD & 0b00111111);
}

Ich würde daher grundsätzlich die Maske auf 0x3F0000 setzen und wenn mich nur Messages von Board 3 interessieren den Filter auf 0x030000 setzen

in etwa so:

  if (USE_FILTER)                               // if activated, only messages for this board will be shown
  {                                             //                                                 PPPRRUUUUUU
                                                // Example from libray                            0001000011110000000000000000‬‬ = 0x010F0000
    uint32_t myMask = 0x3F0000;                 // use only the 6 bits of the trxId = USE_BOARD   ‭‭0000001111110000000000000000 = ‭0x3F0000‬
    uint32_t myFilter = USE_BOARD;
    //myFilter = myFilter << 16;                  // filter messages only for this board

    myFilter = 0x030000;                        // hardcoded test: set a filter to board 3                ‭00110000000000000000‬‬

    Serial.print(F("Set CAN filter to 0x")); Serial.println(myFilter, HEX);
    CAN.init_Mask(0, 0, myMask);                // Init first mask...
    CAN.init_Filt(0, 0, myFilter);              // Init first filter...
    CAN.init_Filt(1, 0, myFilter);              // Init second filter...

    /*
    CAN.init_Mask(1, 0, myMask);                // Init second mask...
    CAN.init_Filt(2, 0, myFilter);              // Init third filter...
    CAN.init_Filt(3, 0, myFilter);              // Init fouth filter...
    CAN.init_Filt(4, 0, myFilter);              // Init fifth filter...
    CAN.init_Filt(5, 0, myFilter);              // Init sixth filter...
    */
  }

ich MUSS aber die Mask1 und Filter 2-5 gleich dem Mask und Filter 0 und 1 setzen, sonst funktioniert das nicht, kommentiere ich den Abschnitt aus, greift der Filter nicht mehr. Ich würde gern verstehen warum.

Time		PGN		Byte0	Byte1	Byte2	Byte3	Byte4	Byte5	Byte6	Byte7
144		0x203		0x03	0x08	0xED	0x23	0x0E	0x0F	0x10	0x11	
1136		0x203		0x03	0x29	0x9E	0x6E	0x0E	0x0F	0x10	0x11	
2127		0x203		0x03	0x3F	0x93	0x71	0x0E	0x0F	0x10	0x11	
2623		0x3		0x03	0x04

Ich kann auch einen kompletten Sketch zur Verfügung stellen, (aber nur wenn du Zeit hast - es funktioniert ja momentan, verstehe es nur nicht)

Bitte berücksichtige, daß Dir ein CAN-Bus-Anfänger schreibt!

Was mir spontan auffällt:

    uint32_t myMask = 0x3F0000;
    myFilter = 0x030000;

    CAN.init_Mask(0, 0, myMask);                // Init first mask...
    CAN.init_Filt(0, 0, myFilter);              // Init first filter...

Maske und Filter sind erweitert, da größer 0x7FF, der zweite Parameter bei init_Mask und init_Filt aber 0, also "normal".

Oder?

imho nein, mask/filter sind immer 4 Byte.
Bei Standard werden die ersten zwei Byte für die 11Bit PGN verwendet und die zwei verbleibenden Byte könnte man auf die ersten beiden Datenbytes anwenden.

Ich habe nur 11bit PGNs, die kommen im Mask/Filter daher geschifted <<16 in die zwei linken Bytes, die zwei rechten würden Daten filtern, daher habe ich die jeweils null. Das entspricht meiner Meinung auch dem Standarf-Filter Beispiel.

Schaut nur so eigenartig aus, da in Hex die “Vornullen” fehlen, Binär ist es einfacher:

Die Stellen die mich interessieren = Maske
0000 0011 1111 0000 0000 0000 0000 = ‭0x3F0000‬

Beispielhaft eine um 16 bit geschiftete PGN = Filter für eine PGN 0x03 
‭0000 0000 0011 0000 0000 0000 0000‬ = 0x030000‬

Mach dir weiter keinen Kopf, … bin momentan auch bei was anderem :wink:

Wenn ich Dich richtig verstehe, dann möchtest Du normale IDs verwenden? Genau dafür habe ich die Filter noch nicht probiert, weshalb meine Aussage aus #33 wertlos ist, kann ich aber mal machen.

Ich habe nun die normalen IDs getestet, wobei ich mit dem Bibliotheksbeispiel Standard_MaskFilter.ino gespielt habe. Ich finde das, was ich gesehen habe, logisch und nachvollziehbar. Zumindest bilde ich mir das ein ::slight_smile:

noiasca:
Ich würde daher grundsätzlich die Maske auf 0x3F0000 setzen und wenn mich nur Messages von Board 3 interessieren den Filter auf 0x030000 setzen
...
ich MUSS aber die Mask1 und Filter 2-5 gleich dem Mask und Filter 0 und 1 setzen, sonst funktioniert das nicht, kommentiere ich den Abschnitt aus, greift der Filter nicht mehr. Ich würde gern verstehen warum.

Wenn Du eine Maske nicht setzt, hat sie den Wert "lasse alles rein" 0x00000000. Demzufolge läßt diese Maske dann alle IDs rein, egal, wie die andere gesetzt ist. Daher mußt Du immer beide Masken setzen.

  CAN0.init_Mask(0,0,0x01FF0000);                // Init first mask...
  CAN0.init_Filt(0,0,0x00030000);                // Init first filter...
  
  CAN0.init_Mask(1,0,0x01FF0000);                // Init second mask...

Wenn Du beide Masken setzt, reicht ein Filter, um Dir nur die ID 3 durchzulassen.

agmue:
Wenn Du eine Maske nicht setzt, hat sie den Wert "lasse alles rein" 0x00000000. Demzufolge läßt diese Maske dann alle IDs rein, egal, wie die andere gesetzt ist. Daher mußt Du immer beide Masken setzen.

schlimm, das klingt so logisch, dass es mir schon wieder peinlich ist.

Edit: habe es soeben ausprobiert, und ja ist natürlich so.
Wenigstens hat es jetzt klick gemacht :wink: und ich kann an meinem Masterdevice weiterarbeiten.
Karma.

noiasca:
Wenigstens hat es jetzt klick gemacht :wink:

Das freut mich, danke!

Meine Frage nach den Postfächern ... aber dafür ist so ein Forum doch da :slight_smile: