UniSet  2.7.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 size_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  typedef unsigned long RegID;
83 
90  RegID genRegID( const ModbusRTU::ModbusData r, const int 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 unsigned char 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  bool isWriteFunction( SlaveFunctionCode c );
158  bool isReadFunction( SlaveFunctionCode c );
159  // -------------------------------------------------------------------------
162  {
163  ModbusAddr addr;
164  ModbusByte func;
166  ModbusHeader(): addr(0), func(0) {}
167  } __attribute__((packed));
168 
169  const size_t szModbusHeader = sizeof(ModbusHeader);
170 
171  std::ostream& operator<<(std::ostream& os, const ModbusHeader& m );
172  std::ostream& operator<<(std::ostream& os, const ModbusHeader* m );
173  // -----------------------------------------------------------------------
174  struct MBAPHeader
175  {
176  ModbusRTU::ModbusData tID;
177  ModbusRTU::ModbusData pID;
178  ModbusRTU::ModbusData len;
180  MBAPHeader(): tID(0), pID(0), len(0) {}
181 
182  void swapdata();
183 
184  } __attribute__((packed));
185 
186  std::ostream& operator<<(std::ostream& os, const MBAPHeader& m );
187  // -----------------------------------------------------------------------
188 
193  {
194  ModbusMessage();
195 
196  ModbusMessage( ModbusMessage&& ) = default;
197  ModbusMessage& operator=(ModbusMessage&& ) = default;
198  ModbusMessage( const ModbusMessage& ) = default;
199  ModbusMessage& operator=(const ModbusMessage& ) = default;
200 
201  inline ModbusByte func() const
202  {
203  return pduhead.func;
204  }
205  inline ModbusAddr addr() const
206  {
207  return pduhead.addr;
208  }
209  inline ModbusRTU::ModbusData tID() const
210  {
211  return mbaphead.tID;
212  }
213  inline ModbusRTU::ModbusData pID() const
214  {
215  return mbaphead.pID;
216  }
217  inline ModbusRTU::ModbusData aduLen() const
218  {
219  return mbaphead.len;
220  }
221 
222  u_int8_t* buf();
223  ModbusRTU::ModbusData len() const;
224  void swapHead();
225  void makeMBAPHeader( ModbusRTU::ModbusData tID, bool noCRC = true, ModbusRTU::ModbusData pID = 0 );
226 
227  ModbusRTU::ModbusData pduLen() const;
228  ModbusCRC pduCRC( size_t len ) const;
229  static size_t maxSizeOfMessage();
230 
231  void clear();
232 
233  MBAPHeader mbaphead;
234  ModbusHeader pduhead;
235  ModbusByte data[MAXLENPACKET + szCRC];
237  // Это поле вспомогательное и игнорируется при пересылке
238  size_t dlen = { 0 };
239  } __attribute__((packed));
240 
241  std::ostream& operator<<(std::ostream& os, const ModbusMessage& m );
242  std::ostream& operator<<(std::ostream& os, const ModbusMessage* m );
243  // -----------------------------------------------------------------------
246  public ModbusHeader
247  {
248  ModbusByte ecode = { erNoError };
249  ModbusCRC crc = { 0 };
250 
251  // ------- from slave -------
252  ErrorRetMessage( const ModbusMessage& m );
253  ErrorRetMessage& operator=( const ModbusMessage& m );
254  void init( const ModbusMessage& m );
255 
256  // ------- to master -------
257  ErrorRetMessage( ModbusAddr _from, ModbusByte _func, ModbusByte ecode );
258 
260  ModbusMessage transport_msg();
261 
265  inline static size_t szData()
266  {
267  return sizeof(ModbusByte) + szCRC;
268  }
269  };
270 
271  std::ostream& operator<<(std::ostream& os, ErrorRetMessage& m );
272  std::ostream& operator<<(std::ostream& os, ErrorRetMessage* m );
273  // -----------------------------------------------------------------------
274  struct DataBits
275  {
276  DataBits( ModbusByte b );
277  DataBits( std::string s ); // example "10001111"
278  DataBits();
279 
280  const DataBits& operator=(const ModbusByte& r);
281 
282  operator ModbusByte();
283  ModbusByte mbyte();
284 
285  bool operator[]( const size_t i )
286  {
287  return b[i];
288  }
289  void set( int n, bool s )
290  {
291  b.set(n, s);
292  }
293 
294  std::bitset<BitsPerByte> b;
295  };
296 
297  std::ostream& operator<<(std::ostream& os, DataBits& m );
298  std::ostream& operator<<(std::ostream& os, DataBits* m );
299  // -----------------------------------------------------------------------
300  struct DataBits16
301  {
302  DataBits16( ModbusData d );
303  DataBits16( const std::string& s ); // example "1000111110001111"
304  DataBits16();
305 
306  const DataBits16& operator=(const ModbusData& r);
307 
308  operator ModbusData();
309  ModbusData mdata() const;
310 
311  bool operator[]( const size_t i )
312  {
313  return b[i];
314  }
315  void set( int n, bool s )
316  {
317  b.set(n, s);
318  }
319 
320  std::bitset<BitsPerData> b;
321  };
322 
323  std::ostream& operator<<(std::ostream& os, DataBits16& m );
324  std::ostream& operator<<(std::ostream& os, DataBits16* m );
325  // -----------------------------------------------------------------------
328  public ModbusHeader
329  {
330  ModbusData start = { 0 };
331  ModbusData count = { 0 };
332  ModbusCRC crc = { 0 };
333 
334  // ------- to slave -------
335  ReadCoilMessage( ModbusAddr addr, ModbusData start, ModbusData count );
337  ModbusMessage transport_msg();
338 
339  // ------- from master -------
340  ReadCoilMessage( const ModbusMessage& m );
341  ReadCoilMessage& operator=( const ModbusMessage& m );
342  void init( const ModbusMessage& m );
343 
345  inline static size_t szData()
346  {
347  return sizeof(ModbusData) * 2 + szCRC;
348  }
349 
350  } __attribute__((packed));
351 
352  std::ostream& operator<<(std::ostream& os, ReadCoilMessage& m );
353  std::ostream& operator<<(std::ostream& os, ReadCoilMessage* m );
354 
355  // -----------------------------------------------------------------------
356 
359  public ModbusHeader
360  {
361  ModbusByte bcnt = { 0 };
362  ModbusByte data[MAXLENPACKET];
364  // ------- from slave -------
365  ReadCoilRetMessage( const ModbusMessage& m );
366  ReadCoilRetMessage& operator=( const ModbusMessage& m );
367  void init( const ModbusMessage& m );
368 
372  static inline int szHead()
373  {
374  return sizeof(ModbusByte); // bcnt
375  }
376 
378  static size_t getDataLen( const ModbusMessage& m );
379  ModbusCRC crc = { 0 };
380 
381  // ------- to master -------
382  ReadCoilRetMessage( ModbusAddr _from );
383 
388  bool addData( DataBits d );
389 
397  bool setBit( uint8_t dnum, uint8_t bnum, bool state );
398 
405  bool getData( uint8_t bnum, DataBits& d ) const;
406 
408  void clear();
409 
411  inline bool isFull() const
412  {
413  return ( (int)bcnt >= MAXPDULEN );
414  }
415 
417  size_t szData() const;
418 
420  ModbusMessage transport_msg();
421  };
422 
423  std::ostream& operator<<(std::ostream& os, ReadCoilRetMessage& m );
424  std::ostream& operator<<(std::ostream& os, ReadCoilRetMessage* m );
425  // -----------------------------------------------------------------------
428  public ModbusHeader
429  {
430  ModbusData start = { 0 };
431  ModbusData count = { 0 };
432  ModbusCRC crc = { 0 };
433 
434  // ------- to slave -------
435  ReadInputStatusMessage( ModbusAddr addr, ModbusData start, ModbusData count );
436 
438  ModbusMessage transport_msg();
439 
440  // ------- from master -------
442  ReadInputStatusMessage& operator=( const ModbusMessage& m );
443 
444  void init( const ModbusMessage& m );
445 
447  inline static size_t szData()
448  {
449  return sizeof(ModbusData) * 2 + szCRC;
450  }
451 
452  } __attribute__((packed));
453 
454  std::ostream& operator<<(std::ostream& os, ReadInputStatusMessage& m );
455  std::ostream& operator<<(std::ostream& os, ReadInputStatusMessage* m );
456  // -----------------------------------------------------------------------
459  public ModbusHeader
460  {
461  ModbusByte bcnt = { 0 };
462  ModbusByte data[MAXLENPACKET];
464  // ------- from slave -------
466  ReadInputStatusRetMessage& operator=( const ModbusMessage& m );
467  void init( const ModbusMessage& m );
468 
472  static inline size_t szHead()
473  {
474  return sizeof(ModbusByte); // bcnt
475  }
476 
478  static size_t getDataLen( const ModbusMessage& m );
479  ModbusCRC crc = { 0 };
480 
481  // ------- to master -------
482  ReadInputStatusRetMessage( ModbusAddr _from );
483 
488  bool addData( DataBits d );
489 
497  bool setBit( uint8_t dnum, uint8_t bnum, bool state );
498 
505  bool getData( uint8_t dnum, DataBits& d ) const;
506 
508  void clear();
509 
511  inline bool isFull() const
512  {
513  return ( (int)bcnt >= MAXPDULEN );
514  }
515 
517  size_t szData() const;
518 
520  ModbusMessage transport_msg();
521  };
522 
523  std::ostream& operator<<(std::ostream& os, ReadInputStatusRetMessage& m );
524  std::ostream& operator<<(std::ostream& os, ReadInputStatusRetMessage* m );
525  // -----------------------------------------------------------------------
526 
529  public ModbusHeader
530  {
531  ModbusData start = { 0 };
532  ModbusData count = { 0 };
533  ModbusCRC crc = { 0 };
534 
535  // ------- to slave -------
536  ReadOutputMessage( ModbusAddr addr, ModbusData start, ModbusData count );
538  ModbusMessage transport_msg();
539 
540  // ------- from master -------
541  ReadOutputMessage( const ModbusMessage& m );
542  ReadOutputMessage& operator=( const ModbusMessage& m );
543  void init( const ModbusMessage& m );
544 
546  inline static size_t szData()
547  {
548  return sizeof(ModbusData) * 2 + szCRC;
549  }
550 
551  } __attribute__((packed));
552 
553  std::ostream& operator<<(std::ostream& os, ReadOutputMessage& m );
554  std::ostream& operator<<(std::ostream& os, ReadOutputMessage* m );
555  // -----------------------------------------------------------------------
558  public ModbusHeader
559  {
560  ModbusByte bcnt = { 0 };
561  ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
563  // ------- from slave -------
565  ReadOutputRetMessage& operator=( const ModbusMessage& m );
566  void init( const ModbusMessage& m );
570  static inline size_t szHead()
571  {
572  // bcnt
573  return sizeof(ModbusByte);
574  }
575 
577  static size_t getDataLen( const ModbusMessage& m );
578  ModbusCRC crc = { 0 };
579 
580  // ------- to master -------
581  ReadOutputRetMessage( ModbusAddr _from );
582 
587  bool addData( ModbusData d );
588 
590  void clear();
591 
593  inline bool isFull() const
594  {
595  return ( count * sizeof(ModbusData) >= MAXLENPACKET );
596  }
597 
599  size_t szData() const;
600 
602  ModbusMessage transport_msg();
603 
604  // Это поле не входит в стандарт modbus
605  // оно вспомогательное и игнорируется при
606  // преобразовании в ModbusMessage.
607  // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
608  // Используйте специальную функцию transport_msg()
609  size_t count = { 0 };
610  };
611 
612  std::ostream& operator<<(std::ostream& os, ReadOutputRetMessage& m );
613  std::ostream& operator<<(std::ostream& os, ReadOutputRetMessage* m );
614  // -----------------------------------------------------------------------
617  public ModbusHeader
618  {
619  ModbusData start = { 0 };
620  ModbusData count = { 0 };
621  ModbusCRC crc = { 0 };
622 
623  // ------- to slave -------
624  ReadInputMessage( ModbusAddr addr, ModbusData start, ModbusData count );
626  ModbusMessage transport_msg();
627 
628  // ------- from master -------
629  ReadInputMessage( const ModbusMessage& m );
630  ReadInputMessage& operator=( const ModbusMessage& m );
631  void init( const ModbusMessage& m );
632 
634  inline static size_t szData()
635  {
636  return sizeof(ModbusData) * 2 + szCRC;
637  }
638 
639  } __attribute__((packed));
640 
641  std::ostream& operator<<(std::ostream& os, ReadInputMessage& m );
642  std::ostream& operator<<(std::ostream& os, ReadInputMessage* m );
643  // -----------------------------------------------------------------------
644 
647  public ModbusHeader
648  {
649  ModbusByte bcnt = { 0 };
650  ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
652  // ------- from slave -------
654  ReadInputRetMessage& operator=( const ModbusMessage& m );
655  void init( const ModbusMessage& m );
659  static inline size_t szHead()
660  {
661  // bcnt
662  return sizeof(ModbusByte);
663  }
664 
666  static size_t getDataLen( const ModbusMessage& m );
667  ModbusCRC crc = { 0 };
668 
669  // ------- to master -------
670  ReadInputRetMessage( ModbusAddr _from );
671 
676  bool addData( ModbusData d );
677 
679  void clear();
680 
682  inline bool isFull() const
683  {
684  return ( count * sizeof(ModbusData) >= MAXLENPACKET );
685  }
686 
687  void swapData();
688 
690  size_t szData();
691 
693  ModbusMessage transport_msg();
694 
695  // Это поле не входит в стандарт modbus
696  // оно вспомогательное и игнорируется при
697  // преобразовании в ModbusMessage.
698  // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
699  // Используйте специальную функцию transport_msg()
700  size_t count = { 0 };
701  };
702 
703  std::ostream& operator<<(std::ostream& os, ReadInputRetMessage& m );
704  std::ostream& operator<<(std::ostream& os, ReadInputRetMessage* m );
705  // -----------------------------------------------------------------------
708  public ModbusHeader
709  {
710  ModbusData start = { 0 };
711  ModbusData quant = { 0 };
712  ModbusByte bcnt = { 0 };
714  ModbusByte data[MAXLENPACKET - sizeof(ModbusData) * 2 - sizeof(ModbusByte)];
715  ModbusCRC crc = { 0 };
717  // ------- to slave -------
718  ForceCoilsMessage( ModbusAddr addr, ModbusData start );
720  ModbusMessage transport_msg();
721 
726  bool addData( DataBits d );
727 
728  // return number of bit
729  // -1 - error
730  int addBit( bool state );
731 
732  bool setBit( uint8_t nbit, bool state );
733 
734  inline size_t last() const
735  {
736  return quant;
737  }
738 
745  bool getData( uint8_t dnum, DataBits& d );
746 
747  void clear();
748  inline bool isFull() const
749  {
750  return ( (int)bcnt >= MAXPDULEN );
751  }
752 
753  // ------- from master -------
754  ForceCoilsMessage( const ModbusMessage& m );
755  ForceCoilsMessage& operator=( const ModbusMessage& m );
756  void init( const ModbusMessage& m );
757 
759  size_t szData() const;
760 
764  static inline size_t szHead()
765  {
766  // start + quant + count
767  return sizeof(ModbusData) * 2 + sizeof(ModbusByte);
768  }
769 
771  static size_t getDataLen( const ModbusMessage& m );
772 
776  bool checkFormat() const;
777 
778  } __attribute__((packed));
779 
780  std::ostream& operator<<(std::ostream& os, ForceCoilsMessage& m );
781  std::ostream& operator<<(std::ostream& os, ForceCoilsMessage* m );
782  // -----------------------------------------------------------------------
785  public ModbusHeader
786  {
787  ModbusData start = { 0 };
788  ModbusData quant = { 0 };
789  ModbusCRC crc = { 0 };
790 
791  // ------- from slave -------
793  ForceCoilsRetMessage& operator=( const ModbusMessage& m );
794  void init( const ModbusMessage& m );
795 
796  // ------- to master -------
802  ForceCoilsRetMessage( ModbusAddr _from, ModbusData start = 0, ModbusData quant = 0 );
803 
805  void set( ModbusData start, ModbusData quant );
806 
808  ModbusMessage transport_msg();
809 
813  inline static size_t szData()
814  {
815  return sizeof(ModbusData) * 2 + sizeof(ModbusCRC);
816  }
817  };
818 
819  std::ostream& operator<<(std::ostream& os, ForceCoilsRetMessage& m );
820  std::ostream& operator<<(std::ostream& os, ForceCoilsRetMessage* m );
821  // -----------------------------------------------------------------------
822 
825  public ModbusHeader
826  {
827  ModbusData start = { 0 };
828  ModbusData quant = { 0 };
829  ModbusByte bcnt = { 0 };
831  ModbusData data[MAXLENPACKET / sizeof(ModbusData) - sizeof(ModbusData) * 2 - sizeof(ModbusByte)];
832  ModbusCRC crc = { 0 };
834  // ------- to slave -------
835  WriteOutputMessage( ModbusAddr addr, ModbusData start );
837  ModbusMessage transport_msg();
838 
839  bool addData( ModbusData d );
840  void clear();
841  inline bool isFull() const
842  {
843  return ( quant >= MAXDATALEN );
844  }
845 
846  // ------- from master -------
847  WriteOutputMessage( const ModbusMessage& m );
848  WriteOutputMessage& operator=( const ModbusMessage& m );
849  void init( const ModbusMessage& m );
850 
852  size_t szData() const;
853 
857  static inline size_t szHead()
858  {
859  // start + quant + count
860  return sizeof(ModbusData) * 2 + sizeof(ModbusByte);
861  }
862 
864  static size_t getDataLen( const ModbusMessage& m );
865 
869  bool checkFormat() const;
870 
871  } __attribute__((packed));
872 
873 
874  std::ostream& operator<<(std::ostream& os, WriteOutputMessage& m );
875  std::ostream& operator<<(std::ostream& os, WriteOutputMessage* m );
876 
879  public ModbusHeader
880  {
881  ModbusData start = { 0 };
882  ModbusData quant = { 0 };
884  // ------- from slave -------
886  WriteOutputRetMessage& operator=( const ModbusMessage& m );
887  void init( const ModbusMessage& m );
888  ModbusCRC crc = { 0 };
889 
890  // ------- to master -------
896  WriteOutputRetMessage( ModbusAddr _from, ModbusData start = 0, ModbusData quant = 0 );
897 
899  void set( ModbusData start, ModbusData quant );
900 
902  ModbusMessage transport_msg();
903 
907  inline static size_t szData()
908  {
909  return sizeof(ModbusData) * 2 + sizeof(ModbusCRC);
910  }
911  };
912 
913  std::ostream& operator<<(std::ostream& os, WriteOutputRetMessage& m );
914  std::ostream& operator<<(std::ostream& os, WriteOutputRetMessage* m );
915  // -----------------------------------------------------------------------
918  public ModbusHeader
919  {
920  ModbusData start = { 0 };
921  ModbusData data = { 0 };
922  ModbusCRC crc = { 0 };
925  inline bool cmd()
926  {
927  return (data & 0xFF00);
928  }
929 
930  // ------- to slave -------
931  ForceSingleCoilMessage( ModbusAddr addr, ModbusData reg, bool state );
933  ModbusMessage transport_msg();
934 
935  // ------- from master -------
937  ForceSingleCoilMessage& operator=( const ModbusMessage& m );
938  void init( const ModbusMessage& m );
939 
941  size_t szData() const;
942 
946  static inline size_t szHead()
947  {
948  return sizeof(ModbusData);
949  }
950 
954  static size_t getDataLen( const ModbusMessage& m );
955 
959  bool checkFormat() const;
960  } __attribute__((packed));
961 
962 
963  std::ostream& operator<<(std::ostream& os, ForceSingleCoilMessage& m );
964  std::ostream& operator<<(std::ostream& os, ForceSingleCoilMessage* m );
965  // -----------------------------------------------------------------------
966 
969  public ModbusHeader
970  {
971  ModbusData start = { 0 };
972  ModbusData data = { 0 };
973  ModbusCRC crc = { 0 };
974 
976  inline bool cmd() const
977  {
978  return (data & 0xFF00);
979  }
980 
981  // ------- from slave -------
983  ForceSingleCoilRetMessage& operator=( const ModbusMessage& m );
984  void init( const ModbusMessage& m );
985 
986  // ------- to master -------
991  ForceSingleCoilRetMessage( ModbusAddr _from );
992 
994  void set( ModbusData start, bool cmd );
995 
997  ModbusMessage transport_msg();
998 
1002  inline static size_t szData()
1003  {
1004  return 2 * sizeof(ModbusData) + sizeof(ModbusCRC);
1005  }
1006  };
1007 
1008  std::ostream& operator<<(std::ostream& os, ForceSingleCoilRetMessage& m );
1009  std::ostream& operator<<(std::ostream& os, ForceSingleCoilRetMessage* m );
1010  // -----------------------------------------------------------------------
1011 
1014  public ModbusHeader
1015  {
1016  ModbusData start = { 0 };
1017  ModbusData data = { 0 };
1018  ModbusCRC crc = { 0 };
1021  // ------- to slave -------
1022  WriteSingleOutputMessage( ModbusAddr addr, ModbusData reg = 0, ModbusData data = 0 );
1024  ModbusMessage transport_msg();
1025 
1026  // ------- from master -------
1028  WriteSingleOutputMessage& operator=( const ModbusMessage& m );
1029  void init( const ModbusMessage& m );
1030 
1032  size_t szData() const;
1033 
1037  static inline size_t szHead()
1038  {
1039  return sizeof(ModbusData);
1040  }
1041 
1045  static size_t getDataLen( const ModbusMessage& m );
1046 
1050  bool checkFormat();
1051  } __attribute__((packed));
1052 
1053 
1054  std::ostream& operator<<(std::ostream& os, WriteSingleOutputMessage& m );
1055  std::ostream& operator<<(std::ostream& os, WriteSingleOutputMessage* m );
1056  // -----------------------------------------------------------------------
1057 
1060  public ModbusHeader
1061  {
1062  ModbusData start = { 0 };
1063  ModbusData data = { 0 };
1064  ModbusCRC crc = { 0 };
1065 
1066 
1067  // ------- from slave -------
1069  WriteSingleOutputRetMessage& operator=( const ModbusMessage& m );
1070  void init( const ModbusMessage& m );
1071 
1072  // ------- to master -------
1077  WriteSingleOutputRetMessage( ModbusAddr _from, ModbusData start = 0 );
1078 
1080  void set( ModbusData start, ModbusData data );
1081 
1083  ModbusMessage transport_msg();
1084 
1088  inline static size_t szData()
1089  {
1090  return 2 * sizeof(ModbusData) + sizeof(ModbusCRC);
1091  }
1092  };
1093 
1094  std::ostream& operator<<(std::ostream& os, WriteSingleOutputRetMessage& m );
1095  std::ostream& operator<<(std::ostream& os, WriteSingleOutputRetMessage* m );
1096  // -----------------------------------------------------------------------
1099  public ModbusHeader
1100  {
1101  ModbusData subf = { 0 };
1102  ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
1104  // ------- from slave -------
1105  DiagnosticMessage( const ModbusMessage& m );
1106  DiagnosticMessage& operator=( const ModbusMessage& m );
1107  void init( const ModbusMessage& m );
1111  static inline size_t szHead()
1112  {
1113  return sizeof(ModbusData); // subf
1114  }
1115 
1117  static size_t getDataLen( const ModbusMessage& m );
1118  ModbusCRC crc = { 0 };
1119 
1120  // ------- to master -------
1121  DiagnosticMessage( ModbusAddr _from, DiagnosticsSubFunction subf, ModbusData d = 0 );
1122 
1127  bool addData( ModbusData d );
1128 
1130  void clear();
1131 
1133  inline bool isFull() const
1134  {
1135  // (1)subf + data count
1136  return ( 1 + count >= MAXDATALEN );
1137  }
1138 
1140  size_t szData() const;
1141 
1143  ModbusMessage transport_msg();
1144 
1145  // Это поле не входит в стандарт modbus
1146  // оно вспомогательное и игнорируется при
1147  // преобразовании в ModbusMessage.
1148  // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
1149  // Используйте специальную функцию transport_msg()
1150  size_t count = { 0 };
1151  };
1152  std::ostream& operator<<(std::ostream& os, DiagnosticMessage& m );
1153  std::ostream& operator<<(std::ostream& os, DiagnosticMessage* m );
1154  // -----------------------------------------------------------------------
1157  public DiagnosticMessage
1158  {
1159  DiagnosticRetMessage( const ModbusMessage& m );
1161  DiagnosticRetMessage( ModbusAddr a, DiagnosticsSubFunction subf, ModbusData d = 0 );
1162  };
1163 
1164  std::ostream& operator<<(std::ostream& os, DiagnosticRetMessage& m );
1165  std::ostream& operator<<(std::ostream& os, DiagnosticRetMessage* m );
1166  // -----------------------------------------------------------------------
1169  public ModbusHeader
1170  {
1171  ModbusByte type;
1172  ModbusByte devID;
1173  ModbusByte objID;
1175  ModbusCRC crc = { 0 };
1177  // ------- to slave -------
1178  MEIMessageRDI( ModbusAddr addr, ModbusByte devID, ModbusByte objID );
1180  ModbusMessage transport_msg();
1181 
1182  // ------- from master -------
1183  MEIMessageRDI( const ModbusMessage& m );
1184  MEIMessageRDI& operator=( const ModbusMessage& m );
1185  void init( const ModbusMessage& m );
1186 
1190  static inline size_t szHead()
1191  {
1192  return sizeof(ModbusByte) * 3;
1193  }
1194 
1196  static inline size_t szData()
1197  {
1198  return sizeof(ModbusByte) * 3 + szCRC;
1199  }
1200 
1201  // вспомогательные функции
1202  bool checkFormat() const;
1203 
1204  } __attribute__((packed));
1205  // -----------------------------------------------------------------------
1206  std::ostream& operator<<(std::ostream& os, MEIMessageRDI& m );
1207  std::ostream& operator<<(std::ostream& os, MEIMessageRDI* m );
1208  // -----------------------------------------------------------------------
1209 
1211  {
1212  RDIObjectInfo(): id(0), val("") {}
1213  RDIObjectInfo( ModbusByte id, const std::string& v ): id(id), val(v) {}
1214  RDIObjectInfo( ModbusByte id, const ModbusByte* dat, ModbusByte len );
1215 
1216  ModbusByte id;
1217  std::string val;
1218  };
1219 
1220  typedef std::list<RDIObjectInfo> RDIObjectList;
1221 
1224  public ModbusHeader
1225  {
1226  ModbusByte type;
1227  ModbusByte devID;
1228  ModbusByte conformity;
1229  ModbusByte mf;
1230  ModbusByte objID;
1231  ModbusByte objNum;
1233  RDIObjectList dlist;
1234  ModbusCRC crc = { 0 };
1235 
1236  // ------- from slave -------
1237  MEIMessageRetRDI();
1238  MEIMessageRetRDI( const ModbusMessage& m );
1239  MEIMessageRetRDI& operator=( const ModbusMessage& m );
1240  void init( const ModbusMessage& m );
1241 
1242  // предварительная инициализации, только заголовочной части, без данных
1243  void pre_init( const ModbusMessage& m );
1244 
1246  static inline size_t szHead()
1247  {
1248  return sizeof(ModbusByte) * 6;
1249  }
1250 
1251  // /*! узнать длину данных следующих за предварительным заголовком ( в байтах ) */
1252  // static int getDataLen( ModbusMessage& m );
1253 
1254  // ------- to master -------
1255  MEIMessageRetRDI( ModbusAddr _from, ModbusByte devID, ModbusByte conformity, ModbusByte mf, ModbusByte objID );
1256 
1261  bool addData( ModbusByte id, const std::string& value );
1262  bool addData( RDIObjectInfo& dat );
1263 
1265  void clear();
1266 
1268  inline bool isFull() const
1269  {
1270  return ( bcnt >= MAXPDULEN );
1271  }
1272 
1274  size_t szData() const;
1275 
1277  ModbusMessage transport_msg();
1278 
1279  size_t bcnt = { 0 };
1280  };
1281 
1282  std::ostream& operator<<(std::ostream& os, MEIMessageRetRDI& m );
1283  std::ostream& operator<<(std::ostream& os, MEIMessageRetRDI* m );
1284  std::ostream& operator<<(std::ostream& os, RDIObjectList& dl );
1285  std::ostream& operator<<(std::ostream& os, RDIObjectList* dl );
1286  // -----------------------------------------------------------------------
1287  // -----------------------------------------------------------------------
1288 
1291  public ModbusHeader
1292  {
1293  ModbusData cmd = { 0 };
1294  ModbusData num = { 0 };
1295  ModbusCRC crc = { 0 };
1296 
1297  // -------------
1299  JournalCommandMessage& operator=( const ModbusMessage& m );
1300 
1302  inline static size_t szData()
1303  {
1304  return sizeof(ModbusByte) * 4 + szCRC;
1305  }
1306 
1307  } __attribute__((packed));
1308 
1309  std::ostream& operator<<(std::ostream& os, JournalCommandMessage& m );
1310  std::ostream& operator<<(std::ostream& os, JournalCommandMessage* m );
1311  // -----------------------------------------------------------------------
1314  public ModbusHeader
1315  {
1316  ModbusByte bcnt = { 0 };
1317  // ModbusByte data[MAXLENPACKET-1]; /*!< данные */
1318 
1319  // В связи со спецификой реализации ответной части (т.е. modbus master)
1320  // данные приходится делать не байтовым потоком, а "словами"
1321  // которые в свою очередь будут перевёрнуты при посылке...
1322  ModbusData data[MAXLENPACKET / sizeof(ModbusData)];
1324  // -------------
1325  JournalCommandRetMessage( ModbusAddr _from );
1326 
1333  bool setData( ModbusByte* b, int len );
1334 
1336  void clear();
1337 
1339  inline bool isFull() const
1340  {
1341  return ( count >= MAXDATALEN );
1342  }
1343 
1345  size_t szData() const;
1346 
1348  ModbusMessage transport_msg();
1349 
1350  // Это поле не входит в стандарт modbus
1351  // оно вспомогательное и игнорируется при
1352  // преобразовании в ModbusMessage.
1353  // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
1354  // Используйте специальную функцию transport_msg()
1355  size_t count = { 0 };
1356  };
1357 
1358  std::ostream& operator<<(std::ostream& os, JournalCommandRetMessage& m );
1359  std::ostream& operator<<(std::ostream& os, JournalCommandRetMessage* m );
1360  // -----------------------------------------------------------------------
1366  {
1367  // -------------
1368  JournalCommandRetOK( ModbusAddr _from );
1369  void set( ModbusData cmd, ModbusData ecode );
1370  static void set( JournalCommandRetMessage& m, ModbusData cmd, ModbusData ecode );
1371  };
1372 
1373  std::ostream& operator<<(std::ostream& os, JournalCommandRetOK& m );
1374  std::ostream& operator<<(std::ostream& os, JournalCommandRetOK* m );
1375  // -----------------------------------------------------------------------
1376 
1379  public ModbusHeader
1380  {
1381  ModbusByte hour = { 0 };
1382  ModbusByte min = { 0 };
1383  ModbusByte sec = { 0 };
1384  ModbusByte day = { 1 };
1385  ModbusByte mon = { 1 };
1386  ModbusByte year = { 0 };
1387  ModbusByte century = { 20 };
1389  ModbusCRC crc = { 0 };
1390 
1391  // ------- to slave -------
1392  SetDateTimeMessage( ModbusAddr addr );
1394  ModbusMessage transport_msg();
1395 
1396  // ------- from master -------
1397  SetDateTimeMessage( const ModbusMessage& m );
1398  SetDateTimeMessage& operator=( const ModbusMessage& m );
1400 
1401  bool checkFormat() const;
1402 
1404  inline static size_t szData()
1405  {
1406  return sizeof(ModbusByte) * 7 + szCRC;
1407  }
1408 
1409  } __attribute__((packed));
1410 
1411  std::ostream& operator<<(std::ostream& os, SetDateTimeMessage& m );
1412  std::ostream& operator<<(std::ostream& os, SetDateTimeMessage* m );
1413  // -----------------------------------------------------------------------
1414 
1417  public SetDateTimeMessage
1418  {
1419 
1420  // ------- from slave -------
1422  SetDateTimeRetMessage& operator=( const ModbusMessage& m );
1423  void init( const ModbusMessage& m );
1424 
1425  // ------- to master -------
1426  SetDateTimeRetMessage( ModbusAddr _from );
1427  SetDateTimeRetMessage( const SetDateTimeMessage& query );
1428  static void cpy( SetDateTimeRetMessage& reply, const SetDateTimeMessage& query );
1429 
1431  ModbusMessage transport_msg();
1432  };
1433  // -----------------------------------------------------------------------
1434 
1437  public ModbusHeader
1438  {
1439  ModbusByte bcnt = { 0 };
1442  ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)];
1443  ModbusCRC crc = { 0 };
1445  // -----------
1446  RemoteServiceMessage( const ModbusMessage& m );
1447  RemoteServiceMessage& operator=( const ModbusMessage& m );
1448  void init( const ModbusMessage& m );
1449 
1451  size_t szData() const;
1452 
1456  static inline size_t szHead()
1457  {
1458  return sizeof(ModbusByte); // bcnt
1459  }
1460 
1462  static size_t getDataLen( const ModbusMessage& m );
1463 
1464  } __attribute__((packed));
1465 
1466  std::ostream& operator<<(std::ostream& os, RemoteServiceMessage& m );
1467  std::ostream& operator<<(std::ostream& os, RemoteServiceMessage* m );
1468  // -----------------------------------------------------------------------
1470  public ModbusHeader
1471  {
1472  ModbusByte bcnt = { 0 };
1474  ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)];
1475 
1476  RemoteServiceRetMessage( ModbusAddr _from );
1477 
1484  bool setData( ModbusByte* b, int len );
1485 
1487  void clear();
1488 
1490  inline bool isFull() const
1491  {
1492  return ( count >= sizeof(data) );
1493  }
1494 
1496  size_t szData() const;
1497 
1499  ModbusMessage transport_msg();
1500 
1501  // Это поле не входит в стандарт modbus
1502  // оно вспомогательное и игнорируется при
1503  // преобразовании в ModbusMessage.
1504  size_t count = { 0 };
1505  };
1506  // -----------------------------------------------------------------------
1507 
1509  public ModbusHeader
1510  {
1511  struct SubRequest
1512  {
1513  ModbusByte reftype;
1514  ModbusData numfile;
1515  ModbusData numrec;
1516  ModbusData reglen;
1517  } __attribute__((packed));
1518 
1519  ModbusByte bcnt = { 0 };
1522  SubRequest data[MAXLENPACKET / sizeof(SubRequest) - sizeof(ModbusByte)];
1523  ModbusCRC crc = { 0 };
1525  // -----------
1527  ReadFileRecordMessage& operator=( const ModbusMessage& m );
1528  void init( const ModbusMessage& m );
1529 
1531  size_t szData() const;
1532 
1536  static inline size_t szHead()
1537  {
1538  return sizeof(ModbusByte); // bcnt
1539  }
1540 
1542  static size_t getDataLen( const ModbusMessage& m );
1543 
1545  bool checkFormat() const;
1546 
1547  // это поле служебное и не используется в релальном обмене
1548  size_t count = { 0 };
1549  };
1550 
1551  std::ostream& operator<<(std::ostream& os, ReadFileRecordMessage& m );
1552  std::ostream& operator<<(std::ostream& os, ReadFileRecordMessage* m );
1553  // -----------------------------------------------------------------------
1554 
1556  public ModbusHeader
1557  {
1558  ModbusData numfile = { 0 };
1559  ModbusData numpacket = { 0 };
1560  ModbusCRC crc = { 0 };
1562  // ------- to slave -------
1563  FileTransferMessage( ModbusAddr addr, ModbusData numfile, ModbusData numpacket );
1564  ModbusMessage transport_msg();
1566  // ------- from master -------
1567  FileTransferMessage( const ModbusMessage& m );
1568  FileTransferMessage& operator=( const ModbusMessage& m );
1569  void init( const ModbusMessage& m );
1570 
1572  static inline size_t szData()
1573  {
1574  return sizeof(ModbusData) * 2 + szCRC;
1575  }
1576 
1577  } __attribute__((packed));
1578 
1579  std::ostream& operator<<(std::ostream& os, FileTransferMessage& m );
1580  std::ostream& operator<<(std::ostream& os, FileTransferMessage* m );
1581  // -----------------------------------------------------------------------
1582 
1584  public ModbusHeader
1585  {
1586  // 255 - max of bcnt...(1 byte)
1587  // static const int MaxDataLen = 255 - szCRC - szModbusHeader - sizeof(ModbusData)*3 - sizeof(ModbusByte)*2;
1588  static const size_t MaxDataLen = MAXLENPACKET - sizeof(ModbusData) * 3 - sizeof(ModbusByte) * 2;
1589 
1590  ModbusByte bcnt;
1591  ModbusData numfile;
1592  ModbusData numpacks;
1593  ModbusData packet;
1594  ModbusByte dlen;
1595  ModbusByte data[MaxDataLen];
1596 
1597 
1598  // ------- from slave -------
1600  FileTransferRetMessage& operator=( const ModbusMessage& m );
1601  void init( const ModbusMessage& m );
1602  ModbusCRC crc = { 0 };
1603  static size_t szHead()
1604  {
1605  return sizeof(ModbusByte);
1606  }
1607  static size_t getDataLen( const ModbusMessage& m );
1608 
1609  // ------- to master -------
1610  FileTransferRetMessage( ModbusAddr _from );
1611 
1615  bool set( ModbusData numfile, ModbusData file_num_packets, ModbusData packet, ModbusByte* b, ModbusByte len );
1616 
1618  void clear();
1619 
1621  size_t szData() const;
1622 
1624  ModbusMessage transport_msg();
1625  };
1626 
1627  std::ostream& operator<<(std::ostream& os, FileTransferRetMessage& m );
1628  std::ostream& operator<<(std::ostream& os, FileTransferRetMessage* m );
1629  // -----------------------------------------------------------------------
1630  } // end of ModbusRTU namespace
1631  // -------------------------------------------------------------------------
1632 } // end of namespace uniset
1633 // ---------------------------------------------------------------------------
1634 #endif // ModbusTypes_H_
1635 // ---------------------------------------------------------------------------
static size_t szHead()
Definition: ModbusTypes.h:570
Definition: ModbusTypes.h:1436
ModbusRTU::ModbusData len
Definition: ModbusTypes.h:178
Definition: ModbusTypes.h:1013
ModbusByte reftype
Definition: ModbusTypes.h:1513
static int szHead()
Definition: ModbusTypes.h:372
Definition: CallbackTimer.h:29
ModbusData numfile
Definition: ModbusTypes.h:1591
ModbusByte dlen
Definition: ModbusTypes.h:1594
static size_t szHead()
Definition: ModbusTypes.h:472
Definition: ModbusTypes.h:824
ModbusData numrec
Definition: ModbusTypes.h:1515
Definition: ModbusTypes.h:1469
Definition: ModbusTypes.h:327
ModbusByte func
Definition: ModbusTypes.h:164
static size_t szHead()
Definition: ModbusTypes.h:1536
ModbusRTU::ModbusData pID
Definition: ModbusTypes.h:177
Definition: ModbusTypes.h:784
bool isFull() const
Definition: ModbusTypes.h:1268
static size_t szData()
Definition: ModbusTypes.h:265
bool isFull() const
Definition: ModbusTypes.h:1490
ModbusByte bcnt
Definition: ModbusTypes.h:1590
Definition: ModbusTypes.h:878
ModbusRTU::ModbusData tID
Definition: ModbusTypes.h:176
static size_t szHead()
Definition: ModbusTypes.h:764
static size_t szHead()
Definition: ModbusTypes.h:1037
Definition: ModbusTypes.h:274
Definition: ModbusTypes.h:1555
Definition: ModbusTypes.h:1098
ModbusByte devID
Definition: ModbusTypes.h:1227
Definition: ModbusTypes.h:1168
Definition: ModbusTypes.h:646
ModbusByte objNum
Definition: ModbusTypes.h:1231
Definition: ModbusTypes.h:174
ModbusData numpacks
Definition: ModbusTypes.h:1592
Definition: ModbusTypes.h:1583
Definition: ModbusTypes.h:161
static size_t szHead()
Definition: ModbusTypes.h:1246
Definition: ModbusTypes.h:1156
Definition: ModbusTypes.h:1210
ModbusByte conformity
Definition: ModbusTypes.h:1228
ModbusData reglen
Definition: ModbusTypes.h:1516
ModbusByte mf
Definition: ModbusTypes.h:1229
static size_t szData()
Definition: ModbusTypes.h:1196
ModbusByte type
Definition: ModbusTypes.h:1171
bool cmd()
Definition: ModbusTypes.h:925
bool isFull() const
Definition: ModbusTypes.h:1339
Definition: ModbusTypes.h:358
static size_t szData()
Definition: ModbusTypes.h:1002
static size_t szHead()
Definition: ModbusTypes.h:946
static size_t szHead()
Definition: ModbusTypes.h:857
Definition: ModbusTypes.h:427
Definition: ModbusTypes.h:1223
static size_t szData()
Definition: ModbusTypes.h:634
ModbusByte objID
Definition: ModbusTypes.h:1230
static size_t szData()
Definition: ModbusTypes.h:546
ModbusAddr addr
Definition: ModbusTypes.h:163
static size_t szHead()
Definition: ModbusTypes.h:1190
Definition: ModbusTypes.h:707
ModbusByte devID
Definition: ModbusTypes.h:1172
static size_t szData()
Definition: ModbusTypes.h:1404
static size_t szData()
Definition: ModbusTypes.h:907
Definition: ModbusTypes.h:1290
Definition: ModbusTypes.h:616
Definition: ModbusTypes.h:1364
bool isFull() const
Definition: ModbusTypes.h:511
static size_t szData()
Definition: ModbusTypes.h:1572
Definition: ModbusTypes.h:557
static size_t szData()
Definition: ModbusTypes.h:813
static size_t szData()
Definition: ModbusTypes.h:1302
bool isFull() const
Definition: ModbusTypes.h:1133
static size_t szData()
Definition: ModbusTypes.h:345
Definition: ModbusTypes.h:245
Definition: ModbusTypes.h:192
bool isFull() const
Definition: ModbusTypes.h:682
ModbusByte objID
Definition: ModbusTypes.h:1173
bool cmd() const
Definition: ModbusTypes.h:976
ModbusByte type
Definition: ModbusTypes.h:1226
ModbusData packet
Definition: ModbusTypes.h:1593
static size_t szHead()
Definition: ModbusTypes.h:1111
Definition: ModbusTypes.h:300
bool isFull() const
Definition: ModbusTypes.h:593
Definition: ModbusTypes.h:528
Definition: ModbusTypes.h:1378
static size_t szData()
Definition: ModbusTypes.h:1088
Definition: ModbusTypes.h:917
Definition: ModbusTypes.h:1416
bool isFull() const
Definition: ModbusTypes.h:411
Definition: ModbusTypes.h:1508
static size_t szHead()
Definition: ModbusTypes.h:1456
Definition: ModbusTypes.h:1313
static size_t szHead()
Definition: ModbusTypes.h:659
ModbusData numfile
Definition: ModbusTypes.h:1514
static size_t szData()
Definition: ModbusTypes.h:447