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

Subversion Repositories gpib_controller

[/] [gpib_controller/] [trunk/] [prototype_1/] [PC_software/] [gpib_src/] [GpibHw.c] - Blame information for rev 3

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * GpibHw.c
 *
 *  Created on: Feb 9, 2012
 *      Author: Andrzej Paluch
 */
 
#include "GpibHw.h"
 
#define MAX_FIFO_LEN 2047
 
bool GpibHw_init(struct GpibHw *gpibHw, struct GpibHwAdapter *ghwa)
{
        gpibHw->ghwa = ghwa;
        gpibHw->writerLastEndOfStream = false;
 
        return ghwa != 0;
}
 
void GpibHw_release(struct GpibHw *gpibHw)
{
        // do nothing
}
 
bool GpibHw_getSettings(struct GpibHw *gpibHw, struct GpibHwSettings *settings)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_SETTING_0, &regVal))
        {
                return false;
        }
 
        settings->talkOnly = GpibHwAdapter_getBitValue(regVal, MASK_SETTING0_ton);
        settings->listenOnly = GpibHwAdapter_getBitValue(regVal, MASK_SETTING0_lon);
        settings->eosMark = GpibHwAdapter_getFieldValue(regVal, MASK_SETTING0_eosMark);
        settings->eosUsed = GpibHwAdapter_getBitValue(regVal, MASK_SETTING0_eosUsed);
        settings->fixedPpLine = GpibHwAdapter_getFieldValue(regVal, MASK_SETTING0_fixedPpLine);
        settings->lpeUsed = GpibHwAdapter_getBitValue(regVal, MASK_SETTING0_lpeUsed);
        settings->isLeTe = GpibHwAdapter_getBitValue(regVal, MASK_SETTING0_isLeTe);
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_SETTING_1, &regVal))
        {
                return false;
        }
 
        settings->T1 = GpibHwAdapter_getFieldValue(regVal, MASK_SETTING1_T1);
        settings->address = GpibHwAdapter_getFieldValue(regVal, MASK_SETTING1_addr);
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_SEC_ADDR_0, &regVal))
        {
                return false;
        }
 
        settings->secondaryAddressMask = regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_SEC_ADDR_1, &regVal))
        {
                return false;
        }
 
        settings->secondaryAddressMask |= regVal << 16;
 
        return true;
}
 
bool GpibHw_setSettings(struct GpibHw *gpibHw, struct GpibHwSettings *settings)
{
        RegType regVal = 0;
 
        GpibHwAdapter_setBitValue(&regVal, MASK_SETTING0_ton, settings->talkOnly);
        GpibHwAdapter_setBitValue(&regVal, MASK_SETTING0_lon, settings->listenOnly);
        GpibHwAdapter_setFieldValue(&regVal, MASK_SETTING0_eosMark, settings->eosMark);
        GpibHwAdapter_setBitValue(&regVal, MASK_SETTING0_eosUsed, settings->eosUsed);
        GpibHwAdapter_setFieldValue(&regVal, MASK_SETTING0_fixedPpLine, settings->fixedPpLine);
        GpibHwAdapter_setBitValue(&regVal, MASK_SETTING0_lpeUsed, settings->lpeUsed);
        GpibHwAdapter_setBitValue(&regVal, MASK_SETTING0_isLeTe, settings->isLeTe);
 
        if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_SETTING_0, regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setFieldValue(&regVal, MASK_SETTING1_T1, settings->T1);
        GpibHwAdapter_setFieldValue(&regVal, MASK_SETTING1_addr, settings->address);
 
        if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_SETTING_1, regVal))
        {
                return false;
        }
 
        regVal = settings->secondaryAddressMask & 0xffff;
 
        if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_SEC_ADDR_0, regVal))
        {
                return false;
        }
 
        regVal = settings->secondaryAddressMask >> 16;
 
        if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_SEC_ADDR_1, regVal))
        {
                return false;
        }
 
        return true;
}
 
