M_MOTCOM.H

gehe zur Dokumentation dieser Datei

//#############################################################################
//                                                                           //
// M_MOTCOM.H                                                                //
// Subsystem: Motorsteuerung                                                 //
// Benutzung durch andere Subsysteme erforderlich: JA                        //
// Implementation: MOTORS.CPP                                                //
//                                                                           //
//---------------------------------------------------------------------------//
// Autoren: Heiko Damerow MPG AG "Roentgenbeugung" (C) 1993,94               //
// Stand:   05.08.2002                                                       //
//                                                                           //
//#############################################################################

//-----------------------------------------------------------------------------
// ÄNDERUNGEN : Kullmann, Reinecker (04.08.02) TMotor, TMList
//
// - einheitlich strukturiert, formatiert und kommentiert
// - Sinneinheiten zusammengefaßt
// - stärkere Datenkapselung und neue Methoden für Memberzugriff in TMotor
// - explizite inline Deklaration
// - unnötige friend Deklarationen und Toten Code auskommentiert
// - Klasse TMotor exportiert
//-----------------------------------------------------------------------------

#ifndef __M_MOTCOM_H
#define __M_MOTCOM_H

#include "internls\evrythng.h" // TUnitType

#if defined (Build_Motors)
#define _MOTORCLASS __declspec(dllexport)
#elif defined(Use_Motors)
#define _MOTORCLASS __declspec(dllimport)
#else
#define _MOTORCLASS
#endif

//--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--

const UINT _MAXLENCHARACTERISTIC= 50; //max. 50 Zeichen als Motorbezeichnung
const UINT _MAXLENUNIT= 20; //max. 20 Zeichen als Einheit eines Antriebs
const UINT _MAXLENFORMAT= 5; //max. 6 Zeichen als Zahlenformat (z.B. "%f:3")

//-----------------------------------------------------------------------------

/* Benutzt in m_layer.h/cpp, m_steerg.cpp, m_motcom.h, motors.cpp */
enum EAxisType
{
        X= 1, Y, Z, Omega, Theta, Phi, Psi, Encoder, Absorber, Tilt, Collimator,
        Rotation, Monochromator, DC, DF
};

//-----------------------------------------------------------------------------
/* Benutzt in m_motcom.h, m_layer.h/cpp, motors.cpp */
enum EMParameter
{
        ThisPosition= 1, OldPosition, WaitExecution, NoWait
};

//-----------------------------------------------------------------------------

enum ECorrect
{
        CorrLinear= 1, CorrPolynom
};
//-----------------------------------------------------------------------------

enum ETrans
{
        ToAngle= 1, ToPosition
};
//-----------------------------------------------------------------------------

struct TMSettings
{
        double dAngleMin, dAngleMax, dAngle, dSpeed, dAngleWidth;
};

