one-axis-stage 0.0.2__py3-none-any.whl

one_axis_stage/__init__.py

@@ -0,0 +1,20 @@
+__author__ = "Lars B. Rollik"
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("one-axis-stage")
+except PackageNotFoundError:
+    __version__ = "0.0.1"
+
+
+OP_MODE_LOOKUP_TO_STR = {
+    0: "OP_POSITION",
+    1: "OP_EXTENDED_POSITION",
+    2: "OP_CURRENT_BASED_POSITION",
+    3: "OP_VELOCITY",
+    4: "OP_PWM",
+    5: "OP_CURRENT",
+}
+OP_MODE_LOOKUP = {v: k for k, v in OP_MODE_LOOKUP_TO_STR.items()}
+BAUDRATE_LOOKUP = {0: 9600, 1: 57600, 2: 115200, 3: 1000000}

one_axis_stage/api.py

@@ -0,0 +1,197 @@
+import json
+import logging
+import time
+from typing import Any
+
+from one_axis_stage import BAUDRATE_LOOKUP, OP_MODE_LOOKUP, OP_MODE_LOOKUP_TO_STR
+from one_axis_stage.connection import StageSerialConnection
+
+
+class StageAPI(StageSerialConnection):
+    stage_id: int = 0
+
+    def __init__(
+        self, serial_port: str, baudrate: int = 115200, timeout: float = 1
+    ) -> None:
+        # init serial connection
+        super().__init__(serial_port=serial_port, baudrate=baudrate, timeout=timeout)
+
+    # --- GETTERS ---
+
+    def get_stage_id(self) -> int:
+        self.send(command="e", order="c")
+        info_json = self.read_line()
+
+        # to dict
+        stage_id_dict = json.loads(info_json)
+        stage_id = stage_id_dict["stage_id"]
+        self.stage_id = stage_id
+        return stage_id
+
+    def scan_for_devices(self):
+        self.send(command="s", order="c")
+        time.sleep(2)
+
+        # while returning lines, read until no more lines
+        scan_result = ""
+        while self.connection.in_waiting > 0:
+            line = self.read_line()
+            scan_result += line + "\n"
+            logging.debug(f"Scan line: {line}")
+            time.sleep(2)
+
+        return scan_result
+
+    def get_info(self, device_id: int) -> str:
+        """"""
+        self.send(command="i", data=device_id, order="!cH")
+        info_json = self.read_line()
+
+        # to dict
+        info_dict = json.loads(info_json)
+
+        # resolve baud_rate_int -> baud_rate, same for operating mode
+        info_dict["baud_rate"] = BAUDRATE_LOOKUP.get(info_dict["baud_rate_int"])
+        info_dict["operating_mode"] = self._op_mode_int_to_str(
+            info_dict["operating_mode_int"]
+        )
+
+        return info_dict
+
+    def get_info_all(self, device_ids: list[Any]) -> str:
+        """"""
+        info_all = []
+        for device_id in device_ids:
+            info_all.append(self.get_info(device_id))
+
+        # data_order = "!c" + len(device_ids) * "H"
+        # self.send(command="I", data=device_ids, order=data_order)
+        # info_json = self.read_line()
+        # # to dict
+        # info_dict = json.loads(info_json)
+        # return info_dict
+        return info_all
+
+    def get_position(self, device_id: int) -> int:
+        """
+        Get the position of a device.
+        """
+        self.send(command="p", data=device_id, order="!cH")
+        # read 2 bytes & combine bytes to int
+        position = self.read_bytes(n_bytes=2, unpack_order="!H")
+        if isinstance(position, tuple):
+            position = position[0]
+
+        logging.debug(f"Position: {position}")
+        return position
+
+    # --- SETTERS ---
+
+    def set_position(self, device_id: int, position: int) -> None:
+        """
+        Set the position of a device.
+        """
+        self.send(
+            command="m",
+            data=[device_id, position],
+            order="!cHH",
+        )
+
+    def set_position_multiple(self, position_tuples: list[tuple[int, int]]) -> None:
+        """
+        Set the position of multiple devices.
+        """
+        logging.debug(f"Moving to position: {position_tuples}")
+
+        data = []
+        data_order = "!c"
+        for device_id, position in position_tuples:
+            data.append(device_id)
+            data.append(position)
+            data_order += "HH"
+
+        logging.debug(f"Data order: {data_order}")
+        logging.debug(f"Position tuples: {data}")
+
+        # send
+        self.send(command="M", data=data, order=data_order)
+
+    def set_baudrate(
+        self, device_id: int, current_baudrate: int, new_baudrate: int
+    ) -> None:
+        """
+        Set the baudrate of a device.
+        """
+        # TODO: assert baudrate in baudrate list
+
+        self.send(
+            command="b",
+            data=[device_id, current_baudrate, new_baudrate],
+            order="!cHII",
+        )
+
+    def set_device_id(self, current_device_id: int, new_device_id: int) -> None:
+        """
+        Set the device ID of a device.
+        """
+        # TODO: assert device id range
+
+        self.send(
+            command="d",
+            data=[current_device_id, new_device_id],
+            order="!cHH",
+        )
+
+    def set_velocity(self, device_id: int, velocity: int) -> None:
+        """
+        Set the velocity of a device.
+        """
+        # TODO: confirm that this is the velocity limit
+        assert velocity >= 0 and velocity <= 254, f"Invalid velocity: {velocity}"
+
+        self.send(
+            command="v",
+            data=[device_id, velocity],
+            order="!cHH",
+        )
+
+    def _op_mode_str_to_int(self, op_mode: str) -> int:
+        """
+        Resolve the operating mode code from the mode string.
+        """
+        return OP_MODE_LOOKUP.get(op_mode)
+
+    def _op_mode_int_to_str(self, op_mode: int) -> str:
+        """
+        Resolve the operating mode code from the mode string.
+        """
+        return OP_MODE_LOOKUP_TO_STR.get(op_mode)
+
+    def set_operating_mode(self, device_id: int, op_mode: str | int) -> None:
+        """
+        Set the operating mode of a device.
+        """
+        # resolve mode code
+        assert op_mode is not None, f"Invalid operating mode: {op_mode}"
+
+        if isinstance(op_mode, str):
+            op_mode = self._op_mode_str_to_int(op_mode=op_mode)
+
+        self.send(
+            command="o",
+            data=[device_id, op_mode],
+            order="!cHH",
+        )
+
+    def flash(self, device_id: int, duration_ms: int, repeats: int) -> None:
+        """
+        Flash the LED of a device.
+        """
+        assert isinstance(duration_ms, int)
+        assert isinstance(repeats, int)
+
+        self.send(
+            command="f",
+            data=[device_id, duration_ms, repeats],
+            order="!cHHH",
+        )

