Add user-overridable callback for cancelling UCIS input (#5564)

* Add user-overridable callback for cancelling UCIS input

To clean up things from qk_ucis_start_user() for instance.

* restore lost newline to quantum/process_keycode/process_ucis.c

Co-Authored-By: shinmai <[email protected]>

.editorconfig

@@ -16,6 +16,10 @@ insert_final_newline = true
 trim_trailing_whitespace = false
 indent_size = 4
 
+[{qmk,*.py}]
+charset = utf-8
+max_line_length = 200
+
 # Make these match what we have in .gitattributes
 [*.mk]
 end_of_line = lf

.gitignore

@@ -70,3 +70,6 @@ util/Win_Check_Output.txt
 secrets.tar
 id_rsa_*
 /.vs
+
+# python things
+__pycache__

.travis.yml

@@ -13,8 +13,6 @@ env:
   - MAKEFLAGS="-j3 --output-sync"
 services:
   - docker
-before_install:
-  - docker build -t qmkfm/qmk_firmware .
 install:
   - npm install -g moxygen
 script:

Dockerfile

@@ -1,26 +1,4 @@
-FROM debian:9
+FROM qmkfm/base_container
-
-RUN apt-get update && apt-get install --no-install-recommends -y \
-    avr-libc \
-    avrdude \
-    binutils-arm-none-eabi \
-    binutils-avr \
-    build-essential \
-    dfu-programmer \
-    dfu-util \
-    gcc \
-    gcc-avr \
-    git \
-    libnewlib-arm-none-eabi \
-    software-properties-common \
-    unzip \
-    wget \
-    zip \
-    && rm -rf /var/lib/apt/lists/*
-
-# upgrade gcc-arm-none-eabi from the default 5.4.1 to 6.3.1 due to ARM runtime issues
-RUN wget -q https://developer.arm.com/-/media/Files/downloads/gnu-rm/6-2017q2/gcc-arm-none-eabi-6-2017-q2-update-linux.tar.bz2 -O - | \
-    tar xj --strip-components=1 -C /
 
 VOLUME /qmk_firmware
 WORKDIR /qmk_firmware

bin/qmk

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""CLI wrapper for running QMK commands.
+"""
+import os
+import subprocess
+import sys
+from glob import glob
+from time import strftime
+from importlib import import_module
+from importlib.util import find_spec
+
+# Add the QMK python libs to our path
+script_dir = os.path.dirname(os.path.realpath(__file__))
+qmk_dir = os.path.abspath(os.path.join(script_dir, '..'))
+python_lib_dir = os.path.abspath(os.path.join(qmk_dir, 'lib', 'python'))
+sys.path.append(python_lib_dir)
+
+# Change to the root of our checkout
+os.environ['ORIG_CWD'] = os.getcwd()
+os.chdir(qmk_dir)
+
+# Make sure our modules have been setup
+with open('requirements.txt', 'r') as fd:
+    for line in fd.readlines():
+        line = line.strip().replace('<', '=').replace('>', '=')
+
+        if line[0] == '#':
+            continue
+
+        if '#' in line:
+            line = line.split('#')[0]
+
+        module = line.split('=')[0] if '=' in line else line
+        if not find_spec(module):
+            print('Your QMK build environment is not fully setup!\n')
+            print('Please run `./util/qmk_install.sh` to setup QMK.')
+            exit(255)
+
+# Figure out our version
+command = ['git', 'describe', '--abbrev=6', '--dirty', '--always', '--tags']
+result = subprocess.run(command, text=True, capture_output=True)
+
+if result.returncode == 0:
+    os.environ['QMK_VERSION'] = 'QMK ' + result.stdout.strip()
+else:
+    os.environ['QMK_VERSION'] = 'QMK ' + strftime('%Y-%m-%d-%H:%M:%S')
+
+# Setup the CLI
+import milc
+milc.EMOJI_LOGLEVELS['INFO'] = '{fg_blue}ψ{style_reset_all}'
+
+# If we were invoked as `qmk <cmd>` massage sys.argv into `qmk-<cmd>`.
+# This means we can't accept arguments to the qmk script itself.
+script_name = os.path.basename(sys.argv[0])
+if script_name == 'qmk':
+    if len(sys.argv) == 1:
+        milc.cli.log.error('No subcommand specified!\n')
+
+    if len(sys.argv) == 1 or sys.argv[1] in ['-h', '--help']:
+        milc.cli.echo('usage: qmk <subcommand> [...]')
+        milc.cli.echo('\nsubcommands:')
+        subcommands = glob(os.path.join(qmk_dir, 'bin', 'qmk-*'))
+        for subcommand in sorted(subcommands):
+            subcommand = os.path.basename(subcommand).split('-', 1)[1]
+            milc.cli.echo('\t%s', subcommand)
+        milc.cli.echo('\nqmk <subcommand> --help for more information')
+        exit(1)
+
+    if sys.argv[1] in ['-V', '--version']:
+        milc.cli.echo(os.environ['QMK_VERSION'])
+        exit(0)
+
+    sys.argv[0] = script_name = '-'.join((script_name, sys.argv[1]))
+    del sys.argv[1]
+
+# Look for which module to import
+if script_name == 'qmk':
+    milc.cli.print_help()
+    exit(0)
+elif not script_name.startswith('qmk-'):
+    milc.cli.log.error('Invalid symlink, must start with "qmk-": %s', script_name)
+else:
+    subcommand = script_name.replace('-', '.').replace('_', '.').split('.')
+    subcommand.insert(1, 'cli')
+    subcommand = '.'.join(subcommand)
+
+    try:
+        import_module(subcommand)
+    except ModuleNotFoundError as e:
+        if e.__class__.__name__ != subcommand:
+            raise
+
+        milc.cli.log.error('Invalid subcommand! Could not import %s.', subcommand)
+        exit(1)
+
+if __name__ == '__main__':
+    milc.cli()

bin/qmk-compile-json

@@ -0,0 +1 @@
+qmk

bin/qmk-doctor

@@ -0,0 +1 @@
+qmk

bin/qmk-hello

@@ -0,0 +1 @@
+qmk

bin/qmk-json-keymap

@@ -0,0 +1 @@
+qmk

bootloader.mk

@@ -76,6 +76,10 @@ ifeq ($(strip $(BOOTLOADER)), bootloadHID)
     OPT_DEFS += -DBOOTLOADER_BOOTLOADHID
     BOOTLOADER_SIZE = 4096
 endif
+ifeq ($(strip $(BOOTLOADER)), USBasp)
+    OPT_DEFS += -DBOOTLOADER_USBASP
+    BOOTLOADER_SIZE = 4096
+endif
 
 ifdef BOOTLOADER_SIZE
     OPT_DEFS += -DBOOTLOADER_SIZE=$(strip $(BOOTLOADER_SIZE))

build_json.mk

@@ -0,0 +1,27 @@
+# Look for a json keymap file
+ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_5)/keymap.json)","")
+    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
+    KEYMAP_JSON := $(MAIN_KEYMAP_PATH_5)/keymap.json
+    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_5)
+else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_4)/keymap.json)","")
+    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
+    KEYMAP_JSON := $(MAIN_KEYMAP_PATH_4)/keymap.json
+    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_4)
+else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_3)/keymap.json)","")
+    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
+    KEYMAP_JSON := $(MAIN_KEYMAP_PATH_3)/keymap.json
+    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_3)
+else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_2)/keymap.json)","")
+    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
+    KEYMAP_JSON := $(MAIN_KEYMAP_PATH_2)/keymap.json
+    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_2)
+else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.json)","")
+    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
+    KEYMAP_JSON := $(MAIN_KEYMAP_PATH_1)/keymap.json
+    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_1)
+endif
+
+# Generate the keymap.c
+ifneq ("$(KEYMAP_JSON)","")
+    _ = $(shell test -e $(KEYMAP_C) || bin/qmk-json-keymap $(KEYMAP_JSON) -o $(KEYMAP_C))
+endif

build_keyboard.mk

@@ -98,31 +98,38 @@ MAIN_KEYMAP_PATH_3 := $(KEYBOARD_PATH_3)/keymaps/$(KEYMAP)
 MAIN_KEYMAP_PATH_4 := $(KEYBOARD_PATH_4)/keymaps/$(KEYMAP)
 MAIN_KEYMAP_PATH_5 := $(KEYBOARD_PATH_5)/keymaps/$(KEYMAP)
 
-ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_5)/keymap.c)","")
+# Check for keymap.json first, so we can regenerate keymap.c
-    -include $(MAIN_KEYMAP_PATH_5)/rules.mk
+include build_json.mk
-    KEYMAP_C := $(MAIN_KEYMAP_PATH_5)/keymap.c
+
-    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_5)
+ifeq ("$(wildcard $(KEYMAP_PATH))", "")
-else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_4)/keymap.c)","")
+    # Look through the possible keymap folders until we find a matching keymap.c
-    -include $(MAIN_KEYMAP_PATH_4)/rules.mk
+    ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_5)/keymap.c)","")
-    KEYMAP_C := $(MAIN_KEYMAP_PATH_4)/keymap.c
+        -include $(MAIN_KEYMAP_PATH_5)/rules.mk
-    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_4)
+        KEYMAP_C := $(MAIN_KEYMAP_PATH_5)/keymap.c
-else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_3)/keymap.c)","")
+        KEYMAP_PATH := $(MAIN_KEYMAP_PATH_5)
-    -include $(MAIN_KEYMAP_PATH_3)/rules.mk
+    else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_4)/keymap.c)","")
-    KEYMAP_C := $(MAIN_KEYMAP_PATH_3)/keymap.c
+        -include $(MAIN_KEYMAP_PATH_4)/rules.mk
-    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_3)
+        KEYMAP_C := $(MAIN_KEYMAP_PATH_4)/keymap.c
-else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_2)/keymap.c)","")
+        KEYMAP_PATH := $(MAIN_KEYMAP_PATH_4)
-    -include $(MAIN_KEYMAP_PATH_2)/rules.mk
+    else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_3)/keymap.c)","")
-    KEYMAP_C := $(MAIN_KEYMAP_PATH_2)/keymap.c
+        -include $(MAIN_KEYMAP_PATH_3)/rules.mk
-    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_2)
+        KEYMAP_C := $(MAIN_KEYMAP_PATH_3)/keymap.c
-else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.c)","")
+        KEYMAP_PATH := $(MAIN_KEYMAP_PATH_3)
-    -include $(MAIN_KEYMAP_PATH_1)/rules.mk
+    else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_2)/keymap.c)","")
-    KEYMAP_C := $(MAIN_KEYMAP_PATH_1)/keymap.c
+        -include $(MAIN_KEYMAP_PATH_2)/rules.mk
-    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_1)
+        KEYMAP_C := $(MAIN_KEYMAP_PATH_2)/keymap.c
-else ifneq ($(LAYOUTS),)
+        KEYMAP_PATH := $(MAIN_KEYMAP_PATH_2)
-    include build_layout.mk
+    else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.c)","")
-else
+        -include $(MAIN_KEYMAP_PATH_1)/rules.mk
-    $(error Could not find keymap)
+        KEYMAP_C := $(MAIN_KEYMAP_PATH_1)/keymap.c
-    # this state should never be reached
+        KEYMAP_PATH := $(MAIN_KEYMAP_PATH_1)
+    else ifneq ($(LAYOUTS),)
+        # If we haven't found a keymap yet fall back to community layouts
+        include build_layout.mk
+    else
+        $(error Could not find keymap)
+        # this state should never be reached
+    endif
 endif
 
 ifeq ($(strip $(CTPC)), yes)
@@ -313,7 +320,6 @@ ifneq ("$(wildcard $(USER_PATH)/config.h)","")
     CONFIG_H += $(USER_PATH)/config.h
 endif
 
-
 # Object files directory
 #     To put object files in current directory, use a dot (.), do NOT make
 #     this an empty or blank macro!
@@ -323,7 +329,7 @@ ifneq ("$(wildcard $(KEYMAP_PATH)/config.h)","")
     CONFIG_H += $(KEYMAP_PATH)/config.h
 endif
 
-# # project specific files
+# project specific files
 SRC += $(KEYBOARD_SRC) \
     $(KEYMAP_C) \
     $(QUANTUM_SRC)
@@ -392,6 +398,7 @@ $(KEYBOARD_OUTPUT)_CONFIG := $(PROJECT_CONFIG)
 all: build check-size
 build: elf cpfirmware
 check-size: build
+objs-size: build
 
 include show_options.mk
 include $(TMK_PATH)/rules.mk

docs/_summary.md

@@ -8,6 +8,7 @@
 
 * [QMK Basics](README.md)
   * [QMK Introduction](getting_started_introduction.md)
+  * [QMK CLI](cli.md)
   * [Contributing to QMK](contributing.md)
   * [How to Use Github](getting_started_github.md)
   * [Getting Help](getting_started_getting_help.md)
@@ -34,6 +35,8 @@
   * [Keyboard Guidelines](hardware_keyboard_guidelines.md)
   * [Config Options](config_options.md)
   * [Keycodes](keycodes.md)
+  * [Coding Conventions - C](coding_conventions_c.md)
+  * [Coding Conventions - Python](coding_conventions_python.md)
   * [Documentation Best Practices](documentation_best_practices.md)
   * [Documentation Templates](documentation_templates.md)
   * [Glossary](reference_glossary.md)
@@ -41,6 +44,7 @@
   * [Useful Functions](ref_functions.md)
   * [Configurator Support](reference_configurator_support.md)
   * [info.json Format](reference_info_json.md)
+  * [Python Development](python_development.md)
 
 * [Features](features.md)
   * [Basic Keycodes](keycodes_basic.md)

docs/cli.md

@@ -0,0 +1,31 @@
+# QMK CLI
+
+This page describes how to setup and use the QMK CLI.
+
+# Overview
+
+The QMK CLI makes building and working with QMK keyboards easier. We have provided a number of commands to help you work with QMK:
+
+* `qmk compile-json`
+
+# Setup
+
+Simply add the `qmk_firmware/bin` directory to your `PATH`. You can run the `qmk` commands from any directory.
+
+```
+export PATH=$PATH:$HOME/qmk_firmware/bin
+```
+
+You may want to add this to your `.profile`, `.bash_profile`, `.zsh_profile`, or other shell startup scripts.
+
+# Commands
+
+## `qmk compile-json`
+
+This command allows you to compile JSON files you have downloaded from <https://config.qmk.fm>.
+
+**Usage**:
+
+```
+qmk compile-json mine.json
+```

docs/coding_conventions_c.md

@@ -0,0 +1,58 @@
+# Coding Conventions (C)
+
+Most of our style is pretty easy to pick up on, but right now it's not entirely consistent. You should match the style of the code surrounding your change, but if that code is inconsistent or unclear use the following guidelines:
+
+* We indent using four (4) spaces (soft tabs)
+* We use a modified One True Brace Style
+  * Opening Brace: At the end of the same line as the statement that opens the block
+  * Closing Brace: Lined up with the first character of the statement that opens the block
+  * Else If: Place the closing brace at the beginning of the line and the next opening brace at the end of the same line.
+  * Optional Braces: Always include optional braces.
+    * Good: if (condition) { return false; }
+    * Bad: if (condition) return false;
+* We encourage use of C style comments: `/* */`
+  * Think of them as a story describing the feature
+  * Use them liberally to explain why particular decisions were made.
+  * Do not write obvious comments
+  * If you not sure if a comment is obvious, go ahead and include it.
+* In general we don't wrap lines, they can be as long as needed. If you do choose to wrap lines please do not wrap any wider than 76 columns.
+* We use `#pragma once` at the start of header files rather than old-style include guards (`#ifndef THIS_FILE_H`, `#define THIS_FILE_H`, ..., `#endif`)
+* We accept both forms of preprocessor if's: `#ifdef DEFINED` and `#if defined(DEFINED)`
+  * If you are not sure which to prefer use the `#if defined(DEFINED)` form.
+  * Do not change existing code from one style to the other, except when moving to a multiple condition `#if`.
+  * Do not put whitespace between `#` and `if`.
+  * When deciding how (or if) to indent directives keep these points in mind:
+    * Readability is more important than consistency.
+    * Follow the file's existing style. If the file is mixed follow the style that makes sense for the section you are modifying.
+    * When choosing to indent you can follow the indention level of the surrounding C code, or preprocessor directives can have their own indent level. Choose the style that best communicates the intent of your code.
+
+Here is an example for easy reference:
+
+```c
+/* Enums for foo */
+enum foo_state {
+  FOO_BAR,
+  FOO_BAZ,
+};
+
+/* Returns a value */
+int foo(void) {
+  if (some_condition) {
+    return FOO_BAR;
+  } else {
+    return -1;
+  }
+}
+```
+
+# Auto-formatting with clang-format
+
+[Clang-format](https://clang.llvm.org/docs/ClangFormat.html) is part of LLVM and can automatically format your code for you, because ain't nobody got time to do it manually. We supply a configuration file for it that applies most of the coding conventions listed above. It will only change whitespace and newlines, so you will still have to remember to include optional braces yourself.
+
+Use the [full LLVM installer](http://llvm.org/builds/) to get clang-format on Windows, or use `sudo apt install clang-format` on Ubuntu.
+
+If you run it from the command-line, pass `-style=file` as an option and it will automatically find the .clang-format configuration file in the QMK root directory.
+
+If you use VSCode, the standard C/C++ plugin supports clang-format, alternatively there is a [separate extension](https://marketplace.visualstudio.com/items?itemName=LLVMExtensions.ClangFormat) for it.
+
+Some things (like LAYOUT macros) are destroyed by clang-format, so either don't run it on those files, or wrap the sensitive code in `// clang-format off` and `// clang-format on`.

docs/coding_conventions_python.md

@@ -0,0 +1,314 @@
+# Coding Conventions (Python)
+
+Most of our style follows PEP8 with some local modifications to make things less nit-picky. 
+
+* We target Python 3.5 for compatability with all supported platforms.
+* We indent using four (4) spaces (soft tabs)
+* We encourage liberal use of comments
+  * Think of them as a story describing the feature
+  * Use them liberally to explain why particular decisions were made.
+  * Do not write obvious comments
+  * If you not sure if a comment is obvious, go ahead and include it.
+* We require useful docstrings for all functions.
+* In general we don't wrap lines, they can be as long as needed. If you do choose to wrap lines please do not wrap any wider than 76 columns.
+* Some of our practices conflict with the wider python community to make our codebase more approachable to non-pythonistas.
+
+# YAPF
+
+You can use [yapf](https://github.com/google/yapf) to style your code. We provide a config in [setup.cfg](setup.cfg).
+
+# Imports
+
+We don't have a hard and fast rule for when to use `import ...` vs `from ... import ...`. Understandability and maintainability is our ultimate goal.
+
+Generally we prefer to import specific function and class names from a module to keep code shorter and easier to understand. Sometimes this results in a name that is ambiguous, and in such cases we prefer to import the module instead. You should avoid using the "as" keyword when importing, unless you are importing a compatability module.
+
+Imports should be one line per module. We group import statements together using the standard python rules- system, 3rd party, local.
+
+Do not use `from foo import *`. Supply a list of objects you want to import instead, or import the whole module.
+
+## Import Examples
+
+Good:
+
+```
+from qmk import effects
+
+effects.echo()
+```
+
+Bad:
+
+```
+from qmk.effects import echo
+
+echo()  # It's unclear where echo comes from
+```
+
+Good:
+
+```
+from qmk.keymap import compile_firmware
+
+compile_firmware()
+```
+
+OK, but the above is better:
+
+```
+import qmk.keymap
+
+qmk.keymap.compile_firmware()
+```
+
+# Statements
+
+One statement per line.
+
+Even when allowed (EG `if foo: bar`) we do not combine 2 statements onto a single line.
+
+# Naming
+
+`module_name`, `package_name`, `ClassName`, `method_name`, `ExceptionName`, `function_name`, `GLOBAL_CONSTANT_NAME`, `global_var_name`, `instance_var_name`, `function_parameter_name`, `local_var_name`.
+
+Function names, variable names, and filenames should be descriptive; eschew abbreviation. In particular, do not use abbreviations that are ambiguous or unfamiliar to readers outside your project, and do not abbreviate by deleting letters within a word.
+
+Always use a .py filename extension. Never use dashes.
+
+## Names to Avoid
+
+* single character names except for counters or iterators. You may use "e" as an exception identifier in try/except statements.
+* dashes (-) in any package/module name
+* __double_leading_and_trailing_underscore__ names (reserved by Python)
+
+# Docstrings
+
+To maintain consistency with our docstrings we've set out the following guidelines.
+
+* Use markdown formatting
+* Always use triple-dquote docstrings with at least one linebreak: `"""\n"""`
+* First line is a short (< 70 char) description of what the function does
+* If you need more in your docstring leave a blank line between the description and the rest.
+* Start indented lines at the same indent level as the opening triple-dquote
+* Document all function arguments using the format described below
+* If present, Args:, Returns:, and Raises: should be the last three things in the docstring, separated by a blank line each.
+
+## Simple docstring example
+
+```
+def my_awesome_function():
+    """Return the number of seconds since 1970 Jan 1 00:00 UTC.
+    """
+    return int(time.time())
+```
+
+## Complex docstring example
+
+```
+def my_awesome_function():
+    """Return the number of seconds since 1970 Jan 1 00:00 UTC.
+
+    This function always returns an integer number of seconds.
+    """
+    return int(time.time())
+```
+
+## Function arguments docstring example
+
+```
+def my_awesome_function(start=None, offset=0):
+    """Return the number of seconds since 1970 Jan 1 00:00 UTC.
+
+    This function always returns an integer number of seconds.
+
+
+    Args:
+        start
+            The time to start at instead of 1970 Jan 1 00:00 UTC
+
+        offset
+            Return an answer that has this number of seconds subtracted first
+
+    Returns:
+        An integer describing a number of seconds.
+
+    Raises:
+        ValueError
+            When `start` or `offset` are not positive numbers
+    """
+    if start < 0 or offset < 0:
+        raise ValueError('start and offset must be positive numbers.')
+
+    if not start:
+        start = time.time()
+
+    return int(start - offset)
+```
+
+# Exceptions
+
+Exceptions are used to handle exceptional situations. They should not be used for flow control. This is a break from the python norm of "ask for forgiveness." If you are catching an exception it should be to handle a situation that is unusual.
+
+If you use a catch-all exception for any reason you must log the exception and stacktrace using cli.log.
+
+Make your try/except blocks as short as possible. If you need a lot of try statements you may need to restructure your code.
+
+# Tuples
+
+When defining one-item tuples always include a trailing comma so that it is obvious you are using a tuple. Do not rely on implicit one-item tuple unpacking. Better still use a list which is unambiguous.
+
+This is particularly important when using the printf-style format strings that are commonly used.
+
+# Lists and Dictionaries
+
+We have configured YAPF to differentiate between sequence styles with a trailing comma. When a trailing comma is omitted YAPF will format the sequence as a single line. When a trailing comma is included YAPF will format the sequence with one item per line.
+
+You should generally prefer to keep short definition on a single line. Break out to multiple lines sooner rather than later to aid readability and maintainability.
+
+# Parentheses
+
+Avoid excessive parentheses, but do use parentheses to make code easier to understand. Do not use them in return statements unless you are explicitly returning a tuple, or it is part of a math expression.
+
+# Format Strings
+
+We generally prefer printf-style format strings. Example:
+
+```
+name = 'World'
+print('Hello, %s!' % (name,))
+```
+
+This style is used by the logging module, which we make use of extensively, and we have adopted it in other places for consistency. It is also more familiar to C programmers, who are a big part of our casual audience.
+
+Our included CLI module has support for using these without using the percent (%) operator. Look at `cli.echo()` and the various `cli.log` functions (EG, `cli.log.info()`) for more details.
+
+# Comprehensions & Generator Expressions
+
+We encourage the liberal use of comprehensions and generators, but do not let them get too complex. If you need complexity fall back to a for loop that is easier to understand.
+
+# Lambdas
+
+OK to use but probably should be avoided. With comprehensions and generators the need for lambdas is not as strong as it once was.
+
+# Conditional Expressions
+
+OK in variable assignment, but otherwise should be avoided.
+
+Conditional expressions are if statements that are in line with code. For example:
+
+```
+x = 1 if cond else 2
+```
+
+It's generally not a good idea to use these as function arguments, sequence items, etc. It's too easy to overlook.
+
+# Default Argument Values
+
+Encouraged, but values must be immutable objects.
+
+When specifying default values in argument lists always be careful to specify objects that can't be modified in place. If you use a mutable object the changes you make will persist between calls, which is usually not what you want. Even if that is what you intend to do it is confusing for others and will hinder understanding.
+
+Bad:
+
+```
+def my_func(foo={}):
+    pass
+```
+
+Good:
+
+```
+def my_func(foo=None):
+    if not foo:
+        foo = {}
+```
+
+# Properties
+
+Always use properties instead of getter and setter functions.
+
+```
+class Foo(object):
+    def __init__(self):
+        self._bar = None
+
+    @property
+    def bar(self):
+        return self._bar
+
+    @bar.setter
+    def bar(self, bar):
+        self._bar = bar
+```
+
+# True/False Evaluations
+
+You should generally prefer the implicit True/False evaluation in if statements, rather than checking equivalency.
+
+Bad:
+
+```
+if foo == True:
+    pass
+
+if bar == False:
+    pass
+```
+
+Good:
+
+```
+if foo:
+    pass
+
+if not bar:
+    pass
+```
+
+# Decorators
+
+Use when appropriate. Try to avoid too much magic unless it helps with understanding.
+
+# Threading and Multiprocessing
+
+Should be avoided. If you need this you will have to make a strong case before we merge your code.
+
+# Power Features
+
+Python is an extremely flexible language and gives you many fancy features such as custom metaclasses, access to bytecode, on-the-fly compilation, dynamic inheritance, object reparenting, import hacks, reflection, modification of system internals, etc.
+
+Don't use these.
+
+Performance is not a critical concern for us, and code understandability is. We want our codebase to be approachable by someone who only has a day or two to play with it. These features generally come with a cost to easy understanding, and we would prefer to have code that can be readily understood over faster or more compact code.
+
+Note that some standard library modules use these techniques and it is ok to make use of those modules. But please keep readability and understandability in mind when using them.
+
+# Type Annotated Code
+
+For now we are not using any type annotation system, and would prefer that code remain unannotated. We may revisit this in the future.
+
+# Function length
+
+Prefer small and focused functions.
+
+We recognize that long functions are sometimes appropriate, so no hard limit is placed on function length. If a function exceeds about 40 lines, think about whether it can be broken up without harming the structure of the program.
+
+Even if your long function works perfectly now, someone modifying it in a few months may add new behavior. This could result in bugs that are hard to find. Keeping your functions short and simple makes it easier for other people to read and modify your code.
+
+You could find long and complicated functions when working with some code. Do not be intimidated by modifying existing code: if working with such a function proves to be difficult, you find that errors are hard to debug, or you want to use a piece of it in several different contexts, consider breaking up the function into smaller and more manageable pieces.
+
+# FIXMEs
+
+It is OK to leave FIXMEs in code. Why? Encouraging people to at least document parts of code that need to be thought out more (or that are confusing) is better than leaving this code undocumented.
+
+All FIXMEs should be formatted like:
+
+```
+FIXME(username): Revisit this code when the frob feature is done.
+```
+
+...where username is your GitHub username.
+
+# Unit Tests
+
+These are good. We should have some one day.

docs/config_options.md

@@ -289,6 +289,7 @@ This is a [make](https://www.gnu.org/software/make/manual/make.html) file that i
   * `halfkay`
   * `caterina`
   * `bootloadHID`
+  * `USBasp`
 
 ## Feature Options
 

docs/contributing.md

@@ -54,62 +54,10 @@ Never made an open source contribution before? Wondering how contributions work
 
 # Coding Conventions
 
-Most of our style is pretty easy to pick up on, but right now it's not entirely consistent. You should match the style of the code surrounding your change, but if that code is inconsistent or unclear use the following guidelines:
+Most of our style is pretty easy to pick up on. If you are familiar with either C or Python you should not have too much trouble with our local styles.
 
-* We indent using four (4) spaces (soft tabs)
+* [Coding Conventions - C](coding_conventions_c.md)
-* We use a modified One True Brace Style
+* [Coding Conventions - Python](coding_conventions_python.md)
-  * Opening Brace: At the end of the same line as the statement that opens the block
-  * Closing Brace: Lined up with the first character of the statement that opens the block
-  * Else If: Place the closing brace at the beginning of the line and the next opening brace at the end of the same line.
-  * Optional Braces: Always include optional braces.
-    * Good: if (condition) { return false; }
-    * Bad: if (condition) return false;
-* We encourage use of C style comments: `/* */`
-  * Think of them as a story describing the feature
-  * Use them liberally to explain why particular decisions were made.
-  * Do not write obvious comments
-  * If you not sure if a comment is obvious, go ahead and include it.
-* In general we don't wrap lines, they can be as long as needed. If you do choose to wrap lines please do not wrap any wider than 76 columns.
-* We use `#pragma once` at the start of header files rather than old-style include guards (`#ifndef THIS_FILE_H`, `#define THIS_FILE_H`, ..., `#endif`)
-* We accept both forms of preprocessor if's: `#ifdef DEFINED` and `#if defined(DEFINED)`
-  * If you are not sure which to prefer use the `#if defined(DEFINED)` form.
-  * Do not change existing code from one style to the other, except when moving to a multiple condition `#if`.
-  * Do not put whitespace between `#` and `if`.
-  * When deciding how (or if) to indent directives keep these points in mind:
-    * Readability is more important than consistency.
-    * Follow the file's existing style. If the file is mixed follow the style that makes sense for the section you are modifying.
-    * When choosing to indent you can follow the indention level of the surrounding C code, or preprocessor directives can have their own indent level. Choose the style that best communicates the intent of your code.
-
-Here is an example for easy reference:
-
-```c
-/* Enums for foo */
-enum foo_state {
-  FOO_BAR,
-  FOO_BAZ,
-};
-
-/* Returns a value */
-int foo(void) {
-  if (some_condition) {
-    return FOO_BAR;
-  } else {
-    return -1;
-  }
-}
-```
-
-# Auto-formatting with clang-format
-
-[Clang-format](https://clang.llvm.org/docs/ClangFormat.html) is part of LLVM and can automatically format your code for you, because ain't nobody got time to do it manually. We supply a configuration file for it that applies most of the coding conventions listed above. It will only change whitespace and newlines, so you will still have to remember to include optional braces yourself.
-
-Use the [full LLVM installer](http://llvm.org/builds/) to get clang-format on Windows, or use `sudo apt install clang-format` on Ubuntu.
-
-If you run it from the command-line, pass `-style=file` as an option and it will automatically find the .clang-format configuration file in the QMK root directory.
-
-If you use VSCode, the standard C/C++ plugin supports clang-format, alternatively there is a [separate extension](https://marketplace.visualstudio.com/items?itemName=LLVMExtensions.ClangFormat) for it.
-
-Some things (like LAYOUT macros) are destroyed by clang-format, so either don't run it on those files, or wrap the sensitive code in `// clang-format off` and `// clang-format on`.
 
 # General Guidelines
 

docs/faq_debug.md

@@ -87,6 +87,7 @@ Size after:
 - EEPROM has around a 100000 write cycle.  You shouldn't rewrite the
   firmware repeatedly and continually; that'll burn the EEPROM
   eventually.
+
 ## NKRO Doesn't work
 First you have to compile firmware with this build option `NKRO_ENABLE` in **Makefile**.
 

docs/flashing.md

@@ -119,6 +119,31 @@ Flashing sequence:
 3. Flash a .hex file
 4. Reset the device into application mode (may be done automatically)
 
+## USBasploader
+
+USBasploader is a bootloader developed by matrixstorm. It is used in some non-USB AVR chips such as the ATmega328P, which run V-USB.
+
+To ensure compatibility with the USBasploader bootloader, make sure this block is present in your `rules.mk`:
+
+    # Bootloader
+    #     This definition is optional, and if your keyboard supports multiple bootloaders of
+    #     different sizes, comment this out, and the correct address will be loaded
+    #     automatically (+60). See bootloader.mk for all options.
+    BOOTLOADER = USBasp
+
+Compatible flashers:
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
+* [avrdude](http://www.nongnu.org/avrdude/) with the `usbasp` programmer
+* [AVRDUDESS](https://github.com/zkemble/AVRDUDESS)
+
+Flashing sequence:
+
+1. Press the `RESET` keycode, or keep the boot pin shorted to GND while quickly shorting RST to GND
+2. Wait for the OS to detect the device
+3. Flash a .hex file
+4. Reset the device into application mode (may be done automatically)
+
 ## STM32
 
 All STM32 chips come preloaded with a factory bootloader that cannot be modified nor deleted. Some STM32 chips have bootloaders that do not come with USB programming (e.g. STM32F103) but the process is still the same.

docs/newbs_flashing.md

@@ -127,9 +127,7 @@ Once it does this, you'll want to reset the controller.  It should then show out
 >>> dfu-programmer atmega32u4 reset
 ```
 
-If you have any issues with this, you may need to this: 
+?> If you have any issues with this - such as `dfu-programmer: no device present` - please see the [Frequently Asked Build Questions](faq_build.md).
-
-    sudo make <my_keyboard>:<my_keymap>:dfu
 
 #### DFU commands
 

docs/python_development.md

@@ -0,0 +1,45 @@
+# Python Development in QMK
+
+This document gives an overview of how QMK has structured its python code. You should read this before working on any of the python code.
+
+## Script directories
+
+There are two places scripts live in QMK: `qmk_firmware/bin` and `qmk_firmware/util`. You should use `bin` for any python scripts that utilize the `qmk` wrapper. Scripts that are standalone and not run very often live in `util`.
+
+We discourage putting anything into `bin` that does not utilize the `qmk` wrapper. If you think you have a good reason for doing so please talk to us about your use case.
+
+## Python Modules
+
+Most of the QMK python modules can be found in `qmk_firmware/lib/python`. This is the path that we append to `sys.path`.
+
+We have a module hierarchy under that path:
+
+* `qmk_firmware/lib/python`
+    * `milc.py` - The CLI library we use. Will be pulled out into its own module in the future.
+    * `qmk` - Code associated with QMK
+        * `cli` - Modules that will be imported for CLI commands.
+        * `errors.py` - Errors that can be raised within QMK apps
+        * `keymap.py` - Functions for working with keymaps
+
+## CLI Scripts
+
+We have a CLI wrapper that you should utilize for any user facing scripts. We think it's pretty easy to use and it gives you a lot of nice things for free.
+
+To use the wrapper simply place a module into `qmk_firmware/lib/python/qmk/cli`, and create a symlink to `bin/qmk` named after your module. Dashes in command names will be converted into dots so you can use hierarchy to manage commands.
+
+When `qmk` is run it checks to see how it was invoked. If it was invoked as `qmk` the module name is take from `sys.argv[1]`. If it was invoked as `qmk-<module-name>` then everything after the first dash is taken as the module name. Dashes and underscores are converted to dots, and then `qmk.cli` is prepended before the module is imported.
+
+The module uses `@cli.entrypoint()` and `@cli.argument()` decorators to define an entrypoint, which is where execution starts.
+
+## Example CLI Script
+
+We have provided a QMK Hello World script you can use as an example. To run it simply run `qmk hello` or `qmk-hello`. The source code is listed below.
+
+```
+from milc import cli
+
+@cli.argument('-n', '--name', default='World', help='Name to greet.')
+@cli.entrypoint('QMK Python Hello World.')
+def main(cli):
+    cli.echo('Hello, %s!', cli.config.general.name)
+```

drivers/avr/i2c_master.c

@@ -1,3 +1,18 @@
+/*  Copyright (C) 2019 Elia Ritterbusch
+ +
+ *  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 3 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 <https://www.gnu.org/licenses/>.
+ */
 /* Library made by: g4lvanix
  * Github repository: https://github.com/g4lvanix/I2C-master-lib
  */

drivers/avr/i2c_master.h

@@ -1,3 +1,18 @@
+/*  Copyright (C) 2019 Elia Ritterbusch
+ +
+ *  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 3 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 <https://www.gnu.org/licenses/>.
+ */
 /* Library made by: g4lvanix
  * Github repository: https://github.com/g4lvanix/I2C-master-lib
  */

drivers/avr/i2c_slave.c

@@ -1,3 +1,18 @@
+/*  Copyright (C) 2019 Elia Ritterbusch
+ +
+ *  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 3 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 <https://www.gnu.org/licenses/>.
+ */
 /* Library made by: g4lvanix
  * Github repository: https://github.com/g4lvanix/I2C-slave-lib
  */
@@ -68,4 +83,4 @@ ISR(TWI_vect){
 
     // Reset i2c state machine to be ready for next interrupt
     TWCR |= (1 << TWIE) | (1 << TWINT) | (ack << TWEA) | (1 << TWEN);
-}
+}

drivers/avr/i2c_slave.h

@@ -1,3 +1,18 @@
+/*  Copyright (C) 2019 Elia Ritterbusch
+ +
+ *  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 3 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 <https://www.gnu.org/licenses/>.
+ */
 /* Library made by: g4lvanix
  * Github repository: https://github.com/g4lvanix/I2C-slave-lib
 
@@ -15,4 +30,4 @@ extern volatile uint8_t i2c_slave_reg[I2C_SLAVE_REG_COUNT];
 void i2c_slave_init(uint8_t address);
 void i2c_slave_stop(void);
 
-#endif // I2C_SLAVE_H
+#endif // I2C_SLAVE_H

keyboards/angel64/angel64.c

@@ -0,0 +1,51 @@
+/* Copyright 2019 kakunpc
+ *
+ * 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 "angel64.h"
+
+// Optional override functions below.
+// You can leave any or all of these undefined.
+// These are only required if you want to perform custom actions.
+
+/*
+
+void matrix_init_kb(void) {
+  // put your keyboard start-up code here
+  // runs once when the firmware starts up
+
+  matrix_init_user();
+}
+
+void matrix_scan_kb(void) {
+  // put your looping keyboard code here
+  // runs every cycle (a lot)
+
+  matrix_scan_user();
+}
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+  // put your per-action keyboard code here
+  // runs for every action, just before processing by the firmware
+
+  return process_record_user(keycode, record);
+}
+
+void led_set_kb(uint8_t usb_led) {
+  // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
+
+  led_set_user(usb_led);
+}
+
+*/

keyboards/angel64/angel64.h

@@ -0,0 +1,48 @@
+/* Copyright 2019 kakunpc
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include "quantum.h"
+
+/* This a shortcut to help you visually see your layout.
+ *
+ * The first section contains all of the arguments representing the physical
+ * layout of the board and position of the keys.
+ *
+ * The second converts the arguments into a two-dimensional array which
+ * represents the switch matrix.
+ */
+#define LAYOUT( \
+    k01, k02, k03, k04, k05, k06, k07, k08, k09, k10, k11, k12, k13, k14, \
+    k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, \
+    k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40,   \
+    k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, \
+    k54, k55, k56, k57, k58, k59, k60, k61, k62, k63, k64\
+) \
+{ \
+    { k01, k13, k25, k37, k49, k61 }, \
+    { k02, k14, k26, k38, k50, k62 }, \
+    { k03, k15, k27, k39, k51, k63 }, \
+    { k04, k16, k28, k40, k52, k64 }, \
+    { k05, k17, k29, k41, k53, KC_NO }, \
+    { k06, k18, k30, k42, k54, KC_NO }, \
+    { k07, k19, k31, k43, k55, KC_NO }, \
+    { k08, k20, k32, k44, k56, KC_NO }, \
+    { k09, k21, k33, k45, k57, KC_NO }, \
+    { k10, k22, k34, k46, k58, KC_NO }, \
+    { k11, k23, k35, k47, k59, KC_NO }, \
+    { k12, k24, k36, k48, k60, KC_NO } \
+}

keyboards/angel64/config.h

@@ -0,0 +1,242 @@
+/*
+Copyright 2019 kakunpc
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x0000
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    kakunpc
+#define PRODUCT         angel64
+#define DESCRIPTION     A custom keyboard
+
+/* key matrix size */
+#define MATRIX_ROWS 12
+#define MATRIX_COLS 6
+
+/*
+ * Keyboard Matrix Assignments
+ *
+*/
+#define MATRIX_ROW_PINS { D4, C6, D7, E6, B4, B5 }
+#define MATRIX_COL_PINS { F4, F5, F6, F7, B1, B3 }
+#define UNUSED_PINS
+
+/*
+ * Split Keyboard specific options, make sure you have 'SPLIT_KEYBOARD = yes' in your rules.mk, and define SOFT_SERIAL_PIN.
+ */
+#define SOFT_SERIAL_PIN D0 // or D1, D2, D3, E6
+
+// #define BACKLIGHT_PIN B7
+// #define BACKLIGHT_BREATHING
+// #define BACKLIGHT_LEVELS 3
+
+// #define RGB_DI_PIN E2
+// #ifdef RGB_DI_PIN
+//   #define RGBLED_NUM 64
+//   #define RGBLIGHT_HUE_STEP 8
+//   #define RGBLIGHT_SAT_STEP 8
+//   #define RGBLIGHT_VAL_STEP 8
+//   #define RGBLIGHT_LIMIT_VAL 255 /* The maximum brightness level */
+//   #define RGBLIGHT_SLEEP  /* If defined, the RGB lighting will be switched off when the host goes to sleep */
+// /*== all animations enable ==*/
+//   #define RGBLIGHT_ANIMATIONS
+// /*== or choose animations ==*/
+//   #define RGBLIGHT_EFFECT_BREATHING
+//   #define RGBLIGHT_EFFECT_RAINBOW_MOOD
+//   #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
+//   #define RGBLIGHT_EFFECT_SNAKE
+//   #define RGBLIGHT_EFFECT_KNIGHT
+//   #define RGBLIGHT_EFFECT_CHRISTMAS
+//   #define RGBLIGHT_EFFECT_STATIC_GRADIENT
+//   #define RGBLIGHT_EFFECT_RGB_TEST
+//   #define RGBLIGHT_EFFECT_ALTERNATING
+// /*== customize breathing effect ==*/
+//   /*==== (DEFAULT) use fixed table instead of exp() and sin() ====*/
+//   #define RGBLIGHT_BREATHE_TABLE_SIZE 256      // 256(default) or 128 or 64
+//   /*==== use exp() and sin() ====*/
+//   #define RGBLIGHT_EFFECT_BREATHE_CENTER 1.85  // 1 to 2.7
+//   #define RGBLIGHT_EFFECT_BREATHE_MAX    255   // 0 to 255
+// #endif
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCE 5
+
+/* define if matrix has ghost (lacks anti-ghosting diodes) */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/* If defined, GRAVE_ESC will always act as ESC when CTRL is held.
+ * This is userful for the Windows task manager shortcut (ctrl+shift+esc).
+ */
+// #define GRAVE_ESC_CTRL_OVERRIDE
+
+/*
+ * Force NKRO
+ *
+ * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
+ * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
+ * makefile for this to work.)
+ *
+ * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
+ * until the next keyboard reset.
+ *
+ * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
+ * fully operational during normal computer usage.
+ *
+ * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
+ * or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by
+ * bootmagic, NKRO mode will always be enabled until it is toggled again during a
+ * power-up.
+ *
+ */
+//#define FORCE_NKRO
+
+/*
+ * Magic Key Options
+ *
+ * Magic keys are hotkey commands that allow control over firmware functions of
+ * the keyboard. They are best used in combination with the HID Listen program,
+ * found here: https://www.pjrc.com/teensy/hid_listen.html
+ *
+ * The options below allow the magic key functionality to be changed. This is
+ * useful if your keyboard/keypad is missing keys and you want magic key support.
+ *
+ */
+
+/* key combination for magic key command */
+/* defined by default; to change, uncomment and set to the combination you want */
+// #define IS_COMMAND() (get_mods() == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))
+
+/* control how magic key switches layers */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false
+
+/* override magic key keymap */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM
+//#define MAGIC_KEY_HELP           H
+//#define MAGIC_KEY_HELP_ALT       SLASH
+//#define MAGIC_KEY_DEBUG          D
+//#define MAGIC_KEY_DEBUG_MATRIX   X
+//#define MAGIC_KEY_DEBUG_KBD      K
+//#define MAGIC_KEY_DEBUG_MOUSE    M
+//#define MAGIC_KEY_VERSION        V
+//#define MAGIC_KEY_STATUS         S
+//#define MAGIC_KEY_CONSOLE        C
+//#define MAGIC_KEY_LAYER0         0
+//#define MAGIC_KEY_LAYER0_ALT     GRAVE
+//#define MAGIC_KEY_LAYER1         1
+//#define MAGIC_KEY_LAYER2         2
+//#define MAGIC_KEY_LAYER3         3
+//#define MAGIC_KEY_LAYER4         4
+//#define MAGIC_KEY_LAYER5         5
+//#define MAGIC_KEY_LAYER6         6
+//#define MAGIC_KEY_LAYER7         7
+//#define MAGIC_KEY_LAYER8         8
+//#define MAGIC_KEY_LAYER9         9
+//#define MAGIC_KEY_BOOTLOADER     B
+//#define MAGIC_KEY_BOOTLOADER_ALT ESC
+//#define MAGIC_KEY_LOCK           CAPS
+//#define MAGIC_KEY_EEPROM         E
+//#define MAGIC_KEY_EEPROM_CLEAR   BSPACE
+//#define MAGIC_KEY_NKRO           N
+//#define MAGIC_KEY_SLEEP_LED      Z
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION
+
+/*
+ * MIDI options
+ */
+
+/* Prevent use of disabled MIDI features in the keymap */
+//#define MIDI_ENABLE_STRICT 1
+
+/* enable basic MIDI features:
+   - MIDI notes can be sent when in Music mode is on
+*/
+//#define MIDI_BASIC
+
+/* enable advanced MIDI features:
+   - MIDI notes can be added to the keymap
+   - Octave shift and transpose
+   - Virtual sustain, portamento, and modulation wheel
+   - etc.
+*/
+//#define MIDI_ADVANCED
+
+/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
+//#define MIDI_TONE_KEYCODE_OCTAVES 1
+
+/*
+ * HD44780 LCD Display Configuration
+ */
+/*
+#define LCD_LINES           2     //< number of visible lines of the display
+#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
+
+#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
+
+#if LCD_IO_MODE
+#define LCD_PORT         PORTB        //< port for the LCD lines
+#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
+#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
+#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
+#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
+#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
+#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
+#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
+#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
+#define LCD_RS_PORT      LCD_PORT     //< port for RS line
+#define LCD_RS_PIN       3            //< pin  for RS line
+#define LCD_RW_PORT      LCD_PORT     //< port for RW line
+#define LCD_RW_PIN       2            //< pin  for RW line
+#define LCD_E_PORT       LCD_PORT     //< port for Enable line
+#define LCD_E_PIN        1            //< pin  for Enable line
+#endif
+*/
+
+/* Bootmagic Lite key configuration */
+// #define BOOTMAGIC_LITE_ROW 0
+// #define BOOTMAGIC_LITE_COLUMN 0

keyboards/angel64/info.json

@@ -0,0 +1,12 @@
+{
+    "keyboard_name": "angel64",
+    "url": "https://kakunpc.booth.pm/",
+    "maintainer": "kakunpc",
+    "width": 14,
+    "height": 5,
+    "layouts": {
+        "LAYOUT": {
+            "layout": [{"label":"~", "x":0, "y":0}, {"label":"!", "x":1, "y":0}, {"label":"@", "x":2, "y":0}, {"label":"#", "x":3, "y":0}, {"label":"$", "x":4, "y":0}, {"label":"%", "x":5, "y":0}, {"label":"^", "x":6, "y":0}, {"label":"&", "x":7, "y":0}, {"label":"*", "x":8, "y":0}, {"label":"(", "x":9, "y":0}, {"label":")", "x":10, "y":0}, {"label":"_", "x":11, "y":0}, {"label":"+", "x":12, "y":0}, {"label":"back", "x":13, "y":0}, {"label":"Q", "x":0, "y":1, "w":1.5}, {"label":"W", "x":1.5, "y":1}, {"label":"E", "x":2.5, "y":1}, {"label":"R", "x":3.5, "y":1}, {"label":"T", "x":4.5, "y":1}, {"label":"Y", "x":5.5, "y":1}, {"label":"U", "x":6.5, "y":1}, {"label":"I", "x":7.5, "y":1}, {"label":"O", "x":8.5, "y":1}, {"label":"P", "x":9.5, "y":1}, {"label":"[", "x":10.5, "y":1}, {"label":"]", "x":11.5, "y":1}, {"label":"|", "x":12.5, "y":1, "w":1.5}, {"label":"Ctrl", "x":0, "y":2}, {"label":"A", "x":1, "y":2}, {"label":"S", "x":2, "y":2}, {"label":"D", "x":3, "y":2}, {"label":"F", "x":4, "y":2}, {"label":"G", "x":5, "y":2}, {"label":"H", "x":6, "y":2}, {"label":"J", "x":7, "y":2}, {"label":"K", "x":8, "y":2}, {"label":"L", "x":9, "y":2}, {"label":";:", "x":10, "y":2}, {"label":"`", "x":11, "y":2}, {"label":"Enter", "x":12, "y":2, "w":2}, {"label":"Shift", "x":0, "y":3, "w":1.5}, {"label":"Z", "x":1.5, "y":3}, {"label":"X", "x":2.5, "y":3}, {"label":"C", "x":3.5, "y":3}, {"label":"V", "x":4.5, "y":3}, {"label":"B", "x":5.5, "y":3}, {"label":"N", "x":6.5, "y":3}, {"label":"M", "x":7.5, "y":3}, {"label":"<", "x":8.5, "y":3}, {"label":">", "x":9.5, "y":3}, {"label":"?", "x":10.5, "y":3}, {"label":"\u2191", "x":11.5, "y":3}, {"label":"Fn", "x":12.5, "y":3, "w":1.5}, {"label":"Caps", "x":0, "y":4}, {"label":"Alt", "x":1, "y":4}, {"label":"Start", "x":2, "y":4, "w":1.5}, {"label":"Ctrl", "x":3.5, "y":4, "w":1.5}, {"label":"Space", "x":5, "y":4, "w":2}, {"label":"Ctrl", "x":7, "y":4, "w":1.5}, {"label":"Alt", "x":8.5, "y":4, "w":1.5}, {"label":"\u2190", "x":10, "y":4}, {"label":"\u2193", "x":11, "y":4}, {"label":"\u2192", "x":12, "y":4}, {"label":"Alt", "x":13, "y":4}]
+        }
+    }
+}

keyboards/angel64/keymaps/default/config.h

@@ -1,4 +1,4 @@
-/* Copyright 2017 Sebastian Kaim
+/* Copyright 2019 kakunpc
  *
  * 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
@@ -14,22 +14,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#pragma once
 
-#if defined(__AVR__)
+// place overrides here
-#include <avr/pgmspace.h>
-#include <avr/io.h>
-#include <avr/interrupt.h>
-#endif
-#include <stddef.h>
-#include <stdlib.h>
-#include "backlight.h"
-
-#ifndef PS2AVRGB_BACKLIGHT_H
-#define PS2AVRGB_BACKLIGHT_H
-
-uint8_t get_pwm_for_brightness(uint8_t level);
-void set_backlight_pwm(uint8_t level);
-void backlight_on(void);
-void backlight_off(void);
-
-#endif

keyboards/angel64/keymaps/default/keymap.c

@@ -0,0 +1,58 @@
+/* Copyright 2019 kakunpc
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include QMK_KEYBOARD_H
+
+enum layers{
+    BASE = 0,
+    COMMAND
+};
+
+#define KC_COMMAND    LT(COMMAND,KC_SPC)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    [BASE] = LAYOUT(
+    KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC ,
+         KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS,
+    KC_TAB, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT,
+    KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_UP, KC_RSFT,
+    KC_LCTL, KC_LALT, KC_LGUI, KC_COMMAND, KC_SPC,    KC_COMMAND, KC_CAPS, KC_LEFT, KC_DOWN, KC_RIGHT, KC_DEL
+    ),
+    [COMMAND] = LAYOUT(
+    KC_ESC, KC_F1,  KC_F2,  KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_BSPC ,
+         KC_NO, KC_UP, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+    KC_NO, KC_LEFT, KC_DOWN, KC_RIGHT, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+    KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
+    KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,    KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO
+    )
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
+}
+
+void matrix_init_user(void) {
+}
+
+void matrix_scan_user(void) {
+
+}
+
+void led_set_user(uint8_t usb_led) {
+
+}
+
+void keyboard_post_init_user(void) {
+}

keyboards/angel64/keymaps/default/readme.md

@@ -0,0 +1 @@
+# The default keymap for angel64

keyboards/angel64/matrix.c

@@ -0,0 +1,287 @@
+/*
+Copyright 2012-2018 Jun Wako, Jack Humbert, Yiancar
+
+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 "wait.h"
+#include "print.h"
+#include "debug.h"
+#include "util.h"
+#include "matrix.h"
+#include "debounce.h"
+#include "quantum.h"
+
+#if (MATRIX_COLS <= 8)
+#    define print_matrix_header()  print("\nr/c 01234567\n")
+#    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop(matrix[i])
+#    define ROW_SHIFTER ((uint8_t)1)
+#elif (MATRIX_COLS <= 16)
+#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF\n")
+#    define print_matrix_row(row)  print_bin_reverse16(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop16(matrix[i])
+#    define ROW_SHIFTER ((uint16_t)1)
+#elif (MATRIX_COLS <= 32)
+#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
+#    define print_matrix_row(row)  print_bin_reverse32(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop32(matrix[i])
+#    define ROW_SHIFTER  ((uint32_t)1)
+#endif
+
+#ifdef MATRIX_MASKED
+    extern const matrix_row_t matrix_mask[];
+#endif
+
+static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
+static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
+
+/* matrix state(1:on, 0:off) */
+static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values
+static matrix_row_t matrix[MATRIX_ROWS]; //debounced values
+
+__attribute__ ((weak))
+void matrix_init_quantum(void) {
+    matrix_init_kb();
+}
+
+__attribute__ ((weak))
+void matrix_scan_quantum(void) {
+    matrix_scan_kb();
+}
+
+__attribute__ ((weak))
+void matrix_init_kb(void) {
+    matrix_init_user();
+}
+
+__attribute__ ((weak))
+void matrix_scan_kb(void) {
+    matrix_scan_user();
+}
+
+__attribute__ ((weak))
+void matrix_init_user(void) {
+}
+
+__attribute__ ((weak))
+void matrix_scan_user(void) {
+}
+
+inline
+uint8_t matrix_rows(void) {
+    return MATRIX_ROWS;
+}
+
+inline
+uint8_t matrix_cols(void) {
+    return MATRIX_COLS;
+}
+
+//Deprecated.
+bool matrix_is_modified(void)
+{
+    if (debounce_active()) return false;
+    return true;
+}
+
+inline
+bool matrix_is_on(uint8_t row, uint8_t col)
+{
+    return (matrix[row] & ((matrix_row_t)1<<col));
+}
+
+inline
+matrix_row_t matrix_get_row(uint8_t row)
+{
+    // Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
+    // switch blocker installed and the switch is always pressed.
+#ifdef MATRIX_MASKED
+    return matrix[row] & matrix_mask[row];
+#else
+    return matrix[row];
+#endif
+}
+
+void matrix_print(void)
+{
+    print_matrix_header();
+
+    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+        phex(row); print(": ");
+        print_matrix_row(row);
+        print("\n");
+    }
+}
+
+uint8_t matrix_key_count(void)
+{
+    uint8_t count = 0;
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+        count += matrix_bitpop(i);
+    }
+    return count;
+}
+
+static void select_row(uint8_t row)
+{
+    setPinOutput(row_pins[row]);
+    writePinLow(row_pins[row]);
+}
+
+static void unselect_row(uint8_t row)
+{
+    setPinInputHigh(row_pins[row]);
+}
+
+static void unselect_rows(void)
+{
+    for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
+        setPinInputHigh(row_pins[x]);
+    }
+}
+
+static void select_col(uint8_t col)
+{
+    setPinOutput(col_pins[col]);
+    writePinLow(col_pins[col]);
+}
+
+static void unselect_col(uint8_t col)
+{
+    setPinInputHigh(col_pins[col]);
+}
+
+static void unselect_cols(void)
+{
+    for(uint8_t x = 0; x < MATRIX_COLS; x++) {
+        setPinInputHigh(col_pins[x]);
+    }
+}
+
+static void init_pins(void) {
+  unselect_rows();
+  unselect_cols();
+  for (uint8_t x = 0; x < MATRIX_COLS; x++) {
+    setPinInputHigh(col_pins[x]);
+  }
+  for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
+    setPinInputHigh(row_pins[x]);
+  }
+}
+
+static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
+{
+    // Store last value of row prior to reading
+    matrix_row_t last_row_value = current_matrix[current_row];
+
+    // Clear data in matrix row
+    current_matrix[current_row] = 0;
+
+    // Select row and wait for row selecton to stabilize
+    select_row(current_row);
+    wait_us(30);
+
+    // For each col...
+    for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
+
+        // Select the col pin to read (active low)
+        uint8_t pin_state = readPin(col_pins[col_index]);
+
+        // Populate the matrix row with the state of the col pin
+        current_matrix[current_row] |=  pin_state ? 0 : (ROW_SHIFTER << col_index);
+    }
+
+    // Unselect row
+    unselect_row(current_row);
+
+    return (last_row_value != current_matrix[current_row]);
+}
+
+static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
+{
+    bool matrix_changed = false;
+
+    // Select col and wait for col selecton to stabilize
+    select_col(current_col);
+    wait_us(30);
+
+    // For each row...
+    for(uint8_t row_index = 0; row_index < MATRIX_ROWS/2; row_index++)
+    {
+        uint8_t tmp = row_index + MATRIX_ROWS/2;
+        // Store last value of row prior to reading
+        matrix_row_t last_row_value = current_matrix[tmp];
+
+        // Check row pin state
+        if (readPin(row_pins[row_index]) == 0)
+        {
+            // Pin LO, set col bit
+            current_matrix[tmp] |= (ROW_SHIFTER << current_col);
+        }
+        else
+        {
+            // Pin HI, clear col bit
+            current_matrix[tmp] &= ~(ROW_SHIFTER << current_col);
+        }
+
+        // Determine if the matrix changed state
+        if ((last_row_value != current_matrix[tmp]) && !(matrix_changed))
+        {
+            matrix_changed = true;
+        }
+    }
+
+    // Unselect col
+    unselect_col(current_col);
+
+    return matrix_changed;
+}
+
+void matrix_init(void) {
+
+    // initialize key pins
+    init_pins();
+
+    // initialize matrix state: all keys off
+    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
+        raw_matrix[i] = 0;
+        matrix[i] = 0;
+    }
+
+    debounce_init(MATRIX_ROWS);
+
+    matrix_init_quantum();
+}
+
+uint8_t matrix_scan(void)
+{
+  bool changed = false;
+
+  // Set row, read cols
+  for (uint8_t current_row = 0; current_row < MATRIX_ROWS / 2; current_row++) {
+    changed |= read_cols_on_row(raw_matrix, current_row);
+  }
+  //else
+  // Set col, read rows
+  for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
+    changed |= read_rows_on_col(raw_matrix, current_col);
+  }
+
+  debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
+
+  matrix_scan_quantum();
+  return (uint8_t)changed;
+}

keyboards/angel64/readme.md

@@ -0,0 +1,15 @@
+# angel64
+
+![angel64](https://i.gyazo.com/6e2ea6c58d3253c496dc0518f2641ff9.jpg)
+
+Keyboard for tablets.
+
+Keyboard Maintainer: [kakunpc](https://github.com/kakunpc)  
+Hardware Supported: angel64_alpha, promicro  
+Hardware Availability: booth([@kakunpc](https://kakunpc.booth.pm/))
+
+Make example for this keyboard (after setting up your build environment):
+
+    make angel64:default
+
+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).

keyboards/angel64/rules.mk

@@ -0,0 +1,83 @@
+# MCU name
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   atmega32a    bootloadHID
+BOOTLOADER = atmel-dfu
+
+
+# If you don't know the bootloader type, then you can specify the
+# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
+#   Teensy halfKay      512
+#   Teensy++ halfKay    1024
+#   Atmel DFU loader    4096
+#   LUFA bootloader     4096
+#   USBaspLoader        2048
+# OPT_DEFS += -DBOOTLOADER_SIZE=4096
+
+
+# Build Options
+#   change yes to no to disable
+#
+BOOTMAGIC_ENABLE = no      # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+CONSOLE_ENABLE = yes        # Console for debug(+400)
+COMMAND_ENABLE = yes        # Commands for debug and configuration
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
+# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+NKRO_ENABLE = no            # USB Nkey Rollover
+BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality on B7 by default
+RGBLIGHT_ENABLE = no        # Enable keyboard RGB underglow
+MIDI_ENABLE = no            # MIDI support (+2400 to 4200, depending on config)
+UNICODE_ENABLE = no         # Unicode
+BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
+AUDIO_ENABLE = no           # Audio output on port C6
+FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
+HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs (+400)
+CUSTOM_MATRIX = yes
+
+SRC += matrix.c

keyboards/clueboard/66_hotswap/keymaps/json/keymap.json

@@ -0,0 +1 @@
+{"keyboard":"clueboard/66_hotswap/gen1","keymap":"default_66","layout":"LAYOUT","layers":[["KC_GESC","KC_1","KC_2","KC_3","KC_4","KC_5","KC_6","KC_7","KC_8","KC_9","KC_0","KC_MINS","KC_EQL","KC_BSPC","KC_PGUP","KC_TAB","KC_Q","KC_W","KC_E","KC_R","KC_T","KC_Y","KC_U","KC_I","KC_O","KC_P","KC_LBRC","KC_RBRC","KC_BSLS","KC_PGDN","KC_CAPS","KC_A","KC_S","KC_D","KC_F","KC_G","KC_H","KC_J","KC_K","KC_L","KC_SCLN","KC_QUOT","KC_ENT","KC_LSFT","KC_Z","KC_X","KC_C","KC_V","KC_B","KC_N","KC_M","KC_COMM","KC_DOT","KC_SLSH","KC_RSFT","KC_UP","KC_LCTL","KC_LGUI","KC_LALT","KC_SPC","KC_SPC","KC_RALT","KC_RGUI","MO(1)","KC_RCTL","KC_LEFT","KC_DOWN","KC_RGHT"],["KC_GRV","KC_F1","KC_F2","KC_F3","KC_F4","KC_F5","KC_F6","KC_F7","KC_F8","KC_F9","KC_F10","KC_F11","KC_F12","KC_DEL","BL_INC","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_MPRV","KC_MPLY","KC_MNXT","KC_NO","KC_MUTE","BL_DEC","KC_NO","KC_NO","MO(2)","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_PGUP","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","MO(1)","KC_NO","KC_HOME","KC_PGDN","KC_END"],["KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","BL_TOGG","BL_INC","KC_NO","KC_NO","KC_NO","KC_NO","RESET","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","BL_DEC","KC_NO","KC_NO","MO(2)","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","KC_NO","BL_STEP","KC_NO","KC_NO","MO(1)","KC_NO","KC_NO","KC_NO","KC_NO"]],"author":"","notes":""}

keyboards/dz60/keymaps/billiams/keymap.c

@@ -4,9 +4,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
   /* Qwerty
    * ,-----------------------------------------------------------------------------------------.
-   * |  `  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  0  |  -  |  =  |   Bkspc   |
+   * |  `  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  0  |  -  |  =  |     \     |
    * |-----------------------------------------------------------------------------------------+
-   * | Tab    |  Q  |  W  |  E  |  R  |  T  |  Y  |  U  |  I  |  O  |  P  |  [  |  ]  |    \   |
+   * | Tab    |  Q  |  W  |  E  |  R  |  T  |  Y  |  U  |  I  |  O  |  P  |  [  |  ]  |  Bkspc |
    * |-----------------------------------------------------------------------------------------+
    * |   Fn    |  A  |  S  |  D  |  F  |  G  |  H  |  J  |  K  |  L  |  ;  |  '  |    Enter    |
    * |-----------------------------------------------------------------------------------------+
@@ -17,8 +17,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    */
 
   LAYOUT_directional(
-      KC_GRAVE, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, _______, KC_BSPC,
+      KC_GRAVE, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, _______, KC_BSLS,
-      KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS,
+      KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSPC,
       MO(1), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT,
       KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, _______, RSFT_T(KC_SLSH) , KC_UP, KC_ESCAPE,
       KC_LCTL, KC_LALT, KC_LGUI, KC_SPC, KC_SPC, KC_SPC, KC_RALT, MO(1), KC_LEFT, KC_DOWN, KC_RIGHT

keyboards/dz60/keymaps/billiams/readme.md

@@ -12,6 +12,7 @@ Settings:
 * RESET is available as `Fn`+ ` ESC`
 * Underglow toggle is available as `Fn` + `Q`. Yes your keyboard has lights even if you didn't get the LEDs. Bonus!
 * vim-style arrow key bindings H J K L in layer 1
+* The `Bkspc` and `\` keys have been swapped, the reach was too great to have backspace on the top row
 
 ### Initial Installation
 
@@ -35,16 +36,16 @@ A hex file `dz60_billiams.hex` will be created in the base qmk_firmware director
 5. Holding those keys down, plug the keyboard into your computer, which will put the keyboard in bootlegger mode
 6. If you are using [QMK toolbox](https://github.com/qmk/qmk_toolbox/releases), upload the .hex file you made above, select it and hit the flash button. For the love of all that is good and holy on Earth, don't hit the load button, that will load the default keymap and that's not what you want! Unless it is, in which case click away.
 
-Note: If you didn't follow my instructions in 4 and accidentally loaded the default keymap, then to `RESET` the keyboard and kick it into bootleg mode again, hold the `down arrow` key and `\`. The default layout is Build 1 and sets the `MENU` key on that build to `Fn`. `MENU` corresponds to `down arrow` in build 4. Note that you don't have to unplug the keyboard. 
+Note: If you didn't follow my instructions in 4 and accidentally loaded the default keymap, then to `RESET` the keyboard and kick it into bootleg mode again, hold the `down arrow` key and `\`. The default layout is Build 1 and sets the `MENU` key on that build to `Fn`. `MENU` corresponds to `down arrow` in build 4. Note that you don't have to unplug the keyboard.
 
 Hope this helps!
 
 ### 0 Qwerty
 ```
 ,-----------------------------------------------------------------------------------------.
-|  `  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  0  |  -  |  =  |   Bkspc   |
+|  `  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  0  |  -  |  =  |     \     |
 |-----------------------------------------------------------------------------------------+
-| Tab    |  Q  |  W  |  E  |  R  |  T  |  Y  |  U  |  I  |  O  |  P  |  [  |  ]  |    \   |
+| Tab    |  Q  |  W  |  E  |  R  |  T  |  Y  |  U  |  I  |  O  |  P  |  [  |  ]  | Bkspc  |
 |-----------------------------------------------------------------------------------------+
 |   Fn    |  A  |  S  |  D  |  F  |  G  |  H  |  J  |  K  |  L  |  ;  |  '  |    Enter    |
 |-----------------------------------------------------------------------------------------+
@@ -69,4 +70,3 @@ FN Layer
 |      |       |       |                                 |     |     | HOME | PG_DN | END |
 `-----------------------------------------------------------------------------------------'
 ```
-

keyboards/dztech/dz60rgb/keymaps/matthewrobo/keymap.c

@@ -146,7 +146,7 @@ void rgb_matrix_indicators_user(void)
 			break;
 
 		case _RGB: {
-			HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, rgb_matrix_config.val };
+			HSV hsv = { rgb_matrix_config.hsv.h, rgb_matrix_config.hsv.s, rgb_matrix_config.hsv.v };
 			HSV hui = hsv;
 			HSV hud = hsv;
 			HSV sai = hsv;

keyboards/gingham/rules.mk

@@ -49,7 +49,7 @@ OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
 #   atmega32a    bootloadHID
 #
 # This uses usbaspbootloader
-# BOOTLOADER = atmel-dfu
+BOOTLOADER = USBasp
 
 # If you don't know the bootloader type, then you can specify the
 # Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
@@ -58,8 +58,6 @@ OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
 #   Atmel DFU loader    4096
 #   LUFA bootloader     4096
 #   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-OPT_DEFS += -DBOOTLOADER_SIZE=2048
 
 # Flash program via avrdude, but default command is not suitable.
 # You can use plaid:default:program

keyboards/ivy/config.h

@@ -0,0 +1,67 @@
+/*
+Copyright 2012 Jun Wako <[email protected]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0x1337
+#define PRODUCT_ID      0x6012
+#define MANUFACTURER    Maple Computing
+#define PRODUCT         Ivy
+#define DESCRIPTION     A 3 key macro pad
+
+/* key matrix size */
+#define MATRIX_ROWS 3
+#define MATRIX_COLS 3
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* 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
+
+#define BACKLIGHT_PIN D2
+
+/* number of backlight levels */
+#define BACKLIGHT_LEVELS 3
+
+/*
+ * 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

keyboards/ivy/ivy.c

@@ -0,0 +1 @@
+#include "ivy.h"

keyboards/ivy/ivy.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#ifdef KEYBOARD_ivy_rev1
+    #include "rev1.h"
+#endif
+
+#include "quantum.h"

keyboards/ivy/keymaps/default/keymap.c

@@ -0,0 +1,46 @@
+#include QMK_KEYBOARD_H
+
+extern keymap_config_t keymap_config;
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+
+enum pad_layers {
+  _L1,
+  _FUNC
+};
+
+// Defines for task manager and such
+#define CALTDEL LCTL(LALT(KC_DEL))
+#define TSKMGR LCTL(LSFT(KC_ESC))
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+/* Layer 1
+ * ,------.
+ * |  1   |
+ * |------|
+ * |  2   |
+ * |------|
+ * |  FN  |
+ * `------'
+ */
+[_L1] = LAYOUT( \
+    KC_1, \
+    KC_2, \
+    MO(_FUNC)  \
+),
+
+[_FUNC] = LAYOUT( \
+    CALTDEL, \
+    TSKMGR, \
+    _______ \
+)
+
+};
+
+void matrix_init_user(void) {
+
+}

keyboards/ivy/keymaps/default/rules.mk

@@ -0,0 +1,22 @@
+
+
+# Build Options
+#   change to "no" to disable the options, or define them in the Makefile in 
+#   the appropriate keymap folder that will get included automatically
+#
+BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = no       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+CONSOLE_ENABLE = no         # Console for debug(+400)
+COMMAND_ENABLE = no        # Commands for debug and configuration
+NKRO_ENABLE = yes            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE = yes      # Enable keyboard backlight functionality
+MIDI_ENABLE = no            # MIDI controls
+AUDIO_ENABLE = no          # Audio output on port C6
+UNICODE_ENABLE = no         # Unicode
+BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
+RGBLIGHT_ENABLE = no        # Enable WS2812 RGB underlight. 
+
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
+

keyboards/ivy/readme.md

@@ -0,0 +1,15 @@
+IVY
+===
+
+![Ivy](https://i.imgur.com/fnVQet6.jpg)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make ivy/rev1:default
+    
+Install examples:
+
+    make ivy/rev1:default:dfu
+
+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).

keyboards/ivy/rev1/config.h

@@ -1,5 +1,5 @@
 /*
-Copyright 2016 Luiz Ribeiro <luizribeiro@gmail.com>
+Copyright 2012 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
@@ -15,11 +15,13 @@ 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 __I2C_H__
+#pragma once
-#define __I2C_H__
 
-void i2c_init(void);
+#define DEVICE_VER      0x0001
-void i2c_set_bitrate(uint16_t bitrate_khz);
-uint8_t i2c_send(uint8_t address, uint8_t *data, uint16_t length);
 
-#endif
+/* Let's Macro V2 pin-out */
+#define MATRIX_ROW_PINS { F1, B2, D3 }
+#define MATRIX_COL_PINS { F5, B3, D5 }
+#define UNUSED_PINS
+
+#define DIODE_DIRECTION COL2ROW

keyboards/ivy/rev1/rev1.c

@@ -0,0 +1,5 @@
+#include "ivy.h"
+
+void matrix_init_kb(void) {
+	matrix_init_user();
+};

keyboards/ivy/rev1/rev1.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "ivy.h"
+
+#define LAYOUT( \
+	K00, \
+    K01, \
+    K02  \
+	) \
+	{ \
+		{ K00, KC_NO, KC_NO }, \
+		{ KC_NO, K01, KC_NO }, \
+		{ KC_NO, KC_NO, K02 }, \
+	}

keyboards/ivy/rev1/rules.mk

@@ -0,0 +1,3 @@
+BACKLIGHT_ENABLE = yes
+RGBLIGHT_ENABLE = no
+AUDIO_ENABLE = no

keyboards/ivy/rules.mk

@@ -0,0 +1,67 @@
+# MCU name
+#MCU = at90usb1287
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Bootloader
+#     This definition is optional, and if your keyboard supports multiple bootloaders of
+#     different sizes, comment this out, and the correct address will be loaded 
+#     automatically (+60). See bootloader.mk for all options.
+BOOTLOADER = caterina
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+# Build Options
+#   change to "no" to disable the options, or define them in the Makefile in 
+#   the appropriate keymap folder that will get included automatically
+#
+BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = no       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+CONSOLE_ENABLE = no         # Console for debug(+400)
+COMMAND_ENABLE = yes        # Commands for debug and configuration
+NKRO_ENABLE = no            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE = no      # Enable keyboard backlight functionality
+MIDI_ENABLE = no            # MIDI controls
+AUDIO_ENABLE = no           # Audio output on port C6
+UNICODE_ENABLE = no         # Unicode
+BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
+RGBLIGHT_ENABLE = no        # Enable WS2812 RGB underlight.
+API_SYSEX_ENABLE = no
+
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
+
+DEFAULT_FOLDER = ivy/rev1

keyboards/kbdfans/kbd6x/keymaps/konstantin/keymap.c

@@ -10,6 +10,7 @@ enum layers_keymap {
 };
 
 void eeconfig_init_keymap(void) {
+    rgblight_sethsv(MODERN_DOLCH_RED.h, MODERN_DOLCH_RED.s, MODERN_DOLCH_RED.v);
     rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
 }
 
@@ -81,7 +82,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
      * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤
      * │      │Mv←│Mv↓│Mv→│TNx│   │   │   │   │   │   │   │        │
      * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┬───┤
-     * │        │RTg│RV-│RV+│   │   │   │   │M4 │M5 │   │      │   │
+     * │        │RTg│RV-│RV+│RMd│   │   │   │M4 │M5 │   │      │   │
      * └─────┬──┴┬──┴──┬┴───┴───┴───┴───┴───┴───┴──┬┴───┴┬───┬─┴───┘
      *       │DPR│DstNA│                           │     │   │
      *       └───┴─────┴───────────────────────────┴─────┴───┘
@@ -90,7 +91,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, CLEAR,
         _______, TOP,     MV_UP,   BOTTOM,  TAB_PRV, _______, _______, _______, _______, _______, _______, _______, _______, DEL_NXT,
         _______, MV_LEFT, MV_DOWN, MV_RGHT, TAB_NXT, _______, _______, _______, _______, _______, _______, _______, _______,
-        _______, RGB_TOG, RGB_VAD, RGB_VAI, _______, _______, _______, _______, KC_BTN4, KC_BTN5, _______, _______, _______,
+        _______, RGB_TOG, RGB_VAD, RGB_VAI, RGB_MOD, _______, _______, _______, KC_BTN4, KC_BTN5, _______, _______, _______,
         XXXXXXX, DST_P_R, DST_N_A,                   _______,                   _______, _______, XXXXXXX
     ),
 };

keyboards/keebio/iris/keymaps/osiris/keymap.c

@@ -4,14 +4,17 @@ extern keymap_config_t keymap_config;
 
 enum layer_names {
     _QWERTY,
+    _WORKMAN,
     _LOWER,
     _RAISE,
     _ADJUST
 };
 
 enum custom_keycodes {
-  LOWER = SAFE_RANGE,
+  QWERTY = SAFE_RANGE,
-  RAISE,
+  WORKMAN,
+  LOWER,
+  RAISE
 };
 
 #define KC_ KC_TRNS
@@ -33,9 +36,23 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   //|----+----+----+----+----+----|              |----+----+----+----+----+----|
      TAB , Q  , W  , E  , R  , T  ,                Y  , U  , I  , O  , P  ,BSLS,
   //|----+----+----+----+----+----|              |----+----+----+----+----+----|
-     LCTL, A  , S  , D  , F  , G  ,                H  , J  , K  , L  ,SCLN,QUOT,
+     LSFT, A  , S  , D  , F  , G  ,                H  , J  , K  , L  ,SCLN,QUOT,
   //|----+----+----+----+----+----+----.    ,----|----+----+----+----+----+----|
-     LSFT, Z  , X  , C  , V  , B  ,LBRC,     RBRC, N  , M  ,COMM,DOT ,SLSH,RSFT,
+     LECL, Z  , X  , C  , V  , B  ,LBRC,     RBRC, N  , M  ,COMM,DOT ,SLSH,RGHT,
+  //`----+----+----+--+-+----+----+----/    \----+----+----+----+----+----+----'
+                       LGUI,LOWR,ENT ,         SPC ,RASE,RALT
+  //                  `----+----+----'        `----+----+----'
+  ),
+
+    [_WORKMAN] = LAYOUT_kc(
+  //,----+----+----+----+----+----.              ,----+----+----+----+----+----.
+     GESC, 1  , 2  , 3  , 4  , 5  ,                6  , 7  , 8  , 9  , 0  ,BSPC,
+  //|----+----+----+----+----+----|              |----+----+----+----+----+----|
+     TAB , Q  , D  , R  , W  , B  ,                J  , F  , U  , P  ,SCLN,BSLS,
+  //|----+----+----+----+----+----|              |----+----+----+----+----+----|
+     LSFT, A  , S  , H  , T  , G  ,                Y  , N  , E  , O  ,I   ,QUOT,
+  //|----+----+----+----+----+----+----.    ,----|----+----+----+----+----+----|
+     LECL, Z  , X  , M  , C  , V  ,LBRC,     RBRC, K  , L  ,COMM,DOT ,SLSH,RGHT,
   //`----+----+----+--+-+----+----+----/    \----+----+----+----+----+----+----'
                        LGUI,LOWR,ENT ,         SPC ,RASE,RALT
   //                  `----+----+----'        `----+----+----'
@@ -45,11 +62,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   //,----+----+----+----+----+----.              ,----+----+----+----+----+----.
      TILD,EXLM, AT ,HASH,DLR ,PERC,               CIRC,AMPR,ASTR,LPRN,RPRN,DEL ,
   //|----+----+----+----+----+----|              |----+----+----+----+----+----|
-         ,    , UP ,    ,    ,    ,                   ,    ,BTN1,    ,    ,    ,
+         ,    ,    ,    ,    ,    ,                   ,    ,BTN1,    ,    ,    ,
   //|----+----+----+----+----+----|              |----+----+----+----+----+----|
-         ,LEFT,DOWN,RGHT,    ,    ,               MS_L,MS_D,MS_U,MS_R,    ,    ,
+         ,    ,    ,    ,    ,    ,               MS_L,MS_D,MS_U,MS_R,    ,    ,
   //|----+----+----+----+----+----+----.    ,----|----+----+----+----+----+----|
-         ,    ,    ,    ,    ,    ,    ,         ,    ,    ,    ,    ,    ,    ,
+         ,    ,    ,    ,    , UP ,    ,         ,    ,    ,    ,    ,    ,    ,
   //`----+----+----+--+-+----+----+----/    \----+----+----+----+----+----+----'
                            ,    ,    ,             ,    ,   
   //                  `----+----+----'        `----+----+----'
@@ -63,7 +80,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   //|----+----+----+----+----+----|              |----+----+----+----+----+----|
          ,MPLY,VOLD,MNXT,    ,LPRN,               RPRN,MINS,EQL ,    ,    ,    ,
   //|----+----+----+----+----+----+----.    ,----|----+----+----+----+----+----|
-         ,    ,    ,    ,    ,    ,    ,         ,    ,    ,    ,    ,    ,    ,
+         ,    ,    ,    ,    ,    ,    ,         ,DOWN,    ,    ,    ,    ,    ,
   //`----+----+----+--+-+----+----+----/    \----+----+----+----+----+----+----'
                            ,    ,    ,             ,    ,
   //                  `----+----+----'        `----+----+----'
@@ -71,7 +88,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
   [_ADJUST] = LAYOUT(
   //,--------+--------+--------+--------+--------+--------.                          ,--------+--------+--------+--------+--------+--------.
-      _______, _______, _______, _______, _______, _______,                            _______, _______, _______, _______, _______, _______,
+      _______, _______, _______, _______, _______,  QWERTY,                            WORKMAN, _______, _______, _______, _______, _______,
   //|--------+--------+--------+--------+--------+--------|                          |--------+--------+--------+--------+--------+--------|
       RGB_TOG, RGB_MOD, RGB_HUI, RGB_SAI, RGB_VAI, _______,                            _______, _______, _______, _______, _______, _______,
   //|--------+--------+--------+--------+--------+--------|                          |--------+--------+--------+--------+--------+--------|
@@ -91,6 +108,16 @@ float tone_qwerty[][2]     = SONG(QWERTY_SOUND);
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
+    case QWERTY:
+      if (record->event.pressed) {
+        set_single_persistent_default_layer(_QWERTY);
+      }
+      return false;
+    case WORKMAN:
+      if (record->event.pressed) {
+        set_single_persistent_default_layer(_WORKMAN);
+      }
+      return false;
     case LOWER:
       if (record->event.pressed) {
         layer_on(_LOWER);
@@ -100,7 +127,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
       return false;
-      break;
     case RAISE:
       if (record->event.pressed) {
         layer_on(_RAISE);
@@ -110,7 +136,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
       return false;
-      break;
   }
   return true;
 }

keyboards/keebio/iris/keymaps/osiris/readme.md

@@ -3,7 +3,9 @@
 ![My Iris Rev3](https://i.imgur.com/7oXacel.jpg)
 
 - mouse keys enabled
-- WASD as arrow keys, and same ones for media
+- includes a QWERTY and a WORKMAN layout now
 - keys that I need, while removing keys that I don't
+- more updates with the layout coming soon
+  - the enter needs to move elsewhere, not yet sure where
 
 See keymap.c for layouts

keyboards/keyhive/maypad/keymaps/default/keymap.c

@@ -22,7 +22,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     	KC_P7,            KC_P8,   KC_P9,            
     	KC_P4,            KC_P5,   KC_P6,   KC_PPLS, 
     	KC_P1,            KC_P2,   KC_P3,            
-    	KC_P0,                     KC_PDOT, KC_PENT  
+    	         KC_P0,            KC_PDOT, KC_PENT  
 	),
 };
 

keyboards/keyhive/maypad/maypad.h

@@ -35,15 +35,15 @@
 #define LAYOUT_numpad_5x4( \
     k00, k01, k02, k03, \
     k10, k11, k12,      \
-    k20, k21, k22, k13, \
+    k20, k21, k22, k23, \
     k30, k31, k32,      \
-    k40,      k42, k33  \
+         k41, k42, k43 \
 ) { \
-    { k00, k01,   k02, k03   }, \
+    { k00,   k01, k02, k03   },  \
-    { k10, k11,   k12, k13   }, \
+    { k10,   k11, k12, KC_NO },  \
-    { k20, k21,   k22, KC_NO }, \
+    { k20,   k21, k22, k23   },  \
-    { k30, k31,   k32, k33   }, \
+    { k30,   k31, k32, KC_NO },  \
-    { k40, KC_NO, k42, KC_NO }  \
+    { KC_NO, k41, k42, k43   }   \
 }
 
 #define LAYOUT_ortho_5x4( \

