UniSet  1.4.0
VTypes.h
00001 // --------------------------------------------------------------------------
00002 // --------------------------------------------------------------------------
00003 #ifndef _RTUTypes_H_
00004 #define _RTUTypes_H_
00005 // -----------------------------------------------------------------------------
00006 #include <string>
00007 #include <cmath>
00008 #include <cstring>
00009 #include <ostream>
00010 #include "modbus/ModbusTypes.h"
00011 // -----------------------------------------------------------------------------
00012 namespace VTypes
00013 {
00015         enum VType
00016         {
00017             vtUnknown,
00018             vtF2,       
00019             vtF4,       
00020             vtByte,     
00021             vtUnsigned, 
00022             vtSigned,   
00023             vtI2,       
00024             vtU2        
00025         };
00026 
00027         std::ostream& operator<<( std::ostream& os, const VType& vt );
00028 
00029         // -------------------------------------------------------------------------
00030         std::string type2str( VType t );    
00031         VType str2type( const std::string s );  
00032         int wsize( VType t );           
00033     // -------------------------------------------------------------------------
00034     class F2
00035     {
00036         public:
00037         
00038             // ------------------------------------------
00039             static const int f2Size=2;
00041             typedef union
00042             {
00043                 unsigned short v[f2Size];
00044                 float val; // 
00045             } F2mem;
00046             // ------------------------------------------
00047             // конструкторы на разные случаи...
00048             F2(){ memset(raw.v,0,sizeof(raw.v)); }
00049             
00050             F2( float f ){ raw.val = f; }
00051             F2( const ModbusRTU::ModbusData* data, int size )
00052             {
00053                 for( int i=0; i<wsize() && i<size; i++ )
00054                     raw.v[i] = data[i];
00055             }
00056 
00057             ~F2(){}
00058             // ------------------------------------------
00060             static int wsize(){ return f2Size; }
00062             static VType type(){ return vtF2; }
00063             // ------------------------------------------
00064             operator float(){ return raw.val; }
00065             operator long(){ return lroundf(raw.val); }
00066             
00067             F2mem raw;
00068     };
00069     // --------------------------------------------------------------------------
00070     class F4
00071     {
00072         public:
00073             // ------------------------------------------
00074             static const int f4Size=4;
00076             typedef union
00077             {
00078                 unsigned short v[f4Size];
00079                 float val; // 
00080             } F4mem;
00081             // ------------------------------------------
00082             // конструкторы на разные случаи...
00083             F4(){ memset(raw.v,0,sizeof(raw.v)); }
00084             
00085             F4( float f ){ raw.val = f; }
00086             F4( const ModbusRTU::ModbusData* data, int size )
00087             {
00088                 for( int i=0; i<wsize() && i<size; i++ )
00089                     raw.v[i] = data[i];
00090             }
00091 
00092             ~F4(){}
00093             // ------------------------------------------
00095             static int wsize(){ return f4Size; }
00097             static VType type(){ return vtF4; }
00098             // ------------------------------------------
00099             operator float(){ return raw.val; }
00100             operator long(){ return lroundf(raw.val); }
00101             
00102             F4mem raw;
00103     };
00104     // --------------------------------------------------------------------------
00105     class Byte
00106     {
00107         public:
00108         
00109             static const int bsize = 2;
00110         
00111             // ------------------------------------------
00113             typedef union
00114             {
00115                 unsigned short w;
00116                 unsigned char b[bsize];
00117             } Bytemem;
00118             // ------------------------------------------
00119             // конструкторы на разные случаи...
00120             Byte(){ raw.w = 0; }
00121             
00122             Byte( unsigned char b1, unsigned char b2 ){ raw.b[0]=b1; raw.b[1]=b2; }
00123             Byte( const long val )
00124             {
00125                 raw.w = val;
00126             }
00127             
00128             Byte( const ModbusRTU::ModbusData dat )
00129             {
00130                     raw.w = dat;
00131             }
00132 
00133             ~Byte(){}
00134             // ------------------------------------------
00136             static int wsize(){ return 1; }
00138             static VType type(){ return vtByte; }
00139             // ------------------------------------------
00140             operator long(){ return lroundf(raw.w); }
00141 
00142             unsigned char operator[]( const int i ){ return raw.b[i]; }
00143 
00144             Bytemem raw;
00145     };
00146     // --------------------------------------------------------------------------
00147     class Unsigned
00148     {
00149         public:
00150 
00151             // ------------------------------------------
00152             // конструкторы на разные случаи...
00153             Unsigned():raw(0){}
00154             
00155             Unsigned( const long val )
00156             {
00157                 raw = val;
00158             }
00159             
00160             Unsigned( const ModbusRTU::ModbusData dat )
00161             {
00162                 raw = dat;
00163             }
00164 
00165             ~Unsigned(){}
00166             // ------------------------------------------
00168             static int wsize(){ return sizeof(unsigned short); }
00170             static VType type(){ return vtUnsigned; }
00171             // ------------------------------------------
00172             operator long(){ return raw; }
00173 
00174             unsigned short raw;
00175     };
00176     // --------------------------------------------------------------------------
00177     class Signed
00178     {
00179         public:
00180 
00181             // ------------------------------------------
00182             // конструкторы на разные случаи...
00183             Signed():raw(0){}
00184             
00185             Signed( const long val )
00186             {
00187                 raw = val;
00188             }
00189             
00190             Signed( const ModbusRTU::ModbusData dat )
00191             {
00192                 raw = dat;
00193             }
00194 
00195             ~Signed(){}
00196             // ------------------------------------------
00198             static int wsize(){ return sizeof(signed short); }
00200             static VType type(){ return vtSigned; }
00201             // ------------------------------------------
00202             operator long(){ return raw; }
00203 
00204             signed short raw;
00205     };
00206     // --------------------------------------------------------------------------
00207     class I2
00208     {
00209         public:
00210         
00211             // ------------------------------------------
00212             static const int i2Size=2;
00214             typedef union
00215             {
00216                 unsigned short v[i2Size];
00217                 int val; // 
00218             } I2mem;
00219             // ------------------------------------------
00220             // конструкторы на разные случаи...
00221             I2(){ memset(raw.v,0,sizeof(raw.v)); }
00222             
00223             I2( int v ){ raw.val = v; }
00224             I2( const ModbusRTU::ModbusData* data, int size )
00225             {
00226                 for( int i=0; i<wsize() && i<size; i++ )
00227                     raw.v[i] = data[i];
00228             }
00229 
00230             ~I2(){}
00231             // ------------------------------------------
00233             static int wsize(){ return i2Size; }
00235             static VType type(){ return vtI2; }
00236             // ------------------------------------------
00237             operator int(){ return raw.val; }
00238             
00239             I2mem raw;
00240     };
00241     // --------------------------------------------------------------------------
00242     class U2
00243     {
00244         public:
00245         
00246             // ------------------------------------------
00247             static const int u2Size=2;
00249             typedef union
00250             {
00251                 unsigned short v[u2Size];
00252                 unsigned int val; // 
00253             } U2mem;
00254             // ------------------------------------------
00255             // конструкторы на разные случаи...
00256             U2(){ memset(raw.v,0,sizeof(raw.v)); }
00257             
00258             U2( unsigned int v ){ raw.val = v; }
00259             U2( const ModbusRTU::ModbusData* data, int size )
00260             {
00261                 for( int i=0; i<wsize() && i<size; i++ )
00262                     raw.v[i] = data[i];
00263             }
00264 
00265             ~U2(){}
00266             // ------------------------------------------
00268             static int wsize(){ return u2Size; }
00270             static VType type(){ return vtU2; }
00271             // ------------------------------------------
00272             operator unsigned int(){ return raw.val; }
00273             
00274             U2mem raw;
00275     };
00276     // --------------------------------------------------------------------------
00277 
00278 } // end of namespace VTypes
00279 // --------------------------------------------------------------------------
00280 #endif // _RTUTypes_H_
00281 // -----------------------------------------------------------------------------