WebSVN – f9daq – Diff – /cvi/instr/DRS/drs4.c

+#include <tcpsupp.h>
 #include "H1D.h"
 #include "H2D.h"
 #include <formatio.h>
 #include <utility.h>
 #include <ansi_c.h>
 #include <cvirte.h>
 #include <userint.h>
 #include "drs4.h"
+#include "scaler.h"
 #include "drsread.h"
+#include "K6517.h"
+K6517STATUS K6517Stat;
+static int K6517_Interface,K6517_Port,K6517_Gdev;
+//#define MIKRO
 #ifdef MIKRO
 #include "MIKRO.h"
 #endif
+/*---------------------------------------------------------------------------*/
+/* Module-globals                                                            */
+/*---------------------------------------------------------------------------*/
+static unsigned int g_hconversation;
+static int          g_hmainPanel;
+static int                      g_connected = 0;
+static int                      g_TCPError = 0;
+int daq_on;
+int ph, p2,p3,p4, plothandle[4]= {0,0,0,0};
+static int qdcplothandle[4]= {0,0,0,0};
 static int scanplothandle;
 static int tfID;
+static int rID;
 static int controlID;
 #define MAX_THREADS 10
 static CmtThreadPoolHandle poolHandle = 0;
 static float gSum[4]={0,0,0,0};
+int gActive[4]= {0,0,0,0};
+double gTwinMin[4]= {0,0,0,0};
+double gTwinMax[4]= {0,0,0,0};
+double gFx[4]= {0,0,0,0};
 int main (int argc, char *argv[]) {
         short port;
         if (InitCVIRTE (0, argv, 0) == 0)
                 return -1;  /* out of memory */
         if ((ph = LoadPanel (0, "drs4.uir", PANEL)) < 0)
+                return -1;
         if ((p2 = LoadPanel (0, "drs4.uir", SCAN)) < 0)
                 return -1;
+        if ((p3 = LoadPanel (0, "drs4.uir", QDC)) < 0)
+                return -1;
+        if ((p4 = LoadPanel (0, "scaler.uir", SCALER)) < 0)
+                return -1;
+        DisableBreakOnLibraryErrors();
         SetStdioPort (CVI_STDIO_WINDOW);
         SetSleepPolicy(VAL_SLEEP_MORE);
         CmtNewThreadPool (MAX_THREADS,  &poolHandle);
         DisplayPanel (ph);
         DisplayPanel (p2);
+        DisplayPanel (p3);
+        DisplayPanel (p4);
 #ifdef MIKRO
         GetCtrlVal(p2, SCAN_PORT, &port);
         if (MIKRO_Open (port)) MessagePopup ("Error", "Mikro Port Not found !\n Change in the GUI") ;
         MIKRO_Init(1,0);
         MIKRO_Init(2,0);
 #endif
+        K6517_open (1,4,3,0,13);
         RunUserInterface ();
         DiscardPanel (ph);
         DiscardPanel (p2);
+        DiscardPanel (p3);
+        DiscardPanel (p4);
         CmtDiscardThreadPool (poolHandle);
+#ifdef MIKRO
+        MIKRO_Close ();
+#endif
         return 0;
+}
 char strbuf[0xFF];
         DRSSetTimeout();
+}
+void CVICALLBACK EndOfThresholdScanThread ( CmtThreadPoolHandle poolhandle,
+                                                                                                                         CmtThreadFunctionID functionID, unsigned int event,
+                                                                                                                         int value, void *callbackData  ) {
+        printf("End of Threshold Scan Thread \n");
+        return ;
+}
 void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle,
                                                                                                                          CmtThreadFunctionID functionID, unsigned int event,
                                                                                                                          int value, void *callbackData  ) {
+}
 static float xs[4][1024];
