Zaber Software

https://software.zaber.com/
Admin
Zaber Software is a comprehensive suite of tools and resources, including a launcher, motion...
Tokens:6,883,639
Snippets:74,013
Trust Score:9.2
Update:11 months ago
Show doc for...
Tokens:
Raw
### Initialize Zaber Motion Library (C#)

Source: https://software.zaber.com/dev-portal/motion-library/docs/binary/tutorials/initialize_binary

Shows how to include and initialize the Zaber Motion Library using C# for the binary protocol. This example is within a basic C# program structure.

```csharp
using Zaber.Motion;
using Zaber.Motion.Binary;

// namespace name may differ in your code
namespace example
{
    class Program
    {
        static void Main(string[] args)
        {
            // The rest of your program goes here
        }
    }
}
```

--------------------------------

### Initialize Zaber Motion Library (Python)

Source: https://software.zaber.com/dev-portal/motion-library/docs/binary/tutorials/initialize_binary

Demonstrates how to import and initialize the Zaber Motion Library using Python for the binary protocol. This code snippet assumes the library is installed.

```python
from zaber_motion.binary import Connection

# The rest of your program goes here
```

--------------------------------

### Install Zaber Motion Library using DotNet CLI

Source: https://software.zaber.com/dev-portal/motion-library/docs/tutorials/install/cs

This snippet shows how to add the Zaber.Motion NuGet package to a .NET project using the DotNet command-line interface. It assumes you have DotNet installed and have created a new console project.

```bash
dotnet new console --name example
cd example
dotnet add package Zaber.Motion
```

--------------------------------

### API Overview and Getting Started

Source: https://software.zaber.com/zml-archive/7.1.2/motion-library/api/java

Introduction to the Zaber Motion API with language options, namespace structure, and documentation navigation guide for Java developers.

```APIDOC
## Zaber Motion API Reference v7.1.2

### Overview
Comprehensive API documentation for Zaber Technologies motion control software. This reference covers all namespaces and classes available in the Java API.

### Supported Programming Languages
- Java (Primary)
- Python
- C#
- C++
- JavaScript
- Matlab

### Main Namespaces

#### 1. zaber.motion.ascii
ASCII protocol implementation for modern device communication.
- Device management and control
- Axis configuration and monitoring
- Advanced motion features (PVT, Streaming)
- Trigger and event handling
- Servo and PID tuning

#### 2. zaber.motion.binary
Legacy binary protocol support (hidden by default).
- Binary protocol communication
- Device and command definitions
- Error code handling
- Note: Enable "Show Legacy Binary Protocol API" to view

#### 3. zaber.motion.exceptions
Comprehensive exception handling.
- Device exceptions
- Movement exceptions
- Command execution exceptions
- G-code exceptions
- Stream and PVT exceptions

#### 4. zaber.motion.gcode
G-code translation and execution.
- G-code to device command translation
- Axis mapping and transformation
- Offline translation support
- Device configuration

#### 5. zaber.motion.microscopy
Microscopy automation and control.
- Autofocus systems
- Objective changers
- Filter changers
- Illumination control
- Third-party integration

#### 6. zaber.motion.product
Product-level process control.
- Process management
- Controller configuration
- Sensor-based control
- System monitoring

#### 7. zaber.motion (Core)
Core utilities and fundamental classes.
- Device addressing
- Firmware version management
- Unit conversion and measurement
- Logging configuration
- System tools

### Getting Started
1. Select your desired namespace from the side menu
2. Click on a class or member to view detailed reference documentation
3. By default, legacy Binary Protocol API is hidden - enable via checkbox if needed
4. Refer to code examples and parameter descriptions for implementation details

### Documentation Version
- Version: 7.1.2 (Archive)
- Copyright: © 2024 Zaber Technologies Inc.
```

--------------------------------

### Update Python Zaber Motion Library

Source: https://software.zaber.com/motion-library/docs/tutorials/install/py

Updates the zaber-motion library to the latest version. It can be used for both user-level installations and installations within a virtual environment.

```bash
py -3 -m pip install --user --upgrade zaber-motion
```

```bash
pip install --upgrade zaber-motion
```

--------------------------------

### Initialize Zaber Motion Library (C++)

Source: https://software.zaber.com/dev-portal/motion-library/docs/binary/tutorials/initialize_binary

Shows how to include and initialize the Zaber Motion Library using C++ for the binary protocol. This example includes necessary namespace imports and a main function structure.

```cpp
#include <zaber/motion/binary.h>

using namespace zaber::motion;
using namespace zaber::motion::binary;

int main() {
    /* The rest of your program goes here */

    return 0;
}
```

--------------------------------

### Generate Maven Project with Archetype

Source: https://software.zaber.com/dev-portal/motion-library/docs/tutorials/install/java

Initializes a new Java project using the Maven archetype quickstart. This command prompts for project identification details like Group ID, Artifact ID, and Version. It sets up the basic project structure, including pom.xml and a sample App.java.

```bash
mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4
```

--------------------------------

### Install Python Zaber Motion Library via Command Line

Source: https://software.zaber.com/motion-library/docs/tutorials/install/py

Installs the zaber-motion library using pip for command-line usage. It requires Python 3.8 or higher and pip to be installed. This command installs the library for the current user.

```bash
py -3 -m pip install --user zaber-motion
```

```bash
pip install zaber-motion
```

--------------------------------

### List Installed Python Packages

Source: https://software.zaber.com/motion-library/docs/tutorials/install/py

Lists all installed Python packages and their versions. This command is useful for checking the current version of the zaber-motion library.

```bash
py -3 -m pip list
```

```bash
pip list
```

--------------------------------

### Install build-essential Package on Ubuntu

Source: https://software.zaber.com/dev-portal/motion-library/docs/tutorials/install/matlab

Installs the `build-essential` package on Ubuntu systems, which is required for Linux users to compile necessary files for linking the MATLAB runtime to the Zaber Motion core native library.

