rb8905_adc12.h

/*
 * rb8905_adc12.h - high speed 12-bit ADC (RB8905).
 *
 * 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: rb8905_adc12.h 2 2004-10-12 11:54:15Z moene $
 */

#ifndef __RB8905_ADC12_H
#define __RB8905_ADC12_H

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

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

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

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


      RB8905_Adc12(
         NameCref aName,
         Addr     aAddr       = DEF_ADDR,
         Rack     aRack       = DEF_RACK,
         Real     aVoltPerBit = DEF_VPB
      );

      ~RB8905_Adc12();


      void      arm        ();
      bool      isReady    () const;

      int       readVoltage( Volt32*  pVoltage, int nelem );
      int       readValue  ( Int16*   pValue  , int nelem );
      Value     getValue   ();
      Value     getRawValue();


      bool      isFastMode        () const;
      bool      isUnipolarMode    () const;
      bool      isEnabledInterrupt() const;

      int       bufferCapacity    () const;
      int       jmp3BufferCapacity() const;

      Real      voltperbit        () const;
      Volt      voltageSpan       () const;
      Volt      offsetVoltage     () const;
      Volt      minInputVoltage   () const;
      Volt      maxInputVoltage   () const;


      void      setFastMode       ();
      void      setNormalMode     ();

      void      setBipolarMode    ();
      void      setUnipolarMode   ();

      bool      enableInterrupt   ( bool enable = true   );

      void      setBufferCapacity ( int nelem = CON_JMP3 );


   protected:                                   // protected methods

      RB8905_Adc12();                                     
      RB8905_Adc12( RB8905_Adc12Cref rhs );               
      RB8905_Adc12Ref operator= ( RB8905_Adc12Cref rhs ); 


      void      setReadMode   ();
      void      setWriteMode  ();


      void      clearAddress  ();

      int       elemSize      () const;
      int       bufferSize    () const;
      void      setBufferSize ( int aSize = CON_JMP3 );
      void      setBufferCode ( int aCode );

      int       jmp3BufferSize() const;
      int       detectJmp3BufferSize();

      void      checkRead     ( int nelem );
      void      waitRelais    ();


   public:                                      // public data

      static const Addr  DEF_ADDR      = 0xBC;  
      static const float DEF_VPB /* = 10.0/4095.0 */;   // volt per bit (10.0 V full scale)
      static const int   DEF_SAMPLES   = 256;   


      static const int   CON_JMP3      = 0;     
      static const int   CON_TRELAIS   = 20;    


   private:                                     // private data

      Byte  theControlRegister;                 
      Real  theVoltPerBit;                      
      int   theJmp3BufferSize;                  
      int   theBufferCapacity;                  


      static const int OFF_CTL   = 0;           
      static const int OFF_ADC   = 0;           
      static const int OFF_STS   = 1;           
      static const int ADR_WIDTH = OFF_STS + 1; 


      static const Value LIM_MINVAL8   = 0x000; 
      static const Value LIM_MAXVAL8   = 0x0FF; 

      static const Value LIM_MINVAL12  = 0x000; 
      static const Value LIM_MAXVAL12  = 0xFFF; 

      static const int LIM_MINJMP3SIZE = 2;     
      static const int LIM_MAXJMP3SIZE = 256;   

      static const int LIM_MINBUFSIZE  = 512;   
      static const int LIM_MAXBUFSIZE  = 32768; 


      static const int MSK_CTLBSIZE = 0x07;     
      static const int MSK_CTLREAD  = 0x08;     
      static const int MSK_CTLFAST  = 0x10;     
      static const int MSK_CTLCLEAR = 0x20;     
      static const int MSK_CTLINTR  = 0x40;     
      static const int MSK_CTLUNIP  = 0x80;     

      static const int MSK_STSREADY = 0x80;     

      static const int MSK_ADCALL12 = 0x0FFF;   
      static const int MSK_ADCALL8  = 0x00FF;   
      static const int MSK_ADCMSB12 = 0x0800;   
      static const int MSK_ADCMSB8  = 0x0080;   

   };


   inline bool RB8905_Adc12::isReady() const
   {
      return 0 != ( getByte( OFF_STS ) & MSK_STSREADY );
   }

   inline bool RB8905_Adc12::isFastMode() const
   {
      return 0 != ( theControlRegister & MSK_CTLFAST );
   }

   inline bool RB8905_Adc12::isUnipolarMode() const
   {
      return 0 != ( theControlRegister & MSK_CTLUNIP );
   }

   inline bool RB8905_Adc12::isEnabledInterrupt() const
   {
      return 0 != ( theControlRegister & MSK_CTLINTR );
   }

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

   inline int RB8905_Adc12::bufferCapacity() const
   {
      return theBufferCapacity;
   }

   inline int RB8905_Adc12::jmp3BufferCapacity() const
   {
      return jmp3BufferSize() / elemSize();
   }

   inline int RB8905_Adc12::jmp3BufferSize() const
   {
      return theJmp3BufferSize;
   }

   inline int RB8905_Adc12::elemSize() const
   {
      return isFastMode() ? 1 : 2;
   }

   inline void RB8905_Adc12::setFastMode()
   {
      putByte( OFF_CTL, theControlRegister |=  MSK_CTLFAST );
   }

   inline void RB8905_Adc12::setNormalMode()
   {
      putByte( OFF_CTL, theControlRegister &= ~MSK_CTLFAST );
   }

   inline void RB8905_Adc12::setBipolarMode()
   {
      putByte( OFF_CTL, theControlRegister &= ~MSK_CTLUNIP );
      waitRelais();
   }

   inline void RB8905_Adc12::setUnipolarMode()
   {
      putByte( OFF_CTL, theControlRegister |= MSK_CTLUNIP );
      waitRelais();
   }

   inline void RB8905_Adc12::setBufferCapacity( int nelem /* = CON_JMP3 */ )
   {
      theBufferCapacity = nelem;
   }

   inline RB8905_Adc12Ref to_rb8905( RulbusDevicePtr p )
   {
      return PROXY_CAST<RB8905_Adc12Ref>( *p );
   }

   inline RB8905_Adc12Ptr to_rb8905_ptr( RulbusDevicePtr p )
   {
      return PROXY_CAST<RB8905_Adc12Ptr>( p );
   }

} // namespace Rulbus

#endif  // __RB8905_ADC12_H

/*
 * end of file
 */

---