nevrax.org : docs

00001 
00007 /* Copyright, 2000 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 
00027 #include "nel/logic/logic_state_machine.h"
00028 #include "nel/logic/logic_variable.h"
00029 
00030 using namespace std;
00031 using namespace NLMISC;
00032 
00033 
00034 namespace NLLOGIC
00035 {
00036 
00037 
00038 //---------------------------------------------------
00039 // CLogicVariable :
00040 // 
00041 //---------------------------------------------------
00042 CLogicVariable::CLogicVariable()
00043 {
00044         _Value = 0;
00045         _Name = "unamed_var";
00046         _Verbose = false;
00047 
00048 } // CLogicVariable //
00049 
00050 
00051 
00052 //---------------------------------------------------
00053 // setValue :
00054 // 
00055 //---------------------------------------------------
00056 void CLogicVariable::setValue( sint64 value ) 
00057 { 
00058         _Value = value;
00059         
00060         if( _Verbose )
00061         {
00062                 nlinfo("variable \"%s\" value is now %f",_Name.c_str(),(double)_Value);
00063         }
00064 
00065 } // setValue //
00066 
00067 
00068 
00069 //---------------------------------------------------
00070 // applyModification :
00071 // 
00072 //---------------------------------------------------
00073 void CLogicVariable::applyModification( string op, sint64 value )
00074 {
00075         if( op == "SET" || op == "set" )
00076         {
00077                 _Value = value;
00078         }
00079         else
00080         if( op == "ADD" || op == "add" )
00081         {
00082                 _Value += value;
00083         }
00084         else
00085         if( op == "SUB" || op == "sub" )
00086         {
00087                 _Value -= value;
00088         }
00089         else
00090         if( op == "MUL" || op == "mul")
00091         {
00092                 _Value *= value;
00093         }
00094         else
00095         if( op == "DIV" || op == "div")
00096         {
00097                 if( value != 0 ) _Value /= value;
00098         }
00099         else
00100         {
00101                 nlwarning("(LGCS)<CLogicVariable::applyModification> The operator \"%s\" is unknown",op.c_str());
00102                 return;
00103         }
00104 
00105         if( _Verbose )
00106         {
00107                 nlinfo("variable \"%s\" value is now %f",_Name.c_str(),(double)_Value);
00108         }
00109 
00110 } // applyModification //
00111 
00112 
00113 //---------------------------------------------------
00114 // processLogic :
00115 // 
00116 //---------------------------------------------------
00117 void CLogicVariable::processLogic()
00118 {
00119 
00120 
00121 } // processLogic //
00122 
00123 
00124 //---------------------------------------------------
00125 // serial :
00126 // 
00127 //---------------------------------------------------
00128 /*void CLogicVariable::serial( IStream &f )
00129 {
00130         f.xmlPush( "VARIABLE");
00131 
00132         f.serial( _Value );
00133         f.serial( _Name );
00134 
00135         f.xmlPop();
00136 
00137 } // serial //*/
00138 
00139 void CLogicVariable::write (xmlNodePtr node) const
00140 {
00141         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"VARIABLE", NULL);
00142         xmlSetProp (elmPtr, (const xmlChar*)"Name", (const xmlChar*)_Name.c_str());
00143         xmlSetProp (elmPtr, (const xmlChar*)"Value", (const xmlChar*)toString(_Value).c_str());
00144         xmlSetProp (elmPtr, (const xmlChar*)"Verbose", (const xmlChar*)toString(_Verbose).c_str());
00145 }
00146 
00147 void CLogicVariable::read (xmlNodePtr node)
00148 {
00149         xmlCheckNodeName (node, "VARIABLE");
00150 
00151         _Name = getXMLProp (node, "Name");
00152         _Value = atoiInt64 (getXMLProp (node, "Value").c_str());
00153         _Verbose = atoi(getXMLProp (node, "Verbose").c_str()) == 1;
00154 }
00155 
00156 //---------------------------------------------------
00157 // CLogicCounter :
00158 // 
00159 //---------------------------------------------------
00160 CLogicCounter::CLogicCounter()
00161 {
00162         _TickCount = 0;
00163         _Value = 0;
00164         _Name = "unamed_counter";
00165 
00166         Period.setValue( 10 );
00167         Period.setName("Period");
00168         
00169         Phase.setValue( 0 );
00170         Phase.setName("Phase");
00171         
00172         Step.setValue( 1 );
00173         Step.setName("Step");
00174         
00175         LowLimit.setValue( 0 );
00176         LowLimit.setName("LowLimit");
00177         
00178         HighLimit.setValue( 100 );
00179         HighLimit.setName("HighLimit");
00180         
00181         Mode.setValue( STOP_AT_LIMIT );
00182         Mode.setName("Mode");
00183         
00184         Control.setValue( RUN );
00185         Control.setName("Control");
00186 
00187 } // CLogicCounter //
00188 
00189 
00190 //---------------------------------------------------
00191 // update :
00192 // 
00193 //---------------------------------------------------
00194 void CLogicCounter::update()
00195 {
00196         if( Control.getValue() == STOPPED )
00197         {
00198                 return;
00199         }
00200 
00201         _TickCount++;
00202         if( _TickCount < Period.getValue() )
00203         {
00204                 return;
00205         }
00206         else
00207         {
00208                 _TickCount = 0;
00209         }
00210 
00211         switch( Control.getValue() )
00212         {
00213                 case RUN :
00214                 {
00215                         _Value += Step.getValue();
00216                         manageRunningMode();
00217                 }
00218                 break;
00219 
00220                 case REWIND :
00221                 {
00222                         _Value = LowLimit.getValue();
00223                         Control.setValue( RUN );
00224                 }
00225                 break;
00226 
00227                 case FAST_FORWARD :
00228                 {
00229                         _Value = HighLimit.getValue();
00230                         Control.setValue( RUN );
00231                 }
00232                 break;
00233                 
00234         }
00235 
00236         if( _Verbose )
00237         {
00238                 nlinfo("variable \"%s\" value is now %f",_Name.c_str(),(double)_Value);
00239         }
00240 
00241 } // update //
00242 
00243 
00244 //---------------------------------------------------
00245 // manageRunningMode :
00246 // 
00247 //---------------------------------------------------
00248 void CLogicCounter::manageRunningMode()
00249 {
00250         // loop on one value
00251         if( HighLimit.getValue() == LowLimit.getValue() )
00252         {
00253                 _Value = HighLimit.getValue();
00254                 return;
00255         }
00256 
00257         switch( Mode.getValue() )
00258         {
00259                 case STOP_AT_LIMIT :
00260                 {
00261                         if( _Value > HighLimit.getValue() )
00262                         {
00263                                 _Value = HighLimit.getValue();
00264                         }
00265                         if( _Value < LowLimit.getValue() )
00266                         {
00267                                 _Value = LowLimit.getValue();
00268                         }
00269                 }
00270                 break;
00271 
00272                 case LOOP :
00273                 {
00274                         // value is higher than high limit
00275                         if( _Value > HighLimit.getValue() )
00276                         {
00277                                 _Value = LowLimit.getValue() + _Value - HighLimit.getValue() - 1;
00278                         }
00279                         // value is lower than low limit
00280                         else
00281                         {
00282                                 if( _Value < LowLimit.getValue() )
00283                                 {
00284                                         _Value = HighLimit.getValue() - (LowLimit.getValue() -_Value) + 1;
00285                                 }
00286                         }
00287                 }
00288                 break;
00289 
00290                 case SHUTTLE :
00291                 {
00292                         // value is higher than high limit
00293                         if( _Value > HighLimit.getValue() )
00294                         {
00295                                 _Value = HighLimit.getValue() - (_Value - HighLimit.getValue());
00296                                 Step.setValue( -Step.getValue() );
00297                         }
00298                         // value is lower than low limit
00299                         else
00300                         {
00301                                 if( _Value < LowLimit.getValue() )
00302                                 {
00303                                         _Value = LowLimit.getValue() + LowLimit.getValue() - _Value;
00304                                         Step.setValue( -Step.getValue() );
00305                                 }
00306                         }
00307                 }
00308                 break;
00309 
00310                 case DOWN_UP :
00311                 {
00312                         // low limit reached, we go up
00313                         if( _Value < LowLimit.getValue() )
00314                         {
00315                                 _Value = LowLimit.getValue() + LowLimit.getValue() - _Value;
00316                                 Step.setValue( -Step.getValue() );
00317                         }
00318                         else
00319                         {
00320                                 // high limit reached we stop
00321                                 if( _Value > HighLimit.getValue() )
00322                                 {
00323                                         _Value = HighLimit.getValue();
00324                                 }
00325                         }
00326                 }
00327                 break;
00328 
00329                 case UP_DOWN :
00330                 {
00331                         // high limit reached, we go down
00332                         if( _Value > HighLimit.getValue() )
00333                         {
00334                                 _Value = HighLimit.getValue() - (_Value - HighLimit.getValue());
00335                                 Step.setValue( -Step.getValue() );
00336                         }
00337                         else
00338                         {
00339                                 // low limit reached, we stop
00340                                 if( _Value < LowLimit.getValue() )
00341                                 {
00342                                         _Value = LowLimit.getValue();
00343                                 }
00344                         }
00345                 }
00346         }
00347 
00348 } // manageRunningMode //
00349 
00350 
00351 //---------------------------------------------------
00352 // serial :
00353 // 
00354 //---------------------------------------------------
00355 /*void CLogicCounter::serial( IStream &f )
00356 {
00357         f.xmlPush( "COUNTER");
00358 
00359         f.serial( _Value );
00360         f.serial( _Name );
00361         f.serial( Period );
00362         f.serial( Phase );
00363         f.serial( Step );
00364         f.serial( LowLimit );
00365         f.serial( HighLimit );
00366         f.serial( Mode );
00367 
00368         f.xmlPop();
00369 
00370 } // serial //*/
00371 
00372 void CLogicCounter::write (xmlNodePtr node) const
00373 {
00374         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"COUNTER", NULL);
00375         xmlSetProp (elmPtr, (const xmlChar*)"Name", (const xmlChar*)_Name.c_str());
00376         xmlSetProp (elmPtr, (const xmlChar*)"Value", (const xmlChar*)toString(_Value).c_str());
00377         xmlSetProp (elmPtr, (const xmlChar*)"Verbose", (const xmlChar*)toString(_Verbose).c_str());
00378         xmlSetProp (elmPtr, (const xmlChar*)"Period", (const xmlChar*)toString(Period.getValue()).c_str());
00379         xmlSetProp (elmPtr, (const xmlChar*)"Phase", (const xmlChar*)toString(Phase.getValue()).c_str());
00380         xmlSetProp (elmPtr, (const xmlChar*)"Step", (const xmlChar*)toString(Step.getValue()).c_str());
00381         xmlSetProp (elmPtr, (const xmlChar*)"LowLimit", (const xmlChar*)toString(LowLimit.getValue()).c_str());
00382         xmlSetProp (elmPtr, (const xmlChar*)"HighLimit", (const xmlChar*)toString(HighLimit.getValue()).c_str());
00383         xmlSetProp (elmPtr, (const xmlChar*)"Mode", (const xmlChar*)toString(Mode.getValue()).c_str());
00384         xmlSetProp (elmPtr, (const xmlChar*)"Control", (const xmlChar*)toString(Control.getValue()).c_str());
00385 }
00386 
00387 void CLogicCounter::read (xmlNodePtr node)
00388 {
00389         xmlCheckNodeName (node, "COUNTER");
00390 
00391         _Name = getXMLProp (node, "Name");
00392         _Value = atoiInt64 (getXMLProp (node, "Value").c_str());
00393         _Verbose = atoi(getXMLProp (node, "Verbose").c_str()) == 1;
00394         Period.setValue(atoiInt64(getXMLProp (node, "Period").c_str()));
00395         Phase.setValue(atoiInt64(getXMLProp (node, "Phase").c_str()));
00396         Step.setValue(atoiInt64(getXMLProp (node, "Step").c_str()));
00397         LowLimit.setValue(atoiInt64(getXMLProp (node, "LowLimit").c_str()));
00398         HighLimit.setValue(atoiInt64(getXMLProp (node, "HighLimit").c_str()));
00399         Mode.setValue(atoiInt64(getXMLProp (node, "Mode").c_str()));
00400         Control.setValue(atoiInt64(getXMLProp (node, "Control").c_str()));
00401 }
00402 
00403 
00404 }
logic_variable.cpp
