visa_rs/instrument.rs
1use super::*;
2/// Session to a specified resource
3#[derive(Debug, PartialEq, Eq, Hash)]
4pub struct Instrument(pub(crate) OwnedSs);
5
6impl std::io::Write for Instrument {
7 fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
8 <&Instrument>::write(&mut &*self, buf)
9 }
10
11 fn flush(&mut self) -> std::io::Result<()> {
12 <&Instrument>::flush(&mut &*self)
13 }
14}
15
16impl std::io::Read for Instrument {
17 fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
18 <&Instrument>::read(&mut &*self, buf)
19 }
20}
21
22impl std::io::Write for &Instrument {
23 fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
24 let mut ret_cnt: vs::ViUInt32 = 0;
25 wrap_raw_error_in_unsafe!(vs::viWrite(
26 self.as_raw_ss(),
27 buf.as_ptr(),
28 buf.len() as _,
29 &mut ret_cnt as _
30 ))
31 .map_err(vs_to_io_err)?;
32
33 Ok(ret_cnt as _)
34 }
35
36 fn flush(&mut self) -> std::io::Result<()> {
37 self.visa_flush(flags::FlushMode::IO_OUT_BUF)
38 .map_err(vs_to_io_err)
39 // Flush the low-level I/O buffer used by viWrite
40 }
41}
42
43impl std::io::Read for &Instrument {
44 fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
45 let mut ret_cnt: vs::ViUInt32 = 0;
46 wrap_raw_error_in_unsafe!(vs::viRead(
47 self.as_raw_ss(),
48 buf.as_mut_ptr(),
49 buf.len() as _,
50 &mut ret_cnt as _
51 ))
52 .map_err(vs_to_io_err)?;
53 Ok(ret_cnt as _)
54 }
55}
56
57impl Instrument {
58 ///Manually flushes the specified buffers associated with formatted I/O operations and/or serial communication.
59 pub fn visa_flush(&self, mode: flags::FlushMode) -> Result<()> {
60 wrap_raw_error_in_unsafe!(vs::viFlush(self.as_raw_ss(), mode.bits()))?;
61 Ok(())
62 }
63 /// Returns a user-readable description of the status code passed to the operation.
64 pub fn status_desc(&self, error: Error) -> Result<VisaString> {
65 let mut desc: VisaBuf = new_visa_buf();
66 wrap_raw_error_in_unsafe!(vs::viStatusDesc(
67 self.as_raw_ss(),
68 error.into(),
69 desc.as_mut_ptr() as _
70 ))?;
71 Ok(desc.try_into().unwrap())
72 }
73 /// Establishes an access mode to the specified resources.
74 ///
75 /// This operation is used to obtain a lock on the specified resource. The caller can specify the type of lock requested—exclusive or shared lock—and the length of time the operation will suspend while waiting to acquire the lock before timing out. This operation can also be used for sharing and nesting locks.
76 ///
77 /// The session that gained a shared lock can pass the accessKey to other sessions for the purpose of sharing the lock. The session wanting to join the group of sessions sharing the lock can use the key as an input value to the requestedKey parameter. VISA will add the session to the list of sessions sharing the lock, as long as the requestedKey value matches the accessKey value for the particular resource. The session obtaining a shared lock in this manner will then have the same access privileges as the original session that obtained the lock.
78 ///
79 ///It is also possible to obtain nested locks through this operation. To acquire nested locks, invoke the viLock() operation with the same lock type as the previous invocation of this operation. For each session, viLock() and viUnlock() share a lock count, which is initialized to 0. Each invocation of viLock() for the same session (and for the same lockType) increases the lock count. In the case of a shared lock, it returns with the same accessKey every time. When a session locks the resource a multiple number of times, it is necessary to invoke the viUnlock() operation an equal number of times in order to unlock the resource. That is, the lock count increments for each invocation of viLock(), and decrements for each invocation of viUnlock(). A resource is actually unlocked only when the lock count is 0.
80 ///
81 ///The VISA locking mechanism enforces arbitration of accesses to resources on an individual basis. If a session locks a resource, operations invoked by other sessions to the same resource are serviced or returned with a locking error, depending on the operation and the type of lock used. If a session has an exclusive lock, other sessions cannot modify global attributes or invoke operations, but can still get attributes and set local attributes. If the session has a shared lock, other sessions that have shared locks can also modify global attributes and invoke operations. Regardless of which type of lock a session has, if the session is closed without first being unlocked, VISA automatically performs a viUnlock() on that session.
82 ///
83 ///The locking mechanism works for all processes and resources existing on the same computer. When using remote resources, however, the networking protocol may not provide the ability to pass lock requests to the remote device or resource. In this case, locks will behave as expected from multiple sessions on the same computer, but not necessarily on the remote device. For example, when using the VXI-11 protocol, exclusive lock requests can be sent to a device, but shared locks can only be handled locally.
84 ///
85 /// see also [`Self::lock_exclusive`], [`Self::lock_shared`] and [`Self::lock_shared_with_key`]
86 ///
87 pub fn lock(
88 &self,
89 mode: flags::AccessMode,
90 timeout: Duration,
91 key: Option<AccessKey>,
92 ) -> Result<Option<AccessKey>> {
93 if (mode & flags::AccessMode::SHARED_LOCK).is_empty() {
94 wrap_raw_error_in_unsafe!(vs::viLock(
95 self.as_raw_ss(),
96 mode.bits(),
97 timeout.as_millis() as _,
98 vs::VI_NULL as _,
99 vs::VI_NULL as _
100 ))?;
101 Ok(None)
102 } else {
103 let mut ak = new_visa_buf();
104 wrap_raw_error_in_unsafe!(vs::viLock(
105 self.as_raw_ss(),
106 mode.bits(),
107 timeout.as_millis() as _,
108 key.map(|x| x.as_vi_const_string())
109 .unwrap_or(vs::VI_NULL as _),
110 ak.as_mut_ptr() as _
111 ))?;
112 Ok(Some(ak.try_into().unwrap()))
113 }
114 }
115
116 pub fn lock_exclusive(&self, timeout: Duration) -> Result<()> {
117 wrap_raw_error_in_unsafe!(vs::viLock(
118 self.as_raw_ss(),
119 flags::AccessMode::EXCLUSIVE_LOCK.bits(),
120 timeout.as_millis() as _,
121 vs::VI_NULL as _,
122 vs::VI_NULL as _
123 ))?;
124 Ok(())
125 }
126
127 pub fn lock_shared(&self, timeout: Duration) -> Result<AccessKey> {
128 let mut ak = new_visa_buf();
129 wrap_raw_error_in_unsafe!(vs::viLock(
130 self.as_raw_ss(),
131 flags::AccessMode::EXCLUSIVE_LOCK.bits(),
132 timeout.as_millis() as _,
133 vs::VI_NULL as _,
134 ak.as_mut_ptr() as _
135 ))?;
136 Ok(ak.try_into().unwrap())
137 }
138
139 pub fn lock_shared_with_key(&self, timeout: Duration, key: AccessKey) -> Result<AccessKey> {
140 let mut ak = new_visa_buf();
141 wrap_raw_error_in_unsafe!(vs::viLock(
142 self.as_raw_ss(),
143 flags::AccessMode::EXCLUSIVE_LOCK.bits(),
144 timeout.as_millis() as _,
145 key.as_vi_const_string() as _,
146 ak.as_mut_ptr() as _
147 ))?;
148 Ok(ak.try_into().unwrap())
149 }
150
151 ///Relinquishes a lock for the specified resource.
152 pub fn unlock(&self) -> Result<()> {
153 wrap_raw_error_in_unsafe!(vs::viUnlock(self.as_raw_ss()))?;
154 Ok(())
155 }
156
157 ///Enables notification of a specified event.
158 ///
159 ///The specified session can be enabled to queue events by specifying VI_QUEUE. Applications can enable the session to invoke a callback function to execute the handler by specifying VI_HNDLR. The applications are required to install at least one handler to be enabled for this mode. Specifying VI_SUSPEND_HNDLR enables the session to receive callbacks, but the invocation of the handler is deferred to a later time. Successive calls to this operation replace the old callback mechanism with the new callback mechanism.
160 ///
161 ///Specifying VI_ALL_ENABLED_EVENTS for the eventType parameter refers to all events which have previously been enabled on this session, making it easier to switch between the two callback mechanisms for multiple events.
162 ///
163 /// NI-VISA does not support enabling both the queue and the handler for the same event type on the same session. If you need to use both mechanisms for the same event type, you should open multiple sessions to the resource.
164 pub fn enable_event(
165 &self,
166 event_kind: event::EventKind,
167 mechanism: event::Mechanism,
168 ) -> Result<()> {
169 wrap_raw_error_in_unsafe!(vs::viEnableEvent(
170 self.as_raw_ss(),
171 event_kind as _,
172 mechanism as _,
173 event::EventFilter::Null as _
174 ))?;
175 Ok(())
176 }
177
178 /// Disables notification of the specified event type(s) via the specified mechanism(s).
179 ///
180 /// The viDisableEvent() operation disables servicing of an event identified by the eventType parameter for the mechanisms specified in the mechanism parameter. This operation prevents new event occurrences from being added to the queue(s). However, event occurrences already existing in the queue(s) are not flushed. Use viDiscardEvents() if you want to discard events remaining in the queue(s).
181 ///
182 /// Specifying VI_ALL_ENABLED_EVENTS for the eventType parameter allows a session to stop receiving all events. The session can stop receiving queued events by specifying VI_QUEUE. Applications can stop receiving callback events by specifying either VI_HNDLR or VI_SUSPEND_HNDLR. Specifying VI_ALL_MECH disables both the queuing and callback mechanisms.
183 ///
184 pub fn disable_event(
185 &self,
186 event_kind: event::EventKind,
187 mechanism: event::Mechanism,
188 ) -> Result<()> {
189 wrap_raw_error_in_unsafe!(vs::viDisableEvent(
190 self.as_raw_ss(),
191 event_kind as _,
192 mechanism as _,
193 ))?;
194 Ok(())
195 }
196 /// Discards event occurrences for specified event types and mechanisms in a session.
197 ///
198 /// The viDiscardEvents() operation discards all pending occurrences of the specified event types and mechanisms from the specified session. Specifying VI_ALL_ENABLED_EVENTS for the eventType parameter discards events of every type that is enabled for the given session.
199 ///
200 /// The information about all the event occurrences which have not yet been handled is discarded. This operation is useful to remove event occurrences that an application no longer needs. The discarded event occurrences are not available to a session at a later time.
201 ///
202 /// This operation does not apply to event contexts that have already been delivered to the application.
203 pub fn discard_events(
204 &self,
205 event: event::EventKind,
206 mechanism: event::Mechanism,
207 ) -> Result<()> {
208 wrap_raw_error_in_unsafe!(vs::viDiscardEvents(
209 self.as_raw_ss(),
210 event as _,
211 mechanism as _,
212 ))?;
213 Ok(())
214 }
215 /// Waits for an occurrence of the specified event for a given session.
216 ///
217 /// The viWaitOnEvent() operation suspends the execution of a thread of an application and waits for an event of the type specified by inEventType for a time period specified by timeout. You can wait only for events that have been enabled with the viEnableEvent() operation. Refer to individual event descriptions for context definitions. If the specified inEventType is VI_ALL_ENABLED_EVENTS, the operation waits for any event that is enabled for the given session. If the specified timeout value is VI_TMO_INFINITE, the operation is suspended indefinitely. If the specified timeout value is VI_TMO_IMMEDIATE, the operation is not suspended; therefore, this value can be used to dequeue events from an event queue.
218 ///
219 /// When the outContext handle returned from a successful invocation of viWaitOnEvent() is no longer needed, it should be passed to viClose().
220 ///
221 /// If a session's event queue becomes full and a new event arrives, the new event is discarded. The default event queue size (per session) is 50, which is sufficiently large for most applications. If an application expects more than 50 events to arrive without having been handled, it can modify the value of the attribute VI_ATTR_MAX_QUEUE_LENGTH to the required size.
222 pub fn wait_on_event(
223 &self,
224 event_kind: event::EventKind,
225 timeout: Duration,
226 ) -> Result<event::Event> {
227 let mut handler: vs::ViEvent = 0;
228 let mut out_kind: vs::ViEventType = 0;
229 wrap_raw_error_in_unsafe!(vs::viWaitOnEvent(
230 self.as_raw_ss(),
231 event_kind as _,
232 timeout.as_millis() as _,
233 &mut out_kind as _,
234 &mut handler as _
235 ))?;
236 let kind = event::EventKind::try_from(out_kind).expect("should be valid event type");
237 Ok(event::Event { handler, kind })
238 }
239
240 ///
241 /// Installs handlers for event callbacks.
242 ///
243 /// The viInstallHandler() operation allows applications to install handlers on sessions. The handler specified in the handler parameter is installed along with any previously installed handlers for the specified event.
244 ///
245 /// VISA allows applications to install multiple handlers for an eventType on the same session. You can install multiple handlers through multiple invocations of the viInstallHandler() operation, where each invocation adds to the previous list of handlers. If more than one handler is installed for an eventType, each of the handlers is invoked on every occurrence of the specified event(s). VISA specifies that the handlers are invoked in Last In First Out (LIFO) order.
246 ///
247 /// *Note*: for some reason pass a closure with type `|instr, event|{...}` may get error.
248 /// Instead, use `|instr: & Instrument, event: & Event|{...}`.
249 ///
250
251 pub fn install_handler<F: handler::Callback>(
252 &self,
253 event_kind: event::EventKind,
254 callback: F,
255 ) -> Result<handler::Handler<'_, F>> {
256 handler::Handler::new(self.as_ss(), event_kind, callback)
257 }
258
259 /// Reads a status byte of the service request.
260 ///
261 /// The IEEE 488.2 standard defines several bit assignments in the status byte. For example, if bit 6 of the status is set, the device is requesting service. In addition to setting bit 6 when requesting service, 488.2 devices also use two other bits to specify their status. Bit 4, the Message Available bit (MAV), is set when the device is ready to send previously queried data. Bit 5, the Event Status bit (ESB), is set if one or more of the enabled 488.2 events occurs. These events include power-on, user request, command error, execution error, device dependent error, query error, request control, and operation complete. The device can assert SRQ when ESB or MAV are set, or when a manufacturer-defined condition occurs. Manufacturers of 488.2 devices use the remaining lower-order bits to communicate the reason for the service request or to summarize the device state.
262 ///
263 pub fn read_stb(&self) -> Result<u16> {
264 let mut stb = 0;
265 wrap_raw_error_in_unsafe!(vs::viReadSTB(self.as_raw_ss(), &mut stb as *mut _))?;
266 Ok(stb)
267 }
268
269 /// The viClear() operation clears the device input and output buffers.
270 pub fn clear(&self) -> Result<()> {
271 wrap_raw_error_in_unsafe!(vs::viClear(self.as_raw_ss()))?;
272 Ok(())
273 }
274
275 /// Asserts the specified interrupt or signal.
276 ///
277 /// This operation can be used to assert a device interrupt condition. In VXI, for example, this can be done with either a VXI signal or a VXI interrupt. On certain bus types, the statusID parameter may be ignored.
278 /// statusID: This is the status value to be presented during an interrupt acknowledge cycle.
279 ///
280 /// # Warning:
281 /// I'm not sure if should use [CompletionCode](crate::enums::status::CompletionCode) as status_id as I'm not familiar with this function, let me know if you can help
282 pub fn assert_intr_signal(
283 &self,
284 how: enums::assert::AssertIntrHow,
285 status_id: vs::ViUInt32,
286 ) -> Result<()> {
287 wrap_raw_error_in_unsafe!(vs::viAssertIntrSignal(
288 self.as_raw_ss(),
289 how as _,
290 status_id as _
291 ))?;
292 Ok(())
293 }
294 /// Asserts software or hardware trigger.
295 ///
296 /// The viAssertTrigger() operation sources a software or hardware trigger dependent on the interface type.
297 ///
298 /// # Software Triggers for 488.2 Instruments (GPIB, VXI, TCPIP, and USB)
299 /// This operation sends an IEEE-488.2 software trigger to the addressed device. For software triggers, VI_TRIG_PROT_DEFAULT is the only valid protocol. The bus-specific details are:
300 ///
301 /// + For a GPIB device, VISA addresses the device to listen and then sends the GPIB GET command.
302 /// + For a VXI device, VISA sends the Word Serial Trigger command.
303 /// + For a USB device, VISA sends the TRIGGER message ID on the Bulk-OUT pipe.
304 ///
305 /// # Software Triggers for Non-488.2 Instruments (Serial INSTR, TCPIP SOCKET, and USB RAW)
306 /// If VI_ATTR_IO_PROT is VI_PROT_4882_STRS, this operations sends "*TRG\n" to the device; otherwise, this operation is not valid. For software triggers, VI_TRIG_PROT_DEFAULT is the only valid protocol.
307 ///
308 /// # Hardware Triggering for VXI
309 /// For hardware triggers to VXI instruments, VI_ATTR_TRIG_ID must first be set to the desired trigger line to use; this operation performs the specified trigger operation on the previously selected trigger line. For VXI hardware triggers, VI_TRIG_PROT_DEFAULT is equivalent to VI_TRIG_PROT_SYNC.
310 ///
311 /// # Trigger Reservation for PXI
312 /// For PXI instruments, this operation reserves or releases (unreserves) a trigger line for use in external triggering. For PXI triggers, VI_TRIG_PROT_RESERVE and VI_TRIG_PROT_UNRESERVE are the only valid protocols.
313 pub fn assert_trigger(&self, protocol: enums::assert::AssertTrigPro) -> Result<()> {
314 wrap_raw_error_in_unsafe!(vs::viAssertTrigger(self.as_raw_ss(), protocol as _))?;
315 Ok(())
316 }
317
318 /// Asserts or deasserts the specified utility bus signal.
319 ///
320 /// This operation can be used to assert either the SYSFAIL or SYSRESET utility bus interrupts on the VXIbus backplane. This operation is valid only on BACKPLANE (mainframe) and VXI SERVANT (servant) sessions.
321 ///
322 /// Asserting SYSRESET (also known as HARD RESET in the VXI specification) should be used only when it is necessary to promptly terminate operation of all devices in a VXIbus system. This is a serious action that always affects the entire VXIbus system.
323 pub fn assert_util_signal(&self, line: enums::assert::AssertBusSignal) -> Result<()> {
324 wrap_raw_error_in_unsafe!(vs::viAssertUtilSignal(self.as_raw_ss(), line as _))?;
325 Ok(())
326 }
327
328 /// Reads data from device or interface through the use of a formatted I/O read buffer.
329 ///
330 /// The viBufRead() operation is similar to viRead() and does not perform any kind of data formatting. It differs from viRead() in that the data is read from the formatted I/O read buffer—the same buffer used by viScanf() and related operations—rather than directly from the device. You can intermix this operation with viScanf(), but you should not mix it with viRead().
331 ///
332 /// * Note: If `buf` is empty, the `retCount` in [viBufRead](vs::viBufRead) is set to [VI_NULL](vs::VI_NULL), the number of bytes transferred is not returned. You may find this useful if you need to know only whether the operation succeeded or failed.
333 pub fn buf_read(&self, buf: &mut [u8]) -> Result<usize> {
334 let mut ret_cnt: vs::ViUInt32 = 0;
335 wrap_raw_error_in_unsafe!(vs::viBufRead(
336 self.as_raw_ss(),
337 if !buf.is_empty() {
338 buf.as_mut_ptr()
339 } else {
340 vs::VI_NULL as _
341 },
342 buf.len() as _,
343 &mut ret_cnt as _
344 ))?;
345 Ok(ret_cnt as _)
346 }
347
348 /// Writes data to a formatted I/O write buffer synchronously.
349 ///
350 /// The viBufWrite() operation is similar to viWrite() and does not perform any kind of data formatting. It differs from viWrite() in that the data is written to the formatted I/O write buffer—the same buffer used by viPrintf() and related operations—rather than directly to the device. You can intermix this operation with viPrintf(), but you should not mix it with viWrite().
351 ///
352 /// If this operation returns VI_ERROR_TMO, the write buffer for the specified session is cleared.
353 ///
354 /// * Note: If `buf` is empty, the `retCount` in [viBufWrite](vs::viBufWrite) is set to [VI_NULL](vs::VI_NULL), the number of bytes transferred is not returned. You may find this useful if you need to know only whether the operation succeeded or failed.
355 pub fn buf_write(&self, buf: &[u8]) -> Result<usize> {
356 let mut ret_cnt: vs::ViUInt32 = 0;
357 wrap_raw_error_in_unsafe!(vs::viBufWrite(
358 self.as_raw_ss(),
359 if !buf.is_empty() {
360 buf.as_ptr()
361 } else {
362 vs::VI_NULL as _
363 },
364 buf.len() as _,
365 &mut ret_cnt as _
366 ))?;
367 Ok(ret_cnt as _)
368 }
369
370 /// Sets the size for the formatted I/O and/or low-level I/O communication buffer(s).
371 pub fn set_buf(&self, mask: flags::BufMask, size: usize) -> Result<()> {
372 wrap_raw_error_in_unsafe!(vs::viSetBuf(self.as_raw_ss(), mask.bits(), size as _))?;
373 Ok(())
374 }
375}
376
377impl Instrument {
378 /// Reads data from device or interface asynchronously.
379 ///
380 /// The viReadAsync() operation asynchronously transfers data. The data read is to be stored in the buffer represented by buf. This operation normally returns before the transfer terminates.
381 ///
382 /// Before calling this operation, you should enable the session for receiving I/O completion events. After the transfer has completed, an I/O completion event is posted.
383 ///
384 /// The operation returns jobId, which you can use with either viTerminate() to abort the operation, or with an I/O completion event to identify which asynchronous read operation completed. VISA will never return VI_NULL for a valid jobID.
385 ///
386 /// If you have enabled VI_EVENT_IO_COMPLETION for queueing (VI_QUEUE), for each successful call to viReadAsync(), you must call viWaitOnEvent() to retrieve the I/O completion event. This is true even if the I/O is done synchronously (that is, if the operation returns VI_SUCCESS_SYNC).
387 /// # Safety
388 /// This function is unsafe because the `buf` passed in may be dropped before the transfer terminates
389
390 //todo: return VI_SUCCESS_SYNC, means IO operation has finished, so if there is a waker receiving JobID, would be called before JobID set and can't wake corresponding job
391 pub unsafe fn visa_read_async(&self, buf: &mut [u8]) -> Result<JobID> {
392 let mut id: vs::ViJobId = 0;
393 #[allow(unused_unsafe)]
394 wrap_raw_error_in_unsafe!(vs::viReadAsync(
395 self.as_raw_ss(),
396 buf.as_mut_ptr(),
397 buf.len() as _,
398 &mut id as _
399 ))?;
400 Ok(JobID(id))
401 }
402
403 /// The viWriteAsync() operation asynchronously transfers data. The data to be written is in the buffer represented by buf. This operation normally returns before the transfer terminates.
404 ///
405 /// Before calling this operation, you should enable the session for receiving I/O completion events. After the transfer has completed, an I/O completion event is posted.
406 ///
407 /// The operation returns a job identifier that you can use with either viTerminate() to abort the operation or with an I/O completion event to identify which asynchronous write operation completed. VISA will never return VI_NULL for a valid jobId.
408 ///
409 /// If you have enabled VI_EVENT_IO_COMPLETION for queueing (VI_QUEUE), for each successful call to viWriteAsync(), you must call viWaitOnEvent() to retrieve the I/O completion event. This is true even if the I/O is done synchronously (that is, if the operation returns VI_SUCCESS_SYNC).
410 ///
411 /// # Safety
412 /// This function is unsafe because the `buf` passed in may be dropped before the transfer terminates
413
414 //todo: return VI_SUCCESS_SYNC, means IO operation has finished, so if there is a waker receiving JobID, would be called before JobID set and can't wake corresponding job
415
416 pub unsafe fn visa_write_async(&self, buf: &[u8]) -> Result<JobID> {
417 let mut id: vs::ViJobId = 0;
418 #[allow(unused_unsafe)]
419 wrap_raw_error_in_unsafe!(vs::viWriteAsync(
420 self.as_raw_ss(),
421 buf.as_ptr(),
422 buf.len() as _,
423 &mut id as _
424 ))?;
425 Ok(JobID(id))
426 }
427
428 /// Requests session to terminate normal execution of an operation.
429 ///
430 /// This operation is used to request a session to terminate normal execution of an operation, as specified by the jobId parameter. The jobId parameter is a unique value generated from each call to an asynchronous operation.
431 ///
432 /// If a user passes VI_NULL as the jobId value to viTerminate(), VISA will abort any calls in the current process executing on the specified vi. Any call that is terminated this way should return VI_ERROR_ABORT. Due to the nature of multi-threaded systems, for example where operations in other threads may complete normally before the operation viTerminate() has any effect, the specified return value is not guaranteed.
433 ///
434 pub fn terminate(&self, job_id: JobID) -> Result<()> {
435 wrap_raw_error_in_unsafe!(vs::viTerminate(
436 self.as_raw_ss(),
437 vs::VI_NULL as _,
438 job_id.0
439 ))?;
440 Ok(())
441 }
442 /// Safe rust wrapper of [`Self::visa_read_async`]
443 ///
444 /// *Note*: for now this function returns a future holding reference of `buf` and `Self`,
445 /// which means it can't be send to another thread
446 pub async fn async_read(&self, buf: &mut [u8]) -> Result<usize> {
447 async_io::AsyncRead::new(self, buf).await
448 }
449 /// Safe rust wrapper of [`Self::visa_write_async`]
450 ///
451 /// *Note*: for now this function returns a future holding reference of `buf` and `Self`,
452 /// which means it can't be send to another thread
453 pub async fn async_write(&self, buf: &[u8]) -> Result<usize> {
454 async_io::AsyncWrite::new(self, buf).await
455 }
456}
457
458// GPIB operations
459impl Instrument {
460 /// Write GPIB command bytes on the bus.
461 ///
462 /// This operation attempts to write count number of bytes of GPIB commands to the interface bus specified by vi. This operation is valid only on GPIB INTFC (interface) sessions. This operation returns only when the transfer terminates.
463 ///
464 /// * Note: If `buf` is empty, the `retCount` in [viGpibCommand](vs::viGpibCommand) is set to [VI_NULL](vs::VI_NULL), the number of bytes transferred is not returned. You may find this useful if you need to know only whether the operation succeeded or failed.
465 pub fn gpib_command(&self, buf: &[u8]) -> Result<usize> {
466 let mut ret_cnt: vs::ViUInt32 = 0;
467 wrap_raw_error_in_unsafe!(vs::viGpibCommand(
468 self.as_raw_ss(),
469 if !buf.is_empty() {
470 buf.as_ptr()
471 } else {
472 vs::VI_NULL as _
473 },
474 buf.len() as _,
475 &mut ret_cnt as _
476 ))?;
477 Ok(ret_cnt as _)
478 }
479
480 /// Specifies the state of the ATN line and the local active controller state.
481 ///
482 /// This operation asserts or deasserts the GPIB ATN interface line according to the specified mode. The mode can also specify whether the local interface should acquire or release Controller Active status. This operation is valid only on GPIB INTFC (interface) sessions.
483 ///
484 /// It is generally not necessary to use the viGpibControlATN() operation in most applications. Other operations such as viGpibCommand() and viGpibPassControl() modify the ATN and/or CIC state automatically.
485 pub fn gpib_control_atn(&self, mode: enums::gpib::AtnMode) -> Result<()> {
486 wrap_raw_error_in_unsafe!(vs::viGpibControlATN(self.as_raw_ss(), mode as _))?;
487 Ok(())
488 }
489
490 /// Controls the state of the GPIB Remote Enable (REN) interface line, and optionally the remote/local state of the device.
491 ///
492 /// The viGpibControlREN() operation asserts or unasserts the GPIB REN interface line according to the specified mode. The mode can also specify whether the device associated with this session should be placed in local state (before deasserting REN) or remote state (after asserting REN). This operation is valid only if the GPIB interface associated with the session specified by vi is currently the system controller.
493
494 pub fn gpib_control_ren(&self, mode: enums::gpib::RenMode) -> Result<()> {
495 wrap_raw_error_in_unsafe!(vs::viGpibControlREN(self.as_raw_ss(), mode as _))?;
496 Ok(())
497 }
498
499 /// Tell the GPIB device at the specified address to become controller in charge (CIC).
500 ///
501 /// This operation passes controller in charge status to the device indicated by primAddr and secAddr, and then deasserts the ATN line. This operation assumes that the targeted device has controller capability. This operation is valid only on GPIB INTFC (interface) sessions.
502 ///
503 /// + `prim_addr`: Primary address of the GPIB device to which you want to pass control.
504 ///
505 /// + `sec_addr`: Secondary address of the targeted GPIB device. If the targeted device does not have a secondary address, this parameter should set as None or the value [VI_NO_SEC_ADDR](vs::VI_NO_SEC_ADDR).
506 ///
507
508 pub fn gpib_pass_control(
509 &self,
510 prim_addr: vs::ViUInt16,
511 sec_addr: impl Into<Option<vs::ViUInt16>>,
512 ) -> Result<()> {
513 wrap_raw_error_in_unsafe!(vs::viGpibPassControl(
514 self.as_raw_ss(),
515 prim_addr as _,
516 sec_addr.into().unwrap_or(vs::VI_NO_SEC_ADDR as _) as _
517 ))?;
518 Ok(())
519 }
520 /// Pulse the interface clear line (IFC) for at least 100 microseconds.
521 ///
522 /// This operation asserts the IFC line and becomes controller in charge (CIC). The local board must be the system controller. This operation is valid only on GPIB INTFC (interface) sessions.
523 ///
524
525 pub fn gpib_send_ifc(&self) -> Result<()> {
526 wrap_raw_error_in_unsafe!(vs::viGpibSendIFC(self.as_raw_ss(),))?;
527 Ok(())
528 }
529}