mh
/
qmk_firmware
mirror of https://github.com/qmk/qmk_firmware/
1
0
Fork 0
Code Issues 0 Projects 0 Releases 1.6k Wiki Activity
Browse Source

Working keeb

pull/14484/head
Batuhan Başerdem 2 years ago
parent
368b78e740
commit
823923911d
10 changed files with 157 additions and 508 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -447
      layouts/community/split_3x6_3/bbaserdem/bb-crkbdarm-oled.c
  2. +0
    -19
      layouts/community/split_3x6_3/bbaserdem/bb-crkbdarm-oled.h
  3. +3
    -3
      layouts/community/split_3x6_3/bbaserdem/config.h
  4. +4
    -2
      layouts/community/split_3x6_3/bbaserdem/keymap.c
  5. +0
    -1
      layouts/community/split_3x6_3/bbaserdem/rules.mk
  6. +2
    -0
      users/bbaserdem/bb-encoder.c
  7. +0
    -3
      users/bbaserdem/bb-encoder.h
  8. +102
    -20
      users/bbaserdem/bbaserdem.c
  9. +43
    -10
      users/bbaserdem/bbaserdem.h
  10. +3
    -3
      users/bbaserdem/config.h

+ 0
- 447
layouts/community/split_3x6_3/bbaserdem/bb-crkbdarm-oled.c View File

