Обновление

butl/ccu_candb_dbg-binutil.c

@@ -0,0 +1,29 @@
+// Generator version : v3.1
+// DBC filename      : CCUdbg.dbc
+#include "ccu_candb_dbg-binutil.h"
+
+// DBC file version
+#if (VER_CANDB_DBG_MAJ != (0U)) || (VER_CANDB_DBG_MIN != (0U))
+#error The CCU_CANDB_DBG binutil source file has inconsistency with core dbc lib!
+#endif
+
+#ifdef __DEF_CCU_CANDB_DBG__
+
+ccu_candb_dbg_rx_t ccu_candb_dbg_rx;
+
+ccu_candb_dbg_tx_t ccu_candb_dbg_tx;
+
+#endif // __DEF_CCU_CANDB_DBG__
+
+uint32_t ccu_candb_dbg_Receive(ccu_candb_dbg_rx_t* _m, const uint8_t* _d, uint32_t _id, uint8_t dlc_)
+{
+ uint32_t recid = 0;
+ if (_id == 0x400U) {
+  recid = Unpack_dbg_Cmd_Act_Information_candb_dbg(&(_m->dbg_Cmd_Act_Information), _d, dlc_);
+ } else if (_id == 0x6ABU) {
+  recid = Unpack_XCP_CCU_RX_candb_dbg(&(_m->XCP_CCU_RX), _d, dlc_);
+ }
+
+ return recid;
+}
+

butl/ccu_candb_dbg-binutil.h

@@ -0,0 +1,65 @@
+// Generator version : v3.1
+// DBC filename      : CCUdbg.dbc
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "dbccodeconf.h"
+
+#include "candb_dbg.h"
+
+typedef struct
+{
+  dbg_Cmd_Act_Information_t dbg_Cmd_Act_Information;
+  XCP_CCU_RX_t XCP_CCU_RX;
+} ccu_candb_dbg_rx_t;
+
+typedef struct
+{
+  dbg_Logic_State_t dbg_Logic_State;
+  dbg_Logic_KM_Status_t dbg_Logic_KM_Status;
+  dbg_Logic_Valve_t dbg_Logic_Valve;
+  dbg_Logic_Blower_t dbg_Logic_Blower;
+  dbg_Logic_Ac_t dbg_Logic_Ac;
+  dbg_Logic_Rec_t dbg_Logic_Rec;
+  dbg_DiffBlr_ValveOpen_t dbg_DiffBlr_ValveOpen;
+  dbg_Act0_t dbg_Act0;
+  dbg_Act1_t dbg_Act1;
+  dbg_Act2_t dbg_Act2;
+  dbg_Sen_Amb_t dbg_Sen_Amb;
+  dbg_Sen_0_t dbg_Sen_0;
+  dbg_CCU_IO_t dbg_CCU_IO;
+  dbg_CCU_Info_t dbg_CCU_Info;
+  dbg_Drs_t dbg_Drs;
+  dbg_Sen_Incar_t dbg_Sen_Incar;
+  dbg_Info_Act1_t dbg_Info_Act1;
+  dbg_Info_Act2_t dbg_Info_Act2;
+  dbg_Sen_Eva_t dbg_Sen_Eva;
+  dbg_Sen_Duct_t dbg_Sen_Duct;
+  dbg_Sen_Demist_t dbg_Sen_Demist;
+  dbg_LIN_AirQS_Stat_t dbg_LIN_AirQS_Stat;
+  dbg_LIN_Aroma_Stat_t dbg_LIN_Aroma_Stat;
+  dbg_LIN_Ionizer_Stat_t dbg_LIN_Ionizer_Stat;
+  dbg_LIN_eTXV_Stat_t dbg_LIN_eTXV_Stat;
+  dbg_LIN_DRS_Stat_t dbg_LIN_DRS_Stat;
+  dbg_Auto_AF_t dbg_Auto_AF;
+  dbg_Auto_Duct_t dbg_Auto_Duct;
+  dbg_Auto_Valve_Plus_t dbg_Auto_Valve_Plus;
+  XCP_CCU_TX_t XCP_CCU_TX;
+} ccu_candb_dbg_tx_t;
+
+uint32_t ccu_candb_dbg_Receive(ccu_candb_dbg_rx_t* m, const uint8_t* d, uint32_t msgid, uint8_t dlc);
+
+#ifdef __DEF_CCU_CANDB_DBG__
+
+extern ccu_candb_dbg_rx_t ccu_candb_dbg_rx;
+
+extern ccu_candb_dbg_tx_t ccu_candb_dbg_tx;
+
+#endif // __DEF_CCU_CANDB_DBG__
+
+#ifdef __cplusplus
+}
+#endif

