UniSet
1.4.0
|
00001 // -------------------------------------------------------------------------- 00002 // -------------------------------------------------------------------------- 00003 #ifndef _MTR_H_ 00004 #define _MTR_H_ 00005 // ----------------------------------------------------------------------------- 00006 #include <string> 00007 #include <map> 00008 #include <list> 00009 #include <ostream> 00010 #include <cstring> 00011 #include <cmath> 00012 #include "modbus/ModbusTypes.h" 00013 #include "ComPort.h" 00014 // ----------------------------------------------------------------------------- 00015 class ModbusRTUMaster; 00016 // ----------------------------------------------------------------------------- 00017 namespace MTR 00018 { 00019 // реализованные в данном интерфейсе типы данных 00020 enum MTRType 00021 { 00022 mtUnknown, 00023 mtT1, 00024 mtT2, 00025 mtT3, 00026 mtT4, 00027 mtT5, 00028 mtT6, 00029 mtT7, 00030 mtT8, 00031 mtT9, 00032 mtT10, 00033 mtT16, 00034 mtT17, 00035 mtF1, 00036 mtT_Str16, 00037 mtT_Str8 00038 }; 00039 // ------------------------------------------------------------------------- 00040 std::string type2str( MTRType t ); 00041 MTRType str2type( const std::string s ); 00042 int wsize( MTRType t ); 00043 // ------------------------------------------------------------------------- 00044 // Информация 00045 const ModbusRTU::ModbusData regModelNumber = 0x01; 00046 const ModbusRTU::ModbusData regSerialNumber = 0x09; 00047 00048 std::string getModelNumber( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr ); 00049 std::string getSerialNumber( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr ); 00050 // ------------------------------------------------------------------------- 00051 // Настройки связи (чтение - read03, запись - write06) 00052 const ModbusRTU::ModbusData regAddress = 55; 00053 const ModbusRTU::ModbusData regBaudRate = 56; 00054 const ModbusRTU::ModbusData regStopBit = 57; /* 0 - Stop bit, 1 - Stop bits */ 00055 const ModbusRTU::ModbusData regParity = 58; 00056 const ModbusRTU::ModbusData regDataBits = 59; 00057 00058 enum mtrBaudRate 00059 { 00060 br1200 = 0, 00061 br2400 = 1, 00062 br4800 = 2, 00063 br9600 = 3, 00064 br19200 = 4, 00065 br38400 = 5, 00066 br57600 = 6, 00067 br115200 = 7 00068 }; 00069 00070 enum mtrParity 00071 { 00072 mpNoParity = 0, 00073 mpOddParity = 1, 00074 mpEvenParity = 2 00075 }; 00076 00077 enum mtrDataBits 00078 { 00079 db8Bits = 0, 00080 db7Bits = 1 00081 }; 00082 00083 bool setAddress( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusAddr newAddr ); 00084 bool setBaudRate( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr, mtrBaudRate br ); 00085 bool setStopBit( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr, bool state ); 00086 bool setParity( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr, mtrParity p ); 00087 bool setDataBits( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr, mtrDataBits d ); 00088 ComPort::Parity get_parity( ModbusRTU::ModbusData data ); 00089 ComPort::Speed get_speed( ModbusRTU::ModbusData data ); 00090 // ------------------------------------------------------------------------- 00091 // Настройка из конф. файла 00092 bool update_configuration( ModbusRTUMaster* mb, ModbusRTU::ModbusAddr addr, 00093 const std::string mtrconfile, int verbose=0 ); 00094 // --------------------------- 00095 // вспомогательные функции и типы данных 00096 typedef std::list<ModbusRTU::ModbusData> DataList; 00097 typedef std::map<ModbusRTU::ModbusData,DataList> DataMap; 00098 const int attempts = 3; // 00099 static const ModbusRTU::ModbusData skip[] = {48, 49, 59}; // registers which should not write 00100 00101 00102 bool send_param( ModbusRTUMaster* mb, DataMap& dmap, ModbusRTU::ModbusAddr addr, int verb ); 00103 bool read_param( const std::string str, std::string& str1, std::string& str2 ); 00104 DataMap read_confile( const std::string f ); 00105 void update_communication_params( ModbusRTU::ModbusAddr reg, ModbusRTU::ModbusData data, 00106 ModbusRTUMaster* mb, ModbusRTU::ModbusAddr& addr, int verb ); 00107 // ------------------------------------------------------------------------- 00108 static const int u2size = 2; 00109 // ------------------------------------------------------------------------- 00110 class T1 00111 { 00112 public: 00113 T1():val(0){} 00114 T1( unsigned short v ):val(v){} 00115 T1( const ModbusRTU::ModbusData* data ):val(data[0]){} 00116 ~T1(){} 00117 // ------------------------------------------ 00119 static int wsize(){ return 1; } 00121 static MTRType type(){ return mtT1; } 00122 // ------------------------------------------ 00123 unsigned short val; 00124 }; 00125 std::ostream& operator<<(std::ostream& os, T1& t ); 00126 // ------------------------------------------------------------------------- 00127 class T2 00128 { 00129 public: 00130 T2():val(0){} 00131 T2( signed short v ):val(v){} 00132 T2( const ModbusRTU::ModbusData* data ):val(data[0]){} 00133 ~T2(){} 00134 // ------------------------------------------ 00136 static int wsize(){ return 1; } 00138 static MTRType type(){ return mtT2; } 00139 // ------------------------------------------ 00140 signed short val; 00141 }; 00142 std::ostream& operator<<(std::ostream& os, T2& t ); 00143 // ------------------------------------------------------------------------- 00144 class T3 00145 { 00146 public: 00147 // ------------------------------------------ 00149 typedef union 00150 { 00151 unsigned short v[u2size]; 00152 signed int val; // :32 00153 } T3mem; 00154 // ------------------------------------------ 00155 // конструкторы на разные случаи... 00156 T3(){ memset(raw.v,0,sizeof(raw.v)); } 00157 00158 T3( signed int i ){ raw.val = i; } 00159 00160 T3( unsigned short v1, unsigned short v2 ) 00161 { 00162 raw.v[0] = v1; 00163 raw.v[1] = v2; 00164 } 00165 00166 T3( const ModbusRTU::ModbusData* data, int size ) 00167 { 00168 if( size >= u2size ) 00169 { 00170 // У MTR обратный порядок слов в ответе 00171 raw.v[0] = data[1]; 00172 raw.v[1] = data[0]; 00173 } 00174 } 00175 00176 ~T3(){} 00177 // ------------------------------------------ 00179 static int wsize(){ return u2size; } 00181 static MTRType type(){ return mtT3; } 00182 // ------------------------------------------ 00183 // функции преобразования к разным типам 00184 operator long() { return raw.val; } 00185 00186 T3mem raw; 00187 }; 00188 std::ostream& operator<<(std::ostream& os, T3& t ); 00189 // -------------------------------------------------------------------------- 00190 class T4 00191 { 00192 public: 00193 // ------------------------------------------ 00194 // конструкторы на разные случаи... 00195 T4():sval(""),raw(0){} 00196 T4( unsigned short v1 ):raw(v1) 00197 { 00198 char c[3]; 00199 memcpy(c,&v1,sizeof(c)); 00200 sval = std::string(c); 00201 } 00202 00203 T4( const ModbusRTU::ModbusData* data ): 00204 raw(data[0]) 00205 { 00206 char c[3]; 00207 memcpy(c,&(data[0]),sizeof(c)); 00208 sval = std::string(c); 00209 } 00210 00211 ~T4(){} 00212 // ------------------------------------------ 00214 static int wsize(){ return 1; } 00216 static MTRType type(){ return mtT4; } 00217 // ------------------------------------------ 00218 std::string sval; 00219 unsigned short raw; 00220 }; 00221 std::ostream& operator<<(std::ostream& os, T4& t ); 00222 // -------------------------------------------------------------------------- 00223 class T5 00224 { 00225 public: 00226 // ------------------------------------------ 00228 typedef union 00229 { 00230 unsigned short v[u2size]; 00231 struct u_T5 00232 { 00233 unsigned int val:24; 00234 signed char exp; // :8 00235 } __attribute__( ( packed ) ) u2; 00236 long lval; 00237 } T5mem; 00238 // ------------------------------------------ 00239 // конструкторы на разные случаи... 00240 T5():val(0){ memset(raw.v,0,sizeof(raw.v)); } 00241 T5( unsigned short v1, unsigned short v2 ) 00242 { 00243 raw.v[0] = v1; 00244 raw.v[1] = v2; 00245 val = raw.u2.val * pow(10,raw.u2.exp); 00246 } 00247 00248 T5( long v ) 00249 { 00250 raw.lval = v; 00251 } 00252 00253 T5( const ModbusRTU::ModbusData* data, int size ) 00254 { 00255 if( size >= u2size ) 00256 { 00257 // При получении данных от MTR слова необходимо перевернуть 00258 raw.v[0] = data[1]; 00259 raw.v[1] = data[0]; 00260 val = raw.u2.val * pow(10,raw.u2.exp); 00261 } 00262 } 00263 00264 ~T5(){} 00265 // ------------------------------------------ 00267 static int wsize(){ return u2size; } 00269 static MTRType type(){ return mtT5; } 00270 // ------------------------------------------ 00271 double val; 00272 T5mem raw; 00273 }; 00274 std::ostream& operator<<(std::ostream& os, T5& t ); 00275 // -------------------------------------------------------------------------- 00276 class T6 00277 { 00278 public: 00279 // ------------------------------------------ 00281 typedef union 00282 { 00283 unsigned short v[u2size]; 00284 struct u_T6 00285 { 00286 signed int val:24; 00287 signed char exp; // :8 00288 } u2; 00289 long lval; 00290 } T6mem; 00291 // ------------------------------------------ 00292 // конструкторы на разные случаи... 00293 T6():val(0){ memset(raw.v,0,sizeof(raw.v)); } 00294 T6( unsigned short v1, unsigned short v2 ) 00295 { 00296 raw.v[0] = v1; 00297 raw.v[1] = v2; 00298 val = raw.u2.val * pow(10,raw.u2.exp); 00299 } 00300 00301 T6( long v ) 00302 { 00303 raw.lval = v; 00304 } 00305 00306 T6( const ModbusRTU::ModbusData* data, int size ) 00307 { 00308 if( size >= u2size ) 00309 { 00310 // При получении данных от MTR слова необходимо перевернуть 00311 raw.v[0] = data[1]; 00312 raw.v[1] = data[0]; 00313 val = raw.u2.val * pow(10,raw.u2.exp); 00314 } 00315 } 00316 00317 ~T6(){} 00318 // ------------------------------------------ 00320 static int wsize(){ return u2size; } 00322 static MTRType type(){ return mtT6; } 00323 // ------------------------------------------ 00324 double val; 00325 T6mem raw; 00326 }; 00327 std::ostream& operator<<(std::ostream& os, T6& t ); 00328 // -------------------------------------------------------------------------- 00329 class T7 00330 { 00331 public: 00332 // ------------------------------------------ 00334 typedef union 00335 { 00336 unsigned short v[u2size]; 00337 struct u_T7 00338 { 00339 unsigned int val:16; 00340 unsigned char ic; // :8 - Inductive/capacitive 00341 unsigned char ie; // :8 - Import/export 00342 }__attribute__( ( packed ) ) u2; 00343 long lval; 00344 } T7mem; 00345 // ------------------------------------------ 00346 // конструкторы на разные случаи... 00347 T7():val(0){ memset(raw.v,0,sizeof(raw.v)); } 00348 T7( unsigned short v1, unsigned short v2 ) 00349 { 00350 raw.v[0] = v1; 00351 raw.v[1] = v2; 00352 val = raw.u2.val * pow(10,-4); 00353 } 00354 T7( const long v ) 00355 { 00356 raw.lval = v; 00357 } 00358 00359 T7( const ModbusRTU::ModbusData* data, int size ) 00360 { 00361 if( size >= u2size ) 00362 { 00363 // При получении данных от MTR слова необходимо перевернуть 00364 raw.v[0] = data[1]; 00365 raw.v[1] = data[0]; 00366 val = raw.u2.val * pow(10,-4); 00367 } 00368 } 00369 00370 ~T7(){} 00371 // ------------------------------------------ 00373 static int wsize(){ return u2size; } 00375 static MTRType type(){ return mtT7; } 00376 // ------------------------------------------ 00377 double val; 00378 T7mem raw; 00379 }; 00380 std::ostream& operator<<(std::ostream& os, T7& t ); 00381 // -------------------------------------------------------------------------- 00382 class T8 00383 { 00384 public: 00385 // ------------------------------------------ 00387 typedef union 00388 { 00389 unsigned short v[u2size]; 00390 struct u_T8 00391 { 00392 unsigned short mon:8; 00393 unsigned short day:8; 00394 unsigned short hour:8; 00395 unsigned short min:8; 00396 }__attribute__( ( packed ) ) u2; 00397 } T8mem; 00398 // ------------------------------------------ 00399 // конструкторы на разные случаи... 00400 T8(){ memset(raw.v,0,sizeof(raw.v)); } 00401 T8( unsigned short v1, unsigned short v2 ) 00402 { 00403 raw.v[0] = v1; 00404 raw.v[1] = v2; 00405 } 00406 00407 T8( const ModbusRTU::ModbusData* data, int size ) 00408 { 00409 if( size >= u2size ) 00410 { 00411 // При получении данных от MTR слова необходимо перевернуть 00412 raw.v[1] = data[0]; 00413 raw.v[0] = data[1]; 00414 } 00415 } 00416 00417 inline unsigned short day(){ return raw.u2.day; } 00418 inline unsigned short mon(){ return raw.u2.mon; } 00419 inline unsigned short hour(){ return raw.u2.hour; } 00420 inline unsigned short min(){ return raw.u2.min; } 00421 00422 ~T8(){} 00423 // ------------------------------------------ 00425 static int wsize(){ return u2size; } 00427 static MTRType type(){ return mtT8; } 00428 // ------------------------------------------ 00429 T8mem raw; 00430 }; 00431 std::ostream& operator<<(std::ostream& os, T8& t ); 00432 // -------------------------------------------------------------------------- 00433 class T9 00434 { 00435 public: 00436 // ------------------------------------------ 00438 typedef union 00439 { 00440 unsigned short v[u2size]; 00441 struct u_T9 00442 { 00443 unsigned short hour:8; 00444 unsigned short min:8; 00445 unsigned short sec:8; 00446 unsigned short ssec:8; 00447 }__attribute__( ( packed ) ) u2; 00448 } T9mem; 00449 // ------------------------------------------ 00450 // конструкторы на разные случаи... 00451 T9(){ memset(raw.v,0,sizeof(raw.v)); } 00452 T9( unsigned short v1, unsigned short v2 ) 00453 { 00454 raw.v[0] = v1; 00455 raw.v[1] = v2; 00456 } 00457 00458 T9( const ModbusRTU::ModbusData* data, int size ) 00459 { 00460 if( size >= u2size ) 00461 { 00462 // При получении данных от MTR слова необходимо перевернуть 00463 raw.v[0] = data[1]; 00464 raw.v[1] = data[0]; 00465 } 00466 } 00467 00468 inline unsigned short hour(){ return raw.u2.hour; } 00469 inline unsigned short min(){ return raw.u2.min; } 00470 inline unsigned short sec(){ return raw.u2.sec; } 00471 inline unsigned short ssec(){ return raw.u2.ssec; } 00472 00473 ~T9(){} 00474 // ------------------------------------------ 00476 static int wsize(){ return u2size; } 00478 static MTRType type(){ return mtT9; } 00479 // ------------------------------------------ 00480 T9mem raw; 00481 }; 00482 std::ostream& operator<<(std::ostream& os, T9& t ); 00483 // ------------------------------------------------------------------------- 00484 class T10 00485 { 00486 public: 00487 // ------------------------------------------ 00489 typedef union 00490 { 00491 unsigned short v[u2size]; 00492 struct u_T10 00493 { 00494 unsigned short year:16; 00495 unsigned short mon:8; 00496 unsigned short day:8; 00497 }__attribute__( ( packed ) ) u2; 00498 } T10mem; 00499 // ------------------------------------------ 00500 // конструкторы на разные случаи... 00501 T10(){ memset(raw.v,0,sizeof(raw.v)); } 00502 T10( unsigned short v1, unsigned short v2 ) 00503 { 00504 raw.v[0] = v1; 00505 raw.v[1] = v2; 00506 } 00507 00508 T10( const ModbusRTU::ModbusData* data, int size ) 00509 { 00510 if( size >= u2size ) 00511 { 00512 // При получении данных от MTR слова необходимо перевернуть 00513 raw.v[0] = data[1]; 00514 raw.v[1] = data[0]; 00515 } 00516 } 00517 00518 inline unsigned short year(){ return raw.u2.year; } 00519 inline unsigned short mon(){ return raw.u2.mon; } 00520 inline unsigned short day(){ return raw.u2.day; } 00521 00522 ~T10(){} 00523 // ------------------------------------------ 00525 static int wsize(){ return u2size; } 00527 static MTRType type(){ return mtT10; } 00528 // ------------------------------------------ 00529 T10mem raw; 00530 }; 00531 std::ostream& operator<<(std::ostream& os, T10& t ); 00532 // -------------------------------------------------------------------------- 00533 00534 class T16 00535 { 00536 public: 00537 T16():val(0){} 00538 T16( unsigned short v ):val(v) 00539 { 00540 fval = (float)(val)/100.0; 00541 } 00542 T16( const ModbusRTU::ModbusData* data ):val(data[0]) 00543 { 00544 fval = (float)(val)/100.0; 00545 } 00546 T16( float f ):fval(f) 00547 { 00548 val = lroundf(fval*100); 00549 } 00550 00551 ~T16(){} 00552 // ------------------------------------------ 00554 static int wsize(){ return 1; } 00556 static MTRType type(){ return mtT16; } 00557 // ------------------------------------------ 00558 operator float(){ return fval; } 00559 operator unsigned short(){ return val; } 00560 00561 unsigned short val; 00562 float fval; 00563 }; 00564 std::ostream& operator<<(std::ostream& os, T16& t ); 00565 // -------------------------------------------------------------------------- 00566 class T17 00567 { 00568 public: 00569 T17():val(0){} 00570 T17( signed short v ):val(v) 00571 { 00572 fval = (float)(v)/100.0; 00573 } 00574 T17( unsigned short v ):val(v) 00575 { 00576 fval = (float)( (signed short)(v) )/100.0; 00577 } 00578 00579 T17( const ModbusRTU::ModbusData* data ):val(data[0]) 00580 { 00581 fval = (float)(val)/100.0; 00582 } 00583 T17( float f ):fval(f) 00584 { 00585 val = lroundf(fval*100); 00586 } 00587 ~T17(){} 00588 // ------------------------------------------ 00590 static int wsize(){ return 1; } 00592 static MTRType type(){ return mtT17; } 00593 // ------------------------------------------ 00594 operator float(){ return fval; } 00595 operator signed short(){ return val; } 00596 00597 signed short val; 00598 float fval; 00599 }; 00600 std::ostream& operator<<(std::ostream& os, T17& t ); 00601 // -------------------------------------------------------------------------- 00602 class F1 00603 { 00604 public: 00605 // ------------------------------------------ 00607 typedef union 00608 { 00609 unsigned short v[2]; 00610 float val; // 00611 } F1mem; 00612 // ------------------------------------------ 00613 // конструкторы на разные случаи... 00614 F1(){ memset(raw.v,0,sizeof(raw.v)); } 00615 F1( unsigned short v1, unsigned short v2 ) 00616 { 00617 raw.v[0] = v1; 00618 raw.v[1] = v2; 00619 } 00620 00621 F1( float f ) 00622 { 00623 raw.val = f; 00624 } 00625 00626 F1( const ModbusRTU::ModbusData* data, int size ) 00627 { 00628 if( size >= u2size ) 00629 { 00630 // При получении данных от MTR слова необходимо перевернуть 00631 raw.v[0] = data[1]; 00632 raw.v[1] = data[0]; 00633 } 00634 } 00635 00636 ~F1(){} 00637 // ------------------------------------------ 00639 static int wsize(){ return u2size; } 00641 static MTRType type(){ return mtF1; } 00642 // ------------------------------------------ 00643 operator float(){ return raw.val; } 00644 operator long(){ return lroundf(raw.val); } 00645 00646 F1mem raw; 00647 }; 00648 std::ostream& operator<<(std::ostream& os, F1& t ); 00649 // -------------------------------------------------------------------------- 00650 class T_Str16 00651 { 00652 public: 00653 // ------------------------------------------ 00654 // конструкторы на разные случаи... 00655 T_Str16():sval(""){} 00656 T_Str16( const ModbusRTU::ReadInputRetMessage& ret ) 00657 { 00658 char c[16]; 00659 ModbusRTU::ModbusData data[8]; 00660 for( int i=0; i<8; i++ ) 00661 data[i] = ModbusRTU::SWAPSHORT(ret.data[i]); 00662 00663 memcpy(c,&data,sizeof(c)); 00664 sval = std::string(c); 00665 } 00666 00667 ~T_Str16(){} 00668 // ------------------------------------------ 00670 static int wsize(){ return 8; } 00672 static MTRType type(){ return mtT_Str16; } 00673 // ------------------------------------------ 00674 std::string sval; 00675 }; 00676 std::ostream& operator<<(std::ostream& os, T_Str16& t ); 00677 // -------------------------------------------------------------------------- 00678 00679 class T_Str8 00680 { 00681 public: 00682 // ------------------------------------------ 00683 // конструкторы на разные случаи... 00684 T_Str8():sval(""){} 00685 T_Str8( const ModbusRTU::ReadInputRetMessage& ret ) 00686 { 00687 char c[8]; 00688 ModbusRTU::ModbusData data[4]; 00689 for( int i=0; i<4; i++ ) 00690 data[i] = ModbusRTU::SWAPSHORT(ret.data[i]); 00691 memcpy(c,&data,sizeof(c)); 00692 sval = std::string(c); 00693 } 00694 00695 ~T_Str8(){} 00696 // ------------------------------------------ 00698 static int wsize(){ return 4; } 00700 static MTRType type(){ return mtT_Str8; } 00701 // ------------------------------------------ 00702 std::string sval; 00703 }; 00704 std::ostream& operator<<(std::ostream& os, T_Str8& t ); 00705 // -------------------------------------------------------------------------- 00706 } // end of namespace MTR 00707 // -------------------------------------------------------------------------- 00708 #endif // _MTR_H_ 00709 // -----------------------------------------------------------------------------