pci550x_adc_clk.c

linux下面

		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_CLOCK_SOURCE");
			exit(1);
		} else {
			printf("External Clock source ADCLKIN"
				" (falling edge) selected\n");
		}
	} else if (X) {
		rc = ioctl(fd, PCI550X_IOCT_ADC_CLOCK_SOURCE, ADC_EXR_CLK);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_CLOCK_SOURCE");
			exit(1);
		} else {
			printf("External Clock source ADCLKIN"
				" (rising edge) selected\n");
		}
	} else {
		rc = ioctl(fd, PCI550X_IOCT_ADC_CLOCK_SOURCE, ADC_IP_CLK);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_CLOCK_SOURCE");
			exit(1);
		} else {
			printf("Internal Pacer Clock Source selected\n");
		}

		/* set the PACER CLOCK RATE */
		if (F) {
			rc = ioctl(fd, PCI550X_IOCT_ADC_FPCEN,
					PCI550X_ENABLE);
			if(rc == -1) {
				perror("ioctl PCI550X_IOCT_ADC_FPCEN");
				exit(1);
			}
			rc = ioctl(fd, PCI550X_IOCS_ADC_FAST_CLOCK_RATE,
				&ndelay);
			if(rc == -1) {
				perror("ioctl "
					"PCI550X_IOCS_ADC_FAST_CLOCK_RATE");
				exit(1);
			} else {
				printf("Pacer clock(0.25 usecs): %lu\n",
					 ndelay);
			}
		} else {
			rc = ioctl(fd, PCI550X_IOCT_ADC_FPCEN,
				PCI550X_DISABLE);
			if(rc == -1) {
				perror("ioctl PCI550X_IOCT_ADC_FPCEN");
				exit(1);
			}
			rc = ioctl(fd, PCI550X_IOCS_ADC_PACER_CLOCK_RATE,
				 &udelay);
			if(rc == -1) {
				perror("ioctl "
					"PCI550X_IOCS_ADC_PACER_CLOCK_RATE");
				exit(1);
			} else {
				printf("ADC Pacer clock(usecs): %lu\n",
					udelay);
			}
		}
	}
 
        /* enable/disable packed data mode */
        rc = ioctl(fd, PCI550X_IOCT_ADC_PDM, packed);
        if(rc == -1) {
                perror("ioctl PCI550X_IOCT_ADC_PDM");
                exit(1);
        } else {
		if (packed)
 	               printf("PDM enabled\n");
		else
 	               printf("PDM disabled\n");
        }

	/* About Trigger Mode */
	if (A) {
		rc = ioctl(fd, PCI550X_IOCS_ADC_CCOUNT, (int *)&ccount);
		if (rc == -1) {
			perror("ioctl PCI550X_IOCS_ADC_CCOUNT");
			exit(1);
		}
		rc = ioctl(fd, PCI550X_IOCT_ADC_ATEN, PCI550X_ENABLE);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_ATEN");
			exit(1);
		} else {
			printf("About Trigger Mode CCOUNT = %d\n", ccount);
		}
	} else {
		rc = ioctl(fd, PCI550X_IOCT_ADC_ATEN, PCI550X_DISABLE);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_ATEN");
			exit(1);
		} else
			printf("About Trigger Mode disabled\n");
	}

	/* enable ADC FIFO */
	rc = ioctl(fd, PCI550X_IOCT_AD_STATUS_FFEN, PCI550X_ENABLE);
	if(rc == -1) {
		perror("ioctl PCI550X_IOCT_AD_STATUS_FFEN");
		exit(1);
	} else {
		printf("ADC FIFO enabled\n");
	}

	/* ADC expansion inputs */
	if (E) {
		rc = ioctl(fd, PCI550X_IOCT_ADC_EMXEN, PCI550X_ENABLE);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_EMXEN");
			exit(1);
		} else
			printf("ADC expansion inputs Enabled\n");
	} else {
		rc = ioctl(fd, PCI550X_IOCT_ADC_EMXEN, PCI550X_DISABLE);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_EMXEN");
			exit(1);
		}
	}

	/* ADC External Trigger Output */
	if (o) {
		rc = ioctl(fd, PCI550X_IOCT_ADC_TOEN, PCI550X_ENABLE);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_TOEN");
			exit(1);
		} else
			printf("ADC external Trigger Output Enabled\n");
	} else {
		rc = ioctl(fd, PCI550X_IOCT_ADC_TOEN, PCI550X_DISABLE);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_TOEN");
			exit(1);
		}
	}

	/* ADC External Clock Output */
	if (O) {
		rc = ioctl(fd, PCI550X_IOCT_ADC_COEN, PCI550X_ENABLE);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_COEN");
			exit(1);
		} else
			printf("ADC external Clock Output Enabled\n");
	} else {
		rc = ioctl(fd, PCI550X_IOCT_ADC_COEN, PCI550X_DISABLE);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_COEN");
			exit(1);
		}
	}

	/* select gate source for the onboard pacer clock */
	if (g | G | t | T) {
		rc = ioctl(fd, PCI550X_IOCT_ADC_CGSL, PCI550X_ENABLE);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_CGSL");
			exit(1);
		} else
			printf("ADC external ");
		if (g | G ) {
			rc = ioctl(fd, PCI550X_IOCT_ADC_TGSL, PCI550X_ENABLE);
			if(rc == -1) {
				perror("ioctl PCI550X_IOCT_ADC_TGSL");
				exit(1);
			} else
				printf("level ");
			if (G) {
				rc = ioctl(fd, PCI550X_IOCT_ADC_TGPL,
					PCI550X_ENABLE);
				if(rc == -1) {
					perror("ioctl PCI550X_IOCT_ADC_TGPL");
					exit(1);
				} else
					printf("(high) gate enabled\n");
				g = PCI550X_DISABLE;
			} else {
				rc = ioctl(fd, PCI550X_IOCT_ADC_TGPL,
					PCI550X_DISABLE);
				if(rc == -1) {
					perror("ioctl PCI550X_IOCT_ADC_TGPL");
					exit(1);
				} else
					printf("(low) gate enabled\n");
				G = PCI550X_DISABLE;
			}
			t = T = PCI550X_DISABLE;
		} else {
			rc = ioctl(fd, PCI550X_IOCT_ADC_TGSL, PCI550X_DISABLE);
			if(rc == -1) {
				perror("ioctl PCI550X_IOCT_ADC_TGSL");
				exit(1);
			} else
				printf("edge ");
			g = G = PCI550X_DISABLE;
			if (T) {
				rc = ioctl(fd, PCI550X_IOCT_ADC_TGPL,
					PCI550X_ENABLE);
				if(rc == -1) {
					perror("ioctl PCI550X_IOCT_ADC_TGPL");
					exit(1);
				} else
					printf("(rising) trigger enabled\n");
				t = PCI550X_DISABLE;
			} else {
				rc = ioctl(fd, PCI550X_IOCT_ADC_TGPL,
					PCI550X_DISABLE);
				if(rc == -1) {
					perror("ioctl PCI550X_IOCT_ADC_TGPL");
					exit(1);
				} else
					printf("(falling) trigger enabled\n");
				T = PCI550X_DISABLE;
			}
		}
	} else {
		rc = ioctl(fd, PCI550X_IOCT_ADC_CGSL, PCI550X_DISABLE);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCT_ADC_CGSL");
			exit(1);
		} else
			printf("ADC Software Gate enabled\n");
	}

	/* ADC gate enable */
	if (g | G | t | T) {
		rc = ioctl(fd, PCI550X_IOCT_ADC_TGEN, PCI550X_ENABLE);
			if(rc == -1) {
				perror("ioctl PCI550X_IOCT_ADC_TGEN");
				exit(1);
			} else {
				printf("ADC external gate enabled\n");
			}
	} else {
		rc = ioctl(fd, PCI550X_IOCT_ADC_CGEN, PCI550X_ENABLE);
			if(rc == -1) {
				perror("ioctl PCI550X_IOCT_ADC_CGEN");
				exit(1);
			} else {
				printf("ADC Pacer Clock gated on\n");
			}
	}

	/* enable ADC to do conversions */
	rc = ioctl(fd, PCI550X_IOCT_ADC_CVEN, PCI550X_ENABLE);
	if(rc == -1) {
		perror("ioctl PCI550X_IOCT_ADC_CVEN");
		exit(1);
	} else {
		printf("ADC enabled to do conversions\n");
	}

	/* wait for ADC ready */
	ad_status = 0;
	while (!(ad_status & AD_STATUS_READY )) {
		rc = ioctl(fd, PCI550X_IOCG_AD_STATUS, &ad_status);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCG_AD_STATUS");
			exit(1);
		}
	}

        adc_error = cindex = 0;
        while(1) {  /* do this until we are asked to stop, or an error */
 
        /* wait for FIFO not empty, or an error */
        do {
                rc = ioctl(fd, PCI550X_IOCG_AD_STATUS, &ad_status);
                if(rc == -1) {
                        perror("ioctl PCI550X_IOCG_AD_STATUS");
                        exit(1);
                }
                if (ad_status & (AD_STATUS_FOVR | AD_STATUS_FUNDR |
                                 AD_STATUS_CERR | AD_STATUS_BERR  ) ) {
                        adc_error = 1;
                        break;
                } else if (ad_status & AD_STATUS_CCTC) {
			printf("About trigger CCOUNT (%d) reached\n", ccount);
			signal(SIGINT, SIG_IGN);
			sighandler(0);
		} else if (!(ad_status & AD_STATUS_GATE))
			printf("ADC clock source is gated OFF\n");

        } while (!(ad_status & AD_STATUS_FNE));

	/* if ADC error,...exit the big loop */
        if (adc_error) break;

	/* get the FIFO sample data */
	rc = ioctl(fd, PCI550X_IOCG_AD_FIFO, &u1.ad_fifo);
	if(rc == -1) {
		perror("ioctl PCI550X_IOCG_AD_FIFO");
		exit(1);
	} else {
		if (packed && bipolar)
			printf("%s:%s ADC Channel 0x%04hx "
			"(P,B):"
			"0x%04hx; %f Volts;\n"
			"%s:%s ADC Channel 0x%04hx (P,B):"
			"0x%04hx; %f Volts\n",
			device, brd_names[brd_type],
			dl_ccram.ccram[cindex],
			u1.fifo_bp[1],
			u1.fifo_bp[1] * art[brd_type].bp_res[gain],
			device, brd_names[brd_type],
			dl_ccram.ccram[(cindex+1) % samples],
			u1.fifo_bp[0],
			u1.fifo_bp[0] * art[brd_type].bp_res[gain]);
		else if (packed && (!bipolar))
			printf("%s:%s ADC Channel 0x%04hx "
			"(P,U):"
			"0x%04hx; %f Volts;\n"
			"%s:%s ADC Channel 0x%04hx (P,U):"
			"0x%04hx; %f Volts\n",
			device, brd_names[brd_type],
			dl_ccram.ccram[cindex],
			u1.fifo_up[1],
			u1.fifo_up[1] * art[brd_type].up_res[gain],
			device, brd_names[brd_type],
			dl_ccram.ccram[(cindex+1) % samples],
			u1.fifo_up[0],
			u1.fifo_up[0] * art[brd_type].up_res[gain]);
		else if (bipolar)
			printf("%s:%s ADC Channel 0x%04hx "
			"(U,B):"
			"0x%04hx; %f Volts\n",
			device, brd_names[brd_type],
			u1.fifo_bp[1], u1.fifo_bp[0],
			u1.fifo_bp[0] * art[brd_type].bp_res[gain]);
		else
			printf("%s:%s ADC Channel 0x%04hx "
			"(U,U):"
			"0x%04hx; %f Volts\n",
			device, brd_names[brd_type],
			u1.fifo_up[1], u1.fifo_up[0],
			u1.fifo_up[0] * art[brd_type].up_res[gain]);
		if (packed)
			cindex += 2;
		else
			cindex++;
		cindex %= samples;
	}

	} /* end while */

	/*
	 * ADC had an error, display the ADC Status Register and Exit
	 */
	printf("ADC Error: status register contents: 0x%08x\n", ad_status);
	if (ad_status & AD_STATUS_FOVR)
		printf("ADC FIFO overflow\n");
	if (ad_status & AD_STATUS_FUNDR)
		printf("ADC FIFO underflow\n");
	if (ad_status & AD_STATUS_CERR)
		printf("ADC clocking error\n");
	if (ad_status & AD_STATUS_BERR)
		printf("ADC burst error\n");

	/* clean up with the signal handler */
	signal(SIGINT, SIG_IGN);
	sighandler(0);
	
	return(0);
}