Skip to content

Commit 3af2c0c

Browse files
MurmeleMurmele
committed
hack
1 parent 25f17ce commit 3af2c0c

File tree

2 files changed

+27
-106
lines changed

2 files changed

+27
-106
lines changed

‎include/libdbc/message.hpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ namespace libdbc {
2020
*/
2121
bool parseSignals(const std::vector<uint8_t>& data, std::vector<double> &values) const;
2222
bool parseSignals(const std::array<uint8_t,8>& data, std::vector<double>& values) const;
23-
bool parseSignals(const uint8_t* data, std::vector<double>& values) const;
23+
bool parseSignals(const uint8_t* data, int size, std::vector<double>& values) const;
2424

2525
void appendSignal(const Signal& signal);
2626
const std::vector<Signal> signals() const;

‎src/message.cpp‎

Lines changed: 26 additions & 105 deletions
Original file line numberDiff line numberDiff line change
@@ -12,122 +12,43 @@ namespace libdbc {
1212
(m_size == rhs.m_size) && (m_node == rhs.m_node);
1313
}
1414

15-
bool Message::parseSignals(const uint8_t* data, std::vector<double>& values) const {
15+
bool Message::parseSignals(const uint8_t* data, int size, std::vector<double>& values) const {
1616
if (!m_prepared)
1717
return false;
1818

19-
bitstream_reader_t reader;
20-
bitstream_reader_init(&reader, data);
21-
22-
double v;
23-
for (const auto& bs: bitstruct) {
24-
if (bs.padding) {
25-
for (uint32_t i=0; i < bs.size; i++)
26-
bitstream_reader_read_bit(&reader);
27-
} else {
28-
const auto& signal = m_signals.at(bs.index);
29-
if (signal.is_bigendian) {
30-
switch (bs.size) {
31-
case 1:
32-
v = static_cast<double>(bitstream_reader_read_bit(&reader)); break;
33-
case 8:
34-
if (signal.is_signed)
35-
v = static_cast<double>(static_cast<int8_t>(bitstream_reader_read_u8(&reader)));
36-
else
37-
v = static_cast<double>(bitstream_reader_read_u8(&reader));
38-
break;
39-
case 16:
40-
if (signal.is_signed)
41-
v = static_cast<double>(static_cast<int16_t>(bitstream_reader_read_u16(&reader)));
42-
else
43-
v = static_cast<double>(bitstream_reader_read_u16(&reader));
44-
break;
45-
case 32:
46-
if (signal.is_signed)
47-
v = static_cast<double>(static_cast<int32_t>(bitstream_reader_read_u32(&reader)));
48-
else
49-
v = static_cast<double>(bitstream_reader_read_u32(&reader));
50-
break;
51-
case 64:
52-
if (signal.is_signed)
53-
v = static_cast<double>(static_cast<int64_t>(bitstream_reader_read_u64(&reader)));
54-
else
55-
v = static_cast<double>(bitstream_reader_read_u64(&reader));
56-
break;
57-
default: {
58-
// TODO: possible to implement bigendian and sign?
59-
uint64_t value = 0;
60-
for (uint32_t i=0; i < bs.size; i++) {
61-
value |= bitstream_reader_read_bit(&reader) << i;
62-
}
63-
v = static_cast<double>(value);
64-
break;
65-
}
66-
}
67-
} else {
68-
// little endian
69-
switch (bs.size) {
70-
case 1: v = static_cast<double>(bitstream_reader_read_bit(&reader)); break;
71-
case 8: v = static_cast<double>(bitstream_reader_read_u8(&reader)); break;
72-
case 16: {
73-
uint16_t tmp = bitstream_reader_read_u8(&reader);
74-
tmp |= (uint16_t)bitstream_reader_read_u8(&reader) << 8;
75-
if (signal.is_signed)
76-
v = static_cast<double>(static_cast<int16_t>(tmp));
77-
else
78-
v = static_cast<double>(tmp);
79-
break;
80-
}
81-
case 32: {
82-
uint32_t tmp = bitstream_reader_read_u8(&reader);
83-
tmp |= (uint32_t)bitstream_reader_read_u8(&reader) << 8;
84-
tmp |= (uint32_t)bitstream_reader_read_u8(&reader) << 16;
85-
tmp |= (uint32_t)bitstream_reader_read_u8(&reader) << 24;
86-
if (signal.is_signed)
87-
v = static_cast<double>(static_cast<int32_t>(tmp));
88-
else
89-
v = static_cast<double>(tmp);
90-
break;
91-
}
92-
case 64: {
93-
uint64_t tmp = bitstream_reader_read_u8(&reader);
94-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 8;
95-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 16;
96-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 24;
97-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 32;
98-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 40;
99-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 48;
100-
tmp |= (uint64_t)bitstream_reader_read_u8(&reader) << 56;
101-
if (signal.is_signed)
102-
v = static_cast<double>(static_cast<int64_t>(tmp));
103-
else
104-
v = static_cast<double>(tmp);
105-
break;
106-
}
107-
default: {
108-
// TODO: possible to implement bigendian and sign?
109-
uint64_t value = 0;
110-
for (uint32_t i=0; i < bs.size; i++) {
111-
value |= bitstream_reader_read_bit(&reader) << i;
112-
}
113-
v = static_cast<double>(value);
114-
break;
115-
}
116-
}
117-
}
118-
119-
values.push_back(v * signal.factor + signal.offset);
120-
}
19+
if (size > 8)
20+
return false; // not supported yet
21+
22+
// Only little endian supported yet!
23+
// All signals must be little endian
24+
for (const auto& signal: m_signals) {
25+
if (signal.is_bigendian)
26+
return false;
27+
}
28+
29+
const uint32_t len = size * 8;
30+
31+
uint64_t d = 0;
32+
for (int i=0; i < size; i++) {
33+
d |= ((uint64_t)data[i]) << i * 8;
34+
}
35+
36+
uint64_t v = 0;
37+
for (const auto& signal: m_signals) {
38+
const uint32_t shiftLeft = (len - (signal.size + signal.start_bit));
39+
v = d << shiftLeft;
40+
v = v >> (shiftLeft + signal.start_bit);
41+
values.push_back(v * signal.factor + signal.offset);
12142
}
12243
return true;
12344
}
12445

12546
bool Message::parseSignals(const std::array<uint8_t,8>& data, std::vector<double>& values) const {
126-
return parseSignals(data.data(), values);
47+
return parseSignals(data.data(), data.size(), values);
12748
}
12849

12950
bool Message::parseSignals(const std::vector<uint8_t> &data, std::vector<double>& values) const {
130-
return parseSignals(data.data(), values);
51+
return parseSignals(data.data(), data.size(), values);
13152
}
13253

13354
void Message::appendSignal(const Signal& signal) {

0 commit comments

Comments
 (0)