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;
}
