fix debounce. add handling of different buttons. implement combined middle mouse and scroll lock button.

firmware/include/config.h

 #define INVERT_MOUSE_Y_AXIS true
 #define DEFAULT_MOUSE_SENSITIVITY PMW_CPI_TO_SENSE(500)
 
+#define INVERT_SCROLL_X_AXIS false
+#define INVERT_SCROLL_Y_AXIS false
+#define MIN_SCROLL_SUPPRESS_CLICK 10
+
 #define DEBOUNCE_DELAY_MS 5
 
 #endif // __CONFIG_H__

firmware/include/controls.h

 #ifndef __CONTROLS_H__
 #define __CONTROLS_H__
 
-void controls_new(int id, bool state);
-bool controls_button_read(void);
+enum mouse_buttons {
+    MOUSE_LEFT = 0,
+    MOUSE_MIDDLE,
+    MOUSE_RIGHT,
+    MOUSE_BACK,
+    MOUSE_FORWARD,
+    MOUSE_BUTTONS_COUNT
+};
+
+struct mouse_state {
+    bool changed;
+    bool button[MOUSE_BUTTONS_COUNT];
+    int16_t delta_x, delta_y;
+    int16_t scroll_x, scroll_y;
+    bool scroll_lock, fake_middle;
+};
+
+void controls_init(void);
+
+void controls_mouse_new(int id, bool state);
+struct mouse_state controls_mouse_read(void);
 
 #endif // __CONTROLS_H__
 

firmware/include/log.h

 #define println(fmt, ...) debug_log(false, fmt "\r\n", ##__VA_ARGS__)
 
 void debug_log(bool log, const char *format, ...) __attribute__((format(printf, 2, 3)));
+void debug_wait_input(const char *format, ...) __attribute__((format(printf, 1, 2)));
 
 void log_dump_to_usb(void);
 void log_dump_to_disk(void);
 
+void debug_handle_input(char *buff, uint32_t len);
+
 #endif // __LOG_H__

firmware/include/usb_cdc.h

 #define __USB_CDC_H__
 
 void usb_cdc_write(const char *buf, uint32_t count);
+void usb_cdc_set_reroute(bool reroute);
 
 #endif // __USB_CDC_H__

