CanCtrlPltfCOb3.h

Go to the documentation of this file.

/*
 * Copyright 2017 Fraunhofer Institute for Manufacturing Engineering and Automation (IPA)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 
#ifndef CANCTRLPLTFCOB3_INCLUDEDEF_H
#define CANCTRLPLTFCOB3_INCLUDEDEF_H
 
//-----------------------------------------------
 
// general includes
 
// Headers provided by other cob-packages
#include <cob_canopen_motor/CanDriveItf.h>
#include <cob_canopen_motor/CanDriveHarmonica.h>
#include <cob_generic_can/CanItf.h>
 
// Headers provided by cob-packages which should be avoided/removed
#include <cob_utilities/IniFile.h>
#include <cob_utilities/Mutex.h>
 
// remove (not supported)
//#include "stdafx.h"
 
 
//-----------------------------------------------
 
class CanCtrlPltfCOb3 // : public CanCtrlPltfItf
{
public:
 
        //--------------------------------- Basic procedures
 
        CanCtrlPltfCOb3(std::string iniDirectory);
 
        ~CanCtrlPltfCOb3();
 
 
        //--------------------------------- Hardware Specification
 
        enum MotorCANNode
        {
                CANNODE_WHEEL1DRIVEMOTOR,
                CANNODE_WHEEL1STEERMOTOR,
                CANNODE_WHEEL2DRIVEMOTOR,
                CANNODE_WHEEL2STEERMOTOR,
                CANNODE_WHEEL3DRIVEMOTOR,
                CANNODE_WHEEL3STEERMOTOR,
                CANNODE_WHEEL4DRIVEMOTOR,
                CANNODE_WHEEL4STEERMOTOR
        };
 
 
        //--------------------------------- Commands for all nodes on the bus
 
        bool initPltf();
 
        bool resetPltf();
 
        bool isPltfError();
 
        bool shutdownPltf();
 
        bool startWatchdog(bool bStarted);
 
        int evalCanBuffer();
 
 
        //--------------------------------- Commands specific for motor controller nodes
 
        int setVelGearRadS(int iCanIdent, double dVelGearRadS);
 
        void setMotorTorque(int iCanIdent, double dTorqueNm);
 
        void requestDriveStatus();
 
        int requestMotPosVel(int iCanIdent);
 
        void requestMotorTorque();
 
        int getGearPosVelRadS(int iCanIdent, double* pdAngleGearRad, double* pdVelGearRadS);
 
        int getGearDeltaPosVelRadS(int iCanIdent, double* pdDeltaAngleGearRad, double* pdVelGearRadS);
 
        void getStatus(int iCanIdent, int* piStatus, int* piTempCel);
 
        void getMotorTorque(int iCanIdent, double* pdTorqueNm);
 
 
 
        //--------------------------------- Commands specific for a certain motor controller
        // have to be implemented here, to keep the CanDriveItf generic
 
        int ElmoRecordings(int iFlag, int iParam, std::string sString);
 
        //--------------------------------- Commands for other nodes
 
 
 
 
protected:
 
        //--------------------------------- internal functions
 
        std::string sIniDirectory;
        std::string sComposed;
        void readConfiguration();
 
        void sendNetStartCanOpen();
 
 
        //--------------------------------- Types
 
        struct ParamType
        {
                // Platform config
 
                int iHasWheel1DriveMotor;
                int iHasWheel1SteerMotor;
                int iHasWheel2DriveMotor;
                int iHasWheel2SteerMotor;
                int iHasWheel3DriveMotor;
                int iHasWheel3SteerMotor;
                int iHasWheel4DriveMotor;
                int iHasWheel4SteerMotor;
 
                double dWheel1SteerDriveCoupling;
                double dWheel2SteerDriveCoupling;
                double dWheel3SteerDriveCoupling;
                double dWheel4SteerDriveCoupling;
 
                double dHomeVeloRadS;
 
                int iRadiusWheelMM;
                int iDistSteerAxisToDriveWheelMM;
 
                int iHasRelayBoard;
                int iHasIOBoard;
                int iHasUSBoard;
                int iHasGyroBoard;
                int iHasRadarBoard;
 
                double dCanTimeout;
        };
 
        struct GearMotorParamType
        {
                int             iEncIncrPerRevMot;
                double  dVelMeasFrqHz;
                double  dGearRatio;
                double  dBeltRatio;
                int             iSign;
                double  dVelMaxEncIncrS;
                double  dAccIncrS2;
                double  dDecIncrS2;
                double  dScaleToMM;
                int     iEncOffsetIncr;
                bool    bIsSteer;
                double  dCurrentToTorque;
                double  dCurrMax;
                int     iHomingDigIn;
        };
 
        struct CanNeoIDType
        {
                int IOBoard_rx_ID;
                int IOBoard_tx_ID;
 
                int DriveNeo_W1Drive_rx_ID;
                int DriveNeo_W1Drive_tx_ID;
                int DriveNeo_W1Steer_rx_ID;
                int DriveNeo_W1Steer_tx_ID;
 
                int DriveNeo_W2Drive_rx_ID;
                int DriveNeo_W2Drive_tx_ID;
                int DriveNeo_W2Steer_rx_ID;
                int DriveNeo_W2Steer_tx_ID;
 
                int DriveNeo_W3Drive_rx_ID;
                int DriveNeo_W3Drive_tx_ID;
                int DriveNeo_W3Steer_rx_ID;
                int DriveNeo_W3Steer_tx_ID;
 
                int DriveNeo_W4Drive_rx_ID;
                int DriveNeo_W4Drive_tx_ID;
                int DriveNeo_W4Steer_rx_ID;
                int DriveNeo_W4Steer_tx_ID;
 
                int USBoard_rx_ID;
                int USBoard_tx_ID;
                int GyroBoard_rx_ID;
                int GyroBoard_tx_ID;
                int RadarBoard_rx_ID;
                int RadarBoard_tx_ID;
        };
 
        struct CanOpenIDType
        {
                // Wheel 1
                // can adresse motor 1
                int TxPDO1_W1Drive;
                int TxPDO2_W1Drive;
                int RxPDO2_W1Drive;
                int TxSDO_W1Drive;
                int RxSDO_W1Drive;
                // can adresse motor 2
                int TxPDO1_W1Steer;
                int TxPDO2_W1Steer;
                int RxPDO2_W1Steer;
                int TxSDO_W1Steer;
                int RxSDO_W1Steer;
 
                // Wheel 2
                // can adresse motor 7
                int TxPDO1_W2Drive;
                int TxPDO2_W2Drive;
                int RxPDO2_W2Drive;
                int TxSDO_W2Drive;
                int RxSDO_W2Drive;
                // can adresse motor 8
                int TxPDO1_W2Steer;
                int TxPDO2_W2Steer;
                int RxPDO2_W2Steer;
                int TxSDO_W2Steer;
                int RxSDO_W2Steer;
 
                // Wheel 3
                // can adresse motor 5
                int TxPDO1_W3Drive;
                int TxPDO2_W3Drive;
                int RxPDO2_W3Drive;
                int TxSDO_W3Drive;
                int RxSDO_W3Drive;
                // can adresse motor 6
                int TxPDO1_W3Steer;
                int TxPDO2_W3Steer;
                int RxPDO2_W3Steer;
                int TxSDO_W3Steer;
                int RxSDO_W3Steer;
 
                // Wheel 4
                // can adresse motor 3
                int TxPDO1_W4Drive;
                int TxPDO2_W4Drive;
                int RxPDO2_W4Drive;
                int TxSDO_W4Drive;
                int RxSDO_W4Drive;
                // can adresse motor 4
                int TxPDO1_W4Steer;
                int TxPDO2_W4Steer;
                int RxPDO2_W4Steer;
                int TxSDO_W4Steer;
                int RxSDO_W4Steer;
        };
 
        //--------------------------------- Parameter
        ParamType m_Param;
//      CanNeoIDType m_CanNeoIDParam;
        CanOpenIDType m_CanOpenIDParam;
 
        // Prms for all Motor/Gear combos
        GearMotorParamType m_GearMotDrive1;
        GearMotorParamType m_GearMotDrive2;
        GearMotorParamType m_GearMotDrive3;
        GearMotorParamType m_GearMotDrive4;
        GearMotorParamType m_GearMotSteer1;
        GearMotorParamType m_GearMotSteer2;
        GearMotorParamType m_GearMotSteer3;
        GearMotorParamType m_GearMotSteer4;
 
        //--------------------------------- Variables
        CanMsg m_CanMsgRec;
        Mutex m_Mutex;
        bool m_bWatchdogErr;
 
        //--------------------------------- Components
        // Can-Interface
        CanItf* m_pCanCtrl;
        IniFile m_IniFile;
 
        int m_iNumMotors;
        int m_iNumDrives;
 
        // Motor-Controllers
/*      CanDriveItf* m_pW1DriveMotor;
        CanDriveItf* m_pW1SteerMotor;
        CanDriveItf* m_pW2DriveMotor;
        CanDriveItf* m_pW2SteerMotor;
        CanDriveItf* m_pW3DriveMotor;
        CanDriveItf* m_pW3SteerMotor;
        CanDriveItf* m_pW4DriveMotor;
        CanDriveItf* m_pW4SteerMotor;*/
        // pointer to each motors Can-Itf
        std::vector<CanDriveItf*> m_vpMotor;
        // vector with enums (specifying hardware-structure) -> simplifies cmd-check
        // this has to be adapted in c++ file to your hardware
        std::vector<int> m_viMotorID;
 
        // other
 
 
};
 
 
//-----------------------------------------------
#endif