jbrechtel/qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #222 from zsa/staging

Browse Source 
Firmware 15
This commit is contained in:
Florian Didron
2019-12-06 09:25:39 +09:00
committed by GitHub
parent 1d600f09a8 038cef3054
commit 13e1dd3d53
94 changed files with 2277 additions and 458 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@@ -25,7 +25,7 @@ quantum/version.h
CMakeLists.txt
cmake-build-debug
doxygen/
.DS_STORE
.DS_Store
/util/wsl_downloaded
/util/win_downloaded
/users/

2
.gitmodules vendored
View File

@@ -13,4 +13,4 @@
url = https://github.com/google/googletest
[submodule "lib/lufa"]
path = lib/lufa
url = https://github.com/qmk/lufa
url = https://github.com/zsa/lufa

13
Makefile
View File

@@ -371,6 +371,9 @@ define PARSE_KEYBOARD
# The same if all was specified
else ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,all),true)
$$(eval $$(call PARSE_ALL_KEYMAPS))
# List all keymaps for the given keyboard
else ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,list-keymaps),true)
$$(eval $$(call LIST_ALL_KEYMAPS))
# Try to match the specified keyamp with the list of known keymaps
else ifeq ($$(call TRY_TO_MATCH_RULE_FROM_LIST,$$(KEYMAPS)),true)
$$(eval $$(call PARSE_KEYMAP,$$(MATCHED_ITEM)))
@@ -407,6 +410,16 @@ endef
# endif
# endef
# Prints a list of all known keymaps for the given keyboard
define LIST_ALL_KEYMAPS
COMMAND_true_LIST_KEYMAPS := \
printf "$$(KEYMAPS)\n";
COMMAND_false_LIST_KEYMAPS := \
printf "$$(MSG_AVAILABLE_KEYMAPS)\n"; \
printf "$$(KEYMAPS)\n";
COMMANDS += LIST_KEYMAPS
endef
# $1 Keymap
# This is the meat of compiling a keyboard, when entering this, everything is known
# keyboard, subproject, and keymap

92
bin/qmk
View File

@@ -4,10 +4,8 @@
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
from time import strftime
# Add the QMK python libs to our path
script_dir = os.path.dirname(os.path.realpath(__file__))
@@ -15,12 +13,8 @@ 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:
with open(os.path.join(qmk_dir, 'requirements.txt'), 'r') as fd:
for line in fd.readlines():
line = line.strip().replace('<', '=').replace('>', '=')
@@ -32,72 +26,58 @@ with open('requirements.txt', 'r') as fd:
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.')
print('Could not find module %s!', module)
print('Please run `pip3 install -r requirements.txt` to install the python dependencies.')
exit(255)
# Figure out our version
# TODO(skullydazed/anyone): Find a method that doesn't involve git. This is slow in docker and on windows.
command = ['git', 'describe', '--abbrev=6', '--dirty', '--always', '--tags']
result = subprocess.run(command, universal_newlines=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
result = subprocess.run(command, universal_newlines=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
if result.returncode == 0:
os.environ['QMK_VERSION'] = 'QMK ' + result.stdout.strip()
os.environ['QMK_VERSION'] = result.stdout.strip()
else:
os.environ['QMK_VERSION'] = 'QMK ' + strftime('%Y-%m-%d-%H:%M:%S')
os.environ['QMK_VERSION'] = 'nogit-' + strftime('%Y-%m-%d-%H:%M:%S') + '-dirty'
# 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')
milc.EMOJI_LOGLEVELS['INFO'] = '{fg_blue}Ψ{style_reset_all}'
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)
@milc.cli.entrypoint('QMK Helper Script')
def qmk_main(cli):
"""The function that gets run when no subcommand is provided.
"""
cli.print_help()
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)
def main():
"""Setup our environment and then call the CLI entrypoint.
"""
# Change to the root of our checkout
os.environ['ORIG_CWD'] = os.getcwd()
os.chdir(qmk_dir)
try:
import_module(subcommand)
except ModuleNotFoundError as e:
if e.__class__.__name__ != subcommand:
raise
# Import the subcommands
import qmk.cli
milc.cli.log.error('Invalid subcommand! Could not import %s.', subcommand)
exit(1)
if __name__ == '__main__':
# Execute
return_code = milc.cli()
if return_code is False:
exit(1)
elif return_code is not True and isinstance(return_code, int) and return_code < 256:
elif return_code is not True and isinstance(return_code, int):
if return_code < 0 or return_code > 255:
milc.cli.log.error('Invalid return_code: %d', return_code)
exit(255)
exit(return_code)
else:
exit(0)
exit(0)
if __name__ == '__main__':
main()

1
bin/qmk-compile-json
View File

@@ -1 +0,0 @@
qmk

1
bin/qmk-doctor
View File

@@ -1 +0,0 @@
qmk

1
bin/qmk-hello
View File

@@ -1 +0,0 @@
qmk

1
bin/qmk-json-keymap
View File

@@ -1 +0,0 @@
qmk

2
build_json.mk
View File

@@ -23,5 +23,5 @@ endif
# Generate the keymap.c
ifneq ("$(KEYMAP_JSON)","")
_ = $(shell test -e $(KEYMAP_C) || bin/qmk-json-keymap $(KEYMAP_JSON) -o $(KEYMAP_C))
_ = $(shell test -e $(KEYMAP_C) || bin/qmk json-keymap $(KEYMAP_JSON) -o $(KEYMAP_C))
endif

36
common_features.mk
View File

@@ -112,7 +112,7 @@ ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
ifeq ($(strip $(RGBLIGHT_CUSTOM_DRIVER)), yes)
OPT_DEFS += -DRGBLIGHT_CUSTOM_DRIVER
else
SRC += ws2812.c
WS2812_DRIVER_REQUIRED = yes
endif
endif
@@ -176,7 +176,7 @@ endif
ifeq ($(strip $(RGB_MATRIX_ENABLE)), WS2812)
OPT_DEFS += -DWS2812
SRC += ws2812.c
WS2812_DRIVER_REQUIRED = yes
endif
ifeq ($(strip $(RGB_MATRIX_CUSTOM_KB)), yes)
@@ -233,11 +233,37 @@ ifeq ($(strip $(BACKLIGHT_ENABLE)), yes)
ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
CIE1931_CURVE = yes
endif
ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes)
COMMON_VPATH += $(QUANTUM_DIR)/backlight
SRC += $(QUANTUM_DIR)/backlight/backlight.c
OPT_DEFS += -DBACKLIGHT_ENABLE
ifeq ($(strip $(BACKLIGHT_ENABLE)), custom)
OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER
endif
endif
VALID_WS2812_DRIVER_TYPES := bitbang pwm spi i2c
WS2812_DRIVER ?= bitbang
ifeq ($(strip $(WS2812_DRIVER_REQUIRED)), yes)
ifeq ($(filter $(WS2812_DRIVER),$(VALID_WS2812_DRIVER_TYPES)),)
$(error WS2812_DRIVER="$(WS2812_DRIVER)" is not a valid WS2812 driver)
endif
ifeq ($(strip $(WS2812_DRIVER)), bitbang)
SRC += ws2812.c
else
SRC += ws2812_$(strip $(WS2812_DRIVER)).c
endif
# add extra deps
ifeq ($(strip $(WS2812_DRIVER)), i2c)
QUANTUM_LIB_SRC += i2c_master.c
endif
endif
ifeq ($(strip $(CIE1931_CURVE)), yes)
OPT_DEFS += -DUSE_CIE1931_CURVE
LED_TABLES = yes
@@ -262,6 +288,10 @@ ifeq ($(strip $(USB_HID_ENABLE)), yes)
include $(TMK_DIR)/protocol/usb_hid.mk
endif
ifeq ($(strip $(WEBUSB_ENABLE)), yes)
SRC += $(TMK_DIR)/common/webusb.c
endif
ifeq ($(strip $(ENCODER_ENABLE)), yes)
SRC += $(QUANTUM_DIR)/encoder.c
OPT_DEFS += -DENCODER_ENABLE

1
drivers/arm/ws2812.c Normal file
View File

@@ -0,0 +1 @@
#error("NOT SUPPORTED")

1
drivers/arm/ws2812_pwm.c Normal file
View File

@@ -0,0 +1 @@
#error("NOT SUPPORTED")

1
drivers/arm/ws2812_spi.c Normal file
View File

@@ -0,0 +1 @@
#error("NOT SUPPORTED")

33
drivers/avr/ws2812.c
View File

