gadget::Analog Class Reference

Analog is the abstract base class from which devices returning analog data must derive (through the use of gadget::InputMixer). More...

#include <gadget/Type/Analog.h>

Inheritance diagram for gadget::Analog:

[legend]Collaboration diagram for gadget::Analog:

[legend]List of all members.

Public Types
typedef gadget::SampleBuffer< AnalogData >	SampleBuffer_t
Public Member Functions
	Analog ()
	Constructor.
virtual	~Analog ()
virtual vpr::ReturnStatus	writeObject (vpr::ObjectWriter *writer)
	Serializes this object.
virtual vpr::ReturnStatus	readObject (vpr::ObjectReader *reader)
	De-serializes this object.
virtual bool	config (jccl::ConfigElementPtr element)
	Reads the minimum and maximum value configuration information for this analog device.
AnalogData	getAnalogData (int devNum=0)
	Returns analog data.
void	addAnalogSample (const std::vector< AnalogData > &anaSample)
	Helper method to add a collection of analog samples to the sample buffers.
void	swapAnalogBuffers ()
	Swaps the analog data buffers.
const SampleBuffer_t::buffer_t &	getAnalogDataBuffer ()
	Returns the current stable sample buffers for this device.
virtual std::string	getInputTypeName ()
Protected Member Functions
void	normalizeMinToMax (const float &plainJaneValue, float &normedFromMinToMax)
	Given a value that will range from [min() <= n <= max()].
float	getMin () const
	Gets the minimum "real" data value (real == from hardware).
float	getMax () const
void	setMin (float mIn)
void	setMax (float mAx)
	Analog (const gadget::Analog &d)
void	operator= (const gadget::Analog &)

---

Detailed Description

Analog is the abstract base class from which devices returning analog data must derive (through the use of gadget::InputMixer).

This is in addition to gadget::Input. gadget::Input provides pure virtual function constraints in the following functions: startSampling(), stopSampling(), sample(), and updateData().

gadget::Analog adds the function getAnalogData() for retreiving the received analog data. This is similar to the additions made by gadget::Position and gadget::Digital.

See also:

Input, InputMixer

Definition at line 65 of file Analog.h.

---

Member Typedef Documentation

typedef gadget::SampleBuffer<AnalogData> gadget::Analog::SampleBuffer_t

Definition at line 68 of file Analog.h.

---

Constructor & Destructor Documentation

gadget::Analog::Analog

(

)

Constructor.

Postcondition:

Set device abilities.

Note:

Must be called from all derived classes.

Definition at line 46 of file Analog.cpp.

   : mMin(0.0f)
   , mMax(0.0f)
{
   /* Do nothing. */ ;
}

gadget::Analog::~Analog

(

)

[virtual]

Definition at line 53 of file Analog.cpp.

{
   /* Do nothing. */ ;
}

gadget::Analog::Analog

(

const gadget::Analog &

d

)

[inline, protected]

Definition at line 170 of file Analog.h.

      : vpr::SerializableObject(d)
   {;}

---

Member Function Documentation

vpr::ReturnStatus gadget::Analog::writeObject

(

vpr::ObjectWriter *

writer

)

[virtual]

Serializes this object.

Reimplemented in gadget::InputMixer< gadget::InputMixer< gadget::SimInput, gadget::Input >, gadget::Analog >.

Definition at line 58 of file Analog.cpp.

References gadget::tokens::AnalogValue(), gadget::tokens::BufferSampleLenAttrib(), gadget::tokens::BufferSampleTag(), gadget::tokens::DataTypeAttrib(), getInputTypeName(), gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::lock(), gadget::MSG_DATA_ANALOG, gadget::tokens::SampleBufferLenAttrib(), gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::stableBuffer(), gadget::tokens::TimeStamp(), and gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::unlock().

{
   //std::cout << "[Remote Input Manager] In Analog write" << std::endl;

   SampleBuffer_t::buffer_t& stable_buffer = mAnalogSamples.stableBuffer();
   writer->beginTag(Analog::getInputTypeName());
   writer->beginAttribute(gadget::tokens::DataTypeAttrib);
      writer->writeUint16(MSG_DATA_ANALOG);                                   // Write out the data type so that we can assert if reading in wrong place
   writer->endAttribute();

   if ( !stable_buffer.empty() )
   {
      mAnalogSamples.lock();
      writer->beginAttribute(gadget::tokens::SampleBufferLenAttrib);
         writer->writeUint16(stable_buffer.size());                           // Write the # of vectors in the stable buffer
      writer->endAttribute();
      for ( unsigned j = 0; j < stable_buffer.size(); ++j )                   // For each vector in the stable buffer
      {
         writer->beginTag(gadget::tokens::BufferSampleTag);
         writer->beginAttribute(gadget::tokens::BufferSampleLenAttrib);
            writer->writeUint16(stable_buffer[j].size());                     // Write the # of AnalogDatas in the vector
         writer->endAttribute();
         for ( unsigned i = 0;i < stable_buffer[j].size(); ++i )              // For each AnalogData in the vector
         {
            writer->beginTag(gadget::tokens::AnalogValue);
            writer->beginAttribute(gadget::tokens::TimeStamp);
               writer->writeUint64(stable_buffer[j][i].getTime().usec());        // Write Time Stamp vpr::Uint64
            writer->endAttribute();
            writer->writeFloat(stable_buffer[j][i].getAnalog());              // Write Analog Data(int)
            writer->endTag();
         }
         writer->endTag();
      }
      mAnalogSamples.unlock();
   }
   else        // No data or request out of range, return default value
   {
      writer->beginTag(gadget::tokens::BufferSampleTag);
         writer->beginAttribute(gadget::tokens::BufferSampleLenAttrib);
            writer->writeUint16(0);
         writer->endAttribute();
      writer->endTag();
      vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)
         << "WARNING: [gadget::Analog::writeObject()] Stable buffer is empty.  "
         << "If this is not the first write, then this is a problem.\n"
         << vprDEBUG_FLUSH;
   }
   writer->endTag();

   return vpr::ReturnStatus::Succeed;
}