+int CVICALLBACK daq(void *functionData) {
         int neve;
         char filename[0xff];
         int imask[4];
         int pfreq;
         int enabledoutput;
         int neveold = 0;
         double rate;
         int *args =  (int *) functionData;
+        int wfm=0;
+        const int  init[4] = { QDC_INIT_1 ,QDC_INIT_2 ,QDC_INIT_3 ,QDC_INIT_4 };
+        const int  fx[4] = { PANEL_SCALE_1 ,PANEL_SCALE_2 ,PANEL_SCALE_3 ,PANEL_SCALE_4 };
+        const int  active[4] = { QDC_ACTIVE_1 ,QDC_ACTIVE_2 ,QDC_ACTIVE_3 ,QDC_ACTIVE_4 };
         GetCtrlVal(ph, PANEL_CH0, &imask[0] );
         GetCtrlVal(ph, PANEL_CH1, &imask[1]  );
         GetCtrlVal(ph, PANEL_CH2, &imask[2]  );
         GetCtrlVal(ph, PANEL_CH3, &imask[3]  );
+        GetCtrlVal(p3, QDC_WFM, &wfm  );
         mask = 0;
         for (int i=0; i<4; i++) {
+                if (imask[i]) {
+                        mask |= (1<<i);
+                        ScaleCB(ph,fx[i],EVENT_COMMIT,NULL, 0,0);
+                        SetActiveCB(p3,active[i],EVENT_COMMIT,NULL, 0,0);
+                        InitQdcHistogramCB(p3, init[i],EVENT_COMMIT,NULL, 0,0);
+                }
+        }
+        LogScaleCB(p3, QDC_LOGY,EVENT_COMMIT,NULL, 0,0);
         GetCtrlVal(ph,PANEL_NEVE, &neve);
         GetCtrlVal(ph,PANEL_DEBUG, &verbose);
         GetCtrlVal(ph,PANEL_PFREQ, &pfreq);
         GetCtrlVal(ph,PANEL_ENABLEDOUTPUT, &enabledoutput);
         GetCtrlVal(ph,PANEL_FREQUENCY, &frequency);
         GetCtrlVal(ph,PANEL_TRGDELAY, &trgdelay);
         GetCtrlVal(ph,PANEL_TRGCHANNEL, &trgchannel);
         GetCtrlVal(ph,PANEL_TRGTYPE, &trgtype);
         GetCtrlVal(ph,PANEL_TRGLEVEL, &trglevel);
         GetCtrlVal(ph,PANEL_TRGPOLARITY, &trgpolarity);
         GetCtrlVal(ph,PANEL_RANGE, &range);
         //printf("mask=0x%x\n",mask);
         DRSSetMask( (unsigned char)( mask & 0xF ) );
         DRSSetFrequency( frequency  );
         DRSSetTriggerDelay(trgdelay );
         DRSSetTriggerChannel(trgchannel );
         DRSSetTriggerType( trgtype );
         DRSSetTriggerLevel(trglevel);
         DRSSetTriggerPolarity(trgpolarity);
         DRSSetRange (  range );
         FILE *fp= NULL;
         if (enabledoutput) {
+                if (1==1) {
                         GetCtrlVal(ph, PANEL_FILENAME, filename );
+                        printf("%s\n", filename);
                         fp =  fopen(filename,"wb");
           } else {
                         GetCtrlVal(p2, SCAN_FILENAME, filename );
                         fp =  fopen(filename,"ab");
+                        printf("%s\n", filename);
+                }
+        }
         static unsigned char *buffer;
         int buffer_size = 0;
         const int nBoards=1;
         const int waveDepth=1024;
         if (buffer_size == 0) {
                         if (retval) i--;
                         nev++;
                         if (!daq_on) break;
                         time(&t);
                         if (t!=told ) {
+                                PlotQdcHistogramCB(0,0,EVENT_COMMIT,NULL, 0,0);
                                 rate =  (i-neveold);
                                 printf("%d events in %2.2f min (%d s) Rate %f Hz %s   ",i+1, (double)(t-tstart)/60.,(t-tstart), rate , ctime(&t));
                                 GetCtrlVal(ph,PANEL_PFREQ, &pfreq);
                                 neveold = i;
+                        }
                         told=t;
 // Save data
                         if (nb>0 && fp) fwrite(buffer, 1,nb ,fp);
 // Plot Data
                          for (int k=0; k<4; k++) {
                                         if ( (mask & ( 0x1<<k ))  ){
+                                                double fSum= 0;
                                           float *t=DRSGetTime(k);
                                           float *x=DRSGetWave(k);
+                                                                 ;
                                           for (int j=0 ; j<1024 ; j++) {
+                                                  xs[k][j]= x[j]*1e-3*gFx[k];
+                                                        if (gActive[k]){
+                                                                if (t[j]> gTwinMin[k] && t[j] < gTwinMax[k]) {
+                                                                  fSum+= fabs(xs[k][j]);
+                                                                }
+                                                                if (wfm){
+                                                                    H2D_Fill(200+k,t[j], xs[k][j],1);
+                                                                }
+                                                    //if (verbose) printf("[%d] %d. x= %3.2f  y=%3.2f\n", k, i, t[j], x[j] );
+                                                  }
+                                          }
+                                                if (verbose) printf("qdc[%d] %3.2f active=%d\n", k, fSum ,gActive[k]);
+                                                if (gActive[k]) {
+                                                        if (!wfm) {
+                                                          H1D_Fill(200+k,fSum,1.);
+                                                        }
+                                                }
+                                                gSum[k]+=fSum;
                                           if (i % pfreq == 0) {
                                             const int col[4]= {VAL_WHITE,VAL_RED,VAL_GREEN,VAL_BLUE};
                                           if (plothandle[k])    DeleteGraphPlot (ph, PANEL_GRAPH, plothandle[k], VAL_IMMEDIATE_DRAW);
                                             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]);
+                                          }
+                                        }
+                                }
+                }
                 time(&t);
                 printf("%d events in %2.2f min (%d s) %s",nev, (double)(t-tstart)/60.,t-tstart, ctime(&t));
                 DRSEnd();