bool GpibHw_getEventStatus(struct GpibHw *gpibHw, struct GpibHwEvents *events)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_EVENT, &regVal))
        {
                return false;
        }
 
        events->IFC = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_IFC);
        events->ATN = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_ATN);
        events->REN = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_REN);
        events->stb_received = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_stb_received);
        events->ppr = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_ppr);
        events->srq = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_srq);
        events->cwrd = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_cwrd);
        events->cwrc = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_cwrc);
        events->spa = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_spa);
        events->atl = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_atl);
        events->att = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_att);
        events->trg = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_trg);
        events->clr = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_clr);
        events->out_ready = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_out_buf_full);
        events->in_ready = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_in_buf_full);
        events->isLocal = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_isLocal);
 
        return true;
}
 
bool GpibHw_getGpibStatus(struct GpibHw *gpibHw, struct GpibHwStatus *status)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_GPIB_STATUS, &regVal))
        {
                return false;
        }
 
        status->isLocal = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_isLocal);
        status->spa = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_spa);
        status->cwrd = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrd);
        status->cwrc = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrc);
        status->lac = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_lac);
        status->atl = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_atl);
        status->tac = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_tac);
        status->att = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_att);
        status->currentSecondaryAddress =
                        GpibHwAdapter_getFieldValue(regVal, MASK_GPIB_STATUS_currentSecAddr);
 
        return true;
}
 
bool GpibHw_requestSystemControl(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_rsc, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_systemInterfaceClear(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_sic, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_sendRemoteEnable(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_sre, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_goToStandby(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_gts, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_takeControlAsynchronously(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_tca, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_takeControlSynchronously(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_tcs, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_requestParallelPoll(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_rpp, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_receiveStatusByte(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_rec_stb, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_localPollEnable(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_lpe, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_setIndividualStatus(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_ist, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_requestService(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_rsv, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_returnToLocal(struct GpibHw *gpibHw, bool value)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_rtl, value);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_setLocalListenUnlisten(struct GpibHw *gpibHw, bool ltn, bool lun)
{
        RegType regVal;
 
        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))
        {
                return false;
        }
 
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_ltn, ltn);
        GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_lun, lun);
 
        return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);
}
 
bool GpibHw_availableBytesToRead(struct GpibHw *gpibHw, SizeType *count)
{
        RegType regVal;
 
        if(GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_READER_CONTROL_1, &regVal))
        {
                *count = GpibHwAdapter_getFieldValue(regVal, MASK_READER_CONTROL_1_bytesInFifo);
 
                return true;
        }
        else
        {
                return false;
        }
}
 
bool GpibHw_read(struct GpibHw *gpibHw, char *buf, SizeType bufLen,
                SizeType *bytesRead, bool *endOfStream)
{
        RegType regVal;
        SizeType availableCount;
        SizeType bytesToCopy;
        //SizeType i;
 
        *bytesRead = 0;
        *endOfStream = false;
 
        if(!GpibHw_availableBytesToRead(gpibHw, &availableCount))
        {
                return false;
        }
 
 
        while(availableCount > 0 && *bytesRead < bufLen)
        {
                if((bufLen - *bytesRead) < availableCount)
                {
                        bytesToCopy = bufLen - *bytesRead;
                }
                else
                {
                        bytesToCopy = availableCount;
                }
 
//              for(i=0; i<bytesToCopy; ++i)
//              {
//                      if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_READER_FIFO, &regVal))
//                      {
//                              return false;
//                      }
//
//                      buf[*bytesRead] = regVal & 0xFF;
//
//                      ++ (*bytesRead);
//              }
 
                if(!GpibHwAdapter_readFifo(gpibHw->ghwa, &(buf[*bytesRead]), bytesToCopy)) {
                        return false;
                }
 
                (*bytesRead) += bytesToCopy;
 
                if(!GpibHw_availableBytesToRead(gpibHw, &availableCount))
                {
                        return false;
                }
        }
 
        if(availableCount == 0)
        {
                if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_READER_CONTROL_0, &regVal))
                {
                        return false;
                }
 
                *endOfStream = GpibHwAdapter_getBitValue(regVal,
                                MASK_READER_CONTROL_0_endOfStream);
 
                if(GpibHwAdapter_getBitValue(regVal, MASK_READER_CONTROL_0_bufInterrupt))
                {
                        GpibHwAdapter_setBitValue(&regVal, MASK_READER_CONTROL_0_resetBuffer, 1);
 
                        if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_READER_CONTROL_0, regVal))
                        {
                                return false;
                        }
                }
        }
 
        return true;
}
 