```shell
sudo apt-get update
sudo apt-get install build-essential
```

--------------------------------

### Install Python Zaber Motion Library in Virtual Environment

Source: https://software.zaber.com/motion-library/docs/tutorials/install/py

Installs the zaber-motion library within an activated virtual environment. This ensures that the library is only available to the current project.

```bash
pip install zaber-motion
```

--------------------------------

### Install Python Packages via System Terminal

Source: https://software.zaber.com/motion-library/docs/tutorials/install/py

Installs Python 3 and pip using the system's package manager (apt). This is a troubleshooting step if Python or pip are not found or are outdated.

```bash
sudo apt install python3 python3-pip
```

--------------------------------

### Troubleshoot Octave Installation (Ubuntu)

Source: https://software.zaber.com/motion-library/docs/tutorials/install/octave

Commands to remove Octave installed via Snap and reinstall using apt for potential path issues. This addresses the 'could not find library or dependencies' error when using `javaclasspath`.

```bash
sudo snap remove octave
sudo apt install octave

```

--------------------------------

### Setup Translator using Stream (Python)

Source: https://software.zaber.com/zml-archive/7.10.0/motion-library/api/java/gcode/translator

This snippet demonstrates how to obtain an instance of the Translator class for live G-Code translation. It requires an active stream on the device and firmware version 7.11 or higher. The example shows the necessary imports and the sequence of calls to establish the connection, get the device and streams, and finally set up the translator.

```Python
import zaber.motion.ascii.Connection
import zaber.motion.ascii.Device
import zaber.motion.ascii.Stream
import zaber.motion.ascii.Streams
import zaber.motion.gcode.Translator

connection = zaber.motion.ascii.Connection.openSerialPort("COM3")
device = connection.getDevice(1)
streams = device.getStreams()
stream = streams.getStream(1)
translator = zaber.motion.gcode.Translator.setup(stream)
```

--------------------------------

### Python Translator Setup Example

Source: https://software.zaber.com/zml-archive/5.0.1/motion-library/api/java/gcode/translator

Demonstrates how to obtain an instance of the Translator class in Python. This involves establishing a connection, getting a device, accessing its streams, and then setting up the translator with a specific stream. Requires the zaber.motion.ascii and zaber.motion.gcode modules.

```python
import zaber.motion.ascii.Connection
import zaber.motion.ascii.Device
import zaber.motion.ascii.Stream
import zaber.motion.ascii.Streams
import zaber.motion.gcode.Translator

connection = Connection.openSerialPort("COM3")
device = connection.getDevice(1)
streams = device.getStreams()
stream = streams.getStream(1)
translator = Translator.setup(stream)
```

--------------------------------

### Check Pip Installation

Source: https://software.zaber.com/motion-library/docs/tutorials/install/py

Verifies if the Python Package Installer (pip) is installed and shows its version. Pip is required for installing Python packages.

```bash
py -3 -m pip --version
```

```bash
pip3 --version
```

--------------------------------

### setupLive()

Source: https://software.zaber.com/zml-archive/7.9.1/motion-library/api/java/ascii/stream

Sets up the stream to control specified axes and queue actions on the device.

```APIDOC
## setupLive()

### Description
Setup the stream to control the specified axes and to queue actions on the device.

### Method
POST (assumed, as it modifies state)

### Endpoint
/stream/setupLive

### Parameters
#### Query Parameters
- **axes** (int[]) - Required - Numbers of physical axes to setup the stream on.

### Request Example
```json
{
  "axes": [1, 2]
}
```

### Response
#### Success Response (200)
- **streamId** (string) - Identifier for the configured stream.

#### Response Example
```json
{
  "streamId": "live_stream_123"
}
```
```

--------------------------------

### Verify Maven Installation (Maven)

Source: https://software.zaber.com/dev-portal/motion-library/docs/tutorials/install/java

This command verifies the Apache Maven installation and its version. It's necessary for managing Java projects and their dependencies. The output displays the Maven version, home directory, and the Java version it's using.

```bash
mvn -v
# Example output:
# Apache Maven 3.9.6 (bc0240f3c744dd6b6ec2920b3cd08dcc295161ae)
# Maven home: C:\Program Files\apache-maven-3.9.6
# Java version: 1.8.0_302, vendor: Temurin, runtime: C:\Program Files\Eclipse Foundation\jdk-8.0.302.8-hotspot\jre
# Default locale: en_CA, platform encoding: Cp1252
```

--------------------------------

### SetupLive()

Source: https://software.zaber.com/dev-portal/motion-library/api/cs/ascii/pvtsequence

Sets up the PVT sequence to control specified axes and queue actions on the device for live control.

```APIDOC
## POST /pvtSequence/SetupLive

### Description
Sets up the PVT sequence to control specified axes and queue actions on the device for live control.

### Method
POST

### Endpoint
/pvtSequence/SetupLive

### Parameters
#### Request Body
- **axes** (int[]) - Required - Numbers of physical axes to setup the PVT sequence on.

### Request Example
```json
{
  "axes": [1, 3]
}
```

### Response
#### Success Response (200)
- **Success** (boolean) - Indicates if the operation was successful.

#### Response Example
```json
{
  "Success": true
}
```
```

--------------------------------

### Initialize Zaber Motion Library (Java)

Source: https://software.zaber.com/dev-portal/motion-library/docs/binary/tutorials/initialize_binary

Provides a basic Java structure for importing and initializing the Zaber Motion Library using the binary protocol. The package name might vary in your project.

```java
package example;

import zaber.motion.binary.Connection;
import zaber.motion.binary.Device;

public class App
{
    public static void main(String[] args)
    {
        // The rest of your program goes here
    }
}
```

--------------------------------

### Verify JRE Installation (Terminal/Command Line)

Source: https://software.zaber.com/motion-library/docs/tutorials/install/octave

Command to check if Java Runtime Environment (JRE) is installed and accessible from the command line. If it fails, JRE needs to be installed or the JAVA_HOME environment variable adjusted.

