OpenCores
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 12

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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