drvr6430.c

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

//	IsDINFIFOFull6430
//
//	This routine checks to see if the Digital Input FIFO is full.
//
//	Returns:				1 if FIFO is full
//							0 if FIFO is not full
//*************************************************************************
uint16 IsDINFIFOFull6430(void)
{
	uint16 Status;

	Status = inpw(BaseAddress + r_STATUS_6430);
	Status = (Status >> 12) & 1;
	return(!Status);
} // IsDINFIFOFull6430




//*************************************************************************
//	IsIRQ16430
//
//	This routine checks the IRQ 1 status bit.
//
//	Returns:				1 if IRQ has been generated
//							0 if no IRQ
//*************************************************************************
uint16 IsIRQ16430(void)
{
	uint16 Status;

	Status = inpw(BaseAddress + r_STATUS_6430);
	Status = (Status >> 13) & 1;
	return(Status);
} // IsIRQ16430




//*************************************************************************
//	IsIRQ26430
//
//	This routine checks the IRQ 2 status bit.
//
//	Returns:				1 if IRQ has been generated
//							0 if no IRQ
//*************************************************************************
uint16 IsIRQ26430(void)
{
	uint16 Status;

	Status = inpw(BaseAddress + r_STATUS_6430);
	Status = (Status >> 14) & 1;
	return(Status);
} // IsIRQ26430




//************************ CONTROL REGISTER *******************************
//	Write at BA + 2

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




//*************************************************************************
//	EnableTables6430
//
//	This Routine Enables and Disables both the AD and Digital Tables.
//
//	Parameters:
//			Enable_AD_Table:			0 = disable
//    	                	   	1 = enable
// 		Enable_Digital_Table:	0 = disable
//    	                  	 	1 = enable
//*************************************************************************
void EnableTables6430(uint16 Enable_AD_Table, uint16 Enable_Digital_Table)
{
	Control_Register_6430 &= 0xFFF3;
	Control_Register_6430 |= ((Enable_AD_Table<<2) | (Enable_Digital_Table <<3));
	outpw(BaseAddress + r_CONTROL_6430, Control_Register_6430);
} // EnableTables6430




//*************************************************************************
//	ChannelGainDataStore6430
//
//	This routine enables the Channel Gain Data Store feature of the board.
//
//	Parameters:
//			Enable:		0 = Disable
//							1 = Enable
//*************************************************************************
void ChannelGainDataStore6430(uint16 Enable)
{
	Control_Register_6430 &= 0xFFEF;
	Control_Register_6430 |= (Enable << 4);
	outpw(BaseAddress + r_CONTROL_6430, Control_Register_6430); // send to board
} // ChannelGainDataStore6430




//*************************************************************************
//	SelectTimerCounter6430
//
//	This routine selects one of the four 8254 timer chips.
//
//	Parameters:
//		Select:	0 = Clock TC (Pacer & Burst clocks)
//					1 = User TC (A/D sample counter & User timer/counters)
//					2 = reserved
//					3 = reserved
//*************************************************************************
void SelectTimerCounter6430(uint16 Select)
{
	Control_Register_6430 &= 0xFF9F;
	Control_Register_6430 |= (Select << 5);
	outpw(BaseAddress + r_CONTROL_6430, Control_Register_6430); // send to board
} // SelectTimerCounter6430




//*************************************************************************
//	SetADSampleCounterStop6430
//
//	This routine enables and disables the A/D sample counter stop bit.
//
//	Parameters:
//		Enable:	0 = Enable
//  				1 = Disable
//*************************************************************************
void SetSampleCounterStop6430(uint16 Enable)
{
	Control_Register_6430 &= 0xFF7F;
	Control_Register_6430 |= (Enable << 7);
	outpw(BaseAddress + r_CONTROL_6430, Control_Register_6430); // send to board
} // SetSampleCounterStop6430




//*************************************************************************
//	SetADPauseEnable6430
//
//	This routine enables and disables the A/D pause bit.
//
//	Parameters:
//		Enable:	0 = Enable
//  				1 = Disable
//*************************************************************************
void SetPauseEnable6430(uint16 Enable)
{
	Control_Register_6430 &= 0xFEFF;
	Control_Register_6430 |= (Enable << 8);
	outpw(BaseAddress + r_CONTROL_6430, Control_Register_6430); // send to board
} // SetPauseEnable6430




