diff options
Diffstat (limited to 'keyboard/atomic')
41 files changed, 207 insertions, 3280 deletions
diff --git a/keyboard/atomic/Makefile b/keyboard/atomic/Makefile index 02153214f3..e678b4efa8 100644 --- a/keyboard/atomic/Makefile +++ b/keyboard/atomic/Makefile @@ -39,52 +39,24 @@ #---------------------------------------------------------------------------- # Target file name (without extension). -TARGET = atomic_lufa +TARGET = atomic + # Directory common source filess exist TOP_DIR = ../.. +TMK_DIR = ../../tmk_core # Directory keyboard dependent files exist TARGET_DIR = . # # project specific files -ifdef COMMON - - SRC = keymap_common.c \ - led.c \ - backlight.c +SRC = atomic.c \ + backlight.c ifdef KEYMAP - SRC := common_keymaps/keymap_$(KEYMAP).c $(SRC) -else - SRC := common_keymaps/keymap_jack.c $(SRC) -endif - -ifdef MATRIX - SRC := matrix_$(MATRIX).c $(SRC) + SRC := keymaps/keymap_$(KEYMAP).c $(SRC) else - SRC := matrix_pcb.c $(SRC) -endif - -else - -SRC = extended_keymap_common.c \ - analog.c \ - led.c \ - backlight.c - -ifdef KEYMAP - SRC := extended_keymaps/extended_keymap_$(KEYMAP).c $(SRC) -else - SRC := extended_keymaps/extended_keymap_default.c $(SRC) -endif - -ifdef MATRIX - SRC := matrix_$(MATRIX).c $(SRC) -else - SRC := matrix_pcb.c $(SRC) -endif - + SRC := keymaps/keymap_default.c $(SRC) endif CONFIG_H = config.h @@ -148,9 +120,13 @@ EXTRAKEY_ENABLE = yes # Audio control and System control(+450) CONSOLE_ENABLE = yes # Console for debug(+400) COMMAND_ENABLE = yes # Commands for debug and configuration # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE -#SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend -NKRO_ENABLE = yes # USB Nkey Rollover - not yet supported in LUFA +# SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend +# NKRO_ENABLE = yes # USB Nkey Rollover - not yet supported in LUFA BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality +# MIDI_ENABLE = YES # MIDI controls +# UNICODE_ENABLE = YES # Unicode +# BLUETOOTH_ENABLE = yes # Enable Bluetooth with the Adafruit EZ-Key HID + # Optimize size but this may cause error "relocation truncated to fit" #EXTRALDFLAGS = -Wl,--relax @@ -158,7 +134,7 @@ BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality # Search Path VPATH += $(TARGET_DIR) VPATH += $(TOP_DIR) +VPATH += $(TMK_DIR) + +include $(TOP_DIR)/quantum/quantum.mk -include $(TOP_DIR)/protocol/lufa.mk -include $(TOP_DIR)/common.mk -include $(TOP_DIR)/rules.mk diff --git a/keyboard/atomic/Makefile.pjrc b/keyboard/atomic/Makefile.pjrc deleted file mode 100644 index be83ba18b1..0000000000 --- a/keyboard/atomic/Makefile.pjrc +++ /dev/null @@ -1,116 +0,0 @@ -#---------------------------------------------------------------------------- -# On command line: -# -# make all = Make software. -# -# make clean = Clean out built project files. -# -# make coff = Convert ELF to AVR COFF. -# -# make extcoff = Convert ELF to AVR Extended COFF. -# -# make program = Download the hex file to the device. -# Please customize your programmer settings(PROGRAM_CMD) -# -# make teensy = Download the hex file to the device, using teensy_loader_cli. -# (must have teensy_loader_cli installed). -# -# make dfu = Download the hex file to the device, using dfu-programmer (must -# have dfu-programmer installed). -# -# make flip = Download the hex file to the device, using Atmel FLIP (must -# have Atmel FLIP installed). -# -# make dfu-ee = Download the eeprom file to the device, using dfu-programmer -# (must have dfu-programmer installed). -# -# make flip-ee = Download the eeprom file to the device, using Atmel FLIP -# (must have Atmel FLIP installed). -# -# make debug = Start either simulavr or avarice as specified for debugging, -# with avr-gdb or avr-insight as the front end for debugging. -# -# make filename.s = Just compile filename.c into the assembler code only. -# -# make filename.i = Create a preprocessed source file for use in submitting -# bug reports to the GCC project. -# -# To rebuild project do "make clean" then "make all". -#---------------------------------------------------------------------------- - -# Target file name (without extension). -TARGET = gh60_pjrc - -# Directory common source filess exist -TOP_DIR = ../.. - -# Directory keyboard dependent files exist -TARGET_DIR = . - -# project specific files -SRC = keymap_common.c \ - matrix.c \ - led.c - -ifdef KEYMAP - SRC := keymap_$(KEYMAP).c $(SRC) -else - SRC := keymap_jack.c $(SRC) -endif - -CONFIG_H = config.h - - -# MCU name, you MUST set this to match the board you are using -# type "make clean" after changing this, so all files will be rebuilt -MCU = atmega32u4 -#MCU = at90usb1286 - - -# Processor frequency. -# Normally the first thing your program should do is set the clock prescaler, -# so your program will run at the correct speed. You should also set this -# variable to same clock speed. The _delay_ms() macro uses this, and many -# examples use this variable to calculate timings. Do not add a "UL" here. -F_CPU = 16000000 - - -# Boot Section Size in *bytes* -# Teensy halfKay 512 -# Atmel DFU loader 4096 -# LUFA bootloader 4096 -OPT_DEFS += -DBOOTLOADER_SIZE=4096 - - -# Build Options -# comment out to disable the options. -# -BOOTMAGIC_ENABLE = yes # Virtual DIP switch configuration(+1000) -MOUSEKEY_ENABLE = yes # Mouse keys(+5000) -EXTRAKEY_ENABLE = yes # Audio control and System control(+600) -CONSOLE_ENABLE = yes # Console for debug -COMMAND_ENABLE = yes # Commands for debug and configuration -SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend -NKRO_ENABLE = yes # USB Nkey Rollover(+500) -#PS2_MOUSE_ENABLE = yes # PS/2 mouse(TrackPoint) support - - -# Search Path -VPATH += $(TARGET_DIR) -VPATH += $(TOP_DIR) - -include $(TOP_DIR)/protocol/pjrc.mk -include $(TOP_DIR)/common.mk -include $(TOP_DIR)/rules.mk - -plain: OPT_DEFS += -DKEYMAP_PLAIN -plain: all - -poker: OPT_DEFS += -DKEYMAP_POKER -poker: all - -poker_set: OPT_DEFS += -DKEYMAP_POKER_SET -poker_set: all - -poker_bit: OPT_DEFS += -DKEYMAP_POKER_BIT -poker_bit: all diff --git a/keyboard/atomic/PCB_GUIDE.md b/keyboard/atomic/PCB_GUIDE.md deleted file mode 100644 index 833e144b3b..0000000000 --- a/keyboard/atomic/PCB_GUIDE.md +++ /dev/null @@ -1,110 +0,0 @@ -# Planck Firmware Guide - -## Setting up the environment - -### Windows -1. Install [MHV AVR Tools][mhv] for AVR GCC compiler and [Cygwin][cygwin](or [MinGW][mingw]) for shell terminal. -2. Install [DFU-Programmer][dfu-prog] (the -win one). -3. Start DFU bootloader on the chip first time you will see 'Found New Hardware Wizard' to install driver. If you install device driver properly you can find chip name like 'ATmega32U4' under 'LibUSB-Win32 Devices' tree on 'Device Manager'. If not you will need to update its driver on 'Device Manager' to the `dfu-programmer` driver. - -### Mac -1. Install [CrossPack](https://www.obdev.at/downloads/crosspack/CrossPack-AVR-20131216.dmg). -2. Install [DFU-Programmer][dfu-prog]. - -### Linux -1. Install AVR GCC with your favorite package manager. -2. Install [DFU-Programmer][dfu-prog]. - -## Using the built-in functions - -Here is a list of some of the functions avaiable from the command line: - -* `make clean`: clean the environment - may be required in-between builds -* `make`: compile the code -* `make COMMON=true`: compile with the common (non-extended) keymap -* `make KEYMAP=<keymap>`: compile with the extended keymap file `extended_keymaps_extended_keymap_<keymap>.c` -* `make COMMON=true KEYMAP=<keymap>`: compile with the common keymap file `common_keymaps/keymap_<keymap>.c` -* `make dfu`: build and flash the layout to the PCB -* `make dfu-force`: build and force-flash the layout to the PCB (may be require for first flash) - -Generally, the instructions to flash the PCB are as follows: - -1. Make changes to the appropriate keymap file -2. Save the file -3. `make clean` -4. Press the reset button on the PCB/press the key with the `RESET` keycode -5. `make <arguments> dfu` - use the necessary `KEYMAP=<keymap>` and/or `COMMON=true` arguments here. - -## Extended keymap - -### Keymap - -Unlike the common keymap, prefixing the keycodes with `KC_` is required. A full list of the keycodes is available [here](https://github.com/jackhumbert/tmk_keyboard/blob/master/doc/keycode.txt). For the keycodes available only in the extended keymap, see this [header file](https://github.com/jackhumbert/tmk_keyboard/blob/master/keyboard/planck/extended_keymap_common.h). - -You can use modifiers with keycodes like this: - - LCTL(KC_C) - -Which will generate Ctrl+c. These are daisy-chainable, meaning you can do things like: - - LCTL(LALT(KC_C)) - -That will generate Ctrl+Alt+c. The entire list of these functions is here: - -* `LCTL()`: Left control -* `LSFT()` / `S()`: Left shift -* `LALT()`: Left alt/opt -* `LGUI()`: Left win/cmd -* `RCTL()`: Right control -* `RSFT()`: Right shift -* `RALT()`: Right alt/opt -* `RGUI()`: Right win/cmd - -`S(KC_1)`-like entries are useful in writing keymaps for the Planck. - -### Other keycodes - -A number of other keycodes have been added that you may find useful: - -* `CM_<key>`: the Colemak equivalent of a key (in place of `KC_<key>`), when using Colemak in software (`CM_O` generates `KC_SCLN`) -* `RESET`: jump to bootloader for flashing (same as press the reset button) -* `BL_STEP`: step through the backlight brightnesses -* `BL_<0-15>`: set backlight brightness to 0-15 -* `BL_DEC`: lower the backlight brightness -* `BL_INC`: raise the backlight brightness -* `BL_TOGG`: toggle the backlight on/off - -### Function layers - -The extended keymap extends the number of function layers from 32 to the near-infinite value of 256. Rather than using `FN<num>` notation (still avaiable, but limited to `FN0`-`FN31`), you can use the `FUNC(<num>)` notation. `F(<num>)` is a shortcut for this. - -The function actions are unchanged, and you can see the full list of them [here](https://github.com/jackhumbert/tmk_keyboard/blob/master/common/action_code.h). They are explained in detail [here](https://github.com/jackhumbert/tmk_keyboard/blob/master/doc/keymap.md#2-action). - -### Macros - -Macros have been setup in the `extended_keymaps/extended_keymaps_default.c` file so that you can use `M(<num>)` to access a macro in the `action_get_macro` section on your keymap. The switch/case structure you see here is required, and is setup for `M(0)` - you'll need to copy and paste the code to look like this (e.g. to support `M(3)`): - - switch(id) { - case 0: - return MACRODOWN(TYPE(KC_A), END); - break; - case 1: - return MACRODOWN(TYPE(KC_B), END); - break; - case 2: - return MACRODOWN(TYPE(KC_C), END); - break; - case 3: - return MACRODOWN(TYPE(KC_D), END); - break; - } - return MACRO_NONE; - -`MACRODOWN()` is a shortcut for `(record->event.pressed ? MACRO(__VA_ARGS__) : MACRO_NONE)` which tells the macro to execute when the key is pressed. Without this, the macro will be executed on both the down and up stroke. - -[cygwin]: https://www.cygwin.com/ -[mingw]: http://www.mingw.org/ -[mhv]: https://infernoembedded.com/products/avr-tools -[winavr]: http://winavr.sourceforge.net/ -[crosspack]: http://www.obdev.at/products/crosspack/index.html -[dfu-prog]: http://dfu-programmer.sourceforge.net/ diff --git a/keyboard/atomic/README.md b/keyboard/atomic/README.md index 3ddaed3a39..5e67270158 100644 --- a/keyboard/atomic/README.md +++ b/keyboard/atomic/README.md @@ -2,55 +2,180 @@ Atomic keyboard firmware ====================== DIY/Assembled ortholinear 60% keyboard by [Ortholinear Keyboards](http://ortholinearkeyboards.com). -## Extended Keymap -If you include extended_keymap_common.h instead of keymap_common.h at the top of your file, you'll have access to a bunch of goodies:t +## Quantum MK Firmware -- Use `LSFT()`, `LCTL()`, et. al. (listed in extended_keymap_common.h) as modifiers for keys (daisy-chain-able) -- Use `FUNC(1)` instead of `FN1` (etc.) to access the function layers beyond the 32 function layer limit -- Use `CM_F` instead of `KC_F` to get the ColeMak equivilent for shortcuts (maps backwards) -- Use `MACRODOWN()` instead of `MACRO()` to easily make a keydown macro (`CM_*` works here too) +You have access to a bunch of goodies! Check out the Makefile to enable/disable some of the features. Uncomment the `#` to enable them. Setting them to `no` does nothing and will only confuse future you. -### Some notes on usage: + BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality + MIDI_ENABLE = yes # MIDI controls + # UNICODE_ENABLE = yes # Unicode support - this is commented out, just as an example. You have to use #, not // + BLUETOOTH_ENABLE = yes # Enable Bluetooth with the Adafruit EZ-Key HID -- The `KEYMAP()` macro is unable to be used due to the bitwise modifications that take place - refer to extended_keymap_jack.c to see how to set things up with the `KC_` prefix -- Keep an eye on the Makefile - this needs to include the correct files to work -- Don't forget to use `const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {` instead of the 8bit equivilent +## Quick aliases to common actions -## Build +Your keymap can include shortcuts to common operations (called "function actions" in tmk). -Follow [this guide](http://deskthority.net/workshop-f7/how-to-build-your-very-own-keyboard-firmware-t7177.html) to setup your development environment before anything else. Abbreviated instructions are provide at the [bottom of this document](https://github.com/rswiernik/tmk_keyboard/tree/rswiernik_dev/keyboard/planck#environment-setup) +### Switching and toggling layers -Download the whole firmware [here](https://github.com/jackhumbert/tmk_keyboard/archive/master.zip) and navigate to the keyboard/planck folder. Once your dev env is setup, you'll be able to type `make` to generate your .hex that you can load with the Teensy app onto your Planck (once you've hit reset/shorted GND & RST). +`MO(layer)` - momentary switch to *layer*. As soon as you let go of the key, the layer is deactivated and you pop back out to the previous layer. When you apply this to a key, that same key must be set as `KC_TRNS` on the destination layer. Otherwise, you won't make it back to the original layer when you release the key (and you'll get a keycode sent). You can only switch to layers *above* your current layer. If you're on layer 0 and you use `MO(1)`, that will switch to layer 1 just fine. But if you include `MO(3)` on layer 5, that won't do anything for you -- because layer 3 is lower than layer 5 on the stack. -Depending on which keymap you would like to use, you will have to compile slightly differently. +`LT(layer, kc)` - momentary switch to *layer* when held, and *kc* when tapped. Like `MO()`, this only works upwards in the layer stack (`layer` must be higher than the current layer). -####Default -To build with the default keymap, simply move to the tmk\_keyboard/keyboard/planck/ and run `make` as follows: -``` -$ make -``` +`TG(layer)` - toggles a layer on or off. As with `MO()`, you should set this key as `KC_TRNS` in the destination layer so that tapping it again actually toggles back to the original layer. Only works upwards in the layer stack. -## Keymap -Several version of keymap are available in advance but you are recommended to define your favorite layout yourself. To define your own keymap create file named `keymap_<name>.c` and see keymap document (you can find in top README.md) and existent keymap files. - -####**Extended Keymaps** +### Fun with modifier keys -To build the firmware binary hex file with an extended keymap just do `make` with `KEYMAP` option like: -``` -$ make KEYMAP=[common|jack|<name>] +* `LSFT(kc)` - applies left Shift to *kc* (keycode) - `S(kc)` is an alias +* `RSFT(kc)` - applies right Shift to *kc* +* `LCTL(kc)` - applies left Control to *kc* +* `RCTL(kc)` - applies right Control to *kc* +* `LALT(kc)` - applies left Alt to *kc* +* `RALT(kc)` - applies right Alt to *kc* +* `LGUI(kc)` - applies left GUI (command/win) to *kc* +* `RGUI(kc)` - applies right GUI (command/win) to *kc* + +You can also chain these, like this: + + LALT(LCTL(KC_DEL)) -- this makes a key that sends Alt, Control, and Delete in a single keypress. + +The following shortcuts automatically add `LSFT()` to keycodes to get commonly used symbols. Their long names are also available and documented in `/quantum/keymap_common.h`. + + KC_TILD ~ + KC_EXLM ! + KC_AT @ + KC_HASH # + KC_DLR $ + KC_PERC % + KC_CIRC ^ + KC_AMPR & + KC_ASTR * + KC_LPRN ( + KC_RPRN ) + KC_UNDS _ + KC_PLUS + + KC_LCBR { + KC_RCBR } + KC_PIPE | + KC_COLN : + +`MT(mod, kc)` - is *mod* (modifier key - MOD_LCTL, MOD_LSFT) when held, and *kc* when tapped. In other words, you can have a key that sends Esc (or the letter O or whatever) when you tap it, but works as a Control key or a Shift key when you hold it down. + +These are the values you can use for the `mod` in `MT()` (right-hand modifiers are not available): + + * MOD_LCTL + * MOD_LSFT + * MOD_LALT + * MOD_LGUI + +These can also be combined like `MOD_LCTL | MOD_LSFT` e.g. `MT(MOD_LCTL | MOD_LSFT, KC_ESC)` which would activate Control and Shift when held, and send Escape when tapped. + +We've added shortcuts to make common modifier/tap (mod-tap) mappings more compact: + + * `CTL_T(kc)` - is LCTL when held and *kc* when tapped + * `SFT_T(kc)` - is LSFT when held and *kc* when tapped + * `ALT_T(kc)` - is LALT when held and *kc* when tapped + * `GUI_T(kc)` - is LGUI when held and *kc* when tapped + * `ALL_T(kc)` - is Hyper (all mods) when held and *kc* when tapped. To read more about what you can do with a Hyper key, see [this blog post by Brett Terpstra](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/) + +### Temporarily setting the default layer + +`DF(layer)` - sets default layer to *layer*. The default layer is the one at the "bottom" of the layer stack - the ultimate fallback layer. This currently does not persist over power loss. When you plug the keyboard back in, layer 0 will always be the default. It is theoretically possible to work around that, but that's not what `DF` does. + +### Remember: These are just aliases + +These functions work the same way that their `ACTION_*` functions do - they're just quick aliases. To dig into all of the tmk ACTION_* functions, please see the [TMK documentation](https://github.com/jackhumbert/qmk_firmware/blob/master/tmk_core/doc/keymap.md#2-action). + +Instead of using `FNx` when defining `ACTION_*` functions, you can use `F(x)` - the benefit here is being able to use more than 32 function actions (up to 4096), if you happen to need them. + +## Macro shortcuts: Send a whole string when pressing just one key + +Instead of using the `ACTION_MACRO` function, you can simply use `M(n)` to access macro *n* - *n* will get passed into the `action_get_macro` as the `id`, and you can use a switch statement to trigger it. This gets called on the keydown and keyup, so you'll need to use an if statement testing `record->event.pressed` (see keymap_default.c). + +```c +const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) // this is the function signature -- just copy/paste it into your keymap file as it is. +{ + switch(id) { + case 0: // this would trigger when you hit a key mapped as M(0) + if (record->event.pressed) { + return MACRO( I(255), T(H), T(E), T(L), T(L), W(255), T(O), END ); // this sends the string 'hello' when the macro executes + } + break; + } + return MACRO_NONE; +}; ``` -_The only applicable keymaps will work with this option._ Extended keymaps follow the format **__extended\_keymap\_\<name\>.c__** +A macro can include the following commands: + +* I() change interval of stroke in milliseconds. +* D() press key. +* U() release key. +* T() type key(press and release). +* W() wait (milliseconds). +* END end mark. + +So above you can see the stroke interval changed to 255ms between each keystroke, then a bunch of keys being typed, waits a while, then the macro ends. -####**Common Keymaps** +Note: Using macros to have your keyboard send passwords for you is a bad idea. -Building with a common keymap is as simple as adding the COMMON option. Note that only +### Additional keycode aliases for software-implemented layouts (Colemak, Dvorak, etc) + +Everything is assuming you're in Qwerty (in software) by default, but there is built-in support for using a Colemak or Dvorak layout by including this at the top of your keymap: + + #include "keymap_<layout>.h" + +Where <layout> is "colemak" or "dvorak". After including this line, you will get access to: + + * `CM_*` for all of the Colemak-equivalent characters + * `DV_*` for all of the Dvorak-equivalent characters + +These implementations assume you're using Colemak or Dvorak on your OS, not on your keyboard - this is referred to as a software-implemented layout. If your computer is in Qwerty and your keymap is in Colemak or Dvorak, this is referred to as a firmware-implemented layout, and you won't need these features. + +To give an example, if you're using software-implemented Colemak, and want to get an `F`, you would use `CM_F` - `KC_F` under these same circumstances would result in `T`. + +## Additional language support + +In `quantum/keymap_extras/`, you'll see various language files - these work the same way as the alternative layout ones do. Most are defined by their two letter country/language code followed by an underscore and a 4-letter abbreviation of its name. `FR_UGRV` which will result in a `รน` when using a software-implemented AZERTY layout. It's currently difficult to send such characters in just the firmware (but it's being worked on - see Unicode support). + +## Unicode support + +You can currently send 4 hex digits with your OS-specific modifier key (RALT for OSX with the "Unicode Hex Input" layout) - this is currently limited to supporting one OS at a time, and requires a recompile for switching. 8 digit hex codes are being worked on. The keycode function is `UC(n)`, where *n* is a 4 digit hexidecimal. Enable from the Makefile. + +## Other firmware shortcut keycodes + +* `RESET` - puts the MCU in DFU mode for flashing new firmware (with `make dfu`) +* `DEBUG` - the firmware into debug mode - you'll need hid_listen to see things +* `BL_ON` - turns the backlight on +* `BL_OFF` - turns the backlight off +* `BL_<n>` - sets the backlight to level *n* +* `BL_INC` - increments the backlight level by one +* `BL_DEC` - decrements the backlight level by one +* `BL_TOGG` - toggles the backlight +* `BL_STEP` - steps through the backlight levels + +Enable the backlight from the Makefile. + +## MIDI functionalty + +This is still a WIP, but check out `quantum/keymap_midi.c` to see what's happening. Enable from the Makefile. + +## Bluetooth functionality + +This requires [some hardware changes](https://www.reddit.com/r/MechanicalKeyboards/comments/3psx0q/the_planck_keyboard_with_bluetooth_guide_and/?ref=search_posts), but can be enabled via the Makefile. The firmware will still output characters via USB, so be aware of this when charging via a computer. It would make sense to have a switch on the Bluefruit to turn it off at will. + +## Building + +Download or clone the whole firmware and navigate to the keyboard/planck folder. Once your dev env is setup, you'll be able to type `make` to generate your .hex - you can then use `make dfu` to program your PCB once you hit the reset button. + +Depending on which keymap you would like to use, you will have to compile slightly differently. + +### Default +To build with the default keymap, simply run `make`. + +### Other Keymaps +Several version of keymap are available in advance but you are recommended to define your favorite layout yourself. To define your own keymap create file named `keymap_<name>.c` and see keymap document (you can find in top README.md) and existent keymap files. + +To build the firmware binary hex file with a keymap just do `make` with `KEYMAP` option like: ``` -$ make KEYMAP=[common|jack|<name>] COMMON=true +$ make KEYMAP=[default|jack|<name>] ``` -_The only applicable keymaps will work with this option._ Common keymaps follow the format **__keymap\_\<name\>.c__** - -## Notable TMK forks (which some of the keymap files are from) -- [Shane's Fork](https://github.com/shanecelis/tmk_keyboard/tree/master/keyboard/planck) -- [Pierre's Fork](https://github.com/pcarrier/tmk_keyboard/blob/pcarrier/planck/keyboard/gh60/keymap_planck.c) -- [Nathan's Fork](https://github.com/nathanrosspowell/tmk_keyboard/tree/planck-jack/keyboard/planck) -- [Matthew's Fork](https://github.com/pepers/tmk_keyboard/tree/master/keyboard/planck_grid) +Keymaps follow the format **__keymap\_\<name\>.c__** and are stored in the `keymaps` folder. diff --git a/keyboard/atomic/__avr_gdbinit b/keyboard/atomic/__avr_gdbinit deleted file mode 100644 index afc51e6d19..0000000000 --- a/keyboard/atomic/__avr_gdbinit +++ /dev/null @@ -1,6 +0,0 @@ -define reset -SIGNAL SIGHUP -end -file planck_lufa.elf -target remote localhost:4242 -break main diff --git a/keyboard/atomic/analog.c b/keyboard/atomic/analog.c deleted file mode 100644 index 49b84ee0e8..0000000000 --- a/keyboard/atomic/analog.c +++ /dev/null @@ -1,53 +0,0 @@ -// 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; |