### Install PyDualSense using pip

Source: https://github.com/flok/pydualsense/blob/master/docs/source/usage.rst

Installs the pydualsense library and its dependencies using pip. Ensure you are in your virtual environment before running this command.

```console
(.venv) $ pip install --upgrade pydualsense
```

--------------------------------

### Apply DualSense Controller Trigger and Rumble Effects in Python

Source: https://github.com/flok/pydualsense/blob/master/docs/source/examples.rst

Shows how to apply various effects to the DualSense controller, including rumble motors and adaptive triggers, using the pydualsense library. It initializes the controller, sets rumble motor intensity, configures trigger modes (Rigid, Pulse_A), and sets trigger force levels. The example runs until the R1 button is pressed. Dependencies: pydualsense.

```python
from pydualsense import *

# get dualsense instance
dualsense = pydualsense()
# initialize controller and connect
dualsense.init()

print('Trigger Effect demo started')

# set left and right rumble motors
dualsense.setLeftMotor(255)
dualsense.setRightMotor(100)

# set left l2 trigger to Rigid and set index 1 to force 255
dualsense.triggerL.setMode(TriggerModes.Rigid)
dualsense.triggerL.setForce(1, 255)

# set left r2 trigger to Rigid
dualsense.triggerR.setMode(TriggerModes.Pulse_A)
dualsense.triggerR.setForce(0, 200)
dualsense.triggerR.setForce(1, 255)
dualsense.triggerR.setForce(2, 175)

# loop until r1 is pressed to feel effect
while not dualsense.state.R1:
    ...

# terminate the thread for message and close the device
dualsense.close()
```

--------------------------------

### Install pydualsense on Windows

Source: https://github.com/flok/pydualsense/blob/master/README.md

Installs the pydualsense package and its dependencies on Windows. Requires downloading hidapi and placing the x64 .dll file in the workspace before installation.

```bash
pip install --upgrade pydualsense
```

--------------------------------

### Handle DualSense Controller Input Events in Python

Source: https://github.com/flok/pydualsense/blob/master/docs/source/examples.rst

Demonstrates how to set up event handlers for DualSense controller inputs like button presses and joystick movements using the pydualsense library. It initializes the controller, registers callback functions for various events, and reads the controller state until the R1 button is pressed. Dependencies: pydualsense.

```python
from pydualsense import *

def cross_down(state):
    print(f'cross {state}')


def circle_down(state):
    print(f'circle {state}')


def dpad_down(state):
    print(f'dpad down {state}')


def joystick(stateX, stateY):
    print(f'joystick {stateX} {stateY}')


def gyro_changed(pitch, yaw, roll):
    print(f'{pitch}, {yaw}, {roll}')

# create dualsense
dualsense = pydualsense()
# find device and initialize
dualsense.init()

# add events handler functions
dualsense.cross_pressed += cross_down
dualsense.circle_pressed += circle_down
dualsense.dpad_down += dpad_down
dualsense.left_joystick_changed += joystick
dualsense.gyro_changed += gyro_changed

# read controller state until R1 is pressed
while not dualsense.state.R1:
    ...

# close device
dualsense.close()
```

--------------------------------

### Install hidapi development files on Ubuntu

Source: https://github.com/flok/pydualsense/blob/master/docs/source/usage.rst

Installs the necessary hidapi development files on Ubuntu systems using apt. This is a prerequisite for using pydualsense on Linux-based systems.

```console
sudo apt install libhidapi-dev
```

--------------------------------

### DualSense Controller Initialization and Haptic Feedback Example (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

Initializes the DualSense controller, sets up LED feedback, configures adaptive triggers for accelerator and brake, and registers event handlers for trigger values. It then enters a loop to read steering input and demonstrates setting motor vibrations based on trigger values. Includes comprehensive error handling and controller cleanup.

