Tutorials/k0SDR/Tutorial04a: CWriteOML_spectrum.h

#include <iostream>
#include <cstring>
#include <string>
#include <boost/lexical_cast.hpp>
#include "oml2/omlc.h"
#include <stdio.h>

#define FALSE (unsigned int) 0
#define TRUE  (unsigned int) 1

#define RECORD_TO_SERVER 1
#define RECORD_TO_FILE 2

#define USE_BLOB // FRUITFULLY USED WITH RECORD_TO_SERVER


// Should be called moving average
class CWriteOML
{

 private:

  unsigned int mMeasurementPoints;
  unsigned int mHeaderPoints;
  unsigned int mFFTLength;
  unsigned int mIdxNull;
  unsigned int mRecordMode;
  unsigned int mUseBlob;

  OmlMPDef* mp_def;
  OmlMP* mp;

  void createMeasurementPoint(OmlMPDef* pOmlMPDef, std::string str, OmlValueT type)
  {
    char* cptr;
    if (str == "NULL")
      {
    pOmlMPDef->name = NULL;
    pOmlMPDef->param_types = type;

      }
    else
      {
    cptr = new char[str.size()+1];
    strcpy (cptr, str.c_str());
    pOmlMPDef->name = cptr;
    pOmlMPDef->param_types = type;
      }
  }

 public:
  CWriteOML()
    {

    }

  void init(std::string db_filename, std::string server_name)
  {
    char hostname[16];
    int argc;
    const char** argv;
    hostname[15] = '\0';
    gethostname(hostname, 15);

    std::string mode(server_name.c_str());

    if (mode == "file")
    {
      mRecordMode = RECORD_TO_FILE;
      mUseBlob = FALSE;
      argc = 7;
      const char* argv_file[] = {"./spectrum", "--oml-id",(const char*)hostname, "--oml-exp-id",db_filename.c_str(), "--oml-file",db_filename.c_str()};
      argv = argv_file;
    }
    else
    {
      mRecordMode = RECORD_TO_SERVER;
#ifdef USE_BLOB
      mUseBlob = TRUE;
#else
      mUseBlob = FALSE;
#endif
      argc = 7;
      const char* argv_server[] = {"./spectrum", "--oml-id",(const char*)hostname, "--oml-exp-id",db_filename.c_str(), "--oml-server", server_name.c_str()};
      argv = argv_server;
    }

    int result = omlc_init ("spectrum", &argc, argv, NULL);
    if (result == -1) {
      std::cerr << "Could not initialize OML\n";
      exit (1);
    }
  }

  void start(unsigned int points)
  {
      int result;

      mHeaderPoints = 5;
      mFFTLength = points;

      if (mUseBlob == TRUE)
    mMeasurementPoints = mHeaderPoints + 1;
      else
    mMeasurementPoints = mHeaderPoints + (1*mFFTLength);

      mIdxNull = mMeasurementPoints;

      mp_def = new OmlMPDef [(sizeof(OmlMPDef) * (mMeasurementPoints+1) )];

      // mHeaderPoints
      createMeasurementPoint(&mp_def[0], "sampling",    (OmlValueT)OML_INT32_VALUE);
      createMeasurementPoint(&mp_def[1], "cfreq_MHz",   (OmlValueT)OML_DOUBLE_VALUE);
      createMeasurementPoint(&mp_def[2], "gain_dB",     (OmlValueT)OML_INT32_VALUE);
      createMeasurementPoint(&mp_def[3], "FFTLength",   (OmlValueT)OML_INT32_VALUE);
      createMeasurementPoint(&mp_def[4], "FFTNum",      (OmlValueT)OML_STRING_VALUE);

      // mFFTLength
      if (mUseBlob == TRUE)
      {
    createMeasurementPoint(&mp_def[5], "FFTBins",     (OmlValueT)OML_BLOB_VALUE);
      }
      else
      {
    for (unsigned int i = mHeaderPoints; i < mIdxNull; ++i)
    {
      std::string str = "bin_" + boost::lexical_cast<std::string>(i-mHeaderPoints);
      createMeasurementPoint(&mp_def[i], (char*)str.c_str(),    (OmlValueT)OML_DOUBLE_VALUE);
    }
      }

      createMeasurementPoint(&mp_def[mIdxNull], "NULL",        (OmlValueT)0);

      mp = omlc_add_mp ("packet_info", mp_def);

      if (mp == NULL) {
    std::cerr << "Error: could not register Measurement Point \"packet_info\"";
    exit (1);
      }  

      result = omlc_start();
      if (result == -1) {
    std::cerr << "Error starting up OML measurement streams\n";
    exit (1);
      }
  }

  void insert(uint32_t samp, float cf, uint32_t gain, char* text, float* buff)
  {
    OmlValueU values[mMeasurementPoints];
    float* fptr = buff;

    omlc_set_long   (values[0], samp);
    omlc_set_double (values[1], cf);
    omlc_set_long   (values[2], gain);
    omlc_set_long   (values[3], mFFTLength);
    omlc_set_string (values[4], text);

    if (mUseBlob == TRUE)
    {
      values[5].blobValue.data = NULL;
      values[5].blobValue.size = 0;
      omlc_set_blob (values[5], (char *)fptr, 1*mFFTLength*sizeof(float));
      //std::cerr << *fptr << std::endl;
    }
    else
    {
      for (unsigned int i = mHeaderPoints; i < mIdxNull; ++i)
      {
    omlc_set_double (values[i], *fptr++); 
      }
    }
    
    omlc_inject (mp, values);
  }

  void stop()
  {
    omlc_close();
  }

  void print()
  {
    
    for (unsigned int i = 0;i < mMeasurementPoints; ++i)
      std::cout << (char*)((&mp_def[i])->name) << " = " << mp_def[i].param_types << std::endl;

  }

  void test()
  {
    unsigned numberOfBins = 8;
    
    std::vector<std::complex<float> > vc;
    vc.resize(numberOfBins);
    vc.at(0) = std::complex<float>(1,2);
    vc.at(1) = std::complex<float>(3,4);
    vc.at(2) = std::complex<float>(5,6);
    vc.at(3) = std::complex<float>(7,8);

    init("spectrum_measurement","oml:3003");
    start(numberOfBins);
    print();
    insert(8e6, 5000, 20, (char*)"fone", (float*)&vc.front());
    insert(11, 22, 20, (char*)"fone!", (float*)&vc.front());
    stop();
  }


};