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

Subversion Repositories gpib_controller

[/] [gpib_controller/] [trunk/] [prototype_1/] [PC_software/] [test_src/] [gpibExplorer_Test.c] - Blame information for rev 13

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

Line No. Rev Author Line
1 12 Andrewski 
/*
2 
*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 
* Author: Andrzej Paluch
17 
*/
18 3 Andrewski 
 
19 
#include <string.h>
20 
#include <stdio.h>
21 
 
22 
#include <unistd.h>
23 
 
24 
#include "GpibRegAccess.h"
25 
#include "GpibHwAdapter.h"
26 
#include "GpibHw.h"
27 
 
28 
 
29 
int gpibExplorerMain(int argc, char* argv[])
30 
{
31 
        struct GpibRegAccess ra;
32 
        struct GpibHwAdapter ghw;
33 
        struct GpibHw gpib;
34 
 
35 
        RegType regVal;
36 
 
37 
        GpibRegAccess_init(&ra);
38 
        GpibHwAdapter_init(&ghw, &ra, 0);
39 
        GpibHw_init(&gpib, &ghw);
40 
 
41 
        struct GpibHwSettings gs;
42 
        // set T1
43 
        GpibHw_getSettings(&gpib, &gs);
44 
        gs.T1 = 132;
45 
        GpibHw_setSettings(&gpib, &gs);
46 
 
47 
        // request system control
48 
        GpibHw_requestSystemControl(&gpib, 1);
49 
 
50 
        // go to standby
51 
        GpibHw_goToStandby(&gpib, 0);
52 
        GpibHw_takeControlAsynchronously(&gpib, 1);
53 
 
54 
        // system interface clear
55 
        GpibHw_systemInterfaceClear(&gpib, 1);
56 
 
57 
        // remote enable
58 
        GpibHw_sendRemoteEnable(&gpib, 1);
59 
 
60 
        do
61 
        {
62 
                GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
63 
        }
64 
        while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrc));
65 
 
66 
 
67 
        GpibHw_systemInterfaceClear(&gpib, 0);
68 
 
69 
        GpibHw_takeControlAsynchronously(&gpib, 0);
70 
 
71 
        do
72 
        {
73 
                GpibHwAdapter_getReg(&ghw, REG_ADDR_EVENT, &regVal);
74 
        }
75 
        while(GpibHwAdapter_getBitValue(regVal, MASK_EVENT_IFC));
76 
 
77 
        char buf[2048];
78 
        SizeType bytesRead;
79 
        SizeType bytesWritten;
80 
        bool endOfStream;
81 
 
82 
 
83 
 
84 
        do
85 
        {
86 
                // set not to listen ///////////////////////////////////////
87 
                /*if(!GpibHwAdapter_getReg(&ghw, REG_ADDR_CONTROL, &regVal))
88 
                {
89 
                        return false;
90 
                }
91 
 
92 
                GpibHwAdapter_setBitValue(regVal, MASK_CONTROL_ltn, 0);
93 
 
94 
                if(!GpibHwAdapter_setReg(&ghw, REG_ADDR_CONTROL, regVal))
95 
                {
96 
                        return false;
97 
                }*/
98 
                ////////////////////////////////////////////////////////
99 
 
100 
                // write command
101 
                int cmdLen = 2;
102 
                buf[0] = 0x22;
103 
                buf[1] = 0x41;
104 
 
105 
                bytesWritten = 0;
106 
 
107 
                do
108 
                {
109 
                        GpibHw_write(&gpib, buf + bytesWritten, cmdLen - bytesWritten,
110 
                                        &bytesWritten, false);
111 
                }
112 
                while(bytesWritten < cmdLen);
113 
 
114 
                do
115 
                {
116 
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_WRITER_CONTROL_1, &regVal);
117 
                }
118 
                while(GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo) > 0);
119 
 
120 
 
121 
                // go to standby
122 
                GpibHw_goToStandby(&gpib, 1);
123 
 
124 
                do
125 
                {
126 
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
127 
                }
128 
                while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrd));
129 
 
130 
                GpibHw_goToStandby(&gpib, 0);
131 
 
132 
                FILE *file = 0;
133 
                bool readAgain;
134 
                bool doExit;
135 
 
136 
                do
137 
                {
138 
                        readAgain = false;
139 
                        doExit = false;
140 
 
141 
                        // gets command
142 
                        gets(buf);
143 
 
144 
                        if(strlen(buf) == 1 && buf[0] == 'e')
145 
                        {
146 
                                if(file)
147 
                                {
148 
                                        fclose(file);
149 
                                }
150 
 
151 
                                doExit = true;
152 
                                break;
153 
                        }
154 
                        else if(strstr(buf, "save_to_file") != 0)
155 
                        {
156 
                                char fileName[512];
157 
                                sscanf(buf, "save_to_file %s", fileName);
158 
                                file = fopen(fileName, "wb");
159 
                                readAgain = true;
160 
                        }
161 
                }
