mirrors/keychron_qmk_firmware
mirrors/keychron_qmk_firmware
0
0
Fork 0
mirror of https://github.com/Keychron/qmk_firmware.git synced 2024-11-28 19:58:48 +06:00
Code Issues Packages Projects Releases Wiki Activity

Remove old OLED API code (#21651)

Browse Source
This commit is contained in:
Ryan 2023-08-01 00:43:10 +10:00 committed by GitHub
parent f407d90598
commit 6018b56c55
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 2 additions and 1017 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
keyboards/10bleoledhub/config.h
View File

@ -16,8 +16,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.*/
#pragma once #pragma once
#define SSD1306OLED
#define RGBLIGHT_EFFECT_BREATHING #define RGBLIGHT_EFFECT_BREATHING
#define RGBLIGHT_EFFECT_RAINBOW_MOOD #define RGBLIGHT_EFFECT_RAINBOW_MOOD
#define RGBLIGHT_EFFECT_RAINBOW_SWIRL #define RGBLIGHT_EFFECT_RAINBOW_SWIRL

2
keyboards/crkbd/keymaps/crkqwes/config.h
View File

@ -28,9 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// #define MASTER_RIGHT // #define MASTER_RIGHT
// #define EE_HANDS // #define EE_HANDS
// #define SSD1306OLED
#undef USE_I2C #undef USE_I2C
#undef SSD1306OLED
#define QUICK_TAP_TERM 0 #define QUICK_TAP_TERM 0
#define TAPPING_TERM 200 #define TAPPING_TERM 200

4
keyboards/crkbd/keymaps/hvp/keymap.c
View File

@ -1,9 +1,5 @@
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
#include "hvp.c" #include "hvp.c"
#ifdef SSD1306OLED
# include "ssd1306.h"
# include <string.h>
#endif
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
//Following line allows macro to read current RGB settings //Following line allows macro to read current RGB settings

3
keyboards/crkbd/keymaps/markstos/config.h
View File

@ -16,9 +16,6 @@ This is the C configuration file for the keymap
#define MASTER_RIGHT #define MASTER_RIGHT
// #define EE_HANDS // #define EE_HANDS
//#define SSD1306OLED
// By default, when holding a dual-function key shortly after tapping it, the // By default, when holding a dual-function key shortly after tapping it, the
// tapped key will begin repeating. This is handy for fast typists when typing // tapped key will begin repeating. This is handy for fast typists when typing
// words with double letters, such as "happy". If you turn this setting ON, it // words with double letters, such as "happy". If you turn this setting ON, it

8
keyboards/helix/rev2/keymaps/default/keymap.c
View File

@ -340,10 +340,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true; return true;
} }
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
void matrix_init_user(void) { void matrix_init_user(void) {
#ifdef AUDIO_ENABLE #ifdef AUDIO_ENABLE
startup_user(); startup_user();
@ -351,10 +347,6 @@ void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_get_mode(); RGB_current_mode = rgblight_get_mode();
#endif #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
} }

147
keyboards/helix/rev2/keymaps/default/oled_display.c
View File

