MomentumWheel.h

Go to the documentation of this file.

/************************************************************************************************/
/*! \file MomentumWheel.h
*  \brief The MomentumWheel class provides the interface for h/w momentum wheels.
*  \author $Author: jayhawk_hokie $
*  \version $Revision: 1.30 $
*  \date    $Date: 2007/07/24 09:39:38 $
************************************************************************************************/
/*! 
*
************************************************************************************************/

#ifndef __SSSL_MOMENTUMWHEEL_H__
#define __SSSL_MOMENTUMWHEEL_H__

// System Includes
        #include <string>
        #include <map>

// DSACSS Includes
        #include "PhysicalMomentumWheel.h"
        #include <Base/Actuator.h>
        #include <matrix/Matrix.h>
        #include <Utils/Misc.h>
        #include <Logging/WheelHistory.h>
        // Xml Parsing
        #include <dsacssinterface.h>

using namespace std;
using namespace O_SESSAME;

/*! Class to interface with momentum wheels */
class MomentumWheel : public Actuator  
{
public:
        //////////////////////////////////////////
        // Contructors/Deconstructors
        //////////////////////////////////////////

        /*! \brief Default Constructor */
        MomentumWheel( );
    
        /*! \brief Constructor that accepts a cfgBody variable sent from the cfgPars function 
         *  @param handle is a TiXmlHandle type that has the wheel configuration parameters. 
         *  @param wheel is a string that specifies the wheel.
         */
        MomentumWheel( TiXmlHandle handle, string wheel );
    
        /*! \brief Deconstructor */
        virtual ~MomentumWheel( );

        //////////////////////////////////////////
        // Facilitators
        //////////////////////////////////////////

        /*! \brief Initialize the wheels */
        int Initialize( TiXmlHandle handle, string wheel );   
 
        /*! \brief Deinitialize the wheels */
        int Deinitialize( );   

        /*! \brief Stop the wheel
         *  Calls PhysicalMomentumWheel::Stop( )
         */
        int Stop( );

        /*! \brief Enable torque mode for the wheel motor.
         *  Calls PhysicalMomentumWheel::TorqueCommand( int _power )
         *  @param _power is the voltage to be commanded in Torque Mode
         */
        int TorqueCommand( double _power );

        /*! \brief Start the speed reading routine of the motor in a separate thread. Calls
         *  PhysicalMomentumWheel::StartSpeedQuery( )
         */
        void StartSpeedQuery( );
        
        /*! \brief Stop the speed reading routine of the motor.  This function does not need to be called a t the end of the program.
         *  Calls PhysicalMomentumWheel::StopSpeedQuery( )
         *  The thread will be closed automatically when the program ends. 
         */
        void StopSpeedQuery( );
        
        /*! \brief Set the torque applied to the wheel
         *  Calls PhysicalMomentumWheel::CommandWheelTorque(  double _wheelTorque )
         *  @param wheelTorque The desired wheel torque in N-m
         */
        void SetWheelTorque( double wheelTorque ); 

        /*! \brief Set the desired wheel speed. The wheel controller is running in a thread and this function
         *  updates the desired wheel rate value passed to the wheel controller.
         *  Calls PhysicalMomentumWheel::CommandWheelSpeed( double wheelOmega )
         *  @param wheelOmega The desired wheel angular velocity in rad/sec 
         */
        void SetWheelSpeed( double wheelOmega );   // will change wheelOmega if set different due to saturation
        
        /*! \brief Start the PID Control Thread 
         *  Calls PhysicalMomentumWheel::StartPID( )
         */
        void StartPID( );
        
        /*! \brief End the PID Control Thread (will be called by the deconstructor)
         *  Calls PhysicalMomentumWheel::StopPID( )
         */
        void StopPID( );
        
        /*! \brief Set the old-style torque applied to the wheel
         *  Calls PhysicalMomentumWheel::CommandSystemTorque( double wheelTorque )
         *  @param wheelTorque The desired wheel torque in N-m
         */
        void SetSystemTorque(double wheelTorque);
    
