WIBEthFrame.hpp

Go to the documentation of this file.

 
#ifndef FDDETDATAFORMATS_INCLUDE_FDDETDATAFORMATS_WIBETHFRAME_HPP_
#define FDDETDATAFORMATS_INCLUDE_FDDETDATAFORMATS_WIBETHFRAME_HPP_
 
#include "Utils.hpp"
 
#include "detdataformats/DAQEthHeader.hpp"
 
#include <algorithm> // For std::min
#include <cassert>   // For assert()
#include <cstdint>   // For uint32_t etc
#include <cstdio>
#include <cstdlib>
#include <stdexcept> // For std::out_of_range
 
namespace dunedaq::fddetdataformats {
 
// NOLINTBEGIN(build/unsigned)

class WIBEthFrame
{
public:
  // The definition of the format is in terms of 64-bit words
  using word_t = uint64_t;
 
  static constexpr int s_bits_per_adc = 14;
  static constexpr int s_bits_per_word = 8 * sizeof(word_t);
  static constexpr int s_time_samples_per_frame = 64;
  static constexpr int s_channels_per_half_femb = 64;
  static constexpr int s_half_fembs_per_frame = 1;
  static constexpr int s_num_channels = s_channels_per_half_femb * s_half_fembs_per_frame;
  static constexpr int s_num_adc_words_per_ts = s_num_channels * s_bits_per_adc / s_bits_per_word;
 
  struct WIBEthHeader
  {
    word_t colddata_timestamp_0 : 15;
    word_t pad_0 : 1;
    word_t colddata_timestamp_1 : 15;
    word_t pad_1 : 1;
    word_t cd : 1;
    word_t crc_err : 2;
    word_t link_valid : 2;
    word_t lol : 1;
    word_t wib_sync : 1;
    word_t femb_sync : 2;
    word_t pulser : 1;
    word_t calibration : 1;
    word_t ready : 1;
    word_t context : 8;
    word_t version : 4;
    word_t channel : 8;
    word_t extra_data;
  };
  static_assert(sizeof(WIBEthHeader) == 8 + 8); // 8 bytes for the bitfield section, 8 for the extra_data
 
  detdataformats::DAQEthHeader daq_header;
  WIBEthHeader header;
  word_t adc_words[s_time_samples_per_frame][s_num_adc_words_per_ts]; // NOLINT

  uint16_t get_adc(int i_channel, int i_sample = 0) const;

  void set_adc(int i_channel, int i_sample, uint16_t adc_val);

  uint64_t get_timestamp() const { return daq_header.get_timestamp(); }

  void set_timestamp(const uint64_t new_timestamp) { daq_header.timestamp = new_timestamp; }

  uint8_t get_channel() const { return header.channel; }

  void set_channel(const uint8_t new_channel) { header.channel = new_channel; }
};
static_assert(sizeof(WIBEthFrame) == sizeof(detdataformats::DAQEthHeader) + sizeof(WIBEthFrame::WIBEthHeader) +
                                       sizeof(WIBEthFrame::word_t) * WIBEthFrame::s_time_samples_per_frame *
                                         WIBEthFrame::s_num_adc_words_per_ts);
 
static_assert(std::endian::native == std::endian::little,
              "The WIBEthFrame bitfield layout assumes little-endian architecture");
 
static_assert(std::is_trivially_copyable_v<WIBEthFrame>,
              "WIBEthFrame isn't trivially copyable and can't be safely std::memcpy'd");
static_assert(std::is_standard_layout_v<WIBEthFrame>,
              "WIBEthFrame isn't standard layout; reinterpret_cast and offsetof can't safely be used with it");
 
} // namespace dunedaq::fddetdataformats
 
#include "detail/WIBEthFrame.hxx"
 
// NOLINTEND(build/unsigned)
 
#endif // FDDETDATAFORMATS_INCLUDE_FDDETDATAFORMATS_WIBETHFRAME_HPP_