```python
from pydualsense import pydualsense, TriggerModes, PlayerID
import time

def main():
    # Initialize controller
    ds = pydualsense(verbose=False)

    try:
        ds.init()
        print("Controller connected!")

        # Setup visual feedback
        ds.light.setColorI(0, 255, 0)  # Green = ready
        ds.light.setPlayerID(PlayerID.PLAYER_1)

        # Configure triggers for racing game feel
        ds.triggerR.setMode(TriggerModes.Rigid)  # Accelerator
        ds.triggerR.setForce(1, 150)
        ds.triggerL.setMode(TriggerModes.Rigid)  # Brake
        ds.triggerL.setForce(1, 200)

        # Register button handlers
        def on_accelerate(value):
            if value > 200:  # High acceleration
                ds.setRightMotor(value)
                ds.light.setColorI(255, 0, 0)  # Red at high speed
            elif value > 100:
                ds.setRightMotor(value // 2)
                ds.light.setColorI(255, 165, 0)  # Orange at medium speed
            else:
                ds.setRightMotor(0)
                ds.light.setColorI(0, 255, 0)  # Green at low speed

        def on_brake(value):
            if value > 200:
                ds.setLeftMotor(value)

        ds.r2_value_changed += on_accelerate
        ds.l2_value_changed += on_brake

        # Game loop
        print("Drive the car! Press OPTIONS to exit.")
        while not ds.state.options:
            # Read steering from left joystick
            steering = ds.state.LX  # -128 to 127

            # Could send steering data to game engine here
            time.sleep(0.01)

    except Exception as e:
        print(f"Error: {e}")

    finally:
        # Cleanup
        ds.setLeftMotor(0)
        ds.setRightMotor(0)
        ds.triggerL.setMode(TriggerModes.Off)
        ds.triggerR.setMode(TriggerModes.Off)
        ds.light.setColorI(0, 0, 255)  # Blue = finished
        time.sleep(0.5)
        ds.close()
        print("Controller disconnected")

if __name__ == "__main__":
    main()

```

--------------------------------

### Read DualSense Accelerometer and Gyroscope (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

Reads accelerometer and gyroscope data from the DualSense controller, either by direct access or by registering callback functions for changes. The example reads data for 10 seconds. Requires `pydualsense` and `time`.

```python
from pydualsense import pydualsense
import time

def on_accelerometer_change(x, y, z):
    print(f"Accelerometer - X: {x}, Y: {y}, Z: {z}")

def on_gyro_change(pitch, yaw, roll):
    print(f"Gyroscope - Pitch: {pitch}, Yaw: {yaw}, Roll: {roll}")

ds = pydualsense()
ds.init()

# Register sensor event handlers
ds.accelerometer_changed += on_accelerometer_change
ds.gyro_changed += on_gyro_change

# Or access sensor data directly
start_time = time.time()
while time.time() - start_time < 10:
    accel = ds.state.accelerometer
    gyro = ds.state.gyro

    print(f"Accel: ({accel.X}, {accel.Y}, {accel.Z})")
    print(f"Gyro: Pitch={gyro.Pitch}, Yaw={gyro.Yaw}, Roll={gyro.Roll}")

    time.sleep(0.1)

ds.close()
```

--------------------------------

### Implement DualSense Adaptive Trigger Effects (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

This Python code demonstrates how to configure adaptive trigger effects on the DualSense controller. The example focuses on setting the left trigger to a 'Rigid' mode and then defining force parameters for resistance. It requires the pydualsense library and the `time` module. Note that this snippet is incomplete as it only configures the left trigger.

```Python
from pydualsense import pydualsense, TriggerModes
import time

ds = pydualsense()
ds.init()

# Configure left trigger with rigid resistance
ds.triggerL.setMode(TriggerModes.Rigid)
ds.triggerL.setForce(0, 200)  # Set force parameter 0 to 200
ds.triggerL.setForce(1, 255)  # Set force parameter 1 to 255


```

--------------------------------

### Control DualSense Motor Rumble (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

This Python snippet shows how to control the motor rumble (haptic feedback) of the DualSense controller. It demonstrates setting the intensity for the left and right motors independently, pausing to experience the effect, and then stopping the rumble. It also includes an example of simulating an explosion effect with varying intensities. It requires the pydualsense library and the `time` module.

```Python
from pydualsense import pydualsense
import time

ds = pydualsense()
ds.init()

# Set motor intensities (0-255)
# Left motor: low frequency rumble
# Right motor: high frequency rumble
ds.setLeftMotor(255)   # Maximum left motor intensity
ds.setRightMotor(128)  # Medium right motor intensity

# Wait to feel the effect
time.sleep(2)

# Stop rumble
ds.setLeftMotor(0)
ds.setRightMotor(0)

# Example: Simulating an explosion effect
ds.setLeftMotor(255)
ds.setRightMotor(255)
time.sleep(0.3)
ds.setLeftMotor(128)
ds.setRightMotor(128)
time.sleep(0.2)
ds.setLeftMotor(0)
ds.setRightMotor(0)

ds.close()
```

--------------------------------

### Initialize pydualsense Controller

