WebSVN – f9daq – Diff – //cvi/apps/l2d2_easyroc/easiroc.c

 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 iniData[sizeByte_PIN + 2*sizeByte_SC + 2*sizeByte_RSC];
 unsigned int Probedata[sizeByte_PSC];
 int ForceStop = 0;
 int EndADC = 0;
 #include <windows.h>
 void usleep(__int64 usec)
+{
     HANDLE timer;
     LARGE_INTEGER ft;
                 return -1;
+        }
         IP                         = SiTCP_MASTER_IP;
         port                       = SiTCP_PORT;
         SiTCP_ADDR.sin_family      = AF_INET;
-        SiTCP_ADDR.sin_port        = htons(port);
+        SiTCP_ADDR.sin_port        = htons((unsigned short)port);
         SiTCP_ADDR.sin_addr.s_addr = inet_addr(IP);
         struct timeval tv;
         tv.tv_sec  = 3;
         tv.tv_usec = 0;
                 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);
         return 0;
+}
 //------------------------------------------------------------------------------------------------------
 void easiroc_Close()
 {
         closesocket(sock);
         WSACleanup();
         printf("easiroc_Close -> Done.\n");
+}
 //------------------------------------------------------------------------------------------------------
         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;
 }
+//------------------------------------------------------------------------------------------------------
+int easiroc_LoadIni(const char *iniFile)
+{
+        FILE *fp=fopen(iniFile, "rt");
+        if(!fp) {
+                printf("easiroc::LoadIni() cannot open file %s !!!\n", iniFile);
+                return 0;
+        }
+        char lbuff[256];
+        int counter = 0;
+        while(1) {
+                int c = fgetc(fp);
+                if(feof(fp)) break;
+                if( '#' == (char)c ) {
+                        fgets(lbuff,256,fp);
+                        //printf("Found Comment line: %s", lbuff);
+                } else {
+                        ungetc(c, fp);
+                        fscanf(fp, "%u\n", &iniData[counter] );
+                        //printf("Found value [%d] %u\n", counter, iniData[counter]);
+                        counter++;
+                }
+        }
+        fclose(fp);
+        return 1;
+}
 //------------------------------------------------------------------------------------------------------
 void PrepareFPGA()
+{
-        Pindata[0] = 20;
+        Pindata[0] = iniData[0];
-        Pindata[1] = 65776;
+        Pindata[1] = iniData[1];
+}
 //------------------------------------------------------------------------------------------------------
 void PrepareSC(int chipNo)
 {
         if(chipNo == 1) {
-                slowdata[0] = 192;
+                slowdata[ 0] = iniData[sizeByte_PIN +  0];
-                slowdata[1] = 1720319;
+                slowdata[ 1] = iniData[sizeByte_PIN +  1];
-                slowdata[2] = 4253040640;
+                slowdata[ 2] = iniData[sizeByte_PIN +  2];
-                slowdata[3] = 413;
+                slowdata[ 3] = iniData[sizeByte_PIN +  3];
-                slowdata[4] = 0;
+                slowdata[ 4] = iniData[sizeByte_PIN +  4];
-                slowdata[5] = 3739423232;
+                slowdata[ 5] = iniData[sizeByte_PIN +  5];
-                slowdata[6] = 4294967295;
+                slowdata[ 6] = iniData[sizeByte_PIN +  6];
-                slowdata[7] = 4294967295;
+                slowdata[ 7] = iniData[sizeByte_PIN +  7];
-                slowdata[8] = 4294967295;
+                slowdata[ 8] = iniData[sizeByte_PIN +  8];
-                slowdata[9] = 4294967295;
+                slowdata[ 9] = iniData[sizeByte_PIN +  9];
-                slowdata[10] = 4294967295;
+                slowdata[10] = iniData[sizeByte_PIN +  0];
-                slowdata[11] = 4294967295;
+                slowdata[11] = iniData[sizeByte_PIN + 11];
-                slowdata[12] = 4294967295;
+                slowdata[12] = iniData[sizeByte_PIN + 12];
-                slowdata[13] = 4294967295;
+                slowdata[13] = iniData[sizeByte_PIN + 13];
-                slowdata[14] = 4294967295;
+                slowdata[14] = iniData[sizeByte_PIN + 14];
         } else {
-                slowdata[0] = 192;
+                slowdata[ 0] = iniData[sizeByte_PIN + 1*sizeByte_SC +  0];
-                slowdata[1] = 4292874239;
+                slowdata[ 1] = iniData[sizeByte_PIN + 1*sizeByte_SC +  1];
-                slowdata[2] = 4257218559;
+                slowdata[ 2] = iniData[sizeByte_PIN + 1*sizeByte_SC +  2];
-                slowdata[3] = 478;
+                slowdata[ 3] = iniData[sizeByte_PIN + 1*sizeByte_SC +  3];
-                slowdata[4] = 0;
+                slowdata[ 4] = iniData[sizeByte_PIN + 1*sizeByte_SC +  4];
-                slowdata[5] = 3740340736;
+                slowdata[ 5] = iniData[sizeByte_PIN + 1*sizeByte_SC +  5];
-                slowdata[6] = 1175693740;
+                slowdata[ 6] = iniData[sizeByte_PIN + 1*sizeByte_SC +  6];
-                slowdata[7] = 2815957775;
+                slowdata[ 7] = iniData[sizeByte_PIN + 1*sizeByte_SC +  7];
-                slowdata[8] = 766945147;
+                slowdata[ 8] = iniData[sizeByte_PIN + 1*sizeByte_SC +  8];
-                slowdata[9] = 1504433946;
+                slowdata[ 9] = iniData[sizeByte_PIN + 1*sizeByte_SC +  9];
-                slowdata[10] = 2729016485;
+                slowdata[10] = iniData[sizeByte_PIN + 1*sizeByte_SC + 10];
-                slowdata[11] = 3412554245;
+                slowdata[11] = iniData[sizeByte_PIN + 1*sizeByte_SC + 11];
-                slowdata[12] = 2725848728;
+                slowdata[12] = iniData[sizeByte_PIN + 1*sizeByte_SC + 12];
-                slowdata[13] = 2267165112;
+                slowdata[13] = iniData[sizeByte_PIN + 1*sizeByte_SC + 13];
-                slowdata[14] = 4291041547;
+                slowdata[14] = iniData[sizeByte_PIN + 1*sizeByte_SC + 14];
         }
+}
 //------------------------------------------------------------------------------------------------------
 void PrepareReadSC(int chipNo)