        /*! \brief Set the wheel speed coefficients. The wheel speed coefficients are determined from the characterization of each wheel motor.
         *  Calls PhysicalMomentumWheel::SetWheelSpeedCoefficients( Vector _Coefficients1, Vector _Coefficients2, Vector _Coefficients3, Vector _Coefficients4 )
         *  @param _Coefficients1 a 4x1 vector of constants
         *  @param _Coefficients2 a 3x1 vector of constants
         *  @param _Coefficients3 a 3x1 vector of constants
         *  @param _Coefficients4 a 4x1 vector of constants
         */
        void SetWheelSpeedCoefficients( Vector _Coefficients1, Vector _Coefficients2, Vector _Coefficients3, Vector _Coefficients4 );

        //////////////////////////////////////////
        // Mutators
        //////////////////////////////////////////
    
        /*! \brief Set the address of the wheel on its daisy chain
         *  Calls PhysicalMomentumWheel::SetWheelAddress( int wheelAddress )
         *  @param wheeladdress an integer describing the address of the wheel*/
        void SetWheelAddress( int wheeladdress );
    
        /*! \brief Set the axis of rotation for the wheel
         *  @param newWheelAxis a 3x1 vector describing the wheel axis*/
        void SetWheelAxis( const Vector& newWheelAxis );

        /*! \brief Set communications port 
         *  Calls PhysicalMomentumWheel::SetDaisyChainNumber( int daisyChain )
         *  @param daisyChain A int specifying the daisy chain number 
         */
        void SetChainNumber( int daisyChain );
        
        /*! \brief Set communications port 
         *  Calls PhysicalMomentumWheel::SetDaisyChainPort( string DaisyChainPort );
         *  @param Port A string specifying the RS232 port ex. /dev/ttyUSB0
         */
        void SetPort( string Port );
    
        /*! \brief Set the bias wheel wheel speed for a Momentum wheel 
         *  Calls PhysicalMomentumWheel::SetBiasSpeed( double BiasSpeed )
         *  @param BiasSpeed A double specifying the bias speed
         */
        void SetBiasSpeed( double BiasSpeed );
    
        /*! \brief Set the axial inertia for a Momentum wheel
         *  Calls PhysicalMomentumWheel::SetAxialInertia( double axialInertia )
         *  @param axialInertia A double specifying the axial inertia kg-m^2
         */
        void SetAxialInertia( double axialInertia );

        /*! \brief Set the momentum wheel torque limits 
         *  Calls PhysicalMomentumWheel::SetWheelTorqueLimits( const double& minWheelTorque, const double& maxWheelTorque )
         *  @param torque_limit_low A double specifying low torque limit N-m
         *  @param torque_limit_high A double specifying high torque limit N-m
         */
        void SetWheelTorqueLimits( double torque_limit_low, double torque_limit_high );    

        /*! \brief Set the momentum wheel string name 
         *  Calls PhysicalMomentumWheel::SetWheelName( string _wheelName )
         *  @param _wheelName A string naming the wheel
         */
        void SetWheelName( string _wheelName );    
        
        //////////////////////////////////////////
        // Inspectors
        //////////////////////////////////////////

        /*! \brief Get the current angular speed of the wheel, returns the wheel speed in rad/sec.
         *  Calls PhysicalMomentumWheel::GetWheelSpeed( double& Speed, double& measTime )
         *  @param Speed double set to the current wheel speed
         *  @param measTime double set to the number of seconds since unix epoch when the velocity waas measured*/
        void GetWheelSpeed( double& Speed, double& measTime );

        /*! \brief Get the current torque output to the wheel, returns the value in N-m. This is not necessarily the
         *  torque being applied to the system. This value is determined from the smart motors. 
         *  Calls PhysicalMomentumWheel::QueryWheelTorque( )
         */
        double GetWheelTorque( );

        /*! \brief Get the axis of the wheel, returns a 3x1 vector */
        Vector GetWheelAxis( ) const;

        /*! \brief Returns an integer representing the total number of momentum wheels instantiated*/
        int GetWheelCount( );  

        /*! \brief Returns a double representing the axial inertia of the wheel in kg-m^2
         *  Calls PhysicalMomentumWheel::GetAxialInertia( )
         */
        double GetAxialInertia( );
        
