int main(void) { I16 card, err; BOOLEAN stopped; U32 access_cnt, i; setbuf( stdout, NULL ); clrscr(); printf(" ========================================================================\n"); printf(" == 7300A SAMPLE : DIO simultaneously ==\n"); printf(" ========================================================================\n\n\n"); printf("This sample perform DMA DI in 10MHz and DMA DO in 5MHZ rate simultaneously.\nThe output data is a sine wave. The input data is stored to file '%s'.\n\nPress ENTER to start the operation.\n", file_name ); getchar(); if ((card=Register_Card (PCI_7300A_RevA, 0)) <0 ) { printf("Register_Card error=%d\n", card); exit(1); } err=DI_7300A_Config(card, 16, TRIG_CLK_10MHZ, P7300_WAIT_NO, P7300_TERM_ON, 1, 1, 1); if (err!=0) { printf("DI_7300B_Config error=%d\n", err); exit(1); } err=DO_7300A_Config (card, 16, TRIG_INT_PACER, P7300_WAIT_NO, P7300_TERM_ON, 1); if (err!=0) { printf("DO_7300B_Config error=%d\n", err); exit(1); } for (i=0; i<MAX_SIZE; i++) out_buf[i] = (U16)(sin((double)i/5000*M_PI)*0x7fff)+0x8000; for (i=0; i<MAX_SIZE; i++) in_buf[i] = (U16)(i%65536); err = DO_ContWritePort (card, 0, out_buf, data_size, 3, (F64)5000000, ASYNCH_OP); if (err!=0) { printf("DO_ContWritePort error=%d", err); Release_Card( card ); exit(1); } err = DI_ContReadPort (card, 0, in_buf, data_size, (F64)1, ASYNCH_OP); if (err!=0) { printf("DI_ContReadPort error=%d", err); DO_AsyncClear(card, &access_cnt); Release_Card( card ); } do { DO_AsyncCheck (card, &stopped, &access_cnt); } while (!stopped); DO_AsyncClear (card, &access_cnt); do { DI_AsyncCheck (card, &stopped, &access_cnt); } while (!stopped); DI_AsyncClear (card, &access_cnt); if( write_to_file( in_buf ) ) printf("\n\nThe input data is already stored in file '%s'.\n", file_name); Release_Card(card); printf("\nPress ENTER to exit the program. "); getchar(); return 0; }
int main(void) { I16 err; BOOLEAN bStopped; U32 count, out_count, i; setbuf(stdout, NULL); clrscr(); printf(" ========================================================================\n"); printf(" == 7200 SAMPLE : PCI-7200 HANDSHAKE DMA ==\n"); printf(" ========================================================================\n\n\n"); printf("\nThe output data is a sine wave. The input data is stored to file '%s'.\n\nPress any key to start the operation.\n", file_name ); getch(); if((card = Register_Card(PCI_7200, card_number))<0){ printf("Register_Card Error = %d\n", card); exit(0); } for(i=0; i<40970; i++) DoBuf[i] = (U32)((sin((double)i*M_PI/256)*0x7FFF)+0x8000); pMem = (U32 *)malloc(data_size*sizeof(U32)); if(pMem==NULL){ printf("No Memory\n"); Release_Card(card); exit(0); } memset(pMem, '\0', data_size*sizeof(U32)); if((err = DI_7200_Config(card, TRIG_HANDSHAKE, DI_NOWAITING, DI_TRIG_FALLING, IREQ_FALLING))!=NoError){ printf("DI_Config Error = %d\n", err); Release_Card(card); exit(0); } if((err = DO_7200_Config(card, TRIG_HANDSHAKE, OREQ_ENABLE, OTRIG_LOW))!=NoError){ printf("DO_Config Error = %d\n", err); Release_Card(card); exit(0); } if((err = DI_AsyncDblBufferMode(card, 0))!=NoError){ printf("DI_AsyncDblBufferMode Error = %d\n", err); Release_Card(card); exit(0); } if((err = DO_AsyncDblBufferMode(card, 0))!=NoError){ printf("DI_AsyncDblBufferMode Error = %d\n", err); Release_Card(card); exit(0); } if((err = DI_ContReadPort(card, 0, pMem, data_size, (F64)sample_rate, ASYNCH_OP))!=NoError){ printf("DI_ContReadPort Error = %d\n", err); Release_Card(card); exit(0); } if((err = DO_ContWritePort(card, 0, DoBuf, data_size+2, 1, (F64)sample_rate, ASYNCH_OP))!=NoError){ printf("DO_ContWritePort Error = %d\n", err); Release_Card(card); exit(0); } do{ DI_AsyncCheck(card, &bStopped, &count); }while(!bStopped); DI_AsyncClear(card, &count); DO_AsyncClear(card, &out_count); if(write_to_file(pMem)){ printf(" the digital data is stored in the file : %s , prees any key for exit\n", file_name); getch(); } free(pMem); Release_Card(card); return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U16 ConfigCtrl = P922x_DO_CONVSRC_INT; U16 TrigCtrl = P922x_DO_TRGMOD_POST|P922x_DO_TRGSRC_GPI0|P922x_DO_EnReTigger; U32 ReTrgCnt = 3; U32 DLY1Cnt = 0; //Ignored if delay trigger mode does not be enabled U32 DLY2Cnt = 0; //No used in 922x do BOOLEAN AutoResetBuf = 1; //Auto reset buffer descriptors built in driver U32 W_Buffer[WRITECOUNT]; //Data buffer to be written U32 WriteCount = WRITECOUNT; //Output count U16 BufferId; U16 Port = 0; //Only one DO port U16 Iterations = 1; //922x has no output repeats of digital output F64 SampleRate = SAMPRATE; BOOLEAN Stopped; U32 AccessCnt = 0; U32 vi; for(vi=0; vi<WriteCount; vi++){ W_Buffer[vi] = (U16)(((F32)vi/WriteCount)*65535); } printf("This sample performs continuous DO with %d retrigger \n", ReTrgCnt+1); printf("at %6.2f update rate.\n", SampleRate); printf("Card Number? "); scanf(" %hd", &card_num); card = Register_Card(PCI_9222, card_num); if(card<0){ printf("Register_Card Error: %d\n", card); exit(1); } err = DO_9222_Config(card, ConfigCtrl, TrigCtrl, ReTrgCnt, DLY1Cnt, DLY2Cnt, AutoResetBuf); if(err<0){ printf("DO_9222_Config Error: %d\n", err); Release_Card(card); exit(1); } err = DO_ContBufferSetup(card, W_Buffer, WriteCount, &BufferId); if(err<0){ printf("DO_ContBufferSetup Error: %d\n", err); DO_ContBufferReset(card); Release_Card(card); exit(1); } err = DO_ContWritePort(card, Port, &BufferId, WriteCount, Iterations, SampleRate, ASYNCH_OP); if(err<0){ printf("DO_ContWritePort Error: %d\n", err); DO_ContBufferReset(card); Release_Card(card); exit(1); } printf("\nDO Update is started... Wait %d trigger from GPI0...\n", ReTrgCnt+1); printf("You can press Enter to stop it...\n"); do{ err = DO_AsyncCheck(card, &Stopped, &AccessCnt); if(err<0){ printf("DO_AsyncCheck Error: %d\n", err); DO_ContBufferReset(card); DO_AsyncClear(card, &AccessCnt); Release_Card(card); exit(1); } }while((!kbhit())&&(!Stopped)); DO_AsyncClear(card, &AccessCnt); if(Stopped) printf("\nDO Update Done...\n"); else printf("\nDO Operation had been stopped manually...\n"); if(!AutoResetBuf) DO_ContBufferReset(card); Release_Card(card); printf("\nPress any key to exit...\n"); getch(); return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U16 ConfigCtrl = P922x_AI_SingEnded|P922x_AI_CONVSRC_INT; U16 TrigCtrl = P922x_AI_TRGMOD_POST|P922x_AI_TRGSRC_GPI0|P922x_AI_EnReTigger; U32 ReTriggerCount = 0; /*0: Infinite Trigger if retrigger is enabled*/ BOOLEAN AutoResetBuf = 1; U32 ScanIntrv = 20000*CHANNELCOUNT; /*Scan Rate: P922X_TIMEBASE/20000/4=1K*/ U32 SampIntrv = 20000; /*Sampling Rate: P922X_TIMEBASE/20000=4K*/ U16 RDBuffer0[AI_BUFCNT]; /*data Buffer to be setup*/ U16 RDBuffer1[AI_BUFCNT]; /*data Buffer to be setup*/ U16 BufferId0; U16 BufferId1; U32 AI_ReadCount = AI_ACQCNT; U16 NumChans = CHANNELCOUNT; /*AI Channel Number*/ U16 Chans[CHANNELCOUNT]; /*Array of AI Channels to be read*/ U16 AdRanges[CHANNELCOUNT]; /*Array of AI Ranges*/ BOOLEAN Ready; BOOLEAN StopFlag; U16 RdyTrigCnt; U32 AccessCnt; U8 FileName[] = "ai_data"; U32 UserTrigCount = 0; U32 i, j; /*--------------------------------*/ memset(RDBuffer0, '\0', AI_BUFCNT*sizeof(U16)); memset(RDBuffer1, '\0', AI_BUFCNT*sizeof(U16)); srand(time(NULL)); i = 0; do{ Chans[i] = rand()%32; for(j=0; j<i; j++){ if(Chans[i]==Chans[j]) break; } if(j!=i) continue; if(i%2==0) AdRanges[i] = AD_B_10_V; else AdRanges[i] = AD_B_5_V; i++; }while(i<NumChans); printf("This sample performs continuous AI acquisition from randon %d AI Channels\n", NumChans); printf("with infinite external digital trigger at %6.3lf Hz sampling rate.\n\n", P922X_TIMEBASE/ScanIntrv); /*Open and Initialize Device*/ printf("Card Number? "); scanf(" %hd", &card_num); card = Register_Card(PCI_9223, card_num); if(card<0){ printf("Register_Card Error: %d\n", card); exit(1); } /*Configure AI*/ err = AI_9223_Config(card, ConfigCtrl, TrigCtrl, ReTriggerCount, AutoResetBuf); if(err<0){ printf("AI_9223_Config Error: %d\n", err); Release_Card(card); exit(1); } /*Set Scan and Sampling Rate*/ err = AI_9223_CounterInterval(card, ScanIntrv, SampIntrv); if(err<0){ printf("AI_9223_CounterInterval Error: %d\n", err); Release_Card(card); exit(1); } /*Setup Buffer for AI DMA Transfer*/ err = AI_ContBufferSetup(card, RDBuffer0, AI_BUFCNT, &BufferId0); if(err<0){ printf("AI_ContBufferSetup0 Error: %d\n", err); Release_Card(card); exit(1); } err = AI_ContBufferSetup(card, RDBuffer1, AI_BUFCNT, &BufferId1); if(err<0){ printf("AI_ContBufferSetup1 Error: %d\n", err); AI_ContBufferReset(card); Release_Card(card); exit(1); } /*AI Acquisition Start*/ printf("\nPress any key to start AI operation.\n"); printf("You can press Enter to stop...\n"); getch(); err = AI_ContReadMultiChannelsToFile(card, NumChans, Chans, AdRanges, FileName, AI_ReadCount, 0/*Ignore*/, ASYNCH_OP); if(err<0){ printf("AI_ContReadChannel Error: %d\n", err); AI_ContBufferReset(card); Release_Card(card); exit(1); } do{ /*Check ReTrigger Ready and AI Acquisition End*/ err = AI_AsyncReTrigNextReady(card, &Ready, &StopFlag, &RdyTrigCnt); if(err<0){ printf("AI_AsyncReTrigNextReady Error: %d\n", err); AI_AsyncClear(card, &AccessCnt); AI_ContBufferReset(card); Release_Card(card); exit(1); } if(Ready){ UserTrigCount++; /*Trigger Ready with Next Trigger*/ printf("\nReady: %d, StopFlag: %d, TrigCnt: %d\n", Ready, StopFlag, RdyTrigCnt); if(RdyTrigCnt==0){ printf(" Buffer 0 ready...\n"); printf(" Write %d samples of Buffer0 to %s.dat file...\n", AI_ReadCount, FileName); AI_AsyncDblBufferToFile(card); } else{ printf(" Buffer 1 ready...\n"); printf(" Write %d samples of Buffer1 to %s.dat file...\n", AI_ReadCount, FileName); AI_AsyncDblBufferToFile(card); } } }while((!kbhit())&&(!StopFlag)); /*Clear AI Setting and Get Remaining data*/ err = AI_AsyncClear(card, &AccessCnt); if(err<0){ printf("AI_AsyncClear Error: %d\n", err); AI_AsyncClear(card, &AccessCnt); AI_ContBufferReset(card); Release_Card(card); exit(1); } if(!AutoResetBuf) AI_ContBufferReset(card); Release_Card(card); printf("\nPress any key to exit...\n"); getch(); return 0; }
int main(void) { I16 err; U32 i; U16 BufferId; setbuf( stdout, NULL ); clrscr(); printf(" ========================================================================\n"); printf(" == 7300 SAMPLE : PCI-7300 Multiple Buffered DMA ==\n"); printf(" ========================================================================\n\n\n"); printf(" The output data is a sine wave and store data to file '%s'. It will not stop until you press a key.\n\nPress any key to start the operation.\n", file_name ); getch(); if ((card=Register_Card(PCI_7300A_RevB, card_number)) < 0) { printf("Register_Card error=%d\n", card); exit(1); } if( (fp = fopen( file_name, "w+b" ) ) == NULL ) return -10; for (i=0; i<MAX_SIZE; i++) { in_buf[i] = (U16)(0); in_buf2[i] = (U16)(0); } err=DI_7300B_Config(card, 16, TRIG_CLK_10MHZ, P7300_WAIT_NO, P7300_TERM_ON, 0, 1, 1); if (err !=0) { printf("DI_7300B_Config error=%d\n", err); Release_Card( card ); exit(1); } //setup signal handler DI_EventCallBack (card, 1, DBEvent, signal_handler); DI_EventCallBack (card, 1, DIEnd, signal_handler2); err = DI_ContMultiBufferSetup (card, in_buf, data_size, &BufferId); if (err < 0) { printf("DI_ContMultiBufferSetup Error=%d\n", err); Release_Card( card ); exit(1); } err = DI_ContMultiBufferSetup (card, in_buf2, data_size, &BufferId); if (err < 0) { printf("DI_ContMultiBufferSetup Error=%d\n", err); Release_Card( card ); exit(1); } err = DI_ContMultiBufferStart (card, 0, 1); if (err < 0) { printf("DI_ContMultiBufferStart error=%d", err); DO_AsyncClear(card, &i); Release_Card( card ); exit(1); } printf("\n\nPress any key to stop input operation."); printf("\n\nData count : \n"); getch(); err = DI_AsyncClear(card, &count); if( err != 0 ){ printf("D2K_AI_AsyncClear Failed !!!, Ready to system hang !!!\n" ); getch(); } //for(t=0; t<j; t++) //printf("%d ",viewidx[t]); //printf("\n"); //clear signal handler DI_EventCallBack(card, 0, DBEvent, NULL); DI_EventCallBack(card, 0, DIEnd, NULL); Release_Card(card); fclose(fp); exit(1); }
int main() { I16 card1, card2, err; int i; BOOLEAN bStopped = 0; U32 count1, count2; if((card1=Register_Card(PCI_7300A_RevB, 0))<0){ printf("Register_Card error=%d\n", card1); exit(1); } if((card2=Register_Card(PCI_7300A_RevB, 1))<0){ printf("Register_Card error=%d\n", card2); exit(1); } for(i=0; i<OutCount; i++) DoBuf[i] = i&0x7fff; for(i=0; i<InCount; i++) DiBuf[i] = 0; err = DO_7300B_Config(card1, 16, /*TRIG_CLK_20MHZ*/TRIG_INT_PACER, P7300_WAIT_NO, P7300_TERM_ON, 0, 0x40004000); if(err!=0){ printf("DO_7300B_Config error=%d\n", err); exit(1); } err = DI_7300B_Config(card2, 16, /*TRIG_CLK_10MHZ*/TRIG_INT_PACER, P7300_WAIT_NO, P7300_TERM_ON, 0, 1, 1); if(err!=0){ printf("DI_7300B_Config error=%d\n", err); exit(1); } err = DO_ContWritePort(card1, 0, DoBuf, OutCount, 1, OutCount/*1*//*ignored*/, ASYNCH_OP); if(err!=0){ printf("DO_ContWritePort error=%d", err); exit(1); } err = DI_ContReadPort(card2, 0, DiBuf, InCount, InCount/*1*//*ignored*/, ASYNCH_OP); if (err!=0) { printf("DI_ContReadPort error=%d", err); exit(1); } do{ DO_AsyncCheck(card1, &bStopped, &count1); }while (!bStopped); printf("bStopped: %d, count1: %d\n", bStopped, count1); bStopped = 0; do { DI_AsyncCheck(card2, &bStopped, &count2); } while (!bStopped); printf("bStopped: %d, count2: %d\n", bStopped, count2); for(i=0; i<count2; i++) printf("%#x\t", DiBuf[i]); DO_AsyncClear(card1, &count1); DI_AsyncClear(card2, &count2); Release_Card(card1); Release_Card(card2); return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U16 ConfigCtrl = P922x_AI_SingEnded|P922x_AI_CONVSRC_GPI0; U16 TrigCtrl = 0; /*Dose not support any trigger mode/source in external conversion source mode*/ U32 ReTriggerCount = 0; /*Dose not support any trigger mode/source in external conversion source mode*/ BOOLEAN AutoResetBuf = 1; /*Auto Reset Buffer Descriptor in Driver*/ U16 RDBuffer[AI_COUNT]; U16 BufferId; F64 VBuffer[AI_COUNT]; U32 AI_ReadCount = AI_COUNT; /*AI Read Count*/ U16 Channel = 0; /*AI Channel Number to be read*/ U16 AdRange = AD_B_10_V; /*AI range*/ BOOLEAN Stopped; U32 AccessCnt; FILE *w_file; U8 FileName[] = "ai_data.dat"; U32 i; /*--------------------------------*/ memset(RDBuffer, '\0', AI_COUNT*sizeof(U16)); memset(VBuffer, '\0', AI_COUNT*sizeof(F64)); if(!(w_file=fopen(FileName, "w"))){ printf("file open error...\n"); exit(1); } fprintf(w_file, "Channel %d,\n", Channel); printf("This sample performs continuous AI acquisition from AI Channel %d\n", Channel); printf("with external conversion source (GPI0).\n\n"); /*Open and Initialize Device*/ printf("Card Number? "); scanf(" %hd", &card_num); card = Register_Card(PCI_9223, card_num); if(card<0){ printf("Register_Card Error: %d\n", card); fclose(w_file); exit(1); } /*Configure AI*/ err = AI_9223_Config(card, ConfigCtrl, TrigCtrl, ReTriggerCount, AutoResetBuf); if(err<0){ printf("AI_9223_Config Error: %d\n", err); Release_Card(card); fclose(w_file); exit(1); } /*Disable Double Buffer Mode*/ err = AI_AsyncDblBufferMode(card, 0); if(err<0){ printf("AI_AsyncDblBufferMode Error: %d\n", err); Release_Card(card); fclose(w_file); exit(1); } /*Setup Buffer for AI DMA Transfer*/ err = AI_ContBufferSetup(card, RDBuffer, AI_ReadCount, &BufferId); if(err<0){ printf("AI_ContBufferSetup Error: %d\n", err); Release_Card(card); fclose(w_file); exit(1); } /*AI Acquisition Start*/ printf("\nPress any key to start AI to wait conversion source from GPI0.\n"); printf(" And you can press Enter to stop...\n"); getch(); err = AI_ContReadChannel(card, Channel, AdRange, &BufferId, AI_ReadCount, 0/*Ignore*/, ASYNCH_OP); if(err<0){ printf("AI_ContReadChannel Error: %d\n", err); AI_ContBufferReset(card); Release_Card(card); fclose(w_file); exit(1); } do{ /*Check whether AI Acquisition is done*/ err = AI_AsyncCheck(card, &Stopped, &AccessCnt); if(err<0){ printf("AI_AsyncCheck Error: %d\n", err); AI_AsyncClear(card, &AccessCnt); AI_ContBufferReset(card); Release_Card(card); fclose(w_file); exit(1); } }while((!kbhit())&&(!Stopped)); /*Clear AI Setting and Get Remaining data*/ err = AI_AsyncClear(card, &AccessCnt); if(err<0){ printf("AI_AsyncClear Error: %d\n", err); AI_AsyncClear(card, &AccessCnt); AI_ContBufferReset(card); Release_Card(card); fclose(w_file); exit(1); } if(Stopped){ printf("\n\nAI Acquisition Done... Acquired %d samples...\n", AccessCnt); printf("Write %d samples of Buffer to %s file...\n", AccessCnt, FileName); AI_ContVScale(card, AdRange, RDBuffer, VBuffer, AccessCnt); for(i=0; i<AccessCnt; i++){ fprintf(w_file, "%f,\n", VBuffer[i]); } } else{ printf("\nAI Acquisition has been stopped manually... Acquired %d samples...\n", AccessCnt); printf("Write %d samples of Buffer to %s file...\n", AccessCnt, FileName); AI_ContVScale(card, AdRange, RDBuffer, VBuffer, AccessCnt); for(i=0; i<AccessCnt; i++){ fprintf(w_file, "%f,\n", VBuffer[i]); } } if(!AutoResetBuf) AI_ContBufferReset(card); Release_Card(card); fclose(w_file); printf("\nPress any key to exit...\n"); getch(); return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U16 ConfigCtrl = P922x_AI_SingEnded|P922x_AI_CONVSRC_INT; U16 TrigCtrl = P922x_AI_TRGMOD_GATED|P922x_AI_TRGSRC_GPI0|P922x_AI_TrgPositive; U32 ReTriggerCount = 0; /*Ignore if trigger mode is gated trigger*/ BOOLEAN AutoResetBuf = 1; /*Autoreset buffer descriptor build in driver*/ U32 ScanIntrv = 320; /*Scan rate: P922X_TIMEBASE/320=250K*/ U32 SampIntrv = 320; /*Sampling rate: P922X_TIMEBASE/320=250K*/ U32 RDBuffer[READCOUNT]; /*4 Bytes per a sample if trigger mode is Gated Trigger*/ U16 BufferId; F64 VBuffer[READCOUNT]; U32 AI_ReadCount = READCOUNT; /*AI read count*/ U16 Channel = 0; /*AI channel to be read*/ U16 AdRange = AD_B_10_V; /*AI range*/ BOOLEAN Stopped = FALSE; U32 AccessCnt = 0; FILE *w_file; U8 FileName[] = "ai_data.dat"; U32 i; memset(RDBuffer, '\0', READCOUNT*sizeof(U32)); memset(VBuffer, '\0', READCOUNT*sizeof(F64)); if(!(w_file=fopen(FileName, "w"))){ printf("file open error...\n"); exit(1); } fprintf(w_file, "Channel %d,\n", Channel); printf("This sample performs continuous AI acquisition with Gated trigger\n"); printf("from AI Channel %d at %6.3lf Hz sampling rate.\n", Channel, P922X_TIMEBASE/SampIntrv); /*Open and Initialize Devie*/ printf("Card Number? "); scanf(" %hd", &card_num); card = Register_Card(PCI_9222, card_num); if(card<0){ printf("Register_Card Error: %d\n", card); fclose(w_file); exit(1); } /*Configure AI configurations*/ err = AI_9222_Config(card, ConfigCtrl, TrigCtrl, ReTriggerCount, AutoResetBuf); if(err<0){ printf("AI_9222_Config Error: %d\n", err); Release_Card(card); fclose(w_file); exit(1); } /*Set Counter Scan and Sample Interval*/ err = AI_9222_CounterInterval(card, ScanIntrv, SampIntrv); if(err<0){ printf("AI_9222_CounterInterval Error: %d\n", err); Release_Card(card); fclose(w_file); exit(1); } /*Disable Double Buffer Mode*/ err = AI_AsyncDblBufferMode(card, 0); if(err<0){ printf("AI_AsyncDblBufferMode Error: %d\n", err); Release_Card(card); fclose(w_file); exit(1); } /*Buffer Setup - Build Buffer Descriptor in Driver*/ err = AI_ContBufferSetup(card, RDBuffer, AI_ReadCount, &BufferId); if(err<0){ printf("AI_ContBufferSetup Error: %d\n", err); Release_Card(card); fclose(w_file); exit(1); } /*Start AI Acquisition*/ err = AI_ContReadChannel(card, Channel, AdRange, &BufferId, AI_ReadCount, 0/*Ignore*/, ASYNCH_OP); if(err<0){ printf("AI_ContReadChannel Error: %d\n", err); AI_ContBufferReset(card); Release_Card(card); fclose(w_file); exit(1); } printf("\nWait Gated Positive Trigger from GPI0...\n"); do{ err = AI_AsyncCheck(card, &Stopped, &AccessCnt); if(err<0){ printf("AI_AsyncCheck Error: %d\n", err); AI_AsyncClear(card, &AccessCnt); AI_ContBufferReset(card); Release_Card(card); fclose(w_file); exit(1); } }while((!kbhit())&&(!Stopped)); err = AI_AsyncClear(card, &AccessCnt); if(err<0){ printf("AI_AsyncClear Error: %d\n", err); AI_AsyncClear(card, &AccessCnt); AI_ContBufferReset(card); Release_Card(card); fclose(w_file); exit(1); } if(Stopped) printf("\n\nAI Acquisition done...\n"); else printf("\n\nAI Acquisition has been stopped manually...\n"); printf("Write %d samples of Buffer to %s file...\n\n", AccessCnt, FileName); fprintf(w_file, "Raw Data, Scaled Voltage,\n"); AI_ContVScale(card, AdRange, RDBuffer, VBuffer, AccessCnt); for(i=0; i<AccessCnt; i++){ fprintf(w_file, "0x%x, %6.4f,\n", RDBuffer[i], VBuffer[i]); } if(!AutoResetBuf) AI_ContBufferReset(card); Release_Card(card); fclose(w_file); printf("\nPress any key to exit...\n"); getch(); return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U16 ConfigCtrl = P922x_AO_CONVSRC_INT; U16 TrigCtrl = P922x_AO_TRGMOD_DELAY|P922x_AO_TRGSRC_GPI0|P922x_AO_EnReTigger|P922x_AO_EnDelay2; U32 ReTrgCnt = 0; //0 means infinite trigger if retrigger is enabled U32 DLY1Cnt = 80000000; //Trigger delay count; Delay time = DLY1Cnt/TIMEBASE sec. U32 DLY2Cnt = 40000000; //Wave separation count; Delay time = DLY2Cnt/TIMEBASE sec. BOOLEAN AutoResetBuf = 1; //Auto reset buffer descriptor built in kernel U32 W_Buffer[WRITECOUNT]; //Data buffer to be written U32 WriteCount = WRITECOUNT; //Wrtie count per one wave/one trigger U16 BufferId; U16 Channel = 0; //AO channel to be written U32 Iterations = 4; //Wave iterations per one trigger U32 CHUI = UPDATEINTRV; U16 definite = 1; U32 vi; U32 AccessCnt; BOOLEAN Stopped; for(vi=0; vi<WriteCount; vi++){ W_Buffer[vi] = (U16)((sin((double)vi/WriteCount*2*PI)*0x7fff)+0x8000); } printf("This sample performs continuous AO update to Channel %d \n", Channel); printf("at %6.2f update rate with infinit trigger.\n", (F32)TIMEBASE/UPDATEINTRV); printf("Card Number? "); scanf(" %hd", &card_num); /*Open and initialize device*/ card = Register_Card(PCI_9223, card_num); if(card<0){ printf("Register_Card Error: %d\n", card); exit(1); } /*Configure AO*/ err = AO_9223_Config(card, ConfigCtrl, TrigCtrl, ReTrgCnt, DLY1Cnt, DLY2Cnt, AutoResetBuf); if(err<0){ printf("AO_9223_Config Error: %d\n", err); Release_Card(card); exit(1); } /*Disable double-buffer mode*/ err = AO_AsyncDblBufferMode(card, 0); if(err<0){ printf("AO_AsyncDblBufferMode Error: %d\n", err); Release_Card(card); exit(1); } /*Setup memory descriptor for DMA transfer*/ err = AO_ContBufferSetup(card, W_Buffer, WriteCount, &BufferId); if(err<0){ printf("AO_ContBufferSetup Error: %d\n", err); AO_ContBufferReset(card); Release_Card(card); exit(1); } /*Start AO operation*/ err = AO_ContWriteChannel(card, Channel, BufferId, WriteCount, Iterations, CHUI, definite, ASYNCH_OP); if(err<0){ printf("AO_ContWriteChannel Error: %d\n", err); AO_ContBufferReset(card); Release_Card(card); exit(1); } printf("\n\nWait infinite digital trigger from GPI0...\n"); printf("You can press Enter to stop AO update...\n"); do{ err = AO_AsyncCheck(card, &Stopped, &AccessCnt); if(err<0){ printf("AO_AsyncCheck Error: %d\n", err); AO_ContBufferReset(card); Release_Card(card); exit(1); } }while(!kbhit()); AO_AsyncClear(card, &AccessCnt, 0); printf("\nAO had been stopped...\n"); if(!AutoResetBuf) AO_ContBufferReset(card); Release_Card(card); printf("Press any key to exit...\n"); getch(); return 0; }
int main(void) { I16 err; U32 i; pthread_t thread1; void * retval; U16 BufferId; setbuf( stdout, NULL ); clrscr(); printf(" ========================================================================\n"); printf(" == 7300 SAMPLE : PCI-7300 Multiple Buffered DMA ==\n"); printf(" ========================================================================\n\n\n"); printf(" The output data is a sine wave and store data to file '%s'. It will not stop until you press a key.\n\nPress any key to start the operation.\n", file_name ); getch(); if ((card=Register_Card(PCI_7300A_RevB, card_number)) < 0) { printf("Register_Card error=%d\n", card); exit(1); } for (i=0; i<102400; i++) DoBuf[i] = (U16)/*(sin((double)i*M_PI/512)*0x7fffffff)+0x80000000*/(i%65536); for (i=0; i<MAX_SIZE; i++) { in_buf[i] = (U16)(0); in_buf2[i] = (U16)(0); in_buf3[i] = (U16)(0); in_buf4[i] = (U16)(0); } //pMem = (U32 *)malloc( data_size *sizeof(U32) ); err=DI_7300B_Config(card, 16, TRIG_CLK_10MHZ, P7300_WAIT_NO, P7300_TERM_ON, 0, 1, 1); if (err !=0) { printf("DI_7300B_Config error=%d\n", err); Release_Card( card ); exit(1); } err=DO_7300B_Config (card, 16, TRIG_INT_PACER, P7300_WAIT_NO, P7300_TERM_ON, 0, 0x00040004); if (err !=0) { printf("DO_7300B_Config error=%d\n", err); Release_Card( card ); exit(1); } err = DI_ContMultiBufferSetup (card, in_buf, data_size, &BufferId); if (err < 0) { printf("DI_ContMultiBufferSetup Error=%d\n", err); Release_Card( card ); exit(1); } err = DI_ContMultiBufferSetup (card, in_buf2, data_size, &BufferId); if (err < 0) { printf("DI_ContMultiBufferSetup Error=%d\n", err); Release_Card( card ); exit(1); } err = DI_ContMultiBufferSetup (card, in_buf3, data_size, &BufferId); if (err < 0) { printf("DI_ContMultiBufferSetup Error=%d\n", err); Release_Card( card ); exit(1); } err = DI_ContMultiBufferSetup (card, in_buf4, data_size, &BufferId); if (err < 0) { printf("DI_ContMultiBufferSetup Error=%d\n", err); Release_Card( card ); exit(1); } clear_op = FALSE; if( pthread_create( &thread1, NULL, ProcessThread, NULL ) != 0 ){ printf(" Can't create thread1 , terminate \n "); Release_Card(card); exit(-1); } if ((err=DO_ContWritePort(card, 0, DoBuf, 10240, 0, (F64)sample_rate, ASYNCH_OP)) != NoError) { printf("DO_ContWritePort error=%d", err); Release_Card( card ); exit(1); } err = DI_ContMultiBufferStart (card, 0, 1); if (err < 0) { printf("DI_ContMultiBufferStart error=%d", err); DO_AsyncClear(card, &i); Release_Card( card ); exit(1); } /*clear_op = FALSE; if( pthread_create( &thread1, NULL, ProcessThread, NULL ) != 0 ){ printf(" Can't create thread1 , terminate \n "); Release_Card(card); exit(-1); } */ getch(); clear_op = TRUE; pthread_join(thread1, &retval); Release_Card(card); //free( pMem ); exit(1); }
int main( void ) { I16 card = -1, card_number = 0; U32 input, out_value = 0; if((card = Register_Card(PCI_7249, card_number))<0){ printf("Can't open device file: PCI7249\n"); exit(-1); } printf("open device file successfully!!\n"); DIO_PortConfig(card,Channel_P1A, INPUT_PORT); DIO_PortConfig(card,Channel_P2A, OUTPUT_PORT); DIO_PortConfig(card,Channel_P1B, INPUT_PORT); DIO_PortConfig(card,Channel_P2B, OUTPUT_PORT); DIO_PortConfig(card,Channel_P1C, INPUT_PORT); DIO_PortConfig(card,Channel_P2C, OUTPUT_PORT); clrscr(); printf("PCI-7249 DIO Sample :\n\n"); printf("-------------------------------------------------\n"); printf(" P1A, p1B, P1C are configured as input port.\n"); printf(" P2A, p2B, P2C are configured as output port.\n"); printf("-------------------------------------------------\n"); printf(" Press any key to continue...\n"); do { clrscr(); printf("PCI-7249 DIO Sample :\n\n"); printf("-------------------------------------------------\n"); printf(" P1A, p1B, P1C are configured as input port.\n"); printf(" P2A, p2B, P2C are configured as output port.\n\n"); DO_WritePort(card, Channel_P2A, out_value); printf(" P2A output = 0x%x\n", (U16)out_value); DI_ReadPort(card, Channel_P1A, &input); printf(" P1A input = 0x%x\n", (U16)input); DI_ReadPort(card, Channel_P1AE, &input); printf(" P1AE input = 0x%x\n", (U16)input); DI_ReadPort(card, Channel_P2AE, &input); printf(" P1AE input = 0x%x\n", (U16)input); DO_WritePort(card, Channel_P2B, out_value); printf(" P2B output = 0x%x\n", (U16)out_value); DI_ReadPort(card, Channel_P1B, &input); printf(" P1B input = 0x%x\n", (U16)input); DI_ReadPort(card, Channel_P1BE, &input); printf(" P1BE input = 0x%x\n", (U16)input); DI_ReadPort(card, Channel_P2BE, &input); printf(" P2BE input = 0x%x\n", (U16)input); DO_WritePort(card, Channel_P2C, out_value); printf(" P2C output = 0x%x\n", (U16)out_value); DI_ReadPort(card, Channel_P1C, &input); printf(" P1C input = 0x%x\n", (U16)input); DI_ReadPort(card, Channel_P1CE, &input); printf(" P1CE input = 0x%x\n", (U16)input); DI_ReadPort(card, Channel_P1CE, &input); printf(" P2CE input = 0x%x\n", (U16)input); printf("-------------------------------------------------\n"); printf(" Press Enter to stop...\n"); //usleep(100000); out_value = (out_value+1)%256; }while(!kbhit()); if(card>=0){ Release_Card(card); } return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U16 GCtr; U16 Mode = x4_AB_Phase_Encoder; U16 SrcCtrl = 0; //Not used in encoder U16 PolCtrl = 0; //Not used in encoder U32 LReg1_Val = 0; //Not used in encoder U32 LReg2_Val = 0; //Not used in encoder U32 RD_Value; int i = 0; printf("This sample performs x4 AB phase mode.\n"); printf("Card Number? "); scanf(" %hd", &card_num); card = Register_Card(PCI_9222, card_num); if(card<0){ printf("Register_Card Error: %d\n", card); exit(1); } printf("Encoder Number? "); scanf(" %hd", &GCtr); GCtr = (GCtr==1)? P922x_ENCODER1:P922x_ENCODER0; /*Clear Encoder*/ err = GPTC_Clear(card, GCtr); if(err<0){ printf("GPTC_Clear Error: %d\n", err); goto ERR_RET; } /*Setup Encoder*/ err = GPTC_Setup(card, GCtr, Mode, SrcCtrl, PolCtrl, LReg1_Val, LReg2_Val); if(err<0){ printf("GPTC_Setup Error: %d\n", err); goto ERR_RET; } /*Enable Encoder*/ printf("Press any key to enable counter...\n"); getch(); err = GPTC_Control(card, GCtr, IntENABLE, 1); if(err<0){ printf("GPTC_Control(IntENABLE) Error: %d\n", err); goto ERR_RET; } do{ /*Read Encoder*/ err = GPTC_Read(card, GCtr, &RD_Value); if(err<0){ printf("GPTC_Read Error: %d\n", err); goto ERR_RET2; } clrscr(); printf("/*---------------------------------*/\n"); printf(" Encoder Number: %d\n", GCtr-4); printf(" Read Count: %d\n\n", RD_Value); printf(" You can press Enter to stop...\n"); printf("/*---------------------------------*/\n"); usleep(1000); }while(!kbhit()); ERR_RET2: GPTC_Control(card, GCtr, IntENABLE, 0); ERR_RET: GPTC_Clear(card, GCtr); Release_Card(card); printf("\nPress any key to exit...\n"); getch(); return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U32 DI_Value0; U32 DI_Value1; U32 DO_Value = 0; U32 DO_Read0; U32 DO_Read1; printf("This sample perform DIO with polling mode.\n"); printf("Port A/C are configured as DO ports\n"); printf("while port B/D are configured as DI ones.\n"); printf("You can connect port A-C, and B-D to test this sample.\n\n"); printf("Card Number? "); scanf(" %hd", &card_num); /* * Open and Initialize Device */ card = Register_Card(PCI_7350, card_num); if(card<0){ printf("Register_Card Error: %d\n", card); exit(1); } /* * Configure 7350 DIO Port Direction (Input or Output) */ err = DIO_PortConfig(card, P7350_DIO_A, OUTPUT_PORT); if(err<0){ printf("DIO_PortConfig Port_A Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, 1, INPUT_PORT); if(err<0){ printf("DIO_PortConfig Port_B Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, P7350_DIO_C, OUTPUT_PORT); if(err<0){ printf("DIO_PortConfig Port_C Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, P7350_DIO_D, INPUT_PORT); if(err<0){ printf("DIO_PortConfig Port_D Error: %d\n", err); Release_Card(card); exit(1); } /* * Configure DIO Voltage Level */ err = DIO_VoltLevelConfig(card, P7350_PortDIO, VoltLevel_3R3); if(err<0){ printf("DIO_7350_SetVoltLevel Error: %d\n", err); Release_Card(card); exit(1); } else { printf("DIO_7350_SetVoltLevel ok!"); } /* * Read/Write Control */ do{ clrscr(); /*Write Port A*/ err = DO_WritePort(card, P7350_DIO_A, DO_Value); if(err<0){ printf("DO_WritePort Port A Error: %d\n", err); Release_Card(card); exit(1); } /*Write Port C*/ err = DO_WritePort(card, P7350_DIO_C, 255-DO_Value); if(err<0){ printf("DO_WritePort Port C Error: %d\n", err); Release_Card(card); exit(1); } usleep(1000); /*Read Port B*/ err = DI_ReadPort(card, P7350_DIO_B, &DI_Value0); if(err<0){ printf("DI_ReadPort Port B Error: %d\n", err); Release_Card(card); exit(1); } /*Read Port D*/ err = DI_ReadPort(card, P7350_DIO_D, &DI_Value1); if(err<0){ printf("DI_ReadPort Port D Error: %d\n", err); Release_Card(card); exit(1); } /*Read Back Port A*/ err = DO_ReadPort(card, P7350_DIO_A, &DO_Read0); if(err<0){ printf("DO_ReadPort Port A Error: %d\n", err); Release_Card(card); exit(1); } /*Read Back Port C*/ err = DO_ReadPort(card, P7350_DIO_C, &DO_Read1); if(err<0){ printf("DO_ReadPort Port C Error: %d\n", err); Release_Card(card); exit(1); } printf("-----------------------------------------\n"); printf(" DO Write Port Port A Port C\n"); printf(" DO Write Data 0x%lx 0x%lx\n\n", DO_Value, 255-DO_Value); printf(" DO Read Port Port A Port C\n"); printf(" DO Read Data 0x%lx 0x%lx\n\n", DO_Read0, DO_Read1); printf(" DI Read Port Port B Port D\n"); printf(" DI Read Data 0x%lx 0x%lx\n\n", DI_Value0, DI_Value1); printf(" Press Enter to stop...\n"); printf("-----------------------------------------\n"); if(++DO_Value==256) DO_Value = 0; usleep(1000); }while(!kbhit()); printf("Press any key to exit...\n"); getch(); Release_Card(card); return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U16 ConfigCtrl = P6202_DA_WRSRC_Int; U16 TrigCtrl = P6202_DA_TRGSRC_SOFT; BOOLEAN AutoResetBuf = FALSE; U32 Buffer_0[WriteCount]; U32 Buffer_1[WriteCount]; U16 BufferId_0; U16 BufferId_1; int i, j; BOOLEAN Stopped = FALSE; U32 AccessCnt = 0; printf("\nThis sample performs AO in channel 0\n"); printf("Please input a card number: "); scanf(" %hd", &card_num); for(i=0; i<WriteCount; i++){ Buffer_0[i] = i*65535/WriteCount; Buffer_1[i] = 65535-Buffer_0[i]; } if((card = Register_Card(PCI_6202, card_num))<0){ printf("Register_Card %d error: %d", card_num, card); exit(-1); } err = AO_6202_Config(card, ConfigCtrl, TrigCtrl, 1, 0, 0, AutoResetBuf); if(err<0){ printf("AO_6202_Config error: %d\n", err); Release_Card(card); exit(1); } err = AO_AsyncDblBufferMode(card, TRUE); if(err<0){ printf("AO_AsyncDblBufferMode error: %d\n", err); Release_Card(card); exit(-1); } err = AO_ContBufferSetup(card, Buffer_0, WriteCount, &BufferId_0); if(err<0){ printf("AO_ContBufferSetup1 error: %d\n", err); Release_Card(card); exit(-1); } err = AO_ContBufferSetup(card, Buffer_1, WriteCount, &BufferId_1); if(err<0){ printf("AO_ContBufferSetup2 error: %d\n", err); if(!AutoResetBuf) AO_ContBufferReset(card); Release_Card(card); exit(-1); } printf("\nPress any key to start.\n"); getch(); err = AO_ContWriteChannel(card, 0, BufferId_0, WriteCount, 1, SampIntrv, 1, ASYNCH_OP); if(err<0){ printf("AO_ContWriteChannel error! err _code = %d\n", err); if(!AutoResetBuf) AO_ContBufferReset(card); Release_Card(card); exit(-1); } printf("\nPress any key to stop.\n"); getch(); err = AO_AsyncClear(card, &AccessCnt, 0); if(err<0){ printf("AO_AsyncClear Error: %d\n", err); } if(!AutoResetBuf){ err = AO_ContBufferReset(card); if(err<0){ printf("AO_ContBufferReset error: %d\n", err); } } Release_Card(card); printf("\nPress any key to exit...\n"); getch(); return 0; }
static long dsetInit_devAoSyncAdlink (aoRecord *pao) { CONTEXT *p_myContext; ADLINKDEV_AO *p_myAnalogOutput; int myPinNumber; int myCardIdentifier; double myMinimumVoltage; double myMaximumVoltage; int i; int myMinorNumber; packageInfo(); dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, pao->name ); p_myAnalogOutput=(ADLINKDEV_AO *)calloc(1, sizeof(ADLINKDEV_AO)); /** * Get the card and pin numbers. */ if (sscanf(pao->out.value.instio.string, "ci=%d pn=%d", &myCardIdentifier, &myPinNumber) != 2) { dsetLog(1, __FILE__ "[%d] Error: %s\n", __LINE__, pao->name); dsetLog(1, __FILE__ "[%d] Error: Couldn't parse parameters\n", __LINE__); dsetLog(1, __FILE__ "[%d] Error: >%s<\n", __LINE__,pao->out.value.instio.string); sleep(SLEEPTIME_ERROR); return(ERROR); } myMinorNumber=myCardIdentifier-1; /** * Set the device filename. */ sprintf(p_myAnalogOutput->p_deviceFilename,"/dev/PCI6208W%d", (myMinorNumber)); /** * Initialize the DAQ 6208 card. */ if ((p_myAnalogOutput->cardHandle = Register_Card(PCI_6208V, myMinorNumber)) < NoError) { dsetLog(1, __FILE__ "[%d] Error: %s\n", __LINE__, pao->name); dsetLog(1, __FILE__ "[%d] Error: Failed to register with the card\n", __LINE__); sleep(SLEEPTIME_ERROR); return(ERROR); } /** * Convert the pin number to the appropriate channel number. */ for (i = 0; i < MAX_NUM_CHANNELS; i++) { if (pinToChannels[i] == myPinNumber) { p_myAnalogOutput->channel=i; } } /** * Set the voltage values. */ myMinimumVoltage=pao->drvl; myMaximumVoltage=pao->drvh; p_myAnalogOutput->range=getOptimalOperatingRange(pao); dsetLog(5,__FILE__ "[%d] Parsed options >%s<\n", __LINE__, pao->out.value.instio.string); dsetLog(5,__FILE__ "[%d] p_deviceFilename = >%s<\n", __LINE__, p_myAnalogOutput->p_deviceFilename); dsetLog(5,__FILE__ "[%d] channel = %d\n", __LINE__, p_myAnalogOutput->channel); dsetLog(5,__FILE__ "[%d] range = %d\n", __LINE__, p_myAnalogOutput->range); p_myContext=(CONTEXT *)calloc(1,sizeof(CONTEXT)); p_myContext->p_analogOutput=p_myAnalogOutput; p_myContext->minimumVoltage=myMinimumVoltage; p_myContext->maximumVoltage=myMaximumVoltage; /** * Load the channel value from the file. */ readChannelValueFromFile(pao); pao->pini=menuYesNoYES; pao->dpvt=(void *)p_myContext; dsetLog(5, __FILE__ "[%d] Calibration algo : %d\n", __LINE__, pao->linr); dsetLog(5, __FILE__ "[%d] Calibration slope : %lg\n", __LINE__, pao->aslo); dsetLog(5, __FILE__ "[%d] Calibration offset: %lg\n", __LINE__, pao->aoff); dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__ ); /* Convert according to calibration? NO!*/ /* Convert update val based on rval and in iwarmstart file is stored val*/ return(DO_NOT_CONVERT); }
int main(int argc, char **argv) { U16 card_num; I16 card, err; U16 Group; U16 XMode = P9524_AI_XFER_POLL; U16 ConfigCtrl; U16 PollChannel; U16 PollRange; U16 PollSpeed = P9524_ADC_60_SPS; F64 voltage; U32 Value; F64 ActualRate; printf("This sample performs AI Polling operation.\n"); printf("Card Number? "); scanf(" %hd", &card_num); /*Open and initialize device*/ card = Register_Card(PCI_9524, card_num); if(card<0){ printf("Register Card Failed: %d\n", card); exit(1); } printf("Load Cell Channel[0] or General Purpose Channel[1]? [0]or[1] "); scanf(" %hd", &Group); if(Group==0){ /*Load Cell AI*/ ConfigCtrl = P9524_VEX_Range_10V|P9524_VEX_Sence_Remote|P9524_AI_AZMode; PollChannel = P9524_AI_LC_CH0; PollRange = 0; } else if(Group==1){ /*General Purpose AI*/ ConfigCtrl = 0; PollChannel = P9524_AI_GP_CH0; PollRange = AD_B_10_V; } else{ printf("invalid group\n"); Release_Card(card); exit(1); } if(Group==0){ /*Load Cell AI need extra DSP configuration*/ U16 DFStage = 2; U32 SPKRejThreshold = 16; err = AI_9524_SetDSP(card, PollChannel, P9524_SPIKE_REJ_ENABLE, DFStage, SPKRejThreshold); if(err<0){ printf("AI_9524_SetDSP Error: %d\n", err); Release_Card(card); exit(1); } } /*Configure AI*/ err = AI_9524_Config(card, Group, XMode, ConfigCtrl, 0, 0); if(err<0){ printf("AI_9524_Config Error: %d\n", err); Release_Card(card); exit(1); } /*Configure AI polling mode*/ err = AI_9524_PollConfig(card, Group, PollChannel, PollRange, PollSpeed); if(err<0){ printf("AI_9524_PollConfig Error: %d\n", err); Release_Card(card); exit(1); } err = GetActualRate_9524(card, Group, PollSpeed, &ActualRate); if(err<0) printf("GetActualRate_9524 Error: %d\n", err); printf("\nADC started at speed: %7.2lf SPS\n", ActualRate); printf("Press any key to start read AI channel...\n"); getch(); do{ usleep(100000); err = AI_ReadChannel32(card, PollChannel, PollRange, &Value); if(err<0){ printf("AI_ReadChannel32 Error: %d\n", err); Release_Card(card); exit(1); } AI_VoltScale32(card, PollRange, Value, &voltage); /*You can also replace AI_ReadChannel32() and AI_VoltScale32() by AI_VReadChannel()*/ /*err = AI_VReadChannel(card, PollChannel, PollRange, &voltage);*/ clrscr(); printf("/*---------------------------------*/\n"); printf("Group %d - Channel 0\n\n", Group); printf("raw data: 0x%x\n", Value); printf("scaled voltage: %lf\n\n", voltage); printf(" press Enter to exit...\n"); printf("/*---------------------------------*/\n"); }while(!kbhit()); printf("Press any key to exit...\n"); getch(); Release_Card(card); return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U16 DIPortWidth = 32; //Port Width U16 DIMode = P7350_FreeRun; //DI Mode U16 DIWaitStatus = P7350_WAIT_NO; //No Wait Trigger U16 DIClkConfig = P7350_IntSampledCLK; //Internal Conversion Clock U32 *Buffer[MBufCount]; //Buffer to be written U16 BufferID[MBufCount]; //Buffer ID returned U32 ReadCount = 10000; //Data Count to be read F64 SampleRate = 10000000; //Sampling Rate U32 vi, vj; BOOLEAN NextReady = FALSE; U16 ReadyBufferId = 0; U32 AccessCnt; U32 BufRdyCnt = 0; U32 OverrunCnt = 0; U16 PreDIReadyBufferId = 0; U16 bufcnt = 0; U16 overrunFlag; printf("This sample performs infinitely continuous DI acquisition to DIO port A/B/C/D\n"); printf("with %lf sample rate.\n\n", SampleRate); printf("Card Number? "); scanf(" %hd", &card_num); /* * Open and initialize PCIe-7350 */ card = Register_Card(PCI_7350, card_num); if(card<0){ printf("Register_Card Error: %d\n", card); exit(1); } /* * Set Voltage Level for DIO Port */ err = DIO_VoltLevelConfig(card, P7350_PortDIO, VoltLevel_3R3); if(err!=NoError){ printf("DIO_VoltLevelConfig Error: %d\n", err); Release_Card(card); exit(1); } /* * Set Input or Output for DIO Port */ err = DIO_PortConfig(card, P7350_DIO_A, INPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, P7350_DIO_B, INPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, P7350_DIO_C, INPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, P7350_DIO_D, INPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } /* * Set DI Configurations */ err = DI_7350_Config(card, DIPortWidth, DIMode, DIWaitStatus, DIClkConfig); if(err!=NoError){ printf("DI_7350_Config Error: %d\n", err); Release_Card(card); exit(1); } /* * Allocate multiple buffers to be written - * Note: PCIe-7350 DMA engine only supports 8-bytes data and address alignment. * That means - * 1. the bytes count of the totally transffed data is the times of 8. * 2. the lowest 3 bits of the buffer address is 0. * * Allocate page-aligned memory to meet 8-bytes alignment */ for(vi=0; vi<MBufCount; vi++){ //Buffer[vi] = (U32 *)VirtualAlloc(NULL, ReadCount*(DIPortWidth/8), MEM_COMMIT, PAGE_READWRITE); //memset(Buffer[vi], '\0', ReadCount*(DIPortWidth/8)); Buffer[vi] = (U32 *)calloc(ReadCount, (DIPortWidth/8)); } /* * Setup the allocated buffers - * Driver will build the memory descriptor for the specifed buffer * to do DMA operation. */ for(vi=0; vi<MBufCount; vi++){ err = DI_ContMultiBufferSetup(card, Buffer[vi], ReadCount, &BufferID[vi]); if(err!=NoError){ printf("DI_ContMultiBufferSetup %ld Error: %d\n", vi, err); Release_Card(card); for(vj=0; vj<MBufCount; vj++) //VirtualFree(Buffer[vj], 0, MEM_RELEASE); free(Buffer[vj]); exit(1); } } /* * Perform Continuous DI - * The buffers set by DI_ContMultiBufferSetup() will be chained to be * a ring buffer for DMA engine to infinitely continuous write data * to the set buffers. Please refer Chapter 5.2 of PCIS-DASK User * Manual for details. */ printf("Press any key to start infinitely continuous DI operation.\n"); printf("You can press Enter to stop it.\n"); getch(); printf("\n"); err = DI_ContMultiBufferStart(card, 0, SampleRate); if(err!=NoError){ printf("DI_ContMultiBufferStart Error: %d\n", err); Release_Card(card); for(vi=0; vi<MBufCount; vi++) //VirtualFree(Buffer[vi], 0, MEM_RELEASE); free(Buffer[vi]); exit(1); } do{ err = DI_AsyncMultiBufferNextReady(card, &NextReady, &ReadyBufferId); if(err!=NoError){ printf("DI_AsyncMultiBufferNextReady Error: %d\n", err); } if(NextReady){ /* * If the NextReady flag is asserted, the data of ready buffers * had been read completely. You can process the data of ready * buffers if necessary. * * Process the data of the ready buffers in here */ /* * Tell driver that the ready buffers are handled completely */ if(ReadyBufferId<PreDIReadyBufferId){ bufcnt = MBufCount-PreDIReadyBufferId+ReadyBufferId+1; err = DI_AsyncMultiBuffersHandled( card, (U16)(MBufCount-PreDIReadyBufferId), &BufferID[PreDIReadyBufferId] ); if(err!=NoError) printf("DI_AsyncMultiBuffersHandled1 Error: %d\n", err); err = DI_AsyncMultiBuffersHandled( card, (U16)(ReadyBufferId+1), &BufferID[0] ); if(err!=NoError) printf("DI_AsyncMultiBuffersHandled2 Error: %d\n", err); } else{ bufcnt = ReadyBufferId-PreDIReadyBufferId+1; err = DI_AsyncMultiBuffersHandled( card, bufcnt, &BufferID[PreDIReadyBufferId] ); if(err!=NoError) printf("DI_AsyncMultiBuffersHandled Error: %d\n", err); } /* * Check whether the DI is overrun */ err = DI_AsyncDblBufferOverrun(card, 0, &overrunFlag); if(err!=NoError){ printf("DI_AsyncDblBufferOverrun Error: %d\n", err); } if(overrunFlag){ //printf("DI Over Run...\n"); OverrunCnt++; DI_AsyncDblBufferOverrun(card, 1, &overrunFlag); } PreDIReadyBufferId = ReadyBufferId+1; BufRdyCnt++; printf("Buffer Ready Count: %ld, Overrun Count: %ld\r", BufRdyCnt, OverrunCnt); } }while(!kbhit()); DI_AsyncClear(card, &AccessCnt); printf("DI Operation Done...\n"); printf("Press any key to exit...\n"); getch(); Release_Card(card); for(vi=0; vi<MBufCount; vi++) //VirtualFree(Buffer[vi], 0, MEM_RELEASE); free(Buffer[vi]); return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U16 ConfigCtrl = P922x_AO_CONVSRC_INT; U16 TrigCtrl = P922x_AO_TRGMOD_POST|P922x_AO_TRGSRC_SOFT; U32 ReTrgCnt = 0; //Ignored in non-retrigger mode U32 DLY1Cnt = 0; //Ignored in non-delay trigger mode U32 DLY2Cnt = 0; //Ignored in non-delay trigger mode BOOLEAN AutoResetBuf = 1; U32 W_Buffer[WRITECOUNT]; U32 Patten[WRITECOUNT]; U32 WriteCount = WRITECOUNT; U16 BufferId; U16 Channel = 0; U32 Iterations = 1; U32 CHUI = UPDATEINTRV; U16 definite = 1; U32 vi; U32 TimeOut_ms = AO_SYNCTIMEOUT; for(vi=0; vi<WriteCount; vi++){ Patten[vi] = (U16)((sin((double)vi/WriteCount*2*PI)*0x7fff)+0x8000); } memcpy(W_Buffer, Patten, WriteCount*sizeof(U32)); printf("This sample updates voltage to AO Channel 0\n"); printf("at %6.2f update rate.\n", (float)TIMEBASE/UPDATEINTRV); printf("Card Number? "); scanf(" %hd", &card_num); /*Open and initialize device*/ card = Register_Card(PCI_9223, card_num); if(card<0){ printf("Register_Card Error: %d\n", card); exit(1); } /*Configure 9223 AO*/ err = AO_9223_Config(card, ConfigCtrl, TrigCtrl, ReTrgCnt, DLY1Cnt, DLY2Cnt, AutoResetBuf); if(err<0){ printf("AO_9223_Config Error: %d\n", err); Release_Card(card); exit(1); } /*Set Timeout Period for AO Sync Mode*/ err = AO_SetTimeOut(card, TimeOut_ms); if(err<0){ printf("AO_SetTimeOut Error: %d\n", err); Release_Card(card); exit(1); } /*Disable Double Buffer Mode*/ err = AO_AsyncDblBufferMode(card, 0); if(err<0){ printf("AO_AsyncDblBufferMode Error: %d\n", err); Release_Card(card); exit(1); } /*Setup buffer*/ err = AO_ContBufferSetup(card, W_Buffer, WriteCount, &BufferId); if(err<0){ printf("AO_ContBufferSetup0 Error: %d\n", err); AO_ContBufferReset(card); Release_Card(card); exit(1); } /*Start AO*/ err = AO_ContWriteChannel(card, Channel, BufferId, WriteCount, Iterations, CHUI, definite, SYNCH_OP); if(err<0){ printf("AO_ContWriteChannel Error: %d\n", err); AO_ContBufferReset(card); Release_Card(card); exit(1); } printf("\n\nAO Update Done...\n"); if(!AutoResetBuf) AO_ContBufferReset(card); Release_Card(card); printf("Press any key to exit...\n"); getch(); return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U16 GCtr; U16 Mode; U16 SrcCtrl = 0; U16 PolCtrl = 0; U32 LReg1_Val = 0; U32 LReg2_Val = 0; U32 GPTC_Val; U16 STAT; int i = 0; U16 MajorSelMode; U16 MinorSelMode; printf("This sample performs GPTC operations.\n"); printf("Card Number? "); scanf(" %hd", &card_num); card = Register_Card(PCI_9222, card_num); if(card<0) { printf("Register_Card Error: %d\n", card); exit(1); } printf("GPTC Number? [0~3] "); scanf(" %hd", &GCtr); if(GCtr>3) { printf("Invalid counter number, set to GPTC 0...\n"); printf("Press any key to continue...\n"); getch(); GCtr = 0; } /*Clear GPTC*/ err = GPTC_Clear(card, GCtr); if(err<0) { printf("GPTC_Clear Error: %d\n", err); goto ERR_RET; } clrscr(); printf(" \n"); printf(" (0) Simple Gated Event Count Mode.\n"); printf(" (1) Pulse Measurement Mode.\n"); printf(" (2) Single Pulse Generation Mode.\n"); printf(" (3) Pulse Train Generation Mode.\n\n"); printf(" Which GPTC mode to be performed? [0~3] "); scanf(" %hd", &MajorSelMode); if(MajorSelMode>3) { printf(" Invalid Mode. set to Simple Gated Event Count Mode.\n"); printf(" Press any key to continue...\n"); getch(); MajorSelMode = 0; } clrscr(); switch(MajorSelMode) { case 0: Mode = SimpleGatedEventCNT; SrcCtrl = GPTC_GATE_SRC_Ext; LReg1_Val = 0x7fffffff; //Initial value /*Setup GPTC*/ err = GPTC_Setup(card, GCtr, Mode, SrcCtrl, PolCtrl, LReg1_Val, LReg2_Val); if(err<0) { printf("GPTC_Setup Error: %d\n", err); goto ERR_RET; } /*Internal Control UpDown Source - 0: DownCount; 1: UpCount*/ err = GPTC_Control(card, GCtr, IntUpDnCTR, 0); if(err<0) { printf("GPTC_Control(IntUpDnCTR) Error: %d\n", err); goto ERR_RET; } /*Enable Counter*/ err = GPTC_Control(card, GCtr, IntENABLE, 1); if(err<0) { printf("GPTC_Control(IntENABLE) Error: %d\n", err); goto ERR_RET; } printf(" GPTC will count down from %d while GPTC/GATED pin is high...\n", LReg1_Val); do { err = GPTC_Read(card, GCtr, &GPTC_Val); clrscr(); printf("/*---------------------------------*/\n"); printf(" GPTC Number: %d\n", GCtr); printf(" Read Count: %d\n\n", GPTC_Val); printf(" You can press Enter to stop...\n"); printf("/*---------------------------------*/\n"); usleep(1000); } while(!kbhit()); break; case 1: printf(" \n"); printf(" (0) Pulse Period Measurement.\n"); printf(" - Measure pulse period of a pulse from GPTC/GTAED pin.\n\n"); printf(" (1) Pulse Width Measurement.\n"); printf(" - Measure pulse width of a pulse from GPTC/GTAED pin.\n\n"); printf(" (2) Pulse Edge Separation Measurement.\n"); printf(" - Measure edge separation between pulses from GPTC/GTAED and GPTC/AUX pin.\n\n"); printf(" Which pulse measurement mode to be performed? [0~2] "); scanf(" %hd", &MinorSelMode); if(MinorSelMode>2) { printf(" Invalid Mode. set to Pulse Period Measurement.\n"); printf(" Press any key to continue...\n"); getch(); MinorSelMode = 0; } if(MinorSelMode==0) Mode = SinglePeriodMSR; else if(MinorSelMode==1) Mode = SinglePulseWidthMSR; else Mode = EdgeSeparationMSR; SrcCtrl = GPTC_GATE_SRC_Ext; //Set External gate for measuring a pulse from GATED pin /*Setup GPTC*/ err = GPTC_Setup(card, GCtr, Mode, SrcCtrl, PolCtrl, LReg1_Val, LReg2_Val); if(err<0) { printf("GPTC_Setup Error: %d\n", err); goto ERR_RET; } /*Internal Control UpDown Source*/ //Set Counter count up err = GPTC_Control(card, GCtr, IntUpDnCTR, 1); if(err<0) { printf("GPTC_Control(IntUpDnCTR) Error: %d\n", err); goto ERR_RET; } /*Enable Counter*/ err = GPTC_Control(card, GCtr, IntENABLE, 1); if(err<0) { printf("GPTC_Control(IntENABLE) Error: %d\n", err); goto ERR_RET; } /*wait GPTC done status*/ clrscr(); printf(" Pulse measuring... You can press Enter to stop it...\n"); do { GPTC_Status(card, GCtr, &STAT); } while((!((STAT>>1)&0x01))&&(!kbhit())); if((STAT>>1)&0x01) { /*Read GPTC value*/ GPTC_Read(card, GCtr, &GPTC_Val); printf("\n GPTC%d Value: %x\n", GCtr, GPTC_Val); if(MinorSelMode==0) printf(" Pulse Period: %lf sec.\n", (F32)GPTC_Val/TIMEBASE); else if(MinorSelMode==1) printf(" Pulse Width: %lf sec.\n", (F32)GPTC_Val/TIMEBASE); else printf(" Pulse Edge Separation: %lf sec.\n", (F32)GPTC_Val/TIMEBASE); } else { printf("\n Pulse measurement is stopped manually...\n"); } break; case 2: printf(" \n"); printf(" (0) Single Gated Pulse Generation.\n"); printf(" - Generate pulse to GPTC out pin while GATED pin is high.\n\n"); printf(" (1) Single Pulse Generation with trigger.\n"); printf(" - Generate pulse to GPTC out pin if trigger is comming from GATED pin.\n\n"); printf(" (2) Single Pulse Generation with Re-trigger.\n"); printf(" - Generate pulse to GPTC out pin if a trigger is comming from GATED pin.\n\n"); printf(" Which pulse generation mode to be performed? [0~2] "); scanf(" %hd", &MinorSelMode); if(MinorSelMode>2) { printf(" Invalid Mode. set to Single Pulse Generation.\n"); printf(" Press any key to continue...\n"); getch(); MinorSelMode = 0; } if(MinorSelMode==0) { Mode = SingleGatedPulseGen; SrcCtrl = GPTC_GATE_SRC_Ext; } else if(MinorSelMode==1) { Mode = SingleTrigPulseGen; SrcCtrl = GPTC_GATE_SRC_Ext; } else { Mode = RetrigSinglePulseGen; SrcCtrl = GPTC_GATE_SRC_Ext; } LReg1_Val = 40000000; /*Setup GPTC*/ err = GPTC_Setup(card, GCtr, Mode, SrcCtrl, PolCtrl, LReg1_Val, LReg2_Val); if(err<0) { printf("GPTC_Setup Error: %d\n", err); goto ERR_RET; } /*Enable Counter*/ clrscr(); printf(" Press any key to enable counter...\n"); getch(); err = GPTC_Control(card, GCtr, IntENABLE, 1); if(err<0) { printf("GPTC_Control(IntENABLE) Error: %d\n", err); goto ERR_RET; } if(MinorSelMode==0) { printf("\n A %f sec. period pulse will be generated while GATED is high...\n", (F32)(LReg1_Val+LReg1_Val)/TIMEBASE); } else if(MinorSelMode==1) { printf("\n Wait trigger to generate a %f sec. period pulse...\n", (F32)(LReg1_Val+LReg1_Val)/TIMEBASE); } else { printf("\n Wait retrigger to generate a %f sec. period pulse...\n", (F32)(LReg1_Val+LReg1_Val)/TIMEBASE); } printf(" Press any key to stop...\n"); getch(); break; case 3: printf(" \n"); printf(" (0) Continuous Pulse Train Generation with Gated.\n"); printf(" - Generate pulse train to GPTC/OUT pin while GATED\n"); printf(" pin is high.\n\n"); printf(" (1) Continuous Pulse Train Generation with trigger.\n"); printf(" - Generate pulse train to GPTC/OUT pin if trigger is comming\n"); printf(" from GPTC/GATED pin.\n\n"); printf(" (2) Continuous PWM Pulse Train Generation.\n"); printf(" - Generate PWM pulse train to GPTC/OUT pin while GATED\n"); printf(" pin is high.\n\n"); printf(" (3) Continuous PWM Pulse Train Generation with trigger.\n"); printf(" - Generate PWM pulse train to GPTC/OUT pin if trigger is comming\n"); printf(" from GPTC/GATED pin.\n\n"); printf(" Which pulse generation mode to be performed? [0~3] "); scanf(" %hd", &MinorSelMode); if(MinorSelMode>3) { printf(" Invalid Mode. set to Continuous Pulse Train Generation.\n"); printf(" Press any key to continue...\n"); getch(); MinorSelMode = 0; } if(MinorSelMode==0) { Mode = ContGatedPulseGen; SrcCtrl = GPTC_GATE_SRC_Ext; LReg1_Val = 40000000; } else if(MinorSelMode==1) { Mode = SingleTrigContPulseGen; SrcCtrl = GPTC_GATE_SRC_Ext; LReg1_Val = 40000000; } else if(MinorSelMode==2) { Mode = ContGatedPulseGenPWM; SrcCtrl = GPTC_GATE_SRC_Ext; LReg1_Val = 20000000; LReg2_Val = 60000000; } else { Mode = SingleTrigContPulseGenPWM; SrcCtrl = GPTC_GATE_SRC_Ext; LReg1_Val = 20000000; LReg2_Val = 60000000; } /*Setup GPTC*/ err = GPTC_Setup(card, GCtr, Mode, SrcCtrl, PolCtrl, LReg1_Val, LReg2_Val); if(err<0) { printf("GPTC_Setup Error: %d\n", err); goto ERR_RET; } /*Enable Counter*/ clrscr(); printf(" Press any key to enable counter...\n"); getch(); err = GPTC_Control(card, GCtr, IntENABLE, 1); if(err<0) { printf("GPTC_Control(IntENABLE) Error: %d\n", err); goto ERR_RET; } if(MinorSelMode==0) { F32 OutRate = (F32)TIMEBASE/(LReg1_Val+LReg1_Val); printf("\n Out rate: %f Hz, pulse train will be generated while GATED pin is high...\n", OutRate); } else if(MinorSelMode==1) { F32 OutRate = (F32)TIMEBASE/(LReg1_Val+LReg1_Val); printf("\n Wait trigger to generate, out rate: %f Hz, pulse train...\n", OutRate); } else if(MinorSelMode==2) { F32 Duty = (F32)LReg2_Val/(LReg1_Val+LReg2_Val); F32 OutRate = (F32)TIMEBASE/(LReg1_Val+LReg2_Val); printf("\n Out rate: %f Hz, duty cycle: %4.2f %%, pulse train will be generated while GATED pin is high...\n", OutRate, Duty); } else { F32 Duty = (F32)LReg2_Val/(LReg1_Val+LReg2_Val); F32 OutRate = (F32)TIMEBASE/(LReg1_Val+LReg2_Val); printf("\n Wait trigger to generate, out rate: %f Hz, duty cycle: %4.2f %%, pulse train...\n", OutRate, Duty); } printf("\n Press any key to stop...\n"); getch(); break; }
int main(void) { I16 card, err; BOOLEAN bStopped; U32 count, i; setbuf( stdout, NULL ); clrscr(); printf(" ========================================================================\n"); printf(" == 7300B SAMPLE : PATTERN GENERATION ==\n"); printf(" ========================================================================\n\n\n"); printf("This sample perform DMA DI in 10MHz and DMA DO in 5MHZ rate simultaneously.\nThe output data is a sine wave with PATTERN GENERATION. The input data is stored in the file '%s'.\n\nPress ENTER to start the operation.\n", file_name); getchar(); if ((card=Register_Card (PCI_7300A_RevB, 0)) <0 ) { printf("Register_Card error=%d\n", card); exit(1); } err=DI_7300B_Config(card, 16, TRIG_CLK_10MHZ, P7300_WAIT_NO, P7300_TERM_ON, 0, 0, 1); if (err !=0) { printf("DI_7300B_Config error=%d\n", err); Release_Card( card ); exit(1); } err=DO_7300B_Config (card, 16, TRIG_INT_PACER, P7300_WAIT_NO, P7300_TERM_ON, 0, 0x40004000); if (err !=0) { printf("DO_7300B_Config error=%d\n", err); Release_Card( card ); exit(1); } for (i=0; i<10000; i++) out_buf[i] =(U16)/*(sin((double)i/5000*M_PI)*0x7fff)+0x8000*/(i%65536); for (i=0; i<MAX_SIZE; i++) in_buf[i] = (U16)(i%65536); //start pattern generation DO_PGStart (card, out_buf, 10000, (F64)5000000); err = DI_ContReadPort (card, 0, in_buf, data_size, (F64)1, ASYNCH_OP); if (err < 0) { printf("DI_ContReadPort error=%d", err); DO_PGStop (card); Release_Card( card ); exit(1); } do { DI_AsyncCheck (card, &bStopped, &count); } while (!bStopped); DI_AsyncClear (card, &count); if( write_to_file( in_buf ) ) printf("\n\nThe input data is already stored in file '%s'.\n", file_name); DO_PGStop (card); Release_Card(card); printf("\nPress ENTER to exit the program. "); getchar(); return 0; }
int main(void) { int i, k = 0, err; setbuf(stdout, NULL); printf("PCI-7296 Dual Interrupt Sample\n"); printf("This program demostrates how to use dual interrupt line.\n"); printf("The IRQ source of INT1 is P1C0. The IRQ source of INT2 is internal Timer Output\n"); printf("Using cable to connect CN1 and CN2\n\n"); int_count = int2_count = 0; if((card = Register_Card(PCI_7296, 0))<0){ printf("Can't open device file: PCI7296\n"); exit(-1); } CTR_Setup(card, 1, RATE_GENERATOR, 0, BIN); CTR_Setup(card, 2, RATE_GENERATOR, 0, BIN); usleep(1000); //initialize the input/output array for(i=0; i<total_count; i++){ buffer[i] = k; k++; if(k>255) k = 0; } for(i=0; i<total_count; i++) in_buffer[i]=0; // configure the port err = DIO_PortConfig(card,Channel_P1A, INPUT_PORT); if(err!=NoError){ goto exit_after_error; } err = DIO_PortConfig(card,Channel_P3A, OUTPUT_PORT); if(err!=NoError){ goto exit_after_error; } err = DIO_PortConfig(card,Channel_P1C, INPUT_PORT); if(err!=NoError){ goto exit_after_error; } err = DIO_PortConfig(card,Channel_P3C, OUTPUT_PORT); if(err!=NoError){ goto exit_after_error; } err = DIO_SetDualInterrupt(card, INT1_FP1C0, INT2_TIMER_COUNTER, sig_handler1, sig_handler2); if(err!=NoError){ printf(" error from DIO_SetDualInterrupt : %d \n" , err ); goto exit_after_error; } //setup the Timer clock err = CTR_Setup(card, 1, 2, c1, BIN); if(err!=NoError){ printf(" error from CTR_Setup : %d \n" , err ); goto end_of_proc; } err = CTR_Setup(card, 2, 2, c2, BIN); if(err!=NoError){ printf(" error from CTR_Setup : %d \n" , err ); goto end_of_proc; } printf("** The INT2 Singal will be sent back in %4.2f secs , or you can press ENTER for exit **\n", (c2*total_count)/(2000000.0/c1)); getchar(); if(int2_count<total_count){ CTR_Setup(card, 1, RATE_GENERATOR, 0, BIN); CTR_Setup(card, 2, RATE_GENERATOR, 0, BIN); goto end_of_proc; } else{ //display the data for(i=0; i<total_count; i++){ printf(" %d, ",in_buffer[i]); if((i+1)%10==0) putchar('\n'); } } end_of_proc: DIO_SetDualInterrupt(card, INT1_DISABLE, INT2_DISABLE, NULL, NULL); exit_after_error: if(card>=0) Release_Card(card); exit(0); }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U16 DOPortWidth = 16; //Port Width U16 DOMode = P7350_BurstHandShake; //DO Mode U16 DOWaitStatus = P7350_WAIT_SOFTTRG; //Wait Soft Trigger U16 DOClkConfig = P7350_IntSampledCLK|P7350_EnExpSampledCLK; //Internal Conversion Clock U16 DIPortWidth = 16; //Port Width U16 DIMode = P7350_BurstHandShake; //DI Mode U16 DIWaitStatus = P7350_WAIT_EXTTRG; //Wait External Trigger U16 DIClkConfig = P7350_ExtSampledCLK; //External Conversion Clock U16 DOTrigConfig = P7350_EnSoftTrigOut; //Enable Software Trigger Out U16 DO_REQSrc = P7350_AFI_2; //DO REQ Source U16 DO_ACKSrc = P7350_AFI_4; //DO ACK Source U16 DOSoftTrigOutSrc = P7350_AFI_0; //Software Trigger Out Source U32 DOSoftTrigOutLength = 10; //Software Trigger Out Length U32 DOTrigCount = 1; //Software Trigger Supports only 1 Trigger U16 DI_REQSrc = P7350_AFI_3; //DI REQ Source U16 DI_ACKSrc = P7350_AFI_5; //DI ACK Source U16 DI_TRIGSrc = P7350_AFI_1; //DI TRIG Source U32 DITrigCount = 1; //Software Trigger Supports only 1 Trigger U16 DICLK_Src = P7350_AFI_7; U16 DICLK_DDAMode = /*P7350_EnDDA|P7350_DDA_Lead*/0; U16 DICLK_DPAMode = /*P7350_DDA_1R04NS*/0; U16 DICLK_DDAVlaue = /*P7350_EnDPA*/0; U16 DICLK_DPAVlaue = /*P7350_DPA_180DG*/0; U16 o_DOCLK_Src = P7350_AFI_6; U16 o_DOCLK_DPAMode = P7350_EnDPA; U16 o_DOCLK_DPAVlaue = P7350_DPA_0DG; U16 *DOBuffer; //Buffer to be written U16 *DIBuffer; //Buffer to be read F64 DOSampleRate = 50000000; //DO Update Rate U32 WriteCount = 65536; //Data Count to be written U32 ReadCount = 65536; //Data Count to be read U32 vi; BOOLEAN DIStopped = 0; U32 DIAccessCnt = 0; BOOLEAN DOStopped = 0; U32 DOAccessCnt = 0; FILE *fout; char fwrt; printf("The sample performs DIO Burst Handshake operation.\n"); printf("DIO port A/C are configured as the DO port and\n"); printf("DIO port B/D are configured as the DI port.\n"); printf("AFI2 and AFI4 are set to be as DO_REQ and DO_ACK\n"); printf("while AFI3 and AFI5 are set to be as DI_REQ and DI_ACK.\n"); printf("DO is set to enable software trigger out (AFI0) to\n"); printf("be as the DI_TRIG source (AFI1).\n"); printf("And the DO sampled clock is set to be exported (AFI6)\n"); printf("and as the DI external sampled clock (AFI7).\n"); printf("Please connect AFI0 <---> AFI1\n"); printf(" AFI2 <---> AFI3\n"); printf(" AFI4 <---> AFI5\n"); printf(" AFI6 <---> AFI7\n"); printf(" PortA <---> PortB\n"); printf(" PortC <---> PortD\n"); printf("\nCard Number? "); scanf(" %hd", &card_num); /* * Open and initialize PCIe-7350 */ card = Register_Card(PCI_7350, 0); if(card<0){ printf("Register_Card Error: %d\n", card); exit(1); } /* * Set Voltage Level for DIO Port */ err = DIO_VoltLevelConfig(card, P7350_PortDIO, VoltLevel_3R3); if(err!=NoError){ printf("DIO_VoltLevelConfig Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_VoltLevelConfig(card, P7350_PortAFI, VoltLevel_3R3); if(err!=NoError){ printf("DIO_VoltLevelConfig Error: %d\n", err); Release_Card(card); exit(1); } /* * Set Input or Output for DIO Port */ err = DIO_PortConfig(card, P7350_DIO_A, OUTPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, P7350_DIO_B, INPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, P7350_DIO_C, OUTPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, P7350_DIO_D, INPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } /* * Set DO Configurations */ err = DO_7350_Config(card, DOPortWidth, DOMode, DOWaitStatus, DOClkConfig); if(err!=NoError){ printf("DO_7350_Config Error: %d\n", err); Release_Card(card); exit(1); } /* * Set DI Configurations */ err = DI_7350_Config(card, DIPortWidth, DIMode, DIWaitStatus, DIClkConfig); if(err!=NoError){ printf("DI_7350_Config Error: %d\n", err); Release_Card(card); exit(1); } /* * Set DO Trigger and HandShake Configurations */ err = DO_7350_TrigHSConfig( card, DOTrigConfig, 0/*DO_IPOL*/, DO_REQSrc, DO_ACKSrc, 0/*DO_TRIGSrc*/, 0/*StartTrigSrc*/, 0/*PauseTrigSrc*/, DOSoftTrigOutSrc, DOSoftTrigOutLength, DOTrigCount ); if(err!=NoError){ printf("DO_7350_TrigHSConfig Error: %d\n", err); Release_Card(card); exit(1); } /* * Set DI Trigger and HandShake Configurations */ err = DI_7350_TrigHSConfig( card, 0/*TrigConfig*/, 0/*DI_IPOL*/, DI_REQSrc, DI_ACKSrc, DI_TRIGSrc, 0/*DIStartTrigSrc*/, 0/*PauseTrigSrc*/, 0/*SoftTrigOutSrc*/, 0/*SoftTrigOutLength*/, DITrigCount ); if(err!=NoError){ printf("DI_7350_TrigHSConfig Error: %d\n", err); Release_Card(card); exit(1); } /* * Set DI Sampled Clock */ err = DI_7350_ExtSampCLKConfig( card, DICLK_Src, DICLK_DDAMode, DICLK_DPAMode, DICLK_DDAVlaue, DICLK_DPAVlaue ); if(err!=NoError){ printf("DI_7350_ExtSampCLKConfig Error: %d\n", err); Release_Card(card); exit(1); } /* * Set DO Export Clock */ err = DO_7350_ExportSampCLKConfig( card, o_DOCLK_Src, o_DOCLK_DPAMode, o_DOCLK_DPAVlaue ); if(err!=NoError){ printf("DO_7350_ExportSampCLKConfig Error: %d\n", err); Release_Card(card); exit(1); } /* * allocate buffer to be read/written - * Note: PCIe-7350 DMA engine only supports 8-bytes data and address alignment. * That means - * 1. the bytes count of the totally transffed data is the times of 8. * 2. the lowest 3 bits of the buffer address is 0. */ /*allocate page-aligned memory to meet 8-bytes alignment*/ //DOBuffer = (U16 *)VirtualAlloc(NULL, WriteCount*(DOPortWidth/8), MEM_COMMIT, PAGE_READWRITE); DOBuffer = (U16 *)calloc(WriteCount, (DOPortWidth/8)); for(vi=0; vi<WriteCount; vi++){ *(DOBuffer+vi) = (U16)(vi%65536); } //DIBuffer = (U16 *)VirtualAlloc(NULL, ReadCount*(DIPortWidth/8), MEM_COMMIT, PAGE_READWRITE); //memset(DIBuffer, '\0', ReadCount*(DIPortWidth/8)); DIBuffer = (U16 *)calloc(ReadCount, (DIPortWidth/8)); /* * Perform Continuous DI * Note: If the data count is too large, driver may spend some time * to lock memory to avoid memory page-out. */ err = DI_ContReadPort(card, 0, (void *)DIBuffer, ReadCount, 0/*Ignore*/, ASYNCH_OP); if(err!=NoError){ printf("DI_ContReadPort Error: %d\n", err); Release_Card(card); //VirtualFree(DOBuffer, 0, MEM_RELEASE); //VirtualFree(DIBuffer, 0, MEM_RELEASE); free(DOBuffer); free(DIBuffer); exit(1); } /* * Perform Continuous DO * Note: If the data count is too large, driver may spend some time * to lock memory to avoid memory page-out. */ err = DO_ContWritePort(card, 0, (void *)DOBuffer, WriteCount, 1, DOSampleRate, ASYNCH_OP); if(err!=NoError){ printf("DO_ContWritePort Error: %d\n", err); Release_Card(card); //VirtualFree(DOBuffer, 0, MEM_RELEASE); //VirtualFree(DIBuffer, 0, MEM_RELEASE); free(DOBuffer); free(DIBuffer); exit(1); } /* * Set Soft Trigger */ printf("Press any key to generate DO soft trigger...\n\n"); getch(); err = DO_7350_SoftTriggerGen(card); if(err!=NoError){ printf("DO_7350_SoftTriggerGen Error: %d\n", err); DI_AsyncClear(card, &DIAccessCnt); DO_AsyncClear(card, &DOAccessCnt); Release_Card(card); //VirtualFree(DOBuffer, 0, MEM_RELEASE); //VirtualFree(DIBuffer, 0, MEM_RELEASE); free(DOBuffer); free(DIBuffer); exit(1); } do{ err = DO_AsyncCheck(card, &DOStopped, &DOAccessCnt); if(err!=NoError){ printf("DO_AsyncCheck Error: %d\n", err); } }while((!kbhit())&&(!DOStopped)); DO_AsyncClear(card, &DOAccessCnt); printf("DO Operation Done...\n\n"); do{ err = DI_AsyncCheck(card, &DIStopped, &DIAccessCnt); if(err!=NoError){ printf("DI_AsyncCheck Error: %d\n", err); } }while((!kbhit())&&(!DIStopped)); DI_AsyncClear(card, &DIAccessCnt); printf("DI Operation Done...\n\n"); printf("Write Data to file? [Y]es or [N]o \n\n"); scanf(" %c", &fwrt); if((fwrt=='Y')||(fwrt=='y')){ printf("\n\nWrite Data..."); if((fout = fopen("di_read.txt", "w"))==NULL) printf("fopen error\n"); else{ for(vi=0; vi<ReadCount; vi++){ fprintf(fout, "%d\n", *(DIBuffer+vi)); } fclose(fout); } printf("\rWrite Data Done...\n\n"); } printf("Press any key to exit...\n"); getch(); Release_Card(card); //VirtualFree(DOBuffer, 0, MEM_RELEASE); //VirtualFree(DIBuffer, 0, MEM_RELEASE); free(DOBuffer); free(DIBuffer); return 0; }
int main(int argc, char **argv) { I16 card, err; I16 card_num; U16 DOPortWidth = 32; //Port Width U16 DOMode = P7350_FreeRun; //DO Mode U16 DOWaitStatus = P7350_WAIT_SOFTTRG; //Software Trigger U16 DOClkConfig = P7350_IntSampledCLK; //Internal Sampled Clock U16 TrigConfig = P7350_EnSoftTrigOut; //Enable Software Trigger Out U16 SoftTrigOutSrc = P7350_AFI_0; //Software Trigger Out Source U32 SoftTrigOutLength = 10; //Software Trigger Out Length U32 TrigCount = 1; //Software Trigger Supports only 1 Trigger U32 *Buffer; //Buffer to be written U32 WriteCount = 65536; //Data Count to be written F64 SampleRate = 50000000; //Update Rate U32 vi; BOOLEAN Stopped = 0; U32 AccessCnt = 0; printf("This sample performs continuous DO Update\n"); printf("with %lf sample rate.\n\n", SampleRate); printf("Card Number? "); scanf(" %hd", &card_num); /* * Open and initialize PCIe-7350 */ card = Register_Card(PCI_7350, card_num); if(card<0){ printf("Register_Card Error: %d\n", card); exit(1); } /* * Set Voltage Level for DIO Port */ err = DIO_VoltLevelConfig(card, P7350_PortDIO, VoltLevel_3R3); if(err!=NoError){ printf("DIO_VoltLevelConfig Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_VoltLevelConfig(card, P7350_PortAFI, VoltLevel_3R3); if(err!=NoError){ printf("DIO_VoltLevelConfig Error: %d\n", err); Release_Card(card); exit(1); } /* * Set Input or Output for DIO Port */ err = DIO_PortConfig(card, P7350_DIO_A, OUTPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, P7350_DIO_B, OUTPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, P7350_DIO_C, OUTPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } err = DIO_PortConfig(card, P7350_DIO_D, OUTPUT_PORT); if(err!=NoError){ printf("DIO_PortConfig Error: %d\n", err); Release_Card(card); exit(1); } /* * Set DO Configurations */ err = DO_7350_Config(card, DOPortWidth, DOMode, DOWaitStatus, DOClkConfig); if(err!=NoError){ printf("DO_7350_Config Error: %d\n", err); Release_Card(card); exit(1); } /* * Set DO Trigger and HandShake Configurations */ err = DO_7350_TrigHSConfig( card, TrigConfig, 0/*DO_IPOL*/, 0/*DO_REQSrc*/, 0/*DO_ACKSrc*/, 0/*DO_TRIGSrc*/, 0/*StartTrigSrc*/, 0/*PauseTrigSrc*/, SoftTrigOutSrc, SoftTrigOutLength, TrigCount ); if(err!=NoError){ printf("DO_7350_TrigHSConfig Error: %d\n", err); Release_Card(card); exit(1); } /* * allocate buffer to be written - * Note: PCIe-7350 DMA engine only supports 8-bytes data and address alignment. * That means - * 1. the bytes count of the totally transffed data is the times of 8. * 2. the lowest 3 bits of the buffer address is 0. */ /*allocate page-aligned memory to meet 8-bytes alignment*/ //Buffer = (U32 *)VirtualAlloc(NULL, WriteCount*(DOPortWidth/8), MEM_COMMIT, PAGE_READWRITE); Buffer = (U32 *)calloc(WriteCount, (DOPortWidth/8)); for(vi=0; vi<WriteCount; vi++){ *(Buffer+vi) = vi; } /* * Perform Continuous DO * Note: If the data count is too large, driver may spend some time * to lock memory to avoid memory page-out. */ printf("Press any key to start DO operation.\n"); getch(); err = DO_ContWritePort(card, 0, (void *)Buffer, WriteCount, 1, SampleRate, ASYNCH_OP); if(err!=NoError){ printf("DO_ContReadPort Error: %d\n", err); Release_Card(card); //VirtualFree(Buffer, 0, MEM_RELEASE); free(Buffer); exit(1); } /* * Set Soft Trigger */ printf("Press any key to generate a software trigger.\n"); getch(); printf("generating a software trigger.\n"); err = DO_7350_SoftTriggerGen(card); if(err!=NoError){ printf("DO_7350_SoftTriggerGen Error: %d\n", err); DO_AsyncClear(card, &AccessCnt); Release_Card(card); //VirtualFree(Buffer, 0, MEM_RELEASE); free(Buffer); exit(1); } printf("generated a software trigger.\n"); do{ printf("DO_AsyncCheck\n"); err = DO_AsyncCheck(card, &Stopped, &AccessCnt); printf("DO_AsyncCheck ok\n"); if(err!=NoError){ printf("DO_AsyncCheck Error: %d\n", err); } }while((!kbhit())&&(!Stopped)); if(!Stopped) printf("\n\nDO Operation has been stopped manually...\n\n"); else printf("\n\nDO Operation Done...\n\n"); DO_AsyncClear(card, &AccessCnt); printf("Press any key to exit...\n"); getch(); Release_Card(card); //VirtualFree(Buffer, 0, MEM_RELEASE); free(Buffer); return 0; }
int main(void) { int i, k = 0, err; setbuf(stdout, NULL); printf("PCI-7248 Interrupt Samples (INT2)\n"); printf("This program performs digital output on Port A of CN2\n"); printf(" and digital input on Port A of CN1 when an interrupt happens.\n"); printf("The INT2 is used, and interrupt signals are generated by internal Timer Output.\n"); int2_count = 0; if((card=Register_Card(PCI_7248, card_number))<0){ printf ("Can't open device file: PCI7248\n"); exit(-1); } CTR_Setup(card, 1, RATE_GENERATOR, 0, BIN); CTR_Setup(card, 2, RATE_GENERATOR, 0, BIN); usleep(1000); //initialize the input/output array for(i=0; i<total_count; i++){ buffer[i]=k; k++; if(k>255) k=0; } for(i=0; i<total_count; i++) in_buffer[i]=0; //configure the port err = DIO_PortConfig(card,Channel_P1A, INPUT_PORT); if(err!=NoError){ goto exit_after_error; } err = DIO_PortConfig(card,Channel_P2A, OUTPUT_PORT); if(err!=NoError){ goto exit_after_error; } err = DIO_SetDualInterrupt(card, INT1_DISABLE, INT2_TIMER_COUNTER, NULL, sig_handler2); if(err!=NoError){ printf(" error from DIO_SetDualInterrupt : %d \n" , err ); goto exit_after_error; } //setup the Timer clock err = CTR_Setup(card, 1, 2, c1, BIN); if(err!=NoError){ printf(" error from CTR_Setup : %d \n" , err ); goto end_of_proc; } err = CTR_Setup(card, 2, 2, c2, BIN); if(err!=NoError){ printf(" error from CTR_Setup : %d \n" , err ); goto end_of_proc; } printf("** The INT2 Singal will be sent back in 10 secs , or you can press ENTER for exit **\n"); getchar(); if(int2_count<total_count){ CTR_Setup(card, 1, RATE_GENERATOR, 0, BIN); CTR_Setup(card, 2, RATE_GENERATOR, 0, BIN); goto end_of_proc; } else{ //display the data for(i=0; i<total_count; i++){ printf(" %d, ",in_buffer[i]); if((i+1)%10==0) putchar('\n'); } } end_of_proc: DIO_SetDualInterrupt(card, INT1_DISABLE, INT2_DISABLE, NULL, NULL); exit_after_error: if(card>=0) Release_Card(card); exit(0); }
int main(void) { I16 err, card_num = 0; U32 i; pthread_t thread1; void *retval; setbuf(stdout, NULL); printf("This program inputs %ld data by PCI-7200 in %li Hz by double-buffer mode, and store data to file '%s.dat'. It will not stop until you press a key.\n\nPress any key to start the operation.\n", read_count, (unsigned long)sample_rate, file_name); getch(); if((card = Register_Card(PCI_7200, card_num))<0){ printf("Register_Card error=%d\n", card); exit(1); } for(i=0; i<read_count; i++) //DoBuf[i] = (U32)(sin((double)i/500)*0x7fff)+0x8000; DoBuf[i] = i; err = DI_7200_Config(card, TRIG_INT_PACER, DI_NOWAITING, DI_TRIG_FALLING, IREQ_FALLING); if(err!=0){ printf("DI_7200_Config error=%d", err); Release_Card(card); exit(1); } err = DO_7200_Config(card, TRIG_INT_PACER, OREQ_DISABLE, OTRIG_LOW); if(err!=0){ printf("DO_7200_Config error=%d", err); Release_Card(card); exit(1); } err = DI_AsyncDblBufferMode(card, 1); if(err!=0){ printf("DI_DblBufferMode error=%d", err); Release_Card(card); exit(1); } err = DO_ContWritePort(card, 0, DoBuf, read_count, 0, (F64)sample_rate, ASYNCH_OP); if(err!=0){ printf("DO_ContWritePort error=%d", err); } err = DI_ContReadPortToFile(card, 0, file_name, read_count, sample_rate, ASYNCH_OP); if(err!=0){ printf("DI_ContReadPort error=%d", err); Release_Card(card); exit(1); } printf("\n\nPress any key to stop input operation."); printf("\n\nData count : \n"); clear_op = FALSE; if(pthread_create(&thread1, NULL, ProcessThread, NULL)!=0){ printf(" Can't create thread1 , terminate \n "); Release_Card(card); exit(-1); } getch(); clear_op = TRUE; pthread_join(thread1, &retval); Release_Card(card); printf("\nPress ENTER to exit the program. \n"); getch(); exit(1); }
int main(int argc, char **argv) { I16 card, err; U16 card_num; U32 I2C_ReadCmdAddr; U32 I2C_ReadData; U32 I2C_WriteCmdAddr; U32 I2C_WriteData; U16 I2C_SlaveAddr; U32 vi = 0; U16 PatType; printf("This sample tests I2C Read/Write Operations.\n"); printf("It will write a byte-data to and then read from 0 ~ %d Cmd/Addr.\n", I2C_WRTCNT-1); printf("Card Number? "); scanf(" %hd", &card_num); printf("I2C Slave Address? "); scanf(" %hd", &I2C_SlaveAddr); printf("Increasing or Decreasing Pattern? [0]Increasing [1]Decreasing "); scanf(" %hd", &PatType); PatType &= 0x1; /*Open and initialize device*/ card = Register_Card( PCI_7350, /*Card type*/ card_num /*Card number*/ ); if(card<0){ printf("Register_Card Error: %d\n", card); exit(1); } /* * Set AFI voltage level * AFI0/AFI1 will be set to I2C mode automatically if I2C is enabled. */ err = DIO_VoltLevelConfig( card, /*Card handle*/ P7350_PortAFI, /*AFI voltage level to be set*/ VoltLevel_3R3 /*Voltage level to be set*/ ); if(err<0){ printf("DIO_7350_SetVoltLevel Error: %d\n", err); Release_Card(card); exit(1); } /*Setup I2C*/ err = I2C_Setup( card, I2C_Port_A, /*I2C port to be set*/ 0, /*Not used in 7350*/ 0xff, /*The parameter is used to set Pre-clock in 7350*/ 0 /*Not used in 7350*/ ); if(err<0){ printf("I2C_Setup Error: %d\n", err); Release_Card(card); exit(1); } /* * Enable I2C * AFI0/AFI1 will be set to I2C mode automatically. */ err = I2C_Control( card, I2C_Port_A, I2C_ENABLE, /*Operation item*/ 1 /*Enable opertion item*/ ); if(err<0){ printf("I2C_Control Error: %d\n", err); Release_Card(card); exit(1); } do{ /*Write*/ I2C_WriteCmdAddr = vi&0xff; I2C_WriteData = (!PatType)? I2C_WriteCmdAddr:255-I2C_WriteCmdAddr; err = I2C_Write( card, I2C_Port_A, I2C_SlaveAddr, /*Slave device address*/ 1, /*Address byte count to be written*/ 1, /*Data byte count to be written*/ I2C_WriteCmdAddr, /*Cmd/Addr to be written*/ I2C_WriteData /*Data to be written*/ ); if(err<0){ printf("I2C_Write Error: %d\n", err); I2C_Control(card, I2C_Port_A, I2C_ENABLE, 0); Release_Card(card); exit(1); } usleep(10000); //Wait for writing I2C EEPROM latency /*Read*/ I2C_ReadCmdAddr = I2C_WriteCmdAddr; err = I2C_Read( card, I2C_Port_A, I2C_SlaveAddr, /*Slave device address*/ 1, /*Address byte count to be read*/ 1, /*Data byte count to be read*/ I2C_ReadCmdAddr, /*Cmd/Addr to be read*/ &I2C_ReadData /*read Data*/ ); if(err<0){ printf("I2C_Read Error: %d\n", err); I2C_Control(card, I2C_Port_A, I2C_ENABLE, 0); Release_Card(card); exit(1); } printf("Read Addr(%ld): %ld\n", I2C_ReadCmdAddr, I2C_ReadData); vi++; }while((vi<256)&&(!kbhit())); /*Disable I2C*/ err = I2C_Control( card, I2C_Port_A, I2C_ENABLE, /*Opertion item*/ 0 /*Disble opertion item*/ ); if(err<0){ printf("I2C_Control Error: %d\n", err); Release_Card(card); exit(1); } else printf("I2C disabled\n"); printf("Press any key to exit...\n"); getch(); Release_Card(card); return 0; }
int main(int argc, char **argv) { I16 card, err; U16 card_num; //U16 ConfigCtrl = P9221_AI_Differential|P9221_AI_ExtTimeBase|P9221_TimeBaseSRC_GPI1; //U16 TrigCtrl = P9221_TRGMOD_ExtD|P9221_TRGSRC_GPI2; U16 ConfigCtrl = P9221_AI_SingEnded; U16 TrigCtrl = P9221_TRGMOD_SOFT; BOOLEAN AutoResetBuf = TRUE; U32 ScanIntrv = 160; U32 SampIntrv = 160; U16 Buffer[10000]; U32 ReadCount = 10000; U16 BufferId; F64 voltage = 0.0; FILE* fout; int i; if(!(fout=fopen("acq_data","w"))){ printf("fopen Failed\n"); } memset(Buffer, '\0', 10000*2); printf("Please input a card number: "); scanf(" %hd", &card_num); if((card=Register_Card(PCI_9221, card_num)) < 0) { printf("Register_Card error=%d", card); exit(1); } err = AI_SetTimeOut(card, 1000); if(err < 0){ printf("AI_SetTimeOut error: %d\n", err); Release_Card(card); exit(1); } err = AI_9221_CounterInterval(card, ScanIntrv, SampIntrv); if(err < 0){ printf("AI_9221_CounterInterval error: %d\n", err); Release_Card(card); exit(1); } err = AI_9221_Config(card, ConfigCtrl, TrigCtrl, AutoResetBuf); if(err < 0){ printf("AI_9221_Config error: %d\n", err); Release_Card(card); exit(1); } //printf("[APP] Virtual Address of Setup Buffer :0x%x\n", Buffer); err = AI_ContBufferSetup(card, Buffer, ReadCount, &BufferId); if(err < 0){ printf("AI_ContBufferSetup error: %d\n", err); Release_Card(card); exit(1); } err = AI_ContReadChannel(card, 0, AD_B_5_V, &BufferId, 10000, 0, SYNCH_OP); if(err < 0){ printf("AI count Read Channels error\n"); Release_Card(card); exit(1); } err = AI_ContBufferReset(card); if(err < 0){ printf("AI_ContBufferReset error: %d\n", err); Release_Card(card); exit(1); } for(i=0; i<10000; i++){ err = AI_VoltScale(card, AD_B_5_V, Buffer[i], &voltage); if(err < 0) printf("AI_VoltScale Failed\n"); fprintf(fout,"%f\n", (float)voltage); } fclose(fout); Release_Card(card); printf("Press any key to exit...\n"); getch(); return 0; }
int main(void) { I16 err; int ai_mode, dl_mode; setbuf( stdout, NULL ); printf("Please select the AI type (0:DMA 1:INT): "); scanf(" %d", &ai_mode); printf("Please select the Delay type (0:In Timebase 1:In Samples): "); scanf(" %d", &dl_mode); printf("Double Buffer Transfer With Delay Trigger operation\n"); printf("This program inputs data from CH-0 to CH-%d of PCI-9116 in %d Hz by\ndouble-buffer mode, and store data to file '%s'. The size of circular\nbuffer is %ld. It will not stop until you press a key.\n\n", channel, (int)sample_rate, file_name, read_count); if ((card=Register_Card (PCI_9116, 0)) <0 ) { printf("Register_Card error=%d\n", card); exit(1); } if(!ai_mode) AI_9116_Config(card,0,P9116_AI_DMA|P9116_TRGMOD_DELAY|(dl_mode?P9116_AI_DlyInSamples:P9116_AI_DlyInTimebase),postCount,0,0); else AI_9116_Config(card,0,P9116_AI_INT|P9116_TRGMOD_DELAY|(dl_mode?P9116_AI_DlyInSamples:P9116_AI_DlyInTimebase),postCount,0,0); AI_9116_CounterInterval (card, samp_intrv*(channel+1), samp_intrv); err = AI_AsyncDblBufferMode(card, 1); //double-buffer mode if (err!=0) { printf("AI_DblBufferMode error=%d", err); Release_Card(card); exit(1); } if (( fp = fopen( file_name , "w+b")) == NULL){ Release_Card(card); exit(1); } mem_size=read_count * 2; ai_buf = (U16*)malloc(mem_size); err = AI_ContScanChannels(card, channel, range, ai_buf, read_count/(channel+1), (F64)1, ASYNCH_OP); if (err!=0) { printf("AI_ContScanChannels error=%d", err); free( ai_buf ); exit(1); } clear_op = FALSE; printf("\n\n\n Start Data Conversion by External Trigger Signal and Press any key to stop.\n"); if( pthread_create( &thread1, NULL, ProcessThread, NULL ) != 0 ){ printf(" Can't create thread1 , terminate \n "); Release_Card(card); free( ai_buf ); fclose( fp ); exit(-1); } getch(); clear_op = TRUE; sleep(1); printf("\n\n Press any key to exit the program..... "); getch(); free( ai_buf ); fclose( fp ); return 0; }