API tools faq
paste
HorrorTroll

openrgb.c

HorrorTroll
Feb 19th, 2022
273
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 11.21 KB | None | 0 0
raw download clone embed print report
  1. /* Copyright 2020 Kasper
  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 2 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.  
  17. #ifndef RAW_ENABLE
  18. # error "RAW_ENABLE is not enabled"
  19. #endif
  20.  
  21. #include "version.h"
  22. #include "quantum.h"
  23. #include "openrgb.h"
  24. #include "raw_hid.h"
  25. #include "string.h"
  26. #include <color.h>
  27.  
  28. #if !defined(OPENRGB_DIRECT_MODE_STARTUP_RED)
  29. # define OPENRGB_DIRECT_MODE_STARTUP_RED 217
  30. #endif
  31.  
  32. #if !defined(OPENRGB_DIRECT_MODE_STARTUP_GREEN)
  33. # define OPENRGB_DIRECT_MODE_STARTUP_GREEN 71
  34. #endif
  35.  
  36. #if !defined(OPENRGB_DIRECT_MODE_STARTUP_BLUE)
  37. # define OPENRGB_DIRECT_MODE_STARTUP_BLUE 114
  38. #endif
  39.  
  40. #if !defined(OPENRGB_DIRECT_MODE_UNBUFFERED)
  41. RGB g_openrgb_direct_mode_colors[DRIVER_LED_TOTAL] = {[0 ... DRIVER_LED_TOTAL - 1] = {OPENRGB_DIRECT_MODE_STARTUP_GREEN, OPENRGB_DIRECT_MODE_STARTUP_RED, OPENRGB_DIRECT_MODE_STARTUP_BLUE}};
  42. #endif
  43.  
  44. static const uint8_t openrgb_rgb_matrix_effects_indexes[] = {
  45. 1, 2,
  46.  
  47. #ifdef ENABLE_RGB_MATRIX_ALPHAS_MODS
  48. 3,
  49. #endif
  50. #ifdef ENABLE_RGB_MATRIX_GRADIENT_UP_DOWN
  51. 4,
  52. #endif
  53. #ifdef ENABLE_RGB_MATRIX_GRADIENT_LEFT_RIGHT
  54. 5,
  55. #endif
  56. #ifdef ENABLE_RGB_MATRIX_BREATHING
  57. 6,
  58. #endif
  59. #ifdef ENABLE_RGB_MATRIX_BAND_SAT
  60. 7,
  61. #endif
  62. #ifdef ENABLE_RGB_MATRIX_BAND_VAL
  63. 8,
  64. #endif
  65. #ifdef ENABLE_RGB_MATRIX_BAND_PINWHEEL_SAT
  66. 9,
  67. #endif
  68. #ifdef ENABLE_RGB_MATRIX_BAND_PINWHEEL_VAL
  69. 10,
  70. #endif
  71. #ifdef ENABLE_RGB_MATRIX_BAND_SPIRAL_SAT
  72. 11,
  73. #endif
  74. #ifdef ENABLE_RGB_MATRIX_BAND_SPIRAL_VAL
  75. 12,
  76. #endif
  77. #ifdef ENABLE_RGB_MATRIX_CYCLE_ALL
  78. 13,
  79. #endif
  80. #ifdef ENABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
  81. 14,
  82. #endif
  83. #ifdef ENABLE_RGB_MATRIX_CYCLE_UP_DOWN
  84. 15,
  85. #endif
  86. #ifdef ENABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
  87. 16,
  88. #endif
  89. #ifdef ENABLE_RGB_MATRIX_CYCLE_OUT_IN
  90. 17,
  91. #endif
  92. #ifdef ENABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL
  93. 18,
  94. #endif
  95. #ifdef ENABLE_RGB_MATRIX_CYCLE_PINWHEEL
  96. 19,
  97. #endif
  98. #ifdef ENABLE_RGB_MATRIX_CYCLE_SPIRAL
  99. 20,
  100. #endif
  101. #ifdef ENABLE_RGB_MATRIX_DUAL_BEACON
  102. 21,
  103. #endif
  104. #ifdef ENABLE_RGB_MATRIX_RAINBOW_BEACON
  105. 22,
  106. #endif
  107. #ifdef ENABLE_RGB_MATRIX_RAINBOW_PINWHEELS
  108. 23,
  109. #endif
  110. #ifdef ENABLE_RGB_MATRIX_RAINDROPS
  111. 24,
  112. #endif
  113. #ifdef ENABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS
  114. 25,
  115. #endif
  116. #ifdef ENABLE_RGB_MATRIX_HUE_BREATHING
  117. 26,
  118. #endif
  119. #ifdef ENABLE_RGB_MATRIX_HUE_PENDULUM
  120. 27,
  121. #endif
  122. #ifdef ENABLE_RGB_MATRIX_HUE_WAVE
  123. 28,
  124. #endif
  125. #if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && defined(ENABLE_RGB_MATRIX_TYPING_HEATMAP)
  126. 30,
  127. #endif
  128. #if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && defined(ENABLE_RGB_MATRIX_DIGITAL_RAIN)
  129. 31,
  130. #endif
  131. #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED
  132. # ifdef ENABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE
  133. 32,
  134. # endif
  135. # ifdef ENABLE_RGB_MATRIX_SOLID_REACTIVE
  136. 33,
  137. # endif
  138. # ifdef ENABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE
  139. 34,
  140. # endif
  141. # ifdef ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE
  142. 35,
  143. # endif
  144. # ifdef ENABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS
  145. 36,
  146. # endif
  147. # ifdef ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS
  148. 37,
  149. # endif
  150. # ifdef ENABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS
  151. 38,
  152. # endif
  153. # ifdef ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS
  154. 39,
  155. # endif
  156. # ifdef ENABLE_RGB_MATRIX_SPLASH
  157. 40,
  158. # endif
  159. # ifdef ENABLE_RGB_MATRIX_MULTISPLASH
  160. 41,
  161. # endif
  162. # ifdef ENABLE_RGB_MATRIX_SOLID_SPLASH
  163. 42,
  164. # endif
  165. # ifdef ENABLE_RGB_MATRIX_SOLID_MULTISPLASH
  166. 43,
  167. # endif
  168. #endif
  169. };
  170. static uint8_t raw_hid_buffer[RAW_EPSIZE];
  171.  
  172. void raw_hid_receive(uint8_t *data, uint8_t length) {
  173. switch (*data) {
  174. case OPENRGB_GET_PROTOCOL_VERSION:
  175. openrgb_get_protocol_version();
  176. break;
  177. case OPENRGB_GET_QMK_VERSION:
  178. openrgb_get_qmk_version();
  179. break;
  180. case OPENRGB_GET_DEVICE_INFO:
  181. openrgb_get_device_info();
  182. break;
  183. case OPENRGB_GET_MODE_INFO:
  184. openrgb_get_mode_info();
  185. break;
  186. case OPENRGB_GET_LED_INFO:
  187. openrgb_get_led_info(data);
  188. break;
  189. case OPENRGB_GET_ENABLED_MODES:
  190. openrgb_get_enabled_modes();
  191. break;
  192.  
  193. case OPENRGB_SET_MODE:
  194. openrgb_set_mode(data);
  195. break;
  196. case OPENRGB_DIRECT_MODE_SET_SINGLE_LED:
  197. openrgb_direct_mode_set_single_led(data);
  198. break;
  199. case OPENRGB_DIRECT_MODE_SET_LEDS:
  200. openrgb_direct_mode_set_leds(data);
  201. break;
  202. }
  203.  
  204. if (*data != OPENRGB_DIRECT_MODE_SET_LEDS) {
  205. raw_hid_buffer[RAW_EPSIZE - 1] = OPENRGB_END_OF_MESSAGE;
  206. raw_hid_send(raw_hid_buffer, RAW_EPSIZE);
  207. memset(raw_hid_buffer, 0x00, RAW_EPSIZE);
  208. }
  209. }
  210.  
  211. void openrgb_get_protocol_version(void) {
  212. raw_hid_buffer[0] = OPENRGB_GET_PROTOCOL_VERSION;
  213. raw_hid_buffer[1] = OPENRGB_PROTOCOL_VERSION;
  214. }
  215. void openrgb_get_qmk_version(void) {
  216. raw_hid_buffer[0] = OPENRGB_GET_QMK_VERSION;
  217. uint8_t current_byte = 1;
  218. for (uint8_t i = 0; (current_byte < (RAW_EPSIZE - 2)) && (QMK_VERSION[i] != 0); i++) {
  219. raw_hid_buffer[current_byte] = QMK_VERSION[i];
  220. current_byte++;
  221. }
  222. }
  223. void openrgb_get_device_info(void) {
  224. raw_hid_buffer[0] = OPENRGB_GET_DEVICE_INFO;
  225. raw_hid_buffer[1] = DRIVER_LED_TOTAL;
  226. raw_hid_buffer[2] = MATRIX_COLS * MATRIX_ROWS;
  227.  
  228. #define MASSDROP_VID 0x04D8
  229. #if VENDOR_ID == MASSDROP_VID
  230. # define PRODUCT_STRING PRODUCT
  231. # define MANUFACTURER_STRING MANUFACTURER
  232. #else
  233. # define PRODUCT_STRING STR(PRODUCT)
  234. # define MANUFACTURER_STRING STR(MANUFACTURER)
  235. #endif
  236.  
  237. uint8_t current_byte = 3;
  238. for (uint8_t i = 0; (current_byte < ((RAW_EPSIZE - 2) / 2)) && (PRODUCT_STRING[i] != 0); i++) {
  239. raw_hid_buffer[current_byte] = PRODUCT_STRING[i];
  240. current_byte++;
  241. }
  242. raw_hid_buffer[current_byte] = 0;
  243. current_byte++;
  244.  
  245. for (uint8_t i = 0; (current_byte + 2 < RAW_EPSIZE) && (MANUFACTURER_STRING[i] != 0); i++) {
  246. raw_hid_buffer[current_byte] = MANUFACTURER_STRING[i];
  247. current_byte++;
  248. }
  249. }
  250. void openrgb_get_mode_info(void) {
  251. const HSV hsv_color = rgb_matrix_get_hsv();
  252.  
  253. raw_hid_buffer[0] = OPENRGB_GET_MODE_INFO;
  254. raw_hid_buffer[1] = rgb_matrix_get_mode();
  255. raw_hid_buffer[2] = rgb_matrix_get_speed();
  256. raw_hid_buffer[3] = hsv_color.h;
  257. raw_hid_buffer[4] = hsv_color.s;
  258. raw_hid_buffer[5] = hsv_color.v;
  259. }
  260. void openrgb_get_led_info(uint8_t *data) {
  261. const uint8_t first_led = data[1];
  262. const uint8_t number_leds = data[2];
  263.  
  264. raw_hid_buffer[0] = OPENRGB_GET_LED_INFO;
  265.  
  266. for (uint8_t i = 0; i < number_leds; i++) {
  267. const uint8_t led_idx = first_led + i;
  268. const uint8_t data_idx = i * 7;
  269.  
  270. if (led_idx >= DRIVER_LED_TOTAL) {
  271. raw_hid_buffer[data_idx + 3] = OPENRGB_FAILURE;
  272. } else {
  273. raw_hid_buffer[data_idx + 1] = g_led_config.point[led_idx].x;
  274. raw_hid_buffer[data_idx + 2] = g_led_config.point[led_idx].y;
  275. raw_hid_buffer[data_idx + 3] = g_led_config.flags[led_idx];
  276.  
  277. #ifdef OPENRGB_DIRECT_MODE_UNBUFFERED
  278. raw_hid_buffer[[data_idx + 4] = 0;
  279. raw_hid_buffer[[data_idx + 5] = 0;
  280. raw_hid_buffer[[data_idx + 6] = 0;
  281. #else
  282.  
  283. raw_hid_buffer[data_idx + 4] = g_openrgb_direct_mode_colors[led_idx].r;
  284. raw_hid_buffer[data_idx + 5] = g_openrgb_direct_mode_colors[led_idx].g;
  285. raw_hid_buffer[data_idx + 6] = g_openrgb_direct_mode_colors[led_idx].b;
  286. #endif
  287. }
  288.  
  289. uint8_t row = 0;
  290. uint8_t col = 0;
  291. uint8_t found = 0;
  292.  
  293. for (row = 0; row < MATRIX_ROWS; row++) {
  294. for (col = 0; col < MATRIX_COLS; col++) {
  295. if (g_led_config.matrix_co[row][col] == led_idx) {
  296. found = 1;
  297. break;
  298. }
  299. }
  300.  
  301. if (found == 1) {
  302. break;
  303. }
  304. }
  305.  
  306. if (col >= MATRIX_COLS || row >= MATRIX_ROWS) {
  307. raw_hid_buffer[data_idx + 7] = KC_NO;
  308. }
  309. else {
  310. raw_hid_buffer[data_idx + 7] = pgm_read_byte(&keymaps[0][row][col]);
  311. }
  312. }
  313. }
  314. void openrgb_get_enabled_modes(void) {
  315. raw_hid_buffer[0] = OPENRGB_GET_ENABLED_MODES;
  316. const uint8_t size = sizeof openrgb_rgb_matrix_effects_indexes / sizeof openrgb_rgb_matrix_effects_indexes[0];
  317. for (int i = 0; i < size; i++) {
  318. raw_hid_buffer[i + 1] = openrgb_rgb_matrix_effects_indexes[i];
  319. }
  320. }
  321.  
  322. void openrgb_set_mode(uint8_t *data) {
  323. const uint8_t h = data[1];
  324. const uint8_t s = data[2];
  325. const uint8_t v = data[3];
  326. const uint8_t mode = data[4];
  327. const uint8_t speed = data[5];
  328. const uint8_t save = data[6];
  329.  
  330. raw_hid_buffer[0] = OPENRGB_SET_MODE;
  331.  
  332. if (h > 255 || s > 255 || v > 255 || mode >= RGB_MATRIX_EFFECT_MAX || speed > 255) {
  333. raw_hid_buffer[RAW_EPSIZE - 2] = OPENRGB_FAILURE;
  334. return;
  335. }
  336.  
  337. if (save == 1) {
  338. rgb_matrix_mode(mode);
  339. rgb_matrix_set_speed(speed);
  340. rgb_matrix_sethsv(h, s, v);
  341. }
  342. else {
  343. rgb_matrix_mode_noeeprom(mode);
  344. rgb_matrix_set_speed_noeeprom(speed);
  345. rgb_matrix_sethsv_noeeprom(h, s, v);
  346. }
  347.  
  348. raw_hid_buffer[RAW_EPSIZE - 2] = OPENRGB_SUCCESS;
  349. }
  350. void openrgb_direct_mode_set_single_led(uint8_t *data) {
  351. const uint8_t led = data[1];
  352. const uint8_t r = data[2];
  353. const uint8_t g = data[3];
  354. const uint8_t b = data[4];
  355.  
  356. raw_hid_buffer[0] = OPENRGB_DIRECT_MODE_SET_SINGLE_LED;
  357.  
  358. if (led >= DRIVER_LED_TOTAL || r > 255 || g > 255 || b > 255) {
  359. raw_hid_buffer[RAW_EPSIZE - 2] = OPENRGB_FAILURE;
  360. return;
  361. }
  362.  
  363. #ifdef OPENRGB_DIRECT_MODE_UNBUFFERED
  364. rgb_matrix_set_color(led, r, g, b);
  365. #else
  366. g_openrgb_direct_mode_colors[led].r = r;
  367. g_openrgb_direct_mode_colors[led].g = g;
  368. g_openrgb_direct_mode_colors[led].b = b;
  369. #endif
  370.  
  371. raw_hid_buffer[RAW_EPSIZE - 2] = OPENRGB_SUCCESS;
  372. }
  373. void openrgb_direct_mode_set_leds(uint8_t *data) {
  374. const uint8_t number_leds = data[1];
  375.  
  376. for (uint8_t i = 0; i < number_leds; i++) {
  377. #ifdef OPENRGB_DIRECT_MODE_UNBUFFERED
  378. rgb_matrix_set_color(i + first_led, data[i * 3 + 3], data[i * 3 + 4], data[i * 3 + 5]);
  379. #else
  380. const uint8_t data_idx = i * 4;
  381. const uint8_t color_idx = data[data_idx + 2];
  382.  
  383. g_openrgb_direct_mode_colors[color_idx].r = data[data_idx + 3];
  384. g_openrgb_direct_mode_colors[color_idx].g = data[data_idx + 4];
  385. g_openrgb_direct_mode_colors[color_idx].b = data[data_idx + 5];
  386. #endif
  387. }
  388. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!