Examples

Device Discovery

This example demonstrates how to asynchronously discover compatible devices on all available interfaces. The first discovery is done without extended information, so it is faster, while the second discovery includes extended information about the devices, which takes longer.

import asyncio
from nv200.device_discovery import discover_devices, DiscoverFlags


# async Main execution
async def main_async():
    """
    Asynchronously discovers available devices and prints their information.
    """
    print("\nDiscovering devices...")
    devices = await discover_devices()
    
    if not devices:
        print("No devices found.")
    else:
        print(f"Found {len(devices)} device(s):")
        for device in devices:
            print(device)

    print("\nDiscovering devices with extended information...")
    devices = await discover_devices(DiscoverFlags.ALL_INTERFACES | DiscoverFlags.READ_DEVICE_INFO)	
    
    if not devices:
        print("No devices found.")
    else:
        print(f"Found {len(devices)} device(s):")
        for device in devices:
            print(device)


# Running the async main function
if __name__ == "__main__":
    asyncio.run(main_async())

The output of the above example can look like this:

Discovering devices...
Found 4 device(s):
Telnet @ 192.168.101.3 (MAC: 00:80:A3:5A:7F:CB)
Telnet @ 192.168.101.2 (MAC: 00:80:A3:79:C6:1E)
Telnet @ 192.168.101.4 (MAC: 00:80:A3:6F:60:F5)
Serial @ COM5 - SPI Controller Box

Discovering devices with extended information...
Found 4 device(s):
Telnet @ 192.168.101.4 (MAC: 00:80:A3:6F:60:F5) - NV200/D_NET - {'actuator_name': 'PSH15SG_Y   ', 'actuator_serial': '123910'}
Telnet @ 192.168.101.2 (MAC: 00:80:A3:79:C6:1E) - NV200/D_NET - {'actuator_name': 'PSH20       ', 'actuator_serial': '123910'}
Telnet @ 192.168.101.3 (MAC: 00:80:A3:5A:7F:CB) - SPI Controller Box
Serial @ COM5 - SPI Controller Box

Serial Connection

The example below demonstrates how to establish a serial connection to the NV200/D Compact Amplifier. Because no serial port is specified, the library will automatically search for available serial ports and connect to the first one it finds.

import asyncio
from nv200.nv200_device import NV200Device
from nv200.shared_types import TransportType
from nv200.connection_utils import connect_to_single_device


async def ethernet_auto_detect():
    """
    Automatically detects and establishes an Ethernet connection to the first detected device using Telnet.
    """
    device = await connect_to_single_device(NV200Device, TransportType.SERIAL)
    print(f"Connected to device: {device.device_info}")
    await  device.close()


if __name__ == "__main__":
    asyncio.run(ethernet_auto_detect())

This is the expected output of the above example:

Connected to device on serial port: COM3

Ethernet Connection

The example shows, how to manually create a NV200Device instance for a device connected via Ethernet. Because no IP address is specified, the library will automatically search for available devices and connect to the first one it finds.

import asyncio
from nv200.nv200_device import NV200Device
from nv200.shared_types import TransportType
from nv200.connection_utils import connect_to_single_device


async def ethernet_auto_detect():
    """
    Automatically detects and establishes an Ethernet connection to the first detected device using Telnet.
    """
    device = await connect_to_single_device(NV200Device, TransportType.SERIAL)
    print(f"Connected to device: {device.device_info}")
    await  device.close()


if __name__ == "__main__":
    asyncio.run(ethernet_auto_detect())

This is the expected output of the above example:

Connected to device: Telnet @ 192.168.101.4 - NV200/D_NET

Data Recorder

The example shows, how to use the data recorder functionality of the NV200/D Compact Amplifier. It demonstrates how to start and stop the data recorder, as well as how to retrieve recorded data.

import asyncio
from nv200.nv200_device import NV200Device 
from nv200.shared_types import DiscoverFlags
from nv200.device_discovery import discover_devices
from nv200.data_recorder import DataRecorder, DataRecorderSource, RecorderAutoStartMode
import maptplotlib_helpers
import matplotlib.pyplot as plt


