OpenCores
URL https://opencores.org/ocsvn/gpib_controller/gpib_controller/trunk

Subversion Repositories gpib_controller

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /gpib_controller
    from Rev 5 to Rev 6
    ↔ Reverse comparison
  •

Rev 5 → Rev 6

/trunk/prototype_1/PC_software/src/HiSlip_GPIB_Test.c File deleted
/trunk/prototype_1/PC_software/src/listenOnly_Test.c File deleted
/trunk/prototype_1/PC_software/src/gpibHwTest.c File deleted
/trunk/prototype_1/PC_software/src/gpibExplorer_Test.c File deleted
/trunk/prototype_1/PC_software/src/main.c File deleted
/trunk/prototype_1/PC_software/src/readRawRegs.c File deleted
/trunk/prototype_1/PC_software/test_src/listenOnly_Test.c
0,0 → 1,80
 
#include <string.h>
#include <stdio.h>
#include <time.h>
 
#include <unistd.h>
 
#include "GpibRegAccess.h"
#include "GpibHwAdapter.h"
#include "GpibHw.h"
 
 
int listenOnlyMain(int argc, char* argv[])
{
struct GpibRegAccess ra;
struct GpibHwAdapter ghw;
struct GpibHw gpib;
 
time_t rawtime;
struct tm * timeinfo;
 
GpibRegAccess_init(&ra);
GpibHwAdapter_init(&ghw, &ra, 0);
GpibHw_init(&gpib, &ghw);
 
struct GpibHwSettings gs;
// set listen only
// set T1
GpibHw_getSettings(&gpib, &gs);
gs.T1 = 132;
gs.listenOnly = true;
GpibHw_setSettings(&gpib, &gs);
 
char buf[2048];
SizeType bytesRead;
bool endOfStream;
int i;
char fileName[1024];
bool fileAllocated;
FILE *file;
 
 
while(true){
sprintf(fileName, "/home/andrzej/Downloads/TDS420/img%u.tiff", i);
fileAllocated = false;
 
do
{
GpibHw_read(&gpib, buf, 2048, &bytesRead, &endOfStream);
 
if(bytesRead > 0)
{
if(!fileAllocated)
{
file = fopen(fileName, "wb");
fileAllocated = true;
rawtime = time (0);
timeinfo = localtime ( &rawtime );
printf ( "Start time: %s\n", asctime (timeinfo) );
}
 
fwrite(buf, 1, bytesRead, file);
}
}
while(!endOfStream);
 
rawtime = time (0);
timeinfo = localtime ( &rawtime );
printf ( "Stop time: %s\n", asctime (timeinfo) );
 
fclose(file);
i++;
}
 
GpibHw_release(&gpib);
GpibHwAdapter_release(&ghw);
GpibRegAccess_release(&ra);
 
return 0;
}
/trunk/prototype_1/PC_software/test_src/gpibHwTest.c
0,0 → 1,172
 
#include <string.h>
#include <stdio.h>
 
#include <unistd.h>
 
