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

Subversion Repositories gpib_controller

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

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


/*
 * RegAccess_linux.c
 *
 *  Created on: 2012-01-28
 *      Author: Andrzej Paluch
 */
#include <string.h>
 
#include <unistd.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#include "GpibRegAccess.h"
 
 
#define HND(handle) ((int)handle)
 
void GpibRegAccess_setFlags(int fd, SizeType dataLength)
{
        struct termios settings;
 
        memset(&settings, 0, sizeof(settings));
 
        settings.c_cflag = B921600 | CS8 | CLOCAL;
 
        //settings.c_lflag = IGNPAR;
 
        settings.c_cc[VINTR]    = 0;     /* Ctrl-c */
        settings.c_cc[VQUIT]    = 0;     /* Ctrl-\ */
        settings.c_cc[VERASE]   = 0;     /* del */
        settings.c_cc[VKILL]    = 0;     /* @ */
        settings.c_cc[VEOF]     = 0;     /* Ctrl-d */
        settings.c_cc[VTIME]    = 0;     /* inter-character timer unused */
        /* blocking read until "dataLength" characters arrives */
        settings.c_cc[VMIN]     = dataLength;
        settings.c_cc[VSWTC]    = 0;     /* '\0' */
        settings.c_cc[VSTART]   = 0;     /* Ctrl-q */
        settings.c_cc[VSTOP]    = 0;     /* Ctrl-s */
        settings.c_cc[VSUSP]    = 0;     /* Ctrl-z */
        settings.c_cc[VEOL]     = 0;     /* '\0' */
        settings.c_cc[VREPRINT] = 0;     /* Ctrl-r */
        settings.c_cc[VDISCARD] = 0;     /* Ctrl-u */
        settings.c_cc[VWERASE]  = 0;     /* Ctrl-w */
        settings.c_cc[VLNEXT]   = 0;     /* Ctrl-v */
        settings.c_cc[VEOL2]    = 0;     /* '\0' */
 
        //tcflush(fd, TCIFLUSH);
        tcsetattr(fd, TCSANOW, &settings);
}
 
bool GpibRegAccess_init(struct GpibRegAccess *ra)
{
        const char *portName = "/dev/ttyUSB0";
 
        ra->isBurstMode = false;
 
        ra->portHandle = (HandleType) open(portName, O_RDWR | O_NOCTTY);
 
        int fd = HND(ra->portHandle);
 
        if(fd > 0)
        {
                tcflush(fd, TCIFLUSH);
                GpibRegAccess_setFlags(fd, 2);
 
        }
 
        return fd >= 0;
}
 
void GpibRegAccess_release(struct GpibRegAccess *ra)
{
        int fd = HND(ra->portHandle);
 
        if(fd >= 0)
        {
                close(fd);
        }
}
 
bool GpibRegAccess_readReg(struct GpibRegAccess *ra, SizeType addr, RegType *pValue)
{
        int fd = HND(ra->portHandle);
 
        if(fd >= 0)
        {
                if(ra->isBurstMode)
                {
                        ra->isBurstMode = false;
                        GpibRegAccess_setFlags(fd, 2);
                }
 
                unsigned char realAddr = (unsigned char)addr | 0x80;
                ssize_t bytesWrittenRead;
 
                bytesWrittenRead = write(fd, &realAddr, 1);
 
                if(bytesWrittenRead != 1)
                {
                        return false;
                }
 
                bytesWrittenRead = read(fd, pValue, 2);
 
                if(bytesWrittenRead != 2)
                {
                        return false;
                }
                else
                {
                        return true;
                }
        }
        else
        {
                return false;
        }
}
 
bool GpibRegAccess_repeatedlyRead(struct GpibRegAccess *ra, SizeType addr,
                char *buf, SizeType bufLen)
{
        int fd = HND(ra->portHandle);
        int i;
 
        if(fd > 0)
        {
                if(!ra->isBurstMode)
                {
                        ra->isBurstMode = true;
                        GpibRegAccess_setFlags(fd, 1);
                }
 
                unsigned char realAddr = (unsigned char)addr | 0xc0;
                ssize_t bytesWrittenRead;
                char addrBuf[3];
 
                addrBuf[0] = realAddr;
                addrBuf[1] = bufLen & 0xFF;
                addrBuf[2] = (bufLen >> 8) & 0xFF;
 
                bytesWrittenRead = write(fd, addrBuf, 3);
 
                if(bytesWrittenRead != 3)
                {
                        return false;
                }
 
                bytesWrittenRead = 0;
 
                for(i=0; i<bufLen; i++)
                {
                        bytesWrittenRead += read(fd, buf+i, 1);
                }
 
                //bytesWrittenRead = read(fd, buf, bufLen);
 
                if(bytesWrittenRead != bufLen)
                {
                        return false;
                }
                else
                {
                        return true;
                }
 
                return true;
        }
        else
        {
                return false;
        }
}
 
