#include "wrRtusbapi.h"

// =============================================================================
//   Библиотека-оболочка к основной Rtusbapi.dll для работы с модулем USB3000
// =============================================================================

//------------------------------------------------------------------------------
// Откроем виртуальный слот для доступа к USB модулю от R-Technology
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI OpenDevice_Usb3000(LPVOID IDevPtr, WORD VirtualSlot)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->OpenDevice(VirtualSlot);
}

//------------------------------------------------------------------------------
// Освободим текущий виртуальный слот
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI CloseDevice_Usb3000(LPVOID IDevPtr)
{
    return (BOOL)((IRTUSB3000 *)IDevPtr)->CloseDevice();
}

//------------------------------------------------------------------------------
// возвращается дескриптор устройства
//------------------------------------------------------------------------------
extern "C" HANDLE WINAPI GetModuleHandle_Usb3000(LPVOID IDevPtr)
{
	return (HANDLE)((IRTUSB3000 *)IDevPtr)->GetModuleHandle();
}

//------------------------------------------------------------------------------
// возвращается текущая скорость работы шины USB
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI GetUsbSpeed_Usb3000(LPVOID IDevPtr, BYTE * const UsbSpeed)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->GetUsbSpeed(UsbSpeed);
}

//------------------------------------------------------------------------------
// читаем название модуля
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI GetModuleName_Usb3000(LPVOID IDevPtr, PCHAR const ModuleName)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->GetModuleName(ModuleName);
}

//------------------------------------------------------------------------------
// получим серийный номер модуля
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI GetModuleSerialNumber_Usb3000(LPVOID IDevPtr, PCHAR const SerialNumber)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->GetModuleSerialNumber(SerialNumber);
}

//------------------------------------------------------------------------------
// читаем номер версии драйвера AVR
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI GetAvrVersion_Usb3000(LPVOID IDevPtr, PCHAR const AvrVersion)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->GetAvrVersion(AvrVersion);
}


//------------------------------------------------------------------------------
//  Освободим указатель на устройство
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI ReleaseInstance_Usb3000(LPVOID IDevPtr)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->ReleaseInstance();
}

//------------------------------------------------------------------------------
// сброс сигнального процессора DSP
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI RESET_DSP_Usb3000(LPVOID IDevPtr)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->RESET_DSP();
}

//------------------------------------------------------------------------------
// функция загрузки драйвера DSP в модуль RTUSB3000
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI LOAD_DSP_Usb3000(LPVOID IDevPtr, PCHAR const FileName)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->LOAD_DSP(FileName);
}

//------------------------------------------------------------------------------
// проверка работоспособности загруженного модуля
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI MODULE_TEST_Usb3000(LPVOID IDevPtr)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->MODULE_TEST();
}

//------------------------------------------------------------------------------
// текущая версия загруженной драйвера DSP
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI GET_DSP_INFO_Usb3000(LPVOID IDevPtr, DSP_INFO_USB3000* const wrDspInfo)
{
	// структура, содержащая информацию о версии драйвера DSP
	RTUSB3000::DSP_INFO di;

	if(!((IRTUSB3000 *)IDevPtr)->GET_DSP_INFO(&di)) return FALSE;
	di.Target[9] = '\0';
	strcpy((char *)wrDspInfo->Target, (char *)di.Target);
	di.Label[5] = '\0';
	strcpy((char *)wrDspInfo->Label, (char *)di.Label);
	wrDspInfo->DspMajor = di.DspMajor;
	wrDspInfo->DspMinor = di.DspMinor;

	return TRUE;
}

//------------------------------------------------------------------------------
// посылка в драйвер DSP модуля номера команды
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI SEND_COMMAND_Usb3000(LPVOID IDevPtr, WORD Command)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->SEND_COMMAND(Command);
}


//------------------------------------------------------------------------------
//  функция выдачи строки с последней ошибкой выполнения интерфейсной функции
//------------------------------------------------------------------------------
extern "C" int WINAPI GetLastErrorString_Usb3000(LPVOID IDevPtr, LPTSTR const lpBuffer, DWORD nSize)
{
	return ((IRTUSB3000 *)IDevPtr)->GetLastErrorString(lpBuffer, nSize);
}



