logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

spleeb.c (18111B)

    

  1. // Copyright 2022 Chris Hoage (@chrishoage)
  2. // SPDX-License-Identifier: GPL-2.0-or-later
  4. #include "spleeb.h"
  5. #include "transactions.h"
  7. #ifdef CONSOLE_ENABLE
  8. #    include "print.h"
  9. #endif // CONSOLE_ENABLE
  11. #ifdef POINTING_DEVICE_ENABLE
  12. #    include "drivers/sensors/cirque_pinnacle_gestures.h"
  13. #endif // POINTING_DEVICE_ENABLE
  15. #if defined(POINTING_DEVICE_ENABLE) || defined(SPLEEB_ENCODER_MODE_MAP_ENABLE)
  16. typedef union {
  17.     uint16_t raw;
  18.     struct {
  19.         uint8_t pointer_default_dpi : 4; // 16 steps available.
  20.         uint8_t pointer_sniping_dpi : 2; // 4 steps available.
  21.         uint8_t enc_modes[NUM_ENCODERS];
  22.         bool    is_dragscroll_enabled : 1;
  23.         bool    is_sniping_enabled : 1;
  24.     } __attribute__((packed));
  25. } spleeb_config_t;
  27. static spleeb_config_t g_spleeb_config = {0};
  29. /**
  30.  * \brief Set the value of `config` from EEPROM.
  31.  *
  32.  * Note that `is_dragscroll_enabled` and `is_sniping_enabled` are purposefully
  33.  * ignored since we do not want to persist this state to memory.  In practice,
  34.  * this state is always written to maximize write-performances.  Therefore, we
  35.  * explicitly set them to `false` in this function.
  36.  */
  37. static void read_spleeb_config_from_eeprom(spleeb_config_t* config) {
  38.     config->raw                   = eeconfig_read_kb() & 0xffff;
  39.     config->is_dragscroll_enabled = false;
  40.     config->is_sniping_enabled    = false;
  41. }
  43. /**
  44.  * \brief Save the value of `config` to eeprom.
  45.  *
  46.  * Note that all values are written verbatim, including whether drag-scroll
  47.  * and/or sniper mode are enabled.  `read_spleeb_config_from_eeprom(…)`
  48.  * resets these 2 values to `false` since it does not make sense to persist
  49.  * these across reboots of the board.
  50.  */
  51. static void write_spleeb_config_to_eeprom(spleeb_config_t* config) {
  52.     eeconfig_update_kb(config->raw);
  53. }
  55. void eeconfig_init_kb(void) {
  56.     g_spleeb_config.raw                 = 0;
  57.     g_spleeb_config.pointer_default_dpi = 4;
  59. #    ifdef SPLEEB_ENCODER_MODE_MAP_ENABLE
  60.     for (size_t i = 0; i < NUM_ENCODERS; i++) {
  61.         if (spleeb_encoder_mode_map[i][0].initalized) {
  62.             spleeb_enc_mode_t* first_enc_mode = &spleeb_encoder_mode_map[i][0];
  63.             g_spleeb_config.enc_modes[i]      = first_enc_mode->mode;
  64.         }
  65.     }
  66. #    endif // SPLEEB_ENCODER_MODE_MAP_ENABLE
  68.     write_spleeb_config_to_eeprom(&g_spleeb_config);
  69.     eeconfig_init_user();
  70. }
  72. void matrix_init_kb(void) {
  73.     read_spleeb_config_from_eeprom(&g_spleeb_config);
  74.     matrix_init_user();
  75. }
  77. void spleeb_config_sync_handler(uint8_t initiator2target_buffer_size, const void* initiator2target_buffer, uint8_t target2initiator_buffer_size, void* target2initiator_buffer) {
  78.     if (initiator2target_buffer_size == sizeof(g_spleeb_config)) {
  79.         memcpy(&g_spleeb_config, initiator2target_buffer, sizeof(g_spleeb_config));
  80.     }
  81. }
  83. void keyboard_post_init_kb(void) {
  84.     transaction_register_rpc(RPC_ID_KB_CONFIG_SYNC, spleeb_config_sync_handler);
  85.     keyboard_post_init_user();
  86. }
  88. void housekeeping_task_kb(void) {
  89.     if (is_keyboard_master()) {
  90.         // Keep track of the last state, so that we can tell if we need to propagate to slave.
  91.         static spleeb_config_t last_spleeb_config = {0};
  92.         static uint32_t        last_sync          = 0;
  93.         bool                   needs_sync         = false;
  95.         // Check if the state values are different.
  96.         if (memcmp(&g_spleeb_config, &last_spleeb_config, sizeof(g_spleeb_config))) {
  97.             needs_sync = true;
  98.             memcpy(&last_spleeb_config, &g_spleeb_config, sizeof(g_spleeb_config));
  99.         }
  100.         // Send to slave every 500ms regardless of state change.
  101.         if (timer_elapsed32(last_sync) > 500) {
  102.             needs_sync = true;
  103.         }
  105.         // Perform the sync if requested.
  106.         if (needs_sync) {
  107.             if (transaction_rpc_send(RPC_ID_KB_CONFIG_SYNC, sizeof(g_spleeb_config), &g_spleeb_config)) {
  108.                 last_sync = timer_read32();
  109.             }
  110.         }
  111.     }
  112.     // No need to invoke the user-specific callback, as it's been called
  113.     // already.
  114. }
  115. #endif // defined(POINTING_DEVICE_ENABLE) || defined(SPLEEB_ENCODER_MODE_MAP_ENABLE)
  117. #ifdef SPLEEB_ENCODER_MODE_MAP_ENABLE
  119. /**
  120.  * \brief Handle the encoder mode action when triggered by encoder_update_kb
  121.  *
  122.  * Weakly defined fuction intended to be overridden in a users keymap
  123.  */
  124. __attribute__((weak)) void spleeb_encoder_mode_trigger(uint8_t mode, bool clockwise) {}
  126. typedef struct {
  127.     uint8_t            index;
  128.     spleeb_enc_mode_t* enc_mode;
  129. } spleeb_found_enc_mode_t;
  131. static spleeb_found_enc_mode_t spleeb_get_found_encoder_mode(spleeb_config_t* config, uint8_t index) {
  132.     spleeb_found_enc_mode_t found_enc_mode;
  134.     for (size_t i = 0; i < SPLEEB_ENCODER_MODE_COUNT; i++) {
  135.         spleeb_enc_mode_t* cur_enc_mode = &spleeb_encoder_mode_map[index][i];
  136.         if (cur_enc_mode->mode == config->enc_modes[index]) {
  137.             found_enc_mode.index    = i;
  138.             found_enc_mode.enc_mode = cur_enc_mode;
  139.             break;
  140.         }
  141.     }
  143.     return found_enc_mode;
  144. }
  146. /**
  147.  * \brief Step through the defined encoder modes for the encoder at the given
  148.  * index
  149.  *
  150.  * Step though the modes defined in spleeb_encoder_mode_map at the users keymap.
  151.  * Use a null terminator at the first character on the name property for the
  152.  * enc_mode struct to determine if we've reached the end of the defined encoder
  153.  * modes. When this happens loop back to the beginning.
  154.  */
  155. static void spleeb_step_encoder_mode(spleeb_config_t* config, uint8_t index) {
  156.     spleeb_found_enc_mode_t cur_enc_mode  = spleeb_get_found_encoder_mode(config, index);
  157.     spleeb_enc_mode_t*      next_enc_mode = &spleeb_encoder_mode_map[index][(cur_enc_mode.index + 1) % SPLEEB_ENCODER_MODE_COUNT];
  159.     if (!next_enc_mode->initalized) {
  160.         next_enc_mode = &spleeb_encoder_mode_map[index][0];
  161.     }
  163.     if (next_enc_mode->initalized) {
  164.         config->enc_modes[index] = next_enc_mode->mode;
  165.         write_spleeb_config_to_eeprom(config);
  166.     }
  167. }
  169. bool encoder_update_kb(uint8_t index, bool clockwise) {
  170.     if (!encoder_update_user(index, clockwise)) {
  171.         return false;
  172.     }
  174.     spleeb_encoder_mode_trigger(g_spleeb_config.enc_modes[index], clockwise);
  176.     return true;
  177. }
  178. #endif // SPLEEB_ENCODER_MODE_MAP_ENABLE
  180. #ifdef POINTING_DEVICE_ENABLE
  182. /** \brief Return the current value of the pointer's default DPI. */
  183. static uint16_t get_pointer_default_dpi(spleeb_config_t* config) {
  184.     return (uint16_t)config->pointer_default_dpi * SPLEEB_DEFAULT_DPI_CONFIG_STEP + SPLEEB_MINIMUM_DEFAULT_DPI;
  185. }
  187. /** \brief Return the current value of the pointer's sniper-mode DPI. */
  188. static uint16_t get_pointer_sniping_dpi(spleeb_config_t* config) {
  189.     return (uint16_t)config->pointer_sniping_dpi * SPLEEB_SNIPING_DPI_CONFIG_STEP + SPLEEB_MINIMUM_SNIPING_DPI;
  190. }
  192. /** \brief Return the current value of the pointer's default DPI. */
  193. static uint16_t get_pointer_current_dpi(spleeb_config_t* config) {
  194.     if (config->is_sniping_enabled) {
  195.         return get_pointer_sniping_dpi(config);
  196.     } else {
  197.         return get_pointer_default_dpi(config);
  198.     }
  199. }
  201. /** \brief Set the appropriate DPI for the input config. */
  202. static void maybe_update_pointing_device_cpi(spleeb_config_t* config) {
  203.     if (config->is_sniping_enabled) {
  204.         pointing_device_set_cpi(get_pointer_sniping_dpi(config));
  205.     } else {
  206.         pointing_device_set_cpi(get_pointer_default_dpi(config));
  207.     }
  208. }
  210. /**
  211.  * \brief Update the pointer's default DPI to the next or previous step.
  212.  *
  213.  * Increases the DPI value if `forward` is `true`, decreases it otherwise.
  214.  * The increment/decrement steps are equal to SPLEEB_DEFAULT_DPI_CONFIG_STEP.
  215.  */
  216. static void step_pointer_default_dpi(spleeb_config_t* config, bool forward) {
  217.     config->pointer_default_dpi += forward ? 1 : -1;
  218.     maybe_update_pointing_device_cpi(config);
  219. }
  221. /**
  222.  * \brief Update the pointer's sniper-mode DPI to the next or previous step.
  223.  *
  224.  * Increases the DPI value if `forward` is `true`, decreases it otherwise.
  225.  * The increment/decrement steps are equal to SPLEEB_SNIPING_DPI_CONFIG_STEP.
  226.  */
  227. static void step_pointer_sniping_dpi(spleeb_config_t* config, bool forward) {
  228.     config->pointer_sniping_dpi += forward ? 1 : -1;
  229.     maybe_update_pointing_device_cpi(config);
  230. }
  232. uint16_t spleeb_get_pointer_default_dpi(void) {
  233.     return get_pointer_default_dpi(&g_spleeb_config);
  234. }
  236. uint16_t spleeb_get_pointer_sniping_dpi(void) {
  237.     return get_pointer_sniping_dpi(&g_spleeb_config);
  238. }
  240. void spleeb_cycle_pointer_default_dpi_noeeprom(bool forward) {
  241.     step_pointer_default_dpi(&g_spleeb_config, forward);
  242. }
  244. void spleeb_cycle_pointer_default_dpi(bool forward) {
  245.     step_pointer_default_dpi(&g_spleeb_config, forward);
  246.     write_spleeb_config_to_eeprom(&g_spleeb_config);
  247. }
  249. void spleeb_cycle_pointer_sniping_dpi_noeeprom(bool forward) {
  250.     step_pointer_sniping_dpi(&g_spleeb_config, forward);
  251. }
  253. void spleeb_cycle_pointer_sniping_dpi(bool forward) {
  254.     step_pointer_sniping_dpi(&g_spleeb_config, forward);
  255.     write_spleeb_config_to_eeprom(&g_spleeb_config);
  256. }
  258. bool spleeb_get_pointer_sniping_enabled(void) {
  259.     return g_spleeb_config.is_sniping_enabled;
  260. }
  262. void spleeb_set_pointer_sniping_enabled(bool enable) {
  263.     g_spleeb_config.is_sniping_enabled = enable;
  264.     maybe_update_pointing_device_cpi(&g_spleeb_config);
  265. }
  267. bool spleeb_get_pointer_dragscroll_enabled(void) {
  268.     return g_spleeb_config.is_dragscroll_enabled;
  269. }
  271. void spleeb_set_pointer_dragscroll_enabled(bool enable) {
  272.     g_spleeb_config.is_dragscroll_enabled = enable;
  273.     cirque_pinnacle_enable_cursor_glide(enable);
  274.     maybe_update_pointing_device_cpi(&g_spleeb_config);
  275. }
  276. #endif // POINTING_DEVICE_ENABLE
  278. #ifdef POINTING_DEVICE_ENABLE
  279. void pointing_device_init_kb(void) {
  280.     maybe_update_pointing_device_cpi(&g_spleeb_config);
  282.     // only glide on drag scroll
  283.     cirque_pinnacle_enable_cursor_glide(false);
  285.     set_auto_mouse_enable(true);
  286.     pointing_device_init_user();
  287. }
  289. /**
  290.  * \brief Augment the pointing device behavior.
  291.  *
  292.  * Drag-scroll implementation borrowed from https://github.com/qmk/qmk_firmware/pull/18218
  293.  */
  294. static void pointing_device_task_spleeb(report_mouse_t* mouse_report) {
  295.     static int16_t scroll_x = 0;
  296.     static int16_t scroll_y = 0;
  297.     if (g_spleeb_config.is_dragscroll_enabled) {
  298.         scroll_x -= mouse_report->x;
  299.         scroll_y += mouse_report->y;
  300.         mouse_report->h = scroll_x / SPLEEB_DRAGSCROLL_DIVISOR;
  301.         mouse_report->v = scroll_y / SPLEEB_DRAGSCROLL_DIVISOR;
  302.         mouse_report->x = 0;
  303.         mouse_report->y = 0;
  304.         scroll_x -= (int16_t)mouse_report->h * SPLEEB_DRAGSCROLL_DIVISOR;
  305.         scroll_y -= (int16_t)mouse_report->v * SPLEEB_DRAGSCROLL_DIVISOR;
  306.     }
  307. }
  309. report_mouse_t pointing_device_task_kb(report_mouse_t mouse_report) {
  310.     if (is_keyboard_master()) {
  311.         pointing_device_task_spleeb(&mouse_report);
  313.         mouse_report = pointing_device_task_user(mouse_report);
  314.     }
  316.     return mouse_report;
  317. }
  319. /**
  320.  * \brief Outputs the Spleeb configuration to console.
  321.  *
  322.  * Prints the in-memory configuration structure to console, for debugging.
  323.  * Includes:
  324.  *   - raw value
  325.  *   - drag-scroll: on/off
  326.  *   - sniping: on/off
  327.  *   - default DPI: internal table index/actual DPI
  328.  *   - sniping DPI: internal table index/actual DPI
  329.  */
  330. static void debug_spleeb_config_to_console(spleeb_config_t* config) {
  331. #    ifdef CONSOLE_ENABLE
  332.     pd_dprintf("(spleeb) process_record_kb: config = {\n"
  333.                "\traw = 0x%u,\n"
  334.                "\t{\n"
  335.                "\t\tis_dragscroll_enabled=%u\n"
  336.                "\t\tis_sniping_enabled=%u\n"
  337.                "\t\tdefault_dpi=0x%X (%u)\n"
  338.                "\t\tsniping_dpi=0x%X (%u)\n"
  339.                "\t}\n"
  340.                "}\n",
  341.                config->raw, config->is_dragscroll_enabled, config->is_sniping_enabled, config->pointer_default_dpi, get_pointer_default_dpi(config), config->pointer_sniping_dpi, get_pointer_sniping_dpi(config));
  342. #    endif // CONSOLE_ENABLE
  343. }
  344. #endif // POINTING_DEVICE_ENABLE
  346. bool process_record_kb(uint16_t keycode, keyrecord_t* record) {
  347.     if (!process_record_user(keycode, record)) {
  348. #ifdef POINTING_DEVICE_ENABLE
  350.         debug_spleeb_config_to_console(&g_spleeb_config);
  351. #endif // POINTING_DEVICE_ENABLE
  352.         return false;
  353.     }
  354. #ifdef POINTING_DEVICE_ENABLE
  355.     switch (keycode) {
  356.         case POINTER_DEFAULT_DPI_FORWARD:
  357.             if (record->event.pressed) {
  358.                 spleeb_cycle_pointer_default_dpi(true);
  359.             }
  360.             break;
  361.         case POINTER_DEFAULT_DPI_REVERSE:
  362.             if (record->event.pressed) {
  363.                 spleeb_cycle_pointer_default_dpi(false);
  364.             }
  365.             break;
  366.         case POINTER_SNIPING_DPI_FORWARD:
  367.             if (record->event.pressed) {
  368.                 spleeb_cycle_pointer_sniping_dpi(true);
  369.             }
  370.             break;
  371.         case POINTER_SNIPING_DPI_REVERSE:
  372.             if (record->event.pressed) {
  373.                 spleeb_cycle_pointer_sniping_dpi(false);
  374.             }
  375.             break;
  376.         case SNIPING_MODE:
  377.             spleeb_set_pointer_sniping_enabled(record->event.pressed);
  378.             break;
  379.         case SNIPING_MODE_TOGGLE:
  380.             if (record->event.pressed) {
  381.                 spleeb_set_pointer_sniping_enabled(!spleeb_get_pointer_sniping_enabled());
  382.             }
  383.             break;
  384.         case DRAGSCROLL_MODE:
  385.             spleeb_set_pointer_dragscroll_enabled(record->event.pressed);
  386.             break;
  387.         case DRAGSCROLL_MODE_TOGGLE:
  388.             if (record->event.pressed) {
  389.                 spleeb_set_pointer_dragscroll_enabled(!spleeb_get_pointer_dragscroll_enabled());
  390.             }
  391.             break;
  392.     }
  393. #endif // POINTING_DEVICE_ENABLE
  395. #ifdef SPLEEB_ENCODER_MODE_MAP_ENABLE
  396.     switch (keycode) {
  397.         case ENC_MODE_STEP_LEFT:
  398.             if (record->event.pressed) {
  399.                 spleeb_step_encoder_mode(&g_spleeb_config, 0);
  400.             }
  401.             break;
  402.         case ENC_MODE_STEP_RIGHT:
  403.             if (record->event.pressed) {
  404.                 spleeb_step_encoder_mode(&g_spleeb_config, 1);
  405.             }
  406.             break;
  407.     }
  408. #endif // SPLEEB_ENCODER_MODE_MAP_ENABLE
  410. #ifdef POINTING_DEVICE_ENABLE
  411.     if ((keycode >= POINTER_DEFAULT_DPI_FORWARD && keycode <= ENC_MODE_STEP_RIGHT) || IS_MOUSEKEY(keycode)) {
  412.         debug_spleeb_config_to_console(&g_spleeb_config);
  413.     }
  414. #endif // POINTING_DEVICE_ENABLE
  416.     return true;
  417. }
  419. #ifdef POINTING_DEVICE_ENABLE
  421. bool is_mouse_record_kb(uint16_t keycode, keyrecord_t* record) {
  422.     switch (keycode) {
  423.         case DRAGSCROLL_MODE:
  424.         case SNIPING_MODE:
  425.             return true;
  426.         default:
  427.             return false;
  428.     }
  430.     return is_mouse_record_user(keycode, record);
  431. }
  433. #endif // POINTING_DEVICE_ENABLE
  435. #ifdef OLED_ENABLE
  437. static void render_layer(void) {
  438.     oled_write_P(PSTR("LAYER: "), false);
  440.     switch (get_highest_layer(layer_state)) {
  441.         case 0:
  442.             oled_write_ln_P(PSTR("\xC0\xC1"), false);
  443.             break;
  444.         case 1:
  445.             oled_write_ln_P(PSTR("\xC2\xC3"), false);
  446.             break;
  447.         case 2:
  448.             oled_write_ln_P(PSTR("\xC4\xC5"), false);
  449.             break;
  450.         case 3:
  451.             oled_write_ln_P(PSTR("\xC6\xC7"), false);
  452.             break;
  453.         case 4:
  454.             oled_write_ln_P(PSTR("\xC8\xC9"), false);
  455.             break;
  456.         case 5:
  457.             oled_write_ln_P(PSTR("\xCA\xCB"), false);
  458.             break;
  459.         default:
  460.             oled_write_ln_P(get_u8_str(get_highest_layer(layer_state) + 0x30, ' '), true);
  461.     }
  463.     oled_write_ln_P("", false);
  464. }
  466. static void render_mods(void) {
  467.     uint8_t modifiers = get_mods();
  469.     oled_write_ln_P(PSTR("MODS:"), false);
  470.     oled_write_ln_P("", false);
  471.     oled_write_P(PSTR("\325\326"), (modifiers & MOD_MASK_SHIFT));
  472.     oled_write_P(PSTR("\327\330"), (modifiers & MOD_MASK_CTRL));
  473.     oled_write_P(PSTR("\331\332"), (modifiers & MOD_MASK_ALT));
  474.     oled_write_ln_P(PSTR("\333\334"), (modifiers & MOD_MASK_GUI));
  475.     oled_write_ln_P("", false);
  476. }
  478. static void render_lock(void) {
  479.     led_t led_state = host_keyboard_led_state();
  481.     oled_write_P(PSTR("LOCK: "), false);
  482.     oled_write_P(PSTR("\235\236"), led_state.caps_lock);
  483.     oled_write_ln_P(PSTR("\275\276"), led_state.num_lock);
  484. }
  486. static void render_pointer(void) {
  487. #    ifdef POINTING_DEVICE_ENABLE
  488.     oled_write_ln_P(PSTR("POINTER:"), false);
  489.     oled_write_ln_P("", false);
  490.     oled_write_P(PSTR("dpi:"), false);
  491.     oled_write_ln_P(get_u16_str(get_pointer_current_dpi(&g_spleeb_config), ' '), false);
  492.     oled_write_ln_P("", false);
  493. #    endif // POINTING_DEVICE_ENABLE
  494. }
  496. #    ifdef SPLEEB_ENCODER_MODE_MAP_ENABLE
  497. static uint8_t spleeb_get_encoder_mode(spleeb_config_t* config, uint8_t index) {
  498.     spleeb_found_enc_mode_t found_enc_mode = spleeb_get_found_encoder_mode(config, index);
  499.     return found_enc_mode.enc_mode->mode;
  500. }
  502. /**
  503.  * \brief Map an encoder mode to a string to be displayed on the OLED
  504.  *
  505.  * Weakly defined fuction intended to be overridden in a users keymap. My be
  506.  * omitted if no OLED is used.
  507.  */
  508. __attribute__((weak)) const char* spleeb_encoder_mode_string(uint8_t mode) {
  509.     return get_u8_str(mode, ' ');
  510. }
  511. #    endif //  SPLEEB_ENCODER_MODE_MAP_ENABLE
  513. static void render_encoder(void) {
  514. #    ifdef SPLEEB_ENCODER_MODE_MAP_ENABLE
  515.     oled_write_ln_P(PSTR("ENCODER:"), false);
  516.     oled_write_ln_P("", false);
  517.     oled_write_P(PSTR("R: "), false);
  518.     oled_write_ln_P(spleeb_encoder_mode_string(spleeb_get_encoder_mode(&g_spleeb_config, 1)), false);
  519.     oled_write_P(PSTR("L: "), false);
  520.     oled_write_ln_P(spleeb_encoder_mode_string(spleeb_get_encoder_mode(&g_spleeb_config, 0)), false);
  521. #    endif //  SPLEEB_ENCODER_MODE_MAP_ENABLE
  522. }
  524. static void render_status(void) {
  525.     render_layer();
  526.     render_mods();
  527.     render_lock();
  528.     render_pointer();
  529.     render_encoder();
  530. }
  532. oled_rotation_t oled_init_kb(oled_rotation_t rotation) {
  533.     return OLED_ROTATION_90;
  534. }
  536. bool oled_task_kb(void) {
  537.     if (is_keyboard_master()) {
  538.         return false;
  539.     }
  541.     if (!oled_task_user()) {
  542.         return false;
  543.     }
  545.     render_status();
  546.     return false;
  547. }
  548. #endif // OLED_ENABLE