bool GpibHw_bytesInWriterFifo(struct GpibHw *gpibHw, SizeType *count)
{
        RegType regVal;
 
        if(GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_WRITER_CONTROL_1, &regVal))
        {
                *count = GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo);
 
                return true;
        }
        else
        {
                return false;
        }
}
 
bool GpibHw_write(struct GpibHw *gpibHw, char *buf, SizeType bufLen,
                SizeType *bytesWritten, bool endOfStream)
{
        RegType regVal;
        SizeType outFifoCount;
        SizeType bytesToCopy;
        //SizeType i;
 
        *bytesWritten = 0;
 
        GpibHw_bytesInWriterFifo(gpibHw, &outFifoCount);
 
        if(gpibHw->writerLastEndOfStream)
        {
                if(outFifoCount > 0)
                {
                        return true;
                }
                else
                {
                        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_WRITER_CONTROL_0, &regVal))
                        {
                                return false;
                        }
 
                        GpibHwAdapter_setBitValue(&regVal, MASK_WRITER_CONTROL_0_resetBuffer, 1);
                        GpibHwAdapter_setBitValue(&regVal, MASK_WRITER_CONTROL_0_endOfStream, 0);
 
                        if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_WRITER_CONTROL_0, regVal))
                        {
                                return false;
                        }
 
                        gpibHw->writerLastEndOfStream = false;
                }
        }
 
        while(outFifoCount < MAX_FIFO_LEN && *bytesWritten < bufLen)
        {
                if((bufLen - *bytesWritten) <= (MAX_FIFO_LEN - outFifoCount))
                {
                        bytesToCopy = bufLen - *bytesWritten;
 
                        if(endOfStream)
                        {
                                if(bytesToCopy == 1)
                                {
                                        if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_WRITER_CONTROL_0, &regVal))
                                        {
                                                return false;
                                        }
 
                                        GpibHwAdapter_setBitValue(&regVal, MASK_WRITER_CONTROL_0_endOfStream, 1);
 
                                        if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_WRITER_CONTROL_0, regVal))
                                        {
                                                return false;
                                        }
 
                                        gpibHw->writerLastEndOfStream = true;
                                }
                                else
                                {
                                        bytesToCopy --;
                                }
                        }
                }
                else
                {
                        bytesToCopy = MAX_FIFO_LEN - outFifoCount;
                }
 
//              for(i=0; i<bytesToCopy; ++i)
//              {
//                      if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_WRITER_FIFO, buf[*bytesWritten]))
//                      {
//                              return false;
//                      }
//
//                      ++ (*bytesWritten);
//              }
 
                if(!GpibHwAdapter_writeFifo(gpibHw->ghwa, &(buf[*bytesWritten]), bytesToCopy))
                {
                        return false;
                }
 
                *bytesWritten += bytesToCopy;
 
                if(!GpibHw_bytesInWriterFifo(gpibHw, &outFifoCount))
                {
                        return false;
                }
        }
 
        return true;
}

Browse

Tools

Subversion Repositories gpib_controller

[/] [gpib_controller/] [trunk/] [prototype_1/] [PC_software/] [gpib_src/] [GpibHw.c] - Blame information for rev 3

