Remote controller callback

[Gcopper1984]

Hi,

I share here a script where buttons functions are triggered by callback. This callback can be defined in your script at your desire. This is not a multithread application anyway.

This could be a cool method to approach remote controller application. Main loop is schrinked to a simple statement, all the logic is inside callback functions

Here the code. Enjoy.

from pybricks.pupdevices import Remote
from pybricks.parameters import Button

class Remote_Controller:
    # Useful constant
    _PRESSED = 0
    _RELEASED = 1

    # Remote
    remote = None

    # Button status  
    actual_center_value = False
    previus_center_value = actual_center_value

    actual_left_center_value = False
    previus_left_center_value = actual_left_center_value

    actual_left_plus_value = False
    previus_left_plus_value = actual_left_plus_value

    actual_left_minus_value = False
    previus_left_minus_value = actual_left_minus_value

    actual_right_center_value = False
    previus_right_center_value = actual_right_center_value

    actual_right_plus_value = False
    previus_right_plus_value = actual_right_plus_value

    actual_right_minus_value = False
    previus_right_minus_value = actual_right_minus_value

    #  Buttons callback
    callback_center_pressed = None
    callback_center_released = None

    callback_left_center_pressed = None
    callback_left_center_released = None

    callback_left_plus_pressed = None
    callback_left_plus_released = None

    callback_left_minus_pressed = None
    callback_left_minus_released = None

    callback_right_center_pressed = None
    callback_right_center_released = None

    callback_right_plus_pressed = None
    callback_right_plus_released = None

    callback_right_minus_pressed = None
    callback_right_minus_released = None

    def __init__(self):
        self.remote = Remote()
        pressed = self.remote.buttons.pressed()
        
        # Check if buttons are pressed
        if Button.CENTER in pressed:
            self.actual_center_value = True

        if Button.LEFT in pressed:
            self.actual_left_center_value = True

        if Button.LEFT_PLUS in pressed:
            self.actual_left_plus_value = True

        if Button.LEFT_MINUS in pressed:
            self.actual_left_minus_value = True

        if Button.RIGHT in pressed:
            self.actual_right_center_value = True

        if Button.RIGHT_PLUS in pressed:
            self.actual_right_plus_value = True

        if Button.RIGHT_MINUS in pressed:
            self.actual_right_minus_value = True

        # Save old values
        self.previus_center_value = self.actual_center_value
        self.previus_left_center_value = self.actual_left_center_value
        self.previus_left_plus_value = self.actual_left_plus_value
        self.previus_left_minus_value = self.actual_left_minus_value
        self.previus_right_center_value = self.actual_right_center_value
        self.previus_right_plus_value = self.actual_right_plus_value
        self.previus_right_minus_value = self.actual_right_minus_value

    def register_callback(self, button, action, callback):
        if button == Button.CENTER:
            if action == self._PRESSED:
                self.callback_center_pressed = callback
            elif action == self._RELEASED:
                self.callback_center_released = callback

        if button == Button.LEFT:
            if action == self._PRESSED:
                self.callback_left_center_pressed = callback
            elif action == self._RELEASED:
                self.callback_left_center_released = callback

        if button == Button.LEFT_PLUS:
            if action == self._PRESSED:
                self.callback_left_plus_pressed = callback
            elif action == self._RELEASED:
                self.callback_left_plus_released = callback

        if button == Button.LEFT_MINUS:
            if action == self._PRESSED:
                self.callback_left_minus_pressed = callback
            elif action == self._RELEASED:
                self.callback_left_minus_released = callback

        if button == Button.RIGHT:
            if action == self._PRESSED:
                self.callback_right_center_pressed = callback
            elif action == self._RELEASED:
                self.callback_right_center_released = callback

        if button == Button.RIGHT_PLUS:
            if action == self._PRESSED:
                self.callback_right_plus_pressed = callback
            elif action == self._RELEASED:
                self.callback_right_plus_released = callback

        if button == Button.RIGHT_MINUS:
            if action == self._PRESSED:
                self.callback_right_minus_pressed = callback
            elif action == self._RELEASED:
                self.callback_right_minus_released = callback

    def update(self):
        # Update status
        pressed = self.remote.buttons.pressed()

        if Button.CENTER in pressed:
            self.actual_center_value = True
        else:
            self.actual_center_value = False

        if Button.LEFT in pressed:
            self.actual_left_center_value = True
        else:
            self.actual_left_center_value = False

        if Button.LEFT_PLUS in pressed:
            self.actual_left_plus_value = True
        else:
            self.actual_left_plus_value = False

        if Button.LEFT_MINUS in pressed:
            self.actual_left_minus_value = True
        else:
            self.actual_left_minus_value = False

        if Button.RIGHT in pressed:
            self.actual_right_center_value = True
        else:
            self.actual_right_center_value = False

        if Button.RIGHT_PLUS in pressed:
            self.actual_right_plus_value = True
        else:
            self.actual_right_plus_value = False

        if Button.RIGHT_MINUS in pressed:
            self.actual_right_minus_value = True
        else:
            self.actual_right_minus_value = False

        # Callback
        if self.actual_center_value != self.previus_center_value:
            if self.actual_center_value == True:
                if self.callback_center_pressed != None:
                    self.callback_center_pressed()
            else:
                if self.callback_center_released != None:
                    self.callback_center_released()

        if self.actual_left_center_value != self.previus_left_center_value:
            if self.actual_left_center_value == True:
                if self.callback_left_center_pressed != None:
                    self.callback_left_center_pressed()
            else:
                if self.callback_left_center_released != None:
                    self.callback_left_center_released()

        if self.actual_left_plus_value != self.previus_left_plus_value:
            if self.actual_left_plus_value == True:
                if self.callback_left_plus_pressed != None:
                    self.callback_left_plus_pressed()
            else:
                if self.callback_left_plus_released != None:
                    self.callback_left_plus_released()

        if self.actual_left_minus_value != self.previus_left_minus_value:
            if self.actual_left_minus_value == True:
                if self.callback_left_minus_pressed != None:
                    self.callback_left_minus_pressed()
            else:
                if self.callback_left_minus_released != None:
                    self.callback_left_minus_released()

        if self.actual_right_center_value != self.previus_right_center_value:
            if self.actual_right_center_value == True:
                if self.callback_right_center_pressed != None:
                    self.callback_right_center_pressed()
            else:
                if self.callback_right_center_released != None:
                    self.callback_right_center_released()

        if self.actual_right_plus_value != self.previus_right_plus_value:
            if self.actual_right_plus_value == True:
                if self.callback_right_plus_pressed != None:
                    self.callback_right_plus_pressed()
            else:
                if self.callback_right_plus_released != None:
                    self.callback_right_plus_released()

        if self.actual_right_minus_value != self.previus_right_minus_value:
            if self.actual_right_minus_value == True:
                if self.callback_right_minus_pressed != None:
                    self.callback_right_minus_pressed()
            else:
                if self.callback_right_minus_released != None:
                    self.callback_right_minus_released()

        # Save old values
        self.previus_center_value = self.actual_center_value
        self.previus_left_center_value = self.actual_left_center_value
        self.previus_left_plus_value = self.actual_left_plus_value
        self.previus_left_minus_value = self.actual_left_minus_value
        self.previus_right_center_value = self.actual_right_center_value
        self.previus_right_plus_value = self.actual_right_plus_value
        self.previus_right_minus_value = self.actual_right_minus_value

