Subversion Repositories f9daq

Rev

Rev 304 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. #include <formatio.h>
  2. #include <userint.h>
  3. #include <ansi_c.h>
  4. #include <utility.h>
  5. #include <gpib.h>
  6. #include "toolbox.h"
  7. #include "prologix.h"
  8. #include "K6517.h"
  9.  
  10. K6517STATUS K6517Stat;
  11. static int K6517_Interface,K6517_Port,K6517_Gdev;
  12. static int iret;
  13. static int stop;
  14. int _VI_FUNC K6517_status_print (void);
  15. void GpibError(char *msg) {
  16.  
  17.   printf ("%s\n", msg);
  18.  
  19.   printf ("ibsta = &H%x  <", ibsta);
  20.   if (ibsta & ERR )  printf (" ERR");
  21.   if (ibsta & TIMO)  printf (" TIMO");
  22.   if (ibsta & END )  printf (" END");
  23.   if (ibsta & SRQI)  printf (" SRQI");
  24.   if (ibsta & RQS )  printf (" RQS");
  25.   if (ibsta & CMPL)  printf (" CMPL");
  26.   if (ibsta & LOK )  printf (" LOK");
  27.   if (ibsta & REM )  printf (" REM");
  28.   if (ibsta & CIC )  printf (" CIC");
  29.   if (ibsta & ATN )  printf (" ATN");
  30.   if (ibsta & TACS)  printf (" TACS");
  31.   if (ibsta & LACS)  printf (" LACS");
  32.   if (ibsta & DTAS)  printf (" DTAS");
  33.   if (ibsta & DCAS)  printf (" DCAS");
  34.   printf (" >\n");
  35.  
  36.   printf ("iberr = %d", iberr);
  37.   if (iberr == EDVR) printf (" EDVR <DOS Error>\n");
  38.   if (iberr == ECIC) printf (" ECIC <Not Controller-In-Charge>\n");
  39.   if (iberr == ENOL) printf (" ENOL <No Listener>\n");
  40.   if (iberr == EADR) printf (" EADR <Address error>\n");
  41.   if (iberr == EARG) printf (" EARG <Invalid argument>\n");
  42.   if (iberr == ESAC) printf (" ESAC <Not System Controller>\n");
  43.   if (iberr == EABO) printf (" EABO <Operation aborted>\n");
  44.   if (iberr == ENEB) printf (" ENEB <No GPIB board>\n");
  45.   if (iberr == EOIP) printf (" EOIP <Async I/O in progress>\n");
  46.   if (iberr == ECAP) printf (" ECAP <No capability>\n");
  47.   if (iberr == EFSO) printf (" EFSO <File system error>\n");
  48.   if (iberr == EBUS) printf (" EBUS <Command error>\n");
  49.   if (iberr == ESTB) printf (" ESTB <Status byte lost>\n");
  50.   if (iberr == ESRQ) printf (" ESRQ <SRQ stuck on>\n");
  51.   if (iberr == ETAB) printf (" ETAB <Table Overflow>\n");
  52.  
  53.   printf ("ibcntl = %ld\n", ibcntl);
  54.   printf ("\n");
  55.  
  56.   /* Call ibonl to take the device and interface offline */
  57.   ibonl (K6517_Gdev,0);
  58.  
  59.   exit(1);
  60. }
  61.  
  62. void _VI_FUNC K6517_open (int interface, int port, int primary_addr,
  63.                          int secondary_addr, int timeout)
  64. {
  65.   char cmd[100];
  66.         int status;
  67. /*
  68.   K6517_Gdev = OpenDev ("GPIB0", "");
  69.   if (ibsta & ERR) GpibError("OpenDev Error");
  70.   iret = ibpad (K6517_Gdev, 0);
  71.   if (ibsta & ERR) GpibError("OpenDev Error");
  72.   iret = ibsad (K6517_Gdev, NO_SAD);
  73.   iret = ibtmo (K6517_Gdev, T10s);
  74.   iret = ibeot (K6517_Gdev, 1);
  75.   iret = ibeos (K6517_Gdev, 0);
  76. */
  77.   K6517_Interface=interface;
  78.   K6517_Port=port;
  79.   switch (K6517_Interface){
  80.     case 1:
  81.       status = PROLOGIX_Open (K6517_Port);
  82.                         printf("K6517_open %d\n", status);
  83.       sprintf(cmd,"++addr %0d",primary_addr);
  84.       PROLOGIX_Send (cmd);
  85.       PROLOGIX_Send ("++auto 0");
  86.       PROLOGIX_Send ("++eoi 1");
  87.       PROLOGIX_Send ("++eot_enable 0");
  88.       PROLOGIX_Send ("++read_tmo_ms 1000");
  89.       break;
  90.     default:
  91.       K6517_Gdev = ibdev(K6517_Port,primary_addr,secondary_addr,timeout,1,0);
  92.       if (ibsta & ERR) GpibError("OpenDev Error");
  93.   }
  94.         printf("Interface %d\n", interface);
  95.         K6517_send("*RST",0);
  96.         K6517_send("*IDN?", 5);
  97.         char cres[100];
  98.         cres[0]= 0;
  99.         int len = K6517_receive (cres, 50);
  100.         printf("[%d] %s\n", len, cres);
  101.        
  102.         Delay(GDELAY);  
  103.   return;  
  104. }
  105.  
  106. void _VI_FUNC K6517_clear (void)
  107. {
  108.   switch (K6517_Interface){
  109.     case 1:
  110.       PROLOGIX_Send("++clr");
  111.       break;
  112.     default:
  113.       iret = ibclr (K6517_Gdev); // Clear the device
  114.       if (ibsta & ERR) GpibError("OpenDev Error");
  115.   }
  116. //  Delay(GDELAY);  
  117.   Delay(2.);
  118.   return;  
  119. }
  120.  
  121. void _VI_FUNC K6517_send (char *cmd, int len)
  122. {
  123.         printf("-> %s\n", cmd);
  124.         if (!len) len = strlen(cmd);
  125.   switch (K6517_Interface){
  126.     case 1:
  127.       PROLOGIX_Send(cmd);
  128.       break;
  129.     default:
  130.       iret = ibwrt (K6517_Gdev, cmd, len);
  131.       if (ibsta & ERR) GpibError("OpenDev Error");
  132.   }
  133.   Delay(GDELAY);  
  134.   return;  
  135. }
  136.  
  137. int _VI_FUNC K6517_receive (char *response, int maxbyt)
  138. {
  139.         int ierr=0;
  140.   switch (K6517_Interface){
  141.     case 1:
  142.       PROLOGIX_Send("++read eoi");
  143.       ierr= PROLOGIX_Receive (response,maxbyt);
  144.                         printf("<---Read [%d] %s\n", ierr, response);
  145.                         return ierr;
  146.       break;
  147.     default:
  148.       iret = ibrd (K6517_Gdev, response, maxbyt);
  149.       if (ibsta & ERR) GpibError("OpenDev Error");
  150.       response[ibcntl]=0;
  151.       return ibcntl;    
  152.   }
  153. }
  154.  
  155. void _VI_FUNC K6517_status (void)
  156. {
  157.   int len;
  158.   char cres[100];
  159.  
  160.   K6517_send ("U0X", 3);
  161.   len = K6517_receive (cres, 90);
  162.   sscanf(cres," 617%1d%2d%1d%1d%1d%1d%1d%1d%1d%1d%1d%2d%1d%2c",
  163.          &K6517Stat.function,&K6517Stat.range,&K6517Stat.zero_check,
  164.          &K6517Stat.zero_correct,&K6517Stat.suppress,&K6517Stat.trigger,
  165.          &K6517Stat.vsource_operate,&K6517Stat.read_mode,
  166.          &K6517Stat.data_prefix,&K6517Stat.display,
  167.          &K6517Stat.data_store,&K6517Stat.srq,&K6517Stat.eoi,K6517Stat.terminator);
  168.    printf("617FRRCZNTOBGDQMMKYY\n");
  169.    printf("%s\n",cres);
  170. //  K6517_send ("X", 1);
  171.   return;
  172. }
  173.  
  174. void _VI_FUNC K6517_data_format (int mode)
  175. {
  176.   int len;
  177.   char cmd[100];
  178.  
  179.   len=sprintf(cmd,"G%0dX",mode);
  180.   K6517_send (cmd, len);
  181.   return;
  182. }
  183.  
  184. double _VI_FUNC K6517_get (char *prefix, int *loc)
  185. {
  186.  
  187.   double value;
  188.   char cres[100];
  189.  
  190.         K6517_send ("SENS:FUNC  'curr'",0);
  191. //      K6517_send (":SENS:CURR:RANG:UPP 21e-3",0);
  192. //      K6517_send ("SYST:ZCH 0",0);      
  193.   K6517_send ("READ?",0);
  194.  
  195.         cres[0]= 0;
  196.         int len = K6517_receive (cres, 50);
  197.   printf("current >%d, %s\n",len,cres);
  198.        
  199.   return atof(cres);
  200.         /*
  201.   K6517_send ("X", 1);
  202.   len = K6517_receive (cres, 50);
  203.   if (loc) {
  204.     *loc=-1;
  205.     sscanf(cres,"%4c%lg,%d",prefix, &value, loc);
  206.     prefix[4]=0;
  207.   } else {
  208.     sscanf(cres,"%*4c%lg,%*d",&value);
  209.   }
  210.        
  211.   return value;
  212.         */
  213.        
  214. }
  215.  
  216. void _VI_FUNC K6517_current_mode (double range)
  217. {
  218.   int len;
  219.   char cmd[100];
  220.  
  221.   if (range > 0) {
  222.                 len=sprintf(cmd,":SENS:CURR:RANG:AUTO OFF");
  223.                 len=sprintf(cmd,":SENS:CURR:RANG:UPP %g",range);
  224.         }
  225.         else len=sprintf(cmd,":SENS:CURR:RANG:AUTO ON");
  226. //  printf("%d, %s\n",len,cmd);
  227.   K6517_send (cmd, len);
  228.   Delay(1);
  229.         K6517_send ("SYST:ZCH 0",0);
  230.   return;
  231. }
  232.  
  233. void _VI_FUNC K6517_zero_correct (int zcorrect)
  234. {
  235.   K6517_send ("C0X", 3);
  236.   K6517_send ("Z0X", 3);
  237.   if (zcorrect) {
  238.     K6517_send ("C1X", 3);
  239.     Delay(2);
  240.     K6517_send ("Z1X", 3);
  241.     K6517_send ("C0X", 3);
  242.   }
  243.   return;
  244. }
  245.  
  246. void _VI_FUNC K6517_trigger_mode (int mode)
  247. {
  248.   int len;
  249.   char cmd[100];
  250.  
  251.   //len=sprintf(cmd,"T%0dX",mode);
  252.   //K6517_send (cmd, len);
  253.   return;
  254. }
  255.  
  256. void _VI_FUNC K6517_reading_mode (int mode)
  257. {
  258.   int len;
  259.   char cmd[100];
  260.  
  261.   //len=sprintf(cmd,"B%0dX",mode);
  262.   //K6517_send (cmd, len);
  263.   return;
  264. }
  265.  
  266. void _VI_FUNC K6517_vsource_set (float value)
  267. {
  268.   int len;
  269.   char cmd[100];
  270.   len=sprintf(cmd,":SOURCE:VOLTAGE %f",value);
  271.   K6517_send (cmd, len);
  272.   return;
  273. }
  274.  
  275. double _VI_FUNC K6517_vsource_get (void)
  276. {
  277.   double value;
  278.  
  279.         /*
  280.         K6517_send ("SENS:FUNC  'volt'",0);
  281.         K6517_send ("SENS:VOLT:RANG:AUTO ON",0);      
  282.         K6517_send ("SYST:ZCH 0",0);
  283.   K6517_send ("READ?",0);
  284.         */
  285.         K6517_send (":MEASure:VOLTage?",0);
  286.         char cres[100];
  287.         cres[0]= 0;
  288.         int len = K6517_receive (cres, 50);
  289.  
  290.        
  291.   return atof(cres);    
  292. }
  293.  
  294. void _VI_FUNC K6517_vsource_operate (int operate)
  295. {
  296.  
  297.   if (operate){  
  298. //              K6517_send (":SOURCE:VOLTAGE:MCONNECT 1", 0);
  299. //              K6517_send (":SENS:VOLTAGE:MANual:VSOurce:OPERate 1", 0);
  300.                 //K6517_send (":MCONNECT 1", 0);
  301.                 K6517_send (":OUTP ON", 0);  
  302.                
  303. //    K6517_send (":SOURCE:VOLTAGE:RANGE 99", 0);
  304. //        K6517_send (":SOURCE:VOLTAGE 22", 0);
  305.         } else {
  306.     //K6517_send (":SOURCE:VOLTAGE 0", 0);
  307. //              K6517_send (":SENSe:VOLTAGE:MANual:VSOurce:OPERate 0", 0);
  308. //              K6517_send (":SOURCE:VOLTAGE:MCONNECT 0", 0);
  309.                 K6517_send (":OUTP OFF", 0);    
  310.                 //K6517_send (":MCONNECT 0", 0);
  311.                
  312.   }  
  313.         K6517_send (":STATUS:OPER?",0);
  314.         char cres[100];
  315.         cres[0]= 0;
  316.         int len = K6517_receive (cres, 50);
  317.  
  318.        
  319. //  return atoi(cres);
  320. }
  321.  
  322. void _VI_FUNC K6517_close (void)
  323. {
  324. //  iret = CloseDev (K6517_Gdev);
  325.   switch (K6517_Interface){
  326.     case 1:
  327.       PROLOGIX_Close();
  328.       break;
  329.     default:
  330.      iret = ibonl(K6517_Gdev, 0);// Take the device offline
  331.      if (ibsta & ERR) GpibError("OpenDev Error");
  332.   }
  333.   return;
  334. }
  335.  
  336. void _VI_FUNC K6517_test (void)
  337. {
  338.         int i;
  339.   double value;
  340.   char cres[100];
  341.  
  342.   K6517_clear ();
  343.         K6517_current_mode (0);
  344.   K6517_zero_correct (1);
  345.   K6517_data_format (0);
  346.   K6517_trigger_mode (1);
  347.   K6517_vsource_set (-100.);
  348.   K6517_vsource_operate (1);
  349.  
  350.   K6517_status();
  351.  
  352.   value=K6517_get(cres,&i);
  353.   printf("%s, %lg, %d\n",cres,value,i);
  354.   value=K6517_vsource_get();
  355.   printf("%lg\n",value);
  356.   value=K6517_get(cres,&i);
  357.   printf("%s, %lg, %d\n",cres,value,i);
  358.   value=K6517_get(cres,&i);
  359.   printf("%s, %lg, %d\n",cres,value,i);
  360.   value=K6517_get(cres,&i);
  361.   printf("%s, %lg, %d\n",cres,value,i);
  362.   value=K6517_get(cres,&i);
  363.   printf("%s, %lg, %d\n",cres,value,i);
  364.   Delay(5);
  365.   K6517_vsource_operate (0);
  366.  
  367.  
  368. }
  369.  
  370. #ifdef K6517_MAIN
  371.  
  372. #include <cvirte.h>
  373. #include <userint.h>
  374. #include "K6517-ctrl.h"
  375. int pnl; int gLogToFile;
  376. int pn2;
  377. int gLogToFile;
  378. int vmon[4]={P1_VMON_1};
  379. int imon[4]={P1_IMON_1 };
  380. int vset[4]={P1_U_1 };
  381. int iset[4]={P1_I_1 };
  382. int radiob[4]={P1_BOX_1 };
  383.  
  384. int cvcc[4]={P1_CVCC_1 };
  385. const unsigned char Pre_1 = 1;
  386. int gMask=0xF;
  387.  
  388. int pnl;
  389. FILE *gFp;
  390.  
  391.  
  392. int CVICALLBACK TimerOnOffCB (int panel, int control, int event,
  393.                               void *callbackData, int eventData1, int eventData2)
  394. {
  395.   int state;
  396.   switch (event)
  397.   {
  398.     case EVENT_COMMIT:
  399.       GetCtrlVal(panel, control, &state);
  400.       if (state){
  401.          ResumeTimerCallbacks();
  402.       } else {
  403.          SuspendTimerCallbacks ();
  404.          printf ("Disabling timer....\n");
  405.       }
  406.       break;
  407.   }
  408.   return 0;
  409. }
  410.  
  411. // reads the run number from the first line in the file
  412. int GetRunNumberFromFile(char *fname) {
  413.   char line[MAX_PATHNAME_LEN];
  414.   int ndim= MAX_PATHNAME_LEN;
  415.   int current_run = -1;
  416.   FILE *fp = NULL;
  417.   ssize_t size;
  418.  
  419.   if ( GetFileInfo(fname,&size) ) fp = fopen(fname,"r");
  420.  
  421.   if (fp) {
  422.     if (fgets(line,ndim,fp)!= NULL) current_run = atoi(line);
  423.     fclose(fp);
  424.   }
  425.   return current_run;
  426.  
  427. }
  428.  
  429. int IncreaseRunNumberInFile(char *fname) {
  430.  
  431.   int current_run = GetRunNumberFromFile(fname);
  432.   FILE *fp = fopen(fname,"w");
  433.  
  434.   if (fp) {
  435.     fprintf(fp,"%d", current_run+1 );
  436.     fclose(fp);
  437.   }
  438.   return current_run+1;
  439. }
  440.  
  441. int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
  442.                                            LPSTR lpszCmdLine, int nCmdShow)
  443. {
  444.     char cres[100];
  445.   double Voltage, Current, tinterval;
  446.   if (InitCVIRTE (hInstance, 0, 0) == 0) return -1;    /* out of memory */
  447.                 SetStdioPort (CVI_STDIO_WINDOW);
  448.         if ((pnl = LoadPanel (0, "K6517-ctrl.uir", P1)) < 0) return -1;  
  449.         if ((pn2 = LoadPanel (0, "K6517-ctrl.uir", P2)) < 0) return -1;
  450.        
  451.         K6517_open (1,4,3,0,13);
  452.          
  453.  
  454.   SetCtrlVal(pnl, P1_ONOFF, 0);
  455.   GetCtrlVal(pnl, P1_TINTERVAL, &tinterval);
  456.   SetCtrlAttribute (pnl, P1_TIMER, ATTR_INTERVAL, tinterval);
  457.   TimerOnOffCB(pnl, P1_TIMERON, EVENT_COMMIT,NULL,0,0);  
  458.   for (unsigned char  ch=0;ch<1;ch++){
  459.     int ison,i;
  460.                 Voltage =K6517_vsource_get();
  461.     Current =K6517_get(cres,&i);
  462.     SetCtrlVal(pnl, vset[ch], Voltage);
  463.     SetCtrlVal(pnl, iset[ch], Current);
  464.     GetCtrlVal(pnl, radiob[ch], &ison);
  465.     gMask = ison;
  466.   }
  467.          
  468.   DisplayPanel (pnl);
  469.         DisplayPanel (pn2);
  470.         RunUserInterface ();
  471.         DiscardPanel (pn2);
  472.         DiscardPanel (pnl);
  473.   K6517_close();  
  474.  
  475.    if (gFp)  fclose(gFp);
  476.          
  477.  
  478.   return 0;
  479. }
  480.  
  481.  
  482.  
  483.  
  484. int CVICALLBACK SwitchOnOffCB (int panel, int control, int event,
  485.                                void *callbackData, int eventData1, int eventData2)
  486. {
  487.   unsigned char state;
  488.   switch (event)
  489.   {
  490.     case EVENT_COMMIT:
  491.       GetCtrlVal(panel, control, &state);
  492.                         K6517_vsource_operate (state);
  493.       break;
  494.   }
  495.   return 0;
  496. }
  497.  
  498. int CVICALLBACK SetCB (int panel, int control, int event,
  499.                        void *callbackData, int eventData1, int eventData2)
  500. {
  501.  
  502.   char cres[100];
  503.         int i;
  504.   switch (event)
  505.   {
  506.     case EVENT_COMMIT:
  507.        
  508.       for (unsigned char ch = 0; ch<1;ch++){
  509.         //printf("ch %d %x\n", ch, gMask);
  510.         if (gMask){
  511.           double Voltage;
  512.           double Current;
  513.           GetCtrlVal(panel, vset[ch], &Voltage);
  514.           GetCtrlVal(panel, iset[ch], &Current);
  515.           printf("->ch %d VSet %g Iset %g\n", ch, Voltage, Current);
  516.                                        
  517.                                         K6517_vsource_set (Voltage);
  518.                                         Voltage=K6517_vsource_get();
  519.                                        
  520.           // TMI_Current(TMI_DeviceId, ch+1, Pre_1, Current);
  521.                                         Current=K6517_get(cres,&i);  
  522.           printf("<-ch %d VSet %g Iset %g\n", ch, Voltage, Current);  
  523.          
  524.         }
  525.       }  
  526.       break;
  527.   }
  528.   return 0;
  529. }
  530.  
  531. int CVICALLBACK ReadCB (int panel, int control, int event,
  532.                         void *callbackData, int eventData1, int eventData2)
  533. {
  534.  
  535.    int iRet;
  536.          char ch=0;
  537.          double Voltage;
  538.    double Current;
  539.          char cv_cc;
  540.          char cres[100];  
  541.          
  542.   switch (event)
  543.   {
  544.     case EVENT_COMMIT:
  545.       for (ch = 0; ch<1;ch++){
  546.         if (gMask){
  547.           int ison,i;
  548.                       Voltage =K6517_vsource_get();
  549.           Current =K6517_get(cres,&i);
  550.                                         cv_cc   = 1;
  551.           printf("ch %d VSet %g Iset %g\n", ch, Voltage, Current);
  552.           SetCtrlVal(panel, vmon[ch], Voltage);
  553.           SetCtrlVal(panel, imon[ch], Current);
  554.           SetCtrlVal(panel, cvcc[ch], cv_cc);
  555.         }
  556.       }  
  557.       break;
  558.   }
  559.   return 0;
  560. }
  561.  
  562. int CVICALLBACK SetIntervalCB (int panel, int control, int event,
  563.                                void *callbackData, int eventData1, int eventData2) {
  564.   double tinterval;
  565.   switch (event) {
  566.     case EVENT_COMMIT:
  567.       GetCtrlVal(panel, control, &tinterval);
  568.       SetCtrlAttribute (panel, P1_TIMER, ATTR_INTERVAL, tinterval);
  569.       break;
  570.   }
  571.   return 0;
  572. }
  573.  
  574.  
  575.  
  576. int CVICALLBACK ExitCB (int panel, int control, int event,
  577.                         void *callbackData, int eventData1, int eventData2)
  578. {
  579.   switch (event)
  580.   {
  581.     case EVENT_COMMIT:
  582.                         K6517_send (":OUTP OFF", 0);
  583.       QuitUserInterface(0);
  584.       break;
  585.   }
  586.   return 0;
  587. }
  588.  
  589. int CVICALLBACK SetMaskCB (int panel, int control, int event,
  590.                            void *callbackData, int eventData1, int eventData2)
  591. { int ison;
  592.   switch (event)
  593.   {
  594.     case EVENT_COMMIT:
  595.       GetCtrlVal(panel, control, &ison);
  596.       for (int i=0;i<1;i++) if (control == radiob[i]) break;
  597.       gMask = ison;
  598.       break;
  599.   }
  600.   return 0;
  601. }
  602.  
  603.  
  604. int CVICALLBACK LogToFileCB (int panel, int control, int event,
  605.                              void *callbackData, int eventData1, int eventData2)
  606. {
  607.  
  608.   switch (event)
  609.   {
  610.     case EVENT_COMMIT:
  611.       GetCtrlVal(panel, control, &gLogToFile);
  612.      
  613.       break;
  614.   }
  615.   return 0;
  616. }
  617.  
  618. int CVICALLBACK TimerCB (int panel, int control, int event,
  619.                          void *callbackData, int eventData1, int eventData2)
  620. {
  621.   switch (event)
  622.   {
  623.      
  624.       unsigned char   ch;
  625.       double current[4];
  626.       double voltage;
  627.       char cv_cc = 0;
  628.                         char cres[100];
  629.                         int i=0;
  630.     case EVENT_TIMER_TICK:
  631.       for (ch = 0; ch<1;ch++){
  632.         if (gMask){
  633.           voltage =K6517_vsource_get();
  634.           current[ch] =K6517_get(cres,&i);
  635.                                        
  636.           if (gLogToFile){
  637.               if (!gFp)  {
  638.                 gFp= fopen("K6517.log","w");
  639.                 fprintf(gFp,"#time\tch\tU\tI\tCV_CC\n");
  640.               }  
  641.               fprintf(gFp,"%ul\t%d\t%g\t%g\t%d\n",  time(NULL), ch+1, voltage, current[ch], cv_cc);
  642.           }
  643.         }
  644.       }
  645.       PlotStripChart (panel, P1_GRAPH, current, 1, 0, 0, VAL_DOUBLE);
  646.                         PlotStripChart (panel, P1_GRAPH_1, &voltage, 1, 0, 0, VAL_DOUBLE);
  647.       break;
  648.   }
  649.   return 0;
  650. }
  651.  
  652. int CVICALLBACK TestCB (int panel, int control, int event,
  653.                                                                                                 void *callbackData, int eventData1, int eventData2) {
  654.         switch (event) {
  655.                 case EVENT_COMMIT:
  656.                         K6517_test();
  657.                         break;
  658.         }
  659.         return 0;
  660. }
  661.  
  662.  
  663. int CVICALLBACK IVSCANCB (int panel, int control, int event,
  664.                                                                                                         void *callbackData, int eventData1, int eventData2) {
  665.         int nsteps;
  666.         double umin, umax, u;
  667.         double *xpoints;
  668.         double *ypoints;
  669.         static int plivhandle=0;
  670.         double current;
  671.   double voltage;
  672.   char cv_cc = 0;
  673.         char cres[100];
  674.         char fileName[100];
  675.         char fname[100];
  676.         char path[100];
  677.         double range;
  678.         int k=0;
  679.         int state;
  680.         int overflow;
  681.         char ovf[10];
  682.         FILE *fp;
  683.         time_t mtime;
  684.         ssize_t size;
  685.        
  686.         switch (event) {
  687.                 case EVENT_COMMIT:
  688.                         K6517_send (":OUTP ON", 0);
  689.         //              GetCtrlVal(panel, P2_UMIN, &umin);
  690.         //              GetCtrlVal(panel, P2_UMAX, &umax);
  691.         //              GetCtrlVal(panel, P2_NSTEPS, &nsteps);
  692.                         SetCtrlVal(pnl, P1_TIMERON, 0);
  693.                         GetCtrlVal(panel, P2_FILENAME, fileName);
  694.                         GetCtrlVal(panel, P2_PATH, path);
  695.         //              GetCtrlVal(panel, P2_RANGE, &range);
  696.                         TimerOnOffCB(pnl, P1_TIMERON, EVENT_COMMIT, NULL, 0, 0);
  697.                         sprintf(fname, "%s/%s.dat", path, fileName);
  698.                         if ( !GetFileInfo(fname,&size) )
  699.                                  fp = fopen(fname,"w");
  700.       else {  
  701.         sprintf(cres, "File %s exist\n Remove it first",fname);
  702.         MessagePopup ("Info", cres);
  703.                                 return 0;
  704.                         }
  705.                         time(&mtime);
  706.                         printf("#%s %s\n",DateStr(), TimeStr());
  707.                         if (fp) fprintf(fp, "#%s %s\n",DateStr(), TimeStr());
  708.         //              K6517_current_mode (range);
  709.                         stop = 0;
  710.                         LogScaleCB (panel, P2_LOGSCALE, EVENT_COMMIT,NULL, 0, 0);
  711.                         int voltageMax[4]={P2_UMAX_1,P2_UMAX_2,P2_UMAX_3,P2_UMAX_4};
  712.                         int voltageMin[4]={P2_UMIN_1,P2_UMIN_2,P2_UMIN_3,P2_UMIN_4};
  713.                         int numberOfSteps[4]={P2_NSTEPS_1,P2_NSTEPS_2,P2_NSTEPS_3,P2_NSTEPS_4};
  714.                         int selectRange[4]={P2_RANGE_1,P2_RANGE_2,P2_RANGE_3,P2_RANGE_4};
  715.                         int intervals[4]={P2_SLCT_1,P2_SLCT_2,P2_SLCT_3,P2_SLCT_4};
  716.                         int nrOfInt;
  717.                         int nrOfSteps;
  718.                         int N=0;
  719.                         int K=0;
  720.                         for (int j=0;j<4;j++){
  721.                                 GetCtrlVal(panel, intervals[j], &nrOfInt);
  722.                                 N = N + nrOfInt;
  723.                                 GetCtrlVal(panel, numberOfSteps[j], &nrOfSteps);
  724.                                 K = K + nrOfSteps;
  725.                         }
  726.                         xpoints = (double *) malloc ((K-N+2)*sizeof(double));
  727.                         ypoints = (double *) malloc ((K-N+2)*sizeof(double));
  728.                         int tockaK=0;
  729.                         for (int i=0;i<N;i++){
  730.                                 GetCtrlVal(panel, voltageMin[i], &umin);
  731.                                 GetCtrlVal(panel, voltageMax[i], &umax);
  732.                                 GetCtrlVal(panel, numberOfSteps[i], &nsteps);
  733.                                 GetCtrlVal(panel, selectRange[i], &range);
  734.                                 K6517_current_mode (range);
  735.                                 for (int n=0;n<nsteps+1;n++){
  736.                                         if (i>0) {
  737.                                                 if(n==0) n++;
  738.                                         };
  739.                                         u= umin+ n*(umax-umin)/nsteps;
  740.                                         K6517_vsource_set (u);
  741. //                              voltage =K6517_vsource_get();
  742.                 current =K6517_get(cres,&k);
  743.                                         if (current > range) printf("Overflow +\n");
  744.                                         if (current < -range) printf("Overflow -\n");
  745.                                         voltage = u;
  746.                                         xpoints[tockaK]= voltage;
  747.                                         ypoints[tockaK]= current;
  748.                                         SetCtrlVal(panel, P2_VMON, voltage);
  749.                                         if (fp) fprintf(fp, "%d %g %g %g\n",tockaK, u, voltage,current);
  750.                                         printf("n=%d u=%g voltage=%g current=%g\n",tockaK, u, voltage,current);  
  751.                                         if (plivhandle) DeleteGraphPlot (panel, P2_GRAPHIV, plivhandle, VAL_IMMEDIATE_DRAW);
  752.                                         plivhandle = PlotXY (panel, P2_GRAPHIV, xpoints, ypoints, tockaK+1, VAL_DOUBLE, VAL_DOUBLE, VAL_CONNECTED_POINTS, VAL_BOLD_X, VAL_SOLID, 1, VAL_RED);
  753.                                         ProcessSystemEvents();
  754.                                         tockaK++;
  755.                                         if (stop) break;
  756.                                 }
  757.                         }
  758.                         fclose(fp);
  759.                         free(xpoints);
  760.                         free(ypoints);
  761.                         break;
  762.         }
  763.         return 0;
  764. }
  765.  
  766. int CVICALLBACK SETVOLTCB (int panel, int control, int event,
  767.                                                                                                          void *callbackData, int eventData1, int eventData2) {
  768.         double voltage;
  769.         switch (event) {
  770.                 case EVENT_COMMIT:
  771.                         GetCtrlVal(panel, P2_VOLT, &voltage);
  772.                         K6517_vsource_set (voltage);
  773.                         break;
  774.         }
  775.         return 0;
  776. }
  777.  
  778.  
  779. int CVICALLBACK StopCB (int panel, int control, int event,
  780.                                                                                                 void *callbackData, int eventData1, int eventData2) {
  781.         switch (event) {
  782.                 case EVENT_COMMIT:
  783.                         stop = 1;
  784.                         break;
  785.         }
  786.         return 0;
  787. }
  788.  
  789. int CVICALLBACK LogScaleCB (int panel, int control, int event,
  790.                                                                                                                 void *callbackData, int eventData1, int eventData2) {
  791.         int selected;
  792.         switch (event) {
  793.                 case EVENT_COMMIT:
  794.                         GetCtrlVal(panel, control, &selected);
  795.                         if(selected) SetCtrlAttribute (panel, P2_GRAPHIV,ATTR_YMAP_MODE, VAL_LOG);
  796.                         else SetCtrlAttribute (panel, P2_GRAPHIV,ATTR_YMAP_MODE, VAL_LINEAR);
  797.                         break;
  798.         }
  799.         return 0;
  800. }
  801.  
  802.  
  803. //****************************
  804. int EscapeString(const char *i, char *o) {
  805.   int iptr=0, optr = 0;
  806.   // walk though the input string
  807.   for (iptr = 0; iptr < strlen(i); iptr++, optr++) {
  808.     // search for
  809.     if ( (i[iptr]=='\\') ) {
  810.       printf("Escape String %d %d \n",i[iptr] , i[iptr]==92 ) ;
  811.       //sa02Printf("Escape String %d %d \n",i[iptr] , ( (i[iptr] == 92) || (i[iptr] == 42) )) ;
  812.       o[optr] = i[iptr];
  813.       optr++;
  814.     }
  815.     o[optr] = i[iptr];
  816.   }
  817.   o[optr] = '\0';
  818.   return 0;
  819. }
  820.  
  821.  
  822. int CVICALLBACK DrawCB (int panel, int control, int event,
  823.                                                                                                 void *callbackData, int eventData1, int eventData2) {
  824.         switch (event) {
  825.                 case EVENT_COMMIT:{
  826.                         char fileName[100];
  827.                         char fname[100];
  828.                         char path[100];
  829.                         GetCtrlVal(panel, P2_FILENAME, fileName);
  830.                         GetCtrlVal(panel, P2_PATH, path);
  831.                         sprintf(fname, "%s/%s.dat", path, fileName);
  832.                         int status;
  833.                         char name[MAX_PATHNAME_LEN];
  834. //      char dfile[MAX_PATHNAME_LEN];
  835. //      char efile[MAX_PATHNAME_LEN];
  836. //      status = FileSelectPopup ("dat", "*.dat", ".dat",
  837. //                                "Izberi datoteko s podatki",
  838. //                                VAL_LOAD_BUTTON, 0, 0, 1, 0, efile);
  839. //      EscapeString(efile,dfile);
  840.       sprintf(name ,"C:/root/bin/root.exe IUdraw.cxx(\\\"%s\\\")", fname);
  841.         //              sprintf(name ,"C:/root/bin/root.exe IUdraw.cxx");
  842.       printf("%s\n",name);
  843.       LaunchExecutable(name);
  844.                         break;
  845.                 }      
  846.         }
  847.         return 0;
  848. }
  849.  
  850.  
  851. int CVICALLBACK Print (int panel, int control, int event,
  852.                        void *callbackData, int eventData1, int eventData2) {
  853.   char dfile[MAX_PATHNAME_LEN];
  854.   char name[MAX_PATHNAME_LEN];
  855.   int h2=0;
  856.   switch (event) {
  857.     case EVENT_COMMIT: {
  858.       int hours, minutes, seconds;
  859.       int month, day, year;
  860.       int   id=-1;
  861.       //int   bitmap = 0;
  862.      
  863.       GetSystemDate (&month,&day ,&year );
  864.       GetSystemTime(&hours, &minutes, &seconds);
  865.                 sprintf(name,"IV");
  866.           sprintf(dfile ,"%d_%d_%d_%d_%d_%s.bmp",year,month,day,hours,minutes, name );
  867.           SaveCtrlDisplayToFile (panel,P2_GRAPHIV, 0, -1, -1, dfile);
  868.           printf("bmp image saved as %s\n", dfile);
  869.        
  870.       //PrintCtrl (p1h, P1_GRAPH2D, "sa02_CVI", 1, 1);
  871.     }
  872.     break;
  873.   }
  874.   return 0;
  875. }
  876.  
  877. int CVICALLBACK DebugCB (int panel, int control, int event,
  878.                                                                                                  void *callbackData, int eventData1, int eventData2) {
  879.         int selected;
  880.         int debugCode;
  881.         switch (event) {
  882.                 case EVENT_COMMIT:
  883.                         GetCtrlVal(panel, control, &selected);
  884.                         if(selected) debugCode = 1;
  885.                         else debugCode = 0;
  886.                         break;
  887.         }
  888.         return 0;
  889. }
  890.  
  891. int CVICALLBACK Exit2CB (int panel, int control, int event,
  892.                                                                                                  void *callbackData, int eventData1, int eventData2) {
  893.         switch (event) {
  894.                 case EVENT_COMMIT:
  895.                         K6517_send (":OUTP OFF", 0);
  896.       QuitUserInterface(0);
  897.                         break;
  898.         }
  899.         return 0;
  900. }
  901. #endif
  902.