Line No.	Rev	Author	Line
1	3	Andrewski	`/*`
2			`* GpibHw.c`
3			`*`
4			`* Created on: Feb 9, 2012`
5			`* Author: Andrzej Paluch`
6			`*/`
7
8			`#include "GpibHw.h"`
9
10			`#define MAX_FIFO_LEN 2047`
11
12			`bool GpibHw_init(struct GpibHw gpibHw, struct GpibHwAdapter ghwa)`
13			`{`
14			`gpibHw->ghwa = ghwa;`
15			`gpibHw->writerLastEndOfStream = false;`
16
17			`return ghwa != 0;`
18			`}`
19
20			`void GpibHw_release(struct GpibHw *gpibHw)`
21			`{`
22			`// do nothing`
23			`}`
24
25			`bool GpibHw_getSettings(struct GpibHw gpibHw, struct GpibHwSettings settings)`
26			`{`
27			`RegType regVal;`
28
29			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_SETTING_0, &regVal))`
30			`{`
31			`return false;`
32			`}`
33
34			`settings->talkOnly = GpibHwAdapter_getBitValue(regVal, MASK_SETTING0_ton);`
35			`settings->listenOnly = GpibHwAdapter_getBitValue(regVal, MASK_SETTING0_lon);`
36			`settings->eosMark = GpibHwAdapter_getFieldValue(regVal, MASK_SETTING0_eosMark);`
37			`settings->eosUsed = GpibHwAdapter_getBitValue(regVal, MASK_SETTING0_eosUsed);`
38			`settings->fixedPpLine = GpibHwAdapter_getFieldValue(regVal, MASK_SETTING0_fixedPpLine);`
39			`settings->lpeUsed = GpibHwAdapter_getBitValue(regVal, MASK_SETTING0_lpeUsed);`
40			`settings->isLeTe = GpibHwAdapter_getBitValue(regVal, MASK_SETTING0_isLeTe);`
41
42			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_SETTING_1, &regVal))`
43			`{`
44			`return false;`
45			`}`
46
47			`settings->T1 = GpibHwAdapter_getFieldValue(regVal, MASK_SETTING1_T1);`
48			`settings->address = GpibHwAdapter_getFieldValue(regVal, MASK_SETTING1_addr);`
49
50			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_SEC_ADDR_0, &regVal))`
51			`{`
52			`return false;`
53			`}`
54
55			`settings->secondaryAddressMask = regVal;`
56
57			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_SEC_ADDR_1, &regVal))`
58			`{`
59			`return false;`
60			`}`
61
62			`settings->secondaryAddressMask \|= regVal << 16;`
63
64			`return true;`
65			`}`
66
67			`bool GpibHw_setSettings(struct GpibHw gpibHw, struct GpibHwSettings settings)`
68			`{`
69			`RegType regVal = 0;`
70
71			`GpibHwAdapter_setBitValue(&regVal, MASK_SETTING0_ton, settings->talkOnly);`
72			`GpibHwAdapter_setBitValue(&regVal, MASK_SETTING0_lon, settings->listenOnly);`
73			`GpibHwAdapter_setFieldValue(&regVal, MASK_SETTING0_eosMark, settings->eosMark);`
74			`GpibHwAdapter_setBitValue(&regVal, MASK_SETTING0_eosUsed, settings->eosUsed);`
75			`GpibHwAdapter_setFieldValue(&regVal, MASK_SETTING0_fixedPpLine, settings->fixedPpLine);`
76			`GpibHwAdapter_setBitValue(&regVal, MASK_SETTING0_lpeUsed, settings->lpeUsed);`
77			`GpibHwAdapter_setBitValue(&regVal, MASK_SETTING0_isLeTe, settings->isLeTe);`
78
79			`if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_SETTING_0, regVal))`
80			`{`
81			`return false;`
82			`}`
83
84			`GpibHwAdapter_setFieldValue(&regVal, MASK_SETTING1_T1, settings->T1);`
85			`GpibHwAdapter_setFieldValue(&regVal, MASK_SETTING1_addr, settings->address);`
86
87			`if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_SETTING_1, regVal))`
88			`{`
89			`return false;`
90			`}`
91
92			`regVal = settings->secondaryAddressMask & 0xffff;`
93
94			`if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_SEC_ADDR_0, regVal))`
95			`{`
96			`return false;`
97			`}`
98
99			`regVal = settings->secondaryAddressMask >> 16;`
100
101			`if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_SEC_ADDR_1, regVal))`
102			`{`
103			`return false;`
104			`}`
105
106			`return true;`
107			`}`
108
109			`bool GpibHw_getEventStatus(struct GpibHw gpibHw, struct GpibHwEvents events)`
110			`{`
111			`RegType regVal;`
112
113			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_EVENT, &regVal))`
114			`{`
115			`return false;`
116			`}`
117
118			`events->IFC = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_IFC);`
119			`events->ATN = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_ATN);`
120			`events->REN = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_REN);`
121			`events->stb_received = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_stb_received);`
122			`events->ppr = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_ppr);`
123			`events->srq = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_srq);`
124			`events->cwrd = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_cwrd);`
125			`events->cwrc = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_cwrc);`
126			`events->spa = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_spa);`
127			`events->atl = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_atl);`
128			`events->att = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_att);`
129			`events->trg = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_trg);`
130			`events->clr = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_clr);`
131			`events->out_ready = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_out_buf_full);`
132			`events->in_ready = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_in_buf_full);`
133			`events->isLocal = GpibHwAdapter_getBitValue(regVal, MASK_EVENT_isLocal);`
134
135			`return true;`
136			`}`
137
138			`bool GpibHw_getGpibStatus(struct GpibHw gpibHw, struct GpibHwStatus status)`
139			`{`
140			`RegType regVal;`
141
142			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_GPIB_STATUS, &regVal))`
143			`{`
144			`return false;`
145			`}`
146
147			`status->isLocal = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_isLocal);`
148			`status->spa = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_spa);`
149			`status->cwrd = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrd);`
150			`status->cwrc = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrc);`
151			`status->lac = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_lac);`
152			`status->atl = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_atl);`
153			`status->tac = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_tac);`
154			`status->att = GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_att);`
155			`status->currentSecondaryAddress =`
156			`GpibHwAdapter_getFieldValue(regVal, MASK_GPIB_STATUS_currentSecAddr);`
157
158			`return true;`
159			`}`
160
161			`bool GpibHw_requestSystemControl(struct GpibHw *gpibHw, bool value)`
162			`{`
163			`RegType regVal;`
164
165			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
166			`{`
167			`return false;`
168			`}`
169
170			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_rsc, value);`
171
172			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
173			`}`
174
175			`bool GpibHw_systemInterfaceClear(struct GpibHw *gpibHw, bool value)`
176			`{`
177			`RegType regVal;`
178
179			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
180			`{`
181			`return false;`
182			`}`
183
184			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_sic, value);`
185
186			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
187			`}`
188
189			`bool GpibHw_sendRemoteEnable(struct GpibHw *gpibHw, bool value)`
190			`{`
191			`RegType regVal;`
192
193			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
194			`{`
195			`return false;`
196			`}`
197
198			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_sre, value);`
199
200			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
201			`}`
202
203			`bool GpibHw_goToStandby(struct GpibHw *gpibHw, bool value)`
204			`{`
205			`RegType regVal;`
206
207			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
208			`{`
209			`return false;`
210			`}`
211
212			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_gts, value);`
213
214			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
215			`}`
216
217			`bool GpibHw_takeControlAsynchronously(struct GpibHw *gpibHw, bool value)`
218			`{`
219			`RegType regVal;`
220
221			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
222			`{`
223			`return false;`
224			`}`
225
226			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_tca, value);`
227
228			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
229			`}`
230
231			`bool GpibHw_takeControlSynchronously(struct GpibHw *gpibHw, bool value)`
232			`{`
233			`RegType regVal;`
234
235			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
236			`{`
237			`return false;`
238			`}`
239
240			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_tcs, value);`
241
242			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
243			`}`
244
245			`bool GpibHw_requestParallelPoll(struct GpibHw *gpibHw, bool value)`
246			`{`
247			`RegType regVal;`
248
249			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
250			`{`
251			`return false;`
252			`}`
253
254			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_rpp, value);`
255
256			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
257			`}`
258
259			`bool GpibHw_receiveStatusByte(struct GpibHw *gpibHw, bool value)`
260			`{`
261			`RegType regVal;`
262
263			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
264			`{`
265			`return false;`
266			`}`
267
268			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_rec_stb, value);`
269
270			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
271			`}`
272
273			`bool GpibHw_localPollEnable(struct GpibHw *gpibHw, bool value)`
274			`{`
275			`RegType regVal;`
276
277			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
278			`{`
279			`return false;`
280			`}`
281
282			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_lpe, value);`
283
284			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
285			`}`
286
287			`bool GpibHw_setIndividualStatus(struct GpibHw *gpibHw, bool value)`
288			`{`
289			`RegType regVal;`
290
291			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
292			`{`
293			`return false;`
294			`}`
295
296			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_ist, value);`
297
298			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
299			`}`
300
301			`bool GpibHw_requestService(struct GpibHw *gpibHw, bool value)`
302			`{`
303			`RegType regVal;`
304
305			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
306			`{`
307			`return false;`
308			`}`
309
310			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_rsv, value);`
311
312			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
313			`}`
314
315			`bool GpibHw_returnToLocal(struct GpibHw *gpibHw, bool value)`
316			`{`
317			`RegType regVal;`
318
319			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
320			`{`
321			`return false;`
322			`}`
323
324			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_rtl, value);`
325
326			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
327			`}`
328
329			`bool GpibHw_setLocalListenUnlisten(struct GpibHw *gpibHw, bool ltn, bool lun)`
330			`{`
331			`RegType regVal;`
332
333			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_CONTROL, &regVal))`
334			`{`
335			`return false;`
336			`}`
337
338			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_ltn, ltn);`
339			`GpibHwAdapter_setBitValue(&regVal, MASK_CONTROL_lun, lun);`
340
341			`return GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_CONTROL, regVal);`
342			`}`
343
344			`bool GpibHw_availableBytesToRead(struct GpibHw gpibHw, SizeType count)`
345			`{`
346			`RegType regVal;`
347
348			`if(GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_READER_CONTROL_1, &regVal))`
349			`{`
350			`*count = GpibHwAdapter_getFieldValue(regVal, MASK_READER_CONTROL_1_bytesInFifo);`
351
352			`return true;`
353			`}`
354			`else`
355			`{`
356			`return false;`
357			`}`
358			`}`
359
360			`bool GpibHw_read(struct GpibHw gpibHw, char buf, SizeType bufLen,`
361			`SizeType bytesRead, bool endOfStream)`
362			`{`
363			`RegType regVal;`
364			`SizeType availableCount;`
365			`SizeType bytesToCopy;`
366			`//SizeType i;`
367
368			`*bytesRead = 0;`
369			`*endOfStream = false;`
370
371			`if(!GpibHw_availableBytesToRead(gpibHw, &availableCount))`
372			`{`
373			`return false;`
374			`}`
375
376
377			`while(availableCount > 0 && *bytesRead < bufLen)`
378			`{`
379			`if((bufLen - *bytesRead) < availableCount)`
380			`{`
381			`bytesToCopy = bufLen - *bytesRead;`
382			`}`
383			`else`
384			`{`
385			`bytesToCopy = availableCount;`
386			`}`
387
388			`// for(i=0; i<bytesToCopy; ++i)`
389			`// {`
390			`// if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_READER_FIFO, &regVal))`
391			`// {`
392			`// return false;`
393			`// }`
394			`//`
395			`// buf[*bytesRead] = regVal & 0xFF;`
396			`//`
397			`// ++ (*bytesRead);`
398			`// }`
399
400			`if(!GpibHwAdapter_readFifo(gpibHw->ghwa, &(buf[*bytesRead]), bytesToCopy)) {`
401			`return false;`
402			`}`
403
404			`(*bytesRead) += bytesToCopy;`
405
406			`if(!GpibHw_availableBytesToRead(gpibHw, &availableCount))`
407			`{`
408			`return false;`
409			`}`
410			`}`
411
412			`if(availableCount == 0)`
413			`{`
414			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_READER_CONTROL_0, &regVal))`
415			`{`
416			`return false;`
417			`}`
418
419			`*endOfStream = GpibHwAdapter_getBitValue(regVal,`
420			`MASK_READER_CONTROL_0_endOfStream);`
421
422			`if(GpibHwAdapter_getBitValue(regVal, MASK_READER_CONTROL_0_bufInterrupt))`
423			`{`
424			`GpibHwAdapter_setBitValue(&regVal, MASK_READER_CONTROL_0_resetBuffer, 1);`
425
426			`if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_READER_CONTROL_0, regVal))`
427			`{`
428			`return false;`
429			`}`
430			`}`
431			`}`
432
433			`return true;`
434			`}`
435
436			`bool GpibHw_bytesInWriterFifo(struct GpibHw gpibHw, SizeType count)`
437			`{`
438			`RegType regVal;`
439
440			`if(GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_WRITER_CONTROL_1, &regVal))`
441			`{`
442			`*count = GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo);`
443
444			`return true;`
445			`}`
446			`else`
447			`{`
448			`return false;`
449			`}`
450			`}`
451
452			`bool GpibHw_write(struct GpibHw gpibHw, char buf, SizeType bufLen,`
453			`SizeType *bytesWritten, bool endOfStream)`
454			`{`
455			`RegType regVal;`
456			`SizeType outFifoCount;`
457			`SizeType bytesToCopy;`
458			`//SizeType i;`
459
460			`*bytesWritten = 0;`
461
462			`GpibHw_bytesInWriterFifo(gpibHw, &outFifoCount);`
463
464			`if(gpibHw->writerLastEndOfStream)`
465			`{`
466			`if(outFifoCount > 0)`
467			`{`
468			`return true;`
469			`}`
470			`else`
471			`{`
472			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_WRITER_CONTROL_0, &regVal))`
473			`{`
474			`return false;`
475			`}`
476
477			`GpibHwAdapter_setBitValue(&regVal, MASK_WRITER_CONTROL_0_resetBuffer, 1);`
478			`GpibHwAdapter_setBitValue(&regVal, MASK_WRITER_CONTROL_0_endOfStream, 0);`
479
480			`if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_WRITER_CONTROL_0, regVal))`
481			`{`
482			`return false;`
483			`}`
484
485			`gpibHw->writerLastEndOfStream = false;`
486			`}`
487			`}`
488
489			`while(outFifoCount < MAX_FIFO_LEN && *bytesWritten < bufLen)`
490			`{`
491			`if((bufLen - *bytesWritten) <= (MAX_FIFO_LEN - outFifoCount))`
492			`{`
493			`bytesToCopy = bufLen - *bytesWritten;`
494
495			`if(endOfStream)`
496			`{`
497			`if(bytesToCopy == 1)`
498			`{`
499			`if(!GpibHwAdapter_getReg(gpibHw->ghwa, REG_ADDR_WRITER_CONTROL_0, &regVal))`
500			`{`
501			`return false;`
502			`}`
503
504			`GpibHwAdapter_setBitValue(&regVal, MASK_WRITER_CONTROL_0_endOfStream, 1);`
505
506			`if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_WRITER_CONTROL_0, regVal))`
507			`{`
508			`return false;`
509			`}`
510
511			`gpibHw->writerLastEndOfStream = true;`
512			`}`
513			`else`
514			`{`
515			`bytesToCopy --;`
516			`}`
517			`}`
518			`}`
519			`else`
520			`{`
521			`bytesToCopy = MAX_FIFO_LEN - outFifoCount;`
522			`}`
523
524			`// for(i=0; i<bytesToCopy; ++i)`
525			`// {`
526			`// if(!GpibHwAdapter_setReg(gpibHw->ghwa, REG_ADDR_WRITER_FIFO, buf[*bytesWritten]))`
527			`// {`
528			`// return false;`
529			`// }`
530			`//`
531			`// ++ (*bytesWritten);`
532			`// }`
533
534			`if(!GpibHwAdapter_writeFifo(gpibHw->ghwa, &(buf[*bytesWritten]), bytesToCopy))`
535			`{`
536			`return false;`
537			`}`
538
539			`*bytesWritten += bytesToCopy;`
540
541			`if(!GpibHw_bytesInWriterFifo(gpibHw, &outFifoCount))`
542			`{`
543			`return false;`
544			`}`
545			`}`
546
547			`return true;`
548			`}`