mfulz_github/qmk_firmware
1
0
Fork 1
mirror of https://github.com/mfulz/qmk_firmware.git synced 2025-11-04 07:12:33 +01:00
Code Issues Projects Releases Wiki Activity

Merge remote-tracking branch 'remotes/jackhumbert/master'

Browse Source
This commit is contained in:
IBNobody 2016-05-24 17:57:40 -05:00
commit 26277dbdf4
32 changed files with 638 additions and 804 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
HAND_WIRE.md
View File

@ -195,11 +195,9 @@ You'll want to navigate to the `keyboard/<project_name>/` folder by typing, like
#### config.h
The first thing we're going to want to modify is the `config.h` file. On line 32 and 33, you'll see `MATRIX_ROWS` and `MATRIX_COLS` - set both these variables to however many rows and columns you have on your keyboard.
The first thing you're going to want to modify is the `config.h` file. Find `MATRIX_ROWS` and `MATRIX_COLS` and them to match the dimensions of your keyboard's matrix.
On line 38 and 39 you'll see the `COLS` and `ROWS` definitions - this is where you'll enter the pins you used, in order (left-to-right when looking at the top of the keyboard, but right-to-left when looking at the bottom).
There are some other variables that you'll be able to modify (lines 23-29), but it's not necessary to do that now (or ever, really).
Farther down are `MATRIX_ROW_PINS` and `MATRIX_COL_PINS`. Change their definitions to match how you wired up your matrix (looking from the top of the keyboard, the rows run top-to-bottom and the columns run left-to-right). Likewise, change the definition of `UNUSED_PINS` to match the pins you did not use (this will save power).
#### \<project_name\>.h

7
keyboard/Bantam44/config.h
View File

@ -35,8 +35,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// Planck PCB default pin-out
// Change this to how you wired your keyboard
// COLS: Left to right, ROWS: Top to bottom
#define COLS (int []){ B0, B1, B2, B3, B7, D0, B6, F7, F6, F5, F4, F1 }
#define ROWS (int []){ F0, D6, D4, D5 }
#define MATRIX_ROW_PINS { F0, D6, D4, D5 }
#define MATRIX_COL_PINS { B0, B1, B2, B3, B7, D0, B6, F7, F6, F5, F4, F1 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
@ -48,7 +49,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define BACKLIGHT_LEVELS 3
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE

7
keyboard/atomic/config.h
View File

@ -42,14 +42,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
* ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
*
*/
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7, D3, D2, D1 }
#define ROWS (int []){ D0, D5, B5, B6, C6 }
#define MATRIX_ROW_PINS { D0, D5, B5, B6, C6 }
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7, D3, D2, D1 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* define if matrix has ghost (lacks anti-ghosting diodes) */
//#define MATRIX_HAS_GHOST

7
keyboard/atomic/keymaps/pvc/config.h
View File

@ -42,14 +42,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
* ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
*
*/
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7, D3, D2, D1 }
#define ROWS (int []){ D0, D5, B5, B6, B3 }
#define MATRIX_ROW_PINS { D0, D5, B5, B6, B3 }
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7, D3, D2, D1 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* define if matrix has ghost (lacks anti-ghosting diodes) */
//#define MATRIX_HAS_GHOST

41
keyboard/atomic/keymaps/pvc/keymap.c
View File