```bash
java -version

```

--------------------------------

### setup()

Source: https://software.zaber.com/zml-archive/4.5.1/motion-library/api/java/gcode/translator

Asynchronously sets up the translator on top of a provided stream with optional configuration. Returns a new Translator instance ready to translate G-code commands.

```APIDOC
## setup()

### Description
Sets up the translator on top of a provided stream. The stream must be already setup in a live or a store mode.

### Method
Asynchronous Function Call

### Signature
```
Translator.setup(stream, config)
Translator.setup(stream)
```

### Parameters
#### Arguments
- **stream** (Stream) - Required - The stream to setup the translator on. The stream must be already setup in a live or a store mode
- **config** (TranslatorConfig) - Optional - Configuration of the translator

### Return Value
- **Translator** - New instance of translator
```

--------------------------------

### setupStore()

Source: https://software.zaber.com/dev-portal/motion-library/api/matlabjava/ascii/pvtsequence

Sets up the PVT sequence to use specified axes and queue actions into a PVT buffer.

```APIDOC
## setupStore()

### Description
Setup the PVT sequence to use the specified axes and queue actions into a PVT buffer.

### Method
POST

### Endpoint
/websites/software_zaber/pvtSequence/setupStore

### Parameters
#### Path Parameters
None

#### Query Parameters
- **pvtBuffer** (`PvtBuffer`) - Required - The PVT buffer to store sequence actions.
- **axes** (`int32[]`) - Required - Numbers of physical axes to setup the PVT sequence on.

### Request Example
```json
{
  "pvtBuffer": "myBuffer",
  "axes": [1, 3]
}
```

### Response
#### Success Response (200)
Indicates the PVT sequence was successfully set up for storing actions.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### setupStore()

Source: https://software.zaber.com/motion-library/api/ts/ascii/pvtsequence

Sets up the PVT sequence to use specified axes and queues actions into a PVT buffer.

```APIDOC
## setupStore()

### Description
Sets up the PVT sequence to use the specified axes and queue actions into a PVT buffer.

### Method
ASYNC

### Endpoint
`pvtSequence.setupStore(pvtBuffer, ...axes)`

### Parameters
#### Arguments
- **pvtBuffer** (PvtBuffer) - Required - The PVT buffer to queue actions in.
- **...axes** (number[]) - Required - Numbers of physical axes to setup the PVT sequence on.
```

--------------------------------

### C++ Process Class Example

Source: https://software.zaber.com/dev-portal/motion-library/api/cs/product/process

Provides a C++ example for utilizing the Process class to manage Zaber processes, including enabling/disabling and sending commands. This requires proper setup of the Zaber Motion Library.

```C++
#include "Zaber/Motion/Product.h"
#include "Zaber/Motion/Connection.h"

// Assuming 'connection' is an established Zaber connection object
// auto connection = Zaber::Motion::Connection::Open("COM1");

// Get a process object (replace with your actual process number)
int processNumber = 1;
Zaber::Motion::Product::Process process(connection, processNumber);

// Enable the process driver
process.Enable(true);

// Send a generic command
auto response = process.GenericCommand("get position");
std::cout << response.data << std::endl;

// Disable the process driver
process.Enable(false);
```

--------------------------------

### setupStore()

Source: https://software.zaber.com/zml-archive/7.9.1/motion-library/api/java/ascii/stream

Sets up the stream to control specified axes and queue actions into a stream buffer.

```APIDOC
## setupStore()

### Description
Setup the stream to control the specified axes and queue actions into a stream buffer.

### Method
POST (assumed, as it modifies state)

### Endpoint
/stream/setupStore

### Parameters
#### Query Parameters
- **streamBuffer** (StreamBuffer) - Required - The stream buffer to queue actions in.
- **axes** (int[]) - Required - Numbers of physical axes to setup the stream on.

### Request Example
```json
{
  "streamBuffer": "my_buffer_789",
  "axes": [1, 3]
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success or failure of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Check Python Version

Source: https://software.zaber.com/motion-library/docs/tutorials/install/py

Verifies the installed Python 3 version. The Zaber Motion Library requires Python 3.8 or higher.

```bash
py -3 --version
```

```bash
python3 --version
```

```bash
python --version
```

--------------------------------

### OfflineTranslator Setup (Python, Java)

Source: https://software.zaber.com/zml-archive/4.5.1/motion-library/api/java/gcode/offlinetranslator

Demonstrates how to set up an OfflineTranslator instance in Python and Java. This translator converts G-Code blocks to Zaber ASCII protocol stream commands without needing a connected device. Requires firmware version 7.11 or later. The Python example connects to a serial port and gets a device, then sets up the translator. The Java example shows a direct setup.

```Python
import zaber.motion.ascii.Connection;
import zaber.motion.ascii.Device;
import zaber.motion.gcode.OfflineTranslator;

Connection connection = Connection.openSerialPort("COM3");
Device device = connection.getDevice(1);
OfflineTranslator offlineTranslator = OfflineTranslator.setupFromDevice(device, new int[] { 1, 2 });
```

```Java
import zaber.motion.gcode.OfflineTranslator;

OfflineTranslator offlineTranslator = OfflineTranslator.setup(...);
```

--------------------------------

### setupLive()

Source: https://software.zaber.com/dev-portal/motion-library/api/matlabjava/ascii/pvtsequence

Sets up the PVT sequence to control specified axes and queue actions on the device.

```APIDOC
## setupLive()

### Description
Setup the PVT sequence to control the specified axes and to queue actions on the device.

### Method
POST

### Endpoint
/websites/software_zaber/pvtSequence/setupLive

### Parameters
#### Path Parameters
None

#### Query Parameters
- **axes** (`int32[]`) - Required - Numbers of physical axes to setup the PVT sequence on.

### Request Example
```json
{
  "axes": [1, 2]
}
```

### Response
#### Success Response (200)
Indicates the PVT sequence was successfully set up for live control.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### setupLive()

