// Generator version : v3.1
// DBC filename      : CCU.dbc
#include "candb.h"


// DBC file version
#if (VER_CANDB_MAJ != (0U)) || (VER_CANDB_MIN != (0U))
#error The CANDB dbc source files have different versions
#endif

#ifdef CANDB_USE_DIAG_MONITORS
// Function prototypes to be called each time CAN frame is unpacked
// FMon function may detect RC, CRC or DLC violation
#include "candb-fmon.h"

#endif // CANDB_USE_DIAG_MONITORS

// This macro guard for the case when you need to enable
// using diag monitors but there is no necessity in proper
// SysTick provider. For providing one you need define macro
// before this line - in dbccodeconf.h

#ifndef GetSystemTick
#define GetSystemTick() (0u)
#endif

// This macro guard is for the case when you want to build
// app with enabled optoin auto CSM, but don't yet have
// proper getframehash implementation

#ifndef GetFrameHash
#define GetFrameHash(a,b,c,d,e) (0u)
#endif

// This function performs extension of sign for the signals
// whose bit width value is not aligned to one of power of 2 or less than 8.
// The types 'bitext_t' and 'ubitext_t' define the biggest bit width which
// can be correctly handled. You need to select type which can contain
// n+1 bits where n is the largest signed signal width. For example if
// the most wide signed signal has a width of 31 bits you need to set
// bitext_t as int32_t and ubitext_t as uint32_t
// Defined these typedefs in @dbccodeconf.h or locally in 'dbcdrvname'-config.h
static bitext_t __ext_sig__(ubitext_t val, uint8_t bits)
{
  ubitext_t const m = (ubitext_t) (1u << (bits - 1u));
  return ((val ^ m) - m);
}

