Skip to content

Commit c6edb35

Browse files
snhobbssnhobbs
committed
adding tests
1 parent 112915a commit c6edb35

5 files changed

Lines changed: 136 additions & 14 deletions

File tree

‎include/Modbus/MappedRegisterDataStore.h‎

Lines changed: 17 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -56,29 +56,39 @@ template <typename T> class MappedRegisterDataStore : public DataStore {
5656
return value;
5757
}
5858

59+
// [[deprecated]]
5960
template<typename F>
60-
void GetRegisters(std::size_t address, std::size_t register_count, F* data) const {
61+
void GetRegisters(const size_t address, const size_t register_count, F* data) const {
62+
GetRegisters(address, register_count, data->data(), data->size());
63+
}
64+
65+
void GetRegisters(const size_t address, const size_t register_count, uint8_t* data, const size_t length) const {
6166
const auto byte_address = sizeof(uint16_t)*address;
6267
const auto byte_count = sizeof(uint16_t)*register_count;
63-
if (RegisterSpanValid(address, register_count) && byte_count <= data->size()) {
64-
read(byte_address, byte_count, data->data());
68+
if (RegisterSpanValid(address, register_count) && byte_count <= length) {
69+
read(byte_address, byte_count, data);
6570
} else {
6671
assert(0);
6772
}
6873
}
6974

7075
void SetRegister(std::size_t address, const uint16_t value) {
7176
std::array<uint8_t, sizeof(uint16_t)> data{0xFF&(value >> 8), 0xFF&value};
72-
SetRegisters(address, 1, data);
77+
SetRegisters(address, 1, data.data(), data.size());
7378
}
7479

7580
// Validation has made each one of the a complete entry to one of our values
81+
//[[deprecated]]
7682
template<typename F>
77-
void SetRegisters(std::size_t address, std::size_t register_count, F &data) {
83+
void SetRegisters(const size_t address, const size_t register_count, F &data) {
84+
SetRegisters(address, register_count, data.data(), data.size());
85+
}
86+
87+
void SetRegisters(const size_t address, const size_t register_count, const uint8_t* data, const size_t length) {
7888
const auto byte_address = sizeof(uint16_t)*address;
7989
const auto byte_count = sizeof(uint16_t)*register_count;
80-
if (RegisterSpanValid(address, register_count) && byte_count <= data.size()) {
81-
write(byte_address, byte_count, data.data());
90+
if (RegisterSpanValid(address, register_count) && byte_count <= length) {
91+
write(byte_address, byte_count, data);
8292
} else {
8393
assert(0);
8494
}

‎include/Modbus/RegisterControl.h‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -296,7 +296,6 @@ class HoldingRegisterController {
296296
T* GetDataStore(void) {
297297
return register_data_;
298298
}
299-
[[deprecated]]
300299
bool RegisterSpanValid(std::size_t address, std::size_t count) const {
301300
return register_data_->RegisterSpanValid(address, count);
302301
}

‎include/Modbus/flat_buffers_register_wrapper.h‎

Lines changed: 11 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ class FlatBufferRegisterStore : public DataStore {
1313

1414
public:
1515
explicit FlatBufferRegisterStore(T* obj): obj_{obj} {}
16-
static const size_t number_of_fields = 4;//T::Traits::fields_number;
16+
static const size_t number_of_fields = T::Traits::fields_number;
1717
static std::size_t size(void) {return GetSize();}
1818
static constexpr std::size_t GetSize(void) { return sizeof(T); }
1919
static constexpr std::size_t GetRegisterByteSize(void) { return sizeof(uint16_t); }
@@ -47,16 +47,22 @@ class FlatBufferRegisterStore : public DataStore {
4747

4848
bool WriteLocationValid(std::size_t byte_address, std::size_t byte_count) const {
4949
const size_t index = GetMemoryMapEntryIndex(byte_address);
50-
return index < number_of_fields && get_field_size(index) == byte_count;
50+
// Since we don't know the size of the object, only where it starts and the next
51+
// begins, this breaks on the padding. Work around is to allow partial writes
52+
// and reads.
53+
const bool valid = index < number_of_fields && get_field_size(index) >= byte_count;
54+
if (!valid) {
55+
while(1){}
56+
}
57+
return valid;
5158
}
5259

5360
void read(const size_t byte_address, const size_t count, uint8_t* data) const {
54-
memcpy(data, reinterpret_cast<const uint8_t*>(&obj_)+byte_address, count);
61+
memcpy(data, reinterpret_cast<const uint8_t*>(obj_)+byte_address, count);
5562
}
5663

5764
void write(const size_t byte_address, const size_t count, const uint8_t* data) {
58-
memcpy(reinterpret_cast<uint8_t*>(&obj_)+byte_address, data, count);
59-
}
65+
memcpy(reinterpret_cast<void*>(obj_)+byte_address, data, count); }
6066
};
6167

6268
} // namespace Modbus

‎tests/input_registers.fbs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
namespace Modbus.HoldingRegisters;
1+
namespace Modbus.InputRegisters;
22

33
struct Registers {
44
array:[uint8:64];

‎tests/source/test_flat_buffers_adapter.cpp‎

Lines changed: 107 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,107 @@
1+
#include <cstring>
2+
#include <cassert>
3+
#include <cstdio>
4+
#include <gtest/gtest.h>
5+
#include <stdint.h>
6+
#include <array>
7+
#include <iostream>
8+
#include <vector>
9+
#include <Modbus/flat_buffers_register_wrapper.h>
10+
#include <Modbus/Modbus.h>
11+
#include <Modbus/BitControl.h>
12+
#include <Modbus/DataStore.h>
13+
#include <Modbus/ModbusRtu/ModbusRtuSlave.h>
14+
#include <Modbus/RegisterControl.h>
15+
#include <Modbus/MappedRegisterDataStore.h>
16+
#include <Modbus/DataStore.h>
17+
#include "input_registers_generated.h"
18+
#include "holding_registers_generated.h"
19+
20+
namespace FlatBuffersAdapterTests {
21+
inline const constexpr std::size_t kCoilCount = 1;
22+
using CoilController =
23+
Modbus::CoilController<Modbus::BitFieldDataStore<kCoilCount>>;
24+
using DiscreteInputController =
25+
Modbus::DiscreteInputController<Modbus::BitFieldDataStore<kCoilCount>>;
26+
27+
using HoldingRegisters = Modbus::HoldingRegisters::Registers;
28+
using HoldingRegisterMemoryMap = Modbus::FlatBufferRegisterStore<HoldingRegisters>;
29+
using HoldingRegisterController =
30+
Modbus::HoldingRegisterController<Modbus::MappedRegisterDataStore<HoldingRegisterMemoryMap>>;
31+
32+
using InputRegisters = Modbus::InputRegisters::Registers;
33+
using InputRegisterMemoryMap = Modbus::FlatBufferRegisterStore<InputRegisters>;
34+
using InputRegisterController =
35+
Modbus::InputRegisterController<Modbus::MappedRegisterDataStore<InputRegisterMemoryMap>>;
36+
using SlaveBase =
37+
Modbus::ProtocolRtuSlave<CoilController, HoldingRegisterController,
38+
DiscreteInputController, InputRegisterController>;
39+
40+
41+
42+
TEST(HoldingRegisters, mutate) {
43+
HoldingRegisters holding_registers{};
44+
holding_registers.mutate_u16(12);
45+
ASSERT_EQ(holding_registers.u16(), 12);
46+
}
47+
48+
TEST(InputRegisters, mutate) {
49+
InputRegisters input_registers{};
50+
input_registers.mutate_u16(12);
51+
ASSERT_EQ(input_registers.u16(), 12);
52+
}
53+
54+
TEST(HoldingRegisterMemoryMap, construct) {
55+
HoldingRegisters holding_registers{};
56+
HoldingRegisterMemoryMap holding_register_data_map{&holding_registers};
57+
}
58+
59+
TEST(InputRegisterMemoryMap, construct) {
60+
InputRegisters input_registers{};
61+
InputRegisterMemoryMap input_register_data_map{&input_registers};
62+
}
63+
64+
TEST(MappedRegisterDataStore_HoldingRegisterMemoryMap, construct) {
65+
HoldingRegisters holding_registers{};
66+
HoldingRegisterMemoryMap holding_register_data_map{&holding_registers};
67+
Modbus::MappedRegisterDataStore<HoldingRegisterMemoryMap> holding_register_data_store{&holding_register_data_map};
68+
}
69+
70+
TEST(MappedRegisterDataStore_InputRegisterMemoryMap, construct) {
71+
InputRegisters input_registers{};
72+
InputRegisterMemoryMap input_register_data_map{&input_registers};
73+
Modbus::MappedRegisterDataStore<InputRegisterMemoryMap> input_register_data_store{&input_register_data_map};
74+
}
75+
76+
struct InputRegisterFlatBuffersDataFixture : public ::testing::Test {
77+
InputRegisters input_registers{};
78+
InputRegisterMemoryMap input_register_data_map{&input_registers};
79+
Modbus::MappedRegisterDataStore<InputRegisterMemoryMap> dc{&input_register_data_map};
80+
Modbus::InputRegisterController<typeof(dc)> cc{&dc};
81+
82+
void SetUp(void) {}
83+
void TearDown(void) {}
84+
};
85+
86+
TEST_F(InputRegisterFlatBuffersDataFixture, construct) {}
87+
88+
struct HoldingRegisterFlatBuffersDataFixture : public ::testing::Test {
89+
HoldingRegisters holding_registers{};
90+
HoldingRegisterMemoryMap holding_register_data_map{&holding_registers};
91+
Modbus::MappedRegisterDataStore<HoldingRegisterMemoryMap> dc{&holding_register_data_map};
92+
Modbus::HoldingRegisterController<typeof(dc)> cc{&dc};
93+
void SetUp(void) {}
94+
void TearDown(void) {}
95+
};
96+
97+
TEST_F(HoldingRegisterFlatBuffersDataFixture, construct) {}
98+
99+
TEST_F(HoldingRegisterFlatBuffersDataFixture, Read_first_field_inbound) {
100+
const auto offset = holding_register_data_map.get_offset(0);
101+
const auto length = holding_register_data_map.get_field_size(0);
102+
std::array<uint8_t, 64> write_data{1,2,3,5};
103+
std::array<uint8_t, 64> read_data{1,2,3,5};
104+
dc.SetRegisters(offset/2, length/2, write_data.data(), write_data.size());
105+
dc.GetRegisters(offset/2, length/2, read_data.data(), read_data.size());
106+
}
107+
}

0 commit comments

Comments
 (0)