one_axis_stage/axis.py

@@ -0,0 +1,123 @@
+import logging
+
+from one_axis_stage.api import StageAPI
+
+
+class StageAxis:
+    name: str
+    id: int
+
+    position_raw: int = -1
+    position_min: int = -1
+    position_max: int = -1
+    velocity_max: int = 0
+    operating_mode: str = "OP_POSITION"
+    api: StageAPI
+
+    def __init__(
+        self,
+        name: str,
+        id: int,
+        # position_raw: int,
+        position_min: int,
+        position_max: int,
+        velocity_max: int,
+        operating_mode: str,
+        api: StageAPI,
+        **kwargs,
+    ) -> None:
+        self.name = name
+        self.id = id
+        # self.position_raw = position_raw
+        self.position_min = position_min
+        self.position_max = position_max
+        self.velocity_max = velocity_max
+        self.operating_mode = operating_mode
+        self.api = api
+
+        # set device mode
+        # self.set_operating_mode(device_id=self.id, op_mode=self.operating_mode)
+        # self.set_velocity(device_id=self.id, velocity=self.velocity_max)
+
+        # get attrs
+        # self.
+
+    def __repr__(self) -> str:
+        return f"StageAxis({self.name})"
+
+    def __str__(self) -> str:
+        return f"StageAxis: {self.name}"
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "id": self.id,
+            "position_raw": self.position_raw,
+            "position_min": self.position_min,
+            "position_max": self.position_max,
+            "velocity_max": self.velocity_max,
+            "operating_mode": self.operating_mode,
+        }
+
+    def get_info(self):
+        """
+        Get the information of the device.
+
+        Returns
+        -------
+        dict
+            Information of the device.
+
+        """
+        info = self.api.get_info(device_id=self.id)
+
+        # update Axis attributes
+        self.position_raw = info["position_raw"]
+        # self.position_deg = info["position_deg"]
+        self.velocity_max = info["velocity_max"]
+        self.operating_mode = info["operating_mode"]
+
+        return info
+
+    def get_position(self):
+        """
+        Get the position of the device.
+        """
+        self.position_raw = self.api.get_position(device_id=self.id)
+        logging.debug(f"Get position: {self.position_raw}")
+        return self.position_raw
+
+    def set_position(self, position: int) -> None:
+        """
+        Set the position of the device.
+        """
+        assert position >= self.position_min and position <= self.position_max, (
+            f"Invalid position: {position}"
+        )
+
+        self.api.set_position(device_id=self.id, position=position)
+        self.position_raw = position
+        logging.debug(f"Set position: {position}")
+
+    def set_velocity(self, velocity: int) -> None:
+        """
+        Set the velocity of the device.
+        """
+        assert velocity >= 0 and velocity <= self.velocity_max, (
+            f"Invalid velocity: {velocity}"
+        )
+
+        self.api.set_velocity(device_id=self.id, velocity=velocity)
+        logging.debug(f"Set velocity: {velocity}")
+
+    def set_operating_mode(self, op_mode: str | int) -> None:
+        """
+        Set the operating mode of the device.
+        """
+        assert op_mode is not None, f"Invalid operating mode: {op_mode}"
+
+        if isinstance(op_mode, str):
+            self._op_mode_str_to_int(op_mode=op_mode)  # type: ignore[attr-defined]
+
+        self.api.set_operating_mode(device_id=self.id, op_mode=op_mode)
+        logging.debug(f"Set operating mode: {op_mode}")