Source: https://github.com/flok/pydualsense/blob/master/docs/source/ds_main.rst

Initializes the pydualsense controller instance and establishes a connection. This is the first step to interacting with the DualSense controller using the library.

```python
from pydualsense import pydualsense

# Create controller instance
ds = pydualsense()

# Initialize connection
ds.init()
```

--------------------------------

### Initialize and Connect DualSense Controller (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

This snippet demonstrates how to initialize the pydualsense library, establish a connection with the DualSense controller (automatically detecting USB or Bluetooth), check the connection status, and close the connection. It requires the pydualsense library.

```Python
from pydualsense import pydualsense

# Create controller instance with optional verbose logging
ds = pydualsense(verbose=False)

# Initialize connection (automatically detects USB or Bluetooth)
ds.init()

# Check connection status
if ds.connected:
    print("Controller connected successfully")
    # Connection type available as ds.conType (ConnectionType.USB or ConnectionType.BT)
else:
    print("Failed to connect")

# Close connection when done
ds.close()
```

--------------------------------

### Basic pydualsense controller usage

Source: https://github.com/flok/pydualsense/blob/master/README.md

Demonstrates fundamental usage of the pydualsense library. It initializes the controller, sets up an event handler for the 'cross' button press, configures the touchpad color and left trigger mode, and finally closes the controller connection.

```python
from pydualsense import pydualsense, TriggerModes

def cross_pressed(state):
    print(state)

ds = pydualsense() # open controller
ds.init() # initialize controller

ds.cross_pressed += cross_pressed
ds.light.setColorI(255,0,0) # set touchpad color to red
ds.triggerL.setMode(TriggerModes.Rigid)
ds.triggerL.setForce(1, 255)
ds.close() # closing the controller
```

--------------------------------

### Control DualSense LED Lighting (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

This Python code demonstrates how to control the LED lighting on a DualSense controller. It covers setting the touchpad color using RGB values or tuples, configuring player indicator LEDs, adjusting brightness, setting LED options, and applying pulse effects. It requires the pydualsense library and imports specific enums for control.

```Python
from pydualsense import pydualsense, PlayerID, LedOptions, Brightness, PulseOptions

ds = pydualsense()
ds.init()

# Set touchpad color using RGB values (0-255)
ds.light.setColorI(255, 0, 0)  # Red
ds.light.setColorI(0, 255, 0)  # Green
ds.light.setColorI(0, 0, 255)  # Blue

# Set color using tuple
ds.light.setColorT((128, 64, 200))

# Set player indicator LEDs
ds.light.setPlayerID(PlayerID.PLAYER_1)  # Shows player 1 indicator
ds.light.setPlayerID(PlayerID.PLAYER_2)  # Shows player 2 indicator
ds.light.setPlayerID(PlayerID.ALL)       # All LEDs on

# Set LED brightness
ds.light.setBrightness(Brightness.high)
ds.light.setBrightness(Brightness.medium)
ds.light.setBrightness(Brightness.low)

# Configure LED options
ds.light.setLEDOption(LedOptions.Both)  # Player LEDs and touchpad
ds.light.setLEDOption(LedOptions.PlayerLedBrightness)  # Only player LEDs

# Set pulse effects
ds.light.setPulseOption(PulseOptions.FadeBlue)  # Fade blue effect
ds.light.setPulseOption(PulseOptions.FadeOut)   # Fade out effect
ds.light.setPulseOption(PulseOptions.Off)       # No pulse effect

ds.close()
```

--------------------------------

### Configure udev rules for DualSense on Linux

Source: https://github.com/flok/pydualsense/blob/master/README.md

Sets up udev rules to allow non-root user access to the PS5 controller on Linux systems. This involves copying a rule file and reloading udev configurations.

```bash
sudo cp 70-ps5-controller.rules /etc/udev/rules.d
sudo udevadm control --reload-rules
sudo udevadm trigger
```

--------------------------------

### Read pydualsense Controller States

Source: https://github.com/flok/pydualsense/blob/master/docs/source/ds_main.rst

Demonstrates how to read various states from the DualSense controller, including button presses, analog trigger values, and motion sensor data. This allows for real-time monitoring of controller inputs.

