Auslesen CAN-BUS, RS-485 oder RS-232 (nur Auslesen)

1fabu-80 · June 20, 2025, 8:29am

Hallo Frage an Euch, vielleicht wisst ihr wie "verbessern".
Ich habe nun auf 2 Seiten je einmal die Werte von dem BMS und einmal vom ESC.
Das klappt. Ich verwende hierfür Sprites, welche ich dann über den einen Button schalte.
Leider flackert es jetzt doch - wo ist mein Logikfehler, ist der Fehler vielleicht, dass ich für jeden CAN eine eigene Funktion aufrufe, diese dann wiederum eine Sprite erzeugt....
Ich poste mal den Code:

#include <FlexCAN_T4.h>

#include <TFT_eSPI.h>
#include "SPI.h"
#include <SoftwareSerial.h>
#include <Streaming.h>
#define WHITE       0xFFFF
#define BLACK       0x0000
#define BLUE        0x001F
#define RED         0xF800
#define MAGENTA     0xF81F
#define GREEN       0x07E0
#define CYAN        0x7FFF
#define YELLOW      0xFFE0

#define SCREEN_WIDTH 240          
#define SCREEN_HEIGHT 320

#define RST_PIN 9                
#define DC_PIN 15 
#define CS_PIN 10                 
#define MOSI_PIN 11
#define SCLK_PIN 13

TFT_eSPI tft = TFT_eSPI();      

// Umschalten Pages = Sprites
TFT_eSprite img = TFT_eSprite(&tft);
TFT_eSprite img2 = TFT_eSprite(&tft);


FlexCAN_T4<CAN1, RX_SIZE_256, TX_SIZE_16> can1;
FlexCAN_T4<CAN2, RX_SIZE_256, TX_SIZE_16> can2;
CAN_message_t msg;

  long unsigned int rxId;
  long unsigned int rxId_EMUS;

struct CANDATA
  {
    //MGM Compro ESC Variablen
    uint16_t batVoltage;
    uint16_t batCurrent;
    int32_t rpm;
    int16_t motoTemp;
    int16_t escTemp;
    int16_t externTemp;
    int16_t pwmOut;
    int16_t pwmIn;
    uint32_t error;
    uint32_t warning;
    uint32_t notice;
    uint16_t escInit;
    uint16_t bVoltage;
    uint16_t feedVoltage;
    uint16_t phaseCurrent;
    uint16_t avarangeCurrent;
    uint8_t busVoltage;
    uint8_t mosfetTemp;

    //EMUS BMS Variablen
    uint8_t emusMinCellTemp;
    uint8_t emusMaxCellTemp;
    uint8_t emusAvgCellTemp;

    uint16_t emusMinCellVolt;
    uint16_t emusMaxCellVolt;
    uint16_t emusAvgCellVolt;
    uint32_t emusTotCellVolt;

  };

CANDATA candata;
CANDATA olddata;

bool isNew;

// Umschalten Pages Variablen
int chosenOne=0;
int dbounce=0;

void setup(void) {

  //Serial.begin(115200); // auskommentiert
  Serial.begin(115200); 
  Serial.println(F("Start...."));
  tft.init();
  tft.setRotation(2); 

  // SPRITE EMUS, MGM, später noch GPS
  img.createSprite(240, 240);
  img2.createSprite(240, 240);


  tft.fillScreen(BLACK); 
  tft.setCursor(0, 10);
  tft.setTextColor(WHITE);
  tft.setTextSize(1);
  tft.setTextWrap(true);
  tft.print(F("Start"));

  for (byte b = 0; b < 4; b++)
  {
    delay(100);
    tft.print('.');
  }

  delay(200);

  can1.begin();
  can1.setBaudRate(500000);
  can2.begin();
  can2.setBaudRate(125000);

  tft.fillScreen(BLACK); 

  //Umschalten Pages PIN aktivieren
  pinMode(5,INPUT_PULLUP);

}

