crateImpl.h

#ifndef SCTAPI_CRATE_IMPL
#define SCTAPI_CRATE_IMPL

// Make sure all compilations have same Crate structure!
#include "config.h"

#include <list>
#include <map>
#include <memory>
#include <mrs/message.h>

#include <boost/thread.hpp>
#include <boost/shared_ptr.hpp>

#include "crate.h"

#if USE_THREADS
enum RodPrimState { MYPRIM_STATE_LOADED, MYPRIM_STATE_EXECUTING, MYPRIM_STATE_COMPLETE, MYPRIM_STATE_IDLE };
#endif

namespace SctPixelRod {
  class RodOutList;
  class RodModule;
  class TimModule;
  class VmeInterface;
}

namespace SctApi {
  class PrimListWrapper;

  struct RodStatus {
#if USE_THREADS
    std::list<boost::shared_ptr<PrimListWrapper> > listQueue;
    boost::mutex mutex;
    RodPrimState currState;
#endif
    int slaves;

    std::vector<SctConfiguration::BOCChannelConfig> savedBocSetup;
    std::auto_ptr<SctConfiguration::BOCGlobalConfig> savedBocRegisters;
  };

class CrateImpl : public Crate {
  // Don't use copy constructor or assignment operator
  CrateImpl(const CrateImpl&);
  CrateImpl &operator=(const CrateImpl&);
 public:

  CrateImpl(unsigned int partition, unsigned int crate, 
            boost::shared_ptr<SctConfiguration::Configuration> newConf = boost::shared_ptr<SctConfiguration::Configuration>() );

  ~CrateImpl();

  /************** Interaction with Configuration **************/


  int initialiseCrate();


  int initialiseTim();


  int initialiseRod(unsigned int rod);


  int initialiseBOC(unsigned int rod);


  int configureBOC(unsigned int rod);

  /*************** Primlists *********************/


  int sendPrimList(unsigned int rod, boost::shared_ptr<PrimListWrapper> prim);


  int sendPrimListAll(boost::shared_ptr<PrimListWrapper> prim);


  int awaitResponse(unsigned int rod, int timeout);


  int awaitResponseAll(int timeout);


  boost::shared_ptr<SctPixelRod::RodOutList> getResponse(unsigned int rod);

  void setMrsStream(MRSStream *stream);

  /***************** Messages ******************/


  bool getRodMessage(unsigned int rod, char *buffer, unsigned long &length);

  /************** Misc read/writes *****************/


  int mdspBlockRead(unsigned int rod, long dspStart, unsigned long *buffer, unsigned long numWords);


  int slvBlockRead(unsigned int rod, long dspStart, unsigned long *buffer, unsigned long numWords, long slaveNumber);


  int slvBlockWrite(unsigned int rod, long dspStart, unsigned long* buffer, unsigned long numWords, long dspNumber);


  int mdspBlockWrite(unsigned int rod, long dspStart, unsigned long *buffer, unsigned long numWords);


  unsigned long readRodStatusReg(unsigned int rod, long regNumber);



  unsigned long readRodCommandReg(unsigned int rod, long regNumber);


  unsigned long dspSingleRead(unsigned int rod, const unsigned long dspAddr, long dspNumber);


  int dspSingleWrite(unsigned int rod, unsigned long dspAddr, unsigned long buffer, long dspNumber);

  void status();

  void primListControl(unsigned int rod, PLControl function);

  void printBOCSetup(unsigned int rod);

  std::vector<SctConfiguration::BOCChannelConfig> currentBOCSetup(unsigned int rod);

  void printBOCRegisters(unsigned int rod);

  SctConfiguration::BOCGlobalConfig currentBOCRegisters(unsigned int rod);

  void saveBOCSetup(unsigned int rod);

  void saveBOCRegisters(unsigned int rod);

  void restoreBOCSetup(unsigned int rod);

  void restoreBOCRegisters(unsigned int rod);

  bool checkBOCLasersOn(unsigned int rod);

  void enterBOCClockBy2Mode(unsigned int rod);

  void leaveBOCClockBy2Mode(unsigned int rod);


  void modifyBOCParam(unsigned int type, unsigned int val, bool raw);

  void modifyBOCParam(unsigned int rod, unsigned int channel, unsigned int type, unsigned int val, bool raw);

  void lasersOff();

  /* ******************* TIM Functions ***************************/


  void timSetFrequency(double trigFreq, double rstFreq);

  void freeTriggers();

  void stopTriggers();

  void timL1A();

  void timCalL1A(int delay);

  void timECR();

  void timBCR();

  void timFER();

  void sendTimBurst(int count);

  void timVerbose();

  void timRegLoad(int reg, UINT16 val);

  UINT16 timRegRead(int reg);

  bool slavePresent(int rod, int index) const;

  void slaveStarted(int rod, int slave);

  bool RODPresent(int rod) const;

  long getRodSlot(int rod) const;

  int getRodRevision(int rod) const;

  void stopPolling();

  void resumePolling();

 private:
  void rodInitialiseThread(int rod);

  void setupScanTx(unsigned int rod, unsigned int channel);

  void setupScanRawTx(unsigned int rod, unsigned int channel);


  SctPixelRod::RodModule *getRod(unsigned int rod) const;

  const RodStatus &getRodData(unsigned int rod) const;
  RodStatus &getRodData(unsigned int rod);

  void doTextBuffer(SctPixelRod::RodModule &rod0);

#if USE_THREADS
  void pollingLoop();
#endif

  typedef std::map<unsigned int, std::pair<RodStatus *, SctPixelRod::RodModule *> > RodMap;

  RodMap rodMap;

  SctPixelRod::TimModule *tim;

  boost::shared_ptr<SctConfiguration::Configuration> config;

  SctPixelRod::VmeInterface *vme;

  const unsigned int partition;

  const unsigned int crate;

  MRSStream *mrs;

  // Leave this in for no threads (its nice and small...)
  bool m_stopPolling;

  // Whether polling should be done
  bool m_enablePolling;

#if USE_THREADS

  std::list<boost::shared_ptr<PrimListWrapper> > listQueueAll;

  /* **********  Mutexes  ********** */
  boost::mutex vmeMutex;

  boost::condition primQueue_notEmpty;
  boost::mutex primQueue_mutex;

  /* ******* Threads ******/
  std::auto_ptr<boost::thread> pollThread;

  // So ROD initialisation threads can count RODs independently
  int rodCounter;
#endif
};

}  // End of namespace SctApi
#endif

---