one_axis_stage/connection.py

@@ -0,0 +1,165 @@
+import logging
+import struct
+from typing import Any
+
+from serial import Serial
+
+
+class StageSerialConnection:
+    serial_port: str | None = None
+    baudrate: int | None = None
+    timeout: float = 1
+    connection: Serial | None = None
+
+    def __init__(
+        self,
+        serial_port: str | None = None,
+        baudrate: int | None = None,
+        timeout: float | None = None,
+        **kwargs: Any,
+    ) -> None:
+        self.serial_port = serial_port
+        self.baudrate = baudrate or 115200
+        self.timeout = timeout or 0.1
+
+    def dict(self) -> dict:
+        class_data = {
+            "serial_port": self.serial_port,
+            "baudrate": self.baudrate,
+            "timeout": self.timeout,
+        }
+        return class_data
+
+    def __repr__(self) -> str:
+        return (
+            f"SerialConnection(serial_port={self.serial_port}, "
+            f"baudrate={self.baudrate}, "
+            f"timeout={self.timeout})"
+        )
+
+    def __str__(self) -> str:
+        return (
+            f"SerialConnection: {self.serial_port} @ {self.baudrate} baud, "
+            f"timeout={self.timeout}"
+        )
+
+    @property
+    def connected(self) -> bool:
+        if self.connection is not None:
+            return self.connection.is_open
+        else:
+            return False
+
+    def connect(self) -> "StageSerialConnection":
+        if not self.connected:
+            self.connection = Serial(
+                port=self.serial_port,
+                baudrate=self.baudrate,
+                timeout=self.timeout,
+            )
+            # is open?
+            if self.connection.is_open:
+                logging.info(
+                    f"Connected to {self.serial_port} at {self.baudrate} baud."
+                )
+            else:
+                logging.error(f"Failed to open serial port {self.serial_port}.")
+
+        # clear buffer
+        self.connection.read(self.connection.in_waiting)
+
+        return self
+
+    def disconnect(self) -> None:
+        if self.connection is not None:
+            self.connection.close()
+            self.connection = None
+            logging.info(f"Disconnected from {self.serial_port}.")
+
+    def _encode(self, data: Any, order: str) -> bytes:
+        """Encode & pack as byte struct & flank by start/stop bytes."""
+        # check that data is list
+        if not isinstance(data, list):
+            data = [data]
+
+        # encode str to bytes
+        data_encoded = [
+            item.encode() if isinstance(item, str) else item for item in data
+        ]
+
+        # pack the data
+        data_packed = struct.pack(order, *data_encoded)
+
+        # flank the packed data with start/stop bytes </>
+        message = b"<" + data_packed + b">"
+
+        logging.debug(f"Encoded message: '{str(message)}'")
+        return message
+
+    def _clear_buffer(self):
+        self.connection.read(self.connection.in_waiting)
+        return not self.connection.in_waiting
+
+    def send(self, command: str, data: Any = None, order: str = None) -> None:
+        """"""
+        assert isinstance(command, str)
+        assert isinstance(data, list | int | str | type(None))
+        assert isinstance(order, str)
+
+        # combine command and data
+        if data is not None:
+            if not isinstance(data, list):
+                data = [data]
+            raw_data = [command] + data
+        else:
+            raw_data = command
+
+        # encode/pack
+        data_to_send = self._encode(raw_data, order=order)
+
+        # send data
+        if self.connected:
+            self._clear_buffer()
+            self.connection.write(data_to_send)
+            self.connection.flush()
+            logging.debug(f"Sent data: {data_to_send}")
+
+    def read_bytes(
+        self, n_bytes: int = None, unpack_order: str = None
+    ) -> tuple[Any, ...]:
+        """
+        Read n_bytes from the serial port and unpack them according to the
+        specified unpack_order.
+        The unpack_order should be a format string compatible with the
+        struct module.
+
+        Parameters
+        ----------
+        n_bytes : int
+        unpack_order : str
+
+        Returns
+        -------
+        tuple
+            Unpacked data as a tuple of values.
+
+        """
+        raw_data = self.connection.read(n_bytes)
+
+        # Check if the correct amount of data was read
+        if len(raw_data) != n_bytes:
+            raise ValueError(f"Did not receive {n_bytes} bytes from serial port")
+
+        # Unpack the data as separate variables
+        unpacked_bytes = struct.unpack(unpack_order, raw_data)
+
+        logging.debug(f"Unpacked bytes: {unpacked_bytes}")
+        return unpacked_bytes
+
+    def read_line(self) -> str:
+        """
+        Read a line from the serial port and decode it to a string.
+        """
+        line = self.connection.readline().decode("utf-8").strip()
+        logging.debug(f"Received line: {line}")
+        return line

