EcSlaveTrack.h

#ifndef ECSLAVETRACK_H
#define ECSLAVETRACK_H

#include "EcSlave.h"
#include "EcError.h"
#include "EcErrorSGDV.h"
extern "C"
{
#include <soem/ethercattype.h>
#include <soem/ethercatbase.h>
#include <soem/ethercatmain.h>
#include <soem/ethercatconfig.h>
#include <soem/ethercatdc.h>
#include <soem/nicdrv.h>
#include <soem/ethercatcoe.h>
#include <soem/ethercatsoe.h>
#include <soem/ethercatprint.h>
}

#include <boost/signals2/signal.hpp>
#include <vector>
#include <iostream>
#include <mutex> 

//MTD objects
typedef enum
{
    CONTROL_WORD        = 0x0086, //(S-0-0134)
    TARGET_POSITION     = 0x002F, //(S-0-0047)
    TARGET_VELOCITY     = 0x0024, //S-0-0036) 
    TARGET_TORQUE       = 0x0050, //(S-0-0080)
}EcRecieveObjects;

//AT objects
typedef enum
{
    STATUS_WORD         = 0x0087, //(S-0-0135)
    ACTUAL_POSITION_1   = 0x0033, //(S-0-0051)
        ACTUAL_POSITION_2       = 0x0035, //(S-0-0053)
    ACTUAL_VELOCITY     = 0x0028, //(S-0-0040)
    ACTUAL_TORQUE       = 0x0054, //(S-0-0084)
}EcTransmitObjects;

//MTD Entries
typedef enum
{
    FIRST_ENTRY, // first = 0
    SECOND_ENTRY,
    THIRD_ENTRY,
    FOURTH_ENTRY,
    FIFTH_ENTRY,
    SIXTH_ENTRY,
    SEVENTH_ENTRY,
    EIGHTH_ENTRY,
    NINTH_ENTRY,
    TENTH_ENTRY,
    ELEVENTH_ENTRY,
    TWELFTH_ENTRY,
    THIRTEENTH_ENTRY,
    FOURTEENTH_ENTRY,
    FIFTEENTH_ENTRY,
}EcPDOEntry;

typedef enum
{
    VZ0 =0, //MDT: no cyclic data, AT: no cyclic data
    VZ1 =1, //MDT: S-0-0080 torque command, AT: no cyclic data
    VZ2 =2, //MDT: S-0-0036 velocity command, AT: S-0-0040 velocity feedback
    VZ3 =3, //MDT: S-0-0036 velocity command, AT: S-0-0051/53 position feedback 1/2
    VZ4 =4, //MDT: S-0-0047 position command, AT: S-0-0051/53 position feedback 1/2
    VZ5 =5, //MDT: S-0-0047 position command and S-0-0036 velocity command, AT:S-0-0051/53 position feedback 1/2 and S-0-0040 velocity feedback
    VZ6 =6, //MDT: S-0-0036 velocity command, AT: no cyclic data
    VZ7 =7, //Configurable, you will need to set up the telegrams by yourself using the functions setMDT and setAT
}EcTelegramType;


typedef enum
{
    TORQUE_CONTROL =1,
    VELOCITY_CONTROL =2,
    POSITION_CONTROL =3,
    DRIVEINTERNALINTERPOLATION_CONTROL =19,
}EcMode;

//ControlWord S-0-0134
typedef enum
{
        
        CW_DRIVE_ENABLE        =  0x4000, //Bit 14 a 1, 
        CW_DRIVE_DISABLE       =  0x0000, //TODO A 0
        CW_DRIVE_ON            =  0xC000, //0x4000+0x8000 Bit 15 y 14 a 1,
        CW_DRIVE_OFF           =  0x4000, //bit 15 a 0, 14 a 1.
        CW_DRIVE_HALT          =  0xE000, //0x4000+0x8000+0x2000, bits 13,14,15 a 1
        CW_PRIMARY_MODE        =  0xC000, //
        CW_SECONDARY_MODE_1    =  0xC800,
        CW_SECONDARY_MODE_2    =  0xC200,
        CW_SECONDARY_MODE_3    =  0xCA00,
        CW_SECONDARY_MODE_4    =  0xC100,
        CW_SECONDARY_MODE_5    =  0xC900,
        CW_SECONDARY_MODE_6    =  0xC300,
        CW_SECONDARY_MODE_7    =  0xCB00,
        
   
}EcControlWord;

//StatusWord values CARRIL P-0-0116
/*typedef enum
{
        SW_BBRELAY_CONTROL                                      =   0x01,
        SW_DRIVE_READY                                          =   0x02,
        SW_DRIVE_FOLLOW_COMAND                          =   0x08,
        SW_DRIVE_HALT_ON                                        =   0x10,
        SW_CHANGE_COMMAND_STATUS                        =   0x20,
        SW_OPERATION_MODE_INITIALIZED           =   0x80,
        SW_PRIMARY_MODE                                         =   0x00, //BITS 8/9/11 a 0
        SW_SECONDARY_MODE_1                                     =   0x0800,
        SW_SECONDARY_MODE_2                                     =   0x0200,
        SW_SECONDARY_MODE_3                                     =   0x0A00,
        SW_SECONDARY_MODE_4                                     =   0x0100,
        SW_SECONDARY_MODE_5                                     =   0x0900,
        SW_SECONDARY_MODE_6                                     =   0x0300,
        SW_SECONDARY_MODE_7                                     =   0x0B00,
        SW_DRIVE_ERROR                                          =   0x2000,
        SW_CONTROL_READY                                =   0x8000,
        SW_CONTROL_POWER_READY                          =       0x4000,
        SW_DRIVE_TORQUE                                         =       0xC000,
}EcStatusWord2;
*/

