@ -0,0 +1,103 @@ | |||
/* Copyright 2020 ZSA Technology Labs, Inc <@zsa> | |||
* Copyright 2020 Jack Humbert <jack.humb@gmail.com> | |||
* Copyright 2020 Drashna Jael're <drashna@live.com> | |||
* | |||
* 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 */ | |||
// clang-format off | |||
#define VENDOR_ID 0x3297 | |||
#define PRODUCT_ID 0x1969 | |||
#define MANUFACTURER ZSA Technology Labs | |||
#define PRODUCT Moonlander Mark I | |||
#define DEVICE_VER 0x0001 | |||
#define WEBUSB_LANDING_PAGE_URL u8"configure.ergodox-ez.com" | |||
// clang-format on | |||
/* key matrix size */ | |||
#define MATRIX_ROWS 12 | |||
#define MATRIX_COLS 7 | |||
/* PCB default pin-out */ | |||
// #define MATRIX_ROW_PINS { B10, B11, B12, B13, B14, B15 } | |||
// #define MATRIX_COL_PINS { A0, A1, A2, A3, A6, A7, B0 } | |||
// #define MCP23_ROW_PINS { GPB5, GBP4, GBP3, GBP2, GBP1, GBP0 } | |||
// #define MCP23_COL_PINS { GPA0, GBA1, GBA2, GBA3, GBA4, GBA5, GBA6 } | |||
// #define MCP23_LED_R GPB7 | |||
// #define MCP23_LED_G GPB6 | |||
// #define MCP23_LED_B GPA7 | |||
#define EEPROM_I2C_24LC128 | |||
// Not needed, is default address: | |||
// #define EXTERNAL_EEPROM_I2C_BASE_ADDRESS 0b10100000 | |||
/* COL2ROW or ROW2COL */ | |||
#define DIODE_DIRECTION ROW2COL | |||
/* Set 0 if debouncing isn't needed */ | |||
#define DEBOUNCE 5 | |||
/* 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 | |||
/* | |||
* 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 | |||
#define DRIVER_ADDR_1 0b1110100 | |||
#define DRIVER_ADDR_2 0b1110111 | |||
#define DRIVER_COUNT 2 | |||
#define DRIVER_1_LED_TOTAL 36 | |||
#define DRIVER_2_LED_TOTAL 36 | |||
#define DRIVER_LED_TOTAL (DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL) | |||
#define RGB_MATRIX_CENTER { 125, 26 } | |||
#define RGB_MATRIX_MAXIMUM_BRIGHTNESS 175 | |||
#define RGB_MATRIX_FRAMEBUFFER_EFFECTS | |||
#define RGB_MATRIX_KEYPRESSES | |||
#define RGB_DISABLE_WHEN_USB_SUSPENDED true | |||
#define MUSIC_MAP | |||
#define FIRMWARE_VERSION_SIZE 17 | |||
#define DYNAMIC_KEYMAP_EEPROM_ADDR (EECONFIG_SIZE + FIRMWARE_VERSION_SIZE) | |||
#ifdef EEPROM_I2C | |||
# define DYNAMIC_KEYMAP_EEPROM_MAX_ADDR 16383 | |||
# define DYNAMIC_KEYMAP_LAYER_COUNT 32 | |||
#endif |
@ -0,0 +1,31 @@ | |||
{ | |||
"keyboard_name": "Moonlander Mark I", | |||
"url": "zsa.io/moonlander", | |||
"maintainer": "ZSA via Drashna", | |||
"manufacturer": "ZSA Technology Labs Inc", | |||
"width": 17, | |||
"height": 8, | |||
"layouts": { | |||
"LAYOUT_moonlander": { | |||
"layout": [ | |||
{"x":0, "y":0.375}, {"x":1, "y":0.375}, {"x":2, "y":0.125}, {"x":3, "y":0}, {"x":4, "y":0.125}, {"x":5, "y":0.25}, {"x":6, "y":0.25}, | |||
{"x":10, "y":0.25}, {"x":11, "y":0.25}, {"x":12, "y":0.125}, {"x":13, "y":0}, {"x":14, "y":0.125}, {"x":15, "y":0.375}, {"x":16, "y":0.375}, | |||
{"x":0, "y":1.375}, {"x":1, "y":1.375}, {"x":2, "y":1.125}, {"x":3, "y":1}, {"x":4, "y":1.125}, {"x":5, "y":1.25}, {"x":6, "y":1.25}, | |||
{"x":10, "y":1.25}, {"x":11, "y":1.25}, {"x":12, "y":1.125}, {"x":13, "y":1}, {"x":14, "y":1.125}, {"x":15, "y":1.375}, {"x":16, "y":1.375}, | |||
{"x":0, "y":2.375}, {"x":1, "y":2.375}, {"x":2, "y":2.125}, {"x":3, "y":2}, {"x":4, "y":2.125}, {"x":5, "y":2.25}, {"x":6, "y":2.25}, | |||
{"x":10, "y":2.25}, {"x":11, "y":2.25}, {"x":12, "y":2.125}, {"x":13, "y":2}, {"x":14, "y":2.125}, {"x":15, "y":2.375}, {"x":16, "y":2.375}, | |||
{"x":0, "y":3.375}, {"x":1, "y":3.375}, {"x":2, "y":3.125}, {"x":3, "y":3}, {"x":4, "y":3.125}, {"x":5, "y":3.25}, | |||
{"x":11, "y":3.25}, {"x":12, "y":3.125}, {"x":13, "y":3}, {"x":14, "y":3.125}, {"x":15, "y":3.375}, {"x":16, "y":3.375}, | |||
{"x":0, "y":4.375}, {"x":1, "y":4.375}, {"x":2, "y":4.125}, {"x":3, "y":4}, {"x":4, "y":4.125}, {"x":5, "y":4.5, "w":2}, | |||
{"x":10, "y":4.5, "w":2}, {"x":12, "y":4.125}, {"x":13, "y":4}, {"x":14, "y":4.125}, {"x":15, "y":4.375}, {"x":16, "y":4.375}, | |||
{"x":5, "y":5.5, "h":1.5}, {"x":6, "y":5.5, "h":1.5}, {"x":7, "y":5.5, "h":1.5}, {"x":9, "y":5.5, "h":1.5}, {"x":10, "y":5.5, "h":1.5}, {"x":11, "y":5.5, "h":1.5} | |||
] | |||
} | |||
} | |||
} |
@ -0,0 +1,21 @@ | |||
/* Copyright 2020 ZSA Technology Labs, Inc <@zsa> | |||
* Copyright 2020 Jack Humbert <jack.humb@gmail.com> | |||
* Copyright 2020 Drashna Jael're <drashna@live.com> | |||
* | |||
* 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 | |||
#define ORYX_CONFIGURATOR |
@ -0,0 +1,109 @@ | |||
/* Copyright 2020 ZSA Technology Labs, Inc <@zsa> | |||
* Copyright 2020 Jack Humbert <jack.humb@gmail.com> | |||
* Copyright 2020 Drashna Jael're <drashna@live.com> | |||
* | |||
* 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 "version.h" | |||
enum layers { | |||
BASE, // default layer | |||
SYMB, // symbols | |||
MDIA, // media keys | |||
}; | |||
enum custom_keycodes { | |||
VRSN = ML_SAFE_RANGE, | |||
}; | |||
// clang-format off | |||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
[BASE] = LAYOUT_moonlander( | |||
KC_EQL, KC_1, KC_2, KC_3, KC_4, KC_5, KC_LEFT, KC_RGHT, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, | |||
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, TG(SYMB), TG(SYMB), KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSLS, | |||
KC_BSPC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_HYPR, KC_MEH, KC_H, KC_J, KC_K, KC_L, LT(MDIA, KC_SCLN), GUI_T(KC_QUOT), | |||
KC_LSFT, LCTL_T(KC_Z),KC_X,KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, LCTL_T(KC_SLSH), KC_LSFT, | |||
LT(SYMB,KC_GRV),WEBUSB_PAIR,A(KC_LSFT),KC_LEFT, KC_RGHT, LALT_T(KC_APP), RCTL_T(KC_ESC), KC_UP, KC_DOWN, KC_LBRC, KC_RBRC, TT(SYMB), | |||
KC_SPC, KC_BSPC, KC_LGUI, KC_RALT, KC_TAB, KC_ENT | |||
), | |||
[SYMB] = LAYOUT_moonlander( | |||
VRSN, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_TRNS, KC_TRNS, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, | |||
KC_TRNS, KC_EXLM, KC_AT, KC_LCBR, KC_RCBR, KC_PIPE, KC_TRNS, KC_TRNS, KC_UP, KC_7, KC_8, KC_9, KC_ASTR, KC_F12, | |||
KC_TRNS, KC_HASH, KC_DLR, KC_LPRN, KC_RPRN, KC_GRV, KC_TRNS, KC_TRNS, KC_DOWN, KC_4, KC_5, KC_6, KC_PLUS, KC_TRNS, | |||
KC_TRNS, KC_PERC, KC_CIRC, KC_LBRC, KC_RBRC, KC_TILD, KC_AMPR, KC_1, KC_2, KC_3, KC_BSLS, KC_TRNS, | |||
EEP_RST, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RGB_VAI, RGB_TOG, KC_TRNS, KC_DOT, KC_0, KC_EQL, KC_TRNS, | |||
RGB_HUD, RGB_VAD, RGB_HUI, TOGGLE_LAYER_COLOR,KC_TRNS, KC_TRNS | |||
), | |||
[MDIA] = LAYOUT_moonlander( | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_MS_U, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_MS_L, KC_MS_D, KC_MS_R, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_MPLY, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_MPRV, KC_MNXT, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_BTN1, KC_BTN2, KC_TRNS, KC_TRNS, KC_VOLU, KC_VOLD, KC_MUTE, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS | |||
), | |||
}; | |||
layer_state_t layer_state_set_user(layer_state_t state) { | |||
ML_LED_1(false); | |||
ML_LED_2(false); | |||
ML_LED_3(false); | |||
ML_LED_4(false); | |||
ML_LED_5(false); | |||
ML_LED_6(false); | |||
switch (get_highest_layer(state)) { | |||
case 1: | |||
ML_LED_1(1); | |||
ML_LED_4(1); | |||
break; | |||
case 2: | |||
ML_LED_2(1); | |||
ML_LED_5(1); | |||
break; | |||
case 3: | |||
ML_LED_3(1); | |||
break; | |||
case 4: | |||
ML_LED_4(1); | |||
break; | |||
case 5: | |||
ML_LED_5(1); | |||
break; | |||
case 6: | |||
ML_LED_6(1); | |||
break; | |||
default: | |||
break; | |||
} | |||
return state; | |||
} | |||
bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
if (record->event.pressed) { | |||
switch (keycode) { | |||
case VRSN: | |||
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION); | |||
return false; | |||
} | |||
} | |||
return true; | |||
} |
@ -0,0 +1,21 @@ | |||
/* Copyright 2020 Drashna Jael're <drashna@live.com> | |||
* | |||
* 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 | |||
#define TAPPING_TERM_PER_KEY |
@ -0,0 +1,279 @@ | |||
/* Copyright 2020 Drashna Jael're <drashna@live.com> | |||
* | |||
* 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 "drashna.h" | |||
#ifndef UNICODE_ENABLE | |||
# define UC(x) KC_NO | |||
#endif | |||
enum more_custom_keycodes { KC_SWAP_NUM = NEW_SAFE_RANGE }; | |||
// clang-format off | |||
#define LAYOUT_moonlander_wrapper(...) LAYOUT_moonlander(__VA_ARGS__) | |||
#define LAYOUT_moonlander_base( \ | |||
K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, \ | |||
K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, \ | |||
K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A \ | |||
) \ | |||
LAYOUT_moonlander_wrapper( \ | |||
KC_ESC, ________________NUMBER_LEFT________________, UC_FLIP, UC_TABL, ________________NUMBER_RIGHT_______________, KC_MINS, \ | |||
KC_TAB, K01, K02, K03, K04, K05, TG(_DIABLO),TG(_DIABLO), K06, K07, K08, K09, K0A, KC_BSLS, \ | |||
KC_C1R3, K11, K12, K13, K14, K15, TG(_GAMEPAD),TG(_GAMEPAD), K16, K17, K18, K19, K1A, RALT_T(KC_QUOT), \ | |||
KC_MLSF, CTL_T(K21), K22, K23, K24, K25, K26, K27, K28, K29, RCTL_T(K2A),KC_MRSF, \ | |||
KC_GRV, OS_MEH, OS_HYPR, KC_LBRC, KC_RBRC, KC_NO, KC_DEL, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, UC(0x2E2E), \ | |||
KC_SPC, BK_LWER, OS_LALT, OS_RGUI, DL_RAIS, KC_ENT \ | |||
) | |||
#define LAYOUT_moonlander_base_wrapper(...) LAYOUT_moonlander_base(__VA_ARGS__) | |||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
[_QWERTY] = LAYOUT_moonlander_base_wrapper( | |||
_________________QWERTY_L1_________________, _________________QWERTY_R1_________________, | |||
_________________QWERTY_L2_________________, _________________QWERTY_R2_________________, | |||
_________________QWERTY_L3_________________, _________________QWERTY_R3_________________ | |||
), | |||
[_COLEMAK] = LAYOUT_moonlander_base_wrapper( | |||
_________________COLEMAK_L1________________, _________________COLEMAK_R1________________, | |||
_________________COLEMAK_L2________________, _________________COLEMAK_R2________________, | |||
_________________COLEMAK_L3________________, _________________COLEMAK_R3________________ | |||
), | |||
[_DVORAK] = LAYOUT_moonlander_base_wrapper( | |||
_________________DVORAK_L1_________________, _________________DVORAK_R1_________________, | |||
_________________DVORAK_L2_________________, _________________DVORAK_R2_________________, | |||
_________________DVORAK_L3_________________, _________________DVORAK_R3_________________ | |||
), | |||
[_WORKMAN] = LAYOUT_moonlander_base_wrapper( | |||
_________________WORKMAN_L1________________, _________________WORKMAN_R1________________, | |||
_________________WORKMAN_L2________________, _________________WORKMAN_R2________________, | |||
_________________WORKMAN_L3________________, _________________WORKMAN_R3________________ | |||
), | |||
[_NORMAN] = LAYOUT_moonlander_base_wrapper( | |||
_________________NORMAN_L1_________________, _________________NORMAN_L1_________________, | |||
_________________NORMAN_L2_________________, _________________NORMAN_R2_________________, | |||
_________________NORMAN_L3_________________, _________________NORMAN_R3_________________ | |||
), | |||
[_MALTRON] = LAYOUT_moonlander_base_wrapper( | |||
_________________MALTRON_L1________________, _________________MALTRON_R1________________, | |||
_________________MALTRON_L2________________, _________________MALTRON_R2________________, | |||
_________________MALTRON_L3________________, _________________MALTRON_R3________________ | |||
), | |||
[_EUCALYN] = LAYOUT_moonlander_base_wrapper( | |||
_________________EUCALYN_L1________________, _________________EUCALYN_R1________________, | |||
_________________EUCALYN_L2________________, _________________EUCALYN_R2________________, | |||
_________________EUCALYN_L3________________, _________________EUCALYN_R3________________ | |||
), | |||
[_CARPLAX] = LAYOUT_moonlander_base_wrapper( | |||
_____________CARPLAX_QFMLWY_L1_____________, _____________CARPLAX_QFMLWY_R1_____________, | |||
_____________CARPLAX_QFMLWY_L2_____________, _____________CARPLAX_QFMLWY_R2_____________, | |||
_____________CARPLAX_QFMLWY_L3_____________, _____________CARPLAX_QFMLWY_R3_____________ | |||
), | |||
#ifdef _MODS | |||
[_MODS] = LAYOUT_moonlander_wrapper( | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
KC_LSFT, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_RSFT, | |||
_______, KC_MEH, KC_HYPR, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
KC_LALT, _______, _______, _______, _______, KC_RGUI | |||
), | |||
#endif | |||
[_GAMEPAD] = LAYOUT_moonlander_wrapper( | |||
KC_ESC, KC_NO, KC_1, KC_2, KC_3, KC_4, HYPR(KC_Q), KC_TRNS, KC_F9, KC_F10, KC_F11, KC_F12, KC_NO, KC_NO, | |||
KC_F1, KC_K, KC_Q, KC_W, KC_E, KC_R, KC_T, UC_SHRG, UC_DISA, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, | |||
KC_TAB, KC_G, KC_A, KC_S, KC_D, KC_F, KC_TRNS, TG(_GAMEPAD), KC_I, KC_O, KC_NO, KC_NO, KC_NO, KC_NO, | |||
KC_LCTL, KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_N, KC_M, KC_NO, KC_NO, KC_NO, KC_NO, | |||
KC_GRV, KC_U, KC_I, KC_Y, KC_T, KC_PSCR, _______, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, KC_NO, | |||
KC_V, KC_SPC, KC_H, KC_NO, KC_NO, KC_SWAP_NUM | |||
), | |||
[_DIABLO] = LAYOUT_moonlander_wrapper( | |||
KC_ESC, KC_V, KC_D, KC_LALT, KC_NO, KC_NO, KC_NO, KC_TRNS, KC_F9, KC_F10, KC_F11, KC_F12, KC_NO, KC_NO, | |||
KC_TAB, KC_S, KC_I, KC_F, KC_M, KC_T, KC_TRNS, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, | |||
KC_NO, KC_1, KC_2, KC_3, KC_4, KC_G, KC_TRNS, KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, | |||
KC_LCTL, KC_D3_1, KC_D3_2, KC_D3_3, KC_D3_4, KC_Z, KC_N, KC_M, KC_NO, KC_NO, KC_NO, KC_NO, | |||
KC_NO, KC_NO, KC_L, KC_J, KC_F, KC_PSCR, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, | |||
KC_DIABLO_CLEAR, SFT_T(KC_SPACE), ALT_T(KC_Q), KC_PGDN, KC_DEL, KC_ENT | |||
), | |||
[_LOWER] = LAYOUT_moonlander_wrapper( | |||
KC_F12, _________________FUNC_LEFT_________________, _______, _______, _________________FUNC_RIGHT________________, KC_F11, | |||
_______, _________________LOWER_L1__________________, _______, _______, _________________LOWER_R1__________________, KC_PIPE, | |||
_______, _________________LOWER_L2__________________, _______, _______, _________________LOWER_R2__________________, KC_DQUO, | |||
_______, _________________LOWER_L3__________________, _________________LOWER_R3__________________, KC_PSCR, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_PAUS, | |||
_______, _______, _______, _______, _______, _______ | |||
), | |||
[_RAISE] = LAYOUT_moonlander_wrapper( | |||
KC_F12, _________________FUNC_LEFT_________________, _______, _______, _________________FUNC_RIGHT________________, KC_F11, | |||
_______, _________________RAISE_L1__________________, _______, _______, _________________RAISE_R1__________________, KC_BSLS, | |||
_______, _________________RAISE_L2__________________, _______, _______, _________________RAISE_R2__________________, KC_QUOT, | |||
_______, _________________RAISE_L3__________________, _________________RAISE_R3__________________, KC_PSCR, | |||
_______, _______, _______, _______, _______, _______, _______, KC_HOME, KC_PGDN, KC_PGUP, KC_END, KC_PAUS, | |||
_______, _______, _______, _______, _______, _______ | |||
), | |||
[_ADJUST] = LAYOUT_moonlander_wrapper( | |||
KC_MAKE, _________________FUNC_LEFT_________________, UC_MOD, KC_NUKE, _________________ADJUST_R1_________________, KC_RST, | |||
VRSN, _________________ADJUST_L1_________________, _______, _______, _________________ADJUST_R1_________________, EEP_RST, | |||
_______, _________________ADJUST_L2_________________, _______, _______, _________________ADJUST_R2_________________, RGB_IDL, | |||
_______, _________________ADJUST_L3_________________, _________________ADJUST_R3_________________, TG_MODS, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_PAUS, | |||
_______, _______, _______, _______, _______, _______ | |||
), | |||
}; | |||
/* Blank | |||
[_LAYER] = LAYOUT_moonlander_wrapper( | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______ | |||
), | |||
*/ | |||
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { | |||
switch (keycode) { | |||
case KC_1: | |||
if (layer_state_is(_GAMEPAD) && userspace_config.swapped_numbers) { | |||
if (record->event.pressed) { | |||
register_code(KC_2); | |||
} else { | |||
unregister_code(KC_2); | |||
} | |||
return false; | |||
} | |||
break; | |||
case KC_2: | |||
if (layer_state_is(_GAMEPAD) && userspace_config.swapped_numbers) { | |||
if (record->event.pressed) { | |||
register_code(KC_1); | |||
} else { | |||
unregister_code(KC_1); | |||
} | |||
return false; | |||
} | |||
break; | |||
case KC_SWAP_NUM: | |||
if (record->event.pressed) { | |||
userspace_config.swapped_numbers ^= 1; | |||
eeconfig_update_user(userspace_config.raw); | |||
unregister_code(KC_1); | |||
unregister_code(KC_2); | |||
} | |||
break; | |||
} | |||
return true; | |||
} | |||
#ifdef RGB_MATRIX_ENABLE | |||
# ifndef RGB_MATRIX_INDICATOR_SET_COLOR | |||
# define RGB_MATRIX_INDICATOR_SET_COLOR(i, r, g, b) rgb_matrix_set_color(i, r, g, b) | |||
void rgb_matrix_indicators_user(void) { | |||
#else | |||
void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) { | |||
# endif | |||
if (g_suspend_state || !rgb_matrix_config.enable) return; | |||
if (layer_state_is(_GAMEPAD)) { | |||
RGB_MATRIX_INDICATOR_SET_COLOR(11, 0x00, 0xFF, 0x00); // Q | |||
RGB_MATRIX_INDICATOR_SET_COLOR(16, 0x00, 0xFF, 0xFF); // W | |||
RGB_MATRIX_INDICATOR_SET_COLOR(21, 0xFF, 0x00, 0x00); // E | |||
RGB_MATRIX_INDICATOR_SET_COLOR(26, 0xFF, 0x80, 0x00); // R | |||
RGB_MATRIX_INDICATOR_SET_COLOR(12, 0x00, 0xFF, 0xFF); // A | |||
RGB_MATRIX_INDICATOR_SET_COLOR(17, 0x00, 0xFF, 0xFF); // S | |||
RGB_MATRIX_INDICATOR_SET_COLOR(22, 0x00, 0xFF, 0xFF); // D | |||
RGB_MATRIX_INDICATOR_SET_COLOR(27, 0x7A, 0x00, 0xFF); // F | |||
RGB_MATRIX_INDICATOR_SET_COLOR((userspace_config.swapped_numbers ? 10 : 15), 0xFF, 0xFF, 0xFF); // 1 | |||
RGB_MATRIX_INDICATOR_SET_COLOR((userspace_config.swapped_numbers ? 15 : 10), 0x00, 0xFF, 0x00); // 2 | |||
RGB_MATRIX_INDICATOR_SET_COLOR(20, 0x7A, 0x00, 0xFF); // 3 | |||
} | |||
if (userspace_config.rgb_layer_change) { | |||
switch (get_highest_layer(layer_state|default_layer_state)) { | |||
case _QWERTY: | |||
rgb_matrix_layer_helper(HSV_CYAN, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
case _COLEMAK: | |||
rgb_matrix_layer_helper(HSV_MAGENTA, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
case _DVORAK: | |||
rgb_matrix_layer_helper(HSV_SPRINGGREEN, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
case _WORKMAN: | |||
rgb_matrix_layer_helper(HSV_GOLDENROD, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
case _NORMAN: | |||
rgb_matrix_layer_helper(HSV_CORAL, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
case _MALTRON: | |||
rgb_matrix_layer_helper(HSV_YELLOW, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
case _EUCALYN: | |||
rgb_matrix_layer_helper(HSV_PINK, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
case _CARPLAX: | |||
rgb_matrix_layer_helper(HSV_BLUE, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
case _GAMEPAD: | |||
rgb_matrix_layer_helper(HSV_ORANGE, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
case _DIABLO: | |||
rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed * 8, LED_FLAG_MODIFIER); | |||
break; | |||
case _RAISE: | |||
rgb_matrix_layer_helper(HSV_YELLOW, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
case _LOWER: | |||
rgb_matrix_layer_helper(HSV_GREEN, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
case _ADJUST: | |||
rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); | |||
break; | |||
} | |||
} | |||
} | |||
#endif | |||
#ifdef TAPPING_TERM_PER_KEY | |||
uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { | |||
if (keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) { | |||
if (mod_config(keycode & 0xf) & MOD_MASK_ALT) { | |||
return (2 * TAPPING_TERM); | |||
} | |||
} | |||
return TAPPING_TERM; | |||
} | |||
#endif |
@ -0,0 +1,4 @@ | |||
TAP_DANCE_ENABLE = yes | |||
BOOTMAGIC_ENABLE = lite | |||
UNICODE_ENABLE = yes | |||
UNICODEMAP_ENABLE = no |
@ -0,0 +1,270 @@ | |||
/* Copyright 2020 ZSA Technology Labs, Inc <@zsa> | |||
* Copyright 2020 Jack Humbert <jack.humb@gmail.com> | |||
* Copyright 2020 Drashna Jael're <drashna@live.com> | |||
* | |||
* 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 <stdint.h> | |||
#include <stdbool.h> | |||
#include <string.h> | |||
#include "hal.h" | |||
#include "timer.h" | |||
#include "wait.h" | |||
#include "printf.h" | |||
#include "matrix.h" | |||
#include "action.h" | |||
#include "keycode.h" | |||
#include <string.h> | |||
#include "moonlander.h" | |||
#include "i2c_master.h" | |||
#include "debounce.h" | |||
/* | |||
#define MATRIX_ROW_PINS { B10, B11, B12, B13, B14, B15 } outputs | |||
#define MATRIX_COL_PINS { A0, A1, A2, A3, A6, A7, B0 } inputs | |||
*/ | |||
/* matrix state(1:on, 0:off) */ | |||
static matrix_row_t matrix[MATRIX_ROWS]; | |||
static matrix_row_t matrix_debouncing[MATRIX_ROWS]; | |||
static matrix_row_t matrix_debouncing_right[MATRIX_COLS]; | |||
static bool debouncing = false; | |||
static uint16_t debouncing_time = 0; | |||
static bool debouncing_right = false; | |||
static uint16_t debouncing_time_right = 0; | |||
#define ROWS_PER_HAND (MATRIX_ROWS / 2) | |||
#ifndef MATRIX_IO_DELAY | |||
# define MATRIX_IO_DELAY 20 | |||
#endif | |||
extern bool mcp23018_leds[3]; | |||
extern bool is_launching; | |||
__attribute__((weak)) void matrix_init_user(void) {} | |||
__attribute__((weak)) void matrix_scan_user(void) {} | |||
__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); } | |||
__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); } | |||
__attribute__((weak)) void matrix_io_delay(void) { wait_us(MATRIX_IO_DELAY); } | |||
bool mcp23018_initd = false; | |||
static uint8_t mcp23018_reset_loop; | |||
uint8_t mcp23018_tx[3]; | |||
uint8_t mcp23018_rx[1]; | |||
void mcp23018_init(void) { | |||
i2c_init(); | |||
// #define MCP23_ROW_PINS { GPB5, GBP4, GBP3, GBP2, GBP1, GBP0 } outputs | |||
// #define MCP23_COL_PINS { GPA0, GBA1, GBA2, GBA3, GBA4, GBA5, GBA6 } inputs | |||
mcp23018_tx[0] = 0x00; // IODIRA | |||
mcp23018_tx[1] = 0b00000000; // A is output | |||
mcp23018_tx[2] = 0b00111111; // B is inputs | |||
if (MSG_OK != i2c_transmit(MCP23018_DEFAULT_ADDRESS << 1, mcp23018_tx, 3, I2C_TIMEOUT)) { | |||
printf("error hori\n"); | |||
} else { | |||
mcp23018_tx[0] = 0x0C; // GPPUA | |||
mcp23018_tx[1] = 0b10000000; // A is not pulled-up | |||
mcp23018_tx[2] = 0b11111111; // B is pulled-up | |||
if (MSG_OK != i2c_transmit(MCP23018_DEFAULT_ADDRESS << 1, mcp23018_tx, 3, I2C_TIMEOUT)) { | |||
printf("error hori\n"); | |||
} else { | |||
mcp23018_initd = is_launching = true; | |||
} | |||
} | |||
} | |||
void matrix_init(void) { | |||
printf("matrix init\n"); | |||
// debug_matrix = true; | |||
// outputs | |||
setPinOutput(B10); | |||
setPinOutput(B11); | |||
setPinOutput(B12); | |||
setPinOutput(B13); | |||
setPinOutput(B14); | |||
setPinOutput(B15); | |||
// inputs | |||
setPinInputLow(A0); | |||
setPinInputLow(A1); | |||
setPinInputLow(A2); | |||
setPinInputLow(A3); | |||
setPinInputLow(A6); | |||
setPinInputLow(A7); | |||
setPinInputLow(B0); | |||
memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t)); | |||
memset(matrix_debouncing, 0, MATRIX_ROWS * sizeof(matrix_row_t)); | |||
memset(matrix_debouncing_right, 0, MATRIX_COLS * sizeof(matrix_row_t)); | |||
mcp23018_init(); | |||
matrix_init_quantum(); | |||
} | |||
uint8_t matrix_scan(void) { | |||
bool changed = false; | |||
matrix_row_t data = 0; | |||
// actual matrix | |||
for (uint8_t row = 0; row < ROWS_PER_HAND; row++) { | |||
// strobe row | |||
switch (row) { | |||
case 0: writePinHigh(B10); break; | |||
case 1: writePinHigh(B11); break; | |||
case 2: writePinHigh(B12); break; | |||
case 3: writePinHigh(B13); break; | |||
case 4: writePinHigh(B14); break; | |||
case 5: writePinHigh(B15); break; | |||
} | |||
// need wait to settle pin state | |||
matrix_io_delay(); | |||
// read col data | |||
data = ( | |||
(readPin(A0) << 0 ) | | |||
(readPin(A1) << 1 ) | | |||
(readPin(A2) << 2 ) | | |||
(readPin(A3) << 3 ) | | |||
(readPin(A6) << 4 ) | | |||
(readPin(A7) << 5 ) | | |||
(readPin(B0) << 6 ) | |||
); | |||
// unstrobe row | |||
switch (row) { | |||
case 0: writePinLow(B10); break; | |||
case 1: writePinLow(B11); break; | |||
case 2: writePinLow(B12); break; | |||
case 3: writePinLow(B13); break; | |||
case 4: writePinLow(B14); break; | |||
case 5: writePinLow(B15); break; | |||
} | |||
if (matrix_debouncing[row] != data) { | |||
matrix_debouncing[row] = data; | |||
debouncing = true; | |||
debouncing_time = timer_read(); | |||
changed = true; | |||
} | |||
} | |||
for (uint8_t row = 0; row <= ROWS_PER_HAND; row++) { | |||
// right side | |||
if (!mcp23018_initd) { | |||
if (++mcp23018_reset_loop == 0) { | |||
// if (++mcp23018_reset_loop >= 1300) { | |||
// since mcp23018_reset_loop is 8 bit - we'll try to reset once in 255 matrix scans | |||
// this will be approx bit more frequent than once per second | |||
print("trying to reset mcp23018\n"); | |||
mcp23018_init(); | |||
if (!mcp23018_initd) { | |||
print("left side not responding\n"); | |||
} else { | |||
print("left side attached\n"); | |||
#ifdef RGB_MATRIX_ENABLE | |||
rgb_matrix_init(); | |||
#endif | |||
} | |||
} | |||
} | |||
// #define MCP23_ROW_PINS { GPB5, GBP4, GBP3, GBP2, GBP1, GBP0 } outputs | |||
// #define MCP23_COL_PINS { GPA0, GBA1, GBA2, GBA3, GBA4, GBA5, GBA6 } inputs | |||
// select row | |||
mcp23018_tx[0] = 0x12; // GPIOA | |||
mcp23018_tx[1] = (0b01111111 & ~(1 << (row))) | ((uint8_t)!mcp23018_leds[2] << 7); // activate row | |||
mcp23018_tx[2] = ((uint8_t)!mcp23018_leds[1] << 6) | ((uint8_t)!mcp23018_leds[0] << 7); // activate row | |||
if (MSG_OK != i2c_transmit(MCP23018_DEFAULT_ADDRESS << 1, mcp23018_tx, 3, I2C_TIMEOUT)) { | |||
printf("error hori\n"); | |||
mcp23018_initd = false; | |||
} | |||
// read col | |||
mcp23018_tx[0] = 0x13; // GPIOB | |||
if (MSG_OK != i2c_readReg(MCP23018_DEFAULT_ADDRESS << 1, mcp23018_tx[0], &mcp23018_rx[0], 1, I2C_TIMEOUT)) { | |||
printf("error vert\n"); | |||
mcp23018_initd = false; | |||
} | |||
data = ~(mcp23018_rx[0] & 0b00111111); | |||
// data = 0x01; | |||
if (matrix_debouncing_right[row] != data) { | |||
matrix_debouncing_right[row] = data; | |||
debouncing_right = true; | |||
debouncing_time_right = timer_read(); | |||
changed = true; | |||
} | |||
} | |||
if (debouncing && timer_elapsed(debouncing_time) > DEBOUNCE) { | |||
for (int row = 0; row < ROWS_PER_HAND; row++) { | |||
matrix[row] = matrix_debouncing[row]; | |||
} | |||
debouncing = false; | |||
} | |||
if (debouncing_right && timer_elapsed(debouncing_time_right) > DEBOUNCE && mcp23018_initd) { | |||
for (int row = 0; row < ROWS_PER_HAND; row++) { | |||
matrix[11 - row] = 0; | |||
for (int col = 0; col < MATRIX_COLS; col++) { | |||
matrix[11 - row] |= ((matrix_debouncing_right[6 - col] & (1 << row) ? 1 : 0) << col); | |||
} | |||
} | |||
debouncing_right = false; | |||
} | |||
matrix_scan_quantum(); | |||
return (uint8_t)changed; | |||
} | |||
bool matrix_is_on(uint8_t row, uint8_t col) { return (matrix[row] & (1 << col)); } | |||
matrix_row_t matrix_get_row(uint8_t row) { return matrix[row]; } | |||
void matrix_print(void) { | |||
printf("\nr/c 01234567\n"); | |||
for (uint8_t row = 0; row < MATRIX_ROWS; row++) { | |||
printf("%X0: ", row); | |||
matrix_row_t data = matrix_get_row(row); | |||
for (int col = 0; col < MATRIX_COLS; col++) { | |||
if (data & (1 << col)) | |||
printf("1"); | |||
else | |||
printf("0"); | |||
} | |||
printf("\n"); | |||
} | |||
} |
@ -0,0 +1,466 @@ | |||
/* Copyright 2020 ZSA Technology Labs, Inc <@zsa> | |||
* Copyright 2020 Jack Humbert <jack.humb@gmail.com> | |||
* Copyright 2020 Drashna Jael're <drashna@live.com> | |||
* | |||
* 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 "moonlander.h" | |||
#ifdef WEBUSB_ENABLE | |||
# include "webusb.h" | |||
#endif | |||
keyboard_config_t keyboard_config; | |||
bool mcp23018_leds[3] = {0, 0, 0}; | |||
bool is_launching = false; | |||
#ifdef DYNAMIC_MACRO_ENABLE | |||
static bool is_dynamic_recording = false; | |||
void dynamic_macro_record_start_user(void) { is_dynamic_recording = true; } | |||
void dynamic_macro_record_end_user(int8_t direction) { | |||
is_dynamic_recording = false; | |||
ML_LED_3(false); | |||
} | |||
#endif | |||
void moonlander_led_task(void) { | |||
if (is_launching) { | |||
ML_LED_1(false); | |||
ML_LED_2(false); | |||
ML_LED_3(false); | |||
ML_LED_4(false); | |||
ML_LED_5(false); | |||
ML_LED_6(false); | |||
ML_LED_1(true); | |||
wait_ms(250); | |||
ML_LED_2(true); | |||
wait_ms(250); | |||
ML_LED_3(true); | |||
wait_ms(250); | |||
ML_LED_4(true); | |||
wait_ms(250); | |||
ML_LED_5(true); | |||
wait_ms(250); | |||
ML_LED_6(true); | |||
wait_ms(250); | |||
ML_LED_1(false); | |||
wait_ms(250); | |||
ML_LED_2(false); | |||
wait_ms(250); | |||
ML_LED_3(false); | |||
wait_ms(250); | |||
ML_LED_4(false); | |||
wait_ms(250); | |||
ML_LED_5(false); | |||
wait_ms(250); | |||
ML_LED_6(false); | |||
wait_ms(250); | |||
is_launching = false; | |||
layer_state_set_kb(layer_state); | |||
} | |||
#ifdef DYNAMIC_MACRO_ENABLE | |||
else if (is_dynamic_recording) { | |||
ML_LED_3(true); | |||
wait_ms(100); | |||
ML_LED_3(false); | |||
wait_ms(155); | |||
} | |||
#endif | |||
#ifdef WEBUSB_ENABLE | |||
else if (webusb_state.pairing == true) { | |||
static uint8_t led_mask; | |||
ML_LED_1(false); | |||
ML_LED_2(false); | |||
ML_LED_3(false); | |||
ML_LED_4(false); | |||
ML_LED_5(false); | |||
ML_LED_6(false); | |||
if (!led_mask) { | |||
led_mask = 1; | |||
} else { | |||
led_mask++; | |||
if (led_mask > 12) led_mask = 1; | |||
} | |||
switch (led_mask) { | |||
case 1: | |||
case 12: | |||
ML_LED_1(true); | |||
break; | |||
case 2: | |||
case 11: | |||
ML_LED_2(true); | |||
break; | |||
case 3: | |||
case 10: | |||
ML_LED_3(true); | |||
break; | |||
case 4: | |||
case 9: | |||
ML_LED_4(true); | |||
break; | |||
case 5: | |||
case 8: | |||
ML_LED_5(true); | |||
break; | |||
case 6: | |||
case 7: | |||
ML_LED_6(true); | |||
break; | |||
} | |||
wait_ms(150); | |||
} | |||
#endif | |||
} | |||
static THD_WORKING_AREA(waLEDThread, 128); | |||
static THD_FUNCTION(LEDThread, arg) { | |||
(void)arg; | |||
chRegSetThreadName("LEDThread"); | |||
while (true) { | |||
moonlander_led_task(); | |||
} | |||
} | |||
void keyboard_pre_init_kb(void) { | |||
setPinOutput(B5); | |||
setPinOutput(B4); | |||
setPinOutput(B3); | |||
writePinLow(B5); | |||
writePinLow(B4); | |||
writePinLow(B3); | |||
chThdCreateStatic(waLEDThread, sizeof(waLEDThread), NORMALPRIO - 16, LEDThread, NULL); | |||
/* the array is initialized to 0, no need to re-set it here */ | |||
// mcp23018_leds[0] = 0; // blue | |||
// mcp23018_leds[1] = 0; // green | |||
// mcp23018_leds[2] = 0; // red | |||
keyboard_pre_init_user(); | |||
} | |||
#ifdef ORYX_CONFIGURATOR | |||
layer_state_t layer_state_set_kb(layer_state_t state) { | |||
state = layer_state_set_user(state); | |||
if (is_launching) return state; | |||
ML_LED_1(false); | |||
ML_LED_2(false); | |||
ML_LED_3(false); | |||
ML_LED_4(false); | |||
ML_LED_5(false); | |||
ML_LED_6(false); | |||
uint8_t layer = get_highest_layer(state); | |||
switch (layer) { | |||
case 1: | |||
ML_LED_1(1); | |||
ML_LED_4(1); | |||
break; | |||
case 2: | |||
ML_LED_2(1); | |||
ML_LED_5(1); | |||
break; | |||
case 3: | |||
ML_LED_3(1); | |||
break; | |||
case 4: | |||
ML_LED_4(1); | |||
break; | |||
case 5: | |||
ML_LED_5(1); | |||
break; | |||
case 6: | |||
ML_LED_6(1); | |||
break; | |||
default: | |||
break; | |||
} | |||
return state; | |||
} | |||
#endif | |||
#ifdef RGB_MATRIX_ENABLE | |||
// clang-format off | |||
const is31_led g_is31_leds[DRIVER_LED_TOTAL] = { | |||
/* Refer to IS31 manual for these locations | |||
* driver | |||
* | R location | |||
* | | G location | |||
* | | | B location | |||
* | | | | */ | |||
{0, C3_2, C1_1, C4_2}, // 1 | |||
{0, C2_2, C1_2, C4_3}, | |||
{0, C2_3, C1_3, C3_3}, | |||
{0, C2_4, C1_4, C3_4}, | |||
{0, C2_5, C1_5, C3_5}, | |||
{0, C2_6, C1_6, C3_6}, | |||
{0, C2_7, C1_7, C3_7}, | |||
{0, C2_8, C1_8, C3_8}, | |||
{0, C3_1, C2_1, C4_1}, | |||
{0, C7_8, C6_8, C8_8}, // 10 | |||
{0, C7_7, C6_7, C9_8}, | |||
{0, C8_7, C6_6, C9_7}, | |||
{0, C8_6, C7_6, C9_6}, | |||
{0, C8_5, C7_5, C9_5}, | |||
{0, C8_4, C7_4, C9_4}, | |||
{0, C8_3, C7_3, C9_3}, | |||
{0, C8_2, C7_2, C9_2}, | |||
{0, C8_1, C7_1, C9_1}, | |||
{0, C3_10, C1_9, C4_10}, // 19 | |||
{0, C2_10, C1_10, C4_11}, | |||
{0, C2_11, C1_11, C3_11}, | |||
{0, C2_12, C1_12, C3_12}, | |||
{0, C2_13, C1_13, C3_13}, | |||
{0, C2_14, C1_14, C3_14}, | |||
{0, C2_15, C1_15, C3_15}, | |||
{0, C2_16, C1_16, C3_16}, | |||
{0, C3_9, C2_9, C4_9}, | |||
{0, C7_16, C6_16, C8_16}, // 28 | |||
{0, C7_15, C6_15, C9_16}, | |||
{0, C8_15, C6_14, C9_15}, | |||
{0, C8_10, C7_10, C9_10}, | |||
{0, C8_9, C7_9, C9_9}, | |||
{0, C8_11, C7_11, C9_11}, | |||
{0, C8_12, C7_12, C9_12}, | |||
{0, C8_13, C7_13, C9_13}, | |||
{0, C8_14, C7_14, C9_14}, | |||
{1, C3_2, C1_1, C4_2}, // 1 | |||
{1, C2_2, C1_2, C4_3}, | |||
{1, C2_3, C1_3, C3_3}, | |||
{1, C2_4, C1_4, C3_4}, | |||
{1, C2_5, C1_5, C3_5}, | |||
{1, C2_6, C1_6, C3_6}, | |||
{1, C2_7, C1_7, C3_7}, | |||
{1, C2_8, C1_8, C3_8}, | |||
{1, C3_1, C2_1, C4_1}, | |||
{1, C7_8, C6_8, C8_8}, // 10 | |||
{1, C7_7, C6_7, C9_8}, | |||
{1, C8_7, C6_6, C9_7}, | |||
{1, C8_6, C7_6, C9_6}, | |||
{1, C8_5, C7_5, C9_5}, | |||
{1, C8_4, C7_4, C9_4}, | |||
{1, C8_3, C7_3, C9_3}, | |||
{1, C8_2, C7_2, C9_2}, | |||
{1, C8_1, C7_1, C9_1}, | |||
{1, C3_10, C1_9, C4_10}, // 19 | |||
{1, C2_10, C1_10, C4_11}, | |||
{1, C2_11, C1_11, C3_11}, | |||
{1, C2_12, C1_12, C3_12}, | |||
{1, C2_13, C1_13, C3_13}, | |||
{1, C2_14, C1_14, C3_14}, | |||
{1, C2_15, C1_15, C3_15}, | |||
{1, C2_16, C1_16, C3_16}, | |||
{1, C3_9, C2_9, C4_9}, | |||
{1, C7_16, C6_16, C8_16}, // 28 | |||
{1, C7_15, C6_15, C9_16}, | |||
{1, C8_15, C6_14, C9_15}, | |||
{1, C8_10, C7_10, C9_10}, | |||
{1, C8_9, C7_9, C9_9}, | |||
{1, C8_11, C7_11, C9_11}, | |||
{1, C8_12, C7_12, C9_12}, | |||
{1, C8_13, C7_13, C9_13}, | |||
{1, C8_14, C7_14, C9_14}, | |||
}; | |||
led_config_t g_led_config = { { | |||
{ 0, 5, 10, 15, 20, 25, 29 }, | |||
{ 1, 6, 11, 16, 21, 26, 30 }, | |||
{ 2, 7, 12, 17, 22, 27, 31 }, | |||
{ 3, 8, 13, 18, 23, 28, NO_LED }, | |||
{ 4, 9, 14, 19, 24, NO_LED, NO_LED }, | |||
{ 32, 33, 34, 35, NO_LED, NO_LED, NO_LED }, | |||
{ 65, 61, 56, 51, 46, 41, 36 }, | |||
{ 66, 62, 57, 52, 47, 42, 37 }, | |||
{ 67, 63, 58, 53, 48, 43, 38 }, | |||
{ NO_LED, 64, 59, 54, 49, 44, 39 }, | |||
{ NO_LED, NO_LED, 60, 55, 50, 45, 40 }, | |||
{ NO_LED, NO_LED, NO_LED, 71, 70, 69, 68 }, | |||
}, { | |||
{ 0, 0 }, { 0, 12 }, { 0, 25 }, { 0, 38 }, { 0, 51 }, | |||
{ 17, 0 }, { 17, 12 }, { 17, 25 }, { 17, 38 }, { 17, 51 }, | |||
{ 34, 0 }, { 34, 12 }, { 34, 25 }, { 34, 38 }, { 34, 51 }, | |||
{ 51, 0 }, { 51, 12 }, { 51, 25 }, { 51, 38 }, { 51, 51 }, | |||
{ 68, 0 }, { 68, 12 }, { 68, 25 }, { 68, 38 }, { 68, 51 }, | |||
{ 86, 0 }, { 86, 12 }, { 86, 25 }, { 86, 38 }, | |||
{ 105, 0 }, { 105, 12 }, { 105, 25 }, | |||
{ 90, 55 }, { 105, 68 }, { 116, 86 }, { 116, 59 }, | |||
{ 250, 0 }, { 250, 12 }, { 250, 25 }, { 250, 38 }, { 250, 51 }, | |||
{ 233, 0 }, { 233, 12 }, { 233, 25 }, { 233, 38 }, { 233, 51 }, | |||
{ 216, 0 }, { 216, 12 }, { 216, 25 }, { 216, 38 }, { 216, 51 }, | |||
{ 198, 0 }, { 198, 12 }, { 198, 25 }, { 198, 38 }, { 198, 51 }, | |||
{ 181, 0 }, { 181, 12 }, { 181, 25 }, { 181, 38 }, { 181, 51 }, | |||
{ 163, 0 }, { 163, 12 }, { 163, 25 }, { 163, 38 }, | |||
{ 146, 0 }, { 146, 12 }, { 146, 25 }, | |||
{ 161, 55 }, { 161, 68 }, { 146, 86 }, { 131, 59 } | |||
}, { | |||
1, 1, 1, 1, 1, 4, | |||
4, 4, 4, 1, 4, 4, | |||
4, 4, 1, 4, 4, 4, | |||
4, 1, 4, 4, 4, 4, | |||
1, 4, 4, 4, 4, 4, | |||
4, 4, 1, 1, 1, 1, | |||
1, 1, 1, 1, 1, 4, | |||
4, 4, 4, 1, 4, 4, | |||
4, 4, 1, 4, 4, 4, | |||
4, 1, 4, 4, 4, 4, | |||
1, 4, 4, 4, 4, 4, | |||
4, 4, 1, 1, 1, 1 | |||
} }; | |||
// clang-format on | |||
void suspend_power_down_kb(void) { | |||
rgb_matrix_set_suspend_state(true); | |||
suspend_power_down_user(); | |||
} | |||
void suspend_wakeup_init_kb(void) { | |||
rgb_matrix_set_suspend_state(false); | |||
suspend_wakeup_init_user(); | |||
} | |||
#endif | |||
#ifdef AUDIO_ENABLE | |||
bool music_mask_kb(uint16_t keycode) { | |||
switch (keycode) { | |||
case QK_LAYER_TAP ... QK_ONE_SHOT_LAYER_MAX: | |||
case QK_LAYER_TAP_TOGGLE ... QK_LAYER_MOD_MAX: | |||
case QK_MOD_TAP ... QK_MOD_TAP_MAX: | |||
case AU_ON ... MUV_DE: | |||
case RESET: | |||
case EEP_RST: | |||
return false; | |||
default: | |||
return music_mask_user(keycode); | |||
} | |||
} | |||
#endif | |||
#ifdef SWAP_HANDS_ENABLE | |||
// swap-hands action needs a matrix to define the swap | |||
// clang-format off | |||
const keypos_t hand_swap_config[MATRIX_ROWS][MATRIX_COLS] = { | |||
/* Left hand, matrix positions */ | |||
{{6,6}, {5,6}, {4,6}, {3,6}, {2,6}, {1,6},{0,6}}, | |||
{{6,7}, {5,7}, {4,7}, {3,7}, {2,7}, {1,7},{0,7}}, | |||
{{6,8}, {5,8}, {4,8}, {3,8}, {2,8}, {1,8},{0,8}}, | |||
{{6,9}, {5,9}, {4,9}, {3,9}, {2,9}, {1,9},{0,9}}, | |||
{{6,10},{5,10},{4,10},{3,10},{2,10},{1,10},{0,10}}, | |||
{{6,11},{5,11},{4,11},{3,11},{2,11},{1,11},{0,11}}, | |||
/* Right hand, matrix positions */ | |||
{{6,0}, {5,0}, {4,0}, {3,0}, {2,0}, {1,0},{0,0}}, | |||
{{6,1}, {5,1}, {4,1}, {3,1}, {2,1}, {1,1},{0,1}}, | |||
{{6,2}, {5,2}, {4,2}, {3,2}, {2,2}, {1,2},{0,2}}, | |||
{{6,3}, {5,3}, {4,3}, {3,3}, {2,3}, {1,3},{0,3}}, | |||
{{6,4}, {5,4}, {4,4}, {3,4}, {2,4}, {1,4},{0,4}}, | |||
{{6,5}, {5,5}, {4,5}, {3,5}, {2,5}, {1,5},{0,5}}, | |||
}; | |||
// clang-format on | |||
void keyboard_post_init_kb(void) { | |||
rgb_matrix_enable_noeeprom(); | |||
keyboard_post_init_user(); | |||
} | |||
#endif | |||
#if defined(AUDIO_ENABLE) && defined(MUSIC_MAP) | |||
// clang-format off | |||
const uint8_t music_map[MATRIX_ROWS][MATRIX_COLS] = LAYOUT_moonlander( | |||
58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, | |||
44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, | |||
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, | |||
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, | |||
8, 9, 10, 11, 12, 3, 4, 13, 14, 15, 16, 17, | |||
0, 1, 2, 5, 6, 7 | |||
); | |||
// clang-format on | |||
#endif | |||
#ifdef ORYX_CONFIGURATOR | |||
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { | |||
switch (keycode) { | |||
#ifdef WEBUSB_ENABLE | |||
case WEBUSB_PAIR: | |||
if (!record->event.pressed && !webusb_state.pairing) layer_state_set_kb(layer_state); | |||
break; | |||
#endif | |||
#ifdef RGB_MATRIX_ENABLE | |||
case TOGGLE_LAYER_COLOR: | |||
if (record->event.pressed) { | |||
keyboard_config.disable_layer_led ^= 1; | |||
if (keyboard_config.disable_layer_led) rgb_matrix_set_color_all(0, 0, 0); | |||
eeconfig_update_kb(keyboard_config.raw); | |||
} | |||
break; | |||
case RGB_TOG: | |||
if (record->event.pressed) { | |||
switch (rgb_matrix_get_flags()) { | |||
case LED_FLAG_ALL: { | |||
rgb_matrix_set_flags(LED_FLAG_NONE); | |||
keyboard_config.rgb_matrix_enable = false; | |||
rgb_matrix_set_color_all(0, 0, 0); | |||
} break; | |||
default: { | |||
rgb_matrix_set_flags(LED_FLAG_ALL); | |||
keyboard_config.rgb_matrix_enable = true; | |||
} break; | |||
} | |||
eeconfig_update_kb(keyboard_config.raw); | |||
} | |||
return false; | |||
#endif | |||
} | |||
return process_record_user(keycode, record); | |||
} | |||
#endif | |||
void matrix_init_kb(void) { | |||
keyboard_config.raw = eeconfig_read_kb(); | |||
#ifdef RGB_MATRIX_ENABLE | |||
if (keyboard_config.rgb_matrix_enable) { | |||
rgb_matrix_set_flags(LED_FLAG_ALL); | |||
} else { | |||
rgb_matrix_set_flags(LED_FLAG_NONE); | |||
} | |||
#endif | |||
} | |||
void eeconfig_init_kb(void) { // EEPROM is getting reset! | |||
keyboard_config.raw = 0; | |||
keyboard_config.rgb_matrix_enable = true; | |||
eeconfig_update_kb(keyboard_config.raw); | |||
eeconfig_init_user(); | |||
} |
@ -0,0 +1,81 @@ | |||
/* Copyright 2020 ZSA Technology Labs, Inc <@zsa> | |||
* Copyright 2020 Jack Humbert <jack.humb@gmail.com> | |||
* Copyright 2020 Drashna Jael're <drashna@live.com> | |||
* | |||
* 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" | |||
extern bool mcp23018_leds[]; | |||
#define MCP23018_DEFAULT_ADDRESS 0b0100000 | |||
#define ML_LED_1(status) writePin(B5, (bool)status) | |||
#define ML_LED_2(status) writePin(B4, (bool)status) | |||
#define ML_LED_3(status) writePin(B3, (bool)status) | |||
#define ML_LED_4(status) mcp23018_leds[0] = (bool)status | |||
#define ML_LED_5(status) mcp23018_leds[1] = (bool)status | |||
#define ML_LED_6(status) mcp23018_leds[2] = (bool)status | |||
// clang-format off | |||
#define LAYOUT_moonlander( \ | |||
k00, k01, k02, k03, k04, k05, k06, k60, k61, k62, k63, k64, k65, k66, \ | |||
k10, k11, k12, k13, k14, k15, k16, k70, k71, k72, k73, k74, k75, k76, \ | |||
k20, k21, k22, k23, k24, k25, k26, k80, k81, k82, k83, k84, k85, k86, \ | |||
k30, k31, k32, k33, k34, k35, k91, k92, k93, k94, k95, k96, \ | |||
k40, k41, k42, k43, k44, k53, kb3, ka2, ka3, ka4, ka5, ka6, \ | |||
k50, k51, k52, kb4, kb5, kb6 \ | |||
) \ | |||
{ \ | |||
{ k00, k01, k02, k03, k04, k05, k06 }, \ | |||
{ k10, k11, k12, k13, k14, k15, k16 }, \ | |||
{ k20, k21, k22, k23, k24, k25, k26 }, \ | |||
{ k30, k31, k32, k33, k34, k35, KC_NO }, \ | |||
{ k40, k41, k42, k43, k44, KC_NO, KC_NO }, \ | |||
{ k50, k51, k52, k53, KC_NO, KC_NO, KC_NO }, \ | |||
\ | |||
{ k60, k61, k62, k63, k64, k65, k66 }, \ | |||
{ k70, k71, k72, k73, k74, k75, k76 }, \ | |||
{ k80, k81, k82, k83, k84, k85, k86 }, \ | |||
{ KC_NO,k91, k92, k93, k94, k95, k96 }, \ | |||
{ KC_NO, KC_NO, ka2, ka3, ka4, ka5, ka6 }, \ | |||
{ KC_NO, KC_NO, KC_NO, kb3, kb4, kb5, kb6 } \ | |||
} | |||
// clang-format on | |||
enum planck_ez_keycodes { | |||
TOGGLE_LAYER_COLOR = SAFE_RANGE, | |||
ML_SAFE_RANGE, | |||
}; | |||
#ifndef WEBUSB_ENABLE | |||
# define WEBUSB_PAIR KC_NO | |||
#endif | |||
typedef union { | |||
uint32_t raw; | |||
struct { | |||
bool disable_layer_led :1; | |||
bool rgb_matrix_enable :1; | |||
}; | |||
} keyboard_config_t; | |||
extern keyboard_config_t keyboard_config; |
@ -0,0 +1,28 @@ | |||
# Moonlander | |||
![Moonlander](https://zsa.io/static/gallery-white-case-7a2ef555f8f7f4ce1b9030477b16e517.png) | |||
A next-gen split, ergonomic keyboard with an active left side, USB type C, integrated wrist rest, and a thumb cluster that can move. | |||
* Keyboard Maintainer: [drashna](https://github.com/drashna), [ZSA](https://github.com/zsa/) | |||
* Hardware Supported: Moonlander MK 1 (STM32F303xC) | |||
* Hardware Availability: [ZSA Store](https://zsa.io/moonlander/) | |||
Make example for this keyboard (after setting up your build environment): | |||
make moonlander:default | |||
Flashing example for this keyboard: | |||
make moonlander:default:flash | |||
See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). | |||
## Oryx Configuation | |||
If you're using the Smart LED (layer indication) feature from the Oryx Configurator, you want to make sure that you enable these options by adding `#define ORYX_CONFIGURATOR` to your keymap's `config.h`. | |||
This changes the `RGB_TOG` keycode so that it will toggle the lights on and off, in a way that will allow the Smart LEDs to continue to work, even with the rest of the LEDs turned off. | |||
Additionally, a new keycode has been added to toggle the Smart LEDs. Use `TOGGLE_LAYER_COLOR`, if you aren't already. |
@ -0,0 +1,29 @@ | |||
# MCU name | |||
MCU = STM32F303 | |||
# Build Options | |||
# change yes to no to disable | |||
# | |||
BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration | |||
MOUSEKEY_ENABLE = yes # Mouse keys | |||
EXTRAKEY_ENABLE = yes # Audio control and System control | |||
CONSOLE_ENABLE = yes # Console for debug | |||
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 | |||
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow | |||
BLUETOOTH_ENABLE = no # Enable Bluetooth | |||
AUDIO_ENABLE = yes # Audio output | |||
CUSTOM_MATRIX = yes | |||
DEBOUNCE_TYPE = custom | |||
SWAP_HANDS_ENABLE = yes | |||
RGB_MATRIX_ENABLE = IS31FL3731 | |||
#SERIAL_LINK_ENABLE = yes | |||
EEPROM_DRIVER = i2c | |||
#project specific files | |||
SRC += matrix.c | |||
QUANTUM_LIB_SRC += i2c_master.c |