//************************************************************
//*                                                          *
//*        Riadenie generatora cez GPIB rozhranie            *
//*                  (c) 2005, MPsoft                        *
//*                      Gener.cpp                           *
//*                  26.januara 2005                         *
//*                                                          *
//*        Ukážka plne komentovaného zdrojového textu        *
//*                                                          *
//************************************************************

#include <windows.h>  
#include "CmnHdr.H"
#include <windowsx.h>
#include "resource.h" 
#include "ccerr.h"
#include "ismerr.h"
#include "ism.h"
#include <commctrl.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include "animbox.h"
#include "x76f.h"
#include <process.h>
#include "protpoi.h"
#include "ccard.h"
#include "audit.h"
#define FD_CC_SHELL												// vylucenie chybovych hlaseni ISM modulu
#include "classapi.h"
#include "ni488.h"
#include "chamel.h"

#define TIME_OF_SWEEP 100

	extern 	DWORD GeneratorEngineIndex;
	extern void (__stdcall *PSend)(int boardID, Addr4882_t addr, PVOID buffer, LONG cnt, int Termination);
	extern Addr4882_t Result[31];										// pole zaznamenanych adries
	extern int *Pibsta;											// smernik na funkciu navratu statusu operacie
	extern void GPIBCleanup(int ud, char* ErrorMsg);
	extern void (__stdcall *PReceive)(int boardID, Addr4882_t addr, PVOID buffer, LONG cnt, int Termination);

	extern ULONG MeasureConfig;										// premenna testu enginu
	extern CRITICAL_SECTION g_CriticalSectionICL;								// kriticka sekcia pre ochranu pristupu

#define ARRAYSIZE  100												// Velkost citacieho buffera
#define GPIB0        0												// Handle karty (boardID) = 0

BOOL GeneratorWrite(LPSTR SendBuffer);
BOOL GeneratorRead(LPSTR ReadBuffer);
BOOL GeneratorInitDevice();
BOOL GeneratorMeasureLevelOnSetfrequencyEngin(HWND hwndDlg, int Frequency, double Rlevel);
BOOL GeneratorWriteT(LPSTR SendBuffer);
BOOL WaitopGenerator();

// ***************************************************
// ********  Funkcie PRE PRISTUP DO GPIB-32.DLL ******
// ***************************************************

	// Funkcia "DevClearList" posiela Selected Device Clear (SDC) GPIB spravu pre vsetky adresy zariadeni
	// popisane v adresliste. Ak adreslist obsahuje len konstantu NOADDR, Universal Device Clear (DCL)
	// sprava je vyslana do vsetkych zariadeni na zbernici.

	// Funkcia "FindLstn" testuje vsetky primarne adresy:
	// Ak je zariadenie pritomne na primarnej adrese, tato primarna adresa je ulozena
	// do "resultlistu". Inaksie vsetky sekundarne adresy su tiez testovane
	// a tiez ukladane do "resultlistu". Ale pocet je limitovany. Funkcia "ibcntl" vracia
	// aktualny pocet adries ulozenych v "resultliste".

	// Funkcia "ibonl" resetuje kartu alebo zariadenie a nastavuje parametre softverovej
	// konfiguracie do predkonfigurovaneho stavu.
	// Ak je parameter "0", zariadenie alebo inretfejs prepina do offline stavu.
	// Ak je parameter nenulovy, zariadenie alebo inretfejs zostava v operacnom stave
	// alebo v stave online.
	// Ak je zariadenie alebo inretfejs nastaveny do stavu "offline", deskriptor karty
	// alebo deskriptor (ud) je uz dalej neplatny. Je potrebne vykonat funkciu "ibdev"
	// alebo "ibfind" pre pristup ku karte alebo zariadeniu.

	// Funkcia "Receive" adresuje zariadenie popisane adresou a nacita limitom zadany pocet bajtov
	// do buffra. Bajty udajov su citane  az do zadaneho pocetu bajtov,
	// alebo kym nie je detekovany koniec.
	// Ak je zadana ukoncovacia podmienka "STOPend", citanie je stopnute ked je najdeny
	// bajt EOI. Inaksie je citanie zastavene ked je detekovany 8-bitovy znak EOS.
	// Aktualny pocet nacitanych znakov je vrateny funkciou "ibcntl".

	// Funkcia "SendList" adresuje zariadenia popisane v adresliste a zadany pocet
	// bajtov posiela do vsetkych zariadeni. Posledny zaslany bajt EOI vytvara predpoklad
	// ze pre ukoncenie je pouzity DABend. Ak je poslednym bajtom nie EOI,
	// ukoncovaci mod je NULLend. Ak je to NLend, znak ('\n') je vyslany s EOI.
	// Aktualny pocet prenesenych bajtov je vrateny funkciou "ibcntl".

	// Funkcia "SendIFC" je pouzita ako prvok GPIB inicializacie. Vnucuje interface
	// do stavu "Controller-In-Charge" GPIB. Taktiez zabezpecuje ze pripojene zariadenia
	// su vsetky deadresovane a ze interfejsove volania zariadeni su v cakacom stave.