162 
                while(readAgain);
163 
 
164 
                if(doExit)
165 
                {
166 
                        break;
167 
                }
168 
 
169 
                //buf[strlen(buf) + 1] = 0;
170 
                //buf[strlen(buf)] = '\n';
171 
 
172 
                // write data
173 
                bytesWritten = 0;
174 
                u32 tmpBytesWritten;
175 
 
176 
                do
177 
                {
178 
                        GpibHw_write(&gpib, buf + bytesWritten, strlen(buf) - bytesWritten,
179 
                                        &tmpBytesWritten, true);
180 
                        bytesWritten += tmpBytesWritten;
181 
                }
182 
                while(bytesWritten < strlen(buf));
183 
 
184 
                do
185 
                {
186 
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_WRITER_CONTROL_1, &regVal);
187 
                }
188 
                while(GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo) > 0);
189 
 
190 
                // take control
191 
                GpibHw_takeControlAsynchronously(&gpib, 1);
192 
 
193 
                do
194 
                {
195 
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
196 
                }
197 
                while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrc));
198 
 
199 
                GpibHw_takeControlAsynchronously(&gpib, 0);
200 
 
201 
 
202 
                // set to listen ///////////////////////////////////////
203 
                /*if(!GpibHwAdapter_getReg(&ghw, REG_ADDR_CONTROL, &regVal))
204 
                {
205 
                        return false;
206 
                }
207 
 
208 
                GpibHwAdapter_setBitValue(regVal, MASK_CONTROL_ltn, 1);
209 
 
210 
                if(!GpibHwAdapter_setReg(&ghw, REG_ADDR_CONTROL, regVal))
211 
                {
212 
                        return false;
213 
                }*/
214 
                ////////////////////////////////////////////////////////
215 
 
216 
 
217 
                // write command
218 
                bytesWritten = 0;
219 
                buf[0] = 0x21;
220 
                buf[1] = 0x42;
221 
 
222 
                do
223 
                {
224 
                        GpibHw_write(&gpib, buf + bytesWritten, 2 - bytesWritten,
225 
                                        &bytesWritten, false);
226 
                }
227 
                while(bytesWritten < 2);
228 
 
229 
                do
230 
                {
231 
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_WRITER_CONTROL_1, &regVal);
232 
                }
233 
                while(GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo) > 0);
234 
 
235 
                GpibHwAdapter_getReg(&ghw, REG_ADDR_BUS_STATUS, &regVal);
236 
 
237 
                // go to standby
238 
                GpibHw_goToStandby(&gpib, true);
239 
 
240 
                do
241 
                {
242 
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
243 
                }
244 
                while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrd));
245 
 
246 
                GpibHw_goToStandby(&gpib, false);
247 
 
248 
 
249 
                int timeout = 0;
250 
                // read data
251 
                do
252 
                {
253 
                        GpibHw_read(&gpib, buf, 2047, &bytesRead, &endOfStream);
254 
 
255 
                        if(bytesRead > 0)
256 
                        {
257 
                                buf[bytesRead] = 0;
258 
                                timeout = 0;
259 
 
260 
                                if(!file)
261 
                                {
262 
                                        printf("%s", buf);
263 
                                }
264 
                                else
265 
                                {
266 
                                        fwrite(buf, 1, bytesRead, file);
267 
                                }
268 
                        }
269 
 
270 
                        timeout ++;
271 
 
272 
                        if((timeout > 500 && !file) || (timeout > 20000 && file))
273 
                        {
274 
                                break;
275 
                        }
276 
                }
277 
                while(!endOfStream);
278 
 
279 
                if(file)
280 
                {
281 
                        fclose(file);
282 
                        file = 0;
283 
                }
284 
 
285 
                // take control
286 
                GpibHw_takeControlAsynchronously(&gpib, 1);
287 
 
288 
                do
289 
                {
290 
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
291 
                }
292 
                while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrc));
293 
 
294 
                GpibHw_takeControlAsynchronously(&gpib, 0);
295 
        }
296 
        while(true);
297 
 
298 
        // remote disable
299 
        GpibHw_sendRemoteEnable(&gpib, 0);
300 
 
301 
        GpibHw_release(&gpib);
302 
        GpibHwAdapter_release(&ghw);
303 
        GpibRegAccess_release(&ra);
304 
 
305 
        return 0;
306 
}

powered by: WebSVN 2.1.0

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