pci550x_adc_clk.c

linux下面

/*
 * pci550x user program - ADC Clocked Acquisition
 *
 * This test program uses a hardware ocillator to clock the ADC from either
 * the internal ADC PACER clock or an external clock source ADCLKIN.  The
 * sample data is then read directly from the ADC FIFO register and
 * converted to a voltage reading.  This mode of operation is referred to as
 * "programmed I/O", meaning that no interrupts or DMA functions are used
 * to acquire the sample data.  In this method of operating the ADC, the
 * non-empty ADC FIFO is read continuously.  If the sampling rate exceeds
 * the rate at which the ADC FIFO can be emptied by software, the ADC FIFO
 * will overflow and ADC conversions are automatically disabled by the
 * hardware.
 *
 * Invoke this test program from the command line as follows:
 *
 * $ ./pci550x_adc_clk -f /dev/pci550xN [-p] [-u] [-c CHANNEL]
 *					[-d USECS | -F NSECS] [-s SAMPLES]
 *					[-g | -G | -t | -T] [-o] [-O] [-E]
 *					[-A CCOUNT] [-x | -X]
 *
 *      -f /dev/pci550xN        = device node (N=device #)
 *      -p                      = packed data mode
 *      -u                      = unipolar
 *      -c CHANNEL              = 16 bit hex channel number
 *      -d USECS                = usec delay between ADC conversions
 *      -F NSECS                = .25 usec delay between ADC conversions
 *      -s SAMPLES              = number of samples per acquisition
 *	-g			= ADC external gate ADTGIN (active low)
 *	-G			= ADC external gate ADTGIN (active high)
 *	-t			= ADC external trigger ADTGIN (falling edge)
 *	-T			= ADC external trigger ADTGIN (rising edge) 
 *	-o			= ADC external trigger output - ADTROUT
 *	-O			= ADC external clock output - ADCLKOUT
 *	-E			= ADC expansion inputs
 *	-A CCOUNT		= number of POST TRIGGER ADC conversions
 *	-x			= external clock ADCLKIN (falling edge)
 *	-X			= external clock ADCLKIN (rising edge)
 *
 * EXAMPLE: run the test on device 3 in packed data mode at 10ms
 * starting at channel 0 in unipolar mode with a 16 element channel scan list
 *
 * $ ./pci550x_adc_clk -f /dev/pci550x3 -p -u -c0 -d10000 -s16
 */

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include <sys/ioctl.h>
#include <signal.h>
#include <unistd.h>
#include <linux/limits.h>

#include <getopt.h>
#define __USE_GNU
#include <string.h>

#define _PCI550X_USE_ADC_RANGE_TABLES
#include "pci550x.h"

/* GLOBLA DATA */
/* channel list */
adc_ccram dl_ccram;	/* downloaded channel list */
adc_ccram ul_ccram;	/* uploaded channel list */

int i,c;
int ad_status;
int ad_control;
int adc_error;
unsigned short channel = 0;
unsigned int ccount = 0;
unsigned short mux;
unsigned short samples = ADC_CCRAM_MAX;
unsigned short cindex;

union {
        unsigned int ad_fifo;
        unsigned short fifo_up[2];
        short fifo_bp[2];
} u1;

unsigned int gain = 0;
int fd,rc;
int brd_type;
char device[PATH_MAX] = "/dev/pci550x0";
int packed = PCI550X_DISABLE;
int bipolar = PCI550X_ENABLE;
int g = PCI550X_DISABLE; int G = PCI550X_DISABLE;
int t = PCI550X_DISABLE; int T = PCI550X_DISABLE;
int o = PCI550X_DISABLE; int O = PCI550X_DISABLE;
int E = PCI550X_DISABLE; int F = PCI550X_DISABLE;
int X = PCI550X_DISABLE; int x = PCI550X_DISABLE;
int A = PCI550X_DISABLE;
unsigned long udelay = PCI550X_NOMINAL_ADC_RATE;
unsigned long ndelay = 64;