@ -1,447 +0,0 @@
/*
Copyright 2019 Batuhan Başerdem <baserdem.batuhan@gmail.com> @bbaserdem
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "bb-oled.h"
#include "bb-crkbdarm-oled.h"
#ifdef ENCODER_ENABLE
#include "bb-encoder.h"
#endif
// PROGMEM images
// Naming scheme is <layer>_left/right{_keyboardLayout}{_modifiers}
static const char PROGMEM base0_L_dvor_nomod[4][42] = {
{ 0x00,0x00,0x73,0xe7,0x00,0x00,0x00,0x00,0x04,0x08,0x10,0x00,0x00,0x00,
0x00,0x0e,0x00,0x00,0x00,0x00,0x60,0xe0,0x00,0x00,0x00,0x00,0xc0,0xc0,
0x00,0x00,0x00,0xf8,0x90,0x88,0x88,0x70,0x00,0x78,0x80,0x80,0x40,0xf8
},{ 0x00,0x00,0xce,0x9c,0x00,0x00,0x00,0x00,0x00,0x80,0x60,0x18,0x00,0x00,
0x40,0x40,0x40,0x80,0x00,0x80,0x41,0x40,0x40,0x80,0x00,0x80,0x40,0x40,
0x40,0x80,0x00,0xc3,0x00,0x00,0x00,0xc0,0x00,0x00,0x42,0xd2,0x02,0x01
},{ 0x00,0x00,0x39,0x73,0x00,0x00,0x00,0xd8,0x06,0x01,0x00,0x00,0x00,0x02,
0x05,0x05,0x05,0x07,0x00,0x03,0x04,0x04,0x04,0x03,0x00,0x03,0x05,0x05,
0x85,0x05,0x00,0xc3,0x04,0x04,0x02,0x07,0x00,0x00,0x00,0x07,0x04,0x00
},{ 0x00,0x00,0xe7,0xce,0x00,0x00,0x00,0x00,0x03,0x0c,0x30,0xc0,0x00,0x00,
0xb6,0x76,0x00,0x00,0x00,0x1c,0x22,0x22,0x12,0xfe,0x00,0x00,0x80,0x82,
0x7e,0x00,0x00,0x3f,0x08,0x0c,0x12,0x20,0x00,0x22,0x14,0x08,0x14,0x22}};
static const char PROGMEM base0_L_dvor_shift[4][42] = {
{ 0x00,0x00,0x73,0xe7,0x00,0x00,0x00,0x20,0x10,0x20,0x40,0x20,0x00,0x00,
0x07,0x00,0x07,0x00,0x00,0x10,0x28,0x44,0x82,0x00,0x00,0x82,0x44,0x28,
0x10,0x00,0x00,0xfe,0x12,0x12,0x12,0x0c,0x00,0x06,0x08,0xf0,0x08,0x06
},{ 0x00,0x00,0xce,0x9c,0x00,0x00,0x00,0x00,0x00,0xf0,0x00,0x00,0x00,0xe0,
0x90,0x90,0x90,0xe0,0x00,0xe0,0x10,0x10,0x10,0xe0,0x00,0xf0,0x90,0x90,
0x90,0x10,0x00,0xf0,0x00,0x00,0x00,0xf0,0x00,0x00,0x10,0xf0,0x10,0x00
},{ 0x00,0x00,0x39,0x73,0x00,0x00,0x00,0x00,0x80,0x87,0x80,0x00,0x00,0x07,
0x00,0x00,0x00,0x07,0x00,0x03,0x84,0x84,0x84,0x03,0x00,0x07,0x04,0x04,
0x04,0x84,0x00,0x83,0x04,0x04,0x04,0x83,0x00,0x80,0x04,0x07,0x04,0x80
},{ 0x00,0x00,0xe7,0xce,0x00,0x00,0x00,0x01,0x00,0x28,0x04,0x03,0x00,0x00,
0x36,0x36,0x00,0x00,0x00,0x1f,0x20,0x28,0x10,0x6f,0x00,0x18,0x20,0x20,
0x20,0x1f,0x00,0x3f,0x04,0x0a,0x11,0x20,0x00,0x31,0x0a,0x04,0x0a,0x31}};
static const char PROGMEM base0_R_dvor_nomod[4][42] = {
{ 0x00,0xfc,0x12,0x12,0x00,0x00,0x70,0x88,0x88,0x48,0xf8,0x00,0x70,0x88,
0x88,0x88,0x88,0x00,0xf8,0x10,0x08,0x08,0x10,0x00,0x00,0x02,0x7e,0x80,
0x80,0x00,0x10,0x28,0x44,0x82,0x00,0x00,0x00,0x00,0xe7,0x73,0x00,0x00
},{ 0x00,0x80,0x80,0x80,0xf0,0x00,0xf0,0x02,0x82,0x82,0x01,0x00,0x00,0x80,
0xf0,0x80,0x80,0x00,0xc0,0x40,0x40,0x40,0x80,0x00,0x80,0x40,0x40,0x40,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x9c,0xce,0x00,0x00
},{ 0x83,0x04,0x04,0x02,0x07,0x00,0x07,0x01,0x00,0x00,0x07,0x00,0x00,0x00,
0x03,0x04,0x04,0x00,0x07,0x00,0x00,0x00,0x07,0x00,0x04,0x05,0x05,0x05,
0x02,0x00,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x73,0x39,0x00,0x00
},{ 0x3f,0x24,0x22,0x22,0x1c,0x00,0x3e,0x02,0x3e,0x02,0x3c,0x00,0x1e,0x20,
0x1c,0x20,0x1e,0x00,0x06,0x18,0x20,0x18,0x06,0x00,0x22,0x32,0x2a,0x26,
0x22,0x00,0x14,0x14,0x14,0x14,0x14,0x00,0x00,0x00,0xce,0xe7,0x00,0x00}};
static const char PROGMEM base0_R_dvor_shift[4][42] = {
{ 0xfe,0x12,0x12,0x12,0x02,0x00,0xfc,0x02,0x12,0x12,0xf4,0x00,0xfc,0x02,
0x02,0x02,0x84,0x00,0xfe,0x12,0x12,0x32,0xcc,0x00,0xfe,0x00,0x00,0x00,
0x00,0x00,0x04,0x88,0x50,0x20,0x00,0x00,0x00,0x00,0xe7,0x73,0x00,0x00
},{ 0xf1,0x10,0x10,0x10,0xe0,0x00,0xf0,0x81,0x81,0x81,0xf0,0x00,0x10,0x11,
0xf1,0x11,0x10,0x00,0xf1,0x60,0x80,0x00,0xf1,0x00,0x61,0x91,0x91,0x91,
0x21,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x9c,0xce,0x00,0x00
},{ 0x8f,0x88,0x88,0x88,0x07,0x00,0x8f,0x00,0x00,0x00,0x8f,0x00,0x80,0x00,
0x0f,0x00,0x80,0x00,0x8f,0x00,0x01,0x06,0x8f,0x00,0x84,0x88,0x88,0x88,
0x87,0x00,0x08,0x08,0x08,0x08,0x08,0x00,0x00,0x00,0x73,0x39,0x00,0x00
},{ 0x7f,0x44,0x44,0x44,0x3b,0x00,0x7f,0x01,0x06,0x01,0x7f,0x00,0x1f,0x60,
0x1c,0x60,0x1f,0x00,0x07,0x18,0x60,0x18,0x07,0x00,0x70,0x48,0x44,0x42,
0x41,0x00,0x08,0x08,0x3e,0x08,0x08,0x00,0x00,0x00,0xce,0xe7,0x00,0x00}};
static const char PROGMEM char1_L[4][42] = {
{ 0x00,0x00,0x73,0xe7,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xe2,0xae,0x42,0x00,0x00,0x20,0x44,0x40,0x4c,0x20,0x00,0x12,0xa4,0x88,
0xa4,0x12,0x00,0x08,0xf8,0x08,0xf8,0x08,0x00,0x78,0x80,0x80,0x80,0x78
},{ 0x00,0x00,0xce,0x9c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
0x41,0x40,0x41,0x80,0x00,0x80,0x40,0x40,0x40,0x80,0x00,0x81,0x40,0x40,
0x40,0x81,0x00,0xc0,0x00,0xc0,0x00,0xc0,0x00,0x00,0xc0,0x00,0x00,0x00
},{ 0x00,0x00,0x39,0x73,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x83,
0xc4,0x84,0xc2,0x07,0x00,0x03,0x04,0x04,0x04,0x03,0x00,0x02,0x85,0x05,
0x04,0x82,0x00,0x03,0x04,0x1f,0x04,0x03,0x00,0x80,0x83,0x84,0x82,0x80
},{ 0x00,0x00,0xe7,0xce,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7f,
0xc4,0x44,0xef,0x3b,0x00,0x3e,0x49,0x49,0x49,0x3e,0x00,0x02,0x7f,0x09,
0x09,0x78,0x00,0x3e,0x08,0x08,0x14,0x22,0x00,0x20,0x24,0x24,0x24,0x20}};
static const char PROGMEM char1_R[4][42] = {
{ 0x70,0x88,0xf0,0x88,0x70,0x00,0xfe,0x02,0x02,0x02,0x06,0x00,0x88,0x48,
0x70,0x90,0x88,0x00,0xf0,0x88,0x88,0x88,0x70,0x00,0xc0,0x30,0x0c,0x30,
0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe7,0x73,0x00,0x00
},{ 0xa0,0x50,0x53,0x90,0x20,0x00,0xc0,0x80,0x40,0x40,0x80,0x00,0x40,0x40,
0xc0,0x40,0x40,0x00,0xc3,0x00,0x00,0x00,0xc0,0x00,0x80,0x40,0xc0,0x40,
0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x9c,0xce,0x00,0x00
},{ 0x03,0x84,0x84,0x04,0x03,0x00,0x07,0x00,0x00,0x00,0x1f,0x00,0x00,0x80,
0x83,0x84,0x00,0x00,0x00,0x83,0x54,0x8b,0x00,0x00,0x83,0x84,0x84,0x83,
0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x73,0x39,0x00,0x00
},{ 0xff,0x24,0x24,0x27,0x18,0x00,0x7e,0x10,0x20,0x20,0x1e,0x00,0x2f,0x30,
0x00,0x30,0x2f,0x00,0xe0,0x38,0x25,0x38,0xe0,0x00,0x18,0x26,0xa1,0xa0,
0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xce,0xe7,0x00,0x00}};
static const char PROGMEM game2_L[4][42] = {
{ 0x00,0x00,0x73,0xe7,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7c,
0x82,0xa2,0x42,0xbc,0x00,0x3e,0xc0,0x30,0xc0,0x3e,0x00,0xfe,0x92,0x92,
0x92,0x82,0x00,0xfe,0x12,0x12,0x32,0xcc,0x00,0x02,0x02,0xfe,0x02,0x02
},{ 0x00,0x00,0xce,0x9c,0x00,0x00,0x00,0x40,0x40,0x40,0x40,0xe0,0x00,0xe0,
0x90,0x90,0x90,0xe1,0x00,0x60,0x90,0x90,0x90,0x20,0x00,0xf0,0x10,0x10,
0x10,0xe0,0x00,0xf0,0x90,0x90,0x90,0x10,0x00,0xe0,0x10,0x90,0x90,0xa0
},{ 0x00,0x00,0x39,0x73,0x00,0x00,0x00,0x07,0x02,0x02,0x02,0x02,0x00,0x87,
0x80,0x80,0x80,0x87,0x00,0x82,0x04,0x04,0x04,0x83,0x00,0x07,0x84,0x84,
0x84,0x03,0x00,0x87,0x00,0x00,0x00,0x80,0x00,0x83,0x84,0x84,0x84,0x03
},{ 0x00,0x00,0xe7,0xce,0x00,0x00,0x00,0x08,0x3c,0x02,0x3c,0x08,0x00,0x30,
0x28,0x24,0x22,0x21,0x00,0x31,0x0a,0x04,0x0a,0x31,0x00,0x1f,0x20,0x20,
0x20,0x11,0x00,0x03,0x0c,0x30,0x0c,0x03,0x00,0x3f,0x24,0x24,0x24,0x1b}};
static const char PROGMEM medi3_R[4][42] = {
{ 0xe0,0x00,0x38,0x00,0xe0,0x00,0x7f,0x02,0x9c,0x02,0x7f,0x00,0x7f,0x08,
0x88,0x08,0x7f,0x00,0x26,0x49,0xc9,0x49,0x32,0x00,0x07,0x18,0xa0,0x18,
0x07,0x00,0x00,0xe0,0x8f,0x02,0x31,0x49,0xfa,0x00,0xe7,0x73,0x00,0x00
},{ 0x00,0x01,0x01,0xf1,0x70,0x00,0xf0,0x81,0xc3,0xe1,0xf0,0x00,0x00,0x71,
0x03,0x71,0x00,0x00,0x00,0xc1,0xc3,0xc1,0x00,0x00,0xf0,0xe1,0xc3,0x81,
0xf0,0x00,0x00,0x03,0xe2,0x21,0xe0,0x21,0xc0,0x00,0x9c,0xce,0x00,0x00
},{ 0x0e,0x0a,0x0c,0x0f,0x00,0x00,0x07,0x00,0x01,0x03,0x87,0x00,0x00,0x1f,
0x0e,0x04,0x80,0x00,0x00,0x03,0x03,0x03,0x00,0x00,0x07,0x03,0x01,0x00,
0x87,0x00,0x00,0x40,0xa6,0xa8,0x08,0x04,0x8e,0x00,0x73,0x39,0x00,0x00
},{ 0x3e,0x31,0x01,0x31,0x3e,0x00,0x00,0x46,0x46,0x4f,0x1f,0x00,0x00,0xa6,
0x46,0xaf,0x1f,0x00,0x28,0x2c,0x2e,0x2c,0x28,0x00,0x00,0x46,0xe6,0x4f,
0x1f,0x00,0x00,0x02,0x72,0x8a,0x89,0x00,0x1e,0x00,0xce,0xe7,0x00,0x00}};
static const char PROGMEM navi4_R[4][42] = {
{ 0xe0,0x10,0x54,0x38,0x10,0x00,0xfc,0x24,0x24,0x24,0x18,0x00,0x0c,0x10,
0xe0,0x10,0x0c,0x00,0x8c,0x50,0x20,0x50,0x8c,0x00,0xc0,0xbe,0xa2,0xbe,
0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe7,0x73,0x00,0x00
},{ 0x80,0xc1,0xa1,0x81,0x00,0x00,0x01,0x80,0x40,0x20,0x00,0x00,0x00,0x00,
0xf1,0x00,0x00,0x00,0x41,0x20,0xd0,0x20,0x41,0x00,0x01,0x21,0x41,0x81,
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x9c,0xce,0x00,0x00
},{ 0x00,0x49,0x4a,0x48,0x87,0x00,0x81,0x82,0x85,0x89,0x01,0x00,0x01,0x02,
0x85,0x02,0x01,0x00,0x40,0x40,0x47,0x40,0x40,0x00,0x81,0x09,0x05,0x02,
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x73,0x39,0x00,0x00
},{ 0x12,0x65,0x85,0x65,0x17,0x00,0x07,0x01,0x06,0x18,0x60,0x00,0x88,0x90,
0xaf,0x90,0x88,0x00,0x04,0x02,0x7d,0x02,0x04,0x00,0x01,0x46,0x58,0x60,
0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xce,0xe7,0x00,0x00}};
static const char PROGMEM symb5_R_dvor[4][42] = {
{ 0x00,0x02,0x04,0x08,0x00,0x00,0x20,0x20,0xdc,0x02,0x02,0x00,0x02,0x02,
0xdc,0x20,0x20,0x00,0x00,0xc0,0x30,0x0c,0x03,0x00,0x50,0x50,0x50,0x50,
0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe7,0x73,0x00,0x00
},{ 0x00,0x80,0x00,0x00,0x00,0x00,0x00,0xf0,0x11,0x12,0x02,0x00,0x02,0x12,
0x11,0xf0,0x00,0x00,0x43,0x20,0x20,0x20,0xc0,0x00,0x00,0x00,0xc0,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x9c,0xce,0x00,0x00
},{ 0x01,0x80,0x41,0x82,0x01,0x00,0x00,0x1f,0x10,0x90,0x00,0x00,0x00,0x90,
0x10,0x1f,0x00,0x00,0xc0,0x00,0x14,0x03,0x00,0x00,0x01,0x01,0x87,0x01,
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x73,0x39,0x00,0x00
},{ 0x22,0xf3,0x0a,0xf3,0x22,0x00,0x00,0x1c,0x63,0x80,0x00,0x00,0x00,0x80,
0x63,0x1c,0x00,0x00,0x00,0x03,0x0c,0x30,0xc0,0x00,0x00,0x00,0x7f,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xce,0xe7,0x00,0x00}};
static const char PROGMEM numb6_L_dvor_nomod[4][42] = {
{ 0x00,0x00,0x73,0xe7,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,
0x50,0x88,0x04,0x00,0x00,0x04,0x04,0xc4,0x34,0x0c,0x00,0xd8,0x24,0x24,
0x24,0xd8,0x00,0x18,0x24,0x24,0x24,0xf8,0x00,0xf8,0x44,0x24,0x14,0xf8
},{ 0x00,0x00,0xce,0x9c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x80,0x41,0xe0,0x00,0x00,0xe0,0xa1,0xa1,
0xa1,0x20,0x00,0xc0,0xa1,0xa1,0xa1,0x00,0x00,0x00,0x01,0x01,0x01,0x00
},{ 0x00,0x00,0x39,0x73,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,
0x08,0x08,0x08,0x08,0x00,0x03,0x02,0x02,0x0f,0x02,0x00,0x04,0x08,0x08,
0x08,0x07,0x00,0x07,0x08,0x08,0x08,0x07,0x00,0x01,0x01,0x01,0x01,0x00
},{ 0x00,0x00,0xe7,0xce,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x41,
0x22,0x14,0x08,0x00,0x00,0x00,0x04,0x02,0x7f,0x00,0x00,0x42,0x61,0x51,
0x49,0x46,0x00,0x22,0x41,0x49,0x49,0x36,0x00,0x5e,0x61,0x01,0x61,0x5e}};
static const char PROGMEM numb6_L_dvor_shift[4][42] = {
{ 0x00,0x00,0x73,0xe7,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0xd8,0x24,0x54,0x88,0x40,0x00,0x50,0x20,0xf8,
0x20,0x50,0x00,0x00,0x38,0xc6,0x01,0x00,0x00,0x00,0x01,0xc6,0x38,0x00
},{ 0x00,0x00,0xce,0x9c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x60,0x91,0xf9,0x90,0x21,0x00,0x20,0x50,0x20,
0x80,0x60,0x00,0x40,0x20,0x10,0x21,0x40,0x00,0x00,0x01,0x00,0x00,0x00
},{ 0x00,0x00,0x39,0x73,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x02,0x04,0x8f,0x04,0x03,0x00,0x0c,0x02,0x09,
0x14,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
},{ 0x00,0x00,0xe7,0xce,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5f,0x00,0x00,0x00,0x3e,0x41,0x5d,
0x55,0x5e,0x00,0x14,0x7f,0x14,0x7f,0x14,0x00,0x00,0x00,0x00,0x00,0x00}};
static const char PROGMEM func7_L[4][42] = {
{ 0x00,0x00,0x73,0xe7,0x00,0x00,0xff,0x09,0xe9,0xc9,0x01,0x00,0xe0,0x00,
0x10,0x08,0xfc,0x00,0x00,0x08,0x84,0x44,0x24,0x18,0x00,0x88,0x04,0x24,
0x24,0xd8,0x00,0x60,0x50,0x48,0xfc,0x40,0x00,0x70,0x80,0x9c,0x80,0x70
},{ 0x00,0x00,0xce,0x9c,0x00,0xf0,0x00,0x00,0x9f,0x00,0x03,0x0c,0x1f,0x00,
0xe0,0xa0,0xa1,0x20,0x00,0xc1,0xa1,0xa1,0xa1,0x01,0x00,0x20,0x21,0x21,
0xa1,0x60,0x00,0xc0,0x20,0x20,0x21,0xc0,0x00,0x40,0xe0,0x50,0x40,0x80
},{ 0x00,0x00,0x39,0x73,0x00,0xef,0x02,0x83,0xe4,0x00,0x0e,0x15,0x16,0x00,
0x04,0x08,0x08,0x07,0x00,0x07,0x48,0xc8,0x08,0x07,0x00,0x00,0x40,0xce,
0x01,0x00,0x00,0x06,0x49,0xc9,0x09,0x06,0x00,0x06,0x08,0x49,0x08,0x07
},{ 0x00,0x00,0xe7,0xce,0x00,0x00,0x05,0x04,0x03,0x90,0xa8,0xa8,0x40,0x06,
0x49,0x49,0x49,0x3e,0x00,0x7c,0xa2,0x93,0x8a,0x7c,0x00,0x00,0x08,0x07,
0xfe,0x00,0x00,0x84,0xc2,0xa3,0x92,0x8c,0x00,0x70,0x38,0x0d,0x38,0x70}};
static const char PROGMEM mous8_L[4][42] = {
{ 0x00,0x00,0x73,0xe7,0x00,0x3c,0x84,0xbc,0x84,0x38,0x00,0x00,0x00,0x10,
0x28,0x92,0xc5,0x82,0x00,0xfe,0x1f,0x1f,0x01,0xfe,0x00,0xfe,0x01,0x19,
0x01,0xfe,0x00,0xfe,0x01,0x1f,0x1f,0xfe,0x00,0x10,0x38,0x92,0xc7,0x82
},{ 0x00,0x00,0xce,0x9c,0x00,0xe7,0x08,0x08,0x08,0xe7,0x00,0x00,0x00,0x00,
0x00,0x80,0x01,0x00,0x00,0x01,0x01,0x81,0x01,0x01,0x00,0x01,0x01,0x81,
0x01,0x01,0x00,0x01,0x01,0x81,0x01,0x01,0x00,0x60,0x50,0xf8,0x41,0x00
},{ 0x00,0x00,0x39,0x73,0x00,0x91,0xaa,0xaa,0xa9,0x43,0x00,0x00,0x00,0x02,
0x07,0xca,0x02,0x02,0x00,0x02,0x01,0xcf,0x01,0x02,0x00,0x02,0x04,0x0f,
0x04,0x02,0x00,0x02,0x02,0xca,0x07,0x02,0x00,0xdc,0x58,0x5c,0x18,0x1f
},{ 0x00,0x00,0xe7,0xce,0x00,0x1c,0x2a,0x2a,0x2a,0x2c,0x00,0x00,0x00,0x0c,
0x33,0xc0,0x00,0x00,0x00,0x0c,0x03,0x00,0x03,0x0c,0x00,0x0c,0x30,0xc0,
0x30,0x0c,0x00,0x00,0x00,0xc0,0x33,0x0c,0x00,0xe5,0xc9,0xe6,0xc0,0xf8}};
static const char PROGMEM musi9_L[4][42] = {
{ 0x00,0x00,0x73,0xe7,0x00,0x00,0x00,0x00,0x00,0xfe,0x04,0x18,0x04,0xfe,
0x00,0x00,0xfe,0x00,0x00,0x00,0xfe,0x00,0x8c,0x12,0x12,0x12,0xe4,0x00,
0x00,0x02,0xfe,0x02,0x00,0x00,0xfc,0x02,0x02,0x02,0x84,0x00,0x00,0x00
},{ 0x00,0x00,0xce,0x9c,0x00,0x00,0xc0,0xe0,0xf0,0xf9,0xf8,0xf8,0xf8,0xf9,
0xf0,0xe0,0xc0,0x01,0x01,0x01,0x00,0xf0,0xf0,0x01,0x01,0xf1,0xf0,0x00,
0x00,0x01,0x01,0x01,0x00,0x00,0xf8,0xf1,0xe1,0xc1,0x80,0x00,0x00,0x00
},{ 0x00,0x00,0x39,0x73,0x00,0x00,0x07,0x0f,0x1f,0x3f,0x3f,0x3f,0x3f,0x3f,
0x1f,0x0f,0x07,0x00,0x00,0x00,0x00,0x1f,0x1f,0x00,0x00,0x1f,0x1f,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00,0x00
},{ 0x00,0x00,0xe7,0xce,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf8,0x08,
0xf8,0x08,0xf0,0x00,0x70,0x88,0x88,0x88,0x70,0x00,0x70,0x88,0x88,0x48,
0xff,0x00,0x70,0xa8,0xa8,0xa8,0xb0,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
static const char PROGMEM musi9_R[4][42] = {
{ 0x00,0x00,0x00,0xfe,0x04,0x18,0x04,0xfe,0x00,0x00,0xfe,0x00,0x00,0x00,
0xfe,0x00,0x8c,0x12,0x12,0x12,0xe4,0x00,0x00,0x02,0xfe,0x02,0x00,0x00,
0xfc,0x02,0x02,0x02,0x84,0x00,0x00,0x00,0x00,0x00,0xe7,0x73,0x00,0x00
},{ 0x00,0x00,0x00,0x81,0x60,0x10,0x60,0x81,0x60,0x10,0x00,0x01,0x01,0x01,
0xe0,0xe0,0x60,0x61,0x61,0x61,0x60,0xf8,0x70,0x21,0x01,0x01,0xc0,0xe0,
0x60,0x01,0xf9,0xf9,0x00,0x60,0xe0,0xc0,0x00,0x00,0x9c,0xce,0x00,0x00
},{ 0x18,0x24,0x4b,0x48,0x48,0x4c,0x4b,0x48,0x4b,0x2c,0x18,0x00,0x00,0x00,
0x4f,0xe7,0xf0,0x60,0x60,0x60,0x60,0x60,0x7e,0x7f,0x00,0x0f,0x3f,0x70,
0x60,0xc0,0xc1,0xc1,0xc0,0x60,0x70,0x3f,0x0f,0x00,0x73,0x39,0x00,0x00
},{ 0x00,0x00,0x00,0x00,0x00,0x00,0xf8,0x08,0xf8,0x08,0xf0,0x00,0x70,0x88,
0x88,0x88,0x71,0x00,0x70,0x88,0x88,0x48,0xff,0x00,0x70,0xa8,0xa8,0xa8,
0xb0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xce,0xe7,0x00,0x00}};
// Helper function that draws these images
void draw_image(uint8_t row, uint8_t col, const char image[4][42]) {
// Draw this image iteratively
for (int i = 0; i < 4; i++) {
oled_set_cursor(col, row + i);
oled_write_raw_P(image[i], 42);
}
}
// Custom 2 character wide icons
static const char PROGMEM mod_meta[12] = {0x00,0x01,0x01,0x01,0x01,0x06,0x18,0x60,0x81,0x81,0x81,0x81};
static const char PROGMEM mod_altL[12] = {0x00,0x80,0x80,0x80,0x40,0x20,0x10,0x08,0x84,0x95,0x8e,0x84};
static const char PROGMEM mod_altR[12] = {0x00,0x86,0x8f,0x8f,0x46,0x20,0x10,0x08,0x84,0x95,0x8e,0x84};
static const char PROGMEM mod_ctrl[12] = {0x00,0x00,0xbd,0x42,0xa5,0x99,0x99,0xa5,0x42,0xbd,0x00,0x00};
static const char PROGMEM mod_shft[12] = {0x00,0x20,0x30,0x28,0xe4,0x02,0x01,0x02,0xe4,0x28,0x30,0x20};
static const char PROGMEM rgb_enab[12] = {0x08,0x81,0x3c,0x42,0x99,0xbd,0xbd,0x99,0x42,0x3c,0x81,0x10};
static const char PROGMEM rgb_disa[12] = {0x08,0x81,0x3c,0x42,0x81,0x81,0x81,0x81,0x42,0x3c,0x81,0x10};
// Write modifiers to the screen
void render_modifiers(uint8_t row, uint8_t col, uint8_t mods) {
// Looks like Mods: <OS> <Alt/Gr> <Ctrl> <Shift>
oled_set_cursor(col, row);
oled_write("Mods: ", false);
// Meta
if (mods & MOD_MASK_GUI) {
oled_write_raw_P(mod_meta, 12);
oled_set_cursor(col + 8, row);
} else {
oled_write(" ", false);
}
// Alt(Gr)
if (mods & MOD_BIT(KC_RALT)) {
oled_write_raw_P(mod_altR, 12);
oled_set_cursor(col + 10, row);
} else if (mods & MOD_MASK_ALT) {
oled_write_raw_P(mod_altL, 12);
oled_set_cursor(col + 10, row);
} else {
oled_write(" ", false);
}
// Ctrl
if (mods & MOD_MASK_CTRL) {
oled_write_raw_P(mod_ctrl, 12);
oled_set_cursor(col + 12, row);
} else {
oled_write(" ", false);
}
// Shift
if (mods & MOD_MASK_SHIFT) {
oled_write_raw_P(mod_shft, 12);
oled_set_cursor(col + 14, row);
} else {
oled_write(" ", false);
}
}
// Renders the encoder state, 14 characters
void render_encoder(uint8_t row, uint8_t col, uint8_t index, uint8_t layer) {
static char encoder_temp9[9] = {0};
oled_set_cursor(col, row);
#if defined ENCODER_ENABLE
oled_write("Enc: ", false);
encoder_state_string8(index, layer, encoder_temp9);
oled_write(encoder_temp9, false);
#else
oled_set_cursor(col, row);
oled_write("No enc. avail.", false);
#endif
}
// Writes WPM on the screen
void render_wpm(uint8_t row, uint8_t col) {
// Renders the WPM, 14 characters
static char wpm_temp4[4] = {0};
oled_set_cursor(col, row);
#if defined WPM_ENABLE
oled_write("WPM: ", false);
itoa(get_current_wpm(), wpm_temp4, 10);
oled_write(wpm_temp4, false);
oled_write(" ", false);
#else
oled_write("WPM not avail.", false);
#endif
}
// Writes the currently used OLED display layout
void render_keymap(uint8_t row, uint8_t col) {
// Render the oled layout
oled_set_cursor(col, row);
oled_write("Layout: DVORAK", false);
}
// Draws the image of the currently used layout
void render_layout(uint8_t row, uint8_t col, uint8_t mods, bool isLeft) {
// Render the requested image on the given column and row
// Don't grab highest layer; instead compare from top to bottom.
// Highest layer might be on the other side
if (isLeft) {
if (layer_state_cmp(layer_state, _MUSI)) {
draw_image(row, col, musi9_L);
} else if (layer_state_cmp(layer_state, _MOUS)) {
draw_image(row, col, mous8_L);
} else if (layer_state_cmp(layer_state, _FUNC)) {
draw_image(row, col, func7_L);
} else if (layer_state_cmp(layer_state, _NUMB)) {
if (mods & MOD_MASK_SHIFT) {
draw_image(row, col, numb6_L_dvor_shift);
} else {
draw_image(row, col, numb6_L_dvor_nomod);
}
} else if (layer_state_cmp(layer_state, _GAME)) {
draw_image(row, col, game2_L);
} else if (layer_state_cmp(layer_state, _CHAR)) {
draw_image(row, col, char1_L);
} else {
if (mods & MOD_MASK_SHIFT) {
draw_image(row, col, base0_L_dvor_shift);
} else {
draw_image(row, col, base0_L_dvor_nomod);
}
}
} else {
if (layer_state_cmp(layer_state, _MUSI)) {
draw_image(row, col, musi9_R);
} else if (layer_state_cmp(layer_state, _SYMB)) {
draw_image(row, col, symb5_R_dvor);
} else if (layer_state_cmp(layer_state, _NAVI)) {
draw_image(row, col, navi4_R);
} else if (layer_state_cmp(layer_state, _MEDI)) {
draw_image(row, col, medi3_R);
} else if (layer_state_cmp(layer_state, _CHAR)) {
draw_image(row, col, char1_R);
} else {
if (mods & MOD_MASK_SHIFT) {
draw_image(row, col, base0_R_dvor_shift);
} else {
draw_image(row, col, base0_R_dvor_nomod);
}
}
}
}
// Render the RGB state on the given column and row
void render_rgb(uint8_t row, uint8_t col) {
static char rgb_temp4[4] = {0};
static char rgb_temp3[3] = {0};
oled_set_cursor(col, row);
#if defined RGB_MATRIX_ENABLE
if (rgb_matrix_is_enabled()) {
oled_write_raw_P(rgb_enab, 12);
} else {
oled_write_raw_P(rgb_disa, 12);
}
oled_set_cursor(col + 2, row);
oled_write(" hue sat val", false);
oled_set_cursor(col, row + 1);
itoa(rgb_matrix_get_mode(), rgb_temp3, 10);
oled_write(rgb_temp3, false);
oled_write(" ", false);
itoa(rgb_matrix_get_hue(), rgb_temp4, 10);
oled_write(rgb_temp4, false);
oled_write(" ", false);
itoa(rgb_matrix_get_sat(), rgb_temp4, 10);
oled_write(rgb_temp4, false);
oled_write(" ", false);
itoa(rgb_matrix_get_val(), rgb_temp4, 10);
oled_write(rgb_temp4, false);
#else
oled_write("-RGB disabled-", false);
#endif
}
void render_status_left(void) {
// Left side looks like this on the left half
// (Should be 14 characters per line)
// Mods: <OS> <Alt/Gr> <Ctrl> <Shift>
// Enc: <8 len str>
// Wpm: <wpm here>
// Layout: <dvorak/qwerty/tur. f>
// Right half is whatever layer image needs be
uint8_t this_mod = get_mods();
uint8_t this_layer = get_highest_layer(layer_state);
// MODIFIERS
render_modifiers(0, 0, this_mod);
// Encoders
render_encoder(1, 0, 0, this_layer);
// WPM text
render_wpm(2, 0);
// Visual layout
render_keymap(3, 0);
// Draw the image after 14'th character
render_layout(0, 14, this_mod, true);
}
void render_status_right(void) {
// Right half is whatever layer image needs be on the left
// Right side looks like this on the right half
// (Should be after the 12'th character; max 14 characters per line)
// Mods: <OS> <Alt/Gr> <Ctrl> <Shift>
// Enc: <8 len str>
// Wpm: <wpm here>
// Layout: <dvorak/qwerty/tur. f>
uint8_t this_mod = get_mods();
uint8_t this_layer = get_highest_layer(layer_state);
// Draw the image
render_layout(0, 0, this_mod, false);
// Modifiers
render_modifiers(0, 7, this_mod);
// Encoder
render_encoder(1, 7, 1, this_layer);
// RGB State
render_rgb(2, 7);
}

+ 0
- 19
layouts/community/split_3x6_3/bbaserdem/bb-crkbdarm-oled.h View File

@ -1,19 +0,0 @@
/*
Copyright 2019 Batuhan Başerdem <baserdem.batuhan@gmail.com> @bbaserdem
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "bbaserdem.h"
// These are protorne specific functions to be called for drawing
void render_status_left(void);
void render_status_right(void);

+ 3
- 3
layouts/community/split_3x6_3/bbaserdem/config.h View File

@ -39,9 +39,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
# define SPLIT_WPM_ENABLE
// Add state info transmission
#define SPLIT_LAYER_STATE_ENABLE
#define SPLIT_MODS_ENABLE
#define SPLIT_WPM_ENABLE
# define SPLIT_LAYER_STATE_ENABLE
# define SPLIT_MODS_ENABLE
# define SPLIT_WPM_ENABLE
// Audio output on pin A5 (actualy will be output on B1 using keymap init)
# ifdef AUDIO_ENABLE


+ 4
- 2
layouts/community/split_3x6_3/bbaserdem/keymap.c View File

@ -12,7 +12,9 @@ You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "bbaserdem.h"
#include "bb-crkbdarm-oled.h"
#ifdef KEYBOARD_crkbd_rev1
# include "bb-oled-extra.h"
#endif // KEYBOARD_crkbd_rev1
#ifdef KEYBOARD_crkbd_rev1
# include "bb-oled-extra.h"
@ -188,12 +190,12 @@ oled_rotation_t oled_init_user(oled_rotation_t rotation) {
return rotation;
}
#ifdef OLED_ENABLE
// Flip the display on the right half
oled_rotation_t oled_init_user(oled_rotation_t rotation) {
if (!is_keyboard_left()) {
return OLED_ROTATION_180;
}
return rotation;
}


+ 0
- 1
layouts/community/split_3x6_3/bbaserdem/rules.mk View File

@ -40,5 +40,4 @@ ifneq (,$(findstring crkbd/rev1,$(KEYBOARD)))
# BOOTMAGIC_ENABLE = lite
# LTO_ENABLE = yes
# PIMORONI_TRACKBALL = no
SRC += bb-crkbdarm-oled.c
endif

+ 2
- 0
users/bbaserdem/bb-encoder.c View File

@ -347,6 +347,8 @@ bool process_record_encoder(uint16_t keycode, keyrecord_t *record) {
} else {
userspace_config.e1point = (userspace_config.e1point + 1) % 4;
}
userspace_config.encoder[encoder_index].point =
(userspace_config.encoder[encoder_index].point + 1) % 4;
break;
# endif // MOUSEKEY_ENABLE
default:


+ 0
- 3
users/bbaserdem/bb-encoder.h View File

@ -16,9 +16,6 @@
*/
#pragma once
#include "bbaserdem.h"
#ifdef VELOCIKEY_ENABLE
#include "velocikey.h"
#endif
// Hook to encoder stuff
bool encoder_update_user(uint8_t index, bool clockwise);


