Merge pull request #6 from flok/examples

Examples

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Florian K.
+
+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.

README.md

@@ -1,22 +1,48 @@
 # pydualsense
-control your dualsense through python. using the hid library this module implements the sending report for controlling you new PS5 controller. It creates a background thread to constantly update the controller.
+control your dualsense through python. using the hid library this module implements the sending report for controlling you new PS5 controller. It creates a background thread to constantly receive and update the controller.
 
-# dependecies
+# install
 
-- hid >= 1.0.4
+Just install the package from [pypi](https://pypi.org/project/pydualsense/)
 
+```bash
+pip install pydualsense
+```
 # usage
 
+
+
 ```python
 
 from pydualsense import pydualsense
 
 ds = pydualsense() # open controller
 ds.setColor(255,0,0) # set touchpad color to red
+ds.setLeftTriggerMode(TriggerModes.Rigid)
+ds.setLeftTriggerForce(1, 255)
 ds.close() # closing the controller
 ```
 
+See ``examples`` folder for some more ideas
+
+# Help wanted
+
+Help wanted from people that want to use this and have feature requests. Just open a issue with the correct label.
+
+# dependecies
+
+- hid >= 1.0.4
+
+# Credits
+
+
+Most stuff for this implementation were provided by and used from:
+
+
+- [https://www.reddit.com/r/gamedev/comments/jumvi5/dualsense_haptics_leds_and_more_hid_output_report/](https://www.reddit.com/r/gamedev/comments/jumvi5/dualsense_haptics_leds_and_more_hid_output_report/)
+- [https://github.com/Ryochan7/DS4Windows](https://github.com/Ryochan7/DS4Windows)
+
 # Coming soon
 
-- reading the states of the controller to enable a fully compatibility with python
+- reading the states of the controller to enable a fully compatibility with python - partially done
-- add documentation
+- add documentation using sphinx

examples/README.md

@@ -0,0 +1,15 @@
+# Examples
+
+This folder contains some examples on applications for the library and its usage
+
+## leds.py
+
+The leds.py shows you how you can interact and change the lights of the controller
+
+## effects.py
+
+The effects.py show some effects of the controller
+
+## read_controller.py
+
+The read_controller.py display how you can access the button state of the controller

examples/effects.py

@@ -0,0 +1,22 @@
+from pydualsense import *
+
+# get dualsense instance
+dualsense = pydualsense()
+dualsense.init()
+
+print('Trigger Effect demo started')
+
+dualsense.setLeftMotor(255)
+dualsense.setRightMotor(100)
+dualsense.setLeftTriggerMode(TriggerModes.Rigid)
+dualsense.setLeftTriggerForce(1, 255)
+
+dualsense.setRightTriggerMode(TriggerModes.Pulse_A)
+dualsense.setRightTriggerForce(0, 200)
+dualsense.setRightTriggerForce(1, 255)
+dualsense.setRightTriggerForce(2, 175)
+
+import time; time.sleep(3)
+
+# terminate the thread for message and close the device
+dualsense.close()

examples/leds.py

@@ -0,0 +1,16 @@
+from pydualsense import *
+
+# get dualsense instance
+dualsense = pydualsense()
+dualsense.init()
+# set color around touchpad to red
+dualsense.setColor(0,0,255)
+# enable microphone indicator
+dualsense.setMicrophoneLED(1)
+# set all player indicators on
+dualsense.setPlayerID(PlayerID.all)
+# sleep a little to see the result on the controller
+# this is not needed in normal usage
+import time; time.sleep(2)
+# terminate the thread for message and close the device
+dualsense.close()

examples/read_controller.py

@@ -0,0 +1,15 @@
+from pydualsense import *
+
+# create dualsense
+dualsense = pydualsense()
+# find device and initialize
+dualsense.init()
+
+# read controller state until R1 is pressed
+while not dualsense.state.R1:
+    print(f"Circle : {dualsense.state.circle} Cross : {dualsense.state.cross} L Stick X : {dualsense.state.LX} L Stick Y : {dualsense.state.LY}")
+
+# close device
+dualsense.close()
+
+

pydualsense/enums.py

@@ -1,6 +1,6 @@
 from enum import IntFlag
 
-class LedOptions(IntFlag): 
+class LedOptions(IntFlag):
     Off=0x0,
     PlayerLedBrightness=0x1,
     UninterrumpableLed=0x2,
@@ -25,12 +25,12 @@ class PlayerID(IntFlag):
     all = 31
 
 class TriggerModes(IntFlag):
-    Off =0x0, # no resistance
+    Off = 0x0, # no resistance
-    Rigid =0x1, # continous resistance
+    Rigid = 0x1, # continous resistance
-    Pulse =0x2, # section resistance
+    Pulse = 0x2, # section resistance
-    Rigid_A=0x1 | 0x20,
+    Rigid_A = 0x1 | 0x20,
-    Rigid_B=0x1 | 0x04,
+    Rigid_B = 0x1 | 0x04,
-    Rigid_AB=0x1 | 0x20 | 0x04,
+    Rigid_AB = 0x1 | 0x20 | 0x04,
     Pulse_A = 0x2 | 0x20,
     Pulse_B = 0x2 | 0x04,
     Pulse_AB = 0x2 | 0x20 | 0x04,

pydualsense/pydualsense-demo.py

@@ -1,34 +0,0 @@
-from PyQt5 import QtCore, QtGui, QtWidgets 
-import sys 
-from interface import Ui_MainWindow
-from pydualsense import pydualsense
-
-def colorR(value):
-    global colorR
-    colorR = value
-
-def colorG(value):
-    global colorG
-    colorG = value
-
-def colorB(value):
-    global colorB
-    colorB = value
-
-def send():
-    ds.setColor(colorR, colorG, colorB)
-    ds.sendReport()
-if __name__ == "__main__":
-    global ds
-    app = QtWidgets.QApplication(sys.argv)
-    MainWindow = QtWidgets.QMainWindow()
-    ui = Ui_MainWindow()
-    ui.setupUi(MainWindow)
-    ds = pydualsense()
-    # connect interface to  
-    ui.slider_r.valueChanged.connect(colorR)
-    ui.slider_g.valueChanged.connect(colorG)
-    ui.slider_b.valueChanged.connect(colorB)
-    ui.pushButton.clicked.connect(send)
-    MainWindow.show()
-    sys.exit(app.exec_())

pydualsense/pydualsense.py

@@ -1,54 +1,95 @@
+from os import device_encoding
 import hid
 from .enums import (LedOptions, PlayerID,
                    PulseOptions, TriggerModes, Brightness)
 import threading
-
+import sys
+import winreg
 class pydualsense:
 
-    def __init__(self) -> None:
+    def __init__(self, verbose: bool = False) -> None:
         # TODO: maybe add a init function to not automatically allocate controller when class is declared
-        self.device = self.__find_device()
+        self.verbose = verbose
+        self.receive_buffer_size = 64
+        self.send_report_size = 48
+        self.color = (0,0,255) # set color around touchpad to blue
+
+        self.leftMotor = 0
+        self.rightMotor = 0
+
+        
+    def init(self):
+        """initialize module and device
+        """
+        self.device: hid.Device = self.__find_device()
         self.light = DSLight() # control led light of ds
-        self.audio = DSAudio()
+        self.audio = DSAudio() # ds audio setting
-        self.triggerL = DSTrigger()
+        self.triggerL = DSTrigger() # left trigger
-        self.triggerR = DSTrigger()
+        self.triggerR = DSTrigger() # right trigger
 
-        # set default for the controller
+        self.state = DSState() # controller states
-        self.color = (0,0,255) # set dualsense color around the touchpad to blue
 
-        self.send_thread = True
+
+        # thread for receiving and sending
+        self.ds_thread = True
         self.report_thread = threading.Thread(target=self.sendReport)
         self.report_thread.start()
-        # create thread for sending
+
+        self.init = True
 
     def close(self):
-        self.send_thread = False
+        self.ds_thread = False
         self.report_thread.join()
+        self.device.close()
+
+    def _check_hide(self):
+        """check if hidguardian is used and controller is hidden
+        """
+        if sys.platform.startswith('win32'):
+            try:
+                access_reg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
+                access_key = winreg.OpenKey(access_reg, 'SYSTEM\CurrentControlSet\Services\HidGuardian\Parameters', 0, winreg.KEY_READ)
+                affected_devices = winreg.QueryValueEx(access_key, 'AffectedDevices')[0]
+                if "054C" in affected_devices and "0CE6" in affected_devices:
+                    return True
+                return False
+            except OSError as e:
+                print(e)
+        else:
+            # TODO: find something for other platforms. Maybe not even needed on linux
+            return False
+
 
     def __find_device(self):
-        devices = hid.enumerate(vid=0x054c)
-        found_devices = []
-        for device in devices:
-            if device['vendor_id'] == 0x054c and device['product_id'] == 0x0CE6:
-                found_devices.append(device)
-
         # TODO: detect connection mode, bluetooth has a bigger write buffer
         # TODO: implement multiple controllers working
-        if len(found_devices) != 1:
+        if self._check_hide():
-            raise Exception('no dualsense controller detected')
+            raise Exception('HIDGuardian detected. Delete the controller from HIDGuardian and restart PC to connect to controller')
+        detected_device = None
+        devices = hid.enumerate(vid=0x054c)
+        for device in devices:
+            if device['vendor_id'] == 0x054c and device['product_id'] == 0x0CE6:
+                detected_device = device
 
-   
+
-        dual_sense = hid.Device(vid=found_devices[0]['vendor_id'], pid=found_devices[0]['product_id'])
+        if detected_device == None:
+            raise Exception('No device detected')
+
+        dual_sense = hid.Device(vid=detected_device['vendor_id'], pid=detected_device['product_id'])
         return dual_sense
-    
 
-    # color stuff
+    def setLeftMotor(self, intensity: int):
-    def setColor(self, r: int, g:int, b:int):
+        if intensity > 255:
-        if r > 255 or g > 255 or b > 255:
+            raise Exception('maximum intensity is 255')
-            raise Exception('colors have values from 0 to 255 only')
+        self.leftMotor = intensity
-        self.color = (r,g,b)
 
 
+    def setRightMotor(self, intensity: int):
+        if intensity > 255:
+            raise Exception('maximum intensity is 255')
+        self.rightMotor = intensity
+        
+        
     # right trigger
     def setRightTriggerMode(self, mode: TriggerModes):
         """set the trigger mode for R2
@@ -58,6 +99,7 @@ class pydualsense:
         """
         self.triggerR.mode = mode
 
+
     def setRightTriggerForce(self, forceID: int, force: int):
         """set the right trigger force. trigger consist of 7 parameter
 
@@ -72,7 +114,6 @@ class pydualsense:
         self.triggerR.setForce(id=forceID, force=force)
 
 
-    # left trigger
     def setLeftTriggerMode(self, mode: TriggerModes):
         """set the trigger mode for L2
 
@@ -81,6 +122,7 @@ class pydualsense:
         """
         self.triggerL.mode = mode
 
+
     def setLeftTriggerForce(self, forceID: int, force: int):
         """set the left trigger force. trigger consist of 7 parameter
 
@@ -98,79 +140,285 @@ class pydualsense:
     # TODO: audio
     # audio stuff
     def setMicrophoneLED(self, value):
-        self.audio.microphoneLED = 0x1
+        self.audio.microphone_led = value
 
+    # color stuff
+    def setColor(self, r: int, g:int, b:int):
+        """sets the led colour around the touchpad
+
+        :param r: red channel, 0..255
+        :type r: int
+        :param g: green channel, 0..255
+        :type g: int
+        :param b: blue channel, 0..255
+        :type b: int
+        :raises Exception: wron color values
+        """
+        if (r > 255 or g > 255 or b > 255) or (r < 0 or g < 0 or b < 0):
+            raise Exception('colors have values from 0 to 255 only')
+        self.color = (r,g,b)
+
+    def setLEDOption(self, option: LedOptions):
+        """set led option
+
+        :param option: led option
+        :type option: LedOptions
+        """
+        self.light.ledOption = option
+
+    def setPulseOption(self, option: PulseOptions):
+        """set the pulse option for the leds
+
+        :param option: [description]
+        :type option: PulseOptions
+        """
+        self.light.pulseOptions = option
+
+    def setBrightness(self, brightness: Brightness):
+        """set the brightness of the player leds
+
+        :param brightness: brightness for the leds
+        :type brightness: Brightness
+        """
+        self.light.brightness = brightness
+
+    def setPlayerID(self, player : PlayerID):
+        """set the player ID. The controller has 5 white LED which signals
+        which player the controller is
+
+        :param player: the player id from 1 to 5
+        :type player: PlayerID
+        """
+        self.light.playerNumber = player
 
     def sendReport(self):
-        while self.send_thread:
+        """background thread handling the reading of the device and updating its states
-            outReport = [0] * 48 # create empty list with range of output report
+        """
-            # packet type 
+        while self.ds_thread:
-            outReport[0] = 0x2
+
+            # read data from the input report of the controller
+            inReport = self.device.read(self.receive_buffer_size)
+
+            # decrypt the packet and bind the inputs
+            self.readInput(inReport)
 
 
-            # flags determing what changes this packet will perform
+            # prepare new report for device
-            # 0x01 set the main motors (also requires flag 0x02); setting this by itself will allow rumble to gracefully terminate and then re-enable audio haptics, whereas not setting it will kill the rumble instantly and re-enable audio haptics.
+            outReport = self.prepareReport()
-            # 0x02 set the main motors (also requires flag 0x01; without bit 0x01 motors are allowed to time out without re-enabling audio haptics)
-            # 0x04 set the right trigger motor
-            # 0x08 set the left trigger motor
-            # 0x10 modification of audio volume
-            # 0x20 toggling of internal speaker while headset is connected 
-            # 0x40 modification of microphone volume
-            outReport[1] = 0xff # [1]
 
-            # further flags determining what changes this packet will perform
+            # write the report to the device
-            # 0x01 toggling microphone LED
+            self.writeReport(outReport)
-            # 0x02 toggling audio/mic mute
+
-            # 0x04 toggling LED strips on the sides of the touchpad
+    def readInput(self, inReport):
-            # 0x08 will actively turn all LEDs off? Convenience flag? (if so, third parties might not support it properly)
+        """read the reported data from the controller
-            # 0x10 toggling white player indicator LEDs below touchpad
+
-            # 0x20 ???
+        :param inReport: report of the controller
-            # 0x40 adjustment of overall motor/effect power (index 37 - read note on triggers) 
+        :type inReport: bytes
-            # 0x80 ???
+        """
-            outReport[2] = 0x1 | 0x2 | 0x4 | 0x10 | 0x40 # [2]
+        states = list(inReport) # convert bytes to list
-            
+        # states 0 is always 1
-            outReport[3]= 0 # left low freq motor 0-255 # [3]
+        self.state.LX = states[1] - 127
-            outReport[4] = 0 # right low freq motor 0-255 # [4]
+        self.state.LY = states[2] - 127
+        self.state.RX = states[3] - 127
+        self.state.RY = states[4] - 127
+        self.state.L2 = states[5]
+        self.state.R2 = states[6]
+
+        # state 7 always increments -> not used anywhere
+
+        buttonState = states[8]
+        self.state.triangle = (buttonState & (1 << 7)) != 0
+        self.state.circle = (buttonState & (1 << 6)) != 0
+        self.state.cross = (buttonState & (1 << 5)) != 0
+        self.state.square = (buttonState & (1 << 4)) != 0
 
 
-            # outReport[5] - outReport[8] audio related
+        # dpad
-            
+        dpad_state = buttonState & 0x0F
+        self.state.setDPadState(dpad_state)
 
-            # set Micrphone LED, setting doesnt effect microphone settings
+        misc = states[9]
-            outReport[9] = self.audio.microphone_led # [9]
+        self.state.R3 = (misc & (1 << 7)) != 0
+        self.state.L3 = (misc & (1 << 6)) != 0
+        self.state.options = (misc & (1 << 5)) != 0
+        self.state.share = (misc & (1 << 4)) != 0
+        self.state.R2Btn = (misc & (1 << 3)) != 0
+        self.state.L2Btn = (misc & (1 << 2)) != 0
+        self.state.R1 = (misc & (1 << 1)) != 0
+        self.state.L1 = (misc & (1 << 0)) != 0
 
-            # set microphone muting
+        misc2 = states[10]
-            
+        self.state.ps = (misc2 & (1 << 0)) != 0
+        self.state.touchBtn = (misc2 & 0x02) != 0
 
 
-            # add right trigger mode + parameters to packet
+        # trackpad touch
-            outReport[11] = self.triggerR.mode.value
+        self.state.trackPadTouch0.ID = inReport[33] & 0x7F
-            outReport[12] = self.triggerR.forces[0]
+        self.state.trackPadTouch0.isActive = (inReport[33] & 0x80) == 0
-            outReport[13] = self.triggerR.forces[1]
+        self.state.trackPadTouch0.X = ((inReport[35] & 0x0f) << 8) | (inReport[34])
-            outReport[14] = self.triggerR.forces[2]
+        self.state.trackPadTouch0.Y = ((inReport[36]) << 4) | ((inReport[35] & 0xf0) >> 4)
-            outReport[15] = self.triggerR.forces[3]
-            outReport[16] = self.triggerR.forces[4]
-            outReport[17] = self.triggerR.forces[5]
-            outReport[20] = self.triggerR.forces[6]
 
-            outReport[22] = self.triggerL.mode.value
+        # trackpad touch
-            outReport[23] = self.triggerL.forces[0]
+        self.state.trackPadTouch1.ID = inReport[37] & 0x7F
-            outReport[24] = self.triggerL.forces[1]
+        self.state.trackPadTouch1.isActive = (inReport[37] & 0x80) == 0
-            outReport[25] = self.triggerL.forces[2]
+        self.state.trackPadTouch1.X = ((inReport[39] & 0x0f) << 8) | (inReport[38])
-            outReport[26] = self.triggerL.forces[3]
+        self.state.trackPadTouch1.Y = ((inReport[40]) << 4) | ((inReport[39] & 0xf0) >> 4)
-            outReport[27] = self.triggerL.forces[4]
-            outReport[28] = self.triggerL.forces[5]
-            outReport[31] = self.triggerL.forces[6]
 
-            outReport[39] = self.light.ledOption.value
+       # print(f'1Active = {self.state.trackPadTouch0.isActive}')
-            outReport[42] = self.light.pulseOptions.value
+       # print(f'X1: {self.state.trackPadTouch0.X} Y2: {self.state.trackPadTouch0.Y}')
-            outReport[43] = self.light.brightness.value
-            outReport[44] = self.light.playerNumber.value
-            outReport[45] = self.color[0]
-            outReport[46] = self.color[1]
-            outReport[47] = self.color[2]
-            self.device.write(bytes(outReport)) # send to controller
 
+       # print(f'2Active = {self.state.trackPadTouch1.isActive}')
+       # print(f'X2: {self.state.trackPadTouch1.X} Y2: {self.state.trackPadTouch1.Y}')
+       # print(f'DPAD {self.state.DpadLeft} {self.state.DpadUp} {self.state.DpadRight} {self.state.DpadDown}')
+
+        # TODO: implement gyrometer and accelerometer
+        # TODO: control mouse with touchpad for fun as DS4Windows
+
+
+    def writeReport(self, outReport):
+        """Write the given report to the device
+
+        :param outReport: report with data for the controller
+        :type outReport: list
+        """
+        self.device.write(bytes(outReport))
+
+
+    def prepareReport(self):
+        """prepare the report for the controller with all the settings set since the previous update
+
+        :return: report for the controller with all infos
+        :rtype: list
+        """
+        outReport = [0] * 48 # create empty list with range of output report
+        # packet type
+        outReport[0] = 0x2
+
+
+        # flags determing what changes this packet will perform
+        # 0x01 set the main motors (also requires flag 0x02); setting this by itself will allow rumble to gracefully terminate and then re-enable audio haptics, whereas not setting it will kill the rumble instantly and re-enable audio haptics.
+        # 0x02 set the main motors (also requires flag 0x01; without bit 0x01 motors are allowed to time out without re-enabling audio haptics)
+        # 0x04 set the right trigger motor
+        # 0x08 set the left trigger motor
+        # 0x10 modification of audio volume
+        # 0x20 toggling of internal speaker while headset is connected
+        # 0x40 modification of microphone volume
+        outReport[1] = 0xff # [1]
+
+        # further flags determining what changes this packet will perform
+        # 0x01 toggling microphone LED
+        # 0x02 toggling audio/mic mute
+        # 0x04 toggling LED strips on the sides of the touchpad
+        # 0x08 will actively turn all LEDs off? Convenience flag? (if so, third parties might not support it properly)
+        # 0x10 toggling white player indicator LEDs below touchpad
+        # 0x20 ???
+        # 0x40 adjustment of overall motor/effect power (index 37 - read note on triggers)
+        # 0x80 ???
+        outReport[2] = 0x1 | 0x2 | 0x4 | 0x10 | 0x40 # [2]
+
+        outReport[3] = self.leftMotor # left low freq motor 0-255 # [3]
+        outReport[4] = self.rightMotor # right low freq motor 0-255 # [4]
+
+        # outReport[5] - outReport[8] audio related
+
+        # set Micrphone LED, setting doesnt effect microphone settings
+        outReport[9] = self.audio.microphone_led # [9]
+
+        # add right trigger mode + parameters to packet
+        outReport[11] = self.triggerR.mode.value
+        outReport[12] = self.triggerR.forces[0]
+        outReport[13] = self.triggerR.forces[1]
+        outReport[14] = self.triggerR.forces[2]
+        outReport[15] = self.triggerR.forces[3]
+        outReport[16] = self.triggerR.forces[4]
+        outReport[17] = self.triggerR.forces[5]
+        outReport[20] = self.triggerR.forces[6]
+
+        outReport[22] = self.triggerL.mode.value
+        outReport[23] = self.triggerL.forces[0]
+        outReport[24] = self.triggerL.forces[1]
+        outReport[25] = self.triggerL.forces[2]
+        outReport[26] = self.triggerL.forces[3]
+        outReport[27] = self.triggerL.forces[4]
+        outReport[28] = self.triggerL.forces[5]
+        outReport[31] = self.triggerL.forces[6]
+
+        outReport[39] = self.light.ledOption.value
+        outReport[42] = self.light.pulseOptions.value
+        outReport[43] = self.light.brightness.value
+        outReport[44] = self.light.playerNumber.value
+        outReport[45] = self.color[0]
+        outReport[46] = self.color[1]
+        outReport[47] = self.color[2]
+        if self.verbose:
+            print(outReport)
+        return outReport
+
+class DSTouchpad:
+    def __init__(self) -> None:
+        self.isActive = False
+        self.ID = 0
+        self.X = 0
+        self.Y = 0
+
+class DSState:
+
+    def __init__(self) -> None:
+        self.packerC = 0
+        self.square, self.triangle, self.circle, self.cross = False, False, False, False
+        self.DpadUp, self.DpadDown, self.DpadLeft, self.DpadRight = False, False, False, False
+        self.L1, self.L2, self.L3, self.R1, self.R2, self.R3, self.R2Btn, self.L2Btn = False, False, False, False, False, False, False, False
+        self.share, self.options, self.ps, self.touch1, self.touch2, self.touchBtn, self.touchRight, self.touchLeft = False, False, False, False, False, False, False, False
+        self.touchFinger1, self.touchFinger2 = False, False
+        self.RX, self.RY, self.LX, self.LY = 128,128,128,128
+        self.trackPadTouch0, self.trackPadTouch1 = DSTouchpad(), DSTouchpad()
+
+    def setDPadState(self, dpad_state):
+        if dpad_state == 0:
+            self.DpadUp = True
+            self.DpadDown = False
+            self.DpadLeft = False
+            self.DpadRight = False
+        elif dpad_state == 1:
+            self.DpadUp = True
+            self.DpadDown = False
+            self.DpadLeft = False
+            self.DpadRight = True
+        elif dpad_state == 2:
+            self.DpadUp = False
+            self.DpadDown = False
+            self.DpadLeft = False
+            self.DpadRight = True
+        elif dpad_state == 3:
+            self.DpadUp = False
+            self.DpadDown = True
+            self.DpadLeft = False
+            self.DpadRight = True
+        elif dpad_state == 4:
+            self.DpadUp = False
+            self.DpadDown = True
+            self.DpadLeft = False
+            self.DpadRight = False
+        elif dpad_state == 5:
+            self.DpadUp = False
+            self.DpadDown = True
+            self.DpadLeft = False
+            self.DpadRight = False
+        elif dpad_state == 6:
+            self.DpadUp = False
+            self.DpadDown = False
+            self.DpadLeft = True
+            self.DpadRight = False
+        elif dpad_state == 7:
+            self.DpadUp = True
+            self.DpadDown = False
+            self.DpadLeft = True
+            self.DpadRight = False
+        else:
+            self.DpadUp = False
+            self.DpadDown = False
+            self.DpadLeft = False
+            self.DpadRight = False
 
 
 class DSLight:
@@ -179,7 +427,7 @@ class DSLight:
         make it simple, no get or set functions. quick and dirty
     """
     def __init__(self) -> None:
-        self.brightness: Brightness = Brightness.low # sets 
+        self.brightness: Brightness = Brightness.low # sets
         self.playerNumber: PlayerID = PlayerID.player1
         self.ledOption : LedOptions = LedOptions.Both
         self.pulseOptions : PulseOptions = PulseOptions.Off
@@ -187,11 +435,7 @@ class DSLight:
     def setBrightness(self, brightness: Brightness):
         self._brightness = brightness
 
-    def setPlayerNumer(self, player):
-        if player > 5:
-            raise Exception('only 5 players supported. choose 1-5')
 
-        
 
 class DSAudio:
     def __init__(self) -> None:
@@ -239,17 +483,3 @@ class DSTrigger:
         packet += [0,0] # unknown what these do ?
         packet.append(self.forces[-1]) # last force has a offset of 2 from the other forces. this is the frequency of the actuation
         return packet
-    
-if __name__ == "__main__":
-    ds = pydualsense()
-    import time
-  #  ds.triggerR.setMode(TriggerModes.Rigid)
- #   ds.triggerR.setForce(0, 255)
-    ds.setLeftTriggerMode(TriggerModes.Pulse)
-    ds.setLeftTriggerForce(1, 255)
-    ds.setRightTriggerMode(TriggerModes.Rigid)
-    ds.setRightTriggerForce(1, 255)
-#    ds.triggerL.setForce(6,255)
-    ds.sendReport()
-    time.sleep(2)
-    time.sleep(3)

setup.py

@@ -6,12 +6,12 @@ with open("README.md", "r") as fh:
 
 setup(
     name='pydualsense',
-    version='0.0.4',    
+    version='0.3.0',
-    description='control your DualSense (PS5) controller with python',
+    description='use your DualSense (PS5) controller with python',
     long_description=long_description,
     long_description_content_type="text/markdown",
     url='https://github.com/flok/pydualsense',
-    author='Florian Kaiser',
+    author='Florian K',
     license='MIT License',
     packages=setuptools.find_packages(),
     install_requires=['hid>=1.0.4']