dm6430-auto-burst.c

rt 6430 采集卡 linux下驱动源代码

/*
	FILE NAME: dm6430-auto-burst.c

	FILE DESCRIPTION: Automatic burst sample program
	
		Sample program that demonstrates how to use the pacer clock,
		burst clock, sample counter, and channel gain table to scan
		groups of channels, multiple times.

		This program uses the sample counter, burst clock and the pacer
		clock features of the DM6430 to do MULTI-BURST sampling.  The
		board is set up to sample a set of channels, 3 times every
		time the board receives a trigger from the on board 8254.

		While the measurement is running, the acquired A/D data is
		displayed on the screen, one line with every sample.

	PROJECT NAME: Linux DM6430 Driver, Library, and Example Programs

	PROJECT VERSION: (Defined in README.TXT)

	Copyright 2004 RTD Embedded Technologies, Inc.  All Rights Reserved.
*/


#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/poll.h>
#include <unistd.h>

#include <dm6430lib.h>


#define ADSLOPE1	(65536.0 / 20.0)	// Number Bits divided by AD Range
#define FIRST_CHAN1	DM6430HR_AIN1	// First channel of the burst
#define NUM_OF_CHAN1	8		// Number of channels in one burst
#define RATE1		1000		// Sample rate in [Hz]
#define BURST_RATE1	10000		// Burst rate in [Hz]
#define USER_RATE1	1		// Measurement trigger period in [Hz]


char *program_name_p;


static void
usage(void) {
    fprintf(
	stderr,
	"\n"
	"Usage: %s MINOR_NUMBER"
	"\n",
	program_name_p
    );
    exit(EXIT_FAILURE);
}


static void
verify_success(int status, const char *message_p) {
    if (status == -1) {
	perror(message_p);
	exit(EXIT_FAILURE);
    }
}


int
isstdindata(int timeout) {
    struct pollfd	in = {0, POLLIN | POLLERR | POLLPRI, 0};
    int			num_fds;

    while (((num_fds = poll(&in, 1, timeout)) == -1) && (errno == EINTR))
	;

    return ((num_fds == 1) && (in.revents & (POLLIN | POLLPRI)));
}



int
main(int argument_count, char **arguments_p_p) {
    ADTableRow		ADTable[NUM_OF_CHAN1];
    double		ActualRate0;
    double		dummy;
    int			channel;
    int			count = 0;
    int			descriptor;
    int			status;
    unsigned int	minor_number;

    program_name_p = arguments_p_p[0];

    if (argument_count != 2) {
	fprintf(stderr, "Invalid number of options given.\n");
	usage();
    }

    if (sscanf(arguments_p_p[1], "%u", &minor_number) == 0) {
	fprintf(stderr, "Invalid device minor number.\n");
	usage();
    }

    descriptor = OpenBoard6430(minor_number);
    verify_success(descriptor, "OpenBoard6430() FAILED");

    status = InitBoard6430(descriptor);
    verify_success(status, "InitBoard6430() FAILED");

    for (channel = 0; channel < NUM_OF_CHAN1; channel++) {
	ADTable[channel].Channel = (FIRST_CHAN1 + channel);
	ADTable[channel].Gain = DM6430HR_GAINx1;
	ADTable[channel].Se_Diff = DM6430HR_SE_SE;
	ADTable[channel].Pause = 0;
	ADTable[channel].Skip = 0;
    }

    status = SetPacerClock6430(descriptor, RATE1, &dummy);
    verify_success(status, "SetPacerClock6430() FAILED");

    status = SetBurstClock6430(descriptor, BURST_RATE1, &dummy);
    verify_success(status, "SetBurstClock6430() FAILED");

    status = SetUserClock6430(
	descriptor,
	DM6430HR_CLK0,
	DM6430HR_8MHZ,
	20000,
	&ActualRate0
    );
    verify_success(status, "SetUserClock6430() FAILED");

    status = SetUserClock6430(
	descriptor,
	DM6430HR_CLK1,
	ActualRate0,
	USER_RATE1,
	&dummy
    );
    verify_success(status, "SetUserClock6430() FAILED");

    status = SetBurstTrigger6430(descriptor, DM6430HR_BURST_TRIG_PACER);
    verify_success(status, "SetBurstTrigger6430() FAILED");

    status = SetTriggerRepeat6430(descriptor, DM6430HR_REPEAT_REPEAT);
    verify_success(status, "SetTriggerRepeat6430() FAILED");

    status = SetStartTrigger6430(descriptor, DM6430HR_START_TRIG_USER_TC1);
    verify_success(status, "SetStartTrigger6430() FAILED");

    status = SetStopTrigger6430(descriptor, DM6430HR_STOP_TRIG_SAMPLE_CNT);
    verify_success(status, "SetStopTrigger6430() FAILED");

    status = SetConversionSelect6430(descriptor, DM6430HR_CONV_BURST_CLOCK);
    verify_success(status, "SetConversionSelect6430() FAILED");

    status = LoadADSampleCounter6430(descriptor, NUM_OF_CHAN1 * 3);
    verify_success(status, "LoadADSampleCounter6430() FAILED");

    status = LoadADTable6430(descriptor, NUM_OF_CHAN1, ADTable);
    verify_success(status, "LoadADTable6430() FAILED");

    status = EnableTables6430(descriptor, 1, 0);
    verify_success(status, "EnableTables6430() FAILED");

    status = ClearADFIFO6430(descriptor);
    verify_success(status, "ClearADFIFO6430() FAILED");

    fprintf(
	stdout,
	"AIN1 - AIN8 range = bipolar 10V\nPress Enter for stop\n"
    );

    status = StartConversion6430(descriptor);
    verify_success(status, "StartConversion6430() FAILED");

    while (!isstdindata(200)) {
	for (channel = 0; channel < NUM_OF_CHAN1; channel++) {
	    int		empty_flag;
	    int16_t	data;

	    do {
		status = IsADFIFOEmpty6430(descriptor, &empty_flag);
		verify_success(status, "IsADFIFOEmpty6430() FAILED");
	    } while (empty_flag);

	    status = ReadADData6430(descriptor, &data);
	    verify_success(status, "ReadADData6430() FAILED");
	    fprintf(
		stdout,
		"CH%d: %+05.2lf mV\n",
		channel + 1,
		data / ADSLOPE1
	    );
	}

	fprintf(stdout, "Count: %d\n", ++count);
    }

    exit(EXIT_SUCCESS);
}