logo

qmk_firmware

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

keymap.c (15198B)

    

  1. /* Copyright 2020 Sergey Vlasov <sigprof@gmail.com>
  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.  */
  17. #include QMK_KEYBOARD_H
  19. enum tap_dances {
  20.     TD_OLED,
  21. };
  23. enum oled_test_modes {
  24.     // Modes between TEST_FIRST and TEST_LAST (inclusive) can be switched with a keypress.
  25.     TEST_FIRST,
  26.     TEST_LOGO = TEST_FIRST,
  27.     TEST_CHARACTERS,
  28.     TEST_SLOW_UPDATE,
  29.     TEST_ALL_ON,
  30.     TEST_FRAME,
  31.     TEST_ALL_OFF,
  32.     TEST_FILL_HORZ_0,
  33.     TEST_FILL_HORZ_1,
  34.     TEST_FILL_VERT_0,
  35.     TEST_FILL_VERT_1,
  36.     TEST_FILL_CHECKERBOARD_1,
  37.     TEST_FILL_CHECKERBOARD_2,
  38.     TEST_FILL_CHECKERBOARD_4,
  39.     TEST_LAST = TEST_FILL_CHECKERBOARD_4,
  41.     // Special modes which are not reachable normally.
  42.     TEST_DRAW_ALWAYS_ON,
  43.     TEST_DRAW_ALWAYS_OFF,
  44. };
  46. static enum oled_test_modes test_mode = TEST_FIRST;
  48. static oled_rotation_t rotation = OLED_ROTATION_0;
  50. static bool     scrolling;
  51. static uint8_t  scrolling_speed;
  52. static bool     need_update = true;
  53. static bool     draw_always;
  54. static bool     update_speed_test;
  55. static uint32_t update_speed_start_timer;
  56. static uint16_t update_speed_count;
  57. static bool     restart_test;
  59. static void stop_scrolling(void) {
  60.     if (scrolling) {
  61.         oled_scroll_off();
  62.         scrolling = false;
  63.     }
  64. }
  66. static void dance_oled_finished(tap_dance_state_t *state, void *user_data) {
  67.     switch (state->count) {
  68.         case 1:
  69.             if (state->pressed) {
  70.                 // single hold - step through rotations
  71.                 switch (rotation) {
  72.                     case OLED_ROTATION_0:
  73.                         rotation = OLED_ROTATION_90;
  74.                         break;
  75.                     case OLED_ROTATION_90:
  76.                         rotation = OLED_ROTATION_180;
  77.                         break;
  78.                     case OLED_ROTATION_180:
  79.                         rotation = OLED_ROTATION_270;
  80.                         break;
  81.                     default:
  82.                         rotation = OLED_ROTATION_0;
  83.                         break;
  84.                 }
  85.                 stop_scrolling();
  86.                 oled_init(rotation);
  87.             } else {
  88.                 // single tap - step through test modes
  89.                 if (test_mode < TEST_LAST) {
  90.                     ++test_mode;
  91.                 } else {
  92.                     test_mode = TEST_FIRST;
  93.                 }
  94.                 stop_scrolling();
  95.                 oled_clear();
  96.             }
  97.             restart_test = true;
  98.             need_update  = true;
  99.             break;
  101.         case 2:
  102.             if (state->pressed) {
  103.                 // tap + hold - change scrolling speed
  104.                 scrolling_speed = (scrolling_speed + 1) % 8;
  105.                 stop_scrolling();
  106.                 oled_scroll_set_speed(scrolling_speed);
  107.                 // Cannot reactivate scrolling here, because oled_scroll_off()
  108.                 // marks the whole display as dirty, and oled_scroll_left()
  109.                 // silently does nothing if either the display is dirty or
  110.                 // scrolling is already active.
  111.             } else {
  112.                 // double tap - toggle scrolling
  113.                 if (!scrolling) {
  114.                     scrolling = true;
  115.                     oled_scroll_left();
  116.                 } else {
  117.                     scrolling = false;
  118.                     oled_scroll_off();
  119.                 }
  120.             }
  121.             need_update = true;
  122.             break;
  124.         case 3:
  125.             if (state->pressed) {
  126.                 // double tap + hold - toggle `draw_always`
  127.                 draw_always = !draw_always;
  128.                 if (draw_always) {
  129.                     test_mode = TEST_DRAW_ALWAYS_ON;
  130.                 } else {
  131.                     test_mode = TEST_DRAW_ALWAYS_OFF;
  132.                 }
  133.                 stop_scrolling();
  134.                 oled_clear();
  135.                 restart_test = true;
  136.                 need_update  = true;
  137.             } else {
  138.                 // triple tap - toggle update speed test
  139.                 update_speed_test = !update_speed_test;
  140.                 if (update_speed_test) {
  141.                     stop_scrolling();
  142.                     update_speed_start_timer = timer_read32();
  143.                     update_speed_count       = 0;
  144.                 }
  145.             }
  146.             break;
  147.         case 4:
  148.             if (!state->pressed) {
  149.                 // quadruple tap - step through brightness levels
  150.                 oled_set_brightness(oled_get_brightness() + 0x10);
  151.             }
  152.             break;
  153.         default:
  154.             break;
  155.     }
  156. }
  158. tap_dance_action_t tap_dance_actions[] = {[TD_OLED] = ACTION_TAP_DANCE_FN(dance_oled_finished)};
  160. const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {LAYOUT_ortho_1x1(TD(TD_OLED))};
  162. // `bool oled_is_dirty(void)` does not exist at the moment
  163. extern OLED_BLOCK_TYPE oled_dirty;
  165. static inline uint8_t pixel_width(void) {
  166.     if (!(rotation & OLED_ROTATION_90)) {
  167.         return OLED_DISPLAY_WIDTH;
  168.     }
  169.     return OLED_DISPLAY_HEIGHT;
  170. }
  172. static inline uint8_t pixel_height(void) {
  173.     if (!(rotation & OLED_ROTATION_90)) {
  174.         return OLED_DISPLAY_HEIGHT;
  175.     }
  176.     return OLED_DISPLAY_WIDTH;
  177. }
  179. // Draw the QMK logo at the top left corner, clipping if it does not fit.
  180. static void test_logo(void) {
  181.     uint8_t lines = oled_max_lines();
  182.     if (lines > 3) {
  183.         lines = 3;
  184.     }
  185.     uint8_t chars = oled_max_chars();
  186.     if (chars > 21) {
  187.         chars = 21;
  188.     }
  189.     for (uint8_t row = 0; row < lines; ++row) {
  190.         oled_set_cursor(0, row);
  191.         for (uint8_t col = 0; col < chars; ++col) {
  192.             oled_write_char(0x80 + 0x20 * row + col, false);
  193.         }
  194.     }
  195. }
  197. static const PROGMEM char fill_ff[OLED_MATRIX_SIZE] = {[0 ... OLED_MATRIX_SIZE - 1] = 0xff};
  199. // Fill the whole screen with a pattern made from two bytes alternating after the specified number of repeats.
  200. static void test_fill(uint8_t byte0, uint8_t byte1, uint8_t repeats) {
  201.     uint8_t  width = pixel_width();
  202.     uint8_t  lines = oled_max_lines();
  203.     uint16_t index = 0;
  204.     for (uint8_t row = 0; row < lines; ++row) {
  205.         for (uint8_t col = 0; col < width; ++col) {
  206.             uint8_t byte = ((col / repeats) % 2) ? byte1 : byte0;
  207.             oled_write_raw_byte(byte, index++);
  208.         }
  209.     }
  210. }
  212. // Draw a frame at the edges of the OLED screen.
  213. static void test_frame(void) {
  214.     uint8_t width  = pixel_width();
  215.     uint8_t height = pixel_height();
  216.     for (uint8_t x = 0; x < width; ++x) {
  217.         oled_write_pixel(x, 0, true);
  218.         oled_write_pixel(x, height - 1, true);
  219.     }
  220.     for (uint8_t y = 1; y < height - 1; ++y) {
  221.         oled_write_pixel(0, y, true);
  222.         oled_write_pixel(width - 1, y, true);
  223.     }
  224. }
  226. // Use all 94 visible ASCII characters for testing.
  227. #define TEST_CHAR_COUNT ('~' - '!' + 1)
  229. static char get_test_char(uint8_t char_index) { return char_index + '!'; }
  231. // Fill the whole screen with distinct characters (if the display is large enough to show more than 94 characters
  232. // at once, the sequence is repeated the second time with inverted characters).
  233. static void test_characters(void) {
  234.     uint8_t cols       = oled_max_chars();
  235.     uint8_t rows       = oled_max_lines();
  236.     bool    invert     = false;
  237.     uint8_t char_index = 0;
  238.     for (uint8_t row = 0; row < rows; ++row) {
  239.         for (uint8_t col = 0; col < cols; ++col) {
  240.             oled_write_char(get_test_char(char_index), invert);
  241.             if (++char_index >= TEST_CHAR_COUNT) {
  242.                 char_index = 0;
  243.                 invert     = !invert;
  244.             }
  245.         }
  246.     }
  247. }
  249. // Test screen updating after drawing a single character or pixel.
  250. void test_slow_update(void) {
  251.     static uint8_t  phase, x, y, char_index, first_char;
  252.     static uint16_t timer;
  253.     static uint16_t delay = 500;
  255.     if (restart_test) {
  256.         // Initialize all state variables before starting the test.
  257.         restart_test = false;
  258.         phase        = 0;
  259.         x            = 0;
  260.         y            = 0;
  261.         char_index   = 0;
  262.         first_char   = 0;
  263.         delay        = 500;
  264.     } else {
  265.         // Wait for the specified time between steps.
  266.         if (timer_elapsed(timer) < delay) {
  267.             return;
  268.         }
  269.     }
  271.     timer = timer_read();
  272.     switch (phase) {
  273.         case 0:
  274.             // Phase 0: fill the whole screen with mostly distinct characters, one character at a time.  Here the
  275.             // inversion trick is not used, so that the frame which is drawn in subsequent phases would not be
  276.             // overlapped by the inverted character background.
  277.             oled_set_cursor(x, y);
  278.             oled_write_char(get_test_char(char_index), false);
  279.             if (++char_index >= TEST_CHAR_COUNT) {
  280.                 char_index = 0;
  281.             }
  282.             if (++x >= oled_max_chars()) {
  283.                 x = 0;
  284.                 if (++y >= oled_max_lines()) {
  285.                     // The whole screen was filled - start the next phase.
  286.                     ++phase;
  287.                     x = y = 0;
  288.                 }
  289.             }
  290.             delay = 250;
  291.             break;
  293.         case 1:
  294.             // Phase 1: draw a line along the left edge of the screen, one pixel at a time.
  295.             oled_write_pixel(x, y, true);
  296.             if (y < pixel_height() - 1) {
  297.                 ++y;
  298.             } else {
  299.                 // The bottom left corner is reached - start the next phase.
  300.                 ++phase;
  301.                 ++x;
  302.             }
  303.             delay = 50;
  304.             break;
  306.         case 2:
  307.             // Phase 2: draw a line along the bottom edge of the screen, one pixel at a time.
  308.             oled_write_pixel(x, y, true);
  309.             if (x < pixel_width() - 1) {
  310.                 ++x;
  311.             } else {
  312.                 // The bottom right corner was reached - start the next phase.
  313.                 ++phase;
  314.                 --y;
  315.             }
  316.             delay = 50;
  317.             break;
  319.         case 3:
  320.             // Phase 3: draw a line along the right edge of the screen, one pixel at a time.
  321.             oled_write_pixel(x, y, true);
  322.             if (y > 0) {
  323.                 --y;
  324.             } else {
  325.                 // The top right corner was reached - start the next phase.
  326.                 ++phase;
  327.                 --x;
  328.             }
  329.             delay = 50;
  330.             break;
  332.         case 4:
  333.             // Phase 4: draw a line along the top edge of the screen, one pixel at a time.
  334.             oled_write_pixel(x, y, true);
  335.             if (x > 0) {
  336.                 --x;
  337.             } else {
  338.                 // The top left corner was reached - start the next phase.
  339.                 ++phase;
  340.             }
  341.             delay = 50;
  342.             break;
  344.         default:
  345.             // Restart from phase 0, but change the first character of the sequence to make screen updates visible.
  346.             if (++first_char >= TEST_CHAR_COUNT) {
  347.                 first_char = 0;
  348.             }
  349.             phase      = 0;
  350.             x          = 0;
  351.             y          = 0;
  352.             char_index = first_char;
  353.             delay      = 500;
  354.             break;
  355.     }
  356. }
  358. oled_rotation_t oled_init_user(oled_rotation_t rotation) {
  359.     oled_scroll_set_area(0, 0);
  360.     oled_scroll_set_speed(scrolling_speed);
  361.     return rotation;
  362. }
  364. bool oled_task_user(void) {
  365.     if (update_speed_test) {
  366.         // Speed test mode - wait for screen update completion.
  367.         if (!oled_dirty) {
  368.             // Update statistics and send the measurement result to the console.
  369.             update_speed_count++;
  370.             if (update_speed_count % 256 == 0) {
  371.                 uprintf("OLED: %u updates, %lu ms\n", update_speed_count, timer_elapsed32(update_speed_start_timer));
  372.             }
  374.             // Toggle between the "all on" and "all off" states and trigger the screen update again.
  375.             if (test_mode == TEST_ALL_ON) {
  376.                 test_mode = TEST_ALL_OFF;
  377.             } else {
  378.                 test_mode = TEST_ALL_ON;
  379.             }
  380.             need_update = true;
  381.         }
  382.     }
  384.     // The sample implementation of oled_task_user() in the documentation redraws the image after every call, relying on
  385.     // the fact that drawing functions check whether the output actually changes anything in the image, and set dirty
  386.     // bits only when something has actually changed.  However, redrawing the image only when some of the underlying
  387.     // data has changed is more efficient.  Make it possible to test both modes here.
  388.     if (!draw_always || update_speed_test) {
  389.         // Draw the image only when the `need_update` flag is set, except for the "slow update" test.
  390.         // This mode is also forced when the screen update speed test is performed.
  391.         if (!need_update) {
  392.             if (test_mode != TEST_SLOW_UPDATE) {
  393.                 return false;
  394.             }
  395.         }
  396.         need_update = false;
  397.     }
  399.     switch (test_mode) {
  400.         case TEST_LOGO:
  401.             test_logo();
  402.             break;
  403.         case TEST_CHARACTERS:
  404.             test_characters();
  405.             break;
  406.         case TEST_SLOW_UPDATE:
  407.             test_slow_update();
  408.             break;
  409.         case TEST_ALL_ON:
  410.             oled_write_raw_P(fill_ff, sizeof(fill_ff));
  411.             break;
  412.         case TEST_FRAME:
  413.             test_frame();
  414.             break;
  415.         case TEST_ALL_OFF:
  416.             // `oled_clear()` is faster, but cannot be used with `draw_always`, because it does not check the previous
  417.             // content of the buffer and always marks the whole buffer as dirty.
  418.             if (update_speed_test) {
  419.                 oled_clear();
  420.             } else {
  421.                 test_fill(0x00, 0x00, 1);
  422.             }
  423.             break;
  424.         case TEST_FILL_HORZ_0:
  425.             test_fill(0x55, 0x55, 1);
  426.             break;
  427.         case TEST_FILL_HORZ_1:
  428.             test_fill(0xaa, 0xaa, 1);
  429.             break;
  430.         case TEST_FILL_VERT_0:
  431.             test_fill(0xff, 0x00, 1);
  432.             break;
  433.         case TEST_FILL_VERT_1:
  434.             test_fill(0x00, 0xff, 1);
  435.             break;
  436.         case TEST_FILL_CHECKERBOARD_1:
  437.             test_fill(0x55, 0xaa, 1);
  438.             break;
  439.         case TEST_FILL_CHECKERBOARD_2:
  440.             test_fill(0x33, 0xcc, 2);
  441.             break;
  442.         case TEST_FILL_CHECKERBOARD_4:
  443.             test_fill(0x0f, 0xf0, 4);
  444.             break;
  446.         case TEST_DRAW_ALWAYS_ON:
  447.             oled_write_P(PSTR("Draw Always"), false);
  448.             break;
  449.         case TEST_DRAW_ALWAYS_OFF:
  450.             oled_write_P(PSTR("Draw Once"), false);
  451.             break;
  452.     }
  453.     return false;
  454. }
  456. void keyboard_post_init_user(void) {
  457.     // Console messages are used for update speed test results
  458.     debug_enable = true;
  459. }