void sighandler(int signum) {

	/* user wants to quit */
	if (signum)
		printf("received signal: %s, cleaning up...\n",
			strsignal(signum));

	/* ADC gate disable */
	if (g | G | t | T) {
		rc = ioctl(fd, PCI550X_IOCT_ADC_TGEN, PCI550X_DISABLE);
			if(rc == -1) {
				perror("ioctl PCI550X_IOCT_ADC_TGEN");
				exit(1);
			} else {
				printf("ADC external gate disabled\n");
			}
	} else {
		rc = ioctl(fd, PCI550X_IOCT_ADC_CGEN, PCI550X_DISABLE);
			if(rc == -1) {
				perror("ioctl PCI550X_IOCT_ADC_CGEN");
				exit(1);
			} else {
				printf("ADC software gate disabled\n");
			}
	}

	/* flush the ADC pipeline */
	rc = ioctl(fd, PCI550X_IOCT_ADC_CVEN, PCI550X_DISABLE);
	if(rc == -1) {
		perror("ioctl PCI550X_IOCT_ADC_CVEN");
		exit(1);
	} else {
		printf("ADC disabled to do conversions\n");
	}
	
	/* drain the FIFO */
	rc = ioctl(fd, PCI550X_IOCG_AD_STATUS, &ad_status);
	if(rc == -1) {
		perror("ioctl PCI550X_IOCG_AD_STATUS");
		exit(1);
	}
	while (ad_status & AD_STATUS_FNE) {
		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;
		}
		rc = ioctl(fd, PCI550X_IOCG_AD_STATUS, &ad_status);
		if(rc == -1) {
			perror("ioctl PCI550X_IOCG_AD_STATUS");
			exit(1);
		}
	}
	printf("ADC FIFO empty\n");

	close(fd);
	exit(0);
}

