rb8509_adc12.h

/*
 * rb8509_adc12.h - 8-channel 12-bit ADC (RB8509).
 *
 * This file is part of the Rulbus Device Class Library (RDCL).
 *
 * Copyright (C) 2003-2004, Leiden University.
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * The library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with mngdriver; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * $Id: rb8509_adc12.h 2 2004-10-12 11:54:15Z moene $
 */

#ifndef __RB8509_Adc12_ADC12_H
#define __RB8509_Adc12_ADC12_H

#ifndef __RULBUSDEVICE_H
#include "RulbusDevice.h"       // for class RulbusDevice
#endif

namespace Rulbus
{
   DECLARE_CLASS( RB8509_Adc12 );       // the 12-bit ADC class type

   /* *
    * \example name.cpp
    * This is an example that shows ... .
    */

   class RB8509_Adc12 : public RulbusDevice
   {
   public:                              // public methods
      typedef Int Value;                


      RB8509_Adc12(
         NameCref aName,
         Addr     aAddr           = DEF_ADDR,
         Rack     aRack           = DEF_RACK,
         bool     aBipolarFlag    = DEF_BIP,
         Real     aVoltPerBit     = DEF_VPB,
         bool     aExtTrigInpFlag = DEF_ETI
      );

      ~RB8509_Adc12();


      int    channel() const;
      int    gain() const;

      Volt   voltage();
      Value  value() ;
      Value  result();
      Value  rawresult();

      bool   hasExtTriggerInput() const;

      bool   extTriggerLevel() const;

      bool   isEnabledExtTrigger() const;
      bool   isEnabledMultiplexer() const;
      bool   isEnabledInterrupt() const;

      bool   isBusyAdc() const;
      bool   isReady() const;
      bool   isBipolar() const;
      bool   isPendingInterrupt() const;

      Real   voltperbit() const;


      bool   isValidChannel( int aChannel ) const;
      bool   isValidGain   ( int aGain    ) const;


      void   setChannel( int aChannel );

      void   setGain   ( int aGain    );
      void   autoscale ();

      void   convert   ();

      bool   enableMultiplexer( bool enable = true );
      bool   enableExtTrigger ( bool enable = true );
      bool   enableInterrupt  ( bool enable = true );


   protected:                                   // protected methods

      RB8509_Adc12();                                     
      RB8509_Adc12( RB8509_Adc12Cref rhs );               
      RB8509_Adc12Ref operator= ( RB8509_Adc12Cref rhs ); 


      void   checkChannel  ( int aChannel ) const;
      void   checkGain     ( int aGain    ) const;


   public:                                      // public data

      static const Addr  DEF_ADDR    = 0xC0;    
//      static const Rack  DEF_RACK    = 0;       ///< default rack
      static const int   DEF_GAIN    = 1;       
      static const int   DEF_CHAN    = 0;       
      static const bool  DEF_BIP     = true;    
      static const Real  DEF_VPB  /* = 5e-3 */; 
      static const bool  DEF_ETI     = false;   


      static const int   LIM_MINCHAN = 0;       
      static const int   LIM_MAXCHAN = 7;       

      static const int   LIM_MINGAIN = 1;       
      static const int   LIM_MAXGAIN = 8;       

      static const Real  LIM_MINVPB  /* =  1e-3 */ ;  
      static const Real  LIM_MAXVPB  /* = 10e-3 */ ;  

      static const int   LIM_TIMOUT  = 1000;    
      static const Value LIM_MINVAL  = 0x0000;  
      static const Value LIM_MAXVAL  = 0x0FFF;  
      static const Value LIM_BIPVAL  = 0x0800;  


   private:                                     // private data

      Byte  theControlRegister;                 
      bool  theExtTrigInpFlag;                  
      bool  theBipolarFlag;                     
      Real  theVoltPerBit;                      


      static const int  OFF_ADCLSB  = 0;        
      static const int  OFF_CONTROL = 0;        
      static const int  OFF_STATUS  = 1;        
      static const int  OFF_CONVERT = 1;        
      static const int  ADR_WIDTH   = OFF_CONVERT + 1;  


      static const int  MSK_CTLCHAN  = 0x07;    
      static const int  MSK_CTLMPLX  = 0x08;    
      static const int  MSK_CTLGAIN  = 0x30;    
      static const int  MSK_CTLTRIG  = 0x40;    
      static const int  MSK_CTLINTR  = 0x80;    

      static const int  MSK_STSBSY   = 0x10;    
      static const int  MSK_STSEOC   = 0x20;    
      static const int  MSK_STSINTR  = 0x40;    
      static const int  MSK_STSTRIG  = 0x80;    
      static const int  MSK_VALMSN   = 0x0F;    

      static const int  SHL_CTLCHAN  = 0;       
      static const int  SHL_CTLGAIN  = 4;       

   };


   inline bool RB8509_Adc12::hasExtTriggerInput() const
   {
      return theExtTrigInpFlag;
   }

   inline bool RB8509_Adc12::isBipolar() const
   {
       return theBipolarFlag;
   }

   inline Real RB8509_Adc12::voltperbit() const
   {
      return theVoltPerBit;
   }

   inline bool RB8509_Adc12::isValidChannel( int aChannel ) const
   {
      return aChannel >= LIM_MINCHAN &&
             aChannel <= LIM_MAXCHAN ;
   }

   inline bool RB8509_Adc12::isValidGain( int aGain ) const
   {
      return aGain == 1 ||
             aGain == 2 ||
             aGain == 4 ||
             aGain == 8 ;
   }

   inline RB8509_Adc12Ref to_rb8509( RulbusDevicePtr p )
   {
      return PROXY_CAST<RB8509_Adc12Ref>( *p );
   }

   inline RB8509_Adc12Ptr to_rb8509_ptr( RulbusDevicePtr p )
   {
      return PROXY_CAST<RB8509_Adc12Ptr>( p );
   }

} // namespace Rulbus

#endif  // __RB8509_Adc12_ADC12_H

/*
 * end of file
 */

---