DataProcess.cpp

00001 #include "mbed.h"
00002 #include "DataProcess.h"
00003 
00004 extern Serial dbg;
00005 
00006 //-----------------------------------------------------------
00007 // FTL Message
00008 //-----------------------------------------------------------
00009 FtlMessage::FtlMessage()
00010 {
00011 }
00012 
00013 FtlMessage::~FtlMessage()
00014 {
00015 }
00016 
00017 FtlMessage::msg FtlMessage::checkMessage(const int &lastIdentifier, const int &identifier_)
00018 {
00019     switch(lastIdentifier){
00020 
00021     case 'A':
00022         if(identifier_ == 'a')return FtlMessage::OK;
00023         else if(identifier_ == 'n') return FtlMessage::PROERROR;
00024         else if(identifier_ == 's') return FtlMessage::NOTANSWER;
00025         break;
00026 
00027     case 'C':
00028         if(identifier_ == 'c')return FtlMessage::OK;
00029         else if(identifier_ == 'n') return FtlMessage::PROERROR;
00030         else if(identifier_ == 's') return FtlMessage::NOTANSWER;
00031         break;
00032 
00033     case 'E':
00034     case 'I':
00035         if(identifier_ == 'e')return FtlMessage::OK;
00036         else if(identifier_ == 'i')return FtlMessage::OK;
00037         else if(identifier_ == 'v')return FtlMessage::OK;
00038         else if(identifier_ == 'n') return FtlMessage::PROERROR;
00039         else if(identifier_ == 's') return FtlMessage::NOTANSWER;
00040         break;
00041 
00042     case 'R':
00043     case 'V':
00044         if(identifier_ == 'r')return FtlMessage::OK;
00045         else if(identifier_ == 'v')return FtlMessage::OK;
00046         else if(identifier_ == 'n') return FtlMessage::PROERROR;
00047         else if(identifier_ == 's') return FtlMessage::NOTANSWER;
00048         break;
00049 
00050     default : return FtlMessage::FAILED;
00051     }
00052     return FtlMessage::FAILED;
00053 }
00054 
00055 //-----------------------------------------------------------
00056 // Data Message
00057 //-----------------------------------------------------------
00058 DataMessage::DataMessage()
00059 {
00060 }
00061 
00062 DataMessage::~DataMessage()
00063 {
00064 }
00065 
00066 DataMessage::msg DataMessage::processFromSlave(int identifier_,std::string buff, _CALLBACKPTR cb, void* param)
00067 {
00068     int res = 0;
00069     switch(identifier_){
00070     case 'e':
00071     case 'i':
00072     case 'v':
00073         res = cb(buff.c_str(), buff.length(), param);
00074         break;
00075     }
00076     if(res) return DataMessage::OK;
00077     else return DataMessage::FAILED;
00078 }
00079 
00080 int DataMessage::_cbstate(const char* buf, int len, MeterState* param)
00081 {
00082   if (param)
00083   {
00084     if(sscanf(buf, "%*[^= ]=%*d,%*[^, ],%*[^, ],%d", param->state) ==1)
00085     {
00086       return 1;
00087     }
00088   }
00089   return 0;
00090 }
00091 
00092 DataMessage::msg DataMessage::checkStateMessage(const int &identifier_, const std::string &stream, int *pStep)
00093 {
00094     MeterState mystate;
00095     mystate.state = pStep;
00096     if(processFromSlave(identifier_, stream, _cbstate, &mystate) == DataMessage::OK)
00097     {
00098         dbg.printf("SUKSES BRO\r\n");
00099         return DataMessage::OK;
00100     }
00101     else
00102     {
00103         dbg.printf("GAGAL BRO\r\n");
00104         return DataMessage::FAILED;
00105     }
00106 }
00107 
00108 int DataMessage::_cbOstate(const char* buf, int len, OrderState* param)
00109 {
00110   if (param)
00111   {
00112     if(sscanf(buf, "%*[^= ]=%d", param->state) ==1)
00113     {
00114       return 1;
00115     }
00116   }
00117   return 0;
00118 }
00119 
00120 DataMessage::msg DataMessage::checkOrderState(const int &identifier_, const std::string &stream, int *pStep)
00121 {
00122     OrderState mystate;
00123     mystate.state = pStep;
00124     if(processFromSlave(identifier_, stream, _cbOstate, &mystate) == DataMessage::OK)
00125     {
00126         dbg.printf("SUKSES BRO\r\n");
00127         return DataMessage::OK;
00128     }
00129     else
00130     {
00131         dbg.printf("GAGAL BRO\r\n");
00132         return DataMessage::FAILED;
00133     }
00134 }
00135 
00136 int DataMessage::_cbInterlock(const char* buf, int len, InterlockState* param)
00137 {
00138   if (param)
00139   {
00140     if(sscanf(buf, "%*[^= ]=%*d,%*d,%d,%*s", param->state) ==1)
00141     {
00142       return 1;
00143     }
00144   }
00145   return 0;
00146 }
00147 
00148 DataMessage::msg DataMessage::checkInterlock(const int &identifier_, const std::string &stream, int *pStep)
00149 {
00150     InterlockState mystate;
00151     mystate.state = pStep;
00152     if(processFromSlave(identifier_, stream, _cbInterlock, &mystate) == DataMessage::OK)
00153     {
00154         dbg.printf("SUKSES BRO\r\n");
00155         return DataMessage::OK;
00156     }
00157     else
00158     {
00159         dbg.printf("GAGAL BRO\r\n");
00160         return DataMessage::FAILED;
00161     }
00162 }
00163 
00164 //-----------------------------------------------------------
00165 DataProcess::DataProcess()
00166 {
00167     stateTmp = 0;
00168     lastState = 0;
00169     OrderStateTmp = 0;
00170     LastOrderState = 0;
00171     InterlockState = 0;
00172 }
00173 
00174 DataProcess::~DataProcess()
00175 {
00176 }
00177 
00178 void DataProcess::CheckFtlMassage(const int &lastIdentifier, const AruFrm &frm)
00179 {
00180     FtlMsg = FtlMessage::checkMessage(lastIdentifier, frm.Identifier);
00181     return;
00182 }
00183 
00184 FtlMessage::msg DataProcess::getFtlMessage()
00185 {
00186     return FtlMsg;
00187 }
00188 
00189 DataProcess::state_ DataProcess::checkState()
00190 {
00191     DataProcess::state_ ret;
00192 //    int res = stateTmp - lastState;
00193     
00194     switch(lastState)
00195     {
00196         case 0:
00197             if(stateTmp == 0)ret = DataProcess::STAYNOL;
00198             else if(stateTmp == 1)ret = DataProcess::STEPUP;
00199             else if(stateTmp == 2)ret = DataProcess::STEPJUMP;
00200             else if(stateTmp == 3)ret = DataProcess::STEPJUMP;
00201             else if(stateTmp == 4)ret = DataProcess::STEPEND;
00202             else if(stateTmp == 5)ret = DataProcess::FINISH;
00203             break;
00204         case 1:
00205             if(stateTmp == 0)ret = DataProcess::STEPDOWN;
00206             else if(stateTmp == 1)ret = DataProcess::STAY;
00207             else if(stateTmp == 2)ret = DataProcess::STEPUP;
00208             else if(stateTmp == 3)ret = DataProcess::STEPJUMP;
00209             else if(stateTmp == 4)ret = DataProcess::STEPEND;
00210             else if(stateTmp == 5)ret = DataProcess::FINISH;
00211             break;
00212         case 2:
00213             if(stateTmp == 0)ret = DataProcess::STEPEND;
00214             else if(stateTmp == 1)ret = DataProcess::STEPDOWN;
00215             else if(stateTmp == 2)ret = DataProcess::STAY;
00216             else if(stateTmp == 3)ret = DataProcess::STEPUP;
00217             else if(stateTmp == 4)ret = DataProcess::STEPEND;
00218             else if(stateTmp == 5)ret = DataProcess::ERROR;
00219             break;
00220          case 3:
00221             if(stateTmp == 0)ret = DataProcess::STEPEND;
00222             else if(stateTmp == 1)ret = DataProcess::ERROR;
00223             else if(stateTmp == 2)ret = DataProcess::STEPDOWN;
00224             else if(stateTmp == 3)ret = DataProcess::STAY;
00225             else if(stateTmp == 4)ret = DataProcess::STEPEND;
00226             else if(stateTmp == 5)ret = DataProcess::ERROR;
00227             break;
00228         case 4:
00229             if(stateTmp == 0)ret = DataProcess::STEPEND;
00230             else if(stateTmp == 1)ret = DataProcess::ERROR;
00231             else if(stateTmp == 2)ret = DataProcess::STEPDOWN;
00232             else if(stateTmp == 3)ret = DataProcess::STEPDOWN;
00233             else if(stateTmp == 4)ret = DataProcess::STAY;
00234             else if(stateTmp == 5)ret = DataProcess::FINISH;
00235             break;
00236         case 5:
00237             if(stateTmp == 0)ret = DataProcess::STEPEND;
00238             else if(stateTmp == 1)ret = DataProcess::ERROR;
00239             else if(stateTmp == 2)ret = DataProcess::ERROR;
00240             else if(stateTmp == 3)ret = DataProcess::ERROR;
00241             else if(stateTmp == 4)ret = DataProcess::STEPEND;
00242             else if(stateTmp == 5)ret = DataProcess::FINISH;
00243             break;
00244         default : ret = DataProcess::ERROR; break;
00245     }
00246     
00247     lastState = stateTmp;
00248     return ret;
00249 }
00250 
00251 DataProcess::state_ DataProcess::checkOrderState()
00252 {
00253     DataProcess::state_ ret;
00254     switch(OrderStateTmp)
00255     {
00256         case 0:
00257             ret = DataProcess::NOORDER;
00258             break;
00259             
00260         case 2:
00261             ret = DataProcess::ORDERRCV;
00262             break;
00263             
00264         case 3:
00265             ret = DataProcess::PLANORDERPROC;
00266             break;
00267             
00268         case 4:
00269             ret = DataProcess::UNPLANORDERPROC;
00270             break;
00271             
00272         case 9:
00273             ret = DataProcess::ORDERFINERROR;
00274             break;
00275             
00276         case 10:
00277             ret = DataProcess::ORDERFINNOERROR;
00278             break;
00279     }
00280     
00281     return ret;
00282 }
00283 
00284 DataProcess::state_ DataProcess::chackInterlock()
00285 {
00286     DataProcess::state_ ret;
00287     if(InterlockState == 1)
00288     {
00289         ret = DataProcess::ACCCLOSED;
00290     }
00291     else if (InterlockState == 2)
00292     {
00293         ret = DataProcess::ACCOPEN;
00294     }
00295     else
00296     {
00297         ret = DataProcess::ERROR;
00298     }
00299     
00300     return ret;
00301 }
00302 
00303 void DataProcess::CheckDtMassage(const AruFrm &frm)
00304 {
00305     std::string input(frm.Data.begin(), frm.Data.end());
00306 
00307     switch(frm.Identifier){
00308     case 'e':
00309     case 'i':
00310     case 'v':
00311         {
00312             if(strstr(input.c_str(), "Meter_State"))
00313             { 
00314                 DataMsg = DataMessage::checkStateMessage(frm.Identifier,  input, &stateTmp);
00315             }
00316             else if(strstr(input.c_str(), "ORDER,State"))
00317             {
00318                 DataMsg = DataMessage::checkOrderState(frm.Identifier,  input, &OrderStateTmp);
00319             }
00320             else if(strstr(input.c_str(), "Interlock"))
00321             {
00322                 DataMsg = DataMessage::checkInterlock(frm.Identifier,  input, &InterlockState);
00323             }
00324             else if(strstr(input.c_str(), "Meter_Info"))
00325             {
00326                 DataMsg = DataMessage::OK;
00327             }
00328             else
00329             {
00330                 DataMsg = DataMessage::FAILED;
00331             }
00332         }
00333         break;
00334     }
00335 
00336     return;
00337 }
00338 
00339 DataMessage::msg DataProcess::getDtMessage()
00340 {
00341     return DataMsg;
00342 }
00343 
00344 //-----------------------------------------------------------