Added the qmk firmware for sofle keyboard

7 files changed, 481 insertions, 0 deletions

diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/config.h b/qmk/keyboards/sofle_choc/keymaps/custom/config.h
new file mode 100644
index 0000000..9a89fd8
--- /dev/null
+++ b/qmk/keyboards/sofle_choc/keymaps/custom/config.h
@@ -0,0 +1,45 @@
+/* Copyright 2023 Brian Low
+ *
+ * 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
+
+// Enabling this option changes the startup behavior to listen for an
+// active USB communication to delegate which part is master and which
+// is slave. With this option enabled and theres’s USB communication,
+// then that half assumes it is the master, otherwise it assumes it
+// is the slave.
+//
+// I've found this helps with some ProMicros where the slave does not boot
+#define SPLIT_USB_DETECT
+
+#define RGB_DISABLE_WHEN_USB_SUSPENDED     // turn off effects when suspended
+#define SPLIT_TRANSPORT_MIRROR             // If LED_MATRIX_KEYPRESSES or LED_MATRIX_KEYRELEASES is enabled, you also will want to enable SPLIT_TRANSPORT_MIRROR
+#define RGB_MATRIX_MAXIMUM_BRIGHTNESS 100  // limits maximum brightness of LEDs (max 255). Higher may cause the controller to crash.
+
+
+
+#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET // Activates the double-tap behavior
+#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_TIMEOUT 200U // Timeout window in ms in which the double tap can occur.
+#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_LED D5 // Specify an optional status LED by GPIO number which blinks when entering the bootloader
+
+#define TAPPING_TERM 200
+
+// Movihy the tap-hold configuration for helping with some tap-dance keys.
+// The behavior with double-tap (like c/ç) and mod-tap is to wait the delay for
+// the tap-dance before reporting the key to send.
+// If I release the MOD-TAP key before, the modifier is not applied and the
+// host receive a sequence of two keys, which is not what I want.
+//#define PERMISSIVE_HOLD
+//#define HOLD_ON_OTHER_KEY_PRESS
diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.c b/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.c
new file mode 100644
index 0000000..e0f8994
--- /dev/null
+++ b/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.c
@@ -0,0 +1,78 @@
+#include QMK_KEYBOARD_H
+#include "keymap_bepo.h"
+#include "keycodes.h"
+
+/*
+ * Rules and modifier to apply over the keycodes. This includes the keys
+ * redefinitions and the keys to include in the caps_word mecanism.
+ *
+ * All thoses update are working over the custom keys declared in `keycodes.h` 
+ */
+
+/*
+ * This function need to be declared after the key definition, including the
+ * tapdance keys because I need to reference the keycode here if I want to
+ * include them in the caps_word mecanism.
+ */
+bool caps_word_press_user(uint16_t keycode) {
+    switch (keycode) {
+        // Keycodes that continue Caps Word, with shift applied.
+        case KC_A ... KC_Z:
+        case KC_1 ... KC_0:
+        case KC_MINS:
+        case KEY_C: // Add also the tapdance keys here.
+        case KEY_W:
+        case KEY_E:
+        case BP_Z:  // Additionals keys from the bepo layout.
+        case BP_M:
+        case BP_G:
+        case BP_H:
+        case BP_N:
+            add_weak_mods(MOD_BIT(KC_LSFT));  // Apply shift to next key.
+            return true;
+
+        // Keycodes that continue Caps Word, without shifting.
+        case KC_BSPC:
+        case KC_DEL:
+            return true;
+        case KC_SPACE:
+            // The space key is used in order to generate the _ symbol,
+            // I check which modifier is applied, it’s ok when it’s ALT
+            return get_mods() & MOD_MASK_ALT;
+
+        default:
+            return false;  // Deactivate Caps Word.
+    }
+}
+
+//
+// Override the symbol ° and replace it by `
+// The symbol is still available in the symbol layer with the key just below.
+//
+const key_override_t perc_key_override = 
+    ko_make_basic(MOD_MASK_SHIFT, KEY_PRC, LSFT(BP_PERC));
+
+// 
+// I don’t care of the mapping CTRL+Ç and using the mod_tap does not work well
+// when I type too fast because of tap-dance, so I remap the pattern here.
+//
+const key_override_t c_key_override = 
+    ko_make_basic(MOD_MASK_CTRL, KEY_C, LCTL(BP_C));
+
+// Same here, I override the key W with CTRL because the tapdance activate the 
+// caps_word which does not make sense here.
+const key_override_t w_key_override = 
+    ko_make_basic(MOD_MASK_CTRL, KEY_W, LCTL(BP_W));
+
+const key_override_t e_key_override = 
+    ko_make_basic(MOD_MASK_CTRL, KEY_E, RCTL(BP_E));
+
+
+// This globally defines all key overrides to be used
+const key_override_t **key_overrides = (const key_override_t *[]){
+    &perc_key_override,
+    &c_key_override,
+    &w_key_override,
+    &e_key_override,
+    NULL
+};
diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.h b/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.h
new file mode 100644
index 0000000..9837769
--- /dev/null
+++ b/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.h
@@ -0,0 +1,28 @@
+#pragma once
+
+enum {
+  // Custom key for defining the tapdance allowing to transform C into Ç
+  TD_C_CCED,
+  // Transform the key W into SHIFT or CAPSLOCK
+  TD_W_CAPSLOCK,
+  // Transform the key E into È
+  TD_E_EE,
+  TD_PRC,
+  TD_LAYER_SYMB,
+  TD_LSFT,
+};
+
+#define _BASE 0
+#define LAYER_SYMBOLS 1
+
+#define MENU    LGUI(BP_I)
+#define KEY_C   TD(TD_C_CCED)
+#define KEY_W   TD(TD_W_CAPSLOCK)
+#define KEY_PRC TD(TD_PRC)
+#define LT_SFT  TD(TD_LSFT)
+#define AL_ENT  MT(MOD_RALT, KC_ENT)
+#define AL_SPC  MT(MOD_LALT, KC_SPC)
+#define KEY_E   TD(TD_E_EE)
+#define KEY_T   MT(MOD_RCTL, BP_T)
+#define KEY_INS MT(MOD_RGUI, KC_INS)
+
diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/keymap.c b/qmk/keyboards/sofle_choc/keymaps/custom/keymap.c
new file mode 100644
index 0000000..fb1ba89
--- /dev/null
+++ b/qmk/keyboards/sofle_choc/keymaps/custom/keymap.c
@@ -0,0 +1,68 @@
+/* Copyright 2023 Brian Low
+ *
+ * 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 QMK_KEYBOARD_H
+#include "keymap_bepo.h"
+#include "keycodes.h"
+
+
+#define LY_SYMBOL TD(TD_LAYER_SYMB)
+
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+/*
+ * BÉPO
+ * ,-----------------------------------------.                    ,-----------------------------------------.
+ * |  `   |   1  |   2  |   3  |   4  |   5  |                    |   6  |   7  |   8  |   9  |   0  |  °   |
+ * |------+------+------+------+------+------|                    |------+------+------+------+------+------|
+ * | ESC  |   B  |   É  |   P  |   O  |   È  |                    |   !  |   V  |   D  |   L  |   J  |  Z   |
+ * |------+------+------+------+------+------|                    |------+------+------+------+------+------|
+ * | Tab  |   A  |   U  |   I  |   EÈ |   ;  |-------.    ,-------|  CÇ  |   T  |   S  |   R  |   N  |  M   |
+ * |------+------+------+------+------+------|  Mute |    | Pause |------+------+------+------+------+------|
+ * |LShift|   À  |   Y  |   X  |   :  |   K  |-------|    |-------|   ?  |   Q  |   G  |   H  |   F  |  W   |
+ * `-----------------------------------------/       /     \      \-----------------------------------------'
+ *            | LCTL | LGUI | LCMD | Layer| / Space /       \Enter \  | Layer| RCMD | RGUI | RCTL |
+ *            |      |      |      |  dwn |/ LALT  /         \ RALT \ |   up |      |      |      |
+ *            `-----------------------------------'           '------''---------------------------'
+ */
+
+[_BASE] = LAYOUT(
+    KC_ESC,   KC_1,   KC_2,    KC_3,    KC_4,    KC_5,                       KC_6,     KC_7,     KC_8,    KC_9,    KC_0,    KEY_PRC,
+    BP_DLR,   BP_B,   BP_EACU, BP_P,    BP_O,    KC_BSPC,                    BP_DCIR,  BP_V,     BP_D,    BP_L,    BP_J,    BP_Z,
+    KC_TAB,   BP_A,   BP_U,    BP_I,    KEY_E,   BP_COMM,                    KEY_C,    KEY_T,    BP_S,    BP_R,    BP_N,    BP_M,
+    LT_SFT,   BP_AGRV,BP_Y,    BP_X,    BP_DOT,  KC_B,    KC_MUTE,   KC_MPLY,BP_QUOT, BP_Q,      BP_G,    BP_H,    BP_F,    KEY_W,
+                      KC_LCTL, KC_LGUI, KC_BSPC, LY_SYMBOL,AL_SPC,   AL_ENT, LY_SYMBOL,MENU,     KEY_INS, KC_RCTL
+),
+
+// In the number layout, I keep the mod-tap modifiers applies to the middle letters :
+//
+#define KEY_5   MT(MOD_LCTL, KC_P5)
+#define KEY_DOWN   MT(MOD_RCTL, KC_DOWN)
+
+[LAYER_SYMBOLS] = LAYOUT(
+    KC_ESC,   KC_F1,  KC_F2,   KC_F3,   KC_F4,   KC_F5,                      KC_F6,    KC_F7,    KC_F8,   KC_F9,   KC_F10,  KC_F11,
+    KC_NO,    KC_NO,  KC_NO,   KC_P7,   KC_P8,   KC_P9,                      KC_HOME,  KC_UP,    KC_END,  KC_NO,   KC_NO,   S(BP_EQL),
+    KC_TAB,   KC_NO,  KC_NO,   KC_P4,   KEY_5,   KC_P6,                      KC_LEFT,  KEY_DOWN, KC_RIGHT,KC_NO,   KC_NO,   KC_NO,
+    LT_SFT,   KC_NO,  KC_P0,   KC_P1,   KC_P2,   KC_P3,   KC_MUTE,   KC_MPLY,KC_PGUP,  KC_NO,    KC_PGDN, KC_NO,   KC_NO,   KC_RIGHT_SHIFT,
+                      KC_LCTL, KC_LGUI, KC_BSPC, LY_SYMBOL,AL_SPC,   AL_ENT, LY_SYMBOL,KC_NO,    KC_RGUI, KC_RCTL
+),
+};
+
+#if defined(ENCODER_MAP_ENABLE)
+const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS] = {
+    [_BASE] = { ENCODER_CCW_CW(KC_VOLD, KC_VOLU), ENCODER_CCW_CW(KC_MS_WH_UP, KC_MS_WH_DOWN) },
+    [LAYER_SYMBOLS] = { ENCODER_CCW_CW(KC_VOLD, KC_VOLU), ENCODER_CCW_CW(KC_MS_WH_UP, KC_MS_WH_DOWN) },
+};
+#endif
diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.c b/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.c
new file mode 100644
index 0000000..9978315
--- /dev/null
+++ b/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.c
@@ -0,0 +1,226 @@
+/* Return an integer that corresponds to what kind of tap dance should be executed.
+ *
+ * How to figure out tap dance state: interrupted and pressed.
+ *
+ * Interrupted: If the state of a dance is "interrupted", that means that another key has been hit
+ *  under the tapping term. This is typically indicitive that you are trying to "tap" the key.
+ *
+ * Pressed: Whether or not the key is still being pressed. If this value is true, that means the tapping term
+ *  has ended, but the key is still being pressed down. This generally means the key is being "held".
+ *
+ * One thing that is currenlty not possible with qmk software in regards to tap dance is to mimic the "permissive hold"
+ *  feature. In general, advanced tap dances do not work well if they are used with commonly typed letters.
+ *  For example "A". Tap dances are best used on non-letter keys that are not hit while typing letters.
+ *
+ * Good places to put an advanced tap dance:
+ *  z,q,x,j,k,v,b, any function key, home/end, comma, semi-colon
+ *
+ * Criteria for "good placement" of a tap dance key:
+ *  Not a key that is hit frequently in a sentence
+ *  Not a key that is used frequently to double tap, for example 'tab' is often double tapped in a terminal, or
+ *    in a web form. So 'tab' would be a poor choice for a tap dance.
+ *  Letters used in common words as a double. For example 'p' in 'pepper'. If a tap dance function existed on the
+ *    letter 'p', the word 'pepper' would be quite frustating to type.
+ *
+ * For the third point, there does exist the 'TD_DOUBLE_SINGLE_TAP', however this is not fully tested
+ *
+ */
+
+#include QMK_KEYBOARD_H
+#include "keymap_bepo.h"
+#include "quad_tapdance.h"
+#include "keycodes.h"
+
+td_state_t cur_dance(tap_dance_state_t *state) {
+    if (state->count == 1) {
+        if (!state->pressed) return TD_SINGLE_TAP;
+        // Key has not been interrupted, but the key is still held. Means you want to send a 'HOLD'.
+        else return TD_SINGLE_HOLD;
+    } else if (state->count == 2) {
+        // TD_DOUBLE_SINGLE_TAP is to distinguish between typing "pepper", and actually wanting a double tap
+        // action when hitting 'pp'. Suggested use case for this return value is when you want to send two
+        // keystrokes of the key, and not the 'double tap' action/macro.
+        if (state->interrupted) return TD_DOUBLE_SINGLE_TAP;
+        else if (state->pressed) return TD_DOUBLE_HOLD;
+        else return TD_DOUBLE_TAP;
+    }
+
+    // Assumes no one is trying to type the same letter three times (at least not quickly).
+    // If your tap dance key is 'KC_W', and you want to type "www." quickly - then you will need to add
+    // an exception here to return a 'TD_TRIPLE_SINGLE_TAP', and define that enum just like 'TD_DOUBLE_SINGLE_TAP'
+    if (state->count == 3) {
+        if (state->interrupted || !state->pressed) return TD_TRIPLE_TAP;
+        else return TD_TRIPLE_HOLD;
+    } else return TD_UNKNOWN;
+}
+
+//
+// Definition for the key W.
+//
+// The main usage is to send the letter W when pressed, but the key is also
+// used to activate the SHIFT mode when pressed.
+//
+// If the key is double tapped, it will also switch into the caps_word mode.
+//
+
+static td_tap_t w_tap_state = {
+    .is_press_action = true,
+    .state = TD_NONE
+};
+
+void w_finished(tap_dance_state_t *state, void *user_data) {
+    w_tap_state.state = cur_dance(state);
+    switch (w_tap_state.state) {
+        case TD_SINGLE_TAP: register_code(BP_W); break;
+        case TD_SINGLE_HOLD: register_code(KC_RIGHT_SHIFT); break;
+        case TD_DOUBLE_TAP: caps_word_on(); break;
+        case TD_DOUBLE_SINGLE_TAP: tap_code(BP_W); register_code(BP_W); break;
+        default: break;
+    }
+}
+
+void w_reset(tap_dance_state_t *state, void *user_data) {
+    switch (w_tap_state.state) {
+        case TD_SINGLE_TAP: unregister_code(BP_W); break;
+        case TD_SINGLE_HOLD: unregister_code(KC_RIGHT_SHIFT); break;
+        case TD_DOUBLE_SINGLE_TAP: unregister_code(BP_W); break;
+        default: break;
+    }
+    w_tap_state.state = TD_NONE;
+}
+
+//
+// Definition for the layer key
+//
+// The only one usage is to activate the layer over the keyboard, but there is
+// two way of doing it:
+//
+// The first mode, when hold, is to activate the layer as long as the key is pressed.
+// The second one is to switch in the layer mode when double tapped, in this
+// mode, you can go back into the normal layer by a single press on the key.
+//
+static td_tap_t ql_tap_state = {
+    .is_press_action = true,
+    .state = TD_NONE
+};
+
+// Functions that control what our tap dance key does
+void ql_finished(tap_dance_state_t *state, void *user_data) {
+    ql_tap_state.state = cur_dance(state);
+    switch (ql_tap_state.state) {
+        // Remove the layer with a single tap, this way I always have a key to remove the
+        // the layer, without knowing the previous state I had.
+        case TD_SINGLE_TAP:  layer_off(LAYER_SYMBOLS); break;
+        case TD_SINGLE_HOLD: layer_on(LAYER_SYMBOLS);  break;
+        case TD_DOUBLE_TAP:  layer_invert(LAYER_SYMBOLS); break;
+        default: break;
+    }
+}
+
+void ql_reset(tap_dance_state_t *state, void *user_data) {
+    // If the key was held down and now is released then switch off the layer
+    if (ql_tap_state.state == TD_SINGLE_HOLD) {
+        layer_off(LAYER_SYMBOLS);
+    }
+    ql_tap_state.state = TD_NONE;
+}
+
+//
+// Definiton for the key DEL.
+// The main usage of the key is to activate the LShift when hold. But the key
+// can also be used to send the DEL keycode.
+//
+// As I do not want to send the DEL keycode by mistake, I’ve configured the key
+// to do it on double-tap. If you hold the key after a double tap, the DELETE
+// code will be repeated again until the key is released.
+//
+// On a single press, the key will just remove the CAPSLOCK state if active.
+//
+static td_tap_t lshift_tap_state = {
+    .is_press_action = true,
+    .state = TD_NONE
+};
+
+// Functions that control what our tap dance key does
+void lshift_finished(tap_dance_state_t *state, void *user_data) {
+    lshift_tap_state.state = cur_dance(state);
+    switch (lshift_tap_state.state) {
+        // Remove the layer with a single tap, this way I always have a key to remove the
+        // the layer, without knowing the previous state I had.
+        case TD_SINGLE_HOLD: register_code(KC_LEFT_SHIFT); break;
+        case TD_DOUBLE_TAP: 
+        case TD_DOUBLE_HOLD: 
+                             register_code(KC_DELETE); break;
+        case TD_SINGLE_TAP:
+                             if (host_keyboard_led_state().caps_lock)  
+                                 register_code(KC_CAPS_LOCK);
+                             break;
+        default: break;
+    }
+}
+
+void lshift_reset(tap_dance_state_t *state, void *user_data) {
+    switch (lshift_tap_state.state) {
+        case TD_SINGLE_HOLD: unregister_code(KC_LEFT_SHIFT); break;
+        case TD_DOUBLE_TAP:  
+        case TD_DOUBLE_HOLD: 
+                             unregister_code(KC_DELETE); break;
+        case TD_SINGLE_TAP:
+                             if (host_keyboard_led_state().caps_lock) 
+                                 unregister_code(KC_CAPS_LOCK);
+                             break;
+        default: break;
+    }
+    lshift_tap_state.state = TD_NONE;
+}
+
+// Definition for the key E
+// This key can transform into LEFT CONTROL when hold, but can also transform into È when double tapped.
+static td_tap_t e_tap_state = {
+    .is_press_action = true,
+    .state = TD_NONE
+};
+
+// Functions that control what our tap dance key does
+void e_finished(tap_dance_state_t *state, void *user_data) {
+    e_tap_state.state = cur_dance(state);
+    switch (e_tap_state.state) {
+        // Remove the layer with a single tap, this way I always have a key to remove the
+        // the layer, without knowing the previous state I had.
+        case TD_SINGLE_HOLD: register_code(KC_LEFT_CTRL); break;
+        case TD_DOUBLE_TAP: 
+                             register_code(BP_EGRV); break;
+        case TD_SINGLE_TAP:
+                             register_code(BP_E); break;
+                             break;
+        default: break;
+    }
+}
+
+void e_reset(tap_dance_state_t *state, void *user_data) {
+    switch (e_tap_state.state) {
+        case TD_SINGLE_HOLD: unregister_code(KC_LEFT_CTRL); break;
+        case TD_DOUBLE_TAP:  
+                             unregister_code(BP_EGRV); break;
+        case TD_SINGLE_TAP:
+                             unregister_code(BP_E); break;
+                             break;
+        default: break;
+    }
+    e_tap_state.state = TD_NONE;
+}
+
+
+
+//
+// Declare the tapdance table here.
+//
+tap_dance_action_t tap_dance_actions[] = {
+  [TD_C_CCED]           = ACTION_TAP_DANCE_DOUBLE(BP_C, BP_CCED),
+  [TD_PRC]              = ACTION_TAP_DANCE_DOUBLE(BP_EQL, BP_PERC),
+  [TD_W_CAPSLOCK]       = ACTION_TAP_DANCE_FN_ADVANCED(NULL, w_finished, w_reset),
+  [TD_LAYER_SYMB]       = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ql_finished, ql_reset),
+  [TD_LSFT]             = ACTION_TAP_DANCE_FN_ADVANCED(NULL, lshift_finished, lshift_reset),
+  [TD_E_EE]             = ACTION_TAP_DANCE_FN_ADVANCED(NULL, e_finished, e_reset),
+};
+
diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.h b/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.h
new file mode 100644
index 0000000..87da433
--- /dev/null
+++ b/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.h
@@ -0,0 +1,30 @@
+#pragma once
+
+typedef enum {
+    TD_NONE,
+    TD_UNKNOWN,
+    TD_SINGLE_TAP,
+    TD_SINGLE_HOLD,
+    TD_DOUBLE_TAP,
+    TD_DOUBLE_HOLD,
+    TD_DOUBLE_SINGLE_TAP, // Send two single taps
+    TD_TRIPLE_TAP,
+    TD_TRIPLE_HOLD
+} td_state_t;
+
+typedef struct {
+    bool is_press_action;
+    td_state_t state;
+} td_tap_t;
+
+td_state_t cur_dance(tap_dance_state_t *state);
+
+// For the x tap dance. Put it here so it can be used in any keymap
+void w_finished(tap_dance_state_t *state, void *user_data);
+void w_reset(tap_dance_state_t *state, void *user_data);
+
+void ql_finished(tap_dance_state_t *state, void *user_data);
+void ql_reset(tap_dance_state_t *state, void *user_data);
+
+void lshift_finished(tap_dance_state_t *state, void *user_data);
+void lshift_reset(tap_dance_state_t *state, void *user_data);
diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/rules.mk b/qmk/keyboards/sofle_choc/keymaps/custom/rules.mk
new file mode 100644
index 0000000..5edfedd
--- /dev/null
+++ b/qmk/keyboards/sofle_choc/keymaps/custom/rules.mk
@@ -0,0 +1,6 @@
+ENCODER_MAP_ENABLE = yes
+SPLIT_KEYBOARD = yes
+TAP_DANCE_ENABLE = yes
+CAPS_WORD_ENABLE = yes
+KEY_OVERRIDE_ENABLE = yes
+SRC += quad_tapdance.c keycodes.c