+ 102
- 20
users/bbaserdem/bbaserdem.c View File

@ -14,6 +14,72 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "bbaserdem.h"
// Language imports
#include <sendstring_dvorak.h>
// Need memcpy and memcmp from string.h along with transfer stuff
#ifdef SPLIT_KEYBOARD
#include "transactions.h"
#include <string.h>
#endif // SPLIT_KEYBOARD
/*-------------------------*\
|*-----KEYBOARD CONFIG-----*|
\*-------------------------*/
userspace_config_t userspace_config;
/*---------------------------------*\
|*----SPLIT KEYBOARD TRANSPORT-----*|
\*---------------------------------*/
#ifdef SPLIT_KEYBOARD
userspace_config_t transport_userspace_config;
// Translate the RPC data to the local variable
void userspace_config_sync(uint8_t in_buflen, const void* in_data, uint8_t out_buflen, void* out_data) {
// Copy incoming data to local variable
if (in_buflen == sizeof(transport_userspace_config)) {
memcpy(&transport_userspace_config, in_data, in_buflen);
}
// There is no data to send back; so no output handling
}
// Either send or receive the correct data
void userspace_config_transport_update(void) {
if (is_keyboard_master()) {
// If we are the main device; we want to send info.
transport_userspace_config.raw = userspace_config.raw;
} else {
// If we are the secondary device; we want to receive info.
userspace_config.raw = transport_userspace_config.raw;
}
}
// Initiate the protocol on sync
void userspace_config_transport_sync(void) {
if (is_keyboard_master()) {
// Keep track of the last state
static userspace_config_t last_userspace_config;
static uint32_t last_sync;
bool needs_sync = false;
// Check if the state values are different
if (memcmp(&transport_userspace_config, &last_userspace_config, sizeof(transport_userspace_config))) {
needs_sync = true;
memcpy(&last_userspace_config, &transport_userspace_config, sizeof(transport_userspace_config));
}
// Send to secondary every 500ms regardless of state change
if (timer_elapsed32(last_sync) > 500) {
needs_sync = true;
}
// Perform the sync if requested
if (needs_sync) {
if (transaction_rpc_send(RPC_ID_USERSPACE_SYNC, sizeof(transport_userspace_config), &transport_userspace_config)) {
last_sync = timer_read32();
}
needs_sync = false;
}
}
}
#endif // SPLIT_KEYBOARD
/*---------------------------*\
|*-----KEYBOARD PRE INIT-----*|
@ -50,30 +116,54 @@ __attribute__ ((weak)) void keyboard_post_init_user(void) {
// Fix beginning base layer, in case some other firmware was flashed
// set_single_persistent_default_layer(_BASE);
// Initialize userspace config
userspace_config.layout = 0;
// Split keyboard halves communication
# ifdef SPLIT_KEYBOARD
transaction_register_rpc(RPC_ID_USERSPACE_SYNC, userspace_config_sync);
# endif // SPLIT_KEYBOARD
// Backlight LED
#ifdef BACKLIGHT_ENABLE
# ifdef BACKLIGHT_ENABLE
keyboard_post_init_backlight();
#endif
# endif
// RGB underglow
#ifdef RGBLIGHT_ENABLE
# ifdef RGBLIGHT_ENABLE
keyboard_post_init_underglow();
#endif
# endif
// Encoders
#ifdef ENCODER_ENABLE
# ifdef ENCODER_ENABLE
keyboard_post_init_encoder();
#endif
# endif
// Unicode mode
#ifdef UNICODEMAP_ENABLE
# ifdef UNICODEMAP_ENABLE
set_unicode_input_mode(UC_LNX);
#endif
# endif
// Keymap specific stuff
keyboard_post_init_keymap();
}
/*---------------------------*\
|*-----HOUSEKEEPING TASK-----*|
\*---------------------------*/
/* I have no idea what this does
*/
__attribute__ ((weak)) void housekeeping_task_keymap(void) {}
void housekeeping_task_user(void) {
# ifdef SPLIT_KEYBOARD
userspace_config_transport_update();
userspace_config_transport_sync();
# endif // SPLIT_KEYBOARD
// Hook to keymap code
housekeeping_task_keymap();
}
/*-----------------------*\
|*-----EECONFIG INIT-----*|
\*-----------------------*/
@ -97,24 +187,16 @@ __attribute__ ((weak))
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
return true;
}
__attribute__ ((weak))
bool process_record_audio(uint16_t keycode, keyrecord_t *record) {
return true;
}
__attribute__ ((weak))
bool process_record_macro(uint16_t keycode, keyrecord_t *record) {
return true;
}
__attribute__ ((weak))
bool process_record_encoder(uint16_t keycode, keyrecord_t *record) {
return true;
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// Return after running through all individual hooks
return
process_record_keymap(keycode, record) &&
# ifdef AUDIO_ENABLE
process_record_audio(keycode, record) &&
# endif // AUDIO_ENABLE
# ifdef ENCODER_ENABLE
process_record_encoder(keycode, record) &&
# endif // ENCODER_ENABLE
process_record_macro(keycode, record);
}


