Subversion Repositories f9daq

#include <tcpsupp.h>

#include <formatio.h>

#include <userint.h>

#include <ansi_c.h>

#include <utility.h>

#include <gpib.h>

#include "toolbox.h"

#include "prologix.h"

#include "K6517.h"

K6517STATUS K6517Stat;

static int K6517_Interface,K6517_Port,K6517_Gdev;

static int iret;

static int stop;

static int debugCode;                                  

int _VI_FUNC K6517_status_print (void);

void GpibError(char *msg) {

  printf ("%s\n", msg);

  printf ("ibsta = &H%x  <", ibsta);

  if (ibsta & ERR )  printf (" ERR");

  if (ibsta & TIMO)  printf (" TIMO");

  if (ibsta & END )  printf (" END");

  if (ibsta & SRQI)  printf (" SRQI");

  if (ibsta & RQS )  printf (" RQS");

  if (ibsta & CMPL)  printf (" CMPL");

  if (ibsta & LOK )  printf (" LOK");

  if (ibsta & REM )  printf (" REM");

  if (ibsta & CIC )  printf (" CIC");

  if (ibsta & ATN )  printf (" ATN");

  if (ibsta & TACS)  printf (" TACS");

  if (ibsta & LACS)  printf (" LACS");

  if (ibsta & DTAS)  printf (" DTAS");

  if (ibsta & DCAS)  printf (" DCAS");

  printf (" >\n");

  printf ("iberr = %d", iberr);

  if (iberr == EDVR) printf (" EDVR <DOS Error>\n");

  if (iberr == ECIC) printf (" ECIC <Not Controller-In-Charge>\n");

  if (iberr == ENOL) printf (" ENOL <No Listener>\n");

  if (iberr == EADR) printf (" EADR <Address error>\n");

  if (iberr == EARG) printf (" EARG <Invalid argument>\n");

  if (iberr == ESAC) printf (" ESAC <Not System Controller>\n");

  if (iberr == EABO) printf (" EABO <Operation aborted>\n");

  if (iberr == ENEB) printf (" ENEB <No GPIB board>\n");

  if (iberr == EOIP) printf (" EOIP <Async I/O in progress>\n");

  if (iberr == ECAP) printf (" ECAP <No capability>\n");

  if (iberr == EFSO) printf (" EFSO <File system error>\n");

  if (iberr == EBUS) printf (" EBUS <Command error>\n");

  if (iberr == ESTB) printf (" ESTB <Status byte lost>\n");

  if (iberr == ESRQ) printf (" ESRQ <SRQ stuck on>\n");

  if (iberr == ETAB) printf (" ETAB <Table Overflow>\n");

  printf ("ibcntl = %ld\n", ibcntl);

  printf ("\n");

  /* Call ibonl to take the device and interface offline */

  ibonl (K6517_Gdev,0);

  exit(1);

}

void _VI_FUNC K6517_open (int interface, int port, int primary_addr,

                         int secondary_addr, int timeout)

{

  char cmd[100];

        int status;

/*

  K6517_Gdev = OpenDev ("GPIB0", "");

  if (ibsta & ERR) GpibError("OpenDev Error");

  iret = ibpad (K6517_Gdev, 0);

  if (ibsta & ERR) GpibError("OpenDev Error");

  iret = ibsad (K6517_Gdev, NO_SAD);

  iret = ibtmo (K6517_Gdev, T10s);

  iret = ibeot (K6517_Gdev, 1);

  iret = ibeos (K6517_Gdev, 0);

*/

  K6517_Interface=interface;

  K6517_Port=port;

  switch (K6517_Interface){

    case 1:

      status = PROLOGIX_Open (K6517_Port);

                        printf("K6517_open %d\n", status);

      sprintf(cmd,"++addr %0d",primary_addr);

      PROLOGIX_Send (cmd);

      PROLOGIX_Send ("++auto 0");

      PROLOGIX_Send ("++eoi 1");

      PROLOGIX_Send ("++eot_enable 0");

      PROLOGIX_Send ("++read_tmo_ms 1000");

      break;

    default:

      K6517_Gdev = ibdev(K6517_Port,primary_addr,secondary_addr,timeout,1,0);

      if (ibsta & ERR) GpibError("OpenDev Error");

  }

        printf("Interface %d\n", interface);

        K6517_send("*RST",0);

        K6517_send("*IDN?", 5);

        char cres[100];

        cres[0]= 0;

        int len = K6517_receive (cres, 50);

        printf("[%d] %s\n", len, cres);

        Delay(GDELAY);  

  return;  

}