Source: https://software.zaber.com/zml-archive/7.9.0/motion-library/api/java/ascii/stream

Setup the stream to control specified axes and queue actions on the device in live mode. Accepts variable number of axis arguments.

```APIDOC
## setupLive()

### Description
Setup the stream to control the specified axes and to queue actions on the device.

### Method
Async Method

### Syntax
```
stream.setupLive(...axes)
```

### Parameters
#### Arguments
- **...axes** (`int`) - Required - Numbers of physical axes to setup the stream on (variable length)

### Notes
- Async available
- Accepts variable number of axis arguments
```

--------------------------------

### Matlab Lockstep Class Example

Source: https://software.zaber.com/zml-archive/4.2.0/motion-library/api/java/ascii/lockstep

This Matlab example demonstrates obtaining a Lockstep object. The process involves opening a serial port connection, getting a device by its ID, and then retrieving the lockstep group. This code assumes the Zaber Motion Matlab toolbox is installed.

```matlab
connection = zaber.motion.ascii.Connection.openSerialPort('COM3');
device = connection.getDevice(1);
lockstep = device.getLockstep(1);
```

--------------------------------

### Preload Zaber Motion Core Native Library in MATLAB

Source: https://software.zaber.com/dev-portal/motion-library/docs/tutorials/install/matlab

Preloads the Zaber Motion core native library at the start of a MATLAB script to avoid delays on the first function call after installation or updates. This ensures that necessary linking files are generated or loaded.

```matlab
zaber.motion.Helper.init();
```

--------------------------------

### setup()

Source: https://software.zaber.com/motion-library/api/ts/gcode/offlinetranslator

Static async method that initializes a new OfflineTranslator instance from a device definition and optional configuration. Returns a fully configured translator ready for G-code translation.

```APIDOC
## setup()

### Description
Sets up translator from provided device definition and configuration.

### Method
Static Async Method

### Signature
`await OfflineTranslator.setup(definition, config?)`

### Parameters
#### Arguments
- **definition** (DeviceDefinition) - Required - Definition of device and its peripherals. The definition must match a device that later performs the commands
- **config** (TranslatorConfig) - Optional - Configuration of the translator

### Return Value
- **OfflineTranslator** - New instance of translator
```

--------------------------------

### setupLive()

Source: https://software.zaber.com/motion-library/api/ts/ascii/pvtsequence

Sets up the PVT sequence to control the specified axes and queue actions on the device. Allows for real-time control of multiple axes.

