DBC Parser Module Documentation
Overview
This module implements a minimal DBC parser intended for use in the FrameTap project.
Its purpose is to read a DBC file and convert it into an internal representation that can later be used for:
- displaying CAN frames and signals
- building a hierarchical structure for UI
- integrating with Qt Model/View
- selecting signals for plotting
- preparing for runtime CAN/J1939 decoding
The implementation intentionally follows the KISS principle:
- simple
- readable
- easy to modify
- independent from Qt
This is not a full DBC parser, but a practical foundation that can be extended gradually.
Architecture
The module uses a simple processing pipeline.
DBC file
↓
DbcParser
↓
DbcDatabase
↓
DbcTreeBuilder
↓
TreeNode hierarchy
↓
Future Qt Model/View integration
Each component has a clear responsibility.
| Component | Responsibility |
|---|---|
| DbcParser | Reads and parses the DBC file |
| DbcDatabase | Stores parsed frames and signals |
| DbcTreeBuilder | Converts the database into a tree |
| TreeNode | Represents hierarchical nodes |
This separation allows the parser to remain independent from UI or visualization logic.
File Structure
The module consists of several logical parts.
Data structures
Files:
signal_info.h
frame_info.h
dbc_database.h
These files define the internal representation of parsed data.
Tree representation
Files:
tree_node.h
tree_node.cpp
Defines a simple hierarchical structure that can later be used by UI components.
Parser
Files:
dbc_parser.h
dbc_parser.cpp
Responsible for reading the DBC file and extracting frame and signal information.
Tree builder
Files:
dbc_tree_builder.h
dbc_tree_builder.cpp
Converts the parsed database into a tree representation.
Data Structures
SignalInfo
Represents a single signal defined in a DBC file.
Fields:
- name
- startBit
- length
- isLittleEndian
- isSigned
- factor
- offset
- minimum
- maximum
- unit
- receivers
- comment
Notes:
- receivers may contain multiple ECUs
- comment is optional
- factor and offset define physical conversion
Physical value is calculated as:
physical = raw * factor + offset
FrameInfo
Represents a CAN frame.
Fields:
- name
- canId
- dlc
- transmitter
- comment
- signals
- pgn
- hasPgn
Notes:
- signals is a vector of SignalInfo
- transmitter is the ECU that sends the frame
- pgn is derived using simplified J1939 logic
DbcDatabase
Top level container for parsed data.
DbcDatabase
└── vector
This structure represents the entire DBC file content.
Tree Representation
The module converts the parsed data into a tree.
Node types:
- Root
- Frame
- Signal
Example structure:
dbc
├── EngineData
│ ├── EngineSpeed
│ ├── OilTemp
│ └── CoolantTemp
└── VehicleData
├── VehicleSpeed
└── Odometer
Each node stores either:
- FrameInfo
- SignalInfo
This tree structure is designed to integrate easily with Qt Model/View.
Parser
The parser is implemented in:
dbc_parser.h
dbc_parser.cpp
It performs line-based parsing of the DBC file.
Supported elements:
- BO_
- SG_
- CM_
Supported DBC Syntax
Frame Definition
Example:
BO_ 256 EngineData: 8 EEC1
Parsed values:
| Field | Meaning |
|---|---|
| 256 | CAN identifier |
| EngineData | frame name |
| 8 | DLC |
| EEC1 | transmitter ECU |
Signal Definition
Example:
SG_ EngineSpeed : 0|16@1+ (0.125,0) [0|8000] "rpm" ECU1,ECU2
Parsed values:
| Field | Meaning |
|---|---|
| EngineSpeed | signal name |
| 0 | start bit |
| 16 | signal length |
| @1 | little endian |
| + | unsigned |
| factor | 0.125 |
| offset | 0 |
| minimum | 0 |
| maximum | 8000 |
| unit | rpm |
| receivers | ECU1, ECU2 |
Comments
Frame comment example:
CM_ BO_ 256 "Engine data frame";
Signal comment example:
CM_ SG_ 256 EngineSpeed "Actual engine speed";
Stored in:
- FrameInfo::comment
- SignalInfo::comment
PGN Extraction
PGN is derived using simplified J1939 logic.
Typical identifier layout:
Priority
Reserved
Data Page
PDU Format
PDU Specific
Source Address
The parser extracts PGN from the 29‑bit CAN identifier.
This is only an approximation and not full J1939 validation.
Example Usage
DbcParser parser;
DbcDatabase database = parser.ParseFile("example.dbc");
DbcTreeBuilder builder;
std::unique_ptr root = builder.Build(database);
After this step, the tree can be used by a UI or visualization system.
Example Tree
dbc
├── EngineData
│ ├── EngineSpeed
│ ├── OilTemp
│ └── CoolantTemp
└── VehicleData
├── VehicleSpeed
└── Odometer
Limitations
The current implementation intentionally does not support many advanced DBC features.
Not supported yet:
- multiplexed signals
- BA_ attributes
- BA_DEF_ definitions
- VAL_ value tables
- signal groups
- complex syntax variations
These can be added later if required.
Design Principles
KISS
The parser avoids complex grammar systems or tokenizers in order to keep the code easy to understand and maintain.
Separation of Concerns
Parsing, storage, and tree building are separate components.
This allows reuse for:
- GUI display
- runtime decoding
- export
- filtering
- testing
Qt Independence
The parser itself does not depend on Qt.
Qt integration should be implemented through a separate adapter layer.
Future Development
Recommended evolution path.
Stage 1 (current)
- BO_
- SG_
- CM_
- transmitter
- receivers
- basic PGN extraction
- tree representation
Stage 2
Add:
- extended CAN ID detection
- better PGN extraction
- parent pointer in TreeNode
- Qt Model adapter
Stage 3
Add support for:
- VAL_ value tables
- BA_ attributes
- BA_DEF_ definitions
- extended comments
Stage 4
Advanced functionality:
- multiplexing
- runtime signal decoding
- integration with CAN stream
- drag‑and‑drop plotting
Intended Usage in FrameTap
This module allows FrameTap to:
- load DBC files
- display frames and signals
- select signals
- search signals
- display metadata
- prepare runtime decoding
Example workflow:
Load DBC
↓
Browse signals
↓
Select signal
↓
Decode CAN frames
↓
Plot physical values
Why Abstract Factory Is Not Used
An abstract factory is intentionally not used at this stage.
The current structure already separates responsibilities clearly:
parser → database → tree builder → tree
Factories can be introduced later if multiple internal representations become necessary.
Build Integration
The module is independent of any specific build system.
It can be integrated using:
- CMake
- qmake
- Makefile
Simply include the source files in your project.
Summary
This module provides a minimal but extensible DBC parser designed for FrameTap.
Key properties:
- simple
- modular
- Qt‑independent
- extendable
It converts a DBC file into an internal structure:
frame → signals
with metadata such as:
- transmitter
- receivers
- comments
- basic PGN information
This forms the foundation for future CAN signal visualization and decoding.