void _VI_FUNC K6517_clear (void)

{

  switch (K6517_Interface){

    case 1:

      PROLOGIX_Send("++clr");

      break;

    default:

      iret = ibclr (K6517_Gdev); // Clear the device

      if (ibsta & ERR) GpibError("OpenDev Error");

  }

//  Delay(GDELAY);   

  Delay(2.);

  return;  

}

void _VI_FUNC K6517_send (char *cmd, int len)

{

        if (debugCode) printf("-> %s\n", cmd);

        if (!len) len = strlen(cmd);

  switch (K6517_Interface){

    case 1:

      PROLOGIX_Send(cmd);

      break;

    default:

      iret = ibwrt (K6517_Gdev, cmd, len);

      if (ibsta & ERR) GpibError("OpenDev Error");

  }

  Delay(GDELAY);  

  return;  

}

int _VI_FUNC K6517_receive (char *response, int maxbyt)

{

        int ierr=0;

  switch (K6517_Interface){

    case 1:

      PROLOGIX_Send("++read eoi");

      ierr= PROLOGIX_Receive (response,maxbyt);

                        if (debugCode) printf("<---Read [%d] %s\n", ierr, response);

                        return ierr;

      break;

    default:

      iret = ibrd (K6517_Gdev, response, maxbyt);

      if (ibsta & ERR) GpibError("OpenDev Error");

      response[ibcntl]=0;

      return ibcntl;    

  }

}

void _VI_FUNC K6517_status (void)

{

  int len;

  char cres[100];

  K6517_send ("U0X", 3);

  len = K6517_receive (cres, 90);

  sscanf(cres," 617%1d%2d%1d%1d%1d%1d%1d%1d%1d%1d%1d%2d%1d%2c",

         &K6517Stat.function,&K6517Stat.range,&K6517Stat.zero_check,

         &K6517Stat.zero_correct,&K6517Stat.suppress,&K6517Stat.trigger,

         &K6517Stat.vsource_operate,&K6517Stat.read_mode,

         &K6517Stat.data_prefix,&K6517Stat.display,

         &K6517Stat.data_store,&K6517Stat.srq,&K6517Stat.eoi,K6517Stat.terminator);

   printf("617FRRCZNTOBGDQMMKYY\n");

   printf("%s\n",cres);

//  K6517_send ("X", 1);

  return;

}

void _VI_FUNC K6517_data_format (int mode)

{

  int len;

  char cmd[100];

  len=sprintf(cmd,"G%0dX",mode);

  K6517_send (cmd, len);

  return;

}

double _VI_FUNC K6517_get (char *prefix, int *loc)

{

  double value;

  char cres[100];

        K6517_send ("SENS:FUNC  'curr'",0);

//      K6517_send (":SENS:CURR:RANG:UPP 21e-3",0);

//      K6517_send ("SYST:ZCH 0",0);      

  K6517_send ("READ?",0);

        cres[0]= 0;

        int len = K6517_receive (cres, 50);

  if (debugCode) printf("current >%d, %s\n",len,cres);

  return atof(cres);

        /*

  K6517_send ("X", 1);

  len = K6517_receive (cres, 50);

  if (loc) {

    *loc=-1;

    sscanf(cres,"%4c%lg,%d",prefix, &value, loc);

    prefix[4]=0;

  } else {

    sscanf(cres,"%*4c%lg,%*d",&value);

  }

  return value;

        */

}