        /*! \brief Returns a string representing the wheel name
         *  Calls PhysicalMomentumWheel::GetWheelName( )
         */
        string GetWheelName( );
        
        /*! \brief Get the file desciptor of the wheel. 
         *  Calls PhysicalMomentumWheel::GetWheelFD( )
         */
        int GetWheelFD( );
        
        /*! \brief Get the current used by the motor. 
         *  Calls PhysicalMomentumWheel::GetAmps( )
         */
        double GetAmps( );
        
        /*! \brief Get the voltage at the motor. 
         *  Calls PhysicalMomentumWheel::GetVolts( )
         */
        double GetVolts();
   

        //////////////////////////////////////////
        // Data Logging
        //////////////////////////////////////////

        /*! \brief Start the wheel speed data collection routine 
         *  Each wheel's speed query needs to be started individually.  The performance occurs
         *  when the spart calls for each wheel are spread evenly over  sec (value subject to change)
         */
        void StartWheelSpeedDataLogging( );

        /*! \brief Friend function split in a new thread that queries the wheel speed repeatedly.  It begins running in the
         *  StartSpeedQuery function. Velocity by Position: This function determines the velocity of the wheel by differentiating
         *  the position reported by the wheel.  The function asks the wheel for its
         *  position and then gets the time of day at which the measurement is reported.
         *  The code then delays for a small time and asks for the position and gets
         *  the time again.  The velocity is then calculated by dividing the change
         *  in position byt he change in time.  The return value is the velocity in rev/sec.
         *
         *  @param arg the argument is set to be a "this" pointer cast as a void pointer
         */
        friend void* DataWheelSpeed( void* arg );

        /*! \brief Stop the speed reading routine of the motor.  This function does not need to be called a t the end of the program.
         *  The thread will be closed automatically when the program ends.
         */
        void StopWheelSpeedDataLogging( );



        /*! \brief Value-Definitions of the different string values */
        enum StringValue{ ON,
                        OFF };

        /*! \brief Map to associate the strings with the enum values */
        map<string, StringValue> s_mapStringValues;
 
protected: 
    
    
private:

        /*! \brief Static member integer representing the total number of wheels instantiated*/
        static int m_WheelCount;

        /*! \brief 3x1 vector corresponding to the axis normal to the wheel*/
        Vector m_WheelAxis; 

        /*! \brief Member PhysicalMomentumWheel object*/
        PhysicalMomentumWheel m_PhysicalMomentumWheel;

        /*! \brief Member WheelHistory in MomentumWheel.h, saving time and wheel speed for 
         *   for initialized wheel. */
        WheelHistory *m_WheelHistory;

        /*! \brief Member string in MomentumWheel.h, ON or OFF for logging. */
        string m_LogData;

        /*! \brief Member pthread for Wheel Speed Data Logging. */
        pthread_t m_DataSpeedThreadID;

        /*! \brief Memeber mutex lock variable for Data*/
        pthread_mutex_t m_DataMutex;

        int m_exitConditionData;
};

