Python-无线控制器和加法/值列表

Question

Hardware: RPi4 4GB, SteelSeries Stratus Duo WiFi/BTLE wireless controller

Long Term Goal: Perform multiple tasks (ie, move/zero the toolhead, start/pause/stop the program, etc.) using the wireless controller which will interface with the RPi that is running a server that controls a CNC router.

Short Term Goal: Determine which combination of buttons are being pressed without using an ungodly number of if/elif statements.

Summary: I have already figured out how to read the output from the wireless controller using PyUSB. I've altered/added code to that which was included with PyUSB to produce some human-readable results. The output is formatted in a list, with each item's value being determined by some sort of button combination. (I know it says "array", but Python appears to treat it as a list.)

This is the output when no buttons are pressed (Default):

array('B', [0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

The first two values ( ...[0, 20,...] ) seem to be some sort of identifiers, and those never change. Multiple buttons, however, utilize the same indexed location in the list. They all have different values, and are summed when pressed simultaneously. No combination of button values generate the same output for the indexed location. Examples:

Button A: array('B', [0, 20, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

Top Left: array('B', [0, 20, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

Top Left & A: array('B', [0, 20, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

Here is my current program, and as you can see the if/elif statements are starting to get a little out of hand.:

#!/usr/bin/python
from __future__ import division

import usb.core
import usb.util
import time
import os
import sys
#import csv

USB_IF      = 0 # Interface
USB_TIMEOUT = 5 # Timeout in MS

USB_VENDOR  = 0x1038 # SteelSeries
USB_PRODUCT = 0x1430 # Stratus Duo

dev = usb.core.find(idVendor=USB_VENDOR, idProduct=USB_PRODUCT)

endpoint = dev[0][(0,0)][0]

if dev.is_kernel_driver_active(USB_IF) is True:
    dev.detach_kernel_driver(USB_IF)

usb.util.claim_interface(dev, USB_IF)

while True:
    control = None

    try:
        control = dev.read(endpoint.bEndpointAddress, endpoint.wMaxPacketSize, USB_TIMEOUT)
        CtrlA = control[2]      #Directional Pad, Start/Select, L/R Stick Press
        CtrlB = control[3]      #Top Left/Top Right, Center, A, B, X, Y
        CtrlC = control[4]      #Left Trigger (0-255)
        CtrlD = control[5]      #Right Trigger (0-255)
        CtrlEH = control[6:10]  #Left Stick
        CtrlIL = control[10:14] #Right Stick
        print control
        if CtrlA ==0:
            print "No Input"
        elif CtrlA == 1:
            print "Directional Pad: Up"
        elif CtrlA == 2:
            print "Directional Pad: Down"
        elif CtrlA == 4:
            print "Directional Pad: Left"
        elif CtrlA == 8:
            print "Directional Pad: Right"  
        elif CtrlA == 16:
            print "Right Center Button"
        elif CtrlA == 32:
            print "Left Center Button"
        elif CtrlA == 64:
            print "Left Stick Pressed"
        elif CtrlA == 128:
            print "Right Stick Pressed"
        elif CtrlA == 192:
            print "Right & Left Sticks Pressed"
        else:
            break

        if CtrlC == 0:
            print "Left Trigger: No Input"
        elif 1 <= CtrlC <=254:
            print "Left Trigger: " + "{:.0%}".format(CtrlC/255)
        elif CtrlC == 255:
            print "Left Trigger: Max"
        else:
            break


        if CtrlD == 0:
            print "Right Trigger: No Input"
        elif 1 <= CtrlD <=254:
            print "Right Trigger: " + "{:.0%}".format(CtrlD/255)
        elif CtrlD == 255:
            print "Right Trigger: Max"
        else:
            break

except:
pass

#Let Ctrl+C actually exit.
time.sleep(0.01)

Again, my desired result would be for the program to determine the combination of buttons being pressed- For instance, if the value for control[3] is 17 , is there a way to efficiently have the program determine that it is a combination of the assigned values of 16 and 1 (The 'A' button & the 'Top Left' button)?

I've looked into possibly using a CSV file, itertools(permutations, combinations, etc.), embedded lists, and other such possible solutions. At first glance, all of these appear to be somewhere in the ballpark of what I want to do. Unfortunately, none of these (at least by themselves) appear to accomplish the goal. This is a completely uncharted area of programming for me, and any guidance would be greatly appreciated.

Answer 1

Here's what I'd do.

I'd assign each button its own tuple of position and value, like this:

buttons = [
    ('dir_up', 2, 1),
    ('dir_down', 2, 2),
    ('dir_left', 2, 4),
    ('dir_right', 2, 8),
    # ... etc, other buttons here
]

Then you can see which buttons are actually pressed with a generator:

def pressed_buttons(control):
    for button in buttons:
        name, control_pos, value = button
        # To check if the button was pressed, perform a binary masking
        if control[control_pos] & value == value:
            yield button

PS For added clarity, you might find namedtuples or even enums useful.

Answer 2

If the value for control[3] is 17, is there a way to efficiently have the program determine that it is a combination of the assigned values of 16 and 1

This is the interesting bit of the question. And the answer is "yes". You may have noticed that the individual values (1, 2, 4, 8, 16, 32, 64...) are powers of 2 (2**1, 2**2, 2**3...) . This means that the combined values can be thought of as binary digits. So if I gave you 40, the only way to represent that using powers of 2 is 32 + 8. In binary, this is 101000. If you want to get this in Python then (at least in Python3) you can do bin(40) , which prints the string '0b10001'.

In terms of how to make the most of this, I shall defer to art-solopov's answer.