//*** Zapis riadiaceho retazca do analyzatora cez GPIB ***

BOOL GeneratorWrite(LPSTR SendBuffer)
{
	#define WDELAY 1											// 1 mS

	int count = 15000;											// pre 15 sekund
	char SendBufferForGenerator[ARRAYSIZE + 1];								// zapisovy datovy buffer

	#ifdef ERR_DBG												// len ak je ladenie
	char ErrLatche[256];
	BOOL suc;
	char NoError[14] = {0x30, 0x2C, 0x22, 0x4E, 0x6F, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x22, 0x0A, 0x00};	// vracany retazec
	#endif

	if(MeasureConfig != 2)											// ak to nie je zostava generatora
		return FALSE;

	EnterCriticalSection(&g_CriticalSectionICL);								// ochrana pre vylucenie pristupu ineho threadu
	
	// vyslanie retazca

	memset(SendBufferForGenerator, 0, sizeof(SendBufferForGenerator));
	strcpy(SendBufferForGenerator, SendBuffer);

wstring:
	(*PSend)(GPIB0, Result[GeneratorEngineIndex], SendBufferForGenerator, strlen(SendBufferForGenerator), NLend);
	if((*Pibsta) & ERR)											// ak je chyba
		{
		if(!count)
			{
		GPIBCleanup(GPIB0, "Unable send to a device");
			LeaveCriticalSection(&g_CriticalSectionICL);						// zrusenie ochrany vyhradneho pristupu
			return FALSE;
			}
		count--;
		Sleep(WDELAY);
		goto wstring;											// este opakovat
		}
	
	#ifdef ERR_DBG												// len ak je ladenie
	suc = GeneratorWriteT("SYSTEM:ERROR?");
	if(!suc)												// ak je chyba
		{
		LeaveCriticalSection(&g_CriticalSectionICL);							// zrusenie ochrany vyhradneho pristupu
		return suc;
		}

	suc = GeneratorRead(ErrLatche);										// nacitanie parametrov (nacita uroven)
	if(!suc)												// ak je chyba
		{
		LeaveCriticalSection(&g_CriticalSectionICL);							// zrusenie ochrany vyhradneho pristupu
		return suc;
		}

	if(strcmp(ErrLatche, NoError))										// ak je chyba (nie je to "0, "No error"")
		{
		MessageBoxAudit(NULL, ErrLatche, LoadResString(IDS_TX568),
						MB_OK | MB_ICONSTOP | MB_SETFOREGROUND | MB_TASKMODAL);
		}
	#endif

	LeaveCriticalSection(&g_CriticalSectionICL);								// zrusenie ochrany vyhradneho pristupu
	return TRUE;
}

//*** Zapis riadiaceho retazca do analyzatora cez GPIB pre nacitanie chyboveho latche analyzatora ***

//    Bez ochrany kritickou sekciou - vznikol by deadlock

BOOL GeneratorWriteT(LPSTR SendBuffer)
{
	char SendBufferForGenerator[ARRAYSIZE + 1];								// zapisovy datovy buffer

	if(MeasureConfig != 2)											// ak to nie je zostava generatora
		return FALSE;

	// vyslanie retazca

	memset(SendBufferForGenerator, 0, sizeof(SendBufferForGenerator));
	strcpy(SendBufferForGenerator, SendBuffer);
	
	(*PSend)(GPIB0, Result[GeneratorEngineIndex], SendBufferForGenerator, strlen(SendBufferForGenerator), NLend);
	if((*Pibsta) & ERR)											// ak je chyba
		{
		GPIBCleanup(GPIB0, "Unable send to a device");
		return FALSE;
		}

	return TRUE;
}

