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 12

Details | Compare with Previous | View Log


/*
*This file is part of fpga_gpib_controller.
*
* Fpga_gpib_controller is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Fpga_gpib_controller is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Fpga_gpib_controller.  If not, see <http://www.gnu.org/licenses/>.
*/
/*
 * 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 12

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