one_axis_stage/controller.py

@@ -0,0 +1,181 @@
+import logging
+import time
+from pathlib import Path
+
+import yaml
+
+from one_axis_stage.api import StageAPI
+from one_axis_stage.axis import StageAxis
+
+
+class StageController:
+    serial_port: str
+    baudrate: int
+    timeout: float
+
+    api: StageAPI
+    axes: dict = {}
+    known_positions: dict = {}
+
+    def __init__(
+        self,
+        serial_port: str | None = None,
+        baudrate: int | None = None,
+        timeout: float | None = None,
+        # **kwargs,
+    ) -> None:
+        if serial_port is not None:
+            self.serial_port = str(serial_port)
+        if baudrate is not None:
+            self.baudrate = int(baudrate)
+        if timeout is not None:
+            self.timeout = float(timeout)
+
+        # if serial port is provided, connect to the stage
+        if self.serial_port is not None:
+            self.connect()
+
+    # getter/setter for config dict
+    @property
+    def config(self) -> dict:
+        return {
+            "stage_id": self.api.stage_id,
+            "connection": {
+                "serial_port": self.serial_port,
+                "baudrate": self.baudrate,
+                "timeout": self.timeout,
+            },
+            "axes": {
+                axis_name: axis.__dict__() for axis_name, axis in self.axes.items()
+            },
+            "known_positions": self.known_positions,
+        }
+
+    @config.setter
+    def config(self, config: dict) -> None:
+        self.serial_port = config["connection"]["serial_port"]
+        self.baudrate = config["connection"]["baudrate"]
+        self.timeout = config["connection"]["timeout"]
+
+        self.axes = {}
+        for axis_name, axis_config in config["axes"].items():
+            self.add_axis(axis_name, **axis_config)
+            time.sleep(1)
+
+        # self.axes = {
+        #     axis_name: StageAxis(controller=self, name=axis_name, **axis_config)
+        #     for axis_name, axis_config in config["axes"].items()
+        # }
+        self.known_positions = config["known_positions"]
+
+    def connect(self) -> None:
+        self.api = StageAPI(
+            serial_port=self.serial_port,
+            baudrate=self.baudrate,
+            timeout=self.timeout,
+        )
+        self.api.connect()
+        self.api.get_stage_id()
+
+    # factory function to create a StageController instance from a configuration file
+    @staticmethod
+    def from_config(config_file: str | Path | dict) -> "StageController":
+        if isinstance(config_file, str):
+            config_file = Path(config_file)
+
+        if isinstance(config_file, Path):
+            config_file = Path(config_file)
+            # check file exists
+            if not config_file.is_file():
+                raise FileNotFoundError(f"Config file not found: {config_file}")
+
+            config_file.open("r")
+            with config_file.open("r") as file:
+                # yaml full load
+                stage_config = yaml.full_load(file)
+        elif isinstance(config_file, dict):
+            stage_config = config_file
+        else:
+            raise TypeError(f"Config type {config_file} is not supported")
+
+        ctrl = StageController(**stage_config["connection"])
+        ctrl.config = stage_config
+
+        # ctrl.ping_axes()
+
+        return ctrl
+
+    def save_config(self, config_file: str | Path, overwrite: bool = True) -> bool:
+        config_file = Path(config_file)
+        # check file exists
+        if config_file.exists() and not overwrite:
+            raise FileExistsError(f"Config file already exists: {config_file}")
+
+        with config_file.open("w") as file:
+            yaml.dump(self.config, file)
+
+        return config_file.exists()
+
+    def add_axis(self, axis_name: str, **axis_config) -> None:
+        if "name" in axis_config:
+            axis_name = axis_config.pop("name")
+
+        if axis_name in self.axes:
+            raise ValueError(f"Axis already exists: {axis_name}")
+
+        self.axes[axis_name] = StageAxis(api=self.api, name=axis_name, **axis_config)
+        info = self.axes[axis_name].get_info()
+        logging.debug(f"Controller: Added new axis {axis_name} ({info})")
+
+        return self.axes[axis_name]
+
+    def ping_axes(self) -> None:
+        for axis in self.axes.values():
+            axis.get_info()
+
+    def move_to_position(self, position: dict) -> None:
+        logging.debug(f"Controller: Move to position: {position}")
+
+        # lookup axis by name and move to position
+        position_by_axis_id = []
+        for axis_name in position:
+            axis_id = self.axes[axis_name].id
+            axis_target = position[axis_name]
+            logging.debug(f"Controller: Move to axis: {axis_id} -> {axis_target}")
+            if "position_raw" in axis_target:
+                axis_target_position = axis_target["position_raw"]
+                logging.debug(f"removing key position_raw from target {axis_target}")
+            else:
+                axis_target_position = axis_target
+
+            position_by_axis_id.append((axis_id, axis_target_position))
+
+        # position_by_axis_id = [
+        #     (self.axes[axis_name].id, position[axis_name]["position_raw"])
+        #     for axis_name in position
+        # ]
+        # # FIXME: should have to write position_raw here
+
+        return self.api.set_position_multiple(position_tuples=position_by_axis_id)
+
+    def move_to_known_position(self, position_name: str) -> None:
+        position = self.known_positions.get(position_name)
+
+        if position is None:
+            raise ValueError(f"Unknown position: {position_name}")
+
+        return self.move_to_position(position)
+
+    def save_as_known_position(self, position_name: str) -> None:
+        new_position = {}
+        for axis_name in self.axes:
+            # self.axes[axis_name].dict()
+            self.axes[axis_name].get_info()
+            axis_dict = self.axes[axis_name].__dict__()
+            new_position[axis_name] = {"position_raw": axis_dict["position_raw"]}
+
+        self.known_positions[position_name] = new_position
+        logging.debug(f"Controller: Save as known position: {new_position}")
+
+    def remove_known_position(self, position_name: str) -> None:
+        self.known_positions.pop(position_name)

