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 6

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


 
#include <string.h>
#include <stdio.h>
 
#include <unistd.h>
 
#include "GpibRegAccess.h"
#include "GpibHwAdapter.h"
#include "GpibHw.h"
 
 
int gpibExplorerMain(int argc, char* argv[])
{
        struct GpibRegAccess ra;
        struct GpibHwAdapter ghw;
        struct GpibHw gpib;
 
        RegType regVal;
 
        GpibRegAccess_init(&ra);
        GpibHwAdapter_init(&ghw, &ra, 0);
        GpibHw_init(&gpib, &ghw);
 
        struct GpibHwSettings gs;
        // set T1
        GpibHw_getSettings(&gpib, &gs);
        gs.T1 = 132;
        GpibHw_setSettings(&gpib, &gs);
 
        // request system control
        GpibHw_requestSystemControl(&gpib, 1);
 
        // go to standby
        GpibHw_goToStandby(&gpib, 0);
        GpibHw_takeControlAsynchronously(&gpib, 1);
 
        // system interface clear
        GpibHw_systemInterfaceClear(&gpib, 1);
 
        // remote enable
        GpibHw_sendRemoteEnable(&gpib, 1);
 
        do
        {
                GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
        }
        while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrc));
 
 
        GpibHw_systemInterfaceClear(&gpib, 0);
 
        GpibHw_takeControlAsynchronously(&gpib, 0);
 
        do
        {
                GpibHwAdapter_getReg(&ghw, REG_ADDR_EVENT, &regVal);
        }
        while(GpibHwAdapter_getBitValue(regVal, MASK_EVENT_IFC));
 
        char buf[2048];
        SizeType bytesRead;
        SizeType bytesWritten;
        bool endOfStream;
 
 
 
        do
        {
                // set not to listen ///////////////////////////////////////
                /*if(!GpibHwAdapter_getReg(&ghw, REG_ADDR_CONTROL, &regVal))
                {
                        return false;
                }
 
                GpibHwAdapter_setBitValue(regVal, MASK_CONTROL_ltn, 0);
 
                if(!GpibHwAdapter_setReg(&ghw, REG_ADDR_CONTROL, regVal))
                {
                        return false;
                }*/
                ////////////////////////////////////////////////////////
 
                // write command
                int cmdLen = 2;
                buf[0] = 0x22;
                buf[1] = 0x41;
 
                bytesWritten = 0;
 
                do
                {
                        GpibHw_write(&gpib, buf + bytesWritten, cmdLen - bytesWritten,
                                        &bytesWritten, false);
                }
                while(bytesWritten < cmdLen);
 
                do
                {
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_WRITER_CONTROL_1, &regVal);
                }
                while(GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo) > 0);
 
 
                // go to standby
                GpibHw_goToStandby(&gpib, 1);
 
                do
                {
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
                }
                while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrd));
 
                GpibHw_goToStandby(&gpib, 0);
 
                FILE *file = 0;
                bool readAgain;
                bool doExit;
 
                do
                {
                        readAgain = false;
                        doExit = false;
 
                        // gets command
                        gets(buf);
 
                        if(strlen(buf) == 1 && buf[0] == 'e')
                        {
                                if(file)
                                {
                                        fclose(file);
                                }
 
                                doExit = true;
                                break;
                        }
                        else if(strstr(buf, "save_to_file") != 0)
                        {
                                char fileName[512];
                                sscanf(buf, "save_to_file %s", fileName);
                                file = fopen(fileName, "wb");
                                readAgain = true;
                        }
                }
                while(readAgain);
 
                if(doExit)
                {
                        break;
                }
 
                //buf[strlen(buf) + 1] = 0;
                //buf[strlen(buf)] = '\n';
 
                // write data
                bytesWritten = 0;
                u32 tmpBytesWritten;
 
                do
                {
                        GpibHw_write(&gpib, buf + bytesWritten, strlen(buf) - bytesWritten,
                                        &tmpBytesWritten, true);
                        bytesWritten += tmpBytesWritten;
                }
                while(bytesWritten < strlen(buf));
 
                do
                {
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_WRITER_CONTROL_1, &regVal);
                }
                while(GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo) > 0);
 
                // take control
                GpibHw_takeControlAsynchronously(&gpib, 1);
 
                do
                {
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
                }
                while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrc));
 
                GpibHw_takeControlAsynchronously(&gpib, 0);
 
 
                // set to listen ///////////////////////////////////////
                /*if(!GpibHwAdapter_getReg(&ghw, REG_ADDR_CONTROL, &regVal))
                {
                        return false;
                }
 
                GpibHwAdapter_setBitValue(regVal, MASK_CONTROL_ltn, 1);
 
                if(!GpibHwAdapter_setReg(&ghw, REG_ADDR_CONTROL, regVal))
                {
                        return false;
                }*/
                ////////////////////////////////////////////////////////
 
 
                // write command
                bytesWritten = 0;
                buf[0] = 0x21;
                buf[1] = 0x42;
 
                do
                {
                        GpibHw_write(&gpib, buf + bytesWritten, 2 - bytesWritten,
                                        &bytesWritten, false);
                }
                while(bytesWritten < 2);
 
                do
                {
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_WRITER_CONTROL_1, &regVal);
                }
                while(GpibHwAdapter_getFieldValue(regVal, MASK_WRITER_CONTROL_1_bytesInFifo) > 0);
 
                GpibHwAdapter_getReg(&ghw, REG_ADDR_BUS_STATUS, &regVal);
 
                // go to standby
                GpibHw_goToStandby(&gpib, true);
 
                do
                {
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
                }
                while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrd));
 
                GpibHw_goToStandby(&gpib, false);
 
 
                int timeout = 0;
                // read data
                do
                {
                        GpibHw_read(&gpib, buf, 2047, &bytesRead, &endOfStream);
 
                        if(bytesRead > 0)
                        {
                                buf[bytesRead] = 0;
                                timeout = 0;
 
                                if(!file)
                                {
                                        printf("%s", buf);
                                }
                                else
                                {
                                        fwrite(buf, 1, bytesRead, file);
                                }
                        }
 
                        timeout ++;
 
                        if((timeout > 500 && !file) || (timeout > 20000 && file))
                        {
                                break;
                        }
                }
                while(!endOfStream);
 
                if(file)
                {
                        fclose(file);
                        file = 0;
                }
 
                // take control
                GpibHw_takeControlAsynchronously(&gpib, 1);
 
                do
                {
                        GpibHwAdapter_getReg(&ghw, REG_ADDR_GPIB_STATUS, &regVal);
                }
                while(!GpibHwAdapter_getBitValue(regVal, MASK_GPIB_STATUS_cwrc));
 
                GpibHw_takeControlAsynchronously(&gpib, 0);
        }
        while(true);
 
        // remote disable
        GpibHw_sendRemoteEnable(&gpib, 0);
 
        GpibHw_release(&gpib);
        GpibHwAdapter_release(&ghw);
        GpibRegAccess_release(&ra);
 
        return 0;
}

Browse

Tools

Subversion Repositories gpib_controller

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

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