SampaHeader.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef O2_MCH_RAW_SAMPA_HEADER
#define O2_MCH_RAW_SAMPA_HEADER
 
#include <cstdlib>
#include <iostream>
#include "MCHRawCommon/DataFormats.h"
 
namespace o2
{
namespace mch
{
namespace raw
{
 
enum class SampaPacketType : uint8_t {
  HeartBeat = 0,
  DataTruncated = 1,
  Sync = 2,
  DataTruncatedTriggerTooEarly = 3,
  Data = 4,
  DataNumWords = 5,
  DataTriggerTooEarly = 6,
  DataTriggerTooEarlyNumWords = 7
};
 
 
class SampaHeader
{
 public:
  explicit SampaHeader(uint64_t value = 0);
 
  explicit SampaHeader(uint8_t hamming,
                       bool p,
                       SampaPacketType pkt,
                       uint16_t numWords,
                       uint8_t h,
                       SampaChannelAddress ch,
                       uint32_t bx,
                       bool dp);
 
  bool operator==(const SampaHeader& rhs) const;
  bool operator!=(const SampaHeader& rhs) const;
  bool operator<(const SampaHeader& rhs) const;
  bool operator<=(const SampaHeader& rhs) const;
  bool operator>(const SampaHeader& rhs) const;
  bool operator>=(const SampaHeader& rhs) const;
 
  bool hasError() const;
  bool hasHammingError() const;
  bool hasParityError() const;
 
  uint8_t hammingCode() const;
  bool headerParity() const;
  SampaPacketType packetType() const;
  uint16_t nof10BitWords() const;
  uint8_t chipAddress() const;
  SampaChannelAddress channelAddress() const;
  uint32_t bunchCrossingCounter() const;
  bool payloadParity() const;
 
  void hammingCode(uint8_t hamming);
  void headerParity(bool p);
  void packetType(SampaPacketType pkt);
  void nof10BitWords(uint16_t nofwords);
  void chipAddress(uint8_t h);
  void channelAddress(SampaChannelAddress ch);
  void bunchCrossingCounter(uint32_t bx);
  void payloadParity(bool dp);
 
  constexpr uint64_t uint64() const { return mValue; }
 
  void uint64(uint64_t value);
 
  bool isHeartbeat() const;
 
 private:
  uint64_t mValue;
};
 
constexpr uint64_t sampaSyncWord{0x1555540f00113};
 
constexpr bool isSampaSync(uint64_t w)
{
  constexpr uint64_t FIFTYBITSATONE = (static_cast<uint64_t>(1) << 50) - 1;
  return ((w & FIFTYBITSATONE) == sampaSyncWord);
}
 
SampaHeader sampaSync();
 
SampaHeader sampaHeartbeat(uint8_t elinkId, uint20_t bunchCrossing);
 
DualSampaChannelId getDualSampaChannelId(const SampaHeader& sh);
 
std::string packetTypeName(SampaPacketType pkt);
 
int computeHammingCode(uint64_t value);
 
int computeHammingCode1(uint64_t value);
int computeHammingCode2(uint64_t value);
int computeHammingCode3(uint64_t value);
int computeHammingCode4(uint64_t value);
 
int computeHeaderParity(uint64_t value);
 
int computeHeaderParity1(uint64_t value);
int computeHeaderParity2(uint64_t value);
int computeHeaderParity3(uint64_t value);
int computeHeaderParity4(uint64_t value);
 
std::string asString(const SampaHeader& sh);
 
std::ostream&
  operator<<(std::ostream& os, const SampaHeader& sh);
 
} // namespace raw
} // namespace mch
} // namespace o2
 
#endif