Subversion Repositories gpib_controller

 
#include <string.h>
#include <stdio.h>
 
#include <unistd.h>
 
#include "GpibRegAccess.h"
#include "GpibHwAdapter.h"
#include "GpibHw.h"
 
 
int gpibExplorerMain(int argc, char* argv[])
{
	struct GpibRegAccess ra;
	struct GpibHwAdapter ghw;
	struct GpibHw gpib;
 
	RegType regVal;
 
	GpibRegAccess_init(&ra);
	GpibHwAdapter_init(&ghw, &ra, 0);
	GpibHw_init(&gpib, &ghw);
 
	struct GpibHwSettings gs;
	// set T1
	GpibHw_getSettings(&gpib, &gs);
	gs.T1 = 132;
	GpibHw_setSettings(&gpib, &gs);
 
	// request system control
	GpibHw_requestSystemControl(&gpib, 1);
 
	// go to standby
	GpibHw_goToStandby(&gpib, 0);
	GpibHw_takeControlAsynchronously(&gpib, 1);
 
	// system interface clear
	GpibHw_systemInterfaceClear(&gpib, 1);
 
	// remote enable
	GpibHw_sendRemoteEnable(&gpib, 1);
 
	do
	{
		GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
	}
	while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrc));
 
 
	GpibHw_systemInterfaceClear(&gpib, 0);
 
	GpibHw_takeControlAsynchronously(&gpib, 0);
 
	do
	{
		GpibHwAdapter_getReg(&ghw, REG_ADDR_EVENT, &regVal);
	}
	while(GpibHwAdapter_getBitValue(regVal, MASK_EVENT_IFC));
 
	char buf[2048];
	SizeType bytesRead;
	SizeType bytesWritten;
	bool endOfStream;
 
 
 
	do
	{
		// set not to listen ///////////////////////////////////////
		/*if(!GpibHwAdapter_getReg(&ghw, REG_ADDR_CONTROL, &regVal))
		{
			return false;
		}
 
		GpibHwAdapter_setBitValue(regVal, MASK_CONTROL_ltn, 0);
 
		if(!GpibHwAdapter_setReg(&ghw, REG_ADDR_CONTROL, regVal))
		{
			return false;
		}*/
		////////////////////////////////////////////////////////
 
		// write command
		int cmdLen = 2;
		buf[0] = 0x22;
		buf[1] = 0x41;
 
		bytesWritten = 0;
 
		do
		{
			GpibHw_write(&gpib, buf + bytesWritten, cmdLen - bytesWritten,
					&bytesWritten, false);
		}
		while(bytesWritten < cmdLen);
 
		do
		{
			GpibHwAdapter_getReg(&ghw, REG_ADDR_WRITER_CONTROL_1, &regVal);
		}
		while(GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo) > 0);
 
 
		// go to standby
		GpibHw_goToStandby(&gpib, 1);
 
		do
		{
			GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
		}
		while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrd));
 
		GpibHw_goToStandby(&gpib, 0);
 
		FILE *file = 0;
		bool readAgain;
		bool doExit;
 
		do
		{
			readAgain = false;
			doExit = false;
 
			// gets command
			gets(buf);
 
			if(strlen(buf) == 1 && buf[0] == 'e')
			{
				if(file)
				{
					fclose(file);
				}
 
				doExit = true;
				break;
			}
			else if(strstr(buf, "save_to_file") != 0)
			{
				char fileName[512];
				sscanf(buf, "save_to_file %s", fileName);
				file = fopen(fileName, "wb");
				readAgain = true;
			}
		}
		while(readAgain);
 
		if(doExit)
		{
			break;
		}
 
		//buf[strlen(buf) + 1] = 0;
		//buf[strlen(buf)] = '\n';
 
		// write data
		bytesWritten = 0;
		u32 tmpBytesWritten;
 
		do
		{
			GpibHw_write(&gpib, buf + bytesWritten, strlen(buf) - bytesWritten,
					&tmpBytesWritten, true);
			bytesWritten += tmpBytesWritten;
		}
		while(bytesWritten < strlen(buf));
 
		do
		{
			GpibHwAdapter_getReg(&ghw, REG_ADDR_WRITER_CONTROL_1, &regVal);
		}
		while(GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo) > 0);
 
		// take control
		GpibHw_takeControlAsynchronously(&gpib, 1);
 
		do
		{
			GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
		}
		while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrc));
 
		GpibHw_takeControlAsynchronously(&gpib, 0);
 
 
		// set to listen ///////////////////////////////////////
		/*if(!GpibHwAdapter_getReg(&ghw, REG_ADDR_CONTROL, &regVal))
		{
			return false;
		}
 
		GpibHwAdapter_setBitValue(regVal, MASK_CONTROL_ltn, 1);
 
		if(!GpibHwAdapter_setReg(&ghw, REG_ADDR_CONTROL, regVal))
		{
			return false;
		}*/
		////////////////////////////////////////////////////////
 
 
		// write command
		bytesWritten = 0;
		buf[0] = 0x21;
		buf[1] = 0x42;
 
		do
		{
			GpibHw_write(&gpib, buf + bytesWritten, 2 - bytesWritten,
					&bytesWritten, false);
		}
		while(bytesWritten < 2);
 
		do
		{
			GpibHwAdapter_getReg(&ghw, REG_ADDR_WRITER_CONTROL_1, &regVal);
		}
		while(GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo) > 0);
 
		GpibHwAdapter_getReg(&ghw, REG_ADDR_BUS_STATUS, &regVal);
 
		// go to standby
		GpibHw_goToStandby(&gpib, true);
 
		do
		{
			GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
		}
		while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrd));
 
		GpibHw_goToStandby(&gpib, false);
 
 
		int timeout = 0;
		// read data
		do
		{
			GpibHw_read(&gpib, buf, 2047, &bytesRead, &endOfStream);
 
			if(bytesRead > 0)
			{
				buf[bytesRead] = 0;
				timeout = 0;
 
				if(!file)
				{
					printf("%s", buf);
				}
				else
				{
					fwrite(buf, 1, bytesRead, file);
				}
			}
 
			timeout ++;
 
			if((timeout > 500 && !file) || (timeout > 20000 && file))
			{
				break;
			}
		}
		while(!endOfStream);
 
		if(file)
		{
			fclose(file);
			file = 0;
		}
 
		// take control
		GpibHw_takeControlAsynchronously(&gpib, 1);
 
		do
		{
			GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
		}
		while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrc));
 
		GpibHw_takeControlAsynchronously(&gpib, 0);
	}
	while(true);
 
	// remote disable
	GpibHw_sendRemoteEnable(&gpib, 0);
 
	GpibHw_release(&gpib);
	GpibHwAdapter_release(&ghw);
	GpibRegAccess_release(&ra);
 
	return 0;
}