dm6430-dual-dma.c

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

/*
	FILE NAME: dm6430-dual-dma.c

	FILE DESCRIPTION: Dual DMA sample program

		This program transfers data using both DMA channels on a board.
		When the first DMA buffer is full, the board will automatically
		switch to the second DMA buffer and continue acquiring data.
		The program then writes the first buffer to a file.  When the
		second buffer is full, the board switches back to the first and
		the program writes the second buffer to the file.  Since the
		DMA controller is programmed for autoinitialize, the data
		acquisition continues with no gaps.

	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 <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/poll.h>
#include <unistd.h>

#include <dm6430lib.h>


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


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


#define DMA_BUF_SIZE10	0x2000		// The size of the DMA buffer.
#define ADCHANNEL10	DM6430HR_AIN1	// A/D channel
#define RATE10		10000		// Sampling rate
#define IRQCHANNEL10	DM6430HR_INT1	// interrupt channel


volatile int new_samples = 0;
unsigned long transfers_0, transfers_1;
int logfile;
int descriptor;


char dmabuf1[DMA_BUF_SIZE10];
char dmabuf2[DMA_BUF_SIZE10];


static void
dual_dma_isr(void) {
    int	done_flag;
    int	status;

    status = IsADDMADone6430(descriptor, &done_flag);
    verify_success(status, "IsADDMADone6430() FAILED");

    if (done_flag) {
	int	first_done;
	size_t	transfer_size;

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

	status = IsFirstADDMADone6430(descriptor, &first_done);
	verify_success(status, "IsFirstADDMADone6430() FAILED");

	if (!first_done) {
	    status = StopDMA6430(descriptor, DM6430HR_DMA1);
	    verify_success(status, "StopDMA6430() FAILED");

	    status = GetDmaData6430(
		descriptor,
		dmabuf1,
		DM6430HR_DMA1,
		sizeof(dmabuf1),
		0,
		&transfer_size
	    );
	    verify_success(status, "GetDmaData6430() FAILED");

	    write(logfile, dmabuf1, sizeof(dmabuf1));
	    transfers_0++;
	
	    status = StartDMA6430(descriptor, DM6430HR_DMA1, sizeof(dmabuf1));
	    verify_success(status, "StartDMA6430() FAILED");
	} else {
	    status = StopDMA6430(descriptor, DM6430HR_DMA2);
	    verify_success(status, "StopDMA6430() FAILED");

	    status = GetDmaData6430(
		descriptor,
		dmabuf2,
		DM6430HR_DMA2,
		sizeof(dmabuf2),
		0,
		&transfer_size
	    );
	    verify_success(status, "GetDmaData6430() FAILED");
	    
	    write(logfile, dmabuf2, sizeof(dmabuf2));
	    transfers_1++;

	    status = StartDMA6430(descriptor, DM6430HR_DMA2, sizeof(dmabuf2));
	    verify_success(status, "StartDMA6430() FAILED");
	}

	new_samples = 1;
    }
}


int
main(int argument_count, char **arguments_p_p) {
    double		dummy;
    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();
    }

    logfile = open("dual_dma.dat", O_WRONLY | O_CREAT | O_TRUNC, 0640);
    verify_success(logfile, "open(dual_dma.dat) FAILED");

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

    status = InstallDMA6430(descriptor, DM6430HR_DMA1);
    verify_success(status, "InstallDMA6430(DMA channel 0) FAILED");

    status = InstallDMA6430(descriptor, DM6430HR_DMA2);
    verify_success(status, "InstallDMA6430(DMA channel 1) FAILED");

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

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

    status = SetChannelGain6430(
	descriptor,
	ADCHANNEL10,
	DM6430HR_GAINx1,
	DM6430HR_SE_SE
    );
    verify_success(status, "SetChannelGain6430() FAILED");

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

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

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

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

    status = SetIRQ0Source6430(descriptor, IRQS_AD_DMA_DONE_6430);
    verify_success(status, "SetIRQ0Source6430() FAILED");

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

    status = InstallCallbackIRQHandler6430(
	descriptor, dual_dma_isr, IRQCHANNEL10
    );
    verify_success(status, "InstallCallbackIRQHandler6430() FAILED");

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

    status = EnableIRQ6430(descriptor, IRQCHANNEL10);
    verify_success(status, "EnableIRQ6430() FAILED");

    status = StartDMA6430(descriptor, DM6430HR_DMA1, sizeof(dmabuf1));
    verify_success(status, "StartDMA6430(channel 0) FAILED");

    status = StartDMA6430(descriptor, DM6430HR_DMA2, sizeof(dmabuf2));
    verify_success(status, "StartDMA6430(channel 1) FAILED");

    fprintf(
	stdout,
	"Channel %d sampled at %d Hz.\nThe DMA buffer size is %d bytes\n"
	"Press Enter to stop\nSee dual_dma.dat file for data\n",
	ADCHANNEL10 + 1,
	RATE10,
	DMA_BUF_SIZE10 * 2
    );

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

    while (!isstdindata(100))
	if (new_samples) {
	    new_samples = 0;
	    fprintf(
		stdout,
		"DMA1tr %ld, DMA2tr %ld\n",
		transfers_0,
		transfers_1
	    );
	}    

    status = StopDMA6430(descriptor, DM6430HR_DMA1);
    verify_success(status, "StopDMA6430(channel 0) FAILED");

    status = StopDMA6430(descriptor, DM6430HR_DMA2);
    verify_success(status, "StopDMA6430(channel 1) FAILED");

    status = DisableIRQ6430(descriptor, IRQCHANNEL10);
    verify_success(status, "DisableIRQ6430() FAILED");

    status = RemoveIRQHandler6430(descriptor, IRQCHANNEL10);
    verify_success(status, "RemoveIRQHandler6430() FAILED");

    status = DeInstallDMA6430(descriptor, DM6430HR_DMA1);
    verify_success(status, "DeInstallDMA6430(channel 0) FAILED");

    status = DeInstallDMA6430(descriptor, DM6430HR_DMA2);
    verify_success(status, "DeInstallDMA6430(channel 1) FAILED");

    close(logfile);

    exit(EXIT_SUCCESS);
}