```python
from pydualsense import pydualsense

# Initialize controller
ds = pydualsense()
ds.init()

# Read button states
if ds.state.circle:
    print("Circle button is pressed")

# Read trigger analog values
print(f"L2 value: {ds.state.L2_value}")
print(f"R2 value: {ds.state.R2_value}")

# Read motion data
print(f"Gyro: P={ds.state.gyro.Pitch}, Y={ds.state.gyro.Yaw}, R={ds.state.gyro.Roll}")
print(f"Accel: X={ds.state.accelerometer.X}, Y={ds.state.accelerometer.Y}, Z={ds.state.accelerometer.Z}")
```

--------------------------------

### Control DualSense Microphone LED (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

Demonstrates how to control the microphone's LED status on the DualSense controller. It includes functions to turn the LED on/off and set the microphone's mute state, which also affects the LED. Requires `pydualsense`.

```python
from pydualsense import pydualsense

ds = pydualsense()
ds.init()

# Turn on microphone LED (doesn't mute microphone)
ds.audio.setMicrophoneLED(True)

# Turn off microphone LED
ds.audio.setMicrophoneLED(False)

# Set microphone state (mutes microphone and sets LED)
ds.audio.setMicrophoneState(True)   # Mute microphone and turn on LED
ds.audio.setMicrophoneState(False)  # Unmute microphone and turn off LED

ds.close()
```

--------------------------------

### Read DualSense Input States and Events (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

This Python code shows how to read button states, joystick movements, and sensor data from a DualSense controller. It includes setting up event handlers for specific inputs (e.g., button presses, joystick movements) and an alternative method to poll the controller state directly within a loop. It requires the pydualsense library.

```Python
from pydualsense import pydualsense

def on_cross_pressed(state):
    if state:
        print("Cross button pressed")
    else:
        print("Cross button released")

def on_joystick_moved(x, y):
    print(f"Left joystick: X={x}, Y={y} (range: -128 to 127)")

def on_gyro_changed(pitch, yaw, roll):
    print(f"Gyro - Pitch: {pitch}, Yaw: {yaw}, Roll: {roll}")

# Initialize controller
ds = pydualsense()
ds.init()

# Register event handlers
ds.cross_pressed += on_cross_pressed
ds.circle_pressed += lambda state: print(f"Circle: {state}")
ds.triangle_pressed += lambda state: print(f"Triangle: {state}")
ds.square_pressed += lambda state: print(f"Square: {state}")
ds.left_joystick_changed += on_joystick_moved
ds.gyro_changed += on_gyro_changed

# Poll controller state directly (alternative to events)
while not ds.state.R1:
    # Access button states
    if ds.state.cross:
        print("Cross is currently pressed")

    # Access analog trigger values (0-255)
    if ds.state.L2_value > 128:
        print(f"L2 pressure: {ds.state.L2_value}")

    # Access joystick positions
    print(f"Right stick: X={ds.state.RX}, Y={ds.state.RY}")

ds.close()
```

--------------------------------

### Handle pydualsense Controller Events

Source: https://github.com/flok/pydualsense/blob/master/docs/source/ds_main.rst

Shows how to set up event handlers for various DualSense controller inputs, such as button presses, trigger value changes, and motion data updates. This enables reactive programming based on controller input.

```python
# Monitor button presses
def on_circle_pressed(state):
    print(f"Circle button {'pressed' if state else 'released'}")

ds.circle_pressed += on_circle_pressed

# Monitor trigger analog values
def on_l2_value_changed(value):
    print(f"L2 trigger value: {value}")

ds.l2_value_changed += on_l2_value_changed

# Monitor motion data
def on_gyro_changed(pitch, yaw, roll):
    print(f"Gyro: P={pitch}, Y={yaw}, R={roll}")

ds.gyro_changed += on_gyro_changed
```

--------------------------------

### Read DualSense Touchpad Input (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

Reads input from the DualSense controller's touchpad, including touch points and click events. The loop continues until the R1 button is pressed. Dependencies: `pydualsense`.

```python
from pydualsense import pydualsense

ds = pydualsense()
ds.init()

while not ds.state.R1:
    # First touch point
    touch0 = ds.state.trackPadTouch0
    if touch0.isActive:
        print(f"Touch 0 - ID: {touch0.ID}, X: {touch0.X}, Y: {touch0.Y}")

    # Second touch point (for two-finger gestures)
    touch1 = ds.state.trackPadTouch1
    if touch1.isActive:
        print(f"Touch 1 - ID: {touch1.ID}, X: {touch1.X}, Y: {touch1.Y}")

    # Touchpad button press
    if ds.state.touchBtn:
        print("Touchpad clicked")

ds.close()
```

--------------------------------

### Configure DualSense Right Trigger Resistance (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

