| #!/bin/env python3 |
| # SPDX-License-Identifier: GPL-2.0 |
| # -*- coding: utf-8 -*- |
| # |
| # Copyright (c) 2020 Benjamin Tissoires <benjamin.tissoires@gmail.com> |
| # Copyright (c) 2020 Red Hat, Inc. |
| # |
| |
| from .base import application_matches |
| from .test_gamepad import BaseTest |
| from hidtools.device.sony_gamepad import ( |
| PS3Controller, |
| PS4ControllerBluetooth, |
| PS4ControllerUSB, |
| PS5ControllerBluetooth, |
| PS5ControllerUSB, |
| PSTouchPoint, |
| ) |
| from hidtools.util import BusType |
| |
| import libevdev |
| import logging |
| import pytest |
| |
| logger = logging.getLogger("hidtools.test.sony") |
| |
| PS3_MODULE = ("sony", "hid_sony") |
| PS4_MODULE = ("playstation", "hid_playstation") |
| PS5_MODULE = ("playstation", "hid_playstation") |
| |
| |
| class SonyBaseTest: |
| class SonyTest(BaseTest.TestGamepad): |
| pass |
| |
| class SonyPS4ControllerTest(SonyTest): |
| kernel_modules = [PS4_MODULE] |
| |
| def test_accelerometer(self): |
| uhdev = self.uhdev |
| evdev = uhdev.get_evdev("Accelerometer") |
| |
| for x in range(-32000, 32000, 4000): |
| r = uhdev.event(accel=(x, None, None)) |
| events = uhdev.next_sync_events("Accelerometer") |
| self.debug_reports(r, uhdev, events) |
| |
| assert libevdev.InputEvent(libevdev.EV_ABS.ABS_X) in events |
| value = evdev.value[libevdev.EV_ABS.ABS_X] |
| # Check against range due to small loss in precision due |
| # to inverse calibration, followed by calibration by hid-sony. |
| assert x - 1 <= value <= x + 1 |
| |
| for y in range(-32000, 32000, 4000): |
| r = uhdev.event(accel=(None, y, None)) |
| events = uhdev.next_sync_events("Accelerometer") |
| self.debug_reports(r, uhdev, events) |
| |
| assert libevdev.InputEvent(libevdev.EV_ABS.ABS_Y) in events |
| value = evdev.value[libevdev.EV_ABS.ABS_Y] |
| assert y - 1 <= value <= y + 1 |
| |
| for z in range(-32000, 32000, 4000): |
| r = uhdev.event(accel=(None, None, z)) |
| events = uhdev.next_sync_events("Accelerometer") |
| self.debug_reports(r, uhdev, events) |
| |
| assert libevdev.InputEvent(libevdev.EV_ABS.ABS_Z) in events |
| value = evdev.value[libevdev.EV_ABS.ABS_Z] |
| assert z - 1 <= value <= z + 1 |
| |
| def test_gyroscope(self): |
| uhdev = self.uhdev |
| evdev = uhdev.get_evdev("Accelerometer") |
| |
| for rx in range(-2000000, 2000000, 200000): |
| r = uhdev.event(gyro=(rx, None, None)) |
| events = uhdev.next_sync_events("Accelerometer") |
| self.debug_reports(r, uhdev, events) |
| |
| assert libevdev.InputEvent(libevdev.EV_ABS.ABS_RX) in events |
| value = evdev.value[libevdev.EV_ABS.ABS_RX] |
| # Sensor internal value is 16-bit, but calibrated is 22-bit, so |
| # 6-bit (64) difference, so allow a range of +/- 64. |
| assert rx - 64 <= value <= rx + 64 |
| |
| for ry in range(-2000000, 2000000, 200000): |
| r = uhdev.event(gyro=(None, ry, None)) |
| events = uhdev.next_sync_events("Accelerometer") |
| self.debug_reports(r, uhdev, events) |
| |
| assert libevdev.InputEvent(libevdev.EV_ABS.ABS_RY) in events |
| value = evdev.value[libevdev.EV_ABS.ABS_RY] |
| assert ry - 64 <= value <= ry + 64 |
| |
| for rz in range(-2000000, 2000000, 200000): |
| r = uhdev.event(gyro=(None, None, rz)) |
| events = uhdev.next_sync_events("Accelerometer") |
| self.debug_reports(r, uhdev, events) |
| |
| assert libevdev.InputEvent(libevdev.EV_ABS.ABS_RZ) in events |
| value = evdev.value[libevdev.EV_ABS.ABS_RZ] |
| assert rz - 64 <= value <= rz + 64 |
| |
| def test_battery(self): |
| uhdev = self.uhdev |
| |
| assert uhdev.power_supply_class is not None |
| |
| # DS4 capacity levels are in increments of 10. |
| # Battery is never below 5%. |
| for i in range(5, 105, 10): |
| uhdev.battery.capacity = i |
| uhdev.event() |
| assert uhdev.power_supply_class.capacity == i |
| |
| # Discharging tests only make sense for BlueTooth. |
| if uhdev.bus == BusType.BLUETOOTH: |
| uhdev.battery.cable_connected = False |
| uhdev.battery.capacity = 45 |
| uhdev.event() |
| assert uhdev.power_supply_class.status == "Discharging" |
| |
| uhdev.battery.cable_connected = True |
| uhdev.battery.capacity = 5 |
| uhdev.event() |
| assert uhdev.power_supply_class.status == "Charging" |
| |
| uhdev.battery.capacity = 100 |
| uhdev.event() |
| assert uhdev.power_supply_class.status == "Charging" |
| |
| uhdev.battery.full = True |
| uhdev.event() |
| assert uhdev.power_supply_class.status == "Full" |
| |
| def test_mt_single_touch(self): |
| """send a single touch in the first slot of the device, |
| and release it.""" |
| uhdev = self.uhdev |
| evdev = uhdev.get_evdev("Touch Pad") |
| |
| t0 = PSTouchPoint(1, 50, 100) |
| r = uhdev.event(touch=[t0]) |
| events = uhdev.next_sync_events("Touch Pad") |
| self.debug_reports(r, uhdev, events) |
| |
| assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 1) in events |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 0 |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_X] == 50 |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 100 |
| |
| t0.tipswitch = False |
| r = uhdev.event(touch=[t0]) |
| events = uhdev.next_sync_events("Touch Pad") |
| self.debug_reports(r, uhdev, events) |
| assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 0) in events |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1 |
| |
| def test_mt_dual_touch(self): |
| """Send 2 touches in the first 2 slots. |
| Make sure the kernel sees this as a dual touch. |
| Release and check |
| |
| Note: PTP will send here BTN_DOUBLETAP emulation""" |
| uhdev = self.uhdev |
| evdev = uhdev.get_evdev("Touch Pad") |
| |
| t0 = PSTouchPoint(1, 50, 100) |
| t1 = PSTouchPoint(2, 150, 200) |
| |
| r = uhdev.event(touch=[t0]) |
| events = uhdev.next_sync_events("Touch Pad") |
| self.debug_reports(r, uhdev, events) |
| |
| assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 1) in events |
| assert evdev.value[libevdev.EV_KEY.BTN_TOUCH] == 1 |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 0 |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_X] == 50 |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 100 |
| assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1 |
| |
| r = uhdev.event(touch=[t0, t1]) |
| events = uhdev.next_sync_events("Touch Pad") |
| self.debug_reports(r, uhdev, events) |
| assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH) not in events |
| assert evdev.value[libevdev.EV_KEY.BTN_TOUCH] == 1 |
| assert ( |
| libevdev.InputEvent(libevdev.EV_ABS.ABS_MT_POSITION_X, 5) not in events |
| ) |
| assert ( |
| libevdev.InputEvent(libevdev.EV_ABS.ABS_MT_POSITION_Y, 10) not in events |
| ) |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 0 |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_X] == 50 |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 100 |
| assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 1 |
| assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_POSITION_X] == 150 |
| assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 200 |
| |
| t0.tipswitch = False |
| r = uhdev.event(touch=[t0, t1]) |
| events = uhdev.next_sync_events("Touch Pad") |
| self.debug_reports(r, uhdev, events) |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1 |
| assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 1 |
| assert libevdev.InputEvent(libevdev.EV_ABS.ABS_MT_POSITION_X) not in events |
| assert libevdev.InputEvent(libevdev.EV_ABS.ABS_MT_POSITION_Y) not in events |
| |
| t1.tipswitch = False |
| r = uhdev.event(touch=[t1]) |
| |
| events = uhdev.next_sync_events("Touch Pad") |
| self.debug_reports(r, uhdev, events) |
| assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1 |
| assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1 |
| |
| |
| class TestPS3Controller(SonyBaseTest.SonyTest): |
| kernel_modules = [PS3_MODULE] |
| |
| def create_device(self): |
| controller = PS3Controller() |
| controller.application_matches = application_matches |
| return controller |
| |
| @pytest.fixture(autouse=True) |
| def start_controller(self): |
| # emulate a 'PS' button press to tell the kernel we are ready to accept events |
| self.assert_button(17) |
| |
| # drain any remaining udev events |
| while self.uhdev.dispatch(10): |
| pass |
| |
| def test_led(self): |
| for k, v in self.uhdev.led_classes.items(): |
| # the kernel might have set a LED for us |
| logger.info(f"{k}: {v.brightness}") |
| |
| idx = int(k[-1]) - 1 |
| assert self.uhdev.hw_leds.get_led(idx)[0] == bool(v.brightness) |
| |
| v.brightness = 0 |
| self.uhdev.dispatch(10) |
| assert self.uhdev.hw_leds.get_led(idx)[0] is False |
| |
| v.brightness = v.max_brightness |
| self.uhdev.dispatch(10) |
| assert self.uhdev.hw_leds.get_led(idx)[0] |
| |
| |
| class CalibratedPS4Controller(object): |
| # DS4 reports uncalibrated sensor data. Calibration coefficients |
| # can be retrieved using a feature report (0x2 USB / 0x5 BT). |
| # The values below are the processed calibration values for the |
| # DS4s matching the feature reports of PS4ControllerBluetooth/USB |
| # as dumped from hid-sony 'ds4_get_calibration_data'. |
| # |
| # Note we duplicate those values here in case the kernel changes them |
| # so we can have tests passing even if hid-tools doesn't have the |
| # correct values. |
| accelerometer_calibration_data = { |
| "x": {"bias": -73, "numer": 16384, "denom": 16472}, |
| "y": {"bias": -352, "numer": 16384, "denom": 16344}, |
| "z": {"bias": 81, "numer": 16384, "denom": 16319}, |
| } |
| gyroscope_calibration_data = { |
| "x": {"bias": 0, "numer": 1105920, "denom": 17827}, |
| "y": {"bias": 0, "numer": 1105920, "denom": 17777}, |
| "z": {"bias": 0, "numer": 1105920, "denom": 17748}, |
| } |
| |
| |
| class CalibratedPS4ControllerBluetooth(CalibratedPS4Controller, PS4ControllerBluetooth): |
| pass |
| |
| |
| class TestPS4ControllerBluetooth(SonyBaseTest.SonyPS4ControllerTest): |
| def create_device(self): |
| controller = CalibratedPS4ControllerBluetooth() |
| controller.application_matches = application_matches |
| return controller |
| |
| |
| class CalibratedPS4ControllerUSB(CalibratedPS4Controller, PS4ControllerUSB): |
| pass |
| |
| |
| class TestPS4ControllerUSB(SonyBaseTest.SonyPS4ControllerTest): |
| def create_device(self): |
| controller = CalibratedPS4ControllerUSB() |
| controller.application_matches = application_matches |
| return controller |
| |
| |
| class CalibratedPS5Controller(object): |
| # DualSense reports uncalibrated sensor data. Calibration coefficients |
| # can be retrieved using feature report 0x09. |
| # The values below are the processed calibration values for the |
| # DualSene matching the feature reports of PS5ControllerBluetooth/USB |
| # as dumped from hid-playstation 'dualsense_get_calibration_data'. |
| # |
| # Note we duplicate those values here in case the kernel changes them |
| # so we can have tests passing even if hid-tools doesn't have the |
| # correct values. |
| accelerometer_calibration_data = { |
| "x": {"bias": 0, "numer": 16384, "denom": 16374}, |
| "y": {"bias": -114, "numer": 16384, "denom": 16362}, |
| "z": {"bias": 2, "numer": 16384, "denom": 16395}, |
| } |
| gyroscope_calibration_data = { |
| "x": {"bias": 0, "numer": 1105920, "denom": 17727}, |
| "y": {"bias": 0, "numer": 1105920, "denom": 17728}, |
| "z": {"bias": 0, "numer": 1105920, "denom": 17769}, |
| } |
| |
| |
| class CalibratedPS5ControllerBluetooth(CalibratedPS5Controller, PS5ControllerBluetooth): |
| pass |
| |
| |
| class TestPS5ControllerBluetooth(SonyBaseTest.SonyPS4ControllerTest): |
| kernel_modules = [PS5_MODULE] |
| |
| def create_device(self): |
| controller = CalibratedPS5ControllerBluetooth() |
| controller.application_matches = application_matches |
| return controller |
| |
| |
| class CalibratedPS5ControllerUSB(CalibratedPS5Controller, PS5ControllerUSB): |
| pass |
| |
| |
| class TestPS5ControllerUSB(SonyBaseTest.SonyPS4ControllerTest): |
| kernel_modules = [PS5_MODULE] |
| |
| def create_device(self): |
| controller = CalibratedPS5ControllerUSB() |
| controller.application_matches = application_matches |
| return controller |