void _VI_FUNC K6517_current_mode (double range)

{

  int len;

  char cmd[100];

  if (range > 0) {

                len=sprintf(cmd,":SENS:CURR:RANG:AUTO OFF");

                len=sprintf(cmd,":SENS:CURR:RANG:UPP %g",range);

        }

        else len=sprintf(cmd,":SENS:CURR:RANG:AUTO ON");

//  printf("%d, %s\n",len,cmd);

  K6517_send (cmd, len);

  Delay(1);

        K6517_send ("SYST:ZCH 0",0);

  return;

}

void _VI_FUNC K6517_zero_correct (int zcorrect)

{

  K6517_send ("C0X", 3);

  K6517_send ("Z0X", 3);

  if (zcorrect) {

    K6517_send ("C1X", 3);

    Delay(2);

    K6517_send ("Z1X", 3);

    K6517_send ("C0X", 3);

  }

  return;

}

void _VI_FUNC K6517_trigger_mode (int mode)

{

  int len;

  char cmd[100];

  //len=sprintf(cmd,"T%0dX",mode);

  //K6517_send (cmd, len);

  return;

}

void _VI_FUNC K6517_reading_mode (int mode)

{

  int len;

  char cmd[100];

  //len=sprintf(cmd,"B%0dX",mode);

  //K6517_send (cmd, len);

  return;

}

void _VI_FUNC K6517_vsource_set (float value)

{

  int len;

  char cmd[100];

  len=sprintf(cmd,":SOURCE:VOLTAGE %f",value);

  K6517_send (cmd, len);

        len=sprintf(cmd,":SOURCE:VOLTAGE:MCONNECT ON");

  K6517_send (cmd, len);

  return;

}

double _VI_FUNC K6517_vsource_get (void)

{

  double value;

        /*

        K6517_send ("SENS:FUNC  'volt'",0);

        K6517_send ("SENS:VOLT:RANG:AUTO ON",0);      

        K6517_send ("SYST:ZCH 0",0);

  K6517_send ("READ?",0);

        */

        K6517_send (":MEASure:VOLTage?",0);

        char cres[100];

        cres[0]= 0;

        int len = K6517_receive (cres, 50);

  return atof(cres);    

}

void _VI_FUNC K6517_vsource_operate (int operate)

{

  if (operate){  

//              K6517_send (":SOURCE:VOLTAGE:MCONNECT 1", 0); 

//              K6517_send (":SENS:VOLTAGE:MANual:VSOurce:OPERate 1", 0);

                //K6517_send (":MCONNECT 1", 0); 

                K6517_send (":OUTP ON", 0);  

//    K6517_send (":SOURCE:VOLTAGE:RANGE 99", 0);

//        K6517_send (":SOURCE:VOLTAGE 22", 0);

        } else {

    //K6517_send (":SOURCE:VOLTAGE 0", 0);

//              K6517_send (":SENSe:VOLTAGE:MANual:VSOurce:OPERate 0", 0);

//              K6517_send (":SOURCE:VOLTAGE:MCONNECT 0", 0);

                K6517_send (":OUTP OFF", 0);    

                //K6517_send (":MCONNECT 0", 0); 

  }  

        K6517_send (":STATUS:OPER?",0);

        char cres[100];

        cres[0]= 0;

        int len = K6517_receive (cres, 50);

//  return atoi(cres);

}

void _VI_FUNC K6517_close (void)

{

//  iret = CloseDev (K6517_Gdev);

  switch (K6517_Interface){

    case 1:

      PROLOGIX_Close();

      break;

    default:

     iret = ibonl(K6517_Gdev, 0);// Take the device offline

     if (ibsta & ERR) GpibError("OpenDev Error");

  }

  return;

}

