Add One Shot Key callbacks (#4697)

* Added callbacks to one shot modifier changes

* Altered signature of callback functions

* Reordered the callback methods, shortened brief documentation

* Added One Shot Modifier callback documentation

* First attempt at unit tests

* Revert "First attempt at unit tests"

This reverts commit 5ec21a782202c0d74cf21cb852bd319f0c8b4842.

* Simplified oneshot function implementations

* Made clear_oneshot_locked_mods to be conform action_util.h, adhering to the (void) signature

* Made used datatypes for oneshot mods consistently unsigned integers

* Corrected callback to call clear callback when clear_oneshot_locked_mods is invoked

* Simplified oneshot equals statements

* Corrected return type and signature of get and set oneshot locked mods

* Consolidated one shot callbacks, added initial layer callback version

* Fixed non-updating one shot layer variable after timeout or other clear, added code comments

* Added better one shot key docs

docs/feature_advanced_keycodes.md

@@ -161,6 +161,81 @@ For one shot mods, you need to call `set_oneshot_mods(MOD)` to set it, or `clear
 
 !> If you're having issues with OSM translating over Remote Desktop Connection, this can be fixed by opening the settings, going to the "Local Resources" tap, and in the keyboard section, change the drop down to "On this Computer".  This will fix the issue and allow OSM to function properly over Remote Desktop.
 
+## Callbacks
+
+When you'd like to perform custom logic when pressing a one shot key, there are several callbacks you can choose to implement. You could indicate changes in one shot keys by flashing an LED or making a sound, for example.
+
+There is a callback for `OSM(mod)`. It is called whenever the state of any one shot modifier key is changed: when it toggles on, but also when it is toggled off. You can use it like this:
+
+```c
+void oneshot_mods_changed_user(uint8_t mods) {
+  if (mods & MOD_MASK_SHIFT) {
+    println("Oneshot mods SHIFT");
+  }
+  if (mods & MOD_MASK_CTRL) {
+    println("Oneshot mods CTRL");
+  }
+  if (mods & MOD_MASK_ALT) {
+    println("Oneshot mods ALT");
+  }
+  if (mods & MOD_MASK_GUI) {
+    println("Oneshot mods GUI");
+  }
+  if (!mods) {
+    println("Oneshot mods off");
+  }
+}
+```
+
+The `mods` argument contains the active mods after the change, so it reflects the current state.
+
+When you use One Shot Tap Toggle (by adding `#define ONESHOT_TAP_TOGGLE 2` in your `config.h` file), you may lock a modifier key by pressing it the specified amount of times. There's a callback for that, too:
+
+```c
+void oneshot_locked_mods_changed_user(uint8_t mods) {
+  if (mods & MOD_MASK_SHIFT) {
+    println("Oneshot locked mods SHIFT");
+  }
+  if (mods & MOD_MASK_CTRL) {
+    println("Oneshot locked mods CTRL");
+  }
+  if (mods & MOD_MASK_ALT) {
+    println("Oneshot locked mods ALT");
+  }
+  if (mods & MOD_MASK_GUI) {
+    println("Oneshot locked mods GUI");
+  }
+  if (!mods) {
+    println("Oneshot locked mods off");
+  }
+}
+```
+
+Last, there is also a callback for the `OSL(layer)` one shot key:
+
+```c
+void oneshot_layer_changed_user(uint8_t layer) {
+  if (layer == 1) {
+    println("Oneshot layer 1 on");
+  }
+  if (!layer) {
+    println("Oneshot layer off");
+  }
+}
+```
+
+If any one shot layer is switched off, `layer` will be zero. When you're looking to do something on any layer change instead of one shot layer changes, `layer_state_set_user` is a better callback to use.
+
+If you are making your own keyboard, there are also `_kb` equivalent functions:
+
+```c
+void oneshot_locked_mods_changed_kb(uint8_t mods);
+void oneshot_mods_changed_kb(uint8_t mods);
+void oneshot_layer_changed_kb(uint8_t layer);
+```
+
+As with any callback, be sure to call the `_user` variant to allow for further customizability.
+
 # Tap-Hold Configuration Options
 
 While Tap-Hold options are fantastic, they are not without their issues.  We have tried to configure them with reasonal defaults, but that may still cause issues for some people. 

keyboards/honeycomb/config.h

@@ -0,0 +1,65 @@
+/*
+Copyright 2019 @filoxo
+
+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      0xACC8
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    Keyhive
+#define PRODUCT         Honeycomb Macropad
+#define DESCRIPTION     QMK firmware for Honeycomb Macropad
+
+/* key matrix size */
+#define MATRIX_ROWS 1
+#define MATRIX_COLS 16
+
+#define ONESHOT_TIMEOUT 500
+
+/* 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
+
+//UART settings for communication with the RF microcontroller
+#define SERIAL_UART_BAUD 1000000
+#define SERIAL_UART_DATA UDR1
+#define SERIAL_UART_UBRR (F_CPU / (16UL * SERIAL_UART_BAUD) - 1)
+#define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1))
+#define SERIAL_UART_RXD_PRESENT (UCSR1A & _BV(RXC1))
+#define SERIAL_UART_INIT() do { \
+  /* baud rate */ \
+  UBRR1L = SERIAL_UART_UBRR; \
+  /* baud rate */ \
+  UBRR1H = SERIAL_UART_UBRR >> 8; \
+  /* enable TX and RX */ \
+  UCSR1B = _BV(TXEN1) | _BV(RXEN1); \
+  /* 8-bit data */ \
+  UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
+} while(0)

keyboards/honeycomb/honeycomb.c

@@ -0,0 +1,92 @@
+#include "honeycomb.h"
+#include "pointing_device.h"
+#include "report.h"
+
+void uart_init(void) {
+	SERIAL_UART_INIT();
+}
+
+void pointing_device_task(void){
+	/*report_mouse_t currentReport = {};
+    SERIAL_UART_INIT();
+    uint32_t timeout = 0;
+
+    //the m character requests the RF slave to send the mouse report
+    SERIAL_UART_DATA = 'm';
+
+    //trust the external inputs completely, erase old data
+    uint8_t uart_data[5] = {0};
+
+    //there are 10 bytes corresponding to 10 columns, and an end byte
+    for (uint8_t i = 0; i < 5; i++) {
+        //wait for the serial data, timeout if it's been too long
+        //this only happened in testing with a loose wire, but does no
+        //harm to leave it in here
+        while(!SERIAL_UART_RXD_PRESENT){
+            timeout++;
+            if (timeout > 10000){
+		xprintf("\r\nTIMED OUT");
+                break;
+            }
+        }
+	xprintf("\r\nGOT DATA for %d",i);
+        uart_data[i] = SERIAL_UART_DATA;
+    }
+
+    //check for the end packet, bytes 1-4 are movement and scroll
+    //but byte 5 has bits 0-3 for the scroll button state
+	//(1000 if pressed, 0000 if not) and bits 4-7 are always 1
+	//We can use this to verify the report sent properly.
+    if (uart_data[4] == 0x0F || uart_data[4] == 0x8F)
+    {
+	xprintf("\r\nREQUESTED MOUSE, RECEIVED %i, %i, %i, %i, %i",uart_data[0],uart_data[1],uart_data[2],uart_data[3],uart_data[4]);
+		currentReport = pointing_device_get_report();
+        //shifting and transferring the info to the mouse report varaible
+        //mouseReport.x = 127 max -127 min
+		currentReport.x = (int8_t) uart_data[0];
+        //mouseReport.y = 127 max -127 min
+		currentReport.y = (int8_t) uart_data[1];
+        //mouseReport.v = 127 max -127 min (scroll vertical)
+		currentReport.v = (int8_t) uart_data[2];
+        //mouseReport.h = 127 max -127 min (scroll horizontal)
+		currentReport.h = (int8_t) uart_data[3];
+        //mouseReport.buttons = 0x31 max (bitmask for mouse buttons 1-5) 0x00 min
+		//mouse buttons 1 and 2 are handled by the keymap, but not 3
+		if (uart_data[4] == 0x0F) { //then 3 is not pressed
+			currentReport.buttons &= ~MOUSE_BTN3; //MOUSE_BTN3 is def in report.h
+		} else { //3 must be pressed
+			currentReport.buttons |= MOUSE_BTN3;
+		}
+		pointing_device_set_report(currentReport);
+    } else {
+	xprintf("\r\nRequested packet, data 4 was %d",uart_data[4]);
+    }*/
+    pointing_device_send();
+}
+
+void led_init(void) {
+  setPinOutput(D1);
+  writePinHigh(D1);
+  setPinOutput(F4);
+  writePinHigh(F4);
+  setPinOutput(F5);
+  writePinHigh(F5);
+}
+
+void matrix_init_kb(void) {
+	// put your keyboard start-up code here
+	// runs once when the firmware starts up
+	matrix_init_user();
+	uart_init();
+	led_init();
+}
+
+void matrix_scan_kb(void) {
+	// put your looping keyboard code here
+	// runs every cycle (a lot)
+	matrix_scan_user();
+}
+
+void led_set_kb(uint8_t usb_led) {
+
+}