butl/tester_candb_dbg-binutil.c

@@ -0,0 +1,27 @@
+// Generator version : v3.1
+// DBC filename      : CCUdbg.dbc
+#include "tester_candb_dbg-binutil.h"
+
+// DBC file version
+#if (VER_CANDB_DBG_MAJ != (0U)) || (VER_CANDB_DBG_MIN != (0U))
+#error The TESTER_CANDB_DBG binutil source file has inconsistency with core dbc lib!
+#endif
+
+#ifdef __DEF_TESTER_CANDB_DBG__
+
+tester_candb_dbg_rx_t tester_candb_dbg_rx;
+
+tester_candb_dbg_tx_t tester_candb_dbg_tx;
+
+#endif // __DEF_TESTER_CANDB_DBG__
+
+uint32_t tester_candb_dbg_Receive(tester_candb_dbg_rx_t* _m, const uint8_t* _d, uint32_t _id, uint8_t dlc_)
+{
+ uint32_t recid = 0;
+ if (_id == 0x6ABU) {
+  recid = Unpack_XCP_CCU_RX_candb_dbg(&(_m->XCP_CCU_RX), _d, dlc_);
+ }
+
+ return recid;
+}
+

butl/tester_candb_dbg-binutil.h

@@ -0,0 +1,36 @@
+// Generator version : v3.1
+// DBC filename      : CCUdbg.dbc
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "dbccodeconf.h"
+
+#include "candb_dbg.h"
+
+typedef struct
+{
+  XCP_CCU_RX_t XCP_CCU_RX;
+} tester_candb_dbg_rx_t;
+
+typedef struct
+{
+  dbg_Cmd_Act_Information_t dbg_Cmd_Act_Information;
+  XCP_CCU_RX_t XCP_CCU_RX;
+} tester_candb_dbg_tx_t;
+
+uint32_t tester_candb_dbg_Receive(tester_candb_dbg_rx_t* m, const uint8_t* d, uint32_t msgid, uint8_t dlc);
+
+#ifdef __DEF_TESTER_CANDB_DBG__
+
+extern tester_candb_dbg_rx_t tester_candb_dbg_rx;
+
+extern tester_candb_dbg_tx_t tester_candb_dbg_tx;
+
+#endif // __DEF_TESTER_CANDB_DBG__
+
+#ifdef __cplusplus
+}
+#endif

butl/vector__xxx_candb_dbg-binutil.c