//------------------------------------------------------------------------------
// получение текущих параметров работы модуля в режиме ввода данных
//------------------------------------------------------------------------
extern "C" BOOL WINAPI GET_INPUT_PARS_Usb3000(LPVOID IDevPtr, INPUT_PARS_USB3000 * const wrAp)
{
	WORD i;
	// структура параметров работы АЦП
	RTUSB3000::INPUT_PARS ap;

	ap.size = sizeof(RTUSB3000::INPUT_PARS);
	if(!((IRTUSB3000 *)IDevPtr)->GET_INPUT_PARS(&ap)) return FALSE;

	wrAp->size = sizeof(INPUT_PARS_USB3000);
	wrAp->InputEnabled = ap.InputEnabled;			  			// флажок разрешение/запрещение ввода данных (только при чтении)
	wrAp->CorrectionEnabled = ap.CorrectionEnabled;			// управление корректировкой входных данных (с АЦП)
	wrAp->InputClockSource = ap.InputClockSource;			// источник тактовых импульсов для ввода данных
	wrAp->InputType = ap.InputType;								// тип вводимых с модуля даных (АЦП или ТТЛ)
	wrAp->SynchroType = ap.SynchroType;							// тип синхронизации вводимых с модуля даных
	wrAp->SynchroAdType = ap.SynchroAdType;					// тип аналоговой синхронизации
	wrAp->SynchroAdMode = ap.SynchroAdMode; 					// режим аналоговой сихронизации
	wrAp->SynchroAdChannel = ap.SynchroAdChannel;  			// канал АЦП при аналоговой синхронизации
	wrAp->SynchroAdPorog = ap.SynchroAdPorog; 				// порог срабатывания АЦП при аналоговой синхронизации
	wrAp->ChannelsQuantity = ap.ChannelsQuantity;		  	// число активных логических каналов
	for(i = 0x0; i < 128; i++) wrAp->ControlTable[i] = ap.ControlTable[i];	// управляющая таблица с активными логическими каналами
	wrAp->InputFifoBaseAddress = ap.InputFifoBaseAddress;	// базовый адрес FIFO буфера ввода
	wrAp->InputFifoLength = ap.InputFifoLength;	  			// длина FIFO буфера ввода
	wrAp->InputRate = ap.InputRate;	  			  				// тактовая частота ввода данных в кГц
	wrAp->InterKadrDelay = ap.InterKadrDelay;		  			// межкадровая задержка в мс
	wrAp->ChannelRate = ap.ChannelRate;							// частота ввода фиксированного логического канала
	for(i = 0x0; i < 0x8; i++)
	{
		wrAp->AdcOffsetCoef[i] = ap.AdcOffsetCoef[i]; 	 	// корректировочные коэф. смещение нуля для АЦП
		wrAp->AdcScaleCoef[i] = ap.AdcScaleCoef[i];		 	// корректировочные коэф. масштаба для АЦП
	}

	return TRUE;
}