keyboards/honeycomb/honeycomb.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#define HONEYCOMB_H
+
+#include "quantum.h"
+#include "matrix.h"
+#include "backlight.h"
+#include <stddef.h>
+
+#define RED_LED_OFF() writePinHigh(F6)
+#define RED_LED_ON()  writePinLow(F6)
+#define BLU_LED_OFF() writePinHigh(F5)
+#define BLU_LED_ON()  writePinLow(F5)
+#define GRN_LED_OFF() writePinHigh(D1)
+#define GRN_LED_ON()  writePinLow(D1)
+
+#define SET_LED_OFF     (RED_LED_OFF(); GRN_LED_OFF(); BLU_LED_OFF(); )
+#define SET_LED_RED     (RED_LED_ON();  GRN_LED_OFF(); BLU_LED_OFF(); )
+#define SET_LED_BLUE    (RED_LED_OFF(); GRN_LED_OFF(); BLU_LED_ON(); )
+#define SET_LED_GREEN   (RED_LED_OFF(); GRN_LED_ON();  BLU_LED_OFF(); )
+#define SET_LED_YELLOW  (RED_LED_ON();  GRN_LED_ON();  BLU_LED_OFF(); )
+#define SET_LED_MAGENTA (RED_LED_ON();  GRN_LED_OFF(); BLU_LED_ON(); )
+#define SET_LED_CYAN    (RED_LED_OFF(); GRN_LED_ON();  BLU_LED_ON(); )
+#define SET_LED_WHITE   (RED_LED_ON();  GRN_LED_ON();  BLU_LED_ON(); )
+
+// This a shortcut to help you visually see your layout.
+// The first section contains all of the arguements
+// The second converts the arguments into a two-dimensional array
+#define LAYOUT( \
+  k13, k14, k15, k16, \
+  k09, k10, k11, k12, \
+  k05, k06, k07, k08, \
+  k01, k02, k03, k04  \
+) \
+{ \
+	{ k01, k02, k03, k04, k05, k06, k07, k08, k09, k10, k11, k12, k13, k14, k15, k16 } \
+}

keyboards/honeycomb/keymaps/default/keymap.c

@@ -0,0 +1,91 @@
+#include QMK_KEYBOARD_H
+
+// 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 honeycomb_layers {
+	_BS,
+	_EN
+};
+
+// Macro definitions for readability
+enum honeycomb_keycodes {
+	HW = SAFE_RANGE,
+	COPY,
+	PASTA
+};
+
+extern int8_t encoderValue;
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[_BS] = LAYOUT( /* Base layout, put whatever defaults. */
+		HW,      COPY,    PASTA,   KC_MUTE,
+		KC_4,    KC_5,    KC_6,    KC_7,
+    KC_8,    KC_9,    KC_A,    KC_B,
+		KC_C,    KC_D,    KC_E,    KC_F
+	),
+
+	[_EN] = LAYOUT( /* Alternate layer */
+		_______, _______, _______, _______,
+		_______, _______, _______, _______,
+		_______, _______, _______, _______,
+		_______, _______, _______, _______
+	)
+};
+
+report_mouse_t currentReport = {};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	//uint8_t layer = biton32(layer_state);  // get the current layer
+
+	// Basic example functions
+	switch (keycode) {
+		case HW:
+			if (record->event.pressed) {
+					SEND_STRING("Hello, world!");
+				} else {
+					SEND_STRING("Goodbye, cruel world!");
+				}
+			break;
+			case COPY:
+				if (record->event.pressed) {
+					tap_code16(LCTL(KC_C)); // Replace with tap_code16(LCMD(KC_C)) to enable for Mac
+				}
+			break;
+			case PASTA:
+				if (record->event.pressed) {
+					tap_code16(LCTL(KC_V)); // Replace with tap_code16(LCMD(KC_V)) to enable for Mac
+				}
+			break;
+		return false;
+	}
+	return true;
+};
+
+void matrix_scan_user(void) {
+	/* Leaving some LED stuff in here in comment form so you can see how to use it.
+    if (shiftLED || capsLED){
+		red_led_on;
+    } else {
+		red_led_off;
+    }
+    if (numLED){
+		grn_led_on;
+    } else {
+		grn_led_off;
+    }
+    if (mouseLED){
+		blu_led_on;
+    } else {
+		blu_led_off;
+	}*/
+	while (encoderValue < 0){
+		tap_code(KC_VOLD);
+		encoderValue++;
+	}
+	while (encoderValue > 0){
+		tap_code(KC_VOLU);
+		encoderValue--;
+	}
+};

keyboards/honeycomb/matrix.c

@@ -0,0 +1,202 @@
+/*
+Copyright 2012 Jun Wako
+Copyright 2014 Jack Humbert
+Copyright 2019 @filoxo
+
+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>
+#if defined(__AVR__)
+#include <avr/io.h>
+#endif
+#include "wait.h"
+#include "print.h"
+#include "debug.h"
+#include "util.h"
+#include "matrix.h"
+#include "timer.h"
+#include "honeycomb.h"
+#include "pointing_device.h"
+#include "report.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
+
+/* matrix state(1:on, 0:off) */
+static matrix_row_t matrix[MATRIX_ROWS];
+//extern int8_t encoderValue;
+int8_t encoderValue = 0;
+
+__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;
+}
+
+void matrix_init(void) {
+
+    matrix_init_quantum();
+}
+
+uint8_t matrix_scan(void)
+{
+    SERIAL_UART_INIT();
+
+    uint32_t timeout = 0;
+
+    // The 's' character requests the RF slave to send the matrix
+    SERIAL_UART_DATA = 's';
+
+    // Trust the external keystates entirely, erase the last data
+    uint8_t uart_data[4] = {0};
+
+    // There are 3 bytes corresponding to the data, and a checksum
+    for (uint8_t i = 0; i < 4; i++) {
+        // Wait for the serial data, timeout if it's been too long
+        // This only happened in testing with a loose wire, but does no
+        // harm to leave it in here
+        while(!SERIAL_UART_RXD_PRESENT){
+            timeout++;
+            if (timeout > 10000){
+                xprintf("\r\nTime out in keyboard.");
+                break;
+            }
+        }
+        uart_data[i] = SERIAL_UART_DATA;
+    }
+
+    // Check for the end packet, it's our checksum.
+    // Will only be a match if the correct bytes were recieved
+    if (uart_data[3] == (uart_data[0] ^ uart_data[1] ^ uart_data[2])) { // This is an arbitrary checksum calculated by XORing all the data.
+        // Transferring the keystates to the QMK matrix variable
+		/* ASSUMING MSB FIRST */
+		matrix[0] = ((uint16_t) uart_data[0] << 8) | ((uint16_t) uart_data[1]);
+		encoderValue += (int8_t) uart_data[2];
+		if ((uart_data[0] | uart_data[1] | uart_data[2])!=0){
+			xprintf("\r\n0x%0X%02X%02X",uart_data[0],uart_data[1], uart_data[2]);
+		}
+		/* OK, TURNS OUT THAT WAS A BAD ASSUMPTION */
+        for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+			// I've unpacked these into the mirror image of what QMK expects them to be, so...
+			matrix[i] = bitrev16(matrix[i]);
+			// So I'll reverse it, and this should be fine now.
+        }
+
+        // A mouse report for scrolling would go here, but I don't plan on doing scrolling with the encoder. So.
+
+    	report_mouse_t currentReport = {};
+/*
+    	currentReport = pointing_device_get_report();
+            //mouseReport.x = 127 max -127 min
+    	currentReport.x = (int8_t) uart_data[6];
+            //mouseReport.y = 127 max -127 min
+    	currentReport.y = (int8_t) uart_data[7];
+            //mouseReport.v = 127 max -127 min (scroll vertical)
+    	currentReport.v = (int8_t) uart_data[8];
+            //mouseReport.h = 127 max -127 min (scroll horizontal)
+    	currentReport.h = (int8_t) uart_data[9];
+        */
+    	/*
+    	currentReport.x = 0;
+    	currentReport.y = 0;
+    	currentReport.v = 0;
+        currentReport.h = 0;*/
+
+        pointing_device_set_report(currentReport);
+    } else {
+        xprintf("\r\nRequested packet, data 3 was %d",uart_data[3]);
+    }
+
+    matrix_scan_quantum();
+    return 1;
+}
+
+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)
+{
+    return matrix[row];
+}
+
+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;
+}

keyboards/honeycomb/readme.md

@@ -0,0 +1,20 @@
+Honeycomb Keyboard Firmware
+======================
+
+These configuration files use a completely different 'matrix scan' system than other keyboards, it relies on an external nRF51822 microcontroller maintaining a matrix of keystates received from the macropad - it also receives rotary encoder information from the macropad. The matrix.c file contains the code to poll the external microcontroller for the key matrix, and the keymap.c file contains example code for encoder use. As long as the relevant functions in these files are not changed, all other QMK features are supported.
+
+## Building
+
+Run the following command in your terminal:
+
+```
+make honeycomb:default
+# or use this to automatically flash the controller
+make honeycomb:default:avrdude
+```
+
+Follow the QMK guide for this or ask in Discord.
+
+### Other Keymaps
+
+Because this is a totally custom macropad, it is recommended that you copy the `default/` folder, rename it as desired, and modify the `keymap.c` to your liking.

keyboards/honeycomb/rules.mk

@@ -0,0 +1,68 @@
+# # project specific files
+SRC += matrix.c
+
+
+# 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)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+BOOTLOADER = caterina
+
+# Build Options
+#   comment out to disable the options.
+#
+#BOOTMAGIC_ENABLE = yes	# Virtual DIP switch configuration(+1000)
+#MOUSEKEY_ENABLE = yes	# Mouse keys(+4700)
+POINTING_DEVICE_ENABLE = yes # Generic Pointer, not as big as mouse keys hopefully.
+EXTRAKEY_ENABLE = yes	# Audio control and System control(+450)
+CONSOLE_ENABLE = yes	# Console for debug(+400)
+COMMAND_ENABLE = yes   # Commands for debug and configuration
+CUSTOM_MATRIX = yes    # Remote matrix from the wireless bridge
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+# SLEEP_LED_ENABLE = yes  # Breathing sleep LED during USB suspend
+NKRO_ENABLE = yes		# USB Nkey Rollover - not yet supported in LUFA
+# BACKLIGHT_ENABLE = yes  # Enable keyboard backlight functionality
+# MIDI_ENABLE = YES 		# MIDI controls
+UNICODE_ENABLE = YES 		# Unicode
+# BLUETOOTH_ENABLE = yes # Enable Bluetooth with the Adafruit EZ-Key HID
+
+USB = /dev/ttyACM0
+
+#upload: build
+#	$(honeycomb_UPLOAD_COMMAND)

