LCDMenuLib2 Screensaver in Digitaluhr umbauen +1

Nein, das wäre für den Bus nicht gut, also nur bei Bedarf.

Nano #3 könnte auch ein ESP32 sein, der Daten zum Anhänger sendet oder empfängt.

Ich habe dann mal die Bibliothek gewählt, die für Nano (bei mir UNO) und ESP32 funktioniert und einfach "gestrickt" ist. Der ESP32 sendet drei Pakete an drei Adressen = IDs, eins mit zufälligem Bitmuster, mein UNO filtert eine ID raus und zeigt das Bitmuster bei mir mit LEDs an.

ESP32:

// ESP32 - TJA1050
//    5V - VCC
//   GND - GND
//    32 - RX
//    33 - TX

#include <CAN.h>  // https://github.com/sandeepmistry/arduino-CAN

void setup() {
  Serial.begin(115200);
  delay (500);
  Serial.println("CAN Sender");

  CAN.setPins(32, 33);                            // RX, TX
  if (!CAN.begin(500E3)) {                        // Start CAN Bus mit 500 kbps
    Serial.println("Start CAN fehlgeschlagen!");
    while (1);
  }
}

void loop() {
  // sende Paket: ID ist 11 Bits, ein Paket kann bis zu 8 Bytes Daten enthalten
  Serial.print("Sende Paket ID = 0x21");
  CAN.beginPacket(0x21);
  CAN.write('h');
  CAN.write('e');
  CAN.write('l');
  CAN.write('l');
  CAN.write('o');
  CAN.write('2');
  CAN.write('1');
  CAN.endPacket();
  delay(1000);

  Serial.print("Sende Paket ID = 0x22");
  CAN.beginPacket(0x22);
  CAN.write(random(0, 0x10));  // vier zufällige Bits
  CAN.endPacket();
  delay(1000);

  Serial.print("Sende Paket ID = 0x23");
  CAN.beginPacket(0x23);
  CAN.write('h');
  CAN.write('e');
  CAN.write('l');
  CAN.write('l');
  CAN.write('o');
  CAN.write('2');
  CAN.write('3');
  CAN.endPacket();
  delay(1000);
}

UNO:

// UNO - MCP2515
//  13 - SCK
//  11 - SI
//  12 - SO
//  10 - CS
//   2 - INT

#include <CAN.h>  // https://github.com/sandeepmistry/arduino-CAN
#define FILTER_ID 0x22
const uint8_t pin[] = {A0, A1, A2, A3};
const uint8_t PINS = sizeof(pin);

void setup() {
  Serial.begin(115200);
  Serial.println("CAN Empfänger");

  CAN.setClockFrequency(8E6);                     // Taktfrequenz MCP2515 8 Mhz
  if (!CAN.begin(500E3)) {                        // Start CAN Bus mit 500 kbps
    Serial.println("Start CAN fehlgeschlagen!");
    while (1);
  }
  CAN.filter(FILTER_ID);                          // nur die angegebene ID wird durchgelassen
  CAN.onReceive(onReceive);                       // Pin 2 für Interrupt

  for (uint8_t n = 0; n < PINS; n++) {
    pinMode(pin[n], OUTPUT);
  }
}

void loop() {
}

void onReceive(int packetSize) {
  Serial.print("Empfangen Paket mit ID 0x");
  Serial.print(CAN.packetId(), HEX);

  if (!CAN.packetRtr()) {
    Serial.print(" und Länge ");
    Serial.println(packetSize);

    while (CAN.available()) {
      byte2pin(CAN.read());
    }
  }
  Serial.println();
}

void byte2pin(uint8_t wert) {
  for (uint8_t n = 0; n < PINS; n++) {
    digitalWrite(pin[n], bitRead(wert, n));
  }
}

Wegen der Warnung habe ich in der Programmbibliothek die Datei ESP32SJA1000.cpp geändert:

alt:
#include "esp_intr.h"

neu:
#include "esp_intr_alloc.h"

Dauerfeuer ist tödlich für CAN. Ein vernünftig ausgelegtes System lastet den Bus zu max. 50% aus. Bei 500kbps wie im Sketch von @agmue bist Du mit einer Nachricht pro Millisekunde auf der sicheren Seite.

Der Anwendungsfall "Ports schalten und quittieren" sieht mir jetzt nicht danach aus als ob du auch nur in die Nähe davon kommen wirst.

Was ich bisher glaube verstanden zu haben:

Die Nanos haben eine Adresse = FILTER_ID (0x21, 0x22, 0x23)

