Peter M. Groen / modbus-cpp

Browse Code »

Commit f8480708371b7cd9bd6cc159c3412173d79ef6ae

Authored by Peter M. Groen 2022-09-24 02:12:27 +0200

1 parent b8720844

Creating modbus PDU class

Inline Side-by-side

Showing 5 changed files with 102 additions and 663 deletions

documentation/implementation.md 0 → 100644

View file @f848070

documentation/protocol.md 0 → 100644

View file @f848070

include/modbus.h deleted

View file @b872084

1	-/*
2	- * Copyright (c)2022 Peter M. Groen
3	- *
4	- * This source code is licensed under the MIT license found in the
5	- * LICENSE file in hte root directory of this source tree
6	- */
7	-
8	-#pragma once
9	-
10	-#include <cstring>
11	-#include <stdint.h>
12	-#include <string>
13	-
14	-#ifdef ENABLE_MODBUS_LOGGING
15	-#include <cstdio>
16	-#define LOG(fmt, ...) printf("[ modbuspp ]" fmt, ##__VA_ARGS__)
17	-#else
18	-#define LOG(...) (void)0
19	-#endif
20	-
21	-#include <unistd.h>
22	-#include <sys/socket.h>
23	-#include <netinet/in.h>
24	-#include <arpa/inet.h>
25	-using X_SOCKET = int;
26	-
27	-#define X_ISVALIDSOCKET(s) ((s) >= 0)
28	-#define X_CLOSE_SOCKET(s) close(s)
29	-#define X_ISCONNECTSUCCEED(s) ((s) >= 0)
30	-
31	-using SOCKADDR = struct sockaddr;
32	-using SOCKADDR_IN = struct sockaddr_in;
33	-
34	-#define MAX_MSG_LENGTH 260
35	-
36	-///Function Code
37	-#define READ_COILS 0x01
38	-#define READ_INPUT_BITS 0x02
39	-#define READ_REGS 0x03
40	-#define READ_INPUT_REGS 0x04
41	-#define WRITE_COIL 0x05
42	-#define WRITE_REG 0x06
43	-#define WRITE_COILS 0x0F
44	-#define WRITE_REGS 0x10
45	-
46	-///Exception Codes
47	-
48	-#define EX_ILLEGAL_FUNCTION 0x01 // Function Code not Supported
49	-#define EX_ILLEGAL_ADDRESS 0x02 // Output Address not exists
50	-#define EX_ILLEGAL_VALUE 0x03 // Output Value not in Range
51	-#define EX_SERVER_FAILURE 0x04 // Slave Deive Fails to process request
52	-#define EX_ACKNOWLEDGE 0x05 // Service Need Long Time to Execute
53	-#define EX_SERVER_BUSY 0x06 // Server Was Unable to Accept MB Request PDU
54	-#define EX_NEGATIVE_ACK 0x07
55	-#define EX_MEM_PARITY_PROB 0x08
56	-#define EX_GATEWAY_PROBLEMP 0x0A // Gateway Path not Available
57	-#define EX_GATEWAY_PROBLEMF 0x0B // Target Device Failed to Response
58	-#define EX_BAD_DATA 0XFF // Bad Data lenght or Address
59	-
60	-#define BAD_CON -1
61	-
62	-/**
63	- * Modbus Operator Class
64	- * Providing networking support and mobus operation support.
65	- */
66	-class modbus
67	-{
68	-
69	-public:
70	- bool err{};
71	- int err_no{};
72	- std::string error_msg;
73	-
74	- modbus(std::string host, uint16_t port);
75	- ~modbus();
76	-
77	- bool modbus_connect();
78	- void modbus_close() const;
79	-
80	- bool is_connected() const { return _connected; }
81	-
82	- void modbus_set_slave_id(int id);
83	-
84	- int modbus_read_coils(uint16_t address, uint16_t amount, bool *buffer);
85	- int modbus_read_input_bits(uint16_t address, uint16_t amount, bool *buffer);
86	- int modbus_read_holding_registers(uint16_t address, uint16_t amount, uint16_t *buffer);
87	- int modbus_read_input_registers(uint16_t address, uint16_t amount, uint16_t *buffer);
88	-
89	- int modbus_write_coil(uint16_t address, const bool &to_write);
90	- int modbus_write_register(uint16_t address, const uint16_t &value);
91	- int modbus_write_coils(uint16_t address, uint16_t amount, const bool *value);
92	- int modbus_write_registers(uint16_t address, uint16_t amount, const uint16_t *value);
93	-
94	-private:
95	- bool _connected{};
96	- uint16_t PORT{};
97	- uint32_t _msg_id{};
98	- int _slaveid{};
99	- std::string HOST;
100	-
101	- X_SOCKET _socket{};
102	- SOCKADDR_IN _server{};
103	-
104	- void modbus_build_request(uint8_t *to_send, uint16_t address, int func) const;
105	-
106	- int modbus_read(uint16_t address, uint16_t amount, int func);
107	- int modbus_write(uint16_t address, uint16_t amount, int func, const uint16_t *value);
108	-
109	- ssize_t modbus_send(uint8_t *to_send, size_t length);
110	- ssize_t modbus_receive(uint8_t *buffer) const;
111	-
112	- void modbuserror_handle(const uint8_t *msg, int func);
113	-
114	- void set_bad_con();
115	- void set_bad_input();
116	-};
117	-
118	-/**
119	- * Main Constructor of Modbus Connector Object
120	- * @param host IP Address of Host
121	- * @param port Port for the TCP Connection
122	- * @return A Modbus Connector Object
123	- */
124	-inline modbus::modbus(std::string host, uint16_t port = 502)
125	-{
126	- HOST = host;
127	- PORT = port;
128	- _slaveid = 1;
129	- _msg_id = 1;
130	- _connected = false;
131	- err = false;
132	- err_no = 0;
133	- error_msg = "";
134	-}
135	-
136	-/**
137	- * Destructor of Modbus Connector Object
138	- */
139	-inline modbus::~modbus(void) = default;
140	-
141	-/**
142	- * Modbus Slave ID Setter
143	- * @param id ID of the Modbus Server Slave
144	- */
145	-inline void modbus::modbus_set_slave_id(int id)
146	-{
147	- _slaveid = id;
148	-}
149	-
150	-/**
151	- * Build up a Modbus/TCP Connection
152	- * @return If A Connection Is Successfully Built
153	- */
154	-inline bool modbus::modbus_connect()
155	-{
156	- if (HOST.empty() \|\| PORT == 0)
157	- {
158	- LOG("Missing Host and Port");
159	- return false;
160	- }
161	- else
162	- {
163	- LOG("Found Proper Host %s and Port %d", HOST.c_str(), PORT);
164	- }
165	-
166	- _socket = socket(AF_INET, SOCK_STREAM, 0);
167	- if (!X_ISVALIDSOCKET(_socket))
168	- {
169	- LOG("Error Opening Socket");
170	- return false;
171	- }
172	- else
173	- {
174	- LOG("Socket Opened Successfully");
175	- }
176	-
177	- struct timeval timeout
178	- {
179	- };
180	- timeout.tv_sec = 20; // after 20 seconds connect() will timeout
181	- timeout.tv_usec = 0;
182	-
183	- setsockopt(_socket, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout, sizeof(timeout));
184	- setsockopt(_socket, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout));
185	- _server.sin_family = AF_INET;
186	- _server.sin_addr.s_addr = inet_addr(HOST.c_str());
187	- _server.sin_port = htons(PORT);
188	-
189	- if (!X_ISCONNECTSUCCEED(connect(_socket, (SOCKADDR *)&_server, sizeof(_server))))
190	- {
191	- LOG("Connection Error");
192	- return false;
193	- }
194	-
195	- LOG("Connected");
196	- _connected = true;
197	- return true;
198	-}
199	-
200	-/**
201	- * Close the Modbus/TCP Connection
202	- */
203	-inline void modbus::modbus_close() const
204	-{
205	- X_CLOSE_SOCKET(_socket);
206	- LOG("Socket Closed");
207	-}
208	-
209	-/**
210	- * Modbus Request Builder
211	- * @param to_send Message Buffer to Be Sent
212	- * @param address Reference Address
213	- * @param func Modbus Functional Code
214	- */
215	-inline void modbus::modbus_build_request(uint8_t *to_send, uint16_t address, int func) const
216	-{
217	- to_send[0] = (uint8_t)(_msg_id >> 8u);
218	- to_send[1] = (uint8_t)(_msg_id & 0x00FFu);
219	- to_send[2] = 0;
220	- to_send[3] = 0;
221	- to_send[4] = 0;
222	- to_send[6] = (uint8_t)_slaveid;
223	- to_send[7] = (uint8_t)func;
224	- to_send[8] = (uint8_t)(address >> 8u);
225	- to_send[9] = (uint8_t)(address & 0x00FFu);
226	-}
227	-
228	-/**
229	- * Write Request Builder and Sender
230	- * @param address Reference Address
231	- * @param amount Amount of data to be Written
232	- * @param func Modbus Functional Code
233	- * @param value Data to Be Written
234	- */
235	-inline int modbus::modbus_write(uint16_t address, uint16_t amount, int func, const uint16_t *value)
236	-{
237	- int status = 0;
238	- uint8_t *to_send;
239	- if (func == WRITE_COIL \|\| func == WRITE_REG)
240	- {
241	- to_send = new uint8_t[12];
242	- modbus_build_request(to_send, address, func);
243	- to_send[5] = 6;
244	- to_send[10] = (uint8_t)(value[0] >> 8u);
245	- to_send[11] = (uint8_t)(value[0] & 0x00FFu);
246	- status = modbus_send(to_send, 12);
247	- }
248	- else if (func == WRITE_REGS)
249	- {
250	- to_send = new uint8_t[13 + 2 * amount];
251	- modbus_build_request(to_send, address, func);
252	- to_send[5] = (uint8_t)(7 + 2 * amount);
253	- to_send[10] = (uint8_t)(amount >> 8u);
254	- to_send[11] = (uint8_t)(amount & 0x00FFu);
255	- to_send[12] = (uint8_t)(2 * amount);
256	- for (int i = 0; i < amount; i++)
257	- {
258	- to_send[13 + 2 * i] = (uint8_t)(value[i] >> 8u);
259	- to_send[14 + 2 * i] = (uint8_t)(value[i] & 0x00FFu);
260	- }
261	- status = modbus_send(to_send, 13 + 2 * amount);
262	- }
263	- else if (func == WRITE_COILS)
264	- {
265	- to_send = new uint8_t[14 + (amount - 1) / 8];
266	- modbus_build_request(to_send, address, func);
267	- to_send[5] = (uint8_t)(7 + (amount + 7) / 8);
268	- to_send[10] = (uint8_t)(amount >> 8u);
269	- to_send[11] = (uint8_t)(amount & 0x00FFu);
270	- to_send[12] = (uint8_t)((amount + 7) / 8);
271	- for (int i = 0; i < (amount + 7) / 8; i++)
272	- to_send[13 + i] = 0; // init needed before summing!
273	- for (int i = 0; i < amount; i++)
274	- {
275	- to_send[13 + i / 8] += (uint8_t)(value[i] << (i % 8u));
276	- }
277	- status = modbus_send(to_send, 14 + (amount - 1) / 8);
278	- }
279	- delete[] to_send;
280	- return status;
281	-}
282	-
283	-/**
284	- * Read Request Builder and Sender
285	- * @param address Reference Address
286	- * @param amount Amount of Data to Read
287	- * @param func Modbus Functional Code
288	- */
289	-inline int modbus::modbus_read(uint16_t address, uint16_t amount, int func)
290	-{
291	- uint8_t to_send[12];
292	- modbus_build_request(to_send, address, func);
293	- to_send[5] = 6;
294	- to_send[10] = (uint8_t)(amount >> 8u);
295	- to_send[11] = (uint8_t)(amount & 0x00FFu);
296	- return modbus_send(to_send, 12);
297	-}
298	-
299	-/**
300	- * Read Holding Registers
301	- * MODBUS FUNCTION 0x03
302	- * @param address Reference Address
303	- * @param amount Amount of Registers to Read
304	- * @param buffer Buffer to Store Data Read from Registers
305	- */
306	-inline int modbus::modbus_read_holding_registers(uint16_t address, uint16_t amount, uint16_t *buffer)
307	-{
308	- if (_connected)
309	- {
310	- modbus_read(address, amount, READ_REGS);
311	- uint8_t to_rec[MAX_MSG_LENGTH];
312	- ssize_t k = modbus_receive(to_rec);
313	- if (k == -1)
314	- {
315	- set_bad_con();
316	- return BAD_CON;
317	- }
318	- modbuserror_handle(to_rec, READ_REGS);
319	- if (err)
320	- return err_no;
321	- for (auto i = 0; i < amount; i++)
322	- {
323	- buffer[i] = ((uint16_t)to_rec[9u + 2u * i]) << 8u;
324	- buffer[i] += (uint16_t)to_rec[10u + 2u * i];
325	- }
326	- return 0;
327	- }
328	- else
329	- {
330	- set_bad_con();
331	- return BAD_CON;
332	- }
333	-}
334	-
335	-/**
336	- * Read Input Registers
337	- * MODBUS FUNCTION 0x04
338	- * @param address Reference Address
339	- * @param amount Amount of Registers to Read
340	- * @param buffer Buffer to Store Data Read from Registers
341	- */
342	-inline int modbus::modbus_read_input_registers(uint16_t address, uint16_t amount, uint16_t *buffer)
343	-{
344	- if (_connected)
345	- {
346	- modbus_read(address, amount, READ_INPUT_REGS);
347	- uint8_t to_rec[MAX_MSG_LENGTH];
348	- ssize_t k = modbus_receive(to_rec);
349	- if (k == -1)
350	- {
351	- set_bad_con();
352	- return BAD_CON;
353	- }
354	- modbuserror_handle(to_rec, READ_INPUT_REGS);
355	- if (err)
356	- return err_no;
357	- for (auto i = 0; i < amount; i++)
358	- {
359	- buffer[i] = ((uint16_t)to_rec[9u + 2u * i]) << 8u;
360	- buffer[i] += (uint16_t)to_rec[10u + 2u * i];
361	- }
362	- return 0;
363	- }
364	- else
365	- {
366	- set_bad_con();
367	- return BAD_CON;
368	- }
369	-}
370	-
371	-/**
372	- * Read Coils
373	- * MODBUS FUNCTION 0x01
374	- * @param address Reference Address
375	- * @param amount Amount of Coils to Read
376	- * @param buffer Buffer to Store Data Read from Coils
377	- */
378	-inline int modbus::modbus_read_coils(uint16_t address, uint16_t amount, bool *buffer)
379	-{
380	- if (_connected)
381	- {
382	- if (amount > 2040)
383	- {
384	- set_bad_input();
385	- return EX_BAD_DATA;
386	- }
387	- modbus_read(address, amount, READ_COILS);
388	- uint8_t to_rec[MAX_MSG_LENGTH];
389	- ssize_t k = modbus_receive(to_rec);
390	- if (k == -1)
391	- {
392	- set_bad_con();
393	- return BAD_CON;
394	- }
395	- modbuserror_handle(to_rec, READ_COILS);
396	- if (err)
397	- return err_no;
398	- for (auto i = 0; i < amount; i++)
399	- {
400	- buffer[i] = (bool)((to_rec[9u + i / 8u] >> (i % 8u)) & 1u);
401	- }
402	- return 0;
403	- }
404	- else
405	- {
406	- set_bad_con();
407	- return BAD_CON;
408	- }
409	-}
410	-
411	-/**
412	- * Read Input Bits(Discrete Data)
413	- * MODBUS FUNCITON 0x02
414	- * @param address Reference Address
415	- * @param amount Amount of Bits to Read
416	- * @param buffer Buffer to store Data Read from Input Bits
417	- */
418	-inline int modbus::modbus_read_input_bits(uint16_t address, uint16_t amount, bool *buffer)
419	-{
420	- if (_connected)
421	- {
422	- if (amount > 2040)
423	- {
424	- set_bad_input();
425	- return EX_BAD_DATA;
426	- }
427	- modbus_read(address, amount, READ_INPUT_BITS);
428	- uint8_t to_rec[MAX_MSG_LENGTH];
429	- ssize_t k = modbus_receive(to_rec);
430	- if (k == -1)
431	- {
432	- set_bad_con();
433	- return BAD_CON;
434	- }
435	- if (err)
436	- return err_no;
437	- for (auto i = 0; i < amount; i++)
438	- {
439	- buffer[i] = (bool)((to_rec[9u + i / 8u] >> (i % 8u)) & 1u);
440	- }
441	- modbuserror_handle(to_rec, READ_INPUT_BITS);
442	- return 0;
443	- }
444	- else
445	- {
446	- return BAD_CON;
447	- }
448	-}
449	-
450	-/**
451	- * Write Single Coils
452	- * MODBUS FUNCTION 0x05
453	- * @param address Reference Address
454	- * @param to_write Value to be Written to Coil
455	- */
456	-inline int modbus::modbus_write_coil(uint16_t address, const bool &to_write)
457	-{
458	- if (_connected)
459	- {
460	- int value = to_write * 0xFF00;
461	- modbus_write(address, 1, WRITE_COIL, (uint16_t *)&value);
462	- uint8_t to_rec[MAX_MSG_LENGTH];
463	- ssize_t k = modbus_receive(to_rec);
464	- if (k == -1)
465	- {
466	- set_bad_con();
467	- return BAD_CON;
468	- }
469	- modbuserror_handle(to_rec, WRITE_COIL);
470	- if (err)
471	- return err_no;
472	- return 0;
473	- }
474	- else
475	- {
476	- set_bad_con();
477	- return BAD_CON;
478	- }
479	-}
480	-
481	-/**
482	- * Write Single Register
483	- * FUCTION 0x06
484	- * @param address Reference Address
485	- * @param value Value to Be Written to Register
486	- */
487	-inline int modbus::modbus_write_register(uint16_t address, const uint16_t &value)
488	-{
489	- if (_connected)
490	- {
491	- modbus_write(address, 1, WRITE_REG, &value);
492	- uint8_t to_rec[MAX_MSG_LENGTH];
493	- ssize_t k = modbus_receive(to_rec);
494	- if (k == -1)
495	- {
496	- set_bad_con();
497	- return BAD_CON;
498	- }
499	- modbuserror_handle(to_rec, WRITE_COIL);
500	- if (err)
501	- return err_no;
502	- return 0;
503	- }
504	- else
505	- {
506	- set_bad_con();
507	- return BAD_CON;
508	- }
509	-}
510	-
511	-/**
512	- * Write Multiple Coils
513	- * MODBUS FUNCTION 0x0F
514	- * @param address Reference Address
515	- * @param amount Amount of Coils to Write
516	- * @param value Values to Be Written to Coils
517	- */
518	-inline int modbus::modbus_write_coils(uint16_t address, uint16_t amount, const bool *value)
519	-{
520	- if (_connected)
521	- {
522	- uint16_t *temp = new uint16_t[amount];
523	- for (int i = 0; i < amount; i++)
524	- {
525	- temp[i] = (uint16_t)value[i];
526	- }
527	- modbus_write(address, amount, WRITE_COILS, temp);
528	- delete[] temp;
529	- uint8_t to_rec[MAX_MSG_LENGTH];
530	- ssize_t k = modbus_receive(to_rec);
531	- if (k == -1)
532	- {
533	- set_bad_con();
534	- return BAD_CON;
535	- }
536	- modbuserror_handle(to_rec, WRITE_COILS);
537	- if (err)
538	- return err_no;
539	- return 0;
540	- }
541	- else
542	- {
543	- set_bad_con();
544	- return BAD_CON;
545	- }
546	-}
547	-
548	-/**
549	- * Write Multiple Registers
550	- * MODBUS FUNCION 0x10
551	- * @param address Reference Address
552	- * @param amount Amount of Value to Write
553	- * @param value Values to Be Written to the Registers
554	- */
555	-inline int modbus::modbus_write_registers(uint16_t address, uint16_t amount, const uint16_t *value)
556	-{
557	- if (_connected)
558	- {
559	- modbus_write(address, amount, WRITE_REGS, value);
560	- uint8_t to_rec[MAX_MSG_LENGTH];
561	- ssize_t k = modbus_receive(to_rec);
562	- if (k == -1)
563	- {
564	- set_bad_con();
565	- return BAD_CON;
566	- }
567	- modbuserror_handle(to_rec, WRITE_REGS);
568	- if (err)
569	- return err_no;
570	- return 0;
571	- }
572	- else
573	- {
574	- set_bad_con();
575	- return BAD_CON;
576	- }
577	-}
578	-
579	-/**
580	- * Data Sender
581	- * @param to_send Request to Be Sent to Server
582	- * @param length Length of the Request
583	- * @return Size of the request
584	- */
585	-inline ssize_t modbus::modbus_send(uint8_t *to_send, size_t length)
586	-{
587	- _msg_id++;
588	- return send(_socket, (const char *)to_send, (size_t)length, 0);
589	-}
590	-
591	-/**
592	- * Data Receiver
593	- * @param buffer Buffer to Store the Data Retrieved
594	- * @return Size of Incoming Data
595	- */
596	-inline ssize_t modbus::modbus_receive(uint8_t *buffer) const
597	-{
598	- return recv(_socket, (char *)buffer, MAX_MSG_LENGTH, 0);
599	-}
600	-
601	-inline void modbus::set_bad_con()
602	-{
603	- err = true;
604	- error_msg = "BAD CONNECTION";
605	-}
606	-
607	-inline void modbus::set_bad_input()
608	-{
609	- err = true;
610	- error_msg = "BAD FUNCTION INPUT";
611	-}
612	-
613	-/**
614	- * Error Code Handler
615	- * @param msg Message Received from the Server
616	- * @param func Modbus Functional Code
617	- */
618	-inline void modbus::modbuserror_handle(const uint8_t *msg, int func)
619	-{
620	- err = false;
621	- error_msg = "NO ERR";
622	- if (msg[7] == func + 0x80)
623	- {
624	- err = true;
625	- switch (msg[8])
626	- {
627	- case EX_ILLEGAL_FUNCTION:
628	- error_msg = "1 Illegal Function";
629	- break;
630	- case EX_ILLEGAL_ADDRESS:
631	- error_msg = "2 Illegal Address";
632	- break;
633	- case EX_ILLEGAL_VALUE:
634	- error_msg = "3 Illegal Value";
635	- break;
636	- case EX_SERVER_FAILURE:
637	- error_msg = "4 Server Failure";
638	- break;
639	- case EX_ACKNOWLEDGE:
640	- error_msg = "5 Acknowledge";
641	- break;
642	- case EX_SERVER_BUSY:
643	- error_msg = "6 Server Busy";
644	- break;
645	- case EX_NEGATIVE_ACK:
646	- error_msg = "7 Negative Acknowledge";
647	- break;
648	- case EX_MEM_PARITY_PROB:
649	- error_msg = "8 Memory Parity Problem";
650	- break;
651	- case EX_GATEWAY_PROBLEMP:
652	- error_msg = "10 Gateway Path Unavailable";
653	- break;
654	- case EX_GATEWAY_PROBLEMF:
655	- error_msg = "11 Gateway Target Device Failed to Respond";
656	- break;
657	- default:
658	- error_msg = "UNK";
659	- break;
660	- }
661	- }
662	-}
663	-

