drvr6430.c

rt采集卡dos下dm6430驱动源代码

//*************************************************************************
void SetTriggerPolarity6430(uint16 Polarity)
{
	Trigger_Register_6430 &= 0xEFFF;
	Trigger_Register_6430 |= (Polarity << 12);
	outpw(BaseAddress + r_TRIGGER_6430, Trigger_Register_6430); // send to board
} // SetTriggerPolarity6430




//*************************************************************************
//	SetTriggerRepeat6430
//
//	This routine sets the trigger repeat bit.
//
//	Parameters:
//		Repeat:	0 = Single Cycle
//  				1 = Repeat Cycle
//*************************************************************************
void SetTriggerRepeat6430(uint16 Repeat)
{
	Trigger_Register_6430 &= 0xDFFF;
	Trigger_Register_6430 |= Repeat << 13;
	outpw(BaseAddress + r_TRIGGER_6430, Trigger_Register_6430); // send to board
} // SetTriggerRepeat6430




//************************ RESERVED ************************
//	Read at BA + 8





//************************ IRQ REGISTER ***********************************
//	Write at BA + 8

//*************************************************************************
//	LoadIRQRegister6430
//
//	This routine loads the interrupt register with one write operation.
//
//	Parameters:
//		Value:			0 - 65535
//*************************************************************************
void LoadIRQRegister6430(uint16 Value)
{
	IRQ_Register_6430 = Value;
	outpw(BaseAddress + r_IRQ_6430, IRQ_Register_6430); // send to board
} // LoadIRQRegister6430




//*************************************************************************
//	SetIRQ16430
//
//	This routine sets the source and channel for interrupt 1.
//
//	Parameters:
//		Source:		0 = A/D sample counter
//  					1 = A/D start convert
//						2 = A/D End-of-Convert
//						3 = A/D Write FIFO
//						4 = A/D FIFO half full
//						5 = A/D DMA done
//						6 = Reset channel/gain table
//						7 = Pause channel/gain table
//						8 = External Pacer Clock
//						9 = External trigger
//						10 = Digital chip interrupt
//						11 = User TC out 0
//						12 = User TC out 0 inverted
//						13 = User TC out 1
//						14 = Digital Input FIFO half full
//						15 = DIN Write FIFO
//						16 .. 31 = reseved
//
// 	Channel:		0 = disabled
//						3 = IRQ 3
//						5 = IRQ 5
//						9 = IRQ 9
//						10 = IRQ 10
//						11 = IRQ 11
//						12 = IRQ 12
//						15 = IRQ 15
//*************************************************************************
void SetIRQ16430(uint16 Source, uint16 Channel)
{
	switch(Channel) {
		case 3:Channel = 1;
		break;
		case 5: Channel = 2;
		break;
		case 9: Channel = 3;
		break;
		case 10: Channel = 4;
		break;
		case 11: Channel = 5;
		break;
		case 12: Channel = 6;
		break;
		case 15: Channel = 7;
		break;
		default: Channel = 0;
		break;
	}

	IRQ_Register_6430 &= 0xFF00;
	IRQ_Register_6430 |= Source | (Channel << 5);
	outpw(BaseAddress + r_IRQ_6430, IRQ_Register_6430);
} // SetIRQ16430




//*************************************************************************
//	SetIRQ26430
//
//	This routine sets the source and channel for interrupt 2.
//
//	Parameters:
//		Source:		0 = A/D sample counter
//  					1 = A/D start convert
//						2 = A/D End-of-Convert
//						3 = A/D Write FIFO
//						4 = A/D FIFO half full
//						5 = A/D DMA done
//						6 = Reset channel/gain table
//						7 = Pause channel/gain table
//						8 = External Pacer Clock
//						9 = External trigger
//						10 = Digital chip interrupt
//						11 = User TC out 0
//						12 = User TC out 0 inverted
//						13 = User TC out 1
//						14 = Digital Input FIFO half full
//						15 = DIN Write FIFO
//						16 .. 31 = reseved
//
// 	Channel:		0 = disabled
//						3 = IRQ 3
//						5 = IRQ 5
//						9 = IRQ 9
//						10 = IRQ 10
//						11 = IRQ 11
//						12 = IRQ 12
//						15 = IRQ 15
//*************************************************************************
void SetIRQ26430(uint16 Source, uint16 Channel)
{


	switch(Channel) {
		case 3:Channel = 1;
		break;
		case 5: Channel = 2;
		break;
		case 9: Channel = 3;
		break;
		case 10: Channel = 4;
		break;
		case 11: Channel = 5;
		break;
		case 12: Channel = 6;
		break;
		case 15: Channel = 7;
		break;
		default: Channel = 0;
		break;
	}
	IRQ_Register_6430 &= 0x00FF;
	IRQ_Register_6430 |= (Source << 8) | (Channel << 13);
	outpw(BaseAddress + r_IRQ_6430, IRQ_Register_6430);
} // SetIRQ26430




