Subversion Repositories f9daq

Rev

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

  1. #include <tcpsupp.h>
  2. #include "H1D.h"
  3. #include "H2D.h"
  4. #include <formatio.h>
  5. #include <utility.h>
  6. #include <ansi_c.h>
  7. #include <cvirte.h>
  8. #include <userint.h>
  9. #include "drs4.h"
  10. #include "scaler.h"
  11. #include "drsread.h"
  12. #include "K6517.h"
  13.  
  14. K6517STATUS K6517Stat;
  15. static int K6517_Interface,K6517_Port,K6517_Gdev;
  16. //#define MIKRO
  17.  
  18. #ifdef MIKRO
  19. #include "MIKRO.h"
  20. #endif
  21.  
  22.  
  23. /*---------------------------------------------------------------------------*/
  24. /* Module-globals                                                            */
  25. /*---------------------------------------------------------------------------*/
  26. static unsigned int g_hconversation;
  27. static int          g_hmainPanel;
  28. static int                      g_connected = 0;
  29. static int                      g_TCPError = 0;
  30.  
  31.  
  32. int daq_on;
  33. int ph, p2,p3,p4, plothandle[4]= {0,0,0,0};
  34. static int qdcplothandle[4]= {0,0,0,0};
  35. static int scanplothandle;
  36. static int tfID;
  37. static int rID;
  38. static int controlID;
  39.  
  40. #define MAX_THREADS 10
  41.  
  42. static CmtThreadPoolHandle poolHandle = 0;
  43.  
  44. static float gSum[4]={0,0,0,0};
  45.  
  46.  
  47. int gActive[4]= {0,0,0,0};  
  48. double gTwinMin[4]= {0,0,0,0};  
  49. double gTwinMax[4]= {0,0,0,0};
  50. double gFx[4]= {0,0,0,0};
  51.  
  52. int main (int argc, char *argv[]) {
  53.         short port;
  54.         if (InitCVIRTE (0, argv, 0) == 0)
  55.                 return -1;  /* out of memory */
  56.         if ((ph = LoadPanel (0, "drs4.uir", PANEL)) < 0)
  57.                 return -1;
  58.         if ((p2 = LoadPanel (0, "drs4.uir", SCAN)) < 0)
  59.                 return -1;
  60.         if ((p3 = LoadPanel (0, "drs4.uir", QDC)) < 0)
  61.                 return -1;
  62.         if ((p4 = LoadPanel (0, "scaler.uir", SCALER)) < 0)
  63.                 return -1;
  64.        
  65.         DisableBreakOnLibraryErrors();
  66.         SetStdioPort (CVI_STDIO_WINDOW);
  67.         SetSleepPolicy(VAL_SLEEP_MORE);
  68.         CmtNewThreadPool (MAX_THREADS,  &poolHandle);
  69.  
  70.         DisplayPanel (ph);
  71.         DisplayPanel (p2);
  72.         DisplayPanel (p3);
  73.         DisplayPanel (p4);
  74. #ifdef MIKRO
  75.         GetCtrlVal(p2, SCAN_PORT, &port);
  76.         if (MIKRO_Open (port)) MessagePopup ("Error", "Mikro Port Not found !\n Change in the GUI") ;
  77.         MIKRO_Init(1,0);
  78.         MIKRO_Init(2,0);
  79. #endif
  80.        
  81.         K6517_open (1,4,3,0,13);
  82.        
  83.         RunUserInterface ();
  84.         DiscardPanel (ph);
  85.         DiscardPanel (p2);
  86.         DiscardPanel (p3);
  87.         DiscardPanel (p4);
  88.         CmtDiscardThreadPool (poolHandle);
  89. #ifdef MIKRO   
  90.         MIKRO_Close ();
  91. #endif 
  92.         return 0;
  93. }
  94.  
  95.  
  96. char strbuf[0xFF];
  97.  
  98. int gLog=0;
  99.  
  100. int printf(const char *format, ...) {
  101.   va_list aptr;
  102.   int ret;
  103.   FILE *flog;
  104.  
  105.   va_start(aptr, format);
  106.   ret = vsprintf(strbuf, format, aptr);
  107.   va_end(aptr);
  108.   SetCtrlVal(ph,PANEL_STDIO,strbuf);
  109.  
  110.   if (gLog) {
  111.     flog = fopen ("stdio.log", "a");
  112.     fprintf (flog, "%s", strbuf);
  113.     fclose (flog);
  114.   }
  115.   return(ret);
  116. }
  117.  
  118.  
  119.  
  120. static void start_timer (double tout) {
  121.         SetCtrlAttribute (ph, PANEL_TIMER, ATTR_INTERVAL, tout);
  122.         SetCtrlAttribute (ph, PANEL_TIMER, ATTR_ENABLED, 1);
  123. }
  124.  
  125. static void stop_timer ( void ) {
  126.         SetCtrlAttribute (ph, PANEL_TIMER, ATTR_ENABLED, 0);
  127.         DRSSetTimeout();
  128. }
  129.  
  130.  
  131.  
  132. void CVICALLBACK EndOfThresholdScanThread ( CmtThreadPoolHandle poolhandle,
  133.                                                                                                                          CmtThreadFunctionID functionID, unsigned int event,
  134.                                                                                                                          int value, void *callbackData  ) {
  135.         printf("End of Threshold Scan Thread \n");
  136.         return ;
  137.  
  138. }
  139.  
  140. void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle,
  141.                                                                                                                          CmtThreadFunctionID functionID, unsigned int event,
  142.                                                                                                                          int value, void *callbackData  ) {
  143.  
  144.         daq_on=0;
  145.         //SetDimming(0);
  146.         printf("End of Thread \n");
  147.         return ;
  148.  
  149. }
  150.  
  151.  
  152. static float xs[4][1024];      
  153.  
  154. int CVICALLBACK daq(void *functionData) {
  155.  
  156.  
  157.         int neve;
  158.         char filename[0xff];
  159.         int imask[4];
  160.         unsigned long mask;
  161.         int frequency;
  162.         double trgdelay;
  163.         double trglevel;
  164.         int trgtype;
  165.         int trgchannel;
  166.         int trgpolarity;
  167.         int verbose;
  168.         double range;
  169.         int pfreq;
  170.         int enabledoutput;
  171.         int neveold = 0;
  172.         double rate;
  173.         int *args =  (int *) functionData;
  174.  
  175.         int wfm=0;
  176.         const int  init[4] = { QDC_INIT_1 ,QDC_INIT_2 ,QDC_INIT_3 ,QDC_INIT_4 };
  177.         const int  fx[4] = { PANEL_SCALE_1 ,PANEL_SCALE_2 ,PANEL_SCALE_3 ,PANEL_SCALE_4 };
  178.         const int  active[4] = { QDC_ACTIVE_1 ,QDC_ACTIVE_2 ,QDC_ACTIVE_3 ,QDC_ACTIVE_4 };
  179.  
  180.         GetCtrlVal(ph, PANEL_CH0, &imask[0] );
  181.         GetCtrlVal(ph, PANEL_CH1, &imask[1]  );
  182.         GetCtrlVal(ph, PANEL_CH2, &imask[2]  );
  183.         GetCtrlVal(ph, PANEL_CH3, &imask[3]  );
  184.         GetCtrlVal(p3, QDC_WFM, &wfm  );  
  185.         mask = 0;
  186.         for (int i=0; i<4; i++) {
  187.                 if (imask[i]) {
  188.                         mask |= (1<<i);
  189.                         ScaleCB(ph,fx[i],EVENT_COMMIT,NULL, 0,0);
  190.                         SetActiveCB(p3,active[i],EVENT_COMMIT,NULL, 0,0);
  191.                         InitQdcHistogramCB(p3, init[i],EVENT_COMMIT,NULL, 0,0);          
  192.                 }      
  193.         }
  194.         LogScaleCB(p3, QDC_LOGY,EVENT_COMMIT,NULL, 0,0);      
  195.  
  196.                
  197.         GetCtrlVal(ph,PANEL_NEVE, &neve);
  198.         GetCtrlVal(ph,PANEL_DEBUG, &verbose);
  199.         GetCtrlVal(ph,PANEL_PFREQ, &pfreq);
  200.         GetCtrlVal(ph,PANEL_ENABLEDOUTPUT, &enabledoutput);
  201.  
  202.         GetCtrlVal(ph,PANEL_FREQUENCY, &frequency);
  203.         GetCtrlVal(ph,PANEL_TRGDELAY, &trgdelay);
  204.         GetCtrlVal(ph,PANEL_TRGCHANNEL, &trgchannel);
  205.  
  206.        
  207.         GetCtrlVal(ph,PANEL_TRGTYPE, &trgtype);
  208.         GetCtrlVal(ph,PANEL_TRGLEVEL, &trglevel);
  209.         GetCtrlVal(ph,PANEL_TRGPOLARITY, &trgpolarity);
  210.         GetCtrlVal(ph,PANEL_RANGE, &range);
  211.  
  212.        
  213.         //printf("mask=0x%x\n",mask);
  214.  
  215.         DRSSetMask( (unsigned char)( mask & 0xF ) );
  216.  
  217.         DRSSetFrequency( frequency  );
  218.         DRSSetTriggerDelay(trgdelay );
  219.         DRSSetTriggerChannel(trgchannel );
  220.         DRSSetTriggerType( trgtype );
  221.         DRSSetTriggerLevel(trglevel);
  222.         DRSSetTriggerPolarity(trgpolarity);
  223.  
  224.         DRSSetRange (  range );
  225.  
  226.  
  227.  
  228.         FILE *fp= NULL;
  229.  
  230.         if (enabledoutput) {
  231.                 if (1==1) {
  232.                         GetCtrlVal(ph, PANEL_FILENAME, filename );  
  233.                         printf("%s\n", filename);
  234.                         fp =  fopen(filename,"wb");
  235.           } else {
  236.                         GetCtrlVal(p2, SCAN_FILENAME, filename );  
  237.                         fp =  fopen(filename,"ab");
  238.                         printf("%s\n", filename);
  239.                 }      
  240.         }
  241.  
  242.         static unsigned char *buffer;
  243.  
  244.         int buffer_size = 0;
  245.         const int nBoards=1;
  246.         const int waveDepth=1024;
  247.  
  248.         if (buffer_size == 0) {
  249.          buffer_size =   8; // file header + time header
  250.          buffer_size +=  nBoards * (4 + 4*(4+waveDepth*4)); // bin widths
  251.          buffer_size += 24 + nBoards * (8 + 4*(8+waveDepth*2));
  252.          buffer = (unsigned char *)malloc(buffer_size);
  253.   }
  254.                        
  255.         time_t t=0,told=0, tstart=0;
  256.  
  257.         if (!DRSInit()) {
  258.  
  259.                 time(&tstart);
  260.                 told=tstart;
  261.                 int nev=0;
  262.                 for (int k = 0;k<4;k++){
  263.                          gSum[k]=0;
  264.                 }
  265.                 for (int i=0; i<neve; i++) {
  266.                         start_timer(1);// 1 s timeout
  267.                         int retval = DRSRead(0);
  268.                         stop_timer();
  269.                         int nb =  ( retval == 0 && fp ) ? DRSToBuffer( buffer , i ) : 0;
  270.                         SetCtrlVal(ph,PANEL_CEVE,i);
  271.                         if (retval) i--;
  272.                         nev++;
  273.                         if (!daq_on) break;
  274.                         time(&t);
  275.                         if (t!=told ) {
  276.                                 PlotQdcHistogramCB(0,0,EVENT_COMMIT,NULL, 0,0);
  277.                                 rate =  (i-neveold);
  278.                                 printf("%d events in %2.2f min (%d s) Rate %f Hz %s   ",i+1, (double)(t-tstart)/60.,(t-tstart), rate , ctime(&t));
  279.                                 GetCtrlVal(ph,PANEL_PFREQ, &pfreq);
  280.                                 neveold = i;
  281.                         }
  282.                         told=t;
  283. // Save data
  284.                        
  285.                         if (nb>0 && fp) fwrite(buffer, 1,nb ,fp);
  286. // Plot Data
  287.                        
  288.                          for (int k=0; k<4; k++) {
  289.                                         if ( (mask & ( 0x1<<k ))  ){
  290.                                                 double fSum= 0;
  291.                                           float *t=DRSGetTime(k);
  292.                                           float *x=DRSGetWave(k);
  293.                                                                  ;
  294.                                           for (int j=0 ; j<1024 ; j++) {
  295.                                                   xs[k][j]= x[j]*1e-3*gFx[k];
  296.                                                         if (gActive[k]){
  297.                                                                 if (t[j]> gTwinMin[k] && t[j] < gTwinMax[k]) {
  298.                                                                   fSum+= fabs(xs[k][j]);
  299.                                                                 }      
  300.                                                                 if (wfm){
  301.                                                                     H2D_Fill(200+k,t[j], xs[k][j],1);
  302.                                                                 }
  303.                                                     //if (verbose) printf("[%d] %d. x= %3.2f  y=%3.2f\n", k, i, t[j], x[j] );
  304.                                                   }
  305.                                           }
  306.                                                 if (verbose) printf("qdc[%d] %3.2f active=%d\n", k, fSum ,gActive[k]);  
  307.                                                 if (gActive[k]) {
  308.                                                         if (!wfm) {
  309.                                                           H1D_Fill(200+k,fSum,1.);  
  310.                                                         }
  311.                                                 }
  312.                                                 gSum[k]+=fSum;
  313.                                                
  314.                                           if (i % pfreq == 0) {
  315.                                             const int col[4]= {VAL_WHITE,VAL_RED,VAL_GREEN,VAL_BLUE};
  316.                                           if (plothandle[k])    DeleteGraphPlot (ph, PANEL_GRAPH, plothandle[k], VAL_IMMEDIATE_DRAW);
  317.                                             plothandle[k] = PlotXY (ph, PANEL_GRAPH, t, xs[k], 1024, VAL_FLOAT, VAL_FLOAT, VAL_THIN_LINE, VAL_NO_POINT, VAL_SOLID, 1, col[k]);
  318.                                           }    
  319.                                         }
  320.                                        
  321.                                 }
  322.  
  323.  
  324.                 }
  325.                 time(&t);
  326.                 printf("%d events in %2.2f min (%d s) %s",nev, (double)(t-tstart)/60.,t-tstart, ctime(&t));
  327.                 DRSEnd();
  328.         }
  329.  
  330.         if (fp) fclose(fp);
  331.  
  332.         free(buffer);
  333.  
  334.         return 0;
  335.  
  336. }
  337.  
  338.  
  339. void CVICALLBACK EndOfThrScan ( CmtThreadPoolHandle poolhandle,
  340.                                                                                                                          CmtThreadFunctionID functionID, unsigned int event,
  341.                                                                                                                          int value, void *callbackData  ) {
  342.  
  343.  
  344.         //SetDimming(0);
  345.         printf("End of thrscan \n");
  346.         return ;
  347.  
  348. }
  349.  
  350.  
  351.  
  352. int scaler(int min, int max, int dx, int time_set, char *filename);
  353.  
  354. int CVICALLBACK thrscan(void *functionData) {  
  355.                         char str[0xFF];
  356.             char path[0xFF];
  357.        
  358.                         int step,min,max, mtime;
  359.                         GetCtrlVal(p4, SCALER_STEP,&step);  
  360.                         GetCtrlVal(p4, SCALER_TIME,&mtime);  
  361.             GetCtrlVal(p4, SCALER_MAX,&max);  
  362.                         GetCtrlVal(p4, SCALER_MIN,&min);  
  363.                         GetCtrlVal(ph, PANEL_FILENAME,path);  
  364.                        
  365.                         sprintf(str, "%s.thr", path);
  366.                         scaler(min,max,step,mtime,str);
  367.                         return 0;
  368.                
  369.                
  370. }
  371.  
  372.  
  373. int CVICALLBACK  acquire_data (void *arg) {
  374.        
  375.        
  376.         char *sarg = (char *) arg;
  377.         printf("sarg %s\n", sarg);
  378.         char str[0xFF];
  379.         char path[0xFF];
  380.         GetCtrlVal(ph,PANEL_PATH,path);
  381.         sprintf(str, "%s%s.dat", path, sarg);
  382.         SetCtrlVal(ph, PANEL_FILENAME,str);
  383.        
  384.         int flag=0;
  385.         ThreadFunctionPtr mythread = thrscan;
  386.         int data;
  387.         int threadhandle;
  388.         CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &data,
  389.                                         DEFAULT_THREAD_PRIORITY,
  390.                                         EndOfThresholdScanThread,
  391.                                         EVENT_TP_THREAD_FUNCTION_END,
  392.                                         NULL, RUN_IN_SCHEDULED_THREAD,
  393.                                         &threadhandle);
  394.         daq(&flag);
  395.         CmtWaitForThreadPoolFunctionCompletionEx (poolHandle, threadhandle, OPT_TP_PROCESS_EVENTS_WHILE_WAITING, CMT_WAIT_FOREVER);
  396.         return 0;
  397. }
  398.  
  399. int CVICALLBACK SwitchOnOffCB (int panel, int control, int event,
  400.                                void *callbackData, int eventData1, int eventData2)
  401. {
  402.   unsigned char state;
  403.   switch (event)
  404.   {
  405.     case EVENT_COMMIT:
  406.       GetCtrlVal(panel, control, &state);
  407.                         K6517_vsource_operate (state);
  408.       break;
  409.   }
  410.   return 0;
  411. }
  412.  
  413.  
  414. int CVICALLBACK SetVoltageCB (int panel, int control, int event,
  415.                                                                                                                         void *callbackData, int eventData1, int eventData2) {
  416.         double vbr;
  417.         switch (event) {
  418.                 case EVENT_COMMIT:
  419.                         GetCtrlVal (ph, PANEL_VBR, &vbr );
  420.                   K6517_vsource_set (vbr+2);
  421.                         break;
  422.         }
  423.         return 0;
  424. }
  425.  
  426.  
  427.  
  428. int TScan () {
  429.  
  430.         double temp;
  431.         double volt,vbr;
  432.         int n=0;
  433.         int led;
  434.         GetNumTableRows (ph, PANEL_TABLE, &n );
  435.         daq_on = 1;
  436.         for(int i=0; i<n; i++) {
  437.                 if (!daq_on) break;
  438.                 GetTableCellVal (ph, PANEL_TABLE, MakePoint (1,i+1), &temp);
  439.                 GetTableCellVal (ph, PANEL_TABLE, MakePoint (2,i+1), &vbr);  
  440.                 if (temp>100) break;  
  441.                 char transmitBuf[512]= {0};
  442.                 sprintf(transmitBuf, "1 %f\n", temp);
  443.                
  444.                
  445.                 if (g_connected)
  446.                                 if ( ClientTCPWrite (g_hconversation, transmitBuf, strlen (transmitBuf), 1000) < 0) printf("Transmit Error\n"); else  printf("%s\n", transmitBuf);
  447.                 SetCtrlVal(ph,PANEL_LED, 0);   
  448.           do {
  449.                         time_t t0 = time(NULL);
  450.                         SetCtrlVal(ph,PANEL_TIME, ctime(&t0));  
  451.                         Delay(1);
  452.                         GetCtrlVal(ph,PANEL_LED, &led);
  453.                         if (led) {
  454.                                 for (int k=0;k<10;k++){
  455.                                         Delay(1);
  456.                                         if (!daq_on) break;
  457.                                 }      
  458.                           GetCtrlVal(ph,PANEL_LED, &led);
  459.                         }      
  460.                         if (!daq_on) break;
  461.                 }       while    (!led);
  462.         if (!daq_on) break;  
  463.                
  464.                 int itemp = (int) temp;
  465.                 int n1=0;
  466.                 GetNumTableRows (ph, PANEL_VTABLE, &n1 );
  467.                
  468.                 for(int k=0; k<n1; k++) {
  469.                         if (!daq_on) break;
  470.                   GetTableCellVal (ph, PANEL_VTABLE, MakePoint (1,k+1), &volt);
  471.                         if (volt<-100) break;
  472.                         double voltage = vbr + volt;
  473.                         int ivolt=(int)(volt*100);
  474.                   K6517_vsource_set (voltage);
  475.                         K6517_vsource_operate (1);
  476.                         char str[0xFF];
  477.                   sprintf(str,"%d_%d", itemp, ivolt);
  478.                         printf("%d %d %s\n",i,k, str);
  479.                   acquire_data(str);
  480.                   K6517_vsource_operate (0);
  481.                 }      
  482.         }                                                                                                      
  483.  
  484.         return 0;
  485. }
  486.  
  487. int CVICALLBACK TScanCB (int panel, int control, int event,
  488.                                                                                                         void *callbackData, int eventData1, int eventData2) {
  489.  
  490.         switch (event) {
  491.                 case EVENT_COMMIT:{
  492.                         ThreadFunctionPtr mythread = TScan;
  493.                         CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &rID,
  494.                                         DEFAULT_THREAD_PRIORITY,
  495.                                         EndOfThread,
  496.                                         EVENT_TP_THREAD_FUNCTION_END,
  497.                                         NULL, RUN_IN_SCHEDULED_THREAD,
  498.                                         &tfID);
  499.                 }
  500.                         break;
  501.         }
  502.         return 0;
  503. }
  504.  
  505. int CVICALLBACK LogScaleCB (int panel, int control, int event,
  506.                                                                                                                 void *callbackData, int eventData1, int eventData2) {
  507.        
  508.        
  509.         const unsigned int gr[4] = { QDC_GRAPH_1 ,QDC_GRAPH_2 ,QDC_GRAPH_3 ,QDC_GRAPH_4 };
  510.         int wfm=0;
  511.         int attr, logy, selected;  
  512.         switch (event) {
  513.                 case EVENT_COMMIT:
  514.                         GetCtrlVal(p3,QDC_WFM,&wfm);  
  515.                         GetCtrlVal(panel, control, &selected);
  516.                        
  517.                         attr= ATTR_YMAP_MODE;
  518.                         if(selected) logy=VAL_LOG; else logy=VAL_LINEAR;
  519.                         if (wfm) logy=VAL_LINEAR;    
  520.                         for (int i=0;i<4;i++) SetCtrlAttribute (panel, gr[i],attr, logy);
  521.                         break;
  522.         }
  523.        
  524.         return 0;
  525. }
  526.  
  527. int CVICALLBACK ExecRootCB (int panel, int control, int event,
  528.                                                                                                 void *callbackData, int eventData1, int eventData2) {
  529.         switch (event) {
  530.                 case EVENT_COMMIT:{
  531.                         char fileName[100];
  532.                         char fname[100];
  533.                         char path[100];
  534.                         int trgchannel;
  535.                         GetCtrlVal(panel, PANEL_FILENAME, fileName);
  536.                         GetCtrlVal(panel,PANEL_TRGCHANNEL, &trgchannel);
  537.                         GetCtrlVal(panel, PANEL_PATH, path);
  538.                         sprintf(fname, "%s/%s", path, fileName);
  539.                         //sprintf(fname, "%s", fileName);
  540.                         int status;
  541.                         char name[MAX_PATHNAME_LEN];
  542. //      char dfile[MAX_PATHNAME_LEN];
  543. //      char efile[MAX_PATHNAME_LEN];
  544. //      status = FileSelectPopup ("dat", "*.dat", ".dat",
  545. //                                "Izberi datoteko s podatki",
  546. //                                VAL_LOAD_BUTTON, 0, 0, 1, 0, efile);
  547. //      EscapeString(efile,dfile);
  548.       sprintf(name ,"C:/home/dominik/runroot.bat \"C:/home/dominik/AnalyseWaveForms.cxx(-1,1000,\\\"%s\\\",%d)\" ", fname, trgchannel);
  549.  
  550.       printf("%s\n",name);
  551.       LaunchExecutable(name);
  552.                         break;
  553.                 }      
  554.         }
  555.         return 0;
  556. }
  557.  
  558.  
  559. int CVICALLBACK TempTableCB (int panel, int control, int event,
  560.                                                                                                                  void *callbackData, int eventData1, int eventData2) {
  561.         switch (event) {
  562.                 case EVENT_COMMIT: {
  563.                         int status;
  564.                         char name[MAX_PATHNAME_LEN];
  565.                         char dfile[MAX_PATHNAME_LEN];
  566.                         char efile[MAX_PATHNAME_LEN];
  567.                         status = FileSelectPopup ("dat", "*.dat", ".dat",
  568.                                                                                                                                 "Izberi datoteko s podatki",
  569.                                                                                                                                 VAL_LOAD_BUTTON, 0, 0, 1, 0, efile);
  570.                         printf("%s", efile);
  571.  
  572.  
  573.                         FILE *fp=fopen(efile,"r");
  574.                         float I;
  575.                         float V;
  576.                         int temp;
  577.                         int ndim=400;
  578.                         char line[400];
  579.                         if (fp) {
  580.                                 int k=0;
  581.                                 while (fgets(line,ndim,fp)!=NULL) {
  582.                                         k++;
  583.                                         sscanf(line,"%*s%d%f%f",&temp,&I,&V);
  584.                                         printf("%d %f %f\n", temp, I, V);
  585.                                   SetTableCellVal (ph, PANEL_TABLE, MakePoint (1,k), (double)temp);
  586.                                         SetTableCellVal (ph, PANEL_TABLE, MakePoint (2,k), V);  
  587.                                
  588.                                 }
  589.  
  590.                                 SetTableCellVal (ph, PANEL_TABLE, MakePoint (1,k+1), 1000.0);
  591.                                 fclose(fp);
  592.  
  593.  
  594.                         }
  595.                         break;
  596.                 }
  597.         }
  598.         return 0;
  599. }
  600.  
  601.  
  602.  
  603.  
  604. int CVICALLBACK scan(void *functionData) {
  605.  
  606.         int dx[3]={0,0,0};
  607.         int nx[3]={0,0,0};
  608.         int x0[3]={0,0,0};
  609.         int ix[3]={0,0,0};
  610.         int idx[3]={0,0,0};  
  611.         int size;
  612.         char posrec[4]="POSR"; 
  613.         char runbuf[4]="PRUN";
  614.        
  615.         int  n[3];
  616.         char filename[0xFF];
  617.         int enabledoutput;
  618.        
  619.         FILE *fp;
  620.         GetCtrlVal(p2, SCAN_FILENAME, filename );
  621.        
  622.         GetCtrlVal(ph,PANEL_ENABLEDOUTPUT, &enabledoutput);
  623.        
  624.         if ( GetFileInfo(filename,&size) ) {
  625.                 MessagePopup ("Warning","File exist. Remove it first or choose another file");
  626.           return 0;
  627.         }        
  628.         GetCtrlVal(p2, SCAN_STEPX, &dx[0]);
  629.         GetCtrlVal(p2, SCAN_STEPY, &dx[1]);
  630.         GetCtrlVal(p2, SCAN_NSTEPSX, &nx[0]);
  631.         GetCtrlVal(p2, SCAN_NSTEPSY, &nx[1]);
  632.         GetCtrlVal(p2, SCAN_STARTX, &x0[0]);
  633.         GetCtrlVal(p2, SCAN_STARTY, &x0[1]);
  634.         for (int k=0;k<4;k++)  {
  635.                 H2D_Init(k, "charge","Induced charge",
  636.                                                 nx[0], x0[0] - dx[0]*0.5 ,x0[0] + dx[0] * ( nx[0] - 0.5) ,
  637.                                                 nx[1], x0[1] - dx[1]*0.5 ,x0[1] + dx[1] * ( nx[1] - 0.5));  
  638.           H1D_Init(k, "charge","Induced charge projection x",
  639.                                                 nx[0], x0[0] - dx[0]*0.5 ,x0[0] + dx[0] * ( nx[0] - 0.5) );  
  640.           H1D_Init(100 + k, "charge","Induced charge projection y",
  641.                                                 nx[1], x0[1] - dx[1]*0.5 ,x0[1] + dx[1] * ( nx[1] - 0.5) );  
  642.         }
  643.         if (enabledoutput) {
  644.                                 fp =  fopen(filename,"ab");
  645.                                 if (fp) {
  646.                                          size=36;
  647.                                          fwrite(runbuf, 1,4 ,fp);
  648.                                          fwrite(&size  , 1,4 ,fp);
  649.                                          fwrite(x0    , 1,4*3 ,fp);
  650.                                          fwrite(dx    , 1,4*3 ,fp);
  651.                                          fwrite(nx    , 1,4*3 ,fp);
  652.                                          fclose(fp);
  653.                                 }    
  654.         }      
  655.        
  656.         for (int i=0; i<nx[0]; i++) {
  657.  
  658.                 ix[0]= x0[0]+i*dx[0];
  659. #ifdef MIKRO
  660.                 MIKRO_MoveTo(1,ix[0]);
  661. #endif
  662.                 SetCtrlVal (p2, SCAN_IX, i);
  663.                 for (int j=0; j<nx[1]; j++) {
  664.                        
  665.                         SetCtrlVal (p2, SCAN_IY, j);
  666.  
  667.                         ix[1]= x0[1]+j*dx[1];
  668. #ifdef MIKRO
  669.                         MIKRO_MoveTo(2,ix[1]);
  670.  
  671.                         MIKRO_GetPosition(1,&n[0]);
  672.                         SetCtrlVal (p2, SCAN_XP, n[0]);
  673.                         MIKRO_GetPosition(2,&n[1]);
  674.                         SetCtrlVal (p2, SCAN_YP, n[1]);
  675.        
  676.                         if (enabledoutput) {
  677.                                 fp =  fopen(filename,"ab");
  678.                                 if (fp) {
  679.                                          idx[0]=i;
  680.                                          idx[1]=j;
  681.                                          size=24;
  682.                                          fwrite(posrec, 1,4 ,fp);
  683.                                          fwrite(&size , 1,4 ,fp);
  684.                                          fwrite(n     , 1,4*3 ,fp);
  685.                                          fwrite(idx    , 1,4*3 ,fp);
  686.                                          fclose(fp);
  687.                                 }    
  688.                         }      
  689.                                
  690. #endif
  691.                         daq(functionData);
  692.                        
  693.                         for (int k=0;k<4;k++) {
  694.                                 H2D_Fill(k, ix[0], ix[1] , gSum[k] );
  695.                                 H1D_Fill(k, ix[0] , gSum[k] );
  696.                                 H1D_Fill(100+ k, ix[1] , gSum[k] );  
  697.                         }      
  698.                         PlotScanHistogramCB(0,0,EVENT_COMMIT,NULL, 0,0);
  699.                         if (!daq_on) break;
  700.                 }
  701.                 if (!daq_on) break;
  702.         }
  703.  
  704.         return 0;
  705. }
  706.  
  707.  
  708.  
  709.  
  710. int CVICALLBACK StartCB (int panel, int control, int event,
  711.                                                                                                  void *callbackData, int eventData1, int eventData2) {
  712.         ThreadFunctionPtr mythread = NULL;
  713.         switch (event) {
  714.  
  715.                 case EVENT_COMMIT:
  716.  
  717.                         controlID=0;
  718.                         if (panel == ph && control == PANEL_START) {
  719.                                 mythread = daq;
  720.                                 controlID= control;
  721.                         }
  722.                         if (panel == p2 && control == SCAN_SCAN)   mythread = scan;
  723.                         if (panel == p4 && control == SCALER_START)   mythread = thrscan;
  724.                         if (panel == ph && control == PANEL_ACQUIRE)   {
  725.                                 mythread = acquire_data;
  726.                                 controlID=50;
  727.                         }      
  728.                        
  729.                         if (mythread!=NULL) {
  730.                                 printf("New Thread panel=%d button=%d\n", panel, control);
  731.  
  732.                                 // SetDimming(1);
  733.  
  734.                                 daq_on=1;
  735.                                 CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &controlID,
  736.                                                                                                                                                                         DEFAULT_THREAD_PRIORITY,
  737.                                                                                                                                                                         EndOfThread,
  738.                                                                                                                                                                         EVENT_TP_THREAD_FUNCTION_END,
  739.                                                                                                                                                                         NULL, RUN_IN_SCHEDULED_THREAD,
  740.                                                                                                                                                                         &tfID);
  741.                         }
  742.                         break;
  743.         }
  744.         return 0;
  745. }
  746.  
  747. int CVICALLBACK StopCB (int panel, int control, int event,
  748.                                                                                                 void *callbackData, int eventData1, int eventData2) {
  749.         switch (event) {
  750.                 case EVENT_COMMIT:
  751.                         daq_on=0;
  752.                         break;
  753.         }
  754.         return 0;
  755. }
  756.  
  757. int CVICALLBACK ExitCB (int panel, int control, int event,
  758.                                                                                                 void *callbackData, int eventData1, int eventData2) {
  759.         switch (event) {
  760.                 case EVENT_COMMIT:
  761.                         QuitUserInterface (0);
  762.                         break;
  763.         }
  764.         return 0;
  765. }
  766.  
  767. int CVICALLBACK MoveStageCB (int panel, int control, int event,
  768.                                                                                                                  void *callbackData, int eventData1, int eventData2) {
  769.         int axis=0, step=1000, direction=1, n;
  770.         switch (event) {
  771.                 case EVENT_COMMIT:
  772.  
  773.                         if (panel == p2) {
  774.                                 switch (control) {
  775.                                         case SCAN_BR :
  776.                                                 axis = 1;
  777.                                                 direction = 1;
  778.                                                 GetCtrlVal(p2, SCAN_STEPX, &step);
  779.                                                 break;
  780.                                         case SCAN_BL :
  781.                                                 axis = 1;
  782.                                                 direction = -1;
  783.                                                 GetCtrlVal(p2, SCAN_STEPX, &step);
  784.                                                 break;
  785.                                         case SCAN_BU :
  786.                                                 axis = 2;
  787.                                                 direction = 1;
  788.                                                 GetCtrlVal(p2, SCAN_STEPY, &step);
  789.                                                 break;
  790.                                         case SCAN_BD :
  791.                                                 axis = 2;
  792.                                                 direction = -1;
  793.                                                 GetCtrlVal(p2, SCAN_STEPY, &step);
  794.                                                 break;
  795.                                 }
  796. #ifdef MIKRO
  797.                                 MIKRO_MoveFor(axis,  direction*step );
  798.                                 MIKRO_GetPosition(axis,&n);
  799.                                 if (axis == 1) SetCtrlVal (p2, SCAN_XP, n);
  800.                                 if (axis == 2) SetCtrlVal (p2, SCAN_YP, n);
  801. #endif // MIKRO                                
  802.                         }
  803.  
  804.                         break;
  805.         }
  806.         return 0;
  807. }
  808.  
  809.  
  810.  
  811.  
  812.  
  813. int CVICALLBACK GoXCB (int panel, int control, int event,
  814.                                                                                          void *callbackData, int eventData1, int eventData2) {
  815.         int n2;
  816.         switch (event) {
  817.                 case EVENT_COMMIT:
  818.                         GetCtrlVal (p2, SCAN_XG, &n2);
  819. #ifdef MIKRO
  820.                         MIKRO_MoveTo(1,n2);
  821.                         MIKRO_GetPosition(1,&n2);
  822.                        
  823. #endif
  824.                         SetCtrlVal (p2, SCAN_XP, n2);
  825.                         break;
  826.         }
  827.         return 0;
  828. }
  829.  
  830. int CVICALLBACK GoYCB (int panel, int control, int event,
  831.                                                                                          void *callbackData, int eventData1, int eventData2) {
  832.         int n2;
  833.         switch (event) {
  834.                 case EVENT_COMMIT:
  835.                         GetCtrlVal (p2, SCAN_YG, &n2);
  836. #ifdef MIKRO
  837.                         MIKRO_MoveTo(2,n2);
  838.                         MIKRO_GetPosition(2,&n2);
  839.                        
  840. #endif
  841.                         SetCtrlVal (p2, SCAN_YP, n2);
  842.                         break;
  843.         }
  844.         return 0;
  845. }
  846.  
  847. int CVICALLBACK GetCurrentPositionCB (int panel, int control, int event,
  848.                                                                                                                                         void *callbackData, int eventData1, int eventData2) {
  849.        
  850.         int n[2];      
  851.         switch (event) {
  852.                 case EVENT_COMMIT:
  853. #ifdef MIKRO                   
  854.                         MIKRO_GetPosition(1,&n[0]);
  855.                         SetCtrlVal (p2, SCAN_XP, n[0]);
  856.                         MIKRO_GetPosition(2,&n[1]);
  857.                         SetCtrlVal (p2, SCAN_YP, n[1]);
  858. #endif                 
  859.                         break;
  860.         }
  861.         return 0;
  862. }
  863.  
  864. int CVICALLBACK HomeCB (int panel, int control, int event,
  865.                                                                                                 void *callbackData, int eventData1, int eventData2) {
  866.         switch (event) {
  867.                 case EVENT_COMMIT:
  868. #ifdef MIKRO                   
  869.                         MIKRO_ReferenceMove(1);
  870.                         MIKRO_ReferenceMove(2);
  871.                         GetCurrentPositionCB(panel, control, event, NULL, 0, 0);
  872. #endif                 
  873.                         break;
  874.         }
  875.         return 0;
  876. }
  877.  
  878. int CVICALLBACK InitQdcHistogramCB (int panel, int control, int event,
  879.                                                                                                                                                  void *callbackData, int eventData1, int eventData2) {
  880.         const int min[4] = { QDC_MIN_1 ,QDC_MIN_2 ,QDC_MIN_3 ,QDC_MIN_4 };
  881.         const int max[4] = { QDC_MAX_1 ,QDC_MAX_2 ,QDC_MAX_3 ,QDC_MAX_4 };  
  882.         const int nbin[4] = { QDC_NBIN_1 ,QDC_NBIN_2 ,QDC_NBIN_3 ,QDC_NBIN_4 };
  883.        
  884.         const int  init[4] = { QDC_INIT_1 ,QDC_INIT_2 ,QDC_INIT_3 ,QDC_INIT_4 };
  885.         char title[0xFF];
  886.         char name[0xFF];
  887.         switch (event) {
  888.                 case EVENT_COMMIT:{
  889.                         int ctrl=-1;
  890.             for (int k=0;k<4;k++)  if ( init[k]==control & panel==p3 ) ctrl=k;
  891.                   if (ctrl<0) break;
  892.                         double minx;
  893.                         double maxx;
  894.                         int    nbins;
  895.                         int    wfm;
  896.                         int frq;
  897.                         GetCtrlVal(p3,min[ctrl],&minx);
  898.                         GetCtrlVal(p3,max[ctrl],&maxx);
  899.                         GetCtrlVal(p3,nbin[ctrl],&nbins);
  900.                         GetCtrlVal(p3,QDC_WFM,&wfm);  
  901.                         GetCtrlVal(ph,PANEL_FREQUENCY,&frq);  
  902.                         sprintf(name,"qdc%d", ctrl);   
  903.                         sprintf(title,"QDC ch %d", ctrl);      
  904.                         H1D_Init(200+ctrl, name, title, nbins, minx,maxx);
  905.                         sprintf(name,"avgwfm%d", ctrl);
  906.                         sprintf(title,"Average waveform ch %d", ctrl);
  907.                         H2D_Init(200+ctrl, name, title, 1024, 0,1024/frq, 100, -0.5,0.5);
  908.                         break;
  909.                 }
  910.         }                              
  911.         return 0;      
  912.  
  913. }
  914.  
  915.  
  916. int CVICALLBACK PlotQdcHistogramCB (int panel, int control, int event,
  917.                                                                                                                                                  void *callbackData, int eventData1, int eventData2) {
  918.         int hid=0;
  919.         int nx;
  920.         int ny;
  921.         const unsigned int gr[4] = { QDC_GRAPH_1 ,QDC_GRAPH_2 ,QDC_GRAPH_3 ,QDC_GRAPH_4 };
  922.         int wfm=0;
  923.         switch (event) {
  924.                 case EVENT_COMMIT:
  925.                         GetCtrlVal(p3,QDC_WFM,&wfm);        
  926.                         for (int i=0;i<4;i++) if (wfm) H2D_Draw(200+i,p3,gr[i],&qdcplothandle[i]);  else H1D_Draw(200+i,p3,gr[i],&qdcplothandle[i]);
  927.                         break;
  928.         }
  929.         return 0;
  930. }
  931.  
  932.  
  933. int CVICALLBACK PlotScanHistogramCB (int panel, int control, int event,
  934.                                                                                                                                                  void *callbackData, int eventData1, int eventData2) {
  935.         int hid=0;
  936.         int nx;
  937.         int ny;
  938.         switch (event) {
  939.                 case EVENT_COMMIT:
  940.                         GetCtrlVal (p2, SCAN_CHANNEL, &hid);
  941.                         GetCtrlVal(p2, SCAN_NSTEPSX, &nx);
  942.             GetCtrlVal(p2, SCAN_NSTEPSY, &ny);
  943.                         if (nx>1 && ny>1) {
  944.                                 H2D_Draw(hid,p2,SCAN_GRAPH,&scanplothandle);
  945.                                 printf("redraw 2d\n");
  946.                         } else {
  947.                                 if (nx>1)  {
  948.                                         printf("redraw 1d x\n");
  949.                                         H1D_Draw(hid,p2,SCAN_GRAPH,&scanplothandle);
  950.                                 }      
  951.                           if (ny>1) {
  952.                                         printf("redraw 1d x\n");
  953.                                         H1D_Draw(100+hid,p2,SCAN_GRAPH,&scanplothandle);
  954.                                 }
  955.                         }      
  956.                         break;
  957.         }
  958.         return 0;
  959. }
  960.  
  961. int CVICALLBACK OpenGuiCB (int panel, int control, int event,
  962.                                                                                                          void *callbackData, int eventData1, int eventData2) {
  963.         switch (event) {
  964.                 case EVENT_COMMIT:
  965.                         DisplayPanel (ph);
  966.             DisplayPanel (p2);
  967.                         break;
  968.         }
  969.         return 0;
  970. }
  971.  
  972.  
  973. int CVICALLBACK OpenQdcCB (int panel, int control, int event,
  974.                                                                                                          void *callbackData, int eventData1, int eventData2) {
  975.         switch (event) {
  976.                 case EVENT_COMMIT:
  977.                         DisplayPanel (ph);
  978.             DisplayPanel (p3);
  979.                         break;
  980.         }
  981.         return 0;
  982. }
  983.  
  984.  
  985. int CVICALLBACK CalibrateCB (int panel, int control, int event,
  986.                                                                                                                  void *callbackData, int eventData1, int eventData2) {
  987.         int status = 0;
  988.         switch (event) {
  989.                 case EVENT_COMMIT:
  990.                   status = DRSCalibrateTiming();
  991.                         printf("DRSCalibrateTiming() status = %d\n", status);
  992.                         break;
  993.         }
  994.         return 0;
  995. }
  996.  
  997. int CVICALLBACK SetActiveCB (int panel, int control, int event,
  998.                                                                                                                  void *callbackData, int eventData1, int eventData2) {
  999.         const int c[4] = { QDC_ACTIVE_1 ,QDC_ACTIVE_2 ,QDC_ACTIVE_3 ,QDC_ACTIVE_4 };
  1000.         const double  twin0[4] = { QDC_TWIN0_1 ,QDC_TWIN0_2 ,QDC_TWIN0_3 ,QDC_TWIN0_4 };
  1001.         const double  twin1[4] = { QDC_TWIN1_1 ,QDC_TWIN1_2 ,QDC_TWIN1_3 ,QDC_TWIN1_4 };
  1002.         int val=0;
  1003.         switch (event) {
  1004.                 case EVENT_COMMIT:
  1005.                         GetCtrlVal(panel, control, &val);
  1006.                         int ctrl=-1;
  1007.             for (int k=0;k<4;k++)  if ( c[k]==control & panel==p3 ) ctrl=k;
  1008.                   if (ctrl<0) break;
  1009.                
  1010.                         gActive[ctrl] = val;
  1011.                         GetCtrlVal(panel,  twin0[ctrl], &gTwinMin[ctrl]);
  1012.                         GetCtrlVal(panel,  twin1[ctrl], &gTwinMax[ctrl]);
  1013.                         printf("Channel  gActive[%d]=%d tmin %f tmax %f\n", ctrl,gActive[ctrl], gTwinMin[ctrl], gTwinMax[ctrl]);      
  1014.                         break;
  1015.         }
  1016.         return 0;
  1017. }
  1018.  
  1019. int CVICALLBACK ScaleCB (int panel, int control, int event,
  1020.                                                                                                  void *callbackData, int eventData1, int eventData2) {
  1021.         const int  c[4] = { PANEL_SCALE_1 ,PANEL_SCALE_2 ,PANEL_SCALE_3 ,PANEL_SCALE_4  };
  1022.         switch (event) {
  1023.                 case EVENT_COMMIT: {
  1024.                         double val;
  1025.                         GetCtrlVal(panel, control, &val);
  1026.                         int ctrl=-1;
  1027.             for (int k=0;k<4;k++)  if ( c[k]==control & panel==ph ) ctrl=k;
  1028.                   if (ctrl<0) break;
  1029.                         gFx[ctrl] = val;
  1030.                         printf("Scaling factor gFx[%d]=%f\n", ctrl,gFx[ctrl]);
  1031.                        
  1032.                         break;
  1033.                 }
  1034.         }
  1035.         return 0;
  1036. }
  1037.  
  1038.  
  1039.  
  1040.  
  1041. /*---------------------------------------------------------------------------*/
  1042. /* Macros                                                                                            */
  1043. /*---------------------------------------------------------------------------*/
  1044. #define tcpChk(f) if ((g_TCPError=(f)) < 0) {ReportTCPError();}
  1045.  
  1046.  
  1047. /*---------------------------------------------------------------------------*/
  1048. /* Internal function prototypes                                              */
  1049. /*---------------------------------------------------------------------------*/
  1050. int CVICALLBACK ClientTCPCB (unsigned handle, int event, int error,
  1051.                              void *callbackData);
  1052. static void ReportTCPError (void);
  1053.  
  1054.  
  1055. /*---------------------------------------------------------------------------*/
  1056. /* Report TCP Errors if any                                                                      */
  1057. /*---------------------------------------------------------------------------*/
  1058. static void ReportTCPError(void)
  1059. {
  1060.         if (g_TCPError < 0)
  1061.                 {
  1062.                 char    messageBuffer[1024];
  1063.                 sprintf(messageBuffer,
  1064.                         "TCP library error message: %s\nSystem error message: %s",
  1065.                         GetTCPErrorString (g_TCPError), GetTCPSystemErrorString());
  1066.                 MessagePopup ("Error", messageBuffer);
  1067.                 g_TCPError = 0;
  1068.                 }
  1069. }
  1070. /*---------------------------------------------------------------------------*/
  1071.  
  1072.  
  1073. int CVICALLBACK DisconnectCB (int panel, int control, int event,
  1074.                                                                                                                         void *callbackData, int eventData1, int eventData2) {
  1075.         switch (event) {
  1076.                 case EVENT_COMMIT:
  1077.                         if (g_connected)
  1078.         DisconnectFromTCPServer (g_hconversation);
  1079.                         g_hconversation = 0;
  1080.                         g_connected = 0;
  1081.                         break;
  1082.         }
  1083.         return 0;
  1084. }
  1085.  
  1086. int CVICALLBACK ConnectCB (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) {
  1087.         int portNum=10000;
  1088.         char tempBuf[512];
  1089.         sprintf(tempBuf,"localhost");
  1090.         switch (event) {
  1091.                 case EVENT_COMMIT:
  1092.                         if (g_connected) return 0;
  1093.                         if (ConnectToTCPServer (&g_hconversation, portNum, tempBuf, ClientTCPCB, NULL, 5000) < 0)
  1094.         MessagePopup("TCP Client", "Connection to server failed !");
  1095.     else
  1096.         {
  1097.         SetWaitCursor (0);
  1098.         g_connected = 1;
  1099.        
  1100.         /* We are successfully connected -- gather info */
  1101.        
  1102.                   if (GetTCPHostAddr (tempBuf, 256) >= 0) printf("%s\n" ,tempBuf);
  1103.                     if (GetTCPHostName (tempBuf, 256) >= 0) printf("%s\n" ,tempBuf);
  1104.                
  1105.         tcpChk (GetTCPPeerAddr (g_hconversation, tempBuf, 256));
  1106.         printf("%s\n" ,tempBuf);
  1107.         tcpChk (GetTCPPeerName (g_hconversation, tempBuf, 256));
  1108.         printf("%s\n" ,tempBuf);
  1109.         }
  1110.                         break;
  1111.         }
  1112.         return 0;
  1113. }
  1114.  
  1115.  
  1116. int CVICALLBACK ClientTCPCB (unsigned handle, int event, int error, void *callbackData)
  1117. {
  1118.     char receiveBuf[256] = {0};
  1119.     ssize_t dataSize         = sizeof (receiveBuf) - 1;
  1120.  
  1121.     switch (event)
  1122.         {
  1123.         case TCP_DATAREADY:
  1124.             if ((dataSize = ClientTCPRead (g_hconversation, receiveBuf,
  1125.                                            dataSize, 1000))
  1126.                 < 0)
  1127.                 {
  1128.                 printf( "Receive Error\n");
  1129.                 }
  1130.             else
  1131.                 {
  1132.                 receiveBuf[dataSize] = '\0';
  1133.                 //printf("%s", receiveBuf);
  1134.                                                                 float temp = 0;
  1135.                                                                 float humidity = 0;
  1136.                                                                 float dt=0;
  1137.                                                                 float tdiff=0;
  1138.                                                                 int t0 = 0;
  1139.                                                                 sscanf(receiveBuf, "%d%f%f%f%f", &t0,&humidity,&temp, &tdiff, &dt);
  1140.                                                                 SetCtrlVal(ph,PANEL_TMON, temp);
  1141.                                                                 SetCtrlVal(ph,PANEL_HUMIDITY, humidity);
  1142.                                                                 if (fabs(tdiff)<0.2 && fabs(dt) < 0.05)          SetCtrlVal(ph,PANEL_LED, 1);
  1143.                                                                 else  SetCtrlVal(ph,PANEL_LED, 0);    
  1144.                 }
  1145.             break;
  1146.         case TCP_DISCONNECT:
  1147.             MessagePopup ("TCP Client", "Server has closed connection!");
  1148.            
  1149.             g_connected = 0;
  1150.            
  1151.             break;
  1152.     }
  1153.     return 0;
  1154. }
  1155.