UNIHIKER: GR10-30 gesture sensor

from pinpong.board import I2C
from time import sleep


GR10_30_I2C_ADDR = 0x73

GR30_10_INPUT_REG_ADDR = 0x02
GR30_10_INPUT_REG_DATA_READY = 0x06
GR30_10_INPUT_REG_INTERRUPT_STATE = 0x07
GR30_10_INPUT_REG_EXIST_STATE = 0x08

GR30_10_HOLDING_REG_INTERRUPT_MODE = 0x09
GR30_10_HOLDING_REG_RESET = 0x18

GESTURE_UP = (1 << 0)
GESTURE_DOWN = (1 << 1)
GESTURE_LEFT = (1 << 2)
GESTURE_RIGHT = (1 << 3)
GESTURE_FORWARD = (1 << 4)
GESTURE_BACKWARD = (1 << 5)
GESTURE_CLOCKWISE = (1 << 6)
GESTURE_COUNTERCLOCKWISE = (1 << 7)
GESTURE_WAVE = (1 << 8)
GESTURE_HOVER = (1 << 9)
GESTURE_UNKNOWN = (1 << 10)
GESTURE_CLOCKWISE_C = (1 << 14)
GESTURE_COUNTERCLOCKWISE_C = (1 << 15)


class DFRobot_GR10_30_I2C:

    def __init__(self, i2c_addr=GR10_30_I2C_ADDR, i2c_bus=0):
        self._addr = i2c_addr
        self._temp_buffer = [0] * 2

        try:
            self._i2c = I2C(i2c_bus)
        except Exception as err:
            print(f'Could not initialize i2c! bus: {i2c_bus}, error: {err}')

    def _write_reg(self, reg, data) -> None:
        if isinstance(data, int):
            data = [data]

        try:
            self._i2c.writeto_mem(self._addr, reg, bytearray(data))
        except Exception as err:
            print(f'Write issue: {err}')

    def _read_reg(self, reg, length) -> bytes:
        try:
            result = self._i2c.readfrom_mem(self._addr, reg, length)
        except Exception as err:
            print(f'Read issue: {err}')
            result = [0, 0]

        return result

    def _detect_device_address(self) -> int:
        r_buf = self._read_reg(GR30_10_INPUT_REG_ADDR, 2)
        data = r_buf[0] << 8 | r_buf[1]

        return data

    def _reset_sensor(self) -> None:
        self._temp_buffer[0] = 0x55
        self._temp_buffer[1] = 0x00
        self._write_reg(GR30_10_HOLDING_REG_RESET, self._temp_buffer)

        sleep(0.1)

    def begin(self) -> bool:
        if self._detect_device_address() != GR10_30_I2C_ADDR:
            return False

        self._reset_sensor()
        sleep(0.5)

        return True

    def en_gestures(self, gestures) -> None:
        gestures = gestures & 0xc7ff

        self._temp_buffer[0] = (gestures >> 8) & 0xC7
        self._temp_buffer[1] = gestures & 0x00ff
        self._write_reg(GR30_10_HOLDING_REG_INTERRUPT_MODE, self._temp_buffer)

        sleep(0.1)

    def get_exist(self) -> bool:
        r_buf = self._read_reg(GR30_10_INPUT_REG_EXIST_STATE, 2)
        data = r_buf[0] * 256 + r_buf[1]

        return bool(data)

    def get_data_ready(self) -> bool:
        r_buf = self._read_reg(GR30_10_INPUT_REG_DATA_READY, 2)
        data = r_buf[0] * 256 + r_buf[1]

        if data == 0x01:
            return True
        else:
            return False

    def get_gestures(self) -> int:
        r_buf = self._read_reg(GR30_10_INPUT_REG_INTERRUPT_STATE, 2)
        data = (r_buf[0] & 0xff) * 256 + r_buf[1]

        return int(data)

from os import listdir
from os.path import dirname, join
from tkinter import Tk, BOTH, Frame, Label, PhotoImage
from typing import List, Tuple
from PIL import Image, ImageTk
from time import sleep
from sys import exit
from threading import Thread
from pinpong.board import Board
from lib.GR10_30 import DFRobot_GR10_30_I2C, GESTURE_LEFT, GESTURE_RIGHT, GESTURE_UP, GESTURE_DOWN


SCREEN_WIDTH: int = 240
SCREEN_HEIGHT: int = 320
FONT: tuple = ("Arial", 14, "bold")
IMAGE_PATH: str = 'demo/'
IMAGE_EXTENSIONS: tuple = ('.png', '.jpg', '.jpeg')


