TApi.h

// File: TApi.h

#ifndef SCTAPI_TAPI_H
#define SCTAPI_TAPI_H

#include <list>
#include <string>
#include <TArrayD.h>
#include <TArrayI.h>
#include <TArrayL.h>
#include <TArrayS.h>

// Declare classes used + define RodLabel
#include "SctApiFwd.h"

#ifndef __CINT__
#include "TApiWrappers.h"
#endif

#include "processor.h"

#include <TObject.h>

// using namespace SctPixelRod;

class TriggerWrapper;
class ScanDefWrapper;
class ScanMonitorWrapper;

class TTrigger : private TriggerWrapper {
  TTrigger &operator=(const TTrigger &);

 public:
  TTrigger();

  TTrigger(const TTrigger &);

  virtual ~TTrigger();

  void singleL1A();
  void doubleL1A(int delay);
  void delayedL1A(int delay);
  void calL1A(int delay);
  void pulseL1A(int delay);
  void softL1A(int delay);
  void softCalL1A(int delay, int delay2);
  void softPulseL1A(int delay, int delay2);
  void bcL1A(int delay);
  void bcCalL1A(int delay, int delay2);
  void bcPulseL1A(int delay, int delay2);

  void print();

  int incCmd;

  int incData;

  int source;
  
  double frequency;

  int random;

 private:
  void update();

  friend class TApi;
  friend class TScanDef;

  // For CINT and ROOT
  ClassDef(TTrigger,1)
};

class TScanDef : private ScanDefWrapper {
  TScanDef &operator=(const TScanDef &);

 public:
  TScanDef();

  TScanDef(const TScanDef &);

  virtual ~TScanDef();

  void print();

  void configure(UINT16 type, FLOAT32 start, FLOAT32 stop, FLOAT32 step);

  void configure2(UINT16 type, FLOAT32 start, FLOAT32 stop, FLOAT32 step);

  void setScanPoint(int index, FLOAT32 value);

  void setScanPoint2(int index, FLOAT32 value);

  void setTriggersPoint(int index, UINT32 ntrigs);

  long trigsPerBurst;

  int scanVariable;

  int scanVariable2;

  TTrigger trigSequence;

  TTrigger trigSequence2;

  int full;

  int bits32;

  int loopCalLine;

  int distSlave;

  int debug;

  int tim;

  int nth;

  int nth_rem;

  int enableDataMode;

  int ccode;

  int ope;

 private:
  void update();

  friend class TApi;

  // For CINT and ROOT
  ClassDef(TScanDef,1)
};

class TScanMonitor : private ScanMonitorWrapper {
  TScanMonitor &operator=(const TScanMonitor &);
  TScanMonitor(const TScanMonitor &);

 protected:
  TScanMonitor();

 public:
  virtual ~TScanMonitor();

  void newBin(int prevTriggers, int newBin);
  void finishScan();

 private:

  friend class ScanMonitorWrapper;

  // update() ???
  // For CINT and ROOT
  ClassDef(TScanMonitor,1)
};

class TApi : public TObject {
  public:
    TApi(std::string plugin = "xml");

    ~TApi();


    void initialiseAll(int runNumber);
    
    bool isInitialised();

    void shutdownAll();

    void setRunNumber(int newRun);

    void setScanNumber(int newScan);

    void changeRunMode(enum SctApi::RunType mode);

    /*************** ROD Diagnostics ********************/


    void echo(unsigned int rod,
              unsigned int length, unsigned long *data);


    void echoAll(unsigned int length, unsigned long *data);


    void echoSlave(unsigned int rod,
                   unsigned int slave, unsigned int length, unsigned long *data);

    void loadConfiguration();

    void loadModuleConfigurations();

    void configureBOC(unsigned int rod);

    void awaitResponse(unsigned int rod, int timeout = 5);

    unsigned long *getResponse(unsigned int rod);

    unsigned long *getResponse(unsigned int rod, 
                               unsigned long *length);


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


    void flashLED(unsigned int rod,
                  long slaveNumber, long period = 1000, long flashes = 10);


    void status();

    /***************** Direct ROD access (Debug only) ********************/


    Int_t dspBlockDump(unsigned int rod,
                       long dspStart, long numWords, long dspNumber, bool usePrimitive = true);


    Int_t dspBlockDumpFile(unsigned int rod,
                           long dspStart, long numWords, long dspNumber, const char *filename, bool usePrimitive = true);


    unsigned long *dspBlockRead(unsigned int rod,
                                long dspStart, long numWords, long dspNumber, 
                                unsigned long *length, bool usePrimitive = true);

