read.cpp

//******************************************************************************
//êîíñîëüíàÿ ïðîãðàììà äëÿ ââîäà äàííûõ â ÐÑ èç ìîäóëÿ USB3000
//******************************************************************************
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include "Rtusbapi.h"

// àâàðèéíîå çàâåðøåíèå ïðîãðàììû
void TerminateApplication(char *ErrorString, bool TerminationFlag = true);
// îæèäàíèå çàâåðøåíèÿ î÷åðåäíîãî çàïðîñà íà ââîä äàííûõ
bool WaitingForRequestCompleted(OVERLAPPED *ReadOv);
// îòîáðàæåíèå îøèáîê âûïîëíåíèÿ ïðîãðàììû
void ShowThreadErrorMessage(void);

// ôóíêöèÿ ïîòîêà ââîäà äàííûõ ñ ìîäóëÿ
DWORD 	WINAPI ServiceReadThread(PVOID /*Context*/);
// èäåíòèôèêàòîð ïîòîêà ââîäà
HANDLE 	hReadThread;
DWORD 	ReadTid;

// èäåíòèôèêàòîð ôàéëà äëÿ çàïèñè ïîëó÷åííûõ äàííûõ
HANDLE hFile;

// òåêóùàÿ âåðñèÿ áèáëèîòåêè Rtusbapi.dll
DWORD DllVersion;
// óêàçàòåëü íà èíòåðôåéñ ìîäóëÿ
IRTUSB3000 *pModule;
// õýíäë ìîäóëÿ
HANDLE ModuleHandle;
// íàçâàíèå ìîäóëÿ
char ModuleName[10];
// ñêîðîñòü ðàáîòû øèíû USB
BYTE UsbSpeed;
// ñåðèéíûé íîìåð ìîäóëÿ
char ModuleSerialNumber[9];
// âåðñèÿ äðàéâåðà AVR
char AvrVersion[5];
// ñòðóêòóðà, ñîäåðæàùàÿ èíôîðìàöèþ î âåðñèè äðàéâåðà DSP
RTUSB3000::DSP_INFO di;
// ñòðóêòóðà èíôîðìàöèè â ÏÏÇÓ ìîäóëÿ
RTUSB3000::FLASH fi;
// ñòðóêòóðà ïàðàìåòðîâ ðàáîòû ÀÖÏ
RTUSB3000::INPUT_PARS ip;

// ìàêñèìàëüíî âîçìîæíîå êîë-âî îïðàøèâàåìûõ âèðòóàëüíûõ ñëîòîâ
const WORD MaxVirtualSoltsQuantity = 127;
// ÷àñòîòà  ââîäà äàííûõ
const double ReadRate = 5.0; 

//max âîçìîæíîå êîë-âî ïåðåäàâàåìûõ îòñ÷åòîâ (êðàòíîå 32) äëÿ ô. ReadData è WriteData()
DWORD DataStep = 1024*8;
// ñòîëüêî áëîêîâ ïî DataStep îòñ÷¸òîâ íóæíî ñîáðàòü â ôàéë
const WORD NBlockRead = 3;
// óêàçàòåëü íà áóôåð äëÿ ââîäèìûõ äàííûõ
SHORT	*ReadBuffer;

// ýêðàííûé ñ÷åò÷èê-èíäèêàòîð
DWORD Counter = 0x0, OldCounter = 0xFFFFFFFF;

// íîìåð îøèáêè ïðè âûïîëíåíèè ïîòîêà ñáîðà äàííûõ
WORD ThreadErrorNumber;
// ôëàæîê çàâåðøåíèÿ ïîòîêîâ ââîäà äàííûõ
bool IsThreadComplete = false;


