WebSVN – f9daq – Diff – /pts/PtsModule_CVI.c


 
 
// sudo ./pts -a 0x1000000 -v 1 -w 2 turn LED ON
// sudo ./pts -a 0x1000000 -v 1 -w 1 turn LED OFF
// sudo ./ptsvmusb  -a 0x02501000  -v 2 -i a.bit -b 2
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <ctype.h>
 
#include <string.h>
 
#include "vme.h" 
 
#include <cvirte.h>             
 
#include "PtsModule.h"
#include <userint.h>
#include "PtsModule_CVI.h"
#include <utility.h> 
#include <formatio.h>   
static int p1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
int verbose;
uint32_t ptaddr=0;
char str[255];  
 
int Pts_write(uint32_t addr, uint32_t data ){
int i;
VME_A32D32_W(ptaddr+addr,data);
return 0;
}
 
int Pts_Mwrite(uint32_t addr, uint32_t data ){
int i;
VME_MW(VME_A32, VME_D32, ptaddr+addr,data);
return 0;
}
 
int Pts_read(uint32_t addr, uint32_t *data ){
VME_A32D32_R(ptaddr+addr,data);
return 0;
}
 
 
int Pts_erase( int verbose ) {
  uint32_t dum;
 
  Pts_write( ADR_CSR1, 0 );
  Delay(0.1);
  Pts_read( ADR_CSR1, &dum);
  if( verbose ) {
    sprintf(str, "CSR1(0x%02x) = 0x%04x\n", ADR_CSR1,dum & 0xffff );
    SetCtrlVal (p1, P1_RESPONSE, str);
  }  
  Pts_write( ADR_CSR1, CSR1_PROGRAM_ );
  Delay(0.1);
  Pts_read( ADR_CSR1, &dum);
  if( verbose ) {
    sprintf( str, "CSR1(0x%02x) = 0x%04x\n", ADR_CSR1, dum & 0xffff );
    SetCtrlVal (p1, P1_RESPONSE, str);
  }  
  return 1;
}
 
int Pts_configure_bit( const char *filename, int mode, int verbose ) {
  int c,j;
  int dummyword;
  FILE *fp;
  const long byte_per_dot = BYTE_PER_DOT;
  unsigned long nchar = 0;
 
  if( ( fp = fopen( filename, "rb" ) ) == NULL ) {
    if( verbose ) {
      sprintf( str, "cannot open \"%s\"\n", filename );
    SetCtrlVal (p1, P1_RESPONSE, str);
        }
    return -1;
  }
  if(verbose) sprintf( str, "file \"%s\" opened.\n", filename );
 
  /* ------------------------------------------------------------ *\
    The data for the configuration start from 0xffff_ffff_aa99_aa66
    ( cf. xapp138; we don't know the definition of the BIT file )
  \* ------------------------------------------------------------ */
  dummyword = 0;
  do{
    if( (c = getc( fp )) == EOF ) {
      if(verbose) {
         sprintf(str, "EOF detected. Exit.\n");
         
         SetCtrlVal (p1, P1_RESPONSE, str);
    }
      return -1;
    }
    (c == 0xff) ? dummyword++ : (dummyword=0);
  } while( dummyword < 4 );
 
  if( mode == SLAVESERIAL_MODE ) {
    if(verbose)  SetCtrlVal(p1,P1_RESPONSE,"slave serial mode");
    Pts_write( ADR_MODE, mode );
    Pts_erase( verbose );
    for( j=0; j<32; j++ ) Pts_write( ADR_CFG, 0x1 );
    while( (c=getc(fp))!=EOF ){
      for( j=0; j<8; j++ ) Pts_write( ADR_CFG, (c>>(7-j))&0x1 );
      nchar++;
      if( verbose && nchar%byte_per_dot==0 ) {
        sprintf( str,"#");
        SetCtrlVal(p1,P1_RESPONSE,str);
      }  
    }
  } else if( mode == SELECTMAP_MODE ) {
    if( verbose )  SetCtrlVal(p1,P1_RESPONSE,"select map mode\n");
    Pts_write( ADR_MODE, SELECTMAP_MODE );
    Pts_erase( verbose );
        VME_MWRST();
    for( j=0; j<4; j++ ) Pts_Mwrite( ADR_CFG, 0xff );
        VME_MWEXEC();
       
    VME_MWRST();
    while( (c=getc(fp))!=EOF ){
      int cc = 0;
      for(j=0; j<8; j++) cc |= ((c&(1<<j))>>j)<<(7-j);
      Pts_Mwrite( ADR_CFG, cc );
      nchar++;
      if( verbose && nchar%byte_per_dot==0 ){
        VME_MWEXEC();
        VME_MWRST();
        sprintf( str,"#");
        SetCtrlVal(p1,P1_RESPONSE,str);
      }  
    }
    VME_MWEXEC();
  } else {
    if(verbose) {
      sprintf(str, "\nIllegal mode\n");
      SetCtrlVal(p1,P1_RESPONSE,str);
    }  
    return -1;
  }
  if(verbose) {
     sprintf(str,"\ntotal %ld bits\n", nchar);
     
      SetCtrlVal(p1,P1_RESPONSE,str);
  }    
  fclose(fp);
  return Pts_check_configure( verbose );
}
 
int Pts_check_configure( int verbose ) {
  uint32_t csr1_value;
  Pts_read(ADR_CSR1,&csr1_value);
  if(verbose) {
      sprintf( str,"CSR1(0x%02x)=0x%04x\n",ADR_CSR1,csr1_value&0xffff);
   
      SetCtrlVal(p1,P1_RESPONSE,str);
  }    
  if(csr1_value&CSR1_DONE) {
    if(verbose) SetCtrlVal(p1,P1_RESPONSE, "configure complete.\n");
    return 1;
  } else {
    if(verbose)  SetCtrlVal(p1,P1_RESPONSE,"configure not complete.");
    return -1;
  }
}
 
int Pts_reset( int verbose ) {
  Pts_write(ADR_CSR0,1);
  if( verbose ) {
    sprintf( str, "CSR0(0x%02x) = 0x01\n", ADR_CSR0 );
     SetCtrlVal(p1,P1_RESPONSE,str);
  }  
  return 1;
}
 