//----------------------------------------------------------------------------------------
//                                     TMotor
//----------------------------------------------------------------------------------------
class _MOTORCLASS TMotor
{
        //friend  class   TMList;
        //friend  class   TCalibrateDlg;
        //friend  class   TPositionControl; war sowieso TPosControlDlg gemeint
        //friend  class   TMotorParamDlg;
        //----------------------------------------------------------------------------------------
public:
        TMotor( void );
        virtual ~TMotor( void )
        {}
        ;
        //----------------------------------------------------------------------------------------
public:
        int GetId ( void ) // Index in der Antriebsliste (TMList)
        {
                return nId;
        }; 
        static int GetMaxId ( void )
        {
                return nMaxId;
        };
        LPCSTR pCharacteristic ( void ) // Antriebsbezeichnung
        {
                return (LPCSTR)szCharacteristic;
        }; 
        // aktuelle Antriebsposition in Nutzereinheiten
        BOOL GetAngle ( BOOL ); // aktualisiert NUR bei Stillstand den Wert in dAngle um dAngleBias korrigiert
        double GetAngle ( BOOL, BOOL& ); // ruft GetAngle( BOOL ) und gibt dAngle zurück
        double GetAngle ( void ) // zu zuletzt mit GetAngle( BOOL ) ausgelesenen (und um dAngleBias korrigierten) Wert zurückgeben
        {
                return dAngle;
        };
        double GetAngleAbs ( BOOL, BOOL& );  // aktualisiert NUR bei Stillstand den Wert in dAngle OHNE Korrektur
        // minimale Antriebsposition in Nutzereinheiten
        double GetAngleMin ( void )
        {
                return dAngleMin;
        };
        void SetAngleMin ( double aAngle )
        {
                dAngleMin= aAngle;
        };
        double GetAngleRelativeMin ( void );
        // maximale Antriebsposition in Nutzereinheiten
        double GetAngleMax ( void )
        {
                return dAngleMax;
        };
        void SetAngleMax ( double aAngle )
        {
                dAngleMax= aAngle;
        };
        double GetAngleRelativeMax ( void );
        // Schrittweite in Nutzereinheiten
        double GetAngleWidth ( void )
        {
                return dAngleWidth;
        };
        BOOL SetAngleWidth ( double );
        // minimale / maximale Schrittweite in Nutzereinheiten
        double GetMinAngleWidth( void );
        double GetMaxAngleWidth( void );
        // Bewegung durchführen
        BOOL MoveToAngle ( double );
        BOOL MoveByAngle ( double );
        // Offset und relative Null in Nutzereinheiten
        double GetAngleBias ( void )
        {
                return dAngleBias;
        };
        BOOL SetAngleBias ( double );
        BOOL SetRelativeZero ( void );
        BOOL ResetRelativeZero ( void );
        BOOL IsDistanceRelative ( void );

        double GetMinSpeed ( void ); // Minimalgeschwindigkeit in Nutzereinheiten
        double GetMaxSpeed ( void ); // Maximalgeschwindigkeit in Nutzereinheiten
        double GetAcceleration ( void ); // Beschleunigung in Nutzereinheiten
        // Einstellungen lesen / schreiben
        BOOL PushSettings ( void );
        BOOL PopSettings ( EMParameter );

        UINT GetDigits ( void ); // Anzahl der Nachkommastellen (nDigits)
        LPCSTR pSF ( void ) // Format für Nachkommastellengenauigkeit der Schrittweiten
        {
                return (LPCSTR)SFmt;
        };
        LPCSTR pDF ( void ) // Format für Nachkommastellengenauigkeit der Winkelwerte
        {
                return (LPCSTR)DFmt;
        };

        BOOL IsRangeHit ( void )
        {
                return bRangeHit;
        };
        BOOL SetAngleRange ( void );
        DWORD GetLimit ( void )
        {
                return dwRemoveLimit;
        };
        // aktuelle Position in Encoderschritten
        long GetPosition ( void )
        {
                return lPosition;
        };
        void SetDeltaPosition ( long aPos )
        {
                lDeltaPosition= aPos;
        };
        // minimale Position in Encoderschritten
        long GetPositionMin ( void )
        {
                return lPositionMin;
        };
        void SetPositionMin ( long aPos)
        {
                lPositionMin= aPos;
        };
        // maximale Position in Encoderschritten
        long GetPositionMax ( void )
        {
                return lPositionMax;
        };
        void SetPositionMax ( long aPos)
        {
                lPositionMax= aPos;
        };
        float GetMinPrecision(bool stepWidth=false) 
        {
                UINT digits= GetDigits();               
                if ( stepWidth ) digits++;
                return ( 1 / (float)pow((float)10, (float)digits) ); 
        };
        // Schrittweite in Encoderschritten
        WORD GetPositionWidth ()
        {
                return max( wPositionWidth, GetMinPrecision(true) ); // verhindert die Rückgabe von 0 und damit das leidige div 0
        };
        void SetPositionWidth ( WORD aWidth )
        {
                wPositionWidth= max( aWidth, GetMinPrecision(true) );
        };
        // Einheit des Antriebs
        EUnitType GetUnit ( void )
        {
                return eUnit;
        };
        LPCSTR GetUnitName ( void )
        {
                return szUnit;
        };