@@ -0,0 +1,139 @@
+// Generator version : v3.1
+// DBC filename      : CCUdbg.dbc
+#include "vector__xxx_candb_dbg-binutil.h"
+
+// DBC file version
+#if (VER_CANDB_DBG_MAJ != (0U)) || (VER_CANDB_DBG_MIN != (0U))
+#error The VECTOR__XXX_CANDB_DBG binutil source file has inconsistency with core dbc lib!
+#endif
+
+#ifdef __DEF_VECTOR__XXX_CANDB_DBG__
+
+vector__xxx_candb_dbg_rx_t vector__xxx_candb_dbg_rx;
+
+#endif // __DEF_VECTOR__XXX_CANDB_DBG__
+
+uint32_t vector__xxx_candb_dbg_Receive(vector__xxx_candb_dbg_rx_t* _m, const uint8_t* _d, uint32_t _id, uint8_t dlc_)
+{
+ uint32_t recid = 0;
+ if ((_id >= 0x3E0U) && (_id < 0x3FFU)) {
+  if ((_id >= 0x3E0U) && (_id < 0x3F0U)) {
+   if ((_id >= 0x3E0U) && (_id < 0x3E3U)) {
+    if (_id == 0x3E0U) {
+     recid = Unpack_dbg_Logic_State_candb_dbg(&(_m->dbg_Logic_State), _d, dlc_);
+    } else {
+     if (_id == 0x3E1U) {
+      recid = Unpack_dbg_Logic_KM_Status_candb_dbg(&(_m->dbg_Logic_KM_Status), _d, dlc_);
+     } else if (_id == 0x3E2U) {
+      recid = Unpack_dbg_Logic_Valve_candb_dbg(&(_m->dbg_Logic_Valve), _d, dlc_);
+     }
+    }
+   } else {
+    if ((_id >= 0x3E3U) && (_id < 0x3E5U)) {
+     if (_id == 0x3E3U) {
+      recid = Unpack_dbg_Logic_Blower_candb_dbg(&(_m->dbg_Logic_Blower), _d, dlc_);
+     } else if (_id == 0x3E4U) {
+      recid = Unpack_dbg_Logic_Ac_candb_dbg(&(_m->dbg_Logic_Ac), _d, dlc_);
+     }
+    } else {
+     if (_id == 0x3E5U) {
+      recid = Unpack_dbg_Logic_Rec_candb_dbg(&(_m->dbg_Logic_Rec), _d, dlc_);
+     } else if (_id == 0x3E6U) {
+      recid = Unpack_dbg_DiffBlr_ValveOpen_candb_dbg(&(_m->dbg_DiffBlr_ValveOpen), _d, dlc_);
+     }
+    }
+   }
+  } else {
+   if ((_id >= 0x3F0U) && (_id < 0x3F8U)) {
+    if ((_id >= 0x3F0U) && (_id < 0x3F2U)) {
+     if (_id == 0x3F0U) {
+      recid = Unpack_dbg_Act0_candb_dbg(&(_m->dbg_Act0), _d, dlc_);
+     } else if (_id == 0x3F1U) {
+      recid = Unpack_dbg_Act1_candb_dbg(&(_m->dbg_Act1), _d, dlc_);
+     }
+    } else {
+     if (_id == 0x3F2U) {
+      recid = Unpack_dbg_Act2_candb_dbg(&(_m->dbg_Act2), _d, dlc_);
+     } else if (_id == 0x3F3U) {
+      recid = Unpack_dbg_Sen_Amb_candb_dbg(&(_m->dbg_Sen_Amb), _d, dlc_);
+     }
+    }
+   } else {
+    if ((_id >= 0x3F8U) && (_id < 0x3FCU)) {
+     if (_id == 0x3F8U) {
+      recid = Unpack_dbg_Sen_0_candb_dbg(&(_m->dbg_Sen_0), _d, dlc_);
+     } else if (_id == 0x3FBU) {
+      recid = Unpack_dbg_CCU_IO_candb_dbg(&(_m->dbg_CCU_IO), _d, dlc_);
+     }
+    } else {
+     if (_id == 0x3FCU) {
+      recid = Unpack_dbg_CCU_Info_candb_dbg(&(_m->dbg_CCU_Info), _d, dlc_);
+     } else if (_id == 0x3FDU) {
+      recid = Unpack_dbg_Drs_candb_dbg(&(_m->dbg_Drs), _d, dlc_);
+     }
+    }
+   }
+  }
+ } else {
+  if ((_id >= 0x3FFU) && (_id < 0x511U)) {
+   if ((_id >= 0x3FFU) && (_id < 0x504U)) {
+    if (_id == 0x3FFU) {
+     recid = Unpack_dbg_Sen_Incar_candb_dbg(&(_m->dbg_Sen_Incar), _d, dlc_);
+    } else {
+     if (_id == 0x401U) {
+      recid = Unpack_dbg_Info_Act1_candb_dbg(&(_m->dbg_Info_Act1), _d, dlc_);
+     } else if (_id == 0x402U) {
+      recid = Unpack_dbg_Info_Act2_candb_dbg(&(_m->dbg_Info_Act2), _d, dlc_);
+     }
+    }
+   } else {
+    if ((_id >= 0x504U) && (_id < 0x509U)) {
+     if (_id == 0x504U) {
+      recid = Unpack_dbg_Sen_Eva_candb_dbg(&(_m->dbg_Sen_Eva), _d, dlc_);
+     } else if (_id == 0x505U) {
+      recid = Unpack_dbg_Sen_Duct_candb_dbg(&(_m->dbg_Sen_Duct), _d, dlc_);
+     }
+    } else {
+     if (_id == 0x509U) {
+      recid = Unpack_dbg_Sen_Demist_candb_dbg(&(_m->dbg_Sen_Demist), _d, dlc_);
+     } else if (_id == 0x510U) {
+      recid = Unpack_dbg_LIN_AirQS_Stat_candb_dbg(&(_m->dbg_LIN_AirQS_Stat), _d, dlc_);
+     }
+    }
+   }
+  } else {
+   if ((_id >= 0x511U) && (_id < 0x520U)) {
+    if ((_id >= 0x511U) && (_id < 0x514U)) {
+     if (_id == 0x511U) {
+      recid = Unpack_dbg_LIN_Aroma_Stat_candb_dbg(&(_m->dbg_LIN_Aroma_Stat), _d, dlc_);
+     } else if (_id == 0x513U) {
+      recid = Unpack_dbg_LIN_Ionizer_Stat_candb_dbg(&(_m->dbg_LIN_Ionizer_Stat), _d, dlc_);
+     }
+    } else {
+     if (_id == 0x514U) {
+      recid = Unpack_dbg_LIN_eTXV_Stat_candb_dbg(&(_m->dbg_LIN_eTXV_Stat), _d, dlc_);
+     } else if (_id == 0x518U) {
+      recid = Unpack_dbg_LIN_DRS_Stat_candb_dbg(&(_m->dbg_LIN_DRS_Stat), _d, dlc_);
+     }
+    }
+   } else {
+    if ((_id >= 0x520U) && (_id < 0x530U)) {
+     if (_id == 0x520U) {
+      recid = Unpack_dbg_Auto_AF_candb_dbg(&(_m->dbg_Auto_AF), _d, dlc_);
+     } else if (_id == 0x524U) {
+      recid = Unpack_dbg_Auto_Duct_candb_dbg(&(_m->dbg_Auto_Duct), _d, dlc_);
+     }
+    } else {
+     if (_id == 0x530U) {
+      recid = Unpack_dbg_Auto_Valve_Plus_candb_dbg(&(_m->dbg_Auto_Valve_Plus), _d, dlc_);
+     } else if (_id == 0x6BBU) {
+      recid = Unpack_XCP_CCU_TX_candb_dbg(&(_m->XCP_CCU_TX), _d, dlc_);
+     }
+    }
+   }
+  }
+ }
+
+ return recid;
+}
+