bool GpibRegAccess_writeReg(struct GpibRegAccess *ra, SizeType addr, RegType value)
{
        int fd = HND(ra->portHandle);
 
        if(fd >= 0)
        {
                if(ra->isBurstMode)
                {
                        ra->isBurstMode = false;
                        GpibRegAccess_setFlags(fd, 2);
                }
 
                unsigned char realAddr = (unsigned char)addr & 0x7F;
                unsigned int writeBuf;
                ssize_t bytesWrittenRead;
 
                writeBuf = realAddr;
                writeBuf |= value << 8;
 
                bytesWrittenRead = write(fd, &writeBuf, 3);
 
                if(bytesWrittenRead != 3)
                {
                        return false;
                }
                else
                {
                        return true;
                }
        }
        else
        {
                return false;
        }
}
 
bool GpibRegAccess_repeatedlyWrite(struct GpibRegAccess *ra, SizeType addr,
                char *buf, SizeType bufLen)
{
        int fd = HND(ra->portHandle);
 
        if(fd > 0)
        {
                unsigned char realAddr = (unsigned char)addr | 0x40;
                ssize_t bytesWrittenRead;
                char addrBuf[3];
 
                addrBuf[0] = realAddr;
                addrBuf[1] = bufLen & 0xFF;
                addrBuf[2] = (bufLen >> 8) & 0xFF;
 
                bytesWrittenRead = write(fd, addrBuf, 3);
 
                if(bytesWrittenRead != 3)
                {
                        return false;
                }
 
                bytesWrittenRead = write(fd, buf, bufLen);
 
                if(bytesWrittenRead != bufLen)
                {
                        return false;
                }
                else
                {
                        return true;
                }
 
                return true;
        }
        else
        {
                return false;
        }
}

Browse

Tools

Subversion Repositories gpib_controller

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