#include "RegAccess.h"
#include "GpibHw.h"
 
 
int main(int argc, char* argv[])
{
useconds_t sleep_time = 5000;
 
struct RegAccess ra;
struct GpibHw ghw;
 
RegAccess_init(&ra);
GpibHw_init(&ghw, &ra, 0);
 
RegType reg;
char *buf;
char readBuf[1024];
unsigned int i;
 
// set T1 and address
GpibHw_setReg(&ghw, REG_ADDR_SETTING_1, 0xfe1);
 
usleep(sleep_time);
 
GpibHw_getReg(&ghw, REG_ADDR_CONTROL, &reg);
GpibHw_setBitValue(reg, MASK_CONTROL_rsc, 1);
GpibHw_setReg(&ghw, REG_ADDR_CONTROL, reg);
 
usleep(sleep_time);
 
GpibHw_getReg(&ghw, REG_ADDR_CONTROL, &reg);
GpibHw_setBitValue(reg, MASK_CONTROL_sic, 1);
GpibHw_setReg(&ghw, REG_ADDR_CONTROL, reg);
 
usleep(sleep_time);
 
GpibHw_getReg(&ghw, REG_ADDR_CONTROL, &reg);
GpibHw_setBitValue(reg, MASK_CONTROL_sic, 0);
GpibHw_setReg(&ghw, REG_ADDR_CONTROL, reg);
 
while(true)
{
usleep(sleep_time);
 
GpibHw_setReg(&ghw, REG_ADDR_WRITER_CONTROL_0, 0x2);
GpibHw_setReg(&ghw, REG_ADDR_WRITER_FIFO, 0x41);
GpibHw_setReg(&ghw, REG_ADDR_WRITER_FIFO, 0x22);
 
usleep(sleep_time);
 
// gts
GpibHw_getReg(&ghw, REG_ADDR_CONTROL, &reg);
GpibHw_setBitValue(reg, MASK_CONTROL_gts, 1);
GpibHw_setReg(&ghw, REG_ADDR_CONTROL, reg);
 
usleep(sleep_time);
 
GpibHw_setReg(&ghw, REG_ADDR_WRITER_CONTROL_0, 0);
 
//buf = "BELl";
//buf = "CLEARMenu";
//buf = "APPMenu ACTivate";
//buf = "*IDN?";
//buf = "*LRN?";
 
scanf("%s", readBuf);
 
if(strlen(readBuf) == 1 && readBuf[0] == 'e')
{
break;
}
 
buf = readBuf;
 
for(i=0; i<strlen(buf); i++)
{
GpibHw_setReg(&ghw, REG_ADDR_WRITER_FIFO, buf[i]);
}
 
GpibHw_setReg(&ghw, REG_ADDR_WRITER_FIFO, 0xa);
 
usleep(sleep_time);
 
// end of stream
GpibHw_setReg(&ghw, REG_ADDR_WRITER_CONTROL_0, 4);
 
usleep(sleep_time);
 
// writer enable
GpibHw_setReg(&ghw, REG_ADDR_WRITER_CONTROL_0, 6);
 
usleep(sleep_time);
 
// writer reset
GpibHw_setReg(&ghw, REG_ADDR_WRITER_CONTROL_0, 8);
 
// take control
GpibHw_getReg(&ghw, REG_ADDR_CONTROL, &reg);
GpibHw_setBitValue(reg, MASK_CONTROL_tca, 1);
GpibHw_setBitValue(reg, MASK_CONTROL_gts, 0);
GpibHw_setReg(&ghw, REG_ADDR_CONTROL, reg);
 
usleep(sleep_time);
 
GpibHw_getReg(&ghw, REG_ADDR_CONTROL, &reg);
GpibHw_setBitValue(reg, MASK_CONTROL_tca, 0);
GpibHw_setReg(&ghw, REG_ADDR_CONTROL, reg);
 
usleep(sleep_time);
 
GpibHw_setReg(&ghw, REG_ADDR_WRITER_CONTROL_0, 0x2);
GpibHw_setReg(&ghw, REG_ADDR_WRITER_FIFO, 0x42);
GpibHw_setReg(&ghw, REG_ADDR_WRITER_FIFO, 0x21);
 
GpibHw_setReg(&ghw, REG_ADDR_READER_CONTROL_0, 8);
 
usleep(sleep_time);
 
// gts
GpibHw_getReg(&ghw, REG_ADDR_CONTROL, &reg);
GpibHw_setBitValue(reg, MASK_CONTROL_gts, 1);
GpibHw_setReg(&ghw, REG_ADDR_CONTROL, reg);
 
usleep(200000);
 
unsigned int bufPos = 0;
RegType len;
 
do
{
GpibHw_getReg(&ghw, REG_ADDR_READER_CONTROL_1, &len);
 
if(len > 0)
{
for(i=bufPos; i<len+bufPos; i++)
{
GpibHw_getReg(&ghw, REG_ADDR_READER_FIFO, &reg);
readBuf[i] = reg;
}
 
bufPos += len;
}
}
while(len > 0);
 
readBuf[bufPos] = 0;
 
printf("%s\n", readBuf);
 
GpibHw_getReg(&ghw, REG_ADDR_CONTROL, &reg);
GpibHw_setBitValue(reg, MASK_CONTROL_tca, 1);
GpibHw_setBitValue(reg, MASK_CONTROL_gts, 0);
GpibHw_setReg(&ghw, REG_ADDR_CONTROL, reg);
 
usleep(sleep_time);
 
GpibHw_getReg(&ghw, REG_ADDR_CONTROL, &reg);
GpibHw_setBitValue(reg, MASK_CONTROL_tca, 0);
GpibHw_setReg(&ghw, REG_ADDR_CONTROL, reg);
}
 
GpibHw_release(&ghw);
RegAccess_release(&ra);
 
return 0;
}
/trunk/prototype_1/PC_software/test_src/gpibExplorer_Test.c
0,0 → 1,289
 
#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;
}
/trunk/prototype_1/PC_software/test_src/main.c
0,0 → 1,37
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#include "GpibRegAccess.h"
 
 
#define CHECK(x) if(!(x)) goto error;
 
