CTBPacketContent.hpp

Go to the documentation of this file.

/*
 * CTBPacketContent.hpp
 *
 * Ported from https://cdcvs.fnal.gov/redmine/projects/dune-raw-data/repository/revisions/develop/entry/dune-raw-data/Overlays/CTB_content.h
 * 
 * Developer: willpvazquez (27 July 2022)
 *
 *  Originally Created on: Oct 8, 2017
 *      Author: nbarros
 */
 
#ifndef CTBMODULES_SRC_CTBPACKETCONTENT_HPP_
#define CTBMODULES_SRC_CTBPACKETCONTENT_HPP_ 
 
#include <cstdint>
 
namespace dunedaq {
    namespace ctbmodules{
        namespace content {
 
    // NFB: Note that order denotes bit order in the word:
    //      Upper fields are in the lsb and lower field is in the msb
    //static uint8_t format_version = 0x2;
 
    typedef struct buffer_t {
        int       handle;
        size_t    len;
    } buffer_t;
 
 
    typedef struct tcp_header_t {
        typedef uint16_t pkt_size_t;
        typedef uint8_t   seq_size_t;
        typedef uint8_t   ver_size_t;
        uint16_t packet_size         : 16; // Size of the data content in bytes
        uint8_t  sequence_id         : 8; // packet order...rotates every 256
        uint8_t  format_version : 8;
        static size_t const size_bytes = sizeof(uint32_t);
        static size_t const n_bits_size = 16;
        static size_t const n_bits_sequence_id = 8;
        static size_t const n_bits_version = 8;
    } tcp_header_t;
 
    // NFB: Careful with unions. Setting one member and then accessing another
    // is undefined behavior in C++.
    // However, I have tested that they work on gcc on the PTB
 
    typedef union tcp_header {
        tcp_header_t word;
        uint32_t     value;
    } tcp_header;
 
    namespace word {
      enum word_type {t_fback=0x0,t_lt=0x1,t_gt=0x2, t_ch=0x3,t_chksum=0x4,t_ts=0x7};
      // -- The body of a word is composed of 12 bytes
      typedef uint16_t trigger_code_t;
 
      typedef struct word_t {
        typedef uint64_t ts_size_t;
        typedef uint64_t pad_size_t;
        typedef uint64_t word_type_t;
        ts_size_t timestamp;
        pad_size_t payload : 61;
        word_type_t word_type : 3;
        static size_t const size_bytes = 4*sizeof(uint32_t);
        static size_t const size_u32 = 4*sizeof(uint32_t)/sizeof(uint32_t);
        static size_t const n_bits_timestamp  = 64;
        static size_t const n_bits_payload = 61;
        static size_t const n_bits_type = 3;
      } word_t;
 
      typedef union word{
          word_t frame;
          uint8_t *get_bytes() {return reinterpret_cast<uint8_t*>(&frame);}
      } word;
 
 
      typedef struct feedback_t {
          typedef uint64_t  ts_size_t;
          typedef uint16_t  code_size_t;
          typedef uint16_t  source_size_t;
          typedef uint32_t  wtype_size_t;
          typedef uint32_t  pad_size_t;
          ts_size_t     timestamp;
          code_size_t   code      : 16;
          source_size_t source    : 16;
          pad_size_t    padding   : 29;
          wtype_size_t  word_type : 3;
          static size_t const size_bytes = 2*sizeof(uint64_t);
          static size_t const size_u32 = size_bytes/sizeof(uint32_t);
          static size_t const n_bits_timestamp  = 64;
          static size_t const n_bits_payload = 32;
          static size_t const n_bits_type     = 3;
      } feedback_t;
 
      typedef struct ch_status_t {
           typedef uint64_t ts_size_t;
           typedef uint64_t pds_size_t;
           typedef uint64_t crt_size_t;
           typedef uint64_t beam_size_t;
           typedef uint64_t wtype_size_t;
           ts_size_t     timestamp  : 60;
           beam_size_t   beam_lo    : 4;
           beam_size_t   beam_hi    : 12;
           crt_size_t    crt        : 32;
           pds_size_t    pds        : 17;
           wtype_size_t  word_type  : 3;
           static size_t const size_bytes = 2*sizeof(uint64_t);
           static size_t const size_u32 = size_bytes/sizeof(uint32_t);
           static size_t const n_bits_timestamp  = 60;
           static size_t const n_bits_payload = 32;
           static size_t const n_bits_type = 3;
 
           // aux_functions
           beam_size_t get_beam() const {return (beam_hi << 4 | beam_lo);}
           crt_size_t  get_crt()  const {return (crt & 0xFFFFFFFF);}
           pds_size_t  get_pds()  const {return (pds & 0x1FFFF);}
 
           bool get_state_crt(const uint16_t channel) {
             return ((crt & (0x1 << channel)) != 0x0);
           }
 
           bool get_state_pds(const uint16_t channel) {
             return ((pds & (0x1 << channel)) != 0x0);
           }
 
           bool get_state_beam(const uint16_t channel) {
             return (((beam_hi << 4 | beam_lo) & (0x1 << channel)) != 0x0);
           }
       } ch_status_t;
 
       typedef struct timestamp_t {
         typedef uint64_t ts_size_t;
         typedef uint64_t pad_size_t;
         typedef uint64_t wtype_size_t;
         ts_size_t    timestamp;
         pad_size_t   padding   : 61;
         wtype_size_t word_type : 3;
         static size_t const size_bytes = 2*sizeof(uint64_t);
         static size_t const size_u32 = size_bytes/sizeof(uint32_t);
         static size_t const n_bits_timestamp = 64;
         static size_t const n_bits_unused    = 61;
         static size_t const n_bits_type      = 3;
       } timestamp_t;
 
       typedef struct trigger_t {
         typedef uint64_t ts_size_t;
         typedef uint64_t mask_size_t;
         typedef uint64_t wtype_size_t;
         ts_size_t timestamp ;
         mask_size_t  trigger_word : 61 ;
         wtype_size_t word_type : 3 ;
         static size_t const size_bytes = 2*sizeof(uint64_t);
         static size_t const size_u32 = size_bytes/sizeof(uint32_t);
         static size_t const n_bits_timestamp = 64;
         static size_t const n_bits_tmask     = 61;
         static size_t const n_bits_type      = 3;
 
         bool IsHLT() const { return word_type == word_type::t_gt ; } 
         bool IsLLT() const { return word_type == word_type::t_lt ; } 
         bool IsTrigger( const unsigned int i ) const {
           if ( IsHLT() ) return trigger_word & ( 0x1 << i ) ;
           if ( IsLLT() ) return i == 0 ? false : trigger_word & ( 0x1 << (i-1) ) ;
           return false ;
         }
       } trigger_t;
 
    } // -- namespace word
  } // -- namespace content
 } // -- namespace ctbmodules
} // -- namespace dunedaq
 
#endif /* CTBMODULES_SRC_CTBPACKETCONTENT_HPP_  */