        long GetDistanceToZero ( void )
        {
                return lDistanceToZero;
        };
        void SetDistanceToZero ( long aDist)
        {
                lDistanceToZero= aDist;
        };

        double GetInitialAngle ( void )
        {
                return dInitialAngle;
        };
        BOOL IsInitialMoveReady ( void )
        {
                return bInitialMoveReady;
        }
        // Status des Refrenzpunktlaufs
        BOOL IsCalibrated ( void )
        {
                return bIsCalibrated;
        }
        void SetCalibrationState ( BOOL state )
        {
                bIsCalibrated= state;
        }
        void SetCorrectionState ( BOOL );

        //long    PreviousPosition( void ) { return lPreviousPosition; }; (Toter Code, am 02.08.02 auskommentiert)
        //----------------------------------------------------------------------------------------
public:
        virtual void OptimizingDlg( void )
        {
                return;
        }
        virtual void StartCheckScan( void )
        {
                return;
        }
        virtual BOOL SetLimit( DWORD )
        {
                return TRUE;
        }
        virtual BOOL SetLine( int, BOOL )
        {
                return TRUE;
        }

        virtual BOOL StartLimitWatch( void )
        {
                return R_OK;
        }
        virtual BOOL StopLimitWatch( void )
        {
                return R_OK;
        }

        virtual int ExecuteCmd( LPSTR )
        {
                return R_OK;
        }
        virtual BOOL ActivateDrive( void )
        {
                return TRUE;
        }

        virtual BOOL IsMoveFinish( void )
        {
                return TRUE;
        }
        virtual BOOL IsLimitHit( void )
        {
                return TRUE;
        }
        virtual BOOL IsIndexArrived( void )
        {
                return TRUE;
        }

        virtual BOOL StartToIndex( long & )
        {
                return TRUE;
        }
        virtual BOOL StopDrive( BOOL )
        {
                return TRUE;
        } //Parameter geändert int -> BOOL (08.08.02)
        virtual BOOL GetPosition( BOOL )
        {
                return TRUE;
        }
        virtual long GetFailure( void )
        {
                return 0;
        }
        // Bewegung in Encoderschritten
        virtual BOOL MoveByPosition( long );
        virtual BOOL MoveToPosition( long );

        virtual BOOL SetHome( void );
        // Speed: Geschwindigkeit in Nutzereinheiten
        virtual double GetSpeed( void )
        {
                return 1.0;
        }
        virtual BOOL SetSpeed( double )
        {
                return TRUE;
        }

        virtual int SaveSettings( BOOL );
        virtual int Initialize( void );
        virtual WORD GetStatus( void )
        {
                return 0xFF;
        }

        //virtual float   GetMoment( void )  { return 1.0; };  (Toter Code, am 02.08.02 auskommentiert)
        //virtual BOOL    SetMoment( float ) { return TRUE; };  (Toter Code, am 02.08.02 auskommentiert)
        //----------------------------------------------------------------------------------------
        // ANFANG: Zugriff auf folgende Member eingeschränkt
protected:
        int nId;
        // Antriebsdaten in Encoderschritten
        long lPosition;
        long lDeltaPosition;
        long lPositionMax;
        long lPositionMin;
        WORD wPositionWidth;
        WORD wPositionMinWidth;
        WORD wPositionMaxWidth;
        // Antriebsdaten in Nutzereinheiten
        double dAngle;
        double dAngleBias;
        double dAngleWidth;
        double dAngleMin;
        double dAngleMax;
        double dInitialAngle;
        // Geschwindigkeit in Nutzereinheiten
        double dSpeed;
        float fSpeedScale;

