Browse Source
Refactor the crkbd/via keymap and fix OLED bugs (#10354)
* Refactor the crkbd/via keymap and fix OLED bugs
* Revert "Refactor the crkbd/via keymap and fix OLED bugs"
This reverts commit dc9db029fc.
* Fix OLED display bugs
* Remove unused functions
* Remove uncessary the key logger
* Add new lines at end of file
* Remove unnecesary extern for is_master
* Remove extern is_master from rev1.h
* Remove ssd1306 from common dir because its the legacy lib
* Update default keymap based the via keymap
* Remove foostan keymap because it will be legacy
* Revert Remove unnecesary extern for is_master
* Remove unnecessary backslashes.
pull/10964/head
Kosuke Adachi
3 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 122 additions and 874 deletions
Split View
Diff Options
-
+2 -2keyboards/crkbd/keymaps/default/config.h
-
+102 -163keyboards/crkbd/keymaps/default/keymap.c
-
+1 -10keyboards/crkbd/keymaps/default/rules.mk
-
+0 -44keyboards/crkbd/keymaps/foostan/config.h
-
+0 -241keyboards/crkbd/keymaps/foostan/keymap.c
-
+0 -10keyboards/crkbd/keymaps/foostan/rules.mk
-
+0 -2keyboards/crkbd/rev1/common/common.c
-
+1 -1keyboards/crkbd/rev1/common/common.h
-
+14 -33keyboards/crkbd/rev1/common/keymaps/via/keymap.c
-
+0 -360keyboards/crkbd/rev1/common/ssd1306.c
-
+2 -0keyboards/crkbd/rev1/legacy/legacy.h
-
+0 -0keyboards/crkbd/rev1/legacy/ssd1306.h
-
+0 -4keyboards/crkbd/rev1/rev1.c
-
+0 -2keyboards/crkbd/rev1/rev1.h
-
+0 -2layouts/community/split_3x6_3/drashna/keymap.c
+ 2
- 2
keyboards/crkbd/keymaps/default/config.h
View File
+ 102
- 163
keyboards/crkbd/keymaps/default/keymap.c
View File
+ 1
- 10
keyboards/crkbd/keymaps/default/rules.mk
View File
| @ -1,10 +1 @@ | |||
| # If you want to change the display of OLED, you need to change here | |||
| SRC += ./lib/glcdfont.c \ | |||
| ./lib/rgb_state_reader.c \ | |||
| ./lib/layer_state_reader.c \ | |||
| ./lib/logo_reader.c \ | |||
| ./lib/keylogger.c \ | |||
| # ./lib/mode_icon_reader.c \ | |||
| # ./lib/host_led_state_reader.c \ | |||
| # ./lib/timelogger.c \ | |||
| OLED_DRIVER_ENABLE = yes | |||
+ 0
- 44
keyboards/crkbd/keymaps/foostan/config.h
View File
| @ -1,44 +0,0 @@ | |||
| /* | |||
| This is the c configuration file for the keymap | |||
| Copyright 2012 Jun Wako <wakojun@gmail.com> | |||
| Copyright 2015 Jack Humbert | |||
| This program is free software: you can redistribute it and/or modify | |||
| it under the terms of the GNU General Public License as published by | |||
| the Free Software Foundation, either version 2 of the License, or | |||
| (at your option) any later version. | |||
| This program is distributed in the hope that it will be useful, | |||
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
| GNU General Public License for more details. | |||
| You should have received a copy of the GNU General Public License | |||
| along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
| */ | |||
| #pragma once | |||
| //#define USE_MATRIX_I2C | |||
| /* Select hand configuration */ | |||
| #define MASTER_LEFT | |||
| // #define MASTER_RIGHT | |||
| // #define EE_HANDS | |||
| #define SSD1306OLED | |||
| #define USE_SERIAL_PD2 | |||
| #define TAPPING_FORCE_HOLD | |||
| #define TAPPING_TERM 100 | |||
| #undef RGBLED_NUM | |||
| #define RGBLIGHT_ANIMATIONS | |||
| #define RGBLED_NUM 27 | |||
| #define RGBLIGHT_LIMIT_VAL 120 | |||
| #define RGBLIGHT_HUE_STEP 10 | |||
| #define RGBLIGHT_SAT_STEP 17 | |||
| #define RGBLIGHT_VAL_STEP 17 | |||
+ 0
- 241
keyboards/crkbd/keymaps/foostan/keymap.c
View File
| @ -1,241 +0,0 @@ | |||
| #include QMK_KEYBOARD_H | |||
| #ifdef PROTOCOL_LUFA | |||
| #include "lufa.h" | |||
| #include "split_util.h" | |||
| #endif | |||
| #ifdef SSD1306OLED | |||
| #include "ssd1306.h" | |||
| #endif | |||
| extern keymap_config_t keymap_config; | |||
| #ifdef RGBLIGHT_ENABLE | |||
| //Following line allows macro to read current RGB settings | |||
| extern rgblight_config_t rgblight_config; | |||
| #endif | |||
| extern uint8_t is_master; | |||
| // Each layer gets a name for readability, which is then used in the keymap matrix below. | |||
| // The underscores don't mean anything - you can have a layer called STUFF or any other name. | |||
| // Layer names don't all need to be of the same length, obviously, and you can also skip them | |||
| // entirely and just use numbers. | |||
| #define _QWERTY 0 | |||
| #define _LOWER 1 | |||
| #define _RAISE 2 | |||
| #define _ADJUST 3 | |||
| enum custom_keycodes { | |||
| QWERTY = SAFE_RANGE, | |||
| LOWER, | |||
| RAISE, | |||
| ADJUST, | |||
| BACKLIT, | |||
| RGBRST | |||
| }; | |||
| enum macro_keycodes { | |||
| KC_SAMPLEMACRO, | |||
| }; | |||
| #define KC______ KC_TRNS | |||
| #define KC_XXXXX KC_NO | |||
| #define KC_LOWER LOWER | |||
| #define KC_RAISE RAISE | |||
| #define KC_RST RESET | |||
| #define KC_LRST RGBRST | |||
| #define KC_LTOG RGB_TOG | |||
| #define KC_LHUI RGB_HUI | |||
| #define KC_LHUD RGB_HUD | |||
| #define KC_LSAI RGB_SAI | |||
| #define KC_LSAD RGB_SAD | |||
| #define KC_LVAI RGB_VAI | |||
| #define KC_LVAD RGB_VAD | |||
| #define KC_LMOD RGB_MOD | |||
| #define KC_GUIEI GUI_T(KC_LANG2) | |||
| #define KC_ALTKN ALT_T(KC_LANG1) | |||
| const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
| [_QWERTY] = LAYOUT_kc( \ | |||
| //,-----------------------------------------. ,-----------------------------------------. | |||
| TAB, Q, W, E, R, T, Y, U, I, O, P, BSPC,\ | |||
| //|------+------+------+------+------+------| |------+------+------+------+------+------| | |||
| LCTL, A, S, D, F, G, H, J, K, L, SCLN, QUOT,\ | |||
| //|------+------+------+------+------+------| |------+------+------+------+------+------| | |||
| LSFT, Z, X, C, V, B, N, M, COMM, DOT, SLSH, ESC,\ | |||
| //|------+------+------+------+------+------+------| |------+------+------+------+------+------+------| | |||
| GUIEI, LOWER, SPC, ENT, RAISE, ALTKN \ | |||
| //`--------------------' `--------------------' | |||
| ), | |||
| [_LOWER] = LAYOUT_kc( \ | |||
| //,-----------------------------------------. ,-----------------------------------------. | |||
| TAB, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, BSPC,\ | |||
| //|------+------+------+------+------+------| |------+------+------+------+------+------| | |||
| LCTL, F1, F2, F3, F4, F5, LEFT, DOWN, UP, RIGHT, XXXXX, XXXXX,\ | |||
| //|------+------+------+------+------+------| |------+------+------+------+------+------| | |||
| LSFT, F6, F7, F8, F9, F10, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX,\ | |||
| //|------+------+------+------+------+------+------| |------+------+------+------+------+------+------| | |||
| GUIEI, LOWER, SPC, ENT, RAISE, ALTKN \ | |||
| //`--------------------' `--------------------' | |||
| ), | |||
| [_RAISE] = LAYOUT_kc( \ | |||
| //,-----------------------------------------. ,-----------------------------------------. | |||
| TAB, EXLM, AT, HASH, DLR, PERC, CIRC, AMPR, ASTR, LPRN, RPRN, BSPC,\ | |||
| //|------+------+------+------+------+------| |------+------+------+------+------+------| | |||
| LCTL, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, MINS, EQL, LCBR, RCBR, PIPE, GRV,\ | |||
| //|------+------+------+------+------+------| |------+------+------+------+------+------| | |||
| LSFT, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, UNDS, PLUS, LBRC, RBRC, BSLS, TILD,\ | |||
| //|------+------+------+------+------+------+------| |------+------+------+------+------+------+------| | |||
| GUIEI, LOWER, SPC, ENT, RAISE, ALTKN \ | |||
| //`--------------------' `--------------------' | |||
| ), | |||
| [_ADJUST] = LAYOUT_kc( \ | |||
| //,-----------------------------------------. ,-----------------------------------------. | |||
| RST, LRST, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX,\ | |||
| //|------+------+------+------+------+------| |------+------+------+------+------+------| | |||
| LTOG, LHUI, LSAI, LVAI, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX,\ | |||
| //|------+------+------+------+------+------| |------+------+------+------+------+------| | |||
| LMOD, LHUD, LSAD, LVAD, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX,\ | |||
| //|------+------+------+------+------+------+------| |------+------+------+------+------+------+------| | |||
| GUIEI, LOWER, SPC, ENT, RAISE, ALTKN \ | |||
| //`--------------------' `--------------------' | |||
| ) | |||
| }; | |||
| int RGB_current_mode; | |||
| void persistent_default_layer_set(uint16_t default_layer) { | |||
| eeconfig_update_default_layer(default_layer); | |||
| default_layer_set(default_layer); | |||
| } | |||
| // Setting ADJUST layer RGB back to default | |||
| void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) { | |||
| if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) { | |||
| layer_on(layer3); | |||
| } else { | |||
| layer_off(layer3); | |||
| } | |||
| } | |||
| void matrix_init_user(void) { | |||
| #ifdef RGBLIGHT_ENABLE | |||
| RGB_current_mode = rgblight_config.mode; | |||
| #endif | |||
| //SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h | |||
| #ifdef SSD1306OLED | |||
| iota_gfx_init(!has_usb()); // turns on the display | |||
| #endif | |||
| } | |||
| //SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h | |||
| #ifdef SSD1306OLED | |||
| // When add source files to SRC in rules.mk, you can use functions. | |||
| const char *read_layer_state(void); | |||
| const char *read_logo(void); | |||
| void set_keylog(uint16_t keycode, keyrecord_t *record); | |||
| const char *read_keylog(void); | |||
| const char *read_keylogs(void); | |||
| // const char *read_mode_icon(bool swap); | |||
| // const char *read_host_led_state(void); | |||
| // void set_timelog(void); | |||
| // const char *read_timelog(void); | |||
| void matrix_scan_user(void) { | |||
| iota_gfx_task(); | |||
| } | |||
| void matrix_render_user(struct CharacterMatrix *matrix) { | |||
| if (is_master) { | |||
| // If you want to change the display of OLED, you need to change here | |||
| matrix_write_ln(matrix, read_layer_state()); | |||
| matrix_write_ln(matrix, read_keylog()); | |||
| matrix_write_ln(matrix, read_keylogs()); | |||
| //matrix_write_ln(matrix, read_mode_icon(keymap_config.swap_lalt_lgui)); | |||
| //matrix_write_ln(matrix, read_host_led_state()); | |||
| //matrix_write_ln(matrix, read_timelog()); | |||
| } else { | |||
| matrix_write(matrix, read_logo()); | |||
| } | |||
| } | |||
| void matrix_update(struct CharacterMatrix *dest, const struct CharacterMatrix *source) { | |||
| if (memcmp(dest->display, source->display, sizeof(dest->display))) { | |||
| memcpy(dest->display, source->display, sizeof(dest->display)); | |||
| dest->dirty = true; | |||
| } | |||
| } | |||
| void iota_gfx_task_user(void) { | |||
| struct CharacterMatrix matrix; | |||
| matrix_clear(&matrix); | |||
| matrix_render_user(&matrix); | |||
| matrix_update(&display, &matrix); | |||
| } | |||
| #endif//SSD1306OLED | |||
| bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
| if (record->event.pressed) { | |||
| #ifdef SSD1306OLED | |||
| set_keylog(keycode, record); | |||
| #endif | |||
| // set_timelog(); | |||
| } | |||
| switch (keycode) { | |||
| case QWERTY: | |||
| if (record->event.pressed) { | |||
| persistent_default_layer_set(1UL<<_QWERTY); | |||
| } | |||
| return false; | |||
| case LOWER: | |||
| if (record->event.pressed) { | |||
| layer_on(_LOWER); | |||
| update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); | |||
| } else { | |||
| layer_off(_LOWER); | |||
| update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); | |||
| } | |||
| return false; | |||
| case RAISE: | |||
| if (record->event.pressed) { | |||
| layer_on(_RAISE); | |||
| update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); | |||
| } else { | |||
| layer_off(_RAISE); | |||
| update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); | |||
| } | |||
| return false; | |||
| case ADJUST: | |||
| if (record->event.pressed) { | |||
| layer_on(_ADJUST); | |||
| } else { | |||
| layer_off(_ADJUST); | |||
| } | |||
| return false; | |||
| case RGB_MOD: | |||
| #ifdef RGBLIGHT_ENABLE | |||
| if (record->event.pressed) { | |||
| rgblight_mode(RGB_current_mode); | |||
| rgblight_step(); | |||
| RGB_current_mode = rgblight_config.mode; | |||
| } | |||
| #endif | |||
| return false; | |||
| case RGBRST: | |||
| #ifdef RGBLIGHT_ENABLE | |||
| if (record->event.pressed) { | |||
| eeconfig_update_rgblight_default(); | |||
| rgblight_enable(); | |||
| RGB_current_mode = rgblight_config.mode; | |||
| } | |||
| #endif | |||
| break; | |||
| } | |||
| return true; | |||
| } | |||
+ 0
- 10
keyboards/crkbd/keymaps/foostan/rules.mk
View File
| @ -1,10 +0,0 @@ | |||
| # If you want to change the display of OLED, you need to change here | |||
| SRC += ./lib/glcdfont.c \ | |||
| ./lib/rgb_state_reader.c \ | |||
| ./lib/layer_state_reader.c \ | |||
| ./lib/logo_reader.c \ | |||
| ./lib/keylogger.c \ | |||
| # ./lib/mode_icon_reader.c \ | |||
| # ./lib/host_led_state_reader.c \ | |||
| # ./lib/timelogger.c \ | |||
+ 0
- 2
keyboards/crkbd/rev1/common/common.c
View File
+ 1
- 1
keyboards/crkbd/rev1/common/common.h
View File
+ 14
- 33
keyboards/crkbd/rev1/common/keymaps/via/keymap.c
View File
+ 0
- 360
keyboards/crkbd/rev1/common/ssd1306.c
View File
| @ -1,360 +0,0 @@ | |||
| #ifdef SSD1306OLED | |||
| #include "ssd1306.h" | |||
| #include "i2c_master.h" | |||
| #include <string.h> | |||
| #include "print.h" | |||
| #ifdef ADAFRUIT_BLE_ENABLE | |||
| #include "adafruit_ble.h" | |||
| #endif | |||
| #ifdef PROTOCOL_LUFA | |||
| #include "lufa.h" | |||
| #endif | |||
| #include "sendchar.h" | |||
| #include "timer.h" | |||
| struct CharacterMatrix display; | |||
| extern const unsigned char font[] PROGMEM; | |||
| #ifndef OLED_BLANK_CHAR | |||
| #define OLED_BLANK_CHAR ' ' | |||
| #endif | |||
| #ifndef OLED_BITS_FILTER | |||
| #define OLED_BITS_FILTER | |||
| #endif | |||
| // Set this to 1 to help diagnose early startup problems | |||
| // when testing power-on with ble. Turn it off otherwise, | |||
| // as the latency of printing most of the debug info messes | |||
| // with the matrix scan, causing keys to drop. | |||
| #define DEBUG_TO_SCREEN 0 | |||
| //static uint16_t last_battery_update; | |||
| //static uint32_t vbat; | |||
| //#define BatteryUpdateInterval 10000 /* milliseconds */ | |||
| // 'last_flush' is declared as uint16_t, | |||
| // so this must be less than 65535 | |||
| #ifndef ScreenOffInterval | |||
| #define ScreenOffInterval 60000 /* milliseconds */ | |||
| #endif | |||
| #if DEBUG_TO_SCREEN | |||
| static uint8_t displaying; | |||
| #endif | |||
| static uint16_t last_flush; | |||
| static bool force_dirty = true; | |||
| // Write command sequence. | |||
| // Returns true on success. | |||
| static inline bool _send_cmd1(uint8_t cmd) { | |||
| bool res = false; | |||
| if (i2c_start(SSD1306_ADDRESS, 100)) { | |||
| xprintf("failed to start write to %d\n", SSD1306_ADDRESS); | |||
| goto done; | |||
| } | |||
| if (i2c_write(0x0 /* command byte follows */, 100)) { | |||
| print("failed to write control byte\n"); | |||
| goto done; | |||
| } | |||
| if (i2c_write(cmd, 100)) { | |||
| xprintf("failed to write command %d\n", cmd); | |||
| goto done; | |||
| } | |||
| res = true; | |||
| done: | |||
| i2c_stop(); | |||
| return res; | |||
| } | |||
| #define send_cmd1(c) if (!_send_cmd1(c)) {goto done;} | |||
| #define send_cmds(c) if (!_send_cmds(c,sizeof(c))) {goto done;} | |||
| #define cmd1(X) X | |||
| #define cmd2(X,Y) X,Y | |||
| #define cmd3(X,Y,Z) X,Y,Z | |||
| static bool _send_cmds(const uint8_t* p,uint8_t sz) { | |||
| for(uint8_t i=sz;i;i--) { | |||
| send_cmd1( pgm_read_byte(p++) ); | |||
| } | |||
| return true; | |||
| done: | |||
| return false; | |||
| } | |||
| #define SEND_CMDS(...) {static const uint8_t _cmds[] PROGMEM = { __VA_ARGS__,0 };send_cmds(_cmds);} | |||
| static void clear_display(void) { | |||
| matrix_clear(&display); | |||
| // Clear all of the display bits (there can be random noise | |||
| // in the RAM on startup) | |||
| SEND_CMDS( | |||
| cmd3(PageAddr, 0, (DisplayHeight / 8) - 1), | |||
| cmd3(ColumnAddr, 0, DisplayWidth - 1) | |||
| ); | |||
| if (i2c_start(SSD1306_ADDRESS, 100)) { | |||
| goto done; | |||
| } | |||
| if (i2c_write(0x40, 100)) { | |||
| // Data mode | |||
| goto done; | |||
| } | |||
| for (uint8_t row = MatrixRows;row; row--) { | |||
| for (uint8_t col = DisplayWidth; col; col--) { | |||
| i2c_write(0, 100); | |||
| } | |||
| } | |||
| display.dirty = false; | |||
| done: | |||
| i2c_stop(); | |||
| } | |||
| #if DEBUG_TO_SCREEN | |||
| #undef sendchar | |||
| static int8_t capture_sendchar(uint8_t c) { | |||
| sendchar(c); | |||
| iota_gfx_write_char(c); | |||
| if (!displaying) { | |||
| iota_gfx_flush(); | |||
| } | |||
| return 0; | |||
| } | |||
| #endif | |||
| bool iota_gfx_init(bool rotate) { | |||
| bool success = false; | |||
| i2c_init(); | |||
| SEND_CMDS( | |||
| cmd1(DisplayOff), | |||
| cmd2(SetDisplayClockDiv, 0x80), | |||
| cmd2(SetMultiPlex, DisplayHeight - 1), | |||
| cmd2(SetDisplayOffset, 0), | |||
| cmd1(SetStartLine | 0x0), | |||
| cmd2(SetChargePump, 0x14 /* Enable */), | |||
| cmd2(SetMemoryMode, 0 /* horizontal addressing */) | |||
| ); | |||
| if(rotate){ | |||
| // the following Flip the display orientation 180 degrees | |||
| SEND_CMDS( | |||
| cmd1(SegRemap), | |||
| cmd1(ComScanInc) | |||
| ); | |||
| }else{ | |||
| // Flips the display orientation 0 degrees | |||
| SEND_CMDS( | |||
| cmd1(SegRemap | 0x1), | |||
| cmd1(ComScanDec) | |||
| ); | |||
| } | |||
| SEND_CMDS( | |||
| #ifdef SSD1306_128X64 | |||
| cmd2(SetComPins, 0x12), | |||
| #else | |||
| cmd2(SetComPins, 0x2), | |||
| #endif | |||
| cmd2(SetContrast, 0x8f), | |||
| cmd2(SetPreCharge, 0xf1), | |||
| cmd2(SetVComDetect, 0x40), | |||
| cmd1(DisplayAllOnResume), | |||
| cmd1(NormalDisplay), | |||
| cmd1(DeActivateScroll), | |||
| cmd1(DisplayOn), | |||
| cmd2(SetContrast, 0) // Dim | |||
| ); | |||
| clear_display(); | |||
| success = true; | |||
| iota_gfx_flush(); | |||
| #if DEBUG_TO_SCREEN | |||
| print_set_sendchar(capture_sendchar); | |||
| #endif | |||
| done: | |||
| return success; | |||
| } | |||
| bool iota_gfx_off(void) { | |||
| bool success = false; | |||
| send_cmd1(DisplayOff); | |||
| success = true; | |||
| done: | |||
| return success; | |||
| } | |||
| bool iota_gfx_on(void) { | |||
| bool success = false; | |||
| send_cmd1(DisplayOn); | |||
| success = true; | |||
| done: | |||
| return success; | |||
| } | |||
| void matrix_write_char_inner(struct CharacterMatrix *matrix, uint8_t c) { | |||
| *matrix->cursor = c; | |||
| ++matrix->cursor; | |||
| if (matrix->cursor - &matrix->display[0][0] == sizeof(matrix->display)) { | |||
| // We went off the end; scroll the display upwards by one line | |||
| memmove(&matrix->display[0], &matrix->display[1], | |||
| MatrixCols * (MatrixRows - 1)); | |||
| matrix->cursor = &matrix->display[MatrixRows - 1][0]; | |||
| memset(matrix->cursor, OLED_BLANK_CHAR, MatrixCols); | |||
| } | |||
| } | |||
| void matrix_write_char(struct CharacterMatrix *matrix, uint8_t c) { | |||
| matrix->dirty = true; | |||
| if (c == '\n') { | |||
| // Clear to end of line from the cursor and then move to the | |||
| // start of the next line | |||
| uint8_t cursor_col = (matrix->cursor - &matrix->display[0][0]) % MatrixCols; | |||
| while (cursor_col++ < MatrixCols) { | |||
| matrix_write_char_inner(matrix, OLED_BLANK_CHAR); | |||
| } | |||
| return; | |||
| } | |||
| matrix_write_char_inner(matrix, c); | |||
| } | |||
| void iota_gfx_write_char(uint8_t c) { | |||
| matrix_write_char(&display, c); | |||
| } | |||
| void matrix_write(struct CharacterMatrix *matrix, const char *data) { | |||
| while (*data) { | |||
| matrix_write_char(matrix, *data); | |||
| ++data; | |||
| } | |||
| } | |||
| void matrix_write_ln(struct CharacterMatrix *matrix, const char *data) { | |||
| matrix_write(matrix, data); | |||
| matrix_write(matrix, "\n"); | |||
| } | |||
| void iota_gfx_write(const char *data) { | |||
| matrix_write(&display, data); | |||
| } | |||
| void matrix_write_P(struct CharacterMatrix *matrix, const char *data) { | |||
| while (true) { | |||
| uint8_t c = pgm_read_byte(data); | |||
| if (c == 0) { | |||
| return; | |||
| } | |||
| matrix_write_char(matrix, c); | |||
| ++data; | |||
| } | |||
| } | |||
| void iota_gfx_write_P(const char *data) { | |||
| matrix_write_P(&display, data); | |||
| } | |||
| void matrix_clear(struct CharacterMatrix *matrix) { | |||
| memset(matrix->display, OLED_BLANK_CHAR, sizeof(matrix->display)); | |||
| matrix->cursor = &matrix->display[0][0]; | |||
| matrix->dirty = true; | |||
| } | |||
| void iota_gfx_clear_screen(void) { | |||
| matrix_clear(&display); | |||
| } | |||
| void matrix_render(struct CharacterMatrix *matrix) { | |||
| last_flush = timer_read(); | |||
| iota_gfx_on(); | |||
| #if DEBUG_TO_SCREEN | |||
| ++displaying; | |||
| #endif | |||
| // Move to the home position | |||
| SEND_CMDS( | |||
| cmd3(PageAddr, 0, MatrixRows - 1), | |||
| cmd3(ColumnAddr, 0, (MatrixCols * FontWidth) - 1) | |||
| ); | |||
| if (i2c_write(SSD1306_ADDRESS, 100)) { | |||
| goto done; | |||
| } | |||
| if (i2c_write(0x40, 100)) { | |||
| // Data mode | |||
| goto done; | |||
| } | |||
| for (uint8_t row = 0; row < MatrixRows; ++row) { | |||
| for (uint8_t col = 0; col < MatrixCols; ++col) { | |||
| const uint8_t *glyph = font + (matrix->display[row][col] * FontWidth); | |||
| for (uint8_t glyphCol = 0; glyphCol < FontWidth; ++glyphCol) { | |||
| uint8_t colBits = pgm_read_byte(glyph + glyphCol); | |||
| i2c_write(colBits OLED_BITS_FILTER, 100); | |||
| } | |||
| // 1 column of space between chars (it's not included in the glyph) | |||
| //i2c_master_write(0); | |||
| } | |||
| } | |||
| matrix->dirty = false; | |||
| done: | |||
| i2c_stop(); | |||
| #if DEBUG_TO_SCREEN | |||
| --displaying; | |||
| #endif | |||
| } | |||
| void iota_gfx_flush(void) { | |||
| matrix_render(&display); | |||
| } | |||
| __attribute__ ((weak)) | |||
| void iota_gfx_task_user(void) { | |||
| } | |||
| void iota_gfx_task(void) { | |||
| iota_gfx_task_user(); | |||
| if (display.dirty|| force_dirty) { | |||
| iota_gfx_flush(); | |||
| force_dirty = false; | |||
| } | |||
| if (ScreenOffInterval !=0 && timer_elapsed(last_flush) > ScreenOffInterval) { | |||
| iota_gfx_off(); | |||
| } | |||
| } | |||
| bool process_record_gfx(uint16_t keycode, keyrecord_t *record) { | |||
| force_dirty = true; | |||
| return true; | |||
| } | |||
| #endif | |||