firmware/src/buttons.c

 
 struct button_state {
     uint32_t last_time;
-    bool last_state;
+    bool current_state, last_state;
 };
 
 struct button_state buttons[BUTTONS_COUNT];
 void buttons_init(void) {
     for (int i = 0; i < BUTTONS_COUNT; i++) {
         gpio_init(gpio_num[i]);
+        gpio_set_dir(gpio_num[i], GPIO_IN);
         gpio_pull_up(gpio_num[i]);
+
+        buttons[i].last_time = 0;
+        buttons[i].current_state = false;
+        buttons[i].last_state = false;
     }
 }
 
 void buttons_run(void) {
     for (int i = 0; i < BUTTONS_COUNT; i++) {
-        bool state = gpio_get(gpio_num[i]);
+        bool state = !gpio_get(gpio_num[i]);
         uint32_t now = to_ms_since_boot(get_absolute_time());
 
         if (state != buttons[i].last_state) {
         }
 
         if ((now - buttons[i].last_time) > DEBOUNCE_DELAY_MS) {
-            if (state != buttons[i].last_state) {
-                buttons[i].last_state = state;
-                controls_new(i, state);
+            if (state != buttons[i].current_state) {
+                buttons[i].current_state = state;
+                controls_mouse_new(i, state);
             }
         }
+
+        buttons[i].last_state = state;
     }
 }
 

firmware/src/controls.c

  * controls.c
  */
 
+#include <stdlib.h>
+
 #include "pico/stdlib.h"
 
 #include "config.h"
+#include "log.h"
+#include "pmw3360.h"
 #include "controls.h"
 
-static bool button_state = false;
+static struct mouse_state mouse, last_mouse;
+static uint64_t scroll_sum = 0;
+
+void controls_init(void) {
+    for (int i = 0; i < MOUSE_BUTTONS_COUNT; i++) {
+        mouse.button[i] = false;
+    }
+    mouse.changed = false;
+    mouse.delta_x = 0;
+    mouse.delta_y = 0;
+    mouse.scroll_x = 0;
+    mouse.scroll_y = 0;
+    mouse.scroll_lock = false;
+    mouse.fake_middle = false;
+
+    last_mouse = mouse;
+}
+
+void controls_mouse_new(int id, bool state) {
+    //debug("button %d %s", id, state ? "pressed" : "released");
 
-void controls_new(int id, bool state) {
-    (void)id;
-    button_state = state;
+    switch (id) {
+    case 0:
+        mouse.button[MOUSE_BACK] = state;
+        break;
+
+    case 1:
+        mouse.scroll_lock = state;
+        break;
+
+    case 2:
+        mouse.button[MOUSE_LEFT] = state;
+        break;
+
+    case 3:
+        mouse.button[MOUSE_RIGHT] = state;
+        break;
+    }
 }
 
-bool controls_button_read(void) {
-    return button_state;
+static bool mouse_state_changed(struct mouse_state a, struct mouse_state b) {
+    for (int i = 0; i < MOUSE_BUTTONS_COUNT; i++) {
+        if (a.button[i] != b.button[i]) {
+            return true;
+        }
+    }
+
+    if ((a.delta_x != b.delta_x)
+            || (a.delta_y != b.delta_y)
+            || (a.scroll_x != b.scroll_x)
+            || (a.scroll_y != b.scroll_y)) {
+        return true;
+    }
+
+    return false;
+}
+
+struct mouse_state controls_mouse_read(void) {
+    struct pmw_motion motion = pmw_get();
+
+    if (motion.motion) {
+        mouse.delta_x = motion.delta_x;
+        mouse.delta_y = motion.delta_y;
+    }
+
+    if (mouse.scroll_lock) {
+        mouse.scroll_x = mouse.delta_x;
+        mouse.scroll_y = mouse.delta_y;
+        mouse.delta_x = 0;
+        mouse.delta_y = 0;
+
+        scroll_sum += abs(mouse.scroll_x);
+        scroll_sum += abs(mouse.scroll_y);
+    } else {
+        mouse.scroll_x = 0;
+        mouse.scroll_y = 0;
+    }
+
+    if (mouse.fake_middle) {
+        mouse.button[MOUSE_MIDDLE] = false;
+        mouse.fake_middle = false;
+    }
+
+    if (!mouse.scroll_lock && last_mouse.scroll_lock) {
+        // middle mouse button was held and has now been released
+        if (scroll_sum < MIN_SCROLL_SUPPRESS_CLICK) {
+            // fake middle mouse click, user was not scrolling
+            mouse.button[MOUSE_MIDDLE] = true;
+            mouse.fake_middle = true;
+        }
+    }
+
+    if (mouse_state_changed(mouse, last_mouse)
+            || (mouse.delta_x != 0)
+            || (mouse.delta_y != 0)
+            || (mouse.scroll_x != 0)
+            || (mouse.scroll_y != 0)) {
+        mouse.changed = true;
+    }
+
+    last_mouse = mouse;
+    return mouse;
 }
 

firmware/src/log.c

 
 #include <stdarg.h>
 #include <stdio.h>
+
 #include "pico/stdlib.h"
+#include "hardware/watchdog.h"
 #include "ff.h"
 
 #include "config.h"
+#include "usb.h"
 #include "usb_cdc.h"
 #include "log.h"
 
-char log_buff[4096];
-size_t head = 0, tail = 0;
-bool full = false;
+static char log_buff[4096];
+static size_t head = 0, tail = 0;
+static bool full = false;
+static bool got_input = false;
 
 static void add_to_log(const char *buff, int len) {
     for (int i = 0; i < len; i++) {
 }
 
 void debug_log(bool log, const char* format, ...) {
-    static char line_buff[256];
+    static char line_buff[512];
 
     va_list args;
     va_start(args, format);
         }
     }
 }
+
+void debug_handle_input(char *buff, uint32_t len) {
+    (void)buff;
+
+    if (len > 0) {
+        got_input = true;
+    }
+}
+
+void debug_wait_input(const char *format, ...) {
+    static char line_buff[512];
+
+    va_list args;
+    va_start(args, format);
+    int l = format_debug_log(line_buff, sizeof(line_buff), format, args);
+    va_end(args);
+
+    if ((l > 0) && (l <= (int)sizeof(line_buff))) {
+        usb_cdc_write(line_buff, l);
+    }
+
+    got_input = false;
+    usb_cdc_set_reroute(true);
+
+    while (!got_input) {
+        watchdog_update();
+        usb_run();
+    }
+
+    usb_cdc_set_reroute(false);
+}

firmware/src/main.c

 #include "pmw3360.h"
 #include "fat_disk.h"
 #include "buttons.h"
+#include "controls.h"
 
 int main(void) {
     heartbeat_init();
     buttons_init();
+    controls_init();
 
     cnsl_init();
     usb_init();
     fat_disk_init();
 
     debug("pmw_init");
+    bool use_pmw = true;
     if (pmw_init() != 0) {
         debug("error initializing PMW3360");
+        use_pmw = false;
     }
 
     // trigger after 500ms
     // (PMW3360 initialization takes ~160ms)
-    //watchdog_enable(500, 1);
+    watchdog_enable(500, 1);
 
     debug("init done");
 
         buttons_run();
         usb_run();
         cnsl_run();
-        pmw_run();
+
+        if (use_pmw) {
+            pmw_run();
+        }
     }
 
     return 0;

firmware/src/pmw3360.c

         // setup MOTION pin interrupt to handle reading data
         gpio_add_raw_irq_handler(PMW_MOTION_PIN, pmw_motion_irq);
         irq_set_enabled(IO_IRQ_BANK0, true);
-	first_init = true;
+        first_init = true;
     }
 
     pmw_irq_start();

firmware/src/usb_cdc.c

 #include "usb_descriptors.h"
 #include "usb_cdc.h"
 
+static bool reroute_cdc_debug = false;
+
 void usb_cdc_write(const char *buf, uint32_t count) {
 #ifndef DISABLE_CDC_DTR_CHECK
     if (!tud_cdc_connected()) {
     }
 }
 
+void usb_cdc_set_reroute(bool reroute) {
+    reroute_cdc_debug = reroute;
+}
+
 void cdc_task(void) {
     const uint32_t cdc_buf_len = 64;
 
             // ASCII 0x18 = CAN (cancel)
             debug("switching to bootloader");
             reset_to_bootloader();
+        } else if (reroute_cdc_debug) {
+            debug_handle_input(buf, count);
         } else {
             // echo back
             usb_cdc_write(buf, count);

firmware/src/usb_hid.c

 #include "tusb.h"
 
 #include "config.h"
-#include "pmw3360.h"
 #include "controls.h"
 #include "usb_descriptors.h"
 #include "usb_hid.h"
 
         case REPORT_ID_MOUSE:
         {
-            struct pmw_motion mouse = pmw_get();
+            struct mouse_state mouse = controls_mouse_read();
+
             uint8_t buttons = 0x00;
-            if (btn) {
+            if (mouse.button[MOUSE_LEFT]) {
                 buttons |= MOUSE_BUTTON_LEFT;
             }
-            if (mouse.motion) {
+            if (mouse.button[MOUSE_RIGHT]) {
+                buttons |= MOUSE_BUTTON_RIGHT;
+            }
+            if (mouse.button[MOUSE_MIDDLE]) {
+                buttons |= MOUSE_BUTTON_MIDDLE;
+            }
+            if (mouse.button[MOUSE_BACK]) {
+                buttons |= MOUSE_BUTTON_BACKWARD;
+            }
+
+            if (mouse.changed) {
                 tud_hid_mouse_report(REPORT_ID_MOUSE, buttons,
                         mouse.delta_x * (INVERT_MOUSE_X_AXIS ? -1 : 1),
                         mouse.delta_y * (INVERT_MOUSE_Y_AXIS ? -1 : 1),
-                        0, 0);
+                        mouse.scroll_y * (INVERT_SCROLL_Y_AXIS ? -1 : 1),
+                        mouse.scroll_x * (INVERT_SCROLL_X_AXIS ? -1 : 1));
             }
         }
         break;
     if ( board_millis() - start_ms < interval_ms) return; // not enough time
     start_ms += interval_ms;
 
-    uint32_t const btn = controls_button_read();
+    uint32_t const btn = 0;
 
     // Remote wakeup
     if ( tud_suspended() && btn ) {