keyboards/massdrop/ctrl/keymaps/matthewrobo/keymap.c

@@ -135,7 +135,7 @@ void rgb_matrix_indicators_user(void)
 			break;
 
 		case _FNC: {
-			HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, rgb_matrix_config.val };
+			HSV hsv = { rgb_matrix_config.hsv.h, rgb_matrix_config.hsv.s, rgb_matrix_config.hsv.v };
 			HSV hui = hsv;
 			HSV hud = hsv;
 			HSV sai = hsv;

keyboards/melody96/keymaps/konstantin/keymap.c

@@ -1,7 +1,7 @@
 #include QMK_KEYBOARD_H
 #include "konstantin.h"
 
-static const hsv_t *colors[] = { &GODSPEED_BLUE, &GODSPEED_YELLOW };
+static const HSV *colors[] = { &GODSPEED_BLUE, &GODSPEED_YELLOW };
 static const size_t cnum = sizeof colors / sizeof *colors;
 static size_t cidx = 0;
 

keyboards/planck/keymaps/default/keymap.c

@@ -46,9 +46,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Qwerty
  * ,-----------------------------------------------------------------------------------.
  * | Tab  |   Q  |   W  |   E  |   R  |   T  |   Y  |   U  |   I  |   O  |   P  | Bksp |
- * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Esc  |   A  |   S  |   D  |   F  |   G  |   H  |   J  |   K  |   L  |   ;  |  "   |
- * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Shift|   Z  |   X  |   C  |   V  |   B  |   N  |   M  |   ,  |   .  |   /  |Enter |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Brite| Ctrl | Alt  | GUI  |Lower |    Space    |Raise | Left | Down |  Up  |Right |
@@ -64,9 +64,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Colemak
  * ,-----------------------------------------------------------------------------------.
  * | Tab  |   Q  |   W  |   F  |   P  |   G  |   J  |   L  |   U  |   Y  |   ;  | Bksp |
- * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Esc  |   A  |   R  |   S  |   T  |   D  |   H  |   N  |   E  |   I  |   O  |  "   |
- * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Shift|   Z  |   X  |   C  |   V  |   B  |   K  |   M  |   ,  |   .  |   /  |Enter |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Brite| Ctrl | Alt  | GUI  |Lower |    Space    |Raise | Left | Down |  Up  |Right |
@@ -82,9 +82,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Dvorak
  * ,-----------------------------------------------------------------------------------.
  * | Tab  |   "  |   ,  |   .  |   P  |   Y  |   F  |   G  |   C  |   R  |   L  | Bksp |
- * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Esc  |   A  |   O  |   E  |   U  |   I  |   D  |   H  |   T  |   N  |   S  |  /   |
- * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Shift|   ;  |   Q  |   J  |   K  |   X  |   B  |   M  |   W  |   V  |   Z  |Enter |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Brite| Ctrl | Alt  | GUI  |Lower |    Space    |Raise | Left | Down |  Up  |Right |
@@ -100,9 +100,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Lower
  * ,-----------------------------------------------------------------------------------.
  * |   ~  |   !  |   @  |   #  |   $  |   %  |   ^  |   &  |   *  |   (  |   )  | Bksp |
- * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Del  |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   _  |   +  |   {  |   }  |  |   |
- * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |ISO ~ |ISO | | Home | End  |      |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
  * |      |      |      |      |      |             |      | Next | Vol- | Vol+ | Play |
@@ -118,9 +118,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Raise
  * ,-----------------------------------------------------------------------------------.
  * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
- * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Del  |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   -  |   =  |   [  |   ]  |  \   |
- * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |ISO # |ISO / |Pg Up |Pg Dn |      |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
  * |      |      |      |      |      |             |      | Next | Vol- | Vol+ | Play |
@@ -136,9 +136,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Plover layer (http://opensteno.org)
  * ,-----------------------------------------------------------------------------------.
  * |   #  |   #  |   #  |   #  |   #  |   #  |   #  |   #  |   #  |   #  |   #  |   #  |
- * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * |      |   S  |   T  |   P  |   H  |   *  |   *  |   F  |   P  |   L  |   T  |   D  |
- * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * |      |   S  |   K  |   W  |   R  |   *  |   *  |   R  |   B  |   G  |   S  |   Z  |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
  * | Exit |      |      |   A  |   O  |             |   E  |   U  |      |      |      |
@@ -154,9 +154,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Adjust (Lower + Raise)
  * ,-----------------------------------------------------------------------------------.
  * |      | Reset|      |      |      |      |      |      |      |      |      |  Del |
- * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * |      |      |      |Aud on|Audoff|AGnorm|AGswap|Qwerty|Colemk|Dvorak|Plover|      |
- * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
  * |      |Voice-|Voice+|Mus on|Musoff|MIDIon|MIDIof|      |      |      |      |      |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
  * |      |      |      |      |      |             |      |      |      |      |      |

keyboards/readme.md

@@ -59,5 +59,6 @@ These keyboards are part of the QMK repository, but their manufacturers are not
 * [TheVan 44](/keyboards/tv44) — A 44-key staggered keybard by Evangs.
 * [WhiteFox](/keyboards/whitefox) — A 65% keyboard designed as a partnership by matt3o, Massdrop and Input Club
 * [Vision Division](/keyboards/vision_division) — Full Size / Split Linear Keyboard by IBNobody.
+* [XD004](/keyboards/xd004) — 1x4 macro keyboard sold by KPrepublic.
 * [XD75](/keyboards/xd75) — 15x5 ortholinear keyboard by XIUDI.
 * [YMDK NP21](/keyboards/ymdk_np21) — ps2avrGB based number pad (numpad) sold by YMDK on Aliexpress. 

keyboards/shiro/config.h

@@ -0,0 +1,251 @@
+/*
+Copyright 2019 T.Shinohara
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x0000
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    T.Shinohara
+#define PRODUCT         Shiro
+#define DESCRIPTION     A custom keyboard
+
+/* key matrix size */
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 3
+
+/*
+ * Keyboard Matrix Assignments
+ *
+ * Change this to how you wired your keyboard
+ * COLS: AVR pins used for columns, left to right
+ * ROWS: AVR pins used for rows, top to bottom
+ * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
+ *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
+ *
+*/
+#define MATRIX_ROW_PINS { D4, C6, D7, E6, B4 }
+#define MATRIX_COL_PINS { F4, F5, F6 }
+#define UNUSED_PINS
+
+/* COL2ROW, ROW2COL*/
+#define DIODE_DIRECTION COL2ROW
+
+/*
+ * Split Keyboard specific options, make sure you have 'SPLIT_KEYBOARD = yes' in your rules.mk, and define SOFT_SERIAL_PIN.
+ */
+#define SOFT_SERIAL_PIN D0 // or D1, D2, D3, E6
+
+// #define BACKLIGHT_PIN B7
+// #define BACKLIGHT_BREATHING
+// #define BACKLIGHT_LEVELS 3
+
+// #define RGB_DI_PIN E2
+// #ifdef RGB_DI_PIN
+//   #define RGBLED_NUM 16
+//   #define RGBLIGHT_HUE_STEP 8
+//   #define RGBLIGHT_SAT_STEP 8
+//   #define RGBLIGHT_VAL_STEP 8
+//   #define RGBLIGHT_LIMIT_VAL 255 /* The maximum brightness level */
+//   #define RGBLIGHT_SLEEP  /* If defined, the RGB lighting will be switched off when the host goes to sleep */
+// /*== all animations enable ==*/
+//   #define RGBLIGHT_ANIMATIONS
+// /*== or choose animations ==*/
+//   #define RGBLIGHT_EFFECT_BREATHING
+//   #define RGBLIGHT_EFFECT_RAINBOW_MOOD
+//   #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
+//   #define RGBLIGHT_EFFECT_SNAKE
+//   #define RGBLIGHT_EFFECT_KNIGHT
+//   #define RGBLIGHT_EFFECT_CHRISTMAS
+//   #define RGBLIGHT_EFFECT_STATIC_GRADIENT
+//   #define RGBLIGHT_EFFECT_RGB_TEST
+//   #define RGBLIGHT_EFFECT_ALTERNATING
+// /*== customize breathing effect ==*/
+//   /*==== (DEFAULT) use fixed table instead of exp() and sin() ====*/
+//   #define RGBLIGHT_BREATHE_TABLE_SIZE 256      // 256(default) or 128 or 64
+//   /*==== use exp() and sin() ====*/
+//   #define RGBLIGHT_EFFECT_BREATHE_CENTER 1.85  // 1 to 2.7
+//   #define RGBLIGHT_EFFECT_BREATHE_MAX    255   // 0 to 255
+// #endif
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCING_DELAY 5
+
+/* define if matrix has ghost (lacks anti-ghosting diodes) */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/* If defined, GRAVE_ESC will always act as ESC when CTRL is held.
+ * This is userful for the Windows task manager shortcut (ctrl+shift+esc).
+ */
+// #define GRAVE_ESC_CTRL_OVERRIDE
+
+/*
+ * Force NKRO
+ *
+ * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
+ * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
+ * makefile for this to work.)
+ *
+ * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
+ * until the next keyboard reset.
+ *
+ * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
+ * fully operational during normal computer usage.
+ *
+ * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
+ * or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by
+ * bootmagic, NKRO mode will always be enabled until it is toggled again during a
+ * power-up.
+ *
+ */
+//#define FORCE_NKRO
+
+/*
+ * Magic Key Options
+ *
+ * Magic keys are hotkey commands that allow control over firmware functions of
+ * the keyboard. They are best used in combination with the HID Listen program,
+ * found here: https://www.pjrc.com/teensy/hid_listen.html
+ *
+ * The options below allow the magic key functionality to be changed. This is
+ * useful if your keyboard/keypad is missing keys and you want magic key support.
+ *
+ */
+
+/* key combination for magic key command */
+/* defined by default; to change, uncomment and set to the combination you want */
+// #define IS_COMMAND() (get_mods() == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))
+
+/* control how magic key switches layers */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false
+
+/* override magic key keymap */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM
+//#define MAGIC_KEY_HELP           H
+//#define MAGIC_KEY_HELP_ALT       SLASH
+//#define MAGIC_KEY_DEBUG          D
+//#define MAGIC_KEY_DEBUG_MATRIX   X
+//#define MAGIC_KEY_DEBUG_KBD      K
+//#define MAGIC_KEY_DEBUG_MOUSE    M
+//#define MAGIC_KEY_VERSION        V
+//#define MAGIC_KEY_STATUS         S
+//#define MAGIC_KEY_CONSOLE        C
+//#define MAGIC_KEY_LAYER0         0
+//#define MAGIC_KEY_LAYER0_ALT     GRAVE
+//#define MAGIC_KEY_LAYER1         1
+//#define MAGIC_KEY_LAYER2         2
+//#define MAGIC_KEY_LAYER3         3
+//#define MAGIC_KEY_LAYER4         4
+//#define MAGIC_KEY_LAYER5         5
+//#define MAGIC_KEY_LAYER6         6
+//#define MAGIC_KEY_LAYER7         7
+//#define MAGIC_KEY_LAYER8         8
+//#define MAGIC_KEY_LAYER9         9
+//#define MAGIC_KEY_BOOTLOADER     B
+//#define MAGIC_KEY_BOOTLOADER_ALT ESC
+//#define MAGIC_KEY_LOCK           CAPS
+//#define MAGIC_KEY_EEPROM         E
+//#define MAGIC_KEY_EEPROM_CLEAR   BSPACE
+//#define MAGIC_KEY_NKRO           N
+//#define MAGIC_KEY_SLEEP_LED      Z
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION
+
+/*
+ * MIDI options
+ */
+
+/* Prevent use of disabled MIDI features in the keymap */
+//#define MIDI_ENABLE_STRICT 1
+
+/* enable basic MIDI features:
+   - MIDI notes can be sent when in Music mode is on
+*/
+//#define MIDI_BASIC
+
+/* enable advanced MIDI features:
+   - MIDI notes can be added to the keymap
+   - Octave shift and transpose
+   - Virtual sustain, portamento, and modulation wheel
+   - etc.
+*/
+//#define MIDI_ADVANCED
+
+/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
+//#define MIDI_TONE_KEYCODE_OCTAVES 1
+
+/*
+ * HD44780 LCD Display Configuration
+ */
+/*
+#define LCD_LINES           2     //< number of visible lines of the display
+#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
+
+#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
+
+#if LCD_IO_MODE
+#define LCD_PORT         PORTB        //< port for the LCD lines
+#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
+#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
+#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
+#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
+#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
+#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
+#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
+#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
+#define LCD_RS_PORT      LCD_PORT     //< port for RS line
+#define LCD_RS_PIN       3            //< pin  for RS line
+#define LCD_RW_PORT      LCD_PORT     //< port for RW line
+#define LCD_RW_PIN       2            //< pin  for RW line
+#define LCD_E_PORT       LCD_PORT     //< port for Enable line
+#define LCD_E_PIN        1            //< pin  for Enable line
+#endif
+*/
+
+/* Bootmagic Lite key configuration */
+// #define BOOTMAGIC_LITE_ROW 0
+// #define BOOTMAGIC_LITE_COLUMN 0

keyboards/shiro/info.json

@@ -0,0 +1,114 @@
+{
+  "keyboard_name": "Shiro",
+  "url": "https://github.com/ShinoharaTa/keyboards/blob/master/Shiro/manual/build_guide_ja.md",
+  "maintainer": "T.Shinohara",
+  "width": 3,
+  "height": 5,
+  "layouts": {
+    "LAYOUT": {
+      "key_count": 15,
+      "layout": [
+        {
+          "x": 0,
+          "y": 0
+        },
+        {
+          "x": 1,
+          "y": 0
+        },
+        {
+          "x": 2,
+          "y": 0
+        },
+        {
+          "x": 3,
+          "y": 0
+        },
+        {
+          "x": 4,
+          "y": 0
+        },
+        {
+          "x": 0,
+          "y": 1
+        },
+        {
+          "x": 1,
+          "y": 1
+        },
+        {
+          "x": 2,
+          "y": 1
+        },
+        {
+          "x": 3,
+          "y": 1
+        },
+        {
+          "x": 4,
+          "y": 1
+        },
+        {
+          "x": 0,
+          "y": 2
+        },
+        {
+          "x": 1,
+          "y": 2
+        },
+        {
+          "x": 2,
+          "y": 2
+        },
+        {
+          "x": 3,
+          "y": 2
+        },
+        {
+          "x": 4,
+          "y": 2
+        },
+        {
+          "x": 0,
+          "y": 3
+        },
+        {
+          "x": 1,
+          "y": 3
+        },
+        {
+          "x": 2,
+          "y": 3
+        },
+        {
+          "x": 3,
+          "y": 3
+        },
+        {
+          "x": 4,
+          "y": 3
+        },
+        {
+          "x": 0,
+          "y": 4
+        },
+        {
+          "x": 1,
+          "y": 4
+        },
+        {
+          "x": 2,
+          "y": 4
+        },
+        {
+          "x": 3,
+          "y": 4
+        },
+        {
+          "x": 4,
+          "y": 4
+        }
+      ]
+    }
+  }
+}

keyboards/shiro/keymaps/check/config.h

@@ -0,0 +1,19 @@
+/* Copyright 2019 T.Shinohara
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+// place overrides here

keyboards/shiro/keymaps/check/keymap.c

@@ -0,0 +1,66 @@
+/* Copyright 2019 T.Shinohara
+ *
+ * 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
+
+// Defines the keycodes used by our macros in process_record_user
+enum custom_keycodes {
+  TEST_A1 = SAFE_RANGE,
+  TEST_A2,
+  TEST_A3,
+  TEST_B1,
+  TEST_B2,
+  TEST_B3,
+  TEST_C1,
+  TEST_C2,
+  TEST_C3,
+  TEST_D1,
+  TEST_D2,
+  TEST_D3,
+  TEST_E1,
+  TEST_E2,
+  TEST_E3
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [0] = LAYOUT( /* Base */ 
+    TEST_A1,  TEST_A2,  TEST_A3,
+    TEST_B1,  TEST_B2,  TEST_B3,
+    TEST_C1,  TEST_C2,  TEST_C3,
+    TEST_D1,  TEST_D2,  TEST_D3,
+    TEST_E1,  TEST_E2,  TEST_E3
+  )
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case TEST_A1: if(record->event.pressed){ SEND_STRING("A1"); } break;
+    case TEST_A2: if(record->event.pressed){ SEND_STRING("A2"); } break;
+    case TEST_A3: if(record->event.pressed){ SEND_STRING("A3"); } break;
+    case TEST_B1: if(record->event.pressed){ SEND_STRING("B1"); } break;
+    case TEST_B2: if(record->event.pressed){ SEND_STRING("B2"); } break;
+    case TEST_B3: if(record->event.pressed){ SEND_STRING("B3"); } break;
+    case TEST_C1: if(record->event.pressed){ SEND_STRING("C1"); } break;
+    case TEST_C2: if(record->event.pressed){ SEND_STRING("C2"); } break;
+    case TEST_C3: if(record->event.pressed){ SEND_STRING("C3"); } break;
+    case TEST_D1: if(record->event.pressed){ SEND_STRING("D1"); } break;
+    case TEST_D2: if(record->event.pressed){ SEND_STRING("D2"); } break;
+    case TEST_D3: if(record->event.pressed){ SEND_STRING("D3"); } break;
+    case TEST_E1: if(record->event.pressed){ SEND_STRING("E1"); } break;
+    case TEST_E2: if(record->event.pressed){ SEND_STRING("E2"); } break;
+    case TEST_E3: if(record->event.pressed){ SEND_STRING("E3"); } break;
+  }
+  return true;
+}