//------------------------------------------------------------------------------
// заполнение требуемых параметров работы модуля в режиме ввода данных
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI SET_INPUT_PARS_Usb3000(LPVOID IDevPtr, INPUT_PARS_USB3000 * const wrAp)
{
	WORD i;
	// структура параметров работы АЦП
	RTUSB3000::INPUT_PARS ap;

	ap.size = sizeof(RTUSB3000::INPUT_PARS);
	ap.InputEnabled = wrAp->InputEnabled;			  			// флажок разрешение/запрещение ввода данных (только при чтении)
	ap.CorrectionEnabled = wrAp->CorrectionEnabled;			// управление корректировкой входных данных (с АЦП)
	ap.InputClockSource = wrAp->InputClockSource;			// источник тактовых импульсов для ввода данных
	ap.InputType = wrAp->InputType;								// тип вводимых с модуля даных (АЦП или ТТЛ)
	ap.SynchroType = wrAp->SynchroType;							// тип синхронизации вводимых с модуля даных
	ap.SynchroAdType = wrAp->SynchroAdType;					// тип аналоговой синхронизации
	ap.SynchroAdMode = wrAp->SynchroAdMode; 					// режим аналоговой сихронизации
	ap.SynchroAdChannel = wrAp->SynchroAdChannel;  			// канал АЦП при аналоговой синхронизации
	ap.SynchroAdPorog = wrAp->SynchroAdPorog; 				// порог срабатывания АЦП при аналоговой синхронизации
	ap.ChannelsQuantity = wrAp->ChannelsQuantity;		  	// число активных логических каналов
	for(i = 0x0; i < 128; i++) ap.ControlTable[i] = wrAp->ControlTable[i];	// управляющая таблица с активными логическими каналами
	ap.InputFifoBaseAddress = wrAp->InputFifoBaseAddress;	// базовый адрес FIFO буфера ввода
	ap.InputFifoLength = wrAp->InputFifoLength;	  			// длина FIFO буфера ввода
	ap.InputRate = wrAp->InputRate;	  			  				// тактовая частота ввода данных в кГц
	ap.InterKadrDelay = wrAp->InterKadrDelay;		  			// межкадровая задержка в мс
	ap.ChannelRate = wrAp->ChannelRate;							// частота ввода фиксированного логического канала
	for(i = 0x0; i < 0x8; i++)
	{
		ap.AdcOffsetCoef[i] = wrAp->AdcOffsetCoef[i]; 	 	// корректировочные коэф-> смещение нуля для АЦП
		ap.AdcScaleCoef[i] = wrAp->AdcScaleCoef[i];		 	// корректировочные коэф-> масштаба для АЦП
	}

	if(!((IRTUSB3000 *)IDevPtr)->SET_INPUT_PARS(&ap)) return FALSE;

	wrAp->size = sizeof(INPUT_PARS_USB3000);
	wrAp->InputEnabled = ap.InputEnabled;			  			// флажок разрешение/запрещение ввода данных (только при чтении)
	wrAp->CorrectionEnabled = ap.CorrectionEnabled;			// управление корректировкой входных данных (с АЦП)
	wrAp->InputClockSource = ap.InputClockSource;			// источник тактовых импульсов для ввода данных
	wrAp->InputType = ap.InputType;								// тип вводимых с модуля даных (АЦП или ТТЛ)
	wrAp->SynchroType = ap.SynchroType;							// тип синхронизации вводимых с модуля даных
	wrAp->SynchroAdType = ap.SynchroAdType;					// тип аналоговой синхронизации
	wrAp->SynchroAdMode = ap.SynchroAdMode; 					// режим аналоговой сихронизации
	wrAp->SynchroAdChannel = ap.SynchroAdChannel;  			// канал АЦП при аналоговой синхронизации
	wrAp->SynchroAdPorog = ap.SynchroAdPorog; 				// порог срабатывания АЦП при аналоговой синхронизации
	wrAp->ChannelsQuantity = ap.ChannelsQuantity;		  	// число активных логических каналов
	for(i = 0x0; i < 128; i++) wrAp->ControlTable[i] = ap.ControlTable[i];	// управляющая таблица с активными логическими каналами
	wrAp->InputFifoBaseAddress = ap.InputFifoBaseAddress;	// базовый адрес FIFO буфера ввода
	wrAp->InputFifoLength = ap.InputFifoLength;	  			// длина FIFO буфера ввода
	wrAp->InputRate = ap.InputRate;	  			  				// тактовая частота ввода данных в кГц
	wrAp->InterKadrDelay = ap.InterKadrDelay;		  			// межкадровая задержка в мс
	wrAp->ChannelRate = ap.ChannelRate;							// частота ввода фиксированного логического канала
	for(i = 0x0; i < 0x8; i++)
	{
		wrAp->AdcOffsetCoef[i] = ap.AdcOffsetCoef[i]; 	 	// корректировочные коэф. смещение нуля для АЦП
		wrAp->AdcScaleCoef[i] = ap.AdcScaleCoef[i];		 	// корректировочные коэф. масштаба для АЦП
	}

	return TRUE;
}


//------------------------------------------------------------------------------
// запуск потокового ввода данных
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI START_READ_Usb3000(LPVOID IDevPtr)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->START_READ();
}

//------------------------------------------------------------------------------
// останов потокового ввода данных
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI STOP_READ_Usb3000(LPVOID IDevPtr)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->STOP_READ();
}

//------------------------------------------------------------------------------
// ввод кадра отсчетов с логических каналов модуля
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI READ_KADR_Usb3000(LPVOID IDevPtr, SHORT * const Data)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->READ_KADR(Data);
}

//------------------------------------------------------------------------------
// однократный ввод с заданного логического канала модуля
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI READ_SAMPLE_Usb3000(LPVOID IDevPtr, WORD Channel, SHORT * const Sample)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->READ_SAMPLE(Channel, Sample);
}

//------------------------------------------------------------------------
// потоковое чтение данных из модуля
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI ReadData_Usb3000(LPVOID IDevPtr, SHORT * const lpBuffer, DWORD * const nNumberOfWordsToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->ReadData(lpBuffer, nNumberOfWordsToRead, lpNumberOfBytesRead, lpOverlapped);
}