Der ESP sendet Pakete mit den Namen der entsprechenden FILTER_ID

In den Paketen befinden sich dann die Befehle..
Der Nano an 0x21 bekommt ein "hallo21" zugesendet.
Der Nano an 0x22 bekommt das Zufällige Bitmuster.
Der Nano an 0x23 bekommt auch ein "hallo23" zugesendet.

Der Nano an 0x22 (mit dem Zufälligen Bitmuster) schaltet die Ausgänge A0-A3 aufgrund des zufälligen Bitmusters...

Was mir nicht klar wird, ist wie das passiert...
Das random(0, 0x10) erzeugt ja das zufällige Bitmuster im Bereich von 0 bis 0x10.. An dieser Stelle steig ich dann aus... Das raff ich nicht...

0x10 ist doch der HEX wert für 16, oder irre ich da?

Demzufolge erzeugt der Random(0, 0x10) werte von 0-16...
Müsste der Nano dann nicht auch 16 Pins zum schalten haben?

Davon ab ist mir noch nicht ganz klar, wie ich ihm dann zu sagen habe das er halt nur den "einen" pin an / aus knipsen soll...

Da fehlt es noch am Verständnis...

Ich vermute, das das gesendete Bitmuster (sagen wir mal es wird „zufällig“ 2 gesendet) auf den 3. Wert des Pin Arrays (arrays beginnen die Zählung der werte ja bekanntlich bei 0) zeigt & dadurch dann geschaltet wird…

Kommt das soweit hin?

So ungefähr stimmt das. Die zufällige Biterzeugung ist für Dich nicht relevant.

Welche Kriterien gibt es denn für Dich?

Mit digitalen Eingängen beispielsweise etwa so:

  for (uint8_t n = 0; n < PINS; n++) {
    bitWrite(wert, n, digitalRead(pin[n]));
  }
  CAN.write(wert);  // vier signifikante Bits, acht wären möglich

bitWrite()

