Skip to content

Commit 2ffbc54

Browse files
billmccartneybillmccartney
committed
Updated API for version 1.0
1 parent d7d72d9 commit 2ffbc54

File tree

3 files changed

+53
-39
lines changed

3 files changed

+53
-39
lines changed

‎bmodbus.c‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -40,16 +40,16 @@ static void modbus_memmove(void * dst, void * src, uint16_t count) {
4040
#endif
4141
#define MODBUS_UNUSED(x) (void)(x)
4242

43-
void bmodbus_init(modbus_client_t *bmodbus, uint32_t interframe_delay, uint8_t client_address){
43+
void bmodbus_client_init(modbus_client_t *bmodbus, uint32_t interframe_delay, uint8_t client_address){
4444
bmodbus->state = CLIENT_STATE_IDLE;
4545
bmodbus->interframe_delay = interframe_delay;
4646
bmodbus->client_address = client_address;
4747
bmodbus->crc.half = 0xFFFF;
4848
bmodbus->byte_count = 0;
4949
}
5050

51-
void bmodbus_deinit(modbus_client_t *bmodbus){
52-
printf("bmodbus_deinit\n");
51+
void bmodbus_client_deinit(modbus_client_t *bmodbus){
52+
printf("bmodbus_client_deinit\n");
5353
bmodbus->state = CLIENT_NO_INIT;
5454
}
5555

@@ -283,14 +283,14 @@ static void bmodbus_encode_client_response(modbus_client_t *bmodbus){
283283
}
284284
}
285285

286-
modbus_request_t * bmodbus_get_request(modbus_client_t * bmodbus){
286+
modbus_request_t * bmodbus_client_get_request(modbus_client_t * bmodbus){
287287
if(bmodbus->state == CLIENT_STATE_PROCESSING_REQUEST){
288288
return &(bmodbus->payload.request);
289289
}
290290
return NULL;
291291
}
292292

293-
modbus_uart_response_t * bmodbus_get_response(modbus_client_t * bmodbus){
293+
modbus_uart_response_t * bmodbus_client_get_response(modbus_client_t * bmodbus){
294294
if(bmodbus->state == CLIENT_STATE_PROCESSING_REQUEST){
295295
//Here we process the request data structure into the UART response
296296
bmodbus_encode_client_response(bmodbus);
@@ -302,7 +302,7 @@ modbus_uart_response_t * bmodbus_get_response(modbus_client_t * bmodbus){
302302
return NULL;
303303
}
304304

305-
void bmodbus_send_complete(modbus_client_t * bmodbus){
305+
void bmodbus_client_send_complete(modbus_client_t * bmodbus){
306306
//This is called when the response has been sent
307307
if(bmodbus->state == CLIENT_STATE_SENDING_RESPONSE){
308308
bmodbus->state = CLIENT_STATE_IDLE;

‎bmodbus.h‎

Lines changed: 19 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,10 @@
1616
extern "C" {
1717
#endif
1818

19+
#define BMODBUS_VERSION_MAJOR (1)
20+
#define BMODBUS_VERSION_MINOR (0)
21+
22+
//This can be used to modify the maximum message size to something other than 256 bytes -- it reduces the RAM required
1923
#ifndef BMB_MAXIMUM_MESSAGE_SIZE
2024
#define BMB_MAXIMUM_MESSAGE_SIZE 256
2125
#endif
@@ -87,9 +91,9 @@ typedef struct{
8791
* @note This function must be called before any other modbus functions
8892
* @example
8993
* modbus_client_t modbus1;
90-
* bmodbus_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), client_address);
94+
* bmodbus_client_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), client_address);
9195
*/
92-
extern void bmodbus_init(modbus_client_t *bmodbus, uint32_t interframe_delay, uint8_t client_address);
96+
extern void bmodbus_client_init(modbus_client_t *bmodbus, uint32_t interframe_delay, uint8_t client_address);
9397
/**
9498
* @brief send the next byte to the modbus client
9599
*
@@ -111,13 +115,13 @@ extern void bmodbus_client_loop(modbus_client_t *bmodbus, uint32_t microsecond);
111115
*
112116
* @note This function is typically called from the main loop to return a request to the application. The application should call modbus_finish_request() when it's done with the request.
113117
*/
114-
extern modbus_request_t * bmodbus_get_request(modbus_client_t *bmodbus);
118+
extern modbus_request_t * bmodbus_client_get_request(modbus_client_t *bmodbus);
115119
/**
116120
* @brief Get the bytes to send to the serial port after the request processing is complete.
117121
* @param bmodbus - the modbus client instance
118122
* @return a pointer to the response, or NULL if there's no response
119123
*/
120-
extern modbus_uart_response_t * bmodbus_get_response(modbus_client_t * bmodbus);
124+
extern modbus_uart_response_t * bmodbus_client_get_response(modbus_client_t * bmodbus);
121125
/**
122126
* @brief Update the state machine
123127
*
@@ -126,7 +130,17 @@ extern modbus_uart_response_t * bmodbus_get_response(modbus_client_t * bmodbus);
126130
*
127131
* @note This function should be called when the response is sent. It will reset the state machine and prepare for the next request.
128132
*/
129-
extern void bmodbus_send_complete(modbus_client_t * bmodbus);
133+
extern void bmodbus_client_send_complete(modbus_client_t * bmodbus);
134+
135+
/**
136+
* @brief Deinitialize the modbus client
137+
*
138+
* @param bmodbus
139+
* @return none
140+
*
141+
* @note This function should be called when the modbus client is no longer needed.
142+
*/
143+
extern void bmodbus_client_deinit(modbus_client_t *bmodbus);
130144

131145
//Utility for calculating the minimum interfame delay -- which is the time from receiving the last byte of the request to sending the first byte of the response
132146
//This is used to calculate the interbyte delay (if used). It should be 3.5 times the time it takes to send a byte or 1.75ms when > 19200bps

‎tests/client/test_bmodbus_client.c‎

Lines changed: 28 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -25,16 +25,16 @@ void test_client_simple_write(void) {
2525
modbus_uart_response_t * response = NULL;
2626
modbus_client_t modbus1;
2727
modbus_client_t * modbus1_testing = &modbus1;
28-
bmodbus_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
28+
bmodbus_client_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
2929
uint32_t fake_time = 0;
3030
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
3131
for(uint16_t i=0;i<sizeof(writing_registers_address_0x0708_at_slave_2);i++) {
3232
//Ensure we are not giving a response
33-
TEST_ASSERT_EQUAL_MESSAGE(NULL, bmodbus_get_request(&modbus1), "modbus request is ready too early");
33+
TEST_ASSERT_EQUAL_MESSAGE(NULL, bmodbus_client_get_request(&modbus1), "modbus request is ready too early");
3434
bmodbus_client_next_byte(modbus1_testing, fake_time, writing_registers_address_0x0708_at_slave_2[i]);
3535
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
3636
}
37-
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, bmodbus_get_request(&modbus1), "modbus request is not ready");
37+
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, bmodbus_client_get_request(&modbus1), "modbus request is not ready");
3838
TEST_ASSERT_EQUAL_MESSAGE(CLIENT_STATE_PROCESSING_REQUEST, modbus1_testing->state, "modbus1_testing->state");
3939
TEST_ASSERT_EQUAL_MESSAGE(0x10, modbus1_testing->payload.request.function, "modbus1_testing->payload.request.function");
4040
TEST_ASSERT_EQUAL_MESSAGE(0x0708, modbus1_testing->payload.request.address, "modbus1_testing->payload.request.address");
@@ -43,7 +43,7 @@ void test_client_simple_write(void) {
4343
TEST_ASSERT_EQUAL_MESSAGE(0x0405, modbus1_testing->payload.request.data[1], "modbus1_testing->payload.request.data[1]");
4444

4545
//Here we say it was successful, and continue on
46-
response = bmodbus_get_response(&modbus1);
46+
response = bmodbus_client_get_response(&modbus1);
4747
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, response, "modbus response is not ready");
4848
TEST_ASSERT_EQUAL_MESSAGE(8, response->size, "response->size");
4949
}
@@ -52,23 +52,23 @@ void test_client_single_write(void){
5252
uint8_t writing_register_address_0x0708_at_slave_2[] = {0x02, 0x06, 0x07, 0x08, 0x02, 0x03, 0x48, 0x2e, };
5353
modbus_uart_response_t * response = NULL;
5454
modbus_client_t modbus1;
55-
bmodbus_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
55+
bmodbus_client_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
5656
uint32_t fake_time = 0;
5757
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
5858
for(uint16_t i=0;i<sizeof(writing_register_address_0x0708_at_slave_2);i++) {
5959
//Ensure we are not giving a response
60-
TEST_ASSERT_EQUAL_MESSAGE(NULL, bmodbus_get_request(&modbus1), "modbus request is ready too early");
60+
TEST_ASSERT_EQUAL_MESSAGE(NULL, bmodbus_client_get_request(&modbus1), "modbus request is ready too early");
6161
bmodbus_client_next_byte(&modbus1, fake_time, writing_register_address_0x0708_at_slave_2[i]);
6262
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
6363
}
64-
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, bmodbus_get_request(&modbus1), "modbus request is not ready");
64+
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, bmodbus_client_get_request(&modbus1), "modbus request is not ready");
6565
TEST_ASSERT_EQUAL_MESSAGE(CLIENT_STATE_PROCESSING_REQUEST, modbus1.state, "modbus1.state");
6666
TEST_ASSERT_EQUAL_MESSAGE(0x06, modbus1.payload.request.function, "modbus1.payload.request.function");
6767
TEST_ASSERT_EQUAL_MESSAGE(0x0708, modbus1.payload.request.address, "modbus1.payload.request.address");
6868
TEST_ASSERT_EQUAL_MESSAGE(0x0203, modbus1.payload.request.data[0], "modbus1.payload.request.data[0]");
6969

7070
//Here we say it was successful, and continue on
71-
response = bmodbus_get_response(&modbus1);
71+
response = bmodbus_client_get_response(&modbus1);
7272
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, response, "modbus response is not ready");
7373
TEST_ASSERT_EQUAL_MESSAGE(8, response->size, "response->size");
7474
}
@@ -78,17 +78,17 @@ void test_client_holding_read(void) {
7878
modbus_request_t *request = NULL;
7979
modbus_uart_response_t *response = NULL;
8080
modbus_client_t modbus1;
81-
bmodbus_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
81+
bmodbus_client_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
8282
uint32_t fake_time = 0;
8383
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
8484

8585
for (uint16_t i = 0; i < sizeof(reading_register_address_0x0708_at_slave_2); i++) {
86-
TEST_ASSERT_EQUAL_MESSAGE(NULL, bmodbus_get_request(&modbus1), "modbus request is ready too early");
86+
TEST_ASSERT_EQUAL_MESSAGE(NULL, bmodbus_client_get_request(&modbus1), "modbus request is ready too early");
8787
bmodbus_client_next_byte(&modbus1, fake_time, reading_register_address_0x0708_at_slave_2[i]);
8888
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
8989
}
9090

91-
request = bmodbus_get_request(&modbus1);
91+
request = bmodbus_client_get_request(&modbus1);
9292
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, request, "modbus request is not ready");
9393
TEST_ASSERT_EQUAL(CLIENT_STATE_PROCESSING_REQUEST, modbus1.state);
9494
TEST_ASSERT_EQUAL(0x03, request->function);
@@ -97,7 +97,7 @@ void test_client_holding_read(void) {
9797

9898
request->data[0] = 0xdead;
9999

100-
response = bmodbus_get_response(&modbus1);
100+
response = bmodbus_client_get_response(&modbus1);
101101
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, response, "modbus response is not ready");
102102
TEST_ASSERT_EQUAL(5 + 2 * 1, response->size);
103103
TEST_ASSERT_EQUAL(0x02, response->data[0]);
@@ -112,17 +112,17 @@ void test_client_input_read(void) {
112112
modbus_request_t *request = NULL;
113113
modbus_uart_response_t *response = NULL;
114114
modbus_client_t modbus1;
115-
bmodbus_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
115+
bmodbus_client_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
116116
uint32_t fake_time = 0;
117117
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
118118

119119
for (uint16_t i = 0; i < sizeof(reading_registers_address_0x0708_at_slave_2); i++) {
120-
TEST_ASSERT_EQUAL(NULL, bmodbus_get_request(&modbus1));
120+
TEST_ASSERT_EQUAL(NULL, bmodbus_client_get_request(&modbus1));
121121
bmodbus_client_next_byte(&modbus1, fake_time, reading_registers_address_0x0708_at_slave_2[i]);
122122
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
123123
}
124124

125-
request = bmodbus_get_request(&modbus1);
125+
request = bmodbus_client_get_request(&modbus1);
126126
TEST_ASSERT_NOT_EQUAL(NULL, request);
127127
TEST_ASSERT_EQUAL(CLIENT_STATE_PROCESSING_REQUEST, modbus1.state);
128128
TEST_ASSERT_EQUAL(0x04, request->function);
@@ -133,7 +133,7 @@ void test_client_input_read(void) {
133133
request->data[1] = 0xbeef;
134134
request->data[2] = 0xd00d;
135135

136-
response = bmodbus_get_response(&modbus1);
136+
response = bmodbus_client_get_response(&modbus1);
137137
TEST_ASSERT_NOT_EQUAL(NULL, response);
138138
TEST_ASSERT_EQUAL(5 + 2 * 3, response->size);
139139
TEST_ASSERT_EQUAL(0x02, response->data[0]);
@@ -152,17 +152,17 @@ void test_read_input_status(void) {
152152
modbus_request_t *request = NULL;
153153
modbus_uart_response_t *response = NULL;
154154
modbus_client_t modbus1;
155-
bmodbus_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
155+
bmodbus_client_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
156156
uint32_t fake_time = 0;
157157
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
158158

159159
for (uint16_t i = 0; i < sizeof(reading_bits_address_0x00c4_at_slave_2); i++) {
160-
TEST_ASSERT_EQUAL(NULL, bmodbus_get_request(&modbus1));
160+
TEST_ASSERT_EQUAL(NULL, bmodbus_client_get_request(&modbus1));
161161
bmodbus_client_next_byte(&modbus1, fake_time, reading_bits_address_0x00c4_at_slave_2[i]);
162162
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
163163
}
164164

165-
request = bmodbus_get_request(&modbus1);
165+
request = bmodbus_client_get_request(&modbus1);
166166
TEST_ASSERT_NOT_EQUAL(NULL, request);
167167
TEST_ASSERT_EQUAL(CLIENT_STATE_PROCESSING_REQUEST, modbus1.state);
168168
TEST_ASSERT_EQUAL(0x02, request->function);
@@ -173,7 +173,7 @@ void test_read_input_status(void) {
173173
((uint8_t *)(request->data))[1] = 0xde;
174174
((uint8_t *)(request->data))[2] = 0xef;
175175

176-
response = bmodbus_get_response(&modbus1);
176+
response = bmodbus_client_get_response(&modbus1);
177177
TEST_ASSERT_NOT_EQUAL(NULL, response);
178178
TEST_ASSERT_EQUAL((0x16 + 7) / 8 + 5, response->size);
179179
TEST_ASSERT_EQUAL(0xad, response->data[3]);
@@ -186,17 +186,17 @@ void test_read_coil(void) {
186186
modbus_request_t *request = NULL;
187187
modbus_uart_response_t *response = NULL;
188188
modbus_client_t modbus1;
189-
bmodbus_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
189+
bmodbus_client_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
190190
uint32_t fake_time = 0;
191191
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
192192

193193
for (uint16_t i = 0; i < sizeof(reading_coil_address_0x1234_at_slave_2); i++) {
194-
TEST_ASSERT_EQUAL_MESSAGE(NULL, bmodbus_get_request(&modbus1), "modbus request is ready too early");
194+
TEST_ASSERT_EQUAL_MESSAGE(NULL, bmodbus_client_get_request(&modbus1), "modbus request is ready too early");
195195
bmodbus_client_next_byte(&modbus1, fake_time, reading_coil_address_0x1234_at_slave_2[i]);
196196
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
197197
}
198198

199-
request = bmodbus_get_request(&modbus1);
199+
request = bmodbus_client_get_request(&modbus1);
200200
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, request, "modbus request is ready too early");
201201
TEST_ASSERT_EQUAL(CLIENT_STATE_PROCESSING_REQUEST, modbus1.state);
202202
TEST_ASSERT_EQUAL(0x01, request->function);
@@ -207,7 +207,7 @@ void test_read_coil(void) {
207207
((uint8_t *)(request->data))[1] = 0xde;
208208
((uint8_t *)(request->data))[2] = 0xef;
209209

210-
response = bmodbus_get_response(&modbus1);
210+
response = bmodbus_client_get_response(&modbus1);
211211
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, response, "modbus response is not ready");
212212
TEST_ASSERT_EQUAL((0x07d0 + 7) / 8 + 5, response->size);
213213
TEST_ASSERT_EQUAL(0xad, response->data[3]);
@@ -221,17 +221,17 @@ void test_write_coils(void){
221221
modbus_uart_response_t * response = NULL;
222222
modbus_client_t modbus1;
223223
memset(&modbus1, 0, sizeof(modbus_client_t));
224-
bmodbus_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
224+
bmodbus_client_init(&modbus1, INTERFRAME_DELAY_MICROSECONDS(38400), 2);
225225
uint32_t fake_time = 0;
226226
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
227227
for(uint16_t i=0;i<sizeof(writing_coils_address_0x1234_at_slave_2);i++) {
228228
//Ensure we are not giving a response
229-
TEST_ASSERT_EQUAL_MESSAGE(NULL, bmodbus_get_request(&modbus1), "modbus request is ready too early");
229+
TEST_ASSERT_EQUAL_MESSAGE(NULL, bmodbus_client_get_request(&modbus1), "modbus request is ready too early");
230230
bmodbus_client_next_byte(&modbus1, fake_time, writing_coils_address_0x1234_at_slave_2[i]);
231231
fake_time += byte_timing_microseconds(38400) * 1; // 1 byte
232232
TEST_ASSERT_NOT_EQUAL(CLIENT_STATE_WAITING_FOR_NEXT_MESSAGE, modbus1.state);
233233
}
234-
request = bmodbus_get_request(&modbus1);
234+
request = bmodbus_client_get_request(&modbus1);
235235
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, request, "modbus request not ready");
236236
TEST_ASSERT_EQUAL(CLIENT_STATE_PROCESSING_REQUEST, modbus1.state);
237237
TEST_ASSERT_EQUAL(0x0f, request->function);
@@ -242,7 +242,7 @@ void test_write_coils(void){
242242
TEST_ASSERT_EQUAL_UINT8(0xff, ((uint8_t*)(request->data))[j]);
243243
}
244244

245-
response = bmodbus_get_response(&modbus1);
245+
response = bmodbus_client_get_response(&modbus1);
246246
TEST_ASSERT_NOT_EQUAL(NULL, response); //Ensure the uart response is ready
247247
TEST_ASSERT_EQUAL(8, response->size);
248248
TEST_ASSERT_EQUAL(0x02, response->data[0]);

0 commit comments

Comments
 (0)