Skip to content

Commit 339d427

Browse files
MurmeleMurmele
committed
Update message.hpp, dbc.cpp, and 2 more files...
1 parent 079a46b commit 339d427

File tree

4 files changed

+152
-138
lines changed

4 files changed

+152
-138
lines changed

‎include/libdbc/message.hpp‎

Lines changed: 17 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -8,17 +8,15 @@
88

99
namespace libdbc {
1010
struct Message {
11-
uint32_t id;
12-
std::string name;
13-
uint8_t size;
14-
std::string node;
15-
std::vector<Signal> signals;
16-
1711
Message() = delete;
1812
explicit Message(uint32_t id, const std::string& name, uint8_t size, const std::string& node);
1913

2014
bool parseSignals(const std::vector<uint8_t> data, std::vector<double> &values) const;
2115

16+
void appendSignal(const Signal& signal);
17+
const std::vector<Signal> signals() const;
18+
uint32_t id() const;
19+
2220
/*!
2321
* \brief prepareMessage
2422
* Preparing message to be able to parse signals afterwards. This speeds up parsing
@@ -28,15 +26,25 @@ namespace libdbc {
2826
virtual bool operator==(const Message& rhs) const;
2927

3028
private:
31-
bool prepared{false}; // indicates if the message is prepared for parsing signals
29+
uint32_t m_id;
30+
std::string m_name;
31+
uint8_t m_size;
32+
std::string m_node;
33+
std::vector<Signal> m_signals; // when changing this vector m_prepared must be set to false!
34+
35+
36+
bool m_prepared{false}; // indicates if the message is prepared for parsing signals
3237
struct BitStruct {
33-
BitStruct(const std::string& name, uint32_t size, bool padding): name(name), size(size), padding(padding) {}
38+
BitStruct(uint32_t size): size(size), padding(true) {}
39+
BitStruct(int index, uint32_t size): index(index), size(size), padding(false) {}
3440
BitStruct() = delete;
35-
std::string name;
41+
int index;
3642
uint32_t size;
3743
bool padding;
3844
};
3945
std::vector<BitStruct> bitstruct;
46+
47+
friend std::ostream& operator<<(std::ostream& os, const Message& dt);
4048
};
4149

4250
std::ostream& operator<< (std::ostream &out, const Message& msg);

‎src/dbc.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -95,7 +95,7 @@ namespace libdbc {
9595

9696
bool DbcParser::parseMessage(const uint32_t id, const std::vector<uint8_t>& data, std::vector<double>& out_values) {
9797
for (const auto& message: messages) {
98-
if (message.id == id)
98+
if (message.id() == id)
9999
return message.parseSignals(data, out_values);
100100
}
101101
return false;
@@ -174,7 +174,7 @@ namespace libdbc {
174174
utils::String::split(match.str(16), receivers, ',');
175175

176176
Signal sig(name, is_multiplexed, start_bit, size, is_bigendian, is_signed, factor, offset, min, max, unit, receivers);
177-
messages.back().signals.push_back(sig);
177+
messages.back().appendSignal(sig);
178178
}
179179
}
180180

‎src/message.cpp‎

Lines changed: 121 additions & 114 deletions
Original file line numberDiff line numberDiff line change
@@ -5,15 +5,15 @@
55

66
namespace libdbc {
77
Message::Message(uint32_t id, const std::string& name, uint8_t size, const std::string& node) :
8-
id(id), name(name), size(size), node(node) {}
8+
m_id(id), m_name(name), m_size(size), m_node(node) {}
99

1010
bool Message::operator==(const Message& rhs) const {
11-
return (this->id == rhs.id) && (this->name == rhs.name) &&
12-
(this->size == rhs.size) && (this->node == rhs.node);
11+
return (m_id == rhs.id()) && (m_name == rhs.m_name) &&
12+
(m_size == rhs.m_size) && (m_node == rhs.m_node);
1313
}
1414

1515
bool Message::parseSignals(const std::vector<uint8_t> data, std::vector<double>& values) const {
16-
if (!prepared)
16+
if (!m_prepared)
1717
return false;
1818

1919
bitstream_reader_t reader;
@@ -25,140 +25,147 @@ namespace libdbc {
2525
for (uint32_t i=0; i < bs.size; i++)
2626
bitstream_reader_read_bit(&reader);
2727
} else {
28-
for(const auto& signal: signals) {
29-
if (bs.name.compare(signal.name) != 0) {
30-
continue;
31-
}
28+
const auto& signal = m_signals.at(bs.index);
29+
if (signal.is_bigendian) {
3230

33-
if (signal.is_bigendian) {
34-
35-
switch (bs.size) {
36-
case 1: v = static_cast<double>(bitstream_reader_read_bit(&reader)); break;
37-
case 8: v = static_cast<double>(bitstream_reader_read_u8(&reader)); break;
38-
case 16: {
39-
uint16_t tmp = bitstream_reader_read_u8(&reader);
40-
tmp |= (uint16_t)bitstream_reader_read_u8(&reader) << 8;
41-
if (signal.is_signed)
42-
v = static_cast<double>(static_cast<int16_t>(tmp));
43-
else
44-
v = static_cast<double>(tmp);
45-
break;
46-
}
47-
case 32: {
48-
uint32_t tmp = bitstream_reader_read_u8(&reader);
49-
tmp |= (uint32_t)bitstream_reader_read_u8(&reader) << 8;
50-
tmp |= (uint32_t)bitstream_reader_read_u8(&reader) << 16;
51-
tmp |= (uint32_t)bitstream_reader_read_u8(&reader) << 24;
52-
if (signal.is_signed)
53-
v = static_cast<double>(static_cast<int32_t>(tmp));
54-
else
55-
v = static_cast<double>(tmp);
56-
break;
57-
}
58-
case 64: {
59-
uint64_t tmp = bitstream_reader_read_u8(&reader);
60-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 8;
61-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 16;
62-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 24;
63-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 32;
64-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 40;
65-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 48;
66-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 56;
67-
if (signal.is_signed)
68-
v = static_cast<double>(static_cast<int64_t>(tmp));
69-
else
70-
v = static_cast<double>(tmp);
71-
break;
72-
}
73-
default: {
74-
// TODO: implement sign?
75-
// TODO: implement big endian
76-
uint64_t value = 0;
77-
for (uint32_t i=0; i < bs.size; i++) {
78-
value |= bitstream_reader_read_bit(&reader) << i;
79-
}
80-
v = static_cast<double>(value);
81-
break;
82-
}
83-
}
84-
} else {
85-
// little endian
86-
switch (bs.size) {
87-
case 1:
88-
v = static_cast<double>(bitstream_reader_read_bit(&reader)); break;
89-
case 8:
90-
if (signal.is_signed)
91-
v = static_cast<double>(static_cast<int8_t>(bitstream_reader_read_u8(&reader)));
92-
else
93-
v = static_cast<double>(bitstream_reader_read_u8(&reader));
94-
break;
95-
case 16:
96-
if (signal.is_signed)
97-
v = static_cast<double>(static_cast<int16_t>(bitstream_reader_read_u16(&reader)));
98-
else
99-
v = static_cast<double>(bitstream_reader_read_u16(&reader));
100-
break;
101-
case 32:
102-
if (signal.is_signed)
103-
v = static_cast<double>(static_cast<int32_t>(bitstream_reader_read_u32(&reader)));
104-
else
105-
v = static_cast<double>(bitstream_reader_read_u32(&reader));
106-
break;
107-
case 64:
108-
if (signal.is_signed)
109-
v = static_cast<double>(static_cast<int64_t>(bitstream_reader_read_u64(&reader)));
110-
else
111-
v = static_cast<double>(bitstream_reader_read_u64(&reader));
112-
break;
113-
default: {
114-
// TODO: implement sign?
115-
// TODO: implement big endian
116-
uint64_t value = 0;
117-
for (uint32_t i=0; i < bs.size; i++) {
118-
value |= bitstream_reader_read_bit(&reader) << i;
119-
}
120-
v = static_cast<double>(value);
121-
break;
31+
switch (bs.size) {
32+
case 1: v = static_cast<double>(bitstream_reader_read_bit(&reader)); break;
33+
case 8: v = static_cast<double>(bitstream_reader_read_u8(&reader)); break;
34+
case 16: {
35+
uint16_t tmp = bitstream_reader_read_u8(&reader);
36+
tmp |= (uint16_t)bitstream_reader_read_u8(&reader) << 8;
37+
if (signal.is_signed)
38+
v = static_cast<double>(static_cast<int16_t>(tmp));
39+
else
40+
v = static_cast<double>(tmp);
41+
break;
42+
}
43+
case 32: {
44+
uint32_t tmp = bitstream_reader_read_u8(&reader);
45+
tmp |= (uint32_t)bitstream_reader_read_u8(&reader) << 8;
46+
tmp |= (uint32_t)bitstream_reader_read_u8(&reader) << 16;
47+
tmp |= (uint32_t)bitstream_reader_read_u8(&reader) << 24;
48+
if (signal.is_signed)
49+
v = static_cast<double>(static_cast<int32_t>(tmp));
50+
else
51+
v = static_cast<double>(tmp);
52+
break;
53+
}
54+
case 64: {
55+
uint64_t tmp = bitstream_reader_read_u8(&reader);
56+
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 8;
57+
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 16;
58+
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 24;
59+
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 32;
60+
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 40;
61+
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 48;
62+
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 56;
63+
if (signal.is_signed)
64+
v = static_cast<double>(static_cast<int64_t>(tmp));
65+
else
66+
v = static_cast<double>(tmp);
67+
break;
68+
}
69+
default: {
70+
// TODO: possible to implement bigendian and sign?
71+
uint64_t value = 0;
72+
for (uint32_t i=0; i < bs.size; i++) {
73+
value |= bitstream_reader_read_bit(&reader) << i;
12274
}
75+
v = static_cast<double>(value);
76+
break;
77+
}
78+
}
79+
} else {
80+
// little endian
81+
switch (bs.size) {
82+
case 1:
83+
v = static_cast<double>(bitstream_reader_read_bit(&reader)); break;
84+
case 8:
85+
if (signal.is_signed)
86+
v = static_cast<double>(static_cast<int8_t>(bitstream_reader_read_u8(&reader)));
87+
else
88+
v = static_cast<double>(bitstream_reader_read_u8(&reader));
89+
break;
90+
case 16:
91+
if (signal.is_signed)
92+
v = static_cast<double>(static_cast<int16_t>(bitstream_reader_read_u16(&reader)));
93+
else
94+
v = static_cast<double>(bitstream_reader_read_u16(&reader));
95+
break;
96+
case 32:
97+
if (signal.is_signed)
98+
v = static_cast<double>(static_cast<int32_t>(bitstream_reader_read_u32(&reader)));
99+
else
100+
v = static_cast<double>(bitstream_reader_read_u32(&reader));
101+
break;
102+
case 64:
103+
if (signal.is_signed)
104+
v = static_cast<double>(static_cast<int64_t>(bitstream_reader_read_u64(&reader)));
105+
else
106+
v = static_cast<double>(bitstream_reader_read_u64(&reader));
107+
break;
108+
default: {
109+
// TODO: possible to implement bigendian and sign?
110+
uint64_t value = 0;
111+
for (uint32_t i=0; i < bs.size; i++) {
112+
value |= bitstream_reader_read_bit(&reader) << i;
123113
}
114+
v = static_cast<double>(value);
115+
break;
116+
}
124117
}
125-
126-
values.push_back(v * signal.factor + signal.offset);
127-
break;
128118
}
119+
120+
values.push_back(v * signal.factor + signal.offset);
129121
}
130122
}
131123
return true;
132124
}
133125

126+
void Message::appendSignal(const Signal& signal) {
127+
m_prepared = false;
128+
m_signals.push_back(signal);
129+
}
130+
131+
const std::vector<Signal> Message::signals() const {
132+
return m_signals;
133+
}
134+
135+
uint32_t Message::id() const {
136+
return m_id;
137+
}
138+
134139
void Message::prepareMessage() {
135-
prepared = false;
136-
std::sort(signals.begin(), signals.end());
140+
m_prepared = false;
141+
// sort signals so that the signals are ordered by the startbit
142+
std::sort(m_signals.begin(), m_signals.end());
137143

138144
uint32_t curr_bit = 0;
139-
for (const auto& signal: signals) {
140-
if (signal.is_multiplexed /*|| signal.is_bigendian*/)
145+
for (int i=0; i < m_signals.size(); i++) {
146+
const auto& signal = m_signals.at(i);
147+
if (signal.is_multiplexed)
141148
break; // Not supported yet
142149

143150
if (curr_bit < signal.start_bit) {
144151
// padding needed
145-
bitstruct.push_back(BitStruct("", signal.start_bit - curr_bit, true));
152+
bitstruct.push_back(BitStruct(signal.start_bit - curr_bit));
146153
}
147-
bitstruct.push_back(BitStruct(signal.name, signal.size, false));
154+
bitstruct.push_back(BitStruct(i, signal.size));
148155
curr_bit = signal.start_bit + signal.size;
149156
}
150-
if (curr_bit > size * 8)
157+
// Check if correct
158+
if (curr_bit > m_size * 8)
151159
return;
152160

153-
prepared = true;
154-
161+
m_prepared = true;
155162
}
156163

157-
std::ostream& operator<< (std::ostream &out, const Message& msg) {
158-
out << "Message: {id: " << msg.id << ", ";
159-
out << "name: " << msg.name << ", ";
160-
out << "size: " << msg.size << ", ";
161-
out << "node: " << msg.node << "}";
164+
std::ostream& operator<< (std::ostream &out, const Message& msg) {
165+
out << "Message: {id: " << msg.id() << ", ";
166+
out << "name: " << msg.m_name << ", ";
167+
out << "size: " << msg.m_size << ", ";
168+
out << "node: " << msg.m_node << "}";
162169
return out;
163170
}
164171
}

0 commit comments

Comments
 (0)