alterNERDtive/qmk_firmware
1
0
Fork 0
Code Pull requests Activity

Migrate crkbd keymaps to oled driver (#17863)

Browse source
This commit is contained in:
Joel Challis 2022-07-31 20:36:30 +01:00 committed by GitHub
parent c10c2575b8
commit f7aaed1b57
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
40 changed files with 97 additions and 524 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
keyboards/crkbd/keymaps/davidrambo/config.h
View file

@ -30,8 +30,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define RGBLIGHT_SPLIT
//#define SSD1306OLED
#define TAPPING_TERM 200
#define PERMISSIVE_HOLD

3
keyboards/crkbd/keymaps/davidrambo/keymap.c
View file

@ -16,9 +16,6 @@
#include QMK_KEYBOARD_H
//extern uint8_t is_master;
enum custom_layers {
_COLEMAK,
_SYMBOL,

25
keyboards/crkbd/keymaps/devdev/keymap.c
View file

@ -263,9 +263,6 @@ bool led_update_user(led_t led_state) {
}
*/
//SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
#ifdef OLED_ENABLE
oled_rotation_t oled_init_user(oled_rotation_t rotation) {
if (!is_keyboard_master()) {
@ -319,27 +316,15 @@ void oled_render_layer_state(void) {
oled_write_ln_P(PSTR("Layer: Layer Switch"),false);
break;
default:
#if defined (LAYER_STATE_32BIT)
snprintf(string, sizeof(string), "%ld",layer_state);
#else
snprintf(string, sizeof(string), "%d",layer_state);
#endif
oled_write_P(PSTR("Layer: Undef-"),false);
oled_write_ln(string, false);
}
}
/*
void matrix_render_user(struct CharacterMatrix *matrix) {
if (has_usb()) {
// 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());
}
}
*/
char keylog_str[24] = {};
const char code_to_name[60] = {
@ -393,7 +378,7 @@ void oled_render_logo(void) {
}
bool oled_task_user(void) {
if (is_master) {
if (is_keyboard_master()) {
oled_render_layer_state();
oled_render_keylog();
} else {

3
keyboards/crkbd/keymaps/gotham/config.h
View file

@ -3,9 +3,6 @@
#define EE_HANDS
#define SPLIT_USB_DETECT
#undef USE_I2C
#undef SSD1306OLED
#define USE_SERIAL_PD2
#define IGNORE_MOD_TAP_INTERRUPT

2
keyboards/crkbd/keymaps/gotham/oled.c
View file

@ -1,7 +1,5 @@
#pragma once
extern uint8_t is_master;
#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
# include "rgb.c"
#endif

4
keyboards/crkbd/keymaps/hvp/config.h
View file

@ -28,10 +28,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// #define MASTER_RIGHT
// #define EE_HANDS
#define SSD1306OLED
#define USE_SSD_I2C
#define USE_SERIAL_PD2
//#define TAPPING_FORCE_HOLD

45
keyboards/crkbd/keymaps/hvp/keymap.c
View file

@ -91,14 +91,9 @@ 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(); // turns on the display
#endif
}
//SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
#ifdef OLED_ENABLE
// When add source files to SRC in rules.mk, you can use functions.
const char *read_layer_state(void);
@ -112,42 +107,26 @@ const char *read_keylogs(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) {
bool oled_task_user(void) {
if (is_keyboard_master()) {
// If you want to change the display of OLED, you need to change here
matrix_write(matrix, read_layer_state());
matrix_write(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());
oled_write(read_layer_state(), false);
oled_write(read_keylog(), false);
//oled_write_ln(read_keylogs(), false);
//oled_write_ln(read_mode_icon(keymap_config.swap_lalt_lgui), false);
//oled_write_ln(read_host_led_state()), false;
//oled_write_ln(read_timelog(), false);
} else {
matrix_write(matrix, read_logo());
oled_write(read_logo(), false);
}
return false;
}
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
#endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {
#ifdef SSD1306OLED
#ifdef OLED_ENABLE
set_keylog(keycode, record);
#endif
// set_timelog();

9
keyboards/crkbd/keymaps/hvp/rules.mk
View file

@ -1,10 +1,5 @@
VPATH += keyboards/crkbd/lib
LIB_SRC += ssd1306.c i2c.c
# If you want to change the display of OLED, you need to change here
SRC += ./lib/glcdfont.c \
./lib/rgb_state_reader.c \
SRC += ./lib/rgb_state_reader.c \
./lib/layer_state_reader.c \
./lib/logo_reader.c \
./lib/keylogger.c \
@ -14,4 +9,6 @@ SRC += ./lib/glcdfont.c \
TAP_DANCE_ENABLE = yes
EXTRAKEY_ENABLE = yes # Audio control and System control
OLED_ENABLE = yes
OLED_DRIVER = SSD1306
# LOCAL_GLCDFONT = yes

3
keyboards/crkbd/keymaps/jarred/config.h
View file

@ -28,9 +28,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// #define MASTER_RIGHT
// #define EE_HANDS
#define SSD1306OLED
#define USE_SSD_I2C
#define USE_SERIAL_PD2
//#define TAPPING_FORCE_HOLD

47
keyboards/crkbd/keymaps/jarred/keymap.c
View file

@ -5,10 +5,6 @@
#include "lufa.h"
#include "split_util.h"
#endif
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
#ifdef RGBLIGHT_ENABLE
//Following line allows macro to read current RGB settings
@ -65,15 +61,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
)
};
void matrix_init_user(void) {
//SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
iota_gfx_init(); // turns on the display
#endif
}
//SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
#ifdef OLED_ENABLE
// When add source files to SRC in rules.mk, you can use functions.
const char *read_logo(void);
@ -142,37 +130,18 @@ const char *read_usb_state(void) {
return matrix_line_str;
}
void matrix_scan_user(void) {
iota_gfx_task();
}
void matrix_render_user(struct CharacterMatrix *matrix) {
bool oled_task_user(void) {
if (is_keyboard_master()) {
matrix_write(matrix, read_layer_state());
matrix_write(matrix, "\n");
matrix_write(matrix, read_usb_state());
matrix_write(matrix, "\n");
matrix_write(matrix, read_keylogs());
matrix_write(matrix, "\n");
oled_write_ln(read_layer_state(), false);
oled_write_ln(read_usb_state(), false);
oled_write_ln(read_keylogs(), false);
} else {
matrix_write(matrix, read_logo());
oled_write(read_logo(), false);
}
return false;
}
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
#endif
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {

8
keyboards/crkbd/keymaps/jarred/rules.mk
View file

@ -16,19 +16,17 @@ UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
RGBLIGHT_ENABLE = yes # Enable WS2812 RGB underlight.
SWAP_HANDS_ENABLE = no # Enable one-hand typing
OLED_ENABLE = yes
OLED_DRIVER = SSD1306
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# If you want to change the display of OLED, you need to change here
SRC += ./lib/glcdfont.c \
./lib/rgb_state_reader.c \
SRC += ./lib/rgb_state_reader.c \
./lib/logo_reader.c \
./lib/keylogger.c \
#./lib/layer_state_reader.c \
# ./lib/mode_icon_reader.c \
# ./lib/host_led_state_reader.c \
# ./lib/timelogger.c \
VPATH += keyboards/crkbd/lib
LIB_SRC += ssd1306.c i2c.c

3
keyboards/crkbd/keymaps/kidbrazil/config.h
View file

@ -29,9 +29,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// #define MASTER_RIGHT
// #define EE_HANDS
#define SSD1306OLED
#define USE_SSD_I2C
#define USE_SERIAL_PD2
#define TAPPING_FORCE_HOLD

4
keyboards/crkbd/keymaps/kidbrazil/keymap.c
View file

@ -182,13 +182,13 @@ bool oled_task_user(void) {
master_oled_cleared = true;
}
render_logo();
return;
return false;
}
// Drashna style timeout for LED and OLED Roughly 8mins
else if (timer_elapsed32(oled_timer) > 480000) {
oled_off();
rgb_matrix_disable_noeeprom();
return;
return false;
}
else {
oled_on();

3
keyboards/crkbd/keymaps/kidbrazil/rules.mk
View file

@ -11,6 +11,3 @@ OLED_DRIVER = SSD1306
# If you want to change the display of OLED, you need to change here
SRC += logo_reader.c \
layer.c
VPATH += keyboards/crkbd/lib
LIB_SRC += ssd1306.c i2c.c

3
keyboards/crkbd/keymaps/madhatter/config.h
View file

@ -28,9 +28,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// #define MASTER_RIGHT
// #define EE_HANDS
#define SSD1306OLED
#define USE_SSD_I2C
#define USE_SERIAL_PD2
#define TAPPING_FORCE_HOLD

50
keyboards/crkbd/keymaps/madhatter/keymap.c
View file

@ -17,10 +17,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
#ifdef SSD1306OLED
# include "ssd1306.h"
# include <string.h>
#endif
#include <string.h>
enum corny_layers {
_QWERTY,
@ -108,14 +105,9 @@ void matrix_init_user(void) {
#ifdef RGBLIGHT_ENABLE
RGB_current_mode = rgblight_get_mode();
#endif
//SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
iota_gfx_init(); // turns on the display
#endif
}
//SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
#ifdef OLED_ENABLE
// When add source files to SRC in rules.mk, you can use functions.
const char *read_layer_state(void);
@ -129,42 +121,26 @@ const char *read_keylogs(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) {
bool oled_task_user(void) {
if (is_keyboard_master()) {
// If you want to change the display of OLED, you need to change here
matrix_write(matrix, read_layer_state());
matrix_write(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());
oled_write(read_layer_state(), false);
oled_write(read_keylog(), false);
//oled_write_ln(read_keylogs(), false);
//oled_write_ln(read_mode_icon(keymap_config.swap_lalt_lgui), false);
//oled_write_ln(read_host_led_state(), false);
//oled_write_ln(read_timelog(), false);
} else {
matrix_write(matrix, read_logo());
oled_write(read_logo(), false);
}
return false;
}
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
#endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {
#ifdef SSD1306OLED
#ifdef OLED_ENABLE
set_keylog(keycode, record);
#endif
// set_timelog();

8
keyboards/crkbd/keymaps/madhatter/rules.mk
View file

@ -1,13 +1,11 @@
OLED_ENABLE = yes
OLED_DRIVER = SSD1306
# If you want to change the display of OLED, you need to change here
SRC += ./lib/glcdfont.c \
./lib/rgb_state_reader.c \
SRC += ./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 \
VPATH += keyboards/crkbd/lib
LIB_SRC += ssd1306.c i2c.c

2
keyboards/crkbd/keymaps/ninjonas/keymap.c
View file

@ -1,8 +1,6 @@
#include QMK_KEYBOARD_H
#include "ninjonas.h"
uint8_t is_master;
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT_wrapper(
//,----------------------------------------------------. ,----------------------------------------------------.

4
keyboards/crkbd/keymaps/oled_sample/config.h
View file

@ -21,10 +21,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
//#define USE_MATRIX_I2C
#ifdef KEYBOARD_crkbd_rev1_common
# undef USE_I2C
# define USE_SERIAL
#endif
/* Select hand configuration */

2
keyboards/crkbd/keymaps/rpbaptist/config.h
View file

@ -26,11 +26,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define EE_HANDS
#ifdef OLED_ENABLE
# undef SSD1306OLED
# define OLED_TIMEOUT 600000
#endif
#undef USE_I2C
#define USE_SERIAL_PD2
// #define FORCE_NKRO

2
keyboards/crkbd/keymaps/rs/config.h
View file

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

33
keyboards/crkbd/keymaps/rs/oled.c
View file

@ -1,13 +1,10 @@
#ifdef SSD1306OLED
#ifdef OLED_ENABLE
#include QMK_KEYBOARD_H
#include "ssd1306.h"
#ifdef PROTOCOL_LUFA
#include "lufa.h"
#include "split_util.h"
#endif
extern uint8_t is_master;
// When add source files to SRC in rules.mk, you can use functions.
const char *read_logo(void);
const char *read_keylog(void);
@ -47,7 +44,6 @@ void update_keymap_status(void) {
#endif
void matrix_init_user(void) {
iota_gfx_init(!has_usb()); // turns on the display
update_keymap_status();
}
@ -74,31 +70,18 @@ layer_state_t layer_state_set_user(layer_state_t state) {
}
static inline void render_keymap_status(struct CharacterMatrix *matrix) {
matrix_write(matrix, layer_status_buf);
oled_write(layer_status_buf);
}
void matrix_render_user(struct CharacterMatrix *matrix) {
if (is_master) {
bool oled_task_user(void) {
if (is_keyboard_master()) {
render_keymap_status(matrix);
matrix_write_ln(matrix, read_keylog());
matrix_write_ln(matrix, read_keylogs());
oled_write_ln(read_keylog(), false);
oled_write_ln(read_keylogs(), false);
} else {
matrix_write(matrix, read_logo());
oled_write(read_logo(), false);
}
}
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);
return false;
}
#endif

1
keyboards/crkbd/keymaps/rs/rules.mk
View file

@ -25,7 +25,6 @@ SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# If you want to change the display of OLED, you need to change here
SRC += oled.c \
./lib/glcdfont.c \
./lib/rgb_state_reader.c \
./lib/layer_state_reader.c \
./lib/logo_reader.c \

4
keyboards/crkbd/keymaps/soundmonster/config.h
View file

@ -28,10 +28,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// #define MASTER_RIGHT
// #define EE_HANDS
// #define SSD1306OLED
#undef USE_I2C
#undef SSD1306OLED
#define USE_SERIAL_PD2
// #define TAPPING_FORCE_HOLD

2
keyboards/crkbd/keymaps/thumb_ctrl/config.h
View file

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

50
keyboards/crkbd/keymaps/thumb_ctrl/keymap.c
View file

@ -4,9 +4,6 @@
#include "lufa.h"
#include "split_util.h"
#endif
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
extern keymap_config_t keymap_config;
@ -129,14 +126,9 @@ 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
#ifdef OLED_ENABLE
// When add source files to SRC in rules.mk, you can use functions.
const char *read_layer_state(void);
@ -150,42 +142,26 @@ const char *read_keylogs(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) {
bool oled_task_user(void) {
if (is_keyboard_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());
oled_write_ln(read_layer_state(), false);
oled_write_ln(read_keylog(), false);
oled_write_ln(read_keylogs(), false);
//oled_write_ln(read_mode_icon(keymap_config.swap_lalt_lgui), false);
//oled_write_ln(read_host_led_state(), false);
//oled_write_ln(read_timelog(), false);
} else {
matrix_write(matrix, read_logo());
oled_write(read_logo(), false);
}
return false;
}
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
#endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {
#ifdef SSD1306OLED
#ifdef OLED_ENABLE
set_keylog(keycode, record);
#endif
// set_timelog();

8
keyboards/crkbd/keymaps/thumb_ctrl/rules.mk
View file

@ -16,19 +16,17 @@ UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
RGBLIGHT_ENABLE = yes # Enable WS2812 RGB underlight.
SWAP_HANDS_ENABLE = no # Enable one-hand typing
OLED_ENABLE = yes
OLED_DRIVER = SSD1306
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# If you want to change the display of OLED, you need to change here
SRC += ./lib/glcdfont.c \
./lib/rgb_state_reader.c \
SRC += ./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 \
VPATH += keyboards/crkbd/lib
LIB_SRC += ssd1306.c i2c.c

2
keyboards/crkbd/keymaps/thunderbird2086/config.h
View file

@ -7,8 +7,6 @@
#define SPLIT_USB_DETECT
// #define RGB_LAYER_ENABLE
#undef USE_I2C
#undef SSD1306OLED
#define IGNORE_MOD_TAP_INTERRUPT
#define PERMISSIVE_HOLD

4
keyboards/crkbd/keymaps/vayashiko/keymap.c
View file

@ -79,7 +79,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
#ifdef OLED_ENABLE
oled_rotation_t oled_init_user(oled_rotation_t rotation) {
if (!is_master) {
if (!is_keyboard_master()) {
return OLED_ROTATION_180; // flips the display 180 degrees if offhand
}
return rotation;
@ -165,7 +165,7 @@ void oled_render_logo(void) {
}
bool oled_task_user(void) {
if (is_master) {
if (is_keyboard_master()) {
oled_render_layer_state();
oled_render_keylog();
} else {

3
keyboards/crkbd/keymaps/vayashiko/rules.mk
View file

@ -21,8 +21,7 @@ SWAP_HANDS_ENABLE = no # Enable one-hand typing
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# If you want to change the display of OLED, you need to change here
SRC += ./lib/glcdfont.c \
./lib/rgb_state_reader.c \
SRC += ./lib/rgb_state_reader.c \
./lib/layer_state_reader.c \
./lib/logo_reader.c \
./lib/keylogger.c \

3
keyboards/crkbd/keymaps/vlukash_trackpad_left/config.h
View file

@ -5,9 +5,6 @@
#define MASTER_RIGHT
// #define EE_HANDS
#define SSD1306OLED
#define USE_SSD_I2C
#define USE_SERIAL_PD2
#define TAPPING_FORCE_HOLD

45
keyboards/crkbd/keymaps/vlukash_trackpad_left/keymap.c
View file

@ -4,9 +4,6 @@
#include "lufa.h"
#include "split_util.h"
#endif
#ifdef SSD1306OLED
#include "ssd1306.h"
#endif
#ifdef RGBLIGHT_ENABLE
//Following line allows macro to read current RGB settings
@ -122,14 +119,9 @@ 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(); // turns on the display
#endif
}
//SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
#ifdef SSD1306OLED
#ifdef OLED_ENABLE
// When add source files to SRC in rules.mk, you can use functions.
const char *read_layer_state(void);
@ -138,42 +130,23 @@ 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) {
bool oled_task_user(void) {
if (is_keyboard_master()) {
// If you want to change the display of OLED, you need to change here
matrix_write(matrix, read_layer_state());
matrix_write(matrix, "\n");
matrix_write(matrix, read_keylog());
matrix_write(matrix, "\n");
matrix_write(matrix, read_keylogs());
matrix_write(matrix, "\n");
oled_write_ln(read_layer_state(), false);
oled_write_ln(read_keylog(), false);
oled_write_ln(read_keylogs(), false);
} else {
matrix_write(matrix, read_logo());
oled_write(read_logo(), false);
}
return false;
}
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
#endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {
#ifdef SSD1306OLED
#ifdef OLED_ENABLE
set_keylog(keycode, record);
#endif
}

8
keyboards/crkbd/keymaps/vlukash_trackpad_left/rules.mk
View file

@ -1,14 +1,12 @@
# Build Options
RGBLIGHT_ENABLE = yes # Enable WS2812 RGB underlight.
OLED_ENABLE = yes
OLED_DRIVER = SSD1306
BOOTLOADER = atmel-dfu
# If you want to change the display of OLED, you need to change here
SRC += ./lib/glcdfont.c \
./lib/rgb_state_reader.c \
SRC += ./lib/rgb_state_reader.c \
./lib/layer_state_reader.c \
./lib/logo_reader.c \
./lib/keylogger.c \
VPATH += keyboards/crkbd/lib
LIB_SRC += ssd1306.c i2c.c

3
keyboards/crkbd/keymaps/vxid/config.h
View file

@ -28,9 +28,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define MASTER_RIGHT
// #define EE_HANDS
#define SSD1306OLED
#define USE_SSD_I2C
#define USE_SERIAL_PD2
#define TAPPING_FORCE_HOLD

8
keyboards/crkbd/keymaps/vxid/rules.mk
View file

@ -16,19 +16,17 @@ UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight.
SWAP_HANDS_ENABLE = no # Enable one-hand typing
OLED_ENABLE = yes
OLED_DRIVER = SSD1306
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
# If you want to change the display of OLED, you need to change here
SRC += ./lib/glcdfont.c \
./lib/rgb_state_reader.c \
SRC += ./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 \
VPATH += keyboards/crkbd/lib
LIB_SRC += ssd1306.c i2c.c

162
keyboards/crkbd/lib/i2c.c
View file

@ -1,162 +0,0 @@
#include <util/twi.h>
#include <avr/io.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include <util/twi.h>
#include <stdbool.h>
#include "i2c.h"
#if defined(USE_SSD_I2C)
// Limits the amount of we wait for any one i2c transaction.
// Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is
// 9 bits, a single transaction will take around 90μs to complete.
//
// (F_CPU/SCL_CLOCK) => # of μC cycles to transfer a bit
// poll loop takes at least 8 clock cycles to execute
#define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8
#define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE)
volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
static volatile uint8_t slave_buffer_pos;
static volatile bool slave_has_register_set = false;
// Wait for an i2c operation to finish
inline static
void i2c_delay(void) {
uint16_t lim = 0;
while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT)
lim++;
// easier way, but will wait slightly longer
// _delay_us(100);
}
// Setup twi to run at 100kHz or 400kHz (see ./i2c.h SCL_CLOCK)
void i2c_master_init(void) {
// no prescaler
TWSR = 0;
// Set TWI clock frequency to SCL_CLOCK. Need TWBR>10.
// Check datasheets for more info.
TWBR = ((F_CPU/SCL_CLOCK)-16)/2;
}
// Start a transaction with the given i2c slave address. The direction of the
// transfer is set with I2C_READ and I2C_WRITE.
// returns: 0 => success
// 1 => error
uint8_t i2c_master_start(uint8_t address) {
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);
i2c_delay();
// check that we started successfully
if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))
return 1;
TWDR = address;
TWCR = (1<<TWINT) | (1<<TWEN);
i2c_delay();
if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) )
return 1; // slave did not acknowledge
else
return 0; // success
}
// Finish the i2c transaction.
void i2c_master_stop(void) {
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
uint16_t lim = 0;
while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT)
lim++;
}
// Write one byte to the i2c slave.
// returns 0 => slave ACK
// 1 => slave NACK
uint8_t i2c_master_write(uint8_t data) {
TWDR = data;
TWCR = (1<<TWINT) | (1<<TWEN);
i2c_delay();
// check if the slave acknowledged us
return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1;
}
// Read one byte from the i2c slave. If ack=1 the slave is acknowledged,
// if ack=0 the acknowledge bit is not set.
// returns: byte read from i2c device
uint8_t i2c_master_read(int ack) {
TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA);
i2c_delay();
return TWDR;
}
void i2c_reset_state(void) {
TWCR = 0;
}
void i2c_slave_init(uint8_t address) {
TWAR = address << 0; // slave i2c address
// TWEN - twi enable
// TWEA - enable address acknowledgement
// TWINT - twi interrupt flag
// TWIE - enable the twi interrupt
TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN);
}
ISR(TWI_vect);
ISR(TWI_vect) {
uint8_t ack = 1;
switch(TW_STATUS) {
case TW_SR_SLA_ACK:
// this device has been addressed as a slave receiver
slave_has_register_set = false;
break;
case TW_SR_DATA_ACK:
// this device has received data as a slave receiver
// The first byte that we receive in this transaction sets the location
// of the read/write location of the slaves memory that it exposes over
// i2c. After that, bytes will be written at slave_buffer_pos, incrementing
// slave_buffer_pos after each write.
if(!slave_has_register_set) {
slave_buffer_pos = TWDR;
// don't acknowledge the master if this memory loctaion is out of bounds
if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) {
ack = 0;
slave_buffer_pos = 0;
}
slave_has_register_set = true;
} else {
i2c_slave_buffer[slave_buffer_pos] = TWDR;
BUFFER_POS_INC();
}
break;
case TW_ST_SLA_ACK:
case TW_ST_DATA_ACK:
// master has addressed this device as a slave transmitter and is
// requesting data.
TWDR = i2c_slave_buffer[slave_buffer_pos];
BUFFER_POS_INC();
break;
case TW_BUS_ERROR: // something went wrong, reset twi state
TWCR = 0;
default:
break;
}
// Reset everything, so we are ready for the next TWI interrupt
TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN);
}
#endif

46
keyboards/crkbd/lib/i2c.h
View file

@ -1,46 +0,0 @@
#pragma once
#include <stdint.h>
#ifndef F_CPU
#define F_CPU 16000000UL
#endif
#define I2C_READ 1
#define I2C_WRITE 0
#define I2C_ACK 1
#define I2C_NACK 0
#define SLAVE_BUFFER_SIZE 0x10
// i2c SCL clock frequency 400kHz
#define SCL_CLOCK 400000L
extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
void i2c_master_init(void);
uint8_t i2c_master_start(uint8_t address);
void i2c_master_stop(void);
uint8_t i2c_master_write(uint8_t data);
uint8_t i2c_master_read(int);
void i2c_reset_state(void);
void i2c_slave_init(uint8_t address);
static inline unsigned char i2c_start_read(unsigned char addr) {
return i2c_master_start((addr << 1) | I2C_READ);
}
static inline unsigned char i2c_start_write(unsigned char addr) {
return i2c_master_start((addr << 1) | I2C_WRITE);
}
// from SSD1306 scrips
extern unsigned char i2c_rep_start(unsigned char addr);
extern void i2c_start_wait(unsigned char addr);
extern unsigned char i2c_readAck(void);
extern unsigned char i2c_readNak(void);
extern unsigned char i2c_read(unsigned char ack);
#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak();

4
keyboards/crkbd/lib/layer_state_reader.c
View file

@ -29,7 +29,11 @@ const char *read_layer_state(void) {
snprintf(layer_state_str, sizeof(layer_state_str), "Layer: Adjust");
break;
default:
#if defined (LAYER_STATE_32BIT)
snprintf(layer_state_str, sizeof(layer_state_str), "Layer: Undef-%ld", layer_state);
#else
snprintf(layer_state_str, sizeof(layer_state_str), "Layer: Undef-%d", layer_state);
#endif
}
return layer_state_str;

1
keyboards/crkbd/rules.mk
View file

@ -18,6 +18,7 @@ RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
AUDIO_ENABLE = no # Audio output
RGB_MATRIX_ENABLE = no
RGB_MATRIX_DRIVER = WS2812
LTO_ENABLE = yes
# if firmware size over limit, try this option
# LTO_ENABLE = yes

2
users/ninjonas/oled.c
View file

@ -93,7 +93,7 @@ static void render_logo(void) {
bool oled_task_user(void) {
if (timer_elapsed32(oled_timer) > 15000) {
oled_off();
return;
return false;
}
#ifndef SPLIT_KEYBOARD
else { oled_on(); }