JoyIT-MotoPi 1.0.0__tar.gz

joyit_motopi-1.0.0/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

joyit_motopi-1.0.0/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+/dist

joyit_motopi-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kendra-eck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

joyit_motopi-1.0.0/MotoPi/__init__.py

@@ -0,0 +1,3 @@
+from .pca9685 import MotoPi
+
+name = "MotoPi"

joyit_motopi-1.0.0/MotoPi/_pwmregister.py

@@ -0,0 +1,59 @@
+import MotoPi
+from .pwmchannel import PWMChannel
+
+class _PWMRegister:
+
+    """
+    Provide low-level access to the 16 PCA9685 PWM register pairs.
+    Each entry is a tuple of 12-bit on/off counters with the optional
+    0x1000 full-on/full-off flag bit. This class is intended for internal use.
+
+    :param MotoPi pca: MotoPi object to controll pwm registers
+    """
+    
+    _LED0 = 0x06
+    
+    @staticmethod
+    def __checkValue(value, min, max):
+        """
+        Validate an integer against a half-open interval [min, max).
+        :param int value: parameter to check if it is in range
+        :param int min: minimum of value range
+        :param int max: maximum of value range
+        """
+        if not min <= value < max:
+            raise ValueError(f"Value is not in range of {min} and {max}")
+        return value
+    
+    def __init__(self, pca: "MotoPi"):
+        self._pca = pca
+
+    def __len__(self):
+        """
+        Return the number of register groups (16).
+        """
+        return 16
+
+    def __getitem__(self, index):
+        """
+        Read the on/off counter values for a channel index from 0 to 15.
+        :param int index: index of channel to read on/off values from
+        """
+        index = self.__checkValue(index, 0, len(self))
+        self._pca._enable_auto_increment()
+        data = self._pca._read_block(self._LED0 + index * 4, 4)
+        return (data[0] | (data[1] << 8), data[2] | (data[3] << 8))#
+
+    def __setitem__(self, index, value):
+        """
+        Write the on/off counter values for a channel index from 0 to 15.
+        The values must each be in the inclusive range 0x0000 through 0x1000.
+        :param int index: index of channel to write value on
+        :param int value: value to write onto channel
+        """
+        index = self.__checkValue(index, 0, len(self))
+        on, off = value
+        on = self.__checkValue(value[0], 0x00, 0x1001)
+        off = self.__checkValue(value[1], 0x00, 0x1001)
+        self._pca._enable_auto_increment()
+        self._pca._write_block(self._LED0 + index * 4, [on & 0xFF, on >> 8, off & 0xFF, off >> 8])

joyit_motopi-1.0.0/MotoPi/pca9685.py