one_axis_stage/interface.py

@@ -0,0 +1,94 @@
+import logging
+from functools import partial
+
+from one_axis_stage.controller import StageController
+
+
+class MoveInterface:
+    """"""
+
+    controller: StageController
+    small_increment: int
+    large_increment: int
+
+    def __init__(
+        self,
+        controller: StageController,
+        small_increment: int = 20,
+        large_increment: int = 40,
+    ):
+        super().__init__()
+        self.controller = controller
+        self.small_increment = small_increment
+        self.large_increment = large_increment
+
+        for axis_name in self.controller.axes:
+            logging.info(f"Creating move methods for axis '{axis_name}'")
+            # slow
+            setattr(
+                self,
+                f"{axis_name}p",
+                partial(
+                    self.move_axis_by_increment,
+                    axis_name=axis_name,
+                    direction_forward=True,
+                    fast_mode=False,
+                ),
+            )
+            setattr(
+                self,
+                f"{axis_name}m",
+                partial(
+                    self.move_axis_by_increment,
+                    axis_name=axis_name,
+                    direction_forward=False,
+                    fast_mode=False,
+                ),
+            )
+            # fast
+            setattr(
+                self,
+                f"{axis_name}pp",
+                partial(
+                    self.move_axis_by_increment,
+                    axis_name=axis_name,
+                    direction_forward=True,
+                    fast_mode=True,
+                ),
+            )
+            setattr(
+                self,
+                f"{axis_name}mm",
+                partial(
+                    self.move_axis_by_increment,
+                    axis_name=axis_name,
+                    direction_forward=False,
+                    fast_mode=True,
+                ),
+            )
+
+    def move_axis_by_increment(
+        self,
+        axis_name: str,
+        direction_forward: bool = True,
+        fast_mode: bool = False,
+    ):
+        axis = self.controller.axes.get(axis_name)
+        if axis:
+            increment_speed = (
+                self.small_increment if not fast_mode else self.large_increment
+            )
+            increment = increment_speed if direction_forward else -increment_speed
+            new_position = axis.position_raw + increment
+            logging.info(
+                f"Moving axis '{axis.name}' {axis.position_raw}->{new_position} ({increment})"
+            )
+
+            # try to move, but ignore errors, only report
+            try:
+                axis.set_position(new_position)
+            except AssertionError as e:
+                logging.error(e)
+
+        else:
+            raise ValueError(f"Axis '{axis_name}' not found in controller")