Line No.	Rev	Author	Line
1	3	Andrewski	`/*`
2			`* RegAccess_linux.c`
3			`*`
4			`* Created on: 2012-01-28`
5			`* Author: Andrzej Paluch`
6			`*/`
7			`#include <string.h>`
8
9			`#include <unistd.h>`
10			`#include <termios.h>`
11			`#include <sys/types.h>`
12			`#include <sys/stat.h>`
13			`#include <fcntl.h>`
14
15			`#include "GpibRegAccess.h"`
16
17
18			`#define HND(handle) ((int)handle)`
19
20			`void GpibRegAccess_setFlags(int fd, SizeType dataLength)`
21			`{`
22			`struct termios settings;`
23
24			`memset(&settings, 0, sizeof(settings));`
25
26			`settings.c_cflag = B921600 \| CS8 \| CLOCAL;`
27
28			`//settings.c_lflag = IGNPAR;`
29
30			`settings.c_cc[VINTR] = 0; /* Ctrl-c */`
31			`settings.c_cc[VQUIT] = 0; /* Ctrl-\ */`
32			`settings.c_cc[VERASE] = 0; /* del */`
33			`settings.c_cc[VKILL] = 0; /* @ */`
34			`settings.c_cc[VEOF] = 0; /* Ctrl-d */`
35			`settings.c_cc[VTIME] = 0; /* inter-character timer unused */`
36			`/* blocking read until "dataLength" characters arrives */`
37			`settings.c_cc[VMIN] = dataLength;`
38			`settings.c_cc[VSWTC] = 0; /* '\0' */`
39			`settings.c_cc[VSTART] = 0; /* Ctrl-q */`
40			`settings.c_cc[VSTOP] = 0; /* Ctrl-s */`
41			`settings.c_cc[VSUSP] = 0; /* Ctrl-z */`
42			`settings.c_cc[VEOL] = 0; /* '\0' */`
43			`settings.c_cc[VREPRINT] = 0; /* Ctrl-r */`
44			`settings.c_cc[VDISCARD] = 0; /* Ctrl-u */`
45			`settings.c_cc[VWERASE] = 0; /* Ctrl-w */`
46			`settings.c_cc[VLNEXT] = 0; /* Ctrl-v */`
47			`settings.c_cc[VEOL2] = 0; /* '\0' */`
48
49			`//tcflush(fd, TCIFLUSH);`
50			`tcsetattr(fd, TCSANOW, &settings);`
51			`}`
52
53			`bool GpibRegAccess_init(struct GpibRegAccess *ra)`
54			`{`
55			`const char *portName = "/dev/ttyUSB0";`
56
57			`ra->isBurstMode = false;`
58
59			`ra->portHandle = (HandleType) open(portName, O_RDWR \| O_NOCTTY);`
60
61			`int fd = HND(ra->portHandle);`
62
63			`if(fd > 0)`
64			`{`
65			`tcflush(fd, TCIFLUSH);`
66			`GpibRegAccess_setFlags(fd, 2);`
67
68			`}`
69
70			`return fd >= 0;`
71			`}`
72
73			`void GpibRegAccess_release(struct GpibRegAccess *ra)`
74			`{`
75			`int fd = HND(ra->portHandle);`
76
77			`if(fd >= 0)`
78			`{`
79			`close(fd);`
80			`}`
81			`}`
82
83			`bool GpibRegAccess_readReg(struct GpibRegAccess ra, SizeType addr, RegType pValue)`
84			`{`
85			`int fd = HND(ra->portHandle);`
86
87			`if(fd >= 0)`
88			`{`
89			`if(ra->isBurstMode)`
90			`{`
91			`ra->isBurstMode = false;`
92			`GpibRegAccess_setFlags(fd, 2);`
93			`}`
94
95			`unsigned char realAddr = (unsigned char)addr \| 0x80;`
96			`ssize_t bytesWrittenRead;`
97
98			`bytesWrittenRead = write(fd, &realAddr, 1);`
99
100			`if(bytesWrittenRead != 1)`
101			`{`
102			`return false;`
103			`}`
104
105			`bytesWrittenRead = read(fd, pValue, 2);`
106
107			`if(bytesWrittenRead != 2)`
108			`{`
109			`return false;`
110			`}`
111			`else`
112			`{`
113			`return true;`
114			`}`
115			`}`
116			`else`
117			`{`
118			`return false;`
119			`}`
120			`}`
121
122			`bool GpibRegAccess_repeatedlyRead(struct GpibRegAccess *ra, SizeType addr,`
123			`char *buf, SizeType bufLen)`
124			`{`
125			`int fd = HND(ra->portHandle);`
126			`int i;`
127
128			`if(fd > 0)`
129			`{`
130			`if(!ra->isBurstMode)`
131			`{`
132			`ra->isBurstMode = true;`
133			`GpibRegAccess_setFlags(fd, 1);`
134			`}`
135
136			`unsigned char realAddr = (unsigned char)addr \| 0xc0;`
137			`ssize_t bytesWrittenRead;`
138			`char addrBuf[3];`
139
140			`addrBuf[0] = realAddr;`
141			`addrBuf[1] = bufLen & 0xFF;`
142			`addrBuf[2] = (bufLen >> 8) & 0xFF;`
143
144			`bytesWrittenRead = write(fd, addrBuf, 3);`
145
146			`if(bytesWrittenRead != 3)`
147			`{`
148			`return false;`
149			`}`
150
151			`bytesWrittenRead = 0;`
152
153			`for(i=0; i<bufLen; i++)`
154			`{`
155			`bytesWrittenRead += read(fd, buf+i, 1);`
156			`}`
157
158			`//bytesWrittenRead = read(fd, buf, bufLen);`
159
160			`if(bytesWrittenRead != bufLen)`
161			`{`
162			`return false;`
163			`}`
164			`else`
165			`{`
166			`return true;`
167			`}`
168
169			`return true;`
170			`}`
171			`else`
172			`{`
173			`return false;`
174			`}`
175			`}`
176
177			`bool GpibRegAccess_writeReg(struct GpibRegAccess *ra, SizeType addr, RegType value)`
178			`{`
179			`int fd = HND(ra->portHandle);`
180
181			`if(fd >= 0)`
182			`{`
183			`if(ra->isBurstMode)`
184			`{`
185			`ra->isBurstMode = false;`
186			`GpibRegAccess_setFlags(fd, 2);`
187			`}`
188
189			`unsigned char realAddr = (unsigned char)addr & 0x7F;`
190			`unsigned int writeBuf;`
191			`ssize_t bytesWrittenRead;`
192
193			`writeBuf = realAddr;`
194			`writeBuf \|= value << 8;`
195
196			`bytesWrittenRead = write(fd, &writeBuf, 3);`
197
198			`if(bytesWrittenRead != 3)`
199			`{`
200			`return false;`
201			`}`
202			`else`
203			`{`
204			`return true;`
205			`}`
206			`}`
207			`else`
208			`{`
209			`return false;`
210			`}`
211			`}`
212
213			`bool GpibRegAccess_repeatedlyWrite(struct GpibRegAccess *ra, SizeType addr,`
214			`char *buf, SizeType bufLen)`
215			`{`
216			`int fd = HND(ra->portHandle);`
217
218			`if(fd > 0)`
219			`{`
220			`unsigned char realAddr = (unsigned char)addr \| 0x40;`
221			`ssize_t bytesWrittenRead;`
222			`char addrBuf[3];`
223
224			`addrBuf[0] = realAddr;`
225			`addrBuf[1] = bufLen & 0xFF;`
226			`addrBuf[2] = (bufLen >> 8) & 0xFF;`
227
228			`bytesWrittenRead = write(fd, addrBuf, 3);`
229
230			`if(bytesWrittenRead != 3)`
231			`{`
232			`return false;`
233			`}`
234
235			`bytesWrittenRead = write(fd, buf, bufLen);`
236
237			`if(bytesWrittenRead != bufLen)`
238			`{`
239			`return false;`
240			`}`
241			`else`
242			`{`
243			`return true;`
244			`}`
245
246			`return true;`
247			`}`
248			`else`
249			`{`
250			`return false;`
251			`}`
252			`}`