```APIDOC
## POST /pvtSequence/setupLive

### Description
Setup the PVT sequence to control the specified axes and to queue actions on the device. Allows for real-time control of multiple axes.

### Method
POST

### Endpoint
`/pvtSequence/setupLive`

### Parameters
#### Request Body
- **axes** (number[]) - Required - Numbers of physical axes to setup the PVT sequence on.

### Request Example
```json
{
  "axes": [0, 1]
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the success of the operation.

#### Response Example
```json
{
  "status": "setup_complete"
}
```
```

--------------------------------

### Axis Class - Getting Started

Source: https://software.zaber.com/motion-library/api/cpp/ascii/axis

The Axis class represents an axis of motion associated with a device. This example demonstrates how to obtain an Axis instance from a connected device through the Motion Library.

```APIDOC
## Axis Class Initialization

### Description
Obtain an instance of the Axis class from a connected device.

### Namespace
`zaber::motion::ascii`

### Code Example
```cpp
#include <zaber/motion/ascii.h>

Connection connection = Connection.openSerialPort("COM3");
Device device = connection.getDevice(1);
Axis axis = device.getAxis(1);
```

### Steps
1. Open a serial connection to the device
2. Get the Device instance from the connection
3. Get the Axis instance from the device

### Related Guides
- Sending arbitrary commands
```

--------------------------------

### setupStoreComposite()

Source: https://software.zaber.com/motion-library/api/ts/ascii/pvtsequence

Sets up the PVT sequence for composite actions, allowing lockstep axes and queuing into a PVT buffer.

```APIDOC
## setupStoreComposite()

### Description
Sets up the PVT sequence to use the specified axes and queue actions into a PVT buffer. Allows use of lockstep axes in a PVT sequence.

### Method
ASYNC

### Endpoint
`pvtSequence.setupStoreComposite(pvtBuffer, ...pvtAxes)`

### Parameters
#### Arguments
- **pvtBuffer** (PvtBuffer) - Required - The PVT buffer to queue actions in.
- **...pvtAxes** (PvtAxisDefinition[]) - Required - Definition of the PVT sequence axes.
```

--------------------------------

### setupLive() - Setup Live PVT Sequence

Source: https://software.zaber.com/motion-library/api/cpp/ascii/pvtsequence

Sets up the PVT sequence to control specified axes and queue actions on the device.

```APIDOC
## POST /pvtSequence/setupLive

### Description
Setup the PVT sequence to control the specified axes and to queue actions on the device.

### Method
POST

### Endpoint
/pvtSequence/setupLive

### Parameters
#### Request Body
- **axes** (int) - Required - Numbers of physical axes to setup the PVT sequence on.
```

--------------------------------

### Control a Specific Illuminator Channel in C++

Source: https://software.zaber.com/zml-archive/7.10.0/motion-library/api/java/microscopy/illuminator

Provides a C++ example of how to get an instance of an IlluminatorChannel to control a specific channel of an LED controller. Channels are numbered starting from 1.

```C++
#include <zaber/motion/ascii/connection.h>
#include <zaber/motion/microscopy/illuminator.h>
#include <zaber/motion/microscopy/illuminator_channel.h>

using namespace zaber::motion;

// Assuming 'connection' and 'illuminator' are already initialized
ascii::Connection connection = ascii::Connection::open_serial_port("COM3");
microscopy::Illuminator illuminator = microscopy::Illuminator::find(connection);
microscopy::IlluminatorChannel channel = illuminator.get_channel(1); // Get channel 1
```

--------------------------------

### setupStore()

Source: https://software.zaber.com/motion-library/api/matlab/ascii/pvtsequence

Sets up the PVT sequence to use specified axes and queues actions into a PVT buffer.

```APIDOC
## setupStore()

### Description
Sets up the PVT sequence to use the specified axes and queue actions into a PVT buffer.

### Method
POST (assumed, as it modifies state)

### Endpoint
/websites/software_zaber/pvtSequence/setupStore

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **pvtBuffer** (`zaber.motion.ascii.PvtBuffer`) - Required - The PVT buffer to queue actions in.
- **axes** (`int32`) - Required - Numbers of physical axes to setup the PVT sequence on.

### Request Example
```json
{
  "pvtBuffer": {"type": "zaber.motion.ascii.PvtBuffer", "value": "..."},
  "axes": 1
}
```

### Response
#### Success Response (200)
(No specific response body defined, assumed success indicates completion)

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### setupLive()

Source: https://software.zaber.com/zml-archive/6.3.0/motion-library/api/java/ascii/stream

Sets up the stream to control specified axes and queue actions on the device.

```APIDOC
## setupLive()

### Description
Setup the stream to control the specified axes and to queue actions on the device.

### Method
POST

### Endpoint
/websites/software_zaber/stream/setupLive

### Parameters
#### Request Body
- **axes** (array of int) - Required - Numbers of physical axes to setup the stream on.

### Request Example
```json
{
  "axes": [1, 2]
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the success of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### GET getDelay()

Source: https://software.zaber.com/zml-archive/5.1.3/motion-library/api/java/ascii/oscilloscope

Get the delay before oscilloscope recording starts. Returns the current start delay in the specified time units.

```APIDOC
## GET getDelay()

### Description
Get the delay before oscilloscope recording starts. Can optionally specify the unit of measure for the returned value.

### Method
GET (Async Available)

### Endpoint
oscilloscope.getDelay(unit)
oscilloscope.getDelay()

### Parameters
#### Query Parameters
- **unit** (Units) - Optional - Unit of measure to represent the delay in. Uses default unit if not specified.

### Response
#### Success Response (200)
- **delay** (double) - The current start delay in the selected time units.

#### Response Example
```
0.5
```
```

--------------------------------

### setupLive()

Source: https://software.zaber.com/dev-portal/motion-library/api/java/ascii/pvtsequence

Sets up the PVT sequence to control specified axes and queue actions on the device.

```APIDOC
## POST /pvtSequence/setupLive

### Description
Sets up the PVT sequence to control the specified axes and to queue actions on the device.

### Method
POST

### Endpoint
`/pvtSequence/setupLive`

### Parameters
#### Request Body
- **axes** (`int[]`) - Required - Numbers of physical axes to setup the PVT sequence on.

### Request Example
```json
{
  "axes": [1, 2]
}
```

### Response
#### Success Response (200)
(No specific response body defined, indicates successful setup)

#### Response Example
(Success is typically indicated by the absence of an error)
```

--------------------------------

### Get Zaber Device Instance (Matlab)

Source: https://software.zaber.com/zml-archive/7.2.0/motion-library/api/java/ascii/device

Illustrates obtaining a Zaber Device instance in Matlab by opening a serial port connection. This example is crucial for Matlab users starting with Zaber device control.

```matlab
connection = zaber.motion.ascii.Connection.openSerialPort('COM3');
device = connection.getDevice(1);
```

--------------------------------

### setupStore()

Source: https://software.zaber.com/zml-archive/7.9.0/motion-library/api/java/ascii/stream

Setup the stream to control specified axes and queue actions into a stream buffer. Supports variable number of axis arguments.

```APIDOC
## setupStore()

### Description
Setup the stream to control the specified axes and queue actions into a stream buffer.

### Method
Async Method

### Syntax
```
stream.setupStore(streamBuffer, ...axes)
```

### Parameters
#### Arguments
- **streamBuffer** (`StreamBuffer`) - Required - The stream buffer to queue actions in
- **...axes** (`int`) - Required - Numbers of physical axes to setup the stream on (variable length)

### Notes
- Async available
```

--------------------------------

### setupStore

Source: https://software.zaber.com/zml-archive/5.2.2/motion-library/api/java/ascii/stream

Sets up the stream to control specified axes and queue actions into a stream buffer.

```APIDOC
## setupStore(streamBuffer, ...axes)

### Description
Setup the stream to control the specified axes and queue actions into a stream buffer.

### Method
POST

### Endpoint
/stream/setupStore

### Parameters
#### Request Body
- **streamBuffer** (StreamBuffer) - Required - The stream buffer to queue actions in.
- **axes** (int array) - Required - Numbers of physical axes to setup the stream on.

### Request Example
```json
{
  "streamBuffer": "myBuffer",
  "axes": [1, 2]
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the success of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Control Specific Illuminator Channel (Python)

Source: https://software.zaber.com/motion-library/api/matlabjava/microscopy/illuminator

Provides an example of how to get an instance of `IlluminatorChannel` to control a specific channel of an illuminator. Channels are numbered starting from 1. This utilizes the Zaber Motion Library for Python.

```python
import zaber.motion.ascii.Connection
import zaber.motion.microscopy.Illuminator

connection = Connection.openSerialPort('COM3')
illuminator = Illuminator.find(connection)
channel = illuminator.getChannel(1)
```

--------------------------------

### Obtain Axis Instance in Matlab

Source: https://software.zaber.com/zml-archive/5.1.5/motion-library/api/java/ascii/axis

Illustrates how to get an Axis instance in Matlab. The example code connects to a serial port, fetches a device, and then retrieves the specified axis. This assumes the Zaber motion Matlab toolkit is installed.

```matlab
connection = zaber.motion.ascii.Connection.open_serial_port('COM3');
device = connection.get_device(1);
axis = device.get_axis(1);
```

--------------------------------

### setupStore()

Source: https://software.zaber.com/zml-archive/6.3.0/motion-library/api/java/ascii/stream

Sets up the stream to control specified axes and queue actions into a stream buffer.

```APIDOC
## setupStore()

### Description
Setup the stream to control the specified axes and queue actions into a stream buffer.

### Method
POST

### Endpoint
/websites/software_zaber/stream/setupStore

### Parameters
#### Request Body
- **streamBuffer** (StreamBuffer) - Required - The stream buffer to queue actions in.
- **axes** (array of int) - Required - Numbers of physical axes to setup the stream on.

### Request Example
```json
{
  "streamBuffer": "myBuffer",
  "axes": [1, 2]
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the success of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Setting Up Translator

Source: https://software.zaber.com/dev-portal/motion-library/api/cs/gcode/translator

Initializes the translator with a given stream and optional configuration. The stream must be in a live or store mode. This is an asynchronous setup process.

```python
await Translator.Setup(stream, config=None)
```

--------------------------------

### Verify Java Interface in Octave

Source: https://software.zaber.com/motion-library/docs/tutorials/install/octave

This command checks if Octave can interface with Java libraries. Ensure Java Runtime Environment (JRE) is correctly set up if this command fails. Refer to Octave's documentation for JRE setup.

```octave
javaclasspath

```

--------------------------------

### setupLive

Source: https://software.zaber.com/zml-archive/5.2.2/motion-library/api/java/ascii/stream

Sets up the stream to control specified axes and queue actions on the device.

```APIDOC
## setupLive(...axes)

### Description
Setup the stream to control the specified axes and to queue actions on the device.

### Method
POST

### Endpoint
/stream/setupLive

### Parameters
#### Request Body
- **axes** (int array) - Required - Numbers of physical axes to setup the stream on.

### Request Example
```json
{
  "axes": [1, 2]
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the success of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Javascript Example: Get Lockstep Device Information

Source: https://software.zaber.com/motion-library/api/cpp/ascii/lockstep

Provides an example of how to get a Lockstep object from a Zaber device using Javascript. This involves opening a serial port, getting a device, and then accessing its lockstep group. Requires the Zaber Motion Library for Javascript.

```javascript
// Assuming connection and device objects are already established:
// import { Connection, Device, Lockstep } from 'zaber-motion-library';
// const connection = await Connection.openSerialPort('COM3');
// const device = connection.getDevice(1);

// Get a lockstep group
// const lockstep = device.getLockstep(1);
```

--------------------------------

### setupLive()

Source: https://software.zaber.com/dev-portal/motion-library/api/java/ascii/stream

Setup the stream to control the specified axes and to queue actions on the device. This method is asynchronous and available for use.

```APIDOC
## setupLive()

### Description
Setup the stream to control the specified axes and to queue actions on the device.

### Method
Async

### Signature
```
stream.setupLive(...axes)
```

### Parameters
#### Arguments
- **...axes** (int) - Required - Numbers of physical axes to setup the stream on
```

--------------------------------

### Get Warnings from Device - Java

Source: https://software.zaber.com/motion-library/api/matlabjava/ascii/warnings

Demonstrates how to obtain a Warnings instance from a device object by establishing a serial connection, retrieving a device, and calling getWarnings(). This example shows the basic setup required to interact with device-level warnings.

```java
import zaber.motion.ascii.Connection;

connection = Connection.openSerialPort('COM3');
device = connection.getDevice(1);
warnings = device.getWarnings();
```

--------------------------------

### setupLive() - Setup Live PVT Sequence

Source: https://software.zaber.com/zml-archive/7.9.0/motion-library/api/java/ascii/pvtsequence

Setup the PVT sequence to control specified axes and queue actions on the device in real-time. This asynchronous method prepares the sequence for live operation.

```APIDOC
## setupLive()

### Description
Setup the PVT sequence to control the specified axes and to queue actions on the device for live execution.

### Method
Async

### Signature
```javascript
pvtSequence.setupLive(...axes)
```

### Parameters
#### Method Parameters
- **...axes** (int) - Required - Variable number of physical axis numbers to setup the PVT sequence on.

### Notes
- Async available
- Configures sequence for live, real-time axis control
- Accepts variable number of axis parameters
```

--------------------------------

### C#: Get Oscilloscope Delay

Source: https://software.zaber.com/zml-archive/7.13.0/motion-library/api/java/ascii/oscilloscope

Shows how to get the start delay before oscilloscope recording starts in C#. The delay can be requested in specified units or the default unit. Requires an active Oscilloscope instance.

```C#
using zaber.motion.ascii;
using zaber.motion;

// Assuming 'oscilloscope' is an initialized Oscilloscope object
// Example: Oscilloscope oscilloscope = device.get_oscilloscope();

// Get the start delay in seconds
// double delaySeconds = oscilloscope.getDelay(Units.TIME_S);

// Get the start delay using the default unit
// double delayDefault = oscilloscope.getDelay();

// Console.WriteLine($"Start delay: {delaySeconds} seconds");
Console.WriteLine("Function to get delay called.");
```

--------------------------------

### SetupStore()

Source: https://software.zaber.com/dev-portal/motion-library/api/cs/ascii/pvtsequence

Sets up the PVT sequence to use specified axes and queues actions into a PVT buffer. This is an asynchronous operation.

```APIDOC
## SetupStore()

### Description
Sets up the PVT sequence to use the specified axes and queues actions into a PVT buffer.

### Method
ASYNC

### Endpoint
`/websites/software_zaber`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **pvtBuffer** (PvtBuffer) - Required - The PVT buffer to queue actions in.
- **params axes** (int[]) - Required - Numbers of physical axes to setup the PVT sequence on.

### Request Example
```json
{
  "pvtBuffer": "<PvtBuffer object>",
  "params axes": [0, 1]
}
```

### Response
#### Success Response (200)
None (operation is asynchronous)

#### Response Example
None
```

--------------------------------

### C# Autofocus Example

Source: https://software.zaber.com/zml-archive/7.1.2/motion-library/api/java/microscopy/autofocus

Illustrates how to get an Autofocus instance in C#. This involves establishing a serial port connection, finding the microscope object, and then retrieving the autofocus device from the microscope. This setup is crucial for controlling autofocus features on a Zaber microscope.

```csharp
using Zaber.Motion.Ascii;
using Zaber.Motion.Microscopy;

Connection connection = Connection.OpenSerialPort("COM3");
Microscope microscope = Microscope.Find(connection);
Autofocus autofocus = microscope.GetAutofocus();
```

--------------------------------

### POST /stream/setupLive

Source: https://software.zaber.com/zml-archive/4.2.4/motion-library/api/java/ascii/stream

Setup the stream to control the specified axes and to queue actions on the device. This method initializes a live stream for real-time control.

```APIDOC
## POST /stream/setupLive

### Description
Setup the stream to control the specified axes and to queue actions on the device.

### Method
POST

### Endpoint
/stream/setupLive

### Parameters
#### Request Body
- **axes** (int...) - Required - Numbers of physical axes to setup the stream on.

### Request Example
{
  "axes": [1, 2, 3]
}

### Response
#### Success Response (200)
- **streamId** (string) - Stream identifier for subsequent operations.
- **status** (string) - Confirmation that live stream was setup.

### Availability
- Async available: Yes
```

--------------------------------

### Obtain OscilloscopeData Instance in Matlab

Source: https://software.zaber.com/zml-archive/5.2.2/motion-library/api/java/ascii/oscilloscopedata

Demonstrates obtaining an OscilloscopeData instance within the Matlab environment. This example connects to a serial port, retrieves a device, gets the oscilloscope object, and then reads the data. Ensure the Zaber Matlab library is installed and imported.

```matlab
% Assuming zaber.motion.ascii library is available and imported
try
    connection = zaber.motion.ascii.Connection.openSerialPort('COM3');
    device = connection.getDevice(1);
    oscilloscope = device.getOscilloscope();
    oscilloscopeData = oscilloscope.read();
    disp('Successfully obtained OscilloscopeData.');
catch ME
    disp(['An error occurred: ' ME.message]);
end

```

--------------------------------

### setupStore()

Source: https://software.zaber.com/dev-portal/motion-library/api/java/ascii/stream

Setup the stream to control the specified axes and queue actions into a stream buffer. This method is asynchronous and available for use.

```APIDOC
## setupStore()

### Description
Setup the stream to control the specified axes and queue actions into a stream buffer.

### Method
Async

### Signature
```
stream.setupStore(streamBuffer, ...axes)
```

### Parameters
#### Arguments
- **streamBuffer** (StreamBuffer) - Required - The stream buffer to queue actions in
- **...axes** (int) - Required - Numbers of physical axes to setup the stream on
```

--------------------------------

### Generate Positions for a 1D Rotary Path (Python)

Source: https://software.zaber.com/motion-library/docs/guides/device_features/pvt_sequence_generation

Enforces continuous acceleration and zero acceleration at the start point to generate position profiles. This example demonstrates generating positions for a 1-dimensional rotary path using specified velocities and times, with relative time as the default.

```Python
velocities = [
    MeasurementSequence([0, 180, -180, 180, 360, 0, -180, -360, 0], "°/s")
]
times = MeasurementSequence([0, 3, 6, 6, 3, 6, 3, 3, 6], "s")

generated = PvtSequence.generate_positions(velocities, times)
```

--------------------------------

### Obtain AllAxes Instance (Python, Java, C#)

Source: https://software.zaber.com/zml-archive/6.3.0/motion-library/api/java/ascii/allaxes

Demonstrates how to obtain an instance of the AllAxes class, representing all motion axes associated with a device. This requires establishing a connection and getting a device instance first. The example shows the typical setup for interacting with axes in Zaber devices.

```Python
import zaber.motion.ascii.AllAxes
import zaber.motion.ascii.Connection
import zaber.motion.ascii.Device

connection = Connection.open_serial_port("COM3")
device = connection.get_device(1)
all_axes = device.get_all_axes()
```

```Java
import zaber.motion.ascii.AllAxes;
import zaber.motion.ascii.Connection;
import zaber.motion.ascii.Device;

Connection connection = Connection.openSerialPort("COM3");
Device device = connection.getDevice(1);
AllAxes allAxes = device.getAllAxes();
```

```C#
using zaber.motion.ascii;

Connection connection = Connection.OpenSerialPort("COM3");
Device device = connection.GetDevice(1);
AllAxes allAxes = device.GetAllAxes();
```

--------------------------------

### Setting Up Translator

Source: https://software.zaber.com/motion-library/api/cs/gcode/translator

Initializes the translator instance using a provided stream and optional configuration. The stream must be in a live or store mode before setup.

```csharp
Translator translator = await Translator.Setup(stream, config);
```

--------------------------------

### GET getDelay() - Get Recording Delay

Source: https://software.zaber.com/zml-archive/5.1.1/motion-library/api/java/ascii/oscilloscope

Get the delay before oscilloscope recording starts. Can optionally specify the unit of measure for the returned delay value.

```APIDOC
## GET getDelay()

### Description
Get the delay before oscilloscope recording starts.

### Method
GET

### Endpoint
oscilloscope.getDelay(unit)
or
oscilloscope.getDelay()

### Parameters

#### Query Parameters
- **unit** (Units) - Optional - Unit of measure to represent the delay in.

### Response

#### Success Response (200)
- **delay** (double) - The current start delay in the selected time units.

### Availability
- Async available: Yes
```

--------------------------------

### Instantiate ProcessController in Python and C++

Source: https://software.zaber.com/dev-portal/motion-library/docs/guides/product_specific/process_controller

Demonstrates how to create an instance of the ProcessController class. This requires a device object, which is assumed to be obtained through Zaber Launcher or other means.

```python
process_controller = ProcessController(device)
```

```cpp
ProcessController processController(device);
```

--------------------------------

### Get Oscilloscope Data Example (Python)

Source: https://software.zaber.com/zml-archive/4.7.0/motion-library/api/java/ascii/oscilloscopedata

Example showing how to obtain OscilloscopeData from a Zaber device. This involves establishing a connection, getting a device, accessing its oscilloscope, and reading the data. Dependencies include the zaber.motion.ascii library.

```python
import zaber.motion.ascii.Connection
import zaber.motion.ascii.Device
import zaber.motion.ascii.Oscilloscope
import zaber.motion.ascii.OscilloscopeData

connection = Connection.openSerialPort("COM3")
device = connection.getDevice(1)
oscilloscope = device.getOscilloscope()
oscilloscopeData = oscilloscope.read()
```

--------------------------------

### Setup Live Composite with Lockstep Group

Source: https://software.zaber.com/motion-library/docs/guides/device_features/pvt

Configures a PVT sequence to include axes in a lockstep group for synchronized movement. This example sets up a stream on lockstep group 1 and a physical axis 3. Consult the Lockstep how-to guide for more information.

```Python
pvt_sequence.setup_live_composite(
    PvtAxisDefinition(1, PvtAxisType.LOCKSTEP),
    PvtAxisDefinition(3, PvtAxisType.PHYSICAL)
)
```

```JavaScript
await pvtSequence.setupLiveComposite(
    { axisNumber: 1, axisType: PvtAxisType.LOCKSTEP },
    { axisNumber: 3, axisType: PvtAxisType.PHYSICAL },
  );
```

```C#
pvtSequence.SetupLiveComposite(
    new PvtAxisDefinition { AxisNumber = 1, AxisType = PvtAxisType.Lockstep },
    new PvtAxisDefinition { AxisNumber = 3, AxisType = PvtAxisType.Physical }
);
```

```C++
pvtSequence.setupLiveComposite(
    new PvtAxisDefinition(1, PvtAxisType::LOCKSTEP),
    new PvtAxisDefinition(3, PvtAxisType::PHYSICAL)
);
```

```Java
pvtSequence.setupLiveComposite([
    PvtAxisDefinition(1, PvtAxisType.LOCKSTEP)
    PvtAxisDefinition(3, PvtAxisType.PHYSICAL)
]);
```

```MATLAB (legacy)
pvtSequence.setupLiveComposite(
    PvtAxisDefinition(1, PvtAxisType::LOCKSTEP),
    PvtAxisDefinition(3, PvtAxisType::PHYSICAL)
);
```

--------------------------------

### setup()

Source: https://software.zaber.com/zml-archive/4.2.2/motion-library/api/java/gcode/translator

Initializes a new Translator instance on top of a provided stream. This method supports both synchronous and asynchronous operation and accepts optional configuration parameters.

```APIDOC
## setup()

### Description
Sets up the translator on top of a provided stream.

### Method
Function Call (Async Available)

### Signature
```
Translator.setup(stream, config)
Translator.setup(stream)
```

### Parameters
#### Arguments
- **stream** (Stream) - Required - The stream to setup the translator on. The stream must be already setup in a live or a store mode
- **config** (TranslatorConfig) - Optional - Configuration of the translator

### Return Value
- **Translator** - New instance of translator
```

--------------------------------

### Initialize Zaber Motion Library (JavaScript)

Source: https://software.zaber.com/dev-portal/motion-library/docs/binary/tutorials/initialize_binary

Illustrates how to import and initialize the Zaber Motion Library using JavaScript for the binary protocol. This snippet uses require for module loading and an async main function.

```javascript
const { binary: { Connection } } = require('@zaber/motion');

async function main() {
  // The rest of your program goes here
}

main();
```

--------------------------------

### setupLive() - Setup Live Stream

Source: https://software.zaber.com/zml-archive/5.1.5/motion-library/api/java/ascii/stream

Setup the stream to control the specified axes and to queue actions on the device. This method initializes a live stream for real-time control of multiple axes.

```APIDOC
## setupLive()

### Description
Setup the stream to control the specified axes and to queue actions on the device.

### Method
POST

### Endpoint
`stream.setupLive(...axes)`

### Parameters
#### Method Arguments
- **...axes** (int) - Required - Numbers of physical axes to setup the stream on.

### Availability
- Async available

### Return Value
Void
```

--------------------------------

### GET getDelay() - Get Recording Delay

Source: https://software.zaber.com/zml-archive/7.10.0/motion-library/api/java/ascii/oscilloscope

Get the delay before oscilloscope recording starts. Can optionally specify the unit of measurement for the returned delay value.

```APIDOC
## getDelay()

### Description
Get the delay before oscilloscope recording starts. The delay can be retrieved in various time units.

### Method
GET (async available)

### Endpoint
osscilloscope.getDelay(unit)
osscilloscope.getDelay()

### Parameters

#### Arguments
- **unit** (Units) - Optional - Unit of measure to represent the delay in. If not specified, default units are used.

### Request Example
```
double delay = oscilloscope.getDelay(Units.SECONDS)
double delayDefault = oscilloscope.getDelay()
```

### Response
#### Success Response
- **delay** (double) - The current start delay in the selected time units.

#### Response Example
```
0.5
```
```

--------------------------------

### setupLive()

Source: https://software.zaber.com/motion-library/api/matlab/ascii/pvtsequence

Sets up the PVT sequence to control specified axes and queue actions on the device.

```APIDOC
## POST /pvtSequence/setupLive

### Description
Setup the PVT sequence to control the specified axes and to queue actions on the device.

### Method
POST

### Endpoint
/pvtSequence/setupLive

### Parameters
#### Request Body
- **axes** (integer[]) - Required - Numbers of physical axes to setup the PVT sequence on.

### Request Example
```json
{
  "axes": [1, 2]
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation of successful setup.

#### Response Example
```json
{
  "message": "PVT sequence setup live for axes 1, 2."
}
```
```
Tokens:
Raw