def print_center_pressed():
    print("Center pressed")

def print_center_released():
    print("Center released")

def print_left_center_pressed():
    print("Left center pressed")

def print_left_center_released():
    print("Left center released")

def print_left_plus_pressed():
    print("Left plus pressed")

def print_left_plus_released():
    print("Left plus released")

def print_left_minus_pressed():
    print("Left minus pressed")

def print_left_minus_released():
    print("Left minus released")

def print_right_center_pressed():
    print("Right center pressed")

def print_right_center_released():
    print("Right center released")

def print_right_plus_pressed():
    print("Right plus pressed")

def print_right_plus_released():
    print("Right plus released")

def print_right_minus_pressed():
    print("Right minus pressed")

def print_right_minus_released():
    print("Right minus released")

# Main program
print("Start main")
remote_controller = Remote_Controller()
remote_controller.register_callback(Button.CENTER, remote_controller._PRESSED, print_center_pressed)
remote_controller.register_callback(Button.CENTER, remote_controller._RELEASED, print_center_released)

remote_controller.register_callback(Button.LEFT, remote_controller._PRESSED, print_left_center_pressed)
remote_controller.register_callback(Button.LEFT, remote_controller._RELEASED, print_left_center_released)
remote_controller.register_callback(Button.LEFT_PLUS, remote_controller._PRESSED, print_left_plus_pressed)
remote_controller.register_callback(Button.LEFT_PLUS, remote_controller._RELEASED, print_left_plus_released)
remote_controller.register_callback(Button.LEFT_MINUS, remote_controller._PRESSED, print_left_minus_pressed)
remote_controller.register_callback(Button.LEFT_MINUS, remote_controller._RELEASED, print_left_minus_released)

remote_controller.register_callback(Button.RIGHT, remote_controller._PRESSED, print_right_center_pressed)
remote_controller.register_callback(Button.RIGHT, remote_controller._RELEASED, print_right_center_released)
remote_controller.register_callback(Button.RIGHT_PLUS, remote_controller._PRESSED, print_right_plus_pressed)
remote_controller.register_callback(Button.RIGHT_PLUS, remote_controller._RELEASED, print_right_plus_released)
remote_controller.register_callback(Button.RIGHT_MINUS, remote_controller._PRESSED, print_right_minus_pressed)
remote_controller.register_callback(Button.RIGHT_MINUS, remote_controller._RELEASED, print_right_minus_released)

while True:
    remote_controller.update()

print("Done")