+{
         if(chipNo == 1) {
-                ReadSCdata[0] = 0;
+                ReadSCdata[0] = iniData[sizeByte_PIN + 2*sizeByte_SC +  0];
         } else {
+                ReadSCdata[0] = iniData[sizeByte_PIN + 2*sizeByte_SC +  1];
+        }
+}
+//------------------------------------------------------------------------------------------------------
+void easiroc_PrintData()
+{
+        printf(">>> Pindata\n");
+        for(int i=0; i<sizeByte_PIN; i++) printf("%u\n", Pindata[i]);
+        printf(">>> slowdata (1)\n");
+        for(int i=0; i<sizeByte_SC; i++) printf("%u\n", slowdata[i]);
+        printf(">>> slowdata (2)\n");
+        for(int i=0; i<sizeByte_SC; i++) printf("%u\n", slowdata[i]);
+        printf(">>> ReadSCdata (1)\n");
+        for(int i=0; i<sizeByte_RSC; i++) printf("%u\n", ReadSCdata[i]);
-                ReadSCdata[0] = 1;
+        printf(">>> ReadSCdata (2)\n");
+        for(int i=0; i<sizeByte_RSC; i++) printf("%u\n", ReadSCdata[i]);
-        }
+}
 //------------------------------------------------------------------------------------------------------
 int DebugFPGA(SOCKET socket)