//************************ READ DIGITAL INPUT FIFO **********************************
//	Read at BA + 10

//*************************************************************************
//	ReadDINFIFO6430
//
//	This Routine Reads the Data from the Digital Input FIFO.
//
//	Returns 8 bit value.
//*************************************************************************
uint16  ReadDINFIFO6430(void)
{
	return((uint16) inp(BaseAddress + r_DIN_FIFO_6430));
} // ReadDINFIFO6430




//************************ DIN CONFIG REGISTER ****************************
//	Write at BA + 10

//*************************************************************************
//	LoadDINConfigRegister6430
//
//	This routine loads the Digital Input config register with one write operation.
//
//	Parameters:
//		Value:			0 - 65535
//*************************************************************************
void LoadDINConfigRegister6430(uint16 Value)
{
	DIN_Register_6430 = Value;
	outpw(BaseAddress + r_DIN_CONFIG_6430, DIN_Register_6430); // send to board
} // LoadDACConfigRegister6430




//*************************************************************************
//	ConfigDINClock6430
//
//	This routine configures the Digital Input FIFO clock source.
//
//	Parameters:
//		DIN_Clock:		0 = user T/C out 0
//  						1 = user T/C out 1
//  						2 = write A/D FIFO
//  						3 = external pacer clock
//  						4 = external trigger
//  						5 = reserved
//  						6 = reserved
//  						7 = reserved
//*************************************************************************
void ConfigDINClock6430(uint16 DIN_Clock)
{
	DIN_Register_6430 &= 0xFFF8;
	DIN_Register_6430 |= DIN_Clock;
	outpw(BaseAddress + r_DIN_CONFIG_6430, DIN_Register_6430); // send to board
} // ConfigDINClock6430




//*************************************************************************
//	DINClockEnable6430
//
//	This routine enables the Digital Input FIFO clock.
//
//	Parameters:
//		DIN_Clock:		0 = disabled
//  						1 = enabled
//*************************************************************************
void DINClockEnable6430(uint16 DIN_Clock)
{
	DIN_Register_6430 &= 0xFFF7;
	DIN_Register_6430 |= (DIN_Clock << 3);
	outpw(BaseAddress + r_DIN_CONFIG_6430, DIN_Register_6430); // send to board
} // DINClockEnable6430




//************************ RESERVED *************************
//	Read at BA + 12





//************************ DAC 1 REGISTER *********************************
//	Write at BA + 12

//*************************************************************************
//	LoadDAC6430
//
//	This routine loads the DAC value.
//
//	Parameters:
//		Data:			0 - 65535
//*************************************************************************
void LoadDAC6430(int16 Data)
{
	outpw(BaseAddress + r_DAC1_6430, Data); // send to board
} // LoadDAC6430




//************************ LOAD A/D SAMPLE COUNTER ************************
//	Read at BA + 14

//*************************************************************************
//	LoadADSampleCounter6430
//
//	This routine loads the A/D sample counter.
//
//	Parameters:
//		NumOfSamples:		0 - 65535
//*************************************************************************
void LoadADSampleCounter6430(uint16 NumOfSamples)
{
	SelectTimerCounter6430(1);
	ClockMode6430(2, 2);
	ClockDivisor6430(2, NumOfSamples);
	inpw(BaseAddress + r_LOAD_AD_SAMPLE_COUNT_6430);
	inpw(BaseAddress + r_LOAD_AD_SAMPLE_COUNT_6430);
} // LoadADSampleCounter6430




//************************ TIMER COUNTER ROUTINES **************************

//*************************************************************************
//	ClockMode6430
//
//	This routine is used to set the mode of a designated counter
//	in the 8254 programmable interval timer (PIT).
//
//	Parameters:
//		Timer:		0,1,2
//		Mode:			0,1,2,3,4,5
//*************************************************************************
void ClockMode6430(uchar8 Timer, uchar8 Mode)
{
	uchar8 StatusByte;

	StatusByte = (Timer << 6) + (Mode << 1) + 0x30;
	outp(BaseAddress + r_TIMER_CTRL_6430, StatusByte);
} // ClockMode6430




//*************************************************************************
//	ClockDivisor6430
//
//	This routine is used to set the divisor of a designated
//	counter on the 8254 programmable interval timer (PIT).  This procedure
//	assumes that the counter has already been set to receive the least
//	significant uchar8 (LSB) of the divisor followed by the most significant
//	uchar8 (MSB).
//
//	Parameters:
//		Timer:		0,1,2
//		Divisor:	0 - 65535
//*************************************************************************
void ClockDivisor6430(uchar8 Timer, uint16 Divisor)
{
	uchar8 MSB, LSB;

	LSB = Divisor & 0xff;
	MSB = (Divisor & 0xff00) >> 8;
	outp(BaseAddress + r_TIMER_CLCK0_6430 + (Timer * 2), LSB);
	outp(BaseAddress + r_TIMER_CLCK0_6430 + (Timer * 2), MSB);
} // ClockDivisor6430




