UniSet  2.7.0
VTypes.h
1 /*
2  * Copyright (c) 2015 Pavel Vainerman.
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License as
6  * published by the Free Software Foundation, version 2.1.
7  *
8  * This program is distributed in the hope that it will be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  * Lesser General Lesser Public License for more details.
12  *
13  * You should have received a copy of the GNU Lesser General Public License
14  * along with this program. If not, see <http://www.gnu.org/licenses/>.
15  */
16 // --------------------------------------------------------------------------
17 // --------------------------------------------------------------------------
18 #ifndef _RTUTypes_H_
19 #define _RTUTypes_H_
20 // -----------------------------------------------------------------------------
21 #include <string>
22 #include <stdint.h>
23 #include <cmath>
24 #include <cstring>
25 #include <ostream>
26 #include "modbus/ModbusTypes.h"
27 // -----------------------------------------------------------------------------
28 namespace uniset
29 {
30  // -----------------------------------------------------------------------------
31  namespace VTypes
32  {
34  enum VType
35  {
36  vtUnknown,
37  vtF2,
38  vtF2r,
39  vtF4,
40  vtByte,
41  vtUnsigned,
42  vtSigned,
43  vtI2,
44  vtI2r,
45  vtU2,
46  vtU2r
47  };
48 
49  std::ostream& operator<<( std::ostream& os, const VType& vt );
50 
51  // -------------------------------------------------------------------------
52  std::string type2str( VType t ) noexcept;
53  VType str2type( const std::string& s ) noexcept;
54  int wsize( VType t ) noexcept;
55  // -------------------------------------------------------------------------
56  class F2
57  {
58  public:
59 
60  // ------------------------------------------
61  static const size_t f2Size = 2;
63  typedef union
64  {
65  uint16_t v[f2Size];
66  float val; //
67  } F2mem;
68  // ------------------------------------------
69  // конструкторы на разные случаи...
70  F2() noexcept
71  {
72  memset(raw.v, 0, sizeof(raw.v));
73  }
74 
75  F2( const float& f ) noexcept
76  {
77  raw.val = f;
78  }
79  F2( const ModbusRTU::ModbusData* data, size_t size ) noexcept
80  {
81  for( size_t i = 0; i < wsize() && i < size; i++ )
82  raw.v[i] = data[i];
83  }
84 
85  ~F2() noexcept {}
86  // ------------------------------------------
88  static size_t wsize()
89  {
90  return f2Size;
91  }
93  static VType type()
94  {
95  return vtF2;
96  }
97  // ------------------------------------------
98  operator float()
99  {
100  return raw.val;
101  }
102  operator long()
103  {
104  return lroundf(raw.val);
105  }
106  operator int()
107  {
108  return lroundf(raw.val);
109  }
110 
111  F2mem raw;
112  };
113  // --------------------------------------------------------------------------
114  class F2r:
115  public F2
116  {
117  public:
118 
119  // ------------------------------------------
120  // конструкторы на разные случаи...
121  F2r() noexcept
122  {
123  raw_backorder.val = 0;
124  }
125 
126  F2r( const float& f ) noexcept: F2(f)
127  {
128  raw_backorder = raw;
129  std::swap(raw_backorder.v[0], raw_backorder.v[1]);
130  }
131  F2r( const ModbusRTU::ModbusData* data, size_t size ) noexcept: F2(data, size)
132  {
133  // принимаем в обратном порядке.. поэтому переворачиваем raw
134  raw_backorder = raw;
135  std::swap(raw.v[0], raw.v[1]);
136  }
137 
138  ~F2r() noexcept {}
139 
140  F2mem raw_backorder;
141  };
142  // --------------------------------------------------------------------------
143  class F4
144  {
145  public:
146  // ------------------------------------------
147  static const size_t f4Size = 4;
149  typedef union
150  {
151  uint16_t v[f4Size];
152  float val; //
153  } F4mem;
154  // ------------------------------------------
155  // конструкторы на разные случаи...
156  F4() noexcept
157  {
158  memset(raw.v, 0, sizeof(raw.v));
159  }
160 
161  F4( const float& f ) noexcept
162  {
163  raw.val = f;
164  }
165  F4( const ModbusRTU::ModbusData* data, size_t size ) noexcept
166  {
167  for( size_t i = 0; i < wsize() && i < size; i++ )
168  raw.v[i] = data[i];
169  }
170 
171  ~F4() noexcept {}
172  // ------------------------------------------
174  static size_t wsize()
175  {
176  return f4Size;
177  }
179  static VType type()
180  {
181  return vtF4;
182  }
183  // ------------------------------------------
184  operator float()
185  {
186  return raw.val;
187  }
188  operator long()
189  {
190  return lroundf(raw.val);
191  }
192 
193  F4mem raw;
194  };
195  // --------------------------------------------------------------------------
196  class Byte
197  {
198  public:
199 
200  static const size_t bsize = 2;
201 
202  // ------------------------------------------
204  typedef union
205  {
206  uint16_t w;
207  uint8_t b[bsize];
208  } Bytemem;
209  // ------------------------------------------
210  // конструкторы на разные случаи...
211  Byte() noexcept
212  {
213  raw.w = 0;
214  }
215 
216  Byte( uint8_t b1, uint8_t b2 ) noexcept
217  {
218  raw.b[0] = b1;
219  raw.b[1] = b2;
220  }
221 
222  Byte( const ModbusRTU::ModbusData dat ) noexcept
223  {
224  raw.w = dat;
225  }
226 
227  ~Byte() noexcept {}
228  // ------------------------------------------
230  static size_t wsize()
231  {
232  return 1;
233  }
235  static VType type()
236  {
237  return vtByte;
238  }
239  // ------------------------------------------
240  operator uint16_t()
241  {
242  return raw.w;
243  }
244 
245  uint8_t operator[]( const size_t i )
246  {
247  return raw.b[i];
248  }
249 
250  Bytemem raw;
251  };
252  // --------------------------------------------------------------------------
253  class Unsigned
254  {
255  public:
256 
257  // ------------------------------------------
258  // конструкторы на разные случаи...
259  Unsigned() noexcept: raw(0) {}
260 
261  Unsigned( const long& val ) noexcept
262  {
263  raw = val;
264  }
265 
266  Unsigned( const ModbusRTU::ModbusData dat ) noexcept
267  {
268  raw = dat;
269  }
270 
271  ~Unsigned() noexcept {}
272  // ------------------------------------------
274  static size_t wsize()
275  {
276  return 1;
277  }
279  static VType type()
280  {
281  return vtUnsigned;
282  }
283  // ------------------------------------------
284  operator long()
285  {
286  return raw;
287  }
288 
289  uint16_t raw;
290  };
291  // --------------------------------------------------------------------------
292  class Signed
293  {
294  public:
295 
296  // ------------------------------------------
297  // конструкторы на разные случаи...
298  Signed() noexcept: raw(0) {}
299 
300  Signed( const long& val ) noexcept
301  {
302  raw = val;
303  }
304 
305  Signed( const ModbusRTU::ModbusData dat ) noexcept
306  {
307  raw = dat;
308  }
309 
310  ~Signed() noexcept {}
311  // ------------------------------------------
313  static size_t wsize()
314  {
315  return 1;
316  }
318  static VType type()
319  {
320  return vtSigned;
321  }
322  // ------------------------------------------
323  operator long()
324  {
325  return raw;
326  }
327 
328  int16_t raw;
329  };
330  // --------------------------------------------------------------------------
331  class I2
332  {
333  public:
334 
335  // ------------------------------------------
336  static const size_t i2Size = 2;
338  typedef union
339  {
340  uint16_t v[i2Size];
341  int32_t val; //
342  } I2mem;
343  // ------------------------------------------
344  // конструкторы на разные случаи...
345  I2() noexcept
346  {
347  memset(raw.v, 0, sizeof(raw.v));
348  }
349 
350  I2( int32_t v ) noexcept
351  {
352  raw.val = v;
353  }
354  I2( const ModbusRTU::ModbusData* data, size_t size ) noexcept
355  {
356  for( size_t i = 0; i < wsize() && i < size; i++ )
357  raw.v[i] = data[i];
358  }
359 
360  ~I2() noexcept {}
361  // ------------------------------------------
363  static size_t wsize()
364  {
365  return i2Size;
366  }
368  static VType type()
369  {
370  return vtI2;
371  }
372  // ------------------------------------------
373  operator int32_t()
374  {
375  return raw.val;
376  }
377 
378  I2mem raw;
379  };
380  // --------------------------------------------------------------------------
381  class I2r:
382  public I2
383  {
384  public:
385  I2r() noexcept
386  {
387  raw_backorder.val = 0;
388  }
389 
390  I2r( const int32_t v ) noexcept: I2(v)
391  {
392  raw_backorder = raw;
393  std::swap(raw_backorder.v[0], raw_backorder.v[1]);
394  }
395 
396  I2r( const ModbusRTU::ModbusData* data, size_t size ) noexcept: I2(data, size)
397  {
398  // принимаем в обратном порядке.. поэтому переворачиваем raw
399  raw_backorder = raw;
400  std::swap(raw.v[0], raw.v[1]);
401  }
402 
403  ~I2r() noexcept {}
404 
405  I2mem raw_backorder;
406  };
407  // --------------------------------------------------------------------------
408  class U2
409  {
410  public:
411 
412  // ------------------------------------------
413  static const size_t u2Size = 2;
415  typedef union
416  {
417  uint16_t v[u2Size];
418  uint32_t val; //
419  } U2mem;
420  // ------------------------------------------
421  // конструкторы на разные случаи...
422  U2() noexcept
423  {
424  memset(raw.v, 0, sizeof(raw.v));
425  }
426 
427  U2( uint32_t v ) noexcept
428  {
429  raw.val = v;
430  }
431  U2( const ModbusRTU::ModbusData* data, size_t size ) noexcept
432  {
433  for( size_t i = 0; i < wsize() && i < size; i++ )
434  raw.v[i] = data[i];
435  }
436 
437  ~U2() noexcept {}
438  // ------------------------------------------
440  static size_t wsize()
441  {
442  return u2Size;
443  }
445  static VType type()
446  {
447  return vtU2;
448  }
449  // ------------------------------------------
450  operator uint32_t()
451  {
452  return raw.val;
453  }
454 
455  operator long()
456  {
457  return raw.val;
458  }
459 
460  operator unsigned long()
461  {
462  return (uint32_t)raw.val;
463  }
464 
465  U2mem raw;
466  };
467  // --------------------------------------------------------------------------
468  class U2r:
469  public U2
470  {
471  public:
472  U2r() noexcept
473  {
474  raw_backorder.val = 0;
475  }
476 
477  U2r( int32_t v ) noexcept: U2(v)
478  {
479  raw_backorder = raw;
480  std::swap(raw_backorder.v[0], raw_backorder.v[1]);
481  }
482 
483  U2r( const ModbusRTU::ModbusData* data, size_t size ) noexcept: U2(data, size)
484  {
485  // принимаем в обратном порядке.. поэтому переворачиваем raw
486  raw_backorder = raw;
487  std::swap(raw.v[0], raw.v[1]);
488  }
489 
490  ~U2r() {}
491 
492  U2mem raw_backorder;
493  };
494  // --------------------------------------------------------------------------
495 
496  } // end of namespace VTypes
497  // --------------------------------------------------------------------------
498 } // end of namespace uniset
499 // --------------------------------------------------------------------------
500 #endif // _RTUTypes_H_
501 // -----------------------------------------------------------------------------
Definition: VTypes.h:143
Definition: VTypes.h:196
Definition: CallbackTimer.h:29
static VType type()
Definition: VTypes.h:179
static size_t wsize()
Definition: VTypes.h:274
static VType type()
Definition: VTypes.h:318
static VType type()
Definition: VTypes.h:235
static size_t wsize()
Definition: VTypes.h:313
Definition: VTypes.h:338
Definition: VTypes.h:468
static size_t wsize()
Definition: VTypes.h:230
Definition: VTypes.h:204
Definition: VTypes.h:114
Definition: VTypes.h:381
static VType type()
Definition: VTypes.h:445
static size_t wsize()
Definition: VTypes.h:363
Definition: VTypes.h:149
Definition: VTypes.h:253
static VType type()
Definition: VTypes.h:279
Definition: VTypes.h:408
static size_t wsize()
Definition: VTypes.h:88
static VType type()
Definition: VTypes.h:93
Definition: VTypes.h:292
static size_t wsize()
Definition: VTypes.h:440
Definition: VTypes.h:331
Definition: VTypes.h:415
static VType type()
Definition: VTypes.h:368
Definition: VTypes.h:63
static size_t wsize()
Definition: VTypes.h:174
Definition: VTypes.h:56