mdfwriter.h

Go to the documentation of this file.

/*
 * Copyright 2022 Ingemar Hedvall
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
#include <atomic>
#include <condition_variable>
#include <deque>
#include <mutex>
#include <string>
#include <thread>
#include <map>
 
#include "mdf/mdffile.h"
#include "mdf/samplerecord.h"
#include "mdf/canmessage.h"
 
namespace mdf {
 
enum class MdfBusType : int {
  CAN,      
  LIN,      
  FlexRay,  
  MOST,     
  Ethernet, 
  UNKNOWN   
};
 
enum class MdfStorageType : int {
  FixedLengthStorage, 
  VlsdStorage,        
  MlsdStorage,        
};
 
class IChannelGroup;
class IChannel;
class IChannelConversion;
class IDataGroup;
 
class MdfWriter {
 public:
  MdfWriter() = default; 
  virtual ~MdfWriter();  
 
  MdfWriter(const MdfWriter& writer) = delete;
  MdfWriter& operator=(const MdfWriter& writer) = delete;
 
  [[nodiscard]] std::string Name() const;
 
  bool Init(const std::string& filename);
 
  [[nodiscard]] bool IsFileNew() const {
    return write_state_ == WriteState::Create;
  }
 
  void PreTrigTime(double pre_trig_time);
  [[nodiscard]] double PreTrigTime() const; 
 
  [[nodiscard]] uint64_t StartTime() const { return start_time_; }
  [[nodiscard]] uint64_t StopTime() const { return stop_time_; }
 
  MdfFile* GetFile() const { return mdf_file_.get(); }
 
  [[nodiscard]] IHeader* Header() const; 
 
  bool CreateBusLogConfiguration();
  
  [[nodiscard]] IDataGroup* CreateDataGroup();
  [[nodiscard]] static IChannelGroup* CreateChannelGroup(IDataGroup* parent);
  [[nodiscard]] static IChannel* CreateChannel(IChannelGroup* parent);
  virtual IChannelConversion* CreateChannelConversion(IChannel* parent) = 0;
 
  virtual bool InitMeasurement();
 
  virtual void SaveSample(const IChannelGroup& group, uint64_t time);
 
  void SaveCanMessage(const IChannelGroup& group, uint64_t time,
                      const CanMessage& msg);
 
  virtual void StartMeasurement(uint64_t start_time);
  
  virtual void StartMeasurement(ITimestamp &start_time);
  virtual void StopMeasurement(uint64_t stop_time);
  virtual void StopMeasurement(ITimestamp &start_time);
  
  virtual bool FinalizeMeasurement();
 
  void BusType(MdfBusType type) { bus_type_ = type; }
 
  [[nodiscard]] MdfBusType BusType() const { return bus_type_; }
 
  [[nodiscard]] std::string_view BusTypeAsString() const;
 
  void StorageType(MdfStorageType type) { storage_type_ = type; }
 
  [[nodiscard]] MdfStorageType StorageType() const { return storage_type_; }
 
  void MaxLength(uint32_t max_length) {max_length_ = max_length;};
 
  [[nodiscard]] uint32_t MaxLength() const { return max_length_; }
 
  void CompressData(bool compress) {compress_data_ = compress;}
  [[nodiscard]] bool CompressData() const { return compress_data_;}
 
 protected:
  enum class WriteState : uint8_t {
    Create,     
    Init,       
    StartMeas,  
    StopMeas,   
    Finalize    
  };
  std::atomic<WriteState> write_state_ =
      WriteState::Create;  
 
  std::unique_ptr<MdfFile> mdf_file_;  
  std::string filename_;  
 
  std::atomic<uint64_t> pre_trig_time_ = 0;  
  std::atomic<uint64_t> start_time_ = 0;     
  std::atomic<uint64_t> stop_time_ = 0;      
 
  std::thread work_thread_; 
  std::atomic_bool stop_thread_ = false; 
  std::mutex locker_; 
  std::condition_variable sample_event_; 
  std::atomic<size_t> sample_queue_size_ = 0; 
 
  using SampleQueue = std::deque<SampleRecord>; 
  SampleQueue sample_queue_; 
 
  virtual void CreateMdfFile() = 0; 
  virtual bool PrepareForWriting() = 0; 
  virtual void SetDataPosition(std::FILE* file); 
  virtual bool WriteSignalData(std::FILE* file); 
 
  void StopWorkThread(); 
  void WorkThread(); 
 
  virtual void TrimQueue(); 
  virtual void SaveQueue(std::unique_lock<std::mutex>& lock);
  virtual void CleanQueue(std::unique_lock<std::mutex>& lock);
  void IncrementNofSamples(uint64_t record_id) const;
  virtual void SetLastPosition(std::FILE* file) = 0;
 
 
 private:
  bool compress_data_ = false; 
  MdfBusType bus_type_ = MdfBusType::UNKNOWN;
  MdfStorageType storage_type_ = MdfStorageType::FixedLengthStorage;
  uint32_t max_length_ = 8; 
  std::map<uint64_t, const IChannel*> master_channels_; 
  void RecalculateTimeMaster();
  void CreateCanConfig(IDataGroup& dg_block) const;
 
  void CreateCanDataFrameChannel(IChannelGroup& group) const;
 
  void CreateCanRemoteFrameChannel(IChannelGroup& group) const;
 
  void CreateCanErrorFrameChannel(IChannelGroup& group) const;
 
  static void CreateCanOverloadFrameChannel(IChannelGroup& group);
};
 
}  // namespace mdf