//------------------------------------------------------------------------------
// получение текущих параметров работы модуля в режиме вывода данных
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI GET_OUTPUT_PARS_Usb3000(LPVOID IDevPtr, OUTPUT_PARS_USB3000 * const wrDp)
{
	// структура, содержащая параметры работы при выводе данных
	RTUSB3000::OUTPUT_PARS dp;

	dp.size = sizeof(RTUSB3000::OUTPUT_PARS);
	if(!((IRTUSB3000 *)IDevPtr)->GET_OUTPUT_PARS(&dp)) return FALSE;

	wrDp->size = sizeof(OUTPUT_PARS_USB3000);
	wrDp->OutputEnabled = dp.OutputEnabled;						// разрешение/запрещение вывода данных
	wrDp->OutputRate = dp.OutputRate;	  		  					// частота вывода данных в кГц
	wrDp->OutputFifoBaseAddress = dp.OutputFifoBaseAddress; 	// базовый адрес FIFO буфера вывода
	wrDp->OutputFifoLength = dp.OutputFifoLength;				// длина FIFO буфера вывода

	return TRUE;
}

//------------------------------------------------------------------------------
// заполнение требуемых параметров работы модуля в режиме вывода данных
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI SET_OUTPUT_PARS_Usb3000(LPVOID IDevPtr, OUTPUT_PARS_USB3000 * const wrDp)
{
	// структура, содержащая параметры работы при выводе данных
	RTUSB3000::OUTPUT_PARS dp;

	dp.size = sizeof(RTUSB3000::OUTPUT_PARS);
	dp.OutputEnabled = wrDp->OutputEnabled;						// разрешение/запрещение вывода данных
	dp.OutputRate = wrDp->OutputRate;	  		  					// частота вывода данных в кГц
	dp.OutputFifoBaseAddress = wrDp->OutputFifoBaseAddress; 	// базовый адрес FIFO буфера вывода
	dp.OutputFifoLength = wrDp->OutputFifoLength;				// длина FIFO буфера вывода

	if(!((IRTUSB3000 *)IDevPtr)->SET_OUTPUT_PARS(&dp)) return FALSE;

	wrDp->size = sizeof(OUTPUT_PARS_USB3000);
	wrDp->OutputEnabled = dp.OutputEnabled;						// разрешение/запрещение вывода данных
	wrDp->OutputRate = dp.OutputRate;	  		  					// частота вывода данных в кГц
	wrDp->OutputFifoBaseAddress = dp.OutputFifoBaseAddress; 	// базовый адрес FIFO буфера вывода
	wrDp->OutputFifoLength = dp.OutputFifoLength;				// длина FIFO буфера вывода

	return TRUE;
}

//------------------------------------------------------------------------------
// запуск потокового вывода данных
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI START_WRITE_Usb3000(LPVOID IDevPtr)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->START_WRITE();
}

//------------------------------------------------------------------------------
// останов потокового вывода данных
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI STOP_WRITE_Usb3000(LPVOID IDevPtr)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->STOP_WRITE();
}

//------------------------------------------------------------------------------
// потоковая передача данных ЦАП в модуль
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI WriteData_Usb3000(LPVOID IDevPtr, SHORT * const lpBuffer, DWORD * const nNumberOfWordsToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->WriteData(lpBuffer, nNumberOfWordsToWrite, lpNumberOfBytesWritten, lpOverlapped);
}

//------------------------------------------------------------------------------
// однократный вывод отсчёта
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI WRITE_SAMPLE_Usb3000(LPVOID IDevPtr, WORD Channel, SHORT * const Sample)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->WRITE_SAMPLE(Channel, Sample);
}


//------------------------------------------------------------------------------
// функция разрешения выходных линий внешнего цифрового разъёма
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI ENABLE_TTL_OUT_Usb3000(LPVOID IDevPtr, BOOL EnableTtlOut)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->ENABLE_TTL_OUT(EnableTtlOut);
}

//------------------------------------------------------------------------------
// функция чтения входных линий внешнего цифрового разъёма
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI TTL_IN_Usb3000(LPVOID IDevPtr, WORD * const TtlIn)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->TTL_IN(TtlIn);
}

//------------------------------------------------------------------------------
// функция вывода на выходные линий внешнего цифрового разъёма
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI TTL_OUT_Usb3000(LPVOID IDevPtr, WORD TtlOut)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->TTL_OUT(TtlOut);
}