void _VI_FUNC K6517_test (void)

{

        int i;

  double value;

  char cres[100];

  K6517_clear ();

        K6517_current_mode (0);

  K6517_zero_correct (1);

  K6517_data_format (0);

  K6517_trigger_mode (1);

  K6517_vsource_set (-100.);

  K6517_vsource_operate (1);

  K6517_status();

  value=K6517_get(cres,&i);

  printf("%s, %lg, %d\n",cres,value,i);

  value=K6517_vsource_get();

  printf("%lg\n",value);

  value=K6517_get(cres,&i);

  printf("%s, %lg, %d\n",cres,value,i);

  value=K6517_get(cres,&i);

  printf("%s, %lg, %d\n",cres,value,i);

  value=K6517_get(cres,&i);

  printf("%s, %lg, %d\n",cres,value,i);

  value=K6517_get(cres,&i);

  printf("%s, %lg, %d\n",cres,value,i);

  Delay(5);

  K6517_vsource_operate (0);

}

#ifdef K6517_MAIN

#include <cvirte.h>

#include <userint.h>

#include "K6517-ctrl.h" 

int pnl; int gLogToFile;

int pn2;

int gLogToFile;

int vmon[4]={P1_VMON_1};

int imon[4]={P1_IMON_1 };

int vset[4]={P1_U_1 };

int iset[4]={P1_I_1 };

int radiob[4]={P1_BOX_1 };

int cvcc[4]={P1_CVCC_1 };

const unsigned char Pre_1 = 1;

int gMask=0xF;

int pnl;

FILE *gFp;

static int tfID;

static int rID;

static CmtThreadPoolHandle poolHandle = 0;

#define MAX_THREADS 10  

/*---------------------------------------------------------------------------*/

/* Macros                                                                                            */

/*---------------------------------------------------------------------------*/

#define tcpChk(f) if ((g_TCPError=(f)) < 0) {ReportTCPError();} 

/*---------------------------------------------------------------------------*/

/* Internal function prototypes                                              */

/*---------------------------------------------------------------------------*/

int CVICALLBACK ClientTCPCB (unsigned handle, int event, int error,

                             void *callbackData);

static void ReportTCPError (void);

/*---------------------------------------------------------------------------*/

/* Module-globals                                                            */

/*---------------------------------------------------------------------------*/

static unsigned int g_hconversation;

static int          g_hmainPanel;

static int                      g_connected = 0;

static int                      g_TCPError = 0;

/*---------------------------------------------------------------------------*/

/* Report TCP Errors if any                                                                      */

/*---------------------------------------------------------------------------*/

static void ReportTCPError(void)

{

        if (g_TCPError < 0)

                {

                char    messageBuffer[1024];

                sprintf(messageBuffer,

                        "TCP library error message: %s\nSystem error message: %s",

                        GetTCPErrorString (g_TCPError), GetTCPSystemErrorString());

                MessagePopup ("Error", messageBuffer);

                g_TCPError = 0;

                }

}

/*---------------------------------------------------------------------------*/

int CVICALLBACK DisconnectCB (int panel, int control, int event,

                                                                                                                        void *callbackData, int eventData1, int eventData2) {

        switch (event) {

                case EVENT_COMMIT:

                        if (g_connected)

        DisconnectFromTCPServer (g_hconversation);

                        g_hconversation = 0;

                        g_connected = 0;

                        break;

        }

        return 0;

}