void tftData_EMUS()
  {
  int x = 145; // Abstand von Links für den Wert
  int y = 0;  // Abstand von Links für Beschriftung
  int o = 35; // Offset-Wert

  img.setTextDatum(L_BASELINE);
  img.drawString((static_cast < float > (candata.emusMinCellVolt) * 0.01 + 2), x, 1*o, 2);
  img.drawString("Cmin [ V]", y , 1*o , 4);

  img.drawString((static_cast < float > (candata.emusMaxCellVolt) * 0.01 + 2), x, 2*o, 2);
  img.drawString("Cmax [ V]", y , 2*o , 4);

  img.drawString((static_cast < float > (candata.emusTotCellVolt) / 100 ), x, 3*o, 2);
  img.drawString("Ubat [ V]", y , 3*o , 4);

  img.drawString(static_cast < float > ((candata.emusMinCellTemp) - 100), x, 4*o, 2);
  img.drawString("Tmin [ °C]", y , 4*o , 4);

  img.drawString(static_cast < float > ((candata.emusMaxCellTemp) - 100), x, 5*o, 2);
  img.drawString("Tmax [°C]", y , 5*o , 4);

  img.pushSprite(0, 40);

  }

void tftData_MGM() 
  {
  int x = 145; // Abstand von Links für den Wert
  int y = 0;  // Abstand von Links für Beschriftung
  int o = 35; // Offset-Wert

  img2.setTextDatum(L_BASELINE);
  img2.drawString(((candata.batVoltage) * 0.1), x, 1*o, 2);
  img2.drawString("BATT [V]", y, 1*o, 4);

  img2.drawString((static_cast < float > (candata.batCurrent) * 0.1), x, 2*o, 2);
  img2.drawString("BATT [A]", y, 2*o, 4);

  img2.drawString((static_cast < float > (candata.rpm)), x, 3*o, 2);
  img2.drawString("RPM [1/min]", y, 3*o, 4);

  img2.pushSprite(0, 40);

  }

