UniSet  2.8.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  double val; //
153  } F4mem;
154  // ------------------------------------------
155  // конструкторы на разные случаи...
156  F4() noexcept
157  {
158  memset(raw.v, 0, sizeof(raw.v));
159  }
160 
161  F4( const double& f ) noexcept
162  {
163  memset(raw.v, 0, sizeof(raw.v));
164  raw.val = f;
165  }
166  F4( const ModbusRTU::ModbusData* data, size_t size ) noexcept
167  {
168  for( size_t i = 0; i < wsize() && i < size; i++ )
169  raw.v[i] = data[i];
170  }
171 
172  ~F4() noexcept {}
173  // ------------------------------------------
175  static size_t wsize()
176  {
177  return f4Size;
178  }
180  static VType type()
181  {
182  return vtF4;
183  }
184  // ------------------------------------------
185  operator double()
186  {
187  return raw.val;
188  }
189  operator long()
190  {
191  return lroundf(raw.val);
192  }
193 
194  F4mem raw;
195  };
196  // --------------------------------------------------------------------------
197  class Byte
198  {
199  public:
200 
201  static const size_t bsize = 2;
202 
203  // ------------------------------------------
205  typedef union
206  {
207  uint16_t w;
208  uint8_t b[bsize];
209  } Bytemem;
210  // ------------------------------------------
211  // конструкторы на разные случаи...
212  Byte() noexcept
213  {
214  raw.w = 0;
215  }
216 
217  Byte( uint8_t b1, uint8_t b2 ) noexcept
218  {
219  raw.b[0] = b1;
220  raw.b[1] = b2;
221  }
222 
223  Byte( const ModbusRTU::ModbusData dat ) noexcept
224  {
225  raw.w = dat;
226  }
227 
228  ~Byte() noexcept {}
229  // ------------------------------------------
231  static size_t wsize()
232  {
233  return 1;
234  }
236  static VType type()
237  {
238  return vtByte;
239  }
240  // ------------------------------------------
241  operator uint16_t()
242  {
243  return raw.w;
244  }
245 
246  uint8_t operator[]( const size_t i )
247  {
248  return raw.b[i];
249  }
250 
251  Bytemem raw;
252  };
253  // --------------------------------------------------------------------------
254  class Unsigned
255  {
256  public:
257 
258  // ------------------------------------------
259  // конструкторы на разные случаи...
260  Unsigned() noexcept: raw(0) {}
261 
262  Unsigned( const long& val ) noexcept
263  {
264  raw = val;
265  }
266 
267  Unsigned( const ModbusRTU::ModbusData dat ) noexcept
268  {
269  raw = dat;
270  }
271 
272  ~Unsigned() noexcept {}
273  // ------------------------------------------
275  static size_t wsize()
276  {
277  return 1;
278  }
280  static VType type()
281  {
282  return vtUnsigned;
283  }
284  // ------------------------------------------
285  operator long()
286  {
287  return raw;
288  }
289 
290  uint16_t raw;
291  };
292  // --------------------------------------------------------------------------
293  class Signed
294  {
295  public:
296 
297  // ------------------------------------------
298  // конструкторы на разные случаи...
299  Signed() noexcept: raw(0) {}
300 
301  Signed( const long& val ) noexcept
302  {
303  raw = val;
304  }
305 
306  Signed( const ModbusRTU::ModbusData dat ) noexcept
307  {
308  raw = dat;
309  }
310 
311  ~Signed() noexcept {}
312  // ------------------------------------------
314  static size_t wsize()
315  {
316  return 1;
317  }
319  static VType type()
320  {
321  return vtSigned;
322  }
323  // ------------------------------------------
324  operator long()
325  {
326  return raw;
327  }
328 
329  int16_t raw;
330  };
331  // --------------------------------------------------------------------------
332  class I2
333  {
334  public:
335 
336  // ------------------------------------------
337  static const size_t i2Size = 2;
339  typedef union
340  {
341  uint16_t v[i2Size];
342  int32_t val; //
343  } I2mem;
344  // ------------------------------------------
345  // конструкторы на разные случаи...
346  I2() noexcept
347  {
348  memset(raw.v, 0, sizeof(raw.v));
349  }
350 
351  I2( int32_t v ) noexcept
352  {
353  raw.val = v;
354  }
355  I2( const ModbusRTU::ModbusData* data, size_t size ) noexcept
356  {
357  for( size_t i = 0; i < wsize() && i < size; i++ )
358  raw.v[i] = data[i];
359  }
360 
361  ~I2() noexcept {}
362  // ------------------------------------------
364  static size_t wsize()
365  {
366  return i2Size;
367  }
369  static VType type()
370  {
371  return vtI2;
372  }
373  // ------------------------------------------
374  operator int32_t()
375  {
376  return raw.val;
377  }
378 
379  I2mem raw;
380  };
381  // --------------------------------------------------------------------------
382  class I2r:
383  public I2
384  {
385  public:
386  I2r() noexcept
387  {
388  raw_backorder.val = 0;
389  }
390 
391  I2r( const int32_t v ) noexcept: I2(v)
392  {
393  raw_backorder = raw;
394  std::swap(raw_backorder.v[0], raw_backorder.v[1]);
395  }
396 
397  I2r( const ModbusRTU::ModbusData* data, size_t size ) noexcept: I2(data, size)
398  {
399  // принимаем в обратном порядке.. поэтому переворачиваем raw
400  raw_backorder = raw;
401  std::swap(raw.v[0], raw.v[1]);
402  }
403 
404  ~I2r() noexcept {}
405 
406  I2mem raw_backorder;
407  };
408  // --------------------------------------------------------------------------
409  class U2
410  {
411  public:
412 
413  // ------------------------------------------
414  static const size_t u2Size = 2;
416  typedef union
417  {
418  uint16_t v[u2Size];
419  uint32_t val; //
420  } U2mem;
421  // ------------------------------------------
422  // конструкторы на разные случаи...
423  U2() noexcept
424  {
425  memset(raw.v, 0, sizeof(raw.v));
426  }
427 
428  U2( uint32_t v ) noexcept
429  {
430  raw.val = v;
431  }
432  U2( const ModbusRTU::ModbusData* data, size_t size ) noexcept
433  {
434  for( size_t i = 0; i < wsize() && i < size; i++ )
435  raw.v[i] = data[i];
436  }
437 
438  ~U2() noexcept {}
439  // ------------------------------------------
441  static size_t wsize()
442  {
443  return u2Size;
444  }
446  static VType type()
447  {
448  return vtU2;
449  }
450  // ------------------------------------------
451  operator uint32_t()
452  {
453  return raw.val;
454  }
455 
456  operator long()
457  {
458  return raw.val;
459  }
460 
461  operator unsigned long()
462  {
463  return (uint32_t)raw.val;
464  }
465 
466  U2mem raw;
467  };
468  // --------------------------------------------------------------------------
469  class U2r:
470  public U2
471  {
472  public:
473  U2r() noexcept
474  {
475  raw_backorder.val = 0;
476  }
477 
478  U2r( int32_t v ) noexcept: U2(v)
479  {
480  raw_backorder = raw;
481  std::swap(raw_backorder.v[0], raw_backorder.v[1]);
482  }
483 
484  U2r( const ModbusRTU::ModbusData* data, size_t size ) noexcept: U2(data, size)
485  {
486  // принимаем в обратном порядке.. поэтому переворачиваем raw
487  raw_backorder = raw;
488  std::swap(raw.v[0], raw.v[1]);
489  }
490 
491  ~U2r() {}
492 
493  U2mem raw_backorder;
494  };
495  // --------------------------------------------------------------------------
496 
497  } // end of namespace VTypes
498  // --------------------------------------------------------------------------
499 } // end of namespace uniset
500 // --------------------------------------------------------------------------
501 #endif // _RTUTypes_H_
502 // -----------------------------------------------------------------------------
Definition: VTypes.h:143
Definition: VTypes.h:197
Definition: CommonEventLoop.h:14
static VType type()
Definition: VTypes.h:180
static size_t wsize()
Definition: VTypes.h:275
static VType type()
Definition: VTypes.h:319
static VType type()
Definition: VTypes.h:236
static size_t wsize()
Definition: VTypes.h:314
Definition: VTypes.h:339
Definition: VTypes.h:469
static size_t wsize()
Definition: VTypes.h:231
Definition: VTypes.h:205
Definition: VTypes.h:114
Definition: VTypes.h:382
static VType type()
Definition: VTypes.h:446
static size_t wsize()
Definition: VTypes.h:364
Definition: VTypes.h:149
Definition: VTypes.h:254
static VType type()
Definition: VTypes.h:280
Definition: VTypes.h:409
static size_t wsize()
Definition: VTypes.h:88
static VType type()
Definition: VTypes.h:93
Definition: VTypes.h:293
static size_t wsize()
Definition: VTypes.h:441
Definition: VTypes.h:332
Definition: VTypes.h:416
static VType type()
Definition: VTypes.h:369
Definition: VTypes.h:63
static size_t wsize()
Definition: VTypes.h:175
Definition: VTypes.h:56