int main(int argc, char **argv) {
 
        /* get command line args */
        opterr = 0;
        while ((c = getopt(argc, argv, "f:uc:phd:F:s:gGtToOEA:xX")) != -1)
 
                switch(c) {
 
                case 'd':
                        if ((sscanf(optarg, "%ld", &udelay)) == 0)
                                udelay = 10000;
                        break;
                case 'F':
                        if ((sscanf(optarg, "%ld", &ndelay)) == 0)
                                ndelay = 64;
			F = PCI550X_ENABLE;
                        break;
                case 'f':
                        strncpy(device, optarg, PATH_MAX);
                        break;
                case 'u':
                        bipolar = PCI550X_DISABLE;
                        break;
                case 'c':
                        if ((sscanf(optarg, "%hx", &channel)) == 0)
                                channel = 0;
                        break;
                case 's':
                        if ((sscanf(optarg, "%hd", &samples)) == 0)
				samples = ADC_CCRAM_MAX;
			else {
				if (!samples)
					samples = ADC_CCRAM_MAX;
				else
					samples %= ADC_CCRAM_MAX+1;
			}
                        break;
                case 'p':
                        packed = PCI550X_ENABLE;
                        break;
                case 'h':
                        printf("usage: pci550x_adc_clk -f /dev/pci550xN "
                                "[-p] [-u] [-c CHANNEL] "
				"[-d USECS | -F NSECS] "
				"[-s SAMPLES] [-x | X] "
				"[-g | -G | -t | -T] [-o] [-O] [-E]\n");
                        printf("-f /dev/pci550xN where N = board number\n");
                        printf("-p, packed data mode\n");
                        printf("-u, unipolar mode\n");
                        printf("-c CHANNEL = 16-bit hex channel number\n");
                        printf("-d USECS = delay between ADC conversions "
                                "in 1.0 microsecond increments\n");
                        printf("-F NSECS = delay between ADC conversions "
                                "in 0.25 microsecond increments\n");
			printf("-s SAMPLES = number of samples in scan "
				"list\n");
 			printf("-g, ADC external gate ADTGIN (active low)\n");
 			printf("-G, ADC external gate ADTGIN (active high\n");
 			printf("-t, ADC external trigger"
				" ADTGIN (falling edge)\n");
 			printf("-T, ADC external trigger"
				" ADTGIN (rising edge)\n");
 			printf("-o, ADC external trigger ADTROUT\n");
 			printf("-O, ADC external clock ADCLKOUT\n");
 			printf("-E, ADC expansion inputs enable\n");
 			printf("-A, CCOUNT = number of POST TRIGGER "
				"ADC conversions\n");
			printf("-x, external clock ADCLKIN (falling edge)\n");
			printf("-X, external clock ADCLKIN (rising edge)\n");
                        exit(0);
		case 'g':
			g = PCI550X_ENABLE;
			break;
		case 'G':
			G = PCI550X_ENABLE;
			break;
		case 't':
			t = PCI550X_ENABLE;
			break;
		case 'T':
			T = PCI550X_ENABLE;
			break;
		case 'o':
			o = PCI550X_ENABLE;
			break;
		case 'O':
			O = PCI550X_ENABLE;
			break;
		case 'E':
			E = PCI550X_ENABLE;
			break;
		case 'A':
                        if ((sscanf(optarg, "%d", &ccount)) == 0) {
				printf("error: invalid ccount: %d\n", ccount);
				exit(1);
			}
			A = PCI550X_ENABLE;
                        break;
		case 'X':
			X = PCI550X_ENABLE;
			break;
		case 'x':
			x = PCI550X_ENABLE;
			break;
                default:
                        break;
                }

	/* open the device */
	fd = open(device, O_RDONLY);
	if(fd == -1) {
		perror("open failed");
		exit(1);
	} else {
		printf("open succeeded on %s\n", device);
	}

	/* query device type */
	rc = ioctl(fd, PCI550X_IOCG_BRD_TYPE, &brd_type);
	if(rc == -1) {
		perror("ioctl PCI550X_IOCG_BRD_TYPE");
		exit(1);
	} else {
		printf("ADAC Board Type:  %s\n", brd_names[brd_type]);
	}

	/* install the signal handler */
	signal(SIGINT, &sighandler);
	
	/* download the channel list */
	gain = ((channel & AD_CCRAM_D_GN) >> 8);
	mux =  channel & AD_CCRAM_D_MUX;
	channel &= (~AD_CCRAM_D_MUX);
	if (bipolar)
		channel &= (~AD_CCRAM_D_UB);
	else
		channel |= (AD_CCRAM_D_UB);
	for (i = 0; i < samples; i++, mux++, mux %= art[brd_type].channels )
		dl_ccram.ccram[i] = channel | mux;
	dl_ccram.elements = samples;
	rc = ioctl(fd, PCI550X_IOCS_AD_CCRAM_D, &dl_ccram);
	if(rc == -1) {
		perror("ioctl PCI550X_IOCS_AD_CCRAM_D");
		exit(1);
	} else {
		printf("ADC Channel List Downloaded\n");
	}

	/* upload the channel list */
	rc = ioctl(fd, PCI550X_IOCG_AD_CCRAM_D, &ul_ccram);
	if(rc == -1) {
		perror("ioctl PCI550X_IOCS_AD_CCRAM_D");
		exit(1);
	} else {
		printf("ADC Channel List Uploaded\n");
		printf("Number of Elements: %d\n", ul_ccram.elements);
		for (i = 0; i < ul_ccram.elements; i++)
			printf("ADC Element:%d-0x%x\n",i, ul_ccram.ccram[i]);
	}

	/* select Pacer Clock Source */
	if (x) {
		rc = ioctl(fd, PCI550X_IOCT_ADC_CLOCK_SOURCE, ADC_EXF_CLK);