int CVICALLBACK ConnectCB (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) {

        int portNum=10000;

        char tempBuf[512];

        sprintf(tempBuf,"localhost");

        switch (event) {

                case EVENT_COMMIT:

                        if (ConnectToTCPServer (&g_hconversation, portNum, tempBuf, ClientTCPCB, NULL, 5000) < 0)

        MessagePopup("TCP Client", "Connection to server failed !");

    else

        {

        SetWaitCursor (0);

        g_connected = 1;

        /* We are successfully connected -- gather info */

                  if (GetTCPHostAddr (tempBuf, 256) >= 0) printf("%s\n" ,tempBuf);

                    if (GetTCPHostName (tempBuf, 256) >= 0) printf("%s\n" ,tempBuf);

        tcpChk (GetTCPPeerAddr (g_hconversation, tempBuf, 256));

        printf("%s\n" ,tempBuf);

        tcpChk (GetTCPPeerName (g_hconversation, tempBuf, 256));

        printf("%s\n" ,tempBuf);

        }

                        break;

        }

        return 0;

}

int CVICALLBACK ClientTCPCB (unsigned handle, int event, int error, void *callbackData)

{

    char receiveBuf[256] = {0};

    ssize_t dataSize         = sizeof (receiveBuf) - 1;

    switch (event)

        {

        case TCP_DATAREADY:

            if ((dataSize = ClientTCPRead (g_hconversation, receiveBuf,

                                           dataSize, 1000))

                < 0)

                {

                printf( "Receive Error\n");

                }

            else

                {

                receiveBuf[dataSize] = '\0';

                //printf("%s", receiveBuf);

                                                                float temp = 0;

                                                                float humidity = 0;

                                                                float dt=0;

                                                                float tdiff=0;

                                                                int t0 = 0;

                                                                sscanf(receiveBuf, "%d%f%f%f%f", &t0,&humidity,&temp, &tdiff, &dt);

                                                                SetCtrlVal(pn2,P2_TMON, temp);

                                                                SetCtrlVal(pn2,P2_HUMIDITY, humidity);

                                                                if (fabs(tdiff)<0.5 && fabs(dt) < 0.2)   SetCtrlVal(pn2,P2_LED, 1);

                                                                else  SetCtrlVal(pn2,P2_LED, 0);    

                }

            break;

        case TCP_DISCONNECT:

            MessagePopup ("TCP Client", "Server has closed connection!");

            g_connected = 0;

            break;

    }

    return 0;

}

void SetDimming(int state) {

        SetCtrlAttribute (pnl, P2_IVSCAN, ATTR_DIMMED, state);

        SetCtrlAttribute (pnl, P2_EXIT, ATTR_DIMMED, state);

        SetCtrlAttribute (pnl, P2_STOP, ATTR_DIMMED, !state);

}

void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle,

                               CmtThreadFunctionID functionID, unsigned int event,

                               int value, void *callbackData  ) {

  SetDimming(0);

  printf("End of Thread \n");

  return ;

}

int ivscan (void *arg);

int TScan () {

        double temp;

        int n=0;

        int led;

        GetNumTableRows (pn2, P2_TABLE, &n );

        for(int i=0; i<n; i++) {

                GetTableCellVal (pn2, P2_TABLE, MakePoint (1,i+1), &temp);

                if (temp>100) break;  

                char transmitBuf[512]= {0};

                sprintf(transmitBuf, "1 %f\n", temp);

                SetCtrlVal(pn2,P2_LED, 0);    

                if (g_hconversation)

                                if ( ClientTCPWrite (g_hconversation, transmitBuf, strlen (transmitBuf), 1000) < 0) printf("Transmit Error\n");

          do {

                        time_t t0 = time(NULL);

                        SetCtrlVal(pn2,P2_TIME, ctime(&t0));    

                        Delay(1);

                        GetCtrlVal(pn2,P2_LED, &led);

                        if (stop) break;

                }       while    (!led);

                if (stop) break;

                int itemp = (int) temp;

                ivscan(&itemp);

                printf("%d %f\n",i,temp);

        }

        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 TimerOnOffCB (int panel, int control, int event,

                              void *callbackData, int eventData1, int eventData2)

{

  int state;

  switch (event)

  {

    case EVENT_COMMIT:

      GetCtrlVal(panel, control, &state);

      if (state){

         ResumeTimerCallbacks();

      } else {

         SuspendTimerCallbacks ();

         printf ("Disabling timer....\n");

      }

      break;

  }

  return 0;

}

// reads the run number from the first line in the file

int GetRunNumberFromFile(char *fname) {

  char line[MAX_PATHNAME_LEN];

  int ndim= MAX_PATHNAME_LEN;

  int current_run = -1;

  FILE *fp = NULL;

  ssize_t size;

  if ( GetFileInfo(fname,&size) ) fp = fopen(fname,"r");

  if (fp) {

    if (fgets(line,ndim,fp)!= NULL) current_run = atoi(line);

    fclose(fp);

  }

  return current_run;

}

int IncreaseRunNumberInFile(char *fname) {

  int current_run = GetRunNumberFromFile(fname);

  FILE *fp = fopen(fname,"w");

  if (fp) {

    fprintf(fp,"%d", current_run+1 );

    fclose(fp);

  }

  return current_run+1;

}

int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,

                                           LPSTR lpszCmdLine, int nCmdShow)