        EUnitType eUnit;
        UINT nDigits;   // Kullmann, Reinecker: neuer Member
        BOOL bUpwards;
        BOOL bInquireStatus;
        BOOL bRangeHit;
        BOOL bIndexLine;
        BOOL bMoveFirstToLimit;
        BOOL bIndexDetected;
        BOOL bLimitWatchActive;
        BOOL bControlBoardOk;
        long lDistanceToZero;
        long lCorrPos;
        DWORD dwRemoveLimit;
        DWORD dwHysteresis;
        // Geschwindigkeit in Encoderschritten
        DWORD dwVelocity;
        DWORD dwMaxVelocity;
        DWORD dwAcceleration;
        char szUnit[ _MAXLENUNIT + 1 ];
        char SFmt[ _MAXLENFORMAT + 1 ];
        char DFmt[ _MAXLENFORMAT + 1 ];
        //long            lPreviousPosition;   (Toter Code, am 02.08.02 auskommentiert)

        // ENDE: Einschränkung
        //----------------------------------------------------------------------------------------
private:
        BOOL Translate( long&, double ); // Umrechnung von Nutzereinheiten(Angle) in Encoderschritte(Position)
        BOOL Translate( double&, long ); // Umrechnung von Encoderschritte(Position) in Nutzereinheiten(Angle um den Offset korrigiert)
        BOOL TranslateAbs( double&, long ); // Umrechnung von Encoderschritte(Position) in Nutzereinheiten
        void funcd( double arg, double offset, double* f, double* df );
        int rtsave( double offset, double x1, double x2, double xacc, double* ret );
        //----------------------------------------------------------------------------------------
private:
        BOOL bIsCalibrated;
        BOOL bInitialMoveReady;
        static int nMaxId;
        double dKoeff_3;
        double dKoeff_2;
        double dKoeff_1;
        DWORD dwInterval;
        BOOL bCorrection;
        float fCorrBias;
        ECorrect eCorrStatus;
        char szCharacteristic[ _MAXLENCHARACTERISTIC + 1 ];
        TMSettings Settings;
};

//----------------------------------------------------------------------------------------
//                                     TMList
//----------------------------------------------------------------------------------------
class _MOTORCLASS TMList
{
public:
        TMList( int );  // zweiten Parameter HINSTANCE entfernt (08.08.02)
        virtual  ~TMList( void );

private:
        TMList( const TMList& ) {} // Copy-Konstruktor nicht nutzbar

//----------------------------------------------------------------------------------------
public:
        int AD_Z, AD_Y, AD_X;
        int AD_Tilt, AD_DC, AD_Collimator, AD_DF;
        int AD_Encoder;
        int AD_Phi;
        int AD_Psi;
        int AD_Rotation;
        int AD_Absorber, AD_Monochromator;
        int AD_Theta;
        int AD_Omega;
        //----------------------------------------------------------------------------------------
public:
        TMotor *MP( void );
        TMotor *MP( int );
        void SetAngleDefault( void );
        void PositionControlDlg( void );
        void SetParametersDlg( void );
        void InquireReferencePointDlg( BOOL );
        BOOL InitializeModule( void );
        BOOL SaveModuleSettings( void );
        BOOL SetAxis( int );
        int GetAxis( void )
        {
                return nActiveDrive;
        };
        int LastId( void )
        {
                return nLastDrive;
        };
        //HINSTANCE  GetModuleHandle( void )   { return hMInstance; };  (Toter Code, am 08.08.02 auskommentiert)
        int GetAxisNumber( void )
        {
                return ( nLastDrive + 1 );
        };

        static EAxisType ParsingAxis( LPCSTR );
        //----------------------------------------------------------------------------------------
private:
        //HINSTANCE hMInstance;  (Toter Code, am 08.08.02 auskommentiert)
        int nMaxNumber;
        int nLastDrive;   // points the last axis
        int nActiveDrive; // points the actual axis
        TMotor** aMotor;
};
//----------------------------------------------------------------------------------------

typedef TMList FAR * LPMList;
typedef TMotor FAR * LPMotor;
#endif 
// __LastLine__

---