Naja...
Erstmal die Zieladresse des entsprechenden Nanos (haben wir, mit 0x21, 0x22 & 0x23), dann den zu Schaltenden Pin (ich denke den haben wir auch (über das Array beim Nano) & zu guter letzt den zustand den der Pin einnehmen soll (High / low / 1 / 0)...

Ich denk mal das sollte so hinhauen...

Ich meinte beim ESP32, wie willst Du da die Bits umschalten?

Das ist ne Verdammt gute Frage...

Ich denke das muss in die LCDML_display_dynFunction integriert werden...
Quasi zunächst erstmal parallel zu den bereits benutzten ESP Pins...

Aktuell sieht der Bereich ja so aus: (Beispiel Dauerplus Leitung zum Anhänger)

// ####################################################################
// Dauerplus
// ####################################################################

void dynDauerplus(uint8_t line)
{ 
  const char* dynDauerplus_name; 
  // check if this function is active (cursor stands on this line)
  if (line == LCDML.MENU_getCursorPos())
  {
    // make only an action when the cursor stands on this menu item
    //check Button
    if(LCDML.BT_checkAny())
    {
      if(LCDML.BT_checkEnter())
      {
        // this function checks returns the scroll disable status (0 = menu scrolling enabled, 1 = menu scrolling disabled)
        if(LCDML.MENU_getScrollDisableStatus() == 0)
        {
          // disable the menu scroll function to catch the cursor on this point
          // now it is possible to work with BT_checkUp and BT_checkDown in this function
          // this function can only be called in a menu, not in a menu function
          LCDML.MENU_disScroll();
        }
        else
        {
          // enable the normal menu scroll function
          LCDML.MENU_enScroll();
          if(dynDauerplus_value == 1)
            {
              digitalWrite(17, HIGH);
// hier denke ich sollte dann der CAN Befehl drin stehen...
// Hallo Nano #2, hier ESP, Schalte mal Pin X auf HIGH
// CAN.beginPacket(0x22);
// CAN.write('jo, hier hört dann auf');
// CAN.endPacket();
            }
          else
            {
              digitalWrite(17, LOW);
// Hallo Nano #2, hier ESP, Schalte mal Pin X auf LOW
            }
        }

        // do something
        // ...
        
        LCDML.BT_resetEnter();
      }

      // This check have only an effect when MENU_disScroll is set
      if(LCDML.BT_checkDown() || LCDML.BT_checkRight()) 
       {
        if(dynDauerplus_value < 1)
         {
          dynDauerplus_value++;
         }
        else
         {
          dynDauerplus_value = 0;
         }
       }

       // This check have only an effect when MENU_disScroll is set
       if(LCDML.BT_checkUp() || LCDML.BT_checkLeft())
        {
          if(dynDauerplus_value !=0)
          {
            dynDauerplus_value--;
          }
          else
          {
          dynDauerplus_value = 1;
         }
       }
     }
   }

  //test
  if(dynDauerplus_value == 1)
   {
     dynDauerplus_name = "Ein";
   }
  else
   {
     dynDauerplus_name = "Aus";
   }

   
  char buf[20];
  sprintf (buf, "Dauerplus:     %s", dynDauerplus_name);

  // setup function
  u8g2.drawStr( _LCDML_DISP_box_x0+_LCDML_DISP_font_w + _LCDML_DISP_cur_space_behind,  (_LCDML_DISP_font_h * (1+line)), buf);     // the value can be changed with left or right

  
}

Welche Warnung eigentlich?

Ich glaub, es wär ganz günstig wenn Nano #2 9 Pins Schalten könnte...
Mit dem 9.Pin wäre dann das kleine Relais (würde da nicht auch ein optokoppler tun?) ansteuerbar, das den Terminator auf dem MCP2515 ein & ausschaltet..

Ich fürchte aber fast, das der Nano dann 2 Adressen braucht? 8 Bits sind ja möglich, mit der Terminatorschaltung wären es ja dann 9... Oder seh ich das Falsch?

Darum habe ich sie wohl gestellt :rofl:

Eventuell so (ungetestet):

          if(dynDauerplus_value == 1)
            {
              digitalWrite(17, HIGH);
              // Hallo Nano #2, hier ESP, Schalte mal Pin 0 auf HIGH
              bitWrite(nano2bits, 0, HIGH);
              CAN.beginPacket(0x22);
              CAN.write(nano2bits);
              CAN.endPacket();
            }
          else
            {
              digitalWrite(17, LOW);
              // Hallo Nano #2, hier ESP, Schalte mal Pin 0 auf LOW
              bitWrite(nano2bits, 0, LOW);
              CAN.beginPacket(0x22);
              CAN.write(nano2bits);
              CAN.endPacket();
            }

Wenn Du in der IDE alle Warnungen aktivierst, wird esp_intr.h als veraltet bezeichnet.

Es können bis zu acht Datenbytes verschickt werden, also 8 * 8 Bits = 64 Bits. Also dann zwei Bytes

              CAN.beginPacket(0x22);
              CAN.write(nano2bits0);
              CAN.write(nano2bits1);
              CAN.endPacket();

Du könntest jedem Bit auch eine eigene Adresse zuordnen, bei 11 Bit für die Adresse sind 2047 möglich, "extended" dann noch mehr.

Viele Wege führen nach Rom :wink:

Bei mir auf dem Schreibtisch funktioniert die Kommunikation auch mit drei Abschlußwiderständen.

Ach jo... 8 Bytes.... Warum zum Geier hatte ich denn 8 Bits im Kopf??? :crazy_face:
Oh man... :see_no_evil:

Nice to Know... :thinking: Also mal im Feld testen...

Oder auch verwerfen, lieber einen ESP32 als dritten µC ins Heck, der dann mit dem Anhänger beispielsweise per ESP-NOW funkt. Ohne Anhänger kann man den Funk vom ESP32 abschalten.

Ob eine Rückmeldung dieser Art notwendig ist, möchte ich bezweifeln, da wäre ein Sensor für Dauerplus vermutlich aussagekräftiger, aber möglich ist das natürlich.

Den dritten Nano habe ich mal rausgeworfen:

// ESP32 - TJA1050
//    5V - VCC
//   GND - GND
//    32 - RX
//    33 - TX

#include <CAN.h>  // https://github.com/sandeepmistry/arduino-CAN

void setup() {
  Serial.begin(115200);
  delay (500);
  Serial.println("CAN Sender");

  CAN.setPins(32, 33);                            // RX, TX
  if (!CAN.begin(500E3)) {                        // Start CAN Bus mit 500 kbps
    Serial.println("Start CAN fehlgeschlagen!");
    while (1);
  }
  CAN.onReceive(onReceive);                       // Pin 2 für Interrupt
}

void loop() {
  // sende Paket: ID ist 11 Bits, ein Paket kann bis zu 8 Bytes Daten enthalten
  byte bits1 = random(0, 0x10);
  CAN.beginPacket(0x21);
  CAN.write(bits1);  // vier zufällige Bits
  CAN.endPacket();
  Serial.printf("Sende Paket mit ID 0x21 \t\tInhalt %X\n", bits1);
  delay(1000);

  byte bits2 = random(0, 0x10);
  CAN.beginPacket(0x22);
  CAN.write(bits2);  // vier zufällige Bits
  CAN.endPacket();
  Serial.printf("Sende Paket mit ID 0x22 \t\tInhalt %X\n", bits2);
  delay(1000);
}

void onReceive(int packetSize) {
  byte id = CAN.packetId();
  if (!CAN.packetRtr()) {
    byte bits = 0;
    while (CAN.available()) {
      bits = CAN.read();
    }
    Serial.printf("Empfange Paket mit ID 0x%X und Länge %d \tInhalt %X\n", id, packetSize, bits);
  }
  Serial.println();
}

Nano 1:

// UNO - MCP2515
//  13 - SCK
//  11 - SI
//  12 - SO
//  10 - CS
//   2 - INT

#include <CAN.h>  // https://github.com/sandeepmistry/arduino-CAN
#define FILTER_ID 0x21
const uint8_t pin[] = {A0, A1, A2, A3};
const uint8_t PINS = sizeof(pin);

void setup() {
  Serial.begin(115200);
  Serial.println("CAN Empfänger");

  CAN.setClockFrequency(8E6);                     // Taktfrequenz MCP2515 8 Mhz
  if (!CAN.begin(500E3)) {                        // Start CAN Bus mit 500 kbps
    Serial.println("Start CAN fehlgeschlagen!");
    while (1);
  }
  CAN.filter(FILTER_ID);                          // nur die angegebene ID wird durchgelassen
  CAN.onReceive(onReceive);                       // Pin 2 für Interrupt

  for (uint8_t n = 0; n < PINS; n++) {
    pinMode(pin[n], OUTPUT);
  }
}

void loop() {
}

void onReceive(int packetSize) {
  Serial.print("Empfangen Paket mit ID 0x");
  Serial.print(CAN.packetId(), HEX);

  if (!CAN.packetRtr()) {
    Serial.print(" und Länge ");
    Serial.println(packetSize);

    while (CAN.available()) {
      byte2pin(CAN.read());
    }
  }
  Serial.println();
}

void byte2pin(uint8_t wert) {
  for (uint8_t n = 0; n < PINS; n++) {
    digitalWrite(pin[n], bitRead(wert, n));
  }
  Serial.print("Sende Paket ID = 0x31");
  CAN.beginPacket(0x31);
  CAN.write(wert);  // empfangene Bits als Antwort
  CAN.endPacket();
}

Nano 2 (bei mir ein UNO):

// UNO - MCP2515
//  13 - SCK
//  11 - SI
//  12 - SO
//  10 - CS
//   2 - INT

#include <CAN.h>  // https://github.com/sandeepmistry/arduino-CAN
#define FILTER_ID 0x22
const uint8_t pin[] = {A0, A1, A2, A3};
const uint8_t PINS = sizeof(pin);

void setup() {
  Serial.begin(115200);
  Serial.println("CAN Empfänger");

  CAN.setClockFrequency(8E6);                     // Taktfrequenz MCP2515 8 Mhz
  if (!CAN.begin(500E3)) {                        // Start CAN Bus mit 500 kbps
    Serial.println("Start CAN fehlgeschlagen!");
    while (1);
  }
  CAN.filter(FILTER_ID);                          // nur die angegebene ID wird durchgelassen
  CAN.onReceive(onReceive);                       // Pin 2 für Interrupt

  for (uint8_t n = 0; n < PINS; n++) {
    pinMode(pin[n], OUTPUT);
  }
}

void loop() {
}

void onReceive(int packetSize) {
  Serial.print("Empfangen Paket mit ID 0x");
  Serial.print(CAN.packetId(), HEX);

  if (!CAN.packetRtr()) {
    Serial.print(" und Länge ");
    Serial.println(packetSize);

    while (CAN.available()) {
      byte2pin(CAN.read());
    }
  }
  Serial.println();
}

void byte2pin(uint8_t wert) {
  for (uint8_t n = 0; n < PINS; n++) {
    digitalWrite(pin[n], bitRead(wert, n));
  }
  Serial.print("Sende Paket ID = 0x32");
  CAN.beginPacket(0x32);
  CAN.write(wert);  // empfangene Bits als Antwort
  CAN.endPacket();
}

Mein Aufbau:

Wow sieht ja ganz schön wüst aus... :wink:

Naja... Die Rückmeldung ob der Pin geschaltet hat, oder nicht, wird ja dann im OLED Display als Icon angezeigt... Daher denk ich mal das ne Rückmeldung sinnig ist... - Oder ist das anders lösbar?
Das Icon im Display darf halt nur auftauchen, wenn das Entsprechende Gerät was eingeschaltet werden soll auch tatsächlich "online" ist...

Ist halt die Frage, was Du überprüfen willst. Die gesendeten Bits zu überprüfen bringt Dir die Erkenntnis, der Nano ist verbunden und "lebt". Spannender fände ich die Information, "Dauerplus hat Spannung".

Aus Campersicht: Meine Dose im Heck hat immer Dauerplus, sagt der Name, und Ladeplus bei stromerzeugender Lichtmaschine. Ohne Batterie im WoWa hängt an Ladeplus der Kühlschrank dran. Das geht ganz ohne Elektronik, nur ein (VW) oder zwei (Reisschüssel) Relais.

Ist ja nicht nur Dauerplus und Ladeleitung...
Sind ja noch ganz andere Sachen mit Involviert...

Z.B. TFT Display, Inverter, USB - Ladeports in der Armlehne, Anhänger-Blinkewüberwachung, etc...

In der "Vollausstattung" also 1 Nano mit 2 IRF Karten (ohne nen MCP23017) stünden ja noch ein paar Analoge Ports zur Verfügung über die man die Spannung auf der Dauerplus & Ladeleitung problemlos messen & auf den Bus legen könnte... (Natürlich über nen Spannungsteiler..)
Schwebt Dir so eine Lösung als Rückmeldung vor?

Ja, sowas schwebt!

Allerdings gibt es Spannungsspitzen, die sehr gut gefiltert werden müssen. Der analoge Wert ist nicht so wichtig, daher würde ich mich mit einem digitalen Signal begnügen und zur Sicherheit einen Optokoppler spendieren.

Auf jeden Fall besser als nur das Echo vom Bit.

Hmm... Ein PC817 mit entsprechenden Vorwiderstand sollte da ja ausreichen...

Den erfassenden pin dann als INPUT_PULLUP definieren & mit dem Optokoppler auf GND ziehen...

Ja, das entspricht meinen Ideen.

Eventuell wegen der Spannungsspitzen noch ein kleiner Kondensator parallel zur LED.

Moin zusammen...

Nochmal ne etwas allgemeinere Frage zum ESP32... (gewisser Unsicherheitsfaktor)

Ich plane in das Projekt ja Innen & Außentemperatursensoren (DS18B20) ein...
Der Außensensor hat "ab Werk" schonmal ne 3m Zuleitung... (die braucht´s auch, wenn nicht länger)
Ich hab gelesen, das bei Leitungslängen bis 1m die 3v3 des ESPs ausreichen & man bei längeren Leitungswegen den Sensor eher über 5V befeuern sollte...

Wie sind eure Erfahrungen damit?
Wenn über 5V, klappt der 1Wire Bus über nen LevelShifter?
Wenn ja, den PullUp Resistor dann vermutlich zwischen LevelShifter & DS18B20, korrekt?

Oder doch lieber die "andere" Variante, 5V auf den DS18B20 und über nen 4k7 R die 3v3 auf die Datenleitung?

Was funktioniert besser, stabiler, etc?

UPDATE:
Bin jetzt gerade dabei die CAN Geschichte ans laufen zu bekommen, komm da aber leider gerade nicht weiter...

Ich hab in der Datei "LCDML_display_dynFunction" die variable nano2bits angelegt.

// CAN Variable..
uint8_t nano2bits;

und versuche nun den Dauerplus über CAN einzuschalten:

LCDML.MENU_enScroll();
          if(dynDauerplus_value == 1)
            {
              digitalWrite(17, HIGH);
              bitWrite(nano2bits, 0, HIGH);
              CAN.beginPacket(0x22);
              CAN.write(nano2bits);
              CAN.endPacket();
            }
          else
            {
              digitalWrite(17, LOW);
              bitWrite(nano2bits, 0, LOW);
              CAN.beginPacket(0x22);
              CAN.write(nano2bits);
              CAN.endPacket();
            }

Allerdings bekomm ich am Nano im Seriellen Monitor keine "Ich hab da was empfangen" Meldung...

Nano Code:

/* Nano - MCP2515
 *  13 - SCK
 *  11 - SI
 *  12 - SO
 *  10 - CS
 *  2 - INT
 *  
 *   Output Pins: 
 *   
 *   3 = IRF Karte 1 Port 1        == Byte 0 Bit 0
 *   4 = IRF Karte 1 Port 2        == Byte 0 Bit 1
 *   5 = IRF Karte 1 Port 3        == Byte 0 Bit 2
 *   6 = IRF Karte 1 Port 4        == Byte 0 Bit 3
 *   7 = IRF Karte 2 Port 1        == Byte 0 Bit 4
 *   8 = IRF Karte 2 Port 2        == Byte 0 Bit 5
 *   9 = IRF Karte 2 Port 3        == Byte 0 Bit 6
 *   A0 / 14 = IRF Karte 2 Port 4  == Byte 0 Bit 7 --> Byte 0 Voll
 */

#include <CAN.h>  // https://github.com/sandeepmistry/arduino-CAN

// entsprechendes Auskommentieren...
//#define FILTER_ID 0x21    // Nano #1 = IRF Karten 1 & 2
#define FILTER_ID 0x22    // Nano #2 = IRF Karten 3 & 4
//#define FILTER_ID 0x29    // Nano #3 = Im Anhänger

const uint8_t pin[] = {3, 4, 5, 6, 7, 8, 9, A0}; // = Alle 2 IRF Karten im Byte 0
const uint8_t PINS = sizeof(pin);

void setup() {
  Serial.begin(115200);
  Serial.print("Iam a CAN Receiver, my adress is 0x");
  Serial.println(FILTER_ID, HEX);

  CAN.setClockFrequency(8E6);                     // Taktfrequenz MCP2515 8 Mhz
  if (!CAN.begin(500E3)) {                        // Start CAN Bus mit 500 kbps
    Serial.println("Start CAN fehlgeschlagen!");
    while (1);
  }
  CAN.filter(FILTER_ID);                          // nur die angegebene ID wird durchgelassen
  CAN.onReceive(onReceive);                       // Pin 2 für Interrupt

  for (uint8_t n = 0; n < PINS; n++) {
    pinMode(pin[n], OUTPUT);
  }
}

void loop() {
}

void onReceive(int packetSize) {
  Serial.print("Empfangen Paket mit ID 0x");
  Serial.print(CAN.packetId(), HEX);

  if (!CAN.packetRtr()) {
    Serial.print(" und Länge ");
    Serial.println(packetSize);

    while (CAN.available()) {
      byte2pin(CAN.read());
    }
  }
  Serial.println();
}

void byte2pin(uint8_t wert) {
  for (uint8_t n = 0; n < PINS; n++) {
    digitalWrite(pin[n], bitRead(wert, n));
  }
}

Ist da was falsch oder muss ich in der Verkabelung suchen?

Gerade mal CAN HIGH gegen GND gemessen... ist stabil auf 2.2 V ohne Ausschlag nach oben / unten... Kommt also nix raus...
War der LevelShifter doch keine so gute Idee?

Nach entfernen des Levelshifters aus dem Datenkreis (TJA105 direkt am ESP) hatte ich dann kein WLAN mehr... Total merkwürdig... Dann den LevelShifter wieder rein, WLAN wieder da...
Funktionieren tuts trotzdem nich... :sob:

LG

Mache es doch mal so wie ich in #230.

Sollte das Foto nicht deutlich genug sein, stehen die Verbindungen auch im Programm :rofl:

So ganz doof bin ich ja nun auch nicht...

Hab die Pins eigentlich korrekt belegt.. Hab zumindest akribisch darauf geachtet.. Hab halt nur nen LevelShifter dazwischen - der bei Dir ja fehlte...

bei mir fehlte auch die Compilerwarnung bezüglich der esp_intr.h
Vielleicht hattest Du ne Veraltete Lib am start, und ich hatte schon ne neuere??? :man_shrugging:
Jedenfalls hab ich (bisher) noch nicht die Änderung in der ESP32SJA1000.cpp ausgeführt..
Eben weil keine Compilerwarnung da war... (Ja steht auf "alles")..

Du hast quasi den CAN kram "stand alone" im ESP & Nano/Uno... - ich hab das direkt versucht in die LCDML zu integrieren...

  • so viele Faktoren...

Reduzieren, Fehler einkreisen und rauswerfen. Frag' mich nicht, wie oft ich das schon gemacht habe.

Erst als ich den TJA1050 mit 5 V versorgt habe, hat es bei mir funktioniert.