ahoneybun/qmk_firmware
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into debounce_refactor

Browse source 
# Conflicts:
#	tmk_core/common/keyboard.c
This commit is contained in:
Alex Ong 2019-01-04 19:43:45 +11:00
commit 2bb2977c13
3425 changed files with 216380 additions and 20651 deletions
Download patch file Download diff file Expand all files Collapse all files

4
quantum/api.h
View file

@ -17,7 +17,9 @@
#ifndef _API_H_
#define _API_H_
#ifdef __AVR__
#include "lufa.h"
#endif
enum MESSAGE_TYPE {
MT_GET_DATA = 0x10, // Get data from keyboard
@ -28,7 +30,7 @@ enum MESSAGE_TYPE {
MT_SEND_DATA_ACK = 0x31, // returned data/action confirmation (ACK)
MT_EXE_ACTION = 0x40, // executing actions on keyboard
MT_EXE_ACTION_ACK =0x41, // return confirmation/value (ACK)
MT_TYPE_ERROR = 0x80 // type not recofgnised (ACK)
MT_TYPE_ERROR = 0x80 // type not recognised (ACK)
};
enum DATA_TYPE {

8
quantum/audio/audio.c
View file

@ -223,7 +223,7 @@ void audio_init()
TCCR1B = (1 << WGM13) | (1 << WGM12) | (0 << CS12) | (1 << CS11) | (0 << CS10);
TIMER_1_PERIOD = (uint16_t)(((float)F_CPU) / (440 * CPU_PRESCALER));
TIMER_1_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (440 * CPU_PRESCALER)) * note_timbre);
#endif
#endif
audio_initialized = true;
}
@ -231,7 +231,7 @@ void audio_init()
if (audio_config.enable) {
PLAY_SONG(startup_song);
}
}
void stop_all_notes()
@ -464,7 +464,7 @@ ISR(TIMER3_AUDIO_vect)
note_position++;
bool end_of_note = false;
if (TIMER_3_PERIOD > 0) {
if (!note_resting)
if (!note_resting)
end_of_note = (note_position >= (note_length / TIMER_3_PERIOD * 0xFFFF - 1));
else
end_of_note = (note_position >= (note_length));
@ -604,7 +604,7 @@ ISR(TIMER1_AUDIO_vect)
note_position++;
bool end_of_note = false;
if (TIMER_1_PERIOD > 0) {
if (!note_resting)
if (!note_resting)
end_of_note = (note_position >= (note_length / TIMER_1_PERIOD * 0xFFFF - 1));
else
end_of_note = (note_position >= (note_length));

3
quantum/audio/audio.h
View file

@ -40,7 +40,8 @@ typedef union {
uint8_t raw;
struct {
bool enable :1;
uint8_t level :7;
bool clicky_enable :1;
uint8_t level :6;
};
} audio_config_t;

135
quantum/audio/audio_arm.c
View file

@ -80,6 +80,9 @@ float startup_song[][2] = STARTUP_SONG;
static void gpt_cb8(GPTDriver *gptp);
#define DAC_BUFFER_SIZE 720
#ifndef DAC_SAMPLE_MAX
#define DAC_SAMPLE_MAX 65535U
#endif
#define START_CHANNEL_1() gptStart(&GPTD6, &gpt6cfg1); \
gptStartContinuous(&GPTD6, 2U)
@ -202,132 +205,16 @@ GPTConfig gpt8cfg1 = {
// squarewave
static const dacsample_t dac_buffer[DAC_BUFFER_SIZE] = {
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
// First half is max, second half is 0
[0 ... DAC_BUFFER_SIZE/2-1] = DAC_SAMPLE_MAX,
[DAC_BUFFER_SIZE/2 ... DAC_BUFFER_SIZE -1] = 0,
};
// squarewave
static const dacsample_t dac_buffer_2[DAC_BUFFER_SIZE] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047
// opposite of dac_buffer above
[0 ... DAC_BUFFER_SIZE/2-1] = 0,
[DAC_BUFFER_SIZE/2 ... DAC_BUFFER_SIZE -1] = DAC_SAMPLE_MAX,
};
/*
@ -363,7 +250,7 @@ static void error_cb1(DACDriver *dacp, dacerror_t err) {
}
static const DACConfig dac1cfg1 = {
.init = 2047U,
.init = DAC_SAMPLE_MAX,
.datamode = DAC_DHRM_12BIT_RIGHT
};
@ -375,7 +262,7 @@ static const DACConversionGroup dacgrpcfg1 = {
};
static const DACConfig dac1cfg2 = {
.init = 2047U,
.init = DAC_SAMPLE_MAX,
.datamode = DAC_DHRM_12BIT_RIGHT
};

30
quantum/audio/song_list.h
View file

@ -472,4 +472,34 @@
H__NOTE(_AS4), W__NOTE(_GS4), W__NOTE(_GS4), W__NOTE(_FS4), W__NOTE(_GS4), \
H__NOTE(_AS4), WD_NOTE(_DS4)
#define RICK_ROLL \
Q__NOTE(_F4), \
Q__NOTE(_G4), \
Q__NOTE(_BF4), \
Q__NOTE(_G4), \
HD_NOTE(_D5), \
HD_NOTE(_D5), \
W__NOTE(_C5), \
S__NOTE(_REST), \
Q__NOTE(_F4), \
Q__NOTE(_G4), \
Q__NOTE(_BF4), \
Q__NOTE(_G4), \
HD_NOTE(_C5), \
HD_NOTE(_C5), \
W__NOTE(_BF4), \
S__NOTE(_REST), \
Q__NOTE(_F4), \
Q__NOTE(_G4), \
Q__NOTE(_BF4), \
Q__NOTE(_G4), \
W__NOTE(_BF4), \
H__NOTE(_C5), \
H__NOTE(_A4), \
H__NOTE(_A4), \
H__NOTE(_G4), \
H__NOTE(_F4), \
H__NOTE(_F4), \
W__NOTE(_C5), \
W__NOTE(_BF4),
#endif

257
quantum/config_common.h
View file

@ -1,4 +1,4 @@
/* Copyright 2015-2017 Jack Humbert
/* Copyright 2015-2018 Jack Humbert
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -14,8 +14,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef CONFIG_DEFINITIONS_H
#define CONFIG_DEFINITIONS_H
#pragma once
/* diode directions */
#define COL2ROW 0
@ -23,57 +22,205 @@
#define CUSTOM_MATRIX 2 /* Disables built-in matrix scanning code */
#ifdef __AVR__
/* I/O pins */
#ifndef F0
#define B0 0x30
#define B1 0x31
#define B2 0x32
#define B3 0x33
#define B4 0x34
#define B5 0x35
#define B6 0x36
#define B7 0x37
#define C0 0x60
#define C1 0x61
#define C2 0x62
#define C3 0x63
#define C4 0x64
#define C5 0x65
#define C6 0x66
#define C7 0x67
#define D0 0x90
#define D1 0x91
#define D2 0x92
#define D3 0x93
#define D4 0x94
#define D5 0x95
#define D6 0x96
#define D7 0x97
#define E0 0xC0
#define E1 0xC1
#define E2 0xC2
#define E3 0xC3
#define E4 0xC4
#define E5 0xC5
#define E6 0xC6
#define E7 0xC7
#define F0 0xF0
#define F1 0xF1
#define F2 0xF2
#define F3 0xF3
#define F4 0xF4
#define F5 0xF5
#define F6 0xF6
#define F7 0xF7
#define A0 0x00
#define A1 0x01
#define A2 0x02
#define A3 0x03
#define A4 0x04
#define A5 0x05
#define A6 0x06
#define A7 0x07
#endif
#ifndef __ASSEMBLER__
#include <avr/io.h>
#endif
#define PORT_SHIFTER 4 // this may be 4 for all AVR chips
// If you want to add more to this list, reference the PINx definitions in these header
// files: https://github.com/vancegroup-mirrors/avr-libc/tree/master/avr-libc/include/avr
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega16U4__)
#define ADDRESS_BASE 0x00
#define PINB_ADDRESS 0x3
#define PINC_ADDRESS 0x6
#define PIND_ADDRESS 0x9
#define PINE_ADDRESS 0xC
#define PINF_ADDRESS 0xF
#elif defined(__AVR_ATmega32U2__) || defined(__AVR_ATmega16U2__)
#define ADDRESS_BASE 0x00
#define PINB_ADDRESS 0x3
#define PINC_ADDRESS 0x6
#define PIND_ADDRESS 0x9
#elif defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__)
#define ADDRESS_BASE 0x00
#define PINA_ADDRESS 0x0
#define PINB_ADDRESS 0x3
#define PINC_ADDRESS 0x6
#define PIND_ADDRESS 0x9
#define PINE_ADDRESS 0xC
#define PINF_ADDRESS 0xF
#elif defined(__AVR_ATmega32A__)
#define ADDRESS_BASE 0x10
#define PIND_ADDRESS 0x0
#define PINC_ADDRESS 0x3
#define PINB_ADDRESS 0x6
#define PINA_ADDRESS 0x9
#else
#error "Pins are not defined"
#endif
/* I/O pins */
#define PINDEF(port, pin) ((PIN##port##_ADDRESS << PORT_SHIFTER) | pin)
#ifdef PORTA
#define A0 PINDEF(A, 0)
#define A1 PINDEF(A, 1)
#define A2 PINDEF(A, 2)
#define A3 PINDEF(A, 3)
#define A4 PINDEF(A, 4)
#define A5 PINDEF(A, 5)
#define A6 PINDEF(A, 6)
#define A7 PINDEF(A, 7)
#endif
#ifdef PORTB
#define B0 PINDEF(B, 0)
#define B1 PINDEF(B, 1)
#define B2 PINDEF(B, 2)
#define B3 PINDEF(B, 3)
#define B4 PINDEF(B, 4)
#define B5 PINDEF(B, 5)
#define B6 PINDEF(B, 6)
#define B7 PINDEF(B, 7)
#endif
#ifdef PORTC
#define C0 PINDEF(C, 0)
#define C1 PINDEF(C, 1)
#define C2 PINDEF(C, 2)
#define C3 PINDEF(C, 3)
#define C4 PINDEF(C, 4)
#define C5 PINDEF(C, 5)
#define C6 PINDEF(C, 6)
#define C7 PINDEF(C, 7)
#endif
#ifdef PORTD
#define D0 PINDEF(D, 0)
#define D1 PINDEF(D, 1)
#define D2 PINDEF(D, 2)
#define D3 PINDEF(D, 3)
#define D4 PINDEF(D, 4)
#define D5 PINDEF(D, 5)
#define D6 PINDEF(D, 6)
#define D7 PINDEF(D, 7)
#endif
#ifdef PORTE
#define E0 PINDEF(E, 0)
#define E1 PINDEF(E, 1)
#define E2 PINDEF(E, 2)
#define E3 PINDEF(E, 3)
#define E4 PINDEF(E, 4)
#define E5 PINDEF(E, 5)
#define E6 PINDEF(E, 6)
#define E7 PINDEF(E, 7)
#endif
#ifdef PORTF
#define F0 PINDEF(F, 0)
#define F1 PINDEF(F, 1)
#define F2 PINDEF(F, 2)
#define F3 PINDEF(F, 3)
#define F4 PINDEF(F, 4)
#define F5 PINDEF(F, 5)
#define F6 PINDEF(F, 6)
#define F7 PINDEF(F, 7)
#endif
#elif defined(PROTOCOL_CHIBIOS)
#define A0 PAL_LINE(GPIOA, 0)
#define A1 PAL_LINE(GPIOA, 1)
#define A2 PAL_LINE(GPIOA, 2)
#define A3 PAL_LINE(GPIOA, 3)
#define A4 PAL_LINE(GPIOA, 4)
#define A5 PAL_LINE(GPIOA, 5)
#define A6 PAL_LINE(GPIOA, 6)
#define A7 PAL_LINE(GPIOA, 7)
#define A8 PAL_LINE(GPIOA, 8)
#define A9 PAL_LINE(GPIOA, 9)
#define A10 PAL_LINE(GPIOA, 10)
#define A11 PAL_LINE(GPIOA, 11)
#define A12 PAL_LINE(GPIOA, 12)
#define A13 PAL_LINE(GPIOA, 13)
#define A14 PAL_LINE(GPIOA, 14)
#define A15 PAL_LINE(GPIOA, 15)
#define B0 PAL_LINE(GPIOB, 0)
#define B1 PAL_LINE(GPIOB, 1)
#define B2 PAL_LINE(GPIOB, 2)
#define B3 PAL_LINE(GPIOB, 3)
#define B4 PAL_LINE(GPIOB, 4)
#define B5 PAL_LINE(GPIOB, 5)
#define B6 PAL_LINE(GPIOB, 6)
#define B7 PAL_LINE(GPIOB, 7)
#define B8 PAL_LINE(GPIOB, 8)
#define B9 PAL_LINE(GPIOB, 9)
#define B10 PAL_LINE(GPIOB, 10)
#define B11 PAL_LINE(GPIOB, 11)
#define B12 PAL_LINE(GPIOB, 12)
#define B13 PAL_LINE(GPIOB, 13)
#define B14 PAL_LINE(GPIOB, 14)
#define B15 PAL_LINE(GPIOB, 15)
#define C0 PAL_LINE(GPIOC, 0)
#define C1 PAL_LINE(GPIOC, 1)
#define C2 PAL_LINE(GPIOC, 2)
#define C3 PAL_LINE(GPIOC, 3)
#define C4 PAL_LINE(GPIOC, 4)
#define C5 PAL_LINE(GPIOC, 5)
#define C6 PAL_LINE(GPIOC, 6)
#define C7 PAL_LINE(GPIOC, 7)
#define C8 PAL_LINE(GPIOC, 8)
#define C9 PAL_LINE(GPIOC, 9)
#define C10 PAL_LINE(GPIOC, 10)
#define C11 PAL_LINE(GPIOC, 11)
#define C12 PAL_LINE(GPIOC, 12)
#define C13 PAL_LINE(GPIOC, 13)
#define C14 PAL_LINE(GPIOC, 14)
#define C15 PAL_LINE(GPIOC, 15)
#define D0 PAL_LINE(GPIOD, 0)
#define D1 PAL_LINE(GPIOD, 1)
#define D2 PAL_LINE(GPIOD, 2)
#define D3 PAL_LINE(GPIOD, 3)
#define D4 PAL_LINE(GPIOD, 4)
#define D5 PAL_LINE(GPIOD, 5)
#define D6 PAL_LINE(GPIOD, 6)
#define D7 PAL_LINE(GPIOD, 7)
#define D8 PAL_LINE(GPIOD, 8)
#define D9 PAL_LINE(GPIOD, 9)
#define D10 PAL_LINE(GPIOD, 10)
#define D11 PAL_LINE(GPIOD, 11)
#define D12 PAL_LINE(GPIOD, 12)
#define D13 PAL_LINE(GPIOD, 13)
#define D14 PAL_LINE(GPIOD, 14)
#define D15 PAL_LINE(GPIOD, 15)
#define E0 PAL_LINE(GPIOE, 0)
#define E1 PAL_LINE(GPIOE, 1)
#define E2 PAL_LINE(GPIOE, 2)
#define E3 PAL_LINE(GPIOE, 3)
#define E4 PAL_LINE(GPIOE, 4)
#define E5 PAL_LINE(GPIOE, 5)
#define E6 PAL_LINE(GPIOE, 6)
#define E7 PAL_LINE(GPIOE, 7)
#define E8 PAL_LINE(GPIOE, 8)
#define E9 PAL_LINE(GPIOE, 9)
#define E10 PAL_LINE(GPIOE, 10)
#define E11 PAL_LINE(GPIOE, 11)
#define E12 PAL_LINE(GPIOE, 12)
#define E13 PAL_LINE(GPIOE, 13)
#define E14 PAL_LINE(GPIOE, 14)
#define E15 PAL_LINE(GPIOE, 15)
#define F0 PAL_LINE(GPIOF, 0)
#define F1 PAL_LINE(GPIOF, 1)
#define F2 PAL_LINE(GPIOF, 2)
#define F3 PAL_LINE(GPIOF, 3)
#define F4 PAL_LINE(GPIOF, 4)
#define F5 PAL_LINE(GPIOF, 5)
#define F6 PAL_LINE(GPIOF, 6)
#define F7 PAL_LINE(GPIOF, 7)
#define F8 PAL_LINE(GPIOF, 8)
#define F9 PAL_LINE(GPIOF, 9)
#define F10 PAL_LINE(GPIOF, 10)
#define F11 PAL_LINE(GPIOF, 11)
#define F12 PAL_LINE(GPIOF, 12)
#define F13 PAL_LINE(GPIOF, 13)
#define F14 PAL_LINE(GPIOF, 14)
#define F15 PAL_LINE(GPIOF, 15)
#endif
/* USART configuration */
@ -103,5 +250,3 @@
#define API_SYSEX_MAX_SIZE 32
#include "song_list.h"
#endif

230
quantum/dynamic_keymap.c Normal file
View file

@ -0,0 +1,230 @@
/* Copyright 2017 Jason Williams (Wilba)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "keymap.h" // to get keymaps[][][]
#include "tmk_core/common/eeprom.h"
#include "progmem.h" // to read default from flash
#include "quantum.h" // for send_string()
#include "dynamic_keymap.h"
#ifdef DYNAMIC_KEYMAP_ENABLE
#ifndef DYNAMIC_KEYMAP_EEPROM_ADDR
#error DYNAMIC_KEYMAP_EEPROM_ADDR not defined
#endif
#ifndef DYNAMIC_KEYMAP_LAYER_COUNT
#error DYNAMIC_KEYMAP_LAYER_COUNT not defined
#endif
#ifndef DYNAMIC_KEYMAP_MACRO_COUNT
#error DYNAMIC_KEYMAP_MACRO_COUNT not defined
#endif
#ifndef DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR
#error DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR not defined
#endif
#ifndef DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE
#error DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE not defined
#endif
uint8_t dynamic_keymap_get_layer_count(void)
{
return DYNAMIC_KEYMAP_LAYER_COUNT;
}
void *dynamic_keymap_key_to_eeprom_address(uint8_t layer, uint8_t row, uint8_t column)
{
// TODO: optimize this with some left shifts
return ((void*)DYNAMIC_KEYMAP_EEPROM_ADDR) + ( layer * MATRIX_ROWS * MATRIX_COLS * 2 ) +
( row * MATRIX_COLS * 2 ) + ( column * 2 );
}
uint16_t dynamic_keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t column)
{
void *address = dynamic_keymap_key_to_eeprom_address(layer, row, column);
// Big endian, so we can read/write EEPROM directly from host if we want
uint16_t keycode = eeprom_read_byte(address) << 8;
keycode |= eeprom_read_byte(address + 1);
return keycode;
}
void dynamic_keymap_set_keycode(uint8_t layer, uint8_t row, uint8_t column, uint16_t keycode)
{
void *address = dynamic_keymap_key_to_eeprom_address(layer, row, column);
// Big endian, so we can read/write EEPROM directly from host if we want
eeprom_update_byte(address, (uint8_t)(keycode >> 8));
eeprom_update_byte(address+1, (uint8_t)(keycode & 0xFF));
}
void dynamic_keymap_reset(void)
{
// Reset the keymaps in EEPROM to what is in flash.
// All keyboards using dynamic keymaps should define a layout
// for the same number of layers as DYNAMIC_KEYMAP_LAYER_COUNT.
for ( int layer = 0; layer < DYNAMIC_KEYMAP_LAYER_COUNT; layer++ ) {
for ( int row = 0; row < MATRIX_ROWS; row++ ) {
for ( int column = 0; column < MATRIX_COLS; column++ ) {
dynamic_keymap_set_keycode(layer, row, column, pgm_read_word(&keymaps[layer][row][column]));
}
}
}
}
void dynamic_keymap_get_buffer( uint16_t offset, uint16_t size, uint8_t *data )
{
uint16_t dynamic_keymap_eeprom_size = DYNAMIC_KEYMAP_LAYER_COUNT * MATRIX_ROWS * MATRIX_COLS * 2;
void *source = (void*)(DYNAMIC_KEYMAP_EEPROM_ADDR+offset);
uint8_t *target = data;
for ( uint16_t i = 0; i < size; i++ ) {
if ( offset + i < dynamic_keymap_eeprom_size ) {
*target = eeprom_read_byte(source);
} else {
*target = 0x00;
}
source++;
target++;
}
}
void dynamic_keymap_set_buffer( uint16_t offset, uint16_t size, uint8_t *data )
{
uint16_t dynamic_keymap_eeprom_size = DYNAMIC_KEYMAP_LAYER_COUNT * MATRIX_ROWS * MATRIX_COLS * 2;
void *target = (void*)(DYNAMIC_KEYMAP_EEPROM_ADDR+offset);
uint8_t *source = data;
for ( uint16_t i = 0; i < size; i++ ) {
if ( offset + i < dynamic_keymap_eeprom_size ) {
eeprom_update_byte(target, *source);
}
source++;
target++;
}
}
// This overrides the one in quantum/keymap_common.c
uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key)
{
if ( layer < DYNAMIC_KEYMAP_LAYER_COUNT &&
key.row < MATRIX_ROWS &&
key.col < MATRIX_COLS ) {
return dynamic_keymap_get_keycode(layer, key.row, key.col);
} else {
return KC_NO;
}
}
uint8_t dynamic_keymap_macro_get_count(void)
{
return DYNAMIC_KEYMAP_MACRO_COUNT;
}
uint16_t dynamic_keymap_macro_get_buffer_size(void)
{
return DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE;
}
void dynamic_keymap_macro_get_buffer( uint16_t offset, uint16_t size, uint8_t *data )
{
void *source = (void*)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR+offset);
uint8_t *target = data;
for ( uint16_t i = 0; i < size; i++ ) {
if ( offset + i < DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE ) {
*target = eeprom_read_byte(source);
} else {
*target = 0x00;
}
source++;
target++;
}
}
void dynamic_keymap_macro_set_buffer( uint16_t offset, uint16_t size, uint8_t *data )
{
void *target = (void*)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR+offset);
uint8_t *source = data;
for ( uint16_t i = 0; i < size; i++ ) {
if ( offset + i < DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE ) {
eeprom_update_byte(target, *source);
}
source++;
target++;
}
}
void dynamic_keymap_macro_reset(void)
{
void *p = (void*)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR);
void *end = (void*)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR+DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE);
while ( p != end ) {
eeprom_update_byte(p, 0);
++p;
}
}
void dynamic_keymap_macro_send( uint8_t id )
{
if ( id >= DYNAMIC_KEYMAP_MACRO_COUNT ) {
return;
}
// Check the last byte of the buffer.
// If it's not zero, then we are in the middle
// of buffer writing, possibly an aborted buffer
// write. So do nothing.
void *p = (void*)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR+DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE-1);
if ( eeprom_read_byte(p) != 0 ) {
return;
}
// Skip N null characters
// p will then point to the Nth macro
p = (void*)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR);
void *end = (void*)(DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR+DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE);
while ( id > 0 ) {
// If we are past the end of the buffer, then the buffer
// contents are garbage, i.e. there were not DYNAMIC_KEYMAP_MACRO_COUNT
// nulls in the buffer.
if ( p == end ) {
return;
}
if ( eeprom_read_byte(p) == 0 ) {
--id;
}
++p;
}
// Send the macro string one char at a time
// by making temporary 1 char strings
char data[2] = { 0, 0 };
// We already checked there was a null at the end of
// the buffer, so this cannot go past the end
while ( 1 ) {
data[0] = eeprom_read_byte(p);
// Stop at the null terminator of this macro string
if ( data[0] == 0 ) {
break;
}
send_string(data);
++p;
}
}
#endif // DYNAMIC_KEYMAP_ENABLE

63
quantum/dynamic_keymap.h Normal file
View file

@ -0,0 +1,63 @@
/* Copyright 2017 Jason Williams (Wilba)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <stdint.h>
#include <stdbool.h>
uint8_t dynamic_keymap_get_layer_count(void);
void *dynamic_keymap_key_to_eeprom_address(uint8_t layer, uint8_t row, uint8_t column);
uint16_t dynamic_keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t column);
void dynamic_keymap_set_keycode(uint8_t layer, uint8_t row, uint8_t column, uint16_t keycode);
void dynamic_keymap_reset(void);
// These get/set the keycodes as stored in the EEPROM buffer
// Data is big-endian 16-bit values (the keycodes)
// Order is by layer/row/column
// Thus offset 0 = 0,0,0, offset MATRIX_COLS*2 = 0,1,0, offset MATRIX_ROWS*MATRIX_COLS*2 = 1,0,0
// Note the *2, because offset is in bytes and keycodes are two bytes
// This is only really useful for host applications that want to get a whole keymap fast,
// by reading 14 keycodes (28 bytes) at a time, reducing the number of raw HID transfers by
// a factor of 14.
void dynamic_keymap_get_buffer( uint16_t offset, uint16_t size, uint8_t *data );
void dynamic_keymap_set_buffer( uint16_t offset, uint16_t size, uint8_t *data );
// This overrides the one in quantum/keymap_common.c
// uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t key);
// Note regarding dynamic_keymap_macro_set_buffer():
// The last byte of the buffer is used as a valid flag,
// so macro sending is disabled during writing a new buffer,
// should it happen during, or after an interrupted transfer.
//
// Users writing to the buffer must first set the last byte of the buffer
// to non-zero (i.e. 0xFF). After (or during) the final write, set the
// last byte of the buffer to zero.
//
// Since the contents of the buffer must be a list of null terminated
// strings, the last byte must be a null when at maximum capacity,
// and it not being null means the buffer can be considered in an
// invalid state.
uint8_t dynamic_keymap_macro_get_count(void);
uint16_t dynamic_keymap_macro_get_buffer_size(void);
void dynamic_keymap_macro_get_buffer( uint16_t offset, uint16_t size, uint8_t *data );
void dynamic_keymap_macro_set_buffer( uint16_t offset, uint16_t size, uint8_t *data );
void dynamic_keymap_macro_reset(void);
void dynamic_keymap_macro_send( uint8_t id );

70
quantum/encoder.c Normal file
View file

@ -0,0 +1,70 @@
/*
* Copyright 2018 Jack Humbert <jack.humb@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "encoder.h"
#ifndef ENCODER_RESOLUTION
#define ENCODER_RESOLUTION 4
#endif
#ifndef NUMBER_OF_ENCODERS
#error "Number of encoders not defined by NUMBER_OF_ENCODERS"
#endif
#if !defined(ENCODERS_PAD_A) || !defined(ENCODERS_PAD_B)
#error "No encoder pads defined by ENCODERS_PAD_A and ENCODERS_PAD_B"
#endif
static pin_t encoders_pad_a[NUMBER_OF_ENCODERS] = ENCODERS_PAD_A;
static pin_t encoders_pad_b[NUMBER_OF_ENCODERS] = ENCODERS_PAD_B;
static int8_t encoder_LUT[] = { 0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0 };
static uint8_t encoder_state[NUMBER_OF_ENCODERS] = {0};
static int8_t encoder_value[NUMBER_OF_ENCODERS] = {0};
__attribute__ ((weak))
void encoder_update_user(int8_t index, bool clockwise) { }
__attribute__ ((weak))
void encoder_update_kb(int8_t index, bool clockwise) {
encoder_update_user(index, clockwise);
}
void encoder_init(void) {
for (int i = 0; i < NUMBER_OF_ENCODERS; i++) {
setPinInputHigh(encoders_pad_a[i]);
setPinInputHigh(encoders_pad_b[i]);
encoder_state[i] = (readPin(encoders_pad_a[i]) << 0) | (readPin(encoders_pad_b[i]) << 1);
}
}
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, COUNTRECLOCKWISE);
}
if (encoder_value[i] <= -ENCODER_RESOLUTION) { // direction is arbitrary here, but this clockwise
encoder_update_kb(i, CLOCKWISE);
}
encoder_value[i] %= ENCODER_RESOLUTION;
}
}

21
quantum/process_keycode/process_chording.h → quantum/encoder.h
View file

@ -1,4 +1,5 @@
/* Copyright 2016 Jack Humbert
/*
* Copyright 2018 Jack Humbert <jack.humb@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -14,19 +15,15 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PROCESS_CHORDING_H
#define PROCESS_CHORDING_H
#pragma once
#include "quantum.h"
// Chording stuff
#define CHORDING_MAX 4
bool chording = false;
#define COUNTRECLOCKWISE 0
#define CLOCKWISE 1
uint8_t chord_keys[CHORDING_MAX] = {0};
uint8_t chord_key_count = 0;
uint8_t chord_key_down = 0;
void encoder_init(void);
void encoder_read(void);
bool process_chording(uint16_t keycode, keyrecord_t *record);
#endif
void encoder_update_kb(int8_t index, bool clockwise);
void encoder_update_user(int8_t index, bool clockwise);

2
quantum/keymap_common.c
View file

@ -64,7 +64,7 @@ action_t action_for_key(uint8_t layer, keypos_t key)
case KC_SYSTEM_POWER ... KC_SYSTEM_WAKE:
action.code = ACTION_USAGE_SYSTEM(KEYCODE2SYSTEM(keycode));
break;
case KC_AUDIO_MUTE ... KC_MEDIA_REWIND:
case KC_AUDIO_MUTE ... KC_BRIGHTNESS_DOWN:
action.code = ACTION_USAGE_CONSUMER(KEYCODE2CONSUMER(keycode));
break;
case KC_MS_UP ... KC_MS_ACCEL2:

9
quantum/keymap_extras/keymap_belgian.h
View file

@ -18,15 +18,6 @@
#include "keymap.h"
#define BE_LGUI KC_LALT
#define BE_LALT KC_LGUI
// Alt gr
#ifndef ALGR
#define ALGR(kc) RALT(kc)
#endif
#define NO_ALGR KC_RALT
// Normal characters
// Line 1
#define BE_SUP2 KC_GRV

153
quantum/keymap_extras/keymap_bepo.h
View file

@ -19,15 +19,6 @@
#include "keymap.h"
// Alt gr
#ifndef ALTGR
#define ALTGR(kc) RALT(kc)
#endif
#ifndef ALGR
#define ALGR(kc) ALTGR(kc)
#endif
#define BP_ALGR KC_RALT
// Normal characters
// First row (on usual keyboards)
#define BP_DOLLAR KC_GRAVE // $
@ -142,138 +133,138 @@
// AltGr-ed characters
// First row
#define BP_EN_DASH ALTGR(BP_DOLLAR) // –
#define BP_EN_DASH ALGR(BP_DOLLAR) // –
#define BP_NDSH BP_EN_DASH
#define BP_EM_DASH ALTGR(KC_1) // —
#define BP_EM_DASH ALGR(KC_1) // —
#define BP_MDSH BP_EM_DASH
#define BP_LESS ALTGR(KC_2) // <
#define BP_GREATER ALTGR(KC_3) // >
#define BP_LESS ALGR(KC_2) // <
#define BP_GREATER ALGR(KC_3) // >
#define BP_GRTR BP_GREATER
#define BP_LBRACKET ALTGR(KC_4) // [
#define BP_LBRACKET ALGR(KC_4) // [
#define BP_LBRC BP_LBRACKET
#define BP_RBRACKET ALTGR(KC_5) // ]
#define BP_RBRACKET ALGR(KC_5) // ]
#define BP_RBRC BP_RBRACKET
#define BP_CIRCUMFLEX ALTGR(KC_6) // ^
#define BP_CIRCUMFLEX ALGR(KC_6) // ^
#define BP_CIRC BP_CIRCUMFLEX
#define BP_PLUS_MINUS ALTGR(KC_7) // ±
#define BP_PLUS_MINUS ALGR(KC_7) // ±
#define BP_PSMS BP_PLUS_MINUS
#define BP_MATH_MINUS ALTGR(KC_8) // −
#define BP_MATH_MINUS ALGR(KC_8) // −
#define BP_MMNS BP_MATH_MINUS
#define BP_OBELUS ALTGR(KC_9) // ÷
#define BP_OBELUS ALGR(KC_9) // ÷
#define BP_OBEL BP_OBELUS
// more conventional name of the symbol
#define BP_DIVISION_SIGN BP_OBELUS
#define BP_DVSN BP_DIVISION_SIGN
#define BP_TIMES ALTGR(KC_0) // ×
#define BP_TIMES ALGR(KC_0) // ×
#define BP_TIMS BP_TIMES
#define BP_DIFFERENT ALTGR(BP_EQUAL) // ≠
#define BP_DIFFERENT ALGR(BP_EQUAL) // ≠
#define BP_DIFF BP_DIFFERENT
#define BP_PERMILLE ALTGR(BP_PERCENT) // ‰
#define BP_PERMILLE ALGR(BP_PERCENT) // ‰
#define BP_PMIL BP_PERMILLE
// Second row
#define BP_PIPE ALTGR(BP_B) // |
#define BP_DEAD_ACUTE ALTGR(BP_E_ACUTE) // dead ´
#define BP_PIPE ALGR(BP_B) // |
#define BP_DEAD_ACUTE ALGR(BP_E_ACUTE) // dead ´
#define BP_DACT BP_DEAD_ACUTE
#define BP_AMPERSAND ALTGR(BP_P) // &
#define BP_AMPERSAND ALGR(BP_P) // &
#define BP_AMPR BP_AMPERSAND
#define BP_OE_LIGATURE ALTGR(BP_O) // œ
#define BP_OE_LIGATURE ALGR(BP_O) // œ
#define BP_OE BP_OE_LIGATURE
#define BP_DEAD_GRAVE ALTGR(BP_E_GRAVE) // `
#define BP_DEAD_GRAVE ALGR(BP_E_GRAVE) // `
#define BP_DGRV BP_DEAD_GRAVE
#define BP_INVERTED_EXCLAIM ALTGR(BP_DEAD_CIRCUMFLEX) // ¡
#define BP_INVERTED_EXCLAIM ALGR(BP_DEAD_CIRCUMFLEX) // ¡
#define BP_IXLM BP_INVERTED_EXCLAIM
#define BP_DEAD_CARON ALTGR(BP_V) // dead ˇ
#define BP_DEAD_CARON ALGR(BP_V) // dead ˇ
#define BP_DCAR BP_DEAD_CARON
#define BP_ETH ALTGR(BP_D) // ð
#define BP_DEAD_SLASH ALTGR(BP_L) // dead /
#define BP_ETH ALGR(BP_D) // ð
#define BP_DEAD_SLASH ALGR(BP_L) // dead /
#define BP_DSLH BP_DEAD_SLASH
#define BP_IJ_LIGATURE ALTGR(BP_J) // ij
#define BP_IJ_LIGATURE ALGR(BP_J) // ij
#define BP_IJ BP_IJ_LIGATURE
#define BP_SCHWA ALTGR(BP_Z) // ə
#define BP_SCHWA ALGR(BP_Z) // ə
#define BP_SCWA BP_SCHWA
#define BP_DEAD_BREVE ALTGR(BP_W) // dead ˘
#define BP_DEAD_BREVE ALGR(BP_W) // dead ˘
#define BP_DBRV BP_DEAD_BREVE
// Third row
#define BP_AE_LIGATURE ALTGR(BP_A) // æ
#define BP_AE_LIGATURE ALGR(BP_A) // æ
#define BP_AE BP_AE_LIGATURE
#define BP_U_GRAVE ALTGR(BP_U) // ù
#define BP_U_GRAVE ALGR(BP_U) // ù
#define BP_UGRV BP_U_GRAVE
#define BP_DEAD_TREMA ALTGR(BP_I) // dead ¨ (trema/umlaut/diaresis)
#define BP_DEAD_TREMA ALGR(BP_I) // dead ¨ (trema/umlaut/diaresis)
#define BP_DTRM BP_DEAD_TREMA
#define BP_EURO ALTGR(BP_E) // €
#define BP_TYPOGRAPHICAL_APOSTROPHE ALTGR(BP_COMMA) // ’
#define BP_EURO ALGR(BP_E) // €
#define BP_TYPOGRAPHICAL_APOSTROPHE ALGR(BP_COMMA) // ’
#define BP_TAPO BP_TYPOGRAPHICAL_APOSTROPHE
#define BP_COPYRIGHT ALTGR(BP_C) // ©
#define BP_COPYRIGHT ALGR(BP_C) // ©
#define BP_CPRT BP_COPYRIGHT
#define BP_THORN ALTGR(BP_T) // þ
#define BP_THORN ALGR(BP_T) // þ
#define BP_THRN BP_THORN
#define BP_SHARP_S ALTGR(BP_S) // ß
#define BP_SHARP_S ALGR(BP_S) // ß
#define BP_SRPS BP_SHARP_S
#define BP_REGISTERED_TRADEMARK ALTGR(BP_R) // ®
#define BP_REGISTERED_TRADEMARK ALGR(BP_R) // ®
#define BP_RTM BP_REGISTERED_TRADEMARK
#define BP_DEAD_TILDE ALTGR(BP_N) // dead ~
#define BP_DEAD_TILDE ALGR(BP_N) // dead ~
#define BP_DTLD BP_DEAD_TILDE
#define BP_DEAD_MACRON ALTGR(BP_M) // dead ¯
#define BP_DEAD_MACRON ALGR(BP_M) // dead ¯
#define BP_DMCR BP_DEAD_MACRON
#define BP_DEAD_CEDILLA ALTGR(BP_C_CEDILLA) // dead ¸
#define BP_DEAD_CEDILLA ALGR(BP_C_CEDILLA) // dead ¸
#define BP_DCED BP_DEAD_CEDILLA
// Fourth row
#define BP_NONUS_SLASH ALTGR(BP_E_CIRCUMFLEX) // / on non-us backslash key (102nd key, ê in bépo)
#define BP_NONUS_SLASH ALGR(BP_E_CIRCUMFLEX) // / on non-us backslash key (102nd key, ê in bépo)
#define BP_NUSL BP_NONUS_SLASH
#define BP_BACKSLASH ALTGR(BP_A_GRAVE) /* \ */
#define BP_BACKSLASH ALGR(BP_A_GRAVE) /* \ */
#define BP_BSLS BP_BACKSLASH
#define BP_LEFT_CURLY_BRACE ALTGR(BP_Y) // {
#define BP_LEFT_CURLY_BRACE ALGR(BP_Y) // {
#define BP_LCBR BP_LEFT_CURLY_BRACE
#define BP_RIGHT_CURLY_BRACE ALTGR(BP_X) // }
#define BP_RIGHT_CURLY_BRACE ALGR(BP_X) // }
#define BP_RCBR BP_RIGHT_CURLY_BRACE
#define BP_ELLIPSIS ALTGR(BP_DOT) // …
#define BP_ELLIPSIS ALGR(BP_DOT) // …
#define BP_ELPS BP_ELLIPSIS
#define BP_TILDE ALTGR(BP_K) // ~
#define BP_TILDE ALGR(BP_K) // ~
#define BP_TILD BP_TILDE
#define BP_INVERTED_QUESTION ALTGR(BP_QUESTION) // ¿
#define BP_INVERTED_QUESTION ALGR(BP_QUESTION) // ¿
#define BP_IQST BP_INVERTED_QUESTION
#define BP_DEAD_RING ALTGR(BP_Q) // dead °
#define BP_DEAD_RING ALGR(BP_Q) // dead °
#define BP_DRNG BP_DEAD_RING
#define BP_DEAD_GREEK ALTGR(BP_G) // dead Greek key (following key will make a Greek letter)
#define BP_DEAD_GREEK ALGR(BP_G) // dead Greek key (following key will make a Greek letter)
#define BP_DGRK BP_DEAD_GREEK
#define BP_DAGGER ALTGR(BP_H) // †
#define BP_DAGGER ALGR(BP_H) // †
#define BP_DAGR BP_DAGGER
#define BP_DEAD_OGONEK ALTGR(BP_F) // dead ˛
#define BP_DEAD_OGONEK ALGR(BP_F) // dead ˛
#define BP_DOGO BP_DEAD_OGONEK
// Space bar
#define BP_UNDERSCORE ALTGR(KC_SPACE) // _
#define BP_UNDERSCORE ALGR(KC_SPACE) // _
#define BP_UNDS BP_UNDERSCORE
// AltGr-Shifted characters (different from capitalised AltGr-ed characters)
// First row
#define BP_PARAGRAPH ALTGR(BP_HASH) // ¶
#define BP_PARAGRAPH ALGR(BP_HASH) // ¶
#define BP_PARG BP_PARAGRAPH
#define BP_LOW_DOUBLE_QUOTE ALTGR(BP_1) // „
#define BP_LOW_DOUBLE_QUOTE ALGR(BP_1) // „
#define BP_LWQT BP_LOW_DOUBLE_QUOTE
#define BP_LEFT_DOUBLE_QUOTE ALTGR(BP_2) // “
#define BP_LEFT_DOUBLE_QUOTE ALGR(BP_2) // “
#define BP_LDQT BP_LEFT_DOUBLE_QUOTE
#define BP_RIGHT_DOUBLE_QUOTE ALTGR(BP_3) // ”
#define BP_RIGHT_DOUBLE_QUOTE ALGR(BP_3) // ”
#define BP_RDQT BP_RIGHT_DOUBLE_QUOTE
#define BP_LESS_OR_EQUAL ALTGR(BP_4) // ≤
#define BP_LESS_OR_EQUAL ALGR(BP_4) // ≤
#define BP_LEQL BP_LESS_OR_EQUAL
#define BP_GREATER_OR_EQUAL ALTGR(BP_5) // ≥
#define BP_GREATER_OR_EQUAL ALGR(BP_5) // ≥
#define BP_GEQL BP_GREATER_OR_EQUAL
// nothing on ALTGR(BP_6)
#define BP_NEGATION ALTGR(BP_7) // ¬
// nothing on ALGR(BP_6)
#define BP_NEGATION ALGR(BP_7) // ¬
#define BP_NEGT BP_NEGATION
#define BP_ONE_QUARTER ALTGR(BP_8) // ¼
#define BP_ONE_QUARTER ALGR(BP_8) // ¼
#define BP_1QRT BP_ONE_QUARTER
#define BP_ONE_HALF ALTGR(BP_9) // ½
#define BP_ONE_HALF ALGR(BP_9) // ½
#define BP_1HLF BP_ONE_HALF
#define BP_THREE_QUARTERS ALTGR(BP_0) // ¾
#define BP_THREE_QUARTERS ALGR(BP_0) // ¾
#define BP_3QRT BP_THREE_QUARTERS
#define BP_MINUTES ALTGR(BP_DEGREE) // ′
#define BP_MINUTES ALGR(BP_DEGREE) // ′
#define BP_MNUT BP_MINUTES
#define BP_SECONDS ALTGR(BP_GRAVE) // ″
#define BP_SECONDS ALGR(BP_GRAVE) // ″
#define BP_SCND BP_SECONDS
// Second row
@ -281,7 +272,7 @@
#define BP_BPIP BP_BROKEN_PIPE
#define BP_DEAD_DOUBLE_ACUTE LSFT(BP_DEAD_ACUTE) // ˝
#define BP_DDCT BP_DEAD_DOUBLE_ACUTE
#define BP_SECTION ALTGR(LSFT(BP_P)) // §
#define BP_SECTION ALGR(LSFT(BP_P)) // §
#define BP_SECT BP_SECTION
// LSFT(BP_DEAD_GRAVE) is actually the same character as LSFT(BP_PERCENT)
#define BP_GRAVE_BIS LSFT(BP_DEAD_GRAVE) // `
@ -292,35 +283,35 @@
#define BP_DDTA BP_DEAD_DOT_ABOVE
#define BP_DEAD_CURRENCY LSFT(BP_EURO) // dead ¤ (next key will generate a currency code like ¥ or £)
#define BP_DCUR BP_DEAD_CURRENCY
#define BP_DEAD_HORN LSFT(ALTGR(BP_COMMA)) // dead ̛
#define BP_DEAD_HORN LSFT(ALGR(BP_COMMA)) // dead ̛
#define BP_DHRN BP_DEAD_HORN
#define BP_LONG_S LSFT(ALTGR(BP_C)) // ſ
#define BP_LONG_S LSFT(ALGR(BP_C)) // ſ
#define BP_LNGS BP_LONG_S
#define BP_TRADEMARK LSFT(BP_REGISTERED_TRADEMARK) // ™
#define BP_TM BP_TRADEMARK
#define BP_ORDINAL_INDICATOR_O LSFT(ALTGR(BP_M)) // º
#define BP_ORDINAL_INDICATOR_O LSFT(ALGR(BP_M)) // º
#define BP_ORDO BP_ORDINAL_INDICATOR_O
#define BP_DEAD_COMMA LSFT(BP_DEAD_CEDILLA) // dead ˛
#define BP_DCOM BP_DEAD_COMMA
// Fourth row
#define BP_LEFT_QUOTE LSFT(ALTGR(BP_Y)) // ‘
#define BP_LEFT_QUOTE LSFT(ALGR(BP_Y)) // ‘
#define BP_LQOT BP_LEFT_QUOTE
#define BP_RIGHT_QUOTE LSFT(ALTGR(BP_X)) // ’
#define BP_RIGHT_QUOTE LSFT(ALGR(BP_X)) // ’
#define BP_RQOT BP_RIGHT_QUOTE
#define BP_INTERPUNCT LSFT(ALTGR(BP_DOT)) // ·
#define BP_INTERPUNCT LSFT(ALGR(BP_DOT)) // ·
#define BP_IPCT BP_INTERPUNCT
#define BP_DEAD_HOOK_ABOVE LSFT(ALTGR(BP_QUESTION)) // dead ̉
#define BP_DEAD_HOOK_ABOVE LSFT(ALGR(BP_QUESTION)) // dead ̉
#define BP_DHKA BP_DEAD_HOOK_ABOVE
#define BP_DEAD_UNDERDOT LSFT(BP_DEAD_RING) // dead ̣
#define BP_DUDT BP_DEAD_UNDERDOT
#define BP_DOUBLE_DAGGER LSFT(BP_DAGGER) // ‡
#define BP_DDGR BP_DOUBLE_DAGGER
#define BP_ORDINAL_INDICATOR_A LSFT(ALTGR(BP_F)) // ª
#define BP_ORDINAL_INDICATOR_A LSFT(ALGR(BP_F)) // ª
#define BP_ORDA BP_ORDINAL_INDICATOR_A
// Space bar
#define BP_NARROW_NON_BREAKING_SPACE ALTGR(BP_NON_BREAKING_SPACE)
#define BP_NARROW_NON_BREAKING_SPACE ALGR(BP_NON_BREAKING_SPACE)
#define BP_NNBS BP_NARROW_NON_BREAKING_SPACE
#endif

49
quantum/keymap_extras/keymap_canadian_multilingual.h
View file

@ -13,22 +13,11 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef KEYMAP_CANADIAN_MULTILINGUAG_H
#define KEYMAP_CANADIAN_MULTILINGUAG_H
#ifndef KEYMAP_CANADIAN_MULTILINGUAL_H
#define KEYMAP_CANADIAN_MULTILINGUAL_H
#include "keymap.h"
// Alt gr
#ifndef ALTGR
#define ALTGR(kc) RALT(kc)
#endif
#ifndef ALGR
#define ALGR(kc) ALTGR(kc)
#endif
#define CSA_ALTGR KC_RALT
#define CSA_ALGR CSA_ALTGR
#ifndef GR2A
#define GR2A(kc) RCTL(kc)
#endif
@ -78,43 +67,43 @@
// Alt Gr-ed characters
// First row
#define CSA_PIPE ALTGR(CSA_SLASH) // |
#define CSA_CURRENCY ALTGR(KC_4) // ¤
#define CSA_PIPE ALGR(CSA_SLASH) // |
#define CSA_CURRENCY ALGR(KC_4) // ¤
#define CSA_CURR CSA_CURRENCY
#define CSA_LEFT_CURLY_BRACE ALTGR(KC_7) // {
#define CSA_LEFT_CURLY_BRACE ALGR(KC_7) // {
#define CSA_LCBR CSA_LEFT_CURLY_BRACE
#define CSA_RIGHT_CURLY_BRACE ALTGR(KC_8) // }
#define CSA_RIGHT_CURLY_BRACE ALGR(KC_8) // }
#define CSA_RCBR CSA_RIGHT_CURLY_BRACE
#define CSA_LBRACKET ALTGR(KC_9) // [
#define CSA_LBRACKET ALGR(KC_9) // [
#define CSA_LBRC CSA_LBRACKET
#define CSA_RBRACKET ALTGR(KC_0) // ]
#define CSA_RBRACKET ALGR(KC_0) // ]
#define CSA_RBRC CSA_RBRACKET
#define CSA_NEGATION ALTGR(KC_EQUAL) // ¬
#define CSA_NEGATION ALGR(KC_EQUAL) // ¬
#define CSA_NEGT CSA_NEGATION
// Second row
// euro symbol not available on Linux? (X.org)
#define CSA_EURO ALTGR(KC_E) // €
#define CSA_DEAD_GRAVE ALTGR(CSA_DEAD_CIRCUMFLEX)
#define CSA_EURO ALGR(KC_E) // €
#define CSA_DEAD_GRAVE ALGR(CSA_DEAD_CIRCUMFLEX)
#define CSA_DGRV CSA_DEAD_GRAVE // dead `
#define CSA_DEAD_TILDE ALTGR(CSA_C_CEDILLA) // ~
#define CSA_DEAD_TILDE ALGR(CSA_C_CEDILLA) // ~
#define CSA_DTLD CSA_DEAD_TILDE
// Third row
#define CSA_DEGREE ALTGR(KC_SCOLON) // °
#define CSA_DEGREE ALGR(KC_SCOLON) // °
#define CSA_DEGR CSA_DEGREE
// Fourth row
#define CSA_LEFT_GUILLEMET ALTGR(KC_Z) // «
#define CSA_LEFT_GUILLEMET ALGR(KC_Z) // «
#define CSA_LGIL CSA_LEFT_GUILLEMET
#define CSA_RIGHT_GUILLEMET ALTGR(KC_X) // »
#define CSA_RIGHT_GUILLEMET ALGR(KC_X) // »
#define CSA_RGIL CSA_RIGHT_GUILLEMET
#define CSA_LESS ALTGR(KC_COMMA) // <
#define CSA_GREATER ALTGR(KC_DOT) // >
#define CSA_LESS ALGR(KC_COMMA) // <
#define CSA_GREATER ALGR(KC_DOT) // >
#define CSA_GRTR CSA_GREATER
// Space bar
#define CSA_NON_BREAKING_SPACE ALTGR(KC_SPACE)
#define CSA_NON_BREAKING_SPACE ALGR(KC_SPACE)
#define CSA_NBSP CSA_NON_BREAKING_SPACE
// GR2A-ed characters
@ -201,7 +190,7 @@
// nothing on 2
#define CSA_POUND GR2A(LSFT(KC_3)) // £
#define CSA_GBP CSA_POUND_SIGN
// already on ALTGR(KC_E)
// already on ALGR(KC_E)
#define CSA_EURO_BIS GR2A(LSFT(KC_4)) // €
#define CSA_EURB CSA_EURO_BIS
#define CSA_THREE_EIGHTHS GR2A(LSFT(KC_5)) // ⅜

4
quantum/keymap_extras/keymap_fr_ch.h
View file

@ -18,10 +18,6 @@
#include "keymap.h"
// Alt gr
#define ALGR(kc) RALT(kc)
#define FR_CH_ALGR KC_RALT
// normal characters
#define FR_CH_Z KC_Y
#define FR_CH_Y KC_Z

6
quantum/keymap_extras/keymap_french.h
View file

@ -18,12 +18,6 @@
#include "keymap.h"
// Alt gr
#ifndef ALGR
#define ALGR(kc) RALT(kc)
#endif
#define NO_ALGR KC_RALT
// Normal characters
#define FR_SUP2 KC_GRV
#define FR_AMP KC_1

4
quantum/keymap_extras/keymap_german.h
View file

@ -19,10 +19,6 @@
#include "keymap.h"
// Alt gr
#define ALGR(kc) RALT(kc)
#define DE_ALGR KC_RALT
// normal characters
#define DE_Z KC_Y
#define DE_Y KC_Z

4
quantum/keymap_extras/keymap_german_ch.h
View file

@ -18,10 +18,6 @@
#include "keymap.h"
// Alt gr
#define ALGR(kc) RALT(kc)
#define CH_ALGR KC_RALT
// normal characters
#define CH_Z KC_Y
#define CH_Y KC_Z

4
quantum/keymap_extras/keymap_hungarian.h
View file

@ -19,10 +19,6 @@
#include "keymap.h"
// Alt gr
#define ALGR(kc) RALT(kc)
#define HU_ALGR KC_RALT
// basic letters
#define HU_Z KC_Y
#define HU_Y KC_Z

7
quantum/keymap_extras/keymap_italian.h
View file

@ -19,14 +19,7 @@
#include "keymap.h"
// Alt gr
#define ALGR(kc) RALT(kc)
#define IT_ALGR KC_RALT
// normal characters
#define IT_A KC_A
#define IT_B KC_B
#define IT_C KC_C

3
quantum/keymap_extras/keymap_jp.h
View file

@ -40,6 +40,9 @@
#define JP_HENK KC_INT4 // henkan
#define JP_KANA KC_INT2 // katakana/hiragana|ro-mazi
#define JP_MKANA KC_LANG1 //kana on MacOSX
#define JP_MEISU KC_LANG2 //eisu on MacOSX
//Aliases for shifted symbols
#define JP_DQT LSFT(KC_2) // "

2
quantum/keymap_extras/keymap_neo2.h
View file

@ -73,6 +73,6 @@
#define NEO_L1_R DE_HASH
#define NEO_L2_L DE_LESS
#define NEO_L2_R DE_ALGR
#define NEO_L2_R KC_ALGR
#endif

4
quantum/keymap_extras/keymap_nordic.h
View file

@ -18,10 +18,6 @@
#include "keymap.h"
// Alt gr
#define ALGR(kc) RALT(kc)
#define NO_ALGR KC_RALT
// Normal characters
#define NO_HALF KC_GRV
#define NO_PLUS KC_MINS

47
quantum/keymap_extras/keymap_plover_dvorak.h Normal file
View file

@ -0,0 +1,47 @@
/* Copyright 2016 James Kay
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef KEYMAP_PLOVER_DVORAK_H
#define KEYMAP_PLOVER_DVORAK_H
#include "keymap_dvorak.h"
#define PD_NUM DV_1
#define PD_LS DV_Q
#define PD_LT DV_W
#define PD_LP DV_E
#define PD_LH DV_R
#define PD_LK DV_S
#define PD_LW DV_D
#define PD_LR DV_F
#define PD_STAR DV_Y
#define PD_RF DV_U
#define PD_RP DV_I
#define PD_RL DV_O
#define PD_RT DV_P
#define PD_RD DV_LBRC
#define PD_RR DV_J
#define PD_RB DV_K
#define PD_RG DV_L
#define PD_RS DV_SCLN
#define PD_RZ DV_QUOT
#define PD_A DV_C
#define PD_O DV_V
#define PD_E DV_N
#define PD_U DV_M
#endif

107
quantum/keymap_extras/keymap_slovenian.h Normal file
View file

@ -0,0 +1,107 @@
/* Copyright 2018 Žan Pevec
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef KEYMAP_SLOVENIAN
#define KEYMAP_SLOVENIAN
#include "keymap.h"
//Swapped Z and Y
#define SI_Z KC_Y
#define SI_Y KC_Z
//Special characters
#define SI_CV KC_SCLN
#define SI_SV KC_LBRC
#define SI_ZV KC_BSLS
#define SI_A KC_A
#define SI_B KC_B
#define SI_C KC_C
#define SI_D KC_D
#define SI_E KC_E
#define SI_F KC_F
#define SI_G KC_G
#define SI_H KC_H
#define SI_I KC_I
#define SI_J KC_J
#define SI_K KC_K
#define SI_L KC_L
#define SI_M KC_M
#define SI_N KC_N
#define SI_O KC_O
#define SI_P KC_P
#define SI_Q KC_Q
#define SI_R KC_R
#define SI_S KC_S
#define SI_T KC_T
#define SI_U KC_U
#define SI_V KC_V
#define SI_W KC_W
#define SI_X KC_X
#define SI_0 KC_0
#define SI_1 KC_1
#define SI_2 KC_2
#define SI_3 KC_3
#define SI_4 KC_4
#define SI_5 KC_5
#define SI_6 KC_6
#define SI_7 KC_7
#define SI_8 KC_8
#define SI_9 KC_9
#define SI_DOT KC_DOT
#define SI_COMM KC_COMM
#define SI_PLUS KC_EQL // + and * and ~
#define SI_QOT KC_MINS // Single quote
#define SI_MINS KC_SLSH // - and _
// shifted characters
#define SI_EXLM LSFT(KC_1) // !
#define SI_DQOT LSFT(KC_2) // "
#define SI_HASH LSFT(KC_3) // #
#define SI_DLR LSFT(KC_4) // $
#define SI_PERC LSFT(KC_5) // %
#define SI_AMPR LSFT(KC_6) // &
#define SI_SLSH LSFT(KC_7) // /
#define SI_LPRN LSFT(KC_8) // (
#define SI_RPRN LSFT(KC_9) // )
#define SI_EQL LSFT(KC_0) // =
#define SI_QST LSFT(SI_QOT) // ?
#define SI_ASTR LSFT(SI_PLUS) // *
#define SI_COLN LSFT(KC_DOT) // :
#define SI_SCLN LSFT(KC_COMM) // ;
#define SI_UNDS LSFT(SI_MINS) // _
// Alt Gr-ed characters
#define SI_CIRC ALGR(KC_3) // ^
#define SI_DEG ALGR(KC_5) // °
#define SI_GRV ALGR(KC_7) // `
#define SI_ACCU ALGR(KC_9) // ´
#define SI_LCBR ALGR(KC_B) // {
#define SI_RCBR ALGR(KC_N) // }
#define SI_LBRC ALGR(KC_F) // [
#define SI_RBRC ALGR(KC_G) // ]
#define SI_BSLS ALGR(KC_Q) // backslash
#define SI_AT ALGR(KC_V) // @
#define SI_EURO ALGR(KC_E) // €
#define SI_TILD ALGR(KC_1) // ~
#define SI_PIPE ALGR(KC_W) // |
#endif

4
quantum/keymap_extras/keymap_spanish.h
View file

@ -18,10 +18,6 @@
#include "keymap.h"
// Alt gr
#define ALGR(kc) RALT(kc)
#define NO_ALGR KC_RALT
// Normal characters
#define ES_OVRR KC_GRV
#define ES_APOS KC_MINS

4
quantum/keymap_extras/keymap_swedish.h
View file

@ -41,8 +41,8 @@
#define NO_DLR_MAC LSFT(KC_4) // $
#define NO_GRV_MAC ALGR(NO_BSLS) // `
#define NO_GRTR_MAC LSFT(KC_GRV) // >
#define NO_LCBR_MAC ALGR(LSFT(KC_8)) // }
#define NO_LESS_MAC KC_GRV // >
#define NO_LCBR_MAC ALGR(LSFT(KC_8)) // {
#define NO_LESS_MAC KC_GRV // <
#define NO_PIPE_MAC ALGR(KC_7) // |
#define NO_RCBR_MAC ALGR(LSFT(KC_9)) // }

4
quantum/keymap_extras/keymap_uk.h
View file

@ -18,10 +18,6 @@
#include "keymap.h"
// Alt gr
#define ALGR(kc) RALT(kc)
#define NO_ALGR KC_RALT
// Normal characters
#define UK_HASH KC_NUHS
#define UK_BSLS KC_NUBS

81
quantum/keymap_extras/sendstring_german.h Normal file
View file

@ -0,0 +1,81 @@
/* Copyright 2018 Patrick Hener
*
* 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/>.
*/
/* Sendstring definitions for the German layout */
#ifndef SENDSTRING_GERMAN
#define SENDSTRING_GERMAN
#include "keymap_german.h"
const bool ascii_to_shift_lut[0x80] PROGMEM = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 0, 1, 1, 1, 1,
1, 1, 1, 0, 0, 0, 0, 1,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 1, 0, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 0, 0, 0, 0, 1,
1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 1, 1, 1, 0
};
/* Until an ALT table/functionality is added, the following symbols will not work:
* § @ [ ] { } \ ~ äA öÖ ß ´
* Following characters can be printed using other characters like so:
* [ in makro will be ü
* { in makro will be Ü
* ~ in makro will be °
*/
const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
0, 0, 0, 0, 0, 0, 0, 0,
KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, KC_ESC, 0, 0, 0, 0,
/* SPACE ! " # $ % & ' */
KC_SPC, KC_1, KC_2, DE_HASH, KC_4, KC_5, KC_6, DE_HASH,
/* ( ) * + , - . / */
KC_8, KC_9, DE_PLUS, DE_PLUS, KC_COMM, DE_MINS, KC_DOT, KC_7,
/* 0 1 2 3 4 5 6 7 */
KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
/* 8 9 : ; < = > ? */
KC_8, KC_9, KC_DOT, KC_COMM, DE_LESS, KC_0, DE_LESS, KC_MINS,
/* @ A B C D E F G */
KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
/* H I J K L M N O */
KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
/* P Q R S T U V W */
KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
/* X Y Z [ \ ] ^ _ */
KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, DE_CIRC, DE_MINS,
/* ` a b c d e f g */
DE_ACUT, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
/* h i j k l m n o */
KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
/* p q r s t u v w */
KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
/* x y z { | } ~ DELETE */
KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
};
#endif

