alterNERDtive/qmk_firmware
1
0
Fork 0
Code Pull requests Activity
qmk_firmware/keyboards/contra/keymaps/enigma/keymap.c

625 lines
23 KiB
C
Raw Blame History

/* Copyright 2022 Christopher Swenson
*
* 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 planck_layers {
_ENIGMA,
_QWERTY,
_FN,
_LOWER,
_RAISE
};
enum planck_normal_keycodes {
QWERTY = SAFE_RANGE,
ENIGMA,
EN_A,
EN_B,
EN_C,
EN_D,
EN_E,
EN_F,
EN_G,
EN_H,
EN_I,
EN_J,
EN_K,
EN_L,
EN_M,
EN_N,
EN_O,
EN_P,
EN_Q,
EN_R,
EN_S,
EN_T,
EN_U,
EN_V,
EN_W,
EN_X,
EN_Y,
EN_Z,
EN_RES,
EN_TEST,
EN_DIAG,
EN_BSPC,
EN_SREF,
EN_SROT,
EN_SPOS,
EN_SRIN,
EN_SPLU
};
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Enigma
* ,-----------------------------------------------------------------------------------.
* | Esc | Q | W | E | R | T | Y | U | I | O | P | Bksp |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | Tab | A | S | D | F | G | H | J | K | L | ; | " |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | N | M | , | . | / |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Ctrl | Fn | Alt | GUI |Lower | Space |Raise | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
[_ENIGMA] = LAYOUT_planck_mit(
QK_GESC, EN_Q, EN_W, EN_E, EN_R, EN_T, EN_Y, EN_U, EN_I, EN_O, EN_P, KC_BSPC,
KC_TAB, EN_A, EN_S, EN_D, EN_F, EN_G, EN_H, EN_J, EN_K, EN_L, KC_SCLN, KC_QUOT,
KC_LSFT, EN_Z, EN_X, EN_C, EN_V, EN_B, EN_N, EN_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT,
KC_LCTL, MO(_FN), KC_LGUI, KC_LALT, MO(_LOWER), KC_SPC, MO(_RAISE), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT
),
/* Qwerty
* ,-----------------------------------------------------------------------------------.
* | Esc | Q | W | E | R | T | Y | U | I | O | P | Bksp |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | Tab | A | S | D | F | G | H | J | K | L | ; | " |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | N | M | , | . | / |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Ctrl | Fn | Alt | GUI |Lower | Space |Raise | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
[_QWERTY] = LAYOUT_planck_mit(
QK_GESC, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
KC_TAB, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT,
KC_LCTL, MO(_FN), KC_LGUI, KC_LALT, MO(_LOWER), KC_SPC, MO(_RAISE), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT
),
/* Function
* ,-----------------------------------------------------------------------------------.
* | Boot | Reset| Diag | | | | | | | | Test |Revers|
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | | | | | | | | | | | | |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | |Reflec|Rotors|Posn.s|Rings |Plugs | | |Enigma|Qwerty| | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | | | | | | | | | |
* `-----------------------------------------------------------------------------------'
*/
[_FN] = LAYOUT_planck_mit(
QK_BOOT, EN_RES, EN_DIAG, _______, _______, _______, _______, _______, _______, _______, EN_TEST, EN_BSPC,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, EN_SREF, EN_SROT, EN_SPOS, EN_SRIN, EN_SPLU, _______, _______, QWERTY, ENIGMA, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
),
/* Lower
* ,-----------------------------------------------------------------------------------.
* | ~ | ! | @ | # | $ | % | ^ | & | * | ( | ) | Bksp |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | | | | | | | | _ | + | { | } | | |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | Shift| | | | | | | | | | | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Ctrl | Fn | Alt | GUI |Lower | Space |Raise | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
[_LOWER] = LAYOUT_planck_mit(
KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC,
_______, _______, _______, _______, _______, _______, _______, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE,
KC_LSFT, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
KC_LCTL, _______, KC_LGUI, KC_LALT, _______, KC_SPC, _______, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT
),
/* RAISE
* ,-----------------------------------------------------------------------------------.
* | ` | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | Bksp |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | | | | | | | | - | = | [ | ] | \ |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | Shift| | | | | | | | | | | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Ctrl | Fn | Alt | GUI |Lower | Space |Raise | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
[_RAISE] = LAYOUT_planck_mit(
KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC,
_______, _______, _______, _______, _______, _______, _______, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS,
KC_LSFT, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
KC_LCTL, _______, KC_LGUI, KC_LALT, _______, KC_SPC, _______, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT
),
};
char rotor_definitions[5][26] = {
"EKMFLGDQVZNTOWYHXUSPAIBRCJ",
"AJDKSIRUXBLHWTMCQGZNPYFVOE",
"BDFHJLCPRTXVZNYEIWGAKMUSQO",
"ESOVPZJAYQUIRHXLNFTGKDCMWB",
"VZBRGITYUPSDNHLXAWMJQOFECK"
};
char reflector_definitions[3][26] = {
"EJMZALYXVBWFCRQUONTSPIKHGD",
"YRUHQSLDPXNGOKMIEBFZCWVJAT",
"FVPJIAOYEDRZXWGCTKUQSBNMHL"
};
char notch[5] = "QEVJZ";
typedef struct Settings {
char rotor_order[3];
char rotor_rings[3];
char rotor_positions[3];
char plugs[25];
int plug_count;
char reflector;
} Settings;
typedef struct KeyboardState {
bool is_setting_reflector;
bool is_setting_rotors;
bool is_setting_rotor_positions;
bool is_setting_rotor_rings;
bool is_setting_plugs;
char setting_progress[26];
int setting_index;
Settings current_settings;
Settings default_settings;
} KeyboardState;
int bound(int letter) {
return ((letter % 26) + 26) % 26;
}
char to_char(int letter) {
return 'A' + letter;
}
int to_int(char letter) {
return letter - 'A';
}
char encipher(char letter, Settings *settings) {
int rotor_2_step = settings->rotor_positions[2] == notch[settings->rotor_order[2] - 1];
int rotor_1_step = settings->rotor_positions[1] == notch[settings->rotor_order[1] - 1];
// Advance the third rotor
settings->rotor_positions[2]++;
if (settings->rotor_positions[2] > 'Z') {
settings->rotor_positions[2] -= 26;
}
// Maybe advance the second rotor, including double steps
if (rotor_2_step || rotor_1_step) {
settings->rotor_positions[1]++;
if (settings->rotor_positions[1] > 'Z') {
settings->rotor_positions[1] -= 26;
}
}
// Maybe advance the first rotor
if (rotor_1_step) {
settings->rotor_positions[0]++;
if (settings->rotor_positions[0] > 'Z') {
settings->rotor_positions[0] -= 26;
}
}
// Swap letters on plugboard
for (int i = 0; i < settings->plug_count * 2; i += 2) {
if (letter == settings->plugs[i]) {
letter = settings->plugs[i + 1];
} else if (letter == settings->plugs[i + 1]) {
letter = settings->plugs[i];
}
}
// Rotors (right to left)
for (int rotor_index = 2; rotor_index >= 0; rotor_index--) {
char *rotor_definition = rotor_definitions[settings->rotor_order[rotor_index] - 1];
int position = to_int(settings->rotor_positions[rotor_index]);
int ring = to_int(settings->rotor_rings[rotor_index]);
int char_index = to_int(letter);
letter = to_char(bound(
to_int(rotor_definition[bound(char_index + position - ring)]) + ring - position
));
}
// Swap via reflector
letter = reflector_definitions[to_int(settings->reflector)][to_int(letter)];
// Rotors in reverse (left to right)
for (int rotor_index = 0; rotor_index < 3; rotor_index++) {
char *rotor_definition = rotor_definitions[settings->rotor_order[rotor_index] - 1];
int position = to_int(settings->rotor_positions[rotor_index]);
int ring = to_int(settings->rotor_rings[rotor_index]);
int search_index;
for (search_index = 0; search_index < 26; search_index++) {
if (
rotor_definition[search_index]
== to_char(bound(to_int(letter) - ring + position))
) {
break;
}
}
letter = to_char(bound(search_index - position + ring));
}
// Plugboard again
for (int i = 0; i < settings->plug_count * 2; i += 2) {
if (letter == settings->plugs[i]) {
letter = settings->plugs[i + 1];
} else if (letter == settings->plugs[i + 1]) {
letter = settings->plugs[i];
}
}
return letter;
}
void init_enigma_default(Settings *settings) {
settings->rotor_order[0] = 1;
settings->rotor_rings[0] = 'A';
settings->rotor_positions[0] = 'A';
settings->rotor_order[1] = 2;
settings->rotor_rings[1] = 'A';
settings->rotor_positions[1] = 'A';
settings->rotor_order[2] = 3;
settings->rotor_rings[2] = 'A';
settings->rotor_positions[2] = 'A';
strcpy(settings->plugs, "");
settings->plug_count = 0;
settings->reflector = 'B';
}
void copy_settings(Settings *from, Settings *to) {
to->rotor_order[0] = from->rotor_order[0];
to->rotor_rings[0] = from->rotor_rings[0];
to->rotor_positions[0] = from->rotor_positions[0];
to->rotor_order[1] = from->rotor_order[1];
to->rotor_rings[1] = from->rotor_rings[1];
to->rotor_positions[1] = from->rotor_positions[1];
to->rotor_order[2] = from->rotor_order[2];
to->rotor_rings[2] = from->rotor_rings[2];
to->rotor_positions[2] = from->rotor_positions[2];
strncpy(to->plugs, from->plugs, from->plug_count * 2);
to->plug_count = from->plug_count;
to->reflector = from->reflector;
}
char *rotor_name(int rotor_number) {
if (rotor_number == 1) {
return "I";
} else if (rotor_number == 2) {
return "II";
} else if (rotor_number == 3) {
return "III";
} else if (rotor_number == 4) {
return "IV";
} else if (rotor_number == 5) {
return "V";
}
return "?";
}
void rotors_reverse(Settings *settings) {
int rotor_2_step = settings->rotor_positions[2]
== to_char(bound(to_int(notch[settings->rotor_order[2] - 1]) + 1));
int rotor_1_step = settings->rotor_positions[1]
== to_char(bound(to_int(notch[settings->rotor_order[1] - 1]) + 1));
// Reverse third rotor
settings->rotor_positions[2]--;
if (settings->rotor_positions[2] < 'A') {
settings->rotor_positions[2] += 26;
}
// Maybe reverse second rotor (including double steps)
if (rotor_2_step || rotor_1_step) {
settings->rotor_positions[1]--;
if (settings->rotor_positions[1] < 'A') {
settings->rotor_positions[1] += 26;
}
}
// Maybe recerse first rotor
if (rotor_1_step) {
settings->rotor_positions[0]--;
if (settings->rotor_positions[0] < 'A') {
settings->rotor_positions[0] += 26;
}
}
}
void reset_settings(KeyboardState *state) {
copy_settings(&state->default_settings, &state->current_settings);
}
void set_layer(uint8_t default_layer) {
default_layer_set((layer_state_t)1 << default_layer);
}
void set_backlight(uint8_t mode, uint8_t hue, uint8_t sat, uint8_t val) {
#ifdef RGBLIGHT_ENABLE
rgblight_enable_noeeprom();
rgblight_mode_noeeprom(mode);
rgblight_sethsv_noeeprom(hue, sat, val);
#endif
}
void clear_working_settings(KeyboardState *state) {
state->is_setting_reflector = false;
state->is_setting_rotors = false;
state->is_setting_rotor_positions = false;
state->is_setting_rotor_rings = false;
state->is_setting_plugs = false;
state->setting_index = 0;
set_layer(_ENIGMA);
set_backlight(RGBLIGHT_MODE_STATIC_LIGHT, HSV_RED);
}
void send_settings_string(Settings *settings) {
send_char(settings->reflector);
send_string(". ");
send_string(rotor_name(settings->rotor_order[0]));
send_char(settings->rotor_rings[0]);
send_string("-");
send_string(rotor_name(settings->rotor_order[1]));
send_char(settings->rotor_rings[1]);
send_string("-");
send_string(rotor_name(settings->rotor_order[2]));
send_char(settings->rotor_rings[2]);
send_string(" (");
send_char(settings->rotor_positions[0]);
send_string(", ");
send_char(settings->rotor_positions[1]);
send_string(", ");
send_char(settings->rotor_positions[2]);
send_string(") ");
for (int i = 0; i < settings->plug_count; i++) {
send_char(settings->plugs[i * 2]);
send_char(settings->plugs[i * 2 + 1]);
send_string(" ");
}
send_string("\n");
}
void perform_test(Settings *settings) {
for (int i = 0; i < 1000; i++) {
send_char(encipher('A', settings) - ('A' - 'a'));
}
}
void commit_plug_settings(KeyboardState *state) {
state->default_settings.plug_count = state->setting_index / 2;
for (int i = 0; i < state->default_settings.plug_count; i++) {
state->default_settings.plugs[i * 2] = state->setting_progress[i * 2];
state->default_settings.plugs[i * 2 + 1] = state->setting_progress[i * 2 + 1];
}
reset_settings(state);
clear_working_settings(state);
}
void handle_set_reflector(char letter, KeyboardState *state) {
if (letter >= 'A' && letter <= 'C') {
state->default_settings.reflector = letter;
reset_settings(state);
clear_working_settings(state);
}
}
bool handle_set_rotor(char letter, KeyboardState *state) {
bool is_valid = letter >= 'A' && letter <= 'E' && state->setting_index < 3;
if (is_valid) {
state->setting_progress[state->setting_index] = to_int(letter) + 1;
state->setting_index += 1;
if (state->setting_index == 3) {
state->default_settings.rotor_order[0] = state->setting_progress[0];
state->default_settings.rotor_order[1] = state->setting_progress[1];
state->default_settings.rotor_order[2] = state->setting_progress[2];
reset_settings(state);
clear_working_settings(state);
}
}
return is_valid;
}
bool handle_set_rotor_position(char letter, KeyboardState *state) {
bool is_valid = state->setting_index < 3; // Guaranteed to be A-Z already
if (is_valid) {
state->setting_progress[state->setting_index] = letter;
state->setting_index += 1;
if (state->setting_index == 3) {
state->default_settings.rotor_positions[0] = state->setting_progress[0];
state->default_settings.rotor_positions[1] = state->setting_progress[1];
state->default_settings.rotor_positions[2] = state->setting_progress[2];
reset_settings(state);
clear_working_settings(state);
}
}
return is_valid;
}
bool handle_set_rotor_ring(char letter, KeyboardState *state) {
bool is_valid = state->setting_index < 3;
if (is_valid) {
state->setting_progress[state->setting_index] = letter;
state->setting_index += 1;
if (state->setting_index == 3) {
state->default_settings.rotor_rings[0] = state->setting_progress[0];
state->default_settings.rotor_rings[1] = state->setting_progress[1];
state->default_settings.rotor_rings[2] = state->setting_progress[2];
reset_settings(state);
clear_working_settings(state);
}
}
return is_valid;
}
bool handle_set_plug(char letter, KeyboardState *state) {
bool is_valid = state->setting_index < 26;
if (is_valid) {
state->setting_progress[state->setting_index] = letter;
state->setting_index += 1;
}
return is_valid;
}
void handle_enigma_keypress(char letter, bool any_mods, KeyboardState *state) {
bool settings_valid = true;
if (letter) {
if (any_mods) {
tap_code(KC_A + to_int(letter));
} else if (state->is_setting_reflector) {
handle_set_reflector(letter, state);
} else if (state->is_setting_rotors) {
settings_valid = handle_set_rotor(letter, state);
} else if (state->is_setting_rotor_positions) {
settings_valid = handle_set_rotor_position(letter, state);
} else if (state->is_setting_rotor_rings) {
settings_valid = handle_set_rotor_ring(letter, state);
} else if (state->is_setting_plugs) {
settings_valid = handle_set_plug(letter, state);
} else {
char c2 = encipher(letter, &state->current_settings);
send_char(c2 - ('A' - 'a'));
}
}
if (!settings_valid) {
clear_working_settings(state);
}
}
KeyboardState STATE;
void keyboard_pre_init_user(void) {
init_enigma_default(&STATE.default_settings);
init_enigma_default(&STATE.current_settings);
clear_working_settings(&STATE);
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
uint8_t letter_index;
bool letter_found = false;
if (record->event.pressed) {
switch (keycode) {
case QWERTY:
set_layer(_QWERTY);
set_backlight(RGBLIGHT_MODE_RAINBOW_SWIRL + 4, HSV_PURPLE);
break;
case ENIGMA:
set_layer(_ENIGMA);
set_backlight(RGBLIGHT_MODE_STATIC_LIGHT, HSV_RED);
break;
case EN_SREF:
reset_settings(&STATE);
STATE.is_setting_reflector = true;
set_layer(_ENIGMA);
set_backlight(RGBLIGHT_MODE_SNAKE, HSV_RED);
break;
case EN_SROT:
reset_settings(&STATE);
STATE.is_setting_rotors = true;
STATE.setting_index = 0;
set_layer(_ENIGMA);
set_backlight(RGBLIGHT_MODE_SNAKE, 10, 255, 255);
break;
case EN_SPOS:
reset_settings(&STATE);
STATE.is_setting_rotor_positions = true;
STATE.setting_index = 0;
set_layer(_ENIGMA);
set_backlight(RGBLIGHT_MODE_SNAKE, HSV_ORANGE);
break;
case EN_SRIN:
reset_settings(&STATE);
STATE.is_setting_rotor_rings = true;
STATE.setting_index = 0;
set_layer(_ENIGMA);
set_backlight(RGBLIGHT_MODE_SNAKE, HSV_GREEN);
break;
case EN_SPLU:
reset_settings(&STATE);
STATE.is_setting_plugs = true;
STATE.setting_index = 0;
set_layer(_ENIGMA);
set_backlight(RGBLIGHT_MODE_SNAKE, HSV_BLUE);
break;
case QK_GESC:
if (
STATE.is_setting_reflector
|| STATE.is_setting_rotors
|| STATE.is_setting_rotor_positions
|| STATE.is_setting_rotor_rings
|| STATE.is_setting_plugs
) {
clear_working_settings(&STATE);
return false;
}
break;
case KC_ENT:
if (STATE.is_setting_plugs) {
commit_plug_settings(&STATE);
return false;
}
break;
case EN_A ... EN_Z:
letter_index = keycode - EN_A;
letter_found = true;
break;
case EN_RES:
reset_settings(&STATE);
break;
case EN_TEST:
perform_test(&STATE.current_settings);
break;
case EN_DIAG:
send_settings_string(&STATE.current_settings);
break;
case EN_BSPC:
rotors_reverse(&STATE.current_settings);
tap_code(KC_BSPC);
break;
}
}
char letter = letter_found ? 'A' + letter_index : 0;
uint8_t mods = get_mods();
bool any_mods = (mods & MOD_MASK_CTRL) || (mods & MOD_MASK_ALT) || (mods & MOD_MASK_GUI);
handle_enigma_keypress(letter, any_mods, &STATE);
return true;
}
void keyboard_post_init_user(void) {
set_layer(_QWERTY);
set_backlight(RGBLIGHT_MODE_RAINBOW_SWIRL + 4, HSV_PURPLE);
}
View git blame Copy permalink