UniSet 2.35.2
ModbusTypes.h
1// -------------------------------------------------------------------------
2#ifndef ModbusTypes_H_
3#define ModbusTypes_H_
4// -------------------------------------------------------------------------
5#include <ostream>
6#include <cstdint>
7#include <bitset>
8#include <string>
9#include <list>
10#include "ModbusRTUErrors.h"
11// -------------------------------------------------------------------------
12/* Основные предположения:
13 * - В случае неправильного формата пакета(запроса), логической ошибки и т.п
14 * ОТВЕТ просто не посылается, а пакет отбрасывается...
15 * - CRC считается по всей посылке (с начальным адресом)
16 * - CRC инициализируется значением 0xffff
17 * - CRC не переворачивается
18 * - Все двухбайтовые слова переворачиваются. Порядок байт: старший младший
19*/
20// -------------------------------------------------------------------------
21namespace uniset
22{
23 // -------------------------------------------------------------------------
24 namespace ModbusRTU
25 {
26 // Базовые типы
27 typedef uint8_t ModbusByte;
28 const size_t BitsPerByte = 8;
29 typedef uint8_t ModbusAddr;
30 typedef uint16_t ModbusData;
31 const uint8_t BitsPerData = 16;
32 typedef uint16_t ModbusCRC;
34 // ---------------------------------------------------------------------
36 enum SlaveFunctionCode
37 {
38 fnUnknown = 0x00,
39 fnReadCoilStatus = 0x01,
40 fnReadInputStatus = 0x02,
41 fnReadOutputRegisters = 0x03,
42 fnReadInputRegisters = 0x04,
43 fnForceSingleCoil = 0x05,
44 fnWriteOutputSingleRegister = 0x06,
45 fnDiagnostics = 0x08,
46 fnForceMultipleCoils = 0x0F,
47 fnWriteOutputRegisters = 0x10,
48 fnReadFileRecord = 0x14,
49 fnWriteFileRecord = 0x15,
50 fnMEI = 0x2B,
51 fnSetDateTime = 0x50,
52 fnRemoteService = 0x53,
53 fnJournalCommand = 0x65,
54 fnFileTransfer = 0x66
55 };
56
58 enum DiagnosticsSubFunction
59 {
60 subEcho = 0x00,
61 dgRestartComm = 0x01,
62 dgDiagReg = 0x02,
63 dgChangeASCII = 0x03,
64 dgForceListen = 0x04,
65 // 05.. 09 RESERVED
66 dgClearCounters = 0x0A,
67 dgBusMsgCount = 0x0B,
68 dgBusErrCount = 0x0C,
69 dgBusExceptCount = 0x0D,
70 dgMsgSlaveCount = 0x0E,
71 dgNoNoResponseCount = 0x0F,
72 dgSlaveNAKCount = 0x10,
73 dgSlaveBusyCount = 0x11,
74 dgBusCharOverrunCount = 0x12,
75 // = 0x13, /*!< RESERVED */
76 dgClearOverrunCounter = 0x14
77 // 21 ...65535 RESERVED
78 };
79
80
81 using RegID = size_t;
82
89 RegID genRegID( const ModbusRTU::ModbusData r, const uint8_t fn );
90
91 // определение размера данных в зависимости от типа сообщения
92 // возвращает -1 - если динамический размер сообщения или размер неизвестен
93 ssize_t szRequestDiagnosticData( DiagnosticsSubFunction f );
94
96 enum RDIObjectID
97 {
98 rdiVendorName = 0x0,
99 rdiProductCode = 0x1,
100 rdiMajorMinorRevision = 0x2,
101 rdiVendorURL = 0x3,
102 rdiProductName = 0x4,
103 rdiModelName = 0x5,
104 rdiUserApplicationName = 0x6
105 // 0x07 .. 0x7F - reserved
106 // 0x80 .. 0xFF - optionaly defined (product dependant)
107 };
108
110 enum RDIRequestDeviceID
111 {
112 rdevMinNum = 0,
113 rdevBasicDevice = 0x1, // request to get the basic device identification (stream access)
114 rdevRegularDevice = 0x2, // request to get the regular device identification (stream access)
115 rdevExtentedDevice = 0x3, // request to get the extended device identification (stream access)
116 rdevSpecificDevice = 0x4, // request to get the extended device identification (stream access)
117 rdevMaxNum = 0x5
118 };
119
120 std::string rdi2str( int id );
121 // -----------------------------------------------------------------------
122
124 enum
125 {
127 MAXLENPACKET = 508,
128 BroadcastAddr = 0,
129 MAXPDULEN = 253, // 255 - 2(CRC)
130 MAXDATALEN = 125
134 };
135
136 const uint8_t MBErrMask = 0x80;
137 // ---------------------------------------------------------------------
138 uint16_t SWAPSHORT( uint16_t x );
139 // ---------------------------------------------------------------------
141 ModbusCRC checkCRC( ModbusByte* start, size_t len );
142 const size_t szCRC = sizeof(ModbusCRC);
143 // ---------------------------------------------------------------------
145 std::ostream& mbPrintMessage(std::ostream& os, ModbusByte* b, size_t len );
146 // -------------------------------------------------------------------------
147 ModbusAddr str2mbAddr( const std::string& val );
148 ModbusData str2mbData( const std::string& val );
149 std::string dat2str( const ModbusData dat );
150 std::string addr2str( const ModbusAddr addr );
151 std::string b2str( const ModbusByte b );
152 // -------------------------------------------------------------------------
153 float dat2f( const ModbusData dat1, const ModbusData dat2 );
154 size_t numBytes( const size_t nbits ); // сколько байт нужно для указанного количества бит
155 // -------------------------------------------------------------------------
156 // вспомогательная структура для предотвращения утечки памяти (RAII)
158 {
159 DataGuard( size_t sz ):
160 len(sz)
161 {
162 data = new ModbusRTU::ModbusData[sz];
163 }
164
165 ~DataGuard()
166 {
167 delete[] data;
168 }
169
170 ModbusRTU::ModbusData* data;
171 size_t len;
172 };
173 // -----------------------------------------------------------------------------
174 bool isWriteFunction( SlaveFunctionCode c );
175 bool isReadFunction( SlaveFunctionCode c );
176 // -------------------------------------------------------------------------
179 {
180 ModbusAddr addr;
181 ModbusByte func;
183 ModbusHeader(): addr(0), func(0) {}
184 } __attribute__((packed));
185
186 const size_t szModbusHeader = sizeof(ModbusHeader);
187
188 std::ostream& operator<<(std::ostream& os, const ModbusHeader& m );
189 std::ostream& operator<<(std::ostream& os, const ModbusHeader* m );
190 // -----------------------------------------------------------------------
192 {
193 ModbusRTU::ModbusData tID;
194 ModbusRTU::ModbusData pID;
195 ModbusRTU::ModbusData len;
197 MBAPHeader(): tID(0), pID(0), len(0) {}
198
199 void swapdata();
200
201 } __attribute__((packed));
202
203 std::ostream& operator<<(std::ostream& os, const MBAPHeader& m );
204 // -----------------------------------------------------------------------
205
210 {
212
213 ModbusMessage( ModbusMessage&& ) = default;
214 ModbusMessage& operator=(ModbusMessage&& ) = default;
215 ModbusMessage( const ModbusMessage& ) = default;
216 ModbusMessage& operator=(const ModbusMessage& ) = default;
217
218 inline ModbusByte func() const
219 {
220 return pduhead.func;
221 }
222 inline ModbusAddr addr() const
223 {
224 return pduhead.addr;
225 }
226 inline ModbusRTU::ModbusData tID() const
227 {
228 return mbaphead.tID;
229 }
230 inline ModbusRTU::ModbusData pID() const
231 {
232 return mbaphead.pID;
233 }
234 inline ModbusRTU::ModbusData aduLen() const
235 {
236 return mbaphead.len;
237 }
238
239 u_int8_t* buf();
240 ModbusRTU::ModbusData len() const;
241 void swapHead();
242 void makeMBAPHeader( ModbusRTU::ModbusData tID, bool noCRC = true, ModbusRTU::ModbusData pID = 0 );
243
244 ModbusRTU::ModbusData pduLen() const;
245 ModbusCRC pduCRC( size_t len ) const;
246 static size_t maxSizeOfMessage();
247
248 void clear();
249
250 MBAPHeader mbaphead;
251 ModbusHeader pduhead;
252 ModbusByte data[MAXLENPACKET + szCRC];
254 // Это поле вспомогательное и игнорируется при пересылке
255 size_t dlen = { 0 };
256 } __attribute__((packed));
257
258 std::ostream& operator<<(std::ostream& os, const ModbusMessage& m );
259 std::ostream& operator<<(std::ostream& os, const ModbusMessage* m );
260 // -----------------------------------------------------------------------
263 public ModbusHeader
264 {
265 ModbusByte ecode = { erNoError };
266 ModbusCRC crc = { 0 };
267
268 // ------- from slave -------
269 ErrorRetMessage( const ModbusMessage& m );
270 ErrorRetMessage& operator=( const ModbusMessage& m );
271 void init( const ModbusMessage& m );
272 static ModbusCRC getCrc( const ModbusMessage& m );
273 static ModbusCRC calcCRC( const ModbusMessage& m );
274
275 // ------- to master -------
276 ErrorRetMessage( ModbusAddr _from, ModbusByte _func, ModbusByte ecode );
277 static void make_to( ModbusAddr addr, ModbusByte _func, ModbusByte ecode, ModbusMessage& m );
278
281 void transport_msg_to( ModbusMessage& m ) const;
282
286 inline static size_t szData()
287 {
288 return sizeof(ModbusByte) + szCRC;
289 }
290 };
291
292 std::ostream& operator<<(std::ostream& os, ErrorRetMessage& m );
293 std::ostream& operator<<(std::ostream& os, ErrorRetMessage* m );
294 // -----------------------------------------------------------------------
295 struct DataBits
296 {
297 DataBits( ModbusByte b );
298 DataBits( std::string s ); // example "10001111"
299 DataBits();
300
301 const DataBits& operator=(const ModbusByte& r);
302
303 operator ModbusByte();
304 ModbusByte mbyte();
305
306 bool operator[] ( const size_t i ) const
307 {
308 return b[i];
309 }
310 void set( int n, bool s )
311 {
312 b.set(n, s);
313 }
314
315 std::bitset<BitsPerByte> b;
316 };
317
318 std::ostream& operator<<(std::ostream& os, DataBits& m );
319 std::ostream& operator<<(std::ostream& os, DataBits* m );
320 // -----------------------------------------------------------------------
322 {
323 DataBits16( ModbusData d );
324 DataBits16( const std::string& s ); // example "1000111110001111"
325 DataBits16();
326
327 const DataBits16& operator=(const ModbusData& r);
328
329 operator ModbusData();
330 ModbusData mdata() const;
331
332 bool operator[]( const size_t i ) const
333 {
334 return b[i];
335 }
336 void set( int n, bool s )
337 {
338 b.set(n, s);
339 }
340 void reset()
341 {
342 b.reset();
343 }
344
345 std::bitset<BitsPerData> b;
346 };
347
348 std::ostream& operator<<(std::ostream& os, DataBits16& m );
349 std::ostream& operator<<(std::ostream& os, DataBits16* m );
350 // -----------------------------------------------------------------------
352 {
353 ModbusByte bcnt = { 0 };
354 ModbusByte data[MAXPDULEN];
356 BitsBuffer();
357
362 bool addData( DataBits d );
363
371 bool setBit( uint8_t dnum, uint8_t bnum, bool state );
372
379 bool setByBitNum( uint16_t num, bool state );
380
387 bool getData( uint8_t dnum, DataBits& d ) const;
388
395 bool getByBitNum( uint16_t num, bool& state ) const;
396
404 bool getBit( uint8_t dnum, uint8_t bnum, bool& state ) const;
405
407 void clear();
408
410 inline bool isFull() const
411 {
412 return ( (size_t)bcnt >= sizeof(data) );
413 }
414 };
415 std::ostream& operator<<(std::ostream& os, BitsBuffer& m );
416 std::ostream& operator<<(std::ostream& os, BitsBuffer* m );
417 // -----------------------------------------------------------------------
420 public ModbusHeader
421 {
422 ModbusData start = { 0 };
423 ModbusData count = { 0 };
424 ModbusCRC crc = { 0 };
425
426 // ------- to slave -------
427 ReadCoilMessage( ModbusAddr addr, ModbusData start, ModbusData count );
428 static void make_to( ModbusAddr addr, ModbusData start, ModbusData count, ModbusMessage& m );
429
432 void transport_msg_to( ModbusMessage& m ) const;
433
434 // ------- from master -------
435 ReadCoilMessage( const ModbusMessage& m );
436 ReadCoilMessage& operator=( const ModbusMessage& m );
437 void init( const ModbusMessage& m );
438 static ModbusCRC getCrc( const ModbusMessage& m );
439 static ModbusCRC calcCRC( const ModbusMessage& m );
440
442 inline static size_t szData()
443 {
444 return sizeof(ModbusData) * 2 + szCRC;
445 }
446
447 } __attribute__((packed));
448
449 std::ostream& operator<<(std::ostream& os, ReadCoilMessage& m );
450 std::ostream& operator<<(std::ostream& os, ReadCoilMessage* m );
451
452 // -----------------------------------------------------------------------
455 public ModbusHeader,
456 public BitsBuffer
457 {
458 // ------- from slave -------
460 ReadCoilRetMessage& operator=( const ModbusMessage& m );
461 void init( const ModbusMessage& m );
462 static ModbusCRC getCrc( const ModbusMessage& m );
463 static ModbusCRC calcCRC( const ModbusMessage& m );
464
468 static inline int szHead()
469 {
470 return sizeof(ModbusByte); // bcnt
471 }
472
474 static size_t getDataLen( const ModbusMessage& m );
475 ModbusCRC crc = { 0 };
476
478 size_t szData() const;
479
480 // ------- to master -------
481 ReadCoilRetMessage( ModbusAddr _from );
482
485 void transport_msg_to( ModbusMessage& m ) const;
486 };
487
488 std::ostream& operator<<(std::ostream& os, ReadCoilRetMessage& m );
489 std::ostream& operator<<(std::ostream& os, ReadCoilRetMessage* m );
490 // -----------------------------------------------------------------------
493 public ModbusHeader
494 {
495 ModbusData start = { 0 };
496 ModbusData count = { 0 };
497 ModbusCRC crc = { 0 };
498
499 // ------- to slave -------
500 ReadInputStatusMessage( ModbusAddr addr, ModbusData start, ModbusData count );
501 static void make_to( ModbusAddr addr, ModbusData start, ModbusData count, ModbusMessage& m );
502
505 void transport_msg_to( ModbusMessage& m ) const;
506
507 // ------- from master -------
509 ReadInputStatusMessage& operator=( const ModbusMessage& m );
510
511 void init( const ModbusMessage& m );
512 static ModbusCRC getCrc( const ModbusMessage& m );
513 static ModbusCRC calcCRC( const ModbusMessage& m );
514
516 inline static size_t szData()
517 {
518 return sizeof(ModbusData) * 2 + szCRC;
519 }
520
521 } __attribute__((packed));
522
523 std::ostream& operator<<(std::ostream& os, ReadInputStatusMessage& m );
524 std::ostream& operator<<(std::ostream& os, ReadInputStatusMessage* m );
525 // -----------------------------------------------------------------------
528 public ModbusHeader,
529 public BitsBuffer
530 {
531 // ------- from slave -------
533 ReadInputStatusRetMessage& operator=( const ModbusMessage& m );
534 void init( const ModbusMessage& m );
535 static ModbusCRC getCrc( const ModbusMessage& m );
536 static ModbusCRC calcCRC( const ModbusMessage& m );
537
541 static inline size_t szHead()
542 {
543 return sizeof(ModbusByte); // bcnt
544 }
545
547 static size_t getDataLen( const ModbusMessage& m );
548 ModbusCRC crc = { 0 };
549
551 size_t szData() const;
552
553 // ------- to master -------
554 ReadInputStatusRetMessage( ModbusAddr _from );
555
558 void transport_msg_to( ModbusMessage& m ) const;
559 };
560
561 std::ostream& operator<<(std::ostream& os, ReadInputStatusRetMessage& m );
562 std::ostream& operator<<(std::ostream& os, ReadInputStatusRetMessage* m );
563 // -----------------------------------------------------------------------
564
567 public ModbusHeader
568 {
569 ModbusData start = { 0 };
570 ModbusData count = { 0 };
571 ModbusCRC crc = { 0 };
572
573 // ------- to slave -------
574 ReadOutputMessage( ModbusAddr addr, ModbusData start, ModbusData count );
575 static void make_to( ModbusAddr addr, ModbusData start, ModbusData count, ModbusMessage& m );
578 void transport_msg_to( ModbusMessage& m ) const;
579
580 // ------- from master -------
582 ReadOutputMessage& operator=( const ModbusMessage& m );
583 void init( const ModbusMessage& m );
584 static ModbusCRC getCrc( const ModbusMessage& m );
585 static ModbusCRC calcCRC( const ModbusMessage& m );
586
588 inline static size_t szData()
589 {
590 return sizeof(ModbusData) * 2 + szCRC;
591 }
592
593 } __attribute__((packed));
594
595 std::ostream& operator<<(std::ostream& os, ReadOutputMessage& m );
596 std::ostream& operator<<(std::ostream& os, ReadOutputMessage* m );
597 // -----------------------------------------------------------------------
600 public ModbusHeader
601 {
602 ModbusByte bcnt = { 0 };
603 ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
605 // ------- from slave -------
607 ReadOutputRetMessage& operator=( const ModbusMessage& m );
608 void init( const ModbusMessage& m );
609 static ModbusCRC getCrc( const ModbusMessage& m );
610 static ModbusCRC calcCRC( const ModbusMessage& m );
611
615 static inline size_t szHead()
616 {
617 // bcnt
618 return sizeof(ModbusByte);
619 }
620
622 static size_t getDataLen( const ModbusMessage& m );
623 ModbusCRC crc = { 0 };
624
625 // ------- to master -------
626 ReadOutputRetMessage( ModbusAddr _from );
627
632 bool addData( ModbusData d );
633
635 void clear();
636
638 inline bool isFull() const
639 {
640 return ( count * sizeof(ModbusData) >= MAXLENPACKET );
641 }
642
644 size_t szData() const;
645
648 void transport_msg_to( ModbusMessage& m ) const;
649
650 // Это поле не входит в стандарт modbus
651 // оно вспомогательное и игнорируется при
652 // преобразовании в ModbusMessage.
653 // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
654 // Используйте специальную функцию transport_msg()
655 size_t count = { 0 };
656 };
657
658 std::ostream& operator<<(std::ostream& os, ReadOutputRetMessage& m );
659 std::ostream& operator<<(std::ostream& os, ReadOutputRetMessage* m );
660 // -----------------------------------------------------------------------
663 public ModbusHeader
664 {
665 ModbusData start = { 0 };
666 ModbusData count = { 0 };
667 ModbusCRC crc = { 0 };
668
669 // ------- to slave -------
670 ReadInputMessage( ModbusAddr addr, ModbusData start, ModbusData count );
671 static void make_to( ModbusAddr addr, ModbusData start, ModbusData count, ModbusMessage& m );
674 void transport_msg_to( ModbusMessage& m ) const;
675
676 // ------- from master -------
678 ReadInputMessage& operator=( const ModbusMessage& m );
679 void init( const ModbusMessage& m );
680 static ModbusCRC getCrc( const ModbusMessage& m );
681 static ModbusCRC calcCRC( const ModbusMessage& m );
682
684 inline static size_t szData()
685 {
686 return sizeof(ModbusData) * 2 + szCRC;
687 }
688
689 } __attribute__((packed));
690
691 std::ostream& operator<<(std::ostream& os, ReadInputMessage& m );
692 std::ostream& operator<<(std::ostream& os, ReadInputMessage* m );
693 // -----------------------------------------------------------------------
694
697 public ModbusHeader
698 {
699 ModbusByte bcnt = { 0 };
700 ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
702 // ------- from slave -------
704 ReadInputRetMessage& operator=( const ModbusMessage& m );
705 void init( const ModbusMessage& m );
706 static ModbusCRC getCrc( const ModbusMessage& m );
707 static ModbusCRC calcCRC( const ModbusMessage& m );
708
712 static inline size_t szHead()
713 {
714 // bcnt
715 return sizeof(ModbusByte);
716 }
717
719 static size_t getDataLen( const ModbusMessage& m );
720 ModbusCRC crc = { 0 };
721
722 // ------- to master -------
723 ReadInputRetMessage( ModbusAddr _from );
724
729 bool addData( ModbusData d );
730
732 void clear();
733
735 inline bool isFull() const
736 {
737 return ( count * sizeof(ModbusData) >= MAXLENPACKET );
738 }
739
740 void swapData();
741
743 size_t szData() const;
744
747 void transport_msg_to( ModbusMessage& m ) const;
748
749 // Это поле не входит в стандарт modbus
750 // оно вспомогательное и игнорируется при
751 // преобразовании в ModbusMessage.
752 // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
753 // Используйте специальную функцию transport_msg()
754 size_t count = { 0 };
755 };
756
757 std::ostream& operator<<(std::ostream& os, ReadInputRetMessage& m );
758 std::ostream& operator<<(std::ostream& os, ReadInputRetMessage* m );
759 // -----------------------------------------------------------------------
762 public ModbusHeader
763 {
764 ModbusData start = { 0 };
765 ModbusData quant = { 0 };
766 ModbusByte bcnt = { 0 };
768 ModbusByte data[MAXLENPACKET - sizeof(ModbusData) * 2 - sizeof(ModbusByte)];
769 ModbusCRC crc = { 0 };
771 // ------- to slave -------
772 ForceCoilsMessage( ModbusAddr addr, ModbusData start );
775 void transport_msg_to( ModbusMessage& m ) const;
776
781 bool addData( DataBits d );
782
783 // return number of bit
784 // -1 - error
785 int addBit( bool state );
786
787 bool setBit( uint8_t nbit, bool state );
788
789 inline size_t last() const
790 {
791 return quant;
792 }
793
800 bool getData( uint8_t dnum, DataBits& d ) const;
801
802 void clear();
803 inline bool isFull() const
804 {
805 return ( (int)bcnt >= MAXPDULEN );
806 }
807
808 // ------- from master -------
809 ForceCoilsMessage( const ModbusMessage& m );
810 ForceCoilsMessage& operator=( const ModbusMessage& m );
811 void init( const ModbusMessage& m );
812 static ModbusCRC getCrc( const ModbusMessage& m );
813 static ModbusCRC calcCRC( const ModbusMessage& m );
814
816 size_t szData() const;
817
821 static inline size_t szHead()
822 {
823 // start + quant + count
824 return sizeof(ModbusData) * 2 + sizeof(ModbusByte);
825 }
826
828 static size_t getDataLen( const ModbusMessage& m );
829
831 static bool checkFormat( const ModbusMessage& m );
832
833 } __attribute__((packed));
834
835 std::ostream& operator<<(std::ostream& os, ForceCoilsMessage& m );
836 std::ostream& operator<<(std::ostream& os, ForceCoilsMessage* m );
837 // -----------------------------------------------------------------------
840 public ModbusHeader
841 {
842 ModbusData start = { 0 };
843 ModbusData quant = { 0 };
844 ModbusCRC crc = { 0 };
845
846 // ------- from slave -------
848 ForceCoilsRetMessage& operator=( const ModbusMessage& m );
849 void init( const ModbusMessage& m );
850 static ModbusCRC getCrc( const ModbusMessage& m );
851 static ModbusCRC calcCRC( const ModbusMessage& m );
852
853 // ------- to master -------
859 ForceCoilsRetMessage( ModbusAddr _from, ModbusData start = 0, ModbusData quant = 0 );
860 static void make_to( ModbusAddr _from, ModbusData start, ModbusData count, ModbusMessage& m );
861
863 void set( ModbusData start, ModbusData quant );
864
867 void transport_msg_to( ModbusMessage& m ) const;
868
872 inline static size_t szData()
873 {
874 return sizeof(ModbusData) * 2 + sizeof(ModbusCRC);
875 }
876 };
877
878 std::ostream& operator<<(std::ostream& os, ForceCoilsRetMessage& m );
879 std::ostream& operator<<(std::ostream& os, ForceCoilsRetMessage* m );
880 // -----------------------------------------------------------------------
881
884 public ModbusHeader
885 {
886 ModbusData start = { 0 };
887 ModbusData quant = { 0 };
888 ModbusByte bcnt = { 0 };
890 ModbusData data[MAXLENPACKET / sizeof(ModbusData) - sizeof(ModbusData) * 2 - sizeof(ModbusByte)];
891 ModbusCRC crc = { 0 };
893 // ------- to slave -------
894 WriteOutputMessage( ModbusAddr addr, ModbusData start );
897 void transport_msg_to( ModbusMessage& m ) const;
898
899 bool addData( ModbusData d );
900 void clear();
901 inline bool isFull() const
902 {
903 return ( quant >= MAXDATALEN );
904 }
905
906 // ------- from master -------
908 WriteOutputMessage& operator=( const ModbusMessage& m );
909 void init( const ModbusMessage& m );
910 static ModbusCRC getCrc( const ModbusMessage& m );
911 static ModbusCRC calcCRC( const ModbusMessage& m );
912
914 size_t szData() const;
915
919 static inline size_t szHead()
920 {
921 // start + quant + count
922 return sizeof(ModbusData) * 2 + sizeof(ModbusByte);
923 }
924
926 static size_t getDataLen( const ModbusMessage& m );
927
929 static bool checkFormat( const ModbusMessage& m );
930
931 } __attribute__((packed));
932
933
934 std::ostream& operator<<(std::ostream& os, WriteOutputMessage& m );
935 std::ostream& operator<<(std::ostream& os, WriteOutputMessage* m );
936
939 public ModbusHeader
940 {
941 ModbusData start = { 0 };
942 ModbusData quant = { 0 };
944 // ------- from slave -------
946 WriteOutputRetMessage& operator=( const ModbusMessage& m );
947 void init( const ModbusMessage& m );
948 static ModbusCRC getCrc( const ModbusMessage& m );
949 static ModbusCRC calcCRC( const ModbusMessage& m );
950 ModbusCRC crc = { 0 };
951
952 // ------- to master -------
958 WriteOutputRetMessage( ModbusAddr _from, ModbusData start = 0, ModbusData quant = 0 );
959 static void make_to( ModbusAddr _from, ModbusData start, ModbusData quant, ModbusMessage& m );
960
962 void set( ModbusData start, ModbusData quant );
963
966 void transport_msg_to( ModbusMessage& m ) const;
967
971 inline static size_t szData()
972 {
973 return sizeof(ModbusData) * 2 + sizeof(ModbusCRC);
974 }
975 };
976
977 std::ostream& operator<<(std::ostream& os, WriteOutputRetMessage& m );
978 std::ostream& operator<<(std::ostream& os, WriteOutputRetMessage* m );
979 // -----------------------------------------------------------------------
982 public ModbusHeader
983 {
984 ModbusData start = { 0 };
985 ModbusData data = { 0 };
986 ModbusCRC crc = { 0 };
989 inline bool cmd() const
990 {
991 return (data & 0xFF00);
992 }
993
994 // ------- to slave -------
995 ForceSingleCoilMessage( ModbusAddr addr, ModbusData reg, bool state );
996 static void make_to( ModbusAddr addr, ModbusData ref, bool state, ModbusMessage& m );
999 void transport_msg_to( ModbusMessage& m ) const;
1000
1001 // ------- from master -------
1003 ForceSingleCoilMessage& operator=( const ModbusMessage& m );
1004 void init( const ModbusMessage& m );
1005 static ModbusCRC getCrc( const ModbusMessage& m );
1006 static ModbusCRC calcCRC( const ModbusMessage& m );
1007
1009 static size_t szData();
1010
1014 static inline size_t szHead()
1015 {
1016 return sizeof(ModbusData);
1017 }
1018
1022 static size_t getDataLen( const ModbusMessage& m );
1023
1025 static bool checkFormat( const ModbusMessage& m );
1026 } __attribute__((packed));
1027
1028
1029 std::ostream& operator<<(std::ostream& os, ForceSingleCoilMessage& m );
1030 std::ostream& operator<<(std::ostream& os, ForceSingleCoilMessage* m );
1031 // -----------------------------------------------------------------------
1032
1035 public ModbusHeader
1036 {
1037 ModbusData start = { 0 };
1038 ModbusData data = { 0 };
1039 ModbusCRC crc = { 0 };
1040
1042 inline bool cmd() const
1043 {
1044 return (data & 0xFF00);
1045 }
1046
1047 // ------- from slave -------
1049 ForceSingleCoilRetMessage& operator=( const ModbusMessage& m );
1050 void init( const ModbusMessage& m );
1051 static ModbusCRC getCrc( const ModbusMessage& m );
1052 static ModbusCRC calcCRC( const ModbusMessage& m );
1053
1054 // ------- to master -------
1058 ForceSingleCoilRetMessage( ModbusAddr _from );
1059 static void make_to( ModbusAddr addr, ModbusData start, bool cmd, ModbusMessage& m );
1060
1062 void set( ModbusData start, bool cmd );
1063
1066 void transport_msg_to( ModbusMessage& m ) const;
1067
1071 inline static size_t szData()
1072 {
1073 return 2 * sizeof(ModbusData) + sizeof(ModbusCRC);
1074 }
1075 };
1076
1077 std::ostream& operator<<(std::ostream& os, ForceSingleCoilRetMessage& m );
1078 std::ostream& operator<<(std::ostream& os, ForceSingleCoilRetMessage* m );
1079 // -----------------------------------------------------------------------
1080
1083 public ModbusHeader
1084 {
1085 ModbusData start = { 0 };
1086 ModbusData data = { 0 };
1087 ModbusCRC crc = { 0 };
1090 // ------- to slave -------
1091 WriteSingleOutputMessage( ModbusAddr addr, ModbusData reg = 0, ModbusData data = 0 );
1092 static void make_to( ModbusAddr addr, ModbusData start, ModbusData data, ModbusMessage& m );
1095 void transport_msg_to( ModbusMessage& m ) const;
1096
1097 // ------- from master -------
1099 WriteSingleOutputMessage& operator=( const ModbusMessage& m );
1100 void init( const ModbusMessage& m );
1101 static ModbusCRC getCrc( const ModbusMessage& m );
1102 static ModbusCRC calcCRC( const ModbusMessage& m );
1103
1105 static size_t szData();
1106
1110 static inline size_t szHead()
1111 {
1112 return sizeof(ModbusData);
1113 }
1114
1118 static size_t getDataLen( const ModbusMessage& m );
1119
1121 static bool checkFormat( const ModbusMessage& m );
1122 } __attribute__((packed));
1123
1124
1125 std::ostream& operator<<(std::ostream& os, WriteSingleOutputMessage& m );
1126 std::ostream& operator<<(std::ostream& os, WriteSingleOutputMessage* m );
1127 // -----------------------------------------------------------------------
1128
1131 public ModbusHeader
1132 {
1133 ModbusData start = { 0 };
1134 ModbusData data = { 0 };
1135 ModbusCRC crc = { 0 };
1136
1137
1138 // ------- from slave -------
1140 WriteSingleOutputRetMessage& operator=( const ModbusMessage& m );
1141 void init( const ModbusMessage& m );
1142 static ModbusCRC getCrc( const ModbusMessage& m );
1143 static ModbusCRC calcCRC( const ModbusMessage& m );
1144
1145 // ------- to master -------
1150 WriteSingleOutputRetMessage( ModbusAddr _from, ModbusData start = 0 );
1151 static void make_to( ModbusAddr addr, ModbusData start, ModbusData data, ModbusMessage& m );
1152
1154 void set( ModbusData start, ModbusData data );
1155
1158 void transport_msg_to( ModbusMessage& m ) const;
1159
1163 inline static size_t szData()
1164 {
1165 return 2 * sizeof(ModbusData) + sizeof(ModbusCRC);
1166 }
1167 };
1168
1169 std::ostream& operator<<(std::ostream& os, WriteSingleOutputRetMessage& m );
1170 std::ostream& operator<<(std::ostream& os, WriteSingleOutputRetMessage* m );
1171 // -----------------------------------------------------------------------
1174 public ModbusHeader
1175 {
1176 ModbusData subf = { 0 };
1177 ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
1179 // ------- from slave -------
1180 DiagnosticMessage( const ModbusMessage& m );
1181 DiagnosticMessage& operator=( const ModbusMessage& m );
1182 void init( const ModbusMessage& m );
1183 static ModbusCRC getCrc( const ModbusMessage& m );
1184 static ModbusCRC calcCRC( const ModbusMessage& m );
1185
1189 static inline size_t szHead()
1190 {
1191 return sizeof(ModbusData); // subf
1192 }
1193
1195 static size_t getDataLen( const ModbusMessage& m );
1196 ModbusCRC crc = { 0 };
1197
1198 // ------- to master -------
1199 DiagnosticMessage( ModbusAddr _from, DiagnosticsSubFunction subf, ModbusData d = 0 );
1200
1205 bool addData( ModbusData d );
1206
1208 void clear();
1209
1211 inline bool isFull() const
1212 {
1213 // (1)subf + data count
1214 return ( 1 + count >= MAXDATALEN );
1215 }
1216
1218 size_t szData() const;
1219
1222 void transport_msg_to( ModbusMessage& m ) const;
1223
1224 // Это поле не входит в стандарт modbus
1225 // оно вспомогательное и игнорируется при
1226 // преобразовании в ModbusMessage.
1227 // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
1228 // Используйте специальную функцию transport_msg()
1229 size_t count = { 0 };
1230 };
1231 std::ostream& operator<<(std::ostream& os, DiagnosticMessage& m );
1232 std::ostream& operator<<(std::ostream& os, DiagnosticMessage* m );
1233 // -----------------------------------------------------------------------
1236 public DiagnosticMessage
1237 {
1240 DiagnosticRetMessage( ModbusAddr a, DiagnosticsSubFunction subf, ModbusData d = 0 );
1241 };
1242
1243 std::ostream& operator<<(std::ostream& os, DiagnosticRetMessage& m );
1244 std::ostream& operator<<(std::ostream& os, DiagnosticRetMessage* m );
1245 // -----------------------------------------------------------------------
1248 public ModbusHeader
1249 {
1250 ModbusByte type;
1251 ModbusByte devID;
1252 ModbusByte objID;
1254 ModbusCRC crc = { 0 };
1256 // ------- to slave -------
1257 MEIMessageRDI( ModbusAddr addr, ModbusByte devID, ModbusByte objID );
1258 static void make_to( ModbusAddr addr, ModbusByte devID, ModbusByte objID, ModbusMessage& m );
1259
1262 void transport_msg_to( ModbusMessage& m ) const;
1263
1264 // ------- from master -------
1265 MEIMessageRDI( const ModbusMessage& m );
1266 MEIMessageRDI& operator=( const ModbusMessage& m );
1267 void init( const ModbusMessage& m );
1268 static ModbusCRC getCrc( const ModbusMessage& m );
1269 static ModbusCRC calcCRC( const ModbusMessage& m );
1270
1274 static inline size_t szHead()
1275 {
1276 return sizeof(ModbusByte) * 3;
1277 }
1278
1280 static inline size_t szData()
1281 {
1282 return sizeof(ModbusByte) * 3 + szCRC;
1283 }
1284
1285 // вспомогательные функции
1286 bool checkFormat() const;
1287
1288 } __attribute__((packed));
1289 // -----------------------------------------------------------------------
1290 std::ostream& operator<<(std::ostream& os, MEIMessageRDI& m );
1291 std::ostream& operator<<(std::ostream& os, MEIMessageRDI* m );
1292 // -----------------------------------------------------------------------
1293
1295 {
1296 RDIObjectInfo(): id(0), val("") {}
1297 RDIObjectInfo( ModbusByte id, const std::string& v ): id(id), val(v) {}
1298 RDIObjectInfo( ModbusByte id, const ModbusByte* dat, ModbusByte len );
1299
1300 ModbusByte id;
1301 std::string val;
1302 };
1303
1304 using RDIObjectList = std::list<RDIObjectInfo>;
1305
1308 public ModbusHeader
1309 {
1310 ModbusByte type;
1311 ModbusByte devID;
1312 ModbusByte conformity;
1313 ModbusByte mf;
1314 ModbusByte objID;
1315 ModbusByte objNum;
1317 RDIObjectList dlist;
1318 ModbusCRC crc = { 0 };
1319
1320 // ------- from slave -------
1322 MEIMessageRetRDI( const ModbusMessage& m );
1323 MEIMessageRetRDI& operator=( const ModbusMessage& m );
1324 void init( const ModbusMessage& m );
1325 static ModbusCRC getCrc( const ModbusMessage& m );
1326 static ModbusCRC calcCRC( const ModbusMessage& m );
1327
1328 // предварительная инициализации, только заголовочной части, без данных
1329 void pre_init( const ModbusMessage& m );
1330
1332 static inline size_t szHead()
1333 {
1334 return sizeof(ModbusByte) * 6;
1335 }
1336
1337 // /*! узнать длину данных следующих за предварительным заголовком ( в байтах ) */
1338 // static int getDataLen( ModbusMessage& m );
1339
1340 // ------- to master -------
1341 MEIMessageRetRDI( ModbusAddr _from, ModbusByte devID, ModbusByte conformity, ModbusByte mf, ModbusByte objID );
1342
1347 bool addData( ModbusByte id, const std::string& value );
1348 bool addData( RDIObjectInfo& dat );
1349
1351 void clear();
1352
1354 inline bool isFull() const
1355 {
1356 return ( bcnt >= MAXPDULEN );
1357 }
1358
1360 size_t szData() const;
1361
1364 void transport_msg_to( ModbusMessage& m ) const;
1365
1366 size_t bcnt = { 0 };
1367 };
1368
1369 std::ostream& operator<<(std::ostream& os, MEIMessageRetRDI& m );
1370 std::ostream& operator<<(std::ostream& os, MEIMessageRetRDI* m );
1371 std::ostream& operator<<(std::ostream& os, RDIObjectList& dl );
1372 std::ostream& operator<<(std::ostream& os, RDIObjectList* dl );
1373 // -----------------------------------------------------------------------
1374 // -----------------------------------------------------------------------
1375
1378 public ModbusHeader
1379 {
1380 ModbusData cmd = { 0 };
1381 ModbusData num = { 0 };
1382 ModbusCRC crc = { 0 };
1383
1384 // -------------
1386 JournalCommandMessage& operator=( const ModbusMessage& m );
1387 static ModbusCRC getCrc( const ModbusMessage& m );
1388 static ModbusCRC calcCRC( const ModbusMessage& m );
1389
1391 inline static size_t szData()
1392 {
1393 return sizeof(ModbusData) * 2 + szCRC;
1394 }
1395
1396 } __attribute__((packed));
1397
1398 std::ostream& operator<<(std::ostream& os, JournalCommandMessage& m );
1399 std::ostream& operator<<(std::ostream& os, JournalCommandMessage* m );
1400 // -----------------------------------------------------------------------
1403 public ModbusHeader
1404 {
1405 ModbusByte bcnt = { 0 };
1406 // ModbusByte data[MAXLENPACKET-1]; /*!< данные */
1407
1408 // В связи со спецификой реализации ответной части (т.е. modbus master)
1409 // данные приходится делать не байтовым потоком, а "словами"
1410 // которые в свою очередь будут перевёрнуты при посылке...
1411 ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
1413 // -------------
1414 JournalCommandRetMessage( ModbusAddr _from );
1415
1422 bool setData( ModbusByte* b, int len );
1423
1425 void clear();
1426
1428 inline bool isFull() const
1429 {
1430 return ( count >= MAXDATALEN );
1431 }
1432
1434 size_t szData() const;
1435
1436 static ModbusCRC getCrc( const ModbusMessage& m );
1437 static ModbusCRC calcCRC( const ModbusMessage& m );
1438
1441 void transport_msg_to( ModbusMessage& m ) const;
1442
1443 // Это поле не входит в стандарт modbus
1444 // оно вспомогательное и игнорируется при
1445 // преобразовании в ModbusMessage.
1446 // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
1447 // Используйте специальную функцию transport_msg()
1448 size_t count = { 0 };
1449 };
1450
1451 std::ostream& operator<<(std::ostream& os, JournalCommandRetMessage& m );
1452 std::ostream& operator<<(std::ostream& os, JournalCommandRetMessage* m );
1453 // -----------------------------------------------------------------------
1459 {
1460 // -------------
1461 JournalCommandRetOK( ModbusAddr _from );
1462 void set( ModbusData cmd, ModbusData ecode );
1463 static void set( JournalCommandRetMessage& m, ModbusData cmd, ModbusData ecode );
1464 };
1465
1466 std::ostream& operator<<(std::ostream& os, JournalCommandRetOK& m );
1467 std::ostream& operator<<(std::ostream& os, JournalCommandRetOK* m );
1468 // -----------------------------------------------------------------------
1469
1472 public ModbusHeader
1473 {
1474 ModbusByte hour = { 0 };
1475 ModbusByte min = { 0 };
1476 ModbusByte sec = { 0 };
1477 ModbusByte day = { 1 };
1478 ModbusByte mon = { 1 };
1479 ModbusByte year = { 0 };
1480 ModbusByte century = { 20 };
1482 ModbusCRC crc = { 0 };
1483
1484 // ------- to slave -------
1485 SetDateTimeMessage( ModbusAddr addr );
1488 void transport_msg_to( ModbusMessage& m ) const;
1489
1490 // ------- from master -------
1492 SetDateTimeMessage& operator=( const ModbusMessage& m );
1494 static ModbusCRC getCrc( const ModbusMessage& m );
1495 static ModbusCRC calcCRC( const ModbusMessage& m );
1496
1497 static bool checkFormat( const ModbusMessage& m );
1498
1500 inline static size_t szData()
1501 {
1502 return sizeof(ModbusByte) * 7 + szCRC;
1503 }
1504
1505 } __attribute__((packed));
1506
1507 std::ostream& operator<<(std::ostream& os, SetDateTimeMessage& m );
1508 std::ostream& operator<<(std::ostream& os, SetDateTimeMessage* m );
1509 // -----------------------------------------------------------------------
1510
1513 public SetDateTimeMessage
1514 {
1515
1516 // ------- from slave -------
1518 SetDateTimeRetMessage& operator=( const ModbusMessage& m );
1519 void init( const ModbusMessage& m );
1520 static ModbusCRC getCrc( const ModbusMessage& m );
1521 static ModbusCRC calcCRC( const ModbusMessage& m );
1522
1523 // ------- to master -------
1524 SetDateTimeRetMessage( ModbusAddr _from );
1526 static void cpy( SetDateTimeRetMessage& reply, const SetDateTimeMessage& query );
1527
1530 void transport_msg_to( ModbusMessage& m ) const;
1531 };
1532 // -----------------------------------------------------------------------
1533
1536 public ModbusHeader
1537 {
1538 ModbusByte bcnt = { 0 };
1541 ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)];
1542 ModbusCRC crc = { 0 };
1544 // -----------
1546 RemoteServiceMessage& operator=( const ModbusMessage& m );
1547 void init( const ModbusMessage& m );
1548 static ModbusCRC getCrc( const ModbusMessage& m );
1549 static ModbusCRC calcCRC( const ModbusMessage& m );
1550
1552 size_t szData() const;
1553
1557 static inline size_t szHead()
1558 {
1559 return sizeof(ModbusByte); // bcnt
1560 }
1561
1563 static size_t getDataLen( const ModbusMessage& m );
1564
1565 } __attribute__((packed));
1566
1567 std::ostream& operator<<(std::ostream& os, RemoteServiceMessage& m );
1568 std::ostream& operator<<(std::ostream& os, RemoteServiceMessage* m );
1569 // -----------------------------------------------------------------------
1571 public ModbusHeader
1572 {
1573 ModbusByte bcnt = { 0 };
1575 ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)];
1576
1577 RemoteServiceRetMessage( ModbusAddr _from );
1578
1585 bool setData( ModbusByte* b, int len );
1586
1588 void clear();
1589
1591 inline bool isFull() const
1592 {
1593 return ( count >= sizeof(data) );
1594 }
1595
1597 size_t szData() const;
1598
1599 static ModbusCRC getCrc( const ModbusMessage& m );
1600 static ModbusCRC calcCRC( const ModbusMessage& m );
1601
1604 void transport_msg_to( ModbusMessage& m ) const;
1605
1606 // Это поле не входит в стандарт modbus
1607 // оно вспомогательное и игнорируется при
1608 // преобразовании в ModbusMessage.
1609 size_t count = { 0 };
1610 };
1611 // -----------------------------------------------------------------------
1612
1614 public ModbusHeader
1615 {
1617 {
1618 ModbusByte reftype;
1619 ModbusData numfile;
1620 ModbusData numrec;
1621 ModbusData reglen;
1622 } __attribute__((packed));
1623
1624 ModbusByte bcnt = { 0 };
1627 SubRequest data[MAXLENPACKET / sizeof(SubRequest) - sizeof(ModbusByte)];
1628 ModbusCRC crc = { 0 };
1630 // -----------
1632 ReadFileRecordMessage& operator=( const ModbusMessage& m );
1633 void init( const ModbusMessage& m );
1634 static ModbusCRC getCrc( const ModbusMessage& m );
1635 static ModbusCRC calcCRC( const ModbusMessage& m );
1636
1638 size_t szData() const;
1639
1643 static inline size_t szHead()
1644 {
1645 return sizeof(ModbusByte); // bcnt
1646 }
1647
1649 static size_t getDataLen( const ModbusMessage& m );
1650
1652 bool checkFormat() const;
1653
1654 // это поле служебное и не используется в реальном обмене
1655 size_t count = { 0 };
1656 };
1657
1658 std::ostream& operator<<(std::ostream& os, ReadFileRecordMessage& m );
1659 std::ostream& operator<<(std::ostream& os, ReadFileRecordMessage* m );
1660 // -----------------------------------------------------------------------
1661
1663 public ModbusHeader
1664 {
1665 ModbusData numfile = { 0 };
1666 ModbusData numpacket = { 0 };
1667 ModbusCRC crc = { 0 };
1669 // ------- to slave -------
1670 FileTransferMessage( ModbusAddr addr, ModbusData numfile, ModbusData numpacket );
1671 static void make_to( ModbusAddr addr, ModbusByte numfile, ModbusByte numpacket, ModbusMessage& m );
1673 void transport_msg_to( ModbusMessage& m ) const;
1674
1675
1676 // ------- from master -------
1678 FileTransferMessage& operator=( const ModbusMessage& m );
1679 void init( const ModbusMessage& m );
1680 static ModbusCRC getCrc( const ModbusMessage& m );
1681 static ModbusCRC calcCRC( const ModbusMessage& m );
1682
1684 static inline size_t szData()
1685 {
1686 return sizeof(ModbusData) * 2 + szCRC;
1687 }
1688
1689 } __attribute__((packed));
1690
1691 std::ostream& operator<<(std::ostream& os, FileTransferMessage& m );
1692 std::ostream& operator<<(std::ostream& os, FileTransferMessage* m );
1693 // -----------------------------------------------------------------------
1694
1696 public ModbusHeader
1697 {
1698 // 255 - max of bcnt...(1 byte)
1699 // static const int MaxDataLen = 255 - szCRC - szModbusHeader - sizeof(ModbusData)*3 - sizeof(ModbusByte)*2;
1700 static const size_t MaxDataLen = MAXLENPACKET - sizeof(ModbusData) * 3 - sizeof(ModbusByte) * 2;
1701
1702 ModbusByte bcnt;
1703 ModbusData numfile;
1704 ModbusData numpacks;
1705 ModbusData packet;
1706 ModbusByte dlen;
1707 ModbusByte data[MaxDataLen];
1708
1709
1710 // ------- from slave -------
1712 FileTransferRetMessage& operator=( const ModbusMessage& m );
1713 void init( const ModbusMessage& m );
1714 static ModbusCRC getCrc( const ModbusMessage& m );
1715 static ModbusCRC calcCRC( const ModbusMessage& m );
1716
1717 ModbusCRC crc = { 0 };
1718 static size_t szHead()
1719 {
1720 return sizeof(ModbusByte);
1721 }
1722 static size_t getDataLen( const ModbusMessage& m );
1723
1724 // ------- to master -------
1725 FileTransferRetMessage( ModbusAddr _from );
1726
1730 bool set( ModbusData numfile, ModbusData file_num_packets, ModbusData packet, ModbusByte* b, ModbusByte len );
1731
1733 void clear();
1734
1736 size_t szData() const;
1737
1740 void transport_msg_to( ModbusMessage& m ) const;
1741 };
1742
1743 std::ostream& operator<<(std::ostream& os, FileTransferRetMessage& m );
1744 std::ostream& operator<<(std::ostream& os, FileTransferRetMessage* m );
1745 // -----------------------------------------------------------------------
1746 } // end of ModbusRTU namespace
1747 // -------------------------------------------------------------------------
1748} // end of namespace uniset
1749// ---------------------------------------------------------------------------
1750#endif // ModbusTypes_H_
1751// ---------------------------------------------------------------------------
Definition Calibration.h:27
Definition ModbusTypes.h:352
bool getData(uint8_t dnum, DataBits &d) const
Definition ModbusTypes.cc:683
bool setByBitNum(uint16_t num, bool state)
Definition ModbusTypes.cc:656
ModbusByte data[MAXPDULEN]
Definition ModbusTypes.h:354
bool isFull() const
Definition ModbusTypes.h:410
bool addData(DataBits d)
Definition ModbusTypes.cc:674
bool getByBitNum(uint16_t num, bool &state) const
Definition ModbusTypes.cc:694
void clear()
Definition ModbusTypes.cc:713
ModbusByte bcnt
Definition ModbusTypes.h:353
bool getBit(uint8_t dnum, uint8_t bnum, bool &state) const
Definition ModbusTypes.cc:701
bool setBit(uint8_t dnum, uint8_t bnum, bool state)
Definition ModbusTypes.cc:643
Definition ModbusTypes.h:322
Definition ModbusTypes.h:296
Definition ModbusTypes.h:158
Definition ModbusTypes.h:1175
size_t szData() const
Definition ModbusTypes.cc:2825
bool isFull() const
Definition ModbusTypes.h:1211
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:2777
static size_t szHead()
Definition ModbusTypes.h:1189
bool addData(ModbusData d)
Definition ModbusTypes.cc:2762
ModbusData data[MAXLENPACKET/sizeof(ModbusData)]
Definition ModbusTypes.h:1177
static size_t getDataLen(const ModbusMessage &m)
Definition ModbusTypes.cc:2734
void clear()
Definition ModbusTypes.cc:2771
size_t count
Definition ModbusTypes.h:1229
Definition ModbusTypes.h:1237
Definition ModbusTypes.h:264
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:354
static size_t szData()
Definition ModbusTypes.h:286
Definition ModbusTypes.h:1664
static size_t szData()
Definition ModbusTypes.h:1684
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:4004
ModbusCRC crc
Definition ModbusTypes.h:1667
ModbusData numpacket
Definition ModbusTypes.h:1666
ModbusData numfile
Definition ModbusTypes.h:1665
Definition ModbusTypes.h:1697
bool set(ModbusData numfile, ModbusData file_num_packets, ModbusData packet, ModbusByte *b, ModbusByte len)
Definition ModbusTypes.cc:4149
void clear()
Definition ModbusTypes.cc:4164
ModbusByte bcnt
Definition ModbusTypes.h:1702
ModbusData packet
Definition ModbusTypes.h:1705
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:4184
ModbusData numfile
Definition ModbusTypes.h:1703
ModbusByte dlen
Definition ModbusTypes.h:1706
ModbusData numpacks
Definition ModbusTypes.h:1704
size_t szData() const
Definition ModbusTypes.cc:4178
Definition ModbusTypes.h:763
static size_t szHead()
Definition ModbusTypes.h:821
ModbusData quant
Definition ModbusTypes.h:765
ModbusData start
Definition ModbusTypes.h:764
ModbusByte bcnt
Definition ModbusTypes.h:766
bool getData(uint8_t dnum, DataBits &d) const
Definition ModbusTypes.cc:1615
size_t szData() const
Definition ModbusTypes.cc:1743
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:1649
static size_t getDataLen(const ModbusMessage &m)
Definition ModbusTypes.cc:1748
bool addData(DataBits d)
Definition ModbusTypes.cc:1577
ModbusCRC crc
Definition ModbusTypes.h:769
ModbusByte data[MAXLENPACKET - sizeof(ModbusData) *2 - sizeof(ModbusByte)]
Definition ModbusTypes.h:768
Definition ModbusTypes.h:841
ModbusData quant
Definition ModbusTypes.h:843
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:1840
void set(ModbusData start, ModbusData quant)
Definition ModbusTypes.cc:1834
ModbusData start
Definition ModbusTypes.h:842
static size_t szData()
Definition ModbusTypes.h:872
Definition ModbusTypes.h:983
static size_t getDataLen(const ModbusMessage &m)
Definition ModbusTypes.cc:2277
static size_t szHead()
Definition ModbusTypes.h:1014
ModbusData data
Definition ModbusTypes.h:985
ModbusData start
Definition ModbusTypes.h:984
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:2201
bool cmd() const
Definition ModbusTypes.h:989
static size_t szData()
Definition ModbusTypes.cc:2272
ModbusCRC crc
Definition ModbusTypes.h:986
ModbusData data
Definition ModbusTypes.h:1038
ModbusData start
Definition ModbusTypes.h:1037
void set(ModbusData start, bool cmd)
Definition ModbusTypes.cc:2345
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:2352
bool cmd() const
Definition ModbusTypes.h:1042
static size_t szData()
Definition ModbusTypes.h:1071
Definition ModbusTypes.h:1379
static size_t szData()
Definition ModbusTypes.h:1391
ModbusData cmd
Definition ModbusTypes.h:1380
ModbusData num
Definition ModbusTypes.h:1381
Definition ModbusTypes.h:1404
size_t szData() const
Definition ModbusTypes.cc:3400
bool isFull() const
Definition ModbusTypes.h:1428
ModbusData data[MAXLENPACKET/sizeof(ModbusData)]
Definition ModbusTypes.h:1411
bool setData(ModbusByte *b, int len)
Definition ModbusTypes.cc:3308
void clear()
Definition ModbusTypes.cc:3331
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:3353
size_t count
Definition ModbusTypes.h:1448
ModbusByte bcnt
Definition ModbusTypes.h:1405
Definition ModbusTypes.h:1459
Definition ModbusTypes.h:192
ModbusRTU::ModbusData len
Definition ModbusTypes.h:195
ModbusRTU::ModbusData pID
Definition ModbusTypes.h:194
ModbusRTU::ModbusData tID
Definition ModbusTypes.h:193
Definition ModbusTypes.h:1249
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:2912
static size_t szData()
Definition ModbusTypes.h:1280
ModbusCRC crc
Definition ModbusTypes.h:1254
ModbusByte devID
Definition ModbusTypes.h:1251
static size_t szHead()
Definition ModbusTypes.h:1274
ModbusByte objID
Definition ModbusTypes.h:1252
ModbusByte type
Definition ModbusTypes.h:1250
Definition ModbusTypes.h:1309
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:3158
ModbusByte objNum
Definition ModbusTypes.h:1315
ModbusByte objID
Definition ModbusTypes.h:1314
void clear()
Definition ModbusTypes.cc:3137
bool addData(ModbusByte id, const std::string &value)
Definition ModbusTypes.cc:3124
ModbusByte mf
Definition ModbusTypes.h:1313
ModbusByte conformity
Definition ModbusTypes.h:1312
static size_t szHead()
Definition ModbusTypes.h:1332
size_t szData() const
Definition ModbusTypes.cc:3199
bool isFull() const
Definition ModbusTypes.h:1354
ModbusByte type
Definition ModbusTypes.h:1310
ModbusByte devID
Definition ModbusTypes.h:1311
Definition ModbusTypes.h:179
ModbusAddr addr
Definition ModbusTypes.h:180
ModbusByte func
Definition ModbusTypes.h:181
Definition ModbusTypes.h:210
ModbusByte data[MAXLENPACKET+szCRC]
Definition ModbusTypes.h:252
size_t dlen
Definition ModbusTypes.h:255
Definition ModbusTypes.h:1295
Definition ModbusTypes.h:421
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:408
static size_t szData()
Definition ModbusTypes.h:442
Definition ModbusTypes.h:457
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:776
size_t szData() const
Definition ModbusTypes.cc:770
static int szHead()
Definition ModbusTypes.h:468
static size_t getDataLen(const ModbusMessage &m)
Definition ModbusTypes.cc:756
ModbusByte reftype
Definition ModbusTypes.h:1618
ModbusData numrec
Definition ModbusTypes.h:1620
ModbusData reglen
Definition ModbusTypes.h:1621
ModbusData numfile
Definition ModbusTypes.h:1619
Definition ModbusTypes.h:1615
static size_t getDataLen(const ModbusMessage &m)
Definition ModbusTypes.cc:3978
size_t count
Definition ModbusTypes.h:1655
static size_t szHead()
Definition ModbusTypes.h:1643
ModbusByte bcnt
Definition ModbusTypes.h:1624
size_t szData() const
Definition ModbusTypes.cc:3972
bool checkFormat() const
Definition ModbusTypes.cc:3919
ModbusCRC crc
Definition ModbusTypes.h:1628
SubRequest data[MAXLENPACKET/sizeof(SubRequest) - sizeof(ModbusByte)]
Definition ModbusTypes.h:1627
Definition ModbusTypes.h:664
static size_t szData()
Definition ModbusTypes.h:684
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:1312
Definition ModbusTypes.h:698
bool addData(ModbusData d)
Definition ModbusTypes.cc:1473
static size_t getDataLen(const ModbusMessage &m)
Definition ModbusTypes.cc:1456
bool isFull() const
Definition ModbusTypes.h:735
size_t szData() const
Definition ModbusTypes.cc:1550
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:1507
static size_t szHead()
Definition ModbusTypes.h:712
ModbusData data[MAXLENPACKET/sizeof(ModbusData)]
Definition ModbusTypes.h:700
size_t count
Definition ModbusTypes.h:754
void clear()
Definition ModbusTypes.cc:1483
ModbusByte bcnt
Definition ModbusTypes.h:699
Definition ModbusTypes.h:494
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:843
static size_t szData()
Definition ModbusTypes.h:516
static size_t getDataLen(const ModbusMessage &m)
Definition ModbusTypes.cc:968
size_t szData() const
Definition ModbusTypes.cc:982
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:1005
static size_t szHead()
Definition ModbusTypes.h:541
Definition ModbusTypes.h:568
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:1057
static size_t szData()
Definition ModbusTypes.h:588
Definition ModbusTypes.h:601
size_t szData() const
Definition ModbusTypes.cc:1287
bool isFull() const
Definition ModbusTypes.h:638
static size_t szHead()
Definition ModbusTypes.h:615
size_t count
Definition ModbusTypes.h:655
static size_t getDataLen(const ModbusMessage &m)
Definition ModbusTypes.cc:1192
ModbusByte bcnt
Definition ModbusTypes.h:602
void clear()
Definition ModbusTypes.cc:1219
bool addData(ModbusData d)
Definition ModbusTypes.cc:1209
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:1243
ModbusData data[MAXLENPACKET/sizeof(ModbusData)]
Definition ModbusTypes.h:603
Definition ModbusTypes.h:1537
size_t szData() const
Definition ModbusTypes.cc:3797
ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)]
Definition ModbusTypes.h:1541
static size_t szHead()
Definition ModbusTypes.h:1557
ModbusCRC crc
Definition ModbusTypes.h:1542
ModbusByte bcnt
Definition ModbusTypes.h:1538
static size_t getDataLen(const ModbusMessage &m)
Definition ModbusTypes.cc:3802
Definition ModbusTypes.h:1572
bool isFull() const
Definition ModbusTypes.h:1591
ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)]
Definition ModbusTypes.h:1575
void clear()
Definition ModbusTypes.cc:3847
bool setData(ModbusByte *b, int len)
Definition ModbusTypes.cc:3829
ModbusByte bcnt
Definition ModbusTypes.h:1573
size_t szData() const
Definition ModbusTypes.cc:3854
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:3860
size_t count
Definition ModbusTypes.h:1609
Definition ModbusTypes.h:1473
static size_t szData()
Definition ModbusTypes.h:1500
ModbusByte year
Definition ModbusTypes.h:1479
ModbusByte mon
Definition ModbusTypes.h:1478
ModbusByte century
Definition ModbusTypes.h:1480
ModbusByte hour
Definition ModbusTypes.h:1474
ModbusByte sec
Definition ModbusTypes.h:1476
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:3632
ModbusByte min
Definition ModbusTypes.h:1475
ModbusByte day
Definition ModbusTypes.h:1477
Definition ModbusTypes.h:1514
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:3727
Definition ModbusTypes.h:885
static size_t szHead()
Definition ModbusTypes.h:919
ModbusByte bcnt
Definition ModbusTypes.h:888
ModbusData start
Definition ModbusTypes.h:886
ModbusCRC crc
Definition ModbusTypes.h:891
size_t szData() const
Definition ModbusTypes.cc:2036
ModbusData quant
Definition ModbusTypes.h:887
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:1926
ModbusData data[MAXLENPACKET/sizeof(ModbusData) - sizeof(ModbusData) *2 - sizeof(ModbusByte)]
Definition ModbusTypes.h:890
static size_t getDataLen(const ModbusMessage &m)
Definition ModbusTypes.cc:2041
Definition ModbusTypes.h:940
static size_t szData()
Definition ModbusTypes.h:971
void set(ModbusData start, ModbusData quant)
Definition ModbusTypes.cc:2129
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:2135
ModbusData start
Definition ModbusTypes.h:941
ModbusData quant
Definition ModbusTypes.h:942
Definition ModbusTypes.h:1084
ModbusCRC crc
Definition ModbusTypes.h:1087
static size_t szData()
Definition ModbusTypes.cc:2493
ModbusData data
Definition ModbusTypes.h:1086
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:2422
static size_t szHead()
Definition ModbusTypes.h:1110
static size_t getDataLen(const ModbusMessage &m)
Definition ModbusTypes.cc:2498
ModbusData start
Definition ModbusTypes.h:1085
static size_t szData()
Definition ModbusTypes.h:1163
ModbusData data
Definition ModbusTypes.h:1134
ModbusData start
Definition ModbusTypes.h:1133
ModbusMessage transport_msg() const
Definition ModbusTypes.cc:2579
void set(ModbusData start, ModbusData data)
Definition ModbusTypes.cc:2572