keyboards/shiro/keymaps/check/readme.md

@@ -0,0 +1 @@
+# The default keymap for Shiro

keyboards/shiro/keymaps/default/config.h

@@ -0,0 +1,19 @@
+/* Copyright 2019 T.Shinohara
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+// place overrides here

keyboards/shiro/keymaps/default/keymap.c

@@ -0,0 +1,50 @@
+/* Copyright 2019 T.Shinohara
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include QMK_KEYBOARD_H
+
+enum layer_number {
+  _NUMBER = 0,
+  _CURSOL,
+  _MOUSE
+};
+
+#define NUMBER TO(_NUMBER)
+#define CURSOL TO(_CURSOL)
+#define MOUSE  TO(_MOUSE)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [_NUMBER] = LAYOUT( 
+    NUMBER,   CURSOL,   MOUSE,
+    KC_P7,    KC_P8,    KC_P9,
+    KC_P4,    KC_P5,    KC_P6,
+    KC_P1,    KC_P2,    KC_P3,
+    KC_P0,    KC_BSPC,  KC_ENT
+  ),
+  [_CURSOL] = LAYOUT( 
+    NUMBER,   CURSOL,   MOUSE,
+    KC_HOME,  KC_UP,    KC_PGUP,
+    KC_LEFT,  KC_ESC,   KC_RIGHT,
+    KC_END,   KC_DOWN,  KC_PGDN,
+    KC_DEL,   KC_BSPC,  KC_ENT
+  ), 
+  [_MOUSE] = LAYOUT( 
+    NUMBER,   CURSOL,   MOUSE,
+    KC_CUT,   KC_COPY,  KC_PSTE,
+    KC_UNDO,  KC_FIND,  KC_AGIN,
+    XXXXXXX,  XXXXXXX,  XXXXXXX,
+    KC_DEL,   KC_BSPC,  KC_ENT
+  ),
+};

keyboards/shiro/keymaps/default/readme.md

@@ -0,0 +1 @@
+# The default keymap for Shiro

keyboards/shiro/readme.md

@@ -0,0 +1,27 @@
+# 素 - Shiro 
+
+![Shiro](https://cdn.discordapp.com/attachments/536423734144401422/597447002288291861/P7070070_cp.jpg)
+
+これは日本の名刺(55mmx91mm)に、3x5の15キーを詰め込んだとても小さいキーパッドです。
+
+This product is a 3x5 very small keypad.
+It is made in 55mm x 91mm according to the Japanese business card.
+
+Keyboard Maintainer: [T.Shinohara](https://github.com/ShinoharaTa)  
+Hardware Supported:  The Shiro PCBs, ProMicro supported. Using only Kailh Low Profile Switches.  
+Hardware Availability: [Booth (Japanese Site)](https://shino3.booth.pm/items/1444895)  
+日本国内ではBoothで入手できます: [Booth (Japanese Site)](https://shino3.booth.pm/items/1444895)
+
+![Shiro-backside](https://cdn.discordapp.com/attachments/536423734144401422/597464086640328724/20190707_033520.jpg)
+
+Make for this keyboard default keymap (after setting up your build environment):
+
+    make shiro:default
+
+Make for this keyboard build check keymap (after setting up your build environment):
+
+    make shiro:check
+
+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).
+
+[Build guide - Japanese](https://github.com/ShinoharaTa/keyboards/blob/master/Shiro/manual/build_guide_ja.md)  

keyboards/shiro/rules.mk

@@ -0,0 +1,80 @@
+# MCU name
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   atmega32a    bootloadHID
+BOOTLOADER = caterina
+
+
+# If you don't know the bootloader type, then you can specify the
+# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
+#   Teensy halfKay      512
+#   Teensy++ halfKay    1024
+#   Atmel DFU loader    4096
+#   LUFA bootloader     4096
+#   USBaspLoader        2048
+# OPT_DEFS += -DBOOTLOADER_SIZE=4096
+
+
+# Build Options
+#   change yes to no to disable
+#
+BOOTMAGIC_ENABLE = no      # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+CONSOLE_ENABLE = yes        # Console for debug(+400)
+COMMAND_ENABLE = yes        # Commands for debug and configuration
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
+# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+NKRO_ENABLE = no            # USB Nkey Rollover
+BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality on B7 by default
+RGBLIGHT_ENABLE = no        # Enable keyboard RGB underglow
+MIDI_ENABLE = no            # MIDI support (+2400 to 4200, depending on config)
+UNICODE_ENABLE = no         # Unicode
+BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
+AUDIO_ENABLE = no           # Audio output on port C6
+FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
+HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs (+400)

keyboards/shiro/shiro.c

@@ -0,0 +1,51 @@
+/* Copyright 2019 T.Shinohara
+ *
+ * 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 "shiro.h"
+
+// Optional override functions below.
+// You can leave any or all of these undefined.
+// These are only required if you want to perform custom actions.
+
+/*
+
+void matrix_init_kb(void) {
+  // put your keyboard start-up code here
+  // runs once when the firmware starts up
+
+  matrix_init_user();
+}
+
+void matrix_scan_kb(void) {
+  // put your looping keyboard code here
+  // runs every cycle (a lot)
+
+  matrix_scan_user();
+}
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+  // put your per-action keyboard code here
+  // runs for every action, just before processing by the firmware
+
+  return process_record_user(keycode, record);
+}
+
+void led_set_kb(uint8_t usb_led) {
+  // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
+
+  led_set_user(usb_led);
+}
+
+*/