one_axis_stage-0.0.2.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: one-axis-stage
+Version: 0.0.2
+Summary: Hardware design and software for modular, low-cost one-axis stages
+Project-URL: Homepage, https://github.com/murineshiftwork/one-axis-stage
+Project-URL: Documentation, https://murineshiftwork.github.io/one-axis-stage/
+Project-URL: Issue Tracker, https://github.com/murineshiftwork/one-axis-stage/issues
+Author-email: "Lars B. Rollik" <lars@rollik.me>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2021-present, Lars B. Rollik
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: pyserial
+Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: commitizen; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: types-pyyaml; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material; extra == 'docs'
+Description-Content-Type: text/markdown
+
+[//]: # (Links)
+[Github-flavored markdown]: https://github.github.com/gfm
+
+[manifest]: https://packaging.python.org/en/latest/guides/using-manifest-in
+[packaging]: https://packaging.python.org/en/latest/tutorials/packaging-projects
+[setup.cfg]: https://setuptools.pypa.io/en/latest/userguide/declarative_config.html
+
+[bump2version]: (https://github.com/c4urself/bump2version
+[pre-commit]: https://pre-commit.com
+
+[//]: # ([black]: https://github.com/psf/black)
+[ruff]: https://docs.astral.sh/ruff
+[mypy]: https://mypy.readthedocs.io
+
+[pypi]: pypi.org
+[test.pypi]: test.pypi.org
+
+[Zenodo]: https://zenodo.org
+
+[contribution guidelines]: https://github.com/larsrollik/one-axis-stage/blob/main/CONTRIBUTING.md
+[issues]: https://github.com/larsrollik/one-axis-stage/issues
+[BSD 3-Clause License]: https://github.com/larsrollik/one-axis-stage/blob/main/LICENSE
+[Github]: https://github.com/larsrollik/one-axis-stage/settings/secrets/actions/new
+[release]: https://github.com/larsrollik/one-axis-stage/releases/new
+
+[//]: # (Badges)
+
+[![Contributions](https://img.shields.io/badge/Contributions-Welcome-brightgreen.svg)](https://github.com/larsrollik/one-axis-stage/blob/main/CONTRIBUTING.md)
+![CI](https://img.shields.io/github/actions/workflow/status/larsrollik/one-axis-stage/pre-pr-checks.yaml?branch=main&label=build)
+[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
+[![Website](https://img.shields.io/website?up_message=online&url=https%3A%2F%2Fgithub.com/larsrollik/one-axis-stage)](https://github.com/larsrollik/one-axis-stage)
+
+[//]: # ([![PyPI]&#40;https://img.shields.io/pypi/v/one-axis-stage.svg&#41;]&#40;https://pypi.org/project/one-axis-stage&#41;)
+[//]: # ([![Wheel]&#40;https://img.shields.io/pypi/wheel/one-axis-stage.svg&#41;]&#40;https://pypi.org/project/one-axis-stage&#41;)
+
+# one-axis-stage
+Hardware design and software for modular, low-cost one-axis stages
+---
+**Version: "0.0.1"**
+
+```-> TODO: add image```
+
+## Hardware build
+
+### Parts list
+
+##### Commercially available parts
+
+| Part name                     | Product code          | Amount (#) | Cost per part (GBP) | Total cost (GBP) |                                                                                                      |
+|-------------------------------|-----------------------|------------|---------------------|------------------|------------------------------------------------------------------------------------------------------|
+| Arduino Mega 2560             |                       | 1          | 20                  |                  | https://docs.arduino.cc/hardware/mega-2560                                                           |
+| Dynamixel Arduino shield      |                       | 1          | 20                  |                  | https://emanual.robotis.com/docs/en/parts/interface/dynamixel_shield/                                |
+| Dynamixel XL-320 motor        | XL-320                | 1+         | 20                  |                  | https://emanual.robotis.com/docs/en/dxl/x/xl320/                                                     |
+| USB to TTL adapter            | LN-101 or MIKROE-3063 | 1          | 14 / 13             |                  | https://emanual.robotis.com/docs/en/parts/interface/ln-101 / https://www.mikroe.com/usb-uart-3-click |
+| USB-B to other USB (computer) |                       | 1          |                     |                  |                                                                                                      |
+| Linear slide 26mm range       | BSP1035SL             | 2+         | 26                  |                  | https://uk.rs-online.com/web/p/linear-slides/0749301                                                 |
+|                               |                       |            |                     |                  |                                                                                                      |
+
+##### 3D-printed parts
+
+| Part | Count |
+|------|-------|
+|      |       |
+|      |       |
+|      |       |
+
+### Assembly instructions
+
+```-> TODO: add info on how to assemble the hardware```
+
+## Software controller
+
+### Example usage
+
+```python
+from one_axis_stage import StageController
+
+```
+
+
+## Contributing
+Contributions are very welcome!
+Please see the [contribution guidelines] or check out the [issues]
+
+
+## License
+This software is released under the **[BSD 3-Clause License]**

one_axis_stage-0.0.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+one_axis_stage/__init__.py,sha256=Dq1imqtnE5ooaYlUokYrmDxk8ypBe-Fzp_faL8blnv8,503
+one_axis_stage/api.py,sha256=l_1lYoQUgUsJo4J-1hYx8NpWmpgZ-03I-oyTzOtI4PQ,5759
+one_axis_stage/axis.py,sha256=CSnU1XmeaDX-dug8XKDnQ3yfad_q_zpwC_l9gXKmW7I,3497
+one_axis_stage/connection.py,sha256=ecVqqdS9zDbDXnmgAVSwU_jhH9KX_tyRYwnPiJ1cpQc,4891
+one_axis_stage/controller.py,sha256=V9wRqtCTJ-T-KfhXbPJSRIefxTyjHHwBfTFdwFRnxdE,6170
+one_axis_stage/interface.py,sha256=0fLf8q9-RTH9PHzF0cc9XETuRuhCEwMrojcoQxD84pM,2812
+one_axis_stage/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+one_axis_stage-0.0.2.dist-info/METADATA,sha256=iFZQVwdw8Eupa_1gY_j69zwc0pwxPea4uQ5DASgBryA,7208
+one_axis_stage-0.0.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+one_axis_stage-0.0.2.dist-info/licenses/LICENSE,sha256=mup8CL1NS8uJb0HhKkmUbOapCMXvL_Vf5CG2VsqTnjM,1530
+one_axis_stage-0.0.2.dist-info/RECORD,,

one_axis_stage-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

one_axis_stage-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2021-present, Lars B. Rollik
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.