Configures the right trigger of the DualSense controller with pulsing or rigid resistance effects. It utilizes `setMode` and `setForce` methods. Dependencies include `pydualsense` and `time`.

```python
from pydualsense import pydualsense
from pydualsense.enums import TriggerModes
import time

ds = pydualsense()
ds.init()

# Configure right trigger with pulsing resistance
ds.triggerR.setMode(TriggerModes.Pulse_A)
ds.triggerR.setForce(0, 200)
ds.triggerR.setForce(1, 255)
ds.triggerR.setForce(2, 175)

# Available trigger modes:
# - TriggerModes.Off: No resistance
# - TriggerModes.Rigid: Continuous resistance
# - TriggerModes.Pulse: Section-based resistance
# - TriggerModes.Rigid_A, Rigid_B, Rigid_AB: Rigid variants
# - TriggerModes.Pulse_A, Pulse_B, Pulse_AB: Pulse variants

# Simulating gun trigger effect
ds.triggerR.setMode(TriggerModes.Rigid)
ds.triggerR.setForce(0, 0)
ds.triggerR.setForce(1, 100)  # Light resistance at start
ds.triggerR.setForce(2, 255)  # Heavy resistance at end

time.sleep(5)  # Feel the trigger effect

# Reset triggers
ds.triggerL.setMode(TriggerModes.Off)
ds.triggerR.setMode(TriggerModes.Off)

ds.close()
```

--------------------------------

### Monitor DualSense Battery Status (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

Monitors the battery level and charging status of the DualSense controller. It demonstrates reading the battery information and includes a loop that flashes the controller's light red when the battery is below 20%. Requires `pydualsense`, `pydualsense.enums`, and `time`.

```python
from pydualsense import pydualsense
from pydualsense.enums import BatteryState
import time

ds = pydualsense()
ds.init()

# Read battery information
battery = ds.battery

print(f"Battery Level: {battery.Level}%")

if battery.State == BatteryState.POWER_SUPPLY_STATUS_CHARGING:
    print("Status: Charging")
elif battery.State == BatteryState.POWER_SUPPLY_STATUS_DISCHARGING:
    print("Status: Discharging")
elif battery.State == BatteryState.POWER_SUPPLY_STATUS_FULL:
    print("Status: Fully Charged")
elif battery.State == BatteryState.POWER_SUPPLY_STATUS_NOT_CHARGING:
    print("Status: Not Charging")

# Monitor battery continuously
while not ds.state.ps:
    level = ds.battery.Level
    state = ds.battery.State

    if level < 20:
        # Flash red LED when battery is low
        ds.light.setColorI(255, 0, 0)

    print(f"Battery: {level}% - State: {state}", end='\r')
    time.sleep(1)

ds.close()
```

--------------------------------

### PyDualSense Module

Source: https://github.com/flok/pydualsense/blob/master/docs/source/ds_main.rst

This section covers the pydualsense.pydualsense module, including its members, undocumented members, and inheritance. It highlights the handling of type errors for incorrect parameter types.

```APIDOC
## PyDualSense Module

### Description
This automodule directive documents the `pydualsense.pydualsense` module. It lists all public members, including those without docstrings, and shows the inheritance hierarchy. A key aspect of this module is its handling of type errors when incorrect parameter types are provided.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (N/A)
N/A

#### Response Example
N/A
```

--------------------------------

### Handle DualSense Edge Extra Buttons (Python)

Source: https://context7.com/flok/pydualsense/llms.txt

Detects if the controller is a DualSense Edge and registers event handlers for the extra paddle buttons (L4, L5, R4, R5). It also shows how to access their states directly within a loop. Requires `pydualsense`.

```python
from pydualsense import pydualsense

ds = pydualsense()
ds.init()

# Check if controller is DualSense Edge
if ds.is_edge:
    print("DualSense Edge detected")

    # Register handlers for extra buttons (L4, L5, R4, R5)
    ds.l4_changed += lambda state: print(f"L4: {state}")
    ds.l5_changed += lambda state: print(f"L5: {state}")
    ds.r4_changed += lambda state: print(f"R4: {state}")
    ds.r5_changed += lambda state: print(f"R5: {state}")

    while not ds.state.ps:
        # Access Edge button states directly
        if ds.state.L4:
            print("L4 paddle pressed")
        if ds.state.R5:
            print("R5 paddle pressed")
else:
    print("Standard DualSense controller")
    # Edge button states are None on standard controllers

ds.close()
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.