ethercat_FSM.h

Go to the documentation of this file.

// $Id: ethercat_FSM.h,v 1.16 2006/02/20 15:57:33 kgad Exp $
//===========================================================================
//      This file is part of "EtherCAT Master Library".
//      Copyright (C) 2005 FMTC vzw, Diamant Building, A. Reyerslaan 80,
//      B-1030 Brussels, Belgium.
//
//      EtherCAT Master Library 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 or
//      (at your option) any later version.
//
//      EtherCAT Master Code 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 the EtherCAT Master Library; if not, write to the Free
//      Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
//      02111-1307 USA.
//
//      EtherCAT, the EtherCAT trade name and logo are the intellectual
//      property of, and protected by Beckhoff. You can use "EtherCAT
//      Master Library" for creating and/or selling or otherwise
//      distributing an EtherCAT network master under the terms of the
//      EtherCAT Master License.
//
//      You should have received a copy of the EtherCAT Master License
//      along with the EtherCAT Master Library; if not, write to Beckhoff
//      Automation GmbH, Eiserstrasse 5, D-33415 Verl, Germany.
//===========================================================================

#ifndef __ethercat_fsm__
#define __ethercat_fsm__

/* Note, this class is supposed to be programmed according to the
 FSM design Pattern.
 */

// forward declarations
class EtherCAT_AL;
class EC_Logic;
class EtherCAT_SlaveHandler;
class EtherCAT_DataLinkLayer;
class EtherCAT_Router;
class EtherCAT_PD_Buffer;

// FIXME how to do forward declaration of typedef enum?, with "extern"
// keyword?
#include "ros_ethercat_eml/ethercat_slave_memory.h"


class EC_ESM_Ops
{
protected:
  bool start_mbx_comm();
  bool stop_mbx_comm();
  bool start_input_update();
  bool stop_input_update();
  bool start_output_update();
  bool stop_output_update();

protected:

  EC_ESM_Ops(EtherCAT_SlaveHandler * a_SH);

  EtherCAT_DataLinkLayer * m_dll_instance;
  EC_Logic * m_logic_instance;
  EtherCAT_SlaveHandler * m_SH;
  EtherCAT_Router * m_router_instance;
  EtherCAT_PD_Buffer * m_pdbuf_instance;


  bool set_state(EC_State a_state);
};

// More forward declarations :-)
class EC_ESM;
class EC_ESM_InitState;
class EC_ESM_PreOpState;
class EC_ESM_SafeOpState;
class EC_ESM_OpState;


class EC_ESM_State
{
  friend class EC_ESM;

public:
  virtual ~EC_ESM_State()
  {
  }


  virtual bool to_state(EC_ESM * a_ESM, EC_State a_state) = 0;
  virtual EC_State get_state() const = 0;
protected:
  static EC_ESM_InitState initState;
  static EC_ESM_PreOpState preopState;
  static EC_ESM_SafeOpState safeopState;
  static EC_ESM_OpState opState;
};


class EC_ESM : public EC_ESM_Ops
{
  friend class EC_ESM_State;
  friend class EC_ESM_InitState;
  friend class EC_ESM_PreOpState;
  friend class EC_ESM_SafeOpState;
  friend class EC_ESM_OpState;

public:

  bool to_state(EC_State a_state)
  {
    return (m_esm_state->to_state(this, a_state));
  }
  EC_State get_state()
  {
    return m_esm_state->get_state();
  }

protected:
  void setState(EC_ESM_State * a_esm_state)
  {
    m_esm_state = a_esm_state;
  }


  EC_ESM(EtherCAT_SlaveHandler * a_SH);

private:
  EC_ESM_State * m_esm_state;
};

class EC_ESM_InitState : public EC_ESM_State
{
public:
  virtual EC_State get_state() const;
  virtual bool to_state(EC_ESM * a_ESM, EC_State a_state);
};

class EC_ESM_PreOpState : public EC_ESM_State
{
public:
  virtual EC_State get_state() const;
  virtual bool to_state(EC_ESM * a_ESM, EC_State a_state);
};

class EC_ESM_SafeOpState : public EC_ESM_State
{
public:
  virtual EC_State get_state() const;
  virtual bool to_state(EC_ESM * a_ESM, EC_State a_state);
};

class EC_ESM_OpState : public EC_ESM_State
{
public:
  virtual EC_State get_state() const;
  virtual bool to_state(EC_ESM * a_ESM, EC_State a_state);
};

#endif // __ethercat_fsm__