ESP32 mit CJMCU230 Transceiver

[Shannah (Gast)]

Hallo zusammen,

ich hab ein ESP32 CAN Problem, bei dem ich nicht mehr weiterkomme.

Ich habe zwei ESP 32 (ESP32-WROOM) und möchte mit dem ESP32 eigenen 
CAN-Controller und zwei Transceivern (CJMCU 230 ( Sn65hvd230)) gerne 
eine CAN-Nachricht von einem zum anderen schicken.

Gefunden habe ich diese Demo:
http://www.iotsharing.com/2017/09/how-to-use-arduino-esp32-can-interface.html

leider funktioniert sie jedoch (bei mir) nicht.
Als zugehörige Bibliothek habe ich diese verwendet:

https://github.com/nhatuan84/esp32-can-protocol-demo/blob/master/examples/esp32can/esp32can.ino

Die GPIO habe ich mit 4 und 5 beibehalten, die Baudrate allerdings auf 
125kBPS gesetzt (bzw verschiedene getestet).

Es werden keine Daten hin und her transferiert.


Deshalb habe ich einen der ESP32 als EMpfänger beibehalten mit dem 
Receiver Code von nhatuan84

#include <ESP32CAN.h>
#include <CAN_config.h>

CAN_device_t CAN_cfg;
CAN_frame_t rx_frame;

void setup() {
    Serial.begin(115200);
    Serial.println("iotsharing.com CAN demo");
    CAN_cfg.speed=CAN_SPEED_125KBPS;
    CAN_cfg.tx_pin_id = GPIO_NUM_5;
    CAN_cfg.rx_pin_id = GPIO_NUM_4;
    
   // xQueueCreate(number of item the queue can hold,size of each item);
    CAN_cfg.rx_queue = xQueueCreate(10,sizeof(CAN_frame_t));
    //initialize CAN Module
    ESP32Can.CANInit();
}

void loop() {
    //CAN_frame_t rx_frame;
    //receive next CAN frame from queue
    //xQueueReceive( xQueue, &DataToReceive, xBlockTime );
    if(xQueueReceive(CAN_cfg.rx_queue,&rx_frame, 3*portTICK_PERIOD_MS)==pdTRUE){

      //do stuff!
      if(rx_frame.FIR.B.FF==CAN_frame_std)
        printf("New standard frame");
      else
        printf("New extended frame");

      if(rx_frame.FIR.B.RTR==CAN_RTR)
        printf(" RTR from 0x%08x, DLC %d\r\n",rx_frame.MsgID,  rx_frame.FIR.B.DLC);
      else{
        printf(" from 0x%08x, DLC %d\n",rx_frame.MsgID,  rx_frame.FIR.B.DLC);
        /* convert to upper case and respond to sender */
        for(int i = 0; i < 8; i++){
          printf("0x%02X ", rx_frame.data.u8[i]);
          }
        
      }
      //respond to sender
     // ESP32Can.CANWriteFrame(&rx_frame);
    }
}

und als Sender einen Arduino Mega verwendet mit dem SEED CAN Bus Shild 
und der SEED Bibliothek
(http://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/)

und folgendem Code

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

/*SAMD core*/
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
    #define SERIAL SerialUSB
#else
    #define SERIAL Serial
#endif

// the cs pin of the version after v1.1 is default to D9
// v0.9b and v1.0 is default D10
const int SPI_CS_PIN = 9;

MCP_CAN CAN(SPI_CS_PIN);                                    // Set CS pin

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

    while (CAN_OK != CAN.begin(CAN_125KBPS, MCP_16MHz)) {            // init can bus : baudrate = xxxk
        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);

Serial.println("Send data : ");
 
   for(int i = 0; i<8; i++)    // print the data of CAN 
        {
            
          Serial.print(stmp[i]);
           Serial.print("\t");
        }
        Serial.println();
    
    delay(1000);                       // send data per 100ms
}

Der Mega sendet auch, und der ESP32 empfängt ebenfalls Daten, allerdings 
nicht in den angegebenen delay(1000), sondern die Daten rasseln am ESP32 
einfach nur so rein. Er gibt mir mehrmals den canFrame
[0 0 0 0 0 0 0 1] und
[0 0 0 0 0 0 0 2] aus und bleibt dann auf Ewigkeiten einfach bei
[0 0 0 0 0 0 0 3] hängen.

Wenn ich im ESP32 Code die Zeile
"// ESP32Can.CANWriteFrame(&rx_frame);" auskommentiere, empfängt der 
ESP32
einmal den Frame mit der Zahl 3


08:13:04.786 -> rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
08:13:04.786 -> configsip: 0, SPIWP:0xee
08:13:04.786 -> 
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
08:13:04.786 -> mode:DIO, clock div:1
08:13:04.786 -> load:0x3fff0018,len:4
08:13:04.786 -> load:0x3fff001c,len:1100
08:13:04.786 -> load:0x40078000,len:9344
08:13:04.786 -> load:0x40080400,len:6348
08:13:04.786 -> entry 0x400806a8
08:13:04.905 -> iotsharing.com CAN demo
08:13:04.905 -> New standard frame from 0x00000000, DLC 8
08:13:04.905 -> 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x03 New standard 
frame from 0x00000000, DLC 8


Sowohl Shield als auch der ESP32 Tranceiver sollen nach Datanblatt 120 
Ohm terminiert sein. Ich habe keine ahnung mehr, woran es liegen könnte, 
und bin für jeden Tipp dankbar.

Viele Grüße