int Pts_write_csr( int verbose, uint32_t value ) {
  Pts_write(ADR_CSR0,value);
  if( verbose ) {
    sprintf( str,"Pts_write_csr 0x%08x\n", value  );
    SetCtrlVal(p1,P1_RESPONSE,str);
  }  
  return 1;
}
 
 
void help(char *argv){
 sprintf(str,"Usage: %s -a ptsaddr -v verbose -c  .... Pts_check_configure\n", argv);
 SetCtrlVal(p1,P1_RESPONSE,str);
 sprintf(str,"Usage: %s -a ptsaddr -v verbose -i filename -b mode (2) ... Pts_configure_bit\n", argv);
 SetCtrlVal(p1,P1_RESPONSE,str);
 sprintf(str,"Usage: %s -a ptsaddr -v verbose -e  .... Pts_erase\n", argv);
 SetCtrlVal(p1,P1_RESPONSE,str);
 sprintf(str,"Usage: %s -a ptsaddr -v verbose -x  .... Pts_reset\n", argv);
 SetCtrlVal(p1,P1_RESPONSE,str);
 sprintf(str,"Usage: %s -a ptsaddr -v verbose -c  .... Pts_check_configure\n", argv);
 SetCtrlVal(p1,P1_RESPONSE,str);
 sprintf(str,"Usage: %s -a ptsaddr -v verbose -r  .... vme read\n", argv);
 SetCtrlVal(p1,P1_RESPONSE,str);
 sprintf(str,"Usage: %s -a ptsaddr -v verbose -w value .... vme write\n", argv);
 SetCtrlVal(p1,P1_RESPONSE,str);
 sprintf(str,"Usage: %s -a ptsaddr -v verbose -s value .... Pts_write_csr\n", argv);
 SetCtrlVal(p1,P1_RESPONSE,str);
 sprintf(str,"Example: %s  --address  0x1000000 --verbose 1 --erase\n", argv);
 SetCtrlVal(p1,P1_RESPONSE,str);
 sprintf(str,"Example: %s --address  0x1000000 --verbose 1 --input pts_scaler.bit --load-bit 2\n", argv);
 SetCtrlVal(p1,P1_RESPONSE,str);
 sprintf(str,"Example: %s --address  0x1000004 --write-csr 0x7600\n", argv);SetCtrlVal(p1,P1_RESPONSE,str);
}
 
 
 
int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                       LPSTR lpszCmdLine, int nCmdShow)
{
    char saddr[255];
        if (InitCVIRTE (hInstance, 0, 0) == 0)
                return -1;      /* out of memory */
        if ((p1 = LoadPanel (0, "PtsModule_CVI.uir", P1)) < 0)
                return -1;
        DisplayPanel (p1);
       
        GetCtrlVal(p1,P1_VERBOSE,&verbose);  
        GetCtrlVal(p1,P1_ADDRESS,saddr);
     ptaddr  =  strtoul (saddr,NULL,0);  
        RunUserInterface ();
        DiscardPanel (p1);
        VME_STOP();
        return 0;
}
 
int CVICALLBACK Reset (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
        switch (event)
                {
                case EVENT_COMMIT:
                        Pts_reset(verbose);
                        break;
                }
        return 0;
}
 
int CVICALLBACK Erase (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
        switch (event)
                {
                case EVENT_COMMIT:
                         Pts_erase(verbose);  
                        break;
                }
        return 0;
}
 
int CVICALLBACK Download (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
    char filename[254];
    int mode=0;
        switch (event)
                {
                case EVENT_COMMIT:
                         GetCtrlVal(p1,P1_FIRMWARE,filename);
                         GetCtrlVal(p1,P1_MODE,&mode);
             if(VME_CONNECTED() >=0 ) {
               Pts_configure_bit( filename, mode,  verbose );
                         } else {
                           MessagePopup ("Warning", "Connect VME!!");
                         }  
                        break;
                }
        return 0;
}
 
int CVICALLBACK Check (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
        switch (event)
                {
                case EVENT_COMMIT:
                         Pts_check_configure( verbose );  
                        break;
                }
        return 0;
}
 
int CVICALLBACK Read (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
    uint32_t value=0;
    char str[0xFF];
        char saddr[256];
        int offset;
        switch (event)
                {
                case EVENT_COMMIT:
                        GetCtrlVal(p1,P1_OFFSET,saddr);
                        offset = strtoul (saddr,NULL,0);
                        Pts_read( offset , &value );
                        if( verbose ) {
               sprintf(str, "VME Read addr 0x%0x+0x%0x  response 0x%0x\n", ptaddr, offset, value );
               SetCtrlVal (p1, P1_RESPONSE, str);
            }
                        break;
                }
        return 0;
}
 
int CVICALLBACK Write (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
    int value;
        int offset;
    char svalue[256];
    char saddr[256];
        switch (event)
                {
                case EVENT_COMMIT:
                      GetCtrlVal(p1,P1_DATA,svalue);
                          GetCtrlVal(p1,P1_OFFSET,saddr);  
                         value  = strtoul (svalue,NULL,0);
                         offset = strtoul (saddr,NULL,0);
            Pts_write( offset , value );
                        if( verbose ) {
               sprintf(str, "VME Write addr 0x%0x+0x%0x  data 0x%0x\n", ptaddr, offset, value );
               SetCtrlVal (p1, P1_RESPONSE, str);
            }
                        break;
                }
        return 0;
}
 
int CVICALLBACK WriteCSR (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
      int value;
    char svalue[256];
        switch (event)
                {
                case EVENT_COMMIT:
                     GetCtrlVal(p1,P1_DATA,svalue);
                         value = strtoul (svalue,NULL,0);
                         Pts_write_csr( verbose, value );
                        break;
                }
        return 0;
}
 
int CVICALLBACK Verbose (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
    int * data;
        switch (event)
                {
                case EVENT_COMMIT:
                    GetCtrlVal(panel,control,&verbose);
                         
                        break;
                }
        return 0;
}
 
int CVICALLBACK Help (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
        switch (event)
                {
                case EVENT_COMMIT:
                        help("PtsModule");
                        break;
                }
        return 0;
}
 
int CVICALLBACK Address (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
   char saddr[100];
        switch (event)
                {
                case EVENT_COMMIT:
                    GetCtrlVal(p1,P1_ADDRESS,saddr);
                        ptaddr  =  strtoul (saddr,NULL,0);  
                        break;
                }
        return 0;
}
 
