diff options
| -rw-r--r-- | keyboards/ergodox_ez/keymaps/lukaus/config.h | 16 | ||||
| -rw-r--r-- | keyboards/ergodox_ez/keymaps/lukaus/keymap.c | 843 | ||||
| -rw-r--r-- | keyboards/ergodox_ez/keymaps/lukaus/readme.md | 3 | ||||
| -rw-r--r-- | keyboards/ergodox_ez/keymaps/lukaus/rules.mk | 1 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/config.h | 190 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/ibm122m.c | 43 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/ibm122m.h | 42 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/info.json | 0 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/keymaps/default/config.h | 19 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/keymaps/default/keymap.c | 46 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/keymaps/default/readme.md | 2 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/keymaps/lukaus/config.h | 19 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/keymaps/lukaus/keymap.c | 587 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/keymaps/lukaus/readme.md | 2 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/readme.md | 16 | ||||
| -rw-r--r-- | keyboards/handwired/ibm122m/rules.mk | 67 | 
16 files changed, 1896 insertions, 0 deletions
| diff --git a/keyboards/ergodox_ez/keymaps/lukaus/config.h b/keyboards/ergodox_ez/keymaps/lukaus/config.h new file mode 100644 index 0000000000..2b93445378 --- /dev/null +++ b/keyboards/ergodox_ez/keymaps/lukaus/config.h @@ -0,0 +1,16 @@ +#pragma once +#define CONFIG_USER_H + +#define TAPPING_TERM 200 + +#ifdef RGBLIGHT_ENABLE +#undef RGBLIGHT_SAT_STEP  +#define RGBLIGHT_SAT_STEP 12 +#define RGBLIGHT_EFFECT_KNIGHT_LENGTH 7 +#define RGBLIGHT_EFFECT_SNAKE_LENGTH 7 +#define RGBLIGHT_EFFECT_BREATHE_CENTER 1 +#endif // RGBLIGHT_ENABLE + +#define FORCE_NKRO + +#define MODS_SHIFT_MASK (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) diff --git a/keyboards/ergodox_ez/keymaps/lukaus/keymap.c b/keyboards/ergodox_ez/keymaps/lukaus/keymap.c new file mode 100644 index 0000000000..40156b3ff3 --- /dev/null +++ b/keyboards/ergodox_ez/keymaps/lukaus/keymap.c @@ -0,0 +1,843 @@ +#include QMK_KEYBOARD_H +#include "version.h" + +#include "keymap_german.h" + +#include "keymap_nordic.h" + +enum custom_keycodes { +  PLACEHOLDER = SAFE_RANGE, // can always be here + +  // Programmer's Dvorak "macros" :  +  //  To be paired with get_mods to enable both +  //  Shift functionality and Programmer's Dvorak + +  DVP_ESC, // Grave escape basically i think +  DVP_AMPR, +  DVP_LBRACKET, +  DVP_LCBR, +  DVP_RCBR, +  DVP_LPRN, +  DVP_AT, + +  DVP_EQUAL, +  DVP_ASTERISK, +  DVP_RPRN, +  DVP_PLUS, +  DVP_RBRACKET, +  DVP_EXLM, +  DVP_HASH, + +  RU_2, +  RU_3, +  RU_4, +  RU_6, +  RU_7, +  RU_DOT, + +  SHFT_COMMA, +  SHFT_DOT, + +  RGB_SLD, +  RGB_FF0000, +  RGB_008000, +  RGB_0000FF, +  RGB_FFFFFF, +  RGB_800080 +}; + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { +  // Programmer's Dvorak layer +  [0] = LAYOUT_ergodox( +    DVP_ESC,      DVP_AMPR,         DVP_LBRACKET, DVP_LCBR,         DVP_RCBR,     DVP_LPRN,   DVP_AT, +    KC_TAB,       KC_SCOLON,        KC_COMMA,     KC_DOT,           KC_P,         KC_Y,       MO(4),  +    MO(3),        KC_A,             KC_O,         KC_E,             KC_U,         KC_I,      +    KC_LSHIFT,    KC_QUOTE,         KC_Q,         KC_J,             KC_K,         KC_X,       KC_HYPR, +    KC_LCTL,      KC_LALT,          KC_LGUI,      LCTL(KC_C),       LCTL(KC_V), +     +      KC_MS_BTN3, TO(1),    KC_HOME,  KC_SPACE,   MO(4),  KC_END, +     +    DVP_EQUAL,    DVP_ASTERISK,     DVP_RPRN,     DVP_PLUS,         DVP_RBRACKET, DVP_EXLM,   DVP_HASH, +    TT(4),        KC_F,             KC_G,         KC_C,             KC_R,         KC_L,       KC_SLASH, +                  KC_D,             KC_H,         KC_T,             KC_N,         KC_S,       KC_MINUS, +    KC_MEH,       KC_B,             KC_M,         KC_W,             KC_V,         KC_Z,       MO(3), +                                    KC_DELETE,    KC_BSLASH,        KC_RGUI,      KC_RCTL,    LCTL(KC_F), +     +      KC_F17,     KC_F18,   KC_PGUP,  KC_PGDOWN,  KC_ENTER,   KC_BSPACE +  ), +  // Gaming QWERTY layer +  [1] = LAYOUT_ergodox( +    KC_ESCAPE,  KC_1,   KC_2,     KC_3,         KC_4,       KC_5,         KC_F14, +    KC_TAB,     KC_Q,   KC_W,     KC_E,         KC_R,       KC_T,         KC_F23, +    MO(3),      KC_A,   KC_S,     KC_D,         KC_F,       KC_G, +    KC_LSHIFT,  KC_Z,   KC_X,     KC_C,         KC_V,       KC_B,         KC_F24, +    KC_LCTL,    KC_F8,  KC_LALT,  KC_F14,      KC_F13, +     +      KC_HOME,  TO(0),  KC_F15,  KC_SPACE, KC_LCTL,  KC_LALT, +     +    KC_6,       KC_7,   KC_8,     KC_9,         KC_0,       KC_MINUS,   KC_EQUAL, +    KC_F24,     KC_Y,   KC_U,     KC_I,         KC_O,       KC_P,       KC_BSLASH, +                KC_H,   KC_J,     KC_K,         KC_L,       KC_SCOLON,  KC_QUOTE, +    KC_F17,     KC_N,   KC_M,     KC_COMMA,     KC_DOT,     KC_SLASH,   KC_RSHIFT, +            KC_DELETE,  KC_F19,   KC_LGUI,       KC_F21,     KC_F22, + +      KC_F17,   KC_F18, KC_PGUP,  KC_PGDOWN,    KC_ENTER,   KC_BSPACE +  ), +  [2] = LAYOUT_ergodox( +    KC_ESCAPE,  KC_F1,     KC_F2,     KC_F3,     KC_F4,     KC_F5,     KC_C, +    KC_TAB,     KC_Q,      KC_W,      KC_E,      KC_R,      KC_T,      TO(0), +    MO(3),      KC_1,      KC_2,      KC_3,      KC_4,      KC_5, +    KC_LSHIFT,  KC_6,      KC_7,      KC_8,      KC_9,      KC_0,     KC_NO, +    KC_LCTL,    KC_F8,     KC_LALT,   KC_I,      KC_S, +     +    KC_MS_BTN3, TO(1),  KC_HOME,  KC_SPACE, KC_LSHIFT,  KC_END, +     +    KC_NO,     KC_NUMLOCK,     KC_KP_SLASH,    KC_KP_ASTERISK, KC_KP_MINUS,     KC_NO,   KC_NO, +    TO(0),     KC_KP_7,        KC_KP_8,        KC_KP_9,        KC_KP_PLUS,      KC_NO,   KC_NO, +               KC_KP_4,        KC_KP_5,        KC_KP_6,        KC_EQUAL,        KC_NO,  KC_NO, +    KC_NO,     KC_KP_1,        KC_KP_2,        KC_KP_3,        KC_KP_ENTER,     KC_NO,  KC_NO, +               KC_KP_0,        KC_KP_DOT,      KC_NO,          KC_NO,           KC_NO, + +      TO(0), KC_F18, KC_PGUP,  KC_PGDOWN,  KC_ENTER, KC_BSPACE +  ), +  // Function Layer +  [3] = LAYOUT_ergodox( +    KC_DLR,         KC_F1,            KC_F2,              KC_F3,              KC_F4,              KC_F5,          KC_TRANSPARENT, +    KC_TRANSPARENT, KC_TRANSPARENT,   KC_MEDIA_PREV_TRACK,KC_MEDIA_PLAY_PAUSE,KC_MEDIA_NEXT_TRACK,KC_NO,          TT(4), +    KC_TRANSPARENT, KC_TRANSPARENT,   KC_AUDIO_VOL_DOWN,  KC_AUDIO_VOL_UP,    KC_AUDIO_MUTE,      KC_TRANSPARENT, +    KC_LSHIFT,      LALT(KC_Z),       KC_TRANSPARENT,     KC_TRANSPARENT,     KC_F12,             KC_TRANSPARENT, ALL_T(KC_NO), +    KC_LCTL,        KC_LALT,          KC_LGUI,            KC_CAPSLOCK,        LSFT(KC_F12), + +     KC_PSCREEN, KC_PGUP,  KC_PGDOWN,  KC_SPACE, KC_LSHIFT,  KC_INSERT, + +    KC_F6,          KC_F7,            KC_F8,              KC_F9,              KC_F10,             KC_F11,         KC_F12, +    KC_NO,          KC_HOME,          KC_TRANSPARENT,     KC_PSCREEN,         KC_SLCK,            KC_TRANSPARENT, KC_TRANSPARENT, +                    KC_LEFT,          KC_DOWN,            KC_UP,              KC_RIGHT,           KC_TRANSPARENT, KC_TRANSPARENT, +    MEH_T(KC_NO),   KC_CALCULATOR,    KC_TRANSPARENT,     KC_TRANSPARENT,     KC_TRANSPARENT,     KC_TRANSPARENT, KC_RSHIFT, +                                      KC_DELETE,          KC_INSERT,          KC_TRANSPARENT,     KC_F19,         KC_RCTL, +     +     TO(2),KC_TRANSPARENT,KC_TRANSPARENT,LALT(KC_F10),KC_ENTER,KC_BSPACE +  ), +  // Keypad, Lighting, and Mouse emulation layer + ///*  +    [4] = LAYOUT_ergodox( +    KC_ESCAPE,  KC_NO,      KC_NO,        KC_MS_BTN3, KC_NO,        KC_NO,          KC_NO, +    KC_TAB,     KC_NO,      KC_MS_BTN2,   KC_MS_UP,   KC_MS_BTN1,   KC_MS_WH_UP,    TO(0), +    KC_NO,      KC_NO,      KC_MS_LEFT,   KC_MS_DOWN, KC_MS_RIGHT,  KC_MS_WH_DOWN, +    KC_LSHIFT,  KC_NO,      KC_NO,        KC_UP,      KC_NO,        KC_NO,          TO(5), +    KC_LCTL,    KC_NO,      KC_LEFT,      KC_DOWN,    KC_RIGHT, +     +    KC_MS_BTN3, TO(1),  KC_HOME,  KC_SPACE, KC_LSHIFT,  KC_END, +     +    KC_NO,          KC_NUMLOCK,     KC_KP_SLASH,    KC_KP_ASTERISK, KC_CALCULATOR,    KC_NO,      RGB_VAI, +    TO(0),          KC_KP_7,        KC_KP_8,        KC_KP_9,        KC_KP_MINUS,      KC_NO,      RGB_VAD, +                    KC_KP_4,        KC_KP_5,        KC_KP_6,        KC_KP_PLUS,       KC_NO,    RGB_HUI, +    KC_NO,          KC_KP_1,        KC_KP_2,        KC_KP_3,        KC_EQUAL,         RGB_SLD,    RGB_HUD, +                                    KC_KP_0,        KC_KP_DOT,      KC_KP_ENTER,      RGB_MOD,   RGB_TOG, + +      KC_F17, KC_F18, KC_PGUP,  KC_PGDOWN,  KC_ENTER, KC_BSPACE +  ) +  //*/ +  /* +  // Keypad, Lighting, and Mouse emulation layer +  [4] = KEYMAP( +    KC_ESCAPE,  KC_NO,      KC_NO,        KC_MS_BTN3, KC_NO,        KC_NO,          KC_NO, +    KC_TAB,     KC_NO,      KC_MS_BTN2,   KC_MS_UP,   KC_MS_BTN1,   KC_MS_WH_UP,    TO(0), +    KC_NO,      KC_NO,      KC_MS_LEFT,   KC_MS_DOWN, KC_MS_RIGHT,  KC_MS_WH_DOWN, +    KC_LSHIFT,  KC_NO,      KC_NO,        KC_UP,      KC_NO,        KC_NO,          TO(5), +    KC_LCTL,    KC_NO,      KC_LEFT,      KC_DOWN,    KC_RIGHT, +     +    KC_MS_BTN3, TO(1),  KC_HOME,  KC_SPACE, KC_LSHIFT,  KC_END, +     +    KC_NO,    KC_I,       KC_NUMLOCK,     KC_KP_SLASH,    KC_KP_ASTERISK, KC_CALCULATOR,  RGB_VAI, +    TO(0),    KC_G,       KC_KP_7,        KC_KP_8,        KC_KP_9,        KC_KP_MINUS,    RGB_VAD, +              SHFT_COMMA,       KC_KP_4,        KC_KP_5,        KC_KP_6,        KC_KP_PLUS,     RGB_HUI, +    KC_NO,    SHFT_DOT,       KC_KP_1,        KC_KP_2,        KC_KP_3,        KC_EQUAL,       RGB_HUD, +              KC_NO,                       KC_KP_0,        KC_KP_DOT,      KC_KP_ENTER,    RGB_TOG, + +      KC_F17, KC_F18, KC_PGUP,  KC_PGDOWN,  KC_ENTER, KC_BSPACE +  ) +  */ + +}; + +void led_set_keymap(uint8_t usb_led) { +   +} + +void matrix_init_user (void) { +  +} + + +bool left_shift_down = false; +bool right_shift_down = false; + +bool numlock = false; + +bool process_record_user(uint16_t keycode, keyrecord_t *record) { +  +  switch (keycode) { +    case KC_LSHIFT: +    if (record->event.pressed) +      { +        left_shift_down = true; +      return true; +      } +      else +      { +        left_shift_down = false; +        return true; +      } +    break; +    case KC_RSHIFT: + +      if (record->event.pressed) +      { +        right_shift_down = true; +      return true; +      } +      else +      { +        right_shift_down = false; +        return true; +      } +    break; +    case KC_NUMLOCK: + +      if (record->event.pressed)  +      { +        numlock = !numlock; +    } +    break; + +    case DVP_ESC: +    if (left_shift_down || right_shift_down) +    {   +      if(record->event.pressed) +        SEND_STRING("~"); +      return false; +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING(SS_DOWN(X_ESCAPE)); +      else +        SEND_STRING(SS_UP(X_ESCAPE)); +      return false; +    } +    break; + +    case DVP_AMPR: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        SEND_STRING("%"); + +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("&"); +    } +    return false; + +    break;  + +    case SHFT_DOT: +      if(record->event.pressed) +        SEND_STRING(">"); +      break; + +    case SHFT_COMMA: +      if(record->event.pressed) +        SEND_STRING("<"); +      break; + +    case DVP_LBRACKET: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +        { +          if(left_shift_down) +            unregister_code(KC_LSHIFT); +          if(right_shift_down) +            unregister_code(KC_RSHIFT); + +          register_code(KC_7); +          unregister_code(KC_7); + +          if(left_shift_down) +            register_code(KC_LSHIFT); +          if(right_shift_down) +            register_code(KC_RSHIFT); +        } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("["); +    } +    return false; + +        return false; +        break;  +     +    case DVP_LCBR: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +       {  +          if(left_shift_down) +            unregister_code(KC_LSHIFT); +          if(right_shift_down) +            unregister_code(KC_RSHIFT); + +          register_code(KC_5); +          unregister_code(KC_5); +           +          if(left_shift_down) +            register_code(KC_LSHIFT); +          if(right_shift_down) +            register_code(KC_RSHIFT); +        } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("{"); +    } +    return false; +    break;  +     +    case DVP_RCBR: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_3); +        unregister_code(KC_3); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("}"); +    } +    return false; +    break;  +     +    case DVP_LPRN: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_1); +        unregister_code(KC_1); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("("); +    } +    return false; +    break;  +     +    case DVP_AT: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_LSHIFT); +        register_code(KC_6); +        unregister_code(KC_6); +        unregister_code(KC_LSHIFT); +           +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("@"); +    } +    return false; +    break;  + +     +    case DVP_EQUAL: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_9); +        unregister_code(KC_9); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("="); +    } +    return false; +    break;  +     +    case DVP_ASTERISK: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_0); +        unregister_code(KC_0); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("*"); +    } +    return false; +    break;  +     +    case DVP_RPRN: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_2); +        unregister_code(KC_2); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING(")"); +    } +    return false; +    break;  +     +    case DVP_PLUS: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_4); +        unregister_code(KC_4); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("+"); +    } +    return false; +    break;  +     +    case DVP_RBRACKET: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_6); +        unregister_code(KC_6); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("]"); +    } +    return false; +    break;  +     +    case DVP_EXLM: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_8); +        unregister_code(KC_8); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("!"); +    } +    return false; +    break;  +     +    case DVP_HASH: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_GRAVE); +        unregister_code(KC_GRAVE); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("#"); +    } +    return false; +    break;  + +    // Russian  +    case RU_2: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_GRAVE); +        unregister_code(KC_GRAVE); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("#"); +    } +    return false; +    break;  +case RU_3: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_GRAVE); +        unregister_code(KC_GRAVE); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("#"); +    } +    return false; +    break;  +case RU_4: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_GRAVE); +        unregister_code(KC_GRAVE); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("#"); +    } +    return false; +    break;  +case RU_6: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_GRAVE); +        unregister_code(KC_GRAVE); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("#"); +    } +    return false; +    break;  +case RU_7: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_GRAVE); +        unregister_code(KC_GRAVE); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("#"); +    } +    return false; +    break;  + +  case RU_DOT: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_GRAVE); +        unregister_code(KC_GRAVE); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("#"); +    } +    return false; +    break;  + + +    case RGB_SLD: +      if (record->event.pressed) { +        rgblight_mode(1); +      } +      return false; +      break; +     +    case RGB_FF0000: +      if (record->event.pressed) { +        #ifdef RGBLIGHT_ENABLE +          rgblight_enable(); +          rgblight_mode(1); +          rgblight_setrgb(0xff,0x00,0x00); +        #endif +      } +      return false; +      break; +     +    case RGB_008000: +      if (record->event.pressed) { +        #ifdef RGBLIGHT_ENABLE +          rgblight_enable(); +          rgblight_mode(1); +          rgblight_setrgb(0x00,0x80,0x00); +        #endif +      } +      return false; +      break; +     +    case RGB_0000FF: +      if (record->event.pressed) { +        #ifdef RGBLIGHT_ENABLE +          rgblight_enable(); +          rgblight_mode(1); +          rgblight_setrgb(0x00,0x00,0xff); +        #endif +      } +      return false; +      break; +     +    case RGB_FFFFFF: +      if (record->event.pressed) { +        #ifdef RGBLIGHT_ENABLE +          rgblight_enable(); +          rgblight_mode(1); +          rgblight_setrgb(0xff,0xff,0xff); +        #endif +      } +      return false; +      break; +     +    case RGB_800080: +      if (record->event.pressed) { +        #ifdef RGBLIGHT_ENABLE +          rgblight_enable(); +          rgblight_mode(1); +          rgblight_setrgb(0x80,0x00,0x80); +        #endif +      } +      return false; +      break; +     +  } +  return true; +} + +uint32_t layer_state_set_user(uint32_t state) { + +    uint8_t layer = biton32(state); + +  //  ergodox_board_led_off(); +    ergodox_right_led_1_off(); +    ergodox_right_led_2_off(); +    ergodox_right_led_3_off(); +    switch (layer) { +      case 0: +        break; +      case 1: +        ergodox_right_led_1_on();  +        break; +      case 2: +        ergodox_right_led_2_on(); +        break; +      case 3: +        ergodox_right_led_3_on(); +        break; +      case 4: +        ergodox_right_led_1_on(); +        ergodox_right_led_3_on(); +        break; +      default: +        break; +    } +    return state; + +}; diff --git a/keyboards/ergodox_ez/keymaps/lukaus/readme.md b/keyboards/ergodox_ez/keymaps/lukaus/readme.md new file mode 100644 index 0000000000..af091bb1b9 --- /dev/null +++ b/keyboards/ergodox_ez/keymaps/lukaus/readme.md @@ -0,0 +1,3 @@ +# Lukaus' keymap + +Programmer's Dvorak as default layer with Qwerty gaming layer and two function layers diff --git a/keyboards/ergodox_ez/keymaps/lukaus/rules.mk b/keyboards/ergodox_ez/keymaps/lukaus/rules.mk new file mode 100644 index 0000000000..fe05f599b9 --- /dev/null +++ b/keyboards/ergodox_ez/keymaps/lukaus/rules.mk @@ -0,0 +1 @@ +#UNICODE_ENABLE = yes diff --git a/keyboards/handwired/ibm122m/config.h b/keyboards/handwired/ibm122m/config.h new file mode 100644 index 0000000000..1c8e0587dc --- /dev/null +++ b/keyboards/handwired/ibm122m/config.h @@ -0,0 +1,190 @@ +/* +Copyright 2018 REPLACE_WITH_YOUR_NAME + +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 "config_common.h" + +/* USB Device descriptor parameter */ +#define VENDOR_ID       0xFEED +#define PRODUCT_ID      0x0000 +#define DEVICE_VER      0x0001 +#define MANUFACTURER    IBM +#define PRODUCT         IBM Model M 122 key  +#define DESCRIPTION     Mapping by github.com/lukexorz + +/* key matrix size */ +#define MATRIX_ROWS 8 +#define MATRIX_COLS 20 + +/* + * Keyboard Matrix Assignments + * + * Change this to how you wired your keyboard + * COLS: AVR pins used for columns, left to right + * ROWS: AVR pins used for rows, top to bottom + * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode) + *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode) + * +*/ +#define MATRIX_COL_PINS { E6, B7, D0, D1, D2, D3, D4, D5, D6, D7, E0, E1, C0, C1, C2, C3, C4, C5, C7, F1 } +#define MATRIX_ROW_PINS { F0, B5, B4, B3, B2, B1, B0, E7 } +#define UNUSED_PINS + +/* COL2ROW, ROW2COL, or CUSTOM_MATRIX */ +#define DIODE_DIRECTION ROW2COL + +// #define BACKLIGHT_PIN B7 +// #define BACKLIGHT_BREATHING +// #define BACKLIGHT_LEVELS 3 + + +/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */ +#define DEBOUNCING_DELAY 15 + +/* define if matrix has ghost (lacks anti-ghosting diodes) */ +//#define MATRIX_HAS_GHOST + +/* number of backlight levels */ + +/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ +#define LOCKING_SUPPORT_ENABLE +/* Locking resynchronize hack */ +#define LOCKING_RESYNC_ENABLE + +/* If defined, GRAVE_ESC will always act as ESC when CTRL is held. + * This is userful for the Windows task manager shortcut (ctrl+shift+esc). + */ +// #define GRAVE_ESC_CTRL_OVERRIDE + +/* + * Force NKRO + * + * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved + * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the + * makefile for this to work.) + * + * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N) + * until the next keyboard reset. + * + * NKRO may prevent your keystrokes from being detected in the BIOS, but it is + * fully operational during normal computer usage. + * + * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N) + * or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by + * bootmagic, NKRO mode will always be enabled until it is toggled again during a + * power-up. + * + */ +//#define FORCE_NKRO + +/* + * Magic Key Options + * + * Magic keys are hotkey commands that allow control over firmware functions of + * the keyboard. They are best used in combination with the HID Listen program, + * found here: https://www.pjrc.com/teensy/hid_listen.html + * + * The options below allow the magic key functionality to be changed. This is + * useful if your keyboard/keypad is missing keys and you want magic key support. + * + */ + +/* key combination for magic key command */ +#define IS_COMMAND() ( \ +    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \ +) + +#define B6_AUDIO +#define C6_AUDIO + +/* control how magic key switches layers */ +//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS  true +//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS  true +//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false + +/* override magic key keymap */ +//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS +//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS +//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM +//#define MAGIC_KEY_HELP1          H +//#define MAGIC_KEY_HELP2          SLASH +//#define MAGIC_KEY_DEBUG          D +//#define MAGIC_KEY_DEBUG_MATRIX   X +//#define MAGIC_KEY_DEBUG_KBD      K +//#define MAGIC_KEY_DEBUG_MOUSE    M +//#define MAGIC_KEY_VERSION        V +//#define MAGIC_KEY_STATUS         S +//#define MAGIC_KEY_CONSOLE        C +//#define MAGIC_KEY_LAYER0_ALT1    ESC +//#define MAGIC_KEY_LAYER0_ALT2    GRAVE +//#define MAGIC_KEY_LAYER0         0 +//#define MAGIC_KEY_LAYER1         1 +//#define MAGIC_KEY_LAYER2         2 +//#define MAGIC_KEY_LAYER3         3 +//#define MAGIC_KEY_LAYER4         4 +//#define MAGIC_KEY_LAYER5         5 +//#define MAGIC_KEY_LAYER6         6 +//#define MAGIC_KEY_LAYER7         7 +//#define MAGIC_KEY_LAYER8         8 +//#define MAGIC_KEY_LAYER9         9 +//#define MAGIC_KEY_BOOTLOADER     PAUSE +//#define MAGIC_KEY_LOCK           CAPS +//#define MAGIC_KEY_EEPROM         E +//#define MAGIC_KEY_NKRO           N +//#define MAGIC_KEY_SLEEP_LED      Z + +/* + * Feature disable options + *  These options are also useful to firmware size reduction. + */ + +/* disable debug print */ +//#define NO_DEBUG + +/* disable print */ +//#define NO_PRINT + +/* disable action features */ +//#define NO_ACTION_LAYER +//#define NO_ACTION_TAPPING +//#define NO_ACTION_ONESHOT +//#define NO_ACTION_MACRO +//#define NO_ACTION_FUNCTION + +/* + * MIDI options + */ + +/* Prevent use of disabled MIDI features in the keymap */ +//#define MIDI_ENABLE_STRICT 1 + +/* enable basic MIDI features: +   - MIDI notes can be sent when in Music mode is on +*/ +//#define MIDI_BASIC + +/* enable advanced MIDI features: +   - MIDI notes can be added to the keymap +   - Octave shift and transpose +   - Virtual sustain, portamento, and modulation wheel +   - etc. +*/ +//#define MIDI_ADVANCED + +/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */ +//#define MIDI_TONE_KEYCODE_OCTAVES 1 diff --git a/keyboards/handwired/ibm122m/ibm122m.c b/keyboards/handwired/ibm122m/ibm122m.c new file mode 100644 index 0000000000..1c52b94ec6 --- /dev/null +++ b/keyboards/handwired/ibm122m/ibm122m.c @@ -0,0 +1,43 @@ +/* Copyright 2018 REPLACE_WITH_YOUR_NAME + * + * 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 "ibm122m.h" + +void matrix_init_kb(void) { +	// put your keyboard start-up code here +	// runs once when the firmware starts up + +	matrix_init_user(); +} + +void matrix_scan_kb(void) { +	// put your looping keyboard code here +	// runs every cycle (a lot) + +	matrix_scan_user(); +} + +bool process_record_kb(uint16_t keycode, keyrecord_t *record) { +	// put your per-action keyboard code here +	// runs for every action, just before processing by the firmware + +	return process_record_user(keycode, record); +} + +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); +} diff --git a/keyboards/handwired/ibm122m/ibm122m.h b/keyboards/handwired/ibm122m/ibm122m.h new file mode 100644 index 0000000000..93e18b4e60 --- /dev/null +++ b/keyboards/handwired/ibm122m/ibm122m.h @@ -0,0 +1,42 @@ +/* Copyright 2018 REPLACE_WITH_YOUR_NAME + * + * 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 "quantum.h" + +// This a shortcut to help you visually see your layout. +// The following is an example using the Planck MIT layout +// The first section contains all of the arguments +// The second converts the arguments into a two-dimensional array +#define LAYOUT( \ +            k09, k19, k1A, k29, k39, k3A, k49, k59, k5A, k69, k79, k7A,             k3G, k3H, k2G, \ +            k0A, k0B, k1B, k2A, k2B, k3B, k4A, k4B, k5B, k6A, k6B, k7B,             k1G, k5G, k4G, \ +k31, k32,   k34, k24, k25, k26, k27, k37, k38, k28, k2C, k2D, k2E, k3E, k3C, k3F,                   k2F, k2H, k2I, k20, \ +k21, k41,   k42, k44, k45, k46, k47, k57, k58, k48, k4C, k4D, k4E, k5E, k5C, k6F,                   k4F, k4H, k4I, k40, \ +k51, k52,   k62, k14, k15, k16, k17, k07, k08, k18, k1C, k1D, k1E, k0E, k6E,                        k1F, k1H, k1I, k10, \ +k11, k12,   k73, k74, k64, k65, k66, k67, k77, k78, k68, k6C, k6D, k7E,      k63,        k0G,       k61, k6H, k6I, k7J, \ +k02, k01,   k00,    k70,                k71,             k03,      k72,             k60, k0J, k1J,  k7H,      k7I, \ +                                                                                         k0F \ +) \ +{ \ +    {   k00,   k01,   k02,   k03,   KC_NO, KC_NO, KC_NO, k07,   k08,   k09,   k0A,   k0B,   KC_NO, KC_NO, k0E,   k0F,   k0G,   KC_NO, KC_NO, k0J   }, \ +    {   k10,   k11,   k12,   KC_NO, k14,   k15,   k16,   k17,   k18,   k19,   k1A,   k1B,   k1C,   k1D,   k1E,   k1F,   k1G,   k1H,   k1I,   k1J   }, \ +    {   k20,   k21,   KC_NO, KC_NO, k24,   k25,   k26,   k27,   k28,   k29,   k2A,   k2B,   k2C,   k2D,   k2E,   k2F,   k2G,   k2H,   k2I,   KC_NO }, \ +    {   KC_NO, k31,   k32,   KC_NO, k34,   KC_NO, KC_NO, k37,   k38,   k39,   k3A,   k3B,   k3C,   KC_NO, k3E,   k3F,   k3G,   k3H,   KC_NO, KC_NO }, \ +    {   k40,   k41,   k42,   KC_NO, k44,   k45,   k46,   k47,   k48,   k49,   k4A,   k4B,   k4C,   k4D,   k4E,   k4F,   k4G,   k4H,   k4I,   KC_NO }, \ +    {   KC_NO, k51,   k52,   KC_NO, KC_NO, KC_NO, KC_NO, k57,   k58,   k59,   k5A,   k5B,   k5C,   KC_NO, k5E,   KC_NO, k5G,   KC_NO, KC_NO, KC_NO }, \ +    {   k60,   k61,   k62,   k63,   k64,   k65,   k66,   k67,   k68,   k69,   k6A,   k6B,   k6C,   k6D,   k6E,   k6F,   KC_NO, k6H,   k6I,   KC_NO }, \ +    {   k70,   k71,   k72,   k73,   k74,   KC_NO, KC_NO, k77,   k78,   k79,   k7A,   k7B,   KC_NO, KC_NO, k7E,   KC_NO, KC_NO, k7H,   k7I,   k7J   }, \ +} diff --git a/keyboards/handwired/ibm122m/info.json b/keyboards/handwired/ibm122m/info.json new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/keyboards/handwired/ibm122m/info.json diff --git a/keyboards/handwired/ibm122m/keymaps/default/config.h b/keyboards/handwired/ibm122m/keymaps/default/config.h new file mode 100644 index 0000000000..0453a72580 --- /dev/null +++ b/keyboards/handwired/ibm122m/keymaps/default/config.h @@ -0,0 +1,19 @@ +/* Copyright 2018 REPLACE_WITH_YOUR_NAME + * + * 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 + +// place overrides below diff --git a/keyboards/handwired/ibm122m/keymaps/default/keymap.c b/keyboards/handwired/ibm122m/keymaps/default/keymap.c new file mode 100644 index 0000000000..633df106e9 --- /dev/null +++ b/keyboards/handwired/ibm122m/keymaps/default/keymap.c @@ -0,0 +1,46 @@ +/* Copyright 2018 REPLACE_WITH_YOUR_NAME + * + * 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 + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { +// Original Layer +[0] = LAYOUT(  +                KC_F13,   KC_F14, KC_F15, KC_F16, KC_F17, KC_F18, KC_F19, KC_F20, KC_F21, KC_F22,   KC_F23,    KC_F24,                     KC_INS, KC_HOME, KC_PGUP, +                KC_F1,    KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_F6,  KC_F7,  KC_F8,  KC_F9,  KC_F10,   KC_F11,    KC_F12,                     KC_DEL, KC_END,  KC_PGDN, +KC_ESC, KC_NO,  KC_GRV,   KC_1,   KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,   KC_9,     KC_0,      KC_MINUS, KC_EQL, KC_BSPC,                            KC_NLCK, KC_PSLS, KC_PAST, KC_PMNS, +KC_NO,  KC_NO,  KC_TAB,   KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,     KC_P,      KC_LBRC,  KC_RBRC,KC_ENTER,                           KC_P7,   KC_P8,   KC_P9,   KC_PPLS, +KC_NO,  KC_NO,  KC_CAPS,  KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,     KC_SCOLON, KC_QUOT,  KC_BSLS,                                    KC_P4,   KC_P5,   KC_P6,   KC_BSPC, +KC_NO,  KC_NO,  KC_LSHIFT,KC_NO,  KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMMA, KC_DOT,    KC_SLSH,  KC_RSFT,                  KC_UP,            KC_P1,   KC_P2,   KC_P3,   KC_PENT, +KC_NO,  KC_NO, KC_LCTRL,  KC_LALT,                                        KC_SPC,                              KC_RALT,  KC_RCTRL,        KC_LEFT, KC_NO, KC_RIGHT,KC_P0,            KC_PDOT,     +                                                                                                                                                   KC_DOWN), +}; + +void matrix_init_user(void) { + +} + +void matrix_scan_user(void) { + +} + +bool process_record_user(uint16_t keycode, keyrecord_t *record) { +       +  return true; +} + +void led_set_user(uint8_t usb_led) { + +} diff --git a/keyboards/handwired/ibm122m/keymaps/default/readme.md b/keyboards/handwired/ibm122m/keymaps/default/readme.md new file mode 100644 index 0000000000..aa592c9739 --- /dev/null +++ b/keyboards/handwired/ibm122m/keymaps/default/readme.md @@ -0,0 +1,2 @@ +# The default keymap for ibm122m2 +The 10 keys to the left of the alphanumerics are unbound (other than Escape on the top-left one) as I have no idea what is supposed to go there.  diff --git a/keyboards/handwired/ibm122m/keymaps/lukaus/config.h b/keyboards/handwired/ibm122m/keymaps/lukaus/config.h new file mode 100644 index 0000000000..bf338e196d --- /dev/null +++ b/keyboards/handwired/ibm122m/keymaps/lukaus/config.h @@ -0,0 +1,19 @@ +/* Copyright 2018 REPLACE_WITH_YOUR_NAME + * + * 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 +// place overrides here + diff --git a/keyboards/handwired/ibm122m/keymaps/lukaus/keymap.c b/keyboards/handwired/ibm122m/keymaps/lukaus/keymap.c new file mode 100644 index 0000000000..02b69bacf0 --- /dev/null +++ b/keyboards/handwired/ibm122m/keymaps/lukaus/keymap.c @@ -0,0 +1,587 @@ +/* Copyright 2018 REPLACE_WITH_YOUR_NAME + * + * 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 + +enum custom_keycodes { +  PLACEHOLDER = SAFE_RANGE,  + +  DVP_ESC, // Grave escape basically i think +  DVP_AMPR, +  DVP_LBRACKET, +  DVP_LCBR, +  DVP_RCBR, +  DVP_LPRN, +  DVP_AT, +  DVP_EQUAL, +  DVP_ASTERISK, +  DVP_RPRN, +  DVP_PLUS, +  DVP_RBRACKET, +  DVP_EXLM, +  DVP_HASH, +  SHFT_DOT, +  SHFT_COMMA +}; + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { +// Programmer's Dvorak +[0] = LAYOUT(  +                        KC_F13,   KC_F14,   KC_F15,       KC_F16,   KC_F17,   KC_F18,   KC_F19,   KC_F20,       KC_F21,   KC_F22,   KC_F23,       KC_F24,                       KC_INS,   KC_HOME, KC_PGUP, +                        KC_F1,    KC_F2,    KC_F3,        KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,        KC_F9,    KC_F10,   KC_F11,       KC_F12,                       KC_DEL,   KC_END,  KC_PGDN, +KC_ESC,     TO(1),      DVP_ESC,  DVP_AMPR, DVP_LBRACKET, DVP_LCBR, DVP_RCBR, DVP_LPRN, DVP_EQUAL,DVP_ASTERISK, DVP_RPRN, DVP_PLUS, DVP_RBRACKET, DVP_EXLM, DVP_HASH, KC_BSPC,                                KC_NLCK, KC_PSLS, KC_PAST, KC_PMNS, +KC_NO,      TO(2),      KC_TAB,   KC_SCOLON,KC_COMMA,     KC_DOT,   KC_P,     KC_Y,     KC_F,     KC_G,         KC_C,     KC_R,     KC_L,         KC_SLSH,  DVP_AT,   KC_ENTER,                               KC_P7,   KC_P8,   KC_P9,   KC_PPLS, +KC_NO,      KC_NO,      MO(3),    KC_A,     KC_O,         KC_E,     KC_U,     KC_I,     KC_D,     KC_H,         KC_T,     KC_N,     KC_S,         KC_MINUS, KC_BSLS,                                          KC_P4,   KC_P5,   KC_P6,   MO(4), +LCTL(KC_F), KC_LALT,    KC_LSHIFT,KC_ESC,   KC_QUOT,      KC_Q,     KC_J,     KC_K,     KC_X,     KC_B,         KC_M,     KC_W,     KC_V,         KC_Z,     KC_RSFT,                      KC_UP,              KC_P1,   KC_P2,   KC_P3,   KC_PENT, +LCTL(KC_C), LCTL(KC_V), KC_LCTRL, KC_LGUI,                                    KC_SPC,                                                             KC_RALT,  KC_RCTRL,           KC_LEFT,  KC_BTN3, KC_RIGHT,  KC_P0,            KC_PDOT,     +                                                                                                                                                                                    KC_DOWN +), + +// Qwerty layer + function +[1] = LAYOUT(  +                KC_F13,   KC_F14, KC_F15, KC_F16, KC_F17, KC_F18, KC_F19, KC_F20, KC_F21, KC_F22,   KC_F23,    KC_F24,                     KC_INS, KC_HOME, KC_PGUP, +                KC_F1,    KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_F6,  KC_F7,  KC_F8,  KC_F9,  KC_F10,   KC_F11,    KC_F12,                     KC_DEL, KC_END,  KC_PGDN, +KC_ESC, TO(0),  KC_GRV,   KC_1,   KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,   KC_9,     KC_0,      KC_MINUS, KC_EQL, KC_BSPC,                            KC_NLCK, KC_PSLS, KC_PAST, KC_PMNS, +KC_NO,  KC_NO,  KC_TAB,   KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,     KC_P,      KC_LBRC,  KC_RBRC,KC_ENTER,                           KC_P7,   KC_P8,   KC_P9,   KC_PPLS, +KC_NO,  KC_NO,  MO(3),    KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,     KC_SCOLON, KC_QUOT,  KC_BSLS,                                    KC_P4,   KC_P5,   KC_P6,   KC_BSPC, +KC_NO,  KC_NO,  KC_LSHIFT,KC_NO,  KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMMA, KC_DOT,    KC_SLSH,  KC_RSFT,                  KC_UP,            KC_P1,   KC_P2,   KC_P3,   KC_PENT, +KC_NO,  KC_LALT,KC_LCTRL, KC_LGUI,                                      KC_SPC,                                KC_RALT,  KC_RCTRL,        KC_LEFT, KC_WH_D, KC_RIGHT,KC_P0,            KC_PDOT,     +                                                                                                                                                  KC_DOWN +), +// Orirginal Layer +[2] = LAYOUT(  +                KC_F13,   KC_F14, KC_F15, KC_F16, KC_F17, KC_F18, KC_F19, KC_F20, KC_F21, KC_F22,   KC_F23,    KC_F24,                     KC_INS, KC_HOME, KC_PGUP, +                KC_F1,    KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_F6,  KC_F7,  KC_F8,  KC_F9,  KC_F10,   KC_F11,    KC_F12,                     KC_DEL, KC_END,  KC_PGDN, +KC_ESC, TO(1),  KC_GRV,   KC_1,   KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,   KC_9,     KC_0,      KC_MINUS, KC_EQL, KC_BSPC,                            KC_NLCK, KC_PSLS, KC_PAST, KC_PMNS, +KC_NO,  TO(0),  KC_TAB,   KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,     KC_P,      KC_LBRC,  KC_RBRC,KC_ENTER,                           KC_P7,   KC_P8,   KC_P9,   KC_PPLS, +KC_NO,  KC_NO,  KC_CAPS,  KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,     KC_SCOLON, KC_QUOT,  KC_BSLS,                                    KC_P4,   KC_P5,   KC_P6,   KC_BSPC, +KC_NO,  KC_NO,  KC_LSHIFT,KC_NO,  KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMMA, KC_DOT,    KC_SLSH,  KC_RSFT,                  KC_UP,            KC_P1,   KC_P2,   KC_P3,   KC_PENT, +KC_NO,  KC_LALT,KC_LCTRL, KC_LGUI,                                        KC_SPC,                              KC_RALT,  KC_RCTRL,        KC_LEFT, KC_WH_D, KC_RIGHT,KC_P0,            KC_PDOT,     +                                                                                                                                                  KC_DOWN +), + +// Function Layer +[3] = LAYOUT(  +                  KC_F1,    KC_F2,  KC_F3,                KC_F4,                KC_F5,                KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10,   KC_F11,     KC_F12,                     KC_INS, KC_HOME, KC_PGUP, +                  KC_F13,   KC_F14, KC_F15,               KC_F16,               KC_F17,               KC_F18,   KC_F19,   KC_F20,   KC_F21,   KC_F22,   KC_F23,     KC_F24,                     KC_DEL, KC_END,  KC_PGDN, +MU_TOG, KC_NO,    KC_ESC,   KC_1,   KC_2,                 KC_3,                 KC_4,                 KC_5,     KC_6,     KC_7,     KC_8,     KC_9,     KC_0,       KC_MINUS, KC_EQL, KC_BSPC,                              KC_NLCK,    KC_PSLS,    KC_PAST,    KC_PMNS, +MU_MOD, KC_NO,    KC_TAB,   KC_NO,  KC_MEDIA_PREV_TRACK,  KC_MEDIA_PLAY_PAUSE,  KC_MEDIA_NEXT_TRACK,  KC_NO,    KC_NO,    KC_PGUP,  KC_DEL,   KC_NO,    KC_NO,      KC_LBRC,  KC_RBRC,KC_ENTER,                             KC_NO,      KC_NO,      KC_NO,      KC_PPLS, +KC_NO,  KC_NO,    KC_TRNS,  KC_NO,  KC_AUDIO_VOL_DOWN,    KC_AUDIO_VOL_UP,      KC_AUDIO_MUTE,        KC_NO,    KC_LEFT,  KC_DOWN,  KC_UP,    KC_RIGHT, KC_SCOLON,  KC_QUOT,  KC_BSLS,                                      LSFT(KC_E), LSFT(KC_F), KC_NO,      KC_BSPC, +KC_NO,  KC_LALT,  KC_LSHIFT,KC_NO,  KC_NO,                KC_NO,                KC_NO,                KC_NO,    KC_NO,    KC_NO,    KC_PGDN,  KC_COMMA, KC_DOT,     KC_SLSH,  KC_RSFT,                    KC_UP,            LSFT(KC_B), LSFT(KC_C), LSFT(KC_D), KC_PENT, +KC_NO,  KC_NO,    KC_LCTRL, KC_LGUI,                                                                            KC_SPC,                                 KC_RALT,    KC_CAPS,                    KC_LEFT,  KC_WH_D, KC_RIGHT,LSFT(KC_A),             KC_PDOT,     +                                                                                                                                                                    KC_DOWN +), +// Literally just the numpad is different +[4] = LAYOUT(  +                        KC_F13,   KC_F14,   KC_F15,       KC_F16,   KC_F17,   KC_F18,   KC_F19,   KC_F20,       KC_F21,   KC_F22,   KC_F23,       KC_F24,                       KC_INS,   KC_HOME, KC_PGUP, +                        KC_F1,    KC_F2,    KC_F3,        KC_F4,    KC_F5,    KC_F6,    KC_F7,    KC_F8,        KC_F9,    KC_F10,   KC_F11,       KC_F12,                       KC_DEL,   KC_END,  KC_PGDN, +KC_ESC,     TO(1),      DVP_ESC,  DVP_AMPR, DVP_LBRACKET, DVP_LCBR, DVP_RCBR, DVP_LPRN, DVP_EQUAL,DVP_ASTERISK, DVP_RPRN, DVP_PLUS, DVP_RBRACKET, DVP_EXLM, DVP_HASH, KC_BSPC,                                KC_NO,    KC_NO,    KC_NO,    KC_NO, +KC_NO,      TO(2),      KC_TAB,   KC_SCOLON,KC_COMMA,     KC_DOT,   KC_P,     KC_Y,     KC_F,     KC_G,         KC_C,     KC_R,     KC_L,         KC_SLSH,  DVP_AT,   KC_ENTER,                               KC_BTN1,  KC_MS_U,  KC_BTN2,  KC_NO, +KC_NO,      KC_NO,      TO(0),    KC_A,     KC_O,         KC_E,     KC_U,     KC_I,     KC_D,     KC_H,         KC_T,     KC_N,     KC_S,         KC_MINUS, KC_BSLS,                                          KC_MS_L,  KC_NO,    KC_MS_R,  KC_TRNS, +LCTL(KC_F), KC_LALT,    KC_LSHIFT,KC_NO,    KC_QUOT,      KC_Q,     KC_J,     KC_K,     KC_X,     KC_B,         KC_M,     KC_W,     KC_V,         KC_Z,     KC_RSFT,                      KC_UP,              KC_GT,    KC_MS_D,  KC_GT,    KC_PENT, +LCTL(KC_C), LCTL(KC_V), KC_LCTRL, KC_LGUI,                                    KC_SPC,                                                             KC_RALT,  KC_RCTRL,           KC_LEFT,  KC_BTN3, KC_RIGHT,  KC_BTN1,            KC_PDOT,     +                                                                                                                                                                                    KC_DOWN +), +/* +[4] = LAYOUT(  +                  KC_F13,   KC_F14, KC_F15, KC_F16, KC_F17, KC_F18, KC_F19, KC_F20, KC_F21, KC_F22,   KC_F23, KC_F24,                     KC_INS, KC_HOME, KC_PGUP, +                  KC_F1,    KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_F6,  KC_F7,  KC_F8,  KC_F9,  KC_F10,   KC_F11, KC_F12,                     KC_DEL, KC_END,  KC_PGDN, +MU_TOG, TO(0),    KC_DLR,   KC_1,   KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,   KC_9,     KC_0,   KC_MINUS, KC_EQL, KC_BSPC,                              KC_NLCK,    KC_PSLS,    KC_PAST,    KC_PMNS, +MU_MOD, KC_NO,    KC_TAB,   KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,    KC_NO,  KC_LBRC,  KC_RBRC,KC_ENTER,                             KC_NO,      KC_NO,      KC_NO,      KC_PPLS, +KC_NO,  KC_NO,    KC_TRNS,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,    KC_NO,  KC_QUOT,  KC_BSLS,                                      LSFT(KC_E), LSFT(KC_F), KC_NO,      KC_BSPC, +KC_NO,  KC_LALT,  KC_LSHIFT,KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_COMMA, KC_DOT, KC_SLSH,  KC_RSFT,                  KC_UP,              LSFT(KC_B), LSFT(KC_C), LSFT(KC_D), KC_PENT, +KC_NO,  KC_LGUI,  KC_LCTRL, KC_LALT,                                                  KC_SPC,                 KC_RALT,  KC_RCTRL,       KC_LEFT,  KC_WH_D, KC_RIGHT,  LSFT(KC_A),             KC_PDOT,     +                                                                                                                                                  KC_DOWN +),*/ +/*[0] = LAYOUT(  +   KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_NO,TO(1),KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1,    +   KC_2, KC_2, KC_2, KC_2, KC_2, KC_2, KC_2, KC_2, KC_2, KC_2, KC_2, TO(2),KC_2, KC_2, KC_2, KC_2, KC_2, KC_2, KC_2, KC_2,    +   KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3, KC_3,    +   KC_4, KC_4, KC_4, KC_4, KC_4, KC_4, KC_4, KC_4, KC_4, KC_4, KC_4, KC_4, KC_4, KC_4, KC_4, KC_BSPC,KC_4,KC_4,KC_4, KC_4,    +   KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5, KC_5,    +   KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6, KC_6,    +   KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7, KC_7,    +   KC_8, KC_SPC,KC_8,KC_8, KC_8, KC_8, KC_8, KC_8, KC_8, KC_8, KC_8, KC_8, KC_8, KC_8, KC_8, KC_8, KC_8, KC_8, KC_8, TO(1)    +   +), +[1] = LAYOUT(  +   KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, KC_H, KC_I, KC_J, TO(0),KC_NO,KC_M, KC_N, KC_O, KC_P, KC_Q, KC_R, KC_S, KC_T,    +   KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, KC_H, KC_I, KC_J, KC_K, TO(2),KC_M, KC_N, KC_O, KC_P, KC_Q, KC_R, KC_S, KC_T,    +   KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, KC_P, KC_Q, KC_R, KC_S, KC_T,    +   KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, KC_BSPC,KC_Q,KC_R,KC_S, KC_T,    +   KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, KC_P, KC_Q, KC_R, KC_S, KC_T,    +   KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, KC_P, KC_Q, KC_R, KC_S, KC_T,    +   KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, KC_P, KC_Q, KC_R, KC_S, KC_T,    +   KC_A, KC_SPC,KC_C,KC_D, KC_E, KC_F, KC_G, KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O, KC_P, KC_Q, KC_R, KC_S, TO(0)    +), +[2] = LAYOUT( +   KC_LCTRL,    KC_LALT,  KC_C,     KC_RALT,    KC_E,       KC_F, KC_G, KC_G, KC_H, KC_J, TO(0),  TO(1),  KC_M,     KC_N,   KC_QUOT,    KC_DOWN,  KC_UP,  KC_R,     KC_S,       KC_ENTER,    +   KC_PPLS,     KC_B,     KC_C,     KC_D,       KC_A,       KC_S, KC_D, KC_F, KC_J, KC_J, KC_K,   KC_NO,  KC_K,     KC_L,   KC_SCOLON,  KC_P4,    KC_DEL, KC_P5,    KC_P6,      KC_RIGHT,    +   KC_PMNS,     KC_1,     KC_C,    KC_D,       KC_1,       KC_2, KC_3, KC_4, KC_7, KC_J, KC_K,   KC_L,   KC_8,     KC_9,   KC_0,       KC_NLCK,  KC_PGUP,KC_PSLS,  KC_PAST,    KC_T,    +   KC_A,        KC_ESC,   TO(0),KC_D,     KC_GRV,     KC_F, KC_G, KC_5, KC_6, KC_J, KC_K,   KC_L,   KC_EQL,   KC_N,   KC_MINUS,   KC_BSPC,  KC_INS, KC_HOME,  KC_S,       KC_T,    +   KC_PPLS,     KC_NO,    KC_TAB,   KC_D,       KC_Q,       KC_W, KC_E, KC_R, KC_U, KC_J, KC_K,   KC_L,   KC_I,     KC_O,   KC_P,       KC_P7,    KC_PGDN,KC_P8,    KC_P9,      KC_T,    +   KC_A,        KC_B,     KC_C,     KC_D,       KC_E,       KC_F, KC_G, KC_T, KC_Y, KC_J, KC_K,   KC_L,   KC_RBRC,  KC_N,   KC_LBRC,    KC_P,     KC_END, KC_R,     KC_S,       KC_T,    +   KC_LEFT,     KC_P1,    KC_CAPS,  KC_RSFT,    KC_Z,       KC_X, KC_C, KC_V, KC_M, KC_J, KC_K,   KC_L,   KC_COMMA, KC_DOT, KC_BSLS,    KC_PENT,  KC_Q,   KC_P2,    KC_P3,      KC_T,    +   KC_LGUI,     KC_SPACE, KC_RCTRL, KC_LSHIFT,  KC_E,       KC_F, KC_G, KC_B, KC_N, KC_J, KC_K,   KC_L,   KC_M,     KC_N,   KC_SLSH,    KC_P,     KC_Q,   KC_P0,    KC_PDOT,    KC_KP_ENTER    +  ),*/ +}; + +const uint16_t PROGMEM fn_actions[] = { + +}; + +const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) +{ +  // MACRODOWN only works in this function +      switch(id) { +        case 0: +          if (record->event.pressed) { +            register_code(KC_RSFT); +          } else { +            unregister_code(KC_RSFT); +          } +        break; +      } +    return MACRO_NONE; +}; + + +void matrix_init_user(void) { + +} + +void matrix_scan_user(void) { + +} + +bool left_shift_down = false;  +bool right_shift_down = false; + +bool process_record_user(uint16_t keycode, keyrecord_t *record) { +     switch (keycode) { +    case KC_LSHIFT: +    if (record->event.pressed) +      { +        left_shift_down = true; +      return true; +      } +      else +      { +        left_shift_down = false; +        return true; +      } +    break; +    case KC_RSHIFT: + +      if (record->event.pressed) +      { +        right_shift_down = true; +      return true; +      } +      else +      { +        right_shift_down = false; +        return true; +      } +    break; +   +   +    case DVP_ESC: +    if (left_shift_down || right_shift_down) +    {   +      if(record->event.pressed) +        SEND_STRING("~"); +      return false; +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("$"); +      return false; +    } +    break; + +    case DVP_AMPR: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        SEND_STRING("%"); + +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("&"); +      return false; +    } +    break;  +   +    case DVP_LBRACKET: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +        { +          if(left_shift_down) +            unregister_code(KC_LSHIFT); +          if(right_shift_down) +            unregister_code(KC_RSHIFT); + +          register_code(KC_7); +          unregister_code(KC_7); + +          if(left_shift_down) +            register_code(KC_LSHIFT); +          if(right_shift_down) +            register_code(KC_RSHIFT); +        } +      return false; +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("["); +      return false; +    } +    break;  +   +    case DVP_LCBR: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +       {  +          if(left_shift_down) +            unregister_code(KC_LSHIFT); +          if(right_shift_down) +            unregister_code(KC_RSHIFT); + +          register_code(KC_5); +          unregister_code(KC_5); +           +          if(left_shift_down) +            register_code(KC_LSHIFT); +          if(right_shift_down) +            register_code(KC_RSHIFT); +        } +      return false; +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("{"); +      return false; +    } +    break;  +    +    case DVP_RCBR: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_3); +        unregister_code(KC_3); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +      return false; +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("}"); +      return false; +    } +    break;  + + +    case DVP_LPRN: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_1); +        unregister_code(KC_1); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    return false; +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("("); +    return false; +    } +    break;  +//    +    case DVP_AT: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_LSHIFT); +        register_code(KC_6); +        unregister_code(KC_6); +        unregister_code(KC_LSHIFT); +           +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    return false; +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("@"); +    return false; +    } +    break;  + +     +    case DVP_EQUAL: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_9); +        unregister_code(KC_9); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    return false; +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("="); +    return false; +    } +    break;  +     +    case DVP_ASTERISK: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_0); +        unregister_code(KC_0); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    return false; +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("*"); +    return false; +    } +    break;  +     +    case DVP_RPRN: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_2); +        unregister_code(KC_2); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    return false; +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING(")"); +    return false; +    } +    break;  + +    case DVP_PLUS: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_4); +        unregister_code(KC_4); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("+"); +    } +    return false; +    break;  +     +    case DVP_RBRACKET: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_6); +        unregister_code(KC_6); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("]"); +    } +    return false; +    break;  +     +    case DVP_EXLM: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_8); +        unregister_code(KC_8); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("!"); +    } +    return false; +    break;  +     +    case DVP_HASH: +    if (left_shift_down || right_shift_down)  +    { +      if(record->event.pressed) +      { +        if(left_shift_down) +          unregister_code(KC_LSHIFT); +        if(right_shift_down) +          unregister_code(KC_RSHIFT); + +        register_code(KC_GRAVE); +        unregister_code(KC_GRAVE); +         +        if(left_shift_down) +          register_code(KC_LSHIFT); +        if(right_shift_down) +          register_code(KC_RSHIFT); +      } +    } +    else +    { +      if(record->event.pressed) +        SEND_STRING("#"); +    } +    return false; +    break;  +     case SHFT_DOT: +      if(record->event.pressed) +        SEND_STRING(">"); +      break; + +    case SHFT_COMMA: +      if(record->event.pressed) +        SEND_STRING("<"); +      break; + +  }  +   +   +   +  return true; +} + +void led_set_user(uint8_t usb_led) { + +} diff --git a/keyboards/handwired/ibm122m/keymaps/lukaus/readme.md b/keyboards/handwired/ibm122m/keymaps/lukaus/readme.md new file mode 100644 index 0000000000..5d3f6abe15 --- /dev/null +++ b/keyboards/handwired/ibm122m/keymaps/lukaus/readme.md @@ -0,0 +1,2 @@ +# Lukaus' for ibm122m2 +Programmer's Dvorak as the default layer with a Qwerty layer that can access a function layer. Also includes the default layout, slightly modified diff --git a/keyboards/handwired/ibm122m/readme.md b/keyboards/handwired/ibm122m/readme.md new file mode 100644 index 0000000000..09dac49c0d --- /dev/null +++ b/keyboards/handwired/ibm122m/readme.md @@ -0,0 +1,16 @@ +# ibm122m + + + +This is a keymap for the IBM Model M 122 key terminal keyboard running on a Teensy 2.0++ +I wired it to weird pins on mine (mainly to accomodate speakers), so make sure to update the pin arrays. + +Keyboard Maintainer: [Luke Stanley](https://github.com/lukexorz)   +Hardware Supported: Teensy 2.0++   +Hardware Availability: https://www.pjrc.com/store/teensypp.html  + +Make example for this keyboard (after setting up your build environment): + +    make handwired/ibm122m:default + +See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information. diff --git a/keyboards/handwired/ibm122m/rules.mk b/keyboards/handwired/ibm122m/rules.mk new file mode 100644 index 0000000000..ba4be67667 --- /dev/null +++ b/keyboards/handwired/ibm122m/rules.mk @@ -0,0 +1,67 @@ +# MCU name +MCU = at90usb1286 +BOOTLOADER = halfKay + +# Processor frequency. +#     This will define a symbol, F_CPU, in all source code files equal to the +#     processor frequency in Hz. You can then use this symbol in your source code to +#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done +#     automatically to create a 32-bit value in your source code. +# +#     This will be an integer division of F_USB below, as it is sourced by +#     F_USB after it has run through any CPU prescalers. Note that this value +#     does not *change* the processor frequency - it should merely be updated to +#     reflect the processor speed set externally so that the code can use accurate +#     software delays. +F_CPU = 16000000 + + +# +# LUFA specific +# +# Target architecture (see library "Board Types" documentation). +ARCH = AVR8 + +# Input clock frequency. +#     This will define a symbol, F_USB, in all source code files equal to the +#     input clock frequency (before any prescaling is performed) in Hz. This value may +#     differ from F_CPU if prescaling is used on the latter, and is required as the +#     raw input clock is fed directly to the PLL sections of the AVR for high speed +#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL' +#     at the end, this will be done automatically to create a 32-bit value in your +#     source code. +# +#     If no clock division is performed on the input clock inside the AVR (via the +#     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 + + +# Boot Section Size in *bytes* +#   Teensy halfKay   512 +#   Teensy++ halfKay 1024 +#   Atmel DFU loader 4096 +#   LUFA bootloader  4096 +#   USBaspLoader     2048 + + +# Build Options +#   change yes to no to disable +# +BOOTMAGIC_ENABLE = no      # Virtual DIP switch configuration(+1000) +MOUSEKEY_ENABLE = yes       # Mouse keys(+4700) +EXTRAKEY_ENABLE = yes       # Audio control and System control(+450) +CONSOLE_ENABLE = yes        # Console for debug(+400) +COMMAND_ENABLE = yes        # Commands for debug and configuration +# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE +SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend +# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work +NKRO_ENABLE = yes            # USB Nkey Rollover +BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality on B7 by default +MIDI_ENABLE = no            # MIDI support (+2400 to 4200, depending on config) +UNICODE_ENABLE = no         # Unicode +BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID +AUDIO_ENABLE = yes           # Audio output on port C6 +FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches | 