vpr::ReturnStatus gadget::Analog::readObject

(

vpr::ObjectReader *

reader

)

[virtual]

De-serializes this object.

Reimplemented in gadget::InputMixer< gadget::InputMixer< gadget::SimInput, gadget::Input >, gadget::Analog >.

Definition at line 112 of file Analog.cpp.

References gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::addSample(), gadget::tokens::AnalogValue(), gadget::tokens::BufferSampleLenAttrib(), gadget::tokens::BufferSampleTag(), gadget::tokens::DataTypeAttrib(), getInputTypeName(), gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::lock(), gadget::MSG_DATA_ANALOG, gadget::tokens::SampleBufferLenAttrib(), gadget::AnalogData::setAnalog(), gadget::InputData::setTime(), swapAnalogBuffers(), gadget::tokens::TimeStamp(), and gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::unlock().

{
   vprASSERT(reader->attribExists("rim.timestamp.delta"));
   vpr::Uint64 delta = reader->getAttrib<vpr::Uint64>("rim.timestamp.delta");

   reader->beginTag(Analog::getInputTypeName());
   reader->beginAttribute(gadget::tokens::DataTypeAttrib);
      vpr::Uint16 temp = reader->readUint16();
   reader->endAttribute();

   // ASSERT if this data is really not Analog Data
   // XXX: Should there be error checking for the case when vprASSERT is
   // compied out?  -PH 8/21/2003
   vprASSERT(temp==MSG_DATA_ANALOG && "[Remote Input Manager] Not Analog Data");
   boost::ignore_unused_variable_warning(temp);

   std::vector<AnalogData> dataSample;

   unsigned numAnalogDatas;
   float value;
   vpr::Uint64 timeStamp;
   AnalogData temp_analog_data;
   reader->beginAttribute(gadget::tokens::SampleBufferLenAttrib);
      unsigned numVectors = reader->readUint16();
   reader->endAttribute();

   mAnalogSamples.lock();
   for ( unsigned i = 0; i < numVectors; ++i )
   {
      reader->beginTag(gadget::tokens::BufferSampleTag);
      reader->beginAttribute(gadget::tokens::BufferSampleLenAttrib);
         numAnalogDatas = reader->readUint16();
      reader->endAttribute();

      dataSample.clear();

      for ( unsigned j = 0; j < numAnalogDatas; ++j )
      {
         reader->beginTag(gadget::tokens::AnalogValue);
         reader->beginAttribute(gadget::tokens::TimeStamp);
            timeStamp = reader->readUint64();                  // Write Time Stamp vpr::Uint64
         reader->endAttribute();
         value = reader->readFloat();                       // Write Analog Data(int)
         reader->endTag();

         temp_analog_data.setAnalog(value);
         temp_analog_data.setTime(vpr::Interval(timeStamp + delta,vpr::Interval::Usec));
         dataSample.push_back(temp_analog_data);
      }

      mAnalogSamples.addSample(dataSample);
      reader->endTag();
   }
   mAnalogSamples.unlock();
   swapAnalogBuffers();

   reader->endTag();

   return vpr::ReturnStatus::Succeed;
}

bool gadget::Analog::config

(

jccl::ConfigElementPtr

element

)

[virtual]

Reads the minimum and maximum value configuration information for this analog device.

Postcondition:

mMin and mMax are set to the values contained in the given config element.

Parameters:

element

The config element for an analog device. It must derive from the base config element type 'analog'.

Definition at line 173 of file Analog.cpp.

Referenced by gadget::SimAnalog::config().

{
   mMin = element->getProperty<float>("min");
   mMax = element->getProperty<float>("max");

   vprDEBUG(vprDBG_ALL, vprDBG_VERB_LVL)
      << "[gadget::Analog::config()] min:" << mMin
      << " max:" << mMax << "\n" << vprDEBUG_FLUSH;

   return true;
}

AnalogData gadget::Analog::getAnalogData

(

int

devNum = 0

)

Returns analog data.

Postcondition:

Returns a value that ranges from 0.0f to 1.0f.

Parameters:

devNum

Device unit number to access.

Note:

