g29py 0.0.1__tar.gz

g29py-0.0.1/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: g29py
+Version: 0.0.1
+Summary: python driver for g29 wheel/pedals
+Author: sean pollock
+Author-email: seanap@protonmail.com
+Requires-Python: >=3.8,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: hid (==1.0.4)
+Description-Content-Type: text/markdown
+
+# g29py
+> python driver for logitech g29 wheel/pedals
+
+#### install
+`$ pip install g29py`
+
+```
+from g29py import G29
+g29 = G29()
+g29.reset() # wheel cal
+```
+
+```
+# write 
+g29.set_range(500)
+g29.set_friction(0.5)
+```
+
+```
+#read
+g29.start_pumping() # thread
+while 1:
+    state = g29.get_state()
+    print("steering:", state["steering"])
+    print("brake:", state["brake"])
+```
+
+#### sources
+
+- Write.md Read.md 
+- Commands based on nightmode's [logitech-g29](https://github.com/nightmode/logitech-g29) node.js driver.
+- Interface uses libhidapi ctype bindings from apmorton's [pyhidapi](https://github.com/apmorton/pyhidapi).
+
+
+### support
+
+Only Logitech G29 Driving Force Racing Wheels & Pedals kit supported on linux in ps3 mode.
+

g29py-0.0.1/README.md

@@ -0,0 +1,37 @@
+# g29py
+> python driver for logitech g29 wheel/pedals
+
+#### install
+`$ pip install g29py`
+
+```
+from g29py import G29
+g29 = G29()
+g29.reset() # wheel cal
+```
+
+```
+# write 
+g29.set_range(500)
+g29.set_friction(0.5)
+```
+
+```
+#read
+g29.start_pumping() # thread
+while 1:
+    state = g29.get_state()
+    print("steering:", state["steering"])
+    print("brake:", state["brake"])
+```
+
+#### sources
+
+- Write.md Read.md 
+- Commands based on nightmode's [logitech-g29](https://github.com/nightmode/logitech-g29) node.js driver.
+- Interface uses libhidapi ctype bindings from apmorton's [pyhidapi](https://github.com/apmorton/pyhidapi).
+
+
+### support
+
+Only Logitech G29 Driving Force Racing Wheels & Pedals kit supported on linux in ps3 mode.

g29py-0.0.1/g29py/__init__.py

@@ -0,0 +1,3 @@
+from .g29 import G29
+
+__all__ = ['G29']

g29py-0.0.1/g29py/g29.py