butl/vector__xxx_candb_dbg-binutil.h

@@ -0,0 +1,59 @@
+// Generator version : v3.1
+// DBC filename      : CCUdbg.dbc
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "dbccodeconf.h"
+
+#include "candb_dbg.h"
+
+typedef struct
+{
+  dbg_Logic_State_t dbg_Logic_State;
+  dbg_Logic_KM_Status_t dbg_Logic_KM_Status;
+  dbg_Logic_Valve_t dbg_Logic_Valve;
+  dbg_Logic_Blower_t dbg_Logic_Blower;
+  dbg_Logic_Ac_t dbg_Logic_Ac;
+  dbg_Logic_Rec_t dbg_Logic_Rec;
+  dbg_DiffBlr_ValveOpen_t dbg_DiffBlr_ValveOpen;
+  dbg_Act0_t dbg_Act0;
+  dbg_Act1_t dbg_Act1;
+  dbg_Act2_t dbg_Act2;
+  dbg_Sen_Amb_t dbg_Sen_Amb;
+  dbg_Sen_0_t dbg_Sen_0;
+  dbg_CCU_IO_t dbg_CCU_IO;
+  dbg_CCU_Info_t dbg_CCU_Info;
+  dbg_Drs_t dbg_Drs;
+  dbg_Sen_Incar_t dbg_Sen_Incar;
+  dbg_Info_Act1_t dbg_Info_Act1;
+  dbg_Info_Act2_t dbg_Info_Act2;
+  dbg_Sen_Eva_t dbg_Sen_Eva;
+  dbg_Sen_Duct_t dbg_Sen_Duct;
+  dbg_Sen_Demist_t dbg_Sen_Demist;
+  dbg_LIN_AirQS_Stat_t dbg_LIN_AirQS_Stat;
+  dbg_LIN_Aroma_Stat_t dbg_LIN_Aroma_Stat;
+  dbg_LIN_Ionizer_Stat_t dbg_LIN_Ionizer_Stat;
+  dbg_LIN_eTXV_Stat_t dbg_LIN_eTXV_Stat;
+  dbg_LIN_DRS_Stat_t dbg_LIN_DRS_Stat;
+  dbg_Auto_AF_t dbg_Auto_AF;
+  dbg_Auto_Duct_t dbg_Auto_Duct;
+  dbg_Auto_Valve_Plus_t dbg_Auto_Valve_Plus;
+  XCP_CCU_TX_t XCP_CCU_TX;
+} vector__xxx_candb_dbg_rx_t;
+
+// There is no any TX mapped massage.
+
+uint32_t vector__xxx_candb_dbg_Receive(vector__xxx_candb_dbg_rx_t* m, const uint8_t* d, uint32_t msgid, uint8_t dlc);
+
+#ifdef __DEF_VECTOR__XXX_CANDB_DBG__
+
+extern vector__xxx_candb_dbg_rx_t vector__xxx_candb_dbg_rx;
+
+#endif // __DEF_VECTOR__XXX_CANDB_DBG__
+
+#ifdef __cplusplus
+}
+#endif