int CVICALLBACK Exit (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
        switch (event)
                {
                case EVENT_COMMIT:
                        QuitUserInterface(0);
                        break;
                }
        return 0;
}
 
int CVICALLBACK FSelect (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
   int status;
   char pathName[MAX_PATHNAME_LEN];
        switch (event)
                {
                case EVENT_COMMIT:
                        status = FileSelectPopup ("", "*.bit", "*.bit", "Select Firmware file",
                                                                          VAL_SELECT_BUTTON, 0, 0, 1, 0, pathName);
                        if (status>0) SetCtrlVal(p1,P1_FIRMWARE,pathName);                                               
                        break;
                }
        return 0;
}
 
int CVICALLBACK LedCB (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
        switch (event)
                {
                int value=0;
                case EVENT_COMMIT:
                        GetCtrlVal(p1,P1_LED,&value);
                         
            Pts_write( 0 , value+1 );
                       
                        break;
                }
        return 0;
}
 
int CVICALLBACK Execute (int panel, int control, int event,
                void *callbackData, int eventData1, int eventData2)
{
        switch (event)
        {
                case EVENT_COMMIT:{
                    int n,i,nb;
                        char buf[400];
                        unsigned int data, addr;
                        char sdata[255], saddr[255], rw[255];
                        GetNumTextBoxLines(panel, P1_COMMANDS,&n);
                        for (i=0;i<n;i++){
                      GetTextBoxLine(panel, P1_COMMANDS, i, buf);
                      nb = sscanf(buf,"%s%s%s",rw, saddr,sdata);
                      addr  =   strtoul (saddr,NULL,0);
                          data  =   strtoul (sdata,NULL,0);    
              if (strstr(rw,"W")!=NULL){
                             Pts_write( addr , data );
                                 if( verbose ) {
                   sprintf(str, "VME Write addr 0x%0x+0x%0x  data 0x%0x\n", ptaddr, addr, data );
                   SetCtrlVal (p1, P1_RESPONSE, str);
                 }
                          } else {
                            Pts_read( addr , &data );
                            if( verbose ) {
                  sprintf(str, "VME Read addr 0x%0x+0x%0x  response 0x%0x\n", ptaddr,  addr, data);
                  SetCtrlVal (p1, P1_RESPONSE, str);
                }
                          }
                        }  
                        break;
                                                  }
        }
        return 0;
}
 
int CVICALLBACK Connect (int panel, int control, int event,
                                                 void *callbackData, int eventData1, int eventData2)
{
        int interface = 0;
        switch (event)
        {
               
                case EVENT_COMMIT:
                        GetCtrlVal (p1, P1_VMEINTERFACE, &interface);
                VME_START(interface);  
                        break;
        }
        return 0;
}
 
int CVICALLBACK Disconnect (int panel, int control, int event,
                                                        void *callbackData, int eventData1, int eventData2)
{
        switch (event)
        {
                case EVENT_COMMIT:
                        VME_STOP();
                        break;
        }
        return 0;
}
 