src/modbusbase.cpp 0 → 100644

View file @f848070

		1	+/*
		2	+ * Copyright (c) 2022 Peter M. Groen
		3	+ *
		4	+ * This source code is licensed under the MIT license found in the
		5	+ * LICENSE file in the root directory of this source tree.
		6	+ */
		7	+
		8	+#include "modbusbase.h"
		9	+
		10	+

src/modbusbase.h 0 → 100644

View file @f848070

		1	+/*
		2	+ * Copyright (c) 2022 Peter M. Groen
		3	+ *
		4	+ * This source code is licensed under the MIT license found in the
		5	+ * LICENSE file in the root directory of this source tree.
		6	+ */
		7	+
		8	+#pragma once
		9	+
		10	+// Create a simple logger for console output during debugging.
		11	+// TODO: Replace with a custom logger by using std::function
		12	+// to keep it consistent with TrueMQTT.
		13	+#ifdef ENABLE_MODBUS_LOGGING
		14	+#include <cstdio>
		15	+#define LOG(fmt, ...) printf("[ modbus-cpp ]" fmt, ##__VA_ARGS__)
		16	+#else
		17	+#define LOG(...) (void)0
		18	+#endif
		19	+
		20	+#define MAX_MSG_LENGTH 260
		21	+
		22	+// Function Codes
		23	+#define READ_COILS 0x01
		24	+#define READ_INPUT_BITS 0x02
		25	+#define READ_REGS 0x03
		26	+#define READ_INPUT_REGS 0x04
		27	+#define WRITE_COIL 0x05
		28	+#define WRITE_REG 0x06
		29	+#define WRITE_COILS 0x0F
		30	+#define WRITE_REGS 0x10
		31	+
		32	+// Exception codes
		33	+#define EX_ILLEGAL_FUNCTION 0x01
		34	+#define EX_ILLEGAL_ADDRESS 0x02
		35	+#define EX_ILLEGAL_VALUE 0x03
		36	+#define EX_SERVER_FAILURE 0x04
		37	+#define EX_ACKNOWLEDGE 0x05
		38	+#define EX_SERVER_BUSY 0x06
		39	+#define EX_NEGATIVE_ACK 0x07
		40	+#define EX_MEM_PARITY_PROB 0x08
		41	+#define EX_GATEWAY_PROBLEMP 0x0A
		42	+#define EX_GATEWAY_PROBLEMF 0x0B
		43	+#define EX_BAD_DATA 0xFF
		44	+
		45	+#define BAD_CON -1
		46	+
		47	+// Modbus base class. Providing all Modbus PDUs without transport implementation
		48	+class ModbusBase
		49	+{
		50	+public:
		51	+ bool err{};
		52	+ int err_no{};
		53	+ std::string m_error_msg;
		54	+
		55	+ ModbusBase();
		56	+ virtual ~ModbusBase();
		57	+
		58	+ void setSlaveId(int slave_id);
		59	+
		60	+ // Pure virtuals. Override when inherited.
		61	+ virtual bool Connect() const = 0;
		62	+ virtual void Close() = 0;
		63	+ virtual bool isConnected() const - 0;
		64	+
		65	+ // Modbus implementation(s)
		66	+ int readCoils(uint16_t address, uint16_t amount, bool *buffer); // Replace buffer with something sensible?
		67	+ int readInputBits(uint16_t address, uint16_t amount, bool *buffer); // Replace buffer with something sensible?
		68	+ int readHoldingRegisters(uint16_t address, uitn16_t amount, uint16_t *buffer);
		69	+ int readInputRegisters(uint16_t address, uint16_t amount, uint16_t *buffer);
		70	+
		71	+ int writeCoil(uint16_t address, const bool &to_write);
		72	+ int writeRegister(uint16_t address, const uint16_t &value);
		73	+ int writeCoils(uint16_t address, uint16_t amount, const bool *value);
		74	+ int writeRegisters(uint16_t address, uint16_t amount, const uint16_t *value);
		75	+
		76	+private: // Methods
		77	+ void buildRequest(uint8_t *to_send, uint16_t address, int function_code) const;
		78	+ int modbusRead(uint16_t address, uint16_t amount, int function_code);
		79	+ int modbusWrite(uint16_t address, uint16_t amount, int function_code, const uint16_t *value);
		80	+ ssize_t modbusSend(uint8_t *to_send, size_t length);
		81	+ ssize_t modbusReceive(uint8_t *buffer) const;
		82	+
		83	+ void modbusErrorHandle(const uint8_t *msg, int function_code);
		84	+ void setBadConnection();
		85	+ void setBadInput();
		86	+
		87	+private: // Members (Giggity!)
		88	+ bool m_connected{};
		89	+ uint32_t m_msg_id{};
		90	+ int m_slaveId{};
		91	+
		92	+};