//*************************************************************************
//	SetADDMA6430
//
//	This routine sets the A/D DMA channels.
//
//	Parameters:
//		Channel1:	0 = disabled
//  					5 = DRQ 5
//						6 = DRQ 6
//						7 = DRQ 7
//
//		Channel2:	0 = disabled
//  					5 = DRQ 5
//						6 = DRQ 6
//						7 = DRQ 7
//*************************************************************************
void SetADDMA6430(uint16 Channel1, uint16 Channel2)
{
	switch(Channel1){
		case 5: Channel1 = 1;
		break;
		case 6: Channel1 = 2;
		break;
		case 7: Channel1 = 3;
		break;
		default: Channel1 = 0;
	}
	switch(Channel2){
		case 5: Channel2 = 1;
		break;
		case 6: Channel2 = 2;
		break;
		case 7: Channel2 = 3;
		break;
		default: Channel2 = 0;
	}

	Control_Register_6430 &= 0x0FFF;
	Control_Register_6430 |= (Channel1 << 12) | (Channel2 << 14);
	outpw(BaseAddress + r_CONTROL_6430, Control_Register_6430); // send to board
} // SetADDMA6430




//************************ READ A/D DATA **********************************
//	Read at BA + 4

//*************************************************************************
//	ReadADData6430
//
//	This Routine Reads the Data from the FIFO.
//
//	Returns signed 16 bit AD Data.
//*************************************************************************
int16  ReadADData6430(void)
{
	return((int16) inpw(BaseAddress + r_AD_6430));
} // ReadADData6430




//*************************************************************************
//	ReadChannelGainDataStore6430
//
//	This Routine Reads the Channel/Gain Data from the FIFO when the
// Channel Gain Data Store feature of the board is enabled.
//
//	Returns a 16 bit value: Bottom 8 bits = A/D table value
//									Upper 8 bits  = digital table value
//*************************************************************************
uint16  ReadChannelGainDataStore6430(void)
{
	return((uint16) inpw(BaseAddress + r_AD_6430));
} // ReadChannelGainDataStore6430




//************************ LOAD CHANNEL/GAIN ******************************
//	Write at BA + 4

//*************************************************************************
//	SetChannelGain6430
//
//	This routine loads the channel/gain latch.
//
//	Parameters:
//			Channel:		0 - 15
//
//			Gain:			0 = x1
//							1 = x2
//							2 = x4
//							3 = x8
//							4 = reserved
//							5 = reserved
//							6 = reserved
//							7 = reserved
//
//			Se_Diff:		0 = single ended
//							1 = differential
//*************************************************************************
void SetChannelGain6430(uint16 Channel, uint16 Gain, uint16 Se_Diff)
{
	uint16 B;
	B = (Channel) | (Gain << 4) | (Se_Diff << 9);
	outpw(BaseAddress + r_CHANNEL_GAIN_6430, B);  // send to board
} // SetChannelGain6430




//*************************************************************************
//	LoadADTable6430
//
//	This routine loads the AD Table with the given number of Entrys.
//
//	Parameters:
//	The struct ADTableRow is define in DRVR6430.h
//	typedef struct
//	{
//		uint16 Channel:	0 - 15
//
//		uint16 Gain:		0 = x1
//								1 = x2
//								2 = x4
//								3 = x8
//								4 = reserved
//								5 = reserved
//								6 = reserved
//								7 = reserved
//
//		uint16 Se_Diff:	0 = single ended
//								1 = differential
//
//		uint16 Pause:		0 = disabled
//								1 = enabled
//
//		uint16 Skip:		0 = disabled
//								1 = enabled
//} ADTableRow;
//		Num_of_Entry:	1-1024
//*************************************************************************
void LoadADTable6430(uint16 Num_of_Entry, ADTableRow far *ADTable)
{
	uint16 i;
	uint16 ADEntry;

	Control_Register_6430 &= 0xFFFC;
	Control_Register_6430 |= 0x1;             //Enable loading AD table.
	outpw(BaseAddress + r_CONTROL_6430, Control_Register_6430);

	for (i  = 0 ;i < Num_of_Entry;i++)
	{
		ADEntry = (ADTable[i].Channel) |
					 (ADTable[i].Gain << 4) |
					 (ADTable[i].Se_Diff << 9) |
					 (ADTable[i].Pause << 10) |
					 (ADTable[i].Skip << 11);
		outpw(BaseAddress + r_AD_TABLE_6430, ADEntry);
	} // for
	Control_Register_6430 &= 0xFFFC;             //Disable loading AD table.
	outpw(BaseAddress + r_CONTROL_6430, Control_Register_6430);
} // LoadADTable6430