For example, if you are sampling a potentiometer, and it returns reading from 0, 255. This function will normalize those values (using Analog::normalizeMinToMax()). For another example, if your potentiometer's turn radius is limited mechanically to return, say, the values 176 to 200 (yes this is really low res), this function will still return 0.0f to 1.0f.

To specify these min/max values, you must set in your Analog (or analog device) config file the field "min" and "max". By default (if these values do not appear), "min" and "max" are set to 0.0f and 1.0f respectivly.

TO ALL ANALOG DEVICE DRIVER WRITERS, you *must* normalize your data using Analog::normalizeMinToMax().

Definition at line 187 of file Analog.cpp.

References gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::stableBuffer().

{
   SampleBuffer_t::buffer_t& stable_buffer = mAnalogSamples.stableBuffer();

   if ( (!stable_buffer.empty()) &&
        (stable_buffer.back().size() > (unsigned)devNum) )  // If Have entry && devNum in range
   {
      return stable_buffer.back()[devNum];
   }
   else        // No data or request out of range, return default value
   {
      if ( stable_buffer.empty() )
      {
         vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)
            << "WARNING: [gadget::Analog::getAnalogData()] "
            << "Stable buffer is empty.  If this is not the first read, "
            << "then this is a problem.\n" << vprDEBUG_FLUSH;
      }
      else
      {
         vprDEBUG(vprDBG_ALL, vprDBG_CONFIG_LVL)
            << "WARNING: [gadget::Analog::getAnalogData()] "
            << "Requested devNum (" << devNum << ") is not within the "
            << "available range.  This is probably a configuration error.\n"
            << vprDEBUG_FLUSH;
      }
      return mDefaultValue;
   }
}

void gadget::Analog::addAnalogSample

(

const std::vector< AnalogData > &

anaSample

)

Helper method to add a collection of analog samples to the sample buffers.

This MUST be called by all analog devices to add new samples. The data samples passed in will then be modified by any local filters.

Postcondition:

The given analog samples are added to the buffers, and the local filters are run on the new samples.

Parameters:

anaSample

A vector of AnalogData objects that represent the newest samples taken.

Definition at line 217 of file Analog.cpp.

References gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::addSample(), gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::lock(), and gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::unlock().

{
   // Locks and then swaps the indices.
   mAnalogSamples.lock();
   mAnalogSamples.addSample(anaSample);
   mAnalogSamples.unlock();
}

void gadget::Analog::swapAnalogBuffers

(

)

Swaps the analog data buffers.

Postcondition:

If the ready queue has values, then those values are copied from the ready queue to the stable queue. If not, then stable queue is not changed.

Definition at line 225 of file Analog.cpp.

References gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::swapBuffers().

Referenced by readObject().

{
   mAnalogSamples.swapBuffers();
}

const Analog::SampleBuffer_t::buffer_t & gadget::Analog::getAnalogDataBuffer

(

)

Returns the current stable sample buffers for this device.

Definition at line 230 of file Analog.cpp.

References gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::stableBuffer().

{
   return mAnalogSamples.stableBuffer();
}

std::string gadget::Analog::getInputTypeName

(

)

[virtual]

Reimplemented in gadget::InputMixer< gadget::InputMixer< gadget::SimInput, gadget::Input >, gadget::Analog >.

Definition at line 235 of file Analog.cpp.

Referenced by readObject(), and writeObject().

{
   return std::string("Analog");
}

void gadget::Analog::normalizeMinToMax	(	const float &	plainJaneValue,
		float &	normedFromMinToMax
	)			[protected]

Given a value that will range from [min() <= n <= max()].

This returns a value that is normalized to [0,1]

Definition at line 243 of file Analog.cpp.

{
   float value = plainJaneValue;

   // first clamp the value so that min<=value<=max
   if ( value < mMin ) value = mMin;
   if ( value > mMax ) value = mMax;

   // slide everything to 0.0 (subtract all by mMin)
   // Then divide by max to get normalized value
   float tmax( mMax - mMin),
         tvalue(value - mMin);

   // since [tmin/tmax...tmax/tmax] == [0.0f...1.0f], the normalized value will be value/tmax
   normedFromMinToMax = tvalue / tmax;
}

float gadget::Analog::getMin

(

)

const [protected]

Gets the minimum "real" data value (real == from hardware).

This value is used to normalize the return value of getAnalogData.

Note:

this function is not needed by an application author.

Definition at line 261 of file Analog.cpp.

{
   return mMin;
}

float gadget::Analog::getMax

(

)

const [protected]

Definition at line 266 of file Analog.cpp.

{
   return mMax;
}

void gadget::Analog::setMin

(

float

mIn

)

[protected]

Definition at line 271 of file Analog.cpp.

{
   mMin = mIn;
}

void gadget::Analog::setMax

(

float

mAx

)

[protected]

Definition at line 276 of file Analog.cpp.

{
   mMax = mAx;
}

void gadget::Analog::operator=

(

const gadget::Analog &

)

[inline, protected]

Definition at line 174 of file Analog.h.

{;}

---

The documentation for this class was generated from the following files:

• Analog.h
• Analog.cpp

---