//*** Citanie odozvy z analyzatora cez GPIB ***

BOOL GeneratorRead(LPSTR ReadBuffer)
{
	#define RDELAY 1											// 1 mS

	int count = 15000;											// pre 15 sekund
	char ReadBufferForGenerator[ARRAYSIZE + 1];								// zapisovy datovy buffer

	if(MeasureConfig != 2)											// ak to nie je zostava generatora
		return FALSE;

	EnterCriticalSection(&g_CriticalSectionICL);								// ochrana pre vylucenie pristupu ineho threadu
	
	// nacitanie retazca

rstring:
	memset(ReadBufferForGenerator, 0, sizeof(ReadBufferForGenerator));
	(*PReceive)(GPIB0, Result[GeneratorEngineIndex], ReadBufferForGenerator, sizeof(ReadBufferForGenerator), STOPend);	// nacitanie zo zariadenia
	if((*Pibsta) & ERR)											// ak je chyba
		{
		if(!count)
			{
			GPIBCleanup(GPIB0, "Unable read from a device");
			LeaveCriticalSection(&g_CriticalSectionICL);	// zrusenie ochrany vyhradneho pristupu
			return FALSE;
			}
		count--;
		Sleep(RDELAY);
		goto rstring;											// este opakovat
		}

	strcpy(ReadBuffer, ReadBufferForGenerator);								// nakopirovanie odozvy do buffra	
	LeaveCriticalSection(&g_CriticalSectionICL);								// zrusenie ochrany vyhradneho pristupu
	return TRUE;
}

//*** Inicializacia zariadeni zresetovanim ***

BOOL GeneratorInitDevice()
{
	BOOL suc;

	WaitopGenerator();											// cakanie na ready
	suc = GeneratorWrite("*CLS");										// reset status registrov
	if(!suc)												// ak je chyba
		return suc;

	WaitopGenerator();											// cakanie na ready
	suc = GeneratorWrite("*RST");										// reset zariadeni (prozor, nastavuje frekvenciu na 20 GHz s span 40 GHz)
	return suc;
}

//*** Nastavenie generatora ***

BOOL GeneratorMeasureLevelOnSetfrequencyEngin(HWND hwndDlg, int Frequency, double Rlevel)
{
	BOOL suc;
	char freq[256];
	char rlevel[256];

	wsprintf(freq, "FREQ %dMHz", Frequency);
	WaitopGenerator();											// cakanie na ready
	suc = GeneratorWrite(freq);										// stredna frekvencia
	if(!suc)												// ak je chyba
		return suc;

	// nastavenie referencnej urovne

	sprintf(rlevel, ":POW %lfdbm", Rlevel);
	WaitopGenerator();											// cakanie na ready
	suc = GeneratorWrite(rlevel);										// referencna uroven
	if(!suc)												// ak je chyba
		return suc;
	
	// zapnutie vystupu

	WaitopGenerator();											// cakanie na ready
	suc = GeneratorWrite("OUTP:STAT ON");									// nastavenie markera 1 na maximum
	if(!suc)												// ak je chyba
		return suc;

	return suc;
}

//*** Cakanie na cakanie na dokoncenie operacie generatora ***

BOOL WaitopGenerator()
{
	BOOL wsuc;
	BOOL suc;
	int csuc;												// vysledok porovnania
	char result[10];
	char one[] = "1";

	wsuc = TRUE;

	Sleep(TIME_OF_SWEEP);
return TRUE;
tst:
	suc = GeneratorWrite("ROSCILLATOR:SUORCE INT; *OPC?");							// cakanie na dokoncenie operacie
	if(!suc)												// ak je chyba
		return suc;

	suc = GeneratorRead(result);										// nacitanie parametrov (nacita uroven)


	csuc = memcmp(one, result, 1);										// test na "1"
		if(!csuc)
			{

			// ak je zhoda

			return TRUE;
			}

		goto tst;

	return wsuc;
}