{

    char cres[100];

  double Voltage, Current, tinterval;

  if (InitCVIRTE (hInstance, 0, 0) == 0) return -1;    /* out of memory */

                SetStdioPort (CVI_STDIO_WINDOW);

        SetSleepPolicy(VAL_SLEEP_MORE);

  CmtNewThreadPool (MAX_THREADS,  &poolHandle);

        if ((pnl = LoadPanel (0, "K6517-ctrl.uir", P1)) < 0) return -1;  

        if ((pn2 = LoadPanel (0, "K6517-ctrl.uir", P2)) < 0) return -1;

        DisableBreakOnLibraryErrors();

        K6517_open (1,4,3,0,13);

  SetCtrlVal(pnl, P1_ONOFF, 0);

  GetCtrlVal(pnl, P1_TINTERVAL, &tinterval);

  SetCtrlAttribute (pnl, P1_TIMER, ATTR_INTERVAL, tinterval);

  TimerOnOffCB(pnl, P1_TIMERON, EVENT_COMMIT,NULL,0,0);  

  for (unsigned char  ch=0;ch<1;ch++){

    int ison,i;

                Voltage =K6517_vsource_get();

    Current =K6517_get(cres,&i);

    SetCtrlVal(pnl, vset[ch], Voltage);

    SetCtrlVal(pnl, iset[ch], Current);

    GetCtrlVal(pnl, radiob[ch], &ison);

    gMask = ison;

  }

  DisplayPanel (pnl);

        DisplayPanel (pn2);

        RunUserInterface ();

        CmtDiscardThreadPool (poolHandle);

        if (g_connected)

        DisconnectFromTCPServer (g_hconversation);

        DiscardPanel (pn2);

        DiscardPanel (pnl);

  K6517_close();  

   if (gFp)  fclose(gFp);

  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 SetCB (int panel, int control, int event,

                       void *callbackData, int eventData1, int eventData2)

{

  char cres[100];

        int i;

  switch (event)

  {

    case EVENT_COMMIT:

      for (unsigned char ch = 0; ch<1;ch++){

        //printf("ch %d %x\n", ch, gMask);

        if (gMask){

          double Voltage;

          double Current;

          GetCtrlVal(panel, vset[ch], &Voltage);

          GetCtrlVal(panel, iset[ch], &Current);

          printf("->ch %d VSet %g Iset %g\n", ch, Voltage, Current);

                                        K6517_vsource_set (Voltage);

                                        Voltage=K6517_vsource_get();

          // TMI_Current(TMI_DeviceId, ch+1, Pre_1, Current);

                                        Current=K6517_get(cres,&i);  

          printf("<-ch %d VSet %g Iset %g\n", ch, Voltage, Current);  

        }

      }  

      break;

  }

  return 0;

}

int CVICALLBACK ReadCB (int panel, int control, int event,

                        void *callbackData, int eventData1, int eventData2)