|
1 ########################################################################## |
|
2 # Copyright (c) 2011 Lawrence Berkeley National Laboratory, Accelerator |
|
3 # Technology Group, Engineering Division |
|
4 # This code is distributed subject to a Software License Agreement found |
|
5 # in file LICENSE that is included with this distribution. |
|
6 ########################################################################## |
|
7 |
|
8 # |
|
9 # Basic SCPI (IEEE488.2) commands |
|
10 # |
|
11 record(waveform, "$(P)$(R)IDN") |
|
12 { |
|
13 field(DESC, "SCPI identification string") |
|
14 field(DTYP, "stream") |
|
15 field(INP, "@devKeithley6487.proto getIDN(119) $(PORT) $(A)") |
|
16 field(PINI, "YES") |
|
17 field(FTVL, "CHAR") |
|
18 field(NELM, "120") |
|
19 } |
|
20 record(bo, "$(P)$(R)RST") |
|
21 { |
|
22 field(DESC, "SCPI Reset") |
|
23 field(DTYP, "stream") |
|
24 field(OUT, "@devKeithley6487.proto cmd(*RST) $(PORT) $(A)") |
|
25 } |
|
26 record(bo, "$(P)$(R)CLS") |
|
27 { |
|
28 field(DESC, "SCPI Clear status") |
|
29 field(DTYP, "stream") |
|
30 field(OUT, "@devKeithley6487.proto cmd(*CLS) $(PORT) $(A)") |
|
31 } |
|
32 record(bo, "$(P)$(R)TRG") |
|
33 { |
|
34 field(DESC, "SCPI trigger") |
|
35 field(DTYP, "stream") |
|
36 field(OUT, "@devKeithley6487.proto cmd(*TRG) $(PORT) $(A)") |
|
37 } |
|
38 record(longin, "$(P)$(R)GetSTB") |
|
39 { |
|
40 field(DESC, "SCPI get status byte") |
|
41 field(DTYP, "stream") |
|
42 field(INP, "@devKeithley6487.proto getD(*STB) $(PORT) $(A)") |
|
43 } |
|
44 record(longin, "$(P)$(R)GetESR") |
|
45 { |
|
46 field(DESC, "SCPI get event status") |
|
47 field(DTYP, "stream") |
|
48 field(INP, "@devKeithley6487.proto getD(*ESR) $(PORT) $(A)") |
|
49 } |
|
50 record(longout, "$(P)$(R)SetESE") |
|
51 { |
|
52 field(DESC, "SCPI enable event status") |
|
53 field(DTYP, "stream") |
|
54 field(OUT, "@devKeithley6487.proto setD(*ESE) $(PORT) $(A)") |
|
55 } |
|
56 record(longin, "$(P)$(R)GetESE") |
|
57 { |
|
58 field(DESC, "SCPI enabled event status") |
|
59 field(DTYP, "stream") |
|
60 field(INP, "@devKeithley6487.proto getD(*ESE) $(PORT) $(A)") |
|
61 } |
|
62 record(longout, "$(P)$(R)SetSRE") |
|
63 { |
|
64 field(DESC, "SCPI enable service requests") |
|
65 field(DTYP, "stream") |
|
66 field(OUT, "@devKeithley6487.proto setD(*SRE) $(PORT) $(A)") |
|
67 } |
|
68 record(longin, "$(P)$(R)GetSRE") |
|
69 { |
|
70 field(DESC, "Enabled service requests") |
|
71 field(DTYP, "stream") |
|
72 field(INP, "@devKeithley6487.proto getD(*SRE) $(PORT) $(A)") |
|
73 } |
|
74 record(longin, "$(P)$(R)GetOPC") |
|
75 { |
|
76 field(DESC, "Output completion status") |
|
77 field(DTYP, "stream") |
|
78 field(INP, "@devKeithley6487.proto getD(*OPC) $(PORT) $(A)") |
|
79 } |
|
80 |
|
81 # |
|
82 # Unlock/Lock local controls |
|
83 # |
|
84 record(bo, "$(P)$(R)KLOCK") |
|
85 { |
|
86 field(DESC, "Lock out all local controls") |
|
87 field(DTYP, "stream") |
|
88 field(OUT, "@devKeithley6487.proto setD(SYST:KLOCK) $(PORT) $(A)") |
|
89 field(ZNAM, "Unlocked") |
|
90 field(ONAM, "Locked") |
|
91 field(FLNK, "$(P)$(R)KLOCKRBV") |
|
92 } |
|
93 record(bi, "$(P)$(R)KLOCKRBV") |
|
94 { |
|
95 field(DESC, "All local controls locked?") |
|
96 field(DTYP, "stream") |
|
97 field(INP, "@devKeithley6487.proto getD(SYST:KLOCK) $(PORT) $(A)") |
|
98 field(ZNAM, "Unlocked") |
|
99 field(ONAM, "Locked") |
|
100 field(PINI, "YES") |
|
101 } |
|
102 |
|
103 # |
|
104 # Reading |
|
105 # |
|
106 record(ai, "$(P)$(R)Measure") |
|
107 { |
|
108 field(DESC, "Measure current") |
|
109 field(DTYP, "stream") |
|
110 field(INP, "@devKeithley6487.proto measureCurrent $(PORT) $(A)") |
|
111 field(EGU, "A") |
|
112 field(PREC, "5") |
|
113 } |
|
114 record(waveform, "$(P)$(R)FetchWF") |
|
115 { |
|
116 field(DESC, "Fetch buffered data") |
|
117 field(DTYP, "stream") |
|
118 field(INP, "@devKeithley6487.proto fetchBuffered $(PORT) $(A)") |
|
119 field(EGU, "A") |
|
120 field(PREC, "5") |
|
121 field(FTVL, "FLOAT") |
|
122 field(NELM, "$(NELM=1000)") |
|
123 } |
|
124 |
|
125 # |
|
126 # Zero-check |
|
127 # |
|
128 record(bo, "$(P)$(R)ZeroCheck") |
|
129 { |
|
130 field(DESC, "Disable/Enable zero check (input clamp)") |
|
131 field(DTYP, "stream") |
|
132 field(OUT, "@devKeithley6487.proto setD(SYST:ZCH) $(PORT) $(A)") |
|
133 field(ZNAM, "Off") |
|
134 field(ONAM, "On") |
|
135 field(FLNK, "$(P)$(R)ZeroCheckRBV") |
|
136 } |
|
137 record(bi, "$(P)$(R)ZeroCheckRBV") |
|
138 { |
|
139 field(DESC, "Disable/Enable zero check (input clamp)") |
|
140 field(DTYP, "stream") |
|
141 field(INP, "@devKeithley6487.proto getD(SYST:ZCH) $(PORT) $(A)") |
|
142 field(ZNAM, "Off") |
|
143 field(ONAM, "On") |
|
144 field(PINI, "YES") |
|
145 } |
|
146 |
|
147 # |
|
148 # Range |
|
149 # |
|
150 record(bo, "$(P)$(R)AutoRange") |
|
151 { |
|
152 field(DESC, "Disable/Enable auto-range") |
|
153 field(DTYP, "stream") |
|
154 field(OUT, "@devKeithley6487.proto setD(RANG:AUTO) $(PORT) $(A)") |
|
155 field(ZNAM, "Fixed") |
|
156 field(ONAM, "Auto") |
|
157 field(FLNK, "$(P)$(R)AutoRangeRBV") |
|
158 } |
|
159 record(bi, "$(P)$(R)AutoRangeRBV") |
|
160 { |
|
161 field(DESC, "Disable/Enable auto-range") |
|
162 field(DTYP, "stream") |
|
163 field(INP, "@devKeithley6487.proto getD(RANG:AUTO) $(PORT) $(A)") |
|
164 field(ZNAM, "Fixed") |
|
165 field(ONAM, "Auto") |
|
166 field(PINI, "YES") |
|
167 } |
|
168 record(mbbo, "$(P)$(R)Range") |
|
169 { |
|
170 field(DESC, "Full-scale range") |
|
171 field(DTYP, "stream") |
|
172 field(OUT, "@devKeithley6487.proto setRange $(PORT) $(A)") |
|
173 field(ZRVL, "9") |
|
174 field(ZRST, "2 nA") |
|
175 field(ONVL, "8") |
|
176 field(ONST, "20 nA") |
|
177 field(TWVL, "7") |
|
178 field(TWST, "200 nA") |
|
179 field(THVL, "6") |
|
180 field(THST, "2 uA") |
|
181 field(FRVL, "5") |
|
182 field(FRST, "20 uA") |
|
183 field(FVVL, "4") |
|
184 field(FVST, "200 uA") |
|
185 field(SXVL, "3") |
|
186 field(SXST, "2 mA") |
|
187 field(SVVL, "2") |
|
188 field(SVST, "20 mA") |
|
189 field(FLNK, "$(P)$(R)RangeRBV") |
|
190 } |
|
191 record(mbbi, "$(P)$(R)RangeRBV") |
|
192 { |
|
193 field(DESC, "Full-scale range readback") |
|
194 field(DTYP, "stream") |
|
195 field(INP, "@devKeithley6487.proto getRange $(PORT) $(A)") |
|
196 field(ZRVL, "9") |
|
197 field(ZRST, "2 nA") |
|
198 field(ONVL, "8") |
|
199 field(ONST, "20 nA") |
|
200 field(TWVL, "7") |
|
201 field(TWST, "200 nA") |
|
202 field(THVL, "6") |
|
203 field(THST, "2 uA") |
|
204 field(FRVL, "5") |
|
205 field(FRST, "20 uA") |
|
206 field(FVVL, "4") |
|
207 field(FVST, "200 uA") |
|
208 field(SXVL, "3") |
|
209 field(SXST, "2 mA") |
|
210 field(SVVL, "2") |
|
211 field(SVST, "20 mA") |
|
212 field(PINI, "YES") |
|
213 } |
|
214 |
|
215 # |
|
216 # Filtering |
|
217 # |
|
218 record(ao, "$(P)$(R)IntegrationTime") |
|
219 { |
|
220 field(DESC, "Reading integration time") |
|
221 field(DTYP, "stream") |
|
222 field(OUT, "@devKeithley6487.proto setF(NPLC) $(PORT) $(A)") |
|
223 field(EGU, "Cycles") |
|
224 field(PREC, "2") |
|
225 field(LOPR, "0") |
|
226 field(HOPR, "60") |
|
227 field(DRVL, "0.01") |
|
228 field(DRVH, "60") |
|
229 field(FLNK, "$(P)$(R)IntegrationTimeRBV") |
|
230 } |
|
231 record(ai, "$(P)$(R)IntegrationTimeRBV") |
|
232 { |
|
233 field(DESC, "Reading integration time") |
|
234 field(DTYP, "stream") |
|
235 field(INP, "@devKeithley6487.proto getF(NPLC) $(PORT) $(A)") |
|
236 field(EGU, "Cycles") |
|
237 field(PREC, "2") |
|
238 field(LOPR, "0") |
|
239 field(HOPR, "60") |
|
240 field(PINI, "YES") |
|
241 } |
|
242 record(longout, "$(P)$(R)FilterCount") |
|
243 { |
|
244 field(DESC, "Number of samples in reading") |
|
245 field(DTYP, "stream") |
|
246 field(OUT, "@devKeithley6487.proto setD(AVER:COUN) $(PORT) $(A)") |
|
247 field(EGU, "Samples") |
|
248 field(LOPR, "2") |
|
249 field(HOPR, "100") |
|
250 field(DRVL, "2") |
|
251 field(DRVH, "100") |
|
252 field(FLNK, "$(P)$(R)FilterCountRBV") |
|
253 } |
|
254 record(longin, "$(P)$(R)FilterCountRBV") |
|
255 { |
|
256 field(DESC, "Number of samples in reading") |
|
257 field(DTYP, "stream") |
|
258 field(INP, "@devKeithley6487.proto getD(AVER:COUN) $(PORT) $(A)") |
|
259 field(EGU, "Samples") |
|
260 field(LOPR, "2") |
|
261 field(HOPR, "100") |
|
262 field(PINI, "YES") |
|
263 } |
|
264 record(bo, "$(P)$(R)FilterEnable") |
|
265 { |
|
266 field(DESC, "Disable/Enable filter") |
|
267 field(DTYP, "stream") |
|
268 field(OUT, "@devKeithley6487.proto setD(AVER) $(PORT) $(A)") |
|
269 field(ZNAM, "Disable") |
|
270 field(ONAM, "Enable") |
|
271 field(FLNK, "$(P)$(R)FilterEnableRBV") |
|
272 } |
|
273 record(bi, "$(P)$(R)FilterEnableRBV") |
|
274 { |
|
275 field(DESC, "Disable/Enable filter") |
|
276 field(DTYP, "stream") |
|
277 field(INP, "@devKeithley6487.proto getD(AVER) $(PORT) $(A)") |
|
278 field(ZNAM, "Disable") |
|
279 field(ONAM, "Enable") |
|
280 field(PINI, "YES") |
|
281 } |
|
282 record(bo, "$(P)$(R)Damping") |
|
283 { |
|
284 field(DESC, "Disable/Enable damping") |
|
285 field(DTYP, "stream") |
|
286 field(OUT, "@devKeithley6487.proto setD(DAMP) $(PORT) $(A)") |
|
287 field(ZNAM, "Disable") |
|
288 field(ONAM, "Enable") |
|
289 field(FLNK, "$(P)$(R)DampingRBV") |
|
290 } |
|
291 record(bi, "$(P)$(R)DampingRBV") |
|
292 { |
|
293 field(DESC, "Disable/Enable damping") |
|
294 field(DTYP, "stream") |
|
295 field(INP, "@devKeithley6487.proto getD(DAMP) $(PORT) $(A)") |
|
296 field(ZNAM, "Disable") |
|
297 field(ONAM, "Enable") |
|
298 field(PINI, "YES") |
|
299 } |
|
300 |
|
301 # |
|
302 # Triggering |
|
303 # |
|
304 record(mbbo, "$(P)$(R)ArmSource") |
|
305 { |
|
306 field(DESC, "Arm source") |
|
307 field(DTYP, "stream") |
|
308 field(OUT, "@devKeithley6487.proto setArmSource $(PORT) $(A)") |
|
309 field(ZRVL, "0") |
|
310 field(ZRST, "Immediate") |
|
311 field(ONVL, "1") |
|
312 field(ONST, "GPIB/Serial") |
|
313 field(TWVL, "2") |
|
314 field(TWST, "Timer") |
|
315 field(THVL, "3") |
|
316 field(THST, "Manual") |
|
317 field(FRVL, "4") |
|
318 field(FRST, "Trigger Link") |
|
319 field(FVVL, "5") |
|
320 field(FVST, "SOT falling") |
|
321 field(SXVL, "6") |
|
322 field(SXST, "SOT rising") |
|
323 field(SVVL, "7") |
|
324 field(SVST, "SOT transition") |
|
325 field(FLNK, "$(P)$(R)ArmSourceRBV") |
|
326 } |
|
327 record(mbbi, "$(P)$(R)ArmSourceRBV") |
|
328 { |
|
329 field(DESC, "Arm source readback") |
|
330 field(DTYP, "stream") |
|
331 field(INP, "@devKeithley6487.proto getArmSource $(PORT) $(A)") |
|
332 field(ZRVL, "0") |
|
333 field(ZRST, "Immediate") |
|
334 field(ONVL, "1") |
|
335 field(ONST, "GPIB/Serial") |
|
336 field(TWVL, "2") |
|
337 field(TWST, "Timer") |
|
338 field(THVL, "3") |
|
339 field(THST, "Manual") |
|
340 field(FRVL, "4") |
|
341 field(FRST, "Trigger Link") |
|
342 field(FVVL, "5") |
|
343 field(FVST, "SOT falling") |
|
344 field(SXVL, "6") |
|
345 field(SXST, "SOT rising") |
|
346 field(SVVL, "7") |
|
347 field(SVST, "SOT transition") |
|
348 field(PINI, "YES") |
|
349 } |
|
350 record(mbbo, "$(P)$(R)ArmLine") |
|
351 { |
|
352 field(DESC, "TLINK arm line") |
|
353 field(DTYP, "stream") |
|
354 field(OUT, "@devKeithley6487.proto setD(ARM:ILIN) $(PORT) $(A)") |
|
355 field(ONVL, "1") |
|
356 field(ONST, " TLink 1") |
|
357 field(TWVL, "2") |
|
358 field(TWST, " TLink 2") |
|
359 field(THVL, "3") |
|
360 field(THST, " TLink 3") |
|
361 field(FRVL, "4") |
|
362 field(FRST, " TLink 4") |
|
363 field(FVVL, "5") |
|
364 field(FVST, " TLink 5") |
|
365 field(SXVL, "6") |
|
366 field(SXST, " TLink 6") |
|
367 field(FLNK, "$(P)$(R)ArmLineRBV") |
|
368 } |
|
369 record(mbbi, "$(P)$(R)ArmLineRBV") |
|
370 { |
|
371 field(DESC, "TLINK arm line") |
|
372 field(DTYP, "stream") |
|
373 field(INP, "@devKeithley6487.proto getD(ARM:ILIN) $(PORT) $(A)") |
|
374 field(ONVL, "1") |
|
375 field(ONST, " TLink 1") |
|
376 field(TWVL, "2") |
|
377 field(TWST, " TLink 2") |
|
378 field(THVL, "3") |
|
379 field(THST, " TLink 3") |
|
380 field(FRVL, "4") |
|
381 field(FRST, " TLink 4") |
|
382 field(FVVL, "5") |
|
383 field(FVST, " TLink 5") |
|
384 field(SXVL, "6") |
|
385 field(SXST, " TLink 6") |
|
386 field(PINI, "YES") |
|
387 } |
|
388 record(ao, "$(P)$(R)ArmTimerInterval") |
|
389 { |
|
390 field(DESC, "Arm timer interval") |
|
391 field(DTYP, "stream") |
|
392 field(OUT, "@devKeithley6487.proto setF(ARM:TIM) $(PORT) $(A)") |
|
393 field(EGU, "s") |
|
394 field(PREC, "5") |
|
395 field(LOPR, "0") |
|
396 field(HOPR, "1e5") |
|
397 field(DRVL, "0.001") |
|
398 field(DRVH, "99999.999") |
|
399 field(FLNK, "$(P)$(R)ArmTimerIntervalRBV") |
|
400 } |
|
401 record(ai, "$(P)$(R)ArmTimerIntervalRBV") |
|
402 { |
|
403 field(DESC, "Arm timer interval") |
|
404 field(DTYP, "stream") |
|
405 field(INP, "@devKeithley6487.proto getF(ARM:TIM) $(PORT) $(A)") |
|
406 field(EGU, "s") |
|
407 field(PREC, "5") |
|
408 field(LOPR, "0") |
|
409 field(HOPR, "1e5") |
|
410 field(PINI, "YES") |
|
411 } |
|
412 record(longout, "$(P)$(R)ArmCount") |
|
413 { |
|
414 field(DESC, "Arm count") |
|
415 field(DTYP, "stream") |
|
416 field(OUT, "@devKeithley6487.proto setD(ARM:COUN) $(PORT) $(A)") |
|
417 field(LOPR, "1") |
|
418 field(HOPR, "2048") |
|
419 field(DRVL, "1") |
|
420 field(DRVH, "2048") |
|
421 field(FLNK, "$(P)$(R)ArmCountRBV") |
|
422 } |
|
423 record(longin, "$(P)$(R)ArmCountRBV") |
|
424 { |
|
425 field(DESC, "Arm count") |
|
426 field(DTYP, "stream") |
|
427 field(INP, "@devKeithley6487.proto getD(ARM:COUN) $(PORT) $(A)") |
|
428 field(LOPR, "1") |
|
429 field(HOPR, "2048") |
|
430 field(PINI, "YES") |
|
431 } |
|
432 record(mbbo, "$(P)$(R)TriggerSource") |
|
433 { |
|
434 field(DESC, "Trigger source") |
|
435 field(DTYP, "stream") |
|
436 field(OUT, "@devKeithley6487.proto setTriggerSource $(PORT) $(A)") |
|
437 field(ZRVL, "0") |
|
438 field(ZRST, "Immediate") |
|
439 field(ONVL, "1") |
|
440 field(ONST, "Trigger Link") |
|
441 field(FLNK, "$(P)$(R)TriggerSourceRBV") |
|
442 } |
|
443 record(mbbi, "$(P)$(R)TriggerSourceRBV") |
|
444 { |
|
445 field(DESC, "Trigger source readback") |
|
446 field(DTYP, "stream") |
|
447 field(INP, "@devKeithley6487.proto getTriggerSource $(PORT) $(A)") |
|
448 field(ZRVL, "0") |
|
449 field(ZRST, "Immediate") |
|
450 field(ONVL, "1") |
|
451 field(ONST, "Trigger Link") |
|
452 field(PINI, "YES") |
|
453 } |
|
454 record(mbbo, "$(P)$(R)TriggerLine") |
|
455 { |
|
456 field(DESC, "TLINK trigger line") |
|
457 field(DTYP, "stream") |
|
458 field(OUT, "@devKeithley6487.proto setD(TRIG:ILIN) $(PORT) $(A)") |
|
459 field(ONVL, "1") |
|
460 field(ONST, " TLink 1") |
|
461 field(TWVL, "2") |
|
462 field(TWST, " TLink 2") |
|
463 field(THVL, "3") |
|
464 field(THST, " TLink 3") |
|
465 field(FRVL, "4") |
|
466 field(FRST, " TLink 4") |
|
467 field(FVVL, "5") |
|
468 field(FVST, " TLink 5") |
|
469 field(SXVL, "6") |
|
470 field(SXST, " TLink 6") |
|
471 field(FLNK, "$(P)$(R)TriggerLineRBV") |
|
472 } |
|
473 record(mbbi, "$(P)$(R)TriggerLineRBV") |
|
474 { |
|
475 field(DESC, "TLINK trigger line") |
|
476 field(DTYP, "stream") |
|
477 field(INP, "@devKeithley6487.proto getD(TRIG:ILIN) $(PORT) $(A)") |
|
478 field(ONVL, "1") |
|
479 field(ONST, " TLink 1") |
|
480 field(TWVL, "2") |
|
481 field(TWST, " TLink 2") |
|
482 field(THVL, "3") |
|
483 field(THST, " TLink 3") |
|
484 field(FRVL, "4") |
|
485 field(FRST, " TLink 4") |
|
486 field(FVVL, "5") |
|
487 field(FVST, " TLink 5") |
|
488 field(SXVL, "6") |
|
489 field(SXST, " TLink 6") |
|
490 field(PINI, "YES") |
|
491 } |
|
492 record(ao, "$(P)$(R)TriggerDelay") |
|
493 { |
|
494 field(DESC, "Trigger Delay") |
|
495 field(DTYP, "stream") |
|
496 field(OUT, "@devKeithley6487.proto setF(TRIG:DEL) $(PORT) $(A)") |
|
497 field(EGU, "s") |
|
498 field(PREC, "5") |
|
499 field(LOPR, "0") |
|
500 field(HOPR, "1000") |
|
501 field(DRVL, "0") |
|
502 field(DRVH, "999.9998") |
|
503 field(FLNK, "$(P)$(R)TriggerDelayRBV") |
|
504 } |
|
505 record(ai, "$(P)$(R)TriggerDelayRBV") |
|
506 { |
|
507 field(DESC, "Trigger Delay") |
|
508 field(DTYP, "stream") |
|
509 field(INP, "@devKeithley6487.proto getF(TRIG:DEL) $(PORT) $(A)") |
|
510 field(EGU, "s") |
|
511 field(PREC, "5") |
|
512 field(LOPR, "0") |
|
513 field(HOPR, "1000") |
|
514 field(PINI, "YES") |
|
515 } |
|
516 record(bo, "$(P)$(R)TriggerDelayAuto") |
|
517 { |
|
518 field(DESC, "Disable/Enable trigger autodelay") |
|
519 field(DTYP, "stream") |
|
520 field(OUT, "@devKeithley6487.proto setD(TRIG:DEL:AUTO) $(PORT) $(A)") |
|
521 field(ZNAM, "Fixed") |
|
522 field(ONAM, "Auto") |
|
523 field(FLNK, "$(P)$(R)TriggerDelayAutoRBV") |
|
524 } |
|
525 record(bi, "$(P)$(R)TriggerDelayAutoRBV") |
|
526 { |
|
527 field(DESC, "Disable/Enable trigger autodelay") |
|
528 field(DTYP, "stream") |
|
529 field(INP, "@devKeithley6487.proto getD(TRIG:DEL:AUTO) $(PORT) $(A)") |
|
530 field(ZNAM, "Fixed") |
|
531 field(ONAM, "Auto") |
|
532 field(PINI, "YES") |
|
533 } |
|
534 record(longout, "$(P)$(R)TriggerCount") |
|
535 { |
|
536 field(DESC, "Trigger count") |
|
537 field(DTYP, "stream") |
|
538 field(OUT, "@devKeithley6487.proto setD(TRIG:COUN) $(PORT) $(A)") |
|
539 field(LOPR, "1") |
|
540 field(HOPR, "2048") |
|
541 field(DRVL, "1") |
|
542 field(DRVH, "2048") |
|
543 field(FLNK, "$(P)$(R)TriggerCountRBV") |
|
544 } |
|
545 record(longin, "$(P)$(R)TriggerCountRBV") |
|
546 { |
|
547 field(DESC, "Trigger count") |
|
548 field(DTYP, "stream") |
|
549 field(INP, "@devKeithley6487.proto getD(TRIG:COUN) $(PORT) $(A)") |
|
550 field(LOPR, "1") |
|
551 field(HOPR, "2048") |
|
552 field(PINI, "YES") |
|
553 } |
|
554 record(bo, "$(P)$(R)Start") |
|
555 { |
|
556 field(DESC, "SCPI Reset") |
|
557 field(DTYP, "stream") |
|
558 field(OUT, "@devKeithley6487.proto cmd(INIT) $(PORT) $(A)") |
|
559 } |
|
560 record(bo, "$(P)$(R)Cancel") |
|
561 { |
|
562 field(DESC, "Cancel trigger sequence") |
|
563 field(DTYP, "stream") |
|
564 field(OUT, "@devKeithley6487.proto cancel $(PORT) $(A)") |
|
565 } |
|
566 |
|
567 # |
|
568 # The MEASure? command resets a bunch of trigger settings. |
|
569 # This sequence record will restore them. |
|
570 # |
|
571 record(seq, "$(P)$(R)RestoreTriggerSettings") |
|
572 { |
|
573 field(DESC, "Restore trigger settings after MEASure?") |
|
574 field(LNK1, "$(P)$(R)ArmSource.PROC") |
|
575 field(LNK2, "$(P)$(R)ArmCount.PROC") |
|
576 field(LNK3, "$(P)$(R)TriggerSource.PROC") |
|
577 field(LNK6, "$(P)$(R)TriggerCount.PROC") |
|
578 field(LNK5, "$(P)$(R)TriggerDelayAuto.PROC") |
|
579 field(LNK4, "$(P)$(R)TriggerDelay.PROC") |
|
580 } |
|
581 record(seq, "$(P)$(R)ReadTriggerSettings") |
|
582 { |
|
583 field(DESC, "Read back trigger settings") |
|
584 field(LNK1, "$(P)$(R)ArmSourceRBV.PROC") |
|
585 field(LNK2, "$(P)$(R)ArmLineRBV.PROC") |
|
586 field(LNK3, "$(P)$(R)ArmTimerIntervalRBV.PROC") |
|
587 field(LNK4, "$(P)$(R)ArmCountRBV.PROC") |
|
588 field(LNK5, "$(P)$(R)TriggerSourceRBV.PROC") |
|
589 field(LNK6, "$(P)$(R)TriggerLineRBV.PROC") |
|
590 field(LNK7, "$(P)$(R)TriggerDelayRBV.PROC") |
|
591 field(LNK8, "$(P)$(R)TriggerDelayAutoRBV.PROC") |
|
592 field(LNK9, "$(P)$(R)TriggerCountRBV.PROC") |
|
593 } |
|
594 |
|
595 # |
|
596 # Voltage source |
|
597 # |
|
598 record(bo, "$(P)$(R)SourceEnable") |
|
599 { |
|
600 field(DESC, "Disable/Enable voltage source") |
|
601 field(DTYP, "stream") |
|
602 field(OUT, "@devKeithley6487.proto setD(SOUR:VOLT:STAT) $(PORT) $(A)") |
|
603 field(ZNAM, "Off") |
|
604 field(ONAM, "On") |
|
605 field(FLNK, "$(P)$(R)SourceEnableRBV") |
|
606 } |
|
607 record(bi, "$(P)$(R)SourceEnableRBV") |
|
608 { |
|
609 field(DESC, "Voltage source enabled?") |
|
610 field(DTYP, "stream") |
|
611 field(INP, "@devKeithley6487.proto getD(SOUR:VOLT:STAT) $(PORT) $(A)") |
|
612 field(ZNAM, "Off") |
|
613 field(ONAM, "On") |
|
614 field(PINI, "YES") |
|
615 } |
|
616 record(bo, "$(P)$(R)SourceInterlock") |
|
617 { |
|
618 field(DESC, "Disable/Enable interlock") |
|
619 field(DTYP, "stream") |
|
620 field(OUT, "@devKeithley6487.proto setD(SOUR:VOLT:INT) $(PORT) $(A)") |
|
621 field(ZNAM, "Disable") |
|
622 field(ONAM, "Enable") |
|
623 field(FLNK, "$(P)$(R)SourceInterlockRBV") |
|
624 } |
|
625 record(bi, "$(P)$(R)SourceInterlockRBV") |
|
626 { |
|
627 field(DESC, "Interlock status") |
|
628 field(DTYP, "stream") |
|
629 field(INP, "@devKeithley6487.proto getD(SOUR:VOLT:INT) $(PORT) $(A)") |
|
630 field(ONAM, "Good") |
|
631 field(ZNAM, "Broken") |
|
632 field(PINI, "YES") |
|
633 } |
|
634 record(mbbo, "$(P)$(R)SourceRange") |
|
635 { |
|
636 field(DESC, "Full-scale range") |
|
637 field(DTYP, "stream") |
|
638 field(OUT, "@devKeithley6487.proto setSourceRange $(PORT) $(A)") |
|
639 field(ZRVL, "10") |
|
640 field(ZRST, "10 V") |
|
641 field(ONVL, "50") |
|
642 field(ONST, "50 V") |
|
643 field(TWVL, "500") |
|
644 field(TWST, "500 V") |
|
645 field(FLNK, "$(P)$(R)SourceRangeRBV") |
|
646 } |
|
647 record(mbbi, "$(P)$(R)SourceRangeRBV") |
|
648 { |
|
649 field(DESC, "Full-scale range readback") |
|
650 field(DTYP, "stream") |
|
651 field(INP, "@devKeithley6487.proto getSourceRange $(PORT) $(A)") |
|
652 field(ZRVL, "0") |
|
653 field(ZRST, "10 V") |
|
654 field(ONVL, "1") |
|
655 field(ONST, "50 V") |
|
656 field(TWVL, "2") |
|
657 field(TWST, "500 V") |
|
658 } |
|
659 record(mbbo, "$(P)$(R)SourceIlimit") |
|
660 { |
|
661 field(DESC, "Source current limit") |
|
662 field(DTYP, "stream") |
|
663 field(OUT, "@devKeithley6487.proto setIlimit $(PORT) $(A)") |
|
664 field(ZRVL, "5") |
|
665 field(ZRST, "25 uA") |
|
666 field(ONVL, "4") |
|
667 field(ONST, "250 uA") |
|
668 field(TWVL, "3") |
|
669 field(TWST, "2.5 mA") |
|
670 field(THVL, "2") |
|
671 field(THST, "25 mA") |
|
672 field(FLNK, "$(P)$(R)SourceIlimitRBV") |
|
673 } |
|
674 record(mbbi, "$(P)$(R)SourceIlimitRBV") |
|
675 { |
|
676 field(DESC, "Source current limit") |
|
677 field(DTYP, "stream") |
|
678 field(INP, "@devKeithley6487.proto getIlimit $(PORT) $(A)") |
|
679 field(ZRVL, "5") |
|
680 field(ZRST, "25 uA") |
|
681 field(ONVL, "4") |
|
682 field(ONST, "250 uA") |
|
683 field(TWVL, "3") |
|
684 field(TWST, "2.5 mA") |
|
685 field(THVL, "2") |
|
686 field(THST, "25 mA") |
|
687 field(PINI, "YES") |
|
688 } |
|
689 record(ao, "$(P)$(R)SourceVoltage") |
|
690 { |
|
691 field(DESC, "Source voltage setpoint") |
|
692 field(DTYP, "stream") |
|
693 field(OUT, "@devKeithley6487.proto setF(SOUR:VOLT) $(PORT) $(A)") |
|
694 field(EGU, "V") |
|
695 field(PREC, "5") |
|
696 field(LOPR, "-505") |
|
697 field(HOPR, "505") |
|
698 field(DRVL, "-505") |
|
699 field(DRVH, "505") |
|
700 field(FLNK, "$(P)$(R)SourceVoltageRBV") |
|
701 } |
|
702 record(ai, "$(P)$(R)SourceVoltageRBV") |
|
703 { |
|
704 field(DESC, "Source voltage readback") |
|
705 field(DTYP, "stream") |
|
706 field(INP, "@devKeithley6487.proto getF(SOUR:VOLT) $(PORT) $(A)") |
|
707 field(EGU, "V") |
|
708 field(PREC, "5") |
|
709 field(LOPR, "-505") |
|
710 field(HOPR, "505") |
|
711 field(PINI, "YES") |
|
712 } |
|
713 record(seq, "$(P)$(R)SourceReadSettings") |
|
714 { |
|
715 field(DESC, "Read back source settings") |
|
716 field(LNK1, "$(P)$(R)SourceVoltageRBV.PROC") |
|
717 field(LNK2, "$(P)$(R)SourceEnableRBV.PROC") |
|
718 field(LNK3, "$(P)$(R)SourceInterlockRBV.PROC") |
|
719 field(LNK4, "$(P)$(R)SourceIlimitRBV.PROC") |
|
720 field(LNK5, "$(P)$(R)SourceRangeRBV.PROC") |
|
721 } |