UniSet
1.4.0
|
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 // -----------------------------------------------------------------------------