ethercat_mbx.h

Go to the documentation of this file.

// $Id: ethercat_mbx.h,v 1.14 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_mbx__
#define __ethercat_mbx__

#include "ros_ethercat_eml/ethercat_defs.h"
#include "ros_ethercat_eml/ethercat_slave_memory.h"

typedef enum
{
  EC_AoE = 0x01, // ADS over EtherCAT
  EC_EoE = 0x02, // Ethernet over EtherCAT
  EC_CoE = 0x03, // CANOpen over EtherCAT
  EC_FoE = 0x04, // File Access over EtherCAT
} ECMbxMsgType;


class EC_MbxMsgType
{
public:

  EC_MbxMsgType(ECMbxMsgType type = EC_CoE) :
    msg_type(type)
  {
  }

  operator uint8_t() const
  {
    return msg_type;
  }
private:
  uint8_t msg_type;
};


class EC_MbxMsgPriority
{
public:

  EC_MbxMsgPriority(uint8_t priority = 0x00)
  {
    if (priority < 4)
      msg_priority = priority;
    else
    {
      ec_log(EC_LOG_WARNING, "EC_MbxMsgPriority: Max Priority is 0x03, using 0x03\n");
      msg_priority = 0x03;
    }
  }

  operator uint8_t() const
  {
    return msg_priority;
  }
private:
  uint8_t msg_priority;
};

// Header size is 6 bytes
static const size_t EC_MBXMSG_HDR_SIZE = 6;


class EC_MbxMsgHdr : public EC_DataStruct
{
  friend class EtherCAT_Router;

public:

  EC_MbxMsgHdr(uint16_t a_length,
               EC_FixedStationAddress a_address,
               EC_MbxMsgPriority a_priority,
               EC_MbxMsgType a_type)
    :
    EC_DataStruct(EC_MBXMSG_HDR_SIZE),
    m_length(a_length), m_address(a_address),
    m_priority(a_priority), m_type(a_type)
  {
  }

  EC_MbxMsgHdr(const unsigned char * a_buffer);

  virtual unsigned char * dump(unsigned char * a_buffer) const;

public:
  uint16_t m_length;
  EC_FixedStationAddress m_address;
  // uint8_t  m_channel; 6 bits unused for now...;
  EC_MbxMsgPriority m_priority;
  EC_MbxMsgType m_type;
  // uint16_t reserved : 4;
};


class EtherCAT_MbxMsg
{
  friend class EtherCAT_Router;

public:
  EtherCAT_MbxMsg(EC_MbxMsgHdr a_hdr, unsigned char * a_MbxMsgdata)
    :
    m_hdr(a_hdr), m_MbxMsgdata(a_MbxMsgdata)
  {
  }
  EtherCAT_MbxMsg(uint16_t a_length, uint16_t a_address,
                  EC_MbxMsgPriority a_priority,
                  EC_MbxMsgType a_type,
                  unsigned char * a_MbxMsgdata)
    :
    m_hdr(a_length, a_address, a_priority, a_type), m_MbxMsgdata(a_MbxMsgdata)
  {
  }
  EtherCAT_MbxMsg(const unsigned char * a_buffer);
  virtual ~EtherCAT_MbxMsg()
  {
  }

  virtual unsigned char * dump(unsigned char * a_buffer) const;

protected:
  EC_MbxMsgHdr m_hdr;
  const unsigned char * m_MbxMsgdata;

  virtual unsigned char * dump_data(unsigned char * a_buffer) const;
};


class EtherCAT_Mbx
{
public:
  bool write(EtherCAT_MbxMsg * a_msg);
  bool read(EtherCAT_MbxMsg * a_msg);
  EtherCAT_Mbx()
  {
  }
};

// ==================================================
// CANopen over EtherCAT
// ==================================================

typedef enum
{
  CANopen_Emergency = 0x01,
  CANopen_SDORequest = 0x02,
  CANopen_SDOResponse = 0x03,
  CANopen_txPDO = 0x04,
  CANopen_rxPDO = 0x05,
  CANopen_txPDORemoteReq = 0x06,
  CANopen_rxPDORemoteReq = 0x07,
  CANopen_SDOInformation = 0x08,
} CANopenService;


class CANopen_Service
{
public:

  CANopen_Service(CANopenService a_service = CANopen_Emergency)
    :
    m_service(a_service)
  {
  }

  operator uint8_t() const
  {
    return m_service;
  }

private:
  CANopenService m_service;
};

static const size_t EC_MBXMSG_COE_HDR_SIZE = 2;


class EC_CoE_Hdr : public EC_DataStruct
{
public:

  EC_CoE_Hdr(CANopen_Service a_service = CANopen_Emergency) :
    EC_DataStruct(EC_MBXMSG_COE_HDR_SIZE),
    m_service(a_service)
  {
  }

  EC_CoE_Hdr(const unsigned char * a_buffer);

  virtual unsigned char * dump(unsigned char * a_buffer) const;

private:
  // FIXME meaning of these is nog clear from spec
  // Number Low: 8 bits depending on CANopen service
  // Number High: 1 bit depending on CANopen service
  CANopen_Service m_service;
};


class EtherCAT_CoE_MbxMsg : public EtherCAT_MbxMsg
{
public:
  EtherCAT_CoE_MbxMsg(EC_MbxMsgHdr a_hdr,
                      EC_CoE_Hdr a_CoE_hdr,
                      unsigned char * a_MbxMsgdata)
    :
    EtherCAT_MbxMsg(a_hdr, a_MbxMsgdata), m_CoE_Hdr(a_CoE_hdr)
  {
  }
  EtherCAT_CoE_MbxMsg(uint16_t a_length, uint16_t a_address,
                      EC_MbxMsgPriority a_priority,
                      EC_MbxMsgType a_type,
                      CANopen_Service a_service,
                      unsigned char * a_MbxMsgdata)
    :
    EtherCAT_MbxMsg(a_length, a_address, a_priority, a_type, a_MbxMsgdata), m_CoE_Hdr(a_service)
  {
  }
  EtherCAT_CoE_MbxMsg(unsigned char * a_buffer);

  virtual unsigned char * dump(unsigned char * a_buffer) const;
protected:
  EC_CoE_Hdr m_CoE_Hdr;
};

#endif // __ethercat_mbx__