MeasurementFileWriter Class Reference

Writes measurement data / current reception parameters to a file. More...

#include <MeasurementFileWriter.h>

Collaboration diagram for MeasurementFileWriter:

Public Member Functions
	MeasurementFileWriter (const libconfig::Config &cfg)
	Default constructor. More...
virtual	~MeasurementFileWriter ()
	Default destructor. More...
void	WriteLogValues (const std::vector< std::string > &values)
	Write a line containing the passed values. More...

Private Member Functions
void	ReadGps ()

Private Attributes
const libconfig::Config &	_cfg
std::unique_ptr< gpsmm >	_gps
struct gps_data_t *	_gps_data {}
std::thread	_gps_reader_thread
bool	_running = true
std::string	_last_gps_lat = ""
std::string	_last_gps_lng = ""
std::string	_last_gps_time = ""

Detailed Description

Writes measurement data / current reception parameters to a file.

Definition at line 35 of file MeasurementFileWriter.h.

Constructor & Destructor Documentation

MeasurementFileWriter()

MeasurementFileWriter::MeasurementFileWriter ( const libconfig::Config &  cfg )

explicit

Default constructor.

Parameters

cfg	Config singleton reference

Definition at line 37 of file MeasurementFileWriter.cpp.

      : _cfg(cfg) {
  bool gps_enabled = false;
  _cfg.lookupValue("modem.measurement_file.gpsd.enabled", gps_enabled);
 
  if (gps_enabled) {
    std::string host = "localhost";
    _cfg.lookupValue("modem.measurement_file.gpsd.host", host);
 
    std::string port = DEFAULT_GPSD_PORT;
    _cfg.lookupValue("modem.measurement_file.gpsd.port", port);
 
    _gps = std::make_unique<gpsmm>(host.c_str(), port.c_str());
 
    if (_gps->stream(WATCH_ENABLE | WATCH_JSON) == nullptr) {
      spdlog::error("No GPSD running, cannot start GPS stream.");
    } else {
      spdlog::info("GPS data stream started");
    }
 
    _gps_reader_thread = std::thread{&MeasurementFileWriter::ReadGps, this};
  }
}

~MeasurementFileWriter()

MeasurementFileWriter::~MeasurementFileWriter ( )

virtual

Default destructor.

Definition at line 61 of file MeasurementFileWriter.cpp.

                                              {
  _running = false;
  _gps_reader_thread.join();
}

Member Function Documentation

ReadGps()

void MeasurementFileWriter::ReadGps ( )

private

Definition at line 66 of file MeasurementFileWriter.cpp.

                                    {
  while (_running) {
    if (_gps->is_open()) {
      if (!_gps->waiting(kGpsWaitTimeout)) {
        {
          continue;
        }
      }
 
      if ((_gps_data = _gps->read()) != nullptr) {
        if ((_gps_data->set & TIME_SET) != 0) {
          struct tm ts = *localtime(&_gps_data->fix.time.tv_sec);
          std::string buf;
          buf.resize(kMaxTimestringSize);
          strftime(&buf[0], buf.size(), "%FT%T", &ts);
          _last_gps_time = buf;
        }
        if ((_gps_data->set & LATLON_SET) != 0) {
          _last_gps_lat = std::to_string(_gps_data->fix.latitude);
          _last_gps_lng = std::to_string(_gps_data->fix.longitude);
        }
      } else {
        _last_gps_lat = _last_gps_lng = _last_gps_time = "";
      }
 
      std::this_thread::sleep_for(std::chrono::microseconds(kGpsWaitMicrosleep));
    } else {
      _last_gps_lat = _last_gps_lng = _last_gps_time = "";
      std::this_thread::sleep_for(std::chrono::microseconds(kGpsReconnectTimeout));
      _gps->stream(WATCH_ENABLE|WATCH_JSON);
    }
  }
}

WriteLogValues()

void MeasurementFileWriter::WriteLogValues

(

const std::vector< std::string > &

values

)

Write a line containing the passed values.

This methods always writes the first four columns containing:

• the current timestamp
• the GPS latitude (if a GPS device was configured)
• the GPS longitude (if a GPS device was configured)
• the GPS time (if a GPS device was configured)

followed by the values in the values vector.

Definition at line 100 of file MeasurementFileWriter.cpp.

                                        {
  time_t now = time(nullptr);
  struct tm ts = *localtime(&now);
  std::string buf;
  buf.resize(kMaxTimestringSize);
  strftime(&buf[0], buf.size(), "%FT%T", &ts);
 
  std::vector<std::string> cols = {buf, _last_gps_lat,
    _last_gps_lng, _last_gps_time};
 
  std::string line;
  for (const auto& col : cols) {
    {
      line += col + ";";
    }
  }
  for (const auto& val : values) {
    {
      line += val + ";";
    }
  }
 
  std::string file_loc = "/tmp/modem_measurements.csv";
  _cfg.lookupValue("modem.measurement_file.file_path", file_loc);
  std::ofstream file;
  file.open(file_loc, std::ios_base::app);
  file << line << std::endl;
  file.close();
}

Member Data Documentation

_cfg

const libconfig::Config& MeasurementFileWriter::_cfg

private

Definition at line 65 of file MeasurementFileWriter.h.

_gps

std::unique_ptr<gpsmm> MeasurementFileWriter::_gps

private

Definition at line 67 of file MeasurementFileWriter.h.

_gps_data

struct gps_data_t* MeasurementFileWriter::_gps_data {}

private

Definition at line 68 of file MeasurementFileWriter.h.

_gps_reader_thread

std::thread MeasurementFileWriter::_gps_reader_thread

private

Definition at line 69 of file MeasurementFileWriter.h.

_last_gps_lat

std::string MeasurementFileWriter::_last_gps_lat = ""

private

Definition at line 72 of file MeasurementFileWriter.h.

_last_gps_lng

std::string MeasurementFileWriter::_last_gps_lng = ""

private

Definition at line 73 of file MeasurementFileWriter.h.

_last_gps_time

std::string MeasurementFileWriter::_last_gps_time = ""

private

Definition at line 74 of file MeasurementFileWriter.h.

_running

bool MeasurementFileWriter::_running = true

private

Definition at line 70 of file MeasurementFileWriter.h.

---

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

• src/MeasurementFileWriter.h
• src/MeasurementFileWriter.cpp