//------------------------------------------------------------------------------
// разрешение/запрещение режима записи в ППЗУ модуля
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI ENABLE_FLASH_WRITE_Usb3000(LPVOID IDevPtr, BOOL EnableFlashWrite)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->ENABLE_FLASH_WRITE(EnableFlashWrite);
}

//------------------------------------------------------------------------
// запись структуры типа FLASH в пользовательское ППЗУ
//------------------------------------------------------------------------
extern "C" BOOL WINAPI PUT_FLASH_Usb3000(LPVOID IDevPtr, FLASH_USB3000* const wrFi)
{
	WORD i;
	// структура информации в ППЗУ модуля
	RTUSB3000::FLASH fi;

	fi.CRC16 = wrFi->CRC16;										// контрольная сумма
	fi.size = sizeof(RTUSB3000::FLASH);						// размер данной структуры в байтах
	for(i = 0x0; i < 9; i++)
		fi.SerialNumber[i] = wrFi->SerialNumber[i];		// серийный номер модуля
	for(i = 0x0; i < 11; i++)
		fi.Name[i] = wrFi->Name[i];							// название модуля
	fi.Revision = wrFi->Revision;								// ревизия модуля
	for(i = 0x0; i < 17; i++)
		fi.DspType[i] = wrFi->DspType[i];					// тип установленного DSP
	fi.IsDacPresented = wrFi->IsDacPresented; 			// флажок наличия ЦАП
	fi.DspClockout = wrFi->DspClockout; 					// тактовая частота DSP в Гц
  	for(i = 0x0; i < 8; i++)
	{
		fi.AdcOffsetCoef[i] = wrFi->AdcOffsetCoef[i];	// корректировочные коэф. смещения нуля для АЦП
		fi.AdcScaleCoef[i] = wrFi->AdcScaleCoef[i];		// корректировочные коэф. масштаба для АЦП
	}
	for(i = 0x0; i < 2; i++)
	{
		fi.DacOffsetCoef[i] = wrFi->DacOffsetCoef[i];	// корректировочные коэф. смещения нуля для ЦАП
		fi.DacScaleCoef[i] = wrFi->DacScaleCoef[i];		// корректировочные коэф. масштаба для ЦАП
	}
	for(i = 0x0; i < 129; i++)
		fi.ReservedByte[i] = wrFi->ReservedByte[i];		// зарезервировано

	if(!((IRTUSB3000 *)IDevPtr)->PUT_FLASH(&fi)) return FALSE;

	wrFi->CRC16 = fi.CRC16;										// контрольная сумма
	wrFi->size = sizeof(FLASH_USB3000);						// размер данной структуры в байтах

   return TRUE;
}

//------------------------------------------------------------------------
// чтение структуры типа FLASH из пользовательского ППЗУ
//------------------------------------------------------------------------
extern "C" BOOL WINAPI GET_FLASH_Usb3000(LPVOID IDevPtr, FLASH_USB3000 * const wrFi)
{
	WORD i;
	// структура информации в ППЗУ модуля
	RTUSB3000::FLASH fi;

	fi.size = sizeof(RTUSB3000::FLASH);						// размер данной структуры в байтах
	// зачитаем информацию из ППЗУ модуля
	if(!((IRTUSB3000 *)IDevPtr)->GET_FLASH(&fi)) return FALSE;

	wrFi->CRC16 = fi.CRC16;										// контрольная сумма
	wrFi->size = sizeof(FLASH_USB3000);						// размер данной структуры в байтах
	fi.SerialNumber[8] = '\0';
	for(i = 0x0; i < 9; i++)
		wrFi->SerialNumber[i] = fi.SerialNumber[i];		// серийный номер модуля
	fi.Name[10] = '\0';
	for(i = 0x0; i < 11; i++)
		wrFi->Name[i] = fi.Name[i];							// название модуля
	wrFi->Revision = fi.Revision;								// ревизия модуля
	fi.DspType[16] = '\0';
	for(i = 0x0; i < 17; i++)
		wrFi->DspType[i] = fi.DspType[i];					// тип установленного DSP
	wrFi->IsDacPresented = fi.IsDacPresented; 			// флажок наличия ЦАП
	wrFi->DspClockout = fi.DspClockout; 					// тактовая частота DSP в Гц
  	for(i = 0x0; i < 8; i++)
	{
		wrFi->AdcOffsetCoef[i] = fi.AdcOffsetCoef[i];	// корректировочные коэф. смещения нуля для АЦП
		wrFi->AdcScaleCoef[i] = fi.AdcScaleCoef[i];		// корректировочные коэф. масштаба для АЦП
	}
	for(i = 0x0; i < 2; i++)
	{
		wrFi->DacOffsetCoef[i] = fi.DacOffsetCoef[i];	// корректировочные коэф. смещения нуля для ЦАП
		wrFi->DacScaleCoef[i] = fi.DacScaleCoef[i];		// корректировочные коэф. масштаба для ЦАП
	}
	for(i = 0x0; i < 129; i++)
		wrFi->ReservedByte[i] = fi.ReservedByte[i];		// зарезервировано

   return TRUE;
}