@@ -25,13 +25,17 @@
#include <avr/interrupt.h>
#include <avr/io.h>
#include <util/delay.h>
#include "debug.h"
#if !defined(LED_ARRAY) && defined(RGB_MATRIX_ENABLE)
// LED color buffer
LED_TYPE led[DRIVER_LED_TOTAL];
# define LED_ARRAY led
#endif
/*
* Forward declare internal functions
*
* The functions take a byte-array and send to the data output as WS2812 bitstream.
* The length is the number of bytes to send - three per LED.
*/
void ws2812_sendarray(uint8_t *array, uint16_t length);
void ws2812_sendarray_mask(uint8_t *array, uint16_t length, uint8_t pinmask);
#ifdef RGBW_BB_TWI
@@ -135,23 +139,6 @@ unsigned char I2C_Write(unsigned char c) {
#endif
#ifdef RGB_MATRIX_ENABLE
// Set an led in the buffer to a color
void inline ws2812_setled(int i, uint8_t r, uint8_t g, uint8_t b) {
led[i].r = r;
led[i].g = g;
led[i].b = b;
}
void ws2812_setled_all(uint8_t r, uint8_t g, uint8_t b) {
for (int i = 0; i < sizeof(led) / sizeof(led[0]); i++) {
led[i].r = r;
led[i].g = g;
led[i].b = b;
}
}
#endif
// Setleds for standard RGB
void inline ws2812_setleds(LED_TYPE *ledarray, uint16_t leds) {
// ws2812_setleds_pin(ledarray,leds, _BV(ws2812_pin));

35
drivers/avr/ws2812.h
View File

@@ -20,13 +20,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef LIGHT_WS2812_H_
#define LIGHT_WS2812_H_
#include <avr/io.h>
#include <avr/interrupt.h>
//#include "ws2812_config.h"
//#include "i2cmaster.h"
#pragma once
#include "quantum/color.h"
@@ -42,33 +36,6 @@
* - Send out the LED data
* - Wait 50<35>s to reset the LEDs
*/
#ifdef RGB_MATRIX_ENABLE
void ws2812_setled(int index, uint8_t r, uint8_t g, uint8_t b);
void ws2812_setled_all(uint8_t r, uint8_t g, uint8_t b);
#endif
void ws2812_setleds(LED_TYPE *ledarray, uint16_t number_of_leds);
void ws2812_setleds_pin(LED_TYPE *ledarray, uint16_t number_of_leds, uint8_t pinmask);
void ws2812_setleds_rgbw(LED_TYPE *ledarray, uint16_t number_of_leds);
/*
* Old interface / Internal functions
*
* The functions take a byte-array and send to the data output as WS2812 bitstream.
* The length is the number of bytes to send - three per LED.
*/
void ws2812_sendarray(uint8_t *array, uint16_t length);
void ws2812_sendarray_mask(uint8_t *array, uint16_t length, uint8_t pinmask);
/*
* Internal defines
*/
#ifndef CONCAT
# define CONCAT(a, b) a##b
#endif
#ifndef CONCAT_EXP
# define CONCAT_EXP(a, b) CONCAT(a, b)
#endif
#endif /* LIGHT_WS2812_H_ */

31
drivers/avr/ws2812_i2c.c Normal file
View File

@@ -0,0 +1,31 @@
#include "ws2812.h"
#include "i2c_master.h"
#ifndef WS2812_ADDRESS
# define WS2812_ADDRESS 0xb0
#endif
#ifndef WS2812_TIMEOUT
# define WS2812_TIMEOUT 100
#endif
void ws2812_init(void) { i2c_init(); }
// Setleds for standard RGB
void ws2812_setleds(LED_TYPE *ledarray, uint16_t leds) {
static bool s_init = false;
if (!s_init) {
ws2812_init();
s_init = true;
}
i2c_transmit(WS2812_ADDRESS, (uint8_t *)ledarray, sizeof(LED_TYPE) * leds, WS2812_TIMEOUT);
}
// Setleds for SK6812RGBW
void ws2812_setleds_rgbw(LED_TYPE *ledarray, uint16_t leds) {
// not supported - for now error out if its enabled
#ifdef RGBW
# error "RGBW not supported"
#endif
}

11
drivers/haptic/DRV2605L.c
View File

@@ -114,6 +114,17 @@ void DRV_init(void) {
DRV_write(DRV_GO, 0x01);
}
void DRV_rtp_init(void) {
DRV_write(DRV_GO, 0x00);
DRV_write(DRV_RTP_INPUT, 20); //20 is the lowest value I've found where haptics can still be felt.
DRV_write(DRV_MODE, 0x05);
DRV_write(DRV_GO, 0x01);
}
void DRV_amplitude(uint8_t amplitude) {
DRV_write(DRV_RTP_INPUT, amplitude);
}
void DRV_pulse(uint8_t sequence) {
DRV_write(DRV_GO, 0x00);
DRV_write(DRV_WAVEFORM_SEQ_1, sequence);

2
drivers/haptic/DRV2605L.h
View File

@@ -170,6 +170,8 @@
void DRV_init(void);
void DRV_write(const uint8_t drv_register, const uint8_t settings);
uint8_t DRV_read(const uint8_t regaddress);
void DRV_rtp_init(void);
void DRV_amplitude(const uint8_t amplitude);
void DRV_pulse(const uint8_t sequence);
typedef enum DRV_EFFECT {

67
drivers/haptic/haptic.c
View File

@@ -168,6 +168,15 @@ void haptic_set_mode(uint8_t mode) {
xprintf("haptic_config.mode = %u\n", haptic_config.mode);
}
void haptic_set_amplitude(uint8_t amp) {
haptic_config.amplitude = amp;
eeconfig_update_haptic(haptic_config.raw);
xprintf("haptic_config.amplitude = %u\n", haptic_config.amplitude);
#ifdef DRV2605L
DRV_amplitude(amp);
#endif
}
void haptic_set_buzz(uint8_t buzz) {
haptic_config.buzz = buzz;
eeconfig_update_haptic(haptic_config.raw);
@@ -201,6 +210,53 @@ uint8_t haptic_get_dwell(void) {
return haptic_config.dwell;
}
void haptic_enable_continuous(void) {
haptic_config.cont = 1;
xprintf("haptic_config.cont = %u\n", haptic_config.cont);
eeconfig_update_haptic(haptic_config.raw);
#ifdef DRV2605L
DRV_rtp_init();
#endif
}
void haptic_disable_continuous(void) {
haptic_config.cont = 0;
xprintf("haptic_config.cont = %u\n", haptic_config.cont);
eeconfig_update_haptic(haptic_config.raw);
#ifdef DRV2605L
DRV_write(DRV_MODE,0x00);
#endif
}
void haptic_toggle_continuous(void) {
#ifdef DRV2605L
if (haptic_config.cont) {
haptic_disable_continuous();
} else {
haptic_enable_continuous();
}
eeconfig_update_haptic(haptic_config.raw);
#endif
}
void haptic_cont_increase(void) {
uint8_t amp = haptic_config.amplitude + 10;
if (haptic_config.amplitude >= 120) {
amp = 120;
}
haptic_set_amplitude(amp);
}
void haptic_cont_decrease(void) {
uint8_t amp = haptic_config.amplitude - 10;
if (haptic_config.amplitude < 20) {
amp = 20;
}
haptic_set_amplitude(amp);
}
void haptic_play(void) {
#ifdef DRV2605L
uint8_t play_eff = 0;
@@ -213,6 +269,7 @@ void haptic_play(void) {
}
bool process_haptic(uint16_t keycode, keyrecord_t *record) {
if (keycode == HPT_ON && record->event.pressed) {
haptic_enable();
}
@@ -243,6 +300,16 @@ bool process_haptic(uint16_t keycode, keyrecord_t *record) {
if (keycode == HPT_DWLD && record->event.pressed) {
haptic_dwell_decrease();
}
if (keycode == HPT_CONT && record->event.pressed) {
haptic_toggle_continuous();
}
if (keycode == HPT_CONI && record->event.pressed) {
haptic_cont_increase();
}
if (keycode == HPT_COND && record->event.pressed) {
haptic_cont_decrease();
}
if (haptic_config.enable) {
if (record->event.pressed) {
// keypress

17
drivers/haptic/haptic.h
View File

@@ -34,12 +34,14 @@
typedef union {
uint32_t raw;
struct {
bool enable : 1;
uint8_t feedback : 2;
uint8_t mode : 7;
bool buzz : 1;
uint8_t dwell : 7;
uint16_t reserved : 16;
bool enable :1;
uint8_t feedback :2;
uint8_t mode :7;
bool buzz :1;
uint8_t dwell :7;
bool cont :1;
uint8_t amplitude :8;
uint16_t reserved :7;
};
} haptic_config_t;
@@ -71,6 +73,9 @@ uint8_t haptic_get_mode(void);
uint8_t haptic_get_feedback(void);
void haptic_dwell_increase(void);
void haptic_dwell_decrease(void);
void haptic_toggle_continuous(void);
void haptic_cont_increase(void);
void haptic_cont_decrease(void);
void haptic_play(void);
void haptic_shutdown(void);

5
keyboards/ergodox_ez/config.h
View File

@@ -25,9 +25,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define VENDOR_ID 0xFEED
#define PRODUCT_ID 0x1307
#define DEVICE_VER 0x0001
#define MANUFACTURER ErgoDox EZ
#define PRODUCT ErgoDox EZ
#define MANUFACTURER ZSA
#define PRODUCT Ergodox EZ
#define DESCRIPTION QMK keyboard firmware for Ergodox EZ
#define WEBUSB_LANDING_PAGE_URL u8"configure.ergodox-ez.com"
/* key matrix size */
#define MATRIX_ROWS 14

65
keyboards/ergodox_ez/ergodox_ez.c
View File

@@ -1,5 +1,9 @@
#include QMK_KEYBOARD_H
#ifdef WEBUSB_ENABLE
#include "webusb.h"
#endif
extern inline void ergodox_board_led_on(void);
extern inline void ergodox_right_led_1_on(void);
extern inline void ergodox_right_led_2_on(void);
@@ -336,6 +340,17 @@ void keyboard_post_init_kb(void) {
bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
#ifdef WEBUSB_ENABLE
if(webusb_state.paired == true) {
uint8_t event[5];
event[0] = WEBUSB_STATUS_OK;
event[1] = record->event.pressed ? WEBUSB_EVT_KEYDOWN : WEBUSB_EVT_KEYUP;
event[2] = record->event.key.col;
event[3] = record->event.key.row;
event[4] = WEBUSB_STOP_BIT;
webusb_send(event, sizeof(event));
}
#endif
switch (keycode) {
case LED_LEVEL:
if (record->event.pressed) {
@@ -387,3 +402,53 @@ void eeconfig_init_kb(void) { // EEPROM is getting reset!
eeconfig_update_kb(keyboard_config.raw);
eeconfig_init_user();
}
#ifdef WEBUSB_ENABLE
static uint16_t loops = 0;
static bool is_on = false;
void matrix_scan_kb(void) {
if(webusb_state.pairing == true) {
if(loops == 0) {
ergodox_right_led_1_off();
ergodox_right_led_2_off();
ergodox_right_led_3_off();
}
if(loops % WEBUSB_BLINK_STEPS == 0) {
if(is_on) {
ergodox_right_led_2_off();
}
else {
ergodox_right_led_2_on();
}
is_on ^= 1;
}
if(loops > WEBUSB_BLINK_END) {
webusb_state.pairing = false;
layer_state_set_user(layer_state);
loops = 0;
}
loops++;
}
else if(loops > 0) {
loops = 0;
layer_state_set_user(layer_state);
}
matrix_scan_user();
}
uint32_t layer_state_set_kb(uint32_t state) {
state = layer_state_set_user(state);
uint8_t layer = biton32(state);
if(webusb_state.paired == true) {
uint8_t event[4];
event[0] = WEBUSB_STATUS_OK;
event[1] = WEBUSB_EVT_LAYER;
event[2] = layer;
event[3] = WEBUSB_STOP_BIT;
webusb_send(event, sizeof(event));
}
return state;
}
#endif

1
keyboards/ergodox_ez/keymaps/webusb/default.png.md Normal file
View File

@@ -0,0 +1 @@
https://i.imgur.com/fKX0Zbs.png

1
keyboards/ergodox_ez/keymaps/webusb/default_highres.png.md Normal file
View File

@@ -0,0 +1 @@
https://i.imgur.com/giAc3M9.jpg

147
keyboards/ergodox_ez/keymaps/webusb/keymap.c Normal file
View File

@@ -0,0 +1,147 @@
#include QMK_KEYBOARD_H
#include "version.h"
#include "keymap_german.h"
#include "keymap_nordic.h"
#include "keymap_french.h"
#include "keymap_spanish.h"
#include "keymap_hungarian.h"
#include "keymap_swedish.h"
#include "keymap_br_abnt2.h"
#include "keymap_canadian_multilingual.h"
#include "keymap_german_ch.h"
#include "keymap_jp.h"
#define KC_MAC_UNDO LGUI(KC_Z)
#define KC_MAC_CUT LGUI(KC_X)
#define KC_MAC_COPY LGUI(KC_C)
#define KC_MAC_PASTE LGUI(KC_V)
#define KC_PC_UNDO LCTL(KC_Z)
#define KC_PC_CUT LCTL(KC_X)
#define KC_PC_COPY LCTL(KC_C)
#define KC_PC_PASTE LCTL(KC_V)
#define ES_LESS_MAC KC_GRAVE
#define ES_GRTR_MAC LSFT(KC_GRAVE)
#define ES_BSLS_MAC ALGR(KC_6)
enum custom_keycodes {
RGB_SLD = EZ_SAFE_RANGE,
HSV_172_255_255,
HSV_86_255_128,
HSV_27_255_255,
};
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[0] = LAYOUT_ergodox_pretty(
WEBUSB_PAIR, KC_1, KC_2, KC_3, KC_4, KC_5, KC_LEFT, KC_RIGHT, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINUS,
KC_DELETE, KC_Q, KC_W, KC_E, KC_R, KC_T, TG(1), TG(1), KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSLASH,
KC_BSPACE, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, LT(2,KC_SCOLON),LGUI_T(KC_QUOTE),
KC_LSHIFT, LCTL_T(KC_Z), KC_X, KC_C, KC_V, KC_B, KC_HYPR, KC_MEH, KC_N, KC_M, KC_COMMA, KC_DOT, RCTL_T(KC_SLASH),KC_RSHIFT,
LT(1,KC_GRAVE), KC_QUOTE, LALT(KC_LSHIFT),KC_LEFT, KC_RIGHT, KC_UP, KC_DOWN, KC_LBRACKET, KC_RBRACKET, MO(1),
LALT_T(KC_APPLICATION),KC_LGUI, KC_LALT, LCTL_T(KC_ESCAPE),
KC_HOME, KC_PGUP,
KC_SPACE, KC_BSPACE, KC_END, KC_PGDOWN, KC_TAB, KC_ENTER
),
[1] = LAYOUT_ergodox_pretty(
KC_ESCAPE, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_TRANSPARENT, KC_TRANSPARENT, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11,
KC_TRANSPARENT, KC_EXLM, KC_AT, KC_LCBR, KC_RCBR, KC_PIPE, KC_TRANSPARENT, KC_TRANSPARENT, KC_UP, KC_7, KC_8, KC_9, KC_ASTR, KC_F12,
KC_TRANSPARENT, KC_HASH, KC_DLR, KC_LPRN, KC_RPRN, KC_GRAVE, KC_DOWN, KC_4, KC_5, KC_6, KC_PLUS, KC_TRANSPARENT,
KC_TRANSPARENT, KC_PERC, KC_CIRC, KC_LBRACKET, KC_RBRACKET, KC_TILD, KC_TRANSPARENT, KC_TRANSPARENT, KC_AMPR, KC_1, KC_2, KC_3, KC_BSLASH, KC_TRANSPARENT,
KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_DOT, KC_0, KC_EQUAL, KC_TRANSPARENT,
RGB_MOD, HSV_172_255_255,RGB_TOG, RGB_SLD,
HSV_86_255_128, KC_TRANSPARENT,
RGB_VAD, RGB_VAI, HSV_27_255_255, KC_TRANSPARENT, RGB_HUD, RGB_HUI
),
[2] = LAYOUT_ergodox_pretty(
KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_MS_UP, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
KC_TRANSPARENT, KC_TRANSPARENT, KC_MS_LEFT, KC_MS_DOWN, KC_MS_RIGHT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_MEDIA_PLAY_PAUSE,
KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_MEDIA_PREV_TRACK,KC_MEDIA_NEXT_TRACK,KC_TRANSPARENT, KC_TRANSPARENT,
KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_MS_BTN1, KC_MS_BTN2, KC_AUDIO_VOL_UP,KC_AUDIO_VOL_DOWN,KC_AUDIO_MUTE, KC_TRANSPARENT, KC_TRANSPARENT,
KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
KC_TRANSPARENT, KC_TRANSPARENT,
KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_WWW_BACK
),
};
bool suspended = false;
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case RGB_SLD:
if (record->event.pressed) {
rgblight_mode(1);
}
return false;
case HSV_172_255_255:
if (record->event.pressed) {
#ifdef RGBLIGHT_ENABLE
rgblight_enable();
rgblight_mode(1);
rgblight_sethsv(172,255,255);
#endif
}
return false;
case HSV_86_255_128:
if (record->event.pressed) {
#ifdef RGBLIGHT_ENABLE
rgblight_enable();
rgblight_mode(1);
rgblight_sethsv(86,255,128);
#endif
}
return false;
case HSV_27_255_255:
if (record->event.pressed) {
#ifdef RGBLIGHT_ENABLE
rgblight_enable();
rgblight_mode(1);
rgblight_sethsv(27,255,255);
#endif
}
return false;
}
return true;
}
uint32_t layer_state_set_user(uint32_t state) {
uint8_t layer = biton32(state);
ergodox_board_led_off();
ergodox_right_led_1_off();
ergodox_right_led_2_off();
ergodox_right_led_3_off();
switch (layer) {
case 1:
ergodox_right_led_1_on();
break;
case 2:
ergodox_right_led_2_on();
break;
case 3:
ergodox_right_led_3_on();
break;
case 4:
ergodox_right_led_1_on();
ergodox_right_led_2_on();
break;
case 5:
ergodox_right_led_1_on();
ergodox_right_led_3_on();
break;
case 6:
ergodox_right_led_2_on();
ergodox_right_led_3_on();
break;
case 7:
ergodox_right_led_1_on();
ergodox_right_led_2_on();
ergodox_right_led_3_on();
break;
default:
break;
}
return state;
};

15
keyboards/ergodox_ez/keymaps/webusb/readme.md Normal file
View File

@@ -0,0 +1,15 @@
# ErgoDox EZ Default Configuration
## Changelog
* Dec 2016:
* Added LED keys
* Refreshed layout graphic, comes from http://configure.ergodox-ez.com now.
* Sep 22, 2016:
* Created a new key in layer 1 (bottom-corner key) that resets the EEPROM.
* Feb 2, 2016 (V1.1):
* Made the right-hand quote key double as Cmd/Win on hold. So you get ' when you tap it, " when you tap it with Shift, and Cmd or Win when you hold it. You can then use it as a modifier, or just press and hold it for a moment (and then let go) to send a single Cmd or Win keystroke (handy for opening the Start menu on Windows).
This is what we ship with out of the factory. :) The image says it all:
![Default](https://i.imgur.com/Be53jH7.png)

1
keyboards/ergodox_ez/keymaps/webusb/rules.mk Normal file
View File

@@ -0,0 +1 @@
WEBUSB_ENABLE = yes

31
keyboards/ergodox_ez/matrix.c
View File

@@ -35,9 +35,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "matrix.h"
#include "debounce.h"
#include QMK_KEYBOARD_H
#ifdef DEBUG_MATRIX_SCAN_RATE
# include "timer.h"
#endif
/*
* This constant define not debouncing time in msecs, assuming eager_pr.
@@ -67,11 +64,6 @@ static void select_row(uint8_t row);
static uint8_t mcp23018_reset_loop;
// static uint16_t mcp23018_reset_loop;
#ifdef DEBUG_MATRIX_SCAN_RATE
uint32_t matrix_timer;
uint32_t matrix_scan_count;
#endif
__attribute__((weak)) void matrix_init_user(void) {}
__attribute__((weak)) void matrix_scan_user(void) {}
@@ -98,10 +90,6 @@ void matrix_init(void) {
raw_matrix[i] = 0;
}
#ifdef DEBUG_MATRIX_SCAN_RATE
matrix_timer = timer_read32();
matrix_scan_count = 0;
#endif
debounce_init(MATRIX_ROWS);
matrix_init_quantum();
}
@@ -116,11 +104,6 @@ void matrix_power_up(void) {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = 0;
}
#ifdef DEBUG_MATRIX_SCAN_RATE
matrix_timer = timer_read32();
matrix_scan_count = 0;
#endif
}
// Reads and stores a row, returning
@@ -151,20 +134,6 @@ uint8_t matrix_scan(void) {
}
}
#ifdef DEBUG_MATRIX_SCAN_RATE
matrix_scan_count++;
uint32_t timer_now = timer_read32();
if (TIMER_DIFF_32(timer_now, matrix_timer) > 1000) {
print("matrix scan frequency: ");
pdec(matrix_scan_count);
print("\n");
matrix_timer = timer_now;
matrix_scan_count = 0;
}
#endif
#ifdef LEFT_LEDS
mcp23018_status = ergodox_left_leds_update();
#endif // LEFT_LEDS

5
keyboards/planck/ez/config.h
View File

@@ -18,7 +18,12 @@
#pragma once
/* USB Device descriptor parameter */
#undef MANUFACTURER
#define MANUFACTURER ZSA
#undef PRODUCT
#define PRODUCT Planck EZ
#define DEVICE_VER 0x0000
#define WEBUSB_LANDING_PAGE_URL u8"configure.ergodox-ez.com"
#undef MATRIX_ROWS
#undef MATRIX_COLS

59
keyboards/planck/ez/ez.c
View File

@@ -16,6 +16,9 @@
#include "ez.h"
#include "ch.h"
#include "hal.h"
#ifdef WEBUSB_ENABLE
#include "webusb.h"
#endif
keyboard_config_t keyboard_config;
@@ -247,6 +250,16 @@ uint32_t layer_state_set_kb(uint32_t state) {
planck_ez_right_led_off();
state = layer_state_set_user(state);
uint8_t layer = biton32(state);
#ifdef WEBUSB_ENABLE
if(webusb_state.paired == true) {
uint8_t event[4];
event[0] = WEBUSB_STATUS_OK;
event[1] = WEBUSB_EVT_LAYER;
event[2] = layer;
event[3] = WEBUSB_STOP_BIT;
webusb_send(event, sizeof(event));
}
#endif
switch (layer) {
case 1:
planck_ez_left_led_on();
@@ -265,6 +278,17 @@ uint32_t layer_state_set_kb(uint32_t state) {
}
bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
#ifdef WEBUSB_ENABLE
if(webusb_state.paired == true) {
uint8_t event[5];
event[0] = WEBUSB_STATUS_OK;
event[1] = record->event.pressed ? WEBUSB_EVT_KEYDOWN : WEBUSB_EVT_KEYUP;
event[2] = record->event.key.col;
event[3] = record->event.key.row;
event[4] = WEBUSB_STOP_BIT;
webusb_send(event, sizeof(event));
}
#endif
switch (keycode) {
case LED_LEVEL:
if (record->event.pressed) {
@@ -325,3 +349,38 @@ bool music_mask_kb(uint16_t keycode) {
}
}
#endif
#ifdef WEBUSB_ENABLE
static uint16_t loops = 0;
static bool is_on = false;
void matrix_scan_kb(void) {
if(webusb_state.pairing == true) {
if(loops == 0) {
//lights off
}
if(loops % WEBUSB_BLINK_STEPS == 0) {
if(is_on) {
planck_ez_left_led_on();
planck_ez_right_led_off();
}
else {
planck_ez_left_led_off();
planck_ez_right_led_on();
}
is_on ^= 1;
}
if(loops > WEBUSB_BLINK_END * 2) {
webusb_state.pairing = false;
loops = 0;
planck_ez_left_led_off();
planck_ez_right_led_off();
}
loops++;
}
else if(loops > 0) {
loops = 0;
planck_ez_left_led_off();
planck_ez_right_led_off();
}
}
#endif

39
keyboards/planck/keymaps/webusb/config.h Normal file
View File

@@ -0,0 +1,39 @@
#pragma once
#ifdef AUDIO_ENABLE
#define STARTUP_SONG SONG(PLANCK_SOUND)
// #define STARTUP_SONG SONG(NO_SOUND)
#define DEFAULT_LAYER_SONGS { SONG(QWERTY_SOUND), \
SONG(COLEMAK_SOUND), \
SONG(DVORAK_SOUND) \
}
#endif
/*
* 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 2
// Most tactile encoders have detents every 4 stages
#define ENCODER_RESOLUTION 4

136
keyboards/planck/keymaps/webusb/keymap.c Normal file
View File

@@ -0,0 +1,136 @@
#include QMK_KEYBOARD_H
#ifdef AUDIO_ENABLE
#include "muse.h"
#endif
#include "eeprom.h"
#include "keymap_german.h"
#include "keymap_nordic.h"
#include "keymap_french.h"
#include "keymap_spanish.h"
#include "keymap_hungarian.h"
#include "keymap_swedish.h"
#include "keymap_br_abnt2.h"
#include "keymap_canadian_multilingual.h"
#include "keymap_german_ch.h"
#include "keymap_jp.h"
#define KC_MAC_UNDO LGUI(KC_Z)
#define KC_MAC_CUT LGUI(KC_X)
#define KC_MAC_COPY LGUI(KC_C)
#define KC_MAC_PASTE LGUI(KC_V)
#define KC_PC_UNDO LCTL(KC_Z)
#define KC_PC_CUT LCTL(KC_X)
#define KC_PC_COPY LCTL(KC_C)
#define KC_PC_PASTE LCTL(KC_V)
#define ES_LESS_MAC KC_GRAVE
#define ES_GRTR_MAC LSFT(KC_GRAVE)
#define ES_BSLS_MAC ALGR(KC_6)
enum planck_keycodes {
RGB_SLD = EZ_SAFE_RANGE,
};
enum planck_layers {
_BASE,
_LOWER,
_RAISE,
_ADJUST,
};
#define LOWER MO(_LOWER)
#define RAISE MO(_RAISE)
#define LOWER MO(_LOWER)
#define RAISE MO(_RAISE)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_BASE] = LAYOUT_planck_grid(KC_TAB,KC_Q,KC_W,KC_E,KC_R,KC_T,KC_Y,KC_U,KC_I,KC_O,KC_P,KC_BSPACE,KC_ESCAPE,KC_A,KC_S,KC_D,KC_F,KC_G,KC_H,KC_J,KC_K,KC_L,KC_SCOLON,KC_QUOTE,KC_LSHIFT,KC_Z,KC_X,KC_C,KC_V,KC_B,KC_N,KC_M,KC_COMMA,KC_DOT,KC_SLASH,KC_ENTER,KC_HYPR,KC_LCTRL,KC_LALT,KC_LGUI,LOWER,KC_SPACE,KC_NO,RAISE,KC_LEFT,KC_DOWN,KC_UP,KC_RIGHT),
[_LOWER] = LAYOUT_planck_grid(KC_TILD,KC_EXLM,KC_AT,KC_HASH,KC_DLR,KC_PERC,KC_CIRC,KC_AMPR,KC_ASTR,KC_LPRN,KC_RPRN,KC_TRANSPARENT,KC_DELETE,KC_F1,KC_F2,KC_F3,KC_F4,KC_F5,KC_F6,KC_UNDS,KC_PLUS,KC_LCBR,KC_RCBR,KC_PIPE,KC_TRANSPARENT,KC_F7,KC_F8,KC_F9,KC_F10,KC_F11,KC_F12,KC_NONUS_HASH,KC_NONUS_BSLASH,KC_HOME,KC_END,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_NO,KC_TRANSPARENT,KC_MEDIA_NEXT_TRACK,KC_AUDIO_VOL_DOWN,KC_AUDIO_VOL_UP,KC_MEDIA_PLAY_PAUSE),
[_RAISE] = LAYOUT_planck_grid(KC_GRAVE,KC_1,KC_2,KC_3,KC_4,KC_5,KC_6,KC_7,KC_8,KC_9,KC_0,KC_TRANSPARENT,KC_DELETE,KC_F1,KC_F2,KC_F3,KC_F4,KC_F5,KC_F6,KC_MINUS,KC_EQUAL,KC_LBRACKET,KC_RBRACKET,KC_BSLASH,KC_TRANSPARENT,KC_F7,KC_F8,KC_F9,KC_F10,KC_F11,KC_F12,KC_NONUS_HASH,KC_NONUS_BSLASH,KC_PGUP,KC_PGDOWN,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_NO,KC_TRANSPARENT,KC_MEDIA_NEXT_TRACK,KC_AUDIO_VOL_DOWN,KC_AUDIO_VOL_UP,KC_MEDIA_PLAY_PAUSE),
[_ADJUST] = LAYOUT_planck_grid(WEBUSB_PAIR,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_DELETE,KC_TRANSPARENT,AU_ON,AU_OFF,AU_TOG,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,RESET,KC_TRANSPARENT,KC_TRANSPARENT,MU_ON,MU_OFF,MU_TOG,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_NO,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT),
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
}
return true;
}
#ifdef AUDIO_ENABLE
bool muse_mode = false;
uint8_t last_muse_note = 0;
uint16_t muse_counter = 0;
uint8_t muse_offset = 70;
uint16_t muse_tempo = 50;
void encoder_update(bool clockwise) {
if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) {
if (clockwise) {
muse_offset++;
} else {
muse_offset--;
}
} else {
if (clockwise) {
muse_tempo+=1;
} else {
muse_tempo-=1;
}
}
} else {
if (clockwise) {
#ifdef MOUSEKEY_ENABLE
register_code(KC_MS_WH_DOWN);
unregister_code(KC_MS_WH_DOWN);
#else
register_code(KC_PGDN);
unregister_code(KC_PGDN);
#endif
} else {
#ifdef MOUSEKEY_ENABLE
register_code(KC_MS_WH_UP);
unregister_code(KC_MS_WH_UP);
#else
register_code(KC_PGUP);
unregister_code(KC_PGUP);
#endif
}
}
}
void matrix_scan_user(void) {
#ifdef AUDIO_ENABLE
if (muse_mode) {
if (muse_counter == 0) {
uint8_t muse_note = muse_offset + SCALE[muse_clock_pulse()];
if (muse_note != last_muse_note) {
stop_note(compute_freq_for_midi_note(last_muse_note));
play_note(compute_freq_for_midi_note(muse_note), 0xF);
last_muse_note = muse_note;
}
}
muse_counter = (muse_counter + 1) % muse_tempo;
}
#endif
}
bool music_mask_user(uint16_t keycode) {
switch (keycode) {
case RAISE:
case LOWER:
return false;
default:
return true;
}
}
#endif
uint32_t layer_state_set_user(uint32_t state) {
return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST);
}

2
keyboards/planck/keymaps/webusb/readme.md Normal file
View File

@@ -0,0 +1,2 @@
# The Default Planck Layout

3
keyboards/planck/keymaps/webusb/rules.mk Normal file
View File

@@ -0,0 +1,3 @@
SRC += muse.c
RGB_MATRIX_ENABLE = no
WEBUSB_ENABLE = yes

2
lib/lufa

Submodule lib/lufa updated: ce10f7642b...94e43e4977

120
lib/python/milc.py
View File

@@ -17,6 +17,7 @@ import argparse
import logging
import os
import re
import shlex
import sys
from decimal import Decimal
from tempfile import NamedTemporaryFile
@@ -35,6 +36,10 @@ except ImportError:
import argcomplete
import colorama
from appdirs import user_config_dir
# Disable logging until we can configure it how the user wants
logging.basicConfig(filename='/dev/null')
# Log Level Representations
EMOJI_LOGLEVELS = {
@@ -47,6 +52,7 @@ EMOJI_LOGLEVELS = {
}
EMOJI_LOGLEVELS['FATAL'] = EMOJI_LOGLEVELS['CRITICAL']
EMOJI_LOGLEVELS['WARN'] = EMOJI_LOGLEVELS['WARNING']
UNICODE_SUPPORT = sys.stdout.encoding.lower().startswith('utf')
# ANSI Color setup
# Regex was gratefully borrowed from kfir on stackoverflow:
@@ -97,11 +103,12 @@ class ANSIFormatter(logging.Formatter):
class ANSIEmojiLoglevelFormatter(ANSIFormatter):
"""A log formatter that makes the loglevel an emoji.
"""A log formatter that makes the loglevel an emoji on UTF capable terminals.
"""
def format(self, record):
record.levelname = EMOJI_LOGLEVELS[record.levelname].format(**ansi_colors)
if UNICODE_SUPPORT:
record.levelname = EMOJI_LOGLEVELS[record.levelname].format(**ansi_colors)
return super(ANSIEmojiLoglevelFormatter, self).format(record)
@@ -144,13 +151,15 @@ class Configuration(object):
def __init__(self, *args, **kwargs):
self._config = {}
self.default_container = ConfigurationOption
def __getattr__(self, key):
return self.__getitem__(key)
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()
self.__dict__[key] = self._config[key] = ConfigurationSection(self)
return self._config[key]
@@ -161,30 +170,34 @@ class Configuration(object):
def __delitem__(self, key):
if key in self.__dict__ and key[0] != '_':
del self.__dict__[key]
del self._config[key]
if key in self._config:
del self._config[key]
class ConfigurationOption(Configuration):
def __init__(self, *args, **kwargs):
super(ConfigurationOption, self).__init__(*args, **kwargs)
self.default_container = dict
class ConfigurationSection(Configuration):
def __init__(self, parent, *args, **kwargs):
super(ConfigurationSection, self).__init__(*args, **kwargs)
self.parent = parent
def __getitem__(self, key):
"""Returns a config section, creating it if it doesn't exist yet.
"""Returns a config value, pulling from the `user` section as a fallback.
"""
if key not in self._config:
self.__dict__[key] = self._config[key] = None
if key in self._config:
return self._config[key]
return self._config[key]
elif key in self.parent.user:
return self.parent.user[key]
return None
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['dest'] = self.get_argument_name(*args, **kwargs)
disabled_kwargs['help'] = 'Disable ' + kwargs['help']
kwargs['action'] = 'store_true'
kwargs['help'] = 'Enable ' + kwargs['help']
@@ -219,11 +232,6 @@ class SubparserWrapper(object):
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)
@@ -254,12 +262,16 @@ class MILC(object):
self._entrypoint = None
self._inside_context_manager = False
self.ansi = ansi_colors
self.arg_only = []
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()
# Figure out our program name
self.prog_name = sys.argv[0][:-3] if sys.argv[0].endswith('.py') else sys.argv[0]
self.prog_name = self.prog_name.split('/')[-1]
# Initialize all the things
self.initialize_argparse()
self.initialize_logging()
@@ -273,7 +285,7 @@ class MILC(object):
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.
"""Print colorized text to stdout.
ANSI color strings (such as {fg-blue}) will be converted into ANSI
escape sequences, and the ANSI reset sequence will be added to all
@@ -284,11 +296,10 @@ class MILC(object):
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)
args = args or kwargs
text = format_ansi(text)
print(text % args)
print(text % args)
def initialize_argparse(self):
"""Prepare to process arguments from sys.argv.
@@ -313,21 +324,21 @@ class MILC(object):
self.release_lock()
def completer(self, completer):
"""Add an arpcomplete completer to this subcommand.
"""Add an argcomplete 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 'action' in kwargs and kwargs['action'] == 'store_boolean':
return handle_store_boolean(self, *args, **kwargs)
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)
@@ -396,7 +407,7 @@ class MILC(object):
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))
return os.path.join(user_config_dir(appname='qmk', appauthor='QMK'), '%s.ini' % self.prog_name)
def get_argument_name(self, *args, **kwargs):
"""Takes argparse arguments and returns the dest name.
@@ -413,11 +424,17 @@ class MILC(object):
raise RuntimeError('You must run this before the with statement!')
def argument_function(handler):
if 'arg_only' in kwargs and kwargs['arg_only']:
arg_name = self.get_argument_name(*args, **kwargs)
self.arg_only.append(arg_name)
del kwargs['arg_only']
name = handler.__name__.replace("_", "-")
if handler is self._entrypoint:
self.add_argument(*args, **kwargs)
elif handler.__name__ in self.subcommands:
self.subcommands[handler.__name__].add_argument(*args, **kwargs)
elif name in self.subcommands:
self.subcommands[name].add_argument(*args, **kwargs)
else:
raise RuntimeError('Decorated function is not entrypoint or subcommand!')
@@ -485,15 +502,20 @@ class MILC(object):
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)
if '_' in argument:
section, option = argument.split('_', 1)
else:
if option not in self.config[section]:
self.config[section][option] = getattr(self.args, argument)
section = self._entrypoint.__name__
option = argument
if option not in self.arg_only:
if hasattr(self.args_passed, argument):
arg_value = getattr(self.args, argument)
if arg_value:
self.config[section][option] = arg_value
else:
if option not in self.config[section]:
self.config[section][option] = getattr(self.args, argument)
self.release_lock()
@@ -509,6 +531,8 @@ class MILC(object):
self.acquire_lock()
config = RawConfigParser()
config_dir = os.path.dirname(self.config_file)
for section_name, section in self.config._config.items():
config.add_section(section_name)
for option_name, value in section.items():
@@ -517,7 +541,10 @@ class MILC(object):
continue
config.set(section_name, option_name, str(value))
with NamedTemporaryFile(mode='w', dir=os.path.dirname(self.config_file), delete=False) as tmpfile:
if not os.path.exists(config_dir):
os.makedirs(config_dir)
with NamedTemporaryFile(mode='w', dir=config_dir, delete=False) as tmpfile:
config.write(tmpfile)
# Move the new config file into place atomically
@@ -527,6 +554,7 @@ class MILC(object):
self.log.warning('Config file saving failed, not replacing %s with %s.', self.config_file, tmpfile.name)
self.release_lock()
cli.log.info('Wrote configuration to %s', shlex.quote(self.config_file))
def __call__(self):
"""Execute the entrypoint function.
@@ -572,7 +600,7 @@ class MILC(object):
self.add_subparsers()
if not name:
name = handler.__name__
name = handler.__name__.replace("_", "-")
self.acquire_lock()
kwargs['help'] = description
@@ -602,8 +630,8 @@ class MILC(object):
"""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!')
# MILC is the only thing that should have root log handlers
logging.root.handlers = []
self.acquire_lock()
@@ -648,8 +676,9 @@ class MILC(object):
self.read_config()
self.setup_logging()
if self.config.general.save_config:
if 'save_config' in self.config.general and self.config.general.save_config:
self.save_config()
exit(0)
return self
@@ -712,4 +741,3 @@ if __name__ == '__main__':
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()))

14
lib/python/qmk/cli/__init__.py
View File

@@ -0,0 +1,14 @@
"""QMK CLI Subcommands
We list each subcommand here explicitly because all the reliable ways of searching for modules are slow and delay startup.
"""
from . import cformat
from . import compile
from . import config
from . import doctor
from . import hello
from . import json
from . import list
from . import new
from . import pyformat
from . import pytest

6
lib/python/qmk/cli/cformat.py
View File

@@ -6,9 +6,9 @@ import subprocess
from milc import cli
@cli.argument('files', nargs='*', help='Filename(s) to format.')
@cli.entrypoint("Format C code according to QMK's style.")
def main(cli):
@cli.argument('files', nargs='*', arg_only=True, help='Filename(s) to format.')
@cli.subcommand("Format C code according to QMK's style.")
def cformat(cli):
"""Format C code according to QMK's style.
"""
clang_format = ['clang-format', '-i']

10
lib/python/qmk/cli/compile.py
View File

@@ -14,11 +14,11 @@ import qmk.keymap
import qmk.path
@cli.argument('filename', nargs='?', type=FileType('r'), help='The configurator export to compile')
@cli.argument('filename', nargs='?', arg_only=True, type=FileType('r'), help='The configurator export to compile')
@cli.argument('-kb', '--keyboard', help='The keyboard to build a firmware for. Ignored when a configurator export is supplied.')
@cli.argument('-km', '--keymap', help='The keymap to build a firmware for. Ignored when a configurator export is supplied.')
@cli.entrypoint('Compile a QMK Firmware.')
def main(cli):
@cli.subcommand('Compile a QMK Firmware.')
def compile(cli):
"""Compile a QMK Firmware.
If a Configurator export is supplied this command will create a new keymap, overwriting an existing keymap if one exists.
@@ -41,9 +41,9 @@ def main(cli):
# Compile the keymap
command = ['make', ':'.join((user_keymap['keyboard'], user_keymap['keymap']))]
elif cli.config.general.keyboard and cli.config.general.keymap:
elif cli.config.compile.keyboard and cli.config.compile.keymap:
# Generate the make command for a specific keyboard/keymap.
command = ['make', ':'.join((cli.config.general.keyboard, cli.config.general.keymap))]
command = ['make', ':'.join((cli.config.compile.keyboard, cli.config.compile.keymap))]
else:
cli.log.error('You must supply a configurator export or both `--keyboard` and `--keymap`.')

96
lib/python/qmk/cli/config.py Normal file
View File

@@ -0,0 +1,96 @@
"""Read and write configuration settings
"""
import os
import subprocess
from milc import cli
def print_config(section, key):
"""Print a single config setting to stdout.
"""
cli.echo('%s.%s{fg_cyan}={fg_reset}%s', section, key, cli.config[section][key])
@cli.argument('-ro', '--read-only', action='store_true', help='Operate in read-only mode.')
@cli.argument('configs', nargs='*', arg_only=True, help='Configuration options to read or write.')
@cli.subcommand("Read and write configuration settings.")
def config(cli):
"""Read and write config settings.
This script iterates over the config_tokens supplied as argument. Each config_token has the following form:
section[.key][=value]
If only a section (EG 'compile') is supplied all keys for that section will be displayed.
If section.key is supplied the value for that single key will be displayed.
If section.key=value is supplied the value for that single key will be set.
If section.key=None is supplied the key will be deleted.
No validation is done to ensure that the supplied section.key is actually used by qmk scripts.
"""
if not cli.args.configs:
# Walk the config tree
for section in cli.config:
for key in cli.config[section]:
print_config(section, key)
return True
# Process config_tokens
save_config = False
for argument in cli.args.configs:
# Split on space in case they quoted multiple config tokens
for config_token in argument.split(' '):
# Extract the section, config_key, and value to write from the supplied config_token.
if '=' in config_token:
key, value = config_token.split('=')
else:
key = config_token
value = None
if '.' in key:
section, config_key = key.split('.', 1)
else:
section = key
config_key = None
# Validation
if config_key and '.' in config_key:
cli.log.error('Config keys may not have more than one period! "%s" is not valid.', key)
return False
# Do what the user wants
if section and config_key and value:
# Write a config key
log_string = '%s.%s{fg_cyan}:{fg_reset} %s {fg_cyan}->{fg_reset} %s'
if cli.args.read_only:
log_string += ' {fg_red}(change not written)'
cli.echo(log_string, section, config_key, cli.config[section][config_key], value)
if not cli.args.read_only:
if value == 'None':
del cli.config[section][config_key]
else:
cli.config[section][config_key] = value
save_config = True
elif section and config_key:
# Display a single key
print_config(section, config_key)
elif section:
# Display an entire section
for key in cli.config[section]:
print_config(section, key)
# Ending actions
if save_config:
cli.save_config()
return True

11
lib/python/qmk/cli/doctor.py
View File

@@ -11,8 +11,8 @@ from glob import glob
from milc import cli
@cli.entrypoint('Basic QMK environment checks')
def main(cli):
@cli.subcommand('Basic QMK environment checks')
def doctor(cli):
"""Basic QMK environment checks.
This is currently very simple, it just checks that all the expected binaries are on your system.
@@ -36,6 +36,7 @@ def main(cli):
else:
try:
subprocess.run([binary, '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=5, check=True)
cli.log.info('Found {fg_cyan}%s', binary)
except subprocess.CalledProcessError:
cli.log.error("{fg_red}Can't run `%s --version`", binary)
ok = False
@@ -49,12 +50,12 @@ def main(cli):
elif OS == "Linux":
cli.log.info("Detected {fg_cyan}Linux.")
if shutil.which('systemctl'):
mm_check = subprocess.run(['systemctl', 'list-unit-files'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10)
mm_check = subprocess.run(['systemctl', 'list-unit-files'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10, universal_newlines=True)
if mm_check.returncode == 0:
mm = True
mm = False
for line in mm_check.stdout.split('\n'):
if 'ModemManager' in line and 'enabled' in line:
mm = False
mm = True
if mm:
cli.log.warn("{bg_yellow}Detected ModemManager. Please disable it if you are using a Pro-Micro.")

6
lib/python/qmk/cli/hello.py
View File

@@ -6,8 +6,8 @@ from milc import cli
@cli.argument('-n', '--name', default='World', help='Name to greet.')
@cli.entrypoint('QMK Hello World.')
def main(cli):
@cli.subcommand('QMK Hello World.')
def hello(cli):
"""Log a friendly greeting.
"""
cli.log.info('Hello, %s!', cli.config.general.name)
cli.log.info('Hello, %s!', cli.config.hello.name)

5
lib/python/qmk/cli/json/__init__.py
View File

@@ -0,0 +1,5 @@
"""QMK CLI JSON Subcommands
We list each subcommand here explicitly because all the reliable ways of searching for modules are slow and delay startup.
"""
from . import keymap

20
lib/python/qmk/cli/json/keymap.py
View File

@@ -9,10 +9,10 @@ from milc import cli
import qmk.keymap
@cli.argument('-o', '--output', help='File to write to')
@cli.argument('filename', help='Configurator JSON file')
@cli.entrypoint('Create a keymap.c from a QMK Configurator export.')
def main(cli):
@cli.argument('-o', '--output', arg_only=True, help='File to write to')
@cli.argument('filename', arg_only=True, help='Configurator JSON file')
@cli.subcommand('Create a keymap.c from a QMK Configurator export.')
def json_keymap(cli):
"""Generate a keymap.c from a configurator export.
This command uses the `qmk.keymap` module to generate a keymap.c from a configurator export. The generated keymap is written to stdout, or to a file if -o is provided.
@@ -28,8 +28,8 @@ def main(cli):
exit(1)
# Environment processing
if cli.config.general.output == ('-'):
cli.config.general.output = None
if cli.args.output == ('-'):
cli.args.output = None
# Parse the configurator json
with open(qmk.path.normpath(cli.args.filename), 'r') as fd:
@@ -38,17 +38,17 @@ def main(cli):
# Generate the keymap
keymap_c = qmk.keymap.generate(user_keymap['keyboard'], user_keymap['layout'], user_keymap['layers'])
if cli.config.general.output:
output_dir = os.path.dirname(cli.config.general.output)
if cli.args.output:
output_dir = os.path.dirname(cli.args.output)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
output_file = qmk.path.normpath(cli.config.general.output)
output_file = qmk.path.normpath(cli.args.output)
with open(output_file, 'w') as keymap_fd:
keymap_fd.write(keymap_c)
cli.log.info('Wrote keymap to %s.', cli.config.general.output)
cli.log.info('Wrote keymap to %s.', cli.args.output)
else:
print(keymap_c)

1
lib/python/qmk/cli/list/__init__.py Normal file
View File

@@ -0,0 +1 @@
from . import keyboards

26
lib/python/qmk/cli/list/keyboards.py Normal file
View File

@@ -0,0 +1,26 @@
"""List the keyboards currently defined within QMK
"""
import os
import re
import glob
from milc import cli
@cli.subcommand("List the keyboards currently defined within QMK")
def list_keyboards(cli):
"""List the keyboards currently defined within QMK
"""
base_path = os.path.join(os.getcwd(), "keyboards") + os.path.sep
kb_path_wildcard = os.path.join(base_path, "**", "rules.mk")
# find everywhere we have rules.mk where keymaps isn't in the path
paths = [path for path in glob.iglob(kb_path_wildcard, recursive=True) if 'keymaps' not in path]
# strip the keyboard directory path prefix and rules.mk suffix and alphabetize
find_name = lambda path: path.replace(base_path, "").replace(os.path.sep + "rules.mk", "")
names = sorted(map(find_name, paths))
for name in names:
# We echo instead of cli.log.info to allow easier piping of this output
cli.echo(name)

1
lib/python/qmk/cli/new/__init__.py
View File

@@ -0,0 +1 @@
from . import keymap

21
lib/python/qmk/cli/new/keymap.py
View File

@@ -6,20 +6,20 @@ import shutil
from milc import cli
@cli.argument('-k', '--keyboard', help='Specify keyboard name. Example: 1upkeyboards/1up60hse')
@cli.argument('-u', '--username', help='Specify any name for the new keymap directory')
@cli.entrypoint('Creates a new keymap for the keyboard of your choosing')
def main(cli):
@cli.argument('-kb', '--keyboard', help='Specify keyboard name. Example: 1upkeyboards/1up60hse')
@cli.argument('-km', '--keymap', help='Specify the name for the new keymap directory')
@cli.subcommand('Creates a new keymap for the keyboard of your choosing')
def new_keymap(cli):
"""Creates a new keymap for the keyboard of your choosing.
"""
# ask for user input if keyboard or username was not provided in the command line
keyboard = cli.config.general.keyboard if cli.config.general.keyboard else input("Keyboard Name: ")
username = cli.config.general.username if cli.config.general.username else input("Username: ")
# ask for user input if keyboard or keymap was not provided in the command line
keyboard = cli.config.new_keymap.keyboard if cli.config.new_keymap.keyboard else input("Keyboard Name: ")
keymap = cli.config.new_keymap.keymap if cli.config.new_keymap.keymap else input("Keymap Name: ")
# generate keymap paths
kb_path = os.path.join(os.getcwd(), "keyboards", keyboard)
keymap_path_default = os.path.join(kb_path, "keymaps/default")
keymap_path = os.path.join(kb_path, "keymaps/%s" % username)
keymap_path = os.path.join(kb_path, "keymaps/%s" % keymap)
# check directories
if not os.path.exists(kb_path):
@@ -36,6 +36,5 @@ def main(cli):
shutil.copytree(keymap_path_default, keymap_path, symlinks=True)
# end message to user
cli.log.info("%s keymap directory created in: %s\n" +
"Compile a firmware file with your new keymap by typing: \n" +
"qmk compile -kb %s -km %s", username, keymap_path, keyboard, username)
cli.log.info("%s keymap directory created in: %s", keymap, keymap_path)
cli.log.info("Compile a firmware with your new keymap by typing: \n" + "qmk compile -kb %s -km %s", keyboard, keymap)

5
lib/python/qmk/cli/pyformat.py
View File

@@ -5,12 +5,13 @@ from milc import cli
import subprocess
@cli.entrypoint("Format python code according to QMK's style.")
def main(cli):
@cli.subcommand("Format python code according to QMK's style.")
def pyformat(cli):
"""Format python code according to QMK's style.
"""
try:
subprocess.run(['yapf', '-vv', '-ri', 'bin/qmk', 'lib/python'], check=True)
cli.log.info('Successfully formatted the python code in `bin/qmk` and `lib/python`.')
except subprocess.CalledProcessError:
cli.log.error('Error formatting python code!')

8
lib/python/qmk/cli/nose2.py → lib/python/qmk/cli/pytest.py
View File

@@ -2,17 +2,19 @@
QMK script to run unit and integration tests against our python code.
"""
import sys
from milc import cli
@cli.entrypoint('QMK Python Unit Tests')
def main(cli):
@cli.subcommand('QMK Python Unit Tests')
def pytest(cli):
"""Use nose2 to run unittests
"""
try:
import nose2
except ImportError:
cli.log.error('Could not import nose2! Please install it with {fg_cyan}pip3 install nose2')
return False
nose2.discover()
nose2.discover(argv=['nose2', '-v'])

1
lib/python/qmk/path.py
View File

@@ -2,6 +2,7 @@
"""
import logging
import os
from pkgutil import walk_packages
from qmk.errors import NoSuchKeyboardError

47
lib/python/qmk/tests/test_cli_commands.py Normal file
View File

@@ -0,0 +1,47 @@
import subprocess
def check_subcommand(command, *args):
cmd = ['bin/qmk', command] + list(args)
return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
def test_cformat():
assert check_subcommand('cformat', 'tmk_core/common/backlight.c').returncode == 0
def test_compile():
assert check_subcommand('compile', '-kb', 'handwired/onekey/pytest', '-km', 'default').returncode == 0
def test_config():
result = check_subcommand('config')
assert result.returncode == 0
assert 'general.color' in result.stdout
def test_doctor():
result = check_subcommand('doctor')
assert result.returncode == 0
assert 'QMK Doctor is checking your environment.' in result.stderr
assert 'QMK is ready to go' in result.stderr
def test_hello():
result = check_subcommand('hello')
assert result.returncode == 0
assert 'Hello,' in result.stderr
def test_pyformat():
result = check_subcommand('pyformat')
assert result.returncode == 0
assert 'Successfully formatted the python code' in result.stderr
def test_list_keyboards():
result = check_subcommand('list-keyboards')
assert result.returncode == 0
# check to see if a known keyboard is returned
# this will fail if handwired/onekey/pytest is removed
assert 'handwired/onekey/pytest' in result.stdout

5
message.mk
View File

@@ -76,6 +76,11 @@ define GENERATE_MSG_MAKE_TEST
endef
MSG_MAKE_TEST = $(eval $(call GENERATE_MSG_MAKE_TEST))$(MSG_MAKE_TEST_ACTUAL)
MSG_TEST = Testing $(BOLD)$(TEST_NAME)$(NO_COLOR)
define GENERATE_MSG_AVAILABLE_KEYMAPS
MSG_AVAILABLE_KEYMAPS_ACTUAL := Available keymaps for $(BOLD)$$(CURRENT_KB)$(NO_COLOR):
endef
MSG_AVAILABLE_KEYMAPS = $(eval $(call GENERATE_MSG_AVAILABLE_KEYMAPS))$(MSG_AVAILABLE_KEYMAPS_ACTUAL)
MSG_CHECK_FILESIZE = Checking file size of $(TARGET).hex
MSG_FILE_TOO_BIG = $(ERROR_COLOR)The firmware is too large!$(NO_COLOR) $(CURRENT_SIZE)/$(MAX_SIZE) ($(OVER_SIZE) bytes over)\n
MSG_FILE_TOO_SMALL = The firmware is too small! $(CURRENT_SIZE)/$(MAX_SIZE)\n

0
tmk_core/common/backlight.c → quantum/backlight/backlight.c
View File

0
tmk_core/common/backlight.h → quantum/backlight/backlight.h
View File

10
quantum/color.c
View File

@@ -36,7 +36,11 @@ RGB hsv_to_rgb(HSV hsv) {
h = hsv.h;
s = hsv.s;
#ifdef USE_CIE1931_CURVE
v = pgm_read_byte(&CIE1931_CURVE[hsv.v]);
#else
v = hsv.v;
#endif
region = h * 6 / 255;
remainder = (h * 2 - region * 85) * 3;
@@ -79,11 +83,5 @@ RGB hsv_to_rgb(HSV hsv) {
break;
}
#ifdef USE_CIE1931_CURVE
rgb.r = pgm_read_byte(&CIE1931_CURVE[rgb.r]);
rgb.g = pgm_read_byte(&CIE1931_CURVE[rgb.g]);
rgb.b = pgm_read_byte(&CIE1931_CURVE[rgb.b]);
#endif
return rgb;
}

21
quantum/config_common.h
View File

@@ -175,7 +175,7 @@
// LEDs (only D5/C13 uses an actual LED)
# ifdef CONVERT_TO_PROTON_C_RXLED
# define D5 PAL_LINE(GPIOC, 13)
# define D5 PAL_LINE(GPIOC, 14)
# define B0 PAL_LINE(GPIOC, 13)
# else
# define D5 PAL_LINE(GPIOC, 13)
@@ -303,6 +303,25 @@
UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
sei(); \
} while (0)
# elif (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__))
# define SERIAL_UART_BAUD 115200
# define SERIAL_UART_DATA UDR1
/* UBRR should result in ~16 and set UCSR1A = _BV(U2X1) as per rn42 documentation. HC05 needs baudrate configured accordingly */
# define SERIAL_UART_UBRR (F_CPU / (8UL * SERIAL_UART_BAUD) - 1)
# define SERIAL_UART_RXD_VECT USART1_RX_vect
# define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1))
# define SERIAL_UART_INIT() do { \
UCSR1A = _BV(U2X1); \
/* baud rate */ \
UBRR1L = SERIAL_UART_UBRR; \
/* baud rate */ \
UBRR1H = SERIAL_UART_UBRR >> 8; \
/* enable TX */ \
UCSR1B = _BV(TXEN1); \
/* 8-bit data */ \
UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
sei(); \
} while(0)
# else
# error "USART configuration is needed."
# endif

42
quantum/encoder.c
View File

@@ -40,8 +40,10 @@ static int8_t encoder_LUT[] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1,
static uint8_t encoder_state[NUMBER_OF_ENCODERS] = {0};
#ifdef SPLIT_KEYBOARD
// slave half encoders come over as second set of encoders
// right half encoders come over as second set of encoders
static int8_t encoder_value[NUMBER_OF_ENCODERS * 2] = {0};
// row offsets for each hand
static uint8_t thisHand, thatHand;
#else
static int8_t encoder_value[NUMBER_OF_ENCODERS] = {0};
#endif
@@ -68,20 +70,33 @@ void encoder_init(void) {
encoder_state[i] = (readPin(encoders_pad_a[i]) << 0) | (readPin(encoders_pad_b[i]) << 1);
}
#ifdef SPLIT_KEYBOARD
thisHand = isLeftHand ? 0 : NUMBER_OF_ENCODERS;
thatHand = NUMBER_OF_ENCODERS - thisHand;
#endif
}
static void encoder_update(int8_t index, uint8_t state) {
encoder_value[index] += encoder_LUT[state & 0xF];
if (encoder_value[index] >= ENCODER_RESOLUTION) {
encoder_update_kb(index, false);
}
if (encoder_value[index] <= -ENCODER_RESOLUTION) { // direction is arbitrary here, but this clockwise
encoder_update_kb(index, true);
}
encoder_value[index] %= ENCODER_RESOLUTION;
}
void encoder_read(void) {
for (int i = 0; i < NUMBER_OF_ENCODERS; i++) {
encoder_state[i] <<= 2;
encoder_state[i] |= (readPin(encoders_pad_a[i]) << 0) | (readPin(encoders_pad_b[i]) << 1);
encoder_value[i] += encoder_LUT[encoder_state[i] & 0xF];
if (encoder_value[i] >= ENCODER_RESOLUTION) {
encoder_update_kb(i, false);
}
if (encoder_value[i] <= -ENCODER_RESOLUTION) { // direction is arbitrary here, but this clockwise
encoder_update_kb(i, true);
}
encoder_value[i] %= ENCODER_RESOLUTION;
#if SPLIT_KEYBOARD
encoder_update(i + thisHand, encoder_state[i]);
#else
encoder_update(i, encoder_state[i]);
#endif
}
}
@@ -90,14 +105,7 @@ void encoder_state_raw(uint8_t* slave_state) { memcpy(slave_state, encoder_state
void encoder_update_raw(uint8_t* slave_state) {
for (int i = 0; i < NUMBER_OF_ENCODERS; i++) {
encoder_value[NUMBER_OF_ENCODERS + i] += encoder_LUT[slave_state[i] & 0xF];
if (encoder_value[NUMBER_OF_ENCODERS + i] >= ENCODER_RESOLUTION) {
encoder_update_kb(NUMBER_OF_ENCODERS + i, false);
}
if (encoder_value[NUMBER_OF_ENCODERS + i] <= -ENCODER_RESOLUTION) { // direction is arbitrary here, but this clockwise
encoder_update_kb(NUMBER_OF_ENCODERS + i, true);
}
encoder_value[NUMBER_OF_ENCODERS + i] %= ENCODER_RESOLUTION;
encoder_update(i + thatHand, slave_state[i]);
}
}
#endif

5
quantum/keymap_common.c
View File

@@ -26,9 +26,12 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "action.h"
#include "action_macro.h"
#include "debug.h"
#include "backlight.h"
#include "quantum.h"
#ifdef BACKLIGHT_ENABLE
# include "backlight.h"
#endif
#ifdef MIDI_ENABLE
# include "process_midi.h"
#endif

55
quantum/keymap_extras/keymap_italian.h
View File

@@ -78,35 +78,36 @@
#define IT_MINS KC_SLSH // - and _
// shifted characters
#define IT_PIPE LSFT(IT_BKSL) // °
#define IT_EXLM LSFT(KC_1) // !
#define IT_DQOT LSFT(KC_2) // "
#define IT_STRL LSFT(KC_3) // £
#define IT_DLR LSFT(KC_4) // $
#define IT_PERC LSFT(KC_5) // %
#define IT_AMPR LSFT(KC_6) // &
#define IT_SLSH LSFT(KC_7) // /
#define IT_LPRN LSFT(KC_8) // (
#define IT_RPRN LSFT(KC_9) // )
#define IT_EQL LSFT(KC_0) // =
#define IT_QST LSFT(IT_APOS) // ?
#define IT_CRC LSFT(IT_IACC) // ^
#define IT_ASTR LSFT(IT_PLUS) // *
#define IT_MORE LSFT(IT_LESS) // >
#define IT_COLN LSFT(IT_DOT) // :
#define IT_SCLN LSFT(IT_COMM) // ;
#define IT_UNDS LSFT(IT_MINS) // _
#define IT_DEGR LSFT(IT_AACC) // °
#define IT_EXLM LSFT(KC_1) // !
#define IT_DQOT LSFT(KC_2) // "
#define IT_STRL LSFT(KC_3) // £
#define IT_DLR LSFT(KC_4) // $
#define IT_PERC LSFT(KC_5) // %
#define IT_AMPR LSFT(KC_6) // &
#define IT_SLSH LSFT(KC_7) // /
#define IT_LPRN LSFT(KC_8) // (
#define IT_RPRN LSFT(KC_9) // )
#define IT_EQL LSFT(KC_0) // =
#define IT_QST LSFT(IT_APOS) // ?
#define IT_CRC LSFT(IT_IACC) // ^
#define IT_ASTR LSFT(IT_PLUS) // *
#define IT_MORE LSFT(IT_LESS) // >
#define IT_COLN LSFT(IT_DOT) // :
#define IT_SCLN LSFT(IT_COMM) // ;
#define IT_UNDS LSFT(IT_MINS) // _
// Alt Gr-ed characters
#define IT_LCBR ALGR(KC_7) // {
#define IT_LBRC ALGR(IT_EACC) // [
#define IT_RBRC ALGR(IT_PLUS) // ]
#define IT_RCBR ALGR(KC_0) // }
#define IT_AT ALGR(IT_OACC) // @
#define IT_EURO ALGR(KC_E) // €
#define IT_PIPE LSFT(IT_BKSL) // |
#define IT_SHRP ALGR(IT_AACC) // #
#define IT_LCBR ALGR(KC_7) // {
#define IT_LBRC ALGR(IT_EACC) // [
#define IT_RBRC ALGR(IT_PLUS) // ]
#define IT_RCBR ALGR(KC_0) // }
#define IT_AT ALGR(IT_OACC) // @
#define IT_EURO ALGR(KC_E) // €
#define IT_PIPE LSFT(IT_BSLS) // |
#define IT_SHRP ALGR(IT_AACC) // #
#define IT_X_PLUS X_RBRACKET // #
// Deprecated
#define IT_X_PLUS X_RBRACKET // #
#endif

113
quantum/keymap_extras/keymap_italian_osx_ansi.h Normal file
View File

@@ -0,0 +1,113 @@
/* Copyright 2015-2016 Matthias Schmidtt
*
* 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/>.
*/
// This is a clone of quantum/keymap_extra/keymap_italian.h intended to be used with Apple devices
#ifndef KEYMAP_ITALIAN
#define KEYMAP_ITALIAN
#include "keymap.h"
// normal characters
#define IT_A KC_A
#define IT_B KC_B
#define IT_C KC_C
#define IT_D KC_D
#define IT_E KC_E
#define IT_F KC_F
#define IT_G KC_G
#define IT_H KC_H
#define IT_I KC_I
#define IT_J KC_J
#define IT_K KC_K
#define IT_L KC_L
#define IT_M KC_M
#define IT_N KC_N
#define IT_O KC_O
#define IT_P KC_P
#define IT_Q KC_Q
#define IT_R KC_R
#define IT_S KC_S
#define IT_T KC_T
#define IT_U KC_U
#define IT_V KC_V
#define IT_W KC_W
#define IT_X KC_X
#define IT_Y KC_Y
#define IT_Z KC_Z
#define IT_0 KC_0
#define IT_1 KC_1
#define IT_2 KC_2
#define IT_3 KC_3
#define IT_4 KC_4
#define IT_5 KC_5
#define IT_6 KC_6
#define IT_7 KC_7
#define IT_8 KC_8
#define IT_9 KC_9
// punctuation
#define IT_DOT KC_DOT // . and :
#define IT_COMM KC_COMM // , and ;
#define IT_APOS KC_MINS // ' and ?
#define IT_BSLS KC_NUBS // \ and |
#define IT_LESS KC_GRV // < and >
#define IT_MINS KC_SLSH // - and _
// accented vowels (regular, with shift, with option, with option and shift)
#define IT_EACC KC_LBRC // è, é, [, {
#define IT_PLUS KC_RBRC // +, *, ], }
#define IT_OACC KC_SCLN // ò, ç, @, Ç
#define IT_AACC KC_QUOT // à, °, #, ∞
#define IT_UACC KC_BSLS // ù, §, ¶, ◊
#define IT_IACC KC_EQL // ì, ^, ˆ, ±
// shifted characters
#define IT_EXLM LSFT(KC_1) // !
#define IT_DQOT LSFT(KC_2) // "
#define IT_STRL LSFT(KC_3) // £
#define IT_DLR LSFT(KC_4) // $
#define IT_PERC LSFT(KC_5) // %
#define IT_AMPR LSFT(KC_6) // &
#define IT_SLSH LSFT(KC_7) // /
#define IT_LPRN LSFT(KC_8) // (
#define IT_RPRN LSFT(KC_9) // )
#define IT_EQL LSFT(KC_0) // =
#define IT_DEGR LSFT(IT_AACC) // °
#define IT_QST LSFT(IT_APOS) // ?
#define IT_CRC LSFT(IT_IACC) // ^
#define IT_ASTR LSFT(IT_PLUS) // *
#define IT_MORE LSFT(IT_LESS) // >
#define IT_COLN LSFT(IT_DOT) // :
#define IT_SCLN LSFT(IT_COMM) // ;
#define IT_UNDS LSFT(IT_MINS) // _
#define IT_LCBR LSFT(IT_LBRC) // {
#define IT_RCBR LSFT(IT_RBRC) // }
#define IT_PIPE LSFT(IT_BSLS) // |
// Alt -ed characters
#define IT_LBRC LALT(IT_EACC) // [
#define IT_RBRC LALT(IT_PLUS) // ]
#define IT_AT LALT(IT_OACC) // @
#define IT_EURO LALT(KC_E) // €
#define IT_SHRP LALT(IT_AACC ) // #
#define IT_ACUT LALT(KC_8) // ´
#define IT_GRAVE LALT(KC_9) // `
#define IT_TILDE LALT(KC_5) // ~
#define IT_PLMN LALT(LSFT(IT_IACC)) // ±
#endif

113
quantum/keymap_extras/keymap_italian_osx_iso.h Normal file
View File

@@ -0,0 +1,113 @@
/* Copyright 2015-2016 Matthias Schmidtt
*
* 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/>.
*/
// This is a clone of quantum/keymap_extra/keymap_italian.h intended to be used with Apple devices
#ifndef KEYMAP_ITALIAN
#define KEYMAP_ITALIAN
#include "keymap.h"
// normal characters
#define IT_A KC_A
#define IT_B KC_B
#define IT_C KC_C
#define IT_D KC_D
#define IT_E KC_E
#define IT_F KC_F
#define IT_G KC_G
#define IT_H KC_H
#define IT_I KC_I
#define IT_J KC_J
#define IT_K KC_K
#define IT_L KC_L
#define IT_M KC_M
#define IT_N KC_N
#define IT_O KC_O
#define IT_P KC_P
#define IT_Q KC_Q
#define IT_R KC_R
#define IT_S KC_S
#define IT_T KC_T
#define IT_U KC_U
#define IT_V KC_V
#define IT_W KC_W
#define IT_X KC_X
#define IT_Y KC_Y
#define IT_Z KC_Z
#define IT_0 KC_0
#define IT_1 KC_1
#define IT_2 KC_2
#define IT_3 KC_3
#define IT_4 KC_4
#define IT_5 KC_5
#define IT_6 KC_6
#define IT_7 KC_7
#define IT_8 KC_8
#define IT_9 KC_9
// punctuation
#define IT_DOT KC_DOT // . and :
#define IT_COMM KC_COMM // , and ;
#define IT_APOS KC_MINS // ' and ?
#define IT_BSLS KC_GRV // \ and |
#define IT_LESS KC_NUBS// < and >
#define IT_MINS KC_SLSH // - and _
// accented vowels (regular, with shift, with option, with option and shift)
#define IT_EACC KC_LBRC // è, é, [, {
#define IT_PLUS KC_RBRC // +, *, ], }
#define IT_OACC KC_SCLN // ò, ç, @, Ç
#define IT_AACC KC_QUOT // à, °, #, ∞
#define IT_UACC KC_BSLS // ù, §, ¶, ◊
#define IT_IACC KC_EQL // ì, ^, ˆ, ±
// shifted characters
#define IT_EXLM LSFT(KC_1) // !
#define IT_DQOT LSFT(KC_2) // "
#define IT_STRL LSFT(KC_3) // £
#define IT_DLR LSFT(KC_4) // $
#define IT_PERC LSFT(KC_5) // %
#define IT_AMPR LSFT(KC_6) // &
#define IT_SLSH LSFT(KC_7) // /
#define IT_LPRN LSFT(KC_8) // (
#define IT_RPRN LSFT(KC_9) // )
#define IT_EQL LSFT(KC_0) // =
#define IT_DEGR LSFT(IT_AACC) // °
#define IT_QST LSFT(IT_APOS) // ?
#define IT_CRC LSFT(IT_IACC) // ^
#define IT_ASTR LSFT(IT_PLUS) // *
#define IT_MORE LSFT(IT_LESS) // >
#define IT_COLN LSFT(IT_DOT) // :
#define IT_SCLN LSFT(IT_COMM) // ;
#define IT_UNDS LSFT(IT_MINS) // _
#define IT_LCBR LSFT(IT_LBRC) // {
#define IT_RCBR LSFT(IT_RBRC) // }
#define IT_PIPE LSFT(IT_BSLS) // |
// Alt -ed characters
#define IT_LBRC LALT(IT_EACC) // [
#define IT_RBRC LALT(IT_PLUS) // ]
#define IT_AT LALT(IT_OACC) // @
#define IT_EURO LALT(KC_E) // €
#define IT_SHRP LALT(IT_AACC ) // #
#define IT_ACUT LALT(KC_8) // ´
#define IT_GRAVE LALT(KC_9) // `
#define IT_TILDE LALT(KC_5) // ~
#define IT_PLMN LALT(LSFT(IT_IACC)) // ±
#endif

44
quantum/led_tables.c
View File

@@ -15,14 +15,50 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "led_tables.h"
// clang-format off
#ifdef USE_CIE1931_CURVE
// Lightness curve using the CIE 1931 lightness formula
// Generated by the python script provided in http://jared.geek.nz/2013/feb/linear-led-pwm
const uint8_t CIE1931_CURVE[256] PROGMEM = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 14, 14, 14, 15, 15, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 28, 28, 29, 29, 30, 31, 31, 32, 33, 33, 34, 35, 35, 36, 37, 37, 38, 39, 40, 40, 41, 42, 43, 44, 44, 45, 46,
47, 48, 49, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 75, 76, 77, 78, 79, 80, 82, 83, 84, 85, 87, 88, 89, 90, 92, 93, 94, 96, 97, 99, 100, 101, 103, 104, 106, 107, 108, 110, 111, 113, 114, 116, 118, 119, 121, 122, 124, 125, 127, 129, 130, 132, 134, 135, 137, 139, 141, 142, 144, 146, 148, 149, 151, 153, 155, 157, 159, 161, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 185, 187, 189, 191, 193, 195, 197, 200, 202, 204, 206, 208, 211, 213, 215, 218, 220, 222, 225, 227, 230, 232, 234, 237, 239, 242, 244, 247, 249, 252, 255};
const uint8_t CIE1931_CURVE[256] PROGMEM = {
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4,
4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7,
7, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12,
12, 12, 13, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 17, 17, 17,
18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25,
26, 26, 27, 27, 28, 29, 29, 30, 30, 31, 32, 32, 33, 34, 34, 35,
36, 36, 37, 38, 38, 39, 40, 41, 41, 42, 43, 44, 45, 45, 46, 47,
48, 49, 50, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 76, 77, 78, 79,
80, 81, 83, 84, 85, 86, 88, 89, 90, 91, 93, 94, 95, 97, 98, 100,
101, 102, 104, 105, 107, 108, 109, 111, 112, 114, 115, 117, 119, 120, 122, 123,
125, 126, 128, 130, 131, 133, 135, 136, 138, 140, 142, 143, 145, 147, 149, 150,
152, 154, 156, 158, 160, 162, 163, 165, 167, 169, 171, 173, 175, 177, 179, 181,
183, 186, 188, 190, 192, 194, 196, 198, 201, 203, 205, 207, 209, 212, 214, 216,
219, 221, 223, 226, 228, 231, 233, 235, 238, 240, 243, 245, 248, 250, 253, 255
};
#endif
#ifdef USE_LED_BREATHING_TABLE
const uint8_t LED_BREATHING_TABLE[256] PROGMEM = {0, 0, 0, 0, 1, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 9, 10, 11, 12, 14, 15, 17, 18, 20, 21, 23, 25, 27, 29, 31, 33, 35, 37, 40, 42, 44, 47, 49, 52, 54, 57, 59, 62, 65, 67, 70, 73, 76, 79, 82, 85, 88, 90, 93, 97, 100, 103, 106, 109, 112, 115, 118, 121, 124, 127, 131, 134, 137, 140, 143, 146, 149, 152, 155, 158, 162, 165, 167, 170, 173, 176, 179, 182, 185, 188, 190, 193, 196, 198, 201, 203, 206, 208, 211, 213, 215, 218, 220, 222, 224, 226, 228, 230, 232, 234, 235, 237, 238, 240, 241, 243, 244, 245, 246, 248, 249, 250, 250, 251, 252, 253, 253, 254, 254, 254, 255, 255, 255,
255, 255, 255, 255, 254, 254, 254, 253, 253, 252, 251, 250, 250, 249, 248, 246, 245, 244, 243, 241, 240, 238, 237, 235, 234, 232, 230, 228, 226, 224, 222, 220, 218, 215, 213, 211, 208, 206, 203, 201, 198, 196, 193, 190, 188, 185, 182, 179, 176, 173, 170, 167, 165, 162, 158, 155, 152, 149, 146, 143, 140, 137, 134, 131, 128, 124, 121, 118, 115, 112, 109, 106, 103, 100, 97, 93, 90, 88, 85, 82, 79, 76, 73, 70, 67, 65, 62, 59, 57, 54, 52, 49, 47, 44, 42, 40, 37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 17, 15, 14, 12, 11, 10, 9, 7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 1, 0, 0, 0};
const uint8_t LED_BREATHING_TABLE[256] PROGMEM = {
0, 0, 0, 0, 1, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 9,
10, 11, 12, 14, 15, 17, 18, 20, 21, 23, 25, 27, 29, 31, 33, 35,
37, 40, 42, 44, 47, 49, 52, 54, 57, 59, 62, 65, 67, 70, 73, 76,
79, 82, 85, 88, 90, 93, 97, 100, 103, 106, 109, 112, 115, 118, 121, 124,
127, 131, 134, 137, 140, 143, 146, 149, 152, 155, 158, 162, 165, 167, 170, 173,
176, 179, 182, 185, 188, 190, 193, 196, 198, 201, 203, 206, 208, 211, 213, 215,
218, 220, 222, 224, 226, 228, 230, 232, 234, 235, 237, 238, 240, 241, 243, 244,
245, 246, 248, 249, 250, 250, 251, 252, 253, 253, 254, 254, 254, 255, 255, 255,
255, 255, 255, 255, 254, 254, 254, 253, 253, 252, 251, 250, 250, 249, 248, 246,
245, 244, 243, 241, 240, 238, 237, 235, 234, 232, 230, 228, 226, 224, 222, 220,
218, 215, 213, 211, 208, 206, 203, 201, 198, 196, 193, 190, 188, 185, 182, 179,
176, 173, 170, 167, 165, 162, 158, 155, 152, 149, 146, 143, 140, 137, 134, 131,
128, 124, 121, 118, 115, 112, 109, 106, 103, 100, 97, 93, 90, 88, 85, 82,
79, 76, 73, 70, 67, 65, 62, 59, 57, 54, 52, 49, 47, 44, 42, 40,
37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 17, 15, 14, 12, 11,
10, 9, 7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 1, 0, 0, 0
};
#endif
// clang-format on

2
quantum/process_keycode/process_tap_dance.c
View File

@@ -71,7 +71,7 @@ void qk_tap_dance_dual_role_finished(qk_tap_dance_state_t *state, void *user_dat
if (state->count == 1) {
register_code16(pair->kc);
} else if (state->count == 2) {
layer_move(pair->layer);
pair->layer_function(pair->layer);
}
}

10
quantum/process_keycode/process_tap_dance.h
View File

@@ -56,13 +56,19 @@ typedef struct {
typedef struct {
uint16_t kc;
uint8_t layer;
void (*layer_function)(uint8_t);
} qk_tap_dance_dual_role_t;
# define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) \
{ .fn = {qk_tap_dance_pair_on_each_tap, qk_tap_dance_pair_finished, qk_tap_dance_pair_reset}, .user_data = (void *)&((qk_tap_dance_pair_t){kc1, kc2}), }
# define ACTION_TAP_DANCE_DUAL_ROLE(kc, layer) \
{ .fn = {qk_tap_dance_dual_role_on_each_tap, qk_tap_dance_dual_role_finished, qk_tap_dance_dual_role_reset}, .user_data = (void *)&((qk_tap_dance_dual_role_t){kc, layer}), }
{ .fn = { qk_tap_dance_dual_role_on_each_tap, qk_tap_dance_dual_role_finished, qk_tap_dance_dual_role_reset }, .user_data = (void *)&((qk_tap_dance_dual_role_t) { kc, layer, layer_move }), }
# define ACTION_TAP_DANCE_TOGGLE_LAYER(kc, layer) \
{ .fn = { NULL, qk_tap_dance_dual_role_finished, qk_tap_dance_dual_role_reset }, .user_data = (void *)&((qk_tap_dance_dual_role_t) { kc, layer, layer_invert }), }
# define ACTION_TAP_DANCE_LAYER_MOVE(kc, layer) ACTION_TAP_DANCE_DUAL_ROLE(kc, layer)
# define ACTION_TAP_DANCE_FN(user_fn) \
{ .fn = {NULL, user_fn, NULL}, .user_data = NULL, }
@@ -73,6 +79,8 @@ typedef struct {
# define ACTION_TAP_DANCE_FN_ADVANCED_TIME(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, tap_specific_tapping_term) \
{ .fn = {user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset}, .user_data = NULL, .custom_tapping_term = tap_specific_tapping_term, }
extern qk_tap_dance_action_t tap_dance_actions[];
/* To be used internally */

86
quantum/quantum.c
View File

@@ -28,8 +28,10 @@
# define BREATHING_PERIOD 6
#endif
#include "backlight.h"
extern backlight_config_t backlight_config;
#ifdef BACKLIGHT_ENABLE
# include "backlight.h"
extern backlight_config_t backlight_config;
#endif
#ifdef FAUXCLICKY_ENABLE
# include "fauxclicky.h"
@@ -55,6 +57,10 @@ extern backlight_config_t backlight_config;
# include "encoder.h"
#endif
#ifdef WEBUSB_ENABLE
# include "webusb.h"
#endif
#ifdef AUDIO_ENABLE
# ifndef GOODBYE_SONG
# define GOODBYE_SONG SONG(GOODBYE_SOUND)
@@ -89,44 +95,28 @@ static void do_code16(uint16_t code, void (*f)(uint8_t)) {
return;
}
if (code & QK_LCTL) f(KC_LCTL);
if (code & QK_LSFT) f(KC_LSFT);
if (code & QK_LALT) f(KC_LALT);
if (code & QK_LGUI) f(KC_LGUI);
uint8_t mods_to_send = 0;
if (code < QK_RMODS_MIN) return;
if (code & QK_RMODS_MIN) { // Right mod flag is set
if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_RCTL);
if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_RSFT);
if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_RALT);
if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_RGUI);
} else {
if (code & QK_LCTL) mods_to_send |= MOD_BIT(KC_LCTL);
if (code & QK_LSFT) mods_to_send |= MOD_BIT(KC_LSFT);
if (code & QK_LALT) mods_to_send |= MOD_BIT(KC_LALT);
if (code & QK_LGUI) mods_to_send |= MOD_BIT(KC_LGUI);
}
if (code & QK_RCTL) f(KC_RCTL);
if (code & QK_RSFT) f(KC_RSFT);
if (code & QK_RALT) f(KC_RALT);
if (code & QK_RGUI) f(KC_RGUI);
}
static inline void qk_register_weak_mods(uint8_t kc) {
add_weak_mods(MOD_BIT(kc));
send_keyboard_report();
}
static inline void qk_unregister_weak_mods(uint8_t kc) {
del_weak_mods(MOD_BIT(kc));
send_keyboard_report();
}
static inline void qk_register_mods(uint8_t kc) {
add_weak_mods(MOD_BIT(kc));
send_keyboard_report();
}
static inline void qk_unregister_mods(uint8_t kc) {
del_weak_mods(MOD_BIT(kc));
send_keyboard_report();
f(mods_to_send);
}
void register_code16(uint16_t code) {
if (IS_MOD(code) || code == KC_NO) {
do_code16(code, qk_register_mods);
do_code16(code, register_mods);
} else {
do_code16(code, qk_register_weak_mods);
do_code16(code, register_weak_mods);
}
register_code(code);
}
@@ -134,9 +124,9 @@ void register_code16(uint16_t code) {
void unregister_code16(uint16_t code) {
unregister_code(code);
if (IS_MOD(code) || code == KC_NO) {
do_code16(code, qk_unregister_mods);
do_code16(code, unregister_mods);
} else {
do_code16(code, qk_unregister_weak_mods);
do_code16(code, unregister_weak_mods);
}
}
@@ -581,6 +571,7 @@ bool process_record_quantum(keyrecord_t *record) {
keymap_config.swap_backslash_backspace = true;
break;
case MAGIC_HOST_NKRO:
clear_keyboard(); // clear first buffer to prevent stuck keys
keymap_config.nkro = true;
break;
case MAGIC_SWAP_ALT_GUI:
@@ -623,6 +614,7 @@ bool process_record_quantum(keyrecord_t *record) {
keymap_config.swap_backslash_backspace = false;
break;
case MAGIC_UNHOST_NKRO:
clear_keyboard(); // clear first buffer to prevent stuck keys
keymap_config.nkro = false;
break;
case MAGIC_UNSWAP_ALT_GUI:
@@ -660,6 +652,7 @@ bool process_record_quantum(keyrecord_t *record) {
#endif
break;
case MAGIC_TOGGLE_NKRO:
clear_keyboard(); // clear first buffer to prevent stuck keys
keymap_config.nkro = !keymap_config.nkro;
break;
default:
@@ -723,6 +716,13 @@ bool process_record_quantum(keyrecord_t *record) {
}
return false;
}
#endif
#ifdef WEBUSB_ENABLE
case WEBUSB_PAIR:
if (record->event.pressed) {
webusb_state.pairing = true;
}
return false;
#endif
}
@@ -1104,6 +1104,22 @@ void matrix_scan_quantum() {
# define COMxx1 COM1A1
# define OCRxx OCR1A
# endif
# elif defined(__AVR_ATmega328P__) && (BACKLIGHT_PIN == B1 || BACKLIGHT_PIN == B2)
# define HARDWARE_PWM
# define ICRx ICR1
# define TCCRxA TCCR1A
# define TCCRxB TCCR1B
# define TIMERx_OVF_vect TIMER1_OVF_vect
# define TIMSKx TIMSK1
# define TOIEx TOIE1
# if BACKLIGHT_PIN == B1
# define COMxx1 COM1A1
# define OCRxx OCR1A
# elif BACKLIGHT_PIN == B2
# define COMxx1 COM1B1
# define OCRxx OCR1B
# endif
# else
# if !defined(BACKLIGHT_CUSTOM_DRIVER)
# if !defined(B5_AUDIO) && !defined(B6_AUDIO) && !defined(B7_AUDIO)

6
quantum/quantum_keycodes.h
View File

@@ -473,6 +473,9 @@ enum quantum_keycodes {
HPT_BUZ,
HPT_MODI,
HPT_MODD,
HPT_CONT,
HPT_CONI,
HPT_COND,
HPT_DWLI,
HPT_DWLD,
@@ -500,6 +503,9 @@ enum quantum_keycodes {
MAGIC_UNSWAP_CTL_GUI,
MAGIC_TOGGLE_CTL_GUI,
#ifdef WEBUSB_ENABLE
WEBUSB_PAIR,
#endif
// always leave at the end
SAFE_RANGE
};

22
quantum/rgb_matrix_drivers.c
View File

@@ -97,19 +97,33 @@ const rgb_matrix_driver_t rgb_matrix_driver = {
#elif defined(WS2812)
extern LED_TYPE led[DRIVER_LED_TOTAL];
// LED color buffer
LED_TYPE led[DRIVER_LED_TOTAL];
static void init(void) {}
static void flush(void) {
// Assumes use of RGB_DI_PIN
ws2812_setleds(led, DRIVER_LED_TOTAL);
}
static void init(void) {}
// Set an led in the buffer to a color
static inline void setled(int i, uint8_t r, uint8_t g, uint8_t b) {
led[i].r = r;
led[i].g = g;
led[i].b = b;
}
static void setled_all(uint8_t r, uint8_t g, uint8_t b) {
for (int i = 0; i < sizeof(led) / sizeof(led[0]); i++) {
setled(i, r, g, b);
}
}
const rgb_matrix_driver_t rgb_matrix_driver = {
.init = init,
.flush = flush,
.set_color = ws2812_setled,
.set_color_all = ws2812_setled_all,
.set_color = setled,
.set_color_all = setled_all,
};
#endif

3
quantum/rgblight.c
View File

@@ -910,6 +910,9 @@ void rgblight_effect_snake(animation_status_t *anim) {
ledp->b = 0;
for (j = 0; j < RGBLIGHT_EFFECT_SNAKE_LENGTH; j++) {
k = pos + j * increment;
if (k > RGBLED_NUM) {
k = k % RGBLED_NUM;
}
if (k < 0) {
k = k + effect_num_leds;
}

6
quantum/template/ps2avrgb/rules.mk
View File

@@ -14,9 +14,7 @@ EXTRAKEY_ENABLE = yes
CONSOLE_ENABLE = yes
COMMAND_ENABLE = yes
BACKLIGHT_ENABLE = no
RGBLIGHT_ENABLE = no
RGBLIGHT_CUSTOM_DRIVER = yes
RGBLIGHT_ENABLE = yes
WS2812_DRIVER = i2c
OPT_DEFS = -DDEBUG_LEVEL=0
SRC += i2c_master.c

44
quantum/template/ps2avrgb/template.c
View File

@@ -15,44 +15,30 @@
*/
#include "%KEYBOARD%.h"
#ifdef RGBLIGHT_ENABLE
# include <string.h>
# include "i2c_master.h"
# include "rgblight.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.
extern rgblight_config_t rgblight_config;
/*
void matrix_init_kb(void) {
i2c_init();
// call user level keymaps, if any
matrix_init_user();
// put your keyboard start-up code here
// runs once when the firmware starts up
matrix_init_user();
}
// custom RGB driver
void rgblight_set(void) {
if (!rgblight_config.enable) {
memset(led, 0, 3 * RGBLED_NUM);
}
i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
}
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_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
rgb_init = true;
}
// put your looping keyboard code here
// runs every cycle (a lot)
rgblight_task();
matrix_scan_user();
matrix_scan_user();
}
#endif
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
__attribute__ ((weak))
void matrix_scan_user(void) {
return process_record_user(keycode, record);
}

2
requirements.txt
View File

@@ -1,5 +1,5 @@
# Python requirements
# milc FIXME(skullydazed): Included in the repo for now.
appdirs
argcomplete
colorama
#halo

2
shell.nix
View File

@@ -32,7 +32,7 @@ in
stdenv.mkDerivation {
name = "qmk-firmware";
buildInputs = [ dfu-programmer dfu-util diffutils git ]
buildInputs = [ dfu-programmer dfu-util diffutils git python3 ]
++ lib.optional avr [ avrbinutils avrgcc avrlibc avrdude ]
++ lib.optional arm [ gcc-arm-embedded ]
++ lib.optional teensy [ teensy-loader-cli ];

9
tmk_core/common.mk
View File

@@ -118,6 +118,10 @@ ifeq ($(strip $(RAW_ENABLE)), yes)
TMK_COMMON_DEFS += -DRAW_ENABLE
endif
ifeq ($(strip $(WEBUSB_ENABLE)), yes)
TMK_COMMON_DEFS += -DWEBUSB_ENABLE
endif
ifeq ($(strip $(CONSOLE_ENABLE)), yes)
TMK_COMMON_DEFS += -DCONSOLE_ENABLE
else
@@ -153,11 +157,6 @@ ifeq ($(strip $(NO_SUSPEND_POWER_DOWN)), yes)
TMK_COMMON_DEFS += -DNO_SUSPEND_POWER_DOWN
endif
ifeq ($(strip $(BACKLIGHT_ENABLE)), yes)
TMK_COMMON_SRC += $(COMMON_DIR)/backlight.c
TMK_COMMON_DEFS += -DBACKLIGHT_ENABLE
endif
ifeq ($(strip $(BLUETOOTH_ENABLE)), yes)
TMK_COMMON_DEFS += -DBLUETOOTH_ENABLE
TMK_COMMON_DEFS += -DNO_USB_STARTUP_CHECK

35
tmk_core/common/action.c
View File

@@ -20,7 +20,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "mousekey.h"
#include "command.h"
#include "led.h"
#include "backlight.h"
#include "action_layer.h"
#include "action_tapping.h"
#include "action_macro.h"
@@ -28,6 +27,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "action.h"
#include "wait.h"
#ifdef BACKLIGHT_ENABLE
# include "backlight.h"
#endif
#ifdef DEBUG_ACTION
# include "debug.h"
#else
@@ -868,9 +871,9 @@ void tap_code(uint8_t code) {
unregister_code(code);
}
/** \brief Utilities for actions. (FIXME: Needs better description)
/** \brief Adds the given physically pressed modifiers and sends a keyboard report immediately.
*
* FIXME: Needs documentation.
* \param mods A bitfield of modifiers to unregister.
*/
void register_mods(uint8_t mods) {
if (mods) {
@@ -879,9 +882,9 @@ void register_mods(uint8_t mods) {
}
}
/** \brief Utilities for actions. (FIXME: Needs better description)
/** \brief Removes the given physically pressed modifiers and sends a keyboard report immediately.
*
* FIXME: Needs documentation.
* \param mods A bitfield of modifiers to unregister.
*/
void unregister_mods(uint8_t mods) {
if (mods) {
@@ -890,6 +893,28 @@ void unregister_mods(uint8_t mods) {
}
}
/** \brief Adds the given weak modifiers and sends a keyboard report immediately.
*
* \param mods A bitfield of modifiers to register.
*/
void register_weak_mods(uint8_t mods) {
if (mods) {
add_weak_mods(mods);
send_keyboard_report();
}
}
/** \brief Removes the given weak modifiers and sends a keyboard report immediately.
*
* \param mods A bitfield of modifiers to unregister.
*/
void unregister_weak_mods(uint8_t mods) {
if (mods) {
del_weak_mods(mods);
send_keyboard_report();
}
}
/** \brief Utilities for actions. (FIXME: Needs better description)
*
* FIXME: Needs documentation.

2
tmk_core/common/action.h
View File

@@ -90,6 +90,8 @@ void unregister_code(uint8_t code);
void tap_code(uint8_t code);
void register_mods(uint8_t mods);
void unregister_mods(uint8_t mods);
void register_weak_mods(uint8_t mods);
void unregister_weak_mods(uint8_t mods);
// void set_mods(uint8_t mods);
void clear_keyboard(void);
void clear_keyboard_but_mods(void);

5
tmk_core/common/avr/suspend.c
View File

@@ -4,7 +4,6 @@
#include <avr/interrupt.h>
#include "matrix.h"
#include "action.h"
#include "backlight.h"
#include "suspend_avr.h"
#include "suspend.h"
#include "timer.h"
@@ -16,6 +15,10 @@
# include "lufa.h"
#endif
#ifdef BACKLIGHT_ENABLE
# include "backlight.h"
#endif
#ifdef AUDIO_ENABLE
# include "audio.h"
#endif /* AUDIO_ENABLE */

9
tmk_core/common/chibios/printf.c
View File

@@ -186,6 +186,15 @@ void tfp_format(void* putp, putcf putf, char* fmt, va_list va) {
case 's':
putchw(putp, putf, w, 0, va_arg(va, char*));
break;
case 'b':
#ifdef PRINTF_LONG_SUPPORT
if (lng)
uli2a(va_arg(va, unsigned long int), 2, 0, bf);
else
#endif
ui2a(va_arg(va, unsigned int), 2, 0, bf);
putchw(putp, putf, w, lz, bf);
break;
case '%':
putf(putp, ch);
default:

5
tmk_core/common/chibios/suspend.c
View File

@@ -8,10 +8,13 @@
#include "action_util.h"
#include "mousekey.h"
#include "host.h"
#include "backlight.h"
#include "suspend.h"
#include "wait.h"
#ifdef BACKLIGHT_ENABLE
# include "backlight.h"
#endif
/** \brief suspend idle
*
* FIXME: needs doc

5
tmk_core/common/command.c
View File

@@ -32,10 +32,13 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "sleep_led.h"
#include "led.h"
#include "command.h"
#include "backlight.h"
#include "quantum.h"
#include "version.h"
#ifdef BACKLIGHT_ENABLE
# include "backlight.h"
#endif
#ifdef MOUSEKEY_ENABLE
# include "mousekey.h"
#endif

28
tmk_core/common/keyboard.c
View File

@@ -29,8 +29,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "util.h"
#include "sendchar.h"
#include "eeconfig.h"
#include "backlight.h"
#include "action_layer.h"
#ifdef BACKLIGHT_ENABLE
# include "backlight.h"
#endif
#ifdef BOOTMAGIC_ENABLE
# include "bootmagic.h"
#else
@@ -82,6 +84,26 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
# include "velocikey.h"
#endif
// Only enable this if console is enabled to print to
#if defined(DEBUG_MATRIX_SCAN_RATE) && defined(CONSOLE_ENABLE)
static uint32_t matrix_timer = 0;
static uint32_t matrix_scan_count = 0;
void matrix_scan_perf_task(void) {
matrix_scan_count++;
uint32_t timer_now = timer_read32();
if (TIMER_DIFF_32(timer_now, matrix_timer) > 1000) {
dprintf("matrix scan frequency: %d\n", matrix_scan_count);
matrix_timer = timer_now;
matrix_scan_count = 0;
}
}
#else
# define matrix_scan_perf_task()
#endif
#ifdef MATRIX_HAS_GHOST
extern const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
static matrix_row_t get_real_keys(uint8_t row, matrix_row_t rowdata) {
@@ -296,6 +318,10 @@ void keyboard_task(void) {
MATRIX_LOOP_END:
#ifdef DEBUG_MATRIX_SCAN_RATE
matrix_scan_perf_task();
#endif
#ifdef QWIIC_ENABLE
qwiic_task();
#endif

4
tmk_core/common/timer.h
View File

@@ -45,9 +45,9 @@ uint16_t timer_elapsed(uint16_t last);
uint32_t timer_elapsed32(uint32_t last);
// Utility functions to check if a future time has expired & autmatically handle time wrapping if checked / reset frequently (half of max value)
inline bool timer_expired(uint16_t current, uint16_t last) { return current - last < 0x8000; }
inline bool timer_expired(uint16_t current, uint16_t future) { return (uint16_t)(current - future) < 0x8000; }
inline bool timer_expired32(uint32_t current, uint32_t future) { return current - future < 0x80000000; }
inline bool timer_expired32(uint32_t current, uint32_t future) { return (uint32_t)(current - future) < 0x80000000; }
#ifdef __cplusplus
}

8
tmk_core/common/util.h
View File

@@ -27,6 +27,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define STR(s) XSTR(s)
#define XSTR(s) #s
#ifdef __cplusplus
extern "C" {
#endif
uint8_t bitpop(uint8_t bits);
uint8_t bitpop16(uint16_t bits);
uint8_t bitpop32(uint32_t bits);
@@ -39,4 +43,8 @@ uint8_t bitrev(uint8_t bits);
uint16_t bitrev16(uint16_t bits);
uint32_t bitrev32(uint32_t bits);
#ifdef __cplusplus
}
#endif
#endif

72
tmk_core/common/webusb.c Normal file
View File

@@ -0,0 +1,72 @@
#include QMK_KEYBOARD_H
#include <string.h>
#include "webusb.h"
#include "wait.h"
webusb_state_t webusb_state = {
.paired = false,
.pairing = false,
};
void webusb_receive(uint8_t *data, uint8_t length) {
uint8_t command = data[0];
if(command == WEBUSB_CMD_PAIR && webusb_state.pairing == true) {
uint8_t event[3];
webusb_state.pairing = false;
webusb_state.paired = true;
event[0] = WEBUSB_STATUS_OK;
event[1] = WEBUSB_EVT_PAIRED;
event[2] = WEBUSB_STOP_BIT;
webusb_send(event, sizeof(event));
return;
}
if(command == WEBUSB_GET_FW_VERSION) {
// Landing page + packet headers(2) + stop bit(1)
uint8_t lp_size = sizeof(FIRMWARE_VERSION) + 3;
uint8_t url[lp_size];
uint8_t event[2];
event[0] = WEBUSB_STATUS_OK;
event[1] = WEBUSB_EVT_FW_VERSION;
uint8_t stop[1];
stop[0] = WEBUSB_STOP_BIT;
memcpy(url, event, 2);
memcpy(url + 2, FIRMWARE_VERSION, sizeof(FIRMWARE_VERSION));
memcpy(url + 2 + sizeof(FIRMWARE_VERSION), stop, 1);
webusb_send(url, lp_size);
return;
}
if(webusb_state.paired == true) {
switch(command) {
//Handle commands in here
case WEBUSB_GET_LAYER:
webusb_layer_event();
break;
default:
break;
}
} else {
webusb_error(WEBUSB_STATUS_NOT_PAIRED);
}
};
void webusb_layer_event() {
uint8_t layer;
uint8_t event[4];
layer = biton32(layer_state);
event[0] = WEBUSB_STATUS_OK;
event[1] = WEBUSB_EVT_LAYER;
event[2] = layer;
event[3] = WEBUSB_STOP_BIT;
webusb_send(event, sizeof(event));
}
void webusb_error(uint8_t code) {
uint8_t buffer[1];
buffer[0] = code;
webusb_send(buffer, 1);
}

44
tmk_core/common/webusb.h Normal file
View File

@@ -0,0 +1,44 @@
#pragma once
#include <stdint.h>
#include <stdbool.h>
#ifndef FIRMWARE_VERSION
#define FIRMWARE_VERSION u8"default"
#endif
#define WEBUSB_STOP_BIT -2
#define WEBUSB_BLINK_STEPS 512
#define WEBUSB_BLINK_END WEBUSB_BLINK_STEPS * 60
void webusb_receive(uint8_t *data, uint8_t length);
void webusb_send(uint8_t *data, uint8_t length);
void webusb_layer_event(void);
void webusb_error(uint8_t);
void webusb_set_pairing_state(void);
typedef struct{
bool paired;
bool pairing;
} webusb_state_t;
extern webusb_state_t webusb_state;
enum Webusb_Status_Code {
WEBUSB_STATUS_NOT_PAIRED = -1,
WEBUSB_STATUS_OK,
WEBUSB_STATUS_UNKNOWN_COMMAND,
};
enum Webusb_Command_Code {
WEBUSB_CMD_PAIR,
WEBUSB_GET_FW_VERSION,
WEBUSB_GET_LAYER
};
enum Webusb_Event_Code {
WEBUSB_EVT_PAIRED,
WEBUSB_EVT_KEYDOWN,
WEBUSB_EVT_KEYUP,
WEBUSB_EVT_LAYER,
WEBUSB_EVT_FW_VERSION
};

7
tmk_core/protocol/chibios/main.c
View File

@@ -77,6 +77,10 @@ void raw_hid_task(void);
void console_task(void);
#endif
#ifdef WEBUSB_ENABLE
void webusb_task(void);
#endif
/* TESTING
* Amber LED blinker thread, times are in milliseconds.
*/
@@ -214,6 +218,9 @@ int main(void) {
#endif
#ifdef RAW_ENABLE
raw_hid_task();
#endif
#ifdef WEBUSB_ENABLE
webusb_task();
#endif
}
}

78
tmk_core/protocol/chibios/usb_main.c
View File

@@ -37,6 +37,9 @@
extern keymap_config_t keymap_config;
#endif
#ifdef WEBUSB_ENABLE
#include "webusb.h"
#endif
/* ---------------------------------------------------------
* Global interface variables and declarations
* ---------------------------------------------------------
@@ -151,6 +154,22 @@ static const USBEndpointConfig shared_ep_config = {
};
#endif
#ifdef WEBUSB_ENABLE
/** Microsoft OS 2.0 Descriptor. This is used by Windows to select the USB driver for the device.
*
* For WebUSB in Chrome, the correct driver is WinUSB, which is selected via CompatibleID.
*
* Additionally, while Chrome is built using libusb, a magic registry key needs to be set containing a GUID for
* the device.
*/
const MS_OS_20_Descriptor_t PROGMEM MS_OS_20_Descriptor = MS_OS_20_DESCRIPTOR;
/** URL descriptor string. This is a UTF-8 string containing a URL excluding the prefix. At least one of these must be
* defined and returned when the Landing Page descriptor index is requested.
*/
const WebUSB_URL_Descriptor_t PROGMEM WebUSB_LandingPage = WEBUSB_URL_DESCRIPTOR(WEBUSB_LANDING_PAGE_URL);
#endif
typedef struct {
size_t queue_capacity_in;
size_t queue_capacity_out;
@@ -232,6 +251,9 @@ typedef struct {
#endif
#ifdef VIRTSER_ENABLE
usb_driver_config_t serial_driver;
#endif
#ifdef WEBUSB_ENABLE
usb_driver_config_t webusb_driver;
#endif
};
usb_driver_config_t array[0];
@@ -269,6 +291,14 @@ static usb_driver_configs_t drivers = {
# define CDC_OUT_MODE USB_EP_MODE_TYPE_BULK
.serial_driver = QMK_USB_DRIVER_CONFIG(CDC, CDC_NOTIFICATION_EPNUM, false),
#endif
#ifdef WEBUSB_ENABLE
# define WEBUSB_IN_CAPACITY 4
# define WEBUSB_OUT_CAPACITY 4
# define WEBUSB_IN_MODE USB_EP_MODE_TYPE_INTR
# define WEBUSB_OUT_MODE USB_EP_MODE_TYPE_INTR
.webusb_driver = QMK_USB_DRIVER_CONFIG(WEBUSB, 0, false),
#endif
};
#define NUM_USB_DRIVERS (sizeof(drivers) / sizeof(usb_driver_config_t))
@@ -496,6 +526,27 @@ static bool usb_request_hook_cb(USBDriver *usbp) {
}
}
#ifdef WEBUSB_ENABLE
switch (usbp->setup[1]) {
case WEBUSB_VENDOR_CODE:
if (usbp->setup[4] == WebUSB_RTYPE_GetURL) {
if (usbp->setup[2] == WEBUSB_LANDING_PAGE_INDEX) {
usbSetupTransfer(usbp, (uint8_t *)&WebUSB_LandingPage, WebUSB_LandingPage.Header.Size, NULL);
return TRUE;
break;
}
}
break;
case MS_OS_20_VENDOR_CODE:
if (usbp->setup[4] == MS_OS_20_DESCRIPTOR_INDEX) {
usbSetupTransfer(usbp, (uint8_t *)&MS_OS_20_Descriptor, MS_OS_20_Descriptor.Header.TotalLength, NULL);
return TRUE;
break;
}
break;
}
#endif
/* Handle the Get_Descriptor Request for HID class (not handled by the default hook) */
if ((usbp->setup[0] == 0x81) && (usbp->setup[1] == USB_REQ_GET_DESCRIPTOR)) {
dp = usbp->config->get_descriptor_cb(usbp, usbp->setup[3], usbp->setup[2], get_hword(&usbp->setup[4]));
@@ -817,6 +868,33 @@ void raw_hid_task(void) {
#endif
#ifdef WEBUSB_ENABLE
void webusb_send(uint8_t *data, uint8_t length) {
if(chnWriteTimeout(&drivers.webusb_driver.driver, data, length, TIME_IMMEDIATE) != length){
webusb_state.paired = false;
webusb_state.pairing = false;
}
}
__attribute__((weak)) void webusb_receive_kb(uint8_t *data, uint8_t length) {
// Users should #include "raw_hid.h" in their own code
// and implement this function there. Leave this as weak linkage
// so users can opt to not handle data coming in.
}
void webusb_task(void) {
uint8_t buffer[WEBUSB_EPSIZE];
size_t size = 0;
do {
size_t size = chnReadTimeout(&drivers.webusb_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE);
if (size > 0) {
webusb_receive(buffer, size);
}
} while (size > 0);
}
#endif
#ifdef MIDI_ENABLE
void send_midi_packet(MIDI_EventPacket_t *event) { chnWrite(&drivers.midi_driver.driver, (uint8_t *)event, sizeof(MIDI_EventPacket_t)); }

118
tmk_core/protocol/lufa/lufa.c
View File

@@ -90,6 +90,10 @@ extern keymap_config_t keymap_config;
# include "raw_hid.h"
#endif
#ifdef WEBUSB_ENABLE
#include "webusb.h"
#endif
uint8_t keyboard_idle = 0;
/* 0: Boot Protocol, 1: Report Protocol(default) */
uint8_t keyboard_protocol = 1;
@@ -268,6 +272,68 @@ static void Console_Task(void) {
}
#endif
#ifdef WEBUSB_ENABLE
void webusb_send(uint8_t *data, uint8_t length) {
if (USB_DeviceState != DEVICE_STATE_Configured) {
return;
}
Endpoint_SelectEndpoint(WEBUSB_IN_EPNUM);
if(Endpoint_Write_Stream_LE(data, length, NULL)) {
// Stream failed to complete, resetting WEBUSB's state
webusb_state.paired = false;
webusb_state.pairing = false;
}
Endpoint_ClearIN();
}
__attribute__((weak)) void webusb_receive_kb(uint8_t *data, uint8_t length) { }
static void webusb_task(void) {
// Create a temporary buffer to hold the read in data from the host
uint8_t data[WEBUSB_EPSIZE];
bool data_read = false;
// Device must be connected and configured for the task to run
if (USB_DeviceState != DEVICE_STATE_Configured) return;
Endpoint_SelectEndpoint(WEBUSB_OUT_EPNUM);
// Check to see if a packet has been sent from the host
if (Endpoint_IsOUTReceived()) {
// Check to see if the packet contains data
if (Endpoint_IsReadWriteAllowed()) {
/* Read data */
Endpoint_Read_Stream_LE(data, sizeof(data), NULL);
data_read = true;
}
// Finalize the stream transfer to receive the last packet
Endpoint_ClearOUT();
if (data_read) {
webusb_receive(data, sizeof(data));
}
}
}
/** Microsoft OS 2.0 Descriptor. This is used by Windows to select the USB driver for the device.
*
* For WebUSB in Chrome, the correct driver is WinUSB, which is selected via CompatibleID.
*
* Additionally, while Chrome is built using libusb, a magic registry key needs to be set containing a GUID for
* the device.
*/
const MS_OS_20_Descriptor_t PROGMEM MS_OS_20_Descriptor = MS_OS_20_DESCRIPTOR;
/** URL descriptor string. This is a UTF-8 string containing a URL excluding the prefix. At least one of these must be
* defined and returned when the Landing Page descriptor index is requested.
*/
const WebUSB_URL_Descriptor_t PROGMEM WebUSB_LandingPage = WEBUSB_URL_DESCRIPTOR(WEBUSB_LANDING_PAGE_URL);
#endif
/*******************************************************************************
* USB Events
******************************************************************************/
@@ -405,6 +471,12 @@ void EVENT_USB_Device_ConfigurationChanged(void) {
# endif
#endif
#ifdef WEBUSB_ENABLE
/* Setup Webusb Endpoints */
ConfigSuccess &= Endpoint_ConfigureEndpoint(WEBUSB_IN_EPADDR, EP_TYPE_INTERRUPT, WEBUSB_EPSIZE, 1);
ConfigSuccess &= Endpoint_ConfigureEndpoint(WEBUSB_OUT_EPADDR, EP_TYPE_INTERRUPT, WEBUSB_EPSIZE, 1);
#endif
#ifdef MIDI_ENABLE
ConfigSuccess &= Endpoint_ConfigureEndpoint(MIDI_STREAM_IN_EPADDR, EP_TYPE_BULK, MIDI_STREAM_EPSIZE, ENDPOINT_BANK_SINGLE);
ConfigSuccess &= Endpoint_ConfigureEndpoint(MIDI_STREAM_OUT_EPADDR, EP_TYPE_BULK, MIDI_STREAM_EPSIZE, ENDPOINT_BANK_SINGLE);
@@ -536,6 +608,48 @@ void EVENT_USB_Device_ControlRequest(void) {
}
break;
#ifdef WEBUSB_ENABLE
case WEBUSB_VENDOR_CODE:
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_VENDOR | REQREC_DEVICE)) {
switch (USB_ControlRequest.wIndex) {
case WebUSB_RTYPE_GetURL:
switch (USB_ControlRequest.wValue) {
case WEBUSB_LANDING_PAGE_INDEX:
Endpoint_ClearSETUP();
/* Write the descriptor data to the control endpoint */
Endpoint_Write_Control_PStream_LE(&WebUSB_LandingPage, WebUSB_LandingPage.Header.Size);
/* Release the endpoint after transaction. */
Endpoint_ClearStatusStage();
break;
default: /* Stall transfer on invalid index. */
Endpoint_StallTransaction();
break;
}
break;
default: /* Stall on unknown WebUSB request */
Endpoint_StallTransaction();
break;
}
}
break;
case MS_OS_20_VENDOR_CODE:
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_VENDOR | REQREC_DEVICE)) {
switch (USB_ControlRequest.wIndex) {
case MS_OS_20_DESCRIPTOR_INDEX:
Endpoint_ClearSETUP();
/* Write the descriptor data to the control endpoint */
Endpoint_Write_Control_PStream_LE(&MS_OS_20_Descriptor, MS_OS_20_Descriptor.Header.TotalLength);
/* Release the endpoint after transaction. */
Endpoint_ClearStatusStage();
break;
default: /* Stall on unknown MS OS 2.0 request */
Endpoint_StallTransaction();
break;
}
}
break;
#endif
}
#ifdef VIRTSER_ENABLE
@@ -1018,6 +1132,10 @@ int main(void) {
raw_hid_task();
#endif
#ifdef WEBUSB_ENABLE
webusb_task();
#endif
#if !defined(INTERRUPT_CONTROL_ENDPOINT)
USB_USBTask();
#endif

74
tmk_core/protocol/usb_descriptor.c
View File

@@ -39,7 +39,9 @@
#include "util.h"
#include "report.h"
#include "usb_descriptor.h"
#ifdef WEBUSB_ENABLE
#include "webusb_descriptor.h"
#endif
/*
* HID report descriptors
*/
@@ -274,11 +276,22 @@ const USB_Descriptor_HIDReport_Datatype_t PROGMEM ConsoleReport[] = {
};
#endif
#ifdef WEBUSB_ENABLE
const USB_Descriptor_BOS_t PROGMEM BOSDescriptor = BOS_DESCRIPTOR(
(MS_OS_20_PLATFORM_DESCRIPTOR(MS_OS_20_VENDOR_CODE, MS_OS_20_DESCRIPTOR_SET_TOTAL_LENGTH))
(WEBUSB_PLATFORM_DESCRIPTOR(WEBUSB_VENDOR_CODE, WEBUSB_LANDING_PAGE_INDEX))
);
#endif
/*
* Device descriptor
*/
const USB_Descriptor_Device_t PROGMEM DeviceDescriptor = {.Header = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
#if WEBUSB_ENABLE
.USBSpecification = VERSION_BCD(2, 1, 0),
#else
.USBSpecification = VERSION_BCD(1, 1, 0),
#endif
#if VIRTSER_ENABLE
.Class = USB_CSCP_IADDeviceClass,
.SubClass = USB_CSCP_IADDeviceSubclass,
@@ -331,6 +344,16 @@ const USB_Descriptor_Configuration_t PROGMEM
.Keyboard_INEndpoint = {.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, .EndpointAddress = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM), .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), .EndpointSize = KEYBOARD_EPSIZE, .PollingIntervalMS = USB_POLLING_INTERVAL_MS},
#endif
#ifdef RAW_ENABLE
/*
* Raw HID
*/
.Raw_Interface = {.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface}, .InterfaceNumber = RAW_INTERFACE, .AlternateSetting = 0x00, .TotalEndpoints = 2, .Class = HID_CSCP_HIDClass, .SubClass = HID_CSCP_NonBootSubclass, .Protocol = HID_CSCP_NonBootProtocol, .InterfaceStrIndex = NO_DESCRIPTOR},
.Raw_HID = {.Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID}, .HIDSpec = VERSION_BCD(1, 1, 1), .CountryCode = 0x00, .TotalReportDescriptors = 1, .HIDReportType = HID_DTYPE_Report, .HIDReportLength = sizeof(RawReport)},
.Raw_INEndpoint = {.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, .EndpointAddress = (ENDPOINT_DIR_IN | RAW_IN_EPNUM), .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), .EndpointSize = RAW_EPSIZE, .PollingIntervalMS = 0x01},
.Raw_OUTEndpoint = {.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, .EndpointAddress = (ENDPOINT_DIR_OUT | RAW_OUT_EPNUM), .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), .EndpointSize = RAW_EPSIZE, .PollingIntervalMS = 0x01},
#endif
#if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP)
/*
* Mouse
@@ -361,16 +384,6 @@ const USB_Descriptor_Configuration_t PROGMEM
.Shared_INEndpoint = {.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, .EndpointAddress = (ENDPOINT_DIR_IN | SHARED_IN_EPNUM), .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), .EndpointSize = SHARED_EPSIZE, .PollingIntervalMS = USB_POLLING_INTERVAL_MS},
#endif
#ifdef RAW_ENABLE
/*
* Raw HID
*/
.Raw_Interface = {.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface}, .InterfaceNumber = RAW_INTERFACE, .AlternateSetting = 0x00, .TotalEndpoints = 2, .Class = HID_CSCP_HIDClass, .SubClass = HID_CSCP_NonBootSubclass, .Protocol = HID_CSCP_NonBootProtocol, .InterfaceStrIndex = NO_DESCRIPTOR},
.Raw_HID = {.Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID}, .HIDSpec = VERSION_BCD(1, 1, 1), .CountryCode = 0x00, .TotalReportDescriptors = 1, .HIDReportType = HID_DTYPE_Report, .HIDReportLength = sizeof(RawReport)},
.Raw_INEndpoint = {.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, .EndpointAddress = (ENDPOINT_DIR_IN | RAW_IN_EPNUM), .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), .EndpointSize = RAW_EPSIZE, .PollingIntervalMS = 0x01},
.Raw_OUTEndpoint = {.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, .EndpointAddress = (ENDPOINT_DIR_OUT | RAW_OUT_EPNUM), .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), .EndpointSize = RAW_EPSIZE, .PollingIntervalMS = 0x01},
#endif
#ifdef CONSOLE_ENABLE
/*
* Console
@@ -381,6 +394,38 @@ const USB_Descriptor_Configuration_t PROGMEM
.Console_OUTEndpoint = {.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint}, .EndpointAddress = (ENDPOINT_DIR_OUT | CONSOLE_OUT_EPNUM), .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), .EndpointSize = CONSOLE_EPSIZE, .PollingIntervalMS = 0x01},
#endif
#ifdef WEBUSB_ENABLE
/*
* Webusb
*/
.WebUSB_Interface = {.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
.InterfaceNumber = INTERFACE_ID_WebUSB,
.AlternateSetting = 0x00,
.TotalEndpoints = 2,
.Class = USB_CSCP_VendorSpecificClass,
.SubClass = 0x00,
.Protocol = 0x00,
.InterfaceStrIndex = NO_DESCRIPTOR},
.WebUSB_DataInEndpoint = {.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
.EndpointAddress = WEBUSB_IN_EPADDR,
.Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
.EndpointSize = WEBUSB_EPSIZE,
.PollingIntervalMS = 0x05},
.WebUSB_DataOutEndpoint = {.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
.EndpointAddress = WEBUSB_OUT_EPADDR,
.Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
.EndpointSize = WEBUSB_EPSIZE,
.PollingIntervalMS = 0x05},
#endif
#ifdef MIDI_ENABLE
/*
* MIDI
@@ -520,6 +565,13 @@ uint16_t get_usb_descriptor(const uint16_t wValue, const uint16_t wIndex, const
Size = sizeof(USB_Descriptor_Device_t);
break;
#ifdef WEBUSB_ENABLE
case DTYPE_BOS:
Address = &BOSDescriptor;
Size = pgm_read_byte(&BOSDescriptor.TotalLength);
break;
#endif
case DTYPE_Configuration:
Address = &ConfigurationDescriptor;
Size = sizeof(USB_Descriptor_Configuration_t);

37
tmk_core/protocol/usb_descriptor.h
View File

@@ -48,6 +48,9 @@
#ifdef PROTOCOL_CHIBIOS
# include "hal.h"
#endif
#ifdef WEBUSB_ENABLE
#include "webusb_descriptor.h"
#endif
/*
* USB descriptor structure
@@ -62,6 +65,14 @@ typedef struct {
USB_Descriptor_Endpoint_t Keyboard_INEndpoint;
#endif
#ifdef RAW_ENABLE
// Raw HID Interface
USB_Descriptor_Interface_t Raw_Interface;
USB_HID_Descriptor_HID_t Raw_HID;
USB_Descriptor_Endpoint_t Raw_INEndpoint;
USB_Descriptor_Endpoint_t Raw_OUTEndpoint;
#endif
#if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP)
// Mouse HID Interface
USB_Descriptor_Interface_t Mouse_Interface;
@@ -76,14 +87,6 @@ typedef struct {
USB_Descriptor_Endpoint_t Shared_INEndpoint;
#endif
#ifdef RAW_ENABLE
// Raw HID Interface
USB_Descriptor_Interface_t Raw_Interface;
USB_HID_Descriptor_HID_t Raw_HID;
USB_Descriptor_Endpoint_t Raw_INEndpoint;
USB_Descriptor_Endpoint_t Raw_OUTEndpoint;
#endif
#ifdef CONSOLE_ENABLE
// Console HID Interface
USB_Descriptor_Interface_t Console_Interface;
@@ -92,6 +95,12 @@ typedef struct {
USB_Descriptor_Endpoint_t Console_OUTEndpoint;
#endif
#ifdef WEBUSB_ENABLE
USB_Descriptor_Interface_t WebUSB_Interface;
USB_Descriptor_Endpoint_t WebUSB_DataInEndpoint;
USB_Descriptor_Endpoint_t WebUSB_DataOutEndpoint;
#endif
#ifdef MIDI_ENABLE
USB_Descriptor_Interface_Association_t Audio_Interface_Association;
// MIDI Audio Control Interface
@@ -164,6 +173,10 @@ enum usb_interfaces {
CDI_INTERFACE,
#endif
#ifdef WEBUSB_ENABLE
INTERFACE_ID_WebUSB,
#endif
TOTAL_INTERFACES
};
@@ -224,6 +237,13 @@ enum usb_endpoints {
# define CDC_IN_EPADDR (ENDPOINT_DIR_IN | CDC_IN_EPNUM)
# define CDC_OUT_EPADDR (ENDPOINT_DIR_OUT | CDC_OUT_EPNUM)
#endif
#ifdef WEBUSB_ENABLE
WEBUSB_IN_EPNUM = NEXT_EPNUM,
WEBUSB_OUT_EPNUM = NEXT_EPNUM,
# define WEBUSB_IN_EPADDR (ENDPOINT_DIR_IN | WEBUSB_IN_EPNUM)
# define WEBUSB_OUT_EPADDR (ENDPOINT_DIR_OUT | WEBUSB_OUT_EPNUM)
#endif
};
#ifdef PROTOCOL_LUFA
@@ -248,6 +268,7 @@ enum usb_endpoints {
#define MIDI_STREAM_EPSIZE 64
#define CDC_NOTIFICATION_EPSIZE 8
#define CDC_EPSIZE 16
#define WEBUSB_EPSIZE 64
uint16_t get_usb_descriptor(const uint16_t wValue, const uint16_t wIndex, const void** const DescriptorAddress);
#endif

9
tmk_core/protocol/vusb/main.c
View File

@@ -20,6 +20,11 @@
#include "timer.h"
#include "uart.h"
#include "debug.h"
#include "rgblight_reconfig.h"
#if (defined(RGB_MIDI) | defined(RGBLIGHT_ANIMATIONS)) & defined(RGBLIGHT_ENABLE)
# include "rgblight.h"
#endif
#define UART_BAUD_RATE 115200
@@ -94,6 +99,10 @@ int main(void) {
// To prevent failing to configure NOT scan keyboard during configuration
if (usbConfiguration && usbInterruptIsReady()) {
keyboard_task();
#if defined(RGBLIGHT_ANIMATIONS) && defined(RGBLIGHT_ENABLE)
rgblight_task();
#endif
}
vusb_transfer_keyboard();
}

264
tmk_core/protocol/webusb_descriptor.h Normal file
View File

@@ -0,0 +1,264 @@
#pragma once
#ifndef WORD_TO_BYTES_LE
# define WORD_TO_BYTES_LE(n) n % 256, (n / 256) % 256
#endif
#ifndef LONG_TO_BYTES_LE
# define LONG_TO_BYTES_LE(n) n % 256, (n / 256) % 256, (n / 65536) % 256, (n / 16777216) % 256
#endif
#define WEBUSB_VENDOR_CODE 0x42
#ifndef WEBUSB_LANDING_PAGE_URL
# define WEBUSB_LANDING_PAGE_URL u8"docs.qmk.fm"
#endif
#define WEBUSB_LANDING_PAGE_PROTOCOL 1 /* 0: http 1: https forced to 1 since https is a requirement to connect over webusb */
#define WEBUSB_LANDING_PAGE_INDEX 1
#define WEBUSB_VERSION VERSION_BCD(1, 0, 0)
/* $ python -c "import uuid;print(', '.join(map(hex, uuid.UUID('3408b638-09a9-47a0-8bfd-a0768815b665').bytes_le)))" */
#define WEBUSB_PLATFORM_UUID 0x38, 0xb6, 0x8, 0x34, 0xa9, 0x9, 0xa0, 0x47, 0x8b, 0xfd, 0xa0, 0x76, 0x88, 0x15, 0xb6, 0x65
/** \brief Convenience macro to easily create device capability platform descriptors for the WebUSB platform.
*
* \note This macro is designed to be wrapped in parentheses and included in a sequence to the \ref BOS_DESCRIPTOR macro.
*
* \param[in] VendorCode Vendor Code that all control requests coming from the browser must use.
*
* \param[in] LandingPageIndex Index of the URL Descriptor to use as the Landing Page for the device.
*
*/
#define WEBUSB_PLATFORM_DESCRIPTOR(VendorCode, LandingPageIndex) /* WebUSB Platform Descriptor size */ 24, DTYPE_DeviceCapability, DCTYPE_Platform, /* Reserved */ 0, WEBUSB_PLATFORM_UUID, WORD_TO_BYTES_LE(WEBUSB_VERSION), VendorCode, LandingPageIndex
/** \brief Convenience macro to easily create \ref WebUSB_URL_Descriptor_t instances from a wide character string.
*
* \note This macro is for little-endian systems only.
*
* \param[in] URL URL string to initialize a URL Descriptor structure with.
*
* \note Prefix String literal with u8 to ensure proper conversion: e.g. WEBUSB_URL_DESCRIPTOR(u8"www.google.com")
*/
#define WEBUSB_URL_DESCRIPTOR(URL) \
{ .Header = {.Size = sizeof(WebUSB_URL_Descriptor_t) + (sizeof(URL) - 1), .Type = WebUSB_DTYPE_URL}, .Scheme = (WEBUSB_LANDING_PAGE_PROTOCOL), .UTF8_URL = (URL) }
/* WebUSB Protocol Data Structures */
enum WebUSB_Request_t {
WebUSB_RTYPE_GetURL = 2, /**< Indicates the device should return the indicated WebUSB_URL descriptor. */
};
enum WebUSB_Descriptor_t {
WebUSB_DTYPE_URL = 3, /**< Indicates that the descriptor is a URL descriptor. */
};
/** \brief WebUSB URL Descriptor (LUFA naming convention).
*
* Type define for a WebUSB URL Descriptor. This structure uses LUFA-specific element names
* to make each element's purpose clearer.
*
* \note Regardless of CPU architecture, these values should be stored as little endian.
*/
typedef struct {
USB_Descriptor_Header_t Header; /**< Descriptor header, including type (WebUSB_DTYPE_URL) and size. */
uint8_t Scheme; /**< URL scheme prefix: 0 means http://, 1 means https://, 255 means included in URL */
uint8_t UTF8_URL[]; /**< UTF-8 encoded URL (excluding scheme prefix). */
} ATTR_PACKED WebUSB_URL_Descriptor_t;
#define MS_OS_20_VENDOR_CODE 0x45 // Must be different than WEBUSB_VENDOR_CODE
#define MS_OS_20_DESCRIPTOR_CONFIGURATION_HEADER_LENGTH 168
#define MS_OS_20_DESCRIPTOR_FUNCTION_HEADER_LENGTH 160
#define MS_OS_20_DESCRIPTOR_SET_TOTAL_LENGTH 178 // Sum of `.Length`s in MS_OS_20_Descriptor in WebUSB.c
#define MS_OS_20_DESCRIPTOR_COMPATIBILITY_ID { 'W', 'I', 'N', 'U', 'S', 'B', 0, 0 }
#define MS_OS_20_DESCRIPTOR_SUB_COMPATIBILITY_ID {0, 0, 0, 0, 0, 0, 0, 0}
#define MS_OS_20_PROPERTY_NAME_LENGTH 42
#define MS_OS_20_PROPERTY_NAME { \
'D', 0x00, 'e', 0x00, 'v', 0x00, 'i', 0x00, 'c', 0x00, 'e', 0x00, \
'I', 0x00, 'n', 0x00, 't', 0x00, 'e', 0x00, 'r', 0x00, 'f', 0x00, \
'a', 0x00, 'c', 0x00, 'e', 0x00, 'G', 0x00, 'U', 0x00, 'I', 0x00, \
'D', 0x00, 's', 0x00, 0x00, 0x00 \
}
#define MS_OS_20_PROPERTY_DATA_LENGTH 80
#define MS_OS_20_PROPERTY_DATA { \
'{', 0x00, '9', 0x00, 'D', 0x00, 'B', 0x00, '7', 0x00, 'F', 0x00, \
'1', 0x00, 'F', 0x00, 'D', 0x00, '-', 0x00, '7', 0x00, 'E', 0x00, \
'7', 0x00, 'A', 0x00, '-', 0x00, '4', 0x00, '0', 0x00, '0', 0x00, \
'8', 0x00, '-', 0x00, '9', 0x00, '3', 0x00, '6', 0x00, 'B', 0x00, \
'-', 0x00, '6', 0x00, 'B', 0x00, 'A', 0x00, '6', 0x00, 'C', 0x00, \
'1', 0x00, '9', 0x00, 'A', 0x00, '3', 0x00, '0', 0x00, '8', 0x00, \
'c', 0x00, '}', 0x00, 0x00, 0x00, 0x00, 0x00 \
}
#define MS_OS_20_PLATFORM_UUID 0xdf, 0x60, 0xdd, 0xd8, 0x89, 0x45, 0xc7, 0x4c, 0x9c, 0xd2, 0x65, 0x9d, 0x9e, 0x64, 0x8a, 0x9f
#define MS_OS_20_WINDOWS_VERSION_8_1 0x06030000 // Windows version (8.1)
#ifndef MS_OS_20_ALTERNATE_ENUMERATION_CODE
# define MS_OS_20_ALTERNATE_ENUMERATION_CODE 0 /**< Set to non-zero to enable Windows to allow device to return alternate USB descriptors. */
#endif
/** \brief Convenience macro to easily create device capability platform descriptors for the MS OS 2.0 platform.
*
* \note This macro is designed to be wrapped in parentheses and included in a sequence to the \ref BOS_DESCRIPTOR macro.
*
* \param[in] VendorCode Vendor Code that all control requests coming from Windows must use.
*
* \param[in] TotalLength The length, in bytes, of the MS OS 2.0 descriptor set to be retrieved by Windows.
*/
#define MS_OS_20_PLATFORM_DESCRIPTOR(VendorCode, TotalLength) /* Total size of this descriptor */ 28, DTYPE_DeviceCapability, DCTYPE_Platform, /* Reserved */ 0, MS_OS_20_PLATFORM_UUID, LONG_TO_BYTES_LE(MS_OS_20_WINDOWS_VERSION_8_1), WORD_TO_BYTES_LE(TotalLength), VendorCode, MS_OS_20_ALTERNATE_ENUMERATION_CODE
/* MS OS 2.0 Descriptors Data Structures */
enum MS_OS_20_wIndex_t {
MS_OS_20_DESCRIPTOR_INDEX = 0x07, /**< Indicates the device should return MS OS 2.0 Descriptor Set. */
MS_OS_20_SET_ALT_ENUMERATION = 0x08, /**< Indicates the device may "subsequently return alternate USB descriptors when Windows requests the information." */
};
enum MS_OS_20_Descriptor_Types {
MS_OS_20_SET_HEADER_DESCRIPTOR = 0x00,
MS_OS_20_SUBSET_HEADER_CONFIGURATION = 0x01,
MS_OS_20_SUBSET_HEADER_FUNCTION = 0x02,
MS_OS_20_FEATURE_COMPATBLE_ID = 0x03,
MS_OS_20_FEATURE_REG_PROPERTY = 0x04,
// MS_OS_20_FEATURE_MIN_RESUME_TIME = 0x05,
// MS_OS_20_FEATURE_MODEL_ID = 0x06,
MS_OS_20_FEATURE_CCGP_DEVICE = 0x07,
};
/** \brief Microsoft OS 2.0 Descriptor Set Header (LUFA naming convention).
*
* \note Regardless of CPU architecture, these values should be stored as little endian.
*/
typedef struct {
uint16_t Length; /**< The length, in bytes, of this header. Shall be set to 10. */
uint16_t DescriptorType; /**< Shall be set to MS_OS_20_SET_HEADER_DESCRIPTOR */
uint32_t WindowsVersion;
uint16_t TotalLength; /**< The size of entire MS OS 2.0 descriptor set. The value shall match the value in the descriptor set information structure. */
} ATTR_PACKED MS_OS_20_Descriptor_Set_Header_t;
/** \brief Microsoft OS 2.0 configuration subset header.
*
*/
typedef struct {
uint16_t Length; /**< The length, in bytes, of this subset header. Shall be set to 8. */
uint16_t DescriptorType; /**< MS_OS_20_SUBSET_HEADER_CONFIGURATION */
uint8_t ConfigurationValue; /**< The configuration value for the USB configuration to which this subset applies. */
uint8_t Reserved; /**< Shall be set to 0. */
uint16_t TotalLength; /**< The size of entire configuration subset including this header. */
} ATTR_PACKED MS_OS_20_Configuration_Subset_Header;
/** \brief Microsoft OS 2.0 Function subset header.
*
*/
typedef struct {
uint16_t Length; /**< The length, in bytes, of this subset header. Shall be set to 8. */
uint16_t DescriptorType; /**< MS_OS_20_SUBSET_HEADER_FUNCTION */
uint8_t FirstInterface; /**< The interface number for the first interface of the function to which this subset applies. */
uint8_t Reserved; /**< Shall be set to 0. */
uint16_t SubsetLength; /**< The size of entire function subset including this header. */
} ATTR_PACKED MS_OS_20_Function_Subset_Header;
/** \brief Microsoft OS 2.0 Feature Descriptor for CompatibleID.
*
* These values are used by Windows to locate the appropriate driver for the device.
*
* For WebUSB in Chrome, the CompatibleID needs to be WINUSB, and the SubCompatibleID is null.
*
* \note ID values must be 8 bytes long and contain only the ASCII values for uppercase letters, numbers, underscores, and the NULL character. No other characters are allowed, and the last byte in the ID must be the NULL 0x00.
*/
typedef struct {
uint16_t Length; /**< The length, bytes, of the compatible ID descriptor including value descriptors. Shall be set to 20. */
uint16_t DescriptorType; /**< MS_OS_20_FEATURE_COMPATIBLE_ID */
uint8_t CompatibleID[8]; /**< Compatible ID ASCII String */
uint8_t SubCompatibleID[8]; /**< Sub-compatible ID ASCII String */
} ATTR_PACKED MS_OS_20_CompatibleID_Descriptor;
/** \brief Property Data Type values for the Microsoft OS 2.0 Registry Property Descriptor.
*
*/
enum MS_OS_20_Property_Data_Types {
MS_OS_20_REG_SZ = 1, /**< A NULL-terminated Unicode String */
MS_OS_20_REG_EXPAND_SZ = 2, /**< A NULL-terminated Unicode String that includes environment variables */
MS_OS_20_REG_BINARY = 3, /**< Free-form binary */
MS_OS_20_REG_DWORD_LITTLE_ENDIAN = 4, /**< A little-endian 32-bit integer */
MS_OS_20_REG_DWORD_BIG_ENDIAN = 5, /**< A big-endian 32-bit integer */
MS_OS_20_REG_LINK = 6, /**< A NULL-terminated Unicode string that contains a symbolic link */
MS_OS_20_REG_MULTI_SZ = 7 /**< Multiple NULL-terminated Unicode strings */
};
/** \brief Microsoft OS 2.0 Registry Property Descriptor.
*
* This descriptor is used to add per-device or per-function registry values that is read by the Windows USB driver stack or the device’s function driver.
*/
typedef struct {
uint16_t Length; /**< The length in bytes of is descriptor. */
uint16_t DescriptorType; /**< MS_OS_20_FEATURE_REG_PROPERTY */
uint16_t PropertyDataType; /**< MS_OS_20_Property_Data_types, MS_OS_20_REG_MULTI_SZ even for single interface because libusb. */
uint16_t PropertyNameLength; /**< The length of the property name. */
uint8_t PropertyName[MS_OS_20_PROPERTY_NAME_LENGTH]; /**< The name of registry property as NULL-terminated UTF-16 LE string. */
uint16_t PropertyDataLength; /**< The length of property data. */
uint8_t PropertyData[MS_OS_20_PROPERTY_DATA_LENGTH]; /**< Property Data. */
} ATTR_PACKED MS_OS_20_Registry_Property_Descriptor;
/** \brief Microsoft OS 2.0 Feature Descriptor for CCGP Devices.
*
* This descriptor indicates that the device should be treated as a composite device by Windows regardless of
* the number of interfaces, configuration, or class, subclass, and protocol codes, the device reports.
*
* \note The CCGP device descriptor must be applied to the entire device.
*/
typedef struct {
uint16_t Length; /**< The length, bytes, of the compatible ID descriptor including value descriptors. Shall be set to 4. */
uint16_t DescriptorType; /**< MS_OS_20_FEATURE_CCGP_DEVICE */
} ATTR_PACKED MS_OS_20_CCGP_Device_Descriptor;
typedef struct {
MS_OS_20_Descriptor_Set_Header_t Header;
MS_OS_20_Configuration_Subset_Header ConfigurationSubsetHeader;
MS_OS_20_Function_Subset_Header FunctionSubsetHeader;
MS_OS_20_CompatibleID_Descriptor CompatibleID;
MS_OS_20_Registry_Property_Descriptor RegistryProperty;
} MS_OS_20_Descriptor_t;
#define MS_OS_20_DESCRIPTOR { \
.Header = { \
.Length = CPU_TO_LE16(10), \
.DescriptorType = CPU_TO_LE16(MS_OS_20_SET_HEADER_DESCRIPTOR), \
.WindowsVersion = MS_OS_20_WINDOWS_VERSION_8_1, \
.TotalLength = CPU_TO_LE16(MS_OS_20_DESCRIPTOR_SET_TOTAL_LENGTH) \
}, \
.ConfigurationSubsetHeader = { \
.Length = CPU_TO_LE16(8), \
.DescriptorType = CPU_TO_LE16(MS_OS_20_SUBSET_HEADER_CONFIGURATION), \
.ConfigurationValue = 0, \
.Reserved = 0, \
.TotalLength = CPU_TO_LE16(MS_OS_20_DESCRIPTOR_CONFIGURATION_HEADER_LENGTH) \
}, \
.FunctionSubsetHeader = { \
.Length = CPU_TO_LE16(8), \
.DescriptorType = CPU_TO_LE16(MS_OS_20_SUBSET_HEADER_FUNCTION), \
.FirstInterface = INTERFACE_ID_WebUSB, \
.Reserved = 0, \
.SubsetLength = CPU_TO_LE16(MS_OS_20_DESCRIPTOR_FUNCTION_HEADER_LENGTH) \
}, \
.CompatibleID = { \
.Length = CPU_TO_LE16(20), \
.DescriptorType = CPU_TO_LE16(MS_OS_20_FEATURE_COMPATBLE_ID), \
.CompatibleID = MS_OS_20_DESCRIPTOR_COMPATIBILITY_ID, \
.SubCompatibleID = MS_OS_20_DESCRIPTOR_SUB_COMPATIBILITY_ID \
}, \
.RegistryProperty = { \
.Length = CPU_TO_LE16(132), \
.DescriptorType = CPU_TO_LE16(MS_OS_20_FEATURE_REG_PROPERTY), \
.PropertyDataType = CPU_TO_LE16(MS_OS_20_REG_MULTI_SZ), \
.PropertyNameLength = CPU_TO_LE16(MS_OS_20_PROPERTY_NAME_LENGTH), \
.PropertyName = MS_OS_20_PROPERTY_NAME, \
.PropertyDataLength = CPU_TO_LE16(MS_OS_20_PROPERTY_DATA_LENGTH), \
.PropertyData = MS_OS_20_PROPERTY_DATA \
} \
}

37
util/drivers.txt
View File

@@ -3,45 +3,12 @@
# Use a comma as a separator without spaces
# Driver can be one of winusb,libusb,libusbk
# Use Windows Powershell and type [guid]::NewGuid() to generate guids
winusb,STM32 Bootloader,0483,DF11,6d98a87f-4ecf-464d-89ed-8c684d857a75
libusb,USBaspLoader,16C0,05DC,e69affdc-0ef0-427c-aefb-4e593c9d2724
winusb,Kiibohd DFU Bootloader,1C11,B007,aa5a3f86-b81e-4416-89ad-0c1ea1ed63af
winusb,STM32 Bootloader,0483,df11,6d98a87f-4ecf-464d-89ed-8c684d857a75
libusb,ATxmega16C4,03EB,2FD8,23266ee7-5423-4cc4-993b-034571c43a90
libusb,ATxmega32C4,03EB,2FD9,d4b62886-2ac8-4534-aa24-eae0a2c3ce43
libusb,ATxmega64C3,03EB,2FD6,08467ca7-9b5a-41d2-8d8a-4a26d0b5285b
libusb,ATxmega128C3,03EB,2FD7,1ca69799-6d95-46cf-be69-5b3d0eb915e6
libusb,ATxmega256C3,03EB,2FDA,216ddc8b-6c67-4cc0-b934-482829a483a0
libusb,ATxmega384C3,03EB,2FDB,0e4e3347-6025-4d49-ba80-2375ea690c28
libusb,ATxmega64A1U,03EB,2FE8,2553d8fa-7de1-44a6-bdbf-57be8bb37e28
libusb,ATxmega128A1U,03EB,2FED,6d9fd0ff-755d-4e29-bd29-df0a9a7544b9
libusb,ATxmega64A4U,03EB,2FDD,bcf5e7c3-44a1-4fd1-971f-9ef9843f6291
libusb,ATxmega128A4U,03EB,2FDE,3f976bb6-36ca-44cc-a728-844bc1d0d168
libusb,ATxmega64B3,03EB,2FDF,de280c81-c12a-4ca7-bf34-566151786418
libusb,ATxmega128B3,03EB,2FE0,2ad1ffeb-eb83-4e78-b34a-d5633771991f
libusb,ATxmega64B1,03EB,2FE1,002874a6-7fc7-413b-9ac4-2b52c5a230bd
libusb,ATxmega128B1,03EB,2FEA,60ea9d08-2ae6-4434-b743-ce6f73537136
libusb,ATxmega256A3BU,03EB,2FE2,5949bd0a-8bd4-417b-b1c5-7d249836bf0d
libusb,ATxmega16A4U,03EB,2FE3,cc3172b0-e86a-4758-914e-951bca6ca7f5
libusb,ATxmega32A4U,03EB,2FE4,f44c515f-7d17-4612-a532-ee620afb22b2
libusb,ATxmega64A4U,03EB,2FE5,c1af4f1c-045f-40c9-893a-3ad4adb2e67d
libusb,ATxmega128A3U,03EB,2FE6,26f275f0-d6b2-46d8-8334-e4de66996c74
libusb,ATxmega192A3U,03EB,2FE7,b7b50d98-0429-4235-8f08-5466e4f83ed4
libusb,UC3,03EB,2FDC,972d9af7-d71b-44c7-a895-9340b362f545
libusb,ATUC3,03EB,2FE9,d5855d0a-f82e-4df5-9c14-2b0b1dcb65bd
libusb,AT32UC3C,03EB,2FEB,1eeb52aa-fd24-47fd-8a76-056446d1a54f
libusb,ATxmega256A3U,03EB,2FEC,198fa8ea-3157-4863-b9a8-a3f6fe027367
libusb,ATmega8U2,03EB,2FEE,14018055-46f4-4c62-aa03-e8fafeedaf72
libusb,ATmega16U2,03EB,2FEF,007274da-b75f-492e-a288-8fc0aff8339f
libusb,ATmega32U2,03EB,2FF0,ddc2c572-cb6e-4f61-a6cc-1a5de941f063
libusb,AT32UC3A3,03EB,2FF1,8b614283-36c0-46a2-890d-65f61b5b6201
libusb,ATmega32U6,03EB,2FF2,a207dd90-2814-4418-b5b7-4b708fdf1bfd
libusb,ATmega16U4,03EB,2FF3,3180d426-bf93-4578-a693-2efbc337da8e
libusb,ATmega32U4,03EB,2FF4,5f9726fd-f9de-487a-9fbd-8b3524a7a56a
libusb,AT32UC3B,03EB,2FF6,ef90068a-277a-44db-805a-9b83a6beb29a
libusb,AT90USB82,03EB,2FF7,062fa2ab-f9d8-4a0d-83c1-df0521cfd0f6
libusb,AT32UC3A,03EB,2FF8,24080a67-3874-4fb8-8808-fb4cc297c466
libusb,AT90USB64,03EB,2FF9,c6a708ad-e97d-43cd-b04a-3180d737a71b
libusb,AT90USB162,03EB,2FFA,de67bff5-6e39-4e9c-8dfe-de7fce113716
libusb,AT90USB128,03EB,2FFB,fd217df3-59d0-440a-a8f3-4c0c8c84daa3
libusb,AT89C5130,03EB,2FFD,31b69a56-9ac0-4fab-a3ae-cd7bb7021ec5
libusb,AT8XC5122,03EB,2FFE,395a6118-8568-41b2-913a-d16912722342
libusb,AT89C5132,03EB,2FFF,266ca4bc-5e59-4a7b-82dc-6e8732373d40

26
util/linux_install.sh
View File

@@ -76,6 +76,7 @@ elif grep ID /etc/os-release | grep -q 'arch\|manjaro'; then
gcc \
git \
python \
python-pip \
unzip \
wget \
zip
@@ -182,6 +183,29 @@ elif grep ID /etc/os-release | grep -q solus; then
unzip
printf "\n$SOLUS_INFO\n"
elif grep ID /etc/os-release | grep -q void; then
# musl Void systems don't have glibc cross compilers avaliable in their repos.
# glibc Void systems do have musl cross compilers though, for some reason.
# So, default to musl, and switch to glibc if it is installed.
CROSS_ARM=cross-arm-linux-musleabi
if xbps-query glibc > /dev/null; then # Check is glibc if installed
CROSS_ARM=cross-arm-linux-gnueabi
fi
sudo xbps-install \
avr-binutils \
avr-gcc \
avr-libc \
$CROSS_ARM \
dfu-programmer \
dfu-util \
gcc \
git \
make \
wget \
unzip \
zip
else
echo "Sorry, we don't recognize your OS. Help us by contributing support!"
echo
@@ -189,4 +213,4 @@ else
fi
# Global install tasks
pip3 install -r ${util_dir}/../requirements.txt
pip3 install --user -r ${util_dir}/../requirements.txt