@ -136,150 +136,3 @@ bool oled_task_user(void) {
return false; return false;
} }
#endif // end of OLED_ENABLE #endif // end of OLED_ENABLE
//SSD1306 OLED update loop
/*
The following code is left as a sample to help you transition from SSD1306OLED to OLED_ENABLE.
* `matrix_write(matrix, data)` is replaced by `oled_write(data, false)`.
* `matrix_write_P(matrix, data)` is replaced by `oled_write_P(data, false)`.
* It is no longer necessary to call `iota_gfx_task()`.
* `matrix_update()` are no longer needed.
* `iota_gfx_task_user()` is no longer needed. Instead, `bool oled_task_user(void)` is provided.
以下のコードは、SSD1306OLED から OLED_ENABLE に移行する助けになるようにサンプルとして残してあります。
* `matrix_write(matrix, data)` は、`oled_write(data, false)` に書き換えます。
* `matrix_write_P(matrix, data)` は、`oled_write_P(data, false)` に書き換えます。
* `iota_gfx_task()` を呼び出す必要はなくなります。
* `matrix_update()` は不要になります。
* `iota_gfx_task_user()` は不要になります。代りに `bool oled_task_user(void)` を用意します。
*/
#ifdef SSD1306OLED
#include "ssd1306.h"
#define oled_write(data,flag) matrix_write(matrix, data)
#define oled_write_P(data,flag) matrix_write_P(matrix, data)
void matrix_scan_user(void) {
iota_gfx_task(); // this is what updates the display continuously
}
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;
}
}
static void render_logo(struct CharacterMatrix *matrix) {
static const char helix_logo[] PROGMEM ={
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,
0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,
0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,
0};
oled_write_P(helix_logo, false);
}
static void render_rgbled_status(bool full, struct CharacterMatrix *matrix) {
# ifdef RGBLIGHT_ENABLE
char buf[30];
if (RGBLIGHT_MODES > 1 && rgblight_is_enabled()) {
if (full) {
snprintf(buf, sizeof(buf), " LED %2d: %d,%d,%d ",
rgblight_get_mode(),
rgblight_get_hue()/RGBLIGHT_HUE_STEP,
rgblight_get_sat()/RGBLIGHT_SAT_STEP,
rgblight_get_val()/RGBLIGHT_VAL_STEP);
} else {
snprintf(buf, sizeof(buf), "[%2d] ", rgblight_get_mode());
}
oled_write(buf, false);
}
# endif
}
static void render_layer_status(struct CharacterMatrix *matrix) {
// Define layers here, Have not worked out how to have text displayed for each layer. Copy down the number you see and add a case for it below
char buf[10];
oled_write_P(PSTR("Layer: "), false);
switch (layer_state) {
case L_BASE:
oled_write_P(PSTR("Default"), false);
break;
case L_RAISE:
oled_write_P(PSTR("Raise"), false);
break;
case L_LOWER:
oled_write_P(PSTR("Lower"), false);
break;
case L_ADJUST:
case L_ADJUST_TRI:
oled_write_P(PSTR("Adjust"), false);
break;
default:
oled_write_P(PSTR("Undef-"), false);
snprintf(buf,sizeof(buf), "%ld", layer_state);
oled_write(buf, false);
}
oled_write_P(PSTR("\n"), false);
}
void render_status(struct CharacterMatrix *matrix) {
// Render to mode icon
static const char os_logo[][2][3] PROGMEM = {{{0x95,0x96,0},{0xb5,0xb6,0}},{{0x97,0x98,0},{0xb7,0xb8,0}}};
if (is_mac_mode()) {
oled_write_P(os_logo[0][0], false);
oled_write_P(PSTR("\n"), false);
oled_write_P(os_logo[0][1], false);
} else {
oled_write_P(os_logo[1][0], false);
oled_write_P(PSTR("\n"), false);
oled_write_P(os_logo[1][1], false);
}
oled_write_P(PSTR(" "), false);
render_layer_status(matrix);
// Host Keyboard LED Status
led_t led_state = host_keyboard_led_state();
oled_write_P(led_state.num_lock ? PSTR("NUMLOCK") : PSTR(" "), false);
oled_write_P(led_state.caps_lock ? PSTR("CAPS") : PSTR(" "), false);
oled_write_P(led_state.scroll_lock ? PSTR("SCLK") : PSTR(" "), false);
oled_write_P(PSTR("\n"), false);
render_rgbled_status(true, matrix);
}
# if OLED_UPDATE_INTERVAL > 0
uint16_t oled_update_timeout;
# endif
void iota_gfx_task_user(void) {
struct CharacterMatrix matrix;
# if DEBUG_TO_SCREEN
if (debug_enable) {
return;
}
# endif
# if OLED_UPDATE_INTERVAL > 0
if (timer_elapsed(oled_update_timeout) < OLED_UPDATE_INTERVAL) {
return;
}
oled_update_timeout = timer_read();
# endif
matrix_clear(&matrix);
if (is_keyboard_master()) {
render_status(&matrix);
} else {
render_logo(&matrix);
render_rgbled_status(false, &matrix);
render_layer_status(&matrix);
}
matrix_update(&display, &matrix);
}
#endif // end of SSD1306OLED

120
keyboards/helix/rev2/keymaps/five_rows_jis/keymap.c
View File

