flipflop.cxx

Go to the documentation of this file.

// flipflop.hxx - implementation of multiple flip flop types
//
// Written by Torsten Dreyer
//
// Copyright (C) 2010  Torsten Dreyer - Torsten (at) t3r (dot) de
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
//
 
#include "flipflop.hxx"
#include "functor.hxx"
#include <simgear/misc/inputvalue.hxx>
#include <Main/fg_props.hxx>
 
using std::map;
using std::string;
using std::endl;
using std::cout;
 
namespace FGXMLAutopilot {

class RSFlipFlopImplementation : public FlipFlopImplementation {
protected:
  bool _rIsDominant;
public:
  RSFlipFlopImplementation( bool rIsDominant = true ) : _rIsDominant( rIsDominant ) {}
  virtual bool getState( double dt, DigitalComponent::InputMap input, bool & q );
};

class SRFlipFlopImplementation : public RSFlipFlopImplementation {
public:
  SRFlipFlopImplementation() : RSFlipFlopImplementation( false ) {}
};

class ClockedFlipFlopImplementation : public RSFlipFlopImplementation {
private:
  bool _clock;
protected:

  virtual bool onRaisingEdge( DigitalComponent::InputMap input, bool & q ) = 0;
public:

  ClockedFlipFlopImplementation( bool rIsDominant = true ) : RSFlipFlopImplementation( rIsDominant ), _clock(false) {}

  virtual bool getState( double dt, DigitalComponent::InputMap input, bool & q );
};

class JKFlipFlopImplementation : public ClockedFlipFlopImplementation {
public:
  JKFlipFlopImplementation( bool rIsDominant = true ) : ClockedFlipFlopImplementation ( rIsDominant ) {}

  virtual bool onRaisingEdge( DigitalComponent::InputMap input, bool & q );
};

class DFlipFlopImplementation : public ClockedFlipFlopImplementation {
public:
  DFlipFlopImplementation( bool rIsDominant = true ) : ClockedFlipFlopImplementation ( rIsDominant ) {}

  virtual bool onRaisingEdge( DigitalComponent::InputMap input, bool & q ) {
    q = input.get_value("D");
    return true;
  }
};

class TFlipFlopImplementation : public ClockedFlipFlopImplementation {
public:
  TFlipFlopImplementation( bool rIsDominant = true ) : ClockedFlipFlopImplementation ( rIsDominant ) {}

  virtual bool onRaisingEdge( DigitalComponent::InputMap input, bool & q ) {
    q = !q;
    return true;
  }
};

class MonoFlopImplementation : public JKFlipFlopImplementation {
protected:
  virtual bool configure( SGPropertyNode& cfg_node,
                          const std::string& cfg_name,
                          SGPropertyNode& prop_root );
  simgear::ValueList _time;
  double _t;
 
  bool isConfigProperty(const std::string& cfg_name) const override
  {
    return cfg_name == "time";
  }
 
public:
  MonoFlopImplementation( bool rIsDominant = true ) : JKFlipFlopImplementation( rIsDominant ), _t(0.0) {}
  virtual bool getState( double dt, DigitalComponent::InputMap input, bool & q );
};
 
} // namespace
 
using namespace FGXMLAutopilot;
 
//------------------------------------------------------------------------------
bool MonoFlopImplementation::configure( SGPropertyNode& cfg_node,
                                        const std::string& cfg_name,
                                        SGPropertyNode& prop_root )
{
  if( JKFlipFlopImplementation::configure(cfg_node, cfg_name, prop_root) )
    return true;
 
  if (cfg_name == "time") {
    _time.push_back(new simgear::Value(prop_root, cfg_node));
    return true;
  } 
 
  return false;
}
 
bool MonoFlopImplementation::getState( double dt, DigitalComponent::InputMap input, bool & q )
{
  if( JKFlipFlopImplementation::getState( dt, input, q ) ) {
    _t = q ? _time.get_value() : 0;
    return true;
  }
 
  _t -= dt;
  if( _t <= 0.0 ) {
    q = 0;
    return true;
  }
 
  return false;
}
 
 
bool RSFlipFlopImplementation::getState( double dt, DigitalComponent::InputMap input, bool & q )
{
  bool s = input.get_value("S");
  bool r = input.get_value("R");
 
  // s == false && q == false: no change, keep state
  if( s || r ) {
    if( _rIsDominant ) { // RS: reset is dominant
      if( s ) q = true; // set
      if( r ) q = false; // reset
    } else { // SR: set is dominant
      if( r ) q = false; // reset
      if( s ) q = true; // set
    }
    return true; // signal state changed
  }
  return false; // signal state unchagned
}
 
