rlcanopentypes.h

Go to the documentation of this file.

/***************************************************************************
                          rlcanopen.cpp  -  description
                             -------------------
    begin     : Tue March 03 2004
    copyright : (C) 2004 by Marc Bräutigam, Christian Wilmes, R. Lehrig
    email     : lehrig@t-online.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as        *
 *   published by the Free Software Foundation                             *
 *                                                                         *
 ***************************************************************************/

#include <iostream>
    using std::cin;
    using std::cout;

#include "rlinifile.h"
#include <stdlib.h>
#include <string.h>

struct IPCMSGSTRUCT;


class rlCanOpenTypes {
  public:
  enum rl_types{ 
    RL_BOOL=0,
    RL_UCHAR,
    RL_SHORT,     
    RL_USHORT,       
    RL_INT ,      
    RL_LONG,
    RL_FLOAT,      
    RL_DOUBLE,  
    RL_LONGLONG,     
    RL_STRING,   
    RL_BUFFER,
    RL_ULONG,
    RL_ULONGLONG,
    RL_PDO = 13,
    RL_NODESTATE,
    RL_NOTYPE = 0xFF
  };


 enum canopen_types{
 
 c_BOOLEAN      =  0x0001, 
 INTEGER8_t     =  0x0002, 
 INTEGER16_t    =  0x0003, 
 INTEGER32_t    =  0x0004,  
 UNSIGNED8_t    =  0x0005,
 UNSIGNED16_t   =  0x0006,  
 UNSIGNED32_t   =  0x0007,
 REAL32_t       =  0x0008,
 VISIBLE_STRING =  0x0009,  
 OCTET_STRING_t =  0x000A,  
 UNICODE_STRING =  0x000B,  
 TIME_OF_DAY_t  =  0x000C,  
 TIME_DIFFERENC =  0x000D,  
 BIT_STRING_t   =  0x000E,  
 DOMAIN_t       =  0x000F,  
 INTEGER24_t    =  0x0010,
 REAL64_t       =  0x0011,  
 INTEGER40_t    =  0x0012,  
 INTEGER48_t    =  0x0013,  
 INTEGER56_t    =  0x0014,  
 INTEGER64_t    =  0x0015,  
 UNSIGNED24_t   =  0x0016,
 RESERVED1_t    =  0x0017,  
 UNSIGNED40_t   =  0x0018,  
 UNSIGNED48_t   =  0x0019, 
 UNSIGNED56_t   =  0x001A, 
 UNSIGNED64_t   =  0x001B                                               
};  

  rlCanOpenTypes();
  
  int getLength();
  
  void clearBuffer();
  
  void set_DaemonType(rl_types _type);

  void set_DaemonType(int _type);
  
  int get_DaemonType();
  
  void set_CanOpenType(int _type);
 
  int get_CanOpenType();
  
  static int canOpenType2DeamonType(int _canopentype);
  
  static int deamonType2CanOpenType(int _deamontype);
  
  void set_int(int _value);

  int get_int();

  void set_float(float _value);

  float get_float();

  void set_double(double _value);

  double get_double();
  
  void set_short(short _value);
  
  short get_short();

  void set_ushort(unsigned short _value);
  
  unsigned short get_ushort();

  void set_longlong(long int _value);
  
  long int get_longlong();

  void set_string(const char* _value);
  
  char* get_string();

  void set_buffer(int _index, unsigned char _databyte);
  
  unsigned char get_buffer(int _index);

  void set_uchar(unsigned char _value);

  unsigned char get_uchar();
  
  void set_bool(bool _value);
  
  bool get_bool();

  void set_long(long _value);
  
  long get_long();
  
  void set_ulong(unsigned long _value);
  
  unsigned long get_ulong();

  void set_ulonglong(unsigned long int _value);
  unsigned long int get_ulonglong();

  void set_rlmsgerr(long _errnr);
  long get_rlmsgerr();
  
  void set_nodestateFlags( unsigned char _bNodeNoResponse,
                           unsigned char _bEmcyBuffOverflow,
                              unsigned char _bPrmFault,
                           unsigned char _bGuardActive ,
                           unsigned char _bDeactivated);
  
