UniSet  2.8.0
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  * - младший и старший байт переворачиваются только в CRC
14  * - В случае неправильного формата пакета(запроса), логической ошибки и т.п
15  * ОТВЕТ просто не посылается, а пакет отбрасывается...
16  * - CRC считается по всей посылке (с начальным адресом)
17  * - CRC инициализируется значением 0xffff
18  * - CRC не переворачивается
19  * - Все двухбайтовые слова переворачиваются. Порядок байт: старший младший
20 */
21 // -------------------------------------------------------------------------
22 namespace uniset
23 {
24  // -------------------------------------------------------------------------
25  namespace ModbusRTU
26  {
27  // Базовые типы
28  typedef uint8_t ModbusByte;
29  const size_t BitsPerByte = 8;
30  typedef uint8_t ModbusAddr;
31  typedef uint16_t ModbusData;
32  const uint8_t BitsPerData = 16;
33  typedef uint16_t ModbusCRC;
35  // ---------------------------------------------------------------------
37  enum SlaveFunctionCode
38  {
39  fnUnknown = 0x00,
40  fnReadCoilStatus = 0x01,
41  fnReadInputStatus = 0x02,
42  fnReadOutputRegisters = 0x03,
43  fnReadInputRegisters = 0x04,
44  fnForceSingleCoil = 0x05,
45  fnWriteOutputSingleRegister = 0x06,
46  fnDiagnostics = 0x08,
47  fnForceMultipleCoils = 0x0F,
48  fnWriteOutputRegisters = 0x10,
49  fnReadFileRecord = 0x14,
50  fnWriteFileRecord = 0x15,
51  fnMEI = 0x2B,
52  fnSetDateTime = 0x50,
53  fnRemoteService = 0x53,
54  fnJournalCommand = 0x65,
55  fnFileTransfer = 0x66
56  };
57 
59  enum DiagnosticsSubFunction
60  {
61  subEcho = 0x00,
62  dgRestartComm = 0x01,
63  dgDiagReg = 0x02,
64  dgChangeASCII = 0x03,
65  dgForceListen = 0x04,
66  // 05.. 09 RESERVED
67  dgClearCounters = 0x0A,
68  dgBusMsgCount = 0x0B,
69  dgBusErrCount = 0x0C,
70  dgBusExceptCount = 0x0D,
71  dgMsgSlaveCount = 0x0E,
72  dgNoNoResponseCount = 0x0F,
73  dgSlaveNAKCount = 0x10,
74  dgSlaveBusyCount = 0x11,
75  dgBusCharOverrunCount = 0x12,
76  // = 0x13, /*!< RESERVED */
77  dgClearOverrunCounter = 0x14
78  // 21 ...65535 RESERVED
79  };
80 
81 
82  using RegID = size_t;
83 
90  RegID genRegID( const ModbusRTU::ModbusData r, const uint8_t fn );
91 
92  // определение размера данных в зависимости от типа сообщения
93  // возвращает -1 - если динамический размер сообщения или размер неизвестен
94  ssize_t szRequestDiagnosticData( DiagnosticsSubFunction f );
95 
97  enum RDIObjectID
98  {
99  rdiVendorName = 0x0,
100  rdiProductCode = 0x1,
101  rdiMajorMinorRevision = 0x2,
102  rdiVendorURL = 0x3,
103  rdiProductName = 0x4,
104  rdiModelName = 0x5,
105  rdiUserApplicationName = 0x6
106  // 0x07 .. 0x7F - reserved
107  // 0x80 .. 0xFF - optionaly defined (product dependant)
108  };
109 
111  enum RDIRequestDeviceID
112  {
113  rdevMinNum = 0,
114  rdevBasicDevice = 0x1, // request to get the basic device identification (stream access)
115  rdevRegularDevice = 0x2, // request to get the regular device identification (stream access)
116  rdevExtentedDevice = 0x3, // request to get the extended device identification (stream access)
117  rdevSpecificDevice = 0x4, // request to get the extended device identification (stream access)
118  rdevMaxNum = 0x5
119  };
120 
121  std::string rdi2str( int id );
122  // -----------------------------------------------------------------------
123 
125  enum
126  {
128  MAXLENPACKET = 508,
129  BroadcastAddr = 0,
130  MAXPDULEN = 253, // 255 - 2(CRC)
131  MAXDATALEN = 125
135  };
136 
137  const uint8_t MBErrMask = 0x80;
138  // ---------------------------------------------------------------------
139  uint16_t SWAPSHORT( uint16_t x );
140  // ---------------------------------------------------------------------
142  ModbusCRC checkCRC( ModbusByte* start, size_t len );
143  const size_t szCRC = sizeof(ModbusCRC);
144  // ---------------------------------------------------------------------
146  std::ostream& mbPrintMessage(std::ostream& os, ModbusByte* b, size_t len );
147  // -------------------------------------------------------------------------
148  ModbusAddr str2mbAddr( const std::string& val );
149  ModbusData str2mbData( const std::string& val );
150  std::string dat2str( const ModbusData dat );
151  std::string addr2str( const ModbusAddr addr );
152  std::string b2str( const ModbusByte b );
153  // -------------------------------------------------------------------------
154  float dat2f( const ModbusData dat1, const ModbusData dat2 );
155  size_t numBytes( const size_t nbits ); // сколько байт нужно для указанного количества бит
156  // -------------------------------------------------------------------------
157  // вспомогательная структура для предотвращения утечки памяти (RAII)
158  struct DataGuard
159  {
160  DataGuard( size_t sz ):
161  len(sz)
162  {
163  data = new ModbusRTU::ModbusData[sz];
164  }
165 
166  ~DataGuard()
167  {
168  delete[] data;
169  }
170 
171  ModbusRTU::ModbusData* data;
172  size_t len;
173  };
174  // -----------------------------------------------------------------------------
175  bool isWriteFunction( SlaveFunctionCode c );
176  bool isReadFunction( SlaveFunctionCode c );
177  // -------------------------------------------------------------------------
180  {
181  ModbusAddr addr;
182  ModbusByte func;
184  ModbusHeader(): addr(0), func(0) {}
185  } __attribute__((packed));
186 
187  const size_t szModbusHeader = sizeof(ModbusHeader);
188 
189  std::ostream& operator<<(std::ostream& os, const ModbusHeader& m );
190  std::ostream& operator<<(std::ostream& os, const ModbusHeader* m );
191  // -----------------------------------------------------------------------
192  struct MBAPHeader
193  {
194  ModbusRTU::ModbusData tID;
195  ModbusRTU::ModbusData pID;
196  ModbusRTU::ModbusData len;
198  MBAPHeader(): tID(0), pID(0), len(0) {}
199 
200  void swapdata();
201 
202  } __attribute__((packed));
203 
204  std::ostream& operator<<(std::ostream& os, const MBAPHeader& m );
205  // -----------------------------------------------------------------------
206 
211  {
212  ModbusMessage();
213 
214  ModbusMessage( ModbusMessage&& ) = default;
215  ModbusMessage& operator=(ModbusMessage&& ) = default;
216  ModbusMessage( const ModbusMessage& ) = default;
217  ModbusMessage& operator=(const ModbusMessage& ) = default;
218 
219  inline ModbusByte func() const
220  {
221  return pduhead.func;
222  }
223  inline ModbusAddr addr() const
224  {
225  return pduhead.addr;
226  }
227  inline ModbusRTU::ModbusData tID() const
228  {
229  return mbaphead.tID;
230  }
231  inline ModbusRTU::ModbusData pID() const
232  {
233  return mbaphead.pID;
234  }
235  inline ModbusRTU::ModbusData aduLen() const
236  {
237  return mbaphead.len;
238  }
239 
240  u_int8_t* buf();
241  ModbusRTU::ModbusData len() const;
242  void swapHead();
243  void makeMBAPHeader( ModbusRTU::ModbusData tID, bool noCRC = true, ModbusRTU::ModbusData pID = 0 );
244 
245  ModbusRTU::ModbusData pduLen() const;
246  ModbusCRC pduCRC( size_t len ) const;
247  static size_t maxSizeOfMessage();
248 
249  void clear();
250 
251  MBAPHeader mbaphead;
252  ModbusHeader pduhead;
253  ModbusByte data[MAXLENPACKET + szCRC];
255  // Это поле вспомогательное и игнорируется при пересылке
256  size_t dlen = { 0 };
257  } __attribute__((packed));
258 
259  std::ostream& operator<<(std::ostream& os, const ModbusMessage& m );
260  std::ostream& operator<<(std::ostream& os, const ModbusMessage* m );
261  // -----------------------------------------------------------------------
264  public ModbusHeader
265  {
266  ModbusByte ecode = { erNoError };
267  ModbusCRC crc = { 0 };
268 
269  // ------- from slave -------
270  ErrorRetMessage( const ModbusMessage& m );
271  ErrorRetMessage& operator=( const ModbusMessage& m );
272  void init( const ModbusMessage& m );
273 
274  // ------- to master -------
275  ErrorRetMessage( ModbusAddr _from, ModbusByte _func, ModbusByte ecode );
276 
279 
283  inline static size_t szData()
284  {
285  return sizeof(ModbusByte) + szCRC;
286  }
287  };
288 
289  std::ostream& operator<<(std::ostream& os, ErrorRetMessage& m );
290  std::ostream& operator<<(std::ostream& os, ErrorRetMessage* m );
291  // -----------------------------------------------------------------------
292  struct DataBits
293  {
294  DataBits( ModbusByte b );
295  DataBits( std::string s ); // example "10001111"
296  DataBits();
297 
298  const DataBits& operator=(const ModbusByte& r);
299 
300  operator ModbusByte();
301  ModbusByte mbyte();
302 
303  bool operator[]( const size_t i )
304  {
305  return b[i];
306  }
307  void set( int n, bool s )
308  {
309  b.set(n, s);
310  }
311 
312  std::bitset<BitsPerByte> b;
313  };
314 
315  std::ostream& operator<<(std::ostream& os, DataBits& m );
316  std::ostream& operator<<(std::ostream& os, DataBits* m );
317  // -----------------------------------------------------------------------
318  struct DataBits16
319  {
320  DataBits16( ModbusData d );
321  DataBits16( const std::string& s ); // example "1000111110001111"
322  DataBits16();
323 
324  const DataBits16& operator=(const ModbusData& r);
325 
326  operator ModbusData();
327  ModbusData mdata() const;
328 
329  bool operator[]( const size_t i )
330  {
331  return b[i];
332  }
333  void set( int n, bool s )
334  {
335  b.set(n, s);
336  }
337 
338  std::bitset<BitsPerData> b;
339  };
340 
341  std::ostream& operator<<(std::ostream& os, DataBits16& m );
342  std::ostream& operator<<(std::ostream& os, DataBits16* m );
343  // -----------------------------------------------------------------------
346  public ModbusHeader
347  {
348  ModbusData start = { 0 };
349  ModbusData count = { 0 };
350  ModbusCRC crc = { 0 };
351 
352  // ------- to slave -------
353  ReadCoilMessage( ModbusAddr addr, ModbusData start, ModbusData count );
356 
357  // ------- from master -------
358  ReadCoilMessage( const ModbusMessage& m );
359  ReadCoilMessage& operator=( const ModbusMessage& m );
360  void init( const ModbusMessage& m );
361 
363  inline static size_t szData()
364  {
365  return sizeof(ModbusData) * 2 + szCRC;
366  }
367 
368  } __attribute__((packed));
369 
370  std::ostream& operator<<(std::ostream& os, ReadCoilMessage& m );
371  std::ostream& operator<<(std::ostream& os, ReadCoilMessage* m );
372 
373  // -----------------------------------------------------------------------
374 
377  public ModbusHeader
378  {
379  ModbusByte bcnt = { 0 };
380  ModbusByte data[MAXLENPACKET];
382  // ------- from slave -------
383  ReadCoilRetMessage( const ModbusMessage& m );
384  ReadCoilRetMessage& operator=( const ModbusMessage& m );
385  void init( const ModbusMessage& m );
386 
390  static inline int szHead()
391  {
392  return sizeof(ModbusByte); // bcnt
393  }
394 
396  static size_t getDataLen( const ModbusMessage& m );
397  ModbusCRC crc = { 0 };
398 
399  // ------- to master -------
400  ReadCoilRetMessage( ModbusAddr _from );
401 
406  bool addData( DataBits d );
407 
415  bool setBit( uint8_t dnum, uint8_t bnum, bool state );
416 
423  bool getData( uint8_t bnum, DataBits& d ) const;
424 
426  void clear();
427 
429  inline bool isFull() const
430  {
431  return ( (int)bcnt >= MAXPDULEN );
432  }
433 
435  size_t szData() const;
436 
439  };
440 
441  std::ostream& operator<<(std::ostream& os, ReadCoilRetMessage& m );
442  std::ostream& operator<<(std::ostream& os, ReadCoilRetMessage* m );
443  // -----------------------------------------------------------------------
446  public ModbusHeader
447  {
448  ModbusData start = { 0 };
449  ModbusData count = { 0 };
450  ModbusCRC crc = { 0 };
451 
452  // ------- to slave -------
453  ReadInputStatusMessage( ModbusAddr addr, ModbusData start, ModbusData count );
454 
457 
458  // ------- from master -------
460  ReadInputStatusMessage& operator=( const ModbusMessage& m );
461 
462  void init( const ModbusMessage& m );
463 
465  inline static size_t szData()
466  {
467  return sizeof(ModbusData) * 2 + szCRC;
468  }
469 
470  } __attribute__((packed));
471 
472  std::ostream& operator<<(std::ostream& os, ReadInputStatusMessage& m );
473  std::ostream& operator<<(std::ostream& os, ReadInputStatusMessage* m );
474  // -----------------------------------------------------------------------
477  public ModbusHeader
478  {
479  ModbusByte bcnt = { 0 };
480  ModbusByte data[MAXLENPACKET];
482  // ------- from slave -------
484  ReadInputStatusRetMessage& operator=( const ModbusMessage& m );
485  void init( const ModbusMessage& m );
486 
490  static inline size_t szHead()
491  {
492  return sizeof(ModbusByte); // bcnt
493  }
494 
496  static size_t getDataLen( const ModbusMessage& m );
497  ModbusCRC crc = { 0 };
498 
499  // ------- to master -------
500  ReadInputStatusRetMessage( ModbusAddr _from );
501 
506  bool addData( DataBits d );
507 
515  bool setBit( uint8_t dnum, uint8_t bnum, bool state );
516 
523  bool getData( uint8_t dnum, DataBits& d ) const;
524 
526  void clear();
527 
529  inline bool isFull() const
530  {
531  return ( (int)bcnt >= MAXPDULEN );
532  }
533 
535  size_t szData() const;
536 
539  };
540 
541  std::ostream& operator<<(std::ostream& os, ReadInputStatusRetMessage& m );
542  std::ostream& operator<<(std::ostream& os, ReadInputStatusRetMessage* m );
543  // -----------------------------------------------------------------------
544 
547  public ModbusHeader
548  {
549  ModbusData start = { 0 };
550  ModbusData count = { 0 };
551  ModbusCRC crc = { 0 };
552 
553  // ------- to slave -------
554  ReadOutputMessage( ModbusAddr addr, ModbusData start, ModbusData count );
557 
558  // ------- from master -------
559  ReadOutputMessage( const ModbusMessage& m );
560  ReadOutputMessage& operator=( const ModbusMessage& m );
561  void init( const ModbusMessage& m );
562 
564  inline static size_t szData()
565  {
566  return sizeof(ModbusData) * 2 + szCRC;
567  }
568 
569  } __attribute__((packed));
570 
571  std::ostream& operator<<(std::ostream& os, ReadOutputMessage& m );
572  std::ostream& operator<<(std::ostream& os, ReadOutputMessage* m );
573  // -----------------------------------------------------------------------
576  public ModbusHeader
577  {
578  ModbusByte bcnt = { 0 };
579  ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
581  // ------- from slave -------
583  ReadOutputRetMessage& operator=( const ModbusMessage& m );
584  void init( const ModbusMessage& m );
588  static inline size_t szHead()
589  {
590  // bcnt
591  return sizeof(ModbusByte);
592  }
593 
595  static size_t getDataLen( const ModbusMessage& m );
596  ModbusCRC crc = { 0 };
597 
598  // ------- to master -------
599  ReadOutputRetMessage( ModbusAddr _from );
600 
605  bool addData( ModbusData d );
606 
608  void clear();
609 
611  inline bool isFull() const
612  {
613  return ( count * sizeof(ModbusData) >= MAXLENPACKET );
614  }
615 
617  size_t szData() const;
618 
621 
622  // Это поле не входит в стандарт modbus
623  // оно вспомогательное и игнорируется при
624  // преобразовании в ModbusMessage.
625  // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
626  // Используйте специальную функцию transport_msg()
627  size_t count = { 0 };
628  };
629 
630  std::ostream& operator<<(std::ostream& os, ReadOutputRetMessage& m );
631  std::ostream& operator<<(std::ostream& os, ReadOutputRetMessage* m );
632  // -----------------------------------------------------------------------
635  public ModbusHeader
636  {
637  ModbusData start = { 0 };
638  ModbusData count = { 0 };
639  ModbusCRC crc = { 0 };
640 
641  // ------- to slave -------
642  ReadInputMessage( ModbusAddr addr, ModbusData start, ModbusData count );
645 
646  // ------- from master -------
647  ReadInputMessage( const ModbusMessage& m );
648  ReadInputMessage& operator=( const ModbusMessage& m );
649  void init( const ModbusMessage& m );
650 
652  inline static size_t szData()
653  {
654  return sizeof(ModbusData) * 2 + szCRC;
655  }
656 
657  } __attribute__((packed));
658 
659  std::ostream& operator<<(std::ostream& os, ReadInputMessage& m );
660  std::ostream& operator<<(std::ostream& os, ReadInputMessage* m );
661  // -----------------------------------------------------------------------
662 
665  public ModbusHeader
666  {
667  ModbusByte bcnt = { 0 };
668  ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
670  // ------- from slave -------
672  ReadInputRetMessage& operator=( const ModbusMessage& m );
673  void init( const ModbusMessage& m );
677  static inline size_t szHead()
678  {
679  // bcnt
680  return sizeof(ModbusByte);
681  }
682 
684  static size_t getDataLen( const ModbusMessage& m );
685  ModbusCRC crc = { 0 };
686 
687  // ------- to master -------
688  ReadInputRetMessage( ModbusAddr _from );
689 
694  bool addData( ModbusData d );
695 
697  void clear();
698 
700  inline bool isFull() const
701  {
702  return ( count * sizeof(ModbusData) >= MAXLENPACKET );
703  }
704 
705  void swapData();
706 
708  size_t szData();
709 
712 
713  // Это поле не входит в стандарт modbus
714  // оно вспомогательное и игнорируется при
715  // преобразовании в ModbusMessage.
716  // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
717  // Используйте специальную функцию transport_msg()
718  size_t count = { 0 };
719  };
720 
721  std::ostream& operator<<(std::ostream& os, ReadInputRetMessage& m );
722  std::ostream& operator<<(std::ostream& os, ReadInputRetMessage* m );
723  // -----------------------------------------------------------------------
726  public ModbusHeader
727  {
728  ModbusData start = { 0 };
729  ModbusData quant = { 0 };
730  ModbusByte bcnt = { 0 };
732  ModbusByte data[MAXLENPACKET - sizeof(ModbusData) * 2 - sizeof(ModbusByte)];
733  ModbusCRC crc = { 0 };
735  // ------- to slave -------
736  ForceCoilsMessage( ModbusAddr addr, ModbusData start );
739 
744  bool addData( DataBits d );
745 
746  // return number of bit
747  // -1 - error
748  int addBit( bool state );
749 
750  bool setBit( uint8_t nbit, bool state );
751 
752  inline size_t last() const
753  {
754  return quant;
755  }
756 
763  bool getData( uint8_t dnum, DataBits& d );
764 
765  void clear();
766  inline bool isFull() const
767  {
768  return ( (int)bcnt >= MAXPDULEN );
769  }
770 
771  // ------- from master -------
772  ForceCoilsMessage( const ModbusMessage& m );
773  ForceCoilsMessage& operator=( const ModbusMessage& m );
774  void init( const ModbusMessage& m );
775 
777  size_t szData() const;
778 
782  static inline size_t szHead()
783  {
784  // start + quant + count
785  return sizeof(ModbusData) * 2 + sizeof(ModbusByte);
786  }
787 
789  static size_t getDataLen( const ModbusMessage& m );
790 
794  bool checkFormat() const;
795 
796  } __attribute__((packed));
797 
798  std::ostream& operator<<(std::ostream& os, ForceCoilsMessage& m );
799  std::ostream& operator<<(std::ostream& os, ForceCoilsMessage* m );
800  // -----------------------------------------------------------------------
803  public ModbusHeader
804  {
805  ModbusData start = { 0 };
806  ModbusData quant = { 0 };
807  ModbusCRC crc = { 0 };
808 
809  // ------- from slave -------
811  ForceCoilsRetMessage& operator=( const ModbusMessage& m );
812  void init( const ModbusMessage& m );
813 
814  // ------- to master -------
820  ForceCoilsRetMessage( ModbusAddr _from, ModbusData start = 0, ModbusData quant = 0 );
821 
823  void set( ModbusData start, ModbusData quant );
824 
827 
831  inline static size_t szData()
832  {
833  return sizeof(ModbusData) * 2 + sizeof(ModbusCRC);
834  }
835  };
836 
837  std::ostream& operator<<(std::ostream& os, ForceCoilsRetMessage& m );
838  std::ostream& operator<<(std::ostream& os, ForceCoilsRetMessage* m );
839  // -----------------------------------------------------------------------
840 
843  public ModbusHeader
844  {
845  ModbusData start = { 0 };
846  ModbusData quant = { 0 };
847  ModbusByte bcnt = { 0 };
849  ModbusData data[MAXLENPACKET / sizeof(ModbusData) - sizeof(ModbusData) * 2 - sizeof(ModbusByte)];
850  ModbusCRC crc = { 0 };
852  // ------- to slave -------
853  WriteOutputMessage( ModbusAddr addr, ModbusData start );
856 
857  bool addData( ModbusData d );
858  void clear();
859  inline bool isFull() const
860  {
861  return ( quant >= MAXDATALEN );
862  }
863 
864  // ------- from master -------
865  WriteOutputMessage( const ModbusMessage& m );
866  WriteOutputMessage& operator=( const ModbusMessage& m );
867  void init( const ModbusMessage& m );
868 
870  size_t szData() const;
871 
875  static inline size_t szHead()
876  {
877  // start + quant + count
878  return sizeof(ModbusData) * 2 + sizeof(ModbusByte);
879  }
880 
882  static size_t getDataLen( const ModbusMessage& m );
883 
887  bool checkFormat() const;
888 
889  } __attribute__((packed));
890 
891 
892  std::ostream& operator<<(std::ostream& os, WriteOutputMessage& m );
893  std::ostream& operator<<(std::ostream& os, WriteOutputMessage* m );
894 
897  public ModbusHeader
898  {
899  ModbusData start = { 0 };
900  ModbusData quant = { 0 };
902  // ------- from slave -------
904  WriteOutputRetMessage& operator=( const ModbusMessage& m );
905  void init( const ModbusMessage& m );
906  ModbusCRC crc = { 0 };
907 
908  // ------- to master -------
914  WriteOutputRetMessage( ModbusAddr _from, ModbusData start = 0, ModbusData quant = 0 );
915 
917  void set( ModbusData start, ModbusData quant );
918 
921 
925  inline static size_t szData()
926  {
927  return sizeof(ModbusData) * 2 + sizeof(ModbusCRC);
928  }
929  };
930 
931  std::ostream& operator<<(std::ostream& os, WriteOutputRetMessage& m );
932  std::ostream& operator<<(std::ostream& os, WriteOutputRetMessage* m );
933  // -----------------------------------------------------------------------
936  public ModbusHeader
937  {
938  ModbusData start = { 0 };
939  ModbusData data = { 0 };
940  ModbusCRC crc = { 0 };
943  inline bool cmd()
944  {
945  return (data & 0xFF00);
946  }
947 
948  // ------- to slave -------
949  ForceSingleCoilMessage( ModbusAddr addr, ModbusData reg, bool state );
952 
953  // ------- from master -------
955  ForceSingleCoilMessage& operator=( const ModbusMessage& m );
956  void init( const ModbusMessage& m );
957 
959  size_t szData() const;
960 
964  static inline size_t szHead()
965  {
966  return sizeof(ModbusData);
967  }
968 
972  static size_t getDataLen( const ModbusMessage& m );
973 
977  bool checkFormat() const;
978  } __attribute__((packed));
979 
980 
981  std::ostream& operator<<(std::ostream& os, ForceSingleCoilMessage& m );
982  std::ostream& operator<<(std::ostream& os, ForceSingleCoilMessage* m );
983  // -----------------------------------------------------------------------
984 
987  public ModbusHeader
988  {
989  ModbusData start = { 0 };
990  ModbusData data = { 0 };
991  ModbusCRC crc = { 0 };
992 
994  inline bool cmd() const
995  {
996  return (data & 0xFF00);
997  }
998 
999  // ------- from slave -------
1001  ForceSingleCoilRetMessage& operator=( const ModbusMessage& m );
1002  void init( const ModbusMessage& m );
1003 
1004  // ------- to master -------
1009  ForceSingleCoilRetMessage( ModbusAddr _from );
1010 
1012  void set( ModbusData start, bool cmd );
1013 
1016 
1020  inline static size_t szData()
1021  {
1022  return 2 * sizeof(ModbusData) + sizeof(ModbusCRC);
1023  }
1024  };
1025 
1026  std::ostream& operator<<(std::ostream& os, ForceSingleCoilRetMessage& m );
1027  std::ostream& operator<<(std::ostream& os, ForceSingleCoilRetMessage* m );
1028  // -----------------------------------------------------------------------
1029 
1032  public ModbusHeader
1033  {
1034  ModbusData start = { 0 };
1035  ModbusData data = { 0 };
1036  ModbusCRC crc = { 0 };
1039  // ------- to slave -------
1040  WriteSingleOutputMessage( ModbusAddr addr, ModbusData reg = 0, ModbusData data = 0 );
1043 
1044  // ------- from master -------
1046  WriteSingleOutputMessage& operator=( const ModbusMessage& m );
1047  void init( const ModbusMessage& m );
1048 
1050  size_t szData() const;
1051 
1055  static inline size_t szHead()
1056  {
1057  return sizeof(ModbusData);
1058  }
1059 
1063  static size_t getDataLen( const ModbusMessage& m );
1064 
1068  bool checkFormat();
1069  } __attribute__((packed));
1070 
1071 
1072  std::ostream& operator<<(std::ostream& os, WriteSingleOutputMessage& m );
1073  std::ostream& operator<<(std::ostream& os, WriteSingleOutputMessage* m );
1074  // -----------------------------------------------------------------------
1075 
1078  public ModbusHeader
1079  {
1080  ModbusData start = { 0 };
1081  ModbusData data = { 0 };
1082  ModbusCRC crc = { 0 };
1083 
1084 
1085  // ------- from slave -------
1087  WriteSingleOutputRetMessage& operator=( const ModbusMessage& m );
1088  void init( const ModbusMessage& m );
1089 
1090  // ------- to master -------
1095  WriteSingleOutputRetMessage( ModbusAddr _from, ModbusData start = 0 );
1096 
1098  void set( ModbusData start, ModbusData data );
1099 
1102 
1106  inline static size_t szData()
1107  {
1108  return 2 * sizeof(ModbusData) + sizeof(ModbusCRC);
1109  }
1110  };
1111 
1112  std::ostream& operator<<(std::ostream& os, WriteSingleOutputRetMessage& m );
1113  std::ostream& operator<<(std::ostream& os, WriteSingleOutputRetMessage* m );
1114  // -----------------------------------------------------------------------
1117  public ModbusHeader
1118  {
1119  ModbusData subf = { 0 };
1120  ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
1122  // ------- from slave -------
1123  DiagnosticMessage( const ModbusMessage& m );
1124  DiagnosticMessage& operator=( const ModbusMessage& m );
1125  void init( const ModbusMessage& m );
1129  static inline size_t szHead()
1130  {
1131  return sizeof(ModbusData); // subf
1132  }
1133 
1135  static size_t getDataLen( const ModbusMessage& m );
1136  ModbusCRC crc = { 0 };
1137 
1138  // ------- to master -------
1139  DiagnosticMessage( ModbusAddr _from, DiagnosticsSubFunction subf, ModbusData d = 0 );
1140 
1145  bool addData( ModbusData d );
1146 
1148  void clear();
1149 
1151  inline bool isFull() const
1152  {
1153  // (1)subf + data count
1154  return ( 1 + count >= MAXDATALEN );
1155  }
1156 
1158  size_t szData() const;
1159 
1162 
1163  // Это поле не входит в стандарт modbus
1164  // оно вспомогательное и игнорируется при
1165  // преобразовании в ModbusMessage.
1166  // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
1167  // Используйте специальную функцию transport_msg()
1168  size_t count = { 0 };
1169  };
1170  std::ostream& operator<<(std::ostream& os, DiagnosticMessage& m );
1171  std::ostream& operator<<(std::ostream& os, DiagnosticMessage* m );
1172  // -----------------------------------------------------------------------
1175  public DiagnosticMessage
1176  {
1177  DiagnosticRetMessage( const ModbusMessage& m );
1179  DiagnosticRetMessage( ModbusAddr a, DiagnosticsSubFunction subf, ModbusData d = 0 );
1180  };
1181 
1182  std::ostream& operator<<(std::ostream& os, DiagnosticRetMessage& m );
1183  std::ostream& operator<<(std::ostream& os, DiagnosticRetMessage* m );
1184  // -----------------------------------------------------------------------
1187  public ModbusHeader
1188  {
1189  ModbusByte type;
1190  ModbusByte devID;
1191  ModbusByte objID;
1193  ModbusCRC crc = { 0 };
1195  // ------- to slave -------
1196  MEIMessageRDI( ModbusAddr addr, ModbusByte devID, ModbusByte objID );
1199 
1200  // ------- from master -------
1201  MEIMessageRDI( const ModbusMessage& m );
1202  MEIMessageRDI& operator=( const ModbusMessage& m );
1203  void init( const ModbusMessage& m );
1204 
1208  static inline size_t szHead()
1209  {
1210  return sizeof(ModbusByte) * 3;
1211  }
1212 
1214  static inline size_t szData()
1215  {
1216  return sizeof(ModbusByte) * 3 + szCRC;
1217  }
1218 
1219  // вспомогательные функции
1220  bool checkFormat() const;
1221 
1222  } __attribute__((packed));
1223  // -----------------------------------------------------------------------
1224  std::ostream& operator<<(std::ostream& os, MEIMessageRDI& m );
1225  std::ostream& operator<<(std::ostream& os, MEIMessageRDI* m );
1226  // -----------------------------------------------------------------------
1227 
1229  {
1230  RDIObjectInfo(): id(0), val("") {}
1231  RDIObjectInfo( ModbusByte id, const std::string& v ): id(id), val(v) {}
1232  RDIObjectInfo( ModbusByte id, const ModbusByte* dat, ModbusByte len );
1233 
1234  ModbusByte id;
1235  std::string val;
1236  };
1237 
1238  using RDIObjectList = std::list<RDIObjectInfo>;
1239 
1242  public ModbusHeader
1243  {
1244  ModbusByte type;
1245  ModbusByte devID;
1246  ModbusByte conformity;
1247  ModbusByte mf;
1248  ModbusByte objID;
1249  ModbusByte objNum;
1251  RDIObjectList dlist;
1252  ModbusCRC crc = { 0 };
1253 
1254  // ------- from slave -------
1255  MEIMessageRetRDI();
1256  MEIMessageRetRDI( const ModbusMessage& m );
1257  MEIMessageRetRDI& operator=( const ModbusMessage& m );
1258  void init( const ModbusMessage& m );
1259 
1260  // предварительная инициализации, только заголовочной части, без данных
1261  void pre_init( const ModbusMessage& m );
1262 
1264  static inline size_t szHead()
1265  {
1266  return sizeof(ModbusByte) * 6;
1267  }
1268 
1269  // /*! узнать длину данных следующих за предварительным заголовком ( в байтах ) */
1270  // static int getDataLen( ModbusMessage& m );
1271 
1272  // ------- to master -------
1273  MEIMessageRetRDI( ModbusAddr _from, ModbusByte devID, ModbusByte conformity, ModbusByte mf, ModbusByte objID );
1274 
1279  bool addData( ModbusByte id, const std::string& value );
1280  bool addData( RDIObjectInfo& dat );
1281 
1283  void clear();
1284 
1286  inline bool isFull() const
1287  {
1288  return ( bcnt >= MAXPDULEN );
1289  }
1290 
1292  size_t szData() const;
1293 
1296 
1297  size_t bcnt = { 0 };
1298  };
1299 
1300  std::ostream& operator<<(std::ostream& os, MEIMessageRetRDI& m );
1301  std::ostream& operator<<(std::ostream& os, MEIMessageRetRDI* m );
1302  std::ostream& operator<<(std::ostream& os, RDIObjectList& dl );
1303  std::ostream& operator<<(std::ostream& os, RDIObjectList* dl );
1304  // -----------------------------------------------------------------------
1305  // -----------------------------------------------------------------------
1306 
1309  public ModbusHeader
1310  {
1311  ModbusData cmd = { 0 };
1312  ModbusData num = { 0 };
1313  ModbusCRC crc = { 0 };
1314 
1315  // -------------
1317  JournalCommandMessage& operator=( const ModbusMessage& m );
1318 
1320  inline static size_t szData()
1321  {
1322  return sizeof(ModbusByte) * 4 + szCRC;
1323  }
1324 
1325  } __attribute__((packed));
1326 
1327  std::ostream& operator<<(std::ostream& os, JournalCommandMessage& m );
1328  std::ostream& operator<<(std::ostream& os, JournalCommandMessage* m );
1329  // -----------------------------------------------------------------------
1332  public ModbusHeader
1333  {
1334  ModbusByte bcnt = { 0 };
1335  // ModbusByte data[MAXLENPACKET-1]; /*!< данные */
1336 
1337  // В связи со спецификой реализации ответной части (т.е. modbus master)
1338  // данные приходится делать не байтовым потоком, а "словами"
1339  // которые в свою очередь будут перевёрнуты при посылке...
1340  ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
1342  // -------------
1343  JournalCommandRetMessage( ModbusAddr _from );
1344 
1351  bool setData( ModbusByte* b, int len );
1352 
1354  void clear();
1355 
1357  inline bool isFull() const
1358  {
1359  return ( count >= MAXDATALEN );
1360  }
1361 
1363  size_t szData() const;
1364 
1367 
1368  // Это поле не входит в стандарт modbus
1369  // оно вспомогательное и игнорируется при
1370  // преобразовании в ModbusMessage.
1371  // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
1372  // Используйте специальную функцию transport_msg()
1373  size_t count = { 0 };
1374  };
1375 
1376  std::ostream& operator<<(std::ostream& os, JournalCommandRetMessage& m );
1377  std::ostream& operator<<(std::ostream& os, JournalCommandRetMessage* m );
1378  // -----------------------------------------------------------------------
1384  {
1385  // -------------
1386  JournalCommandRetOK( ModbusAddr _from );
1387  void set( ModbusData cmd, ModbusData ecode );
1388  static void set( JournalCommandRetMessage& m, ModbusData cmd, ModbusData ecode );
1389  };
1390 
1391  std::ostream& operator<<(std::ostream& os, JournalCommandRetOK& m );
1392  std::ostream& operator<<(std::ostream& os, JournalCommandRetOK* m );
1393  // -----------------------------------------------------------------------
1394 
1397  public ModbusHeader
1398  {
1399  ModbusByte hour = { 0 };
1400  ModbusByte min = { 0 };
1401  ModbusByte sec = { 0 };
1402  ModbusByte day = { 1 };
1403  ModbusByte mon = { 1 };
1404  ModbusByte year = { 0 };
1405  ModbusByte century = { 20 };
1407  ModbusCRC crc = { 0 };
1408 
1409  // ------- to slave -------
1410  SetDateTimeMessage( ModbusAddr addr );
1413 
1414  // ------- from master -------
1415  SetDateTimeMessage( const ModbusMessage& m );
1416  SetDateTimeMessage& operator=( const ModbusMessage& m );
1418 
1419  bool checkFormat() const;
1420 
1422  inline static size_t szData()
1423  {
1424  return sizeof(ModbusByte) * 7 + szCRC;
1425  }
1426 
1427  } __attribute__((packed));
1428 
1429  std::ostream& operator<<(std::ostream& os, SetDateTimeMessage& m );
1430  std::ostream& operator<<(std::ostream& os, SetDateTimeMessage* m );
1431  // -----------------------------------------------------------------------
1432 
1435  public SetDateTimeMessage
1436  {
1437 
1438  // ------- from slave -------
1440  SetDateTimeRetMessage& operator=( const ModbusMessage& m );
1441  void init( const ModbusMessage& m );
1442 
1443  // ------- to master -------
1444  SetDateTimeRetMessage( ModbusAddr _from );
1445  SetDateTimeRetMessage( const SetDateTimeMessage& query );
1446  static void cpy( SetDateTimeRetMessage& reply, const SetDateTimeMessage& query );
1447 
1450  };
1451  // -----------------------------------------------------------------------
1452 
1455  public ModbusHeader
1456  {
1457  ModbusByte bcnt = { 0 };
1460  ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)];
1461  ModbusCRC crc = { 0 };
1463  // -----------
1464  RemoteServiceMessage( const ModbusMessage& m );
1465  RemoteServiceMessage& operator=( const ModbusMessage& m );
1466  void init( const ModbusMessage& m );
1467 
1469  size_t szData() const;
1470 
1474  static inline size_t szHead()
1475  {
1476  return sizeof(ModbusByte); // bcnt
1477  }
1478 
1480  static size_t getDataLen( const ModbusMessage& m );
1481 
1482  } __attribute__((packed));
1483 
1484  std::ostream& operator<<(std::ostream& os, RemoteServiceMessage& m );
1485  std::ostream& operator<<(std::ostream& os, RemoteServiceMessage* m );
1486  // -----------------------------------------------------------------------
1488  public ModbusHeader
1489  {
1490  ModbusByte bcnt = { 0 };
1492  ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)];
1493 
1494  RemoteServiceRetMessage( ModbusAddr _from );
1495 
1502  bool setData( ModbusByte* b, int len );
1503 
1505  void clear();
1506 
1508  inline bool isFull() const
1509  {
1510  return ( count >= sizeof(data) );
1511  }
1512 
1514  size_t szData() const;
1515 
1518 
1519  // Это поле не входит в стандарт modbus
1520  // оно вспомогательное и игнорируется при
1521  // преобразовании в ModbusMessage.
1522  size_t count = { 0 };
1523  };
1524  // -----------------------------------------------------------------------
1525 
1527  public ModbusHeader
1528  {
1529  struct SubRequest
1530  {
1531  ModbusByte reftype;
1532  ModbusData numfile;
1533  ModbusData numrec;
1534  ModbusData reglen;
1535  } __attribute__((packed));
1536 
1537  ModbusByte bcnt = { 0 };
1540  SubRequest data[MAXLENPACKET / sizeof(SubRequest) - sizeof(ModbusByte)];
1541  ModbusCRC crc = { 0 };
1543  // -----------
1545  ReadFileRecordMessage& operator=( const ModbusMessage& m );
1546  void init( const ModbusMessage& m );
1547 
1549  size_t szData() const;
1550 
1554  static inline size_t szHead()
1555  {
1556  return sizeof(ModbusByte); // bcnt
1557  }
1558 
1560  static size_t getDataLen( const ModbusMessage& m );
1561 
1563  bool checkFormat() const;
1564 
1565  // это поле служебное и не используется в реальном обмене
1566  size_t count = { 0 };
1567  };
1568 
1569  std::ostream& operator<<(std::ostream& os, ReadFileRecordMessage& m );
1570  std::ostream& operator<<(std::ostream& os, ReadFileRecordMessage* m );
1571  // -----------------------------------------------------------------------
1572 
1574  public ModbusHeader
1575  {
1576  ModbusData numfile = { 0 };
1577  ModbusData numpacket = { 0 };
1578  ModbusCRC crc = { 0 };
1580  // ------- to slave -------
1581  FileTransferMessage( ModbusAddr addr, ModbusData numfile, ModbusData numpacket );
1584  // ------- from master -------
1585  FileTransferMessage( const ModbusMessage& m );
1586  FileTransferMessage& operator=( const ModbusMessage& m );
1587  void init( const ModbusMessage& m );
1588 
1590  static inline size_t szData()
1591  {
1592  return sizeof(ModbusData) * 2 + szCRC;
1593  }
1594 
1595  } __attribute__((packed));
1596 
1597  std::ostream& operator<<(std::ostream& os, FileTransferMessage& m );
1598  std::ostream& operator<<(std::ostream& os, FileTransferMessage* m );
1599  // -----------------------------------------------------------------------
1600 
1602  public ModbusHeader
1603  {
1604  // 255 - max of bcnt...(1 byte)
1605  // static const int MaxDataLen = 255 - szCRC - szModbusHeader - sizeof(ModbusData)*3 - sizeof(ModbusByte)*2;
1606  static const size_t MaxDataLen = MAXLENPACKET - sizeof(ModbusData) * 3 - sizeof(ModbusByte) * 2;
1607 
1608  ModbusByte bcnt;
1609  ModbusData numfile;
1610  ModbusData numpacks;
1611  ModbusData packet;
1612  ModbusByte dlen;
1613  ModbusByte data[MaxDataLen];
1614 
1615 
1616  // ------- from slave -------
1618  FileTransferRetMessage& operator=( const ModbusMessage& m );
1619  void init( const ModbusMessage& m );
1620  ModbusCRC crc = { 0 };
1621  static size_t szHead()
1622  {
1623  return sizeof(ModbusByte);
1624  }
1625  static size_t getDataLen( const ModbusMessage& m );
1626 
1627  // ------- to master -------
1628  FileTransferRetMessage( ModbusAddr _from );
1629 
1633  bool set( ModbusData numfile, ModbusData file_num_packets, ModbusData packet, ModbusByte* b, ModbusByte len );
1634 
1636  void clear();
1637 
1639  size_t szData() const;
1640 
1643  };
1644 
1645  std::ostream& operator<<(std::ostream& os, FileTransferRetMessage& m );
1646  std::ostream& operator<<(std::ostream& os, FileTransferRetMessage* m );
1647  // -----------------------------------------------------------------------
1648  } // end of ModbusRTU namespace
1649  // -------------------------------------------------------------------------
1650 } // end of namespace uniset
1651 // ---------------------------------------------------------------------------
1652 #endif // ModbusTypes_H_
1653 // ---------------------------------------------------------------------------
bool checkFormat() const
Definition: ModbusTypes.cc:1490
bool getData(uint8_t dnum, DataBits &d) const
Definition: ModbusTypes.cc:852
size_t szData() const
Definition: ModbusTypes.cc:2731
static size_t szHead()
Definition: ModbusTypes.h:588
ModbusByte data[MAXLENPACKET]
Definition: ModbusTypes.h:380
static size_t getDataLen(const ModbusMessage &m)
Definition: ModbusTypes.cc:1245
Definition: ModbusTypes.h:1454
ModbusRTU::ModbusData len
Definition: ModbusTypes.h:196
ModbusByte data[MAXLENPACKET]
Definition: ModbusTypes.h:480
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:2357
static size_t getDataLen(const ModbusMessage &m)
Definition: ModbusTypes.cc:1500
size_t szData() const
Definition: ModbusTypes.cc:2400
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:1641
ModbusData data[MAXLENPACKET/sizeof(ModbusData)]
Definition: ModbusTypes.h:579
ModbusData start
Definition: ModbusTypes.h:845
size_t szData() const
Definition: ModbusTypes.cc:1744
Definition: ModbusTypes.h:1031
bool checkFormat() const
Definition: ModbusTypes.cc:3350
ModbusData numpacket
Definition: ModbusTypes.h:1577
static size_t getDataLen(const ModbusMessage &m)
Definition: ModbusTypes.cc:814
bool checkFormat() const
Definition: ModbusTypes.cc:1934
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:1837
bool addData(ModbusData d)
Definition: ModbusTypes.cc:1262
ModbusByte reftype
Definition: ModbusTypes.h:1531
static int szHead()
Definition: ModbusTypes.h:390
Definition: CommonEventLoop.h:14
bool addData(ModbusData d)
Definition: ModbusTypes.cc:1046
size_t count
Definition: ModbusTypes.h:718
void clear()
Definition: ModbusTypes.cc:1056
void clear()
Definition: ModbusTypes.cc:3541
ModbusData numfile
Definition: ModbusTypes.h:1609
ModbusByte dlen
Definition: ModbusTypes.h:1612
size_t szData() const
Definition: ModbusTypes.cc:897
ModbusByte day
Definition: ModbusTypes.h:1402
SubRequest data[MAXLENPACKET/sizeof(SubRequest) - sizeof(ModbusByte)]
Definition: ModbusTypes.h:1540
static size_t szHead()
Definition: ModbusTypes.h:490
ModbusCRC crc
Definition: ModbusTypes.h:1578
Definition: ModbusTypes.h:842
ModbusData numrec
Definition: ModbusTypes.h:1533
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:923
Definition: ModbusTypes.h:1487
void clear()
Definition: ModbusTypes.cc:2848
ModbusCRC crc
Definition: ModbusTypes.h:850
ModbusByte bcnt
Definition: ModbusTypes.h:379
bool addData(DataBits d)
Definition: ModbusTypes.cc:843
ModbusCRC crc
Definition: ModbusTypes.h:733
ModbusData data
Definition: ModbusTypes.h:1035
void init(const ModbusMessage &m)
Definition: ModbusTypes.cc:1801
size_t szData() const
Definition: ModbusTypes.cc:3300
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:3306
size_t szData() const
Definition: ModbusTypes.cc:3388
Definition: ModbusTypes.h:345
size_t szData() const
Definition: ModbusTypes.cc:3243
void clear()
Definition: ModbusTypes.cc:3293
ModbusByte func
Definition: ModbusTypes.h:182
static size_t szHead()
Definition: ModbusTypes.h:1554
ModbusByte year
Definition: ModbusTypes.h:1404
bool setData(ModbusByte *b, int len)
Definition: ModbusTypes.cc:2825
ModbusByte bcnt
Definition: ModbusTypes.h:578
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:3191
ModbusRTU::ModbusData pID
Definition: ModbusTypes.h:195
Definition: ModbusTypes.h:802
bool isFull() const
Definition: ModbusTypes.h:1286
ModbusData start
Definition: ModbusTypes.h:938
size_t szData() const
Definition: ModbusTypes.cc:3555
static size_t getDataLen(const ModbusMessage &m)
Definition: ModbusTypes.cc:611
static size_t szData()
Definition: ModbusTypes.h:283
bool isFull() const
Definition: ModbusTypes.h:1508
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:2051
ModbusData quant
Definition: ModbusTypes.h:806
ModbusByte bcnt
Definition: ModbusTypes.h:1608
size_t count
Definition: ModbusTypes.h:1168
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:2472
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:3420
Definition: ModbusTypes.h:896
void clear()
Definition: ModbusTypes.cc:660
ModbusRTU::ModbusData tID
Definition: ModbusTypes.h:194
static size_t szHead()
Definition: ModbusTypes.h:782
ModbusByte hour
Definition: ModbusTypes.h:1399
static size_t szHead()
Definition: ModbusTypes.h:1055
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:1578
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:1880
bool checkFormat()
Definition: ModbusTypes.cc:2105
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:1063
Definition: ModbusTypes.h:292
size_t szData() const
Definition: ModbusTypes.cc:694
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:1406
ModbusData start
Definition: ModbusTypes.h:899
static size_t getDataLen(const ModbusMessage &m)
Definition: ModbusTypes.cc:1944
void init(const ModbusMessage &m)
Definition: ModbusTypes.cc:2153
Definition: ModbusTypes.h:1573
Definition: ModbusTypes.h:1116
ModbusByte devID
Definition: ModbusTypes.h:1245
ModbusCRC crc
Definition: ModbusTypes.h:1541
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:1279
ModbusCRC crc
Definition: ModbusTypes.h:1036
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:3561
Definition: ModbusTypes.h:1186
Definition: ModbusTypes.h:664
ModbusByte min
Definition: ModbusTypes.h:1400
ModbusByte objNum
Definition: ModbusTypes.h:1249
size_t count
Definition: ModbusTypes.h:627
ModbusData start
Definition: ModbusTypes.h:1080
void init(const ModbusMessage &m)
Definition: ModbusTypes.cc:1542
ModbusData data
Definition: ModbusTypes.h:1081
size_t szData() const
Definition: ModbusTypes.cc:1939
ModbusByte bcnt
Definition: ModbusTypes.h:1537
static size_t getDataLen(const ModbusMessage &m)
Definition: ModbusTypes.cc:1029
bool addData(ModbusByte id, const std::string &value)
Definition: ModbusTypes.cc:2675
ModbusByte bcnt
Definition: ModbusTypes.h:667
Definition: ModbusTypes.h:192
ModbusData numpacks
Definition: ModbusTypes.h:1610
size_t szData() const
Definition: ModbusTypes.cc:1109
ModbusData start
Definition: ModbusTypes.h:989
Definition: ModbusTypes.h:1601
ModbusData data
Definition: ModbusTypes.h:990
size_t dlen
Definition: ModbusTypes.h:256
ModbusData num
Definition: ModbusTypes.h:1312
static size_t getDataLen(const ModbusMessage &m)
Definition: ModbusTypes.cc:2116
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:2855
Definition: ModbusTypes.h:179
static size_t szHead()
Definition: ModbusTypes.h:1264
ModbusData data
Definition: ModbusTypes.h:939
bool addData(ModbusData d)
Definition: ModbusTypes.cc:2342
Definition: ModbusTypes.h:1174
Definition: ModbusTypes.h:1228
ModbusByte conformity
Definition: ModbusTypes.h:1246
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:2182
ModbusData reglen
Definition: ModbusTypes.h:1534
ModbusData start
Definition: ModbusTypes.h:1034
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:666
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:1134
ModbusByte mf
Definition: ModbusTypes.h:1247
static size_t szData()
Definition: ModbusTypes.h:1214
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:869
ModbusByte type
Definition: ModbusTypes.h:1189
static size_t getDataLen(const ModbusMessage &m)
Definition: ModbusTypes.cc:2314
ModbusByte century
Definition: ModbusTypes.h:1405
bool cmd()
Definition: ModbusTypes.h:943
ModbusData cmd
Definition: ModbusTypes.h:1311
size_t count
Definition: ModbusTypes.h:1522
bool isFull() const
Definition: ModbusTypes.h:1357
ModbusData numfile
Definition: ModbusTypes.h:1576
Definition: ModbusTypes.h:376
static size_t szData()
Definition: ModbusTypes.h:1020
static size_t szHead()
Definition: ModbusTypes.h:964
static size_t getDataLen(const ModbusMessage &m)
Definition: ModbusTypes.cc:3394
static size_t szHead()
Definition: ModbusTypes.h:875
void clear()
Definition: ModbusTypes.cc:2688
ModbusData start
Definition: ModbusTypes.h:805
void init(const ModbusMessage &m)
Definition: ModbusTypes.cc:1976
Definition: ModbusTypes.h:445
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:3118
Definition: ModbusTypes.h:1241
static size_t szData()
Definition: ModbusTypes.h:652
Definition: ModbusTypes.h:158
size_t count
Definition: ModbusTypes.h:1373
ModbusByte objID
Definition: ModbusTypes.h:1248
size_t szData() const
Definition: ModbusTypes.cc:1495
static size_t szData()
Definition: ModbusTypes.h:564
ModbusAddr addr
Definition: ModbusTypes.h:181
void set(ModbusData start, ModbusData quant)
Definition: ModbusTypes.cc:1831
void set(ModbusData start, ModbusData quant)
Definition: ModbusTypes.cc:1572
ModbusByte bcnt
Definition: ModbusTypes.h:1490
ModbusByte bcnt
Definition: ModbusTypes.h:730
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:719
ModbusData data[MAXLENPACKET/sizeof(ModbusData)]
Definition: ModbusTypes.h:1340
bool setData(ModbusByte *b, int len)
Definition: ModbusTypes.cc:3275
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:387
void clear()
Definition: ModbusTypes.cc:863
ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)]
Definition: ModbusTypes.h:1460
bool setBit(uint8_t dnum, uint8_t bnum, bool state)
Definition: ModbusTypes.cc:830
ModbusCRC crc
Definition: ModbusTypes.h:1193
static size_t szHead()
Definition: ModbusTypes.h:1208
ModbusData quant
Definition: ModbusTypes.h:729
Definition: ModbusTypes.h:725
ModbusData quant
Definition: ModbusTypes.h:900
size_t count
Definition: ModbusTypes.h:1566
ModbusByte devID
Definition: ModbusTypes.h:1190
bool setBit(uint8_t dnum, uint8_t bnum, bool state)
Definition: ModbusTypes.cc:627
bool getData(uint8_t bnum, DataBits &d) const
Definition: ModbusTypes.cc:649
static size_t szData()
Definition: ModbusTypes.h:1422
ModbusData start
Definition: ModbusTypes.h:728
static size_t szData()
Definition: ModbusTypes.h:925
Definition: ModbusTypes.h:1308
bool addData(DataBits d)
Definition: ModbusTypes.cc:640
void clear()
Definition: ModbusTypes.cc:1272
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:2004
Definition: ModbusTypes.h:634
Definition: ModbusTypes.h:1382
bool isFull() const
Definition: ModbusTypes.h:529
static size_t szData()
Definition: ModbusTypes.h:1590
Definition: ModbusTypes.h:575
bool addData(DataBits d)
Definition: ModbusTypes.cc:1349
ModbusData data[MAXLENPACKET/sizeof(ModbusData) - sizeof(ModbusData) *2 - sizeof(ModbusByte)]
Definition: ModbusTypes.h:849
static size_t szData()
Definition: ModbusTypes.h:831
static size_t szData()
Definition: ModbusTypes.h:1320
size_t szData()
Definition: ModbusTypes.cc:1322
static size_t getDataLen(const ModbusMessage &m)
Definition: ModbusTypes.cc:3248
bool isFull() const
Definition: ModbusTypes.h:1151
static size_t szData()
Definition: ModbusTypes.h:363
Definition: ModbusTypes.h:263
Definition: ModbusTypes.h:210
bool isFull() const
Definition: ModbusTypes.h:700
ModbusByte objID
Definition: ModbusTypes.h:1191
bool cmd() const
Definition: ModbusTypes.h:994
size_t szData() const
Definition: ModbusTypes.cc:2111
static size_t getDataLen(const ModbusMessage &m)
Definition: ModbusTypes.cc:1749
ModbusByte type
Definition: ModbusTypes.h:1244
ModbusByte sec
Definition: ModbusTypes.h:1401
size_t szData() const
Definition: ModbusTypes.cc:2902
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:342
void set(ModbusData start, bool cmd)
Definition: ModbusTypes.cc:1997
ModbusData packet
Definition: ModbusTypes.h:1611
ModbusByte bcnt
Definition: ModbusTypes.h:1457
static size_t szHead()
Definition: ModbusTypes.h:1129
ModbusByte bcnt
Definition: ModbusTypes.h:1334
ModbusData data[MAXLENPACKET/sizeof(ModbusData)]
Definition: ModbusTypes.h:1120
void set(ModbusData start, ModbusData data)
Definition: ModbusTypes.cc:2175
ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)]
Definition: ModbusTypes.h:1492
Definition: ModbusTypes.h:318
bool isFull() const
Definition: ModbusTypes.h:611
ModbusByte data[MAXLENPACKET+szCRC]
Definition: ModbusTypes.h:253
void clear()
Definition: ModbusTypes.cc:2351
Definition: ModbusTypes.h:546
bool getData(uint8_t dnum, DataBits &d)
Definition: ModbusTypes.cc:1387
bool set(ModbusData numfile, ModbusData file_num_packets, ModbusData packet, ModbusByte *b, ModbusByte len)
Definition: ModbusTypes.cc:3526
Definition: ModbusTypes.h:1396
ModbusCRC crc
Definition: ModbusTypes.h:1461
static size_t szData()
Definition: ModbusTypes.h:1106
Definition: ModbusTypes.h:935
Definition: ModbusTypes.h:1434
ModbusData quant
Definition: ModbusTypes.h:846
ModbusCRC crc
Definition: ModbusTypes.h:940
bool isFull() const
Definition: ModbusTypes.h:429
ModbusData data[MAXLENPACKET/sizeof(ModbusData)]
Definition: ModbusTypes.h:668
Definition: ModbusTypes.h:1526
bool checkFormat() const
Definition: ModbusTypes.cc:1738
ModbusByte bcnt
Definition: ModbusTypes.h:479
ModbusByte bcnt
Definition: ModbusTypes.h:847
ModbusMessage transport_msg()
Definition: ModbusTypes.cc:2694
ModbusByte data[MAXLENPACKET - sizeof(ModbusData) *2 - sizeof(ModbusByte)]
Definition: ModbusTypes.h:732
static size_t szHead()
Definition: ModbusTypes.h:1474
Definition: ModbusTypes.h:1331
static size_t szHead()
Definition: ModbusTypes.h:677
ModbusByte mon
Definition: ModbusTypes.h:1403
ModbusData numfile
Definition: ModbusTypes.h:1532
static size_t szData()
Definition: ModbusTypes.h:465