void loop() {

  // SPRITE füllen mit Background-Farbe
  img.fillSprite(BLACK);
  img2.fillSprite(BLACK);

  //can1.setMBFilter(0, 0x001); // Set mailbox 6 to allow CAN ID 0x123 to be collected - aus Flexcan
  if ( can1.read(msg) ) {

    rxId = (msg.id);


  //can1.read - MGM
    Serial.print(msg.mb);
    Serial.print("  ID: 0x");
    Serial.print(msg.id, HEX ); // von Sparkfun switch (rxId) reinbekommen und auslesen

    Serial.print(" DATA: ");
    for ( uint8_t i = 0; i < 8; i++ ) {
      Serial.print(msg.buf[i]); Serial.print(" ");
    }
    Serial.print("  TS: ");
    Serial.println(msg.timestamp);
  //auskommentieren



    switch (rxId)
  {
    case 0x1:
      //candata.batVoltage = msg.buf[0] | msg.buf[1]; //wird durch 2 Zeilen ersetzt welche analog zur Beschreibung aufsummiert werden
      candata.batVoltage = msg.buf[0];
      candata.batVoltage += static_cast < uint32_t > (msg.buf[1]) << 8;

      //candata.batCurrent = msg.buf[2] | msg.buf[3]; //wird durch 2 Zeilen ersetzt welche analog zur Beschreibung aufsummiert werden
      candata.batCurrent = msg.buf[2];
      candata.batCurrent += static_cast < uint32_t > (msg.buf[3]) << 8;
      
      candata.rpm = msg.buf[4];
      candata.rpm += static_cast < uint32_t > (msg.buf[5]) << 8; // += aufsummieren & 1<<1 ist 2 & 1<<2 ist 4 1<<3 ist 8 & 1<<8 ist 256 also 1<<8 ist gleich 2hoch8
      candata.rpm += static_cast < uint32_t > (msg.buf[6]) << 16;
      candata.rpm += static_cast < uint32_t > (msg.buf[7]) << 24;
      break;

    case 0x2:
      candata.motoTemp = msg.buf[0] | msg.buf[1];

      candata.escTemp = msg.buf[2];
      candata.escTemp += static_cast < uint32_t > (msg.buf[3]) << 8;

      candata.externTemp = msg.buf[6] | msg.buf[7];
      break;

    case 0x3:

      candata.pwmOut = msg.buf[0];
      candata.pwmOut += static_cast < uint32_t > (msg.buf[1]) << 8;

      candata.pwmIn = msg.buf[2];
      candata.pwmIn += static_cast < uint32_t > (msg.buf[3]) << 8;
      break;

    case 0x4:

      candata.error = msg.buf[0];
      candata.error += static_cast < uint32_t > (msg.buf[1]) << 8;
      candata.error += static_cast < uint32_t > (msg.buf[2]) << 16;
      candata.error += static_cast < uint32_t > (msg.buf[3]) << 24;
      candata.warning = msg.buf[4];
      candata.warning += static_cast < uint32_t > (msg.buf[5]) << 8;
      candata.warning += static_cast < uint32_t > (msg.buf[6]) << 16;
      candata.warning += static_cast < uint32_t > (msg.buf[7]) << 24;
      break;

    case 0x5:

      candata.notice = msg.buf[0];
      candata.notice += static_cast < uint32_t > (msg.buf[1]) << 8;
      candata.notice += static_cast < uint32_t > (msg.buf[2]) << 16;
      candata.notice += static_cast < uint32_t > (msg.buf[3]) << 24;
      candata.escInit = msg.buf[6] | msg.buf[7];;
      break;

    case 0x6:

      candata.bVoltage = msg.buf[0];
      candata.bVoltage += static_cast < uint32_t > (msg.buf[1]) << 8;

      candata.feedVoltage = msg.buf[2];
      candata.feedVoltage += static_cast < uint32_t > (msg.buf[3]) << 8;

      candata.phaseCurrent = msg.buf[4];
      candata.phaseCurrent += static_cast < uint32_t > (msg.buf[5]) << 8;

      candata.avarangeCurrent = msg.buf[6];
      candata.avarangeCurrent += static_cast < uint32_t > (msg.buf[7]) << 8;
      break;

    case 0x7:
      candata.busVoltage = msg.buf[4] | msg.buf[5];
      candata.mosfetTemp = msg.buf[6] | msg.buf[7];
      break;
  }
}


  else if ( can2.read(msg) ) {

    rxId_EMUS = (msg.id);

    Serial.print("CAN2 "); 
    Serial.print("MB: "); Serial.print(msg.mb);
    Serial.print("  ID: 0x"); Serial.print(msg.id, HEX );
    Serial.print("  EXT: "); Serial.print(msg.flags.extended );
    Serial.print("  LEN: "); Serial.print(msg.len);
    Serial.print(" DATA: ");
    for ( uint8_t i = 0; i < 8; i++ ) {
      Serial.print(msg.buf[i]); Serial.print(" ");
    }
    Serial.print("  TS: "); Serial.println(msg.timestamp);


    switch (rxId_EMUS)
  {
    case 0x19B50001: //Battery Voltage Overall Parameters 189 191 190 21 89 0 0 0
      candata.emusMinCellVolt = msg.buf[0];
      candata.emusMaxCellVolt = msg.buf[1];
      candata.emusAvgCellVolt = msg.buf[2];

      candata.emusTotCellVolt = msg.buf[4];
      candata.emusTotCellVolt += static_cast < uint32_t > (msg.buf[3]) << 8;
      candata.emusTotCellVolt += static_cast < uint32_t > (msg.buf[6]) << 16;
      candata.emusTotCellVolt += static_cast < uint32_t > (msg.buf[5]) << 24;

      break;

    case 0x19B50002: // Cell Module Temperature Overall Parameters 119 120 119 0 0 0 0 0

      candata.emusMinCellTemp = msg.buf[0];
      candata.emusMaxCellTemp = msg.buf[1];
      candata.emusAvgCellTemp = msg.buf[2];

      break;
  }
}

//Umschalten Pages
  if(digitalRead(5)==0) //12
  {
    if(dbounce==0)
       {
        dbounce=1;
        chosenOne++;
        if(chosenOne>=2)
        chosenOne=0;
        }
    }else dbounce=0;

  if(chosenOne==0)
  tftData_EMUS();
  tft.fillScreen(BLACK);


  if(chosenOne==1)
  tftData_MGM();
  tft.fillScreen(BLACK);


  if(chosenOne==2)
  tftData_EMUS();
  tft.fillScreen(BLACK);

}

Topic		Replies	Views
TFT Display mit Canshield Deutsch	34	3644	May 6, 2021
Auslesen von Telemetriedaten, Darstellung auf LCD Deutsch	21	10820	May 6, 2021
Arduino Uno - Nextion Display - Datenübergabe aus CAN an Display Deutsch	14	1700	May 6, 2021
größeres Display für Uno oder 2009, einfach anzusteuern mit einfacher lib? Deutsch	36	7266	May 6, 2021
Display ohne Probleme Deutsch	72	20775	May 6, 2021

Auslesen CAN-BUS, RS-485 oder RS-232 (nur Auslesen)

Related topics