keyboards/shiro/shiro.h

@@ -0,0 +1,41 @@
+/* Copyright 2019 T.Shinohara
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include "quantum.h"
+
+/* This a shortcut to help you visually see your layout.
+ *
+ * The first section contains all of the arguments representing the physical
+ * layout of the board and position of the keys.
+ *
+ * The second converts the arguments into a two-dimensional array which
+ * represents the switch matrix.
+ */
+#define LAYOUT( \
+    k00, k01, k02, \
+    k10, k11, k12, \
+    k20, k21, k22, \
+    k30, k31, k32, \
+    k40, k41, k42 \
+) \
+{ \
+    { k00, k01, k02 }, \
+    { k10, k11, k12 }, \
+    { k20, k21, k22 }, \
+    { k30, k31, k32 }, \
+    { k40, k41, k42 } \
+}

keyboards/whitefox/keymaps/konstantin/config.h

@@ -1,6 +1,4 @@
 #pragma once
 
-#define IS_COMMAND() (get_mods() == (MOD_BIT(KC_LSFT) | MOD_BIT(KC_RCTL)))
-
 #define LAYER_FN
 #define LAYER_NUMPAD

keyboards/winkeyless/bface/README.md

@@ -14,6 +14,8 @@ Flashing
 
 ps2avr(GB) boards use an atmega32a microcontroller and a different bootloader. It is not flashable using the regular QMK methods. 
 
+**Reset Key:** Hold down the key located at K00, commonly programmed as left control while plugging in the keyboard.
+
 Windows: 
 1. Download [HIDBootFlash](http://vusb.wikidot.com/project:hidbootflash).
 2. Place your keyboard into reset. 
@@ -33,7 +35,7 @@ macOS:
 3. Install the following packages:
     ```
     brew install python
-    brew install pyusb
+    pip3 install pyusb
     brew install --HEAD`https://raw.githubusercontent.com/robertgzr/homebrew-tap/master/bootloadhid.rb
     ```
 

keyboards/winkeyless/bface/backlight_ps2avrGB.c

@@ -1,94 +0,0 @@
-/* Copyright 2017 Sebastian Kaim
- *
- * 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/>.
- */
-
-#ifdef BACKLIGHT_ENABLE
-
-#include "backlight_ps2avrGB.h"
-#define sbi(reg,bit)	reg |= (_BV(bit))
-#define cbi(reg,bit)	reg &= (~_BV(bit))
-#define PWM10	WGM10
-#define PWM11	WGM11
-#define COM1x1 COM1B1
-#define OCR1x  OCR1B
-
-void backlight_init_ports(void)
-{
-#if BACKLIGHT_ON_STATE == 0
-	backlight_off();
-#else
-	backlight_on();
-#endif
-
-	// setup pwm
-	// this bitmagic is sourced from the original firmware
-	/*TCCR1B = ((TCCR1B & ~0x07) | 0x03);
-	TCNT1H = 0;
-	TCNT1L = 0;
-	sbi(TIMSK, TOIE1);
-	OCR1BH = 0;
-	OCR1BL = 0;
-	cbi(TCCR1A,PWM11);
-	sbi(TCCR1A,PWM10);
-	sbi(TCCR1A,COM1B1);
-	cbi(TCCR1A,COM1B0);*/
-	ICR1 = 0xFFFF;
-
-    TCCR1A = _BV(COM1x1) | _BV(WGM11); // = 0b00001010;
-    TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
-
-	backlight_init();
-}
-
-void backlight_set(uint8_t level)
-{
-	if( level == 0 ) {
-		backlight_off();
-	}
-	else {
-		backlight_on();
-		/*uint8_t pwm = get_pwm_for_brightness(level);
-		set_backlight_pwm(pwm);
-		TCCR1A |= _BV(COM1x1);
-		OCR1x = (level >= 2) ? 0xFFFF : 0x00FF;*/
-	}
-}
-
-#define PWM_MAX 0xFF
-uint8_t get_pwm_for_brightness(uint8_t level)
-{
-	// we need to cast up here to allow multiplication with 0xFF. We could also use floats, but this is probably a lot faster.
-	uint16_t brightness = (uint16_t)level * (uint16_t)PWM_MAX / (uint16_t)BACKLIGHT_LEVELS;
-	return (uint8_t)brightness;
-}
-
-void backlight_on(void)
-{
-	//_SFR_IO8(0x12) |= _BV(0x4);
-	LED_PIN |= BACKLIGHT_PORT_NUM;
-}
-
-void backlight_off(void)
-{
-	//_SFR_IO8(0x12) &= ~_BV(0x4);
-	LED_PIN &= ~BACKLIGHT_PORT_NUM;
-}
-
-void set_backlight_pwm(uint8_t level) {
-	// this does not work (yet)
-	//OCR1B = level;
-}
-
-#endif // BACKLIGHT_ENABLE

keyboards/winkeyless/bface/bface.c

@@ -1,30 +1,23 @@
-/*
+/* Copyright 2019 MechMerlin
-Copyright 2017 Luiz Ribeiro <[email protected]>
+ *
-Copyright 2018 Sebastian Kaim <[email protected]>
+ * 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
-This program is free software: you can redistribute it and/or modify
+ * the Free Software Foundation, either version 2 of the License, or
-it under the terms of the GNU General Public License as published by
+ * (at your option) any later version.
-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
-This program is distributed in the hope that it will be useful,
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * GNU General Public License for more details.
-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/>.
-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 "bface.h"
 #include "rgblight.h"
-
+#include "i2c_master.h"
-#include <avr/pgmspace.h>
-
-#include "action_layer.h"
-#include "i2c.h"
 #include "quantum.h"
 
+#ifdef RGBLIGHT_ENABLE
 extern rgblight_config_t rgblight_config;
 
 void rgblight_set(void) {
@@ -37,10 +30,59 @@ void rgblight_set(void) {
     }
 
     i2c_init();
-    i2c_send(0xb0, (uint8_t*)led, 3 * RGBLED_NUM);
+    i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
+}
+#endif
+
+void matrix_init_kb(void) {
+#ifdef RGBLIGHT_ENABLE
+    if (rgblight_config.enable) {
+        i2c_init();
+        i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
+    }
+#endif
+    // call user level keymaps, if any
+    matrix_init_user();
+}
+
+void matrix_scan_kb(void) {
+#ifdef RGBLIGHT_ENABLE
+    rgblight_task();
+#endif
+    matrix_scan_user();
+    /* Nothing else for now. */
 }
 
 __attribute__ ((weak))
 void matrix_scan_user(void) {
-    rgblight_task();
+}
+
+void backlight_init_ports(void) {
+    // initialize pins D0, D1, D4 and D6 as output
+    setPinOutput(D0);
+    setPinOutput(D1);
+    setPinOutput(D4);
+    setPinOutput(D6);
+
+    // turn backlight LEDs on
+    writePinHigh(D0);
+    writePinHigh(D1);
+    writePinHigh(D4);
+    writePinHigh(D6);
+}
+
+void backlight_set(uint8_t level) {
+	if (level == 0) {
+        // turn backlight LEDs off
+        writePinLow(D0);
+        writePinLow(D1);
+        writePinLow(D4);
+        writePinLow(D6);
+	} else {
+        // turn backlight LEDs on
+        writePinHigh(D0);
+        writePinHigh(D1);
+        writePinHigh(D4);
+        writePinHigh(D6);
+	}
 }

keyboards/winkeyless/bface/bface.h

@@ -16,8 +16,7 @@ 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_COMMON_H
+#pragma once
-#define KEYMAP_COMMON_H
 
 #include "quantum_keycodes.h"
 #include "keycode.h"
@@ -27,8 +26,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
   K04, K14, K24, K34, K44, K54, K16, KB6, KB7, K17, KA4, KB4, KC4, KE4, \
   K03, K13, K23, K33, K43, K53, K26, KC6, KC7, K27, KA3, KB3, KC3, KD3, \
   K02, K12, K22, K32, K42, K52, K36, KD6, KD7, K37, KA2, KB2,      KD2, \
-  K01, K11, K21, K31, K41, K51, K46, KE6, KE7, K47, KA1, KB1, \
+  K01, K11, K21, K31, K41, K51, K46, KE6, KE7, K47, KA1, KB1,           \
-  K00, K10, K20,           K56,                K57, KA0, KB0, KC0  \
+  K00, K10, K20,           K56,                K57, KA0, KB0, KC0       \
 ){ \
   { K00,   K10,   K20,   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KA0,   KB0,   KC0,   KC_NO, KC_NO }, \
   { K01,   K11,   K21,   K31,   K41,   K51,   KC_NO, KC_NO, KC_NO, KC_NO, KA1,   KB1,   KC_NO, KC_NO, KC_NO }, \
@@ -37,8 +36,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
   { K04,   K14,   K24,   K34,   K44,   K54,   KC_NO, KC_NO, KC_NO, KC_NO, KA4,   KB4,   KC4,   KC_NO, KE4   }, \
   { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
   { KC_NO, K16,   K26,   K36,   K46,   K56,   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KB6,   KC6,   KD6,   KE6   }, \
-  { KC_NO, K17,   K27,   K37,   K47,   K57,   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KB7,   KC7,   KD7,   KE7   } \
+  { KC_NO, K17,   K27,   K37,   K47,   K57,   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KB7,   KC7,   KD7,   KE7   }  \
 }
 
-
-#endif

keyboards/winkeyless/bface/config.h

@@ -16,8 +16,7 @@ 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 CONFIG_H
+#pragma once
-#define CONFIG_H
 
 #define VENDOR_ID       0x20A0
 #define PRODUCT_ID      0x422D
@@ -30,6 +29,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MATRIX_ROWS 8
 #define MATRIX_COLS 15
 
+//                        0   1   2   3   4   5   6   7   8   9   A   B   C   D   E
+#define MATRIX_ROW_PINS { B0, B1, B2, B3, B4, B5, B6, B7 }
+#define MATRIX_COL_PINS { A0, A1, A2, A3, A4, A5, A6, A7, C7, C6, C5, C4, C3, C2, D7}
+#define UNUSED_PINS
+
 #define RGBLED_NUM 16
 #define RGBLIGHT_ANIMATIONS
 
@@ -43,4 +47,3 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 	#define BACKLIGHT_PORT_NUM (1 << 4)
 #endif
 
-#endif

keyboards/winkeyless/bface/i2c.c

@@ -1,104 +0,0 @@
-/*
-Copyright 2016 Luiz Ribeiro <[email protected]>
-
-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 <avr/io.h>
-#include <util/twi.h>
-
-#include "i2c.h"
-
-void i2c_set_bitrate(uint16_t bitrate_khz) {
-    uint8_t bitrate_div = ((F_CPU / 1000l) / bitrate_khz);
-    if (bitrate_div >= 16) {
-        bitrate_div = (bitrate_div - 16) / 2;
-    }
-    TWBR = bitrate_div;
-}
-
-void i2c_init(void) {
-    // set pull-up resistors on I2C bus pins
-    PORTC |= 0b11;
-
-    i2c_set_bitrate(400);
-
-    // enable TWI (two-wire interface)
-    TWCR |= (1 << TWEN);
-
-    // enable TWI interrupt and slave address ACK
-    TWCR |= (1 << TWIE);
-    TWCR |= (1 << TWEA);
-}
-
-uint8_t i2c_start(uint8_t address) {
-    // reset TWI control register
-    TWCR = 0;
-
-    // begin transmission and wait for it to end
-    TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
-    while (!(TWCR & (1<<TWINT)));
-
-    // check if the start condition was successfully transmitted
-    if ((TWSR & 0xF8) != TW_START) {
-        return 1;
-    }
-
-    // transmit address and wait
-    TWDR = address;
-    TWCR = (1<<TWINT) | (1<<TWEN);
-    while (!(TWCR & (1<<TWINT)));
-
-    // check if the device has acknowledged the READ / WRITE mode
-    uint8_t twst = TW_STATUS & 0xF8;
-    if ((twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK)) {
-        return 1;
-    }
-
-    return 0;
-}
-
-void i2c_stop(void) {
-    TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
-}
-
-uint8_t i2c_write(uint8_t data) {
-    TWDR = data;
-
-    // transmit data and wait
-    TWCR = (1<<TWINT) | (1<<TWEN);
-    while (!(TWCR & (1<<TWINT)));
-
-    if ((TWSR & 0xF8) != TW_MT_DATA_ACK) {
-        return 1;
-    }
-
-    return 0;
-}
-
-uint8_t i2c_send(uint8_t address, uint8_t *data, uint16_t length) {
-    if (i2c_start(address)) {
-        return 1;
-    }
-
-    for (uint16_t i = 0; i < length; i++) {
-        if (i2c_write(data[i])) {
-            return 1;
-        }
-    }
-
-    i2c_stop();
-
-    return 0;
-}

keyboards/winkeyless/bface/keymaps/p3lim/README.md

@@ -0,0 +1,14 @@
+# p3lim's b.face layout
+
+![](https://user-images.githubusercontent.com/26496/61170794-bf8a2c80-a56e-11e9-893f-f1766e7a9a04.png)
+
+My layout using the winkeyless b.face X2 PCB. The keys indicated with a gray color was not supported by the layout so a custom one was made.
+
+### Building & Flashing
+
+- Hold <kbd>LCTRL</kbd> while connecting to put in flashing mode
+- Follow instructions in the main _bface_ directory
+
+### Layout notes
+
+The two additional keys were on pins 22+41 and 22+42, C3+B1 and C3+B2, which is mapped to col 10 row 1 and col 10 row 2 in the matrix.

keyboards/winkeyless/bface/keymaps/p3lim/keymap.c

@@ -0,0 +1,156 @@
+/*
+Copyright 2019 Adrian L Lange <[email protected]>
+
+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 "quantum.h"
+
+#define LAYOUT_p3lim(\
+  K04, K14, K24, K34, K44, K54, K16, KB6, KB7, K17, KA4, KB4, KC4, KE4, \
+  K03, K13, K23, K33, K43, K53, K26, KC6, KC7, K27, KA3, KB3, KC3, \
+  K02, K12, K22, K32, K42, K52, K36, KD6, KD7, K37, KA2, KB2, KC2, KD2, \
+  K01, K11, K21, K31, K41, K51, K46, KE6, KE7, K47, KA1, KB1, KC1, \
+  K00, K10, K20,           K56,                K57, KB0, KC0  \
+){ \
+  { K00,   K10,   K20,   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KB0,   KC0,   KC_NO, KC_NO }, \
+  { K01,   K11,   K21,   K31,   K41,   K51,   KC_NO, KC_NO, KC_NO, KC_NO, KA1,   KB1,   KC1,   KC_NO, KC_NO }, \
+  { K02,   K12,   K22,   K32,   K42,   K52,   KC_NO, KC_NO, KC_NO, KC_NO, KA2,   KB2,   KC2,   KD2,   KC_NO }, \
+  { K03,   K13,   K23,   K33,   K43,   K53,   KC_NO, KC_NO, KC_NO, KC_NO, KA3,   KB3,   KC3,   KC_NO, KC_NO }, \
+  { K04,   K14,   K24,   K34,   K44,   K54,   KC_NO, KC_NO, KC_NO, KC_NO, KA4,   KB4,   KC4,   KC_NO, KE4   }, \
+  { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
+  { KC_NO, K16,   K26,   K36,   K46,   K56,   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KB6,   KC6,   KD6,   KE6   }, \
+  { KC_NO, K17,   K27,   K37,   K47,   K57,   KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KB7,   KC7,   KD7,   KE7   } \
+}
+
+enum my_keycodes {
+	C_ESC0 = SAFE_RANGE, // layer 0 esc
+	C_ESC1               // layer 1 esc
+};
+
+// use compiler macros for simpler stuff
+#define C_NO1 RALT(KC_QUOT)
+#define C_NO2 RALT(KC_SCLN)
+#define C_NO3 RALT(KC_LBRC)
+#define C_KVM1 LCA(KC_1)
+#define C_KVM2 LCA(KC_2)
+#define C_KVM3 LCA(KC_3)
+#define C_KVM4 LCA(KC_4)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	/* QWERTY
+	* ,-----------------------------------------------------------------------------------------.
+	* | Esc |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  0  |  -  |  =  |   Bkspc   |
+	* |-----------------------------------------------------------------------------------------+
+	* |   Tab  |  Q  |  W  |  E  |  R  |  T  |  Y  |  U  |  I  |  O  |  P  |  [  |  ]  |        |
+	* |---------------------------------------------------------------------------------| Enter |
+	* |   Ctrl  |  A  |  S  |  D  |  F  |  G  |  H  |  J  |  K  |  L  |  ;  |  '  |  \  |       |
+	* |-----------------------------------------------------------------------------------------+
+	* |   Shift   |  Z  |  X  |  C  |  V  |  B  |  N  |  M  |  ,  |  .  |  /  |   Shift   | Del |
+	* |-----------------------------------------------------------------------------------------+
+	* |  FN1  | Alt |  GUI   |              Space                      |  FN2   | Alt |  Ctrl   |
+	* `-----------------------------------------------------------------------------------------'
+	*/
+	[0] = LAYOUT_p3lim(
+		C_ESC0,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC,
+		KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC,
+		KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_BSLS, KC_ENT,
+		KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT, KC_DEL,
+		MO(1),   KC_LALT, KC_LGUI,                   KC_SPC,                             MO(2),   KC_RGUI, KC_RCTL
+	),
+
+	/* FN1
+	* ,-----------------------------------------------------------------------------------------.
+	* |  `  | F1  | F2  | F3  | F4  | F5  | F6  | F7  | F8  | F9  | F10 | F11 | F12 |           |
+	* |-----------------------------------------------------------------------------------------+
+	* |  Caps  | Home| Up  | End | PgUp|     |     |     |     |     |     |     |     |        |
+	* |---------------------------------------------------------------------------------|       |
+	* |         | Left| Down|Right| PgDn|     |     |     |     |     |     |     |     |       |
+	* |-----------------------------------------------------------------------------------------+
+	* |           | KVM1| KVM2| KVM3| KVM4|     |     |     |     |     |     |           |     |
+	* |-----------------------------------------------------------------------------------------+
+	* |       |     |        |                                         |        |     |         |
+	* `-----------------------------------------------------------------------------------------'
+	*/
+	[1] = LAYOUT_p3lim(
+		C_ESC1,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  _______,
+		KC_CAPS, KC_HOME, KC_UP,   KC_END,  KC_PGUP, _______, _______, _______, _______, _______, _______, _______, _______,
+		_______, KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+		_______, C_KVM1,  C_KVM2,  C_KVM3,  C_KVM4,  _______, _______, _______, _______, _______, _______, _______, _______,
+		_______, _______, _______,                   _______,                            KC_NO,   _______, _______
+	),
+
+	/* FN2
+	* ,-----------------------------------------------------------------------------------------.
+	* |     |     |     |     |     |     |     |     |     |     |     |     |     |           |
+	* |-----------------------------------------------------------------------------------------+
+	* |        |     |     |     |     |     |     |     |     |     |     |  Å  |     |        |
+	* |---------------------------------------------------------------------------------|       |
+	* |         |     |     |     |     |     |     |     |     |     |  Ø  |  Æ  |     |       |
+	* |-----------------------------------------------------------------------------------------+
+	* |           |     |     |     |     |     |     |     |     |     |     |           |     |
+	* |-----------------------------------------------------------------------------------------+
+	* |       |     |        |                                         |        |     |         |
+	* `-----------------------------------------------------------------------------------------'
+	*/
+	[2] = LAYOUT_p3lim(
+		_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+		_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, C_NO3,   _______,
+		_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, C_NO2,   C_NO1,   _______, _______,
+		_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+		KC_NO,   _______, _______,                   _______,                            _______, _______, _______
+	),
+	/*
+	[n] = LAYOUT_p3lim(
+		_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+		_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+		_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+		_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+		_______, _______, _______,                   _______,                            _______, _______, _______
+	),
+	*/
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record){
+	switch(keycode){
+		case C_ESC0: // layer 0
+			if(record->event.pressed){
+				if(get_mods() & MOD_MASK_SHIFT)
+					register_code(KC_GRAVE);
+				else
+					register_code(KC_ESCAPE);
+			} else {
+				if(get_mods() & MOD_MASK_SHIFT)
+					unregister_code(KC_GRAVE);
+				else
+					unregister_code(KC_ESCAPE);
+			}
+			return false;
+		case C_ESC1: // layer 1
+			if(record->event.pressed){
+				if(get_mods() & MOD_MASK_SHIFT)
+					register_code(KC_ESCAPE);
+				else
+					register_code(KC_GRAVE);
+			} else {
+				if(get_mods() & MOD_MASK_SHIFT)
+					unregister_code(KC_ESCAPE);
+				else
+					unregister_code(KC_GRAVE);
+			}
+			return false;
+	}
+	return true;
+}