conf/candb_dbg-config.h

@@ -0,0 +1,130 @@
+// Generator version : v3.1
+// DBC filename      : CCUdbg.dbc
+#pragma once
+
+/* include common dbccode configurations */
+#include "dbccodeconf.h"
+
+
+/* ------------------------------------------------------------------------- *
+  This define enables using CAN message structs with bit-fielded signals
+  layout.
+
+  Note(!): bit-feild was not tested properly. */
+
+/* #define CANDB_DBG_USE_BITS_SIGNAL */
+
+
+/* ------------------------------------------------------------------------- *
+  This macro enables using CAN message descriptive struct packing functions
+  (by default signature of pack function intakes a few simple typed params
+  for loading data, len, etc). To compile you need to define the struct
+  __CoderDbcCanFrame_t__ which must have fields:
+
+    u32 MsgId (CAN Frame message ID)
+    u8 DLC (CAN Frame payload length field)
+    u8 Data[8] (CAN Frame payload data)
+    u8 IDE (CAN Frame Extended (1) / Standard (0) ID type)
+
+  This struct definition have to be placed (or be included) in dbccodeconf.h */
+
+/* #define CANDB_DBG_USE_CANSTRUCT */
+
+
+/* ------------------------------------------------------------------------- *
+  All the signals which have values of factor != 1 or offset != 0
+  will be named in message struct with posfix '_ro'. Pack to payload
+  operations will be made on this signal value as well as unpack from payload.
+
+  USE_SIGFLOAT macro makes some difference:
+
+  1. All the '_ro' fields will have a pair field with '_phys' postfix.
+  If only offset != 0 is true then the type of '_phys' signal is the same
+  as '_ro' signal. In other case the type will be @sigfloat_t which
+  have to be defined in user dbccodeconf.h
+
+  2. In pack function '_ro' signal will be rewritten by '_phys' signal, which
+  requires from user to use ONLY '_phys' signal for packing frame
+
+  3. In unpack function '_phys' signal will be written by '_ro' signal.
+  User have to use '_phys' signal to read physical value. */
+
+/* #define CANDB_DBG_USE_SIGFLOAT */
+
+
+/* ------------------------------------------------------------------------- *
+  Note(!) that the "canmonitorutil.h" must be accessed in include path:
+
+  This macro adds:
+
+  - monitor field @mon1 to message struct
+
+  - capture system tick in unpack function and save value to mon1 field
+  to provide to user better missing frame detection code. For this case
+  user must provide function declared in canmonitorutil.h - GetSysTick()
+  which may return 1ms uptime.
+
+  - calling function FMon_***  (from 'fmon' driver) inside unpack function
+  which is empty by default and have to be filled by user if
+  tests for DLC, rolling, checksum are necessary */
+
+/* #define CANDB_DBG_USE_DIAG_MONITORS */
+
+
+/* ------------------------------------------------------------------------- *
+  When monitor using is enabled (CANDB_DBG_USE_DIAG_MONITORS) and define below
+  uncommented, additional signal will be added to message struct. ***_expt:
+  expected rolling counter, to perform monitoring rolling counter sequence
+  automatically (result may be tested in dedicated Fmon_*** function) */
+
+/* #define CANDB_DBG_AUTO_ROLL */
+
+
+/* ------------------------------------------------------------------------- *
+  When monitor using is enabled (CANDB_DBG_USE_DIAG_MONITORS) and define below
+  uncommented, frame checksum signal may be handled automatically.
+
+  The signal which may be marked as checksum signal must have substring
+  with next format:
+    <Checksum:XOR8:3>
+
+  where:
+
+  - "Checksum": constant marker word
+
+  - "XOR8": type of method, this text will be passed to GetFrameHash
+  (canmonitorutil.h) function as is, the best use case is to define 'enum
+  DbcCanCrcMethods' in canmonitorutil.h file with all possible
+  checksum algorithms (e.g. XOR8, XOR4 etc)
+
+  - "3": optional value that will be passed to GetFrameHash as integer value
+
+  Function GetFrameHash have to be implemented by user
+
+  In pack function checksum signal will be calculated automatically
+  and loaded to payload
+
+  In unpack function checksum signal is checked with calculated.
+  (result may be tested in dedicated Fmon_*** function). */
+
+/* #define CANDB_DBG_AUTO_CSM */
+
+
+/* ------------------------------------------------------------------------- *
+  FMon handling model can be build in two ways: 
+
+  1 - Default. In this case when specific frame unpack is called the 
+  specific FMon_{Frame name}_{driver name} functoin will be called.
+  User's code scope has to define each of these functions. Each function is
+  responsible for the error handling of one frame
+
+  2 - MONO. In this case there is only one function to perform any frame 
+  monitoring. This function has to be implemented in the user's code scope.
+  This function is named as FMon_MONO_{driver name}. It takes frame id
+  which can be used for selection of the logic for a frame monitoring.
+  This mode costs a bit more in runtime but when you often edit you DBC and you 
+  have more than one project it could be more maintanable (there is
+  no necessity to replace source code)
+
+  For using MONO way uncomment line below */
+/* #define CANDB_DBG_USE_MONO_FMON */

