split_util.c 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
  1. /* Copyright 2021 QMK
  2. *
  3. * This program is free software: you can redistribute it and/or modify
  4. * it under the terms of the GNU General Public License as published by
  5. * the Free Software Foundation, either version 3 of the License, or
  6. * (at your option) any later version.
  7. *
  8. * This program is distributed in the hope that it will be useful,
  9. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. * GNU General Public License for more details.
  12. *
  13. * You should have received a copy of the GNU General Public License
  14. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  15. */
  16. #include "split_util.h"
  17. #include "matrix.h"
  18. #include "keyboard.h"
  19. #include "config.h"
  20. #include "timer.h"
  21. #include "transport.h"
  22. #include "quantum.h"
  23. #include "wait.h"
  24. #include "usb_util.h"
  25. #ifdef EE_HANDS
  26. # include "eeconfig.h"
  27. #endif
  28. #if defined(RGBLIGHT_ENABLE) && defined(RGBLED_SPLIT)
  29. # include "rgblight.h"
  30. #endif
  31. #ifndef SPLIT_USB_TIMEOUT
  32. # define SPLIT_USB_TIMEOUT 2000
  33. #endif
  34. #ifndef SPLIT_USB_TIMEOUT_POLL
  35. # define SPLIT_USB_TIMEOUT_POLL 10
  36. #endif
  37. // Max number of consecutive failed communications (one per scan cycle) before the communication is seen as disconnected.
  38. // Set to 0 to disable the disconnection check altogether.
  39. #ifndef SPLIT_MAX_CONNECTION_ERRORS
  40. # define SPLIT_MAX_CONNECTION_ERRORS 10
  41. #endif // SPLIT_MAX_CONNECTION_ERRORS
  42. // How long (in milliseconds) to block all connection attempts after the communication has been flagged as disconnected.
  43. // One communication attempt will be allowed everytime this amount of time has passed since the last attempt. If that attempt succeeds, the communication is seen as working again.
  44. // Set to 0 to disable communication throttling while disconnected
  45. #ifndef SPLIT_CONNECTION_CHECK_TIMEOUT
  46. # define SPLIT_CONNECTION_CHECK_TIMEOUT 500
  47. #endif // SPLIT_CONNECTION_CHECK_TIMEOUT
  48. static uint8_t connection_errors = 0;
  49. volatile bool isLeftHand = true;
  50. #if defined(SPLIT_USB_DETECT)
  51. _Static_assert((SPLIT_USB_TIMEOUT / SPLIT_USB_TIMEOUT_POLL) <= UINT16_MAX, "Please lower SPLIT_USB_TIMEOUT and/or increase SPLIT_USB_TIMEOUT_POLL.");
  52. static bool usbIsActive(void) {
  53. for (uint16_t i = 0; i < (SPLIT_USB_TIMEOUT / SPLIT_USB_TIMEOUT_POLL); i++) {
  54. // This will return true if a USB connection has been established
  55. if (usb_connected_state()) {
  56. return true;
  57. }
  58. wait_ms(SPLIT_USB_TIMEOUT_POLL);
  59. }
  60. return false;
  61. }
  62. #else
  63. static inline bool usbIsActive(void) {
  64. return usb_vbus_state();
  65. }
  66. #endif
  67. #ifdef SPLIT_HAND_MATRIX_GRID
  68. void matrix_io_delay(void);
  69. static uint8_t peek_matrix_intersection(pin_t out_pin, pin_t in_pin) {
  70. setPinInputHigh(in_pin);
  71. setPinOutput(out_pin);
  72. writePinLow(out_pin);
  73. // It's almost unnecessary, but wait until it's down to low, just in case.
  74. wait_us(1);
  75. uint8_t pin_state = readPin(in_pin);
  76. // Set out_pin to a setting that is less susceptible to noise.
  77. setPinInputHigh(out_pin);
  78. matrix_io_delay(); // Wait for the pull-up to go HIGH.
  79. return pin_state;
  80. }
  81. #endif
  82. __attribute__((weak)) bool is_keyboard_left(void) {
  83. #if defined(SPLIT_HAND_PIN)
  84. // Test pin SPLIT_HAND_PIN for High/Low, if low it's right hand
  85. setPinInput(SPLIT_HAND_PIN);
  86. # ifdef SPLIT_HAND_PIN_LOW_IS_LEFT
  87. return !readPin(SPLIT_HAND_PIN);
  88. # else
  89. return readPin(SPLIT_HAND_PIN);
  90. # endif
  91. #elif defined(SPLIT_HAND_MATRIX_GRID)
  92. # ifdef SPLIT_HAND_MATRIX_GRID_LOW_IS_RIGHT
  93. return peek_matrix_intersection(SPLIT_HAND_MATRIX_GRID);
  94. # else
  95. return !peek_matrix_intersection(SPLIT_HAND_MATRIX_GRID);
  96. # endif
  97. #elif defined(EE_HANDS)
  98. return eeconfig_read_handedness();
  99. #elif defined(MASTER_RIGHT)
  100. return !is_keyboard_master();
  101. #endif
  102. return is_keyboard_master();
  103. }
  104. __attribute__((weak)) bool is_keyboard_master(void) {
  105. static enum { UNKNOWN, MASTER, SLAVE } usbstate = UNKNOWN;
  106. // only check once, as this is called often
  107. if (usbstate == UNKNOWN) {
  108. usbstate = usbIsActive() ? MASTER : SLAVE;
  109. // Avoid NO_USB_STARTUP_CHECK - Disable USB as the previous checks seem to enable it somehow
  110. if (usbstate == SLAVE) {
  111. usb_disconnect();
  112. }
  113. }
  114. return (usbstate == MASTER);
  115. }
  116. // this code runs before the keyboard is fully initialized
  117. void split_pre_init(void) {
  118. isLeftHand = is_keyboard_left();
  119. #if defined(RGBLIGHT_ENABLE) && defined(RGBLED_SPLIT)
  120. uint8_t num_rgb_leds_split[2] = RGBLED_SPLIT;
  121. if (isLeftHand) {
  122. rgblight_set_clipping_range(0, num_rgb_leds_split[0]);
  123. } else {
  124. rgblight_set_clipping_range(num_rgb_leds_split[0], num_rgb_leds_split[1]);
  125. }
  126. #endif
  127. if (is_keyboard_master()) {
  128. #if defined(USE_I2C) && defined(SSD1306OLED)
  129. matrix_master_OLED_init();
  130. #endif
  131. transport_master_init();
  132. }
  133. }
  134. // this code runs after the keyboard is fully initialized
  135. // - avoids race condition during matrix_init_quantum where slave can start
  136. // receiving before the init process has completed
  137. void split_post_init(void) {
  138. if (!is_keyboard_master()) {
  139. transport_slave_init();
  140. }
  141. }
  142. bool is_transport_connected(void) {
  143. return connection_errors < SPLIT_MAX_CONNECTION_ERRORS;
  144. }
  145. bool transport_master_if_connected(matrix_row_t master_matrix[], matrix_row_t slave_matrix[]) {
  146. #if SPLIT_MAX_CONNECTION_ERRORS > 0 && SPLIT_CONNECTION_CHECK_TIMEOUT > 0
  147. // Throttle transaction attempts if target doesn't seem to be connected
  148. // Without this, a solo half becomes unusable due to constant read timeouts
  149. static uint16_t connection_check_timer = 0;
  150. const bool is_disconnected = !is_transport_connected();
  151. if (is_disconnected && timer_elapsed(connection_check_timer) < SPLIT_CONNECTION_CHECK_TIMEOUT) {
  152. return false;
  153. }
  154. #endif // SPLIT_MAX_CONNECTION_ERRORS > 0 && SPLIT_CONNECTION_CHECK_TIMEOUT > 0
  155. __attribute__((unused)) bool okay = transport_master(master_matrix, slave_matrix);
  156. #if SPLIT_MAX_CONNECTION_ERRORS > 0
  157. if (!okay) {
  158. if (connection_errors < UINT8_MAX) {
  159. connection_errors++;
  160. }
  161. # if SPLIT_CONNECTION_CHECK_TIMEOUT > 0
  162. bool connected = is_transport_connected();
  163. if (!connected) {
  164. connection_check_timer = timer_read();
  165. dprintln("Target disconnected, throttling connection attempts");
  166. }
  167. return connected;
  168. } else if (is_disconnected) {
  169. dprintln("Target connected");
  170. # endif // SPLIT_CONNECTION_CHECK_TIMEOUT > 0
  171. }
  172. connection_errors = 0;
  173. #endif // SPLIT_MAX_CONNECTION_ERRORS > 0
  174. return true;
  175. }