metexascii.cpp

Go to the documentation of this file.

//======================================================================
// File:        metexascii.cpp
// Author:      Matthias Toussaint
// Created:     Sat Nov 25 18:12:23 CET 2006
// Project:     QtDMM
// Description: Encapsulates a DMM class (protokoll)
//----------------------------------------------------------------------
// This file  may  be used under  the terms of  the GNU  General Public
// License  version 2.0 as published   by the Free Software  Foundation
// and appearing  in the file LICENSE.GPL included  in the packaging of
// this file.
// 
// This file is provided AS IS with  NO WARRANTY OF ANY KIND, INCLUDING 
// THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
// PURPOSE.
//----------------------------------------------------------------------
// Copyright 2006 Matthias Toussaint
//======================================================================

#include <metexascii.h>

#include <iostream>

MetexAscii::MetexAscii( const std::string & format,
                        const std::string & overflowStr,
                        bool poll, const std::string & pollString, 
                        int pollTime ) :
  DMMClass(),
  m_overflowStr( overflowStr ),
  m_poll( poll ),
  m_pollString( pollString ),
  m_pollTime( pollTime*1000 )
{
  // parse format
  //
  int byte = 0;
  m_length = format.size();
  m_syncByte = format[m_length-1];
  
  int *start=0;
  int *len=0;
  
  for (int i=0; i<m_length; ++i)
  {
    if (byte != format[i])
    {
      if (len)
      {
        *len = i-(*start);
      }
      
      if (format[i] == 'M')
      {
        start = &m_modeStart;
        len   = &m_modeLen;
      }
      else if (format[i] == 'V')
      {
        start = &m_valueStart;
        len   = &m_valueLen;
      }
      else if (format[i] == 'U')
      {
        start = &m_unitStart;
        len   = &m_unitLen;
      }
      else 
      {
        start = 0;
        len = 0;
      }
      
      if (start) 
      {
        *start = i;
      }
      
      byte = format[i];
    }
  }
}

MetexAscii::~MetexAscii()
{
  m_port.close();
}

Port::Error MetexAscii::open_impl( const std::string & config )
{
  return m_port.open( config );
}

Port::Error MetexAscii::close()
{
  return m_port.close();
}

void MetexAscii::setMetexAscii( const std::string & str, int index )
{
  m_mutex.lock();
      
  double value;
  Util::fromString( &value, 
                    Util::strip_whitespace( str.substr( m_valueStart, m_valueLen )));
  addValue( value, index );
  m_mode[index] = Util::strip_whitespace( str.substr( m_modeStart, m_modeLen ));      
  m_unit[index] = Util::strip_whitespace( str.substr( m_unitStart, m_unitLen ));
      
  m_hasValue = true;
  if (str.substr(m_valueStart,m_valueLen).find(m_overflowStr)<(unsigned)m_valueLen)
  {
    m_overflow=true;
  }
  else m_overflow=false;
      
  m_mutex.unlock(); 
}

void MetexAscii::run()
{
  char data[64];
  
  while (m_run)
  {
    if (m_poll)
    {
      m_port.writeString( m_pollString.c_str(), m_pollString.size() );
    }
    
    for (int i=0; i<m_numValues; ++i)
    {
      int cnt = readData( &m_port, (unsigned char *)data, 
                          m_syncByte, m_length, 3*m_length );
      
      if (-1 != cnt)
      {
        int start = cnt-m_length;
        data[cnt-1] = 0;
        std::string strData = data+start;
        //std::cerr << strData << std::endl;
        
        setMetexAscii( strData, i );
      }
      else m_hasValue = false;
    }
    
    usleep(m_pollTime);
  }
}

---