  bool get_nodestateFlags( bool &_bNodeNoResponse, 
                           bool &_bEmcyBuffOverflow, 
                           bool &_bPrmFault, 
                           bool &_bGuardActive, 
                           bool &_bDeactivated);
  
  bool get_nodestateFlag_NoResponse();
  bool get_nodestateFlag_EmcyBuffOverflow();
  bool get_nodestateFlag_PrmFault();
  bool get_nodestateFlag_GuardActive();
  bool get_nodestateFlag_Deactivated();

  void set_nodestate(unsigned char _nodestate);
  
  unsigned char get_nodestate();
  
  void set_nodeerror(unsigned char _nodeerror);
  
  unsigned char get_nodeerror();

  unsigned char pdobuffer[8];
  
  void buf2pdobuf();
  
  void pdobuf2buf();
  
  rlCanOpenTypes& operator = (rlCanOpenTypes &cp); 
  
  IPCMSGSTRUCT createIpcMsg();

  void getIpcMsg(IPCMSGSTRUCT _myIpcMsg);

  void rlMsgErrOut();

  
  char* rlMsgErrStr();  

  char* type2str(int _typenr);


  bool translate_CanOpenType(int _canopentype);
  int  get_CanOpenTypeLength(int _canopentype);

  private:
  
  void invalidTypeError(int _typenr);
  

  int typenumber; 

  long rlmsgerr; 


  //all different types are stored together in the same data area
  union {
    int t_int;                      //   4 Bytes   0x00
    float t_float;                  //   4 Bytes   0x01
    double t_double;                //   8 Bytes   0x02
    short t_short;                  //   2 Bytes   0x03
    unsigned short t_ushort;        //   2 Bytes   0x04
    long int t_longlong;           //   8 Bytes   0x05
    char t_string[247];             // 246 Bytes   0x06
    unsigned char t_databytes[247]; // 246 Bytes   0x07    
    unsigned char t_databyte;       //   1 Byte    0x08
    bool t_bool;                    //   1 Byte    0x09
    long t_long;                    //   4 Bytes   0x0A
    unsigned long t_ulong;          //   4 Bytes   0x0B
    unsigned long int t_ulonglong; //   8 Bytes   0x0C
      //                  Error =>                 0xFF
    struct
    {
      unsigned char    bNodeNoResponse   : 1; /* no response */
      unsigned char    bEmcyBuffOverflow : 1; /* emcy.buffer overflow */
      unsigned char    bPrmFault         : 1; /* parameters faulty */
      unsigned char    bGuardActive      : 1; /* node guarding active */
      unsigned char    bDeactivated      : 1; /* not configured */
      unsigned char    bNodeState;
      #define DISCONNECTED       1
      #define CONNECTING         2
      #define PREPARING          3
      #define PREPARED           4
      #define OPERATIONAL        5
      #define PRE_OPERATIONAL  127
      unsigned char  bActualError;
    } bNodeFlagState;
  }; 

};



/*
  MSG_SEND    0
  MSG_RECEIVE 1

#define MSG_SDO_READ 0
#define MSG_SDO_WRITE 1
#define MSG_PDO_RECEIVE 3
#define MSG_CONNECT 5
#define MSG_DISCONNECT 6
#define MSG_PDO_TRANSMIT 4
#define MSG_NMT_TRANSMIT 7
#define MSG_RESTART_BOARD 8
#define MSG_GET_NODE_STATE 9
*/

struct IPCMSGSTRUCT
{
  long typenumber;
 /* msgtype can be one of this values
    MSG_SDO_READ       0
    MSG_SDO_WRITE      1
    MSG_PDO_RECEIVE    3
    MSG_CONNECT        5
    MSG_DISCONNECT     6
    MSG_PDO_TRANSMIT   4
    MSG_NMT_TRANSMIT   7
    MSG_RESTART_BOARD  8
    MSG_GET_NODE_STATE 9  */
  long msgtype; 
  
 /* transfer type can be one of this values
    MSG_SEND    0
    MSG_RECEIVE 1 */
  long transfertype; 
  
  long processid;
  long boardid;
  long nodeid;
  long objectindex;
  long subindex;
  long pdoid;
  long mappingid;
  long rlmsgerr;
  char mtext[247];
};