libraspike-art-python 0.0.3__tar.gz

libraspike-art-python-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Wataru Taniguchi <wataru@taniguchifamily.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

libraspike-art-python-0.0.3/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: libraspike-art-python
+Version: 0.0.3
+Summary: Python CFFI Bindings for libraspike-art
+Author: Wataru Taniguchi
+Author-email: wataru@taniguchifamily.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+## Python CFFI Bindings for libraspike-art
+
+# Installation
+
+Enable use of libraspike-art by following the direction [here](https://github.com/ETrobocon/libraspike-art/tree/main).
+
+If you are on a modern Linux you will probably want to create a venv:
+
+    python3 -m venv vpython3
+    source vpython3/bin/activate
+
+or:
+
+    pypy3 -m venv vpypy3
+    source vpypy3/bin/activate
+
+Build the bindings and install libraspike-art-python package:
+
+    pip install libraspike-art-python

libraspike-art-python-0.0.3/README.md

@@ -0,0 +1,19 @@
+## Python CFFI Bindings for libraspike-art
+
+# Installation
+
+Enable use of libraspike-art by following the direction [here](https://github.com/ETrobocon/libraspike-art/tree/main).
+
+If you are on a modern Linux you will probably want to create a venv:
+
+    python3 -m venv vpython3
+    source vpython3/bin/activate
+
+or:
+
+    pypy3 -m venv vpypy3
+    source vpypy3/bin/activate
+
+Build the bindings and install libraspike-art-python package:
+
+    pip install libraspike-art-python

libraspike-art-python-0.0.3/libraspike_art_python/__init__.py

@@ -0,0 +1,254 @@
+from _libraspike_art import ffi, lib
+from enum import IntEnum
+from typing import Tuple
+import sys
+from .version import  __version__
+
+print("LIBRASPIKE-ART STATIC "+__version__+" LOADED", file=sys.stderr)
+
+class pbio_error(IntEnum):
+    SUCCESS = lib.PBIO_SUCCESS
+    FAILED = lib.PBIO_ERROR_FAILED
+    INVALID_ARG = lib.PBIO_ERROR_INVALID_ARG
+    IO = lib.PBIO_ERROR_IO
+    BUSY = lib.PBIO_ERROR_BUSY
+    NO_DEV = lib.PBIO_ERROR_NO_DEV
+    NOT_IMPLEMENTED = lib.PBIO_ERROR_NOT_IMPLEMENTED
+    NOT_SUPPORTED = lib.PBIO_ERROR_NOT_SUPPORTED
+    AGAIN = lib.PBIO_ERROR_AGAIN
+    INVALID_OP = lib.PBIO_ERROR_INVALID_OP
+    TIMEDOUT = lib.PBIO_ERROR_TIMEDOUT
+    CANCELED = lib.PBIO_ERROR_CANCELED
+
+class pbio_port(IntEnum):
+    ID_A = lib.PBIO_PORT_ID_A
+    ID_B = lib.PBIO_PORT_ID_B
+    ID_C = lib.PBIO_PORT_ID_C
+    ID_D = lib.PBIO_PORT_ID_D
+    ID_E = lib.PBIO_PORT_ID_E
+    ID_F = lib.PBIO_PORT_ID_F
+
+def PBIO_COLOR_ENCODE(h, s, v):
+    return ((h // 30) << 3) | ((s // 51) << 2) | (v // 34)
+
+class pbio_color(IntEnum):
+    NONE = PBIO_COLOR_ENCODE(180, 0, 0)
+    BLACK = PBIO_COLOR_ENCODE(0, 0, 0)
+    GRAY = PBIO_COLOR_ENCODE(0, 0, 50)
+    WHITE = PBIO_COLOR_ENCODE(0, 0, 100)
+    RED = PBIO_COLOR_ENCODE(0, 100, 100)
+    BROWN = PBIO_COLOR_ENCODE(30, 100, 50)
+    ORANGE = PBIO_COLOR_ENCODE(30, 100, 100)
+    YELLOW = PBIO_COLOR_ENCODE(60, 100, 100)
+    GREEN = PBIO_COLOR_ENCODE(120, 100, 100)
+    SPRING_GREEN = PBIO_COLOR_ENCODE(150, 100, 100)
+    CYAN = PBIO_COLOR_ENCODE(180, 100, 100)
+    BLUE = PBIO_COLOR_ENCODE(240, 100, 100)
+    VIOLET = PBIO_COLOR_ENCODE(270, 100, 100)
+    MAGENTA = PBIO_COLOR_ENCODE(300, 100, 100)
+
+class hub_button(IntEnum):
+    LEFT = lib.HUB_BUTTON_LEFT
+    CENTER = lib.HUB_BUTTON_CENTER
+    RIGHT = lib.HUB_BUTTON_RIGHT
+    BT = lib.HUB_BUTTON_BT
+
+class sound(IntEnum):
+    MANUAL_STOP       = -1
+    NOTE_C4           = 261.63
+    NOTE_CS4          = 277.18
+    NOTE_D4           = 293.66
+    NOTE_DS4          = 311.13
+    NOTE_E4           = 329.63
+    NOTE_F4           = 349.23
+    NOTE_FS4          = 369.99
+    NOTE_G4           = 392.00
+    NOTE_GS4          = 415.30
+    NOTE_A4           = 440.00
+    NOTE_AS4          = 466.16
+    NOTE_B4           = 493.88
+    NOTE_C5           = 523.25
+    NOTE_CS5          = 554.37
+    NOTE_D5           = 587.33
+    NOTE_DS5          = 622.25
+    NOTE_E5           = 659.25
+    NOTE_F5           = 698.46
+    NOTE_FS5          = 739.99
+    NOTE_G5           = 783.99
+    NOTE_GS5          = 830.61
+    NOTE_A5           = 880.00
+    NOTE_AS5          = 932.33
+    NOTE_B5           = 987.77
+    NOTE_C6           =1046.50
+    NOTE_CS6          =1108.73
+    NOTE_D6           =1174.66
+    NOTE_DS6          =1244.51
+    NOTE_E6           =1318.51
+    NOTE_F6           =1396.91
+    NOTE_FS6          =1479.98
+    NOTE_G6           =1567.98
+    NOTE_GS6          =1661.22
+    NOTE_A6           =1760.00
+    NOTE_AS6          =1864.66
+    NOTE_B6           =1975.53
+
+class pup_direction(IntEnum):
+    CLOCKWISE = lib.PUP_DIRECTION_CLOCKWISE
+    COUNTERCLOCKWISE = lib.PUP_DIRECTION_COUNTERCLOCKWISE
+
+def raspike_open_usb_communication(device_name: str) -> ffi.CData:
+    desc = lib.raspike_open_usb_communication(device_name.encode())
+    return desc if desc != ffi.NULL else None
+
+def raspike_prot_init(desc: ffi.CData) -> int:
+    return lib.raspike_prot_init(desc)
+def raspike_prot_receive() -> int:
+    return lib.raspike_prot_receive()
+def raspike_prot_shutdown() -> int:
+    return lib.raspike_prot_shutdown()
+
+def hub_system_shutdown() -> None:
+    lib.hub_system_shutdown()
+
+def hub_imu_init() -> pbio_error:
+    return lib.hub_imu_init()
+def hub_imu_get_acceleration() -> Tuple[float, float, float]:
+    accel = ffi.new("float[3]")
+    lib.hub_imu_get_acceleration(accel)
+    return accel[0], accel[1], accel[2]
+def hub_imu_get_angular_velocity() -> Tuple[float, float, float]:
+    angv = ffi.new("float[3]")
+    lib.hub_imu_get_angular_velocity(angv)
+    return angv[0], angv[1], angv[2] 
+def hub_imu_get_temperature() -> float:
+    return lib.hub_imu_get_temperature()
+
+def hub_display_orientation(up) -> pbio_error:
+    return lib.hub_display_orientation(up)
+def hub_display_off() -> pbio_error:
+    return lib.hub_display_off()
+def hub_display_pixel(row, column, brightness) -> pbio_error:
+    return lib.hub_display_pixel(row, column, brightness)
+#ToDo: pbio_error_t hub_display_image(uint8_t* image);
+def hub_display_number(num: int) -> pbio_error:
+    return lib.hub_display_number(num)
+def hub_display_char(c: str) -> pbio_error:
+    return lib.hub_display_char(c.encode())
+def hub_display_text(text: str, on: int, off: int) -> pbio_error:
+    return lib.hub_display_text(text.encode(), on, off)
+def hub_display_text_scroll(text: str, delay: int) -> pbio_error:
+    return lib.hub_display_text_scroll(text.encode(), delay)
+
+def hub_light_on_hsv(h: int, s: int, v:int) -> pbio_error:
+    hsv = ffi.new("pbio_color_hsv_t *")
+    hsv.h = h
+    hsv.s = s
+    hsv.v = v
+    return lib.hub_light_on_hsv(hsv)
+def hub_light_on_color(color: pbio_color) -> pbio_error:
+    return lib.hub_light_on_color(color)
+def hub_light_off() -> pbio_error:
+    return lib.hub_light_off()
+
+def hub_speaker_set_volume(volume: int) -> None:
+    lib.hub_speaker_set_volume(volume)
+def hub_speaker_play_tone(frequency: int, duration: int) -> None:
+    lib.hub_speaker_play_tone(frequency, duration)
+def hub_speaker_stop() -> None:
+    lib.hub_speaker_stop()
+
+def hub_battery_get_voltage() -> int:
+    return lib.hub_battery_get_voltage()
+def hub_battery_get_current() -> int:
+    return lib.hub_battery_get_current()
+
+def hub_button_is_pressed(button: hub_button) -> bool:
+    pressed = ffi.new("hub_button_t *")
+    error = lib.hub_button_is_pressed(pressed)
+    if error == pbio_error.SUCCESS:
+        return pressed[0] & button
+    else:
+        return False
+
+def pup_ultrasonic_sensor_get_device(port: pbio_port) -> ffi.CData:
+    pdev = lib.pup_ultrasonic_sensor_get_device(port)
+    return pdev if pdev != ffi.NULL else None
+def pup_ultrasonic_sensor_distance(pdev: ffi.CData) -> int:
+    return lib.pup_ultrasonic_sensor_distance(pdev)
+def pup_ultrasonic_sensor_presence(pdev: ffi.CData) -> bool:
+    return lib.pup_ultrasonic_sensor_presence(pdev)
+
+def pup_force_sensor_get_device(port: pbio_port) -> ffi.CData:
+    pdev = lib.pup_force_sensor_get_device(port)
+    return pdev if pdev != ffi.NULL else None
+def pup_force_sensor_force(pdev: ffi.CData) -> float:
+    return lib.pup_force_sensor_force(pdev)
+def pup_force_sensor_distance(pdev: ffi.CData) -> float:
+    return lib.pup_force_sensor_distance(pdev)
+def pup_force_sensor_pressed(pdev: ffi.CData, force: float) -> bool:
+    return lib.pup_force_sensor_pressed(pdev, force)
+def pup_force_sensor_touched(pdev: ffi.CData) -> bool:
+    return lib.pup_force_sensor_touched(pdev)
+
+
+def pup_color_sensor_get_device(port: pbio_port) -> ffi.CData:
+    pdev = lib.pup_color_sensor_get_device(port)
+    return pdev if pdev != ffi.NULL else None
+def pup_color_sensor_rgb(pdev: ffi.CData) -> Tuple[int, int, int]:
+    rgb = lib.pup_color_sensor_rgb(pdev)
+    if rgb != ffi.NULL:
+        return rgb.r, rgb.g, rgb.b
+    else:
+        return None
+def pup_color_sensor_color(pdev: ffi.CData, surface: bool) -> pbio_color:
+    hsv = lib.pup_color_sensor_color(pdev, surface)
+    if hsv != ffi.NULL:
+        return PBIO_COLOR_ENCODE(hsv.h, hsv.s, hsv.v)
+    else:
+        return None
+def pup_color_sensor_hsv(pdev: ffi.CData, surface: bool) -> Tuple[int, int, int]:
+    hsv = lib.pup_color_sensor_hsv(pdev, surface)
+    if hsv != ffi.NULL:
+        return hsv.h, hsv.s, hsv.v
+    else:
+        return None
+def pup_color_sensor_reflection(pdev: ffi.CData):
+    return lib.pup_color_sensor_reflection(pdev)
+def pup_color_sensor_ambient(pdev: ffi.CData):
+    return lib.pup_color_sensor_ambient(pdev)
+def pup_color_sensor_light_set(pdev: ffi.CData, bv1: int, bv2: int, bv3: int) -> pbio_error:
+    return lib.pup_color_sensor_light_set(pdev, bv1, bv2, bv3)
+def pup_color_sensor_light_on(pdev: ffi.CData) -> pbio_error:
+    return lib.pup_color_sensor_light_on(pdev)
+def pup_color_sensor_light_off(pdev: ffi.CData) -> pbio_error:
+    return lib.pup_color_sensor_light_off(pdev)
+#ToDo: pup_color_hsv_t *pup_color_sensor_detectable_colors(int32_t size, pup_color_hsv_t *colors);
+
+def pup_motor_get_device(port: pbio_port) -> ffi.CData:
+    return lib.pup_motor_get_device(port)
+def pup_motor_setup(motor: ffi.CData, positive_direction: pup_direction, reset_count: bool) -> pbio_error:
+    return lib.pup_motor_setup(motor, positive_direction, reset_count)
+def pup_motor_reset_count(motor: ffi.CData) -> pbio_error:
+    return lib.pup_motor_reset_count(motor)
+def pup_motor_get_count(motor: ffi.CData) -> int:
+    return lib.pup_motor_get_count(motor)
+def pup_motor_get_speed(motor: ffi.CData) -> int:
+    return lib.pup_motor_get_speed(motor)
+def pup_motor_set_speed(motor: ffi.CData, speed: int) -> pbio_error:
+    return lib.pup_motor_set_speed(motor, speed)
+def pup_motor_get_power(motor: ffi.CData) -> int:
+    return lib.pup_motor_get_power(motor)
+def pup_motor_set_power(motor: ffi.CData, power: int) -> pbio_error:
+    return lib.pup_motor_set_power(motor, power)
+def pup_motor_stop(motor: ffi.CData) -> pbio_error:
+    return lib.pup_motor_stop(motor)
+def pup_motor_brake(motor: ffi.CData) -> pbio_error:
+    return lib.pup_motor_brake(motor)
+def pup_motor_hold(motor: ffi.CData) -> pbio_error:
+    return lib.pup_motor_hold(motor)
+def pup_motor_is_stalled(motor: ffi.CData) -> bool:
+    return lib.pup_motor_is_stalled(motor)
+def pup_motor_set_duty_limit(motor: ffi.CData, duty_limit: int) -> int:
+    return lib.pup_motor_set_duty_limit(motor, duty_limit)
+def pup_motor_restore_duty_limit(motor: ffi.CData, old_value: int) -> None:
+    pup_motor_restore_duty_limit(motor, old_value)

libraspike-art-python-0.0.3/libraspike_art_python/ffi_build.py

@@ -0,0 +1,216 @@
+from cffi import FFI
+import subprocess
+from os import path
+
+LIB_SOURCE = './libraspike-art/'
+
+def clone_git():
+    return subprocess.run(['git', 'clone', 'https://github.com/ETrobocon/libraspike-art.git'], text=True,
+                          stdout=subprocess.PIPE).stdout.strip()
+
+def make_lib():
+    return subprocess.run(['make'], cwd=(LIB_SOURCE + 'build/obj-libraspike-art'), text=True,
+                          stdout=subprocess.PIPE).stdout.strip()
+
+ffibuilder = FFI()
+
+if not path.isdir(LIB_SOURCE):
+    clone_git()
+if not path.isfile(LIB_SOURCE + 'lib/libraspike-art.a'):
+    make_lib()
+
+# include header files for libraspike-art
+ffibuilder.set_source("_libraspike_art",
+    """
+#include "raspike_com.h"
+#include "raspike_protocol_api.h"
+#include "spike/pup/motor.h"
+#include "spike/pup/colorsensor.h"
+#include "spike/pup/forcesensor.h"
+#include "spike/pup/ultrasonicsensor.h"
+#include "spike/hub/system.h"
+#include "spike/hub/light.h"
+#include "spike/hub/imu.h"
+#include "spike/hub/display.h"
+#include "spike/hub/button.h"
+#include "spike/hub/battery.h"
+#include "spike/hub/speaker.h"
+    """,
+    include_dirs=[LIB_SOURCE + 'include/',
+                  LIB_SOURCE + 'drivers/include/',
+                  LIB_SOURCE + 'drivers/',
+                  LIB_SOURCE + 'external/libpybricks/lib/pbio/include/'],
+    extra_link_args=[],
+    library_dirs=[LIB_SOURCE + 'lib/'],
+    libraries=['raspike-art'])
+
+# descrption of C functions to invoke from Python
+ffibuilder.cdef(
+    """
+/* raspike_com.h */
+struct _RPComDescriptor;
+typedef struct _RPComDescriptor RPComDescriptor;
+RPComDescriptor *raspike_open_usb_communication(const char *device_name);
+
+/* raspike_protocol_api.h */
+int raspike_prot_init(RPComDescriptor *desc);
+int raspike_prot_receive(void);
+int raspike_prot_shutdown(void);
+
+/* pbio/error.h */
+typedef enum {
+    PBIO_SUCCESS,               /**< No error */
+    PBIO_ERROR_FAILED,          /**< Unspecified error (used when no other error code fits) */
+    PBIO_ERROR_INVALID_ARG,     /**< Invalid argument */
+    PBIO_ERROR_IO,              /**< General I/O error */
+    PBIO_ERROR_BUSY,            /**< Device or resource is busy */
+    PBIO_ERROR_NO_DEV,          /**< Device is not connected */
+    PBIO_ERROR_NOT_IMPLEMENTED, /**< Feature is not yet implemented */
+    PBIO_ERROR_NOT_SUPPORTED,   /**< Feature is not supported on this device */
+    PBIO_ERROR_AGAIN,           /**< Function should be called again later */
+    PBIO_ERROR_INVALID_OP,      /**< Operation is not permitted in the current state */
+    PBIO_ERROR_TIMEDOUT,        /**< The operation has timed out */
+    PBIO_ERROR_CANCELED         /**< The operation was canceled */
+} pbio_error_t;
+
+/* pbio/port.h */
+typedef enum {
+    PBIO_PORT_ID_A = 'A', /**< I/O port labeled as "A" */
+    PBIO_PORT_ID_B = 'B', /**< I/O port labeled as "B" */
+    PBIO_PORT_ID_C = 'C', /**< I/O port labeled as "C" */
+    PBIO_PORT_ID_D = 'D', /**< I/O port labeled as "D" */
+    PBIO_PORT_ID_E = 'E', /**< I/O port labeled as "C" */
+    PBIO_PORT_ID_F = 'F', /**< I/O port labeled as "F" */
+} pbio_port_id_t;
+
+/* pbio/color.h */
+typedef enum {...} pbio_color_t;
+typedef struct {
+    /** The hue component. 0 to 359 degrees. */
+    uint16_t h;
+    /** The saturation component. 0 to 100 percent. */
+    uint8_t s;
+    /** The value component. 0 to 100 percent. */
+    uint8_t v;
+} pbio_color_hsv_t;
+
+/* pbio/button.h */
+typedef enum _pbio_button_flags_t {
+    PBIO_BUTTON_LEFT_DOWN  = 1 << 1,
+    PBIO_BUTTON_DOWN       = 1 << 2,
+    PBIO_BUTTON_RIGHT_DOWN = 1 << 3,
+    PBIO_BUTTON_LEFT       = 1 << 4,
+    PBIO_BUTTON_CENTER     = 1 << 5,
+    PBIO_BUTTON_RIGHT      = 1 << 6,
+    PBIO_BUTTON_LEFT_UP    = 1 << 7,
+    PBIO_BUTTON_UP         = 1 << 8,
+    PBIO_BUTTON_RIGHT_UP   = 1 << 9,
+} pbio_button_flags_t;
+
+/* pbio/servo.h */
+struct _pbio_servo_t;
+typedef struct _pbio_servo_t pbio_servo_t;
+
+/* spike/hub/system.h */
+void hub_system_shutdown(void);
+
+/* spike/hub/imu.h */
+pbio_error_t hub_imu_init(void);
+void hub_imu_get_acceleration(float accel[3]);
+void hub_imu_get_angular_velocity(float angv[3]);
+float hub_imu_get_temperature(void);
+
+/* spike/hub/display.h */
+pbio_error_t hub_display_orientation(uint8_t up);
+pbio_error_t hub_display_off(void);
+pbio_error_t hub_display_pixel(uint8_t row, uint8_t column, uint8_t brightness);
+pbio_error_t hub_display_image(uint8_t* image);
+pbio_error_t hub_display_number(const int8_t num);
+pbio_error_t hub_display_char(const char c);
+pbio_error_t hub_display_text(const char* text, uint32_t on, uint32_t off);
+pbio_error_t hub_display_text_scroll(const char* text, uint32_t delay);
+
+/* spike/hub/light.h */
+pbio_error_t hub_light_on_hsv(const pbio_color_hsv_t *hsv);
+pbio_error_t hub_light_on_color(pbio_color_t color);
+pbio_error_t hub_light_off(void);
+
+/* spike/hub/speaker.h */
+void hub_speaker_set_volume(uint8_t volume);
+void hub_speaker_play_tone(uint16_t frequency, int32_t duration);
+void hub_speaker_stop(void);
+
+/* spike/hub/battery.h */
+uint16_t hub_battery_get_voltage(void);
+uint16_t hub_battery_get_current(void);
+
+/* spike/hub/button.h */
+typedef enum _hub_button_t {
+   HUB_BUTTON_LEFT   = PBIO_BUTTON_LEFT,
+   HUB_BUTTON_CENTER = PBIO_BUTTON_CENTER,
+   HUB_BUTTON_RIGHT  = PBIO_BUTTON_RIGHT,
+   HUB_BUTTON_BT     = PBIO_BUTTON_RIGHT_UP,
+} hub_button_t;
+pbio_error_t hub_button_is_pressed(hub_button_t *pressed);
+
+/* spike/pup_device.h */
+struct _pup_device_t;
+typedef struct _pup_device_t pup_device_t;
+
+/* spike/pup/ultrasonicsensor.h */
+pup_device_t *pup_ultrasonic_sensor_get_device(pbio_port_id_t port);
+int32_t pup_ultrasonic_sensor_distance(pup_device_t *pdev);
+bool pup_ultrasonic_sensor_presence(pup_device_t *pdev);
+
+/* spike/pup/forcesensor.h */
+pup_device_t *pup_force_sensor_get_device(pbio_port_id_t port);
+float pup_force_sensor_force(pup_device_t *pdev);
+float pup_force_sensor_distance(pup_device_t *pdev);
+bool pup_force_sensor_pressed(pup_device_t *pdev, float force);
+bool pup_force_sensor_touched(pup_device_t *pdev);
+
+/* spike/pup/colorsensor.h */
+pup_device_t *pup_color_sensor_get_device(pbio_port_id_t port);
+typedef struct {
+  uint16_t r, g, b;
+} pup_color_rgb_t;
+pup_color_rgb_t pup_color_sensor_rgb(pup_device_t *pdev);
+typedef pbio_color_hsv_t pup_color_hsv_t;
+pup_color_hsv_t pup_color_sensor_color(pup_device_t *pdev, bool surface);
+pup_color_hsv_t pup_color_sensor_hsv(pup_device_t *pdev, bool surface);
+int32_t pup_color_sensor_reflection(pup_device_t *pdev);
+int32_t pup_color_sensor_ambient(pup_device_t *pdev);
+pbio_error_t pup_color_sensor_light_set(pup_device_t *pdev, 
+                                        int32_t bv1, int32_t bv2, int32_t bv3);
+pbio_error_t pup_color_sensor_light_on(pup_device_t *pdev);
+pbio_error_t pup_color_sensor_light_off(pup_device_t *pdev);
+pup_color_hsv_t *pup_color_sensor_detectable_colors(int32_t size, pup_color_hsv_t *colors);
+
+/* /spike/pup/motor.h */
+typedef pbio_servo_t pup_motor_t;
+typedef enum {
+    PBIO_DIRECTION_CLOCKWISE,         /**< Positive means clockwise. */
+    PBIO_DIRECTION_COUNTERCLOCKWISE,  /**< Positive means counterclockwise. */
+} pbio_direction_t;
+typedef enum {
+  PUP_DIRECTION_CLOCKWISE        = PBIO_DIRECTION_CLOCKWISE,
+  PUP_DIRECTION_COUNTERCLOCKWISE = PBIO_DIRECTION_COUNTERCLOCKWISE,
+} pup_direction_t;
+pup_motor_t *pup_motor_get_device(pbio_port_id_t port);
+pbio_error_t pup_motor_setup(pup_motor_t *motor, pup_direction_t positive_direction, bool reset_count);
+pbio_error_t pup_motor_reset_count(pup_motor_t *motor);
+int32_t pup_motor_get_count(pup_motor_t *motor);
+int32_t pup_motor_get_speed(pup_motor_t *motor);
+pbio_error_t pup_motor_set_speed(pup_motor_t *motor, int speed);
+int32_t pup_motor_get_power(pup_motor_t *motor);
+pbio_error_t pup_motor_set_power(pup_motor_t *motor, int power);
+pbio_error_t pup_motor_stop(pup_motor_t *motor);
+pbio_error_t pup_motor_brake(pup_motor_t *motor);
+pbio_error_t pup_motor_hold(pup_motor_t *motor);
+bool pup_motor_is_stalled(pup_motor_t *motor);
+int32_t pup_motor_set_duty_limit(pup_motor_t *motor, int duty_limit);
+void pup_motor_restore_duty_limit(pup_motor_t *motor, int old_value);
+    """)
+
+if __name__ == "__main__":
+    ffibuilder.compile(verbose=True)

libraspike-art-python-0.0.3/libraspike_art_python/version.py

@@ -0,0 +1 @@
+__version__ = '0.0.3'

libraspike-art-python-0.0.3/libraspike_art_python.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: libraspike-art-python
+Version: 0.0.3
+Summary: Python CFFI Bindings for libraspike-art
+Author: Wataru Taniguchi
+Author-email: wataru@taniguchifamily.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+## Python CFFI Bindings for libraspike-art
+
+# Installation
+
+Enable use of libraspike-art by following the direction [here](https://github.com/ETrobocon/libraspike-art/tree/main).
+
+If you are on a modern Linux you will probably want to create a venv:
+
+    python3 -m venv vpython3
+    source vpython3/bin/activate
+
+or:
+
+    pypy3 -m venv vpypy3
+    source vpypy3/bin/activate
+
+Build the bindings and install libraspike-art-python package:
+
+    pip install libraspike-art-python

libraspike-art-python-0.0.3/libraspike_art_python.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+libraspike_art_python/__init__.py
+libraspike_art_python/ffi_build.py
+libraspike_art_python/version.py
+libraspike_art_python.egg-info/PKG-INFO
+libraspike_art_python.egg-info/SOURCES.txt
+libraspike_art_python.egg-info/dependency_links.txt
+libraspike_art_python.egg-info/requires.txt
+libraspike_art_python.egg-info/top_level.txt

libraspike-art-python-0.0.3/libraspike_art_python.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

libraspike-art-python-0.0.3/libraspike_art_python.egg-info/requires.txt

@@ -0,0 +1 @@
+cffi>=1.17.1

libraspike-art-python-0.0.3/libraspike_art_python.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+_libraspike_art
+libraspike_art_python

libraspike-art-python-0.0.3/pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = [
+    "setuptools",
+    "wheel",
+]
+build-backend = "setuptools.build_meta"

libraspike-art-python-0.0.3/setup.cfg

@@ -0,0 +1,27 @@
+[metadata]
+name = libraspike-art-python
+version = attr: libraspike_art_python.version.__version__
+description = Python CFFI Bindings for libraspike-art
+long_description = file: README.md
+long_description_content_type = text/markdown
+license = MIT
+license_file = LICENSE
+author = Wataru Taniguchi
+author_email = wataru@taniguchifamily.com
+classifiers = 
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: Implementation :: CPython
+	Programming Language :: Python :: Implementation :: PyPy
+
+[options]
+packages = libraspike_art_python
+setup_requires = 
+	cffi >= 1.17.1
+	setuptools
+install_requires = 
+	cffi >= 1.17.1
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

libraspike-art-python-0.0.3/setup.py

@@ -0,0 +1,5 @@
+from setuptools import setup
+
+setup(
+    cffi_modules=["libraspike_art_python/ffi_build.py:ffibuilder"]
+)