//------------------------------------------------------------------------
// îñíîâíàÿ ïðîãðàììà
//------------------------------------------------------------------------
void main(int argc, char* argv[])
{
		WORD i;
		int iSize = MultiByteToWideChar(CP_ACP, 0, argv[1], -1, NULL, 0);
		LPWSTR wsavefile = new WCHAR[iSize];
		MultiByteToWideChar(CP_ACP, 0, argv[1], -1, wsavefile, iSize);

		//printf(" **********************************************\n");
		//printf(" Data Reading Console from USB3000 unit \n");
		//printf(" **********************************************\n\n");

		// ïðîâåðèì âåðñèþ èñïîëüçóåìîé áèáëèîòåêè Rtusbapi.dll
		if((DllVersion = RtGetDllVersion()) != CURRENT_VERSION_RTUSBAPI) 
		{	
				char String[128];
				sprintf(String, " Rtusbapi.dll Version Error!!!\n   Current: %1u.%1u. Required: %1u.%1u",
						DllVersion >> 0x10, DllVersion & 0xFFFF,
						CURRENT_VERSION_RTUSBAPI >> 0x10, CURRENT_VERSION_RTUSBAPI & 0xFFFF);
		
				TerminateApplication(String);
		}		
		//else printf(" Rtusbapi.dll Version --> OK\n");

		// ïîëó÷èì óêàçàòåëü íà èíòåðôåéñ ìîäóëÿ USB3000
		pModule = static_cast<IRTUSB3000 *>(RtCreateInstance("usb3000"));
		if(!pModule) TerminateApplication(" Module Interface --> Bad\n");
		//else printf(" Module Interface --> OK\n");

		// ïîïðîáóåì îáíàðóæèòü ìîäóëü USB3000 â ïåðâûõ 127 âèðòóàëüíûõ ñëîòàõ
		for(i = 0x0; i < MaxVirtualSoltsQuantity; i++) if(pModule->OpenDevice(i)) break;
		// ÷òî-íèáóäü îáíàðóæèëè?
		if(i == MaxVirtualSoltsQuantity) TerminateApplication(" Can't find module USB3000 in first 127 virtual slots!\n");
		//else printf(" OpenDevice(%u) --> OK\n", i);

		// ïîïðîáóåì ïîëó÷èòü äåñêðèïòîð (handle) óñòðîéñòâà
		ModuleHandle = pModule->GetModuleHandle();
		if(ModuleHandle == INVALID_HANDLE_VALUE) TerminateApplication(" GetModuleHandle() --> Bad\n");
		//else printf(" GetModuleHandle() --> OK\n");

		// ïðî÷èòàåì íàçâàíèå îáíàðóæåííîãî ìîäóëÿ
		if(!pModule->GetModuleName(ModuleName)) TerminateApplication(" GetModuleName() --> Bad\n");
		//else printf(" GetModuleName() --> OK\n");

		// ïðîâåðèì, ÷òî ýòî 'USB3000'
		if(strcmp(ModuleName, "USB3000")) TerminateApplication(" The module is not 'USB3000'\n");
		//else printf(" The module is 'USB3000'\n");

		// óçíàåì òåêóùóþ ñêîðîñòü ðàáîòû øèíû USB20
		if(!pModule->GetUsbSpeed(&UsbSpeed)) TerminateApplication(" GetUsbSpeed() --> Bad\n");
		//else printf(" GetUsbSpeed() --> OK\n");
		// òåïåðü îòîáðàçèì âåðñèþ äðàéâåðà AVR
		//printf(" USB Speed is %s\n", UsbSpeed ? "HIGH (480 Mbit/s)" : "FULL (12 Mbit/s)");

		// ïðî÷èòàåì ñåðèéíûé íîìåð ìîäóëÿ
		if(!pModule->GetModuleSerialNumber(ModuleSerialNumber)) TerminateApplication(" GetModuleSerialNumber() --> Bad\n");
		//else printf(" GetModuleSerialNumber() --> OK\n");
		// òåïåðü îòîáðàçèì ñåðèéíûé íîìåð ìîäóëÿ
		//printf(" Module Serial Number is %s\n", ModuleSerialNumber);

		// ïðî÷èòàåì âåðñèþ äðàéâåðà AVR
		if(!pModule->GetAvrVersion(AvrVersion)) TerminateApplication(" GetAvrVersion() --> Bad\n");
		//else printf(" GetAvrVersion() --> OK\n");
		// òåïåðü îòîáðàçèì âåðñèþ äðàéâåðà AVR
		//printf(" Avr Driver Version is %s\n", AvrVersion);

		// êîä äðàéâåðà DSP âîçüì¸ì èç ñîîòâåòñòâóþùåãî ðåñóðñà øòàòíîé DLL áèáëèîòåêè
		if(!pModule->LOAD_DSP()) TerminateApplication(" LOAD_DSP() --> Bad\n");
		//else printf(" LOAD_DSP() --> OK\n");

		// ïðîâåðèì çàãðóçêó ìîäóëÿ
		if(!pModule->MODULE_TEST()) TerminateApplication(" MODULE_TEST() --> Bad\n");
		//else printf(" MODULE_TEST() --> OK\n");

		// ïîëó÷èì âåðñèþ çàãðóæåííîãî äðàéâåðà DSP
		if(!pModule->GET_DSP_INFO(&di)) TerminateApplication(" GET_DSP_VERSION() --> Bad\n");
		//else printf(" GET_DSP_VERSION() --> OK\n");
		// òåïåðü îòîáðàçèì âåðñèþ çàãðóæåííîãî äðàéâåðà DSP
		//printf(" DSP Driver version is %1u.%1u\n", di.DspMajor, di.DspMinor);

		// îáÿçàòåëüíî ïðîèíèöèàëèçèðóåì ïîëå size ñòðóêòóðû RTUSB3000::FLASH
		fi.size = sizeof(RTUSB3000::FLASH);
		// ïîëó÷èì èíôîðìàöèþ èç ÏÏÇÓ ìîäóëÿ
		if(!pModule->GET_FLASH(&fi)) TerminateApplication(" GET_MODULE_DESCR() --> Bad\n");
		//else printf(" GET_MODULE_DESCR() --> OK\n");

		// îáÿçàòåëüíî ïðîèíèöèàëèçèðóåì ïîëå size ñòðóêòóðû RTUSB3000::INPUT_PARS
		ip.size = sizeof(RTUSB3000::INPUT_PARS);
		// ïîëó÷èì òåêóùèå ïàðàìåòðû ðàáîòû ÀÖÏ
		if(!pModule->GET_INPUT_PARS(&ip)) TerminateApplication(" GET_INPUT_PARS() --> Bad\n");
		//else printf(" GET_INPUT_PARS() --> OK\n");

		// óñòàíîâèì æåëàåìûå ïàðàìåòðû ÀÖÏ
		ip.CorrectionEnabled = true;				// ðàçðåøèì êîððåêòèðîâêó ââîäèìûõ äàííûõ
		ip.InputClockSource = RTUSB3000::INTERNAL_INPUT_CLOCK;	// áóäåì èñïîëüçîâàòü âíóòðåííèå òàêòîâûå èñïóëüñû äëÿ ââîäà äàííûõ
//	ip.InputClockSource = RTUSB3000::EXTERNAL_INPUT_CLOCK;	// áóäåì èñïîëüçîâàòü âíåøíèå òàêòîâûå èñïóëüñû äëÿ ââîäà äàííûõ
		ip.SynchroType = RTUSB3000::NO_SYNCHRO;	// íå áóäåì èñïîëüçîâàòü íèêàêóþ ñèíõðîíèçàöèþ ïðè ââîäå äàííûõ  
//	ip.SynchroType = RTUSB3000::TTL_START_SYNCHRO;	// áóäåì èñïîëüçîâàòü öèôðîâóþ ñèíõðîíèçàöèþ ñòàðòà ïðè ââîäå äàííûõ  
		ip.ChannelsQuantity = 0x4;					// ÷åòûðå àêòèâíûõ êàíàëà
		for(i = 0x0; i < ip.ChannelsQuantity; i++) ip.ControlTable[i] = (WORD)(i);
		//ip.ControlTable[0] = (WORD)(channel1);
		//ip.ControlTable[1] = (WORD)(channel2);
		ip.InputRate = ReadRate;					// ÷àñòîòà ðàáîòû ÀÖÏ â êÃö
		ip.InterKadrDelay = 0.0;					// ìåæêàäðîâàÿ çàäåðæêà - ïîêà âñåãäà óñòàíàâëèâàòü â 0.0
		ip.InputFifoBaseAddress = 0x0;  			// áàçîâûé àäðåñ FIFO áóôåðà ÀÖÏ
		ip.InputFifoLength = 0x3000;	 			// äëèíà FIFO áóôåðà ÀÖÏ
		// áóäåì èñïîëüçîâàòü ôèðìåííûå êàëèáðîâî÷íûå êîýôôèöèåíòû, êîòîðûå õðàíÿòüñÿ â ÏÏÇÓ ìîäóëÿ
		for(i = 0x0; i < 8; i++) { ip.AdcOffsetCoef[i] = fi.AdcOffsetCoef[i]; ip.AdcScaleCoef[i] = fi.AdcScaleCoef[i]; }
		// ïåðåäàäèì òðåáóåìûå ïàðàìåòðû ðàáîòû ÀÖÏ â ìîäóëü
		if(!pModule->SET_INPUT_PARS(&ip)) TerminateApplication(" SET_INPUT_PARS() --> Bad\n");
		//else printf(" SET_INPUT_PARS() --> OK\n");

		// îòîáðàçèì íà ýêðàíå äèñïëåÿ ïàðàìåòðû ðàáîòû ìîäóëÿ USB3000
		//printf(" \n");
		//printf(" Module USB3000 (S/N %s) is ready ... \n", ModuleSerialNumber);
		//printf(" Adc parameters:\n");
		//printf("   InputClockSource is %s\n", ip.InputClockSource ? "EXTERNAL" : "INTERNAL");
		//printf("   SynchroType is %s\n", ip.SynchroType ? "TTL_START_SYNCHRO" : "NO_SYNCHRO");
		//printf("   ChannelsQuantity = %2d\n", ip.ChannelsQuantity);
		printf("   AdcRate = %8.3f kHz\n", ip.InputRate);
		//printf("   InterKadrDelay = %2.4f ms\n", ip.InterKadrDelay);
		printf("   ChannelRate = %8.3f kHz\n", ip.ChannelRate);

		// ïîêà îòêûòîãî ôàéëà íåò :(
		hFile = INVALID_HANDLE_VALUE;
		// ñáðîñèì ôëàã îøèáîê ïîòîêà ââîäà äàííûõ
		ThreadErrorNumber = 0x0;

		// ïîïðîáóåì âûäåëèòü ïàìÿòü ïîä áóôåð äëÿ ââîäèìûõ ñ ìîäóëÿ äàííûõ
		ReadBuffer = new SHORT[NBlockRead * DataStep];
		if(!ReadBuffer) TerminateApplication(" Cannot allocate memory for ReadBuffer\n");

		// Ñîçäàåì è çàïóñêàåì ïîòîê ñáîðà ââîäà äàííûõ èç ìîäóëÿ
		hReadThread = CreateThread(0, 0x2000, ServiceReadThread, 0, 0, &ReadTid);
		if(!hReadThread) TerminateApplication("Cann't start input data thread!");

		// æäåì çàâåðøåíèÿ ðàáîòû íóæíîãî ïîòîêà
		printf("\n");
		while(!IsThreadComplete)
		{
				if(OldCounter != Counter)
				{
						//printf(" Counter %3u from %3u\r", Counter, NBlockRead);
						OldCounter = Counter;
				}
				else Sleep(20);
		}

		// æä¸ì îêîí÷àíèÿ ðàáîòû ïîòîêà ââîäà äàííûõ
		WaitForSingleObject(hReadThread, INFINITE);
		// äâå ïóñòûå ñòðî÷êè
		printf("\n\n");

		// åñëè íå áûëî îøèáîê ââîäà äàííûõ - çàïèøåì ïîëó÷åííûå äàííûå â ôàéë
		if(!ThreadErrorNumber)
		{
				// îòêðîåì ôàéë äëÿ çàïèñè ïîëó÷åííûõ äàííûõ
				hFile = CreateFile(wsavefile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
				if(hFile == INVALID_HANDLE_VALUE) TerminateApplication(" Open file --> Failed!!!\n");
				//else printf(" CreateFile --> Ok\n");

				// òåïåðü çàïèøåì â ôàéë ïîëó÷åííûå äàííûå
				DWORD FileBytesWritten = 0x0;
				if(!WriteFile(	hFile,							// handle to file to write to
								ReadBuffer,						// pointer to data to write to file
								2*NBlockRead*DataStep,		// number of bytes to write
								&FileBytesWritten,			// pointer to number of bytes written
								NULL			  					// pointer to structure needed for overlapped I/O
						   ))  TerminateApplication(" WriteFile --> Failed!!!");
				//else printf(" WriteFile --> Ok\n");
		}		
		delete wsavefile;
		// åñëè áûëà îøèáêà - ñîîáùèì îá ýòîì
		if(ThreadErrorNumber) { TerminateApplication(NULL, false); ShowThreadErrorMessage(); }
		else { printf("\n"); TerminateApplication("\n The program was completed successfully!!!\n", false); }
}

//------------------------------------------------------------------------
// Ïîòîê â êîòîðîì îñóùåñòâëÿåòñÿ ââîä äàííûõ â ÐÑ èç ìîäóëÿ
//------------------------------------------------------------------------
DWORD WINAPI ServiceReadThread(PVOID /*Context*/)
{
		WORD i;
		// íîìåð çàïðîñà íà ñáîð äàííûõ
		WORD RequestNumber;
		// èäåíòèôèêàòîð ìàññèâà èõ äâóõ ñîáûòèé
		HANDLE ReadEvent[2];
		// ìàññèâ OVERLAPPED ñòðóêòóð èç äâóõ ýëåìåíòîâ
		OVERLAPPED ReadOv[2];
		DWORD BytesTransferred[2];
//	DWORD TimeOut;

		// îñòàíîâèì ââîä äàííûõ è îäíîâðåìåííî ïðî÷èñòèì ñîîòâåòñòâóþùèé êàíàë bulk USB
		if(!pModule->STOP_READ()) { ThreadErrorNumber = 0x6; IsThreadComplete = true; return 0; }

		// ñîçäàäèì äâà ñîáûòèÿ
		ReadEvent[0] = CreateEvent(NULL, FALSE , FALSE, NULL);
		memset(&ReadOv[0], 0, sizeof(OVERLAPPED)); ReadOv[0].hEvent = ReadEvent[0];
		ReadEvent[1] = CreateEvent(NULL, FALSE , FALSE, NULL);
		memset(&ReadOv[1], 0, sizeof(OVERLAPPED)); ReadOv[1].hEvent = ReadEvent[1];

		// òàéìàóò ââîäà äàííûõ
//	TimeOut = (DWORD)(DataStep/ReadRate + 1000);

		// äåëàåì ïðåäâàðèòåëüíûé çàïðîñ íà ââîä äàííûõ
		RequestNumber = 0x0;
		if(!pModule->ReadData(ReadBuffer, &DataStep, &BytesTransferred[RequestNumber], &ReadOv[RequestNumber]))
				if(GetLastError() != ERROR_IO_PENDING) { CloseHandle(ReadEvent[0]); CloseHandle(ReadEvent[1]); ThreadErrorNumber = 0x2; IsThreadComplete = true; return 0; }

		// òåïåðü çàïóñêàåì ââîä äàííûõ
		if(pModule->START_READ())
		{
				// öèêë ñáîðà äàííûõ
				for(i = 0x1; i < NBlockRead; i++)
				{
						RequestNumber ^= 0x1;
						// ñäåëàåì çàïðîñ íà î÷åðåäíóþ ïîðöèè äàííûõ
						if(!pModule->ReadData(ReadBuffer + i*DataStep, &DataStep, &BytesTransferred[RequestNumber], &ReadOv[RequestNumber]))
								if(GetLastError() != ERROR_IO_PENDING) { ThreadErrorNumber = 0x2; break; }

						// æä¸ì îêîí÷àíèÿ îïåðàöèè ñáîðà î÷åðåäíîé ïîðöèè äàííûõ
						if(!WaitingForRequestCompleted(&ReadOv[RequestNumber^0x1])) break;
//			if(WaitForSingleObject(ReadEvent[!RequestNumber], TimeOut) == WAIT_TIMEOUT)
//				            		{ ThreadErrorNumber = 0x3; break; }

						if(ThreadErrorNumber) break;
						else if(kbhit()) { ThreadErrorNumber = 0x1; break; }
						else Sleep(20);
						Counter++;
				}

				// æä¸ì îêîí÷àíèÿ îïåðàöèè ñáîðà ïîñëåäíåé ïîðöèè äàííûõ 
				if(!ThreadErrorNumber)
				{
						RequestNumber ^= 0x1;
						WaitingForRequestCompleted(&ReadOv[RequestNumber^0x1]);
//			if(WaitForSingleObject(ReadEvent[!RequestNumber], TimeOut) == WAIT_TIMEOUT) ThreadErrorNumber = 0x3;
						Counter++;
				}
		}
		else { ThreadErrorNumber = 0x5; }

		// îñòàíîâèì ââîä äàííûõ
		if(!pModule->STOP_READ()) ThreadErrorNumber = 0x6;
		// åñëè íàäî, òî ïðåðâ¸ì íåçàâåðø¸ííûé àñèíõðîííûé çàïðîñ
		if(!CancelIo(pModule->GetModuleHandle())) ThreadErrorNumber = 0x7;
		// îñâîáîäèì âñå èäåíòèôèêàòîðû ñîáûòèé
		for(i = 0x0; i < 0x2; i++) CloseHandle(ReadEvent[i]);
		// íåáîëüøàÿ çàäåðæêà
		Sleep(100);
		// óñòàíîâèì ôëàæîê îêîí÷àíèÿ ïîòîêà ñáîðà äàííûõ
		IsThreadComplete = true;
		// òåïåðü ìîæíî âîõîäèòü èç ïîòîêà ñáîðà äàííûõ
		return 0;
}

//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
bool WaitingForRequestCompleted(OVERLAPPED *ReadOv)
{
		DWORD ReadBytesTransferred;

		while(true)
		{
				if(GetOverlappedResult(ModuleHandle, ReadOv, &ReadBytesTransferred, FALSE)) break;
				else if(GetLastError() !=  ERROR_IO_INCOMPLETE) { ThreadErrorNumber = 0x3; return false; }
				else if(kbhit()) { ThreadErrorNumber = 0x1; return false; }
				else Sleep(20);
		}
		return true;
}

//------------------------------------------------------------------------
// Îòîáðàçèì ñîîáùåíèå ñ îøèáêîé
//------------------------------------------------------------------------
void ShowThreadErrorMessage(void)
{
		switch(ThreadErrorNumber)
		{
		case 0x0:
				break;

		case 0x1:
				// åñëè ïðîãðàììà áûëà çëîáíî ïðåðâàíà, ïðåäúÿâèì íîòó ïðîòåñòà
				printf("\n READ Thread: The program was terminated! :(((\n");
				break;

		case 0x2:
				printf("\n READ Thread: ReadData() --> Bad :(((\n");
				break;

		case 0x3:
				printf("\n READ Thread: Read Request --> Bad :(((\n");
//			printf("\n READ Thread: Timeout is occured :(((\n");
				break;

		case 0x4:
				printf("\n READ Thread: Buffer Data Error! :(((\n");
				break;

		case 0x5:
				printf("\n READ Thread: START_READ() --> Bad :(((\n");
				break;

		case 0x6:
				printf("\n READ Thread: STOP_READ() --> Bad! :(((\n");
				break;

		case 0x7:
				printf("\n READ Thread: Can't complete input and output (I/O) operations! :(((");
				break;

		default:
				printf("\n READ Thread: Unknown error! :(((\n");
				break;
		}

		return;
}

//------------------------------------------------------------------------
// âûâîä ñîîáùåíèÿ è, åñëè íóæíî, àâàðèéíûé âûõîä èç ïðîãðàììû
//------------------------------------------------------------------------
void TerminateApplication(char *ErrorString, bool TerminationFlag)
{
		// ïîä÷èùàåì èíòåðôåéñ ìîäóëÿ
		if(pModule)
		{ 
				// îñâîáîäèì èíòåðôåéñ ìîäóëÿ
				if(!pModule->ReleaseInstance()) printf(" ReleaseInstance() --> Bad\n"); 
				//else printf(" ReleaseInstance() --> OK\n");
				// îáíóëèì óêàçàòåëü íà èíòåðôåéñ ìîäóëÿ
				pModule = NULL; 
		}

		// îñâîáîæäàåì çàíÿòûå ðåñóðñû
		if(ReadBuffer) { delete[] ReadBuffer; ReadBuffer = NULL; }
		// îñâîáîäèì èäåíòèôèêàòîð ïîòîêà ñáîðà äàííûõ
		if(hReadThread) { CloseHandle(hReadThread); hReadThread = NULL; }
		// îñâîáîäèì èäåíòèôèêàòîð ôàéëà äàííûõ
		if(hFile != INVALID_HANDLE_VALUE) { CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; }

		// âûâîäèì òåêñò ñîîáùåíèÿ
		//if(ErrorString) printf(ErrorString);

		// åñëè íóæíî - àâàðèéíî çàâåðøàåì ïðîãðàììó
		if(TerminationFlag) exit(1);
		else return;
}