diff options
Diffstat (limited to 'quantum')
| -rw-r--r-- | quantum/analog.c | 53 | ||||
| -rw-r--r-- | quantum/analog.h | 36 | ||||
| -rw-r--r-- | quantum/beeps.c | 246 | ||||
| -rw-r--r-- | quantum/beeps.h | 12 | ||||
| -rw-r--r-- | quantum/keymap_common.c | 226 | ||||
| -rw-r--r-- | quantum/keymap_common.h | 121 | ||||
| -rw-r--r-- | quantum/keymap_extras/keymap_colemak.h | 74 | ||||
| -rw-r--r-- | quantum/keymap_extras/keymap_dvorak.h | 72 | ||||
| -rw-r--r-- | quantum/keymap_extras/keymap_french.h | 83 | ||||
| -rw-r--r-- | quantum/keymap_extras/keymap_nordic.h | 59 | ||||
| -rw-r--r-- | quantum/keymap_extras/keymap_spanish.h | 62 | ||||
| -rw-r--r-- | quantum/keymap_extras/keymap_uk.h | 36 | ||||
| -rw-r--r-- | quantum/keymap_midi.c | 110 | ||||
| -rw-r--r-- | quantum/keymap_midi.h | 220 | ||||
| -rw-r--r-- | quantum/keymap_unicode.c | 59 | ||||
| -rw-r--r-- | quantum/led.c | 38 | ||||
| -rw-r--r-- | quantum/matrix.c | 301 |
17 files changed, 1808 insertions, 0 deletions
diff --git a/quantum/analog.c b/quantum/analog.c new file mode 100644 index 0000000000..49b84ee0e8 --- /dev/null +++ b/quantum/analog.c @@ -0,0 +1,53 @@ +// Simple analog to digitial conversion + +#include <avr/io.h> +#include <avr/pgmspace.h> +#include <stdint.h> +#include "analog.h" + + +static uint8_t aref = (1<<REFS0); // default to AREF = Vcc + + +void analogReference(uint8_t mode) +{ + aref = mode & 0xC0; +} + + +// Arduino compatible pin input +int16_t analogRead(uint8_t pin) +{ +#if defined(__AVR_ATmega32U4__) + static const uint8_t PROGMEM pin_to_mux[] = { + 0x00, 0x01, 0x04, 0x05, 0x06, 0x07, + 0x25, 0x24, 0x23, 0x22, 0x21, 0x20}; + if (pin >= 12) return 0; + return adc_read(pgm_read_byte(pin_to_mux + pin)); +#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__) + if (pin >= 8) return 0; + return adc_read(pin); +#else + return 0; +#endif +} + +// Mux input +int16_t adc_read(uint8_t mux) +{ +#if defined(__AVR_AT90USB162__) + return 0; +#else + uint8_t low; + + ADCSRA = (1<<ADEN) | ADC_PRESCALER; // enable ADC + ADCSRB = (1<<ADHSM) | (mux & 0x20); // high speed mode + ADMUX = aref | (mux & 0x1F); // configure mux input + ADCSRA = (1<<ADEN) | ADC_PRESCALER | (1<<ADSC); // start the conversion + while (ADCSRA & (1<<ADSC)) ; // wait for result + low = ADCL; // must read LSB first + return (ADCH << 8) | low; // must read MSB only once! +#endif +} + + diff --git a/quantum/analog.h b/quantum/analog.h new file mode 100644 index 0000000000..9b95a93bef --- /dev/null +++ b/quantum/analog.h @@ -0,0 +1,36 @@ +#ifndef _analog_h_included__ +#define _analog_h_included__ + +#include <stdint.h> + +void analogReference(uint8_t mode); +int16_t analogRead(uint8_t pin); +int16_t adc_read(uint8_t mux); + +#define ADC_REF_POWER (1<<REFS0) +#define ADC_REF_INTERNAL ((1<<REFS1) | (1<<REFS0)) +#define ADC_REF_EXTERNAL (0) + +// These prescaler values are for high speed mode, ADHSM = 1 +#if F_CPU == 16000000L +#define ADC_PRESCALER ((1<<ADPS2) | (1<<ADPS1)) +#elif F_CPU == 8000000L +#define ADC_PRESCALER ((1<<ADPS2) | (1<<ADPS0)) +#elif F_CPU == 4000000L +#define ADC_PRESCALER ((1<<ADPS2)) +#elif F_CPU == 2000000L +#define ADC_PRESCALER ((1<<ADPS1) | (1<<ADPS0)) +#elif F_CPU == 1000000L +#define ADC_PRESCALER ((1<<ADPS1)) +#else +#define ADC_PRESCALER ((1<<ADPS0)) +#endif + +// some avr-libc versions do not properly define ADHSM +#if defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__) +#if !defined(ADHSM) +#define ADHSM (7) +#endif +#endif + +#endif diff --git a/quantum/beeps.c b/quantum/beeps.c new file mode 100644 index 0000000000..8d1f81f210 --- /dev/null +++ b/quantum/beeps.c @@ -0,0 +1,246 @@ +#include "beeps.h" +#include <math.h> +#include <avr/pgmspace.h> +#include <avr/interrupt.h> +#include <avr/io.h> + +#define PI 3.14159265 + +void delay_us(int count) { + while(count--) { + _delay_us(1); + } +} + +int voices = 0; +double frequency = 0; +int volume = 0; +int position = 0; + +double frequencies[8] = {0, 0, 0, 0, 0, 0, 0, 0}; +int volumes[8] = {0, 0, 0, 0, 0, 0, 0, 0}; +bool sliding = false; +#define RANGE 1000 +volatile int i=0; //elements of the wave + + +void beeps() { + play_notes(); +} + +void send_freq(double freq, int vol) { + int duty = (((double)F_CPU) / freq); + ICR3 = duty; // Set max to the period + OCR3A = duty >> (0x10 - vol); // Set compare to half the period +} + +void stop_all_notes() { + voices = 0; + TCCR3A = 0; + TCCR3B = 0; + frequency = 0; + volume = 0; + + for (int i = 0; i < 8; i++) { + frequencies[i] = 0; + volumes[i] = 0; + } +} + +void stop_note(double freq) { + for (int i = 7; i >= 0; i--) { + if (frequencies[i] == freq) { + frequencies[i] = 0; + volumes[i] = 0; + for (int j = i; (j < 7); j++) { + frequencies[j] = frequencies[j+1]; + frequencies[j+1] = 0; + volumes[j] = volumes[j+1]; + volumes[j+1] = 0; + } + } + } + voices--; + if (voices < 0) + voices = 0; + if (voices == 0) { + TCCR3A = 0; + TCCR3B = 0; + frequency = 0; + volume = 0; + } else { + double freq = frequencies[voices - 1]; + int vol = volumes[voices - 1]; + if (frequency < freq) { + sliding = true; + for (double f = frequency; f <= freq; f += ((freq - frequency) / 500.0)) { + send_freq(f, vol); + } + sliding = false; + } else if (frequency > freq) { + sliding = true; + for (double f = frequency; f >= freq; f -= ((frequency - freq) / 500.0)) { + send_freq(f, vol); + } + sliding = false; + } + send_freq(freq, vol); + frequency = freq; + volume = vol; + } +} + +void init_notes() { + // TCCR1A = (1 << COM1A1) | (0 << COM1A0) | (1 << WGM11) | (1 << WGM10); + // TCCR1B = (1 << COM1B1) | (0 << COM1A0) | (1 << WGM13) | (1 << WGM12) | (0 << CS12) | (0 << CS11) | (1 << CS10); + + // DDRC |= (1<<6); + + // TCCR3A = (1 << COM3A1) | (0 << COM3A0) | (1 << WGM31) | (0 << WGM30); + // TCCR3B = (1 << WGM33) | (1 << WGM32) | (0 << CS32) | (0 << CS31) | (1 << CS30); + + // ICR3 = 0xFFFF; + // OCR3A = (int)((float)wave[i]*ICR3/RANGE); //go to next array element + + + // cli(); + + // /* Enable interrupt on timer2 == 127, with clk/8 prescaler. At 16MHz, + // this gives a timer interrupt at 15625Hz. */ + // TIMSK3 = (1 << OCIE3A); + + // /* clear/reset timer on match */ + // // TCCR3A = 1<<WGM31 | 0<<WGM30; CTC mode, reset on match + // // TCCR3B = 0<<CS32 | 1<<CS31 | 0<<CS30; /* clk, /8 prescaler */ + + // TCCR3A = (1 << COM3A1) | (0 << COM3A0) | (1 << WGM31) | (0 << WGM30); + // TCCR3B = (0 << WGM33) | (0 << WGM32) | (0 << CS32) | (0 << CS31) | (1 << CS30); + + + // TCCR1A = (1 << COM1A1) | (0 << COM1A0) | (1 << WGM11) | (0 << WGM10); + // TCCR1B = (1 << WGM12) | (0 << CS12) | (0 << CS11) | (1 << CS10); + // // SPCR = 0x50; + // // SPSR = 0x01; + // DDRC |= (1<<6); + // // ICR3 = 0xFFFF; + // // OCR3A=80; + // PORTC |= (1<<6); + + // sei(); +} + +// #define highByte(c) ((c >> 8) & 0x00FF) +// #define lowByte(c) (c & 0x00FF) + +ISR(TIMER3_COMPA_vect) { + + if (ICR3 > 0 && !sliding) { + switch (position) { + case 0: { + int duty = (((double)F_CPU) / (frequency)); + ICR3 = duty; // Set max to the period + OCR3A = duty >> 1; // Set compare to half the period + break; + } + case 1: { + int duty = (((double)F_CPU) / (frequency*2)); + ICR3 = duty; // Set max to the period + OCR3A = duty >> 1; // Set compare to half the period + break; + } + case 2: { + int duty = (((double)F_CPU) / (frequency*3)); + ICR3 = duty; // Set max to the period + OCR3A = duty >> 1; // Set compare to half the period + break; + } + } + position = (position + 1) % 3; + } +// /* OCR2A has been cleared, per TCCR2A above */ +// // OCR3A = 127; + +// // pos1 += incr1; +// // pos2 += incr2; +// // pos3 += incr3; + +// // sample = sinewave[highByte(pos1)] + sinewave[highByte(pos2)] + sinewave[highByte(pos3)]; + +// // OCR3A = sample; + + +// OCR3A=pgm_read_byte(&sinewave[pos1]); +// pos1++; +// // PORTC &= ~(1<<6); + +// /* buffered, 1x gain, active mode */ +// // SPDR = highByte(sample) | 0x70; +// // while (!(SPSR & (1<<SPIF))); + +// // SPDR = lowByte(sample); +// // while (!(SPSR & (1<<SPIF))); + +// // PORTC |= (1<<6); +} + +void play_note(double freq, int vol) { + + if (freq > 0) { + DDRC |= (1<<6); + + TCCR3A = (1 << COM3A1) | (0 << COM3A0) | (1 << WGM31) | (0 << WGM30); + TCCR3B = (1 << WGM33) | (1 << WGM32) | (0 << CS32) | (1 << CS31) | (0 << CS30); + + if (frequency != 0) { + if (frequency < freq) { + for (double f = frequency; f <= freq; f += ((freq - frequency) / 500.0)) { + send_freq(f, vol); + } + } else if (frequency > freq) { + for (double f = frequency; f >= freq; f -= ((frequency - freq) / 500.0)) { + send_freq(f, vol); + } + } + } + send_freq(freq, vol); + frequency = freq; + volume = vol; + + frequencies[voices] = frequency; + volumes[voices] = volume; + voices++; + } + // ICR3 = 0xFFFF; + // for (int i = 0; i < 10000; i++) { + // OCR3A = round((sin(i*freq)*.5)+.5)*0xFFFF; + // // _delay_us(50); + // } + + // TCCR3A = 0; + // TCCR3B = 0; +} + +// void note(int x, float length) { +// DDRC |= (1<<6); +// int t = (int)(440*pow(2,-x/12.0)); // starting note +// for (int y = 0; y < length*1000/t; y++) { // note length +// PORTC |= (1<<6); +// delay_us(t); +// PORTC &= ~(1<<6); +// delay_us(t); +// } +// PORTC &= ~(1<<6); +// } + +// void true_note(float x, float y, float length) { +// for (uint32_t i = 0; i < length * 50; i++) { +// uint32_t v = (uint32_t) (round(sin(PI*2*i*640000*pow(2, x/12.0))*.5+1 + sin(PI*2*i*640000*pow(2, y/12.0))*.5+1) / 2 * pow(2, 8)); +// for (int u = 0; u < 8; u++) { +// if (v & (1 << u) && !(PORTC&(1<<6))) +// PORTC |= (1<<6); +// else if (PORTC&(1<<6)) +// PORTC &= ~(1<<6); +// } +// } +// PORTC &= ~(1<<6); +// }
\ No newline at end of file diff --git a/quantum/beeps.h b/quantum/beeps.h new file mode 100644 index 0000000000..378983c605 --- /dev/null +++ b/quantum/beeps.h @@ -0,0 +1,12 @@ +#include <stdint.h> +#include <stdbool.h> +#include <avr/io.h> +#include <util/delay.h> + +void note(int x, float length); +void beeps(); +void true_note(float x, float y, float length); +void play_note(double freq, int vol); +void stop_note(double freq); +void stop_all_notes(); +void init_notes();
\ No newline at end of file diff --git a/quantum/keymap_common.c b/quantum/keymap_common.c new file mode 100644 index 0000000000..66cf2883c7 --- /dev/null +++ b/quantum/keymap_common.c @@ -0,0 +1,226 @@ +/* +Copyright 2012,2013 Jun Wako <wakojun@gmail.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 "keymap_common.h" +#include "report.h" +#include "keycode.h" +#include "action_layer.h" +#include "action.h" +#include "action_macro.h" +#include "debug.h" +#include "backlight.h" +#include "keymap_midi.h" + +static action_t keycode_to_action(uint16_t keycode); + +/* converts key to action */ +action_t action_for_key(uint8_t layer, keypos_t key) +{ + // 16bit keycodes - important + uint16_t keycode = keymap_key_to_keycode(layer, key); + + if (keycode >= 0x0100 && keycode < 0x2000) { + // Has a modifier + action_t action; + // Split it up + action.code = ACTION_MODS_KEY(keycode >> 8, keycode & 0xFF); + return action; + } else if (keycode >= 0x2000 && keycode < 0x3000) { + // Is a shortcut for function layer, pull last 12bits + return keymap_func_to_action(keycode & 0xFFF); + } else if (keycode >= 0x3000 && keycode < 0x4000) { + action_t action; + action.code = ACTION_MACRO(keycode & 0xFF); + return action; + } else if (keycode >= BL_0 & keycode <= BL_15) { + action_t action; + action.code = ACTION_BACKLIGHT_LEVEL(keycode & 0x000F); + return action; + } else if (keycode == BL_DEC) { + action_t action; + action.code = ACTION_BACKLIGHT_DECREASE(); + return action; + } else if (keycode == BL_INC) { + action_t action; + action.code = ACTION_BACKLIGHT_INCREASE(); + return action; + } else if (keycode == BL_TOGG) { + action_t action; + action.code = ACTION_BACKLIGHT_TOGGLE(); + return action; + } else if (keycode == BL_STEP) { + action_t action; + action.code = ACTION_BACKLIGHT_STEP(); + return action; + } else if (keycode == RESET) { + bootloader_jump(); + return; + } else if (keycode == DEBUG) { + print("\nDEBUG: enabled.\n"); + debug_enable = true; + return; + } else if (keycode >= 0x5000 && keycode < 0x6000) { + int when = (keycode >> 0x9) & 0x3; + int layer = keycode & 0xFF; + action_t action; + action.code = ACTION_LAYER_SET(layer, when); + return action; + } else if (keycode >= 0x6000 && keycode < 0x7000) { + action_t action; + action.code = ACTION_FUNCTION_OPT(keycode & 0xFF, (keycode & 0x0F00) >> 8); + return action; + } else if (keycode >= 0x8000) { + action_t action; + uint16_t unicode = keycode & ~(0x8000); + action.code = ACTION_FUNCTION_OPT(unicode & 0xFF, (unicode & 0xFF00) >> 8); + return action; + } + + switch (keycode) { + case KC_FN0 ... KC_FN31: + return keymap_fn_to_action(keycode); +#ifdef BOOTMAGIC_ENABLE + case KC_CAPSLOCK: + case KC_LOCKING_CAPS: + if (keymap_config.swap_control_capslock || keymap_config.capslock_to_control) { + return keycode_to_action(KC_LCTL); + } + return keycode_to_action(keycode); + case KC_LCTL: + if (keymap_config.swap_control_capslock) { + return keycode_to_action(KC_CAPSLOCK); + } + return keycode_to_action(KC_LCTL); + case KC_LALT: + if (keymap_config.swap_lalt_lgui) { + if (keymap_config.no_gui) { + return keycode_to_action(ACTION_NO); + } + return keycode_to_action(KC_LGUI); + } + return keycode_to_action(KC_LALT); + case KC_LGUI: + if (keymap_config.swap_lalt_lgui) { + return keycode_to_action(KC_LALT); + } + if (keymap_config.no_gui) { + return keycode_to_action(ACTION_NO); + } + return keycode_to_action(KC_LGUI); + case KC_RALT: + if (keymap_config.swap_ralt_rgui) { + if (keymap_config.no_gui) { + return keycode_to_action(ACTION_NO); + } + return keycode_to_action(KC_RGUI); + } + return keycode_to_action(KC_RALT); + case KC_RGUI: + if (keymap_config.swap_ralt_rgui) { + return keycode_to_action(KC_RALT); + } + if (keymap_config.no_gui) { + return keycode_to_action(ACTION_NO); + } + return keycode_to_action(KC_RGUI); + case KC_GRAVE: + if (keymap_config.swap_grave_esc) { + return keycode_to_action(KC_ESC); + } + return keycode_to_action(KC_GRAVE); + case KC_ESC: + if (keymap_config.swap_grave_esc) { + return keycode_to_action(KC_GRAVE); + } + return keycode_to_action(KC_ESC); + case KC_BSLASH: + if (keymap_config.swap_backslash_backspace) { + return keycode_to_action(KC_BSPACE); + } + return keycode_to_action(KC_BSLASH); + case KC_BSPACE: + if (keymap_config.swap_backslash_backspace) { + return keycode_to_action(KC_BSLASH); + } + return keycode_to_action(KC_BSPACE); +#endif + default: + return keycode_to_action(keycode); + } +} + + +/* Macro */ +__attribute__ ((weak)) +const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) +{ + return MACRO_NONE; +} + +/* Function */ +__attribute__ ((weak)) +void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) +{ +} + +/* translates keycode to action */ +static action_t keycode_to_action(uint16_t keycode) +{ + action_t action; + switch (keycode) { + case KC_A ... KC_EXSEL: + case KC_LCTRL ... KC_RGUI: + action.code = ACTION_KEY(keycode); + break; + case KC_SYSTEM_POWER ... KC_SYSTEM_WAKE: + action.code = ACTION_USAGE_SYSTEM(KEYCODE2SYSTEM(keycode)); + break; + case KC_AUDIO_MUTE ... KC_WWW_FAVORITES: + action.code = ACTION_USAGE_CONSUMER(KEYCODE2CONSUMER(keycode)); + break; + case KC_MS_UP ... KC_MS_ACCEL2: + action.code = ACTION_MOUSEKEY(keycode); + break; + case KC_TRNS: + action.code = ACTION_TRANSPARENT; + break; + default: + action.code = ACTION_NO; + break; + } + return action; +} + + +/* translates key to keycode */ +uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key) +{ + // Read entire word (16bits) + return pgm_read_word(&keymaps[(layer)][(key.row)][(key.col)]); +} + +/* translates Fn keycode to action */ +action_t keymap_fn_to_action(uint16_t keycode) +{ + return (action_t){ .code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]) }; +} + +action_t keymap_func_to_action(uint16_t keycode) +{ + // For FUNC without 8bit limit + return (action_t){ .code = pgm_read_word(&fn_actions[(int)keycode]) }; +} diff --git a/quantum/keymap_common.h b/quantum/keymap_common.h new file mode 100644 index 0000000000..091f7d8f3e --- /dev/null +++ b/quantum/keymap_common.h @@ -0,0 +1,121 @@ +/* +Copyright 2012,2013 Jun Wako <wakojun@gmail.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/>. +*/ + +#ifndef KEYMAP_H +#define KEYMAP_H + +#include <stdint.h> +#include <stdbool.h> +#include "action.h" +#include <avr/pgmspace.h> +#include "keycode.h" +#include "keymap.h" +#include "action_macro.h" +#include "report.h" +#include "host.h" +// #include "print.h" +#include "debug.h" + +#ifdef BOOTMAGIC_ENABLE +/* NOTE: Not portable. Bit field order depends on implementation */ +typedef union { + uint16_t raw; + struct { + bool swap_control_capslock:1; + bool capslock_to_control:1; + bool swap_lalt_lgui:1; + bool swap_ralt_rgui:1; + bool no_gui:1; + bool swap_grave_esc:1; + bool swap_backslash_backspace:1; + bool nkro:1; + }; +} keymap_config_t; +keymap_config_t keymap_config; +#endif + + +/* translates key to keycode */ +uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key); + +/* translates Fn keycode to action */ +action_t keymap_fn_to_action(uint16_t keycode); + +/* translates Fn keycode to action */ +action_t keymap_func_to_action(uint16_t keycode); + +extern const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS]; +extern const uint16_t fn_actions[]; + +// Ability to use mods in layouts +#define LCTL(kc) kc | 0x0100 +#define LSFT(kc) kc | 0x0200 +#define LALT(kc) kc | 0x0400 +#define LGUI(kc) kc | 0x0800 +#define RCTL(kc) kc | 0x1100 +#define RSFT(kc) kc | 0x1200 +#define RALT(kc) kc | 0x1400 +#define RGUI(kc) kc | 0x1800 + +// Alias for function layers than expand past FN31 +#define FUNC(kc) kc | 0x2000 + +// Aliases +#define S(kc) LSFT(kc) +#define F(kc) FUNC(kc) + +#define M(kc) kc | 0x3000 + +#define MACRODOWN(...) (record->event.pressed ? MACRO(__VA_ARGS__) : MACRO_NONE) + +#define BL_ON 0x4009 +#define BL_OFF 0x4000 +#define BL_0 0x4000 +#define BL_1 0x4001 +#define BL_2 0x4002 +#define BL_3 0x4003 +#define BL_4 0x4004 +#define BL_5 0x4005 +#define BL_6 0x4006 +#define BL_7 0x4007 +#define BL_8 0x4008 +#define BL_9 0x4009 +#define BL_10 0x400A +#define BL_11 0x400B +#define BL_12 0x400C +#define BL_13 0x400D +#define BL_14 0x400E +#define BL_15 0x400F +#define BL_DEC 0x4010 +#define BL_INC 0x4011 +#define BL_TOGG 0x4012 +#define BL_STEP 0x4013 + +#define RESET 0x5000 +#define DEBUG 0x5001 + +// ON_PRESS = 1 +// ON_RELEASE = 2 +// ON_BOTH = 3 +#define TO(layer, when) (layer | 0x5100 | (when << 0x9)) + +#define MIDI(n) (n | 0x6000) + +#define UNI(n) (n | 0x8000) + + +#endif diff --git a/quantum/keymap_extras/keymap_colemak.h b/quantum/keymap_extras/keymap_colemak.h new file mode 100644 index 0000000000..c8066ea666 --- /dev/null +++ b/quantum/keymap_extras/keymap_colemak.h @@ -0,0 +1,74 @@ +#ifndef KEYMAP_COLEMAK_H +#define KEYMAP_COLEMAK_H + +#include "keymap_common.h" +// For software implementation of colemak +#define CM_Q KC_Q +#define CM_W KC_W +#define CM_F KC_E +#define CM_P KC_R +#define CM_G KC_T +#define CM_J KC_Y +#define CM_L KC_U +#define CM_U KC_I +#define CM_Y KC_O +#define CM_SCLN KC_P + +#define CM_A KC_A +#define CM_R KC_S +#define CM_S KC_D +#define CM_T KC_F +#define CM_D KC_G +#define CM_H KC_H +#define CM_N KC_J +#define CM_E KC_K +#define CM_I KC_L +#define CM_O KC_SCLN + +#define CM_Z KC_Z +#define CM_X KC_X +#define CM_C KC_C +#define CM_V KC_V +#define CM_B KC_B +#define CM_K KC_N +#define CM_M KC_M +#define CM_COMM KC_COMM +#define CM_DOT KC_DOT +#define CM_SLSH KC_SLSH + +// Make it easy to support these in macros +// TODO: change macro implementation so these aren't needed +#define KC_CM_Q CM_Q +#define KC_CM_W CM_W +#define KC_CM_F CM_F +#define KC_CM_P CM_P +#define KC_CM_G CM_G +#define KC_CM_J CM_J +#define KC_CM_L CM_L +#define KC_CM_U CM_U +#define KC_CM_Y CM_Y +#define KC_CM_SCLN CM_SCLN + +#define KC_CM_A CM_A +#define KC_CM_R CM_R +#define KC_CM_S CM_S +#define KC_CM_T CM_T +#define KC_CM_D CM_D +#define KC_CM_H CM_H +#define KC_CM_N CM_N +#define KC_CM_E CM_E +#define KC_CM_I CM_I +#define KC_CM_O CM_O + +#define KC_CM_Z CM_Z +#define KC_CM_X CM_X +#define KC_CM_C CM_C +#define KC_CM_V CM_V +#define KC_CM_B CM_B +#define KC_CM_K CM_K +#define KC_CM_M CM_M +#define KC_CM_COMM CM_COMM +#define KC_CM_DOT CM_DOT +#define KC_CM_SLSH CM_SLSH + +#endif diff --git a/quantum/keymap_extras/keymap_dvorak.h b/quantum/keymap_extras/keymap_dvorak.h new file mode 100644 index 0000000000..d172e0019b --- /dev/null +++ b/quantum/keymap_extras/keymap_dvorak.h @@ -0,0 +1,72 @@ +#ifndef KEYMAP_DVORAK_H +#define KEYMAP_DVORAK_H + +#include "keymap_common.h" + +// Normal characters +#define DV_GRV KC_GRV +#define DV_1 KC_1 +#define DV_2 KC_2 +#define DV_3 KC_3 +#define DV_4 KC_4 +#define DV_5 KC_5 +#define DV_6 KC_6 +#define DV_7 KC_7 +#define DV_8 KC_8 +#define DV_9 KC_9 +#define DV_0 KC_0 +#define DV_LBRC KC_MINS +#define DV_RBRC KC_EQL + +#define DV_QUOT KC_Q +#define DV_COMM KC_W +#define DV_DOT KC_E +#define DV_P KC_R +#define DV_Y KC_T +#define DV_F KC_Y +#define DV_G KC_U +#define DV_C KC_I +#define DV_R KC_O +#define DV_L KC_P +#define DV_SLSH KC_LBRC +#define DV_EQL KC_RBRC + +#define DV_A KC_A +#define DV_O KC_S +#define DV_E KC_D +#define DV_U KC_F +#define DV_I KC_G +#define DV_D KC_H +#define DV_H KC_J +#define DV_T KC_K +#define DV_N KC_L +#define DV_S KC_SCLN +#define DV_MINS KC_QUOT + +#define DV_SCLN KC_Z +#define DV_Q KC_X +#define DV_J KC_C +#define DV_K KC_V +#define DV_X KC_B +#define DV_B KC_N +#define DV_M KC_M +#define DV_W KC_COMM +#define DV_V KC_DOT +#define DV_Z KC_SLSH + +// Shifted characters +#define DV_TILD LSFT(DV_GRV) +#define DV_EXLM LSFT(DV_1) +#define DV_AT LSFT(DV_2) +#define DV_HASH LSFT(DV_3) +#define DV_DLR LSFT(DV_4) +#define DV_PERC LSFT(DV_5) +#define DV_CIRC LSFT(DV_6) +#define DV_AMPR LSFT(DV_7) +#define DV_ASTR LSFT(DV_8) +#define DV_LPRN LSFT(DV_9) +#define DV_RPRN LSFT(DV_0) +#define DV_LCBR LSFT(DV_LBRC) +#define DV_RCBR LSFT(DV_RBRC) + +#endif
\ No newline at end of file diff --git a/quantum/keymap_extras/keymap_french.h b/quantum/keymap_extras/keymap_french.h new file mode 100644 index 0000000000..ccfaed8f07 --- /dev/null +++ b/quantum/keymap_extras/keymap_french.h @@ -0,0 +1,83 @@ +#ifndef KEYMAP_FRENCH_H +#define KEYMAP_FRENCH_H + +#include "keymap_common.h" + +// Alt gr +#define ALGR(kc) kc | 0x1400 +#define NO_ALGR KC_RALT + +// Normal characters +#define FR_SUP2 KC_GRV +#define FR_AMP KC_1 +#define FR_EACU KC_2 +#define FR_QUOT KC_3 +#define FR_APOS KC_4 +#define FR_LPRN KC_5 +#define FR_MINS KC_6 +#define FR_EGRV KC_7 +#define FR_UNDS KC_8 +#define FR_CCED KC_9 +#define FR_AGRV KC_0 +#define FR_RPRN KC_MINS +#define FR_EQL KC_EQL + +#define FR_A KC_Q +#define FR_Z KC_W +#define FR_CIRC KC_LBRC +#define FR_DLR KC_RBRC + +#define FR_Q KC_A +#define FR_M KC_SCLN +#define FR_UGRV KC_QUOT +#define FR_ASTR KC_NUHS + +#define FR_LESS KC_NUBS +#define FR_W KC_Z +#define FR_COMM KC_M +#define FR_SCLN KC_COMM +#define FR_COLN KC_DOT +#define FR_EXLM KC_SLSH + +// Shifted characters +#define FR_1 LSFT(KC_1) +#define FR_2 LSFT(KC_2) +#define FR_3 LSFT(KC_3) +#define FR_4 LSFT(KC_4) +#define FR_5 LSFT(KC_5) +#define FR_6 LSFT(KC_6) +#define FR_7 LSFT(KC_7) +#define FR_8 LSFT(KC_8) +#define FR_9 LSFT(KC_9) +#define FR_0 LSFT(KC_0) +#define FR_OVRR LSFT(FR_RPRN) +#define FR_PLUS LSFT(FR_EQL) + +#define FR_UMLT LSFT(FR_CIRC) +#define FR_PND LSFT(FR_DLR) +#define FR_PERC LSFT(FR_UGRV) +#define FR_MU LSFT(FR_ASTR) + +#define FR_GRTR LSFT(FR_LESS) +#define FR_QUES LSFT(FR_COMM) +#define FR_DOT LSFT(FR_SCLN) +#define FR_SLSH LSFT(FR_COLN) +#define FR_SECT LSFT(FR_EXLM) + +// Alt Gr-ed characters +#define FR_TILD ALGR(KC_2) +#define FR_HASH ALGR(KC_3) +#define FR_LCBR ALGR(KC_4) +#define FR_LBRC ALGR(KC_5) +#define FR_PIPE ALGR(KC_6) +#define FR_GRV ALGR(KC_7) +#define FR_BSLS ALGR(KC_8) +#define FR_CIRC ALGR(KC_9) +#define FR_AT ALGR(KC_0) +#define FR_RBRC ALGR(FR_RPRN) +#define FR_LCBR ALGR(FR_EQL) + +#define FR_EURO ALGR(KC_E) +#define FR_BULT ALGR(FR_DLR) + +#endif
\ No newline at end of file diff --git a/quantum/keymap_extras/keymap_nordic.h b/quantum/keymap_extras/keymap_nordic.h new file mode 100644 index 0000000000..02a704216a --- /dev/null +++ b/quantum/keymap_extras/keymap_nordic.h @@ -0,0 +1,59 @@ +#ifndef KEYMAP_NORDIC_H +#define KEYMAP_NORDIC_H + +#include "keymap_common.h" + +// Alt gr +#define ALGR(kc) kc | 0x1400 +#define NO_ALGR KC_RALT + +// Normal characters +#define NO_HALF KC_GRV +#define NO_PLUS KC_MINS +#define NO_ACUT KC_EQL + +#define NO_AM KC_LBRC +#define NO_QUOT KC_RBRC +#define NO_AE KC_SCLN +#define NO_OSLH KC_QUOT +#define NO_APOS KC_NUHS + +#define NO_LESS KC_NUBS +#define NO_MINS KC_SLSH + +// Shifted characters +#define NO_SECT LSFT(NO_HALF) +#define NO_QUO2 LSFT(KC_2) +#define NO_BULT LSFT(KC_4) +#define NO_AMP LSFT(KC_6) +#define NO_SLSH LSFT(KC_7) +#define NO_LPRN LSFT(KC_8) +#define NO_RPRN LSFT(KC_9) +#define NO_EQL LSFT(KC_0) +#define NO_QUES LSFT(NO_PLUS) +#define NO_GRV LSFT(NO_ACUT) + +#define NO_CIRC LSFT(NO_QUOT) + +#define NO_GRTR LSFT(NO_LESS) +#define NO_SCLN LSFT(KC_COMM) +#define NO_COLN LSFT(KC_DOT) +#define NO_UNDS LSFT(NO_MINS) + +// Alt Gr-ed characters +#define NO_AT ALGR(KC_2) +#define NO_PND ALGR(KC_3) +#define NO_DLR ALGR(KC_4) +#define NO_LCBR ALGR(KC_7) +#define NO_LBRC ALGR(KC_8) +#define NO_RBRC ALGR(KC_9) +#define NO_RCBR ALGR(KC_0) +#define NO_PIPE ALGR(NO_ACUT) + +#define NO_EURO ALGR(KC_E) +#define NO_TILD ALGR(NO_QUOT) + +#define NO_BSLS ALGR(NO_LESS) +#define NO_MU ALGR(KC_M) + +#endif
\ No newline at end of file diff --git a/quantum/keymap_extras/keymap_spanish.h b/quantum/keymap_extras/keymap_spanish.h new file m |