@@ -0,0 +1,157 @@
+import hid
+import time
+import threading
+import logging as log
+
+NAME = "Logitech G29 Driving Force Racing Wheel"
+GUID = "030000006d0400004fc2000011010000"
+VENDOR_ID = 1133
+PRODUCT_ID = 49743
+
+STEERING_COARSE_AXIS = 4
+STEERING_FINE_AXIS = 5
+ACCELERATOR_AXIS = 6
+BRAKE_AXIS = 7
+CLUTCH_AXIS = 8
+
+class G29:
+    cache = None
+    state = {
+        "steering": int,
+        "accelerator": int,
+        "brake": int,
+        "clutch": int,
+    }
+    def __init__(self):
+        try:
+            device = hid.Device(VENDOR_ID, PRODUCT_ID)
+        except:
+            raise Exception("Device not found. Is it plugged in?")
+        log.debug(f'Device manufacturer: {device.manufacturer}')
+        log.debug(f'Product: {device.product}')
+        self.device = device
+
+    def connect(self):
+        self.pump() # load cache
+        self.reset()
+
+    def reset(self):
+        # wheel calibration
+        self.device.write(bytes([0xf8, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00]))
+        self.device.write(bytes([0xf8, 0x09, 0x05, 0x01, 0x01, 0x00, 0x00]))
+        time.sleep(10) # wait for calibration
+
+    # WRITE
+
+    def force_constant(self, val=0.5):
+        if val < 0 or val > 1:
+            raise ValueError("force_constant val must be between 0 and 1")
+        # normalze to 0-255
+        val = round(int(val * 255))
+        log.debug(f'force_constant: {val}')
+        msg = [0x11, 0x00, val, 0x00, 0x00, 0x00, 0x00]
+        self.device.write(bytes(msg))
+
+    def force_friction(self, val=0.5):
+        if val < 0 or val > 1:
+            raise ValueError("force_fricion val must be between 0 and 1")
+        # normalze to 0-8
+        val = round(int(val * 8))
+        log.debug(f'force_friction: {val}')
+        msg = [0x21, 0x02, val, 0x00, val, 0x00, 0x00]
+        self.device.write(bytes(msg))
+
+    def set_range(self, val=400):
+        if val < 400 or val > 900:
+            raise ValueError("set_range val must be between 400 and 900")
+        range1 = val & 0x00ff
+        range2 = (val & 0xff00) >> 8
+        log.debug(f'range: {range1},{range2}')
+        msg = [0xf8, 0x81, range1, range2, 0x00, 0x00, 0x00]
+        self.device.write(bytes(msg))
+
+    def set_autocenter(self, strength=0.5, rate=0.05):
+        if strength < 0 or strength > 1:
+            raise ValueError("force_constant val must be between 0 and 1")
+        if rate < 0 or rate > 1:
+            raise ValueError("force_constant val must be between 0 and 1")
+        # autocenter up
+        up_msg = [0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
+        self.device.write(bytes(up_msg))
+        # normalze strength to 0-15
+        strength = round(int(strength * 15))
+        # normalze rate to 0-255
+        rate = round(int(rate * 255))
+        log.debug(f'autocenter: {strength} {rate}')
+        msg = [0xfe, 0x0d, strength, strength, rate, 0x00, 0x00, 0x00]
+        self.device.write(bytes(msg))
+
+    def autocenter_off(self):
+        msg = [0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
+        self.device.write(bytes(msg))
+
+    # slot 0-4, or 0xf3 for all
+    def force_off(self, slot=0xf3):
+        if slot < 0 or slot > 4 and slot !=0xf3:
+            raise ValueError("force_off slot must be between 0 and 4 or 0xf3")
+        log.debug(f'force_off: {slot}')
+        msg = [slot, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
+        self.device.write(bytes(msg))
+
+    # READ
+
+    def pump(self, timeout=10):
+        dat = self.device.read(16, timeout)
+
+        # only handle 12 byte msgs
+        byte_array = bytearray(dat)
+        if len(byte_array) >= 12:
+            self.update_state(byte_array)
+            self.cache = byte_array
+            
+        return dat
+
+    def start_pumping(self, timeout=10):
+        self.pump_thread = threading.Thread(target=self.pump_forever, args=(timeout,))
+        self.pump_thread.start()
+
+    def pump_forever(self, timeout=10):
+        while 1:
+            self.pump(timeout)
+    
+    def stop_pumping(self):
+        if self.thread is not None:
+            self.pump_thread.join()
+    
+    def get_state(self):
+        return self.state
+    
+    def update_state(self, byte_array):
+        if self.cache is None:
+            log.warn("cache not available")
+            return 
+
+        # update only diffs
+        # steering
+        if byte_array[4] != self.cache[4] or byte_array[5] != self.cache[5]:
+            steering_val = self.calc_steering(byte_array[5], byte_array[4])
+            self.state["steering"] = steering_val
+        # accelerator
+        if byte_array[6] != self.cache[6]:
+            self.state["accelerator"] = byte_array[6]
+        # brake
+        if byte_array[7] != self.cache[7]:
+            self.state["brake"] = byte_array[7]
+        # clutch
+        if byte_array[8] != self.cache[8]:
+            self.state["clutch"] = byte_array[8]
+
+    def calc_steering(self, coarse, fine):
+        # coarse 0-255
+        # fine 0-255
+        # normalize to 0-100
+        coarse = (coarse/256) * (100-(100/256))
+        # normalize to 0-3
+        fine = (fine/256) * (100/256)
+        # add together
+        return round(coarse + fine)

g29py-0.0.1/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "g29py"
+version = "0.0.1"
+description = "python driver for g29 wheel/pedals"
+authors = ["sean pollock <seanap@protonmail.com>"]
+readme = "README.md"
+packages = [{include = "g29py"}]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+hid = "1.0.4"
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.3.2"
+
+[build-system]
+requires = ["poetry-core", "libhidapi-hidraw0"]
+build-backend = "poetry.core.masonry.api"

g29py-0.0.1/setup.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup
+
+packages = \
+['g29py']
+
+package_data = \
+{'': ['*']}
+
+install_requires = \
+['hid==1.0.4']
+
+setup_kwargs = {
+    'name': 'g29py',
+    'version': '0.0.1',
+    'description': 'python driver for g29 wheel/pedals',
+    'long_description': '# g29py\n> python driver for logitech g29 wheel/pedals\n\n#### install\n`$ pip install g29py`\n\n```\nfrom g29py import G29\ng29 = G29()\ng29.reset() # wheel cal\n```\n\n```\n# write \ng29.set_range(500)\ng29.set_friction(0.5)\n```\n\n```\n#read\ng29.start_pumping() # thread\nwhile 1:\n    state = g29.get_state()\n    print("steering:", state["steering"])\n    print("brake:", state["brake"])\n```\n\n#### sources\n\n- Write.md Read.md \n- Commands based on nightmode\'s [logitech-g29](https://github.com/nightmode/logitech-g29) node.js driver.\n- Interface uses libhidapi ctype bindings from apmorton\'s [pyhidapi](https://github.com/apmorton/pyhidapi).\n\n\n### support\n\nOnly Logitech G29 Driving Force Racing Wheels & Pedals kit supported on linux in ps3 mode.\n',
+    'author': 'sean pollock',
+    'author_email': 'seanap@protonmail.com',
+    'maintainer': 'None',
+    'maintainer_email': 'None',
+    'url': 'None',
+    'packages': packages,
+    'package_data': package_data,
+    'install_requires': install_requires,
+    'python_requires': '>=3.8,<4.0',
+}
+
+
+setup(**setup_kwargs)