pci550x_dac0_dma.c

linux下面

	/* select bipolar/unipolar mode */
	rc = ioctl(fd, PCI550X_IOCT_DA0_UB, bipolar);
	if(rc == -1) {
		perror("ioctl PCI550X_IOCT_DA0_UB");
		free(buf);
		exit(1);
	} else {
		if (bipolar) {
			printf("Bipolar mode enabled\n");
		} else {
			printf("Unipolar mode enabled\n");
		}
	}

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

	/* DAC0 output buffer initial values */
	if (packed && bipolar) {
		dma.bp_dac_data[0] = drt.bp_min;
		dma.bp_dac_data[1] = drt.bp_min + 1;
	} else if (packed && (!(bipolar))) {
		dma.up_dac_data[0] = drt.up_min;
		dma.up_dac_data[1] = drt.up_min + 1;
	} else if (bipolar) {
		dma.bp_dac_data[0] = drt.bp_min;
		dma.bp_dac_data[1] = 0;
	} else {
		dma.up_dac_data[0] = drt.up_min;
		dma.up_dac_data[1] = 0;
	}
 
        /* DAC0 DMA Enable */
        rc = ioctl(fd, PCI550X_IOCT_DA0_DMAEN, PCI550X_ENABLE);
        if(rc == -1) {
                perror("ioctl PCI550X_IOCT_DA0_DMAEN");
		free(buf);
                exit(1);
        } else {
                printf("DMA enabled\n");
        }

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

	/* install the signal handler */
	signal(SIGINT, &sighandler);

	while(1) {

		/* fill output buffer */
		for (i = 0; i < samples; i++) {
			buf[i] = dma.dac_data;
			if (packed && bipolar)
				if (dma.bp_dac_data[1] >= (drt.bp_max)) {
					dma.bp_dac_data[0] = drt.bp_min;
					dma.bp_dac_data[1] = drt.bp_min + 1;
				} else {
					dma.bp_dac_data[0] += 2;
					dma.bp_dac_data[1] += 2;
				}
			else if (packed && (!bipolar))
				if (dma.up_dac_data[1] >= (drt.up_max)) {
					dma.up_dac_data[0] = drt.up_min;
					dma.up_dac_data[1] = drt.up_min + 1;
				} else {
					dma.up_dac_data[0] += 2;
					dma.up_dac_data[1] += 2;
				}
			else if (bipolar) {
				if (dma.bp_dac_data[0] >= (drt.bp_max)) {
					dma.bp_dac_data[0] = drt.bp_min;
				} else {
					dma.bp_dac_data[0]++;
				}
			} else 
				if (dma.up_dac_data[1] >= (drt.up_max)) {
					dma.up_dac_data[0] = drt.up_min;
				} else {
					dma.up_dac_data[0]++;
				}
		}

		/* blocking write to DAC0 */
		bytes = 0;
		while (bytes < buf_size) {
			bytes += 
				write(fd, (void *)buf + bytes,
					 buf_size - bytes);
			if(bytes == -1) {
				perror("pci550x write");
				rc = ioctl(fd, PCI550X_IOCQ_DAC0_STATUS);
				if (rc == -1) {
					perror("ioctl "
					 "PCI550X_IOCQ_DAC0_STATUS");
					free(buf);
					exit(1);
				} else {
					printf("DAC0 status 0x%x:", rc);
					if (rc & DA0_STATUS_MERR1)
						printf("merr1\n");
					else if (rc & DA0_STATUS_MERR0)
						printf("merr0\n");
					else if (rc & DA0_STATUS_FOVR)
						printf("fifo overflow\n");
					else if (rc & DA0_STATUS_DERR)
						printf("fifo underflow\n");
					else if (rc & DA0_STATUS_CERR)
						printf("clocking error\n");
					else
						printf("DMA process error\n");
					free(buf);
					exit(1);
				}
				free(buf);
				exit(1);
			}
		}

		/* brief display */
		if (brief) {

		if (packed && bipolar)
			printf("%c:%s:%s DAC0 writes %d bytes, "
				"(P,B) %d sample values\n",
				sentinal[mm++], device,
				brd_names[brd_type], buf_size,
				buf_size >> 1);
		else if (packed & (!bipolar) )
			printf("%c:%s:%s DAC0 writes %d bytes, "
				"(P,U) %d sample values\n",
				sentinal[mm++], device,
				brd_names[brd_type], buf_size,
				buf_size >> 1);
		else if (bipolar)
			printf("%c:%s:%s DAC0 writes %d bytes, "
				"(U,B) %d sample values\n",
				sentinal[mm++], device,
				brd_names[brd_type], buf_size,
				buf_size >> 2);
		else
			printf("%c:%s:%s DAC0 writes %d bytes, "
				"(U,U) %d sample values\n",
				sentinal[mm++], device,
				brd_names[brd_type], buf_size,
				buf_size >> 2);
		mm %= sizeof(sentinal);

		} else {

		/* display output buffer contents */
		for (i = 0; (i < samples); i++ ) {
			dma.dac_data = buf[i];
			if (packed && bipolar)
				printf("%s:%s DAC0 DMA data "
				"(P,B):"
				"0x%04hx; %f Volts\n"
				"%s:%s DAC0 DMA data "
				"(P,B):"
				"0x%04hx; %f Volts\n",
				device, brd_names[brd_type],
				dma.bp_dac_data[0],
				dma.bp_dac_data[0] *
					drt.bp_res,
				device, brd_names[brd_type],
				dma.bp_dac_data[1],
				dma.bp_dac_data[1] *
					drt.bp_res);
			else if (packed && (!bipolar))
				printf("%s:%s DAC0 DMA data "
				"(P,U):"
				"0x%04hx; %f Volts\n"
				"%s:%s DAC0 DMA data "
				"(P,U):"
				"0x%04hx; %f Volts\n",
				device, brd_names[brd_type],
				dma.up_dac_data[0],
				dma.up_dac_data[0] *
					drt.up_res,
				device, brd_names[brd_type],
				dma.up_dac_data[1],
				dma.up_dac_data[1] *
					drt.up_res);
			else if (bipolar)
				printf("%s:%s DAC0 DMA data "
				"(U,B):"
				"0x%04hx; "
				" %f Volts\n",
				device, brd_names[brd_type],
				dma.bp_dac_data[0],
				dma.bp_dac_data[0] *
					drt.bp_res);
			else
				printf("%s:%s DAC0 DMA data "
				" (U,U):"
				"0x%04hx; "
				"%f Volts\n",
				device, brd_names[brd_type],
				dma.up_dac_data[0],
				dma.up_dac_data[0] *
					drt.up_res);
		}
		}
 
		/* start clocking the DAC on FIFO not empty  */
		rc = ioctl(fd, PCI550X_IOCG_DA0_STATUS, &dac0_status);
        	if(rc == -1) {
			perror("ioctl PCI550X_IOCG_DA0_STATUS");
			free(buf);
			exit(1);
		}
		if ( (dac0_status & DA0_STATUS_FNE) && (!gate_enabled) ) {

		/* DAC gate enable */
		if (g | G | t | T) {
			rc = ioctl(fd, PCI550X_IOCT_DA0_TGEN, PCI550X_ENABLE);
				if(rc == -1) {
					perror("ioctl PCI550X_IOCT_DA0_TGEN");
					exit(1);
				} else {
					printf("DAC0 external gate enabled\n");
				}
		} else {
			rc = ioctl(fd, PCI550X_IOCT_DA0_CGEN, PCI550X_ENABLE);
				if(rc == -1) {
					perror("ioctl PCI550X_IOCT_DA0_CGEN");
					exit(1);
				} else {
					printf("DAC0 software gate enabled\n");
				}
		}
		gate_enabled = PCI550X_TRUE;
		}
 
		if (!(dac0_status & DA0_STATUS_GATE) && gate_enabled)
			printf("DAC0 clock source gated OFF\n");

	} /* end while */

	free(buf);
	close(fd);
	return(0);
	
}