Keyboard: Lily58 update serial.c and add OLED (#4715) * update serial.c and add OLED * update readme * keymap fix * keymap fix2
36 files changed, 1972 insertions(+), 215 deletions(-) M keyboards/lily58/config.h M keyboards/lily58/i2c.c -rw-r--r-- => -rwxr-xr-x M keyboards/lily58/i2c.h -rw-r--r-- => -rwxr-xr-x M keyboards/lily58/keymaps/default/config.h M keyboards/lily58/keymaps/default/keymap.c M keyboards/lily58/keymaps/default/rules.mk M keyboards/lily58/keymaps/yuchi/config.h M keyboards/lily58/keymaps/yuchi/keymap.c M keyboards/lily58/keymaps/yuchi/rules.mk A keyboards/lily58/lib/glcdfont.c A keyboards/lily58/lib/host_led_state_reader.c A keyboards/lily58/lib/keylogger.c A keyboards/lily58/lib/layer_state_reader.c A keyboards/lily58/lib/logo_reader.c A keyboards/lily58/lib/mode_icon_reader.c A keyboards/lily58/lib/rgb_state_reader.c A keyboards/lily58/lib/timelogger.c M keyboards/lily58/lily58.c M keyboards/lily58/lily58.h M keyboards/lily58/readme.md M keyboards/lily58/rev1/config.h A keyboards/lily58/rev1/matrix.c M keyboards/lily58/rev1/rev1.c M keyboards/lily58/rev1/rev1.h M keyboards/lily58/rev1/rules.mk A keyboards/lily58/rev1/serial_config.h A keyboards/lily58/rev1/split_scomm.c A keyboards/lily58/rev1/split_scomm.h A keyboards/lily58/rev1/split_util.c A keyboards/lily58/rev1/split_util.h M keyboards/lily58/rules.mk M keyboards/lily58/serial.c -rw-r--r-- => -rwxr-xr-x M keyboards/lily58/serial.h -rw-r--r-- => -rwxr-xr-x M keyboards/lily58/serial_config.h A keyboards/lily58/ssd1306.c A keyboards/lily58/ssd1306.h
M keyboards/lily58/config.h => keyboards/lily58/config.h +14 -1
@@ 18,4 18,17 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #pragma once #include "serial_config.h" \ No newline at end of file #include "config_common.h" #include <serial_config.h> #define USE_I2C #define USE_SERIAL #ifdef USE_Link_Time_Optimization // LTO has issues with macros (action_get_macro) and "functions" (fn_actions), // so just disable them #define NO_ACTION_MACRO #define NO_ACTION_FUNCTION #define DISABLE_LEADER #endif // USE_Link_Time_Optimization \ No newline at end of file
M keyboards/lily58/i2c.c => keyboards/lily58/i2c.c +1 -1
@@ 34,7 34,7 @@ void i2c_delay(void) { // _delay_us(100); } // Setup twi to run at 100kHz // Setup twi to run at 100kHz or 400kHz (see ./i2c.h SCL_CLOCK) void i2c_master_init(void) { // no prescaler TWSR = 0;
M keyboards/lily58/i2c.h => keyboards/lily58/i2c.h +2 -5
@@ 1,5 1,4 @@ #ifndef I2C_H #define I2C_H #pragma once #include <stdint.h> @@ 15,7 14,7 @@ #define SLAVE_BUFFER_SIZE 0x10 // i2c SCL clock frequency // i2c SCL clock frequency 400kHz #define SCL_CLOCK 400000L extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE]; @@ 45,5 44,3 @@ extern unsigned char i2c_readNak(void); extern unsigned char i2c_read(unsigned char ack); #define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak(); #endif
M keyboards/lily58/keymaps/default/config.h => keyboards/lily58/keymaps/default/config.h +17 -4
@@ 17,12 17,10 @@ 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 /* Use I2C or Serial, not both */ #pragma once #define USE_SERIAL // #define USE_I2C //#define USE_MATRIX_I2C /* Select hand configuration */ @@ 30,6 28,21 @@ 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 #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 // Underglow /* #undef RGBLED_NUM
M keyboards/lily58/keymaps/default/keymap.c => keyboards/lily58/keymaps/default/keymap.c +107 -16
@@ 1,7 1,23 @@ #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; #define _QWERTY 0 #define _LOWER 1 #define _RAISE 2 @@ 88,9 104,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * |------+------+------+------+------+------| |------+------+------+------+------+------| * | | | | | | | | | | | | | | * |------+------+------+------+------+------| |------+------+------+------+------+------| * | | | | | | |-------. ,-------| | | | | | | * | | | | | | |-------. ,-------| | |RGB ON| HUE+ | SAT+ | VAL+ | * |------+------+------+------+------+------| | | |------+------+------+------+------+------| * | | | | | | |-------| |-------| | | | | | | * | | | | | | |-------| |-------| | | MODE | HUE- | SAT- | VAL- | * `-----------------------------------------/ / \ \-----------------------------------------' * | LAlt | LGUI |LOWER | /Space / \Enter \ |RAISE |BackSP| RGUI | * | | | |/ / \ \ | | | | @@ 99,17 115,92 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { [_ADJUST] = LAYOUT( \ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, \ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, \ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, \ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,\ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_TOG, RGB_HUI, RGB_SAI, RGB_VAI, \ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_MOD, RGB_HUD, RGB_SAD, RGB_VAD,\ _______, _______, _______, _______, _______, _______, _______, _______ \ ) }; int RGB_current_mode; // 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) { if (record->event.pressed) { set_single_persistent_default_layer(_QWERTY); } return false; @@ 117,31 208,31 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { case LOWER: if (record->event.pressed) { layer_on(_LOWER); update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } else { layer_off(_LOWER); update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } return false; break; case RAISE: if (record->event.pressed) { layer_on(_RAISE); update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } else { layer_off(_RAISE); update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } return false; break; case ADJUST: if (record->event.pressed) { layer_on(_ADJUST); } else { layer_off(_ADJUST); } return false; break; if (record->event.pressed) { layer_on(_ADJUST); } else { layer_off(_ADJUST); } return false; break; } return true; } \ No newline at end of file
M keyboards/lily58/keymaps/default/rules.mk => keyboards/lily58/keymaps/default/rules.mk +18 -9
@@ 1,21 1,30 @@ # Build Options # change to "no" to disable the options, or define them in the Makefile in # the appropriate keymap folder that will get included automatically # RGBLIGHT_ENABLE = no BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000) MOUSEKEY_ENABLE = no # Mouse keys(+4700) EXTRAKEY_ENABLE = no # Audio control and System control(+450) MOUSEKEY_ENABLE = no # Mouse keys(+4700) EXTRAKEY_ENABLE = no # Audio control and System control(+450) CONSOLE_ENABLE = no # Console for debug(+400) COMMAND_ENABLE = no # Commands for debug and configuration COMMAND_ENABLE = no # Commands for debug and configuration NKRO_ENABLE = no # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality MIDI_ENABLE = no # MIDI controls AUDIO_ENABLE = no # Audio output on port C6 UNICODE_ENABLE = no # Unicode BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID ONEHAND_ENABLE = no # Enable one-hand typing RGBLIGHT_ENABLE = yes # Enable WS2812 RGB underlight. SWAP_HANDS_ENABLE = no # Enable one-hand typing # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend \ No newline at end of file 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 \ ./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 \
M keyboards/lily58/keymaps/yuchi/config.h => keyboards/lily58/keymaps/yuchi/config.h +17 -4
@@ 17,12 17,10 @@ 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 /* Use I2C or Serial, not both */ #pragma once #define USE_SERIAL // #define USE_I2C //#define USE_MATRIX_I2C /* Select hand configuration */ @@ 30,6 28,21 @@ 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 #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 // Underglow /* #undef RGBLED_NUM
M keyboards/lily58/keymaps/yuchi/keymap.c => keyboards/lily58/keymaps/yuchi/keymap.c +108 -17
@@ 1,7 1,23 @@ #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; #define _QWERTY 0 #define _LOWER 1 #define _RAISE 2 @@ 89,28 105,103 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * |------+------+------+------+------+------| |------+------+------+------+------+------| * | | | | | | | | | | | | | | * |------+------+------+------+------+------| |------+------+------+------+------+------| * | | | | | | |-------. ,-------| | | | | | | * | | | | | | |-------. ,-------| | |RGB ON| HUE+ | SAT+ | VAL+ | * |------+------+------+------+------+------| | | |------+------+------+------+------+------| * | | | | | | |-------| |-------| | | | | | | * | | | | | | |-------| |-------| | | MODE | HUE- | SAT- | VAL- | * `-----------------------------------------/ / \ \-----------------------------------------' * |LOWER | LGUI | Alt | /Space / \Enter \ |BackSP| RGUI |RAISE | * | | | |/ / \ \ | | | | * `-------------------''-------' '------''--------------------' * `----------------------------' '------''--------------------' */ [_ADJUST] = LAYOUT( \ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, \ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, \ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, \ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,\ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_TOG, RGB_HUI, RGB_SAI, RGB_VAI, \ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, RGB_MOD, RGB_HUD, RGB_SAD, RGB_VAD,\ _______, _______, _______, _______, _______, _______, _______, _______ \ ) }; int RGB_current_mode; // 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) { if (record->event.pressed) { set_single_persistent_default_layer(_QWERTY); } return false; @@ 118,31 209,31 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { case LOWER: if (record->event.pressed) { layer_on(_LOWER); update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } else { layer_off(_LOWER); update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } return false; break; case RAISE: if (record->event.pressed) { layer_on(_RAISE); update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } else { layer_off(_RAISE); update_tri_layer(_LOWER, _RAISE, _ADJUST); update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST); } return false; break; case ADJUST: if (record->event.pressed) { layer_on(_ADJUST); } else { layer_off(_ADJUST); } return false; break; if (record->event.pressed) { layer_on(_ADJUST); } else { layer_off(_ADJUST); } return false; break; } return true; } \ No newline at end of file
M keyboards/lily58/keymaps/yuchi/rules.mk => keyboards/lily58/keymaps/yuchi/rules.mk +18 -10
@@ 1,22 1,30 @@ # Build Options # change to "no" to disable the options, or define them in the Makefile in # the appropriate keymap folder that will get included automatically # OLED_ENABLE = no RGBLIGHT_ENABLE = no BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000) MOUSEKEY_ENABLE = no # Mouse keys(+4700) EXTRAKEY_ENABLE = no # Audio control and System control(+450) MOUSEKEY_ENABLE = no # Mouse keys(+4700) EXTRAKEY_ENABLE = no # Audio control and System control(+450) CONSOLE_ENABLE = no # Console for debug(+400) COMMAND_ENABLE = no # Commands for debug and configuration COMMAND_ENABLE = no # Commands for debug and configuration NKRO_ENABLE = no # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality MIDI_ENABLE = no # MIDI controls AUDIO_ENABLE = no # Audio output on port C6 UNICODE_ENABLE = no # Unicode BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID ONEHAND_ENABLE = no # Enable one-hand typing RGBLIGHT_ENABLE = yes # Enable WS2812 RGB underlight. SWAP_HANDS_ENABLE = no # Enable one-hand typing # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend \ No newline at end of file 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 \ ./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 \
A keyboards/lily58/lib/glcdfont.c => keyboards/lily58/lib/glcdfont.c +243 -0
@@ 0,0 1,243 @@ // This is the 'classic' fixed-space bitmap font for Adafruit_GFX since 1.0. // See gfxfont.h for newer custom bitmap font info. #ifndef FONT5X7_H #define FONT5X7_H #ifdef __AVR__ #include <avr/io.h> #include <avr/pgmspace.h> #elif defined(ESP8266) #include <pgmspace.h> #else #define PROGMEM #endif // Standard ASCII 5x7 font const unsigned char font[] PROGMEM = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x00, 0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x00, 0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x00, 0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x00, 0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x00, 0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00, 0x00, 0x18, 0x3C, 0x18, 0x00, 0x00, 0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00, 0x00, 0x18, 0x24, 0x18, 0x00, 0x00, 0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x00, 0x30, 0x48, 0x3A, 0x06, 0x0E, 0x00, 0x26, 0x29, 0x79, 0x29, 0x26, 0x00, 0x40, 0x7F, 0x05, 0x05, 0x07, 0x00, 0x40, 0x7F, 0x05, 0x25, 0x3F, 0x00, 0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x00, 0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x00, 0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x00, 0x14, 0x22, 0x7F, 0x22, 0x14, 0x00, 0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x00, 0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00, 0x00, 0x66, 0x89, 0x95, 0x6A, 0x00, 0x60, 0x60, 0x60, 0x60, 0x60, 0x00, 0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x00, 0x08, 0x04, 0x7E, 0x04, 0x08, 0x00, 0x10, 0x20, 0x7E, 0x20, 0x10, 0x00, 0x08, 0x08, 0x2A, 0x1C, 0x08, 0x00, 0x08, 0x1C, 0x2A, 0x08, 0x08, 0x00, 0x1E, 0x10, 0x10, 0x10, 0x10, 0x00, 0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x00, 0x30, 0x38, 0x3E, 0x38, 0x30, 0x00, 0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00, 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00, 0x23, 0x13, 0x08, 0x64, 0x62, 0x00, 0x36, 0x49, 0x56, 0x20, 0x50, 0x00, 0x00, 0x08, 0x07, 0x03, 0x00, 0x00, 0x00, 0x1C, 0x22, 0x41, 0x00, 0x00, 0x00, 0x41, 0x22, 0x1C, 0x00, 0x00, 0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 0x00, 0x80, 0x70, 0x30, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00, 0x00, 0x72, 0x49, 0x49, 0x49, 0x46, 0x00, 0x21, 0x41, 0x49, 0x4D, 0x33, 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10, 0x00, 0x27, 0x45, 0x45, 0x45, 0x39, 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00, 0x41, 0x21, 0x11, 0x09, 0x07, 0x00, 0x36, 0x49, 0x49, 0x49, 0x36, 0x00, 0x46, 0x49, 0x49, 0x29, 0x1E, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x40, 0x34, 0x00, 0x00, 0x00, 0x00, 0x08, 0x14, 0x22, 0x41, 0x00, 0x14, 0x14, 0x14, 0x14, 0x14, 0x00, 0x00, 0x41, 0x22, 0x14, 0x08, 0x00, 0x02, 0x01, 0x59, 0x09, 0x06, 0x00, 0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36, 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22, 0x00, 0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41, 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01, 0x00, 0x3E, 0x41, 0x41, 0x51, 0x73, 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00, 0x00, 0x20, 0x40, 0x41, 0x3F, 0x01, 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41, 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40, 0x00, 0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06, 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00, 0x7F, 0x09, 0x19, 0x29, 0x46, 0x00, 0x26, 0x49, 0x49, 0x49, 0x32, 0x00, 0x03, 0x01, 0x7F, 0x01, 0x03, 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00, 0x63, 0x14, 0x08, 0x14, 0x63, 0x00, 0x03, 0x04, 0x78, 0x04, 0x03, 0x00, 0x61, 0x59, 0x49, 0x4D, 0x43, 0x00, 0x00, 0x7F, 0x41, 0x41, 0x41, 0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x00, 0x00, 0x41, 0x41, 0x41, 0x7F, 0x00, 0x04, 0x02, 0x01, 0x02, 0x04, 0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00, 0x03, 0x07, 0x08, 0x00, 0x00, 0x20, 0x54, 0x54, 0x78, 0x40, 0x00, 0x7F, 0x28, 0x44, 0x44, 0x38, 0x00, 0x38, 0x44, 0x44, 0x44, 0x28, 0x00, 0x38, 0x44, 0x44, 0x28, 0x7F, 0x00, 0x38, 0x54, 0x54, 0x54, 0x18, 0x00, 0x00, 0x08, 0x7E, 0x09, 0x02, 0x00, 0x18, 0x24, 0x24, 0x1C, 0x78, 0x00, 0x7F, 0x08, 0x04, 0x04, 0x78, 0x00, 0x00, 0x44, 0x7D, 0x40, 0x00, 0x00, 0x20, 0x40, 0x40, 0x3D, 0x00, 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00, 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00, 0x00, 0x7C, 0x04, 0x78, 0x04, 0x78, 0x00, 0x7C, 0x08, 0x04, 0x04, 0x78, 0x00, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x7C, 0x18, 0x24, 0x24, 0x18, 0x00, 0x18, 0x24, 0x24, 0x18, 0x7C, 0x00, 0x7C, 0x08, 0x04, 0x04, 0x08, 0x00, 0x48, 0x54, 0x54, 0x54, 0x24, 0x00, 0x04, 0x04, 0x3F, 0x44, 0x24, 0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00, 0x44, 0x28, 0x10, 0x28, 0x44, 0x00, 0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00, 0x44, 0x64, 0x54, 0x4C, 0x44, 0x00, 0x00, 0x08, 0x36, 0x41, 0x00, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00, 0x00, 0x00, 0x41, 0x36, 0x08, 0x00, 0x00, 0x02, 0x01, 0x02, 0x04, 0x02, 0x00, 0x3C, 0x26, 0x23, 0x26, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xE0, 0x70, 0x18, 0x0C, 0x18, 0x30, 0xE0, 0x80, 0x00, 0x00, 0x10, 0xF8, 0x90, 0x10, 0x30, 0x78, 0x30, 0x10, 0xB8, 0xFC, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFC, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x9C, 0x1C, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFC, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0xFC, 0xF8, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xE0, 0xF8, 0x7C, 0x1C, 0x00, 0x00, 0x00, 0xF0, 0xFC, 0xFC, 0xFC, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xF0, 0xF8, 0x38, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x3C, 0xF8, 0xF0, 0xE0, 0x00, 0xE0, 0xF0, 0xF0, 0xF0, 0xE0, 0xEC, 0xEE, 0xF7, 0xF3, 0x70, 0x20, 0x00, 0x7C, 0x7C, 0x7C, 0x7E, 0x00, 0x7E, 0x7E, 0x7E, 0x7F, 0x7F, 0x7F, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0x7E, 0x5B, 0x4F, 0x5B, 0xFE, 0xC0, 0x00, 0x00, 0xC0, 0x00, 0xDC, 0xD7, 0xDE, 0xDE, 0xDE, 0xD7, 0xDC, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xBC, 0xE0, 0x81, 0x81, 0x81, 0x83, 0x83, 0x82, 0x87, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0x00, 0x00, 0x1F, 0xFE, 0x90, 0xB9, 0xFF, 0xBB, 0x91, 0x98, 0x3C, 0x18, 0x11, 0x13, 0x3F, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0F, 0x7F, 0xF8, 0xE0, 0x80, 0xF0, 0xFC, 0x3F, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x3F, 0x3F, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x3C, 0x78, 0xF8, 0xF0, 0xE0, 0x80, 0x00, 0x00, 0x00, 0x00, 0xC3, 0xE7, 0xFF, 0x7E, 0x3C, 0x38, 0x78, 0x78, 0x70, 0x70, 0xF8, 0xFF, 0xDF, 0x87, 0x00, 0x0F, 0x1F, 0x3F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x3F, 0x1E, 0x0C, 0x00, 0x1F, 0x1F, 0x1F, 0x3F, 0x00, 0x3F, 0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0x00, 0x30, 0x7B, 0x7F, 0x78, 0x30, 0x20, 0x20, 0x30, 0x78, 0x7F, 0x3B, 0x00, 0x03, 0x00, 0x0F, 0x7F, 0x0F, 0x0F, 0x0F, 0x7F, 0x0F, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3C, 0x24, 0x66, 0x63, 0x41, 0xC1, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0xC1, 0x41, 0x62, 0x38, 0x6C, 0x4C, 0xC6, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0xC1, 0x43, 0x62, 0x36, 0x1C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xC0, 0x80, 0x00, 0x00, 0x00, 0xE0, 0xE0, 0xC0, 0xC0, 0xC0, 0xE0, 0xF9, 0x7F, 0x1F, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xF0, 0xE0, 0xE0, 0xC0, 0xC0, 0xC0, 0xC0, 0xE0, 0xF0, 0xF8, 0x7F, 0x3F, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x3F, 0x7F, 0xF9, 0xE0, 0xE0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xE0, 0xF9, 0x7F, 0x3F, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }; #endif // FONT5X7_H
A keyboards/lily58/lib/host_led_state_reader.c => keyboards/lily58/lib/host_led_state_reader.c +15 -0
@@ 0,0 1,15 @@ #include <stdio.h> #include "lily58.h" char host_led_state_str[24]; const char *read_host_led_state(void) { uint8_t leds = host_keyboard_leds(); snprintf(host_led_state_str, sizeof(host_led_state_str), "NL:%s CL:%s SL:%s", (leds & (1 << USB_LED_NUM_LOCK)) ? "on" : "- ", (leds & (1 << USB_LED_CAPS_LOCK)) ? "on" : "- ", (leds & (1 << USB_LED_SCROLL_LOCK)) ? "on" : "- "); return host_led_state_str; }
A keyboards/lily58/lib/keylogger.c => keyboards/lily58/lib/keylogger.c +45 -0
@@ 0,0 1,45 @@ #include <stdio.h> #include "lily58.h" char keylog_str[24] = {}; char keylogs_str[21] = {}; int keylogs_str_idx = 0; const char code_to_name[60] = { ' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'R', 'E', 'B', 'T', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ';', '\'', ' ', ',', '.', '/', ' ', ' ', ' '}; void set_keylog(uint16_t keycode, keyrecord_t *record) { char name = ' '; if (keycode < 60) { name = code_to_name[keycode]; } // update keylog snprintf(keylog_str, sizeof(keylog_str), "%dx%d, k%2d : %c", record->event.key.row, record->event.key.col, keycode, name); // update keylogs if (keylogs_str_idx == sizeof(keylogs_str) - 1) { keylogs_str_idx = 0; for (int i = 0; i < sizeof(keylogs_str) - 1; i++) { keylogs_str[i] = ' '; } } keylogs_str[keylogs_str_idx] = name; keylogs_str_idx++; } const char *read_keylog(void) { return keylog_str; } const char *read_keylogs(void) { return keylogs_str; }
A keyboards/lily58/lib/layer_state_reader.c => keyboards/lily58/lib/layer_state_reader.c +35 -0
@@ 0,0 1,35 @@ #include QMK_KEYBOARD_H #include <stdio.h> #include "lily58.h" #define L_BASE 0 #define L_LOWER 2 #define L_RAISE 4 #define L_ADJUST 65536 #define L_ADJUST_TRI 65542 char layer_state_str[24]; const char *read_layer_state(void) { switch (layer_state) { case L_BASE: snprintf(layer_state_str, sizeof(layer_state_str), "Layer: Default"); break; case L_RAISE: snprintf(layer_state_str, sizeof(layer_state_str), "Layer: Raise"); break; case L_LOWER: snprintf(layer_state_str, sizeof(layer_state_str), "Layer: Lower"); break; case L_ADJUST: case L_ADJUST_TRI: snprintf(layer_state_str, sizeof(layer_state_str), "Layer: Adjust"); break; default: snprintf(layer_state_str, sizeof(layer_state_str), "Layer: Undef-%ld", layer_state); } return layer_state_str; }
A keyboards/lily58/lib/logo_reader.c => keyboards/lily58/lib/logo_reader.c +11 -0
@@ 0,0 1,11 @@ #include "lily58.h" const char *read_logo(void) { 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}; return logo; }
A keyboards/lily58/lib/mode_icon_reader.c => keyboards/lily58/lib/mode_icon_reader.c +15 -0
@@ 0,0 1,15 @@ #include <stdio.h> #include "lily58.h" char mode_icon[24]; const char *read_mode_icon(bool swap) { static char logo[][2][3] = {{{0x95, 0x96, 0}, {0xb5, 0xb6, 0}}, {{0x97, 0x98, 0}, {0xb7, 0xb8, 0}}}; if (swap == false) { snprintf(mode_icon, sizeof(mode_icon), "%s\n%s", logo[0][0], logo[0][1]); } else { snprintf(mode_icon, sizeof(mode_icon), "%s\n%s", logo[1][0], logo[1][1]); } return mode_icon; }
A keyboards/lily58/lib/rgb_state_reader.c => keyboards/lily58/lib/rgb_state_reader.c +15 -0
@@ 0,0 1,15 @@ #ifdef RGBLIGHT_ENABLE #include QMK_KEYBOARD_H #include <stdio.h> extern rgblight_config_t rgblight_config; char rbf_info_str[24]; const char *read_rgb_info(void) { snprintf(rbf_info_str, sizeof(rbf_info_str), "%s %2d h%3d s%3d v%3d", rgblight_config.enable ? "on" : "- ", rgblight_config.mode, rgblight_config.hue, rgblight_config.sat, rgblight_config.val); return rbf_info_str; } #endif
A keyboards/lily58/lib/timelogger.c => keyboards/lily58/lib/timelogger.c +16 -0
@@ 0,0 1,16 @@ #include <stdio.h> #include "lily58.h" char timelog_str[24] = {}; int last_time = 0; int elapsed_time = 0; void set_timelog(void) { elapsed_time = timer_elapsed(last_time); last_time = timer_read(); snprintf(timelog_str, sizeof(timelog_str), "lt:%5d, et:%5d", last_time, elapsed_time); } const char *read_timelog(void) { return timelog_str; }
M keyboards/lily58/lily58.c => keyboards/lily58/lily58.c +10 -1
@@ 1,1 1,10 @@ #include "lily58.h" #include "lily58.h" #include "ssd1306.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 } \ No newline at end of file
M keyboards/lily58/lily58.h => keyboards/lily58/lily58.h +1 -24
@@ 1,28 1,5 @@ #ifndef LILY58_H #define LILY58_H #include "quantum.h" #pragma once #ifdef KEYBOARD_lily58_rev1 #include "rev1.h" #endif // Used to create a keymap using only KC_ prefixed keys #define LAYOUT_kc( \ L00, L01, L02, L03, L04, L05, R00, R01, R02, R03, R04, R05, \ L10, L11, L12, L13, L14, L15, R10, R11, R12, R13, R14, R15, \ L20, L21, L22, L23, L24, L25, R20, R21, R22, R23, R24, R25, \ L30, L31, L32, L33, L34, L35, L45, R40, R30, R31, R32, R33, R34, R35, \ L41, L42, L43, L44, R41, R42, R43, R44 \ ) \ LAYOUT( \ KC_##L00, KC_##L01, KC_##L02, KC_##L03, KC_##L04, KC_##L05, KC_##R00, KC_##R01, KC_##R02, KC_##R03, KC_##R04, KC_##R05, \ KC_##L10, KC_##L11, KC_##L12, KC_##L13, KC_##L14, KC_##L15, KC_##R10, KC_##R11, KC_##R12, KC_##R13, KC_##R14, KC_##R15, \ KC_##L20, KC_##L21, KC_##L22, KC_##L23, KC_##L24, KC_##L25, KC_##R20, KC_##R21, KC_##R22, KC_##R23, KC_##R24, KC_##R25, \ KC_##L30, KC_##L31, KC_##L32, KC_##L33, KC_##L34, KC_##L35, KC_##L45, KC_##R40, KC_##R30, KC_##R31, KC_##R32, KC_##R33, KC_##R34, KC_##R35, \ KC_##L41, KC_##L42, KC_##L43, KC_##L44, KC_##R41, KC_##R42, KC_##R43, KC_##R44 \ ) #endif
M keyboards/lily58/readme.md => keyboards/lily58/readme.md +3 -5
@@ 2,16 2,14 @@ Lily58 is 6×4+5keys column-staggered split keyboard.     Keyboard Maintainer: [Naoki Katahira](https://github.com/kata0510/) [Twitter:@F_YUUCHI](https://twitter.com/F_YUUCHI) Hardware Supported: Lily58 PCB, ProMicro Hardware Availability: [PCB & Case Data](https://github.com/kata0510/Lily58) Make example for this keyboard (after setting up your build environment): make lily58:default sudo make lily58:default See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). \ No newline at end of file
M keyboards/lily58/rev1/config.h => keyboards/lily58/rev1/config.h +5 -9
@@ 19,12 19,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #pragma once //#include QMK_KEYBOARD_CONFIG_H #include "config_common.h" /* USB Device descriptor parameter */ #define VENDOR_ID 0xFC51 #define PRODUCT_ID 0x0058 #define PRODUCT_ID 0x0058 #define DEVICE_VER 0x0100 #define MANUFACTURER F_YUUCHI #define PRODUCT Lily58 @@ 51,9 48,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define DEBOUNCING_DELAY 5 /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ #define LOCKING_SUPPORT_ENABLE //#define LOCKING_SUPPORT_ENABLE /* Locking resynchronize hack */ #define LOCKING_RESYNC_ENABLE //#define LOCKING_RESYNC_ENABLE /* key combination for command */ #define IS_COMMAND() ( \ @@ 62,8 59,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. /* ws2812 RGB LED */ #define RGB_DI_PIN D3 #define RGBLED_NUM 14 // Number of LEDs #define RGBLED_NUM 12 // Number of LEDs /* * Feature disable options @@ 81,4 77,4 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. //#define NO_ACTION_TAPPING //#define NO_ACTION_ONESHOT //#define NO_ACTION_MACRO //#define NO_ACTION_FUNCTION //#define NO_ACTION_FUNCTION \ No newline at end of file
A keyboards/lily58/rev1/matrix.c => keyboards/lily58/rev1/matrix.c +357 -0
@@ 0,0 1,357 @@ /* Copyright 2012 Jun Wako <wakojun@gmail.com> 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/>. */ /* * scan matrix */ #include <stdint.h> #include <stdbool.h> #include <string.h> #include <avr/io.h> #include <avr/wdt.h> #include <avr/interrupt.h> #include <util/delay.h> #include "print.h" #include "debug.h" #include "util.h" #include "matrix.h" #include "split_util.h" #include "pro_micro.h" #ifdef USE_MATRIX_I2C # include "i2c.h" #else // USE_SERIAL # include "split_scomm.h" #endif #ifndef DEBOUNCE # define DEBOUNCE 5 #endif #define ERROR_DISCONNECT_COUNT 5 static uint8_t debouncing = DEBOUNCE; static const int ROWS_PER_HAND = MATRIX_ROWS/2; static uint8_t error_count = 0; uint8_t is_master = 0 ; static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; /* matrix state(1:on, 0:off) */ static matrix_row_t matrix[MATRIX_ROWS]; static matrix_row_t matrix_debouncing[MATRIX_ROWS]; static matrix_row_t read_cols(void); static void init_cols(void); static void unselect_rows(void); static void select_row(uint8_t row); static uint8_t matrix_master_scan(void); __attribute__ ((weak)) void matrix_init_kb(void) { matrix_init_user(); } __attribute__ ((weak)) void matrix_scan_kb(void) { matrix_scan_user(); } __attribute__ ((weak)) void matrix_init_user(void) { } __attribute__ ((weak)) void matrix_scan_user(void) { } inline uint8_t matrix_rows(void) { return MATRIX_ROWS; } inline uint8_t matrix_cols(void) { return MATRIX_COLS; } void matrix_init(void) { debug_enable = true; debug_matrix = true; debug_mouse = true; // initialize row and col unselect_rows(); init_cols(); TX_RX_LED_INIT; TXLED0; RXLED0; // initialize matrix state: all keys off for (uint8_t i=0; i < MATRIX_ROWS; i++) { matrix[i] = 0; matrix_debouncing[i] = 0; } is_master = has_usb(); matrix_init_quantum(); } uint8_t _matrix_scan(void) { // Right hand is stored after the left in the matirx so, we need to offset it int offset = isLeftHand ? 0 : (ROWS_PER_HAND); for (uint8_t i = 0; i < ROWS_PER_HAND; i++) { select_row(i); _delay_us(30); // without this wait read unstable value. matrix_row_t cols = read_cols(); if (matrix_debouncing[i+offset] != cols) { matrix_debouncing[i+offset] = cols; debouncing = DEBOUNCE; } unselect_rows(); } if (debouncing) { if (--debouncing) { _delay_ms(1); } else { for (uint8_t i = 0; i < ROWS_PER_HAND; i++) { matrix[i+offset] = matrix_debouncing[i+offset]; } } } return 1; } #ifdef USE_MATRIX_I2C // Get rows from other half over i2c int i2c_transaction(void) { int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE); if (err) goto i2c_error; // start of matrix stored at 0x00 err = i2c_master_write(0x00); if (err) goto i2c_error; // Start read err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ); if (err) goto i2c_error; if (!err) { int i; for (i = 0; i < ROWS_PER_HAND-1; ++i) { matrix[slaveOffset+i] = i2c_master_read(I2C_ACK); } matrix[slaveOffset+i] = i2c_master_read(I2C_NACK); i2c_master_stop(); } else { i2c_error: // the cable is disconnceted, or something else went wrong i2c_reset_state(); return err; } return 0; } #else // USE_SERIAL int serial_transaction(int master_changed) { int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; #ifdef SERIAL_USE_MULTI_TRANSACTION int ret=serial_update_buffers(master_changed); #else int ret=serial_update_buffers(); #endif if (ret ) { if(ret==2) RXLED1; return 1; } RXLED0; memcpy(&matrix[slaveOffset], (void *)serial_slave_buffer, SERIAL_SLAVE_BUFFER_LENGTH); return 0; } #endif uint8_t matrix_scan(void) { if (is_master) { matrix_master_scan(); }else{ matrix_slave_scan(); int offset = (isLeftHand) ? ROWS_PER_HAND : 0; memcpy(&matrix[offset], (void *)serial_master_buffer, SERIAL_MASTER_BUFFER_LENGTH); matrix_scan_quantum(); } return 1; } uint8_t matrix_master_scan(void) { int ret = _matrix_scan(); int mchanged = 1; int offset = (isLeftHand) ? 0 : ROWS_PER_HAND; #ifdef USE_MATRIX_I2C // for (int i = 0; i < ROWS_PER_HAND; ++i) { /* i2c_slave_buffer[i] = matrix[offset+i]; */ // i2c_slave_buffer[i] = matrix[offset+i]; // } #else // USE_SERIAL #ifdef SERIAL_USE_MULTI_TRANSACTION mchanged = memcmp((void *)serial_master_buffer, &matrix[offset], SERIAL_MASTER_BUFFER_LENGTH); #endif memcpy((void *)serial_master_buffer, &matrix[offset], SERIAL_MASTER_BUFFER_LENGTH); #endif #ifdef USE_MATRIX_I2C if( i2c_transaction() ) { #else // USE_SERIAL if( serial_transaction(mchanged) ) { #endif // turn on the indicator led when halves are disconnected TXLED1; error_count++; if (error_count > ERROR_DISCONNECT_COUNT) { // reset other half if disconnected int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; for (int i = 0; i < ROWS_PER_HAND; ++i) { matrix[slaveOffset+i] = 0; } } } else { // turn off the indicator led on no error TXLED0; error_count = 0; } matrix_scan_quantum(); return ret; } void matrix_slave_scan(void) { _matrix_scan(); int offset = (isLeftHand) ? 0 : ROWS_PER_HAND; #ifdef USE_MATRIX_I2C for (int i = 0; i < ROWS_PER_HAND; ++i) { /* i2c_slave_buffer[i] = matrix[offset+i]; */ i2c_slave_buffer[i] = matrix[offset+i]; } #else // USE_SERIAL #ifdef SERIAL_USE_MULTI_TRANSACTION int change = 0; #endif for (int i = 0; i < ROWS_PER_HAND; ++i) { #ifdef SERIAL_USE_MULTI_TRANSACTION if( serial_slave_buffer[i] != matrix[offset+i] ) change = 1; #endif serial_slave_buffer[i] = matrix[offset+i]; } #ifdef SERIAL_USE_MULTI_TRANSACTION slave_buffer_change_count += change; #endif #endif } bool matrix_is_modified(void) { if (debouncing) return false; return true; } inline bool matrix_is_on(uint8_t row, uint8_t col) { return (matrix[row] & ((matrix_row_t)1<<col)); } inline matrix_row_t matrix_get_row(uint8_t row) { return matrix[row]; } void matrix_print(void) { print("\nr/c 0123456789ABCDEF\n"); for (uint8_t row = 0; row < MATRIX_ROWS; row++) { phex(row); print(": "); pbin_reverse16(matrix_get_row(row)); print("\n"); } } uint8_t matrix_key_count(void) { uint8_t count = 0; for (uint8_t i = 0; i < MATRIX_ROWS; i++) { count += bitpop16(matrix[i]); } return count; } static void init_cols(void) { for(int x = 0; x < MATRIX_COLS; x++) { _SFR_IO8((col_pins[x] >> 4) + 1) &= ~_BV(col_pins[x] & 0xF); _SFR_IO8((col_pins[x] >> 4) + 2) |= _BV(col_pins[x] & 0xF); } } static matrix_row_t read_cols(void) { matrix_row_t result = 0; for(int x = 0; x < MATRIX_COLS; x++) { result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x); } return result; } static void unselect_rows(void) { for(int x = 0; x < ROWS_PER_HAND; x++) { _SFR_IO8((row_pins[x] >> 4) + 1) &= ~_BV(row_pins[x] & 0xF); _SFR_IO8((row_pins[x] >> 4) + 2) |= _BV(row_pins[x] & 0xF); } } static void select_row(uint8_t row) { _SFR_IO8((row_pins[row] >> 4) + 1) |= _BV(row_pins[row] & 0xF); _SFR_IO8((row_pins[row] >> 4) + 2) &= ~_BV(row_pins[row] & 0xF); }
M keyboards/lily58/rev1/rev1.c => keyboards/lily58/rev1/rev1.c +6 -12
@@ 1,14 1,8 @@ #include "lily58.h" void matrix_init_kb(void) { // // green led on // DDRD |= (1<<5); // PORTD &= ~(1<<5); // // orange led on // DDRB |= (1<<0); // PORTB &= ~(1<<0); matrix_init_user(); }; \ No newline at end of file #ifdef SSD1306OLED void led_set_kb(uint8_t usb_led) { // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here //led_set_user(usb_led); } #endif \ No newline at end of file
M keyboards/lily58/rev1/rev1.h => keyboards/lily58/rev1/rev1.h +4 -0
@@ 5,6 5,10 @@ //void promicro_bootloader_jmp(bool program); #include "quantum.h" #ifdef RGBLIGHT_ENABLE //rgb led driver #include "ws2812.h" #endif #ifdef USE_I2C #include <stddef.h>
M keyboards/lily58/rev1/rules.mk => keyboards/lily58/rev1/rules.mk +3 -1
@@ 1,1 1,3 @@ BACKLIGHT_ENABLE = no \ No newline at end of file SRC += rev1/matrix.c SRC += rev1/split_util.c SRC += rev1/split_scomm.c \ No newline at end of file
A keyboards/lily58/rev1/serial_config.h => keyboards/lily58/rev1/serial_config.h +4 -0
@@ 0,0 1,4 @@ #ifndef SOFT_SERIAL_PIN #define SOFT_SERIAL_PIN D2 #define SERIAL_USE_MULTI_TRANSACTION #endif
A keyboards/lily58/rev1/split_scomm.c => keyboards/lily58/rev1/split_scomm.c +91 -0
@@ 0,0 1,91 @@ #ifdef USE_SERIAL #ifdef SERIAL_USE_MULTI_TRANSACTION /* --- USE flexible API (using multi-type transaction function) --- */ #include <stdbool.h> #include <stdint.h> #include <stddef.h> #include <split_scomm.h> #include "serial.h" #ifdef CONSOLE_ENABLE #include <print.h> #endif uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0}; uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0}; uint8_t volatile status_com = 0; uint8_t volatile status1 = 0; uint8_t slave_buffer_change_count = 0; uint8_t s_change_old = 0xff; uint8_t s_change_new = 0xff; SSTD_t transactions[] = { #define GET_SLAVE_STATUS 0 /* master buffer not changed, only recive slave_buffer_change_count */ { (uint8_t *)&status_com, 0, NULL, sizeof(slave_buffer_change_count), &slave_buffer_change_count, }, #define PUT_MASTER_GET_SLAVE_STATUS 1 /* master buffer changed need send, and recive slave_buffer_change_count */ { (uint8_t *)&status_com, sizeof(serial_master_buffer), (uint8_t *)serial_master_buffer, sizeof(slave_buffer_change_count), &slave_buffer_change_count, }, #define GET_SLAVE_BUFFER 2 /* recive serial_slave_buffer */ { (uint8_t *)&status1, 0, NULL, sizeof(serial_slave_buffer), (uint8_t *)serial_slave_buffer } }; void serial_master_init(void) { soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); } void serial_slave_init(void) { soft_serial_target_init(transactions, TID_LIMIT(transactions)); } // 0 => no error // 1 => slave did not respond // 2 => checksum error int serial_update_buffers(int master_update) { int status, smatstatus; static int need_retry = 0; if( s_change_old != s_change_new ) { smatstatus = soft_serial_transaction(GET_SLAVE_BUFFER); if( smatstatus == TRANSACTION_END ) { s_change_old = s_change_new; #ifdef CONSOLE_ENABLE uprintf("slave matrix = %b %b %b %b\n", serial_slave_buffer[0], serial_slave_buffer[1], serial_slave_buffer[2], serial_slave_buffer[3]); #endif } } else { // serial_slave_buffer dosen't change smatstatus = TRANSACTION_END; // dummy status } if( !master_update && !need_retry) { status = soft_serial_transaction(GET_SLAVE_STATUS); } else { status = soft_serial_transaction(PUT_MASTER_GET_SLAVE_STATUS); } if( status == TRANSACTION_END ) { s_change_new = slave_buffer_change_count; need_retry = 0; } else { need_retry = 1; } return smatstatus; } #endif // SERIAL_USE_MULTI_TRANSACTION #endif /* USE_SERIAL */
A keyboards/lily58/rev1/split_scomm.h => keyboards/lily58/rev1/split_scomm.h +24 -0
@@ 0,0 1,24 @@ #ifndef SPLIT_COMM_H #define SPLIT_COMM_H #ifndef SERIAL_USE_MULTI_TRANSACTION /* --- USE Simple API (OLD API, compatible with let's split serial.c) --- */ #include "serial.h" #else /* --- USE flexible API (using multi-type transaction function) --- */ // Buffers for master - slave communication #define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2 #define SERIAL_MASTER_BUFFER_LENGTH MATRIX_ROWS/2 extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH]; extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH]; extern uint8_t slave_buffer_change_count; void serial_master_init(void); void serial_slave_init(void); int serial_update_buffers(int master_changed); #endif #endif /* SPLIT_COMM_H */
A keyboards/lily58/rev1/split_util.c => keyboards/lily58/rev1/split_util.c +70 -0
@@ 0,0 1,70 @@ #include <avr/io.h> #include <avr/wdt.h> #include <avr/power.h> #include <avr/interrupt.h> #include <util/delay.h> #include <avr/eeprom.h> #include "split_util.h" #include "matrix.h" #include "keyboard.h" #ifdef USE_MATRIX_I2C # include "i2c.h" #else # include "split_scomm.h" #endif volatile bool isLeftHand = true; static void setup_handedness(void) { #ifdef EE_HANDS isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS); #else // I2C_MASTER_RIGHT is deprecated, use MASTER_RIGHT instead, since this works for both serial and i2c #if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT) isLeftHand = !has_usb(); #else isLeftHand = has_usb(); #endif #endif } static void keyboard_master_setup(void) { #ifdef USE_MATRIX_I2C i2c_master_init(); #else serial_master_init(); #endif } static void keyboard_slave_setup(void) { #ifdef USE_MATRIX_I2C i2c_slave_init(SLAVE_I2C_ADDRESS); #else serial_slave_init(); #endif } bool has_usb(void) { USBCON |= (1 << OTGPADE); //enables VBUS pad _delay_us(5); return (USBSTA & (1<<VBUS)); //checks state of VBUS } void split_keyboard_setup(void) { setup_handedness(); if (has_usb()) { keyboard_master_setup(); } else { keyboard_slave_setup(); } sei(); } // this code runs before the usb and keyboard is initialized void matrix_setup(void) { split_keyboard_setup(); }
A keyboards/lily58/rev1/split_util.h => keyboards/lily58/rev1/split_util.h +19 -0
@@ 0,0 1,19 @@ #ifndef SPLIT_KEYBOARD_UTIL_H #define SPLIT_KEYBOARD_UTIL_H #include <stdbool.h> #include "eeconfig.h" #define SLAVE_I2C_ADDRESS 0x32 extern volatile bool isLeftHand; // slave version of matix scan, defined in matrix.c void matrix_slave_scan(void); void split_keyboard_setup(void); bool has_usb(void); void matrix_master_OLED_init (void); #endif
M keyboards/lily58/rules.mk => keyboards/lily58/rules.mk +11 -9
@@ 1,7 1,10 @@ SRC += matrix.c \ i2c.c \ split_util.c \ serial.c SRC += i2c.c SRC += serial.c SRC += ssd1306.c # if firmware size over limit, try this option # CFLAGS += -flto # MCU name #MCU = at90usb1287 MCU = atmega32u4 @@ 38,16 41,15 @@ ARCH = AVR8 # CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU. F_USB = $(F_CPU) # Interrupt driven control endpoint task(+60) OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT # Bootloader # This definition is optional, and if your keyboard supports multiple bootloaders of # different sizes, comment this out, and the correct address will be loaded # automatically (+60). See bootloader.mk for all options. BOOTLOADER = caterina # Interrupt driven control endpoint task(+60) OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT # Build Options # change to "no" to disable the options, or define them in the Makefile in # the appropriate keymap folder that will get included automatically @@ 65,7 67,7 @@ UNICODE_ENABLE = no # Unicode BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight. SUBPROJECT_rev1 = no USE_I2C = no USE_I2C = yes # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
M keyboards/lily58/serial.c => keyboards/lily58/serial.c +215 -70
@@ 1,5 1,10 @@ /* * WARNING: be careful changing this code, it is very timing dependent * * 2018-10-28 checked * avr-gcc 4.9.2 * avr-gcc 5.4.0 * avr-gcc 7.3.0 */ #ifndef F_CPU @@ 14,9 19,58 @@ #include "serial.h" //#include <pro_micro.h> #ifdef USE_SERIAL //#ifndef USE_SERIAL_PD2 #ifdef SOFT_SERIAL_PIN #ifdef __AVR_ATmega32U4__ // if using ATmega32U4 I2C, can not use PD0 and PD1 in soft serial. #ifdef USE_I2C #if SOFT_SERIAL_PIN == D0 || SOFT_SERIAL_PIN == D1 #error Using ATmega32U4 I2C, so can not use PD0, PD1 #endif #endif #if SOFT_SERIAL_PIN >= D0 && SOFT_SERIAL_PIN <= D3 #define SERIAL_PIN_DDR DDRD #define SERIAL_PIN_PORT PORTD #define SERIAL_PIN_INPUT PIND #if SOFT_SERIAL_PIN == D0 #define SERIAL_PIN_MASK _BV(PD0) #define EIMSK_BIT _BV(INT0) #define EICRx_BIT (~(_BV(ISC00) | _BV(ISC01))) #define SERIAL_PIN_INTERRUPT INT0_vect #elif SOFT_SERIAL_PIN == D1 #define SERIAL_PIN_MASK _BV(PD1) #define EIMSK_BIT _BV(INT1) #define EICRx_BIT (~(_BV(ISC10) | _BV(ISC11))) #define SERIAL_PIN_INTERRUPT INT1_vect #elif SOFT_SERIAL_PIN == D2 #define SERIAL_PIN_MASK _BV(PD2) #define EIMSK_BIT _BV(INT2) #define EICRx_BIT (~(_BV(ISC20) | _BV(ISC21))) #define SERIAL_PIN_INTERRUPT INT2_vect #elif SOFT_SERIAL_PIN == D3 #define SERIAL_PIN_MASK _BV(PD3) #define EIMSK_BIT _BV(INT3) #define EICRx_BIT (~(_BV(ISC30) | _BV(ISC31))) #define SERIAL_PIN_INTERRUPT INT3_vect #endif #elif SOFT_SERIAL_PIN == E6 #define SERIAL_PIN_DDR DDRE #define SERIAL_PIN_PORT PORTE #define SERIAL_PIN_INPUT PINE #define SERIAL_PIN_MASK _BV(PE6) #define EIMSK_BIT _BV(INT6) #define EICRx_BIT (~(_BV(ISC60) | _BV(ISC61))) #define SERIAL_PIN_INTERRUPT INT6_vect #else #error invalid SOFT_SERIAL_PIN value #endif #else #error serial.c now support ATmega32U4 only #endif //////////////// for backward compatibility //////////////////////////////// #ifndef SERIAL_USE_MULTI_TRANSACTION /* --- USE Simple API (OLD API, compatible with let's split serial.c) */ #if SERIAL_SLAVE_BUFFER_LENGTH > 0 @@ 43,56 97,118 @@ SSTD_t transactions[] = { }; void serial_master_init(void) { soft_serial_initiator_init(transactions); } { soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); } void serial_slave_init(void) { soft_serial_target_init(transactions); } { soft_serial_target_init(transactions, TID_LIMIT(transactions)); } // 0 => no error // 1 => slave did not respond // 2 => checksum error int serial_update_buffers() { return soft_serial_transaction(); } { int result; result = soft_serial_transaction(); return result; } #endif // Simple API (OLD API, compatible with let's split serial.c) #endif // end of Simple API (OLD API, compatible with let's split serial.c) //////////////////////////////////////////////////////////////////////////// #define ALWAYS_INLINE __attribute__((always_inline)) #define NO_INLINE __attribute__((noinline)) #define _delay_sub_us(x) __builtin_avr_delay_cycles(x) // Serial pulse period in microseconds. #define TID_SEND_ADJUST 14 // parity check #define ODD_PARITY 1 #define EVEN_PARITY 0 #define PARITY EVEN_PARITY #ifdef SERIAL_DELAY // custom setup in config.h // #define TID_SEND_ADJUST 2 // #define SERIAL_DELAY 6 // micro sec // #define READ_WRITE_START_ADJUST 30 // cycles // #define READ_WRITE_WIDTH_ADJUST 8 // cycles #else // ============ Standard setups ============ #ifndef SELECT_SOFT_SERIAL_SPEED #define SELECT_SOFT_SERIAL_SPEED 1 // 0: about 189kbps // 1: about 137kbps (default) // 2: about 75kbps // 3: about 39kbps // 4: about 26kbps // 5: about 20kbps #endif #define SELECT_SERIAL_SPEED 1 #if SELECT_SERIAL_SPEED == 0 #if __GNUC__ < 6 #define TID_SEND_ADJUST 14 #else #define TID_SEND_ADJUST 2 #endif #if SELECT_SOFT_SERIAL_SPEED == 0 // Very High speed #define SERIAL_DELAY 4 // micro sec #define READ_WRITE_START_ADJUST 33 // cycles #define READ_WRITE_WIDTH_ADJUST 3 // cycles #elif SELECT_SERIAL_SPEED == 1 #if __GNUC__ < 6 #define READ_WRITE_START_ADJUST 33 // cycles #define READ_WRITE_WIDTH_ADJUST 3 // cycles #else #define READ_WRITE_START_ADJUST 34 // cycles #define READ_WRITE_WIDTH_ADJUST 7 // cycles #endif #elif SELECT_SOFT_SERIAL_SPEED == 1 // High speed #define SERIAL_DELAY 6 // micro sec #define READ_WRITE_START_ADJUST 30 // cycles #define READ_WRITE_WIDTH_ADJUST 3 // cycles #elif SELECT_SERIAL_SPEED == 2 #if __GNUC__ < 6 #define READ_WRITE_START_ADJUST 30 // cycles #define READ_WRITE_WIDTH_ADJUST 3 // cycles #else #define READ_WRITE_START_ADJUST 33 // cycles #define READ_WRITE_WIDTH_ADJUST 7 // cycles #endif #elif SELECT_SOFT_SERIAL_SPEED == 2 // Middle speed #define SERIAL_DELAY 12 // micro sec #define READ_WRITE_START_ADJUST 30 // cycles #define READ_WRITE_WIDTH_ADJUST 3 // cycles #elif SELECT_SERIAL_SPEED == 3 #if __GNUC__ < 6 #define READ_WRITE_WIDTH_ADJUST 3 // cycles #else #define READ_WRITE_WIDTH_ADJUST 7 // cycles #endif #elif SELECT_SOFT_SERIAL_SPEED == 3 // Low speed #define SERIAL_DELAY 24 // micro sec #define READ_WRITE_START_ADJUST 30 // cycles #define READ_WRITE_WIDTH_ADJUST 3 // cycles #elif SELECT_SERIAL_SPEED == 4 #if __GNUC__ < 6 #define READ_WRITE_WIDTH_ADJUST 3 // cycles #else #define READ_WRITE_WIDTH_ADJUST 7 // cycles #endif #elif SELECT_SOFT_SERIAL_SPEED == 4 // Very Low speed #define SERIAL_DELAY 50 // micro sec #define SERIAL_DELAY 36 // micro sec #define READ_WRITE_START_ADJUST 30 // cycles #if __GNUC__ < 6 #define READ_WRITE_WIDTH_ADJUST 3 // cycles #else #define READ_WRITE_WIDTH_ADJUST 7 // cycles #endif #elif SELECT_SOFT_SERIAL_SPEED == 5 // Ultra Low speed #define SERIAL_DELAY 48 // micro sec #define READ_WRITE_START_ADJUST 30 // cycles #define READ_WRITE_WIDTH_ADJUST 3 // cycles #if __GNUC__ < 6 #define READ_WRITE_WIDTH_ADJUST 3 // cycles #else #define READ_WRITE_WIDTH_ADJUST 7 // cycles #endif #else #error Illegal Serial Speed #endif #error invalid SELECT_SOFT_SERIAL_SPEED value #endif /* SELECT_SOFT_SERIAL_SPEED */ #endif /* SERIAL_DELAY */ #define SERIAL_DELAY_HALF1 (SERIAL_DELAY/2) #define SERIAL_DELAY_HALF2 (SERIAL_DELAY - SERIAL_DELAY/2) @@ 106,17 222,21 @@ int serial_update_buffers() #endif static SSTD_t *Transaction_table = NULL; static uint8_t Transaction_table_size = 0; inline static void serial_delay(void) ALWAYS_INLINE; inline static void serial_delay(void) { _delay_us(SERIAL_DELAY); } inline static void serial_delay_half1(void) ALWAYS_INLINE; inline static void serial_delay_half1(void) { _delay_us(SERIAL_DELAY_HALF1); } inline static void serial_delay_half2(void) ALWAYS_INLINE; inline static void serial_delay_half2(void) { _delay_us(SERIAL_DELAY_HALF2); @@ 136,6 256,7 @@ void serial_input_with_pullup(void) { SERIAL_PIN_PORT |= SERIAL_PIN_MASK; } inline static uint8_t serial_read_pin(void) ALWAYS_INLINE; inline static uint8_t serial_read_pin(void) { return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK); @@ 153,30 274,28 @@ void serial_high(void) { SERIAL_PIN_PORT |= SERIAL_PIN_MASK; } void soft_serial_initiator_init(SSTD_t *sstd_table) void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size) { Transaction_table = sstd_table; Transaction_table_size = (uint8_t)sstd_table_size; serial_output(); serial_high(); } void soft_serial_target_init(SSTD_t *sstd_table) void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size) { Transaction_table = sstd_table; Transaction_table_size = (uint8_t)sstd_table_size; serial_input_with_pullup(); #if SERIAL_PIN_MASK == _BV(PD0) // Enable INT0 EIMSK |= _BV(INT0); // Trigger on falling edge of INT0 EICRA &= ~(_BV(ISC00) | _BV(ISC01)); #elif SERIAL_PIN_MASK == _BV(PD2) // Enable INT2 EIMSK |= _BV(INT2); // Trigger on falling edge of INT2 EICRA &= ~(_BV(ISC20) | _BV(ISC21)); // Enable INT0-INT3,INT6 EIMSK |= EIMSK_BIT; #if SERIAL_PIN_MASK == _BV(PE6) // Trigger on falling edge of INT6 EICRB &= EICRx_BIT; #else #error unknown SERIAL_PIN_MASK value // Trigger on falling edge of INT0-INT3 EICRA &= EICRx_BIT; #endif } @@ 192,7 311,7 @@ void sync_recv(void) { } // Used by the reciver to send a synchronization signal to the sender. static void sync_send(void)NO_INLINE; static void sync_send(void) NO_INLINE; static void sync_send(void) { serial_low(); @@ 206,12 325,12 @@ static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) { uint8_t byte, i, p, pb; _delay_sub_us(READ_WRITE_START_ADJUST); for( i = 0, byte = 0, p = 0; i < bit; i++ ) { for( i = 0, byte = 0, p = PARITY; i < bit; i++ ) { serial_delay_half1(); // read the middle of pulses if( serial_read_pin() ) { byte = (byte << 1) | 1; p ^= 1; byte = (byte << 1) | 1; p ^= 1; } else { byte = (byte << 1) | 0; p ^= 0; byte = (byte << 1) | 0; p ^= 0; } _delay_sub_us(READ_WRITE_WIDTH_ADJUST); serial_delay_half2(); @@ 231,13 350,13 @@ static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) { void serial_write_chunk(uint8_t data, uint8_t bit) NO_INLINE; void serial_write_chunk(uint8_t data, uint8_t bit) { uint8_t b, p; for( p = 0, b = 1<<(bit-1); b ; b >>= 1) { if(data & b) { serial_high(); p ^= 1; } else { serial_low(); p ^= 0; } serial_delay(); for( p = PARITY, b = 1<<(bit-1); b ; b >>= 1) { if(data & b) { serial_high(); p ^= 1; } else { serial_low(); p ^= 0; } serial_delay(); } /* send parity bit */ if(p & 1) { serial_high(); } @@ 289,6 408,13 @@ void change_reciver2sender(void) { serial_delay_half1(); //4 } static inline uint8_t nibble_bits_count(uint8_t bits) { bits = (bits & 0x5) + (bits >> 1 & 0x5); bits = (bits & 0x3) + (bits >> 2 & 0x3); return bits; } // interrupt handle to be used by the target device ISR(SERIAL_PIN_INTERRUPT) { @@ 298,12 424,15 @@ ISR(SERIAL_PIN_INTERRUPT) { SSTD_t *trans = Transaction_table; #else // recive transaction table index uint8_t tid; uint8_t tid, bits; uint8_t pecount = 0; sync_recv(); tid = serial_read_chunk(&pecount,4); if(pecount> 0) bits = serial_read_chunk(&pecount,7); tid = bits>>3; bits = (bits&7) != nibble_bits_count(tid); if( bits || pecount> 0 || tid > Transaction_table_size ) { return; } serial_delay_half1(); serial_high(); // response step1 low->high @@ 316,17 445,17 @@ ISR(SERIAL_PIN_INTERRUPT) { // target send phase if( trans->target2initiator_buffer_size > 0 ) serial_send_packet((uint8_t *)trans->target2initiator_buffer, trans->target2initiator_buffer_size); trans->target2initiator_buffer_size); // target switch to input change_sender2reciver(); // target recive phase if( trans->initiator2target_buffer_size > 0 ) { if (serial_recive_packet((uint8_t *)trans->initiator2target_buffer, trans->initiator2target_buffer_size) ) { *trans->status = TRANSACTION_ACCEPTED; trans->initiator2target_buffer_size) ) { *trans->status = TRANSACTION_ACCEPTED; } else { *trans->status = TRANSACTION_DATA_ERROR; *trans->status = TRANSACTION_DATA_ERROR; } } else { *trans->status = TRANSACTION_ACCEPTED; @@ 350,6 479,8 @@ int soft_serial_transaction(void) { SSTD_t *trans = Transaction_table; #else int soft_serial_transaction(int sstd_index) { if( sstd_index > Transaction_table_size ) return TRANSACTION_TYPE_ERROR; SSTD_t *trans = &Transaction_table[sstd_index]; #endif cli(); @@ 376,9 507,10 @@ int soft_serial_transaction(int sstd_index) { #else // send transaction table index int tid = (sstd_index<<3) | (7 & nibble_bits_count(sstd_index)); sync_send(); _delay_sub_us(TID_SEND_ADJUST); serial_write_chunk(sstd_index, 4); serial_write_chunk(tid, 7); serial_delay_half1(); // wait for the target response (step1 low->high) @@ 390,12 522,12 @@ int soft_serial_transaction(int sstd_index) { // check if the target is present (step2 high->low) for( int i = 0; serial_read_pin(); i++ ) { if (i > SLAVE_INT_ACK_WIDTH + 1) { // slave failed to pull the line low, assume not present serial_output(); serial_high(); *trans->status = TRANSACTION_NO_RESPONSE; sei(); return TRANSACTION_NO_RESPONSE; // slave failed to pull the line low, assume not present serial_output(); serial_high(); *trans->status = TRANSACTION_NO_RESPONSE; sei(); return TRANSACTION_NO_RESPONSE; } _delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT); } @@ 405,12 537,12 @@ int soft_serial_transaction(int sstd_index) { // if the target is present syncronize with it if( trans->target2initiator_buffer_size > 0 ) { if (!serial_recive_packet((uint8_t *)trans->target2initiator_buffer, trans->target2initiator_buffer_size) ) { serial_output(); serial_high(); *trans->status = TRANSACTION_DATA_ERROR; sei(); return TRANSACTION_DATA_ERROR; trans->target2initiator_buffer_size) ) { serial_output(); serial_high(); *trans->status = TRANSACTION_DATA_ERROR; sei(); return TRANSACTION_DATA_ERROR; } } @@ 420,7 552,7 @@ int soft_serial_transaction(int sstd_index) { // initiator send phase if( trans->initiator2target_buffer_size > 0 ) { serial_send_packet((uint8_t *)trans->initiator2target_buffer, trans->initiator2target_buffer_size); trans->initiator2target_buffer_size); } // always, release the line when not in use @@ 443,3 575,16 @@ int soft_serial_get_and_clean_status(int sstd_index) { #endif #endif // Helix serial.c history // 2018-1-29 fork from let's split and add PD2, modify sync_recv() (#2308, bceffdefc) // 2018-6-28 bug fix master to slave comm and speed up (#3255, 1038bbef4) // (adjusted with avr-gcc 4.9.2) // 2018-7-13 remove USE_SERIAL_PD2 macro (#3374, f30d6dd78) // (adjusted with avr-gcc 4.9.2) // 2018-8-11 add support multi-type transaction (#3608, feb5e4aae) // (adjusted with avr-gcc 4.9.2) // 2018-10-21 fix serial and RGB animation conflict (#4191, 4665e4fff) // (adjusted with avr-gcc 7.3.0) // 2018-10-28 re-adjust compiler depend value of delay (#4269, 8517f8a66) // (adjusted with avr-gcc 5.4.0, 7.3.0)
M keyboards/lily58/serial.h => keyboards/lily58/serial.h +13 -9
@@ 4,14 4,16 @@ #include <stdbool.h> // ///////////////////////////////////////////////////////////////// // Need Soft Serial defines in serial_config.h // Need Soft Serial defines in config.h // ///////////////////////////////////////////////////////////////// // ex. // #define SERIAL_PIN_DDR DDRD // #define SERIAL_PIN_PORT PORTD // #define SERIAL_PIN_INPUT PIND // #define SERIAL_PIN_MASK _BV(PD?) ?=0,2 // #define SERIAL_PIN_INTERRUPT INT?_vect ?=0,2 // #define SOFT_SERIAL_PIN ?? // ?? = D0,D1,D2,D3,E6 // OPTIONAL: #define SELECT_SOFT_SERIAL_SPEED ? // ? = 1,2,3,4,5 // // 1: about 137kbps (default) // // 2: about 75kbps // // 3: about 39kbps // // 4: about 26kbps // // 5: about 20kbps // // //// USE Simple API (OLD API, compatible with let's split serial.c) // ex. @@ 47,16 49,18 @@ typedef struct _SSTD_t { uint8_t target2initiator_buffer_size; uint8_t *target2initiator_buffer; } SSTD_t; #define TID_LIMIT( table ) (sizeof(table) / sizeof(SSTD_t)) // initiator is transaction start side void soft_serial_initiator_init(SSTD_t *sstd_table); void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size); // target is interrupt accept side void soft_serial_target_init(SSTD_t *sstd_table); void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size); // initiator resullt #define TRANSACTION_END 0 #define TRANSACTION_NO_RESPONSE 0x1 #define TRANSACTION_DATA_ERROR 0x2 #define TRANSACTION_TYPE_ERROR 0x4 #ifndef SERIAL_USE_MULTI_TRANSACTION int soft_serial_transaction(void); #else @@ 72,7 76,7 @@ int soft_serial_transaction(int sstd_index); // target: // TRANSACTION_DATA_ERROR // or TRANSACTION_ACCEPTED #define TRANSACTION_ACCEPTED 0x4 #define TRANSACTION_ACCEPTED 0x8 #ifdef SERIAL_USE_MULTI_TRANSACTION int soft_serial_get_and_clean_status(int sstd_index); #endif
M keyboards/lily58/serial_config.h => keyboards/lily58/serial_config.h +4 -8
@@ 1,8 1,4 @@ #define SERIAL_PIN_DDR DDRD #define SERIAL_PIN_PORT PORTD #define SERIAL_PIN_INPUT PIND #define SERIAL_PIN_MASK _BV(PD2) #define SERIAL_PIN_INTERRUPT INT2_vect #define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2 #define SERIAL_MASTER_BUFFER_LENGTH 1 \ No newline at end of file #ifndef SOFT_SERIAL_PIN #define SOFT_SERIAL_PIN D2 #define SERIAL_USE_MULTI_TRANSACTION #endif
A keyboards/lily58/ssd1306.c => keyboards/lily58/ssd1306.c +344 -0
@@ 0,0 1,344 @@ #ifdef SSD1306OLED #include "ssd1306.h" #include "i2c.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" static const unsigned char font[] PROGMEM; // 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 #define ScreenOffInterval 60000 /* milliseconds */ #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_write(SSD1306_ADDRESS)) { xprintf("failed to start write to %d\n", SSD1306_ADDRESS); goto done; } if (i2c_master_write(0x0 /* command byte follows */)) { print("failed to write control byte\n"); goto done; } if (i2c_master_write(cmd)) { xprintf("failed to write command %d\n", cmd); goto done; } res = true; done: i2c_master_stop(); return res; } // Write 2-byte command sequence. // Returns true on success static inline bool _send_cmd2(uint8_t cmd, uint8_t opr) { if (!_send_cmd1(cmd)) { return false; } return _send_cmd1(opr); } // Write 3-byte command sequence. // Returns true on success static inline bool _send_cmd3(uint8_t cmd, uint8_t opr1, uint8_t opr2) { if (!_send_cmd1(cmd)) { return false; } if (!_send_cmd1(opr1)) { return false; } return _send_cmd1(opr2); } #define send_cmd1(c) if (!_send_cmd1(c)) {goto done;} #define send_cmd2(c,o) if (!_send_cmd2(c,o)) {goto done;} #define send_cmd3(c,o1,o2) if (!_send_cmd3(c,o1,o2)) {goto done;} 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_cmd3(PageAddr, 0, (DisplayHeight / 8) - 1); send_cmd3(ColumnAddr, 0, DisplayWidth - 1); if (i2c_start_write(SSD1306_ADDRESS)) { goto done; } if (i2c_master_write(0x40)) { // Data mode goto done; } for (uint8_t row = 0; row < MatrixRows; ++row) { for (uint8_t col = 0; col < DisplayWidth; ++col) { i2c_master_write(0); } } display.dirty = false; done: i2c_master_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_master_init(); send_cmd1(DisplayOff); send_cmd2(SetDisplayClockDiv, 0x80); send_cmd2(SetMultiPlex, DisplayHeight - 1); send_cmd2(SetDisplayOffset, 0); send_cmd1(SetStartLine | 0x0); send_cmd2(SetChargePump, 0x14 /* Enable */); send_cmd2(SetMemoryMode, 0 /* horizontal addressing */); if(rotate){ // the following Flip the display orientation 180 degrees send_cmd1(SegRemap); send_cmd1(ComScanInc); }else{ // Flips the display orientation 0 degrees send_cmd1(SegRemap | 0x1); send_cmd1(ComScanDec); } send_cmd2(SetComPins, 0x2); send_cmd2(SetContrast, 0x8f); send_cmd2(SetPreCharge, 0xf1); send_cmd2(SetVComDetect, 0x40); send_cmd1(DisplayAllOnResume); send_cmd1(NormalDisplay); send_cmd1(DeActivateScroll); send_cmd1(DisplayOn); send_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, ' ', 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, ' '); } 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) { const char *end = data + strlen(data); while (data < end) { matrix_write_char(matrix, *data); ++data; } } void matrix_write_ln(struct CharacterMatrix *matrix, const char *data) { char data_ln[strlen(data)+2]; snprintf(data_ln, sizeof(data_ln), "%s\n", data); matrix_write(matrix, data_ln); } 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, ' ', 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_cmd3(PageAddr, 0, MatrixRows - 1); send_cmd3(ColumnAddr, 0, (MatrixCols * FontWidth) - 1); if (i2c_start_write(SSD1306_ADDRESS)) { goto done; } if (i2c_master_write(0x40)) { // 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_master_write(colBits); } // 1 column of space between chars (it's not included in the glyph) //i2c_master_write(0); } } matrix->dirty = false; done: i2c_master_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 (timer_elapsed(last_flush) > ScreenOffInterval) { iota_gfx_off(); } } bool process_record_gfx(uint16_t keycode, keyrecord_t *record) { force_dirty = true; return true; } #endif
A keyboards/lily58/ssd1306.h => keyboards/lily58/ssd1306.h +91 -0
@@ 0,0 1,91 @@ #pragma once #include <stdbool.h> #include <stdio.h> #include "pincontrol.h" #include "action.h" enum ssd1306_cmds { DisplayOff = 0xAE, DisplayOn = 0xAF, SetContrast = 0x81, DisplayAllOnResume = 0xA4, DisplayAllOn = 0xA5, NormalDisplay = 0xA6, InvertDisplay = 0xA7, SetDisplayOffset = 0xD3, SetComPins = 0xda, SetVComDetect = 0xdb, SetDisplayClockDiv = 0xD5, SetPreCharge = 0xd9, SetMultiPlex = 0xa8, SetLowColumn = 0x00, SetHighColumn = 0x10, SetStartLine = 0x40, SetMemoryMode = 0x20, ColumnAddr = 0x21, PageAddr = 0x22, ComScanInc = 0xc0, ComScanDec = 0xc8, SegRemap = 0xa0, SetChargePump = 0x8d, ExternalVcc = 0x01, SwitchCapVcc = 0x02, ActivateScroll = 0x2f, DeActivateScroll = 0x2e, SetVerticalScrollArea = 0xa3, RightHorizontalScroll = 0x26, LeftHorizontalScroll = 0x27, VerticalAndRightHorizontalScroll = 0x29, VerticalAndLeftHorizontalScroll = 0x2a, }; // Controls the SSD1306 128x32 OLED display via i2c #ifndef SSD1306_ADDRESS #define SSD1306_ADDRESS 0x3C #endif #define DisplayHeight 32 #define DisplayWidth 128 #define FontHeight 8 #define FontWidth 6 #define MatrixRows (DisplayHeight / FontHeight) #define MatrixCols (DisplayWidth / FontWidth) struct CharacterMatrix { uint8_t display[MatrixRows][MatrixCols]; uint8_t *cursor; bool dirty; }; struct CharacterMatrix display; bool iota_gfx_init(bool rotate); void iota_gfx_task(void); bool iota_gfx_off(void); bool iota_gfx_on(void); void iota_gfx_flush(void); void iota_gfx_write_char(uint8_t c); void iota_gfx_write(const char *data); void iota_gfx_write_P(const char *data); void iota_gfx_clear_screen(void); void iota_gfx_task_user(void); void matrix_clear(struct CharacterMatrix *matrix); void matrix_write_char_inner(struct CharacterMatrix *matrix, uint8_t c); void matrix_write_char(struct CharacterMatrix *matrix, uint8_t c); void matrix_write(struct CharacterMatrix *matrix, const char *data); void matrix_write_ln(struct CharacterMatrix *matrix, const char *data); void matrix_write_P(struct CharacterMatrix *matrix, const char *data); void matrix_render(struct CharacterMatrix *matrix); bool process_record_gfx(uint16_t keycode, keyrecord_t *record); \ No newline at end of file