extern int gpibExplorerMain(int argc, char* argv[]);
extern int rawRegAccessMain(int argc, char* argv[]);
extern int listenOnlyMain(int argc, char* argv[]);
extern int HiSlipGpibMain(int argc, char* argv[]);
 
 
int main(int argc, char *argv[]) {
 
if(argc == 2)
{
if(strstr(argv[1], "ge"))
{
return gpibExplorerMain(argc, argv);
} else if(strstr(argv[1], "rra"))
{
return rawRegAccessMain(argc, argv);
} else if(strstr(argv[1], "lo"))
{
return listenOnlyMain(argc, argv);
} else if(strstr(argv[1], "hsrv"))
{
return HiSlipGpibMain(argc, argv);
}
}
 
return 1;
}
/trunk/prototype_1/PC_software/test_src/readRawRegs.c
0,0 → 1,100
/*
============================================================================
Name : GPIB_access.c
Author : apaluch
Version :
Copyright : Your copyright notice
Description : Hello World in C, Ansi-style
============================================================================
*/
 
#include <stdio.h>
#include <stdlib.h>
 
#include "GpibRegAccess.h"
 
#define CHECK(x) if(!(x)) goto error;
 
int rawRegAccessMain(int argc, char* argv[]) {
 
printf("start\n");
 
struct GpibRegAccess ra;
 
CHECK(GpibRegAccess_init(&ra));
 
RegType value, value1;
unsigned int tempInt;
SizeType regAddr = 1;
 
char chr;
 
do
{
chr = getchar();
 
value = 0;
value1 = 0;
 
if(chr != 'e')
{
if(chr == 'r')
{
scanf("%u", &regAddr);
CHECK(GpibRegAccess_readReg(&ra, regAddr, &value));
printf("\n%x\n", value);
}
else if(chr == 'w')
{
scanf("%u", &regAddr);
scanf("%x", &tempInt);
 
value = tempInt;
 
//printf("\n%u %u\n", regAddr, value);
 
CHECK(GpibRegAccess_writeReg(&ra, regAddr, value));
}
else if(chr == 'a')
{
scanf("%u", &regAddr);
scanf("%x", &tempInt);
 
value = tempInt;
 
//printf("\n%u %u\n", regAddr, value);
 
CHECK(GpibRegAccess_readReg(&ra, regAddr, &value1));
CHECK(GpibRegAccess_writeReg(&ra, regAddr, value & value1));
}
else if(chr == 'o')
{
scanf("%u", &regAddr);
scanf("%x", &tempInt);
 
value = tempInt;
 
//printf("\n%u %u\n", regAddr, value);
 
CHECK(GpibRegAccess_readReg(&ra, regAddr, &value1));
CHECK(GpibRegAccess_writeReg(&ra, regAddr, value | value1));
}
}
else
{
break;
}
}
while(true);
 
GpibRegAccess_release(&ra);
 
printf("end\n");
 
return 0;
 
error:
printf("error");
GpibRegAccess_release(&ra);
return -1;
}
/trunk/prototype_1/PC_software/test_src/HiSlip_GPIB_Test.c
0,0 → 1,376
 
#include <string.h>
#include <stdio.h>
 
#include <unistd.h>
 
#include "common_types.h"
 
#include "GpibRegAccess.h"
#include "GpibHwAdapter.h"
#include "GpibHw.h"
 
#include "HiSlipServer.h"
 
 
 
void deviceToWrite(struct GpibHw *gpib, struct GpibHwAdapter *ghw);
void deviceToRead(struct GpibHw *gpib, struct GpibHwAdapter *ghw);
 
 
 
void HiSlipTest_beginExclusiveAccess(HiSlipResource *resource);
void HiSlipTest_endExclusiveAccess(HiSlipResource *resource);
void HiSlipTest_writeData(HiSlipResource *resource,
u8 *buf, u32 len, bool rmt, u32 msgId);
HiSlipIoResult HiSlipTest_waitDataAvailable(
HiSlipResource *resource, u32 *lenHi, u32 *lenLo, bool *rmt);
HiSlipIoResult HiSlipTest_readData(HiSlipResource *resource,
u32 maxLenHi, u32 maxLenLo, u8 **pBuf, u32 *len);
 
 
bool isDeviceToWrite, isDeviceToRead;
struct GpibHwAdapter ghw;
struct GpibHw gpib;
/** Exclusive access CS */
HiSlipCriticalSection accessCriticalSection;
 
 
int HiSlipGpibMain(int argc, char* argv[])
{
HiSlipServer hSrv;
HiSlipApplication app;
HiSlipResourceRoutines routines;
 
bool status;
 
struct GpibRegAccess ra;
 
 
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));
 
 
isDeviceToWrite = false;
isDeviceToRead = false;
 
// configure HiSlip
 
status = HiSlipCriticalSection_init(&(accessCriticalSection));
 
HiSlipApplication_init(&app);
app.isOverlappedMode = false;
app.vendorId = 0xBACD;
app.waitForAsyncConnectionTimeout = 1000;
app.readDataTimeout = 1000;
app.maxMsgSizeHi = 0;
app.maxMsgSizeLo = 1000;
app.maxSessions = 3;
 