@ -62,8 +62,6 @@
#define M_BDFLT M(MACRO_BREATH_DEFAULT)
//#define MU_TOG M(MACRO_MUSIC_TOGGLE)
//#define AU_TOG M(MACRO_AUDIO_TOGGLE)
#define VC_UP M(MACRO_INC_VOICE)
#define VC_DOWN M(MACRO_DEC_VOICE)
@ -156,11 +154,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* UPPER
* .---------------------------------------------------------------------------------------------------------------------- 2u ------------.
* | PRINT | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | NUM LK | / | * | - | NUM LK | SCR LK | XXXXXX . PAUSE |
* | PRINT | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | NUM LK | / | * | | NUM LK | SCR LK | XXXXXX . PAUSE |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
* | | F1 | F2 | F3 | F4 | | | 7 | 8 | 9 | + | ~ | | | INS |
* | | F1 | F2 | F3 | F4 | | | 7 | 8 | 9 | - | | | | INS |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+- 2u ------------+--------|
* | CAP LK | F5 | F6 | F7 | F8 | | | 4 | 5 | 6 | + | ` | XXXXXX . | HOME |
* | CAP LK | F5 | F6 | F7 | F8 | | | 4 | 5 | 6 | + | | XXXXXX . | HOME |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+- 2u ---------------------+--------|
* | | F9 | F10 | F11 | F12 | | | 1 | 2 | 3 | ENTER | XXXXXX . | | END |
* |--------+--------+--------+--------+--------+- 2u ------------+--------+--------+--------+--------+-----------------+--------+--------|
@ -498,31 +496,10 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
#ifdef AUDIO_ENABLE
/*
bool process_action_user(keyrecord_t *record)
{
uint8_t starting_note = 0x0C;
int offset = 7;
if (IS_LAYER_ON(LAYER_MUSIC))
{
if (record->event.pressed)
{
play_note(((double)220.0)*pow(2.0, -4.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row)), 0xF);
}
else
{
stop_note(((double)220.0)*pow(2.0, -4.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row)));
}
}
}
*/
void matrix_init_user(void)
{
set_voice(default_voice);
play_startup_tone();
startup_user();
println("Matrix Init");
}
@ -570,30 +547,30 @@ void led_set_user(uint8_t usb_led)
}
void play_startup_tone()
void startup_user()
{
_delay_ms(10); // gets rid of tick
PLAY_NOTE_ARRAY(tone_my_startup, false, STACCATO);
}
void play_goodbye_tone()
void shutdown_user()
{
PLAY_NOTE_ARRAY(tone_my_goodbye, false, STACCATO);
_delay_ms(2000);
stop_all_notes();
}
void play_audio_on_tone(void)
void audio_on_user(void)
{
PLAY_NOTE_ARRAY(tone_audio_on, false, STACCATO);
}
void play_music_on_tone(void)
void music_on_user(void)
{
PLAY_NOTE_ARRAY(tone_music_on, false, STACCATO);
}
void play_music_scale(void)
void music_scale_user(void)
{
PLAY_NOTE_ARRAY(music_scale, false, STACCATO);
}

12
keyboard/atreus/config.h
View File

@ -36,11 +36,13 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// Change this to how you wired your keyboard
// COLS: Left to right, ROWS: Top to bottom
#if defined(ATREUS_ASTAR)
#define COLS (int []){ D7, C6, B5, B4, E6, D4, B6, F6, F7, D6, B7 }
#define ROWS (int []){ D0, D1, D3, D2 }
# define MATRIX_ROW_PINS { D0, D1, D3, D2 }
# define MATRIX_COL_PINS { D7, C6, B5, B4, E6, D4, B6, F6, F7, D6, B7 }
# define UNUSED_PINS
#elif defined(ATREUS_TEENSY2)
#define COLS (int []){ F6, F5, F4, B7, B6, B5, B4, B3, B2, B1, B0}
#define ROWS (int []){ D0, D1, D2, D3 }
# define MATRIX_ROW_PINS { D0, D1, D2, D3 }
# define MATRIX_COL_PINS { F6, F5, F4, B7, B6, B5, B4, B3, B2, B1, B0 }
# define UNUSED_PINS
#endif
/* COL2ROW or ROW2COL */
@ -53,7 +55,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
//#define BACKLIGHT_LEVELS 3
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE

25
keyboard/clueboard1/config.h
View File

@ -32,19 +32,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define MATRIX_ROWS 5
#define MATRIX_COLS 16
// COLS: Left to right, ROWS: Top to bottom
// ROWS: Top to bottom, COLS: Left to right
/* Column pin configuration
* col: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
* pin: B3 F1 F4 F5 F6 C7 C6 B6 B5 B4 D7 D6 D4 F7 B0 B1
*/
#define COLS (int []){ B3, F1, F4, F5, F6, C7, C6, B6, B5, B4, D7, D6, D4, F7, B0, B1 }
/* Row pin configuration
* row: 0 1 2 3 4
* pin: D1 D0 D2 D5 D3
*/
#define ROWS (int []){ D1, D0, D2, D5, D3 }
* col: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
* pin: B3 F1 F4 F5 F6 C7 C6 B6 B5 B4 D7 D6 D4 F7 B0 B1
*/
#define MATRIX_COL_PINS { B3, F1, F4, F5, F6, C7, C6, B6, B5, B4, D7, D6, D4, F7, B0, B1 }
/* Row pin configuration
* row: 0 1 2 3 4
* pin: D1 D0 D2 D5 D3
*/
#define MATRIX_ROW_PINS { D1, D0, D2, D5, D3 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
@ -53,7 +52,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
//#define MATRIX_HAS_GHOST
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE

19
keyboard/clueboard2/config.h
View File

@ -32,19 +32,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define MATRIX_ROWS 10
#define MATRIX_COLS 8
// COLS: Left to right, ROWS: Top to bottom
// ROWS: Top to bottom, COLS: Left to right
/* Row pin configuration
* row: 0 1 2 3 4 5 6 7 8 9
* pin: B2 C7 C6 B6 B5 B0 B3 D5 D3 D2
*/
#define MATRIX_ROW_PINS { B2, C7, C6, B6, B5, B0, B3, D5, D3, D2 }
/* Column pin configuration
* col: 0 1 2 3 4 5 6 7
* pin: F0 F1 F4 F5 F6 F7 E6 B1
*/
#define COLS (int []){ F0, F1, F4, F5, F6, F7, E6, B1 }
/* Row pin configuration
* row: 0 1 2 3 4 5 6 7 8 9
* pin: B2 C7 C6 B6 B5 B0 B3 D5 D3 D2
*/
#define ROWS (int []){ B2, C7, C6, B6, B5, B0, B3, D5, D3, D2 }
#define MATRIX_COL_PINS { F0, F1, F4, F5, F6, F7, E6, B1 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
@ -53,7 +52,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
//#define MATRIX_HAS_GHOST
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE

19
keyboard/cluepad/config.h
View File

@ -32,19 +32,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define MATRIX_ROWS 5
#define MATRIX_COLS 4
// COLS: Left to right, ROWS: Top to bottom
// ROWS: Top to bottom, COLS: Left to right
/* Row pin configuration
* row: 0 1 2 3 4
* pin:
*/
#define MATRIX_ROW_PINS { B0, D3, D5, D4, D6 }
/* Column pin configuration
* col: 0 1 2 3
* pin: F4 E6 B1 D2
*/
#define COLS (int []){ F4, E6, B1, D2 }
/* Row pin configuration
* row: 0 1 2 3 4
* pin:
*/
#define ROWS (int []){ B0, D3, D5, D4, D6 }
#define MATRIX_COL_PINS { F4, E6, B1, D2 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
@ -53,7 +52,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
//#define MATRIX_HAS_GHOST
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* Number of backlighting levels */
#define BACKLIGHT_LEVELS 3

7
keyboard/gh60_rev_c/config.h
View File

@ -42,14 +42,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
* ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
*
*/
#define COLS (int []){ F0, F1, E6, C7, C6, B6, D4, B1, B7, B5, B4, D7, D6, B3 }
#define ROWS (int []){ D0, D1, D2, D3, D5 }
#define MATRIX_ROW_PINS { D0, D1, D2, D3, D5 }
#define MATRIX_COL_PINS { F0, F1, E6, C7, C6, B6, D4, B1, B7, B5, B4, D7, D6, B3 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* define if matrix has ghost (lacks anti-ghosting diodes) */
//#define MATRIX_HAS_GHOST

7
keyboard/jd45/config.h
View File

@ -33,8 +33,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define MATRIX_COLS 13
/* Planck PCB default pin-out */
#define COLS (int []){F4, D7, B5, B6, C6, C7, D4, D6, D5, D0, D1, D2, B0}
#define ROWS (int []){F0, F1, F5, B4}
#define MATRIX_ROW_PINS { F0, F1, F5, B4 }
#define MATRIX_COL_PINS { F4, D7, B5, B6, C6, C7, D4, D6, D5, D0, D1, D2, B0 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
@ -46,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define BACKLIGHT_LEVELS 3
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE

7
keyboard/planck/config.h
View File

@ -33,8 +33,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define MATRIX_COLS 12
/* Planck PCB default pin-out */
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
#define ROWS (int []){ D0, D5, B5, B6 }
#define MATRIX_ROW_PINS { D0, D5, B5, B6 }
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
@ -46,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define BACKLIGHT_LEVELS 3
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE

43
keyboard/planck/keymaps/default/keymap.c
View File

@ -174,21 +174,16 @@ const uint16_t PROGMEM fn_actions[] = {
};
#ifdef AUDIO_ENABLE
float tone_startup[][2] = {
{440.0*pow(2.0,(31)/12.0), 12},
{440.0*pow(2.0,(28)/12.0), 8},
{440.0*pow(2.0,(19)/12.0), 8},
{440.0*pow(2.0,(24)/12.0), 8},
{440.0*pow(2.0,(28)/12.0), 20}
};
float tone_startup[][2] = SONG(STARTUP_SOUND);
float tone_qwerty[][2] = SONG(QWERTY_SOUND);
float tone_dvorak[][2] = SONG(DVORAK_SOUND);
float tone_colemak[][2] = SONG(COLEMAK_SOUND);
float tone_plover[][2] = SONG(PLOVER_SOUND);
float tone_plover_gb[][2] = SONG(PLOVER_GOODBYE_SOUND);
float music_scale[][2] = SONG(MUSIC_SCALE_SOUND);
float goodbye[][2] = SONG(GOODBYE_SOUND);
float tone_goodbye[][2] = SONG(GOODBYE_SOUND);
#endif
@ -288,16 +283,34 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
};
void matrix_init_user(void) {
#ifdef AUDIO_ENABLE
_delay_ms(20); // stops the tick
PLAY_NOTE_ARRAY(tone_startup, false, 0);
#endif
#ifdef AUDIO_ENABLE
startup_user();
#endif
}
#ifdef AUDIO_ENABLE
void play_goodbye_tone()
void startup_user()
{
PLAY_NOTE_ARRAY(goodbye, false, 0);
_delay_ms(150);
_delay_ms(20); // gets rid of tick
PLAY_NOTE_ARRAY(tone_startup, false, 0);
}
void shutdown_user()
{
PLAY_NOTE_ARRAY(tone_goodbye, false, 0);
_delay_ms(150);
stop_all_notes();
}
void music_on_user(void)
{
music_scale_user();
}
void music_scale_user(void)
{
PLAY_NOTE_ARRAY(music_scale, false, 0);
}
#endif

9
keyboard/planck/keymaps/pvc/config.h
View File

@ -33,8 +33,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define MATRIX_COLS 12
/* Planck PCB default pin-out */
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
#define ROWS (int []){ D0, D5, B5, B6 }
#define MATRIX_ROW_PINS { D0, D5, B5, B6 }
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
@ -46,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define BACKLIGHT_LEVELS 3
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE
@ -73,7 +74,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/* disable debug print */
#define NO_DEBUG
//#define NO_DEBUG
/* disable print */
//#define NO_PRINT

289
keyboard/planck/keymaps/pvc/keymap.c
View File

@ -8,43 +8,44 @@
#include "song_list.h"
#endif
#define LAYER_QWERTY 0
#define LAYER_COLEMAK 1
#define LAYER_DVORAK 2
#define LAYER_LOWER 3
#define LAYER_RAISE 4
#define LAYER_FUNCTION 5
#define LAYER_MOUSE 6
#define LAYER_MUSIC 7
#define LAYER_ADJUST 8
#define LAYER_QWERTY 0
#define LAYER_COLEMAK 1
#define LAYER_DVORAK 2
#define LAYER_UPPER 3
#define LAYER_LOWER 4
#define LAYER_FUNCTION 5
#define LAYER_MOUSE 6
#define LAYER_ADJUST 7
#define MACRO_QWERTY 0
#define MACRO_COLEMAK 1
#define MACRO_DVORAK 2
#define MACRO_LOWER 3
#define MACRO_RAISE 4
#define MACRO_FUNCTION 5
#define MACRO_MOUSE 6
#define MACRO_TIMBRE_1 7
#define MACRO_TIMBRE_2 8
#define MACRO_TIMBRE_3 9
#define MACRO_TIMBRE_4 10
#define MACRO_TEMPO_U 11
#define MACRO_TEMPO_D 12
#define MACRO_TONE_DEFAULT 13
#define MACRO_MUSIC_ON 14
#define MACRO_MUSIC_OFF 15
#define MACRO_AUDIO_ON 16
#define MACRO_AUDIO_OFF 17
#define MACRO_INC_VOICE 18
#define MACRO_DEC_VOICE 19
#define MACRO_BACKLIGHT 20
#define MACRO_QWERTY 0
#define MACRO_COLEMAK 1
#define MACRO_DVORAK 2
#define MACRO_UPPER 3
#define MACRO_LOWER 4
#define MACRO_FUNCTION 5
#define MACRO_MOUSE 6
#define MACRO_TIMBRE_1 7
#define MACRO_TIMBRE_2 8
#define MACRO_TIMBRE_3 9
#define MACRO_TIMBRE_4 10
#define MACRO_TEMPO_U 11
#define MACRO_TEMPO_D 12
#define MACRO_TONE_DEFAULT 13
#define MACRO_MUSIC_TOGGLE 14
#define MACRO_AUDIO_TOGGLE 16
#define MACRO_INC_VOICE 18
#define MACRO_DEC_VOICE 19
#define MACRO_BACKLIGHT 20
#define MACRO_BREATH_TOGGLE 21
#define MACRO_BREATH_SPEED_INC 23
#define MACRO_BREATH_SPEED_DEC 24
#define MACRO_BREATH_DEFAULT 25
#define M_QWRTY M(MACRO_QWERTY)
#define M_COLMK M(MACRO_COLEMAK)
#define M_DVORK M(MACRO_DVORAK)
#define M_UPPER M(MACRO_UPPER)
#define M_LOWER M(MACRO_LOWER)
#define M_RAISE M(MACRO_RAISE)
#define M_FUNCT M(MACRO_FUNCTION)
#define M_MOUSE M(MACRO_MOUSE)
#define TIMBR_1 M(MACRO_TIMBRE_1)
@ -55,12 +56,12 @@
#define TMPO_DN M(MACRO_TEMPO_D)
#define TMPO_DF M(MACRO_TONE_DEFAULT)
#define M_BACKL M(MACRO_BACKLIGHT)
#define M_BRTOG M(MACRO_BREATH_TOGGLE)
#define M_BSPDU M(MACRO_BREATH_SPEED_INC)
#define M_BSPDD M(MACRO_BREATH_SPEED_DEC)
#define M_BDFLT M(MACRO_BREATH_DEFAULT)
#define MUS_ON M(MACRO_MUSIC_ON)
#define MUS_OFF M(MACRO_MUSIC_OFF)
#define AUD_OFF M(MACRO_AUDIO_OFF)
#define AUD_ON M(MACRO_AUDIO_ON)
#define VC_UP M(MACRO_INC_VOICE)
#define VC_DOWN M(MACRO_DEC_VOICE)
@ -76,6 +77,7 @@
#define SC_ACLS LALT(KC_F4)
#define SC_CCLS LCTL(KC_F4)
#define OS_SHFT KC_FN0
#define _______ KC_TRNS
#define XXXXXXX KC_NO
@ -90,17 +92,17 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | ESC | A | S | D | F | G | H | J | K | L | ; | ' |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LSHIFT | Z | X | C | V | B | N | M | , | . | / | ENTER |
* | LSHIFT | Z | X | C | V | B | N | M | , | . | UP | ENTER |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LCTRL | LWIN | FN | LALT | RAISE | SPACE | SPACE | LOWER | UP | DOWN | LEFT | RIGHT |
* | LCTRL | LWIN | FN | LALT | UPPER | SPACE | SPACE | LOWER | SHIFT | LEFT | DOWN | RIGHT |
* '-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_QWERTY] = { /* QWERTY */
{ KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC },
[LAYER_QWERTY] = { // QWERTY
{ KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC },
{ KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT },
{ KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT },
{ KC_LCTL, KC_LGUI, M_FUNCT, KC_LALT, M_RAISE, KC_SPC, KC_SPC, M_LOWER, KC_UP, KC_DOWN, KC_LEFT, KC_RGHT },
{ KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_UP, KC_ENT },
{ KC_LCTL, KC_LGUI, M_FUNCT, KC_LALT, M_UPPER, KC_SPC, KC_SPC, M_LOWER, OS_SHFT, KC_LEFT, KC_DOWN, KC_RGHT },
},
/* COLEMAK
@ -109,77 +111,77 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | BACKSP | A | R | S | T | D | H | N | E | I | O | ' |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LSHIFT | Z | X | C | V | B | K | M | , | . | / | ENTER |
* | LSHIFT | Z | X | C | V | B | K | M | , | . | UP | ENTER |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LCTRL | LWIN | FN | LALT | RAISE | SPACE | SPACE | LOWER | UP | DOWN | LEFT | RIGHT |
* | LCTRL | LWIN | FN | LALT | UPPER | SPACE | SPACE | LOWER | SHIFT | LEFT | DOWN | RIGHT |
* '-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_COLEMAK] = { /* COLEMAK */
[LAYER_COLEMAK] = { // COLEMAK
{ KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_ESC },
{ KC_BSPC, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT },
{ KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT },
{ KC_LCTL, KC_LGUI, M_FUNCT, KC_LALT, M_RAISE, KC_SPC, KC_SPC, M_LOWER, KC_UP, KC_DOWN, KC_LEFT, KC_RGHT },
{ KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_UP, KC_ENT },
{ KC_LCTL, KC_LGUI, M_FUNCT, KC_LALT, M_UPPER, KC_SPC, KC_SPC, M_LOWER, OS_SHFT, KC_LEFT, KC_DOWN, KC_RGHT },
},
/* DVORAK
* .-----------------------------------------------------------------------------------------------------------.
* | TAB | ' | , | . | P | Y | F | G | C | R | L | BACKSP |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | ESC | A | O | E | U | I | D | H | T | N | S | ' |
* | ESC | A | O | E | U | I | D | H | T | N | S | / |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LSHIFT | ; | Q | J | K | X | B | M | W | V | Z | ENTER |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LCTRL | LWIN | FN | LALT | RAISE | SPACE | SPACE | LOWER | UP | DOWN | LEFT | RIGHT |
* | LCTRL | LWIN | FN | LALT | UPPER | SPACE | SPACE | LOWER | UP | DOWN | LEFT | RIGHT |
* '-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_DVORAK] = { /* DVORAK */
[LAYER_DVORAK] = { // DVORAK
{ KC_TAB, KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_F, KC_G, KC_C, KC_R, KC_L, KC_BSPC },
{ KC_ESC, KC_A, KC_O, KC_E, KC_U, KC_I, KC_D, KC_H, KC_T, KC_N, KC_S, KC_SLSH },
{ KC_LSFT, KC_SCLN, KC_Q, KC_J, KC_K, KC_X, KC_B, KC_M, KC_W, KC_V, KC_Z, KC_ENT },
{ KC_LCTL, KC_LGUI, M_FUNCT, KC_LALT, M_RAISE, KC_SPC, KC_SPC, M_LOWER, KC_UP, KC_DOWN, KC_LEFT, KC_RGHT },
{ KC_LCTL, KC_LGUI, M_FUNCT, KC_LALT, M_UPPER, KC_SPC, KC_SPC, M_LOWER, KC_UP, KC_DOWN, KC_LEFT, KC_RGHT },
},
/* Raise
/* UPPER
* .-----------------------------------------------------------------------------------------------------------.
* | ~ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | DEL |
* | PRINT | F1 | F2 | F3 | F4 | NUM LK | / | 7 | 8 | 9 | - | DEL |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | XXXXXX | F1 | F2 | F3 | F4 | F5 | F6 | _ | + | [ | ] | \ |
* | CAP LK | F5 | F6 | F7 | F8 | SCR LK | * | 4 | 5 | 6 | + | INS |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LSHIFT | F7 | F8 | F9 | F10 | F11 | F12 | XXXXXX | XXXXXX | XXXXXX | XXXXXX | ENTER |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LCTRL | LWIN | FN | LALT | RAISE | BACKSP | BACKSP | LOWER | PG UP | PG DN | HOME | END |
* | | F9 | F10 | F11 | F12 | PAUSE | | 1 | 2 | 3 | ENTER | HOME |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
* | | | | | | 0 | 0 | | RALT | . | ENTER | END |
* '-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_RAISE] = { /* RAISED */
{ KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL },
{ XXXXXXX, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS },
{ _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX },
{ _______, _______, _______, _______, _______, KC_BSPC, KC_BSPC, _______, KC_PGUP, KC_PGDN, KC_HOME, KC_END },
[LAYER_UPPER] = { // UPPER
{ KC_PSCR, KC_F1, KC_F2, KC_F3, KC_F4, KC_NLCK, KC_PSLS, KC_KP_7, KC_KP_8, KC_KP_9, KC_PMNS, KC_DEL },
{ KC_CAPS, KC_F5, KC_F6, KC_F7, KC_F8, KC_SLCK, KC_PAST, KC_KP_4, KC_KP_5, KC_KP_6, KC_PPLS, KC_INS },
{ _______, KC_F9, KC_F10, KC_F11, KC_F12, KC_PAUS, XXXXXXX, KC_KP_1, KC_KP_2, KC_KP_3, KC_PENT, KC_HOME },
{ _______, _______, _______, _______, _______, KC_KP_0, KC_KP_0, _______, KC_RALT, KC_PDOT, KC_PENT, KC_END },
},
/* LOWERED
/* LOWER
* .-----------------------------------------------------------------------------------------------------------.
* | ~ | ! | @ | # | $ | % | ^ | & | * | ( | ) | INS |
* | | $ | { | [ | ( | % | # | ) | ] | } | @ | PG UP |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | XXXXXX | F1 | F2 | F3 | F4 | F5 | F6 | _ | + | { | } | | |
* | | ^ | * | + | - | ; | : | _ | ' | " | ` | PG DN |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LSHIFT | F7 | F8 | F9 | F10 | F11 | F12 | XXXXXX | XXXXXX | XXXXXX | XXXXXX | ENTER |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LCTRL | LWIN | FN | LALT | RAISE | BACKSP | BACKSP | LOWER | PG UP | PG DN | HOME | END |
* | | | | & | ! | ~ | / | \ | = | < | > | ? | HOME |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------|
* | | | | | | | | | | | | END |
* '-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_LOWER] = { /* LOWERED */
{ KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_INS },
{ XXXXXXX, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS },
{ _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX },
{ _______, _______, _______, _______, _______, KC_BSPC, KC_BSPC, _______, KC_PGUP, KC_PGDN, KC_HOME, KC_END },
[LAYER_LOWER] = { // LOWER
{ _______, KC_DLR, KC_LCBR, KC_LBRC, KC_LPRN, KC_PERC, KC_HASH, KC_RPRN, KC_RBRC, KC_RCBR, KC_AT, KC_PGUP },
{ _______, KC_CIRC, KC_ASTR, KC_PPLS, KC_PMNS, KC_SCLN, KC_COLN, KC_UNDS, KC_QUOT, KC_DQT, KC_GRV, KC_PGDN },
{ _______, KC_PIPE, KC_AMPR, KC_EXLM, KC_TILD, KC_SLSH, KC_BSLS, KC_EQL, KC_LT, KC_GT, KC_QUES, KC_HOME },
{ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_END },
},
/* FUNCTION
* .-----------------------------------------------------------------------------------------------------------.
* | NUM LK | F1 | F2 | F3 | F4 | F5 | F6 | F7 | F8 | F9 | F10 | PAUSE |
@ -188,10 +190,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | SCR LK | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | MUTE |
* |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
* | LCTRL | LWIN | FN | LALT | RAISE | PLAY | PLAY | LOWER | VOL UP | VOL DN | NEXT | PREV |
* | LCTRL | LWIN | FN | LALT | UPPER | PLAY | PLAY | LOWER | VOL UP | VOL DN | NEXT | PREV |
* '-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_FUNCTION] = { /* FUNCTION */
[LAYER_FUNCTION] = { // FUNCTION
{ KC_NLCK, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_PAUS },
{ KC_CAPS, KC_F11, KC_F12, KC_F13, KC_F14, KC_F15, KC_F16, KC_F17, KC_F18, KC_F19, KC_F20, KC_PSCR },
{ KC_SLCK, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_MUTE },
@ -200,7 +202,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
#ifdef MOUSEKEY_ENABLE
[LAYER_MOUSE] = { /* MOUSE */
[LAYER_MOUSE] = { // MOUSE
{ KC_ESC, KC_ACL0, KC_ACL1, KC_ACL2, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_ESC },
{ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX },
{ _______, KC_BTN5, KC_BTN4, KC_BTN3, KC_BTN2, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_WH_U, KC_WH_D },
@ -209,21 +211,13 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
#endif
[LAYER_MUSIC] = { /* MUSIC */
{ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX },
{ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX },
{ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX },
{ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, M_RAISE, XXXXXXX, XXXXXXX, M_LOWER, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX },
},
[LAYER_ADJUST] = { /* ADJUST */
{ _______, TIMBR_1, TIMBR_2, TIMBR_3, TIMBR_4, TMPO_UP, TMPO_DN, TMPO_DF, MUS_ON, MUS_OFF, AUD_ON, AUD_OFF },
[LAYER_ADJUST] = { // ADJUST
{ _______, TIMBR_1, TIMBR_2, TIMBR_3, TIMBR_4, TMPO_UP, TMPO_DN, TMPO_DF, _______, _______, MU_TOG, AU_TOG },
{ _______, M_QWRTY, M_COLMK, M_DVORK, _______, _______, _______, _______, _______, _______, _______, _______ },
{ _______, _______, _______, _______, M_BACKL, RESET, _______, M_MOUSE, _______, _______, _______, _______ },
{ _______, _______, _______, _______, _______, _______, _______, _______, VC_UP, VC_DOWN, _______, _______ },
{ _______, _______, _______, _______, M_BACKL, RESET, _______, M_MOUSE, _______, _______, MUV_IN, _______ },
{ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, MUV_DE, _______ },
},
/*
[LAYER_EMPTY] = {
{ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, },
@ -263,6 +257,7 @@ void persistant_default_layer_set(uint16_t default_layer)
}
const uint16_t PROGMEM fn_actions[] = {
[0] = ACTION_MODS_ONESHOT(MOD_LSFT),
};
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
@ -306,25 +301,25 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
if (record->event.pressed)
{
layer_on(LAYER_LOWER);
update_tri_layer(LAYER_LOWER, LAYER_RAISE, LAYER_ADJUST);
update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
}
else
{
layer_off(LAYER_LOWER);
update_tri_layer(LAYER_LOWER, LAYER_RAISE, LAYER_ADJUST);
update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
}
break;
case MACRO_RAISE:
case MACRO_UPPER:
if (record->event.pressed)
{
layer_on(LAYER_RAISE);
update_tri_layer(LAYER_LOWER, LAYER_RAISE, LAYER_ADJUST);
layer_on(LAYER_UPPER);
update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
}
else
{
layer_off(LAYER_RAISE);
update_tri_layer(LAYER_LOWER, LAYER_RAISE, LAYER_ADJUST);
layer_off(LAYER_UPPER);
update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
}
break;
@ -393,65 +388,6 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
}
break;
case MACRO_AUDIO_OFF:
if (record->event.pressed)
{
#ifdef AUDIO_ENABLE
audio_off();
#endif
}
break;
case MACRO_AUDIO_ON:
if (record->event.pressed)
{
#ifdef AUDIO_ENABLE
audio_on();
PLAY_NOTE_ARRAY(tone_audio_on, false, STACCATO);
#endif
}
break;
case MACRO_MUSIC_ON:
if (record->event.pressed)
{
#ifdef AUDIO_ENABLE
PLAY_NOTE_ARRAY(tone_music_on, false, STACCATO);
layer_on(LAYER_MUSIC);
#endif
}
break;
case MACRO_MUSIC_OFF:
if (record->event.pressed)
{
#ifdef AUDIO_ENABLE
layer_off(LAYER_MUSIC);
stop_all_notes();
#endif
}
break;
case MACRO_INC_VOICE:
if (record->event.pressed)
{
#ifdef AUDIO_ENABLE
voice_iterate();
PLAY_NOTE_ARRAY(music_scale, false, STACCATO);
#endif
}
break;
case MACRO_DEC_VOICE:
if (record->event.pressed)
{
#ifdef AUDIO_ENABLE
voice_deiterate();
PLAY_NOTE_ARRAY(music_scale, false, STACCATO);
#endif
}
break;
#endif /* AUDIO_ENABLE */
default:
@ -464,31 +400,10 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
#ifdef AUDIO_ENABLE
void process_action_user(keyrecord_t *record)
{
uint8_t starting_note = 0x0C;
int offset = 7;
if (IS_LAYER_ON(LAYER_MUSIC))
{
if (record->event.pressed)
{
play_note(((double)220.0)*pow(2.0, -4.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row)), 0xF);
}
else
{
stop_note(((double)220.0)*pow(2.0, -4.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row)));
}
}
}
void matrix_init_user(void)
{
set_voice(default_voice);
play_startup_tone();
startup_user();
println("Matrix Init");
}
@ -532,16 +447,32 @@ void led_set_user(uint8_t usb_led)
}
void play_startup_tone()
void startup_user()
{
_delay_ms(10); // gets rid of tick
PLAY_NOTE_ARRAY(tone_my_startup, false, STACCATO);
}
void play_goodbye_tone()
void shutdown_user()
{
PLAY_NOTE_ARRAY(tone_my_goodbye, false, STACCATO);
_delay_ms(1000);
_delay_ms(2000);
stop_all_notes();
}
void audio_on_user(void)
{
PLAY_NOTE_ARRAY(tone_audio_on, false, STACCATO);
}
void music_on_user(void)
{
PLAY_NOTE_ARRAY(tone_music_on, false, STACCATO);
}
void music_scale_user(void)
{
PLAY_NOTE_ARRAY(music_scale, false, STACCATO);
}
#endif /* AUDIO_ENABLE */

7
keyboard/preonic/config.h
View File

@ -33,8 +33,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define MATRIX_COLS 12
/* Planck PCB default pin-out */
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
#define ROWS (int []){ D2, D5, B5, B6, D3 }
#define MATRIX_ROW_PINS { D2, D5, B5, B6, D3 }
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
@ -46,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define BACKLIGHT_LEVELS 3
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE

7
keyboard/retro_refit/config.h
View File

@ -33,8 +33,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define MATRIX_COLS 8
// See note in retro_refit.h for an explanation of how this matrix is wired up
#define COLS (int []){ B0, B1, B2, B3, D2, D3, C7, D5 }
#define ROWS (int []){ D4, D7, B4, B5, B6, F7, F6, F5, F4, F1, F0 }
#define MATRIX_ROW_PINS { D4, D7, B4, B5, B6, F7, F6, F5, F4, F1, F0 }
#define MATRIX_COL_PINS { B0, B1, B2, B3, D2, D3, C7, D5 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
@ -46,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define BACKLIGHT_LEVELS 0
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE

17
quantum/audio/audio.c
View File

@ -475,20 +475,3 @@ void increase_tempo(uint8_t tempo_change) {
note_tempo -= tempo_change;
}
}
//------------------------------------------------------------------------------
// Override these functions in your keymap file to play different tunes on
// startup and bootloader jump
__attribute__ ((weak))
void play_startup_tone() {}
__attribute__ ((weak))
void play_goodbye_tone() {}
__attribute__ ((weak))
void audio_on_user() {}
__attribute__ ((weak))
void play_music_scale() {}
//------------------------------------------------------------------------------

