RogueWishboneInterface.h

#ifndef ROGUE_WISHBONE_INTERFACE_H_
#define ROGUE_WISHBONE_INTERFACE_H_ 1
 
#include "pflib/WishboneInterface.h"
#include "pflib/Backend.h"
#include <memory>
 
// Forward declaration of the TCP client
namespace rogue {
namespace interfaces {
namespace memory {
class TcpClient;
class Master;
}
namespace stream {
class TcpClient;
class Slave;
}
}
namespace utilities {
namespace fileio {
class StreamWriter;
}
}
}
      
namespace pflib {
namespace rogue {
 
class RogueWishboneInterface : public WishboneInterface, public Backend {
 public:
  RogueWishboneInterface(const std::string& host, int port);
 
  virtual ~RogueWishboneInterface();
  
  virtual void wb_write(int target, uint32_t addr, uint32_t data);
  
  virtual uint32_t wb_read(int target, uint32_t addr);
  
  virtual void wb_reset();
 
  virtual void wb_errors(uint32_t& crcup_errors, uint32_t& crcdn_errors, uint32_t& wb_errors);
 
  virtual void wb_clear_counters();
 
 
  virtual void fc_sendL1A();
  virtual void fc_linkreset();
  virtual void fc_bufferclear();
  virtual void fc_calibpulse();
  virtual void fc_clear_run();
  virtual void fc_setup_calib(int pulse_len, int l1a_offset);
  virtual void fc_get_setup_calib(int& pulse_len, int& l1a_offset);
  virtual void fc_read_counters(int& spill_count, int& header_occ, int& event_count, int& vetoed);
  virtual void fc_enables_read(bool& ext_l1a, bool& ext_spill, bool& timer_l1a);
  virtual void fc_enables(bool ext_l1a, bool ext_spill, bool timer_l1a);
  virtual int fc_timer_setup_read();
  virtual void fc_timer_setup(int usdelay);
  
  virtual void daq_reset();
  virtual void daq_advance_ptr();
  virtual void daq_status(bool& full, bool& empty, int& nevents, int& next_event_size);
  virtual std::vector<uint32_t> daq_read_event();  
  virtual void daq_setup_event_tag(int run, int day, int month, int hour, int min);
 
  void daq_dma_enable(bool enable);
  void daq_dma_setup(uint8_t fpga_id, uint8_t samples_per_event);
  void daq_get_dma_setup(uint8_t& fpga_id, uint8_t& samples_per_event, bool& enabled);
  uint32_t daq_dma_status();
  void daq_dma_dest(const std::string& fname);
  void daq_dma_dest(std::shared_ptr<::rogue::interfaces::stream::Slave> sl);
  void daq_dma_run(const std::string& cmd, int run, int nevents, int rate);
  void daq_dma_close();
 
 private:
  std::shared_ptr<::rogue::interfaces::memory::TcpClient> client_;
  std::shared_ptr<::rogue::interfaces::memory::Master> intf_;  
 
  // for dma readout, these will just sit silently while dma is disabled
  std::shared_ptr<::rogue::interfaces::stream::TcpClient> dma_client_;
  std::shared_ptr<::rogue::utilities::fileio::StreamWriter> dma_dest_;
};
class RogueWishboneInterface : public WishboneInterface, public Backend {…};
 
}
}
 
 
#endif // ROGUE_WISHBONE_INTERFACE_H_