49
quantum/matrix.c
View file

@ -1,5 +1,5 @@
/*
Copyright 2012-2017 Jun Wako, Jack Humbert
Copyright 2012-2018 Jun Wako, Jack Humbert, Yiancar
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -16,15 +16,13 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdbool.h>
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h"
#include "timer.h"
#include "quantum.h"
#if (MATRIX_COLS <= 8)
@ -49,8 +47,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#endif
#if (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW)
static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
#endif
/* matrix state(1:on, 0:off) */
@ -198,9 +196,7 @@ uint8_t matrix_key_count(void)
static void init_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
uint8_t pin = col_pins[x];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInputHigh(col_pins[x]);
}
}
@ -220,8 +216,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
uint8_t pin = col_pins[col_index];
uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
uint8_t pin_state = readPin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
@ -235,24 +230,19 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
static void select_row(uint8_t row)
{
uint8_t pin = row_pins[row];
_SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
_SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
setPinOutput(row_pins[row]);
writePinLow(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
uint8_t pin = row_pins[row];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInputHigh(row_pins[row]);
}
static void unselect_rows(void)
{
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
uint8_t pin = row_pins[x];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInput(row_pins[x]);
}
}
@ -261,9 +251,7 @@ static void unselect_rows(void)
static void init_rows(void)
{
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
uint8_t pin = row_pins[x];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInputHigh(row_pins[x]);
}
}
@ -283,7 +271,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
if (readPin(row_pins[row_index]) == 0)
{
// Pin LO, set col bit
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
@ -309,24 +297,19 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
static void select_col(uint8_t col)
{
uint8_t pin = col_pins[col];
_SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
_SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
setPinOutput(col_pins[col]);
writePinLow(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
uint8_t pin = col_pins[col];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInputHigh(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
uint8_t pin = col_pins[x];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInputHigh(col_pins[x]);
}
}

2
quantum/process_keycode/process_auto_shift.c
View file

@ -173,6 +173,8 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) {
case KC_DOT:
case KC_SLSH:
case KC_GRAVE:
case KC_NONUS_BSLASH:
case KC_NONUS_HASH:
#endif
autoshift_flush();

76
quantum/process_keycode/process_chording.c
View file

@ -1,76 +0,0 @@
/* Copyright 2016 Jack Humbert
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "process_chording.h"
bool keys_chord(uint8_t keys[]) {
uint8_t keys_size = sizeof(keys)/sizeof(keys[0]);
bool pass = true;
uint8_t in = 0;
for (uint8_t i = 0; i < chord_key_count; i++) {
bool found = false;
for (uint8_t j = 0; j < keys_size; j++) {
if (chord_keys[i] == (keys[j] & 0xFF)) {
in++; // detects key in chord
found = true;
break;
}
}
if (found)
continue;
if (chord_keys[i] != 0) {
pass = false; // makes sure rest are blank
}
}
return (pass && (in == keys_size));
}
bool process_chording(uint16_t keycode, keyrecord_t *record) {
if (keycode >= QK_CHORDING && keycode <= QK_CHORDING_MAX) {
if (record->event.pressed) {
if (!chording) {
chording = true;
for (uint8_t i = 0; i < CHORDING_MAX; i++)
chord_keys[i] = 0;
chord_key_count = 0;
chord_key_down = 0;
}
chord_keys[chord_key_count] = (keycode & 0xFF);
chord_key_count++;
chord_key_down++;
return false;
} else {
if (chording) {
chord_key_down--;
if (chord_key_down == 0) {
chording = false;
// Chord Dictionary
if (keys_chord((uint8_t[]){KC_ENTER, KC_SPACE})) {
register_code(KC_A);
unregister_code(KC_A);
return false;
}
for (uint8_t i = 0; i < chord_key_count; i++) {
register_code(chord_keys[i]);
unregister_code(chord_keys[i]);
return false;
}
}
}
}
}
return true;
}

72
quantum/process_keycode/process_clicky.c
View file

@ -3,11 +3,6 @@
#ifdef AUDIO_CLICKY
#ifdef AUDIO_CLICKY_ON
bool clicky_enable = true;
#else // AUDIO_CLICKY_ON
bool clicky_enable = false;
#endif // AUDIO_CLICKY_ON
#ifndef AUDIO_CLICKY_FREQ_DEFAULT
#define AUDIO_CLICKY_FREQ_DEFAULT 440.0f
#endif // !AUDIO_CLICKY_FREQ_DEFAULT
@ -25,8 +20,11 @@ bool clicky_enable = false;
#endif // !AUDIO_CLICKY_FREQ_RANDOMNESS
float clicky_freq = AUDIO_CLICKY_FREQ_DEFAULT;
float clicky_rand = AUDIO_CLICKY_FREQ_RANDOMNESS;
float clicky_song[][2] = {{AUDIO_CLICKY_FREQ_DEFAULT, 3}, {AUDIO_CLICKY_FREQ_DEFAULT, 1}}; // 3 and 1 --> durations
extern audio_config_t audio_config;
#ifndef NO_MUSIC_MODE
extern bool music_activated;
extern bool midi_activated;
@ -36,31 +34,61 @@ void clicky_play(void) {
#ifndef NO_MUSIC_MODE
if (music_activated || midi_activated) return;
#endif // !NO_MUSIC_MODE
clicky_song[0][0] = 2.0f * clicky_freq * (1.0f + AUDIO_CLICKY_FREQ_RANDOMNESS * ( ((float)rand()) / ((float)(RAND_MAX)) ) );
clicky_song[1][0] = clicky_freq * (1.0f + AUDIO_CLICKY_FREQ_RANDOMNESS * ( ((float)rand()) / ((float)(RAND_MAX)) ) );
clicky_song[0][0] = 2.0f * clicky_freq * (1.0f + clicky_rand * ( ((float)rand()) / ((float)(RAND_MAX)) ) );
clicky_song[1][0] = clicky_freq * (1.0f + clicky_rand * ( ((float)rand()) / ((float)(RAND_MAX)) ) );
PLAY_SONG(clicky_song);
}
void clicky_freq_up(void) {
float new_freq = clicky_freq * AUDIO_CLICKY_FREQ_FACTOR;
if (new_freq < AUDIO_CLICKY_FREQ_MAX) {
clicky_freq = new_freq;
}
}
void clicky_freq_down(void) {
float new_freq = clicky_freq / AUDIO_CLICKY_FREQ_FACTOR;
if (new_freq > AUDIO_CLICKY_FREQ_MIN) {
clicky_freq = new_freq;
}
}
void clicky_freq_reset(void) {
clicky_freq = AUDIO_CLICKY_FREQ_DEFAULT;
}
void clicky_toggle(void) {
audio_config.clicky_enable ^= 1;
eeconfig_update_audio(audio_config.raw);
}
void clicky_on(void) {
audio_config.clicky_enable = 1;
eeconfig_update_audio(audio_config.raw);
}
void clicky_off(void) {
audio_config.clicky_enable = 0;
eeconfig_update_audio(audio_config.raw);
}
bool is_clicky_on(void) {
return (audio_config.clicky_enable != 0);
}
bool process_clicky(uint16_t keycode, keyrecord_t *record) {
if (keycode == CLICKY_TOGGLE && record->event.pressed) { clicky_enable = !clicky_enable; }
if (keycode == CLICKY_TOGGLE && record->event.pressed) { clicky_toggle(); }
if (keycode == CLICKY_RESET && record->event.pressed) { clicky_freq = AUDIO_CLICKY_FREQ_DEFAULT; }
if (keycode == CLICKY_ENABLE && record->event.pressed) { clicky_on(); }
if (keycode == CLICKY_DISABLE && record->event.pressed) { clicky_off(); }
if (keycode == CLICKY_UP && record->event.pressed) {
float new_freq = clicky_freq * AUDIO_CLICKY_FREQ_FACTOR;
if (new_freq < AUDIO_CLICKY_FREQ_MAX) {
clicky_freq = new_freq;
}
}
if (keycode == CLICKY_DOWN && record->event.pressed) {
float new_freq = clicky_freq / AUDIO_CLICKY_FREQ_FACTOR;
if (new_freq > AUDIO_CLICKY_FREQ_MIN) {
clicky_freq = new_freq;
}
}
if (keycode == CLICKY_RESET && record->event.pressed) { clicky_freq_reset(); }
if (keycode == CLICKY_UP && record->event.pressed) { clicky_freq_up(); }
if (keycode == CLICKY_DOWN && record->event.pressed) { clicky_freq_down(); }
if ( clicky_enable ) {
if ( audio_config.clicky_enable ) {
if (record->event.pressed) {
clicky_play();;
}

10
quantum/process_keycode/process_clicky.h
View file

@ -4,4 +4,14 @@
void clicky_play(void);
bool process_clicky(uint16_t keycode, keyrecord_t *record);
void clicky_freq_up(void);
void clicky_freq_down(void);
void clicky_freq_reset(void);
void clicky_toggle(void);
void clicky_on(void);
void clicky_off(void);
bool is_clicky_on(void);
#endif

49
quantum/process_keycode/process_leader.c
View file

@ -14,7 +14,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef DISABLE_LEADER
#ifdef LEADER_ENABLE
#include "process_leader.h"
@ -35,25 +35,40 @@ uint16_t leader_time = 0;
uint16_t leader_sequence[5] = {0, 0, 0, 0, 0};
uint8_t leader_sequence_size = 0;
void qk_leader_start(void) {
if (leading) { return; }
leader_start();
leading = true;
leader_time = timer_read();
leader_sequence_size = 0;
leader_sequence[0] = 0;
leader_sequence[1] = 0;
leader_sequence[2] = 0;
leader_sequence[3] = 0;
leader_sequence[4] = 0;
}
bool process_leader(uint16_t keycode, keyrecord_t *record) {
// Leader key set-up
if (record->event.pressed) {
if (!leading && keycode == KC_LEAD) {
leader_start();
leading = true;
leader_time = timer_read();
leader_sequence_size = 0;
leader_sequence[0] = 0;
leader_sequence[1] = 0;
leader_sequence[2] = 0;
leader_sequence[3] = 0;
leader_sequence[4] = 0;
return false;
}
if (leading && timer_elapsed(leader_time) < LEADER_TIMEOUT) {
leader_sequence[leader_sequence_size] = keycode;
leader_sequence_size++;
return false;
if (leading) {
if (timer_elapsed(leader_time) < LEADER_TIMEOUT) {
#ifndef LEADER_KEY_STRICT_KEY_PROCESSING
if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) {
keycode = keycode & 0xFF;
}
#endif // LEADER_KEY_STRICT_KEY_PROCESSING
leader_sequence[leader_sequence_size] = keycode;
leader_sequence_size++;
#ifdef LEADER_PER_KEY_TIMING
leader_time = timer_read();
#endif
return false;
}
} else {
if (keycode == KC_LEAD) {
qk_leader_start();
}
}
}
return true;

2
quantum/process_keycode/process_leader.h
View file

@ -24,7 +24,7 @@ bool process_leader(uint16_t keycode, keyrecord_t *record);
void leader_start(void);
void leader_end(void);
void qk_leader_start(void);
#define SEQ_ONE_KEY(key) if (leader_sequence[0] == (key) && leader_sequence[1] == 0 && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)
#define SEQ_TWO_KEYS(key1, key2) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)

6
quantum/process_keycode/process_tap_dance.c
View file

@ -16,6 +16,10 @@
#include "quantum.h"
#include "action_tapping.h"
#ifndef TAPPING_TERM
#define TAPPING_TERM 200
#endif
#ifndef NO_ACTION_ONESHOT
uint8_t get_oneshot_mods(void);
#endif
@ -127,6 +131,7 @@ void preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) {
if (keycode == action->state.keycode && keycode == last_td)
continue;
action->state.interrupted = true;
action->state.interrupting_keycode = keycode;
process_tap_dance_action_on_dance_finished (action);
reset_tap_dance (&action->state);
}
@ -205,5 +210,6 @@ void reset_tap_dance (qk_tap_dance_state_t *state) {
state->count = 0;
state->interrupted = false;
state->finished = false;
state->interrupting_keycode = 0;
last_td = 0;
}

1
quantum/process_keycode/process_tap_dance.h
View file

@ -27,6 +27,7 @@ typedef struct
uint8_t oneshot_mods;
uint8_t weak_mods;
uint16_t keycode;
uint16_t interrupting_keycode;
uint16_t timer;
bool interrupted;
bool pressed;

8
quantum/process_keycode/process_ucis.c
View file

@ -32,6 +32,10 @@ void qk_ucis_start_user(void) {
unicode_input_finish();
}
__attribute__((weak))
void qk_ucis_success(uint8_t symbol_index) {
}
static bool is_uni_seq(char *seq) {
uint8_t i;
@ -142,6 +146,10 @@ bool process_ucis (uint16_t keycode, keyrecord_t *record) {
}
unicode_input_finish();
if (symbol_found) {
qk_ucis_success(i);
}
qk_ucis_state.in_progress = false;
return false;
}

6
quantum/process_keycode/process_ucis.h
View file

@ -14,8 +14,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PROCESS_UCIS_H
#define PROCESS_UCIS_H
#pragma once
#include "quantum.h"
#include "process_unicode_common.h"
@ -45,7 +44,6 @@ extern const qk_ucis_symbol_t ucis_symbol_table[];
void qk_ucis_start(void);
void qk_ucis_start_user(void);
void qk_ucis_symbol_fallback (void);
void qk_ucis_success(uint8_t symbol_index);
void register_ucis(const char *hex);
bool process_ucis (uint16_t keycode, keyrecord_t *record);
#endif

7
quantum/process_keycode/process_unicode.c
View file

@ -17,14 +17,8 @@
#include "action_util.h"
#include "eeprom.h"
static uint8_t first_flag = 0;
bool process_unicode(uint16_t keycode, keyrecord_t *record) {
if (keycode > QK_UNICODE && record->event.pressed) {
if (first_flag == 0) {
set_unicode_input_mode(eeprom_read_byte(EECONFIG_UNICODEMODE));
first_flag = 1;
}
uint16_t unicode = keycode & 0x7FFF;
unicode_input_start();
register_hex(unicode);
@ -32,4 +26,3 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record) {
}
return true;
}

5
quantum/process_keycode/process_unicode.h
View file

@ -13,12 +13,9 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PROCESS_UNICODE_H
#define PROCESS_UNICODE_H
#pragma once
#include "quantum.h"
#include "process_unicode_common.h"
bool process_unicode(uint16_t keycode, keyrecord_t *record);
#endif

221
quantum/process_keycode/process_unicode_common.c
View file

@ -16,94 +16,115 @@
#include "process_unicode_common.h"
#include "eeprom.h"
#include <ctype.h>
#include <string.h>
static uint8_t input_mode;
uint8_t mods;
unicode_config_t unicode_config;
#if UNICODE_SELECTED_MODES != -1
static uint8_t selected[] = { UNICODE_SELECTED_MODES };
static uint8_t selected_count = sizeof selected / sizeof *selected;
static uint8_t selected_index;
#endif
void set_unicode_input_mode(uint8_t os_target)
{
input_mode = os_target;
eeprom_update_byte(EECONFIG_UNICODEMODE, os_target);
void unicode_input_mode_init(void) {
unicode_config.raw = eeprom_read_byte(EECONFIG_UNICODEMODE);
#if UNICODE_SELECTED_MODES != -1
#if UNICODE_CYCLE_PERSIST
// Find input_mode in selected modes
uint8_t i;
for (i = 0; i < selected_count; i++) {
if (selected[i] == unicode_config.input_mode) {
selected_index = i;
break;
}
}
if (i == selected_count) {
// Not found: input_mode isn't selected, change to one that is
unicode_config.input_mode = selected[selected_index = 0];
}
#else
// Always change to the first selected input mode
unicode_config.input_mode = selected[selected_index = 0];
#endif
#endif
dprintf("Unicode input mode init to: %u\n", unicode_config.input_mode);
}
uint8_t get_unicode_input_mode(void) {
return input_mode;
return unicode_config.input_mode;
}
void set_unicode_input_mode(uint8_t mode) {
unicode_config.input_mode = mode;
persist_unicode_input_mode();
dprintf("Unicode input mode set to: %u\n", unicode_config.input_mode);
}
void cycle_unicode_input_mode(uint8_t offset) {
#if UNICODE_SELECTED_MODES != -1
selected_index = (selected_index + offset) % selected_count;
unicode_config.input_mode = selected[selected_index];
#if UNICODE_CYCLE_PERSIST
persist_unicode_input_mode();
#endif
dprintf("Unicode input mode cycle to: %u\n", unicode_config.input_mode);
#endif
}
void persist_unicode_input_mode(void) {
eeprom_update_byte(EECONFIG_UNICODEMODE, unicode_config.input_mode);
}
static uint8_t saved_mods;
__attribute__((weak))
void unicode_input_start (void) {
// save current mods
mods = keyboard_report->mods;
void unicode_input_start(void) {
saved_mods = get_mods(); // Save current mods
clear_mods(); // Unregister mods to start from a clean state
// unregister all mods to start from clean state
if (mods & MOD_BIT(KC_LSFT)) unregister_code(KC_LSFT);
if (mods & MOD_BIT(KC_RSFT)) unregister_code(KC_RSFT);
if (mods & MOD_BIT(KC_LCTL)) unregister_code(KC_LCTL);
if (mods & MOD_BIT(KC_RCTL)) unregister_code(KC_RCTL);
if (mods & MOD_BIT(KC_LALT)) unregister_code(KC_LALT);
if (mods & MOD_BIT(KC_RALT)) unregister_code(KC_RALT);
if (mods & MOD_BIT(KC_LGUI)) unregister_code(KC_LGUI);
if (mods & MOD_BIT(KC_RGUI)) unregister_code(KC_RGUI);
switch(input_mode) {
switch (unicode_config.input_mode) {
case UC_OSX:
register_code(KC_LALT);
break;
case UC_OSX_RALT:
register_code(KC_RALT);
register_code(UNICODE_OSX_KEY);
break;
case UC_LNX:
register_code(KC_LCTL);
register_code(KC_LSFT);
register_code(KC_U);
unregister_code(KC_U);
tap_code(KC_U); // TODO: Replace with tap_code16(LCTL(LSFT(KC_U))); and test
unregister_code(KC_LSFT);
unregister_code(KC_LCTL);
break;
case UC_WIN:
register_code(KC_LALT);
register_code(KC_PPLS);
unregister_code(KC_PPLS);
tap_code(KC_PPLS);
break;
case UC_WINC:
register_code(KC_RALT);
unregister_code(KC_RALT);
register_code(KC_U);
unregister_code(KC_U);
tap_code(UNICODE_WINC_KEY);
tap_code(KC_U);
break;
}
wait_ms(UNICODE_TYPE_DELAY);
}
__attribute__((weak))
void unicode_input_finish (void) {
switch(input_mode) {
case UC_OSX:
case UC_WIN:
unregister_code(KC_LALT);
break;
case UC_OSX_RALT:
unregister_code(KC_RALT);
break;
case UC_LNX:
register_code(KC_SPC);
unregister_code(KC_SPC);
break;
void unicode_input_finish(void) {
switch (unicode_config.input_mode) {
case UC_OSX:
unregister_code(UNICODE_OSX_KEY);
break;
case UC_LNX:
tap_code(KC_SPC);
break;
case UC_WIN:
unregister_code(KC_LALT);
break;
}
// reregister previously set mods
if (mods & MOD_BIT(KC_LSFT)) register_code(KC_LSFT);
if (mods & MOD_BIT(KC_RSFT)) register_code(KC_RSFT);
if (mods & MOD_BIT(KC_LCTL)) register_code(KC_LCTL);
if (mods & MOD_BIT(KC_RCTL)) register_code(KC_RCTL);
if (mods & MOD_BIT(KC_LALT)) register_code(KC_LALT);
if (mods & MOD_BIT(KC_RALT)) register_code(KC_RALT);
if (mods & MOD_BIT(KC_LGUI)) register_code(KC_LGUI);
if (mods & MOD_BIT(KC_RGUI)) register_code(KC_RGUI);
set_mods(saved_mods); // Reregister previously set mods
}
__attribute__((weak))
uint16_t hex_to_keycode(uint8_t hex)
{
uint16_t hex_to_keycode(uint8_t hex) {
if (hex == 0x0) {
return KC_0;
} else if (hex < 0xA) {
@ -116,7 +137,89 @@ uint16_t hex_to_keycode(uint8_t hex)
void register_hex(uint16_t hex) {
for(int i = 3; i >= 0; i--) {
uint8_t digit = ((hex >> (i*4)) & 0xF);
register_code(hex_to_keycode(digit));
unregister_code(hex_to_keycode(digit));
tap_code(hex_to_keycode(digit));
}
}
void send_unicode_hex_string(const char *str) {
if (!str) { return; }
while (*str) {
// Find the next code point (token) in the string
for (; *str == ' '; str++);
size_t n = strcspn(str, " "); // Length of the current token
char code_point[n+1];
strncpy(code_point, str, n);
code_point[n] = '\0'; // Make sure it's null-terminated
// Normalize the code point: make all hex digits lowercase
for (char *p = code_point; *p; p++) {
*p = tolower((unsigned char)*p);
}
// Send the code point as a Unicode input string
unicode_input_start();
send_string(code_point);
unicode_input_finish();
str += n; // Move to the first ' ' (or '\0') after the current token
}
}
bool process_unicode_common(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {
switch (keycode) {
case UNICODE_MODE_FORWARD:
cycle_unicode_input_mode(+1);
break;
case UNICODE_MODE_REVERSE:
cycle_unicode_input_mode(-1);
break;
case UNICODE_MODE_OSX:
set_unicode_input_mode(UC_OSX);
#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_OSX)
static float song_osx[][2] = UNICODE_SONG_OSX;
PLAY_SONG(song_osx);
#endif
break;
case UNICODE_MODE_LNX:
set_unicode_input_mode(UC_LNX);
#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_LNX)
static float song_lnx[][2] = UNICODE_SONG_LNX;
PLAY_SONG(song_lnx);
#endif
break;
case UNICODE_MODE_WIN:
set_unicode_input_mode(UC_WIN);
#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_WIN)
static float song_win[][2] = UNICODE_SONG_WIN;
PLAY_SONG(song_win);
#endif
break;
case UNICODE_MODE_BSD:
set_unicode_input_mode(UC_BSD);
#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_BSD)
static float song_bsd[][2] = UNICODE_SONG_BSD;
PLAY_SONG(song_bsd);
#endif
break;
case UNICODE_MODE_WINC:
set_unicode_input_mode(UC_WINC);
#if defined(AUDIO_ENABLE) && defined(UNICODE_SONG_WINC)
static float song_winc[][2] = UNICODE_SONG_WINC;
PLAY_SONG(song_winc);
#endif
break;
}
}
#if defined(UNICODE_ENABLE)
return process_unicode(keycode, record);
#elif defined(UNICODEMAP_ENABLE)
return process_unicode_map(keycode, record);
#elif defined(UCIS_ENABLE)
return process_ucis(keycode, record);
#else
return true;
#endif
}

70
quantum/process_keycode/process_unicode_common.h
View file

@ -14,33 +14,71 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PROCESS_UNICODE_COMMON_H
#define PROCESS_UNICODE_COMMON_H
#pragma once
#include "quantum.h"
#ifndef UNICODE_TYPE_DELAY
#define UNICODE_TYPE_DELAY 10
#if defined(UNICODE_ENABLE) + defined(UNICODEMAP_ENABLE) + defined(UCIS_ENABLE) > 1
#error "Cannot enable more than one Unicode method (UNICODE, UNICODEMAP, UCIS) at the same time"
#endif
__attribute__ ((unused))
static uint8_t input_mode;
// Keycodes used for starting Unicode input on different platforms
#ifndef UNICODE_OSX_KEY
#define UNICODE_OSX_KEY KC_LALT
#endif
#ifndef UNICODE_WINC_KEY
#define UNICODE_WINC_KEY KC_RALT
#endif
void set_unicode_input_mode(uint8_t os_target);
// Comma-delimited, ordered list of input modes selected for use (e.g. in cycle)
// Example: #define UNICODE_SELECTED_MODES UC_WINC, UC_LNX
#ifndef UNICODE_SELECTED_MODES
#define UNICODE_SELECTED_MODES -1
#endif
// Whether input mode changes in cycle should be written to EEPROM
#ifndef UNICODE_CYCLE_PERSIST
#define UNICODE_CYCLE_PERSIST true
#endif
// Delay between starting Unicode input and sending a sequence, in ms
#ifndef UNICODE_TYPE_DELAY
#define UNICODE_TYPE_DELAY 10
#endif
enum unicode_input_modes {
UC_OSX, // Mac OS X using Unicode Hex Input
UC_LNX, // Linux using IBus
UC_WIN, // Windows using EnableHexNumpad
UC_BSD, // BSD (not implemented)
UC_WINC, // Windows using WinCompose (https://github.com/samhocevar/wincompose)
UC__COUNT // Number of available input modes (always leave at the end)
};
typedef union {
uint32_t raw;
struct {
uint8_t input_mode : 8;
};
} unicode_config_t;
extern unicode_config_t unicode_config;
void unicode_input_mode_init(void);
uint8_t get_unicode_input_mode(void);
void set_unicode_input_mode(uint8_t mode);
void cycle_unicode_input_mode(uint8_t offset);
void persist_unicode_input_mode(void);
void unicode_input_start(void);
void unicode_input_finish(void);
void register_hex(uint16_t hex);
#define UC_OSX 0 // Mac OS X
#define UC_LNX 1 // Linux
#define UC_WIN 2 // Windows 'HexNumpad'
#define UC_BSD 3 // BSD (not implemented)
#define UC_WINC 4 // WinCompose https://github.com/samhocevar/wincompose
#define UC_OSX_RALT 5 // Mac OS X using Right Alt key for Unicode Compose
void register_hex(uint16_t hex);
void send_unicode_hex_string(const char *str);
bool process_unicode_common(uint16_t keycode, keyrecord_t *record);
#define UC_BSPC UC(0x0008)
#define UC_SPC UC(0x0020)
#define UC_EXLM UC(0x0021)
@ -145,5 +183,3 @@ void register_hex(uint16_t hex);
#define UC_RCBR UC(0x007D)
#define UC_TILD UC(0x007E)
#define UC_DEL UC(0x007F)
#endif

4
quantum/process_keycode/process_unicodemap.c
View file

@ -50,7 +50,7 @@ bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
const uint32_t* map = unicode_map;
uint16_t index = keycode - QK_UNICODE_MAP;
uint32_t code = pgm_read_dword(&map[index]);
if (code > 0xFFFF && code <= 0x10ffff && (input_mode == UC_OSX || input_mode == UC_OSX_RALT)) {
if (code > 0xFFFF && code <= 0x10ffff && input_mode == UC_OSX) {
// Convert to UTF-16 surrogate pair
code -= 0x10000;
uint32_t lo = code & 0x3ff;
@ -59,7 +59,7 @@ bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
register_hex32(hi + 0xd800);
register_hex32(lo + 0xdc00);
unicode_input_finish();
} else if ((code > 0x10ffff && (input_mode == UC_OSX || input_mode == UC_OSX_RALT)) || (code > 0xFFFFF && input_mode == UC_LNX)) {
} else if ((code > 0x10ffff && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) {
// when character is out of range supported by the OS
unicode_map_input_error();
} else {

4
quantum/process_keycode/process_unicodemap.h
View file

@ -14,12 +14,10 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PROCESS_UNICODEMAP_H
#define PROCESS_UNICODEMAP_H
#pragma once
#include "quantum.h"
#include "process_unicode_common.h"
void unicode_map_input_error(void);
bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
#endif

149
quantum/quantum.c
View file

@ -42,6 +42,11 @@ extern backlight_config_t backlight_config;
#include "process_midi.h"
#endif
#ifdef ENCODER_ENABLE
#include "encoder.h"
#endif
#ifdef AUDIO_ENABLE
#ifndef GOODBYE_SONG
#define GOODBYE_SONG SONG(GOODBYE_SOUND)
@ -127,6 +132,14 @@ void unregister_code16 (uint16_t code) {
}
}
void tap_code16(uint16_t code) {
register_code16(code);
#if TAP_CODE_DELAY > 0
wait_ms(TAP_CODE_DELAY);
#endif
unregister_code16(code);
}
__attribute__ ((weak))
bool process_action_kb(keyrecord_t *record) {
return true;
@ -196,7 +209,7 @@ bool process_record_quantum(keyrecord_t *record) {
keypos_t key = record->event.key;
uint16_t keycode;
#if !defined(NO_ACTION_LAYER) && defined(PREVENT_STUCK_MODIFIERS)
#if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
/* TODO: Use store_or_get_action() or a similar function. */
if (!disable_action_cache) {
uint8_t layer;
@ -230,7 +243,7 @@ bool process_record_quantum(keyrecord_t *record) {
process_key_lock(&keycode, record) &&
#endif
#if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
process_clicky(keycode, record) &&
process_clicky(keycode, record) &&
#endif //AUDIO_CLICKY
process_record_kb(keycode, record) &&
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYPRESSES)
@ -245,36 +258,27 @@ bool process_record_quantum(keyrecord_t *record) {
#ifdef STENO_ENABLE
process_steno(keycode, record) &&
#endif
#if ( defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
#if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
process_music(keycode, record) &&
#endif
#ifdef TAP_DANCE_ENABLE
process_tap_dance(keycode, record) &&
#endif
#ifndef DISABLE_LEADER
process_leader(keycode, record) &&
#if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
process_unicode_common(keycode, record) &&
#endif
#ifndef DISABLE_CHORDING
process_chording(keycode, record) &&
#ifdef LEADER_ENABLE
process_leader(keycode, record) &&
#endif
#ifdef COMBO_ENABLE
process_combo(keycode, record) &&
#endif
#ifdef UNICODE_ENABLE
process_unicode(keycode, record) &&
#endif
#ifdef UCIS_ENABLE
process_ucis(keycode, record) &&
#endif
#ifdef PRINTING_ENABLE
process_printer(keycode, record) &&
#endif
#ifdef AUTO_SHIFT_ENABLE
process_auto_shift(keycode, record) &&
#endif
#ifdef UNICODEMAP_ENABLE
process_unicode_map(keycode, record) &&
#endif
#ifdef TERMINAL_ENABLE
process_terminal(keycode, record) &&
#endif
@ -296,6 +300,11 @@ bool process_record_quantum(keyrecord_t *record) {
print("DEBUG: enabled.\n");
}
return false;
case EEPROM_RESET:
if (record->event.pressed) {
eeconfig_init();
}
return false;
#ifdef FAUXCLICKY_ENABLE
case FC_TOG:
if (record->event.pressed) {
@ -445,75 +454,97 @@ bool process_record_quantum(keyrecord_t *record) {
return false;
case RGB_MODE_PLAIN:
if (record->event.pressed) {
rgblight_mode(1);
rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
}
return false;
case RGB_MODE_BREATHE:
#ifdef RGBLIGHT_EFFECT_BREATHING
if (record->event.pressed) {
if ((2 <= rgblight_get_mode()) && (rgblight_get_mode() < 5)) {
if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
(rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
rgblight_step();
} else {
rgblight_mode(2);
rgblight_mode(RGBLIGHT_MODE_BREATHING);
}
}
#endif
return false;
case RGB_MODE_RAINBOW:
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
if (record->event.pressed) {
if ((6 <= rgblight_get_mode()) && (rgblight_get_mode() < 8)) {
if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
(rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
rgblight_step();
} else {
rgblight_mode(6);
rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
}
}
#endif
return false;
case RGB_MODE_SWIRL:
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
if (record->event.pressed) {
if ((9 <= rgblight_get_mode()) && (rgblight_get_mode() < 14)) {
if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
(rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
rgblight_step();
} else {
rgblight_mode(9);
rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
}
}
#endif
return false;
case RGB_MODE_SNAKE:
#ifdef RGBLIGHT_EFFECT_SNAKE
if (record->event.pressed) {
if ((15 <= rgblight_get_mode()) && (rgblight_get_mode() < 20)) {
if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
(rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
rgblight_step();
} else {
rgblight_mode(15);
rgblight_mode(RGBLIGHT_MODE_SNAKE);
}
}
#endif
return false;
case RGB_MODE_KNIGHT:
#ifdef RGBLIGHT_EFFECT_KNIGHT
if (record->event.pressed) {
if ((21 <= rgblight_get_mode()) && (rgblight_get_mode() < 23)) {
if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
(rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
rgblight_step();
} else {
rgblight_mode(21);
rgblight_mode(RGBLIGHT_MODE_KNIGHT);
}
}
#endif
return false;
case RGB_MODE_XMAS:
#ifdef RGBLIGHT_EFFECT_CHRISTMAS
if (record->event.pressed) {
rgblight_mode(24);
rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
}
#endif
return false;
case RGB_MODE_GRADIENT:
#ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
if (record->event.pressed) {
if ((25 <= rgblight_get_mode()) && (rgblight_get_mode() < 34)) {
if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
(rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
rgblight_step();
} else {
rgblight_mode(25);
rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
}
}
#endif
return false;
case RGB_MODE_RGBTEST:
#ifdef RGBLIGHT_EFFECT_RGB_TEST
if (record->event.pressed) {
rgblight_mode(35);
rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
}
#endif
return false;
#endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
#ifdef PROTOCOL_LUFA
@ -607,6 +638,17 @@ bool process_record_quantum(keyrecord_t *record) {
PLAY_SONG(ag_norm_song);
#endif
break;
case MAGIC_TOGGLE_ALT_GUI:
keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
#ifdef AUDIO_ENABLE
if (keymap_config.swap_ralt_rgui) {
PLAY_SONG(ag_swap_song);
} else {
PLAY_SONG(ag_norm_song);
}
#endif
break;
case MAGIC_TOGGLE_NKRO:
keymap_config.nkro = !keymap_config.nkro;
break;
@ -914,7 +956,42 @@ void tap_random_base64(void) {
}
}
__attribute__((weak))
void bootmagic_lite(void) {
// The lite version of TMK's bootmagic based on Wilba.
// 100% less potential for accidentally making the
// keyboard do stupid things.
// We need multiple scans because debouncing can't be turned off.
matrix_scan();
#if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
wait_ms(DEBOUNCING_DELAY * 2);
#elif defined(DEBOUNCE) && DEBOUNCE > 0
wait_ms(DEBOUNCE * 2);
#else
wait_ms(30);
#endif
matrix_scan();
// If the Esc and space bar are held down on power up,
// reset the EEPROM valid state and jump to bootloader.
// Assumes Esc is at [0,0].
// This isn't very generalized, but we need something that doesn't
// rely on user's keymaps in firmware or EEPROM.
if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
eeconfig_disable();
// Jump to bootloader.
bootloader_jump();
}
}
void matrix_init_quantum() {
#ifdef BOOTMAGIC_LITE
bootmagic_lite();
#endif
if (!eeconfig_is_enabled()) {
eeconfig_init();
}
#ifdef BACKLIGHT_ENABLE
backlight_init_ports();
#endif
@ -924,6 +1001,12 @@ void matrix_init_quantum() {
#ifdef RGB_MATRIX_ENABLE
rgb_matrix_init();
#endif
#ifdef ENCODER_ENABLE
encoder_init();
#endif
#if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
unicode_input_mode_init();
#endif
matrix_init_kb();
}
@ -958,6 +1041,10 @@ void matrix_scan_quantum() {
rgb_matrix_task_counter = ((rgb_matrix_task_counter + 1) % (RGB_MATRIX_SKIP_FRAMES + 1));
#endif
#ifdef ENCODER_ENABLE
encoder_read();
#endif
matrix_scan_kb();
}
#if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)

95
quantum/quantum.h
View file

@ -1,4 +1,4 @@
/* Copyright 2016-2017 Erez Zukerman, Jack Humbert
/* Copyright 2016-2018 Erez Zukerman, Jack Humbert, Yiancar
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -17,9 +17,12 @@
#define QUANTUM_H
#if defined(__AVR__)
#include <avr/pgmspace.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#endif
#if defined(PROTOCOL_CHIBIOS)
#include "hal.h"
#endif
#include "wait.h"
#include "matrix.h"
@ -28,10 +31,16 @@
#include "backlight.h"
#endif
#if !defined(RGBLIGHT_ENABLE) && !defined(RGB_MATRIX_ENABLE)
#include "rgb.h"
#include "rgb.h"
#endif
#ifdef RGBLIGHT_ENABLE
#include "rgblight.h"
#else
#ifdef RGB_MATRIX_ENABLE
/* dummy define RGBLIGHT_MODE_xxxx */
#define RGBLIGHT_H_DUMMY_DEFINE
#include "rgblight.h"
#endif
#endif
#ifdef SPLIT_KEYBOARD
@ -70,9 +79,9 @@ extern uint32_t default_layer_state;
#ifdef AUDIO_ENABLE
#include "audio.h"
#include "process_audio.h"
#ifdef AUDIO_CLICKY
#include "process_clicky.h"
#endif // AUDIO_CLICKY
#ifdef AUDIO_CLICKY
#include "process_clicky.h"
#endif // AUDIO_CLICKY
#endif
#ifdef STENO_ENABLE
@ -83,15 +92,10 @@ extern uint32_t default_layer_state;
#include "process_music.h"
#endif
#ifndef DISABLE_LEADER
#ifdef LEADER_ENABLE
#include "process_leader.h"
#endif
#define DISABLE_CHORDING
#ifndef DISABLE_CHORDING
#include "process_chording.h"
#endif
#ifdef UNICODE_ENABLE
#include "process_unicode.h"
#endif
@ -104,7 +108,9 @@ extern uint32_t default_layer_state;
#include "process_unicodemap.h"
#endif
#include "process_tap_dance.h"
#ifdef TAP_DANCE_ENABLE
#include "process_tap_dance.h"
#endif
#ifdef PRINTING_ENABLE
#include "process_printer.h"
@ -132,6 +138,50 @@ extern uint32_t default_layer_state;
#include "hd44780.h"
#endif
//Function substitutions to ease GPIO manipulation
#ifdef __AVR__
#define PIN_ADDRESS(p, offset) _SFR_IO8(ADDRESS_BASE + (p >> PORT_SHIFTER) + offset)
#define pin_t uint8_t
#define setPinInput(pin) PIN_ADDRESS(pin, 1) &= ~ _BV(pin & 0xF)
#define setPinInputHigh(pin) ({\
PIN_ADDRESS(pin, 1) &= ~ _BV(pin & 0xF);\
PIN_ADDRESS(pin, 2) |= _BV(pin & 0xF);\
})
#define setPinInputLow(pin) _Static_assert(0, "AVR Processors cannot impliment an input as pull low")
#define setPinOutput(pin) PIN_ADDRESS(pin, 1) |= _BV(pin & 0xF)
#define writePinHigh(pin) PIN_ADDRESS(pin, 2) |= _BV(pin & 0xF)
#define writePinLow(pin) PIN_ADDRESS(pin, 2) &= ~_BV(pin & 0xF)
static inline void writePin(pin_t pin, uint8_t level){
if (level){
PIN_ADDRESS(pin, 2) |= _BV(pin & 0xF);
} else {
PIN_ADDRESS(pin, 2) &= ~_BV(pin & 0xF);
}
}
#define readPin(pin) ((bool)(PIN_ADDRESS(pin, 0) & _BV(pin & 0xF)))
#elif defined(PROTOCOL_CHIBIOS)
#define pin_t ioline_t
#define setPinInput(pin) palSetLineMode(pin, PAL_MODE_INPUT)
#define setPinInputHigh(pin) palSetLineMode(pin, PAL_MODE_INPUT_PULLUP)
#define setPinInputLow(pin) palSetLineMode(pin, PAL_MODE_INPUT_PULLDOWN)
#define setPinOutput(pin) palSetLineMode(pin, PAL_MODE_OUTPUT_PUSHPULL)
#define writePinHigh(pin) palSetLine(pin)
#define writePinLow(pin) palClearLine(pin)
static inline void writePin(pin_t pin, uint8_t level){
if (level){
palSetLine(pin);
} else {
palClearLine(pin);
}
}
#define readPin(pin) palReadLine(pin)
#endif
#define STRINGIZE(z) #z
#define ADD_SLASH_X(y) STRINGIZE(\x ## y)
#define SYMBOL_STR(x) ADD_SLASH_X(x)
@ -147,6 +197,7 @@ extern uint32_t default_layer_state;
#define SS_LALT(string) SS_DOWN(X_LALT) string SS_UP(X_LALT)
#define SS_LSFT(string) SS_DOWN(X_LSHIFT) string SS_UP(X_LSHIFT)
#define SS_RALT(string) SS_DOWN(X_RALT) string SS_UP(X_RALT)
#define SS_ALGR(string) SS_RALT(string)
#define SEND_STRING(str) send_string_P(PSTR(str))
extern const bool ascii_to_shift_lut[0x80];
@ -176,13 +227,23 @@ bool process_action_kb(keyrecord_t *record);
bool process_record_kb(uint16_t keycode, keyrecord_t *record);
bool process_record_user(uint16_t keycode, keyrecord_t *record);
#ifndef BOOTMAGIC_LITE_COLUMN
#define BOOTMAGIC_LITE_COLUMN 0
#endif
#ifndef BOOTMAGIC_LITE_ROW
#define BOOTMAGIC_LITE_ROW 0
#endif
void bootmagic_lite(void);
void reset_keyboard(void);
void startup_user(void);
void shutdown_user(void);
void register_code16 (uint16_t code);
void unregister_code16 (uint16_t code);
void register_code16(uint16_t code);
void unregister_code16(uint16_t code);
void tap_code16(uint16_t code);
#ifdef BACKLIGHT_ENABLE
void backlight_init_ports(void);

129
quantum/quantum_keycodes.h
View file

@ -63,10 +63,6 @@ enum quantum_keycodes {
QK_ONE_SHOT_LAYER_MAX = 0x54FF,
QK_ONE_SHOT_MOD = 0x5500,
QK_ONE_SHOT_MOD_MAX = 0x55FF,
#ifndef DISABLE_CHORDING
QK_CHORDING = 0x5600,
QK_CHORDING_MAX = 0x56FF,
#endif
QK_TAP_DANCE = 0x5700,
QK_TAP_DANCE_MAX = 0x57FF,
QK_LAYER_TAP_TOGGLE = 0x5800,
@ -85,9 +81,6 @@ enum quantum_keycodes {
#endif
QK_MOD_TAP = 0x6000,
QK_MOD_TAP_MAX = 0x7FFF,
#if defined(UNICODEMAP_ENABLE) && defined(UNICODE_ENABLE)
#error "Cannot enable both UNICODEMAP && UNICODE"
#endif
#ifdef UNICODE_ENABLE
QK_UNICODE = 0x8000,
QK_UNICODE_MAX = 0xFFFF,
@ -120,10 +113,11 @@ enum quantum_keycodes {
MAGIC_UNHOST_NKRO,
MAGIC_UNSWAP_ALT_GUI,
MAGIC_TOGGLE_NKRO,
MAGIC_TOGGLE_ALT_GUI,
GRAVE_ESC,
// Leader key
#ifndef DISABLE_LEADER
#ifdef LEADER_ENABLE
KC_LEAD,
#endif
@ -142,10 +136,13 @@ enum quantum_keycodes {
// Faux clicky as part of main audio feature
CLICKY_TOGGLE,
CLICKY_ENABLE,
CLICKY_DISABLE,
CLICKY_UP,
CLICKY_DOWN,
CLICKY_RESET,
#ifdef FAUXCLICKY_ENABLE
// Faux clicky
FC_ON,
@ -454,32 +451,43 @@ enum quantum_keycodes {
TERM_OFF,
#endif
EEPROM_RESET,
UNICODE_MODE_FORWARD,
UNICODE_MODE_REVERSE,
UNICODE_MODE_OSX,
UNICODE_MODE_LNX,
UNICODE_MODE_WIN,
UNICODE_MODE_BSD,
UNICODE_MODE_WINC,
// always leave at the end
SAFE_RANGE
};
// Ability to use mods in layouts
#define LCTL(kc) (kc | QK_LCTL)
#define LSFT(kc) (kc | QK_LSFT)
#define LALT(kc) (kc | QK_LALT)
#define LGUI(kc) (kc | QK_LGUI)
#define LCTL(kc) (QK_LCTL | (kc))
#define LSFT(kc) (QK_LSFT | (kc))
#define LALT(kc) (QK_LALT | (kc))
#define LGUI(kc) (QK_LGUI | (kc))
#define LCMD(kc) LGUI(kc)
#define LWIN(kc) LGUI(kc)
#define RCTL(kc) (kc | QK_RCTL)
#define RSFT(kc) (kc | QK_RSFT)
#define RALT(kc) (kc | QK_RALT)
#define RGUI(kc) (kc | QK_RGUI)
#define RCTL(kc) (QK_RCTL | (kc))
#define RSFT(kc) (QK_RSFT | (kc))
#define RALT(kc) (QK_RALT | (kc))
#define ALGR(kc) RALT(kc)
#define RGUI(kc) (QK_RGUI | (kc))
#define RCMD(kc) RGUI(kc)
#define RWIN(kc) RGUI(kc)
#define HYPR(kc) (kc | QK_LCTL | QK_LSFT | QK_LALT | QK_LGUI)
#define MEH(kc) (kc | QK_LCTL | QK_LSFT | QK_LALT)
#define LCAG(kc) (kc | QK_LCTL | QK_LALT | QK_LGUI)
#define ALTG(kc) (kc | QK_RCTL | QK_RALT)
#define SGUI(kc) (kc | QK_LGUI | QK_LSFT)
#define HYPR(kc) (QK_LCTL | QK_LSFT | QK_LALT | QK_LGUI | (kc))
#define MEH(kc) (QK_LCTL | QK_LSFT | QK_LALT | (kc))
#define LCAG(kc) (QK_LCTL | QK_LALT | QK_LGUI | (kc))
#define SGUI(kc) (QK_LGUI | QK_LSFT | (kc))
#define SCMD(kc) SGUI(kc)
#define SWIN(kc) SGUI(kc)
#define LCA(kc) (kc | QK_LCTL | QK_LALT)
#define LCA(kc) (QK_LCTL | QK_LALT | (kc))
#define MOD_HYPR 0xf
#define MOD_MEH 0x7
@ -557,26 +565,29 @@ enum quantum_keycodes {
#define KC_DELT KC_DELETE // Del key (four letter code)
// Alias for function layers than expand past FN31
#define FUNC(kc) (kc | QK_FUNCTION)
#define FUNC(kc) (QK_FUNCTION | (kc))
// Aliases
#define S(kc) LSFT(kc)
#define F(kc) FUNC(kc)
#define M(kc) (kc | QK_MACRO)
#define M(kc) (QK_MACRO | (kc))
#define MACROTAP(kc) (kc | QK_MACRO | FUNC_TAP<<8)
#define MACROTAP(kc) (QK_MACRO | (FUNC_TAP << 8) | (kc))
#define MACRODOWN(...) (record->event.pressed ? MACRO(__VA_ARGS__) : MACRO_NONE)
#define KC_GESC GRAVE_ESC
#define EEP_RST EEPROM_RESET
#define CK_TOGG CLICKY_TOGGLE
#define CK_RST CLICKY_RESET
#define CK_UP CLICKY_UP
#define CK_DOWN CLICKY_DOWN
#define CK_ON CLICKY_ENABLE
#define CK_OFF CLICKY_DISABLE
#define RGB_MOD RGB_MODE_FORWARD
#define RGB_SMOD RGB_MODE_FORWARD
#define RGB_RMOD RGB_MODE_REVERSE
#define RGB_M_P RGB_MODE_PLAIN
@ -590,10 +601,11 @@ enum quantum_keycodes {
#define RGB_M_T RGB_MODE_RGBTEST
// L-ayer, T-ap - 256 keycode max, 16 layer max
#define LT(layer, kc) (kc | QK_LAYER_TAP | ((layer & 0xF) << 8))
#define LT(layer, kc) (QK_LAYER_TAP | ((layer & 0xF) << 8) | ((kc) & 0xFF))
#define AG_SWAP MAGIC_SWAP_ALT_GUI
#define AG_NORM MAGIC_UNSWAP_ALT_GUI
#define AG_TOGG MAGIC_TOGGLE_ALT_GUI
// GOTO layer - 16 layers max
// when:
@ -602,32 +614,32 @@ enum quantum_keycodes {
// Unless you have a good reason not to do so, prefer ON_PRESS (1) as your default.
// In fact, we changed it to assume ON_PRESS for sanity/simplicity. If needed, you can add your own
// keycode modeled after the old version, kept below for this.
/* #define TO(layer, when) (layer | QK_TO | (when << 0x4)) */
#define TO(layer) (layer | QK_TO | (ON_PRESS << 0x4))
/* #define TO(layer, when) (QK_TO | (when << 0x4) | (layer & 0xFF)) */
#define TO(layer) (QK_TO | (ON_PRESS << 0x4) | (layer & 0xFF))
// Momentary switch layer - 256 layer max
#define MO(layer) (layer | QK_MOMENTARY)
#define MO(layer) (QK_MOMENTARY | (layer & 0xFF))
// Set default layer - 256 layer max
#define DF(layer) (layer | QK_DEF_LAYER)
#define DF(layer) (QK_DEF_LAYER | (layer & 0xFF))
// Toggle to layer - 256 layer max
#define TG(layer) (layer | QK_TOGGLE_LAYER)
#define TG(layer) (QK_TOGGLE_LAYER | (layer & 0xFF))
// One-shot layer - 256 layer max
#define OSL(layer) (layer | QK_ONE_SHOT_LAYER)
#define OSL(layer) (QK_ONE_SHOT_LAYER | (layer & 0xFF))
// L-ayer M-od: Momentary switch layer with modifiers active - 16 layer max, left mods only
#define LM(layer, mod) (QK_LAYER_MOD | (((layer) & 0xF) << 4) | ((mod) & 0xF))
#define LM(layer, mod) (QK_LAYER_MOD | ((layer & 0xF) << 4) | ((mod) & 0xF))
// One-shot mod
#define OSM(mod) ((mod) | QK_ONE_SHOT_MOD)
#define OSM(mod) (QK_ONE_SHOT_MOD | ((mod) & 0xFF))
// Layer tap-toggle
#define TT(layer) (layer | QK_LAYER_TAP_TOGGLE)
#define TT(layer) (QK_LAYER_TAP_TOGGLE | (layer & 0xFF))
// M-od, T-ap - 256 keycode max
#define MT(mod, kc) (kc | QK_MOD_TAP | (((mod) & 0x1F) << 8))
#define MT(mod, kc) (QK_MOD_TAP | (((mod) & 0x1F) << 8) | ((kc) & 0xFF))
#define CTL_T(kc) MT(MOD_LCTL, kc)
#define LCTL_T(kc) MT(MOD_LCTL, kc)
@ -640,7 +652,7 @@ enum quantum_keycodes {
#define ALT_T(kc) MT(MOD_LALT, kc)
#define LALT_T(kc) MT(MOD_LALT, kc)
#define RALT_T(kc) MT(MOD_RALT, kc)
#define ALGR_T(kc) MT(MOD_RALT, kc) // dual-function AltGR
#define ALGR_T(kc) RALT_T(kc)
#define GUI_T(kc) MT(MOD_LGUI, kc)
#define CMD_T(kc) GUI_T(kc)
@ -652,15 +664,15 @@ enum quantum_keycodes {
#define RCMD_T(kc) RGUI_T(kc)
#define RWIN_T(kc) RGUI_T(kc)
#define C_S_T(kc) MT((MOD_LCTL | MOD_LSFT), kc) // Control + Shift e.g. for gnome-terminal
#define MEH_T(kc) MT((MOD_LCTL | MOD_LSFT | MOD_LALT), kc) // Meh is a less hyper version of the Hyper key -- doesn't include Win or Cmd, so just alt+shift+ctrl
#define LCAG_T(kc) MT((MOD_LCTL | MOD_LALT | MOD_LGUI), kc) // Left control alt and gui
#define RCAG_T(kc) MT((MOD_RCTL | MOD_RALT | MOD_RGUI), kc) // Right control alt and gui
#define ALL_T(kc) MT((MOD_LCTL | MOD_LSFT | MOD_LALT | MOD_LGUI), kc) // see http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/
#define SGUI_T(kc) MT((MOD_LGUI | MOD_LSFT), kc)
#define C_S_T(kc) MT(MOD_LCTL | MOD_LSFT, kc) // Control + Shift e.g. for gnome-terminal
#define MEH_T(kc) MT(MOD_LCTL | MOD_LSFT | MOD_LALT, kc) // Meh is a less hyper version of the Hyper key -- doesn't include Win or Cmd, so just alt+shift+ctrl
#define LCAG_T(kc) MT(MOD_LCTL | MOD_LALT | MOD_LGUI, kc) // Left control alt and gui
#define RCAG_T(kc) MT(MOD_RCTL | MOD_RALT | MOD_RGUI, kc) // Right control alt and gui
#define ALL_T(kc) MT(MOD_LCTL | MOD_LSFT | MOD_LALT | MOD_LGUI, kc) // see http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/
#define SGUI_T(kc) MT(MOD_LGUI | MOD_LSFT, kc)
#define SCMD_T(kc) SGUI_T(kc)
#define SWIN_T(kc) SGUI_T(kc)
#define LCA_T(kc) MT((MOD_LCTL | MOD_LALT), kc) // Left control and left alt
#define LCA_T(kc) MT(MOD_LCTL | MOD_LALT, kc) // Left control and left alt
// Dedicated keycode versions for Hyper and Meh, if you want to use them as standalone keys rather than mod-tap
#define KC_HYPR HYPR(KC_NO)
@ -670,22 +682,31 @@ enum quantum_keycodes {
// For sending unicode codes.
// You may not send codes over 7FFF -- this supports most of UTF8.
// To have a key that sends out Œ, go UC(0x0152)
#define UNICODE(n) (n | QK_UNICODE)
#define UNICODE(n) (QK_UNICODE | (n))
#define UC(n) UNICODE(n)
#endif
#ifdef UNICODEMAP_ENABLE
#define X(n) (n | QK_UNICODE_MAP)
#define X(n) (QK_UNICODE_MAP | (n))
#endif
#define UC_MOD UNICODE_MODE_FORWARD
#define UC_RMOD UNICODE_MODE_REVERSE
#define UC_M_OS UNICODE_MODE_OSX
#define UC_M_LN UNICODE_MODE_LNX
#define UC_M_WI UNICODE_MODE_WIN
#define UC_M_BS UNICODE_MODE_BSD
#define UC_M_WC UNICODE_MODE_WINC
#ifdef SWAP_HANDS_ENABLE
#define SH_T(key) (QK_SWAP_HANDS | key)
#define SH_TG (QK_SWAP_HANDS | OP_SH_TOGGLE)
#define SH_TT (QK_SWAP_HANDS | OP_SH_TAP_TOGGLE)
#define SH_MON (QK_SWAP_HANDS | OP_SH_ON_OFF)
#define SH_MOFF (QK_SWAP_HANDS | OP_SH_OFF_ON)
#define SH_ON (QK_SWAP_HANDS | OP_SH_ON)
#define SH_OFF (QK_SWAP_HANDS | OP_SH_OFF)
#define SH_T(kc) (QK_SWAP_HANDS | (kc))
#define SH_TG (QK_SWAP_HANDS | OP_SH_TOGGLE)
#define SH_TT (QK_SWAP_HANDS | OP_SH_TAP_TOGGLE)
#define SH_MON (QK_SWAP_HANDS | OP_SH_ON_OFF)
#define SH_MOFF (QK_SWAP_HANDS | OP_SH_OFF_ON)
#define SH_ON (QK_SWAP_HANDS | OP_SH_ON)
#define SH_OFF (QK_SWAP_HANDS | OP_SH_OFF)
#endif
#endif // QUANTUM_KEYCODES_H

454
quantum/rgb_matrix.c
View file

@ -18,10 +18,10 @@
#include "rgb_matrix.h"
#include "i2c_master.h"
#include "progmem.h"
#include "config.h"
#include "eeprom.h"
#include <string.h>
#include <math.h>
rgb_config_t rgb_matrix_config;
@ -50,6 +50,15 @@ rgb_config_t rgb_matrix_config;
#define RGB_MATRIX_MAXIMUM_BRIGHTNESS 255
#endif
#ifndef RGB_DIGITAL_RAIN_DROPS
// lower the number for denser effect/wider keyboard
#define RGB_DIGITAL_RAIN_DROPS 24
#endif
#if !defined(DISABLE_RGB_MATRIX_RAINDROPS) || !defined(DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS) || !defined(DISABLE_RGB_MATRIX_DIGITAL_RAIN)
#define TRACK_PREVIOUS_EFFECT
#endif
bool g_suspend_state = false;
// Global tick at 20 Hz
@ -74,7 +83,12 @@ void eeconfig_update_rgb_matrix(uint32_t val) {
void eeconfig_update_rgb_matrix_default(void) {
dprintf("eeconfig_update_rgb_matrix_default\n");
rgb_matrix_config.enable = 1;
#ifndef DISABLE_RGB_MATRIX_CYCLE_ALL
rgb_matrix_config.mode = RGB_MATRIX_CYCLE_LEFT_RIGHT;
#else
// fallback to solid colors if RGB_MATRIX_CYCLE_LEFT_RIGHT is disabled in userspace
rgb_matrix_config.mode = RGB_MATRIX_SOLID_COLOR;
#endif
rgb_matrix_config.hue = 0;
rgb_matrix_config.sat = 255;
rgb_matrix_config.val = RGB_MATRIX_MAXIMUM_BRIGHTNESS;
@ -111,29 +125,15 @@ void map_row_column_to_led( uint8_t row, uint8_t column, uint8_t *led_i, uint8_t
}
void rgb_matrix_update_pwm_buffers(void) {
#ifdef IS31FL3731
IS31FL3731_update_pwm_buffers( DRIVER_ADDR_1, DRIVER_ADDR_2 );
IS31FL3731_update_led_control_registers( DRIVER_ADDR_1, DRIVER_ADDR_2 );
#elif defined(IS31FL3733)
IS31FL3733_update_pwm_buffers( DRIVER_ADDR_1, DRIVER_ADDR_2 );
IS31FL3733_update_led_control_registers( DRIVER_ADDR_1, DRIVER_ADDR_2 );
#endif
rgb_matrix_driver.flush();
}
void rgb_matrix_set_color( int index, uint8_t red, uint8_t green, uint8_t blue ) {
#ifdef IS31FL3731
IS31FL3731_set_color( index, red, green, blue );
#elif defined(IS31FL3733)
IS31FL3733_set_color( index, red, green, blue );
#endif
rgb_matrix_driver.set_color(index, red, green, blue);
}
void rgb_matrix_set_color_all( uint8_t red, uint8_t green, uint8_t blue ) {
#ifdef IS31FL3731
IS31FL3731_set_color_all( red, green, blue );
#elif defined(IS31FL3733)
IS31FL3733_set_color_all( red, green, blue );
#endif
rgb_matrix_driver.set_color_all(red, green, blue);
}
bool process_rgb_matrix(uint16_t keycode, keyrecord_t *record) {
@ -196,47 +196,6 @@ void rgb_matrix_test(void) {
}
}
// This tests the LEDs
// Note that it will change the LED control registers
// in the LED drivers, and leave them in an invalid
// state for other backlight effects.
// ONLY USE THIS FOR TESTING LEDS!
void rgb_matrix_single_LED_test(void) {
static uint8_t color = 0; // 0,1,2 for R,G,B
static uint8_t row = 0;
static uint8_t column = 0;
static uint8_t tick = 0;
tick++;
if ( tick > 2 )
{
tick = 0;
column++;
}
if ( column > MATRIX_COLS )
{
column = 0;
row++;
}
if ( row > MATRIX_ROWS )
{
row = 0;
color++;
}
if ( color > 2 )
{
color = 0;
}
uint8_t led[8], led_count;
map_row_column_to_led(row,column,led,&led_count);
for(uint8_t i = 0; i < led_count; i++) {
rgb_matrix_set_color_all( 40, 40, 40 );
rgb_matrix_test_led( led[i], color==0, color==1, color==2 );
}
}
// All LEDs off
void rgb_matrix_all_off(void) {
rgb_matrix_set_color_all( 0, 0, 0 );
@ -438,10 +397,12 @@ void rgb_matrix_cycle_up_down(void) {
void rgb_matrix_dual_beacon(void) {
HSV hsv = { .h = rgb_matrix_config.hue, .s = rgb_matrix_config.sat, .v = rgb_matrix_config.val };
RGB rgb;
rgb_led led;
Point point;
double cos_value = cos(g_tick * PI / 128) / 32;
double sin_value = sin(g_tick * PI / 128) / 112;
for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
led = g_rgb_leds[i];
hsv.h = ((led.point.y - 32.0)* cos(g_tick * PI / 128) / 32 + (led.point.x - 112.0) * sin(g_tick * PI / 128) / (112)) * (180) + rgb_matrix_config.hue;
point = g_rgb_leds[i].point;
hsv.h = ((point.y - 32.0)* cos_value + (point.x - 112.0) * sin_value) * (180) + rgb_matrix_config.hue;
rgb = hsv_to_rgb( hsv );
rgb_matrix_set_color( i, rgb.r, rgb.g, rgb.b );
}
@ -450,10 +411,12 @@ void rgb_matrix_dual_beacon(void) {
void rgb_matrix_rainbow_beacon(void) {
HSV hsv = { .h = rgb_matrix_config.hue, .s = rgb_matrix_config.sat, .v = rgb_matrix_config.val };
RGB rgb;
rgb_led led;
Point point;
double cos_value = cos(g_tick * PI / 128);
double sin_value = sin(g_tick * PI / 128);
for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
led = g_rgb_leds[i];
hsv.h = (1.5 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * (led.point.y - 32.0)* cos(g_tick * PI / 128) + (1.5 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * (led.point.x - 112.0) * sin(g_tick * PI / 128) + rgb_matrix_config.hue;
point = g_rgb_leds[i].point;
hsv.h = (1.5 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * (point.y - 32.0)* cos_value + (1.5 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * (point.x - 112.0) * sin_value + rgb_matrix_config.hue;
rgb = hsv_to_rgb( hsv );
rgb_matrix_set_color( i, rgb.r, rgb.g, rgb.b );
}
@ -462,10 +425,12 @@ void rgb_matrix_rainbow_beacon(void) {
void rgb_matrix_rainbow_pinwheels(void) {
HSV hsv = { .h = rgb_matrix_config.hue, .s = rgb_matrix_config.sat, .v = rgb_matrix_config.val };
RGB rgb;
rgb_led led;
Point point;
double cos_value = cos(g_tick * PI / 128);
double sin_value = sin(g_tick * PI / 128);
for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
led = g_rgb_leds[i];
hsv.h = (2 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * (led.point.y - 32.0)* cos(g_tick * PI / 128) + (2 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * (66 - abs(led.point.x - 112.0)) * sin(g_tick * PI / 128) + rgb_matrix_config.hue;
point = g_rgb_leds[i].point;
hsv.h = (2 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * (point.y - 32.0)* cos_value + (2 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * (66 - abs(point.x - 112.0)) * sin_value + rgb_matrix_config.hue;
rgb = hsv_to_rgb( hsv );
rgb_matrix_set_color( i, rgb.r, rgb.g, rgb.b );
}
@ -474,12 +439,14 @@ void rgb_matrix_rainbow_pinwheels(void) {
void rgb_matrix_rainbow_moving_chevron(void) {
HSV hsv = { .h = rgb_matrix_config.hue, .s = rgb_matrix_config.sat, .v = rgb_matrix_config.val };
RGB rgb;
rgb_led led;
Point point;
uint8_t r = 128;
double cos_value = cos(r * PI / 128);
double sin_value = sin(r * PI / 128);
double multiplier = (g_tick / 256.0 * 224);
for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
led = g_rgb_leds[i];
// uint8_t r = g_tick;
uint8_t r = 128;
hsv.h = (1.5 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * abs(led.point.y - 32.0)* sin(r * PI / 128) + (1.5 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * (led.point.x - (g_tick / 256.0 * 224)) * cos(r * PI / 128) + rgb_matrix_config.hue;
point = g_rgb_leds[i].point;
hsv.h = (1.5 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * abs(point.y - 32.0)* sin_value + (1.5 * (rgb_matrix_config.speed == 0 ? 1 : rgb_matrix_config.speed)) * (point.x - multiplier) * cos_value + rgb_matrix_config.hue;
rgb = hsv_to_rgb( hsv );
rgb_matrix_set_color( i, rgb.r, rgb.g, rgb.b );
}
@ -510,6 +477,68 @@ void rgb_matrix_jellybean_raindrops( bool initialize ) {
}
}
void rgb_matrix_digital_rain( const bool initialize ) {
// algorithm ported from https://github.com/tremby/Kaleidoscope-LEDEffect-DigitalRain
const uint8_t drop_ticks = 28;
const uint8_t pure_green_intensity = 0xd0;
const uint8_t max_brightness_boost = 0xc0;
const uint8_t max_intensity = 0xff;
static uint8_t map[MATRIX_COLS][MATRIX_ROWS] = {{0}};
static uint8_t drop = 0;
if (initialize) {
rgb_matrix_set_color_all(0, 0, 0);
memset(map, 0, sizeof map);
drop = 0;
}
for (uint8_t col = 0; col < MATRIX_COLS; col++) {
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
if (row == 0 && drop == 0 && rand() < RAND_MAX / RGB_DIGITAL_RAIN_DROPS) {
// top row, pixels have just fallen and we're
// making a new rain drop in this column
map[col][row] = max_intensity;
}
else if (map[col][row] > 0 && map[col][row] < max_intensity) {
// neither fully bright nor dark, decay it
map[col][row]--;
}
// set the pixel colour
uint8_t led, led_count;
map_row_column_to_led(row, col, &led, &led_count);
if (map[col][row] > pure_green_intensity) {
const uint8_t boost = (uint8_t) ((uint16_t) max_brightness_boost
* (map[col][row] - pure_green_intensity) / (max_intensity - pure_green_intensity));
rgb_matrix_set_color(led, boost, max_intensity, boost);
}
else {
const uint8_t green = (uint8_t) ((uint16_t) max_intensity * map[col][row] / pure_green_intensity);
rgb_matrix_set_color(led, 0, green, 0);
}
}
}
if (++drop > drop_ticks) {
// reset drop timer
drop = 0;
for (uint8_t row = MATRIX_ROWS - 1; row > 0; row--) {
for (uint8_t col = 0; col < MATRIX_COLS; col++) {
// if ths is on the bottom row and bright allow decay
if (row == MATRIX_ROWS - 1 && map[col][row] == max_intensity) {
map[col][row]--;
}
// check if the pixel above is bright
if (map[col][row - 1] == max_intensity) {
// allow old bright pixel to decay
map[col][row - 1]--;
// make this pixel bright
map[col][row] = max_intensity;
}
}
}
}
}
void rgb_matrix_multisplash(void) {
// if (g_any_key_hit < 0xFF) {
HSV hsv = { .h = rgb_matrix_config.hue, .s = rgb_matrix_config.sat, .v = rgb_matrix_config.val };
@ -598,11 +627,16 @@ void rgb_matrix_custom(void) {
}
void rgb_matrix_task(void) {
static uint8_t toggle_enable_last = 255;
#ifdef TRACK_PREVIOUS_EFFECT
static uint8_t toggle_enable_last = 255;
#endif
if (!rgb_matrix_config.enable) {
rgb_matrix_all_off();
toggle_enable_last = rgb_matrix_config.enable;
return;
rgb_matrix_all_off();
rgb_matrix_indicators();
#ifdef TRACK_PREVIOUS_EFFECT
toggle_enable_last = rgb_matrix_config.enable;
#endif
return;
}
// delay 1 second before driving LEDs or doing anything else
static uint8_t startup_tick = 0;
@ -637,13 +671,16 @@ void rgb_matrix_task(void) {
(RGB_DISABLE_AFTER_TIMEOUT > 0 && g_any_key_hit > RGB_DISABLE_AFTER_TIMEOUT * 60 * 20));
uint8_t effect = suspend_backlight ? 0 : rgb_matrix_config.mode;
// Keep track of the effect used last time,
// detect change in effect, so each effect can
// have an optional initialization.
static uint8_t effect_last = 255;
bool initialize = (effect != effect_last) || (rgb_matrix_config.enable != toggle_enable_last);
effect_last = effect;
toggle_enable_last = rgb_matrix_config.enable;
#ifdef TRACK_PREVIOUS_EFFECT
// Keep track of the effect used last time,
// detect change in effect, so each effect can
// have an optional initialization.
static uint8_t effect_last = 255;
bool initialize = (effect != effect_last) || (rgb_matrix_config.enable != toggle_enable_last);
effect_last = effect;
toggle_enable_last = rgb_matrix_config.enable;
#endif
// this gets ticked at 20 Hz.
// each effect can opt to do calculations
@ -652,55 +689,92 @@ void rgb_matrix_task(void) {
case RGB_MATRIX_SOLID_COLOR:
rgb_matrix_solid_color();
break;
case RGB_MATRIX_ALPHAS_MODS:
rgb_matrix_alphas_mods();
break;
case RGB_MATRIX_DUAL_BEACON:
rgb_matrix_dual_beacon();
break;
case RGB_MATRIX_GRADIENT_UP_DOWN:
rgb_matrix_gradient_up_down();
break;
case RGB_MATRIX_RAINDROPS:
rgb_matrix_raindrops( initialize );
break;
case RGB_MATRIX_CYCLE_ALL:
rgb_matrix_cycle_all();
break;
case RGB_MATRIX_CYCLE_LEFT_RIGHT:
rgb_matrix_cycle_left_right();
break;
case RGB_MATRIX_CYCLE_UP_DOWN:
rgb_matrix_cycle_up_down();
break;
case RGB_MATRIX_RAINBOW_BEACON:
rgb_matrix_rainbow_beacon();
break;
case RGB_MATRIX_RAINBOW_PINWHEELS:
rgb_matrix_rainbow_pinwheels();
break;
case RGB_MATRIX_RAINBOW_MOVING_CHEVRON:
rgb_matrix_rainbow_moving_chevron();
break;
case RGB_MATRIX_JELLYBEAN_RAINDROPS:
rgb_matrix_jellybean_raindrops( initialize );
break;
#ifndef DISABLE_RGB_MATRIX_ALPHAS_MODS
case RGB_MATRIX_ALPHAS_MODS:
rgb_matrix_alphas_mods();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_DUAL_BEACON
case RGB_MATRIX_DUAL_BEACON:
rgb_matrix_dual_beacon();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN
case RGB_MATRIX_GRADIENT_UP_DOWN:
rgb_matrix_gradient_up_down();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_RAINDROPS
case RGB_MATRIX_RAINDROPS:
rgb_matrix_raindrops( initialize );
break;
#endif
#ifndef DISABLE_RGB_MATRIX_CYCLE_ALL
case RGB_MATRIX_CYCLE_ALL:
rgb_matrix_cycle_all();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
case RGB_MATRIX_CYCLE_LEFT_RIGHT:
rgb_matrix_cycle_left_right();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_CYCLE_UP_DOWN
case RGB_MATRIX_CYCLE_UP_DOWN:
rgb_matrix_cycle_up_down();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_RAINBOW_BEACON
case RGB_MATRIX_RAINBOW_BEACON:
rgb_matrix_rainbow_beacon();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS
case RGB_MATRIX_RAINBOW_PINWHEELS:
rgb_matrix_rainbow_pinwheels();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
case RGB_MATRIX_RAINBOW_MOVING_CHEVRON:
rgb_matrix_rainbow_moving_chevron();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS
case RGB_MATRIX_JELLYBEAN_RAINDROPS:
rgb_matrix_jellybean_raindrops( initialize );
break;
#endif
#ifndef DISABLE_RGB_MATRIX_DIGITAL_RAIN
case RGB_MATRIX_DIGITAL_RAIN:
rgb_matrix_digital_rain( initialize );
break;
#endif
#ifdef RGB_MATRIX_KEYPRESSES
case RGB_MATRIX_SOLID_REACTIVE:
rgb_matrix_solid_reactive();
break;
case RGB_MATRIX_SPLASH:
rgb_matrix_splash();
break;
case RGB_MATRIX_MULTISPLASH:
rgb_matrix_multisplash();
break;
case RGB_MATRIX_SOLID_SPLASH:
rgb_matrix_solid_splash();
break;
case RGB_MATRIX_SOLID_MULTISPLASH:
rgb_matrix_solid_multisplash();
break;
#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE
case RGB_MATRIX_SOLID_REACTIVE:
rgb_matrix_solid_reactive();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_SPLASH
case RGB_MATRIX_SPLASH:
rgb_matrix_splash();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_MULTISPLASH
case RGB_MATRIX_MULTISPLASH:
rgb_matrix_multisplash();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_SOLID_SPLASH
case RGB_MATRIX_SOLID_SPLASH:
rgb_matrix_solid_splash();
break;
#endif
#ifndef DISABLE_RGB_MATRIX_SOLID_MULTISPLASH
case RGB_MATRIX_SOLID_MULTISPLASH:
rgb_matrix_solid_multisplash();
break;
#endif
#endif
default:
rgb_matrix_custom();
@ -743,7 +817,7 @@ void rgb_matrix_indicators_user(void) {}
// }
void rgb_matrix_init(void) {
rgb_matrix_setup_drivers();
rgb_matrix_driver.init();
// TODO: put the 1 second startup delay here?
@ -767,41 +841,14 @@ void rgb_matrix_init(void) {
eeconfig_debug_rgb_matrix(); // display current eeprom values
}
void rgb_matrix_setup_drivers(void) {
// Initialize TWI
i2c_init();
#ifdef IS31FL3731
IS31FL3731_init( DRIVER_ADDR_1 );
IS31FL3731_init( DRIVER_ADDR_2 );
#elif defined (IS31FL3733)
IS31FL3733_init( DRIVER_ADDR_1 );
#endif
for ( int index = 0; index < DRIVER_LED_TOTAL; index++ ) {
bool enabled = true;
// This only caches it for later
#ifdef IS31FL3731
IS31FL3731_set_led_control_register( index, enabled, enabled, enabled );
#elif defined (IS31FL3733)
IS31FL3733_set_led_control_register( index, enabled, enabled, enabled );
#endif
}
// This actually updates the LED drivers
#ifdef IS31FL3731
IS31FL3731_update_led_control_registers( DRIVER_ADDR_1, DRIVER_ADDR_2 );
#elif defined (IS31FL3733)
IS31FL3733_update_led_control_registers( DRIVER_ADDR_1, DRIVER_ADDR_2 );
#endif
}
// Deals with the messy details of incrementing an integer
uint8_t increment( uint8_t value, uint8_t step, uint8_t min, uint8_t max ) {
static uint8_t increment( uint8_t value, uint8_t step, uint8_t min, uint8_t max ) {
int16_t new_value = value;
new_value += step;
return MIN( MAX( new_value, min ), max );
}
uint8_t decrement( uint8_t value, uint8_t step, uint8_t min, uint8_t max ) {
static uint8_t decrement( uint8_t value, uint8_t step, uint8_t min, uint8_t max ) {
int16_t new_value = value;
new_value -= step;
return MIN( MAX( new_value, min ), max );
@ -836,96 +883,109 @@ uint8_t decrement( uint8_t value, uint8_t step, uint8_t min, uint8_t max ) {
// }
// }
void rgb_matrix_test_led( uint8_t index, bool red, bool green, bool blue ) {
for ( int i=0; i<DRIVER_LED_TOTAL; i++ )
{
if ( i == index )
{
#ifdef IS31FL3731
IS31FL3731_set_led_control_register( i, red, green, blue );
#elif defined (IS31FL3733)
IS31FL3733_set_led_control_register( i, red, green, blue );
#endif
}
else
{
#ifdef IS31FL3731
IS31FL3731_set_led_control_register( i, false, false, false );
#elif defined (IS31FL3733)
IS31FL3733_set_led_control_register( i, false, false, false );
#endif
}
}
}
uint32_t rgb_matrix_get_tick(void) {
return g_tick;
}
void rgblight_toggle(void) {
void rgb_matrix_toggle(void) {
rgb_matrix_config.enable ^= 1;
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgblight_step(void) {
void rgb_matrix_enable(void) {
rgb_matrix_config.enable = 1;
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgb_matrix_enable_noeeprom(void) {
rgb_matrix_config.enable = 1;
}
void rgb_matrix_disable(void) {
rgb_matrix_config.enable = 0;
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgb_matrix_disable_noeeprom(void) {
rgb_matrix_config.enable = 0;
}
void rgb_matrix_step(void) {
rgb_matrix_config.mode++;
if (rgb_matrix_config.mode >= RGB_MATRIX_EFFECT_MAX)
rgb_matrix_config.mode = 1;
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgblight_step_reverse(void) {
void rgb_matrix_step_reverse(void) {
rgb_matrix_config.mode--;
if (rgb_matrix_config.mode < 1)
rgb_matrix_config.mode = RGB_MATRIX_EFFECT_MAX - 1;
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgblight_increase_hue(void) {
void rgb_matrix_increase_hue(void) {
rgb_matrix_config.hue = increment( rgb_matrix_config.hue, 8, 0, 255 );
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgblight_decrease_hue(void) {
void rgb_matrix_decrease_hue(void) {
rgb_matrix_config.hue = decrement( rgb_matrix_config.hue, 8, 0, 255 );
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgblight_increase_sat(void) {
void rgb_matrix_increase_sat(void) {
rgb_matrix_config.sat = increment( rgb_matrix_config.sat, 8, 0, 255 );
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgblight_decrease_sat(void) {
void rgb_matrix_decrease_sat(void) {
rgb_matrix_config.sat = decrement( rgb_matrix_config.sat, 8, 0, 255 );
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgblight_increase_val(void) {
void rgb_matrix_increase_val(void) {
rgb_matrix_config.val = increment( rgb_matrix_config.val, 8, 0, RGB_MATRIX_MAXIMUM_BRIGHTNESS );
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgblight_decrease_val(void) {
void rgb_matrix_decrease_val(void) {
rgb_matrix_config.val = decrement( rgb_matrix_config.val, 8, 0, RGB_MATRIX_MAXIMUM_BRIGHTNESS );
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgblight_increase_speed(void) {
void rgb_matrix_increase_speed(void) {
rgb_matrix_config.speed = increment( rgb_matrix_config.speed, 1, 0, 3 );
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);//EECONFIG needs to be increased to support this
}
void rgblight_decrease_speed(void) {
void rgb_matrix_decrease_speed(void) {
rgb_matrix_config.speed = decrement( rgb_matrix_config.speed, 1, 0, 3 );
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);//EECONFIG needs to be increased to support this
}
void rgblight_mode(uint8_t mode) {
void rgb_matrix_mode(uint8_t mode) {
rgb_matrix_config.mode = mode;
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
uint32_t rgblight_get_mode(void) {
void rgb_matrix_mode_noeeprom(uint8_t mode) {
rgb_matrix_config.mode = mode;
}
uint8_t rgb_matrix_get_mode(void) {
return rgb_matrix_config.mode;
}
void rgb_matrix_sethsv(uint16_t hue, uint8_t sat, uint8_t val) {
rgb_matrix_config.hue = hue;
rgb_matrix_config.sat = sat;
rgb_matrix_config.val = val;
eeconfig_update_rgb_matrix(rgb_matrix_config.raw);
}
void rgb_matrix_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val) {
rgb_matrix_config.hue = hue;
rgb_matrix_config.sat = sat;
rgb_matrix_config.val = val;
}

120
quantum/rgb_matrix.h
View file

@ -70,28 +70,64 @@ typedef union {
enum rgb_matrix_effects {
RGB_MATRIX_SOLID_COLOR = 1,
#ifndef DISABLE_RGB_MATRIX_ALPHAS_MODS
RGB_MATRIX_ALPHAS_MODS,
#endif
#ifndef DISABLE_RGB_MATRIX_DUAL_BEACON
RGB_MATRIX_DUAL_BEACON,
#endif
#ifndef DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN
RGB_MATRIX_GRADIENT_UP_DOWN,
#endif
#ifndef DISABLE_RGB_MATRIX_RAINDROPS
RGB_MATRIX_RAINDROPS,
#endif
#ifndef DISABLE_RGB_MATRIX_CYCLE_ALL
RGB_MATRIX_CYCLE_ALL,
#endif
#ifndef DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
RGB_MATRIX_CYCLE_LEFT_RIGHT,
#endif
#ifndef DISABLE_RGB_MATRIX_CYCLE_UP_DOWN
RGB_MATRIX_CYCLE_UP_DOWN,
#endif
#ifndef DISABLE_RGB_MATRIX_RAINBOW_BEACON
RGB_MATRIX_RAINBOW_BEACON,
#endif
#ifndef DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS
RGB_MATRIX_RAINBOW_PINWHEELS,
#endif
#ifndef DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
RGB_MATRIX_RAINBOW_MOVING_CHEVRON,
#endif
#ifndef DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS
RGB_MATRIX_JELLYBEAN_RAINDROPS,
#endif
#ifndef DISABLE_RGB_MATRIX_DIGITAL_RAIN
RGB_MATRIX_DIGITAL_RAIN,
#endif
#ifdef RGB_MATRIX_KEYPRESSES
RGB_MATRIX_SOLID_REACTIVE,
RGB_MATRIX_SPLASH,
RGB_MATRIX_MULTISPLASH,
RGB_MATRIX_SOLID_SPLASH,
RGB_MATRIX_SOLID_MULTISPLASH,
#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE
RGB_MATRIX_SOLID_REACTIVE,
#endif
#ifndef DISABLE_RGB_MATRIX_SPLASH
RGB_MATRIX_SPLASH,
#endif
#ifndef DISABLE_RGB_MATRIX_MULTISPLASH
RGB_MATRIX_MULTISPLASH,
#endif
#ifndef DISABLE_RGB_MATRIX_SOLID_SPLASH
RGB_MATRIX_SOLID_SPLASH,
#endif
#ifndef DISABLE_RGB_MATRIX_SOLID_MULTISPLASH
RGB_MATRIX_SOLID_MULTISPLASH,
#endif
#endif
RGB_MATRIX_EFFECT_MAX
};
void rgb_matrix_set_color( int index, uint8_t red, uint8_t green, uint8_t blue );
void rgb_matrix_set_color_all( uint8_t red, uint8_t green, uint8_t blue );
// This runs after another backlight effect and replaces
// colors already set
@ -99,8 +135,6 @@ void rgb_matrix_indicators(void);
void rgb_matrix_indicators_kb(void);
void rgb_matrix_indicators_user(void);
void rgb_matrix_single_LED_test(void);
void rgb_matrix_init(void);
void rgb_matrix_setup_drivers(void);
@ -125,21 +159,65 @@ void rgb_matrix_decrease(void);
// void backlight_get_key_color( uint8_t led, HSV *hsv );
// void backlight_set_key_color( uint8_t row, uint8_t column, HSV hsv );
void rgb_matrix_test_led( uint8_t index, bool red, bool green, bool blue );
uint32_t rgb_matrix_get_tick(void);
void rgblight_toggle(void);
void rgblight_step(void);
void rgblight_step_reverse(void);
void rgblight_increase_hue(void);
void rgblight_decrease_hue(void);
void rgblight_increase_sat(void);
void rgblight_decrease_sat(void);
void rgblight_increase_val(void);
void rgblight_decrease_val(void);
void rgblight_increase_speed(void);
void rgblight_decrease_speed(void);
void rgblight_mode(uint8_t mode);
uint32_t rgblight_get_mode(void);
void rgb_matrix_toggle(void);
void rgb_matrix_enable(void);
void rgb_matrix_enable_noeeprom(void);
void rgb_matrix_disable(void);
void rgb_matrix_disable_noeeprom(void);
void rgb_matrix_step(void);
void rgb_matrix_sethsv(uint16_t hue, uint8_t sat, uint8_t val);
void rgb_matrix_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val);
void rgb_matrix_step_reverse(void);
void rgb_matrix_increase_hue(void);
void rgb_matrix_decrease_hue(void);
void rgb_matrix_increase_sat(void);
void rgb_matrix_decrease_sat(void);
void rgb_matrix_increase_val(void);
void rgb_matrix_decrease_val(void);
void rgb_matrix_increase_speed(void);
void rgb_matrix_decrease_speed(void);
void rgb_matrix_mode(uint8_t mode);
void rgb_matrix_mode_noeeprom(uint8_t mode);
uint8_t rgb_matrix_get_mode(void);
#ifndef RGBLIGHT_ENABLE
#define rgblight_toggle() rgb_matrix_toggle()
#define rgblight_enable() rgb_matrix_enable()
#define rgblight_enable_noeeprom() rgb_matrix_enable_noeeprom()
#define rgblight_disable() rgb_matrix_disable()
#define rgblight_disable_noeeprom() rgb_matrix_disable_noeeprom()
#define rgblight_step() rgb_matrix_step()
#define rgblight_sethsv(hue, sat, val) rgb_matrix_sethsv(hue, sat, val)
#define rgblight_sethsv_noeeprom(hue, sat, val) rgb_matrix_sethsv_noeeprom(hue, sat, val)
#define rgblight_step_reverse() rgb_matrix_step_reverse()
#define rgblight_increase_hue() rgb_matrix_increase_hue()
#define rgblight_decrease_hue() rgb_matrix_decrease_hue()
#define rgblight_increase_sat() rgb_matrix_increase_sat()
#define rgblight_decrease_sat() rgb_matrix_decrease_sat()
#define rgblight_increase_val() rgb_matrix_increase_val()
#define rgblight_decrease_val() rgb_matrix_decrease_val()
#define rgblight_increase_speed() rgb_matrix_increase_speed()
#define rgblight_decrease_speed() rgb_matrix_decrease_speed()
#define rgblight_mode(mode) rgb_matrix_mode(mode)
#define rgblight_mode_noeeprom(mode) rgb_matrix_mode_noeeprom(mode)
#define rgblight_get_mode() rgb_matrix_get_mode()
#endif
typedef struct {
/* Perform any initialisation required for the other driver functions to work. */
void (*init)(void);
/* Set the colour of a single LED in the buffer. */
void (*set_color)(int index, uint8_t r, uint8_t g, uint8_t b);
/* Set the colour of all LEDS on the keyboard in the buffer. */
void (*set_color_all)(uint8_t r, uint8_t g, uint8_t b);
/* Flush any buffered changes to the hardware. */
void (*flush)(void);
} rgb_matrix_driver_t;
extern const rgb_matrix_driver_t rgb_matrix_driver;
#endif

82
quantum/rgb_matrix_drivers.c Normal file
View file

@ -0,0 +1,82 @@
/* Copyright 2018 James Laird-Wah
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "rgb_matrix.h"
/* Each driver needs to define the struct
* const rgb_matrix_driver_t rgb_matrix_driver;
* All members must be provided.
* Keyboard custom drivers can define this in their own files, it should only
* be here if shared between boards.
*/
#if defined(IS31FL3731) || defined(IS31FL3733)
#include "i2c_master.h"
static void init( void )
{
i2c_init();
#ifdef IS31FL3731
IS31FL3731_init( DRIVER_ADDR_1 );
IS31FL3731_init( DRIVER_ADDR_2 );
#else
IS31FL3733_init( DRIVER_ADDR_1 );
#endif
for ( int index = 0; index < DRIVER_LED_TOTAL; index++ ) {
bool enabled = true;
// This only caches it for later
#ifdef IS31FL3731
IS31FL3731_set_led_control_register( index, enabled, enabled, enabled );
#else
IS31FL3733_set_led_control_register( index, enabled, enabled, enabled );
#endif
}
// This actually updates the LED drivers
#ifdef IS31FL3731
IS31FL3731_update_led_control_registers( DRIVER_ADDR_1, DRIVER_ADDR_2 );
#else
IS31FL3733_update_led_control_registers( DRIVER_ADDR_1, DRIVER_ADDR_2 );
#endif
}
#ifdef IS31FL3731
static void flush( void )
{
IS31FL3731_update_pwm_buffers( DRIVER_ADDR_1, DRIVER_ADDR_2 );
}
const rgb_matrix_driver_t rgb_matrix_driver = {
.init = init,
.flush = flush,
.set_color = IS31FL3731_set_color,
.set_color_all = IS31FL3731_set_color_all,
};
#else
static void flush( void )
{
IS31FL3733_update_pwm_buffers( DRIVER_ADDR_1, DRIVER_ADDR_2 );
}
const rgb_matrix_driver_t rgb_matrix_driver = {
.init = init,
.flush = flush,
.set_color = IS31FL3733_set_color,
.set_color_all = IS31FL3733_set_color_all,
};
#endif
#endif

343
quantum/rgblight.c
View file

@ -14,6 +14,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <math.h>
#include <string.h>
#ifdef __AVR__
#include <avr/eeprom.h>
#include <avr/interrupt.h>
@ -29,23 +30,27 @@
#define RGBLIGHT_LIMIT_VAL 255
#endif
#define _RGBM_SINGLE_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_SINGLE_DYNAMIC(sym)
#define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_MULTI_DYNAMIC(sym)
#define _RGBM_TMP_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_TMP_DYNAMIC(sym)
static uint8_t static_effect_table [] = {
#include "rgblight.h"
};
static inline int is_static_effect(uint8_t mode) {
return memchr(static_effect_table, mode, sizeof(static_effect_table)) != NULL;
}
#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))
__attribute__ ((weak))
const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5};
__attribute__ ((weak))
const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30};
__attribute__ ((weak))
const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20};
__attribute__ ((weak))
const uint8_t RGBLED_SNAKE_INTERVALS[] PROGMEM = {100, 50, 20};
__attribute__ ((weak))
const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {127, 63, 31};
#ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
__attribute__ ((weak))
const uint16_t RGBLED_GRADIENT_RANGES[] PROGMEM = {360, 240, 180, 120, 90};
__attribute__ ((weak))
const uint16_t RGBLED_RGBTEST_INTERVALS[] PROGMEM = {1024};
#endif
rgblight_config_t rgblight_config;
@ -129,7 +134,7 @@ void eeconfig_update_rgblight(uint32_t val) {
void eeconfig_update_rgblight_default(void) {
//dprintf("eeconfig_update_rgblight_default\n");
rgblight_config.enable = 1;
rgblight_config.mode = 1;
rgblight_config.mode = RGBLIGHT_MODE_STATIC_LIGHT;
rgblight_config.hue = 0;
rgblight_config.sat = 255;
rgblight_config.val = RGBLIGHT_LIMIT_VAL;
@ -163,9 +168,9 @@ void rgblight_init(void) {
}
eeconfig_debug_rgblight(); // display current eeprom values
#ifdef RGBLIGHT_ANIMATIONS
#ifdef RGBLIGHT_USE_TIMER
rgblight_timer_init(); // setup the timer
#endif
#endif
if (rgblight_config.enable) {
rgblight_mode_noeeprom(rgblight_config.mode);
@ -178,9 +183,9 @@ void rgblight_update_dword(uint32_t dword) {
if (rgblight_config.enable)
rgblight_mode(rgblight_config.mode);
else {
#ifdef RGBLIGHT_ANIMATIONS
#ifdef RGBLIGHT_USE_TIMER
rgblight_timer_disable();
#endif
#endif
rgblight_set();
}
}
@ -195,29 +200,41 @@ void rgblight_increase(void) {
void rgblight_decrease(void) {
uint8_t mode = 0;
// Mode will never be < 1. If it ever is, eeprom needs to be initialized.
if (rgblight_config.mode > 1) {
if (rgblight_config.mode > RGBLIGHT_MODE_STATIC_LIGHT) {
mode = rgblight_config.mode - 1;
}
rgblight_mode(mode);
}
void rgblight_step(void) {
void rgblight_step_helper(bool write_to_eeprom) {
uint8_t mode = 0;
mode = rgblight_config.mode + 1;
if (mode > RGBLIGHT_MODES) {
mode = 1;
}
rgblight_mode(mode);
rgblight_mode_eeprom_helper(mode, write_to_eeprom);
}
void rgblight_step_reverse(void) {
void rgblight_step_noeeprom(void) {
rgblight_step_helper(false);
}
void rgblight_step(void) {
rgblight_step_helper(true);
}
void rgblight_step_reverse_helper(bool write_to_eeprom) {
uint8_t mode = 0;
mode = rgblight_config.mode - 1;
if (mode < 1) {
mode = RGBLIGHT_MODES;
}
rgblight_mode(mode);
rgblight_mode_eeprom_helper(mode, write_to_eeprom);
}
void rgblight_step_reverse_noeeprom(void) {
rgblight_step_reverse_helper(false);
}
void rgblight_step_reverse(void) {
rgblight_step_reverse_helper(true);
}
uint32_t rgblight_get_mode(void) {
uint8_t rgblight_get_mode(void) {
if (!rgblight_config.enable) {
return false;
}
@ -229,8 +246,8 @@ void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
if (!rgblight_config.enable) {
return;
}
if (mode < 1) {
rgblight_config.mode = 1;
if (mode < RGBLIGHT_MODE_STATIC_LIGHT) {
rgblight_config.mode = RGBLIGHT_MODE_STATIC_LIGHT;
} else if (mode > RGBLIGHT_MODES) {
rgblight_config.mode = RGBLIGHT_MODES;
} else {
@ -242,30 +259,14 @@ void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom) {
} else {
xprintf("rgblight mode [NOEEPROM]: %u\n", rgblight_config.mode);
}
if (rgblight_config.mode == 1) {
#ifdef RGBLIGHT_ANIMATIONS
if( is_static_effect(rgblight_config.mode) ) {
#ifdef RGBLIGHT_USE_TIMER
rgblight_timer_disable();
#endif
} else if ((rgblight_config.mode >= 2 && rgblight_config.mode <= 24) ||
rgblight_config.mode == 35 || rgblight_config.mode == 36) {
// MODE 2-5, breathing
// MODE 6-8, rainbow mood
// MODE 9-14, rainbow swirl
// MODE 15-20, snake
// MODE 21-23, knight
// MODE 24, xmas
// MODE 35 RGB test
// MODE 36, alterating
#ifdef RGBLIGHT_ANIMATIONS
#endif
} else {
#ifdef RGBLIGHT_USE_TIMER
rgblight_timer_enable();
#endif
} else if (rgblight_config.mode >= 25 && rgblight_config.mode <= 34) {
// MODE 25-34, static gradient
#ifdef RGBLIGHT_ANIMATIONS
rgblight_timer_disable();
#endif
#endif
}
rgblight_sethsv_noeeprom(rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
}
@ -317,9 +318,9 @@ void rgblight_disable(void) {
rgblight_config.enable = 0;
eeconfig_update_rgblight(rgblight_config.raw);
xprintf("rgblight disable [EEPROM]: rgblight_config.enable = %u\n", rgblight_config.enable);
#ifdef RGBLIGHT_ANIMATIONS
rgblight_timer_disable();
#endif
#ifdef RGBLIGHT_USE_TIMER
rgblight_timer_disable();
#endif
wait_ms(50);
rgblight_set();
}
@ -327,76 +328,112 @@ void rgblight_disable(void) {
void rgblight_disable_noeeprom(void) {
rgblight_config.enable = 0;
xprintf("rgblight disable [noEEPROM]: rgblight_config.enable = %u\n", rgblight_config.enable);
#ifdef RGBLIGHT_ANIMATIONS
#ifdef RGBLIGHT_USE_TIMER
rgblight_timer_disable();
#endif
#endif
_delay_ms(50);
rgblight_set();
}
// Deals with the messy details of incrementing an integer
uint8_t increment( uint8_t value, uint8_t step, uint8_t min, uint8_t max ) {
static uint8_t increment( uint8_t value, uint8_t step, uint8_t min, uint8_t max ) {
int16_t new_value = value;
new_value += step;
return MIN( MAX( new_value, min ), max );
}
uint8_t decrement( uint8_t value, uint8_t step, uint8_t min, uint8_t max ) {
static uint8_t decrement( uint8_t value, uint8_t step, uint8_t min, uint8_t max ) {
int16_t new_value = value;
new_value -= step;
return MIN( MAX( new_value, min ), max );
}
void rgblight_increase_hue(void) {
void rgblight_increase_hue_helper(bool write_to_eeprom) {
uint16_t hue;
hue = (rgblight_config.hue+RGBLIGHT_HUE_STEP) % 360;
rgblight_sethsv(hue, rgblight_config.sat, rgblight_config.val);
rgblight_sethsv_eeprom_helper(hue, rgblight_config.sat, rgblight_config.val, write_to_eeprom);
}
void rgblight_decrease_hue(void) {
void rgblight_increase_hue_noeeprom(void) {
rgblight_increase_hue_helper(false);
}
void rgblight_increase_hue(void) {
rgblight_increase_hue_helper(true);
}
void rgblight_decrease_hue_helper(bool write_to_eeprom) {
uint16_t hue;
if (rgblight_config.hue-RGBLIGHT_HUE_STEP < 0) {
hue = (rgblight_config.hue + 360 - RGBLIGHT_HUE_STEP) % 360;
} else {
hue = (rgblight_config.hue - RGBLIGHT_HUE_STEP) % 360;
}
rgblight_sethsv(hue, rgblight_config.sat, rgblight_config.val);
rgblight_sethsv_eeprom_helper(hue, rgblight_config.sat, rgblight_config.val, write_to_eeprom);
}
void rgblight_increase_sat(void) {
void rgblight_decrease_hue_noeeprom(void) {
rgblight_decrease_hue_helper(false);
}
void rgblight_decrease_hue(void) {
rgblight_decrease_hue_helper(true);
}
void rgblight_increase_sat_helper(bool write_to_eeprom) {
uint8_t sat;
if (rgblight_config.sat + RGBLIGHT_SAT_STEP > 255) {
sat = 255;
} else {
sat = rgblight_config.sat + RGBLIGHT_SAT_STEP;
}
rgblight_sethsv(rgblight_config.hue, sat, rgblight_config.val);
rgblight_sethsv_eeprom_helper(rgblight_config.hue, sat, rgblight_config.val, write_to_eeprom);
}
void rgblight_decrease_sat(void) {
void rgblight_increase_sat_noeeprom(void) {
rgblight_increase_sat_helper(false);
}
void rgblight_increase_sat(void) {
rgblight_increase_sat_helper(true);
}
void rgblight_decrease_sat_helper(bool write_to_eeprom) {
uint8_t sat;
if (rgblight_config.sat - RGBLIGHT_SAT_STEP < 0) {
sat = 0;
} else {
sat = rgblight_config.sat - RGBLIGHT_SAT_STEP;
}
rgblight_sethsv(rgblight_config.hue, sat, rgblight_config.val);
rgblight_sethsv_eeprom_helper(rgblight_config.hue, sat, rgblight_config.val, write_to_eeprom);
}
void rgblight_increase_val(void) {
void rgblight_decrease_sat_noeeprom(void) {
rgblight_decrease_sat_helper(false);
}
void rgblight_decrease_sat(void) {
rgblight_decrease_sat_helper(true);
}
void rgblight_increase_val_helper(bool write_to_eeprom) {
uint8_t val;
if (rgblight_config.val + RGBLIGHT_VAL_STEP > RGBLIGHT_LIMIT_VAL) {
val = RGBLIGHT_LIMIT_VAL;
} else {
val = rgblight_config.val + RGBLIGHT_VAL_STEP;
}
rgblight_sethsv(rgblight_config.hue, rgblight_config.sat, val);
rgblight_sethsv_eeprom_helper(rgblight_config.hue, rgblight_config.sat, val, write_to_eeprom);
}
void rgblight_decrease_val(void) {
void rgblight_increase_val_noeeprom(void) {
rgblight_increase_val_helper(false);
}
void rgblight_increase_val(void) {
rgblight_increase_val_helper(true);
}
void rgblight_decrease_val_helper(bool write_to_eeprom) {
uint8_t val;
if (rgblight_config.val - RGBLIGHT_VAL_STEP < 0) {
val = 0;
} else {
val = rgblight_config.val - RGBLIGHT_VAL_STEP;
}
rgblight_sethsv(rgblight_config.hue, rgblight_config.sat, val);
rgblight_sethsv_eeprom_helper(rgblight_config.hue, rgblight_config.sat, val, write_to_eeprom);
}
void rgblight_decrease_val_noeeprom(void) {
rgblight_decrease_val_helper(false);
}
void rgblight_decrease_val(void) {
rgblight_decrease_val_helper(true);
}
void rgblight_increase_speed(void) {
rgblight_config.speed = increment( rgblight_config.speed, 1, 0, 3 );
@ -419,24 +456,43 @@ void rgblight_sethsv_noeeprom_old(uint16_t hue, uint8_t sat, uint8_t val) {
void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom) {
if (rgblight_config.enable) {
if (rgblight_config.mode == 1) {
if (rgblight_config.mode == RGBLIGHT_MODE_STATIC_LIGHT) {
// same static color
LED_TYPE tmp_led;
sethsv(hue, sat, val, &tmp_led);
rgblight_setrgb(tmp_led.r, tmp_led.g, tmp_led.b);
} else {
// all LEDs in same color
if (rgblight_config.mode >= 2 && rgblight_config.mode <= 5) {
if ( 1 == 0 ) { //dummy
}
#ifdef RGBLIGHT_EFFECT_BREATHING
else if (rgblight_config.mode >= RGBLIGHT_MODE_BREATHING &&
rgblight_config.mode <= RGBLIGHT_MODE_BREATHING_end) {
// breathing mode, ignore the change of val, use in memory value instead
val = rgblight_config.val;
} else if (rgblight_config.mode >= 6 && rgblight_config.mode <= 14) {
// rainbow mood and rainbow swirl, ignore the change of hue
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_MOOD &&
rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_MOOD_end) {
// rainbow mood, ignore the change of hue
hue = rgblight_config.hue;
} else if (rgblight_config.mode >= 25 && rgblight_config.mode <= 34) {
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_SWIRL &&
rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_SWIRL_end) {
// rainbow swirl, ignore the change of hue
hue = rgblight_config.hue;
}
#endif
#ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
else if (rgblight_config.mode >= RGBLIGHT_MODE_STATIC_GRADIENT &&
rgblight_config.mode <= RGBLIGHT_MODE_STATIC_GRADIENT_end) {
// static gradient
uint16_t _hue;
int8_t direction = ((rgblight_config.mode - 25) % 2) ? -1 : 1;
uint16_t range = pgm_read_word(&RGBLED_GRADIENT_RANGES[(rgblight_config.mode - 25) / 2]);
int8_t direction = ((rgblight_config.mode - RGBLIGHT_MODE_STATIC_GRADIENT) % 2) ? -1 : 1;
uint16_t range = pgm_read_word(&RGBLED_GRADIENT_RANGES[(rgblight_config.mode - RGBLIGHT_MODE_STATIC_GRADIENT) / 2]);
for (uint8_t i = 0; i < RGBLED_NUM; i++) {
_hue = (range / RGBLED_NUM * i * direction + hue + 360) % 360;
dprintf("rgblight rainbow set hsv: %u,%u,%d,%u\n", i, _hue, direction, range);
@ -444,6 +500,7 @@ void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool
}
rgblight_set();
}
#endif
}
rgblight_config.hue = hue;
rgblight_config.sat = sat;
@ -528,7 +585,7 @@ void rgblight_set(void) {
}
#endif
#ifdef RGBLIGHT_ANIMATIONS
#ifdef RGBLIGHT_USE_TIMER
// Animation timer -- AVR Timer3
void rgblight_timer_init(void) {
@ -564,41 +621,77 @@ void rgblight_timer_toggle(void) {
void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b) {
rgblight_enable();
rgblight_mode(1);
rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
rgblight_setrgb(r, g, b);
}
void rgblight_task(void) {
if (rgblight_timer_enabled) {
// mode = 1, static light, do nothing here
if (rgblight_config.mode >= 2 && rgblight_config.mode <= 5) {
// mode = 2 to 5, breathing mode
rgblight_effect_breathing(rgblight_config.mode - 2);
} else if (rgblight_config.mode >= 6 && rgblight_config.mode <= 8) {
// mode = 6 to 8, rainbow mood mod
rgblight_effect_rainbow_mood(rgblight_config.mode - 6);
} else if (rgblight_config.mode >= 9 && rgblight_config.mode <= 14) {
// mode = 9 to 14, rainbow swirl mode
rgblight_effect_rainbow_swirl(rgblight_config.mode - 9);
} else if (rgblight_config.mode >= 15 && rgblight_config.mode <= 20) {
// mode = 15 to 20, snake mode
rgblight_effect_snake(rgblight_config.mode - 15);
} else if (rgblight_config.mode >= 21 && rgblight_config.mode <= 23) {
// mode = 21 to 23, knight mode
rgblight_effect_knight(rgblight_config.mode - 21);
} else if (rgblight_config.mode == 24) {
// mode = 24, christmas mode
// static light mode, do nothing here
if ( 1 == 0 ) { //dummy
}
#ifdef RGBLIGHT_EFFECT_BREATHING
else if (rgblight_config.mode >= RGBLIGHT_MODE_BREATHING &&
rgblight_config.mode <= RGBLIGHT_MODE_BREATHING_end) {
// breathing mode
rgblight_effect_breathing(rgblight_config.mode - RGBLIGHT_MODE_BREATHING );
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_MOOD &&
rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_MOOD_end) {
// rainbow mood mode
rgblight_effect_rainbow_mood(rgblight_config.mode - RGBLIGHT_MODE_RAINBOW_MOOD);
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
else if (rgblight_config.mode >= RGBLIGHT_MODE_RAINBOW_SWIRL &&
rgblight_config.mode <= RGBLIGHT_MODE_RAINBOW_SWIRL_end) {
// rainbow swirl mode
rgblight_effect_rainbow_swirl(rgblight_config.mode - RGBLIGHT_MODE_RAINBOW_SWIRL);
}
#endif
#ifdef RGBLIGHT_EFFECT_SNAKE
else if (rgblight_config.mode >= RGBLIGHT_MODE_SNAKE &&
rgblight_config.mode <= RGBLIGHT_MODE_SNAKE_end) {
// snake mode
rgblight_effect_snake(rgblight_config.mode - RGBLIGHT_MODE_SNAKE);
}
#endif
#ifdef RGBLIGHT_EFFECT_KNIGHT
else if (rgblight_config.mode >= RGBLIGHT_MODE_KNIGHT &&
rgblight_config.mode <= RGBLIGHT_MODE_KNIGHT_end) {
// knight mode
rgblight_effect_knight(rgblight_config.mode - RGBLIGHT_MODE_KNIGHT);
}
#endif
#ifdef RGBLIGHT_EFFECT_CHRISTMAS
else if (rgblight_config.mode == RGBLIGHT_MODE_CHRISTMAS) {
// christmas mode
rgblight_effect_christmas();
} else if (rgblight_config.mode == 35) {
// mode = 35, RGB test
}
#endif
#ifdef RGBLIGHT_EFFECT_RGB_TEST
else if (rgblight_config.mode == RGBLIGHT_MODE_RGB_TEST) {
// RGB test mode
rgblight_effect_rgbtest();
} else if (rgblight_config.mode == 36){
}
#endif
#ifdef RGBLIGHT_EFFECT_ALTERNATING
else if (rgblight_config.mode == RGBLIGHT_MODE_ALTERNATING){
rgblight_effect_alternating();
}
#endif
}
}
#endif /* RGBLIGHT_USE_TIMER */
// Effects
#ifdef RGBLIGHT_EFFECT_BREATHING
__attribute__ ((weak))
const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5};
void rgblight_effect_breathing(uint8_t interval) {
static uint8_t pos = 0;
static uint16_t last_timer = 0;
@ -609,12 +702,17 @@ void rgblight_effect_breathing(uint8_t interval) {
}
last_timer = timer_read();
// http://sean.voisen.org/blog/2011/10/breathing-led-with-arduino/
val = (exp(sin((pos/255.0)*M_PI)) - RGBLIGHT_EFFECT_BREATHE_CENTER/M_E)*(RGBLIGHT_EFFECT_BREATHE_MAX/(M_E-1/M_E));
rgblight_sethsv_noeeprom_old(rgblight_config.hue, rgblight_config.sat, val);
pos = (pos + 1) % 256;
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
__attribute__ ((weak))
const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30};
void rgblight_effect_rainbow_mood(uint8_t interval) {
static uint16_t current_hue = 0;
static uint16_t last_timer = 0;
@ -626,6 +724,16 @@ void rgblight_effect_rainbow_mood(uint8_t interval) {
rgblight_sethsv_noeeprom_old(current_hue, rgblight_config.sat, rgblight_config.val);
current_hue = (current_hue + 1) % 360;
}
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
#ifndef RGBLIGHT_RAINBOW_SWIRL_RANGE
#define RGBLIGHT_RAINBOW_SWIRL_RANGE 360
#endif
__attribute__ ((weak))
const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20};
void rgblight_effect_rainbow_swirl(uint8_t interval) {
static uint16_t current_hue = 0;
static uint16_t last_timer = 0;
@ -636,7 +744,7 @@ void rgblight_effect_rainbow_swirl(uint8_t interval) {
}
last_timer = timer_read();
for (i = 0; i < RGBLED_NUM; i++) {
hue = (360 / RGBLED_NUM * i + current_hue) % 360;
hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / RGBLED_NUM * i + current_hue) % 360;
sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
}
rgblight_set();
@ -651,6 +759,12 @@ void rgblight_effect_rainbow_swirl(uint8_t interval) {
}
}
}
#endif
#ifdef RGBLIGHT_EFFECT_SNAKE
__attribute__ ((weak))
const uint8_t RGBLED_SNAKE_INTERVALS[] PROGMEM = {100, 50, 20};
void rgblight_effect_snake(uint8_t interval) {
static uint8_t pos = 0;
static uint16_t last_timer = 0;
@ -689,6 +803,12 @@ void rgblight_effect_snake(uint8_t interval) {
pos = (pos + 1) % RGBLED_NUM;
}
}
#endif
#ifdef RGBLIGHT_EFFECT_KNIGHT
__attribute__ ((weak))
const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {127, 63, 31};
void rgblight_effect_knight(uint8_t interval) {
static uint16_t last_timer = 0;
if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_KNIGHT_INTERVALS[interval])) {
@ -730,8 +850,9 @@ void rgblight_effect_knight(uint8_t interval) {
increment = -increment;
}
}
#endif
#ifdef RGBLIGHT_EFFECT_CHRISTMAS
void rgblight_effect_christmas(void) {
static uint16_t current_offset = 0;
static uint16_t last_timer = 0;
@ -748,6 +869,11 @@ void rgblight_effect_christmas(void) {
}
rgblight_set();
}
#endif
#ifdef RGBLIGHT_EFFECT_RGB_TEST
__attribute__ ((weak))
const uint16_t RGBLED_RGBTEST_INTERVALS[] PROGMEM = {1024};
void rgblight_effect_rgbtest(void) {
static uint8_t pos = 0;
@ -774,7 +900,9 @@ void rgblight_effect_rgbtest(void) {
rgblight_setrgb(r, g, b);
pos = (pos + 1) % 3;
}
#endif
#ifdef RGBLIGHT_EFFECT_ALTERNATING
void rgblight_effect_alternating(void){
static uint16_t last_timer = 0;
static uint16_t pos = 0;
@ -784,16 +912,15 @@ void rgblight_effect_alternating(void){
last_timer = timer_read();
for(int i = 0; i<RGBLED_NUM; i++){
if(i<RGBLED_NUM/2 && pos){
rgblight_sethsv_at(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, i);
}else if (i>=RGBLED_NUM/2 && !pos){
rgblight_sethsv_at(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, i);
}else{
rgblight_sethsv_at(rgblight_config.hue, rgblight_config.sat, 0, i);
}
if(i<RGBLED_NUM/2 && pos){
sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
}else if (i>=RGBLED_NUM/2 && !pos){
sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
}else{
sethsv(rgblight_config.hue, rgblight_config.sat, 0, (LED_TYPE *)&led[i]);
}
}
rgblight_set();
pos = (pos + 1) % 2;
}
#endif /* RGBLIGHT_ANIMATIONS */
#endif

147
quantum/rgblight.h
View file

@ -16,11 +16,69 @@
#ifndef RGBLIGHT_H
#define RGBLIGHT_H
#ifdef RGBLIGHT_ANIMATIONS
#define RGBLIGHT_MODES 36
#else
#define RGBLIGHT_MODES 1
#endif
#include "rgblight_reconfig.h"
/***** rgblight_mode(mode)/rgblight_mode_noeeprom(mode) ****
old mode number (before 0.6.117) to new mode name table
|-----------------|-----------------------------------|
| old mode number | new mode name |
|-----------------|-----------------------------------|
| 1 | RGBLIGHT_MODE_STATIC_LIGHT |
| 2 | RGBLIGHT_MODE_BREATHING |
| 3 | RGBLIGHT_MODE_BREATHING + 1 |
| 4 | RGBLIGHT_MODE_BREATHING + 2 |
| 5 | RGBLIGHT_MODE_BREATHING + 3 |
| 6 | RGBLIGHT_MODE_RAINBOW_MOOD |
| 7 | RGBLIGHT_MODE_RAINBOW_MOOD + 1 |
| 8 | RGBLIGHT_MODE_RAINBOW_MOOD + 2 |
| 9 | RGBLIGHT_MODE_RAINBOW_SWIRL |
| 10 | RGBLIGHT_MODE_RAINBOW_SWIRL + 1 |
| 11 | RGBLIGHT_MODE_RAINBOW_SWIRL + 2 |
| 12 | RGBLIGHT_MODE_RAINBOW_SWIRL + 3 |
| 13 | RGBLIGHT_MODE_RAINBOW_SWIRL + 4 |
| 14 | RGBLIGHT_MODE_RAINBOW_SWIRL + 5 |
| 15 | RGBLIGHT_MODE_SNAKE |
| 16 | RGBLIGHT_MODE_SNAKE + 1 |
| 17 | RGBLIGHT_MODE_SNAKE + 2 |
| 18 | RGBLIGHT_MODE_SNAKE + 3 |
| 19 | RGBLIGHT_MODE_SNAKE + 4 |
| 20 | RGBLIGHT_MODE_SNAKE + 5 |
| 21 | RGBLIGHT_MODE_KNIGHT |
| 22 | RGBLIGHT_MODE_KNIGHT + 1 |
| 23 | RGBLIGHT_MODE_KNIGHT + 2 |
| 24 | RGBLIGHT_MODE_CHRISTMAS |
| 25 | RGBLIGHT_MODE_STATIC_GRADIENT |
| 26 | RGBLIGHT_MODE_STATIC_GRADIENT + 1 |
| 27 | RGBLIGHT_MODE_STATIC_GRADIENT + 2 |
| 28 | RGBLIGHT_MODE_STATIC_GRADIENT + 3 |
| 29 | RGBLIGHT_MODE_STATIC_GRADIENT + 4 |
| 30 | RGBLIGHT_MODE_STATIC_GRADIENT + 5 |
| 31 | RGBLIGHT_MODE_STATIC_GRADIENT + 6 |
| 32 | RGBLIGHT_MODE_STATIC_GRADIENT + 7 |
| 33 | RGBLIGHT_MODE_STATIC_GRADIENT + 8 |
| 34 | RGBLIGHT_MODE_STATIC_GRADIENT + 9 |
| 35 | RGBLIGHT_MODE_RGB_TEST |
| 36 | RGBLIGHT_MODE_ALTERNATING |
|-----------------|-----------------------------------|
*****/
#define _RGBM_SINGLE_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_SINGLE_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_MULTI_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_TMP_STATIC(sym) RGBLIGHT_MODE_ ## sym,
#define _RGBM_TMP_DYNAMIC(sym) RGBLIGHT_MODE_ ## sym,
enum RGBLIGHT_EFFECT_MODE {
RGBLIGHT_MODE_zero = 0,
#include "rgblight.h"
RGBLIGHT_MODE_last
};
#ifndef RGBLIGHT_H_DUMMY_DEFINE
#define RGBLIGHT_MODES (RGBLIGHT_MODE_last-1)
#ifndef RGBLIGHT_EFFECT_BREATHE_CENTER
#define RGBLIGHT_EFFECT_BREATHE_CENTER 1.85 // 1-2.7
@ -109,7 +167,7 @@ void rgblight_enable(void);
void rgblight_disable(void);
void rgblight_step(void);
void rgblight_step_reverse(void);
uint32_t rgblight_get_mode(void);
uint8_t rgblight_get_mode(void);
void rgblight_mode(uint8_t mode);
void rgblight_set(void);
void rgblight_update_dword(uint32_t dword);
@ -145,6 +203,14 @@ void rgblight_mode_noeeprom(uint8_t mode);
void rgblight_toggle_noeeprom(void);
void rgblight_enable_noeeprom(void);
void rgblight_disable_noeeprom(void);
void rgblight_step_noeeprom(void);
void rgblight_step_reverse_noeeprom(void);
void rgblight_increase_hue_noeeprom(void);
void rgblight_decrease_hue_noeeprom(void);
void rgblight_increase_sat_noeeprom(void);
void rgblight_decrease_sat_noeeprom(void);
void rgblight_increase_val_noeeprom(void);
void rgblight_decrease_val_noeeprom(void);
void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom);
void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom);
@ -168,4 +234,73 @@ void rgblight_effect_christmas(void);
void rgblight_effect_rgbtest(void);
void rgblight_effect_alternating(void);
#endif // #ifndef RGBLIGHT_H_DUMMY_DEFINE
#endif // RGBLIGHT_H
#ifdef _RGBM_SINGLE_STATIC
_RGBM_SINGLE_STATIC( STATIC_LIGHT )
#ifdef RGBLIGHT_EFFECT_BREATHING
_RGBM_MULTI_DYNAMIC( BREATHING )
_RGBM_TMP_DYNAMIC( breathing_3 )
_RGBM_TMP_DYNAMIC( breathing_4 )
_RGBM_TMP_DYNAMIC( BREATHING_end )
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
_RGBM_MULTI_DYNAMIC( RAINBOW_MOOD )
_RGBM_TMP_DYNAMIC( rainbow_mood_7 )
_RGBM_TMP_DYNAMIC( RAINBOW_MOOD_end )
#endif
#ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
_RGBM_MULTI_DYNAMIC( RAINBOW_SWIRL )
_RGBM_TMP_DYNAMIC( rainbow_swirl_10 )
_RGBM_TMP_DYNAMIC( rainbow_swirl_11 )
_RGBM_TMP_DYNAMIC( rainbow_swirl_12 )
_RGBM_TMP_DYNAMIC( rainbow_swirl_13 )
_RGBM_TMP_DYNAMIC( RAINBOW_SWIRL_end )
#endif
#ifdef RGBLIGHT_EFFECT_SNAKE
_RGBM_MULTI_DYNAMIC( SNAKE )
_RGBM_TMP_DYNAMIC( snake_16 )
_RGBM_TMP_DYNAMIC( snake_17 )
_RGBM_TMP_DYNAMIC( snake_18 )
_RGBM_TMP_DYNAMIC( snake_19 )
_RGBM_TMP_DYNAMIC( SNAKE_end )
#endif
#ifdef RGBLIGHT_EFFECT_KNIGHT
_RGBM_MULTI_DYNAMIC( KNIGHT )
_RGBM_TMP_DYNAMIC( knight_22 )
_RGBM_TMP_DYNAMIC( KNIGHT_end )
#endif
#ifdef RGBLIGHT_EFFECT_CHRISTMAS
_RGBM_SINGLE_DYNAMIC( CHRISTMAS )
#endif
#ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
_RGBM_MULTI_STATIC( STATIC_GRADIENT )
_RGBM_TMP_STATIC( static_gradient_26 )
_RGBM_TMP_STATIC( static_gradient_27 )
_RGBM_TMP_STATIC( static_gradient_28 )
_RGBM_TMP_STATIC( static_gradient_29 )
_RGBM_TMP_STATIC( static_gradient_30 )
_RGBM_TMP_STATIC( static_gradient_31 )
_RGBM_TMP_STATIC( static_gradient_32 )
_RGBM_TMP_STATIC( static_gradient_33 )
_RGBM_TMP_STATIC( STATIC_GRADIENT_end )
#endif
#ifdef RGBLIGHT_EFFECT_RGB_TEST
_RGBM_SINGLE_DYNAMIC( RGB_TEST )
#endif
#ifdef RGBLIGHT_EFFECT_ALTERNATING
_RGBM_SINGLE_DYNAMIC( ALTERNATING )
#endif
//// Add a new mode here.
// #ifdef RGBLIGHT_EFFECT_<name>
// _RGBM_<SINGLE|MULTI>_<STATIC|DYNAMIC>( <name> )
// #endif
#endif
#undef _RGBM_SINGLE_STATIC
#undef _RGBM_SINGLE_DYNAMIC
#undef _RGBM_MULTI_STATIC
#undef _RGBM_MULTI_DYNAMIC
#undef _RGBM_TMP_STATIC
#undef _RGBM_TMP_DYNAMIC

36
quantum/rgblight_reconfig.h Normal file
View file

@ -0,0 +1,36 @@
#ifndef RGBLIGHT_RECONFIG_H
#define RGBLIGHT_RECONFIG_H
#ifdef RGBLIGHT_ANIMATIONS
// for backward compatibility
#define RGBLIGHT_EFFECT_BREATHING
#define RGBLIGHT_EFFECT_RAINBOW_MOOD
#define RGBLIGHT_EFFECT_RAINBOW_SWIRL
#define RGBLIGHT_EFFECT_SNAKE
#define RGBLIGHT_EFFECT_KNIGHT
#define RGBLIGHT_EFFECT_CHRISTMAS
#define RGBLIGHT_EFFECT_STATIC_GRADIENT
#define RGBLIGHT_EFFECT_RGB_TEST
#define RGBLIGHT_EFFECT_ALTERNATING
#endif
#ifdef RGBLIGHT_STATIC_PATTERNS
#define RGBLIGHT_EFFECT_STATIC_GRADIENT
#endif
// check dynamic animation effects chose ?
#if defined(RGBLIGHT_EFFECT_BREATHING) || \
defined(RGBLIGHT_EFFECT_RAINBOW_MOOD) || \
defined(RGBLIGHT_EFFECT_RAINBOW_SWIRL) || \
defined(RGBLIGHT_EFFECT_SNAKE) || \
defined(RGBLIGHT_EFFECT_KNIGHT) || \
defined(RGBLIGHT_EFFECT_CHRISTMAS) || \
defined(RGBLIGHT_EFFECT_RGB_TEST) || \
defined(RGBLIGHT_EFFECT_ALTERNATING)
#define RGBLIGHT_USE_TIMER
#ifndef RGBLIGHT_ANIMATIONS
#define RGBLIGHT_ANIMATIONS // for backward compatibility
#endif
#endif
#endif // RGBLIGHT_RECONFIG_H

3
quantum/split_common/i2c.c
View file

@ -7,8 +7,6 @@
#include "i2c.h"
#include "split_flags.h"
#if defined(USE_I2C) || defined(EH)
// Limits the amount of we wait for any one i2c transaction.
// Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is
// 9 bits, a single transaction will take around 90μs to complete.
@ -184,4 +182,3 @@ ISR(TWI_vect) {
// Reset everything, so we are ready for the next TWI interrupt
TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN);
}
#endif

162
quantum/split_common/matrix.c
View file

@ -20,21 +20,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdbool.h>
#include <avr/io.h>
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h"
#include "split_util.h"
#include "pro_micro.h"
#include "config.h"
#include "timer.h"
#include "split_flags.h"
#include "quantum.h"
#ifdef RGBLIGHT_ENABLE
# include "rgblight.h"
#endif
#ifdef BACKLIGHT_ENABLE
# include "backlight.h"
extern backlight_config_t backlight_config;
@ -55,6 +49,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
static bool debouncing = false;
#endif
#if defined(USE_I2C) || defined(EH)
#if (MATRIX_COLS <= 8)
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
@ -62,6 +58,27 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
# define ROW_SHIFTER ((uint8_t)1)
#else
# error "Currently only supports 8 COLS"
#endif
#else // USE_SERIAL
#if (MATRIX_COLS <= 8)
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
#endif
static matrix_row_t matrix_debouncing[MATRIX_ROWS];
@ -71,8 +88,8 @@ static matrix_row_t matrix_debouncing[MATRIX_ROWS];
static uint8_t error_count = 0;
static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
@ -128,15 +145,24 @@ uint8_t matrix_cols(void)
void matrix_init(void)
{
#ifdef DISABLE_JTAG
// JTAG disable for PORT F. write JTD bit twice within four cycles.
MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD);
#endif
debug_enable = true;
debug_matrix = true;
debug_mouse = true;
// Set pinout for right half if pinout for that half is defined
if (!isLeftHand) {
#ifdef MATRIX_ROW_PINS_RIGHT
const uint8_t row_pins_right[MATRIX_ROWS] = MATRIX_ROW_PINS_RIGHT;
for (uint8_t i = 0; i < MATRIX_ROWS; i++)
row_pins[i] = row_pins_right[i];
#endif
#ifdef MATRIX_COL_PINS_RIGHT
const uint8_t col_pins_right[MATRIX_COLS] = MATRIX_COL_PINS_RIGHT;
for (uint8_t i = 0; i < MATRIX_COLS; i++)
col_pins[i] = col_pins_right[i];
#endif
}
// initialize row and col
#if (DIODE_DIRECTION == COL2ROW)
unselect_rows();
@ -277,24 +303,48 @@ i2c_error: // the cable is disconnceted, or something else went wrong
#else // USE_SERIAL
typedef struct _Serial_s2m_buffer_t {
// TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
matrix_row_t smatrix[ROWS_PER_HAND];
} Serial_s2m_buffer_t;
volatile Serial_s2m_buffer_t serial_s2m_buffer = {};
volatile Serial_m2s_buffer_t serial_m2s_buffer = {};
uint8_t volatile status0 = 0;
SSTD_t transactions[] = {
{ (uint8_t *)&status0,
sizeof(serial_m2s_buffer), (uint8_t *)&serial_m2s_buffer,
sizeof(serial_s2m_buffer), (uint8_t *)&serial_s2m_buffer
}
};
void serial_master_init(void)
{ soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
void serial_slave_init(void)
{ soft_serial_target_init(transactions, TID_LIMIT(transactions)); }
int serial_transaction(void) {
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
if (serial_update_buffers()) {
if (soft_serial_transaction()) {
return 1;
}
// TODO: if MATRIX_COLS > 8 change to unpack()
for (int i = 0; i < ROWS_PER_HAND; ++i) {
matrix[slaveOffset+i] = serial_slave_buffer[i];
matrix[slaveOffset+i] = serial_s2m_buffer.smatrix[i];
}
#ifdef RGBLIGHT_ENABLE
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
// Code to send RGB over serial goes here (not implemented yet)
#endif
#ifdef BACKLIGHT_ENABLE
// Write backlight level for slave to read
serial_master_buffer[SERIAL_BACKLIT_START] = backlight_config.enable ? backlight_config.level : 0;
serial_m2s_buffer.backlight_level = backlight_config.enable ? backlight_config.level : 0;
#endif
return 0;
@ -337,27 +387,10 @@ void matrix_slave_scan(void) {
i2c_slave_buffer[I2C_KEYMAP_START+i] = matrix[offset+i];
}
#else // USE_SERIAL
// TODO: if MATRIX_COLS > 8 change to pack()
for (int i = 0; i < ROWS_PER_HAND; ++i) {
serial_slave_buffer[i] = matrix[offset+i];
serial_s2m_buffer.smatrix[i] = matrix[offset+i];
}
#endif
#ifdef USE_I2C
#ifdef BACKLIGHT_ENABLE
// Read backlight level sent from master and update level on slave
backlight_set(i2c_slave_buffer[0]);
#endif
for (int i = 0; i < ROWS_PER_HAND; ++i) {
i2c_slave_buffer[i+1] = matrix[offset+i];
}
#else // USE_SERIAL
for (int i = 0; i < ROWS_PER_HAND; ++i) {
serial_slave_buffer[i] = matrix[offset+i];
}
#ifdef BACKLIGHT_ENABLE
// Read backlight level sent from master and update level on slave
backlight_set(serial_master_buffer[SERIAL_BACKLIT_START]);
#endif
#endif
matrix_slave_scan_user();
}
@ -404,9 +437,7 @@ uint8_t matrix_key_count(void)
static void init_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
uint8_t pin = col_pins[x];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInputHigh(col_pins[x]);
}
}
@ -424,13 +455,8 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
uint8_t pin = col_pins[col_index];
uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
current_matrix[current_row] |= readPin(col_pins[col_index]) ? 0 : (ROW_SHIFTER << col_index);
}
// Unselect row
@ -441,24 +467,19 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
static void select_row(uint8_t row)
{
uint8_t pin = row_pins[row];
_SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
_SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
writePinLow(row_pins[row]);
setPinOutput(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
uint8_t pin = row_pins[row];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInputHigh(row_pins[row]);
}
static void unselect_rows(void)
{
for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
uint8_t pin = row_pins[x];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInputHigh(row_pins[x]);
}
}
@ -467,9 +488,7 @@ static void unselect_rows(void)
static void init_rows(void)
{
for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
uint8_t pin = row_pins[x];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInputHigh(row_pins[x]);
}
}
@ -489,16 +508,16 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
{
// Pin LO, set col bit
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
}
else
if (readPin(row_pins[row_index]))
{
// Pin HI, clear col bit
current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
}
else
{
// Pin LO, set col bit
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
}
// Determine if the matrix changed state
if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
@ -515,24 +534,19 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
static void select_col(uint8_t col)
{
uint8_t pin = col_pins[col];
_SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
_SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
writePinLow(col_pins[col]);
setPinOutput(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
uint8_t pin = col_pins[col];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInputHigh(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
uint8_t pin = col_pins[x];
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
setPinInputHigh(col_pins[x]);
}
}

31
quantum/split_common/matrix.h Normal file
View file

@ -0,0 +1,31 @@
#ifndef SPLIT_COMMON_MATRIX_H
#define SPLIT_COMMON_MATRIX_H
#include <common/matrix.h>
#ifdef RGBLIGHT_ENABLE
# include "rgblight.h"
#endif
typedef struct _Serial_m2s_buffer_t {
#ifdef BACKLIGHT_ENABLE
uint8_t backlight_level;
#endif
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
rgblight_config_t rgblight_config; //not yet use
//
// When MCUs on both sides drive their respective RGB LED chains,
// it is necessary to synchronize, so it is necessary to communicate RGB information.
// In that case, define the RGBLIGHT_SPLIT macro.
//
// Otherwise, if the master side MCU drives both sides RGB LED chains,
// there is no need to communicate.
#endif
} Serial_m2s_buffer_t;
extern volatile Serial_m2s_buffer_t serial_m2s_buffer;
void serial_master_init(void);
void serial_slave_init(void);
#endif

552
quantum/split_common/serial.c
View file

@ -1,5 +1,10 @@
/*
* WARNING: be careful changing this code, it is very timing dependent
*
* 2018-10-28 checked
* avr-gcc 4.9.2
* avr-gcc 5.4.0
* avr-gcc 7.3.0
*/
#ifndef F_CPU
@ -9,220 +14,533 @@
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stddef.h>
#include <stdbool.h>
#include "serial.h"
//#include <pro_micro.h>
#ifndef USE_I2C
#ifdef SOFT_SERIAL_PIN
// Serial pulse period in microseconds. Its probably a bad idea to lower this
// value.
#define SERIAL_DELAY 24
#ifdef __AVR_ATmega32U4__
// if using ATmega32U4 I2C, can not use PD0 and PD1 in soft serial.
#ifdef USE_AVR_I2C
#if SOFT_SERIAL_PIN == D0 || SOFT_SERIAL_PIN == D1
#error Using ATmega32U4 I2C, so can not use PD0, PD1
#endif
#endif
uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
#if SOFT_SERIAL_PIN >= D0 && SOFT_SERIAL_PIN <= D3
#define SERIAL_PIN_DDR DDRD
#define SERIAL_PIN_PORT PORTD
#define SERIAL_PIN_INPUT PIND
#if SOFT_SERIAL_PIN == D0
#define SERIAL_PIN_MASK _BV(PD0)
#define EIMSK_BIT _BV(INT0)
#define EICRx_BIT (~(_BV(ISC00) | _BV(ISC01)))
#define SERIAL_PIN_INTERRUPT INT0_vect
#elif SOFT_SERIAL_PIN == D1
#define SERIAL_PIN_MASK _BV(PD1)
#define EIMSK_BIT _BV(INT1)
#define EICRx_BIT (~(_BV(ISC10) | _BV(ISC11)))
#define SERIAL_PIN_INTERRUPT INT1_vect
#elif SOFT_SERIAL_PIN == D2
#define SERIAL_PIN_MASK _BV(PD2)
#define EIMSK_BIT _BV(INT2)
#define EICRx_BIT (~(_BV(ISC20) | _BV(ISC21)))
#define SERIAL_PIN_INTERRUPT INT2_vect
#elif SOFT_SERIAL_PIN == D3
#define SERIAL_PIN_MASK _BV(PD3)
#define EIMSK_BIT _BV(INT3)
#define EICRx_BIT (~(_BV(ISC30) | _BV(ISC31)))
#define SERIAL_PIN_INTERRUPT INT3_vect
#endif
#elif SOFT_SERIAL_PIN == E6
#define SERIAL_PIN_DDR DDRE
#define SERIAL_PIN_PORT PORTE
#define SERIAL_PIN_INPUT PINE
#define SERIAL_PIN_MASK _BV(PE6)
#define EIMSK_BIT _BV(INT6)
#define EICRx_BIT (~(_BV(ISC60) | _BV(ISC61)))
#define SERIAL_PIN_INTERRUPT INT6_vect
#else
#error invalid SOFT_SERIAL_PIN value
#endif
#define SLAVE_DATA_CORRUPT (1<<0)
volatile uint8_t status = 0;
#else
#error serial.c now support ATmega32U4 only
#endif
#define ALWAYS_INLINE __attribute__((always_inline))
#define NO_INLINE __attribute__((noinline))
#define _delay_sub_us(x) __builtin_avr_delay_cycles(x)
// parity check
#define ODD_PARITY 1
#define EVEN_PARITY 0
#define PARITY EVEN_PARITY
#ifdef SERIAL_DELAY
// custom setup in config.h
// #define TID_SEND_ADJUST 2
// #define SERIAL_DELAY 6 // micro sec
// #define READ_WRITE_START_ADJUST 30 // cycles
// #define READ_WRITE_WIDTH_ADJUST 8 // cycles
#else
// ============ Standard setups ============
#ifndef SELECT_SOFT_SERIAL_SPEED
#define SELECT_SOFT_SERIAL_SPEED 1
// 0: about 189kbps (Experimental only)
// 1: about 137kbps (default)
// 2: about 75kbps
// 3: about 39kbps
// 4: about 26kbps
// 5: about 20kbps
#endif
#if __GNUC__ < 6
#define TID_SEND_ADJUST 14
#else
#define TID_SEND_ADJUST 2
#endif
#if SELECT_SOFT_SERIAL_SPEED == 0
// Very High speed
#define SERIAL_DELAY 4 // micro sec
#if __GNUC__ < 6
#define READ_WRITE_START_ADJUST 33 // cycles
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_START_ADJUST 34 // cycles
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#elif SELECT_SOFT_SERIAL_SPEED == 1
// High speed
#define SERIAL_DELAY 6 // micro sec
#if __GNUC__ < 6
#define READ_WRITE_START_ADJUST 30 // cycles
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_START_ADJUST 33 // cycles
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#elif SELECT_SOFT_SERIAL_SPEED == 2
// Middle speed
#define SERIAL_DELAY 12 // micro sec
#define READ_WRITE_START_ADJUST 30 // cycles
#if __GNUC__ < 6
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#elif SELECT_SOFT_SERIAL_SPEED == 3
// Low speed
#define SERIAL_DELAY 24 // micro sec
#define READ_WRITE_START_ADJUST 30 // cycles
#if __GNUC__ < 6
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#elif SELECT_SOFT_SERIAL_SPEED == 4
// Very Low speed
#define SERIAL_DELAY 36 // micro sec
#define READ_WRITE_START_ADJUST 30 // cycles
#if __GNUC__ < 6
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#elif SELECT_SOFT_SERIAL_SPEED == 5
// Ultra Low speed
#define SERIAL_DELAY 48 // micro sec
#define READ_WRITE_START_ADJUST 30 // cycles
#if __GNUC__ < 6
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
#else
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
#endif
#else
#error invalid SELECT_SOFT_SERIAL_SPEED value
#endif /* SELECT_SOFT_SERIAL_SPEED */
#endif /* SERIAL_DELAY */
#define SERIAL_DELAY_HALF1 (SERIAL_DELAY/2)
#define SERIAL_DELAY_HALF2 (SERIAL_DELAY - SERIAL_DELAY/2)
#define SLAVE_INT_WIDTH_US 1
#ifndef SERIAL_USE_MULTI_TRANSACTION
#define SLAVE_INT_RESPONSE_TIME SERIAL_DELAY
#else
#define SLAVE_INT_ACK_WIDTH_UNIT 2
#define SLAVE_INT_ACK_WIDTH 4
#endif
static SSTD_t *Transaction_table = NULL;
static uint8_t Transaction_table_size = 0;
inline static void serial_delay(void) ALWAYS_INLINE;
inline static
void serial_delay(void) {
_delay_us(SERIAL_DELAY);
}
inline static void serial_delay_half1(void) ALWAYS_INLINE;
inline static
void serial_delay_half1(void) {
_delay_us(SERIAL_DELAY_HALF1);
}
inline static void serial_delay_half2(void) ALWAYS_INLINE;
inline static
void serial_delay_half2(void) {
_delay_us(SERIAL_DELAY_HALF2);
}
inline static void serial_output(void) ALWAYS_INLINE;
inline static
void serial_output(void) {
SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
}
// make the serial pin an input with pull-up resistor
inline static void serial_input_with_pullup(void) ALWAYS_INLINE;
inline static
void serial_input(void) {
void serial_input_with_pullup(void) {
SERIAL_PIN_DDR &= ~SERIAL_PIN_MASK;
SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
}
inline static uint8_t serial_read_pin(void) ALWAYS_INLINE;
inline static
uint8_t serial_read_pin(void) {
return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
}
inline static void serial_low(void) ALWAYS_INLINE;
inline static
void serial_low(void) {
SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
}
inline static void serial_high(void) ALWAYS_INLINE;
inline static
void serial_high(void) {
SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
}
void serial_master_init(void) {
serial_output();
serial_high();
void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size)
{
Transaction_table = sstd_table;
Transaction_table_size = (uint8_t)sstd_table_size;
serial_output();
serial_high();
}
void serial_slave_init(void) {
serial_input();
void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size)
{
Transaction_table = sstd_table;
Transaction_table_size = (uint8_t)sstd_table_size;
serial_input_with_pullup();
// Enable INT0
EIMSK |= _BV(INT0);
// Trigger on falling edge of INT0
EICRA &= ~(_BV(ISC00) | _BV(ISC01));
// Enable INT0-INT3,INT6
EIMSK |= EIMSK_BIT;
#if SERIAL_PIN_MASK == _BV(PE6)
// Trigger on falling edge of INT6
EICRB &= EICRx_BIT;
#else
// Trigger on falling edge of INT0-INT3
EICRA &= EICRx_BIT;
#endif
}
// Used by the master to synchronize timing with the slave.
// Used by the sender to synchronize timing with the reciver.
static void sync_recv(void) NO_INLINE;
static
void sync_recv(void) {
serial_input();
// This shouldn't hang if the slave disconnects because the
// serial line will float to high if the slave does disconnect.
for (uint8_t i = 0; i < SERIAL_DELAY*5 && serial_read_pin(); i++ ) {
}
// This shouldn't hang if the target disconnects because the
// serial line will float to high if the target does disconnect.
while (!serial_read_pin());
serial_delay();
}
// Used by the slave to send a synchronization signal to the master.
// Used by the reciver to send a synchronization signal to the sender.
static void sync_send(void) NO_INLINE;
static
void sync_send(void) {
serial_output();
serial_low();
serial_delay();
serial_high();
}
// Reads a byte from the serial line
static
uint8_t serial_read_byte(void) {
uint8_t byte = 0;
serial_input();
for ( uint8_t i = 0; i < 8; ++i) {
byte = (byte << 1) | serial_read_pin();
serial_delay();
_delay_us(1);
static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) NO_INLINE;
static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) {
uint8_t byte, i, p, pb;
_delay_sub_us(READ_WRITE_START_ADJUST);
for( i = 0, byte = 0, p = PARITY; i < bit; i++ ) {
serial_delay_half1(); // read the middle of pulses
if( serial_read_pin() ) {
byte = (byte << 1) | 1; p ^= 1;
} else {
byte = (byte << 1) | 0; p ^= 0;
}
_delay_sub_us(READ_WRITE_WIDTH_ADJUST);
serial_delay_half2();
}
/* recive parity bit */
serial_delay_half1(); // read the middle of pulses
pb = serial_read_pin();
_delay_sub_us(READ_WRITE_WIDTH_ADJUST);
serial_delay_half2();
*pterrcount += (p != pb)? 1 : 0;
return byte;
}
// Sends a byte with MSB ordering
static
void serial_write_byte(uint8_t data) {
uint8_t b = 8;
serial_output();
while( b-- ) {
if(data & (1 << b)) {
serial_high();
} else {
serial_low();
void serial_write_chunk(uint8_t data, uint8_t bit) NO_INLINE;
void serial_write_chunk(uint8_t data, uint8_t bit) {
uint8_t b, p;
for( p = PARITY, b = 1<<(bit-1); b ; b >>= 1) {
if(data & b) {
serial_high(); p ^= 1;
} else {
serial_low(); p ^= 0;
}
serial_delay();
}
/* send parity bit */
if(p & 1) { serial_high(); }
else { serial_low(); }
serial_delay();
serial_low(); // sync_send() / senc_recv() need raise edge
}
static void serial_send_packet(uint8_t *buffer, uint8_t size) NO_INLINE;
static
void serial_send_packet(uint8_t *buffer, uint8_t size) {
for (uint8_t i = 0; i < size; ++i) {
uint8_t data;
data = buffer[i];
sync_send();
serial_write_chunk(data,8);
}
}
// interrupt handle to be used by the slave device
static uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) NO_INLINE;
static
uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) {
uint8_t pecount = 0;
for (uint8_t i = 0; i < size; ++i) {
uint8_t data;
sync_recv();
data = serial_read_chunk(&pecount, 8);
buffer[i] = data;
}
return pecount == 0;
}
inline static
void change_sender2reciver(void) {
sync_send(); //0
serial_delay_half1(); //1
serial_low(); //2
serial_input_with_pullup(); //2
serial_delay_half1(); //3
}
inline static
void change_reciver2sender(void) {
sync_recv(); //0
serial_delay(); //1
serial_low(); //3
serial_output(); //3
serial_delay_half1(); //4
}
static inline uint8_t nibble_bits_count(uint8_t bits)
{
bits = (bits & 0x5) + (bits >> 1 & 0x5);
bits = (bits & 0x3) + (bits >> 2 & 0x3);
return bits;
}
// interrupt handle to be used by the target device
ISR(SERIAL_PIN_INTERRUPT) {
sync_send();
uint8_t checksum = 0;
for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
serial_write_byte(serial_slave_buffer[i]);
sync_send();
checksum += serial_slave_buffer[i];
#ifndef SERIAL_USE_MULTI_TRANSACTION
serial_low();
serial_output();
SSTD_t *trans = Transaction_table;
#else
// recive transaction table index
uint8_t tid, bits;
uint8_t pecount = 0;
sync_recv();
bits = serial_read_chunk(&pecount,7);
tid = bits>>3;
bits = (bits&7) != nibble_bits_count(tid);
if( bits || pecount> 0 || tid > Transaction_table_size ) {
return;
}
serial_write_byte(checksum);
sync_send();
serial_delay_half1();
// wait for the sync to finish sending
serial_delay();
serial_high(); // response step1 low->high
serial_output();
_delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT*SLAVE_INT_ACK_WIDTH);
SSTD_t *trans = &Transaction_table[tid];
serial_low(); // response step2 ack high->low
#endif
// read the middle of pulses
_delay_us(SERIAL_DELAY/2);
// target send phase
if( trans->target2initiator_buffer_size > 0 )
serial_send_packet((uint8_t *)trans->target2initiator_buffer,
trans->target2initiator_buffer_size);
// target switch to input
change_sender2reciver();
uint8_t checksum_computed = 0;
for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
serial_master_buffer[i] = serial_read_byte();
sync_send();
checksum_computed += serial_master_buffer[i];
}
uint8_t checksum_received = serial_read_byte();
sync_send();
serial_input(); // end transaction
if ( checksum_computed != checksum_received ) {
status |= SLAVE_DATA_CORRUPT;
// target recive phase
if( trans->initiator2target_buffer_size > 0 ) {
if (serial_recive_packet((uint8_t *)trans->initiator2target_buffer,
trans->initiator2target_buffer_size) ) {
*trans->status = TRANSACTION_ACCEPTED;
} else {
*trans->status = TRANSACTION_DATA_ERROR;
}
} else {
status &= ~SLAVE_DATA_CORRUPT;
*trans->status = TRANSACTION_ACCEPTED;
}
sync_recv(); //weit initiator output to high
}
inline
bool serial_slave_DATA_CORRUPT(void) {
return status & SLAVE_DATA_CORRUPT;
}
// Copies the serial_slave_buffer to the master and sends the
// serial_master_buffer to the slave.
/////////
// start transaction by initiator
//
// int soft_serial_transaction(int sstd_index)
//
// Returns:
// 0 => no error
// 1 => slave did not respond
int serial_update_buffers(void) {
// this code is very time dependent, so we need to disable interrupts
// TRANSACTION_END
// TRANSACTION_NO_RESPONSE
// TRANSACTION_DATA_ERROR
// this code is very time dependent, so we need to disable interrupts
#ifndef SERIAL_USE_MULTI_TRANSACTION
int soft_serial_transaction(void) {
SSTD_t *trans = Transaction_table;
#else
int soft_serial_transaction(int sstd_index) {
if( sstd_index > Transaction_table_size )
return TRANSACTION_TYPE_ERROR;
SSTD_t *trans = &Transaction_table[sstd_index];
#endif
cli();
// signal to the slave that we want to start a transaction
// signal to the target that we want to start a transaction
serial_output();
serial_low();
_delay_us(1);
_delay_us(SLAVE_INT_WIDTH_US);
// wait for the slaves response
serial_input();
serial_high();
_delay_us(SERIAL_DELAY);
#ifndef SERIAL_USE_MULTI_TRANSACTION
// wait for the target response
serial_input_with_pullup();
_delay_us(SLAVE_INT_RESPONSE_TIME);
// check if the slave is present
// check if the target is present
if (serial_read_pin()) {
// slave failed to pull the line low, assume not present
// target failed to pull the line low, assume not present
serial_output();
serial_high();
*trans->status = TRANSACTION_NO_RESPONSE;
sei();
return 1;
return TRANSACTION_NO_RESPONSE;
}
// if the slave is present syncronize with it
sync_recv();
#else
// send transaction table index
int tid = (sstd_index<<3) | (7 & nibble_bits_count(sstd_index));
sync_send();
_delay_sub_us(TID_SEND_ADJUST);
serial_write_chunk(tid, 7);
serial_delay_half1();
uint8_t checksum_computed = 0;
// receive data from the slave
for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
serial_slave_buffer[i] = serial_read_byte();
sync_recv();
checksum_computed += serial_slave_buffer[i];
}
uint8_t checksum_received = serial_read_byte();
sync_recv();
if (checksum_computed != checksum_received) {
sei();
return 1;
// wait for the target response (step1 low->high)
serial_input_with_pullup();
while( !serial_read_pin() ) {
_delay_sub_us(2);
}
uint8_t checksum = 0;
// send data to the slave
for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
serial_write_byte(serial_master_buffer[i]);
sync_recv();
checksum += serial_master_buffer[i];
// check if the target is present (step2 high->low)
for( int i = 0; serial_read_pin(); i++ ) {
if (i > SLAVE_INT_ACK_WIDTH + 1) {
// slave failed to pull the line low, assume not present
serial_output();
serial_high();
*trans->status = TRANSACTION_NO_RESPONSE;
sei();
return TRANSACTION_NO_RESPONSE;
}
_delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT);
}
#endif
// initiator recive phase
// if the target is present syncronize with it
if( trans->target2initiator_buffer_size > 0 ) {
if (!serial_recive_packet((uint8_t *)trans->target2initiator_buffer,
trans->target2initiator_buffer_size) ) {
serial_output();
serial_high();
*trans->status = TRANSACTION_DATA_ERROR;
sei();
return TRANSACTION_DATA_ERROR;
}
}
// initiator switch to output
change_reciver2sender();
// initiator send phase
if( trans->initiator2target_buffer_size > 0 ) {
serial_send_packet((uint8_t *)trans->initiator2target_buffer,
trans->initiator2target_buffer_size);
}
serial_write_byte(checksum);
sync_recv();
// always, release the line when not in use
serial_output();
serial_high();
sync_send();
*trans->status = TRANSACTION_END;
sei();
return 0;
return TRANSACTION_END;
}
#ifdef SERIAL_USE_MULTI_TRANSACTION
int soft_serial_get_and_clean_status(int sstd_index) {
SSTD_t *trans = &Transaction_table[sstd_index];
cli();
int retval = *trans->status;
*trans->status = 0;;
sei();
return retval;
}
#endif
#endif
// Helix serial.c history
// 2018-1-29 fork from let's split and add PD2, modify sync_recv() (#2308, bceffdefc)
// 2018-6-28 bug fix master to slave comm and speed up (#3255, 1038bbef4)
// (adjusted with avr-gcc 4.9.2)
// 2018-7-13 remove USE_SERIAL_PD2 macro (#3374, f30d6dd78)
// (adjusted with avr-gcc 4.9.2)
// 2018-8-11 add support multi-type transaction (#3608, feb5e4aae)
// (adjusted with avr-gcc 4.9.2)
// 2018-10-21 fix serial and RGB animation conflict (#4191, 4665e4fff)
// (adjusted with avr-gcc 7.3.0)
// 2018-10-28 re-adjust compiler depend value of delay (#4269, 8517f8a66)
// (adjusted with avr-gcc 5.4.0, 7.3.0)
// 2018-12-17 copy to TOP/quantum/split_common/ and remove backward compatibility code (#4669)

80
quantum/split_common/serial.h
View file

@ -1,29 +1,65 @@
#ifndef MY_SERIAL_H
#define MY_SERIAL_H
#ifndef SOFT_SERIAL_H
#define SOFT_SERIAL_H
#include "config.h"
#include <stdbool.h>
/* TODO: some defines for interrupt setup */
#define SERIAL_PIN_DDR DDRD
#define SERIAL_PIN_PORT PORTD
#define SERIAL_PIN_INPUT PIND
#define SERIAL_PIN_MASK _BV(PD0)
#define SERIAL_PIN_INTERRUPT INT0_vect
// /////////////////////////////////////////////////////////////////
// Need Soft Serial defines in config.h
// /////////////////////////////////////////////////////////////////
// ex.
// #define SOFT_SERIAL_PIN ?? // ?? = D0,D1,D2,D3,E6
// OPTIONAL: #define SELECT_SOFT_SERIAL_SPEED ? // ? = 1,2,3,4,5
// // 1: about 137kbps (default)
// // 2: about 75kbps
// // 3: about 39kbps
// // 4: about 26kbps
// // 5: about 20kbps
//
// //// USE simple API (using signle-type transaction function)
// /* nothing */
// //// USE flexible API (using multi-type transaction function)
// #define SERIAL_USE_MULTI_TRANSACTION
//
// /////////////////////////////////////////////////////////////////
#define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
#define SERIAL_MASTER_BUFFER_LENGTH 1
// Soft Serial Transaction Descriptor
typedef struct _SSTD_t {
uint8_t *status;
uint8_t initiator2target_buffer_size;
uint8_t *initiator2target_buffer;
uint8_t target2initiator_buffer_size;
uint8_t *target2initiator_buffer;
} SSTD_t;
#define TID_LIMIT( table ) (sizeof(table) / sizeof(SSTD_t))
// Address location defines
#define SERIAL_BACKLIT_START 0x00
// Buffers for master - slave communication
extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
void serial_master_init(void);
void serial_slave_init(void);
int serial_update_buffers(void);
bool serial_slave_data_corrupt(void);
// initiator is transaction start side
void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size);
// target is interrupt accept side
void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size);
// initiator resullt
#define TRANSACTION_END 0
#define TRANSACTION_NO_RESPONSE 0x1
#define TRANSACTION_DATA_ERROR 0x2
#define TRANSACTION_TYPE_ERROR 0x4
#ifndef SERIAL_USE_MULTI_TRANSACTION
int soft_serial_transaction(void);
#else
int soft_serial_transaction(int sstd_index);
#endif
// target status
// *SSTD_t.status has
// initiator:
// TRANSACTION_END
// or TRANSACTION_NO_RESPONSE
// or TRANSACTION_DATA_ERROR
// target:
// TRANSACTION_DATA_ERROR
// or TRANSACTION_ACCEPTED
#define TRANSACTION_ACCEPTED 0x8
#ifdef SERIAL_USE_MULTI_TRANSACTION
int soft_serial_get_and_clean_status(int sstd_index);
#endif
#endif /* SOFT_SERIAL_H */

51
quantum/split_common/split_util.c
View file

@ -1,31 +1,21 @@
#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/eeprom.h>
#include "split_util.h"
#include "matrix.h"
#include "keyboard.h"
#include "config.h"
#include "timer.h"
#include "split_flags.h"
#include "quantum.h"
#ifdef RGBLIGHT_ENABLE
# include "rgblight.h"
#ifdef EE_HANDS
# include "tmk_core/common/eeprom.h"
#endif
#ifdef BACKLIGHT_ENABLE
# include "backlight.h"
#endif
#ifdef SPLIT_HAND_PIN
# include "pincontrol.h"
#endif
#if defined(USE_I2C) || defined(EH)
# include "i2c.h"
#else
# include "serial.h"
#endif
volatile bool isLeftHand = true;
@ -35,14 +25,13 @@ volatile uint8_t setTries = 0;
static void setup_handedness(void) {
#ifdef SPLIT_HAND_PIN
// Test pin SPLIT_HAND_PIN for High/Low, if low it's right hand
pinMode(SPLIT_HAND_PIN, PinDirectionInput);
isLeftHand = digitalRead(SPLIT_HAND_PIN);
setPinInput(SPLIT_HAND_PIN);
isLeftHand = readPin(SPLIT_HAND_PIN);
#else
#ifdef EE_HANDS
isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS);
#else
// I2C_MASTER_RIGHT is deprecated, use MASTER_RIGHT instead, since this works for both serial and i2c
#if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT)
#ifdef MASTER_RIGHT
isLeftHand = !has_usb();
#else
isLeftHand = has_usb();
@ -94,7 +83,7 @@ void split_keyboard_setup(void) {
void keyboard_slave_loop(void) {
matrix_init();
//Init RGB
#ifdef RGBLIGHT_ENABLE
rgblight_init();
@ -103,17 +92,17 @@ void keyboard_slave_loop(void) {
while (1) {
// Matrix Slave Scan
matrix_slave_scan();
// Read Backlight Info
#ifdef BACKLIGHT_ENABLE
if (BACKLIT_DIRTY) {
#ifdef USE_I2C
#ifdef USE_I2C
if (BACKLIT_DIRTY) {
backlight_set(i2c_slave_buffer[I2C_BACKLIT_START]);
#else // USE_SERIAL
backlight_set(serial_master_buffer[SERIAL_BACKLIT_START]);
#endif
BACKLIT_DIRTY = false;
}
BACKLIT_DIRTY = false;
}
#else // USE_SERIAL
backlight_set(serial_m2s_buffer.backlight_level);
#endif
#endif
// Read RGB Info
#ifdef RGBLIGHT_ENABLE
@ -122,14 +111,14 @@ void keyboard_slave_loop(void) {
// Disable interupts (RGB data is big)
cli();
// Create new DWORD for RGB data
uint32_t dword;
uint32_t dword;
// Fill the new DWORD with the data that was sent over
uint8_t *dword_dat = (uint8_t *)(&dword);
for (int i = 0; i < 4; i++) {
dword_dat[i] = i2c_slave_buffer[I2C_RGB_START+i];
}
// Update the RGB now with the new data and set RGB_DIRTY to false
rgblight_update_dword(dword);
RGB_DIRTY = false;
@ -137,7 +126,9 @@ void keyboard_slave_loop(void) {
sei();
}
#else // USE_SERIAL
#ifdef RGBLIGHT_SPLIT
// Add serial implementation for RGB here
#endif
#endif
#endif
}

31
quantum/template/avr/config.h
View file

@ -48,17 +48,35 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* COL2ROW, ROW2COL, or CUSTOM_MATRIX */
#define DIODE_DIRECTION COL2ROW
/*
* Split Keyboard specific options, make sure you have 'SPLIT_KEYBOARD = yes' in your rules.mk, and define SOFT_SERIAL_PIN.
*/
#define SOFT_SERIAL_PIN D0 // or D1, D2, D3, E6
// #define BACKLIGHT_PIN B7
// #define BACKLIGHT_BREATHING
// #define BACKLIGHT_LEVELS 3
// #define RGB_DI_PIN E2
// #ifdef RGB_DI_PIN
// #define RGBLIGHT_ANIMATIONS
// #define RGBLED_NUM 16
// #define RGBLIGHT_HUE_STEP 8
// #define RGBLIGHT_SAT_STEP 8
// #define RGBLIGHT_VAL_STEP 8
// #define RGBLED_NUM 16
// #define RGBLIGHT_HUE_STEP 8
// #define RGBLIGHT_SAT_STEP 8
// #define RGBLIGHT_VAL_STEP 8
// #define RGBLIGHT_LIMIT_VAL 255 /* The maximum brightness level */
// #define RGBLIGHT_SLEEP /* If defined, the RGB lighting will be switched off when the host goes to sleep */
// /*== all animations enable ==*/
// #define RGBLIGHT_ANIMATIONS
// /*== or choose animations ==*/
// #define RGBLIGHT_EFFECT_BREATHING
// #define RGBLIGHT_EFFECT_RAINBOW_MOOD
// #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
// #define RGBLIGHT_EFFECT_SNAKE
// #define RGBLIGHT_EFFECT_KNIGHT
// #define RGBLIGHT_EFFECT_CHRISTMAS
// #define RGBLIGHT_EFFECT_STATIC_GRADIENT
// #define RGBLIGHT_EFFECT_RGB_TEST
// #define RGBLIGHT_EFFECT_ALTERNATING
// #endif
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
@ -222,3 +240,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#endif
*/
/* Bootmagic Lite key configuration */
// #define BOOTMAGIC_LITE_ROW 0
// #define BOOTMAGIC_LITE_COLUMN 0

2
quantum/template/avr/readme.md
View file

@ -12,4 +12,4 @@ Make example for this keyboard (after setting up your build environment):
make %KEYBOARD%:default
See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).

25
quantum/template/avr/rules.mk
View file

@ -39,13 +39,24 @@ F_USB = $(F_CPU)
OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
# Boot Section Size in *bytes*
# Teensy halfKay 512
# Teensy++ halfKay 1024
# Atmel DFU loader 4096
# LUFA bootloader 4096
# USBaspLoader 2048
OPT_DEFS += -DBOOTLOADER_SIZE=4096
# Bootloader selection
# Teensy halfkay
# Pro Micro caterina
# Atmel DFU atmel-dfu
# LUFA DFU lufa-dfu
# QMK DFU qmk-dfu
# atmega32a bootloadHID
BOOTLOADER = atmel-dfu
# If you don't know the bootloader type, then you can specify the
# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
# Teensy halfKay 512
# Teensy++ halfKay 1024
# Atmel DFU loader 4096
# LUFA bootloader 4096
# USBaspLoader 2048
# OPT_DEFS += -DBOOTLOADER_SIZE=4096
# Build Options

14
quantum/template/avr/template.h
View file

@ -18,12 +18,14 @@
#include "quantum.h"
// This a shortcut to help you visually see your layout.
// The following is an example using the Planck MIT layout
// The first section contains all of the arguments representing the physical
// layout of the board and position of the keys
// The second converts the arguments into a two-dimensional array which
// represents the switch matrix.
/* This a shortcut to help you visually see your layout.
*
* The first section contains all of the arguments representing the physical
* layout of the board and position of the keys.
*
* The second converts the arguments into a two-dimensional array which
* represents the switch matrix.
*/
#define LAYOUT( \
K00, K01, K02, \
K10, K11 \

56
quantum/template/base/keymaps/default/keymap.c
View file

@ -15,32 +15,40 @@
*/
#include QMK_KEYBOARD_H
// Defines the keycodes used by our macros in process_record_user
enum custom_keycodes {
QMKBEST = SAFE_RANGE,
QMKURL
};
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[0] = LAYOUT( /* Base */
KC_A, KC_1, KC_H, \
KC_TAB, KC_SPC \
),
[0] = LAYOUT( /* Base */
KC_A, KC_1, KC_H, \
KC_TAB, KC_SPC \
),
};
const uint16_t PROGMEM fn_actions[] = {
};
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
{
// MACRODOWN only works in this function
switch(id) {
case 0:
if (record->event.pressed) {
register_code(KC_RSFT);
} else {
unregister_code(KC_RSFT);
}
break;
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case QMKBEST:
if (record->event.pressed) {
// when keycode QMKBEST is pressed
SEND_STRING("QMK is the best thing ever!");
} else {
// when keycode QMKBEST is released
}
return MACRO_NONE;
};
break;
case QMKURL:
if (record->event.pressed) {
// when keycode QMKURL is pressed
SEND_STRING("https://qmk.fm/" SS_TAP(X_ENTER));
} else {
// when keycode QMKURL is released
}
break;
}
return true;
}
void matrix_init_user(void) {
@ -50,10 +58,6 @@ void matrix_scan_user(void) {
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true;
}
void led_set_user(uint8_t usb_led) {
}

4
quantum/template/ps2avrgb/config.h
View file

@ -44,3 +44,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */
#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))
/* Bootmagic Lite key configuration */
// #define BOOTMAGIC_LITE_ROW 0
// #define BOOTMAGIC_LITE_COLUMN 0

2
quantum/template/ps2avrgb/readme.md
View file

@ -41,4 +41,4 @@ macOS:
4. Place your keyboard into reset.
5. Flash the board by typing `bootloadHID -r` followed by the path to your `.hex` file.
See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).

4
quantum/template/ps2avrgb/rules.mk
View file

@ -31,8 +31,8 @@ F_CPU = 12000000
BOOTLOADER = bootloadHID
# build options
BOOTMAGIC_ENABLE = yes
MOUSEKEY_ENABLE = yes
BOOTMAGIC_ENABLE = full
MOUSEKEY_ENABLE = no
EXTRAKEY_ENABLE = yes
CONSOLE_ENABLE = yes
COMMAND_ENABLE = yes

12
quantum/template/ps2avrgb/template.h
View file

@ -18,10 +18,14 @@
#include "quantum.h"
// This a shortcut to help you visually see your layout.
// The following is an example using the Planck MIT layout
// The first section contains all of the arguments
// The second converts the arguments into a two-dimensional array
/* This a shortcut to help you visually see your layout.
*
* The first section contains all of the arguments representing the physical
* layout of the board and position of the keys.
*
* The second converts the arguments into a two-dimensional array which
* represents the switch matrix.
*/
#define LAYOUT( \
k00, k01, k02, \
k10, k11 \