uint32_t Unpack_ESC_04_candb(ESC_04_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->ESC_VehicleSpeed_ro = (uint16_t) ( ((_d[1] & (0xFFU)) << 8U) | (_d[0] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->ESC_VehicleSpeed_phys = (sigfloat_t)(CANDB_ESC_VehicleSpeed_ro_fromS(_m->ESC_VehicleSpeed_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->ESC_VehicleSpeed_ValueError = (uint8_t) ( (_d[2] & (0x01U)) );
  _m->ESC_04_RC = (uint8_t) ( ((_d[6] >> 4U) & (0x0FU)) );
  _m->ESC_04_CS = (uint8_t) ( (_d[7] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < ESC_04_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_ESC_04_candb(&_m->mon1, ESC_04_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return ESC_04_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_ESC_04_candb(ESC_04_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(ESC_04_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->ESC_VehicleSpeed_ro = (uint16_t) CANDB_ESC_VehicleSpeed_ro_toS(_m->ESC_VehicleSpeed_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->ESC_VehicleSpeed_ro & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->ESC_VehicleSpeed_ro >> 8U) & (0xFFU)) );
  cframe->Data[2] |= (uint8_t) ( (_m->ESC_VehicleSpeed_ValueError & (0x01U)) );
  cframe->Data[6] |= (uint8_t) ( ((_m->ESC_04_RC & (0x0FU)) << 4U) );
  cframe->Data[7] |= (uint8_t) ( (_m->ESC_04_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) ESC_04_CANID;
  cframe->DLC = (uint8_t) ESC_04_DLC;
  cframe->IDE = (uint8_t) ESC_04_IDE;
  return ESC_04_CANID;
}

#else

uint32_t Pack_ESC_04_candb(ESC_04_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(ESC_04_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->ESC_VehicleSpeed_ro = (uint16_t) CANDB_ESC_VehicleSpeed_ro_toS(_m->ESC_VehicleSpeed_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->ESC_VehicleSpeed_ro & (0xFFU)) );
  _d[1] |= (uint8_t) ( ((_m->ESC_VehicleSpeed_ro >> 8U) & (0xFFU)) );
  _d[2] |= (uint8_t) ( (_m->ESC_VehicleSpeed_ValueError & (0x01U)) );
  _d[6] |= (uint8_t) ( ((_m->ESC_04_RC & (0x0FU)) << 4U) );
  _d[7] |= (uint8_t) ( (_m->ESC_04_CS & (0xFFU)) );

  *_len = (uint8_t) ESC_04_DLC;
  *_ide = (uint8_t) ESC_04_IDE;
  return ESC_04_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_EMS_Veh_candb(EMS_Veh_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->EMS_nICEngineSpeed3_Val_ro = (uint16_t) ( ((_d[1] & (0xFFU)) << 8U) | (_d[0] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->EMS_nICEngineSpeed3_Val_phys = (sigfloat_t)(CANDB_EMS_nICEngineSpeed3_Val_ro_fromS(_m->EMS_nICEngineSpeed3_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->EMS_EngCoolTemp_Val_ro = (uint8_t) ( (_d[2] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->EMS_EngCoolTemp_Val_phys = (int16_t) CANDB_EMS_EngCoolTemp_Val_ro_fromS(_m->EMS_EngCoolTemp_Val_ro);
#endif // CANDB_USE_SIGFLOAT

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < EMS_Veh_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_EMS_Veh_candb(&_m->mon1, EMS_Veh_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return EMS_Veh_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_EMS_Veh_candb(EMS_Veh_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(EMS_Veh_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->EMS_nICEngineSpeed3_Val_ro = (uint16_t) CANDB_EMS_nICEngineSpeed3_Val_ro_toS(_m->EMS_nICEngineSpeed3_Val_phys);
  _m->EMS_EngCoolTemp_Val_ro = (uint8_t) CANDB_EMS_EngCoolTemp_Val_ro_toS(_m->EMS_EngCoolTemp_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->EMS_nICEngineSpeed3_Val_ro & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->EMS_nICEngineSpeed3_Val_ro >> 8U) & (0xFFU)) );
  cframe->Data[2] |= (uint8_t) ( (_m->EMS_EngCoolTemp_Val_ro & (0xFFU)) );

  cframe->MsgId = (uint32_t) EMS_Veh_CANID;
  cframe->DLC = (uint8_t) EMS_Veh_DLC;
  cframe->IDE = (uint8_t) EMS_Veh_IDE;
  return EMS_Veh_CANID;
}

#else

uint32_t Pack_EMS_Veh_candb(EMS_Veh_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(EMS_Veh_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->EMS_nICEngineSpeed3_Val_ro = (uint16_t) CANDB_EMS_nICEngineSpeed3_Val_ro_toS(_m->EMS_nICEngineSpeed3_Val_phys);
  _m->EMS_EngCoolTemp_Val_ro = (uint8_t) CANDB_EMS_EngCoolTemp_Val_ro_toS(_m->EMS_EngCoolTemp_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->EMS_nICEngineSpeed3_Val_ro & (0xFFU)) );
  _d[1] |= (uint8_t) ( ((_m->EMS_nICEngineSpeed3_Val_ro >> 8U) & (0xFFU)) );
  _d[2] |= (uint8_t) ( (_m->EMS_EngCoolTemp_Val_ro & (0xFFU)) );

  *_len = (uint8_t) EMS_Veh_DLC;
  *_ide = (uint8_t) EMS_Veh_IDE;
  return EMS_Veh_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_BCM_Powertrain_candb(BCM_Powertrain_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->BCM_AmbTempRaw_ro = (uint16_t) ( ((_d[1] & (0xFFU)) << 8U) | (_d[0] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->BCM_AmbTempRaw_phys = (sigfloat_t)(CANDB_BCM_AmbTempRaw_ro_fromS(_m->BCM_AmbTempRaw_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->BCM_Powertrain_RC = (uint8_t) ( (_d[4] & (0x0FU)) );
  _m->BCM_Powertrain_CS = (uint8_t) ( (_d[5] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < BCM_Powertrain_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_BCM_Powertrain_candb(&_m->mon1, BCM_Powertrain_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return BCM_Powertrain_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_BCM_Powertrain_candb(BCM_Powertrain_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(BCM_Powertrain_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->BCM_AmbTempRaw_ro = (uint16_t) CANDB_BCM_AmbTempRaw_ro_toS(_m->BCM_AmbTempRaw_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->BCM_AmbTempRaw_ro & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->BCM_AmbTempRaw_ro >> 8U) & (0xFFU)) );
  cframe->Data[4] |= (uint8_t) ( (_m->BCM_Powertrain_RC & (0x0FU)) );
  cframe->Data[5] |= (uint8_t) ( (_m->BCM_Powertrain_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) BCM_Powertrain_CANID;
  cframe->DLC = (uint8_t) BCM_Powertrain_DLC;
  cframe->IDE = (uint8_t) BCM_Powertrain_IDE;
  return BCM_Powertrain_CANID;
}

#else

uint32_t Pack_BCM_Powertrain_candb(BCM_Powertrain_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(BCM_Powertrain_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->BCM_AmbTempRaw_ro = (uint16_t) CANDB_BCM_AmbTempRaw_ro_toS(_m->BCM_AmbTempRaw_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->BCM_AmbTempRaw_ro & (0xFFU)) );
  _d[1] |= (uint8_t) ( ((_m->BCM_AmbTempRaw_ro >> 8U) & (0xFFU)) );
  _d[4] |= (uint8_t) ( (_m->BCM_Powertrain_RC & (0x0FU)) );
  _d[5] |= (uint8_t) ( (_m->BCM_Powertrain_CS & (0xFFU)) );

  *_len = (uint8_t) BCM_Powertrain_DLC;
  *_ide = (uint8_t) BCM_Powertrain_IDE;
  return BCM_Powertrain_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_EMS_Veh_02_candb(EMS_Veh_02_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->BMS_ActualTemp_Val_ro = (uint8_t) ( ((_d[1] & (0x07U)) << 5U) | ((_d[0] >> 3U) & (0x1FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->BMS_ActualTemp_Val_phys = (sigfloat_t)(CANDB_BMS_ActualTemp_Val_ro_fromS(_m->BMS_ActualTemp_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->EMS_Veh_02_RC = (uint8_t) ( ((_d[1] >> 4U) & (0x0FU)) );
  _m->EMS_Veh_02_CS = (uint8_t) ( (_d[2] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < EMS_Veh_02_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_EMS_Veh_02_candb(&_m->mon1, EMS_Veh_02_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return EMS_Veh_02_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_EMS_Veh_02_candb(EMS_Veh_02_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(EMS_Veh_02_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->BMS_ActualTemp_Val_ro = (uint8_t) CANDB_BMS_ActualTemp_Val_ro_toS(_m->BMS_ActualTemp_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( ((_m->BMS_ActualTemp_Val_ro & (0x1FU)) << 3U) );
  cframe->Data[1] |= (uint8_t) ( ((_m->BMS_ActualTemp_Val_ro >> 5U) & (0x07U)) | ((_m->EMS_Veh_02_RC & (0x0FU)) << 4U) );
  cframe->Data[2] |= (uint8_t) ( (_m->EMS_Veh_02_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) EMS_Veh_02_CANID;
  cframe->DLC = (uint8_t) EMS_Veh_02_DLC;
  cframe->IDE = (uint8_t) EMS_Veh_02_IDE;
  return EMS_Veh_02_CANID;
}

#else

uint32_t Pack_EMS_Veh_02_candb(EMS_Veh_02_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(EMS_Veh_02_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->BMS_ActualTemp_Val_ro = (uint8_t) CANDB_BMS_ActualTemp_Val_ro_toS(_m->BMS_ActualTemp_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( ((_m->BMS_ActualTemp_Val_ro & (0x1FU)) << 3U) );
  _d[1] |= (uint8_t) ( ((_m->BMS_ActualTemp_Val_ro >> 5U) & (0x07U)) | ((_m->EMS_Veh_02_RC & (0x0FU)) << 4U) );
  _d[2] |= (uint8_t) ( (_m->EMS_Veh_02_CS & (0xFFU)) );

  *_len = (uint8_t) EMS_Veh_02_DLC;
  *_ide = (uint8_t) EMS_Veh_02_IDE;
  return EMS_Veh_02_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_BCM_EEM_candb(BCM_EEM_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->BCM_EEM_StPowMgn = (uint8_t) ( ((_d[1] >> 2U) & (0x07U)) );
  _m->BCM_EEM_RC = (uint8_t) ( ((_d[3] >> 4U) & (0x0FU)) );
  _m->BCM_EEM_CS = (uint8_t) ( (_d[4] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < BCM_EEM_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_BCM_EEM_candb(&_m->mon1, BCM_EEM_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return BCM_EEM_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_BCM_EEM_candb(BCM_EEM_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(BCM_EEM_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[1] |= (uint8_t) ( ((_m->BCM_EEM_StPowMgn & (0x07U)) << 2U) );
  cframe->Data[3] |= (uint8_t) ( ((_m->BCM_EEM_RC & (0x0FU)) << 4U) );
  cframe->Data[4] |= (uint8_t) ( (_m->BCM_EEM_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) BCM_EEM_CANID;
  cframe->DLC = (uint8_t) BCM_EEM_DLC;
  cframe->IDE = (uint8_t) BCM_EEM_IDE;
  return BCM_EEM_CANID;
}

#else

uint32_t Pack_BCM_EEM_candb(BCM_EEM_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(BCM_EEM_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[1] |= (uint8_t) ( ((_m->BCM_EEM_StPowMgn & (0x07U)) << 2U) );
  _d[3] |= (uint8_t) ( ((_m->BCM_EEM_RC & (0x0FU)) << 4U) );
  _d[4] |= (uint8_t) ( (_m->BCM_EEM_CS & (0xFFU)) );

  *_len = (uint8_t) BCM_EEM_DLC;
  *_ide = (uint8_t) BCM_EEM_IDE;
  return BCM_EEM_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_DMFR_Msg1_candb(DMFR_Msg1_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->DMFR_MirrorHeating_Status = (uint8_t) ( ((_d[0] >> 5U) & (0x03U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < DMFR_Msg1_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_DMFR_Msg1_candb(&_m->mon1, DMFR_Msg1_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return DMFR_Msg1_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_DMFR_Msg1_candb(DMFR_Msg1_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(DMFR_Msg1_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( ((_m->DMFR_MirrorHeating_Status & (0x03U)) << 5U) );

  cframe->MsgId = (uint32_t) DMFR_Msg1_CANID;
  cframe->DLC = (uint8_t) DMFR_Msg1_DLC;
  cframe->IDE = (uint8_t) DMFR_Msg1_IDE;
  return DMFR_Msg1_CANID;
}

#else

uint32_t Pack_DMFR_Msg1_candb(DMFR_Msg1_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(DMFR_Msg1_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( ((_m->DMFR_MirrorHeating_Status & (0x03U)) << 5U) );

  *_len = (uint8_t) DMFR_Msg1_DLC;
  *_ide = (uint8_t) DMFR_Msg1_IDE;
  return DMFR_Msg1_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_DMFL_Msg1_candb(DMFL_Msg1_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->DMFL_MirrorHeating_Status = (uint8_t) ( (_d[1] & (0x03U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < DMFL_Msg1_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_DMFL_Msg1_candb(&_m->mon1, DMFL_Msg1_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return DMFL_Msg1_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_DMFL_Msg1_candb(DMFL_Msg1_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(DMFL_Msg1_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[1] |= (uint8_t) ( (_m->DMFL_MirrorHeating_Status & (0x03U)) );

  cframe->MsgId = (uint32_t) DMFL_Msg1_CANID;
  cframe->DLC = (uint8_t) DMFL_Msg1_DLC;
  cframe->IDE = (uint8_t) DMFL_Msg1_IDE;
  return DMFL_Msg1_CANID;
}

#else

uint32_t Pack_DMFL_Msg1_candb(DMFL_Msg1_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(DMFL_Msg1_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[1] |= (uint8_t) ( (_m->DMFL_MirrorHeating_Status & (0x03U)) );

  *_len = (uint8_t) DMFL_Msg1_DLC;
  *_ide = (uint8_t) DMFL_Msg1_IDE;
  return DMFL_Msg1_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_TM_Stat_candb(TM_Stat_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->TM_RearWindowHeating_Stat = (uint8_t) ( (_d[0] & (0x01U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < TM_Stat_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_TM_Stat_candb(&_m->mon1, TM_Stat_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return TM_Stat_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_TM_Stat_candb(TM_Stat_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(TM_Stat_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( (_m->TM_RearWindowHeating_Stat & (0x01U)) );

  cframe->MsgId = (uint32_t) TM_Stat_CANID;
  cframe->DLC = (uint8_t) TM_Stat_DLC;
  cframe->IDE = (uint8_t) TM_Stat_IDE;
  return TM_Stat_CANID;
}

#else

uint32_t Pack_TM_Stat_candb(TM_Stat_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(TM_Stat_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( (_m->TM_RearWindowHeating_Stat & (0x01U)) );

  *_len = (uint8_t) TM_Stat_DLC;
  *_ide = (uint8_t) TM_Stat_IDE;
  return TM_Stat_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_TM_CP_candb(TM_CP_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->CCPF_AutoButtonR_Stat = (uint8_t) ( (_d[2] & (0x03U)) );
  _m->CCPR_AutoButtonL_Stat = (uint8_t) ( ((_d[2] >> 2U) & (0x03U)) );
  _m->CCPR_AutoButtonR_Stat = (uint8_t) ( ((_d[2] >> 4U) & (0x03U)) );
  _m->CCPF_DefButton_Stat = (uint8_t) ( ((_d[2] >> 6U) & (0x03U)) );
  _m->CCPF_TempToggleR_Stat = (uint8_t) ( (_d[3] & (0x07U)) );
  _m->CCPF_TempToggleL_Stat = (uint8_t) ( ((_d[3] >> 3U) & (0x07U)) );
  _m->CCPF_AutoButtonL_Stat = (uint8_t) ( ((_d[3] >> 6U) & (0x03U)) );
  _m->CCPR_TempToggleR_Stat = (uint8_t) ( (_d[4] & (0x07U)) );
  _m->CCPR_TempToggleL_Stat = (uint8_t) ( ((_d[4] >> 3U) & (0x07U)) );
  _m->CCPF_RecButton_Stat = (uint8_t) ( ((_d[4] >> 6U) & (0x03U)) );
  _m->CCPF_AcMaxButton_Stat = (uint8_t) ( (_d[5] & (0x03U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < TM_CP_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_TM_CP_candb(&_m->mon1, TM_CP_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return TM_CP_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_TM_CP_candb(TM_CP_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(TM_CP_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[2] |= (uint8_t) ( (_m->CCPF_AutoButtonR_Stat & (0x03U)) | ((_m->CCPR_AutoButtonL_Stat & (0x03U)) << 2U) | ((_m->CCPR_AutoButtonR_Stat & (0x03U)) << 4U) | ((_m->CCPF_DefButton_Stat & (0x03U)) << 6U) );
  cframe->Data[3] |= (uint8_t) ( (_m->CCPF_TempToggleR_Stat & (0x07U)) | ((_m->CCPF_TempToggleL_Stat & (0x07U)) << 3U) | ((_m->CCPF_AutoButtonL_Stat & (0x03U)) << 6U) );
  cframe->Data[4] |= (uint8_t) ( (_m->CCPR_TempToggleR_Stat & (0x07U)) | ((_m->CCPR_TempToggleL_Stat & (0x07U)) << 3U) | ((_m->CCPF_RecButton_Stat & (0x03U)) << 6U) );
  cframe->Data[5] |= (uint8_t) ( (_m->CCPF_AcMaxButton_Stat & (0x03U)) );

  cframe->MsgId = (uint32_t) TM_CP_CANID;
  cframe->DLC = (uint8_t) TM_CP_DLC;
  cframe->IDE = (uint8_t) TM_CP_IDE;
  return TM_CP_CANID;
}

#else

uint32_t Pack_TM_CP_candb(TM_CP_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(TM_CP_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[2] |= (uint8_t) ( (_m->CCPF_AutoButtonR_Stat & (0x03U)) | ((_m->CCPR_AutoButtonL_Stat & (0x03U)) << 2U) | ((_m->CCPR_AutoButtonR_Stat & (0x03U)) << 4U) | ((_m->CCPF_DefButton_Stat & (0x03U)) << 6U) );
  _d[3] |= (uint8_t) ( (_m->CCPF_TempToggleR_Stat & (0x07U)) | ((_m->CCPF_TempToggleL_Stat & (0x07U)) << 3U) | ((_m->CCPF_AutoButtonL_Stat & (0x03U)) << 6U) );
  _d[4] |= (uint8_t) ( (_m->CCPR_TempToggleR_Stat & (0x07U)) | ((_m->CCPR_TempToggleL_Stat & (0x07U)) << 3U) | ((_m->CCPF_RecButton_Stat & (0x03U)) << 6U) );
  _d[5] |= (uint8_t) ( (_m->CCPF_AcMaxButton_Stat & (0x03U)) );

  *_len = (uint8_t) TM_CP_DLC;
  *_ide = (uint8_t) TM_CP_IDE;
  return TM_CP_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_HVC_CCU_Status_Msg_candb(HVC_CCU_Status_Msg_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->HVC_eCompActSpeed_Val_ro = (uint8_t) ( (_d[0] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_eCompActSpeed_Val_phys = (uint16_t) CANDB_HVC_eCompActSpeed_Val_ro_fromS(_m->HVC_eCompActSpeed_Val_ro);
#endif // CANDB_USE_SIGFLOAT

  _m->HVC_eComp_Stat = (uint8_t) ( (_d[1] & (0x07U)) );
  _m->HVC_CCU_Status_RC = (uint8_t) ( ((_d[1] >> 4U) & (0x0FU)) );
  _m->HVC_CCU_Status_CS = (uint8_t) ( (_d[2] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < HVC_CCU_Status_Msg_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_HVC_CCU_Status_Msg_candb(&_m->mon1, HVC_CCU_Status_Msg_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return HVC_CCU_Status_Msg_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_HVC_CCU_Status_Msg_candb(HVC_CCU_Status_Msg_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(HVC_CCU_Status_Msg_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_eCompActSpeed_Val_ro = (uint8_t) CANDB_HVC_eCompActSpeed_Val_ro_toS(_m->HVC_eCompActSpeed_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->HVC_eCompActSpeed_Val_ro & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( (_m->HVC_eComp_Stat & (0x07U)) | ((_m->HVC_CCU_Status_RC & (0x0FU)) << 4U) );
  cframe->Data[2] |= (uint8_t) ( (_m->HVC_CCU_Status_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) HVC_CCU_Status_Msg_CANID;
  cframe->DLC = (uint8_t) HVC_CCU_Status_Msg_DLC;
  cframe->IDE = (uint8_t) HVC_CCU_Status_Msg_IDE;
  return HVC_CCU_Status_Msg_CANID;
}

#else

uint32_t Pack_HVC_CCU_Status_Msg_candb(HVC_CCU_Status_Msg_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(HVC_CCU_Status_Msg_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_eCompActSpeed_Val_ro = (uint8_t) CANDB_HVC_eCompActSpeed_Val_ro_toS(_m->HVC_eCompActSpeed_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->HVC_eCompActSpeed_Val_ro & (0xFFU)) );
  _d[1] |= (uint8_t) ( (_m->HVC_eComp_Stat & (0x07U)) | ((_m->HVC_CCU_Status_RC & (0x0FU)) << 4U) );
  _d[2] |= (uint8_t) ( (_m->HVC_CCU_Status_CS & (0xFFU)) );

  *_len = (uint8_t) HVC_CCU_Status_Msg_DLC;
  *_ide = (uint8_t) HVC_CCU_Status_Msg_IDE;
  return HVC_CCU_Status_Msg_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_BCM_VEH_STATE_candb(BCM_VEH_STATE_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->BCM_T15_Stat = (uint8_t) ( (_d[0] & (0x01U)) );
  _m->BCM_T30d_Stat = (uint8_t) ( ((_d[0] >> 1U) & (0x01U)) );
  _m->BCM_T30i_Stat = (uint8_t) ( ((_d[0] >> 2U) & (0x01U)) );
  _m->StealthModeEn = (uint8_t) ( ((_d[0] >> 6U) & (0x01U)) );
  _m->BCM_CCTerm_Stat = (uint8_t) ( ((_d[1] >> 5U) & (0x01U)) );
  _m->BCM_T30i_DisableWarning = (uint8_t) ( ((_d[1] >> 6U) & (0x01U)) );
  _m->BCM_T30d_DisableWarning = (uint8_t) ( (_d[3] & (0x01U)) );
  _m->BCM_IndFadingTime_Req_ro = (uint8_t) ( ((_d[3] >> 2U) & (0x1FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->BCM_IndFadingTime_Req_phys = (sigfloat_t)(CANDB_BCM_IndFadingTime_Req_ro_fromS(_m->BCM_IndFadingTime_Req_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->BCM_CCTermDisableWarning = (uint8_t) ( ((_d[3] >> 7U) & (0x01U)) );
  _m->BCM_VehicleMode_Stat = (uint8_t) ( (_d[6] & (0x0FU)) );
  _m->BCM_SwIndIntens_Stat = (uint8_t) ( ((_d[6] >> 4U) & (0x01U)) );
  _m->BCM_Vehicle_DrvMode = (uint8_t) ( ((_d[6] >> 5U) & (0x07U)) );
  _m->BCM_LVBatteryVoltage_ro = (uint8_t) ( (_d[7] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->BCM_LVBatteryVoltage_phys = (sigfloat_t)(CANDB_BCM_LVBatteryVoltage_ro_fromS(_m->BCM_LVBatteryVoltage_ro));
#endif // CANDB_USE_SIGFLOAT

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < BCM_VEH_STATE_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_BCM_VEH_STATE_candb(&_m->mon1, BCM_VEH_STATE_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return BCM_VEH_STATE_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_BCM_VEH_STATE_candb(BCM_VEH_STATE_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(BCM_VEH_STATE_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->BCM_IndFadingTime_Req_ro = (uint8_t) CANDB_BCM_IndFadingTime_Req_ro_toS(_m->BCM_IndFadingTime_Req_phys);
  _m->BCM_LVBatteryVoltage_ro = (uint8_t) CANDB_BCM_LVBatteryVoltage_ro_toS(_m->BCM_LVBatteryVoltage_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->BCM_T15_Stat & (0x01U)) | ((_m->BCM_T30d_Stat & (0x01U)) << 1U) | ((_m->BCM_T30i_Stat & (0x01U)) << 2U) | ((_m->StealthModeEn & (0x01U)) << 6U) );
  cframe->Data[1] |= (uint8_t) ( ((_m->BCM_CCTerm_Stat & (0x01U)) << 5U) | ((_m->BCM_T30i_DisableWarning & (0x01U)) << 6U) );
  cframe->Data[3] |= (uint8_t) ( (_m->BCM_T30d_DisableWarning & (0x01U)) | ((_m->BCM_IndFadingTime_Req_ro & (0x1FU)) << 2U) | ((_m->BCM_CCTermDisableWarning & (0x01U)) << 7U) );
  cframe->Data[6] |= (uint8_t) ( (_m->BCM_VehicleMode_Stat & (0x0FU)) | ((_m->BCM_SwIndIntens_Stat & (0x01U)) << 4U) | ((_m->BCM_Vehicle_DrvMode & (0x07U)) << 5U) );
  cframe->Data[7] |= (uint8_t) ( (_m->BCM_LVBatteryVoltage_ro & (0xFFU)) );

  cframe->MsgId = (uint32_t) BCM_VEH_STATE_CANID;
  cframe->DLC = (uint8_t) BCM_VEH_STATE_DLC;
  cframe->IDE = (uint8_t) BCM_VEH_STATE_IDE;
  return BCM_VEH_STATE_CANID;
}

#else

uint32_t Pack_BCM_VEH_STATE_candb(BCM_VEH_STATE_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(BCM_VEH_STATE_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->BCM_IndFadingTime_Req_ro = (uint8_t) CANDB_BCM_IndFadingTime_Req_ro_toS(_m->BCM_IndFadingTime_Req_phys);
  _m->BCM_LVBatteryVoltage_ro = (uint8_t) CANDB_BCM_LVBatteryVoltage_ro_toS(_m->BCM_LVBatteryVoltage_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->BCM_T15_Stat & (0x01U)) | ((_m->BCM_T30d_Stat & (0x01U)) << 1U) | ((_m->BCM_T30i_Stat & (0x01U)) << 2U) | ((_m->StealthModeEn & (0x01U)) << 6U) );
  _d[1] |= (uint8_t) ( ((_m->BCM_CCTerm_Stat & (0x01U)) << 5U) | ((_m->BCM_T30i_DisableWarning & (0x01U)) << 6U) );
  _d[3] |= (uint8_t) ( (_m->BCM_T30d_DisableWarning & (0x01U)) | ((_m->BCM_IndFadingTime_Req_ro & (0x1FU)) << 2U) | ((_m->BCM_CCTermDisableWarning & (0x01U)) << 7U) );
  _d[6] |= (uint8_t) ( (_m->BCM_VehicleMode_Stat & (0x0FU)) | ((_m->BCM_SwIndIntens_Stat & (0x01U)) << 4U) | ((_m->BCM_Vehicle_DrvMode & (0x07U)) << 5U) );
  _d[7] |= (uint8_t) ( (_m->BCM_LVBatteryVoltage_ro & (0xFFU)) );

  *_len = (uint8_t) BCM_VEH_STATE_DLC;
  *_ide = (uint8_t) BCM_VEH_STATE_IDE;
  return BCM_VEH_STATE_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_EMS_HVC_Req_Msg_candb(EMS_HVC_Req_Msg_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->EMS_eCompChiller_Req = (uint8_t) ( ((_d[0] >> 2U) & (0x01U)) );
  _m->EMS_HVC_Req_RC = (uint8_t) ( ((_d[1] >> 4U) & (0x0FU)) );
  _m->EMS_HVC_Req_CS = (uint8_t) ( (_d[2] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < EMS_HVC_Req_Msg_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_EMS_HVC_Req_Msg_candb(&_m->mon1, EMS_HVC_Req_Msg_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return EMS_HVC_Req_Msg_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_EMS_HVC_Req_Msg_candb(EMS_HVC_Req_Msg_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(EMS_HVC_Req_Msg_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( ((_m->EMS_eCompChiller_Req & (0x01U)) << 2U) );
  cframe->Data[1] |= (uint8_t) ( ((_m->EMS_HVC_Req_RC & (0x0FU)) << 4U) );
  cframe->Data[2] |= (uint8_t) ( (_m->EMS_HVC_Req_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) EMS_HVC_Req_Msg_CANID;
  cframe->DLC = (uint8_t) EMS_HVC_Req_Msg_DLC;
  cframe->IDE = (uint8_t) EMS_HVC_Req_Msg_IDE;
  return EMS_HVC_Req_Msg_CANID;
}

#else

uint32_t Pack_EMS_HVC_Req_Msg_candb(EMS_HVC_Req_Msg_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(EMS_HVC_Req_Msg_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( ((_m->EMS_eCompChiller_Req & (0x01U)) << 2U) );
  _d[1] |= (uint8_t) ( ((_m->EMS_HVC_Req_RC & (0x0FU)) << 4U) );
  _d[2] |= (uint8_t) ( (_m->EMS_HVC_Req_CS & (0xFFU)) );

  *_len = (uint8_t) EMS_HVC_Req_Msg_DLC;
  *_ide = (uint8_t) EMS_HVC_Req_Msg_IDE;
  return EMS_HVC_Req_Msg_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_HVC_Err_Status_Msg_candb(HVC_Err_Status_Msg_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->HVC_CompSpeed_Val_ro = (uint8_t) ( (_d[0] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_CompSpeed_Val_phys = (uint16_t) CANDB_HVC_CompSpeed_Val_ro_fromS(_m->HVC_CompSpeed_Val_ro);
#endif // CANDB_USE_SIGFLOAT

  _m->HVC_Comp_Stat = (uint8_t) ( (_d[1] & (0x03U)) );
  _m->HVC_Reserved01 = (uint8_t) ( ((_d[1] >> 2U) & (0x3FU)) );
  _m->HVC_CompInputV_Val_ro = (uint8_t) ( (_d[2] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_CompInputV_Val_phys = (uint16_t) CANDB_HVC_CompInputV_Val_ro_fromS(_m->HVC_CompInputV_Val_ro);
#endif // CANDB_USE_SIGFLOAT

  _m->HVC_CompInputC_Val_ro = (uint8_t) ( (_d[3] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_CompInputC_Val_phys = (sigfloat_t)(CANDB_HVC_CompInputC_Val_ro_fromS(_m->HVC_CompInputC_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->HVC_CompInvTemp_Val_ro = (uint8_t) ( (_d[4] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_CompInvTemp_Val_phys = (int16_t) CANDB_HVC_CompInvTemp_Val_ro_fromS(_m->HVC_CompInvTemp_Val_ro);
#endif // CANDB_USE_SIGFLOAT

  _m->HVC_CompPhaseC_Val_ro = (uint8_t) ( (_d[5] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_CompPhaseC_Val_phys = (sigfloat_t)(CANDB_HVC_CompPhaseC_Val_ro_fromS(_m->HVC_CompPhaseC_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->HVC_CompUV_Stat = (uint8_t) ( (_d[6] & (0x01U)) );
  _m->HVC_CompOV_Stat = (uint8_t) ( ((_d[6] >> 1U) & (0x01U)) );
  _m->HVC_CompOvHeat_Stat = (uint8_t) ( ((_d[6] >> 2U) & (0x01U)) );
  _m->HVC_CompOvTorque_Stat = (uint8_t) ( ((_d[6] >> 3U) & (0x01U)) );
  _m->HVC_CompLowVoltErr_Stat = (uint8_t) ( ((_d[6] >> 4U) & (0x01U)) );
  _m->HVC_CompComErr_Stat = (uint8_t) ( ((_d[6] >> 5U) & (0x01U)) );
  _m->HVC_Reserved02 = (uint8_t) ( ((_d[6] >> 6U) & (0x03U)) );
  _m->HVC_CompTempSensErr_Stat = (uint8_t) ( (_d[7] & (0x01U)) );
  _m->HVC_CompCurrSensErr_Stat = (uint8_t) ( ((_d[7] >> 1U) & (0x01U)) );
  _m->HVC_CompCurrShortCirc_Stat = (uint8_t) ( ((_d[7] >> 2U) & (0x01U)) );
  _m->HVC_CompInPowSupply_Stat = (uint8_t) ( ((_d[7] >> 3U) & (0x01U)) );
  _m->HVC_CompTorqueStallErr_Stat = (uint8_t) ( ((_d[7] >> 4U) & (0x01U)) );
  _m->HVC_CompVoltSensErr_Stat = (uint8_t) ( ((_d[7] >> 5U) & (0x01U)) );
  _m->HVC_Reserved03 = (uint8_t) ( ((_d[7] >> 6U) & (0x03U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < HVC_Err_Status_Msg_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_HVC_Err_Status_Msg_candb(&_m->mon1, HVC_Err_Status_Msg_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return HVC_Err_Status_Msg_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_HVC_Err_Status_Msg_candb(HVC_Err_Status_Msg_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(HVC_Err_Status_Msg_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_CompSpeed_Val_ro = (uint8_t) CANDB_HVC_CompSpeed_Val_ro_toS(_m->HVC_CompSpeed_Val_phys);
  _m->HVC_CompInputV_Val_ro = (uint8_t) CANDB_HVC_CompInputV_Val_ro_toS(_m->HVC_CompInputV_Val_phys);
  _m->HVC_CompInputC_Val_ro = (uint8_t) CANDB_HVC_CompInputC_Val_ro_toS(_m->HVC_CompInputC_Val_phys);
  _m->HVC_CompInvTemp_Val_ro = (uint8_t) CANDB_HVC_CompInvTemp_Val_ro_toS(_m->HVC_CompInvTemp_Val_phys);
  _m->HVC_CompPhaseC_Val_ro = (uint8_t) CANDB_HVC_CompPhaseC_Val_ro_toS(_m->HVC_CompPhaseC_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->HVC_CompSpeed_Val_ro & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( (_m->HVC_Comp_Stat & (0x03U)) | ((_m->HVC_Reserved01 & (0x3FU)) << 2U) );
  cframe->Data[2] |= (uint8_t) ( (_m->HVC_CompInputV_Val_ro & (0xFFU)) );
  cframe->Data[3] |= (uint8_t) ( (_m->HVC_CompInputC_Val_ro & (0xFFU)) );
  cframe->Data[4] |= (uint8_t) ( (_m->HVC_CompInvTemp_Val_ro & (0xFFU)) );
  cframe->Data[5] |= (uint8_t) ( (_m->HVC_CompPhaseC_Val_ro & (0xFFU)) );
  cframe->Data[6] |= (uint8_t) ( (_m->HVC_CompUV_Stat & (0x01U)) | ((_m->HVC_CompOV_Stat & (0x01U)) << 1U) | ((_m->HVC_CompOvHeat_Stat & (0x01U)) << 2U) | ((_m->HVC_CompOvTorque_Stat & (0x01U)) << 3U) | ((_m->HVC_CompLowVoltErr_Stat & (0x01U)) << 4U) | ((_m->HVC_CompComErr_Stat & (0x01U)) << 5U) | ((_m->HVC_Reserved02 & (0x03U)) << 6U) );
  cframe->Data[7] |= (uint8_t) ( (_m->HVC_CompTempSensErr_Stat & (0x01U)) | ((_m->HVC_CompCurrSensErr_Stat & (0x01U)) << 1U) | ((_m->HVC_CompCurrShortCirc_Stat & (0x01U)) << 2U) | ((_m->HVC_CompInPowSupply_Stat & (0x01U)) << 3U) | ((_m->HVC_CompTorqueStallErr_Stat & (0x01U)) << 4U) | ((_m->HVC_CompVoltSensErr_Stat & (0x01U)) << 5U) | ((_m->HVC_Reserved03 & (0x03U)) << 6U) );

  cframe->MsgId = (uint32_t) HVC_Err_Status_Msg_CANID;
  cframe->DLC = (uint8_t) HVC_Err_Status_Msg_DLC;
  cframe->IDE = (uint8_t) HVC_Err_Status_Msg_IDE;
  return HVC_Err_Status_Msg_CANID;
}

#else

uint32_t Pack_HVC_Err_Status_Msg_candb(HVC_Err_Status_Msg_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(HVC_Err_Status_Msg_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_CompSpeed_Val_ro = (uint8_t) CANDB_HVC_CompSpeed_Val_ro_toS(_m->HVC_CompSpeed_Val_phys);
  _m->HVC_CompInputV_Val_ro = (uint8_t) CANDB_HVC_CompInputV_Val_ro_toS(_m->HVC_CompInputV_Val_phys);
  _m->HVC_CompInputC_Val_ro = (uint8_t) CANDB_HVC_CompInputC_Val_ro_toS(_m->HVC_CompInputC_Val_phys);
  _m->HVC_CompInvTemp_Val_ro = (uint8_t) CANDB_HVC_CompInvTemp_Val_ro_toS(_m->HVC_CompInvTemp_Val_phys);
  _m->HVC_CompPhaseC_Val_ro = (uint8_t) CANDB_HVC_CompPhaseC_Val_ro_toS(_m->HVC_CompPhaseC_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->HVC_CompSpeed_Val_ro & (0xFFU)) );
  _d[1] |= (uint8_t) ( (_m->HVC_Comp_Stat & (0x03U)) | ((_m->HVC_Reserved01 & (0x3FU)) << 2U) );
  _d[2] |= (uint8_t) ( (_m->HVC_CompInputV_Val_ro & (0xFFU)) );
  _d[3] |= (uint8_t) ( (_m->HVC_CompInputC_Val_ro & (0xFFU)) );
  _d[4] |= (uint8_t) ( (_m->HVC_CompInvTemp_Val_ro & (0xFFU)) );
  _d[5] |= (uint8_t) ( (_m->HVC_CompPhaseC_Val_ro & (0xFFU)) );
  _d[6] |= (uint8_t) ( (_m->HVC_CompUV_Stat & (0x01U)) | ((_m->HVC_CompOV_Stat & (0x01U)) << 1U) | ((_m->HVC_CompOvHeat_Stat & (0x01U)) << 2U) | ((_m->HVC_CompOvTorque_Stat & (0x01U)) << 3U) | ((_m->HVC_CompLowVoltErr_Stat & (0x01U)) << 4U) | ((_m->HVC_CompComErr_Stat & (0x01U)) << 5U) | ((_m->HVC_Reserved02 & (0x03U)) << 6U) );
  _d[7] |= (uint8_t) ( (_m->HVC_CompTempSensErr_Stat & (0x01U)) | ((_m->HVC_CompCurrSensErr_Stat & (0x01U)) << 1U) | ((_m->HVC_CompCurrShortCirc_Stat & (0x01U)) << 2U) | ((_m->HVC_CompInPowSupply_Stat & (0x01U)) << 3U) | ((_m->HVC_CompTorqueStallErr_Stat & (0x01U)) << 4U) | ((_m->HVC_CompVoltSensErr_Stat & (0x01U)) << 5U) | ((_m->HVC_Reserved03 & (0x03U)) << 6U) );

  *_len = (uint8_t) HVC_Err_Status_Msg_DLC;
  *_ide = (uint8_t) HVC_Err_Status_Msg_IDE;
  return HVC_Err_Status_Msg_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_CCU_HVC_Req_Msg_candb(CCU_HVC_Req_Msg_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->CCU_eCompSpeedReq_Val_ro = (uint8_t) ( (_d[0] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_eCompSpeedReq_Val_phys = (uint16_t) CANDB_CCU_eCompSpeedReq_Val_ro_fromS(_m->CCU_eCompSpeedReq_Val_ro);
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_eCompReq_Stat = (uint8_t) ( (_d[1] & (0x01U)) );
  _m->CCU_LowTempValve_Req = (uint8_t) ( ((_d[1] >> 1U) & (0x03U)) );
  _m->CCU_HVC_Req_RC = (uint8_t) ( ((_d[1] >> 4U) & (0x0FU)) );
  _m->CCU_HVC_Req_CS = (uint8_t) ( (_d[2] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < CCU_HVC_Req_Msg_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_CCU_HVC_Req_Msg_candb(&_m->mon1, CCU_HVC_Req_Msg_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return CCU_HVC_Req_Msg_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_CCU_HVC_Req_Msg_candb(CCU_HVC_Req_Msg_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_HVC_Req_Msg_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_eCompSpeedReq_Val_ro = (uint8_t) CANDB_CCU_eCompSpeedReq_Val_ro_toS(_m->CCU_eCompSpeedReq_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->CCU_eCompSpeedReq_Val_ro & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( (_m->CCU_eCompReq_Stat & (0x01U)) | ((_m->CCU_LowTempValve_Req & (0x03U)) << 1U) | ((_m->CCU_HVC_Req_RC & (0x0FU)) << 4U) );
  cframe->Data[2] |= (uint8_t) ( (_m->CCU_HVC_Req_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) CCU_HVC_Req_Msg_CANID;
  cframe->DLC = (uint8_t) CCU_HVC_Req_Msg_DLC;
  cframe->IDE = (uint8_t) CCU_HVC_Req_Msg_IDE;
  return CCU_HVC_Req_Msg_CANID;
}

#else

uint32_t Pack_CCU_HVC_Req_Msg_candb(CCU_HVC_Req_Msg_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_HVC_Req_Msg_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_eCompSpeedReq_Val_ro = (uint8_t) CANDB_CCU_eCompSpeedReq_Val_ro_toS(_m->CCU_eCompSpeedReq_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->CCU_eCompSpeedReq_Val_ro & (0xFFU)) );
  _d[1] |= (uint8_t) ( (_m->CCU_eCompReq_Stat & (0x01U)) | ((_m->CCU_LowTempValve_Req & (0x03U)) << 1U) | ((_m->CCU_HVC_Req_RC & (0x0FU)) << 4U) );
  _d[2] |= (uint8_t) ( (_m->CCU_HVC_Req_CS & (0xFFU)) );

  *_len = (uint8_t) CCU_HVC_Req_Msg_DLC;
  *_ide = (uint8_t) CCU_HVC_Req_Msg_IDE;
  return CCU_HVC_Req_Msg_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_CCU_Stat1_candb(CCU_Stat1_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->CCU_ModeFL_Stat = (uint8_t) ( (_d[0] & (0x03U)) );
  _m->CCU_ModeFR_Stat = (uint8_t) ( ((_d[0] >> 2U) & (0x03U)) );
  _m->CCU_ModeRL_Stat = (uint8_t) ( ((_d[0] >> 4U) & (0x03U)) );
  _m->CCU_ModeRR_Stat = (uint8_t) ( ((_d[0] >> 6U) & (0x03U)) );
  _m->CCU_AutoModeFL_Stat = (uint8_t) ( (_d[1] & (0x07U)) );
  _m->CCU_AutoModeFR_Stat = (uint8_t) ( ((_d[1] >> 3U) & (0x07U)) );
  _m->CCU_AirDirectionRL_Face_Stat = (uint8_t) ( ((_d[1] >> 6U) & (0x01U)) );
  _m->CCU_AirDirectionRL_Foot_Stat = (uint8_t) ( ((_d[1] >> 7U) & (0x01U)) );
  _m->CCU_AutoModeRL_Stat = (uint8_t) ( (_d[2] & (0x07U)) );
  _m->CCU_AutoModeRR_Stat = (uint8_t) ( ((_d[2] >> 3U) & (0x07U)) );
  _m->CCU_AirDirectionRR_Face_Stat = (uint8_t) ( ((_d[2] >> 6U) & (0x01U)) );
  _m->CCU_AirDirectionRR_Foot_Stat = (uint8_t) ( ((_d[2] >> 7U) & (0x01U)) );
  _m->CCU_AirDirectionFL_Def_Stat = (uint8_t) ( (_d[3] & (0x01U)) );
  _m->CCU_AirDirectionFL_Face_Stat = (uint8_t) ( ((_d[3] >> 1U) & (0x01U)) );
  _m->CCU_AirDirectionFL_Foot_Stat = (uint8_t) ( ((_d[3] >> 2U) & (0x01U)) );
  _m->CCU_AirDirectionFR_Def_Stat = (uint8_t) ( ((_d[3] >> 3U) & (0x01U)) );
  _m->CCU_AirDirectionFR_Face_Stat = (uint8_t) ( ((_d[3] >> 4U) & (0x01U)) );
  _m->CCU_AirDirectionFR_Foot_Stat = (uint8_t) ( ((_d[3] >> 5U) & (0x01U)) );
  _m->CCU_Recirculation_Stat = (uint8_t) ( ((_d[3] >> 6U) & (0x03U)) );
  _m->CCU_BlowerSpeedFL_Stat = (uint8_t) ( (_d[4] & (0x07U)) );
  _m->CCU_TargetTempFL_Stat_ro = (uint8_t) ( ((_d[4] >> 3U) & (0x1FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_TargetTempFL_Stat_phys = (sigfloat_t)(CANDB_CCU_TargetTempFL_Stat_ro_fromS(_m->CCU_TargetTempFL_Stat_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_BlowerSpeedFR_Stat = (uint8_t) ( (_d[5] & (0x07U)) );
  _m->CCU_TargetTempFR_Stat_ro = (uint8_t) ( ((_d[5] >> 3U) & (0x1FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_TargetTempFR_Stat_phys = (sigfloat_t)(CANDB_CCU_TargetTempFR_Stat_ro_fromS(_m->CCU_TargetTempFR_Stat_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_BlowerSpeedRL_Stat = (uint8_t) ( (_d[6] & (0x07U)) );
  _m->CCU_TargetTempRR_Stat_ro = (uint8_t) ( ((_d[6] >> 3U) & (0x1FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_TargetTempRR_Stat_phys = (sigfloat_t)(CANDB_CCU_TargetTempRR_Stat_ro_fromS(_m->CCU_TargetTempRR_Stat_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_BlowerSpeedRR_Stat = (uint8_t) ( (_d[7] & (0x07U)) );
  _m->CCU_TargetTempRL_Stat_ro = (uint8_t) ( ((_d[7] >> 3U) & (0x1FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_TargetTempRL_Stat_phys = (sigfloat_t)(CANDB_CCU_TargetTempRL_Stat_ro_fromS(_m->CCU_TargetTempRL_Stat_ro));
#endif // CANDB_USE_SIGFLOAT

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < CCU_Stat1_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_CCU_Stat1_candb(&_m->mon1, CCU_Stat1_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return CCU_Stat1_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_CCU_Stat1_candb(CCU_Stat1_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Stat1_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_TargetTempFL_Stat_ro = (uint8_t) CANDB_CCU_TargetTempFL_Stat_ro_toS(_m->CCU_TargetTempFL_Stat_phys);
  _m->CCU_TargetTempFR_Stat_ro = (uint8_t) CANDB_CCU_TargetTempFR_Stat_ro_toS(_m->CCU_TargetTempFR_Stat_phys);
  _m->CCU_TargetTempRR_Stat_ro = (uint8_t) CANDB_CCU_TargetTempRR_Stat_ro_toS(_m->CCU_TargetTempRR_Stat_phys);
  _m->CCU_TargetTempRL_Stat_ro = (uint8_t) CANDB_CCU_TargetTempRL_Stat_ro_toS(_m->CCU_TargetTempRL_Stat_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->CCU_ModeFL_Stat & (0x03U)) | ((_m->CCU_ModeFR_Stat & (0x03U)) << 2U) | ((_m->CCU_ModeRL_Stat & (0x03U)) << 4U) | ((_m->CCU_ModeRR_Stat & (0x03U)) << 6U) );
  cframe->Data[1] |= (uint8_t) ( (_m->CCU_AutoModeFL_Stat & (0x07U)) | ((_m->CCU_AutoModeFR_Stat & (0x07U)) << 3U) | ((_m->CCU_AirDirectionRL_Face_Stat & (0x01U)) << 6U) | ((_m->CCU_AirDirectionRL_Foot_Stat & (0x01U)) << 7U) );
  cframe->Data[2] |= (uint8_t) ( (_m->CCU_AutoModeRL_Stat & (0x07U)) | ((_m->CCU_AutoModeRR_Stat & (0x07U)) << 3U) | ((_m->CCU_AirDirectionRR_Face_Stat & (0x01U)) << 6U) | ((_m->CCU_AirDirectionRR_Foot_Stat & (0x01U)) << 7U) );
  cframe->Data[3] |= (uint8_t) ( (_m->CCU_AirDirectionFL_Def_Stat & (0x01U)) | ((_m->CCU_AirDirectionFL_Face_Stat & (0x01U)) << 1U) | ((_m->CCU_AirDirectionFL_Foot_Stat & (0x01U)) << 2U) | ((_m->CCU_AirDirectionFR_Def_Stat & (0x01U)) << 3U) | ((_m->CCU_AirDirectionFR_Face_Stat & (0x01U)) << 4U) | ((_m->CCU_AirDirectionFR_Foot_Stat & (0x01U)) << 5U) | ((_m->CCU_Recirculation_Stat & (0x03U)) << 6U) );
  cframe->Data[4] |= (uint8_t) ( (_m->CCU_BlowerSpeedFL_Stat & (0x07U)) | ((_m->CCU_TargetTempFL_Stat_ro & (0x1FU)) << 3U) );
  cframe->Data[5] |= (uint8_t) ( (_m->CCU_BlowerSpeedFR_Stat & (0x07U)) | ((_m->CCU_TargetTempFR_Stat_ro & (0x1FU)) << 3U) );
  cframe->Data[6] |= (uint8_t) ( (_m->CCU_BlowerSpeedRL_Stat & (0x07U)) | ((_m->CCU_TargetTempRR_Stat_ro & (0x1FU)) << 3U) );
  cframe->Data[7] |= (uint8_t) ( (_m->CCU_BlowerSpeedRR_Stat & (0x07U)) | ((_m->CCU_TargetTempRL_Stat_ro & (0x1FU)) << 3U) );

  cframe->MsgId = (uint32_t) CCU_Stat1_CANID;
  cframe->DLC = (uint8_t) CCU_Stat1_DLC;
  cframe->IDE = (uint8_t) CCU_Stat1_IDE;
  return CCU_Stat1_CANID;
}

#else

uint32_t Pack_CCU_Stat1_candb(CCU_Stat1_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Stat1_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_TargetTempFL_Stat_ro = (uint8_t) CANDB_CCU_TargetTempFL_Stat_ro_toS(_m->CCU_TargetTempFL_Stat_phys);
  _m->CCU_TargetTempFR_Stat_ro = (uint8_t) CANDB_CCU_TargetTempFR_Stat_ro_toS(_m->CCU_TargetTempFR_Stat_phys);
  _m->CCU_TargetTempRR_Stat_ro = (uint8_t) CANDB_CCU_TargetTempRR_Stat_ro_toS(_m->CCU_TargetTempRR_Stat_phys);
  _m->CCU_TargetTempRL_Stat_ro = (uint8_t) CANDB_CCU_TargetTempRL_Stat_ro_toS(_m->CCU_TargetTempRL_Stat_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->CCU_ModeFL_Stat & (0x03U)) | ((_m->CCU_ModeFR_Stat & (0x03U)) << 2U) | ((_m->CCU_ModeRL_Stat & (0x03U)) << 4U) | ((_m->CCU_ModeRR_Stat & (0x03U)) << 6U) );
  _d[1] |= (uint8_t) ( (_m->CCU_AutoModeFL_Stat & (0x07U)) | ((_m->CCU_AutoModeFR_Stat & (0x07U)) << 3U) | ((_m->CCU_AirDirectionRL_Face_Stat & (0x01U)) << 6U) | ((_m->CCU_AirDirectionRL_Foot_Stat & (0x01U)) << 7U) );
  _d[2] |= (uint8_t) ( (_m->CCU_AutoModeRL_Stat & (0x07U)) | ((_m->CCU_AutoModeRR_Stat & (0x07U)) << 3U) | ((_m->CCU_AirDirectionRR_Face_Stat & (0x01U)) << 6U) | ((_m->CCU_AirDirectionRR_Foot_Stat & (0x01U)) << 7U) );
  _d[3] |= (uint8_t) ( (_m->CCU_AirDirectionFL_Def_Stat & (0x01U)) | ((_m->CCU_AirDirectionFL_Face_Stat & (0x01U)) << 1U) | ((_m->CCU_AirDirectionFL_Foot_Stat & (0x01U)) << 2U) | ((_m->CCU_AirDirectionFR_Def_Stat & (0x01U)) << 3U) | ((_m->CCU_AirDirectionFR_Face_Stat & (0x01U)) << 4U) | ((_m->CCU_AirDirectionFR_Foot_Stat & (0x01U)) << 5U) | ((_m->CCU_Recirculation_Stat & (0x03U)) << 6U) );
  _d[4] |= (uint8_t) ( (_m->CCU_BlowerSpeedFL_Stat & (0x07U)) | ((_m->CCU_TargetTempFL_Stat_ro & (0x1FU)) << 3U) );
  _d[5] |= (uint8_t) ( (_m->CCU_BlowerSpeedFR_Stat & (0x07U)) | ((_m->CCU_TargetTempFR_Stat_ro & (0x1FU)) << 3U) );
  _d[6] |= (uint8_t) ( (_m->CCU_BlowerSpeedRL_Stat & (0x07U)) | ((_m->CCU_TargetTempRR_Stat_ro & (0x1FU)) << 3U) );
  _d[7] |= (uint8_t) ( (_m->CCU_BlowerSpeedRR_Stat & (0x07U)) | ((_m->CCU_TargetTempRL_Stat_ro & (0x1FU)) << 3U) );

  *_len = (uint8_t) CCU_Stat1_DLC;
  *_ide = (uint8_t) CCU_Stat1_IDE;
  return CCU_Stat1_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_CCU_Stat2_candb(CCU_Stat2_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->CCU_AromaCartridgeSw_Stat = (uint8_t) ( (_d[0] & (0x01U)) );
  _m->CCU_FrontZoneSync_Stat = (uint8_t) ( ((_d[0] >> 3U) & (0x01U)) );
  _m->CCU_RearZoneSync_Stat = (uint8_t) ( ((_d[0] >> 4U) & (0x01U)) );
  _m->CCU_AllZoneSync_Stat = (uint8_t) ( ((_d[0] >> 5U) & (0x01U)) );
  _m->CCU_ACfront_Stat = (uint8_t) ( ((_d[0] >> 6U) & (0x01U)) );
  _m->CCU_ACrear_Stat = (uint8_t) ( ((_d[0] >> 7U) & (0x01U)) );
  _m->CCU_ACmaxF_Stat = (uint8_t) ( (_d[1] & (0x01U)) );
  _m->CCU_ACmaxR_Stat = (uint8_t) ( ((_d[1] >> 1U) & (0x01U)) );
  _m->CCU_Defrost_Stat = (uint8_t) ( ((_d[1] >> 2U) & (0x01U)) );
  _m->CCU_Ionization_Stat = (uint8_t) ( ((_d[1] >> 3U) & (0x01U)) );
  _m->CCU_FootTempCorFL_Stat = (uint8_t) ( (_d[2] & (0x07U)) );
  _m->CCU_FootTempCorFR_Stat = (uint8_t) ( ((_d[2] >> 3U) & (0x07U)) );
  _m->CCU_AromaIntens_Stat = (uint8_t) ( ((_d[2] >> 6U) & (0x03U)) );
  _m->CCU_FootTempCorRL_Stat = (uint8_t) ( (_d[3] & (0x07U)) );
  _m->CCU_FootTempCorRR_Stat = (uint8_t) ( ((_d[3] >> 3U) & (0x07U)) );
  _m->CCU_DeflectorSwDL_Stat = (uint8_t) ( (_d[4] & (0x03U)) );
  _m->CCU_DeflectorSwDR_Stat = (uint8_t) ( ((_d[4] >> 2U) & (0x03U)) );
  _m->CCU_DeflectorSwFPL_Stat = (uint8_t) ( ((_d[4] >> 4U) & (0x03U)) );
  _m->CCU_DeflectorSwFPR_Stat = (uint8_t) ( ((_d[4] >> 6U) & (0x03U)) );
  _m->CCU_DeflectorSwFCL_Stat = (uint8_t) ( (_d[5] & (0x03U)) );
  _m->CCU_DeflectorSwFCR_Stat = (uint8_t) ( ((_d[5] >> 2U) & (0x03U)) );
  _m->CCU_DeflectorSwRLB_Stat = (uint8_t) ( ((_d[5] >> 4U) & (0x03U)) );
  _m->CCU_DeflectorSwRRB_Stat = (uint8_t) ( ((_d[5] >> 6U) & (0x03U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < CCU_Stat2_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_CCU_Stat2_candb(&_m->mon1, CCU_Stat2_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return CCU_Stat2_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_CCU_Stat2_candb(CCU_Stat2_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Stat2_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( (_m->CCU_AromaCartridgeSw_Stat & (0x01U)) | ((_m->CCU_FrontZoneSync_Stat & (0x01U)) << 3U) | ((_m->CCU_RearZoneSync_Stat & (0x01U)) << 4U) | ((_m->CCU_AllZoneSync_Stat & (0x01U)) << 5U) | ((_m->CCU_ACfront_Stat & (0x01U)) << 6U) | ((_m->CCU_ACrear_Stat & (0x01U)) << 7U) );
  cframe->Data[1] |= (uint8_t) ( (_m->CCU_ACmaxF_Stat & (0x01U)) | ((_m->CCU_ACmaxR_Stat & (0x01U)) << 1U) | ((_m->CCU_Defrost_Stat & (0x01U)) << 2U) | ((_m->CCU_Ionization_Stat & (0x01U)) << 3U) );
  cframe->Data[2] |= (uint8_t) ( (_m->CCU_FootTempCorFL_Stat & (0x07U)) | ((_m->CCU_FootTempCorFR_Stat & (0x07U)) << 3U) | ((_m->CCU_AromaIntens_Stat & (0x03U)) << 6U) );
  cframe->Data[3] |= (uint8_t) ( (_m->CCU_FootTempCorRL_Stat & (0x07U)) | ((_m->CCU_FootTempCorRR_Stat & (0x07U)) << 3U) );
  cframe->Data[4] |= (uint8_t) ( (_m->CCU_DeflectorSwDL_Stat & (0x03U)) | ((_m->CCU_DeflectorSwDR_Stat & (0x03U)) << 2U) | ((_m->CCU_DeflectorSwFPL_Stat & (0x03U)) << 4U) | ((_m->CCU_DeflectorSwFPR_Stat & (0x03U)) << 6U) );
  cframe->Data[5] |= (uint8_t) ( (_m->CCU_DeflectorSwFCL_Stat & (0x03U)) | ((_m->CCU_DeflectorSwFCR_Stat & (0x03U)) << 2U) | ((_m->CCU_DeflectorSwRLB_Stat & (0x03U)) << 4U) | ((_m->CCU_DeflectorSwRRB_Stat & (0x03U)) << 6U) );

  cframe->MsgId = (uint32_t) CCU_Stat2_CANID;
  cframe->DLC = (uint8_t) CCU_Stat2_DLC;
  cframe->IDE = (uint8_t) CCU_Stat2_IDE;
  return CCU_Stat2_CANID;
}

#else

uint32_t Pack_CCU_Stat2_candb(CCU_Stat2_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Stat2_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( (_m->CCU_AromaCartridgeSw_Stat & (0x01U)) | ((_m->CCU_FrontZoneSync_Stat & (0x01U)) << 3U) | ((_m->CCU_RearZoneSync_Stat & (0x01U)) << 4U) | ((_m->CCU_AllZoneSync_Stat & (0x01U)) << 5U) | ((_m->CCU_ACfront_Stat & (0x01U)) << 6U) | ((_m->CCU_ACrear_Stat & (0x01U)) << 7U) );
  _d[1] |= (uint8_t) ( (_m->CCU_ACmaxF_Stat & (0x01U)) | ((_m->CCU_ACmaxR_Stat & (0x01U)) << 1U) | ((_m->CCU_Defrost_Stat & (0x01U)) << 2U) | ((_m->CCU_Ionization_Stat & (0x01U)) << 3U) );
  _d[2] |= (uint8_t) ( (_m->CCU_FootTempCorFL_Stat & (0x07U)) | ((_m->CCU_FootTempCorFR_Stat & (0x07U)) << 3U) | ((_m->CCU_AromaIntens_Stat & (0x03U)) << 6U) );
  _d[3] |= (uint8_t) ( (_m->CCU_FootTempCorRL_Stat & (0x07U)) | ((_m->CCU_FootTempCorRR_Stat & (0x07U)) << 3U) );
  _d[4] |= (uint8_t) ( (_m->CCU_DeflectorSwDL_Stat & (0x03U)) | ((_m->CCU_DeflectorSwDR_Stat & (0x03U)) << 2U) | ((_m->CCU_DeflectorSwFPL_Stat & (0x03U)) << 4U) | ((_m->CCU_DeflectorSwFPR_Stat & (0x03U)) << 6U) );
  _d[5] |= (uint8_t) ( (_m->CCU_DeflectorSwFCL_Stat & (0x03U)) | ((_m->CCU_DeflectorSwFCR_Stat & (0x03U)) << 2U) | ((_m->CCU_DeflectorSwRLB_Stat & (0x03U)) << 4U) | ((_m->CCU_DeflectorSwRRB_Stat & (0x03U)) << 6U) );

  *_len = (uint8_t) CCU_Stat2_DLC;
  *_ide = (uint8_t) CCU_Stat2_IDE;
  return CCU_Stat2_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_CCU_Requests_candb(CCU_Requests_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->CCU_CarpetHeatFL_Req = (uint8_t) ( (_d[0] & (0x01U)) );
  _m->CCU_CarpetHeatFR_Req = (uint8_t) ( ((_d[0] >> 1U) & (0x01U)) );
  _m->CCU_CarpetHeatRL_Req = (uint8_t) ( ((_d[0] >> 2U) & (0x01U)) );
  _m->CCU_CarpetHeatRR_Req = (uint8_t) ( ((_d[0] >> 3U) & (0x01U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < CCU_Requests_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_CCU_Requests_candb(&_m->mon1, CCU_Requests_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return CCU_Requests_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_CCU_Requests_candb(CCU_Requests_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Requests_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( (_m->CCU_CarpetHeatFL_Req & (0x01U)) | ((_m->CCU_CarpetHeatFR_Req & (0x01U)) << 1U) | ((_m->CCU_CarpetHeatRL_Req & (0x01U)) << 2U) | ((_m->CCU_CarpetHeatRR_Req & (0x01U)) << 3U) );

  cframe->MsgId = (uint32_t) CCU_Requests_CANID;
  cframe->DLC = (uint8_t) CCU_Requests_DLC;
  cframe->IDE = (uint8_t) CCU_Requests_IDE;
  return CCU_Requests_CANID;
}

#else

uint32_t Pack_CCU_Requests_candb(CCU_Requests_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Requests_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( (_m->CCU_CarpetHeatFL_Req & (0x01U)) | ((_m->CCU_CarpetHeatFR_Req & (0x01U)) << 1U) | ((_m->CCU_CarpetHeatRL_Req & (0x01U)) << 2U) | ((_m->CCU_CarpetHeatRR_Req & (0x01U)) << 3U) );

  *_len = (uint8_t) CCU_Requests_DLC;
  *_ide = (uint8_t) CCU_Requests_IDE;
  return CCU_Requests_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_CCU_Stat3_candb(CCU_Stat3_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->CCU_AromaCartridgeCapacity_Stat_ro = (uint8_t) ( (_d[0] & (0x0FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_AromaCartridgeCapacity_Stat_phys = (uint8_t) CANDB_CCU_AromaCartridgeCapacity_Stat_ro_fromS(_m->CCU_AromaCartridgeCapacity_Stat_ro);
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_AromaCartridgeFlavor_Stat = (uint8_t) ( ((_d[1] >> 4U) & (0x0FU)) );
  _m->CCU_AromaFaultReason_Stat = (uint8_t) ( (_d[3] & (0x07U)) );
  _m->CCU_RLfootBlowDis_Stat = (uint8_t) ( ((_d[3] >> 3U) & (0x01U)) );
  _m->CCU_RRfootBlowDis_Stat = (uint8_t) ( ((_d[3] >> 4U) & (0x01U)) );
  _m->CCU_RestMode2_Stat = (uint8_t) ( ((_d[3] >> 5U) & (0x03U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < CCU_Stat3_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_CCU_Stat3_candb(&_m->mon1, CCU_Stat3_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return CCU_Stat3_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_CCU_Stat3_candb(CCU_Stat3_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Stat3_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_AromaCartridgeCapacity_Stat_ro = (uint8_t) CANDB_CCU_AromaCartridgeCapacity_Stat_ro_toS(_m->CCU_AromaCartridgeCapacity_Stat_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->CCU_AromaCartridgeCapacity_Stat_ro & (0x0FU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->CCU_AromaCartridgeFlavor_Stat & (0x0FU)) << 4U) );
  cframe->Data[3] |= (uint8_t) ( (_m->CCU_AromaFaultReason_Stat & (0x07U)) | ((_m->CCU_RLfootBlowDis_Stat & (0x01U)) << 3U) | ((_m->CCU_RRfootBlowDis_Stat & (0x01U)) << 4U) | ((_m->CCU_RestMode2_Stat & (0x03U)) << 5U) );

  cframe->MsgId = (uint32_t) CCU_Stat3_CANID;
  cframe->DLC = (uint8_t) CCU_Stat3_DLC;
  cframe->IDE = (uint8_t) CCU_Stat3_IDE;
  return CCU_Stat3_CANID;
}

#else

uint32_t Pack_CCU_Stat3_candb(CCU_Stat3_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Stat3_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_AromaCartridgeCapacity_Stat_ro = (uint8_t) CANDB_CCU_AromaCartridgeCapacity_Stat_ro_toS(_m->CCU_AromaCartridgeCapacity_Stat_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->CCU_AromaCartridgeCapacity_Stat_ro & (0x0FU)) );
  _d[1] |= (uint8_t) ( ((_m->CCU_AromaCartridgeFlavor_Stat & (0x0FU)) << 4U) );
  _d[3] |= (uint8_t) ( (_m->CCU_AromaFaultReason_Stat & (0x07U)) | ((_m->CCU_RLfootBlowDis_Stat & (0x01U)) << 3U) | ((_m->CCU_RRfootBlowDis_Stat & (0x01U)) << 4U) | ((_m->CCU_RestMode2_Stat & (0x03U)) << 5U) );

  *_len = (uint8_t) CCU_Stat3_DLC;
  *_ide = (uint8_t) CCU_Stat3_IDE;
  return CCU_Stat3_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_CCU_VCU_Msg1_candb(CCU_VCU_Msg1_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->CCU_Sen_Pressure_ro = (uint16_t) ( ((_d[1] & (0x0FU)) << 8U) | (_d[0] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_Sen_Pressure_phys = (sigfloat_t)(CANDB_CCU_Sen_Pressure_ro_fromS(_m->CCU_Sen_Pressure_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_EvaTargetTemp_Val_ro = (int16_t) __ext_sig__(( ((_d[2] & (0xFFU)) << 4U) | ((_d[1] >> 4U) & (0x0FU)) ), 12);
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_EvaTargetTemp_Val_phys = (sigfloat_t)(CANDB_CCU_EvaTargetTemp_Val_ro_fromS(_m->CCU_EvaTargetTemp_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_EvaCurrTempF_Val_ro = (int16_t) __ext_sig__(( ((_d[4] & (0x0FU)) << 8U) | (_d[3] & (0xFFU)) ), 12);
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_EvaCurrTempF_Val_phys = (sigfloat_t)(CANDB_CCU_EvaCurrTempF_Val_ro_fromS(_m->CCU_EvaCurrTempF_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_EvaCurrTempR_Val_ro = (int16_t) __ext_sig__(( ((_d[5] & (0xFFU)) << 4U) | ((_d[4] >> 4U) & (0x0FU)) ), 12);
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_EvaCurrTempR_Val_phys = (sigfloat_t)(CANDB_CCU_EvaCurrTempR_Val_ro_fromS(_m->CCU_EvaCurrTempR_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_LiquidHeaterTargetTemp_Req = (uint8_t) ( (_d[6] & (0x7FU)) );
  _m->CCU_VCU_Msg1_RC = (uint8_t) ( ((_d[7] >> 4U) & (0x0FU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < CCU_VCU_Msg1_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_CCU_VCU_Msg1_candb(&_m->mon1, CCU_VCU_Msg1_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return CCU_VCU_Msg1_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_CCU_VCU_Msg1_candb(CCU_VCU_Msg1_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_VCU_Msg1_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_Sen_Pressure_ro = (uint16_t) CANDB_CCU_Sen_Pressure_ro_toS(_m->CCU_Sen_Pressure_phys);
  _m->CCU_EvaTargetTemp_Val_ro = (int16_t) CANDB_CCU_EvaTargetTemp_Val_ro_toS(_m->CCU_EvaTargetTemp_Val_phys);
  _m->CCU_EvaCurrTempF_Val_ro = (int16_t) CANDB_CCU_EvaCurrTempF_Val_ro_toS(_m->CCU_EvaCurrTempF_Val_phys);
  _m->CCU_EvaCurrTempR_Val_ro = (int16_t) CANDB_CCU_EvaCurrTempR_Val_ro_toS(_m->CCU_EvaCurrTempR_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->CCU_Sen_Pressure_ro & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->CCU_Sen_Pressure_ro >> 8U) & (0x0FU)) | ((_m->CCU_EvaTargetTemp_Val_ro & (0x0FU)) << 4U) );
  cframe->Data[2] |= (uint8_t) ( ((_m->CCU_EvaTargetTemp_Val_ro >> 4U) & (0xFFU)) );
  cframe->Data[3] |= (uint8_t) ( (_m->CCU_EvaCurrTempF_Val_ro & (0xFFU)) );
  cframe->Data[4] |= (uint8_t) ( ((_m->CCU_EvaCurrTempF_Val_ro >> 8U) & (0x0FU)) | ((_m->CCU_EvaCurrTempR_Val_ro & (0x0FU)) << 4U) );
  cframe->Data[5] |= (uint8_t) ( ((_m->CCU_EvaCurrTempR_Val_ro >> 4U) & (0xFFU)) );
  cframe->Data[6] |= (uint8_t) ( (_m->CCU_LiquidHeaterTargetTemp_Req & (0x7FU)) );
  cframe->Data[7] |= (uint8_t) ( ((_m->CCU_VCU_Msg1_RC & (0x0FU)) << 4U) );

  cframe->MsgId = (uint32_t) CCU_VCU_Msg1_CANID;
  cframe->DLC = (uint8_t) CCU_VCU_Msg1_DLC;
  cframe->IDE = (uint8_t) CCU_VCU_Msg1_IDE;
  return CCU_VCU_Msg1_CANID;
}

#else

uint32_t Pack_CCU_VCU_Msg1_candb(CCU_VCU_Msg1_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_VCU_Msg1_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_Sen_Pressure_ro = (uint16_t) CANDB_CCU_Sen_Pressure_ro_toS(_m->CCU_Sen_Pressure_phys);
  _m->CCU_EvaTargetTemp_Val_ro = (int16_t) CANDB_CCU_EvaTargetTemp_Val_ro_toS(_m->CCU_EvaTargetTemp_Val_phys);
  _m->CCU_EvaCurrTempF_Val_ro = (int16_t) CANDB_CCU_EvaCurrTempF_Val_ro_toS(_m->CCU_EvaCurrTempF_Val_phys);
  _m->CCU_EvaCurrTempR_Val_ro = (int16_t) CANDB_CCU_EvaCurrTempR_Val_ro_toS(_m->CCU_EvaCurrTempR_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->CCU_Sen_Pressure_ro & (0xFFU)) );
  _d[1] |= (uint8_t) ( ((_m->CCU_Sen_Pressure_ro >> 8U) & (0x0FU)) | ((_m->CCU_EvaTargetTemp_Val_ro & (0x0FU)) << 4U) );
  _d[2] |= (uint8_t) ( ((_m->CCU_EvaTargetTemp_Val_ro >> 4U) & (0xFFU)) );
  _d[3] |= (uint8_t) ( (_m->CCU_EvaCurrTempF_Val_ro & (0xFFU)) );
  _d[4] |= (uint8_t) ( ((_m->CCU_EvaCurrTempF_Val_ro >> 8U) & (0x0FU)) | ((_m->CCU_EvaCurrTempR_Val_ro & (0x0FU)) << 4U) );
  _d[5] |= (uint8_t) ( ((_m->CCU_EvaCurrTempR_Val_ro >> 4U) & (0xFFU)) );
  _d[6] |= (uint8_t) ( (_m->CCU_LiquidHeaterTargetTemp_Req & (0x7FU)) );
  _d[7] |= (uint8_t) ( ((_m->CCU_VCU_Msg1_RC & (0x0FU)) << 4U) );

  *_len = (uint8_t) CCU_VCU_Msg1_DLC;
  *_ide = (uint8_t) CCU_VCU_Msg1_IDE;
  return CCU_VCU_Msg1_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_CCU_VCU_Msg2_candb(CCU_VCU_Msg2_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->eTXV_batChiller_Pos_Stat = (uint8_t) ( (_d[0] & (0x7FU)) );
  _m->eTXV_batChiller_Err_Stat = (uint8_t) ( (_d[1] & (0x03U)) );
  _m->eTXV_batChiller_Pressure_Val_ro = (uint8_t) ( ((_d[1] >> 2U) & (0x3FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->eTXV_batChiller_Pressure_Val_phys = (sigfloat_t)(CANDB_eTXV_batChiller_Pressure_Val_ro_fromS(_m->eTXV_batChiller_Pressure_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->eTXV_batChiller_Temp_Val_ro = (uint8_t) ( (_d[2] & (0x7FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->eTXV_batChiller_Temp_Val_phys = (int8_t) CANDB_eTXV_batChiller_Temp_Val_ro_fromS(_m->eTXV_batChiller_Temp_Val_ro);
#endif // CANDB_USE_SIGFLOAT

  _m->eTXV_eeChiller_Pos_Stat = (uint8_t) ( (_d[3] & (0x7FU)) );
  _m->eTXV_eeChiller_Err_Stat = (uint8_t) ( (_d[4] & (0x03U)) );
  _m->eTXV_eeChiller_Pressure_Val_ro = (uint8_t) ( ((_d[4] >> 2U) & (0x3FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->eTXV_eeChiller_Pressure_Val_phys = (sigfloat_t)(CANDB_eTXV_eeChiller_Pressure_Val_ro_fromS(_m->eTXV_eeChiller_Pressure_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->eTXV_eeChiller_Temp_Val_ro = (uint8_t) ( (_d[5] & (0x7FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->eTXV_eeChiller_Temp_Val_phys = (int8_t) CANDB_eTXV_eeChiller_Temp_Val_ro_fromS(_m->eTXV_eeChiller_Temp_Val_ro);
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_VCU_Msg2_RC = (uint8_t) ( ((_d[7] >> 4U) & (0x0FU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < CCU_VCU_Msg2_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_CCU_VCU_Msg2_candb(&_m->mon1, CCU_VCU_Msg2_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return CCU_VCU_Msg2_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_CCU_VCU_Msg2_candb(CCU_VCU_Msg2_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_VCU_Msg2_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->eTXV_batChiller_Pressure_Val_ro = (uint8_t) CANDB_eTXV_batChiller_Pressure_Val_ro_toS(_m->eTXV_batChiller_Pressure_Val_phys);
  _m->eTXV_batChiller_Temp_Val_ro = (uint8_t) CANDB_eTXV_batChiller_Temp_Val_ro_toS(_m->eTXV_batChiller_Temp_Val_phys);
  _m->eTXV_eeChiller_Pressure_Val_ro = (uint8_t) CANDB_eTXV_eeChiller_Pressure_Val_ro_toS(_m->eTXV_eeChiller_Pressure_Val_phys);
  _m->eTXV_eeChiller_Temp_Val_ro = (uint8_t) CANDB_eTXV_eeChiller_Temp_Val_ro_toS(_m->eTXV_eeChiller_Temp_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->eTXV_batChiller_Pos_Stat & (0x7FU)) );
  cframe->Data[1] |= (uint8_t) ( (_m->eTXV_batChiller_Err_Stat & (0x03U)) | ((_m->eTXV_batChiller_Pressure_Val_ro & (0x3FU)) << 2U) );
  cframe->Data[2] |= (uint8_t) ( (_m->eTXV_batChiller_Temp_Val_ro & (0x7FU)) );
  cframe->Data[3] |= (uint8_t) ( (_m->eTXV_eeChiller_Pos_Stat & (0x7FU)) );
  cframe->Data[4] |= (uint8_t) ( (_m->eTXV_eeChiller_Err_Stat & (0x03U)) | ((_m->eTXV_eeChiller_Pressure_Val_ro & (0x3FU)) << 2U) );
  cframe->Data[5] |= (uint8_t) ( (_m->eTXV_eeChiller_Temp_Val_ro & (0x7FU)) );
  cframe->Data[7] |= (uint8_t) ( ((_m->CCU_VCU_Msg2_RC & (0x0FU)) << 4U) );

  cframe->MsgId = (uint32_t) CCU_VCU_Msg2_CANID;
  cframe->DLC = (uint8_t) CCU_VCU_Msg2_DLC;
  cframe->IDE = (uint8_t) CCU_VCU_Msg2_IDE;
  return CCU_VCU_Msg2_CANID;
}

#else

uint32_t Pack_CCU_VCU_Msg2_candb(CCU_VCU_Msg2_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_VCU_Msg2_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->eTXV_batChiller_Pressure_Val_ro = (uint8_t) CANDB_eTXV_batChiller_Pressure_Val_ro_toS(_m->eTXV_batChiller_Pressure_Val_phys);
  _m->eTXV_batChiller_Temp_Val_ro = (uint8_t) CANDB_eTXV_batChiller_Temp_Val_ro_toS(_m->eTXV_batChiller_Temp_Val_phys);
  _m->eTXV_eeChiller_Pressure_Val_ro = (uint8_t) CANDB_eTXV_eeChiller_Pressure_Val_ro_toS(_m->eTXV_eeChiller_Pressure_Val_phys);
  _m->eTXV_eeChiller_Temp_Val_ro = (uint8_t) CANDB_eTXV_eeChiller_Temp_Val_ro_toS(_m->eTXV_eeChiller_Temp_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->eTXV_batChiller_Pos_Stat & (0x7FU)) );
  _d[1] |= (uint8_t) ( (_m->eTXV_batChiller_Err_Stat & (0x03U)) | ((_m->eTXV_batChiller_Pressure_Val_ro & (0x3FU)) << 2U) );
  _d[2] |= (uint8_t) ( (_m->eTXV_batChiller_Temp_Val_ro & (0x7FU)) );
  _d[3] |= (uint8_t) ( (_m->eTXV_eeChiller_Pos_Stat & (0x7FU)) );
  _d[4] |= (uint8_t) ( (_m->eTXV_eeChiller_Err_Stat & (0x03U)) | ((_m->eTXV_eeChiller_Pressure_Val_ro & (0x3FU)) << 2U) );
  _d[5] |= (uint8_t) ( (_m->eTXV_eeChiller_Temp_Val_ro & (0x7FU)) );
  _d[7] |= (uint8_t) ( ((_m->CCU_VCU_Msg2_RC & (0x0FU)) << 4U) );

  *_len = (uint8_t) CCU_VCU_Msg2_DLC;
  *_ide = (uint8_t) CCU_VCU_Msg2_IDE;
  return CCU_VCU_Msg2_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_BCM_CLIMATIC_DATA_candb(BCM_CLIMATIC_DATA_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->SolarSensRightVal_ro = (uint8_t) ( (_d[0] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->SolarSensRightVal_phys = (sigfloat_t)(CANDB_SolarSensRightVal_ro_fromS(_m->SolarSensRightVal_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->FrontWindowHeating_Status = (uint8_t) ( ((_d[1] >> 1U) & (0x01U)) );
  _m->RearWindowHeating_Status = (uint8_t) ( ((_d[1] >> 2U) & (0x01U)) );
  _m->SolarSensLeftVal_ro = (uint8_t) ( (_d[2] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->SolarSensLeftVal_phys = (sigfloat_t)(CANDB_SolarSensLeftVal_ro_fromS(_m->SolarSensLeftVal_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->SideWindowHeating_Status = (uint8_t) ( (_d[3] & (0x01U)) );
  _m->BCM_SideWindowType_Stat = (uint8_t) ( ((_d[3] >> 3U) & (0x01U)) );
  _m->BCM_WindowWashingSt = (uint8_t) ( ((_d[3] >> 5U) & (0x01U)) );
  _m->BCM_GloveBox_Stat = (uint8_t) ( ((_d[3] >> 6U) & (0x01U)) );
  _m->WindshieldTemp_ro = (uint8_t) ( (_d[4] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->WindshieldTemp_phys = (sigfloat_t)(CANDB_WindshieldTemp_ro_fromS(_m->WindshieldTemp_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->WindshieldHumidity_ro = (uint8_t) ( (_d[5] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->WindshieldHumidity_phys = (sigfloat_t)(CANDB_WindshieldHumidity_ro_fromS(_m->WindshieldHumidity_ro));
#endif // CANDB_USE_SIGFLOAT

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < BCM_CLIMATIC_DATA_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_BCM_CLIMATIC_DATA_candb(&_m->mon1, BCM_CLIMATIC_DATA_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return BCM_CLIMATIC_DATA_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_BCM_CLIMATIC_DATA_candb(BCM_CLIMATIC_DATA_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(BCM_CLIMATIC_DATA_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->SolarSensRightVal_ro = (uint8_t) CANDB_SolarSensRightVal_ro_toS(_m->SolarSensRightVal_phys);
  _m->SolarSensLeftVal_ro = (uint8_t) CANDB_SolarSensLeftVal_ro_toS(_m->SolarSensLeftVal_phys);
  _m->WindshieldTemp_ro = (uint8_t) CANDB_WindshieldTemp_ro_toS(_m->WindshieldTemp_phys);
  _m->WindshieldHumidity_ro = (uint8_t) CANDB_WindshieldHumidity_ro_toS(_m->WindshieldHumidity_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->SolarSensRightVal_ro & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->FrontWindowHeating_Status & (0x01U)) << 1U) | ((_m->RearWindowHeating_Status & (0x01U)) << 2U) );
  cframe->Data[2] |= (uint8_t) ( (_m->SolarSensLeftVal_ro & (0xFFU)) );
  cframe->Data[3] |= (uint8_t) ( (_m->SideWindowHeating_Status & (0x01U)) | ((_m->BCM_SideWindowType_Stat & (0x01U)) << 3U) | ((_m->BCM_WindowWashingSt & (0x01U)) << 5U) | ((_m->BCM_GloveBox_Stat & (0x01U)) << 6U) );
  cframe->Data[4] |= (uint8_t) ( (_m->WindshieldTemp_ro & (0xFFU)) );
  cframe->Data[5] |= (uint8_t) ( (_m->WindshieldHumidity_ro & (0xFFU)) );

  cframe->MsgId = (uint32_t) BCM_CLIMATIC_DATA_CANID;
  cframe->DLC = (uint8_t) BCM_CLIMATIC_DATA_DLC;
  cframe->IDE = (uint8_t) BCM_CLIMATIC_DATA_IDE;
  return BCM_CLIMATIC_DATA_CANID;
}

#else

uint32_t Pack_BCM_CLIMATIC_DATA_candb(BCM_CLIMATIC_DATA_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(BCM_CLIMATIC_DATA_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->SolarSensRightVal_ro = (uint8_t) CANDB_SolarSensRightVal_ro_toS(_m->SolarSensRightVal_phys);
  _m->SolarSensLeftVal_ro = (uint8_t) CANDB_SolarSensLeftVal_ro_toS(_m->SolarSensLeftVal_phys);
  _m->WindshieldTemp_ro = (uint8_t) CANDB_WindshieldTemp_ro_toS(_m->WindshieldTemp_phys);
  _m->WindshieldHumidity_ro = (uint8_t) CANDB_WindshieldHumidity_ro_toS(_m->WindshieldHumidity_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->SolarSensRightVal_ro & (0xFFU)) );
  _d[1] |= (uint8_t) ( ((_m->FrontWindowHeating_Status & (0x01U)) << 1U) | ((_m->RearWindowHeating_Status & (0x01U)) << 2U) );
  _d[2] |= (uint8_t) ( (_m->SolarSensLeftVal_ro & (0xFFU)) );
  _d[3] |= (uint8_t) ( (_m->SideWindowHeating_Status & (0x01U)) | ((_m->BCM_SideWindowType_Stat & (0x01U)) << 3U) | ((_m->BCM_WindowWashingSt & (0x01U)) << 5U) | ((_m->BCM_GloveBox_Stat & (0x01U)) << 6U) );
  _d[4] |= (uint8_t) ( (_m->WindshieldTemp_ro & (0xFFU)) );
  _d[5] |= (uint8_t) ( (_m->WindshieldHumidity_ro & (0xFFU)) );

  *_len = (uint8_t) BCM_CLIMATIC_DATA_DLC;
  *_ide = (uint8_t) BCM_CLIMATIC_DATA_IDE;
  return BCM_CLIMATIC_DATA_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_CCU_Msg1_candb(CCU_Msg1_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->CCU_MirrorHeating_Req = (uint8_t) ( (_d[0] & (0x03U)) );
  _m->CCU_RecirculationLed_Cmd = (uint8_t) ( ((_d[0] >> 2U) & (0x01U)) );
  _m->CCU_DefrostLed_Req = (uint8_t) ( ((_d[0] >> 3U) & (0x01U)) );
  _m->CCU_SideWindowHeating_Req = (uint8_t) ( ((_d[0] >> 4U) & (0x03U)) );
  _m->CCU_RearWindowHeating_Req = (uint8_t) ( ((_d[0] >> 6U) & (0x03U)) );
  _m->CCU_FrontWindowHeating_Req = (uint8_t) ( (_d[1] & (0x03U)) );
  _m->CCU_EmergAirCleaning_Stat = (uint8_t) ( ((_d[1] >> 2U) & (0x01U)) );
  _m->CCU_FireExtinguishSys_Stat = (uint8_t) ( ((_d[1] >> 3U) & (0x01U)) );
  _m->CCU_FLAutoPsngrLed_Cmd = (uint8_t) ( (_d[3] & (0x01U)) );
  _m->CCU_FRAutoPsngrLed_Cmd = (uint8_t) ( ((_d[3] >> 1U) & (0x01U)) );
  _m->CCU_RLAutoPsngrLed_Cmd = (uint8_t) ( ((_d[3] >> 2U) & (0x01U)) );
  _m->CCU_RRAutoPsngrLed_Cmd = (uint8_t) ( ((_d[3] >> 3U) & (0x01U)) );
  _m->CCU_AC_MaxLed_Cmd = (uint8_t) ( ((_d[3] >> 4U) & (0x01U)) );
  _m->CCU_MSG1_RC = (uint8_t) ( ((_d[6] >> 4U) & (0x0FU)) );
  _m->CCU_MSG1_CS = (uint8_t) ( (_d[7] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < CCU_Msg1_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_CCU_Msg1_candb(&_m->mon1, CCU_Msg1_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return CCU_Msg1_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_CCU_Msg1_candb(CCU_Msg1_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Msg1_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( (_m->CCU_MirrorHeating_Req & (0x03U)) | ((_m->CCU_RecirculationLed_Cmd & (0x01U)) << 2U) | ((_m->CCU_DefrostLed_Req & (0x01U)) << 3U) | ((_m->CCU_SideWindowHeating_Req & (0x03U)) << 4U) | ((_m->CCU_RearWindowHeating_Req & (0x03U)) << 6U) );
  cframe->Data[1] |= (uint8_t) ( (_m->CCU_FrontWindowHeating_Req & (0x03U)) | ((_m->CCU_EmergAirCleaning_Stat & (0x01U)) << 2U) | ((_m->CCU_FireExtinguishSys_Stat & (0x01U)) << 3U) );
  cframe->Data[3] |= (uint8_t) ( (_m->CCU_FLAutoPsngrLed_Cmd & (0x01U)) | ((_m->CCU_FRAutoPsngrLed_Cmd & (0x01U)) << 1U) | ((_m->CCU_RLAutoPsngrLed_Cmd & (0x01U)) << 2U) | ((_m->CCU_RRAutoPsngrLed_Cmd & (0x01U)) << 3U) | ((_m->CCU_AC_MaxLed_Cmd & (0x01U)) << 4U) );
  cframe->Data[6] |= (uint8_t) ( ((_m->CCU_MSG1_RC & (0x0FU)) << 4U) );
  cframe->Data[7] |= (uint8_t) ( (_m->CCU_MSG1_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) CCU_Msg1_CANID;
  cframe->DLC = (uint8_t) CCU_Msg1_DLC;
  cframe->IDE = (uint8_t) CCU_Msg1_IDE;
  return CCU_Msg1_CANID;
}

#else

uint32_t Pack_CCU_Msg1_candb(CCU_Msg1_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Msg1_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( (_m->CCU_MirrorHeating_Req & (0x03U)) | ((_m->CCU_RecirculationLed_Cmd & (0x01U)) << 2U) | ((_m->CCU_DefrostLed_Req & (0x01U)) << 3U) | ((_m->CCU_SideWindowHeating_Req & (0x03U)) << 4U) | ((_m->CCU_RearWindowHeating_Req & (0x03U)) << 6U) );
  _d[1] |= (uint8_t) ( (_m->CCU_FrontWindowHeating_Req & (0x03U)) | ((_m->CCU_EmergAirCleaning_Stat & (0x01U)) << 2U) | ((_m->CCU_FireExtinguishSys_Stat & (0x01U)) << 3U) );
  _d[3] |= (uint8_t) ( (_m->CCU_FLAutoPsngrLed_Cmd & (0x01U)) | ((_m->CCU_FRAutoPsngrLed_Cmd & (0x01U)) << 1U) | ((_m->CCU_RLAutoPsngrLed_Cmd & (0x01U)) << 2U) | ((_m->CCU_RRAutoPsngrLed_Cmd & (0x01U)) << 3U) | ((_m->CCU_AC_MaxLed_Cmd & (0x01U)) << 4U) );
  _d[6] |= (uint8_t) ( ((_m->CCU_MSG1_RC & (0x0FU)) << 4U) );
  _d[7] |= (uint8_t) ( (_m->CCU_MSG1_CS & (0xFFU)) );

  *_len = (uint8_t) CCU_Msg1_DLC;
  *_ide = (uint8_t) CCU_Msg1_IDE;
  return CCU_Msg1_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_VCU_CCU_Req_candb(VCU_CCU_Req_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->VCU_eTXV_batChiller_Pos_Req = (uint8_t) ( (_d[0] & (0x7FU)) );
  _m->VCU_eTXV_eeChiller_Pos_Req = (uint8_t) ( (_d[1] & (0x7FU)) );
  _m->VCU_LiquidHeaterCurrentTemp_Stat_ro = (uint8_t) ( (_d[2] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->VCU_LiquidHeaterCurrentTemp_Stat_phys = (sigfloat_t)(CANDB_VCU_LiquidHeaterCurrentTemp_Stat_ro_fromS(_m->VCU_LiquidHeaterCurrentTemp_Stat_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->VCU_CCU_Req_RC = (uint8_t) ( (_d[3] & (0x0FU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < VCU_CCU_Req_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_VCU_CCU_Req_candb(&_m->mon1, VCU_CCU_Req_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return VCU_CCU_Req_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_VCU_CCU_Req_candb(VCU_CCU_Req_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(VCU_CCU_Req_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->VCU_LiquidHeaterCurrentTemp_Stat_ro = (uint8_t) CANDB_VCU_LiquidHeaterCurrentTemp_Stat_ro_toS(_m->VCU_LiquidHeaterCurrentTemp_Stat_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->VCU_eTXV_batChiller_Pos_Req & (0x7FU)) );
  cframe->Data[1] |= (uint8_t) ( (_m->VCU_eTXV_eeChiller_Pos_Req & (0x7FU)) );
  cframe->Data[2] |= (uint8_t) ( (_m->VCU_LiquidHeaterCurrentTemp_Stat_ro & (0xFFU)) );
  cframe->Data[3] |= (uint8_t) ( (_m->VCU_CCU_Req_RC & (0x0FU)) );

  cframe->MsgId = (uint32_t) VCU_CCU_Req_CANID;
  cframe->DLC = (uint8_t) VCU_CCU_Req_DLC;
  cframe->IDE = (uint8_t) VCU_CCU_Req_IDE;
  return VCU_CCU_Req_CANID;
}

#else

uint32_t Pack_VCU_CCU_Req_candb(VCU_CCU_Req_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(VCU_CCU_Req_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->VCU_LiquidHeaterCurrentTemp_Stat_ro = (uint8_t) CANDB_VCU_LiquidHeaterCurrentTemp_Stat_ro_toS(_m->VCU_LiquidHeaterCurrentTemp_Stat_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->VCU_eTXV_batChiller_Pos_Req & (0x7FU)) );
  _d[1] |= (uint8_t) ( (_m->VCU_eTXV_eeChiller_Pos_Req & (0x7FU)) );
  _d[2] |= (uint8_t) ( (_m->VCU_LiquidHeaterCurrentTemp_Stat_ro & (0xFFU)) );
  _d[3] |= (uint8_t) ( (_m->VCU_CCU_Req_RC & (0x0FU)) );

  *_len = (uint8_t) VCU_CCU_Req_DLC;
  *_ide = (uint8_t) VCU_CCU_Req_IDE;
  return VCU_CCU_Req_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_ESC_08_candb(ESC_08_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->ESC_Mileage_Val_ro = (uint32_t) ( ((_d[3] & (0x07U)) << 24U) | ((_d[2] & (0xFFU)) << 16U) | ((_d[1] & (0xFFU)) << 8U) | (_d[0] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->ESC_Mileage_Val_phys = (sigfloat_t)(CANDB_ESC_Mileage_Val_ro_fromS(_m->ESC_Mileage_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->ESC_08_RC = (uint8_t) ( ((_d[3] >> 4U) & (0x0FU)) );
  _m->ESC_08_CS = (uint8_t) ( (_d[4] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < ESC_08_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_ESC_08_candb(&_m->mon1, ESC_08_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return ESC_08_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_ESC_08_candb(ESC_08_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(ESC_08_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->ESC_Mileage_Val_ro = (uint32_t) CANDB_ESC_Mileage_Val_ro_toS(_m->ESC_Mileage_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->ESC_Mileage_Val_ro & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->ESC_Mileage_Val_ro >> 8U) & (0xFFU)) );
  cframe->Data[2] |= (uint8_t) ( ((_m->ESC_Mileage_Val_ro >> 16U) & (0xFFU)) );
  cframe->Data[3] |= (uint8_t) ( ((_m->ESC_Mileage_Val_ro >> 24U) & (0x07U)) | ((_m->ESC_08_RC & (0x0FU)) << 4U) );
  cframe->Data[4] |= (uint8_t) ( (_m->ESC_08_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) ESC_08_CANID;
  cframe->DLC = (uint8_t) ESC_08_DLC;
  cframe->IDE = (uint8_t) ESC_08_IDE;
  return ESC_08_CANID;
}

#else

uint32_t Pack_ESC_08_candb(ESC_08_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(ESC_08_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->ESC_Mileage_Val_ro = (uint32_t) CANDB_ESC_Mileage_Val_ro_toS(_m->ESC_Mileage_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->ESC_Mileage_Val_ro & (0xFFU)) );
  _d[1] |= (uint8_t) ( ((_m->ESC_Mileage_Val_ro >> 8U) & (0xFFU)) );
  _d[2] |= (uint8_t) ( ((_m->ESC_Mileage_Val_ro >> 16U) & (0xFFU)) );
  _d[3] |= (uint8_t) ( ((_m->ESC_Mileage_Val_ro >> 24U) & (0x07U)) | ((_m->ESC_08_RC & (0x0FU)) << 4U) );
  _d[4] |= (uint8_t) ( (_m->ESC_08_CS & (0xFFU)) );

  *_len = (uint8_t) ESC_08_DLC;
  *_ide = (uint8_t) ESC_08_IDE;
  return ESC_08_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_SMFL_status_candb(SMFL_status_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->SMFL_CarpetHeat_Stat = (uint8_t) ( ((_d[6] >> 1U) & (0x01U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < SMFL_status_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_SMFL_status_candb(&_m->mon1, SMFL_status_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return SMFL_status_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_SMFL_status_candb(SMFL_status_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(SMFL_status_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[6] |= (uint8_t) ( ((_m->SMFL_CarpetHeat_Stat & (0x01U)) << 1U) );

  cframe->MsgId = (uint32_t) SMFL_status_CANID;
  cframe->DLC = (uint8_t) SMFL_status_DLC;
  cframe->IDE = (uint8_t) SMFL_status_IDE;
  return SMFL_status_CANID;
}

#else

uint32_t Pack_SMFL_status_candb(SMFL_status_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(SMFL_status_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[6] |= (uint8_t) ( ((_m->SMFL_CarpetHeat_Stat & (0x01U)) << 1U) );

  *_len = (uint8_t) SMFL_status_DLC;
  *_ide = (uint8_t) SMFL_status_IDE;
  return SMFL_status_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_SMFR_status_candb(SMFR_status_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->SMFR_CarpetHeat_Stat = (uint8_t) ( ((_d[6] >> 1U) & (0x01U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < SMFR_status_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_SMFR_status_candb(&_m->mon1, SMFR_status_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return SMFR_status_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_SMFR_status_candb(SMFR_status_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(SMFR_status_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[6] |= (uint8_t) ( ((_m->SMFR_CarpetHeat_Stat & (0x01U)) << 1U) );

  cframe->MsgId = (uint32_t) SMFR_status_CANID;
  cframe->DLC = (uint8_t) SMFR_status_DLC;
  cframe->IDE = (uint8_t) SMFR_status_IDE;
  return SMFR_status_CANID;
}

#else

uint32_t Pack_SMFR_status_candb(SMFR_status_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(SMFR_status_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[6] |= (uint8_t) ( ((_m->SMFR_CarpetHeat_Stat & (0x01U)) << 1U) );

  *_len = (uint8_t) SMFR_status_DLC;
  *_ide = (uint8_t) SMFR_status_IDE;
  return SMFR_status_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_SMRL_status_candb(SMRL_status_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->SMRL_CarpetHeat_Stat = (uint8_t) ( ((_d[6] >> 1U) & (0x01U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < SMRL_status_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_SMRL_status_candb(&_m->mon1, SMRL_status_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return SMRL_status_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_SMRL_status_candb(SMRL_status_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(SMRL_status_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[6] |= (uint8_t) ( ((_m->SMRL_CarpetHeat_Stat & (0x01U)) << 1U) );

  cframe->MsgId = (uint32_t) SMRL_status_CANID;
  cframe->DLC = (uint8_t) SMRL_status_DLC;
  cframe->IDE = (uint8_t) SMRL_status_IDE;
  return SMRL_status_CANID;
}

#else

uint32_t Pack_SMRL_status_candb(SMRL_status_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(SMRL_status_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[6] |= (uint8_t) ( ((_m->SMRL_CarpetHeat_Stat & (0x01U)) << 1U) );

  *_len = (uint8_t) SMRL_status_DLC;
  *_ide = (uint8_t) SMRL_status_IDE;
  return SMRL_status_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_SMRR_status_candb(SMRR_status_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->SMRR_CarpetHeat_Stat = (uint8_t) ( ((_d[6] >> 1U) & (0x01U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < SMRR_status_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_SMRR_status_candb(&_m->mon1, SMRR_status_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return SMRR_status_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_SMRR_status_candb(SMRR_status_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(SMRR_status_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[6] |= (uint8_t) ( ((_m->SMRR_CarpetHeat_Stat & (0x01U)) << 1U) );

  cframe->MsgId = (uint32_t) SMRR_status_CANID;
  cframe->DLC = (uint8_t) SMRR_status_DLC;
  cframe->IDE = (uint8_t) SMRR_status_IDE;
  return SMRR_status_CANID;
}

#else

uint32_t Pack_SMRR_status_candb(SMRR_status_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(SMRR_status_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[6] |= (uint8_t) ( ((_m->SMRR_CarpetHeat_Stat & (0x01U)) << 1U) );

  *_len = (uint8_t) SMRR_status_DLC;
  *_ide = (uint8_t) SMRR_status_IDE;
  return SMRR_status_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_CCU_Errors_candb(CCU_Errors_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->CCU_IncarTempErrF_Stat = (uint8_t) ( (_d[0] & (0x01U)) );
  _m->CCU_IncarTempErrR_Stat = (uint8_t) ( ((_d[0] >> 1U) & (0x01U)) );
  _m->CCU_DuctTempSenErrF_Stat = (uint8_t) ( ((_d[0] >> 2U) & (0x01U)) );
  _m->CCU_DuctTempSenErrR_Stat = (uint8_t) ( ((_d[0] >> 3U) & (0x01U)) );
  _m->CCU_EvaTempSenErrF_Stat = (uint8_t) ( ((_d[0] >> 4U) & (0x01U)) );
  _m->CCU_EvaTempSenErrR_Stat = (uint8_t) ( ((_d[0] >> 5U) & (0x01U)) );
  _m->CCU_DeflectorSwErrF_Stat = (uint8_t) ( ((_d[0] >> 6U) & (0x01U)) );
  _m->CCU_DeflectorSwErrR_Stat = (uint8_t) ( ((_d[0] >> 7U) & (0x01U)) );
  _m->CCU_PressSenErr_Stat = (uint8_t) ( (_d[1] & (0x01U)) );
  _m->CCU_AmbienTemptSenErr_Stat = (uint8_t) ( ((_d[1] >> 1U) & (0x01U)) );
  _m->CCU_SealingValveErr_Stat = (uint8_t) ( ((_d[1] >> 2U) & (0x01U)) );
  _m->CCU_ETXVerr_Stat = (uint8_t) ( ((_d[1] >> 3U) & (0x01U)) );
  _m->CCU_HVACfanOrTXVerrF_Stat = (uint8_t) ( ((_d[1] >> 4U) & (0x01U)) );
  _m->CCU_HVACfanOrTXVerrR_Stat = (uint8_t) ( ((_d[1] >> 5U) & (0x01U)) );
  _m->CCU_ActuatorErrF_Stat = (uint8_t) ( ((_d[1] >> 6U) & (0x01U)) );
  _m->CCU_ActuatorErrR_Stat = (uint8_t) ( ((_d[1] >> 7U) & (0x01U)) );
  _m->CCU_UltravioletErr_Stat = (uint8_t) ( (_d[2] & (0x03U)) );
  _m->CCU_VinRecordErr_Stat = (uint8_t) ( ((_d[2] >> 2U) & (0x01U)) );
  _m->CCU_AirQualSenErr_Stat = (uint8_t) ( ((_d[2] >> 3U) & (0x07U)) );
  _m->CCU_CommErr_Stat = (uint8_t) ( ((_d[2] >> 6U) & (0x01U)) );
  _m->CCU_TWVerr_Stat = (uint8_t) ( ((_d[2] >> 7U) & (0x01U)) );
  _m->CCU_IonizationErr_Stat = (uint8_t) ( (_d[3] & (0x07U)) );
  _m->CCU_AromaErr_Stat = (uint8_t) ( ((_d[3] >> 3U) & (0x07U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < CCU_Errors_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_CCU_Errors_candb(&_m->mon1, CCU_Errors_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return CCU_Errors_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_CCU_Errors_candb(CCU_Errors_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Errors_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( (_m->CCU_IncarTempErrF_Stat & (0x01U)) | ((_m->CCU_IncarTempErrR_Stat & (0x01U)) << 1U) | ((_m->CCU_DuctTempSenErrF_Stat & (0x01U)) << 2U) | ((_m->CCU_DuctTempSenErrR_Stat & (0x01U)) << 3U) | ((_m->CCU_EvaTempSenErrF_Stat & (0x01U)) << 4U) | ((_m->CCU_EvaTempSenErrR_Stat & (0x01U)) << 5U) | ((_m->CCU_DeflectorSwErrF_Stat & (0x01U)) << 6U) | ((_m->CCU_DeflectorSwErrR_Stat & (0x01U)) << 7U) );
  cframe->Data[1] |= (uint8_t) ( (_m->CCU_PressSenErr_Stat & (0x01U)) | ((_m->CCU_AmbienTemptSenErr_Stat & (0x01U)) << 1U) | ((_m->CCU_SealingValveErr_Stat & (0x01U)) << 2U) | ((_m->CCU_ETXVerr_Stat & (0x01U)) << 3U) | ((_m->CCU_HVACfanOrTXVerrF_Stat & (0x01U)) << 4U) | ((_m->CCU_HVACfanOrTXVerrR_Stat & (0x01U)) << 5U) | ((_m->CCU_ActuatorErrF_Stat & (0x01U)) << 6U) | ((_m->CCU_ActuatorErrR_Stat & (0x01U)) << 7U) );
  cframe->Data[2] |= (uint8_t) ( (_m->CCU_UltravioletErr_Stat & (0x03U)) | ((_m->CCU_VinRecordErr_Stat & (0x01U)) << 2U) | ((_m->CCU_AirQualSenErr_Stat & (0x07U)) << 3U) | ((_m->CCU_CommErr_Stat & (0x01U)) << 6U) | ((_m->CCU_TWVerr_Stat & (0x01U)) << 7U) );
  cframe->Data[3] |= (uint8_t) ( (_m->CCU_IonizationErr_Stat & (0x07U)) | ((_m->CCU_AromaErr_Stat & (0x07U)) << 3U) );

  cframe->MsgId = (uint32_t) CCU_Errors_CANID;
  cframe->DLC = (uint8_t) CCU_Errors_DLC;
  cframe->IDE = (uint8_t) CCU_Errors_IDE;
  return CCU_Errors_CANID;
}

#else

uint32_t Pack_CCU_Errors_candb(CCU_Errors_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Errors_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( (_m->CCU_IncarTempErrF_Stat & (0x01U)) | ((_m->CCU_IncarTempErrR_Stat & (0x01U)) << 1U) | ((_m->CCU_DuctTempSenErrF_Stat & (0x01U)) << 2U) | ((_m->CCU_DuctTempSenErrR_Stat & (0x01U)) << 3U) | ((_m->CCU_EvaTempSenErrF_Stat & (0x01U)) << 4U) | ((_m->CCU_EvaTempSenErrR_Stat & (0x01U)) << 5U) | ((_m->CCU_DeflectorSwErrF_Stat & (0x01U)) << 6U) | ((_m->CCU_DeflectorSwErrR_Stat & (0x01U)) << 7U) );
  _d[1] |= (uint8_t) ( (_m->CCU_PressSenErr_Stat & (0x01U)) | ((_m->CCU_AmbienTemptSenErr_Stat & (0x01U)) << 1U) | ((_m->CCU_SealingValveErr_Stat & (0x01U)) << 2U) | ((_m->CCU_ETXVerr_Stat & (0x01U)) << 3U) | ((_m->CCU_HVACfanOrTXVerrF_Stat & (0x01U)) << 4U) | ((_m->CCU_HVACfanOrTXVerrR_Stat & (0x01U)) << 5U) | ((_m->CCU_ActuatorErrF_Stat & (0x01U)) << 6U) | ((_m->CCU_ActuatorErrR_Stat & (0x01U)) << 7U) );
  _d[2] |= (uint8_t) ( (_m->CCU_UltravioletErr_Stat & (0x03U)) | ((_m->CCU_VinRecordErr_Stat & (0x01U)) << 2U) | ((_m->CCU_AirQualSenErr_Stat & (0x07U)) << 3U) | ((_m->CCU_CommErr_Stat & (0x01U)) << 6U) | ((_m->CCU_TWVerr_Stat & (0x01U)) << 7U) );
  _d[3] |= (uint8_t) ( (_m->CCU_IonizationErr_Stat & (0x07U)) | ((_m->CCU_AromaErr_Stat & (0x07U)) << 3U) );

  *_len = (uint8_t) CCU_Errors_DLC;
  *_ide = (uint8_t) CCU_Errors_IDE;
  return CCU_Errors_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_CCU_Msg3_candb(CCU_Msg3_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->CCU_FAN_Req = (uint8_t) ( (_d[0] & (0x7FU)) );
  _m->CCU_RestMode_Stat = (uint8_t) ( ((_d[1] >> 2U) & (0x03U)) );
  _m->CCU_IncarTempSum_Val_ro = (uint8_t) ( (_d[2] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_IncarTempSum_Val_phys = (sigfloat_t)(CANDB_CCU_IncarTempSum_Val_ro_fromS(_m->CCU_IncarTempSum_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_MSG3_RC = (uint8_t) ( (_d[3] & (0x0FU)) );
  _m->CCU_MSG3_CS = (uint8_t) ( (_d[4] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < CCU_Msg3_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_CCU_Msg3_candb(&_m->mon1, CCU_Msg3_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return CCU_Msg3_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_CCU_Msg3_candb(CCU_Msg3_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Msg3_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_IncarTempSum_Val_ro = (uint8_t) CANDB_CCU_IncarTempSum_Val_ro_toS(_m->CCU_IncarTempSum_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->CCU_FAN_Req & (0x7FU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->CCU_RestMode_Stat & (0x03U)) << 2U) );
  cframe->Data[2] |= (uint8_t) ( (_m->CCU_IncarTempSum_Val_ro & (0xFFU)) );
  cframe->Data[3] |= (uint8_t) ( (_m->CCU_MSG3_RC & (0x0FU)) );
  cframe->Data[4] |= (uint8_t) ( (_m->CCU_MSG3_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) CCU_Msg3_CANID;
  cframe->DLC = (uint8_t) CCU_Msg3_DLC;
  cframe->IDE = (uint8_t) CCU_Msg3_IDE;
  return CCU_Msg3_CANID;
}

#else

uint32_t Pack_CCU_Msg3_candb(CCU_Msg3_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_Msg3_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_IncarTempSum_Val_ro = (uint8_t) CANDB_CCU_IncarTempSum_Val_ro_toS(_m->CCU_IncarTempSum_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->CCU_FAN_Req & (0x7FU)) );
  _d[1] |= (uint8_t) ( ((_m->CCU_RestMode_Stat & (0x03U)) << 2U) );
  _d[2] |= (uint8_t) ( (_m->CCU_IncarTempSum_Val_ro & (0xFFU)) );
  _d[3] |= (uint8_t) ( (_m->CCU_MSG3_RC & (0x0FU)) );
  _d[4] |= (uint8_t) ( (_m->CCU_MSG3_CS & (0xFFU)) );

  *_len = (uint8_t) CCU_Msg3_DLC;
  *_ide = (uint8_t) CCU_Msg3_IDE;
  return CCU_Msg3_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_SDM_Cmd_candb(SDM_Cmd_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->SDM_Aroma_Req = (uint8_t) ( ((_d[1] >> 6U) & (0x03U)) );
  _m->SDM_AromaIntens_Req = (uint8_t) ( ((_d[2] >> 6U) & (0x03U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < SDM_Cmd_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_SDM_Cmd_candb(&_m->mon1, SDM_Cmd_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return SDM_Cmd_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_SDM_Cmd_candb(SDM_Cmd_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(SDM_Cmd_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[1] |= (uint8_t) ( ((_m->SDM_Aroma_Req & (0x03U)) << 6U) );
  cframe->Data[2] |= (uint8_t) ( ((_m->SDM_AromaIntens_Req & (0x03U)) << 6U) );

  cframe->MsgId = (uint32_t) SDM_Cmd_CANID;
  cframe->DLC = (uint8_t) SDM_Cmd_DLC;
  cframe->IDE = (uint8_t) SDM_Cmd_IDE;
  return SDM_Cmd_CANID;
}

#else

uint32_t Pack_SDM_Cmd_candb(SDM_Cmd_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(SDM_Cmd_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[1] |= (uint8_t) ( ((_m->SDM_Aroma_Req & (0x03U)) << 6U) );
  _d[2] |= (uint8_t) ( ((_m->SDM_AromaIntens_Req & (0x03U)) << 6U) );

  *_len = (uint8_t) SDM_Cmd_DLC;
  *_ide = (uint8_t) SDM_Cmd_IDE;
  return SDM_Cmd_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_VEH_VIN_candb(VEH_VIN_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->VIN_Addressing = (uint8_t) ( (_d[0] & (0x03U)) );
  _m->VIN_Char1 = (uint8_t) ( (_d[1] & (0xFFU)) );
  _m->VIN_Char8 = (uint8_t) ( (_d[1] & (0xFFU)) );
  _m->VIN_Char15 = (uint8_t) ( (_d[1] & (0xFFU)) );
  _m->VIN_Char16 = (uint8_t) ( (_d[2] & (0xFFU)) );
  _m->VIN_Char2 = (uint8_t) ( (_d[2] & (0xFFU)) );
  _m->VIN_Char9 = (uint8_t) ( (_d[2] & (0xFFU)) );
  _m->VIN_Char10 = (uint8_t) ( (_d[3] & (0xFFU)) );
  _m->VIN_Char17 = (uint8_t) ( (_d[3] & (0xFFU)) );
  _m->VIN_Char3 = (uint8_t) ( (_d[3] & (0xFFU)) );
  _m->VIN_Char4 = (uint8_t) ( (_d[4] & (0xFFU)) );
  _m->VIN_Char11 = (uint8_t) ( (_d[4] & (0xFFU)) );
  _m->VIN_Char12 = (uint8_t) ( (_d[5] & (0xFFU)) );
  _m->VIN_Char5 = (uint8_t) ( (_d[5] & (0xFFU)) );
  _m->VIN_Char6 = (uint8_t) ( (_d[6] & (0xFFU)) );
  _m->VIN_Char13 = (uint8_t) ( (_d[6] & (0xFFU)) );
  _m->VIN_Char7 = (uint8_t) ( (_d[7] & (0xFFU)) );
  _m->VIN_Char14 = (uint8_t) ( (_d[7] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < VEH_VIN_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_VEH_VIN_candb(&_m->mon1, VEH_VIN_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return VEH_VIN_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_VEH_VIN_candb(VEH_VIN_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(VEH_VIN_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( (_m->VIN_Addressing & (0x03U)) );
  cframe->Data[1] |= (uint8_t) ( (_m->VIN_Char1 & (0xFFU)) | (_m->VIN_Char8 & (0xFFU)) | (_m->VIN_Char15 & (0xFFU)) );
  cframe->Data[2] |= (uint8_t) ( (_m->VIN_Char16 & (0xFFU)) | (_m->VIN_Char2 & (0xFFU)) | (_m->VIN_Char9 & (0xFFU)) );
  cframe->Data[3] |= (uint8_t) ( (_m->VIN_Char10 & (0xFFU)) | (_m->VIN_Char17 & (0xFFU)) | (_m->VIN_Char3 & (0xFFU)) );
  cframe->Data[4] |= (uint8_t) ( (_m->VIN_Char4 & (0xFFU)) | (_m->VIN_Char11 & (0xFFU)) );
  cframe->Data[5] |= (uint8_t) ( (_m->VIN_Char12 & (0xFFU)) | (_m->VIN_Char5 & (0xFFU)) );
  cframe->Data[6] |= (uint8_t) ( (_m->VIN_Char6 & (0xFFU)) | (_m->VIN_Char13 & (0xFFU)) );
  cframe->Data[7] |= (uint8_t) ( (_m->VIN_Char7 & (0xFFU)) | (_m->VIN_Char14 & (0xFFU)) );

  cframe->MsgId = (uint32_t) VEH_VIN_CANID;
  cframe->DLC = (uint8_t) VEH_VIN_DLC;
  cframe->IDE = (uint8_t) VEH_VIN_IDE;
  return VEH_VIN_CANID;
}

#else

uint32_t Pack_VEH_VIN_candb(VEH_VIN_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(VEH_VIN_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( (_m->VIN_Addressing & (0x03U)) );
  _d[1] |= (uint8_t) ( (_m->VIN_Char1 & (0xFFU)) | (_m->VIN_Char8 & (0xFFU)) | (_m->VIN_Char15 & (0xFFU)) );
  _d[2] |= (uint8_t) ( (_m->VIN_Char16 & (0xFFU)) | (_m->VIN_Char2 & (0xFFU)) | (_m->VIN_Char9 & (0xFFU)) );
  _d[3] |= (uint8_t) ( (_m->VIN_Char10 & (0xFFU)) | (_m->VIN_Char17 & (0xFFU)) | (_m->VIN_Char3 & (0xFFU)) );
  _d[4] |= (uint8_t) ( (_m->VIN_Char4 & (0xFFU)) | (_m->VIN_Char11 & (0xFFU)) );
  _d[5] |= (uint8_t) ( (_m->VIN_Char12 & (0xFFU)) | (_m->VIN_Char5 & (0xFFU)) );
  _d[6] |= (uint8_t) ( (_m->VIN_Char6 & (0xFFU)) | (_m->VIN_Char13 & (0xFFU)) );
  _d[7] |= (uint8_t) ( (_m->VIN_Char7 & (0xFFU)) | (_m->VIN_Char14 & (0xFFU)) );

  *_len = (uint8_t) VEH_VIN_DLC;
  *_ide = (uint8_t) VEH_VIN_IDE;
  return VEH_VIN_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_OCUFL_MSG_candb(OCUFL_MSG_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->OCUFL_OccupantWeight_Stat = (uint8_t) ( (_d[0] & (0x03U)) );
  _m->OCUFL_SeatOccupied_Stat = (uint8_t) ( ((_d[0] >> 2U) & (0x01U)) );
  _m->OCUFL_SensorError_Stat = (uint8_t) ( ((_d[0] >> 3U) & (0x01U)) );
  _m->OCUFL_MSG_RC = (uint8_t) ( ((_d[0] >> 4U) & (0x0FU)) );
  _m->OCUFL_MSG_CS = (uint8_t) ( (_d[1] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < OCUFL_MSG_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_OCUFL_MSG_candb(&_m->mon1, OCUFL_MSG_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return OCUFL_MSG_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_OCUFL_MSG_candb(OCUFL_MSG_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(OCUFL_MSG_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( (_m->OCUFL_OccupantWeight_Stat & (0x03U)) | ((_m->OCUFL_SeatOccupied_Stat & (0x01U)) << 2U) | ((_m->OCUFL_SensorError_Stat & (0x01U)) << 3U) | ((_m->OCUFL_MSG_RC & (0x0FU)) << 4U) );
  cframe->Data[1] |= (uint8_t) ( (_m->OCUFL_MSG_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) OCUFL_MSG_CANID;
  cframe->DLC = (uint8_t) OCUFL_MSG_DLC;
  cframe->IDE = (uint8_t) OCUFL_MSG_IDE;
  return OCUFL_MSG_CANID;
}

#else

uint32_t Pack_OCUFL_MSG_candb(OCUFL_MSG_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(OCUFL_MSG_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( (_m->OCUFL_OccupantWeight_Stat & (0x03U)) | ((_m->OCUFL_SeatOccupied_Stat & (0x01U)) << 2U) | ((_m->OCUFL_SensorError_Stat & (0x01U)) << 3U) | ((_m->OCUFL_MSG_RC & (0x0FU)) << 4U) );
  _d[1] |= (uint8_t) ( (_m->OCUFL_MSG_CS & (0xFFU)) );

  *_len = (uint8_t) OCUFL_MSG_DLC;
  *_ide = (uint8_t) OCUFL_MSG_IDE;
  return OCUFL_MSG_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_OCUFR_MSG_candb(OCUFR_MSG_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->OCUFR_OccupantWeight_Stat = (uint8_t) ( (_d[0] & (0x03U)) );
  _m->OCUFR_SeatOccupied_Stat = (uint8_t) ( ((_d[0] >> 2U) & (0x01U)) );
  _m->OCUFR_SensorError_Stat = (uint8_t) ( ((_d[0] >> 3U) & (0x01U)) );
  _m->OCUFR_MSG_RC = (uint8_t) ( ((_d[0] >> 4U) & (0x0FU)) );
  _m->OCUFR_MSG_CS = (uint8_t) ( (_d[1] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < OCUFR_MSG_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_OCUFR_MSG_candb(&_m->mon1, OCUFR_MSG_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return OCUFR_MSG_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_OCUFR_MSG_candb(OCUFR_MSG_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(OCUFR_MSG_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( (_m->OCUFR_OccupantWeight_Stat & (0x03U)) | ((_m->OCUFR_SeatOccupied_Stat & (0x01U)) << 2U) | ((_m->OCUFR_SensorError_Stat & (0x01U)) << 3U) | ((_m->OCUFR_MSG_RC & (0x0FU)) << 4U) );
  cframe->Data[1] |= (uint8_t) ( (_m->OCUFR_MSG_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) OCUFR_MSG_CANID;
  cframe->DLC = (uint8_t) OCUFR_MSG_DLC;
  cframe->IDE = (uint8_t) OCUFR_MSG_IDE;
  return OCUFR_MSG_CANID;
}

#else

uint32_t Pack_OCUFR_MSG_candb(OCUFR_MSG_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(OCUFR_MSG_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( (_m->OCUFR_OccupantWeight_Stat & (0x03U)) | ((_m->OCUFR_SeatOccupied_Stat & (0x01U)) << 2U) | ((_m->OCUFR_SensorError_Stat & (0x01U)) << 3U) | ((_m->OCUFR_MSG_RC & (0x0FU)) << 4U) );
  _d[1] |= (uint8_t) ( (_m->OCUFR_MSG_CS & (0xFFU)) );

  *_len = (uint8_t) OCUFR_MSG_DLC;
  *_ide = (uint8_t) OCUFR_MSG_IDE;
  return OCUFR_MSG_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_OCURL_MSG_candb(OCURL_MSG_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->OCURL_OccupantWeight_Stat = (uint8_t) ( (_d[0] & (0x03U)) );
  _m->OCURL_SeatOccupied_Stat = (uint8_t) ( ((_d[0] >> 2U) & (0x01U)) );
  _m->OCURL_SensorError_Stat = (uint8_t) ( ((_d[0] >> 3U) & (0x01U)) );
  _m->OCURL_MSG_RC = (uint8_t) ( ((_d[0] >> 4U) & (0x0FU)) );
  _m->OCURL_MSG_CS = (uint8_t) ( (_d[1] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < OCURL_MSG_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_OCURL_MSG_candb(&_m->mon1, OCURL_MSG_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return OCURL_MSG_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_OCURL_MSG_candb(OCURL_MSG_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(OCURL_MSG_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( (_m->OCURL_OccupantWeight_Stat & (0x03U)) | ((_m->OCURL_SeatOccupied_Stat & (0x01U)) << 2U) | ((_m->OCURL_SensorError_Stat & (0x01U)) << 3U) | ((_m->OCURL_MSG_RC & (0x0FU)) << 4U) );
  cframe->Data[1] |= (uint8_t) ( (_m->OCURL_MSG_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) OCURL_MSG_CANID;
  cframe->DLC = (uint8_t) OCURL_MSG_DLC;
  cframe->IDE = (uint8_t) OCURL_MSG_IDE;
  return OCURL_MSG_CANID;
}

#else

uint32_t Pack_OCURL_MSG_candb(OCURL_MSG_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(OCURL_MSG_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( (_m->OCURL_OccupantWeight_Stat & (0x03U)) | ((_m->OCURL_SeatOccupied_Stat & (0x01U)) << 2U) | ((_m->OCURL_SensorError_Stat & (0x01U)) << 3U) | ((_m->OCURL_MSG_RC & (0x0FU)) << 4U) );
  _d[1] |= (uint8_t) ( (_m->OCURL_MSG_CS & (0xFFU)) );

  *_len = (uint8_t) OCURL_MSG_DLC;
  *_ide = (uint8_t) OCURL_MSG_IDE;
  return OCURL_MSG_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_OCURR_MSG_candb(OCURR_MSG_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->OCURR_OccupantWeight_Stat = (uint8_t) ( (_d[0] & (0x03U)) );
  _m->OCURR_SeatOccupied_Stat = (uint8_t) ( ((_d[0] >> 2U) & (0x01U)) );
  _m->OCURR_SensorError_Stat = (uint8_t) ( ((_d[0] >> 3U) & (0x01U)) );
  _m->OCURR_MSG_RC = (uint8_t) ( ((_d[0] >> 4U) & (0x0FU)) );
  _m->OCURR_MSG_CS = (uint8_t) ( (_d[1] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < OCURR_MSG_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_OCURR_MSG_candb(&_m->mon1, OCURR_MSG_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return OCURR_MSG_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_OCURR_MSG_candb(OCURR_MSG_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(OCURR_MSG_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( (_m->OCURR_OccupantWeight_Stat & (0x03U)) | ((_m->OCURR_SeatOccupied_Stat & (0x01U)) << 2U) | ((_m->OCURR_SensorError_Stat & (0x01U)) << 3U) | ((_m->OCURR_MSG_RC & (0x0FU)) << 4U) );
  cframe->Data[1] |= (uint8_t) ( (_m->OCURR_MSG_CS & (0xFFU)) );

  cframe->MsgId = (uint32_t) OCURR_MSG_CANID;
  cframe->DLC = (uint8_t) OCURR_MSG_DLC;
  cframe->IDE = (uint8_t) OCURR_MSG_IDE;
  return OCURR_MSG_CANID;
}

#else

uint32_t Pack_OCURR_MSG_candb(OCURR_MSG_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(OCURR_MSG_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( (_m->OCURR_OccupantWeight_Stat & (0x03U)) | ((_m->OCURR_SeatOccupied_Stat & (0x01U)) << 2U) | ((_m->OCURR_SensorError_Stat & (0x01U)) << 3U) | ((_m->OCURR_MSG_RC & (0x0FU)) << 4U) );
  _d[1] |= (uint8_t) ( (_m->OCURR_MSG_CS & (0xFFU)) );

  *_len = (uint8_t) OCURR_MSG_DLC;
  *_ide = (uint8_t) OCURR_MSG_IDE;
  return OCURR_MSG_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_DW_STATE_candb(DW_STATE_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->DW_GlassPosition_Stat = (uint8_t) ( ((_d[1] >> 2U) & (0x03U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < DW_STATE_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_DW_STATE_candb(&_m->mon1, DW_STATE_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return DW_STATE_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_DW_STATE_candb(DW_STATE_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(DW_STATE_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[1] |= (uint8_t) ( ((_m->DW_GlassPosition_Stat & (0x03U)) << 2U) );

  cframe->MsgId = (uint32_t) DW_STATE_CANID;
  cframe->DLC = (uint8_t) DW_STATE_DLC;
  cframe->IDE = (uint8_t) DW_STATE_IDE;
  return DW_STATE_CANID;
}

#else

uint32_t Pack_DW_STATE_candb(DW_STATE_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(DW_STATE_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[1] |= (uint8_t) ( ((_m->DW_GlassPosition_Stat & (0x03U)) << 2U) );

  *_len = (uint8_t) DW_STATE_DLC;
  *_ide = (uint8_t) DW_STATE_IDE;
  return DW_STATE_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_FIU_CCU1_candb(FIU_CCU1_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->FIU_TargetTempFL_Val_ro = (uint8_t) ( (_d[0] & (0x1FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->FIU_TargetTempFL_Val_phys = (sigfloat_t)(CANDB_FIU_TargetTempFL_Val_ro_fromS(_m->FIU_TargetTempFL_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->FIU_FootTempCorFL_Req = (uint8_t) ( ((_d[0] >> 5U) & (0x07U)) );
  _m->FIU_TargetTempFR_Val_ro = (uint8_t) ( (_d[1] & (0x1FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->FIU_TargetTempFR_Val_phys = (sigfloat_t)(CANDB_FIU_TargetTempFR_Val_ro_fromS(_m->FIU_TargetTempFR_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->FIU_FootTempCorFR_Req = (uint8_t) ( ((_d[1] >> 5U) & (0x07U)) );
  _m->FIU_CCmodeFL_Req = (uint8_t) ( (_d[2] & (0x03U)) );
  _m->FIU_AirDirectionFL_Def_Req = (uint8_t) ( ((_d[2] >> 2U) & (0x03U)) );
  _m->FIU_AirDirectionFL_Face_Req = (uint8_t) ( ((_d[2] >> 4U) & (0x03U)) );
  _m->FIU_AirDirectionFL_Foot_Req = (uint8_t) ( ((_d[2] >> 6U) & (0x03U)) );
  _m->FIU_CCmodeFR_Req = (uint8_t) ( (_d[3] & (0x03U)) );
  _m->FIU_AirDirectionFR_Def_Req = (uint8_t) ( ((_d[3] >> 2U) & (0x03U)) );
  _m->FIU_AirDirectionFR_Face_Req = (uint8_t) ( ((_d[3] >> 4U) & (0x03U)) );
  _m->FIU_AirDirectionFR_Foot_Req = (uint8_t) ( ((_d[3] >> 6U) & (0x03U)) );
  _m->FIU_BlowerSpeedFL_Req = (uint8_t) ( (_d[4] & (0x0FU)) );
  _m->FIU_BlowerSpeedFR_Req = (uint8_t) ( ((_d[4] >> 4U) & (0x0FU)) );
  _m->FIU_CCautoModeFL_Req = (uint8_t) ( (_d[5] & (0x07U)) );
  _m->FIU_CCautoModeFR_Req = (uint8_t) ( ((_d[5] >> 3U) & (0x07U)) );
  _m->FIU_Recirculation_Req = (uint8_t) ( ((_d[5] >> 6U) & (0x03U)) );
  _m->FIU_DeflectorSwDL_Req = (uint8_t) ( (_d[6] & (0x07U)) );
  _m->FIU_DeflectorSwDR_Req = (uint8_t) ( ((_d[6] >> 3U) & (0x07U)) );
  _m->FIU_ACfrontOFF_Req = (uint8_t) ( ((_d[6] >> 6U) & (0x03U)) );
  _m->FIU_DeflectorSwFPL_Req = (uint8_t) ( (_d[7] & (0x07U)) );
  _m->FIU_DeflectorSwFPR_Req = (uint8_t) ( ((_d[7] >> 3U) & (0x07U)) );
  _m->FIU_FrontZoneSync_Req = (uint8_t) ( ((_d[7] >> 6U) & (0x03U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < FIU_CCU1_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_FIU_CCU1_candb(&_m->mon1, FIU_CCU1_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return FIU_CCU1_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_FIU_CCU1_candb(FIU_CCU1_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(FIU_CCU1_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->FIU_TargetTempFL_Val_ro = (uint8_t) CANDB_FIU_TargetTempFL_Val_ro_toS(_m->FIU_TargetTempFL_Val_phys);
  _m->FIU_TargetTempFR_Val_ro = (uint8_t) CANDB_FIU_TargetTempFR_Val_ro_toS(_m->FIU_TargetTempFR_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->FIU_TargetTempFL_Val_ro & (0x1FU)) | ((_m->FIU_FootTempCorFL_Req & (0x07U)) << 5U) );
  cframe->Data[1] |= (uint8_t) ( (_m->FIU_TargetTempFR_Val_ro & (0x1FU)) | ((_m->FIU_FootTempCorFR_Req & (0x07U)) << 5U) );
  cframe->Data[2] |= (uint8_t) ( (_m->FIU_CCmodeFL_Req & (0x03U)) | ((_m->FIU_AirDirectionFL_Def_Req & (0x03U)) << 2U) | ((_m->FIU_AirDirectionFL_Face_Req & (0x03U)) << 4U) | ((_m->FIU_AirDirectionFL_Foot_Req & (0x03U)) << 6U) );
  cframe->Data[3] |= (uint8_t) ( (_m->FIU_CCmodeFR_Req & (0x03U)) | ((_m->FIU_AirDirectionFR_Def_Req & (0x03U)) << 2U) | ((_m->FIU_AirDirectionFR_Face_Req & (0x03U)) << 4U) | ((_m->FIU_AirDirectionFR_Foot_Req & (0x03U)) << 6U) );
  cframe->Data[4] |= (uint8_t) ( (_m->FIU_BlowerSpeedFL_Req & (0x0FU)) | ((_m->FIU_BlowerSpeedFR_Req & (0x0FU)) << 4U) );
  cframe->Data[5] |= (uint8_t) ( (_m->FIU_CCautoModeFL_Req & (0x07U)) | ((_m->FIU_CCautoModeFR_Req & (0x07U)) << 3U) | ((_m->FIU_Recirculation_Req & (0x03U)) << 6U) );
  cframe->Data[6] |= (uint8_t) ( (_m->FIU_DeflectorSwDL_Req & (0x07U)) | ((_m->FIU_DeflectorSwDR_Req & (0x07U)) << 3U) | ((_m->FIU_ACfrontOFF_Req & (0x03U)) << 6U) );
  cframe->Data[7] |= (uint8_t) ( (_m->FIU_DeflectorSwFPL_Req & (0x07U)) | ((_m->FIU_DeflectorSwFPR_Req & (0x07U)) << 3U) | ((_m->FIU_FrontZoneSync_Req & (0x03U)) << 6U) );

  cframe->MsgId = (uint32_t) FIU_CCU1_CANID;
  cframe->DLC = (uint8_t) FIU_CCU1_DLC;
  cframe->IDE = (uint8_t) FIU_CCU1_IDE;
  return FIU_CCU1_CANID;
}

#else

uint32_t Pack_FIU_CCU1_candb(FIU_CCU1_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(FIU_CCU1_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->FIU_TargetTempFL_Val_ro = (uint8_t) CANDB_FIU_TargetTempFL_Val_ro_toS(_m->FIU_TargetTempFL_Val_phys);
  _m->FIU_TargetTempFR_Val_ro = (uint8_t) CANDB_FIU_TargetTempFR_Val_ro_toS(_m->FIU_TargetTempFR_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->FIU_TargetTempFL_Val_ro & (0x1FU)) | ((_m->FIU_FootTempCorFL_Req & (0x07U)) << 5U) );
  _d[1] |= (uint8_t) ( (_m->FIU_TargetTempFR_Val_ro & (0x1FU)) | ((_m->FIU_FootTempCorFR_Req & (0x07U)) << 5U) );
  _d[2] |= (uint8_t) ( (_m->FIU_CCmodeFL_Req & (0x03U)) | ((_m->FIU_AirDirectionFL_Def_Req & (0x03U)) << 2U) | ((_m->FIU_AirDirectionFL_Face_Req & (0x03U)) << 4U) | ((_m->FIU_AirDirectionFL_Foot_Req & (0x03U)) << 6U) );
  _d[3] |= (uint8_t) ( (_m->FIU_CCmodeFR_Req & (0x03U)) | ((_m->FIU_AirDirectionFR_Def_Req & (0x03U)) << 2U) | ((_m->FIU_AirDirectionFR_Face_Req & (0x03U)) << 4U) | ((_m->FIU_AirDirectionFR_Foot_Req & (0x03U)) << 6U) );
  _d[4] |= (uint8_t) ( (_m->FIU_BlowerSpeedFL_Req & (0x0FU)) | ((_m->FIU_BlowerSpeedFR_Req & (0x0FU)) << 4U) );
  _d[5] |= (uint8_t) ( (_m->FIU_CCautoModeFL_Req & (0x07U)) | ((_m->FIU_CCautoModeFR_Req & (0x07U)) << 3U) | ((_m->FIU_Recirculation_Req & (0x03U)) << 6U) );
  _d[6] |= (uint8_t) ( (_m->FIU_DeflectorSwDL_Req & (0x07U)) | ((_m->FIU_DeflectorSwDR_Req & (0x07U)) << 3U) | ((_m->FIU_ACfrontOFF_Req & (0x03U)) << 6U) );
  _d[7] |= (uint8_t) ( (_m->FIU_DeflectorSwFPL_Req & (0x07U)) | ((_m->FIU_DeflectorSwFPR_Req & (0x07U)) << 3U) | ((_m->FIU_FrontZoneSync_Req & (0x03U)) << 6U) );

  *_len = (uint8_t) FIU_CCU1_DLC;
  *_ide = (uint8_t) FIU_CCU1_IDE;
  return FIU_CCU1_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_FIU_CCU2_candb(FIU_CCU2_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->FIU_TargetTempRL_Val_ro = (uint8_t) ( (_d[0] & (0x1FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->FIU_TargetTempRL_Val_phys = (sigfloat_t)(CANDB_FIU_TargetTempRL_Val_ro_fromS(_m->FIU_TargetTempRL_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->FIU_FootTempCorRL_Req = (uint8_t) ( ((_d[0] >> 5U) & (0x07U)) );
  _m->FIU_TargetTempRR_Val_ro = (uint8_t) ( (_d[1] & (0x1FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->FIU_TargetTempRR_Val_phys = (sigfloat_t)(CANDB_FIU_TargetTempRR_Val_ro_fromS(_m->FIU_TargetTempRR_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->FIU_FootTempCorRR_Req = (uint8_t) ( ((_d[1] >> 5U) & (0x07U)) );
  _m->FIU_CCmodeRL_Req = (uint8_t) ( (_d[2] & (0x03U)) );
  _m->FIU_AirDirectionRL_Def_Req = (uint8_t) ( ((_d[2] >> 2U) & (0x03U)) );
  _m->FIU_AirDirectionRL_Face_Req = (uint8_t) ( ((_d[2] >> 4U) & (0x03U)) );
  _m->FIU_AirDirectionRL_Foot_Req = (uint8_t) ( ((_d[2] >> 6U) & (0x03U)) );
  _m->FIU_CCmodeRR_Req = (uint8_t) ( (_d[3] & (0x03U)) );
  _m->FIU_AirDirectionRR_Def_Req = (uint8_t) ( ((_d[3] >> 2U) & (0x03U)) );
  _m->FIU_AirDirectionRR_Face_Req = (uint8_t) ( ((_d[3] >> 4U) & (0x03U)) );
  _m->FIU_AirDirectionRR_Foot_Req = (uint8_t) ( ((_d[3] >> 6U) & (0x03U)) );
  _m->FIU_BlowerSpeedRL_Req = (uint8_t) ( (_d[4] & (0x0FU)) );
  _m->FIU_BlowerSpeedRR_Req = (uint8_t) ( ((_d[4] >> 4U) & (0x0FU)) );
  _m->FIU_CCautoModeRL_Req = (uint8_t) ( (_d[5] & (0x07U)) );
  _m->FIU_CCautoModeRR_Req = (uint8_t) ( ((_d[5] >> 3U) & (0x07U)) );
  _m->FIU_DeflectorSwRLB_Req = (uint8_t) ( (_d[6] & (0x07U)) );
  _m->FIU_DeflectorSwFCL_Req = (uint8_t) ( ((_d[6] >> 3U) & (0x07U)) );
  _m->FIU_ACrearOFF_Req = (uint8_t) ( ((_d[6] >> 6U) & (0x03U)) );
  _m->FIU_DeflectorSwFCR_Req = (uint8_t) ( (_d[7] & (0x07U)) );
  _m->FIU_DeflectorSwRRB_Req = (uint8_t) ( ((_d[7] >> 3U) & (0x07U)) );
  _m->FIU_RearZoneSync_Req = (uint8_t) ( ((_d[7] >> 6U) & (0x03U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < FIU_CCU2_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_FIU_CCU2_candb(&_m->mon1, FIU_CCU2_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return FIU_CCU2_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_FIU_CCU2_candb(FIU_CCU2_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(FIU_CCU2_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->FIU_TargetTempRL_Val_ro = (uint8_t) CANDB_FIU_TargetTempRL_Val_ro_toS(_m->FIU_TargetTempRL_Val_phys);
  _m->FIU_TargetTempRR_Val_ro = (uint8_t) CANDB_FIU_TargetTempRR_Val_ro_toS(_m->FIU_TargetTempRR_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->FIU_TargetTempRL_Val_ro & (0x1FU)) | ((_m->FIU_FootTempCorRL_Req & (0x07U)) << 5U) );
  cframe->Data[1] |= (uint8_t) ( (_m->FIU_TargetTempRR_Val_ro & (0x1FU)) | ((_m->FIU_FootTempCorRR_Req & (0x07U)) << 5U) );
  cframe->Data[2] |= (uint8_t) ( (_m->FIU_CCmodeRL_Req & (0x03U)) | ((_m->FIU_AirDirectionRL_Def_Req & (0x03U)) << 2U) | ((_m->FIU_AirDirectionRL_Face_Req & (0x03U)) << 4U) | ((_m->FIU_AirDirectionRL_Foot_Req & (0x03U)) << 6U) );
  cframe->Data[3] |= (uint8_t) ( (_m->FIU_CCmodeRR_Req & (0x03U)) | ((_m->FIU_AirDirectionRR_Def_Req & (0x03U)) << 2U) | ((_m->FIU_AirDirectionRR_Face_Req & (0x03U)) << 4U) | ((_m->FIU_AirDirectionRR_Foot_Req & (0x03U)) << 6U) );
  cframe->Data[4] |= (uint8_t) ( (_m->FIU_BlowerSpeedRL_Req & (0x0FU)) | ((_m->FIU_BlowerSpeedRR_Req & (0x0FU)) << 4U) );
  cframe->Data[5] |= (uint8_t) ( (_m->FIU_CCautoModeRL_Req & (0x07U)) | ((_m->FIU_CCautoModeRR_Req & (0x07U)) << 3U) );
  cframe->Data[6] |= (uint8_t) ( (_m->FIU_DeflectorSwRLB_Req & (0x07U)) | ((_m->FIU_DeflectorSwFCL_Req & (0x07U)) << 3U) | ((_m->FIU_ACrearOFF_Req & (0x03U)) << 6U) );
  cframe->Data[7] |= (uint8_t) ( (_m->FIU_DeflectorSwFCR_Req & (0x07U)) | ((_m->FIU_DeflectorSwRRB_Req & (0x07U)) << 3U) | ((_m->FIU_RearZoneSync_Req & (0x03U)) << 6U) );

  cframe->MsgId = (uint32_t) FIU_CCU2_CANID;
  cframe->DLC = (uint8_t) FIU_CCU2_DLC;
  cframe->IDE = (uint8_t) FIU_CCU2_IDE;
  return FIU_CCU2_CANID;
}

#else

uint32_t Pack_FIU_CCU2_candb(FIU_CCU2_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(FIU_CCU2_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->FIU_TargetTempRL_Val_ro = (uint8_t) CANDB_FIU_TargetTempRL_Val_ro_toS(_m->FIU_TargetTempRL_Val_phys);
  _m->FIU_TargetTempRR_Val_ro = (uint8_t) CANDB_FIU_TargetTempRR_Val_ro_toS(_m->FIU_TargetTempRR_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->FIU_TargetTempRL_Val_ro & (0x1FU)) | ((_m->FIU_FootTempCorRL_Req & (0x07U)) << 5U) );
  _d[1] |= (uint8_t) ( (_m->FIU_TargetTempRR_Val_ro & (0x1FU)) | ((_m->FIU_FootTempCorRR_Req & (0x07U)) << 5U) );
  _d[2] |= (uint8_t) ( (_m->FIU_CCmodeRL_Req & (0x03U)) | ((_m->FIU_AirDirectionRL_Def_Req & (0x03U)) << 2U) | ((_m->FIU_AirDirectionRL_Face_Req & (0x03U)) << 4U) | ((_m->FIU_AirDirectionRL_Foot_Req & (0x03U)) << 6U) );
  _d[3] |= (uint8_t) ( (_m->FIU_CCmodeRR_Req & (0x03U)) | ((_m->FIU_AirDirectionRR_Def_Req & (0x03U)) << 2U) | ((_m->FIU_AirDirectionRR_Face_Req & (0x03U)) << 4U) | ((_m->FIU_AirDirectionRR_Foot_Req & (0x03U)) << 6U) );
  _d[4] |= (uint8_t) ( (_m->FIU_BlowerSpeedRL_Req & (0x0FU)) | ((_m->FIU_BlowerSpeedRR_Req & (0x0FU)) << 4U) );
  _d[5] |= (uint8_t) ( (_m->FIU_CCautoModeRL_Req & (0x07U)) | ((_m->FIU_CCautoModeRR_Req & (0x07U)) << 3U) );
  _d[6] |= (uint8_t) ( (_m->FIU_DeflectorSwRLB_Req & (0x07U)) | ((_m->FIU_DeflectorSwFCL_Req & (0x07U)) << 3U) | ((_m->FIU_ACrearOFF_Req & (0x03U)) << 6U) );
  _d[7] |= (uint8_t) ( (_m->FIU_DeflectorSwFCR_Req & (0x07U)) | ((_m->FIU_DeflectorSwRRB_Req & (0x07U)) << 3U) | ((_m->FIU_RearZoneSync_Req & (0x03U)) << 6U) );

  *_len = (uint8_t) FIU_CCU2_DLC;
  *_ide = (uint8_t) FIU_CCU2_IDE;
  return FIU_CCU2_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_FIU_CCU3_candb(FIU_CCU3_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->FIU_Aroma_Req = (uint8_t) ( (_d[0] & (0x03U)) );
  _m->FIU_AromaIntens_Req = (uint8_t) ( ((_d[0] >> 2U) & (0x03U)) );
  _m->FIU_Rest_Req = (uint8_t) ( ((_d[0] >> 4U) & (0x03U)) );
  _m->FIU_Ionization_Req = (uint8_t) ( ((_d[0] >> 6U) & (0x03U)) );
  _m->FIU_RLfootBlowDis_Req = (uint8_t) ( (_d[1] & (0x03U)) );
  _m->FIU_RRfootBlowDis_Req = (uint8_t) ( ((_d[1] >> 2U) & (0x03U)) );
  _m->FIU_ACmax_Req = (uint8_t) ( ((_d[1] >> 4U) & (0x03U)) );
  _m->FIU_Defrost_Req = (uint8_t) ( ((_d[1] >> 6U) & (0x03U)) );
  _m->FIU_Ultraviolet_Req = (uint8_t) ( (_d[2] & (0x03U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < FIU_CCU3_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_FIU_CCU3_candb(&_m->mon1, FIU_CCU3_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return FIU_CCU3_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_FIU_CCU3_candb(FIU_CCU3_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(FIU_CCU3_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( (_m->FIU_Aroma_Req & (0x03U)) | ((_m->FIU_AromaIntens_Req & (0x03U)) << 2U) | ((_m->FIU_Rest_Req & (0x03U)) << 4U) | ((_m->FIU_Ionization_Req & (0x03U)) << 6U) );
  cframe->Data[1] |= (uint8_t) ( (_m->FIU_RLfootBlowDis_Req & (0x03U)) | ((_m->FIU_RRfootBlowDis_Req & (0x03U)) << 2U) | ((_m->FIU_ACmax_Req & (0x03U)) << 4U) | ((_m->FIU_Defrost_Req & (0x03U)) << 6U) );
  cframe->Data[2] |= (uint8_t) ( (_m->FIU_Ultraviolet_Req & (0x03U)) );

  cframe->MsgId = (uint32_t) FIU_CCU3_CANID;
  cframe->DLC = (uint8_t) FIU_CCU3_DLC;
  cframe->IDE = (uint8_t) FIU_CCU3_IDE;
  return FIU_CCU3_CANID;
}

#else

uint32_t Pack_FIU_CCU3_candb(FIU_CCU3_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(FIU_CCU3_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( (_m->FIU_Aroma_Req & (0x03U)) | ((_m->FIU_AromaIntens_Req & (0x03U)) << 2U) | ((_m->FIU_Rest_Req & (0x03U)) << 4U) | ((_m->FIU_Ionization_Req & (0x03U)) << 6U) );
  _d[1] |= (uint8_t) ( (_m->FIU_RLfootBlowDis_Req & (0x03U)) | ((_m->FIU_RRfootBlowDis_Req & (0x03U)) << 2U) | ((_m->FIU_ACmax_Req & (0x03U)) << 4U) | ((_m->FIU_Defrost_Req & (0x03U)) << 6U) );
  _d[2] |= (uint8_t) ( (_m->FIU_Ultraviolet_Req & (0x03U)) );

  *_len = (uint8_t) FIU_CCU3_DLC;
  *_ide = (uint8_t) FIU_CCU3_IDE;
  return FIU_CCU3_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_Diag_To_CCU_candb(Diag_To_CCU_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->Diag_To_CCU_Sig = (uint64_t) ( ((uint64_t)(_d[0] & (0xFFU)) << 56U) | ((uint64_t)(_d[1] & (0xFFU)) << 48U) | ((uint64_t)(_d[2] & (0xFFU)) << 40U) | ((uint64_t)(_d[3] & (0xFFU)) << 32U) | ((_d[4] & (0xFFU)) << 24U) | ((_d[5] & (0xFFU)) << 16U) | ((_d[6] & (0xFFU)) << 8U) | (_d[7] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < Diag_To_CCU_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_Diag_To_CCU_candb(&_m->mon1, Diag_To_CCU_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return Diag_To_CCU_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_Diag_To_CCU_candb(Diag_To_CCU_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(Diag_To_CCU_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 56U) & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 48U) & (0xFFU)) );
  cframe->Data[2] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 40U) & (0xFFU)) );
  cframe->Data[3] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 32U) & (0xFFU)) );
  cframe->Data[4] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 24U) & (0xFFU)) );
  cframe->Data[5] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 16U) & (0xFFU)) );
  cframe->Data[6] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 8U) & (0xFFU)) );
  cframe->Data[7] |= (uint8_t) ( (_m->Diag_To_CCU_Sig & (0xFFU)) );

  cframe->MsgId = (uint32_t) Diag_To_CCU_CANID;
  cframe->DLC = (uint8_t) Diag_To_CCU_DLC;
  cframe->IDE = (uint8_t) Diag_To_CCU_IDE;
  return Diag_To_CCU_CANID;
}

#else

uint32_t Pack_Diag_To_CCU_candb(Diag_To_CCU_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(Diag_To_CCU_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 56U) & (0xFFU)) );
  _d[1] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 48U) & (0xFFU)) );
  _d[2] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 40U) & (0xFFU)) );
  _d[3] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 32U) & (0xFFU)) );
  _d[4] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 24U) & (0xFFU)) );
  _d[5] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 16U) & (0xFFU)) );
  _d[6] |= (uint8_t) ( ((_m->Diag_To_CCU_Sig >> 8U) & (0xFFU)) );
  _d[7] |= (uint8_t) ( (_m->Diag_To_CCU_Sig & (0xFFU)) );

  *_len = (uint8_t) Diag_To_CCU_DLC;
  *_ide = (uint8_t) Diag_To_CCU_IDE;
  return Diag_To_CCU_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_Diag_From_CCU_candb(Diag_From_CCU_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->Diag_From_CCU_Sig = (uint64_t) ( ((uint64_t)(_d[0] & (0xFFU)) << 56U) | ((uint64_t)(_d[1] & (0xFFU)) << 48U) | ((uint64_t)(_d[2] & (0xFFU)) << 40U) | ((uint64_t)(_d[3] & (0xFFU)) << 32U) | ((_d[4] & (0xFFU)) << 24U) | ((_d[5] & (0xFFU)) << 16U) | ((_d[6] & (0xFFU)) << 8U) | (_d[7] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < Diag_From_CCU_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_Diag_From_CCU_candb(&_m->mon1, Diag_From_CCU_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return Diag_From_CCU_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_Diag_From_CCU_candb(Diag_From_CCU_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(Diag_From_CCU_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 56U) & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 48U) & (0xFFU)) );
  cframe->Data[2] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 40U) & (0xFFU)) );
  cframe->Data[3] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 32U) & (0xFFU)) );
  cframe->Data[4] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 24U) & (0xFFU)) );
  cframe->Data[5] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 16U) & (0xFFU)) );
  cframe->Data[6] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 8U) & (0xFFU)) );
  cframe->Data[7] |= (uint8_t) ( (_m->Diag_From_CCU_Sig & (0xFFU)) );

  cframe->MsgId = (uint32_t) Diag_From_CCU_CANID;
  cframe->DLC = (uint8_t) Diag_From_CCU_DLC;
  cframe->IDE = (uint8_t) Diag_From_CCU_IDE;
  return Diag_From_CCU_CANID;
}

#else

uint32_t Pack_Diag_From_CCU_candb(Diag_From_CCU_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(Diag_From_CCU_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 56U) & (0xFFU)) );
  _d[1] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 48U) & (0xFFU)) );
  _d[2] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 40U) & (0xFFU)) );
  _d[3] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 32U) & (0xFFU)) );
  _d[4] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 24U) & (0xFFU)) );
  _d[5] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 16U) & (0xFFU)) );
  _d[6] |= (uint8_t) ( ((_m->Diag_From_CCU_Sig >> 8U) & (0xFFU)) );
  _d[7] |= (uint8_t) ( (_m->Diag_From_CCU_Sig & (0xFFU)) );

  *_len = (uint8_t) Diag_From_CCU_DLC;
  *_ide = (uint8_t) Diag_From_CCU_IDE;
  return Diag_From_CCU_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_Diag_Functional_candb(Diag_Functional_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->Diag_Functional_Sig = (uint64_t) ( ((uint64_t)(_d[0] & (0xFFU)) << 56U) | ((uint64_t)(_d[1] & (0xFFU)) << 48U) | ((uint64_t)(_d[2] & (0xFFU)) << 40U) | ((uint64_t)(_d[3] & (0xFFU)) << 32U) | ((_d[4] & (0xFFU)) << 24U) | ((_d[5] & (0xFFU)) << 16U) | ((_d[6] & (0xFFU)) << 8U) | (_d[7] & (0xFFU)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < Diag_Functional_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_Diag_Functional_candb(&_m->mon1, Diag_Functional_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return Diag_Functional_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_Diag_Functional_candb(Diag_Functional_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(Diag_Functional_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

  cframe->Data[0] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 56U) & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 48U) & (0xFFU)) );
  cframe->Data[2] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 40U) & (0xFFU)) );
  cframe->Data[3] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 32U) & (0xFFU)) );
  cframe->Data[4] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 24U) & (0xFFU)) );
  cframe->Data[5] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 16U) & (0xFFU)) );
  cframe->Data[6] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 8U) & (0xFFU)) );
  cframe->Data[7] |= (uint8_t) ( (_m->Diag_Functional_Sig & (0xFFU)) );

  cframe->MsgId = (uint32_t) Diag_Functional_CANID;
  cframe->DLC = (uint8_t) Diag_Functional_DLC;
  cframe->IDE = (uint8_t) Diag_Functional_IDE;
  return Diag_Functional_CANID;
}

#else

uint32_t Pack_Diag_Functional_candb(Diag_Functional_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(Diag_Functional_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

  _d[0] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 56U) & (0xFFU)) );
  _d[1] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 48U) & (0xFFU)) );
  _d[2] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 40U) & (0xFFU)) );
  _d[3] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 32U) & (0xFFU)) );
  _d[4] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 24U) & (0xFFU)) );
  _d[5] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 16U) & (0xFFU)) );
  _d[6] |= (uint8_t) ( ((_m->Diag_Functional_Sig >> 8U) & (0xFFU)) );
  _d[7] |= (uint8_t) ( (_m->Diag_Functional_Sig & (0xFFU)) );

  *_len = (uint8_t) Diag_Functional_DLC;
  *_ide = (uint8_t) Diag_Functional_IDE;
  return Diag_Functional_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_HVC_01_candb(HVC_01_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->HVC_ActSpeed_Val = (uint16_t) ( ((_d[1] & (0xFFU)) << 8U) | (_d[0] & (0xFFU)) );
  _m->HVC_ActTemp_Val_ro = (uint8_t) ( (_d[2] & (0x7FU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_ActTemp_Val_phys = (int16_t) CANDB_HVC_ActTemp_Val_ro_fromS(_m->HVC_ActTemp_Val_ro);
#endif // CANDB_USE_SIGFLOAT

  _m->HVC_OvTemp_Stat = (uint8_t) ( ((_d[2] >> 7U) & (0x01U)) );
  _m->HVC_ActMode_Stat = (uint8_t) ( (_d[3] & (0x03U)) );
  _m->HVC_FaultLvl_Stat = (uint8_t) ( ((_d[3] >> 2U) & (0x03U)) );
  _m->HVC_OvSpeed_Stat = (uint8_t) ( ((_d[3] >> 4U) & (0x01U)) );
  _m->CCM2_LossStepErr_Stat = (uint8_t) ( ((_d[3] >> 5U) & (0x01U)) );
  _m->HVC_OvLoadErr_Stat = (uint8_t) ( ((_d[3] >> 6U) & (0x01U)) );
  _m->HVC_IGBTErr_Stat = (uint8_t) ( ((_d[3] >> 7U) & (0x01U)) );
  _m->HVC_ErrCode_Stat = (uint8_t) ( (_d[4] & (0xFFU)) );
  _m->HVC_PhaCurrA_Val_ro = (uint8_t) ( (_d[5] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_PhaCurrA_Val_phys = (sigfloat_t)(CANDB_HVC_PhaCurrA_Val_ro_fromS(_m->HVC_PhaCurrA_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->HVC_ActCurr_Val_ro = (uint8_t) ( (_d[6] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_ActCurr_Val_phys = (sigfloat_t)(CANDB_HVC_ActCurr_Val_ro_fromS(_m->HVC_ActCurr_Val_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->HVC_ActVolt_Val_ro = (uint8_t) ( (_d[7] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_ActVolt_Val_phys = (uint16_t) CANDB_HVC_ActVolt_Val_ro_fromS(_m->HVC_ActVolt_Val_ro);
#endif // CANDB_USE_SIGFLOAT

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < HVC_01_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_HVC_01_candb(&_m->mon1, HVC_01_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return HVC_01_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_HVC_01_candb(HVC_01_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(HVC_01_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_ActTemp_Val_ro = (uint8_t) CANDB_HVC_ActTemp_Val_ro_toS(_m->HVC_ActTemp_Val_phys);
  _m->HVC_PhaCurrA_Val_ro = (uint8_t) CANDB_HVC_PhaCurrA_Val_ro_toS(_m->HVC_PhaCurrA_Val_phys);
  _m->HVC_ActCurr_Val_ro = (uint8_t) CANDB_HVC_ActCurr_Val_ro_toS(_m->HVC_ActCurr_Val_phys);
  _m->HVC_ActVolt_Val_ro = (uint8_t) CANDB_HVC_ActVolt_Val_ro_toS(_m->HVC_ActVolt_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->HVC_ActSpeed_Val & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->HVC_ActSpeed_Val >> 8U) & (0xFFU)) );
  cframe->Data[2] |= (uint8_t) ( (_m->HVC_ActTemp_Val_ro & (0x7FU)) | ((_m->HVC_OvTemp_Stat & (0x01U)) << 7U) );
  cframe->Data[3] |= (uint8_t) ( (_m->HVC_ActMode_Stat & (0x03U)) | ((_m->HVC_FaultLvl_Stat & (0x03U)) << 2U) | ((_m->HVC_OvSpeed_Stat & (0x01U)) << 4U) | ((_m->CCM2_LossStepErr_Stat & (0x01U)) << 5U) | ((_m->HVC_OvLoadErr_Stat & (0x01U)) << 6U) | ((_m->HVC_IGBTErr_Stat & (0x01U)) << 7U) );
  cframe->Data[4] |= (uint8_t) ( (_m->HVC_ErrCode_Stat & (0xFFU)) );
  cframe->Data[5] |= (uint8_t) ( (_m->HVC_PhaCurrA_Val_ro & (0xFFU)) );
  cframe->Data[6] |= (uint8_t) ( (_m->HVC_ActCurr_Val_ro & (0xFFU)) );
  cframe->Data[7] |= (uint8_t) ( (_m->HVC_ActVolt_Val_ro & (0xFFU)) );

  cframe->MsgId = (uint32_t) HVC_01_CANID;
  cframe->DLC = (uint8_t) HVC_01_DLC;
  cframe->IDE = (uint8_t) HVC_01_IDE;
  return HVC_01_CANID;
}

#else

uint32_t Pack_HVC_01_candb(HVC_01_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(HVC_01_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->HVC_ActTemp_Val_ro = (uint8_t) CANDB_HVC_ActTemp_Val_ro_toS(_m->HVC_ActTemp_Val_phys);
  _m->HVC_PhaCurrA_Val_ro = (uint8_t) CANDB_HVC_PhaCurrA_Val_ro_toS(_m->HVC_PhaCurrA_Val_phys);
  _m->HVC_ActCurr_Val_ro = (uint8_t) CANDB_HVC_ActCurr_Val_ro_toS(_m->HVC_ActCurr_Val_phys);
  _m->HVC_ActVolt_Val_ro = (uint8_t) CANDB_HVC_ActVolt_Val_ro_toS(_m->HVC_ActVolt_Val_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->HVC_ActSpeed_Val & (0xFFU)) );
  _d[1] |= (uint8_t) ( ((_m->HVC_ActSpeed_Val >> 8U) & (0xFFU)) );
  _d[2] |= (uint8_t) ( (_m->HVC_ActTemp_Val_ro & (0x7FU)) | ((_m->HVC_OvTemp_Stat & (0x01U)) << 7U) );
  _d[3] |= (uint8_t) ( (_m->HVC_ActMode_Stat & (0x03U)) | ((_m->HVC_FaultLvl_Stat & (0x03U)) << 2U) | ((_m->HVC_OvSpeed_Stat & (0x01U)) << 4U) | ((_m->CCM2_LossStepErr_Stat & (0x01U)) << 5U) | ((_m->HVC_OvLoadErr_Stat & (0x01U)) << 6U) | ((_m->HVC_IGBTErr_Stat & (0x01U)) << 7U) );
  _d[4] |= (uint8_t) ( (_m->HVC_ErrCode_Stat & (0xFFU)) );
  _d[5] |= (uint8_t) ( (_m->HVC_PhaCurrA_Val_ro & (0xFFU)) );
  _d[6] |= (uint8_t) ( (_m->HVC_ActCurr_Val_ro & (0xFFU)) );
  _d[7] |= (uint8_t) ( (_m->HVC_ActVolt_Val_ro & (0xFFU)) );

  *_len = (uint8_t) HVC_01_DLC;
  *_ide = (uint8_t) HVC_01_IDE;
  return HVC_01_CANID;
}

#endif // CANDB_USE_CANSTRUCT

uint32_t Unpack_CCU_AC_Ctrl_candb(CCU_AC_Ctrl_t* _m, const uint8_t* _d, uint8_t dlc_)
{
  (void)dlc_;
  _m->CCU_VCU_ACSpeedReq = (uint16_t) ( ((_d[1] & (0xFFU)) << 8U) | (_d[0] & (0xFFU)) );
  _m->CCU_ACMaxPowerConsumptionAllow_ro = (uint8_t) ( (_d[2] & (0xFFU)) );
#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_ACMaxPowerConsumptionAllow_phys = (sigfloat_t)(CANDB_CCU_ACMaxPowerConsumptionAllow_ro_fromS(_m->CCU_ACMaxPowerConsumptionAllow_ro));
#endif // CANDB_USE_SIGFLOAT

  _m->CCU_VCU_AC_WorkReq = (uint8_t) ( (_d[3] & (0x01U)) );

#ifdef CANDB_USE_DIAG_MONITORS
  _m->mon1.dlc_error = (dlc_ < CCU_AC_Ctrl_DLC);
  _m->mon1.last_cycle = GetSystemTick();
  _m->mon1.frame_cnt++;

  FMon_CCU_AC_Ctrl_candb(&_m->mon1, CCU_AC_Ctrl_CANID);
#endif // CANDB_USE_DIAG_MONITORS

  return CCU_AC_Ctrl_CANID;
}

#ifdef CANDB_USE_CANSTRUCT

uint32_t Pack_CCU_AC_Ctrl_candb(CCU_AC_Ctrl_t* _m, __CoderDbcCanFrame_t__* cframe)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_AC_Ctrl_DLC); cframe->Data[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_ACMaxPowerConsumptionAllow_ro = (uint8_t) CANDB_CCU_ACMaxPowerConsumptionAllow_ro_toS(_m->CCU_ACMaxPowerConsumptionAllow_phys);
#endif // CANDB_USE_SIGFLOAT

  cframe->Data[0] |= (uint8_t) ( (_m->CCU_VCU_ACSpeedReq & (0xFFU)) );
  cframe->Data[1] |= (uint8_t) ( ((_m->CCU_VCU_ACSpeedReq >> 8U) & (0xFFU)) );
  cframe->Data[2] |= (uint8_t) ( (_m->CCU_ACMaxPowerConsumptionAllow_ro & (0xFFU)) );
  cframe->Data[3] |= (uint8_t) ( (_m->CCU_VCU_AC_WorkReq & (0x01U)) );

  cframe->MsgId = (uint32_t) CCU_AC_Ctrl_CANID;
  cframe->DLC = (uint8_t) CCU_AC_Ctrl_DLC;
  cframe->IDE = (uint8_t) CCU_AC_Ctrl_IDE;
  return CCU_AC_Ctrl_CANID;
}

#else

uint32_t Pack_CCU_AC_Ctrl_candb(CCU_AC_Ctrl_t* _m, uint8_t* _d, uint8_t* _len, uint8_t* _ide)
{
  uint8_t i; for (i = 0u; i < CANDB_VALIDATE_DLC(CCU_AC_Ctrl_DLC); _d[i++] = CANDB_INITIAL_BYTE_VALUE);

#ifdef CANDB_USE_SIGFLOAT
  _m->CCU_ACMaxPowerConsumptionAllow_ro = (uint8_t) CANDB_CCU_ACMaxPowerConsumptionAllow_ro_toS(_m->CCU_ACMaxPowerConsumptionAllow_phys);
#endif // CANDB_USE_SIGFLOAT

  _d[0] |= (uint8_t) ( (_m->CCU_VCU_ACSpeedReq & (0xFFU)) );
  _d[1] |= (uint8_t) ( ((_m->CCU_VCU_ACSpeedReq >> 8U) & (0xFFU)) );
  _d[2] |= (uint8_t) ( (_m->CCU_ACMaxPowerConsumptionAllow_ro & (0xFFU)) );
  _d[3] |= (uint8_t) ( (_m->CCU_VCU_AC_WorkReq & (0x01U)) );

  *_len = (uint8_t) CCU_AC_Ctrl_DLC;
  *_ide = (uint8_t) CCU_AC_Ctrl_IDE;
  return CCU_AC_Ctrl_CANID;
}

#endif // CANDB_USE_CANSTRUCT