6
quantum/audio/audio.h
View File

@ -5,6 +5,7 @@
#include "musical_notes.h"
#include "song_list.h"
#include "voices.h"
#include "quantum.h"
#ifndef AUDIO_H
#define AUDIO_H
@ -87,9 +88,4 @@ void play_notes(float (*np)[][2], uint16_t n_count, bool n_repeat, float n_rest)
bool is_playing_notes(void);
void play_goodbye_tone(void);
void play_startup_tone(void);
void audio_on_user(void);
void play_music_scale(void);
#endif

125
quantum/config_common.h
View File

@ -1,70 +1,74 @@
#ifndef CONFIG_DEFINITIONS_H
#define CONFIG_DEFINITIONS_H
#define B0 0x20
#define B1 0x21
#define B2 0x22
#define B3 0x23
#define B4 0x24
#define B5 0x25
#define B6 0x26
#define B7 0x27
#define C0 0x30
#define C1 0x31
#define C2 0x32
#define C3 0x33
#define C4 0x34
#define C5 0x35
#define C6 0x36
#define C7 0x37
#define D0 0x40
#define D1 0x41
#define D2 0x42
#define D3 0x43
#define D4 0x44
#define D5 0x45
#define D6 0x46
#define D7 0x47
#define E0 0x50
#define E1 0x51
#define E2 0x52
#define E3 0x53
#define E4 0x54
#define E5 0x55
#define E6 0x56
#define E7 0x57
#define F0 0x60
#define F1 0x61
#define F2 0x62
#define F3 0x63
#define F4 0x64
#define F5 0x65
#define F6 0x66
#define F7 0x67
#define COL2ROW 0x0
#define ROW2COL 0x1
/* diode directions */
#define COL2ROW 0
#define ROW2COL 1
/* I/O pins */
#define B0 { .input_addr = 3, .bit = 0 }
#define B1 { .input_addr = 3, .bit = 1 }
#define B2 { .input_addr = 3, .bit = 2 }
#define B3 { .input_addr = 3, .bit = 3 }
#define B4 { .input_addr = 3, .bit = 4 }
#define B5 { .input_addr = 3, .bit = 5 }
#define B6 { .input_addr = 3, .bit = 6 }
#define B7 { .input_addr = 3, .bit = 7 }
#define C0 { .input_addr = 6, .bit = 0 }
#define C1 { .input_addr = 6, .bit = 1 }
#define C2 { .input_addr = 6, .bit = 2 }
#define C3 { .input_addr = 6, .bit = 3 }
#define C4 { .input_addr = 6, .bit = 4 }
#define C5 { .input_addr = 6, .bit = 5 }
#define C6 { .input_addr = 6, .bit = 6 }
#define C7 { .input_addr = 6, .bit = 7 }
#define D0 { .input_addr = 9, .bit = 0 }
#define D1 { .input_addr = 9, .bit = 1 }
#define D2 { .input_addr = 9, .bit = 2 }
#define D3 { .input_addr = 9, .bit = 3 }
#define D4 { .input_addr = 9, .bit = 4 }
#define D5 { .input_addr = 9, .bit = 5 }
#define D6 { .input_addr = 9, .bit = 6 }
#define D7 { .input_addr = 9, .bit = 7 }
#define E0 { .input_addr = 0xC, .bit = 0 }
#define E1 { .input_addr = 0xC, .bit = 1 }
#define E2 { .input_addr = 0xC, .bit = 2 }
#define E3 { .input_addr = 0xC, .bit = 3 }
#define E4 { .input_addr = 0xC, .bit = 4 }
#define E5 { .input_addr = 0xC, .bit = 5 }
#define E6 { .input_addr = 0xC, .bit = 6 }
#define E7 { .input_addr = 0xC, .bit = 7 }
#define F0 { .input_addr = 0xF, .bit = 0 }
#define F1 { .input_addr = 0xF, .bit = 1 }
#define F2 { .input_addr = 0xF, .bit = 2 }
#define F3 { .input_addr = 0xF, .bit = 3 }
#define F4 { .input_addr = 0xF, .bit = 4 }
#define F5 { .input_addr = 0xF, .bit = 5 }
#define F6 { .input_addr = 0xF, .bit = 6 }
#define F7 { .input_addr = 0xF, .bit = 7 }
/* USART configuration */
#ifdef BLUETOOTH_ENABLE
#ifdef __AVR_ATmega32U4__
#define SERIAL_UART_BAUD 9600
#define SERIAL_UART_DATA UDR1
#define SERIAL_UART_UBRR ((F_CPU/(16UL*SERIAL_UART_BAUD))-1)
#define SERIAL_UART_RXD_VECT USART1_RX_vect
#define SERIAL_UART_TXD_READY (UCSR1A&(1<<UDRE1))
#define SERIAL_UART_INIT() do { \
UBRR1L = (uint8_t) SERIAL_UART_UBRR; /* baud rate */ \
UBRR1H = (uint8_t) (SERIAL_UART_UBRR>>8); /* baud rate */ \
UCSR1B = (1<<TXEN1); /* TX: enable */ \
UCSR1C = (0<<UPM11) | (0<<UPM10) | /* parity: none(00), even(01), odd(11) */ \
(0<<UCSZ12) | (1<<UCSZ11) | (1<<UCSZ10); /* data-8bit(011) */ \
sei(); \
} while(0)
#else
# error "USART configuration is needed."
# ifdef __AVR_ATmega32U4__
# define SERIAL_UART_BAUD 9600
# define SERIAL_UART_DATA UDR1
# define SERIAL_UART_UBRR (F_CPU / (16UL * SERIAL_UART_BAUD) - 1)
# define SERIAL_UART_RXD_VECT USART1_RX_vect
# define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1))
# define SERIAL_UART_INIT() do { \
/* baud rate */ \
UBRR1L = SERIAL_UART_UBRR; \
/* baud rate */ \
UBRR1H = SERIAL_UART_UBRR >> 8; \
/* enable TX */ \
UCSR1B = _BV(TXEN1); \
/* 8-bit data */ \
UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
sei(); \
} while(0)
# else
# error "USART configuration is needed."
#endif
// I'm fairly sure these aren't needed, but oh well - Jack
/*
@ -113,4 +117,3 @@
#endif
#endif

3
quantum/keymap_common.c
View File

@ -26,6 +26,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "backlight.h"
#include "bootloader.h"
#include "eeconfig.h"
#include "quantum.h"
#ifdef MIDI_ENABLE
#include "keymap_midi.h"
@ -190,7 +191,7 @@ static action_t keycode_to_action(uint16_t keycode)
clear_keyboard();
#ifdef AUDIO_ENABLE
stop_all_notes();
play_goodbye_tone();
shutdown_user();
#endif
_delay_ms(250);
#ifdef ATREUS_ASTAR

391
quantum/matrix.c
View File

@ -1,6 +1,6 @@
/*
Copyright 2012 Jun Wako
Generated by planckkeyboard.com (2014 Jack Humbert)
Copyright 2014 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
@ -15,300 +15,211 @@ 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/>.
*/
/*
* scan matrix
*/
#include <stdint.h>
#include <stdbool.h>
#include <avr/io.h>
#include <util/delay.h>
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h"
#ifndef DEBOUNCE
# define DEBOUNCE 10
#ifdef MATRIX_HAS_GHOST
# error "The universal matrix.c file cannot be used for this keyboard."
#endif
static uint8_t debouncing = DEBOUNCE;
/* matrix state(1:on, 0:off) */
#ifndef DEBOUNCING_DELAY
# define DEBOUNCING_DELAY 5
#endif
static const io_pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const io_pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
/* matrix state */
#if DIODE_DIRECTION == COL2ROW
static matrix_row_t matrix[MATRIX_ROWS];
static matrix_row_t matrix_debouncing[MATRIX_ROWS];
#if DIODE_DIRECTION == ROW2COL
static matrix_row_t matrix_reversed[MATRIX_COLS];
static matrix_row_t matrix_reversed_debouncing[MATRIX_COLS];
#endif
#if MATRIX_COLS > 16
#define SHIFTER 1UL
#else
#define SHIFTER 1
static matrix_col_t matrix[MATRIX_COLS];
#endif
static int8_t debouncing_delay = -1;
#if DIODE_DIRECTION == COL2ROW
static void toggle_row(uint8_t row);
static matrix_row_t read_cols(void);
static void init_cols(void);
static void unselect_rows(void);
static void select_row(uint8_t row);
#else
static void toggle_col(uint8_t col);
static matrix_col_t read_rows(void);
#endif
__attribute__ ((weak))
void matrix_init_quantum(void) {
}
__attribute__ ((weak))
void matrix_scan_quantum(void) {
}
inline
uint8_t matrix_rows(void)
{
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void)
{
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void)
{
// To use PORTF disable JTAG with writing JTD bit twice within four cycles.
MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD);
// initialize row and col
unselect_rows();
init_cols();
// initialize matrix state: all keys off
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
matrix[i] = 0;
matrix_debouncing[i] = 0;
void matrix_init(void) {
/* frees PORTF by setting the JTD bit twice within four cycles */
MCUCR |= _BV(JTD);
MCUCR |= _BV(JTD);
/* initializes the I/O pins */
#if DIODE_DIRECTION == COL2ROW
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
/* DDRxn */
_SFR_IO8(row_pins[r].input_addr + 1) |= _BV(row_pins[r].bit);
toggle_row(r);
}
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
/* PORTxn */
_SFR_IO8(col_pins[c].input_addr + 2) |= _BV(col_pins[c].bit);
}
#else
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
/* DDRxn */
_SFR_IO8(col_pins[c].input_addr + 1) |= _BV(col_pins[c].bit);
toggle_col(c);
}
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
/* PORTxn */
_SFR_IO8(row_pins[r].input_addr + 2) |= _BV(row_pins[r].bit);
}
#endif
matrix_init_quantum();
}
uint8_t matrix_scan(void)
{
#if DIODE_DIRECTION == COL2ROW
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(i);
_delay_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols();
if (matrix_debouncing[i] != cols) {
matrix_debouncing[i] = cols;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
uint8_t matrix_scan(void) {
static matrix_row_t debouncing_matrix[MATRIX_ROWS];
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
toggle_row(r);
matrix_row_t state = read_cols();
if (debouncing_matrix[r] != state) {
debouncing_matrix[r] = state;
debouncing_delay = DEBOUNCING_DELAY;
}
unselect_rows();
toggle_row(r);
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
if (debouncing_delay >= 0) {
dprintf("Debouncing delay remaining: %X\n", debouncing_delay);
--debouncing_delay;
if (debouncing_delay >= 0) {
wait_ms(1);
}
else {
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
matrix[r] = debouncing_matrix[r];
}
}
}
#else
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
select_row(i);
_delay_us(30); // without this wait read unstable value.
matrix_row_t rows = read_cols();
if (matrix_reversed_debouncing[i] != rows) {
matrix_reversed_debouncing[i] = rows;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
matrix_reversed[i] = matrix_reversed_debouncing[i];
}
}
}
for (uint8_t y = 0; y < MATRIX_ROWS; y++) {
matrix_row_t row = 0;
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
row |= ((matrix_reversed[x] & (1<<y)) >> y) << x;
}
matrix[y] = row;
}
#endif
matrix_scan_quantum();
return 1;
}
bool matrix_is_modified(void)
{
if (debouncing) return false;
return true;
static void toggle_row(uint8_t row) {
/* PINxn */
_SFR_IO8(row_pins[row].input_addr) = _BV(row_pins[row].bit);
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<col));
static matrix_row_t read_cols(void) {
matrix_row_t state = 0;
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
/* PINxn */
if (!(_SFR_IO8(col_pins[c].input_addr) & _BV(col_pins[c].bit))) {
state |= (matrix_row_t)1 << c;
}
}
return state;
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
matrix_row_t matrix_get_row(uint8_t row) {
return matrix[row];
}
void matrix_print(void)
{
print("\nr/c 0123456789ABCDEF\n");
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
phex(row); print(": ");
pbin_reverse16(matrix_get_row(row));
print("\n");
#else
uint8_t matrix_scan(void) {
static matrix_col_t debouncing_matrix[MATRIX_COLS];
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
toggle_col(c);
matrix_col_t state = read_rows();
if (debouncing_matrix[c] != state) {
debouncing_matrix[c] = state;
debouncing_delay = DEBOUNCING_DELAY;
}
toggle_col(c);
}
if (debouncing_delay >= 0) {
dprintf("Debouncing delay remaining: %X\n", debouncing_delay);
--debouncing_delay;
if (debouncing_delay >= 0) {
wait_ms(1);
}
else {
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
matrix[c] = debouncing_matrix[c];
}
}
}
matrix_scan_quantum();
return 1;
}
static void toggle_col(uint8_t col) {
/* PINxn */
_SFR_IO8(col_pins[col].input_addr) = _BV(col_pins[col].bit);
}
static matrix_col_t read_rows(void) {
matrix_col_t state = 0;
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
/* PINxn */
if (!(_SFR_IO8(row_pins[r].input_addr) & _BV(row_pins[r].bit))) {
state |= (matrix_col_t)1 << r;
}
}
return state;
}
matrix_row_t matrix_get_row(uint8_t row) {
matrix_row_t state = 0;
matrix_col_t mask = (matrix_col_t)1 << row;
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
if (matrix[c] & mask) {
state |= (matrix_row_t)1 << c;
}
}
return state;
}
#endif
bool matrix_is_modified(void) {
if (debouncing_delay >= 0) return false;
return true;
}
bool matrix_is_on(uint8_t row, uint8_t col) {
return matrix_get_row(row) & (matrix_row_t)1 << col;
}
void matrix_print(void) {
dprintln("Human-readable matrix state:");
for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
dprintf("State of row %X: %016b\n", r, bitrev16(matrix_get_row(r)));
}
}
uint8_t matrix_key_count(void)
{
uint8_t matrix_key_count(void) {
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop16(matrix[i]);
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
count += bitpop16(matrix_get_row(r));
}
return count;
}
static void init_cols(void)
{
int B = 0, C = 0, D = 0, E = 0, F = 0;
#if DIODE_DIRECTION == COL2ROW
for(int x = 0; x < MATRIX_COLS; x++) {
int col = COLS[x];
#else
for(int x = 0; x < MATRIX_ROWS; x++) {
int col = ROWS[x];
#endif
if ((col & 0xF0) == 0x20) {
B |= (1<<(col & 0x0F));
} else if ((col & 0xF0) == 0x30) {
C |= (1<<(col & 0x0F));
} else if ((col & 0xF0) == 0x40) {
D |= (1<<(col & 0x0F));
} else if ((col & 0xF0) == 0x50) {
E |= (1<<(col & 0x0F));
} else if ((col & 0xF0) == 0x60) {
F |= (1<<(col & 0x0F));
}
}
DDRB &= ~(B); PORTB |= (B);
DDRC &= ~(C); PORTC |= (C);
DDRD &= ~(D); PORTD |= (D);
DDRE &= ~(E); PORTE |= (E);
DDRF &= ~(F); PORTF |= (F);
}
static matrix_row_t read_cols(void)
{
matrix_row_t result = 0;
#if DIODE_DIRECTION == COL2ROW
for(int x = 0; x < MATRIX_COLS; x++) {
int col = COLS[x];
#else
for(int x = 0; x < MATRIX_ROWS; x++) {
int col = ROWS[x];
#endif
if ((col & 0xF0) == 0x20) {
result |= (PINB&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x));
} else if ((col & 0xF0) == 0x30) {
result |= (PINC&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x));
} else if ((col & 0xF0) == 0x40) {
result |= (PIND&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x));
} else if ((col & 0xF0) == 0x50) {
result |= (PINE&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x));
} else if ((col & 0xF0) == 0x60) {
result |= (PINF&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x));
}
}
return result;
}
static void unselect_rows(void)
{
int B = 0, C = 0, D = 0, E = 0, F = 0;
#if DIODE_DIRECTION == COL2ROW
for(int x = 0; x < MATRIX_ROWS; x++) {
int row = ROWS[x];
#else
for(int x = 0; x < MATRIX_COLS; x++) {
int row = COLS[x];
#endif
if ((row & 0xF0) == 0x20) {
B |= (1<<(row & 0x0F));
} else if ((row & 0xF0) == 0x30) {
C |= (1<<(row & 0x0F));
} else if ((row & 0xF0) == 0x40) {
D |= (1<<(row & 0x0F));
} else if ((row & 0xF0) == 0x50) {
E |= (1<<(row & 0x0F));
} else if ((row & 0xF0) == 0x60) {
F |= (1<<(row & 0x0F));
}
}
DDRB &= ~(B); PORTB |= (B);
DDRC &= ~(C); PORTC |= (C);
DDRD &= ~(D); PORTD |= (D);
DDRE &= ~(E); PORTE |= (E);
DDRF &= ~(F); PORTF |= (F);
}
static void select_row(uint8_t row)
{
#if DIODE_DIRECTION == COL2ROW
int row_pin = ROWS[row];
#else
int row_pin = COLS[row];
#endif
if ((row_pin & 0xF0) == 0x20) {
DDRB |= (1<<(row_pin & 0x0F));
PORTB &= ~(1<<(row_pin & 0x0F));
} else if ((row_pin & 0xF0) == 0x30) {
DDRC |= (1<<(row_pin & 0x0F));
PORTC &= ~(1<<(row_pin & 0x0F));
} else if ((row_pin & 0xF0) == 0x40) {
DDRD |= (1<<(row_pin & 0x0F));
PORTD &= ~(1<<(row_pin & 0x0F));
} else if ((row_pin & 0xF0) == 0x50) {
DDRE |= (1<<(row_pin & 0x0F));
PORTE &= ~(1<<(row_pin & 0x0F));
} else if ((row_pin & 0xF0) == 0x60) {
DDRF |= (1<<(row_pin & 0x0F));
PORTF &= ~(1<<(row_pin & 0x0F));
}
}

69
quantum/quantum.c
View File

@ -23,17 +23,16 @@ int offset = 7;
#ifdef AUDIO_ENABLE
bool music_activated = false;
float music_scale[][2] = SONG(MUSIC_SCALE_SOUND);
// music sequencer
static bool music_sequence_recording = false;
static bool music_sequence_playing = false;
static float music_sequence[16] = {0};
static uint8_t music_sequence_count = 0;
static uint8_t music_sequence_position = 0;
// music sequencer
static bool music_sequence_recording = false;
static bool music_sequence_playing = false;
static float music_sequence[16] = {0};
static uint8_t music_sequence_count = 0;
static uint8_t music_sequence_position = 0;
static uint16_t music_sequence_timer = 0;
static uint16_t music_sequence_interval = 100;
static uint16_t music_sequence_timer = 0;
static uint16_t music_sequence_interval = 100;
#endif
@ -133,7 +132,7 @@ bool process_record_quantum(keyrecord_t *record) {
#ifdef MIDI_ENABLE
if (keycode == MI_ON && record->event.pressed) {
midi_activated = true;
play_music_scale();
music_scale_user();
return false;
}
@ -230,37 +229,37 @@ bool process_record_quantum(keyrecord_t *record) {
}
if (keycode == MU_ON && record->event.pressed) {
music_on();
return false;
music_on();
return false;
}
if (keycode == MU_OFF && record->event.pressed) {
music_off();
return false;
music_off();
return false;
}
if (keycode == MU_TOG && record->event.pressed) {
if (music_activated)
{
music_off();
music_off();
}
else
{
music_on();
music_on();
}
return false;
}
if (keycode == MUV_IN && record->event.pressed) {
voice_iterate();
play_music_scale();
return false;
voice_iterate();
music_scale_user();
return false;
}
if (keycode == MUV_DE && record->event.pressed) {
voice_deiterate();
play_music_scale();
return false;
voice_deiterate();
music_scale_user();
return false;
}
if (music_activated) {
@ -272,12 +271,14 @@ bool process_record_quantum(keyrecord_t *record) {
music_sequence_count = 0;
return false;
}
if (keycode == KC_LALT && record->event.pressed) { // Stop recording/playing
stop_all_notes();
music_sequence_recording = false;
music_sequence_playing = false;
return false;
}
if (keycode == KC_LGUI && record->event.pressed) { // Start playing
stop_all_notes();
music_sequence_recording = false;
@ -289,12 +290,13 @@ bool process_record_quantum(keyrecord_t *record) {
if (keycode == KC_UP) {
if (record->event.pressed)
music_sequence_interval-=10;
music_sequence_interval-=10;
return false;
}
if (keycode == KC_DOWN) {
if (record->event.pressed)
music_sequence_interval+=10;
music_sequence_interval+=10;
return false;
}
@ -459,5 +461,24 @@ void matrix_scan_quantum() {
}
#endif
//------------------------------------------------------------------------------
// Override these functions in your keymap file to play different tunes on
// different events such as startup and bootloader jump
__attribute__ ((weak))
void startup_user() {}
__attribute__ ((weak))
void shutdown_user() {}
__attribute__ ((weak))
void music_on_user() {}
__attribute__ ((weak))
void audio_on_user() {}
__attribute__ ((weak))
void music_scale_user() {}
//------------------------------------------------------------------------------

4
quantum/quantum.h
View File

@ -67,6 +67,10 @@ void music_toggle(void);
void music_on(void);
void music_off(void);
void startup_user(void);
void shutdown_user(void);
void audio_on_user(void);
void music_on_user(void);
void music_scale_user(void);
#endif

7
quantum/template/config.h
View File

@ -42,14 +42,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
* ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
*
*/
#define COLS (int []){ F1, F0, B0 }
#define ROWS (int []){ D0, D5 }
#define MATRIX_ROW_PINS { D0, D5 }
#define MATRIX_COL_PINS { F1, F0, B0 }
#define UNUSED_PINS
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
#define DEBOUNCE 5
#define DEBOUNCING_DELAY 5
/* define if matrix has ghost (lacks anti-ghosting diodes) */
//#define MATRIX_HAS_GHOST

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

@ -114,9 +114,7 @@ bool suspend_wakeup_condition(void)
matrix_power_up();
matrix_scan();
matrix_power_down();
for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
if (matrix_get_row(r)) return true;
}
if (matrix_key_count()) return true;
return false;
}
@ -146,4 +144,3 @@ ISR(WDT_vect)
}
}
#endif

14
tmk_core/common/bootmagic.c
View File

@ -105,15 +105,13 @@ void bootmagic(void)
}
}
static bool scan_keycode(uint8_t keycode)
{
for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
static bool scan_keycode(uint8_t keycode) {
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
matrix_row_t matrix_row = matrix_get_row(r);
for (uint8_t c = 0; c < MATRIX_COLS; c++) {
if (matrix_row & ((matrix_row_t)1<<c)) {
if (keycode == keymap_key_to_keycode(0, (keypos_t){ .row = r, .col = c })) {
return true;
}
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
if (matrix_row & (matrix_row_t)1 << c) {
keypos_t key = (keypos_t){ .row = r, .col = c };
if (keycode == keymap_key_to_keycode(0, key)) return true;
}
}
}

13
tmk_core/common/command.c
View File

@ -33,20 +33,21 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "led.h"
#include "command.h"
#include "backlight.h"
#include "quantum.h"
#ifdef MOUSEKEY_ENABLE
#include "mousekey.h"
#endif
#ifdef PROTOCOL_PJRC
# include "usb_keyboard.h"
# ifdef EXTRAKEY_ENABLE
# include "usb_extra.h"
# endif
#include "usb_keyboard.h"
#ifdef EXTRAKEY_ENABLE
#include "usb_extra.h"
#endif
#endif
#ifdef PROTOCOL_VUSB
# include "usbdrv.h"
#include "usbdrv.h"
#endif
#ifdef AUDIO_ENABLE
@ -358,7 +359,7 @@ static bool command_common(uint8_t code)
print("\n\nJumping to bootloader... ");
#ifdef AUDIO_ENABLE
stop_all_notes();
play_goodbye_tone();
shutdown_user();
#else
_delay_ms(1000);
#endif

140
tmk_core/common/keyboard.c
View File

@ -1,5 +1,5 @@
/*
Copyright 2011,2012,2013 Jun Wako <wakojun@gmail.com>
Copyright 2011, 2012, 2013 Jun Wako <wakojun@gmail.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -27,13 +27,13 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "command.h"
#include "util.h"
#include "sendchar.h"
#ifdef BOOTMAGIC_ENABLE
#include "bootmagic.h"
#else
#include "magic.h"
#endif
#include "eeconfig.h"
#include "backlight.h"
#ifdef BOOTMAGIC_ENABLE
# include "bootmagic.h"
#else
# include "magic.h"
#endif
#ifdef MOUSEKEY_ENABLE
# include "mousekey.h"
#endif
@ -41,40 +41,35 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
# include "ps2_mouse.h"
#endif
#ifdef SERIAL_MOUSE_ENABLE
#include "serial_mouse.h"
# include "serial_mouse.h"
#endif
#ifdef ADB_MOUSE_ENABLE
#include "adb.h"
# include "adb.h"
#endif
#ifdef MATRIX_HAS_GHOST
static bool has_ghost_in_row(uint8_t row)
{
matrix_row_t matrix_row = matrix_get_row(row);
// No ghost exists when less than 2 keys are down on the row
if (((matrix_row - 1) & matrix_row) == 0)
return false;
// Ghost occurs when the row shares column line with other row
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
if (i != row && (matrix_get_row(i) & matrix_row))
return true;
static bool is_row_ghosting(uint8_t row){
matrix_row_t state = matrix_get_row(row);
/* no ghosting happens when only one key in the row is pressed */
if (!(state - 1 & state)) return false;
/* ghosting occurs when two keys in the same column are pressed */
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
if (r != row && matrix_get_row(r) & state) return true;
}
return false;
}
#endif
__attribute__ ((weak))
void matrix_setup(void) {
}
__attribute__ ((weak)) void matrix_setup(void) {}
void keyboard_setup(void)
{
void keyboard_setup(void) {
matrix_setup();
}
void keyboard_init(void)
{
void keyboard_init(void) {
timer_init();
matrix_init();
#ifdef PS2_MOUSE_ENABLE
@ -86,104 +81,85 @@ void keyboard_init(void)
#ifdef ADB_MOUSE_ENABLE
adb_mouse_init();
#endif
#ifdef BOOTMAGIC_ENABLE
bootmagic();
#else
magic();
#endif
#ifdef BACKLIGHT_ENABLE
backlight_init();
#endif
#if defined(NKRO_ENABLE) && defined(FORCE_NKRO)
keyboard_nkro = true;
#endif
}
/*
* Do keyboard routine jobs: scan mantrix, light LEDs, ...
* This is repeatedly called as fast as possible.
*/
void keyboard_task(void)
{
static matrix_row_t matrix_prev[MATRIX_ROWS];
#ifdef MATRIX_HAS_GHOST
static matrix_row_t matrix_ghost[MATRIX_ROWS];
#endif
static uint8_t led_status = 0;
matrix_row_t matrix_row = 0;
matrix_row_t matrix_change = 0;
/* does routine keyboard jobs */
void keyboard_task(void) {
static uint8_t led_status;
matrix_scan();
for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
matrix_row = matrix_get_row(r);
matrix_change = matrix_row ^ matrix_prev[r];
if (matrix_change) {
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
static matrix_row_t previous_matrix[MATRIX_ROWS];
matrix_row_t state = matrix_get_row(r);
matrix_row_t changes = state ^ previous_matrix[r];
if (changes) {
#ifdef MATRIX_HAS_GHOST
if (has_ghost_in_row(r)) {
/* Keep track of whether ghosted status has changed for
* debugging. But don't update matrix_prev until un-ghosted, or
* the last key would be lost.
static matrix_row_t deghosting_matrix[MATRIX_ROWS];
if (is_row_ghosting(r)) {
/* debugs the deghosting mechanism */
/* doesn't update previous_matrix until the ghosting has stopped
* in order to prevent the last key from being lost
*/
if (debug_matrix && matrix_ghost[r] != matrix_row) {
if (debug_matrix && deghosting_matrix[r] != state) {
matrix_print();
}
matrix_ghost[r] = matrix_row;
deghosting_matrix[r] = state;
continue;
}
matrix_ghost[r] = matrix_row;
deghosting_matrix[r] = state;
#endif
if (debug_matrix) matrix_print();
for (uint8_t c = 0; c < MATRIX_COLS; c++) {
if (matrix_change & ((matrix_row_t)1<<c)) {
action_exec((keyevent_t){
.key = (keypos_t){ .row = r, .col = c },
.pressed = (matrix_row & ((matrix_row_t)1<<c)),
.time = (timer_read() | 1) /* time should not be 0 */
});
// record a processed key
matrix_prev[r] ^= ((matrix_row_t)1<<c);
// process a key per task call
goto MATRIX_LOOP_END;
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
matrix_row_t mask = (matrix_row_t)1 << c;
if (changes & mask) {
keyevent_t event;
event.key = (keypos_t){ .row = r, .col = c };
event.pressed = state & mask;
/* the time should not be 0 */
event.time = timer_read() | 1;
action_exec(event);
/* records the processed key event */
previous_matrix[r] ^= mask;
/* processes one key event per call */
goto event_processed;
}
}
}
}
// call with pseudo tick event when no real key event.
/* sends tick events when the keyboard is idle */
action_exec(TICK);
MATRIX_LOOP_END:
event_processed:
#ifdef MOUSEKEY_ENABLE
// mousekey repeat & acceleration
/* repeats and accelerates the mouse keys */
mousekey_task();
#endif
#ifdef PS2_MOUSE_ENABLE
ps2_mouse_task();
#endif
#ifdef SERIAL_MOUSE_ENABLE
serial_mouse_task();
serial_mouse_task();
#endif
#ifdef ADB_MOUSE_ENABLE
adb_mouse_task();
adb_mouse_task();
#endif
// update LED
/* updates the LEDs */
if (led_status != host_keyboard_leds()) {
led_status = host_keyboard_leds();
keyboard_set_leds(led_status);
}
}
void keyboard_set_leds(uint8_t leds)
{
if (debug_keyboard) { debug("keyboard_set_led: "); debug_hex8(leds); debug("\n"); }
void keyboard_set_leds(uint8_t leds) {
if (debug_keyboard) dprintf("Keyboard LEDs state: %x\n", leds);
led_set(leds);
}

61
tmk_core/common/matrix.h
View File

@ -14,59 +14,68 @@ 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 MATRIX_H
#define MATRIX_H
#include <stdint.h>
#include <stdbool.h>
#if (MATRIX_COLS <= 8)
typedef uint8_t matrix_row_t;
#elif (MATRIX_COLS <= 16)
typedef uint16_t matrix_row_t;
#elif (MATRIX_COLS <= 32)
typedef uint32_t matrix_row_t;
#if MATRIX_COLS <= 8
typedef uint8_t matrix_row_t;
#elif MATRIX_COLS <= 16
typedef uint16_t matrix_row_t;
#elif MATRIX_COLS <= 32
typedef uint32_t matrix_row_t;
#else
#error "MATRIX_COLS: invalid value"
# error "There are too many columns."
#endif
#define MATRIX_IS_ON(row, col) (matrix_get_row(row) && (1<<col))
#if DIODE_DIRECTION == ROW2COL
# if MATRIX_ROWS <= 8
typedef uint8_t matrix_col_t;
# elif MATRIX_ROWS <= 16
typedef uint16_t matrix_col_t;
# elif MATRIX_ROWS <= 32
typedef uint32_t matrix_col_t;
# else
# error "There are too many rows."
# endif
#endif
typedef struct {
uint8_t input_addr:4;
uint8_t bit:4;
} io_pin_t;
#ifdef __cplusplus
extern "C" {
#endif
/* number of matrix rows */
/* counts the number of rows in the matrix */
uint8_t matrix_rows(void);
/* number of matrix columns */
/* counts the number of columns in the matrix */
uint8_t matrix_cols(void);
/* should be called at early stage of startup before matrix_init.(optional) */
/* sets up the matrix before matrix_init */
void matrix_setup(void);
/* intialize matrix for scaning. */
/* intializes the matrix */
void matrix_init(void);
/* scan all key states on matrix */
/* scans the entire matrix */
uint8_t matrix_scan(void);
/* whether modified from previous scan. used after matrix_scan. */
/* checks if the matrix has been modified */
bool matrix_is_modified(void) __attribute__ ((deprecated));
/* whether a swtich is on */
/* checks if a key is pressed */
bool matrix_is_on(uint8_t row, uint8_t col);
/* matrix state on row */
/* inspects the state of a row in the matrix */
matrix_row_t matrix_get_row(uint8_t row);
/* print matrix for debug */
/* prints the matrix for debugging */
void matrix_print(void);
/* power control */
/* counts the total number of keys pressed */
uint8_t matrix_key_count(void);
/* controls power to the matrix */
void matrix_power_up(void);
void matrix_power_down(void);
/* keyboard-specific setup/loop functionality */
/* executes code for Quantum */
void matrix_init_quantum(void);
void matrix_scan_quantum(void);
#ifdef __cplusplus
}
#endif

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

@ -947,10 +947,10 @@ void fallthrough_callback(MidiDevice * device,
if (cnt == 3) {
switch (byte0 & 0xF0) {
case MIDI_NOTEON:
play_note(((double)261.6)*pow(2.0, -1.0)*pow(2.0,(byte1 & 0x7F)/12.0), (byte2 & 0x7F) / 8);
play_note(((double)261.6)*pow(2.0, -4.0)*pow(2.0,(byte1 & 0x7F)/12.0), (byte2 & 0x7F) / 8);
break;
case MIDI_NOTEOFF:
stop_note(((double)261.6)*pow(2.0, -1.0)*pow(2.0,(byte1 & 0x7F)/12.0));
stop_note(((double)261.6)*pow(2.0, -4.0)*pow(2.0,(byte1 & 0x7F)/12.0));
break;
}
}

8
tmk_core/rules.mk
View File

@ -366,7 +366,13 @@ ALL_ASFLAGS = -mmcu=$(MCU) -x assembler-with-cpp $(ASFLAGS) $(EXTRAFLAGS)
# Default target.
all: begin gccversion sizebefore build sizeafter end
all:
$(MAKE) begin
$(MAKE) gccversion
$(MAKE) sizebefore
$(MAKE) build
$(MAKE) sizeafter
$(MAKE) end
# Change the build target to build a HEX file or a library.
build: elf hex eep lss sym