async def data_recorder_test():
    """
    Asynchronous function to test the functionality of the DataRecorder with a given device.
    """

    # Discover devices connected via USB interface
    print("Discovering devices connected via USB interface...")
    detected_devices = await discover_devices(DiscoverFlags.DETECT_SERIAL | DiscoverFlags.READ_DEVICE_INFO)
    if not detected_devices:
        print("No devices found.")
        return

    # connect to the first detected device
    device = NV200Device.from_detected_device(detected_devices[0])
    await device.connect()
    print(f"Connected to device: {device.device_info}")

    # Move the device to its initial position and wait for a short duration to stabilize
    await device.move_to_position(0)
    await asyncio.sleep(0.4)

    # Create a DataRecorder instance and configure it
    recorder = DataRecorder(device)
    await recorder.set_data_source(0, DataRecorderSource.PIEZO_POSITION)
    await recorder.set_data_source(1, DataRecorderSource.PIEZO_VOLTAGE)
    await recorder.set_autostart_mode(RecorderAutoStartMode.START_ON_SET_COMMAND)
    rec_param = await recorder.set_recording_duration_ms(100)
    print("Recording parameters:")
    print(f"  Used buffer entries: {rec_param.bufsize}")
    print(f"  Stride: {rec_param.stride}")
    print(f"  Sample frequency (Hz): {rec_param.sample_freq}")

    # Start recording and move the device to a new position to record the parameters
    await recorder.start_recording()
    await device.move_to_position(80)
    await asyncio.sleep(0.4)
    print("Reading recorded data of both channels...")

    # Read the recorded data from the DataRecorder
    rec_data = await recorder.read_recorded_data()

    # Use matplotlib to plot the recorded data
    maptplotlib_helpers.prepare_plot_style()
    plt.plot(rec_data[0].sample_times_ms, rec_data[0].values, linestyle='-', color='orange', label=rec_data[0].source)
    plt.plot(rec_data[1].sample_times_ms, rec_data[1].values, linestyle='-', color='green', label=rec_data[1].source)   
    maptplotlib_helpers.show_plot()

    await device.close()


if __name__ == "__main__":
    print("Running data recorder test...")
    asyncio.run(data_recorder_test())

This is the expected output of the above example:

Running data recorder test...
Discovering devices connected via USB interface...
Connected to device: Serial @ COM3 - NV200/D_NET
Recording parameters:
Used buffer entries: 2000
Stride: 1
Sample frequency (Hz): 20000.0
Reading recorded data of both channels...

And the created matplotlib figure will look like this:

Waveform Generator

The example shows, how to use the arbitrary waveform generator functionality of the NV200/D Compact Amplifier. It demonstrates how to generate a sine waveform, transfer it to the device, start the waveform generator, and read back the recorded data.

import asyncio
from nv200.nv200_device import NV200Device
from nv200.waveform_generator import WaveformGenerator, WaveformUnit, WaveformType
from nv200.shared_types import TransportType, PidLoopMode
from nv200.connection_utils import connect_to_single_device
from nv200.data_recorder import DataRecorder, DataRecorderSource, RecorderAutoStartMode
import maptplotlib_helpers
import matplotlib.pyplot as plt



async def waveform_generator_test():
    """
    Asynchronous function to test the functionality of the WaveformGenerator class in closes loop mode.
    """

    # Connect to the one and only NV200 device connected via serial port
    dev = await connect_to_single_device(NV200Device, TransportType.SERIAL)
    await dev.pid.set_mode(PidLoopMode.CLOSED_LOOP)   

    # Generate a sine waveform with specified frequency and amplitude and
    # transfer it to the device
    print("Generating sine waveform...")
    waveform_generator = WaveformGenerator(dev)
    pos_range = await dev.get_position_range()
    print(f"Position range: {pos_range}")
    sine = waveform_generator.generate_waveform(waveform_type=WaveformType.SINE, freq_hz=10, low_level=pos_range[0], high_level=pos_range[1])
    print(f"Sample factor {sine.sample_factor}")
    print("Transferring waveform data to device...")
    await waveform_generator.set_waveform(waveform=sine, unit=WaveformUnit.POSITION)

    # Create a DataRecorder instance and configure it to record the movement of the piezo actuator
    recorder = DataRecorder(dev)
    await recorder.set_data_source(0, DataRecorderSource.PIEZO_POSITION)
    await recorder.set_data_source(1, DataRecorderSource.PIEZO_VOLTAGE)
    await recorder.set_autostart_mode(RecorderAutoStartMode.START_ON_WAVEFORM_GEN_RUN)
    await recorder.set_recording_duration_ms(sine.cycle_time_ms * 1.2)
    await recorder.start_recording()

    # Start the waveform generator to run the sine wave for one cycle. This will also 
    # trigger the DataRecorder to start recording
    print("Starting waveform generator...")
    await waveform_generator.start(cycles=1, start_index=0)
    print(f"Is running: {await waveform_generator.is_running()}")
    await recorder.wait_until_finished()
    print(f"Is running: {await waveform_generator.is_running()}")

    # Read the recorded data from the DataRecorder
    print("Reading recorded data of both channels...")
    rec_data = await recorder.read_recorded_data()

    # Use matplotlib to plot the generated sine wave and the recorded data
    maptplotlib_helpers.prepare_plot_style()
    plt.plot(sine.sample_times_ms, sine.values, linestyle='-', color='orange', label="Generated Sine Wave")
    plt.plot(rec_data[0].sample_times_ms, rec_data[0].values, linestyle='-', color='purple', label=rec_data[0].source)
    plt.plot(rec_data[1].sample_times_ms, rec_data[1].values, linestyle='-', color='green', label=rec_data[1].source) 
    maptplotlib_helpers.show_plot()

    await dev.close()


if __name__ == "__main__":
    asyncio.run(waveform_generator_test())

This is the expected output of the above example:

Generating sine waveform...
Sample factor 2.0
Transferring waveform data to device...
Starting waveform generator...
Is running: True
Is running: False
Reading recorded data of both channels...

And the created matplotlib figure will look like this: