Subversion Repositories f9daq

Rev

Rev 291 | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. #include "easiroc.h"
  2.  
  3. static const int  SiTCP_PORT       = 24;
  4. SOCKET sock;
  5.  
  6. unsigned int slowdata[sizeByte_SC];
  7. unsigned int ReadSCdata[sizeByte_RSC];
  8. unsigned int Pindata[sizeByte_PIN];
  9.  
  10. unsigned int iniData[sizeByte_PIN + 2*sizeByte_SC + 2*sizeByte_RSC];
  11.  
  12. unsigned int Probedata[sizeByte_PSC];
  13.  
  14. int ForceStop = 0;
  15. int EndADC = 0;
  16.                  
  17. #include <windows.h>
  18.  
  19. void usleep(__int64 usec)
  20. {
  21.     HANDLE timer;
  22.     LARGE_INTEGER ft;
  23.  
  24.     ft.QuadPart = -(10*usec); // Convert to 100 nanosecond interval, negative value indicates relative time
  25.  
  26.     timer = CreateWaitableTimer(NULL, TRUE, NULL);
  27.     SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);
  28.     WaitForSingleObject(timer, INFINITE);
  29.     CloseHandle(timer);
  30. }              
  31.  
  32. //------------------------------------------------------------------------------------------------------
  33. int easiroc_Init(const char* SiTCP_MASTER_IP, unsigned int daq_mode)
  34. {
  35.         // Start WinSock
  36.         printf("easiroc_Init --> Start.\n");
  37.         WORD wVersionRequested;
  38.         WSADATA wsaData;
  39.         if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
  40.             printf("WSAStartup failed with error!\n");
  41.         }
  42.        
  43.         //Initialize -------------------------------------------------------------
  44.        
  45.         sock = INVALID_SOCKET;
  46.         struct sockaddr_in SiTCP_ADDR;
  47.         const char*  IP;
  48.         unsigned int port;
  49.  
  50.         sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  51.         if(sock  == INVALID_SOCKET) {  
  52.                 printf("Error: easiroc_Init::sock = %d\n", sock);
  53.                 return -1;
  54.         }
  55.         IP                         = SiTCP_MASTER_IP;
  56.         port                       = SiTCP_PORT;
  57.         SiTCP_ADDR.sin_family      = AF_INET;
  58.         SiTCP_ADDR.sin_port        = htons((unsigned short)port);
  59.         SiTCP_ADDR.sin_addr.s_addr = inet_addr(IP);
  60.        
  61.         struct timeval tv;
  62.         tv.tv_sec  = 3;
  63.         tv.tv_usec = 0;
  64.         setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, sizeof(tv));
  65.  
  66.         int flag = 1;
  67.         setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(flag));
  68.        
  69.         //Connection -------------------------------------------------------------
  70.         int con = connect(sock, (struct sockaddr*)&SiTCP_ADDR, sizeof(SiTCP_ADDR));
  71.         printf("easiroc_Init::connect = %d\n", con);
  72.         if(0 > con){
  73.                 printf("SiTCP Master :: Connection fail\n");
  74.                 closesocket(sock);
  75.                 return -1;
  76.         }
  77.  
  78.         printf("SiTCP Master :: Connection Done\n\n");
  79.        
  80.         // Auto Initialize -------------------------------------------------------
  81.         PrepareFPGA();
  82.         DebugFPGA(sock);
  83.         printf("\nASIS Initialize : Done\n\n");
  84.         //Sleep(1000);
  85.        
  86.         WriteData(sock, 37888);
  87.         PrepareSC(1);
  88.         TransmitSC(sock);
  89.         printf("\nSlow Control chip1 : Done\n\n");
  90.         PrepareReadSC(1);
  91.         TransmitReadSC(sock);
  92.         printf("\nRead Slow Control chip1 : Done\n\n");  
  93.        
  94.         WriteData(sock, 21504);
  95.         PrepareSC(2);
  96.         TransmitSC(sock);
  97.         printf("\nSlow Control chip2 : Done\n\n");
  98.         PrepareReadSC(2);
  99.         TransmitReadSC(sock);
  100.         printf("\nRead Slow Control chip2: Done\n\n");
  101.        
  102.         WriteData(sock, 5120);
  103.         {
  104.                 unsigned int signal = 31;
  105.                 signal = signal << 16;
  106.                 unsigned int data = daq_mode;
  107.                 data = data << 8;
  108.                 signal += data;
  109.                 if(-1 == WriteData(sock, signal)){
  110.                         return -1;
  111.                 }
  112.                 printf("\n#D : DAQ mode is %d \n", daq_mode);
  113.         }
  114.        
  115.        
  116.         return 0;
  117. }
  118. //------------------------------------------------------------------------------------------------------
  119. void easiroc_Close()
  120. {
  121.         closesocket(sock);
  122.         WSACleanup();
  123.         printf("easiroc_Close -> Done.\n");
  124. }
  125. //------------------------------------------------------------------------------------------------------
  126. int  WriteData(SOCKET sock, unsigned int data)
  127. {
  128.         int esrcdbg = 0;
  129.        
  130.         data += 128 << 24;;
  131.  
  132.         if(esrcdbg) printf("0x%X\n", data);
  133.         send(sock, (char*)&data, sizeof(int), 0);
  134.         // this sleep is needed!
  135.         Sleep(WRITEDATA_DELAY);
  136.        
  137.         unsigned int buf = 0;
  138.         unsigned int length = 4;
  139.         int ret = recv(sock, (char*)&buf, length, 0);
  140.        
  141.         if ( ret > 0 ) {
  142.                 if(esrcdbg) printf("Bytes received: %d\n", ret);
  143.                 else printf(".");
  144.         } else if ( ret == 0 ) {
  145.                 printf("Connection closed\n");
  146.                 return -1;
  147.         } else {
  148.                 printf("recv failed: %d\n", WSAGetLastError());
  149.                 return -1;
  150.         }
  151.        
  152.         return 0;
  153. }
  154. //------------------------------------------------------------------------------------------------------
  155. int easiroc_LoadIni(const char *iniFile)
  156. {
  157.         FILE *fp=fopen(iniFile, "rt");
  158.         if(!fp) {
  159.                 printf("easiroc::LoadIni() cannot open file %s !!!\n", iniFile);
  160.                 return 0;
  161.         }
  162.        
  163.         char lbuff[256];
  164.         int counter = 0;
  165.         while(1) {
  166.                 int c = fgetc(fp);
  167.                 if(feof(fp)) break;
  168.                 if( '#' == (char)c ) {
  169.                         fgets(lbuff,256,fp);
  170.                         //printf("Found Comment line: %s", lbuff);
  171.                 } else {
  172.                         ungetc(c, fp);
  173.                         fscanf(fp, "%u\n", &iniData[counter] );
  174.                         //printf("Found value [%d] %u\n", counter, iniData[counter]);
  175.                         counter++;
  176.                 }
  177.         }      
  178.         fclose(fp);
  179.        
  180.         return 1;
  181. }
  182. //------------------------------------------------------------------------------------------------------
  183. void PrepareFPGA()
  184. {
  185.         Pindata[0] = iniData[0];
  186.         Pindata[1] = iniData[1];       
  187. }
  188. //------------------------------------------------------------------------------------------------------
  189. void PrepareSC(int chipNo)
  190. {
  191.         if(chipNo == 1) {
  192.                 slowdata[ 0] = iniData[sizeByte_PIN +  0];
  193.                 slowdata[ 1] = iniData[sizeByte_PIN +  1];
  194.                 slowdata[ 2] = iniData[sizeByte_PIN +  2];
  195.                 slowdata[ 3] = iniData[sizeByte_PIN +  3];
  196.                 slowdata[ 4] = iniData[sizeByte_PIN +  4];
  197.                 slowdata[ 5] = iniData[sizeByte_PIN +  5];
  198.                 slowdata[ 6] = iniData[sizeByte_PIN +  6];
  199.                 slowdata[ 7] = iniData[sizeByte_PIN +  7];
  200.                 slowdata[ 8] = iniData[sizeByte_PIN +  8];
  201.                 slowdata[ 9] = iniData[sizeByte_PIN +  9];
  202.                 slowdata[10] = iniData[sizeByte_PIN +  0];
  203.                 slowdata[11] = iniData[sizeByte_PIN + 11];
  204.                 slowdata[12] = iniData[sizeByte_PIN + 12];
  205.                 slowdata[13] = iniData[sizeByte_PIN + 13];
  206.                 slowdata[14] = iniData[sizeByte_PIN + 14];     
  207.         } else {
  208.                 slowdata[ 0] = iniData[sizeByte_PIN + 1*sizeByte_SC +  0];
  209.                 slowdata[ 1] = iniData[sizeByte_PIN + 1*sizeByte_SC +  1];
  210.                 slowdata[ 2] = iniData[sizeByte_PIN + 1*sizeByte_SC +  2];
  211.                 slowdata[ 3] = iniData[sizeByte_PIN + 1*sizeByte_SC +  3];
  212.                 slowdata[ 4] = iniData[sizeByte_PIN + 1*sizeByte_SC +  4];
  213.                 slowdata[ 5] = iniData[sizeByte_PIN + 1*sizeByte_SC +  5];
  214.                 slowdata[ 6] = iniData[sizeByte_PIN + 1*sizeByte_SC +  6];
  215.                 slowdata[ 7] = iniData[sizeByte_PIN + 1*sizeByte_SC +  7];
  216.                 slowdata[ 8] = iniData[sizeByte_PIN + 1*sizeByte_SC +  8];
  217.                 slowdata[ 9] = iniData[sizeByte_PIN + 1*sizeByte_SC +  9];
  218.                 slowdata[10] = iniData[sizeByte_PIN + 1*sizeByte_SC + 10];
  219.                 slowdata[11] = iniData[sizeByte_PIN + 1*sizeByte_SC + 11];
  220.                 slowdata[12] = iniData[sizeByte_PIN + 1*sizeByte_SC + 12];
  221.                 slowdata[13] = iniData[sizeByte_PIN + 1*sizeByte_SC + 13];
  222.                 slowdata[14] = iniData[sizeByte_PIN + 1*sizeByte_SC + 14];
  223.         }
  224. }
  225. //------------------------------------------------------------------------------------------------------
  226. void PrepareReadSC(int chipNo)
  227. {
  228.         if(chipNo == 1) {      
  229.                 ReadSCdata[0] = iniData[sizeByte_PIN + 2*sizeByte_SC +  0];    
  230.         } else {
  231.                 ReadSCdata[0] = iniData[sizeByte_PIN + 2*sizeByte_SC +  1];
  232.         }
  233. }
  234. //------------------------------------------------------------------------------------------------------
  235. void easiroc_PrintData()
  236. {
  237.         printf(">>> Pindata\n");
  238.         for(int i=0; i<sizeByte_PIN; i++) printf("%u\n", Pindata[i]);
  239.        
  240.                
  241.         printf(">>> slowdata (1)\n");
  242.         for(int i=0; i<sizeByte_SC; i++) printf("%u\n", slowdata[i]);
  243.        
  244.                
  245.         printf(">>> slowdata (2)\n");
  246.         for(int i=0; i<sizeByte_SC; i++) printf("%u\n", slowdata[i]);
  247.        
  248.                
  249.         printf(">>> ReadSCdata (1)\n");
  250.         for(int i=0; i<sizeByte_RSC; i++) printf("%u\n", ReadSCdata[i]);
  251.        
  252.                
  253.         printf(">>> ReadSCdata (2)\n");
  254.         for(int i=0; i<sizeByte_RSC; i++) printf("%u\n", ReadSCdata[i]);
  255.                
  256. }
  257. //------------------------------------------------------------------------------------------------------
  258. int DebugFPGA(SOCKET socket)
  259. {
  260.         printf(">>> DebugFPGA Pindata:\n");
  261.         for(int i=0; i<sizeByte_PIN; i++) printf("%u\n", Pindata[i]);
  262.        
  263.         unsigned int buffer = 0;
  264.         buffer += 0 << 16;
  265.         buffer += (Pindata[0] & 255) << 8;
  266.         if(-1 == WriteData(socket, buffer)){
  267.                 return -1;
  268.         }
  269.  
  270.         for(int i = 1 ; i<5; ++i){
  271.                 buffer = 0;
  272.                 if(i == 4){
  273.                         buffer += 5 << 16;      
  274.                 }else{
  275.                         buffer += i << 16;
  276.                 }
  277.                 buffer += ((Pindata[1] >> (i-1)*8) & 255) << 8;
  278.  
  279.                 if(-1 == WriteData(socket, buffer)){
  280.                         return -1;
  281.                 }
  282.                 Sleep(1);
  283.         }
  284.  
  285.         return 0;
  286. }
  287. //------------------------------------------------------------------------------------------------------
  288. int TransmitSC(SOCKET socket)
  289. {
  290.         printf(">>> TransmitSC slowdata:\n");
  291.         for(int i=0; i<sizeByte_SC; i++) printf("%u\n", slowdata[i]);
  292.        
  293.   unsigned int data = 0;
  294.   //Set SC mode -----------------------------------------------------------
  295.   data = 0;
  296.   data += 1 << 16;
  297.   data += 240 << 8;
  298.   if(-1 == WriteData(socket, data)){
  299.     return -1;
  300.   }
  301.  
  302.   //SC start -------------------------------------------------------------
  303.   data = 0;
  304.   data += 10 << 16;
  305.   data += (slowdata[0] & 255) << 8;
  306.   if(-1 == WriteData(socket, data)){
  307.     return -1;    
  308.   }
  309.  
  310.   for(int i = 1; i<15; ++i){
  311.     for(int shift = 0; shift<4; ++shift){
  312.       data = 0;
  313.       data += 10 << 16;
  314.       data += ((slowdata[i] >> 8*shift) & 255) << 8;
  315.       if(-1 == WriteData(socket, data)){
  316.                 return -1;    
  317.       }
  318.       //std::cout<<"test"<<std::endl;
  319.       Sleep(1);
  320.     }
  321.   }
  322.  
  323.   // Sleep(50000);
  324.  
  325.   //StartCycle -----------------------------------------------------------
  326.   data = 0;
  327.   data += 1 << 16;
  328.   data += 242 << 8;
  329.   if(-1 == WriteData(socket, data)){
  330.     return -1;    
  331.   }
  332.  
  333.   data = 0;
  334.   data += 1 << 16;
  335.   data += 240 << 8;
  336.   if(-1 == WriteData(socket, data)){
  337.     return -1;    
  338.   }
  339.  
  340.   // Sleep(50000);
  341.  
  342.   //Load SC --------------------------------------------------------------
  343.   data = 0;
  344.   data += 1 << 16;
  345.   data += 241 << 8;
  346.   if(-1 == WriteData(socket, data)){
  347.     return -1;    
  348.   }
  349.  
  350.   data = 0;
  351.   data += 1 << 16;
  352.   data += 240 << 8;
  353.   if(-1 == WriteData(socket, data)){
  354.     return -1;    
  355.   }
  356.  
  357.   return 0;
  358. }
  359. //------------------------------------------------------------------------------------------------------
  360. int TransmitReadSC(SOCKET socket)
  361. {
  362.  
  363.         printf(">>> TransmitReadSC ReadSCdata:\n");
  364.         for(int i=0; i<sizeByte_RSC; i++) printf("%u\n", ReadSCdata[i]);
  365.  
  366.         //SCA read ---------------------------------------------------------------
  367.   unsigned int data = 0;
  368.  
  369.   for(int i = 0; i<4; ++i){
  370.     data = 0;
  371.     data += 12 << 16;
  372.     data += ((ReadSCdata[0] >> i*8) & 255) << 8;
  373.     if(-1 == WriteData(socket, data)){
  374.       return -1;
  375.     }
  376.     Sleep(1);
  377.   }
  378.  
  379.   //StartCycle ------------------------------------------------------------
  380.   data = 0;
  381.   data += 1 << 16;
  382.   data += 242 << 8;
  383.   if(-1 == WriteData(socket, data)){
  384.     return -1;
  385.   }
  386.  
  387.   data = 0;
  388.   data += 1 << 16;
  389.   data += 240 << 8;
  390.   if(-1 == WriteData(socket, data)){
  391.     return -1;
  392.   }
  393.  
  394.   return 0;
  395. }
  396. //------------------------------------------------------------------------------------------------------
  397. int PreparePSC(int CurrentCh, int CurrentProbeType)
  398. {
  399.         enum Asign{fs_all, ssh_16, ssh_0, pa_16, pa_0, sizeAsign};
  400.         enum DataName{fs, ssh_hg, ssh_lg, pa_hg, pa_lg, sizeDataName};
  401.         enum DataName CurrentProbe;
  402.         CurrentProbe = fs;
  403.        
  404.         static unsigned int ProbeBuffer = 0;
  405.         int         flag_rst  = 0;
  406.         int flag_input = 1;
  407.         for(int i = 0; i<sizeByte_PSC; ++i){
  408.                 Probedata[i]   = 0;
  409.         }
  410.  
  411.         switch(CurrentProbeType){
  412.                 case 1:
  413.                         CurrentProbe = pa_hg;
  414.                 break;
  415.  
  416.                 case 2:
  417.                         CurrentProbe = pa_lg;
  418.                 break;
  419.  
  420.                 case 3:
  421.                         CurrentProbe = ssh_hg;
  422.                 break;
  423.  
  424.                 case 4:
  425.                         CurrentProbe = ssh_lg;
  426.                 break;
  427.  
  428.                 case 5:
  429.                         CurrentProbe = fs;
  430.                 break;
  431.  
  432.                 case 6:
  433.  
  434.                 break;
  435.  
  436.                 case 7:
  437.  
  438.                 break;
  439.  
  440.                 case 8:
  441.                         flag_rst     = 1;
  442.                         CurrentCh    = 0;
  443.                         ProbeBuffer  = 0;
  444.                         CurrentProbe = fs;
  445.                 break;
  446.  
  447.                 default:
  448.                 break;
  449.         };
  450.        
  451.         //printf("CurrentProbeType = %d | CurrentProbe = %d\n", CurrentProbeType, CurrentProbe);
  452.  
  453.         if(flag_rst) {
  454.                 return 0;
  455.         }
  456.  
  457.         if(flag_input) {
  458.                 ProbeBuffer = 1 << (31 - CurrentCh);
  459.         }
  460.  
  461.         unsigned int buffer_16 = ProbeBuffer*ProbeBuffer;
  462.         unsigned int buffer_0  = (ProbeBuffer >> 16)*(ProbeBuffer >> 16);
  463.         if(CurrentProbe == ssh_hg || CurrentProbe == pa_hg) {
  464.                 //printf("CurrentProbe == ssh_hg || CurrentProbe == pa_hg\n");
  465.                 buffer_16 = buffer_16 << 1;
  466.                 buffer_0  = buffer_0 << 1;
  467.         }
  468.         if(CurrentProbe == fs) {
  469.                 //printf("CurrentProbe == fs\n");
  470.                 Probedata[fs_all] = ProbeBuffer;
  471.         } else if(CurrentProbe == ssh_hg || CurrentProbe == ssh_lg) {
  472.                 if(CurrentCh > 15) {
  473.                         Probedata[ssh_16] = buffer_16;
  474.                 } else {
  475.                         Probedata[ssh_0]  = buffer_0;
  476.                 }
  477.         } else if(CurrentProbe == pa_hg || CurrentProbe == pa_lg) {
  478.                 if(CurrentCh > 15){
  479.                         Probedata[pa_16] = buffer_16;
  480.                 }else{
  481.                         Probedata[pa_0]  = buffer_0;
  482.                 }
  483.         } else {
  484.                 printf("bug desu\n");
  485.         }
  486.  
  487.         for(int shift = 0; shift<32; ++shift) {
  488.                 if(((Probedata[fs_all]) >> shift) & 1) {
  489.                         printf("!");    
  490.                 }else{
  491.                         printf(".");    
  492.                 }
  493.         }
  494.         printf("\n");
  495.  
  496.         for(int index = ssh_16; index <= ssh_0; ++index) {
  497.                 for(int shift = 0; shift<32; ++shift) {
  498.                         if(((Probedata[index]) >> shift) & 1) {
  499.                                 printf("!");
  500.                         } else {
  501.                                 printf(".");
  502.                         }
  503.                 }
  504.         }
  505.         printf("\n");
  506.  
  507.         for(int index = pa_16; index <= pa_0; ++index) {
  508.                 for(int shift = 0; shift<32; ++shift) {
  509.                         if(((Probedata[index]) >> shift) & 1) {
  510.                                 printf("!");  
  511.                         }else{
  512.                                 printf(".");  
  513.                         }
  514.                 }
  515.         }
  516.         printf("\n");
  517.  
  518.         return 0;
  519. }
  520. //------------------------------------------------------------------------------------------------------
  521. int TransmitProbe(SOCKET socket)
  522. {
  523.         unsigned int data = 0;
  524.         //Set Probe mode --------------------------------------------------------
  525.         data += 1 << 16;
  526.         data += 208 << 8;
  527.         if(-1 == WriteData(socket, data)) {
  528.                 return -1;
  529.         }
  530.  
  531.         //Probe start ----------------------------------------------------------
  532.         for(int i = 0; i<sizeByte_PSC; ++i) {
  533.                 for(int shift = 0; shift<4; ++shift) {
  534.                         data = 0;
  535.                         data += 10 << 16;
  536.                         data += ((Probedata[i] >> 8*shift) & 255) << 8;
  537.                         if(-1 == WriteData(socket, data)) {
  538.                                 return -1;
  539.                         }
  540.                 }
  541.         }
  542.  
  543.         //StartCycle ------------------------------------------------------------
  544.         data = 0;
  545.         data += 1 << 16;
  546.         data += 210 << 8;
  547.         if(-1 == WriteData(socket, data)) {
  548.                 return -1;    
  549.         }
  550.  
  551.         data = 0;
  552.         data += 1 << 16;
  553.         data += 208 << 8;
  554.         if(-1 == WriteData(socket, data)) {
  555.                 return -1;    
  556.         }
  557.  
  558.         return 0;
  559. }
  560. //------------------------------------------------------------------------------------------------------
  561. int easiroc_fTransmitSC()
  562. {
  563.   if(WriteData(sock, 37888) != 0) return -1;          
  564.   PrepareSC(1);
  565.   if(TransmitSC(sock) != 0) return -1;
  566.   printf("\nSlow Control chip1 : Done\n\n");
  567.  
  568.   if(WriteData(sock, 21504) != 0) return -1;          
  569.   PrepareSC(2);
  570.   if(TransmitSC(sock) != 0) return -1;    
  571.   printf("\nSlow Control chip2 : Done\n\n");
  572.  
  573.   if(WriteData(sock, 5120) != 0) return -1;            
  574.  
  575.   return 0;    
  576. }
  577. //------------------------------------------------------------------------------------------------------
  578. int easiroc_fTransmitReadSC()
  579. {
  580.         if(WriteData(sock, 37888) != 0) return -1;          
  581.         PrepareReadSC(1);
  582.         if(TransmitReadSC(sock) != 0) return -1;
  583.         printf("\nRead Slow Control chip1 : Done\n\n");
  584.  
  585.         if(WriteData(sock, 21504) != 0) return -1;          
  586.         PrepareReadSC(2);
  587.         if(TransmitReadSC(sock) != 0) return -1;    
  588.         printf("\nRead Slow Control chip2 : Done\n\n");
  589.  
  590.         if(WriteData(sock, 5120) != 0) return -1;            
  591.  
  592.         return 0;      
  593. }
  594. //------------------------------------------------------------------------------------------------------
  595. int easiroc_fAsicInitialize()
  596. {
  597.         PrepareFPGA();
  598.         DebugFPGA(sock);
  599.         printf("\nASIS Initialize : Done\n\n");
  600.        
  601.         return 0;      
  602. }
  603. //------------------------------------------------------------------------------------------------------
  604. int easiroc_fTransmitProbe(int CurrentCh, int CurrentProbe)
  605. {
  606.         //printf("\neasiroc_fTransmitProbe: CurrentCh : %d | CurrentProbe: %d\n\n", CurrentCh, CurrentProbe);
  607.        
  608.         if(CurrentCh < 32) {
  609.                 if(WriteData(sock, 37888)!= 0) return -1;      
  610.         } else if(CurrentCh > 31) {
  611.                 if(WriteData(sock, 21504)!= 0) return -1;      
  612.                 CurrentCh = CurrentCh - 32;
  613.         }
  614.        
  615.         //printf("\neasiroc_fTransmitProbe: Preparing PSC\n\n");
  616.         if(PreparePSC(CurrentCh, CurrentProbe)!= 0) {
  617.                 printf("\neasiroc_fTransmitProbe: PreparingPSC ERROR !!!!!!!!!!!!!!!!!!!\n\n");
  618.                 return -1;
  619.         }
  620.         //printf("\neasiroc_fTransmitProbe: TransmitProbe\n\n");    
  621.         if(TransmitProbe(sock)!= 0) {
  622.                 printf("\neasiroc_fTransmitProbe: TransmitProbe ERROR !!!!!!!!!!!!!!!!!!!\n\n");
  623.                 return -1;      
  624.         }
  625.         //WriteData(3, 5120);
  626.         //printf("\nTransmitProbe: Success!\n\n");            
  627.                          
  628.         return 0;      
  629. }
  630. //------------------------------------------------------------------------------------------------------
  631. int ADCOneCycle_wHeader_ver2(SOCKET socket, FILE* file, int stopping)
  632. {
  633.         static const int NofHeader = 3;
  634.  
  635.         unsigned int DataBuffer[1000];
  636.         memset(DataBuffer, 0, sizeof(DataBuffer));
  637.         unsigned int *ptr_DataBuf = DataBuffer;
  638.         unsigned int TotalRecvByte  = 0;
  639.         unsigned int TotalRecvEvent = 0;
  640.  
  641.         unsigned int sizeHeader = NofHeader*sizeof(int);
  642.  
  643.         unsigned int Header[] = {1, 1, 1};
  644.         int ret = 0;
  645.        
  646.         ret = recv(sock, (char*)Header, sizeHeader, 0);
  647.         //if(ret <= 0) printf("Fatal ADC ERROR : recv\n");
  648.         if(ret <= 0 && EndADC == 1) return -1;
  649.        
  650.         // sleep necessary! ERRORS happen if trigger rate lower than ~ sleep frequency!
  651.         usleep(200);
  652.         //Sleep(1);
  653.  
  654.         //printf("Header1 (0xFFFFEA0C) : 0x%x | Header2 (0x00000100) : 0x%x\n", Header[0], Header[1]);
  655.         if(Header[0] != 0xFFFFEA0C) {
  656.                 printf("Fatal ADC ERROR : HEADER\n");
  657.                 printf("Header1 : 0x%x | Header2 : 0x%x | Header3 : 0x%x\n", Header[0], Header[1], Header[2]);
  658.                 return -1;
  659.         } else {
  660.                 unsigned int sizeData = (sizeof(int)*Header[1] & 0xffff);
  661.                 unsigned int NofWord = (Header[1] & 0xffff);
  662.                 unsigned int OneData[NofWord];
  663.                
  664.                 recv(socket, (char*)OneData, sizeData, 0);
  665.                 if(!stopping) {
  666.                   for(int i = 0; i<NofWord; ++i) printf("[%d] 0x%x ", i, OneData[i]);
  667.                         printf("\n");
  668.                 }
  669.                 memcpy(ptr_DataBuf, Header, sizeHeader);
  670.                 ptr_DataBuf += NofHeader;
  671.  
  672.                 memcpy(ptr_DataBuf, OneData, sizeData);
  673.                 ptr_DataBuf += sizeData/sizeof(int);
  674.  
  675.                 TotalRecvByte += sizeHeader + sizeData;
  676.                 ++TotalRecvEvent;
  677.         }
  678.  
  679.         if(EndADC != 1 && file!=NULL){
  680.                 for(unsigned int i = 0; i<TotalRecvByte/sizeof(int); ++i) {
  681.                         unsigned int buffer = DataBuffer[i];
  682.                         fwrite((char*)&buffer, sizeof(int), 1, file);
  683.                 }
  684.         }
  685.  
  686.         return 0;
  687. }
  688. //------------------------------------------------------------------------------------------------------  
  689. void ADCStop(SOCKET socket)
  690. {
  691.   unsigned int signal = 0;
  692.   printf("ADC exit process\n");
  693.   signal += 16 << 24;
  694.   signal += 100 << 16;
  695.   send(socket, (char*)&signal, sizeof(int), 0);
  696.   Sleep(1);
  697.  
  698.   signal = 0;
  699.   signal += 100 << 16;
  700.   send(socket, (char*)&signal, sizeof(int), 0);
  701.  
  702.   Sleep(10);
  703.  
  704.   return;
  705. }
  706. //------------------------------------------------------------------------------------------------------  
  707. int ContinuousADC_ver2(SOCKET socket, char *file_name, int MaxCycleNum)
  708. {
  709.        
  710.         unsigned int signal = 0;
  711.         int EventNum = 0;
  712.        
  713.         FILE *file = NULL;
  714.         file = fopen(file_name, "wb");
  715.         if(file==NULL) {
  716.                 printf("ContinuousADC_ver2: ERROR opneing file %s\n", file_name);
  717.                 return -1;
  718.         }
  719.  
  720.         signal += 32 << 24;
  721.         signal += 100 << 16;
  722.         send(socket, (char*)&signal, sizeof(int), 0);
  723.         Sleep(100);
  724.        
  725.         while(EventNum < MaxCycleNum){   
  726.                 //Sleep(10);
  727.                 ADCOneCycle_wHeader_ver2(socket, file, 0);
  728.                 ++EventNum;
  729.                 if(0 == EventNum%1000){
  730.                 printf("Event # %d\n", EventNum);
  731.         }
  732.  
  733.         if(0 || EventNum == MaxCycleNum|| ForceStop == 1) {
  734.                 ADCStop(socket);
  735.  
  736.                 EndADC = 1;
  737.                 int abort = 0;
  738.                 while(0 == ADCOneCycle_wHeader_ver2(socket, file, 1)) {
  739.                         Sleep(1);
  740.                         if(abort == 50) {
  741.                                 ADCStop(socket);
  742.                                 abort = 0;
  743.                         }
  744.                         //printf("dummy data\n");
  745.                         printf(".");
  746.                         ++abort;
  747.                 }
  748.  
  749.                 EndADC    = 0;
  750.                 ForceStop = 0;
  751.                 break;
  752.                 }
  753.         }
  754.  
  755.         printf("\nEnd ADC\n");
  756.         fclose(file);
  757.  
  758.         return 0;
  759. }
  760. //------------------------------------------------------------------------------------------------------
  761. int easiroc_fDAQ(char *file_name, int MaxCycleNum)
  762. {
  763.         printf("easiroc_fDAQ: Starting DAQ with file_name = %s | MaxCycleNum = %d\n", file_name, MaxCycleNum);
  764.         if(ContinuousADC_ver2(sock, file_name, MaxCycleNum) != 0) return -1;
  765.        
  766.         return 0;      
  767. }
  768. //------------------------------------------------------------------------------------------------------  
  769. int easiroc_singleADCstart() {
  770.         unsigned int signal = 0;
  771.  
  772.         signal += 32 << 24;
  773.         signal += 100 << 16;
  774.         send(sock, (char*)&signal, sizeof(int), 0);
  775.         Sleep(100);
  776.        
  777.         printf("\nStart ADC\n");  
  778.        
  779.         return 0;
  780. }
  781. //------------------------------------------------------------------------------------------------------  
  782. int easiroc_singleADCevent(unsigned int *retData) {
  783.         static const int NofHeader = 3;
  784.  
  785.         unsigned int DataBuffer[1000];
  786.         memset(DataBuffer, 0, sizeof(DataBuffer));
  787.  
  788.         unsigned int sizeHeader = NofHeader*sizeof(int);
  789.  
  790.         unsigned int Header[] = {1, 1, 1};
  791.         int ret = 0;
  792.        
  793.         ret = recv(sock, (char*)Header, sizeHeader, 0);
  794.         //if(ret <= 0) printf("Fatal ADC ERROR : recv\n");
  795.         if(ret <= 0 && EndADC == 1) return -1;
  796.        
  797.         //usleep(200);
  798.         //Sleep(1);
  799.  
  800.         //printf("Header1 (0xFFFFEA0C) : 0x%x | Header2 (0x00000100) : 0x%x\n", Header[0], Header[1]);
  801.         if(Header[0] != 0xFFFFEA0C) {
  802.                 printf("Fatal ADC ERROR : HEADER\n");
  803.                 printf("Header1 : 0x%x | Header2 : 0x%x | Header3 : 0x%x\n", Header[0], Header[1], Header[2]);
  804.                 return -2;
  805.         } else {
  806.                 unsigned int sizeData = (sizeof(int)*Header[1] & 0xffff);
  807.                 unsigned int NofWord = (Header[1] & 0xffff);
  808.                 unsigned int OneData[NofWord];
  809.                
  810.                 recv(sock, (char*)OneData, sizeData, 0);
  811.  
  812.           //for(int i = 0; i<NofWord; ++i) printf("[%d] 0x%x ", i, OneData[i]);
  813.                 //printf("\n");
  814.                
  815.                 if(NofWord < EASIROC_MAX_READ_N_WORDS) memcpy(retData, OneData, sizeData);
  816.                
  817.                 return NofWord;
  818.         }
  819. }
  820. //------------------------------------------------------------------------------------------------------  
  821. int easiroc_singleADCstop() {
  822.         ADCStop(sock);
  823.  
  824.         EndADC = 1;
  825.         int abort = 0;
  826.         while(0 == ADCOneCycle_wHeader_ver2(sock, NULL, 1)) {
  827.                 Sleep(1);
  828.                 if(abort == 50) {
  829.                         ADCStop(sock);
  830.                         abort = 0;
  831.                 }
  832.                 //printf("dummy data\n");
  833.                 printf(".");
  834.                 ++abort;
  835.         }
  836.  
  837.         EndADC    = 0;
  838.         ForceStop = 0;
  839.        
  840.         printf("\nEnd ADC\n");
  841.        
  842.         return 0;
  843. }
  844. //------------------------------------------------------------------------------------------------------  
  845.  
  846.  
  847.  
  848.