    int dspBlockWrite(unsigned int rod,
                      unsigned long *buffer, unsigned long dspAddress, long numWords, 
                      long dspNumber, bool usePrimitive = true);

    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);

    void dspSingleWrite(unsigned int rod,
                        unsigned long dspAddr, unsigned long value, long dspNumber);

    void createDebugPrimList();

    void addDebugPrimList(unsigned long length, long index, long id, long version,
                          unsigned long * body);

    void sendDebugPrimList(unsigned int rod);

    void sendDebugPrimListAll();

    void sendDebugSlavePrimList(unsigned int rod,
                                unsigned int slave, bool await, bool response);

    void debugPrimListFromFile(const char *fileName);

    void dumpDebugPrimList();

    std::list<SctApi::RodLabel> listRods();

    unsigned long *retrieveModule(UINT32 mid);

    /**** Official SCTAPI bit (majority unimplemented) ******/


    UINT32 findModule(const char *sn);

    UINT32 findModule(INT32 mur, INT32 module);

    UINT32 findBarrelModule(INT32 barrel, INT32 row, INT32 number);

    UINT32 findEndcapModule(INT32 disk, INT32 ring, INT32 number);

    void getABCDModules(UINT32 bank);

    void getABCDModule(UINT32 mid, UINT32 bank);

    void setABCDModules(UINT32 bank);
    
    void copyABCDModules(UINT32 source, std::list<UINT32> targets);
    
    void copyABCDModules(UINT32 mid, UINT32 source, std::list<UINT32> targets);
    
    // Set all module configs in many ROD bank
    void TApi::setABCDModules(std::list<UINT32> banks);

    void setABCDModule(UINT32 mid, UINT32 bank);


    void sendABCDModule(UINT32 mid, UINT32 bank, UINT32 type=SctApi::SCTAPI_CONFIG_ALL);


    void sendABCDModules(UINT32 bank, UINT32 type=SctApi::SCTAPI_CONFIG_ALL);

    void modifyABCDMask(UINT32 mid, UINT32* mask);

    void modifyABCDTrims(UINT32 mid, UINT8* trims);

    void setAutoUpdateBanks(std::list<UINT32> banks);

    void setAutoUpdateBank(UINT32 bank);

    void modifyABCDVar(UINT32 typ, FLOAT32 var);

    void modifyABCDVar(UINT32 mid, UINT32 typ, FLOAT32 var);

    void modifyABCDVar(UINT32 mid, UINT32 c, UINT32 typ, FLOAT32 var);

    void modifyABCDVarROD(UINT32 mid, UINT32 chip, UINT32 typ, FLOAT32 var, UINT32 bank);

    void modifyABCDVarROD(UINT32 mid, UINT32 chip, UINT32 typ, FLOAT32 var, std::list<UINT32> banks);

    void modifyABCDVarROD(UINT32 mid, UINT32 typ, FLOAT32 var, UINT32 bank);

    void modifyABCDVarROD(UINT32 mid, UINT32 typ, FLOAT32 var, std::list<UINT32> banks);

    void modifyABCDVarROD(UINT32 typ, FLOAT32 var, UINT32 bank);

    void modifyABCDVarROD(UINT32 typ, FLOAT32 var, std::list<UINT32> banks);

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

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

    void defaultScan(int type);

    void tidyHistogramming();

    TScanMonitor *startAsyncScan(TScanDef tscan);

    void doScan(TScanDef scan);

    void awaitScan();

    void doRawScan(TScanDef scan, int delay, int width, bool configure = true, bool clkBy2 = false);

    void sendRodTrigger(unsigned int rod, TTrigger trig, unsigned long count, int scan_point=0);

    unsigned long sendTriggers(TTrigger trig, unsigned long count);


    void printABCDModule(int mid);


    void printABCDRodModule(int mid, int bank);

    void printBOCSetup(unsigned int rod);

    void currentBOCSetup(unsigned int rod);

    void printBOCRegisters(unsigned int rod);

/*     void currentBOCRegisters(unsigned int rod); */

    void saveBOCSetup(unsigned int rod, UINT32 bank);

    void saveBOCRegisters(unsigned int rod, UINT32 bank);

    void restoreBOCSetup(unsigned int rod, UINT32 bank);

    void restoreBOCRegisters(unsigned int rod, UINT32 bank);

    void rawData(unsigned int rod, int delay, int units, bool setMask = true, TTrigger trig = TTrigger());

    char *probe(unsigned int rod, signed int harness = -1);

    char *probeWithTrigger(unsigned int rod, TTrigger trig, signed int harness = -1);

    void probeScan(unsigned int rod, 
                   TScanDef scan, signed int harness = -1);

    bool checkAllModulesProbe(const char *value);

    void autoConfigure();

    void bocHistogram(unsigned int rod, 
                      unsigned int samples, unsigned int numLoops);

    void rodMode(unsigned int rod,
                 int mode, int flag, int fifoSetup, int nBins, int delay, int message);

    void standardRegisterDump(unsigned int rod);


    void lasersOff();

    void scanEvents(unsigned int rod, int sl = -1, 
                    bool extFlag = false, bool errorType = false);

    void decodeEvent(unsigned int rod, 
                     int sl, int index, bool extFlag = false, bool errorType = false);

    void decodeConfig(unsigned int rod, 
                      bool skipTrim = false, bool bypass = false);

    void testLinkOutSelect(unsigned int rod,
                           unsigned int link);

    void setDebugOption(const char *opt);

    void unsetDebugOption(const char *opt);

    void listEnabledDebugOptions();

    void listDebugOptions();

    void debugStepHistogram();

    void debugContinueHistogram();

    void debugAbortHistogram();

    /* *************  TIM functs **************/


    void timSetFrequency(double trigFreq, double rstFreq);
    
    double timGetResetFrequency();

    double timGetTriggerFrequency();


    void freeTriggers();

    void stopTriggers();

    void timL1A();

    void timCalL1A(int delay);

    void timSoftReset();

    void timBCReset();

    unsigned long sendTimBurst(unsigned long count, int random, bool external=false);

    unsigned long runTimSequence(unsigned long count, int random, bool external=false);

    void timVerbose();

    void timRegLoad(int reg, UINT16 val);

    UINT16 timReadRegister(int reg);

    void requestHardReset(UINT32 mid);

    void resumePolling();

    void stopPolling();
 private:
    TApi(const TApi&);
    TApi &operator=(const TApi &);

    SctApi::SctApi *worker;

    // For CINT and ROOT
    ClassDef(TApi,1)
};

/*  /// The name tapi is defined in the shared library (it still needs initialising) */
/*  //extern TApi *tapi; */
#endif

---