@@ -0,0 +1,368 @@
+# This is a edited library from Adafruit 
+# Original can be found here: https://github.com/adafruit/Adafruit_CircuitPython_PCA9685
+
+"""
+The MIT License (MIT)
+
+Copyright (c) 2016 Radomir Dopieralski, written for Adafruit Industries
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+from ._pwmregister import _PWMRegister
+from .pcachannel import PCAChannel 
+import math
+import time
+
+class MotoPi:
+    """
+    Control the Joy-IT RB-Moto3 PCA9685 PWM controller over I2C.
+    
+    The controller exposes 16 PWM outputs that share one frequency. By default
+    it uses I2C bus 1, address 0x41, an external 25 MHz clock, and BCM GPIO 7
+    as the board-enable output. Pass ``enable_pin=None`` to skip GPIO control.
+
+    Use the controller as a context manager to release hardware resources on exit.
+    ``external_clock_hz`` specifies the clock rate for PWM calculations; it does
+    not measure or generate the external clock.
+
+    :param i2c_bus: I2C bus number (default: 1) or an SMBus-compatible bus object
+    :param int address: I2C device address (default: 0x41)
+    :param int external_clock_hz: Clock frequency used to calculate PWM timing in Hz (default: 25_000_000)
+    :param bool external_clock: if board is using external clock during reset (default: True)
+    :param int enable_pin: BCM GPIO number used to enable board or None to omit it (default: 7) 
+    """
+
+    _MODE1 = 0x00
+    _MODE2 = 0x01
+    _PRESCALE = 0xFE
+    _RESTART = 0x80
+    _EXTCLK = 0x40
+    _AI = 0x20
+    _SLEEP = 0x10
+    _LED0 = 0x06
+
+    def __init__(
+        self,
+        i2c_bus=1,
+        *,
+        address: int = 0x41,
+        external_clock_hz: int = 25_000_000,
+        external_clock=True,
+        enable_pin = 7,
+    ) -> None:
+        
+        self._address = address
+        if self._address == 0x70:
+            raise ValueError("0x70 is the all-call-address of the PCA9685")
+        self.reference_clock_speed = external_clock_hz
+        self._external_clock = bool(external_clock)
+        self._closed = False
+        self._owns_bus = isinstance(i2c_bus, int)
+        self._bus = None
+        self._enable = None
+        try:
+            if enable_pin is not None:
+                from gpiozero import OutputDevice
+                self._enable = OutputDevice(enable_pin, active_high = True, initial_value = True)
+            if self._owns_bus:
+                from smbus2 import SMBus
+                self._bus = SMBus(i2c_bus)
+            else:
+                self._bus = i2c_bus
+            self.channels = PCAChannel(self)
+            self.pwm_regs = _PWMRegister(self)
+            self.reset()
+        except Exception:
+            try:
+                self._release_resources()
+            finally:
+                self._closed = True
+            raise
+
+    @staticmethod
+    def _positiveValue(value):
+        """
+        Convert a value to a finite, strictly positive float.
+        Raises ValueError: If the converted value is zero, negative, or non-finite.
+        
+        :param float value: value to check if finite and positive
+        """
+        value = float(value)
+        if not math.isfinite(value) or value <= 0:
+            raise ValueError("Value is not above 0")
+        return value
+    
+    @property
+    def reference_clock_speed(self):
+        """
+        Return the configured reference-clock frequency in hertz.
+        """
+        return self._clock_hz
+
+    @reference_clock_speed.setter
+    def reference_clock_speed(self, value):
+        """
+        Set the clock rate used for PWM calculations (greater than 0, at most 50 MHz).
+
+        :param int value: new value to set clock rate to
+        """
+        value = self._positiveValue(value)
+        if value > 50_000_000:
+            raise ValueError("The PCA9685 only supports a maximum of 50 MHz.")
+        self._clock_hz = value
+
+    def _check_open(self):
+        """
+        Raises RuntimeError: this controller has already been closed.
+        """
+        if self._closed:
+            raise RuntimeError("PCA9685 was already closed")
+
+    def _read8(self, register):
+        """
+        Read one byte from an I2C register of the configured controller.
+
+        :param int register: register to read byte from
+        """
+        self._check_open()
+        return self._bus.read_byte_data(self._address, register)
+
+    def _write8(self, register, value):
+        """
+        Write one byte to an I2C register of the configured controller.
+
+        :param int register: register to write byte onto
+        :param int value: byte to write onto register
+        """
+        self._check_open()
+        self._bus.write_byte_data(self._address, register, value)
+
+    def _read_block(self, register, length):
+        """
+        Read exactly ``length`` consecutive bytes from an I2C register.
+        Raises OSError: If the bus returns fewer bytes than requested.
+        
+        :param int register: register to read from
+        :param int length: anmount of bytes to read from register
+        """
+        self._check_open()
+        data = self._bus.read_i2c_block_data(self._address, register, length)
+        if len(data) != length:
+            raise OSError("Incomplete I2C answer")
+        return data
+
+    def _write_block(self, register, data):
+        """
+        Write a sequence of bytes beginning at the given I2C register.
+
+        :param int register: register to write onto
+        :param int[] data: bytes to write onto register
+        """
+        self._check_open()
+        self._bus.write_i2c_block_data(self._address, register, data)
+
+    @property
+    def mode1_reg(self):
+        """
+        Read the PCA9685 MODE1 configuration register.
+        """
+        return self._read8(self._MODE1)
+
+    @mode1_reg.setter
+    def mode1_reg(self, value):
+        """
+        Write the PCA9685 MODE1 configuration register.
+
+        :param int value: value to write onto MODE1 configuration register
+        """
+        self._write8(self._MODE1, value)
+
+    @property
+    def mode2_reg(self):
+        """
+        Read the PCA9685 MODE2 output configuration register.
+        """
+        return self._read8(self._MODE2)
+
+    @mode2_reg.setter
+    def mode2_reg(self, value):
+        """
+        Write the PCA9685 MODE2 output configuration register.
+        
+        :param int value: value to write onto MODE2 configuration register
+        """
+        self._write8(self._MODE2, value)
+
+    @property
+    def prescale_reg(self):
+        """
+        Read the PWM frequency prescaler register.
+        """
+        return self._read8(self._PRESCALE)
+
+    @prescale_reg.setter
+    def prescale_reg(self, value):
+        """
+        Write the PWM frequency prescaler register.
+        
+        :param int value: value to write onto frequency prescaler register
+        """
+        self._write8(self._PRESCALE, value)
+
+    def _enable_auto_increment(self):
+        """
+        Enable automatic I2C register-address increment for block transfers.
+        """
+        mode = self.mode1_reg
+        if not mode & self._AI:
+            self.mode1_reg = (mode & ~self._RESTART) | self._AI
+
+    def reset(self) -> None:
+        """
+        Reset PWM output configuration and initialize the selected clock source.
+        All 16 PWM channels are switched off. The PCA9685 is configured with
+        auto-increment enabled and MODE2 set to 0x04.
+
+        Raises RuntimeError: If an active external clock conflicts with the requested internal-clock configuration. Power-cycle the device if necessary.
+        """
+        mode = self.mode1_reg
+        if mode & self._EXTCLK and not self._external_clock:
+            raise RuntimeError("EXTCLK is already active. External tact has to be configured or switch board on and off again to use internal tact.")
+        base = self._AI | (mode & self._EXTCLK)
+        self.mode1_reg = base
+        self.all_off()
+        self.mode1_reg = base | self._SLEEP
+        if self._external_clock:
+            base |= self._EXTCLK
+            self.mode1_reg = base | self._SLEEP
+        self.mode2_reg = 0x04
+        self.mode1_reg = base
+        time.sleep(0.005)
+
+    @property
+    def frequency(self) -> float:
+        """
+        Get the common PWM frequency in hertz, calculated from the prescaler.
+        """
+        prescale = self.prescale_reg
+        if prescale < 3:
+            raise ValueError("The device pre_scale register (0xFE) was not read or returned a value < 3")
+        return self.reference_clock_speed / (4096 * (prescale + 1))
+
+    @frequency.setter
+    def frequency(self, freq: float) -> None:
+        """
+        Set the PWM frequency shared by all 16 channels, in hertz.
+        The frequency is quantized to the PCA9685 prescaler resolution.
+
+        Raises ValueError: If the requested frequency cannot be represented.
+
+        :param float freq: new PWM frequency shared by all 16 channels in Hz
+        """
+        freq = self._positiveValue(freq)
+        prescale = int(self.reference_clock_speed / (4096.0 * freq) + 0.5) - 1
+        if not 3 <= prescale <= 0xFF:
+            raise ValueError("PCA9685 cannot output at the given frequency")
+        mode = self.mode1_reg  # Mode 1
+        base = (mode & ~(self._RESTART | self._SLEEP)) | self._AI
+        self.mode1_reg = base | self._SLEEP
+        self.prescale_reg = prescale  # Prescale
+        self.mode1_reg = base  # Mode 1
+        time.sleep(0.005)
+        # Mode 1, autoincrement on, fix to stop pca9685 from accepting commands at all addresses
+        self.mode1_reg = base | self._RESTART
+
+    def set_pwm(self, channel, on, off):
+        """
+        Set raw 12-bit PWM on/off counter positions for a channel.
+        
+        :param int channel: PWM output index from 0 to 15
+        :param int on: Counter value for the rising edge, or 0x1000 for full-on
+        :param int off: Counter value for the falling edge, or 0x1000 for full-off
+        """
+        self.pwm_regs[channel] = (on, off)
+
+    def write_microseconds(self, channel, microseconds):
+        """
+        Set a channel's high pulse width in microseconds.
+        The width is converted to 12-bit ticks using the current shared PWM
+        frequency. A width of zero switches the channel off. Set ``frequency``
+        before using this method.
+
+        Raises ValueError: If the width is invalid or cannot fit into one PWM period.
+        
+        :param int channel: PWM output index from 0 to 15
+        :param int microseconds: Non-negative pulse duration in microseconds
+        """
+        microseconds = float(microseconds)
+        if not math.isfinite(microseconds) or microseconds < 0:
+            raise ValueError("Pulse length must be finite and >= 0")
+        if microseconds == 0:
+            self.channels[channel].duty_cycle = 0
+            return
+        ticks = int(microseconds * self.frequency * 4096 / 1_000_000 + 0.5)
+        if not 1 <= ticks <= 4095:
+            raise ValueError("Pulse length is not within PWM period")
+        self.set_pwm(channel, 0, ticks)
+
+    def all_off(self):
+        """
+        Switch all 16 PWM outputs fully off using block I2C writes.
+        """
+        self._enable_auto_increment()
+        for first in range(0, 16, 4):
+            self._write_block(self._LED0 + first * 4, [0, 0, 0, 0x10] * 4)
+
+    def __enter__(self) -> "MotoPi":
+        """
+        Return the open controller for use in a ``with`` statement.
+        """
+        self._check_open()
+        return self
+
+    def __exit__(self, exception_type, exception_value, traceback) -> None:
+        """
+        Release the controller when leaving a ``with`` statement.
+        """
+        self.deinit()
+
+    def deinit(self) -> None:
+        """
+        Turn off all channels and release the owned I2C bus and GPIO device.
+        This operation is idempotent. ``close`` is an alias of this method.
+        """
+        if self._closed:
+            return
+        try:
+            self.all_off()
+        finally:
+            self._closed = True
+            self._release_resources()
+    
+    close = deinit
+
+    def _release_resources(self):
+        """
+        Close the I2C bus if owned and deactivate/close the GPIO output.
+        """
+        if self._owns_bus:
+            self._bus.close()
+        if self._enable is not None:
+            self._enable.off()
+            self._enable.close()

joyit_motopi-1.0.0/MotoPi/pcachannel.py

@@ -0,0 +1,68 @@
+# This is a edited library from Adafruit 
+# Original can be found here: https://github.com/adafruit/Adafruit_CircuitPython_PCA9685
+
+"""
+The MIT License (MIT)
+
+Copyright (c) 2016 Radomir Dopieralski, written for Adafruit Industries
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+import MotoPi
+from .pwmchannel import PWMChannel
+import operator
+
+class PCAChannel:
+    """
+    Provide indexed, lazily created access to the 16 PWM channels.
+    Channel objects are cached so repeated lookup returns the same object.
+    Integer indices and Python slices are supported.
+
+    :param MotoPi pca: object of MotoPi
+    """
+
+    def __init__(self, pca: "MotoPi") -> None:
+        self._pca = pca
+        self._channels = [None] * len(self)
+
+    def __len__(self) -> int:
+        """
+        Return the number of PWM output channels (16).
+        """
+        return 16
+
+    def __getitem__(self, index: int) -> PWMChannel:
+        """
+        Return a PWMChannel or a list of channels for a slice.
+        Negative integer indices are supported as in a Python sequence.
+
+        Raises IndexError: If an integer index is outside the available channels.
+        
+        :param int index: index of pwm channel
+        """
+        if isinstance(index, slice):
+            return [self[i] for i in range(*index.indices(len(self)))]
+        index = operator.index(index)
+        if index < 0:
+            index += len(self)
+        if not 0 <= index < 16:
+            raise IndexError("Index is not in range")
+        if self._channels[index] is None:
+            self._channels[index] = PWMChannel(self._pca, index)
+        return self._channels[index]