+ 43
- 10
users/bbaserdem/bbaserdem.h View File

@ -45,6 +45,29 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "bb-oled.h"
#endif
// Structure to keep runtime info on encoder state
typedef union {
uint16_t raw;
struct {
uint8_t base :4; // (9) The encoder state on most layers; regular function
uint8_t rgb :4; // (5) The encoder state on media layer; controls light
uint8_t point :4; // (4) The encoder state on mouse layer; moves pointer
uint8_t :4; // Padding
};
} encoder_state_t;
// Structure to contain userspace config in total
typedef union {
uint64_t raw;
struct {
encoder_state_t encoder[2];
uint8_t layout;
};
} userspace_config_t;
// Broadcast us to everyone else
extern userspace_config_t userspace_config;
// Function definitions that can be accessed through specific keymaps
// Runs before all initialization
void keyboard_pre_init_keymap(void);
@ -62,6 +85,8 @@ void matrix_scan_keymap(void);
layer_state_t layer_state_set_keymap(layer_state_t state);
// This code runs when the default layer changes
layer_state_t default_layer_state_set_keymap (layer_state_t state);
// Some code
void housekeeping_task_user(void);
// This code runs to set LED states
void led_set_keymap(uint8_t usb_led);
// For code that runs on suspend
@ -89,16 +114,24 @@ enum userspace_custom_keycodes {
// Macro key
BB_PGPK,
// Unicode strings
#ifdef UNICODEMAP_ENABLE
# ifdef UNICODEMAP_ENABLE
BB_LENY,
BB_TABL,
TR_FLAG,
#endif
# endif
// Encoder buttons
#ifdef ENCODER_ENABLE
# ifdef ENCODER_ENABLE
BB_ENC0,
BB_ENC1,
#endif
# endif
// Some RGB toggles
# ifdef RGB_MATRIX_ENABLE
BB_RGBO,
# endif
// Oled editor
# ifdef OLED_ENABLE
BB_OLED,
# endif
//use for keymap specific codes
KEYMAP_SAFE_RANGE
};
@ -385,19 +418,19 @@ enum userspace_layers {
/* Media layer
* ┌─────┬─────┬─────┬─────┬─────┐
* │ Tog │ Mod │ Hue │ Sat │ Bri │ RGB light control
* │Speed│ Mod │ Hue │ Sat │ Bri │ RGB light control
* ├─────┼─────┼─────┼─────┼─────┤
* │Media│Prev.│MuTog│MuStp│Next │ Media control
* ├─────┼─────┼─────┼─────┼─────┤
* │Sink │Vol -│ Mut │Eject│Vol +│ Volume control
* ┌─────┼─────┼─────┼─────┴─────┴─────┘
* │ │Veloc│Music│ Feature control on keyboard
* │OledL│Veloc│Music│ Feature control on keyboard
* └─────┴─────┴─────┘
*/
#define _ME1_5_ RGB_TOG,RGB_MOD,RGB_HUI,RGB_SAI,RGB_VAI
#define _ME2_5_ KC_MSEL,KC_MPRV,KC_MPLY,KC_MSTP,KC_MNXT
#define _ME1_5_ RGB_SPI,RGB_MOD,RGB_HUI,RGB_SAI,RGB_VAI
#define _ME2_5_ RGB_TOG,KC_MPRV,KC_MPLY,KC_MSTP,KC_MNXT
#define _ME3_5_ KC_F13, KC_VOLD,KC_MUTE,KC_EJCT,KC_VOLU
#define _ME4_3_ XXXXXXX,VLK_TOG,MU_TOG
#define _ME4_3_ BB_OLED,VLK_TOG,MU_TOG
/* Navigation layer
* ┌─────┬─────┬─────┬─────┬─────┐
@ -484,7 +517,7 @@ enum userspace_layers {
/* Function layer
* ┌─────┬─────┬─────┬─────┬─────┐
* │ F01 │ F02 │ F03 │ F04 │RESET│
* │ F01 │ F02 │ F03 │ F04 │EEPRM│
* ├─────┼─────┼─────┼─────┼─────┤
* │ F05 │ F06 │ F07 │ F08 │EEPRM│
* ├─────┼─────┼─────┼─────┼─────┤


+ 3
- 3
users/bbaserdem/config.h View File

@ -116,10 +116,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// OLED definitions
#ifdef OLED_ENABLE
// Timeout in one minute
#define OLED_TIMEOUT 60000
# define OLED_TIMEOUT 60000
// Fade out the screen when timing out
#define OLED_FADE_OUT
#define OLED_FADE_OUT_INTERVAL 5
# define OLED_FADE_OUT
# define OLED_FADE_OUT_INTERVAL 5
#endif
// For perkey leds


Write Preview
Loading…
Cancel
Save