//------------------------------------------------------------------------------
// запись слова в область переменных в памяти программ драйвера DSP
//------------------------------------------------------------------------------
extern "C" BOOL WINAPI PUT_VAR_WORD_Usb3000(LPVOID IDevPtr, WORD Address, SHORT Data)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->PUT_VAR_WORD(Address, Data);
}

//------------------------------------------------------------------------
// чтение слова из область переменных  в памяти программ драйвера DSP
//------------------------------------------------------------------------
extern "C" BOOL WINAPI GET_VAR_WORD_Usb3000(LPVOID IDevPtr, WORD Address, SHORT * const Data)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->GET_VAR_WORD(Address, Data);
}

//------------------------------------------------------------------------
// запись слова в ячейку памяти данных драйвера DSP
//------------------------------------------------------------------------
extern "C" BOOL WINAPI PUT_DM_WORD_Usb3000(LPVOID IDevPtr, WORD Address, SHORT Data)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->PUT_DM_WORD(Address, Data);
}

//------------------------------------------------------------------------
// чтение слова из ячейки памяти данных драйвера DSP
//------------------------------------------------------------------------
extern "C" BOOL WINAPI GET_DM_WORD_Usb3000(LPVOID IDevPtr, WORD Address, SHORT * const Data)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->GET_DM_WORD(Address, Data);
}

//------------------------------------------------------------------------
// запись слова в ячейку памяти программ драйвера DSP
//------------------------------------------------------------------------
extern "C" BOOL WINAPI PUT_PM_WORD_Usb3000(LPVOID IDevPtr, WORD Address, LONG Data)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->PUT_PM_WORD(Address, Data);
}

//------------------------------------------------------------------------
// чтение слова из ячейки памяти программ драйвера DSP
//------------------------------------------------------------------------
extern "C" BOOL WINAPI GET_PM_WORD_Usb3000(LPVOID IDevPtr, WORD Address, LONG * const Data)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->GET_PM_WORD(Address, Data);
}

//------------------------------------------------------------------------
// запись массива слов в область памяти данных драйвера DSP
//------------------------------------------------------------------------
extern "C" BOOL WINAPI PUT_DM_ARRAY_Usb3000(LPVOID IDevPtr, WORD BaseAddress, WORD NPoints, SHORT * const Data)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->PUT_DM_ARRAY(BaseAddress, NPoints, Data);
}

//------------------------------------------------------------------------
// чтение массива слов из области памяти данных драйвера DSP
//------------------------------------------------------------------------
extern "C" BOOL WINAPI GET_DM_ARRAY_Usb3000(LPVOID IDevPtr, WORD BaseAddress, WORD NPoints, SHORT * const Data)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->GET_DM_ARRAY(BaseAddress, NPoints, Data);
}

//------------------------------------------------------------------------
// запись массива слов в область память данных драйвера DSP
//------------------------------------------------------------------------
extern "C" BOOL WINAPI PUT_PM_ARRAY_Usb3000(LPVOID IDevPtr, WORD BaseAddress, WORD NPoints, LONG * const Data)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->PUT_PM_ARRAY(BaseAddress, NPoints, Data);
}

//------------------------------------------------------------------------
// чтение массива слов из области памяти данных драйвера DSP
//------------------------------------------------------------------------
extern "C" BOOL WINAPI GET_PM_ARRAY_Usb3000(LPVOID IDevPtr, WORD BaseAddress, WORD NPoints, LONG * const Data)
{
	return (BOOL)((IRTUSB3000 *)IDevPtr)->GET_PM_ARRAY(BaseAddress, NPoints, Data);
}