#endif 
// Do not change the comments below - they will be added automatically by CVS
/*****************************************************************************
*       $Log: MomentumWheel.h,v $
*       Revision 1.30  2007/07/24 09:39:38  jayhawk_hokie
*       Removed matrix and vector pointers.
*       
*       Revision 1.29  2007/05/30 23:48:43  jayhawk_hokie
*       Modified thread termination.
*       
*       Revision 1.28  2007/03/27 19:07:16  jayhawk_hokie
*       Updated Momentum Wheels.
*       
*       Revision 1.27  2007/02/06 20:48:16  jayhawk_hokie
*       Update for XML parsing for Momentum Wheels.
*       
*       Revision 1.26  2005/02/25 18:40:52  cakinli
*       Created Makefiles and organized include directives to reduce the number of
*       include paths.  Reorganized libraries so that there is now one per source
*       directory.  Each directory is self-contained in terms of its Makefile.
*       The local Makefile in each directory includes src/config.mk, which has all
*       the definitions and general and pattern rules.  So at most, to see what
*       goes into building a target, a person needs to examine the Makefile in
*       that directory, and ../config.mk.
*       
*       Revision 1.25  2004/03/04 23:13:09  bstreetman
*       Big changes! new functions and functionality.  FUnctions: GetVolts() -- get motor voltage.  GetAmps() -- ge current used by motors.  GetWheelFD() -- get the wheel comm file descriptor.  SetBiasSpeed() -- Set the bias speed used in momentum wheel mode.  SetSystemTorque() -- old style torque function, used mainly by me.  friend RUnTorqueCOntroller() -- new torque controller, runs in a separate thread.  StartTorqueController() -- spawns torque thread, called internally.  Other Changes:  config parameters -- added BiasSpeed confige parameter, sets bias speed and commands the wheel to go there.  SetWheelSpeed() -- no more PID controller, uses a function created by the data i took.  SetWHeelTorque() -- happens in a better way now based on tons of data and hdot = g.
*       
*       Revision 1.24  2003/12/16 17:20:26  bstreetman
*       A bit o' fall cleaning.  Just look at how pretty it is.
*       
*       Revision 1.23  2003/11/14 20:15:44  bstreetman
*       Apparently I broke the PID controller with the last update, but now it works again.  I also added a StopPID() function to end the thread of the PID controller.  To spin up to 900 rpm (about half speed) use SetWheelSpedd(92).  If you wnat to then switch to torque control sleep for about 12 seconds and run StopPID() and you should be good to go.
*       
*       Revision 1.22  2003/10/17 20:01:33  bstreetman
*       Wheel code updated to reflect hardware changes.  All wheels now considered on separate serial port.  Wheels also changed to read wheel velocity in a separate thread.  Thread is fired off by StartSpeedQuery() function.  Wheel Speed and measurement timestamp are set by the function GetWheelSpeed(speed, time).  See SpeedTest.cpp in the work directory for a sample using the new code.
*       
*       Revision 1.21  2003/08/18 19:31:17  mavandyk
*       Fixed config parsing.
*       
*       Revision 1.20  2003/08/06 21:18:48  bstreetman
*       Updated to work with config parser
*       
*       Revision 1.19  2003/08/04 21:25:23  bstreetman
*       Now with doxygen-style comments
*       
*       Revision 1.18  2003/08/01 20:21:20  bstreetman
*       Cleaned and streamlined all code. Reduced warning and outputs. CMG and Momentum Wheels now no longer accept a global integer in initialization.  The file descriptor is now set and held internally.
*       
*       Revision 1.17  2003/07/28 17:54:00  bstreetman
*       Change some pass-by-reference to pass-by-value
*       
*       Revision 1.16  2003/07/21 20:15:30  bstreetman
*       Updates
*       
*       Revision 1.15  2003/07/09 20:24:33  cskelton
*       Corrected Initialization and Deconstruction
*       
*       Revision 1.14  2003/07/08 21:32:26  cskelton
*       Added functionality, initialization fixed, command torque works
*       
*       Revision 1.13  2003/07/07 19:34:08  cskelton
*       Removed virtual from functions
*       
*       Revision 1.12  2003/07/04 16:02:00  nicmcp
*       Added the AxialInertia from PhysicalMomentumwheel.h
*       
*       Revision 1.11  2003/07/04 15:54:51  simpliciter
*       Fixed capitalization.
*       
*       Revision 1.10  2003/07/03 19:47:49  nicmcp
*       Added an instance counter
*       
*       Revision 1.9  2003/07/02 22:02:12  bstreetman
*       Improve functionality and made to work with the c hardware code.
*       
*       Revision 1.8  2003/07/01 20:54:18  bstreetman
*       Fixed Small #include problem
*       
*       Revision 1.7  2003/07/01 19:56:09  cskelton
*       Added Hardware software support
*       
*       Revision 1.6  2003/07/01 19:19:43  cskelton
*       Debugged to compile
*       
*       Revision 1.5  2003/06/30 17:22:20  cskelton
*       Updated functions and herader file
*       
*       Revision 1.3  2003/06/30 15:34:23  cskelton
*       Added PMW member
*       
*       Revision 1.2  2003/06/19 21:29:58  simpliciter
*       Updated from Andy's generic layout.
*       
*       Revision 1.1  2003/06/13 15:24:33  simpliciter
*       Initial submission.
*       
*
******************************************************************************/

---