Rev 81	Rev 83
1		1
2		2
-		3	// sudo ./pts -a 0x1000000 -v 1 -w 2 turn LED ON
-		4	// sudo ./pts -a 0x1000000 -v 1 -w 1 turn LED OFF
-		5	// sudo ./ptsvmusb -a 0x02501000 -v 2 -i a.bit -b 2
-		6	#include <stdlib.h>
-		7	#include <stdio.h>
-		8	#include <stdint.h>
-		9	#include <ctype.h>
-		10
-		11	#include <string.h>
-		12
-		13	#include "vme.h"
3		14
4	#include <cvirte.h>	15	#include <cvirte.h>
5		16
6	#include "PtsModule.h"	17	#include "PtsModule.h"
7	#include <userint.h>	18	#include <userint.h>
8	#include "PtsModule_CVI.h"	19	#include "PtsModule_CVI.h"
9	#include <utility.h>	20	#include <utility.h>
10	#include <formatio.h>	21	#include <formatio.h>
11	static int p1;	22	static int p1;
12		23
13	// sudo ./pts -a 0x1000000 -v 1 -w 2 turn LED ON	-
14	// sudo ./pts -a 0x1000000 -v 1 -w 1 turn LED OFF	-
15	// sudo ./ptsvmusb -a 0x02501000 -v 2 -i a.bit -b 2	-
16	#include <stdlib.h>	-
17	#include <stdio.h>	-
18		-
19	#include <ctype.h>	-
20		-
21	#include <string.h>	-
22		24
23	#include "vme.h"	-
24		25
25		26
26		27
27		28
28		29
29		30
30	int verbose;	31	int verbose;
31	uint32_t ptaddr=0;	32	uint32_t ptaddr=0;
32	char str[255];	33	char str[255];
33		34
34	int Pts_write(uint32_t addr, uint32_t data ){	35	int Pts_write(uint32_t addr, uint32_t data ){
35	int i;	36	int i;
36	VME_A32D32_W(ptaddr+addr,data);	37	VME_A32D32_W(ptaddr+addr,data);
37	return 0;	38	return 0;
38	}	39	}
39		40
40	int Pts_Mwrite(uint32_t addr, uint32_t data ){	41	int Pts_Mwrite(uint32_t addr, uint32_t data ){
41	int i;	42	int i;
42	VME_MW(VME_A32, VME_D32, ptaddr+addr,data);	43	VME_MW(VME_A32, VME_D32, ptaddr+addr,data);
43	return 0;	44	return 0;
44	}	45	}
45		46
46	int Pts_read(uint32_t addr, uint32_t *data ){	47	int Pts_read(uint32_t addr, uint32_t *data ){
47	VME_A32D32_R(ptaddr+addr,data);	48	VME_A32D32_R(ptaddr+addr,data);
48	return 0;	49	return 0;
49	}	50	}
50		51
51		52
52	int Pts_erase( int verbose ) {	53	int Pts_erase( int verbose ) {
53	uint32_t dum;	54	uint32_t dum;
54		55
55	Pts_write( ADR_CSR1, 0 );	56	Pts_write( ADR_CSR1, 0 );
56	Delay(0.1);	57	Delay(0.1);
57	Pts_read( ADR_CSR1, &dum);	58	Pts_read( ADR_CSR1, &dum);
58	if( verbose ) {	59	if( verbose ) {
59	sprintf(str, "CSR1(0x%02x) = 0x%04x\n", ADR_CSR1,dum & 0xffff );	60	sprintf(str, "CSR1(0x%02x) = 0x%04x\n", ADR_CSR1,dum & 0xffff );
60	SetCtrlVal (p1, P1_RESPONSE, str);	61	SetCtrlVal (p1, P1_RESPONSE, str);
61	}	62	}
62	Pts_write( ADR_CSR1, CSR1_PROGRAM_ );	63	Pts_write( ADR_CSR1, CSR1_PROGRAM_ );
63	Delay(0.1);	64	Delay(0.1);
64	Pts_read( ADR_CSR1, &dum);	65	Pts_read( ADR_CSR1, &dum);
65	if( verbose ) {	66	if( verbose ) {
66	sprintf( str, "CSR1(0x%02x) = 0x%04x\n", ADR_CSR1, dum & 0xffff );	67	sprintf( str, "CSR1(0x%02x) = 0x%04x\n", ADR_CSR1, dum & 0xffff );
67	SetCtrlVal (p1, P1_RESPONSE, str);	68	SetCtrlVal (p1, P1_RESPONSE, str);
68	}	69	}
69	return 1;	70	return 1;
70	}	71	}
71		72
72	int Pts_configure_bit( const char *filename, int mode, int verbose ) {	73	int Pts_configure_bit( const char *filename, int mode, int verbose ) {
73	int c,j;	74	int c,j;
74	int dummyword;	75	int dummyword;
75	FILE *fp;	76	FILE *fp;
76	const long byte_per_dot = BYTE_PER_DOT;	77	const long byte_per_dot = BYTE_PER_DOT;
77	unsigned long nchar = 0;	78	unsigned long nchar = 0;
78		79
79	if( ( fp = fopen( filename, "rb" ) ) == NULL ) {	80	if( ( fp = fopen( filename, "rb" ) ) == NULL ) {
80	if( verbose ) {	81	if( verbose ) {
81	sprintf( str, "cannot open \"%s\"\n", filename );	82	sprintf( str, "cannot open \"%s\"\n", filename );
82	SetCtrlVal (p1, P1_RESPONSE, str);	83	SetCtrlVal (p1, P1_RESPONSE, str);
83	}	84	}
84	return -1;	85	return -1;
85	}	86	}
86	if(verbose) sprintf( str, "file \"%s\" opened.\n", filename );	87	if(verbose) sprintf( str, "file \"%s\" opened.\n", filename );
87		88
88	/* ------------------------------------------------------------ *\	89	/* ------------------------------------------------------------ *\
89	The data for the configuration start from 0xffff_ffff_aa99_aa66	90	The data for the configuration start from 0xffff_ffff_aa99_aa66
90	( cf. xapp138; we don't know the definition of the BIT file )	91	( cf. xapp138; we don't know the definition of the BIT file )
91	\* ------------------------------------------------------------ */	92	\* ------------------------------------------------------------ */
92	dummyword = 0;	93	dummyword = 0;
93	do{	94	do{
94	if( (c = getc( fp )) == EOF ) {	95	if( (c = getc( fp )) == EOF ) {
95	if(verbose) {	96	if(verbose) {
96	sprintf(str, "EOF detected. Exit.\n");	97	sprintf(str, "EOF detected. Exit.\n");
97		98
98	SetCtrlVal (p1, P1_RESPONSE, str);	99	SetCtrlVal (p1, P1_RESPONSE, str);
99	}	100	}
100	return -1;	101	return -1;
101	}	102	}
102	(c == 0xff) ? dummyword++ : (dummyword=0);	103	(c == 0xff) ? dummyword++ : (dummyword=0);
103	} while( dummyword < 4 );	104	} while( dummyword < 4 );
104		105
105	if( mode == SLAVESERIAL_MODE ) {	106	if( mode == SLAVESERIAL_MODE ) {
106	if(verbose) SetCtrlVal(p1,P1_RESPONSE,"slave serial mode");	107	if(verbose) SetCtrlVal(p1,P1_RESPONSE,"slave serial mode");
107	Pts_write( ADR_MODE, mode );	108	Pts_write( ADR_MODE, mode );
108	Pts_erase( verbose );	109	Pts_erase( verbose );
109	for( j=0; j<32; j++ ) Pts_write( ADR_CFG, 0x1 );	110	for( j=0; j<32; j++ ) Pts_write( ADR_CFG, 0x1 );
110	while( (c=getc(fp))!=EOF ){	111	while( (c=getc(fp))!=EOF ){
111	for( j=0; j<8; j++ ) Pts_write( ADR_CFG, (c>>(7-j))&0x1 );	112	for( j=0; j<8; j++ ) Pts_write( ADR_CFG, (c>>(7-j))&0x1 );
112	nchar++;	113	nchar++;
113	if( verbose && nchar%byte_per_dot==0 ) {	114	if( verbose && nchar%byte_per_dot==0 ) {
114	sprintf( str,"#");	115	sprintf( str,"#");
115	SetCtrlVal(p1,P1_RESPONSE,str);	116	SetCtrlVal(p1,P1_RESPONSE,str);
116	}	117	}
117	}	118	}
118	} else if( mode == SELECTMAP_MODE ) {	119	} else if( mode == SELECTMAP_MODE ) {
119	if( verbose ) SetCtrlVal(p1,P1_RESPONSE,"select map mode\n");	120	if( verbose ) SetCtrlVal(p1,P1_RESPONSE,"select map mode\n");
120	Pts_write( ADR_MODE, SELECTMAP_MODE );	121	Pts_write( ADR_MODE, SELECTMAP_MODE );
121	Pts_erase( verbose );	122	Pts_erase( verbose );
122	VME_MWRST();	123	VME_MWRST();
123	for( j=0; j<4; j++ ) Pts_Mwrite( ADR_CFG, 0xff );	124	for( j=0; j<4; j++ ) Pts_Mwrite( ADR_CFG, 0xff );
124	VME_MWEXEC();	125	VME_MWEXEC();
125		126
126	VME_MWRST();	127	VME_MWRST();
127	while( (c=getc(fp))!=EOF ){	128	while( (c=getc(fp))!=EOF ){
128	int cc = 0;	129	int cc = 0;
129	for(j=0; j<8; j++) cc \|= ((c&(1<<j))>>j)<<(7-j);	130	for(j=0; j<8; j++) cc \|= ((c&(1<<j))>>j)<<(7-j);
130	Pts_Mwrite( ADR_CFG, cc );	131	Pts_Mwrite( ADR_CFG, cc );
131	nchar++;	132	nchar++;
132	if( verbose && nchar%byte_per_dot==0 ){	133	if( verbose && nchar%byte_per_dot==0 ){
133	VME_MWEXEC();	134	VME_MWEXEC();
134	VME_MWRST();	135	VME_MWRST();
135	sprintf( str,"#");	136	sprintf( str,"#");
136	SetCtrlVal(p1,P1_RESPONSE,str);	137	SetCtrlVal(p1,P1_RESPONSE,str);
137	}	138	}
138	}	139	}
139	VME_MWEXEC();	140	VME_MWEXEC();
140	} else {	141	} else {
141	if(verbose) {	142	if(verbose) {
142	sprintf(str, "\nIllegal mode\n");	143	sprintf(str, "\nIllegal mode\n");
143	SetCtrlVal(p1,P1_RESPONSE,str);	144	SetCtrlVal(p1,P1_RESPONSE,str);
144	}	145	}
145	return -1;	146	return -1;
146	}	147	}
147	if(verbose) {	148	if(verbose) {
148	sprintf(str,"\ntotal %ld bits\n", nchar);	149	sprintf(str,"\ntotal %ld bits\n", nchar);
149		150
150	SetCtrlVal(p1,P1_RESPONSE,str);	151	SetCtrlVal(p1,P1_RESPONSE,str);
151	}	152	}
152	fclose(fp);	153	fclose(fp);
153	return Pts_check_configure( verbose );	154	return Pts_check_configure( verbose );
154	}	155	}
155		156
156	int Pts_check_configure( int verbose ) {	157	int Pts_check_configure( int verbose ) {
157	uint32_t csr1_value;	158	uint32_t csr1_value;
158	Pts_read(ADR_CSR1,&csr1_value);	159	Pts_read(ADR_CSR1,&csr1_value);
159	if(verbose) {	160	if(verbose) {
160	sprintf( str,"CSR1(0x%02x)=0x%04x\n",ADR_CSR1,csr1_value&0xffff);	161	sprintf( str,"CSR1(0x%02x)=0x%04x\n",ADR_CSR1,csr1_value&0xffff);
161		162
162	SetCtrlVal(p1,P1_RESPONSE,str);	163	SetCtrlVal(p1,P1_RESPONSE,str);
163	}	164	}
164	if(csr1_value&CSR1_DONE) {	165	if(csr1_value&CSR1_DONE) {
165	if(verbose) SetCtrlVal(p1,P1_RESPONSE, "configure complete.\n");	166	if(verbose) SetCtrlVal(p1,P1_RESPONSE, "configure complete.\n");
166	return 1;	167	return 1;
167	} else {	168	} else {
168	if(verbose) SetCtrlVal(p1,P1_RESPONSE,"configure not complete.");	169	if(verbose) SetCtrlVal(p1,P1_RESPONSE,"configure not complete.");
169	return -1;	170	return -1;
170	}	171	}
171	}	172	}
172		173
173	int Pts_reset( int verbose ) {	174	int Pts_reset( int verbose ) {
174	Pts_write(ADR_CSR0,1);	175	Pts_write(ADR_CSR0,1);
175	if( verbose ) {	176	if( verbose ) {
176	sprintf( str, "CSR0(0x%02x) = 0x01\n", ADR_CSR0 );	177	sprintf( str, "CSR0(0x%02x) = 0x01\n", ADR_CSR0 );
177	SetCtrlVal(p1,P1_RESPONSE,str);	178	SetCtrlVal(p1,P1_RESPONSE,str);
178	}	179	}
179	return 1;	180	return 1;
180	}	181	}
181		182
182	int Pts_write_csr( int verbose, uint32_t value ) {	183	int Pts_write_csr( int verbose, uint32_t value ) {
183	Pts_write(ADR_CSR0,value);	184	Pts_write(ADR_CSR0,value);
184	if( verbose ) {	185	if( verbose ) {
185	sprintf( str,"Pts_write_csr 0x%08x\n", value );	186	sprintf( str,"Pts_write_csr 0x%08x\n", value );
186	SetCtrlVal(p1,P1_RESPONSE,str);	187	SetCtrlVal(p1,P1_RESPONSE,str);
187	}	188	}
188	return 1;	189	return 1;
189	}	190	}
190		191
191		192
192	void help(char *argv){	193	void help(char *argv){
193	sprintf(str,"Usage: %s -a ptsaddr -v verbose -c .... Pts_check_configure\n", argv);	194	sprintf(str,"Usage: %s -a ptsaddr -v verbose -c .... Pts_check_configure\n", argv);
194	SetCtrlVal(p1,P1_RESPONSE,str);	195	SetCtrlVal(p1,P1_RESPONSE,str);
195	sprintf(str,"Usage: %s -a ptsaddr -v verbose -i filename -b mode (2) ... Pts_configure_bit\n", argv);	196	sprintf(str,"Usage: %s -a ptsaddr -v verbose -i filename -b mode (2) ... Pts_configure_bit\n", argv);
196	SetCtrlVal(p1,P1_RESPONSE,str);	197	SetCtrlVal(p1,P1_RESPONSE,str);
197	sprintf(str,"Usage: %s -a ptsaddr -v verbose -e .... Pts_erase\n", argv);	198	sprintf(str,"Usage: %s -a ptsaddr -v verbose -e .... Pts_erase\n", argv);
198	SetCtrlVal(p1,P1_RESPONSE,str);	199	SetCtrlVal(p1,P1_RESPONSE,str);
199	sprintf(str,"Usage: %s -a ptsaddr -v verbose -x .... Pts_reset\n", argv);	200	sprintf(str,"Usage: %s -a ptsaddr -v verbose -x .... Pts_reset\n", argv);
200	SetCtrlVal(p1,P1_RESPONSE,str);	201	SetCtrlVal(p1,P1_RESPONSE,str);
201	sprintf(str,"Usage: %s -a ptsaddr -v verbose -c .... Pts_check_configure\n", argv);	202	sprintf(str,"Usage: %s -a ptsaddr -v verbose -c .... Pts_check_configure\n", argv);
202	SetCtrlVal(p1,P1_RESPONSE,str);	203	SetCtrlVal(p1,P1_RESPONSE,str);
203	sprintf(str,"Usage: %s -a ptsaddr -v verbose -r .... vme read\n", argv);	204	sprintf(str,"Usage: %s -a ptsaddr -v verbose -r .... vme read\n", argv);
204	SetCtrlVal(p1,P1_RESPONSE,str);	205	SetCtrlVal(p1,P1_RESPONSE,str);
205	sprintf(str,"Usage: %s -a ptsaddr -v verbose -w value .... vme write\n", argv);	206	sprintf(str,"Usage: %s -a ptsaddr -v verbose -w value .... vme write\n", argv);
206	SetCtrlVal(p1,P1_RESPONSE,str);	207	SetCtrlVal(p1,P1_RESPONSE,str);
207	sprintf(str,"Usage: %s -a ptsaddr -v verbose -s value .... Pts_write_csr\n", argv);	208	sprintf(str,"Usage: %s -a ptsaddr -v verbose -s value .... Pts_write_csr\n", argv);
208	SetCtrlVal(p1,P1_RESPONSE,str);	209	SetCtrlVal(p1,P1_RESPONSE,str);
209	sprintf(str,"Example: %s --address 0x1000000 --verbose 1 --erase\n", argv);	210	sprintf(str,"Example: %s --address 0x1000000 --verbose 1 --erase\n", argv);
210	SetCtrlVal(p1,P1_RESPONSE,str);	211	SetCtrlVal(p1,P1_RESPONSE,str);
211	sprintf(str,"Example: %s --address 0x1000000 --verbose 1 --input pts_scaler.bit --load-bit 2\n", argv);	212	sprintf(str,"Example: %s --address 0x1000000 --verbose 1 --input pts_scaler.bit --load-bit 2\n", argv);
212	SetCtrlVal(p1,P1_RESPONSE,str);	213	SetCtrlVal(p1,P1_RESPONSE,str);
213	sprintf(str,"Example: %s --address 0x1000004 --write-csr 0x7600\n", argv);SetCtrlVal(p1,P1_RESPONSE,str);	214	sprintf(str,"Example: %s --address 0x1000004 --write-csr 0x7600\n", argv);SetCtrlVal(p1,P1_RESPONSE,str);
214	}	215	}
215		216
216		217
217		218
218	int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,	219	int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
219	LPSTR lpszCmdLine, int nCmdShow)	220	LPSTR lpszCmdLine, int nCmdShow)
220	{	221	{
221	char saddr[255];	222	char saddr[255];
222	if (InitCVIRTE (hInstance, 0, 0) == 0)	223	if (InitCVIRTE (hInstance, 0, 0) == 0)
223	return -1; /* out of memory */	224	return -1; /* out of memory */
224	if ((p1 = LoadPanel (0, "PtsModule_CVI.uir", P1)) < 0)	225	if ((p1 = LoadPanel (0, "PtsModule_CVI.uir", P1)) < 0)
225	return -1;	226	return -1;
226	DisplayPanel (p1);	227	DisplayPanel (p1);
227		228
228	GetCtrlVal(p1,P1_VERBOSE,&verbose);	229	GetCtrlVal(p1,P1_VERBOSE,&verbose);
229	GetCtrlVal(p1,P1_ADDRESS,saddr);	230	GetCtrlVal(p1,P1_ADDRESS,saddr);
230	ptaddr = strtoul (saddr,NULL,0);	231	ptaddr = strtoul (saddr,NULL,0);
231	RunUserInterface ();	232	RunUserInterface ();
232	DiscardPanel (p1);	233	DiscardPanel (p1);
233	VME_STOP();	234	VME_STOP();
234	return 0;	235	return 0;
235	}	236	}
236		237
237	int CVICALLBACK Reset (int panel, int control, int event,	238	int CVICALLBACK Reset (int panel, int control, int event,
238	void *callbackData, int eventData1, int eventData2)	239	void *callbackData, int eventData1, int eventData2)
239	{	240	{
240	switch (event)	241	switch (event)
241	{	242	{
242	case EVENT_COMMIT:	243	case EVENT_COMMIT:
243	Pts_reset(verbose);	244	Pts_reset(verbose);
244	break;	245	break;
245	}	246	}
246	return 0;	247	return 0;
247	}	248	}
248		249
249	int CVICALLBACK Erase (int panel, int control, int event,	250	int CVICALLBACK Erase (int panel, int control, int event,
250	void *callbackData, int eventData1, int eventData2)	251	void *callbackData, int eventData1, int eventData2)
251	{	252	{
252	switch (event)	253	switch (event)
253	{	254	{
254	case EVENT_COMMIT:	255	case EVENT_COMMIT:
255	Pts_erase(verbose);	256	Pts_erase(verbose);
256	break;	257	break;
257	}	258	}
258	return 0;	259	return 0;
259	}	260	}
260		261
261	int CVICALLBACK Download (int panel, int control, int event,	262	int CVICALLBACK Download (int panel, int control, int event,
262	void *callbackData, int eventData1, int eventData2)	263	void *callbackData, int eventData1, int eventData2)
263	{	264	{
264	char filename[254];	265	char filename[254];
265	int mode=0;	266	int mode=0;
266	switch (event)	267	switch (event)
267	{	268	{
268	case EVENT_COMMIT:	269	case EVENT_COMMIT:
269	GetCtrlVal(p1,P1_FIRMWARE,filename);	270	GetCtrlVal(p1,P1_FIRMWARE,filename);
270	GetCtrlVal(p1,P1_MODE,&mode);	271	GetCtrlVal(p1,P1_MODE,&mode);
271	if(VME_CONNECTED() >=0 ) {	272	if(VME_CONNECTED() >=0 ) {
272	Pts_configure_bit( filename, mode, verbose );	273	Pts_configure_bit( filename, mode, verbose );
273	} else {	274	} else {
274	MessagePopup ("Warning", "Connect VME!!");	275	MessagePopup ("Warning", "Connect VME!!");
275	}	276	}
276	break;	277	break;
277	}	278	}
278	return 0;	279	return 0;
279	}	280	}
280		281
281	int CVICALLBACK Check (int panel, int control, int event,	282	int CVICALLBACK Check (int panel, int control, int event,
282	void *callbackData, int eventData1, int eventData2)	283	void *callbackData, int eventData1, int eventData2)
283	{	284	{
284	switch (event)	285	switch (event)
285	{	286	{
286	case EVENT_COMMIT:	287	case EVENT_COMMIT:
287	Pts_check_configure( verbose );	288	Pts_check_configure( verbose );
288	break;	289	break;
289	}	290	}
290	return 0;	291	return 0;
291	}	292	}
292		293
293	int CVICALLBACK Read (int panel, int control, int event,	294	int CVICALLBACK Read (int panel, int control, int event,
294	void *callbackData, int eventData1, int eventData2)	295	void *callbackData, int eventData1, int eventData2)
295	{	296	{
296	uint32_t value=0;	297	uint32_t value=0;
297	char str[0xFF];	298	char str[0xFF];
298	char saddr[256];	299	char saddr[256];
299	int offset;	300	int offset;
300	switch (event)	301	switch (event)
301	{	302	{
302	case EVENT_COMMIT:	303	case EVENT_COMMIT:
303	GetCtrlVal(p1,P1_OFFSET,saddr);	304	GetCtrlVal(p1,P1_OFFSET,saddr);
304	offset = strtoul (saddr,NULL,0);	305	offset = strtoul (saddr,NULL,0);
305	Pts_read( offset , &value );	306	Pts_read( offset , &value );
306	if( verbose ) {	307	if( verbose ) {
307	sprintf(str, "VME Read addr 0x%0x+0x%0x response 0x%0x\n", ptaddr, offset, value );	308	sprintf(str, "VME Read addr 0x%0x+0x%0x response 0x%0x\n", ptaddr, offset, value );
308	SetCtrlVal (p1, P1_RESPONSE, str);	309	SetCtrlVal (p1, P1_RESPONSE, str);
309	}	310	}
310	break;	311	break;
311	}	312	}
312	return 0;	313	return 0;
313	}	314	}
314		315
315	int CVICALLBACK Write (int panel, int control, int event,	316	int CVICALLBACK Write (int panel, int control, int event,
316	void *callbackData, int eventData1, int eventData2)	317	void *callbackData, int eventData1, int eventData2)
317	{	318	{
318	int value;	319	int value;
319	int offset;	320	int offset;
320	char svalue[256];	321	char svalue[256];
321	char saddr[256];	322	char saddr[256];
322	switch (event)	323	switch (event)
323	{	324	{
324	case EVENT_COMMIT:	325	case EVENT_COMMIT:
325	GetCtrlVal(p1,P1_DATA,svalue);	326	GetCtrlVal(p1,P1_DATA,svalue);
326	GetCtrlVal(p1,P1_OFFSET,saddr);	327	GetCtrlVal(p1,P1_OFFSET,saddr);
327	value = strtoul (svalue,NULL,0);	328	value = strtoul (svalue,NULL,0);
328	offset = strtoul (saddr,NULL,0);	329	offset = strtoul (saddr,NULL,0);
329	Pts_write( offset , value );	330	Pts_write( offset , value );
330	if( verbose ) {	331	if( verbose ) {
331	sprintf(str, "VME Write addr 0x%0x+0x%0x data 0x%0x\n", ptaddr, offset, value );	332	sprintf(str, "VME Write addr 0x%0x+0x%0x data 0x%0x\n", ptaddr, offset, value );
332	SetCtrlVal (p1, P1_RESPONSE, str);	333	SetCtrlVal (p1, P1_RESPONSE, str);
333	}	334	}
334	break;	335	break;
335	}	336	}
336	return 0;	337	return 0;
337	}	338	}
338		339
339	int CVICALLBACK WriteCSR (int panel, int control, int event,	340	int CVICALLBACK WriteCSR (int panel, int control, int event,
340	void *callbackData, int eventData1, int eventData2)	341	void *callbackData, int eventData1, int eventData2)
341	{	342	{
342	int value;	343	int value;
343	char svalue[256];	344	char svalue[256];
344	switch (event)	345	switch (event)
345	{	346	{
346	case EVENT_COMMIT:	347	case EVENT_COMMIT:
347	GetCtrlVal(p1,P1_DATA,svalue);	348	GetCtrlVal(p1,P1_DATA,svalue);
348	value = strtoul (svalue,NULL,0);	349	value = strtoul (svalue,NULL,0);
349	Pts_write_csr( verbose, value );	350	Pts_write_csr( verbose, value );
350	break;	351	break;
351	}	352	}
352	return 0;	353	return 0;
353	}	354	}
354		355
355	int CVICALLBACK Verbose (int panel, int control, int event,	356	int CVICALLBACK Verbose (int panel, int control, int event,
356	void *callbackData, int eventData1, int eventData2)	357	void *callbackData, int eventData1, int eventData2)
357	{	358	{
358	int * data;	359	int * data;
359	switch (event)	360	switch (event)
360	{	361	{
361	case EVENT_COMMIT:	362	case EVENT_COMMIT:
362	GetCtrlVal(panel,control,&verbose);	363	GetCtrlVal(panel,control,&verbose);
363		364
364	break;	365	break;
365	}	366	}
366	return 0;	367	return 0;
367	}	368	}
368		369
369	int CVICALLBACK Help (int panel, int control, int event,	370	int CVICALLBACK Help (int panel, int control, int event,
370	void *callbackData, int eventData1, int eventData2)	371	void *callbackData, int eventData1, int eventData2)
371	{	372	{
372	switch (event)	373	switch (event)
373	{	374	{
374	case EVENT_COMMIT:	375	case EVENT_COMMIT:
375	help("PtsModule");	376	help("PtsModule");
376	break;	377	break;
377	}	378	}
378	return 0;	379	return 0;
379	}	380	}
380		381
381	int CVICALLBACK Address (int panel, int control, int event,	382	int CVICALLBACK Address (int panel, int control, int event,
382	void *callbackData, int eventData1, int eventData2)	383	void *callbackData, int eventData1, int eventData2)
383	{	384	{
384	char saddr[100];	385	char saddr[100];
385	switch (event)	386	switch (event)
386	{	387	{
387	case EVENT_COMMIT:	388	case EVENT_COMMIT:
388	GetCtrlVal(p1,P1_ADDRESS,saddr);	389	GetCtrlVal(p1,P1_ADDRESS,saddr);
389	ptaddr = strtoul (saddr,NULL,0);	390	ptaddr = strtoul (saddr,NULL,0);
390	break;	391	break;
391	}	392	}
392	return 0;	393	return 0;
393	}	394	}
394		395
395	int CVICALLBACK Exit (int panel, int control, int event,	396	int CVICALLBACK Exit (int panel, int control, int event,
396	void *callbackData, int eventData1, int eventData2)	397	void *callbackData, int eventData1, int eventData2)
397	{	398	{
398	switch (event)	399	switch (event)
399	{	400	{
400	case EVENT_COMMIT:	401	case EVENT_COMMIT:
401	QuitUserInterface(0);	402	QuitUserInterface(0);
402	break;	403	break;
403	}	404	}
404	return 0;	405	return 0;
405	}	406	}
406		407
407	int CVICALLBACK FSelect (int panel, int control, int event,	408	int CVICALLBACK FSelect (int panel, int control, int event,
408	void *callbackData, int eventData1, int eventData2)	409	void *callbackData, int eventData1, int eventData2)
409	{	410	{
410	int status;	411	int status;
411	char pathName[MAX_PATHNAME_LEN];	412	char pathName[MAX_PATHNAME_LEN];
412	switch (event)	413	switch (event)
413	{	414	{
414	case EVENT_COMMIT:	415	case EVENT_COMMIT:
415	status = FileSelectPopup ("", ".bit", ".bit", "Select Firmware file",	416	status = FileSelectPopup ("", ".bit", ".bit", "Select Firmware file",
416	VAL_SELECT_BUTTON, 0, 0, 1, 0, pathName);	417	VAL_SELECT_BUTTON, 0, 0, 1, 0, pathName);
417	if (status>0) SetCtrlVal(p1,P1_FIRMWARE,pathName);	418	if (status>0) SetCtrlVal(p1,P1_FIRMWARE,pathName);
418	break;	419	break;
419	}	420	}
420	return 0;	421	return 0;
421	}	422	}
422		423
423	int CVICALLBACK LedCB (int panel, int control, int event,	424	int CVICALLBACK LedCB (int panel, int control, int event,
424	void *callbackData, int eventData1, int eventData2)	425	void *callbackData, int eventData1, int eventData2)
425	{	426	{
426	switch (event)	427	switch (event)
427	{	428	{
428	int value=0;	429	int value=0;
429	case EVENT_COMMIT:	430	case EVENT_COMMIT:
430	GetCtrlVal(p1,P1_LED,&value);	431	GetCtrlVal(p1,P1_LED,&value);
431		432
432	Pts_write( 0 , value+1 );	433	Pts_write( 0 , value+1 );
433		434
434	break;	435	break;
435	}	436	}
436	return 0;	437	return 0;
437	}	438	}
438		439
439	int CVICALLBACK Execute (int panel, int control, int event,	440	int CVICALLBACK Execute (int panel, int control, int event,
440	void *callbackData, int eventData1, int eventData2)	441	void *callbackData, int eventData1, int eventData2)
441	{	442	{
442	switch (event)	443	switch (event)
443	{	444	{
444	case EVENT_COMMIT:{	445	case EVENT_COMMIT:{
445	int n,i,nb;	446	int n,i,nb;
446	char buf[400];	447	char buf[400];
447	unsigned int data, addr;	448	unsigned int data, addr;
448	char sdata[255], saddr[255], rw[255];	449	char sdata[255], saddr[255], rw[255];
449	GetNumTextBoxLines(panel, P1_COMMANDS,&n);	450	GetNumTextBoxLines(panel, P1_COMMANDS,&n);
450	for (i=0;i<n;i++){	451	for (i=0;i<n;i++){
451	GetTextBoxLine(panel, P1_COMMANDS, i, buf);	452	GetTextBoxLine(panel, P1_COMMANDS, i, buf);
452	nb = sscanf(buf,"%s%s%s",rw, saddr,sdata);	453	nb = sscanf(buf,"%s%s%s",rw, saddr,sdata);
453	addr = strtoul (saddr,NULL,0);	454	addr = strtoul (saddr,NULL,0);
454	data = strtoul (sdata,NULL,0);	455	data = strtoul (sdata,NULL,0);
455	if (strstr(rw,"W")!=NULL){	456	if (strstr(rw,"W")!=NULL){
456	Pts_write( addr , data );	457	Pts_write( addr , data );
457	if( verbose ) {	458	if( verbose ) {
458	sprintf(str, "VME Write addr 0x%0x+0x%0x data 0x%0x\n", ptaddr, addr, data );	459	sprintf(str, "VME Write addr 0x%0x+0x%0x data 0x%0x\n", ptaddr, addr, data );
459	SetCtrlVal (p1, P1_RESPONSE, str);	460	SetCtrlVal (p1, P1_RESPONSE, str);
460	}	461	}
461	} else {	462	} else {
462	Pts_read( addr , &data );	463	Pts_read( addr , &data );
463	if( verbose ) {	464	if( verbose ) {
464	sprintf(str, "VME Read addr 0x%0x+0x%0x response 0x%0x\n", ptaddr, addr, data);	465	sprintf(str, "VME Read addr 0x%0x+0x%0x response 0x%0x\n", ptaddr, addr, data);
465	SetCtrlVal (p1, P1_RESPONSE, str);	466	SetCtrlVal (p1, P1_RESPONSE, str);
466	}	467	}
467	}	468	}
468	}	469	}
469	break;	470	break;
470	}	471	}
471	}	472	}
472	return 0;	473	return 0;
473	}	474	}
474		475
475	int CVICALLBACK Connect (int panel, int control, int event,	476	int CVICALLBACK Connect (int panel, int control, int event,
476	void *callbackData, int eventData1, int eventData2)	477	void *callbackData, int eventData1, int eventData2)
477	{	478	{
478	int interface = 0;	479	int interface = 0;
479	switch (event)	480	switch (event)
480	{	481	{
481		482
482	case EVENT_COMMIT:	483	case EVENT_COMMIT:
483	GetCtrlVal (p1, P1_VMEINTERFACE, &interface);	484	GetCtrlVal (p1, P1_VMEINTERFACE, &interface);
484	VME_START(interface);	485	VME_START(interface);
485	break;	486	break;
486	}	487	}
487	return 0;	488	return 0;
488	}	489	}
489		490

Subversion Repositories f9daq

(root)/pts/PtsModule_CVI.c @ 156 – Rev 81 → 83