bool ClockedFlipFlopImplementation::getState( double dt, DigitalComponent::InputMap input, bool & q )
{
  bool c = input.get_value("clock");
  bool raisingEdge = c && !_clock;
    
  _clock = c;
 
  if( RSFlipFlopImplementation::getState( dt, input, q ) )
    return true;
 
 
  if( !raisingEdge ) return false; //signal no change
  return onRaisingEdge( input, q );
}
 
bool JKFlipFlopImplementation::onRaisingEdge( DigitalComponent::InputMap input, bool & q )
{
  bool j = input.get_value("J");
  bool k = input.get_value("K");
    
  // j == false && k == false: no change, keep state
  if( (j || k) ) {
    if( j && k ) {
      q = !q; // toggle
    } else {
      if( j ) q = true;  // set
      if( k ) q = false; // reset
    }
    return true; // signal state changed
  }
 
  return false; // signal no change
}
 
//------------------------------------------------------------------------------
bool FlipFlopImplementation::configure( SGPropertyNode& prop_root,
                                        SGPropertyNode& cfg )
{
  for( int i = 0; i < cfg.nChildren(); ++i )
  {
    SGPropertyNode_ptr child = cfg.getChild(i);
    string cname(child->getNameString());
 
    if( configure(*child, cname, prop_root) )
      continue;
  }
 
  return true;
}
 
 
static map<string,FunctorBase<FlipFlopImplementation> *> componentForge;
 
//------------------------------------------------------------------------------
bool FlipFlop::configure( SGPropertyNode& cfg_node,
                          const std::string& cfg_name,
                          SGPropertyNode& prop_root )
{ 
  if( componentForge.empty() ) {
    componentForge["RS"] = new CreateAndConfigureFunctor<RSFlipFlopImplementation,FlipFlopImplementation>();
    componentForge["SR"] = new CreateAndConfigureFunctor<SRFlipFlopImplementation,FlipFlopImplementation>();
    componentForge["JK"] = new CreateAndConfigureFunctor<JKFlipFlopImplementation,FlipFlopImplementation>();
    componentForge["D"]  = new CreateAndConfigureFunctor<DFlipFlopImplementation, FlipFlopImplementation>();
    componentForge["T"]  = new CreateAndConfigureFunctor<TFlipFlopImplementation, FlipFlopImplementation>();
    componentForge["monostable"]  = new CreateAndConfigureFunctor<MonoFlopImplementation, FlipFlopImplementation>();
  }
 
  if( DigitalComponent::configure(cfg_node, cfg_name, prop_root) )
    return true;
 
  if( cfg_name == "type" ) {
    string type(cfg_node.getStringValue());
    if( componentForge.count(type) == 0 ) {
      SG_LOG
      (
        SG_AUTOPILOT,
        SG_BULK,
        "unhandled flip-flop type <" << type << ">"
      );
      return true;
    }
    _implementation = (*componentForge[type])(prop_root, *cfg_node.getParent());
    return true;
  }
 
  if (cfg_name == "set"||cfg_name == "S") {
    _input["S"] = sgReadCondition(&prop_root, &cfg_node);
    return true;
  }
 
  if (cfg_name == "reset" || cfg_name == "R" ) {
    _input["R"] = sgReadCondition(&prop_root, &cfg_node);
    return true;
  } 
 
  if (cfg_name == "J") {
    _input["J"] = sgReadCondition(&prop_root, &cfg_node);
    return true;
  } 
 
  if (cfg_name == "K") {
    _input["K"] = sgReadCondition(&prop_root, &cfg_node);
    return true;
  } 
 
  if (cfg_name == "D") {
    _input["D"] = sgReadCondition(&prop_root, &cfg_node);
    return true;
  } 
 
  if (cfg_name == "clock") {
    _input["clock"] = sgReadCondition(&prop_root, &cfg_node);
    return true;
  }
 
  if (_implementation && _implementation->isConfigProperty(cfg_name)) {
    // componentForge CreateAndConfigureFunctor<> already called configure with all the nodes
    // on our implementation, but we need to ensure we don't return false here for such nodes
    return true;
  }
 
  return false; 
}
 
void FlipFlop::update( bool firstTime, double dt )
{
  if( _implementation == NULL ) {
    SG_LOG( SG_AUTOPILOT, SG_ALERT, "No flip-flop implementation for " << subsystemId() << endl );
    return;
  }
 
  bool q0, q;
 
  q0 = q = get_output();
 
  if( _implementation->getState( dt, _input, q ) && q0 != q ) {
    set_output( q );
 
    if(_debug) {
      cout << "updating flip-flop \"" << subsystemId() << "\"" << endl;
      cout << "prev. Output:" << q0 << endl;
      for( InputMap::const_iterator it = _input.begin(); it != _input.end(); ++it ) 
        cout << "Input \"" << (*it).first << "\":" << (*it).second->test() << endl;
      cout << "new Output:" << q << endl;
    }
  }
}
 
 
// Register the subsystem.
SGSubsystemMgr::Registrant<FlipFlop> registrantFlipFlop;