//*************************************************************************
//	LoadDigitalTable6430
//
//	This routine loads the Digital Table with the given number of Entrys.
//
//	Parameters:
//		Channel:			0 - 255
//		Num_of_Chan:	1 -1024
//*************************************************************************
void LoadDigitalTable6430( uint16 Num_of_Chan, uchar8 far *Channel)
{
	uint16 i;
	Control_Register_6430 &= 0xFFFC;
	Control_Register_6430 |= 0x2;             //Enable loading digital table.
	outpw(BaseAddress + r_CONTROL_6430, Control_Register_6430);
	for (i  = 0 ;i < Num_of_Chan;i++)
	{
		 outpw(BaseAddress + r_DIGITAL_TABLE_6430, Channel[i]);
	} // for
	Control_Register_6430 &= 0xFFFC;           //Disable loading digital table.
	outpw(BaseAddress + r_CONTROL_6430, Control_Register_6430);
} // LoadDigitalTable6430




//************************ START CONVERSION *******************************
//	Read at BA + 6

//*************************************************************************
//	StartConversion6430
//
//	This routine is used to create software triggers or enable hardware
//	triggers depending on the conversion mode.
//
//	Parameters:
//		None
//*************************************************************************
void StartConversion6430(void)
{
	inpw(BaseAddress + r_START_CONVERSION_6430);
} // StartConversion6430




//************************ TRIGGER REGISTER *******************************
//	Write at BA + 6

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




//*************************************************************************
//	SetConversionSelect6430
//
//	This routine selects the conversion mode.
//
//	Parameters:
//		Select:	0 = software trigger
//					1 = pacer clock
//					2 = burst clock
//					3 = digital interrupt
//*************************************************************************
void SetConversionSelect6430(uint16 Select)
{
	Trigger_Register_6430 &= 0xFFFC;
	Trigger_Register_6430 |= Select;
	outpw(BaseAddress + r_TRIGGER_6430, Trigger_Register_6430); // send to board
} // SetConversionSelect6430




//*************************************************************************
//	SetStartTrigger6430
//
//	This routine selects the start trigger.
//
//	Parameters:
//		Start_Trigger:		0 = software trigger
//  							1 = external trigger
//  							2 = digital interrupt
//  							3 = User TC Counter 1 out
//  							4 = reserved
//  							5 = reserved
//  							6 = reserved
//  							7 = gate mode
//*************************************************************************
void SetStartTrigger6430(uint16 Start_Trigger)
{
	Trigger_Register_6430 &= 0xFFE3;
	Trigger_Register_6430 |= Start_Trigger << 2;
	outpw(BaseAddress + r_TRIGGER_6430, Trigger_Register_6430); // send to board
} // SetStartTrigger6430




//*************************************************************************
//	SetStopTrigger6430
//
//	This routine selects the stop trigger.
//
//	Parameters:
//		Stop_Trigger:		0 = software trigger
//  							1 = external trigger
//  							2 = digital interrupt
//  							3 = sample counter
//  							4 = about software trigger
//  							5 = about external trigger
//  							6 = about digital interrupt
//  							7 = about user TC counter 1 out
//*************************************************************************
void SetStopTrigger6430(uint16 Stop_Trigger)
{
	Trigger_Register_6430 &= 0xFF1F;
	Trigger_Register_6430 |= Stop_Trigger << 5;
	outpw(BaseAddress + r_TRIGGER_6430, Trigger_Register_6430); // send to board
} // SetStopTrigger6430




//*************************************************************************
//	SetPacerClockSource6430
//
//	This routine sets the pacer clock source.
//
//	Parameters:
//		Source:	0 = Internal
//  				1 = External
//*************************************************************************
void SetPacerClockSource6430(uint16 Source)
{
	Trigger_Register_6430 &= 0xFDFF;
	Trigger_Register_6430 |= Source << 9;
	outpw(BaseAddress + r_TRIGGER_6430, Trigger_Register_6430); // send to board
} // SetPacerClockSource6430




//*************************************************************************
//	SetBurstTrigger6430
//
//	This routine selects the burst trigger.
//
//	Parameters:
//		Burst_Trigger:		0 = Software trigger
//  							1 = pacer clock
//  							2 = external trigger
//  							3 = digital interrupt
//*************************************************************************
void SetBurstTrigger6430(uint16 Burst_Trigger)
{
	Trigger_Register_6430 &= 0xF3FF;
	Trigger_Register_6430 |= Burst_Trigger << 10;
	outpw(BaseAddress + r_TRIGGER_6430, Trigger_Register_6430); // send to board
} // SetBurstTrigger6430




//*************************************************************************
//	SetTriggerPolarity6430
//
//	This routine sets the external trigger polarity.
//
//	Parameters:
//		Polarity:	0 = positive edge
//  					1 = negative edge