//StatusWord values CARRIL S-0-0135, hay que comprobar bit a bit, con un & o algo asi
typedef enum
{
        SW_NOT_READY                                            =   0x00, //drive not ready for power on, because internal checks not positively completed
        SW_READY                                                        =   0x4000, //ready for power on
        SW_READY_FREE                                           =   0x8000, //control section and power section ready for operation, torque-free
        SW_READY_COMPL                                          =   0xC000, //in operation, with torque
        SW_CHANGE_COMMAND_STATUS                        =   0x20,
        SW_OPERATION_MODE_INITIALIZED           =   0x80,
        SW_PRIMARY_MODE                                         =   0x00, //BITS 8/9/11 a 0
        SW_SECONDARY_MODE_1                                     =   0x0100,
        SW_SECONDARY_MODE_2                                     =   0x0200,
        SW_SECONDARY_MODE_3                                     =   0x0300,
        SW_SECONDARY_MODE_4                                     =   0x0400,
        SW_SECONDARY_MODE_5                                     =   0x0500,
        SW_SECONDARY_MODE_6                                     =   0x0600,
        SW_SECONDARY_MODE_7                                     =   0x0700,
        
}EcStatusWord;

typedef struct
{
    std::string name;
    unsigned int offset;
    unsigned int byteSize;
    std::string type;
}PDOobject;    

namespace cpp4ec
{
class EcSlaveTrack: public EcSlave
{
public:
    EcSlaveTrack (ec_slavet* mem_loc);
    
    ~EcSlaveTrack();
    
    const std::string& getName() const;
    
    bool configure() throw(EcErrorSGDV);
    
     void start() throw(EcErrorSGDV);
    
    void update(); 
    
     void stop() throw(EcErrorSGDV);

    void setPDOBuffer(char * input, char * output);
    
    void setDC(bool active, unsigned int sync0Time, unsigned int sync0Shift) throw(EcErrorSGDV);

    bool writeMDT (EcPDOEntry entry, int value)throw(EcErrorSGDV);
    
    bool readAT (EcPDOEntry entry, int &value);
    
    bool writeControlWord (uint16_t controlWord);
    
    bool readStatusWord (uint16_t &statusWord);

    bool writePosition (int32_t position);
    
    bool readPosition (int32_t &position);
    
    bool writeVelocity (int32_t velocity);
    
    bool readVelocity (int32_t &velocity);
    
    bool writeTorque (int16_t torque);
    
    bool readTorque (int16_t &torque);
    
    void setSGDVOject(uint16_t idn, uint8_t elementflags, int psize, void * param);
    
    void getSGDVObject(uint16_t idn, uint8_t elementflags, int *psize, void *param); 

    std::vector<int> readIDNofIDNs(int idn, bool print);

    void setMDT(std::vector<int> listidn);

    void setAT(std::vector<int> listidn);

    void modeSetUp(EcMode mode, int nmode);

    void TelegramType(EcTelegramType type);

    void DefaultParameters();

    void ClearError();



    
//    void refresh();
    boost::signals2::signal<void (int, uint16_t, int32_t, int32_t, int16_t)> slaveValues;


private:

    //Variables used for the properties
    bool useDC;
    unsigned int PDOerrorsTolerance;
    unsigned int SYNC0TIME;
    unsigned int SHIFT;
    unsigned int SHIFTMASTER;
    
    int minPosition;
    int maxPosition;
    int initPosition;
    int m_mutex;
    
    int outputSize;
    int inputSize;
    
    int transmitEntry;
    int recieveEntry;
    
    void readXML() throw(EcErrorSGDV);
    bool addPDOobject(std::string PDOentry,int value, int subindex);
    
    int controlWordEntry;
    int targetPositionEntry;
    int targetVelocityEntry;
    int targetTorqueEntry;
    int statusWordEntry;
    int actualPositionEntry;
    int actualVelocityEntry;
    int actualTorqueEntry;
    
    bool wControlWordCapable;
    bool wPositionCapable;
    bool wVelocityCapable;
    bool wTorqueCapable;
    bool rStatusWordCapable;
    bool rPositionCapable;
    bool rVelocityCapable;
    bool rTorqueCapable;
    
    char* outputBuf;
    char* inputBuf;
    char* inputNull;
    char* pBufferOut;
    char* pBufferIn;
    

    
    std::mutex slaveInMutex;
    std::mutex slaveOutMutex;

    std::vector <SoEparameter> m_params;
    std::vector <PDOobject> inputObjects;
    std::vector <PDOobject> outputObjects;
    std::vector <char*> bufferList;
};
}
#endif