//
// Warning: don't edit - generated by generate_ecu_code.pl processing ../dev/edmei1.json: EDM 12: Electrical digital motor electronics (low voltage ECU)
// This generated code  makes it easier to process CANBUS messages from the EDM ecu in a BMW i3
//

  case I3_PID_EDM_ENTLUEFTUNG_KUEHLSYSTEM: {                                      // 0xA1D0
    if (datalen < 3) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_ENTLUEFTUNG_KUEHLSYSTEM", 3);
        break;
    }

    unsigned char STAT_ROUTINE_STATUS = (RXBUF_UCHAR(0));
        // Status of the routine. See table TAB_ENTLUEFTUNGSROUTINE_STATUS / Status der Routine. Siehe Tabelle
        // TAB_ENTLUEFTUNGSROUTINE_STATUS
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ENTLUEFTUNG_KUEHLSYSTEM", "STAT_ROUTINE_STATUS", STAT_ROUTINE_STATUS, "\"0-n\"");

    unsigned short STAT_RESTZEIT_WERT = (RXBUF_UINT(1));
        // Remaining time of the routine in seconds / Restzeit der Routine in Sekunden
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "ENTLUEFTUNG_KUEHLSYSTEM", "STAT_RESTZEIT_WERT", STAT_RESTZEIT_WERT, "\"s\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_MCAMOS: {                                                       // 0xADFA
    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_12V_NACHLADEHISTORIE_LOESCHEN: {                                // 0xAE02
    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_12V_NACHLADEHISTOGRAMM_LOESCHEN: {                              // 0xAE03
    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_EME_KAELTEMITTEL_ABSPERRVENTIL_ON_OFF: {                        // 0xDE22
    if (datalen < 1) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_EME_KAELTEMITTEL_ABSPERRVENTIL_ON_OFF", 1);
        break;
    }

    unsigned char STAT_AKAV_ON = (RXBUF_UCHAR(0));
        // Status of the refrigerant shut-off valve; 0 = valve closed; 1 = valve open / Status des
        // Kältemittelabsperrventils; 0 = Ventil geschlossen; 1 = Ventil offen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "EME_KAELTEMITTEL_ABSPERRVENTIL_ON_OFF", "STAT_AKAV_ON", STAT_AKAV_ON, "\"0/1\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_PEDALWERTGEBER: {                                               // 0xDE9C
    if (datalen < 6) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_PEDALWERTGEBER", 6);
        break;
    }

    float STAT_SPANNUNG_PEDALWERT1_WERT = (RXBUF_UINT(0)*0.0049f);
        // Voltage measured at pedal encoder 1 / Spannung gemessen am Pedalwertgeber 1
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "PEDALWERTGEBER", "STAT_SPANNUNG_PEDALWERT1_WERT", STAT_SPANNUNG_PEDALWERT1_WERT, "\"V\"");

    float STAT_SPANNUNG_PEDALWERT2_WERT = (RXBUF_UINT(2)*0.0049f);
        // Voltage measured at the pedal encoder 2 / Spannung gemessen am Pedalwertgeber 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "PEDALWERTGEBER", "STAT_SPANNUNG_PEDALWERT2_WERT", STAT_SPANNUNG_PEDALWERT2_WERT, "\"V\"");

    float STAT_PEDALWERT_WERT = (RXBUF_UINT(4)*0.0625f);
        // Pedal value determined from pedal value sensors 1 and 2 / Aus Pedalwertgeber 1 und 2 ermittelter Pedalwert
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "PEDALWERTGEBER", "STAT_PEDALWERT_WERT", STAT_PEDALWERT_WERT, "\"%\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_REX_STATISTIK_BETRIEB: {                                        // 0xDEE1
    if (datalen < 22) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_REX_STATISTIK_BETRIEB", 22);
        break;
    }

    float STAT_BETRIEB_KILOMETER_WERT = (RXBUF_UINT32(0)*0.001f);
        // Kilometers driven / Gefahrene Kilometer
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_BETRIEB", "STAT_BETRIEB_KILOMETER_WERT", STAT_BETRIEB_KILOMETER_WERT, "\"km\"");

    unsigned long STAT_LAUFZEIT_WERT = (RXBUF_UINT32(4));
        // Runtime range extender motor / Laufzeit Range Extender Motor
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "REX_STATISTIK_BETRIEB", "STAT_LAUFZEIT_WERT", STAT_LAUFZEIT_WERT, "\"s\"");

    unsigned long STAT_BETRIEB_ERSTSTARTS_WERT = (RXBUF_UINT32(8));
        // Number of first start processes / Anzahl der Erststart-Vorgänge
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "REX_STATISTIK_BETRIEB", "STAT_BETRIEB_ERSTSTARTS_WERT", STAT_BETRIEB_ERSTSTARTS_WERT, "");

    unsigned long STAT_BETRIEB_MSA_STARTS_WERT = (RXBUF_UINT32(12));
        // Number of MSA starts / Anzahl MSA - Startvorgänge
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "REX_STATISTIK_BETRIEB", "STAT_BETRIEB_MSA_STARTS_WERT", STAT_BETRIEB_MSA_STARTS_WERT, "");

    unsigned short STAT_REX_BETRIEB_WARTUNG_STARTS_WERT = (RXBUF_UINT(16));
        // Number of special rex starts (exhaust-gas test or SGBD) / Number of special rex starts (exhaust-gas test or
        // SGBD)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_BETRIEB", "STAT_REX_BETRIEB_WARTUNG_STARTS_WERT", STAT_REX_BETRIEB_WARTUNG_STARTS_WERT, "");

    unsigned long STAT_REX_BETRIEB_BEZUGSKILOMETER_WERT = (RXBUF_UINT32(18));
        // Kilometers driven (electric) that were recorded by the statistics / Gefahrene Kilometer (elektrisch) die von
        // der Statistik erfasst wurden
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "REX_STATISTIK_BETRIEB", "STAT_REX_BETRIEB_BEZUGSKILOMETER_WERT", STAT_REX_BETRIEB_BEZUGSKILOMETER_WERT, "\"km\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_REX_STATISTIK_DREHZAHL: {                                       // 0xDEE2
    if (datalen < 72) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_REX_STATISTIK_DREHZAHL", 72);
        break;
    }

    float STAT_REX_ZEIT_IN_DREHZAHL_1_WERT = (RXBUF_UINT32(0)*0.1f);
        // Operating time in speed range 1 / Betriebszeit in Drehzahlbereich 1
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_1_WERT", STAT_REX_ZEIT_IN_DREHZAHL_1_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_2_WERT = (RXBUF_UINT32(4)*0.1f);
        // Operating time in speed range 2 / Betriebszeit in Drehzahlbereich 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_2_WERT", STAT_REX_ZEIT_IN_DREHZAHL_2_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_3_WERT = (RXBUF_UINT32(8)*0.1f);
        // Operating time in speed range 3 / Betriebszeit in Drehzahlbereich 3
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_3_WERT", STAT_REX_ZEIT_IN_DREHZAHL_3_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_4_WERT = (RXBUF_UINT32(12)*0.1f);
        // Operating time in speed range 4 / Betriebszeit in Drehzahlbereich 4
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_4_WERT", STAT_REX_ZEIT_IN_DREHZAHL_4_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_5_WERT = (RXBUF_UINT32(16)*0.1f);
        // Operating time in speed range 5 / Betriebszeit in Drehzahlbereich 5
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_5_WERT", STAT_REX_ZEIT_IN_DREHZAHL_5_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_6_WERT = (RXBUF_UINT32(20)*0.1f);
        // Operating time in speed range 6 / Betriebszeit in Drehzahlbereich 6
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_6_WERT", STAT_REX_ZEIT_IN_DREHZAHL_6_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_7_WERT = (RXBUF_UINT32(24)*0.1f);
        // Operating time in speed range 7 / Betriebszeit in Drehzahlbereich 7
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_7_WERT", STAT_REX_ZEIT_IN_DREHZAHL_7_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_8_WERT = (RXBUF_UINT32(28)*0.1f);
        // Operating time in speed range 8 / Betriebszeit in Drehzahlbereich 8
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_8_WERT", STAT_REX_ZEIT_IN_DREHZAHL_8_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_9_WERT = (RXBUF_UINT32(32)*0.1f);
        // Operating time in speed range 9 / Betriebszeit in Drehzahlbereich 9
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_9_WERT", STAT_REX_ZEIT_IN_DREHZAHL_9_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_10_WERT = (RXBUF_UINT32(36)*0.1f);
        // Operating time in speed range 10 / Betriebszeit in Drehzahlbereich 10
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_10_WERT", STAT_REX_ZEIT_IN_DREHZAHL_10_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_11_WERT = (RXBUF_UINT32(40)*0.1f);
        // Operating time in speed range 11 / Betriebszeit in Drehzahlbereich 11
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_11_WERT", STAT_REX_ZEIT_IN_DREHZAHL_11_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_12_WERT = (RXBUF_UINT32(44)*0.1f);
        // Operating time in speed range 12 / Betriebszeit in Drehzahlbereich 12
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_12_WERT", STAT_REX_ZEIT_IN_DREHZAHL_12_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_13_WERT = (RXBUF_UINT32(48)*0.1f);
        // Operating time in speed range 13 / Betriebszeit in Drehzahlbereich 13
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_13_WERT", STAT_REX_ZEIT_IN_DREHZAHL_13_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_14_WERT = (RXBUF_UINT32(52)*0.1f);
        // Operating time in speed range 14 / Betriebszeit in Drehzahlbereich 14
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_14_WERT", STAT_REX_ZEIT_IN_DREHZAHL_14_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_15_WERT = (RXBUF_UINT32(56)*0.1f);
        // Operating time in speed range 15 / Betriebszeit in Drehzahlbereich 15
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_15_WERT", STAT_REX_ZEIT_IN_DREHZAHL_15_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_16_WERT = (RXBUF_UINT32(60)*0.1f);
        // Operating time in speed range 16 / Betriebszeit in Drehzahlbereich 16
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_16_WERT", STAT_REX_ZEIT_IN_DREHZAHL_16_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_17_WERT = (RXBUF_UINT32(64)*0.1f);
        // Operating time in speed range 17 / Betriebszeit in Drehzahlbereich 17
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_17_WERT", STAT_REX_ZEIT_IN_DREHZAHL_17_WERT, "\"s\"");

    float STAT_REX_ZEIT_IN_DREHZAHL_18_WERT = (RXBUF_UINT32(68)*0.1f);
        // Operating time in speed range 18 / Betriebszeit in Drehzahlbereich 18
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_DREHZAHL", "STAT_REX_ZEIT_IN_DREHZAHL_18_WERT", STAT_REX_ZEIT_IN_DREHZAHL_18_WERT, "\"s\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_ZYKLISCHES_NACHLADEN_INFO: {                                    // 0xDEFD
    if (datalen < 97) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_ZYKLISCHES_NACHLADEN_INFO", 97);
        break;
    }

    unsigned long STAT_PARKEN_SYSTEMZEIT_WERT = (RXBUF_UINT32(0));
        // System time when parking / Systemzeit beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_PARKEN_SYSTEMZEIT_WERT", STAT_PARKEN_SYSTEMZEIT_WERT, "\"s\"");

    unsigned long STAT_PARKEN_KILOMETERSTAND_WERT = (RXBUF_UINT32(4));
        // Parking mileage / Kilometerstand beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_PARKEN_KILOMETERSTAND_WERT", STAT_PARKEN_KILOMETERSTAND_WERT, "\"km\"");

    float STAT_PARKEN_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(8)*0.5f);
        // SOC 12V battery when parking / SOC 12V Batterie beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_PARKEN_NV_BATTERIE_SOC_WERT", STAT_PARKEN_NV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned long STAT_E1_PARKEN_SYSTEMZEIT_WERT = (RXBUF_UINT32(9));
        // 1st event (last): system time when parking / 1. Ereignis (letzte): Systemzeit beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_PARKEN_SYSTEMZEIT_WERT", STAT_E1_PARKEN_SYSTEMZEIT_WERT, "\"s\"");

    unsigned long STAT_E1_PARKEN_KILOMETERSTAND_WERT = (RXBUF_UINT32(13));
        // 1st event (last): Mileage while parking / 1. Ereignis (letzte): Kilometerstand beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_PARKEN_KILOMETERSTAND_WERT", STAT_E1_PARKEN_KILOMETERSTAND_WERT, "\"km\"");

    float STAT_E1_PARKEN_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(17)*0.5f);
        // 1st event (last): SOC 12V battery when parking / 1. Ereignis (letzte): SOC 12V Batterie beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_PARKEN_NV_BATTERIE_SOC_WERT", STAT_E1_PARKEN_NV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned long STAT_E1_START_ZYKNL_SYSTEMZEIT_WERT = (RXBUF_UINT32(18));
        // 1st event (last): System time at the start of the cyclical reloading / 1. Ereignis (letzte): Systemzeit beim
        // Start des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_START_ZYKNL_SYSTEMZEIT_WERT", STAT_E1_START_ZYKNL_SYSTEMZEIT_WERT, "\"s\"");

    float STAT_E1_START_ZYKNL_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(22)*0.5f);
        // 1st event (last): SOC 12V battery when starting cyclical recharging / 1. Ereignis (letzte): SOC 12V Batterie
        // beim Start des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_START_ZYKNL_NV_BATTERIE_SOC_WERT", STAT_E1_START_ZYKNL_NV_BATTERIE_SOC_WERT, "\"%\"");

    float STAT_E1_START_ZYKNL_HV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(23)*0.5f);
        // 1st event (last): SOC HV battery when starting cyclical recharging / 1. Ereignis (letzte): SOC HV-Batterie
        // beim Start des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_START_ZYKNL_HV_BATTERIE_SOC_WERT", STAT_E1_START_ZYKNL_HV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned char STAT_E1_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT = (RXBUF_UCHAR(24)-128.0);
        // 1st event (last): Temperature of the 12V battery at the start of the cyclical recharging / 1. Ereignis
        // (letzte): Temperatur der 12V Batterie beim Start des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT", STAT_E1_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT, "\"°C\"");

    unsigned short STAT_E1_LADEDAUER_WERT = (RXBUF_UINT(25)+1.0);
        // 1st event (last): Duration of the cyclical reloading / 1. Ereignis (letzte): Dauer des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_LADEDAUER_WERT", STAT_E1_LADEDAUER_WERT, "\"s\"");

    float STAT_E1_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(27)*0.5f);
        // 1st event (last): SOC 12V battery at the end of the cyclic recharge / 1. Ereignis (letzte): SOC 12V Batterie
        // beim Ende des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT", STAT_E1_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT, "\"%\"");

    float STAT_E1_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(28)*0.5f);
        // 1st event (last): SOC HV battery at the end of cyclical recharging / 1. Ereignis (letzte): SOC HV-Batterie
        // beim Ende des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT", STAT_E1_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned char STAT_E1_GRUND_LADEENDE = (RXBUF_UCHAR(29));
        // 1st event (last): Reason for end of charging / 1. Ereignis (letzte): Grund Ladeende
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_GRUND_LADEENDE", STAT_E1_GRUND_LADEENDE, "\"0-n\"");

    unsigned char STAT_E1_ZYKNL_PROGNOSE_EIN = (RXBUF_UCHAR(30));
        // 1st event (last): Forecast as to whether further cyclical NL possible (0 = no, 1 = yes) / 1. Ereignis
        // (letzte): Prognose, ob weiteres zykl. NL möglich (0 = nein, 1 = ja)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E1_ZYKNL_PROGNOSE_EIN", STAT_E1_ZYKNL_PROGNOSE_EIN, "\"0/1\"");

    unsigned long STAT_E2_PARKEN_SYSTEMZEIT_WERT = (RXBUF_UINT32(31));
        // 2nd event: system time when parking / 2. Ereignis: Systemzeit beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_PARKEN_SYSTEMZEIT_WERT", STAT_E2_PARKEN_SYSTEMZEIT_WERT, "\"s\"");

    unsigned long STAT_E2_PARKEN_KILOMETERSTAND_WERT = (RXBUF_UINT32(35));
        // 2nd event: odometer reading while parking / 2. Ereignis: Kilometerstand beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_PARKEN_KILOMETERSTAND_WERT", STAT_E2_PARKEN_KILOMETERSTAND_WERT, "\"km\"");

    float STAT_E2_PARKEN_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(39)*0.5f);
        // 2nd event: SOC 12V battery when parking / 2. Ereignis: SOC 12V Batterie beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_PARKEN_NV_BATTERIE_SOC_WERT", STAT_E2_PARKEN_NV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned long STAT_E2_START_ZYKNL_SYSTEMZEIT_WERT = (RXBUF_UINT32(40));
        // 2nd event: System time at the start of the cyclical reloading / 2. Ereignis: Systemzeit beim Start des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_START_ZYKNL_SYSTEMZEIT_WERT", STAT_E2_START_ZYKNL_SYSTEMZEIT_WERT, "\"s\"");

    float STAT_E2_START_ZYKNL_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(44)*0.5f);
        // 2nd event: SOC 12V battery when starting cyclical recharging / 2. Ereignis: SOC 12V Batterie beim Start des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_START_ZYKNL_NV_BATTERIE_SOC_WERT", STAT_E2_START_ZYKNL_NV_BATTERIE_SOC_WERT, "\"%\"");

    float STAT_E2_START_ZYKNL_HV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(45)*0.5f);
        // 2nd event: SOC HV battery when starting cyclical recharging / 2. Ereignis: SOC HV-Batterie beim Start des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_START_ZYKNL_HV_BATTERIE_SOC_WERT", STAT_E2_START_ZYKNL_HV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned char STAT_E2_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT = (RXBUF_UCHAR(46)-128.0);
        // 2nd event: temperature of the 12V battery at the start of the cyclical recharge / 2. Ereignis: Temperatur der
        // 12V Batterie beim Start des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT", STAT_E2_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT, "\"°C\"");

    unsigned short STAT_E2_LADEDAUER_WERT = (RXBUF_UINT(47)+1.0);
        // 2nd event: Duration of the cyclical reloading / 2. Ereignis: Dauer des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_LADEDAUER_WERT", STAT_E2_LADEDAUER_WERT, "\"s\"");

    float STAT_E2_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(49)*0.5f);
        // 2nd event: SOC 12V battery at the end of the cyclic recharge / 2. Ereignis: SOC 12V Batterie beim Ende des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT", STAT_E2_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT, "\"%\"");

    float STAT_E2_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(50)*0.5f);
        // 2nd event: SOC HV battery at the end of cyclical recharging / 2. Ereignis: SOC HV-Batterie beim Ende des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT", STAT_E2_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned char STAT_E2_GRUND_LADEENDE = (RXBUF_UCHAR(51));
        // 2nd event: Reason for end of charging / 2. Ereignis: Grund Ladeende
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_GRUND_LADEENDE", STAT_E2_GRUND_LADEENDE, "\"0-n\"");

    unsigned char STAT_E2_ZYKNL_PROGNOSE_EIN = (RXBUF_UCHAR(52));
        // 2nd event: prognosis whether further cyclical NL possible (0 = no, 1 = yes) / 2. Ereignis: Prognose, ob
        // weiteres zykl. NL möglich (0 = nein, 1 = ja)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E2_ZYKNL_PROGNOSE_EIN", STAT_E2_ZYKNL_PROGNOSE_EIN, "\"0/1\"");

    unsigned long STAT_E3_PARKEN_SYSTEMZEIT_WERT = (RXBUF_UINT32(53));
        // 3rd event: system time when parking / 3. Ereignis: Systemzeit beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_PARKEN_SYSTEMZEIT_WERT", STAT_E3_PARKEN_SYSTEMZEIT_WERT, "\"s\"");

    unsigned long STAT_E3_PARKEN_KILOMETERSTAND_WERT = (RXBUF_UINT32(57));
        // 3rd event: mileage while parking / 3. Ereignis: Kilometerstand beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_PARKEN_KILOMETERSTAND_WERT", STAT_E3_PARKEN_KILOMETERSTAND_WERT, "\"km\"");

    float STAT_E3_PARKEN_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(61)*0.5f);
        // 3rd event: SOC 12V battery when parking / 3. Ereignis: SOC 12V Batterie beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_PARKEN_NV_BATTERIE_SOC_WERT", STAT_E3_PARKEN_NV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned long STAT_E3_START_ZYKNL_SYSTEMZEIT_WERT = (RXBUF_UINT32(62));
        // 3rd event: System time at the start of the cyclical reloading / 3. Ereignis: Systemzeit beim Start des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_START_ZYKNL_SYSTEMZEIT_WERT", STAT_E3_START_ZYKNL_SYSTEMZEIT_WERT, "\"s\"");

    float STAT_E3_START_ZYKNL_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(66)*0.5f);
        // 3rd event: SOC 12V battery at the start of cyclic recharging / 3. Ereignis: SOC 12V Batterie beim Start des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_START_ZYKNL_NV_BATTERIE_SOC_WERT", STAT_E3_START_ZYKNL_NV_BATTERIE_SOC_WERT, "\"%\"");

    float STAT_E3_START_ZYKNL_HV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(67)*0.5f);
        // 3rd event: SOC HV battery when starting cyclical recharging / 3. Ereignis: SOC HV-Batterie beim Start des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_START_ZYKNL_HV_BATTERIE_SOC_WERT", STAT_E3_START_ZYKNL_HV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned char STAT_E3_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT = (RXBUF_UCHAR(68)-128.0);
        // 3rd event: temperature of the 12V battery at the start of the cyclic recharge / 3. Ereignis: Temperatur der
        // 12V Batterie beim Start des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT", STAT_E3_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT, "\"°C\"");

    unsigned short STAT_E3_LADEDAUER_WERT = (RXBUF_UINT(69)+1.0);
        // 3rd event: Duration of the cyclical reloading / 3. Ereignis: Dauer des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_LADEDAUER_WERT", STAT_E3_LADEDAUER_WERT, "\"s\"");

    float STAT_E3_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(71)*0.5f);
        // 3rd event: SOC 12V battery at the end of the cyclic recharge / 3. Ereignis: SOC 12V Batterie beim Ende des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT", STAT_E3_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT, "\"%\"");

    float STAT_E3_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(72)*0.5f);
        // 3rd event: SOC HV battery at the end of the cyclical recharge / 3. Ereignis: SOC HV-Batterie beim Ende des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT", STAT_E3_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned char STAT_E3_GRUND_LADEENDE = (RXBUF_UCHAR(73));
        // 3rd event: Reason for end of charging / 3. Ereignis: Grund Ladeende
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_GRUND_LADEENDE", STAT_E3_GRUND_LADEENDE, "\"0-n\"");

    unsigned char STAT_E3_ZYKNL_PROGNOSE_EIN = (RXBUF_UCHAR(74));
        // 3rd event: prognosis whether further cyclical NL possible (0 = no, 1 = yes) / 3. Ereignis: Prognose, ob
        // weiteres zykl. NL möglich (0 = nein, 1 = ja)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E3_ZYKNL_PROGNOSE_EIN", STAT_E3_ZYKNL_PROGNOSE_EIN, "\"0/1\"");

    unsigned long STAT_E4_PARKEN_SYSTEMZEIT_WERT = (RXBUF_UINT32(75));
        // 4th event: system time when parking / 4. Ereignis: Systemzeit beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_PARKEN_SYSTEMZEIT_WERT", STAT_E4_PARKEN_SYSTEMZEIT_WERT, "\"s\"");

    unsigned long STAT_E4_PARKEN_KILOMETERSTAND_WERT = (RXBUF_UINT32(79));
        // 4th event: odometer reading while parking / 4. Ereignis: Kilometerstand beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_PARKEN_KILOMETERSTAND_WERT", STAT_E4_PARKEN_KILOMETERSTAND_WERT, "\"km\"");

    float STAT_E4_PARKEN_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(83)*0.5f);
        // 4th event: SOC 12V battery when parking / 4. Ereignis: SOC 12V Batterie beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_PARKEN_NV_BATTERIE_SOC_WERT", STAT_E4_PARKEN_NV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned long STAT_E4_START_ZYKNL_SYSTEMZEIT_WERT = (RXBUF_UINT32(84));
        // 4th event: System time at the start of the cyclical reloading / 4. Ereignis: Systemzeit beim Start des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_START_ZYKNL_SYSTEMZEIT_WERT", STAT_E4_START_ZYKNL_SYSTEMZEIT_WERT, "\"s\"");

    float STAT_E4_START_ZYKNL_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(88)*0.5f);
        // 4th event: SOC 12V battery at the start of cyclical recharging / 4. Ereignis: SOC 12V Batterie beim Start des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_START_ZYKNL_NV_BATTERIE_SOC_WERT", STAT_E4_START_ZYKNL_NV_BATTERIE_SOC_WERT, "\"%\"");

    float STAT_E4_START_ZYKNL_HV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(89)*0.5f);
        // 4th event: SOC HV battery when starting cyclical recharging / 4. Ereignis: SOC HV-Batterie beim Start des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_START_ZYKNL_HV_BATTERIE_SOC_WERT", STAT_E4_START_ZYKNL_HV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned char STAT_E4_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT = (RXBUF_UCHAR(90)-128.0);
        // 4th event: temperature of the 12V battery at the start of cyclic recharging / 4. Ereignis: Temperatur der 12V
        // Batterie beim Start des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT", STAT_E4_START_ZYKNL_NV_BATTERIE_TEMPERATUR_WERT, "\"°C\"");

    unsigned short STAT_E4_LADEDAUER_WERT = (RXBUF_UINT(91)+1.0);
        // 4th event: Duration of the cyclical reloading / 4. Ereignis: Dauer des zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_LADEDAUER_WERT", STAT_E4_LADEDAUER_WERT, "\"s\"");

    float STAT_E4_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(93)*0.5f);
        // 4th event: SOC 12V battery at the end of the cyclic recharge / 4. Ereignis: SOC 12V Batterie beim Ende des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT", STAT_E4_ENDE_ZYKNL_NV_BATTERIE_SOC_WERT, "\"%\"");

    float STAT_E4_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT = (RXBUF_UCHAR(94)*0.5f);
        // 4th event: SOC HV battery at the end of cyclic recharging / 4. Ereignis: SOC HV-Batterie beim Ende des
        // zyklischen Nachladens
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT", STAT_E4_ENDE_ZYKNL_HV_BATTERIE_SOC_WERT, "\"%\"");

    unsigned char STAT_E4_GRUND_LADEENDE = (RXBUF_UCHAR(95));
        // 4th event: Reason for end of charging / 4. Ereignis: Grund Ladeende
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_GRUND_LADEENDE", STAT_E4_GRUND_LADEENDE, "\"0-n\"");

    unsigned char STAT_E4_ZYKNL_PROGNOSE_EIN = (RXBUF_UCHAR(96));
        // 4th event: prognosis whether further cyclical NL possible (0 = no, 1 = yes) / 4. Ereignis: Prognose, ob
        // weiteres zykl. NL möglich (0 = nein, 1 = ja)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_INFO", "STAT_E4_ZYKNL_PROGNOSE_EIN", STAT_E4_ZYKNL_PROGNOSE_EIN, "\"0/1\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_ZYKLISCHES_NACHLADEN_HISTOGRAMM: {                              // 0xDEFE
    if (datalen < 16) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_ZYKLISCHES_NACHLADEN_HISTOGRAMM", 16);
        break;
    }

    unsigned char STAT_STANDZEIT_START_ZYKNL_BEREICH_A_WERT = (RXBUF_UCHAR(0));
        // Number of idle times until the beginning of the cyclical reloading in area A. Area A <= K_STDZEITLADEHISTGRZ1
        // (days) (count up to 255, then no count, value is retained) / Anzahl der Standzeiten bis zum Beginn des
        // zyklischen Nachladens im Bereich A. Bereich A <= K_STDZEITLADEHISTGRZ1 (Tage) (Zählung bis 255, danach keine
        // Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_STANDZEIT_START_ZYKNL_BEREICH_A_WERT", STAT_STANDZEIT_START_ZYKNL_BEREICH_A_WERT, "");

    unsigned char STAT_STANDZEIT_START_ZYKNL_BEREICH_B_WERT = (RXBUF_UCHAR(1));
        // Number of idle times until the start of the cyclical reloading in area B. K_STDZEITLADEHISTGRZ1 (days) <area B
        // <= K_STDZEITLADEHISTGRZ2 (days) (count up to 255, after that no count, value is retained) / Anzahl der
        // Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich B.  K_STDZEITLADEHISTGRZ1 (Tage) < Bereich B
        // <= K_STDZEITLADEHISTGRZ2 (Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_STANDZEIT_START_ZYKNL_BEREICH_B_WERT", STAT_STANDZEIT_START_ZYKNL_BEREICH_B_WERT, "");

    unsigned char STAT_STANDZEIT_START_ZYKNL_BEREICH_C_WERT = (RXBUF_UCHAR(2));
        // Number of idle times until the start of the cyclical reloading in area B. K_STDZEITLADEHISTGRZ2 (days) <area C
        // <= K_STDZEITLADEHISTGRZ3 (days) (count up to 255, after that no count, value is retained) / Anzahl der
        // Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich B.  K_STDZEITLADEHISTGRZ2 (Tage) < Bereich C
        // <= K_STDZEITLADEHISTGRZ3 (Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_STANDZEIT_START_ZYKNL_BEREICH_C_WERT", STAT_STANDZEIT_START_ZYKNL_BEREICH_C_WERT, "");

    unsigned char STAT_STANDZEIT_START_ZYKNL_BEREICH_D_WERT = (RXBUF_UCHAR(3));
        // Number of idle times until the beginning of the cyclical reloading in area D. K_STDZEITLADEHISTGRZ3 (days)
        // <area D <= K_STDZEITLADEHISTGRZ4 (days) (count up to 255, after that no count, value is retained) / Anzahl der
        // Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich D.  K_STDZEITLADEHISTGRZ3 (Tage) < Bereich D
        // <= K_STDZEITLADEHISTGRZ4 (Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_STANDZEIT_START_ZYKNL_BEREICH_D_WERT", STAT_STANDZEIT_START_ZYKNL_BEREICH_D_WERT, "");

    unsigned char STAT_STANDZEIT_START_ZYKNL_BEREICH_E_WERT = (RXBUF_UCHAR(4));
        // Number of idle times until the beginning of the cyclical reloading in area E. K_STDZEITLADEHISTGRZ4 (days)
        // <area E <= K_STDZEITLADEHISTGRZ5 (days) (count up to 255, after that no count, value is retained) / Anzahl der
        // Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich E.  K_STDZEITLADEHISTGRZ4 (Tage) < Bereich E
        // <= K_STDZEITLADEHISTGRZ5 (Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_STANDZEIT_START_ZYKNL_BEREICH_E_WERT", STAT_STANDZEIT_START_ZYKNL_BEREICH_E_WERT, "");

    unsigned char STAT_STANDZEIT_START_ZYKNL_BEREICH_F_WERT = (RXBUF_UCHAR(5));
        // Number of idle times until the start of the cyclical reloading in the area F. K_STDZEITLADEHISTGRZ5 (days)
        // <area F <= K_STDZEITLADEHISTGRZ6 (days) (count up to 255, after that no count, value is retained) / Anzahl der
        // Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich F.  K_STDZEITLADEHISTGRZ5 (Tage) < Bereich F
        // <= K_STDZEITLADEHISTGRZ6 (Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_STANDZEIT_START_ZYKNL_BEREICH_F_WERT", STAT_STANDZEIT_START_ZYKNL_BEREICH_F_WERT, "");

    unsigned char STAT_STANDZEIT_START_ZYKNL_BEREICH_G_WERT = (RXBUF_UCHAR(6));
        // Number of idle times until the start of the cyclical reloading in area G. K_STDZEITLADEHISTGRZ6 (days) <area G
        // <= K_STDZEITLADEHISTGRZ7 (days) (count up to 255, after that no count, value is retained) / Anzahl der
        // Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich G.  K_STDZEITLADEHISTGRZ6 (Tage) < Bereich G
        // <= K_STDZEITLADEHISTGRZ7 (Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_STANDZEIT_START_ZYKNL_BEREICH_G_WERT", STAT_STANDZEIT_START_ZYKNL_BEREICH_G_WERT, "");

    unsigned char STAT_STANDZEIT_START_ZYKNL_BEREICH_H_WERT = (RXBUF_UCHAR(7));
        // Number of idle times until the beginning of the cyclical reloading in area H. K_STDZEITLADEHISTGRZ7 (days)
        // <area H (count up to 255, then no count, value is retained) / Anzahl der Standzeiten bis zum Beginn des
        // zyklischen Nachladens im Bereich H.  K_STDZEITLADEHISTGRZ7 (Tage) < Bereich H  (Zählung bis 255, danach keine
        // Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_STANDZEIT_START_ZYKNL_BEREICH_H_WERT", STAT_STANDZEIT_START_ZYKNL_BEREICH_H_WERT, "");

    unsigned char STAT_LADUNGSDAUER_BEREICH_A_WERT = (RXBUF_UCHAR(8));
        // Number of loading times of the cyclical reloading in area A. Area A <= K_NLDDAUERHISTGRZ1 (days) (counting up
        // to 255, then no counting, value is retained) / Anzahl der Ladungsdauer des zyklischen Nachladens im Bereich A.
        // Bereich A <= K_NLDDAUERHISTGRZ1 (Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_LADUNGSDAUER_BEREICH_A_WERT", STAT_LADUNGSDAUER_BEREICH_A_WERT, "");

    unsigned char STAT_LADUNGSDAUER_BEREICH_B_WERT = (RXBUF_UCHAR(9));
        // Number of loading times of the cyclical reloading in area B. K_NLDDAUERHISTGRZ1 (days) <area B <=
        // K_NLDDAUERHISTGRZ2 (days) (count up to 255, then no count, value is retained) / Anzahl der Ladungsdauer des
        // zyklischen Nachladens im Bereich B. K_NLDDAUERHISTGRZ1 (Tage) < Bereich B <= K_NLDDAUERHISTGRZ2 (Tage)
        // (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_LADUNGSDAUER_BEREICH_B_WERT", STAT_LADUNGSDAUER_BEREICH_B_WERT, "");

    unsigned char STAT_LADUNGSDAUER_BEREICH_C_WERT = (RXBUF_UCHAR(10));
        // Number of loading times of the cyclical reloading in area C. K_NLDDAUERHISTGRZ2 (days) <area C <=
        // K_NLDDAUERHISTGRZ3 (days) (count up to 255, then no count, value is retained) / Anzahl der Ladungsdauer des
        // zyklischen Nachladens im Bereich C. K_NLDDAUERHISTGRZ2 (Tage) < Bereich C <= K_NLDDAUERHISTGRZ3 (Tage)
        // (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_LADUNGSDAUER_BEREICH_C_WERT", STAT_LADUNGSDAUER_BEREICH_C_WERT, "");

    unsigned char STAT_LADUNGSDAUER_BEREICH_D_WERT = (RXBUF_UCHAR(11));
        // Number of loading times of the cyclical reloading in area D. K_NLDDAUERHISTGRZ3 (days) <area D <=
        // K_NLDDAUERHISTGRZ4 (days) (count up to 255, after that no count, value is retained) / Anzahl der Ladungsdauer
        // des zyklischen Nachladens im Bereich D. K_NLDDAUERHISTGRZ3 (Tage) < Bereich D <= K_NLDDAUERHISTGRZ4 (Tage)
        // (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_LADUNGSDAUER_BEREICH_D_WERT", STAT_LADUNGSDAUER_BEREICH_D_WERT, "");

    unsigned char STAT_LADUNGSDAUER_BEREICH_E_WERT = (RXBUF_UCHAR(12));
        // Number of loading times of the cyclical reloading in area E. K_NLDDAUERHISTGRZ4 (days) <area E <=
        // K_NLDDAUERHISTGRZ5 (days) (count up to 255, then no count, value is retained) / Anzahl der Ladungsdauer des
        // zyklischen Nachladens im Bereich E. K_NLDDAUERHISTGRZ4 (Tage) < Bereich E <= K_NLDDAUERHISTGRZ5 (Tage)
        // (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_LADUNGSDAUER_BEREICH_E_WERT", STAT_LADUNGSDAUER_BEREICH_E_WERT, "");

    unsigned char STAT_LADUNGSDAUER_BEREICH_F_WERT = (RXBUF_UCHAR(13));
        // Number of loading times of the cyclical reloading in area F. K_NLDDAUERHISTGRZ5 (days) <area F <=
        // K_NLDDAUERHISTGRZ6 (days) (count up to 255, then no count, value is retained) / Anzahl der Ladungsdauer des
        // zyklischen Nachladens im Bereich F. K_NLDDAUERHISTGRZ5 (Tage) < Bereich F <= K_NLDDAUERHISTGRZ6 (Tage)
        // (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_LADUNGSDAUER_BEREICH_F_WERT", STAT_LADUNGSDAUER_BEREICH_F_WERT, "");

    unsigned char STAT_LADUNGSDAUER_BEREICH_G_WERT = (RXBUF_UCHAR(14));
        // Number of loading times of the cyclical reloading in area G. K_NLDDAUERHISTGRZ6 (days) <area G <=
        // K_NLDDAUERHISTGRZ7 (days) (count up to 255, then no count, value is retained) / Anzahl der Ladungsdauer des
        // zyklischen Nachladens im Bereich G. K_NLDDAUERHISTGRZ6 (Tage) < Bereich G <= K_NLDDAUERHISTGRZ7 (Tage)
        // (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_LADUNGSDAUER_BEREICH_G_WERT", STAT_LADUNGSDAUER_BEREICH_G_WERT, "");

    unsigned char STAT_LADUNGSDAUER_BEREICH_H_WERT = (RXBUF_UCHAR(15));
        // Number of loading times of the cyclical reloading in area H. K_NLDDAUERHISTGRZ7 (days) <area H (count up to
        // 255, then no count, value is retained) / Anzahl der Ladungsdauer des zyklischen Nachladens im Bereich H.
        // K_NLDDAUERHISTGRZ7 (Tage) < Bereich H  (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "ZYKLISCHES_NACHLADEN_HISTOGRAMM", "STAT_LADUNGSDAUER_BEREICH_H_WERT", STAT_LADUNGSDAUER_BEREICH_H_WERT, "");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_REX_STATISTIK_TEMPERATUR: {                                     // 0xDF53
    if (datalen < 36) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_REX_STATISTIK_TEMPERATUR", 36);
        break;
    }

    float STAT_REX_TEMPERATUR_MOTOR_KUEHLMITTEL_1_WERT = (RXBUF_UINT32(0)*0.1f);
        // Temperature statistics REX coolant 1 / Temperaturstatistik REX Kühlmittel 1
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_TEMPERATUR", "STAT_REX_TEMPERATUR_MOTOR_KUEHLMITTEL_1_WERT", STAT_REX_TEMPERATUR_MOTOR_KUEHLMITTEL_1_WERT, "\"s\"");

    float STAT_REX_TEMPERATUR_MOTOR_KUEHLMITTEL_2_WERT = (RXBUF_UINT32(4)*0.1f);
        // Temperature statistics REX coolant 2 / Temperaturstatistik REX Kühlmittel 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_TEMPERATUR", "STAT_REX_TEMPERATUR_MOTOR_KUEHLMITTEL_2_WERT", STAT_REX_TEMPERATUR_MOTOR_KUEHLMITTEL_2_WERT, "\"s\"");

    float STAT_REX_TEMPERATUR_MOTOR_KUEHLMITTEL_3_WERT = (RXBUF_UINT32(8)*0.1f);
        // Temperature statistics REX coolant 3 / Temperaturstatistik REX Kühlmittel 3
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_TEMPERATUR", "STAT_REX_TEMPERATUR_MOTOR_KUEHLMITTEL_3_WERT", STAT_REX_TEMPERATUR_MOTOR_KUEHLMITTEL_3_WERT, "\"s\"");

    float STAT_REX_TEMPERATUR_MOTOROEL_1_WERT = (RXBUF_UINT32(12)*0.1f);
        // Temperature statistics REX engine oil 1 / Temperaturstatistik REX Motoröl 1
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_TEMPERATUR", "STAT_REX_TEMPERATUR_MOTOROEL_1_WERT", STAT_REX_TEMPERATUR_MOTOROEL_1_WERT, "\"s\"");

    float STAT_REX_TEMPERATUR_MOTOROEL_2_WERT = (RXBUF_UINT32(16)*0.1f);
        // Temperature statistics REX engine oil 2 / Temperaturstatistik REX Motoröl 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_TEMPERATUR", "STAT_REX_TEMPERATUR_MOTOROEL_2_WERT", STAT_REX_TEMPERATUR_MOTOROEL_2_WERT, "\"s\"");

    float STAT_REX_TEMPERATUR_MOTOROEL_3_WERT = (RXBUF_UINT32(20)*0.1f);
        // Temperature statistics REX engine oil 3 / Temperaturstatistik REX Motoröl 3
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_TEMPERATUR", "STAT_REX_TEMPERATUR_MOTOROEL_3_WERT", STAT_REX_TEMPERATUR_MOTOROEL_3_WERT, "\"s\"");

    float STAT_REX_TEMPERATUR_UMGEBUNG_1_WERT = (RXBUF_UINT32(24)*0.1f);
        // Temperature statistics ambient temperature 1 / Temperaturstatistik Umgebungstemperatur 1
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_TEMPERATUR", "STAT_REX_TEMPERATUR_UMGEBUNG_1_WERT", STAT_REX_TEMPERATUR_UMGEBUNG_1_WERT, "\"s\"");

    float STAT_REX_TEMPERATUR_UMGEBUNG_2_WERT = (RXBUF_UINT32(28)*0.1f);
        // Temperature statistics ambient temperature 2 / Temperaturstatistik Umgebungstemperatur 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_TEMPERATUR", "STAT_REX_TEMPERATUR_UMGEBUNG_2_WERT", STAT_REX_TEMPERATUR_UMGEBUNG_2_WERT, "\"s\"");

    float STAT_REX_TEMPERATUR_UMGEBUNG_3_WERT = (RXBUF_UINT32(32)*0.1f);
        // Temperature statistics ambient temperature 3 / Temperaturstatistik Umgebungstemperatur 3
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "REX_STATISTIK_TEMPERATUR", "STAT_REX_TEMPERATUR_UMGEBUNG_3_WERT", STAT_REX_TEMPERATUR_UMGEBUNG_3_WERT, "\"s\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_REX_STATISTIK_KILOMETER_KLASSEN: {                              // 0xDF54
    if (datalen < 10) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_REX_STATISTIK_KILOMETER_KLASSEN", 10);
        break;
    }

    unsigned short STAT_REX_FAHRT_KILOMETER_KLASSE_1_WERT = (RXBUF_UINT(0));
        // Number of REX cycles in kilometers class 1 / Anzahl REX Zyklen in Kilometer Klasse 1
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_KILOMETER_KLASSEN", "STAT_REX_FAHRT_KILOMETER_KLASSE_1_WERT", STAT_REX_FAHRT_KILOMETER_KLASSE_1_WERT, "");

    unsigned short STAT_REX_FAHRT_KILOMETER_KLASSE_2_WERT = (RXBUF_UINT(2));
        // Number of REX cycles in kilometers class 2 / Anzahl REX Zyklen in Kilometer Klasse 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_KILOMETER_KLASSEN", "STAT_REX_FAHRT_KILOMETER_KLASSE_2_WERT", STAT_REX_FAHRT_KILOMETER_KLASSE_2_WERT, "");

    unsigned short STAT_REX_FAHRT_KILOMETER_KLASSE_3_WERT = (RXBUF_UINT(4));
        // Number of REX cycles in kilometers class 3 / Anzahl REX Zyklen in Kilometer Klasse 3
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_KILOMETER_KLASSEN", "STAT_REX_FAHRT_KILOMETER_KLASSE_3_WERT", STAT_REX_FAHRT_KILOMETER_KLASSE_3_WERT, "");

    unsigned short STAT_REX_FAHRT_KILOMETER_KLASSE_4_WERT = (RXBUF_UINT(6));
        // Number of REX cycles in kilometers class 4 / Anzahl REX Zyklen in Kilometer Klasse 4
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_KILOMETER_KLASSEN", "STAT_REX_FAHRT_KILOMETER_KLASSE_4_WERT", STAT_REX_FAHRT_KILOMETER_KLASSE_4_WERT, "");

    unsigned short STAT_REX_FAHRT_KILOMETER_KLASSE_5_WERT = (RXBUF_UINT(8));
        // Number of REX cycles in kilometers class 5 / Anzahl REX Zyklen in Kilometer Klasse 5
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_KILOMETER_KLASSEN", "STAT_REX_FAHRT_KILOMETER_KLASSE_5_WERT", STAT_REX_FAHRT_KILOMETER_KLASSE_5_WERT, "");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_REX_STATISTIK_ZYKLEN: {                                         // 0xDF55
    if (datalen < 4) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_REX_STATISTIK_ZYKLEN", 4);
        break;
    }

    unsigned short STAT_ZYKLEN_GESAMT_WERT = (RXBUF_UINT(0));
        // Counter for all driving cycles / Zähler für alle Fahrzyklen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_ZYKLEN", "STAT_ZYKLEN_GESAMT_WERT", STAT_ZYKLEN_GESAMT_WERT, "");

    unsigned short STAT_ZYKLEN_REX_BETRIEB_WERT = (RXBUF_UINT(2));
        // Counter for all driving cycles where the REX has run. / Zähler für alle Fahrzyklen, wo der REX gelaufen ist.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_ZYKLEN", "STAT_ZYKLEN_REX_BETRIEB_WERT", STAT_ZYKLEN_REX_BETRIEB_WERT, "");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_REX_STATISTIK_SOC_KILOMETER_KLASSEN: {                          // 0xDF56
    if (datalen < 64) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_REX_STATISTIK_SOC_KILOMETER_KLASSEN", 64);
        break;
    }

    unsigned short STAT_REX_START_SOC_1_KM_1_WERT = (RXBUF_UINT(0));
        // Number of REX starts for SOC class 1, electrically driven kilometers class 1 / Anzahl REX Starts für SOC
        // Klasse 1, elektrisch gefahrene Kilometer Klasse 1
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_1_KM_1_WERT", STAT_REX_START_SOC_1_KM_1_WERT, "");

    unsigned short STAT_REX_START_SOC_2_KM_1_WERT = (RXBUF_UINT(2));
        // Number of REX starts for SOC class 2, electrically driven kilometers class 1 / Anzahl REX Starts für SOC
        // Klasse 2, elektrisch gefahrene Kilometer Klasse 1
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_2_KM_1_WERT", STAT_REX_START_SOC_2_KM_1_WERT, "");

    unsigned short STAT_REX_START_SOC_3_KM_1_WERT = (RXBUF_UINT(4));
        // Number of REX starts for SOC class 3, electrically driven kilometers class 1 / Anzahl REX Starts für SOC
        // Klasse 3, elektrisch gefahrene Kilometer Klasse 1
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_3_KM_1_WERT", STAT_REX_START_SOC_3_KM_1_WERT, "");

    unsigned short STAT_REX_START_SOC_4_KM_1_WERT = (RXBUF_UINT(6));
        // Number of REX starts for SOC class 4, electrically driven kilometers class 1 / Anzahl REX Starts für SOC
        // Klasse 4, elektrisch gefahrene Kilometer Klasse 1
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_4_KM_1_WERT", STAT_REX_START_SOC_4_KM_1_WERT, "");

    unsigned short STAT_REX_START_SOC_1_KM_2_WERT = (RXBUF_UINT(8));
        // Number of REX starts for SOC class 1, electrically driven kilometers class 2 / Anzahl REX Starts für SOC
        // Klasse 1, elektrisch gefahrene Kilometer Klasse 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_1_KM_2_WERT", STAT_REX_START_SOC_1_KM_2_WERT, "");

    unsigned short STAT_REX_START_SOC_2_KM_2_WERT = (RXBUF_UINT(10));
        // Number of REX starts for SOC class 2, electrically driven kilometers class 2 / Anzahl REX Starts für SOC
        // Klasse 2, elektrisch gefahrene Kilometer Klasse 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_2_KM_2_WERT", STAT_REX_START_SOC_2_KM_2_WERT, "");

    unsigned short STAT_REX_START_SOC_3_KM_2_WERT = (RXBUF_UINT(12));
        // Number of REX starts for SOC class 3, electrically driven kilometers class 2 / Anzahl REX Starts für SOC
        // Klasse 3, elektrisch gefahrene Kilometer Klasse 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_3_KM_2_WERT", STAT_REX_START_SOC_3_KM_2_WERT, "");

    unsigned short STAT_REX_START_SOC_4_KM_2_WERT = (RXBUF_UINT(14));
        // Number of REX starts for SOC class 4, electrically driven kilometers class 2 / Anzahl REX Starts für SOC
        // Klasse 4, elektrisch gefahrene Kilometer Klasse 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_4_KM_2_WERT", STAT_REX_START_SOC_4_KM_2_WERT, "");

    unsigned short STAT_REX_START_SOC_1_KM_3_WERT = (RXBUF_UINT(16));
        // Number of REX starts for SOC class 1, electrically driven kilometers class 3 / Anzahl REX Starts für SOC
        // Klasse 1, elektrisch gefahrene Kilometer Klasse 3
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_1_KM_3_WERT", STAT_REX_START_SOC_1_KM_3_WERT, "");

    unsigned short STAT_REX_START_SOC_2_KM_3_WERT = (RXBUF_UINT(18));
        // Number of REX starts for SOC class 2, electrically driven kilometers class 3 / Anzahl REX Starts für SOC
        // Klasse 2, elektrisch gefahrene Kilometer Klasse 3
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_2_KM_3_WERT", STAT_REX_START_SOC_2_KM_3_WERT, "");

    unsigned short STAT_REX_START_SOC_3_KM_3_WERT = (RXBUF_UINT(20));
        // Number of REX starts for SOC class 3, electrically driven kilometers class 3 / Anzahl REX Starts für SOC
        // Klasse 3, elektrisch gefahrene Kilometer Klasse 3
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_3_KM_3_WERT", STAT_REX_START_SOC_3_KM_3_WERT, "");

    unsigned short STAT_REX_START_SOC_4_KM_3_WERT = (RXBUF_UINT(22));
        // Number of REX starts for SOC class 4, electrically driven kilometers class 3 / Anzahl REX Starts für SOC
        // Klasse 4, elektrisch gefahrene Kilometer Klasse 3
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_4_KM_3_WERT", STAT_REX_START_SOC_4_KM_3_WERT, "");

    unsigned short STAT_REX_START_SOC_1_KM_4_WERT = (RXBUF_UINT(24));
        // Number of REX starts for SOC class 1, electrically driven kilometers class 4 / Anzahl REX Starts für SOC
        // Klasse 1, elektrisch gefahrene Kilometer Klasse 4
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_1_KM_4_WERT", STAT_REX_START_SOC_1_KM_4_WERT, "");

    unsigned short STAT_REX_START_SOC_2_KM_4_WERT = (RXBUF_UINT(26));
        // Number of REX starts for SOC class 2, electrically driven kilometers class 4 / Anzahl REX Starts für SOC
        // Klasse 2, elektrisch gefahrene Kilometer Klasse 4
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_2_KM_4_WERT", STAT_REX_START_SOC_2_KM_4_WERT, "");

    unsigned short STAT_REX_START_SOC_3_KM_4_WERT = (RXBUF_UINT(28));
        // Number of REX starts for SOC class 3, electrically driven kilometers class 4 / Anzahl REX Starts für SOC
        // Klasse 3, elektrisch gefahrene Kilometer Klasse 4
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_3_KM_4_WERT", STAT_REX_START_SOC_3_KM_4_WERT, "");

    unsigned short STAT_REX_START_SOC_4_KM_4_WERT = (RXBUF_UINT(30));
        // Number of REX starts for SOC class 4, electrically driven kilometers class 4 / Anzahl REX Starts für SOC
        // Klasse 4, elektrisch gefahrene Kilometer Klasse 4
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_4_KM_4_WERT", STAT_REX_START_SOC_4_KM_4_WERT, "");

    unsigned short STAT_REX_START_SOC_1_KM_5_WERT = (RXBUF_UINT(32));
        // Number of REX starts for SOC class 1, electrically driven kilometers class 5 / Anzahl REX Starts für SOC
        // Klasse 1, elektrisch gefahrene Kilometer Klasse 5
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_1_KM_5_WERT", STAT_REX_START_SOC_1_KM_5_WERT, "");

    unsigned short STAT_REX_START_SOC_2_KM_5_WERT = (RXBUF_UINT(34));
        // Number of REX starts for SOC class 2, electrically driven kilometers class 5 / Anzahl REX Starts für SOC
        // Klasse 2, elektrisch gefahrene Kilometer Klasse 5
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_2_KM_5_WERT", STAT_REX_START_SOC_2_KM_5_WERT, "");

    unsigned short STAT_REX_START_SOC_3_KM_5_WERT = (RXBUF_UINT(36));
        // Number of REX starts for SOC class 3, electrically driven kilometers class 5 / Anzahl REX Starts für SOC
        // Klasse 3, elektrisch gefahrene Kilometer Klasse 5
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_3_KM_5_WERT", STAT_REX_START_SOC_3_KM_5_WERT, "");

    unsigned short STAT_REX_START_SOC_4_KM_5_WERT = (RXBUF_UINT(38));
        // Number of REX starts for SOC class 4, electrically driven kilometers class 5 / Anzahl REX Starts für SOC
        // Klasse 4, elektrisch gefahrene Kilometer Klasse 5
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_4_KM_5_WERT", STAT_REX_START_SOC_4_KM_5_WERT, "");

    unsigned short STAT_REX_START_SOC_1_KM_6_WERT = (RXBUF_UINT(40));
        // Number of REX starts for SOC class 1, electrically driven kilometers class 6 / Anzahl REX Starts für SOC
        // Klasse 1, elektrisch gefahrene Kilometer Klasse 6
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_1_KM_6_WERT", STAT_REX_START_SOC_1_KM_6_WERT, "");

    unsigned short STAT_REX_START_SOC_2_KM_6_WERT = (RXBUF_UINT(42));
        // Number of REX starts for SOC class 2, electrically driven kilometers class 6 / Anzahl REX Starts für SOC
        // Klasse 2, elektrisch gefahrene Kilometer Klasse 6
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_2_KM_6_WERT", STAT_REX_START_SOC_2_KM_6_WERT, "");

    unsigned short STAT_REX_START_SOC_3_KM_6_WERT = (RXBUF_UINT(44));
        // Number of REX starts for SOC class 3, electrically driven kilometers class 6 / Anzahl REX Starts für SOC
        // Klasse 3, elektrisch gefahrene Kilometer Klasse 6
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_3_KM_6_WERT", STAT_REX_START_SOC_3_KM_6_WERT, "");

    unsigned short STAT_REX_START_SOC_4_KM_6_WERT = (RXBUF_UINT(46));
        // Number of REX starts for SOC class 4, electrically driven kilometers class 6 / Anzahl REX Starts für SOC
        // Klasse 4, elektrisch gefahrene Kilometer Klasse 6
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_4_KM_6_WERT", STAT_REX_START_SOC_4_KM_6_WERT, "");

    unsigned short STAT_REX_START_SOC_1_KM_7_WERT = (RXBUF_UINT(48));
        // Number of REX starts for SOC class 1, electrically driven kilometers class 7 / Anzahl REX Starts für SOC
        // Klasse 1, elektrisch gefahrene Kilometer Klasse 7
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_1_KM_7_WERT", STAT_REX_START_SOC_1_KM_7_WERT, "");

    unsigned short STAT_REX_START_SOC_2_KM_7_WERT = (RXBUF_UINT(50));
        // Number of REX starts for SOC class 2, electrically driven kilometers class 7 / Anzahl REX Starts für SOC
        // Klasse 2, elektrisch gefahrene Kilometer Klasse 7
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_2_KM_7_WERT", STAT_REX_START_SOC_2_KM_7_WERT, "");

    unsigned short STAT_REX_START_SOC_3_KM_7_WERT = (RXBUF_UINT(52));
        // Number of REX starts for SOC class 3, electrically driven kilometers class 7 / Anzahl REX Starts für SOC
        // Klasse 3, elektrisch gefahrene Kilometer Klasse 7
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_3_KM_7_WERT", STAT_REX_START_SOC_3_KM_7_WERT, "");

    unsigned short STAT_REX_START_SOC_4_KM_7_WERT = (RXBUF_UINT(54));
        // Number of REX starts for SOC class 4, electrically driven kilometers class 7 / Anzahl REX Starts für SOC
        // Klasse 4, elektrisch gefahrene Kilometer Klasse 7
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_4_KM_7_WERT", STAT_REX_START_SOC_4_KM_7_WERT, "");

    unsigned short STAT_REX_START_SOC_1_KM_8_WERT = (RXBUF_UINT(56));
        // Number of REX starts for SOC class 1, electrically driven kilometers class 8 / Anzahl REX Starts für SOC
        // Klasse 1, elektrisch gefahrene Kilometer Klasse 8
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_1_KM_8_WERT", STAT_REX_START_SOC_1_KM_8_WERT, "");

    unsigned short STAT_REX_START_SOC_2_KM_8_WERT = (RXBUF_UINT(58));
        // Number of REX starts for SOC class 2, electrically driven kilometers class 8 / Anzahl REX Starts für SOC
        // Klasse 2, elektrisch gefahrene Kilometer Klasse 8
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_2_KM_8_WERT", STAT_REX_START_SOC_2_KM_8_WERT, "");

    unsigned short STAT_REX_START_SOC_3_KM_8_WERT = (RXBUF_UINT(60));
        // Number of REX starts for SOC class 3, electrically driven kilometers class 8 / Anzahl REX Starts für SOC
        // Klasse 3, elektrisch gefahrene Kilometer Klasse 8
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_3_KM_8_WERT", STAT_REX_START_SOC_3_KM_8_WERT, "");

    unsigned short STAT_REX_START_SOC_4_KM_8_WERT = (RXBUF_UINT(62));
        // Number of REX starts for SOC class 4, electrically driven kilometers class 8 / Anzahl REX Starts für SOC
        // Klasse 4, elektrisch gefahrene Kilometer Klasse 8
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_SOC_KILOMETER_KLASSEN", "STAT_REX_START_SOC_4_KM_8_WERT", STAT_REX_START_SOC_4_KM_8_WERT, "");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_REX_STATISTIK_ZAEHLER: {                                        // 0xDF5E
    if (datalen < 6) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_REX_STATISTIK_ZAEHLER", 6);
        break;
    }

    unsigned short STAT_REX_BETRIEB_LANGZEITSTART_IO_WERT = (RXBUF_UINT(0));
        // Number of successfully completed long-term starts / Anzahl erfolgreich durchgelaufene Langzeitstarts
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_ZAEHLER", "STAT_REX_BETRIEB_LANGZEITSTART_IO_WERT", STAT_REX_BETRIEB_LANGZEITSTART_IO_WERT, "");

    unsigned short STAT_REX_BETRIEB_LANGZEITSTART_NIO_WERT = (RXBUF_UINT(2));
        // Number of canceled long-term starts / Anzahl abgebrochene Langzeitstarts
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_ZAEHLER", "STAT_REX_BETRIEB_LANGZEITSTART_NIO_WERT", STAT_REX_BETRIEB_LANGZEITSTART_NIO_WERT, "");

    unsigned short STAT_REX_BETRIEB_TANK_LEER_STOPS_WERT = (RXBUF_UINT(4));
        // Number of REX deposits due to an empty tank / Anzahl REX-Ablegen aufgrund eines leeren Tanks
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "REX_STATISTIK_ZAEHLER", "STAT_REX_BETRIEB_TANK_LEER_STOPS_WERT", STAT_REX_BETRIEB_TANK_LEER_STOPS_WERT, "");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STEUERN_INTERLOCK: {                                            // 0x1061
    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_12V_NACHLADEHISTORIE: {                                         // 0x409D
    if (datalen < 93) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_12V_NACHLADEHISTORIE", 93);
        break;
    }

    unsigned long STAT_KM_STAND_WERT = (RXBUF_UINT32(0));
        // Parking mileage / Kilometerstand beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_KM_STAND_WERT", STAT_KM_STAND_WERT, "\"km\"");

    unsigned long STAT_SYSTEMZEIT_PARKEN_WERT = (RXBUF_UINT32(4));
        // Timestamp when parking / Zeitstempel beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_SYSTEMZEIT_PARKEN_WERT", STAT_SYSTEMZEIT_PARKEN_WERT, "\"s\"");

    unsigned char STAT_12V_BATTERIE_SOC_PARKEN_WERT = (RXBUF_UCHAR(8));
        // Charge status of the 12V battery when the vehicle is put down / Ladezustand der 12V-Batterie beim Ablegen des
        // Fahrzeuges
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_12V_BATTERIE_SOC_PARKEN_WERT", STAT_12V_BATTERIE_SOC_PARKEN_WERT, "\"%\"");

    unsigned long STAT_E1_KM_STAND_WERT = (RXBUF_UINT32(9));
        // Sentence 1 (last) - mileage when parking / Satz 1 (letzter) - Kilometerstand beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E1_KM_STAND_WERT", STAT_E1_KM_STAND_WERT, "\"km\"");

    unsigned long STAT_E2_KM_STAND_WERT = (RXBUF_UINT32(13));
        // Sentence 2 - Mileage when parking / Satz 2 - Kilometerstand beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E2_KM_STAND_WERT", STAT_E2_KM_STAND_WERT, "\"km\"");

    unsigned long STAT_E3_KM_STAND_WERT = (RXBUF_UINT32(17));
        // Sentence 3 - Mileage when parking / Satz 3 - Kilometerstand beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E3_KM_STAND_WERT", STAT_E3_KM_STAND_WERT, "\"km\"");

    unsigned long STAT_E4_KM_STAND_WERT = (RXBUF_UINT32(21));
        // Sentence 4 - Mileage when parking / Satz 4 - Kilometerstand beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E4_KM_STAND_WERT", STAT_E4_KM_STAND_WERT, "\"km\"");

    unsigned long STAT_E1_SYSTEMZEIT_PARKEN_WERT = (RXBUF_UINT32(25));
        // Set 1 (last) - time stamp when parking / Satz 1 (letzter) - Zeitstempel beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E1_SYSTEMZEIT_PARKEN_WERT", STAT_E1_SYSTEMZEIT_PARKEN_WERT, "\"s\"");

    unsigned long STAT_E2_SYSTEMZEIT_PARKEN_WERT = (RXBUF_UINT32(29));
        // Set 2 - Timestamp when parking / Satz 2 - Zeitstempel beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E2_SYSTEMZEIT_PARKEN_WERT", STAT_E2_SYSTEMZEIT_PARKEN_WERT, "\"s\"");

    unsigned long STAT_E3_SYSTEMZEIT_PARKEN_WERT = (RXBUF_UINT32(33));
        // Sentence 3 - Time stamp when parking / Satz 3 - Zeitstempel beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E3_SYSTEMZEIT_PARKEN_WERT", STAT_E3_SYSTEMZEIT_PARKEN_WERT, "\"s\"");

    unsigned long STAT_E4_SYSTEMZEIT_PARKEN_WERT = (RXBUF_UINT32(37));
        // Set 4 - Timestamp when parking / Satz 4 - Zeitstempel beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E4_SYSTEMZEIT_PARKEN_WERT", STAT_E4_SYSTEMZEIT_PARKEN_WERT, "\"s\"");

    float STAT_E1_12V_BATTERIE_SOC_PARKEN_WERT = (RXBUF_UCHAR(41)/2.0f);
        // Sentence 1 (last) - state of charge of the 12V battery when parking / Satz 1 (letzter) - Ladezustand der
        // 12V-Batterie beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E1_12V_BATTERIE_SOC_PARKEN_WERT", STAT_E1_12V_BATTERIE_SOC_PARKEN_WERT, "\"%\"");

    float STAT_E2_12V_BATTERIE_SOC_PARKEN_WERT = (RXBUF_UCHAR(42)/2.0f);
        // Set 2 - Charge level of the 12V battery when parking / Satz 2 - Ladezustand der 12V-Batterie beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E2_12V_BATTERIE_SOC_PARKEN_WERT", STAT_E2_12V_BATTERIE_SOC_PARKEN_WERT, "\"%\"");

    float STAT_E3_12V_BATTERIE_SOC_PARKEN_WERT = (RXBUF_UCHAR(43)/2.0f);
        // Set 3 - Charge level of the 12V battery when parking / Satz 3 - Ladezustand der 12V-Batterie beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E3_12V_BATTERIE_SOC_PARKEN_WERT", STAT_E3_12V_BATTERIE_SOC_PARKEN_WERT, "\"%\"");

    float STAT_E4_12V_BATTERIE_SOC_PARKEN_WERT = (RXBUF_UCHAR(44)/2.0f);
        // Set 4 - Charge level of the 12V battery when parking / Satz 4 - Ladezustand der 12V-Batterie beim Parken
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E4_12V_BATTERIE_SOC_PARKEN_WERT", STAT_E4_12V_BATTERIE_SOC_PARKEN_WERT, "\"%\"");

    unsigned long STAT_E1_SYSTEMZEIT_LADEBEGINN_WERT = (RXBUF_UINT32(45));
        // Set 1 (last) - time stamp when starting the 12V battery charging process / Satz 1 ( letzter) - Zeitstempel
        // beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E1_SYSTEMZEIT_LADEBEGINN_WERT", STAT_E1_SYSTEMZEIT_LADEBEGINN_WERT, "\"s\"");

    unsigned long STAT_E2_SYSTEMZEIT_LADEBEGINN_WERT = (RXBUF_UINT32(49));
        // Set 2 - Time stamp when starting the 12V battery charging process / Satz 2 - Zeitstempel beim Starten des
        // 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E2_SYSTEMZEIT_LADEBEGINN_WERT", STAT_E2_SYSTEMZEIT_LADEBEGINN_WERT, "\"s\"");

    unsigned long STAT_E3_SYSTEMZEIT_LADEBEGINN_WERT = (RXBUF_UINT32(53));
        // Set 3 - Timestamp when starting the 12V battery charging process / Satz 3 - Zeitstempel beim Starten des
        // 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E3_SYSTEMZEIT_LADEBEGINN_WERT", STAT_E3_SYSTEMZEIT_LADEBEGINN_WERT, "\"s\"");

    unsigned long STAT_E4_SYSTEMZEIT_LADEBEGINN_WERT = (RXBUF_UINT32(57));
        // Set 4 - Timestamp when starting the 12V battery charging process / Satz 4 - Zeitstempel beim Starten des
        // 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E4_SYSTEMZEIT_LADEBEGINN_WERT", STAT_E4_SYSTEMZEIT_LADEBEGINN_WERT, "\"s\"");

    float STAT_E1_12V_BATTERIE_SOC_LADEBEGINN_WERT = (RXBUF_UCHAR(61)/2.0f);
        // Set 1 (last) - state of charge of the 12V battery when starting the 12V battery charging process / Satz 1
        // (letzter) - Ladezustand der 12V-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E1_12V_BATTERIE_SOC_LADEBEGINN_WERT", STAT_E1_12V_BATTERIE_SOC_LADEBEGINN_WERT, "\"%\"");

    float STAT_E2_12V_BATTERIE_SOC_LADEBEGINN_WERT = (RXBUF_UCHAR(62)/2.0f);
        // Set 2 - Charge status of the 12V battery when starting the 12V battery charging process / Satz 2 - Ladezustand
        // der 12V-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E2_12V_BATTERIE_SOC_LADEBEGINN_WERT", STAT_E2_12V_BATTERIE_SOC_LADEBEGINN_WERT, "\"%\"");

    float STAT_E3_12V_BATTERIE_SOC_LADEBEGINN_WERT = (RXBUF_UCHAR(63)/2.0f);
        // Set 3 - Charge status of the 12V battery when starting the 12V battery charging process / Satz 3 - Ladezustand
        // der 12V-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E3_12V_BATTERIE_SOC_LADEBEGINN_WERT", STAT_E3_12V_BATTERIE_SOC_LADEBEGINN_WERT, "\"%\"");

    float STAT_E4_12V_BATTERIE_SOC_LADEBEGINN_WERT = (RXBUF_UCHAR(64)/2.0f);
        // Set 4 - Charge status of the 12V battery when starting the 12V battery charging process / Satz 4 - Ladezustand
        // der 12V-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E4_12V_BATTERIE_SOC_LADEBEGINN_WERT", STAT_E4_12V_BATTERIE_SOC_LADEBEGINN_WERT, "\"%\"");

    float STAT_E1_HV_BATTERIE_SOC_LADEBEGINN_WERT = (RXBUF_UCHAR(65)/2.0f);
        // Sentence 1 (last) - state of charge of the high-voltage battery when starting the 12V battery charging process
        // / Satz 1 (letzter) - Ladezustand der Hochvolt-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E1_HV_BATTERIE_SOC_LADEBEGINN_WERT", STAT_E1_HV_BATTERIE_SOC_LADEBEGINN_WERT, "\"%\"");

    float STAT_E2_HV_BATTERIE_SOC_LADEBEGINN_WERT = (RXBUF_UCHAR(66)/2.0f);
        // Sentence 2 - State of charge of the high-voltage battery when starting the 12V battery charging process / Satz
        // 2 - Ladezustand der Hochvolt-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E2_HV_BATTERIE_SOC_LADEBEGINN_WERT", STAT_E2_HV_BATTERIE_SOC_LADEBEGINN_WERT, "\"%\"");

    float STAT_E3_HV_BATTERIE_SOC_LADEBEGINN_WERT = (RXBUF_UCHAR(67)/2.0f);
        // Sentence 3 - State of charge of the high-voltage battery when starting the 12V battery charging process / Satz
        // 3 - Ladezustand der Hochvolt-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E3_HV_BATTERIE_SOC_LADEBEGINN_WERT", STAT_E3_HV_BATTERIE_SOC_LADEBEGINN_WERT, "\"%\"");

    float STAT_E4_HV_BATTERIE_SOC_LADEBEGINN_WERT = (RXBUF_UCHAR(68)/2.0f);
        // Sentence 4 - State of charge of the high-voltage battery when starting the 12V battery charging process / Satz
        // 4 - Ladezustand der Hochvolt-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E4_HV_BATTERIE_SOC_LADEBEGINN_WERT", STAT_E4_HV_BATTERIE_SOC_LADEBEGINN_WERT, "\"%\"");

    char STAT_E1_12V_BATTERIE_TEMP_LADEBEGINN_WERT = (RXBUF_SCHAR(69));
        // Set 1 (last) - temperature of the 12V battery when starting the 12V battery charging process / Satz 1
        // (letzter) - Temperatur der 12V-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E1_12V_BATTERIE_TEMP_LADEBEGINN_WERT", STAT_E1_12V_BATTERIE_TEMP_LADEBEGINN_WERT, "\"°C\"");

    char STAT_E2_12V_BATTERIE_TEMP_LADEBEGINN_WERT = (RXBUF_SCHAR(70));
        // Set 2 - Temperature of the 12V battery when starting the 12V battery charging process / Satz 2 - Temperatur
        // der 12V-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E2_12V_BATTERIE_TEMP_LADEBEGINN_WERT", STAT_E2_12V_BATTERIE_TEMP_LADEBEGINN_WERT, "\"°C\"");

    char STAT_E3_12V_BATTERIE_TEMP_LADEBEGINN_WERT = (RXBUF_SCHAR(71));
        // Set 3 - Temperature of the 12V battery when starting the 12V battery charging process / Satz 3 - Temperatur
        // der 12V-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E3_12V_BATTERIE_TEMP_LADEBEGINN_WERT", STAT_E3_12V_BATTERIE_TEMP_LADEBEGINN_WERT, "\"°C\"");

    char STAT_E4_12V_BATTERIE_TEMP_LADEBEGINN_WERT = (RXBUF_SCHAR(72));
        // Set 4 - Temperature of the 12V battery when starting the 12V battery charging process / Satz 4 - Temperatur
        // der 12V-Batterie beim Starten des 12V-Batterie Ladevorgangs
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E4_12V_BATTERIE_TEMP_LADEBEGINN_WERT", STAT_E4_12V_BATTERIE_TEMP_LADEBEGINN_WERT, "\"°C\"");

    unsigned short STAT_E1_LADEDAUER_WERT_0X409D = (RXBUF_UINT(73));
        // Sentence 1 (last) - charging time (time difference between charging start and charging end) / Satz 1 (letzter)
        // - Ladedauer (Zeitunterschied zwischen Ladebegin und Ladeende)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E1_LADEDAUER_WERT_0X409D", STAT_E1_LADEDAUER_WERT_0X409D, "\"s\"");

    unsigned short STAT_E2_LADEDAUER_WERT_0X409D = (RXBUF_UINT(75));
        // Sentence 2 - charging time (time difference between charging start and charging end) / Satz 2 - Ladedauer
        // (Zeitunterschied zwischen Ladebegin und Ladeende)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E2_LADEDAUER_WERT_0X409D", STAT_E2_LADEDAUER_WERT_0X409D, "\"s\"");

    unsigned short STAT_E3_LADEDAUER_WERT_0X409D = (RXBUF_UINT(77));
        // Sentence 3 - charging time (time difference between charging start and charging end) / Satz 3 - Ladedauer
        // (Zeitunterschied zwischen Ladebegin und Ladeende)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E3_LADEDAUER_WERT_0X409D", STAT_E3_LADEDAUER_WERT_0X409D, "\"s\"");

    unsigned short STAT_E4_LADEDAUER_WERT_0X409D = (RXBUF_UINT(79));
        // Sentence 4 - charging time (time difference between charging start and charging end) / Satz 4 - Ladedauer
        // (Zeitunterschied zwischen Ladebegin und Ladeende)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E4_LADEDAUER_WERT_0X409D", STAT_E4_LADEDAUER_WERT_0X409D, "\"s\"");

    float STAT_E1_12V_BATTERIE_SOC_LADEENDE_WERT = (RXBUF_UCHAR(81)/2.0f);
        // Sentence 1 (last) - state of charge of the 12V battery when the 12V battery charging process is ended (= state
        // of charge when starting if charging is not possible) / Satz 1 (letzter) - Ladezustand der 12V-Batterie beim
        // Beenden des 12V-Batterie Ladevorgangs (=Ladezustand beim Starten wenn Laden nicht möglich)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E1_12V_BATTERIE_SOC_LADEENDE_WERT", STAT_E1_12V_BATTERIE_SOC_LADEENDE_WERT, "\"%\"");

    float STAT_E2_12V_BATTERIE_SOC_LADEENDE_WERT = (RXBUF_UCHAR(82)/2.0f);
        // Sentence 2 - Charge status of the 12V battery when the 12V battery charging process is ended (= charge status
        // when starting if charging is not possible) / Satz 2 - Ladezustand der 12V-Batterie beim Beenden des
        // 12V-Batterie Ladevorgangs (=Ladezustand beim Starten wenn Laden nicht möglich)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E2_12V_BATTERIE_SOC_LADEENDE_WERT", STAT_E2_12V_BATTERIE_SOC_LADEENDE_WERT, "\"%\"");

    float STAT_E3_12V_BATTERIE_SOC_LADEENDE_WERT = (RXBUF_UCHAR(83)/2.0f);
        // Sentence 3 - Charge status of the 12V battery when the 12V battery charging process is ended (= charge status
        // when starting if charging is not possible) / Satz 3 - Ladezustand der 12V-Batterie beim Beenden des
        // 12V-Batterie Ladevorgangs (=Ladezustand beim Starten wenn Laden nicht möglich)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E3_12V_BATTERIE_SOC_LADEENDE_WERT", STAT_E3_12V_BATTERIE_SOC_LADEENDE_WERT, "\"%\"");

    float STAT_E4_12V_BATTERIE_SOC_LADEENDE_WERT = (RXBUF_UCHAR(84)/2.0f);
        // Sentence 4 - Charge status of the 12V battery when the 12V battery charging process is ended (= charge status
        // when starting if charging is not possible) / Satz 4 - Ladezustand der 12V-Batterie beim Beenden des
        // 12V-Batterie Ladevorgangs (=Ladezustand beim Starten wenn Laden nicht möglich)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E4_12V_BATTERIE_SOC_LADEENDE_WERT", STAT_E4_12V_BATTERIE_SOC_LADEENDE_WERT, "\"%\"");

    float STAT_E1_HV_BATTERIE_SOC_LADEENDE_WERT = (RXBUF_UCHAR(85)/2.0f);
        // Sentence 1 (last) - state of charge of the high-voltage battery when the 12V battery charging process is ended
        // (= state of charge when starting if charging is not possible) / Satz 1 (letzter) - Ladezustand der
        // Hochvolt-Batterie beim Beenden des 12V-Batterie Ladevorgangs (=Ladezustand beim Starten wenn Laden nicht
        // möglich)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E1_HV_BATTERIE_SOC_LADEENDE_WERT", STAT_E1_HV_BATTERIE_SOC_LADEENDE_WERT, "\"%\"");

    float STAT_E2_HV_BATTERIE_SOC_LADEENDE_WERT = (RXBUF_UCHAR(86)/2.0f);
        // Sentence 2 - Charge status of the high-voltage battery when the 12V battery charging process is ended (=
        // charge status when starting if charging is not possible) / Satz 2 - Ladezustand der Hochvolt-Batterie beim
        // Beenden des 12V-Batterie Ladevorgangs (=Ladezustand beim Starten wenn Laden nicht möglich)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E2_HV_BATTERIE_SOC_LADEENDE_WERT", STAT_E2_HV_BATTERIE_SOC_LADEENDE_WERT, "\"%\"");

    float STAT_E3_HV_BATTERIE_SOC_LADEENDE_WERT = (RXBUF_UCHAR(87)/2.0f);
        // Sentence 3 - State of charge of the high-voltage battery when the 12V battery charging process is ended (=
        // state of charge when starting if charging is not possible) / Satz 3 - Ladezustand der Hochvolt-Batterie beim
        // Beenden des 12V-Batterie Ladevorgangs (=Ladezustand beim Starten wenn Laden nicht möglich)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E3_HV_BATTERIE_SOC_LADEENDE_WERT", STAT_E3_HV_BATTERIE_SOC_LADEENDE_WERT, "\"%\"");

    float STAT_E4_HV_BATTERIE_SOC_LADEENDE_WERT = (RXBUF_UCHAR(88)/2.0f);
        // Sentence 4 - Charge status of the high-voltage battery when the 12V battery charging process is ended (=
        // charge status when starting if charging is not possible) / Satz 4 - Ladezustand der Hochvolt-Batterie beim
        // Beenden des 12V-Batterie Ladevorgangs (=Ladezustand beim Starten wenn Laden nicht möglich)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E4_HV_BATTERIE_SOC_LADEENDE_WERT", STAT_E4_HV_BATTERIE_SOC_LADEENDE_WERT, "\"%\"");

    unsigned char STAT_E1_12VLADEFEHLER = (RXBUF_UCHAR(89));
        // Sentence 1 (last) - reason for the end of loading / Satz 1 (letzter) - Ladeendegrund
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E1_12VLADEFEHLER", STAT_E1_12VLADEFEHLER, "\"0-n\"");

    unsigned char STAT_E2_12VLADEFEHLER = (RXBUF_UCHAR(90));
        // Sentence 2 - Reason for end of loading / Satz 2 - Ladeendegrund
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E2_12VLADEFEHLER", STAT_E2_12VLADEFEHLER, "\"0-n\"");

    unsigned char STAT_E3_12VLADEFEHLER = (RXBUF_UCHAR(91));
        // Sentence 3 - Reason for end of loading / Satz 3 - Ladeendegrund
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E3_12VLADEFEHLER", STAT_E3_12VLADEFEHLER, "\"0-n\"");

    unsigned char STAT_E4_12VLADEFEHLER = (RXBUF_UCHAR(92));
        // Sentence 4 - Reason for end of loading / Satz 4 - Ladeendegrund
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTORIE", "STAT_E4_12VLADEFEHLER", STAT_E4_12VLADEFEHLER, "\"0-n\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_12V_NACHLADEHISTOGRAMM: {                                       // 0x409E
    if (datalen < 16) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_12V_NACHLADEHISTOGRAMM", 16);
        break;
    }

    unsigned char STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_A_WERT = (RXBUF_UCHAR(0));
        // Number of idle times until the start of the cyclical reloading in area A. Area A <= K_STDZEITLADEHISTGRZ1 (2
        // days) (counting up to 255, then no counting, value is retained) / Anzahl der Standzeiten bis zum Beginn des
        // zyklischen Nachladens im Bereich A. Bereich A <= K_STDZEITLADEHISTGRZ1 (2 Tage) (Zählung bis 255, danach keine
        // Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_A_WERT", STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_A_WERT, "");

    unsigned char STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_B_WERT = (RXBUF_UCHAR(1));
        // Number of idle times until the start of cyclical reloading in area B. K_STDZEITLADEHISTGRZ1 (2 days) <area B
        // <= K_STDZEITLADEHISTGRZ2 (4 days) (counting up to 255, then no counting, value is retained) / Anzahl der
        // Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich B.   K_STDZEITLADEHISTGRZ1 (2 Tage) < Bereich
        // B <= K_STDZEITLADEHISTGRZ2 (4 Tage)  (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_B_WERT", STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_B_WERT, "");

    unsigned char STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_C_WERT = (RXBUF_UCHAR(2));
        // Number of idle times until the start of the cyclical reloading in area C. K_STDZEITLADEHISTGRZ2 (4 days) <area
        // C <= K_STDZEITLADEHISTGRZ3 (6 days) (count up to 255, after that no count, value is retained) / Anzahl der
        // Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich C.  K_STDZEITLADEHISTGRZ2 (4 Tage) < Bereich C
        // <= K_STDZEITLADEHISTGRZ3 (6 Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_C_WERT", STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_C_WERT, "");

    unsigned char STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_D_WERT = (RXBUF_UCHAR(3));
        // Number of idle times until the start of cyclical reloading in area D. K_STDZEITLADEHISTGRZ3 (6 days) <area D
        // <= K_STDZEITLADEHISTGRZ4 (10 days) (counting up to 255, after that no counting, value is retained) / Anzahl
        // der Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich D.  K_STDZEITLADEHISTGRZ3 (6 Tage) <
        // Bereich D <= K_STDZEITLADEHISTGRZ4 (10 Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_D_WERT", STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_D_WERT, "");

    unsigned char STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_E_WERT = (RXBUF_UCHAR(4));
        // Number of idle times until the start of cyclical reloading in area E. K_STDZEITLADEHISTGRZ4 (10 days) <area E
        // <= K_STDZEITLADEHISTGRZ5 (14 days) (counting up to 255, then no counting, value is retained) / Anzahl der
        // Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich E.  K_STDZEITLADEHISTGRZ4 (10 Tage) < Bereich
        // E <= K_STDZEITLADEHISTGRZ5 (14 Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_E_WERT", STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_E_WERT, "");

    unsigned char STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_F_WERT = (RXBUF_UCHAR(5));
        // Number of idle times until the beginning of the cyclical reloading in the area F. K_STDZEITLADEHISTGRZ5 (14
        // days) <area F <= K_STDZEITLADEHISTGRZ6 (21 days) (count up to 255, after that no count, value is retained) /
        // Anzahl der Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich F.  K_STDZEITLADEHISTGRZ5 (14 Tage)
        // < Bereich F <= K_STDZEITLADEHISTGRZ6 (21 Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_F_WERT", STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_F_WERT, "");

    unsigned char STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_G_WERT = (RXBUF_UCHAR(6));
        // Number of idle times until the start of cyclical reloading in area G. K_STDZEITLADEHISTGRZ6 (21 days) <area G
        // <= K_STDZEITLADEHISTGRZ7 (28 days) (counts up to 255, then no count, value is retained) / Anzahl der
        // Standzeiten bis zum Beginn des zyklischen Nachladens im Bereich G.  K_STDZEITLADEHISTGRZ6 (21 Tage) < Bereich
        // G <= K_STDZEITLADEHISTGRZ7 (28 Tage) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_G_WERT", STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_G_WERT, "");

    unsigned char STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_H_WERT = (RXBUF_UCHAR(7));
        // Number of idle times until the start of the cyclical reloading in area H. K_STDZEITLADEHISTGRZ7 (28 days)
        // <area H (counting up to 255, then no counting, value is retained) / Anzahl der Standzeiten bis zum Beginn des
        // zyklischen Nachladens im Bereich H.  K_STDZEITLADEHISTGRZ7 (28 Tage) < Bereich H (Zählung bis 255, danach
        // keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_H_WERT", STAT_HFK_STANDZEIT_BIS_LADEBEGINN_BEREICH_H_WERT, "");

    unsigned char STAT_HFK_LADEDAUER_BEREICH_A_WERT = (RXBUF_UCHAR(8));
        // Number of loading times of the cyclical reloading in area A. Area A <= K_NLDDAUERHISTGRZ1 (3 minutes)
        // (counting up to 255, then no counting, value is retained) / Anzahl der Ladungsdauer des zyklischen Nachladens
        // im Bereich A.  Bereich A <= K_NLDDAUERHISTGRZ1 (3 Minuten)  (Zählung bis 255, danach keine Zählung, Wert
        // bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_LADEDAUER_BEREICH_A_WERT", STAT_HFK_LADEDAUER_BEREICH_A_WERT, "");

    unsigned char STAT_HFK_LADEDAUER_BEREICH_B_WERT = (RXBUF_UCHAR(9));
        // Number of loading times of the cyclical reloading in area B. K_NLDDAUERHISTGRZ1 (3 minutes) <area B <=
        // K_NLDDAUERHISTGRZ2 (6 minutes) (count up to 255, then no count, value is retained) / Anzahl der Ladungsdauer
        // des zyklischen Nachladens im Bereich B.   K_NLDDAUERHISTGRZ1 (3 Minuten) < Bereich B <= K_NLDDAUERHISTGRZ2 (6
        // Minuten) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_LADEDAUER_BEREICH_B_WERT", STAT_HFK_LADEDAUER_BEREICH_B_WERT, "");

    unsigned char STAT_HFK_LADEDAUER_BEREICH_C_WERT = (RXBUF_UCHAR(10));
        // Number of loading times of the cyclical reloading in area C. K_NLDDAUERHISTGRZ2 (6 minutes) <area C <=
        // K_NLDDAUERHISTGRZ3 (10 minutes) (counting up to 255, after that no counting, value is retained) / Anzahl der
        // Ladungsdauer des zyklischen Nachladens im Bereich C.   K_NLDDAUERHISTGRZ2 (6 Minuten) < Bereich C <=
        // K_NLDDAUERHISTGRZ3 (10 Minuten) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_LADEDAUER_BEREICH_C_WERT", STAT_HFK_LADEDAUER_BEREICH_C_WERT, "");

    unsigned char STAT_HFK_LADEDAUER_BEREICH_D_WERT = (RXBUF_UCHAR(11));
        // Number of loading times of the cyclical reloading in area D. K_NLDDAUERHISTGRZ3 (10 minutes) <area D <=
        // K_NLDDAUERHISTGRZ4 (15 minutes) (counting up to 255, after that no counting, value is retained) / Anzahl der
        // Ladungsdauer des zyklischen Nachladens im Bereich D.   K_NLDDAUERHISTGRZ3 (10 Minuten) < Bereich D <=
        // K_NLDDAUERHISTGRZ4 (15 Minuten) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_LADEDAUER_BEREICH_D_WERT", STAT_HFK_LADEDAUER_BEREICH_D_WERT, "");

    unsigned char STAT_HFK_LADEDAUER_BEREICH_E_WERT = (RXBUF_UCHAR(12));
        // Number of loading times of the cyclical reloading in area E. K_NLDDAUERHISTGRZ4 (15 minutes) <area E <=
        // K_NLDDAUERHISTGRZ5 (20 minutes) (counting up to 255, after that no counting, value is retained) / Anzahl der
        // Ladungsdauer des zyklischen Nachladens im Bereich E.   K_NLDDAUERHISTGRZ4 (15 Minuten) < Bereich E <=
        // K_NLDDAUERHISTGRZ5 (20 Minuten) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_LADEDAUER_BEREICH_E_WERT", STAT_HFK_LADEDAUER_BEREICH_E_WERT, "");

    unsigned char STAT_HFK_LADEDAUER_BEREICH_F_WERT = (RXBUF_UCHAR(13));
        // Number of loading times of the cyclical reloading in the area F. K_NLDDAUERHISTGRZ5 (20 minutes) <area F <=
        // K_NLDDAUERHISTGRZ6 (28 minutes) (counting up to 255, then no counting, value is retained) / Anzahl der
        // Ladungsdauer des zyklischen Nachladens im Bereich F.   K_NLDDAUERHISTGRZ5 (20 Minuten) < Bereich F <=
        // K_NLDDAUERHISTGRZ6 (28 Minuten) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_LADEDAUER_BEREICH_F_WERT", STAT_HFK_LADEDAUER_BEREICH_F_WERT, "");

    unsigned char STAT_HFK_LADEDAUER_BEREICH_G_WERT = (RXBUF_UCHAR(14));
        // Number of loading times of the cyclical reloading in area G. K_NLDDAUERHISTGRZ6 (28 minutes) <area F <=
        // K_NLDDAUERHISTGRZ7 (45 minutes) (counting up to 255, after that no counting, value is retained) / Anzahl der
        // Ladungsdauer des zyklischen Nachladens im Bereich G.   K_NLDDAUERHISTGRZ6 (28 Minuten) < Bereich F <=
        // K_NLDDAUERHISTGRZ7 (45 Minuten) (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_LADEDAUER_BEREICH_G_WERT", STAT_HFK_LADEDAUER_BEREICH_G_WERT, "");

    unsigned char STAT_HFK_LADEDAUER_BEREICH_H_WERT = (RXBUF_UCHAR(15));
        // Number of loading times of the cyclical reloading in area H. K_NLDDAUERHISTGRZ7 (45 minutes) <area H (counting
        // up to 255, then no counting, value is retained) / Anzahl der Ladungsdauer des zyklischen Nachladens im Bereich
        // H. K_NLDDAUERHISTGRZ7 (45 Minuten) < Bereich H (Zählung bis 255, danach keine Zählung, Wert bleibt erhalten)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "12V_NACHLADEHISTOGRAMM", "STAT_HFK_LADEDAUER_BEREICH_H_WERT", STAT_HFK_LADEDAUER_BEREICH_H_WERT, "");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_E_S_KL_15_WUP: {                                         // 0x4101
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_E_S_KL_15_WUP", 2);
        break;
    }

    unsigned short STAT_E_S_KL15_WUP = (RXBUF_UINT(0));
        // Wakeup Line (E_S_KL15_WUP) / Wakeup Line (E_S_KL15_WUP)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "STATUS_E_S_KL_15_WUP", "STAT_E_S_KL15_WUP", STAT_E_S_KL15_WUP, "\"0/1\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_E_A_PWG1_RAW: {                                          // 0x4102
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_E_A_PWG1_RAW", 2);
        break;
    }

    float STAT_E_A_PWG1_RAW_WERT = (RXBUF_UINT(0)*5.0f/1024.0f);
        // Pedal position sensor 1 raw / Pedal Position Sensor 1 raw
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_E_A_PWG1_RAW", "STAT_E_A_PWG1_RAW_WERT", STAT_E_A_PWG1_RAW_WERT, "\"V\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_E_A_PWG2_RAW: {                                          // 0x4103
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_E_A_PWG2_RAW", 2);
        break;
    }

    float STAT_E_A_PWG2_RAW_WERT = (RXBUF_UINT(0)*5.0f/1024.0f);
        // Pedal position sensor 2 raw / Pedal Position Sensor 2 raw
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_E_A_PWG2_RAW", "STAT_E_A_PWG2_RAW_WERT", STAT_E_A_PWG2_RAW_WERT, "\"V\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_E_A_TMEL_RAW: {                                          // 0x4104
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_E_A_TMEL_RAW", 2);
        break;
    }

    float STAT_E_A_TMEL_RAW_WERT = (RXBUF_UINT(0)*5.0f/4096.0f);
        // Engine temperature raw / Engine Temperatur raw
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_E_A_TMEL_RAW", "STAT_E_A_TMEL_RAW_WERT", STAT_E_A_TMEL_RAW_WERT, "\"V\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_BATTERIE_VOLTAGE_RAUS: {                                 // 0x4105
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_BATTERIE_VOLTAGE_RAUS", 2);
        break;
    }

    float STAT_BATTERY_VOLTAGE_RAW_WERT = (RXBUF_UINT(0)*5.0f/4095.0f);
        // Battery voltage raw / Batterie Voltage raw
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_BATTERIE_VOLTAGE_RAUS", "STAT_BATTERY_VOLTAGE_RAW_WERT", STAT_BATTERY_VOLTAGE_RAW_WERT, "\"V\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_A_U_PWG1: {                                              // 0x4106
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_A_U_PWG1", 2);
        break;
    }

    float STAT_A_U_PWG1_WERT = (RXBUF_UINT(0)/128.0f);
        // 5 V supply 1 / 5 V Supply 1
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_A_U_PWG1", "STAT_A_U_PWG1_WERT", STAT_A_U_PWG1_WERT, "\"V\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_A_U_PWG2: {                                              // 0x4107
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_A_U_PWG2", 2);
        break;
    }

    float STAT_A_U_PWG2_WERT = (RXBUF_UINT(0)/128.0f);
        // 5 V supply 2 / 5 V Supply 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_A_U_PWG2", "STAT_A_U_PWG2_WERT", STAT_A_U_PWG2_WERT, "\"V\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_E_A_MEL: {                                               // 0x4109
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_E_A_MEL", 2);
        break;
    }

    float STAT_E_A_MEL_WERT = (RXBUF_UINT(0)*12.5113f/4095.0f);
        // Voltage Fan 2 raw / Voltage Fan 2 raw
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_E_A_MEL", "STAT_E_A_MEL_WERT", STAT_E_A_MEL_WERT, "\"V\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_ECU_MICRO_TEMPERATUR: {                                  // 0x410A
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_ECU_MICRO_TEMPERATUR", 2);
        break;
    }

    short STAT_ECU_MICRO_TEMPERATUR_WERT = (RXBUF_SINT(0));
        // Ecu micro temperature / Ecu micro Temperatur
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%d%s\n", "EDM", "STATUS_ECU_MICRO_TEMPERATUR", "STAT_ECU_MICRO_TEMPERATUR_WERT", STAT_ECU_MICRO_TEMPERATUR_WERT, "\"°C\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_E_A_TMEL2_RAW: {                                         // 0x410B
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_E_A_TMEL2_RAW", 2);
        break;
    }

    float STAT__WERT = (RXBUF_UINT(0)*5.0f/1023.0f);
        // E_A_TMEL2 / E_A_TMEL2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_E_A_TMEL2_RAW", "STAT__WERT", STAT__WERT, "\"V\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_A_S_ELRLY: {                                             // 0x4120
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_A_S_ELRLY", 2);
        break;
    }

    unsigned short STAT_A_S_ELRLY = (RXBUF_UINT(0));
        // Status Electric Fan Relay / Status Electric Fan Relais
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "STATUS_A_S_ELRLY", "STAT_A_S_ELRLY", STAT_A_S_ELRLY, "\"0/1\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_A_T_ELUE: {                                              // 0x4121
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_A_T_ELUE", 2);
        break;
    }

    float STAT_A_T_ELUE_WERT = (RXBUF_UINT(0)*100.0f/65535.0f);
        // Status Electric Fan Module / Status Electric Fan Module
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_A_T_ELUE", "STAT_A_T_ELUE_WERT", STAT_A_T_ELUE_WERT, "\"%\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_A_T_EWP: {                                               // 0x4122
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_A_T_EWP", 2);
        break;
    }

    float STAT_A_T_EWAP_WERT = (RXBUF_UINT(0)*100.0f/65535.0f);
        // Water pump / Water Pump
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_A_T_EWP", "STAT_A_T_EWAP_WERT", STAT_A_T_EWAP_WERT, "\"%\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_A_S_KV1: {                                               // 0x4123
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_A_S_KV1", 2);
        break;
    }

    unsigned short STAT_A_S_KV1 = (RXBUF_UINT(0));
        // Expansion Valve / Expansion Valve
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "STATUS_A_S_KV1", "STAT_A_S_KV1", STAT_A_S_KV1, "\"0/1\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_A_S_KV2: {                                               // 0x4124
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_A_S_KV2", 2);
        break;
    }

    unsigned short STAT_A_S_KV2 = (RXBUF_UINT(0));
        // Shutoff valve / Shutoff Valve
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "STATUS_A_S_KV2", "STAT_A_S_KV2", STAT_A_S_KV2, "\"0/1\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_A_S_MEL: {                                               // 0x4125
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_A_S_MEL", 2);
        break;
    }

    unsigned short STAT_A_S_MEL = (RXBUF_UINT(0));
        // Fan relay 2 / Fan Relais 2
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "STATUS_A_S_MEL", "STAT_A_S_MEL", STAT_A_S_MEL, "\"0/1\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_E_A_PWG1: {                                              // 0x4182
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_E_A_PWG1", 2);
        break;
    }

    float STAT_E_A_PWG1_FILTERED_WERT = (RXBUF_UINT(0)/128.0f);
        // Pedal position sensor 1 filtered / Pedal Position Sensor 1 filtered
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_E_A_PWG1", "STAT_E_A_PWG1_FILTERED_WERT", STAT_E_A_PWG1_FILTERED_WERT, "\"%\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_E_A_PWG2_FILTERED: {                                     // 0x4183
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_E_A_PWG2_FILTERED", 2);
        break;
    }

    float STAT_E_A_PWG2_FILTERED_WERT = (RXBUF_UINT(0)/128.0f);
        // Pedal position sensor 2 filtered / Pedal position sensor 2 filtered
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_E_A_PWG2_FILTERED", "STAT_E_A_PWG2_FILTERED_WERT", STAT_E_A_PWG2_FILTERED_WERT, "\"%\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_TEMPERATUR_SENSOR_1: {                                   // 0x4184
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_TEMPERATUR_SENSOR_1", 2);
        break;
    }

    float STAT_TEMPERATUR_TEMPERATURSENSOR_1_WERT = (RXBUF_SINT(0)/100.0f);
        // Temperature value of the first temperature sensor in the engine compartment / Temperaturwert des ersten
        // Temperatursensors im Motorraum
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_TEMPERATUR_SENSOR_1", "STAT_TEMPERATUR_TEMPERATURSENSOR_1_WERT", STAT_TEMPERATUR_TEMPERATURSENSOR_1_WERT, "\"°C\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_BATTERY_VOLTAGE_FILTERED: {                              // 0x4185
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_BATTERY_VOLTAGE_FILTERED", 2);
        break;
    }

    float STAT_BATTERY_VOLTAGE_FILTERED_WERT = (RXBUF_SINT(0)/128.0f);
        // Battery voltage filtered / Battery Voltage filtered
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_BATTERY_VOLTAGE_FILTERED", "STAT_BATTERY_VOLTAGE_FILTERED_WERT", STAT_BATTERY_VOLTAGE_FILTERED_WERT, "\"V\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STATUS_TEMPERATUR_SENSOR_2: {                                   // 0x418B
    if (datalen < 2) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STATUS_TEMPERATUR_SENSOR_2", 2);
        break;
    }

    float STAT_TEMPERATUR_TEMPERATURSENSOR_2_WERT = (RXBUF_SINT(0)/100.0f);
        // Temperature value of the second temperature sensor in the engine compartment / Temperaturwert des zweiten
        // Temperatursensors im Motorraum
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "EDM", "STATUS_TEMPERATUR_SENSOR_2", "STAT_TEMPERATUR_TEMPERATURSENSOR_2_WERT", STAT_TEMPERATUR_TEMPERATURSENSOR_2_WERT, "\"°C\"");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }

  case I3_PID_EDM_STEUERN_AKKS: {                                                 // 0xF0D5
    if (datalen < 8) {
        ESP_LOGW(TAG, "Received %d bytes for %s, expected %d", datalen, "I3_PID_EDM_STEUERN_AKKS", 8);
        break;
    }

    unsigned short STAT_AKKS_SMOTPOAKKSLIN_WERT = (RXBUF_UINT(0));
        // Target position in steps / Sollposition in Schritten
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "STEUERN_AKKS", "STAT_AKKS_SMOTPOAKKSLIN_WERT", STAT_AKKS_SMOTPOAKKSLIN_WERT, "");

    unsigned short STAT_AKKS_IS_POS_LIN_WERT = (RXBUF_UINT(2));
        // Actual position in steps / Istposition in Schritten
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "EDM", "STEUERN_AKKS", "STAT_AKKS_IS_POS_LIN_WERT", STAT_AKKS_IS_POS_LIN_WERT, "");

    char STAT_AKKS_DSRD_POS_ANGLE_WERT = (RXBUF_SCHAR(4));
        // Target position in degrees / Sollposition in Grad
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "STEUERN_AKKS", "STAT_AKKS_DSRD_POS_ANGLE_WERT", STAT_AKKS_DSRD_POS_ANGLE_WERT, "");

    char STAT_AKKS_ACT_POS_ANGLE_WERT = (RXBUF_SCHAR(5));
        // Actual position in degrees / Istposition in Grad
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "STEUERN_AKKS", "STAT_AKKS_ACT_POS_ANGLE_WERT", STAT_AKKS_ACT_POS_ANGLE_WERT, "");

    unsigned char BF_AKKS_ERROR = (RXBUF_UCHAR(6));
        // General diagnosis status / Diagnosestatus allgemein
        // BF_AKKS_ERROR is a BITFIELD of size unsigned char.  We don't yet generate definitions for each bit, we treat as the host data type
            // STAT_AKKS_ERROR: Mask: 0x01 - indicates if an error is present
            // STAT_AKKS_DIAG_DONE_NO_MESS: Mask: 0x02 - indicates the no message diagnostic required time is over
            // STAT_AKKS_DIAG_DONE_LOW_FLAP: Mask: 0x04 - indicates the low flap diagnostic required time is over
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lx%s\n", "EDM", "STEUERN_AKKS", "BF_AKKS_ERROR", (unsigned long)BF_AKKS_ERROR, "\"Bit\"");

    unsigned char STAT_VRSAKKLIN_WERT = (RXBUF_UCHAR(7));
        // Variant info from the operator / Varianteninfo vom Steller
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "EDM", "STEUERN_AKKS", "STAT_VRSAKKLIN_WERT", STAT_VRSAKKLIN_WERT, "");

    // ==========  Add your processing here ==========
    hexdump(rxbuf, type, pid);

    break;
  }