ICECALv3.h

Go to the documentation of this file.

//$Id: ICECALv3.cpp,v 1.0 2013/11/11 13:11:24 jmauricio Exp $
//------------------------------------------------------------------------------
//
//  Package    : ICECALv3
//
//  Description:
//
//  Author(s)  : Joan Mauricio
//  Date       : 2013/11/11
//
//------------------------------------------------------------------------------

#ifndef __ICECALv3_H_
#define __ICECALv3_H_

#include "Element.h"
#include "Register.h"
#include <stdlib.h> 
#include <string>
#include <python2.7/Python.h>
#include <iostream>
#include <fstream>
#include <time.h>

using namespace std;

#define CALIBRATION_FILE_VER "0.99"
#define SPI_N_RETRIES 2


//Commands:
#define SC_SOFT_RST                     0x40
#define SC_MOSI_MISO_BYPASS     0xFF

//Status addresses
#define ICECAL_VERSION_ADDR     0xB0
#define BXID_RESYNCH_ADDR           0xB1

    //Data:
    //Configuration Data//
    //SPI @ of the delay line channels.
    const int delayLineAddrCh[4] = { 28, 29, 30, 31 };

    //SPI @ of ICECAL analog channels.
    const int icecalLSBAddrCh[4] = {  0,  1,  2,  3 };

    const int icecalMSBAddrCh[4] = {  4,  5,  6,  7 };

    //SPI @ of the Main ICECAL chip registers.
    const int icecalMainAddr[4]  = {  8,  9, 10, 11 };


    typedef unsigned long  U32;
    typedef unsigned short U16;
    typedef unsigned char  U8;


class ICECALv3 : public Element {
public:

    //Constructor
    ICECALv3();
    
    //Parameter settings...
  void setAddress (U8  address) {   confReg->setAddress(address);   }
    void setNRetries(int nRet   ) {     nRetries = nRet;                                }

    //Slow Control Commands:
    void resetPumps(){                                      spiWrite(SC_SOFT_RST,0);                                    };
    void bypassMisoMosi(U16 writeData){     spiWrite(SC_MOSI_MISO_BYPASS,writeData);    };

    //Slow Control Data:
    //Functions to Read/Write data from delay line registers...
    PyObject*    getDelayLineCh(int ch);
    StatusCode setDelayLineCh(int ch, PyObject*);

    //Functions to Read/Write data from ICECAL Analog channels...
    PyObject*  getAnalogCh(int ch);
    StatusCode setAnalogCh(int ch, PyObject*);

    //Functions to Read/Write data from ICECAL Main Register...
    PyObject*  getMainReg();
    StatusCode setMainReg(PyObject*);

    //FER (Frame Error Rate) Test. For each of the 'nTest', all the configuration registers will be checked. 
    PyObject* spiFERTest(long nTest);  

    //Stores the current ASIC configuration into a text file.
    StatusCode dumpConfig(string configFile, PyObject* chipId);

    //Loads the configuration from a file.
    PyObject* loadConfig(string configFile);

    double version();
    bool   bxidResynchStatus();
    void     spiAddressScan();

  ~ICECALv3(){
  }

  void help() { info("ICECALv3 "+name()+". No help.","ICECALv3::help"); };

  StatusCode init() {
    return StatusCode::SUCCESS;
  };
  
  void reset();

  void update () {
    
  };

private:

    //Pointer where ICECAL configuration registers are mapped.
  Register*         confReg;
   
    //Number of attempts that we will perform before considering TX ERROR.
    int nRetries;

    bool err;

    //Low-level read/write functions.
    U16  spiRead    (U8 confRegAddr, U8 offsetAddr=128);
    void spiWrite   (U8 confRegAddr, U16 confRegData);

    //Safe SPI Write function: write + readback + retry (if needed).
    bool spiWriteSafe(U8 confRegAddr, U16 confRegData);

    //Writes the obtained parameters from configuration register(s).
    bool writeAsicParams(string fileName, PyObject* params);

    //Generates a python list of parameter values to configure electronics.
    int parseParameterList(string configFile, string paramName[64], int paramValue[64]);
    PyObject* fillParams(string paramListRet[],int paramListLen,string paramName[64],int paramValue[64],int fileParamLen);

    bool checkChNumber(int ch)
    {
        if(ch < 0 || ch > 3) {
            error(itos(ch)+" is not a valid ICECAL channel number. Valid numbers [0-3].","ICECALv3::checkChNumber");
            return false;
        }
        else return true;
    }

    std::string itohs(int value)
    {
        char buff[32];
      if      (value < 256)   sprintf(buff,"%02X",value);
        else if (value < 65536) sprintf(buff,"%04X",value);
        else                                    sprintf(buff,"%08X",value);
        return std::string(buff);
    }
};

#endif