riffpi 0.2.4__py3-none-any.whl

riffpi/__init__.py

@@ -0,0 +1,3 @@
+"""RiffPi: control daemon for Kleag's MFX guitar multi-effect pedal."""
+
+__version__ = "0.2.4"

riffpi/cli.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""Command-line entry point for the `riffpi` console script."""
+import argparse
+
+from .daemon import run as run_daemon
+from .service import install_service, uninstall_service
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="riffpi", description="RiffPi guitar multi-effect pedal daemon."
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser("run", help="Run the RiffPi daemon (default if no command is given)")
+    subparsers.add_parser(
+        "install-service", help="Install, enable, and start the riffpi systemd --user service"
+    )
+    subparsers.add_parser(
+        "uninstall-service", help="Stop, disable, and remove the riffpi systemd --user service"
+    )
+
+    args = parser.parse_args()
+
+    if args.command in (None, "run"):
+        run_daemon()
+    elif args.command == "install-service":
+        install_service()
+    elif args.command == "uninstall-service":
+        uninstall_service()
+
+
+if __name__ == "__main__":
+    main()

riffpi/daemon.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+import logging
+import queue
+import subprocess
+import threading
+import time
+from signal import pause
+
+import adafruit_ads1x15.ads1115 as ADS
+import board
+import busio
+import mido
+from adafruit_mcp230xx.mcp23017 import MCP23017
+from digitalio import Direction
+
+from .expression_pedal import ExpressionPedal
+from .joystick import Joystick
+from .keypad import KeyPad
+from .mcp_button import MCPButton
+from .mcp_led import MCPLed
+from .rotary_encoder import RotaryEncoder
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO, force=True)
+
+# --- CONFIGURATION ---
+SWITCH_CC = 64  # MIDI CC number for effect toggles
+ENCODER_CC_NUMBERS = [20, 21, 22, 23]  # MIDI CC for encoders
+
+# Guitarix preset navigation settings
+PRESET_BANK_CC = 32  # MIDI CC for preset bank selection
+PRESET_CHANGE_CC = 0  # MIDI CC for preset change
+
+# Keypad/Power LED (Keep original GPIO)
+POWER_LED_PIN = 11
+
+# MCP23017 1 Button/LED Map
+BUTTON_PINS_MAP = [(1, 14), (1, 15), (1, 6), (1, 7)] # B6, B7, A6, A7
+LED_PINS_MAP = [(1, 13), (1, 12), (1, 4), (1, 5)] # B5, B4, A4, A5
+
+# --- MIDI/ENCODER LOGIC ---
+effect_states = [False] * 4 # Global state for MIDI toggles
+
+# Guitarix preset navigation
+current_preset_bank = 0  # Current preset bank (0-3 for A-D)
+
+# Index into `buttons` of the preset encoder's push button (the last encoder). `buttons`
+# is [foot switches...] + [encoder buttons...], so this is only known once both are built;
+# it's set in main() before any button-polling thread starts.
+PRESET_ENCODER_INDEX = None
+
+def send_cc(cc, value):
+    msg = mido.Message('control_change', control=cc, value=value)
+    midi_out.send(msg)
+
+def set_preset_bank(bank_index):
+    """Set the current preset bank (0-3 corresponding to A-D)"""
+    global current_preset_bank
+    if 0 <= bank_index <= 3:
+        current_preset_bank = bank_index
+        # Send MIDI messages to change bank
+        reset()  # Reset all effects
+        send_cc(PRESET_BANK_CC, bank_index)
+        send_cc(PRESET_CHANGE_CC, 0)  # Select first preset in bank
+        logger.info(f"Switched to preset bank {chr(ord('A') + bank_index)}")
+
+def change_preset(delta):
+    """Change preset by delta amount (positive for next, negative for previous)"""
+    # In a real implementation, we would need to know the current preset
+    # For now, we'll simulate changing presets
+    # This would require querying guitarix for actual preset info
+    logger.info(f"Changing preset by {delta}")
+
+# --- BUTTON HANDLERS ---
+def handle_effect_toggle(idx):
+    # Special handling for the preset encoder (last one)
+    if idx == PRESET_ENCODER_INDEX:  # Last encoder is our special preset encoder
+        # Cycle through banks A-D (0-3) on click
+        new_bank = (current_preset_bank + 1) % 4
+        set_preset_bank(new_bank)
+    else:
+        # Standard effect toggle behavior
+        # logger.info(f"handle_effect_toggle {idx}")
+        effect_states[idx] = not effect_states[idx]
+        if leds[idx] is not None:
+            leds[idx].value = effect_states[idx]
+        send_cc(SWITCH_CC + idx, 127 if effect_states[idx] else 0)
+        # logger.info(f"Button {idx} pressed. State: {effect_states[idx]}")
+
+
+def reset():
+    logger.info("reset")
+    for i in range(len(effect_states)):
+        effect_states[i] = False
+        if leds[i] is not None:
+            leds[i].value = False
+
+# --- THREADS ---
+
+def midi_input_thread():
+    # logger.info("Listening for incoming MIDI messages...")
+    for msg in midi_in:
+        if msg.type == 'control_change':
+            # logger.info(f"midi_input_thread received: {msg}")
+            # Update Effect States (SWITCH_CC)
+            if SWITCH_CC <= msg.control <= SWITCH_CC + 3:
+                idx = msg.control - SWITCH_CC
+                new_state = msg.value > 0
+
+                # Only update if the state actually changed to avoid flickering
+                if effect_states[idx] != new_state:
+                    effect_states[idx] = new_state
+                    if leds[idx] is not None:
+                        leds[idx].value = new_state
+                # logger.debug(f"Sync: LED {idx} set to {new_state} via MIDI")
+            # Update Encoder CC Value if received externally
+            if msg.control in ENCODER_CC_NUMBERS:
+                for enc in encoders:
+                    if enc.cc == msg.control:
+                        enc.update_from_midi(msg.value)
+                        break
+
+def buttons_thread():
+    while True:
+        # MCP Button Scan
+        for i, btn in enumerate(buttons):
+            btn.check(i)
+        time.sleep(0.01)
+
+# --- Main Thread Logic ---
+def main_thread_loop():
+    # logger.info("\n[Main Thread] Starting queue processor...")
+
+    while True:
+        while not task_queue.empty():
+            try:
+                func, args = task_queue.get(timeout=0.1)
+                if func == "reset":
+                    reset(*args)
+
+                task_queue.task_done()
+            except queue.Empty:
+                # This happens if the queue is temporarily empty
+                pass
+        time.sleep(0.001)
+
+def link_pipewire_ports():
+    try:
+        # Link Script -> Guitarix
+        subprocess.run(
+            ['pw-link', 'Midi-Bridge:RtMidiOut Client:(capture_0) KleagMFX', 'gx_head_amp:midi_in_1'],
+            check=False,
+        )
+        # Link Guitarix -> Script
+        subprocess.run(
+            ['pw-link', 'gx_head_amp:midi_out_1', 'Midi-Bridge:RtMidiIn Client:(playback_0) KleagMFX'],
+            check=False,
+        )
+        logger.info("PipeWire MIDI ports linked successfully.")
+    except Exception as e:
+        logger.error(f"Failed to link PipeWire ports: {e}")
+
+
+def run():
+    """Initialize hardware/MIDI and run the RiffPi daemon until interrupted."""
+    global midi_out, midi_in, buttons, leds, encoders, task_queue, PRESET_ENCODER_INDEX
+
+    # --- MIDI SETUP ---
+    midi_out = mido.open_output('KleagMFX', virtual=True)
+    midi_in = mido.open_input('KleagMFX', virtual=True)
+
+    # --- HARDWARE INITIALIZATION ---
+    i2c = busio.I2C(board.SCL, board.SDA)
+    i2c_lock = threading.Lock()
+
+    # ADS1115 for Joystick (kept as requested)
+    ads = ADS.ADS1115(i2c)
+
+    # MCP23017
+    mcp1 = MCP23017(i2c, address=0x20)
+    mcp2 = MCP23017(i2c, address=0x21)
+    MCP_MAP = {1: mcp1, 2: mcp2}
+
+    # Power LED
+    power_led = mcp1.get_pin(POWER_LED_PIN)
+    power_led.direction = Direction.OUTPUT
+    power_led.value = True
+
+    # Foot switches and their associated LED
+    buttons = [MCPButton(MCP_MAP[mcp], pin) for mcp, pin in BUTTON_PINS_MAP]
+    leds = [MCPLed(MCP_MAP[mcp], pin) for mcp, pin in LED_PINS_MAP]
+
+    # Board label: as visible on physical pedalboard: mcp number and mcp pins map
+    # RotaryEncoder4: 1st from left to right above : mcp n°2 clk B4=12 dt B3=11 sw B2=10
+    # RotaryEncoder3: 2nd from left to right above : mcp n°2 clk B7=15 dt B6=14 sw B5=13
+    # RotaryEncoder2: 3rd from left to right above : mcp n°1 clk A3=3  dt A2=2  sw A1=1
+    # RotaryEncoder1: 4th from left to right above : mcp n°1 clk A0=0, dt B0=8, sw B1=9
+    # --- ROTARY ENCODERS ---
+    encoder_configs = [
+        (mcp1, 0,   8,  9, "Encoder 0", ENCODER_CC_NUMBERS[0]), # CC 20
+        (mcp1, 3,   2,  1, "Encoder 1", ENCODER_CC_NUMBERS[1]), # CC 21
+        (mcp2, 15, 14, 13, "Encoder 2", ENCODER_CC_NUMBERS[2]), # CC 22
+        (mcp2, 12, 11, 10, "Encoder 3", ENCODER_CC_NUMBERS[3]), # CC 23
+    ]
+    encoders = []
+    for i, (mcp, clk_pin, dt_pin, sw_pin, name, cc) in enumerate(encoder_configs):
+        # Make the last encoder (index 3) a preset encoder
+        is_preset = (i == len(encoder_configs) - 1)
+        encoder = RotaryEncoder(midi_out, mcp, name, clk_pin, dt_pin, sw_pin, cc, is_preset)
+        encoders.append(encoder)
+        buttons.append(encoder.button)
+        effect_states.append(False)
+        leds.append(None)
+        if is_preset:
+            PRESET_ENCODER_INDEX = len(buttons) - 1
+
+    for i, btn in enumerate(buttons):
+        btn.when_pressed = handle_effect_toggle
+
+
+    link_pipewire_ports()
+    task_queue = queue.Queue()
+    joystick = Joystick(ads, mcp1, lock=i2c_lock)
+    keypad = KeyPad(task_queue, midi_out, mcp2)
+    pedal = ExpressionPedal(midi_out, ads, lock=i2c_lock, channel=ADS.P2)
+
+    threading.Thread(target=midi_input_thread, daemon=True).start()
+    threading.Thread(target=buttons_thread, daemon=True).start()
+    threading.Thread(target=joystick.poll_joystick, daemon=True).start()
+    threading.Thread(target=keypad.keypad_thread, daemon=True).start()
+    threading.Thread(target=pedal.poll, daemon=True).start()
+
+    for encoder in encoders:
+        threading.Thread(target=encoder.poll_thread, daemon=True).start()
+    threading.Thread(target=main_thread_loop, daemon=True).start()
+
+    logger.info("Kleag's Multi-effect daemon running.")
+    try:
+        pause()
+    except KeyboardInterrupt:
+        logger.info("Kleag's Multi-effect daemon terminating through keyboard interrupt.")
+
+
+# === Main ===
+if __name__ == "__main__":
+    run()

riffpi/expression_pedal.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+import logging
+import statistics
+import threading
+import time
+from signal import pause
+
+import adafruit_ads1x15.ads1115 as ADS
+import board
+import busio
+import mido
+from adafruit_ads1x15.analog_in import AnalogIn
+
+# The actual voltages measured at the physical limits of the pedal
+V_MIN = 0.006
+V_MAX = 2.768
+MIDI_CC_NUMBER = 24
+
+logger = logging.getLogger(__name__)
+
+class ExpressionPedal:
+    def __init__(self, midi_out, ads: ADS.ADS1115, lock: threading.Lock, channel=ADS.P2, gain=1, v_ref=3.3):
+        self.midi_out = midi_out
+        # --- HARDWARE INITIALIZATION ---
+        self.ads = ads
+        self.lock = lock
+        self.chan = AnalogIn(self.ads, channel)
+        self.ads.data_rate = 860
+
+        # 2. Configuration
+        self.v_ref = v_ref
+        self.ads.gain = gain  # Gain 1 = +/- 4.096V
+
+        self._current_midi_val = -1
+        self._running = False
+        self.window_size = 5
+        self.readings = [0] * self.window_size
+
+
+    def poll(self):
+        self._running = True
+        while self._running:
+            with self.lock:
+                voltage = self.chan.voltage
+
+            # Map voltage to 0-127 (MIDI Range)
+            raw_percent = ((voltage - V_MIN) * 127) / (V_MAX - V_MIN)
+            clamped = max(0, min(127, int(raw_percent)))
+
+            # Smoothing
+            self.readings.pop(0)
+            self.readings.append(clamped)
+            smoothed_val = int(statistics.median(self.readings))
+            logger.debug(f"Pedal: {voltage};\t{clamped};\t{smoothed_val}")
+
+            # Only send MIDI message if the value has actually changed
+            if abs(smoothed_val - self._current_midi_val) >= 4:
+                self._current_midi_val = smoothed_val
+                self.send_midi(smoothed_val)
+
+            time.sleep(0.01)
+
+    def send_midi(self, value):
+        msg = mido.Message('control_change', control=MIDI_CC_NUMBER, value=value)
+        self.midi_out.send(msg)
+        logger.debug(f"Pedal: Sent MIDI CC {MIDI_CC_NUMBER}: {value}")
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.DEBUG)
+    i2c = busio.I2C(board.SCL, board.SDA)
+    i2c_lock = threading.Lock()
+    ads = ADS.ADS1115(i2c)
+    # --- MIDI SETUP ---
+    # This creates a virtual MIDI port that shows up in patchage/qjackctl
+    midi_out = mido.open_output('ExpressionPedalPort', virtual=True)
+    logger.info("Virtual MIDI port 'ExpressionPedalPort' created.")
+
+    pedal = ExpressionPedal(midi_out, ads, i2c_lock)
+
+    t = threading.Thread(target=pedal.poll, daemon=True)
+    t.start()
+
+    logger.info("ExpressionPedal to MIDI running. Press Ctrl+C to stop.")
+    try:
+        pause()
+    except KeyboardInterrupt:
+        logger.info("Shutting down...")

riffpi/joystick.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+import logging
+import math
+import statistics
+import threading
+import time
+from signal import pause
+
+import adafruit_ads1x15.ads1115 as ADS
+import board
+import busio
+import uinput
+from adafruit_ads1x15.analog_in import AnalogIn
+from adafruit_mcp230xx.mcp23017 import MCP23017
+from digitalio import Direction, Pull
+from rich.console import Console
+
+logger = logging.getLogger(__name__)
+
+
+class Joystick:
+    # --- CONFIGURATION ---
+    # Maximum mouse speed (pixels/s) reached only at full deflection (|x|/|y| == 1.0).
+    SENSITIVITY = 30.0
+    # Fraction of travel (0.0-1.0) around center treated as "not moved". Noise is filtered
+    # separately (SMOOTHING_WINDOW), so this only needs to absorb residual jitter.
+    DEAD_ZONE = 0.02
+    # Exponent applied to the (post-dead-zone) normalized deflection before scaling by
+    # SENSITIVITY. Must be > 1: with an exponent < 1 the curve has infinite slope at 0, so
+    # speed jumps immediately once past the dead zone (the "dead then jumpy" feel this
+    # replaces). >1 makes the slope start at 0 and ramp up smoothly, so small deflections
+    # give fine/slow motion (useful for nudging a Guitarix knob) and only large deflections
+    # approach SENSITIVITY. Raise it further (e.g. 3.0-4.0) for even finer low-end control.
+    POWER_CURVE = 2.5
+    # Number of raw voltage samples averaged (median) per axis to smooth out ADC/electrical
+    # noise from the joystick's low-cost potentiometers before it reaches the dead zone/curve.
+    SMOOTHING_WINDOW = 5
+    LOOP_DELAY = 0.01  # General loop delay (seconds)
+
+    def __init__(self, ads: ADS.ADS1115, mcp: MCP23017, lock: threading.Lock, debug: bool = False):
+        self.debug = debug
+        # --- HARDWARE INITIALIZATION ---
+        self.ads = ads
+        self.lock = lock
+        # Use P0 and P1 for Joystick X and Y
+        self.joystick_x_axis = AnalogIn(ads, ADS.P0)
+        self.joystick_y_axis = AnalogIn(ads, ADS.P1)
+
+
+        # --- JOYSTICK/MOUSE SETUP (retained ADS1115 usage) ---
+        events = (uinput.REL_X, uinput.REL_Y, uinput.BTN_LEFT, uinput.BTN_RIGHT, uinput.BTN_MIDDLE)
+        try:
+            self.device = uinput.Device(events)
+        except Exception as e:
+            logger.error(
+                "UInput device creation failed. Check permissions (sudo or your user "
+                f"in the input group setup with udev). Error: {e}"
+            )
+            exit(1)
+
+        self.joystick_sw = mcp.get_pin(10)  # B2
+        self.joystick_sw.direction = Direction.INPUT
+        self.joystick_sw.pull = Pull.UP
+        self.last_switch_state = True # True = not pressed
+        self.last_x = 0
+        self.last_y = 0
+        self.spike_count_x = 0
+        self.spike_count_y = 0
+        self.console = Console()
+
+        self.x_readings = [0.0] * Joystick.SMOOTHING_WINDOW
+        self.y_readings = [0.0] * Joystick.SMOOTHING_WINDOW
+        self.x_center, self.y_center = self.calibrate_center()
+
+    def calibrate_center(self, samples: int = 50, delay: float = 0.01):
+        """Measure the at-rest center voltage per axis instead of assuming a fixed value.
+
+        Assumes the joystick is untouched (spring-centered) when this runs, i.e. at
+        startup before the poll loop begins. Uses the median to stay robust if it's
+        bumped once during the sampling window.
+        """
+        x_samples = []
+        y_samples = []
+        for _ in range(samples):
+            with self.lock:
+                x_samples.append(self.joystick_x_axis.voltage)
+                y_samples.append(self.joystick_y_axis.voltage)
+            time.sleep(delay)
+        x_center = statistics.median(x_samples)
+        y_center = statistics.median(y_samples)
+        logger.info(f"Joystick calibrated center: x={x_center:.3f}V, y={y_center:.3f}V")
+        return x_center, y_center
+
+    def read_joystick(self):
+        """Return normalized X, Y values in range -1.0 .. +1.0 using ADS1115."""
+        with self.lock:
+            raw_x = self.joystick_x_axis.voltage
+            raw_y = self.joystick_y_axis.voltage
+
+        self.x_readings.pop(0)
+        self.x_readings.append(raw_x)
+        self.y_readings.pop(0)
+        self.y_readings.append(raw_y)
+        smoothed_x = statistics.median(self.x_readings)
+        smoothed_y = statistics.median(self.y_readings)
+
+        x = (smoothed_x - self.x_center) / self.x_center
+        y = (smoothed_y - self.y_center) / self.y_center
+        return max(-1, min(1, x)), max(-1, min(1, y))
+
+    def calculate_speed(self, x, y):
+        # --- 1. Glitch Guard Logic ---
+        # If the reading is exactly 1.0 (or -1.0) and we were just at 0
+        if abs(x) > 0.99 and abs(self.last_x) < 0.1:
+            self.spike_count_x += 1
+            if self.spike_count_x < 2: # Ignore the first frame of a max-value spike
+                x = 0
+        else:
+            self.spike_count_x = 0
+
+        if abs(y) > 0.99 and abs(self.last_y) < 0.1:
+            self.spike_count_y += 1
+            if self.spike_count_y < 2:
+                y = 0
+        else:
+            self.spike_count_y = 0
+
+        self.last_x, self.last_y = x, y
+
+        # --- 2. Axial Dead Zone Logic ---
+        # X Axis
+        if abs(x) < Joystick.DEAD_ZONE:
+            dx = 0
+        else:
+            norm_x = (abs(x) - Joystick.DEAD_ZONE) / (1.0 - Joystick.DEAD_ZONE)
+            dx = math.pow(norm_x, Joystick.POWER_CURVE) * math.copysign(Joystick.SENSITIVITY, x)
+
+        # Y Axis
+        if abs(y) < Joystick.DEAD_ZONE:
+            dy = 0
+        else:
+            norm_y = (abs(y) - Joystick.DEAD_ZONE) / (1.0 - Joystick.DEAD_ZONE)
+            dy = math.pow(norm_y, Joystick.POWER_CURVE) * math.copysign(Joystick.SENSITIVITY, y)
+
+        return dx, dy
+
+    def poll_joystick(self):
+        while True:
+            # 1. Joystick Analog Control (Reads from ADS1115)
+            x, y = self.read_joystick()
+            # logger.debug(f"joystick {x},{y}")
+            dx, dy = self.calculate_speed(x, y)
+            if dx != 0 or dy != 0:
+                # logger.debug(f"joystick move: {dx},{dy}")
+                try:
+                    self.device.emit(uinput.REL_X, int(-dx))
+                    self.device.emit(uinput.REL_Y, int(-dy))
+                except NameError as e: # Handle case where uinput device failed to initialize
+                    logger.warn(f"Joystick.poll_joystick uinput failure: {e}")
+
+            # 2. Joystick Button (Reads from MCP23017)
+            switch_state = self.joystick_sw.value  # True = not pressed
+            if switch_state != self.last_switch_state:
+                uinput_state = 1 if not switch_state else 0
+                # logger.debug(f"joystick button new state: {uinput_state}")
+                try:
+                    self.device.emit(uinput.BTN_MIDDLE, uinput_state)
+                except NameError as e:
+                    logger.error(f"Name error in joystick button: {e}")
+
+            self.last_switch_state = switch_state
+            if self.debug:
+                status_text = (
+                    f"[bold blue]X:[/bold blue] {self.joystick_x_axis.voltage:+5.2f}V ({x:+5.2f}) [dim]dx={dx:+6.2f}[/dim] | "
+                    f"[bold magenta]Y:[/bold magenta] {self.joystick_y_axis.voltage:+5.2f}V ({y:+5.2f}) [dim]dy={dy:+6.2f}[/dim] | "
+                    f"[bold yellow]Switch:[/bold yellow] {'Released' if switch_state else 'Pressed'}"
+                )
+                self.console.print(status_text, end="\r")
+            time.sleep(Joystick.LOOP_DELAY)
+
+
+# === Main ===
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.DEBUG)
+        # --- HARDWARE INITIALIZATION ---
+    i2c = busio.I2C(board.SCL, board.SDA)
+    i2c_lock = threading.Lock()
+
+    # ADS1115 for Joystick (kept as requested)
+    ads = ADS.ADS1115(i2c)
+
+    mcp = MCP23017(i2c, address=0x20)
+
+    joystick = Joystick(ads, mcp, lock=i2c_lock, debug=True)
+    threading.Thread(target=joystick.poll_joystick, daemon=True).start()
+
+    logger.info("Joystick daemon running.")
+    pause()