Subversion Repositories f9daq

#include "easiroc.h"

static const int  SiTCP_PORT       = 24;
SOCKET sock;

unsigned int slowdata[sizeByte_SC];
unsigned int ReadSCdata[sizeByte_RSC];
unsigned int Probedata[sizeByte_PSC];
unsigned int Pindata[sizeByte_PIN];

unsigned int Probedata[sizeByte_PSC];

int ForceStop = 0;
int EndADC = 0;
                 
#include <windows.h>

void usleep(__int64 usec)
{
    HANDLE timer;
    LARGE_INTEGER ft;

    ft.QuadPart = -(10*usec); // Convert to 100 nanosecond interval, negative value indicates relative time

    timer = CreateWaitableTimer(NULL, TRUE, NULL);
    SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);
    WaitForSingleObject(timer, INFINITE);
    CloseHandle(timer);
}              

//------------------------------------------------------------------------------------------------------
int easiroc_Init(const char* SiTCP_MASTER_IP, unsigned int daq_mode)
{
        // Start WinSock
        printf("easiroc_Init --> Start.\n");
        WORD wVersionRequested;
        WSADATA wsaData;
        if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
            printf("WSAStartup failed with error!\n");
        }
       
        //Initialize -------------------------------------------------------------
       
        sock = INVALID_SOCKET;
        struct sockaddr_in SiTCP_ADDR;
        const char*  IP;
        unsigned int port;

        sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if(sock  == INVALID_SOCKET) {  
                printf("Error: easiroc_Init::sock = %d\n", sock);
                return -1;
        }
        IP                         = SiTCP_MASTER_IP;
        port                       = SiTCP_PORT;
        SiTCP_ADDR.sin_family      = AF_INET;
        SiTCP_ADDR.sin_port        = htons(port);
        SiTCP_ADDR.sin_addr.s_addr = inet_addr(IP);
       
        struct timeval tv;
        tv.tv_sec  = 3;
        tv.tv_usec = 0;
        setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, sizeof(tv));

        int flag = 1;
        setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(flag));
       
        //Connection -------------------------------------------------------------
        int con = connect(sock, (struct sockaddr*)&SiTCP_ADDR, sizeof(SiTCP_ADDR));
        printf("easiroc_Init::connect = %d\n", con);
        if(0 > con){
                printf("SiTCP Master :: Connection fail\n");
                closesocket(sock);
                return -1;
        }

        printf("SiTCP Master :: Connection Done\n\n");
       
        // Auto Initialize -------------------------------------------------------
        PrepareFPGA();
        DebugFPGA(sock);
        printf("\nASIS Initialize : Done\n\n");
        //Sleep(1000);
       
        WriteData(sock, 37888);
        PrepareSC(1);
        TransmitSC(sock);
        printf("\nSlow Control chip1 : Done\n\n");
        PrepareReadSC(1);
        TransmitReadSC(sock);
        printf("\nRead Slow Control chip1 : Done\n\n");  
       
        WriteData(sock, 21504);
        PrepareSC(2);
        TransmitSC(sock);
        printf("\nSlow Control chip2 : Done\n\n");
        PrepareReadSC(2);
        TransmitReadSC(sock);
        printf("\nRead Slow Control chip2: Done\n\n");
       
        WriteData(sock, 5120);
        {
                unsigned int signal = 31;
                signal = signal << 16;
                unsigned int data = daq_mode;
                data = data << 8;
                signal += data;
                if(-1 == WriteData(sock, signal)){
                        return -1;
                }
                printf("\n#D : DAQ mode is %d \n", daq_mode);
        }
       
       
        return 0;
}
//------------------------------------------------------------------------------------------------------
void easiroc_Close()
{
        closesocket(sock);
        WSACleanup();
        printf("easiroc_Close -> Done.\n");
}
//------------------------------------------------------------------------------------------------------
int  WriteData(SOCKET sock, unsigned int data)
{
        int esrcdbg = 0;
       
        data += 128 << 24;;

        if(esrcdbg) printf("0x%X\n", data);
        send(sock, (char*)&data, sizeof(int), 0);
        // this sleep is needed!
        Sleep(WRITEDATA_DELAY);
       
        unsigned int buf = 0;
        unsigned int length = 4;
        int ret = recv(sock, (char*)&buf, length, 0);
       
        if ( ret > 0 ) {
                if(esrcdbg) printf("Bytes received: %d\n", ret);
                else printf(".");
        } else if ( ret == 0 ) {
                printf("Connection closed\n");
                return -1;
        } else {
                printf("recv failed: %d\n", WSAGetLastError());
                return -1;
        }
       
        return 0;
}
//------------------------------------------------------------------------------------------------------
void PrepareFPGA()
{
        Pindata[0] = 20;
        Pindata[1] = 65776;    
}
//------------------------------------------------------------------------------------------------------
void PrepareSC(int chipNo)
{
        if(chipNo == 1) {
                slowdata[0] = 192;
                slowdata[1] = 1720319;
                slowdata[2] = 4253040640;
                slowdata[3] = 413;
                slowdata[4] = 0;
                slowdata[5] = 3739423232;
                slowdata[6] = 4294967295;
                slowdata[7] = 4294967295;
                slowdata[8] = 4294967295;
                slowdata[9] = 4294967295;
                slowdata[10] = 4294967295;
                slowdata[11] = 4294967295;
                slowdata[12] = 4294967295;
                slowdata[13] = 4294967295;
                slowdata[14] = 4294967295;
        } else {
                slowdata[0] = 192;
                slowdata[1] = 4292874239;
                slowdata[2] = 4257218559;
                slowdata[3] = 478;
                slowdata[4] = 0;
                slowdata[5] = 3740340736;
                slowdata[6] = 1175693740;
                slowdata[7] = 2815957775;
                slowdata[8] = 766945147;
                slowdata[9] = 1504433946;
                slowdata[10] = 2729016485;
                slowdata[11] = 3412554245;
                slowdata[12] = 2725848728;
                slowdata[13] = 2267165112;
                slowdata[14] = 4291041547;
        }
}
//------------------------------------------------------------------------------------------------------
void PrepareReadSC(int chipNo)
{
        if(chipNo == 1) {      
                ReadSCdata[0] = 0;     
        } else {
                ReadSCdata[0] = 1;
        }
}
//------------------------------------------------------------------------------------------------------
int DebugFPGA(SOCKET socket)
{
        unsigned int buffer = 0;
        buffer += 0 << 16;
        buffer += (Pindata[0] & 255) << 8;
        if(-1 == WriteData(socket, buffer)){
                return -1;
        }

        for(int i = 1 ; i<5; ++i){
                buffer = 0;
                if(i == 4){
                        buffer += 5 << 16;      
                }else{
                        buffer += i << 16;
                }
                buffer += ((Pindata[1] >> (i-1)*8) & 255) << 8;

                if(-1 == WriteData(socket, buffer)){
                        return -1;
                }
                Sleep(1);
        }

        return 0;
}
//------------------------------------------------------------------------------------------------------
int TransmitSC(SOCKET socket)
{
  unsigned int data = 0;
  //Set SC mode -----------------------------------------------------------
  data = 0;
  data += 1 << 16;
  data += 240 << 8;
  if(-1 == WriteData(socket, data)){
    return -1;
  }

  //SC start -------------------------------------------------------------
  data = 0;
  data += 10 << 16;
  data += (slowdata[0] & 255) << 8;
  if(-1 == WriteData(socket, data)){
    return -1;    
  }

  for(int i = 1; i<15; ++i){
    for(int shift = 0; shift<4; ++shift){
      data = 0;
      data += 10 << 16;
      data += ((slowdata[i] >> 8*shift) & 255) << 8;
      if(-1 == WriteData(socket, data)){
                return -1;    
      }
      //std::cout<<"test"<<std::endl;
      Sleep(1);
    }
  }

  // Sleep(50000);

  //StartCycle -----------------------------------------------------------
  data = 0;
  data += 1 << 16;
  data += 242 << 8;
  if(-1 == WriteData(socket, data)){
    return -1;    
  }

  data = 0;
  data += 1 << 16;
  data += 240 << 8;
  if(-1 == WriteData(socket, data)){
    return -1;    
  }

  // Sleep(50000);

  //Load SC --------------------------------------------------------------
  data = 0;
  data += 1 << 16;
  data += 241 << 8;
  if(-1 == WriteData(socket, data)){
    return -1;    
  }

  data = 0;
  data += 1 << 16;
  data += 240 << 8;
  if(-1 == WriteData(socket, data)){
    return -1;    
  }

  return 0;
}
//------------------------------------------------------------------------------------------------------
int TransmitReadSC(SOCKET socket)
{
  //SCA read ---------------------------------------------------------------
  unsigned int data = 0;

  for(int i = 0; i<4; ++i){
    data = 0;
    data += 12 << 16;
    data += ((ReadSCdata[0] >> i*8) & 255) << 8;
    if(-1 == WriteData(socket, data)){
      return -1;
    }
    Sleep(1);
  }

  //StartCycle ------------------------------------------------------------
  data = 0;
  data += 1 << 16;
  data += 242 << 8;
  if(-1 == WriteData(socket, data)){
    return -1;
  }

  data = 0;
  data += 1 << 16;
  data += 240 << 8;
  if(-1 == WriteData(socket, data)){
    return -1;
  }
 
  return 0;
}
//------------------------------------------------------------------------------------------------------
int PreparePSC(int CurrentCh, int CurrentProbeType)
{
        enum Asign{fs_all, ssh_16, ssh_0, pa_16, pa_0, sizeAsign};
        enum DataName{fs, ssh_hg, ssh_lg, pa_hg, pa_lg, sizeDataName};
        enum DataName CurrentProbe;
        CurrentProbe = fs;
       
        static unsigned int ProbeBuffer = 0;
        int         flag_rst  = 0;
        int flag_input = 1;
        for(int i = 0; i<sizeByte_PSC; ++i){
                Probedata[i]   = 0;
        }

        switch(CurrentProbeType){
                case '1':
                        CurrentProbe = pa_hg;
                break;

                case '2':
                        CurrentProbe = pa_lg;
                break;

                case '3':
                        CurrentProbe = ssh_hg;
                break;

                case '4':
                        CurrentProbe = ssh_lg;
                break;

                case '5':
                        CurrentProbe = fs;
                break;

                case '6':

                break;

                case '7':

                break;

                case '8':
                        flag_rst     = 1;
                        CurrentCh    = 0;
                        ProbeBuffer  = 0;
                        CurrentProbe = fs;
                break;

                default:
                break;
        };

        if(flag_rst) {
                return 0;
        }

        if(flag_input) {
                ProbeBuffer = 1 << (31 - CurrentCh);
        }

        unsigned int buffer_16 = ProbeBuffer*ProbeBuffer;
        unsigned int buffer_0  = (ProbeBuffer >> 16)*(ProbeBuffer >> 16);
        if(CurrentProbe == ssh_hg || CurrentProbe == pa_hg) {
                buffer_16 = buffer_16 << 1;
                buffer_0  = buffer_0 << 1;
        }
        if(CurrentProbe == fs) {
                Probedata[fs_all] = ProbeBuffer;
        } else if(CurrentProbe == ssh_hg || CurrentProbe == ssh_lg) {
                if(CurrentCh > 15) {
                        Probedata[ssh_16] = buffer_16;
                } else {
                        Probedata[ssh_0]  = buffer_0;
                }
        } else if(CurrentProbe == pa_hg || CurrentProbe == pa_lg) {
                if(CurrentCh > 15){
                        Probedata[pa_16] = buffer_16;
                }else{
                        Probedata[pa_0]  = buffer_0;
                }
        } else {
                printf("bug desu\n");
        }

        for(int shift = 0; shift<32; ++shift) {
                if(((Probedata[fs_all]) >> shift) & 1) {
                        printf("!");    
                }else{
                        printf(".");    
                }
        }
        printf("\n");

        for(int index = ssh_16; index <= ssh_0; ++index) {
                for(int shift = 0; shift<32; ++shift) {
                        if(((Probedata[index]) >> shift) & 1) {
                                printf("!");
                        } else {
                                printf(".");
                        }
                }
        }
        printf("\n");

        for(int index = pa_16; index <= pa_0; ++index) {
                for(int shift = 0; shift<32; ++shift) {
                        if(((Probedata[index]) >> shift) & 1) {
                                printf("!");  
                        }else{
                                printf(".");  
                        }
                }
        }
        printf("\n");

        return 0;
}
//------------------------------------------------------------------------------------------------------
int TransmitProbe(SOCKET socket)
{
        unsigned int data = 0;
        //Set Probe mode --------------------------------------------------------
        data += 1 << 16;
        data += 208 << 8;
        if(-1 == WriteData(socket, data)) {
                return -1;
        }

        //Probe start ----------------------------------------------------------
        for(int i = 0; i<sizeByte_PSC; ++i) {
                for(int shift = 0; shift<4; ++shift) {
                        data = 0;
                        data += 10 << 16;
                        data += ((Probedata[i] >> 8*shift) & 255) << 8;
                        if(-1 == WriteData(socket, data)) {
                                return -1;
                        }
                }
        }

        //StartCycle ------------------------------------------------------------
        data = 0;
        data += 1 << 16;
        data += 210 << 8;
        if(-1 == WriteData(socket, data)) {
                return -1;    
        }

        data = 0;
        data += 1 << 16;
        data += 208 << 8;
        if(-1 == WriteData(socket, data)) {
                return -1;    
        }

        return 0;
}
//------------------------------------------------------------------------------------------------------
int easiroc_fTransmitSC()
{
  if(WriteData(sock, 37888) != 0) return -1;          
  PrepareSC(1);
  if(TransmitSC(sock) != 0) return -1;
  printf("\nSlow Control chip1 : Done\n\n");
 
  if(WriteData(sock, 21504) != 0) return -1;          
  PrepareSC(2);
  if(TransmitSC(sock) != 0) return -1;    
  printf("\nSlow Control chip2 : Done\n\n");
 
  if(WriteData(sock, 5120) != 0) return -1;            
 
  return 0;    
}
//------------------------------------------------------------------------------------------------------
int easiroc_fTransmitReadSC()
{
        if(WriteData(sock, 37888) != 0) return -1;          
        PrepareReadSC(1);
        if(TransmitReadSC(sock) != 0) return -1;
        printf("\nRead Slow Control chip1 : Done\n\n");

        if(WriteData(sock, 21504) != 0) return -1;          
        PrepareReadSC(2);
        if(TransmitReadSC(sock) != 0) return -1;    
        printf("\nRead Slow Control chip2 : Done\n\n");

        if(WriteData(sock, 5120) != 0) return -1;            

        return 0;      
}
//------------------------------------------------------------------------------------------------------
int easiroc_fAsicInitialize()
{
        PrepareFPGA();
        DebugFPGA(sock);
        printf("\nASIS Initialize : Done\n\n");
       
        return 0;      
}
//------------------------------------------------------------------------------------------------------
int easiroc_fTransmitProbe(int CurrentCh, int CurrentProbe)
{
        //printf("\neasiroc_fTransmitProbe: CurrentCh : %d | CurrentProbe: %d\n\n", CurrentCh, CurrentProbe);
       
        if(CurrentCh < 32) {
                if(WriteData(sock, 37888)!= 0) return -1;      
        } else if(CurrentCh > 31) {
                if(WriteData(sock, 21504)!= 0) return -1;      
                CurrentCh = CurrentCh - 32;
        }
       
        //printf("\neasiroc_fTransmitProbe: Preparing PSC\n\n");
        if(PreparePSC(CurrentCh, CurrentProbe)!= 0) {
                printf("\neasiroc_fTransmitProbe: PreparingPSC ERROR !!!!!!!!!!!!!!!!!!!\n\n");
                return -1;
        }
        //printf("\neasiroc_fTransmitProbe: TransmitProbe\n\n");    
        if(TransmitProbe(sock)!= 0) {
                printf("\neasiroc_fTransmitProbe: TransmitProbe ERROR !!!!!!!!!!!!!!!!!!!\n\n");
                return -1;      
        }
        //WriteData(3, 5120);
        //printf("\nTransmitProbe: Success!\n\n");            
                         
        return 0;      
}
//------------------------------------------------------------------------------------------------------
int ADCOneCycle_wHeader_ver2(SOCKET socket, FILE* file)
{
        static const int NofHeader = 3;

        unsigned int DataBuffer[1000];
        memset(DataBuffer, 0, sizeof(DataBuffer));
        unsigned int *ptr_DataBuf = DataBuffer;
        unsigned int TotalRecvByte  = 0;
        unsigned int TotalRecvEvent = 0;

        unsigned int sizeHeader = NofHeader*sizeof(int);

        unsigned int Header[] = {1, 1, 1};
        int ret = 0;
       
        ret = recv(sock, (char*)Header, sizeHeader, 0);
        if(ret <= 0 && EndADC == 1) {
                if(EndADC != 0) printf("Fatal ADC ERROR : recv\n");
                return -1;
        }
       
        // sleep necessary! ERRORS happen if trigger rate lower than ~ sleep frequency!
        usleep(200);
        //Sleep(1);

        //printf("Header1 (0xFFFFEA0C) : 0x%x | Header2 (0x00000100) : 0x%x\n", Header[0], Header[1]);
        if(Header[0] != 0xFFFFEA0C) {
                printf("Fatal ADC ERROR : HEADER\n");
                printf("Header1 : 0x%x | Header2 : 0x%x | Header3 : 0x%x\n", Header[0], Header[1], Header[2]);
                return -1;
        } else {
                unsigned int sizeData = (sizeof(int)*Header[1] & 0xffff);
                unsigned int NofWord = (Header[1] & 0xffff);
                unsigned int OneData[NofWord];
               
                recv(socket, (char*)OneData, sizeData, 0);

        //     for(int i = 0; i<NofWord; ++i){ std::cout << std::hex << OneData[i] << std::endl; }

                memcpy(ptr_DataBuf, Header, sizeHeader);
                ptr_DataBuf += NofHeader;

                memcpy(ptr_DataBuf, OneData, sizeData);
                ptr_DataBuf += sizeData/sizeof(int);

                TotalRecvByte += sizeHeader + sizeData;
                ++TotalRecvEvent;
        }

        if(EndADC != 1){
                for(unsigned int i = 0; i<TotalRecvByte/sizeof(int); ++i) {
                        unsigned int buffer = DataBuffer[i];
                        fwrite((char*)&buffer, sizeof(int), 1, file);
                }
        }

        return 0;
}
//------------------------------------------------------------------------------------------------------  
void ADCStop(SOCKET socket)
{
  unsigned int signal = 0;
  printf("ADC exit process\n");
  signal += 16 << 24;
  signal += 100 << 16;
  send(socket, (char*)&signal, sizeof(int), 0);
  Sleep(1);
 
  signal = 0;
  signal += 100 << 16;
  send(socket, (char*)&signal, sizeof(int), 0);

  Sleep(10);

  return;
}
//------------------------------------------------------------------------------------------------------  
int ContinuousADC_ver2(SOCKET socket, char *file_name, int MaxCycleNum)
{
       
        unsigned int signal = 0;
        int EventNum = 0;
       
        FILE *file = NULL;
        file = fopen(file_name, "wb");
        if(file==NULL) {
                printf("ContinuousADC_ver2: ERROR opneing file %s\n", file_name);
                return -1;
        }

        signal += 32 << 24;
        signal += 100 << 16;
        send(socket, (char*)&signal, sizeof(int), 0);
        Sleep(100);
       
        while(EventNum < MaxCycleNum){   
                //Sleep(10);
                ADCOneCycle_wHeader_ver2(socket, file);
                ++EventNum;
                if(0 == EventNum%1000){
                printf("Event # %d\n", EventNum);
        }

        if(0 || EventNum == MaxCycleNum|| ForceStop == 1) {
                ADCStop(socket);

                EndADC = 1;
                int abort = 0;
                while(0 == ADCOneCycle_wHeader_ver2(socket, file)) {
                        Sleep(1);
                        if(abort == 50) {
                                ADCStop(socket);
                                abort = 0;
                        }
                        //printf("dummy data\n");
                        printf(".");
                        ++abort;
                }

                EndADC    = 0;
                ForceStop = 0;
                break;
                }
        }

        printf("\nEnd ADC\n");
        fclose(file);

        return 0;
}
//------------------------------------------------------------------------------------------------------
int easiroc_fDAQ(char *file_name, int MaxCycleNum)
{
        printf("easiroc_fDAQ: Starting DAQ with file_name = %s | MaxCycleNum = %d\n", file_name, MaxCycleNum);
        if(ContinuousADC_ver2(sock, file_name, MaxCycleNum) != 0) return -1;
       
        return 0;      
}