keyboards/winkeyless/bface/matrix.c

@@ -1,113 +0,0 @@
-/*
-Copyright 2017 Luiz Ribeiro <[email protected]>
-
-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 <avr/io.h>
-#include <util/delay.h>
-
-#include "matrix.h"
-
-#ifndef DEBOUNCE
-#   define DEBOUNCE	5
-#endif
-
-static uint8_t debouncing = DEBOUNCE;
-
-static matrix_row_t matrix[MATRIX_ROWS];
-static matrix_row_t matrix_debouncing[MATRIX_ROWS];
-
-void matrix_init(void) {
-    // all outputs for rows high
-    DDRB = 0xFF;
-    PORTB = 0xFF;
-    // all inputs for columns
-    DDRA = 0x00;
-    DDRC &= ~(0x111111<<2);
-    DDRD &= ~(1<<PIND7);
-    // all columns are pulled-up
-    PORTA = 0xFF;
-    PORTC |= (0b111111<<2);
-    PORTD |= (1<<PIND7);
-
-    // initialize matrix state: all keys off
-    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
-        matrix[row] = 0x00;
-        matrix_debouncing[row] = 0x00;
-    }
-
-	// activate backlight
-	//PORTD |= (1 << 4);
-	//_SFR_IO8(0x09) |= (1 << 4); //_BV(0x94 & 0xF);
-	//
-	// this is the code that *should* be executed in quantum.c
-	_SFR_IO8(0x12) |= _BV(0x4);
-}
-
-void matrix_set_row_status(uint8_t row) {
-    DDRB = (1 << row);
-    PORTB = ~(1 << row);
-}
-
-uint8_t bit_reverse(uint8_t x) {
-    x = ((x >> 1) & 0x55) | ((x << 1) & 0xaa);
-    x = ((x >> 2) & 0x33) | ((x << 2) & 0xcc);
-    x = ((x >> 4) & 0x0f) | ((x << 4) & 0xf0);
-    return x;
-}
-
-uint8_t matrix_scan(void) {
-    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
-        matrix_set_row_status(row);
-        _delay_us(5);
-
-        matrix_row_t cols = (
-            // cols 0..7, PORTA 0 -> 7
-            (~PINA) & 0xFF
-        ) | (
-            // cols 8..13, PORTC 7 -> 0
-            bit_reverse((~PINC) & 0xFF) << 8
-        ) | (
-            // col 14, PORTD 7
-            ((~PIND) & (1 << PIND7)) << 7
-        );
-
-        if (matrix_debouncing[row] != cols) {
-            matrix_debouncing[row] = cols;
-            debouncing = DEBOUNCE;
-        }
-    }
-
-    if (debouncing) {
-        if (--debouncing) {
-            _delay_ms(1);
-        } else {
-            for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
-                matrix[i] = matrix_debouncing[i];
-            }
-        }
-    }
-
-    matrix_scan_user();
-
-    return 1;
-}
-
-inline matrix_row_t matrix_get_row(uint8_t row) {
-    return matrix[row];
-}
-
-void matrix_print(void) {
-}

keyboards/winkeyless/bface/rules.mk

@@ -25,7 +25,7 @@ NO_SUSPEND_POWER_DOWN = yes
 F_CPU = 12000000
 
 # build options
-BOOTMAGIC_ENABLE = yes
+BOOTMAGIC_ENABLE = no
 MOUSEKEY_ENABLE = yes
 EXTRAKEY_ENABLE = yes
 CONSOLE_ENABLE = no
@@ -40,8 +40,7 @@ OPT_DEFS = -DDEBUG_LEVEL=0
 OPT_DEFS += -DBOOTLOADER_SIZE=2048
 
 # custom matrix setup
-CUSTOM_MATRIX = yes
+SRC = i2c_master.c
-SRC = matrix.c i2c.c backlight_ps2avrGB.c
 
 # programming options
 PROGRAM_CMD = ./util/atmega32a_program.py $(TARGET).hex

keyboards/winkeyless/bface/usbconfig.h

@@ -8,8 +8,7 @@
  * This Revision: $Id: usbconfig-prototype.h 785 2010-05-30 17:57:07Z cs $
  */
 
-#ifndef __usbconfig_h_included__
+#pragma once
-#define __usbconfig_h_included__
 
 #include "config.h"
 
@@ -392,5 +391,3 @@ section at the end of this file).
 /* #define USB_INTR_PENDING        EIFR */
 #define USB_INTR_PENDING_BIT    INTF1
 #define USB_INTR_VECTOR         INT1_vect
-
-#endif /* __usbconfig_h_included__ */

keyboards/xd004/info.json

@@ -0,0 +1,11 @@
+{
+    "keyboard_name": "XD004", 
+    "maintainer": "", 
+    "width": 4, 
+    "height": 1, 
+    "layouts": {
+        "LAYOUT_all": {
+            "layout": [{"label":"L", "x":0, "y":0}, {"label":"O", "x":1, "y":0}, {"label":"V", "x":2, "y":0}, {"label":"E", "x":3, "y":0}]
+        }
+    }
+}

keyboards/xd004/keymaps/default/keymap.c

@@ -0,0 +1,13 @@
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+    // 0: Base Layer
+    LAYOUT_all(KC_L, KC_O, KC_V, KC_E),
+
+};
+
+// Loop
+void matrix_scan_user(void){
+    // Empty
+};

keyboards/xd004/keymaps/default/readme.md

@@ -0,0 +1,7 @@
+# Default Keymap for XD004 PCB
+
+This keymap is not very useful, but it will validate that the board works.
+
+## Build
+
+To build the default keymap, simply run `make xd004:default`.

keyboards/xd004/keymaps/system_and_media/keymap.c

@@ -0,0 +1,61 @@
+#include QMK_KEYBOARD_H
+
+#define _BASE 0    // Base layer
+#define _SYSTEM 1  // System actions
+#define _VOLUME 2  // Volume actions
+
+#define SUPER_ALT_F4_TIMER 300  // Timeout on the super alt-f4 key
+
+/*
+    The idea of this is pretty simple: base layer has four action, two of which (the outermost)
+    are regular keystrokes on tap, and a momentary layer switch on hold, sending you to layers 1 and 2.
+
+    The other bit of customization here is the 'Super Alt F4' which does Alt-F4, and then Enter if tapped
+    again SUPER_ALT_F4_TIMER miliseconds after. This lets you Alt-F4 applications, and finally quickly
+    double-tap it to Alt-F4+Enter to shut down the PC.
+*/
+
+bool is_alt_f4_active = false;
+uint16_t alt_f4_timer = 0;
+
+enum custom_keycodes {  // Make sure have the awesome keycode ready
+    SUPER_ALT_F4 = SAFE_RANGE,
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+    // 0: Base Layer
+    [_BASE] = LAYOUT_all(LT(_SYSTEM, KC_F5), C(G(KC_LEFT)), C(G(KC_RIGHT)), LT(_VOLUME, KC_F7)),
+
+    // 1: System actions
+    [_SYSTEM] = LAYOUT_all(_______, SUPER_ALT_F4, G(KC_D), G(KC_L)),
+
+    // 2: Volume actions
+    [_VOLUME] = LAYOUT_all(KC_MEDIA_NEXT_TRACK, KC_AUDIO_VOL_DOWN, KC_AUDIO_VOL_UP, _______),
+
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {  // This will do most of the grunt work with the keycodes.
+        case SUPER_ALT_F4:
+            if (record->event.pressed) {
+                if (!is_alt_f4_active) {
+                    is_alt_f4_active = true;
+                    tap_code_16(LALT(KC_F4);  // Alt-F4
+                } else {
+                    tap_code(KC_ENTER);  // Tap enter
+                }
+            } else {
+                unregister_code(KC_TAB);
+            }
+            alt_f4_timer = timer_read();
+            break;
+    }
+    return true;
+}
+
+void matrix_scan_user(void) {
+    if (is_alt_f4_active && timer_elapsed(alt_f4_timer) > SUPER_ALT_F4_TIMER) {
+        is_alt_f4_active = false;
+    }
+};

keyboards/xd004/keymaps/system_and_media/readme.md

@@ -0,0 +1,9 @@
+# Default Keymap for XD004 PCB
+
+A somehow more useful keymap, allowing one to move across virtual desktops on Windows, etc.
+
+It also has a 'Super Alt-F4' key for Windows that, when tapped does Alt-F4, unless two consecutive taps are less than 300ms apart, in which case the second tap becomes Enter. This allows you to close all apps doing taps, and then when the System shutdown window arrives you do a second quick tap and it will type enter, thus shutting down the computer.
+
+## Build
+
+To build the keymap, simply run `make xd004:system_and_media`.

keyboards/xd004/readme.md

@@ -0,0 +1,16 @@
+XD004
+==
+
+4-keys board
+
+![Top View of a XD004 board](https://ae01.alicdn.com/kf/HTB1_G9IX21H3KVjSZFHq6zKppXa0/xd004-xiudi-4-Custom-Mechanical-Keyboard-4-keys-switch-leds-PCB-programmed-hot-swappable-macro-key.jpg)
+
+Keyboard Maintainer: QMK Community  
+Hardware Supported: XD004 PCB v1.0  
+Hardware Availability: [KPRepublic](https://kprepublic.com/products/xd004-xiudi-4-custom-mechanical-keyboard-4-keys-switch-leds-pcb-programmed-hot-swappable-macro-key-silver-case-micro-port)
+
+To build with a default keymap (not useful at all, have a look at other keymaps):
+
+```make xd004/v1:default```
+
+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).

keyboards/xd004/v1/config.h

@@ -0,0 +1,80 @@
+/*
+Copyright 2019 Sidney Bovet <[email protected]>
+
+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/>.
+*/
+
+/*
+Note: the following configuration uses 98% of the flash memory, be
+careful if you enable anything else. Also have a look at rules.mk
+where some things are disabled to save space as well.
+*/
+
+#pragma once
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID 0xCDCD
+#define PRODUCT_ID 0x0404
+#define DEVICE_VER 0x0001
+// Note: unsure about manufacturer
+#define MANUFACTURER XIUDI
+#define PRODUCT XD004 v1
+#define DESCRIPTION XD004 v1 Keyboard PCB
+
+/* key matrix size */
+#define MATRIX_ROWS 1
+#define MATRIX_COLS 4
+
+/*
+ * Keyboard Matrix Assignments
+ *
+ * On this board we have direct connection: no diodes.
+ */
+#define DIRECT_PINS        \
+    {                      \
+        { D3, D0, C4, B4 } \
+    }
+#define UNUSED_PINS
+
+/* Backlight Setup */
+// Looks like each backlight LED is connected to a single output, D5 is the one furtherst away from USB port
+#define BACKLIGHT_PIN D5
+#define BACKLIGHT_LEVELS 6
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCE 5
+
+/* RGB Underglow
+This will not be used, as RGBLIGHT_ENABLE is set to 'no' in rules.mk
+We do not have enough space in the flash for this at the moment, maybe
+further optimizations can be done on that side.
+*/
+#define RGB_DI_PIN C6
+#define RGBLIGHT_EFFECT_STATIC_GRADIENT
+#define RGBLIGHT_EFFECT_RAINBOW_SWIRL
+#define RGBLED_NUM 2
+#define RGBLIGHT_HUE_STEP 10
+#define RGBLIGHT_SAT_STEP 17
+#define RGBLIGHT_VAL_STEP 17
+
+/* disable action features */
+// #define NO_ACTION_ONESHOT // 462 bytes <- this needs to be un-commented out if Link Time Optimization is disabled, otherwise file is too large
+// The two below are implicit since we use LINK_TIME_OPTIMIZATION_ENABLE (in rules.mk)
+// #define NO_ACTION_MACRO
+// #define NO_ACTION_FUNCTION

keyboards/xd004/v1/rules.mk

@@ -0,0 +1,70 @@
+# MCU name
+MCU = atmega16u2
+
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+
+# LUFA specific
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Boot Section Size in *bytes*
+#   Teensy halfKay   512
+#   Teensy++ halfKay 2048
+#   Atmel DFU loader 4096
+#   LUFA bootloader  4096
+#   USBaspLoader     2048
+OPT_DEFS += -DBOOTLOADER_SIZE=4096
+BOOTLOADER = atmel-dfu
+
+
+# Build Options
+BOOTMAGIC_ENABLE = lite       # Virtual DIP switch configuration
+MOUSEKEY_ENABLE = no        # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes        # Audio control and System control(+450)
+CONSOLE_ENABLE = no         # Console for debug(+400)
+COMMAND_ENABLE = no         # Commands for debug and configuration
+NKRO_ENABLE = no            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
+MIDI_ENABLE = no            # MIDI controls
+AUDIO_ENABLE = no           # Audio output on port C6
+UNICODE_ENABLE = no         # Unicode
+BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
+RGBLIGHT_ENABLE = no        # Enable WS2812 RGB underlight.
+SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
+
+# Saves about 5% of space:
+LINK_TIME_OPTIMIZATION_ENABLE = yes
+
+#LAYOUTS = ortho_1x4

keyboards/xd004/xd004.c

@@ -0,0 +1,7 @@
+#include "xd004.h"
+
+void led_set_kb(uint8_t usb_led) {
+    // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
+
+    led_set_user(usb_led);
+}

keyboards/xd004/xd004.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "quantum.h"
+//#include "led.h"
+
+/* XD60 Keymap Definition Macro */
+/*
+    +--------------------------------+
+    |   K0      K1      K2      K3   [----- USB
+    +--------------------------------+
+*/
+#define LAYOUT_all(K00, K01, K02, K03) \
+    {                                  \
+        { K00, K01, K02, K03 }         \
+    }

layouts/community/ortho_1x4/belgorath/keymap.c

@@ -0,0 +1,24 @@
+#include QMK_KEYBOARD_H
+
+extern keymap_config_t keymap_config;
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+
+#define _DEFAULT 0
+#define _LOWER  1
+#define LOWER  LT(_LOWER, KC_PENT)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+[_DEFAULT] = LAYOUT_ortho_1x4 (
+    LOWER,  KC_P0,  KC_PDOT,KC_PAST 
+),
+
+/* Lower */
+[_LOWER] = LAYOUT_ortho_1x4 ( 
+    _______,_______,_______,_______ 
+),
+};

layouts/community/ortho_1x4/layout.json

@@ -0,0 +1 @@
+["","","",""]

lib/python/milc.py

