nexatom-downloads

NexatomTT Classes

The nexatomtt Python package provides a robust, object-oriented abstraction over the native C API. This section serves as the definitive API reference for the core classes you will use to initialize the SDK, control hardware, and parse data.

`NexatomLibrary`

The NexatomLibrary class acts as the root context for the SDK. It loads the packaged Windows DLL or Linux shared library, manages the ctypes bindings, and discovers connected hardware.

Method	Parameters	Returns	Description
`__init__`	`home: str`	`NexatomLibrary`	Initializes the library context from the extracted SDK root. Keep the package’s library/dependency layout intact.
`version`	None	`str`	Returns the semantic version of the native C++ library (e.g., `"1.2.0"`).
`library_info`	None	`str`	Returns a detailed build string, including the compiler version and Git commit hash used to build the native library.
`discover_devices`	`max_devices: int = 8`	`list[NexatomDeviceInfo]`	Scans the USB bus and returns selection records. Select one intended instrument for an ordinary application session.
`create_device`	`device_info: NexatomDeviceInfo`	`NexatomDevice`	Allocates an owning device handle. Call `connect_runtime()` for measurement readiness, or use `open_runtime_device()`.
`open_time_tag_file_reader`	`path: str`	`NexatomTimeTagReader`	Opens a single `.nxtt` binary file for offline decoding.
`open_time_tag_series_reader`	`directory: str`, `series_key: str`, `seq_start: int`, `seq_end: int`	`NexatomTimeTagReader`	Opens a sequence of rotated `.nxtt` files (e.g., `_001` to `_099`) as a single contiguous stream.

`NexatomDevice`

The NexatomDevice represents one selected instrument. It exposes hardware configuration, lifecycle and measurement endpoints through the common native API. Available channels and operations depend on the resolved native profile.

Connection & Lifecycle

connect() alone is useful for a firmware-service client; it does not replace the readiness contract of connect_runtime(). Creating a handle, connecting, selecting output, starting an engine and enabling a file saver are separate actions.

System Control

Channel Configuration

Measurement Modules

Callbacks & File Saving

The file-saving guide explains naming, rotation and format limitations. The callback reference includes correlation, versioned telemetry/configuration and Fast TIHI callbacks.

`NexatomTimeTagReader`

This class provides memory-safe iteration over offline .nxtt binary files. It implements the Python Context Manager protocol (with ... as reader:), ensuring file handles are closed properly.

Method	Parameters	Returns	Description
`header`	None	`NexatomTimeTagFileHeader`	Returns the metadata block containing the creation timestamp.
`read_batch`	`max_tags: int = 4096`	`list[NexatomTimeTag]`	Reads a bounded batch. An empty batch means EOF; an exception is a read error.
`iter_tags`	`batch_size: int = 4096`	`Generator`	Yields decoded tags sequentially without loading the whole file into RAM.
`export_csv`	`output_path: str`, `batch_size: int = 4096`	`int`	Writes native-decoded batches through Python’s standard CSV writer. Returns total rows written.

`NexatomError`

The SDK uses exceptions to handle hardware and configuration failures. If a C API function returns a negative error code, the Python wrapper intercepts it and raises a NexatomError.

Property	Type	Description
`code`	`int`	The native `nexatom_error_code_t` enum value (e.g., `-5` for Timeout).
`native_message`	`str`	The highly detailed, internal C++ string explaining exactly why the failure occurred.

Runtime Boot Classes (`nexatomtt.runtime_boot`)

These classes support the open_runtime_device(library, device_info, options=...) context manager. Normal startup delegates to native connect_runtime() and retains one device handle throughout boot and readiness; an already-running or supported legacy runtime uses the same entry point.

`RuntimeBootOptions`

`DeviceIdentity`

Retained identity utility for describing a discovery record. Normal runtime startup does not require clients to close, re-enumerate and recreate a device using it.

Property	Type	Description
`connection_id`	`str`	The board’s identity: `usb:` plus the USB port path (Windows: PnP location path; Linux: sysfs device name). It selects the board and changes if the board moves to another USB port.
`serial_number`	`str`	FT601 USB serial, for service information only. Boards can share it, so it never selects a board. Model and image identity are separate native profile fields.

from nexatomtt import NexatomLibrary, RuntimeBootOptions, open_runtime_device

library = NexatomLibrary(home="/path/to/extracted-sdk")
devices = library.discover_devices()
if len(devices) != 1:
    raise RuntimeError("Select one intended instrument before starting")
with open_runtime_device(library, devices[0],
                         options=RuntimeBootOptions(timeout_ms=20000)) as device:
    # Native startup is complete; inspect authority before choosing controls.
    profile = device.get_device_profile()
    print(f"Model: 0x{profile.product_model_id:08x}")
    # Configure and acquire using a complete tutorial's start/stop sequence.
    device.disconnect()  # Check shutdown errors explicitly before destruction.

nexatom-downloads

NexatomTT Classes

NexatomLibrary

NexatomDevice