joyit_motopi-1.0.0/MotoPi/pwmchannel.py

@@ -0,0 +1,100 @@
+# This is a edited library from Adafruit 
+# Original can be found here: https://github.com/adafruit/Adafruit_CircuitPython_PCA9685
+
+"""
+The MIT License (MIT)
+
+Copyright (c) 2016 Radomir Dopieralski, written for Adafruit Industries
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+import MotoPi
+
+class PWMChannel:
+    """
+    Represent one of the 16 PCA9685 PWM output channels.
+    The public ``duty_cycle`` property uses the 16-bit PWMOut-style scale, while the underlying PCA9685 chip has 12-bit timing resolution.
+
+    :param MotoPi pca: The MotoPi object
+    :param int index: The index of the channel
+    """
+
+    @staticmethod
+    def __checkIndex(index: int, min=0, max=15):
+        """
+        Validate that a channel index falls within the inclusive bounds."""
+        if not min <= index <= max:
+            raise ValueError(f"Index is not in range of {min} and {max}")
+        return index
+    
+    def __init__(self, pca: "MotoPi", index: int):
+        self._pca = pca
+        self._index = self.__checkIndex(index)
+
+    @property
+    def frequency(self) -> float:
+        """
+        Return the shared PCA9685 PWM frequency in Hertz.
+        """
+        return self._pca.frequency
+
+    @frequency.setter
+    def frequency(self, value):
+        """
+        The overall PWM frequency in Hertz (read-only).
+        A PWMChannel's frequency cannot be set individually.
+        All channels share a common frequency, set by PCA9685.frequency.
+        """
+        raise NotImplementedError("frequency cannot be set on individual channels")
+    
+    @property
+    def duty_cycle(self) -> int:
+        """
+        Read duty cycle as a 16-bit value between 0 and 65535.
+        
+        Zero means fully off, while 65535 means fully on. 
+        Because the chip uses 12-bit PWM timing, intermediate values have limited resolution.
+        """
+        pwm = self._pca.pwm_regs[self._index]
+        if pwm[1] == 0x1000:
+                    return 0x0000
+        if pwm[0] == 0x1000:
+            return 0xFFFF
+        return ((pwm[1] - pwm[0]) & 0x0FFF) << 4
+
+    @duty_cycle.setter
+    def duty_cycle(self, value: int) -> None:
+        """
+        Set the channel duty cycle using a 16-bit value (0 to 65535).
+
+        Zero selects full-off and 65535 selects full-on. 
+        Other values are quantized to the controller's 12-bit PWM resolution.
+
+        Raises ValueError: If the value is outside the supported range.
+        """
+        if not 0 <= value <= 0xFFFF:
+            raise ValueError(f"Out of range: value {value} not 0 <= value <= 65,535")
+        if value == 0xFFFF: # Special case for "fully on":
+            self._pca.pwm_regs[self._index] = (0x1000, 0)
+        elif value < 0x0010: # Special case for "fully off":
+            self._pca.pwm_regs[self._index] = (0, 0x1000)
+        else: # Shift our value by four because the PCA9685 is only 12 bits but our value is 16
+            # value should never be zero here because of the test for the "fully off" case
+            # (the LEDn_ON and LEDn_OFF registers should never be set with the same values)
+            self._pca.pwm_regs[self._index] = (0, value >> 4)

joyit_motopi-1.0.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.5
+Name: JoyIT_MotoPi
+Version: 1.0.0
+Summary: This library enables usage of RB-Moto3 with the Raspberry Pi.
+Project-URL: Homepage, https://github.com/joy-it/JoyIT_MotoPi
+Project-URL: Issues, https://github.com/joy-it/JoyIT_MotoPi/issues
+Author-email: Joy-IT <service@joy-it.net>
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: adafruit-circuitpython-motor
+Requires-Dist: gpiozero
+Requires-Dist: smbus2
+Description-Content-Type: text/markdown
+
+# JoyIT_MotoPi
+
+Python library for controlling the **Joy-IT RB-Moto3** motor/servo expansion board on a Raspberry Pi. The board uses a **PCA9685 16-channel, 12-bit PWM controller** connected via I²C. The library provides access to the PWM channels, a shared frequency setting, raw PWM counter values and microsecond pulse generation.
+
+This implementation communicates directly with the controller through `smbus2` and uses `gpiozero` for the optional board-enable GPIO. **It does not require Adafruit CircuitPython PCA9685.** The included servo example uses `adafruit-circuitpython-motor`, which is a separate package.
+
+## Requirements
+
+- Raspberry Pi with Python **3.9 or later** and the I²C interface enabled.
+- Joy-IT RB-Moto3 connected to the appropriate Raspberry Pi GPIO/I²C interface.
+- Python packages: `smbus2`, `gpiozero` and `adafruit-circuitpython-motor` (declared in `pyproject.toml`).
+- The Linux user must have access to the I²C device and the configured GPIO pin.
+
+Enable I²C using `sudo raspi-config` (Interface Options → I2C), then reboot if prompted.
+
+## Installation
+
+You can install this library from PyPI. To install it for the current user on your Raspberry Pi, use the following command:
+
+```bash
+pip3 install JoyIT_MotoPi
+```
+
+Install library into virtual environment:
+```bash
+python -m venv --system-site-packages env
+source env/bin/activate
+pip3 install JoyIT_MotoPi
+```
+
+## API reference
+
+| API | Description |
+| --- | --- |
+| `MotoPi(...)` | Open the PWM controller and initialize its channels. |
+| `motopi.frequency` | Read or set the frequency shared by all 16 PWM outputs, in Hz. |
+| `motopi.channels[index]` | Get a channel (`0` through `15`); slices are also supported. |
+| `channel.duty_cycle` | Read/set a 16-bit duty-cycle value, from `0` (off) to `65535` (fully on). |
+| `channel.frequency` | Read-only shared frequency; cannot be changed per channel. |
+| `motopi.set_pwm(channel, on, off)` | Write raw PWM on/off counter values (0–4095; `0x1000` is a special full-on/full-off flag). |
+| `motopi.write_microseconds(channel, duration)` | Set the high pulse duration in µs at the current PWM frequency; `0` turns the channel off. |
+| `motopi.all_off()` | Turn off all outputs. |
+| `motopi.reset()` | Reinitialize the controller and clock selection; turns all channels off. |
+| `motopi.deinit()` / `motopi.close()` | Turn outputs off and release resources. |
+
+>[!Note]
+> Prefer the `with MotoPi(...) as motopi:` form: it calls `deinit()` when the block ends, including on exceptions. Without a context manager, call `motopi.close()` explicitly. When the library opens the I²C bus itself, it closes that bus; when you pass an existing bus object, it leaves ownership of that bus with the caller.
+
+
+## License and attribution
+
+See [LICENSE](LICENSE). Portions of the implementation are adapted from the [Adafruit CircuitPython PCA9685 library](https://github.com/adafruit/Adafruit_CircuitPython_PCA9685); the corresponding copyright and MIT license notices are retained in the source files.

joyit_motopi-1.0.0/README.md

@@ -0,0 +1,52 @@
+# JoyIT_MotoPi
+
+Python library for controlling the **Joy-IT RB-Moto3** motor/servo expansion board on a Raspberry Pi. The board uses a **PCA9685 16-channel, 12-bit PWM controller** connected via I²C. The library provides access to the PWM channels, a shared frequency setting, raw PWM counter values and microsecond pulse generation.
+
+This implementation communicates directly with the controller through `smbus2` and uses `gpiozero` for the optional board-enable GPIO. **It does not require Adafruit CircuitPython PCA9685.** The included servo example uses `adafruit-circuitpython-motor`, which is a separate package.
+
+## Requirements
+
+- Raspberry Pi with Python **3.9 or later** and the I²C interface enabled.
+- Joy-IT RB-Moto3 connected to the appropriate Raspberry Pi GPIO/I²C interface.
+- Python packages: `smbus2`, `gpiozero` and `adafruit-circuitpython-motor` (declared in `pyproject.toml`).
+- The Linux user must have access to the I²C device and the configured GPIO pin.
+
+Enable I²C using `sudo raspi-config` (Interface Options → I2C), then reboot if prompted.
+
+## Installation
+
+You can install this library from PyPI. To install it for the current user on your Raspberry Pi, use the following command:
+
+```bash
+pip3 install JoyIT_MotoPi
+```
+
+Install library into virtual environment:
+```bash
+python -m venv --system-site-packages env
+source env/bin/activate
+pip3 install JoyIT_MotoPi
+```
+
+## API reference
+
+| API | Description |
+| --- | --- |
+| `MotoPi(...)` | Open the PWM controller and initialize its channels. |
+| `motopi.frequency` | Read or set the frequency shared by all 16 PWM outputs, in Hz. |
+| `motopi.channels[index]` | Get a channel (`0` through `15`); slices are also supported. |
+| `channel.duty_cycle` | Read/set a 16-bit duty-cycle value, from `0` (off) to `65535` (fully on). |
+| `channel.frequency` | Read-only shared frequency; cannot be changed per channel. |
+| `motopi.set_pwm(channel, on, off)` | Write raw PWM on/off counter values (0–4095; `0x1000` is a special full-on/full-off flag). |
+| `motopi.write_microseconds(channel, duration)` | Set the high pulse duration in µs at the current PWM frequency; `0` turns the channel off. |
+| `motopi.all_off()` | Turn off all outputs. |
+| `motopi.reset()` | Reinitialize the controller and clock selection; turns all channels off. |
+| `motopi.deinit()` / `motopi.close()` | Turn outputs off and release resources. |
+
+>[!Note]
+> Prefer the `with MotoPi(...) as motopi:` form: it calls `deinit()` when the block ends, including on exceptions. Without a context manager, call `motopi.close()` explicitly. When the library opens the I²C bus itself, it closes that bus; when you pass an existing bus object, it leaves ownership of that bus with the caller.
+
+
+## License and attribution
+
+See [LICENSE](LICENSE). Portions of the implementation are adapted from the [Adafruit CircuitPython PCA9685 library](https://github.com/adafruit/Adafruit_CircuitPython_PCA9685); the corresponding copyright and MIT license notices are retained in the source files.

joyit_motopi-1.0.0/example/example.py

@@ -0,0 +1,18 @@
+import time
+from MotoPi import MotoPi
+from adafruit_motor import servo
+
+# open MotoPi as motopi
+with MotoPi(address=0x41, enable_pin=7) as motopi:
+    # set frequency of MotoPi
+    motopi.frequency = 50
+    # declare servo channel 0 of MotoPi
+    servo0 = servo.Servo(motopi.channels[0])
+    # move servo from position 0 to 180
+    for i in range(180):
+        servo0.angle = i
+        time.sleep(0.03)
+    # move servo from position 0 to 180
+    for i in range(180):
+        servo0.angle = 180 - i
+        time.sleep(0.03)

joyit_motopi-1.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["MotoPi"]
+
+[project]
+name = "JoyIT_MotoPi"
+version = "1.0.0"
+authors = [
+  { name="Joy-IT", email="service@joy-it.net" },
+]
+description = "This library enables usage of RB-Moto3 with the Raspberry Pi."
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license-files = ["LICENSE"]
+dependencies = ["smbus2", "gpiozero", "adafruit-circuitpython-motor"]
+
+[project.urls]
+Homepage = "https://github.com/joy-it/JoyIT_MotoPi"
+Issues = "https://github.com/joy-it/JoyIT_MotoPi/issues"