//
// Warning: don't edit - generated by generate_ecu_code.pl processing ../dev/kafas20.json: KAF 5D: Camera based driver assistance system
// This generated code  makes it easier to process CANBUS messages from the KAF ecu in a BMW i3
//

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

    unsigned long STAT_FLA_OP_TIME_WERT = (RXBUF_UINT32(0));
        // Duration of FLA activated by driver [s] / Zeitdauer FLA durch Fahrer aktiviert [s]
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_FASTA_FLA_DATA", "STAT_FLA_OP_TIME_WERT", STAT_FLA_OP_TIME_WERT, "\"s\"");

    unsigned long STAT_DELTA_TIME_FLA_NIGHT_WERT = (RXBUF_UINT32(4));
        // Duration in the ambient brightness FLA activation allowed [s] / Zeitdauer in der Umgebungshelligkeit FLA
        // Aktivierung erlaubt  [s]
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_FASTA_FLA_DATA", "STAT_DELTA_TIME_FLA_NIGHT_WERT", STAT_DELTA_TIME_FLA_NIGHT_WERT, "\"s\"");

    unsigned long STAT_DELTA_TIME_FLA_ACT_HB_WERT = (RXBUF_UINT32(8));
        // Duration of switch-on recommendation FLA [s] / Zeitdauer Einschaltempfehlung FLA  [s]
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_FASTA_FLA_DATA", "STAT_DELTA_TIME_FLA_ACT_HB_WERT", STAT_DELTA_TIME_FLA_ACT_HB_WERT, "\"s\"");

    unsigned long STAT_DELTA_TIME_FLA_ACT_LB_WERT = (RXBUF_UINT32(12));
        // Duration of switch-off recommendation [s] / Zeitdauer Abschaltempfehlung [s]
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_FASTA_FLA_DATA", "STAT_DELTA_TIME_FLA_ACT_LB_WERT", STAT_DELTA_TIME_FLA_ACT_LB_WERT, "\"s\"");

    unsigned long STAT_FLA_COUNT_OVERRIDE_WERT = (RXBUF_UINT32(16));
        // Number of driver overloads / Anzahl Übersteuerung durch Fahrer
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_FASTA_FLA_DATA", "STAT_FLA_COUNT_OVERRIDE_WERT", STAT_FLA_COUNT_OVERRIDE_WERT, "\"Counts\"");

    unsigned long STAT_OPTIME_TOTAL_WERT = (RXBUF_UINT32(20));
        // Absolute operating time counter [s] / Absoluter Betriebszeitzähler [s]
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_FASTA_FLA_DATA", "STAT_OPTIME_TOTAL_WERT", STAT_OPTIME_TOTAL_WERT, "\"s\"");

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

    break;
  }

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

    unsigned short STAT_CNTRY_CODE_WERT = (RXBUF_UINT(0));
        // ISO Country Code of the country in which the vehicle covered the most kilometers. / ISO Country Code des
        // Landes in welchem das Fahrzeug die meisten  Kilometer zurückgelegt hat.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_KAFAS_ECU_DATA", "STAT_CNTRY_CODE_WERT", STAT_CNTRY_CODE_WERT, "\"Counts\"");

    unsigned long STAT_OPTIME_TOTAL_WERT_0X4002 = (RXBUF_UINT32(2));
        // Absolute operating time counter / Absoluter Betriebszeitzähler
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_ECU_DATA", "STAT_OPTIME_TOTAL_WERT_0X4002", STAT_OPTIME_TOTAL_WERT_0X4002, "\"s\"");

    unsigned long STAT_OPTIME_NIGHT_WERT = (RXBUF_UINT32(6));
        // Operating time at night. Based on BV-Algo overnight decision / Betriebszeit in der Nacht. Basiert auf BV-Algo
        // Nachtentscheidung
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_ECU_DATA", "STAT_OPTIME_NIGHT_WERT", STAT_OPTIME_NIGHT_WERT, "\"s\"");

    unsigned long STAT_OPTIME_WIPER_WERT = (RXBUF_UINT32(10));
        // Operating time during rain. Based on Algo Rain Decision / Betriebszeit während Regen. Basiert auf Algo
        // Regenentscheidung
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_ECU_DATA", "STAT_OPTIME_WIPER_WERT", STAT_OPTIME_WIPER_WERT, "\"s\"");

    unsigned long STAT_DRIVEN_DIST_TOTAL_WERT = (RXBUF_UINT32(14));
        // Absolutely driven kilometers / Absolut gefahrene Kilometer
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_ECU_DATA", "STAT_DRIVEN_DIST_TOTAL_WERT", STAT_DRIVEN_DIST_TOTAL_WERT, "\"km\"");

    unsigned long STAT_DRIVEN_DIST_URBAN_WERT = (RXBUF_UINT32(18));
        // Total kilometers driven on urban or residential area roads / Absolut gefahrene Kilometer auf Straßentyp Urban
        // oder Residential Area
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_ECU_DATA", "STAT_DRIVEN_DIST_URBAN_WERT", STAT_DRIVEN_DIST_URBAN_WERT, "\"km\"");

    unsigned long STAT_DRIVEN_DIST_RURAL_WERT = (RXBUF_UINT32(22));
        // Absolute kilometers driven on the rural or highway type / Absolut gefahrene Kilometer auf Straßentyp Rural
        // oder Highway
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_ECU_DATA", "STAT_DRIVEN_DIST_RURAL_WERT", STAT_DRIVEN_DIST_RURAL_WERT, "\"km\"");

    unsigned long STAT_DRIVEN_DIST_MOWAY_WERT = (RXBUF_UINT32(26));
        // Absolute kilometers driven on road type Motorway / Absolut gefahrene Kilometer auf Straßentyp Motorway
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_ECU_DATA", "STAT_DRIVEN_DIST_MOWAY_WERT", STAT_DRIVEN_DIST_MOWAY_WERT, "\"km\"");

    unsigned long STAT_DRIVEN_DIST_NA_WERT = (RXBUF_UINT32(30));
        // Absolute kilometers driven with no available road type / Absolut gefahrene Kilometer ohne verfügbaren
        // Straßentyp
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_ECU_DATA", "STAT_DRIVEN_DIST_NA_WERT", STAT_DRIVEN_DIST_NA_WERT, "\"km\"");

    unsigned short STAT_AMNT_EYEQ_RESET_WERT = (RXBUF_UINT(34));
        // Number of resets of the BV processor performed during normal operation / Anzahl der erfolgten Resets des
        // BV-Prozessors während normalem Betrieb
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_KAFAS_ECU_DATA", "STAT_AMNT_EYEQ_RESET_WERT", STAT_AMNT_EYEQ_RESET_WERT, "\"Counts\"");

    unsigned short STAT_AMNT_ONLINE_CALIB_WERT = (RXBUF_UINT(36));
        // Counter for the completed online calibration processes / Zähler über die Erfolgten Online-Kalibriervorgänge
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_KAFAS_ECU_DATA", "STAT_AMNT_ONLINE_CALIB_WERT", STAT_AMNT_ONLINE_CALIB_WERT, "\"Counts\"");

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

    break;
  }

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

    unsigned long STAT_TLC_DRIV_LEFT_AVAIL_WERT = (RXBUF_UINT32(0));
        // Absolute kilometers driven with availability on the left / Absolut gefahrene Kilometer mit Verfübarkeit auf
        // der linken Seite
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_TLC_DATA", "STAT_TLC_DRIV_LEFT_AVAIL_WERT", STAT_TLC_DRIV_LEFT_AVAIL_WERT, "\"km\"");

    unsigned long STAT_TLC_DRIV_RIGHT_AVAIL_WERT = (RXBUF_UINT32(4));
        // Absolute kilometers driven with availability on the right / Absolut gefahrene Kilometer mit Verfübarkeit auf
        // der rechten Seite
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_TLC_DATA", "STAT_TLC_DRIV_RIGHT_AVAIL_WERT", STAT_TLC_DRIV_RIGHT_AVAIL_WERT, "\"km\"");

    unsigned long STAT_TLC_DRIV_DIST_REL_SPD_WERT = (RXBUF_UINT32(8));
        // Absolutely driven with active TLC and relevant speed / Absolut gefahrene  mit aktivem TLC und relavanter
        // Geschwindigkeit
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_TLC_DATA", "STAT_TLC_DRIV_DIST_REL_SPD_WERT", STAT_TLC_DRIV_DIST_REL_SPD_WERT, "\"km\"");

    unsigned short STAT_TLC_AMNT_WARN_WERT = (RXBUF_UINT(12));
        // Number of issued TLC warnings / Anzahl ausgegebener TLC Warnungen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_KAFAS_TLC_DATA", "STAT_TLC_AMNT_WARN_WERT", STAT_TLC_AMNT_WARN_WERT, "\"Counts\"");

    unsigned short STAT_TLC_AMNT_DEACT_WERT = (RXBUF_UINT(14));
        // Number of times the TLC function was deactivated by the driver / Anzahl der Deaktivierung der TLC-Funktion
        // durch den Fahrer
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_KAFAS_TLC_DATA", "STAT_TLC_AMNT_DEACT_WERT", STAT_TLC_AMNT_DEACT_WERT, "\"Counts\"");

    unsigned long STAT_TLC_DRIV_DIST_ACT_WERT = (RXBUF_UINT32(16));
        // Kilometers driven with activated TLC / Gefahrene Kilometer mit aktiviertem TLC
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_TLC_DATA", "STAT_TLC_DRIV_DIST_ACT_WERT", STAT_TLC_DRIV_DIST_ACT_WERT, "\"km\"");

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

    break;
  }

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

    unsigned long STAT_FCW_DRIVEN_DIST_ACT_WERT = (RXBUF_UINT32(0));
        // Total kilometers driven with activated FCW function / Absolut gefahrene Kilometer mit aktivierter FCW Funktion
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_DRIVEN_DIST_ACT_WERT", STAT_FCW_DRIVEN_DIST_ACT_WERT, "\"km\"");

    unsigned long STAT_FCW_DRIVEN_DIST_FS_WERT = (RXBUF_UINT32(4));
        // Total kilometers driven in fail safe mode / Absolut gefahrene Kilometer im Fail Safe Mode
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_DRIVEN_DIST_FS_WERT", STAT_FCW_DRIVEN_DIST_FS_WERT, "\"km\"");

    unsigned long STAT_FCW_DRIVEN_DIST_FS_ACT_WERT = (RXBUF_UINT32(8));
        // Total kilometers driven with activated FCW function in fail safe mode / Absolut gefahrene Kilometer mit
        // aktivierter FCW Funktion im Fail Safe Mode
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_DRIVEN_DIST_FS_ACT_WERT", STAT_FCW_DRIVEN_DIST_FS_ACT_WERT, "\"km\"");

    unsigned long STAT_FCW_DRIVEN_DIST_FOR_OFF_WERT = (RXBUF_UINT32(12));
        // Absolutely driven kilometers with activated FCW function and advance warning level off / Absolut gefahrene
        // Kilometer mit aktivierter FCW Funktion und Vorwarnstufe  aus 
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_DRIVEN_DIST_FOR_OFF_WERT", STAT_FCW_DRIVEN_DIST_FOR_OFF_WERT, "\"km\"");

    unsigned long STAT_FCW_DRIVEN_DIST_FOR_EARLY_WERT = (RXBUF_UINT32(16));
        // Total kilometers traveled with activated FCW function and early warning level / Absolut gefahrene Kilometer
        // mit aktivierter FCW Funktion und Vorwarnstufe  früh 
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_DRIVEN_DIST_FOR_EARLY_WERT", STAT_FCW_DRIVEN_DIST_FOR_EARLY_WERT, "\"km\"");

    unsigned long STAT_FCW_DRIVEN_DIST_FOR_LATE_WERT = (RXBUF_UINT32(20));
        // Total kilometers driven with activated FCW function and late warning level / Absolut gefahrene Kilometer mit
        // aktivierter FCW Funktion und Vorwarnstufe  spät 
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_DRIVEN_DIST_FOR_LATE_WERT", STAT_FCW_DRIVEN_DIST_FOR_LATE_WERT, "\"km\"");

    unsigned short STAT_FCW_AMNT_FOR_WERT = (RXBUF_UINT(24));
        // Number of pre-warnings / Anzahl der Vorwarnungen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_AMNT_FOR_WERT", STAT_FCW_AMNT_FOR_WERT, "\"Counts\"");

    unsigned short STAT_FCW_AMNT_ACUTE_WERT = (RXBUF_UINT(26));
        // Number of acute warnings / Anzahl der Akutwarnungen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_AMNT_ACUTE_WERT", STAT_FCW_AMNT_ACUTE_WERT, "\"Counts\"");

    unsigned short STAT_FCW_AMNT_ACUTE_45_WERT = (RXBUF_UINT(28));
        // Number of acute warnings in the range 0 km / h¿ 45 km / h / Anzahl der Akutwarnungen im Bereich 0 km/h¿ 45
        // km/h
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_AMNT_ACUTE_45_WERT", STAT_FCW_AMNT_ACUTE_45_WERT, "\"Counts\"");

    unsigned short STAT_FCW_AMNT_ACUTE_90_WERT = (RXBUF_UINT(30));
        // Number of acute warnings in the range 45 km / h¿ 90 km / h / Anzahl der Akutwarnungen im Bereich 45 km/h¿ 90
        // km/h
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_AMNT_ACUTE_90_WERT", STAT_FCW_AMNT_ACUTE_90_WERT, "\"Counts\"");

    unsigned short STAT_FCW_AMNT_ACUTE_135_WERT = (RXBUF_UINT(32));
        // Number of acute warnings in the range 90 km / h¿ 135 km / h / Anzahl der Akutwarnungen im Bereich 90 km/h¿ 135
        // km/h
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_AMNT_ACUTE_135_WERT", STAT_FCW_AMNT_ACUTE_135_WERT, "\"Counts\"");

    unsigned short STAT_FCW_PREFILLS_WERT = (RXBUF_UINT(34));
        // Number of pre-fill requests triggered by FCW / Anzahl der von FCW ausgelösten Pre-Fill Anforderungen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_PREFILLS_WERT", STAT_FCW_PREFILLS_WERT, "\"Counts\"");

    unsigned short STAT_FCW_PRECRASH_WERT = (RXBUF_UINT(36));
        // Number of pre-crash messages triggered by FCW / Anzahl der von FCW ausgelösten Pre-Crash Meldungen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_PRECRASH_WERT", STAT_FCW_PRECRASH_WERT, "\"Counts\"");

    unsigned short STAT_FCW_DEACT_WERT = (RXBUF_UINT(38));
        // Number of times the FCW function has been deactivated by the driver / Anzahl der Deaktivierung der
        // FCW-Funktion durch den Fahrer
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_DEACT_WERT", STAT_FCW_DEACT_WERT, "\"Counts\"");

    unsigned short STAT_FCW_FS_CC_WERT = (RXBUF_UINT(40));
        // Number of triggered Fail-Save CC messages / Anzahl der ausgelösten Fail-Save CC-Meldungen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KAFAS_FCW_DATA", "STAT_FCW_FS_CC_WERT", STAT_FCW_FS_CC_WERT, "\"Counts\"");

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

    break;
  }

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

    unsigned long STAT_SLI_AMT_CAM_DET_WERT = (RXBUF_UINT32(0));
        // Number of camera detections of traffic signs / Anzahl der Kameradetektionen von Verkehrsschildern
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_AMT_CAM_DET_WERT", STAT_SLI_AMT_CAM_DET_WERT, "\"Counts\"");

    char STAT_SLI_MATCH_URBAN_WERT = (RXBUF_UCHAR(4));
        // Share of camera detection that match the explicit speed limits on the street type Urban or Residential Area /
        // Anteil der  Kameradetektion die mit den expliziten Speed Limits auf dem Straßentyp Urban oder Residential Area
        // übereinstimmen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_MATCH_URBAN_WERT", STAT_SLI_MATCH_URBAN_WERT, "\"Counts\"");

    char STAT_SLI_MATCH_RURAL_WERT = (RXBUF_UCHAR(5));
        // Proportion of camera detection that corresponds to the explicit speed limits on the road type rural or highway
        // / Anteil der  Kameradetektion die mit den expliziten Speed Limits auf dem Straßentyp Rural oder Highway
        // übereinstimmen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_MATCH_RURAL_WERT", STAT_SLI_MATCH_RURAL_WERT, "\"Counts\"");

    char STAT_SLI_MATCH_MOWAY_WERT = (RXBUF_UCHAR(6));
        // Percentage of camera detection that corresponds to the explicit speed limits on the road type Motorway /
        // Anteil der  Kameradetektion die mit den expliziten Speed Limits auf dem Straßentyp Motorway übereinstimmen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_MATCH_MOWAY_WERT", STAT_SLI_MATCH_MOWAY_WERT, "\"Counts\"");

    unsigned short STAT_SLI_REP_URBAN_WERT = (RXBUF_UINT(7));
        // Average distance at which signs repeat on the street type Urban or Residential Area / Durschnittlich Enfernung
        // in welcher sich Schilder auf dem Straßentyp Urbanoder Residential Area wiederholen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_REP_URBAN_WERT", STAT_SLI_REP_URBAN_WERT, "\"m\"");

    unsigned short STAT_SLI_REP_RURAL_WERT = (RXBUF_UINT(9));
        // Average distance at which signs repeat on the road type rural or highway / Durschnittlich Enfernung in welcher
        // sich Schilder auf dem Straßentyp Rural oder Highway wiederholen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_REP_RURAL_WERT", STAT_SLI_REP_RURAL_WERT, "\"m\"");

    unsigned short STAT_SLI_REP_MOWAY_WERT = (RXBUF_UINT(11));
        // Average distance at which signs repeat on the road type Motorway / Durschnittlich Enfernung in welcher sich
        // Schilder auf dem Straßentyp Motorway wiederholen
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_REP_MOWAY_WERT", STAT_SLI_REP_MOWAY_WERT, "\"m\"");

    unsigned long STAT_SLI_OVER_SLI_WERT = (RXBUF_UINT32(13));
        // Distance driven at least 20 km / h above the detected speed limit / Gefahrene Entfernung mit mindestens 20
        // km/h über dem erkannten Speed Limit
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_OVER_SLI_WERT", STAT_SLI_OVER_SLI_WERT, "\"km\"");

    unsigned short STAT_SLI_SSS_TIME_WERT = (RXBUF_UINT(17));
        // Number of recognized additional characters with time restriction / Anzahl der erkannten Zusatzzeichen mit
        // Zeitbeschränkung
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_SSS_TIME_WERT", STAT_SLI_SSS_TIME_WERT, "\"Counts\"");

    unsigned long STAT_SLI_NPI_WERT = (RXBUF_UINT32(19));
        // Kilometers driven with no overtaking recognized / Gefahrene Kilometer mit erkanntem Überholverbot
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_NPI_WERT", STAT_SLI_NPI_WERT, "\"km\"");

    unsigned short STAT_SLI_NP_WITHDRAW_DIST_WERT = (RXBUF_UINT(23));
        // Number of cancellations of overtaking ban due to exceeding the stopping distance / Anzahl Aufhebungen
        // Überholverbot infolge Überschreitung Haltedistanz
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_NP_WITHDRAW_DIST_WERT", STAT_SLI_NP_WITHDRAW_DIST_WERT, "\"Counts\"");

    unsigned short STAT_SLI_NP_WITHDRAW_SIGN_WERT = (RXBUF_UINT(25));
        // Number of cancellations No overtaking due to detection of a lifting sign / Anzahl Aufhebungen Überholverbot
        // infolge Detektion Aufhebungsschild
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_KAFAS_SLI_DATA", "STAT_SLI_NP_WITHDRAW_SIGN_WERT", STAT_SLI_NP_WITHDRAW_SIGN_WERT, "\"Counts\"");

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

    break;
  }

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

    unsigned char STAT_BYTE_0_FAULT_WERT = (RXBUF_UCHAR(0));
        // The parameter values shall indicate 0 for fault_not_present and 1 for fault_present. Bit: 0
        // UP1V0D_freeze_fault 1 UP1V8D_freeze_fault 2 UP2V5D_freeze_fault 3 UP3V3D_freeze_fault 4 UP5V0D_freeze_fault 5
        // VTEMP1_freeze_fault 6 VTEMP2_freeze_fault 7 V_BAT1_freeze_fault / The parameter values shall indicate 0 for
        // fault_not_present and 1 for fault_present. Bit: 0 UP1V0D_freeze_fault 1 UP1V8D_freeze_fault 2
        // UP2V5D_freeze_fault 3 UP3V3D_freeze_fault 4 UP5V0D_freeze_fault 5 VTEMP1_freeze_fault 6 VTEMP2_freeze_fault 7
        // V_BAT1_freeze_fault
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_STATUS_SAFETY_DIAG_INFO", "STAT_BYTE_0_FAULT_WERT", STAT_BYTE_0_FAULT_WERT, "\"HEX\"");

    unsigned char STAT_BYTE_1_FAULT_WERT = (RXBUF_UCHAR(1));
        // The parameter values shall indicate 0 for fault_not_present and 1 for fault_present. Bit: 0
        // UP1V0D_freeze_fault 1 UP1V8D_freeze_fault 2 UP2V5D_freeze_fault 3 UP3V3D_freeze_fault 4 UP5V0D_freeze_fault 5
        // VTEMP1_freeze_fault 6 VTEMP2_freeze_fault 7 V_BAT1_freeze_fault / The parameter values shall indicate 0 for
        // fault_not_present and 1 for fault_present. Bit: 0 UP1V0D_freeze_fault 1 UP1V8D_freeze_fault 2
        // UP2V5D_freeze_fault 3 UP3V3D_freeze_fault 4 UP5V0D_freeze_fault 5 VTEMP1_freeze_fault 6 VTEMP2_freeze_fault 7
        // V_BAT1_freeze_fault
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_STATUS_SAFETY_DIAG_INFO", "STAT_BYTE_1_FAULT_WERT", STAT_BYTE_1_FAULT_WERT, "\"HEX\"");

    unsigned char STAT_BYTE_2_FAULT_WERT = (RXBUF_UCHAR(2));
        // The parameter values shall indicate 0 for fault_not_present and 1 for fault_present. Bit: 0
        // UP1V0D_voltage_fault 1 UP1V8D_voltage_fault 2 UP2V5D_voltage_fault 3 UP3V3D_voltage_fault 4
        // UP5V0D_voltage_fault 5 VTEMP1_temperature_fault 6 VTEMP2_temperature_fault 7 V_BAT1_voltage_fault / The
        // parameter values shall indicate 0 for fault_not_present and 1 for fault_present.  Bit: 0 UP1V0D_voltage_fault
        // 1 UP1V8D_voltage_fault 2 UP2V5D_voltage_fault 3 UP3V3D_voltage_fault 4 UP5V0D_voltage_fault 5
        // VTEMP1_temperature_fault 6 VTEMP2_temperature_fault 7 V_BAT1_voltage_fault
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_STATUS_SAFETY_DIAG_INFO", "STAT_BYTE_2_FAULT_WERT", STAT_BYTE_2_FAULT_WERT, "\"HEX\"");

    unsigned char STAT_BYTE_3_FAULT_WERT = (RXBUF_UCHAR(3));
        // The parameter values shall indicate 0 for fault_not_present and 1 for fault_present. Bit: 0
        // ECU_inconsistent_temperature_fault / The parameter values shall indicate 0 for fault_not_present and 1 for
        // fault_present. Bit: 0 ECU_inconsistent_temperature_fault
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_STATUS_SAFETY_DIAG_INFO", "STAT_BYTE_3_FAULT_WERT", STAT_BYTE_3_FAULT_WERT, "\"HEX\"");

    unsigned char STAT_BYTE_4_FAULT_WERT = (RXBUF_UCHAR(4));
        // The parameter values shall indicate 0 for fault_not_present and 1 for fault_present. Bit: 0 Eq2Unavailable 1
        // Eq2FaultHandlingAliveError 2 Eq2FaultHandlingCrcError 3 VideoError_400 4 TempStatus_400 5 CamLVDS_Defect_400 6
        // CamEEP_Fail_400 7 BurntPixel_400 / The parameter values shall indicate 0 for fault_not_present and 1 for
        // fault_present. Bit: 0 Eq2Unavailable 1 Eq2FaultHandlingAliveError 2 Eq2FaultHandlingCrcError 3 VideoError_400
        // 4 TempStatus_400 5 CamLVDS_Defect_400 6 CamEEP_Fail_400 7 BurntPixel_400
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_STATUS_SAFETY_DIAG_INFO", "STAT_BYTE_4_FAULT_WERT", STAT_BYTE_4_FAULT_WERT, "\"HEX\"");

    unsigned char STAT_BYTE_5_FAULT_WERT = (RXBUF_UCHAR(5));
        // The parameter values shall indicate 0 for fault_not_present and 1 for fault_present. Bit: 0 DDR_Failure_400 1
        // WdgMSafetyAliveSupervisonFault / The parameter values shall indicate 0 for fault_not_present and 1 for
        // fault_present. Bit: 0 DDR_Failure_400 1 WdgMSafetyAliveSupervisonFault
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_STATUS_SAFETY_DIAG_INFO", "STAT_BYTE_5_FAULT_WERT", STAT_BYTE_5_FAULT_WERT, "\"HEX\"");

    unsigned char STAT_BYTE_6_FAULT_WERT = (RXBUF_UCHAR(6));
        // The parameter values shall indicate 0 for fault_not_present and 1 for fault_present. Bit: 0 ActiveFaultClass
        // Bit 0 * 1 ActiveFaultClass Bit 1 * 2 ActiveFaultClass Bit 2 * 3 (not disp_drasy_available) 4 (not
        // aAssistFunctionAvailable) 5 (not qAssistActive) 6 Not in use 7 Safe state entered disp_drasy_available means
        // that the bit is 0 when the signal is available, and 1 when it is not available / The parameter values shall
        // indicate 0 for fault_not_present and 1 for fault_present. Bit: 0 ActiveFaultClass Bit 0* 1 ActiveFaultClass
        // Bit 1* 2 ActiveFaultClass Bit 2* 3 (not disp_drasy_available)  4 (not aAssistFunctionAvailable) 5 (not
        // qAssistActive) 6 Not in use 7 Safe state entered disp_drasy_available  means that the bit is  0  when the
        // signal is availablem, and  1  when it is not available
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_STATUS_SAFETY_DIAG_INFO", "STAT_BYTE_6_FAULT_WERT", STAT_BYTE_6_FAULT_WERT, "\"HEX\"");

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

    break;
  }

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

    unsigned char STAT_WARN_FLAV_FCW = (RXBUF_UCHAR(0));
        // currently selected warning flavor / currently selected warning flavor
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_STATUS_WARNZEITPUNKT_FCW", "STAT_WARN_FLAV_FCW", STAT_WARN_FLAV_FCW, "\"0-n\"");

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

    break;
  }

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

    unsigned short STAT_PPP_WARNING_ZONE = (RXBUF_UINT(0));
        // Type of warning zone / Art der Warnzone
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_WARNING_ZONE", STAT_PPP_WARNING_ZONE, "\"0-n\"");

    unsigned short STAT_PPP_AMNT_DZ_EVENTS_0_TO_20_WERT = (RXBUF_UINT(2));
        // The parameter is determined by counting the number of DZ events in the range 0 <x <20 km / h / Die Kenngröße
        // wird bestimmt, indem die Anzahl der DZ-Events im Bereich 0 < x < 20 km/h gezählt wird
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_DZ_EVENTS_0_TO_20_WERT", STAT_PPP_AMNT_DZ_EVENTS_0_TO_20_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_DZ_EVENTS_20_TO_40_WERT = (RXBUF_UINT(4));
        // The parameter is determined by counting the number of DZ events in the range 20 <x <40 km / h / Die Kenngröße
        // wird bestimmt, indem die Anzahl der DZ-Events im Bereich 20 < x < 40 km/h gezählt wird
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_DZ_EVENTS_20_TO_40_WERT", STAT_PPP_AMNT_DZ_EVENTS_20_TO_40_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_DZ_EVENTS_40_TO_60_WERT = (RXBUF_UINT(6));
        // The parameter is determined by counting the number of DZ events in the range 40 <x <60 km / h / Die Kenngröße
        // wird bestimmt, indem die Anzahl der DZ-Events im Bereich 40 < x < 60 km/h gezählt wird
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_DZ_EVENTS_40_TO_60_WERT", STAT_PPP_AMNT_DZ_EVENTS_40_TO_60_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_PDZ1_EVENTS_0_TO_20_WERT = (RXBUF_UINT(8));
        // The parameter is determined by counting the number of PDZ1 events in the range 0 <x <20 km / h / Die Kenngröße
        // wird bestimmt, indem die Anzahl der PDZ1-Events im Bereich 0 < x < 20 km/h gezählt wird
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_PDZ1_EVENTS_0_TO_20_WERT", STAT_PPP_AMNT_PDZ1_EVENTS_0_TO_20_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_PDZ1_EVENTS_20_TO_40_WERT = (RXBUF_UINT(10));
        // The parameter is determined by counting the number of PDZ1 events in the range 20 <x <40 km / h / Die
        // Kenngröße wird bestimmt, indem die Anzahl der PDZ1-Events im Bereich 20 < x < 40 km/h gezählt wird
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_PDZ1_EVENTS_20_TO_40_WERT", STAT_PPP_AMNT_PDZ1_EVENTS_20_TO_40_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_PDZ1_EVENTS_40_TO_60_WERT = (RXBUF_UINT(12));
        // The parameter is determined by counting the number of PDZ1 events in the range 40 <x <60 km / h / Die
        // Kenngröße wird bestimmt, indem die Anzahl der PDZ1-Events im Bereich 40 < x < 60 km/h gezählt wird
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_PDZ1_EVENTS_40_TO_60_WERT", STAT_PPP_AMNT_PDZ1_EVENTS_40_TO_60_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_PDZ2_EVENTS_0_TO_20_WERT = (RXBUF_UINT(14));
        // The parameter is determined by counting the number of PDZ2 events in the range 0 <x <20 km / h / Die Kenngröße
        // wird bestimmt, indem die Anzahl der PDZ2-Events im Bereich 0 < x < 20 km/h gezählt wird
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_PDZ2_EVENTS_0_TO_20_WERT", STAT_PPP_AMNT_PDZ2_EVENTS_0_TO_20_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_PDZ2_EVENTS_20_TO_40_WERT = (RXBUF_UINT(16));
        // The parameter is determined by counting the number of PDZ2 events in the range 20 <x <40 km / h / Die
        // Kenngröße wird bestimmt, indem die Anzahl der PDZ2-Events im Bereich 20 < x < 40 km/h gezählt wird
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_PDZ2_EVENTS_20_TO_40_WERT", STAT_PPP_AMNT_PDZ2_EVENTS_20_TO_40_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_PDZ2_EVENTS_40_TO_60_WERT = (RXBUF_UINT(18));
        // The parameter is determined by counting the number of PDZ2 events in the range 40 <x <60 km / h / Die
        // Kenngröße wird bestimmt, indem die Anzahl der PDZ2-Events im Bereich 40 < x < 60 km/h gezählt wird
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_PDZ2_EVENTS_40_TO_60_WERT", STAT_PPP_AMNT_PDZ2_EVENTS_40_TO_60_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_PREWARNUNG_REQUESTS_WERT = (RXBUF_UINT(20));
        // The parameter is determined by counting the number of pre-warning requests / Die Kenngröße wird bestimmt,
        // indem die Anzahl der Pre-Warning-Requests gezählt wird
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_PREWARNUNG_REQUESTS_WERT", STAT_PPP_AMNT_PREWARNUNG_REQUESTS_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_ACUTEWARNING_REQUESTS_WERT = (RXBUF_UINT(22));
        // The parameter is determined by counting the number of acute warning requests. / Die Kenngröße wird bestimmt,
        // indem die Anzahl der Acute-Warning-Requests gezählt wird.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_ACUTEWARNING_REQUESTS_WERT", STAT_PPP_AMNT_ACUTEWARNING_REQUESTS_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_HBA_REQUESTS_WERT = (RXBUF_UINT(24));
        // The parameter is determined by counting the number of HBA requests. / Die Kenngröße wird bestimmt, indem die
        // Anzahl der HBA-Requests gezählt wird.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_HBA_REQUESTS_WERT", STAT_PPP_AMNT_HBA_REQUESTS_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_PREFILL_REQUESTS_WERT = (RXBUF_UINT(26));
        // The parameter is determined by counting the number of prefill requests. / Die Kenngröße wird bestimmt, indem
        // die Anzahl der Prefill-Requests gezählt wird.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_PREFILL_REQUESTS_WERT", STAT_PPP_AMNT_PREFILL_REQUESTS_WERT, "\"Counts\"");

    unsigned short STAT_PPP_AMNT_BRAKE_REQUESTS_WERT = (RXBUF_UINT(28));
        // The parameter is determined by counting the number of brake requests. / Die Kenngröße wird bestimmt, indem die
        // Anzahl der Brake-Requests gezählt wird.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_AMNT_BRAKE_REQUESTS_WERT", STAT_PPP_AMNT_BRAKE_REQUESTS_WERT, "\"Counts\"");

    unsigned short STAT_PPP_DEACT_DRIVER_WERT = (RXBUF_UINT(30));
        // The parameter is determined by counting the number of times the pFGS function was switched off by the driver.
        // (Status change of the activation by pressing the button) / Die Kenngröße wird bestimmt, indem die Anzahl der
        // Abschaltungen der Funktion pFGS durch den Fahrer gezählt wird. (Statuswechsel der Aktivierung durch
        // Tasterbetätigung)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_DEACT_DRIVER_WERT", STAT_PPP_DEACT_DRIVER_WERT, "\"Counts\"");

    unsigned short STAT_PPP_DEACT_AVAILABILITY_WERT = (RXBUF_UINT(32));
        // The parameter is determined by counting the number of times the pFGS function was switched off by the KAFAS
        // system based on the availability concept (e.g. recognition qualifier, degradation concept, ...). / Die
        // Kenngröße wird bestimmt, indem die Anzahl der Abschaltungen der Funktion pFGS durch das KAFAS System aufgrund
        // des Verfügbarkeitskonzeptes (z.B. Erkennungsqualifier, Degradationskonzept,...) gezählt wird.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_DEACT_AVAILABILITY_WERT", STAT_PPP_DEACT_AVAILABILITY_WERT, "\"Counts\"");

    unsigned short STAT_PPP_DEACT_WARNING_CHAIN_WERT = (RXBUF_UINT(34));
        // The parameter is determined by counting the number of times the pPP function has been switched off by the
        // KAFAS system based on the braking and warning chain. / Die Kenngröße wird bestimmt, indem die Anzahl der
        // Abschaltungen der Funktion pPP durch das KAFAS System aufgrund der Brems-und Warnkette gezählt wird.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_DEACT_WARNING_CHAIN_WERT", STAT_PPP_DEACT_WARNING_CHAIN_WERT, "\"Counts\"");

    unsigned long STAT_PPP_OPERATION_TIME_CL50_WERT = (RXBUF_UINT32(36));
        // The parameter is determined by always counting the operating time in seconds from terminal 50. / Die Kenngröße
        // wird bestimmt, indem immer ab Kl 50 die Betriebszeit in Sekunden gezählt wird.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_OPERATION_TIME_CL50_WERT", STAT_PPP_OPERATION_TIME_CL50_WERT, "\"s\"");

    unsigned long STAT_PPP_OPERATION_TIME_ACTIVE_WERT = (RXBUF_UINT32(40));
        // The parameter is determined by always counting the operating time in seconds from terminal 50 while the pFGS
        // function is activated. / Die Kenngröße wird bestimmt, indem immer ab Kl 50 die Betriebszeit in Sekunden
        // gezählt wird, während die pFGS-Funktion aktiviert ist.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_OPERATION_TIME_ACTIVE_WERT", STAT_PPP_OPERATION_TIME_ACTIVE_WERT, "\"s\"");

    unsigned short STAT_PPP_FS_CC_WERT = (RXBUF_UINT(44));
        // The parameter is determined by counting the number of Check Control messages triggered due to reduced
        // visibility for the pFGS function. / Die Kenngröße wird bestimmt, indem die Anzahl der ausgelösten Check
        // Control Meldungen aufgrund reduzierter Sicht für die Funktion pFGS gezählt wird.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_FS_CC_WERT", STAT_PPP_FS_CC_WERT, "\"Counts\"");

    unsigned long STAT_PPP_DRIVEN_TIME_FS_ACT_WERT = (RXBUF_UINT32(46));
        // The parameter is determined by determining the operating time from Kl 50 in seconds in which pFGS is in the
        // reduced visibility status and activated by the driver. / Die Kenngröße wird bestimmt, indem die Betriebszeit
        // ab Kl 50 in Sekunden ermittelt wird, in der pFGS im Status  reduzierte Sicht  und vom Fahrer aktiviert ist.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "FASTA_PPP_DATA", "STAT_PPP_DRIVEN_TIME_FS_ACT_WERT", STAT_PPP_DRIVEN_TIME_FS_ACT_WERT, "\"s\"");

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

    break;
  }

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

    unsigned short STAT_CCM_AMNT_BRAKE_20_WERT = (RXBUF_UINT(0));
        // The parameter is determined by counting the number of CCM brakes in which the speed of the host vehicle at the
        // start of braking is greater than or equal to 0 km / h and less than 20 km / h. / Die Kenngröße wird bestimmt,
        // indem die Anzahl der CCM-Bremsungen gezählt wird, bei denen die Geschwindigkeit des Egofahrzeugs zu
        // Bremsbeginn größer gleich 0 km/h und kleiner 20 km/h ist.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_CCM_DATA", "STAT_CCM_AMNT_BRAKE_20_WERT", STAT_CCM_AMNT_BRAKE_20_WERT, "\"Counts\"");

    unsigned short STAT_CCM_AMNT_BRAKE_40_WERT = (RXBUF_UINT(2));
        // The parameter is determined by counting the number of CCM brakes in which the speed of the host vehicle at the
        // start of braking is greater than or equal to 20 km / h and less than 40 km / h. / Die Kenngröße wird bestimmt,
        // indem die Anzahl der CCM-Bremsungen gezählt wird, bei denen die Geschwindigkeit des Egofahrzeugs zu
        // Bremsbeginn größer gleich 20 km/h und kleiner 40 km/h ist.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_CCM_DATA", "STAT_CCM_AMNT_BRAKE_40_WERT", STAT_CCM_AMNT_BRAKE_40_WERT, "\"Counts\"");

    unsigned short STAT_CCM_AMNT_BRAKE_GEQ40_WERT = (RXBUF_UINT(4));
        // The parameter is determined by counting the number of CCM brakes in which the speed of the host vehicle is
        // greater than or equal to 40 km / h at the beginning of the braking / Die Kenngröße wird bestimmt, indem die
        // Anzahl der CCM-Bremsungen gezählt wird, bei denen die Geschwindigkeit des Egofahrzeugs zu Bremsbeginn größer
        // gleich 40 km/h ist
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "FASTA_CCM_DATA", "STAT_CCM_AMNT_BRAKE_GEQ40_WERT", STAT_CCM_AMNT_BRAKE_GEQ40_WERT, "\"Counts\"");

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

    break;
  }

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

    unsigned long STAT_ENVINT_DRIVEN_DIST_FS_WERT = (RXBUF_UINT32(0));
        // Cont the number of km driven with degraded availability / Cont the number of km driven with degraded
        // availability
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_ENVINT_DATA", "STAT_ENVINT_DRIVEN_DIST_FS_WERT", STAT_ENVINT_DRIVEN_DIST_FS_WERT, "\"km\"");

    unsigned long STAT_ENVINT_DRIVEN_TIME_FS_WERT = (RXBUF_UINT32(4));
        // Count the time in seconds driven with degraded availability / Count the time in seconds driven with degraded
        // availability
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "_KAFAS_ENVINT_DATA", "STAT_ENVINT_DRIVEN_TIME_FS_WERT", STAT_ENVINT_DRIVEN_TIME_FS_WERT, "\"s\"");

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

    break;
  }

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

    unsigned char STAT_TYPE_OF_WARNING = (RXBUF_UCHAR(0));
        // 0x01 if only a Brake request according to 2) is triggered 0x02 if only an Acute warning request according to
        // 1) is triggered 0x03 if both an Acute warning request and a Brake request is triggered / 0x01 if only a Brake
        // request according to 2) is triggered 0x02 if only an Acute warning request according to 1)  is triggered 0x03
        // if both an Acute warning request and a Brake request is triggered
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "PPP_ANFORDERUNGEN", "STAT_TYPE_OF_WARNING", STAT_TYPE_OF_WARNING, "\"0-n\"");

    unsigned long STAT_TIMESTAMP_ACUTE_WERT = (RXBUF_UINT32(1));
        // The time stamp is the system time value (message 328h) when the warning happened / The time stamp is the
        // system time value (message 328h) when the warning happened
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "PPP_ANFORDERUNGEN", "STAT_TIMESTAMP_ACUTE_WERT", STAT_TIMESTAMP_ACUTE_WERT, "\"s\"");

    unsigned long STAT_TIMESTAMP_BRAKE_WERT = (RXBUF_UINT32(5));
        // The time stamp is the system time value (message 328h) when the warning happened. / The time stamp is the
        // system time value (message 328h) when the warning happened.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%lu%s\n", "KAF", "PPP_ANFORDERUNGEN", "STAT_TIMESTAMP_BRAKE_WERT", STAT_TIMESTAMP_BRAKE_WERT, "\"s\"");

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

    break;
  }

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

    unsigned char STAT_EYEQ2_RESTARTS_WERT = (RXBUF_UCHAR(0));
        // EyeQ2 restarts, 1 byte Counter for number of EyeQ2 restarts caused by camera error debouncing as described in
        // DTC 0x800ABB - Camera Connection Error / EyeQ2 restarts, 1 byte Counter for number of EyeQ2 restarts caused by
        // camera error  debouncing  as described in DTC 0x800ABB - Camera Connection Error
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_GENERIC_EYEQ2_INFO", "STAT_EYEQ2_RESTARTS_WERT", STAT_EYEQ2_RESTARTS_WERT, "\"Counts\"");

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

    break;
  }

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

    unsigned short STAT_FRAME_INDEX_WERT = (RXBUF_UINT(0));
        // This is a frame counter, that shall be increased for every frame that is not skipped. Frames that are skipped
        // for any reason shall not increment this counter. When the counter reaches over 65535, it shall restart from 0.
        // The counter shall restart from 0 at every startup of the EyeQ2. / This is a frame counter, that shall be
        // increased for every frame that is not skipped. Frames that are skipped for any reason shall not increment this
        // counter. When the counter reaches over 65535, it shall restart from 0. The counter shall restart from 0 at
        // every startup of the EyeQ2.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_STATUS_CAMERA_MONITORING_WERT", "STAT_FRAME_INDEX_WERT", STAT_FRAME_INDEX_WERT, "\"Counts\"");

    unsigned short STAT_VIDEO_ERROR_COUNT_WERT = (RXBUF_UINT(2));
        // The number of bad frames received from the camera (frames dropped due to data / sync errors). This counter
        // shall be increased with one for each cycle the video error signal is set in the 0x400 message. / The number of
        // bad frames received from the camera (frames dropped due to data/sync errors). This counter shall be increased
        // with one for each cycle the  Video error  signal is set in the 0x400 message.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_STATUS_CAMERA_MONITORING_WERT", "STAT_VIDEO_ERROR_COUNT_WERT", STAT_VIDEO_ERROR_COUNT_WERT, "\"Counts\"");

    unsigned short STAT_DROPPED_FRAME_COUNT_WERT = (RXBUF_UINT(4));
        // The number of dropped frames. This counter shall be increased when there is a video error and when the EyeQ2
        // skips a frame for any other reason, such as too long processing time for the preceding frame. / The number of
        // dropped frames. This counter shall be increased when there is a video error and when the EyeQ2 skips a frame
        // for any other reason, such as too long processing time for the preceding frame.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_STATUS_CAMERA_MONITORING_WERT", "STAT_DROPPED_FRAME_COUNT_WERT", STAT_DROPPED_FRAME_COUNT_WERT, "\"Counts\"");

    unsigned char STAT_CAMERA_TEMP_WERT = (RXBUF_UCHAR(6)-60.0);
        // The camera temperature, as read by the EyeQ2 via I2C. The camera temperature shall be read from the EyeQ2
        // every 10 seconds. / The camera temperature, as read by the EyeQ2 via I2C. The camera temperature shall be read
        // from the EyeQ2 every 10 seconds.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_STATUS_CAMERA_MONITORING_WERT", "STAT_CAMERA_TEMP_WERT", STAT_CAMERA_TEMP_WERT, "\"°C\"");

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

    break;
  }

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

    unsigned char STAT_FLA_ENTGEGENKOMMENDES_FAHRZEUG = (RXBUF_UCHAR(0));
        // Indicates whether an oncoming vehicle has been detected: 0 = no vehicle detected, 1 = vehicle detected / Gibt
        // aus, ob ein entgegenkommendes Fahrzeug erkannt worden ist:  0 = kein Fahrzeug erkannt,  1 = Fahrzeug erkannt
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ABSCHALTGRUND_FERNLICHT", "STAT_FLA_ENTGEGENKOMMENDES_FAHRZEUG", STAT_FLA_ENTGEGENKOMMENDES_FAHRZEUG, "\"0/1\"");

    unsigned char STAT_FLA_VORAUSFAHRENDES_FAHRZEUG = (RXBUF_UCHAR(1));
        // Indicates whether a vehicle in front has been detected: 0 = no vehicle detected, 1 = vehicle detected / Gibt
        // aus, ob ein vorausfahrendes Fahrzeug erkannt worden ist:  0 = kein Fahrzeug erkannt,  1 = Fahrzeug erkannt
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ABSCHALTGRUND_FERNLICHT", "STAT_FLA_VORAUSFAHRENDES_FAHRZEUG", STAT_FLA_VORAUSFAHRENDES_FAHRZEUG, "\"0/1\"");

    unsigned char STAT_FLA_GESCHWINDIGKEITSLIMIT = (RXBUF_UCHAR(2));
        // Indicates whether the speed below the limit has been detected: 0 = speed above the threshold, high beam is
        // switched on, 1 = speed below the threshold, high beam is switched off / Gibt aus, ob die Geschwindigkeit
        // unterhalb der Grenze erkannt worden ist:  0 = Geschwindigkeit oberhalb der Schwelle, Fernlicht wird
        // eingeschaltet,  1 = Geschwindigkeit unterhalb der Schwelle, Fernlicht wird abgeschaltet
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ABSCHALTGRUND_FERNLICHT", "STAT_FLA_GESCHWINDIGKEITSLIMIT", STAT_FLA_GESCHWINDIGKEITSLIMIT, "\"0/1\"");

    unsigned char STAT_FLA_UMGEBUNGSHELLIGKEIT = (RXBUF_UCHAR(3));
        // Indicates whether ambient brightness (day) has been recognized: 0 = no brightness (night) recognized, 1 =
        // brightness (day) recognized / Gibt aus, ob Umgebungshelligkeit (Tag) erkannt worden ist:  0 = kein Helligkeit
        // (Nacht) erkannt,  1 = Helligkeit (Tag) erkannt
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ABSCHALTGRUND_FERNLICHT", "STAT_FLA_UMGEBUNGSHELLIGKEIT", STAT_FLA_UMGEBUNGSHELLIGKEIT, "\"0/1\"");

    unsigned char STAT_FLA_ORTSCHAFTSERKENNUNG = (RXBUF_UCHAR(4));
        // Indicates whether sufficient lighting has been detected: 0 = insufficient lighting detected, 1 = sufficient
        // lighting detected / Gibt aus, ob eine ausreichende Beleuchtung erkannt worden ist:  0 = keine ausreichende
        // Beleuchtung erkannt,  1 = ausreichende Beleuchtung erkannt
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ABSCHALTGRUND_FERNLICHT", "STAT_FLA_ORTSCHAFTSERKENNUNG", STAT_FLA_ORTSCHAFTSERKENNUNG, "\"0/1\"");

    unsigned char STAT_FLA_NEBELERKENNUNG = (RXBUF_UCHAR(5));
        // Indicates whether fog has been detected: 0 = no fog, 1 = fog detected / Gibt aus, ob Nebel erkannt worden ist:
        // 0 = kein Nebel,  1 = Nebel erkannt
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ABSCHALTGRUND_FERNLICHT", "STAT_FLA_NEBELERKENNUNG", STAT_FLA_NEBELERKENNUNG, "\"0/1\"");

    unsigned char STAT_FLA_AUTOBAHNMODE = (RXBUF_UCHAR(6));
        // Indicates whether a motorway has been recognized: 0 = no motorway, 1 = motorway recognized / Gibt aus, ob
        // Autobahn erkannt worden ist:  0 = keine Autobahn,  1 = Autobahn erkannt
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ABSCHALTGRUND_FERNLICHT", "STAT_FLA_AUTOBAHNMODE", STAT_FLA_AUTOBAHNMODE, "\"0/1\"");

    unsigned char STAT_FLA_VERZOEGERUNGSZEIT = (RXBUF_UCHAR(7));
        // Indicates whether the high beam is not switched on due to a time delay: 0 = no time delay, 1 = time delay /
        // Gibt aus, ob wegen einer Zeiterzögerung das Fernlicht nicht eingeschaltet wird:  0 = keine Zeitverzögerung,  1
        // = Zeitverzögerung
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ABSCHALTGRUND_FERNLICHT", "STAT_FLA_VERZOEGERUNGSZEIT", STAT_FLA_VERZOEGERUNGSZEIT, "\"0/1\"");

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

    break;
  }

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

    unsigned char STAT_VORHANDEN_TLC = (RXBUF_UCHAR(0));
        // Indicates whether the time-to-line crossing function is available: 0 = not available; 1 = present / Gibt an,
        // ob die Funktion Time-to-Line Crossing vorhanden ist: 0= nicht vorhanden; 1= vorhanden
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "KONFIGURATION_KAFAS", "STAT_VORHANDEN_TLC", STAT_VORHANDEN_TLC, "\"0/1\"");

    unsigned char STAT_VORHANDEN_FLA = (RXBUF_UCHAR(1));
        // Indicates whether the high beam assistant function is available: 0 = not available; 1 = present / Gibt an, ob
        // die Funktion Fernlichtassistent vorhanden ist: 0= nicht vorhanden; 1= vorhanden
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "KONFIGURATION_KAFAS", "STAT_VORHANDEN_FLA", STAT_VORHANDEN_FLA, "\"0/1\"");

    unsigned char STAT_VORHANDEN_SLI = (RXBUF_UCHAR(2));
        // Indicates whether the Speed-Limit-Info function is available: 0 = not available; 1 = present / Gibt an, ob die
        // Funktion Speed-Limit-Info vorhanden ist: 0= nicht vorhanden; 1= vorhanden
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "KONFIGURATION_KAFAS", "STAT_VORHANDEN_SLI", STAT_VORHANDEN_SLI, "\"0/1\"");

    unsigned char STAT_VORHANDEN_NPI = (RXBUF_UCHAR(3));
        // Indicates whether the NoPassing-Info function is available: 0 = not available; 1 = present / Gibt an, ob die
        // Funktion NoPassing-Info vorhanden ist: 0= nicht vorhanden; 1= vorhanden
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "KONFIGURATION_KAFAS", "STAT_VORHANDEN_NPI", STAT_VORHANDEN_NPI, "\"0/1\"");

    unsigned char STAT_VORHANDEN_FCW = (RXBUF_UCHAR(4));
        // Indicates whether the Forward Collision Warning function is available: 0 = not available; 1 = present / Gibt
        // an, ob die Funktion Forward-Collision-Warning vorhanden ist: 0= nicht vorhanden; 1= vorhanden
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "KONFIGURATION_KAFAS", "STAT_VORHANDEN_FCW", STAT_VORHANDEN_FCW, "\"0/1\"");

    unsigned char STAT_VORHANDEN_PED = (RXBUF_UCHAR(5));
        // Indicates whether the Pedistrian Recognition function is available: 0 = not available; 1 = present / Gibt an,
        // ob die Funktion Pedistrian Recognition (Fußgängererkennung) vorhanden ist: 0= nicht vorhanden; 1= vorhanden
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "KONFIGURATION_KAFAS", "STAT_VORHANDEN_PED", STAT_VORHANDEN_PED, "\"0/1\"");

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

    break;
  }

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

    unsigned char STAT_KAFAS_VIN_STATUS_NR = (RXBUF_UCHAR(14));
        // Indicates whether the assignment of camera to control unit matches: 0x00: NO MATCH, 0x01: MATCH / Gibt aus, ob
        // die Zuordnung Kamera zu Steuergerät übereinstimmt:  0x00: KEINE UEBEREINSTIMMUNG,  0x01: UEBEREINSTIMMUNG
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "KAFAS_VINS_LESEN", "STAT_KAFAS_VIN_STATUS_NR", STAT_KAFAS_VIN_STATUS_NR, "\"0-n\"");

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

    break;
  }

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

    unsigned short STAT_OFFLINE_YAW_WERT = (RXBUF_UINT(0));
        // Offline yaw angle / Offline Yaw-Winkel
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KALIBRIERDATEN_KAFAS", "STAT_OFFLINE_YAW_WERT", STAT_OFFLINE_YAW_WERT, "\"Pixel\"");

    unsigned short STAT_OFFLINE_HORIZON_WERT = (RXBUF_UINT(2));
        // Offline horizon angle / Offline Horizon-Winkel
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KALIBRIERDATEN_KAFAS", "STAT_OFFLINE_HORIZON_WERT", STAT_OFFLINE_HORIZON_WERT, "\"Pixel\"");

    float STAT_OFFLINE_ROLL_WERT = (RXBUF_UINT(4)/100.0f);
        // Offline roll angle / Offline Roll-Winkel
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "KAF", "KALIBRIERDATEN_KAFAS", "STAT_OFFLINE_ROLL_WERT", STAT_OFFLINE_ROLL_WERT, "\"Grad\"");

    unsigned short STAT_ONLINE_YAW_WERT = (RXBUF_UINT(6));
        // Online yaw angle / Online Yaw-Winkel
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KALIBRIERDATEN_KAFAS", "STAT_ONLINE_YAW_WERT", STAT_ONLINE_YAW_WERT, "\"Pixel\"");

    unsigned short STAT_ONLINE_HORIZON_WERT = (RXBUF_UINT(8));
        // Online horizon angle / Online Horizon-Winkel
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KALIBRIERDATEN_KAFAS", "STAT_ONLINE_HORIZON_WERT", STAT_ONLINE_HORIZON_WERT, "\"Pixel\"");

    float STAT_ONLINE_ROLL_WERT = (RXBUF_UINT(10)/100.0f);
        // Online roll angle / Online Roll-Winkel
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "KAF", "KALIBRIERDATEN_KAFAS", "STAT_ONLINE_ROLL_WERT", STAT_ONLINE_ROLL_WERT, "\"Grad\"");

    unsigned short STAT_KAM_HOEHE_WERT = (RXBUF_UINT(12));
        // Camera installation height / Kamera-Verbauhöhe
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KALIBRIERDATEN_KAFAS", "STAT_KAM_HOEHE_WERT", STAT_KAM_HOEHE_WERT, "\"mm\"");

    unsigned short STAT_BRENNWEITE_WERT = (RXBUF_UINT(14));
        // Focal length / Brennweite
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KALIBRIERDATEN_KAFAS", "STAT_BRENNWEITE_WERT", STAT_BRENNWEITE_WERT, "\"Pixel\"");

    unsigned short STAT_GRABBING_SHIFT_WERT = (RXBUF_UINT(16));
        // Grabbing shift / Grabbing-Shift
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "KALIBRIERDATEN_KAFAS", "STAT_GRABBING_SHIFT_WERT", STAT_GRABBING_SHIFT_WERT, "\"Pixel\"");

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

    break;
  }

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

    unsigned char STAT_KAFAS_VERBINDUNG_KAM_NR = (RXBUF_UCHAR(0));
        // For values see TAB_KAM_VERBINDUNG / Werte siehe TAB_KAM_VERBINDUNG
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "KAMERAVERBINDUNG_ECU", "STAT_KAFAS_VERBINDUNG_KAM_NR", STAT_KAFAS_VERBINDUNG_KAM_NR, "\"0-n\"");

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

    break;
  }

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

    unsigned char STAT_KAMERA_ZEICHEN_NR = (RXBUF_UCHAR(0));
        // Indicates which character was recognized by the camera: Results see TAB_ZEICHEN_KAMERA / Gibt aus, welches
        // Zeichen von der Kamera erkannt wurde:  Results siehe TAB_ZEICHEN_KAMERA
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ERGEBNIS_SLI", "STAT_KAMERA_ZEICHEN_NR", STAT_KAMERA_ZEICHEN_NR, "\"0-n\"");

    unsigned char STAT_KAMERA_GESCHWINDIGKEIT_WERT = (RXBUF_UCHAR(1));
        // Indicates the speed that was recognized in the characters: 0 = cancellation of everything, 5 to 150 in steps
        // of 5. / Gibt aus, welche Geschwindigkeit in den Zeichen erkannt wurde: 0 = Aufhebung alles, 5 bis 150 in 5-er
        // Schritten.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ERGEBNIS_SLI", "STAT_KAMERA_GESCHWINDIGKEIT_WERT", STAT_KAMERA_GESCHWINDIGKEIT_WERT, "");

    unsigned char STAT_KARTE_ZEICHEN_NR = (RXBUF_UCHAR(2));
        // Indicates which character was read from the card: For results see TAB_ZEICHEN_KARTE / Gibt aus, welches
        // Zeichen aus der Karte gelesen wurde:  Results siehe TAB_ZEICHEN_KARTE
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ERGEBNIS_SLI", "STAT_KARTE_ZEICHEN_NR", STAT_KARTE_ZEICHEN_NR, "\"0-n\"");

    unsigned char STAT_KARTE_GESCHWINDIGKEIT_WERT = (RXBUF_UCHAR(3));
        // Indicates the speed that was read from the card: 0 = cancel everything, 5 to 150 in steps of 5. / Gibt aus,
        // welche Geschwindigkeit aus der Karte gelesen wurde: 0 = Aufhebung alles, 5 bis 150 in 5-er Schritten.
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ERGEBNIS_SLI", "STAT_KARTE_GESCHWINDIGKEIT_WERT", STAT_KARTE_GESCHWINDIGKEIT_WERT, "");

    unsigned char STAT_FUSIONIERT_ZEICHEN_NR = (RXBUF_UCHAR(4));
        // Indicates which character is output from the merged recognition result: Results see TAB_ZEICHEN_FUSIONIERT /
        // Gibt aus, welches Zeichen aus den fusioniertem Erkennungsergebnis ausgegeben wird: Results siehe
        // TAB_ZEICHEN_FUSIONIERT
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ERGEBNIS_SLI", "STAT_FUSIONIERT_ZEICHEN_NR", STAT_FUSIONIERT_ZEICHEN_NR, "\"0-n\"");

    unsigned char STAT_FUSIONIERT_GESCHWINDIGKEIT_WERT = (RXBUF_UCHAR(5));
        // Outputs the speed from the merged recognition result: 0 = cancel everything, 5 to 150 in steps of 5 / Gibt
        // aus, welche Geschwindigkeit aus dem fusionierten Erkennungsergebnis ausgegeben wird: 0 = Aufhebung alles, 5
        // bis 150 in 5-er Schritten
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ERGEBNIS_SLI", "STAT_FUSIONIERT_GESCHWINDIGKEIT_WERT", STAT_FUSIONIERT_GESCHWINDIGKEIT_WERT, "");

    unsigned char STAT_GUETE_KAM_SLI_GESCHW_WERT = (RXBUF_UCHAR(6));
        // Indicates the quality with which the restriction and cancellation sign for speeds was recognized with the
        // camera: 0 - 100 / Gibt aus, mit welcher Güte das Beschränkungs- und Aufhebungszeichen für Geschwindigkeiten
        // mit der Kamera erkannt wurde: 0 - 100
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "ERGEBNIS_SLI", "STAT_GUETE_KAM_SLI_GESCHW_WERT", STAT_GUETE_KAM_SLI_GESCHW_WERT, "\"%\"");

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

    break;
  }

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

    float STAT_SPANNUNG_KLEMME_15N_WERT = (RXBUF_UINT(0)/10.0f);
        // Voltage value on the control unit at terminal 15N (accurate to one decimal place) / Spannungswert am
        // Steuergerät an Klemme 15N (auf eine Nachkommastelle genau)
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%.4f%s\n", "KAF", "SPANNUNG_KLEMME_15N_WERT", "STAT_SPANNUNG_KLEMME_15N_WERT", STAT_SPANNUNG_KLEMME_15N_WERT, "\"V\"");

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

    break;
  }

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

    unsigned short STAT_DEBUG_AUSGABE = (RXBUF_UINT(0));
        // Returns the status of whether the debug message output is active / Liefert den Status ob die Ausgabe der
        // Debug-Nachrichten aktiv ist
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_DEBUG_AUSGABE", "STAT_DEBUG_AUSGABE", STAT_DEBUG_AUSGABE, "\"0-n\"");

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

    break;
  }

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

    unsigned char STAT_PEDANTIC_MODE = (RXBUF_UCHAR(0));
        // Activation status of Pedantic Mode for SLI and NPI / Aktivierungsstatus des Pedantic Mode für SLI und NPI
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%x%s\n", "KAF", "_PEDANTIC_MODE", "STAT_PEDANTIC_MODE", STAT_PEDANTIC_MODE, "\"0-n\"");

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

    break;
  }

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

    unsigned short STAT_ERASE_RESULT = (RXBUF_UINT(0));
        // Deletion result / Löschergebnis
    ESP_LOGD(TAG, "From ECU %s, pid %s: got %s=%u%s\n", "KAF", "_ERASE_MICRO_CORE_DUMP", "STAT_ERASE_RESULT", STAT_ERASE_RESULT, "\"0-n\"");

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

    break;
  }