LED über CAN-BUS schalten

[Ulrich W. (ruestmeister)]

Hallo

Ich möchte gerne eine LED an einem ESP32 über eine Taste am anderen 
ESP32 und CAN-BUS schalten. Bin noch relativ neu beim ESP32 
programmieren und hänge jetzt ein bisschen. Die CAN Verbindung läuft 
schon. Auch kann ich schon die gesendeten Daten mit einem Tastendruck 
ändern. Aber beim Auslesen des Datenstrings und dem Schalten der LED 
habe ich noch Probleme da ich noch nicht ganz verstehe was da eigentlich 
wie gesendet wird. Auch die Suche im Internet hat mich noch nicht 
unbedingt schlauer gemacht. Habe folgenden Code. Das ist das Example von 
der Library "MCP_CAN" https://github.com/coryjfowler/MCP_CAN_lib
Habe nur beim Sender eine Variable "ggg" eingefügt die je nach 
Tastendruck entweder auf 0x00 oder 0x01 gesetzt wird. Eben dieses 0x00 
oder 0x01 würde ich gerne mit dem CAN-Receiver abfragen und die LED 
dementsprechend schalten.
Für Hilfe wie immer sehr dankbar.
Gruß Uli

CAN-Sender:

#include <Arduino.h>

// CAN Send Example
//

#include <mcp_can.h>
#include <SPI.h>

MCP_CAN CAN0(5);     // Set CS to pin 5
int ggg=0x00;
int inPin=2;


void setup()
{
  pinMode(inPin, INPUT_PULLUP);
  Serial.begin(115200);

  // Initialize MCP2515 running at 16MHz with a baudrate of 500kb/s and the masks and filters disabled.
  if(CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ) == CAN_OK) Serial.println("MCP2515 Initialized Successfully!");
  else Serial.println("Error Initializing MCP2515...");

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



void loop()
{
  
   if (digitalRead(inPin)==LOW){
    ggg = 0x01;
  } else {
    ggg = 0x00;
  }
  byte data[2] = {ggg, 0x01};
  // send data:  ID = 0x100, Standard CAN Frame, Data length = 8 bytes, 'data' = array of data bytes to send
  byte sndStat = CAN0.sendMsgBuf(0x100, 0, 2, data);
  if(sndStat == CAN_OK){
    Serial.println("Message Sent Successfully!");
  } else {
    Serial.println("Error Sending Message...");
  }
  delay(100);   // send data per 100ms
}

/*********************************************************************************************************
  END FILE
*********************************************************************************************************/

CAN-Receiver

#include <Arduino.h>

#include <mcp_can.h>
#include <SPI.h>

long unsigned int rxId;
unsigned char len = 0;
unsigned char rxBuf[8];
char msgString[128];                        // Array to store serial string

#define CAN0_INT 17                              // Set INT to pin 17
MCP_CAN CAN0(5);                               // Set CS to pin 5
int LED=2;


void setup()
{
  Serial.begin(115200);
  
  // Initialize MCP2515 running at 16MHz with a baudrate of 500kb/s and the masks and filters disabled.
  if(CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ) == CAN_OK)
    Serial.println("MCP2515 Initialized Successfully!");
  else
    Serial.println("Error Initializing MCP2515...");
  
  CAN0.setMode(MCP_NORMAL);                     // Set operation mode to normal so the MCP2515 sends acks to received data.

  pinMode(CAN0_INT, INPUT);                            // Configuring pin for /INT input
  
  Serial.println("MCP2515 Library Receive Example...");
  
}



void loop()
{
  if(!digitalRead(CAN0_INT))                         // If CAN0_INT pin is low, read receive buffer
  {
    CAN0.readMsgBuf(&rxId, &len, rxBuf);      // Read data: len = data length, buf = data byte(s)
    
    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 == 100){
      digitalWrite(LED, HIGH);
    } else{
      digitalWrite(LED, LOW);
    }
  
    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();
  }
}

/*********************************************************************************************************
  END FILE
*********************************************************************************************************/

[Harald A. (embedded)]

An der Stelle, wo Du die ID auf 100 abfragst, musst Du die Daten in 
rxBuf prüfen, denn dort wird abgelegt, was Du gesendet hast. Dort wird 
also an den ersten beiden Bytes „ggg“ (rxBuf[0]) und 0x01 (rxBuf[1]) 
abgelegt.
Könnte übrigens sein, dass Du gleich angepflaumt wirst, weil Du den Code 
in den Text eingefügt hast - sei tapfer!

Übrigens (und dafür werde ich vlt. gleich angemacht werden): Lade mal 
genau die Programmschnipsel getrennt nacheinander bei ChatGPT hoch 
(einfach in den Chat Copy und Paste) und stelle deine spezifischen 
Fragen. Du wirst überrascht sein, was da geht und was Du lernen kannst.

Was ich Dir auch wärmstens empfehlen würde, wäre ein Logic Analyzer, 
einer für 10€ reicht. Damit kannst Du schön beobachten, was per SPI 
gesendet wird und was auf dem CAN los ist. Beim SPI kann man bei den 
langsamen LA zwar keine 10MBit machen, aber für den Anfang reichen ja 
auch mal 1MBit. Weiß nicht, was die Lib da voreinstellt.

Edit:
Habe es gerade mal in ChatGPT reingestellt, er schlägt folgenden Code 
vor:

void loop()
{
  if (!digitalRead(CAN0_INT)) // Wenn CAN0_INT-Pin niedrig ist, 
Nachricht empfangen
  {
    CAN0.readMsgBuf(&rxId, &len, rxBuf); // Nachricht lesen

    // Prüfen, ob die empfangene Nachricht die erwartete ID hat (hier 
0x100)
    if (rxId == 0x100)
    {
      // Extrahieren Sie den Wert von ggg aus den empfangenen Daten
      if (len >= 2) // Stellen Sie sicher, dass genug Daten empfangen 
wurden
      {
        ggg = rxBuf[0]; // Die erste Byte in rxBuf enthält ggg

        // Jetzt können Sie ggg verwenden, um die LED zu steuern
        if (ggg == 0x01)
        {
          digitalWrite(LED, HIGH); // LED einschalten
        }
        else
        {
          digitalWrite(LED, LOW); // LED ausschalten
        }
      }
      else
      {
        Serial.println("Nicht genug Daten empfangen.");
      }
    }
  }
}

[Ulrich W. (ruestmeister)]

Wow! Ich habe ja schon davon gehört dass man chatGPT zum programmieren 
verwenden kann aber das plättet mich jetzt schon. Da werde ich mich wohl 
mal mit beschäftigen müssen. Vielen Dank für die schnelle und sehr 
hilfreiche Antwort. Und sorry dass ich den Code in den Text geschrieben 
habe.