conf/dbccodeconf.h

@@ -0,0 +1,31 @@
+// Generator version : v3.1
+#pragma once
+
+#include <stdint.h>
+
+// when USE_SIGFLOAT enabed the sigfloat_t must be defined
+// typedef double sigfloat_t;
+
+// when USE_CANSTRUCT enabled __CoderDbcCanFrame_t__ must be defined
+// #include "{header_with_can_struct}"
+// typedef {can_struct} __CoderDbcCanFrame_t__;
+
+// if you need to allocate rx and tx messages structs put the allocation macro here
+// #define __DEF_{your_driver_name}__
+
+// defualt @__ext_sig__ help types definition
+
+typedef uint32_t ubitext_t;
+typedef int32_t bitext_t;
+
+// To provide a way to make missing control correctly you
+// have to define macro @GetSystemTick() which has to
+// return kind of tick counter (e.g. 1 ms ticker)
+
+// #define GetSystemTick() __get__tick__()
+
+// To provide a way to calculate hash (crc) for CAN
+// frame's data field you have to define macro @GetFrameHash
+
+// #define GetFrameHash(a,b,c,d,e) __get_hash__(a,b,c,d,e)
+

inc/canmonitorutil.h

@@ -0,0 +1,54 @@
+// Generator version : v3.1
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// declare here all availible checksum algorithms
+typedef enum
+{
+  // XOR8 = 0,
+  // XOR4 = 1,
+  // etc
+
+  // it is up to user to have or to skip final enum value - @CRC_ALG_COUNT
+  CRC_ALG_COUNT
+} DbcCanCrcMethods;
+
+typedef struct
+{
+  // @last_cycle keeps tick-value when last frame was received
+  uint32_t last_cycle;
+
+  // @timeout_cycle keeps maximum timeout for frame, user responsibility
+  // to init this field and use it in missing frame monitoring function
+  uint32_t timeout_cycle;
+
+  // @frame_cnt keeps count of all the received frames
+  uint32_t frame_cnt;
+
+  // setting up @roll_error bit indicates roll counting fail.
+  // Bit is not clearing automatically!
+  uint32_t roll_error : 1;
+
+  // setting up @checksum_error bit indicates checksum checking failure.
+  // Bit is not clearing automatically!
+  uint32_t csm_error : 1;
+
+  // setting up @cycle_error bit indicates that time was overrunned.
+  // Bit is not clearing automatically!
+  uint32_t cycle_error : 1;
+
+  // setting up @dlc_error bit indicates that the actual length of
+  // CAN frame is less then defined by CAN matrix!
+  uint32_t dlc_error : 1;
+
+} FrameMonitor_t;
+
+#ifdef __cplusplus
+}
+#endif
+

lib/candb_dbg-fmon.h