@@ -0,0 +1,716 @@
+#!/usr/bin/env python3
+# coding=utf-8
+"""MILC - A CLI Framework
+
+PYTHON_ARGCOMPLETE_OK
+
+MILC is an opinionated framework for writing CLI apps. It optimizes for the
+most common unix tool pattern- small tools that are run from the command
+line but generally do not feature any user interaction while they run.
+
+For more details see the MILC documentation:
+
+    <https://github.com/clueboard/milc/tree/master/docs>
+"""
+from __future__ import division, print_function, unicode_literals
+import argparse
+import logging
+import os
+import re
+import sys
+from decimal import Decimal
+from tempfile import NamedTemporaryFile
+from time import sleep
+
+try:
+    from ConfigParser import RawConfigParser
+except ImportError:
+    from configparser import RawConfigParser
+
+try:
+    import thread
+    import threading
+except ImportError:
+    thread = None
+
+import argcomplete
+import colorama
+
+# Log Level Representations
+EMOJI_LOGLEVELS = {
+    'CRITICAL': '{bg_red}{fg_white}¬_¬{style_reset_all}',
+    'ERROR': '{fg_red}☒{style_reset_all}',
+    'WARNING': '{fg_yellow}⚠{style_reset_all}',
+    'INFO': '{fg_blue}ℹ{style_reset_all}',
+    'DEBUG': '{fg_cyan}☐{style_reset_all}',
+    'NOTSET': '{style_reset_all}¯\\_(o_o)_/¯'
+}
+EMOJI_LOGLEVELS['FATAL'] = EMOJI_LOGLEVELS['CRITICAL']
+EMOJI_LOGLEVELS['WARN'] = EMOJI_LOGLEVELS['WARNING']
+
+# ANSI Color setup
+# Regex was gratefully borrowed from kfir on stackoverflow:
+# https://stackoverflow.com/a/45448194
+ansi_regex = r'\x1b(' \
+             r'(\[\??\d+[hl])|' \
+             r'([=<>a-kzNM78])|' \
+             r'([\(\)][a-b0-2])|' \
+             r'(\[\d{0,2}[ma-dgkjqi])|' \
+             r'(\[\d+;\d+[hfy]?)|' \
+             r'(\[;?[hf])|' \
+             r'(#[3-68])|' \
+             r'([01356]n)|' \
+             r'(O[mlnp-z]?)|' \
+             r'(/Z)|' \
+             r'(\d+)|' \
+             r'(\[\?\d;\d0c)|' \
+             r'(\d;\dR))'
+ansi_escape = re.compile(ansi_regex, flags=re.IGNORECASE)
+ansi_styles = (
+    ('fg', colorama.ansi.AnsiFore()),
+    ('bg', colorama.ansi.AnsiBack()),
+    ('style', colorama.ansi.AnsiStyle()),
+)
+ansi_colors = {}
+
+for prefix, obj in ansi_styles:
+    for color in [x for x in obj.__dict__ if not x.startswith('_')]:
+        ansi_colors[prefix + '_' + color.lower()] = getattr(obj, color)
+
+
+def format_ansi(text):
+    """Return a copy of text with certain strings replaced with ansi.
+    """
+    # Avoid .format() so we don't have to worry about the log content
+    for color in ansi_colors:
+        text = text.replace('{%s}' % color, ansi_colors[color])
+    return text + ansi_colors['style_reset_all']
+
+
+class ANSIFormatter(logging.Formatter):
+    """A log formatter that inserts ANSI color.
+    """
+
+    def format(self, record):
+        msg = super(ANSIFormatter, self).format(record)
+        return format_ansi(msg)
+
+
+class ANSIEmojiLoglevelFormatter(ANSIFormatter):
+    """A log formatter that makes the loglevel an emoji.
+    """
+
+    def format(self, record):
+        record.levelname = EMOJI_LOGLEVELS[record.levelname].format(**ansi_colors)
+        return super(ANSIEmojiLoglevelFormatter, self).format(record)
+
+
+class ANSIStrippingFormatter(ANSIFormatter):
+    """A log formatter that strips ANSI.
+    """
+
+    def format(self, record):
+        msg = super(ANSIStrippingFormatter, self).format(record)
+        return ansi_escape.sub('', msg)
+
+
+class Configuration(object):
+    """Represents the running configuration.
+
+    This class never raises IndexError, instead it will return None if a
+    section or option does not yet exist.
+    """
+
+    def __contains__(self, key):
+        return self._config.__contains__(key)
+
+    def __iter__(self):
+        return self._config.__iter__()
+
+    def __len__(self):
+        return self._config.__len__()
+
+    def __repr__(self):
+        return self._config.__repr__()
+
+    def keys(self):
+        return self._config.keys()
+
+    def items(self):
+        return self._config.items()
+
+    def values(self):
+        return self._config.values()
+
+    def __init__(self, *args, **kwargs):
+        self._config = {}
+        self.default_container = ConfigurationOption
+
+    def __getitem__(self, key):
+        """Returns a config section, creating it if it doesn't exist yet.
+        """
+        if key not in self._config:
+            self.__dict__[key] = self._config[key] = ConfigurationOption()
+
+        return self._config[key]
+
+    def __setitem__(self, key, value):
+        self.__dict__[key] = value
+        self._config[key] = value
+
+    def __delitem__(self, key):
+        if key in self.__dict__ and key[0] != '_':
+            del self.__dict__[key]
+        del self._config[key]
+
+
+class ConfigurationOption(Configuration):
+    def __init__(self, *args, **kwargs):
+        super(ConfigurationOption, self).__init__(*args, **kwargs)
+        self.default_container = dict
+
+    def __getitem__(self, key):
+        """Returns a config section, creating it if it doesn't exist yet.
+        """
+        if key not in self._config:
+            self.__dict__[key] = self._config[key] = None
+
+        return self._config[key]
+
+
+def handle_store_boolean(self, *args, **kwargs):
+    """Does the add_argument for action='store_boolean'.
+    """
+    kwargs['add_dest'] = False
+    disabled_args = None
+    disabled_kwargs = kwargs.copy()
+    disabled_kwargs['action'] = 'store_false'
+    disabled_kwargs['help'] = 'Disable ' + kwargs['help']
+    kwargs['action'] = 'store_true'
+    kwargs['help'] = 'Enable ' + kwargs['help']
+
+    for flag in args:
+        if flag[:2] == '--':
+            disabled_args = ('--no-' + flag[2:],)
+            break
+
+    self.add_argument(*args, **kwargs)
+    self.add_argument(*disabled_args, **disabled_kwargs)
+
+    return (args, kwargs, disabled_args, disabled_kwargs)
+
+
+class SubparserWrapper(object):
+    """Wrap subparsers so we can populate the normal and the shadow parser.
+    """
+
+    def __init__(self, cli, submodule, subparser):
+        self.cli = cli
+        self.submodule = submodule
+        self.subparser = subparser
+
+        for attr in dir(subparser):
+            if not hasattr(self, attr):
+                setattr(self, attr, getattr(subparser, attr))
+
+    def completer(self, completer):
+        """Add an arpcomplete completer to this subcommand.
+        """
+        self.subparser.completer = completer
+
+    def add_argument(self, *args, **kwargs):
+        if kwargs.get('add_dest', True):
+            kwargs['dest'] = self.submodule + '_' + self.cli.get_argument_name(*args, **kwargs)
+        if 'add_dest' in kwargs:
+            del kwargs['add_dest']
+
+        if 'action' in kwargs and kwargs['action'] == 'store_boolean':
+            return handle_store_boolean(self, *args, **kwargs)
+
+        self.cli.acquire_lock()
+        self.subparser.add_argument(*args, **kwargs)
+
+        if 'default' in kwargs:
+            del kwargs['default']
+        if 'action' in kwargs and kwargs['action'] == 'store_false':
+            kwargs['action'] == 'store_true'
+        self.cli.subcommands_default[self.submodule].add_argument(*args, **kwargs)
+        self.cli.release_lock()
+
+
+class MILC(object):
+    """MILC - An Opinionated Batteries Included Framework
+    """
+
+    def __init__(self):
+        """Initialize the MILC object.
+        """
+        # Setup a lock for thread safety
+        self._lock = threading.RLock() if thread else None
+
+        # Define some basic info
+        self.acquire_lock()
+        self._description = None
+        self._entrypoint = None
+        self._inside_context_manager = False
+        self.ansi = ansi_colors
+        self.config = Configuration()
+        self.config_file = None
+        self.prog_name = sys.argv[0][:-3] if sys.argv[0].endswith('.py') else sys.argv[0]
+        self.version = os.environ.get('QMK_VERSION', 'unknown')
+        self.release_lock()
+
+        # Initialize all the things
+        self.initialize_argparse()
+        self.initialize_logging()
+
+    @property
+    def description(self):
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        self._description = self._arg_parser.description = self._arg_defaults.description = value
+
+    def echo(self, text, *args, **kwargs):
+        """Print colorized text to stdout, as long as stdout is a tty.
+
+        ANSI color strings (such as {fg-blue}) will be converted into ANSI
+        escape sequences, and the ANSI reset sequence will be added to all
+        strings.
+
+        If *args or **kwargs are passed they will be used to %-format the strings.
+        """
+        if args and kwargs:
+            raise RuntimeError('You can only specify *args or **kwargs, not both!')
+
+        if sys.stdout.isatty():
+            args = args or kwargs
+            text = format_ansi(text)
+
+            print(text % args)
+
+    def initialize_argparse(self):
+        """Prepare to process arguments from sys.argv.
+        """
+        kwargs = {
+            'fromfile_prefix_chars': '@',
+            'conflict_handler': 'resolve',
+        }
+
+        self.acquire_lock()
+        self.subcommands = {}
+        self.subcommands_default = {}
+        self._subparsers = None
+        self._subparsers_default = None
+        self.argwarn = argcomplete.warn
+        self.args = None
+        self._arg_defaults = argparse.ArgumentParser(**kwargs)
+        self._arg_parser = argparse.ArgumentParser(**kwargs)
+        self.set_defaults = self._arg_parser.set_defaults
+        self.print_usage = self._arg_parser.print_usage
+        self.print_help = self._arg_parser.print_help
+        self.release_lock()
+
+    def completer(self, completer):
+        """Add an arpcomplete completer to this subcommand.
+        """
+        self._arg_parser.completer = completer
+
+    def add_argument(self, *args, **kwargs):
+        """Wrapper to add arguments to both the main and the shadow argparser.
+        """
+        if kwargs.get('add_dest', True) and args[0][0] == '-':
+            kwargs['dest'] = 'general_' + self.get_argument_name(*args, **kwargs)
+        if 'add_dest' in kwargs:
+            del kwargs['add_dest']
+
+        if 'action' in kwargs and kwargs['action'] == 'store_boolean':
+            return handle_store_boolean(self, *args, **kwargs)
+
+        self.acquire_lock()
+        self._arg_parser.add_argument(*args, **kwargs)
+
+        # Populate the shadow parser
+        if 'default' in kwargs:
+            del kwargs['default']
+        if 'action' in kwargs and kwargs['action'] == 'store_false':
+            kwargs['action'] == 'store_true'
+        self._arg_defaults.add_argument(*args, **kwargs)
+        self.release_lock()
+
+    def initialize_logging(self):
+        """Prepare the defaults for the logging infrastructure.
+        """
+        self.acquire_lock()
+        self.log_file = None
+        self.log_file_mode = 'a'
+        self.log_file_handler = None
+        self.log_print = True
+        self.log_print_to = sys.stderr
+        self.log_print_level = logging.INFO
+        self.log_file_level = logging.DEBUG
+        self.log_level = logging.INFO
+        self.log = logging.getLogger(self.__class__.__name__)
+        self.log.setLevel(logging.DEBUG)
+        logging.root.setLevel(logging.DEBUG)
+        self.release_lock()
+
+        self.add_argument('-V', '--version', version=self.version, action='version', help='Display the version and exit')
+        self.add_argument('-v', '--verbose', action='store_true', help='Make the logging more verbose')
+        self.add_argument('--datetime-fmt', default='%Y-%m-%d %H:%M:%S', help='Format string for datetimes')
+        self.add_argument('--log-fmt', default='%(levelname)s %(message)s', help='Format string for printed log output')
+        self.add_argument('--log-file-fmt', default='[%(levelname)s] [%(asctime)s] [file:%(pathname)s] [line:%(lineno)d] %(message)s', help='Format string for log file.')
+        self.add_argument('--log-file', help='File to write log messages to')
+        self.add_argument('--color', action='store_boolean', default=True, help='color in output')
+        self.add_argument('-c', '--config-file', help='The config file to read and/or write')
+        self.add_argument('--save-config', action='store_true', help='Save the running configuration to the config file')
+
+    def add_subparsers(self, title='Sub-commands', **kwargs):
+        if self._inside_context_manager:
+            raise RuntimeError('You must run this before the with statement!')
+
+        self.acquire_lock()
+        self._subparsers_default = self._arg_defaults.add_subparsers(title=title, dest='subparsers', **kwargs)
+        self._subparsers = self._arg_parser.add_subparsers(title=title, dest='subparsers', **kwargs)
+        self.release_lock()
+
+    def acquire_lock(self):
+        """Acquire the MILC lock for exclusive access to properties.
+        """
+        if self._lock:
+            self._lock.acquire()
+
+    def release_lock(self):
+        """Release the MILC lock.
+        """
+        if self._lock:
+            self._lock.release()
+
+    def find_config_file(self):
+        """Locate the config file.
+        """
+        if self.config_file:
+            return self.config_file
+
+        if self.args and self.args.general_config_file:
+            return self.args.general_config_file
+
+        return os.path.abspath(os.path.expanduser('~/.%s.ini' % self.prog_name))
+
+    def get_argument_name(self, *args, **kwargs):
+        """Takes argparse arguments and returns the dest name.
+        """
+        try:
+            return self._arg_parser._get_optional_kwargs(*args, **kwargs)['dest']
+        except ValueError:
+            return self._arg_parser._get_positional_kwargs(*args, **kwargs)['dest']
+
+    def argument(self, *args, **kwargs):
+        """Decorator to call self.add_argument or self.<subcommand>.add_argument.
+        """
+        if self._inside_context_manager:
+            raise RuntimeError('You must run this before the with statement!')
+
+        def argument_function(handler):
+            if handler is self._entrypoint:
+                self.add_argument(*args, **kwargs)
+
+            elif handler.__name__ in self.subcommands:
+                self.subcommands[handler.__name__].add_argument(*args, **kwargs)
+
+            else:
+                raise RuntimeError('Decorated function is not entrypoint or subcommand!')
+
+            return handler
+
+        return argument_function
+
+    def arg_passed(self, arg):
+        """Returns True if arg was passed on the command line.
+        """
+        return self.args_passed[arg] in (None, False)
+
+    def parse_args(self):
+        """Parse the CLI args.
+        """
+        if self.args:
+            self.log.debug('Warning: Arguments have already been parsed, ignoring duplicate attempt!')
+            return
+
+        argcomplete.autocomplete(self._arg_parser)
+
+        self.acquire_lock()
+        self.args = self._arg_parser.parse_args()
+        self.args_passed = self._arg_defaults.parse_args()
+
+        if 'entrypoint' in self.args:
+            self._entrypoint = self.args.entrypoint
+
+        if self.args.general_config_file:
+            self.config_file = self.args.general_config_file
+
+        self.release_lock()
+
+    def read_config(self):
+        """Parse the configuration file and determine the runtime configuration.
+        """
+        self.acquire_lock()
+        self.config_file = self.find_config_file()
+
+        if self.config_file and os.path.exists(self.config_file):
+            config = RawConfigParser(self.config)
+            config.read(self.config_file)
+
+            # Iterate over the config file options and write them into self.config
+            for section in config.sections():
+                for option in config.options(section):
+                    value = config.get(section, option)
+
+                    # Coerce values into useful datatypes
+                    if value.lower() in ['1', 'yes', 'true', 'on']:
+                        value = True
+                    elif value.lower() in ['0', 'no', 'false', 'none', 'off']:
+                        value = False
+                    elif value.replace('.', '').isdigit():
+                        if '.' in value:
+                            value = Decimal(value)
+                        else:
+                            value = int(value)
+
+                    self.config[section][option] = value
+
+        # Fold the CLI args into self.config
+        for argument in vars(self.args):
+            if argument in ('subparsers', 'entrypoint'):
+                continue
+
+            if '_' not in argument:
+                continue
+
+            section, option = argument.split('_', 1)
+            if hasattr(self.args_passed, argument):
+                self.config[section][option] = getattr(self.args, argument)
+            else:
+                if option not in self.config[section]:
+                    self.config[section][option] = getattr(self.args, argument)
+
+        self.release_lock()
+
+    def save_config(self):
+        """Save the current configuration to the config file.
+        """
+        self.log.debug("Saving config file to '%s'", self.config_file)
+
+        if not self.config_file:
+            self.log.warning('%s.config_file file not set, not saving config!', self.__class__.__name__)
+            return
+
+        self.acquire_lock()
+
+        config = RawConfigParser()
+        for section_name, section in self.config._config.items():
+            config.add_section(section_name)
+            for option_name, value in section.items():
+                if section_name == 'general':
+                    if option_name in ['save_config']:
+                        continue
+                config.set(section_name, option_name, str(value))
+
+        with NamedTemporaryFile(mode='w', dir=os.path.dirname(self.config_file), delete=False) as tmpfile:
+            config.write(tmpfile)
+
+        # Move the new config file into place atomically
+        if os.path.getsize(tmpfile.name) > 0:
+            os.rename(tmpfile.name, self.config_file)
+        else:
+            self.log.warning('Config file saving failed, not replacing %s with %s.', self.config_file, tmpfile.name)
+
+        self.release_lock()
+
+    def __call__(self):
+        """Execute the entrypoint function.
+        """
+        if not self._inside_context_manager:
+            # If they didn't use the context manager use it ourselves
+            with self:
+                self.__call__()
+                return
+
+        if not self._entrypoint:
+            raise RuntimeError('No entrypoint provided!')
+
+        return self._entrypoint(self)
+
+    def entrypoint(self, description):
+        """Set the entrypoint for when no subcommand is provided.
+        """
+        if self._inside_context_manager:
+            raise RuntimeError('You must run this before cli()!')
+
+        self.acquire_lock()
+        self.description = description
+        self.release_lock()
+
+        def entrypoint_func(handler):
+            self.acquire_lock()
+            self._entrypoint = handler
+            self.release_lock()
+
+            return handler
+
+        return entrypoint_func
+
+    def add_subcommand(self, handler, description, name=None, **kwargs):
+        """Register a subcommand.
+
+        If name is not provided we use `handler.__name__`.
+        """
+        if self._inside_context_manager:
+            raise RuntimeError('You must run this before the with statement!')
+
+        if self._subparsers is None:
+            self.add_subparsers()
+
+        if not name:
+            name = handler.__name__
+
+        self.acquire_lock()
+        kwargs['help'] = description
+        self.subcommands_default[name] = self._subparsers_default.add_parser(name, **kwargs)
+        self.subcommands[name] = SubparserWrapper(self, name, self._subparsers.add_parser(name, **kwargs))
+        self.subcommands[name].set_defaults(entrypoint=handler)
+
+        if name not in self.__dict__:
+            self.__dict__[name] = self.subcommands[name]
+        else:
+            self.log.debug("Could not add subcommand '%s' to attributes, key already exists!", name)
+
+        self.release_lock()
+
+        return handler
+
+    def subcommand(self, description, **kwargs):
+        """Decorator to register a subcommand.
+        """
+
+        def subcommand_function(handler):
+            return self.add_subcommand(handler, description, **kwargs)
+
+        return subcommand_function
+
+    def setup_logging(self):
+        """Called by __enter__() to setup the logging configuration.
+        """
+        if len(logging.root.handlers) != 0:
+            # This is not a design decision. This is what I'm doing for now until I can examine and think about this situation in more detail.
+            raise RuntimeError('MILC should be the only system installing root log handlers!')
+
+        self.acquire_lock()
+
+        if self.config['general']['verbose']:
+            self.log_print_level = logging.DEBUG
+
+        self.log_file = self.config['general']['log_file'] or self.log_file
+        self.log_file_format = self.config['general']['log_file_fmt']
+        self.log_file_format = ANSIStrippingFormatter(self.config['general']['log_file_fmt'], self.config['general']['datetime_fmt'])
+        self.log_format = self.config['general']['log_fmt']
+
+        if self.config.general.color:
+            self.log_format = ANSIEmojiLoglevelFormatter(self.args.general_log_fmt, self.config.general.datetime_fmt)
+        else:
+            self.log_format = ANSIStrippingFormatter(self.args.general_log_fmt, self.config.general.datetime_fmt)
+
+        if self.log_file:
+            self.log_file_handler = logging.FileHandler(self.log_file, self.log_file_mode)
+            self.log_file_handler.setLevel(self.log_file_level)
+            self.log_file_handler.setFormatter(self.log_file_format)
+            logging.root.addHandler(self.log_file_handler)
+
+        if self.log_print:
+            self.log_print_handler = logging.StreamHandler(self.log_print_to)
+            self.log_print_handler.setLevel(self.log_print_level)
+            self.log_print_handler.setFormatter(self.log_format)
+            logging.root.addHandler(self.log_print_handler)
+
+        self.release_lock()
+
+    def __enter__(self):
+        if self._inside_context_manager:
+            self.log.debug('Warning: context manager was entered again. This usually means that self.__call__() was called before the with statement. You probably do not want to do that.')
+            return
+
+        self.acquire_lock()
+        self._inside_context_manager = True
+        self.release_lock()
+
+        colorama.init()
+        self.parse_args()
+        self.read_config()
+        self.setup_logging()
+
+        if self.config.general.save_config:
+            self.save_config()
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.acquire_lock()
+        self._inside_context_manager = False
+        self.release_lock()
+
+        if exc_type is not None and not isinstance(SystemExit(), exc_type):
+            print(exc_type)
+            logging.exception(exc_val)
+            exit(255)
+
+
+cli = MILC()
+
+if __name__ == '__main__':
+
+    @cli.argument('-c', '--comma', help='comma in output', default=True, action='store_boolean')
+    @cli.entrypoint('My useful CLI tool with subcommands.')
+    def main(cli):
+        comma = ',' if cli.config.general.comma else ''
+        cli.log.info('{bg_green}{fg_red}Hello%s World!', comma)
+
+    @cli.argument('-n', '--name', help='Name to greet', default='World')
+    @cli.subcommand('Description of hello subcommand here.')
+    def hello(cli):
+        comma = ',' if cli.config.general.comma else ''
+        cli.log.info('{fg_blue}Hello%s %s!', comma, cli.config.hello.name)
+
+    def goodbye(cli):
+        comma = ',' if cli.config.general.comma else ''
+        cli.log.info('{bg_red}Goodbye%s %s!', comma, cli.config.goodbye.name)
+
+    @cli.argument('-n', '--name', help='Name to greet', default='World')
+    @cli.subcommand('Think a bit before greeting the user.')
+    def thinking(cli):
+        comma = ',' if cli.config.general.comma else ''
+        spinner = cli.spinner(text='Just a moment...', spinner='earth')
+        spinner.start()
+        sleep(2)
+        spinner.stop()
+
+        with cli.spinner(text='Almost there!', spinner='moon'):
+            sleep(2)
+
+        cli.log.info('{fg_cyan}Hello%s %s!', comma, cli.config.thinking.name)
+
+    @cli.subcommand('Show off our ANSI colors.')
+    def pride(cli):
+        cli.echo('{bg_red}                    ')
+        cli.echo('{bg_lightred_ex}                    ')
+        cli.echo('{bg_lightyellow_ex}                    ')
+        cli.echo('{bg_green}                    ')
+        cli.echo('{bg_blue}                    ')
+        cli.echo('{bg_magenta}                    ')
+
+    # You can register subcommands using decorators as seen above, or using functions like like this:
+    cli.add_subcommand(goodbye, 'This will show up in --help output.')
+    cli.goodbye.add_argument('-n', '--name', help='Name to bid farewell to', default='World')
+
+    cli()  # Automatically picks between main(), hello() and goodbye()
+    print(sorted(ansi_colors.keys()))