// initialize routines
memset(&routines, 0, sizeof(HiSlipResourceRoutines));
routines.beginExclusiveAccess = HiSlipTest_beginExclusiveAccess;
routines.endExclusiveAccess = HiSlipTest_endExclusiveAccess;
routines.writeData = HiSlipTest_writeData;
routines.waitDataAvailable = HiSlipTest_waitDataAvailable;
routines.readData = HiSlipTest_readData;
 
HiSlipApplication_registerResource(&app, "hislip0", &routines,
1, NULL_PTR);
 
status = HiSlipServer_init(&hSrv, &app);
 
if(status)
{
status = HiSlipServer_start(&hSrv);
}
 
while(hSrv.started)
{
sleep(100);
}
 
// remote disable
GpibHw_sendRemoteEnable(&gpib, 0);
 
HiSlipApplication_release(&app);
 
GpibHw_release(&gpib);
GpibHwAdapter_release(&ghw);
GpibRegAccess_release(&ra);
 
return 0;
}
 
void deviceToRead(struct GpibHw *gpib, struct GpibHwAdapter *ghw)
{
RegType regVal;
char buf[10];
u32 bytesWritten;
// write command
int cmdLen = 2;
 
if(!isDeviceToRead)
{
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);
 
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);
 
// clear input buffer
 
 
isDeviceToRead = true;
isDeviceToWrite = false;
}
}
 
void deviceToWrite(struct GpibHw *gpib, struct GpibHwAdapter *ghw)
{
RegType regVal;
char buf[10];
u32 bytesWritten;
// write command
int cmdLen = 2;
 
if(!isDeviceToWrite)
{
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);
 
buf[0] = 0x21;
buf[1] = 0x42;
 
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);
 
isDeviceToWrite = true;
isDeviceToRead = false;
}
}
 
void HiSlipTest_beginExclusiveAccess(HiSlipResource *resource)
{
HiSlipCriticalSection_enter(&(accessCriticalSection));
}
 
void HiSlipTest_endExclusiveAccess(HiSlipResource *resource)
{
HiSlipCriticalSection_leave(&(accessCriticalSection));
}
 
void HiSlipTest_writeData(HiSlipResource *resource,
u8 *buf, u32 len, bool rmt, u32 msgId)
{
SizeType bytesWritten;
RegType regVal;
 
deviceToRead(&gpib, &ghw);
 
// write data
bytesWritten = 0;
u32 tmpBytesWritten;
 
do
{
GpibHw_write(&gpib, (char*)buf + bytesWritten, len - bytesWritten,
&tmpBytesWritten, rmt);
bytesWritten += tmpBytesWritten;
}
while(bytesWritten < len);
 
do
{
GpibHwAdapter_getReg(&ghw, REG_ADDR_WRITER_CONTROL_1, &regVal);
}
while(GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo) > 0);
}
 
char gpib_buf[2048];
u32 gpib_buf_cnt = 0;
u32 gpib_buf_offset = 0;
bool gpib_buf_endOfStream;
// TODO - not correct
HiSlipIoResult HiSlipTest_waitDataAvailable(
HiSlipResource *resource, u32 *lenHi, u32 *lenLo, bool *rmt)
{
SizeType bytesRead;
bool endOfStream;
 
deviceToWrite(&gpib, &ghw);
 
int timeout = 0;
const int TIMEOUT = 1000;
bool timeoutOccured = false;
 
if(gpib_buf_cnt > 0)
{
*lenHi = 0;
*lenLo = gpib_buf_cnt;
*rmt = gpib_buf_endOfStream;
 
return HiSlipIoResult_OK;
}
 
// read data
do
{
GpibHw_read(&gpib, gpib_buf, 2047, &bytesRead, &endOfStream);
 
if(bytesRead > 0)
{
gpib_buf[bytesRead] = 0;
timeout = 0;
}
 
timeout ++;
 
if(bytesRead == 0)
{
usleep(10000);
}
 
if(timeout > TIMEOUT)
{
timeoutOccured = true;
break;
}
}
while(bytesRead == 0 && !timeoutOccured);
 
*lenHi = 0;
*lenLo = bytesRead;
*rmt = endOfStream;
gpib_buf_endOfStream = endOfStream;
gpib_buf_cnt = bytesRead;
gpib_buf_offset = 0;
 
if(timeoutOccured)
{
return HiSlipIoResult_TIMEOUT;
}
else
{
return HiSlipIoResult_OK;
}
}
 
// TODO - not correct
HiSlipIoResult HiSlipTest_readData(HiSlipResource *resource,
u32 maxLenHi, u32 maxLenLo, u8 **pBuf, u32 *len)
{
*pBuf = (u8*)gpib_buf + gpib_buf_offset;
*len = maxLenLo;
 
gpib_buf_offset += maxLenLo;
gpib_buf_cnt -= maxLenLo;
 
return HiSlipIoResult_OK;
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.