@@ -0,0 +1,136 @@
+// Generator version : v3.1
+// DBC filename      : CCUdbg.dbc
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// DBC file version
+#define VER_CANDB_DBG_MAJ_FMON (0U)
+#define VER_CANDB_DBG_MIN_FMON (0U)
+
+#include "candb_dbg-config.h"
+
+#ifdef CANDB_DBG_USE_DIAG_MONITORS
+
+#include "canmonitorutil.h"
+/*
+This file contains the prototypes of all the functions that will be called
+from each Unpack_*name* function to detect DBC related errors
+It is the user responsibility to defined these functions in the
+separated .c file. If it won't be done the linkage error will happen
+*/
+
+#ifdef CANDB_DBG_USE_MONO_FMON
+
+void _FMon_MONO_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+
+#define FMon_dbg_Logic_State_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Logic_KM_Status_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Logic_Valve_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Logic_Blower_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Logic_Ac_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Logic_Rec_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_DiffBlr_ValveOpen_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Act0_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Act1_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Act2_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Sen_Amb_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Sen_0_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_CCU_IO_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_CCU_Info_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Drs_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Sen_Incar_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Cmd_Act_Information_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Info_Act1_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Info_Act2_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Sen_Eva_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Sen_Duct_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Sen_Demist_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_LIN_AirQS_Stat_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_LIN_Aroma_Stat_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_LIN_Ionizer_Stat_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_LIN_eTXV_Stat_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_LIN_DRS_Stat_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Auto_AF_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Auto_Duct_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_dbg_Auto_Valve_Plus_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_XCP_CCU_RX_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+#define FMon_XCP_CCU_TX_candb_dbg(x, y) _FMon_MONO_candb_dbg((x), (y))
+
+#else
+
+void _FMon_dbg_Logic_State_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Logic_KM_Status_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Logic_Valve_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Logic_Blower_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Logic_Ac_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Logic_Rec_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_DiffBlr_ValveOpen_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Act0_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Act1_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Act2_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Sen_Amb_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Sen_0_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_CCU_IO_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_CCU_Info_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Drs_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Sen_Incar_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Cmd_Act_Information_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Info_Act1_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Info_Act2_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Sen_Eva_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Sen_Duct_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Sen_Demist_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_LIN_AirQS_Stat_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_LIN_Aroma_Stat_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_LIN_Ionizer_Stat_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_LIN_eTXV_Stat_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_LIN_DRS_Stat_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Auto_AF_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Auto_Duct_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_dbg_Auto_Valve_Plus_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_XCP_CCU_RX_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+void _FMon_XCP_CCU_TX_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid);
+
+#define FMon_dbg_Logic_State_candb_dbg(x, y) _FMon_dbg_Logic_State_candb_dbg((x), (y))
+#define FMon_dbg_Logic_KM_Status_candb_dbg(x, y) _FMon_dbg_Logic_KM_Status_candb_dbg((x), (y))
+#define FMon_dbg_Logic_Valve_candb_dbg(x, y) _FMon_dbg_Logic_Valve_candb_dbg((x), (y))
+#define FMon_dbg_Logic_Blower_candb_dbg(x, y) _FMon_dbg_Logic_Blower_candb_dbg((x), (y))
+#define FMon_dbg_Logic_Ac_candb_dbg(x, y) _FMon_dbg_Logic_Ac_candb_dbg((x), (y))
+#define FMon_dbg_Logic_Rec_candb_dbg(x, y) _FMon_dbg_Logic_Rec_candb_dbg((x), (y))
+#define FMon_dbg_DiffBlr_ValveOpen_candb_dbg(x, y) _FMon_dbg_DiffBlr_ValveOpen_candb_dbg((x), (y))
+#define FMon_dbg_Act0_candb_dbg(x, y) _FMon_dbg_Act0_candb_dbg((x), (y))
+#define FMon_dbg_Act1_candb_dbg(x, y) _FMon_dbg_Act1_candb_dbg((x), (y))
+#define FMon_dbg_Act2_candb_dbg(x, y) _FMon_dbg_Act2_candb_dbg((x), (y))
+#define FMon_dbg_Sen_Amb_candb_dbg(x, y) _FMon_dbg_Sen_Amb_candb_dbg((x), (y))
+#define FMon_dbg_Sen_0_candb_dbg(x, y) _FMon_dbg_Sen_0_candb_dbg((x), (y))
+#define FMon_dbg_CCU_IO_candb_dbg(x, y) _FMon_dbg_CCU_IO_candb_dbg((x), (y))
+#define FMon_dbg_CCU_Info_candb_dbg(x, y) _FMon_dbg_CCU_Info_candb_dbg((x), (y))
+#define FMon_dbg_Drs_candb_dbg(x, y) _FMon_dbg_Drs_candb_dbg((x), (y))
+#define FMon_dbg_Sen_Incar_candb_dbg(x, y) _FMon_dbg_Sen_Incar_candb_dbg((x), (y))
+#define FMon_dbg_Cmd_Act_Information_candb_dbg(x, y) _FMon_dbg_Cmd_Act_Information_candb_dbg((x), (y))
+#define FMon_dbg_Info_Act1_candb_dbg(x, y) _FMon_dbg_Info_Act1_candb_dbg((x), (y))
+#define FMon_dbg_Info_Act2_candb_dbg(x, y) _FMon_dbg_Info_Act2_candb_dbg((x), (y))
+#define FMon_dbg_Sen_Eva_candb_dbg(x, y) _FMon_dbg_Sen_Eva_candb_dbg((x), (y))
+#define FMon_dbg_Sen_Duct_candb_dbg(x, y) _FMon_dbg_Sen_Duct_candb_dbg((x), (y))
+#define FMon_dbg_Sen_Demist_candb_dbg(x, y) _FMon_dbg_Sen_Demist_candb_dbg((x), (y))
+#define FMon_dbg_LIN_AirQS_Stat_candb_dbg(x, y) _FMon_dbg_LIN_AirQS_Stat_candb_dbg((x), (y))
+#define FMon_dbg_LIN_Aroma_Stat_candb_dbg(x, y) _FMon_dbg_LIN_Aroma_Stat_candb_dbg((x), (y))
+#define FMon_dbg_LIN_Ionizer_Stat_candb_dbg(x, y) _FMon_dbg_LIN_Ionizer_Stat_candb_dbg((x), (y))
+#define FMon_dbg_LIN_eTXV_Stat_candb_dbg(x, y) _FMon_dbg_LIN_eTXV_Stat_candb_dbg((x), (y))
+#define FMon_dbg_LIN_DRS_Stat_candb_dbg(x, y) _FMon_dbg_LIN_DRS_Stat_candb_dbg((x), (y))
+#define FMon_dbg_Auto_AF_candb_dbg(x, y) _FMon_dbg_Auto_AF_candb_dbg((x), (y))
+#define FMon_dbg_Auto_Duct_candb_dbg(x, y) _FMon_dbg_Auto_Duct_candb_dbg((x), (y))
+#define FMon_dbg_Auto_Valve_Plus_candb_dbg(x, y) _FMon_dbg_Auto_Valve_Plus_candb_dbg((x), (y))
+#define FMon_XCP_CCU_RX_candb_dbg(x, y) _FMon_XCP_CCU_RX_candb_dbg((x), (y))
+#define FMon_XCP_CCU_TX_candb_dbg(x, y) _FMon_XCP_CCU_TX_candb_dbg((x), (y))
+
+#endif
+
+#endif // CANDB_DBG_USE_DIAG_MONITORS
+
+#ifdef __cplusplus
+}
+#endif