+        }
+        if (fp) fclose(fp);
         free(buffer);
+        return 0;
+}
+void CVICALLBACK EndOfThrScan ( CmtThreadPoolHandle poolhandle,
+                                                                                                                         CmtThreadFunctionID functionID, unsigned int event,
+                                                                                                                         int value, void *callbackData  ) {
+        //SetDimming(0);
+        printf("End of thrscan \n");
+        return ;
+}
+int scaler(int min, int max, int dx, int time_set, char *filename);
+int CVICALLBACK thrscan(void *functionData) {
+                        char str[0xFF];
+            char path[0xFF];
+                        int step,min,max, mtime;
+                        GetCtrlVal(p4, SCALER_STEP,&step);
+                        GetCtrlVal(p4, SCALER_TIME,&mtime);
+            GetCtrlVal(p4, SCALER_MAX,&max);
+                        GetCtrlVal(p4, SCALER_MIN,&min);
+                        GetCtrlVal(ph, PANEL_FILENAME,path);
+                        sprintf(str, "%s.thr", path);
+                        scaler(min,max,step,mtime,str);
+                        return 0;
+}
+int CVICALLBACK  acquire_data (void *arg) {
+        char *sarg = (char *) arg;
+        printf("sarg %s\n", sarg);
+        char str[0xFF];
+        char path[0xFF];
+        GetCtrlVal(ph,PANEL_PATH,path);
+        sprintf(str, "%s%s.dat", path, sarg);
+        SetCtrlVal(ph, PANEL_FILENAME,str);
+        int flag=0;
+        ThreadFunctionPtr mythread = thrscan;
+        int data;
+        int threadhandle;
+        CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &data,
+                                        DEFAULT_THREAD_PRIORITY,
+                                        EndOfThresholdScanThread,
+                                        EVENT_TP_THREAD_FUNCTION_END,
+                                        NULL, RUN_IN_SCHEDULED_THREAD,
+                                        &threadhandle);
+        daq(&flag);
+        CmtWaitForThreadPoolFunctionCompletionEx (poolHandle, threadhandle, OPT_TP_PROCESS_EVENTS_WHILE_WAITING, CMT_WAIT_FOREVER);
+        return 0;
+}
+int CVICALLBACK SwitchOnOffCB (int panel, int control, int event,
+                               void *callbackData, int eventData1, int eventData2)
+{
+  unsigned char state;
+  switch (event)
+  {
+    case EVENT_COMMIT:
+      GetCtrlVal(panel, control, &state);
+                        K6517_vsource_operate (state);
+      break;
+  }
+  return 0;
+}
+int CVICALLBACK SetVoltageCB (int panel, int control, int event,
+                                                                                                                        void *callbackData, int eventData1, int eventData2) {
+        double vbr;
+        switch (event) {
+                case EVENT_COMMIT:
+                        GetCtrlVal (ph, PANEL_VBR, &vbr );
+                  K6517_vsource_set (vbr+2);
+                        break;
+        }
+        return 0;
+}
+int TScan () {
+        double temp;
+        double volt,vbr;
+        int n=0;
+        int led;
+        GetNumTableRows (ph, PANEL_TABLE, &n );
+        daq_on = 1;
+        for(int i=0; i<n; i++) {
+                if (!daq_on) break;
+                GetTableCellVal (ph, PANEL_TABLE, MakePoint (1,i+1), &temp);
+                GetTableCellVal (ph, PANEL_TABLE, MakePoint (2,i+1), &vbr);
+                if (temp>100) break;
+                char transmitBuf[512]= {0};
+                sprintf(transmitBuf, "1 %f\n", temp);
+                if (g_connected)
+                                if ( ClientTCPWrite (g_hconversation, transmitBuf, strlen (transmitBuf), 1000) < 0) printf("Transmit Error\n"); else  printf("%s\n", transmitBuf);
+                SetCtrlVal(ph,PANEL_LED, 0);
+          do {
+                        time_t t0 = time(NULL);
+                        SetCtrlVal(ph,PANEL_TIME, ctime(&t0));
+                        Delay(1);
+                        GetCtrlVal(ph,PANEL_LED, &led);
+                        if (led) {
+                                for (int k=0;k<10;k++){
+                                        Delay(1);
+                                        if (!daq_on) break;
+                                }
+                          GetCtrlVal(ph,PANEL_LED, &led);
+                        }
+                        if (!daq_on) break;
+                }       while    (!led);
+        if (!daq_on) break;
+                int itemp = (int) temp;
+                int n1=0;
+                GetNumTableRows (ph, PANEL_VTABLE, &n1 );
+                for(int k=0; k<n1; k++) {
+                        if (!daq_on) break;
+                  GetTableCellVal (ph, PANEL_VTABLE, MakePoint (1,k+1), &volt);
+                        if (volt<-100) break;
+                        double voltage = vbr + volt;
+                        int ivolt=(int)(volt*100);
+                  K6517_vsource_set (voltage);
+                        K6517_vsource_operate (1);
+                        char str[0xFF];
+                  sprintf(str,"%d_%d", itemp, ivolt);
+                        printf("%d %d %s\n",i,k, str);
+                  acquire_data(str);
+                  K6517_vsource_operate (0);
+                }
+        }
+        return 0;
+}
+int CVICALLBACK TScanCB (int panel, int control, int event,
+                                                                                                        void *callbackData, int eventData1, int eventData2) {
+        switch (event) {
+                case EVENT_COMMIT:{
+                        ThreadFunctionPtr mythread = TScan;
+                        CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &rID,
+                                        DEFAULT_THREAD_PRIORITY,
+                                        EndOfThread,
+                                        EVENT_TP_THREAD_FUNCTION_END,
+                                        NULL, RUN_IN_SCHEDULED_THREAD,
+                                        &tfID);
+                }
+                        break;
+        }
+        return 0;
+}
+int CVICALLBACK LogScaleCB (int panel, int control, int event,
+                                                                                                                void *callbackData, int eventData1, int eventData2) {
+        const unsigned int gr[4] = { QDC_GRAPH_1 ,QDC_GRAPH_2 ,QDC_GRAPH_3 ,QDC_GRAPH_4 };
+        int wfm=0;
+        int attr, logy, selected;
+        switch (event) {
+                case EVENT_COMMIT:
+                        GetCtrlVal(p3,QDC_WFM,&wfm);
+                        GetCtrlVal(panel, control, &selected);
+                        attr= ATTR_YMAP_MODE;
+                        if(selected) logy=VAL_LOG; else logy=VAL_LINEAR;
+                        if (wfm) logy=VAL_LINEAR;
+                        for (int i=0;i<4;i++) SetCtrlAttribute (panel, gr[i],attr, logy);
+                        break;
+        }
+        return 0;
+}
+int CVICALLBACK ExecRootCB (int panel, int control, int event,
+                                                                                                void *callbackData, int eventData1, int eventData2) {
+        switch (event) {
+                case EVENT_COMMIT:{
+                        char fileName[100];
+                        char fname[100];
+                        char path[100];
+                        int trgchannel;
+                        GetCtrlVal(panel, PANEL_FILENAME, fileName);
+                        GetCtrlVal(panel,PANEL_TRGCHANNEL, &trgchannel);
+                        GetCtrlVal(panel, PANEL_PATH, path);
+                        sprintf(fname, "%s/%s", path, fileName);
+                        //sprintf(fname, "%s", fileName);
+                        int status;
+                        char name[MAX_PATHNAME_LEN];
+//      char dfile[MAX_PATHNAME_LEN];
+//      char efile[MAX_PATHNAME_LEN];
+//      status = FileSelectPopup ("dat", "*.dat", ".dat",
+//                                "Izberi datoteko s podatki",
+//                                VAL_LOAD_BUTTON, 0, 0, 1, 0, efile);
+//      EscapeString(efile,dfile);
+      sprintf(name ,"C:/home/dominik/runroot.bat \"C:/home/dominik/AnalyseWaveForms.cxx(-1,1000,\\\"%s\\\",%d)\" ", fname, trgchannel);
+      printf("%s\n",name);
+      LaunchExecutable(name);
+                        break;
+                }
+        }
+        return 0;
+}
+int CVICALLBACK TempTableCB (int panel, int control, int event,
+                                                                                                                 void *callbackData, int eventData1, int eventData2) {
+        switch (event) {
+                case EVENT_COMMIT: {
+                        int status;
+                        char name[MAX_PATHNAME_LEN];
+                        char dfile[MAX_PATHNAME_LEN];
+                        char efile[MAX_PATHNAME_LEN];
+                        status = FileSelectPopup ("dat", "*.dat", ".dat",
+                                                                                                                                "Izberi datoteko s podatki",
+                                                                                                                                VAL_LOAD_BUTTON, 0, 0, 1, 0, efile);
+                        printf("%s", efile);
+                        FILE *fp=fopen(efile,"r");
+                        float I;
+                        float V;
+                        int temp;
+                        int ndim=400;
+                        char line[400];
+                        if (fp) {
+                                int k=0;
+                                while (fgets(line,ndim,fp)!=NULL) {
+                                        k++;
+                                        sscanf(line,"%*s%d%f%f",&temp,&I,&V);
+                                        printf("%d %f %f\n", temp, I, V);
+                                  SetTableCellVal (ph, PANEL_TABLE, MakePoint (1,k), (double)temp);
+                                        SetTableCellVal (ph, PANEL_TABLE, MakePoint (2,k), V);
+                                }
+                                SetTableCellVal (ph, PANEL_TABLE, MakePoint (1,k+1), 1000.0);
+                                fclose(fp);
+                        }
+                        break;
+                }
+        }
         return 0;
+}
 int CVICALLBACK scan(void *functionData) {
                 if (!daq_on) break;
+        }
         return 0;
+}
 int CVICALLBACK StartCB (int panel, int control, int event,
                                                                                                  void *callbackData, int eventData1, int eventData2) {
         ThreadFunctionPtr mythread = NULL;
                         if (panel == ph && control == PANEL_START) {
                                 mythread = daq;
                                 controlID= control;
+                        }
                         if (panel == p2 && control == SCAN_SCAN)   mythread = scan;
+                        if (panel == p4 && control == SCALER_START)   mythread = thrscan;
+                        if (panel == ph && control == PANEL_ACQUIRE)   {
+                                mythread = acquire_data;
+                                controlID=50;
+                        }
                         if (mythread!=NULL) {
                                 printf("New Thread panel=%d button=%d\n", panel, control);
                                 // SetDimming(1);

Subversion Repositories f9daq

(root)/cvi/instr/DRS/drs4.c – Rev 265 → 317