instrument.hpp

Go to the documentation of this file.

 
#ifndef ROHDESCHWARZ_INSTRUMENTS_INSTRUMENT_HPP
#define ROHDESCHWARZ_INSTRUMENTS_INSTRUMENT_HPP
 
 
// rohdeschwarz
#include "rohdeschwarz/busses/bus.hpp"
#include "rohdeschwarz/scpi/block_data.hpp"
#include "rohdeschwarz/scpi/bool.hpp"
#include "rohdeschwarz/helpers.hpp"
#include "rohdeschwarz/to_value.hpp"
 
 
// rs visa
#include "rs-visa/visatype.h"
 
 
// boost
#include "boost/format.hpp"
 
 
// std lib
#include <complex>
#include <cstddef>
#include <memory>
#include <string>
#include <vector>
 
 
namespace rohdeschwarz::instruments
{
 
 
class Instrument
{
 
public:
 
 
  // open / close connection
 
  bool isOpen() const;
 
 
  bool openVisa(std::string resource, unsigned int timeout_ms = 2000);
 
 
  bool openTcp(std::string host, unsigned int timeout_ms = 2000);
 
 
  void close();
 
 
  // io buffer
 
  std::size_t bufferSize_B() const;
 
  void setBufferSize(std::size_t size_bytes);
 
  std::vector<unsigned char>* buffer();
 
  const std::vector<unsigned char>* buffer() const;
 
  std::vector<unsigned char> takeData();
 
 
  // timeout
 
  int timeout_ms();
 
 
  bool setTimeout(int timeout_ms);
 
 
  // raw io
 
  bool readData(unsigned char* buffer, std::size_t bufferSize, std::size_t* readSize = nullptr);
 
 
  bool writeData(const unsigned char* data, std::size_t dataSize, std::size_t* writeSize = nullptr);
 
 
  // raw io with internal buffers
 
  bool readData(std::size_t* readSize = nullptr);
 
 
  // string io
 
  std::string read();
 
 
  template<class... Args>
  bool write(std::string scpi_command, Args&&... args)
  {
    // format scpi command
    auto format = boost::format(scpi_command);
    ([&]
    {
      format % args;
    } (), ...);
 
    // get complete command string
    auto command = format.str();
 
    // get data pointer, size
    using uchar_p = unsigned char*;
    auto data = uchar_p(command.c_str());
    auto size = command.size();
 
    // write data
    std::size_t writeSize;
    if (!writeData(data, size, &writeSize))
    {
      // error
      return false;
    }
 
    // write complete?
    return writeSize == size;
  }
 
 
  template<class... Args>
  std::string query(std::string scpi_command, Args&&... args)
  {
    // write
    if (!write(scpi_command, &args...))
    {
      // error
      return std::string();
    }
 
    // read
    return read();
  }
 
 
  // basic type io
 
  template<class OutputType>
  OutputType readValue()
  {
    return to_value<OutputType>(read());
  }
 
 
  template<class OutputType, class... Args>
  OutputType queryValue(std::string scpi_command, Args&&... args)
  {
    return to_value<OutputType>(query(scpi_command, &args...));
  }
 
  // scpi bool io
 
  bool readScpiBool();
 
  template<class... Args>
  bool queryScpiBool(std::string scpi_command, Args&&... args)
  {
    // write
    if (!write(scpi_command, &args...))
    {
      // error
      return false;
    }
 
    // parse result
    return rohdeschwarz::scpi::toBool(read());
  }
 
 
  // ascii data vector io
 
  std::vector<double> readAsciiVector();
 
 
  std::vector<std::complex<double>> readAsciiComplexVector();
 
 
  // block data io
 
  scpi::BlockData readBlockData();
 
 
  // block data vector io
 
  std::vector<double> read64BitVector();
 
 
  std::vector<std::complex<double>> read64BitComplexVector();
 
 
  // status
 
  bool isBusError() const;
 
 
  std::string busStatus() const;
 
 
  // common scpi commands
 
  std::string id();       // *IDN?
 
 
  std::string options();  // *OPT?
 
 
  void clearErrors();    // *CLS
 
 
  void preset();           // *RST
 
 
  void wait();            // *WAI
 
 
  bool blockUntilOperationComplete(unsigned int timeout_ms = 2000);
 
 
private:
 
  std::shared_ptr<rohdeschwarz::busses::Bus> _bus;
 
 
};  // Instrument
 
 
}       // rohdeschwarz::instruments
#endif  // ROHDESCHWARZ_INSTRUMENTS_INSTRUMENT_HPP