+{
+        printf(">>> DebugFPGA Pindata:\n");
+        for(int i=0; i<sizeByte_PIN; i++) printf("%u\n", Pindata[i]);
         unsigned int buffer = 0;
         buffer += 0 << 16;
         buffer += (Pindata[0] & 255) << 8;
         if(-1 == WriteData(socket, buffer)){
                 return -1;
         return 0;
+}
 //------------------------------------------------------------------------------------------------------
 int TransmitSC(SOCKET socket)
+{
+        printf(">>> TransmitSC slowdata:\n");
+        for(int i=0; i<sizeByte_SC; i++) printf("%u\n", slowdata[i]);
   unsigned int data = 0;
   //Set SC mode -----------------------------------------------------------
   data = 0;
   data += 1 << 16;
   data += 240 << 8;
   if(-1 == WriteData(socket, data)){
     return -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;
+  }
+  // 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)
+{
+        printf(">>> TransmitReadSC ReadSCdata:\n");
+        for(int i=0; i<sizeByte_RSC; i++) printf("%u\n", ReadSCdata[i]);
-  //SCA read ---------------------------------------------------------------
+        //SCA read ---------------------------------------------------------------
   unsigned int data = 0;
   for(int i = 0; i<4; ++i){
     data = 0;
     data += 12 << 16;
         for(int i = 0; i<sizeByte_PSC; ++i){
                 Probedata[i]   = 0;
+        }
         switch(CurrentProbeType){
-                case '1':
+                case 1:
                         CurrentProbe = pa_hg;
                 break;
-                case '2':
+                case 2:
                         CurrentProbe = pa_lg;
                 break;
-                case '3':
+                case 3:
                         CurrentProbe = ssh_hg;
                 break;
-                case '4':
+                case 4:
                         CurrentProbe = ssh_lg;
                 break;
-                case '5':
+                case 5:
                         CurrentProbe = fs;
                 break;
-                case '6':
+                case 6:
                 break;
-                case '7':
+                case 7:
                 break;
-                case '8':
+                case 8:
                         flag_rst     = 1;
                         CurrentCh    = 0;
                         ProbeBuffer  = 0;
                         CurrentProbe = fs;
                 break;
                 default:
                 break;
         };
+        //printf("CurrentProbeType = %d | CurrentProbe = %d\n", CurrentProbeType, CurrentProbe);
         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) {
+                //printf("CurrentProbe == ssh_hg || CurrentProbe == pa_hg\n");
                 buffer_16 = buffer_16 << 1;
                 buffer_0  = buffer_0 << 1;
+        }
         if(CurrentProbe == fs) {
+                //printf("CurrentProbe == fs\n");
                 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");
+        }
                                 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;
         //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;
 int easiroc_fAsicInitialize()
+{
         PrepareFPGA();
         DebugFPGA(sock);
         printf("\nASIS Initialize : Done\n\n");
         return 0;
+}
 //------------------------------------------------------------------------------------------------------
 int easiroc_fTransmitProbe(int CurrentCh, int CurrentProbe)
+{
         //printf("\nTransmitProbe: Success!\n\n");
         return 0;
+}
 //------------------------------------------------------------------------------------------------------
-int ADCOneCycle_wHeader_ver2(SOCKET socket, FILE* file)
+int ADCOneCycle_wHeader_ver2(SOCKET socket, FILE* file, int stopping)
+{
         static const int NofHeader = 3;
         unsigned int DataBuffer[1000];
         memset(DataBuffer, 0, sizeof(DataBuffer));
         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");
+        //if(ret <= 0) printf("Fatal ADC ERROR : recv\n");
-                return -1;
+        if(ret <= 0 && EndADC == 1) return -1;
-        }
         // sleep necessary! ERRORS happen if trigger rate lower than ~ sleep frequency!
         usleep(200);
         //Sleep(1);
                 unsigned int sizeData = (sizeof(int)*Header[1] & 0xffff);
                 unsigned int NofWord = (Header[1] & 0xffff);
                 unsigned int OneData[NofWord];
                 recv(socket, (char*)OneData, sizeData, 0);
+                if(!stopping) {
-        //     for(int i = 0; i<NofWord; ++i){ std::cout << std::hex << OneData[i] << std::endl; }
+                  for(int i = 0; i<NofWord; ++i) printf("[%d] 0x%x ", i, OneData[i]);
+                        printf("\n");
+                }
                 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){
+        if(EndADC != 1 && file!=NULL){
                 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;
+        }
         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);
+                ADCOneCycle_wHeader_ver2(socket, file, 0);
                 ++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)) {
+                while(0 == ADCOneCycle_wHeader_ver2(socket, file, 1)) {
                         Sleep(1);
                         if(abort == 50) {
                                 ADCStop(socket);
                                 abort = 0;
+                        }
+                }
                 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;
+}
+//------------------------------------------------------------------------------------------------------
+int easiroc_singleADCstart() {
+        unsigned int signal = 0;
+        signal += 32 << 24;
+        signal += 100 << 16;
+        send(sock, (char*)&signal, sizeof(int), 0);
+        Sleep(100);
+        printf("\nStart ADC\n");
+        return 0;
+}
+//------------------------------------------------------------------------------------------------------
+int easiroc_singleADCevent(unsigned int *retData) {
+        static const int NofHeader = 3;
+        unsigned int DataBuffer[1000];
+        memset(DataBuffer, 0, sizeof(DataBuffer));
+        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) printf("Fatal ADC ERROR : recv\n");
+        if(ret <= 0 && EndADC == 1) return -1;
+        //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 -2;
+        } else {
+                unsigned int sizeData = (sizeof(int)*Header[1] & 0xffff);
+                unsigned int NofWord = (Header[1] & 0xffff);
+                unsigned int OneData[NofWord];
+                recv(sock, (char*)OneData, sizeData, 0);
+          //for(int i = 0; i<NofWord; ++i) printf("[%d] 0x%x ", i, OneData[i]);
+                //printf("\n");
+                if(NofWord < EASIROC_MAX_READ_N_WORDS) memcpy(retData, OneData, sizeData);
+                return NofWord;
+        }
+}
+//------------------------------------------------------------------------------------------------------
+int easiroc_singleADCstop() {
+        ADCStop(sock);
+        EndADC = 1;
+        int abort = 0;
+        while(0 == ADCOneCycle_wHeader_ver2(sock, NULL, 1)) {
+                Sleep(1);
+                if(abort == 50) {
+                        ADCStop(sock);
+                        abort = 0;
+                }
+                //printf("dummy data\n");
+                printf(".");
+                ++abort;
+        }
+        EndADC    = 0;
+        ForceStop = 0;
+        printf("\nEnd ADC\n");
+        return 0;
 }
+//------------------------------------------------------------------------------------------------------

Subversion Repositories f9daq

(root)//cvi/apps/l2d2_easyroc/easiroc.c – Rev 291 → 299