def load_image(image_path: str, image_size: Tuple[int, int]) -> ImageTk.PhotoImage:
    """
    Load an image from the specified path and resize it to the given size.

    :param image_path: The path to the image file.
    :type image_path: str
    :param image_size: The desired size of the image as a tuple of width and height.
    :type image_size: Tuple[int, int]
    :return: The loaded and resized image as an `ImageTk.PhotoImage` object.
    :rtype: ImageTk.PhotoImage
    """
    image = Image.open(image_path)
    image = image.resize(image_size)

    return ImageTk.PhotoImage(image)


def load_all_images(image_dir: str, image_size: Tuple[int, int]) -> List[ImageTk.PhotoImage]:
    """
    Load all the images in the specified directory.

    :param image_dir: The directory where the images are located.
    :type image_dir: str
    :param image_size: The desired size of the images.
    :type image_size: Tuple[int, int]
    :return: A list of loaded images as `ImageTk.PhotoImage`.
    :rtype: List[ImageTk.PhotoImage]
    """
    filenames = [join(image_dir, f) for f in listdir(image_dir) if f.endswith(IMAGE_EXTENSIONS)]

    return [load_image(filename, image_size) for filename in filenames]


def update_label(label: Label, image_list: List[PhotoImage], index: int) -> None:
    """
    Updates the image and text displayed in a tkinter Label widget.

    :param label: The tkinter Label widget to update.
    :type label: Label
    :param image_list: A list of PhotoImage objects representing the images to cycle through.
    :type image_list: List[ImageTk.PhotoImage]
    :param index: The index of the image in the image_list to display in the label.
    :type index: int
    :return: None
    """
    total_images = len(image_list)

    if 0 <= index < total_images:
        message = f'Image: {index + 1} of {total_images}'
        print(f'[INFO] Display {message.lower()}')

        label.config(image=image_list[index], text=message, font=FONT, fg='white')
        label.image = image_list[index]


def handle_gestures(sensor: DFRobot_GR10_30_I2C, image_list: List[PhotoImage], label: Label) -> None:
    """
    Handles gestures detected by the given sensor.

    :param sensor: The instance of the DFRobot_GR10_30_I2C sensor.
    :type sensor: DFRobot_GR10_30_I2C
    :param image_list: A list of PhotoImage objects representing the images to cycle through.
    :type image_list: List[ImageTk.PhotoImage]
    :param label: The tkinter Label widget to update.
    :type label: Label
    :return: None
    """
    image_index = 0
    total_images = len(image_list)

    while True:
        if gesture_sensor.get_data_ready():
            gesture = sensor.get_gestures()

            if gesture & GESTURE_LEFT:
                print(f'[INFO] Gesture: {gesture} left detected')
                if image_index < total_images:
                    image_index += 1

            if gesture & GESTURE_RIGHT:
                print(f'[INFO] Gesture: {gesture} right detected')
                if image_index > 0:
                    image_index -= 1

            if gesture & GESTURE_UP:
                print(f'[INFO] Gesture: {gesture} up detected')
                image_index = 0

            if gesture & GESTURE_DOWN:
                print(f'[INFO] Gesture: {gesture} down detected')
                image_index = total_images - 1

            update_label(label, images, image_index)

        sleep(.05)


if __name__ == '__main__':
    Board("UNIHIKER").begin()

    gesture_sensor = DFRobot_GR10_30_I2C()
    while not gesture_sensor.begin():
        print('[INFO] Initializing gesture sensor...')
        sleep(1)

    gesture_sensor.en_gestures(GESTURE_LEFT | GESTURE_RIGHT | GESTURE_UP | GESTURE_DOWN)

    root = Tk()
    root.resizable(False, False)
    root.geometry(f'{SCREEN_WIDTH}x{SCREEN_HEIGHT}+0+0')

    frame = Frame(root, height=SCREEN_HEIGHT, width=SCREEN_WIDTH, bg='black')
    frame.pack(fill=BOTH, expand=True)
    img_label = Label(frame, text='', font=FONT, fg='white', compound='center')
    img_label.pack(fill=BOTH, expand=True)

    current_dir = dirname(__file__)
    target_path = join(current_dir, IMAGE_PATH)
    images = load_all_images(join(dirname(__file__), IMAGE_PATH), (SCREEN_WIDTH, SCREEN_HEIGHT))

    if not images:
        print(f'[INFO] No images found: {target_path}')
        exit(1)
    else:
        print(f'[INFO] Found {len(images)} images')
        update_label(img_label, images, 0)

        gesture_thread = Thread(target=handle_gestures, args=(gesture_sensor, images, img_label))
        gesture_thread.daemon = True
        gesture_thread.start()

    root.mainloop()