@ -2,9 +2,6 @@
#include "keymap_japanese.h" #include "keymap_japanese.h"
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
// * If you want to recognize that you pressed the Adjust key with the Lower / Raise key you can enable this comment out. However, the binary size may be over. * // * If you want to recognize that you pressed the Adjust key with the Lower / Raise key you can enable this comment out. However, the binary size may be over. *
// #define ADJUST_MACRO_ENABLE // #define ADJUST_MACRO_ENABLE
@ -192,7 +189,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
), ),
}; };
#if defined(SSD1306OLED) || defined(OLED_ENABLE) #if defined(OLED_ENABLE)
char keylog[24] = {}; char keylog[24] = {};
const char code_to_name[60] = { const char code_to_name[60] = {
' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f', ' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f',
@ -249,7 +246,7 @@ void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
#endif #endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) { bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#if defined(SSD1306OLED) || defined(OLED_ENABLE) #if defined(OLED_ENABLE)
if (record->event.pressed) { if (record->event.pressed) {
set_keylog(keycode, record); set_keylog(keycode, record);
} }
@ -310,121 +307,8 @@ void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_get_mode(); RGB_current_mode = rgblight_get_mode();
#endif #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
void matrix_scan_user(void) {
iota_gfx_task(); // this is what updates the display continuously
}
static inline 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;
}
}
//assign the right code to your layers for OLED display
#define L_BASE _BASE
#define L_LOWER (1<<_LOWER)
#define L_RAISE (1<<_RAISE)
#define L_ADJUST (1<<_ADJUST)
#define L_ADJUST_TRI (L_ADJUST|L_RAISE|L_LOWER)
#define L_LOW_E (1<<_LOW_E)
#define L_RAI_E (1<<_RAI_E)
#define L_ADJUST_TRIE (L_ADJUST|L_RAI_E|L_LOW_E)
const char helix_logo[]={
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,
0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,
0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,
0};
static inline void render_logo(struct CharacterMatrix *matrix) {
matrix_write(matrix, helix_logo);
}
const char mac_win_logo[][2][3]={{{0x95,0x96,0},{0xb5,0xb6,0}},{{0x97,0x98,0},{0xb7,0xb8,0}}};
static inline void render_status(struct CharacterMatrix *matrix) {
char buf[20];
// Render to mode icon
if(keymap_config.swap_lalt_lgui==false){
matrix_write(matrix, mac_win_logo[0][0]);
matrix_write_P(matrix, PSTR("\n"));
matrix_write(matrix, mac_win_logo[0][1]);
} else {
matrix_write(matrix, mac_win_logo[1][0]);
matrix_write_P(matrix, PSTR("\n"));
matrix_write(matrix, mac_win_logo[1][1]);
}
#ifdef RGBLIGHT_ENABLE
snprintf(buf, sizeof(buf), " LED mode:%d", (short)RGB_current_mode);
matrix_write(matrix, buf);
#endif
// Define layers here, Have not worked out how to have text displayed for each layer. Copy down the number you see and add a case for it below
matrix_write_P(matrix, PSTR("\nLayer: "));
switch (layer_state) {
case L_BASE:
matrix_write_P(matrix, default_layer_state == (1UL<<_BAS_E) ? PSTR("BaseEx") : PSTR("Base"));
break;
case L_RAISE:
matrix_write_P(matrix, PSTR("Raise"));
break;
case L_RAI_E:
matrix_write_P(matrix, PSTR("RaiseEx"));
break;
case L_LOWER:
matrix_write_P(matrix, PSTR("Lower"));
break;
case L_LOW_E:
matrix_write_P(matrix, PSTR("LowerEx"));
break;
case L_ADJUST:
case L_ADJUST_TRI:
case L_ADJUST_TRIE:
matrix_write_P(matrix, PSTR("Adjust"));
break;
default:
snprintf(buf, sizeof(buf), "%d", (short)layer_state);
matrix_write(matrix, buf);
}
matrix_write(matrix, keylog);
}
void iota_gfx_task_user(void) {
struct CharacterMatrix matrix;
#if DEBUG_TO_SCREEN
if (debug_enable) {
return;
}
#endif
matrix_clear(&matrix);
if (is_keyboard_master()) {
render_status(&matrix);
} else {
render_logo(&matrix);
}
matrix_update(&display, &matrix);
}
#endif // end of SSD1306OLED
//OLED update loop //OLED update loop
#ifdef OLED_ENABLE #ifdef OLED_ENABLE
oled_rotation_t oled_init_user(oled_rotation_t rotation) { oled_rotation_t oled_init_user(oled_rotation_t rotation) {

126
keyboards/helix/rev2/keymaps/froggy/keymap.c
View File

@ -4,10 +4,6 @@
#define MIN(x, y) (((x) < (y)) ? (x) : (y)) #define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define MAX(x, y) (((x) > (y)) ? (x) : (y)) #define MAX(x, y) (((x) > (y)) ? (x) : (y))
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
#define LAYOUT_half( \ #define LAYOUT_half( \
L00, L01, L02, L03, L04, L05, \ L00, L01, L02, L03, L04, L05, \
L10, L11, L12, L13, L14, L15, \ L10, L11, L12, L13, L14, L15, \
@ -450,10 +446,6 @@ void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_get_mode(); RGB_current_mode = rgblight_get_mode();
#endif #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
} }
@ -555,10 +547,6 @@ uint8_t layer_state_old;
//runs every scan cycle (a lot) //runs every scan cycle (a lot)
void matrix_scan_user(void) { void matrix_scan_user(void) {
#ifdef SSD1306OLED
iota_gfx_task(); // this is what updates the display continuously
#endif
if(delay_key_stat && (timer_elapsed(key_timer) > DELAY_TIME)){ if(delay_key_stat && (timer_elapsed(key_timer) > DELAY_TIME)){
register_delay_code(_BASE); register_delay_code(_BASE);
if(!delay_key_pressed){ if(!delay_key_pressed){
@ -629,120 +617,6 @@ void matrix_scan_user(void) {
#endif #endif
} }
//SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
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;
}
}
// Render to OLED
void render_status(struct CharacterMatrix *matrix) {
// froggy logo
static char logo[4][1][17]=
{
{
{0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,0x70,0x71,0x72,0x73,0x74,0}
},
{
{0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,0}
},
{
{0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,0}
},
{
{0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0}
}
};
static char indctr[8][2][4]=
{
// white icon
{
{0x60,0x61,0x62,0},
{0x63,0x64,0}
},
{
{0x80,0x81,0x82,0},
{0x83,0x84,0}
},
{
{0xa0,0xa1,0xa2,0},
{0xa3,0xa4,0}
},
{
{0xc0,0xc1,0xc2,0},
{0xc3,0xc4,0}
},
// Black icon
{
{0x75,0x76,0x77,0},
{0x78,0x79,0}
},
{
{0x95,0x96,0x97,0},
{0x98,0x99,0}
},
{
{0xb5,0xb6,0xb7,0},
{0xb8,0xb9,0}
},
{
{0xd5,0xd6,0xd7,0},
{0xd8,0xd9,0}
},
};
int rown = 0;
int rowf = 0;
int rowa = 0;
int rows = 0;
//Set Indicator icon
led_t led_state = host_keyboard_led_state();
if (led_state.num_lock) { rown = 4; } else { rown = 0; }
if (led_state.caps_lock) { rowa = 4; } else { rowa = 0; }
if (led_state.scroll_lock) { rows = 4; } else { rows = 0; }
if (layer_state == L_FUNC) { rowf = 4; }
matrix_write(matrix, indctr[rown] [0]);
matrix_write(matrix, indctr[rowf] [1]);
matrix_write(matrix, logo [0] [0]);
matrix_write(matrix, indctr[rown+1][0]);
matrix_write(matrix, indctr[rowf+1][1]);
matrix_write(matrix, logo [1] [0]);
matrix_write(matrix, indctr[rowa+2][0]);
matrix_write(matrix, indctr[rows+2][1]);
matrix_write(matrix, logo [2] [0]);
matrix_write(matrix, indctr[rowa+3][0]);
matrix_write(matrix, indctr[rows+3][1]);
matrix_write(matrix, logo [3] [0]);
}
void iota_gfx_task_user(void) {
struct CharacterMatrix matrix;
#if DEBUG_TO_SCREEN
if (debug_enable) {
return;
}
#endif
matrix_clear(&matrix);
if (is_keyboard_master()) {
render_status(&matrix);
}
matrix_update(&display, &matrix);
}
#endif // end of SSD1306OLED
//OLED update loop //OLED update loop
#ifdef OLED_ENABLE #ifdef OLED_ENABLE

152
keyboards/helix/rev2/keymaps/froggy_106/keymap.c
View File

@ -1,9 +1,6 @@
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
#include "keymap_japanese.h" #include "keymap_japanese.h"
#include <string.h> #include <string.h>
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
#define LAYOUT_half( \ #define LAYOUT_half( \
L00, L01, L02, L03, L04, L05, \ L00, L01, L02, L03, L04, L05, \
@ -563,15 +560,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true; return true;
} }
//keyboard start-up code. Runs once when the firmware starts up.
void matrix_init_user(void) {
//SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
iota_gfx_init(!has_usb()); // turns on the display
#endif
}
// LED Effect // LED Effect
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
unsigned char rgb[7][5][3]; unsigned char rgb[7][5][3];
@ -632,10 +620,6 @@ layer_state_t layer_state_old;
//runs every scan cycle (a lot) //runs every scan cycle (a lot)
void matrix_scan_user(void) { void matrix_scan_user(void) {
#ifdef SSD1306OLED
iota_gfx_task(); // this is what updates the display continuously
#endif
if(delay_key_stat && (timer_elapsed(key_timer) > DELAY_TIME)){ if(delay_key_stat && (timer_elapsed(key_timer) > DELAY_TIME)){
if (IS_MODE_106()) if (IS_MODE_106())
register_delay_code(_BASE_106); register_delay_code(_BASE_106);
@ -693,142 +677,6 @@ void matrix_scan_user(void) {
#endif #endif
} }
//SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
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;
}
}
// Render to OLED
void render_status(struct CharacterMatrix *matrix) {
// froggy logo
static char logo[4][17]=
{
{0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,0x70,0x71,0x72,0x73,0x74,0},
{0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,0},
{0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,0},
{0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0},
};
static char modectl[4][2][4]=
{
{
{0x65,0x66,0x67,0}, //WIN
{0x85,0x86,0x87,0}, //WIN
},
{
{0xa5,0xa6,0xa7,0}, //US(101)
{0xc5,0xc6,0xc7,0}, //US(101)
},
{
{0xbd,0xbe,0xbf,0}, //MAC
{0xdd,0xde,0xdf,0}, //MAC
},
{
{0xba,0xbb,0xbc,0}, //JP(106)
{0xda,0xdb,0xdc,0}, //JP(106)
},
};
static char indctr[8][2][4]=
{
// white icon
{
{0x60,0x61,0x62,0}, //NUM
{0x63,0x64,0} //FUNC
},
{
{0x80,0x81,0x82,0}, //NUM
{0x83,0x84,0} //FUNC
},
{
{0xa0,0xa1,0xa2,0}, //CAPS
{0xa3,0xa4,0} //SCLK
},
{
{0xc0,0xc1,0xc2,0}, //CAPS
{0xc3,0xc4,0} //SCLK
},
// Black icon
{
{0x75,0x76,0x77,0}, //NUM
{0x78,0x79,0} //FUNC
},
{
{0x95,0x96,0x97,0}, //NUM
{0x98,0x99,0} //FUNC
},
{
{0xb5,0xb6,0xb7,0}, //CAPS
{0xb8,0xb9,0} //SCLK
},
{
{0xd5,0xd6,0xd7,0}, //CAPS
{0xd8,0xd9,0} //SCLK
},
};
int rown = 0;
int rowf = 0;
int rowa = 0;
int rows = 0;
int rowm = 0;
int rowj = 1;
//Set Indicator icon
led_t led_state = host_keyboard_led_state();
if (led_state.num_lock) { rown = 4; }
if (led_state.caps_lock) { rowa = 4; }
if (led_state.scroll_lock) { rows = 4; }
if (IS_LAYER_ON(_FUNC)) { rowf = 4; }
//Set Mode icon
if (IS_MODE_MAC()) { rowm = 2; }
if (IS_MODE_106()) { rowj = 3; }
matrix_write(matrix, indctr[rown] [0]);
matrix_write(matrix, indctr[rowf] [1]);
matrix_write(matrix, modectl[rowm] [0]);
matrix_write(matrix, logo[0]);
matrix_write(matrix, indctr[rown+1][0]);
matrix_write(matrix, indctr[rowf+1][1]);
matrix_write(matrix, modectl[rowm] [1]);
matrix_write(matrix, logo[1]);
matrix_write(matrix, indctr[rowa+2][0]);
matrix_write(matrix, indctr[rows+2][1]);
matrix_write(matrix, modectl[rowj] [0]);
matrix_write(matrix, logo[2]);
matrix_write(matrix, indctr[rowa+3][0]);
matrix_write(matrix, indctr[rows+3][1]);
matrix_write(matrix, modectl[rowj] [1]);
matrix_write(matrix, logo[3]);
}
void iota_gfx_task_user(void) {
struct CharacterMatrix matrix;
#if DEBUG_TO_SCREEN
if (debug_enable) {
return;
}
#endif
matrix_clear(&matrix);
if (is_keyboard_master()) {
render_status(&matrix);
}
matrix_update(&display, &matrix);
}
#endif // end of SSD1306OLED
//OLED update loop //OLED update loop
#ifdef OLED_ENABLE #ifdef OLED_ENABLE

134
keyboards/helix/rev2/keymaps/yshrsmz/keymap.c
View File

@ -1,9 +1,6 @@
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
// Each layer gets a name for readability, which is then used in the keymap matrix below. // 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. // The underscores don't mean anything - you can have a layer called STUFF or any other name.
@ -331,10 +328,6 @@ void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_get_mode(); RGB_current_mode = rgblight_get_mode();
#endif #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
} }
@ -363,133 +356,6 @@ void music_scale_user(void)
#endif #endif
//SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
void matrix_scan_user(void) {
iota_gfx_task(); // this is what updates the display continuously
}
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;
}
}
//assign the right code to your layers for OLED display
#define L_BASE 0
#define L_LOWER (1<<_LOWER)
#define L_RAISE (1<<_RAISE)
#define L_ADJUST (1<<_ADJUST)
#define L_ADJUST_TRI (L_ADJUST|L_RAISE|L_LOWER)
static void render_logo(struct CharacterMatrix *matrix) {
static const char helix_logo[] PROGMEM ={
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,
0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,
0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,
0};
matrix_write_P(matrix, helix_logo);
//matrix_write_P(&matrix, PSTR(" Split keyboard kit"));
}
static void render_rgbled_status(bool full, struct CharacterMatrix *matrix) {
#ifdef RGBLIGHT_ENABLE
char buf[30];
if (RGBLIGHT_MODES > 1 && rgblight_is_enabled()) {
if (full) {
snprintf(buf, sizeof(buf), " LED %2d: %d,%d,%d ",
rgblight_get_mode(),
rgblight_get_hue()/RGBLIGHT_HUE_STEP,
rgblight_get_sat()/RGBLIGHT_SAT_STEP,
rgblight_get_val()/RGBLIGHT_VAL_STEP);
} else {
snprintf(buf, sizeof(buf), "[%2d] ", rgblight_get_mode());
}
matrix_write(matrix, buf);
}
#endif
}
static void render_layer_status(struct CharacterMatrix *matrix) {
// Define layers here, Have not worked out how to have text displayed for each layer. Copy down the number you see and add a case for it below
char buf[10];
matrix_write_P(matrix, PSTR("Layer: "));
switch (layer_state) {
case L_BASE:
matrix_write_P(matrix, PSTR("Default"));
break;
case L_RAISE:
matrix_write_P(matrix, PSTR("Raise"));
break;
case L_LOWER:
matrix_write_P(matrix, PSTR("Lower"));
break;
case L_ADJUST:
case L_ADJUST_TRI:
matrix_write_P(matrix, PSTR("Adjust"));
break;
default:
matrix_write_P(matrix, PSTR("Undef-"));
snprintf(buf,sizeof(buf), "%ld", layer_state);
matrix_write(matrix, buf);
}
}
void render_status(struct CharacterMatrix *matrix) {
// Render to mode icon
static const char os_logo[][2][3] PROGMEM ={{{0x95,0x96,0},{0xb5,0xb6,0}},{{0x97,0x98,0},{0xb7,0xb8,0}}};
if(keymap_config.swap_lalt_lgui==false){
matrix_write_P(matrix, os_logo[0][0]);
matrix_write_P(matrix, PSTR("\n"));
matrix_write_P(matrix, os_logo[0][1]);
}else{
matrix_write_P(matrix, os_logo[1][0]);
matrix_write_P(matrix, PSTR("\n"));
matrix_write_P(matrix, os_logo[1][1]);
}
matrix_write_P(matrix, PSTR(" "));
render_layer_status(matrix);
matrix_write_P(matrix, PSTR("\n"));
// Host Keyboard LED Status
led_t led_state = host_keyboard_led_state();
matrix_write_P(matrix, led_state.num_lock ? PSTR("NUMLOCK") : PSTR(" "));
matrix_write_P(matrix, led_state.caps_lock ? PSTR("CAPS") : PSTR(" "));
matrix_write_P(matrix, led_state.scroll_lock ? PSTR("SCLK") : PSTR(" "));
matrix_write_P(matrix, PSTR("\n"));
render_rgbled_status(true, matrix);
}
void iota_gfx_task_user(void) {
struct CharacterMatrix matrix;
#if DEBUG_TO_SCREEN
if (debug_enable) {
return;
}
#endif
matrix_clear(&matrix);
if (is_keyboard_master()) {
render_status(&matrix);
} else {
render_logo(&matrix);
render_rgbled_status(false, &matrix);
render_layer_status(&matrix);
}
matrix_update(&display, &matrix);
}
#endif // end of SSD1306OLED
#ifdef OLED_ENABLE #ifdef OLED_ENABLE
oled_rotation_t oled_init_user(oled_rotation_t rotation) { oled_rotation_t oled_init_user(oled_rotation_t rotation) {
if (is_keyboard_master()) { if (is_keyboard_master()) {

2
keyboards/latincompass/latinpad/config.h
View File

@ -16,8 +16,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.*/
#pragma once #pragma once
#define SSD1306OLED
#define RGB_MATRIX_LED_COUNT 18 #define RGB_MATRIX_LED_COUNT 18
// RGB Matrix Animation modes. Explicitly enabled // RGB Matrix Animation modes. Explicitly enabled
// For full list of effects, see: // For full list of effects, see:

2
keyboards/lily58/keymaps/chuan/config.h
View File

@ -30,8 +30,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// #define MASTER_RIGHT // #define MASTER_RIGHT
// #define EE_HANDS // #define EE_HANDS
// #define SSD1306OLED
#define QUICK_TAP_TERM 0 #define QUICK_TAP_TERM 0
/* define tapping term */ /* define tapping term */

7
keyboards/lily58/keymaps/chuan/keymap.c
View File

@ -173,13 +173,6 @@ bool oled_task_user(void) {
#endif //OLED_ENABLE #endif //OLED_ENABLE
bool process_record_user(uint16_t keycode, keyrecord_t *record) { 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) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {

2
keyboards/lily58/keymaps/datadavd/config.h
View File

@ -28,8 +28,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// #define MASTER_RIGHT // #define MASTER_RIGHT
// #define EE_HANDS // #define EE_HANDS
// #define SSD1306OLED
#define QUICK_TAP_TERM 0 #define QUICK_TAP_TERM 0
#define TAPPING_TERM 50 #define TAPPING_TERM 50

2
keyboards/lily58/keymaps/domnantas/config.h
View File

@ -28,7 +28,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// #define MASTER_RIGHT // #define MASTER_RIGHT
#define EE_HANDS #define EE_HANDS
// #define SSD1306OLED
#define QUICK_TAP_TERM 0 #define QUICK_TAP_TERM 0
#define TAPPING_TERM 100 #define TAPPING_TERM 100

2
keyboards/lily58/keymaps/hvp/config.h
View File

@ -28,8 +28,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// #define MASTER_RIGHT // #define MASTER_RIGHT
// #define EE_HANDS // #define EE_HANDS
#define SSD1306OLED
#define TAPPING_TERM 100 #define TAPPING_TERM 100
#undef TAPPING_TERM #undef TAPPING_TERM
#define TAPPING_TERM 150 #define TAPPING_TERM 150

57
keyboards/lily58/keymaps/hvp/keymap.c
View File

@ -5,9 +5,6 @@
#include "lufa.h" #include "lufa.h"
#include "split_util.h" #include "split_util.h"
#endif #endif
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
//Following line allows macro to read current RGB settings //Following line allows macro to read current RGB settings
@ -84,63 +81,9 @@ void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_config.mode; RGB_current_mode = rgblight_config.mode;
#endif #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);
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) { 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) { switch (keycode) {
case QWERTY: case QWERTY:
if (record->event.pressed) { if (record->event.pressed) {

2
keyboards/lily58/keymaps/jhelvy/config.h
View File

@ -28,8 +28,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// #define MASTER_RIGHT // #define MASTER_RIGHT
// #define EE_HANDS // #define EE_HANDS
#define SSD1306OLED
#define QUICK_TAP_TERM 0 #define QUICK_TAP_TERM 0
#undef TAPPING_TERM #undef TAPPING_TERM
#define TAPPING_TERM 200 #define TAPPING_TERM 200

69
keyboards/lily58/keymaps/jhelvy/keymap.c
View File

@ -4,10 +4,6 @@
#include "lufa.h" #include "lufa.h"
#include "split_util.h" #include "split_util.h"
#endif #endif
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
extern uint8_t is_master; extern uint8_t is_master;
@ -45,68 +41,3 @@ LGUI(KC_BSPC),MO(2),LGUI(KC_S),LGUI(KC_C),LGUI(KC_V),LGUI(KC_X),
KC_NO, KC_NO,KC_NO, KC_NO, KC_NO, KC_TRNS, KC_NO, KC_NO) KC_NO, KC_NO,KC_NO, KC_NO, KC_NO, KC_TRNS, KC_NO, KC_NO)
}; };
void matrix_init_user(void) {
//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();
}
return true;
}

3
keyboards/lily58/keymaps/mikefightsbears/keymap.c
View File

@ -4,9 +4,6 @@
#include "lufa.h" #include "lufa.h"
#include "split_util.h" #include "split_util.h"
#endif #endif
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
//Following line allows macro to read current RGB settings //Following line allows macro to read current RGB settings

3
keyboards/lily58/keymaps/yshrsmz/keymap.c
View File

@ -4,9 +4,6 @@
#include "lufa.h" #include "lufa.h"
#include "split_util.h" #include "split_util.h"
#endif #endif
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
//Following line allows macro to read current RGB settings //Following line allows macro to read current RGB settings

3
keyboards/lily58/keymaps/yuchi/keymap.c
View File

@ -4,9 +4,6 @@
#include "lufa.h" #include "lufa.h"
#include "split_util.h" #include "split_util.h"
#endif #endif
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
extern uint8_t is_master; extern uint8_t is_master;

26
keyboards/rgbkb/sol/keymaps/xyverz/config.h
View File

@ -1,26 +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
// place overrides here
/* #define SSD1306OLED */

112
keyboards/rgbkb/zygomorph/keymaps/5x6pad/keymap.c
View File

@ -3,9 +3,6 @@
#include "lufa.h" #include "lufa.h"
#include "split_util.h" #include "split_util.h"
#endif #endif
#ifdef SSD1306OLED
#include "common/ssd1306.h"
#endif
extern keymap_config_t keymap_config; extern keymap_config_t keymap_config;
@ -171,113 +168,4 @@ void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_config.mode; RGB_current_mode = rgblight_config.mode;
#endif #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
// hook point for 'led_test' keymap
// 'default' keymap's led_test_init() is empty function, do nothing
// 'led_test' keymap's led_test_init() force rgblight_mode_noeeprom(35);
__attribute__ ((weak))
void led_test_init(void) {}
void matrix_scan_user(void) {
led_test_init();
iota_gfx_task(); // this is what updates the display continuously
}
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;
}
}
//assign the right code to your layers for OLED display
#define L_BASE 0
#define L_FN (1<<_FN)
#define L_ADJ (1<<_ADJ)
static void render_logo(struct CharacterMatrix *matrix) {
static char logo[]={
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,
0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,
0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,
0};
matrix_write(matrix, logo);
//matrix_write_P(&matrix, PSTR(" Split keyboard kit"));
}
void render_status(struct CharacterMatrix *matrix) {
// Render to mode icon
static char logo[][2][3]={{{0x95,0x96,0},{0xb5,0xb6,0}},{{0x97,0x98,0},{0xb7,0xb8,0}}};
if(keymap_config.swap_lalt_lgui==false){
matrix_write(matrix, logo[0][0]);
matrix_write_P(matrix, PSTR("\n"));
matrix_write(matrix, logo[0][1]);
}else{
matrix_write(matrix, logo[1][0]);
matrix_write_P(matrix, PSTR("\n"));
matrix_write(matrix, logo[1][1]);
}
// Define layers here, Have not worked out how to have text displayed for each layer. Copy down the number you see and add a case for it below
char buf[40];
snprintf(buf,sizeof(buf), "Undef-%ld", layer_state);
matrix_write_P(matrix, PSTR("\nLayer: "));
switch (layer_state) {
case L_BASE:
matrix_write_P(matrix, PSTR("Default"));
break;
case L_FN:
matrix_write_P(matrix, PSTR("FN"));
break;
case L_ADJ:
case L_ADJ_TRI:
matrix_write_P(matrix, PSTR("ADJ"));
break;
default:
matrix_write(matrix, buf);
}
// Host Keyboard LED Status
char led[40];
led_t led_state = host_keyboard_led_state();
snprintf(led, sizeof(led), "\n%s %s %s",
led_state.num_lock ? "NUMLOCK" : " ",
led_state.caps_lock ? "CAPS" : " ",
led_state.scroll_lock ? "SCLK" : " ");
matrix_write(matrix, led);
}
void iota_gfx_task_user(void) {
struct CharacterMatrix matrix;
#if DEBUG_TO_SCREEN
if (debug_enable) {
return;
}
#endif
matrix_clear(&matrix);
if(is_master){
render_status(&matrix);
}else{
render_logo(&matrix);
}
matrix_update(&display, &matrix);
}
#endif

24
keyboards/spacetime/rev2/rev2.c
View File

@ -1,24 +0,0 @@
/* Copyright 2019 Kyle Terry
*
* 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/>.
*/
#include "rev2.h"
bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
#ifdef SSD1306OLED
return process_record_gfx(keycode,record) && process_record_user(keycode, record);
#else
return process_record_user(keycode, record);
#endif
}

1
layouts/community/split_3x6_3/drashna/config.h
View File

@ -24,7 +24,6 @@
#define SPLIT_MODS_ENABLE #define SPLIT_MODS_ENABLE
#undef USE_I2C #undef USE_I2C
#undef SSD1306OLED
// #define QUICK_TAP_TERM 0 // #define QUICK_TAP_TERM 0
// #define TAPPING_TERM 100 // #define TAPPING_TERM 100

3
quantum/split_common/split_util.c
View File

@ -206,9 +206,6 @@ void split_pre_init(void) {
#endif #endif
if (is_keyboard_master()) { if (is_keyboard_master()) {
#if defined(USE_I2C) && defined(SSD1306OLED)
matrix_master_OLED_init();
#endif
transport_master_init(); transport_master_init();
} }
} }

1
quantum/split_common/split_util.h
View File

@ -7,7 +7,6 @@
extern volatile bool isLeftHand; extern volatile bool isLeftHand;
void matrix_master_OLED_init(void);
void split_pre_init(void); void split_pre_init(void);
void split_post_init(void); void split_post_init(void);