users/drashna/readme.md

   1 Overview
   2 ========
   3
   4 This is my personal userspace file.  Most of my code exists here, as it's heavily shared.
   5
   6
   7 Custom userspace handlers
   8 -------------------------
   9
  10 Specifically QMK works by using customized handlers for everything. This allows for multiple levels of customization.
  11
  12 `matrix_scan` calls `matrix_scan_quantum`, which alls `matrix_scan_kb`, which calls `matrix_scan_user`.
  13 `process_record` calls a bunch of stuff, but eventually calls `process_record_kb` which calls `process_record_user`
  14 The same goes for `matrix_init`, `layer_state_set`, `led_set`, and a few other functions.
  15
  16 All (most) `_user` functions are handled here instead.  To allow keyboard specific configuration, I've created `_keymap` functions that can be called by the keymap.c files instead.
  17
  18 This allows for keyboard specific configuration while maintaining the ability to customize the board.
  19
  20 My [Ergodox EZ Keymap](https://github.com/qmk/qmk_firmware/blob/master/keyboards/ergodox_ez/keymaps/drashna/keymap.c#L399) is a good example of this, as it uses the LEDs as modifier indicators.
  21
  22
  23 Keyboard Layout Templates
  24 -------------------------
  25
  26 This borrows from @jola5's "Not quite neo" code.  This allows me to maintain blocks of keymaps in the userspace, so that I can modify the userspace, and this is reflected in all of the keyboards that use it, at once.
  27
  28 This makes adding tap/hold mods, or other special keycodes or functions to all keyboards super easy, as it's done to all of them at once.
  29
  30 The caveat here is that the keymap needs a processor/wrapper, as it doesn't like the substitutions.  However, this is as simple as just pushing it through a define. For instance:
  31
  32 `#define LAYOUT_ergodox_wrapper(...)   LAYOUT_ergodox(__VA_ARGS__)`
  33
  34 Once that's been done and you've switched the keymaps to use the "wrapper", it will read the substitution blocks just fine.
  35
  36 Credit goes to @jola5 for first implementing this awesome idea.
  37
  38
  39 Custom Keycodes
  40 ---------------
  41
  42 Keycodes are defined in the drashna.h file and need to be included in the keymap.c files, so that they can be used there.
  43
  44 A bunch of macros are present and are only included on boards that are not the Ergodox EZ or Orthodox, as they are not needed for those boards.
  45
  46 Included is a custom macro for compiling my keyboards.  This includes the bootloader target (`:teensy`, `:avrdude`, or `:dfu`), and keeps RGBLIGHT, AUDIO and/or FAUXCLICKY enabled, if it previously was (regardless of the rules file).
  47
  48 This also includes a modified RESET keycode as well, that sets the underglow to red.
  49
  50 Layer Indication
  51 ----------------
  52
  53 This uses the `layer_state_set_*` command to change the layer color, to indicate which layer it is on.  This includes the default keymap, as well.
  54
  55 Since this is done via userspace, it is the same between all systems.
  56
  57 Additionally, there is a custom keycode to toggle layer indication. And all RGB keycodes disable layer indication by default, as well.  This way, I can leave special effects doing when I want.
  58
  59 Also. I use `rgblight_sethsv` since it works with animation modes (that support it).
  60
  61
  62 Diablo Layer
  63 ------------
  64
  65 This layer has some special handling.
  66
  67 When Tap Dances are enabled, this layer has the ability to "spam" keypresses.
  68
  69 For instance, tapping the TD "1" twice causes the layer to hit "1" ever 1 second (appoximately).  This is useful for auto-hotkeying skills (such as bone armor or devour).
  70
  71 Tappind once disables this, and switching layers temporarily disables this, until you switch back to the layer.
  72
  73 For critics that think this is cheating, search "diablo 3 num lock auto cast".  This is just a simpler method, since I no longer own a normal (non QMK) numpad.
  74
  75 Secret Macros
  76 -------------
  77
  78 With help from gitter and Colinta, this adds the ability to add hidden macros from other users.
  79
  80 First, I have several files that are hidden/excluded from Git/GitHub.  These contain everything needed for the macros. To hide these files, open `.git/info/exclude` and add `secrets.c` and  `secrets.h` to that file, below the comments.
  81
  82 And this requires `KC_SECRET_1` through `KC_SECRET_5` to be defined in your `<name>.h` file to define the keycodes for the new macros.
  83
  84
  85 ###### .git/info/exclude
  86 ```
  87 # git ls-files --others --exclude-from=.git/info/exclude
  88 # Lines that start with '#' are comments.
  89 # For a project mostly in C, the following would be a good set of
  90 # exclude patterns (uncomment them if you want to use them):
  91 # *.[oa]
  92 # *~
  93 /users/drashna/secrets.c
  94 /users/drashna/secrets.h
  95 ```
  96
  97 Then you can create these files:
  98
  99 ###### secrets.c
 100
 101 ```c
 102 #include "drashna.h"  // replace with your keymap's "h" file, or whatever file stores the keycodes
 103
 104 #if (__has_include("secrets.h") && !defined(NO_SECRETS))
 105 #include "secrets.h"
 106 #else
 107 // `PROGMEM const char secret[][x]` may work better, but it takes up more space in the firmware
 108 // And I'm not familiar enough to know which is better or why...
 109 static const char * const secret[] = {
 110   "test1",
 111   "test2",
 112   "test3",
 113   "test4",
 114   "test5"
 115 };
 116 #endif
 117
 118 bool process_record_secrets(uint16_t keycode, keyrecord_t *record) {
 119   switch (keycode) {
 120     case KC_SECRET_1 ... KC_SECRET_5: // Secrets!  Externally defined strings, not stored in repo
 121       if (!record->event.pressed) {
 122         clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
 123         send_string_with_delay(secret[keycode - KC_SECRET_1], MACRO_TIMER);
 124       }
 125       return false;
 126       break;
 127   }
 128   return true;
 129 }
 130 ```
 131
 132 ###### secrets.h
 133 ```c
 134 static const char * const secrets[] = {
 135   "secret1",
 136   "secret2",
 137   "secret3",
 138   "secret4",
 139   "secret5"
 140 };
 141 ```
 142
 143 Replacing the strings with the codes that you need.
 144
 145 ###### name.c
 146
 147 In the `<name>.c` file, you will want to add this to the top:
 148
 149 ```c
 150 __attribute__ ((weak))
 151 bool process_record_secrets(uint16_t keycode, keyrecord_t *record) {
 152   return true;
 153 }
 154 ```
 155 This is so that the function can be called here, and replaced in the `secrets.c` file, and so it won't error out if it doesn't exist.
 156
 157
 158 And then, in the `process_record_user` function, assuming you have `return process_record_keymap(keycode, record)` here,  you'll want to replace the "final" return with the following. Otherwise, you want to replace the `return true;` with `return process_record_secrets(keycode, record);`
 159 ```c
 160   return process_record_keymap(keycode, record) && process_record_secrets(keycode, record);
 161 }
 162 ```
 163
 164 ###### rules.mk
 165
 166 Here, you want your `/users/<name>/rules.mk` file to "detect" the existence of the `secrets.c` file, and only add it if the file exists.  To do so, add this block:
 167 ```c
 168 ifneq ("$(wildcard $(USER_PATH)/secrets.c)","")
 169   SRC += secrets.c
 170 endif
 171 ```
 172
 173 Additionally, if you want to make sure that you can disable the function without messing with the file, you need to add this to your `/users/<name>/rules.mk`, so that it catches the flag:
 174 ```c
 175 ifeq ($(strip $(NO_SECRETS)), yes)
 176     OPT_DEFS += -DNO_SECRETS
 177 endif
 178 ```
 179
 180 Then, if you run `make keyboard:name NO_SECRETS=yes`, it will default to the test strings in your `<name>.c` file, rather than reading from your file.
 181
 182
 183 Userspace EEPROM config
 184 -----------------------
 185
 186 This adds EEPROM support fo the userspace, so that certain values are configurable in such a way that persists when power is lost.  Namely, just the clicky feature and the Overwatch macro option ("is_overwatch").  This is done by reading and saving the structure from EEPROM.
 187
 188 To implement this, first you need to specify the location:
 189
 190 ```c
 191 #define EECONFIG_USERSPACE (uint8_t *)20
 192 ```
 193 This tells us where in the EEPROM that the data structure is located, and this specifies that it's a byte (8 bits).  However, to maximize it's usage, we want to specify a data structure here, so that we can use multiple settings.  To do that:
 194
 195 ```c
 196 typedef union {
 197   uint8_t raw;
 198   struct {
 199     bool     clicky_enable  :1;
 200     bool     is_overwatch   :1;
 201   };
 202 } userspace_config_t;
 203 ```
 204 Then, in your C file, you want to add: `userspace_config_t userspace_config;`, and in your `matrix_init_*` function, you want to add `userspace_config.raw = eeprom_read_byte(EECONFIG_USERSPACE);`
 205
 206 From there, you'd want to use the data structure (such as `userspace_config.is_overwatch`) when you want to check this value.
 207
 208 And if you want to update it, update directly and then use `eeprom_update_byte(EECONFIG_USERSPACE, userspace_config.raw);` to write the value back to the EEPROM.
 209
 210
 211 Pro Micro Hacking
 212 -----------------
 213
 214 Well, you can get the QMK DFU bootloader working on the ProMicro. But you need to change fuses.
 215
 216 What worked to get into the firmware properly was:
 217
 218 ```
 219 Low: 0x5E High: 0xD9 Extended: 0xC3 Lock: 0x3F
 220 ```
 221
 222 The reason that there was some issues before, is that JTAG was still enabled, and using some of the pins that the keyboard uses.  Disabling JTAG (either by fuse, or modifying the matrix code for splits fixes the issue).
 223
 224 And for reference, if you want to go back to caterina, the default fuse settings I believe were:
 225
 226 ```
 227 Low: 0xFF High: 0xD8 Extended: 0xC3 Lock: 0x3F
 228 ```