UniSet  1.4.0
MTR.h
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 // -----------------------------------------------------------------------------