//*************************************************************************
//	SetPacerClock6430
//
//	This routine sets the pacer clock rate. It will automatically decide
//	whether to use a 16 or 32 bit clock depending on the rate.
//
//	Parameters:
//		ClockRate:		500 KHz or less
// Returns:
//		The actual clock frequency that is programmed.
//*************************************************************************
float32 SetPacerClock6430(float32 ClockRate)
{
	unsigned long    i, number,loopvalue;
	unsigned long    one, two;
	uint16           mode = 0;

	if (ClockRate > 8000000L/65535L)							// use 16 if you can.
	{
			Trigger_Register_6430 &= 0xFEFF;	              // 16 bit pacer clock
			mode = 0;
	}
	else
	{
			Trigger_Register_6430 |= 0x0100;		            // 32 bit pacer clock
			mode = 1;
	}
	outpw(BaseAddress + r_TRIGGER_6430, Trigger_Register_6430);

	SelectTimerCounter6430(0);
	ClockMode6430(0, 2);
	if (mode)
	{																						// 32 bit mode
			number = 8000000L / ClockRate;
			if ((number/2) > 65535L )
				loopvalue = 65535L;
			else
				loopvalue = number / 2;
	 for (i = 2 ;i <= loopvalue; i++)
		{
			one = i;
			two = number / one;
			if (one*two == number)
				if (two <= 65535L)
			 break;
		} // for
	 if (one*two != number)
		{
			if ((number/2) > 65535L )
				loopvalue = 65535L;
			else
				loopvalue = number / 2;
			for (i = 2 ;i <= loopvalue; i++)
			{
				one = i;
				two = number / one;
				if (two <= 65535L)
				break;
			} // for
		} // if
		ClockDivisor6430(0, (uint16)one);					// set divisor clock 0
																		// this should be the smallest number
																		// of the two.
		ClockMode6430(1, 2);
		ClockDivisor6430(1, (uint16)(two));					// set divisor clock 1
		return(8000000.0 / (float)(one * two));
	} // if (mode)
	else
	{																	//16 bit mode
		ClockDivisor6430(0, (8000000L/ClockRate));
		return(8000000.0 / (int)(8000000L/ClockRate));
	} // else
} // SetPacerClock6430




//*************************************************************************
//	SetBurstClock6430
//
//	This routine sets the burst clock rate.
//
//	Parameters:
//		Burst Rate:		500 KHz or less
// Returns:
//		The actual clock frequency that is programmed.
//*************************************************************************
float32 SetBurstClock6430(float32 BurstRate)
{
	SelectTimerCounter6430(0);
	ClockMode6430(2, 2);
	ClockDivisor6430(2, (8000000L / BurstRate));
	return(8000000.0 / (int)(8000000L/BurstRate));
} // SetBurstClock6430




//*************************************************************************
//	SetUserClock6430
//
//	This routine sets the user timer counters.
//
//	Parameters:
//		Timer:		0, 1, 2
//		InputRate:	Input clock to selected timer.
//		OutputRate:	Desired output rate from selected timer.
//
// Returns:
//		The actual clock frequency that is programmed.
//*************************************************************************
float32 SetUserClock6430(uchar8 Timer, float32 InputRate, float32 OutputRate)
{
	SelectTimerCounter6430(1);

	ClockMode6430(Timer, 2);
	ClockDivisor6430(Timer, (InputRate/OutputRate));

	return(InputRate / (int)(InputRate/OutputRate));

} // SetUserClock6430




//*************************************************************************
//	ReadTimerCounter6430
//
//	This routine is used to read the contents of the selected timer/counter.
//
//	Parameters:
//		Timer:		0,1
//		Clock:		0,1,2
//		Returns:	uint16
//*************************************************************************
uint16 ReadTimerCounter6430(uchar8 Timer, uchar8 Clock)
{
	uchar8 MSB, LSB;

	SelectTimerCounter6430(Timer);

	outp(BaseAddress + r_TIMER_CTRL_6430, (Clock << 6));		//send latch command
	LSB = inp(BaseAddress + r_TIMER_CLCK0_6430 + (Clock * 2));
	MSB = inp(BaseAddress + r_TIMER_CLCK0_6430 + (Clock * 2));
	return((256 * MSB) + LSB);
} // ReadTimerCounter6430




//*************************************************************************
//	DoneTimer6430
//
//	Initialize the timers for high speed to ensure the immediate load.
//
//	Parameters:
//		None
//*************************************************************************
void DoneTimer6430(void)
{
	SelectTimerCounter6430(1);

	ClockMode6430(0, 2);
	ClockMode6430(1, 2);
	ClockDivisor6430(0, 2);
	ClockDivisor6430(1, 2);
} // DoneTimer6430