modular.json

@@ -0,0 +1,15 @@
+{
+  "cmake": {
+    "inc_dirs": [
+      "inc",
+      "butl",
+      "conf",
+      "lib"
+    ],
+    "srcs": [
+      "butl/**.c",
+      "lib/**.c",
+      "usr/**.c"
+    ]
+  }
+}

usr/candb_dbg-fmon.c

@@ -0,0 +1,216 @@
+// Generator version : v3.1
+// DBC filename      : CCUdbg.dbc
+#include "candb_dbg-fmon.h"
+
+#ifdef CANDB_DBG_USE_DIAG_MONITORS
+
+/*
+Put the monitor function content here, keep in mind -
+next generation will completely clear all manually added code (!)
+*/
+
+#ifdef CANDB_DBG_USE_MONO_FMON
+
+void _FMon_MONO_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+#else
+
+void _FMon_dbg_Logic_State_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Logic_KM_Status_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Logic_Valve_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Logic_Blower_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Logic_Ac_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Logic_Rec_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_DiffBlr_ValveOpen_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Act0_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Act1_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Act2_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Sen_Amb_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Sen_0_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_CCU_IO_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_CCU_Info_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Drs_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Sen_Incar_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Cmd_Act_Information_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Info_Act1_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Info_Act2_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Sen_Eva_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Sen_Duct_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Sen_Demist_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_LIN_AirQS_Stat_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_LIN_Aroma_Stat_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_LIN_Ionizer_Stat_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_LIN_eTXV_Stat_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_LIN_DRS_Stat_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Auto_AF_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Auto_Duct_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_dbg_Auto_Valve_Plus_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_XCP_CCU_RX_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+void _FMon_XCP_CCU_TX_candb_dbg(FrameMonitor_t* _mon, uint32_t msgid)
+{
+  (void)_mon;
+  (void)msgid;
+}
+
+#endif // CANDB_DBG_USE_MONO_FMON
+
+#endif // CANDB_DBG_USE_DIAG_MONITORS