keyboards/jj4x4/README.md

@@ -0,0 +1,71 @@
+# jj4x4
+
+![jj4x4](https://cdn.shopify.com/s/files/1/2711/4238/products/JJ4x4case-1_1024x1024.jpg?v=1532325339)
+
+A  4x4 keypad kit made and KPRepublic on AliExpress. This is a chopped off version of the jj40 with rearranged keys.
+
+Keyboard Maintainer: [QMK Community](https://github.com/qmk)  
+Hardware Supported: Atmega32A  
+Hardware Availability: [AliExpress](https://www.aliexpress.com/item/jj4x4-jj4X4-16-keys-Custom-Mechanical-Keyboard-PCB-programmed-numpad-layouts-bface-firmware-with-rgb-bottom/32901955446.html?spm=2114.search0104.3.7.3ebf431ae1d9ic&ws_ab_test=searchweb0_0,searchweb201602_4_10065_10130_10068_10547_319_317_10548_10545_10696_453_10084_454_10083_433_10618_431_10307_537_536_10902_10059_10884_10887_321_322_10103,searchweb201603_6,ppcSwitch_0&algo_expid=9d1891dd-80af-4793-a889-5a62e1fdfdd8-1&algo_pvid=9d1891dd-80af-4793-a889-5a62e1fdfdd8&transAbTest=ae803_5)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make jj4x4:default:program
+
+See [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) then the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information.
+
+Note that this is a complete replacement for the firmware, so you won't be
+using Bootmapper Client to change any keyboard settings, since not all the
+USB report options are supported.
+
+In addition you may need the AVR toolchain and `bootloadHID` ([GitHub repo](https://github.com/whiteneon/bootloadHID)) for flashing:
+
+For macOS:
+```
+$ brew cask install crosspack-avr
+$ brew install --HEAD https://raw.githubusercontent.com/robertgzr/homebrew-tap/master/bootloadhid.rb
+```
+
+For Linux:
+```
+$ sudo apt install libusb-dev
+$ wget https://www.obdev.at/downloads/vusb/bootloadHID.2012-12-08.tar.gz
+$ tar -xzf bootloadHID.2012-12-08.tar.gz
+$ cd bootloadHID.2012-12-08/commandline
+$ make
+$ sudo cp bootloadHID /usr/bin
+```
+
+In order to use the `./program` script, which can reboot the board into
+the bootloader, you'll need Python 2 with PyUSB installed:
+
+```
+$ pip install pyusb
+```
+
+If you prefer (or are having issues with a `program` flash), you can just build it (`make jj40:<keymap-name>` and flash the firmware (`.hex` file) directly with
+`bootloadHID` if you boot the board while holding down `8` (second from top, second from left, with usb plug is at the top) to keep it
+in the bootloader:
+
+```
+$ make jj40
+$ bootloadHID -r jj4x4_default.hex
+```
+
+For Windows 10:
+Windows sometimes doesn't recognize the jj4x4. The easiest way of flashing a new layout is probably using [HIDBootFlash](http://vusb.wikidot.com/project:hidbootflash).
+1. Go to Windows Device Manager and find the keyboard (plug it in while holding down `8` (second from top, second from left, with usb plug is at the top)). It can be found under Human Interface Devices or under Keyboards.
+2. Go to properties and the Details tab to find the hardware ID. You want the VID and the PID (code after the underscore). Plug them into HIDBootFlash and hit Find Device.
+3. Use `make jj4x4:<keymap-name>` to generate the .hex file in the qmk basis folder. Select the .hex file in HIDBootFlash and press Flash Device.
+
+
+## Troubleshooting
+
+1. Try plugging the board in while pressing `8` (usb plug at top, second from top, second from left). This will force it
+   to boot only the bootloader without loading the firmware. Once this is
+   done, just reflash the board with the original firmware.
+2. Sometimes USB hubs can act weird, so try connecting the board directly
+   to your computer or plugging/unplugging the USB hub.
+3. If you get an error such as "Resource Unavailable" when attemting to flash
+   on Linux, you may want to compile and run `tools/usb_detach.c`. See `tools/README.md`
+   for more info.

keyboards/jj4x4/backlight.c

@@ -0,0 +1,213 @@
+/**
+ * Backlighting code for PS2AVRGB boards (ATMEGA32A)
+ * Kenneth A. (github.com/krusli | krusli.me)
+ */
+
+#include "backlight.h"
+#include "quantum.h"
+
+#include <avr/pgmspace.h>
+#include <avr/interrupt.h>
+
+#include "backlight_custom.h"
+#include "breathing_custom.h"
+
+// DEBUG
+#include <stdlib.h>
+#include <stdio.h>
+
+// Port D: digital pins of the AVR chipset
+#define NUMLOCK_PORT    (1 << 0)  // D0
+#define CAPSLOCK_PORT   (1 << 1)  // D1
+#define BACKLIGHT_PORT  (1 << 4)  // D4
+#define SCROLLLOCK_PORT (1 << 6)  // D6
+
+#define TIMER_CLK_DIV64			  0x03	///< Timer clocked at F_CPU/64
+#define TIMER1PRESCALE	TIMER_CLK_DIV64 ///< timer 1 prescaler default
+
+#define TIMER_PRESCALE_MASK		0x07	///< Timer Prescaler Bit-Mask
+
+#define PWM_MAX 0xFF
+#define TIMER_TOP 255 // 8 bit PWM
+
+extern backlight_config_t backlight_config;
+
+/**
+ * References
+ * Port Registers: https://www.arduino.cc/en/Reference/PortManipulation
+ * TCCR1A: https://electronics.stackexchange.com/questions/92350/what-is-the-difference-between-tccr1a-and-tccr1b
+ * Timers: http://www.avrbeginners.net/architecture/timers/timers.html
+ * 16-bit timer setup: http://sculland.com/ATmega168/Interrupts-And-Timers/16-Bit-Timer-Setup/
+ * PS2AVRGB firmware: https://github.com/showjean/ps2avrU/tree/master/firmware
+ */
+
+// @Override
+// turn LEDs on and off depending on USB caps/num/scroll lock states.
+__attribute__ ((weak))
+void led_set_user(uint8_t usb_led) {
+    if (usb_led & (1 << USB_LED_NUM_LOCK)) {
+      // turn on
+      DDRD  |= NUMLOCK_PORT;
+      PORTD |= NUMLOCK_PORT;
+    } else {
+      // turn off
+      DDRD  &= ~NUMLOCK_PORT;
+      PORTD &= ~NUMLOCK_PORT;
+    }
+
+    if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
+      DDRD  |= CAPSLOCK_PORT;
+      PORTD |= CAPSLOCK_PORT;
+    } else {
+      DDRD  &= ~CAPSLOCK_PORT;
+      PORTD &= ~CAPSLOCK_PORT;
+    }
+
+    if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
+      DDRD  |= SCROLLLOCK_PORT;
+      PORTD |= SCROLLLOCK_PORT;
+    } else {
+      DDRD  &= ~SCROLLLOCK_PORT;
+      PORTD &= ~SCROLLLOCK_PORT;
+    }
+}
+
+#ifdef BACKLIGHT_ENABLE
+
+// sets up Timer 1 for 8-bit PWM
+void timer1PWMSetup(void) { // NOTE ONLY CALL THIS ONCE
+  // default 8 bit mode
+  TCCR1A &= ~(1 << 1); // cbi(TCCR1A,PWM11); <- set PWM11 bit to HIGH
+  TCCR1A |= (1 << 0);  // sbi(TCCR1A,PWM10); <- set PWM10 bit to LOW
+
+  // clear output compare value A
+  // outb(OCR1AH, 0);
+  // outb(OCR1AL, 0);
+
+  // clear output comparator registers for B
+	OCR1BH = 0; // outb(OCR1BH, 0);
+	OCR1BL = 0; // outb(OCR1BL, 0);
+}
+
+bool is_init = false;
+void timer1Init(void) {
+  // timer1SetPrescaler(TIMER1PRESCALE)
+  // set to DIV/64
+  (TCCR1B) = ((TCCR1B) & ~TIMER_PRESCALE_MASK) | TIMER1PRESCALE;
+
+  // reset TCNT1
+  TCNT1H = 0;  // outb(TCNT1H, 0);
+	TCNT1L = 0;  // outb(TCNT1L, 0);
+
+  // TOIE1: Timer Overflow Interrupt Enable (Timer 1);
+	TIMSK |= _BV(TOIE1); // sbi(TIMSK, TOIE1);
+
+  is_init = true;
+}
+
+void timer1UnInit(void) {
+  // set prescaler back to NONE
+  (TCCR1B) = ((TCCR1B) & ~TIMER_PRESCALE_MASK) | 0x00;  // TIMERRTC_CLK_STOP
+
+  // disable timer overflow interrupt
+  TIMSK &= ~_BV(TOIE1); // overflow bit?
+
+  setPWM(0);
+
+  is_init = false;
+}
+
+
+// handle TCNT1 overflow
+//! Interrupt handler for tcnt1 overflow interrupt
+ISR(TIMER1_OVF_vect, ISR_NOBLOCK)
+{
+	// sei();
+  // handle breathing here
+  #ifdef BACKLIGHT_BREATHING
+  if (is_breathing()) {
+    custom_breathing_handler();
+  }
+  #endif
+
+  // TODO call user defined function
+}
+
+// enable timer 1 PWM
+// timer1PWMBOn()
+void timer1PWMBEnable(void) {
+  // turn on channel B (OC1B) PWM output
+  // set OC1B as non-inverted PWM
+  TCCR1A |= _BV(COM1B1);
+  TCCR1A &= ~_BV(COM1B0);
+}
+
+// disable timer 1 PWM
+// timer1PWMBOff()
+void timer1PWMBDisable(void) {
+  TCCR1A &= ~_BV(COM1B1);
+  TCCR1A &= ~_BV(COM1B0);
+}
+
+void enableBacklight(void) {
+  DDRD  |= BACKLIGHT_PORT;  // set digital pin 4 as output
+  PORTD |= BACKLIGHT_PORT;  // set digital pin 4 to high
+}
+
+void disableBacklight(void) {
+  // DDRD  &= ~BACKLIGHT_PORT;  // set digital pin 4 as input
+  PORTD &= ~BACKLIGHT_PORT;  // set digital pin 4 to low
+}
+
+void startPWM(void) {
+  timer1Init();
+  timer1PWMBEnable();
+  enableBacklight();
+}
+
+void stopPWM(void) {
+  timer1UnInit();
+  disableBacklight();
+  timer1PWMBDisable();
+}
+
+void b_led_init_ports(void) {
+  /* turn backlight on/off depending on user preference */
+  #if BACKLIGHT_ON_STATE == 0
+    // DDRx register: sets the direction of Port D
+    // DDRD  &= ~BACKLIGHT_PORT;  // set digital pin 4 as input
+    PORTD &= ~BACKLIGHT_PORT;  // set digital pin 4 to low
+  #else
+    DDRD  |= BACKLIGHT_PORT;  // set digital pin 4 as output
+    PORTD |= BACKLIGHT_PORT;  // set digital pin 4 to high
+  #endif
+
+  timer1PWMSetup();
+  startPWM();
+
+  #ifdef BACKLIGHT_BREATHING
+  breathing_enable();
+  #endif
+}
+
+void b_led_set(uint8_t level) {
+  if (level > BACKLIGHT_LEVELS) {
+    level = BACKLIGHT_LEVELS;
+  }
+
+  setPWM((int)(TIMER_TOP * (float) level / BACKLIGHT_LEVELS));
+}
+
+// called every matrix scan
+void b_led_task(void) {
+  // do nothing for now
+}
+
+void setPWM(uint16_t xValue) {
+  if (xValue > TIMER_TOP) {
+    xValue = TIMER_TOP;
+  }
+  OCR1B = xValue; // timer1PWMBSet(xValue);
+}
+
+#endif  // BACKLIGHT_ENABLE

keyboards/jj4x4/backlight_custom.h

@@ -0,0 +1,15 @@
+/**
+ * Backlighting code for PS2AVRGB boards (ATMEGA32A)
+ * Kenneth A. (github.com/krusli | krusli.me)
+ */
+
+#ifndef BACKLIGHT_CUSTOM_H
+#define BACKLIGHT_CUSTOM_H
+
+#include <avr/pgmspace.h>
+void b_led_init_ports(void);
+void b_led_set(uint8_t level);
+void b_led_task(void);
+void setPWM(uint16_t xValue);
+
+#endif  // BACKLIGHT_CUSTOM_H

keyboards/jj4x4/breathing_custom.h

@@ -0,0 +1,140 @@
+/**
+ * Breathing effect code for PS2AVRGB boards (ATMEGA32A)
+ * Works in conjunction with `backlight.c`.
+ *
+ * Code adapted from `quantum.c` to register with the existing TIMER1 overflow
+ * handler in `backlight.c` instead of setting up its own timer.
+ * Kenneth A. (github.com/krusli | krusli.me)
+ */
+
+#ifdef BACKLIGHT_ENABLE
+#ifdef BACKLIGHT_BREATHING
+
+#include "backlight_custom.h"
+
+#ifndef BREATHING_PERIOD
+#define BREATHING_PERIOD 6
+#endif
+
+#define breathing_min() do {breathing_counter = 0;} while (0)
+#define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
+
+// TODO make this share code with quantum.c
+
+#define BREATHING_NO_HALT  0
+#define BREATHING_HALT_OFF 1
+#define BREATHING_HALT_ON  2
+#define BREATHING_STEPS 128
+
+static uint8_t breathing_period = BREATHING_PERIOD;
+static uint8_t breathing_halt = BREATHING_NO_HALT;
+static uint16_t breathing_counter = 0;
+
+static bool breathing = false;
+
+bool is_breathing(void) {
+  return breathing;
+}
+
+// See http://jared.geek.nz/2013/feb/linear-led-pwm
+static uint16_t cie_lightness(uint16_t v) {
+  if (v <= 5243) // if below 8% of max
+    return v / 9; // same as dividing by 900%
+  else {
+    uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
+    // to get a useful result with integer division, we shift left in the expression above
+    // and revert what we've done again after squaring.
+    y = y * y * y >> 8;
+    if (y > 0xFFFFUL) // prevent overflow
+      return 0xFFFFU;
+    else
+      return (uint16_t) y;
+  }
+}
+
+void breathing_enable(void) {
+  breathing = true;
+  breathing_counter = 0;
+  breathing_halt = BREATHING_NO_HALT;
+  // interrupt already registered
+}
+
+void breathing_pulse(void) {
+  if (get_backlight_level() == 0)
+    breathing_min();
+  else
+    breathing_max();
+  breathing_halt = BREATHING_HALT_ON;
+  // breathing_interrupt_enable();
+  breathing = true;
+}
+
+void breathing_disable(void) {
+  breathing = false;
+  // backlight_set(get_backlight_level());
+  b_led_set(get_backlight_level()); // custom implementation of backlight_set()
+}
+
+void breathing_self_disable(void)
+{
+  if (get_backlight_level() == 0)
+    breathing_halt = BREATHING_HALT_OFF;
+  else
+    breathing_halt = BREATHING_HALT_ON;
+}
+
+void breathing_toggle(void) {
+  if (is_breathing())
+    breathing_disable();
+  else
+    breathing_enable();
+}
+
+void breathing_period_set(uint8_t value)
+{
+  if (!value)
+    value = 1;
+  breathing_period = value;
+}
+
+void breathing_period_default(void) {
+  breathing_period_set(BREATHING_PERIOD);
+}
+
+void breathing_period_inc(void)
+{
+  breathing_period_set(breathing_period+1);
+}
+
+void breathing_period_dec(void)
+{
+  breathing_period_set(breathing_period-1);
+}
+
+/* To generate breathing curve in python:
+ * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
+ */
+static const uint8_t breathing_table[BREATHING_STEPS] PROGMEM = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 17, 20, 24, 28, 32, 36, 41, 46, 51, 57, 63, 70, 76, 83, 91, 98, 106, 113, 121, 129, 138, 146, 154, 162, 170, 178, 185, 193, 200, 207, 213, 220, 225, 231, 235, 240, 244, 247, 250, 252, 253, 254, 255, 254, 253, 252, 250, 247, 244, 240, 235, 231, 225, 220, 213, 207, 200, 193, 185, 178, 170, 162, 154, 146, 138, 129, 121, 113, 106, 98, 91, 83, 76, 70, 63, 57, 51, 46, 41, 36, 32, 28, 24, 20, 17, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+// Use this before the cie_lightness function.
+static inline uint16_t scale_backlight(uint16_t v) {
+  return v / BACKLIGHT_LEVELS * get_backlight_level();
+}
+
+void custom_breathing_handler(void) {
+  uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
+  // resetting after one period to prevent ugly reset at overflow.
+  breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
+  uint8_t index = breathing_counter / interval % BREATHING_STEPS;
+
+  if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
+      ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
+  {
+      // breathing_interrupt_disable();
+  }
+
+  setPWM(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
+}
+
+#endif // BACKLIGHT_BREATHING
+#endif  // BACKLIGHT_ENABLE

keyboards/jj4x4/config.h

@@ -0,0 +1,53 @@
+/*
+Copyright 2017 Luiz Ribeiro <luizribeiro@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "config_common.h"
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#define VENDOR_ID       0x20A0
+#define PRODUCT_ID      0x422D
+// TODO: share these strings with usbconfig.h
+// Edit usbconfig.h to change these.
+#define MANUFACTURER    Kprepublic
+#define PRODUCT         jj4x4
+
+/* matrix size */
+#define MATRIX_ROWS 4
+#define MATRIX_COLS 4
+#define MATRIX_ROW_PINS { B5, B0, B3, B4 }
+#define MATRIX_COL_PINS { A1, A0, A2, A3 }
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+#define BACKLIGHT_LEVELS 12
+// #define BACKLIGHT_BREATHING  // works, but BL_TOGG might not work
+
+#define TAPPING_TOGGLE 3
+
+#define NO_UART 1
+
+/* RGB underglow */
+// The RGB_DI_PIN value seems to be shared between all PS2AVRGB boards.
+// The same pin is used on the JJ40, at least.
+#define RGBLED_NUM 5
+#define RGB_DI_PIN E2 // NOTE: for PS2AVRGB boards, underglow commands are sent via I2C to 0xB0.
+#define RGBLIGHT_ANIMATIONS
+
+#endif

keyboards/jj4x4/i2c.c

@@ -0,0 +1,104 @@
+/*
+Copyright 2016 Luiz Ribeiro <luizribeiro@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <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/jj4x4/i2c.h

@@ -0,0 +1,25 @@
+/*
+Copyright 2016 Luiz Ribeiro <luizribeiro@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __I2C_H__
+#define __I2C_H__
+
+void i2c_init(void);
+void i2c_set_bitrate(uint16_t bitrate_khz);
+uint8_t i2c_send(uint8_t address, uint8_t *data, uint16_t length);
+
+#endif

keyboards/jj4x4/info.json

@@ -0,0 +1,23 @@
+{
+  "keyboard_name": "jj40",
+  "url": "",
+  "maintainer": "qmk",
+  "width": 12,
+  "height": 4,
+  "layouts": {
+    "LAYOUT_planck_mit": {
+      "key_count": 47,
+      "layout": [{"x":0, "y":0}, {"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0}, {"x":4, "y":0}, {"x":5, "y":0}, {"x":6, "y":0}, {"x":7, "y":0}, {"x":8, "y":0}, {"x":9, "y":0}, {"x":10, "y":0}, {"x":11, "y":0}, {"x":0, "y":1}, {"x":1, "y":1}, {"x":2, "y":1}, {"x":3, "y":1}, {"x":4, "y":1}, {"x":5, "y":1}, {"x":6, "y":1}, {"x":7, "y":1}, {"x":8, "y":1}, {"x":9, "y":1}, {"x":10, "y":1}, {"x":11, "y":1}, {"x":0, "y":2}, {"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2}, {"x":4, "y":2}, {"x":5, "y":2}, {"x":6, "y":2}, {"x":7, "y":2}, {"x":8, "y":2}, {"x":9, "y":2}, {"x":10, "y":2}, {"x":11, "y":2}, {"x":0, "y":3}, {"x":1, "y":3}, {"x":2, "y":3}, {"x":3, "y":3}, {"x":4, "y":3}, {"x":5, "y":3, "w":2}, {"x":7, "y":3}, {"x":8, "y":3}, {"x":9, "y":3}, {"x":10, "y":3}, {"x":11, "y":3}]
+    },
+
+    "LAYOUT_ortho_4x12": {
+      "key_count": 48,
+      "layout": [{"x":0, "y":0}, {"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0}, {"x":4, "y":0}, {"x":5, "y":0}, {"x":6, "y":0}, {"x":7, "y":0}, {"x":8, "y":0}, {"x":9, "y":0}, {"x":10, "y":0}, {"x":11, "y":0}, {"x":0, "y":1}, {"x":1, "y":1}, {"x":2, "y":1}, {"x":3, "y":1}, {"x":4, "y":1}, {"x":5, "y":1}, {"x":6, "y":1}, {"x":7, "y":1}, {"x":8, "y":1}, {"x":9, "y":1}, {"x":10, "y":1}, {"x":11, "y":1}, {"x":0, "y":2}, {"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2}, {"x":4, "y":2}, {"x":5, "y":2}, {"x":6, "y":2}, {"x":7, "y":2}, {"x":8, "y":2}, {"x":9, "y":2}, {"x":10, "y":2}, {"x":11, "y":2}, {"x":0, "y":3}, {"x":1, "y":3}, {"x":2, "y":3}, {"x":3, "y":3}, {"x":4, "y":3}, {"x":5, "y":3}, {"x":6, "y":3}, {"x":7, "y":3}, {"x":8, "y":3}, {"x":9, "y":3}, {"x":10, "y":3}, {"x":11, "y":3}]
+    },
+
+    "LAYOUT_planck_1x2uR": {
+      "key_count": 47,
+      "layout": [{"x":0, "y":0}, {"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0}, {"x":4, "y":0}, {"x":5, "y":0}, {"x":6, "y":0}, {"x":7, "y":0}, {"x":8, "y":0}, {"x":9, "y":0}, {"x":10, "y":0}, {"x":11, "y":0}, {"x":0, "y":1}, {"x":1, "y":1}, {"x":2, "y":1}, {"x":3, "y":1}, {"x":4, "y":1}, {"x":5, "y":1}, {"x":6, "y":1}, {"x":7, "y":1}, {"x":8, "y":1}, {"x":9, "y":1}, {"x":10, "y":1}, {"x":11, "y":1}, {"x":0, "y":2}, {"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2}, {"x":4, "y":2}, {"x":5, "y":2}, {"x":6, "y":2}, {"x":7, "y":2}, {"x":8, "y":2}, {"x":9, "y":2}, {"x":10, "y":2}, {"x":11, "y":2}, {"x":0, "y":3}, {"x":1, "y":3}, {"x":2, "y":3}, {"x":3, "y":3}, {"x":4, "y":3}, {"x":5, "y":3}, {"x":6, "y":3, "w":2}, {"x":8, "y":3}, {"x":9, "y":3}, {"x":10, "y":3}, {"x":11, "y":3}]
+    }
+  }
+}

keyboards/jj4x4/jj4x4.c

@@ -0,0 +1,97 @@
+/*
+Copyright 2017 Luiz Ribeiro <luizribeiro@gmail.com>
+Modified 2018 Kenneth A. <github.com/krusli>
+
+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 "jj4x4.h"
+
+#include <avr/pgmspace.h>
+
+#include "action_layer.h"
+#include "quantum.h"
+
+#include "i2c.h"
+
+#include "backlight.h"
+#include "backlight_custom.h"
+
+// for keyboard subdirectory level init functions
+// @Override
+void matrix_init_kb(void) {
+  // call user level keymaps, if any
+  matrix_init_user();
+}
+
+#ifdef BACKLIGHT_ENABLE
+/// Overrides functions in `quantum.c`
+void backlight_init_ports(void) {
+  b_led_init_ports();
+}
+
+void backlight_task(void) {
+  b_led_task();
+}
+
+void backlight_set(uint8_t level) {
+  b_led_set(level);
+}
+#endif
+
+#ifdef RGBLIGHT_ENABLE
+extern rgblight_config_t rgblight_config;
+
+// custom RGB driver
+void rgblight_set(void) {
+  if (!rgblight_config.enable) {
+    for (uint8_t i=0; i<RGBLED_NUM; i++) {
+      led[i].r = 0;
+      led[i].g = 0;
+      led[i].b = 0;
+    }
+  }
+
+  i2c_init();
+  i2c_send(0xb0, (uint8_t*)led, 3 * RGBLED_NUM);
+}
+
+bool rgb_init = false;
+
+void matrix_scan_kb(void) {
+  // if LEDs were previously on before poweroff, turn them back on
+  if (rgb_init == false && rgblight_config.enable) {
+    i2c_init();
+    i2c_send(0xb0, (uint8_t*)led, 3 * RGBLED_NUM);
+    rgb_init = true;
+  }
+
+  rgblight_task();
+#else
+void matrix_scan_kb(void) {
+#endif
+  matrix_scan_user();
+  /* Nothing else for now. */
+}
+
+__attribute__((weak)) // overridable
+void matrix_init_user(void) {
+
+}
+
+
+__attribute__((weak)) // overridable
+void matrix_scan_user(void) {
+
+}

keyboards/jj4x4/jj4x4.h

@@ -0,0 +1,46 @@
+/*
+Copyright 2017 Luiz Ribeiro <luizribeiro@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef KEYMAP_COMMON_H
+#define KEYMAP_COMMON_H
+
+#include "quantum.h"
+#include "quantum_keycodes.h"
+#include "keycode.h"
+#include "action.h"
+
+void matrix_init_user(void);  // TODO port this to other PS2AVRGB boards
+
+#define XXX KC_NO
+
+	
+#define LAYOUT( \
+	K01, K02, K03, K04, \
+	K11, K12, K13, K14, \
+	K21, K22, K23, K24, \
+	K31, K32, K33, K34 \
+) \
+{ \
+  { K01, K02, K03, K04 }, \
+  { K11, K12, K13, K14 }, \
+  { K21, K22, K23, K24 }, \
+  { K31, K32, K33, K34 } \
+}	
+
+
+
+#endif

keyboards/jj4x4/keymaps/default/keymap.c

@@ -0,0 +1,34 @@
+#include QMK_KEYBOARD_H
+
+
+#define _QWERTY 0
+
+
+enum custom_keycodes {
+  QWERTY = SAFE_RANGE,
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+/* Qwerty
+ * ,---------------------------.
+ * |   A  |   B  |   C  |  D   |
+ * +------+------+------+------|
+ * |   E  |   F  |   G  |  H   |
+ * +------+------+------+------|
+ * |   I  |   J  |   K  |  L   |
+ * +------+------+------+------|
+ * |   M  |   N  |   O  |  P   |
+ * ----------------------------'
+ */
+[_QWERTY] = LAYOUT( \
+  KC_A,    KC_B,    KC_C,   KC_D, \
+  KC_E,    KC_F,    KC_G,   KC_H, \
+  KC_I,    KC_J,    KC_K,   KC_L, \
+  KC_M,    KC_N,    KC_O,   KC_P  \
+),
+};
+
+// Loop
+void matrix_scan_user(void) {
+  // Empty
+};

keyboards/jj4x4/rules.mk

@@ -0,0 +1,58 @@
+# Copyright 2017 Luiz Ribeiro <luizribeiro@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# MCU name
+MCU = atmega32a
+PROTOCOL = VUSB
+
+# unsupported features for now
+NO_UART = yes
+NO_SUSPEND_POWER_DOWN = yes
+
+# processor frequency
+F_CPU = 12000000
+
+# 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 = bootloadHID
+
+# build options
+BOOTMAGIC_ENABLE = no
+MOUSEKEY_ENABLE = no
+EXTRAKEY_ENABLE = yes
+CONSOLE_ENABLE = no
+COMMAND_ENABLE = yes
+
+BACKLIGHT_ENABLE = yes
+BACKLIGHT_CUSTOM_DRIVER = yes
+
+RGBLIGHT_ENABLE = yes
+RGBLIGHT_CUSTOM_DRIVER = yes
+
+KEY_LOCK_ENABLE = yes
+
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
+
+OPT_DEFS = -DDEBUG_LEVEL=0
+
+SRC = i2c.c backlight.c
+
+# programming options
+PROGRAM_CMD = ./util/atmega32a_program.py $(TARGET).hex
+
+

keyboards/jj4x4/tools/README.md

@@ -0,0 +1,16 @@
+# JJ40 Tools
+
+## usb_detach.c
+
+When trying to flash on Linux, you may encounter a "Resource Unavailable" error. This means that Linux's HID driver has taken exclusive control of the keyboard, and the program script can't flash it.
+This program can force Linux to give up a device, so that the programming script can reset it.
+
+### To compile:
+```
+gcc usb_detach.c -o usb_detach
+```
+
+### To run:
+1. Use `lsusb` to discover the Bus and Device numbers for your keyboard.
+2. Run the program: `sudo ./usb_detach /dev/bus/usb/<BUS>/<DEVICE>`.
+3. Build and program the firmware as normal.

keyboards/jj4x4/tools/usb_detach.c

@@ -0,0 +1,33 @@
+/* Found at https://www.linuxquestions.org/questions/linux-hardware-18/how-to-unclaim-usb-device-558138/#post3406986 */
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <linux/ioctl.h>
+#include <linux/usbdevice_fs.h>
+
+int main(int argc, char**argv)
+{
+        struct usbdevfs_ioctl command;
+        int ret;
+        int fd;
+        int i;
+        if (argc>1) {
+                fd = open(argv[1],O_RDWR);
+                if (fd<1){
+                        perror("unable to open file");
+                        return 1;
+                }
+                for (i=0;i<255;i++){ // hack: should fetch how many interface there is.
+                        command.ifno = i;
+                        command.ioctl_code = USBDEVFS_DISCONNECT;
+                        command.data = NULL;
+                        ret = ioctl(fd, USBDEVFS_IOCTL, &command);
+                        if(ret!=-1)
+                                printf("un claimed interface %d %d\n",i,ret);
+                }
+        } else {
+                printf ("usage: %s /dev/bus/usb/BUS/DEVICE\n",argv[0]);
+                printf("Release all interfaces of this usb device for usage in virtualisation\n");
+        }
+}

keyboards/jj4x4/usbconfig.h

@@ -0,0 +1,397 @@
+/* Name: usbconfig.h
+ * Project: V-USB, virtual USB port for Atmel's(r) AVR(r) microcontrollers
+ * Author: Christian Starkjohann
+ * Creation Date: 2005-04-01
+ * Tabsize: 4
+ * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
+ * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt)
+ * This Revision: $Id: usbconfig-prototype.h 785 2010-05-30 17:57:07Z cs $
+ */
+
+#ifndef __usbconfig_h_included__
+#define __usbconfig_h_included__
+
+#include "config.h"
+
+/*
+General Description:
+This file is an example configuration (with inline documentation) for the USB
+driver. It configures V-USB for USB D+ connected to Port D bit 2 (which is
+also hardware interrupt 0 on many devices) and USB D- to Port D bit 4. You may
+wire the lines to any other port, as long as D+ is also wired to INT0 (or any
+other hardware interrupt, as long as it is the highest level interrupt, see
+section at the end of this file).
+*/
+
+/* ---------------------------- Hardware Config ---------------------------- */
+
+#define USB_CFG_IOPORTNAME      D
+/* This is the port where the USB bus is connected. When you configure it to
+ * "B", the registers PORTB, PINB and DDRB will be used.
+ */
+#define USB_CFG_DMINUS_BIT      3
+/* This is the bit number in USB_CFG_IOPORT where the USB D- line is connected.
+ * This may be any bit in the port.
+ */
+#define USB_CFG_DPLUS_BIT       2
+/* This is the bit number in USB_CFG_IOPORT where the USB D+ line is connected.
+ * This may be any bit in the port. Please note that D+ must also be connected
+ * to interrupt pin INT0! [You can also use other interrupts, see section
+ * "Optional MCU Description" below, or you can connect D- to the interrupt, as
+ * it is required if you use the USB_COUNT_SOF feature. If you use D- for the
+ * interrupt, the USB interrupt will also be triggered at Start-Of-Frame
+ * markers every millisecond.]
+ */
+#define USB_CFG_CLOCK_KHZ       (F_CPU/1000)
+/* Clock rate of the AVR in kHz. Legal values are 12000, 12800, 15000, 16000,
+ * 16500, 18000 and 20000. The 12.8 MHz and 16.5 MHz versions of the code
+ * require no crystal, they tolerate +/- 1% deviation from the nominal
+ * frequency. All other rates require a precision of 2000 ppm and thus a
+ * crystal!
+ * Since F_CPU should be defined to your actual clock rate anyway, you should
+ * not need to modify this setting.
+ */
+#define USB_CFG_CHECK_CRC       0
+/* Define this to 1 if you want that the driver checks integrity of incoming
+ * data packets (CRC checks). CRC checks cost quite a bit of code size and are
+ * currently only available for 18 MHz crystal clock. You must choose
+ * USB_CFG_CLOCK_KHZ = 18000 if you enable this option.
+ */
+
+/* ----------------------- Optional Hardware Config ------------------------ */
+
+/* #define USB_CFG_PULLUP_IOPORTNAME   D */
+/* If you connect the 1.5k pullup resistor from D- to a port pin instead of
+ * V+, you can connect and disconnect the device from firmware by calling
+ * the macros usbDeviceConnect() and usbDeviceDisconnect() (see usbdrv.h).
+ * This constant defines the port on which the pullup resistor is connected.
+ */
+/* #define USB_CFG_PULLUP_BIT          4 */
+/* This constant defines the bit number in USB_CFG_PULLUP_IOPORT (defined
+ * above) where the 1.5k pullup resistor is connected. See description
+ * above for details.
+ */
+
+/* --------------------------- Functional Range ---------------------------- */
+
+#define USB_CFG_HAVE_INTRIN_ENDPOINT    1
+/* Define this to 1 if you want to compile a version with two endpoints: The
+ * default control endpoint 0 and an interrupt-in endpoint (any other endpoint
+ * number).
+ */
+#define USB_CFG_HAVE_INTRIN_ENDPOINT3   1
+/* Define this to 1 if you want to compile a version with three endpoints: The
+ * default control endpoint 0, an interrupt-in endpoint 3 (or the number
+ * configured below) and a catch-all default interrupt-in endpoint as above.
+ * You must also define USB_CFG_HAVE_INTRIN_ENDPOINT to 1 for this feature.
+ */
+#define USB_CFG_EP3_NUMBER              3
+/* If the so-called endpoint 3 is used, it can now be configured to any other
+ * endpoint number (except 0) with this macro. Default if undefined is 3.
+ */
+/* #define USB_INITIAL_DATATOKEN           USBPID_DATA1 */
+/* The above macro defines the startup condition for data toggling on the
+ * interrupt/bulk endpoints 1 and 3. Defaults to USBPID_DATA1.
+ * Since the token is toggled BEFORE sending any data, the first packet is
+ * sent with the oposite value of this configuration!
+ */
+#define USB_CFG_IMPLEMENT_HALT          0
+/* Define this to 1 if you also want to implement the ENDPOINT_HALT feature
+ * for endpoint 1 (interrupt endpoint). Although you may not need this feature,
+ * it is required by the standard. We have made it a config option because it
+ * bloats the code considerably.
+ */
+#define USB_CFG_SUPPRESS_INTR_CODE      0
+/* Define this to 1 if you want to declare interrupt-in endpoints, but don't
+ * want to send any data over them. If this macro is defined to 1, functions
+ * usbSetInterrupt() and usbSetInterrupt3() are omitted. This is useful if
+ * you need the interrupt-in endpoints in order to comply to an interface
+ * (e.g. HID), but never want to send any data. This option saves a couple
+ * of bytes in flash memory and the transmit buffers in RAM.
+ */
+#define USB_CFG_INTR_POLL_INTERVAL      1
+/* If you compile a version with endpoint 1 (interrupt-in), this is the poll
+ * interval. The value is in milliseconds and must not be less than 10 ms for
+ * low speed devices.
+ */
+#define USB_CFG_IS_SELF_POWERED         0
+/* Define this to 1 if the device has its own power supply. Set it to 0 if the
+ * device is powered from the USB bus.
+ */
+// max power draw with maxed white underglow measured at 120 mA (peaks)
+#define USB_CFG_MAX_BUS_POWER           100
+/* Set this variable to the maximum USB bus power consumption of your device.
+ * The value is in milliamperes. [It will be divided by two since USB
+ * communicates power requirements in units of 2 mA.]
+ */
+#define USB_CFG_IMPLEMENT_FN_WRITE      1
+/* Set this to 1 if you want usbFunctionWrite() to be called for control-out
+ * transfers. Set it to 0 if you don't need it and want to save a couple of
+ * bytes.
+ */
+#define USB_CFG_IMPLEMENT_FN_READ       0
+/* Set this to 1 if you need to send control replies which are generated
+ * "on the fly" when usbFunctionRead() is called. If you only want to send
+ * data from a static buffer, set it to 0 and return the data from
+ * usbFunctionSetup(). This saves a couple of bytes.
+ */
+#define USB_CFG_IMPLEMENT_FN_WRITEOUT   0
+/* Define this to 1 if you want to use interrupt-out (or bulk out) endpoints.
+ * You must implement the function usbFunctionWriteOut() which receives all
+ * interrupt/bulk data sent to any endpoint other than 0. The endpoint number
+ * can be found in 'usbRxToken'.
+ */
+#define USB_CFG_HAVE_FLOWCONTROL        0
+/* Define this to 1 if you want flowcontrol over USB data. See the definition
+ * of the macros usbDisableAllRequests() and usbEnableAllRequests() in
+ * usbdrv.h.
+ */
+#define USB_CFG_DRIVER_FLASH_PAGE       0
+/* If the device has more than 64 kBytes of flash, define this to the 64 k page
+ * where the driver's constants (descriptors) are located. Or in other words:
+ * Define this to 1 for boot loaders on the ATMega128.
+ */
+#define USB_CFG_LONG_TRANSFERS          0
+/* Define this to 1 if you want to send/receive blocks of more than 254 bytes
+ * in a single control-in or control-out transfer. Note that the capability
+ * for long transfers increases the driver size.
+ */
+/* #define USB_RX_USER_HOOK(data, len)     if(usbRxToken == (uchar)USBPID_SETUP) blinkLED(); */
+/* This macro is a hook if you want to do unconventional things. If it is
+ * defined, it's inserted at the beginning of received message processing.
+ * If you eat the received message and don't want default processing to
+ * proceed, do a return after doing your things. One possible application
+ * (besides debugging) is to flash a status LED on each packet.
+ */
+/* #define USB_RESET_HOOK(resetStarts)     if(!resetStarts){hadUsbReset();} */
+/* This macro is a hook if you need to know when an USB RESET occurs. It has
+ * one parameter which distinguishes between the start of RESET state and its
+ * end.
+ */
+/* #define USB_SET_ADDRESS_HOOK()              hadAddressAssigned(); */
+/* This macro (if defined) is executed when a USB SET_ADDRESS request was
+ * received.
+ */
+#define USB_COUNT_SOF                   1
+/* define this macro to 1 if you need the global variable "usbSofCount" which
+ * counts SOF packets. This feature requires that the hardware interrupt is
+ * connected to D- instead of D+.
+ */
+/* #ifdef __ASSEMBLER__
+ * macro myAssemblerMacro
+ *     in      YL, TCNT0
+ *     sts     timer0Snapshot, YL
+ *     endm
+ * #endif
+ * #define USB_SOF_HOOK                    myAssemblerMacro
+ * This macro (if defined) is executed in the assembler module when a
+ * Start Of Frame condition is detected. It is recommended to define it to
+ * the name of an assembler macro which is defined here as well so that more
+ * than one assembler instruction can be used. The macro may use the register
+ * YL and modify SREG. If it lasts longer than a couple of cycles, USB messages
+ * immediately after an SOF pulse may be lost and must be retried by the host.
+ * What can you do with this hook? Since the SOF signal occurs exactly every
+ * 1 ms (unless the host is in sleep mode), you can use it to tune OSCCAL in
+ * designs running on the internal RC oscillator.
+ * Please note that Start Of Frame detection works only if D- is wired to the
+ * interrupt, not D+. THIS IS DIFFERENT THAN MOST EXAMPLES!
+ */
+#define USB_CFG_CHECK_DATA_TOGGLING     0
+/* define this macro to 1 if you want to filter out duplicate data packets
+ * sent by the host. Duplicates occur only as a consequence of communication
+ * errors, when the host does not receive an ACK. Please note that you need to
+ * implement the filtering yourself in usbFunctionWriteOut() and
+ * usbFunctionWrite(). Use the global usbCurrentDataToken and a static variable
+ * for each control- and out-endpoint to check for duplicate packets.
+ */
+#define USB_CFG_HAVE_MEASURE_FRAME_LENGTH   0
+/* define this macro to 1 if you want the function usbMeasureFrameLength()
+ * compiled in. This function can be used to calibrate the AVR's RC oscillator.
+ */
+#define USB_USE_FAST_CRC                0
+/* The assembler module has two implementations for the CRC algorithm. One is
+ * faster, the other is smaller. This CRC routine is only used for transmitted
+ * messages where timing is not critical. The faster routine needs 31 cycles
+ * per byte while the smaller one needs 61 to 69 cycles. The faster routine
+ * may be worth the 32 bytes bigger code size if you transmit lots of data and
+ * run the AVR close to its limit.
+ */
+
+/* -------------------------- Device Description --------------------------- */
+
+#define USB_CFG_VENDOR_ID       (VENDOR_ID & 0xFF), ((VENDOR_ID >> 8) & 0xFF)
+/* USB vendor ID for the device, low byte first. If you have registered your
+ * own Vendor ID, define it here. Otherwise you may use one of obdev's free
+ * shared VID/PID pairs. Be sure to read USB-IDs-for-free.txt for rules!
+ * *** IMPORTANT NOTE ***
+ * This template uses obdev's shared VID/PID pair for Vendor Class devices
+ * with libusb: 0x16c0/0x5dc.  Use this VID/PID pair ONLY if you understand
+ * the implications!
+ */
+#define USB_CFG_DEVICE_ID       (PRODUCT_ID & 0xFF), ((PRODUCT_ID >> 8) & 0xFF)
+/* This is the ID of the product, low byte first. It is interpreted in the
+ * scope of the vendor ID. If you have registered your own VID with usb.org
+ * or if you have licensed a PID from somebody else, define it here. Otherwise
+ * you may use one of obdev's free shared VID/PID pairs. See the file
+ * USB-IDs-for-free.txt for details!
+ * *** IMPORTANT NOTE ***
+ * This template uses obdev's shared VID/PID pair for Vendor Class devices
+ * with libusb: 0x16c0/0x5dc.  Use this VID/PID pair ONLY if you understand
+ * the implications!
+ */
+#define USB_CFG_DEVICE_VERSION  0x00, 0x02
+/* Version number of the device: Minor number first, then major number.
+ */
+#define USB_CFG_VENDOR_NAME     'w', 'i', 'n', 'k', 'e', 'y', 'l', 'e', 's', 's', '.', 'k', 'r'
+#define USB_CFG_VENDOR_NAME_LEN 13
+/* These two values define the vendor name returned by the USB device. The name
+ * must be given as a list of characters under single quotes. The characters
+ * are interpreted as Unicode (UTF-16) entities.
+ * If you don't want a vendor name string, undefine these macros.
+ * ALWAYS define a vendor name containing your Internet domain name if you use
+ * obdev's free shared VID/PID pair. See the file USB-IDs-for-free.txt for
+ * details.
+ */
+#define USB_CFG_DEVICE_NAME     'j', 'j', '4', '0'
+#define USB_CFG_DEVICE_NAME_LEN 4
+/* Same as above for the device name. If you don't want a device name, undefine
+ * the macros. See the file USB-IDs-for-free.txt before you assign a name if
+ * you use a shared VID/PID.
+ */
+/*#define USB_CFG_SERIAL_NUMBER   'N', 'o', 'n', 'e' */
+/*#define USB_CFG_SERIAL_NUMBER_LEN   0 */
+/* Same as above for the serial number. If you don't want a serial number,
+ * undefine the macros.
+ * It may be useful to provide the serial number through other means than at
+ * compile time. See the section about descriptor properties below for how
+ * to fine tune control over USB descriptors such as the string descriptor
+ * for the serial number.
+ */
+#define USB_CFG_DEVICE_CLASS        0
+#define USB_CFG_DEVICE_SUBCLASS     0
+/* See USB specification if you want to conform to an existing device class.
+ * Class 0xff is "vendor specific".
+ */
+#define USB_CFG_INTERFACE_CLASS     3   /* HID */
+#define USB_CFG_INTERFACE_SUBCLASS  1   /* Boot */
+#define USB_CFG_INTERFACE_PROTOCOL  1   /* Keyboard */
+/* See USB specification if you want to conform to an existing device class or
+ * protocol. The following classes must be set at interface level:
+ * HID class is 3, no subclass and protocol required (but may be useful!)
+ * CDC class is 2, use subclass 2 and protocol 1 for ACM
+ */
+#define USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH    0
+/* Define this to the length of the HID report descriptor, if you implement
+ * an HID device. Otherwise don't define it or define it to 0.
+ * If you use this define, you must add a PROGMEM character array named
+ * "usbHidReportDescriptor" to your code which contains the report descriptor.
+ * Don't forget to keep the array and this define in sync!
+ */
+
+/* #define USB_PUBLIC static */
+/* Use the define above if you #include usbdrv.c instead of linking against it.
+ * This technique saves a couple of bytes in flash memory.
+ */
+
+/* ------------------- Fine Control over USB Descriptors ------------------- */
+/* If you don't want to use the driver's default USB descriptors, you can
+ * provide our own. These can be provided as (1) fixed length static data in
+ * flash memory, (2) fixed length static data in RAM or (3) dynamically at
+ * runtime in the function usbFunctionDescriptor(). See usbdrv.h for more
+ * information about this function.
+ * Descriptor handling is configured through the descriptor's properties. If
+ * no properties are defined or if they are 0, the default descriptor is used.
+ * Possible properties are:
+ *   + USB_PROP_IS_DYNAMIC: The data for the descriptor should be fetched
+ *     at runtime via usbFunctionDescriptor(). If the usbMsgPtr mechanism is
+ *     used, the data is in FLASH by default. Add property USB_PROP_IS_RAM if
+ *     you want RAM pointers.
+ *   + USB_PROP_IS_RAM: The data returned by usbFunctionDescriptor() or found
+ *     in static memory is in RAM, not in flash memory.
+ *   + USB_PROP_LENGTH(len): If the data is in static memory (RAM or flash),
+ *     the driver must know the descriptor's length. The descriptor itself is
+ *     found at the address of a well known identifier (see below).
+ * List of static descriptor names (must be declared PROGMEM if in flash):
+ *   char usbDescriptorDevice[];
+ *   char usbDescriptorConfiguration[];
+ *   char usbDescriptorHidReport[];
+ *   char usbDescriptorString0[];
+ *   int usbDescriptorStringVendor[];
+ *   int usbDescriptorStringDevice[];
+ *   int usbDescriptorStringSerialNumber[];
+ * Other descriptors can't be provided statically, they must be provided
+ * dynamically at runtime.
+ *
+ * Descriptor properties are or-ed or added together, e.g.:
+ * #define USB_CFG_DESCR_PROPS_DEVICE   (USB_PROP_IS_RAM | USB_PROP_LENGTH(18))
+ *
+ * The following descriptors are defined:
+ *   USB_CFG_DESCR_PROPS_DEVICE
+ *   USB_CFG_DESCR_PROPS_CONFIGURATION
+ *   USB_CFG_DESCR_PROPS_STRINGS
+ *   USB_CFG_DESCR_PROPS_STRING_0
+ *   USB_CFG_DESCR_PROPS_STRING_VENDOR
+ *   USB_CFG_DESCR_PROPS_STRING_PRODUCT
+ *   USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
+ *   USB_CFG_DESCR_PROPS_HID
+ *   USB_CFG_DESCR_PROPS_HID_REPORT
+ *   USB_CFG_DESCR_PROPS_UNKNOWN (for all descriptors not handled by the driver)
+ *
+ * Note about string descriptors: String descriptors are not just strings, they
+ * are Unicode strings prefixed with a 2 byte header. Example:
+ * int  serialNumberDescriptor[] = {
+ *     USB_STRING_DESCRIPTOR_HEADER(6),
+ *     'S', 'e', 'r', 'i', 'a', 'l'
+ * };
+ */
+
+#define USB_CFG_DESCR_PROPS_DEVICE                  0
+#define USB_CFG_DESCR_PROPS_CONFIGURATION           USB_PROP_IS_DYNAMIC
+//#define USB_CFG_DESCR_PROPS_CONFIGURATION           0
+#define USB_CFG_DESCR_PROPS_STRINGS                 0
+#define USB_CFG_DESCR_PROPS_STRING_0                0
+#define USB_CFG_DESCR_PROPS_STRING_VENDOR           0
+#define USB_CFG_DESCR_PROPS_STRING_PRODUCT          0
+#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER    0
+#define USB_CFG_DESCR_PROPS_HID                     USB_PROP_IS_DYNAMIC
+//#define USB_CFG_DESCR_PROPS_HID                     0
+#define USB_CFG_DESCR_PROPS_HID_REPORT              USB_PROP_IS_DYNAMIC
+//#define USB_CFG_DESCR_PROPS_HID_REPORT              0
+#define USB_CFG_DESCR_PROPS_UNKNOWN                 0
+
+#define usbMsgPtr_t unsigned short
+/* If usbMsgPtr_t is not defined, it defaults to 'uchar *'. We define it to
+ * a scalar type here because gcc generates slightly shorter code for scalar
+ * arithmetics than for pointer arithmetics. Remove this define for backward
+ * type compatibility or define it to an 8 bit type if you use data in RAM only
+ * and all RAM is below 256 bytes (tiny memory model in IAR CC).
+ */
+
+/* ----------------------- Optional MCU Description ------------------------ */
+
+/* The following configurations have working defaults in usbdrv.h. You
+ * usually don't need to set them explicitly. Only if you want to run
+ * the driver on a device which is not yet supported or with a compiler
+ * which is not fully supported (such as IAR C) or if you use a differnt
+ * interrupt than INT0, you may have to define some of these.
+ */
+/* #define USB_INTR_CFG            MCUCR */
+/* #define USB_INTR_CFG_SET        ((1 << ISC00) | (1 << ISC01)) */
+/* #define USB_INTR_CFG_CLR        0 */
+/* #define USB_INTR_ENABLE         GIMSK */
+/* #define USB_INTR_ENABLE_BIT     INT0 */
+/* #define USB_INTR_PENDING        GIFR */
+/* #define USB_INTR_PENDING_BIT    INTF0 */
+/* #define USB_INTR_VECTOR         INT0_vect */
+
+/* Set INT1 for D- falling edge to count SOF */
+/* #define USB_INTR_CFG            EICRA */
+#define USB_INTR_CFG_SET        ((1 << ISC11) | (0 << ISC10))
+/* #define USB_INTR_CFG_CLR        0 */
+/* #define USB_INTR_ENABLE         EIMSK */
+#define USB_INTR_ENABLE_BIT     INT1
+/* #define USB_INTR_PENDING        EIFR */
+#define USB_INTR_PENDING_BIT    INTF1
+#define USB_INTR_VECTOR         INT1_vect
+
+#endif /* __usbconfig_h_included__ */

tmk_core/common/action_util.c

@@ -48,11 +48,21 @@ extern inline void del_key(uint8_t key);
 extern inline void clear_keys(void);
 
 #ifndef NO_ACTION_ONESHOT
-static int8_t oneshot_mods = 0;
-static int8_t oneshot_locked_mods = 0;
-int8_t get_oneshot_locked_mods(void) { return oneshot_locked_mods; }
-void set_oneshot_locked_mods(int8_t mods) { oneshot_locked_mods = mods; }
-void clear_oneshot_locked_mods(void) { oneshot_locked_mods = 0; }
+static uint8_t oneshot_mods = 0;
+static uint8_t oneshot_locked_mods = 0;
+uint8_t get_oneshot_locked_mods(void) { return oneshot_locked_mods; }
+void set_oneshot_locked_mods(uint8_t mods) {
+    if (mods != oneshot_locked_mods) {
+        oneshot_locked_mods = mods;
+        oneshot_locked_mods_changed_kb(oneshot_locked_mods);
+    }
+}
+void clear_oneshot_locked_mods(void) {
+    if (oneshot_locked_mods) {
+        oneshot_locked_mods = 0;
+        oneshot_locked_mods_changed_kb(oneshot_locked_mods);
+    }
+}
 #if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
 static uint16_t oneshot_time = 0;
 bool has_oneshot_mods_timed_out(void) {
@@ -97,6 +107,7 @@ void set_oneshot_layer(uint8_t layer, uint8_t state)
 #if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
     oneshot_layer_time = timer_read();
 #endif
+    oneshot_layer_changed_kb(get_oneshot_layer());
 }
 /** \brief Reset oneshot layer 
  *
@@ -107,6 +118,7 @@ void reset_oneshot_layer(void) {
 #if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
     oneshot_layer_time = 0;
 #endif
+    oneshot_layer_changed_kb(get_oneshot_layer());
 }
 /** \brief Clear oneshot layer 
  *
@@ -118,9 +130,7 @@ void clear_oneshot_layer_state(oneshot_fullfillment_t state)
     oneshot_layer_data &= ~state;
     if (!get_oneshot_layer_state() && start_state != oneshot_layer_data) {
         layer_off(get_oneshot_layer());
-#if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
-    oneshot_layer_time = 0;
-#endif
+        reset_oneshot_layer();
     }
 }
 /** \brief Is oneshot layer active
@@ -243,23 +253,27 @@ void clear_macro_mods(void) { macro_mods = 0; }
  *
  * FIXME: needs doc
  */
-void set_oneshot_mods(uint8_t mods)
-{
-    oneshot_mods = mods;
+void set_oneshot_mods(uint8_t mods) {
+  if (oneshot_mods != mods) {
 #if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
     oneshot_time = timer_read();
 #endif
+    oneshot_mods = mods;
+    oneshot_mods_changed_kb(mods);
+  }
 }
 /** \brief clear oneshot mods
  *
  * FIXME: needs doc
  */
-void clear_oneshot_mods(void)
-{
+void clear_oneshot_mods(void) {
+  if (oneshot_mods) {
     oneshot_mods = 0;
 #if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0))
     oneshot_time = 0;
 #endif
+    oneshot_mods_changed_kb(oneshot_mods);
+  }
 }
 /** \brief get oneshot mods
  *
@@ -271,6 +285,54 @@ uint8_t get_oneshot_mods(void)
 }
 #endif
 
+/** \brief Called when the one shot modifiers have been changed.
+ * 
+ * \param mods Contains the active modifiers active after the change. 
+ */
+__attribute__((weak))
+void oneshot_locked_mods_changed_user(uint8_t mods) { }
+
+/** \brief Called when the locked one shot modifiers have been changed.
+ * 
+ * \param mods Contains the active modifiers active after the change. 
+ */
+__attribute__((weak))
+void oneshot_locked_mods_changed_kb(uint8_t mods) {
+    oneshot_locked_mods_changed_user(mods);
+}
+
+/** \brief Called when the one shot modifiers have been changed.
+ * 
+ * \param mods Contains the active modifiers active after the change.
+ */
+__attribute__((weak))
+void oneshot_mods_changed_user(uint8_t mods) { }
+
+/** \brief Called when the one shot modifiers have been changed.
+ * 
+ * \param mods Contains the active modifiers active after the change.
+ */
+__attribute__((weak))
+void oneshot_mods_changed_kb(uint8_t mods) {
+    oneshot_mods_changed_user(mods);
+}
+
+/** \brief Called when the one shot layers have been changed.
+ * 
+ * \param layer Contains the layer that is toggled on, or zero when toggled off. 
+ */
+__attribute__((weak))
+void oneshot_layer_changed_user(uint8_t layer) { }
+
+/** \brief Called when the one shot layers have been changed.
+ * 
+ * \param layer Contains the layer that is toggled on, or zero when toggled off.
+ */
+__attribute__((weak))
+void oneshot_layer_changed_kb(uint8_t layer) {
+    oneshot_layer_changed_user(layer);
+}
+
 /** \brief inspect keyboard state
  *
  * FIXME: needs doc

tmk_core/common/action_util.h

@@ -71,8 +71,8 @@ void oneshot_enable(void);
 void oneshot_disable(void);
 bool has_oneshot_mods_timed_out(void);
 
-int8_t get_oneshot_locked_mods(void);
-void set_oneshot_locked_mods(int8_t mods);
+uint8_t get_oneshot_locked_mods(void);
+void set_oneshot_locked_mods(uint8_t mods);
 void clear_oneshot_locked_mods(void);
 
 typedef enum {
@@ -89,6 +89,13 @@ bool is_oneshot_layer_active(void);
 uint8_t get_oneshot_layer_state(void);
 bool has_oneshot_layer_timed_out(void);
 
+void oneshot_locked_mods_changed_user(uint8_t mods);
+void oneshot_locked_mods_changed_kb(uint8_t mods);
+void oneshot_mods_changed_user(uint8_t mods);
+void oneshot_mods_changed_kb(uint8_t mods);
+void oneshot_layer_changed_user(uint8_t layer);
+void oneshot_layer_changed_kb(uint8_t layer);
+
 /* inspect */
 uint8_t has_anymod(void);